diff --git a/Wohnung 3D Komplett.html b/Wohnung 3D Komplett.html
index f20ad4f..68e39e8 100644
--- a/Wohnung 3D Komplett.html	
+++ b/Wohnung 3D Komplett.html	
@@ -5,11 +5,11 @@
 </head><body>
 <script>
 (function(){
-  var D = "<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <title>Wohnung – 3D Miniatur</title>
  <style>
    * { margin: 0; padding: 0; box-sizing: border-box; }
    body { background: #1b1b19; display: flex; align-items: center; justify-content: center; min-height: 100vh; font-family: -apple-system, BlinkMacSystemFont, sans-serif; }
    #__bundler_loading { position: fixed; bottom: 20px; right: 20px; font: 13px/1.4 -apple-system, BlinkMacSystemFont, sans-serif; color: #666; background: #fff; padding: 8px 14px; border-radius: 8px; box-shadow: 0 1px 4px rgba(0,0,0,0.12); z-index: 10000; }
    #__bundler_thumbnail { position: fixed; inset: 0; width: 100%; height: 100%; display: flex; align-items: center; justify-content: center; background: #1b1b19; z-index: 9999; }
    #__bundler_thumbnail svg { width: 100%; height: 100%; object-fit: contain; }
    #__bundler_placeholder { color: #999; font-size: 14px; }
  </style>
  <noscript>
    <style>#__bundler_loading { display: none; }</style>
    <div style="position:fixed;bottom:12px;left:12px;font:13px/1.4 -apple-system,BlinkMacSystemFont,sans-serif;color:#999;background:rgba(255,255,255,0.9);padding:6px 12px;border-radius:6px;box-shadow:0 1px 4px rgba(0,0,0,0.08);z-index:10000;">
      This page requires JavaScript to display.
    </div>
  </noscript>
</head>
<body>
  <div id="__bundler_thumbnail"><svg viewBox="0 0 120 120" xmlns="http://www.w3.org/2000/svg"><rect width="120" height="120" fill="#1b1b19"></rect><rect x="46" y="26" width="28" height="68" rx="10" fill="none" stroke="#e9e6de" stroke-width="4"></rect><circle cx="60" cy="42" r="5" fill="#e5484d"></circle><circle cx="60" cy="62" r="7" fill="none" stroke="#e9e6de" stroke-width="4"></circle></svg></div>
  <div id="__bundler_loading">Unpacking...</div>

  <script>
    
document.addEventListener('DOMContentLoaded', async function() {
  const loading = document.getElementById('__bundler_loading');
  function setStatus(msg) { if (loading) loading.textContent = msg; }

  const FONT_MIME = /^(font[/]|application[/](x-)?font-|application[/]vnd\.ms-fontobject)/i;
  const MIME_TOKEN = /^[\w.+-]+[/][\w.+-]+$/;
  function toBase64(bytes) {
    let bin = '';
    for (let i = 0; i < bytes.length; i += 0x8000) {
      bin += String.fromCharCode.apply(null, bytes.subarray(i, i + 0x8000));
    }
    return btoa(bin);
  }

  // Error sink persists across replaceWith since it's on window, not the DOM.
  window.addEventListener('error', function(e) {
    // Failed resource loads (CSP-blocked links, scripts, images) fire plain
    // events at the element — warn only; real JS errors carry message/error.
    if (!e.message && !e.error && e.target && e.target !== window) {
      console.warn('[bundle] resource failed to load:',
        e.target.tagName, String(e.target.src || e.target.href || ''));
      return;
    }
    var p = document.body || document.documentElement;
    var d = document.getElementById('__bundler_err') || p.appendChild(document.createElement('div'));
    d.id = '__bundler_err';
    d.style.cssText = 'position:fixed;bottom:12px;left:12px;right:12px;font:12px/1.4 ui-monospace,monospace;background:#2a1215;color:#ff8a80;padding:10px 14px;border-radius:8px;border:1px solid #5c2b2e;z-index:99999;white-space:pre-wrap;max-height:40vh;overflow:auto';
    d.textContent = (d.textContent ? d.textContent + String.fromCharCode(10) : '') +
      '[bundle] ' + (e.message || e.type) +
      (e.filename ? ' (' + e.filename.slice(0, 60) + ':' + e.lineno + ')' : '');
  }, true);

  try {
    const manifestEl = document.querySelector('script[type="__bundler/manifest"]');
    const templateEl = document.querySelector('script[type="__bundler/template"]');
    if (!manifestEl || !templateEl) {
      setStatus('Error: missing bundle data');
      console.error('[bundler] Missing script tags — manifestEl:', !!manifestEl, 'templateEl:', !!templateEl);
      return;
    }

    const manifest = JSON.parse(manifestEl.textContent);
    let template = JSON.parse(templateEl.textContent);

    // Nested page bundles (iframe targets). Each ships ONCE, in the ROOT
    // document's manifest; frame srcs carry an about:blank#<uuid> marker
    // instead of a substitutable uuid. Every document mints the blobs for
    // its OWN frames — from local text at the root, or text obtained from
    // its DIRECT parent over the relay protocol below — so each frame
    // navigation stays same-origin with its initiator and a deduped page
    // loads at any depth on any host, including a file:// download's
    // opaque origins (where a blob minted by one document cannot be
    // navigated to by another).
    const pageOrderEl = document.querySelector('script[type="__bundler/page_order"]');
    const pageOrder = pageOrderEl ? JSON.parse(pageOrderEl.textContent) : [];
    const pageSet = new Set(pageOrder);
    const pageTexts = {};

    // ── Nested-page text protocol (parent-chain relay) ──
    // Page bundles ship once, in the ROOT document's manifest. Every
    // document mints the blobs for its OWN frames, obtaining page text
    // through a strict parent-chain relay: a document only ever SENDS to
    // its direct parent (which, for every document the publisher's own
    // runtime minted, is another publisher document) and only ACCEPTS
    // text from that direct parent; requests from below are honored only
    // for the document's own child frames, and the ROOT never sends
    // upward at all. That last rule is load-bearing: the artifact host's
    // frame-ancestors allows claude.ai (and friends) to frame an
    // artifact, so window.top can be a FOREIGN document — a top-addressed
    // protocol would hand page uuids to that ancestor and accept forged
    // "page text" from it, minting attacker HTML as an artifact-origin
    // blob document. The chain never touches the ancestor: requests stop
    // at the root, replies are origin-addressed per hop (never '*' when
    // an origin exists), and both directions are origin-gated (on https
    // a foreign sender's origin can never equal this document's; in
    // opaque contexts — file:// — everything serializes as 'null', where
    // an embedded EXTERNAL frame still fails the gate by carrying its
    // own real origin, and a sandboxed child of such a frame is excluded
    // by the own-child-frames check plus uuid unguessability). Shape is
    // deny-by-default: one request form, one reply form, no error
    // replies.
    // window.origin is the SERIALIZED SECURITY origin ('null' in opaque
    // contexts such as a sandboxed preview iframe) — location.origin is
    // computed from the URL and stays 'https://…' even when the document
    // is sandboxed, which would misgate every opaque chain.
    const OWN_TARGET = /^https?:[/][/]/.test(window.origin || '')
      ? window.origin
      : '*';
    function trustedOrigin(e) {
      if (e.origin === window.origin) return true; // https chains; opaque==opaque
      // file:// trees: Chrome serializes the file document's origin as
      // 'file://' while the blob: documents it mints serialize as 'null',
      // so the two legitimate shapes can never string-match — accept the
      // pair in both directions. https origins never serialize as either,
      // and sender identity (own child frame / direct parent) is checked
      // separately.
      return (
        (e.origin === 'null' &&
          (window.origin === 'file://' ||
            window.location.protocol === 'file:')) ||
        (/^file:/.test(e.origin) && window.origin === 'null')
      );
    }
    // Non-empty only in the root document (nested bundles ship an empty
    // island), so it doubles as the root marker: the root answers from
    // local text and treats a miss as authoritative — never relaying to
    // its (possibly foreign) parent.
    const isPageRoot = pageOrder.length > 0;
    const blobUrls = {};
    const resourceBlobs = {};
    const UUID_SHAPE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
    const pendingFrames = {}; // uuid -> [{el, frag}] awaiting text for own frames
    const pendingRelays = {}; // uuid -> [childWindow] awaiting text to pass down
    function mountPage(el, frag, text) {
      const pageBlob = new Blob([text], { type: 'text/html' });
      const u = URL.createObjectURL(pageBlob);
      resourceBlobs[u] = pageBlob;
      el.src = u + frag;
    }
    function deliverPage(uuid, text) {
      const frames = pendingFrames[uuid];
      delete pendingFrames[uuid];
      if (frames) for (const f of frames) mountPage(f.el, f.frag, text);
      const relays = pendingRelays[uuid];
      delete pendingRelays[uuid];
      if (relays) {
        for (const cw of relays) {
          try { cw.postMessage({ __bundler_page: uuid, __bundler_text: text }, OWN_TARGET); } catch (err) { /* gone */ }
        }
      }
    }
    function ownFrameWindows() {
      const out = [];
      for (const f of Array.from(document.querySelectorAll('iframe'))) {
        try { if (f.contentWindow) out.push(f.contentWindow); } catch (err) { /* detached */ }
      }
      return out;
    }
    window.addEventListener('message', function (e) {
      const d = e.data;
      if (!d || typeof d !== 'object' || !e.source) return;
      // Origin gate first; the structural checks below (own-child-frames
      // for requests, direct-parent + solicited-uuid for replies, the
      // root's never-relay rule) are what hold in fully opaque chains
      // where origin strings can't discriminate — a sandboxed root's
      // FOREIGN wrapper still fails all three even though both serialize
      // as real-vs-'null' rather than matching.
      if (!trustedOrigin(e)) return;
      if (typeof d.__bundler_need === 'string' && UUID_SHAPE.test(d.__bundler_need)) {
        // Requests are honored only for this document's own child frames.
        if (ownFrameWindows().indexOf(e.source) < 0) return;
        const uuid = d.__bundler_need;
        const text = pageTexts[uuid];
        if (typeof text === 'string') {
          try { e.source.postMessage({ __bundler_page: uuid, __bundler_text: text }, OWN_TARGET); } catch (err) { /* gone */ }
          return;
        }
        if (isPageRoot || window.parent === window) return; // authoritative miss
        const waiting = pendingRelays[uuid];
        if (waiting) {
          if (waiting.indexOf(e.source) < 0) waiting.push(e.source);
          return;
        }
        // Never-answered uuids would otherwise accumulate forever under a
        // request spray; past the cap (far above any real page count) new
        // relays are dropped rather than remembered.
        if (Object.keys(pendingRelays).length >= 128) return;
        pendingRelays[uuid] = [e.source];
        window.parent.postMessage({ __bundler_need: uuid }, OWN_TARGET);
      } else if (
        typeof d.__bundler_page === 'string' &&
        UUID_SHAPE.test(d.__bundler_page) &&
        typeof d.__bundler_text === 'string'
      ) {
        // The shape test is load-bearing beyond tidiness: the solicited
        // check below uses the in operator, which matches prototype keys
        // ('__proto__', 'constructor') — an unshaped key would reach
        // deliverPage and throw, painting the error banner.
        // Text is accepted only from the direct parent — the document
        // that minted this one.
        if (e.source !== window.parent || window.parent === window) return;
        if (!(d.__bundler_page in pendingFrames) && !(d.__bundler_page in pendingRelays)) return;
        deliverPage(d.__bundler_page, d.__bundler_text);
      }
    });

    const uuids = Object.keys(manifest);
    setStatus('Unpacking ' + uuids.length + ' assets...');

    await Promise.all(uuids.map(async (uuid) => {
      const entry = manifest[uuid];
      try {
        const binaryStr = atob(entry.data);
        const bytes = new Uint8Array(binaryStr.length);
        for (let i = 0; i < binaryStr.length; i++) bytes[i] = binaryStr.charCodeAt(i);

        let finalBytes = bytes;
        if (entry.compressed) {
          if (typeof DecompressionStream !== 'undefined') {
            const ds = new DecompressionStream('gzip');
            const writer = ds.writable.getWriter();
            const reader = ds.readable.getReader();
            writer.write(bytes);
            writer.close();
            const chunks = [];
            let totalLen = 0;
            while (true) {
              const { done, value } = await reader.read();
              if (done) break;
              chunks.push(value);
              totalLen += value.length;
            }
            finalBytes = new Uint8Array(totalLen);
            let offset = 0;
            for (const chunk of chunks) { finalBytes.set(chunk, offset); offset += chunk.length; }
          } else {
            console.warn('DecompressionStream not available, asset ' + uuid + ' may not render');
          }
        }

        if (pageSet.has(uuid)) {
          pageTexts[uuid] = new TextDecoder().decode(finalBytes);
          return;
        }
        if (FONT_MIME.test(entry.mime) && MIME_TOKEN.test(entry.mime)) {
          // Strict artifact hosts allow font-src data: but not blob:.
          blobUrls[uuid] = 'data:' + entry.mime + ';base64,' +
            (entry.compressed ? toBase64(finalBytes) : entry.data);
        } else {
          const blob = new Blob([finalBytes], { type: entry.mime });
          blobUrls[uuid] = URL.createObjectURL(blob);
          resourceBlobs[blobUrls[uuid]] = blob;
        }
      } catch (err) {
        console.error('Failed to decode asset ' + uuid + ':', err);
        const blob = new Blob([], { type: entry.mime });
        blobUrls[uuid] = URL.createObjectURL(blob);
        resourceBlobs[blobUrls[uuid]] = blob;
      }
    }));

    const extResEl = document.querySelector('script[type="__bundler/ext_resources"]');
    const extResources = extResEl ? JSON.parse(extResEl.textContent) : [];
    const resourceMap = {};
    for (const entry of extResources) {
      if (blobUrls[entry.uuid]) resourceMap[entry.id] = blobUrls[entry.uuid];
    }

    // Artifact-host CSP (connect-src 'self') refuses fetch() of blob: URLs —
    // consumers read these Blobs directly. Survives the swap like the error sink.
    window.__resourceBlobs = resourceBlobs;

    setStatus('Rendering...');
    // Page uuids have no blob here — they ride inside about:blank#<uuid>
    // frame markers the pass below resolves after the swap.
    for (const uuid of uuids) {
      if (pageSet.has(uuid)) continue;
      template = template.split(uuid).join(blobUrls[uuid]);
    }

    // Strip integrity + crossorigin — blob URLs from a file:// document inherit
    // a null origin, so crossorigin forces a CORS fetch that SRI then rejects.
    // The manifest bytes are ours; SRI protects against CDN compromise, not this.
    template = template.replace(/\s+integrity="[^"]*"/gi, '').replace(/\s+crossorigin="[^"]*"/gi, '');

    const resourceScript = '<script>window.__resources = ' +
      JSON.stringify(resourceMap).replace(/<\//g, '<\\/') +
      ';</' + 'script>';
    // Inject after <head> so the DOCTYPE stays first; prepending the script
    // would push the parser into quirks mode. DOMParser always emits a <head>
    // (synthesizing one if the source HTML omitted it) but may carry
    // attributes through, so match the full opening tag. slice() rather than
    // replace() keeps us clear of $-pattern substitution in resourceScript.
    const headOpen = template.match(/<head[^>]*>/i);
    if (headOpen) {
      const i = headOpen.index + headOpen[0].length;
      template = template.slice(0, i) + resourceScript + template.slice(i);
    }

    // Parse the template and swap the root element. Scripts inserted via
    // DOMParser/replaceWith are inert per spec — re-create each with
    // createElement so they execute, awaiting onload for src scripts to
    // preserve ordering (React before ReactDOM before Babel before text/babel).
    const doc = new DOMParser().parseFromString(template, 'text/html');
    document.documentElement.replaceWith(doc.documentElement);

    // Resolve page-frame markers: mint this document's own blob for each
    // framed page — from local text when this is the root, otherwise by
    // asking the direct parent over the relay protocol above. An
    // unanswered request leaves the frame on about:blank, the same
    // degraded state as a refused embed.
    {
      const MARKER = /^about:blank#([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(#.*)?$/;
      const needed = [];
      for (const el of Array.from(document.querySelectorAll('iframe'))) {
        const m = MARKER.exec(el.getAttribute('src') || '');
        if (!m) continue;
        const text = pageTexts[m[1]];
        if (typeof text === 'string') {
          mountPage(el, m[2] || '', text);
        } else if (window.parent !== window && !isPageRoot) {
          const had = pendingFrames[m[1]];
          (pendingFrames[m[1]] = had || []).push({ el: el, frag: m[2] || '' });
          if (!had) needed.push(m[1]);
        }
      }
      for (const uuid of needed) {
        window.parent.postMessage({ __bundler_need: uuid }, OWN_TARGET);
      }
    }

    const dead = Array.from(document.scripts);
    for (const old of dead) {
      const s = document.createElement('script');
      for (const a of old.attributes) s.setAttribute(a.name, a.value);
      s.textContent = old.textContent;
      // text/babel scripts with a src: read and inline. transformScriptTags
      // does XHR against the src, but blob:null/ from a file:// origin is
      // silently dropped. Inlining makes it a plain inline babel script,
      // which transformScriptTags handles unconditionally.
      if ((s.type === 'text/babel' || s.type === 'text/jsx') && s.src) {
        const pre = resourceBlobs[s.src.split('#')[0]];
        s.textContent = pre ? await pre.text() : await (await fetch(s.src)).text();
        s.removeAttribute('src');
      }
      const p = s.src ? new Promise(function(r) { s.onload = s.onerror = r; }) : null;
      old.replaceWith(s);
      if (p) await p;
    }
    // Babel standalone auto-transforms type=text/babel on DOMContentLoaded,
    // which fired before we swapped the document. Trigger manually if present.
    if (window.Babel && typeof window.Babel.transformScriptTags === 'function') {
      window.Babel.transformScriptTags();
    }
  } catch (err) {
    setStatus('Error unpacking: ' + err.message);
    console.error('Bundle unpack error:', err);
  }
});

  </script>

  <script type="__bundler/manifest">
{"6f3432d0-1bde-4e2e-bd8f-dba82a254a95":{"mime":"text/javascript","compressed":true,"data":"H4sIAAAAAAAAE7U7a3IbN5P/fYqOUrscWuSQkiXHpqLksx5+ypYj2Y6TfFkHM9MkYc0AYwAjinFclTvsnuG7wv7fo+QkWw1gnqRsJ5tNVSwSaDS6G0C/ORrBPxI9ZMkcFYoYh3wmpEIYDkFmmKIxCNowZVCBjtl0KtMEAsUWgClmKIwezfFqlF9BtIQENZ+J/o3RCA5lzjFZwRHCGQ5VIQQXM4hlvnzjJ97EMsulQGFgwc0czJxruOAiAXmJaqG4Qe0GpzzFEgYhZQa1gUtUmksBQc5mCLEUhjBxDYVg0ynGBpN+eGN0Ew6OHzx6Bi/P7z04hpujG6ObN2/ATfjazBXiMBlqw2b4Dfzx+3/BrSOQ0VuMDVxyXKCCTcCrXDpJzDFNIbCrwre6H94Ai+fF3HI6Q5ALoS2Bi7lMEXSMAifwPUYPTkChSFChGoDAwiiWgjZFwiWkfDY3XMwIleWQgZZTAzMlC5GAnrNELgYgVcSNZVLJVEOQKDYDI934ABZzxJS+/yplNiBcivAOS7Ccif4AGMQsQ8WAFUYOp4plmNAs0ez47mmIaF89AIWa/4qEas5EknIxGwATCTBI5EKkktFSmUZMgZkz4wXlBBAXStFheGEyTWhODx7DJjx9cQJSwYOTAwgiLphawix9cb8fwv2D1xAzIaSBCEu5J8CFRRkpudCo9ggTLeZuJy4MqnjOxAxhKlVGhFyiWkImE1SCTpSoBJ5Z6spDK08RiA/CpGQxc7eLblNP+wWQsTyERyJOiwTdXTx+fe/wBeRcCEwIVcZyovHrObLkmwFEOKW3xIQloUgRVCG0vV3+wmorRiJ8prhZwpzpOVoJacOWYOQMzRwVBJplaNETWRvV3dwAfcHTFDImEnoJ/YlnCuBrHSueGzDLHPc3HAsZyze+cdPv3R8AP6U3JvUYwIaVysYENubG5HoyGhUiv5iFscxGduof43Drzk44HkUFTxM3Fjouw7d6Y9BFNWJJIoUeldd2dEq39dB/oyWfsRdesSxPUY/e6uwjmK7dvHzAenR68PjYf/kre1+L6DO2fnDy4v7fs3cXU7n3h0F9uOXV6hzvXzvVCWzoObt1Z2d45/7hj1v46vQ2NzubeYTxNjsy4oVavP3+9Y8nj88ON5/ee3D46PnRTP8gXqp0dDy+t/1Dev8Ol0+fPBo9bgnqzxATS9UhJVlsS/kcF+z4kbo3S2/L+0cHWXbw/eHxXfn93ZOrswfxdPHjeH5yeZyrX+X2eHvxOv3q8vCHh2fpuTh98adI+cwbWFO3o37lz65OD3588t3tu3xzsTm9c/fJ493dF4c/vCsW8fxVdLD8bpGxU3x0+jo5fbn9/ORI3Lo4nb5+uHj0+PDuX6fuY5fdEyeihZE/Hj97fHTr1bvNe4dPxofFg++S50+Lo+8fXrDscPvJ46OvxsevdsV0dvvtd2+nef7kFNn4qx8eP9t8duvvIG7Nc/DUvZLTi8v8we2Hx2fz+4c/RPrl6UN89vrg8N2jo20xfXfx3Tvx6tfjrbfxSD6Pf91893jr1r2j5PXD8Z358Wb8Xf0e3Af/5+uR04zfeFX5UrMZTkqlaZYpftNyByZCmmCS4JQLTPrvL7nmEU+5WU7mPElQfPh65FZ5FK3FIFiG+xtKxhdoNr75etT2NNqqWqt4f6MFQAL5pknwimJ3j7PU6kBugTbeCdmHRMYFeWnhuwLV8hxTjI1UQa+1Sa+/1179Hl48PDs+hg+wD2zBuMcXKmTJsgNLtjWFfRC4cKvCB0oWeVDjHI3gj9//Zd+wtV5uhSwMyKkVTwIZktlzPo8fYQYVZ6m1lg1MhIAgNEQYywydvwIjKDRmJgUURnHUpadQeQ6nB4//+P1fJSLHjkZzaq1oYEkqKe7ej3vGKB4VBrW/JLS/v/Rkyt0ezi+NmEY7HSQ4ZUVqYMPi3ui7pRGLL7w3R0sPz88hlqlUEOGcnF2i2fqKNQIGC6YyyFmOCowU6FGR36akYQYtqsUcBeQKNQpD3p1O5QJMoYRhUYpQCMNTi77QqJyrxGKjPY9P7ZlwAQpZOlxIldKh0PscQIwETM68k6lUfMbFAJbDIm8IwHotXMxRcVPz0SMXnBvn50jFURhmuBRhw1ee8jTVQEByISCSV/YgyOME7sMBqRLnH5LEKtFsjceXixH9O7euGsxRycoZP/JQGk2RT67ztSGYY8Z1TvEPbMIFLmHTUkQ+sqVjjQdOzDw7BRSXXElBD8z6ZiQMLWHOZ3OSHksFak0+HeER0sxpPyNB4TS1vrBIfDCgQSBTwyhl8UUIhyxvrGd2b0IxDm/98ft/jsMduzJmSi2BOUhIpbwog4bIOvyo7HV0F8zJO7ZRGaGyt5VrWMpC6Qmw5G2h3bFZwehBI9po3lou4E0kpQnsLbSXro4YQCAmmqICPp2i9fqJLDoQCrXg+NlRHXrdCII+7H9DXkmltJYpKQI0sA+/3KD3NZlL0kc33GvLpeZ0eSagMGWGX+Ken0m4zlO2nECUyviiHF3wxMwndE3+rRyaI7Fnxy7n5WDN3wQumQqGTi8Oo9kAvpyOEfF2v4SlcHSaysUEnPZ34x/svzETl0zD+y45pOxSTgGgkAL3PHRYhkyr7LFIy7QwFXvKE307v6polsbIrD1WbTtNsRqcsXwCd2qgqRRmOGUZT5cTGLI8T3Gol9pgNoCDlIuLpyw+t9/vS1IlG+c4kwgvH20M4ExG0sgBaCb0UKPi0yb7FUNRYYwUFV8sz5EpJuJSABULKkE1ga38CrRMeQJqFrFgezwA+n/r7gDId+i34YeKJbzQLZ6aB+hw7O4OoP5nHN7drtDY9zCBL7fY1t2t3bVi8WqsNUf6aAJb2+FuR5YLf6V2x+NynA57WF21cjRnScLFbAJ38yvY2q7RxIXSRJLXax+R6WRO9w/etzj+cjqdrlwqD89ieibwHoxiQlNUPHEfKXHyQ7CVX/WvWfpTwjWZjuRneA8yZzF5PDAOd/cgl9Z+DPGSEkCdWy2kwc+40ilOP+NGZ+xq6F/x7foRk9gnsDMeWymOtsLdv+siX3c7Pn3B7uz2V855h8553OSwdYEbfJJRHmrrnjXfiBcpqs9RElxoNBMYr2iD5ptjKZ+JITeY6Ym37OUUWQA+XQ599qw7XXG1vdN+APbmw9aOPYnbf/9J3GHb0+2KK4NXZmi56BK4mHODQ50z0jO5wiG9wlqOv+zduAEwLURM4qsSV0GUymhg7SE5bn0vaGeRCkWu7cuzkzBWyAw6d/Hl2Yld5Q/cgbKmt+2gj12GNOixngdl4VzhFPYJcTlSZdD2KyLcVIUtkskyJCUqksM5T5OAVejilMcXQfVVYSYvsfyu0bzgGcrCeFNLjCi8lBcNRgpFns7OeDy2qz6QkEY3b8ILynCSabcWmInSzWXGYJZbr8qk6NxYY3PBRi1BinTpXA1aRlTcBAgevnh68somUfuU+OJTji5jp2WhYvR+0JDCCzuuySfENNGkEVFofonp0iPzObVYkkcrZnuVX4Up+TpKau2R25ymS2EytQzhQcFUgglo6VHVZMdMgKBcIUQK2YVdXp1Lzsw8JI+lcXuEpKfiwtbA5RoHIC/K20M4ywe74CKRizBn5A+FudTmKWoKOQMPAKSdlzlOoFemyycO//BWMnRi7w18RnMC9W4TkBewv78PRhVokz7+v97Nnv/sb8IHiJmJ5xDQ/f5QHnOcMq3hBYWCR+fWE8crgyLRQAfmb2/zPajCRo/9ijdd5KiChmWll6CkJAeOEqQhM4bF83PrSgbvbehHbOYoevChs866fx95RXa+Vy2yX0NSB4c+3b/f8CArz0lK03o7FqRCYol8Q/r1+n0TftlbXRBa6T2jK7YPPVSqd+2W1ZoOw9ZSfua+BNvekkZ6rem2LHpHzbIA/M9/g46VTKvKAI2sFAauZ4J26Eih9Bf+lOj8ojYvfrDXBpXR2wMjPoLeOSrdHdyykJ4U4fZA62E6EiuffFWeWL+MJckxuT4nXBsUqIKe1cO9ATg964BVIbyC6Mnoba/fIXOWRn+FO7fs49yVMNdw9+DkYP2CP83XLI1W+CoPePUFOOl9Nrgjqv+JZ+XXd7BqNAdWMvpYWCc2mLJU1xeYLNwZaplelmmnOuclRYyNRAzXkJILTYauk8QqFe5Ncr7gl5VU2S+UDSjtk2KxN0wpjxTlMugwvGGpKLfrfDrtuZIZ1xgEylFKdTgy21XY3OTYLvQswT74JXvroWywvu/RlTClPra2weooYQunhyxNyf9t6H0+BS9+ygVg0m+QMxpRjdcpfkyATSkRwcC6Jiy1YlSoi4xKo8yQl1rtBNrIPMckrJDVG5VF0+ZWNVdujjJ69wTPbIbpRMrcr02lzPt7q8sk/Pu/V59DGWlUl2jXNKA/VJ8UUj6tElfrwjk5gLPFeytTQT+0FjgIyAysOz8yKc6keb+dnizF8b3uGRJk62k3GOtVxcwp46mr6Npr9k/Rg80m4OEc4wtXrbWVTlvDvL5oCFMlM58/JE+hg42sg6anUlU/1xQ/He7wn6JLzLlRXMxINHQgxF/mXCT4tvVtAk0juuZOB835zn1meiniMnlVid9Z4mhWOiwzNFW+N+jVYV+thulKRrO+A3cnptE8VzJHZZZBr04e9QYQzTo2/yerZQZV9f6pTH6usuz+wYcsTYOf6jeQOWVrj7bXH6yf+GR9tV75c0dZOsW37xRgpSFHLpusLvFIsQUXs4OCknpwgZh7Pca08V42nYHNM9vnXqOwXR0UsFKi1cgjZtjLsxMYQaLY4lHGZti3GoFTt4HVBym6voEah44VotBzaWz5XkPMclOolo4W2iBLqKDAIEqZuPC5uLAl/FJPtMoVtifjzM8E9bNkwnCWcqYn9k3XYmdpPmfdwbWyagPV/m5TXz3nV5iekcYKnlKgkXER+JAhwUseYw0Av/0GWwPY7q9BZD3spywP0dm7jiZaA+g9CCeE54f3z+XUnJez7QvSkFv5sQXgkJ6RgaYkhDIH9u0H1a6JzLxbM6iVWH/vRtv/t0fZPJpzGgm6pt2D2b8dFL6lpYnjOSqdo82CHdrZYGd3QGIch+OtAaUu6hdq58Myw0KnE9wawHa4PYCdDhXVTu5Dl46yN8dR0njsYetZBm71ANZIqqk43Bt2R3vEspyeU/uAK6DETd9nFKrBPrF5p0N6TVz5sSJ/NIJnrTrJxNU/9MVy5CsAC6bntsBkD30YM21fNxVObOlgUKPyLUI8swUVZ0J8oUtL0Dydy4LCXe2D75kEVwEpQzw6YvJKg/o8H1bVmhPaLRhfTe1/AxhfJXeS7XhnAFvhuN/Ru0Re81occYU2lGdpF892WOeKL3DZvg87A/hqALstABKBezmdQ6FJJ6YwY/k5/9WaimB7vHOHUtw7d/prICPO6GiG43A8Hm+3j85xcYHLvRUJXeCyw7KV+ad53sHb9Bhqlmhdm+nh7gBuDWBYP4J6X1sq61x/f1Oaez9FPa8THo3nmTKBD1DaPEywPba5/3HDyDW0gVdOrjActJLSW3fgQ7+d8wBPRmiLpMTKFYnVKtnnj2AE2104jJFf4tqT9BFJyZf7sCoMN16Lwy1rVGq9lzFnuuFl1PO91UdPk2etxQ18H4E+z9Faga1wexVqJc6zXZhVnFcbwfVk2Fiq6WZ17h3FFmswaQOLkok4pVLw95Tat2ZtrwM4bwM+tLWUDmTTjNLjChYDmDfcQ6/PmdX/sA8LGMF8ZbrIqXPuuZJv3eN4yoziV7XV+VC/C9O1RUr6S35mGyRPXQShgik3HUgKQdZLxcnXURH013DnPgT2lg081avUjUZwhD7mWsypuluFAgumYYompjD0WzinxkKepC6ibXlaKyFfGanZ6+GdPmLEFvM9syBFjYEyGEREqcGr+I3rwxJ5fzV2vTb4+lOR3Yf2s2tGxEEV3reDgmb0uSbOHY3g3Mjck0FmruacvjlBJ17ue6sCbEqGJEkttZRNDihFXrlV3GhMpxQ+XWBu7LkwoEy+TU24VpYaU5kvgqxwSURQWCcmnDLqd+XfiJ8/FTOLwmr0FQSyXx9XLbegLVBKrJzP5QICK6mF6Df6A6j7O09tHoTCwlzhJZeF9rMDcA6OdlvfBO9iaGo88Y28SL6HQm2oX6RsSPFqOSdT4nozbFBS47FtyM5hM9I2mrjG5ir5UncCOVK68WEZITXipaaAvrAjfds6vLD64FiplTariT8rSvDYI+6mi2DKlTa9NbIvqWp4wGWtpwWwkq10is99KCf9WRjFqAkZg0B2lBLtK0OuyWa30y3yel/HTX/MhtYpk27mP5JXLWfhQF7dCvp0M+8rmbVPpiX3SF6FXB9nuVkG/ZUklG9o8WJoXxZ6WNSClkn7kG3zke1rCju6yTsHlT9EDhhtm3ERLrtWy7cROYgZmgNay8Xs3I43vFg/0O93MSRctzM6gcMZuqIxjMA6MIaJIGhGIuFUXlIfl/Nu+jCCW7fH/T7chK3w1u7qLu0Y+JVtC7wV2LCI6tlb4fZuPxRUakrJsq4kXTqxUoPgkH7WUVLtKrT95jT5SQlXYVakhufp8jxmKVMBMd6/bhtqjoJ9x13GriwwjKiJx8Vx162buuoEQd8k6GvAPuUCdCOn0DA1Q7OO02uXrBr48sowKgK0T/km3OoiakQInmrqoCCPljB8GtqWeuxGnwNtrLfyebCub+PzKfmkw7Ua7ttLs1bHrSb6SeW0bdIMDbwpOzMb1t3lc72ObSf+CLLXJ3+zZzP9vX6onOkKRj/9xz8X4fDnzdFsAL03vfZeawiSot6yVUYqG2xgH76Qos2Xr8isA2lY2uPKKlqzVzbNVn14heDvCtcwS3VjkCPfJkutEb61FpyNtNEiF2SPKI839Q6MHvjqvBWVzf86nNVeKdemMqRvaKvn5Cyu5FgzZiiu/ennTtUXUXhddI4NBztFYxl7RDmM1iAzrbGmrfuEUfuitmrtXH417VpA3F9KwOdMmTc92HSk1OCOss391cAltQoc7inFliHX9m8gw1JcffgW6m8wgZ/qbz/XuOiwAi83ymoS1rYptgRndENJsCF3P0vSQdbv26iCi7ZtdvBhs8elYqZiN2OeW2Ye7bVhSOptfpulEfCucEDHSeFt4Le6di//YZOe0F/b0W5FisFv1YSzMskLPQ+yNaWcZibW3msCX3lcpwI7TS/kevp+cv9LOdscM5cLm77iZVdMmXa+CXCG1inUlPBitihDmWv6cZcG+0uCFCvPpECXOtT0i0G8YrFJl/b3ctBsfXHtNUIOvV+DTKXLkhGurZPJRNWnExDqslLPa2SVZqk7w11jvv0VXN+/evczPl/CrF65L6XUhWDXk9KuD37Rdl3bD67ZIAPeE/ZYbEeLrZjDt2Wy2O5yGr0N+jBpjT1Io5YTtbYvp2ERmq0wqlVLXLuyXTQG7+CjUm1b1a4wNan9bIFUP6aoikFrqzvX/aan1/GovbJ1OzZ0csfvpvbwEqo0kG0QGb1tuKO9zKQpj6j65xZvQi/MTGoLelaHZ5TirkkL+tT4pK8JU6w6N5Sk7H0Jx+VPNaIltOKmf9btDV21SGz2V5JMsVUv7ncVv/0G70FRivDOAGb+b2T/1rmTunOJfvi5b6ufhD20A7YJ315KUWQRKrqXzSnXFNtB5XOTTWTVUBdVOTFp6jqSyyYB4oI+Wh1ZqcyGSErIhvLrPUksfByq0Mj7/AqTYKdP6/zwbP1w1Bleswv0nmgYh9vj8bj9Zy3sM20xW7fdhlFBsAVDJ2YKTSjTe+1GjgcvmxXKGktKrV51dNI9PEhlFPwko7c/D+r2Oqqaj/KUcdt9NqivsO3P2bseT2bSz8KTmbTjD7Z0gtVW/486ofNTum7r0P9FD0TFtKKifOfN7cqHfo/4bb32QeN9uh95X1cWrQRfK+XqBKJi2jwBa6pGs9RMhw6nPYh6n/JAqEHJj1bnUnY/FtpUxTYdut/3dX8ZN2i2R/b3bnzok+z+F/7XKWg1QQAA"}}
  </script>

  <script type="__bundler/ext_resources">
[]
  </script>

  <script type="__bundler/page_order">
[]
  </script>

  <script type="__bundler/template">
"<!DOCTYPE html>\n<html lang=\"de\"><head>\n<meta charset=\"utf-8\">\n<title>Wohnung – 3D Miniatur<\u002Ftitle>\n<script type=\"importmap\">\n{\n  \"imports\": {\n    \"three\": \"https://unpkg.com/three@0.184.0/build/three.module.js\",\n    \"three/addons/controls/OrbitControls.js\": \"https://unpkg.com/three@0.184.0/examples/jsm/controls/OrbitControls.js\",\n    \"three/addons/exporters/OBJExporter.js\": \"https://unpkg.com/three@0.184.0/examples/jsm/exporters/OBJExporter.js\",\n    \"three/addons/exporters/GLTFExporter.js\": \"https://unpkg.com/three@0.184.0/examples/jsm/exporters/GLTFExporter.js\",\n    \"three/examples/jsm/\": \"https://unpkg.com/three@0.184.0/examples/jsm/\",\n    \"three/addons/\": \"https://unpkg.com/three@0.184.0/examples/jsm/\",\n    \"three-mesh-bvh\": \"https://cdn.jsdelivr.net/npm/three-mesh-bvh@0.9.5/build/index.module.js\",\n    \"three-gpu-pathtracer\": \"https://cdn.jsdelivr.net/npm/three-gpu-pathtracer@0.0.24/build/index.module.js\",\n    \"n8ao\": \"https://cdn.jsdelivr.net/npm/n8ao@1/dist/N8AO.js\",\n    \"postprocessing\": \"https://cdn.jsdelivr.net/npm/postprocessing@6/build/index.js\"\n  },\n  \"integrity\": {\n    \"https://unpkg.com/three@0.184.0/build/three.module.js\": \"sha384-8FCZ1eVO6it4+pbec2aDtnTrwjWXZLJRC+MAGCIPDgsYnUrl/E0A2YlF8ioMKI/J\",\n    \"https://unpkg.com/three@0.184.0/build/three.core.js\": \"sha384-dw2ooPewaEIrAgl6oFDBmmBWCE9oW9LxRGcfwZ0hLvEprzo202wXl7vCYHRlSnOT\",\n    \"https://unpkg.com/three@0.184.0/examples/jsm/controls/OrbitControls.js\": \"sha384-4rziNxOBZKQ69i+w+f89KJ55TCYquwchVbByQwmaOeIOXdOU2PLDn3kOfXHwIJC9\",\n    \"https://unpkg.com/three@0.184.0/examples/jsm/exporters/OBJExporter.js\": \"sha384-nbwtoZENJD3Vq+ACK0CuGQdPMuDWHkamC2KJD70EV5nfg6jQjfppKOea07YJN+N3\",\n    \"https://unpkg.com/three@0.184.0/examples/jsm/exporters/GLTFExporter.js\": \"sha384-VofkvpG6HERhFCYbsUOHeNXBCqID2nfqkQqnVzE1jc/oPcz+qJ13ADdXH08hE+cQ\"\n  }\n}\n<\u002Fscript>\n<style>\n  html,body{margin:0;height:100%;background:#efece6;font-family:Helvetica,Arial,sans-serif}\n  three-d-stage:not(:defined){visibility:hidden}\n  #rooms{position:fixed;left:50%;bottom:22px;transform:translateX(-50%);display:flex;gap:6px;padding:6px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);border-radius:999px;box-shadow:0 6px 24px rgba(30,28,24,.14)}\n  #rooms button{appearance:none;border:0;background:transparent;color:#2f2d2a;font:500 14px/1 Helvetica,Arial,sans-serif;padding:11px 18px;border-radius:999px;cursor:pointer;transition:background .2s,color .2s}\n  #rooms button:hover{background:rgba(47,45,42,.08)}\n  #rooms button.on{background:#2f2d2a;color:#f7f5f0}\n  #pov{position:fixed;left:50%;top:18px;transform:translate(-50%,-8px);opacity:0;pointer-events:none;transition:opacity .3s,transform .3s;display:flex;gap:4px;padding:4px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);border-radius:999px;box-shadow:0 1px 2px rgba(0,0,0,.06),0 6px 20px rgba(0,0,0,.08)}\n  #pov.show{opacity:1;pointer-events:auto;transform:translate(-50%,0)}\n  #pov button{appearance:none;border:0;background:transparent;color:#2f2d2a;font:500 13px/1 Helvetica,Arial,sans-serif;padding:9px 14px;border-radius:999px;cursor:pointer;transition:background .2s,color .2s}\n  #pov button:hover{background:rgba(47,45,42,.08)}\n  #pov button.on{background:#2f2d2a;color:#f7f5f0}\n  #lamp{position:fixed;left:50%;bottom:82px;transform:translate(-50%,10px);opacity:0;pointer-events:none;transition:opacity .35s,transform .35s;display:flex;align-items:center;gap:4px;padding:4px;border-radius:999px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);color:#2f2d2a;font:500 14px/1 Helvetica,Arial,sans-serif;box-shadow:0 4px 18px rgba(0,0,0,.08)}\n  #lampT{display:flex;align-items:center;gap:10px;appearance:none;border:0;background:transparent;color:inherit;font:inherit;padding:7px 14px 7px 10px;border-radius:999px;cursor:pointer;white-space:nowrap}\n  #lampT:hover{background:rgba(47,45,42,.08)}\n  #lampCtl{display:flex;align-items:center;gap:14px;max-width:0;overflow:hidden;opacity:0;transition:max-width .4s,opacity .3s,padding .4s;padding:0}\n  #lamp.on #lampCtl{max-width:420px;opacity:1;padding:0 12px 0 6px}\n  #lampSw{display:flex;gap:6px}\n  #lampSw button{appearance:none;width:22px;height:22px;border-radius:50%;border:2px solid rgba(250,248,244,.9);box-shadow:0 0 0 1px rgba(47,45,42,.18);cursor:pointer;padding:0}\n  #lampSw button.sel{box-shadow:0 0 0 2px #2f2d2a}\n  #lampSw{align-items:center;gap:8px;font-size:12px;color:#6b665e}\n  #lampSw input[type=color]{appearance:none;-webkit-appearance:none;width:26px;height:26px;border-radius:50%;border:2px solid rgba(250,248,244,.9);box-shadow:0 0 0 1px rgba(47,45,42,.25);padding:0;cursor:pointer;background:none}\n  #lampSw input[type=color]::-webkit-color-swatch-wrapper{padding:0}\n  #lampSw input[type=color]::-webkit-color-swatch{border:0;border-radius:50%}\n  #lampSw input[type=color]::-moz-color-swatch{border:0;border-radius:50%}\n  #lampDim{display:flex;align-items:center;gap:8px;font-size:12px;color:#6b665e}\n  #lampDim input{width:110px;accent-color:#2f2d2a}\n  #lampDim output{width:34px;text-align:right;font-variant-numeric:tabular-nums}\n  #lamp.show{opacity:1;transform:translate(-50%,0);pointer-events:auto}\n  #lamp i{width:12px;height:12px;border-radius:50%;background:#bdb8ae;transition:background .3s,box-shadow .3s}\n  #pt{position:fixed;top:18px;right:18px;padding:8px 12px;border-radius:999px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);color:#2f2d2a;font:500 12px/1 ui-monospace,Menlo,monospace;opacity:0;transition:opacity .3s;pointer-events:none}\n  #pt.show{opacity:1}\n  #pt{top:62px !important}\n  #rt{position:fixed;top:18px;right:18px;display:flex;align-items:center;gap:8px;appearance:none;border:0;padding:9px 14px 9px 11px;border-radius:999px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);color:#2f2d2a;font:500 13px/1 Helvetica,Arial,sans-serif;cursor:pointer;box-shadow:0 1px 2px rgba(0,0,0,.06),0 6px 20px rgba(0,0,0,.08);transition:background .2s,color .2s}\n  #rt i{width:10px;height:10px;border-radius:50%;background:#bdb8ae;transition:background .2s}\n  #rt.on{background:#2f2d2a;color:#f7f5f0}\n  #rt.on i{background:#7fd08a}\n  #lamp.on i{background:#ffc86b;box-shadow:0 0 10px 3px rgba(255,190,90,.6)}\n  #lampD{display:flex;align-items:center;gap:10px;appearance:none;border:0;background:transparent;color:inherit;font:inherit;padding:7px 14px 7px 10px;border-radius:999px;cursor:pointer;white-space:nowrap}\n  #lampD:hover{background:rgba(47,45,42,.08)}\n  #tvB{display:flex;align-items:center;gap:8px;appearance:none;border:0;background:transparent;color:inherit;font:inherit;padding:7px 14px 7px 10px;border-radius:999px;cursor:pointer;white-space:nowrap}\n  #tvB:hover{background:rgba(255,255,255,.1)}\n  #tvB svg{flex:none;transition:color .3s}\n  #tvBar{position:fixed;left:50%;bottom:22px;transform:translate(-50%,10px);opacity:0;pointer-events:none;transition:opacity .4s,transform .4s;display:flex;gap:4px;padding:4px;border-radius:999px;background:rgba(20,20,18,.55);backdrop-filter:blur(12px);-webkit-backdrop-filter:blur(12px);z-index:60}\n  #tvBar.show{opacity:1;transform:translate(-50%,0);pointer-events:auto}\n  #tvUI{position:fixed;inset:0;z-index:55;opacity:0;pointer-events:none;transition:opacity .5s;font-family:Helvetica,Arial,sans-serif;color:#f2f1ec;background:#0b0c0e;overflow:hidden}\n  #tvUI.show{opacity:1;pointer-events:auto}\n  #tvUI .tv-hero{--a:#e5484d;position:absolute;inset:0;display:flex;flex-direction:column;justify-content:flex-end;gap:6px;padding:0 clamp(20px,6vw,80px) clamp(150px,22vh,220px);background:radial-gradient(120% 90% at 85% 20%,color-mix(in oklch,var(--a) 55%,transparent),transparent 60%),linear-gradient(180deg,#0b0c0e 0%,#121316 100%);transition:background .5s}\n  #tvUI .tv-hero small{font-size:clamp(12px,1.4vw,15px);letter-spacing:.08em;text-transform:uppercase;color:#bdbab2}\n  #tvUI .tv-hero h2{margin:0;font-weight:700;font-size:clamp(40px,8vw,110px);line-height:1;letter-spacing:-.02em;text-wrap:balance}\n  #tvUI .tv-nav{position:absolute;left:0;right:0;top:clamp(14px,3vh,28px);display:flex;gap:8px;padding:6px clamp(20px,6vw,80px);overflow-x:auto;scrollbar-width:none;-webkit-overflow-scrolling:touch}\n  #tvUI .tv-nav::-webkit-scrollbar{display:none}\n  #tvUI .tv-nav button{flex:none;appearance:none;border:0;background:rgba(255,255,255,.08);color:#f2f1ec;font:500 clamp(14px,1.5vw,17px)/1 Helvetica,Arial,sans-serif;padding:13px 20px;border-radius:999px;cursor:pointer;transition:background .2s,color .2s,transform .2s;min-height:44px}\n  #tvUI .tv-nav button:hover{background:rgba(255,255,255,.16)}\n  #tvUI .tv-nav button.on{background:#f2f1ec;color:#111214;transform:scale(1.04)}\n  #tvUI .tv-vol{position:absolute;right:clamp(12px,2.5vw,32px);top:50%;transform:translateY(-50%);display:flex;flex-direction:column;align-items:center;gap:10px;padding:10px 8px;border-radius:999px;background:rgba(255,255,255,.08);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px)}\n  #tvUI .tv-vb{appearance:none;border:0;width:44px;height:44px;border-radius:50%;background:transparent;color:#f2f1ec;font:400 22px/1 Helvetica,Arial,sans-serif;cursor:pointer}\n  #tvUI .tv-vb:hover{background:rgba(255,255,255,.12)}\n  #tvUI .tv-vol input{--v:35%;-webkit-appearance:none;appearance:none;writing-mode:vertical-lr;direction:rtl;width:6px;height:clamp(120px,28vh,220px);border-radius:3px;background:linear-gradient(to top,#f2f1ec var(--v),rgba(255,255,255,.2) var(--v));cursor:pointer;margin:0}\n  #tvUI .tv-vol input::-webkit-slider-thumb{-webkit-appearance:none;width:18px;height:18px;border-radius:50%;background:#f2f1ec;box-shadow:0 1px 4px rgba(0,0,0,.4)}\n  #tvUI .tv-vol input::-moz-range-thumb{width:18px;height:18px;border:0;border-radius:50%;background:#f2f1ec}\n  #tvUI .tv-vol output{font:500 12px/1 Helvetica,Arial,sans-serif;color:#bdbab2;font-variant-numeric:tabular-nums;padding-bottom:4px}\n  @media (max-width:600px){#tvUI .tv-nav button{padding:12px 16px}#tvUI .tv-vol{right:10px;padding:6px 4px}#tvUI .tv-hero{padding-right:80px}}\n  #tvBar button{display:flex;align-items:center;gap:8px;appearance:none;border:0;background:transparent;color:#f2f1ec;font:500 13px/1 Helvetica,Arial,sans-serif;padding:9px 14px;border-radius:999px;cursor:pointer}\n  #tvBar button:hover{background:rgba(255,255,255,.12)}\n  body.tvfocus #rooms,body.tvfocus #pov,body.tvfocus #rt,body.tvfocus #pt,body.tvfocus #lamp,body.tvfocus #lamp2,body.tvfocus #mp{opacity:0 !important;pointer-events:none !important;transition:opacity .4s}\n  #tvB .pw{transition:fill .3s,stroke .3s}\n  #tvB.on .pw{fill:#e5484d;stroke:#e5484d}\n  #tvB.on svg{filter:drop-shadow(0 0 4px rgba(120,170,255,.7))}\n  #lampD b{width:12px;height:12px;border-radius:50%;background:#bdb8ae;transition:background .3s,box-shadow .3s}\n  #lampD.on b{background:#ff9a3c;box-shadow:0 0 10px 3px rgba(255,150,60,.6)}\n  #lamp2{position:fixed;left:50%;bottom:82px;transform:translate(-50%,10px);opacity:0;pointer-events:none;transition:opacity .35s,transform .35s;display:flex;align-items:center;gap:4px;padding:4px;border-radius:999px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);color:#2f2d2a;font:500 14px/1 Helvetica,Arial,sans-serif;box-shadow:0 4px 18px rgba(0,0,0,.08)}\n  #lamp2.show{opacity:1;transform:translate(-50%,0);pointer-events:auto}\n  #tripT{display:flex;align-items:center;gap:10px;appearance:none;border:0;background:transparent;color:inherit;font:inherit;padding:7px 14px 7px 10px;border-radius:999px;cursor:pointer;white-space:nowrap}\n  #tripT:hover{background:rgba(47,45,42,.08)}\n  #tripT i{width:12px;height:12px;border-radius:50%;background:#bdb8ae;transition:background .3s,box-shadow .3s}\n  #tripCtl{display:flex;align-items:center;gap:14px;max-width:0;overflow:hidden;opacity:0;transition:max-width .4s,opacity .3s,padding .4s;padding:0}\n  #lamp2.on #tripCtl{max-width:560px;opacity:1;padding:0 12px 0 6px}\n  #tripCtl label{display:flex;align-items:center;gap:8px;font-size:12px;color:#6b665e}\n  #tripCtl input[type=range]{width:100px;accent-color:#2f2d2a}\n  #tripCtl output{width:34px;text-align:right;font-variant-numeric:tabular-nums}\n  #tripCtl input[type=color]{appearance:none;-webkit-appearance:none;width:26px;height:26px;border-radius:50%;border:2px solid rgba(250,248,244,.9);box-shadow:0 0 0 1px rgba(47,45,42,.25);padding:0;cursor:pointer;background:none}\n  #tripCtl input[type=color]::-webkit-color-swatch-wrapper{padding:0}\n  #tripCtl input[type=color]::-webkit-color-swatch{border:0;border-radius:50%}\n  #tripCtl input[type=color]::-moz-color-swatch{border:0;border-radius:50%}\n  #rooms,#pov,#rt,#pt,#lamp,#lamp2,three-d-stage::part(toolbar){transition:opacity .6s}\n  body.idle #rooms,body.idle #pov,body.idle #rt,body.idle #pt,body.idle #lamp,body.idle #lamp2{opacity:0 !important;pointer-events:none}\n  body.idle{cursor:none}\n\n  /* muavin-Gradient für GUI-Leisten */\n  #rooms,#pov,#lamp,#lamp2,#pt,#rt,#mp{background-color:#000 !important;background-image:radial-gradient(circle at 65.34% 44.62%, rgba(95,95,95,1) 0%, rgba(95,95,95,.844) 8.53%, rgba(95,95,95,.5) 17.05%, rgba(95,95,95,.156) 25.58%, rgba(95,95,95,0) 34.1%),radial-gradient(circle at 28.07% 74.48%, rgba(53,54,48,1) 0%, rgba(53,54,48,.844) 11.41%, rgba(53,54,48,.5) 22.83%, rgba(53,54,48,.156) 34.24%, rgba(53,54,48,0) 45.65%),radial-gradient(circle at 52.42% 19.94%, rgba(56,122,56,1) 0%, rgba(56,122,56,.844) 14.39%, rgba(56,122,56,.5) 28.77%, rgba(56,122,56,.156) 43.16%, rgba(56,122,56,0) 57.55%),radial-gradient(circle at 80.31% 84.47%, rgba(0,0,0,1) 0%, rgba(0,0,0,.844) 17.27%, rgba(0,0,0,.5) 34.55%, rgba(0,0,0,.156) 51.82%, rgba(0,0,0,0) 69.1%) !important;background-size:100% 100% !important;color:#f2f1ec !important;box-shadow:0 6px 24px rgba(0,0,0,.25),inset 0 0 0 1px rgba(255,255,255,.08)}\n  #rooms button,#pov button{color:#f2f1ec}\n  #rooms button:hover,#pov button:hover,#lampT:hover,#lampD:hover,#tripT:hover{background:rgba(255,255,255,.1)}\n  #rooms button.on,#pov button.on,#rt.on{background:#f2f1ec !important;background-image:none !important;color:#141412 !important}\n  #lampSw,#lampDim,#tripCtl{color:#d9d7d0 !important}\n  #lampSw button.sel{box-shadow:0 0 0 2px #f2f1ec}\n  #lampDim input[type=range],#tripCtl input[type=range]{accent-color:#f2f1ec}\n  .lp-sw{appearance:none;width:26px;height:26px;border-radius:50%;border:2px solid rgba(250,248,244,.9);box-shadow:0 0 0 1px rgba(47,45,42,.25);padding:0;cursor:pointer;flex:none}\n  .lpick{position:fixed;z-index:50;width:236px;padding:14px;border-radius:18px;background:rgba(26,27,24,.38);backdrop-filter:blur(18px) saturate(1.2);-webkit-backdrop-filter:blur(18px) saturate(1.2);color:#f2f1ec;font:500 12px/1.2 Helvetica,Arial,sans-serif;box-shadow:0 10px 36px rgba(0,0,0,.35),inset 0 0 0 1px rgba(255,255,255,.08);display:none;flex-direction:column;gap:14px;transition:opacity .6s}\n  .lpick.open{display:flex}\n  body.lpfocus #rooms,body.lpfocus #pov,body.lpfocus #rt,body.lpfocus #pt,body.lpfocus #lamp,body.lpfocus #lamp2,body.lpfocus three-d-stage::part(toolbar){opacity:0 !important;pointer-events:none !important}\n  .lp-done{appearance:none;border:0;border-radius:999px;padding:9px 0;background:rgba(255,255,255,.1);color:#f2f1ec;font:inherit;cursor:pointer}\n  .lp-done:hover{background:rgba(255,255,255,.18)}\n  body.idle .lpick{opacity:0;pointer-events:none}\n  .lp-seg{display:grid;grid-template-columns:1fr 1fr;gap:3px;padding:3px;border-radius:999px;background:rgba(255,255,255,.08)}\n  .lp-seg button{appearance:none;border:0;border-radius:999px;padding:7px 0;background:transparent;color:#d9d7d0;font:inherit;cursor:pointer}\n  .lp-seg button.on{background:#f2f1ec;color:#141412}\n  .lp-row{display:flex;flex-direction:column;gap:7px}\n  .lp-row>div{display:flex;justify-content:space-between;color:#d9d7d0}\n  .lp-row output{font-variant-numeric:tabular-nums;color:#f2f1ec}\n  .lp-row small{display:flex;justify-content:space-between;color:#a9a69e;font-size:11px}\n  .lpick input[type=range]{width:100%;margin:0;accent-color:#f2f1ec}\n  .lpick input.lp-temp{appearance:none;-webkit-appearance:none;height:10px;border-radius:5px;outline:none}\n  .lp-temp::-webkit-slider-thumb{-webkit-appearance:none;width:18px;height:18px;border-radius:50%;background:#fff;border:2px solid #1a1b18;box-shadow:0 0 0 1px rgba(255,255,255,.6);cursor:pointer}\n  .lp-temp::-moz-range-thumb{width:14px;height:14px;border-radius:50%;background:#fff;border:2px solid #1a1b18;cursor:pointer}\n  .lp-wheel{position:relative;width:180px;height:180px;margin:0 auto;touch-action:none;cursor:pointer}\n  .lp-wheel canvas{width:180px;height:180px;border-radius:50%;display:block}\n  .lp-wheel i{position:absolute;width:18px;height:18px;margin:-9px 0 0 -9px;border-radius:50%;border:2px solid #fff;box-shadow:0 0 0 1px rgba(0,0,0,.4),0 2px 6px rgba(0,0,0,.4);pointer-events:none}\n\n  #mp{position:fixed;top:18px;left:18px;z-index:40;width:300px;box-sizing:border-box;padding:12px 14px 12px 12px;border-radius:20px;font:500 13px/1.2 Helvetica,Arial,sans-serif;display:flex;flex-direction:column;gap:10px;transition:opacity .6s}\n  #mp .mp-top{display:flex;align-items:center;gap:12px}\n  #mp .mp-disc{flex:none;width:40px;height:40px;border-radius:50%;background:radial-gradient(circle,#141412 0 5px,#f2f1ec 5px 7px,#2a2b27 7px 100%);box-shadow:inset 0 0 0 1px rgba(255,255,255,.12);animation:mpspin 4s linear infinite;animation-play-state:paused}\n  #mp.play .mp-disc{animation-play-state:running}\n  #mp .mp-meta{flex:1;min-width:0;display:flex;flex-direction:column;gap:3px}\n  #mp .mp-t{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;color:#f2f1ec}\n  #mp .mp-s{font-size:11px;color:#a9a69e;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}\n  #mp .mp-ctl{display:flex;align-items:center;gap:2px}\n  #mp button{appearance:none;border:0;background:transparent;color:#f2f1ec;cursor:pointer;width:32px;height:32px;border-radius:50%;display:grid;place-items:center;padding:0}\n  #mp button:hover{background:rgba(255,255,255,.1)}\n  #mp button:disabled{opacity:.35;cursor:default;background:transparent}\n  #mp button.mp-pp{background:#f2f1ec;color:#141412}\n  #mp button.mp-pp:hover{background:#fff}\n  #mp button.mp-pp:disabled{background:#f2f1ec}\n  #mp svg{width:14px;height:14px;fill:currentColor;display:block}\n  #mp .mp-bar{display:flex;align-items:center;gap:8px;font-size:11px;color:#a9a69e;font-variant-numeric:tabular-nums}\n  #mp input[type=range]{flex:1;margin:0;accent-color:#f2f1ec;height:14px}\n  #mp .mp-vol{width:64px;flex:none}\n  #mp .mp-add{width:auto;height:28px;padding:0 12px;border-radius:999px;background:rgba(255,255,255,.1);font:inherit;font-size:12px;white-space:nowrap}\n  #mp .mp-add:hover{background:rgba(255,255,255,.18)}\n  #mp.empty .mp-bar{display:none}\n  #mp.drag{box-shadow:0 0 0 2px #f2f1ec,0 6px 24px rgba(0,0,0,.25) !important}\n  body.idle #mp,body.lpfocus #mp{opacity:0 !important;pointer-events:none !important}\n  @keyframes mpspin{to{transform:rotate(360deg)}}\n<\u002Fstyle>\n<\u002Fhead>\n<body>\n\n<three-d-stage name=\"wohnung\" background=\"#efece6\"><\u002Fthree-d-stage>\n<div id=\"rooms\"><\u002Fdiv>\n<div id=\"pov\"><button data-m=\"bird\" class=\"on\">Vogelperspektive<\u002Fbutton><button data-m=\"fp\">Frei umsehen<\u002Fbutton><\u002Fdiv>\n<button id=\"rt\" aria-pressed=\"false\"><i><\u002Fi><span>Render aus<\u002Fspan><\u002Fbutton>\n<div id=\"pt\"><\u002Fdiv>\n<div id=\"mp\" class=\"empty\"><div class=\"mp-top\"><div class=\"mp-disc\"><\u002Fdiv><div class=\"mp-meta\"><div class=\"mp-t\">Keine Musik<\u002Fdiv><div class=\"mp-s\">Dateien hinzufügen oder hierher ziehen<\u002Fdiv><\u002Fdiv><div class=\"mp-ctl\"><button class=\"mp-prev\" title=\"Zurück\" disabled=\"\"><svg viewBox=\"0 0 16 16\"><rect x=\"2\" y=\"3\" width=\"2\" height=\"10\"><\u002Frect><polygon points=\"14,3 14,13 5,8\"><\u002Fpolygon><\u002Fsvg><\u002Fbutton><button class=\"mp-pp\" title=\"Abspielen\" disabled=\"\"><svg viewBox=\"0 0 16 16\"><polygon points=\"4,2 4,14 14,8\"><\u002Fpolygon><\u002Fsvg><\u002Fbutton><button class=\"mp-next\" title=\"Weiter\" disabled=\"\"><svg viewBox=\"0 0 16 16\"><rect x=\"12\" y=\"3\" width=\"2\" height=\"10\"><\u002Frect><polygon points=\"2,3 2,13 11,8\"><\u002Fpolygon><\u002Fsvg><\u002Fbutton><\u002Fdiv><\u002Fdiv><div class=\"mp-bar\"><span class=\"mp-cur\">0:00<\u002Fspan><input class=\"mp-seek\" type=\"range\" min=\"0\" max=\"1000\" value=\"0\"><span class=\"mp-dur\">0:00<\u002Fspan><\u002Fdiv><div class=\"mp-bar\"><button class=\"mp-add\">+ Musik<\u002Fbutton><span style=\"margin-left:auto\">Lautstärke<\u002Fspan><input class=\"mp-vol\" type=\"range\" min=\"0\" max=\"100\" value=\"80\"><\u002Fdiv><input class=\"mp-file\" type=\"file\" accept=\"audio/*,.mp3,.m4a,.aac,.wav,.flac,.ogg,.opus\" multiple=\"\" hidden=\"\"><button class=\"mp-add mp-add0\" style=\"align-self:flex-start\">+ Musik hinzufügen<\u002Fbutton><audio class=\"mp-a\" preload=\"metadata\"><\u002Faudio><\u002Fdiv>\n<div id=\"lamp\"><button id=\"lampT\"><i><\u002Fi><span>Bogenlampe an<\u002Fspan><\u002Fbutton><div id=\"lampCtl\"><div id=\"lampSw\"><\u002Fdiv><label id=\"lampDim\" style=\"display:none\"><span>Stärke<\u002Fspan><input type=\"range\" min=\"10\" max=\"200\" step=\"5\" value=\"100\"><output>100%<\u002Foutput><\u002Flabel><\u002Fdiv><button id=\"lampD\" aria-pressed=\"false\"><b><\u002Fb><span>Donut-Lampe an<\u002Fspan><\u002Fbutton><button id=\"tvB\" aria-pressed=\"false\" title=\"Fernseher an/aus\"><svg viewBox=\"0 0 24 24\" width=\"18\" height=\"18\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.6\"><rect x=\"7.5\" y=\"2.5\" width=\"9\" height=\"19\" rx=\"3\"><\u002Frect><circle cx=\"12\" cy=\"7\" r=\"1.6\" class=\"pw\"><\u002Fcircle><circle cx=\"12\" cy=\"12.5\" r=\"2.2\"><\u002Fcircle><circle cx=\"10.3\" cy=\"17.3\" r=\".6\" fill=\"currentColor\"><\u002Fcircle><circle cx=\"13.7\" cy=\"17.3\" r=\".6\" fill=\"currentColor\"><\u002Fcircle><\u002Fsvg><span>Fernseher an<\u002Fspan><\u002Fbutton><\u002Fdiv>\n<div id=\"tvUI\"><div class=\"tv-hero\"><small>Zuletzt geöffnet<\u002Fsmall><h2><\u002Fh2><\u002Fdiv><nav class=\"tv-nav\"><\u002Fnav><div class=\"tv-vol\"><button class=\"tv-vb\" data-d=\"5\" aria-label=\"Lauter\">+<\u002Fbutton><input type=\"range\" min=\"0\" max=\"100\" step=\"1\" aria-label=\"Lautstärke\"><button class=\"tv-vb\" data-d=\"-5\" aria-label=\"Leiser\">−<\u002Fbutton><output><\u002Foutput><\u002Fdiv><\u002Fdiv>\n<div id=\"tvBar\"><button id=\"tvBack\">Zurück<\u002Fbutton><button id=\"tvOff\"><svg viewBox=\"0 0 24 24\" width=\"18\" height=\"18\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.6\"><rect x=\"7.5\" y=\"2.5\" width=\"9\" height=\"19\" rx=\"3\"><\u002Frect><circle cx=\"12\" cy=\"7\" r=\"1.6\" fill=\"#e5484d\" stroke=\"#e5484d\"><\u002Fcircle><circle cx=\"12\" cy=\"12.5\" r=\"2.2\"><\u002Fcircle><circle cx=\"10.3\" cy=\"17.3\" r=\".6\" fill=\"currentColor\"><\u002Fcircle><circle cx=\"13.7\" cy=\"17.3\" r=\".6\" fill=\"currentColor\"><\u002Fcircle><\u002Fsvg><span>Ausschalten<\u002Fspan><\u002Fbutton><\u002Fdiv>\n<div id=\"lamp2\"><button id=\"tripT\"><i><\u002Fi><span>Tripod-Lampe an<\u002Fspan><\u002Fbutton><div id=\"tripCtl\"><label><button id=\"tripCol\" class=\"lp-sw\" title=\"Licht einstellen\"><\u002Fbutton><\u002Flabel><label style=\"display:none\"><span>Stärke<\u002Fspan><input id=\"tripDim\" type=\"range\" min=\"10\" max=\"200\" step=\"5\" value=\"100\"><output>100%<\u002Foutput><\u002Flabel><label><span>Kegel<\u002Fspan><input id=\"tripCone\" type=\"range\" min=\"15\" max=\"80\" step=\"1\" value=\"32\"><output>32°<\u002Foutput><\u002Flabel><\u002Fdiv><\u002Fdiv>\n<script>\n(function(){\nconst R=document.getElementById('mp'),$=s=>R.querySelector(s),A=$('.mp-a'),F=$('.mp-file');\nconst P=\"<svg viewBox=\\\"0 0 16 16\\\"><polygon points=\\\"4,2 4,14 14,8\\\"/><\u002Fsvg>\",Z=\"<svg viewBox=\\\"0 0 16 16\\\"><rect x=\\\"3\\\" y=\\\"2\\\" width=\\\"3.5\\\" height=\\\"12\\\"/><rect x=\\\"9.5\\\" y=\\\"2\\\" width=\\\"3.5\\\" height=\\\"12\\\"/><\u002Fsvg>\";\nlet list=[],i=-1;\nconst fmt=s=>isFinite(s)?Math.floor(s/60)+':'+String(Math.floor(s%60)).padStart(2,'0'):'0:00';\nconst vol=+(localStorage.getItem('wohnung.mp.vol')??80);$('.mp-vol').value=vol;A.volume=vol/100;\nfunction ui(){\n  const e=!list.length;R.classList.toggle('empty',e);$('.mp-add0').style.display=e?'':'none';\n  $('.mp-pp').disabled=e;$('.mp-prev').disabled=$('.mp-next').disabled=list.length<2;\n  const t=list[i];$('.mp-t').textContent=t?t.name:'Keine Musik';\n  $('.mp-s').textContent=t?('Titel '+(i+1)+' von '+list.length):'Dateien hinzufügen oder hierher ziehen';\n  const pl=!A.paused&&!!t;R.classList.toggle('play',pl);$('.mp-pp').innerHTML=pl?Z:P;$('.mp-pp').title=pl?'Pause':'Abspielen';\n}\nfunction load(n,go){if(!list.length)return;i=(n+list.length)%list.length;A.src=list[i].url;if(go)A.play().catch(()=>{});ui();}\nfunction add(files){\n  const fs=[...files].filter(f=>f.type.startsWith('audio/')||/\\.(mp3|m4a|aac|wav|flac|ogg|opus)$/i.test(f.name));\n  if(!fs.length)return;const first=!list.length;\n  fs.forEach(f=>list.push({name:f.name.replace(/\\.[^.]+$/,'').replace(/[_]+/g,' '),url:URL.createObjectURL(f)}));\n  if(first)load(0,true);else ui();\n}\nR.querySelectorAll('.mp-add').forEach(b=>b.onclick=()=>F.click());\nF.onchange=()=>{add(F.files);F.value='';};\n$('.mp-pp').onclick=()=>{if(i<0)return load(0,true);A.paused?A.play().catch(()=>{}):A.pause();};\n$('.mp-prev').onclick=()=>{if(A.currentTime>3){A.currentTime=0;return;}load(i-1,true);};\n$('.mp-next').onclick=()=>load(i+1,true);\nA.onended=()=>{if(list.length>1||i<list.length-1)load(i+1,true);else ui();};\nA.onplay=A.onpause=ui;\nlet seeking=false;const sk=$('.mp-seek');\nsk.oninput=()=>{seeking=true;$('.mp-cur').textContent=fmt(sk.value/1000*A.duration);};\nsk.onchange=()=>{if(isFinite(A.duration))A.currentTime=sk.value/1000*A.duration;seeking=false;};\nA.ontimeupdate=()=>{if(seeking)return;$('.mp-cur').textContent=fmt(A.currentTime);if(A.duration)sk.value=A.currentTime/A.duration*1000;};\nA.onloadedmetadata=()=>{$('.mp-dur').textContent=fmt(A.duration);};\n$('.mp-vol').oninput=e=>{A.volume=e.target.value/100;localStorage.setItem('wohnung.mp.vol',e.target.value);};\n['dragenter','dragover'].forEach(t=>R.addEventListener(t,e=>{e.preventDefault();R.classList.add('drag');}));\n['dragleave','drop'].forEach(t=>R.addEventListener(t,e=>{e.preventDefault();R.classList.remove('drag');}));\nR.addEventListener('drop',e=>add(e.dataTransfer.files));\n['pointerdown','keydown','wheel'].forEach(t=>R.addEventListener(t,e=>e.stopPropagation()));\nui();\n})();\n<\u002Fscript>\n<script src=\"6f3432d0-1bde-4e2e-bd8f-dba82a254a95\"><\u002Fscript>\n<script type=\"module\">\n// moebel.js (eingebettet)\n// Möbel-Builder (aus Sofa 3D / Regal 3D / Bogenlampe 3D übernommen)\nconst mk = (THREE, name, geo, mat, x=0, y=0, z=0) => { const m = new THREE.Mesh(geo, mat); m.name=name; m.position.set(x,y,z); return m; };\n\nfunction buildSofa(THREE){\n  const M = {\n    fabric: new THREE.MeshStandardMaterial({ name:'poly_wool_herringbone', color:0x8b8780, roughness:0.95 }),\n    metal:  new THREE.MeshStandardMaterial({ name:'black_powdercoat', color:0x1d1d1f, roughness:0.45, metalness:0.6 }),\n    cup:    new THREE.MeshStandardMaterial({ name:'cupholder_black', color:0x151515, roughness:0.8 }),\n  };\n  const TEX = 0.5;\n  function rbox(w, h, d, r, k = 7, bulge = 0){\n    const half = [w/2, h/2, d/2];\n    const S = half.map(hh => { const a=[]; for(let i=k;i>=0;i--) a.push(-(hh-r) - r*Math.sin(i/k*Math.PI/2)); for(let i=0;i<=k;i++) a.push((hh-r) + r*Math.sin(i/k*Math.PI/2)); return a; });\n    const pos=[], nor=[], uv=[], idx=[];\n    for (let a=0;a<3;a++) for (const s of [1,-1]){\n      const u=(a+1)%3, v=(a+2)%3, su=S[u], sv=S[v], base=pos.length/3;\n      for (let j=0;j<sv.length;j++) for (let i=0;i<su.length;i++){\n        const p=[0,0,0]; p[a]=s*half[a]; p[u]=su[i]; p[v]=sv[j];\n        const c=p.map((x,m)=>Math.max(-(half[m]-r),Math.min(half[m]-r,x)));\n        let o=p.map((x,m)=>x-c[m]); const L=Math.hypot(...o)||1; o=o.map(x=>x/L);\n        const q=c.map((x,m)=>x+o[m]*r);\n        pos.push(...q); nor.push(...o);\n        const ax=Math.abs(o[0]),ay=Math.abs(o[1]),az=Math.abs(o[2]);\n        if (ay>=ax&&ay>=az) uv.push(q[0]/TEX,q[2]/TEX); else if (ax>=az) uv.push(q[2]/TEX,q[1]/TEX); else uv.push(q[0]/TEX,q[1]/TEX);\n      }\n      const nu=su.length;\n      for (let j=0;j<sv.length-1;j++) for (let i=0;i<nu-1;i++){\n        const A=base+j*nu+i, B=A+1, C=A+nu+1, D=A+nu;\n        if (s>0) idx.push(A,B,C, A,C,D); else idx.push(A,C,B, A,D,C);\n      }\n    }\n    const g = new THREE.BufferGeometry();\n    g.setAttribute('position', new THREE.Float32BufferAttribute(pos,3));\n    g.setAttribute('normal', new THREE.Float32BufferAttribute(nor,3));\n    g.setAttribute('uv', new THREE.Float32BufferAttribute(uv,2));\n    g.setIndex(idx);\n    if (bulge){\n      const p=g.attributes.position;\n      for (let i=0;i<p.count;i++){ const x=p.getX(i)/half[0], y=p.getY(i)/half[1]; p.setZ(i, p.getZ(i)*(1+bulge*(1-x*x)*(1-y*y))); }\n      g.computeVertexNormals();\n    }\n    return g;\n  }\n  const mesh = (...a) => mk(THREE, ...a);\n  const W=1.85, D=0.925, L=0.20, ARM=0.24, TOP=0.21, G=0.004;\n  const sofa = new THREE.Group(); sofa.name = 'sofa';\n  for (const [i,sx] of [[1,-1],[2,1]])\n    sofa.add(mesh('lage_unten_'+i, rbox(W/2-G, L-G, D, 0.035), M.fabric, sx*W/4, L/2, 0));\n  const hinge = new THREE.Group(); hinge.name='klappteil'; hinge.position.set(0, L, D/2);\n  for (const [i,sx] of [[1,-1],[2,1]])\n    hinge.add(mesh('lage_mitte_'+i, rbox(W/2-G, L-G, D, 0.035), M.fabric, sx*W/4, L/2, -D/2));\n  sofa.add(hinge);\n  const top = new THREE.Group(); top.name='aufbau'; top.position.y = 2*L;\n  for (const [n,sx] of [['links',-1],['rechts',1]]){\n    const x = sx*(W/2-ARM/2);\n    top.add(mesh('armlehne_'+n, rbox(ARM, TOP, D, 0.05), M.fabric, x, TOP/2, 0));\n    top.add(mesh('becherhalter_'+n, new THREE.CylinderGeometry(0.04,0.04,0.012,40), M.cup, x, TOP+0.001, D/2-0.1));\n    const ring = mesh('becherhalter_ring_'+n, new THREE.TorusGeometry(0.042,0.005,12,40), M.metal, x, TOP+0.004, D/2-0.1);\n    ring.rotation.x = Math.PI/2; top.add(ring);\n  }\n  const backW = (W-2*ARM)/2 - G;\n  for (const [i,sx] of [[1,-1],[2,1]]){\n    top.add(mesh('rueckenteil_'+i, rbox(backW, TOP, ARM, 0.05), M.fabric, sx*(backW/2+G/2), TOP/2, -D/2+ARM/2));\n    const p = mesh('kissen_'+i, rbox(0.45, 0.45, 0.10, 0.04, 7, 0.6), M.fabric, sx*0.33, 0.22, -D/2+ARM+0.08);\n    p.rotation.x = -0.28; p.rotation.z = sx*0.06; top.add(p);\n  }\n  sofa.add(top);\n  const fz0 = -0.05, fz1 = 0.30, fh = 0.34, rr = 0.008, R = 0.045, y0 = 0.02, yt = y0 + fh;\n  for (const [n,sx] of [['links',-1],['rechts',1]]){\n    const frame = new THREE.Group(); frame.name='seitengestell_'+n;\n    const fx = sx*(W/2 + 0.012);\n    for (const z of [fz0, fz1]) frame.add(mesh('gestell_stab_'+n, new THREE.CylinderGeometry(rr,rr,fh-R,20), M.metal, fx, y0+(fh-R)/2, z));\n    const bar = mesh('gestell_quer_'+n, new THREE.CylinderGeometry(rr,rr,fz1-fz0-2*R,20), M.metal, fx, yt, (fz0+fz1)/2); bar.rotation.x=Math.PI/2; frame.add(bar);\n    for (const [z,ry] of [[fz0+R, Math.PI/2],[fz1-R, -Math.PI/2]]){\n      const c = mesh('gestell_bogen_'+n, new THREE.TorusGeometry(R, rr, 16, 24, Math.PI/2), M.metal, fx, yt-R, z); c.rotation.y = ry; frame.add(c);\n    }\n    sofa.add(frame);\n  }\n  return { group: sofa, M, D };\n}\n\nfunction buildRegal(THREE, M){\n  const box = (w, h, d) => {\n    const g = new THREE.BoxGeometry(w, h, d), uv = g.attributes.uv;\n    const faces = [[d,h],[d,h],[w,d],[w,d],[w,h],[w,h]];\n    for (let f=0; f<6; f++) for (let i=0;i<4;i++){ const k=f*4+i; uv.setXY(k, uv.getX(k)*faces[f][0], uv.getY(k)*faces[f][1]); }\n    return g;\n  };\n  const mesh = (...a) => mk(THREE, ...a);\n  const W=0.60, D=0.27, H=0.74, A=0.03, T=0.0015, LIP=0.02, FOOT=0.012;\n  const shelfTops = [0.10, 0.42, H];\n  const regal = new THREE.Group(); regal.name='regal';\n  const postH = H - FOOT;\n  for (const [n,sx,sz] of [['vl',-1,1],['vr',1,1],['hl',-1,-1],['hr',1,-1]]){\n    const p = new THREE.Group(); p.name='pfosten_'+n;\n    const cx = sx*(W/2 - A/2), cz = sz*(D/2 - A/2), y = FOOT + postH/2;\n    p.add(mesh('pfosten_'+n+'_a', box(A, postH, T), M.concrete, cx, y, sz*(D/2 - T/2)));\n    p.add(mesh('pfosten_'+n+'_b', box(T, postH, A), M.concrete, sx*(W/2 - T/2), y, cz));\n    p.add(mesh('fuss_'+n, box(A+0.002, FOOT, A+0.002), M.foot, cx, FOOT/2, cz));\n    for (const top of shelfTops){\n      const yb = top - LIP/2;\n      const b1 = mesh('schraube_'+n, new THREE.CylinderGeometry(0.004,0.004,0.003,16), M.bolt, cx, yb, sz*(D/2+0.001)); b1.rotation.x = Math.PI/2; p.add(b1);\n      const b2 = mesh('schraube_'+n, new THREE.CylinderGeometry(0.004,0.004,0.003,16), M.bolt, sx*(W/2+0.001), yb, cz); b2.rotation.z = Math.PI/2; p.add(b2);\n    }\n    regal.add(p);\n  }\n  shelfTops.forEach((top, i) => {\n    const s = new THREE.Group(); s.name='boden_'+(i+1);\n    const iw = W - 2*T, id = D - 2*T;\n    s.add(mesh('boden_'+(i+1)+'_platte', box(iw, T, id), M.concrete, 0, top - T/2, 0));\n    for (const sz of [1,-1]) s.add(mesh('boden_'+(i+1)+'_kante_z', box(iw, LIP, T), M.concrete, 0, top - LIP/2, sz*(id/2 - T/2)));\n    for (const sx of [1,-1]) s.add(mesh('boden_'+(i+1)+'_kante_x', box(T, LIP, id), M.concrete, sx*(iw/2 - T/2), top - LIP/2, 0));\n    regal.add(s);\n  });\n  return regal;\n}\nfunction regalMaterials(THREE){\n  return {\n    concrete: galvanizedMaterial(THREE, 18), // verzinkter Stahl, Textur „Fein“\n    foot:     new THREE.MeshStandardMaterial({ name:'kunststoff_fuss', color:0x2a2a2a, roughness:0.7 }),\n    bolt:     new THREE.MeshStandardMaterial({ name:'schraube', color:0x8c8c8c, roughness:0.35, metalness:0.9 }),\n  };\n}\n\nfunction buildLampe(THREE){\n  const V = (x,y,z=0) => new THREE.Vector3(x,y,z);\n  const M = {\n    chrom:  new THREE.MeshStandardMaterial({ name:'chrom', color:0xd8dadd, metalness:0.5, roughness:0.25 }),\n    schirm: new THREE.MeshPhysicalMaterial({ name:'acryl_weiss', color:0xf7f7f5, roughness:0.28, clearcoat:0.8, clearcoatRoughness:0.1, side:THREE.DoubleSide }),\n    birne:  new THREE.MeshStandardMaterial({ name:'leuchtmittel', color:0xffffff, emissive:0xfff1d6, emissiveIntensity:0.2 }),\n  };\n  const add = (parent, name, geo, mat, p=[0,0,0], r=[0,0,0]) => { const m = new THREE.Mesh(geo, mat); m.name = name; m.position.set(...p); m.rotation.set(...r); parent.add(m); return m; };\n  const lampe = new THREE.Group(); lampe.name = 'bogenlampe';\n  const H = 1.66, REACH = 1.22, SH_R = 0.15, BASE_R = 0.13, BASE_H = 0.028, POLE_R = 0.0125, ARC_R = 0.0085, POLE_TOP = 0.74;\n  const prof = [new THREE.Vector2(0, 0), new THREE.Vector2(BASE_R - 0.004, 0)];\n  for (let i = 0; i <= 10; i++){ const a = -Math.PI/2 + i/10*Math.PI/2; prof.push(new THREE.Vector2(BASE_R - 0.008 + Math.cos(a)*0.008, 0.008 + Math.sin(a)*0.008)); }\n  for (let i = 0; i <= 10; i++){ const a = i/10*Math.PI/2; prof.push(new THREE.Vector2(BASE_R - 0.012 + Math.cos(a)*0.012, BASE_H - 0.012 + Math.sin(a)*0.012)); }\n  prof.push(new THREE.Vector2(0, BASE_H));\n  add(lampe, 'fuss', new THREE.LatheGeometry(prof, 96), M.chrom);\n  add(lampe, 'fuss_rosette', new THREE.CylinderGeometry(0.022, 0.026, 0.012, 48), M.chrom, [0, BASE_H + 0.006, 0]);\n  add(lampe, 'standrohr', new THREE.CylinderGeometry(POLE_R, POLE_R, POLE_TOP - BASE_H, 48), M.chrom, [0, (POLE_TOP + BASE_H)/2, 0]);\n  add(lampe, 'muffe_unten', new THREE.CylinderGeometry(POLE_R + 0.0015, POLE_R + 0.0015, 0.03, 48), M.chrom, [0, POLE_TOP - 0.015, 0]);\n  const ARC_END = V(REACH - 0.04, H - ARC_R);\n  const arc = new THREE.CubicBezierCurve3(V(0, POLE_TOP - 0.02), V(0, 1.38), V(0.42, H - ARC_R), ARC_END);\n  add(lampe, 'bogen', new THREE.TubeGeometry(arc, 240, ARC_R, 32), M.chrom);\n  const pM = arc.getPointAt(0.36), dM = arc.getTangentAt(0.36);\n  const muffe = add(lampe, 'muffe_bogen', new THREE.CylinderGeometry(ARC_R + 0.0018, ARC_R + 0.0018, 0.035, 32), M.chrom, [pM.x, pM.y, 0]);\n  muffe.quaternion.setFromUnitVectors(V(0,1,0), dM);\n  add(lampe, 'endkappe', new THREE.CylinderGeometry(ARC_R + 0.002, ARC_R + 0.002, 0.07, 32), M.chrom, [ARC_END.x - 0.02, ARC_END.y, 0], [0, 0, Math.PI/2]);\n  const kopf = new THREE.Group(); kopf.name = 'schirm_gruppe';\n  const TILT = 0.3;\n  kopf.position.set(REACH - SH_R*Math.sin(TILT), H - ARC_R - 0.035, 0);\n  kopf.rotation.z = TILT;\n  add(lampe, 'gelenk', new THREE.CylinderGeometry(0.006, 0.006, 0.03, 20), M.chrom, [kopf.position.x, H - ARC_R - 0.018, 0]);\n  lampe.add(kopf);\n  add(kopf, 'schirm', new THREE.SphereGeometry(SH_R, 96, 48, 0, Math.PI*2, 0, 1.95), M.schirm, [0, -SH_R, 0]);\n  add(kopf, 'schirm_nabe', new THREE.CylinderGeometry(0.018, 0.028, 0.02, 40), M.chrom, [0, -0.004, 0]);\n  add(kopf, 'fassung', new THREE.CylinderGeometry(0.016, 0.016, 0.05, 32), M.chrom, [0, -0.04, 0]);\n  add(kopf, 'leuchtmittel', new THREE.SphereGeometry(0.03, 32, 16), M.birne, [0, -0.09, 0]);\n  return { group: lampe, REACH };\n}\n\n// Verzinkter Stahl (Zink-Spangle, prozedural) – aus Regal 3D\nfunction galvanized(size=1024, cells=24, seed=7){\n  let s = seed; const rnd = () => (s = (s*16807) % 2147483647) / 2147483647;\n  const g = cells, pts = [];\n  for (let j=0;j<g;j++) for (let i=0;i<g;i++){\n    const a = rnd()*Math.PI*2;\n    pts.push({ x:(i+rnd())/g, y:(j+rnd())/g, base: 0.72 + rnd()*0.18, gx:Math.cos(a), gy:Math.sin(a), k: 0.03 + rnd()*0.08, r: rnd() });\n  }\n  const col = document.createElement('canvas'); col.width = col.height = size;\n  const rou = document.createElement('canvas'); rou.width = rou.height = size;\n  const cc = col.getContext('2d'), rc = rou.getContext('2d');\n  const ci = cc.createImageData(size,size), ri = rc.createImageData(size,size);\n  for (let y=0;y<size;y++) for (let x=0;x<size;x++){\n    const u = x/size, v = y/size, cx = Math.floor(u*g), cy = Math.floor(v*g);\n    let best = 9, second = 9, bp = null, bdx=0, bdy=0;\n    for (let oy=-1;oy<=1;oy++) for (let ox=-1;ox<=1;ox++){\n      const ix = (cx+ox+g)%g, iy = (cy+oy+g)%g, p = pts[iy*g+ix];\n      const dx = u - (p.x + Math.floor((cx+ox)/g) * 1 + ((cx+ox)<0?0:0)) , dy = v - (p.y + Math.floor((cy+oy)/g));\n      const d = dx*dx + dy*dy;\n      if (d < best){ second = best; best = d; bp = p; bdx = dx; bdy = dy; } else if (d < second) second = d;\n    }\n    const edge = Math.sqrt(second) - Math.sqrt(best);            // Abstand zur Korngrenze\n    let l = bp.base + (bdx*bp.gx + bdy*bp.gy) * g * bp.k;        // Facetten-Verlauf pro Korn\n    l += (Math.random()-0.5)*0.05;                               // feines Korn\n    if (edge < 0.0018) l -= 0.035;                                // dunkle Korngrenzen\n    if (Math.random() < 0.003) l -= 0.12;                        // dunkle Sprenkel\n    l = Math.max(0.25, Math.min(0.97, l));\n    const o = (y*size+x)*4, c = l*255;\n    ci.data[o]=c*0.98; ci.data[o+1]=c; ci.data[o+2]=c*1.02; ci.data[o+3]=255;\n    const r = (0.28 + (1-l)*0.35 + bp.r*0.12) * 255;             // helle Körner glänzender\n    ri.data[o]=ri.data[o+1]=ri.data[o+2]=r; ri.data[o+3]=255;\n  }\n  cc.putImageData(ci,0,0); rc.putImageData(ri,0,0);\n  return { col, rou };\n}\nfunction galvanizedMaterial(THREE, repeat = 18){\n  const { col, rou } = galvanized();\n  const mk = (c, srgb) => { const t = new THREE.CanvasTexture(c); t.wrapS = t.wrapT = THREE.RepeatWrapping; t.repeat.set(repeat, repeat);\n    if (srgb) t.colorSpace = THREE.SRGBColorSpace; t.anisotropy = 8; return t; };\n  return new THREE.MeshStandardMaterial({ name:'stahl_verzinkt', map: mk(col, true), roughnessMap: mk(rou), bumpMap: mk(col), bumpScale: 0.25,\n    color: 0xeceef0, roughness: 1, metalness: 0.3 });\n}\n\n// Regallautsprecher-Paar (aus Boxen 3D): passiv + aktiv (Bedienfeld an lokaler +x-Seite)\nfunction buildBoxen(THREE){\n  const M = {\n    wood:   new THREE.MeshStandardMaterial({ name:'eiche', color:0xb77a3e, roughness:0.55 }),\n    fabric: new THREE.MeshStandardMaterial({ name:'stoff_grau', color:0x6c6c6a, roughness:0.97 }),\n    strip:  new THREE.MeshStandardMaterial({ name:'zierleiste_silber', color:0xc9c9c9, roughness:0.3, metalness:0.9 }),\n    black:  new THREE.MeshStandardMaterial({ name:'kunststoff_schwarz', color:0x1c1c1c, roughness:0.6 }),\n    knob:   new THREE.MeshStandardMaterial({ name:'drehregler', color:0x141414, roughness:0.4, metalness:0.2 }),\n    alu:    new THREE.MeshStandardMaterial({ name:'hochtoener_alu', color:0xaaaaaa, roughness:0.35, metalness:0.8 }),\n    led:    new THREE.MeshStandardMaterial({ name:'led', color:0x0a2a10, emissive:0x2bd45a, emissiveIntensity:1.2 }),\n  };\n  const W=0.146, D=0.196, H=0.234, R=0.014, BV=0.002;\n  const mesh = (name, geo, mat, x=0, y=0, z=0) => mk(THREE, name, geo, mat, x, y, z);\n  const rrect = (w, h, r) => { const s = new THREE.Shape(), x=-w/2, y=-h/2;\n    s.moveTo(x+r,y); s.lineTo(x+w-r,y); s.quadraticCurveTo(x+w,y,x+w,y+r); s.lineTo(x+w,y+h-r); s.quadraticCurveTo(x+w,y+h,x+w-r,y+h);\n    s.lineTo(x+r,y+h); s.quadraticCurveTo(x,y+h,x,y+h-r); s.lineTo(x,y+r); s.quadraticCurveTo(x,y,x+r,y); return s; };\n  const cabGeo = new THREE.ExtrudeGeometry(rrect(W-2*BV, D-2*BV, R), { depth:H-2*BV, bevelEnabled:true, bevelSize:BV, bevelThickness:BV, bevelSegments:2, curveSegments:10 });\n  cabGeo.rotateX(-Math.PI/2); cabGeo.translate(0, BV, 0);\n  { const p = cabGeo.attributes.position, n = cabGeo.attributes.normal, uv = cabGeo.attributes.uv;\n    for (let i=0;i<p.count;i++){ const x=p.getX(i), y=p.getY(i), z=p.getZ(i);\n      if (Math.abs(n.getY(i)) > 0.7) uv.setXY(i, x, z); else uv.setXY(i, Math.abs(n.getX(i)) > Math.abs(n.getZ(i)) ? z : x, y); } }\n  const GW=W-0.006, GH=H-0.006, GT=0.008;\n  const grilleGeo = new THREE.ExtrudeGeometry(rrect(GW-0.004, GH-0.004, 0.009), { depth:GT-0.003, bevelEnabled:true, bevelSize:0.002, bevelThickness:0.0015, bevelSegments:3, curveSegments:8 });\n  function speaker(name, active){\n    const s = new THREE.Group(); s.name = name;\n    s.add(mesh(name+'_gehaeuse', cabGeo, M.wood));\n    s.add(mesh(name+'_stoff', grilleGeo, M.fabric, 0, H/2, D/2 + 0.0015));\n    s.add(mesh(name+'_zierleiste', new THREE.BoxGeometry(GW*0.74, 0.0026, 0.0012), M.strip, 0, H*0.585, D/2 + GT + 0.0005));\n    s.add(mesh(name+'_logo', new THREE.BoxGeometry(0.026, 0.006, 0.0008), M.strip, 0, 0.026, D/2 + GT + 0.0003));\n    const port = mesh(name+'_bassreflex', new THREE.CylinderGeometry(0.014, 0.014, 0.004, 32), M.black, 0, 0.17, -D/2 - 0.001);\n    port.rotation.x = Math.PI/2; s.add(port);\n    for (const [fx,fz] of [[-1,-1],[1,-1],[-1,1],[1,1]])\n      s.add(mesh(name+'_fuss', new THREE.CylinderGeometry(0.006,0.006,0.002,20), M.black, fx*(W/2-0.02), 0.001, fz*(D/2-0.025)));\n    if (active){\n      const px = W/2 + 0.0004, cz = -0.012;\n      s.add(mesh(name+'_bedienfeld', new THREE.BoxGeometry(0.002, 0.108, 0.055), M.black, px, 0.14, cz));\n      [0.176, 0.143, 0.11].forEach((y, i) => {\n        const k = mesh(name+'_regler_'+['hoehen','bass','lautstaerke'][i], new THREE.CylinderGeometry(0.0085, 0.0085, 0.011, 28), M.knob, px+0.0055, y, cz-0.004);\n        k.rotation.z = Math.PI/2; s.add(k);\n      });\n      s.add(mesh(name+'_led', new THREE.SphereGeometry(0.0015, 12, 8), M.led, px+0.001, 0.093, cz-0.004));\n    }\n    s.traverse(o => { if (o.isMesh) o.position.y += 0.002; });\n    return s;\n  }\n  return { W, D, H, links: speaker('box_links', false), rechts: speaker('box_rechts_aktiv', true) };\n}\n\n// Tripod-Lampe (aus Tripodlampe 3D): Eichen-Leuchtkopf mit LED-Spot auf schwarzem Dreibein; Front = lokale +z\nfunction buildTripod(THREE){\n  const V = (x,y,z) => new THREE.Vector3(x,y,z);\n  const c = document.createElement('canvas'); c.width = c.height = 512; const g = c.getContext('2d');\n  g.fillStyle = '#c49a66'; g.fillRect(0,0,512,512);\n  let s = 11; const r = () => (s = (s*16807) % 2147483647) / 2147483647;\n  for (let i = 0; i < 260; i++){\n    const y = r()*512, a = 0.04 + r()*0.12; g.strokeStyle = r() > 0.5 ? `rgba(120,80,40,${a})` : `rgba(235,200,150,${a})`; g.lineWidth = 0.5 + r()*2.2;\n    g.beginPath(); g.moveTo(0,y); for (let x = 0; x <= 512; x += 32) g.lineTo(x, y + Math.sin(x*0.012 + i)*4 + (r()-0.5)*1.5); g.stroke();\n  }\n  const tex = new THREE.CanvasTexture(c); tex.colorSpace = THREE.SRGBColorSpace;\n  const M = {\n    holz:   new THREE.MeshStandardMaterial({ name:'tripod_eiche', map: tex, roughness:0.6 }),\n    stahl:  new THREE.MeshStandardMaterial({ name:'tripod_stahl_schwarz', color:0x1b1b1c, roughness:0.45, metalness:0.6 }),\n    gummi:  new THREE.MeshStandardMaterial({ name:'tripod_gummi', color:0x111111, roughness:0.9 }),\n    blende: new THREE.MeshStandardMaterial({ name:'tripod_reflektor', color:0x9a9a9a, roughness:0.25, metalness:0.9 }),\n    led:    new THREE.MeshStandardMaterial({ name:'tripod_led', color:0xd8dadd, emissive:0xf4f7ff, emissiveIntensity:0, roughness:0.2 }),\n    kabel:  new THREE.MeshStandardMaterial({ name:'tripod_kabel', color:0x151515, roughness:0.7 }),\n  };\n  const add = (p, n, geo, mat, pos=[0,0,0]) => { const o = mk(THREE, n, geo, mat, ...pos); p.add(o); return o; };\n  const rod = (p, n, a, b, rr, mat) => { const d = b.clone().sub(a), o = add(p, n, new THREE.CylinderGeometry(rr, rr, d.length(), 20), mat);\n    o.position.copy(a).addScaledVector(d, 0.5); o.quaternion.setFromUnitVectors(V(0,1,0), d.normalize()); return o; };\n  const group = new THREE.Group(); group.name = 'tripodlampe';\n  const HUB = V(0, 0.36, 0), FR = 0.17;\n  for (let i = 0; i < 3; i++){\n    const a = Math.PI/2 + i*2*Math.PI/3, foot = V(Math.cos(a)*FR, 0.006, Math.sin(a)*FR);\n    rod(group, 'tripod_bein_'+(i+1), foot, HUB.clone().add(V(Math.cos(a)*0.012, 0, Math.sin(a)*0.012)), 0.005, M.stahl);\n    add(group, 'tripod_fuss_'+(i+1), new THREE.CylinderGeometry(0.0058, 0.0058, 0.012, 16), M.gummi, [foot.x, 0.006, foot.z]);\n  }\n  add(group, 'tripod_knoten', new THREE.CylinderGeometry(0.016, 0.018, 0.028, 28), M.stahl, [0, 0.36, 0]);\n  const HW = 0.14, HH = 0.12, HD = 0.11;\n  const arm = new THREE.CatmullRomCurve3([V(0,0.374,0), V(-0.01,0.41,0), V(-0.045,0.45,0.005), V(-0.09,0.485,0.01), V(-0.092,0.495,0.01), V(-HW/2-0.008,0.49,0.01)]);\n  add(group, 'tripod_buegel', new THREE.TubeGeometry(arm, 48, 0.0055, 12), M.stahl);\n  const kopf = new THREE.Group(); kopf.name = 'tripod_kopf'; kopf.position.set(0, 0.49, 0.01); kopf.rotation.set(0.12, 0.15, 0); group.add(kopf);\n  add(kopf, 'tripod_holzkoerper', new THREE.BoxGeometry(HW, HH, HD), M.holz);\n  add(kopf, 'tripod_gelenk', new THREE.CylinderGeometry(0.013, 0.013, 0.01, 28), M.stahl, [-HW/2-0.005, 0, 0]).rotation.z = Math.PI/2;\n  add(kopf, 'tripod_blende', new THREE.TorusGeometry(0.036, 0.005, 12, 48), M.blende, [0.01, 0, HD/2+0.001]);\n  add(kopf, 'tripod_reflektor', new THREE.CylinderGeometry(0.036, 0.03, 0.012, 48, 1, true), M.blende, [0.01, 0, HD/2-0.005]).rotation.x = Math.PI/2;\n  const linse = add(kopf, 'tripod_led_linse', new THREE.CircleGeometry(0.034, 48), M.led, [0.01, 0, HD/2-0.008]);\n  const kabel = new THREE.CatmullRomCurve3([V(-0.005,0.35,-0.012), V(-0.03,0.28,-0.04), V(-0.07,0.16,-0.08), V(-0.11,0.05,-0.12), V(-0.14,0.004,-0.16), V(-0.28,0.004,-0.24), V(-0.45,0.004,-0.2)]);\n  add(group, 'tripod_kabel', new THREE.TubeGeometry(kabel, 64, 0.0022, 8), M.kabel);\n  group.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\n  linse.castShadow = false;\n  // Lichtquellen am Kopf (Intensität 0 = aus)\n  const spot = new THREE.SpotLight(0xf2f5ff, 0, 0, 0.55, 0.5, 2);\n  spot.position.set(0.01, 0, HD/2 + 0.005); spot.target.position.set(0.01, 0, HD/2 + 1);\n  spot.castShadow = true; spot.shadow.mapSize.set(1024, 1024); spot.shadow.bias = -0.0005; spot.shadow.normalBias = 0.02;\n  spot.shadow.camera.near = 0.03; spot.shadow.camera.far = 8;\n  const glow = new THREE.PointLight(0xf2f5ff, 0, 3, 2); glow.position.set(0.01, 0, HD/2 + 0.05);\n  kopf.add(spot, spot.target, glow);\n  return { group, kopf, M, spot, glow };\n}\n\nconst stage = document.querySelector('three-d-stage');\nconst { THREE } = await stage.ready;\nconst statusEl = { set textContent(v){} };\nfor (const sel of ['.toolbar','.note']) { const el = stage.shadowRoot.querySelector(sel); if (el) el.style.display = 'none'; }\n\n// ---------- Maße in Metern (LiDAR-Scan 10/2026, bereinigt) ----------\n// x = Ost, z = Süd; Ursprung = Innenkante Westwand Schlafzimmer / Innenkante Nordwand\nconst H = 2.5, TE = 0.2, TI = 0.1;     // Wandhöhe, Außen-/Innenwand\nconst DOOR_W = 0.9, DOOR_H = 2.1, WIN_B = 0.9, WIN_T = 2.2;\n\n// ---------- Materialien ----------\nconst M = {\n  floor:  new THREE.MeshStandardMaterial({ name:'wood_floor', color:0x8a6242, roughness:0.6 }),\n  wall:   new THREE.MeshStandardMaterial({ name:'white_stucco', color:0xf2efe9, roughness:0.95 }),\n  brick:  new THREE.MeshStandardMaterial({ name:'brick_wall_04', color:0x9a5a44, roughness:0.9 }),\n  cap:    new THREE.MeshStandardMaterial({ name:'rough_plaster_brick_04', color:0xb8a898, roughness:0.95 }),\n  plinth: new THREE.MeshStandardMaterial({ name:'plinth', color:0x2f2d2a, roughness:0.7 }),\n  wood:   new THREE.MeshStandardMaterial({ name:'door_white_lacquer', color:0xf7f5f0, roughness:0.35 }),\n  metal:  new THREE.MeshStandardMaterial({ name:'brushed_steel', color:0xb9bcc0, roughness:0.3, metalness:0.35 }),\n  glass:  new THREE.MeshStandardMaterial({ name:'glass', color:0xbfd8e4, roughness:0.05, transparent:true, opacity:0.35 }),\n  balcony:new THREE.MeshStandardMaterial({ name:'balcony_concrete', color:0xa9a59d, roughness:0.9 }),\n};\n\n// Welt-UVs (Box-Projektion), damit Texturen nicht gestreckt werden\nfunction worldUV(geo, scale){\n  const p = geo.attributes.position, n = geo.attributes.normal, uv = geo.attributes.uv;\n  for (let i = 0; i < p.count; i++){\n    const ax = Math.abs(n.getX(i)), ay = Math.abs(n.getY(i)), az = Math.abs(n.getZ(i));\n    let u, v;\n    if (ay >= ax && ay >= az){ u = p.getX(i); v = p.getZ(i); }\n    else if (ax >= az){ u = p.getZ(i); v = p.getY(i); }\n    else { u = p.getX(i); v = p.getY(i); }\n    uv.setXY(i, u/scale, v/scale);\n  }\n  uv.needsUpdate = true;\n  return geo;\n}\n// Box in Weltkoordinaten (min/max)\nfunction box(name, mat, x0,y0,z0, x1,y1,z1, uvScale){\n  const g = new THREE.BoxGeometry(x1-x0, y1-y0, z1-z0);\n  g.translate((x0+x1)/2, (y0+y1)/2, (z0+z1)/2);\n  if (uvScale) worldUV(g, uvScale);\n  const m = new THREE.Mesh(g, mat); m.name = name; return m;\n}\n\nconst home = new THREE.Group(); home.name = 'wohnung';\nconst walls = new THREE.Group(); walls.name = 'waende';\nconst doors = new THREE.Group(); doors.name = 'tueren';\nconst windows = new THREE.Group(); windows.name = 'fenster';\nhome.add(walls, doors, windows);\n\n// ---------- Tür (prozedural, Kassettentür) ----------\nfunction makeDoor(name, t, openDeg, glassDoor=false, w=DOOR_W){\n  const g = new THREE.Group(); g.name = name;\n  const d = t + 0.03;\n  g.add(box(name+'_zarge_l', M.wood, -w/2, 0, -d/2, -w/2+0.04, DOOR_H, d/2));\n  g.add(box(name+'_zarge_r', M.wood,  w/2-0.04, 0, -d/2, w/2, DOOR_H, d/2));\n  g.add(box(name+'_zarge_oben', M.wood, -w/2, DOOR_H-0.04, -d/2, w/2, DOOR_H, d/2));\n  const lw = w - 0.08, lh = DOOR_H - 0.05, lt = 0.04;\n  const pivot = new THREE.Group(); pivot.name = name+'_blatt';\n  pivot.position.set(-w/2 + 0.04, 0.005, 0);\n  pivot.rotation.y = THREE.MathUtils.degToRad(openDeg);\n  pivot.add(box(name+'_tuerblatt', M.wood, 0, 0, -lt/2, lw, lh, lt/2));\n  for (const s of [1,-1]){\n    const z0 = s*0.014, z1 = s*0.026, zz=[Math.min(z0,z1),Math.max(z0,z1)];\n    if (glassDoor){\n      pivot.add(box(name+'_glas', M.glass, 0.1, 0.35, -0.006, lw-0.1, lh-0.12, 0.006));\n    } else {\n      pivot.add(box(name+'_kassette_o'+s, M.wood, 0.11, 1.05, zz[0], lw-0.11, lh-0.14, zz[1]));\n      pivot.add(box(name+'_kassette_u'+s, M.wood, 0.11, 0.14, zz[0], lw-0.11, 0.9, zz[1]));\n    }\n    const rose = new THREE.Mesh(new THREE.CylinderGeometry(0.026,0.026,0.012,32), M.metal);\n    rose.name = name+'_rosette'+s; rose.rotation.x = Math.PI/2; rose.position.set(lw-0.07, 1.05, s*(lt/2+0.006)); pivot.add(rose);\n    const neck = new THREE.Mesh(new THREE.CylinderGeometry(0.009,0.009,0.05,20), M.metal);\n    neck.name = name+'_hals'+s; neck.rotation.x = Math.PI/2; neck.position.set(lw-0.07, 1.05, s*(lt/2+0.03)); pivot.add(neck);\n    const lever = new THREE.Mesh(new THREE.CapsuleGeometry(0.009, 0.12, 6, 16), M.metal);\n    lever.name = name+'_druecker'+s; lever.rotation.z = Math.PI/2; lever.position.set(lw-0.13, 1.05, s*(lt/2+0.055)); pivot.add(lever);\n  }\n  for (const y of [0.25, lh-0.25]){\n    const h = new THREE.Mesh(new THREE.CylinderGeometry(0.008,0.008,0.1,16), M.metal);\n    h.name = name+'_band'; h.position.set(-0.004, y, lt/2); pivot.add(h);\n  }\n  g.add(pivot);\n  return g;\n}\n\n// ---------- Fenster ----------\nfunction makeWindow(name, w, t, bottom, top){\n  const g = new THREE.Group(); g.name = name;\n  const f = 0.05, d = 0.07;\n  g.add(box(name+'_rahmen_l', M.wood, -w/2, bottom, -d/2, -w/2+f, top, d/2));\n  g.add(box(name+'_rahmen_r', M.wood, w/2-f, bottom, -d/2, w/2, top, d/2));\n  g.add(box(name+'_rahmen_o', M.wood, -w/2+f, top-f, -d/2, w/2-f, top, d/2));\n  g.add(box(name+'_rahmen_u', M.wood, -w/2+f, bottom, -d/2, w/2-f, bottom+f, d/2));\n  if (w > 1.1) g.add(box(name+'_pfosten', M.wood, -0.025, bottom+f, -d/2+0.005, 0.025, top-f, d/2-0.005));\n  g.add(box(name+'_glas', M.glass, -w/2+f, bottom+f, -0.005, w/2-f, top-f, 0.005));\n  if (bottom > 0) g.add(box(name+'_bank', M.wood, -w/2-0.05, bottom-0.027, -t/2-0.04, w/2+0.05, bottom+0.012, t/2+0.04));\n  return g;\n}\n\n// ---------- Wand mit Öffnungen (achsparallel, Meter) ----------\n// a..b: Ausdehnung entlang der Wand, fixed: Mittellinie; ops: {c, w, type:'door'|'window'|'glassdoor', open, flip, name}\n// outside: Box-Face-Index der Außenseite (0:+x 1:-x 4:+z 5:-z) → Klinker außen, Putz innen; ends: Stirnseiten außen sichtbar\nfunction wall(name, a, b, fixed, horizontal, t, h, ops=[], outside=-1, ends=[false,false]){\n  const F = fixed;\n  const seg = (n, s0, s1, y0, y1, ef=[]) => {\n    if (s1 - s0 < 0.001) return;\n    const mat = Array(6).fill(M.wall);\n    if (outside >= 0){ mat[outside] = M.brick; ef.forEach(e => mat[e] = M.brick); }\n    if (y1 >= h - 0.0001) mat[2] = M.cap;\n    walls.add(horizontal ? box(n, mat, s0, y0, F-t/2, s1, y1, F+t/2, 1.5)\n                         : box(n, mat, F-t/2, y0, s0, F+t/2, y1, s1, 1.5));\n  };\n  const endA = ends[0] ? [horizontal ? 1 : 5] : [], endB = ends[1] ? [horizontal ? 0 : 4] : [];\n  const list = [...ops].sort((p,q)=>p.c-q.c);\n  let cur = a;\n  list.forEach((o, i) => {\n    const s0 = o.c - o.w/2, s1 = o.c + o.w/2;\n    seg(`${name}_${i}`, cur, s0, 0, h, i === 0 ? endA : []);\n    seg(`${name}_sturz_${i}`, s0, s1, o.type === 'door' ? DOOR_H : WIN_T, h);\n    if (o.type === 'window') seg(`${name}_bruestung_${i}`, s0, s1, 0, WIN_B);\n    let el;\n    if (o.type === 'door') { el = makeDoor(o.name, t, o.open ?? 0, false, o.w); doors.add(el); }\n    else if (o.type === 'glassdoor') { el = makeWindow(o.name, o.w, t, 0, WIN_T); windows.add(el); }\n    else { el = makeWindow(o.name, o.w, t, WIN_B, WIN_T); windows.add(el); }\n    if (horizontal) el.position.set(o.c, 0, F);\n    else { el.position.set(F, 0, o.c); el.rotation.y = Math.PI/2; }\n    if (o.flip) el.rotation.y += Math.PI;\n    cur = s1;\n  });\n  seg(`${name}_${list.length}`, cur, b, 0, h, list.length === 0 ? [...endA, ...endB] : endB);\n}\n\n// Grundriss nach LiDAR-Scan: Raummaße, Wandlagen, Öffnungsmitten. Nicht übernommen: „Other 4“-Spalt, Scan-Möbel,\n// schräger Wandrest im Flur, 10-cm-Versatz der Ostfassade (begradigt). Tür-/Fensterbreiten + Mauervorsprung = Handmaße.\nconst HI = H - 0.003; // Innenwände minimal niedriger → kein Z-Fighting auf den Oberkanten\nconst X_FL = 1.21;              // Innenkante Westwand Bad/Flur (Schlafzimmer springt 1,21 m weiter nach Westen)\nconst X_SW = 2.66;              // Wandmitte Schlafzimmer | Wohnzimmer\nconst X_SCH = 2.11;             // Westkante Schacht\nconst X_BK = 3.29;              // Wandmitte Bad | Küche\nconst X_FK = 3.58;              // Wandmitte Flur | Küche\nconst X_EK = 6.17, X_E = 6.27;  // Innenkante Ostwand Küche / Wohnzimmer\nconst Z_SCH0 = 2.54, Z_SCH1 = 3.31; // Schacht Nord-/Südkante\nconst Z_BF = 3.13;              // Wandmitte Bad | Flur\nconst Z_SP = 4.40;              // Wandmitte Küche/Flur | Wohn-/Schlafzimmer\nconst Z_S = 8.49;               // Innenkante Südwand\nconst ZST = Z_SP + TI/2 - TE;   // Außenkante Rücksprung (Treppenhaus)\n// Raum-Innenkanten [x0, z0, x1, z1]\nconst RM_SZ  = [0, Z_SP + TI/2, X_SW - TI/2, Z_S];            // Schlafzimmer 2,61 × 4,04\nconst RM_WZ  = [X_SW + TI/2, Z_SP + TI/2, X_E, Z_S];          // Wohnzimmer 3,56 × 4,04\nconst RM_KU  = [X_BK + TI/2, 0, X_EK, Z_SP - TI/2];           // Küche 2,83 × 4,35\nconst RM_BAD = [X_FL, 0, X_BK - TI/2, Z_BF - TI/2];           // Bad 2,03 × 3,08\nconst RM_FL  = [X_FL, Z_BF + TI/2, X_FK - TI/2, Z_SP - TI/2]; // Flur 2,32 × 1,17\nconst BAD_DOOR = { c: 1.70, w: 0.75 }, SZ_DOOR = { c: 1.74, w: 0.83 }, WZ_DOOR = { c: 4.85, w: 0.83 };\nconst KU_WIN = { c: RM_KU[0] + 0.48 + 0.325, w: 0.65 }, KU_DOOR = { c: RM_KU[0] + 0.48 + 0.65 + 0.12 + 0.425, w: 0.85 };\n\n// Außenwände\nwall('aussen_nord', X_FL - TE, X_E + TE, -TE/2, true, TE, H, [\n  { c: 2.25, w: 0.8, type:'window', name:'fenster_bad' },\n  // Küche: Fenster + Balkontür als Einheit\n  { ...KU_WIN, type:'window', name:'fenster_kueche' },\n  { ...KU_DOOR, type:'glassdoor', name:'balkontuer' },\n], 5, [true, true]);\nwall('aussen_sued', -TE, X_E + TE, Z_S + TE/2, true, TE, H, [\n  { c: 0.94, w: 0.7, type:'window', name:'fenster_schlafzimmer' },\n  { c: 3.37, w: 0.7, type:'window', name:'fenster_wohnzimmer_1' },\n  { c: 5.42, w: 0.7, type:'window', name:'fenster_wohnzimmer_2' },\n], 4, [true, true]);\nwall('aussen_west_schlafzimmer', Z_SP + TI/2, Z_S, -TE/2, false, TE, H, [], 1);\nwall('aussen_nord_schlafzimmer', -TE, X_FL, ZST + TE/2, true, TE, H, [], 5, [true, false]);\nwall('aussen_west', 0, ZST, X_FL - TE/2, false, TE, H, [\n  { c: (Z_BF + Z_SP)/2, w: DOOR_W, type:'door', open: -35, name:'wohnungstuer' },\n], 1);\n// Ostfassade außen gerade; Küchenwand innen 10 cm dicker (Scan)\nwall('aussen_ost_kueche', 0, Z_SP, (X_EK + X_E + TE)/2, false, X_E + TE - X_EK, H, [], 0);\nwall('aussen_ost', Z_SP, Z_S, X_E + TE/2, false, TE, H, [], 0);\n// Innenwände\nwall('innen_bad_kueche', 0, Z_SCH0, X_BK, false, TI, HI);\nwall('innen_bad_flur', X_FL, X_SCH, Z_BF, true, TI, HI, [\n  { ...BAD_DOOR, type:'door', open: 80, name:'tuer_bad' },\n]);\nwall('innen_flur_kueche', Z_SCH1, Z_SP - TI/2, X_FK, false, TI, HI, [\n  { c: 3.78, w: 0.86, type:'door', open: -70, name:'tuer_kueche' },\n]);\nwall('innen_mitte', X_FL, X_E, Z_SP, true, TI, HI, [\n  { ...SZ_DOOR, type:'door', open: 55, flip:true, name:'tuer_schlafzimmer' },\n  { ...WZ_DOOR, type:'door', open: 65, flip:true, name:'tuer_wohnzimmer' },\n]);\nwall('innen_schlafen_wohnen', Z_SP + TI/2, Z_S, X_SW, false, TI, HI);\n// Schacht zwischen Bad, Flur und Küche (Scan: Hohlraum 56 × 145 cm ohne Wand zur Küche → als geschlossen angenommen)\n{ const m = Array(6).fill(M.wall); m[2] = M.cap; walls.add(box('schacht', m, X_SCH, 0, Z_SCH0, X_FK + TI/2, HI, Z_SCH1, 1.5)); }\n\n// ---------- Boden, Sockel, Balkon ----------\nconst OUTLINE = [[X_FL - TE/2, -TE/2], [X_E + TE/2, -TE/2], [X_E + TE/2, Z_S + TE/2], [-TE/2, Z_S + TE/2], [-TE/2, ZST + TE/2], [X_FL - TE/2, ZST + TE/2]];\nconst floorGeo = new THREE.ShapeGeometry(new THREE.Shape(OUTLINE.map(([x, z]) => new THREE.Vector2(x, -z))));\nfloorGeo.rotateX(-Math.PI/2); floorGeo.translate(0, 0.002, 0);\nworldUV(floorGeo, 1.0);\nconst floor = new THREE.Mesh(floorGeo, M.floor); floor.name = 'boden_wood_floor';\nhome.add(floor);\nhome.add(box('sockel_nord', M.plinth, X_FL - TE - 0.05, -0.12, -TE - 0.05, X_E + TE + 0.05, 0, ZST - 0.05));\nhome.add(box('sockel_sued', M.plinth, -TE - 0.05, -0.12, ZST - 0.05, X_E + TE + 0.05, 0, Z_S + TE + 0.05));\n// Balkon über die ganze Küchenbreite, 2,26 m tief (Scan); Brüstungen statt der gescannten Wände\nconst PH = 1.0, PT = 0.08;\nconst BX0 = RM_KU[0] - PT, BX1 = RM_KU[2] + PT, BZ1 = -TE, BZ0 = BZ1 - 2.26 - PT;\nhome.add(box('balkon_platte', M.balcony, BX0, -0.12, BZ0, BX1, 0.02, BZ1));\nhome.add(box('balkon_bruestung_w', M.wall, BX0, 0.02, BZ0, BX0+PT, PH, BZ1, 1.5));\nhome.add(box('balkon_bruestung_o', M.wall, BX1-PT, 0.02, BZ0, BX1, PH, BZ1, 1.5));\nhome.add(box('balkon_bruestung_n', M.wall, BX0+PT, 0.02, BZ0, BX1-PT, PH-0.002, BZ0+PT, 1.5));\n\n// ---------- Wohnzimmer (Raum Süd-Ost) ----------\nconst wohn = new THREE.Group(); wohn.name = 'wohnzimmer';\nconst IN_O = X_E, IN_S = Z_S, WZ_CX = (RM_WZ[0] + RM_WZ[2])/2, SOFA_Z = Z_S - 1.745;   // Innenkanten Ost-/Südwand\n// Sofa an der Ostwand, Rücken zur Wand\nconst sofa = buildSofa(THREE);\nsofa.group.position.set(IN_O - sofa.D/2 - 0.03, 0.002, SOFA_Z);\nsofa.group.rotation.y = -Math.PI/2;\nwohn.add(sofa.group);\n// 3 Regale nebeneinander unter dem Südfenster, Front zum Raum\nconst RM = regalMaterials(THREE);\nfor (const [i, dx] of [[1,-0.603],[2,0],[3,0.603]]){\n  const r = buildRegal(THREE, RM); r.name = 'regal_'+i;\n  r.position.set(WZ_CX + dx, 0.002, IN_S - 0.135 - 0.02);\n  r.rotation.y = Math.PI;\n  wohn.add(r);\n}\n// Boxen oben auf den äußeren Regalen, leicht nach innen gedreht\n{\n  const bx = buildBoxen(THREE), top = new THREE.Box3().setFromObject(wohn.getObjectByName('regal_1')).max.y;\n  const TURN = THREE.MathUtils.degToRad(15), X = 0.603 + 0.30 - 0.105, Z = IN_S - 0.135 - 0.02;\n  // Aktivbox links (–x), Bedienfeld zeigt nach außen\n  bx.rechts.position.set(WZ_CX - X, top, Z); bx.rechts.rotation.y = Math.PI - TURN;\n  bx.links.position.set(WZ_CX + X, top, Z);  bx.links.rotation.y = Math.PI + TURN;\n  wohn.add(bx.links, bx.rechts);\n}\n// Bogenlampe in der Fensterecke, Schirm über dem Sofa – zur Raummitte versetzt\nconst lampe = buildLampe(THREE);\nconst LB = new THREE.Vector2(IN_O - 0.22, IN_S - 0.25);\nconst LT = new THREE.Vector2(IN_O - 0.95, SOFA_Z + 0.25);\nlampe.group.position.set(LB.x, 0.002, LB.y);\nlampe.group.rotation.y = Math.atan2(-(LT.y - LB.y), LT.x - LB.x);\nwohn.add(lampe.group);\n// Donut-Lampe (Ø 30 cm, H 11 cm) im linken Regal, mittleres Fach, mittig\nconst DM = {\n  koerper: new THREE.MeshPhysicalMaterial({ name:'donut_opal_orange', color:0xffa04a, roughness:0.6, clearcoat:0.2, clearcoatRoughness:0.5, emissive:0xff8a2a, emissiveIntensity:0 }),\n  sockel:  new THREE.MeshStandardMaterial({ name:'donut_sockel', color:0xee6a3e, roughness:0.5, emissive:0xd04a20, emissiveIntensity:0 }),\n  knopf:   new THREE.MeshStandardMaterial({ name:'donut_knopf', color:0x9a6a58, roughness:0.45 }),\n};\nconst donut = new THREE.Group(); donut.name = 'donutlampe';\n{\n  const V2 = (x,y) => new THREE.Vector2(x,y), dm = (n,g,m,y=0) => { const o = new THREE.Mesh(g,m); o.name = n; o.position.y = y; donut.add(o); };\n  const SB_R = 0.12, SB_H = 0.018, sp = [V2(0,0), V2(SB_R-0.006,0)];\n  for (let i = 0; i <= 12; i++){ const a = -Math.PI/2 + i/12*Math.PI; sp.push(V2(SB_R-0.006+Math.cos(a)*0.006, 0.006+Math.sin(a)*0.006+(i>6?(SB_H-0.012)*(i-6)/6:0))); }\n  sp.push(V2(0, SB_H));\n  dm('donut_sockel', new THREE.LatheGeometry(sp, 96), DM.sockel);\n  const R = 0.085, A = 0.065, B = 0.0475, CY = 0.0625, sg = v => Math.sign(v)*Math.pow(Math.abs(v), 0.8), kp = [V2(0,0.015)];\n  for (let i = 0; i <= 60; i++){ const t = -Math.PI/2 + i/60*1.35*Math.PI; kp.push(V2(R+A*sg(Math.cos(t)), CY+B*sg(Math.sin(t)))); }\n  kp.push(V2(0.018,0.078), V2(0.008,0.0755), V2(0,0.075));\n  dm('donut_koerper', new THREE.LatheGeometry(kp, 128), DM.koerper);\n  dm('donut_knopf', new THREE.CylinderGeometry(0.02, 0.022, 0.004, 40), DM.knopf, 0.077);\n}\ndonut.position.set(WZ_CX - 0.603, 0.002 + 0.42, IN_S - 0.135 - 0.02);\nwohn.add(donut);\n// Fernseher (43\") auf zwei Sofa-Kartons an der Westwand, gegenüber dem Sofa\n{\n  const tv = new THREE.Group(); tv.name = 'fernseher';\n  const K = new THREE.MeshStandardMaterial({ name:'karton', color:0xa9825a, roughness:0.9 });\n  const KT = new THREE.MeshStandardMaterial({ name:'karton_druck', color:0x3a2d22, roughness:0.9 });\n  const TVM = new THREE.MeshStandardMaterial({ name:'tv_gehaeuse', color:0x141416, roughness:0.45, metalness:0.2 });\n  const SCR = new THREE.MeshPhysicalMaterial({ name:'tv_bildschirm', color:0x050607, roughness:0.08, clearcoat:1, clearcoatRoughness:0.05 });\n  const FT = new THREE.MeshStandardMaterial({ name:'tv_fuss', color:0x9a9ea3, roughness:0.35, metalness:0.7 });\n  const x0 = RM_WZ[0] + 0.02, zc = SOFA_Z, KW = 1.15, KD = 0.5, KH = 0.38;\n  tv.add(box('karton_unten', K, x0, 0.002, zc - KW/2, x0 + KD, KH, zc + KW/2));\n  tv.add(box('karton_oben', K, x0 + 0.01, KH, zc - KW/2 + 0.015, x0 + KD + 0.005, 2*KH, zc + KW/2 + 0.01));\n  for (const y of [0.3, 0.3 + KH]) tv.add(box('karton_aufdruck', KT, x0 + KD + 0.004, y - 0.02, zc - 0.25, x0 + KD + 0.007, y, zc + 0.25));\n  const top = 2*KH, xb = x0 + 0.24, tw = 0.97, th = 0.57, fh = 0.07;\n  tv.add(box('tv_rahmen', TVM, xb, top + fh, zc - tw/2, xb + 0.045, top + fh + th, zc + tw/2));\n  tv.add(box('tv_bildschirm', SCR, xb + 0.045, top + fh + 0.012, zc - tw/2 + 0.012, xb + 0.047, top + fh + th - 0.012, zc + tw/2 - 0.012));\n  tv.add(box('tv_rueckseite', TVM, xb - 0.04, top + fh + 0.08, zc - 0.3, xb, top + fh + 0.45, zc + 0.3));\n  for (const s of [-1, 1]){\n    const f = box('tv_fuss', FT, -0.09, 0, -0.012, 0.09, 0.012, 0.012); f.position.set(xb + 0.02, top, zc + s*0.41); f.rotation.y = s*0.5; tv.add(f);\n    tv.add(box('tv_fuss_steg', FT, xb + 0.01, top, zc + s*0.41 - 0.01, xb + 0.03, top + fh, zc + s*0.41 + 0.01));\n  }\n  tv.add(box('receiver', TVM, xb + 0.06, top, zc - 0.28, xb + 0.2, top + 0.03, zc - 0.06));\n  tv.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\n  wohn.add(tv);\n}\nwohn.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\nhome.add(wohn);\n// ---------- Schlafzimmer: Tripod-Lampe auf dem Boden, Südwest-Ecke, Spot zur Raummitte ----------\nconst trip = buildTripod(THREE);\n{\n  const IN_W = RM_SZ[0], px = IN_W + 0.35, pz = IN_S - 0.35;\n  const cx = (RM_SZ[0] + RM_SZ[2])/2, cz = (RM_SZ[1] + RM_SZ[3])/2;\n  trip.group.position.set(px, 0.002, pz);\n  trip.group.rotation.y = Math.atan2(cx - px, cz - pz);\n  home.add(trip.group);\n}\n\n\n// ---------- Schlafzimmer: Bett (140 × 200, Kopfteil Ostwand, rechts an der Südwand) + Schminktisch ----------\n{\n  const sz = new THREE.Group(); sz.name = 'schlafzimmer_moebel';\n  const add = m => { sz.add(m); return m; };\n  const LE = new THREE.MeshStandardMaterial({ name:'bett_kunstleder', color:0xeee8dc, roughness:0.55 });\n  const SH = new THREE.MeshStandardMaterial({ name:'spannbetttuch', color:0x67696e, roughness:0.95 });\n  const DE = new THREE.MeshStandardMaterial({ name:'kuscheldecke', color:0x58585b, roughness:1 });\n  const KI = new THREE.MeshStandardMaterial({ name:'kissen', color:0xf4f3ef, roughness:0.9 });\n  const LK = new THREE.MeshPhysicalMaterial({ name:'lack_weiss_hochglanz', color:0xf6f6f4, roughness:0.15, clearcoat:0.8, clearcoatRoughness:0.1 });\n  const SP = new THREE.MeshStandardMaterial({ name:'spiegel_schminktisch', color:0xdfe5e8, roughness:0.03, metalness:1 });\n  const BU = new THREE.MeshStandardMaterial({ name:'spiegel_birne', color:0xffffff, roughness:0.3, emissive:0xfff1d8, emissiveIntensity:0.15 });\n  const E = RM_SZ[2], S = RM_SZ[3];\n  // Bett\n  const HB = 0.1, bx0 = E - HB - 2.0, bz0 = S - 1.46, bz1 = S - 0.01;\n  add(box('bett_sockel', M.plinth, bx0 + 0.06, 0, bz0 + 0.06, E - HB - 0.06, 0.06, bz1 - 0.06));\n  add(box('bett_rahmen', LE, bx0, 0.06, bz0, E - HB, 0.36, bz1));\n  add(box('bett_matratze', SH, bx0 + 0.02, 0.36, bz0 + 0.03, E - HB - 0.01, 0.56, bz1 - 0.03));\n  add(box('bett_kopfteil', LE, E - HB, 0.06, bz0, E - 0.002, 1.12, bz1));\n  add(box('bett_kopfteil_ablage', LE, E - HB - 0.05, 1.04, bz0, E - 0.002, 1.12, bz1));\n  for (const y of [0.72, 0.86, 1.0]) for (let i = 0; i < 11; i++){\n    const b = new THREE.Mesh(new THREE.SphereGeometry(0.009, 10, 8), LE); b.name = 'bett_knopf';\n    b.position.set(E - HB - 0.002, y, bz0 + 0.1 + i*(bz1 - bz0 - 0.2)/10 + (y === 0.86 ? 0.06 : 0)); if (b.position.z < bz1 - 0.05) add(b);\n  }\n  const pil = add(new THREE.Mesh(new THREE.SphereGeometry(1, 32, 16), KI)); pil.name = 'kopfkissen';\n  pil.scale.set(0.2, 0.07, 0.34); pil.position.set(E - HB - 0.24, 0.6, bz0 + 0.5);\n  add(box('decke_oben', DE, bx0 + 0.05, 0.56, bz0 - 0.02, E - HB - 0.5, 0.6, bz1 - 0.02));\n  add(box('decke_seite', DE, bx0 + 0.05, 0.3, bz0 - 0.03, E - HB - 0.5, 0.6, bz0 - 0.01));\n  add(box('decke_fuss', DE, bx0 + 0.03, 0.32, bz0 - 0.02, bx0 + 0.05, 0.6, bz1 - 0.02));\n  // Schminktisch an der Ostwand zwischen Heizkörper und Bett, Schubladen links (Norden)\n  const D = 0.45, x1 = E, x0 = E - D, z0 = RM_SZ[1] + 1.0, z1 = z0 + 1.1, H = 0.76, PW = 0.4, T = 0.018;\n  add(box('schminktisch_platte', LK, x0, H - 0.025, z0, x1, H, z1));\n  add(box('schminktisch_korpus', LK, x0, 0.04, z0, x1, H - 0.025, z0 + PW));\n  add(box('schminktisch_sockel', LK, x0 + 0.02, 0, z0 + 0.02, x1, 0.04, z0 + PW - 0.02));\n  add(box('schminktisch_seite', LK, x0, 0, z1 - T, x1, H - 0.025, z1));\n  add(box('schminktisch_zarge', LK, x0, H - 0.15, z0 + PW, x1, H - 0.025, z1 - T));\n  add(box('schminktisch_rueckwand', LK, x1 - 0.015, 0.04, z0 + PW, x1, H - 0.15, z1 - T));\n  const fronts = [[0.05, 0.215], [0.22, 0.385], [0.39, 0.555], [0.56, H - 0.03]];\n  fronts.forEach(([a, b], i) => add(box('schublade_' + (i+1), LK, x0 - 0.012, a, z0 + 0.004, x0, b, z0 + PW - 0.004)));\n  add(box('schublade_mitte', LK, x0 - 0.012, H - 0.145, z0 + PW + 0.004, x0, H - 0.03, z1 - T - 0.004));\n  // Spiegel mit Glühbirnen, auf der Platte an die Wand gelehnt\n  const mz0 = z0 + 0.17, mz1 = z0 + 0.97, my0 = H, my1 = H + 0.62;\n  const mir = new THREE.Group(); mir.name = 'schminkspiegel';\n  mir.add(box('schminkspiegel_rahmen', LK, -0.035, 0, mz0, 0, my1 - my0, mz1));\n  mir.add(box('schminkspiegel_glas', SP, -0.037, 0.06, mz0 + 0.06, -0.035, my1 - my0 - 0.06, mz1 - 0.06));\n  const bulb = (y, z) => { const b = new THREE.Mesh(new THREE.SphereGeometry(0.021, 16, 12), BU); b.name = 'schminkspiegel_birne'; b.position.set(-0.045, y, z); mir.add(b); };\n  for (let i = 0; i < 8; i++) bulb(my1 - my0 - 0.03, mz0 + 0.04 + i*(mz1 - mz0 - 0.08)/7);\n  for (let i = 1; i < 5; i++){ const y = my1 - my0 - 0.03 - i*0.13; bulb(y, mz0 + 0.035); bulb(y, mz1 - 0.035); }\n  mir.position.set(x1 - 0.1, my0, 0); mir.rotation.z = -0.08; sz.add(mir);\n  sz.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\n  home.add(sz);\n}\n// ---------- Mauervorsprung Wohnzimmer (41,5 × 40 cm, Ecke Tür-/Außenwand) ----------\n{\n  const mat = Array(6).fill(M.wall); mat[2] = M.cap;\n  walls.add(box('wohnzimmer_vorsprung', mat, IN_O - 0.415, 0, RM_WZ[1], IN_O + 0.001, HI, RM_WZ[1] + 0.40, 1.5));\n}\n// ---------- Küche: Fliesenspiegel an der Wand zum Bad, ab Fensterunterkante 60 cm hoch ----------\nconst tileMat = new THREE.MeshStandardMaterial({ name:'interior_tiles', color:0xf3f2ee, roughness:0.2 });\n{\n  const x0 = RM_KU[0], z0 = 0, z1 = Z_SCH0;\n  const t = box('kueche_fliesen', tileMat, x0, WIN_B, z0, x0 + 0.008, WIN_B + 0.6, z1, 1.0);\n  // um die Ecke auf die Fensterwand, bis an die Fensterlaibung\n  const winW = KU_WIN.c - KU_WIN.w/2;\n  const t2 = box('kueche_fliesen_fensterwand', tileMat, x0 + 0.008, WIN_B, z0, winW, WIN_B + 0.6, z0 + 0.008, 1.0);\n  t.receiveShadow = t2.receiveShadow = true; home.add(t, t2);\n}\n// ---------- Heizkörper ----------\nconst radMat = new THREE.MeshStandardMaterial({ name:'heizkoerper_weiss', color:0xf4f3ef, roughness:0.4, metalness:0.1 });\nfunction makeRadiator(name, len){\n  const g = new THREE.Group(); g.name = name;\n  const y0 = 0.15, y1 = 0.75, n = Math.max(3, Math.round(len/0.05)), st = len/n;\n  for (let i = 0; i < n; i++){ const x = -len/2 + st*(i+0.5); g.add(box(name+'_glied'+i, radMat, x-st*0.38, y0, -0.035, x+st*0.38, y1, 0.035)); }\n  g.add(box(name+'_sammler_o', radMat, -len/2, y1-0.05, -0.02, len/2, y1-0.01, 0.02));\n  g.add(box(name+'_sammler_u', radMat, -len/2, y0+0.01, -0.02, len/2, y0+0.05, 0.02));\n  const v = new THREE.Mesh(new THREE.CylinderGeometry(0.018, 0.018, 0.08, 20), radMat); v.name = name+'_ventil'; v.position.set(len/2+0.03, y1-0.04, 0); g.add(v);\n  const p = new THREE.Mesh(new THREE.CylinderGeometry(0.01, 0.01, y0, 12), M.metal); p.name = name+'_rohr'; p.position.set(-len/2+0.02, y0/2, 0); g.add(p);\n  g.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\n  return g;\n}\n{\n  // Schlafzimmer: an der Mittelwand, 41–86 cm von der Türwand\n  const h1 = makeRadiator('heizkoerper_schlafzimmer', 0.45);\n  h1.position.set(RM_SZ[2] - 0.075, 0, RM_SZ[1] + 0.41 + 0.225); h1.rotation.y = Math.PI/2;\n  // Wohnzimmer: an der Türwand direkt neben der Tür, Richtung Mittelwand\n  const h2 = makeRadiator('heizkoerper_wohnzimmer', 0.48);\n  h2.position.set(WZ_DOOR.c - WZ_DOOR.w/2 - 0.02 - 0.24, 0, RM_WZ[1] + 0.075);\n  home.add(h1, h2);\n}\n\n// ---------- Bad (nach Foto): Wanne rechts, WC + Waschtisch links, Fliesen ----------\n{\n  const bad = new THREE.Group(); bad.name = 'bad';\n  const [W, N, E, SZ] = RM_BAD, TT = 0.008, SCX = X_SCH, SCZ = Z_SCH0;\n  const add = m => { bad.add(m); return m; };\n  const bx = (n, mat, ...a) => add(box(n, mat, ...a));\n  function cyl(n, mat, r, h, x, y, z, axis, r2){\n    const m = new THREE.Mesh(new THREE.CylinderGeometry(r, r2 ?? r, h, 28), mat); m.name = n; m.position.set(x, y, z);\n    if (axis === 'x') m.rotation.z = Math.PI/2; if (axis === 'z') m.rotation.x = Math.PI/2; return add(m);\n  }\n  function tileTex(px, n, base, grout, veins, seed){\n    const c = document.createElement('canvas'); c.width = c.height = px*n; const g = c.getContext('2d');\n    g.fillStyle = base; g.fillRect(0, 0, c.width, c.height);\n    const rnd = () => (seed = (seed*16807) % 2147483647) / 2147483647;\n    g.lineWidth = 1.4;\n    for (let i = 0; i < veins; i++){\n      g.strokeStyle = 'rgba(125,127,132,' + (0.05 + rnd()*0.07) + ')'; g.beginPath();\n      let x = rnd()*c.width, y = rnd()*c.height; g.moveTo(x, y);\n      for (let k = 0; k < 4; k++){ const cx = x + (rnd()-.5)*px, cy = y + (rnd()-.5)*px; x += (rnd()-.5)*px*1.3; y += (rnd()-.5)*px*1.3; g.quadraticCurveTo(cx, cy, x, y); }\n      g.stroke();\n    }\n    g.fillStyle = grout; const gw = Math.max(3, px/32);\n    for (let i = 0; i < n; i++){ g.fillRect(i*px, 0, gw, c.height); g.fillRect(0, i*px, c.width, gw); }\n    const t = new THREE.CanvasTexture(c); t.wrapS = t.wrapT = THREE.RepeatWrapping; t.colorSpace = THREE.SRGBColorSpace; t.anisotropy = 8; return t;\n  }\n  const BM = {\n    wand:   new THREE.MeshStandardMaterial({ name:'bad_wandfliesen', map: tileTex(128, 4, '#f3f3f1', '#c6c6c2', 46, 11), roughness:0.16 }),\n    boden:  new THREE.MeshStandardMaterial({ name:'bad_bodenfliesen', map: tileTex(128, 4, '#efeeeb', '#a6a5a0', 34, 29), roughness:0.32 }),\n    email:  new THREE.MeshPhysicalMaterial({ name:'sanitaer_email', color:0xfbfbfa, roughness:0.1, clearcoat:1, clearcoatRoughness:0.06 }),\n    chrom:  new THREE.MeshStandardMaterial({ name:'chrom', color:0xe6e8ea, roughness:0.08, metalness:1 }),\n    spiegel:new THREE.MeshStandardMaterial({ name:'spiegel', color:0xe2e8ec, roughness:0.02, metalness:1 }),\n    glas:   new THREE.MeshStandardMaterial({ name:'glasablage', color:0xcfe6e0, roughness:0.05, transparent:true, opacity:0.45 }),\n    dekor:  new THREE.MeshStandardMaterial({ name:'dekorfliese', color:0x9fb0c2, roughness:0.2 }),\n    plast:  new THREE.MeshStandardMaterial({ name:'wc_sitz', color:0xf7f7f5, roughness:0.3 }),\n  };\n  const emailIn = BM.email.clone(); emailIn.name = 'sanitaer_email_innen'; emailIn.side = THREE.BackSide;\n  const emailDS = BM.email.clone(); emailDS.name = 'sanitaer_email_ds'; emailDS.side = THREE.DoubleSide;\n  // Milchglas im Badfenster\n  const fg = windows.getObjectByName('fenster_bad_glas');\n  if (fg) fg.material = new THREE.MeshStandardMaterial({ name:'milchglas', color:0xf2f5f5, roughness:0.7, transparent:true, opacity:0.85 });\n\n  // Boden + Wandfliesen (halbhoch 1,25 m, um die Wanne 2,05 m)\n  const HT = 1.25, FT = 2.05;\n  const TW = 0.78, TL = 1.75, LEDGE = 0.2, TX0 = E - TW, TZ1 = N + LEDGE + TL;\n  const wxc = 2.25, wl = wxc - 0.4, wr = wxc + 0.4, dxc = BAD_DOOR.c, DW = BAD_DOOR.w;\n  // Vorwand an der Fensterwand: von der Westwand bis ans Fenster, 15 cm vorgezogen\n  const VD = 0.15;\n  { const vm = Array(6).fill(M.wall); vm[2] = M.cap; walls.add(box('bad_vorwand', vm, W, 0, N, wl, HI, N + VD, 1.5)); }\n  bx('bad_boden', BM.boden, W, 0, N, E, 0.008, SZ, 0.8);\n  bx('bad_fliesen_west', BM.wand, W, 0, N + VD + TT, W + TT, HT, SZ, 0.6);\n  bx('bad_fliesen_vorwand', BM.wand, W, 0, N + VD, wl, HT, N + VD + TT, 0.6);\n  bx('bad_fliesen_vorwand_seite', BM.wand, wl - 0.001, 0, N, wl + TT, HT, N + VD + TT, 0.6);\n  bx('bad_fliesen_nord_2', BM.wand, wl, 0, N, wr, WIN_B - 0.03, N + TT, 0.6);\n  bx('bad_fliesen_nord_3', BM.wand, wr, 0, N, E - TT, FT, N + TT, 0.6);\n  bx('bad_fliesen_ost_1', BM.wand, E - TT, 0, N, E, FT, TZ1, 0.6);\n  bx('bad_fliesen_ost_2', BM.wand, E - TT, 0, TZ1, E, HT, SCZ, 0.6);\n  bx('bad_fliesen_schacht_n', BM.wand, SCX - TT, 0, SCZ - TT, E - TT, HT, SCZ, 0.6);\n  bx('bad_fliesen_schacht_w', BM.wand, SCX - TT, 0, SCZ, SCX, HT, SZ, 0.6);\n  bx('bad_fliesen_sued_1', BM.wand, W + TT, 0, SZ - TT, dxc - DW/2, HT, SZ, 0.6);\n  bx('bad_fliesen_sued_2', BM.wand, dxc + DW/2, 0, SZ - TT, SCX - TT, HT, SZ, 0.6);\n  for (const [y, z] of [[1.15, N + 0.75], [1.72, N + 0.55]]){\n    const d = bx('bad_dekorfliese', BM.dekor, -0.001, -0.04, -0.04, 0.001, 0.04, 0.04);\n    d.rotation.x = Math.PI/4; d.position.set(E - TT - 0.001, y, z);\n  }\n\n  // Badewanne, eingefliest, mit Ablage am Kopfende\n  bx('wanne_ablage', BM.wand, TX0, 0.008, N + TT, E - TT, 0.6, N + LEDGE, 0.6);\n  bx('wanne_schuerze', BM.wand, TX0, 0.008, N + LEDGE, TX0 + 0.03, 0.565, TZ1, 0.6);\n  bx('wanne_schuerze_ende', BM.wand, TX0, 0.008, TZ1 - 0.03, E - TT, 0.565, TZ1, 0.6);\n  function rr(p, w, d, r){ const x = -w/2, y = -d/2;\n    p.moveTo(x + r, y); p.lineTo(x + w - r, y); p.quadraticCurveTo(x + w, y, x + w, y + r); p.lineTo(x + w, y + d - r);\n    p.quadraticCurveTo(x + w, y + d, x + w - r, y + d); p.lineTo(x + r, y + d); p.quadraticCurveTo(x, y + d, x, y + d - r);\n    p.lineTo(x, y + r); p.quadraticCurveTo(x, y, x + r, y); return p; }\n  const tcx = E - TT/2 - TW/2 + TT/2, tcz = N + LEDGE + TL/2, IW = TW - 0.14, IL = TL - 0.18, IR = 0.22;\n  const rimS = rr(new THREE.Shape(), TW - TT, TL, 0.02); rimS.holes.push(rr(new THREE.Path(), IW, IL, IR));\n  const rimG = new THREE.ExtrudeGeometry(rimS, { depth:0.035, bevelEnabled:false, curveSegments:16 });\n  rimG.rotateX(-Math.PI/2); rimG.translate(tcx, 0.565, tcz);\n  add(new THREE.Mesh(rimG, BM.email)).name = 'wanne_rand';\n  const basG = new THREE.ExtrudeGeometry(rr(new THREE.Shape(), IW, IL, IR), { depth:0.41, bevelEnabled:false, curveSegments:16 });\n  basG.rotateX(-Math.PI/2); basG.translate(tcx, 0.16, tcz);\n  add(new THREE.Mesh(basG, emailIn)).name = 'wanne_innen';\n  const mz0 = TZ1 - 0.35;\n  cyl('wanne_ablauf', BM.chrom, 0.024, 0.004, tcx, 0.163, mz0 - 0.05);\n  // Wannenarmatur an der Ostwand\n  cyl('armatur_koerper', BM.chrom, 0.024, 0.2, E - 0.075, 0.8, mz0, 'z');\n  for (const s of [-1, 1]){\n    cyl('armatur_anschluss', BM.chrom, 0.01, 0.075, E - 0.04, 0.8, mz0 + s*0.08, 'x');\n    cyl('armatur_rosette', BM.chrom, 0.03, 0.008, E - TT - 0.004, 0.8, mz0 + s*0.08, 'x');\n  }\n  cyl('armatur_auslauf', BM.chrom, 0.012, 0.11, E - 0.135, 0.775, mz0, 'x');\n  bx('armatur_hebel', BM.chrom, E - 0.085, 0.82, mz0 - 0.012, E - 0.03, 0.835, mz0 + 0.012);\n  // Duschstange + Handbrause + Schlauch\n  const rz = TZ1 - 0.85, rx = E - 0.045;\n  cyl('duschstange', BM.chrom, 0.012, 0.95, rx, 1.6, rz);\n  for (const y of [1.13, 2.07]){ cyl('duschstange_halter', BM.chrom, 0.01, 0.045, E - 0.022, y, rz, 'x'); cyl('duschstange_rosette', BM.chrom, 0.022, 0.01, E - TT - 0.005, y, rz, 'x'); }\n  bx('duschstange_schieber', BM.chrom, rx - 0.035, 1.68, rz - 0.022, rx + 0.02, 1.76, rz + 0.022);\n  const brause = new THREE.Group(); brause.name = 'handbrause'; brause.position.set(rx - 0.06, 1.72, rz); brause.rotation.z = 0.5;\n  { const h = new THREE.Mesh(new THREE.CylinderGeometry(0.013, 0.011, 0.2, 20), BM.chrom); h.name = 'handbrause_griff'; brause.add(h);\n    const k = new THREE.Mesh(new THREE.CylinderGeometry(0.045, 0.03, 0.025, 32), BM.chrom); k.name = 'handbrause_kopf'; k.position.y = 0.11; k.rotation.z = Math.PI/2 - 0.3; brause.add(k); }\n  add(brause);\n  const hb0 = new THREE.Vector3(rx - 0.06 + 0.1*Math.sin(0.5), 1.72 - 0.1*Math.cos(0.5), rz);\n  const hose = new THREE.CatmullRomCurve3([hb0, new THREE.Vector3(E - 0.09, 1.2, rz + 0.08), new THREE.Vector3(E - 0.2, 0.7, (rz + mz0)/2 + 0.05), new THREE.Vector3(E - 0.12, 0.66, mz0 - 0.02), new THREE.Vector3(E - 0.085, 0.77, mz0 - 0.03)]);\n  add(new THREE.Mesh(new THREE.TubeGeometry(hose, 80, 0.007, 8), BM.chrom)).name = 'brauseschlauch';\n  // Haltegriff\n  const gz = TZ1 - 0.6;\n  cyl('haltegriff', BM.chrom, 0.013, 0.36, E - 0.065, 1.12, gz);\n  for (const y of [0.96, 1.28]) cyl('haltegriff_stuetze', BM.chrom, 0.012, 0.06, E - 0.035, y, gz, 'x');\n  // Vorhangstange oben\n  cyl('vorhangstange', BM.chrom, 0.01, TL - 0.2, E - 0.09, 2.15, N + LEDGE + TL/2 - 0.1, 'z');\n  cyl('vorhangstange_halter', BM.chrom, 0.009, 0.09, E - 0.045, 2.15, N + LEDGE + 0.05, 'x');\n\n  // WC an der Westwand (Blick zur Wanne), Aufputz-Spülkasten\n  const wc = new THREE.Group(); wc.name = 'wc'; wc.position.set(W + TT, 0, N + VD + 0.45); wc.rotation.y = Math.PI/2;\n  { const wa = m => { wc.add(m); return m; };\n    wa(box('wc_sockel_hinten', BM.email, -0.13, 0.008, 0, 0.13, 0.38, 0.22));\n    const p = new THREE.Mesh(new THREE.CylinderGeometry(0.15, 0.115, 0.32, 40), BM.email); p.name = 'wc_fuss'; p.scale.z = 1.3; p.position.set(0, 0.168, 0.37); wa(p);\n    const b = new THREE.Mesh(new THREE.CylinderGeometry(0.185, 0.15, 0.08, 48), BM.email); b.name = 'wc_becken'; b.scale.z = 1.3; b.position.set(0, 0.365, 0.41); wa(b);\n    const s = new THREE.Mesh(new THREE.CylinderGeometry(0.185, 0.185, 0.02, 48), BM.plast); s.name = 'wc_sitz'; s.scale.z = 1.3; s.position.set(0, 0.415, 0.41); wa(s);\n    const d = new THREE.Mesh(new THREE.CylinderGeometry(0.178, 0.178, 0.022, 48), BM.plast); d.name = 'wc_deckel'; d.scale.z = 1.28; d.position.set(0, 0.436, 0.41); wa(d);\n    wa(box('wc_scharnier', BM.plast, -0.1, 0.405, 0.15, 0.1, 0.44, 0.2));\n    wa(box('wc_spuelkasten', BM.email, -0.2, 0.8, 0, 0.2, 1.2, 0.15));\n    const t = new THREE.Mesh(new THREE.CylinderGeometry(0.02, 0.02, 0.02, 28), BM.email); t.name = 'wc_spueltaste'; t.position.set(-0.12, 1.21, 0.09); wa(t);\n    const r = new THREE.Mesh(new THREE.CylinderGeometry(0.025, 0.025, 0.4, 28), BM.email); r.name = 'wc_spuelrohr'; r.position.set(0, 0.6, 0.08); wa(r); }\n  add(wc);\n  // Wasserzähler + Ventil an der Vorwand, Papierhalter unter dem Fenster\n  cyl('bad_wasserzaehler', BM.chrom, 0.055, 0.03, wl - 0.13, 0.98, N + VD + TT + 0.015, 'z');\n  cyl('bad_wasserzaehler_glas', BM.plast, 0.035, 0.034, wl - 0.13, 0.98, N + VD + TT + 0.017, 'z');\n  cyl('bad_ventil', BM.chrom, 0.028, 0.05, wl - 0.13, 1.2, N + VD + TT + 0.025, 'z');\n  bx('papierhalter', BM.chrom, wxc - 0.02, 0.62, N + TT, wxc + 0.12, 0.7, N + 0.08);\n\n  // Waschtisch an der Westwand, Spiegel + Glasablagen darüber\n  const bz = N + 1.35, BR = 0.3, SX = 0.87, RY = 0.85, bcx = W + 0.2;\n  { const o = new THREE.Mesh(new THREE.CylinderGeometry(BR, 0.2, 0.17, 48, 1, true), emailDS); o.name = 'waschbecken_aussen'; o.scale.x = SX; o.position.set(bcx, RY - 0.085, bz); add(o);\n    const f = new THREE.Mesh(new THREE.CircleGeometry(0.2, 48), BM.email); f.name = 'waschbecken_unten'; f.rotation.x = Math.PI/2; f.scale.x = SX; f.position.set(bcx, RY - 0.17, bz); add(f);\n    const r = new THREE.Mesh(new THREE.RingGeometry(0.235, BR, 48), BM.email); r.name = 'waschbecken_rand'; r.rotation.x = -Math.PI/2; r.scale.x = SX; r.position.set(bcx, RY, bz); add(r);\n    const i = new THREE.Mesh(new THREE.SphereGeometry(0.235, 48, 16, 0, Math.PI*2, Math.PI/2, Math.PI/2), emailDS); i.name = 'waschbecken_innen'; i.scale.set(SX, 0.55, 1); i.position.set(bcx, RY, bz); add(i); }\n  cyl('waschtisch_armatur', BM.chrom, 0.022, 0.12, W + 0.075, RY + 0.06, bz);\n  { const s = cyl('waschtisch_auslauf', BM.chrom, 0.011, 0.13, W + 0.13, RY + 0.1, bz, 'x'); s.rotation.z = Math.PI/2 + 0.25; }\n  bx('waschtisch_hebel', BM.chrom, W + 0.04, RY + 0.12, bz - 0.012, W + 0.1, RY + 0.135, bz + 0.012);\n  cyl('siphon', BM.chrom, 0.02, 0.2, bcx, 0.58, bz);\n  cyl('siphon_rohr', BM.chrom, 0.018, 0.2, W + 0.1, 0.48, bz, 'x');\n  cyl('siphon_rosette', BM.chrom, 0.035, 0.01, W + TT + 0.005, 0.48, bz, 'x');\n  bx('spiegel', BM.spiegel, W + TT, 1.34, bz - 0.3, W + TT + 0.006, 2.0, bz + 0.3);\n  for (const y of [1.3, 1.05]){\n    bx('glasablage', BM.glas, W + TT, y, bz - 0.3, W + 0.14, y + 0.008, bz + 0.3);\n    for (const s of [-1, 1]) bx('glasablage_halter', BM.chrom, W + TT, y - 0.012, bz + s*0.3 - 0.012, W + 0.06, y + 0.016, bz + s*0.3 + 0.012);\n  }\n\n  bad.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\n  bad.getObjectByName('bad_boden').castShadow = false;\n  home.add(bad);\n}\n\n\nstage.setObject(home);\n\n// ---------- Schatten: enger Frustum, 4096er Map, harter PCF → scharf & ohne Flackern ----------\nconst renderer = stage._renderer, scene = stage._scene, key = stage._key;\nrenderer.shadowMap.type = THREE.PCFShadowMap;\nconst hb = new THREE.Box3().setFromObject(home), hc = hb.getCenter(new THREE.Vector3()), hs = hb.getSize(new THREE.Vector3());\nconst sunDir = new THREE.Vector3(4, 7, 5).normalize();\nkey.position.copy(hc).addScaledVector(sunDir, 30);\nkey.target.position.copy(hc); scene.add(key.target);\nconst half = Math.max(hs.x, hs.z) * 0.62;\nObject.assign(key.shadow.camera, { left:-half, right:half, top:half, bottom:-half, near:1, far:60 });\nkey.shadow.camera.updateProjectionMatrix();\nkey.shadow.mapSize.set(2048, 2048);\nkey.shadow.bias = -0.0004; key.shadow.normalBias = 0.015;\nif (key.shadow.map){ key.shadow.map.dispose(); key.shadow.map = null; }\nrenderer.toneMapping = THREE.ACESFilmicToneMapping;\nif (stage._ground) stage._ground.visible = false;\nconst hemi = scene.children.find(o => o.isHemisphereLight), hemiBase = hemi ? hemi.intensity : 0;\nconst fillL = scene.children.find(o => o.isDirectionalLight && o !== key), fillBase = fillL ? fillL.intensity : 0;\nconst ENV = 0.9;\nlet envK = 1, hemiK = 1, fillK = 1, expK = 1;\n// Innenraum: Himmels-/Fülllicht dringt nicht durch die Decke → nur noch Sonne + Umgebung durch die Fenster\nfunction applyInterior(o){\n  if (hemi) hemi.intensity = hemiBase * hemiK * (1 - 0.85*o);\n  if (fillL) fillL.intensity = fillBase * fillK * (1 - o);\n  scene.environmentIntensity = ENV * envK * (1 - 0.7*o);\n  renderer.toneMappingExposure = (1 + 0.45*o) * expK;\n}\n\n// ---------- Decke (blendet ein, sobald man in einem Raum steht) ----------\nconst ceilMat = new THREE.MeshStandardMaterial({ name:'decke', color:0xf4f2ee, roughness:0.95, transparent:true, opacity:0, depthWrite:false });\nconst ceiling = new THREE.Group(); ceiling.name = 'decke';\nceiling.add(box('decke_nord', ceilMat, X_FL - TE, H, -TE, X_E + TE, H+0.04, ZST), box('decke_sued', ceilMat, -TE, H, ZST, X_E + TE, H+0.04, Z_S + TE));\nceiling.traverse(o => { if (o.isMesh){ o.receiveShadow = true; o.castShadow = true; } }); ceiling.visible = false;\nhome.add(ceiling);\nfunction setCeil(o){\n  ceilMat.opacity = o;\n  if (ceiling.visible !== (o > 0.001)){ ceiling.visible = o > 0.001; ptDirty = true; }\n  const solid = o >= 0.999;\n  if (ceilMat.transparent === solid){ ceilMat.transparent = !solid; ceilMat.depthWrite = solid; ceilMat.needsUpdate = true; }\n  if (!ptOn) applyInterior(o);\n}\n\n// ---------- Bogenlampe: Licht an/aus ----------\nhome.updateMatrixWorld(true);\nconst bulb = lampe.group.getObjectByName('leuchtmittel');\nconst bp = bulb.getWorldPosition(new THREE.Vector3());\nconst lampSpot = new THREE.SpotLight(0xffd6a0, 0, 0, 1.0, 0.6, 2);\nlampSpot.position.copy(bp).add(new THREE.Vector3(0, -0.035, 0));\nlampSpot.target.position.set(bp.x, 0, bp.z);\nlampSpot.castShadow = true;\nlampSpot.shadow.mapSize.set(1024, 1024);\nlampSpot.shadow.bias = -0.0005; lampSpot.shadow.normalBias = 0.02;\nlampSpot.shadow.camera.near = 0.05; lampSpot.shadow.camera.far = 8;\nconst lampFill = new THREE.PointLight(0xffd6a0, 0, 7, 2);\nlampFill.position.copy(bp);\nscene.add(lampSpot, lampSpot.target, lampFill);\nconst schirm = lampe.group.getObjectByName('schirm').material;\nschirm.emissive = new THREE.Color(0xffe2b8);\nconst lampBtn = document.getElementById('lamp');\nlet lampOn = false, lampLvl = 0, lampAnim = 0;\nlet rasterEnv = null, ptEnv = null;\nlet tracer = null, ptOn = false, ptDirty = true, inRoom = false, stillSince = 0;\nconst LAMP_KEY = 'wohnung-bogenlampe-farbe';\nlet lampK = 1;\nconst lampSw = document.getElementById('lampSw');\nfunction setLampColor(hex){\n  const c = new THREE.Color(hex), s = c.clone().lerp(new THREE.Color(0xffffff), 0.3);\n  lampSpot.color.copy(c); lampFill.color.copy(c);\n  if (bulb.material.emissive) bulb.material.emissive.copy(c);\n  schirm.emissive.copy(s);\n  try { localStorage.setItem(LAMP_KEY, hex); } catch(e){}\n  document.querySelector('#lamp i').style.cssText = lampOn ? `background:${hex};box-shadow:0 0 10px 3px ${hex}99` : '';\n  if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); }\n}\n// ---------- Licht-Picker: Hell (Lichtton + Helligkeit) oder Farbe (Farbkreis) ----------\nconst K_COLD = 8000, K_WARM = 2000;\nfunction kelvinHex(k){\n  const t = k/100; let r, g, b;\n  if (t <= 66){ r = 255; g = 99.4708025861*Math.log(t) - 161.1195681661; b = t <= 19 ? 0 : 138.5177312231*Math.log(t-10) - 305.0447927307; }\n  else { r = 329.698727446*Math.pow(t-60, -0.1332047592); g = 288.1221695283*Math.pow(t-60, -0.0755148492); b = 255; }\n  const c = v => Math.round(Math.max(0, Math.min(255, v))).toString(16).padStart(2, '0');\n  return '#' + c(r) + c(g) + c(b);\n}\nconst warmK = w => Math.round(K_COLD - w/100*(K_COLD - K_WARM));\nfunction hsvRGB(h, s, v){ const f = n => { const k = (n + h/60) % 6; return v - v*s*Math.max(0, Math.min(k, 4-k, 1)); }; return [f(5), f(3), f(1)]; }\nconst rgbHex = a => '#' + a.map(x => Math.round(x*255).toString(16).padStart(2, '0')).join('');\nfunction makePicker(sw, key, def, dimIn, onChange){\n  let st = { mode: 'white', warm: 70, h: 30, s: 0.6, ...def };\n  try { Object.assign(st, JSON.parse(localStorage.getItem(key) || 'null') || {}); } catch(e){}\n  const pop = document.createElement('div'); pop.className = 'lpick';\n  pop.innerHTML = '<div class=\"lp-seg\"><button data-m=\"white\">Hell<\u002Fbutton><button data-m=\"color\">Farbe<\u002Fbutton><\u002Fdiv>'\n    + '<div class=\"lp-row lp-w\"><div><span>Lichtton<\u002Fspan><output class=\"lp-kv\"><\u002Foutput><\u002Fdiv><input class=\"lp-temp\" type=\"range\" min=\"0\" max=\"100\" step=\"1\"><small><span>Steril<\u002Fspan><span>Warm<\u002Fspan><\u002Fsmall><\u002Fdiv>'\n    + '<div class=\"lp-c\"><div class=\"lp-wheel\"><canvas width=\"360\" height=\"360\"><\u002Fcanvas><i><\u002Fi><\u002Fdiv><\u002Fdiv>'\n    + '<div class=\"lp-row\"><div><span>Helligkeit<\u002Fspan><output class=\"lp-bv\"><\u002Foutput><\u002Fdiv><input class=\"lp-dim\" type=\"range\" min=\"10\" max=\"200\" step=\"5\"><\u002Fdiv><button class=\"lp-done\">Fertig<\u002Fbutton>';\n  document.body.appendChild(pop);\n  const $ = s => pop.querySelector(s), temp = $('.lp-temp'), bri = $('.lp-dim'), bv = $('.lp-bv'), dot = $('.lp-wheel i'), wheel = $('.lp-wheel');\n  temp.style.background = `linear-gradient(90deg,${kelvinHex(K_COLD)},${kelvinHex(4500)},${kelvinHex(3000)},${kelvinHex(K_WARM)})`;\n  const cv = $('canvas'), ctx = cv.getContext('2d'), img = ctx.createImageData(360, 360), R = 180;\n  for (let y = 0; y < 360; y++) for (let x = 0; x < 360; x++){\n    const dx = x + .5 - R, dy = y + .5 - R, d = Math.hypot(dx, dy) / R, i = (y*360 + x)*4;\n    const rgb = hsvRGB((Math.atan2(dy, dx)*180/Math.PI + 360) % 360, 1, 1);\n    img.data[i] = rgb[0]*255; img.data[i+1] = rgb[1]*255; img.data[i+2] = rgb[2]*255;\n    img.data[i+3] = 255 * Math.max(0, Math.min(1, (1 - d) * R, (d - 0.72) * R));\n  }\n  ctx.putImageData(img, 0, 0);\n  const hex = () => st.mode === 'white' ? kelvinHex(warmK(st.warm)) : rgbHex(hsvRGB(st.h, 1, 1));\n  function update(fire = true){\n    pop.querySelectorAll('.lp-seg button').forEach(b => b.classList.toggle('on', b.dataset.m === st.mode));\n    $('.lp-w').style.display = st.mode === 'white' ? '' : 'none';\n    $('.lp-c').style.display = st.mode === 'color' ? '' : 'none';\n    temp.value = st.warm; $('.lp-kv').textContent = warmK(st.warm) + ' K';\n    const a = st.h*Math.PI/180;\n    dot.style.left = (90 + Math.cos(a)*77) + 'px'; dot.style.top = (90 + Math.sin(a)*77) + 'px';\n    const h = hex(); dot.style.background = h; sw.style.background = h;\n    try { localStorage.setItem(key, JSON.stringify(st)); } catch(e){}\n    if (fire) onChange(h);\n  }\n  pop.querySelectorAll('.lp-seg button').forEach(b => b.onclick = () => { st.mode = b.dataset.m; update(); });\n  temp.oninput = () => { st.warm = +temp.value; update(); };\n  const pick = e => { const r = wheel.getBoundingClientRect(), dx = e.clientX - r.left - 90, dy = e.clientY - r.top - 90;\n    st.h = (Math.atan2(dy, dx)*180/Math.PI + 360) % 360; update(); };\n  wheel.onpointerdown = e => { const r = wheel.getBoundingClientRect(), d = Math.hypot(e.clientX - r.left - 90, e.clientY - r.top - 90);\n    if (d < 58 || d > 94) return; wheel.setPointerCapture(e.pointerId); pick(e); };\n  wheel.onpointermove = e => { if (wheel.hasPointerCapture(e.pointerId)) pick(e); };\n  const syncBri = () => { bri.value = dimIn.value; bv.textContent = dimIn.value + '%'; };\n  bri.oninput = () => { dimIn.value = bri.value; dimIn.oninput(); syncBri(); };\n  dimIn.addEventListener('input', syncBri);\n  const place = () => { pop.style.left = '18px'; pop.style.top = '50%'; pop.style.transform = 'translateY(-50%)'; };\n  sw.onclick = e => { e.preventDefault(); e.stopPropagation(); const o = !pop.classList.contains('open');\n    document.querySelectorAll('.lpick.open').forEach(p => p.classList.remove('open'));\n    if (o){ syncBri(); place(); pop.classList.add('open'); }\n    document.body.classList.toggle('lpfocus', o);\n    dispatchEvent(new CustomEvent('lpick', { detail: { key, open: o } })); };\n  $('.lp-done').onclick = () => { pop.classList.remove('open'); document.body.classList.remove('lpfocus'); dispatchEvent(new CustomEvent('lpick', { detail: { key, open: false } })); };\n  document.addEventListener('pointerdown', e => { if (pop.classList.contains('open') && !pop.contains(e.target) && !sw.contains(e.target)){ pop.classList.remove('open'); document.body.classList.remove('lpfocus'); dispatchEvent(new CustomEvent('lpick', { detail: { key, open: false } })); } });\n  addEventListener('resize', () => pop.classList.contains('open') && place());\n  update();\n  return pop;\n}\n\nlet lampCol = localStorage.getItem(LAMP_KEY) || '#ffd6a0';\nlampSw.innerHTML = '';\nconst colIn = document.createElement('button'); colIn.className = 'lp-sw'; colIn.title = 'Licht einstellen';\nlampSw.appendChild(colIn);\nconst dimIn = document.querySelector('#lampDim input'), dimOut = document.querySelector('#lampDim output');\ndimIn.oninput = () => { lampK = dimIn.value / 100; dimOut.textContent = dimIn.value + '%'; applyLamp(lampLvl); if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); } };\nfunction applyLamp(v){\n  v *= lampK;\n  lampSpot.intensity = 9 * v;\n  lampFill.intensity = 2.2 * v;\n  bulb.material.emissiveIntensity = 0.2 + 5 * v;\n  schirm.emissiveIntensity = 0.55 * v;\n}\napplyLamp(0);\nmakePicker(colIn, LAMP_KEY + '-cfg', { mode: 'white', warm: 75 }, dimIn, h => { lampCol = h; setLampColor(h); });\nsetLampColor(lampCol);\ndocument.getElementById('lampT').onclick = () => {\n  lampOn = !lampOn;\n  lampBtn.classList.toggle('on', lampOn);\n  lampBtn.querySelector('span').textContent = lampOn ? 'Bogenlampe aus' : 'Bogenlampe an';\n  setLampColor(lampCol);\n  const id = ++lampAnim, from = lampLvl, to = lampOn ? 1 : 0, t0 = performance.now();\n  (function step(now){\n    if (id !== lampAnim) return;\n    const t = Math.min(1, (now - t0) / 450);\n    lampLvl = from + (to - from) * (1 - Math.pow(1 - t, 3));\n    applyLamp(lampLvl);\n    if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); }\n    if (t < 1) requestAnimationFrame(step);\n  })(t0);\n};\n\n// ---------- Donut-Lampe: nur an/aus ----------\nconst donutLight = new THREE.PointLight(0xffa050, 0, 4.5, 2);\ndonutLight.position.copy(donut.getWorldPosition(new THREE.Vector3())).add(new THREE.Vector3(0, 0.13, 0));\nscene.add(donutLight);\nconst donutBtn = document.getElementById('lampD');\ndonutBtn.onclick = () => {\n  const on = donutBtn.getAttribute('aria-pressed') !== 'true';\n  donutBtn.setAttribute('aria-pressed', on); donutBtn.classList.toggle('on', on);\n  donutBtn.querySelector('span').textContent = on ? 'Donut-Lampe aus' : 'Donut-Lampe an';\n  DM.koerper.emissiveIntensity = on ? 2.2 : 0;\n  DM.sockel.emissiveIntensity = on ? 0.6 : 0;\n  donutLight.intensity = on ? 2.6 : 0;\n  if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); }\n};\n\n// ---------- Fernseher: an/aus per Fernbedienung ----------\n{\n  const scr = home.getObjectByName('fernseher').getObjectByName('tv_bildschirm');\n  const cv = document.createElement('canvas'); cv.width = 1024; cv.height = 600;\n  const c = cv.getContext('2d');\n  let g = c.createLinearGradient(0, 0, 1024, 600);\n  g.addColorStop(0, '#0b1e3a'); g.addColorStop(0.55, '#1d4f7a'); g.addColorStop(1, '#e08a4a');\n  c.fillStyle = g; c.fillRect(0, 0, 1024, 600);\n  g = c.createRadialGradient(760, 380, 10, 760, 380, 320);\n  g.addColorStop(0, 'rgba(255,210,150,.9)'); g.addColorStop(1, 'rgba(255,210,150,0)');\n  c.fillStyle = g; c.fillRect(0, 0, 1024, 600);\n  c.fillStyle = '#081322'; c.beginPath(); c.moveTo(0, 600); c.lineTo(0, 430); c.lineTo(220, 360); c.lineTo(420, 450); c.lineTo(640, 380); c.lineTo(1024, 470); c.lineTo(1024, 600); c.fill();\n  c.fillStyle = 'rgba(255,255,255,.92)'; c.font = '500 64px Helvetica, Arial, sans-serif'; c.fillText('20:15', 70, 120);\n  c.font = '400 28px Helvetica, Arial, sans-serif'; c.fillStyle = 'rgba(255,255,255,.7)'; c.fillText('Guten Abend', 72, 165);\n  const tex = new THREE.CanvasTexture(cv); tex.colorSpace = THREE.SRGBColorSpace;\n  const M = scr.material;\n  const tvLight = new THREE.PointLight(0x9ab8ff, 0, 3.2, 2);\n  const sb = new THREE.Box3().setFromObject(scr), sc = sb.getCenter(new THREE.Vector3()), ss = sb.getSize(new THREE.Vector3());\n  tvLight.position.copy(sc).add(new THREE.Vector3(0.35, 0.1, 0));\n  scene.add(tvLight);\n  const btn = document.getElementById('tvB');\n  let lvl = 0, anim = 0;\n  const apply = () => { M.emissiveIntensity = 1.6 * lvl; tvLight.intensity = 1.4 * lvl; if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); } };\n  const bar = document.getElementById('tvBar'), ui = document.getElementById('tvUI');\n  let saved = null, tvAnim = 0;\n  const tween = (pos, tgt, ms, done) => {\n    const id = ++tvAnim, p0 = cam.position.clone(), q0 = ctl.target.clone(), t0 = performance.now();\n    const ease = t => t < 0.5 ? 4*t*t*t : 1 - Math.pow(-2*t+2, 3)/2;\n    (function step(now){\n      if (id !== tvAnim) return;\n      const t = Math.min(1, (now - t0) / ms), e = ease(t);\n      cam.position.lerpVectors(p0, pos, e); ctl.target.lerpVectors(q0, tgt, e); cam.lookAt(ctl.target);\n      if (t < 1) requestAnimationFrame(step); else done && done();\n    })(t0);\n  };\n  const enter = () => {\n    if (saved) return;\n    saved = { pos: cam.position.clone(), tgt: ctl.target.clone(), en: ctl.enabled };\n    ctl.enabled = false;\n    const th = Math.tan(THREE.MathUtils.degToRad(cam.fov) / 2);\n    const d = Math.min(ss.y / 2 / th, ss.z / 2 / (th * cam.aspect)) * 0.98;\n    document.body.classList.add('tvfocus');\n    tween(new THREE.Vector3(sc.x + d, sc.y, sc.z), sc.clone(), 1600, () => { bar.classList.add('show'); ui.classList.add('show'); });\n  };\n  const leave = () => {\n    if (!saved) return;\n    const s = saved; saved = null;\n    bar.classList.remove('show'); ui.classList.remove('show'); document.body.classList.remove('tvfocus');\n    tween(s.pos, s.tgt, 1200, () => { ctl.enabled = s.en; });\n  };\n  document.getElementById('tvBack').onclick = leave;\n  document.getElementById('tvOff').onclick = () => { leave(); power(false); };\n  addEventListener('keydown', e => { if (e.key === 'Escape') leave(); });\n  addEventListener('resize', () => { if (saved && bar.classList.contains('show')){ const th = Math.tan(THREE.MathUtils.degToRad(cam.fov) / 2); const d = Math.min(ss.y / 2 / th, ss.z / 2 / (th * cam.aspect)) * 0.98; cam.position.set(sc.x + d, sc.y, sc.z); } });\n  const power = on => {\n    btn.setAttribute('aria-pressed', on); btn.classList.toggle('on', on);\n    btn.querySelector('span').textContent = on ? 'Fernbedienung' : 'Fernseher an';\n    if (!on) ui.classList.remove('show');\n    if (on && !M.emissiveMap){ M.emissive = new THREE.Color(0xffffff); M.emissiveMap = tex; M.needsUpdate = true; }\n    const id = ++anim, from = lvl, to = on ? 1 : 0, t0 = performance.now();\n    (function step(now){\n      if (id !== anim) return;\n      const t = Math.min(1, (now - t0) / (on ? 600 : 250));\n      lvl = from + (to - from) * (1 - Math.pow(1 - t, 3)); apply();\n      if (t < 1) requestAnimationFrame(step);\n    })(t0);\n  };\n  btn.onclick = () => { if (btn.getAttribute('aria-pressed') !== 'true') power(true); enter(); };\n  const apps = [['YouTube','#e5484d'],['Netflix','#d6303a'],['Prime Video','#2fa8e0'],['Disney+','#3b6fe0'],['Spotify','#2fbf62'],['ARD Mediathek','#3d7be0'],['ZDF','#f08a24'],['Twitch','#8b5cf6']];\n  const nav = ui.querySelector('.tv-nav'), hero = ui.querySelector('.tv-hero'), vol = ui.querySelector('.tv-vol input'), volO = ui.querySelector('.tv-vol output');\n  let sel = +(localStorage.getItem('wohnung.tv.app') || 0);\n  apps.forEach(([n], i) => { const b = document.createElement('button'); b.textContent = n; b.onclick = () => pick(i); nav.appendChild(b); });\n  function pick(i){\n    sel = (i + apps.length) % apps.length; try { localStorage.setItem('wohnung.tv.app', sel); } catch(e){}\n    const [n, col] = apps[sel];\n    nav.querySelectorAll('button').forEach((b, j) => b.classList.toggle('on', j === sel));\n    const b = nav.children[sel]; nav.scrollTo({ left: b.offsetLeft - nav.clientWidth/2 + b.offsetWidth/2, behavior: 'smooth' });\n    hero.style.setProperty('--a', col); hero.querySelector('h2').textContent = n;\n  }\n  pick(sel);\n  vol.value = localStorage.getItem('wohnung.tv.vol') ?? 35;\n  const setVol = () => { volO.textContent = vol.value; vol.style.setProperty('--v', vol.value + '%'); try { localStorage.setItem('wohnung.tv.vol', vol.value); } catch(e){} };\n  vol.oninput = setVol; setVol();\n  ui.querySelectorAll('.tv-vb').forEach(b => b.onclick = () => { vol.value = Math.max(0, Math.min(100, +vol.value + +b.dataset.d)); setVol(); });\n  ['pointerdown','wheel','keydown'].forEach(t => ui.addEventListener(t, e => e.stopPropagation()));\n  addEventListener('keydown', e => { if (!ui.classList.contains('show')) return;\n    if (e.key === 'ArrowRight') pick(sel + 1); else if (e.key === 'ArrowLeft') pick(sel - 1);\n    else if (e.key === 'ArrowUp'){ vol.value = Math.min(100, +vol.value + 5); setVol(); } else if (e.key === 'ArrowDown'){ vol.value = Math.max(0, +vol.value - 5); setVol(); } });\n}\n\n// ---------- Tripod-Lampe: an/aus, Farbe, Stärke, Kegel ----------\nconst tripBox = document.getElementById('lamp2'), tripDot = document.querySelector('#tripT i');\nconst TRIP_KEY = 'wohnung-tripod-farbe';\nconst tripColIn = document.getElementById('tripCol'), tripDimIn = document.getElementById('tripDim'), tripConeIn = document.getElementById('tripCone');\nlet tripOn = false, tripLvl = 0, tripAnim = 0, tripK = 1;\nlet tripCol = localStorage.getItem(TRIP_KEY) || '#f2f5ff';\nconst tripSync = () => { if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); } };\nfunction applyTrip(){\n  const v = tripLvl * tripK, c = new THREE.Color(tripCol);\n  trip.spot.color.copy(c); trip.glow.color.copy(c); trip.M.led.emissive.copy(c);\n  trip.M.led.color.set(tripLvl > 0.01 ? 0xffffff : 0xd8dadd);\n  trip.spot.intensity = 12 * v; trip.glow.intensity = 0.35 * v;\n  trip.M.led.emissiveIntensity = 4 * v;\n  tripDot.style.cssText = tripOn ? `background:${tripCol};box-shadow:0 0 10px 3px ${tripCol}99` : '';\n}\ntripDimIn.oninput = () => { tripK = tripDimIn.value/100; tripDimIn.nextElementSibling.textContent = tripDimIn.value + '%'; applyTrip(); tripSync(); };\nmakePicker(tripColIn, TRIP_KEY + '-cfg', { mode: 'white', warm: 5 }, tripDimIn, h => { tripCol = h; try { localStorage.setItem(TRIP_KEY, h); } catch(e){} applyTrip(); tripSync(); });\ntripConeIn.oninput = () => { trip.spot.angle = THREE.MathUtils.degToRad(tripConeIn.value); tripConeIn.nextElementSibling.textContent = tripConeIn.value + '°'; tripSync(); };\ntripConeIn.oninput();\napplyTrip();\ndocument.getElementById('tripT').onclick = () => {\n  tripOn = !tripOn;\n  tripBox.classList.toggle('on', tripOn);\n  tripBox.querySelector('#tripT span').textContent = tripOn ? 'Tripod-Lampe aus' : 'Tripod-Lampe an';\n  const id = ++tripAnim, from = tripLvl, to = tripOn ? 1 : 0, t0 = performance.now();\n  (function step(now){\n    if (id !== tripAnim) return;\n    const t = Math.min(1, (now - t0) / 450);\n    tripLvl = from + (to - from) * (1 - Math.pow(1 - t, 3));\n    applyTrip(); tripSync();\n    if (t < 1) requestAnimationFrame(step);\n  })(t0);\n};\n\n// ---------- Pathtracing (three-gpu-pathtracer): echte Lichtbündel mit Mehrfach-Reflexion, sobald die Kamera stillsteht ----------\n\nconst ptLabel = document.getElementById('pt');\nlet renderOn = false;\n// Sparsamer Standard-Renderer: N8AO (Screen-Space Ambient Occlusion) + Rendern nur bei Aktivität\nlet composer = null, aoPass = null, lastAct = performance.now(), lastInput = lastAct;\nconst act = () => { lastAct = lastInput = performance.now(); };\nfor (const ev of ['pointerdown','pointermove','wheel','keydown','input','click','resize','touchstart']) window.addEventListener(ev, act, true);\nPromise.all([import('three/examples/jsm/postprocessing/EffectComposer.js'), import('three/examples/jsm/postprocessing/RenderPass.js'), import('three/examples/jsm/postprocessing/OutputPass.js'), import('n8ao')]).then(([{EffectComposer},{RenderPass},{OutputPass},{N8AOPass}]) => {\n  const s = renderer.getSize(new THREE.Vector2());\n  composer = new EffectComposer(renderer);\n  aoPass = new N8AOPass(scene, cam, s.x, s.y);\n  Object.assign(aoPass.configuration, { aoRadius: 0.6, distanceFalloff: 0.5, intensity: 2.2, aoSamples: 12, denoiseSamples: 6, denoiseRadius: 10, halfRes: true, gammaCorrection: false });\n  aoPass.setQualityMode && aoPass.setQualityMode('Low');\n  composer.addPass(aoPass); composer.addPass(new OutputPass());\n  act();\n}).catch(e => console.warn('N8AO nicht verfügbar – einfacher Raster', e));\nconst _cs = new THREE.Vector2();\nconst rtBtn = document.getElementById('rt');\nrtBtn.onclick = () => {\n  renderOn = !renderOn;\n  rtBtn.classList.toggle('on', renderOn); rtBtn.setAttribute('aria-pressed', renderOn);\n  rtBtn.querySelector('span').textContent = renderOn ? 'Render an' : 'Render aus';\n  if (!renderOn && ptOn) stopPT();\n  stillSince = performance.now();\n};\nimport('three-gpu-pathtracer').then(({ WebGLPathTracer }) => {\n  tracer = new WebGLPathTracer(renderer);\n  tracer.bounces = 4;\n  tracer.renderScale = 0.5;\n  tracer.dynamicLowRes = false;\n  tracer.filterGlossyFactor = 0.5;\n  tracer.tiles.set(4, 4);\n  tracer.minSamples = 2;\n  tracer.fadeDuration = 350;\n  tracer.renderDelay = 0;\n}).catch(e => console.warn('Pathtracer nicht verfügbar – Raster-Fallback', e));\nfunction startPT(){\n  scene.environment = ptEnv; scene.background = ptEnv;\n  scene.environmentIntensity = ENV;\n  renderer.toneMappingExposure = 2.4;\n  if (ptDirty){ tracer.setScene(scene, cam); ptDirty = false; }\n  else { tracer.updateCamera(); tracer.updateMaterials(); tracer.updateLights(); tracer.updateEnvironment(); }\n  tracer.reset();\n  ptOn = true; ptLabel.classList.add('show');\n}\nfunction stopPT(){ ptOn = false; scene.environment = rasterEnv; scene.background = cubeRT.texture; applyInterior(ceilMat.opacity); ptLabel.classList.remove('show'); }\nconst MAX_SAMPLES = 256; let ptFrame = 0;\nlet lastUser = -1e9;\nconst interrupt = () => { stillSince = lastUser = performance.now(); if (ptOn) stopPT(); };\nfor (const ev of ['pointerdown','wheel','keydown']) window.addEventListener(ev, interrupt, true);\nrenderer.domElement.addEventListener('pointerdown', interrupt, true);\nconst lastM = new THREE.Matrix4(); let lastAspect = 0;\nfunction camMoved(){\n  const a = cam.matrixWorld.elements, b = lastM.elements; let d = 0;\n  for (let i = 0; i < 16; i++) d += Math.abs(a[i] - b[i]);\n  const m = d > 1e-5 || cam.aspect !== lastAspect;\n  lastM.copy(cam.matrixWorld); lastAspect = cam.aspect;\n  return m;\n}\nconst loop = () => {\n  ctl.autoRotate = !inRoom && !lampFocus && ctl.enabled && performance.now() - lastUser > 6000;\n  ctl.autoRotateSpeed = 0.4;\n  document.body.classList.toggle('idle', performance.now() - lastInput > 8000);\n  ctl.update(); cam.updateMatrixWorld();\n  const now = performance.now();\n  if (camMoved()){ stillSince = now; lastAct = now; if (ptOn) stopPT(); }\n  if (tracer && renderOn && !ptOn && now - stillSince > 350 && (ceilMat.opacity >= 0.999 || ceilMat.opacity <= 0.001)){\n    try { startPT(); } catch(e){ console.warn('Pathtracer-Fehler: ' + (e && e.message), e); tracer = null; ptOn = false; scene.environment = rasterEnv; scene.background = cubeRT.texture; ptLabel.classList.remove('show'); }\n  }\n  if (ptOn && tracer.samples >= MAX_SAMPLES){ ptLabel.textContent = 'Raytracing · fertig'; return; }\n  if (ptOn){ ptFrame ^= 1; if (ptFrame) tracer.renderSample(); ptLabel.textContent = 'Raytracing · ' + Math.floor(tracer.samples) + ' Samples'; }\n  else if (now - lastAct < 1500) {\n    if (composer){ renderer.getSize(_cs); if (composer._w !== _cs.x || composer._h !== _cs.y){ composer.setSize(_cs.x, _cs.y); composer._w = _cs.x; composer._h = _cs.y; } composer.render(); }\n    else renderer.render(scene, cam);\n  }\n};\nstage._loop = loop;\nrenderer.setAnimationLoop(loop);\n\n// ---------- Raum-Navigation ----------\nconst cam = stage._camera, ctl = stage._controls;\nlet lampFocus = false;\nconst overview = { pos: cam.position.clone(), tgt: ctl.target.clone() };\nconst EYE = 1.6;\n// Standpunkt in der Raummitte, Blick in Richtung (dx,dz); Target minimal vor der Kamera → Umsehen statt Umkreisen\nconst spot = (x, z, dx, dz, y = EYE) => {\n  const d = new THREE.Vector3(dx, -0.12, dz).normalize().multiplyScalar(0.05);\n  const pos = new THREE.Vector3(x, y, z);\n  return { pos, tgt: pos.clone().add(d), fp: true };\n};\n// Vogelperspektive: senkrecht über dem Raum, leicht geneigt, Decke ausgeblendet – ganzer Raum im Bild\nconst bird = (x0,z0,x1,z1) => {\n  const cx = (x0+x1)/2, cz = (z0+z1)/2, w = Math.abs(x1-x0), d = Math.abs(z1-z0);\n  const fov = (cam.fov || 50) * Math.PI/180, asp = Math.max(0.6, innerWidth/innerHeight);\n  const need = Math.max(d, w/asp) * 0.5 * 1.25;            // halbe Ausdehnung + Rand\n  const hgt = need / Math.tan(fov/2) + 1.0;\n  return { pos: new THREE.Vector3(cx, hgt, cz + hgt*0.22), tgt: new THREE.Vector3(cx, 0.3, cz), fp: false };\n};\nconst room = ([x0,z0,x1,z1], dx, dz) => ({ fp: spot((x0+x1)/2, (z0+z1)/2, dx, dz), bird: bird(x0, z0, x1, z1) });\nconst ROOMS = [\n  ['Übersicht', overview],\n  ['Wohnzimmer', room(RM_WZ, 1, 0.4)],\n  ['Küche', room(RM_KU, 1, -0.3)],\n  ['Schlafzimmer', room(RM_SZ, -0.3, 1)],\n  ['Bad', room(RM_BAD, 0, -1)],\n  ['Flur', room(RM_FL, -1, 0)],\n  ['Balkon', room([BX0, BZ0, BX1, BZ1], 0, -1)],\n];\nlet anim = 0;\nfunction flyTo(view){\n  const id = ++anim;\n  const p0 = cam.position.clone(), t0 = ctl.target.clone();\n  const c0 = ceilMat.opacity, c1 = view.fp ? 1 : 0;\n  inRoom = !!view.fp;\n  const clamp01 = x => Math.max(0, Math.min(1, x));\n  const dist = p0.distanceTo(view.pos);\n  const dur = Math.min(2200, 1100 + dist*90);\n  const lift = Math.min(3, dist*0.25);\n  const start = performance.now();\n  ctl.enabled = false;\n  ctl.enableZoom = ctl.enablePan = !view.fp;\n  ctl.rotateSpeed = view.fp ? -0.35 : 1;\n  ctl.minDistance = 0;\n  const ease = t => t < 0.5 ? 4*t*t*t : 1 - Math.pow(-2*t+2, 3)/2;\n  (function step(now){\n    if (id !== anim) return;\n    const t = Math.min(1, (now - start)/dur), e = ease(t);\n    cam.position.lerpVectors(p0, view.pos, e);\n    cam.position.y += Math.sin(Math.PI*e) * lift;\n    ctl.target.lerpVectors(t0, view.tgt, e);\n    cam.lookAt(ctl.target);\n    // Einblenden erst am Ende der Anflugs (Kamera schon unter Deckenhöhe), Ausblenden sofort\n    const k = c1 > c0 ? clamp01((e - 0.6) / 0.4) : clamp01(e / 0.3);\n    setCeil(c0 + (c1 - c0) * k);\n    if (t < 1) requestAnimationFrame(step); else ctl.enabled = true;\n  })(start);\n}\nconst bar = document.getElementById('rooms');\nconst povBar = document.getElementById('pov');\nlet curView = overview, povMode = 'bird';\nconst show = () => flyTo(curView.bird ? curView[povMode] : curView);\nROOMS.forEach(([label, view], i) => {\n  const b = document.createElement('button');\n  b.textContent = label;\n  if (i === 0) b.classList.add('on');\n  b.onclick = () => {\n    bar.querySelectorAll('button').forEach(x => x.classList.toggle('on', x === b));\n    lampBtn.classList.toggle('show', label === 'Wohnzimmer');\n    tripBox.classList.toggle('show', label === 'Schlafzimmer');\n    povBar.classList.toggle('show', !!view.bird);\n    curView = view; povMode = 'bird';\n    povBar.querySelectorAll('button').forEach(x => x.classList.toggle('on', x.dataset.m === povMode));\n    show();\n  };\n  bar.appendChild(b);\n});\n// Lampe konfigurieren → Kamera fliegt an die Lampe, Drehen stoppt; beim Schließen zurück\nconst LAMP_FOCUS = { [LAMP_KEY + '-cfg']: [bp.clone(), 1], [TRIP_KEY + '-cfg']: [trip.spot.getWorldPosition(new THREE.Vector3()), 3] };\naddEventListener('lpick', e => {\n  const f = LAMP_FOCUS[e.detail.key]; if (!f) return;\n  if (e.detail.open){\n    lampFocus = true;\n    const p = f[0], c = ROOMS[f[1]][1].fp.pos, dir = new THREE.Vector3(c.x - p.x, 0, c.z - p.z);\n    const dist = Math.min(1.8, dir.length() * 0.85); dir.normalize();\n    const pos = p.clone().addScaledVector(dir, dist).add(new THREE.Vector3(0, 0.35, 0));\n    const right = new THREE.Vector3(-dir.z, 0, dir.x).multiplyScalar(dist * 0.3); // Lampe ins rechte Bilddrittel, Picker links\n    flyTo({ pos, tgt: p.clone().add(new THREE.Vector3(0, -0.2, 0)).add(right), fp: false });\n  } else { lampFocus = false; show(); }\n});\npovBar.addEventListener('click', e => {\n  const b = e.target.closest('button'); if (!b || b.dataset.m === povMode) return;\n  povMode = b.dataset.m;\n  povBar.querySelectorAll('button').forEach(x => x.classList.toggle('on', x === b));\n  show();\n});\n\n// ---------- Poly Haven Texturen ----------\nasync function polyHaven(assetName, res){\n  const all = await (await fetch('https://api.polyhaven.com/assets?t=textures')).json();\n  const want = assetName.toLowerCase();\n  const id = (all[want] ? want : null) || Object.keys(all).find(k => (all[k].name||'').toLowerCase() === want)\n          || Object.keys(all).find(k => (all[k].name||'').toLowerCase().includes(want))\n          || want.replace(/\\s+/g,'_');\n  const files = await (await fetch(`https://api.polyhaven.com/files/${id}`)).json();\n  const pick = key => files[key]?.['1k']?.jpg?.url || files[key]?.['1k']?.png?.url;\n  const dim = all[id]?.dimensions; // mm [w,h]\n  return { id, dim, diff: pick('Diffuse'), nor: pick('nor_gl'), rough: pick('Rough') };\n}\nconst loader = new THREE.TextureLoader();\nloader.setCrossOrigin('anonymous');\nconst loadTex = (url, srgb) => new Promise((res, rej) => loader.load(url, t => {\n  t.wrapS = t.wrapT = THREE.RepeatWrapping;\n  if (srgb) t.colorSpace = THREE.SRGBColorSpace;\n  t.anisotropy = 8; res(t);\n}, undefined, rej));\nasync function apply(mat, assetName, uvScale, res){\n  const f = await polyHaven(assetName, res);\n  const [map, normalMap, roughnessMap] = await Promise.all([\n    loadTex(f.diff, true), f.nor ? loadTex(f.nor) : null, f.rough ? loadTex(f.rough) : null\n  ]);\n  if (uvScale){ // echte Größe: UVs sind in 1/uvScale m, Textur deckt dim mm ab\n    const w = (f.dim?.[0] || 2000) / 1000, hh = (f.dim?.[1] || f.dim?.[0] || 2000) / 1000;\n    for (const t of [map, normalMap, roughnessMap]) if (t) t.repeat.set(uvScale / w, uvScale / hh);\n  }\n  mat.map = map; mat.color.set(0xffffff);\n  if (normalMap) mat.normalMap = normalMap;\n  if (roughnessMap) { mat.roughnessMap = roughnessMap; mat.roughness = 1; }\n  mat.needsUpdate = true;\n  ptDirty = true; if (ptOn) stopPT();\n  return f.id;\n}\n// ---------- Tageszeit: prozeduraler Himmel (three.js Sky, Preetham-Modell) ----------\nconst { Sky } = await import('three/addons/objects/Sky.js');\nconst sky = new Sky(); sky.scale.setScalar(1000);\nconst skyScene = new THREE.Scene(); skyScene.add(sky);\nconst SU = sky.material.uniforms;\nSU.mieCoefficient.value = 0.005; SU.mieDirectionalG.value = 0.8;\n// Nacht-/Dämmerungs-Minimum: dunkles Blau, zum Horizont heller\nsky.material.uniforms.nightFloor = { value: new THREE.Color(0,0,0) };\nsky.material.fragmentShader = 'uniform vec3 nightFloor;\\n' + sky.material.fragmentShader.replace('#include <tonemapping_fragment>',\n  'float hzF = 1.0 - clamp(normalize(vWorldPosition - cameraPosition).y, 0.0, 1.0);\\n gl_FragColor.rgb = max(gl_FragColor.rgb, nightFloor * (0.55 + 0.9*hzF*hzF));\\n#include <tonemapping_fragment>');\nsky.material.needsUpdate = true;\nconst cubeRT = new THREE.WebGLCubeRenderTarget(512, { type: THREE.HalfFloatType });\nconst cubeCam = new THREE.CubeCamera(1, 5000, cubeRT); skyScene.add(cubeCam);\nconst pmrem = new THREE.PMREMGenerator(renderer);\nlet envRT = null;\nconst keyBase = key.intensity, hemiCol0 = hemi ? hemi.color.clone() : null, hemiGnd0 = hemi ? hemi.groundColor.clone() : null;\nconst SS = THREE.MathUtils.smoothstep, col = (r,g,b) => new THREE.Color(r,g,b);\nfunction makePTEnv(d, day, golden){\n  const w = 256, h = 128, arr = new Float32Array(w*h*4);\n  const zen = col(.03,.045,.1).lerp(col(.16,.32,.75), day);\n  const hor = col(.05,.07,.13).lerp(col(.75,.82,.92).lerp(col(1,.55,.3), golden*.8), day);\n  const gnd = hor.clone().multiplyScalar(.25);\n  const sunC = col(1,.95,.85).lerp(col(1,.5,.2), golden).multiplyScalar(40*day);\n  for (let j = 0; j < h; j++){\n    const el = ((j+.5)/h - .5)*Math.PI, sy = Math.sin(el), cy = Math.cos(el);\n    for (let i = 0; i < w; i++){\n      const az = ((i+.5)/w - .5)*2*Math.PI, x = Math.cos(az)*cy, z = Math.sin(az)*cy;\n      let r, g, bb;\n      if (sy >= 0){ const t = Math.sqrt(sy); r = hor.r+(zen.r-hor.r)*t; g = hor.g+(zen.g-hor.g)*t; bb = hor.b+(zen.b-hor.b)*t; }\n      else { const t = Math.min(1, -sy*4); r = hor.r+(gnd.r-hor.r)*t; g = hor.g+(gnd.g-hor.g)*t; bb = hor.b+(gnd.b-hor.b)*t; }\n      const dot = x*d.x + sy*d.y + z*d.z;\n      if (dot > 0){ const gl = Math.pow(dot, 48)*day*(1+golden); r += gl; g += gl*(.85-.3*golden); bb += gl*(.7-.45*golden); }\n      if (dot > .999 && sy > -0.02){ r = sunC.r; g = sunC.g; bb = sunC.b; }\n      const k = (j*w + i)*4; arr[k] = r; arr[k+1] = g; arr[k+2] = bb; arr[k+3] = 1;\n    }\n  }\n  const dt = new THREE.DataTexture(arr, w, h, THREE.RGBAFormat, THREE.FloatType);\n  dt.mapping = THREE.EquirectangularReflectionMapping;\n  dt.minFilter = dt.magFilter = THREE.LinearFilter; dt.generateMipmaps = false; dt.needsUpdate = true;\n  return dt;\n}\nconst sunV = new THREE.Vector3();\nfunction setTime(hr){\n  // Sonnenbahn (vereinfacht): 7 Uhr Ost (+x) → 13 Uhr Süd (+z) → 19 Uhr West, max. 50° Höhe\n  const phi = Math.PI*(hr - 7)/12, e = THREE.MathUtils.degToRad(50)*Math.sin(phi);\n  sunV.set(Math.cos(phi)*Math.cos(e), Math.sin(e), Math.sin(phi)*Math.cos(e)).normalize();\n  const s = sunV.y, day = SS(s, -0.14, 0.18), golden = 1 - SS(s, 0, 0.4), dusk = SS(s, -0.22, -0.02) * (1 - SS(s, 0.02, 0.2));\n  SU.sunPosition.value.copy(sunV);\n  SU.rayleigh.value = 2.5 + 1.2*golden;\n  SU.turbidity.value = 3 + 5*golden;\n  // Nachtblau, zur blauen Stunde etwas heller/violetter\n  SU.nightFloor.value.setRGB(0.010 + 0.03*dusk, 0.016 + 0.03*dusk, 0.045 + 0.06*dusk);\n  cubeCam.update(renderer, skyScene);\n  envRT = pmrem.fromCubemap(cubeRT.texture, envRT);\n  rasterEnv = envRT.texture;\n  if (s > -0.03){\n    key.position.copy(hc).addScaledVector(sunV, 30);\n    key.color.set(0xff9a52).lerp(new THREE.Color(0xfff3e2), SS(s, 0, 0.5));\n    key.intensity = keyBase * 1.3 * Math.max(day, 0.15);\n  } else { // Mondlicht, gegenüber der Sonne\n    const m = new THREE.Vector3(-sunV.x, Math.abs(sunV.y)*0.8 + 0.2, -sunV.z).normalize();\n    key.position.copy(hc).addScaledVector(m, 30);\n    key.color.set(0x9fb4ff); key.intensity = keyBase * 0.25;\n  }\n  envK = 0.2 + 0.1*day + 0.15*dusk; hemiK = 0.3 + 0.4*day; fillK = 0.1 + 0.5*day; expK = 1 - 0.45*day;\n  if (hemi){ hemi.color.copy(hemiCol0).lerp(new THREE.Color(0x34426e), 1 - day); hemi.groundColor.copy(hemiGnd0).multiplyScalar(0.3 + 0.7*day); }\n  ptEnv = makePTEnv(sunV, day, golden);\n  scene.background = cubeRT.texture;\n  scene.backgroundIntensity = 0.2 + 1.1*(1 - day);\n  if (ptOn) stopPT(); else { scene.environment = rasterEnv; applyInterior(ceilMat.opacity); }\n  act();\n}\n// Himmel & Licht folgen der echten Uhrzeit\nconst nowH = () => { const n = new Date(); return n.getHours() + n.getMinutes()/60; };\nsetTime(nowH());\nsetInterval(() => setTime(nowH()), 60000);\nlet texMsg = 'Texturen werden geladen…';\nconst upd = () => statusEl.textContent = texMsg;\nupd();\nsofa.M.fabric.color.set('#3a3a3c');\napply(sofa.M.fabric, 'Poly Wool Herringbone').then(() => sofa.M.fabric.color.set('#3a3a3c')).catch(e => console.warn(e));\nPromise.all([apply(M.floor, 'wood_floor', 1.0), apply(M.wall, 'White Stucco'), apply(M.brick, 'Brick Wall 04', 1.5), apply(M.cap, 'Rough Plaster Brick 04', 1.5), apply(tileMat, 'interior_tiles', 1.0, '2k').then(id => {\n    // nur Relief/Glanz behalten, Farbe weiß; Raster achsparallel drehen, Fliesen halb so groß\n    tileMat.map = null; tileMat.color.set(0xf3f2ee);\n    // Textur: Rautenraster, 3 Fliesen je Kachel → 45° gedreht achsparallel; 15-cm-Fliesen, Fugen auf 0,90 / 1,50 m\n    const TILE = 0.15, rep = 1 / (3 * Math.SQRT2 * TILE);\n    for (const t of [tileMat.normalMap, tileMat.roughnessMap]) if (t){ t.center.set(0, 0); t.offset.set(0, 0); t.rotation = Math.PI/4; t.repeat.set(rep, rep); }\n    tileMat.needsUpdate = true; return id;\n  })])\n  .then(ids => { texMsg = 'Texturen: ' + ids.join(', '); upd(); })\n  .catch(e => { console.warn(e); texMsg = 'Texturen nicht erreichbar – Farb-Fallback'; upd(); });\n<\u002Fscript>\n\n\n<\u002Fbody><\u002Fhtml>"
  </script>
</body>
</html>", P = "<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <title>Wohnung – 3D Miniatur (Handy)</title>
  <style>
    * { margin: 0; padding: 0; box-sizing: border-box; }
    body { background: #1b1b19; display: flex; align-items: center; justify-content: center; min-height: 100vh; font-family: -apple-system, BlinkMacSystemFont, sans-serif; }
    #__bundler_loading { position: fixed; bottom: 20px; right: 20px; font: 13px/1.4 -apple-system, BlinkMacSystemFont, sans-serif; color: #666; background: #fff; padding: 8px 14px; border-radius: 8px; box-shadow: 0 1px 4px rgba(0,0,0,0.12); z-index: 10000; }
    #__bundler_thumbnail { position: fixed; inset: 0; width: 100%; height: 100%; display: flex; align-items: center; justify-content: center; background: #1b1b19; z-index: 9999; }
    #__bundler_thumbnail svg { width: 100%; height: 100%; object-fit: contain; }
    #__bundler_placeholder { color: #999; font-size: 14px; }
  </style>
  <noscript>
    <style>#__bundler_loading { display: none; }</style>
    <div style="position:fixed;bottom:12px;left:12px;font:13px/1.4 -apple-system,BlinkMacSystemFont,sans-serif;color:#999;background:rgba(255,255,255,0.9);padding:6px 12px;border-radius:6px;box-shadow:0 1px 4px rgba(0,0,0,0.08);z-index:10000;">
      This page requires JavaScript to display.
    </div>
  </noscript>
</head>
<body>
  <div id="__bundler_thumbnail"><svg viewBox="0 0 120 120" xmlns="http://www.w3.org/2000/svg"><rect width="120" height="120" fill="#1b1b19"></rect><rect x="46" y="26" width="28" height="68" rx="10" fill="none" stroke="#e9e6de" stroke-width="4"></rect><circle cx="60" cy="42" r="5" fill="#e5484d"></circle><circle cx="60" cy="62" r="7" fill="none" stroke="#e9e6de" stroke-width="4"></circle></svg></div>
  <div id="__bundler_loading">Unpacking...</div>

  <script>
    
document.addEventListener('DOMContentLoaded', async function() {
  const loading = document.getElementById('__bundler_loading');
  function setStatus(msg) { if (loading) loading.textContent = msg; }

  const FONT_MIME = /^(font[/]|application[/](x-)?font-|application[/]vnd\.ms-fontobject)/i;
  const MIME_TOKEN = /^[\w.+-]+[/][\w.+-]+$/;
  function toBase64(bytes) {
    let bin = '';
    for (let i = 0; i < bytes.length; i += 0x8000) {
      bin += String.fromCharCode.apply(null, bytes.subarray(i, i + 0x8000));
    }
    return btoa(bin);
  }

  // Error sink persists across replaceWith since it's on window, not the DOM.
  window.addEventListener('error', function(e) {
    // Failed resource loads (CSP-blocked links, scripts, images) fire plain
    // events at the element — warn only; real JS errors carry message/error.
    if (!e.message && !e.error && e.target && e.target !== window) {
      console.warn('[bundle] resource failed to load:',
        e.target.tagName, String(e.target.src || e.target.href || ''));
      return;
    }
    var p = document.body || document.documentElement;
    var d = document.getElementById('__bundler_err') || p.appendChild(document.createElement('div'));
    d.id = '__bundler_err';
    d.style.cssText = 'position:fixed;bottom:12px;left:12px;right:12px;font:12px/1.4 ui-monospace,monospace;background:#2a1215;color:#ff8a80;padding:10px 14px;border-radius:8px;border:1px solid #5c2b2e;z-index:99999;white-space:pre-wrap;max-height:40vh;overflow:auto';
    d.textContent = (d.textContent ? d.textContent + String.fromCharCode(10) : '') +
      '[bundle] ' + (e.message || e.type) +
      (e.filename ? ' (' + e.filename.slice(0, 60) + ':' + e.lineno + ')' : '');
  }, true);

  try {
    const manifestEl = document.querySelector('script[type="__bundler/manifest"]');
    const templateEl = document.querySelector('script[type="__bundler/template"]');
    if (!manifestEl || !templateEl) {
      setStatus('Error: missing bundle data');
      console.error('[bundler] Missing script tags — manifestEl:', !!manifestEl, 'templateEl:', !!templateEl);
      return;
    }

    const manifest = JSON.parse(manifestEl.textContent);
    let template = JSON.parse(templateEl.textContent);

    // Nested page bundles (iframe targets). Each ships ONCE, in the ROOT
    // document's manifest; frame srcs carry an about:blank#<uuid> marker
    // instead of a substitutable uuid. Every document mints the blobs for
    // its OWN frames — from local text at the root, or text obtained from
    // its DIRECT parent over the relay protocol below — so each frame
    // navigation stays same-origin with its initiator and a deduped page
    // loads at any depth on any host, including a file:// download's
    // opaque origins (where a blob minted by one document cannot be
    // navigated to by another).
    const pageOrderEl = document.querySelector('script[type="__bundler/page_order"]');
    const pageOrder = pageOrderEl ? JSON.parse(pageOrderEl.textContent) : [];
    const pageSet = new Set(pageOrder);
    const pageTexts = {};

    // ── Nested-page text protocol (parent-chain relay) ──
    // Page bundles ship once, in the ROOT document's manifest. Every
    // document mints the blobs for its OWN frames, obtaining page text
    // through a strict parent-chain relay: a document only ever SENDS to
    // its direct parent (which, for every document the publisher's own
    // runtime minted, is another publisher document) and only ACCEPTS
    // text from that direct parent; requests from below are honored only
    // for the document's own child frames, and the ROOT never sends
    // upward at all. That last rule is load-bearing: the artifact host's
    // frame-ancestors allows claude.ai (and friends) to frame an
    // artifact, so window.top can be a FOREIGN document — a top-addressed
    // protocol would hand page uuids to that ancestor and accept forged
    // "page text" from it, minting attacker HTML as an artifact-origin
    // blob document. The chain never touches the ancestor: requests stop
    // at the root, replies are origin-addressed per hop (never '*' when
    // an origin exists), and both directions are origin-gated (on https
    // a foreign sender's origin can never equal this document's; in
    // opaque contexts — file:// — everything serializes as 'null', where
    // an embedded EXTERNAL frame still fails the gate by carrying its
    // own real origin, and a sandboxed child of such a frame is excluded
    // by the own-child-frames check plus uuid unguessability). Shape is
    // deny-by-default: one request form, one reply form, no error
    // replies.
    // window.origin is the SERIALIZED SECURITY origin ('null' in opaque
    // contexts such as a sandboxed preview iframe) — location.origin is
    // computed from the URL and stays 'https://…' even when the document
    // is sandboxed, which would misgate every opaque chain.
    const OWN_TARGET = /^https?:[/][/]/.test(window.origin || '')
      ? window.origin
      : '*';
    function trustedOrigin(e) {
      if (e.origin === window.origin) return true; // https chains; opaque==opaque
      // file:// trees: Chrome serializes the file document's origin as
      // 'file://' while the blob: documents it mints serialize as 'null',
      // so the two legitimate shapes can never string-match — accept the
      // pair in both directions. https origins never serialize as either,
      // and sender identity (own child frame / direct parent) is checked
      // separately.
      return (
        (e.origin === 'null' &&
          (window.origin === 'file://' ||
            window.location.protocol === 'file:')) ||
        (/^file:/.test(e.origin) && window.origin === 'null')
      );
    }
    // Non-empty only in the root document (nested bundles ship an empty
    // island), so it doubles as the root marker: the root answers from
    // local text and treats a miss as authoritative — never relaying to
    // its (possibly foreign) parent.
    const isPageRoot = pageOrder.length > 0;
    const blobUrls = {};
    const resourceBlobs = {};
    const UUID_SHAPE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
    const pendingFrames = {}; // uuid -> [{el, frag}] awaiting text for own frames
    const pendingRelays = {}; // uuid -> [childWindow] awaiting text to pass down
    function mountPage(el, frag, text) {
      const pageBlob = new Blob([text], { type: 'text/html' });
      const u = URL.createObjectURL(pageBlob);
      resourceBlobs[u] = pageBlob;
      el.src = u + frag;
    }
    function deliverPage(uuid, text) {
      const frames = pendingFrames[uuid];
      delete pendingFrames[uuid];
      if (frames) for (const f of frames) mountPage(f.el, f.frag, text);
      const relays = pendingRelays[uuid];
      delete pendingRelays[uuid];
      if (relays) {
        for (const cw of relays) {
          try { cw.postMessage({ __bundler_page: uuid, __bundler_text: text }, OWN_TARGET); } catch (err) { /* gone */ }
        }
      }
    }
    function ownFrameWindows() {
      const out = [];
      for (const f of Array.from(document.querySelectorAll('iframe'))) {
        try { if (f.contentWindow) out.push(f.contentWindow); } catch (err) { /* detached */ }
      }
      return out;
    }
    window.addEventListener('message', function (e) {
      const d = e.data;
      if (!d || typeof d !== 'object' || !e.source) return;
      // Origin gate first; the structural checks below (own-child-frames
      // for requests, direct-parent + solicited-uuid for replies, the
      // root's never-relay rule) are what hold in fully opaque chains
      // where origin strings can't discriminate — a sandboxed root's
      // FOREIGN wrapper still fails all three even though both serialize
      // as real-vs-'null' rather than matching.
      if (!trustedOrigin(e)) return;
      if (typeof d.__bundler_need === 'string' && UUID_SHAPE.test(d.__bundler_need)) {
        // Requests are honored only for this document's own child frames.
        if (ownFrameWindows().indexOf(e.source) < 0) return;
        const uuid = d.__bundler_need;
        const text = pageTexts[uuid];
        if (typeof text === 'string') {
          try { e.source.postMessage({ __bundler_page: uuid, __bundler_text: text }, OWN_TARGET); } catch (err) { /* gone */ }
          return;
        }
        if (isPageRoot || window.parent === window) return; // authoritative miss
        const waiting = pendingRelays[uuid];
        if (waiting) {
          if (waiting.indexOf(e.source) < 0) waiting.push(e.source);
          return;
        }
        // Never-answered uuids would otherwise accumulate forever under a
        // request spray; past the cap (far above any real page count) new
        // relays are dropped rather than remembered.
        if (Object.keys(pendingRelays).length >= 128) return;
        pendingRelays[uuid] = [e.source];
        window.parent.postMessage({ __bundler_need: uuid }, OWN_TARGET);
      } else if (
        typeof d.__bundler_page === 'string' &&
        UUID_SHAPE.test(d.__bundler_page) &&
        typeof d.__bundler_text === 'string'
      ) {
        // The shape test is load-bearing beyond tidiness: the solicited
        // check below uses the in operator, which matches prototype keys
        // ('__proto__', 'constructor') — an unshaped key would reach
        // deliverPage and throw, painting the error banner.
        // Text is accepted only from the direct parent — the document
        // that minted this one.
        if (e.source !== window.parent || window.parent === window) return;
        if (!(d.__bundler_page in pendingFrames) && !(d.__bundler_page in pendingRelays)) return;
        deliverPage(d.__bundler_page, d.__bundler_text);
      }
    });

    const uuids = Object.keys(manifest);
    setStatus('Unpacking ' + uuids.length + ' assets...');

    await Promise.all(uuids.map(async (uuid) => {
      const entry = manifest[uuid];
      try {
        const binaryStr = atob(entry.data);
        const bytes = new Uint8Array(binaryStr.length);
        for (let i = 0; i < binaryStr.length; i++) bytes[i] = binaryStr.charCodeAt(i);

        let finalBytes = bytes;
        if (entry.compressed) {
          if (typeof DecompressionStream !== 'undefined') {
            const ds = new DecompressionStream('gzip');
            const writer = ds.writable.getWriter();
            const reader = ds.readable.getReader();
            writer.write(bytes);
            writer.close();
            const chunks = [];
            let totalLen = 0;
            while (true) {
              const { done, value } = await reader.read();
              if (done) break;
              chunks.push(value);
              totalLen += value.length;
            }
            finalBytes = new Uint8Array(totalLen);
            let offset = 0;
            for (const chunk of chunks) { finalBytes.set(chunk, offset); offset += chunk.length; }
          } else {
            console.warn('DecompressionStream not available, asset ' + uuid + ' may not render');
          }
        }

        if (pageSet.has(uuid)) {
          pageTexts[uuid] = new TextDecoder().decode(finalBytes);
          return;
        }
        if (FONT_MIME.test(entry.mime) && MIME_TOKEN.test(entry.mime)) {
          // Strict artifact hosts allow font-src data: but not blob:.
          blobUrls[uuid] = 'data:' + entry.mime + ';base64,' +
            (entry.compressed ? toBase64(finalBytes) : entry.data);
        } else {
          const blob = new Blob([finalBytes], { type: entry.mime });
          blobUrls[uuid] = URL.createObjectURL(blob);
          resourceBlobs[blobUrls[uuid]] = blob;
        }
      } catch (err) {
        console.error('Failed to decode asset ' + uuid + ':', err);
        const blob = new Blob([], { type: entry.mime });
        blobUrls[uuid] = URL.createObjectURL(blob);
        resourceBlobs[blobUrls[uuid]] = blob;
      }
    }));

    const extResEl = document.querySelector('script[type="__bundler/ext_resources"]');
    const extResources = extResEl ? JSON.parse(extResEl.textContent) : [];
    const resourceMap = {};
    for (const entry of extResources) {
      if (blobUrls[entry.uuid]) resourceMap[entry.id] = blobUrls[entry.uuid];
    }

    // Artifact-host CSP (connect-src 'self') refuses fetch() of blob: URLs —
    // consumers read these Blobs directly. Survives the swap like the error sink.
    window.__resourceBlobs = resourceBlobs;

    setStatus('Rendering...');
    // Page uuids have no blob here — they ride inside about:blank#<uuid>
    // frame markers the pass below resolves after the swap.
    for (const uuid of uuids) {
      if (pageSet.has(uuid)) continue;
      template = template.split(uuid).join(blobUrls[uuid]);
    }

    // Strip integrity + crossorigin — blob URLs from a file:// document inherit
    // a null origin, so crossorigin forces a CORS fetch that SRI then rejects.
    // The manifest bytes are ours; SRI protects against CDN compromise, not this.
    template = template.replace(/\s+integrity="[^"]*"/gi, '').replace(/\s+crossorigin="[^"]*"/gi, '');

    const resourceScript = '<script>window.__resources = ' +
      JSON.stringify(resourceMap).replace(/<\//g, '<\\/') +
      ';</' + 'script>';
    // Inject after <head> so the DOCTYPE stays first; prepending the script
    // would push the parser into quirks mode. DOMParser always emits a <head>
    // (synthesizing one if the source HTML omitted it) but may carry
    // attributes through, so match the full opening tag. slice() rather than
    // replace() keeps us clear of $-pattern substitution in resourceScript.
    const headOpen = template.match(/<head[^>]*>/i);
    if (headOpen) {
      const i = headOpen.index + headOpen[0].length;
      template = template.slice(0, i) + resourceScript + template.slice(i);
    }

    // Parse the template and swap the root element. Scripts inserted via
    // DOMParser/replaceWith are inert per spec — re-create each with
    // createElement so they execute, awaiting onload for src scripts to
    // preserve ordering (React before ReactDOM before Babel before text/babel).
    const doc = new DOMParser().parseFromString(template, 'text/html');
    document.documentElement.replaceWith(doc.documentElement);

    // Resolve page-frame markers: mint this document's own blob for each
    // framed page — from local text when this is the root, otherwise by
    // asking the direct parent over the relay protocol above. An
    // unanswered request leaves the frame on about:blank, the same
    // degraded state as a refused embed.
    {
      const MARKER = /^about:blank#([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(#.*)?$/;
      const needed = [];
      for (const el of Array.from(document.querySelectorAll('iframe'))) {
        const m = MARKER.exec(el.getAttribute('src') || '');
        if (!m) continue;
        const text = pageTexts[m[1]];
        if (typeof text === 'string') {
          mountPage(el, m[2] || '', text);
        } else if (window.parent !== window && !isPageRoot) {
          const had = pendingFrames[m[1]];
          (pendingFrames[m[1]] = had || []).push({ el: el, frag: m[2] || '' });
          if (!had) needed.push(m[1]);
        }
      }
      for (const uuid of needed) {
        window.parent.postMessage({ __bundler_need: uuid }, OWN_TARGET);
      }
    }

    const dead = Array.from(document.scripts);
    for (const old of dead) {
      const s = document.createElement('script');
      for (const a of old.attributes) s.setAttribute(a.name, a.value);
      s.textContent = old.textContent;
      // text/babel scripts with a src: read and inline. transformScriptTags
      // does XHR against the src, but blob:null/ from a file:// origin is
      // silently dropped. Inlining makes it a plain inline babel script,
      // which transformScriptTags handles unconditionally.
      if ((s.type === 'text/babel' || s.type === 'text/jsx') && s.src) {
        const pre = resourceBlobs[s.src.split('#')[0]];
        s.textContent = pre ? await pre.text() : await (await fetch(s.src)).text();
        s.removeAttribute('src');
      }
      const p = s.src ? new Promise(function(r) { s.onload = s.onerror = r; }) : null;
      old.replaceWith(s);
      if (p) await p;
    }
    // Babel standalone auto-transforms type=text/babel on DOMContentLoaded,
    // which fired before we swapped the document. Trigger manually if present.
    if (window.Babel && typeof window.Babel.transformScriptTags === 'function') {
      window.Babel.transformScriptTags();
    }
  } catch (err) {
    setStatus('Error unpacking: ' + err.message);
    console.error('Bundle unpack error:', err);
  }
});

  </script>

  <script type="__bundler/manifest">
{"95d7c70d-0da3-4ee1-af65-18f73c74e4eb":{"mime":"text/javascript","compressed":true,"data":"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"}}
  </script>

  <script type="__bundler/ext_resources">
[]
  </script>

  <script type="__bundler/page_order">
[]
  </script>

  <script type="__bundler/template">
"<!DOCTYPE html>\n<html lang=\"de\"><head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width,initial-scale=1,maximum-scale=1,viewport-fit=cover\">\n<title>Wohnung – 3D Miniatur (Handy)<\u002Ftitle>\n<script type=\"importmap\">\n{\n  \"imports\": {\n    \"three\": \"https://unpkg.com/three@0.184.0/build/three.module.js\",\n    \"three/addons/controls/OrbitControls.js\": \"https://unpkg.com/three@0.184.0/examples/jsm/controls/OrbitControls.js\",\n    \"three/addons/exporters/OBJExporter.js\": \"https://unpkg.com/three@0.184.0/examples/jsm/exporters/OBJExporter.js\",\n    \"three/addons/exporters/GLTFExporter.js\": \"https://unpkg.com/three@0.184.0/examples/jsm/exporters/GLTFExporter.js\",\n    \"three/examples/jsm/\": \"https://unpkg.com/three@0.184.0/examples/jsm/\",\n    \"three/addons/\": \"https://unpkg.com/three@0.184.0/examples/jsm/\",\n    \"three-mesh-bvh\": \"https://cdn.jsdelivr.net/npm/three-mesh-bvh@0.9.5/build/index.module.js\",\n    \"three-gpu-pathtracer\": \"https://cdn.jsdelivr.net/npm/three-gpu-pathtracer@0.0.24/build/index.module.js\",\n    \"n8ao\": \"https://cdn.jsdelivr.net/npm/n8ao@1/dist/N8AO.js\",\n    \"postprocessing\": \"https://cdn.jsdelivr.net/npm/postprocessing@6/build/index.js\"\n  },\n  \"integrity\": {\n    \"https://unpkg.com/three@0.184.0/build/three.module.js\": \"sha384-8FCZ1eVO6it4+pbec2aDtnTrwjWXZLJRC+MAGCIPDgsYnUrl/E0A2YlF8ioMKI/J\",\n    \"https://unpkg.com/three@0.184.0/build/three.core.js\": \"sha384-dw2ooPewaEIrAgl6oFDBmmBWCE9oW9LxRGcfwZ0hLvEprzo202wXl7vCYHRlSnOT\",\n    \"https://unpkg.com/three@0.184.0/examples/jsm/controls/OrbitControls.js\": \"sha384-4rziNxOBZKQ69i+w+f89KJ55TCYquwchVbByQwmaOeIOXdOU2PLDn3kOfXHwIJC9\",\n    \"https://unpkg.com/three@0.184.0/examples/jsm/exporters/OBJExporter.js\": \"sha384-nbwtoZENJD3Vq+ACK0CuGQdPMuDWHkamC2KJD70EV5nfg6jQjfppKOea07YJN+N3\",\n    \"https://unpkg.com/three@0.184.0/examples/jsm/exporters/GLTFExporter.js\": \"sha384-VofkvpG6HERhFCYbsUOHeNXBCqID2nfqkQqnVzE1jc/oPcz+qJ13ADdXH08hE+cQ\"\n  }\n}\n<\u002Fscript>\n<style>\n  html,body{margin:0;height:100%;background:#efece6;font-family:Helvetica,Arial,sans-serif}\n  three-d-stage:not(:defined){visibility:hidden}\n  #rooms{position:fixed;left:50%;bottom:22px;transform:translateX(-50%);display:flex;gap:6px;padding:6px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);border-radius:999px;box-shadow:0 6px 24px rgba(30,28,24,.14)}\n  #rooms button{appearance:none;border:0;background:transparent;color:#2f2d2a;font:500 14px/1 Helvetica,Arial,sans-serif;padding:11px 18px;border-radius:999px;cursor:pointer;transition:background .2s,color .2s}\n  #rooms button:hover{background:rgba(47,45,42,.08)}\n  #rooms button.on{background:#2f2d2a;color:#f7f5f0}\n  #pov{position:fixed;left:50%;top:18px;transform:translate(-50%,-8px);opacity:0;pointer-events:none;transition:opacity .3s,transform .3s;display:flex;gap:4px;padding:4px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);border-radius:999px;box-shadow:0 1px 2px rgba(0,0,0,.06),0 6px 20px rgba(0,0,0,.08)}\n  #pov.show{opacity:1;pointer-events:auto;transform:translate(-50%,0)}\n  #pov button{appearance:none;border:0;background:transparent;color:#2f2d2a;font:500 13px/1 Helvetica,Arial,sans-serif;padding:9px 14px;border-radius:999px;cursor:pointer;transition:background .2s,color .2s}\n  #pov button:hover{background:rgba(47,45,42,.08)}\n  #pov button.on{background:#2f2d2a;color:#f7f5f0}\n  #lamp{position:fixed;left:50%;bottom:82px;transform:translate(-50%,10px);opacity:0;pointer-events:none;transition:opacity .35s,transform .35s;display:flex;align-items:center;gap:4px;padding:4px;border-radius:999px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);color:#2f2d2a;font:500 14px/1 Helvetica,Arial,sans-serif;box-shadow:0 4px 18px rgba(0,0,0,.08)}\n  #lampT{display:flex;align-items:center;gap:10px;appearance:none;border:0;background:transparent;color:inherit;font:inherit;padding:7px 14px 7px 10px;border-radius:999px;cursor:pointer;white-space:nowrap}\n  #lampT:hover{background:rgba(47,45,42,.08)}\n  #lampCtl{display:flex;align-items:center;gap:14px;max-width:0;overflow:hidden;opacity:0;transition:max-width .4s,opacity .3s,padding .4s;padding:0}\n  #lamp.on #lampCtl{max-width:420px;opacity:1;padding:0 12px 0 6px}\n  #lampSw{display:flex;gap:6px}\n  #lampSw button{appearance:none;width:22px;height:22px;border-radius:50%;border:2px solid rgba(250,248,244,.9);box-shadow:0 0 0 1px rgba(47,45,42,.18);cursor:pointer;padding:0}\n  #lampSw button.sel{box-shadow:0 0 0 2px #2f2d2a}\n  #lampSw{align-items:center;gap:8px;font-size:12px;color:#6b665e}\n  #lampSw input[type=color]{appearance:none;-webkit-appearance:none;width:26px;height:26px;border-radius:50%;border:2px solid rgba(250,248,244,.9);box-shadow:0 0 0 1px rgba(47,45,42,.25);padding:0;cursor:pointer;background:none}\n  #lampSw input[type=color]::-webkit-color-swatch-wrapper{padding:0}\n  #lampSw input[type=color]::-webkit-color-swatch{border:0;border-radius:50%}\n  #lampSw input[type=color]::-moz-color-swatch{border:0;border-radius:50%}\n  #lampDim{display:flex;align-items:center;gap:8px;font-size:12px;color:#6b665e}\n  #lampDim input{width:110px;accent-color:#2f2d2a}\n  #lampDim output{width:34px;text-align:right;font-variant-numeric:tabular-nums}\n  #lamp.show{opacity:1;transform:translate(-50%,0);pointer-events:auto}\n  #lamp i{width:12px;height:12px;border-radius:50%;background:#bdb8ae;transition:background .3s,box-shadow .3s}\n  #pt{position:fixed;top:18px;right:18px;padding:8px 12px;border-radius:999px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);color:#2f2d2a;font:500 12px/1 ui-monospace,Menlo,monospace;opacity:0;transition:opacity .3s;pointer-events:none}\n  #pt.show{opacity:1}\n  #pt{top:62px !important}\n  #rt{position:fixed;top:18px;right:18px;display:flex;align-items:center;gap:8px;appearance:none;border:0;padding:9px 14px 9px 11px;border-radius:999px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);color:#2f2d2a;font:500 13px/1 Helvetica,Arial,sans-serif;cursor:pointer;box-shadow:0 1px 2px rgba(0,0,0,.06),0 6px 20px rgba(0,0,0,.08);transition:background .2s,color .2s}\n  #rt i{width:10px;height:10px;border-radius:50%;background:#bdb8ae;transition:background .2s}\n  #rt.on{background:#2f2d2a;color:#f7f5f0}\n  #rt.on i{background:#7fd08a}\n  #lamp.on i{background:#ffc86b;box-shadow:0 0 10px 3px rgba(255,190,90,.6)}\n  #lampD{display:flex;align-items:center;gap:10px;appearance:none;border:0;background:transparent;color:inherit;font:inherit;padding:7px 14px 7px 10px;border-radius:999px;cursor:pointer;white-space:nowrap}\n  #lampD:hover{background:rgba(47,45,42,.08)}\n  #tvB{display:flex;align-items:center;gap:8px;appearance:none;border:0;background:transparent;color:inherit;font:inherit;padding:7px 14px 7px 10px;border-radius:999px;cursor:pointer;white-space:nowrap}\n  #tvB:hover{background:rgba(255,255,255,.1)}\n  #tvB svg{flex:none;transition:color .3s}\n  #tvBar{position:fixed;left:50%;bottom:22px;transform:translate(-50%,10px);opacity:0;pointer-events:none;transition:opacity .4s,transform .4s;display:flex;gap:4px;padding:4px;border-radius:999px;background:rgba(20,20,18,.55);backdrop-filter:blur(12px);-webkit-backdrop-filter:blur(12px);z-index:60}\n  #tvBar.show{opacity:1;transform:translate(-50%,0);pointer-events:auto}\n  #tvUI{position:fixed;inset:0;z-index:55;opacity:0;pointer-events:none;transition:opacity .5s;font-family:Helvetica,Arial,sans-serif;color:#f2f1ec;background:#0b0c0e;overflow:hidden}\n  #tvUI.show{opacity:1;pointer-events:auto}\n  #tvUI .tv-hero{--a:#e5484d;position:absolute;inset:0;display:flex;flex-direction:column;justify-content:flex-end;gap:6px;padding:0 clamp(20px,6vw,80px) clamp(150px,22vh,220px);background:radial-gradient(120% 90% at 85% 20%,color-mix(in oklch,var(--a) 55%,transparent),transparent 60%),linear-gradient(180deg,#0b0c0e 0%,#121316 100%);transition:background .5s}\n  #tvUI .tv-hero small{font-size:clamp(12px,1.4vw,15px);letter-spacing:.08em;text-transform:uppercase;color:#bdbab2}\n  #tvUI .tv-hero h2{margin:0;font-weight:700;font-size:clamp(40px,8vw,110px);line-height:1;letter-spacing:-.02em;text-wrap:balance}\n  #tvUI .tv-nav{position:absolute;left:0;right:0;top:clamp(14px,3vh,28px);display:flex;gap:8px;padding:6px clamp(20px,6vw,80px);overflow-x:auto;scrollbar-width:none;-webkit-overflow-scrolling:touch}\n  #tvUI .tv-nav::-webkit-scrollbar{display:none}\n  #tvUI .tv-nav button{flex:none;appearance:none;border:0;background:rgba(255,255,255,.08);color:#f2f1ec;font:500 clamp(14px,1.5vw,17px)/1 Helvetica,Arial,sans-serif;padding:13px 20px;border-radius:999px;cursor:pointer;transition:background .2s,color .2s,transform .2s;min-height:44px}\n  #tvUI .tv-nav button:hover{background:rgba(255,255,255,.16)}\n  #tvUI .tv-nav button.on{background:#f2f1ec;color:#111214;transform:scale(1.04)}\n  #tvUI .tv-vol{position:absolute;right:clamp(12px,2.5vw,32px);top:50%;transform:translateY(-50%);display:flex;flex-direction:column;align-items:center;gap:10px;padding:10px 8px;border-radius:999px;background:rgba(255,255,255,.08);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px)}\n  #tvUI .tv-vb{appearance:none;border:0;width:44px;height:44px;border-radius:50%;background:transparent;color:#f2f1ec;font:400 22px/1 Helvetica,Arial,sans-serif;cursor:pointer}\n  #tvUI .tv-vb:hover{background:rgba(255,255,255,.12)}\n  #tvUI .tv-vol input{--v:35%;-webkit-appearance:none;appearance:none;writing-mode:vertical-lr;direction:rtl;width:6px;height:clamp(120px,28vh,220px);border-radius:3px;background:linear-gradient(to top,#f2f1ec var(--v),rgba(255,255,255,.2) var(--v));cursor:pointer;margin:0}\n  #tvUI .tv-vol input::-webkit-slider-thumb{-webkit-appearance:none;width:18px;height:18px;border-radius:50%;background:#f2f1ec;box-shadow:0 1px 4px rgba(0,0,0,.4)}\n  #tvUI .tv-vol input::-moz-range-thumb{width:18px;height:18px;border:0;border-radius:50%;background:#f2f1ec}\n  #tvUI .tv-vol output{font:500 12px/1 Helvetica,Arial,sans-serif;color:#bdbab2;font-variant-numeric:tabular-nums;padding-bottom:4px}\n  @media (max-width:600px){#tvUI .tv-nav button{padding:12px 16px}#tvUI .tv-vol{right:10px;padding:6px 4px}#tvUI .tv-hero{padding-right:80px}}\n  #tvBar button{display:flex;align-items:center;gap:8px;appearance:none;border:0;background:transparent;color:#f2f1ec;font:500 13px/1 Helvetica,Arial,sans-serif;padding:9px 14px;border-radius:999px;cursor:pointer}\n  #tvBar button:hover{background:rgba(255,255,255,.12)}\n  body.tvfocus #rooms,body.tvfocus #pov,body.tvfocus #rt,body.tvfocus #pt,body.tvfocus #lamp,body.tvfocus #lamp2,body.tvfocus #mp{opacity:0 !important;pointer-events:none !important;transition:opacity .4s}\n  #tvB .pw{transition:fill .3s,stroke .3s}\n  #tvB.on .pw{fill:#e5484d;stroke:#e5484d}\n  #tvB.on svg{filter:drop-shadow(0 0 4px rgba(120,170,255,.7))}\n  #tvB{padding:11px 14px 11px 10px;font-size:13px}\n  #tvBar{bottom:max(env(safe-area-inset-bottom),18px)}\n  #tvUI .tv-nav{top:max(env(safe-area-inset-top),14px)}\n  #tvUI .tv-hero{padding-bottom:calc(110px + env(safe-area-inset-bottom))}\n  @media (orientation:landscape) and (max-height:500px){#tvUI .tv-hero{padding-bottom:80px}#tvUI .tv-hero h2{font-size:44px}#tvUI .tv-vol input{height:90px}#tvUI .tv-vb{width:36px;height:36px}}\n  #lampD b{width:12px;height:12px;border-radius:50%;background:#bdb8ae;transition:background .3s,box-shadow .3s}\n  #lampD.on b{background:#ff9a3c;box-shadow:0 0 10px 3px rgba(255,150,60,.6)}\n  #lamp2{position:fixed;left:50%;bottom:82px;transform:translate(-50%,10px);opacity:0;pointer-events:none;transition:opacity .35s,transform .35s;display:flex;align-items:center;gap:4px;padding:4px;border-radius:999px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);color:#2f2d2a;font:500 14px/1 Helvetica,Arial,sans-serif;box-shadow:0 4px 18px rgba(0,0,0,.08)}\n  #lamp2.show{opacity:1;transform:translate(-50%,0);pointer-events:auto}\n  #tripT{display:flex;align-items:center;gap:10px;appearance:none;border:0;background:transparent;color:inherit;font:inherit;padding:7px 14px 7px 10px;border-radius:999px;cursor:pointer;white-space:nowrap}\n  #tripT:hover{background:rgba(47,45,42,.08)}\n  #tripT i{width:12px;height:12px;border-radius:50%;background:#bdb8ae;transition:background .3s,box-shadow .3s}\n  #tripCtl{display:flex;align-items:center;gap:14px;max-width:0;overflow:hidden;opacity:0;transition:max-width .4s,opacity .3s,padding .4s;padding:0}\n  #lamp2.on #tripCtl{max-width:560px;opacity:1;padding:0 12px 0 6px}\n  #tripCtl label{display:flex;align-items:center;gap:8px;font-size:12px;color:#6b665e}\n  #tripCtl input[type=range]{width:100px;accent-color:#2f2d2a}\n  #tripCtl output{width:34px;text-align:right;font-variant-numeric:tabular-nums}\n  #tripCtl input[type=color]{appearance:none;-webkit-appearance:none;width:26px;height:26px;border-radius:50%;border:2px solid rgba(250,248,244,.9);box-shadow:0 0 0 1px rgba(47,45,42,.25);padding:0;cursor:pointer;background:none}\n  #tripCtl input[type=color]::-webkit-color-swatch-wrapper{padding:0}\n  #tripCtl input[type=color]::-webkit-color-swatch{border:0;border-radius:50%}\n  #tripCtl input[type=color]::-moz-color-swatch{border:0;border-radius:50%}\n  #rooms,#pov,#rt,#pt,#lamp,#lamp2,three-d-stage::part(toolbar){transition:opacity .6s}\n  body.idle #rooms,body.idle #pov,body.idle #rt,body.idle #pt,body.idle #lamp,body.idle #lamp2{opacity:0 !important;pointer-events:none}\n  body.idle{cursor:none}\n\n  /* muavin-Gradient für GUI-Leisten */\n  #rooms,#pov,#lamp,#lamp2,#pt,#rt{background-color:#000 !important;background-image:radial-gradient(circle at 65.34% 44.62%, rgba(95,95,95,1) 0%, rgba(95,95,95,.844) 8.53%, rgba(95,95,95,.5) 17.05%, rgba(95,95,95,.156) 25.58%, rgba(95,95,95,0) 34.1%),radial-gradient(circle at 28.07% 74.48%, rgba(53,54,48,1) 0%, rgba(53,54,48,.844) 11.41%, rgba(53,54,48,.5) 22.83%, rgba(53,54,48,.156) 34.24%, rgba(53,54,48,0) 45.65%),radial-gradient(circle at 52.42% 19.94%, rgba(56,122,56,1) 0%, rgba(56,122,56,.844) 14.39%, rgba(56,122,56,.5) 28.77%, rgba(56,122,56,.156) 43.16%, rgba(56,122,56,0) 57.55%),radial-gradient(circle at 80.31% 84.47%, rgba(0,0,0,1) 0%, rgba(0,0,0,.844) 17.27%, rgba(0,0,0,.5) 34.55%, rgba(0,0,0,.156) 51.82%, rgba(0,0,0,0) 69.1%) !important;background-size:100% 100% !important;color:#f2f1ec !important;box-shadow:0 6px 24px rgba(0,0,0,.25),inset 0 0 0 1px rgba(255,255,255,.08)}\n  #rooms button,#pov button{color:#f2f1ec}\n  #rooms button:hover,#pov button:hover,#lampT:hover,#lampD:hover,#tripT:hover{background:rgba(255,255,255,.1)}\n  #rooms button.on,#pov button.on,#rt.on{background:#f2f1ec !important;background-image:none !important;color:#141412 !important}\n  #lampSw,#lampDim,#tripCtl{color:#d9d7d0 !important}\n  #lampSw button.sel{box-shadow:0 0 0 2px #f2f1ec}\n  #lampDim input[type=range],#tripCtl input[type=range]{accent-color:#f2f1ec}\n  .lp-sw{appearance:none;width:26px;height:26px;border-radius:50%;border:2px solid rgba(250,248,244,.9);box-shadow:0 0 0 1px rgba(47,45,42,.25);padding:0;cursor:pointer;flex:none}\n  .lpick{position:fixed;z-index:50;width:236px;padding:14px;border-radius:18px;background:rgba(26,27,24,.38);backdrop-filter:blur(18px) saturate(1.2);-webkit-backdrop-filter:blur(18px) saturate(1.2);color:#f2f1ec;font:500 12px/1.2 Helvetica,Arial,sans-serif;box-shadow:0 10px 36px rgba(0,0,0,.35),inset 0 0 0 1px rgba(255,255,255,.08);display:none;flex-direction:column;gap:14px;transition:opacity .6s}\n  .lpick.open{display:flex}\n  body.lpfocus #rooms,body.lpfocus #pov,body.lpfocus #rt,body.lpfocus #pt,body.lpfocus #lamp,body.lpfocus #lamp2,body.lpfocus three-d-stage::part(toolbar){opacity:0 !important;pointer-events:none !important}\n  .lp-done{appearance:none;border:0;border-radius:999px;padding:9px 0;background:rgba(255,255,255,.1);color:#f2f1ec;font:inherit;cursor:pointer}\n  .lp-done:hover{background:rgba(255,255,255,.18)}\n  body.idle .lpick{opacity:0;pointer-events:none}\n  .lp-seg{display:grid;grid-template-columns:1fr 1fr;gap:3px;padding:3px;border-radius:999px;background:rgba(255,255,255,.08)}\n  .lp-seg button{appearance:none;border:0;border-radius:999px;padding:7px 0;background:transparent;color:#d9d7d0;font:inherit;cursor:pointer}\n  .lp-seg button.on{background:#f2f1ec;color:#141412}\n  .lp-row{display:flex;flex-direction:column;gap:7px}\n  .lp-row>div{display:flex;justify-content:space-between;color:#d9d7d0}\n  .lp-row output{font-variant-numeric:tabular-nums;color:#f2f1ec}\n  .lp-row small{display:flex;justify-content:space-between;color:#a9a69e;font-size:11px}\n  .lpick input[type=range]{width:100%;margin:0;accent-color:#f2f1ec}\n  .lpick input.lp-temp{appearance:none;-webkit-appearance:none;height:10px;border-radius:5px;outline:none}\n  .lp-temp::-webkit-slider-thumb{-webkit-appearance:none;width:18px;height:18px;border-radius:50%;background:#fff;border:2px solid #1a1b18;box-shadow:0 0 0 1px rgba(255,255,255,.6);cursor:pointer}\n  .lp-temp::-moz-range-thumb{width:14px;height:14px;border-radius:50%;background:#fff;border:2px solid #1a1b18;cursor:pointer}\n  .lp-wheel{position:relative;width:180px;height:180px;margin:0 auto;touch-action:none;cursor:pointer}\n  .lp-wheel canvas{width:180px;height:180px;border-radius:50%;display:block}\n  .lp-wheel i{position:absolute;width:18px;height:18px;margin:-9px 0 0 -9px;border-radius:50%;border:2px solid #fff;box-shadow:0 0 0 1px rgba(0,0,0,.4),0 2px 6px rgba(0,0,0,.4);pointer-events:none}\n  /* ---------- Handy-Ansicht ---------- */\n  html,body{overscroll-behavior:none;-webkit-tap-highlight-color:transparent;touch-action:none}\n  @media (max-width:700px){\n    #rooms{left:12px;right:12px;transform:none;bottom:calc(14px + max(env(safe-area-inset-bottom), 18px));overflow-x:auto;scrollbar-width:none;justify-content:flex-start;gap:2px;padding:5px;touch-action:pan-x}\n    #rooms::-webkit-scrollbar{display:none}\n    #rooms button{flex:none;padding:13px 15px;font-size:14px}\n    #pov{left:12px;top:calc(12px + max(env(safe-area-inset-top), 46px));transform:translateY(-8px)}\n    #pov.show{transform:none}\n    #pov button{padding:11px 12px;font-size:12px}\n    #rt{top:calc(12px + max(env(safe-area-inset-top), 46px));right:12px;padding:11px 12px 11px 10px;font-size:12px}\n    #pt{top:calc(62px + max(env(safe-area-inset-top), 46px)) !important;right:12px}\n    #lamp,#lamp2{left:12px;right:12px;bottom:calc(78px + max(env(safe-area-inset-bottom), 18px));transform:translateY(10px);flex-wrap:wrap;justify-content:center;border-radius:24px;row-gap:2px}\n    #lamp.show,#lamp2.show{transform:none}\n    #lampT,#lampD,#tripT{padding:11px 14px 11px 10px;font-size:13px}\n    #lamp.on #lampCtl,#lamp2.on #tripCtl{max-width:100%;padding:4px 10px 8px}\n    #tripCtl{flex-wrap:wrap;justify-content:center;gap:12px}\n    #tripCtl input[type=range]{width:120px}\n    .lp-sw{width:30px;height:30px}\n    .lpick{left:0 !important;right:0;top:auto !important;bottom:0;transform:none !important;width:auto;border-radius:24px 24px 0 0;padding:16px 20px calc(20px + max(env(safe-area-inset-bottom), 18px));gap:16px;font-size:13px}\n    .lp-seg button,.lp-done{padding:12px 0}\n    .lp-wheel,.lp-wheel canvas{width:180px;height:180px}\n  }\n  /* ---------- Handy: 3D oben, Fernbedienung unten ---------- */\n  #rooms,#pov,#rt,#pt,#lamp,#lamp2{display:none !important}\n  body{display:flex;flex-direction:column;height:100vh;height:100dvh;overflow:hidden;cursor:auto !important}\n  three-d-stage{flex:none;height:36%;min-height:0}\n  #remote{position:relative;z-index:5;flex:1;min-height:0;margin-top:-22px;overflow-y:auto;touch-action:pan-y;display:flex;flex-direction:column;gap:12px;padding:10px 16px max(env(safe-area-inset-bottom), 22px);border-radius:28px 28px 0 0;background:linear-gradient(180deg,#262624,#171716 60%);color:#f2f1ec;box-shadow:0 -10px 30px rgba(0,0,0,.18),inset 0 1px 0 rgba(255,255,255,.08);font:500 14px/1.2 Helvetica,Arial,sans-serif}\n  #remote button{appearance:none;border:0;font:inherit;color:inherit;cursor:pointer;-webkit-tap-highlight-color:transparent}\n  .r-grip{width:40px;height:4px;border-radius:2px;background:rgba(255,255,255,.18);margin:0 auto 2px;flex:none}\n  .r-head{display:flex;align-items:center;justify-content:space-between;gap:12px}\n  .r-stat{display:flex;flex-direction:column;gap:4px}\n  .r-stat small{font-size:11px;letter-spacing:.08em;text-transform:uppercase;color:#9d9a92}\n  .r-stat b{font-size:17px;font-weight:600}\n  #rPower{display:flex;align-items:center;gap:9px;padding:0 16px 0 12px;height:48px;border-radius:24px;background:#b8402f !important;color:#fff !important;box-shadow:0 4px 14px rgba(184,64,47,.35),inset 0 1px 0 rgba(255,255,255,.2);font-size:13px !important;font-weight:600 !important;flex:none}\n  #rPower:active{transform:scale(.96)}\n  .r-label{font-size:11px;letter-spacing:.08em;text-transform:uppercase;color:#9d9a92;margin:4px 2px -4px}\n  #rRooms{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:7px}\n  three-d-stage{transition:height .5s cubic-bezier(.3,.8,.2,1)}\n  #remote{flex:none !important;height:calc(64% + 22px)}\n  body.lpfocus three-d-stage{height:calc(100% + 22px)}\n  .lpick.open{animation:lpUp .5s cubic-bezier(.3,.8,.2,1) .1s both}\n  @keyframes lpUp{from{translate:0 110%}to{translate:0 0}}\n  .r-key{height:48px;border-radius:14px;background:#2f2f2c !important;box-shadow:inset 0 1px 0 rgba(255,255,255,.07),0 2px 0 #0e0e0d;font-size:12px !important;padding:0 4px;transition:background .15s,color .15s,transform .1s}\n  .r-key.wide{grid-column:span 2}\n  .r-key:active{transform:translateY(1px)}\n  .r-key.on{background:#f2f1ec !important;color:#141412 !important}\n  #rPov{display:grid;grid-template-columns:1fr 1fr;gap:3px;padding:3px;border-radius:14px;background:#0f0f0e;transition:opacity .2s}\n  #rPov button{height:40px;border-radius:11px;font-size:13px !important;color:#bdbab2 !important}\n  #rPov button.on{background:#3a3a37;color:#f2f1ec !important}\n  #rPov.off{opacity:.35;pointer-events:none}\n  #rLights{display:flex;flex-direction:column;gap:7px}\n  .r-lamp{display:flex;gap:7px}\n  .r-tog{flex:1;display:flex;align-items:center;gap:12px;height:56px;padding:0 14px;border-radius:16px;background:#2f2f2c !important;box-shadow:inset 0 1px 0 rgba(255,255,255,.07),0 2px 0 #0e0e0d;text-align:left}\n  .r-tog i{width:12px;height:12px;border-radius:50%;background:#55534e;flex:none;transition:background .3s,box-shadow .3s}\n  .r-tog span{flex:1;display:flex;flex-direction:column;gap:3px;font-size:14px}\n  .r-tog em{font-style:normal;font-size:11px;color:#9d9a92}\n  .r-tog b{width:38px;height:22px;border-radius:11px;background:#4a4945;position:relative;flex:none;transition:background .2s}\n  .r-tog b::after{content:\"\";position:absolute;top:3px;left:3px;width:16px;height:16px;border-radius:50%;background:#f2f1ec;transition:transform .2s}\n  .r-lamp.on .r-tog b{background:#e9e6de}\n  .r-lamp.on .r-tog b::after{transform:translateX(16px);background:#1b1b19}\n  .r-col{width:56px;height:56px;border-radius:16px;background:#2f2f2c !important;box-shadow:inset 0 1px 0 rgba(255,255,255,.07),0 2px 0 #0e0e0d;display:grid;place-items:center;flex:none}\n  .r-col::after{content:\"\";width:24px;height:24px;border-radius:50%;background:var(--c,#ffd6a0);box-shadow:0 0 0 2px #1b1b19,0 0 0 3px rgba(255,255,255,.25)}\n  .r-tv{display:flex;gap:7px}\n  .r-tv.on .r-tog b{background:#e9e6de}\n  .r-tv.on .r-tog b::after{transform:translateX(16px);background:#1b1b19}\n  .r-tv .r-tog svg{flex:none;color:#9d9a92}\n  .r-tv.on .r-tog .pw{fill:#e5484d;stroke:#e5484d}\n  .r-rc{color:#f2f1ec}\n  .r-rc::after{display:none}\n  #tvUI,#tvBar{display:none !important}\n  #rTvPanel{display:none;flex-direction:column;gap:12px}\n  body.tvfocus #remote > :not(.r-grip):not(#rTvPanel){display:none !important}\n  body.tvfocus #rTvPanel{display:flex;animation:tvIn .4s cubic-bezier(.3,.8,.2,1) both}\n  @keyframes tvIn{from{opacity:0;translate:0 12px}to{opacity:1;translate:0 0}}\n  .tvp-head{display:flex;align-items:center;gap:8px}\n  .tvp-head .r-stat{flex:1}\n  .tvp-ic{width:48px;height:48px;border-radius:14px;display:grid;place-items:center;background:#2f2f2c !important;box-shadow:inset 0 1px 0 rgba(255,255,255,.07),0 2px 0 #0e0e0d;flex:none}\n  .tvp-ic.pow{color:#e5484d}\n  #tvpApps{display:flex;gap:7px;overflow-x:auto;scrollbar-width:none;margin:0 -16px;padding:2px 16px 4px;scroll-padding:16px}\n  #tvpApps::-webkit-scrollbar{display:none}\n  #tvpApps button{flex:none;display:flex;align-items:center;gap:9px;height:44px;padding:0 16px 0 13px;border-radius:999px;white-space:nowrap;background:#2f2f2c !important;box-shadow:inset 0 1px 0 rgba(255,255,255,.07),0 2px 0 #0e0e0d;font-size:14px;text-align:left}\n  #tvpApps button i{width:10px;height:10px;border-radius:50%;flex:none}\n  #tvpApps button.on{background:#e9e6de !important;color:#1b1b19}\n  .tvp-pad{display:flex;align-items:center;justify-content:center;gap:clamp(12px,5vw,24px);padding:6px 0 4px}\n  .tvp-vol,.tvp-side{display:flex;flex-direction:column;align-items:center;justify-content:space-between;width:56px;height:184px;padding:6px 0;border-radius:999px;background:#2f2f2c;box-shadow:inset 0 1px 0 rgba(255,255,255,.07),0 2px 0 #0e0e0d;flex:none}\n  .tvp-side{justify-content:space-around}\n  .tvp-vol button,.tvp-side button{background:transparent;color:#f2f1ec;width:46px;height:46px;border-radius:50%;font-size:24px !important;line-height:1;display:grid;place-items:center}\n  .tvp-vol input{display:none}\n  .tvp-vol output{font-size:13px;color:#9d9a92;font-variant-numeric:tabular-nums}\n  #tvpMute .x{display:none}\n  #tvpMute.on{color:#e5484d}\n  #tvpMute.on .x{display:inline}\n  #tvpMute.on .w{display:none}\n  .tvp-dpad{position:relative;width:184px;height:184px;border-radius:50%;flex:none;background:radial-gradient(circle at 50% 35%,#3a3a36,#2a2a27 70%);box-shadow:inset 0 1px 0 rgba(255,255,255,.08),0 3px 0 #0e0e0d,0 10px 24px rgba(0,0,0,.35)}\n  .tvp-dpad button{background:transparent;position:absolute;width:56px;height:56px;display:grid;place-items:center;border-radius:50%;color:#d9d7d0}\n  .tvp-dpad button:active{background:rgba(255,255,255,.08)}\n  .tvp-dpad .k-up{top:4px;left:64px}\n  .tvp-dpad .k-down{bottom:4px;left:64px}\n  .tvp-dpad .k-left{left:4px;top:64px}\n  .tvp-dpad .k-right{right:4px;top:64px}\n  .tvp-dpad .k-ok{left:52px;top:52px;width:80px;height:80px;background:#e9e6de !important;color:#1b1b19 !important;font-size:15px !important;font-weight:700;letter-spacing:.04em;box-shadow:0 2px 0 #8e8b84,0 6px 14px rgba(0,0,0,.35)}\n  .tvp-dpad .k-ok:active{transform:translateY(2px);box-shadow:0 0 0 #8e8b84}\n  .tvp-dpad .k-ok.play{background:#e5484d !important;color:#fff !important;box-shadow:0 2px 0 #8f2a2e,0 6px 14px rgba(229,72,77,.4)}\n  .tvp-vol button:active,.tvp-side button:active{background:rgba(255,255,255,.08)}\n  .tvp-vol button:active,#tvpApps button:active,.tvp-ic:active{transform:translateY(1px)}\n  .tvp-vol input{flex:1;min-width:0;accent-color:#e9e6de}\n  .tvp-vol output{width:28px;text-align:right;font-size:13px;color:#9d9a92;font-variant-numeric:tabular-nums}\n  .r-two{display:grid;grid-template-columns:1fr 1fr;gap:7px}\n  .r-two button{height:48px;border-radius:14px;background:#2f2f2c !important;box-shadow:inset 0 1px 0 rgba(255,255,255,.07),0 2px 0 #0e0e0d;font-size:14px !important}\n  .r-two button:active,.r-tog:active,.r-col:active{transform:translateY(1px)}\n<\u002Fstyle>\n<\u002Fhead>\n<body>\n\n<three-d-stage name=\"wohnung\" background=\"#efece6\"><\u002Fthree-d-stage>\n<div id=\"remote\">\n  <div class=\"r-grip\"><\u002Fdiv>\n  <div id=\"rTvPanel\">\n    <div class=\"tvp-head\"><button class=\"tvp-ic\" id=\"tvpBack\" aria-label=\"Zurück\"><svg viewBox=\"0 0 24 24\" width=\"22\" height=\"22\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M15 5l-7 7 7 7\"><\u002Fpath><\u002Fsvg><\u002Fbutton><div class=\"r-stat\"><small>Fernseher<\u002Fsmall><b id=\"tvpStat\">YouTube<\u002Fb><\u002Fdiv><button class=\"tvp-ic pow\" id=\"tvpOff\" aria-label=\"Ausschalten\"><svg viewBox=\"0 0 24 24\" width=\"22\" height=\"22\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.4\" stroke-linecap=\"round\"><path d=\"M12 3v8\"><\u002Fpath><path d=\"M6.3 6.8a8 8 0 1 0 11.4 0\"><\u002Fpath><\u002Fsvg><\u002Fbutton><\u002Fdiv>\n    <div class=\"tvp-pad\">\n      <div class=\"tvp-vol\"><button data-d=\"5\" aria-label=\"Lauter\">+<\u002Fbutton><input type=\"range\" min=\"0\" max=\"100\" step=\"1\" aria-label=\"Lautstärke\"><output><\u002Foutput><button data-d=\"-5\" aria-label=\"Leiser\">−<\u002Fbutton><\u002Fdiv>\n      <div class=\"tvp-dpad\"><button data-k=\"up\" class=\"k-up\" aria-label=\"Lauter\"><svg viewBox=\"0 0 24 24\" width=\"22\" height=\"22\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.4\" stroke-linecap=\"round\" stroke-linejoin=\"round\" style=\"transform:rotate(0deg)\"><path d=\"M6 15l6-6 6 6\"><\u002Fpath><\u002Fsvg><\u002Fbutton><button data-k=\"right\" class=\"k-right\" aria-label=\"Nächste App\"><svg viewBox=\"0 0 24 24\" width=\"22\" height=\"22\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.4\" stroke-linecap=\"round\" stroke-linejoin=\"round\" style=\"transform:rotate(90deg)\"><path d=\"M6 15l6-6 6 6\"><\u002Fpath><\u002Fsvg><\u002Fbutton><button data-k=\"down\" class=\"k-down\" aria-label=\"Leiser\"><svg viewBox=\"0 0 24 24\" width=\"22\" height=\"22\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.4\" stroke-linecap=\"round\" stroke-linejoin=\"round\" style=\"transform:rotate(180deg)\"><path d=\"M6 15l6-6 6 6\"><\u002Fpath><\u002Fsvg><\u002Fbutton><button data-k=\"left\" class=\"k-left\" aria-label=\"Vorherige App\"><svg viewBox=\"0 0 24 24\" width=\"22\" height=\"22\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.4\" stroke-linecap=\"round\" stroke-linejoin=\"round\" style=\"transform:rotate(270deg)\"><path d=\"M6 15l6-6 6 6\"><\u002Fpath><\u002Fsvg><\u002Fbutton><button data-k=\"ok\" class=\"k-ok\" id=\"tvpOk\">OK<\u002Fbutton><\u002Fdiv>\n      <div class=\"tvp-side\"><button id=\"tvpMute\" aria-label=\"Stumm\"><svg viewBox=\"0 0 24 24\" width=\"22\" height=\"22\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M4 9h4l5-4v14l-5-4H4z\"><\u002Fpath><path class=\"w\" d=\"M16.5 8.5a5 5 0 0 1 0 7\"><\u002Fpath><path class=\"x\" d=\"M16 9l5 6M21 9l-5 6\"><\u002Fpath><\u002Fsvg><\u002Fbutton><button id=\"tvpHome\" aria-label=\"Startseite\"><svg viewBox=\"0 0 24 24\" width=\"22\" height=\"22\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M4 11l8-7 8 7v9H4z\"><\u002Fpath><\u002Fsvg><\u002Fbutton><\u002Fdiv>\n    <\u002Fdiv>\n    <div class=\"r-label\">Apps<\u002Fdiv>\n    <div id=\"tvpApps\"><\u002Fdiv>\n  <\u002Fdiv>\n  <div class=\"r-head\">\n    <div class=\"r-stat\"><small>Wohnung<\u002Fsmall><b id=\"rStat\">Alle Lichter aus<\u002Fb><\u002Fdiv>\n    <button id=\"rPower\" aria-label=\"Wohnung verlassen\"><svg viewBox=\"0 0 24 24\" width=\"22\" height=\"22\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.4\" stroke-linecap=\"round\"><path d=\"M12 3v8\"><\u002Fpath><path d=\"M6.3 6.8a8 8 0 1 0 11.4 0\"><\u002Fpath><\u002Fsvg><span>Wohnung verlassen<\u002Fspan><\u002Fbutton>\n  <\u002Fdiv>\n  <div class=\"r-label\">Räume<\u002Fdiv>\n  <div id=\"rRooms\"><\u002Fdiv>\n  <div class=\"r-label\" id=\"rLightsLbl\">Licht<\u002Fdiv>\n  <div id=\"rLights\">\n    <div class=\"r-lamp\" data-l=\"bogen\" data-room=\"1\"><button class=\"r-tog\"><i><\u002Fi><span>Bogenlampe<em>Wohnzimmer<\u002Fem><\u002Fspan><b><\u002Fb><\u002Fbutton><button class=\"r-col\" aria-label=\"Farbe\"><\u002Fbutton><\u002Fdiv>\n    <div class=\"r-lamp\" data-l=\"donut\" data-room=\"1\"><button class=\"r-tog\"><i><\u002Fi><span>Donut-Lampe<em>Wohnzimmer · Regal<\u002Fem><\u002Fspan><b><\u002Fb><\u002Fbutton><\u002Fdiv>\n    <div class=\"r-lamp\" data-l=\"trip\" data-room=\"3\"><button class=\"r-tog\"><i><\u002Fi><span>Tripod-Lampe<em>Schlafzimmer<\u002Fem><\u002Fspan><b><\u002Fb><\u002Fbutton><button class=\"r-col\" aria-label=\"Farbe\"><\u002Fbutton><\u002Fdiv>\n  <\u002Fdiv>\n  <div class=\"r-label\" id=\"rTvLbl\">Fernseher<\u002Fdiv>\n  <div class=\"r-tv\" id=\"rTv\"><button class=\"r-tog\" id=\"rTvPow\"><svg viewBox=\"0 0 24 24\" width=\"18\" height=\"18\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.6\"><rect x=\"7.5\" y=\"2.5\" width=\"9\" height=\"19\" rx=\"3\"><\u002Frect><circle cx=\"12\" cy=\"7\" r=\"1.6\" class=\"pw\"><\u002Fcircle><circle cx=\"12\" cy=\"12.5\" r=\"2.2\"><\u002Fcircle><\u002Fsvg><span>Fernseher<em>Wohnzimmer · Westwand<\u002Fem><\u002Fspan><b><\u002Fb><\u002Fbutton><button class=\"r-col r-rc\" id=\"rTvOpen\" aria-label=\"Fernbedienung öffnen\"><svg viewBox=\"0 0 24 24\" width=\"22\" height=\"22\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.6\"><rect x=\"7.5\" y=\"2.5\" width=\"9\" height=\"19\" rx=\"3\"><\u002Frect><circle cx=\"12\" cy=\"7\" r=\"1.6\" fill=\"#e5484d\" stroke=\"#e5484d\"><\u002Fcircle><circle cx=\"12\" cy=\"12.5\" r=\"2.2\"><\u002Fcircle><circle cx=\"10.3\" cy=\"17.3\" r=\".6\" fill=\"currentColor\"><\u002Fcircle><circle cx=\"13.7\" cy=\"17.3\" r=\".6\" fill=\"currentColor\"><\u002Fcircle><\u002Fsvg><\u002Fbutton><\u002Fdiv>\n  <div class=\"r-two\"><button id=\"rAllOn\">Alle an<\u002Fbutton><button id=\"rAllOff\">Alles aus<\u002Fbutton><\u002Fdiv>\n<\u002Fdiv>\n<div id=\"rooms\"><\u002Fdiv>\n<div id=\"pov\"><button data-m=\"bird\" class=\"on\">Vogelperspektive<\u002Fbutton><button data-m=\"fp\">Frei umsehen<\u002Fbutton><\u002Fdiv>\n<button id=\"rt\" aria-pressed=\"false\"><i><\u002Fi><span>Render aus<\u002Fspan><\u002Fbutton>\n<div id=\"pt\"><\u002Fdiv>\n<div id=\"lamp\"><button id=\"lampT\"><i><\u002Fi><span>Bogenlampe an<\u002Fspan><\u002Fbutton><div id=\"lampCtl\"><div id=\"lampSw\"><\u002Fdiv><label id=\"lampDim\" style=\"display:none\"><span>Stärke<\u002Fspan><input type=\"range\" min=\"10\" max=\"200\" step=\"5\" value=\"100\"><output>100%<\u002Foutput><\u002Flabel><\u002Fdiv><button id=\"lampD\" aria-pressed=\"false\"><b><\u002Fb><span>Donut-Lampe an<\u002Fspan><\u002Fbutton><button id=\"tvB\" aria-pressed=\"false\" title=\"Fernseher an/aus\"><svg viewBox=\"0 0 24 24\" width=\"18\" height=\"18\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.6\"><rect x=\"7.5\" y=\"2.5\" width=\"9\" height=\"19\" rx=\"3\"><\u002Frect><circle cx=\"12\" cy=\"7\" r=\"1.6\" class=\"pw\"><\u002Fcircle><circle cx=\"12\" cy=\"12.5\" r=\"2.2\"><\u002Fcircle><circle cx=\"10.3\" cy=\"17.3\" r=\".6\" fill=\"currentColor\"><\u002Fcircle><circle cx=\"13.7\" cy=\"17.3\" r=\".6\" fill=\"currentColor\"><\u002Fcircle><\u002Fsvg><span>Fernseher an<\u002Fspan><\u002Fbutton><\u002Fdiv>\n<div id=\"tvUI\"><div class=\"tv-hero\"><small>Zuletzt geöffnet<\u002Fsmall><h2><\u002Fh2><\u002Fdiv><nav class=\"tv-nav\"><\u002Fnav><div class=\"tv-vol\"><button class=\"tv-vb\" data-d=\"5\" aria-label=\"Lauter\">+<\u002Fbutton><input type=\"range\" min=\"0\" max=\"100\" step=\"1\" aria-label=\"Lautstärke\"><button class=\"tv-vb\" data-d=\"-5\" aria-label=\"Leiser\">−<\u002Fbutton><output><\u002Foutput><\u002Fdiv><\u002Fdiv>\n<div id=\"tvBar\"><button id=\"tvBack\">Zurück<\u002Fbutton><button id=\"tvOff\"><svg viewBox=\"0 0 24 24\" width=\"18\" height=\"18\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.6\"><rect x=\"7.5\" y=\"2.5\" width=\"9\" height=\"19\" rx=\"3\"><\u002Frect><circle cx=\"12\" cy=\"7\" r=\"1.6\" fill=\"#e5484d\" stroke=\"#e5484d\"><\u002Fcircle><circle cx=\"12\" cy=\"12.5\" r=\"2.2\"><\u002Fcircle><circle cx=\"10.3\" cy=\"17.3\" r=\".6\" fill=\"currentColor\"><\u002Fcircle><circle cx=\"13.7\" cy=\"17.3\" r=\".6\" fill=\"currentColor\"><\u002Fcircle><\u002Fsvg><span>Ausschalten<\u002Fspan><\u002Fbutton><\u002Fdiv>\n<div id=\"lamp2\"><button id=\"tripT\"><i><\u002Fi><span>Tripod-Lampe an<\u002Fspan><\u002Fbutton><div id=\"tripCtl\"><label><button id=\"tripCol\" class=\"lp-sw\" title=\"Licht einstellen\"><\u002Fbutton><\u002Flabel><label style=\"display:none\"><span>Stärke<\u002Fspan><input id=\"tripDim\" type=\"range\" min=\"10\" max=\"200\" step=\"5\" value=\"100\"><output>100%<\u002Foutput><\u002Flabel><label><span>Kegel<\u002Fspan><input id=\"tripCone\" type=\"range\" min=\"15\" max=\"80\" step=\"1\" value=\"32\"><output>32°<\u002Foutput><\u002Flabel><\u002Fdiv><\u002Fdiv>\n<script src=\"95d7c70d-0da3-4ee1-af65-18f73c74e4eb\"><\u002Fscript>\n<script type=\"module\">\n// moebel.js (eingebettet)\n// Möbel-Builder (aus Sofa 3D / Regal 3D / Bogenlampe 3D übernommen)\nconst mk = (THREE, name, geo, mat, x=0, y=0, z=0) => { const m = new THREE.Mesh(geo, mat); m.name=name; m.position.set(x,y,z); return m; };\n\nfunction buildSofa(THREE){\n  const M = {\n    fabric: new THREE.MeshStandardMaterial({ name:'poly_wool_herringbone', color:0x8b8780, roughness:0.95 }),\n    metal:  new THREE.MeshStandardMaterial({ name:'black_powdercoat', color:0x1d1d1f, roughness:0.45, metalness:0.6 }),\n    cup:    new THREE.MeshStandardMaterial({ name:'cupholder_black', color:0x151515, roughness:0.8 }),\n  };\n  const TEX = 0.5;\n  function rbox(w, h, d, r, k = 7, bulge = 0){\n    const half = [w/2, h/2, d/2];\n    const S = half.map(hh => { const a=[]; for(let i=k;i>=0;i--) a.push(-(hh-r) - r*Math.sin(i/k*Math.PI/2)); for(let i=0;i<=k;i++) a.push((hh-r) + r*Math.sin(i/k*Math.PI/2)); return a; });\n    const pos=[], nor=[], uv=[], idx=[];\n    for (let a=0;a<3;a++) for (const s of [1,-1]){\n      const u=(a+1)%3, v=(a+2)%3, su=S[u], sv=S[v], base=pos.length/3;\n      for (let j=0;j<sv.length;j++) for (let i=0;i<su.length;i++){\n        const p=[0,0,0]; p[a]=s*half[a]; p[u]=su[i]; p[v]=sv[j];\n        const c=p.map((x,m)=>Math.max(-(half[m]-r),Math.min(half[m]-r,x)));\n        let o=p.map((x,m)=>x-c[m]); const L=Math.hypot(...o)||1; o=o.map(x=>x/L);\n        const q=c.map((x,m)=>x+o[m]*r);\n        pos.push(...q); nor.push(...o);\n        const ax=Math.abs(o[0]),ay=Math.abs(o[1]),az=Math.abs(o[2]);\n        if (ay>=ax&&ay>=az) uv.push(q[0]/TEX,q[2]/TEX); else if (ax>=az) uv.push(q[2]/TEX,q[1]/TEX); else uv.push(q[0]/TEX,q[1]/TEX);\n      }\n      const nu=su.length;\n      for (let j=0;j<sv.length-1;j++) for (let i=0;i<nu-1;i++){\n        const A=base+j*nu+i, B=A+1, C=A+nu+1, D=A+nu;\n        if (s>0) idx.push(A,B,C, A,C,D); else idx.push(A,C,B, A,D,C);\n      }\n    }\n    const g = new THREE.BufferGeometry();\n    g.setAttribute('position', new THREE.Float32BufferAttribute(pos,3));\n    g.setAttribute('normal', new THREE.Float32BufferAttribute(nor,3));\n    g.setAttribute('uv', new THREE.Float32BufferAttribute(uv,2));\n    g.setIndex(idx);\n    if (bulge){\n      const p=g.attributes.position;\n      for (let i=0;i<p.count;i++){ const x=p.getX(i)/half[0], y=p.getY(i)/half[1]; p.setZ(i, p.getZ(i)*(1+bulge*(1-x*x)*(1-y*y))); }\n      g.computeVertexNormals();\n    }\n    return g;\n  }\n  const mesh = (...a) => mk(THREE, ...a);\n  const W=1.85, D=0.925, L=0.20, ARM=0.24, TOP=0.21, G=0.004;\n  const sofa = new THREE.Group(); sofa.name = 'sofa';\n  for (const [i,sx] of [[1,-1],[2,1]])\n    sofa.add(mesh('lage_unten_'+i, rbox(W/2-G, L-G, D, 0.035), M.fabric, sx*W/4, L/2, 0));\n  const hinge = new THREE.Group(); hinge.name='klappteil'; hinge.position.set(0, L, D/2);\n  for (const [i,sx] of [[1,-1],[2,1]])\n    hinge.add(mesh('lage_mitte_'+i, rbox(W/2-G, L-G, D, 0.035), M.fabric, sx*W/4, L/2, -D/2));\n  sofa.add(hinge);\n  const top = new THREE.Group(); top.name='aufbau'; top.position.y = 2*L;\n  for (const [n,sx] of [['links',-1],['rechts',1]]){\n    const x = sx*(W/2-ARM/2);\n    top.add(mesh('armlehne_'+n, rbox(ARM, TOP, D, 0.05), M.fabric, x, TOP/2, 0));\n    top.add(mesh('becherhalter_'+n, new THREE.CylinderGeometry(0.04,0.04,0.012,40), M.cup, x, TOP+0.001, D/2-0.1));\n    const ring = mesh('becherhalter_ring_'+n, new THREE.TorusGeometry(0.042,0.005,12,40), M.metal, x, TOP+0.004, D/2-0.1);\n    ring.rotation.x = Math.PI/2; top.add(ring);\n  }\n  const backW = (W-2*ARM)/2 - G;\n  for (const [i,sx] of [[1,-1],[2,1]]){\n    top.add(mesh('rueckenteil_'+i, rbox(backW, TOP, ARM, 0.05), M.fabric, sx*(backW/2+G/2), TOP/2, -D/2+ARM/2));\n    const p = mesh('kissen_'+i, rbox(0.45, 0.45, 0.10, 0.04, 7, 0.6), M.fabric, sx*0.33, 0.22, -D/2+ARM+0.08);\n    p.rotation.x = -0.28; p.rotation.z = sx*0.06; top.add(p);\n  }\n  sofa.add(top);\n  const fz0 = -0.05, fz1 = 0.30, fh = 0.34, rr = 0.008, R = 0.045, y0 = 0.02, yt = y0 + fh;\n  for (const [n,sx] of [['links',-1],['rechts',1]]){\n    const frame = new THREE.Group(); frame.name='seitengestell_'+n;\n    const fx = sx*(W/2 + 0.012);\n    for (const z of [fz0, fz1]) frame.add(mesh('gestell_stab_'+n, new THREE.CylinderGeometry(rr,rr,fh-R,20), M.metal, fx, y0+(fh-R)/2, z));\n    const bar = mesh('gestell_quer_'+n, new THREE.CylinderGeometry(rr,rr,fz1-fz0-2*R,20), M.metal, fx, yt, (fz0+fz1)/2); bar.rotation.x=Math.PI/2; frame.add(bar);\n    for (const [z,ry] of [[fz0+R, Math.PI/2],[fz1-R, -Math.PI/2]]){\n      const c = mesh('gestell_bogen_'+n, new THREE.TorusGeometry(R, rr, 16, 24, Math.PI/2), M.metal, fx, yt-R, z); c.rotation.y = ry; frame.add(c);\n    }\n    sofa.add(frame);\n  }\n  return { group: sofa, M, D };\n}\n\nfunction buildRegal(THREE, M){\n  const box = (w, h, d) => {\n    const g = new THREE.BoxGeometry(w, h, d), uv = g.attributes.uv;\n    const faces = [[d,h],[d,h],[w,d],[w,d],[w,h],[w,h]];\n    for (let f=0; f<6; f++) for (let i=0;i<4;i++){ const k=f*4+i; uv.setXY(k, uv.getX(k)*faces[f][0], uv.getY(k)*faces[f][1]); }\n    return g;\n  };\n  const mesh = (...a) => mk(THREE, ...a);\n  const W=0.60, D=0.27, H=0.74, A=0.03, T=0.0015, LIP=0.02, FOOT=0.012;\n  const shelfTops = [0.10, 0.42, H];\n  const regal = new THREE.Group(); regal.name='regal';\n  const postH = H - FOOT;\n  for (const [n,sx,sz] of [['vl',-1,1],['vr',1,1],['hl',-1,-1],['hr',1,-1]]){\n    const p = new THREE.Group(); p.name='pfosten_'+n;\n    const cx = sx*(W/2 - A/2), cz = sz*(D/2 - A/2), y = FOOT + postH/2;\n    p.add(mesh('pfosten_'+n+'_a', box(A, postH, T), M.concrete, cx, y, sz*(D/2 - T/2)));\n    p.add(mesh('pfosten_'+n+'_b', box(T, postH, A), M.concrete, sx*(W/2 - T/2), y, cz));\n    p.add(mesh('fuss_'+n, box(A+0.002, FOOT, A+0.002), M.foot, cx, FOOT/2, cz));\n    for (const top of shelfTops){\n      const yb = top - LIP/2;\n      const b1 = mesh('schraube_'+n, new THREE.CylinderGeometry(0.004,0.004,0.003,16), M.bolt, cx, yb, sz*(D/2+0.001)); b1.rotation.x = Math.PI/2; p.add(b1);\n      const b2 = mesh('schraube_'+n, new THREE.CylinderGeometry(0.004,0.004,0.003,16), M.bolt, sx*(W/2+0.001), yb, cz); b2.rotation.z = Math.PI/2; p.add(b2);\n    }\n    regal.add(p);\n  }\n  shelfTops.forEach((top, i) => {\n    const s = new THREE.Group(); s.name='boden_'+(i+1);\n    const iw = W - 2*T, id = D - 2*T;\n    s.add(mesh('boden_'+(i+1)+'_platte', box(iw, T, id), M.concrete, 0, top - T/2, 0));\n    for (const sz of [1,-1]) s.add(mesh('boden_'+(i+1)+'_kante_z', box(iw, LIP, T), M.concrete, 0, top - LIP/2, sz*(id/2 - T/2)));\n    for (const sx of [1,-1]) s.add(mesh('boden_'+(i+1)+'_kante_x', box(T, LIP, id), M.concrete, sx*(iw/2 - T/2), top - LIP/2, 0));\n    regal.add(s);\n  });\n  return regal;\n}\nfunction regalMaterials(THREE){\n  return {\n    concrete: galvanizedMaterial(THREE, 18), // verzinkter Stahl, Textur „Fein“\n    foot:     new THREE.MeshStandardMaterial({ name:'kunststoff_fuss', color:0x2a2a2a, roughness:0.7 }),\n    bolt:     new THREE.MeshStandardMaterial({ name:'schraube', color:0x8c8c8c, roughness:0.35, metalness:0.9 }),\n  };\n}\n\nfunction buildLampe(THREE){\n  const V = (x,y,z=0) => new THREE.Vector3(x,y,z);\n  const M = {\n    chrom:  new THREE.MeshStandardMaterial({ name:'chrom', color:0xd8dadd, metalness:0.5, roughness:0.25 }),\n    schirm: new THREE.MeshPhysicalMaterial({ name:'acryl_weiss', color:0xf7f7f5, roughness:0.28, clearcoat:0.8, clearcoatRoughness:0.1, side:THREE.DoubleSide }),\n    birne:  new THREE.MeshStandardMaterial({ name:'leuchtmittel', color:0xffffff, emissive:0xfff1d6, emissiveIntensity:0.2 }),\n  };\n  const add = (parent, name, geo, mat, p=[0,0,0], r=[0,0,0]) => { const m = new THREE.Mesh(geo, mat); m.name = name; m.position.set(...p); m.rotation.set(...r); parent.add(m); return m; };\n  const lampe = new THREE.Group(); lampe.name = 'bogenlampe';\n  const H = 1.66, REACH = 1.22, SH_R = 0.15, BASE_R = 0.13, BASE_H = 0.028, POLE_R = 0.0125, ARC_R = 0.0085, POLE_TOP = 0.74;\n  const prof = [new THREE.Vector2(0, 0), new THREE.Vector2(BASE_R - 0.004, 0)];\n  for (let i = 0; i <= 10; i++){ const a = -Math.PI/2 + i/10*Math.PI/2; prof.push(new THREE.Vector2(BASE_R - 0.008 + Math.cos(a)*0.008, 0.008 + Math.sin(a)*0.008)); }\n  for (let i = 0; i <= 10; i++){ const a = i/10*Math.PI/2; prof.push(new THREE.Vector2(BASE_R - 0.012 + Math.cos(a)*0.012, BASE_H - 0.012 + Math.sin(a)*0.012)); }\n  prof.push(new THREE.Vector2(0, BASE_H));\n  add(lampe, 'fuss', new THREE.LatheGeometry(prof, 96), M.chrom);\n  add(lampe, 'fuss_rosette', new THREE.CylinderGeometry(0.022, 0.026, 0.012, 48), M.chrom, [0, BASE_H + 0.006, 0]);\n  add(lampe, 'standrohr', new THREE.CylinderGeometry(POLE_R, POLE_R, POLE_TOP - BASE_H, 48), M.chrom, [0, (POLE_TOP + BASE_H)/2, 0]);\n  add(lampe, 'muffe_unten', new THREE.CylinderGeometry(POLE_R + 0.0015, POLE_R + 0.0015, 0.03, 48), M.chrom, [0, POLE_TOP - 0.015, 0]);\n  const ARC_END = V(REACH - 0.04, H - ARC_R);\n  const arc = new THREE.CubicBezierCurve3(V(0, POLE_TOP - 0.02), V(0, 1.38), V(0.42, H - ARC_R), ARC_END);\n  add(lampe, 'bogen', new THREE.TubeGeometry(arc, 240, ARC_R, 32), M.chrom);\n  const pM = arc.getPointAt(0.36), dM = arc.getTangentAt(0.36);\n  const muffe = add(lampe, 'muffe_bogen', new THREE.CylinderGeometry(ARC_R + 0.0018, ARC_R + 0.0018, 0.035, 32), M.chrom, [pM.x, pM.y, 0]);\n  muffe.quaternion.setFromUnitVectors(V(0,1,0), dM);\n  add(lampe, 'endkappe', new THREE.CylinderGeometry(ARC_R + 0.002, ARC_R + 0.002, 0.07, 32), M.chrom, [ARC_END.x - 0.02, ARC_END.y, 0], [0, 0, Math.PI/2]);\n  const kopf = new THREE.Group(); kopf.name = 'schirm_gruppe';\n  const TILT = 0.3;\n  kopf.position.set(REACH - SH_R*Math.sin(TILT), H - ARC_R - 0.035, 0);\n  kopf.rotation.z = TILT;\n  add(lampe, 'gelenk', new THREE.CylinderGeometry(0.006, 0.006, 0.03, 20), M.chrom, [kopf.position.x, H - ARC_R - 0.018, 0]);\n  lampe.add(kopf);\n  add(kopf, 'schirm', new THREE.SphereGeometry(SH_R, 96, 48, 0, Math.PI*2, 0, 1.95), M.schirm, [0, -SH_R, 0]);\n  add(kopf, 'schirm_nabe', new THREE.CylinderGeometry(0.018, 0.028, 0.02, 40), M.chrom, [0, -0.004, 0]);\n  add(kopf, 'fassung', new THREE.CylinderGeometry(0.016, 0.016, 0.05, 32), M.chrom, [0, -0.04, 0]);\n  add(kopf, 'leuchtmittel', new THREE.SphereGeometry(0.03, 32, 16), M.birne, [0, -0.09, 0]);\n  return { group: lampe, REACH };\n}\n\n// Verzinkter Stahl (Zink-Spangle, prozedural) – aus Regal 3D\nfunction galvanized(size=1024, cells=24, seed=7){\n  let s = seed; const rnd = () => (s = (s*16807) % 2147483647) / 2147483647;\n  const g = cells, pts = [];\n  for (let j=0;j<g;j++) for (let i=0;i<g;i++){\n    const a = rnd()*Math.PI*2;\n    pts.push({ x:(i+rnd())/g, y:(j+rnd())/g, base: 0.72 + rnd()*0.18, gx:Math.cos(a), gy:Math.sin(a), k: 0.03 + rnd()*0.08, r: rnd() });\n  }\n  const col = document.createElement('canvas'); col.width = col.height = size;\n  const rou = document.createElement('canvas'); rou.width = rou.height = size;\n  const cc = col.getContext('2d'), rc = rou.getContext('2d');\n  const ci = cc.createImageData(size,size), ri = rc.createImageData(size,size);\n  for (let y=0;y<size;y++) for (let x=0;x<size;x++){\n    const u = x/size, v = y/size, cx = Math.floor(u*g), cy = Math.floor(v*g);\n    let best = 9, second = 9, bp = null, bdx=0, bdy=0;\n    for (let oy=-1;oy<=1;oy++) for (let ox=-1;ox<=1;ox++){\n      const ix = (cx+ox+g)%g, iy = (cy+oy+g)%g, p = pts[iy*g+ix];\n      const dx = u - (p.x + Math.floor((cx+ox)/g) * 1 + ((cx+ox)<0?0:0)) , dy = v - (p.y + Math.floor((cy+oy)/g));\n      const d = dx*dx + dy*dy;\n      if (d < best){ second = best; best = d; bp = p; bdx = dx; bdy = dy; } else if (d < second) second = d;\n    }\n    const edge = Math.sqrt(second) - Math.sqrt(best);            // Abstand zur Korngrenze\n    let l = bp.base + (bdx*bp.gx + bdy*bp.gy) * g * bp.k;        // Facetten-Verlauf pro Korn\n    l += (Math.random()-0.5)*0.05;                               // feines Korn\n    if (edge < 0.0018) l -= 0.035;                                // dunkle Korngrenzen\n    if (Math.random() < 0.003) l -= 0.12;                        // dunkle Sprenkel\n    l = Math.max(0.25, Math.min(0.97, l));\n    const o = (y*size+x)*4, c = l*255;\n    ci.data[o]=c*0.98; ci.data[o+1]=c; ci.data[o+2]=c*1.02; ci.data[o+3]=255;\n    const r = (0.28 + (1-l)*0.35 + bp.r*0.12) * 255;             // helle Körner glänzender\n    ri.data[o]=ri.data[o+1]=ri.data[o+2]=r; ri.data[o+3]=255;\n  }\n  cc.putImageData(ci,0,0); rc.putImageData(ri,0,0);\n  return { col, rou };\n}\nfunction galvanizedMaterial(THREE, repeat = 18){\n  const { col, rou } = galvanized();\n  const mk = (c, srgb) => { const t = new THREE.CanvasTexture(c); t.wrapS = t.wrapT = THREE.RepeatWrapping; t.repeat.set(repeat, repeat);\n    if (srgb) t.colorSpace = THREE.SRGBColorSpace; t.anisotropy = 8; return t; };\n  return new THREE.MeshStandardMaterial({ name:'stahl_verzinkt', map: mk(col, true), roughnessMap: mk(rou), bumpMap: mk(col), bumpScale: 0.25,\n    color: 0xeceef0, roughness: 1, metalness: 0.3 });\n}\n\n// Regallautsprecher-Paar (aus Boxen 3D): passiv + aktiv (Bedienfeld an lokaler +x-Seite)\nfunction buildBoxen(THREE){\n  const M = {\n    wood:   new THREE.MeshStandardMaterial({ name:'eiche', color:0xb77a3e, roughness:0.55 }),\n    fabric: new THREE.MeshStandardMaterial({ name:'stoff_grau', color:0x6c6c6a, roughness:0.97 }),\n    strip:  new THREE.MeshStandardMaterial({ name:'zierleiste_silber', color:0xc9c9c9, roughness:0.3, metalness:0.9 }),\n    black:  new THREE.MeshStandardMaterial({ name:'kunststoff_schwarz', color:0x1c1c1c, roughness:0.6 }),\n    knob:   new THREE.MeshStandardMaterial({ name:'drehregler', color:0x141414, roughness:0.4, metalness:0.2 }),\n    alu:    new THREE.MeshStandardMaterial({ name:'hochtoener_alu', color:0xaaaaaa, roughness:0.35, metalness:0.8 }),\n    led:    new THREE.MeshStandardMaterial({ name:'led', color:0x0a2a10, emissive:0x2bd45a, emissiveIntensity:1.2 }),\n  };\n  const W=0.146, D=0.196, H=0.234, R=0.014, BV=0.002;\n  const mesh = (name, geo, mat, x=0, y=0, z=0) => mk(THREE, name, geo, mat, x, y, z);\n  const rrect = (w, h, r) => { const s = new THREE.Shape(), x=-w/2, y=-h/2;\n    s.moveTo(x+r,y); s.lineTo(x+w-r,y); s.quadraticCurveTo(x+w,y,x+w,y+r); s.lineTo(x+w,y+h-r); s.quadraticCurveTo(x+w,y+h,x+w-r,y+h);\n    s.lineTo(x+r,y+h); s.quadraticCurveTo(x,y+h,x,y+h-r); s.lineTo(x,y+r); s.quadraticCurveTo(x,y,x+r,y); return s; };\n  const cabGeo = new THREE.ExtrudeGeometry(rrect(W-2*BV, D-2*BV, R), { depth:H-2*BV, bevelEnabled:true, bevelSize:BV, bevelThickness:BV, bevelSegments:2, curveSegments:10 });\n  cabGeo.rotateX(-Math.PI/2); cabGeo.translate(0, BV, 0);\n  { const p = cabGeo.attributes.position, n = cabGeo.attributes.normal, uv = cabGeo.attributes.uv;\n    for (let i=0;i<p.count;i++){ const x=p.getX(i), y=p.getY(i), z=p.getZ(i);\n      if (Math.abs(n.getY(i)) > 0.7) uv.setXY(i, x, z); else uv.setXY(i, Math.abs(n.getX(i)) > Math.abs(n.getZ(i)) ? z : x, y); } }\n  const GW=W-0.006, GH=H-0.006, GT=0.008;\n  const grilleGeo = new THREE.ExtrudeGeometry(rrect(GW-0.004, GH-0.004, 0.009), { depth:GT-0.003, bevelEnabled:true, bevelSize:0.002, bevelThickness:0.0015, bevelSegments:3, curveSegments:8 });\n  function speaker(name, active){\n    const s = new THREE.Group(); s.name = name;\n    s.add(mesh(name+'_gehaeuse', cabGeo, M.wood));\n    s.add(mesh(name+'_stoff', grilleGeo, M.fabric, 0, H/2, D/2 + 0.0015));\n    s.add(mesh(name+'_zierleiste', new THREE.BoxGeometry(GW*0.74, 0.0026, 0.0012), M.strip, 0, H*0.585, D/2 + GT + 0.0005));\n    s.add(mesh(name+'_logo', new THREE.BoxGeometry(0.026, 0.006, 0.0008), M.strip, 0, 0.026, D/2 + GT + 0.0003));\n    const port = mesh(name+'_bassreflex', new THREE.CylinderGeometry(0.014, 0.014, 0.004, 32), M.black, 0, 0.17, -D/2 - 0.001);\n    port.rotation.x = Math.PI/2; s.add(port);\n    for (const [fx,fz] of [[-1,-1],[1,-1],[-1,1],[1,1]])\n      s.add(mesh(name+'_fuss', new THREE.CylinderGeometry(0.006,0.006,0.002,20), M.black, fx*(W/2-0.02), 0.001, fz*(D/2-0.025)));\n    if (active){\n      const px = W/2 + 0.0004, cz = -0.012;\n      s.add(mesh(name+'_bedienfeld', new THREE.BoxGeometry(0.002, 0.108, 0.055), M.black, px, 0.14, cz));\n      [0.176, 0.143, 0.11].forEach((y, i) => {\n        const k = mesh(name+'_regler_'+['hoehen','bass','lautstaerke'][i], new THREE.CylinderGeometry(0.0085, 0.0085, 0.011, 28), M.knob, px+0.0055, y, cz-0.004);\n        k.rotation.z = Math.PI/2; s.add(k);\n      });\n      s.add(mesh(name+'_led', new THREE.SphereGeometry(0.0015, 12, 8), M.led, px+0.001, 0.093, cz-0.004));\n    }\n    s.traverse(o => { if (o.isMesh) o.position.y += 0.002; });\n    return s;\n  }\n  return { W, D, H, links: speaker('box_links', false), rechts: speaker('box_rechts_aktiv', true) };\n}\n\n// Tripod-Lampe (aus Tripodlampe 3D): Eichen-Leuchtkopf mit LED-Spot auf schwarzem Dreibein; Front = lokale +z\nfunction buildTripod(THREE){\n  const V = (x,y,z) => new THREE.Vector3(x,y,z);\n  const c = document.createElement('canvas'); c.width = c.height = 512; const g = c.getContext('2d');\n  g.fillStyle = '#c49a66'; g.fillRect(0,0,512,512);\n  let s = 11; const r = () => (s = (s*16807) % 2147483647) / 2147483647;\n  for (let i = 0; i < 260; i++){\n    const y = r()*512, a = 0.04 + r()*0.12; g.strokeStyle = r() > 0.5 ? `rgba(120,80,40,${a})` : `rgba(235,200,150,${a})`; g.lineWidth = 0.5 + r()*2.2;\n    g.beginPath(); g.moveTo(0,y); for (let x = 0; x <= 512; x += 32) g.lineTo(x, y + Math.sin(x*0.012 + i)*4 + (r()-0.5)*1.5); g.stroke();\n  }\n  const tex = new THREE.CanvasTexture(c); tex.colorSpace = THREE.SRGBColorSpace;\n  const M = {\n    holz:   new THREE.MeshStandardMaterial({ name:'tripod_eiche', map: tex, roughness:0.6 }),\n    stahl:  new THREE.MeshStandardMaterial({ name:'tripod_stahl_schwarz', color:0x1b1b1c, roughness:0.45, metalness:0.6 }),\n    gummi:  new THREE.MeshStandardMaterial({ name:'tripod_gummi', color:0x111111, roughness:0.9 }),\n    blende: new THREE.MeshStandardMaterial({ name:'tripod_reflektor', color:0x9a9a9a, roughness:0.25, metalness:0.9 }),\n    led:    new THREE.MeshStandardMaterial({ name:'tripod_led', color:0xd8dadd, emissive:0xf4f7ff, emissiveIntensity:0, roughness:0.2 }),\n    kabel:  new THREE.MeshStandardMaterial({ name:'tripod_kabel', color:0x151515, roughness:0.7 }),\n  };\n  const add = (p, n, geo, mat, pos=[0,0,0]) => { const o = mk(THREE, n, geo, mat, ...pos); p.add(o); return o; };\n  const rod = (p, n, a, b, rr, mat) => { const d = b.clone().sub(a), o = add(p, n, new THREE.CylinderGeometry(rr, rr, d.length(), 20), mat);\n    o.position.copy(a).addScaledVector(d, 0.5); o.quaternion.setFromUnitVectors(V(0,1,0), d.normalize()); return o; };\n  const group = new THREE.Group(); group.name = 'tripodlampe';\n  const HUB = V(0, 0.36, 0), FR = 0.17;\n  for (let i = 0; i < 3; i++){\n    const a = Math.PI/2 + i*2*Math.PI/3, foot = V(Math.cos(a)*FR, 0.006, Math.sin(a)*FR);\n    rod(group, 'tripod_bein_'+(i+1), foot, HUB.clone().add(V(Math.cos(a)*0.012, 0, Math.sin(a)*0.012)), 0.005, M.stahl);\n    add(group, 'tripod_fuss_'+(i+1), new THREE.CylinderGeometry(0.0058, 0.0058, 0.012, 16), M.gummi, [foot.x, 0.006, foot.z]);\n  }\n  add(group, 'tripod_knoten', new THREE.CylinderGeometry(0.016, 0.018, 0.028, 28), M.stahl, [0, 0.36, 0]);\n  const HW = 0.14, HH = 0.12, HD = 0.11;\n  const arm = new THREE.CatmullRomCurve3([V(0,0.374,0), V(-0.01,0.41,0), V(-0.045,0.45,0.005), V(-0.09,0.485,0.01), V(-0.092,0.495,0.01), V(-HW/2-0.008,0.49,0.01)]);\n  add(group, 'tripod_buegel', new THREE.TubeGeometry(arm, 48, 0.0055, 12), M.stahl);\n  const kopf = new THREE.Group(); kopf.name = 'tripod_kopf'; kopf.position.set(0, 0.49, 0.01); kopf.rotation.set(0.12, 0.15, 0); group.add(kopf);\n  add(kopf, 'tripod_holzkoerper', new THREE.BoxGeometry(HW, HH, HD), M.holz);\n  add(kopf, 'tripod_gelenk', new THREE.CylinderGeometry(0.013, 0.013, 0.01, 28), M.stahl, [-HW/2-0.005, 0, 0]).rotation.z = Math.PI/2;\n  add(kopf, 'tripod_blende', new THREE.TorusGeometry(0.036, 0.005, 12, 48), M.blende, [0.01, 0, HD/2+0.001]);\n  add(kopf, 'tripod_reflektor', new THREE.CylinderGeometry(0.036, 0.03, 0.012, 48, 1, true), M.blende, [0.01, 0, HD/2-0.005]).rotation.x = Math.PI/2;\n  const linse = add(kopf, 'tripod_led_linse', new THREE.CircleGeometry(0.034, 48), M.led, [0.01, 0, HD/2-0.008]);\n  const kabel = new THREE.CatmullRomCurve3([V(-0.005,0.35,-0.012), V(-0.03,0.28,-0.04), V(-0.07,0.16,-0.08), V(-0.11,0.05,-0.12), V(-0.14,0.004,-0.16), V(-0.28,0.004,-0.24), V(-0.45,0.004,-0.2)]);\n  add(group, 'tripod_kabel', new THREE.TubeGeometry(kabel, 64, 0.0022, 8), M.kabel);\n  group.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\n  linse.castShadow = false;\n  // Lichtquellen am Kopf (Intensität 0 = aus)\n  const spot = new THREE.SpotLight(0xf2f5ff, 0, 0, 0.55, 0.5, 2);\n  spot.position.set(0.01, 0, HD/2 + 0.005); spot.target.position.set(0.01, 0, HD/2 + 1);\n  spot.castShadow = true; spot.shadow.mapSize.set(1024, 1024); spot.shadow.bias = -0.0005; spot.shadow.normalBias = 0.02;\n  spot.shadow.camera.near = 0.03; spot.shadow.camera.far = 8;\n  const glow = new THREE.PointLight(0xf2f5ff, 0, 3, 2); glow.position.set(0.01, 0, HD/2 + 0.05);\n  kopf.add(spot, spot.target, glow);\n  return { group, kopf, M, spot, glow };\n}\n\nconst stage = document.querySelector('three-d-stage');\nconst { THREE } = await stage.ready;\nconst statusEl = { set textContent(v){} };\nfor (const sel of ['.toolbar','.note']) { const el = stage.shadowRoot.querySelector(sel); if (el) el.style.display = 'none'; }\n\n// ---------- Maße in Metern (LiDAR-Scan 10/2026, bereinigt) ----------\n// x = Ost, z = Süd; Ursprung = Innenkante Westwand Schlafzimmer / Innenkante Nordwand\nconst H = 2.5, TE = 0.2, TI = 0.1;     // Wandhöhe, Außen-/Innenwand\nconst DOOR_W = 0.9, DOOR_H = 2.1, WIN_B = 0.9, WIN_T = 2.2;\n\n// ---------- Materialien ----------\nconst M = {\n  floor:  new THREE.MeshStandardMaterial({ name:'wood_floor', color:0x8a6242, roughness:0.6 }),\n  wall:   new THREE.MeshStandardMaterial({ name:'white_stucco', color:0xf2efe9, roughness:0.95 }),\n  brick:  new THREE.MeshStandardMaterial({ name:'brick_wall_04', color:0x9a5a44, roughness:0.9 }),\n  cap:    new THREE.MeshStandardMaterial({ name:'rough_plaster_brick_04', color:0xb8a898, roughness:0.95 }),\n  plinth: new THREE.MeshStandardMaterial({ name:'plinth', color:0x2f2d2a, roughness:0.7 }),\n  wood:   new THREE.MeshStandardMaterial({ name:'door_white_lacquer', color:0xf7f5f0, roughness:0.35 }),\n  metal:  new THREE.MeshStandardMaterial({ name:'brushed_steel', color:0xb9bcc0, roughness:0.3, metalness:0.35 }),\n  glass:  new THREE.MeshStandardMaterial({ name:'glass', color:0xbfd8e4, roughness:0.05, transparent:true, opacity:0.35 }),\n  balcony:new THREE.MeshStandardMaterial({ name:'balcony_concrete', color:0xa9a59d, roughness:0.9 }),\n};\n\n// Welt-UVs (Box-Projektion), damit Texturen nicht gestreckt werden\nfunction worldUV(geo, scale){\n  const p = geo.attributes.position, n = geo.attributes.normal, uv = geo.attributes.uv;\n  for (let i = 0; i < p.count; i++){\n    const ax = Math.abs(n.getX(i)), ay = Math.abs(n.getY(i)), az = Math.abs(n.getZ(i));\n    let u, v;\n    if (ay >= ax && ay >= az){ u = p.getX(i); v = p.getZ(i); }\n    else if (ax >= az){ u = p.getZ(i); v = p.getY(i); }\n    else { u = p.getX(i); v = p.getY(i); }\n    uv.setXY(i, u/scale, v/scale);\n  }\n  uv.needsUpdate = true;\n  return geo;\n}\n// Box in Weltkoordinaten (min/max)\nfunction box(name, mat, x0,y0,z0, x1,y1,z1, uvScale){\n  const g = new THREE.BoxGeometry(x1-x0, y1-y0, z1-z0);\n  g.translate((x0+x1)/2, (y0+y1)/2, (z0+z1)/2);\n  if (uvScale) worldUV(g, uvScale);\n  const m = new THREE.Mesh(g, mat); m.name = name; return m;\n}\n\nconst home = new THREE.Group(); home.name = 'wohnung';\nconst walls = new THREE.Group(); walls.name = 'waende';\nconst doors = new THREE.Group(); doors.name = 'tueren';\nconst windows = new THREE.Group(); windows.name = 'fenster';\nhome.add(walls, doors, windows);\n\n// ---------- Tür (prozedural, Kassettentür) ----------\nfunction makeDoor(name, t, openDeg, glassDoor=false, w=DOOR_W){\n  const g = new THREE.Group(); g.name = name;\n  const d = t + 0.03;\n  g.add(box(name+'_zarge_l', M.wood, -w/2, 0, -d/2, -w/2+0.04, DOOR_H, d/2));\n  g.add(box(name+'_zarge_r', M.wood,  w/2-0.04, 0, -d/2, w/2, DOOR_H, d/2));\n  g.add(box(name+'_zarge_oben', M.wood, -w/2, DOOR_H-0.04, -d/2, w/2, DOOR_H, d/2));\n  const lw = w - 0.08, lh = DOOR_H - 0.05, lt = 0.04;\n  const pivot = new THREE.Group(); pivot.name = name+'_blatt';\n  pivot.position.set(-w/2 + 0.04, 0.005, 0);\n  pivot.rotation.y = THREE.MathUtils.degToRad(openDeg);\n  pivot.add(box(name+'_tuerblatt', M.wood, 0, 0, -lt/2, lw, lh, lt/2));\n  for (const s of [1,-1]){\n    const z0 = s*0.014, z1 = s*0.026, zz=[Math.min(z0,z1),Math.max(z0,z1)];\n    if (glassDoor){\n      pivot.add(box(name+'_glas', M.glass, 0.1, 0.35, -0.006, lw-0.1, lh-0.12, 0.006));\n    } else {\n      pivot.add(box(name+'_kassette_o'+s, M.wood, 0.11, 1.05, zz[0], lw-0.11, lh-0.14, zz[1]));\n      pivot.add(box(name+'_kassette_u'+s, M.wood, 0.11, 0.14, zz[0], lw-0.11, 0.9, zz[1]));\n    }\n    const rose = new THREE.Mesh(new THREE.CylinderGeometry(0.026,0.026,0.012,32), M.metal);\n    rose.name = name+'_rosette'+s; rose.rotation.x = Math.PI/2; rose.position.set(lw-0.07, 1.05, s*(lt/2+0.006)); pivot.add(rose);\n    const neck = new THREE.Mesh(new THREE.CylinderGeometry(0.009,0.009,0.05,20), M.metal);\n    neck.name = name+'_hals'+s; neck.rotation.x = Math.PI/2; neck.position.set(lw-0.07, 1.05, s*(lt/2+0.03)); pivot.add(neck);\n    const lever = new THREE.Mesh(new THREE.CapsuleGeometry(0.009, 0.12, 6, 16), M.metal);\n    lever.name = name+'_druecker'+s; lever.rotation.z = Math.PI/2; lever.position.set(lw-0.13, 1.05, s*(lt/2+0.055)); pivot.add(lever);\n  }\n  for (const y of [0.25, lh-0.25]){\n    const h = new THREE.Mesh(new THREE.CylinderGeometry(0.008,0.008,0.1,16), M.metal);\n    h.name = name+'_band'; h.position.set(-0.004, y, lt/2); pivot.add(h);\n  }\n  g.add(pivot);\n  return g;\n}\n\n// ---------- Fenster ----------\nfunction makeWindow(name, w, t, bottom, top){\n  const g = new THREE.Group(); g.name = name;\n  const f = 0.05, d = 0.07;\n  g.add(box(name+'_rahmen_l', M.wood, -w/2, bottom, -d/2, -w/2+f, top, d/2));\n  g.add(box(name+'_rahmen_r', M.wood, w/2-f, bottom, -d/2, w/2, top, d/2));\n  g.add(box(name+'_rahmen_o', M.wood, -w/2+f, top-f, -d/2, w/2-f, top, d/2));\n  g.add(box(name+'_rahmen_u', M.wood, -w/2+f, bottom, -d/2, w/2-f, bottom+f, d/2));\n  if (w > 1.1) g.add(box(name+'_pfosten', M.wood, -0.025, bottom+f, -d/2+0.005, 0.025, top-f, d/2-0.005));\n  g.add(box(name+'_glas', M.glass, -w/2+f, bottom+f, -0.005, w/2-f, top-f, 0.005));\n  if (bottom > 0) g.add(box(name+'_bank', M.wood, -w/2-0.05, bottom-0.027, -t/2-0.04, w/2+0.05, bottom+0.012, t/2+0.04));\n  return g;\n}\n\n// ---------- Wand mit Öffnungen (achsparallel, Meter) ----------\n// a..b: Ausdehnung entlang der Wand, fixed: Mittellinie; ops: {c, w, type:'door'|'window'|'glassdoor', open, flip, name}\n// outside: Box-Face-Index der Außenseite (0:+x 1:-x 4:+z 5:-z) → Klinker außen, Putz innen; ends: Stirnseiten außen sichtbar\nfunction wall(name, a, b, fixed, horizontal, t, h, ops=[], outside=-1, ends=[false,false]){\n  const F = fixed;\n  const seg = (n, s0, s1, y0, y1, ef=[]) => {\n    if (s1 - s0 < 0.001) return;\n    const mat = Array(6).fill(M.wall);\n    if (outside >= 0){ mat[outside] = M.brick; ef.forEach(e => mat[e] = M.brick); }\n    if (y1 >= h - 0.0001) mat[2] = M.cap;\n    walls.add(horizontal ? box(n, mat, s0, y0, F-t/2, s1, y1, F+t/2, 1.5)\n                         : box(n, mat, F-t/2, y0, s0, F+t/2, y1, s1, 1.5));\n  };\n  const endA = ends[0] ? [horizontal ? 1 : 5] : [], endB = ends[1] ? [horizontal ? 0 : 4] : [];\n  const list = [...ops].sort((p,q)=>p.c-q.c);\n  let cur = a;\n  list.forEach((o, i) => {\n    const s0 = o.c - o.w/2, s1 = o.c + o.w/2;\n    seg(`${name}_${i}`, cur, s0, 0, h, i === 0 ? endA : []);\n    seg(`${name}_sturz_${i}`, s0, s1, o.type === 'door' ? DOOR_H : WIN_T, h);\n    if (o.type === 'window') seg(`${name}_bruestung_${i}`, s0, s1, 0, WIN_B);\n    let el;\n    if (o.type === 'door') { el = makeDoor(o.name, t, o.open ?? 0, false, o.w); doors.add(el); }\n    else if (o.type === 'glassdoor') { el = makeWindow(o.name, o.w, t, 0, WIN_T); windows.add(el); }\n    else { el = makeWindow(o.name, o.w, t, WIN_B, WIN_T); windows.add(el); }\n    if (horizontal) el.position.set(o.c, 0, F);\n    else { el.position.set(F, 0, o.c); el.rotation.y = Math.PI/2; }\n    if (o.flip) el.rotation.y += Math.PI;\n    cur = s1;\n  });\n  seg(`${name}_${list.length}`, cur, b, 0, h, list.length === 0 ? [...endA, ...endB] : endB);\n}\n\n// Grundriss nach LiDAR-Scan: Raummaße, Wandlagen, Öffnungsmitten. Nicht übernommen: „Other 4“-Spalt, Scan-Möbel,\n// schräger Wandrest im Flur, 10-cm-Versatz der Ostfassade (begradigt). Tür-/Fensterbreiten + Mauervorsprung = Handmaße.\nconst HI = H - 0.003; // Innenwände minimal niedriger → kein Z-Fighting auf den Oberkanten\nconst X_FL = 1.21;              // Innenkante Westwand Bad/Flur (Schlafzimmer springt 1,21 m weiter nach Westen)\nconst X_SW = 2.66;              // Wandmitte Schlafzimmer | Wohnzimmer\nconst X_SCH = 2.11;             // Westkante Schacht\nconst X_BK = 3.29;              // Wandmitte Bad | Küche\nconst X_FK = 3.58;              // Wandmitte Flur | Küche\nconst X_EK = 6.17, X_E = 6.27;  // Innenkante Ostwand Küche / Wohnzimmer\nconst Z_SCH0 = 2.54, Z_SCH1 = 3.31; // Schacht Nord-/Südkante\nconst Z_BF = 3.13;              // Wandmitte Bad | Flur\nconst Z_SP = 4.40;              // Wandmitte Küche/Flur | Wohn-/Schlafzimmer\nconst Z_S = 8.49;               // Innenkante Südwand\nconst ZST = Z_SP + TI/2 - TE;   // Außenkante Rücksprung (Treppenhaus)\n// Raum-Innenkanten [x0, z0, x1, z1]\nconst RM_SZ  = [0, Z_SP + TI/2, X_SW - TI/2, Z_S];            // Schlafzimmer 2,61 × 4,04\nconst RM_WZ  = [X_SW + TI/2, Z_SP + TI/2, X_E, Z_S];          // Wohnzimmer 3,56 × 4,04\nconst RM_KU  = [X_BK + TI/2, 0, X_EK, Z_SP - TI/2];           // Küche 2,83 × 4,35\nconst RM_BAD = [X_FL, 0, X_BK - TI/2, Z_BF - TI/2];           // Bad 2,03 × 3,08\nconst RM_FL  = [X_FL, Z_BF + TI/2, X_FK - TI/2, Z_SP - TI/2]; // Flur 2,32 × 1,17\nconst BAD_DOOR = { c: 1.70, w: 0.75 }, SZ_DOOR = { c: 1.74, w: 0.83 }, WZ_DOOR = { c: 4.85, w: 0.83 };\nconst KU_WIN = { c: RM_KU[0] + 0.48 + 0.325, w: 0.65 }, KU_DOOR = { c: RM_KU[0] + 0.48 + 0.65 + 0.12 + 0.425, w: 0.85 };\n\n// Außenwände\nwall('aussen_nord', X_FL - TE, X_E + TE, -TE/2, true, TE, H, [\n  { c: 2.25, w: 0.8, type:'window', name:'fenster_bad' },\n  // Küche: Fenster + Balkontür als Einheit\n  { ...KU_WIN, type:'window', name:'fenster_kueche' },\n  { ...KU_DOOR, type:'glassdoor', name:'balkontuer' },\n], 5, [true, true]);\nwall('aussen_sued', -TE, X_E + TE, Z_S + TE/2, true, TE, H, [\n  { c: 0.94, w: 0.7, type:'window', name:'fenster_schlafzimmer' },\n  { c: 3.37, w: 0.7, type:'window', name:'fenster_wohnzimmer_1' },\n  { c: 5.42, w: 0.7, type:'window', name:'fenster_wohnzimmer_2' },\n], 4, [true, true]);\nwall('aussen_west_schlafzimmer', Z_SP + TI/2, Z_S, -TE/2, false, TE, H, [], 1);\nwall('aussen_nord_schlafzimmer', -TE, X_FL, ZST + TE/2, true, TE, H, [], 5, [true, false]);\nwall('aussen_west', 0, ZST, X_FL - TE/2, false, TE, H, [\n  { c: (Z_BF + Z_SP)/2, w: DOOR_W, type:'door', open: -35, name:'wohnungstuer' },\n], 1);\n// Ostfassade außen gerade; Küchenwand innen 10 cm dicker (Scan)\nwall('aussen_ost_kueche', 0, Z_SP, (X_EK + X_E + TE)/2, false, X_E + TE - X_EK, H, [], 0);\nwall('aussen_ost', Z_SP, Z_S, X_E + TE/2, false, TE, H, [], 0);\n// Innenwände\nwall('innen_bad_kueche', 0, Z_SCH0, X_BK, false, TI, HI);\nwall('innen_bad_flur', X_FL, X_SCH, Z_BF, true, TI, HI, [\n  { ...BAD_DOOR, type:'door', open: 80, name:'tuer_bad' },\n]);\nwall('innen_flur_kueche', Z_SCH1, Z_SP - TI/2, X_FK, false, TI, HI, [\n  { c: 3.78, w: 0.86, type:'door', open: -70, name:'tuer_kueche' },\n]);\nwall('innen_mitte', X_FL, X_E, Z_SP, true, TI, HI, [\n  { ...SZ_DOOR, type:'door', open: 55, flip:true, name:'tuer_schlafzimmer' },\n  { ...WZ_DOOR, type:'door', open: 65, flip:true, name:'tuer_wohnzimmer' },\n]);\nwall('innen_schlafen_wohnen', Z_SP + TI/2, Z_S, X_SW, false, TI, HI);\n// Schacht zwischen Bad, Flur und Küche (Scan: Hohlraum 56 × 145 cm ohne Wand zur Küche → als geschlossen angenommen)\n{ const m = Array(6).fill(M.wall); m[2] = M.cap; walls.add(box('schacht', m, X_SCH, 0, Z_SCH0, X_FK + TI/2, HI, Z_SCH1, 1.5)); }\n\n// ---------- Boden, Sockel, Balkon ----------\nconst OUTLINE = [[X_FL - TE/2, -TE/2], [X_E + TE/2, -TE/2], [X_E + TE/2, Z_S + TE/2], [-TE/2, Z_S + TE/2], [-TE/2, ZST + TE/2], [X_FL - TE/2, ZST + TE/2]];\nconst floorGeo = new THREE.ShapeGeometry(new THREE.Shape(OUTLINE.map(([x, z]) => new THREE.Vector2(x, -z))));\nfloorGeo.rotateX(-Math.PI/2); floorGeo.translate(0, 0.002, 0);\nworldUV(floorGeo, 1.0);\nconst floor = new THREE.Mesh(floorGeo, M.floor); floor.name = 'boden_wood_floor';\nhome.add(floor);\nhome.add(box('sockel_nord', M.plinth, X_FL - TE - 0.05, -0.12, -TE - 0.05, X_E + TE + 0.05, 0, ZST - 0.05));\nhome.add(box('sockel_sued', M.plinth, -TE - 0.05, -0.12, ZST - 0.05, X_E + TE + 0.05, 0, Z_S + TE + 0.05));\n// Balkon über die ganze Küchenbreite, 2,26 m tief (Scan); Brüstungen statt der gescannten Wände\nconst PH = 1.0, PT = 0.08;\nconst BX0 = RM_KU[0] - PT, BX1 = RM_KU[2] + PT, BZ1 = -TE, BZ0 = BZ1 - 2.26 - PT;\nhome.add(box('balkon_platte', M.balcony, BX0, -0.12, BZ0, BX1, 0.02, BZ1));\nhome.add(box('balkon_bruestung_w', M.wall, BX0, 0.02, BZ0, BX0+PT, PH, BZ1, 1.5));\nhome.add(box('balkon_bruestung_o', M.wall, BX1-PT, 0.02, BZ0, BX1, PH, BZ1, 1.5));\nhome.add(box('balkon_bruestung_n', M.wall, BX0+PT, 0.02, BZ0, BX1-PT, PH-0.002, BZ0+PT, 1.5));\n\n// ---------- Wohnzimmer (Raum Süd-Ost) ----------\nconst wohn = new THREE.Group(); wohn.name = 'wohnzimmer';\nconst IN_O = X_E, IN_S = Z_S, WZ_CX = (RM_WZ[0] + RM_WZ[2])/2, SOFA_Z = Z_S - 1.745;   // Innenkanten Ost-/Südwand\n// Sofa an der Ostwand, Rücken zur Wand\nconst sofa = buildSofa(THREE);\nsofa.group.position.set(IN_O - sofa.D/2 - 0.03, 0.002, SOFA_Z);\nsofa.group.rotation.y = -Math.PI/2;\nwohn.add(sofa.group);\n// 3 Regale nebeneinander unter dem Südfenster, Front zum Raum\nconst RM = regalMaterials(THREE);\nfor (const [i, dx] of [[1,-0.603],[2,0],[3,0.603]]){\n  const r = buildRegal(THREE, RM); r.name = 'regal_'+i;\n  r.position.set(WZ_CX + dx, 0.002, IN_S - 0.135 - 0.02);\n  r.rotation.y = Math.PI;\n  wohn.add(r);\n}\n// Boxen oben auf den äußeren Regalen, leicht nach innen gedreht\n{\n  const bx = buildBoxen(THREE), top = new THREE.Box3().setFromObject(wohn.getObjectByName('regal_1')).max.y;\n  const TURN = THREE.MathUtils.degToRad(15), X = 0.603 + 0.30 - 0.105, Z = IN_S - 0.135 - 0.02;\n  // Aktivbox links (–x), Bedienfeld zeigt nach außen\n  bx.rechts.position.set(WZ_CX - X, top, Z); bx.rechts.rotation.y = Math.PI - TURN;\n  bx.links.position.set(WZ_CX + X, top, Z);  bx.links.rotation.y = Math.PI + TURN;\n  wohn.add(bx.links, bx.rechts);\n}\n// Bogenlampe in der Fensterecke, Schirm über dem Sofa – zur Raummitte versetzt\nconst lampe = buildLampe(THREE);\nconst LB = new THREE.Vector2(IN_O - 0.22, IN_S - 0.25);\nconst LT = new THREE.Vector2(IN_O - 0.95, SOFA_Z + 0.25);\nlampe.group.position.set(LB.x, 0.002, LB.y);\nlampe.group.rotation.y = Math.atan2(-(LT.y - LB.y), LT.x - LB.x);\nwohn.add(lampe.group);\n// Donut-Lampe (Ø 30 cm, H 11 cm) im linken Regal, mittleres Fach, mittig\nconst DM = {\n  koerper: new THREE.MeshPhysicalMaterial({ name:'donut_opal_orange', color:0xffa04a, roughness:0.6, clearcoat:0.2, clearcoatRoughness:0.5, emissive:0xff8a2a, emissiveIntensity:0 }),\n  sockel:  new THREE.MeshStandardMaterial({ name:'donut_sockel', color:0xee6a3e, roughness:0.5, emissive:0xd04a20, emissiveIntensity:0 }),\n  knopf:   new THREE.MeshStandardMaterial({ name:'donut_knopf', color:0x9a6a58, roughness:0.45 }),\n};\nconst donut = new THREE.Group(); donut.name = 'donutlampe';\n{\n  const V2 = (x,y) => new THREE.Vector2(x,y), dm = (n,g,m,y=0) => { const o = new THREE.Mesh(g,m); o.name = n; o.position.y = y; donut.add(o); };\n  const SB_R = 0.12, SB_H = 0.018, sp = [V2(0,0), V2(SB_R-0.006,0)];\n  for (let i = 0; i <= 12; i++){ const a = -Math.PI/2 + i/12*Math.PI; sp.push(V2(SB_R-0.006+Math.cos(a)*0.006, 0.006+Math.sin(a)*0.006+(i>6?(SB_H-0.012)*(i-6)/6:0))); }\n  sp.push(V2(0, SB_H));\n  dm('donut_sockel', new THREE.LatheGeometry(sp, 96), DM.sockel);\n  const R = 0.085, A = 0.065, B = 0.0475, CY = 0.0625, sg = v => Math.sign(v)*Math.pow(Math.abs(v), 0.8), kp = [V2(0,0.015)];\n  for (let i = 0; i <= 60; i++){ const t = -Math.PI/2 + i/60*1.35*Math.PI; kp.push(V2(R+A*sg(Math.cos(t)), CY+B*sg(Math.sin(t)))); }\n  kp.push(V2(0.018,0.078), V2(0.008,0.0755), V2(0,0.075));\n  dm('donut_koerper', new THREE.LatheGeometry(kp, 128), DM.koerper);\n  dm('donut_knopf', new THREE.CylinderGeometry(0.02, 0.022, 0.004, 40), DM.knopf, 0.077);\n}\ndonut.position.set(WZ_CX - 0.603, 0.002 + 0.42, IN_S - 0.135 - 0.02);\nwohn.add(donut);\n// Fernseher (43\") auf zwei Sofa-Kartons an der Westwand, gegenüber dem Sofa\n{\n  const tv = new THREE.Group(); tv.name = 'fernseher';\n  const K = new THREE.MeshStandardMaterial({ name:'karton', color:0xa9825a, roughness:0.9 });\n  const KT = new THREE.MeshStandardMaterial({ name:'karton_druck', color:0x3a2d22, roughness:0.9 });\n  const TVM = new THREE.MeshStandardMaterial({ name:'tv_gehaeuse', color:0x141416, roughness:0.45, metalness:0.2 });\n  const SCR = new THREE.MeshPhysicalMaterial({ name:'tv_bildschirm', color:0x050607, roughness:0.08, clearcoat:1, clearcoatRoughness:0.05 });\n  const FT = new THREE.MeshStandardMaterial({ name:'tv_fuss', color:0x9a9ea3, roughness:0.35, metalness:0.7 });\n  const x0 = RM_WZ[0] + 0.02, zc = SOFA_Z, KW = 1.15, KD = 0.5, KH = 0.38;\n  tv.add(box('karton_unten', K, x0, 0.002, zc - KW/2, x0 + KD, KH, zc + KW/2));\n  tv.add(box('karton_oben', K, x0 + 0.01, KH, zc - KW/2 + 0.015, x0 + KD + 0.005, 2*KH, zc + KW/2 + 0.01));\n  for (const y of [0.3, 0.3 + KH]) tv.add(box('karton_aufdruck', KT, x0 + KD + 0.004, y - 0.02, zc - 0.25, x0 + KD + 0.007, y, zc + 0.25));\n  const top = 2*KH, xb = x0 + 0.24, tw = 0.97, th = 0.57, fh = 0.07;\n  tv.add(box('tv_rahmen', TVM, xb, top + fh, zc - tw/2, xb + 0.045, top + fh + th, zc + tw/2));\n  tv.add(box('tv_bildschirm', SCR, xb + 0.045, top + fh + 0.012, zc - tw/2 + 0.012, xb + 0.047, top + fh + th - 0.012, zc + tw/2 - 0.012));\n  tv.add(box('tv_rueckseite', TVM, xb - 0.04, top + fh + 0.08, zc - 0.3, xb, top + fh + 0.45, zc + 0.3));\n  for (const s of [-1, 1]){\n    const f = box('tv_fuss', FT, -0.09, 0, -0.012, 0.09, 0.012, 0.012); f.position.set(xb + 0.02, top, zc + s*0.41); f.rotation.y = s*0.5; tv.add(f);\n    tv.add(box('tv_fuss_steg', FT, xb + 0.01, top, zc + s*0.41 - 0.01, xb + 0.03, top + fh, zc + s*0.41 + 0.01));\n  }\n  tv.add(box('receiver', TVM, xb + 0.06, top, zc - 0.28, xb + 0.2, top + 0.03, zc - 0.06));\n  tv.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\n  wohn.add(tv);\n}\nwohn.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\nhome.add(wohn);\n// ---------- Schlafzimmer: Tripod-Lampe auf dem Boden, Südwest-Ecke, Spot zur Raummitte ----------\nconst trip = buildTripod(THREE);\n{\n  const IN_W = RM_SZ[0], px = IN_W + 0.35, pz = IN_S - 0.35;\n  const cx = (RM_SZ[0] + RM_SZ[2])/2, cz = (RM_SZ[1] + RM_SZ[3])/2;\n  trip.group.position.set(px, 0.002, pz);\n  trip.group.rotation.y = Math.atan2(cx - px, cz - pz);\n  home.add(trip.group);\n}\n\n\n// ---------- Schlafzimmer: Bett (140 × 200, Kopfteil Ostwand, rechts an der Südwand) + Schminktisch ----------\n{\n  const sz = new THREE.Group(); sz.name = 'schlafzimmer_moebel';\n  const add = m => { sz.add(m); return m; };\n  const LE = new THREE.MeshStandardMaterial({ name:'bett_kunstleder', color:0xeee8dc, roughness:0.55 });\n  const SH = new THREE.MeshStandardMaterial({ name:'spannbetttuch', color:0x67696e, roughness:0.95 });\n  const DE = new THREE.MeshStandardMaterial({ name:'kuscheldecke', color:0x58585b, roughness:1 });\n  const KI = new THREE.MeshStandardMaterial({ name:'kissen', color:0xf4f3ef, roughness:0.9 });\n  const LK = new THREE.MeshPhysicalMaterial({ name:'lack_weiss_hochglanz', color:0xf6f6f4, roughness:0.15, clearcoat:0.8, clearcoatRoughness:0.1 });\n  const SP = new THREE.MeshStandardMaterial({ name:'spiegel_schminktisch', color:0xdfe5e8, roughness:0.03, metalness:1 });\n  const BU = new THREE.MeshStandardMaterial({ name:'spiegel_birne', color:0xffffff, roughness:0.3, emissive:0xfff1d8, emissiveIntensity:0.15 });\n  const E = RM_SZ[2], S = RM_SZ[3];\n  // Bett\n  const HB = 0.1, bx0 = E - HB - 2.0, bz0 = S - 1.46, bz1 = S - 0.01;\n  add(box('bett_sockel', M.plinth, bx0 + 0.06, 0, bz0 + 0.06, E - HB - 0.06, 0.06, bz1 - 0.06));\n  add(box('bett_rahmen', LE, bx0, 0.06, bz0, E - HB, 0.36, bz1));\n  add(box('bett_matratze', SH, bx0 + 0.02, 0.36, bz0 + 0.03, E - HB - 0.01, 0.56, bz1 - 0.03));\n  add(box('bett_kopfteil', LE, E - HB, 0.06, bz0, E - 0.002, 1.12, bz1));\n  add(box('bett_kopfteil_ablage', LE, E - HB - 0.05, 1.04, bz0, E - 0.002, 1.12, bz1));\n  for (const y of [0.72, 0.86, 1.0]) for (let i = 0; i < 11; i++){\n    const b = new THREE.Mesh(new THREE.SphereGeometry(0.009, 10, 8), LE); b.name = 'bett_knopf';\n    b.position.set(E - HB - 0.002, y, bz0 + 0.1 + i*(bz1 - bz0 - 0.2)/10 + (y === 0.86 ? 0.06 : 0)); if (b.position.z < bz1 - 0.05) add(b);\n  }\n  const pil = add(new THREE.Mesh(new THREE.SphereGeometry(1, 32, 16), KI)); pil.name = 'kopfkissen';\n  pil.scale.set(0.2, 0.07, 0.34); pil.position.set(E - HB - 0.24, 0.6, bz0 + 0.5);\n  add(box('decke_oben', DE, bx0 + 0.05, 0.56, bz0 - 0.02, E - HB - 0.5, 0.6, bz1 - 0.02));\n  add(box('decke_seite', DE, bx0 + 0.05, 0.3, bz0 - 0.03, E - HB - 0.5, 0.6, bz0 - 0.01));\n  add(box('decke_fuss', DE, bx0 + 0.03, 0.32, bz0 - 0.02, bx0 + 0.05, 0.6, bz1 - 0.02));\n  // Schminktisch an der Ostwand zwischen Heizkörper und Bett, Schubladen links (Norden)\n  const D = 0.45, x1 = E, x0 = E - D, z0 = RM_SZ[1] + 1.0, z1 = z0 + 1.1, H = 0.76, PW = 0.4, T = 0.018;\n  add(box('schminktisch_platte', LK, x0, H - 0.025, z0, x1, H, z1));\n  add(box('schminktisch_korpus', LK, x0, 0.04, z0, x1, H - 0.025, z0 + PW));\n  add(box('schminktisch_sockel', LK, x0 + 0.02, 0, z0 + 0.02, x1, 0.04, z0 + PW - 0.02));\n  add(box('schminktisch_seite', LK, x0, 0, z1 - T, x1, H - 0.025, z1));\n  add(box('schminktisch_zarge', LK, x0, H - 0.15, z0 + PW, x1, H - 0.025, z1 - T));\n  add(box('schminktisch_rueckwand', LK, x1 - 0.015, 0.04, z0 + PW, x1, H - 0.15, z1 - T));\n  const fronts = [[0.05, 0.215], [0.22, 0.385], [0.39, 0.555], [0.56, H - 0.03]];\n  fronts.forEach(([a, b], i) => add(box('schublade_' + (i+1), LK, x0 - 0.012, a, z0 + 0.004, x0, b, z0 + PW - 0.004)));\n  add(box('schublade_mitte', LK, x0 - 0.012, H - 0.145, z0 + PW + 0.004, x0, H - 0.03, z1 - T - 0.004));\n  // Spiegel mit Glühbirnen, auf der Platte an die Wand gelehnt\n  const mz0 = z0 + 0.17, mz1 = z0 + 0.97, my0 = H, my1 = H + 0.62;\n  const mir = new THREE.Group(); mir.name = 'schminkspiegel';\n  mir.add(box('schminkspiegel_rahmen', LK, -0.035, 0, mz0, 0, my1 - my0, mz1));\n  mir.add(box('schminkspiegel_glas', SP, -0.037, 0.06, mz0 + 0.06, -0.035, my1 - my0 - 0.06, mz1 - 0.06));\n  const bulb = (y, z) => { const b = new THREE.Mesh(new THREE.SphereGeometry(0.021, 16, 12), BU); b.name = 'schminkspiegel_birne'; b.position.set(-0.045, y, z); mir.add(b); };\n  for (let i = 0; i < 8; i++) bulb(my1 - my0 - 0.03, mz0 + 0.04 + i*(mz1 - mz0 - 0.08)/7);\n  for (let i = 1; i < 5; i++){ const y = my1 - my0 - 0.03 - i*0.13; bulb(y, mz0 + 0.035); bulb(y, mz1 - 0.035); }\n  mir.position.set(x1 - 0.1, my0, 0); mir.rotation.z = -0.08; sz.add(mir);\n  sz.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\n  home.add(sz);\n}\n// ---------- Mauervorsprung Wohnzimmer (41,5 × 40 cm, Ecke Tür-/Außenwand) ----------\n{\n  const mat = Array(6).fill(M.wall); mat[2] = M.cap;\n  walls.add(box('wohnzimmer_vorsprung', mat, IN_O - 0.415, 0, RM_WZ[1], IN_O + 0.001, HI, RM_WZ[1] + 0.40, 1.5));\n}\n// ---------- Küche: Fliesenspiegel an der Wand zum Bad, ab Fensterunterkante 60 cm hoch ----------\nconst tileMat = new THREE.MeshStandardMaterial({ name:'interior_tiles', color:0xf3f2ee, roughness:0.2 });\n{\n  const x0 = RM_KU[0], z0 = 0, z1 = Z_SCH0;\n  const t = box('kueche_fliesen', tileMat, x0, WIN_B, z0, x0 + 0.008, WIN_B + 0.6, z1, 1.0);\n  // um die Ecke auf die Fensterwand, bis an die Fensterlaibung\n  const winW = KU_WIN.c - KU_WIN.w/2;\n  const t2 = box('kueche_fliesen_fensterwand', tileMat, x0 + 0.008, WIN_B, z0, winW, WIN_B + 0.6, z0 + 0.008, 1.0);\n  t.receiveShadow = t2.receiveShadow = true; home.add(t, t2);\n}\n// ---------- Heizkörper ----------\nconst radMat = new THREE.MeshStandardMaterial({ name:'heizkoerper_weiss', color:0xf4f3ef, roughness:0.4, metalness:0.1 });\nfunction makeRadiator(name, len){\n  const g = new THREE.Group(); g.name = name;\n  const y0 = 0.15, y1 = 0.75, n = Math.max(3, Math.round(len/0.05)), st = len/n;\n  for (let i = 0; i < n; i++){ const x = -len/2 + st*(i+0.5); g.add(box(name+'_glied'+i, radMat, x-st*0.38, y0, -0.035, x+st*0.38, y1, 0.035)); }\n  g.add(box(name+'_sammler_o', radMat, -len/2, y1-0.05, -0.02, len/2, y1-0.01, 0.02));\n  g.add(box(name+'_sammler_u', radMat, -len/2, y0+0.01, -0.02, len/2, y0+0.05, 0.02));\n  const v = new THREE.Mesh(new THREE.CylinderGeometry(0.018, 0.018, 0.08, 20), radMat); v.name = name+'_ventil'; v.position.set(len/2+0.03, y1-0.04, 0); g.add(v);\n  const p = new THREE.Mesh(new THREE.CylinderGeometry(0.01, 0.01, y0, 12), M.metal); p.name = name+'_rohr'; p.position.set(-len/2+0.02, y0/2, 0); g.add(p);\n  g.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\n  return g;\n}\n{\n  // Schlafzimmer: an der Mittelwand, 41–86 cm von der Türwand\n  const h1 = makeRadiator('heizkoerper_schlafzimmer', 0.45);\n  h1.position.set(RM_SZ[2] - 0.075, 0, RM_SZ[1] + 0.41 + 0.225); h1.rotation.y = Math.PI/2;\n  // Wohnzimmer: an der Türwand direkt neben der Tür, Richtung Mittelwand\n  const h2 = makeRadiator('heizkoerper_wohnzimmer', 0.48);\n  h2.position.set(WZ_DOOR.c - WZ_DOOR.w/2 - 0.02 - 0.24, 0, RM_WZ[1] + 0.075);\n  home.add(h1, h2);\n}\n\n// ---------- Bad (nach Foto): Wanne rechts, WC + Waschtisch links, Fliesen ----------\n{\n  const bad = new THREE.Group(); bad.name = 'bad';\n  const [W, N, E, SZ] = RM_BAD, TT = 0.008, SCX = X_SCH, SCZ = Z_SCH0;\n  const add = m => { bad.add(m); return m; };\n  const bx = (n, mat, ...a) => add(box(n, mat, ...a));\n  function cyl(n, mat, r, h, x, y, z, axis, r2){\n    const m = new THREE.Mesh(new THREE.CylinderGeometry(r, r2 ?? r, h, 28), mat); m.name = n; m.position.set(x, y, z);\n    if (axis === 'x') m.rotation.z = Math.PI/2; if (axis === 'z') m.rotation.x = Math.PI/2; return add(m);\n  }\n  function tileTex(px, n, base, grout, veins, seed){\n    const c = document.createElement('canvas'); c.width = c.height = px*n; const g = c.getContext('2d');\n    g.fillStyle = base; g.fillRect(0, 0, c.width, c.height);\n    const rnd = () => (seed = (seed*16807) % 2147483647) / 2147483647;\n    g.lineWidth = 1.4;\n    for (let i = 0; i < veins; i++){\n      g.strokeStyle = 'rgba(125,127,132,' + (0.05 + rnd()*0.07) + ')'; g.beginPath();\n      let x = rnd()*c.width, y = rnd()*c.height; g.moveTo(x, y);\n      for (let k = 0; k < 4; k++){ const cx = x + (rnd()-.5)*px, cy = y + (rnd()-.5)*px; x += (rnd()-.5)*px*1.3; y += (rnd()-.5)*px*1.3; g.quadraticCurveTo(cx, cy, x, y); }\n      g.stroke();\n    }\n    g.fillStyle = grout; const gw = Math.max(3, px/32);\n    for (let i = 0; i < n; i++){ g.fillRect(i*px, 0, gw, c.height); g.fillRect(0, i*px, c.width, gw); }\n    const t = new THREE.CanvasTexture(c); t.wrapS = t.wrapT = THREE.RepeatWrapping; t.colorSpace = THREE.SRGBColorSpace; t.anisotropy = 8; return t;\n  }\n  const BM = {\n    wand:   new THREE.MeshStandardMaterial({ name:'bad_wandfliesen', map: tileTex(128, 4, '#f3f3f1', '#c6c6c2', 46, 11), roughness:0.16 }),\n    boden:  new THREE.MeshStandardMaterial({ name:'bad_bodenfliesen', map: tileTex(128, 4, '#efeeeb', '#a6a5a0', 34, 29), roughness:0.32 }),\n    email:  new THREE.MeshPhysicalMaterial({ name:'sanitaer_email', color:0xfbfbfa, roughness:0.1, clearcoat:1, clearcoatRoughness:0.06 }),\n    chrom:  new THREE.MeshStandardMaterial({ name:'chrom', color:0xe6e8ea, roughness:0.08, metalness:1 }),\n    spiegel:new THREE.MeshStandardMaterial({ name:'spiegel', color:0xe2e8ec, roughness:0.02, metalness:1 }),\n    glas:   new THREE.MeshStandardMaterial({ name:'glasablage', color:0xcfe6e0, roughness:0.05, transparent:true, opacity:0.45 }),\n    dekor:  new THREE.MeshStandardMaterial({ name:'dekorfliese', color:0x9fb0c2, roughness:0.2 }),\n    plast:  new THREE.MeshStandardMaterial({ name:'wc_sitz', color:0xf7f7f5, roughness:0.3 }),\n  };\n  const emailIn = BM.email.clone(); emailIn.name = 'sanitaer_email_innen'; emailIn.side = THREE.BackSide;\n  const emailDS = BM.email.clone(); emailDS.name = 'sanitaer_email_ds'; emailDS.side = THREE.DoubleSide;\n  // Milchglas im Badfenster\n  const fg = windows.getObjectByName('fenster_bad_glas');\n  if (fg) fg.material = new THREE.MeshStandardMaterial({ name:'milchglas', color:0xf2f5f5, roughness:0.7, transparent:true, opacity:0.85 });\n\n  // Boden + Wandfliesen (halbhoch 1,25 m, um die Wanne 2,05 m)\n  const HT = 1.25, FT = 2.05;\n  const TW = 0.78, TL = 1.75, LEDGE = 0.2, TX0 = E - TW, TZ1 = N + LEDGE + TL;\n  const wxc = 2.25, wl = wxc - 0.4, wr = wxc + 0.4, dxc = BAD_DOOR.c, DW = BAD_DOOR.w;\n  // Vorwand an der Fensterwand: von der Westwand bis ans Fenster, 15 cm vorgezogen\n  const VD = 0.15;\n  { const vm = Array(6).fill(M.wall); vm[2] = M.cap; walls.add(box('bad_vorwand', vm, W, 0, N, wl, HI, N + VD, 1.5)); }\n  bx('bad_boden', BM.boden, W, 0, N, E, 0.008, SZ, 0.8);\n  bx('bad_fliesen_west', BM.wand, W, 0, N + VD + TT, W + TT, HT, SZ, 0.6);\n  bx('bad_fliesen_vorwand', BM.wand, W, 0, N + VD, wl, HT, N + VD + TT, 0.6);\n  bx('bad_fliesen_vorwand_seite', BM.wand, wl - 0.001, 0, N, wl + TT, HT, N + VD + TT, 0.6);\n  bx('bad_fliesen_nord_2', BM.wand, wl, 0, N, wr, WIN_B - 0.03, N + TT, 0.6);\n  bx('bad_fliesen_nord_3', BM.wand, wr, 0, N, E - TT, FT, N + TT, 0.6);\n  bx('bad_fliesen_ost_1', BM.wand, E - TT, 0, N, E, FT, TZ1, 0.6);\n  bx('bad_fliesen_ost_2', BM.wand, E - TT, 0, TZ1, E, HT, SCZ, 0.6);\n  bx('bad_fliesen_schacht_n', BM.wand, SCX - TT, 0, SCZ - TT, E - TT, HT, SCZ, 0.6);\n  bx('bad_fliesen_schacht_w', BM.wand, SCX - TT, 0, SCZ, SCX, HT, SZ, 0.6);\n  bx('bad_fliesen_sued_1', BM.wand, W + TT, 0, SZ - TT, dxc - DW/2, HT, SZ, 0.6);\n  bx('bad_fliesen_sued_2', BM.wand, dxc + DW/2, 0, SZ - TT, SCX - TT, HT, SZ, 0.6);\n  for (const [y, z] of [[1.15, N + 0.75], [1.72, N + 0.55]]){\n    const d = bx('bad_dekorfliese', BM.dekor, -0.001, -0.04, -0.04, 0.001, 0.04, 0.04);\n    d.rotation.x = Math.PI/4; d.position.set(E - TT - 0.001, y, z);\n  }\n\n  // Badewanne, eingefliest, mit Ablage am Kopfende\n  bx('wanne_ablage', BM.wand, TX0, 0.008, N + TT, E - TT, 0.6, N + LEDGE, 0.6);\n  bx('wanne_schuerze', BM.wand, TX0, 0.008, N + LEDGE, TX0 + 0.03, 0.565, TZ1, 0.6);\n  bx('wanne_schuerze_ende', BM.wand, TX0, 0.008, TZ1 - 0.03, E - TT, 0.565, TZ1, 0.6);\n  function rr(p, w, d, r){ const x = -w/2, y = -d/2;\n    p.moveTo(x + r, y); p.lineTo(x + w - r, y); p.quadraticCurveTo(x + w, y, x + w, y + r); p.lineTo(x + w, y + d - r);\n    p.quadraticCurveTo(x + w, y + d, x + w - r, y + d); p.lineTo(x + r, y + d); p.quadraticCurveTo(x, y + d, x, y + d - r);\n    p.lineTo(x, y + r); p.quadraticCurveTo(x, y, x + r, y); return p; }\n  const tcx = E - TT/2 - TW/2 + TT/2, tcz = N + LEDGE + TL/2, IW = TW - 0.14, IL = TL - 0.18, IR = 0.22;\n  const rimS = rr(new THREE.Shape(), TW - TT, TL, 0.02); rimS.holes.push(rr(new THREE.Path(), IW, IL, IR));\n  const rimG = new THREE.ExtrudeGeometry(rimS, { depth:0.035, bevelEnabled:false, curveSegments:16 });\n  rimG.rotateX(-Math.PI/2); rimG.translate(tcx, 0.565, tcz);\n  add(new THREE.Mesh(rimG, BM.email)).name = 'wanne_rand';\n  const basG = new THREE.ExtrudeGeometry(rr(new THREE.Shape(), IW, IL, IR), { depth:0.41, bevelEnabled:false, curveSegments:16 });\n  basG.rotateX(-Math.PI/2); basG.translate(tcx, 0.16, tcz);\n  add(new THREE.Mesh(basG, emailIn)).name = 'wanne_innen';\n  const mz0 = TZ1 - 0.35;\n  cyl('wanne_ablauf', BM.chrom, 0.024, 0.004, tcx, 0.163, mz0 - 0.05);\n  // Wannenarmatur an der Ostwand\n  cyl('armatur_koerper', BM.chrom, 0.024, 0.2, E - 0.075, 0.8, mz0, 'z');\n  for (const s of [-1, 1]){\n    cyl('armatur_anschluss', BM.chrom, 0.01, 0.075, E - 0.04, 0.8, mz0 + s*0.08, 'x');\n    cyl('armatur_rosette', BM.chrom, 0.03, 0.008, E - TT - 0.004, 0.8, mz0 + s*0.08, 'x');\n  }\n  cyl('armatur_auslauf', BM.chrom, 0.012, 0.11, E - 0.135, 0.775, mz0, 'x');\n  bx('armatur_hebel', BM.chrom, E - 0.085, 0.82, mz0 - 0.012, E - 0.03, 0.835, mz0 + 0.012);\n  // Duschstange + Handbrause + Schlauch\n  const rz = TZ1 - 0.85, rx = E - 0.045;\n  cyl('duschstange', BM.chrom, 0.012, 0.95, rx, 1.6, rz);\n  for (const y of [1.13, 2.07]){ cyl('duschstange_halter', BM.chrom, 0.01, 0.045, E - 0.022, y, rz, 'x'); cyl('duschstange_rosette', BM.chrom, 0.022, 0.01, E - TT - 0.005, y, rz, 'x'); }\n  bx('duschstange_schieber', BM.chrom, rx - 0.035, 1.68, rz - 0.022, rx + 0.02, 1.76, rz + 0.022);\n  const brause = new THREE.Group(); brause.name = 'handbrause'; brause.position.set(rx - 0.06, 1.72, rz); brause.rotation.z = 0.5;\n  { const h = new THREE.Mesh(new THREE.CylinderGeometry(0.013, 0.011, 0.2, 20), BM.chrom); h.name = 'handbrause_griff'; brause.add(h);\n    const k = new THREE.Mesh(new THREE.CylinderGeometry(0.045, 0.03, 0.025, 32), BM.chrom); k.name = 'handbrause_kopf'; k.position.y = 0.11; k.rotation.z = Math.PI/2 - 0.3; brause.add(k); }\n  add(brause);\n  const hb0 = new THREE.Vector3(rx - 0.06 + 0.1*Math.sin(0.5), 1.72 - 0.1*Math.cos(0.5), rz);\n  const hose = new THREE.CatmullRomCurve3([hb0, new THREE.Vector3(E - 0.09, 1.2, rz + 0.08), new THREE.Vector3(E - 0.2, 0.7, (rz + mz0)/2 + 0.05), new THREE.Vector3(E - 0.12, 0.66, mz0 - 0.02), new THREE.Vector3(E - 0.085, 0.77, mz0 - 0.03)]);\n  add(new THREE.Mesh(new THREE.TubeGeometry(hose, 80, 0.007, 8), BM.chrom)).name = 'brauseschlauch';\n  // Haltegriff\n  const gz = TZ1 - 0.6;\n  cyl('haltegriff', BM.chrom, 0.013, 0.36, E - 0.065, 1.12, gz);\n  for (const y of [0.96, 1.28]) cyl('haltegriff_stuetze', BM.chrom, 0.012, 0.06, E - 0.035, y, gz, 'x');\n  // Vorhangstange oben\n  cyl('vorhangstange', BM.chrom, 0.01, TL - 0.2, E - 0.09, 2.15, N + LEDGE + TL/2 - 0.1, 'z');\n  cyl('vorhangstange_halter', BM.chrom, 0.009, 0.09, E - 0.045, 2.15, N + LEDGE + 0.05, 'x');\n\n  // WC an der Westwand (Blick zur Wanne), Aufputz-Spülkasten\n  const wc = new THREE.Group(); wc.name = 'wc'; wc.position.set(W + TT, 0, N + VD + 0.45); wc.rotation.y = Math.PI/2;\n  { const wa = m => { wc.add(m); return m; };\n    wa(box('wc_sockel_hinten', BM.email, -0.13, 0.008, 0, 0.13, 0.38, 0.22));\n    const p = new THREE.Mesh(new THREE.CylinderGeometry(0.15, 0.115, 0.32, 40), BM.email); p.name = 'wc_fuss'; p.scale.z = 1.3; p.position.set(0, 0.168, 0.37); wa(p);\n    const b = new THREE.Mesh(new THREE.CylinderGeometry(0.185, 0.15, 0.08, 48), BM.email); b.name = 'wc_becken'; b.scale.z = 1.3; b.position.set(0, 0.365, 0.41); wa(b);\n    const s = new THREE.Mesh(new THREE.CylinderGeometry(0.185, 0.185, 0.02, 48), BM.plast); s.name = 'wc_sitz'; s.scale.z = 1.3; s.position.set(0, 0.415, 0.41); wa(s);\n    const d = new THREE.Mesh(new THREE.CylinderGeometry(0.178, 0.178, 0.022, 48), BM.plast); d.name = 'wc_deckel'; d.scale.z = 1.28; d.position.set(0, 0.436, 0.41); wa(d);\n    wa(box('wc_scharnier', BM.plast, -0.1, 0.405, 0.15, 0.1, 0.44, 0.2));\n    wa(box('wc_spuelkasten', BM.email, -0.2, 0.8, 0, 0.2, 1.2, 0.15));\n    const t = new THREE.Mesh(new THREE.CylinderGeometry(0.02, 0.02, 0.02, 28), BM.email); t.name = 'wc_spueltaste'; t.position.set(-0.12, 1.21, 0.09); wa(t);\n    const r = new THREE.Mesh(new THREE.CylinderGeometry(0.025, 0.025, 0.4, 28), BM.email); r.name = 'wc_spuelrohr'; r.position.set(0, 0.6, 0.08); wa(r); }\n  add(wc);\n  // Wasserzähler + Ventil an der Vorwand, Papierhalter unter dem Fenster\n  cyl('bad_wasserzaehler', BM.chrom, 0.055, 0.03, wl - 0.13, 0.98, N + VD + TT + 0.015, 'z');\n  cyl('bad_wasserzaehler_glas', BM.plast, 0.035, 0.034, wl - 0.13, 0.98, N + VD + TT + 0.017, 'z');\n  cyl('bad_ventil', BM.chrom, 0.028, 0.05, wl - 0.13, 1.2, N + VD + TT + 0.025, 'z');\n  bx('papierhalter', BM.chrom, wxc - 0.02, 0.62, N + TT, wxc + 0.12, 0.7, N + 0.08);\n\n  // Waschtisch an der Westwand, Spiegel + Glasablagen darüber\n  const bz = N + 1.35, BR = 0.3, SX = 0.87, RY = 0.85, bcx = W + 0.2;\n  { const o = new THREE.Mesh(new THREE.CylinderGeometry(BR, 0.2, 0.17, 48, 1, true), emailDS); o.name = 'waschbecken_aussen'; o.scale.x = SX; o.position.set(bcx, RY - 0.085, bz); add(o);\n    const f = new THREE.Mesh(new THREE.CircleGeometry(0.2, 48), BM.email); f.name = 'waschbecken_unten'; f.rotation.x = Math.PI/2; f.scale.x = SX; f.position.set(bcx, RY - 0.17, bz); add(f);\n    const r = new THREE.Mesh(new THREE.RingGeometry(0.235, BR, 48), BM.email); r.name = 'waschbecken_rand'; r.rotation.x = -Math.PI/2; r.scale.x = SX; r.position.set(bcx, RY, bz); add(r);\n    const i = new THREE.Mesh(new THREE.SphereGeometry(0.235, 48, 16, 0, Math.PI*2, Math.PI/2, Math.PI/2), emailDS); i.name = 'waschbecken_innen'; i.scale.set(SX, 0.55, 1); i.position.set(bcx, RY, bz); add(i); }\n  cyl('waschtisch_armatur', BM.chrom, 0.022, 0.12, W + 0.075, RY + 0.06, bz);\n  { const s = cyl('waschtisch_auslauf', BM.chrom, 0.011, 0.13, W + 0.13, RY + 0.1, bz, 'x'); s.rotation.z = Math.PI/2 + 0.25; }\n  bx('waschtisch_hebel', BM.chrom, W + 0.04, RY + 0.12, bz - 0.012, W + 0.1, RY + 0.135, bz + 0.012);\n  cyl('siphon', BM.chrom, 0.02, 0.2, bcx, 0.58, bz);\n  cyl('siphon_rohr', BM.chrom, 0.018, 0.2, W + 0.1, 0.48, bz, 'x');\n  cyl('siphon_rosette', BM.chrom, 0.035, 0.01, W + TT + 0.005, 0.48, bz, 'x');\n  bx('spiegel', BM.spiegel, W + TT, 1.34, bz - 0.3, W + TT + 0.006, 2.0, bz + 0.3);\n  for (const y of [1.3, 1.05]){\n    bx('glasablage', BM.glas, W + TT, y, bz - 0.3, W + 0.14, y + 0.008, bz + 0.3);\n    for (const s of [-1, 1]) bx('glasablage_halter', BM.chrom, W + TT, y - 0.012, bz + s*0.3 - 0.012, W + 0.06, y + 0.016, bz + s*0.3 + 0.012);\n  }\n\n  bad.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\n  bad.getObjectByName('bad_boden').castShadow = false;\n  home.add(bad);\n}\n\n\nstage.setObject(home);\n\n// ---------- Schatten: enger Frustum, 4096er Map, harter PCF → scharf & ohne Flackern ----------\nconst renderer = stage._renderer, scene = stage._scene, key = stage._key;\nrenderer.shadowMap.type = THREE.PCFShadowMap;\nconst hb = new THREE.Box3().setFromObject(home), hc = hb.getCenter(new THREE.Vector3()), hs = hb.getSize(new THREE.Vector3());\nconst sunDir = new THREE.Vector3(4, 7, 5).normalize();\nkey.position.copy(hc).addScaledVector(sunDir, 30);\nkey.target.position.copy(hc); scene.add(key.target);\nconst half = Math.max(hs.x, hs.z) * 0.62;\nObject.assign(key.shadow.camera, { left:-half, right:half, top:half, bottom:-half, near:1, far:60 });\nkey.shadow.camera.updateProjectionMatrix();\nkey.shadow.mapSize.set(2048, 2048);\nkey.shadow.bias = -0.0004; key.shadow.normalBias = 0.015;\nif (key.shadow.map){ key.shadow.map.dispose(); key.shadow.map = null; }\nrenderer.toneMapping = THREE.ACESFilmicToneMapping;\nif (stage._ground) stage._ground.visible = false;\nconst hemi = scene.children.find(o => o.isHemisphereLight), hemiBase = hemi ? hemi.intensity : 0;\nconst fillL = scene.children.find(o => o.isDirectionalLight && o !== key), fillBase = fillL ? fillL.intensity : 0;\nconst ENV = 0.9;\nlet envK = 1, hemiK = 1, fillK = 1, expK = 1;\n// Innenraum: Himmels-/Fülllicht dringt nicht durch die Decke → nur noch Sonne + Umgebung durch die Fenster\nfunction applyInterior(o){\n  if (hemi) hemi.intensity = hemiBase * hemiK * (1 - 0.85*o);\n  if (fillL) fillL.intensity = fillBase * fillK * (1 - o);\n  scene.environmentIntensity = ENV * envK * (1 - 0.7*o);\n  renderer.toneMappingExposure = (1 + 0.45*o) * expK;\n}\n\n// ---------- Decke (blendet ein, sobald man in einem Raum steht) ----------\nconst ceilMat = new THREE.MeshStandardMaterial({ name:'decke', color:0xf4f2ee, roughness:0.95, transparent:true, opacity:0, depthWrite:false });\nconst ceiling = new THREE.Group(); ceiling.name = 'decke';\nceiling.add(box('decke_nord', ceilMat, X_FL - TE, H, -TE, X_E + TE, H+0.04, ZST), box('decke_sued', ceilMat, -TE, H, ZST, X_E + TE, H+0.04, Z_S + TE));\nceiling.traverse(o => { if (o.isMesh){ o.receiveShadow = true; o.castShadow = true; } }); ceiling.visible = false;\nhome.add(ceiling);\nfunction setCeil(o){\n  ceilMat.opacity = o;\n  if (ceiling.visible !== (o > 0.001)){ ceiling.visible = o > 0.001; ptDirty = true; }\n  const solid = o >= 0.999;\n  if (ceilMat.transparent === solid){ ceilMat.transparent = !solid; ceilMat.depthWrite = solid; ceilMat.needsUpdate = true; }\n  if (!ptOn) applyInterior(o);\n}\n\n// ---------- Bogenlampe: Licht an/aus ----------\nhome.updateMatrixWorld(true);\nconst bulb = lampe.group.getObjectByName('leuchtmittel');\nconst bp = bulb.getWorldPosition(new THREE.Vector3());\nconst lampSpot = new THREE.SpotLight(0xffd6a0, 0, 0, 1.0, 0.6, 2);\nlampSpot.position.copy(bp).add(new THREE.Vector3(0, -0.035, 0));\nlampSpot.target.position.set(bp.x, 0, bp.z);\nlampSpot.castShadow = true;\nlampSpot.shadow.mapSize.set(1024, 1024);\nlampSpot.shadow.bias = -0.0005; lampSpot.shadow.normalBias = 0.02;\nlampSpot.shadow.camera.near = 0.05; lampSpot.shadow.camera.far = 8;\nconst lampFill = new THREE.PointLight(0xffd6a0, 0, 7, 2);\nlampFill.position.copy(bp);\nscene.add(lampSpot, lampSpot.target, lampFill);\nconst schirm = lampe.group.getObjectByName('schirm').material;\nschirm.emissive = new THREE.Color(0xffe2b8);\nconst lampBtn = document.getElementById('lamp');\nlet lampOn = false, lampLvl = 0, lampAnim = 0;\nlet rasterEnv = null, ptEnv = null;\nlet tracer = null, ptOn = false, ptDirty = true, inRoom = false, stillSince = 0;\nconst LAMP_KEY = 'wohnung-bogenlampe-farbe';\nlet lampK = 1;\nconst lampSw = document.getElementById('lampSw');\nfunction setLampColor(hex){\n  const c = new THREE.Color(hex), s = c.clone().lerp(new THREE.Color(0xffffff), 0.3);\n  lampSpot.color.copy(c); lampFill.color.copy(c);\n  if (bulb.material.emissive) bulb.material.emissive.copy(c);\n  schirm.emissive.copy(s);\n  try { localStorage.setItem(LAMP_KEY, hex); } catch(e){}\n  document.querySelector('#lamp i').style.cssText = lampOn ? `background:${hex};box-shadow:0 0 10px 3px ${hex}99` : '';\n  if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); }\n}\n// ---------- Licht-Picker: Hell (Lichtton + Helligkeit) oder Farbe (Farbkreis) ----------\nconst K_COLD = 8000, K_WARM = 2000;\nfunction kelvinHex(k){\n  const t = k/100; let r, g, b;\n  if (t <= 66){ r = 255; g = 99.4708025861*Math.log(t) - 161.1195681661; b = t <= 19 ? 0 : 138.5177312231*Math.log(t-10) - 305.0447927307; }\n  else { r = 329.698727446*Math.pow(t-60, -0.1332047592); g = 288.1221695283*Math.pow(t-60, -0.0755148492); b = 255; }\n  const c = v => Math.round(Math.max(0, Math.min(255, v))).toString(16).padStart(2, '0');\n  return '#' + c(r) + c(g) + c(b);\n}\nconst warmK = w => Math.round(K_COLD - w/100*(K_COLD - K_WARM));\nfunction hsvRGB(h, s, v){ const f = n => { const k = (n + h/60) % 6; return v - v*s*Math.max(0, Math.min(k, 4-k, 1)); }; return [f(5), f(3), f(1)]; }\nconst rgbHex = a => '#' + a.map(x => Math.round(x*255).toString(16).padStart(2, '0')).join('');\nfunction makePicker(sw, key, def, dimIn, onChange){\n  let st = { mode: 'white', warm: 70, h: 30, s: 0.6, ...def };\n  try { Object.assign(st, JSON.parse(localStorage.getItem(key) || 'null') || {}); } catch(e){}\n  const pop = document.createElement('div'); pop.className = 'lpick';\n  pop.innerHTML = '<div class=\"lp-seg\"><button data-m=\"white\">Hell<\u002Fbutton><button data-m=\"color\">Farbe<\u002Fbutton><\u002Fdiv>'\n    + '<div class=\"lp-row lp-w\"><div><span>Lichtton<\u002Fspan><output class=\"lp-kv\"><\u002Foutput><\u002Fdiv><input class=\"lp-temp\" type=\"range\" min=\"0\" max=\"100\" step=\"1\"><small><span>Steril<\u002Fspan><span>Warm<\u002Fspan><\u002Fsmall><\u002Fdiv>'\n    + '<div class=\"lp-c\"><div class=\"lp-wheel\"><canvas width=\"360\" height=\"360\"><\u002Fcanvas><i><\u002Fi><\u002Fdiv><\u002Fdiv>'\n    + '<div class=\"lp-row\"><div><span>Helligkeit<\u002Fspan><output class=\"lp-bv\"><\u002Foutput><\u002Fdiv><input class=\"lp-dim\" type=\"range\" min=\"10\" max=\"200\" step=\"5\"><\u002Fdiv><button class=\"lp-done\">Fertig<\u002Fbutton>';\n  document.body.appendChild(pop);\n  const $ = s => pop.querySelector(s), temp = $('.lp-temp'), bri = $('.lp-dim'), bv = $('.lp-bv'), dot = $('.lp-wheel i'), wheel = $('.lp-wheel');\n  temp.style.background = `linear-gradient(90deg,${kelvinHex(K_COLD)},${kelvinHex(4500)},${kelvinHex(3000)},${kelvinHex(K_WARM)})`;\n  const cv = $('canvas'), ctx = cv.getContext('2d'), img = ctx.createImageData(360, 360), R = 180;\n  for (let y = 0; y < 360; y++) for (let x = 0; x < 360; x++){\n    const dx = x + .5 - R, dy = y + .5 - R, d = Math.hypot(dx, dy) / R, i = (y*360 + x)*4;\n    const rgb = hsvRGB((Math.atan2(dy, dx)*180/Math.PI + 360) % 360, 1, 1);\n    img.data[i] = rgb[0]*255; img.data[i+1] = rgb[1]*255; img.data[i+2] = rgb[2]*255;\n    img.data[i+3] = 255 * Math.max(0, Math.min(1, (1 - d) * R, (d - 0.72) * R));\n  }\n  ctx.putImageData(img, 0, 0);\n  const hex = () => st.mode === 'white' ? kelvinHex(warmK(st.warm)) : rgbHex(hsvRGB(st.h, 1, 1));\n  function update(fire = true){\n    pop.querySelectorAll('.lp-seg button').forEach(b => b.classList.toggle('on', b.dataset.m === st.mode));\n    $('.lp-w').style.display = st.mode === 'white' ? '' : 'none';\n    $('.lp-c').style.display = st.mode === 'color' ? '' : 'none';\n    temp.value = st.warm; $('.lp-kv').textContent = warmK(st.warm) + ' K';\n    const a = st.h*Math.PI/180;\n    dot.style.left = (90 + Math.cos(a)*77) + 'px'; dot.style.top = (90 + Math.sin(a)*77) + 'px';\n    const h = hex(); dot.style.background = h; sw.style.background = h;\n    try { localStorage.setItem(key, JSON.stringify(st)); } catch(e){}\n    if (fire) onChange(h);\n  }\n  pop.querySelectorAll('.lp-seg button').forEach(b => b.onclick = () => { st.mode = b.dataset.m; update(); });\n  temp.oninput = () => { st.warm = +temp.value; update(); };\n  const pick = e => { const r = wheel.getBoundingClientRect(), dx = e.clientX - r.left - 90, dy = e.clientY - r.top - 90;\n    st.h = (Math.atan2(dy, dx)*180/Math.PI + 360) % 360; update(); };\n  wheel.onpointerdown = e => { const r = wheel.getBoundingClientRect(), d = Math.hypot(e.clientX - r.left - 90, e.clientY - r.top - 90);\n    if (d < 58 || d > 94) return; wheel.setPointerCapture(e.pointerId); pick(e); };\n  wheel.onpointermove = e => { if (wheel.hasPointerCapture(e.pointerId)) pick(e); };\n  const syncBri = () => { bri.value = dimIn.value; bv.textContent = dimIn.value + '%'; };\n  bri.oninput = () => { dimIn.value = bri.value; dimIn.oninput(); syncBri(); };\n  dimIn.addEventListener('input', syncBri);\n  const place = () => { pop.style.left = '18px'; pop.style.top = '50%'; pop.style.transform = 'translateY(-50%)'; };\n  sw.onclick = e => { e.preventDefault(); e.stopPropagation(); const o = !pop.classList.contains('open');\n    document.querySelectorAll('.lpick.open').forEach(p => p.classList.remove('open'));\n    if (o){ syncBri(); place(); pop.classList.add('open'); }\n    document.body.classList.toggle('lpfocus', o);\n    dispatchEvent(new CustomEvent('lpick', { detail: { key, open: o } })); };\n  $('.lp-done').onclick = () => { pop.classList.remove('open'); document.body.classList.remove('lpfocus'); dispatchEvent(new CustomEvent('lpick', { detail: { key, open: false } })); };\n  document.addEventListener('pointerdown', e => { if (pop.classList.contains('open') && !pop.contains(e.target) && !sw.contains(e.target)){ pop.classList.remove('open'); document.body.classList.remove('lpfocus'); dispatchEvent(new CustomEvent('lpick', { detail: { key, open: false } })); } });\n  addEventListener('resize', () => pop.classList.contains('open') && place());\n  update();\n  return pop;\n}\n\nlet lampCol = localStorage.getItem(LAMP_KEY) || '#ffd6a0';\nlampSw.innerHTML = '';\nconst colIn = document.createElement('button'); colIn.className = 'lp-sw'; colIn.title = 'Licht einstellen';\nlampSw.appendChild(colIn);\nconst dimIn = document.querySelector('#lampDim input'), dimOut = document.querySelector('#lampDim output');\ndimIn.oninput = () => { lampK = dimIn.value / 100; dimOut.textContent = dimIn.value + '%'; applyLamp(lampLvl); if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); } };\nfunction applyLamp(v){\n  v *= lampK;\n  lampSpot.intensity = 9 * v;\n  lampFill.intensity = 2.2 * v;\n  bulb.material.emissiveIntensity = 0.2 + 5 * v;\n  schirm.emissiveIntensity = 0.55 * v;\n}\napplyLamp(0);\nmakePicker(colIn, LAMP_KEY + '-cfg', { mode: 'white', warm: 75 }, dimIn, h => { lampCol = h; setLampColor(h); });\nsetLampColor(lampCol);\ndocument.getElementById('lampT').onclick = () => {\n  lampOn = !lampOn;\n  lampBtn.classList.toggle('on', lampOn);\n  lampBtn.querySelector('span').textContent = lampOn ? 'Bogenlampe aus' : 'Bogenlampe an';\n  setLampColor(lampCol);\n  const id = ++lampAnim, from = lampLvl, to = lampOn ? 1 : 0, t0 = performance.now();\n  (function step(now){\n    if (id !== lampAnim) return;\n    const t = Math.min(1, (now - t0) / 450);\n    lampLvl = from + (to - from) * (1 - Math.pow(1 - t, 3));\n    applyLamp(lampLvl);\n    if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); }\n    if (t < 1) requestAnimationFrame(step);\n  })(t0);\n};\n\n// ---------- Donut-Lampe: nur an/aus ----------\nconst donutLight = new THREE.PointLight(0xffa050, 0, 4.5, 2);\ndonutLight.position.copy(donut.getWorldPosition(new THREE.Vector3())).add(new THREE.Vector3(0, 0.13, 0));\nscene.add(donutLight);\nconst donutBtn = document.getElementById('lampD');\ndonutBtn.onclick = () => {\n  const on = donutBtn.getAttribute('aria-pressed') !== 'true';\n  donutBtn.setAttribute('aria-pressed', on); donutBtn.classList.toggle('on', on);\n  donutBtn.querySelector('span').textContent = on ? 'Donut-Lampe aus' : 'Donut-Lampe an';\n  DM.koerper.emissiveIntensity = on ? 2.2 : 0;\n  DM.sockel.emissiveIntensity = on ? 0.6 : 0;\n  donutLight.intensity = on ? 2.6 : 0;\n  if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); }\n};\n\n// ---------- Fernseher: an/aus per Fernbedienung ----------\n{\n  const scr = home.getObjectByName('fernseher').getObjectByName('tv_bildschirm');\n  const cv = document.createElement('canvas'); cv.width = 1024; cv.height = 600;\n  const c = cv.getContext('2d');\n  let g = c.createLinearGradient(0, 0, 1024, 600);\n  g.addColorStop(0, '#0b1e3a'); g.addColorStop(0.55, '#1d4f7a'); g.addColorStop(1, '#e08a4a');\n  c.fillStyle = g; c.fillRect(0, 0, 1024, 600);\n  g = c.createRadialGradient(760, 380, 10, 760, 380, 320);\n  g.addColorStop(0, 'rgba(255,210,150,.9)'); g.addColorStop(1, 'rgba(255,210,150,0)');\n  c.fillStyle = g; c.fillRect(0, 0, 1024, 600);\n  c.fillStyle = '#081322'; c.beginPath(); c.moveTo(0, 600); c.lineTo(0, 430); c.lineTo(220, 360); c.lineTo(420, 450); c.lineTo(640, 380); c.lineTo(1024, 470); c.lineTo(1024, 600); c.fill();\n  c.fillStyle = 'rgba(255,255,255,.92)'; c.font = '500 64px Helvetica, Arial, sans-serif'; c.fillText('20:15', 70, 120);\n  c.font = '400 28px Helvetica, Arial, sans-serif'; c.fillStyle = 'rgba(255,255,255,.7)'; c.fillText('Guten Abend', 72, 165);\n  const tex = new THREE.CanvasTexture(cv); tex.colorSpace = THREE.SRGBColorSpace;\n  const M = scr.material;\n  const tvLight = new THREE.PointLight(0x9ab8ff, 0, 3.2, 2);\n  const sb = new THREE.Box3().setFromObject(scr), sc = sb.getCenter(new THREE.Vector3()), ss = sb.getSize(new THREE.Vector3());\n  tvLight.position.copy(sc).add(new THREE.Vector3(0.35, -0.45, 0.6));\n  scene.add(tvLight);\n  const btn = document.getElementById('tvB');\n  let lvl = 0, anim = 0;\n  const apply = () => { M.emissiveIntensity = 1.6 * lvl; tvLight.intensity = 1.4 * lvl; if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); } };\n  const bar = document.getElementById('tvBar'), ui = document.getElementById('tvUI');\n  let saved = null, tvAnim = 0;\n  const tween = (pos, tgt, ms, done) => {\n    const id = ++tvAnim, p0 = cam.position.clone(), q0 = ctl.target.clone(), t0 = performance.now();\n    const ease = t => t < 0.5 ? 4*t*t*t : 1 - Math.pow(-2*t+2, 3)/2;\n    (function step(now){\n      if (id !== tvAnim) return;\n      const t = Math.min(1, (now - t0) / ms), e = ease(t);\n      cam.position.lerpVectors(p0, pos, e); ctl.target.lerpVectors(q0, tgt, e); cam.lookAt(ctl.target);\n      if (t < 1) requestAnimationFrame(step); else done && done();\n    })(t0);\n  };\n  const enter = () => {\n    if (saved) return;\n    saved = { pos: cam.position.clone(), tgt: ctl.target.clone(), en: ctl.enabled };\n    ctl.enabled = false;\n    const th = Math.tan(THREE.MathUtils.degToRad(cam.fov) / 2);\n    const d = Math.max(ss.y / 2 / th, ss.z / 2 / (th * cam.aspect)) * 1.18;\n    document.body.classList.add('tvfocus');\n    tween(new THREE.Vector3(sc.x + d, sc.y - 0.045, sc.z), new THREE.Vector3(sc.x, sc.y - 0.045, sc.z), 1600, () => { bar.classList.add('show'); ui.classList.add('show'); });\n  };\n  const leave = () => {\n    if (!saved) return;\n    const s = saved; saved = null;\n    bar.classList.remove('show'); ui.classList.remove('show'); document.body.classList.remove('tvfocus');\n    tween(s.pos, s.tgt, 1200, () => { ctl.enabled = s.en; });\n  };\n  document.getElementById('tvBack').onclick = leave;\n  document.getElementById('tvOff').onclick = () => { leave(); power(false); };\n  addEventListener('keydown', e => { if (e.key === 'Escape') leave(); });\n  addEventListener('resize', () => { if (saved && bar.classList.contains('show')){ const th = Math.tan(THREE.MathUtils.degToRad(cam.fov) / 2); const d = Math.max(ss.y / 2 / th, ss.z / 2 / (th * cam.aspect)) * 1.18; cam.position.set(sc.x + d, sc.y - 0.045, sc.z); } });\n  const power = on => {\n    btn.setAttribute('aria-pressed', on); btn.classList.toggle('on', on);\n    btn.querySelector('span').textContent = on ? 'Fernbedienung' : 'Fernseher an';\n    if (!on) ui.classList.remove('show');\n    if (on && !M.emissiveMap){ M.emissive = new THREE.Color(0xffffff); M.emissiveMap = tex; M.needsUpdate = true; }\n    const id = ++anim, from = lvl, to = on ? 1 : 0, t0 = performance.now();\n    (function step(now){\n      if (id !== anim) return;\n      const t = Math.min(1, (now - t0) / (on ? 600 : 250));\n      lvl = from + (to - from) * (1 - Math.pow(1 - t, 3)); apply();\n      if (t < 1) requestAnimationFrame(step);\n    })(t0);\n  };\n  btn.onclick = () => { if (btn.getAttribute('aria-pressed') !== 'true') power(true); enter(); };\n  const apps = [['YouTube','#e5484d'],['Netflix','#d6303a'],['Prime Video','#2fa8e0'],['Disney+','#3b6fe0'],['Spotify','#2fbf62'],['ARD Mediathek','#3d7be0'],['ZDF','#f08a24'],['Twitch','#8b5cf6']];\n  const nav = ui.querySelector('.tv-nav'), hero = ui.querySelector('.tv-hero'), vol = ui.querySelector('.tv-vol input'), volO = ui.querySelector('.tv-vol output');\n  let sel = +(localStorage.getItem('wohnung.tv.app') || 0);\n  apps.forEach(([n], i) => { const b = document.createElement('button'); b.textContent = n; b.onclick = () => pick(i); nav.appendChild(b); });\n  function pick(i){\n    sel = (i + apps.length) % apps.length; try { localStorage.setItem('wohnung.tv.app', sel); } catch(e){}\n    const [n, col] = apps[sel];\n    nav.querySelectorAll('button').forEach((b, j) => b.classList.toggle('on', j === sel));\n    const b = nav.children[sel]; nav.scrollTo({ left: b.offsetLeft - nav.clientWidth/2 + b.offsetWidth/2, behavior: 'smooth' });\n    hero.style.setProperty('--a', col); hero.querySelector('h2').textContent = n;\n    draw(); syncP();\n  }\n  let osd = 0, osdT = 0, playing = false, muted = false, preMute = 35;\n  function draw(){\n    const [n, col] = apps[sel], W = 1024, H = 600;\n    c.fillStyle = '#0b0c0e'; c.fillRect(0, 0, W, H);\n    let g = c.createRadialGradient(W*0.85, H*0.2, 10, W*0.85, H*0.2, W*0.75);\n    g.addColorStop(0, col + 'cc'); g.addColorStop(1, col + '00'); c.fillStyle = g; c.fillRect(0, 0, W, H);\n    c.font = '500 24px Helvetica, Arial, sans-serif'; c.textBaseline = 'middle';\n    let x = 48; const y = 58, ph = 46;\n    apps.forEach(([a], i) => { const w = c.measureText(a).width + 40; if (x + w > W - 20) return;\n      c.fillStyle = i === sel ? '#f2f1ec' : 'rgba(255,255,255,.12)'; c.beginPath(); c.roundRect(x, y - ph/2, w, ph, ph/2); c.fill();\n      c.fillStyle = i === sel ? '#111214' : '#f2f1ec'; c.fillText(a, x + 20, y); x += w + 10; });\n    c.textBaseline = 'alphabetic';\n    if (!playing){ c.fillStyle = 'rgba(242,241,236,.7)'; c.font = '500 22px Helvetica, Arial, sans-serif'; c.fillText('ZULETZT GEÖFFNET', 56, 420);\n    c.fillStyle = '#f2f1ec'; c.font = '700 104px Helvetica, Arial, sans-serif'; c.fillText(n, 50, 520, W - 100); }\n    if (playing){ c.fillStyle = 'rgba(0,0,0,.45)'; c.fillRect(0, 0, W, H);\n      c.fillStyle = '#f2f1ec'; c.font = '700 64px Helvetica, Arial, sans-serif'; c.fillText(n, 50, 470, W - 100);\n      c.font = '500 22px Helvetica, Arial, sans-serif'; c.fillStyle = 'rgba(242,241,236,.75)'; c.fillText('Läuft', 52, 512);\n      c.fillStyle = 'rgba(255,255,255,.2)'; c.beginPath(); c.roundRect(52, 545, W - 104, 6, 3); c.fill();\n      c.fillStyle = col; c.beginPath(); c.roundRect(52, 545, (W - 104) * 0.34, 6, 3); c.fill(); }\n    if (osd){ c.fillStyle = 'rgba(255,255,255,.14)'; c.beginPath(); c.roundRect(W - 78, 150, 34, 300, 17); c.fill();\n      const v = +vol.value / 100; c.fillStyle = '#f2f1ec'; c.beginPath(); c.roundRect(W - 72, 156 + 288 * (1 - v), 22, Math.max(22, 288 * v), 11); c.fill();\n      c.font = '500 22px Helvetica, Arial, sans-serif'; c.textAlign = 'center'; c.fillText(vol.value, W - 61, 485); c.textAlign = 'left'; }\n    tex.needsUpdate = true; try { act(); if (ptOn) tracer.updateMaterials(); } catch(e){}\n  }\n  const pApps = document.getElementById('tvpApps'), pVol = document.querySelector('.tvp-vol input'), pVolO = document.querySelector('.tvp-vol output');\n  apps.forEach(([a, col], i) => { const b = document.createElement('button'); b.innerHTML = '<i style=\"background:' + col + '\"><\u002Fi>' + a; b.onclick = () => pick(i); pApps.appendChild(b); });\n  function syncP(){ pApps.querySelectorAll('button').forEach((b, j) => b.classList.toggle('on', j === sel)); document.getElementById('tvpStat').textContent = apps[sel][0]; pVol.value = vol.value; pVolO.textContent = vol.value; const m = document.getElementById('tvpMute'); if (m) m.classList.toggle('on', +vol.value === 0); }\n  const showOsd = () => { osd = 1; clearTimeout(osdT); osdT = setTimeout(() => { osd = 0; draw(); }, 1600); draw(); syncP(); };\n  pVol.oninput = () => { vol.value = pVol.value; setVol(); };\n  document.querySelectorAll('.tvp-vol button').forEach(b => b.onclick = () => { vol.value = Math.max(0, Math.min(100, +vol.value + +b.dataset.d)); setVol(); });\n  document.getElementById('tvpBack').onclick = () => leave();\n  document.getElementById('tvpOff').onclick = () => document.getElementById('tvOff').click();\n  const nudge = d => { vol.value = Math.max(0, Math.min(100, +vol.value + d)); muted = false; setVol(); };\n  const okB = document.getElementById('tvpOk'), muteB = document.getElementById('tvpMute');\n  const setPlay = p => { playing = p; okB.classList.toggle('play', p); okB.textContent = p ? 'II' : 'OK'; draw(); };\n  document.querySelectorAll('.tvp-dpad button').forEach(b => b.onclick = () => { const k = b.dataset.k;\n    if (navigator.vibrate) navigator.vibrate(8);\n    if (k === 'left') { pick(sel - 1); setPlay(false); } else if (k === 'right') { pick(sel + 1); setPlay(false); }\n    else if (k === 'up') nudge(5); else if (k === 'down') nudge(-5); else setPlay(!playing); });\n  muteB.onclick = () => { if (!muted){ preMute = +vol.value || 35; vol.value = 0; muted = true; } else { vol.value = preMute; muted = false; } setVol(); muted = +vol.value === 0 && muted; muteB.classList.toggle('on', muted); };\n  document.getElementById('tvpHome').onclick = () => setPlay(false);\n  pick(sel);\n  vol.value = localStorage.getItem('wohnung.tv.vol') ?? 35;\n  const setVol = () => { volO.textContent = vol.value; vol.style.setProperty('--v', vol.value + '%'); try { localStorage.setItem('wohnung.tv.vol', vol.value); } catch(e){} if (typeof showOsd === 'function') showOsd(); };\n  vol.oninput = setVol; setVol();\n  ui.querySelectorAll('.tv-vb').forEach(b => b.onclick = () => { vol.value = Math.max(0, Math.min(100, +vol.value + +b.dataset.d)); setVol(); });\n  ['pointerdown','wheel','keydown'].forEach(t => ui.addEventListener(t, e => e.stopPropagation()));\n  addEventListener('keydown', e => { if (!ui.classList.contains('show')) return;\n    if (e.key === 'ArrowRight') pick(sel + 1); else if (e.key === 'ArrowLeft') pick(sel - 1);\n    else if (e.key === 'ArrowUp'){ vol.value = Math.min(100, +vol.value + 5); setVol(); } else if (e.key === 'ArrowDown'){ vol.value = Math.max(0, +vol.value - 5); setVol(); } });\n}\n\n// ---------- Tripod-Lampe: an/aus, Farbe, Stärke, Kegel ----------\nconst tripBox = document.getElementById('lamp2'), tripDot = document.querySelector('#tripT i');\nconst TRIP_KEY = 'wohnung-tripod-farbe';\nconst tripColIn = document.getElementById('tripCol'), tripDimIn = document.getElementById('tripDim'), tripConeIn = document.getElementById('tripCone');\nlet tripOn = false, tripLvl = 0, tripAnim = 0, tripK = 1;\nlet tripCol = localStorage.getItem(TRIP_KEY) || '#f2f5ff';\nconst tripSync = () => { if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); } };\nfunction applyTrip(){\n  const v = tripLvl * tripK, c = new THREE.Color(tripCol);\n  trip.spot.color.copy(c); trip.glow.color.copy(c); trip.M.led.emissive.copy(c);\n  trip.M.led.color.set(tripLvl > 0.01 ? 0xffffff : 0xd8dadd);\n  trip.spot.intensity = 12 * v; trip.glow.intensity = 0.35 * v;\n  trip.M.led.emissiveIntensity = 4 * v;\n  tripDot.style.cssText = tripOn ? `background:${tripCol};box-shadow:0 0 10px 3px ${tripCol}99` : '';\n}\ntripDimIn.oninput = () => { tripK = tripDimIn.value/100; tripDimIn.nextElementSibling.textContent = tripDimIn.value + '%'; applyTrip(); tripSync(); };\nmakePicker(tripColIn, TRIP_KEY + '-cfg', { mode: 'white', warm: 5 }, tripDimIn, h => { tripCol = h; try { localStorage.setItem(TRIP_KEY, h); } catch(e){} applyTrip(); tripSync(); });\ntripConeIn.oninput = () => { trip.spot.angle = THREE.MathUtils.degToRad(tripConeIn.value); tripConeIn.nextElementSibling.textContent = tripConeIn.value + '°'; tripSync(); };\ntripConeIn.oninput();\napplyTrip();\ndocument.getElementById('tripT').onclick = () => {\n  tripOn = !tripOn;\n  tripBox.classList.toggle('on', tripOn);\n  tripBox.querySelector('#tripT span').textContent = tripOn ? 'Tripod-Lampe aus' : 'Tripod-Lampe an';\n  const id = ++tripAnim, from = tripLvl, to = tripOn ? 1 : 0, t0 = performance.now();\n  (function step(now){\n    if (id !== tripAnim) return;\n    const t = Math.min(1, (now - t0) / 450);\n    tripLvl = from + (to - from) * (1 - Math.pow(1 - t, 3));\n    applyTrip(); tripSync();\n    if (t < 1) requestAnimationFrame(step);\n  })(t0);\n};\n\n// ---------- Pathtracing (three-gpu-pathtracer): echte Lichtbündel mit Mehrfach-Reflexion, sobald die Kamera stillsteht ----------\n\nconst ptLabel = document.getElementById('pt');\nlet renderOn = false;\n// Sparsamer Standard-Renderer: N8AO (Screen-Space Ambient Occlusion) + Rendern nur bei Aktivität\nlet composer = null, aoPass = null, lastAct = performance.now(), lastInput = lastAct;\nconst act = () => { lastAct = lastInput = performance.now(); };\nfor (const ev of ['pointerdown','pointermove','wheel','keydown','input','click','resize','touchstart']) window.addEventListener(ev, act, true);\nPromise.all([import('three/examples/jsm/postprocessing/EffectComposer.js'), import('three/examples/jsm/postprocessing/RenderPass.js'), import('three/examples/jsm/postprocessing/OutputPass.js'), import('n8ao')]).then(([{EffectComposer},{RenderPass},{OutputPass},{N8AOPass}]) => {\n  const s = renderer.getSize(new THREE.Vector2());\n  composer = new EffectComposer(renderer);\n  aoPass = new N8AOPass(scene, cam, s.x, s.y);\n  Object.assign(aoPass.configuration, { aoRadius: 0.6, distanceFalloff: 0.5, intensity: 2.2, aoSamples: 12, denoiseSamples: 6, denoiseRadius: 10, halfRes: true, gammaCorrection: false });\n  aoPass.setQualityMode && aoPass.setQualityMode('Low');\n  composer.addPass(aoPass); composer.addPass(new OutputPass());\n  act();\n}).catch(e => console.warn('N8AO nicht verfügbar – einfacher Raster', e));\nconst _cs = new THREE.Vector2();\nconst rtBtn = document.getElementById('rt');\nrtBtn.onclick = () => {\n  renderOn = !renderOn;\n  rtBtn.classList.toggle('on', renderOn); rtBtn.setAttribute('aria-pressed', renderOn);\n  rtBtn.querySelector('span').textContent = renderOn ? 'Render an' : 'Render aus';\n  if (!renderOn && ptOn) stopPT();\n  stillSince = performance.now();\n};\nnew Promise(() => {}).then(({ WebGLPathTracer }) => {\n  tracer = new WebGLPathTracer(renderer);\n  tracer.bounces = 4;\n  tracer.renderScale = 0.5;\n  tracer.dynamicLowRes = false;\n  tracer.filterGlossyFactor = 0.5;\n  tracer.tiles.set(4, 4);\n  tracer.minSamples = 2;\n  tracer.fadeDuration = 350;\n  tracer.renderDelay = 0;\n}).catch(e => console.warn('Pathtracer nicht verfügbar – Raster-Fallback', e));\nfunction startPT(){\n  scene.environment = ptEnv; scene.background = ptEnv;\n  scene.environmentIntensity = ENV;\n  renderer.toneMappingExposure = 2.4;\n  if (ptDirty){ tracer.setScene(scene, cam); ptDirty = false; }\n  else { tracer.updateCamera(); tracer.updateMaterials(); tracer.updateLights(); tracer.updateEnvironment(); }\n  tracer.reset();\n  ptOn = true; ptLabel.classList.add('show');\n}\nfunction stopPT(){ ptOn = false; scene.environment = rasterEnv; scene.background = cubeRT.texture; applyInterior(ceilMat.opacity); ptLabel.classList.remove('show'); }\nconst MAX_SAMPLES = 256; let ptFrame = 0;\nlet lastUser = -1e9;\nconst interrupt = () => { stillSince = lastUser = performance.now(); if (ptOn) stopPT(); };\nfor (const ev of ['pointerdown','wheel','keydown']) window.addEventListener(ev, interrupt, true);\nrenderer.domElement.addEventListener('pointerdown', interrupt, true);\nconst lastM = new THREE.Matrix4(); let lastAspect = 0;\nfunction camMoved(){\n  const a = cam.matrixWorld.elements, b = lastM.elements; let d = 0;\n  for (let i = 0; i < 16; i++) d += Math.abs(a[i] - b[i]);\n  const m = d > 1e-5 || cam.aspect !== lastAspect;\n  lastM.copy(cam.matrixWorld); lastAspect = cam.aspect;\n  return m;\n}\nconst loop = () => {\n  ctl.autoRotate = !inRoom && !lampFocus && ctl.enabled && performance.now() - lastUser > 6000;\n  ctl.autoRotateSpeed = 0.4;\n  document.body.classList.toggle('idle', performance.now() - lastInput > 8000);\n  ctl.update(); cam.updateMatrixWorld();\n  const now = performance.now();\n  if (camMoved()){ stillSince = now; lastAct = now; if (ptOn) stopPT(); }\n  if (tracer && renderOn && !ptOn && now - stillSince > 350 && (ceilMat.opacity >= 0.999 || ceilMat.opacity <= 0.001)){\n    try { startPT(); } catch(e){ console.warn('Pathtracer-Fehler: ' + (e && e.message), e); tracer = null; ptOn = false; scene.environment = rasterEnv; scene.background = cubeRT.texture; ptLabel.classList.remove('show'); }\n  }\n  if (ptOn && tracer.samples >= MAX_SAMPLES){ ptLabel.textContent = 'Raytracing · fertig'; return; }\n  if (ptOn){ ptFrame ^= 1; if (ptFrame) tracer.renderSample(); ptLabel.textContent = 'Raytracing · ' + Math.floor(tracer.samples) + ' Samples'; }\n  else if (now - lastAct < 1500) {\n    if (composer){ renderer.getSize(_cs); if (composer._w !== _cs.x || composer._h !== _cs.y){ composer.setSize(_cs.x, _cs.y); composer._w = _cs.x; composer._h = _cs.y; } composer.render(); }\n    else renderer.render(scene, cam);\n  }\n};\nstage._loop = loop;\nrenderer.setAnimationLoop(loop);\n// Beim Größenwechsel (Menü-Animation) sofort neu zeichnen → kein heller Blitz\nnew ResizeObserver(() => { const n = performance.now(); lastAct = n; stillSince = n; if (ptOn) stopPT(); loop(); }).observe(stage);\n\n// ---------- Raum-Navigation ----------\nconst cam = stage._camera, ctl = stage._controls;\nlet lampFocus = false;\ncam.position.sub(ctl.target).multiplyScalar(0.6).add(ctl.target);\nconst overview = { pos: cam.position.clone(), tgt: ctl.target.clone() };\nconst EYE = 1.6;\n// Standpunkt in der Raummitte, Blick in Richtung (dx,dz); Target minimal vor der Kamera → Umsehen statt Umkreisen\nconst spot = (x, z, dx, dz, y = EYE) => {\n  const d = new THREE.Vector3(dx, -0.12, dz).normalize().multiplyScalar(0.05);\n  const pos = new THREE.Vector3(x, y, z);\n  return { pos, tgt: pos.clone().add(d), fp: true };\n};\n// Vogelperspektive: senkrecht über dem Raum, leicht geneigt, Decke ausgeblendet – ganzer Raum im Bild\nconst bird = (x0,z0,x1,z1) => {\n  const cx = (x0+x1)/2, cz = (z0+z1)/2, w = Math.abs(x1-x0), d = Math.abs(z1-z0);\n  const fov = (cam.fov || 50) * Math.PI/180, asp = Math.max(0.35, (stage.clientWidth||1)/(stage.clientHeight||1));\n  const need = Math.max(d, w/asp) * 0.5 * 1.25;            // halbe Ausdehnung + Rand\n  const hgt = need / Math.tan(fov/2) + 1.0;\n  return { pos: new THREE.Vector3(cx, hgt, cz + hgt*0.22), tgt: new THREE.Vector3(cx, 0.3, cz), fp: false };\n};\nconst room = ([x0,z0,x1,z1], dx, dz) => ({ fp: spot((x0+x1)/2, (z0+z1)/2, dx, dz), bird: bird(x0, z0, x1, z1) });\nconst ROOMS = [\n  ['Übersicht', overview],\n  ['Wohnzimmer', room(RM_WZ, 1, 0.4)],\n  ['Küche', room(RM_KU, 1, -0.3)],\n  ['Schlafzimmer', room(RM_SZ, -0.3, 1)],\n  ['Bad', room(RM_BAD, 0, -1)],\n  ['Flur', room(RM_FL, -1, 0)],\n  ['Balkon', room([BX0, BZ0, BX1, BZ1], 0, -1)],\n];\nlet anim = 0;\nfunction flyTo(view){\n  const id = ++anim;\n  const p0 = cam.position.clone(), t0 = ctl.target.clone();\n  const c0 = ceilMat.opacity, c1 = view.fp ? 1 : 0;\n  inRoom = !!view.fp;\n  const clamp01 = x => Math.max(0, Math.min(1, x));\n  const dist = p0.distanceTo(view.pos);\n  const dur = Math.min(2200, 1100 + dist*90);\n  const lift = Math.min(3, dist*0.25);\n  const start = performance.now();\n  ctl.enabled = false;\n  ctl.enableZoom = ctl.enablePan = !view.fp;\n  ctl.rotateSpeed = view.fp ? -0.35 : 1;\n  ctl.minDistance = 0;\n  const ease = t => t < 0.5 ? 4*t*t*t : 1 - Math.pow(-2*t+2, 3)/2;\n  (function step(now){\n    if (id !== anim) return;\n    const t = Math.min(1, (now - start)/dur), e = ease(t);\n    cam.position.lerpVectors(p0, view.pos, e);\n    cam.position.y += Math.sin(Math.PI*e) * lift;\n    ctl.target.lerpVectors(t0, view.tgt, e);\n    cam.lookAt(ctl.target);\n    // Einblenden erst am Ende der Anflugs (Kamera schon unter Deckenhöhe), Ausblenden sofort\n    const k = c1 > c0 ? clamp01((e - 0.6) / 0.4) : clamp01(e / 0.3);\n    setCeil(c0 + (c1 - c0) * k);\n    if (t < 1) requestAnimationFrame(step); else ctl.enabled = true;\n  })(start);\n}\nconst bar = document.getElementById('rooms');\nconst povBar = document.getElementById('pov');\nlet curView = overview, povMode = 'bird';\nconst show = () => flyTo(curView.bird ? curView[povMode] : curView);\nROOMS.forEach(([label, view], i) => {\n  const b = document.createElement('button');\n  b.textContent = label;\n  if (i === 0) b.classList.add('on');\n  b.onclick = () => {\n    bar.querySelectorAll('button').forEach(x => x.classList.toggle('on', x === b));\n    lampBtn.classList.toggle('show', label === 'Wohnzimmer');\n    tripBox.classList.toggle('show', label === 'Schlafzimmer');\n    povBar.classList.toggle('show', !!view.bird);\n    curView = view; povMode = 'bird';\n    povBar.querySelectorAll('button').forEach(x => x.classList.toggle('on', x.dataset.m === povMode));\n    show();\n  };\n  bar.appendChild(b);\n});\n// Lampe konfigurieren → Kamera fliegt an die Lampe, Drehen stoppt; beim Schließen zurück\nconst LAMP_FOCUS = { [LAMP_KEY + '-cfg']: [bp.clone(), 1], [TRIP_KEY + '-cfg']: [trip.spot.getWorldPosition(new THREE.Vector3()), 3] };\naddEventListener('lpick', e => {\n  const f = LAMP_FOCUS[e.detail.key]; if (!f) return;\n  if (e.detail.open){\n    lampFocus = true;\n    const p = f[0], c = ROOMS[f[1]][1].fp.pos, dir = new THREE.Vector3(c.x - p.x, 0, c.z - p.z);\n    const dist = Math.min(1.8, dir.length() * 0.85); dir.normalize();\n    // Handy: Lampe mittig im oberen Bildteil, Menü-Sheet unten\n    const pos = p.clone().addScaledVector(dir, dist * 1.4).add(new THREE.Vector3(0, -0.3, 0));\n    flyTo({ pos, tgt: p.clone().add(new THREE.Vector3(0, -0.35, 0)), fp: false });\n  } else { lampFocus = false; show(); }\n});\npovBar.addEventListener('click', e => {\n  const b = e.target.closest('button'); if (!b || b.dataset.m === povMode) return;\n  povMode = b.dataset.m;\n  povBar.querySelectorAll('button').forEach(x => x.classList.toggle('on', x === b));\n  show();\n});\n\n// ---------- Poly Haven Texturen ----------\nasync function polyHaven(assetName, res){\n  const all = await (await fetch('https://api.polyhaven.com/assets?t=textures')).json();\n  const want = assetName.toLowerCase();\n  const id = (all[want] ? want : null) || Object.keys(all).find(k => (all[k].name||'').toLowerCase() === want)\n          || Object.keys(all).find(k => (all[k].name||'').toLowerCase().includes(want))\n          || want.replace(/\\s+/g,'_');\n  const files = await (await fetch(`https://api.polyhaven.com/files/${id}`)).json();\n  const pick = key => files[key]?.['1k']?.jpg?.url || files[key]?.['1k']?.png?.url;\n  const dim = all[id]?.dimensions; // mm [w,h]\n  return { id, dim, diff: pick('Diffuse'), nor: pick('nor_gl'), rough: pick('Rough') };\n}\nconst loader = new THREE.TextureLoader();\nloader.setCrossOrigin('anonymous');\nconst loadTex = (url, srgb) => new Promise((res, rej) => loader.load(url, t => {\n  t.wrapS = t.wrapT = THREE.RepeatWrapping;\n  if (srgb) t.colorSpace = THREE.SRGBColorSpace;\n  t.anisotropy = 8; res(t);\n}, undefined, rej));\nasync function apply(mat, assetName, uvScale, res){\n  const f = await polyHaven(assetName, res);\n  const [map, normalMap, roughnessMap] = await Promise.all([\n    loadTex(f.diff, true), f.nor ? loadTex(f.nor) : null, f.rough ? loadTex(f.rough) : null\n  ]);\n  if (uvScale){ // echte Größe: UVs sind in 1/uvScale m, Textur deckt dim mm ab\n    const w = (f.dim?.[0] || 2000) / 1000, hh = (f.dim?.[1] || f.dim?.[0] || 2000) / 1000;\n    for (const t of [map, normalMap, roughnessMap]) if (t) t.repeat.set(uvScale / w, uvScale / hh);\n  }\n  mat.map = map; mat.color.set(0xffffff);\n  if (normalMap) mat.normalMap = normalMap;\n  if (roughnessMap) { mat.roughnessMap = roughnessMap; mat.roughness = 1; }\n  mat.needsUpdate = true;\n  ptDirty = true; if (ptOn) stopPT();\n  return f.id;\n}\n// ---------- Tageszeit: prozeduraler Himmel (three.js Sky, Preetham-Modell) ----------\nconst { Sky } = await import('three/addons/objects/Sky.js');\nconst sky = new Sky(); sky.scale.setScalar(1000);\nconst skyScene = new THREE.Scene(); skyScene.add(sky);\nconst SU = sky.material.uniforms;\nSU.mieCoefficient.value = 0.005; SU.mieDirectionalG.value = 0.8;\n// Nacht-/Dämmerungs-Minimum: dunkles Blau, zum Horizont heller\nsky.material.uniforms.nightFloor = { value: new THREE.Color(0,0,0) };\nsky.material.fragmentShader = 'uniform vec3 nightFloor;\\n' + sky.material.fragmentShader.replace('#include <tonemapping_fragment>',\n  'float hzF = 1.0 - clamp(normalize(vWorldPosition - cameraPosition).y, 0.0, 1.0);\\n gl_FragColor.rgb = max(gl_FragColor.rgb, nightFloor * (0.55 + 0.9*hzF*hzF));\\n#include <tonemapping_fragment>');\nsky.material.needsUpdate = true;\nconst cubeRT = new THREE.WebGLCubeRenderTarget(512, { type: THREE.HalfFloatType });\nconst cubeCam = new THREE.CubeCamera(1, 5000, cubeRT); skyScene.add(cubeCam);\nconst pmrem = new THREE.PMREMGenerator(renderer);\nlet envRT = null;\nconst keyBase = key.intensity, hemiCol0 = hemi ? hemi.color.clone() : null, hemiGnd0 = hemi ? hemi.groundColor.clone() : null;\nconst SS = THREE.MathUtils.smoothstep, col = (r,g,b) => new THREE.Color(r,g,b);\nfunction makePTEnv(d, day, golden){\n  const w = 256, h = 128, arr = new Float32Array(w*h*4);\n  const zen = col(.03,.045,.1).lerp(col(.16,.32,.75), day);\n  const hor = col(.05,.07,.13).lerp(col(.75,.82,.92).lerp(col(1,.55,.3), golden*.8), day);\n  const gnd = hor.clone().multiplyScalar(.25);\n  const sunC = col(1,.95,.85).lerp(col(1,.5,.2), golden).multiplyScalar(40*day);\n  for (let j = 0; j < h; j++){\n    const el = ((j+.5)/h - .5)*Math.PI, sy = Math.sin(el), cy = Math.cos(el);\n    for (let i = 0; i < w; i++){\n      const az = ((i+.5)/w - .5)*2*Math.PI, x = Math.cos(az)*cy, z = Math.sin(az)*cy;\n      let r, g, bb;\n      if (sy >= 0){ const t = Math.sqrt(sy); r = hor.r+(zen.r-hor.r)*t; g = hor.g+(zen.g-hor.g)*t; bb = hor.b+(zen.b-hor.b)*t; }\n      else { const t = Math.min(1, -sy*4); r = hor.r+(gnd.r-hor.r)*t; g = hor.g+(gnd.g-hor.g)*t; bb = hor.b+(gnd.b-hor.b)*t; }\n      const dot = x*d.x + sy*d.y + z*d.z;\n      if (dot > 0){ const gl = Math.pow(dot, 48)*day*(1+golden); r += gl; g += gl*(.85-.3*golden); bb += gl*(.7-.45*golden); }\n      if (dot > .999 && sy > -0.02){ r = sunC.r; g = sunC.g; bb = sunC.b; }\n      const k = (j*w + i)*4; arr[k] = r; arr[k+1] = g; arr[k+2] = bb; arr[k+3] = 1;\n    }\n  }\n  const dt = new THREE.DataTexture(arr, w, h, THREE.RGBAFormat, THREE.FloatType);\n  dt.mapping = THREE.EquirectangularReflectionMapping;\n  dt.minFilter = dt.magFilter = THREE.LinearFilter; dt.generateMipmaps = false; dt.needsUpdate = true;\n  return dt;\n}\nconst sunV = new THREE.Vector3();\nfunction setTime(hr){\n  // Sonnenbahn (vereinfacht): 7 Uhr Ost (+x) → 13 Uhr Süd (+z) → 19 Uhr West, max. 50° Höhe\n  const phi = Math.PI*(hr - 7)/12, e = THREE.MathUtils.degToRad(50)*Math.sin(phi);\n  sunV.set(Math.cos(phi)*Math.cos(e), Math.sin(e), Math.sin(phi)*Math.cos(e)).normalize();\n  const s = sunV.y, day = SS(s, -0.14, 0.18), golden = 1 - SS(s, 0, 0.4), dusk = SS(s, -0.22, -0.02) * (1 - SS(s, 0.02, 0.2));\n  SU.sunPosition.value.copy(sunV);\n  SU.rayleigh.value = 2.5 + 1.2*golden;\n  SU.turbidity.value = 3 + 5*golden;\n  // Nachtblau, zur blauen Stunde etwas heller/violetter\n  SU.nightFloor.value.setRGB(0.010 + 0.03*dusk, 0.016 + 0.03*dusk, 0.045 + 0.06*dusk);\n  cubeCam.update(renderer, skyScene);\n  envRT = pmrem.fromCubemap(cubeRT.texture, envRT);\n  rasterEnv = envRT.texture;\n  if (s > -0.03){\n    key.position.copy(hc).addScaledVector(sunV, 30);\n    key.color.set(0xff9a52).lerp(new THREE.Color(0xfff3e2), SS(s, 0, 0.5));\n    key.intensity = keyBase * 1.3 * Math.max(day, 0.15);\n  } else { // Mondlicht, gegenüber der Sonne\n    const m = new THREE.Vector3(-sunV.x, Math.abs(sunV.y)*0.8 + 0.2, -sunV.z).normalize();\n    key.position.copy(hc).addScaledVector(m, 30);\n    key.color.set(0x9fb4ff); key.intensity = keyBase * 0.25;\n  }\n  envK = 0.2 + 0.1*day + 0.15*dusk; hemiK = 0.3 + 0.4*day; fillK = 0.1 + 0.5*day; expK = 1 - 0.45*day;\n  if (hemi){ hemi.color.copy(hemiCol0).lerp(new THREE.Color(0x34426e), 1 - day); hemi.groundColor.copy(hemiGnd0).multiplyScalar(0.3 + 0.7*day); }\n  ptEnv = makePTEnv(sunV, day, golden);\n  scene.background = cubeRT.texture;\n  scene.backgroundIntensity = 0.2 + 1.1*(1 - day);\n  if (ptOn) stopPT(); else { scene.environment = rasterEnv; applyInterior(ceilMat.opacity); }\n  act();\n}\n// Himmel & Licht folgen der echten Uhrzeit\nconst nowH = () => { const n = new Date(); return n.getHours() + n.getMinutes()/60; };\nsetTime(nowH());\nsetInterval(() => setTime(nowH()), 60000);\nlet texMsg = 'Texturen werden geladen…';\nconst upd = () => statusEl.textContent = texMsg;\nupd();\nsofa.M.fabric.color.set('#3a3a3c');\napply(sofa.M.fabric, 'Poly Wool Herringbone').then(() => sofa.M.fabric.color.set('#3a3a3c')).catch(e => console.warn(e));\nPromise.all([apply(M.floor, 'wood_floor', 1.0), apply(M.wall, 'White Stucco'), apply(M.brick, 'Brick Wall 04', 1.5), apply(M.cap, 'Rough Plaster Brick 04', 1.5), apply(tileMat, 'interior_tiles', 1.0, '2k').then(id => {\n    // nur Relief/Glanz behalten, Farbe weiß; Raster achsparallel drehen, Fliesen halb so groß\n    tileMat.map = null; tileMat.color.set(0xf3f2ee);\n    // Textur: Rautenraster, 3 Fliesen je Kachel → 45° gedreht achsparallel; 15-cm-Fliesen, Fugen auf 0,90 / 1,50 m\n    const TILE = 0.15, rep = 1 / (3 * Math.SQRT2 * TILE);\n    for (const t of [tileMat.normalMap, tileMat.roughnessMap]) if (t){ t.center.set(0, 0); t.offset.set(0, 0); t.rotation = Math.PI/4; t.repeat.set(rep, rep); }\n    tileMat.needsUpdate = true; return id;\n  })])\n  .then(ids => { texMsg = 'Texturen: ' + ids.join(', '); upd(); })\n  .catch(e => { console.warn(e); texMsg = 'Texturen nicht erreichbar – Farb-Fallback'; upd(); });\n\n// ---------- Fernbedienung ----------\n{\n  const $ = s => document.querySelector(s);\n  const keys = [];\n  [1,2,3,4,5,6,0].forEach(i => {\n    const b = document.createElement('button');\n    b.className = 'r-key' + (i === 0 ? ' wide' : ''); b.textContent = ROOMS[i][0];\n    b.onclick = () => { bar.children[i].click(); sync(); };\n    keys.push([i, b]); $('#rRooms').appendChild(b);\n  });\n  const LAMPS = {\n    bogen: { on: () => lampOn, t: () => $('#lampT').click(), col: () => lampCol, sw: colIn },\n    donut: { on: () => donutBtn.getAttribute('aria-pressed') === 'true', t: () => donutBtn.click(), col: () => '#ff9a3c' },\n    trip:  { on: () => tripOn, t: () => $('#tripT').click(), col: () => tripCol, sw: tripColIn },\n  };\n  let msg = '';\n  document.querySelectorAll('.r-lamp').forEach(row => {\n    const L = LAMPS[row.dataset.l];\n    row.querySelector('.r-tog').onclick = () => { msg = ''; L.t(); sync(); };\n    const c = row.querySelector('.r-col'); if (c) c.onclick = e => { e.stopPropagation(); L.sw.click(); };\n  });\n  const setAll = on => { Object.values(LAMPS).forEach(L => { if (L.on() !== on) L.t(); }); };\n  const closePick = () => document.querySelectorAll('.lpick.open').forEach(p => p.querySelector('.lp-done').click());\n  $('#rAllOn').onclick = () => { msg = ''; setAll(true); sync(); };\n  $('#rAllOff').onclick = () => { msg = ''; closePick(); setAll(false); sync(); };\n  $('#rPower').onclick = () => { closePick(); setAll(false); bar.children[0].click(); msg = 'Tschüss – alles aus'; sync(); };\n  function sync(){\n    const cur = [...bar.children].findIndex(b => b.classList.contains('on'));\n    keys.forEach(([i, b]) => b.classList.toggle('on', i === cur));\n    let n = 0, shown = 0;\n    document.querySelectorAll('.r-lamp').forEach(row => {\n      const L = LAMPS[row.dataset.l], on = L.on(), c = L.col(); if (on) n++;\n      row.classList.toggle('on', on);\n      const vis = +row.dataset.room === cur; row.style.display = vis ? '' : 'none'; if (vis) shown++;\n      row.querySelector('i').style.cssText = on ? 'background:' + c + ';box-shadow:0 0 10px 3px ' + c + '99' : '';\n      const cb = row.querySelector('.r-col'); if (cb) cb.style.setProperty('--c', c);\n    });\n    $('#rLightsLbl').style.display = $('#rLights').style.display = shown ? '' : 'none';\n    const tv = cur === 1; $('#rTvLbl').style.display = $('#rTv').style.display = tv ? '' : 'none';\n    $('#rTv').classList.toggle('on', $('#tvB').getAttribute('aria-pressed') === 'true');\n    if (n) msg = '';\n    $('#rStat').textContent = msg || (n ? n + (n === 1 ? ' Licht an' : ' Lichter an') : 'Alle Lichter aus');\n  }\n  const tvB = $('#tvB'), tvOn = () => tvB.getAttribute('aria-pressed') === 'true';\n  $('#rTvPow').onclick = () => { if (tvOn()) $('#tvOff').click(); else tvB.click(); setTimeout(sync, 0); };\n  $('#rTvOpen').onclick = () => { tvB.click(); setTimeout(sync, 0); };\n  addEventListener('pointerup', () => setTimeout(sync, 0));\n  addEventListener('input', sync);\n  addEventListener('lpick', () => setTimeout(sync, 0));\n  sync();\n}\n<\u002Fscript>\n\n\n<\u002Fbody><\u002Fhtml>"
  </script>
</body>
</html>";
+  var D = "<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <title>Wohnung – 3D Miniatur</title>
  <style>
    * { margin: 0; padding: 0; box-sizing: border-box; }
    body { background: #1b1b19; display: flex; align-items: center; justify-content: center; min-height: 100vh; font-family: -apple-system, BlinkMacSystemFont, sans-serif; }
    #__bundler_loading { position: fixed; bottom: 20px; right: 20px; font: 13px/1.4 -apple-system, BlinkMacSystemFont, sans-serif; color: #666; background: #fff; padding: 8px 14px; border-radius: 8px; box-shadow: 0 1px 4px rgba(0,0,0,0.12); z-index: 10000; }
    #__bundler_thumbnail { position: fixed; inset: 0; width: 100%; height: 100%; display: flex; align-items: center; justify-content: center; background: #1b1b19; z-index: 9999; }
    #__bundler_thumbnail svg { width: 100%; height: 100%; object-fit: contain; }
    #__bundler_placeholder { color: #999; font-size: 14px; }
  </style>
  <noscript>
    <style>#__bundler_loading { display: none; }</style>
    <div style="position:fixed;bottom:12px;left:12px;font:13px/1.4 -apple-system,BlinkMacSystemFont,sans-serif;color:#999;background:rgba(255,255,255,0.9);padding:6px 12px;border-radius:6px;box-shadow:0 1px 4px rgba(0,0,0,0.08);z-index:10000;">
      This page requires JavaScript to display.
    </div>
  </noscript>
</head>
<body>
  <div id="__bundler_thumbnail"><svg viewBox="0 0 120 120" xmlns="http://www.w3.org/2000/svg"><rect width="120" height="120" fill="#1b1b19"></rect><rect x="46" y="26" width="28" height="68" rx="10" fill="none" stroke="#e9e6de" stroke-width="4"></rect><circle cx="60" cy="42" r="5" fill="#e5484d"></circle><circle cx="60" cy="62" r="7" fill="none" stroke="#e9e6de" stroke-width="4"></circle></svg></div>
  <div id="__bundler_loading">Unpacking...</div>

  <script>
    
document.addEventListener('DOMContentLoaded', async function() {
  const loading = document.getElementById('__bundler_loading');
  function setStatus(msg) { if (loading) loading.textContent = msg; }

  const FONT_MIME = /^(font[/]|application[/](x-)?font-|application[/]vnd\.ms-fontobject)/i;
  const MIME_TOKEN = /^[\w.+-]+[/][\w.+-]+$/;
  function toBase64(bytes) {
    let bin = '';
    for (let i = 0; i < bytes.length; i += 0x8000) {
      bin += String.fromCharCode.apply(null, bytes.subarray(i, i + 0x8000));
    }
    return btoa(bin);
  }

  // Error sink persists across replaceWith since it's on window, not the DOM.
  window.addEventListener('error', function(e) {
    // Failed resource loads (CSP-blocked links, scripts, images) fire plain
    // events at the element — warn only; real JS errors carry message/error.
    if (!e.message && !e.error && e.target && e.target !== window) {
      console.warn('[bundle] resource failed to load:',
        e.target.tagName, String(e.target.src || e.target.href || ''));
      return;
    }
    var p = document.body || document.documentElement;
    var d = document.getElementById('__bundler_err') || p.appendChild(document.createElement('div'));
    d.id = '__bundler_err';
    d.style.cssText = 'position:fixed;bottom:12px;left:12px;right:12px;font:12px/1.4 ui-monospace,monospace;background:#2a1215;color:#ff8a80;padding:10px 14px;border-radius:8px;border:1px solid #5c2b2e;z-index:99999;white-space:pre-wrap;max-height:40vh;overflow:auto';
    d.textContent = (d.textContent ? d.textContent + String.fromCharCode(10) : '') +
      '[bundle] ' + (e.message || e.type) +
      (e.filename ? ' (' + e.filename.slice(0, 60) + ':' + e.lineno + ')' : '');
  }, true);

  try {
    const manifestEl = document.querySelector('script[type="__bundler/manifest"]');
    const templateEl = document.querySelector('script[type="__bundler/template"]');
    if (!manifestEl || !templateEl) {
      setStatus('Error: missing bundle data');
      console.error('[bundler] Missing script tags — manifestEl:', !!manifestEl, 'templateEl:', !!templateEl);
      return;
    }

    const manifest = JSON.parse(manifestEl.textContent);
    let template = JSON.parse(templateEl.textContent);

    // Nested page bundles (iframe targets). Each ships ONCE, in the ROOT
    // document's manifest; frame srcs carry an about:blank#<uuid> marker
    // instead of a substitutable uuid. Every document mints the blobs for
    // its OWN frames — from local text at the root, or text obtained from
    // its DIRECT parent over the relay protocol below — so each frame
    // navigation stays same-origin with its initiator and a deduped page
    // loads at any depth on any host, including a file:// download's
    // opaque origins (where a blob minted by one document cannot be
    // navigated to by another).
    const pageOrderEl = document.querySelector('script[type="__bundler/page_order"]');
    const pageOrder = pageOrderEl ? JSON.parse(pageOrderEl.textContent) : [];
    const pageSet = new Set(pageOrder);
    const pageTexts = {};

    // ── Nested-page text protocol (parent-chain relay) ──
    // Page bundles ship once, in the ROOT document's manifest. Every
    // document mints the blobs for its OWN frames, obtaining page text
    // through a strict parent-chain relay: a document only ever SENDS to
    // its direct parent (which, for every document the publisher's own
    // runtime minted, is another publisher document) and only ACCEPTS
    // text from that direct parent; requests from below are honored only
    // for the document's own child frames, and the ROOT never sends
    // upward at all. That last rule is load-bearing: the artifact host's
    // frame-ancestors allows claude.ai (and friends) to frame an
    // artifact, so window.top can be a FOREIGN document — a top-addressed
    // protocol would hand page uuids to that ancestor and accept forged
    // "page text" from it, minting attacker HTML as an artifact-origin
    // blob document. The chain never touches the ancestor: requests stop
    // at the root, replies are origin-addressed per hop (never '*' when
    // an origin exists), and both directions are origin-gated (on https
    // a foreign sender's origin can never equal this document's; in
    // opaque contexts — file:// — everything serializes as 'null', where
    // an embedded EXTERNAL frame still fails the gate by carrying its
    // own real origin, and a sandboxed child of such a frame is excluded
    // by the own-child-frames check plus uuid unguessability). Shape is
    // deny-by-default: one request form, one reply form, no error
    // replies.
    // window.origin is the SERIALIZED SECURITY origin ('null' in opaque
    // contexts such as a sandboxed preview iframe) — location.origin is
    // computed from the URL and stays 'https://…' even when the document
    // is sandboxed, which would misgate every opaque chain.
    const OWN_TARGET = /^https?:[/][/]/.test(window.origin || '')
      ? window.origin
      : '*';
    function trustedOrigin(e) {
      if (e.origin === window.origin) return true; // https chains; opaque==opaque
      // file:// trees: Chrome serializes the file document's origin as
      // 'file://' while the blob: documents it mints serialize as 'null',
      // so the two legitimate shapes can never string-match — accept the
      // pair in both directions. https origins never serialize as either,
      // and sender identity (own child frame / direct parent) is checked
      // separately.
      return (
        (e.origin === 'null' &&
          (window.origin === 'file://' ||
            window.location.protocol === 'file:')) ||
        (/^file:/.test(e.origin) && window.origin === 'null')
      );
    }
    // Non-empty only in the root document (nested bundles ship an empty
    // island), so it doubles as the root marker: the root answers from
    // local text and treats a miss as authoritative — never relaying to
    // its (possibly foreign) parent.
    const isPageRoot = pageOrder.length > 0;
    const blobUrls = {};
    const resourceBlobs = {};
    const UUID_SHAPE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
    const pendingFrames = {}; // uuid -> [{el, frag}] awaiting text for own frames
    const pendingRelays = {}; // uuid -> [childWindow] awaiting text to pass down
    function mountPage(el, frag, text) {
      const pageBlob = new Blob([text], { type: 'text/html' });
      const u = URL.createObjectURL(pageBlob);
      resourceBlobs[u] = pageBlob;
      el.src = u + frag;
    }
    function deliverPage(uuid, text) {
      const frames = pendingFrames[uuid];
      delete pendingFrames[uuid];
      if (frames) for (const f of frames) mountPage(f.el, f.frag, text);
      const relays = pendingRelays[uuid];
      delete pendingRelays[uuid];
      if (relays) {
        for (const cw of relays) {
          try { cw.postMessage({ __bundler_page: uuid, __bundler_text: text }, OWN_TARGET); } catch (err) { /* gone */ }
        }
      }
    }
    function ownFrameWindows() {
      const out = [];
      for (const f of Array.from(document.querySelectorAll('iframe'))) {
        try { if (f.contentWindow) out.push(f.contentWindow); } catch (err) { /* detached */ }
      }
      return out;
    }
    window.addEventListener('message', function (e) {
      const d = e.data;
      if (!d || typeof d !== 'object' || !e.source) return;
      // Origin gate first; the structural checks below (own-child-frames
      // for requests, direct-parent + solicited-uuid for replies, the
      // root's never-relay rule) are what hold in fully opaque chains
      // where origin strings can't discriminate — a sandboxed root's
      // FOREIGN wrapper still fails all three even though both serialize
      // as real-vs-'null' rather than matching.
      if (!trustedOrigin(e)) return;
      if (typeof d.__bundler_need === 'string' && UUID_SHAPE.test(d.__bundler_need)) {
        // Requests are honored only for this document's own child frames.
        if (ownFrameWindows().indexOf(e.source) < 0) return;
        const uuid = d.__bundler_need;
        const text = pageTexts[uuid];
        if (typeof text === 'string') {
          try { e.source.postMessage({ __bundler_page: uuid, __bundler_text: text }, OWN_TARGET); } catch (err) { /* gone */ }
          return;
        }
        if (isPageRoot || window.parent === window) return; // authoritative miss
        const waiting = pendingRelays[uuid];
        if (waiting) {
          if (waiting.indexOf(e.source) < 0) waiting.push(e.source);
          return;
        }
        // Never-answered uuids would otherwise accumulate forever under a
        // request spray; past the cap (far above any real page count) new
        // relays are dropped rather than remembered.
        if (Object.keys(pendingRelays).length >= 128) return;
        pendingRelays[uuid] = [e.source];
        window.parent.postMessage({ __bundler_need: uuid }, OWN_TARGET);
      } else if (
        typeof d.__bundler_page === 'string' &&
        UUID_SHAPE.test(d.__bundler_page) &&
        typeof d.__bundler_text === 'string'
      ) {
        // The shape test is load-bearing beyond tidiness: the solicited
        // check below uses the in operator, which matches prototype keys
        // ('__proto__', 'constructor') — an unshaped key would reach
        // deliverPage and throw, painting the error banner.
        // Text is accepted only from the direct parent — the document
        // that minted this one.
        if (e.source !== window.parent || window.parent === window) return;
        if (!(d.__bundler_page in pendingFrames) && !(d.__bundler_page in pendingRelays)) return;
        deliverPage(d.__bundler_page, d.__bundler_text);
      }
    });

    const uuids = Object.keys(manifest);
    setStatus('Unpacking ' + uuids.length + ' assets...');

    await Promise.all(uuids.map(async (uuid) => {
      const entry = manifest[uuid];
      try {
        const binaryStr = atob(entry.data);
        const bytes = new Uint8Array(binaryStr.length);
        for (let i = 0; i < binaryStr.length; i++) bytes[i] = binaryStr.charCodeAt(i);

        let finalBytes = bytes;
        if (entry.compressed) {
          if (typeof DecompressionStream !== 'undefined') {
            const ds = new DecompressionStream('gzip');
            const writer = ds.writable.getWriter();
            const reader = ds.readable.getReader();
            writer.write(bytes);
            writer.close();
            const chunks = [];
            let totalLen = 0;
            while (true) {
              const { done, value } = await reader.read();
              if (done) break;
              chunks.push(value);
              totalLen += value.length;
            }
            finalBytes = new Uint8Array(totalLen);
            let offset = 0;
            for (const chunk of chunks) { finalBytes.set(chunk, offset); offset += chunk.length; }
          } else {
            console.warn('DecompressionStream not available, asset ' + uuid + ' may not render');
          }
        }

        if (pageSet.has(uuid)) {
          pageTexts[uuid] = new TextDecoder().decode(finalBytes);
          return;
        }
        if (FONT_MIME.test(entry.mime) && MIME_TOKEN.test(entry.mime)) {
          // Strict artifact hosts allow font-src data: but not blob:.
          blobUrls[uuid] = 'data:' + entry.mime + ';base64,' +
            (entry.compressed ? toBase64(finalBytes) : entry.data);
        } else {
          const blob = new Blob([finalBytes], { type: entry.mime });
          blobUrls[uuid] = URL.createObjectURL(blob);
          resourceBlobs[blobUrls[uuid]] = blob;
        }
      } catch (err) {
        console.error('Failed to decode asset ' + uuid + ':', err);
        const blob = new Blob([], { type: entry.mime });
        blobUrls[uuid] = URL.createObjectURL(blob);
        resourceBlobs[blobUrls[uuid]] = blob;
      }
    }));

    const extResEl = document.querySelector('script[type="__bundler/ext_resources"]');
    const extResources = extResEl ? JSON.parse(extResEl.textContent) : [];
    const resourceMap = {};
    for (const entry of extResources) {
      if (blobUrls[entry.uuid]) resourceMap[entry.id] = blobUrls[entry.uuid];
    }

    // Artifact-host CSP (connect-src 'self') refuses fetch() of blob: URLs —
    // consumers read these Blobs directly. Survives the swap like the error sink.
    window.__resourceBlobs = resourceBlobs;

    setStatus('Rendering...');
    // Page uuids have no blob here — they ride inside about:blank#<uuid>
    // frame markers the pass below resolves after the swap.
    for (const uuid of uuids) {
      if (pageSet.has(uuid)) continue;
      template = template.split(uuid).join(blobUrls[uuid]);
    }

    // Strip integrity + crossorigin — blob URLs from a file:// document inherit
    // a null origin, so crossorigin forces a CORS fetch that SRI then rejects.
    // The manifest bytes are ours; SRI protects against CDN compromise, not this.
    template = template.replace(/\s+integrity="[^"]*"/gi, '').replace(/\s+crossorigin="[^"]*"/gi, '');

    const resourceScript = '<script>window.__resources = ' +
      JSON.stringify(resourceMap).replace(/<\//g, '<\\/') +
      ';</' + 'script>';
    // Inject after <head> so the DOCTYPE stays first; prepending the script
    // would push the parser into quirks mode. DOMParser always emits a <head>
    // (synthesizing one if the source HTML omitted it) but may carry
    // attributes through, so match the full opening tag. slice() rather than
    // replace() keeps us clear of $-pattern substitution in resourceScript.
    const headOpen = template.match(/<head[^>]*>/i);
    if (headOpen) {
      const i = headOpen.index + headOpen[0].length;
      template = template.slice(0, i) + resourceScript + template.slice(i);
    }

    // Parse the template and swap the root element. Scripts inserted via
    // DOMParser/replaceWith are inert per spec — re-create each with
    // createElement so they execute, awaiting onload for src scripts to
    // preserve ordering (React before ReactDOM before Babel before text/babel).
    const doc = new DOMParser().parseFromString(template, 'text/html');
    document.documentElement.replaceWith(doc.documentElement);

    // Resolve page-frame markers: mint this document's own blob for each
    // framed page — from local text when this is the root, otherwise by
    // asking the direct parent over the relay protocol above. An
    // unanswered request leaves the frame on about:blank, the same
    // degraded state as a refused embed.
    {
      const MARKER = /^about:blank#([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(#.*)?$/;
      const needed = [];
      for (const el of Array.from(document.querySelectorAll('iframe'))) {
        const m = MARKER.exec(el.getAttribute('src') || '');
        if (!m) continue;
        const text = pageTexts[m[1]];
        if (typeof text === 'string') {
          mountPage(el, m[2] || '', text);
        } else if (window.parent !== window && !isPageRoot) {
          const had = pendingFrames[m[1]];
          (pendingFrames[m[1]] = had || []).push({ el: el, frag: m[2] || '' });
          if (!had) needed.push(m[1]);
        }
      }
      for (const uuid of needed) {
        window.parent.postMessage({ __bundler_need: uuid }, OWN_TARGET);
      }
    }

    const dead = Array.from(document.scripts);
    for (const old of dead) {
      const s = document.createElement('script');
      for (const a of old.attributes) s.setAttribute(a.name, a.value);
      s.textContent = old.textContent;
      // text/babel scripts with a src: read and inline. transformScriptTags
      // does XHR against the src, but blob:null/ from a file:// origin is
      // silently dropped. Inlining makes it a plain inline babel script,
      // which transformScriptTags handles unconditionally.
      if ((s.type === 'text/babel' || s.type === 'text/jsx') && s.src) {
        const pre = resourceBlobs[s.src.split('#')[0]];
        s.textContent = pre ? await pre.text() : await (await fetch(s.src)).text();
        s.removeAttribute('src');
      }
      const p = s.src ? new Promise(function(r) { s.onload = s.onerror = r; }) : null;
      old.replaceWith(s);
      if (p) await p;
    }
    // Babel standalone auto-transforms type=text/babel on DOMContentLoaded,
    // which fired before we swapped the document. Trigger manually if present.
    if (window.Babel && typeof window.Babel.transformScriptTags === 'function') {
      window.Babel.transformScriptTags();
    }
  } catch (err) {
    setStatus('Error unpacking: ' + err.message);
    console.error('Bundle unpack error:', err);
  }
});

  </script>

  <script type="__bundler/manifest">
{"482ab0ad-b962-43d1-9808-656be20dc08e":{"mime":"text/javascript","compressed":true,"data":"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"}}
  </script>

  <script type="__bundler/ext_resources">
[]
  </script>

  <script type="__bundler/page_order">
[]
  </script>

  <script type="__bundler/template">
"<!DOCTYPE html>\n<html lang=\"de\"><head>\n<meta charset=\"utf-8\">\n<title>Wohnung – 3D Miniatur<\u002Ftitle>\n<script type=\"importmap\">\n{\n  \"imports\": {\n    \"three\": \"https://unpkg.com/three@0.184.0/build/three.module.js\",\n    \"three/addons/controls/OrbitControls.js\": \"https://unpkg.com/three@0.184.0/examples/jsm/controls/OrbitControls.js\",\n    \"three/addons/exporters/OBJExporter.js\": \"https://unpkg.com/three@0.184.0/examples/jsm/exporters/OBJExporter.js\",\n    \"three/addons/exporters/GLTFExporter.js\": \"https://unpkg.com/three@0.184.0/examples/jsm/exporters/GLTFExporter.js\",\n    \"three/examples/jsm/\": \"https://unpkg.com/three@0.184.0/examples/jsm/\",\n    \"three/addons/\": \"https://unpkg.com/three@0.184.0/examples/jsm/\",\n    \"three-mesh-bvh\": \"https://cdn.jsdelivr.net/npm/three-mesh-bvh@0.9.5/build/index.module.js\",\n    \"three-gpu-pathtracer\": \"https://cdn.jsdelivr.net/npm/three-gpu-pathtracer@0.0.24/build/index.module.js\",\n    \"n8ao\": \"https://cdn.jsdelivr.net/npm/n8ao@1/dist/N8AO.js\",\n    \"postprocessing\": \"https://cdn.jsdelivr.net/npm/postprocessing@6/build/index.js\"\n  },\n  \"integrity\": {\n    \"https://unpkg.com/three@0.184.0/build/three.module.js\": \"sha384-8FCZ1eVO6it4+pbec2aDtnTrwjWXZLJRC+MAGCIPDgsYnUrl/E0A2YlF8ioMKI/J\",\n    \"https://unpkg.com/three@0.184.0/build/three.core.js\": \"sha384-dw2ooPewaEIrAgl6oFDBmmBWCE9oW9LxRGcfwZ0hLvEprzo202wXl7vCYHRlSnOT\",\n    \"https://unpkg.com/three@0.184.0/examples/jsm/controls/OrbitControls.js\": \"sha384-4rziNxOBZKQ69i+w+f89KJ55TCYquwchVbByQwmaOeIOXdOU2PLDn3kOfXHwIJC9\",\n    \"https://unpkg.com/three@0.184.0/examples/jsm/exporters/OBJExporter.js\": \"sha384-nbwtoZENJD3Vq+ACK0CuGQdPMuDWHkamC2KJD70EV5nfg6jQjfppKOea07YJN+N3\",\n    \"https://unpkg.com/three@0.184.0/examples/jsm/exporters/GLTFExporter.js\": \"sha384-VofkvpG6HERhFCYbsUOHeNXBCqID2nfqkQqnVzE1jc/oPcz+qJ13ADdXH08hE+cQ\"\n  }\n}\n<\u002Fscript>\n<style>\n  html,body{margin:0;height:100%;background:#efece6;font-family:Helvetica,Arial,sans-serif}\n  three-d-stage:not(:defined){visibility:hidden}\n  #rooms{position:fixed;left:50%;bottom:22px;transform:translateX(-50%);display:flex;gap:6px;padding:6px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);border-radius:999px;box-shadow:0 6px 24px rgba(30,28,24,.14)}\n  #rooms button{appearance:none;border:0;background:transparent;color:#2f2d2a;font:500 14px/1 Helvetica,Arial,sans-serif;padding:11px 18px;border-radius:999px;cursor:pointer;transition:background .2s,color .2s}\n  #rooms button:hover{background:rgba(47,45,42,.08)}\n  #rooms button.on{background:#2f2d2a;color:#f7f5f0}\n  #pov{position:fixed;left:50%;top:18px;transform:translate(-50%,-8px);opacity:0;pointer-events:none;transition:opacity .3s,transform .3s;display:flex;gap:4px;padding:4px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);border-radius:999px;box-shadow:0 1px 2px rgba(0,0,0,.06),0 6px 20px rgba(0,0,0,.08)}\n  #pov.show{opacity:1;pointer-events:auto;transform:translate(-50%,0)}\n  #pov button{appearance:none;border:0;background:transparent;color:#2f2d2a;font:500 13px/1 Helvetica,Arial,sans-serif;padding:9px 14px;border-radius:999px;cursor:pointer;transition:background .2s,color .2s}\n  #pov button:hover{background:rgba(47,45,42,.08)}\n  #pov button.on{background:#2f2d2a;color:#f7f5f0}\n  #lamp{position:fixed;left:50%;bottom:82px;transform:translate(-50%,10px);opacity:0;pointer-events:none;transition:opacity .35s,transform .35s;display:flex;align-items:center;gap:4px;padding:4px;border-radius:999px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);color:#2f2d2a;font:500 14px/1 Helvetica,Arial,sans-serif;box-shadow:0 4px 18px rgba(0,0,0,.08)}\n  #lampT{display:flex;align-items:center;gap:10px;appearance:none;border:0;background:transparent;color:inherit;font:inherit;padding:7px 14px 7px 10px;border-radius:999px;cursor:pointer;white-space:nowrap}\n  #lampT:hover{background:rgba(47,45,42,.08)}\n  #lampCtl{display:flex;align-items:center;gap:14px;max-width:0;overflow:hidden;opacity:0;transition:max-width .4s,opacity .3s,padding .4s;padding:0}\n  #lamp.on #lampCtl{max-width:420px;opacity:1;padding:0 12px 0 6px}\n  #lampSw{display:flex;gap:6px}\n  #lampSw button{appearance:none;width:22px;height:22px;border-radius:50%;border:2px solid rgba(250,248,244,.9);box-shadow:0 0 0 1px rgba(47,45,42,.18);cursor:pointer;padding:0}\n  #lampSw button.sel{box-shadow:0 0 0 2px #2f2d2a}\n  #lampSw{align-items:center;gap:8px;font-size:12px;color:#6b665e}\n  #lampSw input[type=color]{appearance:none;-webkit-appearance:none;width:26px;height:26px;border-radius:50%;border:2px solid rgba(250,248,244,.9);box-shadow:0 0 0 1px rgba(47,45,42,.25);padding:0;cursor:pointer;background:none}\n  #lampSw input[type=color]::-webkit-color-swatch-wrapper{padding:0}\n  #lampSw input[type=color]::-webkit-color-swatch{border:0;border-radius:50%}\n  #lampSw input[type=color]::-moz-color-swatch{border:0;border-radius:50%}\n  #lampDim{display:flex;align-items:center;gap:8px;font-size:12px;color:#6b665e}\n  #lampDim input{width:110px;accent-color:#2f2d2a}\n  #lampDim output{width:34px;text-align:right;font-variant-numeric:tabular-nums}\n  #lamp.show{opacity:1;transform:translate(-50%,0);pointer-events:auto}\n  #lamp i{width:12px;height:12px;border-radius:50%;background:#bdb8ae;transition:background .3s,box-shadow .3s}\n  #pt{position:fixed;top:18px;right:18px;padding:8px 12px;border-radius:999px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);color:#2f2d2a;font:500 12px/1 ui-monospace,Menlo,monospace;opacity:0;transition:opacity .3s;pointer-events:none}\n  #pt.show{opacity:1}\n  #pt{top:62px !important}\n  #rt{position:fixed;top:18px;right:18px;display:flex;align-items:center;gap:8px;appearance:none;border:0;padding:9px 14px 9px 11px;border-radius:999px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);color:#2f2d2a;font:500 13px/1 Helvetica,Arial,sans-serif;cursor:pointer;box-shadow:0 1px 2px rgba(0,0,0,.06),0 6px 20px rgba(0,0,0,.08);transition:background .2s,color .2s}\n  #rt i{width:10px;height:10px;border-radius:50%;background:#bdb8ae;transition:background .2s}\n  #rt.on{background:#2f2d2a;color:#f7f5f0}\n  #rt.on i{background:#7fd08a}\n  #lamp.on i{background:#ffc86b;box-shadow:0 0 10px 3px rgba(255,190,90,.6)}\n  #lampD{display:flex;align-items:center;gap:10px;appearance:none;border:0;background:transparent;color:inherit;font:inherit;padding:7px 14px 7px 10px;border-radius:999px;cursor:pointer;white-space:nowrap}\n  #lampD:hover{background:rgba(47,45,42,.08)}\n  #tvB{display:flex;align-items:center;gap:8px;appearance:none;border:0;background:transparent;color:inherit;font:inherit;padding:7px 14px 7px 10px;border-radius:999px;cursor:pointer;white-space:nowrap}\n  #tvB:hover{background:rgba(255,255,255,.1)}\n  #tvB svg{flex:none;transition:color .3s}\n  #tvBar{position:fixed;left:50%;bottom:22px;transform:translate(-50%,10px);opacity:0;pointer-events:none;transition:opacity .4s,transform .4s;display:flex;gap:4px;padding:4px;border-radius:999px;background:rgba(20,20,18,.55);backdrop-filter:blur(12px);-webkit-backdrop-filter:blur(12px);z-index:60}\n  #tvBar.show{opacity:1;transform:translate(-50%,0);pointer-events:auto}\n  #tvUI{position:fixed;inset:0;z-index:55;opacity:0;pointer-events:none;transition:opacity .5s;font-family:Helvetica,Arial,sans-serif;color:#f2f1ec;background:#0b0c0e;overflow:hidden}\n  #tvUI.show{opacity:1;pointer-events:auto}\n  #tvUI .tv-hero{--a:#e5484d;position:absolute;inset:0;display:flex;flex-direction:column;justify-content:flex-end;gap:6px;padding:0 clamp(20px,6vw,80px) clamp(150px,22vh,220px);background:radial-gradient(120% 90% at 85% 20%,color-mix(in oklch,var(--a) 55%,transparent),transparent 60%),linear-gradient(180deg,#0b0c0e 0%,#121316 100%);transition:background .5s}\n  #tvUI .tv-hero small{font-size:clamp(12px,1.4vw,15px);letter-spacing:.08em;text-transform:uppercase;color:#bdbab2}\n  #tvUI .tv-hero h2{margin:0;font-weight:700;font-size:clamp(40px,8vw,110px);line-height:1;letter-spacing:-.02em;text-wrap:balance}\n  #tvUI .tv-nav{position:absolute;left:0;right:0;top:clamp(14px,3vh,28px);display:flex;gap:8px;padding:6px clamp(20px,6vw,80px);overflow-x:auto;scrollbar-width:none;-webkit-overflow-scrolling:touch}\n  #tvUI .tv-nav::-webkit-scrollbar{display:none}\n  #tvUI .tv-nav button{flex:none;appearance:none;border:0;background:rgba(255,255,255,.08);color:#f2f1ec;font:500 clamp(14px,1.5vw,17px)/1 Helvetica,Arial,sans-serif;padding:13px 20px;border-radius:999px;cursor:pointer;transition:background .2s,color .2s,transform .2s;min-height:44px}\n  #tvUI .tv-nav button:hover{background:rgba(255,255,255,.16)}\n  #tvUI .tv-nav button.on{background:#f2f1ec;color:#111214;transform:scale(1.04)}\n  #tvUI .tv-vol{position:absolute;right:clamp(12px,2.5vw,32px);top:50%;transform:translateY(-50%);display:flex;flex-direction:column;align-items:center;gap:10px;padding:10px 8px;border-radius:999px;background:rgba(255,255,255,.08);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px)}\n  #tvUI .tv-vb{appearance:none;border:0;width:44px;height:44px;border-radius:50%;background:transparent;color:#f2f1ec;font:400 22px/1 Helvetica,Arial,sans-serif;cursor:pointer}\n  #tvUI .tv-vb:hover{background:rgba(255,255,255,.12)}\n  #tvUI .tv-vol input{--v:35%;-webkit-appearance:none;appearance:none;writing-mode:vertical-lr;direction:rtl;width:6px;height:clamp(120px,28vh,220px);border-radius:3px;background:linear-gradient(to top,#f2f1ec var(--v),rgba(255,255,255,.2) var(--v));cursor:pointer;margin:0}\n  #tvUI .tv-vol input::-webkit-slider-thumb{-webkit-appearance:none;width:18px;height:18px;border-radius:50%;background:#f2f1ec;box-shadow:0 1px 4px rgba(0,0,0,.4)}\n  #tvUI .tv-vol input::-moz-range-thumb{width:18px;height:18px;border:0;border-radius:50%;background:#f2f1ec}\n  #tvUI .tv-vol output{font:500 12px/1 Helvetica,Arial,sans-serif;color:#bdbab2;font-variant-numeric:tabular-nums;padding-bottom:4px}\n  @media (max-width:600px){#tvUI .tv-nav button{padding:12px 16px}#tvUI .tv-vol{right:10px;padding:6px 4px}#tvUI .tv-hero{padding-right:80px}}\n  #tvBar button{display:flex;align-items:center;gap:8px;appearance:none;border:0;background:transparent;color:#f2f1ec;font:500 13px/1 Helvetica,Arial,sans-serif;padding:9px 14px;border-radius:999px;cursor:pointer}\n  #tvBar button:hover{background:rgba(255,255,255,.12)}\n  body.tvfocus #rooms,body.tvfocus #pov,body.tvfocus #rt,body.tvfocus #pt,body.tvfocus #lamp,body.tvfocus #lamp2,body.tvfocus #mp{opacity:0 !important;pointer-events:none !important;transition:opacity .4s}\n  #tvB .pw{transition:fill .3s,stroke .3s}\n  #tvB.on .pw{fill:#e5484d;stroke:#e5484d}\n  #tvB.on svg{filter:drop-shadow(0 0 4px rgba(120,170,255,.7))}\n  #lampD b{width:12px;height:12px;border-radius:50%;background:#bdb8ae;transition:background .3s,box-shadow .3s}\n  #lampD.on b{background:#ff9a3c;box-shadow:0 0 10px 3px rgba(255,150,60,.6)}\n  #lamp2{position:fixed;left:50%;bottom:82px;transform:translate(-50%,10px);opacity:0;pointer-events:none;transition:opacity .35s,transform .35s;display:flex;align-items:center;gap:4px;padding:4px;border-radius:999px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);color:#2f2d2a;font:500 14px/1 Helvetica,Arial,sans-serif;box-shadow:0 4px 18px rgba(0,0,0,.08)}\n  #lamp2.show{opacity:1;transform:translate(-50%,0);pointer-events:auto}\n  #tripT{display:flex;align-items:center;gap:10px;appearance:none;border:0;background:transparent;color:inherit;font:inherit;padding:7px 14px 7px 10px;border-radius:999px;cursor:pointer;white-space:nowrap}\n  #tripT:hover{background:rgba(47,45,42,.08)}\n  #tripT i{width:12px;height:12px;border-radius:50%;background:#bdb8ae;transition:background .3s,box-shadow .3s}\n  #tripCtl{display:flex;align-items:center;gap:14px;max-width:0;overflow:hidden;opacity:0;transition:max-width .4s,opacity .3s,padding .4s;padding:0}\n  #lamp2.on #tripCtl{max-width:560px;opacity:1;padding:0 12px 0 6px}\n  #tripCtl label{display:flex;align-items:center;gap:8px;font-size:12px;color:#6b665e}\n  #tripCtl input[type=range]{width:100px;accent-color:#2f2d2a}\n  #tripCtl output{width:34px;text-align:right;font-variant-numeric:tabular-nums}\n  #tripCtl input[type=color]{appearance:none;-webkit-appearance:none;width:26px;height:26px;border-radius:50%;border:2px solid rgba(250,248,244,.9);box-shadow:0 0 0 1px rgba(47,45,42,.25);padding:0;cursor:pointer;background:none}\n  #tripCtl input[type=color]::-webkit-color-swatch-wrapper{padding:0}\n  #tripCtl input[type=color]::-webkit-color-swatch{border:0;border-radius:50%}\n  #tripCtl input[type=color]::-moz-color-swatch{border:0;border-radius:50%}\n  #rooms,#pov,#rt,#pt,#lamp,#lamp2,three-d-stage::part(toolbar){transition:opacity .6s}\n  body.idle #rooms,body.idle #pov,body.idle #rt,body.idle #pt,body.idle #lamp,body.idle #lamp2{opacity:0 !important;pointer-events:none}\n  body.idle{cursor:none}\n\n  /* muavin-Gradient für GUI-Leisten */\n  #rooms,#pov,#lamp,#lamp2,#pt,#rt,#mp{background-color:#000 !important;background-image:radial-gradient(circle at 65.34% 44.62%, rgba(95,95,95,1) 0%, rgba(95,95,95,.844) 8.53%, rgba(95,95,95,.5) 17.05%, rgba(95,95,95,.156) 25.58%, rgba(95,95,95,0) 34.1%),radial-gradient(circle at 28.07% 74.48%, rgba(53,54,48,1) 0%, rgba(53,54,48,.844) 11.41%, rgba(53,54,48,.5) 22.83%, rgba(53,54,48,.156) 34.24%, rgba(53,54,48,0) 45.65%),radial-gradient(circle at 52.42% 19.94%, rgba(56,122,56,1) 0%, rgba(56,122,56,.844) 14.39%, rgba(56,122,56,.5) 28.77%, rgba(56,122,56,.156) 43.16%, rgba(56,122,56,0) 57.55%),radial-gradient(circle at 80.31% 84.47%, rgba(0,0,0,1) 0%, rgba(0,0,0,.844) 17.27%, rgba(0,0,0,.5) 34.55%, rgba(0,0,0,.156) 51.82%, rgba(0,0,0,0) 69.1%) !important;background-size:100% 100% !important;color:#f2f1ec !important;box-shadow:0 6px 24px rgba(0,0,0,.25),inset 0 0 0 1px rgba(255,255,255,.08)}\n  #rooms button,#pov button{color:#f2f1ec}\n  #rooms button:hover,#pov button:hover,#lampT:hover,#lampD:hover,#tripT:hover{background:rgba(255,255,255,.1)}\n  #rooms button.on,#pov button.on,#rt.on{background:#f2f1ec !important;background-image:none !important;color:#141412 !important}\n  #lampSw,#lampDim,#tripCtl{color:#d9d7d0 !important}\n  #lampSw button.sel{box-shadow:0 0 0 2px #f2f1ec}\n  #lampDim input[type=range],#tripCtl input[type=range]{accent-color:#f2f1ec}\n  .lp-sw{appearance:none;width:26px;height:26px;border-radius:50%;border:2px solid rgba(250,248,244,.9);box-shadow:0 0 0 1px rgba(47,45,42,.25);padding:0;cursor:pointer;flex:none}\n  .lpick{position:fixed;z-index:50;width:236px;padding:14px;border-radius:18px;background:rgba(26,27,24,.38);backdrop-filter:blur(18px) saturate(1.2);-webkit-backdrop-filter:blur(18px) saturate(1.2);color:#f2f1ec;font:500 12px/1.2 Helvetica,Arial,sans-serif;box-shadow:0 10px 36px rgba(0,0,0,.35),inset 0 0 0 1px rgba(255,255,255,.08);display:none;flex-direction:column;gap:14px;transition:opacity .6s}\n  .lpick.open{display:flex}\n  body.lpfocus #rooms,body.lpfocus #pov,body.lpfocus #rt,body.lpfocus #pt,body.lpfocus #lamp,body.lpfocus #lamp2,body.lpfocus three-d-stage::part(toolbar){opacity:0 !important;pointer-events:none !important}\n  .lp-done{appearance:none;border:0;border-radius:999px;padding:9px 0;background:rgba(255,255,255,.1);color:#f2f1ec;font:inherit;cursor:pointer}\n  .lp-done:hover{background:rgba(255,255,255,.18)}\n  body.idle .lpick{opacity:0;pointer-events:none}\n  .lp-seg{display:grid;grid-template-columns:1fr 1fr;gap:3px;padding:3px;border-radius:999px;background:rgba(255,255,255,.08)}\n  .lp-seg button{appearance:none;border:0;border-radius:999px;padding:7px 0;background:transparent;color:#d9d7d0;font:inherit;cursor:pointer}\n  .lp-seg button.on{background:#f2f1ec;color:#141412}\n  .lp-row{display:flex;flex-direction:column;gap:7px}\n  .lp-row>div{display:flex;justify-content:space-between;color:#d9d7d0}\n  .lp-row output{font-variant-numeric:tabular-nums;color:#f2f1ec}\n  .lp-row small{display:flex;justify-content:space-between;color:#a9a69e;font-size:11px}\n  .lpick input[type=range]{width:100%;margin:0;accent-color:#f2f1ec}\n  .lpick input.lp-temp{appearance:none;-webkit-appearance:none;height:10px;border-radius:5px;outline:none}\n  .lp-temp::-webkit-slider-thumb{-webkit-appearance:none;width:18px;height:18px;border-radius:50%;background:#fff;border:2px solid #1a1b18;box-shadow:0 0 0 1px rgba(255,255,255,.6);cursor:pointer}\n  .lp-temp::-moz-range-thumb{width:14px;height:14px;border-radius:50%;background:#fff;border:2px solid #1a1b18;cursor:pointer}\n  .lp-wheel{position:relative;width:180px;height:180px;margin:0 auto;touch-action:none;cursor:pointer}\n  .lp-wheel canvas{width:180px;height:180px;border-radius:50%;display:block}\n  .lp-wheel i{position:absolute;width:18px;height:18px;margin:-9px 0 0 -9px;border-radius:50%;border:2px solid #fff;box-shadow:0 0 0 1px rgba(0,0,0,.4),0 2px 6px rgba(0,0,0,.4);pointer-events:none}\n\n  #mp{position:fixed;top:18px;left:18px;z-index:40;width:300px;box-sizing:border-box;padding:12px 14px 12px 12px;border-radius:20px;font:500 13px/1.2 Helvetica,Arial,sans-serif;display:flex;flex-direction:column;gap:10px;transition:opacity .6s}\n  #mp .mp-top{display:flex;align-items:center;gap:12px}\n  #mp .mp-disc{flex:none;width:40px;height:40px;border-radius:50%;background:radial-gradient(circle,#141412 0 5px,#f2f1ec 5px 7px,#2a2b27 7px 100%);box-shadow:inset 0 0 0 1px rgba(255,255,255,.12);animation:mpspin 4s linear infinite;animation-play-state:paused}\n  #mp.play .mp-disc{animation-play-state:running}\n  #mp .mp-meta{flex:1;min-width:0;display:flex;flex-direction:column;gap:3px}\n  #mp .mp-t{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;color:#f2f1ec}\n  #mp .mp-s{font-size:11px;color:#a9a69e;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}\n  #mp .mp-ctl{display:flex;align-items:center;gap:2px}\n  #mp button{appearance:none;border:0;background:transparent;color:#f2f1ec;cursor:pointer;width:32px;height:32px;border-radius:50%;display:grid;place-items:center;padding:0}\n  #mp button:hover{background:rgba(255,255,255,.1)}\n  #mp button:disabled{opacity:.35;cursor:default;background:transparent}\n  #mp button.mp-pp{background:#f2f1ec;color:#141412}\n  #mp button.mp-pp:hover{background:#fff}\n  #mp button.mp-pp:disabled{background:#f2f1ec}\n  #mp svg{width:14px;height:14px;fill:currentColor;display:block}\n  #mp .mp-bar{display:flex;align-items:center;gap:8px;font-size:11px;color:#a9a69e;font-variant-numeric:tabular-nums}\n  #mp input[type=range]{flex:1;margin:0;accent-color:#f2f1ec;height:14px}\n  #mp .mp-vol{width:64px;flex:none}\n  #mp .mp-add{width:auto;height:28px;padding:0 12px;border-radius:999px;background:rgba(255,255,255,.1);font:inherit;font-size:12px;white-space:nowrap}\n  #mp .mp-add:hover{background:rgba(255,255,255,.18)}\n  #mp.empty .mp-bar{display:none}\n  #mp.drag{box-shadow:0 0 0 2px #f2f1ec,0 6px 24px rgba(0,0,0,.25) !important}\n  body.idle #mp,body.lpfocus #mp{opacity:0 !important;pointer-events:none !important}\n  @keyframes mpspin{to{transform:rotate(360deg)}}\n\n  /* KI-Kugel */\n  .orb{position:relative;display:block;flex:none;width:var(--s,64px);height:var(--s,64px);border-radius:50%;overflow:hidden;isolation:isolate;background:radial-gradient(circle at 50% 60%,#0d1024 0%,#04050b 72%);box-shadow:0 0 0 1px rgba(150,190,255,.28) inset,0 0 22px 3px rgba(80,130,255,.38),0 0 54px 8px rgba(170,80,255,.16);transition:box-shadow .4s}\n  .orb::after{content:\"\";position:absolute;inset:0;border-radius:50%;box-shadow:inset 0 -7px 14px rgba(0,0,0,.65),inset 0 2px 5px rgba(255,255,255,.22);z-index:3}\n  .orb i{position:absolute;border-radius:50%;display:block}\n  .o-swirl{inset:-22%;background:conic-gradient(from 0deg,#00e5ff,#4f6bff,#b84bff,#ff4fa3,#ffb36b,#00e5ff);filter:blur(9px);opacity:.9;mix-blend-mode:screen;animation:orbSpin 6s linear infinite;-webkit-mask:radial-gradient(circle,rgba(0,0,0,.25) 18%,#000 62%);mask:radial-gradient(circle,rgba(0,0,0,.25) 18%,#000 62%)}\n  .o-swirl.b{inset:-8%;opacity:.7;filter:blur(5px);animation-duration:9s;animation-direction:reverse;background:conic-gradient(from 90deg,transparent,#7cf8ff 18%,transparent 36%,#c17cff 58%,transparent 78%)}\n  .o-core{inset:31%;background:radial-gradient(circle,#fff 0%,#aef0ff 32%,rgba(90,120,255,0) 72%);filter:blur(1.5px);mix-blend-mode:screen;animation:orbBreath 3.2s ease-in-out infinite}\n  .o-shine{inset:5% 20% 58% 20%;z-index:2;background:radial-gradient(ellipse at 50% 0%,rgba(255,255,255,.5),transparent 70%)}\n  @keyframes orbSpin{to{transform:rotate(360deg)}}\n  @keyframes orbBreath{0%,100%{transform:scale(.82);opacity:.7}50%{transform:scale(1.12);opacity:1}}\n  @keyframes orbTalk{from{transform:scale(.78);opacity:.8}to{transform:scale(1.32);opacity:1}}\n  @keyframes micPulse{0%{box-shadow:0 0 0 0 rgba(120,150,255,.65)}100%{box-shadow:0 0 0 14px rgba(120,150,255,0)}}\n  body.ai-listen .o-core{animation-duration:.8s}\n  body.ai-listen .o-swirl{animation-duration:1.8s}\n  body.ai-listen .orb{box-shadow:0 0 0 1px rgba(150,220,255,.5) inset,0 0 30px 6px rgba(60,200,255,.55),0 0 70px 14px rgba(140,90,255,.3)}\n  body.ai-think .o-swirl{animation-duration:.9s}\n  body.ai-speak .o-core{animation:orbTalk .32s ease-in-out infinite alternate}\n  #aiDock{position:fixed;z-index:81;right:30px;top:50%;transform:translateY(-50%);transition:opacity .6s,top .5s,bottom .5s}\n  #aiOrb{appearance:none;border:0;padding:0;background:none;cursor:pointer;position:relative;display:block;border-radius:50%;transition:transform .3s cubic-bezier(.3,.8,.2,1)}\n  #aiOrb:hover{transform:scale(1.07)}\n  #aiOrb:active{transform:scale(.96)}\n  #aiOrb::before{content:\"\";position:absolute;inset:-10px;border-radius:50%;border:1px solid rgba(140,180,255,.2);border-top-color:rgba(120,230,255,.95);border-right-color:rgba(190,120,255,.6);animation:orbSpin 5s linear infinite}\n  #ai.open #aiOrb::before,body.ai-listen #aiOrb::before{animation-duration:1.4s}\n  body.idle #aiDock,body.lpfocus #aiDock{opacity:0 !important;pointer-events:none}\n  body.tvfocus #aiDock{top:calc(100% - 104px);transform:none}\n  #aiScrim{display:none}\n  #aiPanel{position:fixed;z-index:80;right:126px;top:50%;width:min(380px,calc(100vw - 160px));height:min(540px,calc(100vh - 220px));box-sizing:border-box;display:flex;flex-direction:column;gap:12px;padding:16px;border-radius:24px;background:rgba(10,12,22,.74);backdrop-filter:blur(22px) saturate(1.3);-webkit-backdrop-filter:blur(22px) saturate(1.3);border:1px solid rgba(150,180,255,.16);box-shadow:0 24px 60px rgba(0,0,20,.45),inset 0 1px 0 rgba(255,255,255,.06);color:#eef1f8;font:400 14px/1.4 Helvetica,Arial,sans-serif;opacity:0;pointer-events:none;transform:translate(18px,-50%) scale(.98);transform-origin:right center;transition:opacity .3s,transform .4s cubic-bezier(.3,.8,.2,1)}\n  #ai.open #aiPanel{opacity:1;pointer-events:auto;transform:translate(0,-50%)}\n  .ai-top{display:flex;align-items:center;gap:12px}\n  .ai-ttl{flex:1;display:flex;flex-direction:column;gap:3px}\n  .ai-ttl small{font-size:10px;letter-spacing:.16em;text-transform:uppercase;color:#8f9bc4}\n  .ai-ttl b{font-size:15px;font-weight:600}\n  #aiX{appearance:none;border:0;width:36px;height:36px;border-radius:50%;background:rgba(255,255,255,.08);color:#cfd6ea;font:400 20px/1 Helvetica,Arial,sans-serif;cursor:pointer;flex:none}\n  #aiX:hover{background:rgba(255,255,255,.14)}\n  #aiLog{flex:1;min-height:0;overflow-y:auto;display:flex;flex-direction:column;gap:10px;padding:2px;scrollbar-width:thin;scrollbar-color:rgba(255,255,255,.15) transparent}\n  .ai-m{max-width:86%;padding:9px 12px;border-radius:16px;text-wrap:pretty;animation:aiIn .3s cubic-bezier(.3,.8,.2,1) both}\n  .ai-m.u{align-self:flex-end;background:rgba(110,140,255,.2);border:1px solid rgba(140,170,255,.24);border-bottom-right-radius:6px}\n  .ai-m.a{align-self:flex-start;background:rgba(255,255,255,.06);border-bottom-left-radius:6px}\n  .ai-m.dots{color:#8f9bc4;letter-spacing:.2em}\n  @keyframes aiIn{from{opacity:0;transform:translateY(6px)}to{opacity:1;transform:none}}\n  .ai-chips{display:flex;flex-wrap:wrap;gap:6px}\n  .ai-chips button{appearance:none;border:1px solid rgba(150,180,255,.22);background:transparent;color:#cfd6ea;font:500 12px/1 Helvetica,Arial,sans-serif;padding:8px 11px;border-radius:999px;cursor:pointer}\n  .ai-chips button:hover{background:rgba(150,180,255,.12)}\n  #aiForm{display:flex;gap:6px;align-items:center;margin:0;padding:5px;border-radius:999px;background:rgba(255,255,255,.06);border:1px solid rgba(150,180,255,.16)}\n  #aiIn{flex:1;min-width:0;border:0;background:transparent;color:#eef1f8;font:400 15px Helvetica,Arial,sans-serif;padding:8px 10px;outline:none}\n  #aiIn::placeholder{color:#7d87a8}\n  #aiMic,#aiSend{appearance:none;border:0;width:40px;height:40px;border-radius:50%;display:grid;place-items:center;cursor:pointer;color:#fff;background:rgba(255,255,255,.1);flex:none;padding:0}\n  #aiMic{background:linear-gradient(135deg,#20c8f0,#6a5cff 55%,#c04bff)}\n  body.ai-listen #aiMic{animation:micPulse 1s infinite}\n  #bedL{display:flex;align-items:center;gap:10px;appearance:none;border:0;background:transparent;color:inherit;font:inherit;padding:7px 14px 7px 10px;border-radius:999px;cursor:pointer;white-space:nowrap}\n  #bedL:hover{background:rgba(255,255,255,.1)}\n  #bedL b{width:12px;height:12px;border-radius:50%;background:#bdb8ae;transition:background .3s,box-shadow .3s}\n  #bedCtl{display:none;align-items:center;padding:0 10px 0 0}\n  #bedL.on+#bedCtl{display:flex}\n<\u002Fstyle>\n<\u002Fhead>\n<body>\n\n<three-d-stage name=\"wohnung\" background=\"#efece6\"><\u002Fthree-d-stage>\n<div id=\"rooms\"><\u002Fdiv>\n<div id=\"pov\"><button data-m=\"bird\" class=\"on\">Vogelperspektive<\u002Fbutton><button data-m=\"fp\">Frei umsehen<\u002Fbutton><\u002Fdiv>\n<button id=\"rt\" aria-pressed=\"false\"><i><\u002Fi><span>Render aus<\u002Fspan><\u002Fbutton>\n<div id=\"pt\"><\u002Fdiv>\n<div id=\"mp\" class=\"empty\"><div class=\"mp-top\"><div class=\"mp-disc\"><\u002Fdiv><div class=\"mp-meta\"><div class=\"mp-t\">Keine Musik<\u002Fdiv><div class=\"mp-s\">Dateien hinzufügen oder hierher ziehen<\u002Fdiv><\u002Fdiv><div class=\"mp-ctl\"><button class=\"mp-prev\" title=\"Zurück\" disabled=\"\"><svg viewBox=\"0 0 16 16\"><rect x=\"2\" y=\"3\" width=\"2\" height=\"10\"><\u002Frect><polygon points=\"14,3 14,13 5,8\"><\u002Fpolygon><\u002Fsvg><\u002Fbutton><button class=\"mp-pp\" title=\"Abspielen\" disabled=\"\"><svg viewBox=\"0 0 16 16\"><polygon points=\"4,2 4,14 14,8\"><\u002Fpolygon><\u002Fsvg><\u002Fbutton><button class=\"mp-next\" title=\"Weiter\" disabled=\"\"><svg viewBox=\"0 0 16 16\"><rect x=\"12\" y=\"3\" width=\"2\" height=\"10\"><\u002Frect><polygon points=\"2,3 2,13 11,8\"><\u002Fpolygon><\u002Fsvg><\u002Fbutton><\u002Fdiv><\u002Fdiv><div class=\"mp-bar\"><span class=\"mp-cur\">0:00<\u002Fspan><input class=\"mp-seek\" type=\"range\" min=\"0\" max=\"1000\" value=\"0\"><span class=\"mp-dur\">0:00<\u002Fspan><\u002Fdiv><div class=\"mp-bar\"><button class=\"mp-add\">+ Musik<\u002Fbutton><span style=\"margin-left:auto\">Lautstärke<\u002Fspan><input class=\"mp-vol\" type=\"range\" min=\"0\" max=\"100\" value=\"80\"><\u002Fdiv><input class=\"mp-file\" type=\"file\" accept=\"audio/*,.mp3,.m4a,.aac,.wav,.flac,.ogg,.opus\" multiple=\"\" hidden=\"\"><button class=\"mp-add mp-add0\" style=\"align-self:flex-start\">+ Musik hinzufügen<\u002Fbutton><audio class=\"mp-a\" preload=\"metadata\"><\u002Faudio><\u002Fdiv>\n<div id=\"lamp\"><button id=\"lampT\"><i><\u002Fi><span>Bogenlampe an<\u002Fspan><\u002Fbutton><div id=\"lampCtl\"><div id=\"lampSw\"><\u002Fdiv><label id=\"lampDim\" style=\"display:none\"><span>Stärke<\u002Fspan><input type=\"range\" min=\"10\" max=\"200\" step=\"5\" value=\"100\"><output>100%<\u002Foutput><\u002Flabel><\u002Fdiv><button id=\"lampD\" aria-pressed=\"false\"><b><\u002Fb><span>Donut-Lampe an<\u002Fspan><\u002Fbutton><button id=\"tvB\" aria-pressed=\"false\" title=\"Fernseher an/aus\"><svg viewBox=\"0 0 24 24\" width=\"18\" height=\"18\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.6\"><rect x=\"7.5\" y=\"2.5\" width=\"9\" height=\"19\" rx=\"3\"><\u002Frect><circle cx=\"12\" cy=\"7\" r=\"1.6\" class=\"pw\"><\u002Fcircle><circle cx=\"12\" cy=\"12.5\" r=\"2.2\"><\u002Fcircle><circle cx=\"10.3\" cy=\"17.3\" r=\".6\" fill=\"currentColor\"><\u002Fcircle><circle cx=\"13.7\" cy=\"17.3\" r=\".6\" fill=\"currentColor\"><\u002Fcircle><\u002Fsvg><span>Fernseher an<\u002Fspan><\u002Fbutton><\u002Fdiv>\n<div id=\"tvUI\"><div class=\"tv-hero\"><small>Zuletzt geöffnet<\u002Fsmall><h2><\u002Fh2><\u002Fdiv><nav class=\"tv-nav\"><\u002Fnav><div class=\"tv-vol\"><button class=\"tv-vb\" data-d=\"5\" aria-label=\"Lauter\">+<\u002Fbutton><input type=\"range\" min=\"0\" max=\"100\" step=\"1\" aria-label=\"Lautstärke\"><button class=\"tv-vb\" data-d=\"-5\" aria-label=\"Leiser\">−<\u002Fbutton><output><\u002Foutput><\u002Fdiv><\u002Fdiv>\n<div id=\"tvBar\"><button id=\"tvBack\">Zurück<\u002Fbutton><button id=\"tvOff\"><svg viewBox=\"0 0 24 24\" width=\"18\" height=\"18\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.6\"><rect x=\"7.5\" y=\"2.5\" width=\"9\" height=\"19\" rx=\"3\"><\u002Frect><circle cx=\"12\" cy=\"7\" r=\"1.6\" fill=\"#e5484d\" stroke=\"#e5484d\"><\u002Fcircle><circle cx=\"12\" cy=\"12.5\" r=\"2.2\"><\u002Fcircle><circle cx=\"10.3\" cy=\"17.3\" r=\".6\" fill=\"currentColor\"><\u002Fcircle><circle cx=\"13.7\" cy=\"17.3\" r=\".6\" fill=\"currentColor\"><\u002Fcircle><\u002Fsvg><span>Ausschalten<\u002Fspan><\u002Fbutton><\u002Fdiv>\n<div id=\"lamp2\"><button id=\"tripT\"><i><\u002Fi><span>Tripod-Lampe an<\u002Fspan><\u002Fbutton><div id=\"tripCtl\"><label><button id=\"tripCol\" class=\"lp-sw\" title=\"Licht einstellen\"><\u002Fbutton><\u002Flabel><label style=\"display:none\"><span>Stärke<\u002Fspan><input id=\"tripDim\" type=\"range\" min=\"10\" max=\"200\" step=\"5\" value=\"100\"><output>100%<\u002Foutput><\u002Flabel><label><span>Kegel<\u002Fspan><input id=\"tripCone\" type=\"range\" min=\"15\" max=\"80\" step=\"1\" value=\"32\"><output>32°<\u002Foutput><\u002Flabel><\u002Fdiv><button id=\"bedL\" aria-pressed=\"false\"><b><\u002Fb><span>Bett-LED an<\u002Fspan><\u002Fbutton><span id=\"bedCtl\"><button id=\"bedCol\" class=\"lp-sw\" title=\"LED-Farbe einstellen\"><\u002Fbutton><input id=\"bedDim\" type=\"range\" min=\"10\" max=\"200\" step=\"5\" value=\"100\" hidden=\"\"><\u002Fspan><\u002Fdiv>\n<script>\n(function(){\nconst R=document.getElementById('mp'),$=s=>R.querySelector(s),A=$('.mp-a'),F=$('.mp-file');\nconst P=\"<svg viewBox=\\\"0 0 16 16\\\"><polygon points=\\\"4,2 4,14 14,8\\\"/><\u002Fsvg>\",Z=\"<svg viewBox=\\\"0 0 16 16\\\"><rect x=\\\"3\\\" y=\\\"2\\\" width=\\\"3.5\\\" height=\\\"12\\\"/><rect x=\\\"9.5\\\" y=\\\"2\\\" width=\\\"3.5\\\" height=\\\"12\\\"/><\u002Fsvg>\";\nlet list=[],i=-1;\nconst fmt=s=>isFinite(s)?Math.floor(s/60)+':'+String(Math.floor(s%60)).padStart(2,'0'):'0:00';\nconst vol=+(localStorage.getItem('wohnung.mp.vol')??80);$('.mp-vol').value=vol;A.volume=vol/100;\nfunction ui(){\n  const e=!list.length;R.classList.toggle('empty',e);$('.mp-add0').style.display=e?'':'none';\n  $('.mp-pp').disabled=e;$('.mp-prev').disabled=$('.mp-next').disabled=list.length<2;\n  const t=list[i];$('.mp-t').textContent=t?t.name:'Keine Musik';\n  $('.mp-s').textContent=t?('Titel '+(i+1)+' von '+list.length):'Dateien hinzufügen oder hierher ziehen';\n  const pl=!A.paused&&!!t;R.classList.toggle('play',pl);$('.mp-pp').innerHTML=pl?Z:P;$('.mp-pp').title=pl?'Pause':'Abspielen';\n}\nfunction load(n,go){if(!list.length)return;i=(n+list.length)%list.length;A.src=list[i].url;if(go)A.play().catch(()=>{});ui();}\nfunction add(files){\n  const fs=[...files].filter(f=>f.type.startsWith('audio/')||/\\.(mp3|m4a|aac|wav|flac|ogg|opus)$/i.test(f.name));\n  if(!fs.length)return;const first=!list.length;\n  fs.forEach(f=>list.push({name:f.name.replace(/\\.[^.]+$/,'').replace(/[_]+/g,' '),url:URL.createObjectURL(f)}));\n  if(first)load(0,true);else ui();\n}\nR.querySelectorAll('.mp-add').forEach(b=>b.onclick=()=>F.click());\nF.onchange=()=>{add(F.files);F.value='';};\n$('.mp-pp').onclick=()=>{if(i<0)return load(0,true);A.paused?A.play().catch(()=>{}):A.pause();};\n$('.mp-prev').onclick=()=>{if(A.currentTime>3){A.currentTime=0;return;}load(i-1,true);};\n$('.mp-next').onclick=()=>load(i+1,true);\nA.onended=()=>{if(list.length>1||i<list.length-1)load(i+1,true);else ui();};\nA.onplay=A.onpause=ui;\nlet seeking=false;const sk=$('.mp-seek');\nsk.oninput=()=>{seeking=true;$('.mp-cur').textContent=fmt(sk.value/1000*A.duration);};\nsk.onchange=()=>{if(isFinite(A.duration))A.currentTime=sk.value/1000*A.duration;seeking=false;};\nA.ontimeupdate=()=>{if(seeking)return;$('.mp-cur').textContent=fmt(A.currentTime);if(A.duration)sk.value=A.currentTime/A.duration*1000;};\nA.onloadedmetadata=()=>{$('.mp-dur').textContent=fmt(A.duration);};\n$('.mp-vol').oninput=e=>{A.volume=e.target.value/100;localStorage.setItem('wohnung.mp.vol',e.target.value);};\n['dragenter','dragover'].forEach(t=>R.addEventListener(t,e=>{e.preventDefault();R.classList.add('drag');}));\n['dragleave','drop'].forEach(t=>R.addEventListener(t,e=>{e.preventDefault();R.classList.remove('drag');}));\nR.addEventListener('drop',e=>add(e.dataTransfer.files));\n['pointerdown','keydown','wheel'].forEach(t=>R.addEventListener(t,e=>e.stopPropagation()));\nui();\n})();\n<\u002Fscript>\n<div id=\"ai\"><div id=\"aiScrim\"><\u002Fdiv><div id=\"aiPanel\" role=\"dialog\" aria-label=\"KI-Assistent\"><div class=\"ai-top\"><span class=\"orb\" style=\"--s:44px\"><i class=\"o-swirl\"><\u002Fi><i class=\"o-swirl b\"><\u002Fi><i class=\"o-core\"><\u002Fi><i class=\"o-shine\"><\u002Fi><\u002Fspan><div class=\"ai-ttl\"><small>KI-Assistent<\u002Fsmall><b id=\"aiState\">Bereit<\u002Fb><\u002Fdiv><button id=\"aiX\" aria-label=\"Schließen\">×<\u002Fbutton><\u002Fdiv><div id=\"aiLog\"><\u002Fdiv><div class=\"ai-chips\"><button>Bett-LED an<\u002Fbutton><button>Zeig das Schlafzimmer<\u002Fbutton><button>Alle Lichter aus<\u002Fbutton><\u002Fdiv><form id=\"aiForm\"><input id=\"aiIn\" placeholder=\"Sag oder schreib etwas…\" autocomplete=\"off\" enterkeyhint=\"send\"><button type=\"button\" id=\"aiMic\" aria-label=\"Sprechen\"><svg viewBox=\"0 0 24 24\" width=\"20\" height=\"20\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><rect x=\"9\" y=\"3\" width=\"6\" height=\"11\" rx=\"3\"><\u002Frect><path d=\"M5.5 11a6.5 6.5 0 0 0 13 0\"><\u002Fpath><path d=\"M12 17.5V21\"><\u002Fpath><\u002Fsvg><\u002Fbutton><button type=\"submit\" id=\"aiSend\" aria-label=\"Senden\"><svg viewBox=\"0 0 24 24\" width=\"18\" height=\"18\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M12 19V5\"><\u002Fpath><path d=\"M6 11l6-6 6 6\"><\u002Fpath><\u002Fsvg><\u002Fbutton><\u002Fform><\u002Fdiv><\u002Fdiv>\n<div id=\"aiDock\"><button id=\"aiOrb\" title=\"KI-Assistent – klicken und sprechen\" aria-label=\"KI-Assistent\"><span class=\"orb\" style=\"--s:68px\"><i class=\"o-swirl\"><\u002Fi><i class=\"o-swirl b\"><\u002Fi><i class=\"o-core\"><\u002Fi><i class=\"o-shine\"><\u002Fi><\u002Fspan><\u002Fbutton><\u002Fdiv>\n<script src=\"482ab0ad-b962-43d1-9808-656be20dc08e\"><\u002Fscript>\n<script type=\"module\">\n// moebel.js (eingebettet)\n// Möbel-Builder (aus Sofa 3D / Regal 3D / Bogenlampe 3D übernommen)\nconst mk = (THREE, name, geo, mat, x=0, y=0, z=0) => { const m = new THREE.Mesh(geo, mat); m.name=name; m.position.set(x,y,z); return m; };\n\nfunction buildSofa(THREE){\n  const M = {\n    fabric: new THREE.MeshStandardMaterial({ name:'poly_wool_herringbone', color:0x8b8780, roughness:0.95 }),\n    metal:  new THREE.MeshStandardMaterial({ name:'black_powdercoat', color:0x1d1d1f, roughness:0.45, metalness:0.6 }),\n    cup:    new THREE.MeshStandardMaterial({ name:'cupholder_black', color:0x151515, roughness:0.8 }),\n  };\n  const TEX = 0.5;\n  function rbox(w, h, d, r, k = 7, bulge = 0){\n    const half = [w/2, h/2, d/2];\n    const S = half.map(hh => { const a=[]; for(let i=k;i>=0;i--) a.push(-(hh-r) - r*Math.sin(i/k*Math.PI/2)); for(let i=0;i<=k;i++) a.push((hh-r) + r*Math.sin(i/k*Math.PI/2)); return a; });\n    const pos=[], nor=[], uv=[], idx=[];\n    for (let a=0;a<3;a++) for (const s of [1,-1]){\n      const u=(a+1)%3, v=(a+2)%3, su=S[u], sv=S[v], base=pos.length/3;\n      for (let j=0;j<sv.length;j++) for (let i=0;i<su.length;i++){\n        const p=[0,0,0]; p[a]=s*half[a]; p[u]=su[i]; p[v]=sv[j];\n        const c=p.map((x,m)=>Math.max(-(half[m]-r),Math.min(half[m]-r,x)));\n        let o=p.map((x,m)=>x-c[m]); const L=Math.hypot(...o)||1; o=o.map(x=>x/L);\n        const q=c.map((x,m)=>x+o[m]*r);\n        pos.push(...q); nor.push(...o);\n        const ax=Math.abs(o[0]),ay=Math.abs(o[1]),az=Math.abs(o[2]);\n        if (ay>=ax&&ay>=az) uv.push(q[0]/TEX,q[2]/TEX); else if (ax>=az) uv.push(q[2]/TEX,q[1]/TEX); else uv.push(q[0]/TEX,q[1]/TEX);\n      }\n      const nu=su.length;\n      for (let j=0;j<sv.length-1;j++) for (let i=0;i<nu-1;i++){\n        const A=base+j*nu+i, B=A+1, C=A+nu+1, D=A+nu;\n        if (s>0) idx.push(A,B,C, A,C,D); else idx.push(A,C,B, A,D,C);\n      }\n    }\n    const g = new THREE.BufferGeometry();\n    g.setAttribute('position', new THREE.Float32BufferAttribute(pos,3));\n    g.setAttribute('normal', new THREE.Float32BufferAttribute(nor,3));\n    g.setAttribute('uv', new THREE.Float32BufferAttribute(uv,2));\n    g.setIndex(idx);\n    if (bulge){\n      const p=g.attributes.position;\n      for (let i=0;i<p.count;i++){ const x=p.getX(i)/half[0], y=p.getY(i)/half[1]; p.setZ(i, p.getZ(i)*(1+bulge*(1-x*x)*(1-y*y))); }\n      g.computeVertexNormals();\n    }\n    return g;\n  }\n  const mesh = (...a) => mk(THREE, ...a);\n  const W=1.85, D=0.925, L=0.20, ARM=0.24, TOP=0.21, G=0.004;\n  const sofa = new THREE.Group(); sofa.name = 'sofa';\n  for (const [i,sx] of [[1,-1],[2,1]])\n    sofa.add(mesh('lage_unten_'+i, rbox(W/2-G, L-G, D, 0.035), M.fabric, sx*W/4, L/2, 0));\n  const hinge = new THREE.Group(); hinge.name='klappteil'; hinge.position.set(0, L, D/2);\n  for (const [i,sx] of [[1,-1],[2,1]])\n    hinge.add(mesh('lage_mitte_'+i, rbox(W/2-G, L-G, D, 0.035), M.fabric, sx*W/4, L/2, -D/2));\n  sofa.add(hinge);\n  const top = new THREE.Group(); top.name='aufbau'; top.position.y = 2*L;\n  for (const [n,sx] of [['links',-1],['rechts',1]]){\n    const x = sx*(W/2-ARM/2);\n    top.add(mesh('armlehne_'+n, rbox(ARM, TOP, D, 0.05), M.fabric, x, TOP/2, 0));\n    top.add(mesh('becherhalter_'+n, new THREE.CylinderGeometry(0.04,0.04,0.012,40), M.cup, x, TOP+0.001, D/2-0.1));\n    const ring = mesh('becherhalter_ring_'+n, new THREE.TorusGeometry(0.042,0.005,12,40), M.metal, x, TOP+0.004, D/2-0.1);\n    ring.rotation.x = Math.PI/2; top.add(ring);\n  }\n  const backW = (W-2*ARM)/2 - G;\n  for (const [i,sx] of [[1,-1],[2,1]]){\n    top.add(mesh('rueckenteil_'+i, rbox(backW, TOP, ARM, 0.05), M.fabric, sx*(backW/2+G/2), TOP/2, -D/2+ARM/2));\n    const p = mesh('kissen_'+i, rbox(0.45, 0.45, 0.10, 0.04, 7, 0.6), M.fabric, sx*0.33, 0.22, -D/2+ARM+0.08);\n    p.rotation.x = -0.28; p.rotation.z = sx*0.06; top.add(p);\n  }\n  sofa.add(top);\n  const fz0 = -0.05, fz1 = 0.30, fh = 0.34, rr = 0.008, R = 0.045, y0 = 0.02, yt = y0 + fh;\n  for (const [n,sx] of [['links',-1],['rechts',1]]){\n    const frame = new THREE.Group(); frame.name='seitengestell_'+n;\n    const fx = sx*(W/2 + 0.012);\n    for (const z of [fz0, fz1]) frame.add(mesh('gestell_stab_'+n, new THREE.CylinderGeometry(rr,rr,fh-R,20), M.metal, fx, y0+(fh-R)/2, z));\n    const bar = mesh('gestell_quer_'+n, new THREE.CylinderGeometry(rr,rr,fz1-fz0-2*R,20), M.metal, fx, yt, (fz0+fz1)/2); bar.rotation.x=Math.PI/2; frame.add(bar);\n    for (const [z,ry] of [[fz0+R, Math.PI/2],[fz1-R, -Math.PI/2]]){\n      const c = mesh('gestell_bogen_'+n, new THREE.TorusGeometry(R, rr, 16, 24, Math.PI/2), M.metal, fx, yt-R, z); c.rotation.y = ry; frame.add(c);\n    }\n    sofa.add(frame);\n  }\n  return { group: sofa, M, D };\n}\n\nfunction buildRegal(THREE, M){\n  const box = (w, h, d) => {\n    const g = new THREE.BoxGeometry(w, h, d), uv = g.attributes.uv;\n    const faces = [[d,h],[d,h],[w,d],[w,d],[w,h],[w,h]];\n    for (let f=0; f<6; f++) for (let i=0;i<4;i++){ const k=f*4+i; uv.setXY(k, uv.getX(k)*faces[f][0], uv.getY(k)*faces[f][1]); }\n    return g;\n  };\n  const mesh = (...a) => mk(THREE, ...a);\n  const W=0.60, D=0.27, H=0.74, A=0.03, T=0.0015, LIP=0.02, FOOT=0.012;\n  const shelfTops = [0.10, 0.42, H];\n  const regal = new THREE.Group(); regal.name='regal';\n  const postH = H - FOOT;\n  for (const [n,sx,sz] of [['vl',-1,1],['vr',1,1],['hl',-1,-1],['hr',1,-1]]){\n    const p = new THREE.Group(); p.name='pfosten_'+n;\n    const cx = sx*(W/2 - A/2), cz = sz*(D/2 - A/2), y = FOOT + postH/2;\n    p.add(mesh('pfosten_'+n+'_a', box(A, postH, T), M.concrete, cx, y, sz*(D/2 - T/2)));\n    p.add(mesh('pfosten_'+n+'_b', box(T, postH, A), M.concrete, sx*(W/2 - T/2), y, cz));\n    p.add(mesh('fuss_'+n, box(A+0.002, FOOT, A+0.002), M.foot, cx, FOOT/2, cz));\n    for (const top of shelfTops){\n      const yb = top - LIP/2;\n      const b1 = mesh('schraube_'+n, new THREE.CylinderGeometry(0.004,0.004,0.003,16), M.bolt, cx, yb, sz*(D/2+0.001)); b1.rotation.x = Math.PI/2; p.add(b1);\n      const b2 = mesh('schraube_'+n, new THREE.CylinderGeometry(0.004,0.004,0.003,16), M.bolt, sx*(W/2+0.001), yb, cz); b2.rotation.z = Math.PI/2; p.add(b2);\n    }\n    regal.add(p);\n  }\n  shelfTops.forEach((top, i) => {\n    const s = new THREE.Group(); s.name='boden_'+(i+1);\n    const iw = W - 2*T, id = D - 2*T;\n    s.add(mesh('boden_'+(i+1)+'_platte', box(iw, T, id), M.concrete, 0, top - T/2, 0));\n    for (const sz of [1,-1]) s.add(mesh('boden_'+(i+1)+'_kante_z', box(iw, LIP, T), M.concrete, 0, top - LIP/2, sz*(id/2 - T/2)));\n    for (const sx of [1,-1]) s.add(mesh('boden_'+(i+1)+'_kante_x', box(T, LIP, id), M.concrete, sx*(iw/2 - T/2), top - LIP/2, 0));\n    regal.add(s);\n  });\n  return regal;\n}\nfunction regalMaterials(THREE){\n  return {\n    concrete: galvanizedMaterial(THREE, 18), // verzinkter Stahl, Textur „Fein“\n    foot:     new THREE.MeshStandardMaterial({ name:'kunststoff_fuss', color:0x2a2a2a, roughness:0.7 }),\n    bolt:     new THREE.MeshStandardMaterial({ name:'schraube', color:0x8c8c8c, roughness:0.35, metalness:0.9 }),\n  };\n}\n\nfunction buildLampe(THREE){\n  const V = (x,y,z=0) => new THREE.Vector3(x,y,z);\n  const M = {\n    chrom:  new THREE.MeshStandardMaterial({ name:'chrom', color:0xd8dadd, metalness:0.5, roughness:0.25 }),\n    schirm: new THREE.MeshPhysicalMaterial({ name:'acryl_weiss', color:0xf7f7f5, roughness:0.28, clearcoat:0.8, clearcoatRoughness:0.1, side:THREE.DoubleSide }),\n    birne:  new THREE.MeshStandardMaterial({ name:'leuchtmittel', color:0xffffff, emissive:0xfff1d6, emissiveIntensity:0.2 }),\n  };\n  const add = (parent, name, geo, mat, p=[0,0,0], r=[0,0,0]) => { const m = new THREE.Mesh(geo, mat); m.name = name; m.position.set(...p); m.rotation.set(...r); parent.add(m); return m; };\n  const lampe = new THREE.Group(); lampe.name = 'bogenlampe';\n  const H = 1.66, REACH = 1.22, SH_R = 0.15, BASE_R = 0.13, BASE_H = 0.028, POLE_R = 0.0125, ARC_R = 0.0085, POLE_TOP = 0.74;\n  const prof = [new THREE.Vector2(0, 0), new THREE.Vector2(BASE_R - 0.004, 0)];\n  for (let i = 0; i <= 10; i++){ const a = -Math.PI/2 + i/10*Math.PI/2; prof.push(new THREE.Vector2(BASE_R - 0.008 + Math.cos(a)*0.008, 0.008 + Math.sin(a)*0.008)); }\n  for (let i = 0; i <= 10; i++){ const a = i/10*Math.PI/2; prof.push(new THREE.Vector2(BASE_R - 0.012 + Math.cos(a)*0.012, BASE_H - 0.012 + Math.sin(a)*0.012)); }\n  prof.push(new THREE.Vector2(0, BASE_H));\n  add(lampe, 'fuss', new THREE.LatheGeometry(prof, 96), M.chrom);\n  add(lampe, 'fuss_rosette', new THREE.CylinderGeometry(0.022, 0.026, 0.012, 48), M.chrom, [0, BASE_H + 0.006, 0]);\n  add(lampe, 'standrohr', new THREE.CylinderGeometry(POLE_R, POLE_R, POLE_TOP - BASE_H, 48), M.chrom, [0, (POLE_TOP + BASE_H)/2, 0]);\n  add(lampe, 'muffe_unten', new THREE.CylinderGeometry(POLE_R + 0.0015, POLE_R + 0.0015, 0.03, 48), M.chrom, [0, POLE_TOP - 0.015, 0]);\n  const ARC_END = V(REACH - 0.04, H - ARC_R);\n  const arc = new THREE.CubicBezierCurve3(V(0, POLE_TOP - 0.02), V(0, 1.38), V(0.42, H - ARC_R), ARC_END);\n  add(lampe, 'bogen', new THREE.TubeGeometry(arc, 240, ARC_R, 32), M.chrom);\n  const pM = arc.getPointAt(0.36), dM = arc.getTangentAt(0.36);\n  const muffe = add(lampe, 'muffe_bogen', new THREE.CylinderGeometry(ARC_R + 0.0018, ARC_R + 0.0018, 0.035, 32), M.chrom, [pM.x, pM.y, 0]);\n  muffe.quaternion.setFromUnitVectors(V(0,1,0), dM);\n  add(lampe, 'endkappe', new THREE.CylinderGeometry(ARC_R + 0.002, ARC_R + 0.002, 0.07, 32), M.chrom, [ARC_END.x - 0.02, ARC_END.y, 0], [0, 0, Math.PI/2]);\n  const kopf = new THREE.Group(); kopf.name = 'schirm_gruppe';\n  const TILT = 0.3;\n  kopf.position.set(REACH - SH_R*Math.sin(TILT), H - ARC_R - 0.035, 0);\n  kopf.rotation.z = TILT;\n  add(lampe, 'gelenk', new THREE.CylinderGeometry(0.006, 0.006, 0.03, 20), M.chrom, [kopf.position.x, H - ARC_R - 0.018, 0]);\n  lampe.add(kopf);\n  add(kopf, 'schirm', new THREE.SphereGeometry(SH_R, 96, 48, 0, Math.PI*2, 0, 1.95), M.schirm, [0, -SH_R, 0]);\n  add(kopf, 'schirm_nabe', new THREE.CylinderGeometry(0.018, 0.028, 0.02, 40), M.chrom, [0, -0.004, 0]);\n  add(kopf, 'fassung', new THREE.CylinderGeometry(0.016, 0.016, 0.05, 32), M.chrom, [0, -0.04, 0]);\n  add(kopf, 'leuchtmittel', new THREE.SphereGeometry(0.03, 32, 16), M.birne, [0, -0.09, 0]);\n  return { group: lampe, REACH };\n}\n\n// Verzinkter Stahl (Zink-Spangle, prozedural) – aus Regal 3D\nfunction galvanized(size=1024, cells=24, seed=7){\n  let s = seed; const rnd = () => (s = (s*16807) % 2147483647) / 2147483647;\n  const g = cells, pts = [];\n  for (let j=0;j<g;j++) for (let i=0;i<g;i++){\n    const a = rnd()*Math.PI*2;\n    pts.push({ x:(i+rnd())/g, y:(j+rnd())/g, base: 0.72 + rnd()*0.18, gx:Math.cos(a), gy:Math.sin(a), k: 0.03 + rnd()*0.08, r: rnd() });\n  }\n  const col = document.createElement('canvas'); col.width = col.height = size;\n  const rou = document.createElement('canvas'); rou.width = rou.height = size;\n  const cc = col.getContext('2d'), rc = rou.getContext('2d');\n  const ci = cc.createImageData(size,size), ri = rc.createImageData(size,size);\n  for (let y=0;y<size;y++) for (let x=0;x<size;x++){\n    const u = x/size, v = y/size, cx = Math.floor(u*g), cy = Math.floor(v*g);\n    let best = 9, second = 9, bp = null, bdx=0, bdy=0;\n    for (let oy=-1;oy<=1;oy++) for (let ox=-1;ox<=1;ox++){\n      const ix = (cx+ox+g)%g, iy = (cy+oy+g)%g, p = pts[iy*g+ix];\n      const dx = u - (p.x + Math.floor((cx+ox)/g) * 1 + ((cx+ox)<0?0:0)) , dy = v - (p.y + Math.floor((cy+oy)/g));\n      const d = dx*dx + dy*dy;\n      if (d < best){ second = best; best = d; bp = p; bdx = dx; bdy = dy; } else if (d < second) second = d;\n    }\n    const edge = Math.sqrt(second) - Math.sqrt(best);            // Abstand zur Korngrenze\n    let l = bp.base + (bdx*bp.gx + bdy*bp.gy) * g * bp.k;        // Facetten-Verlauf pro Korn\n    l += (Math.random()-0.5)*0.05;                               // feines Korn\n    if (edge < 0.0018) l -= 0.035;                                // dunkle Korngrenzen\n    if (Math.random() < 0.003) l -= 0.12;                        // dunkle Sprenkel\n    l = Math.max(0.25, Math.min(0.97, l));\n    const o = (y*size+x)*4, c = l*255;\n    ci.data[o]=c*0.98; ci.data[o+1]=c; ci.data[o+2]=c*1.02; ci.data[o+3]=255;\n    const r = (0.28 + (1-l)*0.35 + bp.r*0.12) * 255;             // helle Körner glänzender\n    ri.data[o]=ri.data[o+1]=ri.data[o+2]=r; ri.data[o+3]=255;\n  }\n  cc.putImageData(ci,0,0); rc.putImageData(ri,0,0);\n  return { col, rou };\n}\nfunction galvanizedMaterial(THREE, repeat = 18){\n  const { col, rou } = galvanized();\n  const mk = (c, srgb) => { const t = new THREE.CanvasTexture(c); t.wrapS = t.wrapT = THREE.RepeatWrapping; t.repeat.set(repeat, repeat);\n    if (srgb) t.colorSpace = THREE.SRGBColorSpace; t.anisotropy = 8; return t; };\n  return new THREE.MeshStandardMaterial({ name:'stahl_verzinkt', map: mk(col, true), roughnessMap: mk(rou), bumpMap: mk(col), bumpScale: 0.25,\n    color: 0xeceef0, roughness: 1, metalness: 0.3 });\n}\n\n// Regallautsprecher-Paar (aus Boxen 3D): passiv + aktiv (Bedienfeld an lokaler +x-Seite)\nfunction buildBoxen(THREE){\n  const M = {\n    wood:   new THREE.MeshStandardMaterial({ name:'eiche', color:0xb77a3e, roughness:0.55 }),\n    fabric: new THREE.MeshStandardMaterial({ name:'stoff_grau', color:0x6c6c6a, roughness:0.97 }),\n    strip:  new THREE.MeshStandardMaterial({ name:'zierleiste_silber', color:0xc9c9c9, roughness:0.3, metalness:0.9 }),\n    black:  new THREE.MeshStandardMaterial({ name:'kunststoff_schwarz', color:0x1c1c1c, roughness:0.6 }),\n    knob:   new THREE.MeshStandardMaterial({ name:'drehregler', color:0x141414, roughness:0.4, metalness:0.2 }),\n    alu:    new THREE.MeshStandardMaterial({ name:'hochtoener_alu', color:0xaaaaaa, roughness:0.35, metalness:0.8 }),\n    led:    new THREE.MeshStandardMaterial({ name:'led', color:0x0a2a10, emissive:0x2bd45a, emissiveIntensity:1.2 }),\n  };\n  const W=0.146, D=0.196, H=0.234, R=0.014, BV=0.002;\n  const mesh = (name, geo, mat, x=0, y=0, z=0) => mk(THREE, name, geo, mat, x, y, z);\n  const rrect = (w, h, r) => { const s = new THREE.Shape(), x=-w/2, y=-h/2;\n    s.moveTo(x+r,y); s.lineTo(x+w-r,y); s.quadraticCurveTo(x+w,y,x+w,y+r); s.lineTo(x+w,y+h-r); s.quadraticCurveTo(x+w,y+h,x+w-r,y+h);\n    s.lineTo(x+r,y+h); s.quadraticCurveTo(x,y+h,x,y+h-r); s.lineTo(x,y+r); s.quadraticCurveTo(x,y,x+r,y); return s; };\n  const cabGeo = new THREE.ExtrudeGeometry(rrect(W-2*BV, D-2*BV, R), { depth:H-2*BV, bevelEnabled:true, bevelSize:BV, bevelThickness:BV, bevelSegments:2, curveSegments:10 });\n  cabGeo.rotateX(-Math.PI/2); cabGeo.translate(0, BV, 0);\n  { const p = cabGeo.attributes.position, n = cabGeo.attributes.normal, uv = cabGeo.attributes.uv;\n    for (let i=0;i<p.count;i++){ const x=p.getX(i), y=p.getY(i), z=p.getZ(i);\n      if (Math.abs(n.getY(i)) > 0.7) uv.setXY(i, x, z); else uv.setXY(i, Math.abs(n.getX(i)) > Math.abs(n.getZ(i)) ? z : x, y); } }\n  const GW=W-0.006, GH=H-0.006, GT=0.008;\n  const grilleGeo = new THREE.ExtrudeGeometry(rrect(GW-0.004, GH-0.004, 0.009), { depth:GT-0.003, bevelEnabled:true, bevelSize:0.002, bevelThickness:0.0015, bevelSegments:3, curveSegments:8 });\n  function speaker(name, active){\n    const s = new THREE.Group(); s.name = name;\n    s.add(mesh(name+'_gehaeuse', cabGeo, M.wood));\n    s.add(mesh(name+'_stoff', grilleGeo, M.fabric, 0, H/2, D/2 + 0.0015));\n    s.add(mesh(name+'_zierleiste', new THREE.BoxGeometry(GW*0.74, 0.0026, 0.0012), M.strip, 0, H*0.585, D/2 + GT + 0.0005));\n    s.add(mesh(name+'_logo', new THREE.BoxGeometry(0.026, 0.006, 0.0008), M.strip, 0, 0.026, D/2 + GT + 0.0003));\n    const port = mesh(name+'_bassreflex', new THREE.CylinderGeometry(0.014, 0.014, 0.004, 32), M.black, 0, 0.17, -D/2 - 0.001);\n    port.rotation.x = Math.PI/2; s.add(port);\n    for (const [fx,fz] of [[-1,-1],[1,-1],[-1,1],[1,1]])\n      s.add(mesh(name+'_fuss', new THREE.CylinderGeometry(0.006,0.006,0.002,20), M.black, fx*(W/2-0.02), 0.001, fz*(D/2-0.025)));\n    if (active){\n      const px = W/2 + 0.0004, cz = -0.012;\n      s.add(mesh(name+'_bedienfeld', new THREE.BoxGeometry(0.002, 0.108, 0.055), M.black, px, 0.14, cz));\n      [0.176, 0.143, 0.11].forEach((y, i) => {\n        const k = mesh(name+'_regler_'+['hoehen','bass','lautstaerke'][i], new THREE.CylinderGeometry(0.0085, 0.0085, 0.011, 28), M.knob, px+0.0055, y, cz-0.004);\n        k.rotation.z = Math.PI/2; s.add(k);\n      });\n      s.add(mesh(name+'_led', new THREE.SphereGeometry(0.0015, 12, 8), M.led, px+0.001, 0.093, cz-0.004));\n    }\n    s.traverse(o => { if (o.isMesh) o.position.y += 0.002; });\n    return s;\n  }\n  return { W, D, H, links: speaker('box_links', false), rechts: speaker('box_rechts_aktiv', true) };\n}\n\n// Tripod-Lampe (aus Tripodlampe 3D): Eichen-Leuchtkopf mit LED-Spot auf schwarzem Dreibein; Front = lokale +z\nfunction buildTripod(THREE){\n  const V = (x,y,z) => new THREE.Vector3(x,y,z);\n  const c = document.createElement('canvas'); c.width = c.height = 512; const g = c.getContext('2d');\n  g.fillStyle = '#c49a66'; g.fillRect(0,0,512,512);\n  let s = 11; const r = () => (s = (s*16807) % 2147483647) / 2147483647;\n  for (let i = 0; i < 260; i++){\n    const y = r()*512, a = 0.04 + r()*0.12; g.strokeStyle = r() > 0.5 ? `rgba(120,80,40,${a})` : `rgba(235,200,150,${a})`; g.lineWidth = 0.5 + r()*2.2;\n    g.beginPath(); g.moveTo(0,y); for (let x = 0; x <= 512; x += 32) g.lineTo(x, y + Math.sin(x*0.012 + i)*4 + (r()-0.5)*1.5); g.stroke();\n  }\n  const tex = new THREE.CanvasTexture(c); tex.colorSpace = THREE.SRGBColorSpace;\n  const M = {\n    holz:   new THREE.MeshStandardMaterial({ name:'tripod_eiche', map: tex, roughness:0.6 }),\n    stahl:  new THREE.MeshStandardMaterial({ name:'tripod_stahl_schwarz', color:0x1b1b1c, roughness:0.45, metalness:0.6 }),\n    gummi:  new THREE.MeshStandardMaterial({ name:'tripod_gummi', color:0x111111, roughness:0.9 }),\n    blende: new THREE.MeshStandardMaterial({ name:'tripod_reflektor', color:0x9a9a9a, roughness:0.25, metalness:0.9 }),\n    led:    new THREE.MeshStandardMaterial({ name:'tripod_led', color:0xd8dadd, emissive:0xf4f7ff, emissiveIntensity:0, roughness:0.2 }),\n    kabel:  new THREE.MeshStandardMaterial({ name:'tripod_kabel', color:0x151515, roughness:0.7 }),\n  };\n  const add = (p, n, geo, mat, pos=[0,0,0]) => { const o = mk(THREE, n, geo, mat, ...pos); p.add(o); return o; };\n  const rod = (p, n, a, b, rr, mat) => { const d = b.clone().sub(a), o = add(p, n, new THREE.CylinderGeometry(rr, rr, d.length(), 20), mat);\n    o.position.copy(a).addScaledVector(d, 0.5); o.quaternion.setFromUnitVectors(V(0,1,0), d.normalize()); return o; };\n  const group = new THREE.Group(); group.name = 'tripodlampe';\n  const HUB = V(0, 0.36, 0), FR = 0.17;\n  for (let i = 0; i < 3; i++){\n    const a = Math.PI/2 + i*2*Math.PI/3, foot = V(Math.cos(a)*FR, 0.006, Math.sin(a)*FR);\n    rod(group, 'tripod_bein_'+(i+1), foot, HUB.clone().add(V(Math.cos(a)*0.012, 0, Math.sin(a)*0.012)), 0.005, M.stahl);\n    add(group, 'tripod_fuss_'+(i+1), new THREE.CylinderGeometry(0.0058, 0.0058, 0.012, 16), M.gummi, [foot.x, 0.006, foot.z]);\n  }\n  add(group, 'tripod_knoten', new THREE.CylinderGeometry(0.016, 0.018, 0.028, 28), M.stahl, [0, 0.36, 0]);\n  const HW = 0.14, HH = 0.12, HD = 0.11;\n  const arm = new THREE.CatmullRomCurve3([V(0,0.374,0), V(-0.01,0.41,0), V(-0.045,0.45,0.005), V(-0.09,0.485,0.01), V(-0.092,0.495,0.01), V(-HW/2-0.008,0.49,0.01)]);\n  add(group, 'tripod_buegel', new THREE.TubeGeometry(arm, 48, 0.0055, 12), M.stahl);\n  const kopf = new THREE.Group(); kopf.name = 'tripod_kopf'; kopf.position.set(0, 0.49, 0.01); kopf.rotation.set(0.12, 0.15, 0); group.add(kopf);\n  add(kopf, 'tripod_holzkoerper', new THREE.BoxGeometry(HW, HH, HD), M.holz);\n  add(kopf, 'tripod_gelenk', new THREE.CylinderGeometry(0.013, 0.013, 0.01, 28), M.stahl, [-HW/2-0.005, 0, 0]).rotation.z = Math.PI/2;\n  add(kopf, 'tripod_blende', new THREE.TorusGeometry(0.036, 0.005, 12, 48), M.blende, [0.01, 0, HD/2+0.001]);\n  add(kopf, 'tripod_reflektor', new THREE.CylinderGeometry(0.036, 0.03, 0.012, 48, 1, true), M.blende, [0.01, 0, HD/2-0.005]).rotation.x = Math.PI/2;\n  const linse = add(kopf, 'tripod_led_linse', new THREE.CircleGeometry(0.034, 48), M.led, [0.01, 0, HD/2-0.008]);\n  const kabel = new THREE.CatmullRomCurve3([V(-0.005,0.35,-0.012), V(-0.03,0.28,-0.04), V(-0.07,0.16,-0.08), V(-0.11,0.05,-0.12), V(-0.14,0.004,-0.16), V(-0.28,0.004,-0.24), V(-0.45,0.004,-0.2)]);\n  add(group, 'tripod_kabel', new THREE.TubeGeometry(kabel, 64, 0.0022, 8), M.kabel);\n  group.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\n  linse.castShadow = false;\n  // Lichtquellen am Kopf (Intensität 0 = aus)\n  const spot = new THREE.SpotLight(0xf2f5ff, 0, 0, 0.55, 0.5, 2);\n  spot.position.set(0.01, 0, HD/2 + 0.005); spot.target.position.set(0.01, 0, HD/2 + 1);\n  spot.castShadow = true; spot.shadow.mapSize.set(1024, 1024); spot.shadow.bias = -0.0005; spot.shadow.normalBias = 0.02;\n  spot.shadow.camera.near = 0.03; spot.shadow.camera.far = 8;\n  const glow = new THREE.PointLight(0xf2f5ff, 0, 3, 2); glow.position.set(0.01, 0, HD/2 + 0.05);\n  kopf.add(spot, spot.target, glow);\n  return { group, kopf, M, spot, glow };\n}\n\nconst stage = document.querySelector('three-d-stage');\nconst { THREE } = await stage.ready;\nconst statusEl = { set textContent(v){} };\nfor (const sel of ['.toolbar','.note']) { const el = stage.shadowRoot.querySelector(sel); if (el) el.style.display = 'none'; }\n\n// ---------- Maße in Metern (LiDAR-Scan 10/2026, bereinigt) ----------\n// x = Ost, z = Süd; Ursprung = Innenkante Westwand Schlafzimmer / Innenkante Nordwand\nconst H = 2.5, TE = 0.2, TI = 0.1;     // Wandhöhe, Außen-/Innenwand\nconst DOOR_W = 0.9, DOOR_H = 2.1, WIN_B = 0.9, WIN_T = 2.2;\n\n// ---------- Materialien ----------\nconst M = {\n  floor:  new THREE.MeshStandardMaterial({ name:'wood_floor', color:0x8a6242, roughness:0.6 }),\n  wall:   new THREE.MeshStandardMaterial({ name:'white_stucco', color:0xf2efe9, roughness:0.95 }),\n  brick:  new THREE.MeshStandardMaterial({ name:'brick_wall_04', color:0x9a5a44, roughness:0.9 }),\n  cap:    new THREE.MeshStandardMaterial({ name:'rough_plaster_brick_04', color:0xb8a898, roughness:0.95 }),\n  plinth: new THREE.MeshStandardMaterial({ name:'plinth', color:0x2f2d2a, roughness:0.7 }),\n  wood:   new THREE.MeshStandardMaterial({ name:'door_white_lacquer', color:0xf7f5f0, roughness:0.35 }),\n  metal:  new THREE.MeshStandardMaterial({ name:'brushed_steel', color:0xb9bcc0, roughness:0.3, metalness:0.35 }),\n  glass:  new THREE.MeshStandardMaterial({ name:'glass', color:0xbfd8e4, roughness:0.05, transparent:true, opacity:0.35 }),\n  balcony:new THREE.MeshStandardMaterial({ name:'balcony_concrete', color:0xa9a59d, roughness:0.9 }),\n};\n\n// Welt-UVs (Box-Projektion), damit Texturen nicht gestreckt werden\nfunction worldUV(geo, scale){\n  const p = geo.attributes.position, n = geo.attributes.normal, uv = geo.attributes.uv;\n  for (let i = 0; i < p.count; i++){\n    const ax = Math.abs(n.getX(i)), ay = Math.abs(n.getY(i)), az = Math.abs(n.getZ(i));\n    let u, v;\n    if (ay >= ax && ay >= az){ u = p.getX(i); v = p.getZ(i); }\n    else if (ax >= az){ u = p.getZ(i); v = p.getY(i); }\n    else { u = p.getX(i); v = p.getY(i); }\n    uv.setXY(i, u/scale, v/scale);\n  }\n  uv.needsUpdate = true;\n  return geo;\n}\n// Box in Weltkoordinaten (min/max)\nfunction box(name, mat, x0,y0,z0, x1,y1,z1, uvScale){\n  const g = new THREE.BoxGeometry(x1-x0, y1-y0, z1-z0);\n  g.translate((x0+x1)/2, (y0+y1)/2, (z0+z1)/2);\n  if (uvScale) worldUV(g, uvScale);\n  const m = new THREE.Mesh(g, mat); m.name = name; return m;\n}\n\nconst home = new THREE.Group(); home.name = 'wohnung';\nconst walls = new THREE.Group(); walls.name = 'waende';\nconst doors = new THREE.Group(); doors.name = 'tueren';\nconst windows = new THREE.Group(); windows.name = 'fenster';\nhome.add(walls, doors, windows);\n\n// ---------- Tür (prozedural, Kassettentür) ----------\nfunction makeDoor(name, t, openDeg, glassDoor=false, w=DOOR_W){\n  const g = new THREE.Group(); g.name = name;\n  const d = t + 0.03;\n  g.add(box(name+'_zarge_l', M.wood, -w/2, 0, -d/2, -w/2+0.04, DOOR_H, d/2));\n  g.add(box(name+'_zarge_r', M.wood,  w/2-0.04, 0, -d/2, w/2, DOOR_H, d/2));\n  g.add(box(name+'_zarge_oben', M.wood, -w/2, DOOR_H-0.04, -d/2, w/2, DOOR_H, d/2));\n  const lw = w - 0.08, lh = DOOR_H - 0.05, lt = 0.04;\n  const pivot = new THREE.Group(); pivot.name = name+'_blatt';\n  pivot.position.set(-w/2 + 0.04, 0.005, 0);\n  pivot.rotation.y = THREE.MathUtils.degToRad(openDeg);\n  pivot.add(box(name+'_tuerblatt', M.wood, 0, 0, -lt/2, lw, lh, lt/2));\n  for (const s of [1,-1]){\n    const z0 = s*0.014, z1 = s*0.026, zz=[Math.min(z0,z1),Math.max(z0,z1)];\n    if (glassDoor){\n      pivot.add(box(name+'_glas', M.glass, 0.1, 0.35, -0.006, lw-0.1, lh-0.12, 0.006));\n    } else {\n      pivot.add(box(name+'_kassette_o'+s, M.wood, 0.11, 1.05, zz[0], lw-0.11, lh-0.14, zz[1]));\n      pivot.add(box(name+'_kassette_u'+s, M.wood, 0.11, 0.14, zz[0], lw-0.11, 0.9, zz[1]));\n    }\n    const rose = new THREE.Mesh(new THREE.CylinderGeometry(0.026,0.026,0.012,32), M.metal);\n    rose.name = name+'_rosette'+s; rose.rotation.x = Math.PI/2; rose.position.set(lw-0.07, 1.05, s*(lt/2+0.006)); pivot.add(rose);\n    const neck = new THREE.Mesh(new THREE.CylinderGeometry(0.009,0.009,0.05,20), M.metal);\n    neck.name = name+'_hals'+s; neck.rotation.x = Math.PI/2; neck.position.set(lw-0.07, 1.05, s*(lt/2+0.03)); pivot.add(neck);\n    const lever = new THREE.Mesh(new THREE.CapsuleGeometry(0.009, 0.12, 6, 16), M.metal);\n    lever.name = name+'_druecker'+s; lever.rotation.z = Math.PI/2; lever.position.set(lw-0.13, 1.05, s*(lt/2+0.055)); pivot.add(lever);\n  }\n  for (const y of [0.25, lh-0.25]){\n    const h = new THREE.Mesh(new THREE.CylinderGeometry(0.008,0.008,0.1,16), M.metal);\n    h.name = name+'_band'; h.position.set(-0.004, y, lt/2); pivot.add(h);\n  }\n  g.add(pivot);\n  return g;\n}\n\n// ---------- Fenster ----------\nfunction makeWindow(name, w, t, bottom, top){\n  const g = new THREE.Group(); g.name = name;\n  const f = 0.05, d = 0.07;\n  g.add(box(name+'_rahmen_l', M.wood, -w/2, bottom, -d/2, -w/2+f, top, d/2));\n  g.add(box(name+'_rahmen_r', M.wood, w/2-f, bottom, -d/2, w/2, top, d/2));\n  g.add(box(name+'_rahmen_o', M.wood, -w/2+f, top-f, -d/2, w/2-f, top, d/2));\n  g.add(box(name+'_rahmen_u', M.wood, -w/2+f, bottom, -d/2, w/2-f, bottom+f, d/2));\n  if (w > 1.1) g.add(box(name+'_pfosten', M.wood, -0.025, bottom+f, -d/2+0.005, 0.025, top-f, d/2-0.005));\n  g.add(box(name+'_glas', M.glass, -w/2+f, bottom+f, -0.005, w/2-f, top-f, 0.005));\n  if (bottom > 0) g.add(box(name+'_bank', M.wood, -w/2-0.05, bottom-0.027, -t/2-0.04, w/2+0.05, bottom+0.012, t/2+0.04));\n  return g;\n}\n\n// ---------- Wand mit Öffnungen (achsparallel, Meter) ----------\n// a..b: Ausdehnung entlang der Wand, fixed: Mittellinie; ops: {c, w, type:'door'|'window'|'glassdoor', open, flip, name}\n// outside: Box-Face-Index der Außenseite (0:+x 1:-x 4:+z 5:-z) → Klinker außen, Putz innen; ends: Stirnseiten außen sichtbar\nfunction wall(name, a, b, fixed, horizontal, t, h, ops=[], outside=-1, ends=[false,false]){\n  const F = fixed;\n  const seg = (n, s0, s1, y0, y1, ef=[]) => {\n    if (s1 - s0 < 0.001) return;\n    const mat = Array(6).fill(M.wall);\n    if (outside >= 0){ mat[outside] = M.brick; ef.forEach(e => mat[e] = M.brick); }\n    if (y1 >= h - 0.0001) mat[2] = M.cap;\n    walls.add(horizontal ? box(n, mat, s0, y0, F-t/2, s1, y1, F+t/2, 1.5)\n                         : box(n, mat, F-t/2, y0, s0, F+t/2, y1, s1, 1.5));\n  };\n  const endA = ends[0] ? [horizontal ? 1 : 5] : [], endB = ends[1] ? [horizontal ? 0 : 4] : [];\n  const list = [...ops].sort((p,q)=>p.c-q.c);\n  let cur = a;\n  list.forEach((o, i) => {\n    const s0 = o.c - o.w/2, s1 = o.c + o.w/2;\n    seg(`${name}_${i}`, cur, s0, 0, h, i === 0 ? endA : []);\n    seg(`${name}_sturz_${i}`, s0, s1, o.type === 'door' ? DOOR_H : WIN_T, h);\n    if (o.type === 'window') seg(`${name}_bruestung_${i}`, s0, s1, 0, WIN_B);\n    let el;\n    if (o.type === 'door') { el = makeDoor(o.name, t, o.open ?? 0, false, o.w); doors.add(el); }\n    else if (o.type === 'glassdoor') { el = makeWindow(o.name, o.w, t, 0, WIN_T); windows.add(el); }\n    else { el = makeWindow(o.name, o.w, t, WIN_B, WIN_T); windows.add(el); }\n    if (horizontal) el.position.set(o.c, 0, F);\n    else { el.position.set(F, 0, o.c); el.rotation.y = Math.PI/2; }\n    if (o.flip) el.rotation.y += Math.PI;\n    cur = s1;\n  });\n  seg(`${name}_${list.length}`, cur, b, 0, h, list.length === 0 ? [...endA, ...endB] : endB);\n}\n\n// Grundriss nach LiDAR-Scan: Raummaße, Wandlagen, Öffnungsmitten. Nicht übernommen: „Other 4“-Spalt, Scan-Möbel,\n// schräger Wandrest im Flur, 10-cm-Versatz der Ostfassade (begradigt). Tür-/Fensterbreiten + Mauervorsprung = Handmaße.\nconst HI = H - 0.003; // Innenwände minimal niedriger → kein Z-Fighting auf den Oberkanten\nconst X_FL = 1.21;              // Innenkante Westwand Bad/Flur (Schlafzimmer springt 1,21 m weiter nach Westen)\nconst X_SW = 2.66;              // Wandmitte Schlafzimmer | Wohnzimmer\nconst X_SCH = 2.11;             // Westkante Schacht\nconst X_BK = 3.29;              // Wandmitte Bad | Küche\nconst X_FK = 3.58;              // Wandmitte Flur | Küche\nconst X_EK = 6.17, X_E = 6.27;  // Innenkante Ostwand Küche / Wohnzimmer\nconst Z_SCH0 = 2.54, Z_SCH1 = 3.31; // Schacht Nord-/Südkante\nconst Z_BF = 3.13;              // Wandmitte Bad | Flur\nconst Z_SP = 4.40;              // Wandmitte Küche/Flur | Wohn-/Schlafzimmer\nconst Z_S = 8.49;               // Innenkante Südwand\nconst ZST = Z_SP + TI/2 - TE;   // Außenkante Rücksprung (Treppenhaus)\n// Raum-Innenkanten [x0, z0, x1, z1]\nconst RM_SZ  = [0, Z_SP + TI/2, X_SW - TI/2, Z_S];            // Schlafzimmer 2,61 × 4,04\nconst RM_WZ  = [X_SW + TI/2, Z_SP + TI/2, X_E, Z_S];          // Wohnzimmer 3,56 × 4,04\nconst RM_KU  = [X_BK + TI/2, 0, X_EK, Z_SP - TI/2];           // Küche 2,83 × 4,35\nconst RM_BAD = [X_FL, 0, X_BK - TI/2, Z_BF - TI/2];           // Bad 2,03 × 3,08\nconst RM_FL  = [X_FL, Z_BF + TI/2, X_FK - TI/2, Z_SP - TI/2]; // Flur 2,32 × 1,17\nconst BAD_DOOR = { c: 1.70, w: 0.75 }, SZ_DOOR = { c: 1.74, w: 0.83 }, WZ_DOOR = { c: 4.85, w: 0.83 };\nconst KU_WIN = { c: RM_KU[0] + 0.48 + 0.325, w: 0.65 }, KU_DOOR = { c: RM_KU[0] + 0.48 + 0.65 + 0.12 + 0.425, w: 0.85 };\n\n// Außenwände\nwall('aussen_nord', X_FL - TE, X_E + TE, -TE/2, true, TE, H, [\n  { c: 2.25, w: 0.8, type:'window', name:'fenster_bad' },\n  // Küche: Fenster + Balkontür als Einheit\n  { ...KU_WIN, type:'window', name:'fenster_kueche' },\n  { ...KU_DOOR, type:'glassdoor', name:'balkontuer' },\n], 5, [true, true]);\nwall('aussen_sued', -TE, X_E + TE, Z_S + TE/2, true, TE, H, [\n  { c: 0.94, w: 0.7, type:'window', name:'fenster_schlafzimmer' },\n  { c: 3.37, w: 0.7, type:'window', name:'fenster_wohnzimmer_1' },\n  { c: 5.42, w: 0.7, type:'window', name:'fenster_wohnzimmer_2' },\n], 4, [true, true]);\nwall('aussen_west_schlafzimmer', Z_SP + TI/2, Z_S, -TE/2, false, TE, H, [], 1);\nwall('aussen_nord_schlafzimmer', -TE, X_FL, ZST + TE/2, true, TE, H, [], 5, [true, false]);\nwall('aussen_west', 0, ZST, X_FL - TE/2, false, TE, H, [\n  { c: (Z_BF + Z_SP)/2, w: DOOR_W, type:'door', open: -35, name:'wohnungstuer' },\n], 1);\n// Ostfassade außen gerade; Küchenwand innen 10 cm dicker (Scan)\nwall('aussen_ost_kueche', 0, Z_SP, (X_EK + X_E + TE)/2, false, X_E + TE - X_EK, H, [], 0);\nwall('aussen_ost', Z_SP, Z_S, X_E + TE/2, false, TE, H, [], 0);\n// Innenwände\nwall('innen_bad_kueche', 0, Z_SCH0, X_BK, false, TI, HI);\nwall('innen_bad_flur', X_FL, X_SCH, Z_BF, true, TI, HI, [\n  { ...BAD_DOOR, type:'door', open: 80, name:'tuer_bad' },\n]);\nwall('innen_flur_kueche', Z_SCH1, Z_SP - TI/2, X_FK, false, TI, HI, [\n  { c: 3.78, w: 0.86, type:'door', open: -70, name:'tuer_kueche' },\n]);\nwall('innen_mitte', X_FL, X_E, Z_SP, true, TI, HI, [\n  { ...SZ_DOOR, type:'door', open: 55, flip:true, name:'tuer_schlafzimmer' },\n  { ...WZ_DOOR, type:'door', open: 65, flip:true, name:'tuer_wohnzimmer' },\n]);\nwall('innen_schlafen_wohnen', Z_SP + TI/2, Z_S, X_SW, false, TI, HI);\n// Schacht zwischen Bad, Flur und Küche (Scan: Hohlraum 56 × 145 cm ohne Wand zur Küche → als geschlossen angenommen)\n{ const m = Array(6).fill(M.wall); m[2] = M.cap; walls.add(box('schacht', m, X_SCH, 0, Z_SCH0, X_FK + TI/2, HI, Z_SCH1, 1.5)); }\n\n// ---------- Boden, Sockel, Balkon ----------\nconst OUTLINE = [[X_FL - TE/2, -TE/2], [X_E + TE/2, -TE/2], [X_E + TE/2, Z_S + TE/2], [-TE/2, Z_S + TE/2], [-TE/2, ZST + TE/2], [X_FL - TE/2, ZST + TE/2]];\nconst floorGeo = new THREE.ShapeGeometry(new THREE.Shape(OUTLINE.map(([x, z]) => new THREE.Vector2(x, -z))));\nfloorGeo.rotateX(-Math.PI/2); floorGeo.translate(0, 0.002, 0);\nworldUV(floorGeo, 1.0);\nconst floor = new THREE.Mesh(floorGeo, M.floor); floor.name = 'boden_wood_floor';\nhome.add(floor);\nhome.add(box('sockel_nord', M.plinth, X_FL - TE - 0.05, -0.12, -TE - 0.05, X_E + TE + 0.05, 0, ZST - 0.05));\nhome.add(box('sockel_sued', M.plinth, -TE - 0.05, -0.12, ZST - 0.05, X_E + TE + 0.05, 0, Z_S + TE + 0.05));\n// Balkon über die ganze Küchenbreite, 2,26 m tief (Scan); Brüstungen statt der gescannten Wände\nconst PH = 1.0, PT = 0.08;\nconst BX0 = RM_KU[0] - PT, BX1 = RM_KU[2] + PT, BZ1 = -TE, BZ0 = BZ1 - 2.26 - PT;\nhome.add(box('balkon_platte', M.balcony, BX0, -0.12, BZ0, BX1, 0.02, BZ1));\nhome.add(box('balkon_bruestung_w', M.wall, BX0, 0.02, BZ0, BX0+PT, PH, BZ1, 1.5));\nhome.add(box('balkon_bruestung_o', M.wall, BX1-PT, 0.02, BZ0, BX1, PH, BZ1, 1.5));\nhome.add(box('balkon_bruestung_n', M.wall, BX0+PT, 0.02, BZ0, BX1-PT, PH-0.002, BZ0+PT, 1.5));\n\n// ---------- Wohnzimmer (Raum Süd-Ost) ----------\nconst wohn = new THREE.Group(); wohn.name = 'wohnzimmer';\nconst IN_O = X_E, IN_S = Z_S, WZ_CX = (RM_WZ[0] + RM_WZ[2])/2, SOFA_Z = Z_S - 1.745;   // Innenkanten Ost-/Südwand\n// Sofa an der Ostwand, Rücken zur Wand\nconst sofa = buildSofa(THREE);\nsofa.group.position.set(IN_O - sofa.D/2 - 0.03, 0.002, SOFA_Z);\nsofa.group.rotation.y = -Math.PI/2;\nwohn.add(sofa.group);\n// 3 Regale nebeneinander unter dem Südfenster, Front zum Raum\nconst RM = regalMaterials(THREE);\nfor (const [i, dx] of [[1,-0.603],[2,0],[3,0.603]]){\n  const r = buildRegal(THREE, RM); r.name = 'regal_'+i;\n  r.position.set(WZ_CX + dx, 0.002, IN_S - 0.135 - 0.02);\n  r.rotation.y = Math.PI;\n  wohn.add(r);\n}\n// Boxen oben auf den äußeren Regalen, leicht nach innen gedreht\n{\n  const bx = buildBoxen(THREE), top = new THREE.Box3().setFromObject(wohn.getObjectByName('regal_1')).max.y;\n  const TURN = THREE.MathUtils.degToRad(15), X = 0.603 + 0.30 - 0.105, Z = IN_S - 0.135 - 0.02;\n  // Aktivbox links (–x), Bedienfeld zeigt nach außen\n  bx.rechts.position.set(WZ_CX - X, top, Z); bx.rechts.rotation.y = Math.PI - TURN;\n  bx.links.position.set(WZ_CX + X, top, Z);  bx.links.rotation.y = Math.PI + TURN;\n  wohn.add(bx.links, bx.rechts);\n}\n// Bogenlampe in der Fensterecke, Schirm über dem Sofa – zur Raummitte versetzt\nconst lampe = buildLampe(THREE);\nconst LB = new THREE.Vector2(IN_O - 0.22, IN_S - 0.25);\nconst LT = new THREE.Vector2(IN_O - 0.95, SOFA_Z + 0.25);\nlampe.group.position.set(LB.x, 0.002, LB.y);\nlampe.group.rotation.y = Math.atan2(-(LT.y - LB.y), LT.x - LB.x);\nwohn.add(lampe.group);\n// Donut-Lampe (Ø 30 cm, H 11 cm) im linken Regal, mittleres Fach, mittig\nconst DM = {\n  koerper: new THREE.MeshPhysicalMaterial({ name:'donut_opal_orange', color:0xffa04a, roughness:0.6, clearcoat:0.2, clearcoatRoughness:0.5, emissive:0xff8a2a, emissiveIntensity:0 }),\n  sockel:  new THREE.MeshStandardMaterial({ name:'donut_sockel', color:0xee6a3e, roughness:0.5, emissive:0xd04a20, emissiveIntensity:0 }),\n  knopf:   new THREE.MeshStandardMaterial({ name:'donut_knopf', color:0x9a6a58, roughness:0.45 }),\n};\nconst donut = new THREE.Group(); donut.name = 'donutlampe';\n{\n  const V2 = (x,y) => new THREE.Vector2(x,y), dm = (n,g,m,y=0) => { const o = new THREE.Mesh(g,m); o.name = n; o.position.y = y; donut.add(o); };\n  const SB_R = 0.12, SB_H = 0.018, sp = [V2(0,0), V2(SB_R-0.006,0)];\n  for (let i = 0; i <= 12; i++){ const a = -Math.PI/2 + i/12*Math.PI; sp.push(V2(SB_R-0.006+Math.cos(a)*0.006, 0.006+Math.sin(a)*0.006+(i>6?(SB_H-0.012)*(i-6)/6:0))); }\n  sp.push(V2(0, SB_H));\n  dm('donut_sockel', new THREE.LatheGeometry(sp, 96), DM.sockel);\n  const R = 0.085, A = 0.065, B = 0.0475, CY = 0.0625, sg = v => Math.sign(v)*Math.pow(Math.abs(v), 0.8), kp = [V2(0,0.015)];\n  for (let i = 0; i <= 60; i++){ const t = -Math.PI/2 + i/60*1.35*Math.PI; kp.push(V2(R+A*sg(Math.cos(t)), CY+B*sg(Math.sin(t)))); }\n  kp.push(V2(0.018,0.078), V2(0.008,0.0755), V2(0,0.075));\n  dm('donut_koerper', new THREE.LatheGeometry(kp, 128), DM.koerper);\n  dm('donut_knopf', new THREE.CylinderGeometry(0.02, 0.022, 0.004, 40), DM.knopf, 0.077);\n}\ndonut.position.set(WZ_CX - 0.603, 0.002 + 0.42, IN_S - 0.135 - 0.02);\nwohn.add(donut);\n// Fernseher (43\") auf zwei Sofa-Kartons an der Westwand, gegenüber dem Sofa\n{\n  const tv = new THREE.Group(); tv.name = 'fernseher';\n  const K = new THREE.MeshStandardMaterial({ name:'karton', color:0xa9825a, roughness:0.9 });\n  const KT = new THREE.MeshStandardMaterial({ name:'karton_druck', color:0x3a2d22, roughness:0.9 });\n  const TVM = new THREE.MeshStandardMaterial({ name:'tv_gehaeuse', color:0x141416, roughness:0.45, metalness:0.2 });\n  const SCR = new THREE.MeshPhysicalMaterial({ name:'tv_bildschirm', color:0x050607, roughness:0.08, clearcoat:1, clearcoatRoughness:0.05 });\n  const FT = new THREE.MeshStandardMaterial({ name:'tv_fuss', color:0x9a9ea3, roughness:0.35, metalness:0.7 });\n  const x0 = RM_WZ[0] + 0.02, zc = SOFA_Z, KW = 1.15, KD = 0.5, KH = 0.38;\n  tv.add(box('karton_unten', K, x0, 0.002, zc - KW/2, x0 + KD, KH, zc + KW/2));\n  tv.add(box('karton_oben', K, x0 + 0.01, KH, zc - KW/2 + 0.015, x0 + KD + 0.005, 2*KH, zc + KW/2 + 0.01));\n  for (const y of [0.3, 0.3 + KH]) tv.add(box('karton_aufdruck', KT, x0 + KD + 0.004, y - 0.02, zc - 0.25, x0 + KD + 0.007, y, zc + 0.25));\n  const top = 2*KH, xb = x0 + 0.24, tw = 0.97, th = 0.57, fh = 0.07;\n  tv.add(box('tv_rahmen', TVM, xb, top + fh, zc - tw/2, xb + 0.045, top + fh + th, zc + tw/2));\n  tv.add(box('tv_bildschirm', SCR, xb + 0.045, top + fh + 0.012, zc - tw/2 + 0.012, xb + 0.047, top + fh + th - 0.012, zc + tw/2 - 0.012));\n  tv.add(box('tv_rueckseite', TVM, xb - 0.04, top + fh + 0.08, zc - 0.3, xb, top + fh + 0.45, zc + 0.3));\n  for (const s of [-1, 1]){\n    const f = box('tv_fuss', FT, -0.09, 0, -0.012, 0.09, 0.012, 0.012); f.position.set(xb + 0.02, top, zc + s*0.41); f.rotation.y = s*0.5; tv.add(f);\n    tv.add(box('tv_fuss_steg', FT, xb + 0.01, top, zc + s*0.41 - 0.01, xb + 0.03, top + fh, zc + s*0.41 + 0.01));\n  }\n  tv.add(box('receiver', TVM, xb + 0.06, top, zc - 0.28, xb + 0.2, top + 0.03, zc - 0.06));\n  tv.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\n  wohn.add(tv);\n}\nwohn.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\nhome.add(wohn);\n// ---------- Schlafzimmer: Tripod-Lampe auf dem Boden, Südwest-Ecke, Spot zur Raummitte ----------\nconst trip = buildTripod(THREE);\n{\n  const IN_W = RM_SZ[0], px = IN_W + 0.35, pz = IN_S - 0.35;\n  const cx = (RM_SZ[0] + RM_SZ[2])/2, cz = (RM_SZ[1] + RM_SZ[3])/2;\n  trip.group.position.set(px, 0.002, pz);\n  trip.group.rotation.y = Math.atan2(cx - px, cz - pz);\n  home.add(trip.group);\n}\n\n\nconst bedLed = { lights: [] };\n// ---------- Schlafzimmer: Bett (140 × 200, Kopfteil Ostwand, rechts an der Südwand) + Schminktisch ----------\n{\n  const sz = new THREE.Group(); sz.name = 'schlafzimmer_moebel';\n  const add = m => { sz.add(m); return m; };\n  const LE = new THREE.MeshStandardMaterial({ name:'bett_kunstleder', color:0xeee8dc, roughness:0.55 });\n  const SH = new THREE.MeshStandardMaterial({ name:'spannbetttuch', color:0x67696e, roughness:0.95 });\n  const DE = new THREE.MeshStandardMaterial({ name:'kuscheldecke', color:0x58585b, roughness:1 });\n  const KI = new THREE.MeshStandardMaterial({ name:'kissen', color:0xf4f3ef, roughness:0.9 });\n  const LK = new THREE.MeshPhysicalMaterial({ name:'lack_weiss_hochglanz', color:0xf6f6f4, roughness:0.15, clearcoat:0.8, clearcoatRoughness:0.1 });\n  const SP = new THREE.MeshStandardMaterial({ name:'spiegel_schminktisch', color:0xdfe5e8, roughness:0.03, metalness:1 });\n  const BU = new THREE.MeshStandardMaterial({ name:'spiegel_birne', color:0xffffff, roughness:0.3, emissive:0xfff1d8, emissiveIntensity:0.15 });\n  const E = RM_SZ[2], S = RM_SZ[3];\n  // Bett\n  const HB = 0.1, bx0 = E - HB - 2.0, bz0 = S - 1.46, bz1 = S - 0.01;\n  add(box('bett_sockel', M.plinth, bx0 + 0.06, 0, bz0 + 0.06, E - HB - 0.06, 0.06, bz1 - 0.06));\n  add(box('bett_rahmen', LE, bx0, 0.06, bz0, E - HB, 0.36, bz1));\n  add(box('bett_matratze', SH, bx0 + 0.02, 0.36, bz0 + 0.03, E - HB - 0.01, 0.56, bz1 - 0.03));\n  const RB = LE.clone(); RB.name = 'bett_einkerbung'; RB.emissive = new THREE.Color(0xffb070); RB.emissiveIntensity = 0;\n  const LEDM = new THREE.MeshStandardMaterial({ name:'bett_led', color:0xe8e4da, roughness:0.4, emissive:0xffb070, emissiveIntensity:0 });\n  const RY0 = 0.9, RY1 = 1.0, CAP = 0.06;\n  // Kopfteil mit durchgehender Einkerbung oben; LED-Streifen an der Unterseite der oberen Leiste (innen)\n  add(box('bett_kopfteil', LE, E - HB, 0.06, bz0, E - 0.002, RY0, bz1));\n  add(box('bett_einkerbung_rueckwand', RB, E - 0.035, RY0, bz0 + CAP, E - 0.002, RY1, bz1 - CAP));\n  add(box('bett_kopfteil_oben', LE, E - HB - 0.025, RY1, bz0, E - 0.002, 1.13, bz1));\n  for (const [z0, z1] of [[bz0, bz0 + CAP], [bz1 - CAP, bz1]]) add(box('bett_kopfteil_wange', LE, E - HB, RY0, z0, E - 0.002, RY1, z1));\n  add(box('bett_led_streifen', LEDM, E - HB + 0.012, RY1 - 0.007, bz0 + CAP + 0.01, E - 0.045, RY1, bz1 - CAP - 0.01));\n  bedLed.M = LEDM; bedLed.R = RB;\n  for (const f of [0.14, 0.38, 0.62, 0.86]){ const l = new THREE.PointLight(0xffb070, 0, 1.6, 2); l.name = 'bett_led_licht'; l.position.set(E - HB - 0.02, RY1 - 0.012, bz0 + (bz1 - bz0) * f); sz.add(l); bedLed.lights.push(l); }\n  bedLed.anchor = new THREE.Object3D(); bedLed.anchor.position.set(E - HB, RY0, (bz0 + bz1) / 2); sz.add(bedLed.anchor);\n  for (const y of [0.6, 0.72, 0.84]) for (let i = 0; i < 11; i++){\n    const b = new THREE.Mesh(new THREE.SphereGeometry(0.009, 10, 8), LE); b.name = 'bett_knopf';\n    b.position.set(E - HB - 0.002, y, bz0 + 0.1 + i*(bz1 - bz0 - 0.2)/10 + (y === 0.72 ? 0.06 : 0)); if (b.position.z < bz1 - 0.05) add(b);\n  }\n  const pil = add(new THREE.Mesh(new THREE.SphereGeometry(1, 32, 16), KI)); pil.name = 'kopfkissen';\n  pil.scale.set(0.2, 0.07, 0.34); pil.position.set(E - HB - 0.24, 0.6, bz0 + 0.5);\n  add(box('decke_oben', DE, bx0 + 0.05, 0.56, bz0 - 0.02, E - HB - 0.5, 0.6, bz1 - 0.02));\n  add(box('decke_seite', DE, bx0 + 0.05, 0.3, bz0 - 0.03, E - HB - 0.5, 0.6, bz0 - 0.01));\n  add(box('decke_fuss', DE, bx0 + 0.03, 0.32, bz0 - 0.02, bx0 + 0.05, 0.6, bz1 - 0.02));\n  // Schminktisch an der Ostwand zwischen Heizkörper und Bett, Schubladen links (Norden)\n  const D = 0.45, x1 = E, x0 = E - D, z0 = RM_SZ[1] + 1.0, z1 = z0 + 1.1, H = 0.76, PW = 0.4, T = 0.018;\n  add(box('schminktisch_platte', LK, x0, H - 0.025, z0, x1, H, z1));\n  add(box('schminktisch_korpus', LK, x0, 0.04, z0, x1, H - 0.025, z0 + PW));\n  add(box('schminktisch_sockel', LK, x0 + 0.02, 0, z0 + 0.02, x1, 0.04, z0 + PW - 0.02));\n  add(box('schminktisch_seite', LK, x0, 0, z1 - T, x1, H - 0.025, z1));\n  add(box('schminktisch_zarge', LK, x0, H - 0.15, z0 + PW, x1, H - 0.025, z1 - T));\n  add(box('schminktisch_rueckwand', LK, x1 - 0.015, 0.04, z0 + PW, x1, H - 0.15, z1 - T));\n  const fronts = [[0.05, 0.215], [0.22, 0.385], [0.39, 0.555], [0.56, H - 0.03]];\n  fronts.forEach(([a, b], i) => add(box('schublade_' + (i+1), LK, x0 - 0.012, a, z0 + 0.004, x0, b, z0 + PW - 0.004)));\n  add(box('schublade_mitte', LK, x0 - 0.012, H - 0.145, z0 + PW + 0.004, x0, H - 0.03, z1 - T - 0.004));\n  // Spiegel mit Glühbirnen, auf der Platte an die Wand gelehnt\n  const mz0 = z0 + 0.17, mz1 = z0 + 0.97, my0 = H, my1 = H + 0.62;\n  const mir = new THREE.Group(); mir.name = 'schminkspiegel';\n  mir.add(box('schminkspiegel_rahmen', LK, -0.035, 0, mz0, 0, my1 - my0, mz1));\n  mir.add(box('schminkspiegel_glas', SP, -0.037, 0.06, mz0 + 0.06, -0.035, my1 - my0 - 0.06, mz1 - 0.06));\n  const bulb = (y, z) => { const b = new THREE.Mesh(new THREE.SphereGeometry(0.021, 16, 12), BU); b.name = 'schminkspiegel_birne'; b.position.set(-0.045, y, z); mir.add(b); };\n  for (let i = 0; i < 8; i++) bulb(my1 - my0 - 0.03, mz0 + 0.04 + i*(mz1 - mz0 - 0.08)/7);\n  for (let i = 1; i < 5; i++){ const y = my1 - my0 - 0.03 - i*0.13; bulb(y, mz0 + 0.035); bulb(y, mz1 - 0.035); }\n  mir.position.set(x1 - 0.1, my0, 0); mir.rotation.z = -0.08; sz.add(mir);\n  sz.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\n  home.add(sz);\n}\n// ---------- Mauervorsprung Wohnzimmer (41,5 × 40 cm, Ecke Tür-/Außenwand) ----------\n{\n  const mat = Array(6).fill(M.wall); mat[2] = M.cap;\n  walls.add(box('wohnzimmer_vorsprung', mat, IN_O - 0.415, 0, RM_WZ[1], IN_O + 0.001, HI, RM_WZ[1] + 0.40, 1.5));\n}\n// ---------- Küche: Fliesenspiegel an der Wand zum Bad, ab Fensterunterkante 60 cm hoch ----------\nconst tileMat = new THREE.MeshStandardMaterial({ name:'interior_tiles', color:0xf3f2ee, roughness:0.2 });\n{\n  const x0 = RM_KU[0], z0 = 0, z1 = Z_SCH0;\n  const t = box('kueche_fliesen', tileMat, x0, WIN_B, z0, x0 + 0.008, WIN_B + 0.6, z1, 1.0);\n  // um die Ecke auf die Fensterwand, bis an die Fensterlaibung\n  const winW = KU_WIN.c - KU_WIN.w/2;\n  const t2 = box('kueche_fliesen_fensterwand', tileMat, x0 + 0.008, WIN_B, z0, winW, WIN_B + 0.6, z0 + 0.008, 1.0);\n  t.receiveShadow = t2.receiveShadow = true; home.add(t, t2);\n}\n// ---------- Heizkörper ----------\nconst radMat = new THREE.MeshStandardMaterial({ name:'heizkoerper_weiss', color:0xf4f3ef, roughness:0.4, metalness:0.1 });\nfunction makeRadiator(name, len){\n  const g = new THREE.Group(); g.name = name;\n  const y0 = 0.15, y1 = 0.75, n = Math.max(3, Math.round(len/0.05)), st = len/n;\n  for (let i = 0; i < n; i++){ const x = -len/2 + st*(i+0.5); g.add(box(name+'_glied'+i, radMat, x-st*0.38, y0, -0.035, x+st*0.38, y1, 0.035)); }\n  g.add(box(name+'_sammler_o', radMat, -len/2, y1-0.05, -0.02, len/2, y1-0.01, 0.02));\n  g.add(box(name+'_sammler_u', radMat, -len/2, y0+0.01, -0.02, len/2, y0+0.05, 0.02));\n  const v = new THREE.Mesh(new THREE.CylinderGeometry(0.018, 0.018, 0.08, 20), radMat); v.name = name+'_ventil'; v.position.set(len/2+0.03, y1-0.04, 0); g.add(v);\n  const p = new THREE.Mesh(new THREE.CylinderGeometry(0.01, 0.01, y0, 12), M.metal); p.name = name+'_rohr'; p.position.set(-len/2+0.02, y0/2, 0); g.add(p);\n  g.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\n  return g;\n}\n{\n  // Schlafzimmer: an der Mittelwand, 41–86 cm von der Türwand\n  const h1 = makeRadiator('heizkoerper_schlafzimmer', 0.45);\n  h1.position.set(RM_SZ[2] - 0.075, 0, RM_SZ[1] + 0.41 + 0.225); h1.rotation.y = Math.PI/2;\n  // Wohnzimmer: an der Türwand direkt neben der Tür, Richtung Mittelwand\n  const h2 = makeRadiator('heizkoerper_wohnzimmer', 0.48);\n  h2.position.set(WZ_DOOR.c - WZ_DOOR.w/2 - 0.02 - 0.24, 0, RM_WZ[1] + 0.075);\n  home.add(h1, h2);\n}\n\n// ---------- Bad (nach Foto): Wanne rechts, WC + Waschtisch links, Fliesen ----------\n{\n  const bad = new THREE.Group(); bad.name = 'bad';\n  const [W, N, E, SZ] = RM_BAD, TT = 0.008, SCX = X_SCH, SCZ = Z_SCH0;\n  const add = m => { bad.add(m); return m; };\n  const bx = (n, mat, ...a) => add(box(n, mat, ...a));\n  function cyl(n, mat, r, h, x, y, z, axis, r2){\n    const m = new THREE.Mesh(new THREE.CylinderGeometry(r, r2 ?? r, h, 28), mat); m.name = n; m.position.set(x, y, z);\n    if (axis === 'x') m.rotation.z = Math.PI/2; if (axis === 'z') m.rotation.x = Math.PI/2; return add(m);\n  }\n  function tileTex(px, n, base, grout, veins, seed){\n    const c = document.createElement('canvas'); c.width = c.height = px*n; const g = c.getContext('2d');\n    g.fillStyle = base; g.fillRect(0, 0, c.width, c.height);\n    const rnd = () => (seed = (seed*16807) % 2147483647) / 2147483647;\n    g.lineWidth = 1.4;\n    for (let i = 0; i < veins; i++){\n      g.strokeStyle = 'rgba(125,127,132,' + (0.05 + rnd()*0.07) + ')'; g.beginPath();\n      let x = rnd()*c.width, y = rnd()*c.height; g.moveTo(x, y);\n      for (let k = 0; k < 4; k++){ const cx = x + (rnd()-.5)*px, cy = y + (rnd()-.5)*px; x += (rnd()-.5)*px*1.3; y += (rnd()-.5)*px*1.3; g.quadraticCurveTo(cx, cy, x, y); }\n      g.stroke();\n    }\n    g.fillStyle = grout; const gw = Math.max(3, px/32);\n    for (let i = 0; i < n; i++){ g.fillRect(i*px, 0, gw, c.height); g.fillRect(0, i*px, c.width, gw); }\n    const t = new THREE.CanvasTexture(c); t.wrapS = t.wrapT = THREE.RepeatWrapping; t.colorSpace = THREE.SRGBColorSpace; t.anisotropy = 8; return t;\n  }\n  const BM = {\n    wand:   new THREE.MeshStandardMaterial({ name:'bad_wandfliesen', map: tileTex(128, 4, '#f3f3f1', '#c6c6c2', 46, 11), roughness:0.16 }),\n    boden:  new THREE.MeshStandardMaterial({ name:'bad_bodenfliesen', map: tileTex(128, 4, '#efeeeb', '#a6a5a0', 34, 29), roughness:0.32 }),\n    email:  new THREE.MeshPhysicalMaterial({ name:'sanitaer_email', color:0xfbfbfa, roughness:0.1, clearcoat:1, clearcoatRoughness:0.06 }),\n    chrom:  new THREE.MeshStandardMaterial({ name:'chrom', color:0xe6e8ea, roughness:0.08, metalness:1 }),\n    spiegel:new THREE.MeshStandardMaterial({ name:'spiegel', color:0xe2e8ec, roughness:0.02, metalness:1 }),\n    glas:   new THREE.MeshStandardMaterial({ name:'glasablage', color:0xcfe6e0, roughness:0.05, transparent:true, opacity:0.45 }),\n    dekor:  new THREE.MeshStandardMaterial({ name:'dekorfliese', color:0x9fb0c2, roughness:0.2 }),\n    plast:  new THREE.MeshStandardMaterial({ name:'wc_sitz', color:0xf7f7f5, roughness:0.3 }),\n  };\n  const emailIn = BM.email.clone(); emailIn.name = 'sanitaer_email_innen'; emailIn.side = THREE.BackSide;\n  const emailDS = BM.email.clone(); emailDS.name = 'sanitaer_email_ds'; emailDS.side = THREE.DoubleSide;\n  // Milchglas im Badfenster\n  const fg = windows.getObjectByName('fenster_bad_glas');\n  if (fg) fg.material = new THREE.MeshStandardMaterial({ name:'milchglas', color:0xf2f5f5, roughness:0.7, transparent:true, opacity:0.85 });\n\n  // Boden + Wandfliesen (halbhoch 1,25 m, um die Wanne 2,05 m)\n  const HT = 1.25, FT = 2.05;\n  const TW = 0.78, TL = 1.75, LEDGE = 0.2, TX0 = E - TW, TZ1 = N + LEDGE + TL;\n  const wxc = 2.25, wl = wxc - 0.4, wr = wxc + 0.4, dxc = BAD_DOOR.c, DW = BAD_DOOR.w;\n  // Vorwand an der Fensterwand: von der Westwand bis ans Fenster, 15 cm vorgezogen\n  const VD = 0.15;\n  { const vm = Array(6).fill(M.wall); vm[2] = M.cap; walls.add(box('bad_vorwand', vm, W, 0, N, wl, HI, N + VD, 1.5)); }\n  bx('bad_boden', BM.boden, W, 0, N, E, 0.008, SZ, 0.8);\n  bx('bad_fliesen_west', BM.wand, W, 0, N + VD + TT, W + TT, HT, SZ, 0.6);\n  bx('bad_fliesen_vorwand', BM.wand, W, 0, N + VD, wl, HT, N + VD + TT, 0.6);\n  bx('bad_fliesen_vorwand_seite', BM.wand, wl - 0.001, 0, N, wl + TT, HT, N + VD + TT, 0.6);\n  bx('bad_fliesen_nord_2', BM.wand, wl, 0, N, wr, WIN_B - 0.03, N + TT, 0.6);\n  bx('bad_fliesen_nord_3', BM.wand, wr, 0, N, E - TT, FT, N + TT, 0.6);\n  bx('bad_fliesen_ost_1', BM.wand, E - TT, 0, N, E, FT, TZ1, 0.6);\n  bx('bad_fliesen_ost_2', BM.wand, E - TT, 0, TZ1, E, HT, SCZ, 0.6);\n  bx('bad_fliesen_schacht_n', BM.wand, SCX - TT, 0, SCZ - TT, E - TT, HT, SCZ, 0.6);\n  bx('bad_fliesen_schacht_w', BM.wand, SCX - TT, 0, SCZ, SCX, HT, SZ, 0.6);\n  bx('bad_fliesen_sued_1', BM.wand, W + TT, 0, SZ - TT, dxc - DW/2, HT, SZ, 0.6);\n  bx('bad_fliesen_sued_2', BM.wand, dxc + DW/2, 0, SZ - TT, SCX - TT, HT, SZ, 0.6);\n  for (const [y, z] of [[1.15, N + 0.75], [1.72, N + 0.55]]){\n    const d = bx('bad_dekorfliese', BM.dekor, -0.001, -0.04, -0.04, 0.001, 0.04, 0.04);\n    d.rotation.x = Math.PI/4; d.position.set(E - TT - 0.001, y, z);\n  }\n\n  // Badewanne, eingefliest, mit Ablage am Kopfende\n  bx('wanne_ablage', BM.wand, TX0, 0.008, N + TT, E - TT, 0.6, N + LEDGE, 0.6);\n  bx('wanne_schuerze', BM.wand, TX0, 0.008, N + LEDGE, TX0 + 0.03, 0.565, TZ1, 0.6);\n  bx('wanne_schuerze_ende', BM.wand, TX0, 0.008, TZ1 - 0.03, E - TT, 0.565, TZ1, 0.6);\n  function rr(p, w, d, r){ const x = -w/2, y = -d/2;\n    p.moveTo(x + r, y); p.lineTo(x + w - r, y); p.quadraticCurveTo(x + w, y, x + w, y + r); p.lineTo(x + w, y + d - r);\n    p.quadraticCurveTo(x + w, y + d, x + w - r, y + d); p.lineTo(x + r, y + d); p.quadraticCurveTo(x, y + d, x, y + d - r);\n    p.lineTo(x, y + r); p.quadraticCurveTo(x, y, x + r, y); return p; }\n  const tcx = E - TT/2 - TW/2 + TT/2, tcz = N + LEDGE + TL/2, IW = TW - 0.14, IL = TL - 0.18, IR = 0.22;\n  const rimS = rr(new THREE.Shape(), TW - TT, TL, 0.02); rimS.holes.push(rr(new THREE.Path(), IW, IL, IR));\n  const rimG = new THREE.ExtrudeGeometry(rimS, { depth:0.035, bevelEnabled:false, curveSegments:16 });\n  rimG.rotateX(-Math.PI/2); rimG.translate(tcx, 0.565, tcz);\n  add(new THREE.Mesh(rimG, BM.email)).name = 'wanne_rand';\n  const basG = new THREE.ExtrudeGeometry(rr(new THREE.Shape(), IW, IL, IR), { depth:0.41, bevelEnabled:false, curveSegments:16 });\n  basG.rotateX(-Math.PI/2); basG.translate(tcx, 0.16, tcz);\n  add(new THREE.Mesh(basG, emailIn)).name = 'wanne_innen';\n  const mz0 = TZ1 - 0.35;\n  cyl('wanne_ablauf', BM.chrom, 0.024, 0.004, tcx, 0.163, mz0 - 0.05);\n  // Wannenarmatur an der Ostwand\n  cyl('armatur_koerper', BM.chrom, 0.024, 0.2, E - 0.075, 0.8, mz0, 'z');\n  for (const s of [-1, 1]){\n    cyl('armatur_anschluss', BM.chrom, 0.01, 0.075, E - 0.04, 0.8, mz0 + s*0.08, 'x');\n    cyl('armatur_rosette', BM.chrom, 0.03, 0.008, E - TT - 0.004, 0.8, mz0 + s*0.08, 'x');\n  }\n  cyl('armatur_auslauf', BM.chrom, 0.012, 0.11, E - 0.135, 0.775, mz0, 'x');\n  bx('armatur_hebel', BM.chrom, E - 0.085, 0.82, mz0 - 0.012, E - 0.03, 0.835, mz0 + 0.012);\n  // Duschstange + Handbrause + Schlauch\n  const rz = TZ1 - 0.85, rx = E - 0.045;\n  cyl('duschstange', BM.chrom, 0.012, 0.95, rx, 1.6, rz);\n  for (const y of [1.13, 2.07]){ cyl('duschstange_halter', BM.chrom, 0.01, 0.045, E - 0.022, y, rz, 'x'); cyl('duschstange_rosette', BM.chrom, 0.022, 0.01, E - TT - 0.005, y, rz, 'x'); }\n  bx('duschstange_schieber', BM.chrom, rx - 0.035, 1.68, rz - 0.022, rx + 0.02, 1.76, rz + 0.022);\n  const brause = new THREE.Group(); brause.name = 'handbrause'; brause.position.set(rx - 0.06, 1.72, rz); brause.rotation.z = 0.5;\n  { const h = new THREE.Mesh(new THREE.CylinderGeometry(0.013, 0.011, 0.2, 20), BM.chrom); h.name = 'handbrause_griff'; brause.add(h);\n    const k = new THREE.Mesh(new THREE.CylinderGeometry(0.045, 0.03, 0.025, 32), BM.chrom); k.name = 'handbrause_kopf'; k.position.y = 0.11; k.rotation.z = Math.PI/2 - 0.3; brause.add(k); }\n  add(brause);\n  const hb0 = new THREE.Vector3(rx - 0.06 + 0.1*Math.sin(0.5), 1.72 - 0.1*Math.cos(0.5), rz);\n  const hose = new THREE.CatmullRomCurve3([hb0, new THREE.Vector3(E - 0.09, 1.2, rz + 0.08), new THREE.Vector3(E - 0.2, 0.7, (rz + mz0)/2 + 0.05), new THREE.Vector3(E - 0.12, 0.66, mz0 - 0.02), new THREE.Vector3(E - 0.085, 0.77, mz0 - 0.03)]);\n  add(new THREE.Mesh(new THREE.TubeGeometry(hose, 80, 0.007, 8), BM.chrom)).name = 'brauseschlauch';\n  // Haltegriff\n  const gz = TZ1 - 0.6;\n  cyl('haltegriff', BM.chrom, 0.013, 0.36, E - 0.065, 1.12, gz);\n  for (const y of [0.96, 1.28]) cyl('haltegriff_stuetze', BM.chrom, 0.012, 0.06, E - 0.035, y, gz, 'x');\n  // Vorhangstange oben\n  cyl('vorhangstange', BM.chrom, 0.01, TL - 0.2, E - 0.09, 2.15, N + LEDGE + TL/2 - 0.1, 'z');\n  cyl('vorhangstange_halter', BM.chrom, 0.009, 0.09, E - 0.045, 2.15, N + LEDGE + 0.05, 'x');\n\n  // WC an der Westwand (Blick zur Wanne), Aufputz-Spülkasten\n  const wc = new THREE.Group(); wc.name = 'wc'; wc.position.set(W + TT, 0, N + VD + 0.45); wc.rotation.y = Math.PI/2;\n  { const wa = m => { wc.add(m); return m; };\n    wa(box('wc_sockel_hinten', BM.email, -0.13, 0.008, 0, 0.13, 0.38, 0.22));\n    const p = new THREE.Mesh(new THREE.CylinderGeometry(0.15, 0.115, 0.32, 40), BM.email); p.name = 'wc_fuss'; p.scale.z = 1.3; p.position.set(0, 0.168, 0.37); wa(p);\n    const b = new THREE.Mesh(new THREE.CylinderGeometry(0.185, 0.15, 0.08, 48), BM.email); b.name = 'wc_becken'; b.scale.z = 1.3; b.position.set(0, 0.365, 0.41); wa(b);\n    const s = new THREE.Mesh(new THREE.CylinderGeometry(0.185, 0.185, 0.02, 48), BM.plast); s.name = 'wc_sitz'; s.scale.z = 1.3; s.position.set(0, 0.415, 0.41); wa(s);\n    const d = new THREE.Mesh(new THREE.CylinderGeometry(0.178, 0.178, 0.022, 48), BM.plast); d.name = 'wc_deckel'; d.scale.z = 1.28; d.position.set(0, 0.436, 0.41); wa(d);\n    wa(box('wc_scharnier', BM.plast, -0.1, 0.405, 0.15, 0.1, 0.44, 0.2));\n    wa(box('wc_spuelkasten', BM.email, -0.2, 0.8, 0, 0.2, 1.2, 0.15));\n    const t = new THREE.Mesh(new THREE.CylinderGeometry(0.02, 0.02, 0.02, 28), BM.email); t.name = 'wc_spueltaste'; t.position.set(-0.12, 1.21, 0.09); wa(t);\n    const r = new THREE.Mesh(new THREE.CylinderGeometry(0.025, 0.025, 0.4, 28), BM.email); r.name = 'wc_spuelrohr'; r.position.set(0, 0.6, 0.08); wa(r); }\n  add(wc);\n  // Wasserzähler + Ventil an der Vorwand, Papierhalter unter dem Fenster\n  cyl('bad_wasserzaehler', BM.chrom, 0.055, 0.03, wl - 0.13, 0.98, N + VD + TT + 0.015, 'z');\n  cyl('bad_wasserzaehler_glas', BM.plast, 0.035, 0.034, wl - 0.13, 0.98, N + VD + TT + 0.017, 'z');\n  cyl('bad_ventil', BM.chrom, 0.028, 0.05, wl - 0.13, 1.2, N + VD + TT + 0.025, 'z');\n  bx('papierhalter', BM.chrom, wxc - 0.02, 0.62, N + TT, wxc + 0.12, 0.7, N + 0.08);\n\n  // Waschtisch an der Westwand, Spiegel + Glasablagen darüber\n  const bz = N + 1.35, BR = 0.3, SX = 0.87, RY = 0.85, bcx = W + 0.2;\n  { const o = new THREE.Mesh(new THREE.CylinderGeometry(BR, 0.2, 0.17, 48, 1, true), emailDS); o.name = 'waschbecken_aussen'; o.scale.x = SX; o.position.set(bcx, RY - 0.085, bz); add(o);\n    const f = new THREE.Mesh(new THREE.CircleGeometry(0.2, 48), BM.email); f.name = 'waschbecken_unten'; f.rotation.x = Math.PI/2; f.scale.x = SX; f.position.set(bcx, RY - 0.17, bz); add(f);\n    const r = new THREE.Mesh(new THREE.RingGeometry(0.235, BR, 48), BM.email); r.name = 'waschbecken_rand'; r.rotation.x = -Math.PI/2; r.scale.x = SX; r.position.set(bcx, RY, bz); add(r);\n    const i = new THREE.Mesh(new THREE.SphereGeometry(0.235, 48, 16, 0, Math.PI*2, Math.PI/2, Math.PI/2), emailDS); i.name = 'waschbecken_innen'; i.scale.set(SX, 0.55, 1); i.position.set(bcx, RY, bz); add(i); }\n  cyl('waschtisch_armatur', BM.chrom, 0.022, 0.12, W + 0.075, RY + 0.06, bz);\n  { const s = cyl('waschtisch_auslauf', BM.chrom, 0.011, 0.13, W + 0.13, RY + 0.1, bz, 'x'); s.rotation.z = Math.PI/2 + 0.25; }\n  bx('waschtisch_hebel', BM.chrom, W + 0.04, RY + 0.12, bz - 0.012, W + 0.1, RY + 0.135, bz + 0.012);\n  cyl('siphon', BM.chrom, 0.02, 0.2, bcx, 0.58, bz);\n  cyl('siphon_rohr', BM.chrom, 0.018, 0.2, W + 0.1, 0.48, bz, 'x');\n  cyl('siphon_rosette', BM.chrom, 0.035, 0.01, W + TT + 0.005, 0.48, bz, 'x');\n  bx('spiegel', BM.spiegel, W + TT, 1.34, bz - 0.3, W + TT + 0.006, 2.0, bz + 0.3);\n  for (const y of [1.3, 1.05]){\n    bx('glasablage', BM.glas, W + TT, y, bz - 0.3, W + 0.14, y + 0.008, bz + 0.3);\n    for (const s of [-1, 1]) bx('glasablage_halter', BM.chrom, W + TT, y - 0.012, bz + s*0.3 - 0.012, W + 0.06, y + 0.016, bz + s*0.3 + 0.012);\n  }\n\n  bad.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\n  bad.getObjectByName('bad_boden').castShadow = false;\n  home.add(bad);\n}\n\n\nstage.setObject(home);\n\n// ---------- Schatten: enger Frustum, 4096er Map, harter PCF → scharf & ohne Flackern ----------\nconst renderer = stage._renderer, scene = stage._scene, key = stage._key;\nrenderer.shadowMap.type = THREE.PCFShadowMap;\nconst hb = new THREE.Box3().setFromObject(home), hc = hb.getCenter(new THREE.Vector3()), hs = hb.getSize(new THREE.Vector3());\nconst sunDir = new THREE.Vector3(4, 7, 5).normalize();\nkey.position.copy(hc).addScaledVector(sunDir, 30);\nkey.target.position.copy(hc); scene.add(key.target);\nconst half = Math.max(hs.x, hs.z) * 0.62;\nObject.assign(key.shadow.camera, { left:-half, right:half, top:half, bottom:-half, near:1, far:60 });\nkey.shadow.camera.updateProjectionMatrix();\nkey.shadow.mapSize.set(2048, 2048);\nkey.shadow.bias = -0.0004; key.shadow.normalBias = 0.015;\nif (key.shadow.map){ key.shadow.map.dispose(); key.shadow.map = null; }\nrenderer.toneMapping = THREE.ACESFilmicToneMapping;\nif (stage._ground) stage._ground.visible = false;\nconst hemi = scene.children.find(o => o.isHemisphereLight), hemiBase = hemi ? hemi.intensity : 0;\nconst fillL = scene.children.find(o => o.isDirectionalLight && o !== key), fillBase = fillL ? fillL.intensity : 0;\nconst ENV = 0.9;\nlet envK = 1, hemiK = 1, fillK = 1, expK = 1;\n// Innenraum: Himmels-/Fülllicht dringt nicht durch die Decke → nur noch Sonne + Umgebung durch die Fenster\nfunction applyInterior(o){\n  if (hemi) hemi.intensity = hemiBase * hemiK * (1 - 0.85*o);\n  if (fillL) fillL.intensity = fillBase * fillK * (1 - o);\n  scene.environmentIntensity = ENV * envK * (1 - 0.7*o);\n  renderer.toneMappingExposure = (1 + 0.45*o) * expK;\n}\n\n// ---------- Decke (blendet ein, sobald man in einem Raum steht) ----------\nconst ceilMat = new THREE.MeshStandardMaterial({ name:'decke', color:0xf4f2ee, roughness:0.95, transparent:true, opacity:0, depthWrite:false });\nconst ceiling = new THREE.Group(); ceiling.name = 'decke';\nceiling.add(box('decke_nord', ceilMat, X_FL - TE, H, -TE, X_E + TE, H+0.04, ZST), box('decke_sued', ceilMat, -TE, H, ZST, X_E + TE, H+0.04, Z_S + TE));\nceiling.traverse(o => { if (o.isMesh){ o.receiveShadow = true; o.castShadow = true; } }); ceiling.visible = false;\nhome.add(ceiling);\nfunction setCeil(o){\n  ceilMat.opacity = o;\n  if (ceiling.visible !== (o > 0.001)){ ceiling.visible = o > 0.001; ptDirty = true; }\n  const solid = o >= 0.999;\n  if (ceilMat.transparent === solid){ ceilMat.transparent = !solid; ceilMat.depthWrite = solid; ceilMat.needsUpdate = true; }\n  if (!ptOn) applyInterior(o);\n}\n\n// ---------- Bogenlampe: Licht an/aus ----------\nhome.updateMatrixWorld(true);\nconst bulb = lampe.group.getObjectByName('leuchtmittel');\nconst bp = bulb.getWorldPosition(new THREE.Vector3());\nconst lampSpot = new THREE.SpotLight(0xffd6a0, 0, 0, 1.0, 0.6, 2);\nlampSpot.position.copy(bp).add(new THREE.Vector3(0, -0.035, 0));\nlampSpot.target.position.set(bp.x, 0, bp.z);\nlampSpot.castShadow = true;\nlampSpot.shadow.mapSize.set(1024, 1024);\nlampSpot.shadow.bias = -0.0005; lampSpot.shadow.normalBias = 0.02;\nlampSpot.shadow.camera.near = 0.05; lampSpot.shadow.camera.far = 8;\nconst lampFill = new THREE.PointLight(0xffd6a0, 0, 7, 2);\nlampFill.position.copy(bp);\nscene.add(lampSpot, lampSpot.target, lampFill);\nconst schirm = lampe.group.getObjectByName('schirm').material;\nschirm.emissive = new THREE.Color(0xffe2b8);\nconst lampBtn = document.getElementById('lamp');\nlet lampOn = false, lampLvl = 0, lampAnim = 0;\nlet rasterEnv = null, ptEnv = null;\nlet tracer = null, ptOn = false, ptDirty = true, inRoom = false, stillSince = 0;\nconst LAMP_KEY = 'wohnung-bogenlampe-farbe';\nlet lampK = 1;\nconst lampSw = document.getElementById('lampSw');\nfunction setLampColor(hex){\n  const c = new THREE.Color(hex), s = c.clone().lerp(new THREE.Color(0xffffff), 0.3);\n  lampSpot.color.copy(c); lampFill.color.copy(c);\n  if (bulb.material.emissive) bulb.material.emissive.copy(c);\n  schirm.emissive.copy(s);\n  try { localStorage.setItem(LAMP_KEY, hex); } catch(e){}\n  document.querySelector('#lamp i').style.cssText = lampOn ? `background:${hex};box-shadow:0 0 10px 3px ${hex}99` : '';\n  if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); }\n}\n// ---------- Licht-Picker: Hell (Lichtton + Helligkeit) oder Farbe (Farbkreis) ----------\nconst K_COLD = 8000, K_WARM = 2000;\nfunction kelvinHex(k){\n  const t = k/100; let r, g, b;\n  if (t <= 66){ r = 255; g = 99.4708025861*Math.log(t) - 161.1195681661; b = t <= 19 ? 0 : 138.5177312231*Math.log(t-10) - 305.0447927307; }\n  else { r = 329.698727446*Math.pow(t-60, -0.1332047592); g = 288.1221695283*Math.pow(t-60, -0.0755148492); b = 255; }\n  const c = v => Math.round(Math.max(0, Math.min(255, v))).toString(16).padStart(2, '0');\n  return '#' + c(r) + c(g) + c(b);\n}\nconst warmK = w => Math.round(K_COLD - w/100*(K_COLD - K_WARM));\nfunction hsvRGB(h, s, v){ const f = n => { const k = (n + h/60) % 6; return v - v*s*Math.max(0, Math.min(k, 4-k, 1)); }; return [f(5), f(3), f(1)]; }\nconst rgbHex = a => '#' + a.map(x => Math.round(x*255).toString(16).padStart(2, '0')).join('');\nfunction makePicker(sw, key, def, dimIn, onChange){\n  let st = { mode: 'white', warm: 70, h: 30, s: 0.6, ...def };\n  try { Object.assign(st, JSON.parse(localStorage.getItem(key) || 'null') || {}); } catch(e){}\n  const pop = document.createElement('div'); pop.className = 'lpick';\n  pop.innerHTML = '<div class=\"lp-seg\"><button data-m=\"white\">Hell<\u002Fbutton><button data-m=\"color\">Farbe<\u002Fbutton><\u002Fdiv>'\n    + '<div class=\"lp-row lp-w\"><div><span>Lichtton<\u002Fspan><output class=\"lp-kv\"><\u002Foutput><\u002Fdiv><input class=\"lp-temp\" type=\"range\" min=\"0\" max=\"100\" step=\"1\"><small><span>Steril<\u002Fspan><span>Warm<\u002Fspan><\u002Fsmall><\u002Fdiv>'\n    + '<div class=\"lp-c\"><div class=\"lp-wheel\"><canvas width=\"360\" height=\"360\"><\u002Fcanvas><i><\u002Fi><\u002Fdiv><\u002Fdiv>'\n    + '<div class=\"lp-row\"><div><span>Helligkeit<\u002Fspan><output class=\"lp-bv\"><\u002Foutput><\u002Fdiv><input class=\"lp-dim\" type=\"range\" min=\"10\" max=\"200\" step=\"5\"><\u002Fdiv><button class=\"lp-done\">Fertig<\u002Fbutton>';\n  document.body.appendChild(pop);\n  const $ = s => pop.querySelector(s), temp = $('.lp-temp'), bri = $('.lp-dim'), bv = $('.lp-bv'), dot = $('.lp-wheel i'), wheel = $('.lp-wheel');\n  temp.style.background = `linear-gradient(90deg,${kelvinHex(K_COLD)},${kelvinHex(4500)},${kelvinHex(3000)},${kelvinHex(K_WARM)})`;\n  const cv = $('canvas'), ctx = cv.getContext('2d'), img = ctx.createImageData(360, 360), R = 180;\n  for (let y = 0; y < 360; y++) for (let x = 0; x < 360; x++){\n    const dx = x + .5 - R, dy = y + .5 - R, d = Math.hypot(dx, dy) / R, i = (y*360 + x)*4;\n    const rgb = hsvRGB((Math.atan2(dy, dx)*180/Math.PI + 360) % 360, 1, 1);\n    img.data[i] = rgb[0]*255; img.data[i+1] = rgb[1]*255; img.data[i+2] = rgb[2]*255;\n    img.data[i+3] = 255 * Math.max(0, Math.min(1, (1 - d) * R, (d - 0.72) * R));\n  }\n  ctx.putImageData(img, 0, 0);\n  const hex = () => st.mode === 'white' ? kelvinHex(warmK(st.warm)) : rgbHex(hsvRGB(st.h, 1, 1));\n  function update(fire = true){\n    pop.querySelectorAll('.lp-seg button').forEach(b => b.classList.toggle('on', b.dataset.m === st.mode));\n    $('.lp-w').style.display = st.mode === 'white' ? '' : 'none';\n    $('.lp-c').style.display = st.mode === 'color' ? '' : 'none';\n    temp.value = st.warm; $('.lp-kv').textContent = warmK(st.warm) + ' K';\n    const a = st.h*Math.PI/180;\n    dot.style.left = (90 + Math.cos(a)*77) + 'px'; dot.style.top = (90 + Math.sin(a)*77) + 'px';\n    const h = hex(); dot.style.background = h; sw.style.background = h;\n    try { localStorage.setItem(key, JSON.stringify(st)); } catch(e){}\n    if (fire) onChange(h);\n  }\n  pop.querySelectorAll('.lp-seg button').forEach(b => b.onclick = () => { st.mode = b.dataset.m; update(); });\n  temp.oninput = () => { st.warm = +temp.value; update(); };\n  const pick = e => { const r = wheel.getBoundingClientRect(), dx = e.clientX - r.left - 90, dy = e.clientY - r.top - 90;\n    st.h = (Math.atan2(dy, dx)*180/Math.PI + 360) % 360; update(); };\n  wheel.onpointerdown = e => { const r = wheel.getBoundingClientRect(), d = Math.hypot(e.clientX - r.left - 90, e.clientY - r.top - 90);\n    if (d < 58 || d > 94) return; wheel.setPointerCapture(e.pointerId); pick(e); };\n  wheel.onpointermove = e => { if (wheel.hasPointerCapture(e.pointerId)) pick(e); };\n  const syncBri = () => { bri.value = dimIn.value; bv.textContent = dimIn.value + '%'; };\n  bri.oninput = () => { dimIn.value = bri.value; dimIn.oninput(); syncBri(); };\n  dimIn.addEventListener('input', syncBri);\n  const place = () => { pop.style.left = '18px'; pop.style.top = '50%'; pop.style.transform = 'translateY(-50%)'; };\n  sw.onclick = e => { e.preventDefault(); e.stopPropagation(); const o = !pop.classList.contains('open');\n    document.querySelectorAll('.lpick.open').forEach(p => p.classList.remove('open'));\n    if (o){ syncBri(); place(); pop.classList.add('open'); }\n    document.body.classList.toggle('lpfocus', o);\n    dispatchEvent(new CustomEvent('lpick', { detail: { key, open: o } })); };\n  $('.lp-done').onclick = () => { pop.classList.remove('open'); document.body.classList.remove('lpfocus'); dispatchEvent(new CustomEvent('lpick', { detail: { key, open: false } })); };\n  document.addEventListener('pointerdown', e => { if (pop.classList.contains('open') && !pop.contains(e.target) && !sw.contains(e.target)){ pop.classList.remove('open'); document.body.classList.remove('lpfocus'); dispatchEvent(new CustomEvent('lpick', { detail: { key, open: false } })); } });\n  addEventListener('resize', () => pop.classList.contains('open') && place());\n  update();\n  return pop;\n}\n\nlet lampCol = localStorage.getItem(LAMP_KEY) || '#ffd6a0';\nlampSw.innerHTML = '';\nconst colIn = document.createElement('button'); colIn.className = 'lp-sw'; colIn.title = 'Licht einstellen';\nlampSw.appendChild(colIn);\nconst dimIn = document.querySelector('#lampDim input'), dimOut = document.querySelector('#lampDim output');\ndimIn.oninput = () => { lampK = dimIn.value / 100; dimOut.textContent = dimIn.value + '%'; applyLamp(lampLvl); if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); } };\nfunction applyLamp(v){\n  v *= lampK;\n  lampSpot.intensity = 9 * v;\n  lampFill.intensity = 2.2 * v;\n  bulb.material.emissiveIntensity = 0.2 + 5 * v;\n  schirm.emissiveIntensity = 0.55 * v;\n}\napplyLamp(0);\nmakePicker(colIn, LAMP_KEY + '-cfg', { mode: 'white', warm: 75 }, dimIn, h => { lampCol = h; setLampColor(h); });\nsetLampColor(lampCol);\ndocument.getElementById('lampT').onclick = () => {\n  lampOn = !lampOn;\n  lampBtn.classList.toggle('on', lampOn);\n  lampBtn.querySelector('span').textContent = lampOn ? 'Bogenlampe aus' : 'Bogenlampe an';\n  setLampColor(lampCol);\n  const id = ++lampAnim, from = lampLvl, to = lampOn ? 1 : 0, t0 = performance.now();\n  (function step(now){\n    if (id !== lampAnim) return;\n    const t = Math.min(1, (now - t0) / 450);\n    lampLvl = from + (to - from) * (1 - Math.pow(1 - t, 3));\n    applyLamp(lampLvl);\n    if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); }\n    if (t < 1) requestAnimationFrame(step);\n  })(t0);\n};\n\n// ---------- Donut-Lampe: nur an/aus ----------\nconst donutLight = new THREE.PointLight(0xffa050, 0, 4.5, 2);\ndonutLight.position.copy(donut.getWorldPosition(new THREE.Vector3())).add(new THREE.Vector3(0, 0.13, 0));\nscene.add(donutLight);\nconst donutBtn = document.getElementById('lampD');\ndonutBtn.onclick = () => {\n  const on = donutBtn.getAttribute('aria-pressed') !== 'true';\n  donutBtn.setAttribute('aria-pressed', on); donutBtn.classList.toggle('on', on);\n  donutBtn.querySelector('span').textContent = on ? 'Donut-Lampe aus' : 'Donut-Lampe an';\n  DM.koerper.emissiveIntensity = on ? 2.2 : 0;\n  DM.sockel.emissiveIntensity = on ? 0.6 : 0;\n  donutLight.intensity = on ? 2.6 : 0;\n  if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); }\n};\n\n// ---------- Fernseher: an/aus per Fernbedienung ----------\n{\n  const scr = home.getObjectByName('fernseher').getObjectByName('tv_bildschirm');\n  const cv = document.createElement('canvas'); cv.width = 1024; cv.height = 600;\n  const c = cv.getContext('2d');\n  let g = c.createLinearGradient(0, 0, 1024, 600);\n  g.addColorStop(0, '#0b1e3a'); g.addColorStop(0.55, '#1d4f7a'); g.addColorStop(1, '#e08a4a');\n  c.fillStyle = g; c.fillRect(0, 0, 1024, 600);\n  g = c.createRadialGradient(760, 380, 10, 760, 380, 320);\n  g.addColorStop(0, 'rgba(255,210,150,.9)'); g.addColorStop(1, 'rgba(255,210,150,0)');\n  c.fillStyle = g; c.fillRect(0, 0, 1024, 600);\n  c.fillStyle = '#081322'; c.beginPath(); c.moveTo(0, 600); c.lineTo(0, 430); c.lineTo(220, 360); c.lineTo(420, 450); c.lineTo(640, 380); c.lineTo(1024, 470); c.lineTo(1024, 600); c.fill();\n  c.fillStyle = 'rgba(255,255,255,.92)'; c.font = '500 64px Helvetica, Arial, sans-serif'; c.fillText('20:15', 70, 120);\n  c.font = '400 28px Helvetica, Arial, sans-serif'; c.fillStyle = 'rgba(255,255,255,.7)'; c.fillText('Guten Abend', 72, 165);\n  const tex = new THREE.CanvasTexture(cv); tex.colorSpace = THREE.SRGBColorSpace;\n  const M = scr.material;\n  const tvLight = new THREE.PointLight(0x9ab8ff, 0, 3.2, 2);\n  const sb = new THREE.Box3().setFromObject(scr), sc = sb.getCenter(new THREE.Vector3()), ss = sb.getSize(new THREE.Vector3());\n  tvLight.position.copy(sc).add(new THREE.Vector3(0.35, 0.1, 0));\n  scene.add(tvLight);\n  const btn = document.getElementById('tvB');\n  let lvl = 0, anim = 0;\n  const apply = () => { M.emissiveIntensity = 1.6 * lvl; tvLight.intensity = 1.4 * lvl; if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); } };\n  const bar = document.getElementById('tvBar'), ui = document.getElementById('tvUI');\n  let saved = null, tvAnim = 0;\n  const tween = (pos, tgt, ms, done) => {\n    const id = ++tvAnim, p0 = cam.position.clone(), q0 = ctl.target.clone(), t0 = performance.now();\n    const ease = t => t < 0.5 ? 4*t*t*t : 1 - Math.pow(-2*t+2, 3)/2;\n    (function step(now){\n      if (id !== tvAnim) return;\n      const t = Math.min(1, (now - t0) / ms), e = ease(t);\n      cam.position.lerpVectors(p0, pos, e); ctl.target.lerpVectors(q0, tgt, e); cam.lookAt(ctl.target);\n      if (t < 1) requestAnimationFrame(step); else done && done();\n    })(t0);\n  };\n  const enter = () => {\n    if (saved) return;\n    saved = { pos: cam.position.clone(), tgt: ctl.target.clone(), en: ctl.enabled };\n    ctl.enabled = false; window.__tvLock = true;\n    const th = Math.tan(THREE.MathUtils.degToRad(cam.fov) / 2);\n    const d = Math.min(ss.y / 2 / th, ss.z / 2 / (th * cam.aspect)) * 0.98;\n    document.body.classList.add('tvfocus');\n    tween(new THREE.Vector3(sc.x + d, sc.y, sc.z), sc.clone(), 1600, () => { bar.classList.add('show'); ui.classList.add('show'); });\n  };\n  const leave = () => {\n    if (!saved) return;\n    const s = saved; saved = null;\n    bar.classList.remove('show'); ui.classList.remove('show'); document.body.classList.remove('tvfocus');\n    tween(s.pos, s.tgt, 1200, () => { window.__tvLock = false; ctl.enabled = s.en; });\n  };\n  document.getElementById('tvBack').onclick = leave;\n  document.getElementById('tvOff').onclick = () => { leave(); power(false); };\n  addEventListener('keydown', e => { if (e.key === 'Escape') leave(); });\n  addEventListener('resize', () => { if (saved && bar.classList.contains('show')){ const th = Math.tan(THREE.MathUtils.degToRad(cam.fov) / 2); const d = Math.min(ss.y / 2 / th, ss.z / 2 / (th * cam.aspect)) * 0.98; cam.position.set(sc.x + d, sc.y, sc.z); } });\n  const power = on => {\n    btn.setAttribute('aria-pressed', on); btn.classList.toggle('on', on);\n    btn.querySelector('span').textContent = on ? 'Fernbedienung' : 'Fernseher an';\n    if (!on) ui.classList.remove('show');\n    if (on && !M.emissiveMap){ M.emissive = new THREE.Color(0xffffff); M.emissiveMap = tex; M.needsUpdate = true; }\n    const id = ++anim, from = lvl, to = on ? 1 : 0, t0 = performance.now();\n    (function step(now){\n      if (id !== anim) return;\n      const t = Math.min(1, (now - t0) / (on ? 600 : 250));\n      lvl = from + (to - from) * (1 - Math.pow(1 - t, 3)); apply();\n      if (t < 1) requestAnimationFrame(step);\n    })(t0);\n  };\n  btn.onclick = () => { if (btn.getAttribute('aria-pressed') !== 'true') power(true); enter(); };\n  const apps = [['YouTube','#e5484d'],['Netflix','#d6303a'],['Prime Video','#2fa8e0'],['Disney+','#3b6fe0'],['Spotify','#2fbf62'],['ARD Mediathek','#3d7be0'],['ZDF','#f08a24'],['Twitch','#8b5cf6']];\n  const nav = ui.querySelector('.tv-nav'), hero = ui.querySelector('.tv-hero'), vol = ui.querySelector('.tv-vol input'), volO = ui.querySelector('.tv-vol output');\n  let sel = +(localStorage.getItem('wohnung.tv.app') || 0);\n  apps.forEach(([n], i) => { const b = document.createElement('button'); b.textContent = n; b.onclick = () => pick(i); nav.appendChild(b); });\n  function pick(i){\n    sel = (i + apps.length) % apps.length; try { localStorage.setItem('wohnung.tv.app', sel); } catch(e){}\n    const [n, col] = apps[sel];\n    nav.querySelectorAll('button').forEach((b, j) => b.classList.toggle('on', j === sel));\n    const b = nav.children[sel]; nav.scrollTo({ left: b.offsetLeft - nav.clientWidth/2 + b.offsetWidth/2, behavior: 'smooth' });\n    hero.style.setProperty('--a', col); hero.querySelector('h2').textContent = n;\n  }\n  pick(sel);\n  vol.value = localStorage.getItem('wohnung.tv.vol') ?? 35;\n  const setVol = () => { volO.textContent = vol.value; vol.style.setProperty('--v', vol.value + '%'); try { localStorage.setItem('wohnung.tv.vol', vol.value); } catch(e){} };\n  vol.oninput = setVol; setVol();\n  ui.querySelectorAll('.tv-vb').forEach(b => b.onclick = () => { vol.value = Math.max(0, Math.min(100, +vol.value + +b.dataset.d)); setVol(); });\n  ['pointerdown','wheel','keydown'].forEach(t => ui.addEventListener(t, e => e.stopPropagation()));\n  addEventListener('keydown', e => { if (!ui.classList.contains('show')) return;\n    if (e.key === 'ArrowRight') pick(sel + 1); else if (e.key === 'ArrowLeft') pick(sel - 1);\n    else if (e.key === 'ArrowUp'){ vol.value = Math.min(100, +vol.value + 5); setVol(); } else if (e.key === 'ArrowDown'){ vol.value = Math.max(0, +vol.value - 5); setVol(); } });\n}\n\n// ---------- Tripod-Lampe: an/aus, Farbe, Stärke, Kegel ----------\nconst tripBox = document.getElementById('lamp2'), tripDot = document.querySelector('#tripT i');\nconst TRIP_KEY = 'wohnung-tripod-farbe';\nconst tripColIn = document.getElementById('tripCol'), tripDimIn = document.getElementById('tripDim'), tripConeIn = document.getElementById('tripCone');\nlet tripOn = false, tripLvl = 0, tripAnim = 0, tripK = 1;\nlet tripCol = localStorage.getItem(TRIP_KEY) || '#f2f5ff';\nconst tripSync = () => { if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); } };\nfunction applyTrip(){\n  const v = tripLvl * tripK, c = new THREE.Color(tripCol);\n  trip.spot.color.copy(c); trip.glow.color.copy(c); trip.M.led.emissive.copy(c);\n  trip.M.led.color.set(tripLvl > 0.01 ? 0xffffff : 0xd8dadd);\n  trip.spot.intensity = 12 * v; trip.glow.intensity = 0.35 * v;\n  trip.M.led.emissiveIntensity = 4 * v;\n  tripDot.style.cssText = tripOn ? `background:${tripCol};box-shadow:0 0 10px 3px ${tripCol}99` : '';\n}\ntripDimIn.oninput = () => { tripK = tripDimIn.value/100; tripDimIn.nextElementSibling.textContent = tripDimIn.value + '%'; applyTrip(); tripSync(); };\nmakePicker(tripColIn, TRIP_KEY + '-cfg', { mode: 'white', warm: 5 }, tripDimIn, h => { tripCol = h; try { localStorage.setItem(TRIP_KEY, h); } catch(e){} applyTrip(); tripSync(); });\ntripConeIn.oninput = () => { trip.spot.angle = THREE.MathUtils.degToRad(tripConeIn.value); tripConeIn.nextElementSibling.textContent = tripConeIn.value + '°'; tripSync(); };\ntripConeIn.oninput();\napplyTrip();\ndocument.getElementById('tripT').onclick = () => {\n  tripOn = !tripOn;\n  tripBox.classList.toggle('on', tripOn);\n  tripBox.querySelector('#tripT span').textContent = tripOn ? 'Tripod-Lampe aus' : 'Tripod-Lampe an';\n  const id = ++tripAnim, from = tripLvl, to = tripOn ? 1 : 0, t0 = performance.now();\n  (function step(now){\n    if (id !== tripAnim) return;\n    const t = Math.min(1, (now - t0) / 450);\n    tripLvl = from + (to - from) * (1 - Math.pow(1 - t, 3));\n    applyTrip(); tripSync();\n    if (t < 1) requestAnimationFrame(step);\n  })(t0);\n};\n\n// ---------- Bett-LED in der Kopfteil-Einkerbung ----------\nconst BED_KEY = 'wohnung-bett-led';\nconst bedBtn = document.getElementById('bedL'), bedColIn = document.getElementById('bedCol'), bedDimIn = document.getElementById('bedDim');\nlet bedOn = false, bedLvl = 0, bedAnim = 0, bedK = 1, bedCol = localStorage.getItem(BED_KEY) || '#ffb070';\nfunction applyBed(){\n  const v = bedLvl * bedK, c = new THREE.Color(bedCol);\n  bedLed.M.emissive.copy(c); bedLed.M.emissiveIntensity = 7 * v; bedLed.M.color.set(v > 0.01 ? 0xffffff : 0xe8e4da);\n  bedLed.R.emissive.copy(c); bedLed.R.emissiveIntensity = 0.45 * v;\n  bedLed.lights.forEach(l => { l.color.copy(c); l.intensity = 0.07 * v; });\n  bedBtn.querySelector('b').style.cssText = bedOn ? 'background:' + bedCol + ';box-shadow:0 0 10px 3px ' + bedCol + '99' : '';\n}\nbedDimIn.oninput = () => { bedK = bedDimIn.value / 100; applyBed(); tripSync(); };\nmakePicker(bedColIn, BED_KEY + '-cfg', { mode: 'color', h: 28 }, bedDimIn, h => { bedCol = h; try { localStorage.setItem(BED_KEY, h); } catch(e){} applyBed(); tripSync(); });\napplyBed();\nbedBtn.onclick = () => {\n  bedOn = !bedOn;\n  bedBtn.setAttribute('aria-pressed', bedOn); bedBtn.classList.toggle('on', bedOn);\n  bedBtn.querySelector('span').textContent = bedOn ? 'Bett-LED aus' : 'Bett-LED an';\n  const id = ++bedAnim, from = bedLvl, to = bedOn ? 1 : 0, t0 = performance.now();\n  (function step(now){\n    if (id !== bedAnim) return;\n    const t = Math.min(1, (now - t0) / 700);\n    bedLvl = from + (to - from) * (1 - Math.pow(1 - t, 3));\n    applyBed(); tripSync(); try { act(); } catch(e){}\n    if (t < 1) requestAnimationFrame(step);\n  })(t0);\n};\n\n// ---------- Pathtracing (three-gpu-pathtracer): echte Lichtbündel mit Mehrfach-Reflexion, sobald die Kamera stillsteht ----------\n\nconst ptLabel = document.getElementById('pt');\nlet renderOn = false;\n// Sparsamer Standard-Renderer: N8AO (Screen-Space Ambient Occlusion) + Rendern nur bei Aktivität\nlet composer = null, aoPass = null, lastAct = performance.now(), lastInput = lastAct;\nconst act = () => { lastAct = lastInput = performance.now(); };\nfor (const ev of ['pointerdown','pointermove','wheel','keydown','input','click','resize','touchstart']) window.addEventListener(ev, act, true);\nPromise.all([import('three/examples/jsm/postprocessing/EffectComposer.js'), import('three/examples/jsm/postprocessing/RenderPass.js'), import('three/examples/jsm/postprocessing/OutputPass.js'), import('n8ao')]).then(([{EffectComposer},{RenderPass},{OutputPass},{N8AOPass}]) => {\n  const s = renderer.getSize(new THREE.Vector2());\n  composer = new EffectComposer(renderer);\n  aoPass = new N8AOPass(scene, cam, s.x, s.y);\n  Object.assign(aoPass.configuration, { aoRadius: 0.6, distanceFalloff: 0.5, intensity: 2.2, aoSamples: 12, denoiseSamples: 6, denoiseRadius: 10, halfRes: true, gammaCorrection: false });\n  aoPass.setQualityMode && aoPass.setQualityMode('Low');\n  composer.addPass(aoPass); composer.addPass(new OutputPass());\n  act();\n}).catch(e => console.warn('N8AO nicht verfügbar – einfacher Raster', e));\nconst _cs = new THREE.Vector2();\nconst rtBtn = document.getElementById('rt');\nrtBtn.onclick = () => {\n  renderOn = !renderOn;\n  rtBtn.classList.toggle('on', renderOn); rtBtn.setAttribute('aria-pressed', renderOn);\n  rtBtn.querySelector('span').textContent = renderOn ? 'Render an' : 'Render aus';\n  if (!renderOn && ptOn) stopPT();\n  stillSince = performance.now();\n};\nimport('three-gpu-pathtracer').then(({ WebGLPathTracer }) => {\n  tracer = new WebGLPathTracer(renderer);\n  tracer.bounces = 4;\n  tracer.renderScale = 0.5;\n  tracer.dynamicLowRes = false;\n  tracer.filterGlossyFactor = 0.5;\n  tracer.tiles.set(4, 4);\n  tracer.minSamples = 2;\n  tracer.fadeDuration = 350;\n  tracer.renderDelay = 0;\n}).catch(e => console.warn('Pathtracer nicht verfügbar – Raster-Fallback', e));\nfunction startPT(){\n  scene.environment = ptEnv; scene.background = ptEnv;\n  scene.environmentIntensity = ENV;\n  renderer.toneMappingExposure = 2.4;\n  if (ptDirty){ tracer.setScene(scene, cam); ptDirty = false; }\n  else { tracer.updateCamera(); tracer.updateMaterials(); tracer.updateLights(); tracer.updateEnvironment(); }\n  tracer.reset();\n  ptOn = true; ptLabel.classList.add('show');\n}\nfunction stopPT(){ ptOn = false; scene.environment = rasterEnv; scene.background = cubeRT.texture; applyInterior(ceilMat.opacity); ptLabel.classList.remove('show'); }\nconst MAX_SAMPLES = 256; let ptFrame = 0;\nlet lastUser = -1e9;\nconst interrupt = () => { stillSince = lastUser = performance.now(); if (ptOn) stopPT(); };\nfor (const ev of ['pointerdown','wheel','keydown']) window.addEventListener(ev, interrupt, true);\nrenderer.domElement.addEventListener('pointerdown', interrupt, true);\nconst lastM = new THREE.Matrix4(); let lastAspect = 0;\nfunction camMoved(){\n  const a = cam.matrixWorld.elements, b = lastM.elements; let d = 0;\n  for (let i = 0; i < 16; i++) d += Math.abs(a[i] - b[i]);\n  const m = d > 1e-5 || cam.aspect !== lastAspect;\n  lastM.copy(cam.matrixWorld); lastAspect = cam.aspect;\n  return m;\n}\nconst loop = () => {\n  ctl.autoRotate = !inRoom && !lampFocus && ctl.enabled && performance.now() - lastUser > 6000;\n  ctl.autoRotateSpeed = 0.4;\n  document.body.classList.toggle('idle', performance.now() - lastInput > 8000);\n  ctl.update(); cam.updateMatrixWorld();\n  const now = performance.now();\n  if (camMoved()){ stillSince = now; lastAct = now; if (ptOn) stopPT(); }\n  if (tracer && renderOn && !ptOn && now - stillSince > 350 && (ceilMat.opacity >= 0.999 || ceilMat.opacity <= 0.001)){\n    try { startPT(); } catch(e){ console.warn('Pathtracer-Fehler: ' + (e && e.message), e); tracer = null; ptOn = false; scene.environment = rasterEnv; scene.background = cubeRT.texture; ptLabel.classList.remove('show'); }\n  }\n  if (ptOn && tracer.samples >= MAX_SAMPLES){ ptLabel.textContent = 'Raytracing · fertig'; return; }\n  if (ptOn){ ptFrame ^= 1; if (ptFrame) tracer.renderSample(); ptLabel.textContent = 'Raytracing · ' + Math.floor(tracer.samples) + ' Samples'; }\n  else if (now - lastAct < 1500) {\n    if (composer){ renderer.getSize(_cs); if (composer._w !== _cs.x || composer._h !== _cs.y){ composer.setSize(_cs.x, _cs.y); composer._w = _cs.x; composer._h = _cs.y; } composer.render(); }\n    else renderer.render(scene, cam);\n  }\n};\nstage._loop = loop;\nrenderer.setAnimationLoop(loop);\n\n// ---------- Raum-Navigation ----------\nconst cam = stage._camera, ctl = stage._controls;\nlet lampFocus = false;\nconst overview = { pos: cam.position.clone(), tgt: ctl.target.clone() };\nconst EYE = 1.6;\n// Standpunkt in der Raummitte, Blick in Richtung (dx,dz); Target minimal vor der Kamera → Umsehen statt Umkreisen\nconst spot = (x, z, dx, dz, y = EYE) => {\n  const d = new THREE.Vector3(dx, -0.12, dz).normalize().multiplyScalar(0.05);\n  const pos = new THREE.Vector3(x, y, z);\n  return { pos, tgt: pos.clone().add(d), fp: true };\n};\n// Vogelperspektive: senkrecht über dem Raum, leicht geneigt, Decke ausgeblendet – ganzer Raum im Bild\nconst bird = (x0,z0,x1,z1) => {\n  const cx = (x0+x1)/2, cz = (z0+z1)/2, w = Math.abs(x1-x0), d = Math.abs(z1-z0);\n  const fov = (cam.fov || 50) * Math.PI/180, asp = Math.max(0.6, innerWidth/innerHeight);\n  const need = Math.max(d, w/asp) * 0.5 * 1.25;            // halbe Ausdehnung + Rand\n  const hgt = need / Math.tan(fov/2) + 1.0;\n  return { pos: new THREE.Vector3(cx, hgt, cz + hgt*0.22), tgt: new THREE.Vector3(cx, 0.3, cz), fp: false };\n};\nconst room = ([x0,z0,x1,z1], dx, dz) => ({ fp: spot((x0+x1)/2, (z0+z1)/2, dx, dz), bird: bird(x0, z0, x1, z1) });\nconst ROOMS = [\n  ['Übersicht', overview],\n  ['Wohnzimmer', room(RM_WZ, 1, 0.4)],\n  ['Küche', room(RM_KU, 1, -0.3)],\n  ['Schlafzimmer', room(RM_SZ, -0.3, 1)],\n  ['Bad', room(RM_BAD, 0, -1)],\n  ['Flur', room(RM_FL, -1, 0)],\n  ['Balkon', room([BX0, BZ0, BX1, BZ1], 0, -1)],\n];\nlet anim = 0;\nfunction flyTo(view){\n  const id = ++anim;\n  const p0 = cam.position.clone(), t0 = ctl.target.clone();\n  const c0 = ceilMat.opacity, c1 = view.fp ? 1 : 0;\n  inRoom = !!view.fp;\n  const clamp01 = x => Math.max(0, Math.min(1, x));\n  const dist = p0.distanceTo(view.pos);\n  const dur = Math.min(2200, 1100 + dist*90);\n  const lift = Math.min(3, dist*0.25);\n  const start = performance.now();\n  ctl.enabled = false;\n  ctl.enableZoom = ctl.enablePan = !view.fp;\n  ctl.rotateSpeed = view.fp ? -0.35 : 1;\n  ctl.minDistance = 0;\n  const ease = t => t < 0.5 ? 4*t*t*t : 1 - Math.pow(-2*t+2, 3)/2;\n  (function step(now){\n    if (id !== anim) return;\n    const t = Math.min(1, (now - start)/dur), e = ease(t);\n    cam.position.lerpVectors(p0, view.pos, e);\n    cam.position.y += Math.sin(Math.PI*e) * lift;\n    ctl.target.lerpVectors(t0, view.tgt, e);\n    cam.lookAt(ctl.target);\n    // Einblenden erst am Ende der Anflugs (Kamera schon unter Deckenhöhe), Ausblenden sofort\n    const k = c1 > c0 ? clamp01((e - 0.6) / 0.4) : clamp01(e / 0.3);\n    setCeil(c0 + (c1 - c0) * k);\n    if (t < 1) requestAnimationFrame(step); else ctl.enabled = !window.__tvLock;\n  })(start);\n}\nconst bar = document.getElementById('rooms');\nconst povBar = document.getElementById('pov');\nlet curView = overview, povMode = 'bird';\nconst show = () => flyTo(curView.bird ? curView[povMode] : curView);\nROOMS.forEach(([label, view], i) => {\n  const b = document.createElement('button');\n  b.textContent = label;\n  if (i === 0) b.classList.add('on');\n  b.onclick = () => {\n    bar.querySelectorAll('button').forEach(x => x.classList.toggle('on', x === b));\n    lampBtn.classList.toggle('show', label === 'Wohnzimmer');\n    tripBox.classList.toggle('show', label === 'Schlafzimmer');\n    povBar.classList.toggle('show', !!view.bird);\n    curView = view; povMode = 'bird';\n    povBar.querySelectorAll('button').forEach(x => x.classList.toggle('on', x.dataset.m === povMode));\n    show();\n  };\n  bar.appendChild(b);\n});\n// Lampe konfigurieren → Kamera fliegt an die Lampe, Drehen stoppt; beim Schließen zurück\nconst LAMP_FOCUS = { [LAMP_KEY + '-cfg']: [bp.clone(), 1], [TRIP_KEY + '-cfg']: [trip.spot.getWorldPosition(new THREE.Vector3()), 3], [BED_KEY + '-cfg']: [bedLed.anchor.getWorldPosition(new THREE.Vector3()), 3] };\naddEventListener('lpick', e => {\n  const f = LAMP_FOCUS[e.detail.key]; if (!f) return;\n  if (e.detail.open){\n    lampFocus = true;\n    const p = f[0], c = ROOMS[f[1]][1].fp.pos, dir = new THREE.Vector3(c.x - p.x, 0, c.z - p.z);\n    const dist = Math.min(1.8, dir.length() * 0.85); dir.normalize();\n    const pos = p.clone().addScaledVector(dir, dist).add(new THREE.Vector3(0, 0.35, 0));\n    const right = new THREE.Vector3(-dir.z, 0, dir.x).multiplyScalar(dist * 0.3); // Lampe ins rechte Bilddrittel, Picker links\n    flyTo({ pos, tgt: p.clone().add(new THREE.Vector3(0, -0.2, 0)).add(right), fp: false });\n  } else { lampFocus = false; show(); }\n});\npovBar.addEventListener('click', e => {\n  const b = e.target.closest('button'); if (!b || b.dataset.m === povMode) return;\n  povMode = b.dataset.m;\n  povBar.querySelectorAll('button').forEach(x => x.classList.toggle('on', x === b));\n  show();\n});\n\n// ---------- Poly Haven Texturen ----------\nasync function polyHaven(assetName, res){\n  const all = await (await fetch('https://api.polyhaven.com/assets?t=textures')).json();\n  const want = assetName.toLowerCase();\n  const id = (all[want] ? want : null) || Object.keys(all).find(k => (all[k].name||'').toLowerCase() === want)\n          || Object.keys(all).find(k => (all[k].name||'').toLowerCase().includes(want))\n          || want.replace(/\\s+/g,'_');\n  const files = await (await fetch(`https://api.polyhaven.com/files/${id}`)).json();\n  const pick = key => files[key]?.['1k']?.jpg?.url || files[key]?.['1k']?.png?.url;\n  const dim = all[id]?.dimensions; // mm [w,h]\n  return { id, dim, diff: pick('Diffuse'), nor: pick('nor_gl'), rough: pick('Rough') };\n}\nconst loader = new THREE.TextureLoader();\nloader.setCrossOrigin('anonymous');\nconst loadTex = (url, srgb) => new Promise((res, rej) => loader.load(url, t => {\n  t.wrapS = t.wrapT = THREE.RepeatWrapping;\n  if (srgb) t.colorSpace = THREE.SRGBColorSpace;\n  t.anisotropy = 8; res(t);\n}, undefined, rej));\nasync function apply(mat, assetName, uvScale, res){\n  const f = await polyHaven(assetName, res);\n  const [map, normalMap, roughnessMap] = await Promise.all([\n    loadTex(f.diff, true), f.nor ? loadTex(f.nor) : null, f.rough ? loadTex(f.rough) : null\n  ]);\n  if (uvScale){ // echte Größe: UVs sind in 1/uvScale m, Textur deckt dim mm ab\n    const w = (f.dim?.[0] || 2000) / 1000, hh = (f.dim?.[1] || f.dim?.[0] || 2000) / 1000;\n    for (const t of [map, normalMap, roughnessMap]) if (t) t.repeat.set(uvScale / w, uvScale / hh);\n  }\n  mat.map = map; mat.color.set(0xffffff);\n  if (normalMap) mat.normalMap = normalMap;\n  if (roughnessMap) { mat.roughnessMap = roughnessMap; mat.roughness = 1; }\n  mat.needsUpdate = true;\n  ptDirty = true; if (ptOn) stopPT();\n  return f.id;\n}\n// ---------- Tageszeit: prozeduraler Himmel (three.js Sky, Preetham-Modell) ----------\nconst { Sky } = await import('three/addons/objects/Sky.js');\nconst sky = new Sky(); sky.scale.setScalar(1000);\nconst skyScene = new THREE.Scene(); skyScene.add(sky);\nconst SU = sky.material.uniforms;\nSU.mieCoefficient.value = 0.005; SU.mieDirectionalG.value = 0.8;\n// Nacht-/Dämmerungs-Minimum: dunkles Blau, zum Horizont heller\nsky.material.uniforms.nightFloor = { value: new THREE.Color(0,0,0) };\nsky.material.fragmentShader = 'uniform vec3 nightFloor;\\n' + sky.material.fragmentShader.replace('#include <tonemapping_fragment>',\n  'float hzF = 1.0 - clamp(normalize(vWorldPosition - cameraPosition).y, 0.0, 1.0);\\n gl_FragColor.rgb = max(gl_FragColor.rgb, nightFloor * (0.55 + 0.9*hzF*hzF));\\n#include <tonemapping_fragment>');\nsky.material.needsUpdate = true;\nconst cubeRT = new THREE.WebGLCubeRenderTarget(512, { type: THREE.HalfFloatType });\nconst cubeCam = new THREE.CubeCamera(1, 5000, cubeRT); skyScene.add(cubeCam);\nconst pmrem = new THREE.PMREMGenerator(renderer);\nlet envRT = null;\nconst keyBase = key.intensity, hemiCol0 = hemi ? hemi.color.clone() : null, hemiGnd0 = hemi ? hemi.groundColor.clone() : null;\nconst SS = THREE.MathUtils.smoothstep, col = (r,g,b) => new THREE.Color(r,g,b);\nfunction makePTEnv(d, day, golden){\n  const w = 256, h = 128, arr = new Float32Array(w*h*4);\n  const zen = col(.03,.045,.1).lerp(col(.16,.32,.75), day);\n  const hor = col(.05,.07,.13).lerp(col(.75,.82,.92).lerp(col(1,.55,.3), golden*.8), day);\n  const gnd = hor.clone().multiplyScalar(.25);\n  const sunC = col(1,.95,.85).lerp(col(1,.5,.2), golden).multiplyScalar(40*day);\n  for (let j = 0; j < h; j++){\n    const el = ((j+.5)/h - .5)*Math.PI, sy = Math.sin(el), cy = Math.cos(el);\n    for (let i = 0; i < w; i++){\n      const az = ((i+.5)/w - .5)*2*Math.PI, x = Math.cos(az)*cy, z = Math.sin(az)*cy;\n      let r, g, bb;\n      if (sy >= 0){ const t = Math.sqrt(sy); r = hor.r+(zen.r-hor.r)*t; g = hor.g+(zen.g-hor.g)*t; bb = hor.b+(zen.b-hor.b)*t; }\n      else { const t = Math.min(1, -sy*4); r = hor.r+(gnd.r-hor.r)*t; g = hor.g+(gnd.g-hor.g)*t; bb = hor.b+(gnd.b-hor.b)*t; }\n      const dot = x*d.x + sy*d.y + z*d.z;\n      if (dot > 0){ const gl = Math.pow(dot, 48)*day*(1+golden); r += gl; g += gl*(.85-.3*golden); bb += gl*(.7-.45*golden); }\n      if (dot > .999 && sy > -0.02){ r = sunC.r; g = sunC.g; bb = sunC.b; }\n      const k = (j*w + i)*4; arr[k] = r; arr[k+1] = g; arr[k+2] = bb; arr[k+3] = 1;\n    }\n  }\n  const dt = new THREE.DataTexture(arr, w, h, THREE.RGBAFormat, THREE.FloatType);\n  dt.mapping = THREE.EquirectangularReflectionMapping;\n  dt.minFilter = dt.magFilter = THREE.LinearFilter; dt.generateMipmaps = false; dt.needsUpdate = true;\n  return dt;\n}\nconst sunV = new THREE.Vector3();\nfunction setTime(hr){\n  // Sonnenbahn (vereinfacht): 7 Uhr Ost (+x) → 13 Uhr Süd (+z) → 19 Uhr West, max. 50° Höhe\n  const phi = Math.PI*(hr - 7)/12, e = THREE.MathUtils.degToRad(50)*Math.sin(phi);\n  sunV.set(Math.cos(phi)*Math.cos(e), Math.sin(e), Math.sin(phi)*Math.cos(e)).normalize();\n  const s = sunV.y, day = SS(s, -0.14, 0.18), golden = 1 - SS(s, 0, 0.4), dusk = SS(s, -0.22, -0.02) * (1 - SS(s, 0.02, 0.2));\n  SU.sunPosition.value.copy(sunV);\n  SU.rayleigh.value = 2.5 + 1.2*golden;\n  SU.turbidity.value = 3 + 5*golden;\n  // Nachtblau, zur blauen Stunde etwas heller/violetter\n  SU.nightFloor.value.setRGB(0.010 + 0.03*dusk, 0.016 + 0.03*dusk, 0.045 + 0.06*dusk);\n  cubeCam.update(renderer, skyScene);\n  envRT = pmrem.fromCubemap(cubeRT.texture, envRT);\n  rasterEnv = envRT.texture;\n  if (s > -0.03){\n    key.position.copy(hc).addScaledVector(sunV, 30);\n    key.color.set(0xff9a52).lerp(new THREE.Color(0xfff3e2), SS(s, 0, 0.5));\n    key.intensity = keyBase * 1.3 * Math.max(day, 0.15);\n  } else { // Mondlicht, gegenüber der Sonne\n    const m = new THREE.Vector3(-sunV.x, Math.abs(sunV.y)*0.8 + 0.2, -sunV.z).normalize();\n    key.position.copy(hc).addScaledVector(m, 30);\n    key.color.set(0x9fb4ff); key.intensity = keyBase * 0.25;\n  }\n  envK = 0.2 + 0.1*day + 0.15*dusk; hemiK = 0.3 + 0.4*day; fillK = 0.1 + 0.5*day; expK = 1 - 0.45*day;\n  if (hemi){ hemi.color.copy(hemiCol0).lerp(new THREE.Color(0x34426e), 1 - day); hemi.groundColor.copy(hemiGnd0).multiplyScalar(0.3 + 0.7*day); }\n  ptEnv = makePTEnv(sunV, day, golden);\n  scene.background = cubeRT.texture;\n  scene.backgroundIntensity = 0.2 + 1.1*(1 - day);\n  if (ptOn) stopPT(); else { scene.environment = rasterEnv; applyInterior(ceilMat.opacity); }\n  act();\n}\n// Himmel & Licht folgen der echten Uhrzeit\nconst nowH = () => { const n = new Date(); return n.getHours() + n.getMinutes()/60; };\nsetTime(nowH());\nsetInterval(() => setTime(nowH()), 60000);\nlet texMsg = 'Texturen werden geladen…';\nconst upd = () => statusEl.textContent = texMsg;\nupd();\nsofa.M.fabric.color.set('#3a3a3c');\napply(sofa.M.fabric, 'Poly Wool Herringbone').then(() => sofa.M.fabric.color.set('#3a3a3c')).catch(e => console.warn(e));\nPromise.all([apply(M.floor, 'wood_floor', 1.0), apply(M.wall, 'White Stucco'), apply(M.brick, 'Brick Wall 04', 1.5), apply(M.cap, 'Rough Plaster Brick 04', 1.5), apply(tileMat, 'interior_tiles', 1.0, '2k').then(id => {\n    // nur Relief/Glanz behalten, Farbe weiß; Raster achsparallel drehen, Fliesen halb so groß\n    tileMat.map = null; tileMat.color.set(0xf3f2ee);\n    // Textur: Rautenraster, 3 Fliesen je Kachel → 45° gedreht achsparallel; 15-cm-Fliesen, Fugen auf 0,90 / 1,50 m\n    const TILE = 0.15, rep = 1 / (3 * Math.SQRT2 * TILE);\n    for (const t of [tileMat.normalMap, tileMat.roughnessMap]) if (t){ t.center.set(0, 0); t.offset.set(0, 0); t.rotation = Math.PI/4; t.repeat.set(rep, rep); }\n    tileMat.needsUpdate = true; return id;\n  })])\n  .then(ids => { texMsg = 'Texturen: ' + ids.join(', '); upd(); })\n  .catch(e => { console.warn(e); texMsg = 'Texturen nicht erreichbar – Farb-Fallback'; upd(); });\n\n// ---------- TV-Sperre + KI-Assistent ----------\nfor (const t of ['pointerdown','pointermove','wheel','touchstart','touchmove','dblclick','contextmenu']) window.addEventListener(t, e => {\n  if (window.__tvLock && e.composedPath().includes(renderer.domElement)){ e.stopImmediatePropagation(); if (e.cancelable && t !== 'pointerdown') e.preventDefault(); }\n}, { capture: true, passive: false });\n{\n  const $ = s => document.querySelector(s);\n  const ai = $('#ai'), logEl = $('#aiLog'), inp = $('#aiIn'), stateEl = $('#aiState');\n  const roomNames = ROOMS.map(r => r[0]);\n  const ROOM_TO = { 'Übersicht': 'zur Übersicht', 'Wohnzimmer': 'ins Wohnzimmer', 'Küche': 'in die Küche', 'Schlafzimmer': 'ins Schlafzimmer', 'Bad': 'ins Bad', 'Flur': 'in den Flur', 'Balkon': 'auf den Balkon' };\n  const ROOM_LAMPS = { 'Wohnzimmer': ['bogen', 'donut'], 'Schlafzimmer': ['trip', 'bett'] };\n  const L = {\n    bogen: { n: 'Bogenlampe', on: () => lampOn, t: () => $('#lampT').click() },\n    donut: { n: 'Donut-Lampe', on: () => donutBtn.getAttribute('aria-pressed') === 'true', t: () => donutBtn.click() },\n    trip:  { n: 'Tripod-Lampe', on: () => tripOn, t: () => $('#tripT').click() },\n    bett:  { n: 'Bett-LED', on: () => bedOn, t: () => bedBtn.click() },\n  };\n  const tvB = $('#tvB'), tvIsOn = () => tvB.getAttribute('aria-pressed') === 'true';\n  const refresh = () => { try { act(); } catch(e){} dispatchEvent(new Event('input')); setTimeout(() => dispatchEvent(new Event('input')), 60); };\n  const COLORS = { rot: ['#ff2a2a', 'rot'], blau: ['#2a62ff', 'blau'], grün: ['#22e060', 'grün'], gruen: ['#22e060', 'grün'], lila: ['#9b3bff', 'lila'], violett: ['#9b3bff', 'violett'], pink: ['#ff3fa8', 'pink'], rosa: ['#ff7ac0', 'rosa'], orange: ['#ff7a1a', 'orange'], gelb: ['#ffd21a', 'gelb'], türkis: ['#1ae5d8', 'türkis'], weiß: ['#fff1e0', 'weiß'], weiss: ['#fff1e0', 'weiß'], warm: ['#ffb070', 'warmweiß'] };\n  const A = {\n    light(k, on){ const l = L[k]; if (!l) return 'Diese Lampe kenne ich nicht.'; const want = on ?? !l.on(); if (l.on() !== want) l.t(); refresh(); return l.n + (want ? ' ist an.' : ' ist aus.'); },\n    lights(keys, on){ keys.forEach(k => { if (L[k].on() !== on) L[k].t(); }); refresh(); },\n    all(on){ A.lights(Object.keys(L), on); return on ? 'Alle Lichter sind an.' : 'Alle Lichter sind aus.'; },\n    tv(mode){\n      if (mode === 'aus'){ if (tvIsOn()) $('#tvOff').click(); refresh(); return 'Fernseher ist aus.'; }\n      if (!window.__tvLock) tvB.click(); refresh(); return mode === 'fernbedienung' ? 'Fernbedienung ist offen.' : 'Fernseher ist an.';\n    },\n    room(name){\n      const i = roomNames.findIndex(r => r.toLowerCase() === String(name).toLowerCase()); if (i < 0) return 'Diesen Raum kenne ich nicht.';\n      if (window.__tvLock) $('#tvBack').click();\n      bar.children[i].click(); refresh(); return 'Ich bringe dich ' + (ROOM_TO[roomNames[i]] || 'dorthin') + '.';\n    },\n    bedColor(hex, name){\n      bedCol = hex; try { localStorage.setItem(BED_KEY, hex); } catch(e){} bedColIn.style.background = hex;\n      if (!bedOn) bedBtn.click(); applyBed(); tripSync(); refresh(); return 'Die Bett-LED leuchtet jetzt ' + name + '.';\n    },\n  };\n  const HELP = 'Ich kann Lichter schalten („Bett-LED blau“, „Alle Lichter aus“), den Fernseher steuern und dich durch die Räume führen („Zeig die Küche“).';\n  function local(q){\n    const s = ' ' + q.toLowerCase().replace(/[.,!?;:„“\"]/g, ' ').replace(/-/g, ' ') + ' ';\n    const off = /\\s(aus|ausschalten|ausmachen|abschalten|dunkel)\\s/.test(s), on = /\\s(an|ein|einschalten|anmachen|anschalten|hell)\\s/.test(s);\n    const st = off ? false : on ? true : null;\n    const words = s.trim().split(/\\s+/);\n    if (/^(hallo|hi|hey|servus|moin|guten (morgen|tag|abend))/.test(s.trim()) && words.length <= 3) return 'Hallo! ' + HELP;\n    if (/was kannst du|hilfe|befehle/.test(s)) return HELP;\n    const col = Object.keys(COLORS).find(c => s.includes(' ' + c));\n    if (/bett|\\sled/.test(s)){ if (col && st !== false) return A.bedColor(...COLORS[col]); return A.light('bett', st); }\n    if (/bogen|stehlampe/.test(s)) return A.light('bogen', st);\n    if (/donut|regal/.test(s)) return A.light('donut', st);\n    if (/tripod|stativ/.test(s)) return A.light('trip', st);\n    if (/fernbedienung/.test(s) && !off) return A.tv('fernbedienung');\n    if (/fernseh|\\stv\\s|glotze/.test(s)) return A.tv(off ? 'aus' : 'an');\n    const r = roomNames.find(n => s.includes(n.toLowerCase())) || (/übersicht|von oben|ganze wohnung/.test(s) ? 'Übersicht' : null);\n    if (r && /licht|lampe/.test(s) && st !== null){ const ks = ROOM_LAMPS[r]; if (!ks) return 'Im Raum ' + r + ' gibt es noch keine steuerbaren Lichter.'; A.lights(ks, st); return 'Licht im ' + r + (st ? ' ist an.' : ' ist aus.'); }\n    if (/(alle|alles)/.test(s) && st !== null) return A.all(st);\n    if (/licht|lampe/.test(s) && st !== null) return A.all(st);\n    if (r) return A.room(r);\n    return null;\n  }\n  const claude = (() => { try { return window.claude || (parent !== window && parent.claude) || null; } catch(e){ return null; } })();\n  const hist = [];\n  async function remote(q){\n    const cur = bar.querySelector('.on')?.textContent || 'Übersicht';\n    const stat = Object.entries(L).map(([k, l]) => k + '=' + (l.on() ? 'an' : 'aus')).join(', ') + ', fernseher=' + (tvIsOn() ? 'an' : 'aus') + ', raum=' + cur;\n    hist.push({ role: 'user', content: q }); while (hist.length > 12) hist.shift();\n    const text = await claude.complete({\n      max_tokens: 400,\n      system: 'Du bist die KI einer interaktiven 3D-Wohnung. Antworte auf Deutsch, freundlich, höchstens 2 kurze Sätze, ohne Markdown oder Emojis. Steuere die Wohnung über die Tools. Aktueller Zustand: ' + stat + '. Räume: ' + roomNames.join(', ') + '.',\n      messages: hist.slice(),\n      tools: [\n        { name: 'licht', description: 'Schaltet eine Lampe. lampe: bogen (Bogenlampe Wohnzimmer), donut (Donut-Lampe Regal), trip (Tripod-Lampe Schlafzimmer), bett (LED im Bett-Kopfteil), alle.', input_schema: { type: 'object', properties: { lampe: { type: 'string', enum: ['bogen', 'donut', 'trip', 'bett', 'alle'] }, an: { type: 'boolean' } }, required: ['lampe', 'an'] }, run: async ({ lampe, an }) => lampe === 'alle' ? A.all(an) : A.light(lampe, an) },\n        { name: 'bett_farbe', description: 'Setzt die Farbe der Bett-LED.', input_schema: { type: 'object', properties: { hex: { type: 'string', description: '#rrggbb' }, name: { type: 'string', description: 'Farbname auf Deutsch' } }, required: ['hex', 'name'] }, run: async ({ hex, name }) => A.bedColor(hex, name) },\n        { name: 'fernseher', description: 'Fernseher an/aus oder Fernbedienung öffnen.', input_schema: { type: 'object', properties: { aktion: { type: 'string', enum: ['an', 'aus', 'fernbedienung'] } }, required: ['aktion'] }, run: async ({ aktion }) => A.tv(aktion) },\n        { name: 'raum', description: 'Kamera in einen Raum fliegen lassen.', input_schema: { type: 'object', properties: { raum: { type: 'string', enum: roomNames } }, required: ['raum'] }, run: async ({ raum }) => A.room(raum) },\n      ],\n    });\n    hist.push({ role: 'assistant', content: text || 'Erledigt.' });\n    return text || 'Erledigt.';\n  }\n  const setState = s => {\n    document.body.classList.toggle('ai-listen', s === 'listen'); document.body.classList.toggle('ai-think', s === 'think'); document.body.classList.toggle('ai-speak', s === 'speak');\n    stateEl.textContent = { listen: 'Ich höre zu …', think: 'Denke nach …', speak: 'Spricht …' }[s] || 'Bereit';\n  };\n  const add = (who, text) => { const d = document.createElement('div'); d.className = 'ai-m ' + who; d.textContent = text; logEl.appendChild(d); logEl.scrollTop = logEl.scrollHeight; requestAnimationFrame(() => logEl.scrollTop = logEl.scrollHeight); return d; };\n  let voice = null;\n  const pickVoice = () => { try { const vs = speechSynthesis.getVoices().filter(v => /^de/i.test(v.lang)); voice = vs.find(v => /google|anna|petra|helena|katja|neural/i.test(v.name)) || vs[0] || null; } catch(e){} };\n  if ('speechSynthesis' in window){ pickVoice(); speechSynthesis.onvoiceschanged = pickVoice; }\n  function say(text, speak){\n    add('a', text);\n    if (!speak || !('speechSynthesis' in window)) return;\n    const u = new SpeechSynthesisUtterance(text); u.lang = 'de-DE'; if (voice) u.voice = voice; u.rate = 1.03;\n    u.onstart = () => setState('speak'); u.onend = u.onerror = () => setState('');\n    speechSynthesis.cancel(); speechSynthesis.speak(u);\n  }\n  let busy = false;\n  async function send(q, spoken){\n    q = q.trim(); if (!q || busy) return;\n    add('u', q); inp.value = '';\n    let r = null; try { r = local(q); } catch(e){ console.warn(e); }\n    if (r == null && claude){\n      busy = true; setState('think'); const dots = add('a dots', '• • •');\n      try { r = await remote(q); } catch(e){ console.warn(e); r = 'Ich bin gerade nicht erreichbar. ' + HELP; }\n      dots.remove(); busy = false; setState('');\n    }\n    if (r == null) r = 'Das habe ich nicht verstanden. ' + HELP;\n    say(r, spoken);\n  }\n  const SR = window.SpeechRecognition || window.webkitSpeechRecognition;\n  let rec = null, listening = false;\n  function listen(){\n    if (listening){ try { rec.stop(); } catch(e){} return; }\n    if (!SR){ say('Spracheingabe wird von diesem Browser nicht unterstützt – schreib mir einfach.', false); inp.focus(); return; }\n    try { speechSynthesis.cancel(); } catch(e){}\n    rec = new SR(); rec.lang = 'de-DE'; rec.interimResults = true; rec.maxAlternatives = 1;\n    let fin = '', err = false;\n    rec.onresult = e => { let t = ''; for (const r of e.results) t += r[0].transcript; inp.value = t; if (e.results[e.results.length - 1].isFinal) fin = t; };\n    rec.onerror = e => { err = true; listening = false; setState('');\n      if (e.error === 'not-allowed' || e.error === 'service-not-allowed') say('Ich darf das Mikrofon nicht benutzen. Bitte erlaube den Zugriff im Browser.', false);\n      else if (e.error === 'network') say('Für die Spracherkennung brauche ich eine Internetverbindung.', false); };\n    rec.onend = () => { listening = false; setState(''); const q = (fin || inp.value).trim(); if (q && !err) send(q, true); };\n    try { rec.start(); listening = true; setState('listen'); } catch(e){ setState(''); }\n  }\n  const open = (withVoice) => {\n    const was = ai.classList.contains('open');\n    ai.classList.add('open');\n    if (!logEl.children.length) add('a', 'Hallo, ich bin die KI deiner Wohnung. Sag oder schreib mir, was ich tun soll.');\n    if (withVoice) listen(); else if (!was && matchMedia('(pointer:fine)').matches) inp.focus();\n  };\n  const close = () => { ai.classList.remove('open'); if (listening) try { rec.abort(); } catch(e){} try { speechSynthesis.cancel(); } catch(e){} setState(''); inp.blur(); };\n  $('#aiOrb')?.addEventListener('click', () => open(true));\n  $('#aiBar')?.addEventListener('click', () => open(true));\n  $('#aiX').onclick = close; $('#aiScrim').onclick = close;\n  $('#aiMic').onclick = () => listen();\n  $('#aiForm').onsubmit = e => { e.preventDefault(); send(inp.value, false); };\n  document.querySelectorAll('.ai-chips button').forEach(b => b.onclick = () => send(b.textContent, false));\n  addEventListener('keydown', e => { if (e.key === 'Escape' && ai.classList.contains('open')){ e.stopImmediatePropagation(); close(); } }, true);\n  ['pointerdown', 'wheel', 'keydown', 'touchstart'].forEach(t => ai.addEventListener(t, e => e.stopPropagation()));\n}\n<\u002Fscript>\n\n\n<\u002Fbody><\u002Fhtml>"
  </script>
</body>
</html>", P = "<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <title>Wohnung – 3D Miniatur (Handy)</title>
  <style>
    * { margin: 0; padding: 0; box-sizing: border-box; }
    body { background: #1b1b19; display: flex; align-items: center; justify-content: center; min-height: 100vh; font-family: -apple-system, BlinkMacSystemFont, sans-serif; }
    #__bundler_loading { position: fixed; bottom: 20px; right: 20px; font: 13px/1.4 -apple-system, BlinkMacSystemFont, sans-serif; color: #666; background: #fff; padding: 8px 14px; border-radius: 8px; box-shadow: 0 1px 4px rgba(0,0,0,0.12); z-index: 10000; }
    #__bundler_thumbnail { position: fixed; inset: 0; width: 100%; height: 100%; display: flex; align-items: center; justify-content: center; background: #1b1b19; z-index: 9999; }
    #__bundler_thumbnail svg { width: 100%; height: 100%; object-fit: contain; }
    #__bundler_placeholder { color: #999; font-size: 14px; }
  </style>
  <noscript>
    <style>#__bundler_loading { display: none; }</style>
    <div style="position:fixed;bottom:12px;left:12px;font:13px/1.4 -apple-system,BlinkMacSystemFont,sans-serif;color:#999;background:rgba(255,255,255,0.9);padding:6px 12px;border-radius:6px;box-shadow:0 1px 4px rgba(0,0,0,0.08);z-index:10000;">
      This page requires JavaScript to display.
    </div>
  </noscript>
</head>
<body>
  <div id="__bundler_thumbnail"><svg viewBox="0 0 120 120" xmlns="http://www.w3.org/2000/svg"><rect width="120" height="120" fill="#1b1b19"></rect><rect x="46" y="26" width="28" height="68" rx="10" fill="none" stroke="#e9e6de" stroke-width="4"></rect><circle cx="60" cy="42" r="5" fill="#e5484d"></circle><circle cx="60" cy="62" r="7" fill="none" stroke="#e9e6de" stroke-width="4"></circle></svg></div>
  <div id="__bundler_loading">Unpacking...</div>

  <script>
    
document.addEventListener('DOMContentLoaded', async function() {
  const loading = document.getElementById('__bundler_loading');
  function setStatus(msg) { if (loading) loading.textContent = msg; }

  const FONT_MIME = /^(font[/]|application[/](x-)?font-|application[/]vnd\.ms-fontobject)/i;
  const MIME_TOKEN = /^[\w.+-]+[/][\w.+-]+$/;
  function toBase64(bytes) {
    let bin = '';
    for (let i = 0; i < bytes.length; i += 0x8000) {
      bin += String.fromCharCode.apply(null, bytes.subarray(i, i + 0x8000));
    }
    return btoa(bin);
  }

  // Error sink persists across replaceWith since it's on window, not the DOM.
  window.addEventListener('error', function(e) {
    // Failed resource loads (CSP-blocked links, scripts, images) fire plain
    // events at the element — warn only; real JS errors carry message/error.
    if (!e.message && !e.error && e.target && e.target !== window) {
      console.warn('[bundle] resource failed to load:',
        e.target.tagName, String(e.target.src || e.target.href || ''));
      return;
    }
    var p = document.body || document.documentElement;
    var d = document.getElementById('__bundler_err') || p.appendChild(document.createElement('div'));
    d.id = '__bundler_err';
    d.style.cssText = 'position:fixed;bottom:12px;left:12px;right:12px;font:12px/1.4 ui-monospace,monospace;background:#2a1215;color:#ff8a80;padding:10px 14px;border-radius:8px;border:1px solid #5c2b2e;z-index:99999;white-space:pre-wrap;max-height:40vh;overflow:auto';
    d.textContent = (d.textContent ? d.textContent + String.fromCharCode(10) : '') +
      '[bundle] ' + (e.message || e.type) +
      (e.filename ? ' (' + e.filename.slice(0, 60) + ':' + e.lineno + ')' : '');
  }, true);

  try {
    const manifestEl = document.querySelector('script[type="__bundler/manifest"]');
    const templateEl = document.querySelector('script[type="__bundler/template"]');
    if (!manifestEl || !templateEl) {
      setStatus('Error: missing bundle data');
      console.error('[bundler] Missing script tags — manifestEl:', !!manifestEl, 'templateEl:', !!templateEl);
      return;
    }

    const manifest = JSON.parse(manifestEl.textContent);
    let template = JSON.parse(templateEl.textContent);

    // Nested page bundles (iframe targets). Each ships ONCE, in the ROOT
    // document's manifest; frame srcs carry an about:blank#<uuid> marker
    // instead of a substitutable uuid. Every document mints the blobs for
    // its OWN frames — from local text at the root, or text obtained from
    // its DIRECT parent over the relay protocol below — so each frame
    // navigation stays same-origin with its initiator and a deduped page
    // loads at any depth on any host, including a file:// download's
    // opaque origins (where a blob minted by one document cannot be
    // navigated to by another).
    const pageOrderEl = document.querySelector('script[type="__bundler/page_order"]');
    const pageOrder = pageOrderEl ? JSON.parse(pageOrderEl.textContent) : [];
    const pageSet = new Set(pageOrder);
    const pageTexts = {};

    // ── Nested-page text protocol (parent-chain relay) ──
    // Page bundles ship once, in the ROOT document's manifest. Every
    // document mints the blobs for its OWN frames, obtaining page text
    // through a strict parent-chain relay: a document only ever SENDS to
    // its direct parent (which, for every document the publisher's own
    // runtime minted, is another publisher document) and only ACCEPTS
    // text from that direct parent; requests from below are honored only
    // for the document's own child frames, and the ROOT never sends
    // upward at all. That last rule is load-bearing: the artifact host's
    // frame-ancestors allows claude.ai (and friends) to frame an
    // artifact, so window.top can be a FOREIGN document — a top-addressed
    // protocol would hand page uuids to that ancestor and accept forged
    // "page text" from it, minting attacker HTML as an artifact-origin
    // blob document. The chain never touches the ancestor: requests stop
    // at the root, replies are origin-addressed per hop (never '*' when
    // an origin exists), and both directions are origin-gated (on https
    // a foreign sender's origin can never equal this document's; in
    // opaque contexts — file:// — everything serializes as 'null', where
    // an embedded EXTERNAL frame still fails the gate by carrying its
    // own real origin, and a sandboxed child of such a frame is excluded
    // by the own-child-frames check plus uuid unguessability). Shape is
    // deny-by-default: one request form, one reply form, no error
    // replies.
    // window.origin is the SERIALIZED SECURITY origin ('null' in opaque
    // contexts such as a sandboxed preview iframe) — location.origin is
    // computed from the URL and stays 'https://…' even when the document
    // is sandboxed, which would misgate every opaque chain.
    const OWN_TARGET = /^https?:[/][/]/.test(window.origin || '')
      ? window.origin
      : '*';
    function trustedOrigin(e) {
      if (e.origin === window.origin) return true; // https chains; opaque==opaque
      // file:// trees: Chrome serializes the file document's origin as
      // 'file://' while the blob: documents it mints serialize as 'null',
      // so the two legitimate shapes can never string-match — accept the
      // pair in both directions. https origins never serialize as either,
      // and sender identity (own child frame / direct parent) is checked
      // separately.
      return (
        (e.origin === 'null' &&
          (window.origin === 'file://' ||
            window.location.protocol === 'file:')) ||
        (/^file:/.test(e.origin) && window.origin === 'null')
      );
    }
    // Non-empty only in the root document (nested bundles ship an empty
    // island), so it doubles as the root marker: the root answers from
    // local text and treats a miss as authoritative — never relaying to
    // its (possibly foreign) parent.
    const isPageRoot = pageOrder.length > 0;
    const blobUrls = {};
    const resourceBlobs = {};
    const UUID_SHAPE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
    const pendingFrames = {}; // uuid -> [{el, frag}] awaiting text for own frames
    const pendingRelays = {}; // uuid -> [childWindow] awaiting text to pass down
    function mountPage(el, frag, text) {
      const pageBlob = new Blob([text], { type: 'text/html' });
      const u = URL.createObjectURL(pageBlob);
      resourceBlobs[u] = pageBlob;
      el.src = u + frag;
    }
    function deliverPage(uuid, text) {
      const frames = pendingFrames[uuid];
      delete pendingFrames[uuid];
      if (frames) for (const f of frames) mountPage(f.el, f.frag, text);
      const relays = pendingRelays[uuid];
      delete pendingRelays[uuid];
      if (relays) {
        for (const cw of relays) {
          try { cw.postMessage({ __bundler_page: uuid, __bundler_text: text }, OWN_TARGET); } catch (err) { /* gone */ }
        }
      }
    }
    function ownFrameWindows() {
      const out = [];
      for (const f of Array.from(document.querySelectorAll('iframe'))) {
        try { if (f.contentWindow) out.push(f.contentWindow); } catch (err) { /* detached */ }
      }
      return out;
    }
    window.addEventListener('message', function (e) {
      const d = e.data;
      if (!d || typeof d !== 'object' || !e.source) return;
      // Origin gate first; the structural checks below (own-child-frames
      // for requests, direct-parent + solicited-uuid for replies, the
      // root's never-relay rule) are what hold in fully opaque chains
      // where origin strings can't discriminate — a sandboxed root's
      // FOREIGN wrapper still fails all three even though both serialize
      // as real-vs-'null' rather than matching.
      if (!trustedOrigin(e)) return;
      if (typeof d.__bundler_need === 'string' && UUID_SHAPE.test(d.__bundler_need)) {
        // Requests are honored only for this document's own child frames.
        if (ownFrameWindows().indexOf(e.source) < 0) return;
        const uuid = d.__bundler_need;
        const text = pageTexts[uuid];
        if (typeof text === 'string') {
          try { e.source.postMessage({ __bundler_page: uuid, __bundler_text: text }, OWN_TARGET); } catch (err) { /* gone */ }
          return;
        }
        if (isPageRoot || window.parent === window) return; // authoritative miss
        const waiting = pendingRelays[uuid];
        if (waiting) {
          if (waiting.indexOf(e.source) < 0) waiting.push(e.source);
          return;
        }
        // Never-answered uuids would otherwise accumulate forever under a
        // request spray; past the cap (far above any real page count) new
        // relays are dropped rather than remembered.
        if (Object.keys(pendingRelays).length >= 128) return;
        pendingRelays[uuid] = [e.source];
        window.parent.postMessage({ __bundler_need: uuid }, OWN_TARGET);
      } else if (
        typeof d.__bundler_page === 'string' &&
        UUID_SHAPE.test(d.__bundler_page) &&
        typeof d.__bundler_text === 'string'
      ) {
        // The shape test is load-bearing beyond tidiness: the solicited
        // check below uses the in operator, which matches prototype keys
        // ('__proto__', 'constructor') — an unshaped key would reach
        // deliverPage and throw, painting the error banner.
        // Text is accepted only from the direct parent — the document
        // that minted this one.
        if (e.source !== window.parent || window.parent === window) return;
        if (!(d.__bundler_page in pendingFrames) && !(d.__bundler_page in pendingRelays)) return;
        deliverPage(d.__bundler_page, d.__bundler_text);
      }
    });

    const uuids = Object.keys(manifest);
    setStatus('Unpacking ' + uuids.length + ' assets...');

    await Promise.all(uuids.map(async (uuid) => {
      const entry = manifest[uuid];
      try {
        const binaryStr = atob(entry.data);
        const bytes = new Uint8Array(binaryStr.length);
        for (let i = 0; i < binaryStr.length; i++) bytes[i] = binaryStr.charCodeAt(i);

        let finalBytes = bytes;
        if (entry.compressed) {
          if (typeof DecompressionStream !== 'undefined') {
            const ds = new DecompressionStream('gzip');
            const writer = ds.writable.getWriter();
            const reader = ds.readable.getReader();
            writer.write(bytes);
            writer.close();
            const chunks = [];
            let totalLen = 0;
            while (true) {
              const { done, value } = await reader.read();
              if (done) break;
              chunks.push(value);
              totalLen += value.length;
            }
            finalBytes = new Uint8Array(totalLen);
            let offset = 0;
            for (const chunk of chunks) { finalBytes.set(chunk, offset); offset += chunk.length; }
          } else {
            console.warn('DecompressionStream not available, asset ' + uuid + ' may not render');
          }
        }

        if (pageSet.has(uuid)) {
          pageTexts[uuid] = new TextDecoder().decode(finalBytes);
          return;
        }
        if (FONT_MIME.test(entry.mime) && MIME_TOKEN.test(entry.mime)) {
          // Strict artifact hosts allow font-src data: but not blob:.
          blobUrls[uuid] = 'data:' + entry.mime + ';base64,' +
            (entry.compressed ? toBase64(finalBytes) : entry.data);
        } else {
          const blob = new Blob([finalBytes], { type: entry.mime });
          blobUrls[uuid] = URL.createObjectURL(blob);
          resourceBlobs[blobUrls[uuid]] = blob;
        }
      } catch (err) {
        console.error('Failed to decode asset ' + uuid + ':', err);
        const blob = new Blob([], { type: entry.mime });
        blobUrls[uuid] = URL.createObjectURL(blob);
        resourceBlobs[blobUrls[uuid]] = blob;
      }
    }));

    const extResEl = document.querySelector('script[type="__bundler/ext_resources"]');
    const extResources = extResEl ? JSON.parse(extResEl.textContent) : [];
    const resourceMap = {};
    for (const entry of extResources) {
      if (blobUrls[entry.uuid]) resourceMap[entry.id] = blobUrls[entry.uuid];
    }

    // Artifact-host CSP (connect-src 'self') refuses fetch() of blob: URLs —
    // consumers read these Blobs directly. Survives the swap like the error sink.
    window.__resourceBlobs = resourceBlobs;

    setStatus('Rendering...');
    // Page uuids have no blob here — they ride inside about:blank#<uuid>
    // frame markers the pass below resolves after the swap.
    for (const uuid of uuids) {
      if (pageSet.has(uuid)) continue;
      template = template.split(uuid).join(blobUrls[uuid]);
    }

    // Strip integrity + crossorigin — blob URLs from a file:// document inherit
    // a null origin, so crossorigin forces a CORS fetch that SRI then rejects.
    // The manifest bytes are ours; SRI protects against CDN compromise, not this.
    template = template.replace(/\s+integrity="[^"]*"/gi, '').replace(/\s+crossorigin="[^"]*"/gi, '');

    const resourceScript = '<script>window.__resources = ' +
      JSON.stringify(resourceMap).replace(/<\//g, '<\\/') +
      ';</' + 'script>';
    // Inject after <head> so the DOCTYPE stays first; prepending the script
    // would push the parser into quirks mode. DOMParser always emits a <head>
    // (synthesizing one if the source HTML omitted it) but may carry
    // attributes through, so match the full opening tag. slice() rather than
    // replace() keeps us clear of $-pattern substitution in resourceScript.
    const headOpen = template.match(/<head[^>]*>/i);
    if (headOpen) {
      const i = headOpen.index + headOpen[0].length;
      template = template.slice(0, i) + resourceScript + template.slice(i);
    }

    // Parse the template and swap the root element. Scripts inserted via
    // DOMParser/replaceWith are inert per spec — re-create each with
    // createElement so they execute, awaiting onload for src scripts to
    // preserve ordering (React before ReactDOM before Babel before text/babel).
    const doc = new DOMParser().parseFromString(template, 'text/html');
    document.documentElement.replaceWith(doc.documentElement);

    // Resolve page-frame markers: mint this document's own blob for each
    // framed page — from local text when this is the root, otherwise by
    // asking the direct parent over the relay protocol above. An
    // unanswered request leaves the frame on about:blank, the same
    // degraded state as a refused embed.
    {
      const MARKER = /^about:blank#([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(#.*)?$/;
      const needed = [];
      for (const el of Array.from(document.querySelectorAll('iframe'))) {
        const m = MARKER.exec(el.getAttribute('src') || '');
        if (!m) continue;
        const text = pageTexts[m[1]];
        if (typeof text === 'string') {
          mountPage(el, m[2] || '', text);
        } else if (window.parent !== window && !isPageRoot) {
          const had = pendingFrames[m[1]];
          (pendingFrames[m[1]] = had || []).push({ el: el, frag: m[2] || '' });
          if (!had) needed.push(m[1]);
        }
      }
      for (const uuid of needed) {
        window.parent.postMessage({ __bundler_need: uuid }, OWN_TARGET);
      }
    }

    const dead = Array.from(document.scripts);
    for (const old of dead) {
      const s = document.createElement('script');
      for (const a of old.attributes) s.setAttribute(a.name, a.value);
      s.textContent = old.textContent;
      // text/babel scripts with a src: read and inline. transformScriptTags
      // does XHR against the src, but blob:null/ from a file:// origin is
      // silently dropped. Inlining makes it a plain inline babel script,
      // which transformScriptTags handles unconditionally.
      if ((s.type === 'text/babel' || s.type === 'text/jsx') && s.src) {
        const pre = resourceBlobs[s.src.split('#')[0]];
        s.textContent = pre ? await pre.text() : await (await fetch(s.src)).text();
        s.removeAttribute('src');
      }
      const p = s.src ? new Promise(function(r) { s.onload = s.onerror = r; }) : null;
      old.replaceWith(s);
      if (p) await p;
    }
    // Babel standalone auto-transforms type=text/babel on DOMContentLoaded,
    // which fired before we swapped the document. Trigger manually if present.
    if (window.Babel && typeof window.Babel.transformScriptTags === 'function') {
      window.Babel.transformScriptTags();
    }
  } catch (err) {
    setStatus('Error unpacking: ' + err.message);
    console.error('Bundle unpack error:', err);
  }
});

  </script>

  <script type="__bundler/manifest">
{"2fa4feae-3507-4a0e-908b-156f4ee9f68a":{"mime":"text/javascript","compressed":true,"data":"H4sIAAAAAAAAE7U7a3IbN5P/fYqOUrscWuSQkiXHpqLksx5+ypYj2Y6TfFkHM9MkYc0AYwAjinFclTvsnuG7wv7fo+QkWw1gnqRsJ5tNVSwSaDS6G0C/ORrBPxI9ZMkcFYoYh3wmpEIYDkFmmKIxCNowZVCBjtl0KtMEAsUWgClmKIwezfFqlF9BtIQENZ+J/o3RCA5lzjFZwRHCGQ5VIQQXM4hlvnzjJ97EMsulQGFgwc0czJxruOAiAXmJaqG4Qe0GpzzFEgYhZQa1gUtUmksBQc5mCLEUhjBxDYVg0ynGBpN+eGN0Ew6OHzx6Bi/P7z04hpujG6ObN2/ATfjazBXiMBlqw2b4Dfzx+3/BrSOQ0VuMDVxyXKCCTcCrXDpJzDFNIbCrwre6H94Ai+fF3HI6Q5ALoS2Bi7lMEXSMAifwPUYPTkChSFChGoDAwiiWgjZFwiWkfDY3XMwIleWQgZZTAzMlC5GAnrNELgYgVcSNZVLJVEOQKDYDI934ABZzxJS+/yplNiBcivAOS7Ccif4AGMQsQ8WAFUYOp4plmNAs0ez47mmIaF89AIWa/4qEas5EknIxGwATCTBI5EKkktFSmUZMgZkz4wXlBBAXStFheGEyTWhODx7DJjx9cQJSwYOTAwgiLphawix9cb8fwv2D1xAzIaSBCEu5J8CFRRkpudCo9ggTLeZuJy4MqnjOxAxhKlVGhFyiWkImE1SCTpSoBJ5Z6spDK08RiA/CpGQxc7eLblNP+wWQsTyERyJOiwTdXTx+fe/wBeRcCEwIVcZyovHrObLkmwFEOKW3xIQloUgRVCG0vV3+wmorRiJ8prhZwpzpOVoJacOWYOQMzRwVBJplaNETWRvV3dwAfcHTFDImEnoJ/YlnCuBrHSueGzDLHPc3HAsZyze+cdPv3R8AP6U3JvUYwIaVysYENubG5HoyGhUiv5iFscxGduof43Drzk44HkUFTxM3Fjouw7d6Y9BFNWJJIoUeldd2dEq39dB/oyWfsRdesSxPUY/e6uwjmK7dvHzAenR68PjYf/kre1+L6DO2fnDy4v7fs3cXU7n3h0F9uOXV6hzvXzvVCWzoObt1Z2d45/7hj1v46vQ2NzubeYTxNjsy4oVavP3+9Y8nj88ON5/ee3D46PnRTP8gXqp0dDy+t/1Dev8Ol0+fPBo9bgnqzxATS9UhJVlsS/kcF+z4kbo3S2/L+0cHWXbw/eHxXfn93ZOrswfxdPHjeH5yeZyrX+X2eHvxOv3q8vCHh2fpuTh98adI+cwbWFO3o37lz65OD3588t3tu3xzsTm9c/fJ493dF4c/vCsW8fxVdLD8bpGxU3x0+jo5fbn9/ORI3Lo4nb5+uHj0+PDuX6fuY5fdEyeihZE/Hj97fHTr1bvNe4dPxofFg++S50+Lo+8fXrDscPvJ46OvxsevdsV0dvvtd2+nef7kFNn4qx8eP9t8duvvIG7Nc/DUvZLTi8v8we2Hx2fz+4c/RPrl6UN89vrg8N2jo20xfXfx3Tvx6tfjrbfxSD6Pf91893jr1r2j5PXD8Z358Wb8Xf0e3Af/5+uR04zfeFX5UrMZTkqlaZYpftNyByZCmmCS4JQLTPrvL7nmEU+5WU7mPElQfPh65FZ5FK3FIFiG+xtKxhdoNr75etT2NNqqWqt4f6MFQAL5pknwimJ3j7PU6kBugTbeCdmHRMYFeWnhuwLV8hxTjI1UQa+1Sa+/1179Hl48PDs+hg+wD2zBuMcXKmTJsgNLtjWFfRC4cKvCB0oWeVDjHI3gj9//Zd+wtV5uhSwMyKkVTwIZktlzPo8fYQYVZ6m1lg1MhIAgNEQYywydvwIjKDRmJgUURnHUpadQeQ6nB4//+P1fJSLHjkZzaq1oYEkqKe7ej3vGKB4VBrW/JLS/v/Rkyt0ezi+NmEY7HSQ4ZUVqYMPi3ui7pRGLL7w3R0sPz88hlqlUEOGcnF2i2fqKNQIGC6YyyFmOCowU6FGR36akYQYtqsUcBeQKNQpD3p1O5QJMoYRhUYpQCMNTi77QqJyrxGKjPY9P7ZlwAQpZOlxIldKh0PscQIwETM68k6lUfMbFAJbDIm8IwHotXMxRcVPz0SMXnBvn50jFURhmuBRhw1ee8jTVQEByISCSV/YgyOME7sMBqRLnH5LEKtFsjceXixH9O7euGsxRycoZP/JQGk2RT67ztSGYY8Z1TvEPbMIFLmHTUkQ+sqVjjQdOzDw7BRSXXElBD8z6ZiQMLWHOZ3OSHksFak0+HeER0sxpPyNB4TS1vrBIfDCgQSBTwyhl8UUIhyxvrGd2b0IxDm/98ft/jsMduzJmSi2BOUhIpbwog4bIOvyo7HV0F8zJO7ZRGaGyt5VrWMpC6Qmw5G2h3bFZwehBI9po3lou4E0kpQnsLbSXro4YQCAmmqICPp2i9fqJLDoQCrXg+NlRHXrdCII+7H9DXkmltJYpKQI0sA+/3KD3NZlL0kc33GvLpeZ0eSagMGWGX+Ken0m4zlO2nECUyviiHF3wxMwndE3+rRyaI7Fnxy7n5WDN3wQumQqGTi8Oo9kAvpyOEfF2v4SlcHSaysUEnPZ34x/svzETl0zD+y45pOxSTgGgkAL3PHRYhkyr7LFIy7QwFXvKE307v6polsbIrD1WbTtNsRqcsXwCd2qgqRRmOGUZT5cTGLI8T3Gol9pgNoCDlIuLpyw+t9/vS1IlG+c4kwgvH20M4ExG0sgBaCb0UKPi0yb7FUNRYYwUFV8sz5EpJuJSABULKkE1ga38CrRMeQJqFrFgezwA+n/r7gDId+i34YeKJbzQLZ6aB+hw7O4OoP5nHN7drtDY9zCBL7fY1t2t3bVi8WqsNUf6aAJb2+FuR5YLf6V2x+NynA57WF21cjRnScLFbAJ38yvY2q7RxIXSRJLXax+R6WRO9w/etzj+cjqdrlwqD89ieibwHoxiQlNUPHEfKXHyQ7CVX/WvWfpTwjWZjuRneA8yZzF5PDAOd/cgl9Z+DPGSEkCdWy2kwc+40ilOP+NGZ+xq6F/x7foRk9gnsDMeWymOtsLdv+siX3c7Pn3B7uz2V855h8553OSwdYEbfJJRHmrrnjXfiBcpqs9RElxoNBMYr2iD5ptjKZ+JITeY6Ym37OUUWQA+XQ599qw7XXG1vdN+APbmw9aOPYnbf/9J3GHb0+2KK4NXZmi56BK4mHODQ50z0jO5wiG9wlqOv+zduAEwLURM4qsSV0GUymhg7SE5bn0vaGeRCkWu7cuzkzBWyAw6d/Hl2Yld5Q/cgbKmt+2gj12GNOixngdl4VzhFPYJcTlSZdD2KyLcVIUtkskyJCUqksM5T5OAVejilMcXQfVVYSYvsfyu0bzgGcrCeFNLjCi8lBcNRgpFns7OeDy2qz6QkEY3b8ILynCSabcWmInSzWXGYJZbr8qk6NxYY3PBRi1BinTpXA1aRlTcBAgevnh68somUfuU+OJTji5jp2WhYvR+0JDCCzuuySfENNGkEVFofonp0iPzObVYkkcrZnuVX4Up+TpKau2R25ymS2EytQzhQcFUgglo6VHVZMdMgKBcIUQK2YVdXp1Lzsw8JI+lcXuEpKfiwtbA5RoHIC/K20M4ywe74CKRizBn5A+FudTmKWoKOQMPAKSdlzlOoFemyycO//BWMnRi7w18RnMC9W4TkBewv78PRhVokz7+v97Nnv/sb8IHiJmJ5xDQ/f5QHnOcMq3hBYWCR+fWE8crgyLRQAfmb2/zPajCRo/9ijdd5KiChmWll6CkJAeOEqQhM4bF83PrSgbvbehHbOYoevChs866fx95RXa+Vy2yX0NSB4c+3b/f8CArz0lK03o7FqRCYol8Q/r1+n0TftlbXRBa6T2jK7YPPVSqd+2W1ZoOw9ZSfua+BNvekkZ6rem2LHpHzbIA/M9/g46VTKvKAI2sFAauZ4J26Eih9Bf+lOj8ojYvfrDXBpXR2wMjPoLeOSrdHdyykJ4U4fZA62E6EiuffFWeWL+MJckxuT4nXBsUqIKe1cO9ATg964BVIbyC6Mnoba/fIXOWRn+FO7fs49yVMNdw9+DkYP2CP83XLI1W+CoPePUFOOl9Nrgjqv+JZ+XXd7BqNAdWMvpYWCc2mLJU1xeYLNwZaplelmmnOuclRYyNRAzXkJILTYauk8QqFe5Ncr7gl5VU2S+UDSjtk2KxN0wpjxTlMugwvGGpKLfrfDrtuZIZ1xgEylFKdTgy21XY3OTYLvQswT74JXvroWywvu/RlTClPra2weooYQunhyxNyf9t6H0+BS9+ygVg0m+QMxpRjdcpfkyATSkRwcC6Jiy1YlSoi4xKo8yQl1rtBNrIPMckrJDVG5VF0+ZWNVdujjJ69wTPbIbpRMrcr02lzPt7q8sk/Pu/V59DGWlUl2jXNKA/VJ8UUj6tElfrwjk5gLPFeytTQT+0FjgIyAysOz8yKc6keb+dnizF8b3uGRJk62k3GOtVxcwp46mr6Npr9k/Rg80m4OEc4wtXrbWVTlvDvL5oCFMlM58/JE+hg42sg6anUlU/1xQ/He7wn6JLzLlRXMxINHQgxF/mXCT4tvVtAk0juuZOB835zn1meiniMnlVid9Z4mhWOiwzNFW+N+jVYV+thulKRrO+A3cnptE8VzJHZZZBr04e9QYQzTo2/yerZQZV9f6pTH6usuz+wYcsTYOf6jeQOWVrj7bXH6yf+GR9tV75c0dZOsW37xRgpSFHLpusLvFIsQUXs4OCknpwgZh7Pca08V42nYHNM9vnXqOwXR0UsFKi1cgjZtjLsxMYQaLY4lHGZti3GoFTt4HVBym6voEah44VotBzaWz5XkPMclOolo4W2iBLqKDAIEqZuPC5uLAl/FJPtMoVtifjzM8E9bNkwnCWcqYn9k3XYmdpPmfdwbWyagPV/m5TXz3nV5iekcYKnlKgkXER+JAhwUseYw0Av/0GWwPY7q9BZD3spywP0dm7jiZaA+g9CCeE54f3z+XUnJez7QvSkFv5sQXgkJ6RgaYkhDIH9u0H1a6JzLxbM6iVWH/vRtv/t0fZPJpzGgm6pt2D2b8dFL6lpYnjOSqdo82CHdrZYGd3QGIch+OtAaUu6hdq58Myw0KnE9wawHa4PYCdDhXVTu5Dl46yN8dR0njsYetZBm71ANZIqqk43Bt2R3vEspyeU/uAK6DETd9nFKrBPrF5p0N6TVz5sSJ/NIJnrTrJxNU/9MVy5CsAC6bntsBkD30YM21fNxVObOlgUKPyLUI8swUVZ0J8oUtL0Dydy4LCXe2D75kEVwEpQzw6YvJKg/o8H1bVmhPaLRhfTe1/AxhfJXeS7XhnAFvhuN/Ru0Re81occYU2lGdpF892WOeKL3DZvg87A/hqALstABKBezmdQ6FJJ6YwY/k5/9WaimB7vHOHUtw7d/prICPO6GiG43A8Hm+3j85xcYHLvRUJXeCyw7KV+ad53sHb9Bhqlmhdm+nh7gBuDWBYP4J6X1sq61x/f1Oaez9FPa8THo3nmTKBD1DaPEywPba5/3HDyDW0gVdOrjActJLSW3fgQ7+d8wBPRmiLpMTKFYnVKtnnj2AE2104jJFf4tqT9BFJyZf7sCoMN16Lwy1rVGq9lzFnuuFl1PO91UdPk2etxQ18H4E+z9Faga1wexVqJc6zXZhVnFcbwfVk2Fiq6WZ17h3FFmswaQOLkok4pVLw95Tat2ZtrwM4bwM+tLWUDmTTjNLjChYDmDfcQ6/PmdX/sA8LGMF8ZbrIqXPuuZJv3eN4yoziV7XV+VC/C9O1RUr6S35mGyRPXQShgik3HUgKQdZLxcnXURH013DnPgT2lg081avUjUZwhD7mWsypuluFAgumYYompjD0WzinxkKepC6ibXlaKyFfGanZ6+GdPmLEFvM9syBFjYEyGEREqcGr+I3rwxJ5fzV2vTb4+lOR3Yf2s2tGxEEV3reDgmb0uSbOHY3g3Mjck0FmruacvjlBJ17ue6sCbEqGJEkttZRNDihFXrlV3GhMpxQ+XWBu7LkwoEy+TU24VpYaU5kvgqxwSURQWCcmnDLqd+XfiJ8/FTOLwmr0FQSyXx9XLbegLVBKrJzP5QICK6mF6Df6A6j7O09tHoTCwlzhJZeF9rMDcA6OdlvfBO9iaGo88Y28SL6HQm2oX6RsSPFqOSdT4nozbFBS47FtyM5hM9I2mrjG5ir5UncCOVK68WEZITXipaaAvrAjfds6vLD64FiplTariT8rSvDYI+6mi2DKlTa9NbIvqWp4wGWtpwWwkq10is99KCf9WRjFqAkZg0B2lBLtK0OuyWa30y3yel/HTX/MhtYpk27mP5JXLWfhQF7dCvp0M+8rmbVPpiX3SF6FXB9nuVkG/ZUklG9o8WJoXxZ6WNSClkn7kG3zke1rCju6yTsHlT9EDhhtm3ERLrtWy7cROYgZmgNay8Xs3I43vFg/0O93MSRctzM6gcMZuqIxjMA6MIaJIGhGIuFUXlIfl/Nu+jCCW7fH/T7chK3w1u7qLu0Y+JVtC7wV2LCI6tlb4fZuPxRUakrJsq4kXTqxUoPgkH7WUVLtKrT95jT5SQlXYVakhufp8jxmKVMBMd6/bhtqjoJ9x13GriwwjKiJx8Vx162buuoEQd8k6GvAPuUCdCOn0DA1Q7OO02uXrBr48sowKgK0T/km3OoiakQInmrqoCCPljB8GtqWeuxGnwNtrLfyebCub+PzKfmkw7Ua7ttLs1bHrSb6SeW0bdIMDbwpOzMb1t3lc72ObSf+CLLXJ3+zZzP9vX6onOkKRj/9xz8X4fDnzdFsAL03vfZeawiSot6yVUYqG2xgH76Qos2Xr8isA2lY2uPKKlqzVzbNVn14heDvCtcwS3VjkCPfJkutEb61FpyNtNEiF2SPKI839Q6MHvjqvBWVzf86nNVeKdemMqRvaKvn5Cyu5FgzZiiu/ennTtUXUXhddI4NBztFYxl7RDmM1iAzrbGmrfuEUfuitmrtXH417VpA3F9KwOdMmTc92HSk1OCOss391cAltQoc7inFliHX9m8gw1JcffgW6m8wgZ/qbz/XuOiwAi83ymoS1rYptgRndENJsCF3P0vSQdbv26iCi7ZtdvBhs8elYqZiN2OeW2Ye7bVhSOptfpulEfCucEDHSeFt4Le6di//YZOe0F/b0W5FisFv1YSzMskLPQ+yNaWcZibW3msCX3lcpwI7TS/kevp+cv9LOdscM5cLm77iZVdMmXa+CXCG1inUlPBitihDmWv6cZcG+0uCFCvPpECXOtT0i0G8YrFJl/b3ctBsfXHtNUIOvV+DTKXLkhGurZPJRNWnExDqslLPa2SVZqk7w11jvv0VXN+/evczPl/CrF65L6XUhWDXk9KuD37Rdl3bD67ZIAPeE/ZYbEeLrZjDt2Wy2O5yGr0N+jBpjT1Io5YTtbYvp2ERmq0wqlVLXLuyXTQG7+CjUm1b1a4wNan9bIFUP6aoikFrqzvX/aan1/GovbJ1OzZ0csfvpvbwEqo0kG0QGb1tuKO9zKQpj6j65xZvQi/MTGoLelaHZ5TirkkL+tT4pK8JU6w6N5Sk7H0Jx+VPNaIltOKmf9btDV21SGz2V5JMsVUv7ncVv/0G70FRivDOAGb+b2T/1rmTunOJfvi5b6ufhD20A7YJ315KUWQRKrqXzSnXFNtB5XOTTWTVUBdVOTFp6jqSyyYB4oI+Wh1ZqcyGSErIhvLrPUksfByq0Mj7/AqTYKdP6/zwbP1w1Bleswv0nmgYh9vj8bj9Zy3sM20xW7fdhlFBsAVDJ2YKTSjTe+1GjgcvmxXKGktKrV51dNI9PEhlFPwko7c/D+r2Oqqaj/KUcdt9NqivsO3P2bseT2bSz8KTmbTjD7Z0gtVW/486ofNTum7r0P9FD0TFtKKifOfN7cqHfo/4bb32QeN9uh95X1cWrQRfK+XqBKJi2jwBa6pGs9RMhw6nPYh6n/JAqEHJj1bnUnY/FtpUxTYdut/3dX8ZN2i2R/b3bnzok+z+F/7XKWg1QQAA"}}
  </script>

  <script type="__bundler/ext_resources">
[]
  </script>

  <script type="__bundler/page_order">
[]
  </script>

  <script type="__bundler/template">
"<!DOCTYPE html>\n<html lang=\"de\"><head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width,initial-scale=1,maximum-scale=1,viewport-fit=cover\">\n<title>Wohnung – 3D Miniatur (Handy)<\u002Ftitle>\n<script type=\"importmap\">\n{\n  \"imports\": {\n    \"three\": \"https://unpkg.com/three@0.184.0/build/three.module.js\",\n    \"three/addons/controls/OrbitControls.js\": \"https://unpkg.com/three@0.184.0/examples/jsm/controls/OrbitControls.js\",\n    \"three/addons/exporters/OBJExporter.js\": \"https://unpkg.com/three@0.184.0/examples/jsm/exporters/OBJExporter.js\",\n    \"three/addons/exporters/GLTFExporter.js\": \"https://unpkg.com/three@0.184.0/examples/jsm/exporters/GLTFExporter.js\",\n    \"three/examples/jsm/\": \"https://unpkg.com/three@0.184.0/examples/jsm/\",\n    \"three/addons/\": \"https://unpkg.com/three@0.184.0/examples/jsm/\",\n    \"three-mesh-bvh\": \"https://cdn.jsdelivr.net/npm/three-mesh-bvh@0.9.5/build/index.module.js\",\n    \"three-gpu-pathtracer\": \"https://cdn.jsdelivr.net/npm/three-gpu-pathtracer@0.0.24/build/index.module.js\",\n    \"n8ao\": \"https://cdn.jsdelivr.net/npm/n8ao@1/dist/N8AO.js\",\n    \"postprocessing\": \"https://cdn.jsdelivr.net/npm/postprocessing@6/build/index.js\"\n  },\n  \"integrity\": {\n    \"https://unpkg.com/three@0.184.0/build/three.module.js\": \"sha384-8FCZ1eVO6it4+pbec2aDtnTrwjWXZLJRC+MAGCIPDgsYnUrl/E0A2YlF8ioMKI/J\",\n    \"https://unpkg.com/three@0.184.0/build/three.core.js\": \"sha384-dw2ooPewaEIrAgl6oFDBmmBWCE9oW9LxRGcfwZ0hLvEprzo202wXl7vCYHRlSnOT\",\n    \"https://unpkg.com/three@0.184.0/examples/jsm/controls/OrbitControls.js\": \"sha384-4rziNxOBZKQ69i+w+f89KJ55TCYquwchVbByQwmaOeIOXdOU2PLDn3kOfXHwIJC9\",\n    \"https://unpkg.com/three@0.184.0/examples/jsm/exporters/OBJExporter.js\": \"sha384-nbwtoZENJD3Vq+ACK0CuGQdPMuDWHkamC2KJD70EV5nfg6jQjfppKOea07YJN+N3\",\n    \"https://unpkg.com/three@0.184.0/examples/jsm/exporters/GLTFExporter.js\": \"sha384-VofkvpG6HERhFCYbsUOHeNXBCqID2nfqkQqnVzE1jc/oPcz+qJ13ADdXH08hE+cQ\"\n  }\n}\n<\u002Fscript>\n<style>\n  html,body{margin:0;height:100%;background:#efece6;font-family:Helvetica,Arial,sans-serif}\n  three-d-stage:not(:defined){visibility:hidden}\n  #rooms{position:fixed;left:50%;bottom:22px;transform:translateX(-50%);display:flex;gap:6px;padding:6px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);border-radius:999px;box-shadow:0 6px 24px rgba(30,28,24,.14)}\n  #rooms button{appearance:none;border:0;background:transparent;color:#2f2d2a;font:500 14px/1 Helvetica,Arial,sans-serif;padding:11px 18px;border-radius:999px;cursor:pointer;transition:background .2s,color .2s}\n  #rooms button:hover{background:rgba(47,45,42,.08)}\n  #rooms button.on{background:#2f2d2a;color:#f7f5f0}\n  #pov{position:fixed;left:50%;top:18px;transform:translate(-50%,-8px);opacity:0;pointer-events:none;transition:opacity .3s,transform .3s;display:flex;gap:4px;padding:4px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);border-radius:999px;box-shadow:0 1px 2px rgba(0,0,0,.06),0 6px 20px rgba(0,0,0,.08)}\n  #pov.show{opacity:1;pointer-events:auto;transform:translate(-50%,0)}\n  #pov button{appearance:none;border:0;background:transparent;color:#2f2d2a;font:500 13px/1 Helvetica,Arial,sans-serif;padding:9px 14px;border-radius:999px;cursor:pointer;transition:background .2s,color .2s}\n  #pov button:hover{background:rgba(47,45,42,.08)}\n  #pov button.on{background:#2f2d2a;color:#f7f5f0}\n  #lamp{position:fixed;left:50%;bottom:82px;transform:translate(-50%,10px);opacity:0;pointer-events:none;transition:opacity .35s,transform .35s;display:flex;align-items:center;gap:4px;padding:4px;border-radius:999px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);color:#2f2d2a;font:500 14px/1 Helvetica,Arial,sans-serif;box-shadow:0 4px 18px rgba(0,0,0,.08)}\n  #lampT{display:flex;align-items:center;gap:10px;appearance:none;border:0;background:transparent;color:inherit;font:inherit;padding:7px 14px 7px 10px;border-radius:999px;cursor:pointer;white-space:nowrap}\n  #lampT:hover{background:rgba(47,45,42,.08)}\n  #lampCtl{display:flex;align-items:center;gap:14px;max-width:0;overflow:hidden;opacity:0;transition:max-width .4s,opacity .3s,padding .4s;padding:0}\n  #lamp.on #lampCtl{max-width:420px;opacity:1;padding:0 12px 0 6px}\n  #lampSw{display:flex;gap:6px}\n  #lampSw button{appearance:none;width:22px;height:22px;border-radius:50%;border:2px solid rgba(250,248,244,.9);box-shadow:0 0 0 1px rgba(47,45,42,.18);cursor:pointer;padding:0}\n  #lampSw button.sel{box-shadow:0 0 0 2px #2f2d2a}\n  #lampSw{align-items:center;gap:8px;font-size:12px;color:#6b665e}\n  #lampSw input[type=color]{appearance:none;-webkit-appearance:none;width:26px;height:26px;border-radius:50%;border:2px solid rgba(250,248,244,.9);box-shadow:0 0 0 1px rgba(47,45,42,.25);padding:0;cursor:pointer;background:none}\n  #lampSw input[type=color]::-webkit-color-swatch-wrapper{padding:0}\n  #lampSw input[type=color]::-webkit-color-swatch{border:0;border-radius:50%}\n  #lampSw input[type=color]::-moz-color-swatch{border:0;border-radius:50%}\n  #lampDim{display:flex;align-items:center;gap:8px;font-size:12px;color:#6b665e}\n  #lampDim input{width:110px;accent-color:#2f2d2a}\n  #lampDim output{width:34px;text-align:right;font-variant-numeric:tabular-nums}\n  #lamp.show{opacity:1;transform:translate(-50%,0);pointer-events:auto}\n  #lamp i{width:12px;height:12px;border-radius:50%;background:#bdb8ae;transition:background .3s,box-shadow .3s}\n  #pt{position:fixed;top:18px;right:18px;padding:8px 12px;border-radius:999px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);color:#2f2d2a;font:500 12px/1 ui-monospace,Menlo,monospace;opacity:0;transition:opacity .3s;pointer-events:none}\n  #pt.show{opacity:1}\n  #pt{top:62px !important}\n  #rt{position:fixed;top:18px;right:18px;display:flex;align-items:center;gap:8px;appearance:none;border:0;padding:9px 14px 9px 11px;border-radius:999px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);color:#2f2d2a;font:500 13px/1 Helvetica,Arial,sans-serif;cursor:pointer;box-shadow:0 1px 2px rgba(0,0,0,.06),0 6px 20px rgba(0,0,0,.08);transition:background .2s,color .2s}\n  #rt i{width:10px;height:10px;border-radius:50%;background:#bdb8ae;transition:background .2s}\n  #rt.on{background:#2f2d2a;color:#f7f5f0}\n  #rt.on i{background:#7fd08a}\n  #lamp.on i{background:#ffc86b;box-shadow:0 0 10px 3px rgba(255,190,90,.6)}\n  #lampD{display:flex;align-items:center;gap:10px;appearance:none;border:0;background:transparent;color:inherit;font:inherit;padding:7px 14px 7px 10px;border-radius:999px;cursor:pointer;white-space:nowrap}\n  #lampD:hover{background:rgba(47,45,42,.08)}\n  #tvB{display:flex;align-items:center;gap:8px;appearance:none;border:0;background:transparent;color:inherit;font:inherit;padding:7px 14px 7px 10px;border-radius:999px;cursor:pointer;white-space:nowrap}\n  #tvB:hover{background:rgba(255,255,255,.1)}\n  #tvB svg{flex:none;transition:color .3s}\n  #tvBar{position:fixed;left:50%;bottom:22px;transform:translate(-50%,10px);opacity:0;pointer-events:none;transition:opacity .4s,transform .4s;display:flex;gap:4px;padding:4px;border-radius:999px;background:rgba(20,20,18,.55);backdrop-filter:blur(12px);-webkit-backdrop-filter:blur(12px);z-index:60}\n  #tvBar.show{opacity:1;transform:translate(-50%,0);pointer-events:auto}\n  #tvUI{position:fixed;inset:0;z-index:55;opacity:0;pointer-events:none;transition:opacity .5s;font-family:Helvetica,Arial,sans-serif;color:#f2f1ec;background:#0b0c0e;overflow:hidden}\n  #tvUI.show{opacity:1;pointer-events:auto}\n  #tvUI .tv-hero{--a:#e5484d;position:absolute;inset:0;display:flex;flex-direction:column;justify-content:flex-end;gap:6px;padding:0 clamp(20px,6vw,80px) clamp(150px,22vh,220px);background:radial-gradient(120% 90% at 85% 20%,color-mix(in oklch,var(--a) 55%,transparent),transparent 60%),linear-gradient(180deg,#0b0c0e 0%,#121316 100%);transition:background .5s}\n  #tvUI .tv-hero small{font-size:clamp(12px,1.4vw,15px);letter-spacing:.08em;text-transform:uppercase;color:#bdbab2}\n  #tvUI .tv-hero h2{margin:0;font-weight:700;font-size:clamp(40px,8vw,110px);line-height:1;letter-spacing:-.02em;text-wrap:balance}\n  #tvUI .tv-nav{position:absolute;left:0;right:0;top:clamp(14px,3vh,28px);display:flex;gap:8px;padding:6px clamp(20px,6vw,80px);overflow-x:auto;scrollbar-width:none;-webkit-overflow-scrolling:touch}\n  #tvUI .tv-nav::-webkit-scrollbar{display:none}\n  #tvUI .tv-nav button{flex:none;appearance:none;border:0;background:rgba(255,255,255,.08);color:#f2f1ec;font:500 clamp(14px,1.5vw,17px)/1 Helvetica,Arial,sans-serif;padding:13px 20px;border-radius:999px;cursor:pointer;transition:background .2s,color .2s,transform .2s;min-height:44px}\n  #tvUI .tv-nav button:hover{background:rgba(255,255,255,.16)}\n  #tvUI .tv-nav button.on{background:#f2f1ec;color:#111214;transform:scale(1.04)}\n  #tvUI .tv-vol{position:absolute;right:clamp(12px,2.5vw,32px);top:50%;transform:translateY(-50%);display:flex;flex-direction:column;align-items:center;gap:10px;padding:10px 8px;border-radius:999px;background:rgba(255,255,255,.08);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px)}\n  #tvUI .tv-vb{appearance:none;border:0;width:44px;height:44px;border-radius:50%;background:transparent;color:#f2f1ec;font:400 22px/1 Helvetica,Arial,sans-serif;cursor:pointer}\n  #tvUI .tv-vb:hover{background:rgba(255,255,255,.12)}\n  #tvUI .tv-vol input{--v:35%;-webkit-appearance:none;appearance:none;writing-mode:vertical-lr;direction:rtl;width:6px;height:clamp(120px,28vh,220px);border-radius:3px;background:linear-gradient(to top,#f2f1ec var(--v),rgba(255,255,255,.2) var(--v));cursor:pointer;margin:0}\n  #tvUI .tv-vol input::-webkit-slider-thumb{-webkit-appearance:none;width:18px;height:18px;border-radius:50%;background:#f2f1ec;box-shadow:0 1px 4px rgba(0,0,0,.4)}\n  #tvUI .tv-vol input::-moz-range-thumb{width:18px;height:18px;border:0;border-radius:50%;background:#f2f1ec}\n  #tvUI .tv-vol output{font:500 12px/1 Helvetica,Arial,sans-serif;color:#bdbab2;font-variant-numeric:tabular-nums;padding-bottom:4px}\n  @media (max-width:600px){#tvUI .tv-nav button{padding:12px 16px}#tvUI .tv-vol{right:10px;padding:6px 4px}#tvUI .tv-hero{padding-right:80px}}\n  #tvBar button{display:flex;align-items:center;gap:8px;appearance:none;border:0;background:transparent;color:#f2f1ec;font:500 13px/1 Helvetica,Arial,sans-serif;padding:9px 14px;border-radius:999px;cursor:pointer}\n  #tvBar button:hover{background:rgba(255,255,255,.12)}\n  body.tvfocus #rooms,body.tvfocus #pov,body.tvfocus #rt,body.tvfocus #pt,body.tvfocus #lamp,body.tvfocus #lamp2,body.tvfocus #mp{opacity:0 !important;pointer-events:none !important;transition:opacity .4s}\n  #tvB .pw{transition:fill .3s,stroke .3s}\n  #tvB.on .pw{fill:#e5484d;stroke:#e5484d}\n  #tvB.on svg{filter:drop-shadow(0 0 4px rgba(120,170,255,.7))}\n  #tvB{padding:11px 14px 11px 10px;font-size:13px}\n  #tvBar{bottom:max(env(safe-area-inset-bottom),18px)}\n  #tvUI .tv-nav{top:max(env(safe-area-inset-top),14px)}\n  #tvUI .tv-hero{padding-bottom:calc(110px + env(safe-area-inset-bottom))}\n  @media (orientation:landscape) and (max-height:500px){#tvUI .tv-hero{padding-bottom:80px}#tvUI .tv-hero h2{font-size:44px}#tvUI .tv-vol input{height:90px}#tvUI .tv-vb{width:36px;height:36px}}\n  #lampD b{width:12px;height:12px;border-radius:50%;background:#bdb8ae;transition:background .3s,box-shadow .3s}\n  #lampD.on b{background:#ff9a3c;box-shadow:0 0 10px 3px rgba(255,150,60,.6)}\n  #lamp2{position:fixed;left:50%;bottom:82px;transform:translate(-50%,10px);opacity:0;pointer-events:none;transition:opacity .35s,transform .35s;display:flex;align-items:center;gap:4px;padding:4px;border-radius:999px;background:rgba(250,248,244,.82);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);color:#2f2d2a;font:500 14px/1 Helvetica,Arial,sans-serif;box-shadow:0 4px 18px rgba(0,0,0,.08)}\n  #lamp2.show{opacity:1;transform:translate(-50%,0);pointer-events:auto}\n  #tripT{display:flex;align-items:center;gap:10px;appearance:none;border:0;background:transparent;color:inherit;font:inherit;padding:7px 14px 7px 10px;border-radius:999px;cursor:pointer;white-space:nowrap}\n  #tripT:hover{background:rgba(47,45,42,.08)}\n  #tripT i{width:12px;height:12px;border-radius:50%;background:#bdb8ae;transition:background .3s,box-shadow .3s}\n  #tripCtl{display:flex;align-items:center;gap:14px;max-width:0;overflow:hidden;opacity:0;transition:max-width .4s,opacity .3s,padding .4s;padding:0}\n  #lamp2.on #tripCtl{max-width:560px;opacity:1;padding:0 12px 0 6px}\n  #tripCtl label{display:flex;align-items:center;gap:8px;font-size:12px;color:#6b665e}\n  #tripCtl input[type=range]{width:100px;accent-color:#2f2d2a}\n  #tripCtl output{width:34px;text-align:right;font-variant-numeric:tabular-nums}\n  #tripCtl input[type=color]{appearance:none;-webkit-appearance:none;width:26px;height:26px;border-radius:50%;border:2px solid rgba(250,248,244,.9);box-shadow:0 0 0 1px rgba(47,45,42,.25);padding:0;cursor:pointer;background:none}\n  #tripCtl input[type=color]::-webkit-color-swatch-wrapper{padding:0}\n  #tripCtl input[type=color]::-webkit-color-swatch{border:0;border-radius:50%}\n  #tripCtl input[type=color]::-moz-color-swatch{border:0;border-radius:50%}\n  #rooms,#pov,#rt,#pt,#lamp,#lamp2,three-d-stage::part(toolbar){transition:opacity .6s}\n  body.idle #rooms,body.idle #pov,body.idle #rt,body.idle #pt,body.idle #lamp,body.idle #lamp2{opacity:0 !important;pointer-events:none}\n  body.idle{cursor:none}\n\n  /* muavin-Gradient für GUI-Leisten */\n  #rooms,#pov,#lamp,#lamp2,#pt,#rt{background-color:#000 !important;background-image:radial-gradient(circle at 65.34% 44.62%, rgba(95,95,95,1) 0%, rgba(95,95,95,.844) 8.53%, rgba(95,95,95,.5) 17.05%, rgba(95,95,95,.156) 25.58%, rgba(95,95,95,0) 34.1%),radial-gradient(circle at 28.07% 74.48%, rgba(53,54,48,1) 0%, rgba(53,54,48,.844) 11.41%, rgba(53,54,48,.5) 22.83%, rgba(53,54,48,.156) 34.24%, rgba(53,54,48,0) 45.65%),radial-gradient(circle at 52.42% 19.94%, rgba(56,122,56,1) 0%, rgba(56,122,56,.844) 14.39%, rgba(56,122,56,.5) 28.77%, rgba(56,122,56,.156) 43.16%, rgba(56,122,56,0) 57.55%),radial-gradient(circle at 80.31% 84.47%, rgba(0,0,0,1) 0%, rgba(0,0,0,.844) 17.27%, rgba(0,0,0,.5) 34.55%, rgba(0,0,0,.156) 51.82%, rgba(0,0,0,0) 69.1%) !important;background-size:100% 100% !important;color:#f2f1ec !important;box-shadow:0 6px 24px rgba(0,0,0,.25),inset 0 0 0 1px rgba(255,255,255,.08)}\n  #rooms button,#pov button{color:#f2f1ec}\n  #rooms button:hover,#pov button:hover,#lampT:hover,#lampD:hover,#tripT:hover{background:rgba(255,255,255,.1)}\n  #rooms button.on,#pov button.on,#rt.on{background:#f2f1ec !important;background-image:none !important;color:#141412 !important}\n  #lampSw,#lampDim,#tripCtl{color:#d9d7d0 !important}\n  #lampSw button.sel{box-shadow:0 0 0 2px #f2f1ec}\n  #lampDim input[type=range],#tripCtl input[type=range]{accent-color:#f2f1ec}\n  .lp-sw{appearance:none;width:26px;height:26px;border-radius:50%;border:2px solid rgba(250,248,244,.9);box-shadow:0 0 0 1px rgba(47,45,42,.25);padding:0;cursor:pointer;flex:none}\n  .lpick{position:fixed;z-index:50;width:236px;padding:14px;border-radius:18px;background:rgba(26,27,24,.38);backdrop-filter:blur(18px) saturate(1.2);-webkit-backdrop-filter:blur(18px) saturate(1.2);color:#f2f1ec;font:500 12px/1.2 Helvetica,Arial,sans-serif;box-shadow:0 10px 36px rgba(0,0,0,.35),inset 0 0 0 1px rgba(255,255,255,.08);display:none;flex-direction:column;gap:14px;transition:opacity .6s}\n  .lpick.open{display:flex}\n  body.lpfocus #rooms,body.lpfocus #pov,body.lpfocus #rt,body.lpfocus #pt,body.lpfocus #lamp,body.lpfocus #lamp2,body.lpfocus three-d-stage::part(toolbar){opacity:0 !important;pointer-events:none !important}\n  .lp-done{appearance:none;border:0;border-radius:999px;padding:9px 0;background:rgba(255,255,255,.1);color:#f2f1ec;font:inherit;cursor:pointer}\n  .lp-done:hover{background:rgba(255,255,255,.18)}\n  body.idle .lpick{opacity:0;pointer-events:none}\n  .lp-seg{display:grid;grid-template-columns:1fr 1fr;gap:3px;padding:3px;border-radius:999px;background:rgba(255,255,255,.08)}\n  .lp-seg button{appearance:none;border:0;border-radius:999px;padding:7px 0;background:transparent;color:#d9d7d0;font:inherit;cursor:pointer}\n  .lp-seg button.on{background:#f2f1ec;color:#141412}\n  .lp-row{display:flex;flex-direction:column;gap:7px}\n  .lp-row>div{display:flex;justify-content:space-between;color:#d9d7d0}\n  .lp-row output{font-variant-numeric:tabular-nums;color:#f2f1ec}\n  .lp-row small{display:flex;justify-content:space-between;color:#a9a69e;font-size:11px}\n  .lpick input[type=range]{width:100%;margin:0;accent-color:#f2f1ec}\n  .lpick input.lp-temp{appearance:none;-webkit-appearance:none;height:10px;border-radius:5px;outline:none}\n  .lp-temp::-webkit-slider-thumb{-webkit-appearance:none;width:18px;height:18px;border-radius:50%;background:#fff;border:2px solid #1a1b18;box-shadow:0 0 0 1px rgba(255,255,255,.6);cursor:pointer}\n  .lp-temp::-moz-range-thumb{width:14px;height:14px;border-radius:50%;background:#fff;border:2px solid #1a1b18;cursor:pointer}\n  .lp-wheel{position:relative;width:180px;height:180px;margin:0 auto;touch-action:none;cursor:pointer}\n  .lp-wheel canvas{width:180px;height:180px;border-radius:50%;display:block}\n  .lp-wheel i{position:absolute;width:18px;height:18px;margin:-9px 0 0 -9px;border-radius:50%;border:2px solid #fff;box-shadow:0 0 0 1px rgba(0,0,0,.4),0 2px 6px rgba(0,0,0,.4);pointer-events:none}\n  /* ---------- Handy-Ansicht ---------- */\n  html,body{overscroll-behavior:none;-webkit-tap-highlight-color:transparent;touch-action:none}\n  @media (max-width:700px){\n    #rooms{left:12px;right:12px;transform:none;bottom:calc(14px + max(env(safe-area-inset-bottom), 18px));overflow-x:auto;scrollbar-width:none;justify-content:flex-start;gap:2px;padding:5px;touch-action:pan-x}\n    #rooms::-webkit-scrollbar{display:none}\n    #rooms button{flex:none;padding:13px 15px;font-size:14px}\n    #pov{left:12px;top:calc(12px + max(env(safe-area-inset-top), 46px));transform:translateY(-8px)}\n    #pov.show{transform:none}\n    #pov button{padding:11px 12px;font-size:12px}\n    #rt{top:calc(12px + max(env(safe-area-inset-top), 46px));right:12px;padding:11px 12px 11px 10px;font-size:12px}\n    #pt{top:calc(62px + max(env(safe-area-inset-top), 46px)) !important;right:12px}\n    #lamp,#lamp2{left:12px;right:12px;bottom:calc(78px + max(env(safe-area-inset-bottom), 18px));transform:translateY(10px);flex-wrap:wrap;justify-content:center;border-radius:24px;row-gap:2px}\n    #lamp.show,#lamp2.show{transform:none}\n    #lampT,#lampD,#tripT{padding:11px 14px 11px 10px;font-size:13px}\n    #lamp.on #lampCtl,#lamp2.on #tripCtl{max-width:100%;padding:4px 10px 8px}\n    #tripCtl{flex-wrap:wrap;justify-content:center;gap:12px}\n    #tripCtl input[type=range]{width:120px}\n    .lp-sw{width:30px;height:30px}\n    .lpick{left:0 !important;right:0;top:auto !important;bottom:0;transform:none !important;width:auto;border-radius:24px 24px 0 0;padding:16px 20px calc(20px + max(env(safe-area-inset-bottom), 18px));gap:16px;font-size:13px}\n    .lp-seg button,.lp-done{padding:12px 0}\n    .lp-wheel,.lp-wheel canvas{width:180px;height:180px}\n  }\n  /* ---------- Handy: 3D oben, Fernbedienung unten ---------- */\n  #rooms,#pov,#rt,#pt,#lamp,#lamp2{display:none !important}\n  body{display:flex;flex-direction:column;height:100vh;height:100dvh;overflow:hidden;cursor:auto !important}\n  three-d-stage{flex:none;height:36%;min-height:0}\n  #remote{position:relative;z-index:5;flex:1;min-height:0;margin-top:-22px;overflow-y:auto;touch-action:pan-y;display:flex;flex-direction:column;gap:12px;padding:10px 16px max(env(safe-area-inset-bottom), 22px);border-radius:28px 28px 0 0;background:linear-gradient(180deg,#262624,#171716 60%);color:#f2f1ec;box-shadow:0 -10px 30px rgba(0,0,0,.18),inset 0 1px 0 rgba(255,255,255,.08);font:500 14px/1.2 Helvetica,Arial,sans-serif}\n  #remote button{appearance:none;border:0;font:inherit;color:inherit;cursor:pointer;-webkit-tap-highlight-color:transparent}\n  .r-grip{width:40px;height:4px;border-radius:2px;background:rgba(255,255,255,.18);margin:0 auto 2px;flex:none}\n  .r-head{display:flex;align-items:center;justify-content:space-between;gap:12px}\n  .r-stat{display:flex;flex-direction:column;gap:4px}\n  .r-stat small{font-size:11px;letter-spacing:.08em;text-transform:uppercase;color:#9d9a92}\n  .r-stat b{font-size:17px;font-weight:600}\n  #rPower{display:flex;align-items:center;gap:9px;padding:0 16px 0 12px;height:48px;border-radius:24px;background:#b8402f !important;color:#fff !important;box-shadow:0 4px 14px rgba(184,64,47,.35),inset 0 1px 0 rgba(255,255,255,.2);font-size:13px !important;font-weight:600 !important;flex:none}\n  #rPower:active{transform:scale(.96)}\n  .r-label{font-size:11px;letter-spacing:.08em;text-transform:uppercase;color:#9d9a92;margin:4px 2px -4px}\n  #rRooms{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:7px}\n  three-d-stage{transition:height .5s cubic-bezier(.3,.8,.2,1)}\n  #remote{flex:none !important;height:calc(64% + 22px)}\n  body.lpfocus three-d-stage{height:calc(100% + 22px)}\n  .lpick.open{animation:lpUp .5s cubic-bezier(.3,.8,.2,1) .1s both}\n  @keyframes lpUp{from{translate:0 110%}to{translate:0 0}}\n  .r-key{height:48px;border-radius:14px;background:#2f2f2c !important;box-shadow:inset 0 1px 0 rgba(255,255,255,.07),0 2px 0 #0e0e0d;font-size:12px !important;padding:0 4px;transition:background .15s,color .15s,transform .1s}\n  .r-key.wide{grid-column:span 2}\n  .r-key:active{transform:translateY(1px)}\n  .r-key.on{background:#f2f1ec !important;color:#141412 !important}\n  #rPov{display:grid;grid-template-columns:1fr 1fr;gap:3px;padding:3px;border-radius:14px;background:#0f0f0e;transition:opacity .2s}\n  #rPov button{height:40px;border-radius:11px;font-size:13px !important;color:#bdbab2 !important}\n  #rPov button.on{background:#3a3a37;color:#f2f1ec !important}\n  #rPov.off{opacity:.35;pointer-events:none}\n  #rLights{display:flex;flex-direction:column;gap:7px}\n  .r-lamp{display:flex;gap:7px}\n  .r-tog{flex:1;display:flex;align-items:center;gap:12px;height:56px;padding:0 14px;border-radius:16px;background:#2f2f2c !important;box-shadow:inset 0 1px 0 rgba(255,255,255,.07),0 2px 0 #0e0e0d;text-align:left}\n  .r-tog i{width:12px;height:12px;border-radius:50%;background:#55534e;flex:none;transition:background .3s,box-shadow .3s}\n  .r-tog span{flex:1;display:flex;flex-direction:column;gap:3px;font-size:14px}\n  .r-tog em{font-style:normal;font-size:11px;color:#9d9a92}\n  .r-tog b{width:38px;height:22px;border-radius:11px;background:#4a4945;position:relative;flex:none;transition:background .2s}\n  .r-tog b::after{content:\"\";position:absolute;top:3px;left:3px;width:16px;height:16px;border-radius:50%;background:#f2f1ec;transition:transform .2s}\n  .r-lamp.on .r-tog b{background:#e9e6de}\n  .r-lamp.on .r-tog b::after{transform:translateX(16px);background:#1b1b19}\n  .r-col{width:56px;height:56px;border-radius:16px;background:#2f2f2c !important;box-shadow:inset 0 1px 0 rgba(255,255,255,.07),0 2px 0 #0e0e0d;display:grid;place-items:center;flex:none}\n  .r-col::after{content:\"\";width:24px;height:24px;border-radius:50%;background:var(--c,#ffd6a0);box-shadow:0 0 0 2px #1b1b19,0 0 0 3px rgba(255,255,255,.25)}\n  .r-tv{display:flex;gap:7px}\n  .r-tv.on .r-tog b{background:#e9e6de}\n  .r-tv.on .r-tog b::after{transform:translateX(16px);background:#1b1b19}\n  .r-tv .r-tog svg{flex:none;color:#9d9a92}\n  .r-tv.on .r-tog .pw{fill:#e5484d;stroke:#e5484d}\n  .r-rc{color:#f2f1ec}\n  .r-rc::after{display:none}\n  #tvUI,#tvBar{display:none !important}\n  #rTvPanel{display:none;flex-direction:column;gap:12px}\n  body.tvfocus #remote > :not(.r-grip):not(#rTvPanel):not(#aiBar){display:none !important}\n  body.tvfocus #rTvPanel{display:flex;animation:tvIn .4s cubic-bezier(.3,.8,.2,1) both}\n  @keyframes tvIn{from{opacity:0;translate:0 12px}to{opacity:1;translate:0 0}}\n  .tvp-head{display:flex;align-items:center;gap:8px}\n  .tvp-head .r-stat{flex:1}\n  .tvp-ic{width:48px;height:48px;border-radius:14px;display:grid;place-items:center;background:#2f2f2c !important;box-shadow:inset 0 1px 0 rgba(255,255,255,.07),0 2px 0 #0e0e0d;flex:none}\n  .tvp-ic.pow{color:#e5484d}\n  #tvpApps{display:flex;gap:7px;overflow-x:auto;scrollbar-width:none;margin:0 -16px;padding:2px 16px 4px;scroll-padding:16px}\n  #tvpApps::-webkit-scrollbar{display:none}\n  #tvpApps button{flex:none;display:flex;align-items:center;gap:9px;height:44px;padding:0 16px 0 13px;border-radius:999px;white-space:nowrap;background:#2f2f2c !important;box-shadow:inset 0 1px 0 rgba(255,255,255,.07),0 2px 0 #0e0e0d;font-size:14px;text-align:left}\n  #tvpApps button i{width:10px;height:10px;border-radius:50%;flex:none}\n  #tvpApps button.on{background:#e9e6de !important;color:#1b1b19}\n  .tvp-pad{display:flex;align-items:center;justify-content:center;gap:clamp(12px,5vw,24px);padding:6px 0 4px}\n  .tvp-vol,.tvp-side{display:flex;flex-direction:column;align-items:center;justify-content:space-between;width:56px;height:184px;padding:6px 0;border-radius:999px;background:#2f2f2c;box-shadow:inset 0 1px 0 rgba(255,255,255,.07),0 2px 0 #0e0e0d;flex:none}\n  .tvp-side{justify-content:space-around}\n  .tvp-vol button,.tvp-side button{background:transparent;color:#f2f1ec;width:46px;height:46px;border-radius:50%;font-size:24px !important;line-height:1;display:grid;place-items:center}\n  .tvp-vol input{display:none}\n  .tvp-vol output{font-size:13px;color:#9d9a92;font-variant-numeric:tabular-nums}\n  #tvpMute .x{display:none}\n  #tvpMute.on{color:#e5484d}\n  #tvpMute.on .x{display:inline}\n  #tvpMute.on .w{display:none}\n  .tvp-dpad{position:relative;width:184px;height:184px;border-radius:50%;flex:none;background:radial-gradient(circle at 50% 35%,#3a3a36,#2a2a27 70%);box-shadow:inset 0 1px 0 rgba(255,255,255,.08),0 3px 0 #0e0e0d,0 10px 24px rgba(0,0,0,.35)}\n  .tvp-dpad button{background:transparent;position:absolute;width:56px;height:56px;display:grid;place-items:center;border-radius:50%;color:#d9d7d0}\n  .tvp-dpad button:active{background:rgba(255,255,255,.08)}\n  .tvp-dpad .k-up{top:4px;left:64px}\n  .tvp-dpad .k-down{bottom:4px;left:64px}\n  .tvp-dpad .k-left{left:4px;top:64px}\n  .tvp-dpad .k-right{right:4px;top:64px}\n  .tvp-dpad .k-ok{left:52px;top:52px;width:80px;height:80px;background:#e9e6de !important;color:#1b1b19 !important;font-size:15px !important;font-weight:700;letter-spacing:.04em;box-shadow:0 2px 0 #8e8b84,0 6px 14px rgba(0,0,0,.35)}\n  .tvp-dpad .k-ok:active{transform:translateY(2px);box-shadow:0 0 0 #8e8b84}\n  .tvp-dpad .k-ok.play{background:#e5484d !important;color:#fff !important;box-shadow:0 2px 0 #8f2a2e,0 6px 14px rgba(229,72,77,.4)}\n  .tvp-vol button:active,.tvp-side button:active{background:rgba(255,255,255,.08)}\n  .tvp-vol button:active,#tvpApps button:active,.tvp-ic:active{transform:translateY(1px)}\n  .tvp-vol input{flex:1;min-width:0;accent-color:#e9e6de}\n  .tvp-vol output{width:28px;text-align:right;font-size:13px;color:#9d9a92;font-variant-numeric:tabular-nums}\n  .r-two{display:grid;grid-template-columns:1fr 1fr;gap:7px}\n  .r-two button{height:48px;border-radius:14px;background:#2f2f2c !important;box-shadow:inset 0 1px 0 rgba(255,255,255,.07),0 2px 0 #0e0e0d;font-size:14px !important}\n  .r-two button:active,.r-tog:active,.r-col:active{transform:translateY(1px)}\n\n  /* KI-Kugel */\n  .orb{position:relative;display:block;flex:none;width:var(--s,64px);height:var(--s,64px);border-radius:50%;overflow:hidden;isolation:isolate;background:radial-gradient(circle at 50% 60%,#0d1024 0%,#04050b 72%);box-shadow:0 0 0 1px rgba(150,190,255,.28) inset,0 0 22px 3px rgba(80,130,255,.38),0 0 54px 8px rgba(170,80,255,.16);transition:box-shadow .4s}\n  .orb::after{content:\"\";position:absolute;inset:0;border-radius:50%;box-shadow:inset 0 -7px 14px rgba(0,0,0,.65),inset 0 2px 5px rgba(255,255,255,.22);z-index:3}\n  .orb i{position:absolute;border-radius:50%;display:block}\n  .o-swirl{inset:-22%;background:conic-gradient(from 0deg,#00e5ff,#4f6bff,#b84bff,#ff4fa3,#ffb36b,#00e5ff);filter:blur(9px);opacity:.9;mix-blend-mode:screen;animation:orbSpin 6s linear infinite;-webkit-mask:radial-gradient(circle,rgba(0,0,0,.25) 18%,#000 62%);mask:radial-gradient(circle,rgba(0,0,0,.25) 18%,#000 62%)}\n  .o-swirl.b{inset:-8%;opacity:.7;filter:blur(5px);animation-duration:9s;animation-direction:reverse;background:conic-gradient(from 90deg,transparent,#7cf8ff 18%,transparent 36%,#c17cff 58%,transparent 78%)}\n  .o-core{inset:31%;background:radial-gradient(circle,#fff 0%,#aef0ff 32%,rgba(90,120,255,0) 72%);filter:blur(1.5px);mix-blend-mode:screen;animation:orbBreath 3.2s ease-in-out infinite}\n  .o-shine{inset:5% 20% 58% 20%;z-index:2;background:radial-gradient(ellipse at 50% 0%,rgba(255,255,255,.5),transparent 70%)}\n  @keyframes orbSpin{to{transform:rotate(360deg)}}\n  @keyframes orbBreath{0%,100%{transform:scale(.82);opacity:.7}50%{transform:scale(1.12);opacity:1}}\n  @keyframes orbTalk{from{transform:scale(.78);opacity:.8}to{transform:scale(1.32);opacity:1}}\n  @keyframes micPulse{0%{box-shadow:0 0 0 0 rgba(120,150,255,.65)}100%{box-shadow:0 0 0 14px rgba(120,150,255,0)}}\n  body.ai-listen .o-core{animation-duration:.8s}\n  body.ai-listen .o-swirl{animation-duration:1.8s}\n  body.ai-listen .orb{box-shadow:0 0 0 1px rgba(150,220,255,.5) inset,0 0 30px 6px rgba(60,200,255,.55),0 0 70px 14px rgba(140,90,255,.3)}\n  body.ai-think .o-swirl{animation-duration:.9s}\n  body.ai-speak .o-core{animation:orbTalk .32s ease-in-out infinite alternate}\n  #aiDock{position:fixed;z-index:81;right:30px;top:50%;transform:translateY(-50%);transition:opacity .6s,top .5s,bottom .5s}\n  #aiOrb{appearance:none;border:0;padding:0;background:none;cursor:pointer;position:relative;display:block;border-radius:50%;transition:transform .3s cubic-bezier(.3,.8,.2,1)}\n  #aiOrb:hover{transform:scale(1.07)}\n  #aiOrb:active{transform:scale(.96)}\n  #aiOrb::before{content:\"\";position:absolute;inset:-10px;border-radius:50%;border:1px solid rgba(140,180,255,.2);border-top-color:rgba(120,230,255,.95);border-right-color:rgba(190,120,255,.6);animation:orbSpin 5s linear infinite}\n  #ai.open #aiOrb::before,body.ai-listen #aiOrb::before{animation-duration:1.4s}\n  body.idle #aiDock,body.lpfocus #aiDock{opacity:0 !important;pointer-events:none}\n  body.tvfocus #aiDock{top:calc(100% - 104px);transform:none}\n  #aiScrim{display:none}\n  #aiPanel{position:fixed;z-index:80;right:126px;top:50%;width:min(380px,calc(100vw - 160px));height:min(540px,calc(100vh - 220px));box-sizing:border-box;display:flex;flex-direction:column;gap:12px;padding:16px;border-radius:24px;background:rgba(10,12,22,.74);backdrop-filter:blur(22px) saturate(1.3);-webkit-backdrop-filter:blur(22px) saturate(1.3);border:1px solid rgba(150,180,255,.16);box-shadow:0 24px 60px rgba(0,0,20,.45),inset 0 1px 0 rgba(255,255,255,.06);color:#eef1f8;font:400 14px/1.4 Helvetica,Arial,sans-serif;opacity:0;pointer-events:none;transform:translate(18px,-50%) scale(.98);transform-origin:right center;transition:opacity .3s,transform .4s cubic-bezier(.3,.8,.2,1)}\n  #ai.open #aiPanel{opacity:1;pointer-events:auto;transform:translate(0,-50%)}\n  .ai-top{display:flex;align-items:center;gap:12px}\n  .ai-ttl{flex:1;display:flex;flex-direction:column;gap:3px}\n  .ai-ttl small{font-size:10px;letter-spacing:.16em;text-transform:uppercase;color:#8f9bc4}\n  .ai-ttl b{font-size:15px;font-weight:600}\n  #aiX{appearance:none;border:0;width:36px;height:36px;border-radius:50%;background:rgba(255,255,255,.08);color:#cfd6ea;font:400 20px/1 Helvetica,Arial,sans-serif;cursor:pointer;flex:none}\n  #aiX:hover{background:rgba(255,255,255,.14)}\n  #aiLog{flex:1;min-height:0;overflow-y:auto;display:flex;flex-direction:column;gap:10px;padding:2px;scrollbar-width:thin;scrollbar-color:rgba(255,255,255,.15) transparent}\n  .ai-m{max-width:86%;padding:9px 12px;border-radius:16px;text-wrap:pretty;animation:aiIn .3s cubic-bezier(.3,.8,.2,1) both}\n  .ai-m.u{align-self:flex-end;background:rgba(110,140,255,.2);border:1px solid rgba(140,170,255,.24);border-bottom-right-radius:6px}\n  .ai-m.a{align-self:flex-start;background:rgba(255,255,255,.06);border-bottom-left-radius:6px}\n  .ai-m.dots{color:#8f9bc4;letter-spacing:.2em}\n  @keyframes aiIn{from{opacity:0;transform:translateY(6px)}to{opacity:1;transform:none}}\n  .ai-chips{display:flex;flex-wrap:wrap;gap:6px}\n  .ai-chips button{appearance:none;border:1px solid rgba(150,180,255,.22);background:transparent;color:#cfd6ea;font:500 12px/1 Helvetica,Arial,sans-serif;padding:8px 11px;border-radius:999px;cursor:pointer}\n  .ai-chips button:hover{background:rgba(150,180,255,.12)}\n  #aiForm{display:flex;gap:6px;align-items:center;margin:0;padding:5px;border-radius:999px;background:rgba(255,255,255,.06);border:1px solid rgba(150,180,255,.16)}\n  #aiIn{flex:1;min-width:0;border:0;background:transparent;color:#eef1f8;font:400 15px Helvetica,Arial,sans-serif;padding:8px 10px;outline:none}\n  #aiIn::placeholder{color:#7d87a8}\n  #aiMic,#aiSend{appearance:none;border:0;width:40px;height:40px;border-radius:50%;display:grid;place-items:center;cursor:pointer;color:#fff;background:rgba(255,255,255,.1);flex:none;padding:0}\n  #aiMic{background:linear-gradient(135deg,#20c8f0,#6a5cff 55%,#c04bff)}\n  body.ai-listen #aiMic{animation:micPulse 1s infinite}\n  #bedL{display:flex;align-items:center;gap:10px;appearance:none;border:0;background:transparent;color:inherit;font:inherit;padding:7px 14px 7px 10px;border-radius:999px;cursor:pointer;white-space:nowrap}\n  #bedL:hover{background:rgba(255,255,255,.1)}\n  #bedL b{width:12px;height:12px;border-radius:50%;background:#bdb8ae;transition:background .3s,box-shadow .3s}\n  #bedCtl{display:none;align-items:center;padding:0 10px 0 0}\n  #bedL.on+#bedCtl{display:flex}\n\n  #aiBar{display:flex;align-items:center;gap:12px;height:60px;padding:0 8px;border-radius:30px;background:linear-gradient(90deg,rgba(60,90,200,.3),rgba(150,60,210,.2)) !important;box-shadow:inset 0 0 0 1px rgba(150,180,255,.22),0 2px 0 #0e0e0d;text-align:left;flex:none}\n  #aiBar:active{transform:translateY(1px)}\n  .ai-bt{flex:1;display:flex;flex-direction:column;gap:3px}\n  .ai-bt b{font-size:15px;font-weight:600}\n  .ai-bt em{font-style:normal;font-size:12px;color:#a3abc9}\n  .ai-mic{width:44px;height:44px;border-radius:50%;display:grid;place-items:center;background:rgba(255,255,255,.1)}\n  #aiScrim{display:block;position:fixed;inset:0;z-index:79;background:rgba(0,0,0,.4);opacity:0;pointer-events:none;transition:opacity .3s}\n  #ai.open #aiScrim{opacity:1;pointer-events:auto}\n  #aiPanel{left:0;right:0;top:auto;bottom:0;width:auto;height:min(80%,680px);border-radius:28px 28px 0 0;padding:18px 16px max(env(safe-area-inset-bottom),18px);border-width:1px 0 0;transform:translateY(102%);transform-origin:bottom center;background:rgba(10,12,22,.9)}\n  #ai.open #aiPanel{transform:none}\n  #aiIn{font-size:16px}\n  #aiMic,#aiSend{width:46px;height:46px}\n  #aiX{width:44px;height:44px}\n  .ai-chips button{padding:10px 13px;font-size:13px}\n<\u002Fstyle>\n<\u002Fhead>\n<body>\n\n<three-d-stage name=\"wohnung\" background=\"#efece6\"><\u002Fthree-d-stage>\n<div id=\"remote\">\n  <div class=\"r-grip\"><\u002Fdiv>\n  <button id=\"aiBar\"><span class=\"orb\" style=\"--s:44px\"><i class=\"o-swirl\"><\u002Fi><i class=\"o-swirl b\"><\u002Fi><i class=\"o-core\"><\u002Fi><i class=\"o-shine\"><\u002Fi><\u002Fspan><span class=\"ai-bt\"><b>KI-Assistent<\u002Fb><em>Tippen und sprechen<\u002Fem><\u002Fspan><span class=\"ai-mic\"><svg viewBox=\"0 0 24 24\" width=\"20\" height=\"20\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><rect x=\"9\" y=\"3\" width=\"6\" height=\"11\" rx=\"3\"><\u002Frect><path d=\"M5.5 11a6.5 6.5 0 0 0 13 0\"><\u002Fpath><path d=\"M12 17.5V21\"><\u002Fpath><\u002Fsvg><\u002Fspan><\u002Fbutton>\n  <div id=\"rTvPanel\">\n    <div class=\"tvp-head\"><button class=\"tvp-ic\" id=\"tvpBack\" aria-label=\"Zurück\"><svg viewBox=\"0 0 24 24\" width=\"22\" height=\"22\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M15 5l-7 7 7 7\"><\u002Fpath><\u002Fsvg><\u002Fbutton><div class=\"r-stat\"><small>Fernseher<\u002Fsmall><b id=\"tvpStat\">YouTube<\u002Fb><\u002Fdiv><button class=\"tvp-ic pow\" id=\"tvpOff\" aria-label=\"Ausschalten\"><svg viewBox=\"0 0 24 24\" width=\"22\" height=\"22\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.4\" stroke-linecap=\"round\"><path d=\"M12 3v8\"><\u002Fpath><path d=\"M6.3 6.8a8 8 0 1 0 11.4 0\"><\u002Fpath><\u002Fsvg><\u002Fbutton><\u002Fdiv>\n    <div class=\"tvp-pad\">\n      <div class=\"tvp-vol\"><button data-d=\"5\" aria-label=\"Lauter\">+<\u002Fbutton><input type=\"range\" min=\"0\" max=\"100\" step=\"1\" aria-label=\"Lautstärke\"><output><\u002Foutput><button data-d=\"-5\" aria-label=\"Leiser\">−<\u002Fbutton><\u002Fdiv>\n      <div class=\"tvp-dpad\"><button data-k=\"up\" class=\"k-up\" aria-label=\"Lauter\"><svg viewBox=\"0 0 24 24\" width=\"22\" height=\"22\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.4\" stroke-linecap=\"round\" stroke-linejoin=\"round\" style=\"transform:rotate(0deg)\"><path d=\"M6 15l6-6 6 6\"><\u002Fpath><\u002Fsvg><\u002Fbutton><button data-k=\"right\" class=\"k-right\" aria-label=\"Nächste App\"><svg viewBox=\"0 0 24 24\" width=\"22\" height=\"22\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.4\" stroke-linecap=\"round\" stroke-linejoin=\"round\" style=\"transform:rotate(90deg)\"><path d=\"M6 15l6-6 6 6\"><\u002Fpath><\u002Fsvg><\u002Fbutton><button data-k=\"down\" class=\"k-down\" aria-label=\"Leiser\"><svg viewBox=\"0 0 24 24\" width=\"22\" height=\"22\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.4\" stroke-linecap=\"round\" stroke-linejoin=\"round\" style=\"transform:rotate(180deg)\"><path d=\"M6 15l6-6 6 6\"><\u002Fpath><\u002Fsvg><\u002Fbutton><button data-k=\"left\" class=\"k-left\" aria-label=\"Vorherige App\"><svg viewBox=\"0 0 24 24\" width=\"22\" height=\"22\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.4\" stroke-linecap=\"round\" stroke-linejoin=\"round\" style=\"transform:rotate(270deg)\"><path d=\"M6 15l6-6 6 6\"><\u002Fpath><\u002Fsvg><\u002Fbutton><button data-k=\"ok\" class=\"k-ok\" id=\"tvpOk\">OK<\u002Fbutton><\u002Fdiv>\n      <div class=\"tvp-side\"><button id=\"tvpMute\" aria-label=\"Stumm\"><svg viewBox=\"0 0 24 24\" width=\"22\" height=\"22\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M4 9h4l5-4v14l-5-4H4z\"><\u002Fpath><path class=\"w\" d=\"M16.5 8.5a5 5 0 0 1 0 7\"><\u002Fpath><path class=\"x\" d=\"M16 9l5 6M21 9l-5 6\"><\u002Fpath><\u002Fsvg><\u002Fbutton><button id=\"tvpHome\" aria-label=\"Startseite\"><svg viewBox=\"0 0 24 24\" width=\"22\" height=\"22\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M4 11l8-7 8 7v9H4z\"><\u002Fpath><\u002Fsvg><\u002Fbutton><\u002Fdiv>\n    <\u002Fdiv>\n    <div class=\"r-label\">Apps<\u002Fdiv>\n    <div id=\"tvpApps\"><\u002Fdiv>\n  <\u002Fdiv>\n  <div class=\"r-head\">\n    <div class=\"r-stat\"><small>Wohnung<\u002Fsmall><b id=\"rStat\">Alle Lichter aus<\u002Fb><\u002Fdiv>\n    <button id=\"rPower\" aria-label=\"Wohnung verlassen\"><svg viewBox=\"0 0 24 24\" width=\"22\" height=\"22\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.4\" stroke-linecap=\"round\"><path d=\"M12 3v8\"><\u002Fpath><path d=\"M6.3 6.8a8 8 0 1 0 11.4 0\"><\u002Fpath><\u002Fsvg><span>Wohnung verlassen<\u002Fspan><\u002Fbutton>\n  <\u002Fdiv>\n  <div class=\"r-label\">Räume<\u002Fdiv>\n  <div id=\"rRooms\"><\u002Fdiv>\n  <div class=\"r-label\" id=\"rLightsLbl\">Licht<\u002Fdiv>\n  <div id=\"rLights\">\n    <div class=\"r-lamp\" data-l=\"bogen\" data-room=\"1\"><button class=\"r-tog\"><i><\u002Fi><span>Bogenlampe<em>Wohnzimmer<\u002Fem><\u002Fspan><b><\u002Fb><\u002Fbutton><button class=\"r-col\" aria-label=\"Farbe\"><\u002Fbutton><\u002Fdiv>\n    <div class=\"r-lamp\" data-l=\"donut\" data-room=\"1\"><button class=\"r-tog\"><i><\u002Fi><span>Donut-Lampe<em>Wohnzimmer · Regal<\u002Fem><\u002Fspan><b><\u002Fb><\u002Fbutton><\u002Fdiv>\n    <div class=\"r-lamp\" data-l=\"trip\" data-room=\"3\"><button class=\"r-tog\"><i><\u002Fi><span>Tripod-Lampe<em>Schlafzimmer<\u002Fem><\u002Fspan><b><\u002Fb><\u002Fbutton><button class=\"r-col\" aria-label=\"Farbe\"><\u002Fbutton><\u002Fdiv>\n    <div class=\"r-lamp\" data-l=\"bett\" data-room=\"3\"><button class=\"r-tog\"><i><\u002Fi><span>Bett-LED<em>Schlafzimmer · Kopfteil<\u002Fem><\u002Fspan><b><\u002Fb><\u002Fbutton><button class=\"r-col\" aria-label=\"Farbe\"><\u002Fbutton><\u002Fdiv>\n  <\u002Fdiv>\n  <div class=\"r-label\" id=\"rTvLbl\">Fernseher<\u002Fdiv>\n  <div class=\"r-tv\" id=\"rTv\"><button class=\"r-tog\" id=\"rTvPow\"><svg viewBox=\"0 0 24 24\" width=\"18\" height=\"18\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.6\"><rect x=\"7.5\" y=\"2.5\" width=\"9\" height=\"19\" rx=\"3\"><\u002Frect><circle cx=\"12\" cy=\"7\" r=\"1.6\" class=\"pw\"><\u002Fcircle><circle cx=\"12\" cy=\"12.5\" r=\"2.2\"><\u002Fcircle><\u002Fsvg><span>Fernseher<em>Wohnzimmer · Westwand<\u002Fem><\u002Fspan><b><\u002Fb><\u002Fbutton><button class=\"r-col r-rc\" id=\"rTvOpen\" aria-label=\"Fernbedienung öffnen\"><svg viewBox=\"0 0 24 24\" width=\"22\" height=\"22\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.6\"><rect x=\"7.5\" y=\"2.5\" width=\"9\" height=\"19\" rx=\"3\"><\u002Frect><circle cx=\"12\" cy=\"7\" r=\"1.6\" fill=\"#e5484d\" stroke=\"#e5484d\"><\u002Fcircle><circle cx=\"12\" cy=\"12.5\" r=\"2.2\"><\u002Fcircle><circle cx=\"10.3\" cy=\"17.3\" r=\".6\" fill=\"currentColor\"><\u002Fcircle><circle cx=\"13.7\" cy=\"17.3\" r=\".6\" fill=\"currentColor\"><\u002Fcircle><\u002Fsvg><\u002Fbutton><\u002Fdiv>\n  <div class=\"r-two\"><button id=\"rAllOn\">Alle an<\u002Fbutton><button id=\"rAllOff\">Alles aus<\u002Fbutton><\u002Fdiv>\n<\u002Fdiv>\n<div id=\"rooms\"><\u002Fdiv>\n<div id=\"pov\"><button data-m=\"bird\" class=\"on\">Vogelperspektive<\u002Fbutton><button data-m=\"fp\">Frei umsehen<\u002Fbutton><\u002Fdiv>\n<button id=\"rt\" aria-pressed=\"false\"><i><\u002Fi><span>Render aus<\u002Fspan><\u002Fbutton>\n<div id=\"pt\"><\u002Fdiv>\n<div id=\"lamp\"><button id=\"lampT\"><i><\u002Fi><span>Bogenlampe an<\u002Fspan><\u002Fbutton><div id=\"lampCtl\"><div id=\"lampSw\"><\u002Fdiv><label id=\"lampDim\" style=\"display:none\"><span>Stärke<\u002Fspan><input type=\"range\" min=\"10\" max=\"200\" step=\"5\" value=\"100\"><output>100%<\u002Foutput><\u002Flabel><\u002Fdiv><button id=\"lampD\" aria-pressed=\"false\"><b><\u002Fb><span>Donut-Lampe an<\u002Fspan><\u002Fbutton><button id=\"tvB\" aria-pressed=\"false\" title=\"Fernseher an/aus\"><svg viewBox=\"0 0 24 24\" width=\"18\" height=\"18\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.6\"><rect x=\"7.5\" y=\"2.5\" width=\"9\" height=\"19\" rx=\"3\"><\u002Frect><circle cx=\"12\" cy=\"7\" r=\"1.6\" class=\"pw\"><\u002Fcircle><circle cx=\"12\" cy=\"12.5\" r=\"2.2\"><\u002Fcircle><circle cx=\"10.3\" cy=\"17.3\" r=\".6\" fill=\"currentColor\"><\u002Fcircle><circle cx=\"13.7\" cy=\"17.3\" r=\".6\" fill=\"currentColor\"><\u002Fcircle><\u002Fsvg><span>Fernseher an<\u002Fspan><\u002Fbutton><\u002Fdiv>\n<div id=\"tvUI\"><div class=\"tv-hero\"><small>Zuletzt geöffnet<\u002Fsmall><h2><\u002Fh2><\u002Fdiv><nav class=\"tv-nav\"><\u002Fnav><div class=\"tv-vol\"><button class=\"tv-vb\" data-d=\"5\" aria-label=\"Lauter\">+<\u002Fbutton><input type=\"range\" min=\"0\" max=\"100\" step=\"1\" aria-label=\"Lautstärke\"><button class=\"tv-vb\" data-d=\"-5\" aria-label=\"Leiser\">−<\u002Fbutton><output><\u002Foutput><\u002Fdiv><\u002Fdiv>\n<div id=\"tvBar\"><button id=\"tvBack\">Zurück<\u002Fbutton><button id=\"tvOff\"><svg viewBox=\"0 0 24 24\" width=\"18\" height=\"18\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.6\"><rect x=\"7.5\" y=\"2.5\" width=\"9\" height=\"19\" rx=\"3\"><\u002Frect><circle cx=\"12\" cy=\"7\" r=\"1.6\" fill=\"#e5484d\" stroke=\"#e5484d\"><\u002Fcircle><circle cx=\"12\" cy=\"12.5\" r=\"2.2\"><\u002Fcircle><circle cx=\"10.3\" cy=\"17.3\" r=\".6\" fill=\"currentColor\"><\u002Fcircle><circle cx=\"13.7\" cy=\"17.3\" r=\".6\" fill=\"currentColor\"><\u002Fcircle><\u002Fsvg><span>Ausschalten<\u002Fspan><\u002Fbutton><\u002Fdiv>\n<div id=\"lamp2\"><button id=\"tripT\"><i><\u002Fi><span>Tripod-Lampe an<\u002Fspan><\u002Fbutton><div id=\"tripCtl\"><label><button id=\"tripCol\" class=\"lp-sw\" title=\"Licht einstellen\"><\u002Fbutton><\u002Flabel><label style=\"display:none\"><span>Stärke<\u002Fspan><input id=\"tripDim\" type=\"range\" min=\"10\" max=\"200\" step=\"5\" value=\"100\"><output>100%<\u002Foutput><\u002Flabel><label><span>Kegel<\u002Fspan><input id=\"tripCone\" type=\"range\" min=\"15\" max=\"80\" step=\"1\" value=\"32\"><output>32°<\u002Foutput><\u002Flabel><\u002Fdiv><button id=\"bedL\" aria-pressed=\"false\"><b><\u002Fb><span>Bett-LED an<\u002Fspan><\u002Fbutton><span id=\"bedCtl\"><button id=\"bedCol\" class=\"lp-sw\" title=\"LED-Farbe einstellen\"><\u002Fbutton><input id=\"bedDim\" type=\"range\" min=\"10\" max=\"200\" step=\"5\" value=\"100\" hidden=\"\"><\u002Fspan><\u002Fdiv>\n<div id=\"ai\"><div id=\"aiScrim\"><\u002Fdiv><div id=\"aiPanel\" role=\"dialog\" aria-label=\"KI-Assistent\"><div class=\"ai-top\"><span class=\"orb\" style=\"--s:44px\"><i class=\"o-swirl\"><\u002Fi><i class=\"o-swirl b\"><\u002Fi><i class=\"o-core\"><\u002Fi><i class=\"o-shine\"><\u002Fi><\u002Fspan><div class=\"ai-ttl\"><small>KI-Assistent<\u002Fsmall><b id=\"aiState\">Bereit<\u002Fb><\u002Fdiv><button id=\"aiX\" aria-label=\"Schließen\">×<\u002Fbutton><\u002Fdiv><div id=\"aiLog\"><\u002Fdiv><div class=\"ai-chips\"><button>Bett-LED an<\u002Fbutton><button>Zeig das Schlafzimmer<\u002Fbutton><button>Alle Lichter aus<\u002Fbutton><\u002Fdiv><form id=\"aiForm\"><input id=\"aiIn\" placeholder=\"Sag oder schreib etwas…\" autocomplete=\"off\" enterkeyhint=\"send\"><button type=\"button\" id=\"aiMic\" aria-label=\"Sprechen\"><svg viewBox=\"0 0 24 24\" width=\"20\" height=\"20\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><rect x=\"9\" y=\"3\" width=\"6\" height=\"11\" rx=\"3\"><\u002Frect><path d=\"M5.5 11a6.5 6.5 0 0 0 13 0\"><\u002Fpath><path d=\"M12 17.5V21\"><\u002Fpath><\u002Fsvg><\u002Fbutton><button type=\"submit\" id=\"aiSend\" aria-label=\"Senden\"><svg viewBox=\"0 0 24 24\" width=\"18\" height=\"18\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M12 19V5\"><\u002Fpath><path d=\"M6 11l6-6 6 6\"><\u002Fpath><\u002Fsvg><\u002Fbutton><\u002Fform><\u002Fdiv><\u002Fdiv>\n<script src=\"2fa4feae-3507-4a0e-908b-156f4ee9f68a\"><\u002Fscript>\n<script type=\"module\">\n// moebel.js (eingebettet)\n// Möbel-Builder (aus Sofa 3D / Regal 3D / Bogenlampe 3D übernommen)\nconst mk = (THREE, name, geo, mat, x=0, y=0, z=0) => { const m = new THREE.Mesh(geo, mat); m.name=name; m.position.set(x,y,z); return m; };\n\nfunction buildSofa(THREE){\n  const M = {\n    fabric: new THREE.MeshStandardMaterial({ name:'poly_wool_herringbone', color:0x8b8780, roughness:0.95 }),\n    metal:  new THREE.MeshStandardMaterial({ name:'black_powdercoat', color:0x1d1d1f, roughness:0.45, metalness:0.6 }),\n    cup:    new THREE.MeshStandardMaterial({ name:'cupholder_black', color:0x151515, roughness:0.8 }),\n  };\n  const TEX = 0.5;\n  function rbox(w, h, d, r, k = 7, bulge = 0){\n    const half = [w/2, h/2, d/2];\n    const S = half.map(hh => { const a=[]; for(let i=k;i>=0;i--) a.push(-(hh-r) - r*Math.sin(i/k*Math.PI/2)); for(let i=0;i<=k;i++) a.push((hh-r) + r*Math.sin(i/k*Math.PI/2)); return a; });\n    const pos=[], nor=[], uv=[], idx=[];\n    for (let a=0;a<3;a++) for (const s of [1,-1]){\n      const u=(a+1)%3, v=(a+2)%3, su=S[u], sv=S[v], base=pos.length/3;\n      for (let j=0;j<sv.length;j++) for (let i=0;i<su.length;i++){\n        const p=[0,0,0]; p[a]=s*half[a]; p[u]=su[i]; p[v]=sv[j];\n        const c=p.map((x,m)=>Math.max(-(half[m]-r),Math.min(half[m]-r,x)));\n        let o=p.map((x,m)=>x-c[m]); const L=Math.hypot(...o)||1; o=o.map(x=>x/L);\n        const q=c.map((x,m)=>x+o[m]*r);\n        pos.push(...q); nor.push(...o);\n        const ax=Math.abs(o[0]),ay=Math.abs(o[1]),az=Math.abs(o[2]);\n        if (ay>=ax&&ay>=az) uv.push(q[0]/TEX,q[2]/TEX); else if (ax>=az) uv.push(q[2]/TEX,q[1]/TEX); else uv.push(q[0]/TEX,q[1]/TEX);\n      }\n      const nu=su.length;\n      for (let j=0;j<sv.length-1;j++) for (let i=0;i<nu-1;i++){\n        const A=base+j*nu+i, B=A+1, C=A+nu+1, D=A+nu;\n        if (s>0) idx.push(A,B,C, A,C,D); else idx.push(A,C,B, A,D,C);\n      }\n    }\n    const g = new THREE.BufferGeometry();\n    g.setAttribute('position', new THREE.Float32BufferAttribute(pos,3));\n    g.setAttribute('normal', new THREE.Float32BufferAttribute(nor,3));\n    g.setAttribute('uv', new THREE.Float32BufferAttribute(uv,2));\n    g.setIndex(idx);\n    if (bulge){\n      const p=g.attributes.position;\n      for (let i=0;i<p.count;i++){ const x=p.getX(i)/half[0], y=p.getY(i)/half[1]; p.setZ(i, p.getZ(i)*(1+bulge*(1-x*x)*(1-y*y))); }\n      g.computeVertexNormals();\n    }\n    return g;\n  }\n  const mesh = (...a) => mk(THREE, ...a);\n  const W=1.85, D=0.925, L=0.20, ARM=0.24, TOP=0.21, G=0.004;\n  const sofa = new THREE.Group(); sofa.name = 'sofa';\n  for (const [i,sx] of [[1,-1],[2,1]])\n    sofa.add(mesh('lage_unten_'+i, rbox(W/2-G, L-G, D, 0.035), M.fabric, sx*W/4, L/2, 0));\n  const hinge = new THREE.Group(); hinge.name='klappteil'; hinge.position.set(0, L, D/2);\n  for (const [i,sx] of [[1,-1],[2,1]])\n    hinge.add(mesh('lage_mitte_'+i, rbox(W/2-G, L-G, D, 0.035), M.fabric, sx*W/4, L/2, -D/2));\n  sofa.add(hinge);\n  const top = new THREE.Group(); top.name='aufbau'; top.position.y = 2*L;\n  for (const [n,sx] of [['links',-1],['rechts',1]]){\n    const x = sx*(W/2-ARM/2);\n    top.add(mesh('armlehne_'+n, rbox(ARM, TOP, D, 0.05), M.fabric, x, TOP/2, 0));\n    top.add(mesh('becherhalter_'+n, new THREE.CylinderGeometry(0.04,0.04,0.012,40), M.cup, x, TOP+0.001, D/2-0.1));\n    const ring = mesh('becherhalter_ring_'+n, new THREE.TorusGeometry(0.042,0.005,12,40), M.metal, x, TOP+0.004, D/2-0.1);\n    ring.rotation.x = Math.PI/2; top.add(ring);\n  }\n  const backW = (W-2*ARM)/2 - G;\n  for (const [i,sx] of [[1,-1],[2,1]]){\n    top.add(mesh('rueckenteil_'+i, rbox(backW, TOP, ARM, 0.05), M.fabric, sx*(backW/2+G/2), TOP/2, -D/2+ARM/2));\n    const p = mesh('kissen_'+i, rbox(0.45, 0.45, 0.10, 0.04, 7, 0.6), M.fabric, sx*0.33, 0.22, -D/2+ARM+0.08);\n    p.rotation.x = -0.28; p.rotation.z = sx*0.06; top.add(p);\n  }\n  sofa.add(top);\n  const fz0 = -0.05, fz1 = 0.30, fh = 0.34, rr = 0.008, R = 0.045, y0 = 0.02, yt = y0 + fh;\n  for (const [n,sx] of [['links',-1],['rechts',1]]){\n    const frame = new THREE.Group(); frame.name='seitengestell_'+n;\n    const fx = sx*(W/2 + 0.012);\n    for (const z of [fz0, fz1]) frame.add(mesh('gestell_stab_'+n, new THREE.CylinderGeometry(rr,rr,fh-R,20), M.metal, fx, y0+(fh-R)/2, z));\n    const bar = mesh('gestell_quer_'+n, new THREE.CylinderGeometry(rr,rr,fz1-fz0-2*R,20), M.metal, fx, yt, (fz0+fz1)/2); bar.rotation.x=Math.PI/2; frame.add(bar);\n    for (const [z,ry] of [[fz0+R, Math.PI/2],[fz1-R, -Math.PI/2]]){\n      const c = mesh('gestell_bogen_'+n, new THREE.TorusGeometry(R, rr, 16, 24, Math.PI/2), M.metal, fx, yt-R, z); c.rotation.y = ry; frame.add(c);\n    }\n    sofa.add(frame);\n  }\n  return { group: sofa, M, D };\n}\n\nfunction buildRegal(THREE, M){\n  const box = (w, h, d) => {\n    const g = new THREE.BoxGeometry(w, h, d), uv = g.attributes.uv;\n    const faces = [[d,h],[d,h],[w,d],[w,d],[w,h],[w,h]];\n    for (let f=0; f<6; f++) for (let i=0;i<4;i++){ const k=f*4+i; uv.setXY(k, uv.getX(k)*faces[f][0], uv.getY(k)*faces[f][1]); }\n    return g;\n  };\n  const mesh = (...a) => mk(THREE, ...a);\n  const W=0.60, D=0.27, H=0.74, A=0.03, T=0.0015, LIP=0.02, FOOT=0.012;\n  const shelfTops = [0.10, 0.42, H];\n  const regal = new THREE.Group(); regal.name='regal';\n  const postH = H - FOOT;\n  for (const [n,sx,sz] of [['vl',-1,1],['vr',1,1],['hl',-1,-1],['hr',1,-1]]){\n    const p = new THREE.Group(); p.name='pfosten_'+n;\n    const cx = sx*(W/2 - A/2), cz = sz*(D/2 - A/2), y = FOOT + postH/2;\n    p.add(mesh('pfosten_'+n+'_a', box(A, postH, T), M.concrete, cx, y, sz*(D/2 - T/2)));\n    p.add(mesh('pfosten_'+n+'_b', box(T, postH, A), M.concrete, sx*(W/2 - T/2), y, cz));\n    p.add(mesh('fuss_'+n, box(A+0.002, FOOT, A+0.002), M.foot, cx, FOOT/2, cz));\n    for (const top of shelfTops){\n      const yb = top - LIP/2;\n      const b1 = mesh('schraube_'+n, new THREE.CylinderGeometry(0.004,0.004,0.003,16), M.bolt, cx, yb, sz*(D/2+0.001)); b1.rotation.x = Math.PI/2; p.add(b1);\n      const b2 = mesh('schraube_'+n, new THREE.CylinderGeometry(0.004,0.004,0.003,16), M.bolt, sx*(W/2+0.001), yb, cz); b2.rotation.z = Math.PI/2; p.add(b2);\n    }\n    regal.add(p);\n  }\n  shelfTops.forEach((top, i) => {\n    const s = new THREE.Group(); s.name='boden_'+(i+1);\n    const iw = W - 2*T, id = D - 2*T;\n    s.add(mesh('boden_'+(i+1)+'_platte', box(iw, T, id), M.concrete, 0, top - T/2, 0));\n    for (const sz of [1,-1]) s.add(mesh('boden_'+(i+1)+'_kante_z', box(iw, LIP, T), M.concrete, 0, top - LIP/2, sz*(id/2 - T/2)));\n    for (const sx of [1,-1]) s.add(mesh('boden_'+(i+1)+'_kante_x', box(T, LIP, id), M.concrete, sx*(iw/2 - T/2), top - LIP/2, 0));\n    regal.add(s);\n  });\n  return regal;\n}\nfunction regalMaterials(THREE){\n  return {\n    concrete: galvanizedMaterial(THREE, 18), // verzinkter Stahl, Textur „Fein“\n    foot:     new THREE.MeshStandardMaterial({ name:'kunststoff_fuss', color:0x2a2a2a, roughness:0.7 }),\n    bolt:     new THREE.MeshStandardMaterial({ name:'schraube', color:0x8c8c8c, roughness:0.35, metalness:0.9 }),\n  };\n}\n\nfunction buildLampe(THREE){\n  const V = (x,y,z=0) => new THREE.Vector3(x,y,z);\n  const M = {\n    chrom:  new THREE.MeshStandardMaterial({ name:'chrom', color:0xd8dadd, metalness:0.5, roughness:0.25 }),\n    schirm: new THREE.MeshPhysicalMaterial({ name:'acryl_weiss', color:0xf7f7f5, roughness:0.28, clearcoat:0.8, clearcoatRoughness:0.1, side:THREE.DoubleSide }),\n    birne:  new THREE.MeshStandardMaterial({ name:'leuchtmittel', color:0xffffff, emissive:0xfff1d6, emissiveIntensity:0.2 }),\n  };\n  const add = (parent, name, geo, mat, p=[0,0,0], r=[0,0,0]) => { const m = new THREE.Mesh(geo, mat); m.name = name; m.position.set(...p); m.rotation.set(...r); parent.add(m); return m; };\n  const lampe = new THREE.Group(); lampe.name = 'bogenlampe';\n  const H = 1.66, REACH = 1.22, SH_R = 0.15, BASE_R = 0.13, BASE_H = 0.028, POLE_R = 0.0125, ARC_R = 0.0085, POLE_TOP = 0.74;\n  const prof = [new THREE.Vector2(0, 0), new THREE.Vector2(BASE_R - 0.004, 0)];\n  for (let i = 0; i <= 10; i++){ const a = -Math.PI/2 + i/10*Math.PI/2; prof.push(new THREE.Vector2(BASE_R - 0.008 + Math.cos(a)*0.008, 0.008 + Math.sin(a)*0.008)); }\n  for (let i = 0; i <= 10; i++){ const a = i/10*Math.PI/2; prof.push(new THREE.Vector2(BASE_R - 0.012 + Math.cos(a)*0.012, BASE_H - 0.012 + Math.sin(a)*0.012)); }\n  prof.push(new THREE.Vector2(0, BASE_H));\n  add(lampe, 'fuss', new THREE.LatheGeometry(prof, 96), M.chrom);\n  add(lampe, 'fuss_rosette', new THREE.CylinderGeometry(0.022, 0.026, 0.012, 48), M.chrom, [0, BASE_H + 0.006, 0]);\n  add(lampe, 'standrohr', new THREE.CylinderGeometry(POLE_R, POLE_R, POLE_TOP - BASE_H, 48), M.chrom, [0, (POLE_TOP + BASE_H)/2, 0]);\n  add(lampe, 'muffe_unten', new THREE.CylinderGeometry(POLE_R + 0.0015, POLE_R + 0.0015, 0.03, 48), M.chrom, [0, POLE_TOP - 0.015, 0]);\n  const ARC_END = V(REACH - 0.04, H - ARC_R);\n  const arc = new THREE.CubicBezierCurve3(V(0, POLE_TOP - 0.02), V(0, 1.38), V(0.42, H - ARC_R), ARC_END);\n  add(lampe, 'bogen', new THREE.TubeGeometry(arc, 240, ARC_R, 32), M.chrom);\n  const pM = arc.getPointAt(0.36), dM = arc.getTangentAt(0.36);\n  const muffe = add(lampe, 'muffe_bogen', new THREE.CylinderGeometry(ARC_R + 0.0018, ARC_R + 0.0018, 0.035, 32), M.chrom, [pM.x, pM.y, 0]);\n  muffe.quaternion.setFromUnitVectors(V(0,1,0), dM);\n  add(lampe, 'endkappe', new THREE.CylinderGeometry(ARC_R + 0.002, ARC_R + 0.002, 0.07, 32), M.chrom, [ARC_END.x - 0.02, ARC_END.y, 0], [0, 0, Math.PI/2]);\n  const kopf = new THREE.Group(); kopf.name = 'schirm_gruppe';\n  const TILT = 0.3;\n  kopf.position.set(REACH - SH_R*Math.sin(TILT), H - ARC_R - 0.035, 0);\n  kopf.rotation.z = TILT;\n  add(lampe, 'gelenk', new THREE.CylinderGeometry(0.006, 0.006, 0.03, 20), M.chrom, [kopf.position.x, H - ARC_R - 0.018, 0]);\n  lampe.add(kopf);\n  add(kopf, 'schirm', new THREE.SphereGeometry(SH_R, 96, 48, 0, Math.PI*2, 0, 1.95), M.schirm, [0, -SH_R, 0]);\n  add(kopf, 'schirm_nabe', new THREE.CylinderGeometry(0.018, 0.028, 0.02, 40), M.chrom, [0, -0.004, 0]);\n  add(kopf, 'fassung', new THREE.CylinderGeometry(0.016, 0.016, 0.05, 32), M.chrom, [0, -0.04, 0]);\n  add(kopf, 'leuchtmittel', new THREE.SphereGeometry(0.03, 32, 16), M.birne, [0, -0.09, 0]);\n  return { group: lampe, REACH };\n}\n\n// Verzinkter Stahl (Zink-Spangle, prozedural) – aus Regal 3D\nfunction galvanized(size=1024, cells=24, seed=7){\n  let s = seed; const rnd = () => (s = (s*16807) % 2147483647) / 2147483647;\n  const g = cells, pts = [];\n  for (let j=0;j<g;j++) for (let i=0;i<g;i++){\n    const a = rnd()*Math.PI*2;\n    pts.push({ x:(i+rnd())/g, y:(j+rnd())/g, base: 0.72 + rnd()*0.18, gx:Math.cos(a), gy:Math.sin(a), k: 0.03 + rnd()*0.08, r: rnd() });\n  }\n  const col = document.createElement('canvas'); col.width = col.height = size;\n  const rou = document.createElement('canvas'); rou.width = rou.height = size;\n  const cc = col.getContext('2d'), rc = rou.getContext('2d');\n  const ci = cc.createImageData(size,size), ri = rc.createImageData(size,size);\n  for (let y=0;y<size;y++) for (let x=0;x<size;x++){\n    const u = x/size, v = y/size, cx = Math.floor(u*g), cy = Math.floor(v*g);\n    let best = 9, second = 9, bp = null, bdx=0, bdy=0;\n    for (let oy=-1;oy<=1;oy++) for (let ox=-1;ox<=1;ox++){\n      const ix = (cx+ox+g)%g, iy = (cy+oy+g)%g, p = pts[iy*g+ix];\n      const dx = u - (p.x + Math.floor((cx+ox)/g) * 1 + ((cx+ox)<0?0:0)) , dy = v - (p.y + Math.floor((cy+oy)/g));\n      const d = dx*dx + dy*dy;\n      if (d < best){ second = best; best = d; bp = p; bdx = dx; bdy = dy; } else if (d < second) second = d;\n    }\n    const edge = Math.sqrt(second) - Math.sqrt(best);            // Abstand zur Korngrenze\n    let l = bp.base + (bdx*bp.gx + bdy*bp.gy) * g * bp.k;        // Facetten-Verlauf pro Korn\n    l += (Math.random()-0.5)*0.05;                               // feines Korn\n    if (edge < 0.0018) l -= 0.035;                                // dunkle Korngrenzen\n    if (Math.random() < 0.003) l -= 0.12;                        // dunkle Sprenkel\n    l = Math.max(0.25, Math.min(0.97, l));\n    const o = (y*size+x)*4, c = l*255;\n    ci.data[o]=c*0.98; ci.data[o+1]=c; ci.data[o+2]=c*1.02; ci.data[o+3]=255;\n    const r = (0.28 + (1-l)*0.35 + bp.r*0.12) * 255;             // helle Körner glänzender\n    ri.data[o]=ri.data[o+1]=ri.data[o+2]=r; ri.data[o+3]=255;\n  }\n  cc.putImageData(ci,0,0); rc.putImageData(ri,0,0);\n  return { col, rou };\n}\nfunction galvanizedMaterial(THREE, repeat = 18){\n  const { col, rou } = galvanized();\n  const mk = (c, srgb) => { const t = new THREE.CanvasTexture(c); t.wrapS = t.wrapT = THREE.RepeatWrapping; t.repeat.set(repeat, repeat);\n    if (srgb) t.colorSpace = THREE.SRGBColorSpace; t.anisotropy = 8; return t; };\n  return new THREE.MeshStandardMaterial({ name:'stahl_verzinkt', map: mk(col, true), roughnessMap: mk(rou), bumpMap: mk(col), bumpScale: 0.25,\n    color: 0xeceef0, roughness: 1, metalness: 0.3 });\n}\n\n// Regallautsprecher-Paar (aus Boxen 3D): passiv + aktiv (Bedienfeld an lokaler +x-Seite)\nfunction buildBoxen(THREE){\n  const M = {\n    wood:   new THREE.MeshStandardMaterial({ name:'eiche', color:0xb77a3e, roughness:0.55 }),\n    fabric: new THREE.MeshStandardMaterial({ name:'stoff_grau', color:0x6c6c6a, roughness:0.97 }),\n    strip:  new THREE.MeshStandardMaterial({ name:'zierleiste_silber', color:0xc9c9c9, roughness:0.3, metalness:0.9 }),\n    black:  new THREE.MeshStandardMaterial({ name:'kunststoff_schwarz', color:0x1c1c1c, roughness:0.6 }),\n    knob:   new THREE.MeshStandardMaterial({ name:'drehregler', color:0x141414, roughness:0.4, metalness:0.2 }),\n    alu:    new THREE.MeshStandardMaterial({ name:'hochtoener_alu', color:0xaaaaaa, roughness:0.35, metalness:0.8 }),\n    led:    new THREE.MeshStandardMaterial({ name:'led', color:0x0a2a10, emissive:0x2bd45a, emissiveIntensity:1.2 }),\n  };\n  const W=0.146, D=0.196, H=0.234, R=0.014, BV=0.002;\n  const mesh = (name, geo, mat, x=0, y=0, z=0) => mk(THREE, name, geo, mat, x, y, z);\n  const rrect = (w, h, r) => { const s = new THREE.Shape(), x=-w/2, y=-h/2;\n    s.moveTo(x+r,y); s.lineTo(x+w-r,y); s.quadraticCurveTo(x+w,y,x+w,y+r); s.lineTo(x+w,y+h-r); s.quadraticCurveTo(x+w,y+h,x+w-r,y+h);\n    s.lineTo(x+r,y+h); s.quadraticCurveTo(x,y+h,x,y+h-r); s.lineTo(x,y+r); s.quadraticCurveTo(x,y,x+r,y); return s; };\n  const cabGeo = new THREE.ExtrudeGeometry(rrect(W-2*BV, D-2*BV, R), { depth:H-2*BV, bevelEnabled:true, bevelSize:BV, bevelThickness:BV, bevelSegments:2, curveSegments:10 });\n  cabGeo.rotateX(-Math.PI/2); cabGeo.translate(0, BV, 0);\n  { const p = cabGeo.attributes.position, n = cabGeo.attributes.normal, uv = cabGeo.attributes.uv;\n    for (let i=0;i<p.count;i++){ const x=p.getX(i), y=p.getY(i), z=p.getZ(i);\n      if (Math.abs(n.getY(i)) > 0.7) uv.setXY(i, x, z); else uv.setXY(i, Math.abs(n.getX(i)) > Math.abs(n.getZ(i)) ? z : x, y); } }\n  const GW=W-0.006, GH=H-0.006, GT=0.008;\n  const grilleGeo = new THREE.ExtrudeGeometry(rrect(GW-0.004, GH-0.004, 0.009), { depth:GT-0.003, bevelEnabled:true, bevelSize:0.002, bevelThickness:0.0015, bevelSegments:3, curveSegments:8 });\n  function speaker(name, active){\n    const s = new THREE.Group(); s.name = name;\n    s.add(mesh(name+'_gehaeuse', cabGeo, M.wood));\n    s.add(mesh(name+'_stoff', grilleGeo, M.fabric, 0, H/2, D/2 + 0.0015));\n    s.add(mesh(name+'_zierleiste', new THREE.BoxGeometry(GW*0.74, 0.0026, 0.0012), M.strip, 0, H*0.585, D/2 + GT + 0.0005));\n    s.add(mesh(name+'_logo', new THREE.BoxGeometry(0.026, 0.006, 0.0008), M.strip, 0, 0.026, D/2 + GT + 0.0003));\n    const port = mesh(name+'_bassreflex', new THREE.CylinderGeometry(0.014, 0.014, 0.004, 32), M.black, 0, 0.17, -D/2 - 0.001);\n    port.rotation.x = Math.PI/2; s.add(port);\n    for (const [fx,fz] of [[-1,-1],[1,-1],[-1,1],[1,1]])\n      s.add(mesh(name+'_fuss', new THREE.CylinderGeometry(0.006,0.006,0.002,20), M.black, fx*(W/2-0.02), 0.001, fz*(D/2-0.025)));\n    if (active){\n      const px = W/2 + 0.0004, cz = -0.012;\n      s.add(mesh(name+'_bedienfeld', new THREE.BoxGeometry(0.002, 0.108, 0.055), M.black, px, 0.14, cz));\n      [0.176, 0.143, 0.11].forEach((y, i) => {\n        const k = mesh(name+'_regler_'+['hoehen','bass','lautstaerke'][i], new THREE.CylinderGeometry(0.0085, 0.0085, 0.011, 28), M.knob, px+0.0055, y, cz-0.004);\n        k.rotation.z = Math.PI/2; s.add(k);\n      });\n      s.add(mesh(name+'_led', new THREE.SphereGeometry(0.0015, 12, 8), M.led, px+0.001, 0.093, cz-0.004));\n    }\n    s.traverse(o => { if (o.isMesh) o.position.y += 0.002; });\n    return s;\n  }\n  return { W, D, H, links: speaker('box_links', false), rechts: speaker('box_rechts_aktiv', true) };\n}\n\n// Tripod-Lampe (aus Tripodlampe 3D): Eichen-Leuchtkopf mit LED-Spot auf schwarzem Dreibein; Front = lokale +z\nfunction buildTripod(THREE){\n  const V = (x,y,z) => new THREE.Vector3(x,y,z);\n  const c = document.createElement('canvas'); c.width = c.height = 512; const g = c.getContext('2d');\n  g.fillStyle = '#c49a66'; g.fillRect(0,0,512,512);\n  let s = 11; const r = () => (s = (s*16807) % 2147483647) / 2147483647;\n  for (let i = 0; i < 260; i++){\n    const y = r()*512, a = 0.04 + r()*0.12; g.strokeStyle = r() > 0.5 ? `rgba(120,80,40,${a})` : `rgba(235,200,150,${a})`; g.lineWidth = 0.5 + r()*2.2;\n    g.beginPath(); g.moveTo(0,y); for (let x = 0; x <= 512; x += 32) g.lineTo(x, y + Math.sin(x*0.012 + i)*4 + (r()-0.5)*1.5); g.stroke();\n  }\n  const tex = new THREE.CanvasTexture(c); tex.colorSpace = THREE.SRGBColorSpace;\n  const M = {\n    holz:   new THREE.MeshStandardMaterial({ name:'tripod_eiche', map: tex, roughness:0.6 }),\n    stahl:  new THREE.MeshStandardMaterial({ name:'tripod_stahl_schwarz', color:0x1b1b1c, roughness:0.45, metalness:0.6 }),\n    gummi:  new THREE.MeshStandardMaterial({ name:'tripod_gummi', color:0x111111, roughness:0.9 }),\n    blende: new THREE.MeshStandardMaterial({ name:'tripod_reflektor', color:0x9a9a9a, roughness:0.25, metalness:0.9 }),\n    led:    new THREE.MeshStandardMaterial({ name:'tripod_led', color:0xd8dadd, emissive:0xf4f7ff, emissiveIntensity:0, roughness:0.2 }),\n    kabel:  new THREE.MeshStandardMaterial({ name:'tripod_kabel', color:0x151515, roughness:0.7 }),\n  };\n  const add = (p, n, geo, mat, pos=[0,0,0]) => { const o = mk(THREE, n, geo, mat, ...pos); p.add(o); return o; };\n  const rod = (p, n, a, b, rr, mat) => { const d = b.clone().sub(a), o = add(p, n, new THREE.CylinderGeometry(rr, rr, d.length(), 20), mat);\n    o.position.copy(a).addScaledVector(d, 0.5); o.quaternion.setFromUnitVectors(V(0,1,0), d.normalize()); return o; };\n  const group = new THREE.Group(); group.name = 'tripodlampe';\n  const HUB = V(0, 0.36, 0), FR = 0.17;\n  for (let i = 0; i < 3; i++){\n    const a = Math.PI/2 + i*2*Math.PI/3, foot = V(Math.cos(a)*FR, 0.006, Math.sin(a)*FR);\n    rod(group, 'tripod_bein_'+(i+1), foot, HUB.clone().add(V(Math.cos(a)*0.012, 0, Math.sin(a)*0.012)), 0.005, M.stahl);\n    add(group, 'tripod_fuss_'+(i+1), new THREE.CylinderGeometry(0.0058, 0.0058, 0.012, 16), M.gummi, [foot.x, 0.006, foot.z]);\n  }\n  add(group, 'tripod_knoten', new THREE.CylinderGeometry(0.016, 0.018, 0.028, 28), M.stahl, [0, 0.36, 0]);\n  const HW = 0.14, HH = 0.12, HD = 0.11;\n  const arm = new THREE.CatmullRomCurve3([V(0,0.374,0), V(-0.01,0.41,0), V(-0.045,0.45,0.005), V(-0.09,0.485,0.01), V(-0.092,0.495,0.01), V(-HW/2-0.008,0.49,0.01)]);\n  add(group, 'tripod_buegel', new THREE.TubeGeometry(arm, 48, 0.0055, 12), M.stahl);\n  const kopf = new THREE.Group(); kopf.name = 'tripod_kopf'; kopf.position.set(0, 0.49, 0.01); kopf.rotation.set(0.12, 0.15, 0); group.add(kopf);\n  add(kopf, 'tripod_holzkoerper', new THREE.BoxGeometry(HW, HH, HD), M.holz);\n  add(kopf, 'tripod_gelenk', new THREE.CylinderGeometry(0.013, 0.013, 0.01, 28), M.stahl, [-HW/2-0.005, 0, 0]).rotation.z = Math.PI/2;\n  add(kopf, 'tripod_blende', new THREE.TorusGeometry(0.036, 0.005, 12, 48), M.blende, [0.01, 0, HD/2+0.001]);\n  add(kopf, 'tripod_reflektor', new THREE.CylinderGeometry(0.036, 0.03, 0.012, 48, 1, true), M.blende, [0.01, 0, HD/2-0.005]).rotation.x = Math.PI/2;\n  const linse = add(kopf, 'tripod_led_linse', new THREE.CircleGeometry(0.034, 48), M.led, [0.01, 0, HD/2-0.008]);\n  const kabel = new THREE.CatmullRomCurve3([V(-0.005,0.35,-0.012), V(-0.03,0.28,-0.04), V(-0.07,0.16,-0.08), V(-0.11,0.05,-0.12), V(-0.14,0.004,-0.16), V(-0.28,0.004,-0.24), V(-0.45,0.004,-0.2)]);\n  add(group, 'tripod_kabel', new THREE.TubeGeometry(kabel, 64, 0.0022, 8), M.kabel);\n  group.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\n  linse.castShadow = false;\n  // Lichtquellen am Kopf (Intensität 0 = aus)\n  const spot = new THREE.SpotLight(0xf2f5ff, 0, 0, 0.55, 0.5, 2);\n  spot.position.set(0.01, 0, HD/2 + 0.005); spot.target.position.set(0.01, 0, HD/2 + 1);\n  spot.castShadow = true; spot.shadow.mapSize.set(1024, 1024); spot.shadow.bias = -0.0005; spot.shadow.normalBias = 0.02;\n  spot.shadow.camera.near = 0.03; spot.shadow.camera.far = 8;\n  const glow = new THREE.PointLight(0xf2f5ff, 0, 3, 2); glow.position.set(0.01, 0, HD/2 + 0.05);\n  kopf.add(spot, spot.target, glow);\n  return { group, kopf, M, spot, glow };\n}\n\nconst stage = document.querySelector('three-d-stage');\nconst { THREE } = await stage.ready;\nconst statusEl = { set textContent(v){} };\nfor (const sel of ['.toolbar','.note']) { const el = stage.shadowRoot.querySelector(sel); if (el) el.style.display = 'none'; }\n\n// ---------- Maße in Metern (LiDAR-Scan 10/2026, bereinigt) ----------\n// x = Ost, z = Süd; Ursprung = Innenkante Westwand Schlafzimmer / Innenkante Nordwand\nconst H = 2.5, TE = 0.2, TI = 0.1;     // Wandhöhe, Außen-/Innenwand\nconst DOOR_W = 0.9, DOOR_H = 2.1, WIN_B = 0.9, WIN_T = 2.2;\n\n// ---------- Materialien ----------\nconst M = {\n  floor:  new THREE.MeshStandardMaterial({ name:'wood_floor', color:0x8a6242, roughness:0.6 }),\n  wall:   new THREE.MeshStandardMaterial({ name:'white_stucco', color:0xf2efe9, roughness:0.95 }),\n  brick:  new THREE.MeshStandardMaterial({ name:'brick_wall_04', color:0x9a5a44, roughness:0.9 }),\n  cap:    new THREE.MeshStandardMaterial({ name:'rough_plaster_brick_04', color:0xb8a898, roughness:0.95 }),\n  plinth: new THREE.MeshStandardMaterial({ name:'plinth', color:0x2f2d2a, roughness:0.7 }),\n  wood:   new THREE.MeshStandardMaterial({ name:'door_white_lacquer', color:0xf7f5f0, roughness:0.35 }),\n  metal:  new THREE.MeshStandardMaterial({ name:'brushed_steel', color:0xb9bcc0, roughness:0.3, metalness:0.35 }),\n  glass:  new THREE.MeshStandardMaterial({ name:'glass', color:0xbfd8e4, roughness:0.05, transparent:true, opacity:0.35 }),\n  balcony:new THREE.MeshStandardMaterial({ name:'balcony_concrete', color:0xa9a59d, roughness:0.9 }),\n};\n\n// Welt-UVs (Box-Projektion), damit Texturen nicht gestreckt werden\nfunction worldUV(geo, scale){\n  const p = geo.attributes.position, n = geo.attributes.normal, uv = geo.attributes.uv;\n  for (let i = 0; i < p.count; i++){\n    const ax = Math.abs(n.getX(i)), ay = Math.abs(n.getY(i)), az = Math.abs(n.getZ(i));\n    let u, v;\n    if (ay >= ax && ay >= az){ u = p.getX(i); v = p.getZ(i); }\n    else if (ax >= az){ u = p.getZ(i); v = p.getY(i); }\n    else { u = p.getX(i); v = p.getY(i); }\n    uv.setXY(i, u/scale, v/scale);\n  }\n  uv.needsUpdate = true;\n  return geo;\n}\n// Box in Weltkoordinaten (min/max)\nfunction box(name, mat, x0,y0,z0, x1,y1,z1, uvScale){\n  const g = new THREE.BoxGeometry(x1-x0, y1-y0, z1-z0);\n  g.translate((x0+x1)/2, (y0+y1)/2, (z0+z1)/2);\n  if (uvScale) worldUV(g, uvScale);\n  const m = new THREE.Mesh(g, mat); m.name = name; return m;\n}\n\nconst home = new THREE.Group(); home.name = 'wohnung';\nconst walls = new THREE.Group(); walls.name = 'waende';\nconst doors = new THREE.Group(); doors.name = 'tueren';\nconst windows = new THREE.Group(); windows.name = 'fenster';\nhome.add(walls, doors, windows);\n\n// ---------- Tür (prozedural, Kassettentür) ----------\nfunction makeDoor(name, t, openDeg, glassDoor=false, w=DOOR_W){\n  const g = new THREE.Group(); g.name = name;\n  const d = t + 0.03;\n  g.add(box(name+'_zarge_l', M.wood, -w/2, 0, -d/2, -w/2+0.04, DOOR_H, d/2));\n  g.add(box(name+'_zarge_r', M.wood,  w/2-0.04, 0, -d/2, w/2, DOOR_H, d/2));\n  g.add(box(name+'_zarge_oben', M.wood, -w/2, DOOR_H-0.04, -d/2, w/2, DOOR_H, d/2));\n  const lw = w - 0.08, lh = DOOR_H - 0.05, lt = 0.04;\n  const pivot = new THREE.Group(); pivot.name = name+'_blatt';\n  pivot.position.set(-w/2 + 0.04, 0.005, 0);\n  pivot.rotation.y = THREE.MathUtils.degToRad(openDeg);\n  pivot.add(box(name+'_tuerblatt', M.wood, 0, 0, -lt/2, lw, lh, lt/2));\n  for (const s of [1,-1]){\n    const z0 = s*0.014, z1 = s*0.026, zz=[Math.min(z0,z1),Math.max(z0,z1)];\n    if (glassDoor){\n      pivot.add(box(name+'_glas', M.glass, 0.1, 0.35, -0.006, lw-0.1, lh-0.12, 0.006));\n    } else {\n      pivot.add(box(name+'_kassette_o'+s, M.wood, 0.11, 1.05, zz[0], lw-0.11, lh-0.14, zz[1]));\n      pivot.add(box(name+'_kassette_u'+s, M.wood, 0.11, 0.14, zz[0], lw-0.11, 0.9, zz[1]));\n    }\n    const rose = new THREE.Mesh(new THREE.CylinderGeometry(0.026,0.026,0.012,32), M.metal);\n    rose.name = name+'_rosette'+s; rose.rotation.x = Math.PI/2; rose.position.set(lw-0.07, 1.05, s*(lt/2+0.006)); pivot.add(rose);\n    const neck = new THREE.Mesh(new THREE.CylinderGeometry(0.009,0.009,0.05,20), M.metal);\n    neck.name = name+'_hals'+s; neck.rotation.x = Math.PI/2; neck.position.set(lw-0.07, 1.05, s*(lt/2+0.03)); pivot.add(neck);\n    const lever = new THREE.Mesh(new THREE.CapsuleGeometry(0.009, 0.12, 6, 16), M.metal);\n    lever.name = name+'_druecker'+s; lever.rotation.z = Math.PI/2; lever.position.set(lw-0.13, 1.05, s*(lt/2+0.055)); pivot.add(lever);\n  }\n  for (const y of [0.25, lh-0.25]){\n    const h = new THREE.Mesh(new THREE.CylinderGeometry(0.008,0.008,0.1,16), M.metal);\n    h.name = name+'_band'; h.position.set(-0.004, y, lt/2); pivot.add(h);\n  }\n  g.add(pivot);\n  return g;\n}\n\n// ---------- Fenster ----------\nfunction makeWindow(name, w, t, bottom, top){\n  const g = new THREE.Group(); g.name = name;\n  const f = 0.05, d = 0.07;\n  g.add(box(name+'_rahmen_l', M.wood, -w/2, bottom, -d/2, -w/2+f, top, d/2));\n  g.add(box(name+'_rahmen_r', M.wood, w/2-f, bottom, -d/2, w/2, top, d/2));\n  g.add(box(name+'_rahmen_o', M.wood, -w/2+f, top-f, -d/2, w/2-f, top, d/2));\n  g.add(box(name+'_rahmen_u', M.wood, -w/2+f, bottom, -d/2, w/2-f, bottom+f, d/2));\n  if (w > 1.1) g.add(box(name+'_pfosten', M.wood, -0.025, bottom+f, -d/2+0.005, 0.025, top-f, d/2-0.005));\n  g.add(box(name+'_glas', M.glass, -w/2+f, bottom+f, -0.005, w/2-f, top-f, 0.005));\n  if (bottom > 0) g.add(box(name+'_bank', M.wood, -w/2-0.05, bottom-0.027, -t/2-0.04, w/2+0.05, bottom+0.012, t/2+0.04));\n  return g;\n}\n\n// ---------- Wand mit Öffnungen (achsparallel, Meter) ----------\n// a..b: Ausdehnung entlang der Wand, fixed: Mittellinie; ops: {c, w, type:'door'|'window'|'glassdoor', open, flip, name}\n// outside: Box-Face-Index der Außenseite (0:+x 1:-x 4:+z 5:-z) → Klinker außen, Putz innen; ends: Stirnseiten außen sichtbar\nfunction wall(name, a, b, fixed, horizontal, t, h, ops=[], outside=-1, ends=[false,false]){\n  const F = fixed;\n  const seg = (n, s0, s1, y0, y1, ef=[]) => {\n    if (s1 - s0 < 0.001) return;\n    const mat = Array(6).fill(M.wall);\n    if (outside >= 0){ mat[outside] = M.brick; ef.forEach(e => mat[e] = M.brick); }\n    if (y1 >= h - 0.0001) mat[2] = M.cap;\n    walls.add(horizontal ? box(n, mat, s0, y0, F-t/2, s1, y1, F+t/2, 1.5)\n                         : box(n, mat, F-t/2, y0, s0, F+t/2, y1, s1, 1.5));\n  };\n  const endA = ends[0] ? [horizontal ? 1 : 5] : [], endB = ends[1] ? [horizontal ? 0 : 4] : [];\n  const list = [...ops].sort((p,q)=>p.c-q.c);\n  let cur = a;\n  list.forEach((o, i) => {\n    const s0 = o.c - o.w/2, s1 = o.c + o.w/2;\n    seg(`${name}_${i}`, cur, s0, 0, h, i === 0 ? endA : []);\n    seg(`${name}_sturz_${i}`, s0, s1, o.type === 'door' ? DOOR_H : WIN_T, h);\n    if (o.type === 'window') seg(`${name}_bruestung_${i}`, s0, s1, 0, WIN_B);\n    let el;\n    if (o.type === 'door') { el = makeDoor(o.name, t, o.open ?? 0, false, o.w); doors.add(el); }\n    else if (o.type === 'glassdoor') { el = makeWindow(o.name, o.w, t, 0, WIN_T); windows.add(el); }\n    else { el = makeWindow(o.name, o.w, t, WIN_B, WIN_T); windows.add(el); }\n    if (horizontal) el.position.set(o.c, 0, F);\n    else { el.position.set(F, 0, o.c); el.rotation.y = Math.PI/2; }\n    if (o.flip) el.rotation.y += Math.PI;\n    cur = s1;\n  });\n  seg(`${name}_${list.length}`, cur, b, 0, h, list.length === 0 ? [...endA, ...endB] : endB);\n}\n\n// Grundriss nach LiDAR-Scan: Raummaße, Wandlagen, Öffnungsmitten. Nicht übernommen: „Other 4“-Spalt, Scan-Möbel,\n// schräger Wandrest im Flur, 10-cm-Versatz der Ostfassade (begradigt). Tür-/Fensterbreiten + Mauervorsprung = Handmaße.\nconst HI = H - 0.003; // Innenwände minimal niedriger → kein Z-Fighting auf den Oberkanten\nconst X_FL = 1.21;              // Innenkante Westwand Bad/Flur (Schlafzimmer springt 1,21 m weiter nach Westen)\nconst X_SW = 2.66;              // Wandmitte Schlafzimmer | Wohnzimmer\nconst X_SCH = 2.11;             // Westkante Schacht\nconst X_BK = 3.29;              // Wandmitte Bad | Küche\nconst X_FK = 3.58;              // Wandmitte Flur | Küche\nconst X_EK = 6.17, X_E = 6.27;  // Innenkante Ostwand Küche / Wohnzimmer\nconst Z_SCH0 = 2.54, Z_SCH1 = 3.31; // Schacht Nord-/Südkante\nconst Z_BF = 3.13;              // Wandmitte Bad | Flur\nconst Z_SP = 4.40;              // Wandmitte Küche/Flur | Wohn-/Schlafzimmer\nconst Z_S = 8.49;               // Innenkante Südwand\nconst ZST = Z_SP + TI/2 - TE;   // Außenkante Rücksprung (Treppenhaus)\n// Raum-Innenkanten [x0, z0, x1, z1]\nconst RM_SZ  = [0, Z_SP + TI/2, X_SW - TI/2, Z_S];            // Schlafzimmer 2,61 × 4,04\nconst RM_WZ  = [X_SW + TI/2, Z_SP + TI/2, X_E, Z_S];          // Wohnzimmer 3,56 × 4,04\nconst RM_KU  = [X_BK + TI/2, 0, X_EK, Z_SP - TI/2];           // Küche 2,83 × 4,35\nconst RM_BAD = [X_FL, 0, X_BK - TI/2, Z_BF - TI/2];           // Bad 2,03 × 3,08\nconst RM_FL  = [X_FL, Z_BF + TI/2, X_FK - TI/2, Z_SP - TI/2]; // Flur 2,32 × 1,17\nconst BAD_DOOR = { c: 1.70, w: 0.75 }, SZ_DOOR = { c: 1.74, w: 0.83 }, WZ_DOOR = { c: 4.85, w: 0.83 };\nconst KU_WIN = { c: RM_KU[0] + 0.48 + 0.325, w: 0.65 }, KU_DOOR = { c: RM_KU[0] + 0.48 + 0.65 + 0.12 + 0.425, w: 0.85 };\n\n// Außenwände\nwall('aussen_nord', X_FL - TE, X_E + TE, -TE/2, true, TE, H, [\n  { c: 2.25, w: 0.8, type:'window', name:'fenster_bad' },\n  // Küche: Fenster + Balkontür als Einheit\n  { ...KU_WIN, type:'window', name:'fenster_kueche' },\n  { ...KU_DOOR, type:'glassdoor', name:'balkontuer' },\n], 5, [true, true]);\nwall('aussen_sued', -TE, X_E + TE, Z_S + TE/2, true, TE, H, [\n  { c: 0.94, w: 0.7, type:'window', name:'fenster_schlafzimmer' },\n  { c: 3.37, w: 0.7, type:'window', name:'fenster_wohnzimmer_1' },\n  { c: 5.42, w: 0.7, type:'window', name:'fenster_wohnzimmer_2' },\n], 4, [true, true]);\nwall('aussen_west_schlafzimmer', Z_SP + TI/2, Z_S, -TE/2, false, TE, H, [], 1);\nwall('aussen_nord_schlafzimmer', -TE, X_FL, ZST + TE/2, true, TE, H, [], 5, [true, false]);\nwall('aussen_west', 0, ZST, X_FL - TE/2, false, TE, H, [\n  { c: (Z_BF + Z_SP)/2, w: DOOR_W, type:'door', open: -35, name:'wohnungstuer' },\n], 1);\n// Ostfassade außen gerade; Küchenwand innen 10 cm dicker (Scan)\nwall('aussen_ost_kueche', 0, Z_SP, (X_EK + X_E + TE)/2, false, X_E + TE - X_EK, H, [], 0);\nwall('aussen_ost', Z_SP, Z_S, X_E + TE/2, false, TE, H, [], 0);\n// Innenwände\nwall('innen_bad_kueche', 0, Z_SCH0, X_BK, false, TI, HI);\nwall('innen_bad_flur', X_FL, X_SCH, Z_BF, true, TI, HI, [\n  { ...BAD_DOOR, type:'door', open: 80, name:'tuer_bad' },\n]);\nwall('innen_flur_kueche', Z_SCH1, Z_SP - TI/2, X_FK, false, TI, HI, [\n  { c: 3.78, w: 0.86, type:'door', open: -70, name:'tuer_kueche' },\n]);\nwall('innen_mitte', X_FL, X_E, Z_SP, true, TI, HI, [\n  { ...SZ_DOOR, type:'door', open: 55, flip:true, name:'tuer_schlafzimmer' },\n  { ...WZ_DOOR, type:'door', open: 65, flip:true, name:'tuer_wohnzimmer' },\n]);\nwall('innen_schlafen_wohnen', Z_SP + TI/2, Z_S, X_SW, false, TI, HI);\n// Schacht zwischen Bad, Flur und Küche (Scan: Hohlraum 56 × 145 cm ohne Wand zur Küche → als geschlossen angenommen)\n{ const m = Array(6).fill(M.wall); m[2] = M.cap; walls.add(box('schacht', m, X_SCH, 0, Z_SCH0, X_FK + TI/2, HI, Z_SCH1, 1.5)); }\n\n// ---------- Boden, Sockel, Balkon ----------\nconst OUTLINE = [[X_FL - TE/2, -TE/2], [X_E + TE/2, -TE/2], [X_E + TE/2, Z_S + TE/2], [-TE/2, Z_S + TE/2], [-TE/2, ZST + TE/2], [X_FL - TE/2, ZST + TE/2]];\nconst floorGeo = new THREE.ShapeGeometry(new THREE.Shape(OUTLINE.map(([x, z]) => new THREE.Vector2(x, -z))));\nfloorGeo.rotateX(-Math.PI/2); floorGeo.translate(0, 0.002, 0);\nworldUV(floorGeo, 1.0);\nconst floor = new THREE.Mesh(floorGeo, M.floor); floor.name = 'boden_wood_floor';\nhome.add(floor);\nhome.add(box('sockel_nord', M.plinth, X_FL - TE - 0.05, -0.12, -TE - 0.05, X_E + TE + 0.05, 0, ZST - 0.05));\nhome.add(box('sockel_sued', M.plinth, -TE - 0.05, -0.12, ZST - 0.05, X_E + TE + 0.05, 0, Z_S + TE + 0.05));\n// Balkon über die ganze Küchenbreite, 2,26 m tief (Scan); Brüstungen statt der gescannten Wände\nconst PH = 1.0, PT = 0.08;\nconst BX0 = RM_KU[0] - PT, BX1 = RM_KU[2] + PT, BZ1 = -TE, BZ0 = BZ1 - 2.26 - PT;\nhome.add(box('balkon_platte', M.balcony, BX0, -0.12, BZ0, BX1, 0.02, BZ1));\nhome.add(box('balkon_bruestung_w', M.wall, BX0, 0.02, BZ0, BX0+PT, PH, BZ1, 1.5));\nhome.add(box('balkon_bruestung_o', M.wall, BX1-PT, 0.02, BZ0, BX1, PH, BZ1, 1.5));\nhome.add(box('balkon_bruestung_n', M.wall, BX0+PT, 0.02, BZ0, BX1-PT, PH-0.002, BZ0+PT, 1.5));\n\n// ---------- Wohnzimmer (Raum Süd-Ost) ----------\nconst wohn = new THREE.Group(); wohn.name = 'wohnzimmer';\nconst IN_O = X_E, IN_S = Z_S, WZ_CX = (RM_WZ[0] + RM_WZ[2])/2, SOFA_Z = Z_S - 1.745;   // Innenkanten Ost-/Südwand\n// Sofa an der Ostwand, Rücken zur Wand\nconst sofa = buildSofa(THREE);\nsofa.group.position.set(IN_O - sofa.D/2 - 0.03, 0.002, SOFA_Z);\nsofa.group.rotation.y = -Math.PI/2;\nwohn.add(sofa.group);\n// 3 Regale nebeneinander unter dem Südfenster, Front zum Raum\nconst RM = regalMaterials(THREE);\nfor (const [i, dx] of [[1,-0.603],[2,0],[3,0.603]]){\n  const r = buildRegal(THREE, RM); r.name = 'regal_'+i;\n  r.position.set(WZ_CX + dx, 0.002, IN_S - 0.135 - 0.02);\n  r.rotation.y = Math.PI;\n  wohn.add(r);\n}\n// Boxen oben auf den äußeren Regalen, leicht nach innen gedreht\n{\n  const bx = buildBoxen(THREE), top = new THREE.Box3().setFromObject(wohn.getObjectByName('regal_1')).max.y;\n  const TURN = THREE.MathUtils.degToRad(15), X = 0.603 + 0.30 - 0.105, Z = IN_S - 0.135 - 0.02;\n  // Aktivbox links (–x), Bedienfeld zeigt nach außen\n  bx.rechts.position.set(WZ_CX - X, top, Z); bx.rechts.rotation.y = Math.PI - TURN;\n  bx.links.position.set(WZ_CX + X, top, Z);  bx.links.rotation.y = Math.PI + TURN;\n  wohn.add(bx.links, bx.rechts);\n}\n// Bogenlampe in der Fensterecke, Schirm über dem Sofa – zur Raummitte versetzt\nconst lampe = buildLampe(THREE);\nconst LB = new THREE.Vector2(IN_O - 0.22, IN_S - 0.25);\nconst LT = new THREE.Vector2(IN_O - 0.95, SOFA_Z + 0.25);\nlampe.group.position.set(LB.x, 0.002, LB.y);\nlampe.group.rotation.y = Math.atan2(-(LT.y - LB.y), LT.x - LB.x);\nwohn.add(lampe.group);\n// Donut-Lampe (Ø 30 cm, H 11 cm) im linken Regal, mittleres Fach, mittig\nconst DM = {\n  koerper: new THREE.MeshPhysicalMaterial({ name:'donut_opal_orange', color:0xffa04a, roughness:0.6, clearcoat:0.2, clearcoatRoughness:0.5, emissive:0xff8a2a, emissiveIntensity:0 }),\n  sockel:  new THREE.MeshStandardMaterial({ name:'donut_sockel', color:0xee6a3e, roughness:0.5, emissive:0xd04a20, emissiveIntensity:0 }),\n  knopf:   new THREE.MeshStandardMaterial({ name:'donut_knopf', color:0x9a6a58, roughness:0.45 }),\n};\nconst donut = new THREE.Group(); donut.name = 'donutlampe';\n{\n  const V2 = (x,y) => new THREE.Vector2(x,y), dm = (n,g,m,y=0) => { const o = new THREE.Mesh(g,m); o.name = n; o.position.y = y; donut.add(o); };\n  const SB_R = 0.12, SB_H = 0.018, sp = [V2(0,0), V2(SB_R-0.006,0)];\n  for (let i = 0; i <= 12; i++){ const a = -Math.PI/2 + i/12*Math.PI; sp.push(V2(SB_R-0.006+Math.cos(a)*0.006, 0.006+Math.sin(a)*0.006+(i>6?(SB_H-0.012)*(i-6)/6:0))); }\n  sp.push(V2(0, SB_H));\n  dm('donut_sockel', new THREE.LatheGeometry(sp, 96), DM.sockel);\n  const R = 0.085, A = 0.065, B = 0.0475, CY = 0.0625, sg = v => Math.sign(v)*Math.pow(Math.abs(v), 0.8), kp = [V2(0,0.015)];\n  for (let i = 0; i <= 60; i++){ const t = -Math.PI/2 + i/60*1.35*Math.PI; kp.push(V2(R+A*sg(Math.cos(t)), CY+B*sg(Math.sin(t)))); }\n  kp.push(V2(0.018,0.078), V2(0.008,0.0755), V2(0,0.075));\n  dm('donut_koerper', new THREE.LatheGeometry(kp, 128), DM.koerper);\n  dm('donut_knopf', new THREE.CylinderGeometry(0.02, 0.022, 0.004, 40), DM.knopf, 0.077);\n}\ndonut.position.set(WZ_CX - 0.603, 0.002 + 0.42, IN_S - 0.135 - 0.02);\nwohn.add(donut);\n// Fernseher (43\") auf zwei Sofa-Kartons an der Westwand, gegenüber dem Sofa\n{\n  const tv = new THREE.Group(); tv.name = 'fernseher';\n  const K = new THREE.MeshStandardMaterial({ name:'karton', color:0xa9825a, roughness:0.9 });\n  const KT = new THREE.MeshStandardMaterial({ name:'karton_druck', color:0x3a2d22, roughness:0.9 });\n  const TVM = new THREE.MeshStandardMaterial({ name:'tv_gehaeuse', color:0x141416, roughness:0.45, metalness:0.2 });\n  const SCR = new THREE.MeshPhysicalMaterial({ name:'tv_bildschirm', color:0x050607, roughness:0.08, clearcoat:1, clearcoatRoughness:0.05 });\n  const FT = new THREE.MeshStandardMaterial({ name:'tv_fuss', color:0x9a9ea3, roughness:0.35, metalness:0.7 });\n  const x0 = RM_WZ[0] + 0.02, zc = SOFA_Z, KW = 1.15, KD = 0.5, KH = 0.38;\n  tv.add(box('karton_unten', K, x0, 0.002, zc - KW/2, x0 + KD, KH, zc + KW/2));\n  tv.add(box('karton_oben', K, x0 + 0.01, KH, zc - KW/2 + 0.015, x0 + KD + 0.005, 2*KH, zc + KW/2 + 0.01));\n  for (const y of [0.3, 0.3 + KH]) tv.add(box('karton_aufdruck', KT, x0 + KD + 0.004, y - 0.02, zc - 0.25, x0 + KD + 0.007, y, zc + 0.25));\n  const top = 2*KH, xb = x0 + 0.24, tw = 0.97, th = 0.57, fh = 0.07;\n  tv.add(box('tv_rahmen', TVM, xb, top + fh, zc - tw/2, xb + 0.045, top + fh + th, zc + tw/2));\n  tv.add(box('tv_bildschirm', SCR, xb + 0.045, top + fh + 0.012, zc - tw/2 + 0.012, xb + 0.047, top + fh + th - 0.012, zc + tw/2 - 0.012));\n  tv.add(box('tv_rueckseite', TVM, xb - 0.04, top + fh + 0.08, zc - 0.3, xb, top + fh + 0.45, zc + 0.3));\n  for (const s of [-1, 1]){\n    const f = box('tv_fuss', FT, -0.09, 0, -0.012, 0.09, 0.012, 0.012); f.position.set(xb + 0.02, top, zc + s*0.41); f.rotation.y = s*0.5; tv.add(f);\n    tv.add(box('tv_fuss_steg', FT, xb + 0.01, top, zc + s*0.41 - 0.01, xb + 0.03, top + fh, zc + s*0.41 + 0.01));\n  }\n  tv.add(box('receiver', TVM, xb + 0.06, top, zc - 0.28, xb + 0.2, top + 0.03, zc - 0.06));\n  tv.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\n  wohn.add(tv);\n}\nwohn.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\nhome.add(wohn);\n// ---------- Schlafzimmer: Tripod-Lampe auf dem Boden, Südwest-Ecke, Spot zur Raummitte ----------\nconst trip = buildTripod(THREE);\n{\n  const IN_W = RM_SZ[0], px = IN_W + 0.35, pz = IN_S - 0.35;\n  const cx = (RM_SZ[0] + RM_SZ[2])/2, cz = (RM_SZ[1] + RM_SZ[3])/2;\n  trip.group.position.set(px, 0.002, pz);\n  trip.group.rotation.y = Math.atan2(cx - px, cz - pz);\n  home.add(trip.group);\n}\n\n\nconst bedLed = { lights: [] };\n// ---------- Schlafzimmer: Bett (140 × 200, Kopfteil Ostwand, rechts an der Südwand) + Schminktisch ----------\n{\n  const sz = new THREE.Group(); sz.name = 'schlafzimmer_moebel';\n  const add = m => { sz.add(m); return m; };\n  const LE = new THREE.MeshStandardMaterial({ name:'bett_kunstleder', color:0xeee8dc, roughness:0.55 });\n  const SH = new THREE.MeshStandardMaterial({ name:'spannbetttuch', color:0x67696e, roughness:0.95 });\n  const DE = new THREE.MeshStandardMaterial({ name:'kuscheldecke', color:0x58585b, roughness:1 });\n  const KI = new THREE.MeshStandardMaterial({ name:'kissen', color:0xf4f3ef, roughness:0.9 });\n  const LK = new THREE.MeshPhysicalMaterial({ name:'lack_weiss_hochglanz', color:0xf6f6f4, roughness:0.15, clearcoat:0.8, clearcoatRoughness:0.1 });\n  const SP = new THREE.MeshStandardMaterial({ name:'spiegel_schminktisch', color:0xdfe5e8, roughness:0.03, metalness:1 });\n  const BU = new THREE.MeshStandardMaterial({ name:'spiegel_birne', color:0xffffff, roughness:0.3, emissive:0xfff1d8, emissiveIntensity:0.15 });\n  const E = RM_SZ[2], S = RM_SZ[3];\n  // Bett\n  const HB = 0.1, bx0 = E - HB - 2.0, bz0 = S - 1.46, bz1 = S - 0.01;\n  add(box('bett_sockel', M.plinth, bx0 + 0.06, 0, bz0 + 0.06, E - HB - 0.06, 0.06, bz1 - 0.06));\n  add(box('bett_rahmen', LE, bx0, 0.06, bz0, E - HB, 0.36, bz1));\n  add(box('bett_matratze', SH, bx0 + 0.02, 0.36, bz0 + 0.03, E - HB - 0.01, 0.56, bz1 - 0.03));\n  const RB = LE.clone(); RB.name = 'bett_einkerbung'; RB.emissive = new THREE.Color(0xffb070); RB.emissiveIntensity = 0;\n  const LEDM = new THREE.MeshStandardMaterial({ name:'bett_led', color:0xe8e4da, roughness:0.4, emissive:0xffb070, emissiveIntensity:0 });\n  const RY0 = 0.9, RY1 = 1.0, CAP = 0.06;\n  // Kopfteil mit durchgehender Einkerbung oben; LED-Streifen an der Unterseite der oberen Leiste (innen)\n  add(box('bett_kopfteil', LE, E - HB, 0.06, bz0, E - 0.002, RY0, bz1));\n  add(box('bett_einkerbung_rueckwand', RB, E - 0.035, RY0, bz0 + CAP, E - 0.002, RY1, bz1 - CAP));\n  add(box('bett_kopfteil_oben', LE, E - HB - 0.025, RY1, bz0, E - 0.002, 1.13, bz1));\n  for (const [z0, z1] of [[bz0, bz0 + CAP], [bz1 - CAP, bz1]]) add(box('bett_kopfteil_wange', LE, E - HB, RY0, z0, E - 0.002, RY1, z1));\n  add(box('bett_led_streifen', LEDM, E - HB + 0.012, RY1 - 0.007, bz0 + CAP + 0.01, E - 0.045, RY1, bz1 - CAP - 0.01));\n  bedLed.M = LEDM; bedLed.R = RB;\n  for (const f of [0.14, 0.38, 0.62, 0.86]){ const l = new THREE.PointLight(0xffb070, 0, 1.6, 2); l.name = 'bett_led_licht'; l.position.set(E - HB - 0.02, RY1 - 0.012, bz0 + (bz1 - bz0) * f); sz.add(l); bedLed.lights.push(l); }\n  bedLed.anchor = new THREE.Object3D(); bedLed.anchor.position.set(E - HB, RY0, (bz0 + bz1) / 2); sz.add(bedLed.anchor);\n  for (const y of [0.6, 0.72, 0.84]) for (let i = 0; i < 11; i++){\n    const b = new THREE.Mesh(new THREE.SphereGeometry(0.009, 10, 8), LE); b.name = 'bett_knopf';\n    b.position.set(E - HB - 0.002, y, bz0 + 0.1 + i*(bz1 - bz0 - 0.2)/10 + (y === 0.72 ? 0.06 : 0)); if (b.position.z < bz1 - 0.05) add(b);\n  }\n  const pil = add(new THREE.Mesh(new THREE.SphereGeometry(1, 32, 16), KI)); pil.name = 'kopfkissen';\n  pil.scale.set(0.2, 0.07, 0.34); pil.position.set(E - HB - 0.24, 0.6, bz0 + 0.5);\n  add(box('decke_oben', DE, bx0 + 0.05, 0.56, bz0 - 0.02, E - HB - 0.5, 0.6, bz1 - 0.02));\n  add(box('decke_seite', DE, bx0 + 0.05, 0.3, bz0 - 0.03, E - HB - 0.5, 0.6, bz0 - 0.01));\n  add(box('decke_fuss', DE, bx0 + 0.03, 0.32, bz0 - 0.02, bx0 + 0.05, 0.6, bz1 - 0.02));\n  // Schminktisch an der Ostwand zwischen Heizkörper und Bett, Schubladen links (Norden)\n  const D = 0.45, x1 = E, x0 = E - D, z0 = RM_SZ[1] + 1.0, z1 = z0 + 1.1, H = 0.76, PW = 0.4, T = 0.018;\n  add(box('schminktisch_platte', LK, x0, H - 0.025, z0, x1, H, z1));\n  add(box('schminktisch_korpus', LK, x0, 0.04, z0, x1, H - 0.025, z0 + PW));\n  add(box('schminktisch_sockel', LK, x0 + 0.02, 0, z0 + 0.02, x1, 0.04, z0 + PW - 0.02));\n  add(box('schminktisch_seite', LK, x0, 0, z1 - T, x1, H - 0.025, z1));\n  add(box('schminktisch_zarge', LK, x0, H - 0.15, z0 + PW, x1, H - 0.025, z1 - T));\n  add(box('schminktisch_rueckwand', LK, x1 - 0.015, 0.04, z0 + PW, x1, H - 0.15, z1 - T));\n  const fronts = [[0.05, 0.215], [0.22, 0.385], [0.39, 0.555], [0.56, H - 0.03]];\n  fronts.forEach(([a, b], i) => add(box('schublade_' + (i+1), LK, x0 - 0.012, a, z0 + 0.004, x0, b, z0 + PW - 0.004)));\n  add(box('schublade_mitte', LK, x0 - 0.012, H - 0.145, z0 + PW + 0.004, x0, H - 0.03, z1 - T - 0.004));\n  // Spiegel mit Glühbirnen, auf der Platte an die Wand gelehnt\n  const mz0 = z0 + 0.17, mz1 = z0 + 0.97, my0 = H, my1 = H + 0.62;\n  const mir = new THREE.Group(); mir.name = 'schminkspiegel';\n  mir.add(box('schminkspiegel_rahmen', LK, -0.035, 0, mz0, 0, my1 - my0, mz1));\n  mir.add(box('schminkspiegel_glas', SP, -0.037, 0.06, mz0 + 0.06, -0.035, my1 - my0 - 0.06, mz1 - 0.06));\n  const bulb = (y, z) => { const b = new THREE.Mesh(new THREE.SphereGeometry(0.021, 16, 12), BU); b.name = 'schminkspiegel_birne'; b.position.set(-0.045, y, z); mir.add(b); };\n  for (let i = 0; i < 8; i++) bulb(my1 - my0 - 0.03, mz0 + 0.04 + i*(mz1 - mz0 - 0.08)/7);\n  for (let i = 1; i < 5; i++){ const y = my1 - my0 - 0.03 - i*0.13; bulb(y, mz0 + 0.035); bulb(y, mz1 - 0.035); }\n  mir.position.set(x1 - 0.1, my0, 0); mir.rotation.z = -0.08; sz.add(mir);\n  sz.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\n  home.add(sz);\n}\n// ---------- Mauervorsprung Wohnzimmer (41,5 × 40 cm, Ecke Tür-/Außenwand) ----------\n{\n  const mat = Array(6).fill(M.wall); mat[2] = M.cap;\n  walls.add(box('wohnzimmer_vorsprung', mat, IN_O - 0.415, 0, RM_WZ[1], IN_O + 0.001, HI, RM_WZ[1] + 0.40, 1.5));\n}\n// ---------- Küche: Fliesenspiegel an der Wand zum Bad, ab Fensterunterkante 60 cm hoch ----------\nconst tileMat = new THREE.MeshStandardMaterial({ name:'interior_tiles', color:0xf3f2ee, roughness:0.2 });\n{\n  const x0 = RM_KU[0], z0 = 0, z1 = Z_SCH0;\n  const t = box('kueche_fliesen', tileMat, x0, WIN_B, z0, x0 + 0.008, WIN_B + 0.6, z1, 1.0);\n  // um die Ecke auf die Fensterwand, bis an die Fensterlaibung\n  const winW = KU_WIN.c - KU_WIN.w/2;\n  const t2 = box('kueche_fliesen_fensterwand', tileMat, x0 + 0.008, WIN_B, z0, winW, WIN_B + 0.6, z0 + 0.008, 1.0);\n  t.receiveShadow = t2.receiveShadow = true; home.add(t, t2);\n}\n// ---------- Heizkörper ----------\nconst radMat = new THREE.MeshStandardMaterial({ name:'heizkoerper_weiss', color:0xf4f3ef, roughness:0.4, metalness:0.1 });\nfunction makeRadiator(name, len){\n  const g = new THREE.Group(); g.name = name;\n  const y0 = 0.15, y1 = 0.75, n = Math.max(3, Math.round(len/0.05)), st = len/n;\n  for (let i = 0; i < n; i++){ const x = -len/2 + st*(i+0.5); g.add(box(name+'_glied'+i, radMat, x-st*0.38, y0, -0.035, x+st*0.38, y1, 0.035)); }\n  g.add(box(name+'_sammler_o', radMat, -len/2, y1-0.05, -0.02, len/2, y1-0.01, 0.02));\n  g.add(box(name+'_sammler_u', radMat, -len/2, y0+0.01, -0.02, len/2, y0+0.05, 0.02));\n  const v = new THREE.Mesh(new THREE.CylinderGeometry(0.018, 0.018, 0.08, 20), radMat); v.name = name+'_ventil'; v.position.set(len/2+0.03, y1-0.04, 0); g.add(v);\n  const p = new THREE.Mesh(new THREE.CylinderGeometry(0.01, 0.01, y0, 12), M.metal); p.name = name+'_rohr'; p.position.set(-len/2+0.02, y0/2, 0); g.add(p);\n  g.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\n  return g;\n}\n{\n  // Schlafzimmer: an der Mittelwand, 41–86 cm von der Türwand\n  const h1 = makeRadiator('heizkoerper_schlafzimmer', 0.45);\n  h1.position.set(RM_SZ[2] - 0.075, 0, RM_SZ[1] + 0.41 + 0.225); h1.rotation.y = Math.PI/2;\n  // Wohnzimmer: an der Türwand direkt neben der Tür, Richtung Mittelwand\n  const h2 = makeRadiator('heizkoerper_wohnzimmer', 0.48);\n  h2.position.set(WZ_DOOR.c - WZ_DOOR.w/2 - 0.02 - 0.24, 0, RM_WZ[1] + 0.075);\n  home.add(h1, h2);\n}\n\n// ---------- Bad (nach Foto): Wanne rechts, WC + Waschtisch links, Fliesen ----------\n{\n  const bad = new THREE.Group(); bad.name = 'bad';\n  const [W, N, E, SZ] = RM_BAD, TT = 0.008, SCX = X_SCH, SCZ = Z_SCH0;\n  const add = m => { bad.add(m); return m; };\n  const bx = (n, mat, ...a) => add(box(n, mat, ...a));\n  function cyl(n, mat, r, h, x, y, z, axis, r2){\n    const m = new THREE.Mesh(new THREE.CylinderGeometry(r, r2 ?? r, h, 28), mat); m.name = n; m.position.set(x, y, z);\n    if (axis === 'x') m.rotation.z = Math.PI/2; if (axis === 'z') m.rotation.x = Math.PI/2; return add(m);\n  }\n  function tileTex(px, n, base, grout, veins, seed){\n    const c = document.createElement('canvas'); c.width = c.height = px*n; const g = c.getContext('2d');\n    g.fillStyle = base; g.fillRect(0, 0, c.width, c.height);\n    const rnd = () => (seed = (seed*16807) % 2147483647) / 2147483647;\n    g.lineWidth = 1.4;\n    for (let i = 0; i < veins; i++){\n      g.strokeStyle = 'rgba(125,127,132,' + (0.05 + rnd()*0.07) + ')'; g.beginPath();\n      let x = rnd()*c.width, y = rnd()*c.height; g.moveTo(x, y);\n      for (let k = 0; k < 4; k++){ const cx = x + (rnd()-.5)*px, cy = y + (rnd()-.5)*px; x += (rnd()-.5)*px*1.3; y += (rnd()-.5)*px*1.3; g.quadraticCurveTo(cx, cy, x, y); }\n      g.stroke();\n    }\n    g.fillStyle = grout; const gw = Math.max(3, px/32);\n    for (let i = 0; i < n; i++){ g.fillRect(i*px, 0, gw, c.height); g.fillRect(0, i*px, c.width, gw); }\n    const t = new THREE.CanvasTexture(c); t.wrapS = t.wrapT = THREE.RepeatWrapping; t.colorSpace = THREE.SRGBColorSpace; t.anisotropy = 8; return t;\n  }\n  const BM = {\n    wand:   new THREE.MeshStandardMaterial({ name:'bad_wandfliesen', map: tileTex(128, 4, '#f3f3f1', '#c6c6c2', 46, 11), roughness:0.16 }),\n    boden:  new THREE.MeshStandardMaterial({ name:'bad_bodenfliesen', map: tileTex(128, 4, '#efeeeb', '#a6a5a0', 34, 29), roughness:0.32 }),\n    email:  new THREE.MeshPhysicalMaterial({ name:'sanitaer_email', color:0xfbfbfa, roughness:0.1, clearcoat:1, clearcoatRoughness:0.06 }),\n    chrom:  new THREE.MeshStandardMaterial({ name:'chrom', color:0xe6e8ea, roughness:0.08, metalness:1 }),\n    spiegel:new THREE.MeshStandardMaterial({ name:'spiegel', color:0xe2e8ec, roughness:0.02, metalness:1 }),\n    glas:   new THREE.MeshStandardMaterial({ name:'glasablage', color:0xcfe6e0, roughness:0.05, transparent:true, opacity:0.45 }),\n    dekor:  new THREE.MeshStandardMaterial({ name:'dekorfliese', color:0x9fb0c2, roughness:0.2 }),\n    plast:  new THREE.MeshStandardMaterial({ name:'wc_sitz', color:0xf7f7f5, roughness:0.3 }),\n  };\n  const emailIn = BM.email.clone(); emailIn.name = 'sanitaer_email_innen'; emailIn.side = THREE.BackSide;\n  const emailDS = BM.email.clone(); emailDS.name = 'sanitaer_email_ds'; emailDS.side = THREE.DoubleSide;\n  // Milchglas im Badfenster\n  const fg = windows.getObjectByName('fenster_bad_glas');\n  if (fg) fg.material = new THREE.MeshStandardMaterial({ name:'milchglas', color:0xf2f5f5, roughness:0.7, transparent:true, opacity:0.85 });\n\n  // Boden + Wandfliesen (halbhoch 1,25 m, um die Wanne 2,05 m)\n  const HT = 1.25, FT = 2.05;\n  const TW = 0.78, TL = 1.75, LEDGE = 0.2, TX0 = E - TW, TZ1 = N + LEDGE + TL;\n  const wxc = 2.25, wl = wxc - 0.4, wr = wxc + 0.4, dxc = BAD_DOOR.c, DW = BAD_DOOR.w;\n  // Vorwand an der Fensterwand: von der Westwand bis ans Fenster, 15 cm vorgezogen\n  const VD = 0.15;\n  { const vm = Array(6).fill(M.wall); vm[2] = M.cap; walls.add(box('bad_vorwand', vm, W, 0, N, wl, HI, N + VD, 1.5)); }\n  bx('bad_boden', BM.boden, W, 0, N, E, 0.008, SZ, 0.8);\n  bx('bad_fliesen_west', BM.wand, W, 0, N + VD + TT, W + TT, HT, SZ, 0.6);\n  bx('bad_fliesen_vorwand', BM.wand, W, 0, N + VD, wl, HT, N + VD + TT, 0.6);\n  bx('bad_fliesen_vorwand_seite', BM.wand, wl - 0.001, 0, N, wl + TT, HT, N + VD + TT, 0.6);\n  bx('bad_fliesen_nord_2', BM.wand, wl, 0, N, wr, WIN_B - 0.03, N + TT, 0.6);\n  bx('bad_fliesen_nord_3', BM.wand, wr, 0, N, E - TT, FT, N + TT, 0.6);\n  bx('bad_fliesen_ost_1', BM.wand, E - TT, 0, N, E, FT, TZ1, 0.6);\n  bx('bad_fliesen_ost_2', BM.wand, E - TT, 0, TZ1, E, HT, SCZ, 0.6);\n  bx('bad_fliesen_schacht_n', BM.wand, SCX - TT, 0, SCZ - TT, E - TT, HT, SCZ, 0.6);\n  bx('bad_fliesen_schacht_w', BM.wand, SCX - TT, 0, SCZ, SCX, HT, SZ, 0.6);\n  bx('bad_fliesen_sued_1', BM.wand, W + TT, 0, SZ - TT, dxc - DW/2, HT, SZ, 0.6);\n  bx('bad_fliesen_sued_2', BM.wand, dxc + DW/2, 0, SZ - TT, SCX - TT, HT, SZ, 0.6);\n  for (const [y, z] of [[1.15, N + 0.75], [1.72, N + 0.55]]){\n    const d = bx('bad_dekorfliese', BM.dekor, -0.001, -0.04, -0.04, 0.001, 0.04, 0.04);\n    d.rotation.x = Math.PI/4; d.position.set(E - TT - 0.001, y, z);\n  }\n\n  // Badewanne, eingefliest, mit Ablage am Kopfende\n  bx('wanne_ablage', BM.wand, TX0, 0.008, N + TT, E - TT, 0.6, N + LEDGE, 0.6);\n  bx('wanne_schuerze', BM.wand, TX0, 0.008, N + LEDGE, TX0 + 0.03, 0.565, TZ1, 0.6);\n  bx('wanne_schuerze_ende', BM.wand, TX0, 0.008, TZ1 - 0.03, E - TT, 0.565, TZ1, 0.6);\n  function rr(p, w, d, r){ const x = -w/2, y = -d/2;\n    p.moveTo(x + r, y); p.lineTo(x + w - r, y); p.quadraticCurveTo(x + w, y, x + w, y + r); p.lineTo(x + w, y + d - r);\n    p.quadraticCurveTo(x + w, y + d, x + w - r, y + d); p.lineTo(x + r, y + d); p.quadraticCurveTo(x, y + d, x, y + d - r);\n    p.lineTo(x, y + r); p.quadraticCurveTo(x, y, x + r, y); return p; }\n  const tcx = E - TT/2 - TW/2 + TT/2, tcz = N + LEDGE + TL/2, IW = TW - 0.14, IL = TL - 0.18, IR = 0.22;\n  const rimS = rr(new THREE.Shape(), TW - TT, TL, 0.02); rimS.holes.push(rr(new THREE.Path(), IW, IL, IR));\n  const rimG = new THREE.ExtrudeGeometry(rimS, { depth:0.035, bevelEnabled:false, curveSegments:16 });\n  rimG.rotateX(-Math.PI/2); rimG.translate(tcx, 0.565, tcz);\n  add(new THREE.Mesh(rimG, BM.email)).name = 'wanne_rand';\n  const basG = new THREE.ExtrudeGeometry(rr(new THREE.Shape(), IW, IL, IR), { depth:0.41, bevelEnabled:false, curveSegments:16 });\n  basG.rotateX(-Math.PI/2); basG.translate(tcx, 0.16, tcz);\n  add(new THREE.Mesh(basG, emailIn)).name = 'wanne_innen';\n  const mz0 = TZ1 - 0.35;\n  cyl('wanne_ablauf', BM.chrom, 0.024, 0.004, tcx, 0.163, mz0 - 0.05);\n  // Wannenarmatur an der Ostwand\n  cyl('armatur_koerper', BM.chrom, 0.024, 0.2, E - 0.075, 0.8, mz0, 'z');\n  for (const s of [-1, 1]){\n    cyl('armatur_anschluss', BM.chrom, 0.01, 0.075, E - 0.04, 0.8, mz0 + s*0.08, 'x');\n    cyl('armatur_rosette', BM.chrom, 0.03, 0.008, E - TT - 0.004, 0.8, mz0 + s*0.08, 'x');\n  }\n  cyl('armatur_auslauf', BM.chrom, 0.012, 0.11, E - 0.135, 0.775, mz0, 'x');\n  bx('armatur_hebel', BM.chrom, E - 0.085, 0.82, mz0 - 0.012, E - 0.03, 0.835, mz0 + 0.012);\n  // Duschstange + Handbrause + Schlauch\n  const rz = TZ1 - 0.85, rx = E - 0.045;\n  cyl('duschstange', BM.chrom, 0.012, 0.95, rx, 1.6, rz);\n  for (const y of [1.13, 2.07]){ cyl('duschstange_halter', BM.chrom, 0.01, 0.045, E - 0.022, y, rz, 'x'); cyl('duschstange_rosette', BM.chrom, 0.022, 0.01, E - TT - 0.005, y, rz, 'x'); }\n  bx('duschstange_schieber', BM.chrom, rx - 0.035, 1.68, rz - 0.022, rx + 0.02, 1.76, rz + 0.022);\n  const brause = new THREE.Group(); brause.name = 'handbrause'; brause.position.set(rx - 0.06, 1.72, rz); brause.rotation.z = 0.5;\n  { const h = new THREE.Mesh(new THREE.CylinderGeometry(0.013, 0.011, 0.2, 20), BM.chrom); h.name = 'handbrause_griff'; brause.add(h);\n    const k = new THREE.Mesh(new THREE.CylinderGeometry(0.045, 0.03, 0.025, 32), BM.chrom); k.name = 'handbrause_kopf'; k.position.y = 0.11; k.rotation.z = Math.PI/2 - 0.3; brause.add(k); }\n  add(brause);\n  const hb0 = new THREE.Vector3(rx - 0.06 + 0.1*Math.sin(0.5), 1.72 - 0.1*Math.cos(0.5), rz);\n  const hose = new THREE.CatmullRomCurve3([hb0, new THREE.Vector3(E - 0.09, 1.2, rz + 0.08), new THREE.Vector3(E - 0.2, 0.7, (rz + mz0)/2 + 0.05), new THREE.Vector3(E - 0.12, 0.66, mz0 - 0.02), new THREE.Vector3(E - 0.085, 0.77, mz0 - 0.03)]);\n  add(new THREE.Mesh(new THREE.TubeGeometry(hose, 80, 0.007, 8), BM.chrom)).name = 'brauseschlauch';\n  // Haltegriff\n  const gz = TZ1 - 0.6;\n  cyl('haltegriff', BM.chrom, 0.013, 0.36, E - 0.065, 1.12, gz);\n  for (const y of [0.96, 1.28]) cyl('haltegriff_stuetze', BM.chrom, 0.012, 0.06, E - 0.035, y, gz, 'x');\n  // Vorhangstange oben\n  cyl('vorhangstange', BM.chrom, 0.01, TL - 0.2, E - 0.09, 2.15, N + LEDGE + TL/2 - 0.1, 'z');\n  cyl('vorhangstange_halter', BM.chrom, 0.009, 0.09, E - 0.045, 2.15, N + LEDGE + 0.05, 'x');\n\n  // WC an der Westwand (Blick zur Wanne), Aufputz-Spülkasten\n  const wc = new THREE.Group(); wc.name = 'wc'; wc.position.set(W + TT, 0, N + VD + 0.45); wc.rotation.y = Math.PI/2;\n  { const wa = m => { wc.add(m); return m; };\n    wa(box('wc_sockel_hinten', BM.email, -0.13, 0.008, 0, 0.13, 0.38, 0.22));\n    const p = new THREE.Mesh(new THREE.CylinderGeometry(0.15, 0.115, 0.32, 40), BM.email); p.name = 'wc_fuss'; p.scale.z = 1.3; p.position.set(0, 0.168, 0.37); wa(p);\n    const b = new THREE.Mesh(new THREE.CylinderGeometry(0.185, 0.15, 0.08, 48), BM.email); b.name = 'wc_becken'; b.scale.z = 1.3; b.position.set(0, 0.365, 0.41); wa(b);\n    const s = new THREE.Mesh(new THREE.CylinderGeometry(0.185, 0.185, 0.02, 48), BM.plast); s.name = 'wc_sitz'; s.scale.z = 1.3; s.position.set(0, 0.415, 0.41); wa(s);\n    const d = new THREE.Mesh(new THREE.CylinderGeometry(0.178, 0.178, 0.022, 48), BM.plast); d.name = 'wc_deckel'; d.scale.z = 1.28; d.position.set(0, 0.436, 0.41); wa(d);\n    wa(box('wc_scharnier', BM.plast, -0.1, 0.405, 0.15, 0.1, 0.44, 0.2));\n    wa(box('wc_spuelkasten', BM.email, -0.2, 0.8, 0, 0.2, 1.2, 0.15));\n    const t = new THREE.Mesh(new THREE.CylinderGeometry(0.02, 0.02, 0.02, 28), BM.email); t.name = 'wc_spueltaste'; t.position.set(-0.12, 1.21, 0.09); wa(t);\n    const r = new THREE.Mesh(new THREE.CylinderGeometry(0.025, 0.025, 0.4, 28), BM.email); r.name = 'wc_spuelrohr'; r.position.set(0, 0.6, 0.08); wa(r); }\n  add(wc);\n  // Wasserzähler + Ventil an der Vorwand, Papierhalter unter dem Fenster\n  cyl('bad_wasserzaehler', BM.chrom, 0.055, 0.03, wl - 0.13, 0.98, N + VD + TT + 0.015, 'z');\n  cyl('bad_wasserzaehler_glas', BM.plast, 0.035, 0.034, wl - 0.13, 0.98, N + VD + TT + 0.017, 'z');\n  cyl('bad_ventil', BM.chrom, 0.028, 0.05, wl - 0.13, 1.2, N + VD + TT + 0.025, 'z');\n  bx('papierhalter', BM.chrom, wxc - 0.02, 0.62, N + TT, wxc + 0.12, 0.7, N + 0.08);\n\n  // Waschtisch an der Westwand, Spiegel + Glasablagen darüber\n  const bz = N + 1.35, BR = 0.3, SX = 0.87, RY = 0.85, bcx = W + 0.2;\n  { const o = new THREE.Mesh(new THREE.CylinderGeometry(BR, 0.2, 0.17, 48, 1, true), emailDS); o.name = 'waschbecken_aussen'; o.scale.x = SX; o.position.set(bcx, RY - 0.085, bz); add(o);\n    const f = new THREE.Mesh(new THREE.CircleGeometry(0.2, 48), BM.email); f.name = 'waschbecken_unten'; f.rotation.x = Math.PI/2; f.scale.x = SX; f.position.set(bcx, RY - 0.17, bz); add(f);\n    const r = new THREE.Mesh(new THREE.RingGeometry(0.235, BR, 48), BM.email); r.name = 'waschbecken_rand'; r.rotation.x = -Math.PI/2; r.scale.x = SX; r.position.set(bcx, RY, bz); add(r);\n    const i = new THREE.Mesh(new THREE.SphereGeometry(0.235, 48, 16, 0, Math.PI*2, Math.PI/2, Math.PI/2), emailDS); i.name = 'waschbecken_innen'; i.scale.set(SX, 0.55, 1); i.position.set(bcx, RY, bz); add(i); }\n  cyl('waschtisch_armatur', BM.chrom, 0.022, 0.12, W + 0.075, RY + 0.06, bz);\n  { const s = cyl('waschtisch_auslauf', BM.chrom, 0.011, 0.13, W + 0.13, RY + 0.1, bz, 'x'); s.rotation.z = Math.PI/2 + 0.25; }\n  bx('waschtisch_hebel', BM.chrom, W + 0.04, RY + 0.12, bz - 0.012, W + 0.1, RY + 0.135, bz + 0.012);\n  cyl('siphon', BM.chrom, 0.02, 0.2, bcx, 0.58, bz);\n  cyl('siphon_rohr', BM.chrom, 0.018, 0.2, W + 0.1, 0.48, bz, 'x');\n  cyl('siphon_rosette', BM.chrom, 0.035, 0.01, W + TT + 0.005, 0.48, bz, 'x');\n  bx('spiegel', BM.spiegel, W + TT, 1.34, bz - 0.3, W + TT + 0.006, 2.0, bz + 0.3);\n  for (const y of [1.3, 1.05]){\n    bx('glasablage', BM.glas, W + TT, y, bz - 0.3, W + 0.14, y + 0.008, bz + 0.3);\n    for (const s of [-1, 1]) bx('glasablage_halter', BM.chrom, W + TT, y - 0.012, bz + s*0.3 - 0.012, W + 0.06, y + 0.016, bz + s*0.3 + 0.012);\n  }\n\n  bad.traverse(o => { if (o.isMesh){ o.castShadow = true; o.receiveShadow = true; } });\n  bad.getObjectByName('bad_boden').castShadow = false;\n  home.add(bad);\n}\n\n\nstage.setObject(home);\n\n// ---------- Schatten: enger Frustum, 4096er Map, harter PCF → scharf & ohne Flackern ----------\nconst renderer = stage._renderer, scene = stage._scene, key = stage._key;\nrenderer.shadowMap.type = THREE.PCFShadowMap;\nconst hb = new THREE.Box3().setFromObject(home), hc = hb.getCenter(new THREE.Vector3()), hs = hb.getSize(new THREE.Vector3());\nconst sunDir = new THREE.Vector3(4, 7, 5).normalize();\nkey.position.copy(hc).addScaledVector(sunDir, 30);\nkey.target.position.copy(hc); scene.add(key.target);\nconst half = Math.max(hs.x, hs.z) * 0.62;\nObject.assign(key.shadow.camera, { left:-half, right:half, top:half, bottom:-half, near:1, far:60 });\nkey.shadow.camera.updateProjectionMatrix();\nkey.shadow.mapSize.set(2048, 2048);\nkey.shadow.bias = -0.0004; key.shadow.normalBias = 0.015;\nif (key.shadow.map){ key.shadow.map.dispose(); key.shadow.map = null; }\nrenderer.toneMapping = THREE.ACESFilmicToneMapping;\nif (stage._ground) stage._ground.visible = false;\nconst hemi = scene.children.find(o => o.isHemisphereLight), hemiBase = hemi ? hemi.intensity : 0;\nconst fillL = scene.children.find(o => o.isDirectionalLight && o !== key), fillBase = fillL ? fillL.intensity : 0;\nconst ENV = 0.9;\nlet envK = 1, hemiK = 1, fillK = 1, expK = 1;\n// Innenraum: Himmels-/Fülllicht dringt nicht durch die Decke → nur noch Sonne + Umgebung durch die Fenster\nfunction applyInterior(o){\n  if (hemi) hemi.intensity = hemiBase * hemiK * (1 - 0.85*o);\n  if (fillL) fillL.intensity = fillBase * fillK * (1 - o);\n  scene.environmentIntensity = ENV * envK * (1 - 0.7*o);\n  renderer.toneMappingExposure = (1 + 0.45*o) * expK;\n}\n\n// ---------- Decke (blendet ein, sobald man in einem Raum steht) ----------\nconst ceilMat = new THREE.MeshStandardMaterial({ name:'decke', color:0xf4f2ee, roughness:0.95, transparent:true, opacity:0, depthWrite:false });\nconst ceiling = new THREE.Group(); ceiling.name = 'decke';\nceiling.add(box('decke_nord', ceilMat, X_FL - TE, H, -TE, X_E + TE, H+0.04, ZST), box('decke_sued', ceilMat, -TE, H, ZST, X_E + TE, H+0.04, Z_S + TE));\nceiling.traverse(o => { if (o.isMesh){ o.receiveShadow = true; o.castShadow = true; } }); ceiling.visible = false;\nhome.add(ceiling);\nfunction setCeil(o){\n  ceilMat.opacity = o;\n  if (ceiling.visible !== (o > 0.001)){ ceiling.visible = o > 0.001; ptDirty = true; }\n  const solid = o >= 0.999;\n  if (ceilMat.transparent === solid){ ceilMat.transparent = !solid; ceilMat.depthWrite = solid; ceilMat.needsUpdate = true; }\n  if (!ptOn) applyInterior(o);\n}\n\n// ---------- Bogenlampe: Licht an/aus ----------\nhome.updateMatrixWorld(true);\nconst bulb = lampe.group.getObjectByName('leuchtmittel');\nconst bp = bulb.getWorldPosition(new THREE.Vector3());\nconst lampSpot = new THREE.SpotLight(0xffd6a0, 0, 0, 1.0, 0.6, 2);\nlampSpot.position.copy(bp).add(new THREE.Vector3(0, -0.035, 0));\nlampSpot.target.position.set(bp.x, 0, bp.z);\nlampSpot.castShadow = true;\nlampSpot.shadow.mapSize.set(1024, 1024);\nlampSpot.shadow.bias = -0.0005; lampSpot.shadow.normalBias = 0.02;\nlampSpot.shadow.camera.near = 0.05; lampSpot.shadow.camera.far = 8;\nconst lampFill = new THREE.PointLight(0xffd6a0, 0, 7, 2);\nlampFill.position.copy(bp);\nscene.add(lampSpot, lampSpot.target, lampFill);\nconst schirm = lampe.group.getObjectByName('schirm').material;\nschirm.emissive = new THREE.Color(0xffe2b8);\nconst lampBtn = document.getElementById('lamp');\nlet lampOn = false, lampLvl = 0, lampAnim = 0;\nlet rasterEnv = null, ptEnv = null;\nlet tracer = null, ptOn = false, ptDirty = true, inRoom = false, stillSince = 0;\nconst LAMP_KEY = 'wohnung-bogenlampe-farbe';\nlet lampK = 1;\nconst lampSw = document.getElementById('lampSw');\nfunction setLampColor(hex){\n  const c = new THREE.Color(hex), s = c.clone().lerp(new THREE.Color(0xffffff), 0.3);\n  lampSpot.color.copy(c); lampFill.color.copy(c);\n  if (bulb.material.emissive) bulb.material.emissive.copy(c);\n  schirm.emissive.copy(s);\n  try { localStorage.setItem(LAMP_KEY, hex); } catch(e){}\n  document.querySelector('#lamp i').style.cssText = lampOn ? `background:${hex};box-shadow:0 0 10px 3px ${hex}99` : '';\n  if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); }\n}\n// ---------- Licht-Picker: Hell (Lichtton + Helligkeit) oder Farbe (Farbkreis) ----------\nconst K_COLD = 8000, K_WARM = 2000;\nfunction kelvinHex(k){\n  const t = k/100; let r, g, b;\n  if (t <= 66){ r = 255; g = 99.4708025861*Math.log(t) - 161.1195681661; b = t <= 19 ? 0 : 138.5177312231*Math.log(t-10) - 305.0447927307; }\n  else { r = 329.698727446*Math.pow(t-60, -0.1332047592); g = 288.1221695283*Math.pow(t-60, -0.0755148492); b = 255; }\n  const c = v => Math.round(Math.max(0, Math.min(255, v))).toString(16).padStart(2, '0');\n  return '#' + c(r) + c(g) + c(b);\n}\nconst warmK = w => Math.round(K_COLD - w/100*(K_COLD - K_WARM));\nfunction hsvRGB(h, s, v){ const f = n => { const k = (n + h/60) % 6; return v - v*s*Math.max(0, Math.min(k, 4-k, 1)); }; return [f(5), f(3), f(1)]; }\nconst rgbHex = a => '#' + a.map(x => Math.round(x*255).toString(16).padStart(2, '0')).join('');\nfunction makePicker(sw, key, def, dimIn, onChange){\n  let st = { mode: 'white', warm: 70, h: 30, s: 0.6, ...def };\n  try { Object.assign(st, JSON.parse(localStorage.getItem(key) || 'null') || {}); } catch(e){}\n  const pop = document.createElement('div'); pop.className = 'lpick';\n  pop.innerHTML = '<div class=\"lp-seg\"><button data-m=\"white\">Hell<\u002Fbutton><button data-m=\"color\">Farbe<\u002Fbutton><\u002Fdiv>'\n    + '<div class=\"lp-row lp-w\"><div><span>Lichtton<\u002Fspan><output class=\"lp-kv\"><\u002Foutput><\u002Fdiv><input class=\"lp-temp\" type=\"range\" min=\"0\" max=\"100\" step=\"1\"><small><span>Steril<\u002Fspan><span>Warm<\u002Fspan><\u002Fsmall><\u002Fdiv>'\n    + '<div class=\"lp-c\"><div class=\"lp-wheel\"><canvas width=\"360\" height=\"360\"><\u002Fcanvas><i><\u002Fi><\u002Fdiv><\u002Fdiv>'\n    + '<div class=\"lp-row\"><div><span>Helligkeit<\u002Fspan><output class=\"lp-bv\"><\u002Foutput><\u002Fdiv><input class=\"lp-dim\" type=\"range\" min=\"10\" max=\"200\" step=\"5\"><\u002Fdiv><button class=\"lp-done\">Fertig<\u002Fbutton>';\n  document.body.appendChild(pop);\n  const $ = s => pop.querySelector(s), temp = $('.lp-temp'), bri = $('.lp-dim'), bv = $('.lp-bv'), dot = $('.lp-wheel i'), wheel = $('.lp-wheel');\n  temp.style.background = `linear-gradient(90deg,${kelvinHex(K_COLD)},${kelvinHex(4500)},${kelvinHex(3000)},${kelvinHex(K_WARM)})`;\n  const cv = $('canvas'), ctx = cv.getContext('2d'), img = ctx.createImageData(360, 360), R = 180;\n  for (let y = 0; y < 360; y++) for (let x = 0; x < 360; x++){\n    const dx = x + .5 - R, dy = y + .5 - R, d = Math.hypot(dx, dy) / R, i = (y*360 + x)*4;\n    const rgb = hsvRGB((Math.atan2(dy, dx)*180/Math.PI + 360) % 360, 1, 1);\n    img.data[i] = rgb[0]*255; img.data[i+1] = rgb[1]*255; img.data[i+2] = rgb[2]*255;\n    img.data[i+3] = 255 * Math.max(0, Math.min(1, (1 - d) * R, (d - 0.72) * R));\n  }\n  ctx.putImageData(img, 0, 0);\n  const hex = () => st.mode === 'white' ? kelvinHex(warmK(st.warm)) : rgbHex(hsvRGB(st.h, 1, 1));\n  function update(fire = true){\n    pop.querySelectorAll('.lp-seg button').forEach(b => b.classList.toggle('on', b.dataset.m === st.mode));\n    $('.lp-w').style.display = st.mode === 'white' ? '' : 'none';\n    $('.lp-c').style.display = st.mode === 'color' ? '' : 'none';\n    temp.value = st.warm; $('.lp-kv').textContent = warmK(st.warm) + ' K';\n    const a = st.h*Math.PI/180;\n    dot.style.left = (90 + Math.cos(a)*77) + 'px'; dot.style.top = (90 + Math.sin(a)*77) + 'px';\n    const h = hex(); dot.style.background = h; sw.style.background = h;\n    try { localStorage.setItem(key, JSON.stringify(st)); } catch(e){}\n    if (fire) onChange(h);\n  }\n  pop.querySelectorAll('.lp-seg button').forEach(b => b.onclick = () => { st.mode = b.dataset.m; update(); });\n  temp.oninput = () => { st.warm = +temp.value; update(); };\n  const pick = e => { const r = wheel.getBoundingClientRect(), dx = e.clientX - r.left - 90, dy = e.clientY - r.top - 90;\n    st.h = (Math.atan2(dy, dx)*180/Math.PI + 360) % 360; update(); };\n  wheel.onpointerdown = e => { const r = wheel.getBoundingClientRect(), d = Math.hypot(e.clientX - r.left - 90, e.clientY - r.top - 90);\n    if (d < 58 || d > 94) return; wheel.setPointerCapture(e.pointerId); pick(e); };\n  wheel.onpointermove = e => { if (wheel.hasPointerCapture(e.pointerId)) pick(e); };\n  const syncBri = () => { bri.value = dimIn.value; bv.textContent = dimIn.value + '%'; };\n  bri.oninput = () => { dimIn.value = bri.value; dimIn.oninput(); syncBri(); };\n  dimIn.addEventListener('input', syncBri);\n  const place = () => { pop.style.left = '18px'; pop.style.top = '50%'; pop.style.transform = 'translateY(-50%)'; };\n  sw.onclick = e => { e.preventDefault(); e.stopPropagation(); const o = !pop.classList.contains('open');\n    document.querySelectorAll('.lpick.open').forEach(p => p.classList.remove('open'));\n    if (o){ syncBri(); place(); pop.classList.add('open'); }\n    document.body.classList.toggle('lpfocus', o);\n    dispatchEvent(new CustomEvent('lpick', { detail: { key, open: o } })); };\n  $('.lp-done').onclick = () => { pop.classList.remove('open'); document.body.classList.remove('lpfocus'); dispatchEvent(new CustomEvent('lpick', { detail: { key, open: false } })); };\n  document.addEventListener('pointerdown', e => { if (pop.classList.contains('open') && !pop.contains(e.target) && !sw.contains(e.target)){ pop.classList.remove('open'); document.body.classList.remove('lpfocus'); dispatchEvent(new CustomEvent('lpick', { detail: { key, open: false } })); } });\n  addEventListener('resize', () => pop.classList.contains('open') && place());\n  update();\n  return pop;\n}\n\nlet lampCol = localStorage.getItem(LAMP_KEY) || '#ffd6a0';\nlampSw.innerHTML = '';\nconst colIn = document.createElement('button'); colIn.className = 'lp-sw'; colIn.title = 'Licht einstellen';\nlampSw.appendChild(colIn);\nconst dimIn = document.querySelector('#lampDim input'), dimOut = document.querySelector('#lampDim output');\ndimIn.oninput = () => { lampK = dimIn.value / 100; dimOut.textContent = dimIn.value + '%'; applyLamp(lampLvl); if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); } };\nfunction applyLamp(v){\n  v *= lampK;\n  lampSpot.intensity = 9 * v;\n  lampFill.intensity = 2.2 * v;\n  bulb.material.emissiveIntensity = 0.2 + 5 * v;\n  schirm.emissiveIntensity = 0.55 * v;\n}\napplyLamp(0);\nmakePicker(colIn, LAMP_KEY + '-cfg', { mode: 'white', warm: 75 }, dimIn, h => { lampCol = h; setLampColor(h); });\nsetLampColor(lampCol);\ndocument.getElementById('lampT').onclick = () => {\n  lampOn = !lampOn;\n  lampBtn.classList.toggle('on', lampOn);\n  lampBtn.querySelector('span').textContent = lampOn ? 'Bogenlampe aus' : 'Bogenlampe an';\n  setLampColor(lampCol);\n  const id = ++lampAnim, from = lampLvl, to = lampOn ? 1 : 0, t0 = performance.now();\n  (function step(now){\n    if (id !== lampAnim) return;\n    const t = Math.min(1, (now - t0) / 450);\n    lampLvl = from + (to - from) * (1 - Math.pow(1 - t, 3));\n    applyLamp(lampLvl);\n    if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); }\n    if (t < 1) requestAnimationFrame(step);\n  })(t0);\n};\n\n// ---------- Donut-Lampe: nur an/aus ----------\nconst donutLight = new THREE.PointLight(0xffa050, 0, 4.5, 2);\ndonutLight.position.copy(donut.getWorldPosition(new THREE.Vector3())).add(new THREE.Vector3(0, 0.13, 0));\nscene.add(donutLight);\nconst donutBtn = document.getElementById('lampD');\ndonutBtn.onclick = () => {\n  const on = donutBtn.getAttribute('aria-pressed') !== 'true';\n  donutBtn.setAttribute('aria-pressed', on); donutBtn.classList.toggle('on', on);\n  donutBtn.querySelector('span').textContent = on ? 'Donut-Lampe aus' : 'Donut-Lampe an';\n  DM.koerper.emissiveIntensity = on ? 2.2 : 0;\n  DM.sockel.emissiveIntensity = on ? 0.6 : 0;\n  donutLight.intensity = on ? 2.6 : 0;\n  if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); }\n};\n\n// ---------- Fernseher: an/aus per Fernbedienung ----------\n{\n  const scr = home.getObjectByName('fernseher').getObjectByName('tv_bildschirm');\n  const cv = document.createElement('canvas'); cv.width = 1024; cv.height = 600;\n  const c = cv.getContext('2d');\n  let g = c.createLinearGradient(0, 0, 1024, 600);\n  g.addColorStop(0, '#0b1e3a'); g.addColorStop(0.55, '#1d4f7a'); g.addColorStop(1, '#e08a4a');\n  c.fillStyle = g; c.fillRect(0, 0, 1024, 600);\n  g = c.createRadialGradient(760, 380, 10, 760, 380, 320);\n  g.addColorStop(0, 'rgba(255,210,150,.9)'); g.addColorStop(1, 'rgba(255,210,150,0)');\n  c.fillStyle = g; c.fillRect(0, 0, 1024, 600);\n  c.fillStyle = '#081322'; c.beginPath(); c.moveTo(0, 600); c.lineTo(0, 430); c.lineTo(220, 360); c.lineTo(420, 450); c.lineTo(640, 380); c.lineTo(1024, 470); c.lineTo(1024, 600); c.fill();\n  c.fillStyle = 'rgba(255,255,255,.92)'; c.font = '500 64px Helvetica, Arial, sans-serif'; c.fillText('20:15', 70, 120);\n  c.font = '400 28px Helvetica, Arial, sans-serif'; c.fillStyle = 'rgba(255,255,255,.7)'; c.fillText('Guten Abend', 72, 165);\n  const tex = new THREE.CanvasTexture(cv); tex.colorSpace = THREE.SRGBColorSpace;\n  const M = scr.material;\n  const tvLight = new THREE.PointLight(0x9ab8ff, 0, 3.2, 2);\n  const sb = new THREE.Box3().setFromObject(scr), sc = sb.getCenter(new THREE.Vector3()), ss = sb.getSize(new THREE.Vector3());\n  tvLight.position.copy(sc).add(new THREE.Vector3(0.35, -0.45, 0.6));\n  scene.add(tvLight);\n  const btn = document.getElementById('tvB');\n  let lvl = 0, anim = 0;\n  const apply = () => { M.emissiveIntensity = 1.6 * lvl; tvLight.intensity = 1.4 * lvl; if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); } };\n  const bar = document.getElementById('tvBar'), ui = document.getElementById('tvUI');\n  let saved = null, tvAnim = 0;\n  const tween = (pos, tgt, ms, done) => {\n    const id = ++tvAnim, p0 = cam.position.clone(), q0 = ctl.target.clone(), t0 = performance.now();\n    const ease = t => t < 0.5 ? 4*t*t*t : 1 - Math.pow(-2*t+2, 3)/2;\n    (function step(now){\n      if (id !== tvAnim) return;\n      const t = Math.min(1, (now - t0) / ms), e = ease(t);\n      cam.position.lerpVectors(p0, pos, e); ctl.target.lerpVectors(q0, tgt, e); cam.lookAt(ctl.target);\n      if (t < 1) requestAnimationFrame(step); else done && done();\n    })(t0);\n  };\n  const enter = () => {\n    if (saved) return;\n    saved = { pos: cam.position.clone(), tgt: ctl.target.clone(), en: ctl.enabled };\n    ctl.enabled = false; window.__tvLock = true;\n    const th = Math.tan(THREE.MathUtils.degToRad(cam.fov) / 2);\n    const d = Math.max(ss.y / 2 / th, ss.z / 2 / (th * cam.aspect)) * 1.18;\n    document.body.classList.add('tvfocus');\n    tween(new THREE.Vector3(sc.x + d, sc.y - 0.045, sc.z), new THREE.Vector3(sc.x, sc.y - 0.045, sc.z), 1600, () => { bar.classList.add('show'); ui.classList.add('show'); });\n  };\n  const leave = () => {\n    if (!saved) return;\n    const s = saved; saved = null;\n    bar.classList.remove('show'); ui.classList.remove('show'); document.body.classList.remove('tvfocus');\n    tween(s.pos, s.tgt, 1200, () => { window.__tvLock = false; ctl.enabled = s.en; });\n  };\n  document.getElementById('tvBack').onclick = leave;\n  document.getElementById('tvOff').onclick = () => { leave(); power(false); };\n  addEventListener('keydown', e => { if (e.key === 'Escape') leave(); });\n  addEventListener('resize', () => { if (saved && bar.classList.contains('show')){ const th = Math.tan(THREE.MathUtils.degToRad(cam.fov) / 2); const d = Math.max(ss.y / 2 / th, ss.z / 2 / (th * cam.aspect)) * 1.18; cam.position.set(sc.x + d, sc.y - 0.045, sc.z); } });\n  const power = on => {\n    btn.setAttribute('aria-pressed', on); btn.classList.toggle('on', on);\n    btn.querySelector('span').textContent = on ? 'Fernbedienung' : 'Fernseher an';\n    if (!on) ui.classList.remove('show');\n    if (on && !M.emissiveMap){ M.emissive = new THREE.Color(0xffffff); M.emissiveMap = tex; M.needsUpdate = true; }\n    const id = ++anim, from = lvl, to = on ? 1 : 0, t0 = performance.now();\n    (function step(now){\n      if (id !== anim) return;\n      const t = Math.min(1, (now - t0) / (on ? 600 : 250));\n      lvl = from + (to - from) * (1 - Math.pow(1 - t, 3)); apply();\n      if (t < 1) requestAnimationFrame(step);\n    })(t0);\n  };\n  btn.onclick = () => { if (btn.getAttribute('aria-pressed') !== 'true') power(true); enter(); };\n  const apps = [['YouTube','#e5484d'],['Netflix','#d6303a'],['Prime Video','#2fa8e0'],['Disney+','#3b6fe0'],['Spotify','#2fbf62'],['ARD Mediathek','#3d7be0'],['ZDF','#f08a24'],['Twitch','#8b5cf6']];\n  const nav = ui.querySelector('.tv-nav'), hero = ui.querySelector('.tv-hero'), vol = ui.querySelector('.tv-vol input'), volO = ui.querySelector('.tv-vol output');\n  let sel = +(localStorage.getItem('wohnung.tv.app') || 0);\n  apps.forEach(([n], i) => { const b = document.createElement('button'); b.textContent = n; b.onclick = () => pick(i); nav.appendChild(b); });\n  function pick(i){\n    sel = (i + apps.length) % apps.length; try { localStorage.setItem('wohnung.tv.app', sel); } catch(e){}\n    const [n, col] = apps[sel];\n    nav.querySelectorAll('button').forEach((b, j) => b.classList.toggle('on', j === sel));\n    const b = nav.children[sel]; nav.scrollTo({ left: b.offsetLeft - nav.clientWidth/2 + b.offsetWidth/2, behavior: 'smooth' });\n    hero.style.setProperty('--a', col); hero.querySelector('h2').textContent = n;\n    draw(); syncP();\n  }\n  let osd = 0, osdT = 0, playing = false, muted = false, preMute = 35;\n  function draw(){\n    const [n, col] = apps[sel], W = 1024, H = 600;\n    c.fillStyle = '#0b0c0e'; c.fillRect(0, 0, W, H);\n    let g = c.createRadialGradient(W*0.85, H*0.2, 10, W*0.85, H*0.2, W*0.75);\n    g.addColorStop(0, col + 'cc'); g.addColorStop(1, col + '00'); c.fillStyle = g; c.fillRect(0, 0, W, H);\n    c.font = '500 24px Helvetica, Arial, sans-serif'; c.textBaseline = 'middle';\n    let x = 48; const y = 58, ph = 46;\n    apps.forEach(([a], i) => { const w = c.measureText(a).width + 40; if (x + w > W - 20) return;\n      c.fillStyle = i === sel ? '#f2f1ec' : 'rgba(255,255,255,.12)'; c.beginPath(); c.roundRect(x, y - ph/2, w, ph, ph/2); c.fill();\n      c.fillStyle = i === sel ? '#111214' : '#f2f1ec'; c.fillText(a, x + 20, y); x += w + 10; });\n    c.textBaseline = 'alphabetic';\n    if (!playing){ c.fillStyle = 'rgba(242,241,236,.7)'; c.font = '500 22px Helvetica, Arial, sans-serif'; c.fillText('ZULETZT GEÖFFNET', 56, 420);\n    c.fillStyle = '#f2f1ec'; c.font = '700 104px Helvetica, Arial, sans-serif'; c.fillText(n, 50, 520, W - 100); }\n    if (playing){ c.fillStyle = 'rgba(0,0,0,.45)'; c.fillRect(0, 0, W, H);\n      c.fillStyle = '#f2f1ec'; c.font = '700 64px Helvetica, Arial, sans-serif'; c.fillText(n, 50, 470, W - 100);\n      c.font = '500 22px Helvetica, Arial, sans-serif'; c.fillStyle = 'rgba(242,241,236,.75)'; c.fillText('Läuft', 52, 512);\n      c.fillStyle = 'rgba(255,255,255,.2)'; c.beginPath(); c.roundRect(52, 545, W - 104, 6, 3); c.fill();\n      c.fillStyle = col; c.beginPath(); c.roundRect(52, 545, (W - 104) * 0.34, 6, 3); c.fill(); }\n    if (osd){ c.fillStyle = 'rgba(255,255,255,.14)'; c.beginPath(); c.roundRect(W - 78, 150, 34, 300, 17); c.fill();\n      const v = +vol.value / 100; c.fillStyle = '#f2f1ec'; c.beginPath(); c.roundRect(W - 72, 156 + 288 * (1 - v), 22, Math.max(22, 288 * v), 11); c.fill();\n      c.font = '500 22px Helvetica, Arial, sans-serif'; c.textAlign = 'center'; c.fillText(vol.value, W - 61, 485); c.textAlign = 'left'; }\n    tex.needsUpdate = true; try { act(); if (ptOn) tracer.updateMaterials(); } catch(e){}\n  }\n  const pApps = document.getElementById('tvpApps'), pVol = document.querySelector('.tvp-vol input'), pVolO = document.querySelector('.tvp-vol output');\n  apps.forEach(([a, col], i) => { const b = document.createElement('button'); b.innerHTML = '<i style=\"background:' + col + '\"><\u002Fi>' + a; b.onclick = () => pick(i); pApps.appendChild(b); });\n  function syncP(){ pApps.querySelectorAll('button').forEach((b, j) => b.classList.toggle('on', j === sel)); document.getElementById('tvpStat').textContent = apps[sel][0]; pVol.value = vol.value; pVolO.textContent = vol.value; const m = document.getElementById('tvpMute'); if (m) m.classList.toggle('on', +vol.value === 0); }\n  const showOsd = () => { osd = 1; clearTimeout(osdT); osdT = setTimeout(() => { osd = 0; draw(); }, 1600); draw(); syncP(); };\n  pVol.oninput = () => { vol.value = pVol.value; setVol(); };\n  document.querySelectorAll('.tvp-vol button').forEach(b => b.onclick = () => { vol.value = Math.max(0, Math.min(100, +vol.value + +b.dataset.d)); setVol(); });\n  document.getElementById('tvpBack').onclick = () => leave();\n  document.getElementById('tvpOff').onclick = () => document.getElementById('tvOff').click();\n  const nudge = d => { vol.value = Math.max(0, Math.min(100, +vol.value + d)); muted = false; setVol(); };\n  const okB = document.getElementById('tvpOk'), muteB = document.getElementById('tvpMute');\n  const setPlay = p => { playing = p; okB.classList.toggle('play', p); okB.textContent = p ? 'II' : 'OK'; draw(); };\n  document.querySelectorAll('.tvp-dpad button').forEach(b => b.onclick = () => { const k = b.dataset.k;\n    if (navigator.vibrate) navigator.vibrate(8);\n    if (k === 'left') { pick(sel - 1); setPlay(false); } else if (k === 'right') { pick(sel + 1); setPlay(false); }\n    else if (k === 'up') nudge(5); else if (k === 'down') nudge(-5); else setPlay(!playing); });\n  muteB.onclick = () => { if (!muted){ preMute = +vol.value || 35; vol.value = 0; muted = true; } else { vol.value = preMute; muted = false; } setVol(); muted = +vol.value === 0 && muted; muteB.classList.toggle('on', muted); };\n  document.getElementById('tvpHome').onclick = () => setPlay(false);\n  pick(sel);\n  vol.value = localStorage.getItem('wohnung.tv.vol') ?? 35;\n  const setVol = () => { volO.textContent = vol.value; vol.style.setProperty('--v', vol.value + '%'); try { localStorage.setItem('wohnung.tv.vol', vol.value); } catch(e){} if (typeof showOsd === 'function') showOsd(); };\n  vol.oninput = setVol; setVol();\n  ui.querySelectorAll('.tv-vb').forEach(b => b.onclick = () => { vol.value = Math.max(0, Math.min(100, +vol.value + +b.dataset.d)); setVol(); });\n  ['pointerdown','wheel','keydown'].forEach(t => ui.addEventListener(t, e => e.stopPropagation()));\n  addEventListener('keydown', e => { if (!ui.classList.contains('show')) return;\n    if (e.key === 'ArrowRight') pick(sel + 1); else if (e.key === 'ArrowLeft') pick(sel - 1);\n    else if (e.key === 'ArrowUp'){ vol.value = Math.min(100, +vol.value + 5); setVol(); } else if (e.key === 'ArrowDown'){ vol.value = Math.max(0, +vol.value - 5); setVol(); } });\n}\n\n// ---------- Tripod-Lampe: an/aus, Farbe, Stärke, Kegel ----------\nconst tripBox = document.getElementById('lamp2'), tripDot = document.querySelector('#tripT i');\nconst TRIP_KEY = 'wohnung-tripod-farbe';\nconst tripColIn = document.getElementById('tripCol'), tripDimIn = document.getElementById('tripDim'), tripConeIn = document.getElementById('tripCone');\nlet tripOn = false, tripLvl = 0, tripAnim = 0, tripK = 1;\nlet tripCol = localStorage.getItem(TRIP_KEY) || '#f2f5ff';\nconst tripSync = () => { if (ptOn){ tracer.updateLights(); tracer.updateMaterials(); } };\nfunction applyTrip(){\n  const v = tripLvl * tripK, c = new THREE.Color(tripCol);\n  trip.spot.color.copy(c); trip.glow.color.copy(c); trip.M.led.emissive.copy(c);\n  trip.M.led.color.set(tripLvl > 0.01 ? 0xffffff : 0xd8dadd);\n  trip.spot.intensity = 12 * v; trip.glow.intensity = 0.35 * v;\n  trip.M.led.emissiveIntensity = 4 * v;\n  tripDot.style.cssText = tripOn ? `background:${tripCol};box-shadow:0 0 10px 3px ${tripCol}99` : '';\n}\ntripDimIn.oninput = () => { tripK = tripDimIn.value/100; tripDimIn.nextElementSibling.textContent = tripDimIn.value + '%'; applyTrip(); tripSync(); };\nmakePicker(tripColIn, TRIP_KEY + '-cfg', { mode: 'white', warm: 5 }, tripDimIn, h => { tripCol = h; try { localStorage.setItem(TRIP_KEY, h); } catch(e){} applyTrip(); tripSync(); });\ntripConeIn.oninput = () => { trip.spot.angle = THREE.MathUtils.degToRad(tripConeIn.value); tripConeIn.nextElementSibling.textContent = tripConeIn.value + '°'; tripSync(); };\ntripConeIn.oninput();\napplyTrip();\ndocument.getElementById('tripT').onclick = () => {\n  tripOn = !tripOn;\n  tripBox.classList.toggle('on', tripOn);\n  tripBox.querySelector('#tripT span').textContent = tripOn ? 'Tripod-Lampe aus' : 'Tripod-Lampe an';\n  const id = ++tripAnim, from = tripLvl, to = tripOn ? 1 : 0, t0 = performance.now();\n  (function step(now){\n    if (id !== tripAnim) return;\n    const t = Math.min(1, (now - t0) / 450);\n    tripLvl = from + (to - from) * (1 - Math.pow(1 - t, 3));\n    applyTrip(); tripSync();\n    if (t < 1) requestAnimationFrame(step);\n  })(t0);\n};\n\n// ---------- Bett-LED in der Kopfteil-Einkerbung ----------\nconst BED_KEY = 'wohnung-bett-led';\nconst bedBtn = document.getElementById('bedL'), bedColIn = document.getElementById('bedCol'), bedDimIn = document.getElementById('bedDim');\nlet bedOn = false, bedLvl = 0, bedAnim = 0, bedK = 1, bedCol = localStorage.getItem(BED_KEY) || '#ffb070';\nfunction applyBed(){\n  const v = bedLvl * bedK, c = new THREE.Color(bedCol);\n  bedLed.M.emissive.copy(c); bedLed.M.emissiveIntensity = 7 * v; bedLed.M.color.set(v > 0.01 ? 0xffffff : 0xe8e4da);\n  bedLed.R.emissive.copy(c); bedLed.R.emissiveIntensity = 0.45 * v;\n  bedLed.lights.forEach(l => { l.color.copy(c); l.intensity = 0.07 * v; });\n  bedBtn.querySelector('b').style.cssText = bedOn ? 'background:' + bedCol + ';box-shadow:0 0 10px 3px ' + bedCol + '99' : '';\n}\nbedDimIn.oninput = () => { bedK = bedDimIn.value / 100; applyBed(); tripSync(); };\nmakePicker(bedColIn, BED_KEY + '-cfg', { mode: 'color', h: 28 }, bedDimIn, h => { bedCol = h; try { localStorage.setItem(BED_KEY, h); } catch(e){} applyBed(); tripSync(); });\napplyBed();\nbedBtn.onclick = () => {\n  bedOn = !bedOn;\n  bedBtn.setAttribute('aria-pressed', bedOn); bedBtn.classList.toggle('on', bedOn);\n  bedBtn.querySelector('span').textContent = bedOn ? 'Bett-LED aus' : 'Bett-LED an';\n  const id = ++bedAnim, from = bedLvl, to = bedOn ? 1 : 0, t0 = performance.now();\n  (function step(now){\n    if (id !== bedAnim) return;\n    const t = Math.min(1, (now - t0) / 700);\n    bedLvl = from + (to - from) * (1 - Math.pow(1 - t, 3));\n    applyBed(); tripSync(); try { act(); } catch(e){}\n    if (t < 1) requestAnimationFrame(step);\n  })(t0);\n};\n\n// ---------- Pathtracing (three-gpu-pathtracer): echte Lichtbündel mit Mehrfach-Reflexion, sobald die Kamera stillsteht ----------\n\nconst ptLabel = document.getElementById('pt');\nlet renderOn = false;\n// Sparsamer Standard-Renderer: N8AO (Screen-Space Ambient Occlusion) + Rendern nur bei Aktivität\nlet composer = null, aoPass = null, lastAct = performance.now(), lastInput = lastAct;\nconst act = () => { lastAct = lastInput = performance.now(); };\nfor (const ev of ['pointerdown','pointermove','wheel','keydown','input','click','resize','touchstart']) window.addEventListener(ev, act, true);\nPromise.all([import('three/examples/jsm/postprocessing/EffectComposer.js'), import('three/examples/jsm/postprocessing/RenderPass.js'), import('three/examples/jsm/postprocessing/OutputPass.js'), import('n8ao')]).then(([{EffectComposer},{RenderPass},{OutputPass},{N8AOPass}]) => {\n  const s = renderer.getSize(new THREE.Vector2());\n  composer = new EffectComposer(renderer);\n  aoPass = new N8AOPass(scene, cam, s.x, s.y);\n  Object.assign(aoPass.configuration, { aoRadius: 0.6, distanceFalloff: 0.5, intensity: 2.2, aoSamples: 12, denoiseSamples: 6, denoiseRadius: 10, halfRes: true, gammaCorrection: false });\n  aoPass.setQualityMode && aoPass.setQualityMode('Low');\n  composer.addPass(aoPass); composer.addPass(new OutputPass());\n  act();\n}).catch(e => console.warn('N8AO nicht verfügbar – einfacher Raster', e));\nconst _cs = new THREE.Vector2();\nconst rtBtn = document.getElementById('rt');\nrtBtn.onclick = () => {\n  renderOn = !renderOn;\n  rtBtn.classList.toggle('on', renderOn); rtBtn.setAttribute('aria-pressed', renderOn);\n  rtBtn.querySelector('span').textContent = renderOn ? 'Render an' : 'Render aus';\n  if (!renderOn && ptOn) stopPT();\n  stillSince = performance.now();\n};\nnew Promise(() => {}).then(({ WebGLPathTracer }) => {\n  tracer = new WebGLPathTracer(renderer);\n  tracer.bounces = 4;\n  tracer.renderScale = 0.5;\n  tracer.dynamicLowRes = false;\n  tracer.filterGlossyFactor = 0.5;\n  tracer.tiles.set(4, 4);\n  tracer.minSamples = 2;\n  tracer.fadeDuration = 350;\n  tracer.renderDelay = 0;\n}).catch(e => console.warn('Pathtracer nicht verfügbar – Raster-Fallback', e));\nfunction startPT(){\n  scene.environment = ptEnv; scene.background = ptEnv;\n  scene.environmentIntensity = ENV;\n  renderer.toneMappingExposure = 2.4;\n  if (ptDirty){ tracer.setScene(scene, cam); ptDirty = false; }\n  else { tracer.updateCamera(); tracer.updateMaterials(); tracer.updateLights(); tracer.updateEnvironment(); }\n  tracer.reset();\n  ptOn = true; ptLabel.classList.add('show');\n}\nfunction stopPT(){ ptOn = false; scene.environment = rasterEnv; scene.background = cubeRT.texture; applyInterior(ceilMat.opacity); ptLabel.classList.remove('show'); }\nconst MAX_SAMPLES = 256; let ptFrame = 0;\nlet lastUser = -1e9;\nconst interrupt = () => { stillSince = lastUser = performance.now(); if (ptOn) stopPT(); };\nfor (const ev of ['pointerdown','wheel','keydown']) window.addEventListener(ev, interrupt, true);\nrenderer.domElement.addEventListener('pointerdown', interrupt, true);\nconst lastM = new THREE.Matrix4(); let lastAspect = 0;\nfunction camMoved(){\n  const a = cam.matrixWorld.elements, b = lastM.elements; let d = 0;\n  for (let i = 0; i < 16; i++) d += Math.abs(a[i] - b[i]);\n  const m = d > 1e-5 || cam.aspect !== lastAspect;\n  lastM.copy(cam.matrixWorld); lastAspect = cam.aspect;\n  return m;\n}\nconst loop = () => {\n  ctl.autoRotate = !inRoom && !lampFocus && ctl.enabled && performance.now() - lastUser > 6000;\n  ctl.autoRotateSpeed = 0.4;\n  document.body.classList.toggle('idle', performance.now() - lastInput > 8000);\n  ctl.update(); cam.updateMatrixWorld();\n  const now = performance.now();\n  if (camMoved()){ stillSince = now; lastAct = now; if (ptOn) stopPT(); }\n  if (tracer && renderOn && !ptOn && now - stillSince > 350 && (ceilMat.opacity >= 0.999 || ceilMat.opacity <= 0.001)){\n    try { startPT(); } catch(e){ console.warn('Pathtracer-Fehler: ' + (e && e.message), e); tracer = null; ptOn = false; scene.environment = rasterEnv; scene.background = cubeRT.texture; ptLabel.classList.remove('show'); }\n  }\n  if (ptOn && tracer.samples >= MAX_SAMPLES){ ptLabel.textContent = 'Raytracing · fertig'; return; }\n  if (ptOn){ ptFrame ^= 1; if (ptFrame) tracer.renderSample(); ptLabel.textContent = 'Raytracing · ' + Math.floor(tracer.samples) + ' Samples'; }\n  else if (now - lastAct < 1500) {\n    if (composer){ renderer.getSize(_cs); if (composer._w !== _cs.x || composer._h !== _cs.y){ composer.setSize(_cs.x, _cs.y); composer._w = _cs.x; composer._h = _cs.y; } composer.render(); }\n    else renderer.render(scene, cam);\n  }\n};\nstage._loop = loop;\nrenderer.setAnimationLoop(loop);\n// Beim Größenwechsel (Menü-Animation) sofort neu zeichnen → kein heller Blitz\nnew ResizeObserver(() => { const n = performance.now(); lastAct = n; stillSince = n; if (ptOn) stopPT(); loop(); }).observe(stage);\n\n// ---------- Raum-Navigation ----------\nconst cam = stage._camera, ctl = stage._controls;\nlet lampFocus = false;\ncam.position.sub(ctl.target).multiplyScalar(0.6).add(ctl.target);\nconst overview = { pos: cam.position.clone(), tgt: ctl.target.clone() };\nconst EYE = 1.6;\n// Standpunkt in der Raummitte, Blick in Richtung (dx,dz); Target minimal vor der Kamera → Umsehen statt Umkreisen\nconst spot = (x, z, dx, dz, y = EYE) => {\n  const d = new THREE.Vector3(dx, -0.12, dz).normalize().multiplyScalar(0.05);\n  const pos = new THREE.Vector3(x, y, z);\n  return { pos, tgt: pos.clone().add(d), fp: true };\n};\n// Vogelperspektive: senkrecht über dem Raum, leicht geneigt, Decke ausgeblendet – ganzer Raum im Bild\nconst bird = (x0,z0,x1,z1) => {\n  const cx = (x0+x1)/2, cz = (z0+z1)/2, w = Math.abs(x1-x0), d = Math.abs(z1-z0);\n  const fov = (cam.fov || 50) * Math.PI/180, asp = Math.max(0.35, (stage.clientWidth||1)/(stage.clientHeight||1));\n  const need = Math.max(d, w/asp) * 0.5 * 1.25;            // halbe Ausdehnung + Rand\n  const hgt = need / Math.tan(fov/2) + 1.0;\n  return { pos: new THREE.Vector3(cx, hgt, cz + hgt*0.22), tgt: new THREE.Vector3(cx, 0.3, cz), fp: false };\n};\nconst room = ([x0,z0,x1,z1], dx, dz) => ({ fp: spot((x0+x1)/2, (z0+z1)/2, dx, dz), bird: bird(x0, z0, x1, z1) });\nconst ROOMS = [\n  ['Übersicht', overview],\n  ['Wohnzimmer', room(RM_WZ, 1, 0.4)],\n  ['Küche', room(RM_KU, 1, -0.3)],\n  ['Schlafzimmer', room(RM_SZ, -0.3, 1)],\n  ['Bad', room(RM_BAD, 0, -1)],\n  ['Flur', room(RM_FL, -1, 0)],\n  ['Balkon', room([BX0, BZ0, BX1, BZ1], 0, -1)],\n];\nlet anim = 0;\nfunction flyTo(view){\n  const id = ++anim;\n  const p0 = cam.position.clone(), t0 = ctl.target.clone();\n  const c0 = ceilMat.opacity, c1 = view.fp ? 1 : 0;\n  inRoom = !!view.fp;\n  const clamp01 = x => Math.max(0, Math.min(1, x));\n  const dist = p0.distanceTo(view.pos);\n  const dur = Math.min(2200, 1100 + dist*90);\n  const lift = Math.min(3, dist*0.25);\n  const start = performance.now();\n  ctl.enabled = false;\n  ctl.enableZoom = ctl.enablePan = !view.fp;\n  ctl.rotateSpeed = view.fp ? -0.35 : 1;\n  ctl.minDistance = 0;\n  const ease = t => t < 0.5 ? 4*t*t*t : 1 - Math.pow(-2*t+2, 3)/2;\n  (function step(now){\n    if (id !== anim) return;\n    const t = Math.min(1, (now - start)/dur), e = ease(t);\n    cam.position.lerpVectors(p0, view.pos, e);\n    cam.position.y += Math.sin(Math.PI*e) * lift;\n    ctl.target.lerpVectors(t0, view.tgt, e);\n    cam.lookAt(ctl.target);\n    // Einblenden erst am Ende der Anflugs (Kamera schon unter Deckenhöhe), Ausblenden sofort\n    const k = c1 > c0 ? clamp01((e - 0.6) / 0.4) : clamp01(e / 0.3);\n    setCeil(c0 + (c1 - c0) * k);\n    if (t < 1) requestAnimationFrame(step); else ctl.enabled = !window.__tvLock;\n  })(start);\n}\nconst bar = document.getElementById('rooms');\nconst povBar = document.getElementById('pov');\nlet curView = overview, povMode = 'bird';\nconst show = () => flyTo(curView.bird ? curView[povMode] : curView);\nROOMS.forEach(([label, view], i) => {\n  const b = document.createElement('button');\n  b.textContent = label;\n  if (i === 0) b.classList.add('on');\n  b.onclick = () => {\n    bar.querySelectorAll('button').forEach(x => x.classList.toggle('on', x === b));\n    lampBtn.classList.toggle('show', label === 'Wohnzimmer');\n    tripBox.classList.toggle('show', label === 'Schlafzimmer');\n    povBar.classList.toggle('show', !!view.bird);\n    curView = view; povMode = 'bird';\n    povBar.querySelectorAll('button').forEach(x => x.classList.toggle('on', x.dataset.m === povMode));\n    show();\n  };\n  bar.appendChild(b);\n});\n// Lampe konfigurieren → Kamera fliegt an die Lampe, Drehen stoppt; beim Schließen zurück\nconst LAMP_FOCUS = { [LAMP_KEY + '-cfg']: [bp.clone(), 1], [TRIP_KEY + '-cfg']: [trip.spot.getWorldPosition(new THREE.Vector3()), 3], [BED_KEY + '-cfg']: [bedLed.anchor.getWorldPosition(new THREE.Vector3()), 3] };\naddEventListener('lpick', e => {\n  const f = LAMP_FOCUS[e.detail.key]; if (!f) return;\n  if (e.detail.open){\n    lampFocus = true;\n    const p = f[0], c = ROOMS[f[1]][1].fp.pos, dir = new THREE.Vector3(c.x - p.x, 0, c.z - p.z);\n    const dist = Math.min(1.8, dir.length() * 0.85); dir.normalize();\n    // Handy: Lampe mittig im oberen Bildteil, Menü-Sheet unten\n    const pos = p.clone().addScaledVector(dir, dist * 1.4).add(new THREE.Vector3(0, -0.3, 0));\n    flyTo({ pos, tgt: p.clone().add(new THREE.Vector3(0, -0.35, 0)), fp: false });\n  } else { lampFocus = false; show(); }\n});\npovBar.addEventListener('click', e => {\n  const b = e.target.closest('button'); if (!b || b.dataset.m === povMode) return;\n  povMode = b.dataset.m;\n  povBar.querySelectorAll('button').forEach(x => x.classList.toggle('on', x === b));\n  show();\n});\n\n// ---------- Poly Haven Texturen ----------\nasync function polyHaven(assetName, res){\n  const all = await (await fetch('https://api.polyhaven.com/assets?t=textures')).json();\n  const want = assetName.toLowerCase();\n  const id = (all[want] ? want : null) || Object.keys(all).find(k => (all[k].name||'').toLowerCase() === want)\n          || Object.keys(all).find(k => (all[k].name||'').toLowerCase().includes(want))\n          || want.replace(/\\s+/g,'_');\n  const files = await (await fetch(`https://api.polyhaven.com/files/${id}`)).json();\n  const pick = key => files[key]?.['1k']?.jpg?.url || files[key]?.['1k']?.png?.url;\n  const dim = all[id]?.dimensions; // mm [w,h]\n  return { id, dim, diff: pick('Diffuse'), nor: pick('nor_gl'), rough: pick('Rough') };\n}\nconst loader = new THREE.TextureLoader();\nloader.setCrossOrigin('anonymous');\nconst loadTex = (url, srgb) => new Promise((res, rej) => loader.load(url, t => {\n  t.wrapS = t.wrapT = THREE.RepeatWrapping;\n  if (srgb) t.colorSpace = THREE.SRGBColorSpace;\n  t.anisotropy = 8; res(t);\n}, undefined, rej));\nasync function apply(mat, assetName, uvScale, res){\n  const f = await polyHaven(assetName, res);\n  const [map, normalMap, roughnessMap] = await Promise.all([\n    loadTex(f.diff, true), f.nor ? loadTex(f.nor) : null, f.rough ? loadTex(f.rough) : null\n  ]);\n  if (uvScale){ // echte Größe: UVs sind in 1/uvScale m, Textur deckt dim mm ab\n    const w = (f.dim?.[0] || 2000) / 1000, hh = (f.dim?.[1] || f.dim?.[0] || 2000) / 1000;\n    for (const t of [map, normalMap, roughnessMap]) if (t) t.repeat.set(uvScale / w, uvScale / hh);\n  }\n  mat.map = map; mat.color.set(0xffffff);\n  if (normalMap) mat.normalMap = normalMap;\n  if (roughnessMap) { mat.roughnessMap = roughnessMap; mat.roughness = 1; }\n  mat.needsUpdate = true;\n  ptDirty = true; if (ptOn) stopPT();\n  return f.id;\n}\n// ---------- Tageszeit: prozeduraler Himmel (three.js Sky, Preetham-Modell) ----------\nconst { Sky } = await import('three/addons/objects/Sky.js');\nconst sky = new Sky(); sky.scale.setScalar(1000);\nconst skyScene = new THREE.Scene(); skyScene.add(sky);\nconst SU = sky.material.uniforms;\nSU.mieCoefficient.value = 0.005; SU.mieDirectionalG.value = 0.8;\n// Nacht-/Dämmerungs-Minimum: dunkles Blau, zum Horizont heller\nsky.material.uniforms.nightFloor = { value: new THREE.Color(0,0,0) };\nsky.material.fragmentShader = 'uniform vec3 nightFloor;\\n' + sky.material.fragmentShader.replace('#include <tonemapping_fragment>',\n  'float hzF = 1.0 - clamp(normalize(vWorldPosition - cameraPosition).y, 0.0, 1.0);\\n gl_FragColor.rgb = max(gl_FragColor.rgb, nightFloor * (0.55 + 0.9*hzF*hzF));\\n#include <tonemapping_fragment>');\nsky.material.needsUpdate = true;\nconst cubeRT = new THREE.WebGLCubeRenderTarget(512, { type: THREE.HalfFloatType });\nconst cubeCam = new THREE.CubeCamera(1, 5000, cubeRT); skyScene.add(cubeCam);\nconst pmrem = new THREE.PMREMGenerator(renderer);\nlet envRT = null;\nconst keyBase = key.intensity, hemiCol0 = hemi ? hemi.color.clone() : null, hemiGnd0 = hemi ? hemi.groundColor.clone() : null;\nconst SS = THREE.MathUtils.smoothstep, col = (r,g,b) => new THREE.Color(r,g,b);\nfunction makePTEnv(d, day, golden){\n  const w = 256, h = 128, arr = new Float32Array(w*h*4);\n  const zen = col(.03,.045,.1).lerp(col(.16,.32,.75), day);\n  const hor = col(.05,.07,.13).lerp(col(.75,.82,.92).lerp(col(1,.55,.3), golden*.8), day);\n  const gnd = hor.clone().multiplyScalar(.25);\n  const sunC = col(1,.95,.85).lerp(col(1,.5,.2), golden).multiplyScalar(40*day);\n  for (let j = 0; j < h; j++){\n    const el = ((j+.5)/h - .5)*Math.PI, sy = Math.sin(el), cy = Math.cos(el);\n    for (let i = 0; i < w; i++){\n      const az = ((i+.5)/w - .5)*2*Math.PI, x = Math.cos(az)*cy, z = Math.sin(az)*cy;\n      let r, g, bb;\n      if (sy >= 0){ const t = Math.sqrt(sy); r = hor.r+(zen.r-hor.r)*t; g = hor.g+(zen.g-hor.g)*t; bb = hor.b+(zen.b-hor.b)*t; }\n      else { const t = Math.min(1, -sy*4); r = hor.r+(gnd.r-hor.r)*t; g = hor.g+(gnd.g-hor.g)*t; bb = hor.b+(gnd.b-hor.b)*t; }\n      const dot = x*d.x + sy*d.y + z*d.z;\n      if (dot > 0){ const gl = Math.pow(dot, 48)*day*(1+golden); r += gl; g += gl*(.85-.3*golden); bb += gl*(.7-.45*golden); }\n      if (dot > .999 && sy > -0.02){ r = sunC.r; g = sunC.g; bb = sunC.b; }\n      const k = (j*w + i)*4; arr[k] = r; arr[k+1] = g; arr[k+2] = bb; arr[k+3] = 1;\n    }\n  }\n  const dt = new THREE.DataTexture(arr, w, h, THREE.RGBAFormat, THREE.FloatType);\n  dt.mapping = THREE.EquirectangularReflectionMapping;\n  dt.minFilter = dt.magFilter = THREE.LinearFilter; dt.generateMipmaps = false; dt.needsUpdate = true;\n  return dt;\n}\nconst sunV = new THREE.Vector3();\nfunction setTime(hr){\n  // Sonnenbahn (vereinfacht): 7 Uhr Ost (+x) → 13 Uhr Süd (+z) → 19 Uhr West, max. 50° Höhe\n  const phi = Math.PI*(hr - 7)/12, e = THREE.MathUtils.degToRad(50)*Math.sin(phi);\n  sunV.set(Math.cos(phi)*Math.cos(e), Math.sin(e), Math.sin(phi)*Math.cos(e)).normalize();\n  const s = sunV.y, day = SS(s, -0.14, 0.18), golden = 1 - SS(s, 0, 0.4), dusk = SS(s, -0.22, -0.02) * (1 - SS(s, 0.02, 0.2));\n  SU.sunPosition.value.copy(sunV);\n  SU.rayleigh.value = 2.5 + 1.2*golden;\n  SU.turbidity.value = 3 + 5*golden;\n  // Nachtblau, zur blauen Stunde etwas heller/violetter\n  SU.nightFloor.value.setRGB(0.010 + 0.03*dusk, 0.016 + 0.03*dusk, 0.045 + 0.06*dusk);\n  cubeCam.update(renderer, skyScene);\n  envRT = pmrem.fromCubemap(cubeRT.texture, envRT);\n  rasterEnv = envRT.texture;\n  if (s > -0.03){\n    key.position.copy(hc).addScaledVector(sunV, 30);\n    key.color.set(0xff9a52).lerp(new THREE.Color(0xfff3e2), SS(s, 0, 0.5));\n    key.intensity = keyBase * 1.3 * Math.max(day, 0.15);\n  } else { // Mondlicht, gegenüber der Sonne\n    const m = new THREE.Vector3(-sunV.x, Math.abs(sunV.y)*0.8 + 0.2, -sunV.z).normalize();\n    key.position.copy(hc).addScaledVector(m, 30);\n    key.color.set(0x9fb4ff); key.intensity = keyBase * 0.25;\n  }\n  envK = 0.2 + 0.1*day + 0.15*dusk; hemiK = 0.3 + 0.4*day; fillK = 0.1 + 0.5*day; expK = 1 - 0.45*day;\n  if (hemi){ hemi.color.copy(hemiCol0).lerp(new THREE.Color(0x34426e), 1 - day); hemi.groundColor.copy(hemiGnd0).multiplyScalar(0.3 + 0.7*day); }\n  ptEnv = makePTEnv(sunV, day, golden);\n  scene.background = cubeRT.texture;\n  scene.backgroundIntensity = 0.2 + 1.1*(1 - day);\n  if (ptOn) stopPT(); else { scene.environment = rasterEnv; applyInterior(ceilMat.opacity); }\n  act();\n}\n// Himmel & Licht folgen der echten Uhrzeit\nconst nowH = () => { const n = new Date(); return n.getHours() + n.getMinutes()/60; };\nsetTime(nowH());\nsetInterval(() => setTime(nowH()), 60000);\nlet texMsg = 'Texturen werden geladen…';\nconst upd = () => statusEl.textContent = texMsg;\nupd();\nsofa.M.fabric.color.set('#3a3a3c');\napply(sofa.M.fabric, 'Poly Wool Herringbone').then(() => sofa.M.fabric.color.set('#3a3a3c')).catch(e => console.warn(e));\nPromise.all([apply(M.floor, 'wood_floor', 1.0), apply(M.wall, 'White Stucco'), apply(M.brick, 'Brick Wall 04', 1.5), apply(M.cap, 'Rough Plaster Brick 04', 1.5), apply(tileMat, 'interior_tiles', 1.0, '2k').then(id => {\n    // nur Relief/Glanz behalten, Farbe weiß; Raster achsparallel drehen, Fliesen halb so groß\n    tileMat.map = null; tileMat.color.set(0xf3f2ee);\n    // Textur: Rautenraster, 3 Fliesen je Kachel → 45° gedreht achsparallel; 15-cm-Fliesen, Fugen auf 0,90 / 1,50 m\n    const TILE = 0.15, rep = 1 / (3 * Math.SQRT2 * TILE);\n    for (const t of [tileMat.normalMap, tileMat.roughnessMap]) if (t){ t.center.set(0, 0); t.offset.set(0, 0); t.rotation = Math.PI/4; t.repeat.set(rep, rep); }\n    tileMat.needsUpdate = true; return id;\n  })])\n  .then(ids => { texMsg = 'Texturen: ' + ids.join(', '); upd(); })\n  .catch(e => { console.warn(e); texMsg = 'Texturen nicht erreichbar – Farb-Fallback'; upd(); });\n\n// ---------- Fernbedienung ----------\n{\n  const $ = s => document.querySelector(s);\n  const keys = [];\n  [1,2,3,4,5,6,0].forEach(i => {\n    const b = document.createElement('button');\n    b.className = 'r-key' + (i === 0 ? ' wide' : ''); b.textContent = ROOMS[i][0];\n    b.onclick = () => { bar.children[i].click(); sync(); };\n    keys.push([i, b]); $('#rRooms').appendChild(b);\n  });\n  const LAMPS = {\n    bogen: { on: () => lampOn, t: () => $('#lampT').click(), col: () => lampCol, sw: colIn },\n    donut: { on: () => donutBtn.getAttribute('aria-pressed') === 'true', t: () => donutBtn.click(), col: () => '#ff9a3c' },\n    trip:  { on: () => tripOn, t: () => $('#tripT').click(), col: () => tripCol, sw: tripColIn },\n    bett:  { on: () => bedOn, t: () => bedBtn.click(), col: () => bedCol, sw: bedColIn },\n  };\n  let msg = '';\n  document.querySelectorAll('.r-lamp').forEach(row => {\n    const L = LAMPS[row.dataset.l];\n    row.querySelector('.r-tog').onclick = () => { msg = ''; L.t(); sync(); };\n    const c = row.querySelector('.r-col'); if (c) c.onclick = e => { e.stopPropagation(); L.sw.click(); };\n  });\n  const setAll = on => { Object.values(LAMPS).forEach(L => { if (L.on() !== on) L.t(); }); };\n  const closePick = () => document.querySelectorAll('.lpick.open').forEach(p => p.querySelector('.lp-done').click());\n  $('#rAllOn').onclick = () => { msg = ''; setAll(true); sync(); };\n  $('#rAllOff').onclick = () => { msg = ''; closePick(); setAll(false); sync(); };\n  $('#rPower').onclick = () => { closePick(); setAll(false); bar.children[0].click(); msg = 'Tschüss – alles aus'; sync(); };\n  function sync(){\n    const cur = [...bar.children].findIndex(b => b.classList.contains('on'));\n    keys.forEach(([i, b]) => b.classList.toggle('on', i === cur));\n    let n = 0, shown = 0;\n    document.querySelectorAll('.r-lamp').forEach(row => {\n      const L = LAMPS[row.dataset.l], on = L.on(), c = L.col(); if (on) n++;\n      row.classList.toggle('on', on);\n      const vis = +row.dataset.room === cur; row.style.display = vis ? '' : 'none'; if (vis) shown++;\n      row.querySelector('i').style.cssText = on ? 'background:' + c + ';box-shadow:0 0 10px 3px ' + c + '99' : '';\n      const cb = row.querySelector('.r-col'); if (cb) cb.style.setProperty('--c', c);\n    });\n    $('#rLightsLbl').style.display = $('#rLights').style.display = shown ? '' : 'none';\n    const tv = cur === 1; $('#rTvLbl').style.display = $('#rTv').style.display = tv ? '' : 'none';\n    $('#rTv').classList.toggle('on', $('#tvB').getAttribute('aria-pressed') === 'true');\n    if (n) msg = '';\n    $('#rStat').textContent = msg || (n ? n + (n === 1 ? ' Licht an' : ' Lichter an') : 'Alle Lichter aus');\n  }\n  const tvB = $('#tvB'), tvOn = () => tvB.getAttribute('aria-pressed') === 'true';\n  $('#rTvPow').onclick = () => { if (tvOn()) $('#tvOff').click(); else tvB.click(); setTimeout(sync, 0); };\n  $('#rTvOpen').onclick = () => { tvB.click(); setTimeout(sync, 0); };\n  addEventListener('pointerup', () => setTimeout(sync, 0));\n  addEventListener('input', sync);\n  addEventListener('lpick', () => setTimeout(sync, 0));\n  sync();\n}\n\n// ---------- TV-Sperre + KI-Assistent ----------\nfor (const t of ['pointerdown','pointermove','wheel','touchstart','touchmove','dblclick','contextmenu']) window.addEventListener(t, e => {\n  if (window.__tvLock && e.composedPath().includes(renderer.domElement)){ e.stopImmediatePropagation(); if (e.cancelable && t !== 'pointerdown') e.preventDefault(); }\n}, { capture: true, passive: false });\n{\n  const $ = s => document.querySelector(s);\n  const ai = $('#ai'), logEl = $('#aiLog'), inp = $('#aiIn'), stateEl = $('#aiState');\n  const roomNames = ROOMS.map(r => r[0]);\n  const ROOM_TO = { 'Übersicht': 'zur Übersicht', 'Wohnzimmer': 'ins Wohnzimmer', 'Küche': 'in die Küche', 'Schlafzimmer': 'ins Schlafzimmer', 'Bad': 'ins Bad', 'Flur': 'in den Flur', 'Balkon': 'auf den Balkon' };\n  const ROOM_LAMPS = { 'Wohnzimmer': ['bogen', 'donut'], 'Schlafzimmer': ['trip', 'bett'] };\n  const L = {\n    bogen: { n: 'Bogenlampe', on: () => lampOn, t: () => $('#lampT').click() },\n    donut: { n: 'Donut-Lampe', on: () => donutBtn.getAttribute('aria-pressed') === 'true', t: () => donutBtn.click() },\n    trip:  { n: 'Tripod-Lampe', on: () => tripOn, t: () => $('#tripT').click() },\n    bett:  { n: 'Bett-LED', on: () => bedOn, t: () => bedBtn.click() },\n  };\n  const tvB = $('#tvB'), tvIsOn = () => tvB.getAttribute('aria-pressed') === 'true';\n  const refresh = () => { try { act(); } catch(e){} dispatchEvent(new Event('input')); setTimeout(() => dispatchEvent(new Event('input')), 60); };\n  const COLORS = { rot: ['#ff2a2a', 'rot'], blau: ['#2a62ff', 'blau'], grün: ['#22e060', 'grün'], gruen: ['#22e060', 'grün'], lila: ['#9b3bff', 'lila'], violett: ['#9b3bff', 'violett'], pink: ['#ff3fa8', 'pink'], rosa: ['#ff7ac0', 'rosa'], orange: ['#ff7a1a', 'orange'], gelb: ['#ffd21a', 'gelb'], türkis: ['#1ae5d8', 'türkis'], weiß: ['#fff1e0', 'weiß'], weiss: ['#fff1e0', 'weiß'], warm: ['#ffb070', 'warmweiß'] };\n  const A = {\n    light(k, on){ const l = L[k]; if (!l) return 'Diese Lampe kenne ich nicht.'; const want = on ?? !l.on(); if (l.on() !== want) l.t(); refresh(); return l.n + (want ? ' ist an.' : ' ist aus.'); },\n    lights(keys, on){ keys.forEach(k => { if (L[k].on() !== on) L[k].t(); }); refresh(); },\n    all(on){ A.lights(Object.keys(L), on); return on ? 'Alle Lichter sind an.' : 'Alle Lichter sind aus.'; },\n    tv(mode){\n      if (mode === 'aus'){ if (tvIsOn()) $('#tvOff').click(); refresh(); return 'Fernseher ist aus.'; }\n      if (!window.__tvLock) tvB.click(); refresh(); return mode === 'fernbedienung' ? 'Fernbedienung ist offen.' : 'Fernseher ist an.';\n    },\n    room(name){\n      const i = roomNames.findIndex(r => r.toLowerCase() === String(name).toLowerCase()); if (i < 0) return 'Diesen Raum kenne ich nicht.';\n      if (window.__tvLock) $('#tvBack').click();\n      bar.children[i].click(); refresh(); return 'Ich bringe dich ' + (ROOM_TO[roomNames[i]] || 'dorthin') + '.';\n    },\n    bedColor(hex, name){\n      bedCol = hex; try { localStorage.setItem(BED_KEY, hex); } catch(e){} bedColIn.style.background = hex;\n      if (!bedOn) bedBtn.click(); applyBed(); tripSync(); refresh(); return 'Die Bett-LED leuchtet jetzt ' + name + '.';\n    },\n  };\n  const HELP = 'Ich kann Lichter schalten („Bett-LED blau“, „Alle Lichter aus“), den Fernseher steuern und dich durch die Räume führen („Zeig die Küche“).';\n  function local(q){\n    const s = ' ' + q.toLowerCase().replace(/[.,!?;:„“\"]/g, ' ').replace(/-/g, ' ') + ' ';\n    const off = /\\s(aus|ausschalten|ausmachen|abschalten|dunkel)\\s/.test(s), on = /\\s(an|ein|einschalten|anmachen|anschalten|hell)\\s/.test(s);\n    const st = off ? false : on ? true : null;\n    const words = s.trim().split(/\\s+/);\n    if (/^(hallo|hi|hey|servus|moin|guten (morgen|tag|abend))/.test(s.trim()) && words.length <= 3) return 'Hallo! ' + HELP;\n    if (/was kannst du|hilfe|befehle/.test(s)) return HELP;\n    const col = Object.keys(COLORS).find(c => s.includes(' ' + c));\n    if (/bett|\\sled/.test(s)){ if (col && st !== false) return A.bedColor(...COLORS[col]); return A.light('bett', st); }\n    if (/bogen|stehlampe/.test(s)) return A.light('bogen', st);\n    if (/donut|regal/.test(s)) return A.light('donut', st);\n    if (/tripod|stativ/.test(s)) return A.light('trip', st);\n    if (/fernbedienung/.test(s) && !off) return A.tv('fernbedienung');\n    if (/fernseh|\\stv\\s|glotze/.test(s)) return A.tv(off ? 'aus' : 'an');\n    const r = roomNames.find(n => s.includes(n.toLowerCase())) || (/übersicht|von oben|ganze wohnung/.test(s) ? 'Übersicht' : null);\n    if (r && /licht|lampe/.test(s) && st !== null){ const ks = ROOM_LAMPS[r]; if (!ks) return 'Im Raum ' + r + ' gibt es noch keine steuerbaren Lichter.'; A.lights(ks, st); return 'Licht im ' + r + (st ? ' ist an.' : ' ist aus.'); }\n    if (/(alle|alles)/.test(s) && st !== null) return A.all(st);\n    if (/licht|lampe/.test(s) && st !== null) return A.all(st);\n    if (r) return A.room(r);\n    return null;\n  }\n  const claude = (() => { try { return window.claude || (parent !== window && parent.claude) || null; } catch(e){ return null; } })();\n  const hist = [];\n  async function remote(q){\n    const cur = bar.querySelector('.on')?.textContent || 'Übersicht';\n    const stat = Object.entries(L).map(([k, l]) => k + '=' + (l.on() ? 'an' : 'aus')).join(', ') + ', fernseher=' + (tvIsOn() ? 'an' : 'aus') + ', raum=' + cur;\n    hist.push({ role: 'user', content: q }); while (hist.length > 12) hist.shift();\n    const text = await claude.complete({\n      max_tokens: 400,\n      system: 'Du bist die KI einer interaktiven 3D-Wohnung. Antworte auf Deutsch, freundlich, höchstens 2 kurze Sätze, ohne Markdown oder Emojis. Steuere die Wohnung über die Tools. Aktueller Zustand: ' + stat + '. Räume: ' + roomNames.join(', ') + '.',\n      messages: hist.slice(),\n      tools: [\n        { name: 'licht', description: 'Schaltet eine Lampe. lampe: bogen (Bogenlampe Wohnzimmer), donut (Donut-Lampe Regal), trip (Tripod-Lampe Schlafzimmer), bett (LED im Bett-Kopfteil), alle.', input_schema: { type: 'object', properties: { lampe: { type: 'string', enum: ['bogen', 'donut', 'trip', 'bett', 'alle'] }, an: { type: 'boolean' } }, required: ['lampe', 'an'] }, run: async ({ lampe, an }) => lampe === 'alle' ? A.all(an) : A.light(lampe, an) },\n        { name: 'bett_farbe', description: 'Setzt die Farbe der Bett-LED.', input_schema: { type: 'object', properties: { hex: { type: 'string', description: '#rrggbb' }, name: { type: 'string', description: 'Farbname auf Deutsch' } }, required: ['hex', 'name'] }, run: async ({ hex, name }) => A.bedColor(hex, name) },\n        { name: 'fernseher', description: 'Fernseher an/aus oder Fernbedienung öffnen.', input_schema: { type: 'object', properties: { aktion: { type: 'string', enum: ['an', 'aus', 'fernbedienung'] } }, required: ['aktion'] }, run: async ({ aktion }) => A.tv(aktion) },\n        { name: 'raum', description: 'Kamera in einen Raum fliegen lassen.', input_schema: { type: 'object', properties: { raum: { type: 'string', enum: roomNames } }, required: ['raum'] }, run: async ({ raum }) => A.room(raum) },\n      ],\n    });\n    hist.push({ role: 'assistant', content: text || 'Erledigt.' });\n    return text || 'Erledigt.';\n  }\n  const setState = s => {\n    document.body.classList.toggle('ai-listen', s === 'listen'); document.body.classList.toggle('ai-think', s === 'think'); document.body.classList.toggle('ai-speak', s === 'speak');\n    stateEl.textContent = { listen: 'Ich höre zu …', think: 'Denke nach …', speak: 'Spricht …' }[s] || 'Bereit';\n  };\n  const add = (who, text) => { const d = document.createElement('div'); d.className = 'ai-m ' + who; d.textContent = text; logEl.appendChild(d); logEl.scrollTop = logEl.scrollHeight; requestAnimationFrame(() => logEl.scrollTop = logEl.scrollHeight); return d; };\n  let voice = null;\n  const pickVoice = () => { try { const vs = speechSynthesis.getVoices().filter(v => /^de/i.test(v.lang)); voice = vs.find(v => /google|anna|petra|helena|katja|neural/i.test(v.name)) || vs[0] || null; } catch(e){} };\n  if ('speechSynthesis' in window){ pickVoice(); speechSynthesis.onvoiceschanged = pickVoice; }\n  function say(text, speak){\n    add('a', text);\n    if (!speak || !('speechSynthesis' in window)) return;\n    const u = new SpeechSynthesisUtterance(text); u.lang = 'de-DE'; if (voice) u.voice = voice; u.rate = 1.03;\n    u.onstart = () => setState('speak'); u.onend = u.onerror = () => setState('');\n    speechSynthesis.cancel(); speechSynthesis.speak(u);\n  }\n  let busy = false;\n  async function send(q, spoken){\n    q = q.trim(); if (!q || busy) return;\n    add('u', q); inp.value = '';\n    let r = null; try { r = local(q); } catch(e){ console.warn(e); }\n    if (r == null && claude){\n      busy = true; setState('think'); const dots = add('a dots', '• • •');\n      try { r = await remote(q); } catch(e){ console.warn(e); r = 'Ich bin gerade nicht erreichbar. ' + HELP; }\n      dots.remove(); busy = false; setState('');\n    }\n    if (r == null) r = 'Das habe ich nicht verstanden. ' + HELP;\n    say(r, spoken);\n  }\n  const SR = window.SpeechRecognition || window.webkitSpeechRecognition;\n  let rec = null, listening = false;\n  function listen(){\n    if (listening){ try { rec.stop(); } catch(e){} return; }\n    if (!SR){ say('Spracheingabe wird von diesem Browser nicht unterstützt – schreib mir einfach.', false); inp.focus(); return; }\n    try { speechSynthesis.cancel(); } catch(e){}\n    rec = new SR(); rec.lang = 'de-DE'; rec.interimResults = true; rec.maxAlternatives = 1;\n    let fin = '', err = false;\n    rec.onresult = e => { let t = ''; for (const r of e.results) t += r[0].transcript; inp.value = t; if (e.results[e.results.length - 1].isFinal) fin = t; };\n    rec.onerror = e => { err = true; listening = false; setState('');\n      if (e.error === 'not-allowed' || e.error === 'service-not-allowed') say('Ich darf das Mikrofon nicht benutzen. Bitte erlaube den Zugriff im Browser.', false);\n      else if (e.error === 'network') say('Für die Spracherkennung brauche ich eine Internetverbindung.', false); };\n    rec.onend = () => { listening = false; setState(''); const q = (fin || inp.value).trim(); if (q && !err) send(q, true); };\n    try { rec.start(); listening = true; setState('listen'); } catch(e){ setState(''); }\n  }\n  const open = (withVoice) => {\n    const was = ai.classList.contains('open');\n    ai.classList.add('open');\n    if (!logEl.children.length) add('a', 'Hallo, ich bin die KI deiner Wohnung. Sag oder schreib mir, was ich tun soll.');\n    if (withVoice) listen(); else if (!was && matchMedia('(pointer:fine)').matches) inp.focus();\n  };\n  const close = () => { ai.classList.remove('open'); if (listening) try { rec.abort(); } catch(e){} try { speechSynthesis.cancel(); } catch(e){} setState(''); inp.blur(); };\n  $('#aiOrb')?.addEventListener('click', () => open(true));\n  $('#aiBar')?.addEventListener('click', () => open(true));\n  $('#aiX').onclick = close; $('#aiScrim').onclick = close;\n  $('#aiMic').onclick = () => listen();\n  $('#aiForm').onsubmit = e => { e.preventDefault(); send(inp.value, false); };\n  document.querySelectorAll('.ai-chips button').forEach(b => b.onclick = () => send(b.textContent, false));\n  addEventListener('keydown', e => { if (e.key === 'Escape' && ai.classList.contains('open')){ e.stopImmediatePropagation(); close(); } }, true);\n  ['pointerdown', 'wheel', 'keydown', 'touchstart'].forEach(t => ai.addEventListener(t, e => e.stopPropagation()));\n}\n<\u002Fscript>\n\n\n<\u002Fbody><\u002Fhtml>"
  </script>
</body>
</html>";
   var q = new URLSearchParams(location.search).get('v');
   var mobile = q ? q === 'handy' : (matchMedia('(pointer:coarse)').matches && Math.min(screen.width, screen.height) < 820) || innerWidth < 700;
   var bin = atob(mobile ? P : D), u = new Uint8Array(bin.length); for (var i = 0; i < bin.length; i++) u[i] = bin.charCodeAt(i);
-  var f = document.createElement('iframe'); f.allow = 'autoplay; fullscreen; xr-spatial-tracking'; f.setAttribute('allowfullscreen', '');
+  var f = document.createElement('iframe'); f.allow = 'autoplay; fullscreen; xr-spatial-tracking; microphone'; f.setAttribute('allowfullscreen', '');
   f.srcdoc = new TextDecoder().decode(u); document.body.appendChild(f);
   f.onload = function(){ try { f.contentWindow.focus(); } catch(e){} };
 })();