Skip to content

Write HTML. Render video. Built for agents.

65.3 KB
Raw Blame
{"html":"<!doctype html>\n<html\n  lang=\"en\"\n  data-composition-variables='[{\"id\":\"title\",\"type\":\"string\",\"label\":\"Title\",\"default\":\"BREAKTHROUGH\",\"maxLength\":18},{\"id\":\"replacementPhrase\",\"type\":\"string\",\"label\":\"3D replacement phrase (auto layout)\",\"default\":\"Lets do this sir!\",\"description\":\"Every word is preserved. Whole-word line wrapping and type size adapt to the 3D frame.\"},{\"id\":\"phraseDuration\",\"type\":\"number\",\"label\":\"Phrase transition duration (s)\",\"default\":1.85,\"min\":0.65,\"max\":2.9,\"step\":0.05,\"unit\":\"s\",\"description\":\"Total time for the letter transition, including the stagger. Lower is faster. The opening and white return keep their original timing.\"},{\"id\":\"phraseEasing\",\"type\":\"number\",\"label\":\"Transition easing (1 gentle – 8 snap)\",\"default\":8,\"min\":1,\"max\":8,\"step\":0.25,\"description\":\"Higher values keep the beginning slow and concentrate acceleration at the letter swap, then settle gently. 4 is the default.\"},{\"id\":\"settleGlitch\",\"type\":\"number\",\"label\":\"Letter settle glitch strength\",\"default\":0.2,\"min\":0,\"max\":4,\"step\":0.05,\"description\":\"Scales the deterministic block glitch and letter jitter around swap and settling. 0 disables it; 4 makes it strongest.\"},{\"id\":\"depthFog\",\"type\":\"boolean\",\"label\":\"Depth fog (early fade always on)\",\"default\":true,\"description\":\"Dims receding outlines into the dark scene. Early opacity fades remain active when fog is off.\"},{\"id\":\"subtitle\",\"type\":\"string\",\"label\":\"Subtitle\",\"default\":\"HYPERFRAMES PORTAL TITLE\",\"maxLength\":48},{\"id\":\"accent\",\"type\":\"color\",\"label\":\"Accent\",\"default\":\"#F5C518\"},{\"id\":\"burstChaos\",\"type\":\"number\",\"label\":\"Burst chaos (0-2)\",\"default\":1,\"min\":0,\"max\":2,\"step\":0.01}]'\n>\n  <head><base href=\"/public/catalog/items/wireframe-portal-title/\">\n    <meta charset=\"UTF-8\" />\n    <meta name=\"viewport\" content=\"width=1920, height=1080\" />\n    <title>Wireframe Portal Title</title>\n    <script src=\"https://cdn.jsdelivr.net/npm/[email protected]/dist/gsap.min.js\"></script>\n    <script src=\"https://cdn.jsdelivr.net/npm/[email protected]/clipper.js\"></script>\n    <script type=\"importmap\">\n      {\n        \"imports\": {\n          \"three\": \"https://cdn.jsdelivr.net/npm/[email protected]/build/three.module.js\",\n          \"three/addons/\": \"https://cdn.jsdelivr.net/npm/[email protected]/examples/jsm/\"\n        }\n      }\n    </script>\n    <style>\n      @font-face {\n        font-family: \"Geist\";\n        src: url(\"/public/catalog/assets/09af32bab931f1cc.ttf\") format(\"truetype\");\n        font-weight: 400;\n      }\n      @font-face {\n        font-family: \"Geist\";\n        src: url(\"/public/catalog/assets/4c11a19d17e7a608.ttf\") format(\"truetype\");\n        font-weight: 600;\n      }\n      @font-face {\n        font-family: \"Geist\";\n        src: url(\"/public/catalog/assets/f032f37d12e82a37.ttf\") format(\"truetype\");\n        font-weight: 700;\n      }\n      * {\n        margin: 0;\n        padding: 0;\n        box-sizing: border-box;\n      }\n      html,\n      body {\n        margin: 0;\n        width: 1920px;\n        height: 1080px;\n        overflow: hidden;\n        background: #000;\n      }\n      body {\n        font-family: \"Geist\", \"Inter\", system-ui, sans-serif;\n      }\n      #root {\n        position: relative;\n        width: 1920px;\n        height: 1080px;\n        overflow: hidden;\n      }\n      .clip {\n        position: absolute;\n        inset: 0;\n      }\n      /* dark underlay (never on the root itself) */\n      #wpt-under {\n        position: absolute;\n        inset: 0;\n        background: #0b0b0b;\n      }\n      /* ---- flat 2D title card ---- */\n      #wpt-card {\n        position: absolute;\n        inset: 0;\n        background: #e8e8e8;\n        color: #0a0a0a;\n        display: flex;\n        flex-direction: column;\n        align-items: center;\n        justify-content: center;\n      }\n      #wpt-kicker {\n        font-weight: 600;\n        font-size: 22px;\n        letter-spacing: 0;\n        text-indent: 0;\n        color: #1f1f1f;\n        margin-bottom: 34px;\n        display: flex;\n        align-items: center;\n        gap: 18px;\n      }\n      #wpt-headline {\n        font-weight: 700;\n        font-size: 176px;\n        line-height: 1;\n        letter-spacing: 0.03em;\n        white-space: nowrap;\n        color: #0a0a0a;\n      }\n      #wpt-headline span {\n        display: inline-block;\n      }\n      #wpt-subtitle {\n        margin-top: 40px;\n        font-weight: 400;\n        font-size: 34px;\n        letter-spacing: 0.02em;\n        color: #3d3d3d;\n      }\n      /* ---- canvas layers (intentionally cover the 2D card once the portal opens) ---- */\n      #wpt-three,\n      #wpt-warp {\n        position: absolute;\n        inset: 0;\n        width: 1920px;\n        height: 1080px;\n        display: block;\n      }\n      #wpt-white {\n        position: absolute;\n        inset: 0;\n        background: #ffffff;\n        opacity: 0;\n        display: flex;\n        align-items: center;\n        justify-content: center;\n      }\n    </style>\n  </head>\n  <body>\n    <div\n      data-hf-id=\"hf-ek69\"\n      id=\"root\"\n      data-composition-id=\"wireframe-portal-title\"\n      data-start=\"0\"\n      data-duration=\"8\"\n      data-width=\"1920\"\n      data-height=\"1080\"\n    >\n      <section\n        data-hf-id=\"hf-50tz\"\n        id=\"wpt-scene\"\n        class=\"clip\"\n        data-start=\"0\"\n        data-duration=\"8\"\n        data-track-index=\"1\"\n      >\n        <div data-hf-id=\"hf-6av1\" id=\"wpt-under\"></div>\n\n        <div data-hf-id=\"hf-r32l\" id=\"wpt-card\" data-layout-allow-occlusion=\"\">\n          <div data-hf-id=\"hf-0bgu\" id=\"wpt-kicker\">\n            <span data-hf-id=\"hf-m027\" id=\"wpt-kicker-text\">HYPERFRAMES PRESENTS</span>\n          </div>\n          <h1 data-hf-id=\"hf-pwyf\" id=\"wpt-headline\"></h1>\n          <div data-hf-id=\"hf-jivp\" id=\"wpt-subtitle\"></div>\n        </div>\n\n        <div data-hf-id=\"hf-dugk\" id=\"wpt-white\" data-layout-allow-occlusion=\"\"></div>\n      </section>\n    </div>\n\n    <script>\n      // ---- variables (safe fallback when API absent) ----\n      (function () {\n        var vars = {};\n        try {\n          if (window.__hyperframes && window.__hyperframes.getVariables) {\n            vars = window.__hyperframes.getVariables() || {};\n          }\n        } catch (e) {}\n        var title =\n          String(vars.title || \"BREAKTHROUGH\")\n            .trim()\n            .toUpperCase() || \"BREAKTHROUGH\";\n        var subtitle = String(vars.subtitle || \"HYPERFRAMES PORTAL TITLE\");\n        // Preserve every word. The 3D layout wraps whole words and scales to fit.\n        window.__wptPhrase =\n          String(vars.replacementPhrase || \"BEYOND LIMITS\")\n            .trim()\n            .toUpperCase()\n            .replace(/\\s+/g, \" \") || \"BEYOND LIMITS\";\n        function numberVar(id, fallback, min, max) {\n          var value = vars[id] === undefined ? fallback : Number(vars[id]);\n          return isFinite(value) ? Math.max(min, Math.min(max, value)) : fallback;\n        }\n        window.__wptTransition = {\n          start: 2.85,\n          duration: numberVar(\"phraseDuration\", 1.85, 0.65, 2.9),\n          easing: numberVar(\"phraseEasing\", 4, 1, 8),\n          glitch: numberVar(\"settleGlitch\", 1, 0, 4),\n          fog: vars.depthFog !== false,\n        };\n        var accent = String(vars.accent || \"#F5C518\");\n        document.documentElement.style.setProperty(\"--wpt-accent\", accent);\n        window.__wptAccent = accent;\n        var bc = Number(vars.burstChaos);\n        window.__wptBurstChaos = isFinite(bc) ? Math.max(0, Math.min(2, bc)) : 1;\n\n        function fillHeadline(id, text, prefix) {\n          var hl = document.getElementById(id);\n          for (var i = 0; i < text.length; i++) {\n            var ch = text[i];\n            var span = document.createElement(\"span\");\n            if (ch === \" \") {\n              span.innerHTML = \"&nbsp;\";\n            } else {\n              span.textContent = ch;\n              span.setAttribute(\"data-3d-char\", prefix + i);\n            }\n            hl.appendChild(span);\n          }\n        }\n        fillHeadline(\"wpt-headline\", title, \"t-\");\n        document.getElementById(\"wpt-subtitle\").textContent = subtitle;\n        // Runtime canvases keep the Studio variables parser intact.\n        [\"wpt-three\", \"wpt-warp\"].forEach(function (id) {\n          var canvas = document.createElement(\"canvas\");\n          canvas.id = id;\n          canvas.width = 1920;\n          canvas.height = 1080;\n          document\n            .getElementById(\"wpt-scene\")\n            .insertBefore(canvas, document.getElementById(\"wpt-white\"));\n        });\n      })();\n    </script>\n\n    <script>\n      // ---- state proxy + single paused timeline ----\n      window.__timelines = window.__timelines || {};\n      const S = {\n        portal: 0, // 0 = flat 2D page, 1 = 3D wireframe world\n        push: 0, // exit camera push through the letterforms\n        glitch: 0, // block-glitch tick amount\n        warp: 0, // warp-dot visibility\n        travel: 0, // warp-dot accumulated z travel (world units)\n        exitFx: 0, // zoom-blur / brightness lift on the way out\n      };\n      window.__wptState = S;\n\n      const tl = gsap.timeline({ paused: true });\n\n      // IN — the flat 2D card settles first (the 3D module measures letter\n      // positions via offset* geometry, so these transforms don't skew it)\n      tl.from(\"#wpt-kicker\", { y: -24, opacity: 0, duration: 0.45, ease: \"power3.out\" }, 0);\n      tl.from(\n        \"#wpt-headline span\",\n        { y: 44, opacity: 0, duration: 0.5, stagger: 0.025, ease: \"power3.out\" },\n        0.03,\n      );\n      tl.from(\"#wpt-subtitle\", { y: 18, opacity: 0, duration: 0.45, ease: \"power3.out\" }, 0.22);\n\n      // IN — portal irises open (p = 0.5 around t ~= 1.47s)\n      tl.to(S, { portal: 1, duration: 2.05, ease: \"power2.inOut\" }, 0.45);\n      // The 3D layer owns the copy by now. Keep the original card background\n      // under the portal feather, while retiring its covered DOM text.\n      tl.set([\"#wpt-headline\", \"#wpt-kicker\", \"#wpt-subtitle\"], { autoAlpha: 0 }, 2.5);\n\n      // warp dots: burst through the transition, settle to a slow stream in the hold\n      tl.to(S, { warp: 1, duration: 1.0, ease: \"sine.in\" }, 0.45);\n      tl.to(S, { warp: 0.28, duration: 1.2, ease: \"sine.out\" }, 1.5);\n      tl.to(S, { warp: 0.85, duration: 0.8, ease: \"power1.in\" }, 6.0);\n      tl.to(S, { travel: 16, duration: 2.05, ease: \"sine.inOut\" }, 0.45);\n      tl.to(S, { travel: 22, duration: 3.5, ease: \"none\" }, 2.5);\n      tl.to(S, { travel: 38, duration: 2.0, ease: \"power2.in\" }, 6.0);\n\n      // faint glitch ticks on two beats\n      tl.to(S, { glitch: 0.55, duration: 0.09, ease: \"power1.in\" }, 3.8);\n      tl.to(S, { glitch: 0, duration: 0.24, ease: \"power2.out\" }, 3.89);\n      tl.to(S, { glitch: 0.55, duration: 0.09, ease: \"power1.in\" }, 5.2);\n      tl.to(S, { glitch: 0, duration: 0.24, ease: \"power2.out\" }, 5.29);\n\n      // OUT — camera pushes through and past the letterforms, frame lifts to white\n      tl.to(S, { push: 1, duration: 1.6, ease: \"power2.in\" }, 6.0);\n      tl.to(S, { exitFx: 1, duration: 1.6, ease: \"power2.in\" }, 6.4);\n      tl.to(\"#wpt-white\", { opacity: 1, duration: 0.95, ease: \"sine.inOut\" }, 6.9);\n      // The white plate is intentionally empty and fully opaque for the last hold.\n      tl.addLabel(\"light-card\", 0.8);\n      tl.addLabel(\"portal-alignment\", 1.47);\n      tl.addLabel(\n        \"phrase-handoff\",\n        window.__wptTransition.start + window.__wptTransition.duration * 0.6,\n      );\n      tl.addLabel(\"phrase-hold\", window.__wptTransition.start + window.__wptTransition.duration);\n      tl.addLabel(\"white-empty\", 7.9);\n\n      tl.eventCallback(\"onUpdate\", function () {\n        if (window.__wptRender) window.__wptRender(tl.time());\n      });\n      /* Studio's player seeks with GSAP events suppressed and dispatches an\n         hf-seek CustomEvent instead — re-sync and repaint so the stage follows. */\n      window.addEventListener(\"hf-seek\", function (event) {\n        var d = event && event.detail;\n        if (d && typeof d.time === \"number\")\n          tl.totalTime(Math.min(d.time, tl.totalDuration()), true);\n        var fn = tl.eventCallback(\"onUpdate\");\n        if (fn) fn();\n      });\n\n      window.__timelines[\"wireframe-portal-title\"] = tl;\n    </script>\n\n    <script type=\"module\">\n      import * as THREE from \"three\";\n      import { FontLoader } from \"three/addons/loaders/FontLoader.js\";\n      import { TTFLoader } from \"three/addons/loaders/TTFLoader.js\";\n      import { EffectComposer } from \"three/addons/postprocessing/EffectComposer.js\";\n      import { RenderPass } from \"three/addons/postprocessing/RenderPass.js\";\n      import { ShaderPass } from \"three/addons/postprocessing/ShaderPass.js\";\n      import { OutputPass } from \"three/addons/postprocessing/OutputPass.js\";\n      import { LineSegments2 } from \"three/addons/lines/LineSegments2.js\";\n      import { LineSegmentsGeometry } from \"three/addons/lines/LineSegmentsGeometry.js\";\n      import { LineMaterial } from \"three/addons/lines/LineMaterial.js\";\n\n      // ---------- seeded PRNG (replaces the experiment's Math.random) ----------\n      function mulberry32(a) {\n        return function () {\n          a |= 0;\n          a = (a + 0x6d2b79f5) | 0;\n          let t = Math.imul(a ^ (a >>> 15), 1 | a);\n          t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;\n          return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n        };\n      }\n      const rand = mulberry32(20260824);\n      const phraseRand = mulberry32(20260831);\n\n      // ---------- params (preset 31 defaults from the experiment config) ----------\n      const P = {\n        gridLineColor: \"#ffffff\",\n        gridSpacing: 29,\n        gridSize: 500,\n        gridOpacity: 0.15,\n        gridFadeStart: 1,\n        gridFadeEnd: 175,\n        gridOffsetX: -14.5,\n        gridGlowSpeed: 8.7,\n        gridGlowIntensity: 1.3,\n        textDepthMin: 0.28,\n        textDepthMax: 2,\n        letterZSpread: 4, // experiment: 9 — tightened so perspective shifts don't split the word or crop the frame\n        outlineColor: \"#ffffff\",\n        outlineWidth: 1.5,\n        starburstPoints: 24,\n        portalChromatic: 0,\n        portalEdgeBlur: 0.15,\n        portalIrregularity: window.__wptBurstChaos !== undefined ? window.__wptBurstChaos : 1,\n        portalStartColor: \"#e8e8e8\",\n        portalScale: 0.8,\n        portalColorSpeed: 1.7,\n        warpDotCount: 1000,\n        warpDotSize: 2,\n        warpDotOpacity: 0.7,\n        warpDotColor: \"#888888\",\n        transChromatic: 0.01,\n        transZoomBlur: 3.2,\n        transDistortion: 0.05,\n        transBrightness: 1.6,\n        transContrast: 1.25,\n        transSaturation: 0,\n        cameraDistance: 22,\n        initialFOV: 100,\n        cameraDistance3D: 66, // pulled back from the experiment's 48.5 so the full word composes in-frame at 1920x1080\n        finalFOV: 72,\n        contentZOffset: 30,\n        vignetteIntensity: 1.7,\n        chromaticAberration: 0.006,\n        scanlineIntensity: 0.25,\n        edgeBlur: 50,\n        edgeBlurSpread: 0.15,\n        glitchPower: 0.2,\n        glitchSpeed: 3,\n        glitchBlockSize: 15,\n        glitchColorRate: 0.009,\n        ambientIntensity: 0.5,\n        keyLightIntensity: 4.25,\n        keyLightX: 2,\n        keyLightY: -2.5,\n        keyLightZ: 4.5,\n        bgColor: \"#000000\",\n      };\n      const W = 1920;\n      const H = 1080;\n      const ACCENT = window.__wptAccent || \"#F5C518\";\n\n      // ---------- shaders (ported verbatim from the experiment) ----------\n      const PortalCompositeShader = {\n        uniforms: {\n          tDiffuse: { value: null },\n          uPortalRadius: { value: 0.0 },\n          uPortalCenter: { value: new THREE.Vector2(0.5, 0.5) },\n          uStarburstPoints: { value: P.starburstPoints },\n          uChromaticStrength: { value: P.portalChromatic },\n          uEdgeBlur: { value: P.portalEdgeBlur },\n          uIrregularity: { value: P.portalIrregularity },\n          uStartColor: { value: new THREE.Color(P.portalStartColor) },\n          uPortalProgress: { value: 0.0 },\n          uTime: { value: 0 },\n          uOuterBlur: { value: 0.0 },\n        },\n        vertexShader: `\n          varying vec2 vUv;\n          void main() {\n            vUv = uv;\n            gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n          }\n        `,\n        fragmentShader: `\n          uniform sampler2D tDiffuse;\n          uniform float uPortalRadius;\n          uniform vec2 uPortalCenter;\n          uniform int uStarburstPoints;\n          uniform float uChromaticStrength;\n          uniform float uEdgeBlur;\n          uniform float uIrregularity;\n          uniform vec3 uStartColor;\n          uniform float uPortalProgress;\n          uniform float uTime;\n          uniform float uOuterBlur;\n          varying vec2 vUv;\n\n          float hash(float n) { return fract(sin(n) * 43758.5453); }\n\n          void main() {\n            vec2 uv = vUv;\n            vec2 center = uPortalCenter;\n            vec2 delta = uv - center;\n            float dist = length(delta);\n            float angle = atan(delta.y, delta.x);\n\n            float points = float(uStarburstPoints);\n            float spikeLength = 0.2 * uPortalRadius;\n            float valleyDepth = 0.08 * uPortalRadius;\n            float baseR = uPortalRadius - valleyDepth;\n\n            float seed = floor(uTime * 0.4) * 7.13;\n\n            // Low-frequency undulation: the base ellipse itself wobbles.\n            float wob = sin(angle * 2.0 + seed * 1.7)\n                      * 0.45 + sin(angle * 3.0 - seed * 2.3 + 1.9) * 0.33\n                      + sin(angle * 5.0 + seed * 0.9 + 4.2) * 0.22;\n            baseR *= 1.0 + wob * 0.16 * uIrregularity;\n\n            // Warp the angle before segmenting: spikes cluster and gap\n            // instead of sitting on an even sunburst lattice.\n            float aw = angle\n                     + (sin(angle * 3.0 + seed + 0.7) * 0.55\n                      + sin(angle * 5.0 - seed * 1.3 + 2.3) * 0.35)\n                       * 0.45 * uIrregularity;\n\n            float segAngle = 6.28318 / points;\n            float localAngle = mod(aw + 3.14159, segAngle);\n            float segIndex = floor((aw + 3.14159) / segAngle);\n\n            float t = localAngle / segAngle;\n\n            // Per-spike character: off-centre tips, fat-to-needle sharpness,\n            // broad length spread with occasional dominant spikes.\n            float h1 = hash(segIndex * 17.3 + seed);\n            float h2 = hash(segIndex * 31.7 + seed + 5.1);\n            float h3 = hash(segIndex * 47.9 + seed + 9.7);\n            float tip = mix(0.5, mix(0.2, 0.8, h2), min(uIrregularity, 1.0));\n            float spike = t < tip ? t / max(tip, 1e-3)\n                                  : (1.0 - t) / max(1.0 - tip, 1e-3);\n            spike = pow(clamp(spike, 0.0, 1.0),\n                        mix(1.0, mix(0.55, 3.2, h3), min(uIrregularity, 1.0)));\n            float lenVar = mix(0.35, 1.15, h1) + pow(h2, 6.0) * 1.8;\n            float spikeScale = mix(1.0, lenVar, min(uIrregularity, 1.5));\n\n            float thisSpike = spike * spikeLength * spikeScale;\n            float starShape = baseR + thisSpike;\n\n            float feather = max(0.002, uEdgeBlur);\n            float mask = smoothstep(starShape + feather, starShape - feather, dist);\n\n            if (mask < 0.001) {\n              gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);\n              return;\n            }\n\n            float edgeDist = abs(dist - starShape);\n            float edgeFactor = smoothstep(feather * 3.0, 0.0, edgeDist) * uChromaticStrength;\n            vec2 chrDir = normalize(delta + 0.001) * edgeFactor;\n\n            float r = texture2D(tDiffuse, uv + chrDir).r;\n            float g = texture2D(tDiffuse, uv).g;\n            float b = texture2D(tDiffuse, uv - chrDir).b;\n            vec3 sceneColor = vec3(r, g, b);\n\n            gl_FragColor = vec4(sceneColor, mask);\n          }\n        `,\n      };\n\n      const TransitionFXShader = {\n        uniforms: {\n          tDiffuse: { value: null },\n          uTransAmount: { value: 0.0 },\n          uChromatic: { value: P.transChromatic },\n          uZoomBlur: { value: P.transZoomBlur },\n          uDistortion: { value: P.transDistortion },\n          uBrightness: { value: P.transBrightness },\n          uContrast: { value: P.transContrast },\n          uSaturation: { value: P.transSaturation },\n        },\n        vertexShader: `\n          varying vec2 vUv;\n          void main() {\n            vUv = uv;\n            gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n          }\n        `,\n        fragmentShader: `\n          uniform sampler2D tDiffuse;\n          uniform float uTransAmount;\n          uniform float uChromatic;\n          uniform float uZoomBlur;\n          uniform float uDistortion;\n          uniform float uBrightness;\n          uniform float uContrast;\n          uniform float uSaturation;\n          varying vec2 vUv;\n\n          void main() {\n            if (uTransAmount < 0.001) {\n              gl_FragColor = texture2D(tDiffuse, vUv);\n              return;\n            }\n\n            vec2 uv = vUv;\n            vec2 center = uv - 0.5;\n            float dist = length(center);\n\n            vec2 distortedUV = uv + center * dist * dist * uDistortion * uTransAmount;\n            distortedUV = clamp(distortedUV, 0.0, 1.0);\n\n            vec3 color = vec3(0.0);\n            float totalWeight = 0.0;\n            float blurAmount = uZoomBlur * uTransAmount * 0.1;\n            for (int i = 0; i < 10; i++) {\n              float t = float(i) / 9.0;\n              float weight = 1.0 - t * 0.6;\n              vec2 sampleUV = clamp(distortedUV + center * blurAmount * t, 0.0, 1.0);\n              color += texture2D(tDiffuse, sampleUV).rgb * weight;\n              totalWeight += weight;\n            }\n            color /= totalWeight;\n\n            float caAmount = uChromatic * uTransAmount;\n            vec2 caDir = normalize(center + 0.001) * caAmount;\n            color.r = mix(color.r, texture2D(tDiffuse, clamp(distortedUV + caDir, 0.0, 1.0)).r, uTransAmount);\n            color.b = mix(color.b, texture2D(tDiffuse, clamp(distortedUV - caDir, 0.0, 1.0)).b, uTransAmount);\n\n            float brightness = mix(1.0, uBrightness, uTransAmount);\n            color *= brightness;\n\n            float contrast = mix(1.0, uContrast, uTransAmount);\n            color = (color - 0.5) * contrast + 0.5;\n\n            float saturation = mix(1.0, uSaturation, uTransAmount);\n            float lum = dot(color, vec3(0.299, 0.587, 0.114));\n            color = mix(vec3(lum), color, saturation);\n\n            gl_FragColor = vec4(clamp(color, 0.0, 1.0), texture2D(tDiffuse, uv).a);\n          }\n        `,\n      };\n\n      const GlitchShader = {\n        uniforms: {\n          tDiffuse: { value: null },\n          uTime: { value: 0 },\n          uShakePower: { value: 0.0 },\n          uShakeRate: { value: 0.0 },\n          uShakeSpeed: { value: P.glitchSpeed },\n          uShakeBlockSize: { value: P.glitchBlockSize },\n          uShakeColorRate: { value: 0.0 },\n        },\n        vertexShader: `\n          varying vec2 vUv;\n          void main() {\n            vUv = uv;\n            gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n          }\n        `,\n        fragmentShader: `\n          uniform sampler2D tDiffuse;\n          uniform float uTime;\n          uniform float uShakePower;\n          uniform float uShakeRate;\n          uniform float uShakeSpeed;\n          uniform float uShakeBlockSize;\n          uniform float uShakeColorRate;\n          varying vec2 vUv;\n\n          float random(float seed) {\n            return fract(543.2543 * sin(dot(vec2(seed, seed), vec2(3525.46, -54.3415))));\n          }\n\n          void main() {\n            float enable_shift = float(\n              random(trunc(uTime * uShakeSpeed)) < uShakeRate\n            );\n\n            vec2 fixed_uv = vUv;\n            fixed_uv.x += (\n              random(\n                (trunc(vUv.y * uShakeBlockSize) / uShakeBlockSize) + uTime\n              ) - 0.5\n            ) * uShakePower * enable_shift;\n\n            vec4 pixel_color = texture2D(tDiffuse, fixed_uv);\n            pixel_color.r = mix(\n              pixel_color.r,\n              texture2D(tDiffuse, fixed_uv + vec2(uShakeColorRate, 0.0)).r,\n              enable_shift\n            );\n            pixel_color.b = mix(\n              pixel_color.b,\n              texture2D(tDiffuse, fixed_uv + vec2(-uShakeColorRate, 0.0)).b,\n              enable_shift\n            );\n\n            gl_FragColor = pixel_color;\n          }\n        `,\n      };\n\n      const EdgeBlurShader = {\n        uniforms: {\n          tDiffuse: { value: null },\n          uDirection: { value: new THREE.Vector2(1, 0) },\n          uBlurAmount: { value: 0.0 },\n          uSpread: { value: P.edgeBlurSpread },\n          uResolution: { value: new THREE.Vector2(W, H) },\n        },\n        vertexShader: `\n          varying vec2 vUv;\n          void main() {\n            vUv = uv;\n            gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n          }\n        `,\n        fragmentShader: `\n          uniform sampler2D tDiffuse;\n          uniform vec2 uDirection;\n          uniform float uBlurAmount;\n          uniform float uSpread;\n          uniform vec2 uResolution;\n          varying vec2 vUv;\n\n          void main() {\n            vec2 center = vUv - 0.5;\n            float dist = length(center);\n            float blurStart = (1.0 - uSpread) * 0.5;\n            float edgeFactor = smoothstep(blurStart, blurStart + 0.3, dist);\n            float radius = edgeFactor * uBlurAmount;\n\n            if (radius < 0.5) {\n              gl_FragColor = texture2D(tDiffuse, vUv);\n              return;\n            }\n\n            vec2 texelSize = 1.0 / uResolution;\n            vec2 step = uDirection * texelSize * radius;\n\n            vec4 result = vec4(0.0);\n            result += texture2D(tDiffuse, vUv - step * 6.0) * 0.002;\n            result += texture2D(tDiffuse, vUv - step * 5.0) * 0.009;\n            result += texture2D(tDiffuse, vUv - step * 4.0) * 0.028;\n            result += texture2D(tDiffuse, vUv - step * 3.0) * 0.066;\n            result += texture2D(tDiffuse, vUv - step * 2.0) * 0.121;\n            result += texture2D(tDiffuse, vUv - step * 1.0) * 0.175;\n            result += texture2D(tDiffuse, vUv)               * 0.198;\n            result += texture2D(tDiffuse, vUv + step * 1.0) * 0.175;\n            result += texture2D(tDiffuse, vUv + step * 2.0) * 0.121;\n            result += texture2D(tDiffuse, vUv + step * 3.0) * 0.066;\n            result += texture2D(tDiffuse, vUv + step * 4.0) * 0.028;\n            result += texture2D(tDiffuse, vUv + step * 5.0) * 0.009;\n            result += texture2D(tDiffuse, vUv + step * 6.0) * 0.002;\n\n            gl_FragColor = result;\n          }\n        `,\n      };\n\n      const PostFXShader = {\n        uniforms: {\n          tDiffuse: { value: null },\n          uVignetteIntensity: { value: 0.0 },\n          uChromaticAberration: { value: 0.0 },\n          uScanlineIntensity: { value: 0.0 },\n          uTime: { value: 0.0 },\n        },\n        vertexShader: `\n          varying vec2 vUv;\n          void main() {\n            vUv = uv;\n            gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n          }\n        `,\n        fragmentShader: `\n          uniform sampler2D tDiffuse;\n          uniform float uVignetteIntensity;\n          uniform float uChromaticAberration;\n          uniform float uScanlineIntensity;\n          uniform float uTime;\n          varying vec2 vUv;\n\n          void main() {\n            vec2 uv = vUv;\n            vec2 center = uv - 0.5;\n            float dist = length(center);\n            float dist2 = dot(center, center);\n\n            float edgeFactor = smoothstep(0.2, 0.6, dist);\n            float caStrength = uChromaticAberration * edgeFactor;\n            vec2 caDir = normalize(center + 0.001) * caStrength;\n            vec3 color;\n            color.r = texture2D(tDiffuse, clamp(uv + caDir, 0.0, 1.0)).r;\n            color.g = texture2D(tDiffuse, uv).g;\n            color.b = texture2D(tDiffuse, clamp(uv - caDir, 0.0, 1.0)).b;\n\n            float scanline = sin(uv.y * 800.0 + uTime * 2.0) * 0.5 + 0.5;\n            scanline = pow(scanline, 8.0) * uScanlineIntensity;\n            color -= scanline * 0.08;\n            float noiseLine = fract(sin(floor(uv.y * 400.0 + uTime * 5.0) * 43758.5453)) * uScanlineIntensity * 0.03;\n            color += noiseLine;\n\n            float vignette = 1.0 - dist2 * uVignetteIntensity;\n            vignette = smoothstep(0.0, 0.5, clamp(vignette, 0.0, 1.0));\n            color *= vignette;\n\n            gl_FragColor = vec4(color, texture2D(tDiffuse, uv).a);\n          }\n        `,\n      };\n\n      const GridLineShader = {\n        uniforms: {\n          uColor: { value: new THREE.Color(P.gridLineColor) },\n          uOpacity: { value: P.gridOpacity },\n          uFadeStart: { value: P.gridFadeStart },\n          uFadeEnd: { value: P.gridFadeEnd },\n          uCameraPos: { value: new THREE.Vector3() },\n          uTime: { value: 0.0 },\n          uGlowSpeed: { value: P.gridGlowSpeed },\n          uGlowIntensity: { value: P.gridGlowIntensity },\n        },\n        vertexShader: `\n          varying vec3 vWorldPos;\n          void main() {\n            vec4 worldPos = modelMatrix * vec4(position, 1.0);\n            vWorldPos = worldPos.xyz;\n            gl_Position = projectionMatrix * viewMatrix * worldPos;\n          }\n        `,\n        fragmentShader: `\n          uniform vec3 uColor;\n          uniform float uOpacity;\n          uniform float uFadeStart;\n          uniform float uFadeEnd;\n          uniform vec3 uCameraPos;\n          uniform float uTime;\n          uniform float uGlowSpeed;\n          uniform float uGlowIntensity;\n          varying vec3 vWorldPos;\n\n          float hash(float n) { return fract(sin(n) * 43758.5453); }\n\n          void main() {\n            float dist = distance(vWorldPos, uCameraPos);\n            float fade = 1.0 - smoothstep(uFadeStart, uFadeEnd, dist);\n            if (fade < 0.01) discard;\n\n            float dotGlow = 0.0;\n            float dotRadius = 0.4;\n\n            for (int d = 0; d < 5; d++) {\n              float di = float(d);\n              float seedX = hash(floor(vWorldPos.y * 10.0) * 137.0 + floor(vWorldPos.z * 10.0) * 311.0 + di * 73.0);\n              float dotPosX = mod(uTime * uGlowSpeed * (0.5 + seedX * 2.0) + seedX * 200.0, 300.0) - 150.0;\n              dotGlow += exp(-pow((vWorldPos.x - dotPosX) / dotRadius, 2.0)) * 0.5;\n\n              float seedY = hash(floor(vWorldPos.x * 10.0) * 173.0 + floor(vWorldPos.z * 10.0) * 271.0 + di * 91.0);\n              float dotPosY = mod(uTime * uGlowSpeed * (0.5 + seedY * 2.0) + seedY * 200.0, 300.0) - 150.0;\n              dotGlow += exp(-pow((vWorldPos.y - dotPosY) / dotRadius, 2.0)) * 0.5;\n\n              float seedZ = hash(floor(vWorldPos.x * 10.0) * 251.0 + floor(vWorldPos.y * 10.0) * 197.0 + di * 59.0);\n              float dotPosZ = mod(uTime * uGlowSpeed * (0.5 + seedZ * 2.0) + seedZ * 200.0, 300.0) - 150.0;\n              dotGlow += exp(-pow((vWorldPos.z - dotPosZ) / dotRadius, 2.0)) * 0.5;\n            }\n\n            dotGlow *= uGlowIntensity;\n\n            float finalAlpha = (uOpacity + dotGlow) * fade;\n            vec3 finalColor = uColor * (1.0 + dotGlow * 3.0);\n\n            gl_FragColor = vec4(finalColor, min(finalAlpha, 1.0));\n          }\n        `,\n      };\n\n      // ---------- font: local Geist Bold TTF -> three Font (blocks the load event) ----------\n      // Beside this file when mounted; a runtime without assetUrl keeps the plain path.\n      const assetUrl = (path) =>\n        typeof __hyperframes !== \"undefined\" && __hyperframes.assetUrl\n          ? __hyperframes.assetUrl(path)\n          : path;\n      const ttfBuffer = await fetch(assetUrl(\"/public/catalog/assets/f032f37d12e82a37.ttf\")).then((r) =>\n        r.arrayBuffer(),\n      );\n      const font = new FontLoader().parse(new TTFLoader().parse(ttfBuffer));\n      try {\n        await document.fonts.ready; // DOM letter rects must be measured with the real font\n      } catch (e) {}\n\n      // Shrink the DOM headline if a long title overflows, BEFORE measuring spans\n      for (const id of [\"wpt-headline\"]) {\n        const el = document.getElementById(id);\n        if (el.scrollWidth > 1760) {\n          el.style.fontSize = Math.floor(176 * (1760 / el.scrollWidth)) + \"px\";\n        }\n      }\n\n      // ---------- renderer / scenes / camera ----------\n      const canvas = document.getElementById(\"wpt-three\");\n      const renderer = new THREE.WebGLRenderer({\n        canvas,\n        antialias: true,\n        alpha: true,\n        stencil: true,\n        preserveDrawingBuffer: true, // audit pixel-hashing + deterministic capture read the buffer back\n      });\n      renderer.setSize(W, H, false);\n      renderer.setPixelRatio(1);\n      renderer.setClearColor(0x000000, 0);\n      renderer.toneMapping = THREE.NoToneMapping;\n\n      const scene = new THREE.Scene();\n      const gridScene = new THREE.Scene();\n      const camera = new THREE.PerspectiveCamera(P.initialFOV, W / H, 0.1, 500);\n      camera.position.set(0, 0, P.cameraDistance);\n      camera.lookAt(0, 0, 0);\n\n      // Lighting (for the floating extruded shapes)\n      scene.add(new THREE.AmbientLight(0xffffff, P.ambientIntensity));\n      const dirLight = new THREE.DirectionalLight(0xffffff, P.keyLightIntensity);\n      dirLight.position.set(P.keyLightX, P.keyLightY, P.keyLightZ);\n      scene.add(dirLight);\n\n      // ---------- background plane + volumetric glow-dot grid ----------\n      const bgPlaneMat = new THREE.MeshBasicMaterial({\n        color: P.portalStartColor,\n        side: THREE.DoubleSide,\n      });\n      const bgPlane = new THREE.Mesh(new THREE.PlaneGeometry(500, 500), bgPlaneMat);\n      bgPlane.position.z = -100;\n      bgPlane.renderOrder = -10;\n      gridScene.add(bgPlane);\n\n      const gridPositions = [];\n      {\n        const count = Math.floor(P.gridSize / P.gridSpacing);\n        const he = P.gridSize;\n        for (let a = -count; a <= count; a++) {\n          for (let b = -count; b <= count; b++) {\n            const ca = a * P.gridSpacing;\n            const cb = b * P.gridSpacing;\n            gridPositions.push(-he, ca, cb, he, ca, cb);\n            gridPositions.push(ca, -he, cb, ca, he, cb);\n            gridPositions.push(ca, cb, -he, ca, cb, he);\n          }\n        }\n      }\n      const gridGeo = new THREE.BufferGeometry();\n      gridGeo.setAttribute(\"position\", new THREE.Float32BufferAttribute(gridPositions, 3));\n      const gridMat = new THREE.ShaderMaterial({\n        uniforms: THREE.UniformsUtils.clone(GridLineShader.uniforms),\n        vertexShader: GridLineShader.vertexShader,\n        fragmentShader: GridLineShader.fragmentShader,\n        transparent: true,\n        depthWrite: false,\n      });\n      const gridLines = new THREE.LineSegments(gridGeo, gridMat);\n      gridLines.position.x = P.gridOffsetX;\n      gridLines.visible = false;\n      gridScene.add(gridLines);\n\n      // ---------- floating extruded triangles (experiment's decorative shapes) ----------\n      function triangleShape(size) {\n        const shape = new THREE.Shape();\n        const h = (size * Math.sqrt(3)) / 2;\n        shape.moveTo(0, h * 0.66);\n        shape.lineTo(-size / 2, -h * 0.33);\n        shape.lineTo(size / 2, -h * 0.33);\n        shape.closePath();\n        return shape;\n      }\n      const floatingShapes = [];\n      const shapeConfigs = [\n        { size: 1.8, basePos: [-8, 5, 2], color: ACCENT },\n        { size: 1.4, basePos: [7, -3, 1], color: ACCENT },\n        { size: 1.0, basePos: [-6, -6, 3], color: \"#1a1a1a\" },\n        { size: 1.2, basePos: [9, 6, 2], color: ACCENT },\n      ];\n      for (const cfg of shapeConfigs) {\n        const geo = new THREE.ExtrudeGeometry(triangleShape(cfg.size), {\n          depth: 0.3,\n          bevelEnabled: true,\n          bevelThickness: 0.02,\n          bevelSize: 0.02,\n          bevelSegments: 2,\n        });\n        geo.center();\n        const mesh = new THREE.Mesh(\n          geo,\n          new THREE.MeshStandardMaterial({ color: cfg.color, roughness: 0.4, metalness: 0.1 }),\n        );\n        mesh.position.set(cfg.basePos[0], cfg.basePos[1], cfg.basePos[2]);\n        mesh.userData.basePos = new THREE.Vector3(...cfg.basePos);\n        scene.add(mesh);\n        floatingShapes.push(mesh);\n      }\n\n      // ---------- 3D page content: extruded letters + flat outlined lines ----------\n      const contentGroup = new THREE.Group();\n      contentGroup.visible = false;\n      scene.add(contentGroup);\n      const textMeshes = [];\n\n      // Screen px -> world units at the 2D camera (FOV 100, z 22)\n      const fovRad = (P.initialFOV * Math.PI) / 180;\n      const visH = 2 * P.cameraDistance * Math.tan(fovRad / 2);\n      const visW = visH * (W / H);\n      function rectToWorld(r) {\n        return {\n          x: ((r.left + r.width / 2) / W - 0.5) * visW,\n          y: (0.5 - (r.top + r.height / 2) / H) * visH,\n          w: (r.width / W) * visW,\n          h: (r.height / H) * visH,\n        };\n      }\n      // Transform-immune element rect (GSAP intro tweens offset elements at t=0)\n      function offsetRect(el) {\n        let left = el.offsetLeft;\n        let top = el.offsetTop;\n        let node = el.offsetParent;\n        while (node && node.id !== \"wpt-card\" && node !== document.body) {\n          left += node.offsetLeft;\n          top += node.offsetTop;\n          node = node.offsetParent;\n        }\n        return { left, top, width: el.offsetWidth, height: el.offsetHeight };\n      }\n      const lineResolution = new THREE.Vector2(W, H);\n\n      // Geist glyphs contain self-overlapping junction notches (fine for nonzero-winding\n      // browser fills, fatal for extrusion triangulation + EdgesGeometry). Resolve the\n      // overlaps with a nonzero polygon union before extruding.\n      function cleanShapes(shapes) {\n        const SC = 1000;\n        const cleaned = [];\n        for (const shape of shapes) {\n          const pts = shape.extractPoints(12);\n          const paths = [pts.shape, ...pts.holes].map((ring) =>\n            ring.map((p) => ({ X: Math.round(p.x * SC), Y: Math.round(p.y * SC) })),\n          );\n          let simp;\n          try {\n            simp = ClipperLib.Clipper.SimplifyPolygons(paths, ClipperLib.PolyFillType.pftNonZero);\n          } catch (e) {\n            cleaned.push(shape);\n            continue;\n          }\n          const outerRings = [];\n          const holeRings = [];\n          for (const ring of simp) {\n            if (ring.length < 3) continue;\n            (ClipperLib.Clipper.Orientation(ring) ? outerRings : holeRings).push(ring);\n          }\n          const outShapes = outerRings.map(\n            (r) => new THREE.Shape(r.map((p) => new THREE.Vector2(p.X / SC, p.Y / SC))),\n          );\n          for (const hr of holeRings) {\n            let owner = outShapes[0];\n            for (let oi = 0; oi < outerRings.length; oi++) {\n              if (ClipperLib.Clipper.PointInPolygon(hr[0], outerRings[oi]) !== 0) {\n                owner = outShapes[oi];\n                break;\n              }\n            }\n            if (owner)\n              owner.holes.push(\n                new THREE.Path(hr.map((p) => new THREE.Vector2(p.X / SC, p.Y / SC))),\n              );\n          }\n          cleaned.push(...outShapes);\n        }\n        return cleaned;\n      }\n\n      function cleanTextGeometry(text, size, depth) {\n        const shapes = cleanShapes(font.generateShapes(text, size));\n        return new THREE.ExtrudeGeometry(shapes, { depth, bevelEnabled: false });\n      }\n\n      function createLetterAt(char, wr, random = rand) {\n        const g = new THREE.Group();\n        // A shared geometry size lets a reused glyph scale continuously between\n        // source and target layouts, even when a long phrase needs smaller type.\n        const size = 10;\n        const geo = cleanTextGeometry(char, size, P.textDepthMax);\n        geo.computeBoundingBox();\n        const bb = geo.boundingBox;\n        const geoW = bb.max.x - bb.min.x;\n        const geoH = bb.max.y - bb.min.y;\n        geo.center();\n        const xyScale = Math.min(wr.w / (geoW || 1), wr.h / (geoH || 1));\n\n        g.add(\n          new THREE.Mesh(\n            geo,\n            new THREE.MeshBasicMaterial({\n              color: \"#050505\",\n              side: THREE.DoubleSide,\n              transparent: true,\n            }),\n          ),\n        );\n\n        const edges = new THREE.EdgesGeometry(geo, 20);\n        const lineGeo = new LineSegmentsGeometry();\n        lineGeo.setPositions(edges.attributes.position.array);\n        const lineMat = new LineMaterial({\n          color: new THREE.Color(P.outlineColor).getHex(),\n          linewidth: P.outlineWidth,\n          transparent: true,\n          resolution: lineResolution,\n        });\n        g.add(new LineSegments2(lineGeo, lineMat));\n        edges.dispose();\n\n        g.scale.set(xyScale, xyScale, 0.01);\n        g.position.set(wr.x, wr.y, 0);\n        g.userData.char = char;\n        g.userData.baseX = wr.x;\n        g.userData.baseY = wr.y;\n        g.userData.xyScale = xyScale;\n        g.userData.targetZ = (random() - 0.5) * P.letterZSpread;\n        const ratio = P.textDepthMin / P.textDepthMax;\n        g.userData.depthScale = ratio + random() * (1 - ratio);\n        g.userData.isLetter = true;\n        contentGroup.add(g);\n        textMeshes.push(g);\n        return g;\n      }\n\n      function createFlatLine(text, wr, widthMult, opacity) {\n        const geo = cleanTextGeometry(text, 1, 0.02);\n        geo.computeBoundingBox();\n        const bb = geo.boundingBox;\n        const geoW = bb.max.x - bb.min.x;\n        const geoH = bb.max.y - bb.min.y;\n        geo.center();\n        const s = Math.min(wr.h / (geoH || 1), wr.w / (geoW || 1));\n\n        const g = new THREE.Group();\n        g.add(\n          new THREE.Mesh(\n            geo,\n            new THREE.MeshBasicMaterial({\n              color: \"#050505\",\n              side: THREE.DoubleSide,\n              transparent: true,\n            }),\n          ),\n        );\n        const edges = new THREE.EdgesGeometry(geo, 40);\n        const lineGeo = new LineSegmentsGeometry();\n        lineGeo.setPositions(edges.attributes.position.array);\n        const lineMat = new LineMaterial({\n          color: new THREE.Color(P.outlineColor).getHex(),\n          linewidth: P.outlineWidth * widthMult,\n          transparent: true,\n          opacity: opacity,\n          resolution: lineResolution,\n        });\n        g.add(new LineSegments2(lineGeo, lineMat));\n        edges.dispose();\n\n        g.scale.set(s, s, 1);\n        g.position.set(wr.x, wr.y, 0);\n        g.userData.baseY = wr.y;\n        g.userData.isSupporting = true;\n        g.userData.faceColor = g.children[0].material.color.clone();\n        contentGroup.add(g);\n        textMeshes.push(g);\n      }\n\n      // Headline letters from the DOM spans (2D card and 3D letters stay aligned)\n      document.querySelectorAll(\"#wpt-headline [data-3d-char]\").forEach((span) => {\n        const ch = span.textContent;\n        if (!ch || ch.trim() === \"\") return;\n        const r = offsetRect(span);\n        if (r.width < 1 || r.height < 1) return;\n        createLetterAt(ch, rectToWorld(r));\n      });\n      const sourceLetters = textMeshes.slice();\n      // Kicker + subtitle as flat outlined lines\n      const kickEl = document.getElementById(\"wpt-kicker-text\");\n      if (kickEl && kickEl.textContent.trim()) {\n        createFlatLine(kickEl.textContent, rectToWorld(offsetRect(kickEl)), 0.7, 0.6);\n      }\n      const subEl = document.getElementById(\"wpt-subtitle\");\n      if (subEl && subEl.textContent.trim()) {\n        createFlatLine(subEl.textContent, rectToWorld(offsetRect(subEl)), 0.7, 0.6);\n      }\n\n      const supportingLines = textMeshes.filter((obj) => obj.userData.isSupporting);\n      const replacementLetters = [];\n      const transition = window.__wptTransition;\n      const clamp01 = (v) => Math.max(0, Math.min(1, v));\n      const smooth = (v) => {\n        const x = clamp01(v);\n        return x * x * (3 - 2 * x);\n      };\n\n      // Typeset from font metrics, independent of any final DOM card. Search\n      // whole-word wraps, maximizing readable type size in a safe 1520 x 620 box.\n      // A long unbroken word shrinks intact; no words or glyphs are discarded.\n      function layoutPhrase(text) {\n        const measure = document.createElement(\"canvas\").getContext(\"2d\");\n        measure.font = \"700 176px Geist\";\n        const tracking = 176 * 0.03;\n        const advance = (char) => measure.measureText(char).width + tracking;\n        const width = (line) =>\n          Array.from(line).reduce((sum, char) => sum + advance(char), -tracking);\n        const words = text.split(\" \");\n        const widest = Math.max(...words.map(width));\n        const total = width(text);\n        let best = null;\n        // Trying each possible break-width gives several balanced candidates\n        // without restricting the result to two words or a fixed line count.\n        const candidates = new Set([total, widest]);\n        for (let first = 0; first < words.length; first++) {\n          let line = \"\";\n          for (let last = first; last < words.length; last++) {\n            line += (line ? \" \" : \"\") + words[last];\n            candidates.add(width(line));\n          }\n        }\n        for (const limit of candidates) {\n          if (limit < widest) continue;\n          const lines = [];\n          let line = \"\";\n          for (const word of words) {\n            const next = line ? line + \" \" + word : word;\n            if (line && width(next) > limit + 0.01) {\n              lines.push(line);\n              line = word;\n            } else line = next;\n          }\n          if (line) lines.push(line);\n          const widths = lines.map(width);\n          const scale = Math.min(1, 1520 / Math.max(...widths), 620 / (lines.length * 176 * 1.18));\n          const balance = Math.min(...widths) / Math.max(...widths);\n          const score = scale * (0.94 + 0.06 * balance);\n          if (!best || score > best.score) best = { lines, widths, scale, score };\n        }\n        const glyphs = [];\n        const lineHeight = 176 * 1.18 * best.scale;\n        best.lines.forEach((line, row) => {\n          let left = (W - best.widths[row] * best.scale) / 2;\n          for (const char of Array.from(line)) {\n            const step = advance(char) * best.scale;\n            if (char.trim())\n              glyphs.push({\n                char,\n                row,\n                rect: {\n                  left,\n                  top: H / 2 + (row - (best.lines.length - 1) / 2) * lineHeight - 88 * best.scale,\n                  width: (advance(char) - tracking) * best.scale,\n                  height: 176 * best.scale,\n                },\n              });\n            left += step;\n          }\n        });\n        return { ...best, glyphs };\n      }\n      const phraseLayout = layoutPhrase(window.__wptPhrase);\n      for (const { char, rect, row } of phraseLayout.glyphs) {\n        const letter = createLetterAt(char, rectToWorld(rect), phraseRand);\n        // Keep spacing consistent at the hold camera while retaining real depth.\n        const distance = P.cameraDistance3D - P.contentZOffset;\n        const perspective = (distance - letter.userData.targetZ) / distance;\n        letter.userData.baseX *= perspective;\n        letter.userData.baseY *= perspective;\n        letter.userData.xyScale *= perspective;\n        letter.userData.row = row;\n        replacementLetters.push(letter);\n      }\n\n      // Reuse matching letter identities first, then pair remaining glyphs by\n      // spatial proximity. Extra target letters have their own distant Z origin;\n      // unused source letters depart early instead of lingering until a swap.\n      const slots = replacementLetters.map((to) => ({ from: null, to }));\n      const remaining = new Set(sourceLetters);\n      const distance = (a, b) => Math.hypot(a.baseX - b.baseX, a.baseY - b.baseY);\n      for (const exactOnly of [true, false]) {\n        for (const slot of slots) {\n          if (slot.from) continue;\n          let closest = null,\n            cost = Infinity;\n          for (const letter of remaining) {\n            if (exactOnly && letter.userData.char !== slot.to.userData.char) continue;\n            const candidateCost = distance(letter.userData, slot.to.userData);\n            if (candidateCost < cost) {\n              closest = letter;\n              cost = candidateCost;\n            }\n          }\n          if (closest) {\n            slot.from = closest;\n            remaining.delete(closest);\n          }\n        }\n      }\n      for (const from of remaining) slots.push({ from, to: null });\n      slots.forEach((slot, i) => {\n        const target = slot.to || slot.from;\n        slot.start = slot.from\n          ? slot.from.userData\n          : {\n              baseX: target.userData.baseX * 1.25,\n              baseY: target.userData.baseY * 1.25,\n              targetZ: -60 - phraseRand() * 65,\n              xyScale: target.userData.xyScale,\n            };\n        slot.end = (slot.to || slot.from).userData;\n        const rank = i / Math.max(1, replacementLetters.length - 1);\n        slot.delay = clamp01(rank) * transition.duration * 0.26;\n        // Keep the same object alive when the character itself does not change.\n        slot.sameGlyph = !!(\n          slot.from &&\n          slot.to &&\n          slot.from.userData.char === slot.to.userData.char\n        );\n        if (slot.sameGlyph) slot.to.visible = false;\n      });\n\n      // The adjustable power concentrates speed around the edge-on letter swap\n      // at 62% of local time: slow preparation, fast handoff, then a soft settle.\n      function phraseEase(progress) {\n        const x = clamp01(progress);\n        const a = Math.pow(x * 0.38, transition.easing);\n        const b = Math.pow((1 - x) * 0.62, transition.easing);\n        return a / (a + b);\n      }\n      function opacityFor(obj, opacity) {\n        for (const child of obj.children) {\n          child.material.opacity = opacity;\n          child.material.depthWrite = opacity > 0.995;\n        }\n      }\n      function depthFade(obj, amount, baseOpacity = 1) {\n        const opacity = 1 - smooth((amount - 0.005) / 0.13);\n        opacityFor(obj, opacity);\n        const haze = transition.fog ? 1 - smooth(amount / 0.15) : 1;\n        obj.children[1].material.color.set(P.outlineColor).lerp(endCol, 1 - haze);\n        obj.children[1].material.opacity = baseOpacity * opacity;\n        obj.visible = opacity > 0.001;\n        return opacity;\n      }\n\n      function handoffLetters(t, portal) {\n        let glitchEnvelope = 0;\n        for (let i = 0; i < slots.length; i++) {\n          const slot = slots[i];\n          const progress = clamp01(\n            (t - transition.start - slot.delay) / (transition.duration * 0.74),\n          );\n          const motion = phraseEase(progress);\n          const incoming = motion >= 0.5;\n          const start = slot.start,\n            end = slot.end;\n          // Spare source letters fog out during the first fraction of recession,\n          // before the active letters turn. This path also runs with fog disabled.\n          if (!slot.to) {\n            const depart = smooth(\n              (t - transition.start - (i % 3) * 0.025) / Math.min(0.75, transition.duration * 0.45),\n            );\n            const obj = slot.from;\n            obj.position.set(start.baseX, start.baseY, start.targetZ * portal - depart * 125);\n            obj.rotation.set(0, depart * 0.3, 0);\n            obj.scale.set(\n              start.xyScale,\n              start.xyScale,\n              THREE.MathUtils.lerp(0.01, start.depthScale, portal),\n            );\n            depthFade(obj, depart);\n            continue;\n          }\n          const x = THREE.MathUtils.lerp(start.baseX, end.baseX, motion);\n          const y =\n            THREE.MathUtils.lerp(start.baseY, end.baseY, motion) +\n            Math.sin(t * 0.6 + i * 0.7) * 0.12 * portal;\n          // Keep the approved forward rush: the original camera pushes into\n          // the wireframe world as the resolved letters accelerate toward it.\n          // A small reading-order stagger carries each letter past the lens;\n          // there is no backward Z travel or opacity dissolve on this exit.\n          const exitDelay = (i / Math.max(1, replacementLetters.length - 1)) * 0.2;\n          const flyPast = Math.pow(clamp01((t - 6.0 - exitDelay) / 1.25), 3);\n          const z =\n            THREE.MathUtils.lerp(start.targetZ, end.targetZ, motion) * portal -\n            Math.sin(Math.PI * motion) * 1.8 +\n            flyPast * 38;\n          // Retire a glyph only after its full extrusion is behind the camera.\n          // Before then, clipping and perspective carry the fly-through.\n          const cameraSpace = new THREE.Vector3(x, y, z + P.contentZOffset * portal).applyMatrix4(\n            camera.matrixWorldInverse,\n          );\n          const passedCamera = cameraSpace.z > P.textDepthMax * 2;\n          const edge = Math.pow(Math.abs(2 * motion - 1), 0.65);\n          const swapPulse = Math.exp(-Math.pow((progress - 0.62) / 0.045, 2));\n          const settlePulse = Math.exp(-Math.pow((progress - 0.86) / 0.065, 2));\n          glitchEnvelope = Math.max(glitchEnvelope, swapPulse * 0.65, settlePulse);\n          const tick =\n            Math.sin(Math.floor(t * 36) * 17.1 + i * 4.7) * settlePulse * transition.glitch;\n          for (const [obj, isIncoming] of [\n            [slot.from, false],\n            [slot.to, true],\n          ]) {\n            if (!obj) continue;\n            const isActive = slot.sameGlyph ? !isIncoming : incoming === isIncoming;\n            // New glyphs fly up from deep Z throughout the move. They are not\n            // duplicates split out of a source letter, and never disappear at the seam.\n            const extra = !slot.from;\n            const entrance = extra ? smooth(motion / 0.34) : 1;\n            const opacity = entrance;\n            obj.visible = (extra || isActive) && opacity > 0.001 && !passedCamera;\n            opacityFor(obj, opacity);\n            obj.position.set(x + tick * 0.12, y + tick * 0.04, z);\n            obj.rotation.set(\n              0,\n              slot.sameGlyph\n                ? Math.sin(Math.PI * motion) * 0.55\n                : extra\n                  ? -Math.PI * 0.75 * (1 - motion)\n                  : incoming\n                    ? -Math.PI * (1 - motion)\n                    : Math.PI * motion,\n              tick * 0.012,\n            );\n            const xyScale = THREE.MathUtils.lerp(start.xyScale, end.xyScale, motion);\n            obj.scale.set(\n              xyScale,\n              xyScale,\n              THREE.MathUtils.lerp(0.01, end.depthScale, portal) *\n                (extra || slot.sameGlyph ? 1 : 0.015 + 0.985 * edge),\n            );\n          }\n        }\n        return glitchEnvelope;\n      }\n\n      function recedeSupportingLines(t) {\n        supportingLines.forEach((obj, i) => {\n          const travel = smooth((t - 2.65 - i * 0.09) / 1.3);\n          obj.position.z = -145 * travel;\n          depthFade(obj, travel, 0.6);\n        });\n      }\n\n      // ---------- post-processing chain (experiment pass order + glitch pass) ----------\n      const renderTarget = new THREE.WebGLRenderTarget(W, H, {\n        format: THREE.RGBAFormat,\n        type: THREE.HalfFloatType,\n        depthBuffer: true,\n        samples: 4,\n      });\n      const composer = new EffectComposer(renderer, renderTarget);\n      composer.setSize(W, H);\n\n      const gridRenderPass = new RenderPass(gridScene, camera);\n      gridRenderPass.clearAlpha = 0;\n      composer.addPass(gridRenderPass);\n\n      const contentRenderPass = new RenderPass(scene, camera);\n      contentRenderPass.clear = false;\n      composer.addPass(contentRenderPass);\n\n      const blurPassH = new ShaderPass(EdgeBlurShader);\n      blurPassH.uniforms.uDirection.value.set(1, 0);\n      composer.addPass(blurPassH);\n      const blurPassV = new ShaderPass(EdgeBlurShader);\n      blurPassV.uniforms.uDirection.value.set(0, 1);\n      composer.addPass(blurPassV);\n\n      const postfxPass = new ShaderPass(PostFXShader);\n      composer.addPass(postfxPass);\n\n      const glitchPass = new ShaderPass(GlitchShader);\n      composer.addPass(glitchPass);\n\n      const transFXPass = new ShaderPass(TransitionFXShader);\n      composer.addPass(transFXPass);\n\n      const portalPass = new ShaderPass(PortalCompositeShader);\n      portalPass.material.transparent = true;\n      composer.addPass(portalPass);\n\n      composer.addPass(new OutputPass());\n\n      // ---------- warp dots (2D overlay canvas, pure function of state) ----------\n      const warpCanvas = document.getElementById(\"wpt-warp\");\n      // Keep warp-dot rasterization identical on fresh and repeated seeks.\n      const wctx = warpCanvas.getContext(\"2d\", { willReadFrequently: true });\n      const warpDots = [];\n      {\n        const count = P.warpDotCount;\n        const depthLayers = Math.ceil(Math.cbrt(count) * 2);\n        const sideCount = Math.ceil(Math.sqrt(count / depthLayers));\n        outer: for (let iz = 0; iz < depthLayers; iz++) {\n          for (let iy = 0; iy < sideCount; iy++) {\n            for (let ix = 0; ix < sideCount; ix++) {\n              if (warpDots.length >= count) break outer;\n              warpDots.push({\n                x: (ix - (sideCount - 1) / 2) * 1.0,\n                y: (iy - (sideCount - 1) / 2) * 1.0,\n                z: iz * 1.0 + 0.5,\n              });\n            }\n          }\n        }\n      }\n      const WARP_MAX_Z = Math.max(10, Math.ceil(Math.cbrt(P.warpDotCount) * 2));\n\n      function drawWarpDots(S) {\n        wctx.clearRect(0, 0, W, H);\n        const vis = S.warp;\n        if (vis < 0.01) return;\n        const cx = W / 2;\n        const cy = H / 2;\n        for (let i = 0; i < warpDots.length; i++) {\n          const d = warpDots[i];\n          let z = (((d.z - S.travel) % WARP_MAX_Z) + WARP_MAX_Z) % WARP_MAX_Z;\n          if (z < 0.05) z += WARP_MAX_Z;\n\n          const scale = 300 / z;\n          const sx = cx + d.x * scale;\n          const sy = cy + d.y * scale;\n          const size = (P.warpDotSize / z) * 3;\n          if (size < 0.3) continue;\n          if (sx < -10 || sx > W + 10 || sy < -10 || sy > H + 10) continue;\n\n          const depthAlpha = Math.min(1, 2 / z);\n          const alpha = depthAlpha * vis * P.warpDotOpacity;\n\n          wctx.globalAlpha = alpha;\n          wctx.fillStyle = P.warpDotColor;\n          wctx.beginPath();\n          wctx.arc(sx, sy, size, 0, Math.PI * 2);\n          wctx.fill();\n\n          if (z < 2 && size > 1) {\n            const streakLen = (2 - z) * 20 * vis;\n            const dx = sx - cx;\n            const dy = sy - cy;\n            const dist = Math.sqrt(dx * dx + dy * dy) || 1;\n            wctx.globalAlpha = alpha * 0.3;\n            wctx.beginPath();\n            wctx.moveTo(sx, sy);\n            wctx.lineTo(sx + (dx / dist) * streakLen, sy + (dy / dist) * streakLen);\n            wctx.strokeStyle = P.warpDotColor;\n            wctx.lineWidth = size * 0.5;\n            wctx.stroke();\n          }\n        }\n        wctx.globalAlpha = 1;\n      }\n\n      // ---------- render: everything derived from timeline time + state proxy ----------\n      const startCol = new THREE.Color(P.portalStartColor);\n      const endCol = new THREE.Color(P.bgColor);\n\n      function renderScene(t) {\n        const S = window.__wptState;\n        const portal = S.portal;\n        const push = S.push;\n        const transAmount = 1.0 - Math.abs(portal * 2 - 1);\n        const effTrans = Math.min(1, Math.max(transAmount, S.exitFx * 0.85));\n\n        // Camera: FOV/distance lerp (2D -> 3D) plus exit push through the letters\n        camera.fov = THREE.MathUtils.lerp(P.initialFOV, P.finalFOV, portal) + push * 10;\n        camera.position.z =\n          THREE.MathUtils.lerp(P.cameraDistance, P.cameraDistance3D, portal) -\n          push * 52 +\n          Math.sin(t * 0.34) * 1.6 * portal * (1 - push);\n        const driftAmp = portal * (1 - 0.7 * push);\n        camera.rotation.x = Math.cos(t * 0.47) * 0.04 * driftAmp;\n        camera.rotation.y = Math.sin(t * 0.62 + 1.2) * 0.06 * driftAmp;\n        camera.position.x = Math.sin(t * 0.41) * 1.4 * driftAmp;\n        camera.position.y = Math.cos(t * 0.29) * 1.0 * driftAmp;\n        camera.updateProjectionMatrix();\n        camera.updateMatrixWorld();\n\n        // Portal composite\n        portalPass.uniforms.uPortalRadius.value = portal * P.portalScale;\n        portalPass.uniforms.uPortalProgress.value = portal;\n        portalPass.uniforms.uTime.value = t;\n\n        // Vignette / scanline / CA scale with portal\n        postfxPass.uniforms.uVignetteIntensity.value = P.vignetteIntensity * portal;\n        postfxPass.uniforms.uChromaticAberration.value = P.chromaticAberration * portal;\n        postfxPass.uniforms.uScanlineIntensity.value = P.scanlineIntensity * portal;\n        postfxPass.uniforms.uTime.value = t;\n\n        const blurAmount = P.edgeBlur * portal;\n        blurPassH.uniforms.uBlurAmount.value = blurAmount;\n        blurPassV.uniforms.uBlurAmount.value = blurAmount;\n\n        // Transition FX peak at portal 0.5 + on the exit push\n        transFXPass.uniforms.uTransAmount.value = effTrans;\n\n        // Block glitch ticks (the handoff envelope below follows duration/easing).\n        glitchPass.uniforms.uTime.value = t;\n        glitchPass.uniforms.uShakePower.value = P.glitchPower * S.glitch;\n        glitchPass.uniforms.uShakeRate.value = S.glitch > 0.001 ? 1.0 : 0.0;\n        glitchPass.uniforms.uShakeColorRate.value = P.glitchColorRate * Math.min(1, S.glitch * 1.8);\n\n        // Grid + background plane\n        const showContent = portal > 0.01;\n        gridLines.visible = showContent;\n        contentGroup.visible = showContent;\n        bgPlane.visible = showContent;\n        const colorT = Math.min(1, Math.max(0, (portal - 0.15) * P.portalColorSpeed));\n        bgPlaneMat.color.copy(startCol).lerp(endCol, colorT);\n        gridMat.uniforms.uCameraPos.value.copy(camera.position);\n        gridMat.uniforms.uTime.value = t;\n\n        // Floating shapes drift\n        for (let i = 0; i < floatingShapes.length; i++) {\n          const mesh = floatingShapes[i];\n          const base = mesh.userData.basePos;\n          const phase = i * 2.17;\n          mesh.position.x =\n            base.x + Math.sin(t * 0.15 + phase) * 1.2 + Math.sin(t * 0.07 + phase * 3) * 0.5;\n          mesh.position.y =\n            base.y + Math.sin(t * 0.12 + phase * 1.4) * 0.8 + Math.cos(t * 0.09 + phase * 2) * 0.3;\n          mesh.position.z =\n            base.z + Math.sin(t * 0.1 + phase * 0.7) * 0.6 + P.contentZOffset * portal;\n          mesh.rotation.x = Math.sin(t * 0.08 + phase) * 0.4;\n          mesh.rotation.y = t * 0.05 * (i % 2 === 0 ? 1 : -1) + phase;\n          mesh.rotation.z = Math.sin(t * 0.06 + phase * 1.3) * 0.3;\n        }\n\n        // Content: flat page -> per-letter depth and z-spread\n        contentGroup.position.z = P.contentZOffset * portal;\n        for (let i = 0; i < textMeshes.length; i++) {\n          const obj = textMeshes[i];\n          if (obj.userData.isLetter) {\n            obj.position.z = obj.userData.targetZ * portal;\n            const zScale = THREE.MathUtils.lerp(0.01, obj.userData.depthScale, portal);\n            obj.scale.z = zScale;\n          }\n          obj.position.y = obj.userData.baseY + Math.sin(t * 0.6 + i * 0.7) * 0.12 * portal;\n        }\n        const handoffGlitch = handoffLetters(t, portal);\n        recedeSupportingLines(t);\n        const glitch = Math.max(S.glitch * 0.5, handoffGlitch * 0.35) * transition.glitch;\n        glitchPass.uniforms.uShakePower.value = P.glitchPower * glitch;\n        glitchPass.uniforms.uShakeRate.value = glitch > 0.001 ? 1 : 0;\n        glitchPass.uniforms.uShakeColorRate.value = P.glitchColorRate * glitch * 1.8;\n\n        if (portal < 0.001) {\n          renderer.clear();\n          wctx.clearRect(0, 0, W, H);\n          return;\n        }\n        composer.render();\n        drawWarpDots(S);\n      }\n\n      window.__wptRender = renderScene;\n      const tl = window.__timelines[\"wireframe-portal-title\"];\n      renderScene(tl ? tl.time() : 0);\n      /* The portal is closed at t=0 and draws nothing, so the first real draw would\n         link every shader mid-playback. Draw across the timeline and flush the GPU\n         before ready instead. */\n      window.__hf = window.__hf || {};\n      window.__hf.buildReady = window.__hf.buildReady || {};\n      window.__hf.buildReady[\"wireframe-portal-title\"] = (async () => {\n        const warmDur = tl ? tl.duration() : 0;\n        for (const f of [0.3, 0.5, 0.7]) {\n          await new Promise((resolve) => setTimeout(resolve, 0));\n          renderScene(warmDur * f);\n        }\n        renderScene(tl ? tl.time() : 0);\n        renderer.getContext().finish();\n      })();\n    </script>\n  </body>\n</html>\n"}