Skip to content

Write HTML. Render video. Built for agents.

59.0 KB
Raw Blame
{"html":"<!doctype html>\n<html\n  lang=\"en\"\n  data-composition-variables='[{\"id\":\"headline1\",\"type\":\"string\",\"label\":\"Headline 1\",\"default\":\"Understory\"},{\"id\":\"headline2\",\"type\":\"string\",\"label\":\"Headline 2\",\"default\":\"Move slowly\"},{\"id\":\"font\",\"type\":\"string\",\"label\":\"Headline font\",\"default\":\"Helvetica\"},{\"id\":\"fontWeight\",\"type\":\"number\",\"label\":\"Font weight\",\"default\":900,\"min\":100,\"max\":900,\"step\":100},{\"id\":\"fontSize\",\"type\":\"number\",\"label\":\"Font size (1 = auto-fit)\",\"default\":1,\"min\":0.3,\"max\":2,\"step\":0.01},{\"id\":\"letterSpacing\",\"type\":\"number\",\"label\":\"Letter spacing (em)\",\"default\":0.01,\"min\":-0.2,\"max\":1,\"step\":0.01},{\"id\":\"background\",\"type\":\"color\",\"label\":\"Background\",\"default\":\"#020805\"},{\"id\":\"leafCount\",\"type\":\"number\",\"label\":\"Leaves per sweep\",\"default\":170,\"min\":40,\"max\":320,\"step\":1},{\"id\":\"stayCount\",\"type\":\"number\",\"label\":\"Leaves left behind\",\"default\":5,\"min\":0,\"max\":20,\"step\":1},{\"id\":\"sweepSpeed\",\"type\":\"number\",\"label\":\"Sweep speed\",\"default\":1,\"min\":0.3,\"max\":3,\"step\":0.05},{\"id\":\"retainedBreeze\",\"type\":\"number\",\"label\":\"Retained leaf breeze\",\"default\":1,\"min\":0,\"max\":2,\"step\":0.05}]'\n>\n  <head><base href=\"/public/catalog/items/canopy-part-title/\">\n    <meta charset=\"UTF-8\" />\n    <meta name=\"viewport\" content=\"width=1920, height=1080\" />\n    <title>canopy-part-title</title>\n    <link rel=\"preconnect\" href=\"https://fonts.googleapis.com\" />\n    <link rel=\"preconnect\" href=\"https://fonts.gstatic.com\" crossorigin=\"\" />\n    <link\n      href=\"https://fonts.googleapis.com/css2?family=Gelasio:wght@500;600&display=swap\"\n      rel=\"stylesheet\"\n    />\n    <script src=\"https://cdn.jsdelivr.net/npm/[email protected]/dist/gsap.min.js\"></script>\n    <style>\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: #020805;\n      }\n      #cpt-root {\n        position: relative;\n        width: 1920px;\n        height: 1080px;\n        overflow: hidden;\n      }\n      #cpt-scene {\n        position: absolute;\n        inset: 0;\n      }\n      /* Full-frame background paint on a child, never on the composition root.\n         Plain flat colour — driven by the `background` variable, no gradients. */\n      #cpt-bg {\n        position: absolute;\n        inset: 0;\n        background: #020805;\n      }\n      #cpt-canvas {\n        position: absolute;\n        inset: 0;\n        width: 100%;\n        height: 100%;\n        display: block;\n      }\n      #cpt-fontload {\n        position: absolute;\n        opacity: 0;\n        pointer-events: none;\n        font-family: Gelasio, Georgia, serif;\n      }\n    </style>\n  </head>\n  <body>\n    <div\n      data-hf-id=\"hf-idkp\"\n      id=\"cpt-root\"\n      data-composition-id=\"canopy-part-title\"\n      data-start=\"0\"\n      data-duration=\"12\"\n      data-width=\"1920\"\n      data-height=\"1080\"\n    >\n      <section\n        data-hf-id=\"hf-wrn4\"\n        id=\"cpt-scene\"\n        class=\"clip\"\n        data-start=\"0\"\n        data-duration=\"12\"\n        data-track-index=\"1\"\n      >\n        <div\n          style=\"font-family: &quot;Alan Sans&quot;, ui-sans-serif, system-ui, sans-serif\"\n          data-hf-id=\"hf-bank\"\n          id=\"cpt-bg\"\n        ></div>\n      </section>\n      <div data-hf-id=\"hf-p1fl\" id=\"cpt-fontload\" aria-hidden=\"true\">\n        <span data-hf-id=\"hf-grhl\" style=\"font-weight: 500\">Aa</span\n        ><span data-hf-id=\"hf-7bxm\" style=\"font-weight: 600\">Aa</span>\n      </div>\n    </div>\n\n    <!-- Seeded layout + master timeline. Runs synchronously before the Three module so\n         the timeline exists the moment the page is scriptable. Zero Math.random. -->\n    <script>\n      (function () {\n        \"use strict\";\n        window.__timelines = window.__timelines || {};\n        /* Studio's variables parser fails on any composition with a <canvas>\n         in its MARKUP — created at runtime instead (identical for render). */\n        (function () {\n          var c = document.createElement(\"canvas\");\n          c.id = \"cpt-canvas\";\n          c.width = 1920;\n          c.height = 1080;\n          document.getElementById(\"cpt-scene\").appendChild(c);\n        })();\n\n        // getVariables carries the declared defaults, standalone and mounted.\n        var V = {};\n        try {\n          if (window.__hyperframes && window.__hyperframes.getVariables)\n            V = window.__hyperframes.getVariables() || {};\n        } catch (e) {\n          /* corrupt declarations must not blank the composition */\n        }\n        var LEAF_COUNT = Math.max(40, Math.min(320, Number(V.leafCount) || 170));\n        var STAY_COUNT = Math.max(\n          0,\n          Math.min(\n            20,\n            Math.round(\n              V.stayCount === undefined || !isFinite(Number(V.stayCount)) ? 5 : Number(V.stayCount),\n            ),\n          ),\n        );\n        var SPEED = Math.max(0.3, Math.min(3, Number(V.sweepSpeed) || 1));\n        var DUR = 12;\n\n        function mulberry32(seed) {\n          return function () {\n            seed |= 0;\n            seed = (seed + 0x6d2b79f5) | 0;\n            var t = Math.imul(seed ^ (seed >>> 15), 1 | seed);\n            t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;\n            return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n          };\n        }\n\n        /* V1's opening sweep plus a separate depth-lift batch. Each batch has\n           exactly stayCount leaves reserved for edge rest slots. The lift\n           carries the opening's remaining edge leaves past the camera. */\n        var rand = mulberry32(0x6a756e67);\n        var TEXT_HALF_W = 8.2,\n          TEXT_HALF_H = 2.0;\n\n        function buildBatch(batchIndex) {\n          var out = [];\n          for (var i = 0; i < LEAF_COUNT; i++) {\n            var kindRoll = rand();\n            var kind =\n              kindRoll < 0.22\n                ? \"monstera\"\n                : kindRoll < 0.42\n                  ? \"alocasia\"\n                  : kindRoll < 0.68\n                    ? \"lance\"\n                    : kindRoll < 0.89\n                      ? \"calathea\"\n                      : \"fern\";\n            /* Stayers are chosen AFTER the batch is built (exactly stayCount of\n               them, scattered) — here every leaf just gets wind-seed rest values\n               and a LOW flight band: in front of the text plane but pushed away\n               from the camera so the depth of field leaves most leaves sharp. */\n            var stayer = false;\n            var y0 = (rand() * 2 - 1) * 3.6 - 0.5;\n            var restX = (rand() * 2 - 1) * 9.2;\n            var restY = y0;\n            var restRZ = rand() * Math.PI * 2;\n            out.push({\n              batch: batchIndex,\n              kind: kind,\n              stayer: stayer,\n              z: -4.6 + rand() * 3.0,\n              xStart: -12.5 - rand() * 5.5,\n              xEnd: 12.5 + rand() * 5.0,\n              restX: restX,\n              restY: restY,\n              restRZ: restRZ,\n              y0: y0,\n              delay: rand() * 0.5,\n              delay2: 0, // filled for batch-1 stayers below\n              bobAmp: 0.3 + rand() * 0.65,\n              bobN: 1.1 + rand() * 1.6,\n              spin: (rand() < 0.5 ? -1 : 1) * (1.6 + rand() * 3.0),\n              phase: rand() * Math.PI * 2,\n              rotation: rand() * Math.PI * 2,\n              tiltX: (rand() - 0.5) * 0.42,\n              tiltY: (rand() - 0.5) * 0.58,\n              widthMul: 0.83 + rand() * 0.34,\n              lengthMul: 0.86 + rand() * 0.25,\n              scale: (0.62 + rand() * 0.85) * 0.56 * 1.9,\n            });\n          }\n          return out;\n        }\n\n        /* Exactly STAY_COUNT leaves per batch stay behind, scattered at seeded\n           random positions anywhere in frame EXCEPT the headline band — never\n           lined up along the top and bottom. */\n        function pickStayers(batch) {\n          var placed = 0,\n            guard = 0;\n          while (placed < STAY_COUNT && guard++ < 600) {\n            var idx = Math.floor(rand() * batch.length) % batch.length;\n            var sp = batch[idx];\n            if (sp.stayer) continue;\n            var rx,\n              ry,\n              tries = 0;\n            do {\n              rx = (rand() * 2 - 1) * 8.6;\n              ry = (rand() * 2 - 1) * 4.3;\n              tries++;\n            } while (\n              tries < 30 &&\n              Math.abs(ry) < TEXT_HALF_H + 0.7 &&\n              Math.abs(rx) < TEXT_HALF_W + 0.8\n            );\n            sp.stayer = true;\n            sp.restX = rx;\n            sp.restY = ry;\n            if (Math.abs(rx) > TEXT_HALF_W + 0.8 && Math.abs(ry) < TEXT_HALF_H + 1.4) {\n              sp.restRZ = ((rx > 0 ? -1 : 1) * Math.PI) / 2 + (rand() - 0.5) * 0.7;\n            } else if (ry >= 0) {\n              sp.restRZ = (rand() - 0.5) * 0.8;\n            } else {\n              sp.restRZ = Math.PI + (rand() - 0.5) * 0.8;\n            }\n            placed++;\n          }\n        }\n\n        var batch1 = buildBatch(1);\n        var batch2 = buildBatch(2);\n        pickStayers(batch1);\n        pickStayers(batch2);\n        // Sweep-away order for batch-1 stayers: left-most leave first.\n        batch1.forEach(function (s) {\n          s.delay2 = ((s.restX + 16) / 32) * 0.5 + rand() * 0.14;\n        });\n        // Independent seed: V1's opening geometry/seed sequence is unchanged.\n        var liftRand = mulberry32(0x6c696674);\n        batch2.forEach(function (s, i) {\n          s.liftX = (liftRand() * 2 - 1) * 7.8;\n          s.liftY = -5.2 + liftRand() * 5.8;\n          s.liftZ = -7 + liftRand() * 4.9;\n          s.liftDelay = liftRand() * 0.28;\n          s.depthResponse = Math.max(0.25, Math.min(1, (s.liftZ + 7) / 14 + 0.55));\n          // Keep final foliage outside the headline, including its full leaf extent.\n          if (s.stayer) {\n            var a = i * 2.399963;\n            s.restX = Math.sin(a) * 8.5;\n            s.restY = (i % 2 ? 1 : -1) * 5.5;\n            s.restRZ = i % 2 ? 0 : Math.PI;\n          }\n        });\n        window.__cptBatches = [batch1, batch2];\n\n        var DUST_COUNT = 800;\n        var dustHome = new Array(DUST_COUNT * 3);\n        var dustSeeds = new Array(DUST_COUNT);\n        for (var d = 0; d < DUST_COUNT; d++) {\n          dustHome[d * 3] = (rand() * 2 - 1) * 10;\n          dustHome[d * 3 + 1] = (rand() * 2 - 1) * 6;\n          dustHome[d * 3 + 2] = rand() * 12 - 5;\n          dustSeeds[d] = rand();\n        }\n        window.__cptDust = { home: dustHome, seeds: dustSeeds };\n\n        // Separate per-leaf seeds leave the approved sweep/lift layout untouched.\n        // Different periods and phases avoid a shared rocking or looping beat.\n        [batch1, batch2].forEach(function (batch, batchIndex) {\n          batch.forEach(function (s, i) {\n            if (!s.stayer) return;\n            var breezeRand = mulberry32(0x62726565 ^ ((batchIndex + 1) * 104729 + i * 7919));\n            s.breeze = {\n              phase: breezeRand() * Math.PI * 2,\n              phase2: breezeRand() * Math.PI * 2,\n              phase3: breezeRand() * Math.PI * 2,\n              rate: 0.55 + breezeRand() * 0.45,\n              driftX: 0.22 + breezeRand() * 0.24,\n              driftY: 0.28 + breezeRand() * 0.28,\n              driftZ: 0.35 + breezeRand() * 0.45,\n              depth: (breezeRand() - 0.5) * 1.3,\n              tiltX: 0.07 + breezeRand() * 0.1,\n              tiltY: 0.1 + breezeRand() * 0.14,\n              roll: 0.12 + breezeRand() * 0.14,\n              turn: (breezeRand() < 0.5 ? -1 : 1) * (0.012 + breezeRand() * 0.022),\n              arrival: breezeRand() * 0.16,\n            };\n          });\n        });\n\n        /* Masters tweened by the timeline; all per-leaf motion is a closed-form\n           function of these plus each leaf's seeded constants. */\n        var state = { sw1: 0, sw2: 0 };\n        window.__cptState = state;\n\n        // Keep the existing speed parameter; finite holds absorb the slack.\n        var d1 = Math.max(1.2, Math.min(6.0, 3.2 / SPEED));\n        var s2 = Math.max(0.4 + d1 + 0.9, 5.2);\n        var d2 = Math.max(1.2, Math.min(3.2 / SPEED, DUR - s2 - 1.8));\n        window.__cptWindows = { d1: d1, s2: s2, d2: d2 };\n\n        var tl = gsap.timeline({ paused: true });\n        tl.addLabel(\"opening\", 0)\n          .addLabel(\"headline-1\", 0.4 + d1)\n          .addLabel(\"canopy-lift\", s2)\n          .addLabel(\"headline-2\", s2 + d2)\n          .addLabel(\"final-hold\", 10.5);\n        tl.fromTo(\n          \"#cpt-scene\",\n          { opacity: 0 },\n          { opacity: 1, duration: 0.35, ease: \"power1.out\" },\n          0.05,\n        );\n        // Imperceptible 1.5px drift on the bg plate (same colour as the body\n        // behind it) so the layout sweep sees DOM geometry advance under seek.\n        tl.fromTo(\"#cpt-bg\", { y: 0 }, { y: 1.5, duration: 12, ease: \"none\" }, 0);\n        tl.to(state, { sw1: 1, duration: d1, ease: \"none\" }, 0.4);\n        tl.to(state, { sw2: 1, duration: d2, ease: \"none\" }, s2);\n        tl.to(state, { sw2: 1, duration: 0.01 }, DUR - 0.01); // pin timeline length to DUR\n\n        tl.eventCallback(\"onUpdate\", function () {\n          if (window.__cptRender) window.__cptRender(tl.time());\n        });\n\n        window.__timelines[\"canopy-part-title\"] = tl;\n      })();\n    </script>\n\n    <script type=\"importmap\">\n      { \"imports\": { \"three\": \"https://cdn.jsdelivr.net/npm/[email protected]/build/three.module.js\" } }\n    </script>\n    <script type=\"module\">\n      import * as THREE from \"three\";\n      import { EffectComposer } from \"https://cdn.jsdelivr.net/npm/[email protected]/examples/jsm/postprocessing/EffectComposer.js\";\n      import { RenderPass } from \"https://cdn.jsdelivr.net/npm/[email protected]/examples/jsm/postprocessing/RenderPass.js\";\n      import { BokehPass } from \"https://cdn.jsdelivr.net/npm/[email protected]/examples/jsm/postprocessing/BokehPass.js\";\n\n      const W = 1920,\n        H = 1080,\n        DUR = 12;\n      // Bare __hyperframes is this composition's own in a module; getVariables carries the defaults.\n      let V = {};\n      try {\n        if (typeof __hyperframes !== \"undefined\" && __hyperframes.getVariables)\n          V = __hyperframes.getVariables() || {};\n      } catch (e) {\n        /* corrupt declarations must not blank the composition */\n      }\n      const HEADLINE1 = String(V.headline1 ?? \"Understory\");\n      const HEADLINE2 = String(V.headline2 ?? \"Move slowly\");\n      /* Headline typography is a PARAMETER — never a Design-panel edit. Any\n         Google Fonts family name works; falls back through Gelasio/serif\n         while (or if never) loading. */\n      const FONT = (String(V.font || \"Helvetica\").trim() || \"Helvetica\").replace(/[\"']/g, \"\");\n      const FONT_WEIGHT = Math.max(\n        100,\n        Math.min(\n          900,\n          Math.round(\n            isFinite(Number(V.fontWeight)) && Number(V.fontWeight) ? Number(V.fontWeight) : 900,\n          ),\n        ),\n      );\n      /* fontSize is a multiplier on the auto-fitted size (0.3-2); letterSpacing\n         is in em (fraction of the font size, may be negative). */\n      const FONT_SIZE = Math.max(\n        0.3,\n        Math.min(\n          2,\n          isFinite(Number(V.fontSize)) && Number(V.fontSize) > 0 ? Number(V.fontSize) : 1,\n        ),\n      );\n      const LETTER_SP = Math.max(\n        -0.2,\n        Math.min(1, isFinite(Number(V.letterSpacing)) ? Number(V.letterSpacing) : 0.01),\n      );\n      const FONT_STACK = '\"' + FONT + '\", Gelasio, Georgia, serif';\n      if (!/^(Helvetica|Arial|Gelasio|Georgia|serif|sans-serif|monospace)$/i.test(FONT)) {\n        const fl = document.createElement(\"link\");\n        fl.rel = \"stylesheet\";\n        fl.href =\n          \"https://fonts.googleapis.com/css2?family=\" +\n          encodeURIComponent(FONT).replace(/%20/g, \"+\") +\n          \":wght@\" +\n          FONT_WEIGHT +\n          \"&display=swap\";\n        document.head.appendChild(fl);\n      }\n      const BG = String(V.background || \"#020805\");\n      const RETAINED_BREEZE = Math.max(\n        0,\n        Math.min(2, Number.isFinite(Number(V.retainedBreeze)) ? Number(V.retainedBreeze) : 1),\n      );\n      const state = window.__cptState;\n\n      // Fixed experiment parameters (the source's tuned defaults), baked in.\n      const WIND_SPEED = 1.06;\n      const WIND_STRENGTH = 2.5;\n      const TURBULENCE = 0.8;\n      const TEXT_Z = -5.0;\n      const BACKDROP_Z = -7.5;\n      const CAM_DIST = 13.6;\n\n      const clamp = THREE.MathUtils.clamp;\n      const smoothstep = (a, b, x) => {\n        const t = clamp((x - a) / (b - a), 0, 1);\n        return t * t * (3 - 2 * t);\n      };\n      function hash2(x, y, seed) {\n        let n = Math.imul(x + seed * 1013, 374761393) + Math.imul(y - seed * 79, 668265263);\n        n = n ^ (n >>> 13);\n        n = Math.imul(n, 1274126177);\n        return ((n ^ (n >>> 16)) >>> 0) / 4294967295;\n      }\n\n      document.getElementById(\"cpt-bg\").style.background = BG;\n      document.body.style.background = BG;\n\n      const renderer = new THREE.WebGLRenderer({\n        canvas: document.getElementById(\"cpt-canvas\"),\n        antialias: true,\n        powerPreference: \"high-performance\",\n        alpha: false,\n      });\n      renderer.setSize(W, H, false);\n      renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, 2));\n      renderer.outputColorSpace = THREE.SRGBColorSpace;\n      renderer.toneMapping = THREE.ACESFilmicToneMapping;\n      renderer.toneMappingExposure = 1.8;\n      renderer.shadowMap.enabled = true;\n      renderer.shadowMap.type = THREE.PCFShadowMap;\n\n      const scene = new THREE.Scene();\n      const bgColor = new THREE.Color(BG);\n      scene.background = bgColor.clone();\n      scene.fog = new THREE.FogExp2(bgColor.clone(), 0.008);\n\n      const camera = new THREE.PerspectiveCamera(41, W / H, 0.1, 40);\n      camera.position.set(0, 0.15, 12.1);\n      camera.lookAt(0, 0, -1.5);\n\n      const composer = new EffectComposer(renderer);\n      composer.setSize(W, H);\n      // Copy only colour; retain the scene depth for the sharp headline pass.\n      composer.copyPass.material.depthTest = false;\n      composer.copyPass.material.depthWrite = false;\n      composer.addPass(new RenderPass(scene, camera));\n      const bokehPass = new BokehPass(scene, camera, {\n        focus: 16.4,\n        aperture: 0.0016,\n        maxblur: 0.0055,\n      });\n      composer.addPass(bokehPass);\n\n      const hemi = new THREE.HemisphereLight(0x9fc09b, 0x061009, 2);\n      scene.add(hemi);\n      const sun = new THREE.DirectionalLight(new THREE.Color(\"#ece5ff\"), 8.5);\n      sun.position.set(-13.3, 8.5, 9);\n      sun.target.position.set(0, -1, -3);\n      sun.castShadow = true;\n      sun.shadow.mapSize.set(2048, 2048);\n      sun.shadow.camera.left = -20;\n      sun.shadow.camera.right = 20;\n      sun.shadow.camera.top = 20 * 0.73;\n      sun.shadow.camera.bottom = -20 * 0.73;\n      sun.shadow.camera.near = 0.5;\n      sun.shadow.camera.far = 28;\n      sun.shadow.bias = 0.00105;\n      sun.shadow.normalBias = 0.0525;\n      sun.shadow.radius = 2.5;\n      scene.add(sun, sun.target);\n      const fill = new THREE.DirectionalLight(new THREE.Color(\"#00bd03\"), 9.55);\n      fill.position.set(-11.8, 4.2, 5.2);\n      fill.target.position.set(0.7, 1, -2);\n      scene.add(fill, fill.target);\n\n      /* Plain flat backdrop in the variable colour (unlit so it stays flat), with a\n         shadow-only catcher just in front for leaf contact shadows. */\n      const wall = new THREE.Mesh(\n        new THREE.PlaneGeometry(68, 44),\n        new THREE.MeshBasicMaterial({ color: bgColor.clone(), fog: false }),\n      );\n      wall.position.z = BACKDROP_Z;\n      scene.add(wall);\n      const catcher = new THREE.Mesh(\n        new THREE.PlaneGeometry(68, 44),\n        new THREE.ShadowMaterial({ opacity: 0.28 }),\n      );\n      catcher.position.z = BACKDROP_Z + 0.05;\n      catcher.receiveShadow = true;\n      scene.add(catcher);\n\n      // ---- Procedural leaf species textures (ported verbatim from the experiment).\n      const palettes = {\n        monstera: [\n          [22, 77, 46],\n          [79, 128, 70],\n          [170, 184, 104],\n        ],\n        alocasia: [\n          [18, 55, 43],\n          [57, 104, 73],\n          [190, 206, 149],\n        ],\n        lance: [\n          [15, 74, 42],\n          [53, 126, 65],\n          [145, 172, 84],\n        ],\n        calathea: [\n          [32, 58, 39],\n          [82, 117, 72],\n          [195, 178, 126],\n        ],\n        fern: [\n          [20, 73, 39],\n          [64, 126, 65],\n          [158, 176, 88],\n        ],\n      };\n\n      function leafWidth(kind, y) {\n        const s = Math.max(0, Math.sin(Math.PI * y));\n        if (kind === \"lance\" || kind === \"fern\") return Math.pow(s, 1.28) * (0.66 + y * 0.12);\n        if (kind === \"alocasia\") return Math.pow(s, 0.62) * (0.88 + 0.16 * (1 - y));\n        if (kind === \"calathea\") return Math.pow(s, 0.82) * 0.78;\n        return Math.pow(s, 0.55) * (0.82 + 0.15 * y);\n      }\n\n      function makeLeafTexture(kind, seed) {\n        const w = 384,\n          h = 768;\n        const colorCanvas = document.createElement(\"canvas\");\n        const bumpCanvas = document.createElement(\"canvas\");\n        colorCanvas.width = bumpCanvas.width = w;\n        colorCanvas.height = bumpCanvas.height = h;\n        const colorCtx = colorCanvas.getContext(\"2d\");\n        const bumpCtx = bumpCanvas.getContext(\"2d\");\n        const colorImage = colorCtx.createImageData(w, h);\n        const bumpImage = bumpCtx.createImageData(w, h);\n        const p = palettes[kind];\n\n        for (let py = 0; py < h; py++) {\n          const y = py / (h - 1);\n          const width = leafWidth(kind, y);\n          for (let px = 0; px < w; px++) {\n            const x = (px / (w - 1) - 0.5) * 2;\n            const nx = Math.abs(x) / Math.max(0.001, width);\n            let signed = 1 - nx;\n            let inside = signed > -0.015 && y > 0.008 && y < 0.996;\n\n            if (inside && kind === \"monstera\") {\n              const ax = Math.abs(x);\n              const side = x < 0 ? -1 : 1;\n              for (let k = 0; k < 6; k++) {\n                const jitter = (hash2(k, seed, 44) - 0.5) * 0.034;\n                const root = 0.205 + k * 0.083 + jitter;\n                const inner = 0.23 + k * 0.022 + (hash2(k, seed, 51) - 0.5) * 0.026;\n                const curve =\n                  root + (ax - inner) * (0.14 + k * 0.012) + Math.sin((ax + k) * 13.0) * 0.008;\n                const slotWidth =\n                  (0.009 + k * 0.0018) * smoothstep(inner, Math.max(inner + 0.11, width), ax);\n                if (ax > inner && Math.abs(y - curve) < slotWidth && ax < width * 1.025)\n                  inside = false;\n                if (k < 4) {\n                  const cx = side * (0.225 + k * 0.052 + (hash2(k, seed, 61) - 0.5) * 0.025);\n                  const cy = 0.31 + k * 0.105 + (hash2(k, seed, 71) - 0.5) * 0.025;\n                  const rx = 0.026 + k * 0.003;\n                  const ry = 0.038 + k * 0.005;\n                  const skewY = y - cy - (x - cx) * side * 0.26;\n                  const hole = (x - cx) ** 2 / (rx * rx) + skewY ** 2 / (ry * ry) < 1;\n                  if (hole) inside = false;\n                }\n              }\n            }\n            if (inside && kind === \"alocasia\" && y < 0.105) {\n              const notch = Math.abs(x) < 0.15 * (1 - y / 0.105);\n              if (notch) inside = false;\n            }\n\n            const i = (py * w + px) * 4;\n            if (!inside) {\n              colorImage.data[i + 3] = 0;\n              bumpImage.data[i] = bumpImage.data[i + 1] = bumpImage.data[i + 2] = 112;\n              bumpImage.data[i + 3] = 255;\n              continue;\n            }\n\n            const n0 = hash2(px >> 2, py >> 2, seed);\n            const n1 = hash2(px >> 4, py >> 4, seed + 17);\n            const middle = Math.exp(-Math.abs(x) * (kind === \"lance\" ? 28 : 35));\n            const veinFreq = kind === \"lance\" ? 12 : 8.5;\n            const ribWave = Math.abs(((y * veinFreq + Math.abs(x) * 1.85) % 1) - 0.5);\n            const sideVein = Math.exp(-ribWave * 46) * smoothstep(0.04, 0.82, Math.abs(x));\n            const edge = smoothstep(0, 0.16, signed);\n            const stripe =\n              kind === \"calathea\" ? 0.5 + 0.5 * Math.cos(y * 58 + Math.abs(x) * 10) : 0;\n            const mottling = (n0 - 0.5) * 0.16 + (n1 - 0.5) * 0.12 + stripe * 0.08;\n            const light = clamp(\n              0.42 + y * 0.12 + mottling + middle * 0.34 + sideVein * 0.16 - (1 - edge) * 0.27,\n              0,\n              1,\n            );\n            const dry = hash2(px >> 3, py >> 3, seed + 90) > 0.978 ? 0.16 : 0;\n\n            const c0 = p[0],\n              c1 = p[1],\n              c2 = p[2];\n            const t = smoothstep(0.08, 0.9, light);\n            const hi = smoothstep(0.56, 1, t);\n            for (let ch = 0; ch < 3; ch++) {\n              const low = c0[ch] + (c1[ch] - c0[ch]) * t;\n              const val =\n                low + (c2[ch] - low) * hi * 0.58 + dry * (ch === 0 ? 56 : ch === 1 ? 35 : 10);\n              colorImage.data[i + ch] = clamp(val, 0, 255);\n            }\n            colorImage.data[i + 3] = clamp(edge * 390, 0, 255);\n\n            const bump = clamp(\n              112 + (n0 - 0.5) * 22 + middle * 100 + sideVein * 52 - (1 - edge) * 18,\n              0,\n              255,\n            );\n            bumpImage.data[i] = bumpImage.data[i + 1] = bumpImage.data[i + 2] = bump;\n            bumpImage.data[i + 3] = 255;\n          }\n        }\n\n        colorCtx.putImageData(colorImage, 0, 0);\n        bumpCtx.putImageData(bumpImage, 0, 0);\n        const map = new THREE.CanvasTexture(colorCanvas);\n        map.colorSpace = THREE.SRGBColorSpace;\n        map.anisotropy = Math.min(8, renderer.capabilities.getMaxAnisotropy());\n        const bump = new THREE.CanvasTexture(bumpCanvas);\n        bump.anisotropy = map.anisotropy;\n        return { map, bump };\n      }\n\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 textureLoader = new THREE.TextureLoader();\n      const [photoSurface, photoNormal] = await Promise.all([\n        textureLoader.loadAsync(assetUrl(\"/public/catalog/assets/c56b647034523b07.webp\")),\n        textureLoader.loadAsync(assetUrl(\"/public/catalog/assets/c0c37fab0fdfa85d.webp\")),\n      ]);\n      photoSurface.colorSpace = THREE.SRGBColorSpace;\n      photoSurface.wrapS = photoSurface.wrapT = THREE.RepeatWrapping;\n      photoSurface.repeat.set(2.4, 4.8);\n      photoNormal.wrapS = photoNormal.wrapT = THREE.RepeatWrapping;\n      photoNormal.repeat.set(2.4, 4.8);\n\n      const kinds = [\"monstera\", \"alocasia\", \"lance\", \"calathea\", \"fern\"];\n      const textureSets = Object.fromEntries(\n        kinds.map((kind, i) => [kind, makeLeafTexture(kind, i * 31 + 7)]),\n      );\n      const materials = {};\n      const shaderMaterials = [];\n\n      for (const [index, kind] of kinds.entries()) {\n        const tex = textureSets[kind];\n        const material = new THREE.MeshPhysicalMaterial({\n          map: tex.map,\n          bumpMap: tex.bump,\n          bumpScale: (kind === \"monstera\" ? 0.065 : 0.045) * 2.5,\n          normalMap: photoNormal,\n          normalScale: new THREE.Vector2(0.35, 0.35),\n          alphaTest: 0.42,\n          side: THREE.DoubleSide,\n          roughness: 0.5626,\n          metalness: 0,\n          clearcoat: 0.5256,\n          clearcoatRoughness: 0.4274,\n          thickness: 0,\n          transmission: 0.015,\n          sheen: 0.24,\n          sheenColor: new THREE.Color(kind === \"calathea\" ? 0xc6a68d : 0x7da06a),\n          sheenRoughness: 0.8,\n          emissive: new THREE.Color(0x06140a),\n          emissiveIntensity: 0.18,\n          shadowSide: THREE.DoubleSide,\n        });\n        // Transmission and ordinary passes can compile separate shader variants.\n        // All variants share one time uniform, including a late first compilation.\n        material.userData.timeUniform = { value: 0 };\n        material.onBeforeCompile = (shader) => {\n          shader.uniforms.uTime = material.userData.timeUniform;\n          shader.uniforms.uWindStrength = { value: WIND_STRENGTH };\n          shader.uniforms.uTurbulence = { value: TURBULENCE };\n          shader.uniforms.uShapeNoise = { value: 2.5 };\n          shader.uniforms.uTextureNoise = { value: 2 };\n          shader.uniforms.uPhotoTexture = { value: 1.5 };\n          shader.uniforms.uPhotoSurface = { value: photoSurface };\n          shader.vertexShader = shader.vertexShader\n            .replace(\n              \"#include <common>\",\n              `#include <common>\n              uniform float uTime;\n              uniform float uWindStrength;\n              uniform float uTurbulence;\n              uniform float uShapeNoise;\n            `,\n            )\n            .replace(\n              \"#include <begin_vertex>\",\n              `\n              vec3 transformed = vec3(position);\n              float root = pow(uv.y, 1.28);\n              float worldPhase = dot(modelMatrix[3].xyz, vec3(0.71, 1.13, 0.43)) + ${index.toFixed(1)};\n              vec2 worldXY = modelMatrix[3].xy;\n              float gustCell = sin(uTime * 0.23 + worldXY.x * 0.42 + sin(worldXY.y * 0.37 + uTime * 0.11));\n              float localGust = pow(max(0.0, gustCell), 3.6);\n              float breath = sin(uTime * 0.46 + worldPhase) * 0.20 + sin(uTime * 1.17 + worldPhase * 1.7) * 0.07 + localGust * 0.62;\n              float flutter = (sin(uTime * 2.7 + uv.y * 8.0 + worldPhase * 2.2) * 0.012 + localGust * sin(uv.y * 11.0 + worldPhase) * 0.038) * uTurbulence;\n              float edgeNoise = sin(uv.y * 31.0 + worldPhase * 4.1) * pow(abs(uv.x - 0.5) * 2.0, 2.4) * 0.022 * uShapeNoise;\n              transformed.x += (breath * 0.075 * uWindStrength + flutter + edgeNoise) * root;\n              transformed.z += breath * 0.12 * root * uWindStrength + flutter * root * 0.8 + edgeNoise;\n              transformed.z += (1.0 - pow(abs(uv.x - 0.5) * 2.0, 1.65)) * 0.075;\n            `,\n            );\n          shader.fragmentShader = shader.fragmentShader\n            .replace(\n              \"#include <common>\",\n              `#include <common>\n              uniform float uTextureNoise;\n              uniform float uPhotoTexture;\n              uniform sampler2D uPhotoSurface;`,\n            )\n            .replace(\n              \"#include <map_fragment>\",\n              `#include <map_fragment>\n              float leafNoise = fract(sin(dot(vMapUv * vec2(311.7, 917.3), vec2(12.9898, 78.233))) * 43758.5453);\n              diffuseColor.rgb *= 1.0 + (leafNoise - 0.5) * 0.18 * uTextureNoise;\n              vec3 photographedSurface = texture2D(uPhotoSurface, vMapUv * vec2(2.4, 4.8)).rgb;\n              diffuseColor.rgb *= mix(vec3(1.0), photographedSurface * 1.24, clamp(uPhotoTexture, 0.0, 1.0) * 0.26);\n            `,\n            );\n          material.userData.shader = shader;\n        };\n        material.customProgramCacheKey = () => `cpt-leaf-wind-photo-v6-${index}`;\n        materials[kind] = material;\n        shaderMaterials.push(material);\n      }\n\n      const geometryCache = new Map();\n      function leafGeometry(width, length) {\n        const key = `${width.toFixed(2)}-${length.toFixed(2)}`;\n        if (geometryCache.has(key)) return geometryCache.get(key);\n        const geo = new THREE.PlaneGeometry(width, length, 12, 22);\n        geo.translate(0, length * 0.5, 0);\n        const position = geo.attributes.position;\n        const uv = geo.attributes.uv;\n        for (let i = 0; i < position.count; i++) {\n          const across = position.getX(i) / (width * 0.5);\n          const along = uv.getY(i);\n          const arch = (1 - Math.pow(Math.abs(across), 1.62)) * Math.sin(Math.PI * along);\n          const twist = across * (along - 0.22);\n          const edgeRipple =\n            Math.sin(along * Math.PI * 5.4 + across * 2.1) * Math.pow(Math.abs(across), 2.2);\n          position.setZ(\n            i,\n            arch * length * 0.052 + twist * length * 0.038 + edgeRipple * length * 0.012,\n          );\n        }\n        position.needsUpdate = true;\n        geo.computeVertexNormals();\n        geometryCache.set(key, geo);\n        return geo;\n      }\n\n      const DIMS = {\n        monstera: [2.05, 2.7],\n        alocasia: [1.92, 2.85],\n        lance: [0.68, 3.45],\n        calathea: [1.36, 3.05],\n        fern: [0.46, 1.5],\n      };\n      const leaves = [];\n      for (const batch of window.__cptBatches) {\n        for (const spec of batch) {\n          const dims = DIMS[spec.kind];\n          if (spec.batch === 2) {\n            // Start the entire leaf below the camera frustum, including its\n            // tip, wind deformation and the small camera orbit. Its identity\n            // persists: the lift carries it into view rather than spawning it.\n            const reach =\n              Math.hypot(dims[0] * spec.widthMul * 0.5, dims[1] * spec.lengthMul) * spec.scale;\n            spec.liftStartY =\n              -Math.tan(THREE.MathUtils.degToRad(camera.fov * 0.5)) * (CAM_DIST - spec.liftZ) -\n              reach -\n              2;\n          }\n          const group = new THREE.Group();\n          const mesh = new THREE.Mesh(\n            leafGeometry(dims[0] * spec.widthMul, dims[1] * spec.lengthMul),\n            materials[spec.kind],\n          );\n          mesh.castShadow = true;\n          mesh.receiveShadow = spec.z < 4.8;\n          group.add(mesh);\n          group.visible = false;\n          group.position.set(spec.xStart, spec.y0, spec.z);\n          group.scale.setScalar(spec.scale);\n          group.rotation.set(spec.tiltX, spec.tiltY, spec.rotation);\n          scene.add(group);\n          leaves.push({ group, spec });\n        }\n      }\n\n      /* ---- The headlines live IN the scene, behind the leaf band, so foliage\n         genuinely occludes them. Reveal is a wipe uniform that tracks the sweep's\n         trailing edge — the visible edge always sits under the dense part of the\n         band, so the type reads as uncovered by the passing leaves, never faded. */\n      function headlineTexture(text) {\n        // Enough source detail for the headline at both 1x and 2x output density.\n        const c = document.createElement(\"canvas\");\n        c.width = 4096;\n        c.height = 1024;\n        const g = c.getContext(\"2d\");\n        g.clearRect(0, 0, c.width, c.height);\n        g.textAlign = \"center\";\n        g.textBaseline = \"middle\";\n        let size = 380;\n        const applyFont = () => {\n          g.font = `${FONT_WEIGHT} ${size}px ${FONT_STACK}`;\n          g.letterSpacing = `${Math.round(size * LETTER_SP)}px`;\n        };\n        applyFont();\n        let tw = g.measureText(text).width;\n        if (tw > 3760) {\n          size = Math.floor((size * 3760) / tw);\n          applyFont();\n        }\n        /* User size multiplier rides on top of the auto-fit. */\n        size = Math.round(size * FONT_SIZE);\n        applyFont();\n        g.shadowColor = \"rgba(0,0,0,0.5)\";\n        g.shadowBlur = 30;\n        g.shadowOffsetY = 8;\n        g.fillStyle = \"#e4eedb\";\n        g.fillText(text, c.width / 2 + Math.round(size * LETTER_SP * 0.5), c.height / 2 + 16);\n        const t = new THREE.CanvasTexture(c);\n        t.colorSpace = THREE.SRGBColorSpace;\n        t.anisotropy = 16;\n        return t;\n      }\n\n      function headlinePlane(text, second = false) {\n        const mat = new THREE.MeshBasicMaterial({\n          map: headlineTexture(text),\n          transparent: true,\n          toneMapped: false,\n          fog: false,\n          depthWrite: false,\n        });\n        const uniforms = { uIn: { value: -0.05 }, uOut: { value: -0.05 }, uLift: { value: -0.05 } };\n        mat.onBeforeCompile = (shader) => {\n          shader.uniforms.uIn = uniforms.uIn;\n          shader.uniforms.uOut = uniforms.uOut;\n          shader.uniforms.uLift = uniforms.uLift;\n          shader.fragmentShader = shader.fragmentShader\n            .replace(\n              \"#include <common>\",\n              \"#include <common>\\nuniform float uIn;\\nuniform float uOut;\\nuniform float uLift;\",\n            )\n            .replace(\n              \"#include <map_fragment>\",\n              `#include <map_fragment>\n              float eIn = uIn + sin(vMapUv.y * 43.0) * 0.012;\n              float eOut = uOut + sin(vMapUv.y * 37.0 + 2.0) * 0.012;\n              float vis = smoothstep(eIn + 0.02, eIn - 0.02, vMapUv.x) * smoothstep(eOut - 0.02, eOut + 0.02, vMapUv.x);\n              float lifted = smoothstep(uLift - 0.08, uLift + 0.08, vMapUv.y);\n              diffuseColor.a *= vis * ${second ? \"(1.0 - lifted)\" : \"lifted\"};`,\n            );\n        };\n        mat.customProgramCacheKey = () => \"cpt-headline-lift-\" + second;\n        const mesh = new THREE.Mesh(new THREE.PlaneGeometry(16.4, 4.1), mat);\n        mesh.position.set(0, 0.15, TEXT_Z);\n        mesh.renderOrder = 2;\n        // Exclude type from the bokeh colour/depth passes. Its alpha edges must\n        // not be blurred using the discontinuous text/backdrop depth samples.\n        mesh.layers.set(1);\n        scene.add(mesh);\n        return {\n          mesh,\n          mat,\n          uniforms,\n          retex: (t2) => {\n            const previous = mat.map;\n            mat.map = headlineTexture(t2);\n            previous.dispose();\n            mat.needsUpdate = true;\n          },\n        };\n      }\n\n      const plane1 = headlinePlane(HEADLINE1);\n      const plane2 = headlinePlane(HEADLINE2, true);\n\n      // ---- Glow motes (drift is a pure function of seed and t).\n      const DUST_COUNT = 800;\n      const dustHome = Float32Array.from(window.__cptDust.home);\n      const dustSeeds = Float32Array.from(window.__cptDust.seeds);\n      const dustPositions = dustHome.slice();\n      const dustGeo = new THREE.BufferGeometry();\n      dustGeo.setAttribute(\"position\", new THREE.BufferAttribute(dustPositions, 3));\n      dustGeo.setAttribute(\"seed\", new THREE.BufferAttribute(dustSeeds, 1));\n      const moteCanvas = document.createElement(\"canvas\");\n      moteCanvas.width = moteCanvas.height = 64;\n      const moteCtx = moteCanvas.getContext(\"2d\");\n      const moteGradient = moteCtx.createRadialGradient(32, 32, 0, 32, 32, 31);\n      moteGradient.addColorStop(0, \"rgba(255,255,232,1)\");\n      moteGradient.addColorStop(0.16, \"rgba(224,255,202,.92)\");\n      moteGradient.addColorStop(0.5, \"rgba(180,228,160,.28)\");\n      moteGradient.addColorStop(1, \"rgba(140,205,125,0)\");\n      moteCtx.fillStyle = moteGradient;\n      moteCtx.fillRect(0, 0, 64, 64);\n      const moteSprite = new THREE.CanvasTexture(moteCanvas);\n      moteSprite.colorSpace = THREE.SRGBColorSpace;\n      const dustMat = new THREE.PointsMaterial({\n        color: new THREE.Color(\"#daf9b4\"),\n        map: moteSprite,\n        size: 0.1,\n        transparent: true,\n        opacity: 0.55,\n        depthWrite: false,\n        blending: THREE.AdditiveBlending,\n      });\n      const dust = new THREE.Points(dustGeo, dustMat);\n      scene.add(dust);\n\n      // BokehPass depth prepass with alpha-aware materials (ported from the experiment).\n      const dofDepthMaterials = new Map();\n      function depthMaterialFor(source) {\n        const key = source.uuid;\n        if (dofDepthMaterials.has(key)) return dofDepthMaterials.get(key);\n        const depth = new THREE.MeshDepthMaterial({\n          depthPacking: THREE.RGBADepthPacking,\n          map: source.map || null,\n          alphaTest: source.alphaTest || 0.5,\n          side: source.side,\n          depthTest: true,\n          depthWrite: true,\n        });\n        dofDepthMaterials.set(key, depth);\n        return depth;\n      }\n      bokehPass.render = function (activeRenderer, writeBuffer, readBuffer) {\n        const swapped = [];\n        const dustVisible = dust.visible;\n        dust.visible = false;\n        this.scene.traverse((object) => {\n          if (!object.isMesh) return;\n          swapped.push([object, object.material]);\n          object.material = depthMaterialFor(object.material);\n        });\n        try {\n          activeRenderer.setRenderTarget(this.renderTargetDepth);\n          activeRenderer.clear();\n          activeRenderer.render(this.scene, this.camera);\n        } finally {\n          for (const [object, material] of swapped) object.material = material;\n          dust.visible = dustVisible;\n        }\n        this.uniforms.tColor.value = readBuffer.texture;\n        this.uniforms.tDepth.value = this.renderTargetDepth.texture;\n        activeRenderer.setRenderTarget(writeBuffer);\n        if (this.clear) activeRenderer.clear();\n        this.fsQuad.render(activeRenderer);\n\n        // Bring the blurred foliage back without clearing the ORIGINAL colour\n        // pass's depth. That depth includes the leaves' alpha cutouts and wind\n        // deformation, so the unblurred headline still sits behind the canopy.\n        const copy = composer.copyPass;\n        copy.renderToScreen = false;\n        const background = scene.background;\n        const autoClear = activeRenderer.autoClear;\n        const layers = camera.layers.mask;\n        const shadowAutoUpdate = activeRenderer.shadowMap.autoUpdate;\n        try {\n          scene.background = null;\n          activeRenderer.autoClear = false;\n          activeRenderer.shadowMap.autoUpdate = false;\n          copy.render(activeRenderer, readBuffer, writeBuffer);\n          camera.layers.set(1);\n          activeRenderer.render(scene, camera);\n        } finally {\n          scene.background = background;\n          activeRenderer.autoClear = autoClear;\n          activeRenderer.shadowMap.autoUpdate = shadowAutoUpdate;\n          camera.layers.mask = layers;\n        }\n        // Keep the existing colour pipeline for both foliage and typography.\n        copy.renderToScreen = this.renderToScreen;\n        copy.render(activeRenderer, writeBuffer, readBuffer);\n      };\n\n      const cameraTarget = new THREE.Vector3(0, 0, -1.5);\n      const cameraOffset = new THREE.Vector3();\n      const cameraOrbit = new THREE.Euler(0, 0, 0, \"YXZ\");\n      const degToRad = THREE.MathUtils.degToRad;\n      const DJ = 0.5;\n\n      function motionClock(t) {\n        const end = window.__cptWindows.s2 + window.__cptWindows.d2;\n        const duration = Math.max(0.1, 10.5 - end);\n        const p = clamp((t - end) / duration, 0, 1);\n        return t <= end ? t : end + duration * (p - (p * p) / 2);\n      }\n\n      function openingWind(spec, t) {\n        const wt = motionClock(t) * WIND_SPEED;\n        const gust = Math.sin(wt * 0.23 + spec.restX * 0.42 + Math.sin(spec.y0 * 0.37 + wt * 0.11));\n        const sway =\n          (Math.sin(wt * 0.46 + spec.phase) * 0.011 +\n            Math.sin(wt * 0.58 + spec.y0 * 0.74) * 0.007 +\n            Math.max(0, gust) ** 3.6 * 0.03) *\n          WIND_STRENGTH;\n        return [sway, Math.sin(wt * 0.31 + spec.phase) * 0.02];\n      }\n\n      // Sample the authored incoming path, including its actual rotation/wind.\n      // Only retained leaves use this path; the passing leaf wall stays intact.\n      function retainedSweepPose(s, t) {\n        const w = window.__cptWindows;\n        if (s.batch === 2) {\n          const p = clamp(clamp((t - w.s2) / w.d2, 0, 1) * 1.28 - s.liftDelay, 0, 1);\n          const lift = smoothstep(0, 0.58, p),\n            seat = smoothstep(0.38, 1, p);\n          return [\n            THREE.MathUtils.lerp(s.liftX, s.restX, seat),\n            THREE.MathUtils.lerp(s.liftY, s.restY, seat) -\n              (s.liftY - s.liftStartY) * (1 - smoothstep(0, 0.42, p)),\n            THREE.MathUtils.lerp(s.liftZ, s.z, lift),\n            s.tiltX + seat * 3.6 * Math.sin(s.phase),\n            s.tiltY + seat * 3.6 * Math.cos(s.phase * 1.7),\n            THREE.MathUtils.lerp(s.rotation, s.restRZ, seat),\n          ];\n        }\n        const p = clamp(clamp((t - 0.4) / w.d1, 0, 1) * 1.5 - s.delay, 0, 1);\n        const pe = 1 - Math.pow(1 - p, 3);\n        const rz = s.rotation + pe * s.spin * 0.55;\n        const turn =\n          ((((s.restRZ - rz + Math.PI) % (2 * Math.PI)) + 2 * Math.PI) % (2 * Math.PI)) - Math.PI;\n        const [wind, roll] = openingWind(s, t);\n        return [\n          s.xStart + (s.restX - s.xStart) * pe,\n          s.y0 +\n            (s.restY - s.y0) * pe +\n            Math.sin(pe * Math.PI * 1.4 + s.phase) * s.bobAmp * (1 - pe) * 0.8 +\n            wind * 0.14,\n          s.z,\n          s.tiltX + wind,\n          s.tiltY + wind * 0.65,\n          rz + turn * smoothstep(0.55, 1, pe) + roll,\n        ];\n      }\n\n      function retainedIdlePose(spec, t, handoff) {\n        const b = spec.breeze,\n          age = t - handoff.start,\n          a = age * b.rate;\n        const pose = handoff.center.slice();\n        if (spec.batch === 1) {\n          const [wind, roll] = openingWind(spec, t);\n          pose[1] += wind * 0.14;\n          pose[3] += wind;\n          pose[4] += wind * 0.65;\n          pose[5] += roll;\n        }\n        const floatX = Math.sin(a + b.phase) * 0.72 + Math.sin(a * 0.613 + b.phase2) * 0.28;\n        const floatY = Math.sin(a * 0.79 + b.phase2) * 0.76 + Math.sin(a * 1.137 + b.phase3) * 0.24;\n        const floatZ = Math.sin(a * 0.53 + b.phase3);\n        const offsets = [\n          b.driftX * floatX,\n          b.driftY * floatY,\n          b.depth + b.driftZ * floatZ,\n          b.tiltX * Math.sin(a * 0.67 + b.phase2),\n          b.tiltY * Math.sin(a * 0.47 + b.phase3),\n          b.roll * floatX + b.turn * age,\n        ];\n        return pose.map((v, i) => v + RETAINED_BREEZE * offsets[i]);\n      }\n\n      // Join while each leaf still has momentum, before its old stop point.\n      // Quintic Hermite correction matches position, velocity AND acceleration\n      // at both ends. The moving breeze target is present throughout settling;\n      // there is no idle timer, zero-velocity rest, or later amplitude fade-in.\n      for (const { spec: s } of leaves) {\n        if (!s.stayer) continue;\n        const w = window.__cptWindows,\n          first = s.batch === 1;\n        const rate = first ? 1.5 / w.d1 : 1.28 / w.d2;\n        const progress = (first ? 0.64 : 0.78) + s.breeze.arrival * 0.12;\n        const start = (first ? 0.4 : w.s2) + (progress + (first ? s.delay : s.liftDelay)) / rate;\n        const end = first ? 0.4 + w.d1 : w.s2 + w.d2;\n        const center = retainedSweepPose(s, end);\n        const incoming = retainedSweepPose(s, start);\n        if (first) {\n          const [wind, roll] = openingWind(s, end);\n          center[1] -= wind * 0.14;\n          center[3] -= wind;\n          center[4] -= wind * 0.65;\n          center[5] -= roll;\n        }\n        for (let i = 3; i < 6; i++)\n          center[i] += Math.round((incoming[i] - center[i]) / (2 * Math.PI)) * 2 * Math.PI;\n        const h = (s.handoff = { start, duration: (first ? 0.52 : 0.48) / rate, center });\n        const dt = 0.001;\n        const delta = (time) =>\n          retainedSweepPose(s, time).map((v, i) => v - retainedIdlePose(s, time, h)[i]);\n        const a = delta(start - dt),\n          b = delta(start),\n          c = delta(start + dt);\n        h.correction = b.map((v, i) => [\n          v,\n          (c[i] - a[i]) / (2 * dt),\n          (c[i] - 2 * v + a[i]) / (dt * dt),\n        ]);\n      }\n\n      function applyRetainedMotion(group, spec, t) {\n        const h = spec.handoff;\n        if (!h || !group.visible) return;\n        if (t < h.start) {\n          // Use the same unrounded clock on both sides of the handoff; GSAP's\n          // rounded scalar writes must not introduce a tiny boundary jump.\n          const incoming = retainedSweepPose(spec, t);\n          group.position.set(incoming[0], incoming[1], incoming[2]);\n          group.rotation.set(incoming[3], incoming[4], incoming[5]);\n          return;\n        }\n        const pose = retainedIdlePose(spec, t, h);\n        const u = clamp((t - h.start) / h.duration, 0, 1);\n        const u2 = u * u,\n          u3 = u2 * u,\n          u4 = u3 * u,\n          u5 = u4 * u;\n        const p = 1 - 10 * u3 + 15 * u4 - 6 * u5;\n        const v = u - 6 * u3 + 8 * u4 - 3 * u5;\n        const a = (u2 - 3 * u3 + 3 * u4 - u5) / 2;\n        for (let i = 0; i < 6; i++) {\n          const c = h.correction[i];\n          pose[i] += c[0] * p + c[1] * h.duration * v + c[2] * h.duration * h.duration * a;\n        }\n        if (spec.batch === 1) {\n          // Carry the current floating pose into takeoff, never pull it back\n          // to a rest slot. Quintic lift starts with zero added speed/acceleration.\n          const m = clamp((t - window.__cptWindows.s2) / window.__cptWindows.d2, 0, 1);\n          const q = clamp(m * 1.5 - spec.delay2 * 0.4, 0, 1);\n          const lift = q * q * q * (10 + q * (-15 + 6 * q));\n          pose[1] += lift * 6;\n          pose[2] += lift * 34;\n          pose[5] += lift * spec.spin * 0.55;\n        }\n        group.position.set(pose[0], pose[1], pose[2]);\n        group.rotation.set(pose[3], pose[4], pose[5]);\n      }\n\n      let disposed = false;\n      function renderAt(t) {\n        if (disposed) return;\n        t = clamp(t, 0, DUR);\n        const settleTime = window.__cptWindows.s2 + window.__cptWindows.d2;\n        const settleDuration = Math.max(0.1, 10.5 - settleTime);\n        const settleProgress = clamp((t - settleTime) / settleDuration, 0, 1);\n        const motionTime =\n          t <= settleTime\n            ? t\n            : settleTime +\n              settleDuration * (settleProgress - (settleProgress * settleProgress) / 2);\n        const wt = motionTime * WIND_SPEED;\n        const m1 = state.sw1;\n        const m2 = state.sw2;\n\n        for (const { group, spec } of leaves) {\n          // Depth lift: emerge from the backdrop, cross the type plane,\n          // rise through the focal range, then pass the camera (source exitDistance=34).\n          // No lateral sweep, frame history, pointer force, or accumulated physics.\n          if (spec.batch === 2) {\n            const p = clamp(m2 * 1.28 - spec.liftDelay, 0, 1);\n            // At p=0 it is already below frame; at p=1 passers are behind\n            // the camera. No visibility/opacity switch at either boundary.\n            group.visible = true;\n            const entry = smoothstep(0, 0.42, p);\n            const lift = smoothstep(0, 0.58, p);\n            const exit = smoothstep(0.38, 1, p);\n            const seat = smoothstep(0.38, 1, p);\n            const z = spec.stayer\n              ? THREE.MathUtils.lerp(spec.liftZ, spec.z, lift)\n              : spec.liftZ + lift * 8 * spec.depthResponse + exit * 34;\n            const orbit = exit * 1.15;\n            const x = spec.stayer\n              ? THREE.MathUtils.lerp(spec.liftX, spec.restX, seat)\n              : spec.liftX + Math.cos(spec.phase + p * 1.3) * orbit;\n            const liftedY = spec.stayer\n              ? THREE.MathUtils.lerp(spec.liftY, spec.restY, seat)\n              : spec.liftY + lift * 2.2 + exit * 3.8;\n            const y = liftedY - (spec.liftY - spec.liftStartY) * (1 - entry);\n            group.position.set(x, y, z);\n            group.rotation.set(\n              spec.tiltX + exit * 3.6 * Math.sin(spec.phase),\n              spec.tiltY + exit * 3.6 * Math.cos(spec.phase * 1.7),\n              spec.stayer\n                ? THREE.MathUtils.lerp(spec.rotation, spec.restRZ, seat)\n                : spec.rotation + exit * 3.6 * 0.55,\n            );\n            continue;\n          }\n          const m = spec.batch === 1 ? m1 : m2;\n          const p = clamp(m * (1 + DJ) - spec.delay, 0, 1);\n          if (p <= 0.0005) {\n            group.visible = false;\n            continue;\n          }\n          group.visible = true;\n\n          // Analytic wind sway, always applied (scaled up once settled).\n          const gustCell = Math.sin(\n            wt * 0.23 + spec.restX * 0.42 + Math.sin(spec.y0 * 0.37 + wt * 0.11),\n          );\n          const localGust = Math.max(0, gustCell) ** 3.6;\n          const slowWind =\n            (Math.sin(wt * 0.46 + spec.phase) * 0.011 +\n              Math.sin(wt * 0.58 + spec.y0 * 0.74) * 0.007 +\n              localGust * 0.03) *\n            WIND_STRENGTH;\n\n          let x,\n            y,\n            rz,\n            z = spec.z;\n          if (!spec.stayer) {\n            const pe = p * p * (3 - 2 * p);\n            x = spec.xStart + (spec.xEnd - spec.xStart) * pe;\n            y = spec.y0 + Math.sin(pe * Math.PI * spec.bobN + spec.phase) * spec.bobAmp;\n            rz = spec.rotation + pe * spec.spin;\n          } else {\n            const pe = 1 - Math.pow(1 - p, 3);\n            x = spec.xStart + (spec.restX - spec.xStart) * pe;\n            y =\n              spec.y0 +\n              (spec.restY - spec.y0) * pe +\n              Math.sin(pe * Math.PI * 1.4 + spec.phase) * spec.bobAmp * (1 - pe) * 0.8;\n            const travelRz = spec.rotation + pe * spec.spin * 0.55;\n            const seat = smoothstep(0.55, 1, pe);\n            const dRz =\n              ((((spec.restRZ - travelRz + Math.PI) % (2 * Math.PI)) + 2 * Math.PI) %\n                (2 * Math.PI)) -\n              Math.PI;\n            rz = travelRz + dRz * seat;\n            if (spec.batch === 1 && m2 > 0) {\n              // Existing edge leaves join the same upward depth current.\n              const q = clamp(m2 * 1.5 - spec.delay2 * 0.4, 0, 1);\n              const qe = smoothstep(0, 1, q);\n              z += qe * 34;\n              y += qe * 6;\n              rz += qe * spec.spin * 0.55;\n            }\n          }\n\n          group.position.set(x, y + slowWind * 0.14, z);\n          group.rotation.set(\n            spec.tiltX + slowWind,\n            spec.tiltY + slowWind * 0.65,\n            rz + Math.sin(wt * 0.31 + spec.phase) * 0.02,\n          );\n        }\n\n        // The background/camera can settle while retained leaves keep breathing\n        // through the final hold. Use absolute t, never accumulated frame deltas.\n        for (const { group, spec } of leaves) applyRetainedMotion(group, spec, t);\n\n        /* Reveal wipes, derived from the sweep masters. Tuned so the visible wipe\n           edge stays inside the dense part of the leaf band (verified visually). */\n        plane1.uniforms.uIn.value = clamp((m1 - 0.3) / 0.52, 0, 1) * 1.1 - 0.05;\n        plane1.uniforms.uOut.value = -0.05;\n        plane2.uniforms.uIn.value = 1.05;\n        plane1.uniforms.uLift.value = smoothstep(0.25, 0.43, m2) * 1.3 - 0.15;\n        plane2.uniforms.uLift.value = smoothstep(0.4, 0.62, m2) * 1.3 - 0.15;\n        // Source experiment DOF at lift peak; return to V1's crisp hold.\n        const lens = smoothstep(0.05, 0.28, m2) * (1 - smoothstep(0.72, 1, m2));\n        bokehPass.uniforms.aperture.value = 0.0016 + lens * 0.0005;\n        bokehPass.uniforms.maxblur.value = 0.0055 + lens * 0.0035;\n        plane2.uniforms.uOut.value = -0.05;\n\n        for (const material of shaderMaterials) {\n          material.userData.timeUniform.value = wt;\n        }\n\n        for (let i = 0; i < DUST_COUNT; i++) {\n          const o = i * 3;\n          const s = dustSeeds[i];\n          dustPositions[o] = dustHome[o] + Math.sin(wt * 0.19 + s * 18) * 0.36;\n          dustPositions[o + 1] = dustHome[o + 1] + Math.cos(wt * 0.14 + s * 27) * 0.38;\n          dustPositions[o + 2] = dustHome[o + 2] + Math.sin(wt * 0.11 + s * 41) * 0.4;\n        }\n        dustGeo.attributes.position.needsUpdate = true;\n\n        const swayX = Math.sin(motionTime * 0.31) * 0.6 + Math.sin(motionTime * 0.127 + 2.1) * 0.5;\n        const swayY = Math.sin(motionTime * 0.083 + 1.7) * 0.7;\n        cameraOrbit.set(degToRad(-swayY), degToRad(swayX), 0, \"YXZ\");\n        cameraOffset.set(0, 0.15, CAM_DIST).applyEuler(cameraOrbit);\n        camera.position.copy(cameraTarget).add(cameraOffset);\n        camera.lookAt(cameraTarget);\n        dust.rotation.x = degToRad(-swayY) * 0.6;\n        dust.rotation.y = degToRad(swayX) * 0.6;\n\n        composer.render();\n      }\n\n      function onSeek(event) {\n        const time = clamp(Number(event.detail?.time) || 0, 0, DUR);\n        const timeline = window.__timelines[\"canopy-part-title\"];\n        timeline.totalTime(time, true);\n        renderAt(time);\n      }\n      window.addEventListener(\"hf-seek\", onSeek);\n      window.__cptInstance = {\n        dispose() {\n          if (disposed) return;\n          disposed = true;\n          window.removeEventListener(\"hf-seek\", onSeek);\n          const resources = new Set();\n          scene.traverse((object) => {\n            if (object.geometry) resources.add(object.geometry);\n            for (const mat of [object.material].flat().filter(Boolean)) {\n              resources.add(mat);\n              for (const value of Object.values(mat)) if (value?.isTexture) resources.add(value);\n            }\n          });\n          for (const mat of dofDepthMaterials.values()) resources.add(mat);\n          for (const resource of resources) resource.dispose();\n          bokehPass.dispose();\n          composer.dispose();\n          renderer.dispose();\n          renderer.forceContextLoss();\n          window.__cptRender = null;\n        },\n      };\n      window.__cptRender = renderAt;\n\n      const tl = window.__timelines[\"canopy-part-title\"];\n      // Compile every leaf material before the first time sample. Hidden leaves\n      // otherwise compile on their first visible seek with uTime=0, making that\n      // frame differ from a later seek to the same time.\n      for (const { group } of leaves) group.visible = true;\n      renderer.compile(scene, camera);\n      renderAt(0);\n      renderAt(window.__hfThreeTime ?? (tl ? tl.time() : 0));\n      /* Draw across the timeline and flush the GPU before ready, so shader links\n         and texture uploads land in the readiness gate, not the first visible frames. */\n      async function warmGpu() {\n        const dur = tl ? tl.duration() : 0;\n        for (const f of [0.25, 0.5, 0.75]) {\n          await new Promise((resolve) => setTimeout(resolve, 0));\n          renderAt(dur * f);\n        }\n        renderAt(tl ? tl.time() : 0);\n        renderer.getContext().finish();\n      }\n      window.__hf = window.__hf || {};\n      window.__hf.buildReady = window.__hf.buildReady || {};\n      if (document.fonts && document.fonts.ready) {\n        window.__cptReady = Promise.all([\n          document.fonts.load(`${FONT_WEIGHT} 100px \"${FONT}\"`).catch(() => {}),\n          document.fonts.ready,\n        ])\n          .then(() => {\n            if (disposed) return;\n            plane1.retex(HEADLINE1);\n            plane2.retex(HEADLINE2);\n            renderAt(tl ? tl.time() : 0);\n            return warmGpu();\n          })\n          .catch(() => {});\n        window.__hf.buildReady[\"canopy-part-title\"] = window.__cptReady;\n      } else {\n        window.__hf.buildReady[\"canopy-part-title\"] = warmGpu();\n      }\n    </script>\n  </body>\n</html>\n"}