Skip to content

Write HTML. Render video. Built for agents.

44.8 KB
Raw Blame
{"html":"<!doctype html>\n<html lang=\"en\">\n  <head><base href=\"/public/catalog/items/code-slice-hero/\">\n    <meta charset=\"utf-8\" />\n    <meta name=\"viewport\" content=\"width=1920, height=1080\" />\n    <title>Code Slice Hero</title>\n    <script>(function(){\nconst vendor=(url)=>fetch(url).then((r)=>r.json()).then((j)=>j.text);\nconst run=(code,name)=>{const s=document.createElement(\"script\");s.text=code+\"\\n//# sourceURL=hyperframes-catalog://code-slice-hero/\"+name;document.head.append(s);};\n(async()=>{\nrun(await vendor(\"/public/catalog/vendor/gsap-3.14.2.min.json\"),\"gsap-3.14.2.min.js\");\nrun(\"/* Local projected shadows: fixed light, spatial buckets, one extra GPU draw. */\\nwindow.CodeSliceShadows = function (gl, tiles, poses, strength, softness) {\\n  \\\"use strict\\\";\\n  const stride = 29,\\n    light = [0.65, 0.8, -1],\\n    bucketSize = Math.max(64, tiles[0].width);\\n  const states = tiles.map(() => ({\\n    c: new Float64Array(3),\\n    u: new Float64Array(3),\\n    v: new Float64Array(3),\\n    n: new Float64Array(3),\\n    q: new Float64Array(4),\\n  }));\\n  const buckets = new Map(),\\n    usedBuckets = [],\\n    seen = new Int32Array(tiles.length);\\n  let stamp = 0,\\n    count = 0,\\n    storage = new Float32Array(Math.max(64, tiles.length * 8) * stride),\\n    capacity = 0;\\n  const stats = { pairs: 0, shadows: 0 };\\n  const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];\\n  const shaders = [];\\n  function compile(kind, source) {\\n    const s = gl.createShader(kind);\\n    gl.shaderSource(s, source);\\n    gl.compileShader(s);\\n    if (!gl.getShaderParameter(s, gl.COMPILE_STATUS)) throw new Error(gl.getShaderInfoLog(s));\\n    shaders.push(s);\\n    return s;\\n  }\\n  const program = gl.createProgram();\\n  gl.attachShader(\\n    program,\\n    compile(\\n      gl.VERTEX_SHADER,\\n      `#version 300 es\\n  precision highp float;\\n  layout(location=0) in vec2 aCorner;\\n  layout(location=1) in vec3 aCenter;\\n  layout(location=2) in vec3 aU;\\n  layout(location=3) in vec3 aV;\\n  layout(location=4) in vec3 aReceiver;\\n  layout(location=5) in vec3 aReceiverU;\\n  layout(location=6) in vec3 aReceiverV;\\n  layout(location=7) in vec4 aBounds;\\n  layout(location=8) in vec4 aShape;\\n  layout(location=9) in vec3 aRay;\\n  out vec2 vCasterUV;\\n  out vec2 vReceiverXY;\\n  out float vRay;\\n  flat out vec4 vBounds;\\n  flat out vec4 vShape;\\n  void main(){\\n    vec2 uv=aCorner*(1.0+1.5*aShape.z/aShape.xy);\\n    vec3 p=aCenter+aU*uv.x+aV*uv.y;\\n    float w=1.0-p.z/1712.661;\\n    gl_Position=vec4((p.x-960.0)/960.0,-(p.y-540.0)/540.0,1.00020002*w-0.00116788,w);\\n    vCasterUV=uv;vReceiverXY=vec2(dot(p-aReceiver,aReceiverU),dot(p-aReceiver,aReceiverV));\\n    vRay=aRay.x+aRay.y*uv.x+aRay.z*uv.y;vBounds=aBounds;vShape=aShape;\\n  }`,\\n    ),\\n  );\\n  gl.attachShader(\\n    program,\\n    compile(\\n      gl.FRAGMENT_SHADER,\\n      `#version 300 es\\n  precision highp float;\\n  in vec2 vCasterUV;\\n  in vec2 vReceiverXY;\\n  in float vRay;\\n  flat in vec4 vBounds;\\n  flat in vec4 vShape;\\n  out vec4 color;\\n  void main(){\\n    if(vRay\\u003c=0.2)discard;\\n    // Clip to the actual rounded receiver face, never the revealed void.\\n    vec2 q=abs(vReceiverXY)-(vBounds.xy-vBounds.z);\\n    float receiverDistance=length(max(q,0.0))+min(max(q.x,q.y),0.0)-vBounds.z;\\n    if(receiverDistance>=0.0)discard;\\n    vec2 edge=(abs(vCasterUV)-1.0)*vShape.xy;\\n    float distance=max(edge.x,edge.y);\\n    float alpha=(1.0-smoothstep(-vShape.z,vShape.z,distance))*vBounds.w;\\n    alpha*=smoothstep(0.2,3.0,vRay);\\n    if(alpha\\u003c0.002)discard;\\n    color=vec4(0.0,0.0,0.0,alpha);\\n  }`,\\n    ),\\n  );\\n  gl.linkProgram(program);\\n  if (!gl.getProgramParameter(program, gl.LINK_STATUS))\\n    throw new Error(gl.getProgramInfoLog(program));\\n  const vao = gl.createVertexArray();\\n  gl.bindVertexArray(vao);\\n  const corners = gl.createBuffer();\\n  gl.bindBuffer(gl.ARRAY_BUFFER, corners);\\n  gl.bufferData(\\n    gl.ARRAY_BUFFER,\\n    new Float32Array([-1, -1, 1, -1, 1, 1, -1, -1, 1, 1, -1, 1]),\\n    gl.STATIC_DRAW,\\n  );\\n  gl.enableVertexAttribArray(0);\\n  gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 8, 0);\\n  const buffer = gl.createBuffer();\\n  gl.bindBuffer(gl.ARRAY_BUFFER, buffer);\\n  for (const [loc, size, offset] of [\\n    [1, 3, 0],\\n    [2, 3, 3],\\n    [3, 3, 6],\\n    [4, 3, 9],\\n    [5, 3, 12],\\n    [6, 3, 15],\\n    [7, 4, 18],\\n    [8, 4, 22],\\n    [9, 3, 26],\\n  ]) {\\n    gl.enableVertexAttribArray(loc);\\n    gl.vertexAttribPointer(loc, size, gl.FLOAT, false, stride * 4, offset * 4);\\n    gl.vertexAttribDivisor(loc, 1);\\n  }\\n  function prepare() {\\n    for (const bucket of usedBuckets) bucket.length = 0;\\n    usedBuckets.length = 0;\\n    for (let i = 0; i \\u003c tiles.length; i++) {\\n      const t = tiles[i],\\n        s = states[i],\\n        k = i * 14;\\n      const cx = Math.cos(poses[k + 8]),\\n        sx = Math.sin(poses[k + 8]),\\n        cy = Math.cos(poses[k + 9]),\\n        sy = Math.sin(poses[k + 9]),\\n        cz = Math.cos(poses[k + 10]),\\n        sz = Math.sin(poses[k + 10]);\\n      s.u.set([cy * cz, cx * sz + sx * sy * cz, sx * sz - cx * sy * cz]);\\n      s.v.set([-cy * sz, cx * cz - sx * sy * sz, sx * cz + cx * sy * sz]);\\n      s.n.set([sy, -sx * cy, cx * cy]);\\n      s.c.set([t.cx + poses[k + 4], t.cy + poses[k + 5], poses[k + 6]]);\\n      s.w = (t.width * poses[k + 7]) / 2;\\n      s.h = (t.height * poses[k + 7]) / 2;\\n      s.f = poses[k + 11];\\n      // The visible face is also the depth-tested shadow receiver.\\n      const front =\\n        s.n[0] * (960 - s.c[0]) + s.n[1] * (540 - s.c[1]) + s.n[2] * (1712.661 - s.c[2]) >= 0\\n          ? 1\\n          : -1;\\n      const thickness = 1.5 * s.f * poses[k + 7] * front;\\n      for (let a = 0; a \\u003c 3; a++) s.c[a] += s.n[a] * thickness;\\n      const qx = s.c[0] + light[0] * s.c[2],\\n        qy = s.c[1] + light[1] * s.c[2];\\n      const ux = (s.u[0] + light[0] * s.u[2]) * s.w,\\n        uy = (s.u[1] + light[1] * s.u[2]) * s.w;\\n      const vx = (s.v[0] + light[0] * s.v[2]) * s.h,\\n        vy = (s.v[1] + light[1] * s.v[2]) * s.h;\\n      s.q.set([\\n        qx - Math.abs(ux) - Math.abs(vx),\\n        qy - Math.abs(uy) - Math.abs(vy),\\n        qx + Math.abs(ux) + Math.abs(vx),\\n        qy + Math.abs(uy) + Math.abs(vy),\\n      ]);\\n      for (let y = Math.floor(s.q[1] / bucketSize); y \\u003c= Math.floor(s.q[3] / bucketSize); y++)\\n        for (let x = Math.floor(s.q[0] / bucketSize); x \\u003c= Math.floor(s.q[2] / bucketSize); x++) {\\n          const key = x + \\\",\\\" + y;\\n          let bucket = buckets.get(key);\\n          if (!bucket) {\\n            bucket = [];\\n            buckets.set(key, bucket);\\n          }\\n          if (!bucket.length) usedBuckets.push(bucket);\\n          bucket.push(i);\\n        }\\n    }\\n  }\\n  const delta = new Float64Array(3),\\n    center = new Float64Array(3),\\n    u = new Float64Array(3),\\n    v = new Float64Array(3);\\n  function pair(c, r) {\\n    stats.pairs++;\\n    const denom = dot(r.n, light);\\n    if (Math.abs(denom) \\u003c 0.12) return;\\n    for (let a = 0; a \\u003c 3; a++) delta[a] = r.c[a] - c.c[a];\\n    const ray = dot(delta, r.n) / denom,\\n      ru = (-dot(c.u, r.n) * c.w) / denom,\\n      rv = (-dot(c.v, r.n) * c.h) / denom;\\n    if (ray + Math.abs(ru) + Math.abs(rv) \\u003c 0.5) return;\\n    for (let a = 0; a \\u003c 3; a++) {\\n      center[a] = c.c[a] + light[a] * ray;\\n      u[a] = c.u[a] * c.w + light[a] * ru;\\n      v[a] = c.v[a] * c.h + light[a] * rv;\\n      delta[a] = center[a] - r.c[a];\\n    }\\n    const blur = softness * (1 + Math.max(0, ray) * 0.035);\\n    const rx = dot(delta, r.u),\\n      ry = dot(delta, r.v);\\n    if (\\n      Math.abs(rx) > r.w + Math.abs(dot(u, r.u)) + Math.abs(dot(v, r.u)) + blur * 2 ||\\n      Math.abs(ry) > r.h + Math.abs(dot(u, r.v)) + Math.abs(dot(v, r.v)) + blur * 2\\n    )\\n      return;\\n    const crossX = u[1] * v[2] - u[2] * v[1],\\n      crossY = u[2] * v[0] - u[0] * v[2],\\n      crossZ = u[0] * v[1] - u[1] * v[0];\\n    const area = Math.hypot(crossX, crossY, crossZ),\\n      altU = area / Math.hypot(...v),\\n      altV = area / Math.hypot(...u);\\n    if (!Number.isFinite(altU + altV) || altU \\u003c 0.2 || altV \\u003c 0.2) return;\\n    if ((count + 1) * stride > storage.length) {\\n      const larger = new Float32Array(storage.length * 2);\\n      larger.set(storage);\\n      storage = larger;\\n    }\\n    const offset = count++ * stride;\\n    storage.set(center, offset);\\n    storage.set(u, offset + 3);\\n    storage.set(v, offset + 6);\\n    storage.set(r.c, offset + 9);\\n    storage.set(r.u, offset + 12);\\n    storage.set(r.v, offset + 15);\\n    storage.set(\\n      [\\n        r.w,\\n        r.h,\\n        Math.min(r.w, r.h) * 0.12 * r.f,\\n        strength,\\n        altU,\\n        altV,\\n        Math.max(0.6, blur),\\n        0,\\n        ray,\\n        ru,\\n        rv,\\n      ],\\n      offset + 18,\\n    );\\n  }\\n  return {\\n    stats,\\n    draw() {\\n      stats.pairs = 0;\\n      stats.shadows = 0;\\n      count = 0;\\n      if (strength \\u003c= 0) return 0;\\n      prepare();\\n      for (let i = 0; i \\u003c states.length; i++) {\\n        const c = states[i];\\n        if (c.f \\u003c 0.002) continue;\\n        const pad = softness * (1 + (Math.abs(c.c[2]) + c.w + c.h) * 0.035) * 2;\\n        stamp++;\\n        for (\\n          let y = Math.floor((c.q[1] - pad) / bucketSize);\\n          y \\u003c= Math.floor((c.q[3] + pad) / bucketSize);\\n          y++\\n        )\\n          for (\\n            let x = Math.floor((c.q[0] - pad) / bucketSize);\\n            x \\u003c= Math.floor((c.q[2] + pad) / bucketSize);\\n            x++\\n          ) {\\n            const bucket = buckets.get(x + \\\",\\\" + y);\\n            if (!bucket) continue;\\n            for (const j of bucket) {\\n              if (j === i || seen[j] === stamp) continue;\\n              seen[j] = stamp;\\n              pair(c, states[j]);\\n            }\\n          }\\n      }\\n      stats.shadows = count;\\n      if (!count) return 0;\\n      gl.useProgram(program);\\n      gl.bindVertexArray(vao);\\n      gl.bindBuffer(gl.ARRAY_BUFFER, buffer);\\n      if (capacity \\u003c storage.byteLength) {\\n        capacity = storage.byteLength;\\n        gl.bufferData(gl.ARRAY_BUFFER, capacity, gl.DYNAMIC_DRAW);\\n      }\\n      gl.bufferSubData(gl.ARRAY_BUFFER, 0, storage.subarray(0, count * stride));\\n      gl.depthMask(false);\\n      gl.depthFunc(gl.LEQUAL);\\n      gl.disable(gl.CULL_FACE);\\n      gl.enable(gl.POLYGON_OFFSET_FILL);\\n      gl.polygonOffset(-1, -1);\\n      gl.drawArraysInstanced(gl.TRIANGLES, 0, 6, count);\\n      gl.disable(gl.POLYGON_OFFSET_FILL);\\n      gl.enable(gl.CULL_FACE);\\n      gl.depthMask(true);\\n      gl.depthFunc(gl.LESS);\\n      return 1;\\n    },\\n    dispose() {\\n      shaders.forEach((s) => gl.deleteShader(s));\\n      gl.deleteBuffer(buffer);\\n      gl.deleteBuffer(corners);\\n      gl.deleteVertexArray(vao);\\n      gl.deleteProgram(program);\\n    },\\n  };\\n};\\n\",\"shadows.js\");\nrun(\"/* One shared pair of text atlases, one instance buffer, one surface draw and one batched shadow draw per seek. */\\nwindow.CodeSliceSurface = function (stage, front, back, tiles, options) {\\n  \\\"use strict\\\";\\n  const canvas = document.createElement(\\\"canvas\\\");\\n  canvas.id = \\\"csh-surface\\\";\\n  canvas.width = 1920;\\n  canvas.height = 1080;\\n  canvas.style.cssText = \\\"display:block;width:1920px;height:1080px\\\";\\n  stage.appendChild(canvas);\\n  const gl = canvas.getContext(\\\"webgl2\\\", {\\n    alpha: false,\\n    antialias: true,\\n    preserveDrawingBuffer: true,\\n  });\\n  if (!gl) throw new Error(\\\"Code Slice Hero requires WebGL 2 for its full tile surface.\\\");\\n  const vertex = `#version 300 es\\n  precision highp float;\\n  layout(location=0) in vec3 aPosition;\\n  layout(location=1) in vec2 aUV;\\n  layout(location=2) in float aFace;\\n  layout(location=3) in vec4 aCell;\\n  layout(location=4) in vec4 aMotion;\\n  layout(location=5) in vec4 aAngles;\\n  layout(location=6) in vec2 aSurface;\\n  out vec2 vUV;\\n  out vec2 vAtlasUV;\\n  flat out float vFace;\\n  flat out float vFormation;\\n  flat out float vShade;\\n  flat out float vInk;\\n  void main() {\\n    vec3 p = vec3(aPosition.xy * aCell.zw, aPosition.z * 3.0 * aAngles.w) * aMotion.w;\\n    // CSS transform order is translate * Rx * Ry * Rz * scale.\\n    vec3 c = cos(aAngles.xyz), s = sin(aAngles.xyz);\\n    p.xy = vec2(c.z*p.x-s.z*p.y, s.z*p.x+c.z*p.y);\\n    p.xz = vec2(c.y*p.x+s.y*p.z, -s.y*p.x+c.y*p.z);\\n    p.yz = vec2(c.x*p.y-s.x*p.z, s.x*p.y+c.x*p.z);\\n    p += vec3(aCell.xy, 0.0) + aMotion.xyz;\\n    float w = 1.0 - p.z / 1712.661;\\n    gl_Position = vec4((p.x-960.0)/960.0, -(p.y-540.0)/540.0,\\n      1.00020002*w - 0.00116788, w);\\n    vUV = aUV;\\n    vAtlasUV = (aCell.xy + (aUV-0.5)*aCell.zw) / vec2(1920.0,1080.0);\\n    vFace = aFace; vFormation = aAngles.w; vShade = aSurface.x; vInk = aSurface.y;\\n  }`;\\n  const fragment = `#version 300 es\\n  precision highp float;\\n  uniform sampler2D uFront;\\n  uniform sampler2D uBack;\\n  in vec2 vUV;\\n  in vec2 vAtlasUV;\\n  flat in float vFace;\\n  flat in float vFormation;\\n  flat in float vShade;\\n  flat in float vInk;\\n  out vec4 color;\\n  void main() {\\n    if (vFace > 1.5) {\\n      if (vInk \\u003c 0.5 || vFormation \\u003c 0.003) discard;\\n      float shade = vFace == 4.0 ? 0.910 : vFace == 5.0 ? 0.651 : 0.741;\\n      color = vec4(vec3(shade),1.0); return;\\n    }\\n    float radius = 0.06*vFormation;\\n    vec2 q = abs(vUV-0.5) - (0.5-radius);\\n    float distance = length(max(q,0.0)) + min(max(q.x,q.y),0.0) - radius;\\n    // At zero radius adjacent faces use their exact shared pixel boundary.\\n    float alpha = radius > 0.00001 ? 1.0-smoothstep(-fwidth(distance),0.0,distance) : 1.0;\\n    if (alpha \\u003c 0.01) discard;\\n    vec3 ink = vInk \\u003c 0.5 ? vec3(1.0) :\\n      (vFace \\u003c 0.5 ? texture(uFront,vAtlasUV).rgb : texture(uBack,vAtlasUV).rgb);\\n    color = vec4(ink*vShade,alpha);\\n  }`;\\n  const shaders = [];\\n  function compile(kind, source) {\\n    const shader = gl.createShader(kind);\\n    gl.shaderSource(shader, source);\\n    gl.compileShader(shader);\\n    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS))\\n      throw new Error(gl.getShaderInfoLog(shader));\\n    shaders.push(shader);\\n    return shader;\\n  }\\n  const program = gl.createProgram();\\n  gl.attachShader(program, compile(gl.VERTEX_SHADER, vertex));\\n  gl.attachShader(program, compile(gl.FRAGMENT_SHADER, fragment));\\n  gl.linkProgram(program);\\n  if (!gl.getProgramParameter(program, gl.LINK_STATUS))\\n    throw new Error(gl.getProgramInfoLog(program));\\n  gl.useProgram(program);\\n  const vertices = [];\\n  function quad(corners, face) {\\n    const uv = [\\n      [0, 0],\\n      [1, 0],\\n      [1, 1],\\n      [0, 1],\\n    ];\\n    for (const i of [0, 1, 2, 0, 2, 3]) vertices.push(...corners[i], ...uv[i], face);\\n  }\\n  quad(\\n    [\\n      [-0.5, -0.5, 0.5],\\n      [0.5, -0.5, 0.5],\\n      [0.5, 0.5, 0.5],\\n      [-0.5, 0.5, 0.5],\\n    ],\\n    0,\\n  );\\n  // Rear UVs are reversed in local X, just like a CSS rotateY(180deg) face.\\n  quad(\\n    [\\n      [0.5, -0.5, -0.5],\\n      [-0.5, -0.5, -0.5],\\n      [-0.5, 0.5, -0.5],\\n      [0.5, 0.5, -0.5],\\n    ],\\n    1,\\n  );\\n  quad(\\n    [\\n      [-0.5, -0.5, -0.5],\\n      [-0.5, -0.5, 0.5],\\n      [-0.5, 0.5, 0.5],\\n      [-0.5, 0.5, -0.5],\\n    ],\\n    2,\\n  );\\n  quad(\\n    [\\n      [0.5, -0.5, 0.5],\\n      [0.5, -0.5, -0.5],\\n      [0.5, 0.5, -0.5],\\n      [0.5, 0.5, 0.5],\\n    ],\\n    3,\\n  );\\n  quad(\\n    [\\n      [-0.5, -0.5, -0.5],\\n      [0.5, -0.5, -0.5],\\n      [0.5, -0.5, 0.5],\\n      [-0.5, -0.5, 0.5],\\n    ],\\n    4,\\n  );\\n  quad(\\n    [\\n      [-0.5, 0.5, 0.5],\\n      [0.5, 0.5, 0.5],\\n      [0.5, 0.5, -0.5],\\n      [-0.5, 0.5, -0.5],\\n    ],\\n    5,\\n  );\\n  const vao = gl.createVertexArray();\\n  gl.bindVertexArray(vao);\\n  const geometry = gl.createBuffer();\\n  gl.bindBuffer(gl.ARRAY_BUFFER, geometry);\\n  gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW);\\n  for (const [location, size, offset] of [\\n    [0, 3, 0],\\n    [1, 2, 12],\\n    [2, 1, 20],\\n  ]) {\\n    gl.enableVertexAttribArray(location);\\n    gl.vertexAttribPointer(location, size, gl.FLOAT, false, 24, offset);\\n  }\\n  const data = new Float32Array(tiles.length * 14),\\n    instances = gl.createBuffer();\\n  tiles.forEach((tile, i) => {\\n    data.set([tile.cx, tile.cy, tile.width, tile.height], i * 14);\\n    data[i * 14 + 13] = tile.active ? 1 : 0;\\n  });\\n  gl.bindBuffer(gl.ARRAY_BUFFER, instances);\\n  gl.bufferData(gl.ARRAY_BUFFER, data.byteLength, gl.DYNAMIC_DRAW);\\n  for (const [location, size, offset] of [\\n    [3, 4, 0],\\n    [4, 4, 16],\\n    [5, 4, 32],\\n    [6, 2, 48],\\n  ]) {\\n    gl.enableVertexAttribArray(location);\\n    gl.vertexAttribPointer(location, size, gl.FLOAT, false, 56, offset);\\n    gl.vertexAttribDivisor(location, 1);\\n  }\\n  const textures = [front, back].map((source, i) => {\\n    const texture = gl.createTexture();\\n    gl.activeTexture(gl.TEXTURE0 + i);\\n    gl.bindTexture(gl.TEXTURE_2D, texture);\\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);\\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);\\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);\\n    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);\\n    gl.uniform1i(gl.getUniformLocation(program, i === 0 ? \\\"uFront\\\" : \\\"uBack\\\"), i);\\n    return texture;\\n  });\\n  gl.enable(gl.DEPTH_TEST);\\n  gl.enable(gl.CULL_FACE);\\n  gl.frontFace(gl.CW);\\n  gl.enable(gl.BLEND);\\n  gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);\\n  const rgb = options.behindColor.match(/[0-9a-f]{2}/gi).map((part) => parseInt(part, 16) / 255);\\n  const shadows = window.CodeSliceShadows(\\n    gl,\\n    tiles,\\n    data,\\n    options.shadowStrength,\\n    options.shadowSoftness,\\n  );\\n  gl.clearColor(...rgb, 1);\\n  gl.viewport(0, 0, 1920, 1080);\\n  return {\\n    data,\\n    shadowStats: shadows.stats,\\n    set(index, p) {\\n      const offset = index * 14 + 4;\\n      data.set(\\n        [\\n          p.x,\\n          p.y,\\n          p.z,\\n          p.scale,\\n          (p.rx * Math.PI) / 180,\\n          (p.ry * Math.PI) / 180,\\n          (p.rz * Math.PI) / 180,\\n          p.formation,\\n          p.shade,\\n        ],\\n        offset,\\n      );\\n    },\\n    draw() {\\n      gl.useProgram(program);\\n      gl.bindVertexArray(vao);\\n      gl.bindBuffer(gl.ARRAY_BUFFER, instances);\\n      gl.bufferSubData(gl.ARRAY_BUFFER, 0, data);\\n      gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);\\n      gl.drawArraysInstanced(gl.TRIANGLES, 0, 36, tiles.length);\\n      return 1 + shadows.draw();\\n    },\\n    dispose() {\\n      shadows.dispose();\\n      textures.forEach((t) => gl.deleteTexture(t));\\n      shaders.forEach((s) => gl.deleteShader(s));\\n      gl.deleteBuffer(instances);\\n      gl.deleteBuffer(geometry);\\n      gl.deleteVertexArray(vao);\\n      gl.deleteProgram(program);\\n      canvas.remove();\\n    },\\n  };\\n};\\n\",\"surface.js\");\nrun(\"\\n      (() => {\\n        \\\"use strict\\\";\\n        const W = 1920,\\n          H = 1080,\\n          DURATION = 8,\\n          SWEEP_START = 1.35;\\n        const schema = JSON.parse(\\n          document.getElementById(\\\"csh-root\\\").getAttribute(\\\"data-composition-variables\\\"),\\n        );\\n        const defaults = Object.fromEntries(schema.map((v) => [v.id, v.default]));\\n        const values = { ...defaults, ...(window.__hyperframes?.getVariables?.() || {}) };\\n        const clamp = (v, a = 0, b = 1) => Math.max(a, Math.min(b, v));\\n        const number = (key, a, b) =>\\n          Number.isFinite(Number(values[key])) ? clamp(Number(values[key]), a, b) : defaults[key];\\n        const smooth = (v) => {\\n          const u = clamp(v);\\n          return u * u * u * (10 + u * (-15 + 6 * u));\\n        };\\n        const headline = String(values.headline ?? defaults.headline)\\n          .replace(/\\\\s+/g, \\\" \\\")\\n          .trim()\\n          .slice(0, 32);\\n        const reverseHeadline = String(values.reverseHeadline ?? defaults.reverseHeadline)\\n          .replace(/\\\\s+/g, \\\" \\\")\\n          .trim()\\n          .slice(0, 32);\\n        const direction = values.direction === \\\"right-to-left\\\" ? -1 : 1;\\n        const cellSize = Math.round(number(\\\"cellSize\\\", 24, 120));\\n        const columns = Math.ceil(W / cellSize),\\n          rows = Math.ceil(H / cellSize);\\n        const gridX = Math.floor((W - columns * cellSize) / 2),\\n          gridY = Math.floor((H - rows * cellSize) / 2);\\n        const formationScale = number(\\\"formationScale\\\", 0.94, 1);\\n        const sweepPower = 1 + number(\\\"sweepEaseStrength\\\", 0, 3);\\n        const sweepDuration = number(\\\"sweepDuration\\\", 2.6, 4.5),\\n          flipDuration = number(\\\"flipDuration\\\", 0.65, 1.65);\\n        const cursorRadius = number(\\\"cursorRadius\\\", 160, 480),\\n          tiltStrength = number(\\\"tiltStrength\\\", 0, 55);\\n        const cursorDepth = number(\\\"cursorDepth\\\", -320, 320);\\n        const cursorFalloff = number(\\\"cursorFalloff\\\", 0.4, 3.5);\\n        const fieldReach = cursorRadius * Math.sqrt(-Math.log(0.06) / cursorFalloff);\\n        const noiseStrength = number(\\\"noiseStrength\\\", 0, 2),\\n          flipBounce = number(\\\"flipBounce\\\", 0, 0.8);\\n        const maxFont = number(\\\"fontSize\\\", 160, 480);\\n        // Match the workbench color control: both #RGB and #RRGGBB are valid.\\n        const rawBehindColor = String(values.behindColor ?? \\\"\\\")\\n          .trim()\\n          .toLowerCase();\\n        const behindColor = /^#[0-9a-f]{3}$/.test(rawBehindColor)\\n          ? \\\"#\\\" +\\n            rawBehindColor\\n              .slice(1)\\n              .split(\\\"\\\")\\n              .map((c) => c + c)\\n              .join(\\\"\\\")\\n          : /^#[0-9a-f]{6}$/.test(rawBehindColor)\\n            ? rawBehindColor\\n            : \\\"#ffffff\\\";\\n        const shadowStrength = number(\\\"shadowStrength\\\", 0, 0.65),\\n          shadowSoftness = number(\\\"shadowSoftness\\\", 0.5, 4);\\n        const stage = document.getElementById(\\\"csh-stage\\\"),\\n          root = document.getElementById(\\\"csh-root\\\");\\n        const accessible = document.getElementById(\\\"csh-accessible\\\"),\\n          flat = document.getElementById(\\\"csh-flat\\\");\\n        const tiles = [],\\n          cells = [];\\n        const cursorLeft = -cursorRadius * 1.8,\\n          cursorSpan = W + cursorRadius * 3.6;\\n        let disposed = false,\\n          timeline,\\n          lastTime = 0,\\n          finishTime = 0;\\n        let firstMotion = SWEEP_START,\\n          lastMotion = DURATION,\\n          lastRenderedTime = NaN,\\n          frameMode;\\n        let surface;\\n        const renderStats = { evaluatedTiles: 0, drawCalls: 0, restTiles: 0 };\\n\\n        // Shared front and rear surfaces, as in Code Slice Hero's UV windows.\\n        // Raster alpha selects flip eligibility only, never a moving mask.\\n        function textSurface(text) {\\n          const canvas = document.createElement(\\\"canvas\\\");\\n          canvas.width = W;\\n          canvas.height = H;\\n          const ctx = canvas.getContext(\\\"2d\\\", { willReadFrequently: true });\\n          let size = maxFont;\\n          ctx.font = `700 ${size}px SliceGeist`;\\n          const measured = ctx.measureText(text);\\n          if (measured.width > W - 320) size *= (W - 320) / measured.width;\\n          ctx.font = `700 ${size}px SliceGeist`;\\n          ctx.textAlign = \\\"center\\\";\\n          ctx.textBaseline = \\\"alphabetic\\\";\\n          const box = ctx.measureText(text);\\n          const baseline = H / 2 + (box.actualBoundingBoxAscent - box.actualBoundingBoxDescent) / 2;\\n          ctx.fillStyle = \\\"#101010\\\";\\n          ctx.fillText(text, W / 2, baseline);\\n          const ink = ctx.getImageData(0, 0, W, H).data;\\n          let inkPixels = 0;\\n          for (let i = 3; i \\u003c ink.length; i += 4) if (ink[i] > 0) inkPixels++;\\n          ctx.globalCompositeOperation = \\\"destination-over\\\";\\n          ctx.fillStyle = \\\"#fff\\\";\\n          ctx.fillRect(0, 0, W, H);\\n          return { canvas, ink, inkPixels, url: canvas.toDataURL(\\\"image/png\\\"), size };\\n        }\\n\\n        function countInk(ink, x0, y0, x1, y1) {\\n          let count = 0;\\n          for (let y = Math.max(0, y0); y \\u003c Math.min(H, y1); y++)\\n            for (let x = Math.max(0, x0); x \\u003c Math.min(W, x1); x++) {\\n              if (ink[(y * W + x) * 4 + 3] > 0) count++;\\n            }\\n          return count;\\n        }\\n\\n        // These independent hashes are the experiment's actual per-purpose seeds.\\n        function hash(col, row, a, b) {\\n          const v = Math.sin(col * a + row * b) * 43758.5453;\\n          return v - Math.floor(v);\\n        }\\n\\n        // Same Gaussian^falloff + smooth cutoff as the source hover (falloff 1.4).\\n        // Distances are in composition pixels, so the field stays circular even\\n        // when square cell size / grid density changes.\\n        function fieldAt(x, y, cursorX, cursorY) {\\n          const distanceSquared = (x - cursorX) ** 2 + (y - cursorY) ** 2;\\n          const raw = Math.exp((-cursorFalloff * distanceSquared) / (cursorRadius * cursorRadius));\\n          const u = clamp((raw - 0.06) / 0.94);\\n          return u * u * (3 - 2 * u);\\n        }\\n\\n        // One analytic ease-out and its inverse drive every passage/window time.\\n        // Strength zero preserves linear travel exactly; strength one is quadratic.\\n        const easeSweep = (u) =>\\n          sweepPower === 1 ? clamp(u) : 1 - Math.pow(1 - clamp(u), sweepPower);\\n        const inverseSweep = (u) =>\\n          sweepPower === 1 ? clamp(u) : 1 - Math.pow(1 - clamp(u), 1 / sweepPower);\\n        function cursorTimeAtX(x) {\\n          const rank = (direction === 1 ? x - cursorLeft : W - x - cursorLeft) / cursorSpan;\\n          return SWEEP_START + sweepDuration * inverseSweep(rank);\\n        }\\n        function cursorAt(time) {\\n          const progress = easeSweep((time - SWEEP_START) / sweepDuration);\\n          return {\\n            x: cursorLeft + cursorSpan * (direction === 1 ? progress : 1 - progress),\\n            y: H / 2,\\n            z: cursorDepth,\\n          };\\n        }\\n\\n        function poseAt(tile, time) {\\n          const t = clamp(time, 0, DURATION);\\n          const progress = tile.active ? clamp((t - tile.flipStart) / tile.flipDuration) : 0;\\n          const turn = smooth(progress / 0.64);\\n          // Analytic damped oscillation: overshoot, return past 180, settle exactly.\\n          // The attack/tail both have zero slope, so bounce=0 is a clean half-turn.\\n          const ringT = clamp((progress - 0.64) / 0.36);\\n          const ringEnvelope =\\n            smooth(ringT / 0.12) * Math.exp(-3.3 * ringT) * (1 - smooth((ringT - 0.72) / 0.28));\\n          const bounce = flipBounce * 36 * Math.sin(ringT * Math.PI * 3.3) * ringEnvelope;\\n          const flight = Math.sin(Math.PI * progress) ** 0.7;\\n          const cursor = cursorAt(t);\\n          const radial = fieldAt(tile.cx, tile.cy, cursor.x, cursor.y);\\n          const automatic = t >= SWEEP_START && t \\u003c= SWEEP_START + sweepDuration;\\n          // A short approach replaces the long, separate anticipation phase.\\n          const approach = smooth((t - tile.passTime + 0.2) / 0.16);\\n          const pull =\\n            (automatic ? radial * approach * (1 - smooth(progress / 0.32)) : 0) *\\n            (tile.active ? 1 : 0.55);\\n          const dx = cursor.x - tile.cx,\\n            dy = cursor.y - tile.cy;\\n          const variation = noiseStrength * Math.max(pull, flight * tile.peak);\\n          // Continuous deterministic oscillations, not random-at-render-time jitter.\\n          const n1 = Math.sin(t * 5.7 + tile.phase),\\n            n2 = Math.sin(t * 10.3 + tile.phase * 1.71);\\n          const jitter = variation * (n1 * 0.7 + n2 * 0.3);\\n          const formation = Math.max(pull, flight * (0.55 + 0.45 * tile.peak));\\n          // CSS positive Z points toward the camera. The prior 2D tilt signs\\n          // depressed the cursor-facing edge despite lifting the tile center.\\n          // A signed depth field now raises that edge for a positive cursor Z;\\n          // moving the cursor through the plane smoothly reverses this torque.\\n          const depthGain = cursor.z / 160;\\n          const pullTiltX =\\n            depthGain *\\n            ((dy / cursorRadius) * tiltStrength * 1.6 * pull +\\n              tile.seedX * tiltStrength * 0.16 * pull);\\n          // Ink yaw cannot reverse against its half-turn after cursor passage.\\n          // Release its seeded torque over 80 ms; blank tiles retain signed pull.\\n          const yawDx = tile.active ? direction * Math.max(0, -direction * dx) : -dx;\\n          const yawHandoff = tile.active ? 1 - smooth((t - tile.passTime + 0.04) / 0.12) : 1;\\n          const pullTiltY =\\n            depthGain *\\n            ((yawDx / cursorRadius) * tiltStrength * 1.8 * pull +\\n              tile.seedY * tiltStrength * 0.12 * pull) *\\n            yawHandoff;\\n          const pullZ = (tiltStrength / 30) * cursor.z * 0.45 * pull;\\n          const rx = pullTiltX + tile.seedX * variation * 3 * flight + jitter;\\n          const ry = direction * (180 * turn + bounce) + pullTiltY + jitter * 0.7;\\n          const rz = tile.seedZ * variation * (2.3 * flight + 1.2 * pull) + jitter * 0.35;\\n          return {\\n            x: clamp(dx * 0.08 * pull, -tile.width * 0.18, tile.width * 0.18) + jitter * 0.2,\\n            y: clamp(dy * 0.07 * pull, -tile.height * 0.11, tile.height * 0.11) + jitter * 0.16,\\n            z: pullZ + 17 * flight * tile.peak,\\n            cursorDepth: cursor.z,\\n            pullTiltX,\\n            pullTiltY,\\n            pullZ,\\n            rx,\\n            ry,\\n            rz,\\n            turn,\\n            bounce,\\n            radial,\\n            pull,\\n            peak: tile.peak,\\n            formation,\\n            scale: 1 - (1 - formationScale) * formation,\\n            shade: 1 - 0.12 * Math.abs(Math.sin((ry * Math.PI) / 180)) - 0.018 * formation,\\n          };\\n        }\\n\\n        function setRest(tile, rear) {\\n          const rest = tile.active && rear ? 1 : 0;\\n          if (tile.restState === rest) return;\\n          tile.restState = rest;\\n          surface.set(tile.index, {\\n            x: 0,\\n            y: 0,\\n            z: 0,\\n            rx: 0,\\n            ry: rest * direction * 180,\\n            rz: 0,\\n            scale: 1,\\n            formation: 0,\\n            shade: 1,\\n          });\\n        }\\n\\n        function renderAt(time) {\\n          if (disposed) return;\\n          lastTime = clamp(time, 0, DURATION);\\n          if (lastTime === lastRenderedTime) return;\\n          lastRenderedTime = lastTime;\\n          renderStats.evaluatedTiles = 0;\\n          renderStats.drawCalls = 0;\\n          renderStats.restTiles = 0;\\n          const mode =\\n            lastTime \\u003c= firstMotion ? \\\"front\\\" : lastTime >= lastMotion ? \\\"rear\\\" : \\\"moving\\\";\\n          if (mode !== frameMode) {\\n            frameMode = mode;\\n            stage.style.visibility = mode === \\\"moving\\\" ? \\\"visible\\\" : \\\"hidden\\\";\\n            flat.style.visibility = mode === \\\"moving\\\" ? \\\"hidden\\\" : \\\"visible\\\";\\n            if (mode !== \\\"moving\\\")\\n              flat.style.backgroundImage = `var(--csh-${mode === \\\"front\\\" ? \\\"front\\\" : \\\"back\\\"})`;\\n          }\\n          // One unsegmented atlas is shown only while EVERY tile is flat. This\\n          // removes compositor hairlines in the workbench's scaled first frame.\\n          // It is hidden for the whole active wave: no backing text or mask fade.\\n          for (const tile of tiles) {\\n            if (mode !== \\\"moving\\\" || lastTime \\u003c tile.motionStart || lastTime > tile.motionEnd) {\\n              setRest(tile, mode === \\\"rear\\\" || lastTime > tile.flipStart + tile.flipDuration);\\n              renderStats.restTiles++;\\n              continue;\\n            }\\n            tile.restState = null;\\n            surface.set(tile.index, poseAt(tile, lastTime));\\n            renderStats.evaluatedTiles++;\\n          }\\n          if (mode === \\\"moving\\\") renderStats.drawCalls = surface.draw();\\n          const copy =\\n            lastTime \\u003c SWEEP_START + sweepDuration / 2 + flipDuration / 2\\n              ? headline\\n              : reverseHeadline;\\n          if (accessible.textContent !== copy) accessible.textContent = copy;\\n          stage.dataset.time = lastTime.toFixed(4);\\n        }\\n\\n        function build() {\\n          if (disposed) return;\\n          const front = textSurface(headline),\\n            back = textSurface(reverseHeadline);\\n          root.style.setProperty(\\\"--csh-front\\\", `url(\\\"${front.url}\\\")`);\\n          root.style.setProperty(\\\"--csh-back\\\", `url(\\\"${back.url}\\\")`);\\n          let coveredFront = 0,\\n            coveredBack = 0;\\n          firstMotion = Infinity;\\n          lastMotion = 0;\\n          for (let row = 0; row \\u003c rows; row++)\\n            for (let col = 0; col \\u003c columns; col++) {\\n              // One exhaustive integer pixel partition. No alpha threshold, corner\\n              // sampling, skipped row, or per-letter box can punch holes in the type.\\n              const x = gridX + col * cellSize,\\n                x1 = x + cellSize;\\n              const y = gridY + row * cellSize,\\n                y1 = y + cellSize;\\n              const frontInk = countInk(front.ink, x, y, x1, y1),\\n                backInk = countInk(back.ink, x, y, x1, y1);\\n              coveredFront += frontInk;\\n              coveredBack += backInk;\\n              const cell = {\\n                col,\\n                row,\\n                x,\\n                y,\\n                width: x1 - x,\\n                height: y1 - y,\\n                frontInk,\\n                backInk,\\n                active: frontInk + backInk > 0,\\n              };\\n              cells.push(cell);\\n              // Build the whole square surface. White cells participate in radial\\n              // lift/tilt at a restrained strength, but progress is locked to zero\\n              // above so they never enter the headline's half-turn or bounce.\\n              const cx = x + cell.width / 2,\\n                cy = y + cell.height / 2;\\n              const peak = fieldAt(cx, cy, cx, H / 2);\\n              const passTime = cursorTimeAtX(cx);\\n              const columnSeconds = Math.abs(\\n                cursorTimeAtX(cx + cellSize / 2) - cursorTimeAtX(cx - cellSize / 2),\\n              );\\n              // The turn starts at passage, with at most 12 ms of seeded stagger.\\n              const flipStart =\\n                passTime +\\n                hash(col, row, 269.5, 183.3) *\\n                  Math.min(0.012, columnSeconds * 0.08) *\\n                  Math.min(noiseStrength, 1);\\n              const duration = flipDuration * (1 + 0.18 * (1 - peak));\\n              const tile = {\\n                ...cell,\\n                index: tiles.length,\\n                cx,\\n                cy,\\n                peak,\\n                passTime,\\n                flipStart,\\n                flipDuration: duration,\\n                phase: hash(col, row, 127.1, 311.7) * Math.PI * 2,\\n                seedX: hash(col, row, 419.2, 371.9) * 2 - 1,\\n                seedY: hash(col, row, 37.7, 631.5) * 2 - 1,\\n                seedZ: hash(col, row, 97.3, 127.9) * 2 - 1,\\n              };\\n              // The Gaussian is exactly zero outside this circle. Precompute each\\n              // cell's entry/exit times once, independent of playback history.\\n              const dy = cy - H / 2;\\n              let enter = Infinity,\\n                exit = -Infinity;\\n              if (Math.abs(dy) \\u003c fieldReach) {\\n                const dx = Math.sqrt(fieldReach * fieldReach - dy * dy);\\n                enter = Math.max(\\n                  SWEEP_START,\\n                  passTime - 0.2,\\n                  cursorTimeAtX(direction === 1 ? cx - dx : cx + dx),\\n                );\\n                exit = Math.min(\\n                  SWEEP_START + sweepDuration,\\n                  cursorTimeAtX(direction === 1 ? cx + dx : cx - dx),\\n                );\\n              }\\n              tile.motionStart = Math.min(enter, tile.active ? flipStart : Infinity);\\n              tile.motionEnd = Math.max(exit, tile.active ? flipStart + duration : -Infinity);\\n              firstMotion = Math.min(firstMotion, tile.motionStart);\\n              lastMotion = Math.max(lastMotion, tile.motionEnd);\\n              if (tile.active) finishTime = Math.max(finishTime, flipStart + duration);\\n              tiles.push(tile);\\n            }\\n          const inkTiles = tiles.filter((tile) => tile.active);\\n          root.style.backgroundColor = behindColor;\\n          surface = window.CodeSliceSurface(stage, front.canvas, back.canvas, tiles, {\\n            behindColor,\\n            shadowStrength,\\n            shadowSoftness,\\n          });\\n          const state = { time: 0 };\\n          timeline = gsap.timeline({ paused: true });\\n          timeline.to(\\n            state,\\n            {\\n              time: DURATION,\\n              duration: DURATION,\\n              ease: \\\"none\\\",\\n              onUpdate: () => renderAt(state.time),\\n            },\\n            0,\\n          );\\n          timeline\\n            .addLabel(\\\"seamless-front\\\", 0)\\n            .addLabel(\\\"cursor-sweep\\\", SWEEP_START)\\n            .addLabel(\\\"cursor-passed\\\", SWEEP_START + sweepDuration)\\n            .addLabel(\\\"seamless-rear\\\", finishTime);\\n          window.__timelines = window.__timelines || {};\\n          window.__timelines[\\\"code-slice-hero\\\"] = timeline;\\n          window.__codeSliceHero = {\\n            duration: DURATION,\\n            cellSize,\\n            columns,\\n            rows,\\n            activeCount: tiles.length,\\n            flipCount: inkTiles.length,\\n            backgroundCount: tiles.length - inkTiles.length,\\n            copy: [headline, reverseHeadline],\\n            fontSizes: [front.size, back.size],\\n            finishTime,\\n            coverage: {\\n              front: { inkPixels: front.inkPixels, covered: coveredFront },\\n              back: { inkPixels: back.inkPixels, covered: coveredBack },\\n            },\\n            cells,\\n            cursorAt,\\n            cursorTimeAtX,\\n            sweepEaseStrength: sweepPower - 1,\\n            renderStats,\\n            shadowStats: surface.shadowStats,\\n            behindColor,\\n            renderer: \\\"webgl2-instanced\\\",\\n            sample: (time) =>\\n              tiles.map((tile) => ({\\n                col: tile.col,\\n                row: tile.row,\\n                flips: tile.active,\\n                passTime: tile.passTime,\\n                flipStart: tile.flipStart,\\n                flipDuration: tile.flipDuration,\\n                ...poseAt(tile, time),\\n              })),\\n            renderAt,\\n          };\\n          renderAt(0);\\n        }\\n\\n        // The cursor is imaginary and belongs exclusively to the timeline.\\n        // No mouse/pointer input or wall-clock accumulation can affect a frame.\\n        function seek(event) {\\n          if (!timeline || typeof event.detail?.time !== \\\"number\\\") return;\\n          const time = clamp(event.detail.time, 0, DURATION);\\n          timeline.totalTime(time, true);\\n          renderAt(time);\\n        }\\n        window.addEventListener(\\\"hf-seek\\\", seek);\\n        window.__codeSliceInstance = {\\n          dispose() {\\n            disposed = true;\\n            timeline?.kill();\\n            surface?.dispose();\\n            window.removeEventListener(\\\"hf-seek\\\", seek);\\n            stage.replaceChildren();\\n            tiles.length = 0;\\n            cells.length = 0;\\n            root.style.removeProperty(\\\"--csh-front\\\");\\n            root.style.removeProperty(\\\"--csh-back\\\");\\n          },\\n        };\\n        window.__codeSliceReady = document.fonts.load(\\\"700 420px SliceGeist\\\").then(build);\\n      })();\\n    \",\"composition.js\");\n})().catch((error)=>console.error(\"[HyperFrames catalog] code-slice-hero could not load its scripts\",error));\n})();</script>\n    \n    \n    <style>\n      @font-face {\n        font-family: SliceGeist;\n        src: url(\"/public/catalog/assets/f032f37d12e82a37.ttf\") format(\"truetype\");\n        font-weight: 700;\n        font-display: block;\n      }\n      * {\n        box-sizing: border-box;\n        margin: 0;\n        padding: 0;\n      }\n      html,\n      body {\n        background: #fff;\n      }\n      #csh-root {\n        position: relative;\n        width: 1920px;\n        height: 1080px;\n        overflow: hidden;\n        background: #fff;\n      }\n      #csh-stage {\n        position: absolute;\n        inset: 0;\n      }\n      #csh-flat {\n        position: absolute;\n        inset: 0;\n        background: #fff var(--csh-front) no-repeat 0 0 / 1920px 1080px;\n      }\n      .csh-accessible {\n        position: absolute;\n        width: 1px;\n        height: 1px;\n        overflow: hidden;\n        clip-path: inset(50%);\n        white-space: nowrap;\n      }\n    </style>\n  </head>\n  <body>\n    <div\n      id=\"csh-root\"\n      data-composition-variables='[{\"id\":\"headline\",\"type\":\"string\",\"label\":\"Copy - Front headline\",\"default\":\"MAKE IT\",\"maxLength\":32},{\"id\":\"reverseHeadline\",\"type\":\"string\",\"label\":\"Copy - Rear headline\",\"default\":\"MATTER.\",\"maxLength\":32},{\"id\":\"direction\",\"type\":\"enum\",\"label\":\"Motion - Sweep direction\",\"default\":\"left-to-right\",\"options\":[{\"value\":\"left-to-right\",\"label\":\"Left to right\"},{\"value\":\"right-to-left\",\"label\":\"Right to left\"}]},{\"id\":\"sweepDuration\",\"type\":\"number\",\"label\":\"Motion - Sweep duration\",\"default\":4.2,\"min\":2.6,\"max\":4.5,\"step\":0.05,\"unit\":\"s\"},{\"id\":\"sweepEaseStrength\",\"type\":\"number\",\"label\":\"Motion - Sweep easing strength\",\"default\":3,\"min\":0,\"max\":3,\"step\":0.05,\"description\":\"0 = linear. Higher values start faster and slow more strongly toward the end.\"},{\"id\":\"flipDuration\",\"type\":\"number\",\"label\":\"Motion - Each tile flip\",\"default\":0.75,\"min\":0.65,\"max\":1.65,\"step\":0.05,\"unit\":\"s\"},{\"id\":\"cursorRadius\",\"type\":\"number\",\"label\":\"Cursor - Influence radius\",\"default\":210,\"min\":160,\"max\":480,\"step\":10,\"unit\":\"px\"},{\"id\":\"cursorFalloff\",\"type\":\"number\",\"label\":\"Cursor - Influence falloff\",\"default\":1.4,\"min\":0.4,\"max\":3.5,\"step\":0.05},{\"id\":\"cursorDepth\",\"type\":\"number\",\"label\":\"Cursor - Depth (+ toward camera)\",\"default\":80,\"min\":-320,\"max\":320,\"step\":10,\"unit\":\"px\"},{\"id\":\"tiltStrength\",\"type\":\"number\",\"label\":\"Cursor - Pull / tilt strength\",\"default\":55,\"min\":0,\"max\":55,\"step\":1,\"unit\":\"deg\"},{\"id\":\"noiseStrength\",\"type\":\"number\",\"label\":\"Motion - Organic variation\",\"default\":2,\"min\":0,\"max\":2,\"step\":0.05},{\"id\":\"flipBounce\",\"type\":\"number\",\"label\":\"Motion - Elastic flip bounce\",\"default\":0.15,\"min\":0,\"max\":0.8,\"step\":0.05},{\"id\":\"cellSize\",\"type\":\"number\",\"label\":\"Slices - Square cell size\",\"default\":112,\"min\":24,\"max\":120,\"step\":4,\"unit\":\"px\"},{\"id\":\"formationScale\",\"type\":\"number\",\"label\":\"Slices - Local formation scale\",\"default\":1,\"min\":0.94,\"max\":1,\"step\":0.001},{\"id\":\"fontSize\",\"type\":\"number\",\"label\":\"Type - Maximum size\",\"default\":310,\"min\":160,\"max\":480,\"step\":5,\"unit\":\"px\"},{\"id\":\"behindColor\",\"type\":\"color\",\"label\":\"Surface - Behind-tile background\",\"default\":\"#212121\"},{\"id\":\"shadowStrength\",\"type\":\"number\",\"label\":\"Surface - Cast shadow strength\",\"default\":0.19,\"min\":0,\"max\":0.65,\"step\":0.01},{\"id\":\"shadowSoftness\",\"type\":\"number\",\"label\":\"Surface - Cast shadow softness\",\"default\":4,\"min\":0.5,\"max\":4,\"step\":0.1,\"unit\":\"px\"}]'\n      data-composition-id=\"code-slice-hero\"\n      data-start=\"0\"\n      data-duration=\"8\"\n      data-width=\"1920\"\n      data-height=\"1080\"\n    >\n      <section\n        id=\"csh-stage\"\n        class=\"clip\"\n        data-start=\"0\"\n        data-duration=\"8\"\n        data-track-index=\"1\"\n        aria-hidden=\"true\"\n      ></section>\n      <div id=\"csh-flat\" aria-hidden=\"true\"></div>\n      <h1 id=\"csh-accessible\" class=\"csh-accessible\"></h1>\n    </div>\n    \n  </body>\n</html>\n"}