{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "fx-shader-layer",
  "type": "registry:component",
  "title": "Shader layer",
  "description": "Fire, liquid metal, glass and backdrop effects painted by GPUI in painter order",
  "author": "sudo-kw <https://github.com/sudo-kw>",
  "dependencies": [
    "@gpuix/native@0.11.0",
    "@gpuix/react@0.11.0",
    "react@^19.2.4"
  ],
  "registryDependencies": [
    "https://gpuixui.sudokw.com/gpuix-components.json"
  ],
  "files": [
    {
      "path": "packages/fx/src/shader-layer.tsx",
      "target": "@ui/gpuixui/fx/shader-layer.tsx",
      "type": "registry:component",
      "content": "/** @jsxImportSource @gpuix/react */\nimport { useEffect, useState, type ReactNode } from \"react\";\nimport { useMotionPreference } from \"../components/authoring.js\";\nimport type { Fx } from \"./shaders/pack.js\";\n\nexport * from \"./shaders/fire.js\";\nexport * from \"./shaders/firesim.js\";\nexport * from \"./shaders/light.js\";\nexport * from \"./shaders/nen.js\";\nexport * from \"./shaders/pack.js\";\nexport { DISTORT } from \"./shaders/wgsl.js\";\n\nconst Shader = \"gpuixui-shader\" as unknown as (\n  props: Record<string, unknown>,\n) => ReactNode;\n\nexport interface ShaderLayerProps {\n  readonly fx: Fx | null;\n}\n\nexport const ShaderLayer = ({ fx }: ShaderLayerProps): ReactNode =>\n  fx === null ? null : (\n    <Shader\n      source={fx.source}\n      time={fx.time}\n      params={fx.params}\n      data={fx.data}\n      readsBackdrop={fx.readsBackdrop}\n      simulationSource={fx.simulationSource}\n      simulationGrid={fx.simulationGrid}\n      simulationUniform={fx.simulationUniform}\n      style={{\n        position: \"absolute\",\n        left: fx.box.x,\n        top: fx.box.y,\n        width: fx.box.w,\n        height: fx.box.h,\n      }}\n    />\n  );\n\nexport const useShaderClock = (fps = 60): number => {\n  const still = useMotionPreference() === \"reduced\";\n  const [time, setTime] = useState(0);\n  useEffect(() => {\n    if (still) return;\n    const start = performance.now();\n    const tick = setInterval(\n      () => setTime((performance.now() - start) / 1000),\n      1000 / fps,\n    );\n    return () => clearInterval(tick);\n  }, [fps, still]);\n  return time;\n};\n"
    },
    {
      "path": "packages/fx/src/shaders/fire.ts",
      "target": "@ui/gpuixui/fx/shaders/fire.ts",
      "type": "registry:lib",
      "content": "import { FIRE_SIMULATION } from \"./firesim.js\";\n\nexport { FIRE_SIMULATION };\n\nconst pcg = (v: number): number => {\n  const s = (Math.imul(v, 747796405) + 2891336453) | 0;\n  const w = Math.imul(((s >>> ((s >>> 28) + 4)) ^ s) | 0, 277803737);\n  return ((w >>> 22) ^ w) >>> 0;\n};\nconst hu = (a: number, b: number): number =>\n  pcg((a ^ pcg((b + 0x9e3779b9) >>> 0)) >>> 0);\nconst u01 = (n: number): number => (pcg(n >>> 0) >>> 8) * (1 / 16777216);\n\nexport interface FireInput {\n  readonly rect: {\n    readonly x: number;\n    readonly y: number;\n    readonly w: number;\n    readonly h: number;\n  };\n  readonly radius: number;\n  readonly time: number;\n  readonly height: number;\n  readonly maxHeight: number;\n  readonly intensity: number;\n  readonly seed?: number;\n  readonly smoke?: number;\n  readonly scale?: number;\n  readonly embers?: number;\n  readonly emberRise?: number;\n  readonly emberSize?: number;\n  readonly emberLife?: number;\n  readonly occlusion?: number;\n  readonly rise?: number;\n  readonly cooling?: number;\n  readonly domain?: {\n    readonly x: number;\n    readonly y: number;\n    readonly w: number;\n    readonly h: number;\n  };\n}\n\nconst DRAG = 2.4;\n\nconst embersOf = (i: FireInput, seed: number): number[] => {\n  const { rect: r, radius, time: t, height } = i;\n  const rise = i.emberRise ?? 58,\n    size = i.emberSize ?? 0.8,\n    life0 = i.emberLife ?? 1.5;\n  const out: number[] = [];\n  for (let e = 0; e < Math.min(i.embers ?? 24, 30); e++) {\n    const hk0 = hu((seed + 991) >>> 0, e * 7 + 3);\n    const life = life0 * (0.6 + 0.8 * u01(hk0 + 0));\n    const tau = t / life + u01(hk0 + 1);\n    const kk = Math.floor(tau);\n    const a = tau - kk;\n    const hk = hu(hk0, kk >>> 0);\n    const age = a * life;\n    const x0 = r.x + radius * 0.6 + (r.w - radius * 1.2) * u01(hk + 2);\n    const y0 = r.y - height * (0.1 + 0.45 * u01(hk + 3));\n    const v0 = -rise * (1 + 0.8 * u01(hk + 4));\n    const vt = -rise * 0.32;\n    const ek = Math.exp(-DRAG * age);\n    const y = y0 + vt * age + ((v0 - vt) * (1 - ek)) / DRAG;\n    const vy = vt + (v0 - vt) * ek;\n    const sway = 2.5 + 5 * u01(hk + 5);\n    const fq = 3 + 4 * u01(hk + 6);\n    const ph = Math.PI * 2 * u01(hk + 7);\n    const drift = (u01(hk + 8) - 0.5) * 14;\n    const grow = 1 - Math.exp(-age * 3);\n    const x = x0 + drift * age + sway * Math.sin(age * fq + ph) * grow;\n    const vx =\n      drift +\n      sway *\n        (Math.cos(age * fq + ph) * fq * grow +\n          Math.sin(age * fq + ph) * 3 * Math.exp(-age * 3));\n    const sz = size * (0.5 + 0.8 * u01(hk + 9)) * (1 - 0.4 * a);\n    const attack = Math.min(1, age / 0.05);\n    const temp =\n      Math.exp(-age / (life * 0.42)) *\n      (1 - a * a) *\n      (0.8 + 0.3 * u01(hk + 10)) *\n      attack;\n    if (temp < 0.004) continue;\n    const shutter = 0.6 / 60;\n    out.push(x, y, vx * shutter, vy * shutter, sz, temp, 0, 0);\n  }\n  return out;\n};\n\nexport const firePlan = (i: FireInput) => {\n  const { rect: r, radius, height, maxHeight } = i;\n  const seed = i.seed ?? 0;\n  const rise = i.emberRise ?? 58;\n  const life = (i.emberLife ?? 1.5) * 1.4;\n  const emberUp =\n    maxHeight * 0.55 +\n    rise * (1.48 / DRAG + 0.32 * life) +\n    (i.emberSize ?? 0.8) * 4;\n  const side = 7.5 * life + 9;\n  const up = Math.max(maxHeight * 2.6 + 8, emberUp) + 4;\n  const box = i.domain ?? {\n    x: r.x - side,\n    y: r.y - up,\n    w: r.w + 2 * side,\n    h: up + 4,\n  };\n  const cell = Math.min(\n    3,\n    Math.max(1, Math.sqrt(Math.max(box.w * box.h, 1) / 16000)),\n  );\n  const n: [number, number] = [\n    Math.max(8, Math.ceil(box.w / cell)),\n    Math.max(8, Math.ceil(box.h / cell)),\n  ];\n  const simRise = i.rise ?? Math.min(140, Math.max(20, height * 2.2));\n  const cooling = i.cooling ?? (1.15 * simRise) / Math.max(height, 4);\n  const local = { ...i, rect: { ...r, x: r.x - box.x, y: r.y - box.y } };\n  const uniform = [\n    n[0],\n    n[1],\n    cell,\n    1 / 60,\n    0,\n    0,\n    0,\n    0,\n    local.rect.x + r.w / 2,\n    local.rect.y + r.h / 2,\n    r.w / 2,\n    r.h / 2,\n    radius,\n    seed % 65536,\n    simRise,\n    Math.max(i.scale ?? 26, 2),\n    simRise * 3,\n    cooling,\n    Math.max(i.smoke ?? 0.6, 0) * 0.6,\n    0.25 + 0.6,\n    simRise * 0.3,\n    1,\n    1.4,\n    2,\n  ];\n  const embers = embersOf(local, seed);\n  const params = [\n    0,\n    0,\n    n[0] * cell,\n    n[1] * cell,\n    box.w,\n    box.h,\n    i.intensity,\n    i.occlusion ?? 0.25,\n    embers.length / 8,\n    0,\n    0,\n    0,\n    ...embers,\n  ];\n  return { box, grid: n, uniform, params };\n};\n\n// Flame shading from rune-fx (MIT, © Anomaly), crates/rune-fx/src/shaders/fire.wgsl.\nexport const FIRE_SHADER = String.raw`\nfn gauss(x: f32, w: f32) -> f32 { return exp(-(x * x) / max(w * w, 1e-6)); }\nfn to_srgb(c: vec3f) -> vec3f {\n  let lo = c * 12.92;\n  let hi = 1.055 * pow(max(c, vec3f(0.0)), vec3f(1.0 / 2.4)) - 0.055;\n  return select(hi, lo, c <= vec3f(0.0031308));\n}\nfn to_lin(c: vec3f) -> vec3f {\n  let lo = c / 12.92;\n  let hi = pow((max(c, vec3f(0.0)) + 0.055) / 1.055, vec3f(2.4));\n  return select(hi, lo, c <= vec3f(0.04045));\n}\nfn segdist(p: vec2f, a: vec2f, b: vec2f) -> vec2f {\n  let ab = b - a;\n  let h = clamp(dot(p - a, ab) / max(dot(ab, ab), 1e-6), 0.0, 1.0);\n  return vec2f(length(p - a - ab * h), h);\n}\nfn blackbody(k: f32) -> vec3f {\n  let t = k / 100.0;\n  let g = clamp((99.4708 * log(t) - 161.1196) / 255.0, 0.0, 1.0);\n  let b = select(clamp((138.5177 * log(max(t - 10.0, 1.0)) - 305.0448) / 255.0, 0.0, 1.0), 0.0, t <= 19.0);\n  return to_lin(vec3f(1.0, g, b));\n}\nfn flame_light(T: f32, gain: f32) -> vec3f {\n  let x = max(T, 0.0);\n  let e = gain * x * x * x * smoothstep(0.08, 0.3, x);\n  return vec3f(1.0) - exp(-blackbody(1000.0 + 1700.0 * min(x, 1.3)) * e);\n}\nfn sim_at(uv: vec2f) -> vec4f {\n  let dim = vec2f(textureDimensions(simulation_state, 0));\n  let g = uv * dim - 0.5;\n  let i = floor(g);\n  let f = g - i;\n  let w0 = (1.0 - f) * (1.0 - f) * (1.0 - f) / 6.0;\n  let w1 = (4.0 - 6.0 * f * f + 3.0 * f * f * f) / 6.0;\n  let w3 = f * f * f / 6.0;\n  let w2 = 1.0 - w0 - w1 - w3;\n  let s0 = w0 + w1;\n  let s1 = w2 + w3;\n  let o0 = (i - 0.5 + w1 / s0) / dim;\n  let o1 = (i + 1.5 + w3 / s1) / dim;\n  let a = textureSampleLevel(simulation_state, backdrop_sampler, vec2f(o0.x, o0.y), 0.0);\n  let b = textureSampleLevel(simulation_state, backdrop_sampler, vec2f(o1.x, o0.y), 0.0);\n  let c = textureSampleLevel(simulation_state, backdrop_sampler, vec2f(o0.x, o1.y), 0.0);\n  let d = textureSampleLevel(simulation_state, backdrop_sampler, vec2f(o1.x, o1.y), 0.0);\n  return mix(mix(a, b, s1.x), mix(c, d, s1.x), s1.y);\n}\nfn shade(p: vec2f) -> vec4f {\n  let aux = frame.params[0];\n  let box_ = frame.params[1].xy;\n  let inten = frame.params[1].z;\n  let occlusion = frame.params[1].w;\n  var emis = vec3f(0.0);\n  var alpha = 0.0;\n  let uv = (p - aux.xy) / aux.zw;\n  if (all(uv >= vec2f(0.0)) && all(uv <= vec2f(1.0))) {\n    let s = sim_at(uv);\n    let T = s.z;\n    let m = min(min(p.x - aux.x, aux.x + box_.x - p.x), p.y - aux.y);\n    let win = smoothstep(0.0, 18.0, m);\n    emis = flame_light(T, 6.0) * win;\n    let sm = s.w * win;\n    if (sm > 0.002) {\n      alpha = (1.0 - exp(-sm * 1.2)) * occlusion * 1.6;\n      var lit = 0.0;\n      for (var k = 1; k < 5; k++) {\n        let tk = sim_at(uv + vec2f(0.0, f32(k) * 7.0 / aux.w)).z;\n        lit += tk * tk / f32(k);\n      }\n      let warm = vec3f(1.0, 0.45, 0.18) * min(lit, 1.0) * 0.3;\n      emis += alpha * (vec3f(0.11, 0.11, 0.115) + warm);\n    }\n    let vis = smoothstep(0.12, 0.35, T) * win;\n    alpha = min(alpha + vis * occlusion * 0.5, 1.0);\n  }\n  let count = u32(frame.params[2].x);\n  for (var k = 0u; k < count; k++) {\n    let a = frame.params[3u + k * 2u];\n    let b = frame.params[4u + k * 2u];\n    let sd = segdist(p, a.xy - a.zw, a.xy);\n    let T = b.y;\n    let core = gauss(sd.x, b.x);\n    let halo = gauss(sd.x, b.x * 3.0) * 0.12;\n    emis += flame_light(0.45 + T * 0.75, 6.0) * (core * 1.4 + halo) * T;\n    alpha += core * T * 0.5;\n  }\n  let c = vec4f(emis * inten, min(alpha, 1.0) * inten);\n  let cover = min(max(c.rgb, vec3f(0.0)), vec3f(c.a));\n  let straight = select(vec3f(0.0), cover / c.a, c.a > 1e-6);\n  return vec4f(to_srgb(straight) * c.a + to_srgb(max(c.rgb, vec3f(0.0)) - cover), c.a);\n}`;\n\n// Soft glow from rune-fx (MIT, © Anomaly), crates/rune-fx/src/shaders/glow.wgsl.\nexport const GLOW_SHADER = String.raw`\nfn gauss(x: f32, w: f32) -> f32 { return exp(-(x * x) / max(w * w, 1e-6)); }\nfn knee(x: f32) -> f32 { return 1.0 - exp(-max(x, 0.0)); }\nfn bloom(d: f32, r: f32, reach: f32) -> f32 {\n  let o = max(d, 0.0);\n  let w = 1.0 - smoothstep(reach * 0.5, reach, o);\n  return (0.65 * gauss(o, r * 0.35) + 0.35 * gauss(o, r * 1.2)) * w;\n}\nfn to_srgb(c: vec3f) -> vec3f {\n  let lo = c * 12.92;\n  let hi = 1.055 * pow(max(c, vec3f(0.0)), vec3f(1.0 / 2.4)) - 0.055;\n  return select(hi, lo, c <= vec3f(0.0031308));\n}\nfn shade(p: vec2f) -> vec4f {\n  let rect = frame.params[0];\n  let radius = frame.params[1].x;\n  let corner = frame.params[1].y;\n  let intensity = frame.params[1].z;\n  let half_ = rect.zw * 0.5;\n  let q = abs(p - rect.xy - half_) - half_ + corner;\n  let d = length(max(q, vec2f(0.0))) + min(max(q.x, q.y), 0.0) - corner;\n  let reach = radius * 4.5;\n  let edge = smoothstep(-0.5, 0.5, d);\n  let gl = bloom(d, radius, reach) * edge;\n  let corew = gauss(max(d, 0.0), 0.3 * radius) * 0.6;\n  let col = mix(frame.params[2].rgb, vec3f(0.904, 0.871, 1.0), corew * 0.8);\n  let e = knee(gl * intensity * 1.1);\n  return vec4f(col * e, e * 0.15);\n}`;\n\nexport const HEAT_HAZE = String.raw`\nfn pcg(v: u32) -> u32 { let s = v * 747796405u + 2891336453u; let w = ((s >> ((s >> 28u) + 4u)) ^ s) * 277803737u; return (w >> 22u) ^ w; }\nfn hcell(c: vec2i, seed: u32) -> f32 { return f32(pcg(bitcast<u32>(c.x) ^ pcg(bitcast<u32>(c.y) ^ pcg(seed))) >> 8u) * (1.0 / 16777216.0); }\nfn grad2(c: vec2i, seed: u32) -> vec2f { let a = hcell(c, seed) * 6.2831853; return vec2f(cos(a), sin(a)); }\nfn gnoise(p: vec2f, seed: u32) -> f32 {\n  let i = vec2i(floor(p)); let f = p - floor(p); let u = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);\n  return mix(mix(dot(grad2(i, seed), f), dot(grad2(i + vec2i(1, 0), seed), f - vec2f(1., 0.)), u.x), mix(dot(grad2(i + vec2i(0, 1), seed), f - vec2f(0., 1.)), dot(grad2(i + vec2i(1, 1), seed), f - vec2f(1., 1.)), u.x), u.y) * 1.41421;\n}\nconst ROT = mat2x2f(0.8, 0.6, -0.6, 0.8);\nfn fbm3(p0: vec2f, seed: u32) -> f32 {\n  var p = p0; var a = 0.5; var s = 0.0;\n  for (var o = 0u; o < 3u; o++) { s += a * gnoise(p, seed + o * 131u); p = ROT * p * 2.02; a *= 0.5; }\n  return s / 0.875;\n}\nfn shade(p: vec2f) -> vec4f {\n  let rect = frame.params[0];\n  let H = frame.params[1].x; let scale = frame.params[1].y; let speed = frame.params[1].z; let amount = frame.params[1].w;\n  let half_ = rect.zw * 0.5;\n  let above = rect.y - p.y;\n  let side = smoothstep(half_.x + 2.0, half_.x - 4.0, abs(p.x - rect.x - half_.x));\n  let m = smoothstep(1.0, 1.0 + H * 0.3, above) * (1.0 - smoothstep(H * 0.45, H, above)) * side;\n  if (m <= 0.0) { return vec4f(0.0); }\n  let q = p / max(scale, 1.0) + vec2f(0.0, frame.time * speed);\n  let o = vec2f(fbm3(q, 0u), fbm3(q * vec2f(1.0, 0.7) + vec2f(7.3, 2.1), 5u)) * amount;\n  return vec4f(backdrop_at(p + o * m).rgb, 1.0) * smoothstep(0.0, 0.02, m);\n}`;\n\nexport const BURN_FRONT = String.raw`\nfn pcg(v: u32) -> u32 { let s = v * 747796405u + 2891336453u; let w = ((s >> ((s >> 28u) + 4u)) ^ s) * 277803737u; return (w >> 22u) ^ w; }\nfn hcell(c: vec2i, seed: u32) -> f32 { return f32(pcg(bitcast<u32>(c.x) ^ pcg(bitcast<u32>(c.y) ^ pcg(seed))) >> 8u) * (1.0 / 16777216.0); }\nfn grad2(c: vec2i, seed: u32) -> vec2f { let a = hcell(c, seed) * 6.2831853; return vec2f(cos(a), sin(a)); }\nfn gnoise(p: vec2f, seed: u32) -> f32 {\n  let i = vec2i(floor(p)); let f = p - floor(p); let u = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);\n  return mix(mix(dot(grad2(i, seed), f), dot(grad2(i + vec2i(1, 0), seed), f - vec2f(1., 0.)), u.x), mix(dot(grad2(i + vec2i(0, 1), seed), f - vec2f(0., 1.)), dot(grad2(i + vec2i(1, 1), seed), f - vec2f(1., 1.)), u.x), u.y) * 1.41421;\n}\nfn fbm(p0: vec2f, seed: u32) -> f32 {\n  var p = p0; var a = 0.5; var s = 0.0;\n  for (var o = 0u; o < 4u; o++) { s += a * gnoise(p, seed + o * 131u); p = p * 2.03 + vec2f(1.7, 9.2); a *= 0.5; }\n  return s;\n}\nfn shade(p: vec2f) -> vec4f {\n  let front = frame.params[0].x;\n  let ground = frame.params[1].rgb;\n  let edge = front + fbm(vec2f(p.x / 70.0, front / 90.0), 3u) * 46.0 + fbm(vec2f(p.x / 16.0, p.y / 16.0), 7u) * 9.0;\n  let d = p.y - edge;\n  if (d < -44.0) { return vec4f(0.0); }\n  let char_ = smoothstep(-44.0, 0.0, d);\n  let flicker = 0.75 + 0.25 * gnoise(vec2f(p.x / 9.0, frame.time * 9.0), 11u);\n  let glow = exp(-(d * d) / 16.0) * flicker;\n  let ember = exp(-max(d, 0.0) / 9.0) * smoothstep(-3.0, 0.5, d) * (0.5 + 0.5 * gnoise(p / 5.0 + vec2f(0.0, frame.time * 2.0), 13u));\n  let light = vec3f(1.0, 0.42, 0.07) * glow * 1.4 + vec3f(0.9, 0.16, 0.02) * ember * 0.9;\n  let cover = char_ * char_;\n  return vec4f(ground * smoothstep(0.0, 2.0, d) + light, max(cover, smoothstep(0.0, 2.0, d)));\n}`;\n"
    },
    {
      "path": "packages/fx/src/shaders/firesim.ts",
      "target": "@ui/gpuixui/fx/shaders/firesim.ts",
      "type": "registry:lib",
      "content": "// Fire simulation from rune-fx (MIT, © Anomaly), crates/rune-fx/src/shaders/firesim.wgsl.\nexport const FIRE_SIMULATION = String.raw`// Fire and smoke as a small 2D stable-fluids simulation (Stam 1999), one grid per fire layer.\n// State S (rgba16f): velocity (pt/s, screen axes, y down), temperature (0..~1.2), smoke density.\n// One step = curl -> forces (buoyancy, vorticity confinement, sway, emission, cooling, smoke)\n// -> divergence -> Jacobi pressure -> projection -> MacCormack advection.\n\nstruct P {\n    dims: vec4f,   // nx, ny, cell (pt), dt\n    origin: vec4f, // domain x0, y0 (pt), time (s), reset (1 = treat previous state as empty)\n    shape: vec4f,  // centre x, y, half w, half h (pt)\n    shape2: vec4f, // radius, seed, rise speed (pt/s), tongue spacing (pt)\n    fire: vec4f,   // buoyancy (pt/s^2), cooling (1/s), smoke rate, vorticity\n    fire2: vec4f,  // sway (pt/s^2), flicker speed, smoke fade (1/s), source depth (pt)\n}\n\n@group(0) @binding(0) var<uniform> u: P;\n@group(0) @binding(1) var s_in: texture_2d<f32>;\n@group(0) @binding(3) var s_out: texture_storage_2d<rgba16float, write>;\n@group(0) @binding(4) var a_in: texture_2d<f32>;\n@group(0) @binding(5) var b_in: texture_2d<f32>;\n@group(0) @binding(6) var r_out: texture_storage_2d<r32float, write>;\n\nfn n() -> vec2i { return vec2i(u.dims.xy); }\nfn inside(c: vec2i) -> bool { return all(c >= vec2i(0)) && all(c < n()); }\nfn cl(c: vec2i) -> vec2i { return clamp(c, vec2i(0), n() - 1); }\nfn ld(c: vec2i) -> vec4f {\n    if (u.origin.w > 0.5) { return vec4f(0.0); }\n    return textureLoad(s_in, cl(c), 0);\n}\nfn la(c: vec2i) -> f32 { return textureLoad(a_in, cl(c), 0).r; }\nfn lb(c: vec2i) -> f32 { return textureLoad(b_in, cl(c), 0).r; }\nfn pos(c: vec2i) -> vec2f { return u.origin.xy + (vec2f(c) + 0.5) * u.dims.z; }\n\nfn sd_rrect(p: vec2f) -> f32 {\n    let r = min(u.shape2.x, min(u.shape.z, u.shape.w));\n    let q = abs(p - u.shape.xy) - u.shape.zw + r;\n    return length(max(q, vec2f(0.0))) + min(max(q.x, q.y), 0.0) - r;\n}\nfn solid(c: vec2i) -> bool { return sd_rrect(pos(c)) < -u.fire2.w - 1.0; }\n\nfn pcg(v: u32) -> u32 {\n    let s = v * 747796405u + 2891336453u;\n    let w = ((s >> ((s >> 28u) + 4u)) ^ s) * 277803737u;\n    return (w >> 22u) ^ w;\n}\nfn hash2(c: vec2i, seed: u32) -> f32 {\n    return f32(pcg(u32(c.x) ^ pcg(u32(c.y) ^ pcg(seed))) >> 8u) * (1.0 / 16777216.0);\n}\nfn vnoise(p: vec2f, seed: u32) -> f32 {\n    let i = vec2i(floor(p));\n    let f = fract(p);\n    let w = f * f * (3.0 - 2.0 * f);\n    let a = hash2(i, seed);\n    let b = hash2(i + vec2i(1, 0), seed);\n    let c = hash2(i + vec2i(0, 1), seed);\n    let d = hash2(i + vec2i(1, 1), seed);\n    return mix(mix(a, b, w.x), mix(c, d, w.x), w.y) * 2.0 - 1.0;\n}\n\n@compute @workgroup_size(8, 8)\nfn curl(@builtin(global_invocation_id) id: vec3u) {\n    let c = vec2i(id.xy);\n    if (!inside(c)) { return; }\n    let h = u.dims.z;\n    let w = (ld(c + vec2i(1, 0)).y - ld(c - vec2i(1, 0)).y - ld(c + vec2i(0, 1)).x + ld(c - vec2i(0, 1)).x) / (2.0 * h);\n    textureStore(r_out, c, vec4f(w, 0.0, 0.0, 0.0));\n}\n\n// Fuel along the edge: tongues of uneven strength with dark gaps between them, which wander and\n// pulse slowly, plus a fast flicker so tongues pinch off.\nfn emission(x: f32, t: f32, seed: u32) -> f32 {\n    let sp = max(u.shape2.w * 0.32, 3.5);\n    let fs = u.fire2.y;\n    let slow = vnoise(vec2f(x / sp, t * 0.55 * fs), seed) * 0.7 + vnoise(vec2f(x / sp * 2.3 + 5.1, t * 1.1 * fs), seed + 1u) * 0.3;\n    let fast = vnoise(vec2f(x / sp * 1.7 + 11.0, t * 6.0 * fs), seed + 2u);\n    // Thinner and shorter toward the rounded ends, gone before the sides.\n    let r = min(u.shape2.x, min(u.shape.z, u.shape.w));\n    let ends = 1.0 - smoothstep(u.shape.z - r * 1.6, u.shape.z - r * 0.35, abs(x - u.shape.x));\n    return smoothstep(-0.1, 0.4, slow + 0.25 * fast) * ends;\n}\n\n// Where fuel burns: a thin band along the upward-facing edge, under the node's border.\nfn fuel_band(p: vec2f) -> f32 {\n    let h = u.dims.z;\n    let d = sd_rrect(p);\n    let e2 = vec2f(0.5 * h, 0.0);\n    let gx = sd_rrect(p + e2) - sd_rrect(p - e2);\n    let gy = sd_rrect(p + e2.yx) - sd_rrect(p - e2.yx);\n    let up = clamp(-gy / max(length(vec2f(gx, gy)), 1e-4), 0.0, 1.0);\n    let depth = u.fire2.w;\n    return smoothstep(-depth - 1.5, -depth + 0.5, d) * (1.0 - smoothstep(0.0, h + 1.5, d)) * smoothstep(0.35, 0.8, up);\n}\n\n@compute @workgroup_size(8, 8)\nfn forces(@builtin(global_invocation_id) id: vec3u) {\n    let c = vec2i(id.xy);\n    if (!inside(c)) { return; }\n    let dt = u.dims.w;\n    let h = u.dims.z;\n    let t = u.origin.z;\n    let seed = u32(u.shape2.y);\n    var s = ld(c);\n    var v = s.xy;\n    var T = s.z;\n    var sm = s.w;\n    let p = pos(c);\n\n    // Buoyancy: hot gas rises, smoke is a little heavy.\n    v.y -= dt * (u.fire.x * T - u.fire.x * 0.12 * sm);\n\n    // Vorticity confinement puts back the small curls numerical diffusion removes.\n    if (u.origin.w < 0.5) {\n        let wl = abs(la(c - vec2i(1, 0)));\n        let wr = abs(la(c + vec2i(1, 0)));\n        let wu = abs(la(c - vec2i(0, 1)));\n        let wd = abs(la(c + vec2i(0, 1)));\n        var g = vec2f(wr - wl, wd - wu) / (2.0 * h);\n        let gl = length(g);\n        if (gl > 1e-4) {\n            g /= gl;\n            let w = la(c);\n            // Smooth near the base, more broken higher up (as in real flames).\n            let lift = clamp((u.shape.y - u.shape.w - pos(c).y) / max(u.shape2.z * 0.4, 8.0), 0.15, 1.0);\n            v += dt * u.fire.w * lift * h * vec2f(g.y * w, -g.x * w);\n        }\n    }\n\n    // Slow sideways sway of the whole column, stronger higher up.\n    let above = u.shape.y - u.shape.w - p.y;\n    let sway = vnoise(vec2f(p.x / 90.0, t * 0.35 * u.fire2.y), seed + 9u) + 0.5 * vnoise(vec2f(p.x / 30.0 + 3.0, p.y / 40.0 - t * 0.9 * u.fire2.y), seed + 10u);\n    v.x += dt * u.fire2.x * sway * clamp(above / 40.0, 0.0, 1.0);\n\n    let band = fuel_band(p);\n    if (band > 0.0) {\n        let e = emission(p.x, t, seed) * band;\n        T = max(T, e * (0.95 + 0.25 * vnoise(vec2f(p.x / 3.0, t * 9.0), seed + 4u)));\n        v.y = mix(v.y, -u.shape2.z * (0.6 + 0.6 * e), e * 0.6);\n    }\n\n    // Cooling, and the smoke the cooling flame leaves behind.\n    let cool = 1.0 - exp(-dt * u.fire.y);\n    let lost = T * cool;\n    T -= lost;\n    // Smoke is what is left once the flame has cooled past visible.\n    sm += lost * u.fire.z * (1.0 - smoothstep(0.25, 0.55, T));\n    sm *= exp(-dt * u.fire2.z);\n\n    if (solid(c)) {\n        v = vec2f(0.0);\n        T *= 0.5;\n        sm = 0.0;\n    }\n    // Hot gas is carried up far faster than it drifts sideways: damping sideways motion where\n    // it burns keeps tongues upright instead of the whole row merging into one plume.\n    v.x *= exp(-dt * 7.0 * smoothstep(0.1, 0.6, T));\n    // Let everything leave cleanly through the top and sides.\n    let edge = min(min(f32(c.x), f32(n().x - 1 - c.x)), f32(c.y));\n    let fade = smoothstep(0.0, 4.0, edge);\n    T *= fade;\n    sm *= fade;\n    textureStore(s_out, c, vec4f(v, T, sm));\n}\n\n@compute @workgroup_size(8, 8)\nfn divergence(@builtin(global_invocation_id) id: vec3u) {\n    let c = vec2i(id.xy);\n    if (!inside(c)) { return; }\n    let h = u.dims.z;\n    let l = select(textureLoad(s_in, cl(c - vec2i(1, 0)), 0).x, 0.0, solid(c - vec2i(1, 0)));\n    let r = select(textureLoad(s_in, cl(c + vec2i(1, 0)), 0).x, 0.0, solid(c + vec2i(1, 0)));\n    let t = select(textureLoad(s_in, cl(c - vec2i(0, 1)), 0).y, 0.0, solid(c - vec2i(0, 1)));\n    let b = select(textureLoad(s_in, cl(c + vec2i(0, 1)), 0).y, 0.0, solid(c + vec2i(0, 1)));\n    // Burning gas expands: the fuel band is a source, so the projection pushes the flame up and\n    // away from the edge instead of cancelling the rise against the wall below.\n    let src = fuel_band(pos(c)) * emission(pos(c).x, u.origin.z, u32(u.shape2.y)) * u.shape2.z * 0.2 / h;\n    textureStore(r_out, c, vec4f((r - l + b - t) / (2.0 * h) - src, 0.0, 0.0, 0.0));\n}\n\n// a_in = pressure, b_in = divergence. Open (p = 0) above the domain, closed elsewhere.\nfn pn(c: vec2i, centre: f32) -> f32 {\n    if (c.y < 0) { return 0.0; }\n    if (!inside(c) || solid(c)) { return centre; }\n    return la(c);\n}\n\n@compute @workgroup_size(8, 8)\nfn jacobi(@builtin(global_invocation_id) id: vec3u) {\n    let c = vec2i(id.xy);\n    if (!inside(c)) { return; }\n    let h = u.dims.z;\n    let pc = la(c);\n    let s = pn(c - vec2i(1, 0), pc) + pn(c + vec2i(1, 0), pc) + pn(c - vec2i(0, 1), pc) + pn(c + vec2i(0, 1), pc);\n    textureStore(r_out, c, vec4f((s - h * h * lb(c)) * 0.25, 0.0, 0.0, 0.0));\n}\n\n@compute @workgroup_size(8, 8)\nfn project(@builtin(global_invocation_id) id: vec3u) {\n    let c = vec2i(id.xy);\n    if (!inside(c)) { return; }\n    let h = u.dims.z;\n    var s = textureLoad(s_in, c, 0);\n    let pc = la(c);\n    let g = vec2f(pn(c + vec2i(1, 0), pc) - pn(c - vec2i(1, 0), pc), pn(c + vec2i(0, 1), pc) - pn(c - vec2i(0, 1), pc)) / (2.0 * h);\n    var v = s.xy - g;\n    if (solid(c)) { v = vec2f(0.0); }\n    // Keep a hitch from blowing the sim up.\n    let vl = length(v);\n    let vmax = 2.0 * h / u.dims.w;\n    if (vl > vmax) { v *= vmax / vl; }\n    textureStore(s_out, c, vec4f(v, s.z, s.w));\n}\n\nfn cr(t: f32) -> vec4f {\n    // Catmull-Rom weights for the 4 taps around t in [0, 1).\n    let t2 = t * t;\n    let t3 = t2 * t;\n    return vec4f(-0.5 * t3 + t2 - 0.5 * t, 1.5 * t3 - 2.5 * t2 + 1.0, -1.5 * t3 + 2.0 * t2 + 0.5 * t, 0.5 * t3 - 0.5 * t2);\n}\n\n// Monotone cubic sample (Catmull-Rom clamped to the 4 nearest texels): far less smearing than\n// bilinear, so tongues stay sharp as they rise, and no overshoot.\nfn sample_cubic(p: vec2f) -> vec4f {\n    let g = (p - u.origin.xy) / u.dims.z - 0.5;\n    let i0 = vec2i(floor(g));\n    let f = g - floor(g);\n    let wx = cr(f.x);\n    let wy = cr(f.y);\n    var acc = vec4f(0.0);\n    for (var y = 0; y < 4; y++) {\n        var row = vec4f(0.0);\n        for (var x = 0; x < 4; x++) {\n            row += wx[x] * textureLoad(s_in, cl(i0 + vec2i(x - 1, y - 1)), 0);\n        }\n        acc += wy[y] * row;\n    }\n    let q0 = textureLoad(s_in, cl(i0), 0);\n    let q1 = textureLoad(s_in, cl(i0 + vec2i(1, 0)), 0);\n    let q2 = textureLoad(s_in, cl(i0 + vec2i(0, 1)), 0);\n    let q3 = textureLoad(s_in, cl(i0 + vec2i(1, 1)), 0);\n    return clamp(acc, min(min(q0, q1), min(q2, q3)), max(max(q0, q1), max(q2, q3)));\n}\n\n@compute @workgroup_size(8, 8)\nfn advect(@builtin(global_invocation_id) id: vec3u) {\n    let c = vec2i(id.xy);\n    if (!inside(c)) { return; }\n    let p = pos(c);\n    let v = textureLoad(s_in, c, 0).xy;\n    // Two-stage (midpoint) back-trace so curling flow doesn't spiral outward.\n    let mid = p - 0.5 * u.dims.w * v;\n    let vm = sample_cubic(mid).xy;\n    let r = sample_cubic(p - u.dims.w * vm);\n    textureStore(s_out, c, vec4f(r.xy, max(r.z, 0.0), max(r.w, 0.0)));\n}\n`;\n"
    },
    {
      "path": "packages/fx/src/shaders/light.ts",
      "target": "@ui/gpuixui/fx/shaders/light.ts",
      "type": "registry:lib",
      "content": "// rune-light (MIT, © Anomaly): its surface, field, soft shadow, shaft and composite passes as one fragment shader.\nexport interface Prim {\n  readonly x: number;\n  readonly y: number;\n  readonly w: number;\n  readonly h: number;\n  readonly r: number;\n  readonly z0?: number;\n  readonly z1?: number;\n  readonly bevel?: number;\n  readonly lift?: number;\n  readonly gloss?: number;\n  readonly rough?: number;\n  readonly floor?: boolean;\n}\nexport interface LightDesc {\n  readonly x: number;\n  readonly y: number;\n  readonly z: number;\n  readonly radius: number;\n  readonly color: readonly [number, number, number];\n  readonly intensity: number;\n  readonly range: number;\n  readonly shafts?: number;\n  readonly bulb?: number;\n  readonly specular?: number;\n  readonly softness?: number;\n}\nexport interface LightSettings {\n  readonly ambient: readonly [number, number, number];\n  readonly rim: number;\n  readonly ao: number;\n  readonly shaftsOver: number;\n  readonly floor?: number;\n}\n\nconst dec = (c: number) =>\n  c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;\nexport const srgbf = (\n  r: number,\n  g: number,\n  b: number,\n): readonly [number, number, number] => [dec(r), dec(g), dec(b)];\n\nexport const lightParams = (\n  s: number,\n  lights: ReadonlyArray<LightDesc>,\n  st: LightSettings,\n  count: number,\n): number[] => [\n  lights.length,\n  count,\n  st.rim,\n  st.ao,\n  ...st.ambient,\n  st.shaftsOver,\n  st.floor ?? 0.025,\n  0.4,\n  0.55,\n  0,\n  ...lights.flatMap((l) => {\n    const peak = Math.max(...l.color, 1e-6),\n      k = l.intensity / peak;\n    return [\n      l.x * s,\n      l.y * s,\n      l.z * s,\n      l.radius * s,\n      l.color[0] * k,\n      l.color[1] * k,\n      l.color[2] * k,\n      l.range * s,\n      l.shafts ?? 0,\n      l.bulb ?? 0,\n      l.specular ?? 1,\n      l.softness ?? 1,\n    ];\n  }),\n];\nexport const lightData = (s: number, prims: ReadonlyArray<Prim>): number[] =>\n  prims.flatMap((p) => {\n    const z0 = (p.z0 ?? 0) * s,\n      z1 = (p.z1 ?? p.z0 ?? 0) * s,\n      occ = z1 > z0 ? 1 : 0,\n      raised = (p.bevel ?? 0) > 0 ? 4 : 0;\n    return [\n      p.x * s,\n      p.y * s,\n      p.w * s,\n      p.h * s,\n      p.r * s,\n      z0,\n      z1,\n      (p.bevel ?? 0) * s,\n      (p.lift ?? 0) * s,\n      p.gloss ?? 0,\n      p.rough ?? 0.6,\n      occ + raised,\n    ];\n  });\n\nexport const LIGHT_SHADER = String.raw`\nconst PI: f32 = 3.14159265;\nconst REF: f32 = 200.0;\nconst CLAMP: f32 = 256.0;\nstruct L { pos: vec4f, color: vec4f, extra: vec4f }\nfn light_at(i: u32) -> L { return L(frame.params[3u + i * 3u], frame.params[4u + i * 3u], frame.params[5u + i * 3u]); }\nfn sd_rrect(p: vec2f, half_: vec2f, r0: f32) -> f32 {\n  let r = min(r0, min(half_.x, half_.y));\n  let q = abs(p) - half_ + vec2f(r);\n  return min(max(q.x, q.y), 0.0) + length(max(q, vec2f(0.0))) - r;\n}\nfn prim_sd(k: u32, p: vec2f) -> f32 {\n  let rect = shader_data_at(k * 3u); let a = shader_data_at(k * 3u + 1u);\n  let half_ = rect.zw * 0.5;\n  return sd_rrect(p - rect.xy - half_, half_, a.x);\n}\nfn field_at(q: vec2f) -> vec3f {\n  var best = CLAMP; var bot = 0.0; var top = 0.0;\n  let n = u32(frame.params[0].y);\n  for (var k = 0u; k < n; k++) {\n    let b = shader_data_at(k * 3u + 2u);\n    if ((u32(b.w + 0.5) & 1u) == 0u) { continue; }\n    let d = prim_sd(k, q);\n    if (d < best) { let a = shader_data_at(k * 3u + 1u); best = d; bot = a.y; top = a.z; }\n  }\n  return vec3f(best, bot, top);\n}\nfn slab(f: vec3f, z: f32) -> f32 {\n  let dz = max(z - f.z, f.y - z);\n  let a = vec2f(f.x, dz);\n  return length(max(a, vec2f(0.0))) + min(max(a.x, a.y), 0.0);\n}\nfn trace(P: vec3f, T: vec3f, radius: f32, t_start: f32) -> f32 {\n  let D = T - P; let dist = length(D);\n  if (dist < 1e-3) { return 1.0; }\n  let rd = D / dist; let theta = max(radius / dist, 1e-3);\n  var t = t_start; var res = 1.0; var ph = 1e10;\n  let t_end = dist - radius; let zmax = frame.params[2].w;\n  for (var i = 0; i < 64; i++) {\n    if (t >= t_end) { break; }\n    let q = P + rd * t;\n    if (rd.z >= 0.0 && q.z > zmax) { break; }\n    let h = slab(field_at(q.xy), q.z);\n    if (h <= 0.0) { res = min(res, h / (t * theta)); } else {\n      let y = h * h / (2.0 * ph);\n      let dd = sqrt(max(h * h - y * y, 0.0));\n      res = min(res, dd / (max(t - y, 1e-3) * theta));\n    }\n    ph = max(h, 1e-3);\n    if (res <= -1.0) { break; }\n    t = t + clamp(abs(h), 0.6 + t * 0.012, 96.0);\n  }\n  let k = clamp(0.5 + 0.5 * res, 0.0, 1.0);\n  return k * k * (3.0 - 2.0 * k);\n}\nfn shaft(p: vec2f, l: L) -> f32 {\n  let D = l.pos.xy - p; let len = length(D);\n  let R = max(l.pos.w * l.extra.w, 1.0);\n  let n = 48; let step = len / f32(n); let w = max(step * 0.6, 26.0);\n  var acc = 0.0;\n  for (var i = 0; i < n; i++) {\n    let q = p + D * ((f32(i) + 0.5) / f32(n));\n    let open = smoothstep(-w, w, field_at(q).x);\n    let r = length(l.pos.xy - q);\n    acc += open * R * R / (r * r + R * R);\n  }\n  return acc / f32(n);\n}\nfn light_term(l: L, P: vec3f) -> vec4f {\n  let D = l.pos.xyz - P; let d2 = dot(D, D); let d = sqrt(d2);\n  let x = d / max(l.color.w, 1.0);\n  let w = clamp(1.0 - x * x * x * x, 0.0, 1.0);\n  return vec4f(D / max(d, 1e-4), REF * REF / (d2 + l.pos.w * l.pos.w) * w * w);\n}\nfn ggx(nh: f32, a: f32) -> f32 { let a2 = a * a; let d = nh * nh * (a2 - 1.0) + 1.0; return a2 / (PI * d * d); }\nfn shoulder(x: vec3f) -> vec3f { let k = 0.8; let over = max(x - vec3f(k), vec3f(0.0)); return min(x, vec3f(k)) + (1.0 - k) * (vec3f(1.0) - exp(-over / (1.0 - k))); }\nfn to_srgb(c: vec3f) -> vec3f { let lo = c * 12.92; let hi = 1.055 * pow(max(c, vec3f(0.0)), vec3f(1.0 / 2.4)) - 0.055; return select(hi, lo, c <= vec3f(0.0031308)); }\nfn to_lin(c: vec3f) -> vec3f { let lo = c / 12.92; let hi = pow((max(c, vec3f(0.0)) + 0.055) / 1.055, vec3f(2.4)); return select(hi, lo, c <= vec3f(0.04045)); }\nfn ign(p: vec2f) -> f32 { return fract(52.9829189 * fract(dot(p, vec2f(0.06711056, 0.00583715)))); }\nfn shade(point: vec2f) -> vec4f {\n  let px = point * frame.scale;\n  let base = to_lin(backdrop_at(point).rgb);\n  let n_prims = u32(frame.params[0].y);\n  var id = n_prims; var sd = 1e5; var zr = 0.0;\n  for (var k = n_prims; k > 0u; k--) {\n    let d = prim_sd(k - 1u, px);\n    if (d <= 0.5) { id = k - 1u; sd = d; zr = shader_data_at(id * 3u + 1u).z; break; }\n  }\n  var grad = vec2f(0.0); var n = vec3f(0.0, 0.0, 1.0);\n  let ambient = frame.params[1].xyz;\n  var gloss = frame.params[2].y; var rough = frame.params[2].z; var rim = 0.0;\n  if (id < n_prims) {\n    let e = 0.5;\n    let g = vec2f(prim_sd(id, px + vec2f(e, 0.)) - prim_sd(id, px - vec2f(e, 0.)), prim_sd(id, px + vec2f(0., e)) - prim_sd(id, px - vec2f(0., e)));\n    let gl = length(g);\n    grad = select(vec2f(0.0), g / gl, gl > 1e-5);\n    let a = shader_data_at(id * 3u + 1u); let b = shader_data_at(id * 3u + 2u);\n    gloss = b.y; rough = b.z;\n    let flags = u32(b.w + 0.5);\n    if ((flags & 4u) != 0u) {\n      let bw = max(a.w, 0.5); let x = clamp(-sd / bw, 0.0, 1.0);\n      n = normalize(vec3f(grad * (b.x / bw * 3.0 * (1.0 - x) * (1.0 - x)), 1.0));\n    }\n    rim = frame.params[0].z * (1.0 - smoothstep(0.0, 2.0, -sd)) * select(0.0, 1.0, (flags & 1u) != 0u);\n  }\n  let P = vec3f(px, zr + 0.35);\n  var irr = ambient;\n  let f = field_at(px); let below = max(f.z - zr, 0.0);\n  if (below > 0.0 && f.x > 0.0) {\n    let occ = 1.0 - smoothstep(0.0, below * 3.0 + 6.0, f.x);\n    irr *= 1.0 - frame.params[0].w * occ * occ;\n  }\n  var diffuse = vec3f(0.0); var spec = vec3f(0.0); var airc = vec3f(0.0);\n  let nl = u32(frame.params[0].x);\n  for (var li = 0u; li < nl; li++) {\n    let l = light_at(li);\n    let lt = light_term(l, P); let dir = lt.xyz;\n    var v = 1.0;\n    if (lt.w > 1e-5 && l.pos.z > zr + 0.35) { v = trace(P, l.pos.xyz, l.pos.w * l.extra.w, 0.75); }\n    let ndl = max(dot(n, dir), 0.0);\n    let e_ = l.color.rgb * lt.w * v;\n    let front = select(1.0, 0.0, l.extra.x > 0.0);\n    diffuse += e_ * ndl * front;\n    let h = normalize(dir + vec3f(0.0, 0.0, 1.0));\n    let dist = length(l.pos.xyz - P);\n    let a = clamp(rough * rough + l.pos.w / (2.0 * dist), 0.02, 1.0);\n    let fres = 0.04 + 0.96 * pow(1.0 - max(dot(dir, h), 0.0), 5.0);\n    spec += e_ * ndl * ggx(max(dot(n, h), 0.0), a) * ((rough * rough) / a) * fres * gloss * l.extra.z * front;\n    let lxy = l.pos.xy - px;\n    let face = max(dot(grad, lxy / max(length(lxy), 1e-3)), 0.0);\n    spec += e_ * rim * face * face * max(dir.z, 0.15);\n    let d2 = length(lxy);\n    if (l.extra.x > 0.0) {\n      let over = select(1.0, frame.params[1].w, zr > 0.5);\n      let fall = 1.5 * REF / (d2 + 1.5 * REF);\n      airc += l.color.rgb * l.extra.x * shaft(px, l) * over * fall * fall;\n    }\n    if (l.extra.y > 0.0) {\n      let r = max(l.pos.w, 1.0); let q = r * r / (d2 * d2 + r * r);\n      airc += l.color.rgb * l.extra.y * (q * sqrt(q) + 0.05 * q);\n    }\n  }\n  let col = base * irr + (base + vec3f(frame.params[2].x)) * diffuse + spec + airc;\n  let dn = ign(px) + ign(px.yx + vec2f(17.0, 0.0)) - 1.0;\n  return vec4f(to_srgb(shoulder(col)) + vec3f(dn / 255.0), 1.0);\n}`;\n"
    },
    {
      "path": "packages/fx/src/shaders/nen.ts",
      "target": "@ui/gpuixui/fx/shaders/nen.ts",
      "type": "registry:lib",
      "content": "// Backdrop effects over whatever is already painted: each factory is a pure function of time.\nimport type { Fx, Rect } from \"./pack.js\";\n\nconst HASH =\n  \"fn hash(v: vec2f) -> f32 { return fract(sin(dot(v, vec2f(12.9898, 78.233))) * 43758.5453); }\";\nconst WATER = `\nfn ring(p: vec2f, drop: vec4f) -> vec3f {\n  let d = p - drop.yz; let r = max(length(d), 1.0); let age = drop.x;\n  if (age <= 0.0) { return vec3f(0.0); }\n  let front = 40.0 + age * 560.0;\n  let env = (1.0 - smoothstep(front - 170.0, front, r)) * exp(-age * 1.05);\n  let w = sin((r - front) * 0.085) * env;\n  return vec3f(d / r * w, w);\n}\nfn shade(p: vec2f) -> vec4f {\n  var w = vec3f(0.0);\n  for (var k = 0u; k < 8u; k++) { w += ring(p, frame.params[k]); }\n  let t = frame.time; let level = frame.params[8].x; let swell = frame.params[8].y;\n  let surface = level + swell * (sin(p.x * 0.018 + t * 3.1) + 0.55 * sin(p.x * 0.041 - t * 4.3) + 0.3 * sin(p.x * 0.09 + t * 6.1));\n  let depth = p.y - surface; let inside = smoothstep(-1.5, 1.5, depth);\n  let sway = vec2f(sin(p.y * 0.035 + t * 3.7) * 12.0 + sin(p.y * 0.09 - t * 5.0) * 4.0, sin(p.x * 0.03 + t * 2.9) * 7.0) * inside;\n  let off = w.xy * 34.0 + sway;\n  var c = vec3f(backdrop_at(p + off * 1.06).r, backdrop_at(p + off).g, backdrop_at(p + off * 0.94).b);\n  c *= mix(vec3f(1.0), vec3f(0.74, 0.92, 1.12), min(1.0, abs(w.z) * 2.0));\n  c += pow(max(w.z, 0.0), 3.0) * 0.9 * vec3f(0.7, 0.92, 1.0);\n  let q = p + vec2f(sin(p.y * 0.021 + t * 1.3) * 34.0 + sin(p.y * 0.053 - t) * 12.0, sin(p.x * 0.017 - t * 1.1) * 34.0 + sin(p.x * 0.047 + t * 1.7) * 12.0);\n  let caustic = pow(0.5 + 0.1667 * (sin((q.x + q.y) * 0.05 + t * 3.0) + sin((q.x - q.y) * 0.061 - t * 2.3) + sin(q.y * 0.083 + t * 1.9)), 6.0) * 1.6;\n  let body = mix(vec3f(0.34, 0.62, 0.92), vec3f(0.1, 0.26, 0.56), clamp(depth / 340.0, 0.0, 1.0));\n  c = mix(c, c * 0.62 + body * 0.42, inside) + caustic * 0.5 * inside * vec3f(0.55, 0.85, 1.0);\n  c += exp(-pow(depth / 3.0, 2.0)) * 0.75 * vec3f(0.82, 0.95, 1.0) + exp(-max(depth, 0.0) / 26.0) * inside * 0.14 * vec3f(0.6, 0.85, 1.0);\n  return vec4f(c, 1.0);\n}`;\nconst GUM = `\nfn shade(p: vec2f) -> vec4f {\n  let a = frame.params[0].xy; let d = frame.params[0].zw; let tip = a + d;\n  let v = p - tip; let f = exp(-dot(v, v) / (210.0 * 210.0));\n  var c = backdrop_at(p - d * f).rgb;\n  let h = clamp(dot(p - a, d) / max(dot(d, d), 1.0), 0.0, 1.0);\n  let q = p - a - d * h; let n = length(q);\n  let wob = 1.2 * sin(h * 22.0 + frame.time * 18.0) * length(d) * 0.004;\n  let width = mix(13.0, 5.0, sin(h * 3.14159)) + wob;\n  let cover = (1.0 - smoothstep(width - 1.0, width + 1.0, n)) * step(1.0, length(d));\n  let sheen = 1.0 - smoothstep(0.0, width, abs(dot(q, vec2f(-d.y, d.x) / max(length(d), 1.0)) + width * 0.35));\n  c = mix(c, vec3f(1.0, 0.36, 0.66) + sheen * vec3f(0.0, 0.5, 0.34), cover);\n  return vec4f(c, 1.0);\n}`;\nconst EN = `\nfn luma(p: vec2f) -> f32 { return dot(backdrop_at(p).rgb, vec3f(0.3, 0.6, 0.1)); }\nfn shade(p: vec2f) -> vec4f {\n  let r = length(p - frame.params[0].xy); let front = frame.params[0].z;\n  let inside = 1.0 - smoothstep(front - 2.0, front + 2.0, r);\n  let bd = backdrop_at(p).rgb;\n  let gx = luma(p + vec2f(1.5, 0.0)) - luma(p - vec2f(1.5, 0.0));\n  let gy = luma(p + vec2f(0.0, 1.5)) - luma(p - vec2f(0.0, 1.5));\n  let edge = min(1.0, length(vec2f(gx, gy)) * 5.0);\n  let sense = bd * 0.22 + vec3f(0.03, 0.07, 0.11) + edge * vec3f(0.38, 0.92, 1.0);\n  let rings = 0.05 * smoothstep(0.75, 1.0, sin(r * 0.11 - frame.time * 8.0));\n  let band = exp(-pow((r - front) / 9.0, 2.0));\n  return vec4f(mix(bd, sense + rings * vec3f(0.4, 0.9, 1.0), inside) + band * vec3f(0.55, 0.95, 1.0), 1.0);\n}`;\nconst GODSPEED = `${HASH}\nfn shade(p: vec2f) -> vec4f {\n  let amp = frame.params[0].x; let beat = floor(frame.time * 24.0);\n  let band = floor(p.y / (10.0 + 26.0 * hash(vec2f(beat, 3.0))));\n  let h = hash(vec2f(band, beat));\n  let x = step(0.68, h) * (h - 0.68) * 340.0 * amp * sign(h - 0.84);\n  let split = amp * (4.0 + 12.0 * step(0.8, h));\n  let o = vec2f(x, 0.0);\n  let c = vec3f(backdrop_at(p + o + vec2f(split, 0.0)).r, backdrop_at(p + o).g, backdrop_at(p + o - vec2f(split, 0.0)).b);\n  let flash = amp * 0.16 * step(0.5, hash(vec2f(beat, 9.0)));\n  return vec4f(c * (1.0 + amp * 0.2) + flash * vec3f(0.36, 0.72, 1.0), 1.0);\n}`;\nconst NANIKA = `\nfn shade(p: vec2f) -> vec4f {\n  let k = frame.params[0].x; let d = p - frame.params[0].yz; let r = max(length(d), 1.0);\n  let hole = 74.0 * k;\n  let ang = k * 2600.0 / (r + 70.0) * 0.26 + frame.time * 0.5 * k;\n  let far = r + k * 26000.0 / (r + 36.0);\n  let s = vec2f(cos(ang), sin(ang));\n  let u = d / r * far;\n  let q = vec2f(u.x * s.x - u.y * s.y, u.x * s.y + u.y * s.x);\n  var c = backdrop_at(frame.params[0].yz + q).rgb;\n  let theta = atan2(d.y, d.x);\n  let disk = (0.5 + 0.5 * sin(theta * 3.0 + 230.0 / (r * 0.3 + 12.0) - frame.time * 9.0));\n  let ring = exp(-pow((r - hole * 1.22) / (3.0 + 7.0 * k), 2.0));\n  let halo = exp(-max(r - hole, 0.0) / (46.0 * k + 1.0)) * disk;\n  c += (ring * vec3f(1.0, 0.86, 0.68) * 1.5 + halo * vec3f(0.95, 0.32, 0.72) * 0.9) * k;\n  return vec4f(c * smoothstep(hole * 0.92, hole * 1.06, r), 1.0);\n}`;\nconst ZETSU = `${HASH}\nfn shade(p: vec2f) -> vec4f {\n  let wipe = frame.params[0].x; let cell = 9.0;\n  let id = floor(p / cell); let local = p - (id + 0.5) * cell;\n  let v = length((id * cell - frame.params[0].yz) / 980.0) + hash(id) * 0.14;\n  let life = (v - wipe) / 0.16;\n  if (life >= 1.0) { return vec4f(backdrop_at(p).rgb, 1.0); }\n  if (life <= 0.0) { return vec4f(0.0, 0.0, 0.0, 1.0); }\n  let half_size = cell * 0.5 * smoothstep(0.0, 0.8, life);\n  let inner = step(abs(local.x), half_size) * step(abs(local.y), half_size);\n  let glow = (1.0 - life) * (1.0 - life);\n  return vec4f((backdrop_at((id + 0.5) * cell).rgb + glow * vec3f(0.42, 0.72, 1.0)) * inner, 1.0);\n}`;\n\nconst layer = (\n  source: string,\n  box: Rect,\n  time: number,\n  params: ReadonlyArray<number>,\n): Fx => ({ source, box, time, params: [...params], readsBackdrop: true });\n\nexport interface Drop {\n  readonly age: number;\n  readonly x: number;\n  readonly y: number;\n}\nconst MAX_DROPS = 8;\nexport const waterRipple = (o: {\n  box: Rect;\n  time: number;\n  drops: ReadonlyArray<Drop>;\n  level?: number;\n  swell?: number;\n}): Fx => {\n  const drops = Array.from(\n    { length: MAX_DROPS },\n    (_, k) => o.drops[k] ?? { age: -1, x: 0, y: 0 },\n  );\n  return layer(WATER, o.box, o.time, [\n    ...drops.flatMap((d) => [d.age, d.x - o.box.x, d.y - o.box.y, 0]),\n    (o.level ?? o.box.y + o.box.h + 120) - o.box.y,\n    o.swell ?? 0,\n    0,\n    0,\n  ]);\n};\nexport const bungeeGum = (o: {\n  box: Rect;\n  time: number;\n  from: readonly [number, number];\n  pull: readonly [number, number];\n}): Fx =>\n  layer(GUM, o.box, o.time, [\n    o.from[0] - o.box.x,\n    o.from[1] - o.box.y,\n    o.pull[0],\n    o.pull[1],\n  ]);\nexport const enScan = (o: {\n  box: Rect;\n  time: number;\n  center: readonly [number, number];\n  radius: number;\n}): Fx =>\n  layer(EN, o.box, o.time, [\n    o.center[0] - o.box.x,\n    o.center[1] - o.box.y,\n    o.radius,\n    0,\n  ]);\nexport const godspeed = (o: { box: Rect; time: number; amount: number }): Fx =>\n  layer(GODSPEED, o.box, o.time, [o.amount, 0, 0, 0]);\nexport const singularity = (o: {\n  box: Rect;\n  time: number;\n  center: readonly [number, number];\n  pull: number;\n}): Fx =>\n  layer(NANIKA, o.box, o.time, [\n    o.pull,\n    o.center[0] - o.box.x,\n    o.center[1] - o.box.y,\n    0,\n  ]);\nexport const zetsu = (o: {\n  box: Rect;\n  time: number;\n  center: readonly [number, number];\n  wipe: number;\n}): Fx =>\n  layer(ZETSU, o.box, o.time, [\n    o.wipe,\n    o.center[0] - o.box.x,\n    o.center[1] - o.box.y,\n    0,\n  ]);\n"
    },
    {
      "path": "packages/fx/src/shaders/pack.ts",
      "target": "@ui/gpuixui/fx/shaders/pack.ts",
      "type": "registry:lib",
      "content": "// CPU side of the effects, from rune-fx (MIT, © Anomaly): parameter packing and per-frame tables.\nimport { DISTORT, ELECTRIC, EXTRAS, FILL, GLOW, PULSE } from \"./wgsl.js\";\n\nexport interface Rect {\n  readonly x: number;\n  readonly y: number;\n  readonly w: number;\n  readonly h: number;\n}\nexport interface Fx {\n  readonly source: string;\n  readonly box: Rect;\n  readonly params: number[];\n  readonly data?: number[];\n  readonly readsBackdrop?: boolean;\n  readonly time: number;\n  readonly simulationSource?: string;\n  readonly simulationGrid?: readonly [number, number];\n  readonly simulationUniform?: ReadonlyArray<number>;\n}\ntype V4 = readonly [number, number, number, number];\nconst Z: V4 = [0, 0, 0, 0];\nconst dec = (c: number) =>\n  c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;\nexport const rgb = (hex: number): V4 => [\n  dec(((hex >> 16) & 255) / 255),\n  dec(((hex >> 8) & 255) / 255),\n  dec((hex & 255) / 255),\n  0,\n];\nconst inflate = (r: Rect, m: number): Rect => ({\n  x: r.x - m,\n  y: r.y - m,\n  w: r.w + 2 * m,\n  h: r.h + 2 * m,\n});\n\ninterface Pack {\n  c0?: V4;\n  c1?: V4;\n  c2?: V4;\n  p0?: V4;\n  p1?: V4;\n  p2?: V4;\n  p3?: V4;\n  aux?: V4;\n  aux2?: V4;\n  xf?: V4;\n  morph?: number;\n  frost?: number;\n  seed?: number;\n  variant?: number;\n  opacity?: number;\n  time?: number;\n}\nconst pack = (rect: Rect, radius: number, box: Rect, p: Pack): number[] => [\n  rect.x - box.x,\n  rect.y - box.y,\n  rect.w,\n  rect.h,\n  Math.max(0, Math.min(radius, rect.w / 2, rect.h / 2)),\n  1,\n  Math.min(p.opacity ?? 1, 1),\n  p.morph ?? 0,\n  ...(p.c0 ?? Z),\n  ...(p.c1 ?? Z),\n  ...(p.c2 ?? Z),\n  ...(p.p0 ?? Z),\n  ...(p.p1 ?? Z),\n  ...(p.p2 ?? Z),\n  ...(p.p3 ?? Z),\n  p.time ?? 0,\n  (p.seed ?? 0) % 65536,\n  p.variant ?? 0,\n  0,\n  ...(p.aux ?? Z),\n  ...(p.aux2 ?? [0, 0, 1, 1]),\n  ...(p.xf ?? Z),\n  p.frost ?? 0,\n  0,\n  0,\n  0,\n];\n\nconst pcg = (v: number): number => {\n  const s = (Math.imul(v, 747796405) + 2891336453) | 0;\n  const w = Math.imul(((s >>> ((s >>> 28) + 4)) ^ s) | 0, 277803737);\n  return ((w >>> 22) ^ w) >>> 0;\n};\nconst hu = (a: number, b: number): number =>\n  pcg((a ^ pcg((b + 0x9e3779b9) >>> 0)) >>> 0);\nconst u01 = (n: number): number => (pcg(n >>> 0) >>> 8) * (1 / 16777216);\nconst hcell = (cx: number, cy: number, seed: number) =>\n  (pcg((cx ^ pcg((cy ^ pcg(seed >>> 0)) >>> 0)) >>> 0) >>> 8) * (1 / 16777216);\nconst fade = (f: number) => f * f * f * (f * (f * 6 - 15) + 10);\nconst gnoise = (x: number, y: number, per: number, seed: number) => {\n  const ix = Math.floor(x),\n    iy = Math.floor(y),\n    fx = x - ix,\n    fy = y - iy;\n  const a0 = per > 0 ? ((ix % per) + per) % per : ix;\n  const a1 = per > 0 ? (a0 + 1) % per : ix + 1;\n  const dot = (cx: number, cy: number, dx: number, dy: number) => {\n    const g = hcell(cx, cy, seed) * Math.PI * 2;\n    return Math.cos(g) * dx + Math.sin(g) * dy;\n  };\n  const a = dot(a0, iy, fx, fy),\n    b = dot(a1, iy, fx - 1, fy),\n    c = dot(a0, iy + 1, fx, fy - 1),\n    d = dot(a1, iy + 1, fx - 1, fy - 1);\n  const ux = fade(fx),\n    uy = fade(fy);\n  const ab = a + (b - a) * ux,\n    cd = c + (d - c) * ux;\n  return (ab + (cd - ab) * uy) * 1.41421;\n};\nconst foldT = (t: number) => {\n  const u = (((t / 1024) % 1) + 1) % 1;\n  return u <= 0.5 ? u * 1024 : (1 - u) * 1024;\n};\nconst ss = (a: number, b: number, x: number) => {\n  const t = Math.min(1, Math.max(0, (x - a) / (b - a)));\n  return t * t * (3 - 2 * t);\n};\n\nexport const glow = (o: {\n  rect: Rect;\n  radius: number;\n  time: number;\n  style?: 0 | 1 | 2;\n  color?: number;\n  core?: number;\n  third?: number;\n  size?: number;\n  intensity?: number;\n  inner?: number;\n  auraSpeed?: number;\n  opacity?: number;\n  hot?: number;\n}): Fx => {\n  const size = o.size ?? 14;\n  const box = inflate(o.rect, size * 4.5);\n  return {\n    source: GLOW,\n    box,\n    time: o.time,\n    params: pack(o.rect, o.radius, box, {\n      variant: o.style ?? 0,\n      time: o.time,\n      opacity: o.opacity,\n      c0: rgb(o.color ?? 0x7c5cff),\n      c1: rgb(o.core ?? 0xf4f0ff),\n      c2: rgb(o.third ?? 0x22d3ee),\n      p0: [size, o.intensity ?? 1, o.inner ?? 0, 0.15],\n      p1: [0, 2.6, 1, o.hot ?? 0.6],\n      p2: [o.auraSpeed ?? 0.12, 0.6, 4.5, 0],\n    }),\n  };\n};\n\nexport const pulse = (o: {\n  rect: Rect;\n  radius: number;\n  time: number;\n  style?: 0 | 1 | 2;\n  color?: number;\n  period?: number;\n  reach?: number;\n  opacity?: number;\n}): Fx => {\n  const style = o.style ?? 0,\n    reach = o.reach ?? 36,\n    width = 1.6;\n  const box = inflate(\n    o.rect,\n    style === 1\n      ? reach * 5\n      : style === 2\n        ? reach + width * 16 + 2\n        : reach + width * 12.8,\n  );\n  return {\n    source: PULSE,\n    box,\n    time: o.time,\n    params: pack(o.rect, o.radius, box, {\n      variant: style,\n      time: o.time,\n      opacity: o.opacity,\n      c0: rgb(o.color ?? 0x3b82f6),\n      c1: rgb(0xe8f1ff),\n      p0: [3, o.period ?? 2.4, reach, width],\n      p1: [1, 0, 0.75, 0],\n      p2: [0, 0.16, 2.6, 0.15],\n    }),\n  };\n};\n\nexport const shimmer = (o: {\n  rect: Rect;\n  radius: number;\n  time: number;\n  intensity?: number;\n  period?: number;\n  band?: number;\n  opacity?: number;\n}): Fx => {\n  const box = inflate(o.rect, 1);\n  return {\n    source: EXTRAS,\n    box,\n    time: o.time,\n    params: pack(o.rect, o.radius, box, {\n      variant: 0,\n      time: o.time,\n      opacity: o.opacity,\n      c0: rgb(0xffffff),\n      c1: [...rgb(0x1c1f26).slice(0, 3), 0] as unknown as V4,\n      p0: [o.period ?? 1.8, o.band ?? 28, 0.35, o.intensity ?? 0.16],\n      p1: [0, 0.3, 0, 0],\n    }),\n  };\n};\n\nconst BURST_LIFE = 0.55,\n  STAGGER = 0.16;\nconst starScale = (a: number) => {\n  const x = Math.min(a / 0.22, 1),\n    c = 2.2;\n  return (1 + (c + 1) * (x - 1) ** 3 + c * (x - 1) ** 2) * (1 - ss(0.55, 1, a));\n};\nexport const sparkles = (o: {\n  rect: Rect;\n  radius?: number;\n  time: number;\n  burst?: number;\n  count?: number;\n  size?: number;\n  color?: number;\n  margin?: number;\n  life?: number;\n  seed?: number;\n}): Fx => {\n  const count = Math.min(o.count ?? 6, 64),\n    size = o.size ?? 8,\n    margin = o.margin ?? 26,\n    life0 = o.life ?? 1.5,\n    seed = o.seed ?? 0,\n    t = o.time,\n    r = o.rect;\n  const box = inflate(r, margin + size * 1.566 + 2);\n  const lx = r.x - box.x,\n    ly = r.y - box.y,\n    cx = lx + r.w / 2,\n    cy = ly + r.h / 2,\n    hw = r.w / 2,\n    hh = r.h / 2;\n  const data: number[] = [];\n  let live = 0;\n  for (let k = 0; k < count; k++) {\n    const h0 = hu((seed + 313) >>> 0, k * 11 + 1);\n    let hk: number, age: number, life: number;\n    if (o.burst !== undefined) {\n      life = life0 * BURST_LIFE * (0.7 + 0.6 * u01(h0));\n      hk = h0;\n      age = t - o.burst - STAGGER * u01(h0 + 1);\n    } else {\n      life = life0 * (0.7 + 0.6 * u01(h0));\n      const cycle = life * (1.5 + 0.8 * u01(h0 + 2));\n      const tau = t / cycle + u01(h0 + 1);\n      const kk = Math.floor(tau);\n      hk = hu(h0, kk >>> 0);\n      age = (tau - kk) * cycle;\n    }\n    if (age < 0 || age > life) continue;\n    const a = age / life,\n      th = Math.PI * 2 * u01(hk + 2),\n      dx = Math.cos(th),\n      dy = Math.sin(th);\n    const edge =\n      1 /\n      Math.max(Math.abs(dx) / Math.max(hw, 1), Math.abs(dy) / Math.max(hh, 1));\n    let out = margin * (0.15 + 0.85 * u01(hk + 3));\n    if (o.burst !== undefined) out *= 0.35 + 0.65 * (1 - Math.exp(-age * 5));\n    const v = u01(hk + 4),\n      s = size * (0.45 + 0.9 * v * v),\n      fq = 5 + 4 * u01(hk + 5);\n    const tw =\n      0.5 + 0.5 * Math.sin(Math.PI * 2 * fq * age + Math.PI * 2 * u01(hk + 6));\n    const sc = starScale(a),\n      env = 1 - 0.3 * tw * tw;\n    if (sc * env < 0.01) continue;\n    const ang = (u01(hk + 8) - 0.5) * 0.35 + (u01(hk + 7) - 0.5) * 1.2 * age;\n    data.push(\n      cx + dx * (edge + out),\n      cy + dy * (edge + out),\n      s * sc,\n      env,\n      Math.cos(ang),\n      Math.sin(ang),\n      0,\n      0,\n    );\n    live++;\n  }\n  return {\n    source: EXTRAS,\n    box,\n    time: t,\n    data,\n    params: pack(r, o.radius ?? 0, box, {\n      variant: 1,\n      time: t,\n      c0: rgb(o.color ?? 0xffe6a8),\n      p0: [count, life0, size, 1],\n      p1: [margin, 0, 0, 0],\n      xf: [0, live, 0, 0],\n    }),\n  };\n};\n\nconst METAL = {\n  tint: 0xe9ecf0,\n  light: 0xffffff,\n  flow: 0.6,\n  scale: 100,\n  speed: 0.35,\n  bevel: 14,\n  dome: 0.55,\n  angle: -0.12,\n  iridescence: 0.08,\n  contrast: 1,\n  anchor: 0,\n};\nexport type MetalParams = Partial<typeof METAL>;\nexport const liquidMetal = (\n  o: {\n    rect: Rect;\n    radius: number;\n    time: number;\n    border?: number;\n    opacity?: number;\n    origin?: { x: number; y: number };\n  } & MetalParams,\n): Fx => {\n  const p = { ...METAL, ...o };\n  const box = inflate(o.rect, 1);\n  return {\n    source: FILL,\n    box,\n    time: foldT(o.time),\n    params: pack(o.rect, o.radius, box, {\n      variant: 0,\n      time: foldT(o.time),\n      opacity: o.opacity,\n      c0: rgb(p.tint),\n      c1: rgb(p.light),\n      aux: [o.border ?? 0, 1, 0, 0],\n      p0: [p.flow, p.scale, p.speed, p.bevel],\n      p1: [p.dome, p.angle, p.iridescence, p.contrast],\n      p2: [p.anchor, 0, 0, 0],\n    }),\n  };\n};\n\nexport const plastic = (o: {\n  rect: Rect;\n  radius: number;\n  time: number;\n  color: number;\n  roughness?: number;\n  dome?: number;\n  bevel?: number;\n  angle?: number;\n  opacity?: number;\n}): Fx => {\n  const box = inflate(o.rect, 1);\n  return {\n    source: FILL,\n    box,\n    time: 0,\n    params: pack(o.rect, o.radius, box, {\n      variant: 10,\n      opacity: o.opacity,\n      c0: rgb(o.color),\n      aux: [0, 1, 0, 0],\n      p0: [o.roughness ?? 0.15, o.dome ?? 0.35, o.bevel ?? 6, o.angle ?? -0.6],\n    }),\n  };\n};\n\nconst oklab = (c: V4): readonly [number, number, number] => {\n  const [r, g, b] = c;\n  const l = Math.cbrt(\n    Math.max(0, 0.41222146 * r + 0.53633255 * g + 0.051445995 * b),\n  );\n  const m = Math.cbrt(\n    Math.max(0, 0.2119035 * r + 0.6806995 * g + 0.10739696 * b),\n  );\n  const s = Math.cbrt(\n    Math.max(0, 0.08830246 * r + 0.28171885 * g + 0.6299787 * b),\n  );\n  return [\n    0.21045426 * l + 0.7936178 * m - 0.004072047 * s,\n    1.9779985 * l - 2.4285922 * m + 0.4505937 * s,\n    0.025904037 * l + 0.78277177 * m - 0.80867577 * s,\n  ];\n};\nconst POINTS = [\n  [0.12, 0.18],\n  [0.86, 0.12],\n  [0.5, 0.55],\n  [0.14, 0.9],\n  [0.9, 0.86],\n  [0.62, 0.3],\n] as const;\nexport const MESH_PALETTES: Record<string, readonly number[]> = {\n  dusk: [0x2b1b5a, 0xff6f91, 0xffc46b, 0x6a4cff, 0xff9a5a],\n  lagoon: [0x0b3d5c, 0x2ec4b6, 0xcbf3f0, 0x1b6ca8],\n  orchid: [0xf9d5e5, 0xc06c84, 0x6c5b7b, 0xf8b195, 0x355c7d, 0xeeac99],\n  graphite: [0x15171c, 0x3a3f4b, 0x8a93a3, 0x22262e],\n};\nexport const mesh = (o: {\n  rect: Rect;\n  radius: number;\n  time: number;\n  colors: readonly number[];\n  speed?: number;\n  drift?: number;\n  sharpness?: number;\n  warp?: number;\n  seed?: number;\n  opacity?: number;\n}): Fx => {\n  const box = inflate(o.rect, 1),\n    speed = o.speed ?? 0.35,\n    drift = o.drift ?? 0.18,\n    seed = o.seed ?? 1;\n  const tt = foldT(o.time * speed * 0.5);\n  const data: number[] = [];\n  o.colors.forEach((hex, k) => {\n    const c = rgb(hex),\n      l = oklab(c),\n      s = (seed + k * 31) >>> 0,\n      x = tt + k * 13.1;\n    const px = POINTS[k]![0] + drift * 1.4 * gnoise(x, 0.5, 0, s),\n      py = POINTS[k]![1] + drift * 1.4 * gnoise(x, 7.5, 0, (s + 97) >>> 0);\n    data.push(c[0], c[1], c[2], px, l[0], l[1], l[2], py);\n  });\n  return {\n    source: FILL,\n    box,\n    time: foldT(o.time),\n    data,\n    params: pack(o.rect, o.radius, box, {\n      variant: 1,\n      time: foldT(o.time),\n      seed,\n      opacity: o.opacity,\n      aux: [0, 1, 0, 0],\n      p0: [drift, speed, o.sharpness ?? 1.6, o.warp ?? 0.35],\n      xf: [0, o.colors.length, 0, 0],\n    }),\n  };\n};\n\nconst ramp = (colors: readonly number[]): number[] =>\n  colors.flatMap((hex) => {\n    const c = rgb(hex);\n    const l = oklab(c);\n    return [c[0], c[1], c[2], 0, l[0], l[1], l[2], 0];\n  });\n\nexport type DitherInput = 0 | 1 | 2 | 3;\nexport type DitherPattern = 1 | 2 | 3 | 5;\n\nexport const dither = (o: {\n  rect: Rect;\n  radius: number;\n  time: number;\n  colors: readonly number[];\n  pattern?: DitherPattern;\n  input?: DitherInput;\n  pixel?: number;\n  angle?: number;\n  noiseScale?: number;\n  speed?: number;\n  bias?: number;\n  contrast?: number;\n  opacity?: number;\n  seed?: number;\n}): Fx => {\n  const box = inflate(o.rect, 1),\n    colors = o.colors.length === 0 ? [0xffffff] : o.colors,\n    input = o.input ?? 0;\n  return {\n    source: FILL,\n    box,\n    time: o.time,\n    data: ramp(colors),\n    readsBackdrop: input === 3,\n    params: pack(o.rect, o.radius, box, {\n      variant: 2,\n      time: o.time,\n      seed: o.seed ?? 0,\n      opacity: o.opacity,\n      aux: [0, 1, 0, 0],\n      p0: [o.pattern ?? 3, input, o.pixel ?? 4, o.angle ?? 0],\n      p1: [o.noiseScale ?? 40, o.speed ?? 0.3, o.bias ?? 0, o.contrast ?? 1],\n      xf: [0, colors.length, 0, 0],\n    }),\n  };\n};\n\nexport const halftone = (o: {\n  rect: Rect;\n  radius: number;\n  time: number;\n  ink: number;\n  base: number;\n  input?: DitherInput;\n  pitch?: number;\n  angle?: number;\n  screenAngle?: number;\n  noiseScale?: number;\n  speed?: number;\n  bias?: number;\n  contrast?: number;\n  opacity?: number;\n  seed?: number;\n}): Fx => {\n  const box = inflate(o.rect, 1),\n    input = o.input ?? 0;\n  return {\n    source: FILL,\n    box,\n    time: o.time,\n    readsBackdrop: input === 3,\n    params: pack(o.rect, o.radius, box, {\n      variant: 9,\n      time: o.time,\n      seed: o.seed ?? 0,\n      opacity: o.opacity,\n      c0: rgb(o.ink),\n      c1: rgb(o.base),\n      aux: [0, 1, 0, 0],\n      p0: [0, input, o.pitch ?? 8, o.angle ?? 0],\n      p1: [o.noiseScale ?? 40, o.speed ?? 0.3, o.bias ?? 0, o.contrast ?? 1],\n      p2: [o.screenAngle ?? 0.5, 0, 0, 0],\n    }),\n  };\n};\n\nexport const crt = (o: {\n  rect: Rect;\n  time: number;\n  radius?: number;\n  bulge?: number;\n  scanline?: number;\n  depth?: number;\n  chroma?: number;\n  vignette?: number;\n  glow?: number;\n  roll?: number;\n  feather?: number;\n  opacity?: number;\n}): Fx => ({\n  source: DISTORT,\n  box: o.rect,\n  time: o.time,\n  readsBackdrop: true,\n  params: pack(o.rect, o.radius ?? 0, o.rect, {\n    variant: 3,\n    time: o.time,\n    opacity: o.opacity,\n    p0: [o.bulge ?? 0.05, o.scanline ?? 3, o.depth ?? 0.18, o.chroma ?? 0.6],\n    p1: [o.vignette ?? 0.22, o.glow ?? 0.1, o.roll ?? 0.3, o.feather ?? 1],\n  }),\n});\n\nexport const fluted = (o: {\n  rect: Rect;\n  radius?: number;\n  time: number;\n  rib?: number;\n  refraction?: number;\n  frost?: number;\n  dispersion?: number;\n  highlight?: number;\n}): Fx => {\n  const box = inflate(o.rect, 1),\n    frost = o.frost ?? 0;\n  return {\n    source: FILL,\n    box,\n    time: 0,\n    readsBackdrop: true,\n    params: pack(o.rect, o.radius ?? 0, box, {\n      variant: 4,\n      c0: rgb(0xffffff),\n      aux: [0, 1, 0, 0],\n      frost: frost * 18 * 1.6,\n      p0: [o.rib ?? 14, 0, o.refraction ?? 9, frost],\n      p1: [o.dispersion ?? 0.2, o.highlight ?? 0.55, 0, 0],\n    }),\n  };\n};\n\nexport const shockwave = (o: {\n  rect: Rect;\n  time: number;\n  at: readonly [number, number];\n  t0: number;\n  reach?: number;\n  width?: number;\n  amount?: number;\n  chroma?: number;\n  duration?: number;\n}): Fx | null => {\n  const duration = o.duration ?? 1.1;\n  if (o.time < o.t0 || o.time > o.t0 + duration) return null;\n  return {\n    source: DISTORT,\n    box: o.rect,\n    time: o.time,\n    readsBackdrop: true,\n    params: pack(o.rect, 0, o.rect, {\n      variant: 1,\n      time: o.time,\n      aux: [o.at[0] - o.rect.x, o.at[1] - o.rect.y, 0, 0],\n      p0: [o.reach ?? 1100, o.width ?? 90, o.amount ?? 30, o.chroma ?? 0.6],\n      p1: [o.t0, duration, 0, 0],\n    }),\n  };\n};\n\nexport const lens = (o: {\n  rect: Rect;\n  radius: number;\n  time?: number;\n  second?: { x: number; y: number; r: number };\n  frost?: number;\n  bevel?: number;\n  depth?: number;\n  dispersion?: number;\n  magnification?: number;\n  unionK?: number;\n  shadow?: number;\n  rim?: number;\n}): Fx => {\n  const r = o.rect,\n    frost = o.frost ?? 0;\n  const s2 = o.second\n    ? {\n        x: o.second.x - o.second.r,\n        y: o.second.y - o.second.r,\n        w: o.second.r * 2,\n        h: o.second.r * 2,\n      }\n    : null;\n  const x0 = Math.min(r.x, s2?.x ?? r.x),\n    y0 = Math.min(r.y, s2?.y ?? r.y),\n    x1 = Math.max(r.x + r.w, s2 ? s2.x + s2.w : 0),\n    y1 = Math.max(r.y + r.h, s2 ? s2.y + s2.h : 0);\n  const box = inflate({ x: x0, y: y0, w: x1 - x0, h: y1 - y0 }, 28);\n  return {\n    source: DISTORT,\n    box,\n    time: o.time ?? 0,\n    readsBackdrop: true,\n    params: pack(r, o.radius, box, {\n      variant: 2,\n      time: o.time ?? 0,\n      c0: rgb(0xffffff),\n      frost: frost * 18 * 1.6,\n      p0: [\n        o.bevel ?? 14,\n        o.depth ?? 16,\n        o.dispersion ?? 0.14,\n        o.magnification ?? 1.04,\n      ],\n      p1: [1, frost, o.shadow ?? 0.35, o.rim ?? 1.6],\n      p2: [-2.09, 0, s2 ? (o.unionK ?? 22) : 0, s2 ? o.second!.r : 0],\n      p3: s2 ? [s2.x - box.x, s2.y - box.y, s2.w, s2.h] : Z,\n    }),\n  };\n};\n\nconst gauss3 = (h: number) => (u01(h) + u01(h + 1) + u01(h + 2) - 1.5) * 2;\nconst nextMul4 = (n: number) => Math.ceil(n / 4) * 4;\nconst blur3 = (v: number[], radius: number) => {\n  const n = v.length,\n    r = Math.min(n >> (1 - 0), Math.max(0, Math.round(radius * 0.58)));\n  if (r === 0) return v.slice();\n  let a = v.slice(),\n    b = Array.from({ length: n }, () => 0);\n  const at = (x: number[], i: number) => x[((i % n) + n) % n]!;\n  for (let pass = 0; pass < 3; pass++) {\n    let acc = 0;\n    for (let k = -r; k <= r; k++) acc += at(a, k);\n    for (let i = 0; i < n; i++) {\n      b[i] = acc / (2 * r + 1);\n      acc += at(a, i + r + 1) - at(a, i - r);\n    }\n    [a, b] = [b, a];\n  }\n  return a;\n};\nconst perimeter = (r: Rect, radius: number) => {\n  const c = Math.min(radius, Math.min(r.w, r.h) / 2);\n  return 4 * (r.h / 2 - c + (c * Math.PI) / 2 + r.w / 2 - c);\n};\nconst crawl = (\n  n: number,\n  cells: number,\n  speed: number,\n  t: number,\n  seed: number,\n  k: number,\n  calm: boolean,\n) => {\n  const cc = Math.max(Math.trunc(cells / 3), 2),\n    sp = calm ? speed * 0.35 : speed,\n    out: number[] = [];\n  for (let i = 0; i < n; i++) {\n    const cx = (i / n) * cc,\n      c =\n        0.5 +\n        0.5 *\n          gnoise(\n            cx - t * sp * 0.08 * cc,\n            t * 0.35 + k * 5,\n            cc,\n            (seed + 3) >>> 0,\n          );\n    out.push(\n      calm ? 0.45 + 0.55 * ss(0.2, 0.8, c) : 0.3 + 0.7 * ss(0.25, 0.75, c),\n    );\n  }\n  return out;\n};\nconst FORK = 16;\nconst forkWalk = (hk: number, len: number) => {\n  const s = Array.from({ length: FORK }, () => 0);\n  let acc = 0;\n  for (let i = 1; i < FORK; i++) {\n    acc = Math.max(\n      -len * 0.3,\n      Math.min(len * 0.3, acc + gauss3(hu(hk, 100 + i)) * len * 0.07),\n    );\n    s[i] = acc;\n  }\n  return s;\n};\nconst forkEnv = (age: number, life: number) =>\n  [\n    1 - (1 - Math.min(age / 0.035, 1)) ** 3,\n    ss(0, 0.01, age) *\n      Math.exp(-age / (life * 0.4)) *\n      (1 - ss(0.75 * life, life, age)),\n    1 - age / life,\n  ] as const;\nconst mpdLoop = (\n  start: number[],\n  levels: number,\n  amp: (l: number) => number,\n  channel: number,\n  strike: number,\n  memory: number,\n) => {\n  let pts = start;\n  for (let lv = 0; lv < levels; lv++) {\n    const m = pts.length,\n      sd = hu(lv < memory ? channel : strike, lv * 7919 + 1),\n      a = amp(lv),\n      next: number[] = [];\n    for (let i = 0; i < m; i++) {\n      const p0 = pts[i]!,\n        p1 = pts[(i + 1) % m]!;\n      next.push(p0, (p0 + p1) * 0.5 + a * gauss3(hu(sd, i * 3)));\n    }\n    pts = next;\n  }\n  return pts;\n};\nconst resampleLoop = (ctrl: number[], n: number, limit: number) => {\n  const m = ctrl.length,\n    out: number[] = [];\n  for (let i = 0; i < n; i++) {\n    const x = (i / n) * m,\n      i0 = Math.min(Math.floor(x), m - 1),\n      f = x - i0,\n      d = ctrl[i0]! + (ctrl[(i0 + 1) % m]! - ctrl[i0]!) * f;\n    out.push(limit * Math.tanh(d / limit));\n  }\n  return out;\n};\n\nexport const electric = (o: {\n  rect: Rect;\n  radius: number;\n  time: number;\n  charged?: boolean;\n  color?: number;\n  core?: number;\n  cool?: number;\n  intensity?: number;\n  amplitude?: number;\n  seed?: number;\n  opacity?: number;\n}): Fx => {\n  const charged = o.charged ?? false,\n    seed = o.seed ?? 0,\n    t = o.time;\n  const p = charged\n    ? {\n        amplitude: o.amplitude ?? 1.1,\n        frequency: 3,\n        speed: 2,\n        core: 0.5,\n        glow: 4,\n        forks: 0.25,\n        flicker: 0,\n        strands: 1,\n        gap: 2,\n        forkLen: 20,\n      }\n    : {\n        amplitude: o.amplitude ?? 5,\n        frequency: 2.4,\n        speed: 3.2,\n        core: 0.6,\n        glow: 5,\n        forks: 0.55,\n        flicker: 0.45,\n        strands: 2,\n        gap: 2,\n        forkLen: 20,\n      };\n  const m = p.amplitude * 1.7 + p.glow * 5;\n  const box = inflate(o.rect, m + p.gap + p.forkLen * (charged ? 0.6 : 1.3));\n  const total = perimeter(o.rect, o.radius),\n    n = nextMul4(Math.min(2048, Math.max(64, Math.ceil(total)))),\n    step = total / n,\n    freq = p.frequency / 100;\n  const data: number[] = [0, 0, 0, 0, 0, 0, 0, 0];\n  let forks = 0,\n    strands = p.strands;\n  if (charged) {\n    data[4] = 1;\n    const cells = Math.max(Math.round(total * freq), 3),\n      sp = p.speed * 0.35,\n      buf: number[] = [];\n    const disp = (x0: number, t0: number) => {\n      let x = x0,\n        tt = t0,\n        a = 1,\n        s = 0,\n        nn = 0,\n        per = cells;\n      for (let oc = 0; oc < 3; oc++) {\n        s += a * gnoise(x, tt, per, (seed + oc * 101) >>> 0);\n        nn += a;\n        x *= 2;\n        per *= 2;\n        tt *= 1.55;\n        a *= 0.5;\n      }\n      return (s / nn) * 1.6;\n    };\n    for (let i = 0; i < n; i++)\n      buf.push(disp((i / n) * cells, t * sp) * p.amplitude);\n    data.push(\n      ...buf,\n      ...blur3(buf, (p.glow * 1.2) / step),\n      ...crawl(n, cells, p.speed, t, seed, 0, true),\n    );\n    for (let j = 0; j < 5; j++) {\n      const hj = hu(seed, j * 977 + 13),\n        pr = 0.3 + 0.25 * u01(hj),\n        tau = t / pr + u01(hj + 1),\n        kk = Math.floor(tau),\n        age = (tau - kk) * pr,\n        hk = hu(hj, kk >>> 0);\n      if (u01(hk) > p.forks * 0.5) continue;\n      const life = 0.15 + 0.1 * u01(hk + 2);\n      if (age > life) continue;\n      const len = p.forkLen * 0.4 * (0.6 + 0.6 * u01(hk + 4)),\n        [grow, lifee, heat] = forkEnv(age, life);\n      data.push(\n        u01(hk + 3) * total,\n        total,\n        0,\n        0,\n        len,\n        grow,\n        lifee,\n        heat,\n        ...forkWalk(hk, len),\n      );\n      forks++;\n    }\n    strands = 1;\n  } else {\n    const sdS = hu(seed, 0x5157),\n      period = Math.max(0.05, Math.min(4, 0.55 / p.speed));\n    const start = (k: number) => (k + 0.35 * u01(hu(sdS, k >>> 0))) * period;\n    let k = Math.floor(t / period);\n    if (t < start(k)) k -= 1;\n    const age = t - start(k),\n      dur = start(k + 1) - start(k);\n    const strikeSeed = (ks: number) => hu((sdS ^ 0x3d1f) >>> 0, ks >>> 0);\n    const channel = (ks: number) =>\n      hu(\n        (sdS ^ 0xc4a2) >>> 0,\n        Math.floor(ks / 3 + 0.5 * u01(hu(sdS, 77))) >>> 0,\n      );\n    const noise = (j: number) =>\n      1 -\n      p.flicker *\n        0.25 *\n        (0.5 + 0.5 * gnoise(t * 14, j * 3.7, 0, (seed + 41) >>> 0));\n    const h = strikeSeed(k),\n      a1 = dur * (0.3 + 0.4 * u01(h));\n    const ret =\n      u01(h + 1) < 0.6 && age > a1\n        ? 0.7 * p.flicker * Math.exp(-(age - a1) / 0.03)\n        : 0;\n    const env =\n      (1 + 0.65 * Math.exp(-age / 0.022)) *\n        (0.72 + 0.28 * Math.exp(-age / 0.12)) +\n      ret;\n    const ghost = (g: number) => 0.9 * Math.exp(-g / 0.07);\n    const bright = [\n      env * noise(0),\n      ghost(age) * noise(1),\n      ghost(age + start(k) - start(k - 1)) * noise(2),\n    ];\n    data[4] = bright[0]!;\n    data[5] = bright[1]!;\n    data[6] = bright[2]!;\n    const cells = Math.max(Math.round(total * freq), 3);\n    const path = (ks: number) => {\n      const ch = channel(ks),\n        coarse: number[] = [];\n      for (let i = 0; i < cells; i++)\n        coarse.push(p.amplitude * 0.7 * gauss3(hu(ch, i * 3 + 5)));\n      return resampleLoop(\n        mpdLoop(\n          coarse,\n          3,\n          (lv) => p.amplitude * 0.7 * 2 ** (-0.62 * (lv + 1)),\n          ch,\n          strikeSeed(ks),\n          1,\n        ),\n        n,\n        p.amplitude * 1.7,\n      );\n    };\n    const paths = [0, 1].map((j) => path(k - j));\n    for (let s = 0; s < strands; s++) data.push(...paths[s]!);\n    for (let s = 0; s < strands; s++)\n      data.push(...blur3(paths[s]!, (p.glow * 1.2) / step));\n    for (let s = 0; s < strands; s++)\n      data.push(\n        ...crawl(n, cells, p.speed, t, (seed + s * 7919) >>> 0, s, false),\n      );\n    outer: for (let j = 0; j < 2; j++) {\n      const ks = k - j,\n        fage = t - start(ks);\n      for (let c = 0; c < 3; c++) {\n        if (forks === 5) break outer;\n        const hk = hu((strikeSeed(ks) ^ 0xf04c) >>> 0, c),\n          life = 0.07 + 0.13 * u01(hk + 2);\n        if (u01(hk) > p.forks || fage > life || fage < 0) continue;\n        const i0 = Math.min(Math.trunc(u01(hk + 3) * n), n - 1),\n          len = p.forkLen * (0.6 + 0.6 * u01(hk + 4)),\n          [grow, lifee, heat] = forkEnv(fage, life);\n        data.push(\n          i0 * step,\n          total,\n          paths[j]![i0]!,\n          0,\n          len,\n          grow,\n          lifee * Math.max(bright[0]!, 0.6),\n          heat,\n          ...forkWalk(hk, len),\n        );\n        forks++;\n      }\n    }\n  }\n  data[0] = n;\n  data[1] = strands;\n  data[2] = forks;\n  return {\n    source: ELECTRIC,\n    box,\n    time: t,\n    data,\n    params: pack(o.rect, o.radius, box, {\n      variant: charged ? 2 : 1,\n      time: t,\n      opacity: o.opacity,\n      seed,\n      c0: rgb(o.color ?? 0x4f8dff),\n      c1: rgb(o.core ?? 0xeaf3ff),\n      c2: rgb(o.cool ?? 0x7a4dff),\n      p0: [p.amplitude, p.frequency, p.speed, p.core],\n      p1: [o.intensity ?? 1, p.glow, p.forks, p.flicker],\n      p2: [strands, p.gap, p.forkLen, 0.12],\n      xf: [0, n, forks, strands],\n    }),\n  };\n};\n"
    },
    {
      "path": "packages/fx/src/shaders/wgsl.ts",
      "target": "@ui/gpuixui/fx/shaders/wgsl.ts",
      "type": "registry:lib",
      "content": "// Generated by scripts/gen-rune-wgsl.py from rune-fx (MIT, © Anomaly), crates/rune-fx/src/shaders.\nconst COMMON =\n  \"// rune-fx common prelude. Concatenated in front of every effect module.\\n// Invariants:\\n// - All effect maths runs in points (pt); `px = pt * scale`. Params arrive in pt.\\n// - Colours are linear-light; output is premultiplied (rgb may exceed a: additive light).\\n// - Everything is a pure function of (pixel, instance, time, seed): integer hashes only, no sin-hash,\\n//   so goldens are deterministic on every GPU modulo FMA.\\n\\nstruct Globals {\\n    viewport: vec2f, // target size in px\\n    dither: f32,     // 1 = add TPDF dither (8-bit targets)\\n    srgb: f32,       // 1 = sRGB-blended frame: encode the premultiplied output for a non-sRGB target\\n}\\n\\nstruct Inst {\\n    rect: vec4f,   // node rect pt (x, y, w, h)\\n    shape: vec4f,  // corner radius pt, scale px/pt, layer opacity, morph\\n    bounds: vec4f, // drawn quad px (x0, y0, x1, y1), already clipped to the viewport\\n    c0: vec4f,\\n    c1: vec4f,\\n    c2: vec4f,\\n    p0: vec4f,\\n    p1: vec4f,\\n    p2: vec4f,\\n    p3: vec4f,\\n    t: vec4f,      // time s, seed, variant, flags (bit0 reduced motion)\\n    aux: vec4f,\\n    aux2: vec4f,   // simulation_state rect pt (x, y, w, h): what the bound simulation_state texture covers\\n    xf: vec4f,     // CPU table: first vec4, counts... (per effect)\\n    clip: vec4f,   // window device-px clip rect (x0, y0, x1, y1)\\n    fade: vec4u,   // packed soft-edge and rounded-clip words (CLIP_WGSL)\\n}\\n\\n// Per-layer CPU tables (bolt paths, forks, embers, motion poses...), indexed from Inst.xf.x.\\nfn dat1(base: u32, i: u32) -> f32 { return shader_data_at(base + (i >> 2u))[i & 3u]; }\\n// The backdrop's blur pyramid result (frosted glass only; see FxRenderer::blur_backdrop).\\n// ---------- colour ----------\\nfn to_srgb(c: vec3f) -> vec3f {\\n    let lo = c * 12.92;\\n    let hi = 1.055 * pow(max(c, vec3f(0.0)), vec3f(1.0 / 2.4)) - 0.055;\\n    return select(hi, lo, c <= vec3f(0.0031308));\\n}\\nfn to_lin(c: vec3f) -> vec3f {\\n    let lo = c / 12.92;\\n    let hi = pow((max(c, vec3f(0.0)) + 0.055) / 1.055, vec3f(2.4));\\n    return select(hi, lo, c <= vec3f(0.04045));\\n}\\n// In an sRGB-blended frame (`1.0 > 0.5`), both a non-sRGB frame target and an `Rgba16Float`\\n// isolated layer hold sRGB-encoded premultiplied values (`to_srgb(straight) * a, a`). Decode to\\n// linear premultiplied light on sample so glass, lens, distort and backdrop dither/halftone shade\\n// in linear light before `fs` encodes once for the target.\\nfn bd_lin(c: vec4f) -> vec4f {\\n    if (1.0 > 0.5) {\\n        let a = max(c.a, 0.0);\\n        let straight = select(vec3f(0.0), c.rgb / a, a > 1e-6);\\n        return vec4f(to_lin(straight) * a, a);\\n    }\\n    return c;\\n}\\n// The backdrop at p (pt), sharp and blurred.\\nfn bd(p: vec2f, scale: f32) -> vec4f { return bd_lin(backdrop_at(p)); }\\nfn bdb(p: vec2f, scale: f32) -> vec3f {\\n    var acc = vec3f(0.0);\\n    for (var k = 0u; k < 48u; k++) {\\n        let f = (f32(k) + 0.5) / 48.0;\\n        let a = f32(k) * 2.39996;\\n        acc += bd(p + vec2f(cos(a), sin(a)) * sqrt(f) * frost_radius(), scale).rgb;\\n    }\\n    return acc / 48.0;\\n}\\nstruct VOut { id: u32, px: vec2f }\\nfn pixel(in: VOut) -> vec2f { return in.px; }\\nfn effective_blend_mode(i: Inst) -> u32 {\\n    let m = (u32(i.t.w) >> 1u) & 7u;\\n    if ((m == 1u || m == 3u || m == 4u) && 1.0 < 0.5) {\\n        return 0u;\\n    }\\n    return m;\\n}\\nfn blend_overlay_ch(b: f32, s: f32) -> f32 {\\n    return select(1.0 - 2.0 * (1.0 - b) * (1.0 - s), 2.0 * b * s, b <= 0.5);\\n}\\nfn blend_overlay(b: vec3f, s: vec3f) -> vec3f {\\n    return vec3f(blend_overlay_ch(b.r, s.r), blend_overlay_ch(b.g, s.g), blend_overlay_ch(b.b, s.b));\\n}\\nfn blend_soft_light_ch(b: f32, s: f32) -> f32 {\\n    if (s <= 0.5) {\\n        return b - (1.0 - 2.0 * s) * b * (1.0 - b);\\n    }\\n    let d = select(sqrt(max(b, 0.0)), ((16.0 * b - 12.0) * b + 4.0) * b, b <= 0.25);\\n    return b + (2.0 * s - 1.0) * (d - b);\\n}\\nfn blend_soft_light(b: vec3f, s: vec3f) -> vec3f {\\n    return vec3f(blend_soft_light_ch(b.r, s.r), blend_soft_light_ch(b.g, s.g), blend_soft_light_ch(b.b, s.b));\\n}\\n\\nconst TAU: f32 = 6.2831853;\\nconst PI: f32 = 3.14159265;\\n\\n// ---------- hashing / noise (integer, deterministic) ----------\\nfn pcg(v: u32) -> u32 {\\n    let s = v * 747796405u + 2891336453u;\\n    let w = ((s >> ((s >> 28u) + 4u)) ^ s) * 277803737u;\\n    return (w >> 22u) ^ w;\\n}\\nfn hu(a: u32, b: u32) -> u32 { return pcg(a ^ pcg(b + 0x9E3779B9u)); }\\nfn u01(n: u32) -> f32 { return f32(pcg(n) >> 8u) * (1.0 / 16777216.0); }\\nfn hcell(c: vec2i, seed: u32) -> f32 {\\n    return f32(pcg(bitcast<u32>(c.x) ^ pcg(bitcast<u32>(c.y) ^ pcg(seed))) >> 8u) * (1.0 / 16777216.0);\\n}\\nfn grad2(c: vec2i, seed: u32) -> vec2f {\\n    let a = hcell(c, seed) * TAU;\\n    return vec2f(cos(a), sin(a));\\n}\\n// Gradient noise, ~[-1, 1].\\nfn gnoise(p: vec2f, seed: u32) -> f32 {\\n    let i = vec2i(floor(p));\\n    let f = p - floor(p);\\n    let u = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);\\n    let a = dot(grad2(i, seed), f);\\n    let b = dot(grad2(i + vec2i(1, 0), seed), f - vec2f(1.0, 0.0));\\n    let c = dot(grad2(i + vec2i(0, 1), seed), f - vec2f(0.0, 1.0));\\n    let d = dot(grad2(i + vec2i(1, 1), seed), f - vec2f(1.0, 1.0));\\n    return mix(mix(a, b, u.x), mix(c, d, u.x), u.y) * 1.41421;\\n}\\n// Gradient noise periodic in x with integer period `per` (> 0).\\nfn pgnoise(p: vec2f, per: i32, seed: u32) -> f32 {\\n    let i = vec2i(floor(p));\\n    let f = p - floor(p);\\n    let u = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);\\n    let x0 = ((i.x % per) + per) % per;\\n    let x1 = (x0 + 1) % per;\\n    let a = dot(grad2(vec2i(x0, i.y), seed), f);\\n    let b = dot(grad2(vec2i(x1, i.y), seed), f - vec2f(1.0, 0.0));\\n    let c = dot(grad2(vec2i(x0, i.y + 1), seed), f - vec2f(0.0, 1.0));\\n    let d = dot(grad2(vec2i(x1, i.y + 1), seed), f - vec2f(1.0, 1.0));\\n    return mix(mix(a, b, u.x), mix(c, d, u.x), u.y) * 1.41421;\\n}\\nconst ROT: mat2x2f = mat2x2f(0.8, 0.6, -0.6, 0.8);\\nfn fbm3(p0: vec2f, seed: u32) -> f32 {\\n    var p = p0; var a = 0.5; var s = 0.0;\\n    for (var o = 0u; o < 3u; o++) { s += a * gnoise(p, seed + o * 131u); p = ROT * p * 2.02; a *= 0.5; }\\n    return s / 0.875;\\n}\\nfn fbm5(p0: vec2f, seed: u32) -> f32 {\\n    var p = p0; var a = 0.5; var s = 0.0;\\n    for (var o = 0u; o < 5u; o++) { s += a * gnoise(p, seed + o * 131u); p = ROT * p * 2.02; a *= 0.5; }\\n    return s / 0.96875;\\n}\\n// Interleaved gradient noise (Jimenez), static per pixel: jitter that never shimmers.\\nfn ign(px: vec2f) -> f32 { return fract(52.9829189 * fract(dot(floor(px), vec2f(0.06711056, 0.00583715)))); }\\n\\n// ---------- shapes ----------\\nfn sd_rrect(q: vec2f, half: vec2f, r: f32) -> f32 {\\n    let rr = clamp(r, 0.0, min(half.x, half.y));\\n    let k = abs(q) - half + rr;\\n    return length(max(k, vec2f(0.0))) + min(max(k.x, k.y), 0.0) - rr;\\n}\\nfn smin(a: f32, b: f32, k: f32) -> f32 {\\n    if (k <= 0.0) { return min(a, b); }\\n    let h = max(k - abs(a - b), 0.0) / k;\\n    return min(a, b) - h * h * k * 0.25;\\n}\\n// Arc-length coordinate of the closest boundary point of a centred rounded rect.\\n// Returns (s, total perimeter). Continuous everywhere except the single seam at s = 0 = total.\\nfn rrect_perim(q: vec2f, half: vec2f, r0: f32) -> vec2f {\\n    let r = clamp(r0, 0.0, min(half.x, half.y));\\n    let b = half - r;\\n    let a = abs(q);\\n    let lq = b.y + r * PI * 0.5 + b.x;\\n    var s: f32;\\n    if (a.x > b.x && a.y > b.y) {\\n        s = b.y + r * atan2(a.y - b.y, a.x - b.x);\\n    } else if ((a.x - b.x) > (a.y - b.y)) {\\n        s = min(a.y, b.y);\\n    } else {\\n        s = b.y + r * PI * 0.5 + (b.x - min(a.x, b.x));\\n    }\\n    var o: f32;\\n    if (q.x >= 0.0 && q.y >= 0.0) { o = s; }\\n    else if (q.x < 0.0 && q.y >= 0.0) { o = 2.0 * lq - s; }\\n    else if (q.x < 0.0) { o = 2.0 * lq + s; }\\n    else { o = 4.0 * lq - s; }\\n    return vec2f(o, 4.0 * lq);\\n}\\n\\n// Shape context for the current instance.\\nstruct Ctx {\\n    p: vec2f,      // pt\\n    q: vec2f,      // pt relative to node centre\\n    c: vec2f,      // node centre pt\\n    half: vec2f,\\n    r: f32,\\n    scale: f32,\\n    aa: f32,       // one px in pt\\n    d: f32,        // signed distance to the node shape, pt\\n    t: f32,\\n    seed: u32,\\n    variant: i32,\\n    reduced: bool,\\n}\\nfn ctx(i: Inst, px: vec2f) -> Ctx {\\n    var c: Ctx;\\n    c.scale = i.shape.y;\\n    c.p = px / c.scale;\\n    c.half = i.rect.zw * 0.5;\\n    c.c = i.rect.xy + c.half;\\n    c.q = (px - c.c * c.scale) / c.scale;\\n    c.r = i.shape.x;\\n    c.aa = 1.0 / c.scale;\\n    c.d = sd_rrect(c.q, c.half, c.r);\\n    c.t = i.t.x;\\n    c.seed = u32(i.t.y);\\n    c.variant = i32(i.t.z + 0.5);\\n    c.reduced = (u32(i.t.w) & 1u) != 0u;\\n    return c;\\n}\\nfn sd_grad(c: Ctx) -> vec2f {\\n    let e = 0.35;\\n    let dx = sd_rrect(c.q + vec2f(e, 0.0), c.half, c.r) - sd_rrect(c.q - vec2f(e, 0.0), c.half, c.r);\\n    let dy = sd_rrect(c.q + vec2f(0.0, e), c.half, c.r) - sd_rrect(c.q - vec2f(0.0, e), c.half, c.r);\\n    let gv = vec2f(dx, dy);\\n    return gv / max(length(gv), 1e-5);\\n}\\n\\n// ---------- light profiles ----------\\nfn erf_approx(x: f32) -> f32 {\\n    let x2 = x * x;\\n    let a = 0.147;\\n    let v = sqrt(1.0 - exp(-x2 * (1.2732395 + a * x2) / (1.0 + a * x2)));\\n    return select(-v, v, x >= 0.0);\\n}\\n// Coverage of a half-plane blurred by a Gaussian of sigma s, at signed distance d.\\nfn cov(d: f32, s: f32) -> f32 { return 0.5 - 0.5 * erf_approx(d / (max(s, 1e-3) * 1.41421)); }\\n// Bloom of a shape edge: a tight lobe that carries most of the light plus a wider one, both\\n// Gaussian so the light is gone by ~2.5 r (heavy tails read as a uniform haze over dark UI).\\n// Windowed to `reach` so the quad edge never shows. Continuous through d = 0 (inside saturates).\\nfn bloom(d: f32, r: f32, reach: f32) -> f32 {\\n    let o = max(d, 0.0);\\n    let w = 1.0 - smoothstep(reach * 0.5, reach, o);\\n    return (0.65 * gauss(o, r * 0.35) + 0.35 * gauss(o, r * 1.2)) * w;\\n}\\n// Soft knee for light energy: linear when dim, approaching 1 when bright, so a tinted glow\\n// keeps its hue instead of clipping toward white.\\nfn knee(x: f32) -> f32 { return 1.0 - exp(-max(x, 0.0)); }\\nfn gauss(x: f32, w: f32) -> f32 { return exp(-(x * x) / max(w * w, 1e-6)); }\\nfn lum(c: vec3f) -> f32 { return dot(c, vec3f(0.2126, 0.7152, 0.0722)); }\\n// A colour as its light cools: dims and deepens (saturates) instead of just fading.\\nfn cooled(c: vec3f, heat: f32) -> vec3f {\\n    let deep = c * c / max(max(c.r, max(c.g, c.b)), 0.02);\\n    return mix(deep * 0.55, c, smoothstep(0.0, 0.75, heat));\\n}\\nfn segdist(p: vec2f, a: vec2f, b: vec2f) -> vec2f {\\n    let ab = b - a;\\n    let h = clamp(dot(p - a, ab) / max(dot(ab, ab), 1e-6), 0.0, 1.0);\\n    return vec2f(length(p - a - ab * h), h);\\n}\\n\\n// Final write: clamp, optional TPDF dither (applied in sRGB space, only where there is signal).\\nfn finish(c0: vec4f, px: vec2f) -> vec4f {\\n    var c = max(c0, vec4f(0.0));\\n    c.a = min(c.a, 1.0);\\n    if (1.0 > 0.5) {\\n        let ip = vec2u(px);\\n        let n = (u01(ip.x + pcg(ip.y)) + u01(ip.x * 7919u + pcg(ip.y + 104729u))) - 1.0;\\n        let s = to_srgb(c.rgb);\\n        let gate = smoothstep(0.0, 3.0 / 255.0, max(s.r, max(s.g, s.b)));\\n        c = vec4f(to_lin(max(s + vec3f(n / 255.0 * gate), vec3f(0.0))), c.a);\\n    }\\n    return c;\\n}\\n\\nfn inst_at() -> Inst {\\n    var i: Inst;\\n    i.rect = frame.params[0]; i.shape = frame.params[1]; i.shape.y = frame.scale; i.bounds = vec4f(0.0);\\n    i.c0 = frame.params[2]; i.c1 = frame.params[3]; i.c2 = frame.params[4];\\n    i.p0 = frame.params[5]; i.p1 = frame.params[6]; i.p2 = frame.params[7]; i.p3 = frame.params[8];\\n    i.t = frame.params[9]; i.t.x = frame.time;\\n    i.aux = frame.params[10]; i.aux2 = frame.params[11]; i.xf = frame.params[12];\\n    return i;\\n}\\nfn frost_radius() -> f32 { return frame.params[13].x; }\\nfn shade(p: vec2f) -> vec4f {\\n    var v: VOut; v.id = 0u; v.px = p * frame.scale;\\n    let c = rune_shade(v) * frame.params[1].z;\\n    let cover = min(max(c.rgb, vec3f(0.0)), vec3f(c.a));\\n    let straight = select(vec3f(0.0), cover / c.a, c.a > 1e-6);\\n    return vec4f(to_srgb(straight) * c.a + to_srgb(max(c.rgb, vec3f(0.0)) - cover), c.a);\\n}\\n\";\nexport const GLOW =\n  COMMON +\n  \"// Glow / bloom. variant: 0 soft, 1 neon (hot core rim), 2 aura (spectrum around the border), 3 mask (texture).\\n// c0 tint, c1 hot core, c2 aura third colour\\n// p0 (radius, intensity, inner, occlusion)\\n// p1 (breathe_amp, breathe_period, heat, hot)\\n// p2 (aura_speed, rim_width, reach_mul, _)\\n\\nfn aura_palette(u: f32, a: vec3f, b: vec3f, c: vec3f) -> vec3f {\\n    // Three colours around a loop, smooth (cosine) blend.\\n    let x = fract(u) * 3.0;\\n    let w0 = smoothstep(1.0, 0.0, min(x, 3.0 - x));\\n    let w1 = smoothstep(1.0, 0.0, abs(x - 1.0));\\n    let w2 = smoothstep(1.0, 0.0, abs(x - 2.0));\\n    return (a * w0 + b * w1 + c * w2) / max(w0 + w1 + w2, 1e-4);\\n}\\n\\nfn mask_tent(uv: vec2f, lod: f32) -> f32 {\\n    // Bilinear taps at \\u00b10.5 texel of the chosen level: a tent upsample, no blocky mip seams.\\n    let dims = vec2f(textureDimensions(simulation_state, 0));\\n    let texel = exp2(lod) / dims;\\n    let o = texel * 0.5;\\n    var s = textureSampleLevel(simulation_state, backdrop_sampler, uv + vec2f(o.x, o.y), lod).a;\\n    s += textureSampleLevel(simulation_state, backdrop_sampler, uv + vec2f(-o.x, o.y), lod).a;\\n    s += textureSampleLevel(simulation_state, backdrop_sampler, uv + vec2f(o.x, -o.y), lod).a;\\n    s += textureSampleLevel(simulation_state, backdrop_sampler, uv + vec2f(-o.x, -o.y), lod).a;\\n    return s * 0.25;\\n}\\n\\nfn rune_shade(in: VOut) -> vec4f {\\n    let i = inst_at();\\n    let c = ctx(i, in.px);\\n    var radius = i.p0.x;\\n    var intensity = i.p0.y;\\n    let inner = i.p0.z;\\n    let occl = select(1.0, i.p0.w, effective_blend_mode(i) == 0u);\\n    let heat = i.p1.z;\\n    let hot = i.p1.w;\\n\\n    // Breathing: phase comes from the caller's continuous phase clock (t), so speed changes never jump.\\n    var b = 0.0;\\n    if (!c.reduced && i.p1.y > 0.0) {\\n        b = 0.5 - 0.5 * cos(TAU * c.t / i.p1.y);\\n        b = b * b * (3.0 - 2.0 * b);\\n    }\\n    let amp = i.p1.x;\\n    intensity *= (1.0 - amp) + amp * b;\\n    radius *= 1.0 + 0.22 * amp * b;\\n    // Cooling: shrink and deepen as the light loses heat.\\n    radius *= mix(0.72, 1.0, heat);\\n    intensity *= pow(heat, 1.6);\\n    let tint = cooled(i.c0.rgb, heat);\\n    let reach = radius * i.p2.z;\\n\\n    var light = vec3f(0.0);\\n    var alpha = 0.0;\\n    let edge = smoothstep(-c.aa, c.aa, c.d); // 0 inside, 1 outside\\n\\n    if (c.variant == 3) {\\n        // Mask glow from the mip pyramid in `simulation_state` (covers aux2 rect).\\n        let uv = (c.p - i.aux2.xy) / i.aux2.zw;\\n        let rpx = radius * c.scale;\\n        let base = log2(max(rpx, 1.0)) - 0.6;\\n        let m = 0.45 * mask_tent(uv, max(base - 1.0, 0.0)) + 0.35 * mask_tent(uv, max(base, 0.0))\\n              + 0.2 * mask_tent(uv, base + 1.3);\\n        let core = textureSampleLevel(simulation_state, backdrop_sampler, uv, 0.0).a;\\n        let g = knee(m * 1.25 * intensity) * 1.1;\\n        let hotc = core * hot * smoothstep(0.55, 1.0, heat);\\n        light = tint * g + i.c1.rgb * hotc * intensity * 0.6;\\n        alpha = min(g * occl, 1.0);\\n        return finish(vec4f(light, alpha), in.px);\\n    }\\n\\n    if (c.variant == 0) {\\n        let out_g = bloom(c.d, radius, reach);\\n        let in_g = inner * 0.7 * exp(min(c.d, 0.0) / (0.4 * radius));\\n        let gl = mix(in_g, out_g, edge);\\n        let corew = gauss(max(c.d, 0.0), 0.3 * radius) * hot * smoothstep(0.6, 1.0, heat);\\n        let col = mix(tint, i.c1.rgb, corew * 0.8);\\n        let e = knee(gl * intensity * 1.1);\\n        light = col * e;\\n        alpha = e * occl;\\n    } else if (c.variant == 1) {\\n        // Neon: a white-hot hairline core on the border, coloured bloom both sides.\\n        let w = max(i.p2.y, c.aa * 0.75);\\n        let core = gauss(c.d, w) ;\\n        let out_g = bloom(c.d, radius, reach) * edge;\\n        let in_g = inner * bloom(-c.d, radius * 0.6, reach) * (1.0 - edge);\\n        let corec = mix(tint, i.c1.rgb, 0.7 * hot * smoothstep(0.5, 1.0, heat));\\n        let e = knee((out_g + in_g) * intensity);\\n        light = corec * core * 1.4 * intensity + tint * e * 0.9;\\n        alpha = core * 0.6 * intensity + e * occl;\\n    } else {\\n        // Aura: spectrum flowing around the perimeter, inner rim light + outer bloom + hairline.\\n        let pr = rrect_perim(c.q, c.half, c.r);\\n        var u = pr.x / pr.y;\\n        var flow = 0.0;\\n        if (!c.reduced) { flow = c.t * i.p2.x; }\\n        let col = aura_palette(u - flow, tint, i.c1.rgb, i.c2.rgb);\\n        // Slow brightness variation along the loop (periodic noise), never below 70%.\\n        let wob = 0.85 + 0.15 * pgnoise(vec2f(u * 6.0, flow * 1.7 + 3.0), 6, c.seed);\\n        let out_g = bloom(c.d, radius, reach) * edge;\\n        let in_g = inner * exp(min(c.d, 0.0) / (0.55 * radius)) * (1.0 - edge);\\n        let hair = gauss(c.d + 0.6, max(i.p2.y, c.aa)) * 0.9;\\n        let lit = knee((out_g + in_g) * wob * intensity * 1.1);\\n        light = col * lit + mix(col, vec3f(1.0), 0.6) * hair * intensity * hot;\\n        alpha = lit * occl;\\n    }\\n    return finish(vec4f(light, alpha), in.px);\\n}\\n\";\nexport const PULSE =\n  COMMON +\n  \"// Pulses. variant: 0 radar rings, 1 breathing halo, 2 heartbeat, 3 ping (travels A -> along dir), 4 tap ripple.\\n// c0 colour, c1 hot/core colour\\n// p0 (count, period, reach, width)\\n// p1 (intensity, t0, duration, repeat)    t0/duration/repeat: one-shots (ping, ripple)\\n// p2 (travel, lag, head radius, occlusion)\\n// aux: origin xy, direction xy (ping) | origin xy (ripple)\\n\\n// Ease with anticipation for the ping: cubic B\\u00e9zier in value, P1 < 0 winds up against the travel,\\n// P2 = 1 lands with zero velocity (decelerates in, never stops dead).\\nfn shoot(u: f32) -> f32 {\\n    let x = clamp(u, 0.0, 1.0);\\n    let m = 1.0 - x;\\n    return 3.0 * m * m * x * (-0.12) + 3.0 * m * x * x * 1.0 + x * x * x;\\n}\\nfn beat_env(x: f32) -> f32 {\\n    // Fast attack, exponential release; continuous at the peak.\\n    return select(exp(-x / 0.085), exp(-(x / 0.018) * (x / 0.018)), x < 0.0);\\n}\\n\\n// One ping shot at `age` seconds: (energy, white-hot share).\\nfn ping(c: Ctx, i: Inst, age: f32, dur: f32) -> vec2f {\\n    let o = i.aux.xy;\\n    let dir = normalize(i.aux.zw);\\n    let travel = i.p2.x;\\n    let head_r = i.p2.z;\\n    if (age < 0.0) { return vec2f(0.0); }\\n    let u = age / dur;\\n    if (c.reduced) {\\n        // No travel: the destination glows up and cools in place.\\n        let dest = o + dir * travel;\\n        let env = smoothstep(0.0, 0.2, age) * exp(-max(age - 0.2, 0.0) * 3.0);\\n        return vec2f(env * gauss(length(c.p - dest), head_r * 3.0), 0.0);\\n    }\\n    let s_head = shoot(u);\\n    let s_tail = shoot(u - i.p2.y);\\n    let hpos = o + dir * travel * s_head;\\n    let tpos = o + dir * travel * s_tail;\\n    let sd = segdist(c.p, tpos, hpos);\\n    // After arrival the head blooms out and cools (continuous at u = 1).\\n    let after = max(u - 1.0, 0.0);\\n    let cool = exp(-after * 3.5);\\n    let hr = head_r * (1.0 + 0.9 * (1.0 - cool));\\n    let tailw = head_r * 0.55 * (0.35 + 0.65 * sd.y);\\n    let tail = gauss(sd.x, tailw) * sd.y * sd.y * 0.8;\\n    let dh = length(c.p - hpos);\\n    let head = gauss(dh, hr) + 0.35 * bloom(dh - hr * 0.5, hr * 1.2, hr * 8.0);\\n    var e = (head + tail) * cool;\\n    let hot = gauss(dh, hr * 0.45) * cool * cool;\\n    // Launch flash at the origin.\\n    let fr = 26.0 * (1.0 - exp(-age * 7.0));\\n    e += exp(-age * 10.0) * smoothstep(0.0, 0.03, age) * gauss(length(c.p - o) - fr, 2.0 + age * 6.0) * 0.5;\\n    return vec2f(e, hot);\\n}\\n\\nfn rune_shade(in: VOut) -> vec4f {\\n    let i = inst_at();\\n    let c = ctx(i, in.px);\\n    let n = i32(i.p0.x + 0.5);\\n    let period = max(i.p0.y, 0.05);\\n    let reach = i.p0.z;\\n    let width = i.p0.w;\\n    let inten = i.p1.x;\\n    let occl = select(1.0, i.p2.w, effective_blend_mode(i) == 0u);\\n    let outside = smoothstep(-c.aa, c.aa, c.d);\\n    var e = 0.0;     // emitted energy (tint)\\n    var hotv = 0.0;  // white-hot share\\n\\n    if (c.variant == 0) {\\n        if (c.reduced) {\\n            e = 0.35 * bloom(c.d, reach * 0.18, reach * 0.8);\\n        } else {\\n            for (var k = 0; k < n; k++) {\\n                let ph = fract(c.t / period + f32(k) / f32(n));\\n                let r = reach * (1.0 - pow(1.0 - ph, 2.2));\\n                let w = width * (1.0 + 2.2 * ph);\\n                let a = pow(1.0 - ph, 1.6) * smoothstep(0.0, 0.08, ph);\\n                let ring = gauss(c.d - r, w);\\n                // Faint wash trailing inside the ring front, like a radar sweep.\\n                let wash = smoothstep(r + w, r - w, c.d) * exp(-(r - c.d) / max(reach * 0.22, 1.0));\\n                e += a * (ring + 0.22 * wash);\\n            }\\n            e += 0.18 * bloom(c.d, reach * 0.1, reach * 0.6);\\n        }\\n        e *= outside;\\n    } else if (c.variant == 1) {\\n        var b = 0.5;\\n        if (!c.reduced) { b = 0.5 - 0.5 * cos(TAU * c.t / period); b = b * b * (3.0 - 2.0 * b); }\\n        let r = reach * (0.55 + 0.45 * b);\\n        e = (0.45 + 0.55 * b) * bloom(c.d, r, r * 5.0) * outside;\\n        hotv = 0.25 * b * gauss(max(c.d, 0.0), r * 0.25);\\n    } else if (c.variant == 2) {\\n        var beat = 0.3;\\n        var ring = 0.0;\\n        if (!c.reduced) {\\n            // Every beat is its own instance: the rings of earlier beats keep expanding and fading\\n            // under the new one instead of being cut when it starts.\\n            let tp = c.t / period;\\n            let kb = floor(tp);\\n            beat = 0.0;\\n            for (var k = -1; k < 3; k++) {\\n                let x = tp - (kb - f32(k));\\n                beat += beat_env(x) + 0.62 * beat_env(x - 0.17);\\n                let age = x * period; // seconds since that beat's lub\\n                if (age > 0.0) {\\n                    let rr = reach * (1.0 - exp(-age * 4.5));\\n                    // Finished rings fade out instead of piling up into a band at full reach.\\n                    ring += exp(-age * 3.2) * smoothstep(0.0, 0.03, age) * (1.0 - smoothstep(0.7, 1.3, age)) * gauss(c.d - rr, width * (1.0 + age * 3.0));\\n                }\\n            }\\n            // Fade the faint tail of old rings out before the quad edge.\\n            let edge = reach + width * 16.0;\\n            ring *= 1.0 - smoothstep(edge * 0.8, edge, c.d);\\n        }\\n        let r = reach * 0.22 * (1.0 + 0.35 * beat);\\n        e = ((0.25 + 0.75 * beat) * bloom(c.d, r, reach) + 0.55 * ring) * outside;\\n        hotv = 0.35 * beat * gauss(max(c.d, 0.0), r * 0.25) * outside;\\n    } else if (c.variant == 3) {\\n        let dur = max(i.p1.z, 0.05);\\n        let age0 = c.t - i.p1.y;\\n        // A repeating ping lets the previous shot finish blooming while the next one flies.\\n        var shots = 1;\\n        var age = age0;\\n        if (i.p1.w > 0.0 && age0 > 0.0) {\\n            age = age0 - floor(age0 / i.p1.w) * i.p1.w;\\n            shots = 3;\\n        }\\n        for (var k = 0; k < shots; k++) {\\n            let a = age + f32(k) * i.p1.w;\\n            // PING_LIFE in pack.rs: the frame loop ticks until the last shot ends here.\\n            if (a > age0 + 1e-4 || a > dur * 2.2) { break; }\\n            let pe = ping(c, i, a, dur);\\n            e += pe.x;\\n            hotv += pe.y;\\n        }\\n    } else {\\n        // Ripple from a tap point, confined to the shape with a soft edge.\\n        let dur = max(i.p1.z, 0.05);\\n        let age = c.t - i.p1.y;\\n        if (age >= 0.0 && age < dur) {\\n            let u = age / dur;\\n            let r = length(c.p - i.aux.xy);\\n            let inside = smoothstep(c.aa, -c.aa, c.d);\\n            if (c.reduced) {\\n                e = 0.06 * (1.0 - u) * smoothstep(0.0, 0.08, u) * inside;\\n            } else {\\n                let rr = reach * (1.0 - pow(1.0 - u, 3.0));\\n                let w = width * (1.0 + 3.0 * u);\\n                let fade = pow(1.0 - u, 1.5);\\n                let ring = gauss(r - rr, w) * fade * 0.55;\\n                let fill = smoothstep(rr + w, rr - w * 3.0, r) * 0.05 * (1.0 - u) * (1.0 - u) * smoothstep(0.0, 0.05, u);\\n                e = (ring * 0.7 + fill) * inside;\\n                hotv = ring * 0.1 * inside;\\n            }\\n        }\\n    }\\n    let col = i.c0.rgb * e + i.c1.rgb * hotv;\\n    return finish(vec4f(col * inten, (e + hotv) * occl * inten), in.px);\\n}\\n\";\nexport const ELECTRIC =\n  COMMON +\n  \"// Electricity. variant: 0 arc A -> B, 1 around the border, 2 charged border (calm UI variant).\\n// Bolt paths, crawl and forks are CPU tables (cpu.rs::electric); the shader only measures distance\\n// to them and lights it. xf = (first, N samples, forks, strands).\\n// c0 glow tint, c1 hot core, c2 cooled fork colour\\n// p0 (amplitude pt, frequency cells/100pt, speed, core width pt)\\n// p1 (intensity, glow radius pt, fork rate 0..1, flicker 0..1)\\n// p2 (strands, gap pt (border offset), fork length pt, occlusion)\\n// aux: A xy, B xy (arc)\\n\\nstruct Bolt { core: f32, halo: f32 }\\n\\nfn shade_bolt(dist: f32, w: f32, gr: f32) -> Bolt {\\n    var b: Bolt;\\n    b.core = gauss(dist, w);\\n    let o = dist / gr;\\n    // A narrow coloured sheath plus a faint 1/(1+d^2) tail: the air right around the channel glows,\\n    // not a wide haze.\\n    b.halo = 0.35 / (1.0 + o * o) * (1.0 - smoothstep(gr * 2.5, gr * 5.0, dist)) + 0.65 * gauss(dist, gr * 0.6);\\n    return b;\\n}\\n// Lateral distance to a sampled path, slope-corrected but capped so steep jags never smear\\n// into streaks.\\nfn lat(dv: f32, a: f32, b: f32, step: f32) -> f32 {\\n    let s = (b - a) / step;\\n    // Near field: perpendicular distance to the local segment. Far field: the plain lateral offset\\n    // (already a good distance there), so the halo never streaks along steep jags.\\n    let k = inverseSqrt(1.0 + min(s * s, 3.0));\\n    return dv * mix(k, 1.0, smoothstep(1.5, 8.0, abs(dv)));\\n}\\nfn fork_col(i: Inst, heat: f32) -> vec3f {\\n    return mix(mix(i.c2.rgb, i.c0.rgb, smoothstep(0.0, 0.5, heat)), i.c1.rgb, smoothstep(0.6, 1.0, heat));\\n}\\n\\nfn rune_shade(in: VOut) -> vec4f {\\n    let i = inst_at();\\n    let c = ctx(i, in.px);\\n    let w = max(i.p0.w, c.aa * 0.7);\\n    let inten = i.p1.x;\\n    let gr = max(i.p1.y, 1e-3);\\n    let gap = i.p2.y;\\n    let first = u32(i.xf.x);\\n    let n = u32(i.xf.y);\\n    let nf = u32(i.xf.z);\\n    let ns = u32(i.xf.w);\\n    let q4 = n >> 2u;\\n    let fl = shader_data_at(first + 1u);\\n    let base = first + 2u;\\n\\n    var core = 0.0;\\n    var halo = 0.0;\\n    var fork_hot = vec3f(0.0);\\n\\n    if (c.variant == 0) {\\n        let a = i.aux.xy;\\n        let bb = i.aux.zw;\\n        let L = max(length(bb - a), 1.0);\\n        let dir = (bb - a) / L;\\n        let nrm = vec2f(-dir.y, dir.x);\\n        let rel = c.p - a;\\n        let u = dot(rel, dir) / L;\\n        let v = dot(rel, nrm);\\n        let uc = clamp(u, 0.0, 1.0);\\n        let fi = uc * f32(n - 1u);\\n        let i0 = min(u32(fi), n - 2u);\\n        let f = fi - f32(i0);\\n        let step = L / f32(n - 1u);\\n        for (var k = 0u; k < ns; k++) {\\n            let sb = base + k * q4;\\n            let d0 = dat1(sb, i0);\\n            let d1 = dat1(sb, i0 + 1u);\\n            let dd = length(vec2f((u - uc) * L, lat(v - mix(d0, d1, f), d0, d1, step)));\\n            let hb = base + (ns + k) * q4;\\n            let dh = length(vec2f((u - uc) * L, v - mix(dat1(hb, i0), dat1(hb, i0 + 1u), f)));\\n            let bw = select(w * 0.6, w, k == 0u);\\n            var bo = shade_bolt(dd, bw, gr);\\n            bo.halo = 0.4 * shade_bolt(dh, bw, gr).halo + 0.6 * shade_bolt(dd, bw, gr * 0.3).halo;\\n            let kb = select(0.32, 1.0, k == 0u) * fl[k];\\n            core += bo.core * kb;\\n            halo += bo.halo * kb;\\n        }\\n        // Electrode hot spots.\\n        halo += 0.6 * (gauss(length(c.p - a), gr * 0.8) + gauss(length(c.p - bb), gr * 0.8));\\n        core += 0.5 * (gauss(length(c.p - a), w * 2.5) + gauss(length(c.p - bb), w * 2.5));\\n        var fb = base + 2u * ns * q4;\\n        for (var j = 0u; j < nf; j++) {\\n            let h0 = shader_data_at(fb);\\n            let h1 = shader_data_at(fb + 1u);\\n            let o = h0.xy;\\n            let fd = h0.zw;\\n            let len = h1.x;\\n            let fr = c.p - o;\\n            let fu = dot(fr, fd) / len;\\n            let fv = dot(fr, vec2f(-fd.y, fd.x));\\n            let fuc = clamp(fu, 0.0, h1.y);\\n            let ffi = fuc * 15.0;\\n            let j0 = min(u32(ffi), 14u);\\n            let s0 = dat1(fb + 2u, j0);\\n            let s1 = dat1(fb + 2u, j0 + 1u);\\n            let fdist = length(vec2f((fu - fuc) * len, lat(fv - mix(s0, s1, ffi - f32(j0)), s0, s1, len / 15.0)));\\n            let taper = 1.0 - 0.7 * fuc;\\n            let bo = shade_bolt(fdist, w * 0.6 * taper, gr * 0.55);\\n            fork_hot += fork_col(i, h1.w) * (bo.core * 1.1 + bo.halo * 0.45) * h1.z * taper;\\n            fb += 6u;\\n        }\\n    } else {\\n        let pr = rrect_perim(c.q, c.half, c.r);\\n        let s = pr.x;\\n        let total = pr.y;\\n        let calm = c.variant == 2;\\n        let fi = s / total * f32(n);\\n        let i0 = u32(floor(fi)) % n;\\n        let i1 = (i0 + 1u) % n;\\n        let f = fi - floor(fi);\\n        let step = total / f32(n);\\n        for (var k = 0u; k < ns; k++) {\\n            let sb = base + k * q4;\\n            let d0 = dat1(sb, i0);\\n            let d1 = dat1(sb, i1);\\n            let dd = abs(lat(c.d - gap - mix(d0, d1, f), d0, d1, step));\\n            let hb = base + (ns + k) * q4;\\n            let dh = abs(c.d - gap - mix(dat1(hb, i0), dat1(hb, i1), f));\\n            let cb = base + (2u * ns + k) * q4;\\n            let crawl = mix(dat1(cb, i0), dat1(cb, i1), f);\\n            let bw = select(w * 0.6, w, k == 0u);\\n            var bo = shade_bolt(dd, bw, gr);\\n            bo.halo = 0.4 * shade_bolt(dh, bw, gr).halo + 0.6 * shade_bolt(dd, bw, gr * 0.3).halo;\\n            let kb = select(0.32, 1.0, k == 0u) * fl[k] * crawl;\\n            core += bo.core * kb;\\n            halo += bo.halo * kb;\\n        }\\n        if (calm) {\\n            // Beads of charge travelling one way around the border.\\n            let sp = i.p0.z * 0.35;\\n            let bu = fract(s / total - c.t * 0.07 * sp);\\n            for (var k = 0; k < 3; k++) {\\n                let x = fract(bu - f32(k) / 3.0 + 0.5) - 0.5;\\n                let bead = gauss(x * total, 18.0);\\n                halo += bead * gauss(c.d - gap, gr * 0.8) * 0.9;\\n                core += bead * gauss(c.d - gap, w * 1.5) * 0.6;\\n            }\\n        }\\n        var fb = base + 3u * ns * q4;\\n        for (var j = 0u; j < nf; j++) {\\n            let h0 = shader_data_at(fb);\\n            let h1 = shader_data_at(fb + 1u);\\n            let len = h1.x;\\n            var dsv = s - h0.x;\\n            dsv -= total * round(dsv / total);\\n            let fu = (c.d - gap - h0.z) / len;\\n            let fuc = clamp(fu, 0.0, h1.y);\\n            let ffi = fuc * 15.0;\\n            let j0 = min(u32(ffi), 14u);\\n            let s0 = dat1(fb + 2u, j0);\\n            let s1 = dat1(fb + 2u, j0 + 1u);\\n            let fdist = length(vec2f((fu - fuc) * len, lat(dsv - mix(s0, s1, ffi - f32(j0)), s0, s1, len / 15.0)));\\n            let taper = 1.0 - 0.7 * fuc;\\n            let bo = shade_bolt(fdist, w * 0.6 * taper, gr * 0.55);\\n            fork_hot += fork_col(i, h1.w) * (bo.core * 1.1 + bo.halo * 0.45) * h1.z * taper;\\n            fb += 6u;\\n        }\\n    }\\n    let occl = select(1.0, i.p2.w, effective_blend_mode(i) == 0u);\\n    let rgb = (i.c1.rgb * core * 1.3 + i.c0.rgb * halo * 0.75 + fork_hot) * inten;\\n    let a = (core * 0.7 + halo * occl + lum(fork_hot) * 0.5) * inten;\\n    return finish(vec4f(rgb, a), in.px);\\n}\\n\";\nexport const EXTRAS =\n  COMMON +\n  \"// Extras. variant: 0 shimmer/sheen sweep, 1 sparkles, 2 aurora, 3 grain.\\n// shimmer: c0 sheen, c1 base (a = 0: none)  p0 (period, band pt, angle rad, intensity)  p1 (use mask, pause, feather, _)\\n// sparkle: c0 colour  p0 (count, life s, size pt, intensity)  p1 (margin pt, _, _, _)\\n// aurora:  c0 c1 c2 curtains  p0 (scale pt, speed, intensity, feather pt)\\n// grain:   p0 (amount, fps (0 = static), feather, _)\\n\\n// Inner feather: fully inside the shape, so overlays never leak past the node's edge.\\nfn cover(c: Ctx, feather: f32) -> f32 { return smoothstep(c.aa * 0.5, -max(feather, c.aa), c.d); }\\n\\nfn rune_shade(in: VOut) -> vec4f {\\n    let i = inst_at();\\n    let c = ctx(i, in.px);\\n\\n    if (c.variant == 0) {\\n        var m: f32;\\n        if (i.p1.x > 0.5) {\\n            m = textureSampleLevel(simulation_state, backdrop_sampler, (c.p - i.aux2.xy) / i.aux2.zw, 0.0).a;\\n        } else {\\n            m = cover(c, max(i.p1.z, c.aa * 1.5));\\n        }\\n        if (m <= 0.0) { return vec4f(0.0); }\\n        let ta = tan(i.p0.z);\\n        let span = c.half.x + c.half.y * abs(ta) + i.p0.y * 2.5;\\n        let x = c.q.x + c.q.y * ta;\\n        var sheen: f32;\\n        if (c.reduced) {\\n            // Calm: the whole surface breathes slightly instead of a travelling band.\\n            sheen = 0.35 * (0.5 - 0.5 * cos(TAU * c.t / max(i.p0.x, 0.1)));\\n        } else {\\n            let ph = fract(c.t / max(i.p0.x, 0.1));\\n            let travel = clamp(ph / max(1.0 - i.p1.y, 0.05), 0.0, 1.0);\\n            let e = travel * travel * (3.0 - 2.0 * travel);\\n            let xc = mix(-span, span, e);\\n            sheen = gauss(x - xc, i.p0.y) + 0.35 * gauss(x - xc, i.p0.y * 2.6);\\n        }\\n        let base = i.c1.rgb * i.c1.a;\\n        return finish(vec4f(base * m + i.c0.rgb * sheen * i.p0.w * m, i.c1.a * m + sheen * i.p0.w * m * 0.2), in.px);\\n    }\\n    if (c.variant == 1) {\\n        let f0 = u32(i.xf.x);\\n        let n = u32(i.xf.y);\\n        var body = 0.0;\\n        var hot = 0.0;\\n        var halo = 0.0;\\n        for (var k = 0u; k < n; k++) {\\n            let a = shader_data_at(f0 + k * 2u);\\n            let b = shader_data_at(f0 + k * 2u + 1u);\\n            let S = max(a.z, 0.01);\\n            let env = a.w;\\n            let rel = c.p - a.xy;\\n            let r = length(rel);\\n            if (r > S * 1.6) { continue; }\\n            let l = vec2f(b.x * rel.x - b.y * rel.y, b.y * rel.x + b.x * rel.y);\\n            // Four-point star: |x|^p + |y|^p = 1 with p < 1 gives concave sides and needle tips.\\n            // g is homogeneous of degree 1, so (g - 1) * S is roughly a distance in points.\\n            let ax = max(abs(l) / S, vec2f(1e-6));\\n            let g = pow(pow(ax.x, 0.55) + pow(ax.y, 0.55), 1.0 / 0.55);\\n            let w = c.aa * 0.75 / S;\\n            let m = 1.0 - smoothstep(1.0 - w, 1.0 + w, g);\\n            body += env * m;\\n            hot += env * m * (1.0 - g) * (1.0 - g);\\n            halo += env * gauss(r, S * 0.32);\\n        }\\n        let tint = i.c0.rgb;\\n        let col = mix(tint, vec3f(1.0), 0.3) * body + vec3f(1.0) * hot * 0.8 + tint * halo * 0.12;\\n        return finish(vec4f(col * i.p0.w, min(body * 0.9 + halo * 0.05, 1.0) * i.p0.w), in.px);\\n    }\\n    if (c.variant == 2) {\\n        let m = cover(c, max(i.p0.w, c.aa));\\n        if (m <= 0.0) { return vec4f(0.0); }\\n        let sc = max(i.p0.x, 1.0);\\n        let q = c.p / sc;\\n        var t = c.t * i.p0.y;\\n        if (c.reduced) { t = 0.0; }\\n        let uy = (c.p.y - i.rect.y) / i.rect.w;\\n        var col = vec3f(0.0);\\n        let cols = array<vec3f, 3>(i.c0.rgb, i.c1.rgb, i.c2.rgb);\\n        // Curtain heights and warps across the width are CPU tables (cpu.rs::aurora).\\n        let f0 = u32(i.xf.x);\\n        let ns = u32(i.xf.y);\\n        let fx = clamp((c.p.x - i.rect.x) / i.rect.z, 0.0, 1.0) * f32(ns - 1u);\\n        let x0 = min(u32(fx), ns - 2u);\\n        let fr = fx - f32(x0);\\n        for (var k = 0; k < 3; k++) {\\n            let fk = f32(k);\\n            let yb = f0 + u32(k) * 2u * (ns >> 2u);\\n            let wb = yb + (ns >> 2u);\\n            let wv = mix(dat1(wb, x0), dat1(wb, x0 + 1u), fr);\\n            let yk = mix(dat1(yb, x0), dat1(yb, x0 + 1u), fr);\\n            let band = gauss(uy - yk, 0.13 + 0.05 * fk);\\n            let rays = 0.65 + 0.35 * gnoise(vec2f(q.x * 5.0 + wv * 3.0, t * 0.5 + fk), c.seed + 9u);\\n            // Curtains have a bright lower hem and fade upward.\\n            let hem = smoothstep(yk + 0.16, yk - 0.02, uy) * 0.5 + 0.5;\\n            col += cols[k] * band * rays * hem;\\n        }\\n        let a = select(min(max(col.r, max(col.g, col.b)), 1.0), lum(col) * 0.4, effective_blend_mode(i) == 0u);\\n        return finish(vec4f(col * i.p0.z * m, a * i.p0.z * m), in.px);\\n    }\\n    // Grain.\\n    let m = cover(c, max(i.p0.z, c.aa));\\n    if (m <= 0.0) { return vec4f(0.0); }\\n    var frame = 0u;\\n    if (i.p0.y > 0.0 && !c.reduced) { frame = u32(floor(c.t * i.p0.y)); }\\n    let ip = vec2u(in.px);\\n    let n = u01(ip.x + pcg(ip.y + pcg(frame + c.seed))) + u01(ip.y * 7919u + pcg(ip.x + 17u + frame)) - 1.0;\\n    let a = i.p0.x * m;\\n    if (n >= 0.0) { return vec4f(vec3f(n * a), n * a); }\\n    return vec4f(0.0, 0.0, 0.0, -n * a);\\n}\\n\";\nexport const DISTORT =\n  COMMON +\n  \"// Distortion of the backdrop (needs `backdrop` = target content right before this layer).\\n// variant: 0 heat haze, 1 shockwave, 2 liquid-glass lens, 3 CRT, 4 chromatic split.\\n//\\n// heat:   p0 (height pt, scale pt, speed, amount pt)  p1 (full rect 0/1, _, _, _)\\n// shock:  p0 (reach pt, width pt, amount pt, chroma)  p1 (t0, duration, _, _)  aux: origin\\n// lens:   p0 (bevel pt, depth pt, dispersion, magnification)  p1 (presence, frost, shadow, rim)\\n//         p2 (light angle rad, tint, union k pt, radius B)  p3 rect B (w = 0: none)  shape.w morph A->B\\n//         c0 tint\\n// crt:    p0 (bulge, scanline period pt, scanline depth, chroma pt)  p1 (vignette, glow, roll, feather)\\n// split:  p0 (offset x pt, offset y pt, glitch, feather)\\n\\n// Frosted material, after Apple's \\\"regular\\\" glass: a saturation boost puts back the colour that\\n// blur and scrim take out, and a compressive transfer lifts dark backdrops while light ones\\n// barely move (macOS 26 Control Center measures sRGB L' = 0.58 L + 0.134; iOS keeps more of\\n// the colour, so this sits a little above that). k = 0..1.\\nfn frosted(c: vec3f, k: f32) -> vec3f {\\n    let l = lum(c);\\n    let sat = max(mix(vec3f(l), c, 1.0 + 0.9 * k), vec3f(0.0));\\n    let e = to_srgb(sat);\\n    return to_lin(e * (1.0 - 0.32 * k) + vec3f(0.11 * k));\\n}\\n\\nfn lens_sd(c: Ctx, i: Inst, q: vec2f) -> f32 {\\n    let da = sd_rrect(q, c.half, c.r);\\n    if (i.p3.z <= 0.0) { return da; }\\n    let cb = i.p3.xy + i.p3.zw * 0.5 - c.c;\\n    let db = sd_rrect(q - cb, i.p3.zw * 0.5, i.p2.w);\\n    return mix(smin(da, db, i.p2.z), db, i.shape.w);\\n}\\n\\n// Thin-surface optics (psychopomp math/optics.rs): sideways travel per unit depth through a surface\\n// whose tilt rises from vertical at the rim to flat (superellipse bevel, power 3).\\nfn bend_at(t: f32) -> f32 {\\n    let u = clamp(1.0 - t, 0.0, 0.9999);\\n    let pw = 3.0;\\n    let slope = pow(u, pw - 1.0) * pow(max(1.0 - pow(u, pw), 1e-6), 1.0 / pw - 1.0);\\n    let tilt = atan(min(slope, 1e4));\\n    let bent = asin(sin(tilt) / 1.5);\\n    return tan(tilt - bent);\\n}\\n\\nfn rune_shade(in: VOut) -> vec4f {\\n    let i = inst_at();\\n    let c = ctx(i, in.px);\\n    let s = c.scale;\\n\\n    if (c.variant == 0) {\\n        let H = i.p0.x;\\n        var m: f32;\\n        if (i.p1.x > 0.5) {\\n            m = smoothstep(c.aa, -c.aa * 8.0, c.d);\\n        } else {\\n            let above = i.rect.y - c.p.y;\\n            let side = smoothstep(c.half.x + 2.0, c.half.x - c.r - 4.0, abs(c.q.x));\\n            // Starts just clear of the edge so the shape itself never wobbles, and is strongest a\\n            // little up the column where the hot air has risen off the flame tips.\\n            m = smoothstep(1.0, 1.0 + H * 0.3, above) * (1.0 - smoothstep(H * 0.45, H, above)) * side;\\n        }\\n        if (m <= 0.0) { return vec4f(0.0); }\\n        var t = c.t;\\n        if (c.reduced) { t = 0.0; }\\n        let q = c.p / max(i.p0.y, 1.0) + vec2f(0.0, t * i.p0.z);\\n        let o = vec2f(fbm3(q, c.seed), fbm3(q * vec2f(1.0, 0.7) + vec2f(7.3, 2.1), c.seed + 5u)) * i.p0.w;\\n        let col = bd(c.p + o * m, s);\\n        return vec4f(col.rgb, 1.0) * smoothstep(0.0, 0.02, m);\\n    }\\n    if (c.variant == 1) {\\n        let age = c.t - i.p1.x;\\n        let dur = max(i.p1.y, 0.05);\\n        if (age < 0.0 || age > dur) { return vec4f(0.0); }\\n        let u = age / dur;\\n        let rel = c.p - i.aux.xy;\\n        let r = length(rel);\\n        let dir = rel / max(r, 1e-3);\\n        let fade = (1.0 - u) * (1.0 - u);\\n        if (c.reduced) {\\n            // No travel: a soft brightening at the origin that cools.\\n            let gl = gauss(r, i.p0.x * 0.25) * 0.12 * fade * smoothstep(0.0, 0.1, u);\\n            return vec4f(bd(c.p, s).rgb * gl, 0.0);\\n        }\\n        let R = i.p0.x * (1.0 - pow(1.0 - u, 2.6));\\n        let w = i.p0.y * (1.0 + 1.5 * u);\\n        let x = (r - R) / w;\\n        let f = x * exp(-x * x) * 2.33;\\n        let off = -dir * f * i.p0.z * fade;\\n        let ca = i.p0.w * abs(f) * fade;\\n        let rr = bd(c.p + off * (1.0 + ca), s).r;\\n        let gg = bd(c.p + off, s).g;\\n        let bb = bd(c.p + off * (1.0 - ca), s).b;\\n        // Highlight only where there is content to catch it (no grey donut over empty space).\\n        let lit = max(-f, 0.0) * 0.12 * fade * lum(vec3f(rr, gg, bb));\\n        let m = smoothstep(0.0, 0.01, abs(f) * fade);\\n        return vec4f(vec3f(rr, gg, bb) + lit, 1.0) * m;\\n    }\\n    if (c.variant == 2) {\\n        let d = lens_sd(c, i, c.q);\\n        let presence = i.p1.x;\\n        let e = 0.5;\\n        let gx = lens_sd(c, i, c.q + vec2f(e, 0.0)) - lens_sd(c, i, c.q - vec2f(e, 0.0));\\n        let gy = lens_sd(c, i, c.q + vec2f(0.0, e)) - lens_sd(c, i, c.q - vec2f(0.0, e));\\n        let nrm = vec2f(gx, gy) / max(length(vec2f(gx, gy)), 1e-5);\\n        let coverage = clamp(0.5 - d * s, 0.0, 1.0);\\n        // Drop shadow + contact (outside), scaled by presence: glass materialises by lensing.\\n        let sd = lens_sd(c, i, c.q - vec2f(0.0, 5.0 * presence));\\n        let fall = exp(-pow(max(sd + 2.0, 0.0), 2.0) / (2.0 * 9.0 * 9.0));\\n        let contact = exp(-pow(max(d, 0.0), 2.0) / 6.0);\\n        let dark = min(i.p1.z * presence * (0.55 * fall + 0.45 * contact), 1.0) * (1.0 - coverage);\\n        if (coverage <= 0.0) {\\n            return vec4f(0.0, 0.0, 0.0, dark);\\n        }\\n        let depth = -d;\\n        let bevel = max(i.p0.x, 0.5);\\n        let tt = clamp(depth / bevel, 0.0, 1.0);\\n        let bend = i.p0.y * bend_at(tt) * presence;\\n        let mag = mix(1.0, i.p0.w, presence);\\n        let ctr = c.c;\\n        let inward = -nrm;\\n        let dsp = i.p0.z;\\n        let local = c.p - ctr;\\n        let srcg = ctr + (local + inward * bend) / mag;\\n        let srcr = ctr + (local + inward * bend * (1.0 - dsp)) / mag;\\n        let srcb = ctr + (local + inward * bend * (1.0 + dsp)) / mag;\\n        var col = vec3f(bd(srcr, s).r, bd(srcg, s).g, bd(srcb, s).b);\\n        let frost = i.p1.y;\\n        if (frost > 0.0 && i.xf.x > 0.5) {\\n            // Frosted: the dual-filter pyramid, refracted like the clear image (so the rim still\\n            // bends and splits), then the material transfer and a static grain against banding.\\n            let blr = vec3f(bdb(srcr, s).r, bdb(srcg, s).g, bdb(srcb, s).b);\\n            col = mix(col, blr, i.xf.y);\\n            let k = presence * smoothstep(0.0, 0.6, frost);\\n            col = frosted(col, k);\\n            let ip = vec2u(in.px);\\n            let n = u01(ip.x + pcg(ip.y + 7u)) - u01(ip.x * 7919u + pcg(ip.y + 31u));\\n            col = to_lin(max(to_srgb(col) + vec3f(n * 1.6 / 255.0 * k), vec3f(0.0)));\\n        } else {\\n            // Rim softening where the page is squeezed into a thin band (+ a small fallback frost\\n            // when no pyramid was built).\\n            let rim = bend / max(1.118 * i.p0.y, 1e-3);\\n            let soften = min(pow(rim, 1.5) * 0.55, 1.0);\\n            if (soften > 1e-3 || frost > 0.0) {\\n                let rad = mix(1.2, 10.0, frost);\\n                let j = ign(in.px) * TAU;\\n                var acc = vec3f(0.0);\\n                for (var k = 0; k < 8; k++) {\\n                    let a = j + f32(k) * 2.39996;\\n                    let rr = rad * sqrt((f32(k) + 0.5) / 8.0);\\n                    acc += bd(srcg + vec2f(cos(a), sin(a)) * rr, s).rgb;\\n                }\\n                acc /= 8.0;\\n                col = mix(col, acc, clamp(max(soften, frost), 0.0, 1.0));\\n            }\\n        }\\n        col = mix(col, col * i.c0.rgb, i.p2.y * presence);\\n        // Light: sky sheen, crisp specular where the rim faces the light, a fainter counter-line, hairline.\\n        let la = i.p2.x;\\n        let L = vec2f(cos(la), sin(la));\\n        let facing = max(dot(nrm, L), 0.0);\\n        let away = max(-dot(nrm, L), 0.0);\\n        let sky = clamp(0.5 - 0.5 * c.q.y / c.half.y, 0.0, 1.0);\\n        let rimk = i.p1.w;\\n        let fres = pow(1.0 - tt, 3.0) * 0.05 * (0.25 + 0.75 * sky);\\n        let line = gauss(depth - 0.75, 0.55);\\n        let glow = gauss(depth - 1.4, 2.4);\\n        let spec = line * (0.9 * pow(facing, 2.5) + 0.35 * pow(away, 3.0)) + glow * 0.1 * pow(facing, 4.0);\\n        let inner = gauss(tt - 0.32, 0.18) * away * away * 0.06;\\n        let edge = gauss(depth - 0.3, 0.45) * 0.12;\\n        let light = (0.004 + fres + spec + inner + edge) * presence * rimk;\\n        col = col * (1.0 - 0.04 * presence) + vec3f(light);\\n        // Coverage blends glass over the untouched backdrop + shadow.\\n        let base = bd(c.p, s).rgb * (1.0 - dark);\\n        return vec4f(mix(base, col, coverage), 1.0);\\n    }\\n    if (c.variant == 3) {\\n        let feather = max(i.p1.w, c.aa);\\n        let m = smoothstep(feather * 0.5, -feather * 0.5, c.d);\\n        if (m <= 0.0) { return vec4f(0.0); }\\n        let uv = c.q / c.half;\\n        let k = i.p0.x;\\n        let bu = uv * (1.0 + k * dot(uv, uv)) / (1.0 + k);\\n        let inside = smoothstep(1.0, 0.985, max(abs(bu.x), abs(bu.y)));\\n        let src = c.c + bu * c.half;\\n        let ca = i.p0.w;\\n        var col = vec3f(bd(src + vec2f(ca, 0.0), s).r, bd(src, s).g, bd(src - vec2f(ca, 0.0), s).b);\\n        // Glow: cheap 4-tap bloom of the simulation_state.\\n        let gw = 3.0;\\n        let gl = (bd(src + vec2f(gw, 0.0), s).rgb + bd(src - vec2f(gw, 0.0), s).rgb + bd(src + vec2f(0.0, gw), s).rgb + bd(src - vec2f(0.0, gw), s).rgb) * 0.25;\\n        col += gl * i.p1.y;\\n        let per = max(i.p0.y, 3.0 * c.aa);\\n        let sl = 0.5 + 0.5 * cos(TAU * (c.p.y - i.rect.y) / per);\\n        col *= 1.0 - i.p0.z * (1.0 - sl);\\n        // Aperture grille, very subtle.\\n        let col3 = u32(floor(in.px.x)) % 3u;\\n        let grille = select(select(vec3f(0.94, 0.94, 1.0), vec3f(0.94, 1.0, 0.94), col3 == 1u), vec3f(1.0, 0.94, 0.94), col3 == 0u);\\n        col *= grille;\\n        var roll = 0.0;\\n        if (!c.reduced) { roll = gauss(fract((c.p.y - i.rect.y) / i.rect.w - c.t * 0.12) - 0.5, 0.06) * i.p1.z; }\\n        col += vec3f(roll) * 0.06;\\n        col *= 1.0 - i.p1.x * pow(dot(uv, uv) * 0.5, 1.5);\\n        col *= inside;\\n        return vec4f(col, 1.0) * m;\\n    }\\n    // Chromatic split with optional glitch slices.\\n    let feather = max(i.p0.w, c.aa);\\n    let m = smoothstep(feather * 0.5, -feather * 0.5, c.d);\\n    if (m <= 0.0) { return vec4f(0.0); }\\n    var o = i.p0.xy;\\n    var gx = 0.0;\\n    if (i.p0.z > 0.0 && !c.reduced) {\\n        let slice = floor((c.p.y - i.rect.y) / 6.0);\\n        let fr = floor(c.t * 12.0);\\n        let hsl = hu(c.seed + bitcast<u32>(i32(slice)), bitcast<u32>(i32(fr)));\\n        if (u01(hsl) < 0.12 * i.p0.z) { gx = (u01(hsl + 1u) - 0.5) * 16.0 * i.p0.z; }\\n    }\\n    let p = c.p + vec2f(gx, 0.0);\\n    let col = vec3f(bd(p + o, s).r, bd(p, s).g, bd(p - o, s).b);\\n    return vec4f(col, 1.0) * m;\\n}\\n\";\nexport const FILL =\n  COMMON +\n  \"// Fills: styles that paint the node's shape, or a band inside its edge (aux.x = border pt, 0 = whole\\n// shape). aux.y = intensity. Colour lists live in the CPU table: for stop k, shader_data_at(xf.x + 2k) is\\n// linear rgb (w: mesh point x), shader_data_at(xf.x + 2k + 1) is OKLab (w: mesh point y); xf.y stops.\\n// variant:\\n// 0 liquid metal  c0 tint  c1 light  p0 (flow, scale pt, speed, bevel pt)  p1 (dome, angle, iridescence, contrast)\\n//                 p2 (anchor: 0 window, 1 shape, _, _, _)\\n// 1 mesh          p0 (drift, speed, sharpness, warp)  (points are animated on the CPU)\\n// 2 dither        p0 (pattern, input, pixel pt, ramp angle)  p1 (noise scale pt, speed, bias, contrast)\\n//                 xf.zw blue-noise tile (offset, side)\\n// 3 grain grad.   p0 (kind, angle, centre x, centre y)  p1 (amount, size pt, mono, fps)\\n// 4 fluted glass  c0 tint  p0 (rib pt, angle, refraction pt, frost)  p1 (dispersion, highlight, tint amount, _)\\n//                 xf.xy frost pyramid (set by FxRenderer::blur_backdrop)\\n// 5 metaballs     c0 base  p0 (count, size, speed, gloss)  xf.z balls: (x pt, y pt, r pt, stop)\\n// 6 swirl         p0 (scale pt, speed, twist, warp)\\n// 7 voronoi       c0 seam  p0 (cell pt, speed, seam pt, depth)\\n// 8 waves         p0 (amplitude, frequency, speed, angle)  p1 (softness, _, _, _)\\n// 9 halftone      c0 ink  c1 base  p0 (_, input, pitch pt, ramp angle)  p1 as dither  p2 (screen angle, _, _, _)\\n// 10 plastic      c0 colour  p0 (roughness, dome, bevel pt, light angle)\\n\\n// Shape coverage: the whole shape, or (border > 0) a band of that width inside the edge.\\nfn fill_mask(c: Ctx, border: f32) -> f32 {\\n    let inside = clamp(0.5 - c.d * c.scale, 0.0, 1.0);\\n    if (border <= 0.0) { return inside; }\\n    return inside * clamp(0.5 + (c.d + border) * c.scale, 0.0, 1.0);\\n}\\n\\nfn rot2(v: vec2f, a: f32) -> vec2f {\\n    let cs = cos(a);\\n    let sn = sin(a);\\n    return vec2f(cs * v.x - sn * v.y, sn * v.x + cs * v.y);\\n}\\n\\n// ---------- colour lists ----------\\nfn stop_lin(f0: u32, k: u32) -> vec3f { return shader_data_at(f0 + 2u * k).rgb; }\\nfn stop_lab(f0: u32, k: u32) -> vec3f { return shader_data_at(f0 + 2u * k + 1u).rgb; }\\nfn stop_pt(f0: u32, k: u32) -> vec2f { return vec2f(shader_data_at(f0 + 2u * k).w, shader_data_at(f0 + 2u * k + 1u).w); }\\n\\nfn oklab_to_lin(c: vec3f) -> vec3f {\\n    let l = c.x + 0.39633778 * c.y + 0.21580376 * c.z;\\n    let m = c.x - 0.10556135 * c.y - 0.06385417 * c.z;\\n    let s = c.x - 0.08948418 * c.y - 1.29148555 * c.z;\\n    let l3 = l * l * l;\\n    let m3 = m * m * m;\\n    let s3 = s * s * s;\\n    return max(vec3f(\\n        4.07674166 * l3 - 3.30771159 * m3 + 0.23096993 * s3,\\n        -1.26843800 * l3 + 2.60975740 * m3 - 0.34131940 * s3,\\n        -0.00419609 * l3 - 0.70341861 * m3 + 1.70761470 * s3,\\n    ), vec3f(0.0));\\n}\\n\\n// The colour list as an even ramp over x in 0..1, blended in OKLab.\\nfn palette_ramp(f0: u32, n: u32, x: f32) -> vec3f {\\n    if (n <= 1u) { return stop_lin(f0, 0u); }\\n    let fx = clamp(x, 0.0, 1.0) * f32(n - 1u);\\n    let k = min(u32(fx), n - 2u);\\n    return oklab_to_lin(mix(stop_lab(f0, k), stop_lab(f0, k + 1u), fx - f32(k)));\\n}\\n\\n// The colour list as a closed loop over x in 0..1: the last colour blends back into the first.\\nfn ramp_loop(f0: u32, n: u32, x: f32) -> vec3f {\\n    if (n <= 1u) { return stop_lin(f0, 0u); }\\n    let fx = fract(x) * f32(n);\\n    let k = min(u32(fx), n - 1u);\\n    return oklab_to_lin(mix(stop_lab(f0, k), stop_lab(f0, (k + 1u) % n), fx - f32(k)));\\n}\\n\\n// Premultiplied output with the fill's coverage and intensity.\\nfn paint(col: vec3f, m: f32, i: Inst, px: vec2f) -> vec4f {\\n    let a = m * clamp(i.aux.y, 0.0, 1.0);\\n    return finish(vec4f(col * a, a), px);\\n}\\n\\n// ---------- tone inputs (dither, halftone) ----------\\n// Perceptual tone 0..1 at `p` for input `kind`: 0 linear ramp, 1 radial, 2 noise, 3 backdrop, 4 image.\\nfn tone_at(i: Inst, c: Ctx, p: vec2f, kind: i32, angle: f32) -> f32 {\\n    var v: f32;\\n    let q = p - c.c;\\n    if (kind == 0) {\\n        let dir = vec2f(cos(angle), sin(angle));\\n        let ext = abs(c.half.x * dir.x) + abs(c.half.y * dir.y);\\n        v = dot(q, dir) / max(ext, 1e-3) * 0.5 + 0.5;\\n    } else if (kind == 1) {\\n        v = 1.0 - clamp(length(q / max(c.half, vec2f(1e-3))) / 1.3, 0.0, 1.0);\\n    } else if (kind == 2) {\\n        let t = c.t * i.p1.y;\\n        v = 0.5 + 0.62 * fbm3(p / max(i.p1.x, 1.0) + vec2f(t * 0.31, t * 0.17), c.seed);\\n    } else if (kind == 3) {\\n        v = to_srgb(vec3f(lum(bd(p, c.scale).rgb))).x;\\n    } else {\\n        let s = textureSampleLevel(simulation_state, backdrop_sampler, (p - i.aux2.xy) / max(i.aux2.zw, vec2f(1e-3)), 0.0);\\n        v = to_srgb(vec3f(lum(s.rgb))).x;\\n    }\\n    return clamp((v - 0.5) * i.p1.w + 0.5 + i.p1.z * 0.5, 0.0, 1.0);\\n}\\n\\n// Ordered-dither threshold of an n\\u00d7n Bayer matrix (n = 2^bits), from the bit-interleave recurrence.\\nfn bayer(cell: vec2u, bits: u32) -> f32 {\\n    var v = 0u;\\n    for (var b = 0u; b < bits; b++) {\\n        let x = (cell.x >> b) & 1u;\\n        let y = (cell.y >> b) & 1u;\\n        let sh = 2u * (bits - 1u - b);\\n        v |= (((x ^ y) << 1u) | y) << sh;\\n    }\\n    return (f32(v) + 0.5) / f32(1u << (2u * bits));\\n}\\n\\n// ---------- lit slabs (liquid metal, plastic) ----------\\n// Slope of a slab's surface normal as (x, y) plus how far onto the rim it is (0..1). With a border\\n// the band is a round tube; otherwise the edge rolls off in a quarter round over `bevel` pt and\\n// the face is domed (negative `dome` dishes it).\\nfn slab_tilt(c: Ctx, border: f32, bevel: f32, dome: f32) -> vec3f {\\n    let depth = -c.d;\\n    let gv = sd_grad(c);\\n    var tilt = vec2f(0.0);\\n    var rim = 0.0;\\n    if (border > 0.0) {\\n        let x = clamp((depth - border * 0.5) / max(border * 0.5, 1e-3), -0.97, 0.97);\\n        tilt = -gv * x / sqrt(1.0 - x * x);\\n        rim = abs(x);\\n    } else {\\n        let bev = max(bevel, 0.5);\\n        let x = clamp(1.0 - depth / bev, 0.0, 0.92);\\n        tilt = gv * x / sqrt(1.0 - x * x);\\n        rim = x;\\n    }\\n    let qn = c.q / max(c.half, vec2f(1.0));\\n    tilt += vec2f(qn.x * 0.55, qn.y) * dome * select(0.8, 0.25, border > 0.0);\\n    return vec3f(tilt, rim);\\n}\\n\\n// ---------- liquid metal ----------\\n// Height of the flowing surface (in units of `scale`), domain-warped so ripples curl and pool.\\nfn flow_h(u: vec2f, w: vec2f, t: f32, seed: u32) -> f32 {\\n    let p = u + w;\\n    return gnoise(p + vec2f(0.0, t * 0.11), seed + 3u) + 0.5 * gnoise(ROT * p * 2.03 - vec2f(t * 0.07, 0.0), seed + 17u);\\n}\\n\\n// A photo studio seen from a polished object, by reflected direction r (screen y points down, +z\\n// toward the viewer): a bright sky that is lightest just above a hard horizon, an overhead soft\\n// box, a tall strip light on the right and a dim one on the left, over a dark floor that lightens\\n// away from the horizon. White lights; the caller tints them.\\nfn studio(r: vec3f, contrast: f32) -> vec3f {\\n    let up = -r.y;\\n    let e = up + 0.1; // elevation above the horizon (which sits a little below eye level)\\n    let w = 0.014;\\n    let sky = 0.2 + 0.6 * exp(-max(e, 0.0) * 3.2) + 0.45 * exp(-max(e, 0.0) * 24.0);\\n    let key = smoothstep(0.80, 0.95, dot(r, normalize(vec3f(-0.3, -0.82, 0.5)))) * 2.4;\\n    let strip = gauss(r.x - 0.6, 0.075) * smoothstep(-0.05, 0.2, e) * (1.0 - smoothstep(0.55, 0.9, up)) * 1.7;\\n    let fill_l = gauss(r.x + 0.72, 0.045) * smoothstep(0.0, 0.25, e) * (1.0 - smoothstep(0.4, 0.8, up)) * 0.55;\\n    let lights = (key + strip + fill_l) * contrast;\\n    // The floor: near black under the horizon, lifting toward the camera, with a soft pool of\\n    // bounced light off to the left.\\n    let fl = smoothstep(0.05, 1.0, -e);\\n    let pool = 0.16 * gauss(r.x + 0.25, 0.35) * smoothstep(0.25, 0.9, -e);\\n    let ground = (0.014 + 0.3 * fl * fl + pool + 0.05 * gauss(e + 0.06, 0.04)) / (contrast * contrast);\\n    let h = smoothstep(-w, w, e);\\n    let skyc = (sky * mix(1.0, 0.82, clamp(contrast - 1.0, 0.0, 1.0)) + lights) * vec3f(0.97, 0.99, 1.03);\\n    let floorc = ground * vec3f(1.04, 1.0, 0.95);\\n    return mix(floorc, skyc, h);\\n}\\n\\n// Gentle shoulder so lights roll off instead of clipping (per channel: hot gold goes pale).\\nfn shoulder(c: vec3f) -> vec3f {\\n    let k = 0.78;\\n    return select(c, k + (1.0 - k) * (1.0 - exp(-(c - k) / (1.0 - k))), c > vec3f(k));\\n}\\n\\nfn liquid_metal(i: Inst, c: Ctx, m: f32, px: vec2f) -> vec4f {\\n    let flow = i.p0.x;\\n    let sc = max(i.p0.y, 1.0);\\n    let t = c.t * i.p0.z;\\n    // Tilt of the surface normal (where it leans, as a slope): rim or tube + dome + liquid ripples.\\n    let slab = slab_tilt(c, i.aux.x, i.p0.w, i.p1.x);\\n    var tilt = slab.xy;\\n    let rim = slab.z;\\n    var hgt = 0.0;\\n    var bend = 0.0;\\n    if (flow > 0.0) {\\n        // Pinned to the window, or to the shape's centre so equal shapes ripple alike.\\n        let u = select(c.p + frame.bounds.xy / frame.scale, c.q, i.p2.x > 0.5) / sc;\\n        let wv = vec2f(gnoise(u * 0.6 + vec2f(t * 0.05, 1.7), c.seed + 7u), gnoise(u * 0.6 + vec2f(4.3, -t * 0.06), c.seed + 11u)) * 0.9;\\n        let e = 0.04;\\n        hgt = flow_h(u, wv, t, c.seed);\\n        let hx = flow_h(u + vec2f(e, 0.0), wv, t, c.seed) - hgt;\\n        let hy = flow_h(u + vec2f(0.0, e), wv, t, c.seed) - hgt;\\n        let grad = vec2f(hx, hy) / e;\\n        // Ripples calm toward the rim so the silhouette stays crisp.\\n        let k = flow * 0.42 * (1.0 - 0.6 * rim * rim);\\n        tilt -= grad * k;\\n        bend = length(grad) * k;\\n    }\\n    let n = normalize(vec3f(tilt, 1.0));\\n    var r = vec3f(2.0 * n.z * n.xy, 2.0 * n.z * n.z - 1.0);\\n    r = vec3f(rot2(r.xy, i.p1.y), r.z);\\n    let contrast = max(i.p1.w, 0.1);\\n    let env = studio(normalize(r), contrast) * i.c1.rgb;\\n    // Conductor Fresnel (Schlick): the tint at normal incidence, rising to white at grazing angles.\\n    let f0 = i.c0.rgb;\\n    let cz = clamp(1.0 - n.z, 0.0, 1.0);\\n    let cz2 = cz * cz;\\n    var f = f0 + (vec3f(1.0) - f0) * (cz2 * cz2 * cz);\\n    let ir = i.p1.z;\\n    if (ir > 0.0) {\\n        // Thin-film colour where the surface bends hardest.\\n        let ph = 1.6 * (1.0 - n.z) + 0.35 * hgt;\\n        let film = 0.5 + 0.5 * cos(TAU * (vec3f(ph) + vec3f(0.0, 0.33, 0.67)));\\n        let k = ir * clamp(smoothstep(0.04, 0.45, 1.0 - n.z) + bend * 0.8, 0.0, 1.0);\\n        f *= mix(vec3f(1.0), 0.55 + 0.9 * film, k);\\n    }\\n    let col = shoulder(f * env);\\n    return paint(col, m, i, px);\\n}\\n\\n// ---------- plastic ----------\\n// A dielectric under one soft light from `angle` (50\\u00b0 up), seen head on. The diffuse base keeps the\\n// colour on a flat face, darkens away from the light and lightens toward white facing it. The\\n// highlight is a GGX lobe widened by the light's size (so a polished face shows a soft spot, not a\\n// pinpoint) and the grazing-angle reflection is a faint sky. Both fill the headroom left above the\\n// base, so the colour never exceeds coverage and the fill blends alike in either blend mode.\\nfn plastic(i: Inst, c: Ctx, m: f32, px: vec2f) -> vec4f {\\n    let slab = slab_tilt(c, i.aux.x, i.p0.z, i.p0.y);\\n    let n = normalize(vec3f(slab.xy, 1.0));\\n    let l = vec3f(rot2(vec2f(0.0, -1.0), i.p0.w) * 0.6428, 0.766);\\n    let nl = dot(n, l);\\n    let base = clamp(i.c0.rgb, vec3f(0.0), vec3f(1.0));\\n    // 0.4 ambient + 0.6 direct on a flat face (n.l = 0.766).\\n    let shade = 0.4 + 0.7833 * max(nl, 0.0);\\n    var col = mix(base * min(shade, 1.0), vec3f(1.0), clamp((shade - 1.0) * 0.6, 0.0, 1.0));\\n    let rough = clamp(i.p0.x, 0.02, 1.0);\\n    let a = min(rough * rough + 0.1, 1.0);\\n    let a2 = a * a;\\n    let h = normalize(l + vec3f(0.0, 0.0, 1.0));\\n    let nh = max(dot(n, h), 0.0);\\n    let dd = nh * nh * (a2 - 1.0) + 1.0;\\n    let ndf = a2 / (PI * dd * dd);\\n    let fh = 1.0 - h.z;\\n    let spec = ndf * (0.04 + 0.96 * fh * fh * fh * fh * fh) * max(nl, 0.0) * 2.5;\\n    let fz = 1.0 - clamp(n.z, 0.0, 1.0);\\n    let sky = 0.55 + 0.45 * smoothstep(-0.5, 0.5, -n.y);\\n    let edge = 0.96 * fz * fz * fz * fz * fz * sky * (1.0 - 0.5 * rough);\\n    col += (vec3f(1.0) - col) * knee(spec + edge);\\n    return paint(col, m, i, px);\\n}\\n\\n// ---------- fluted glass ----------\\nfn fluted(i: Inst, c: Ctx, m: f32, px: vec2f) -> vec4f {\\n    let s = c.scale;\\n    let rib = max(i.p0.x, 1.0);\\n    let across = vec2f(cos(i.p0.y), sin(i.p0.y));\\n    let u = dot(c.p - c.c, across) / rib;\\n    let local = fract(u) - 0.5;\\n    let x = local * 2.0; // -1..1 across one rib\\n    // A convex rib acts as a cylindrical lens: the strip under it comes back squeezed and flipped.\\n    let o = -x * (1.0 + 0.35 * x * x) * i.p0.z;\\n    let dsp = i.p1.x * 0.3 * abs(x);\\n    let srcg = c.p + across * o;\\n    let srcr = c.p + across * o * (1.0 + dsp);\\n    let srcb = c.p + across * o * (1.0 - dsp);\\n    var col = vec3f(bd(srcr, s).r, bd(srcg, s).g, bd(srcb, s).b);\\n    let frost = i.p0.w;\\n    if (frost > 0.0) {\\n        if (i.xf.x > 0.5) {\\n            let blr = vec3f(bdb(srcr, s).r, bdb(srcg, s).g, bdb(srcb, s).b);\\n            col = mix(col, blr, i.xf.y);\\n        } else {\\n            // No pyramid this frame: a small blur along the ribs.\\n            let along = vec2f(-across.y, across.x);\\n            let j = ign(px) - 0.5;\\n            var acc = vec3f(0.0);\\n            for (var k = 0; k < 4; k++) {\\n                acc += bd(srcg + along * (f32(k) - 1.5 + j) * 3.0 * frost, s).rgb;\\n            }\\n            col = mix(col, acc * 0.25, frost);\\n        }\\n        let k = smoothstep(0.0, 0.6, frost);\\n        let l = lum(col);\\n        let sat = max(mix(vec3f(l), col, 1.0 + 0.5 * k), vec3f(0.0));\\n        col = to_lin(to_srgb(sat) * (1.0 - 0.2 * k) + vec3f(0.07 * k));\\n    }\\n    col = mix(col, col * i.c0.rgb, i.p1.z);\\n    // Light: a sheen down each rib's lit side, a shaded groove between ribs with a bright lip.\\n    let hl = i.p1.y;\\n    let aa = c.aa / rib;\\n    let groove = 1.0 - smoothstep(0.0, max(0.06, aa * 2.0), 0.5 - abs(local));\\n    // The sheen scales with what is behind (glass reflects little over black) plus a faint floor.\\n    let sheen = gauss(local + 0.22, 0.13) * 0.1 + gauss(local + 0.34, 0.03) * 0.1;\\n    let lip = gauss(local - 0.44, max(0.025, aa)) * 0.06;\\n    let lift = 0.35 + 0.65 * sqrt(clamp(lum(col), 0.0, 1.0));\\n    col = col * (1.0 - 0.28 * hl * groove) + vec3f((sheen + lip) * hl * lift);\\n    let a = m * clamp(i.aux.y, 0.0, 1.0);\\n    return vec4f(col * a, a);\\n}\\n\\n// ---------- the rest ----------\\nfn mesh_gradient(i: Inst, c: Ctx, m: f32, px: vec2f) -> vec4f {\\n    let f0 = u32(i.xf.x);\\n    let n = u32(i.xf.y);\\n    var uv = (c.p - i.rect.xy) / max(i.rect.zw, vec2f(1.0));\\n    let t = c.t * i.p0.y;\\n    let warp = i.p0.w;\\n    if (warp > 0.0) {\\n        uv += warp * 0.09 * vec2f(gnoise(uv * 2.1 + vec2f(t * 0.11, 0.0), c.seed + 5u), gnoise(uv * 2.1 + vec2f(3.7, -t * 0.09), c.seed + 9u));\\n    }\\n    let aspect = i.rect.zw / max(max(i.rect.z, i.rect.w), 1.0);\\n    let sharp = clamp(i.p0.z, 0.1, 8.0);\\n    var lab = vec3f(0.0);\\n    var wsum = 0.0;\\n    for (var k = 0u; k < n; k++) {\\n        let d = (uv - stop_pt(f0, k)) * aspect;\\n        // Shepard weights: each colour owns its point, blends fall off smoothly.\\n        let w = pow(dot(d, d) + 0.004, -sharp);\\n        lab += stop_lab(f0, k) * w;\\n        wsum += w;\\n    }\\n    return paint(oklab_to_lin(lab / max(wsum, 1e-6)), m, i, px);\\n}\\n\\nfn dither(i: Inst, c: Ctx, m: f32) -> vec4f {\\n    let f0 = u32(i.xf.x);\\n    let n = max(u32(i.xf.y), 1u);\\n    let pix = max(i.p0.z, 0.25);\\n    let rel = c.p - i.rect.xy;\\n    let cell = floor(rel / pix);\\n    let ci = bitcast<vec2u>(vec2i(cell));\\n    let tone = tone_at(i, c, i.rect.xy + (cell + 0.5) * pix, i32(i.p0.y + 0.5), i.p0.w);\\n    let pat = clamp(i32(i.p0.x + 0.5), 1, 5);\\n    var th: f32;\\n    if (pat <= 3) {\\n        th = bayer(ci, u32(pat));\\n    } else if (pat == 4) {\\n        let side = max(u32(i.xf.w), 1u);\\n        th = dat1(u32(i.xf.z), (ci.y % side) * side + ci.x % side);\\n    } else {\\n        th = u01(ci.x * 7919u + pcg(ci.y + c.seed));\\n    }\\n    let lv = f32(max(n, 2u) - 1u);\\n    let v = tone * lv;\\n    let k = min(u32(floor(v) + select(0.0, 1.0, fract(v) > th)), n - 1u);\\n    let a = m * clamp(i.aux.y, 0.0, 1.0);\\n    return vec4f(stop_lin(f0, k) * a, a);\\n}\\n\\nfn grain_gradient(i: Inst, c: Ctx, m: f32, px: vec2f) -> vec4f {\\n    let f0 = u32(i.xf.x);\\n    let n = u32(i.xf.y);\\n    let kind = i32(i.p0.x + 0.5);\\n    let ang = i.p0.y;\\n    let ctr = i.rect.xy + i.p0.zw * i.rect.zw;\\n    var x: f32;\\n    if (kind == 0) {\\n        let dir = vec2f(cos(ang), sin(ang));\\n        let ext = abs(c.half.x * dir.x) + abs(c.half.y * dir.y);\\n        x = dot(c.q, dir) / max(ext, 1e-3) * 0.5 + 0.5;\\n    } else if (kind == 1) {\\n        x = length(c.p - ctr) / max(length(c.half), 1e-3);\\n    } else {\\n        let d = c.p - ctr;\\n        let th = select(0.0, atan2(d.y, d.x), any(d != vec2f(0.0)));\\n        x = fract((th - ang) / TAU);\\n    }\\n    let amount = i.p1.x;\\n    let size = max(i.p1.y, 0.25);\\n    var frame = 0u;\\n    if (i.p1.w > 0.0) { frame = u32(floor(c.t * i.p1.w)); }\\n    let gc = bitcast<vec2u>(vec2i(floor((c.p - i.rect.xy) / size)));\\n    let h = pcg(gc.x + pcg(gc.y + pcg(frame + c.seed * 977u)));\\n    // Triangular noise scatters the ramp position: colours stipple into each other.\\n    let nx = u01(h) + u01(h + 1u) - 1.0;\\n    var col = palette_ramp(f0, n, x + nx * amount * 0.2);\\n    if (kind == 2) {\\n        col = ramp_loop(f0, n, x + nx * amount * 0.2);\\n    }\\n    let nb = u01(h + 2u) + u01(h + 3u) - 1.0;\\n    if (i.p1.z > 0.5) {\\n        col *= 1.0 + nb * amount * 0.18;\\n    } else {\\n        let nc = vec3f(nb, u01(h + 4u) + u01(h + 5u) - 1.0, u01(h + 6u) + u01(h + 7u) - 1.0);\\n        col *= vec3f(1.0) + nc * amount * 0.18;\\n    }\\n    return paint(col, m, i, px);\\n}\\n\\nfn metaballs(i: Inst, c: Ctx, m: f32, px: vec2f) -> vec4f {\\n    let f0 = u32(i.xf.x);\\n    let b0 = u32(i.xf.z);\\n    let nb = u32(i.xf.w);\\n    var field = 0.0;\\n    var grad = vec2f(0.0);\\n    var lab = vec3f(0.0);\\n    var rsum = 0.0;\\n    for (var k = 0u; k < nb; k++) {\\n        let b = shader_data_at(b0 + k);\\n        let d = c.p - b.xy;\\n        let r2 = b.z * b.z;\\n        let dd = dot(d, d) + 1e-3;\\n        let f = r2 / dd;\\n        field += f;\\n        grad += -2.0 * f / dd * d;\\n        lab += stop_lab(f0, u32(b.w)) * f;\\n        rsum += b.z * f;\\n    }\\n    let base = i.c0.rgb;\\n    let col = select(base, oklab_to_lin(lab / max(field, 1e-6)), field > 1e-5);\\n    let ravg = rsum / max(field, 1e-6);\\n    // Distance to the iso-surface field = 1, roughly (1 - field) * r / 2 near the edge.\\n    let cov = select(0.0, clamp(0.5 + (field - 1.0) * ravg * 0.5 * c.scale, 0.0, 1.0), field > 1e-3);\\n    // Glossy body: the field's slope tilts the normal near the rim, flat in the middle.\\n    let steep = 1.0 - smoothstep(1.0, 2.6, field);\\n    let nxy = -grad / sqrt(dot(grad, grad) + 1e-6) * steep * 0.9;\\n    let nrm = normalize(vec3f(nxy, 1.0));\\n    let l = normalize(vec3f(-0.45, -0.6, 0.66));\\n    let diff = max(dot(nrm, l), 0.0);\\n    let spec = pow(max(dot(reflect(-l, nrm), vec3f(0.0, 0.0, 1.0)), 1e-4), 28.0);\\n    let body = col * (0.6 + 0.5 * diff) + vec3f(spec * i.p0.w * 0.8);\\n    // A soft glow of each blob's colour into the base.\\n    let halo = col * smoothstep(0.25, 1.0, field) * 0.18;\\n    return paint(mix(base + halo, body, cov), m, i, px);\\n}\\n\\nfn swirl(i: Inst, c: Ctx, m: f32, px: vec2f) -> vec4f {\\n    let f0 = u32(i.xf.x);\\n    let n = u32(i.xf.y);\\n    let sc = max(i.p0.x, 1.0);\\n    let t = c.t * i.p0.y;\\n    let rr = length(c.q) / max(min(c.half.x, c.half.y), 1.0);\\n    let q = rot2(c.q, i.p0.z * TAU * exp(-rr * rr * 0.8)) / sc;\\n    let w1 = vec2f(fbm3(q + vec2f(t * 0.1, 0.0), c.seed), fbm3(q + vec2f(5.2, 1.3 - t * 0.08), c.seed + 3u));\\n    let v = fbm3(q + w1 * i.p0.w * 1.5 + vec2f(0.0, t * 0.05), c.seed + 7u);\\n    return paint(palette_ramp(f0, n, 0.5 + 0.75 * v), m, i, px);\\n}\\n\\nfn voronoi(i: Inst, c: Ctx, m: f32, px: vec2f) -> vec4f {\\n    let f0 = u32(i.xf.x);\\n    let n = u32(i.xf.y);\\n    let sc = max(i.p0.x, 2.0);\\n    let t = c.t * i.p0.y;\\n    let t0 = fract(t * (1.0 / TAU)) * TAU;\\n    let t1 = fract(t * (0.8 / TAU)) * TAU;\\n    let p = (c.p - i.rect.xy) / sc;\\n    let ip = floor(p);\\n    // Each cell's seed point orbits its own spot.\\n    var best = 8.0;\\n    var bc = vec2i(0);\\n    var bo = vec2f(0.0);\\n    for (var y = -1; y <= 1; y++) {\\n        for (var x = -1; x <= 1; x++) {\\n            let cc = vec2i(ip) + vec2i(x, y);\\n            let h = hcell(cc, c.seed);\\n            let h2 = hcell(cc, c.seed + 1u);\\n            let o = vec2f(0.5) + 0.38 * vec2f(sin(t0 + TAU * h), cos(t1 + TAU * h2));\\n            let d = vec2f(cc) + o - p;\\n            let dd = dot(d, d);\\n            if (dd < best) { best = dd; bc = cc; bo = d; }\\n        }\\n    }\\n    // Distance to the nearest seam: to the bisector with each neighbour. Seed points stay within\\n    // 0.12..0.88 of their cell, so the eight cells round the winner are enough in practice.\\n    var edge = 8.0;\\n    for (var y = -1; y <= 1; y++) {\\n        for (var x = -1; x <= 1; x++) {\\n            let cc = bc + vec2i(x, y);\\n            if (x == 0 && y == 0) { continue; }\\n            let h = hcell(cc, c.seed);\\n            let h2 = hcell(cc, c.seed + 1u);\\n            let o = vec2f(0.5) + 0.38 * vec2f(sin(t0 + TAU * h), cos(t1 + TAU * h2));\\n            let d = vec2f(cc) + o - p;\\n            let dv = d - bo;\\n            if (dot(dv, dv) > 1e-6) { edge = min(edge, dot(0.5 * (bo + d), normalize(dv))); }\\n        }\\n    }\\n    let k = u32(hcell(bc, c.seed + 2u) * f32(n)) % max(n, 1u);\\n    var col = stop_lin(f0, k) * (1.0 - i.p0.w * 0.55 * clamp(best * 1.6, 0.0, 1.0));\\n    let seam = i.p0.z * 0.5;\\n    if (seam > 0.0) {\\n        let e = clamp(0.5 + (edge * sc - seam) * c.scale, 0.0, 1.0);\\n        col = mix(i.c0.rgb, col, e);\\n    }\\n    return paint(col, m, i, px);\\n}\\n\\nfn waves(i: Inst, c: Ctx, m: f32, px: vec2f) -> vec4f {\\n    let f0 = u32(i.xf.x);\\n    let n = u32(i.xf.y);\\n    let ang = i.p0.w;\\n    let dir = vec2f(-sin(ang), cos(ang));\\n    let along = vec2f(cos(ang), sin(ang));\\n    let ext = abs(c.half.x * dir.x) + abs(c.half.y * dir.y);\\n    let ext2 = abs(c.half.x * along.x) + abs(c.half.y * along.y);\\n    let v = dot(c.q, dir) / max(2.0 * ext, 1e-3) + 0.5;\\n    let s = dot(c.q, along) / max(2.0 * ext2, 1e-3) + 0.5;\\n    let aa = c.aa / max(2.0 * ext, 1e-3);\\n    let soft = max(i.p1.x, aa);\\n    let t = c.t * i.p0.z;\\n    var col = stop_lin(f0, 0u);\\n    for (var k = 1u; k < n; k++) {\\n        let fk = f32(k);\\n        let h = hcell(vec2i(i32(k), 3), c.seed);\\n        let fq = i.p0.y * (0.8 + 0.4 * h);\\n        let ph1 = fract(t * 0.2 * (1.0 + 0.3 * fk) + h);\\n        let ph2 = fract(-t * 0.13) * TAU + 1.7 * fk;\\n        let y = fk / f32(n) + i.p0.x * (0.7 * sin(TAU * (fq * s + ph1)) + 0.3 * sin(TAU * fq * 2.3 * s + ph2));\\n        // The front band shades the one behind it just above its crest.\\n        let shade = exp(-max(y - v, 0.0) / 0.025) * 0.18 * step(v, y);\\n        col *= 1.0 - shade;\\n        col = mix(col, stop_lin(f0, k), smoothstep(y - soft, y + soft, v));\\n    }\\n    return paint(col, m, i, px);\\n}\\n\\nfn halftone(i: Inst, c: Ctx, m: f32, px: vec2f) -> vec4f {\\n    let pitch = max(i.p0.z, 1.0);\\n    let ang = i.p2.x;\\n    let r = rot2(c.p - c.c, -ang) / pitch;\\n    let base = floor(r - 0.5);\\n    let kind = i32(i.p0.y + 0.5);\\n    var ink = 0.0;\\n    // The four nearest dots, so big dots merge across cell lines.\\n    for (var y = 0; y <= 1; y++) {\\n        for (var x = 0; x <= 1; x++) {\\n            let cc = base + vec2f(f32(x), f32(y)) + 0.5;\\n            let w = c.c + rot2(cc * pitch, ang);\\n            let cov = 1.0 - tone_at(i, c, w, kind, i.p0.w);\\n            let rad = sqrt(cov / PI) * 1.12;\\n            let d = (length(r - cc) - rad) * pitch;\\n            ink = max(ink, clamp(0.5 - d * c.scale, 0.0, 1.0));\\n        }\\n    }\\n    return paint(mix(i.c1.rgb, i.c0.rgb, ink), m, i, px);\\n}\\n\\nfn rune_shade(in: VOut) -> vec4f {\\n    let i = inst_at();\\n    let px = pixel(in);\\n    let c = ctx(i, px);\\n    let m = fill_mask(c, i.aux.x);\\n    if (m <= 0.0) { return vec4f(0.0); }\\n    switch c.variant {\\n        case 0: { return liquid_metal(i, c, m, px); }\\n        case 1: { return mesh_gradient(i, c, m, px); }\\n        case 2: { return dither(i, c, m); }\\n        case 3: { return grain_gradient(i, c, m, px); }\\n        case 4: { return fluted(i, c, m, px); }\\n        case 5: { return metaballs(i, c, m, px); }\\n        case 6: { return swirl(i, c, m, px); }\\n        case 7: { return voronoi(i, c, m, px); }\\n        case 8: { return waves(i, c, m, px); }\\n        case 9: { return halftone(i, c, m, px); }\\n        default: { return plastic(i, c, m, px); }\\n    }\\n}\\n\";\n"
    }
  ],
  "docs": "[Shader layer](https://gpuixui.sudokw.com/effects/shader-layer) — These are GPUix native components: the files render through GPUix's reconciler against `@gpuix/react`, not the DOM, and need the per-platform `@gpuix/native` binding. The CLI installs the `@gpuixui/*` runtime the components import as registry items, so the copied tree resolves on its own; wrap it in `ThemeProvider` before it renders.",
  "meta": {
    "url": "/effects/shader-layer",
    "kind": "component",
    "runtime": "gpuix",
    "registry": "gpuixui"
  }
}