vireuikit 0.4.0 → 0.5.0

package/dist/web/index.cjs

@@ -1,1865 +0,0 @@
-'use strict';
-
-var vireglass = require('vireglass');
-var web = require('vireglass/web');
-
-// src/medium/noise.ts
-var VG_VALUE_NOISE = `
-float vgHash21(float2 p) {
-  float h = dot(p, float2(127.1, 311.7));
-  return fract(sin(h) * 43758.5453123);
-}
-
-float vgValueNoise(float2 p) {
-  float2 i = floor(p);
-  float2 f = fract(p);
-  float a = vgHash21(i);
-  float b = vgHash21(i + float2(1.0, 0.0));
-  float c = vgHash21(i + float2(0.0, 1.0));
-  float d = vgHash21(i + float2(1.0, 1.0));
-  float2 u = f * f * (3.0 - 2.0 * f);
-  return mix(mix(a, b, u.x), mix(c, d, u.x), u.y) * 2.0 - 1.0;
-}
-`;
-var glslFloat = (v) => Number.isInteger(v) ? v.toFixed(1) : String(v);
-var MEDIUM_TIME_PERIOD = 1e3;
-var MEDIUM_TIME_OCTAVES = [
-  { rate: 0.6, offset: 0, scale: 1 },
-  { rate: 1.7, offset: 11, scale: 2.03 },
-  { rate: 0.9, offset: 37, scale: 4.11 },
-  { rate: 0.15, offset: 5, scale: 0.35 }
-];
-function mediumOctavePeriod(rate) {
-  const period = rate * MEDIUM_TIME_PERIOD;
-  if (!Number.isInteger(period)) {
-    throw new Error(
-      `medium noise: octave rate ${rate} * MEDIUM_TIME_PERIOD ${MEDIUM_TIME_PERIOD} = ${period}, not an integer \u2014 the phase wrap would not be seamless`
-    );
-  }
-  return period;
-}
-var glslOctave = (o) => ({
-  rate: glslFloat(o.rate),
-  offset: glslFloat(o.offset),
-  scale: glslFloat(o.scale),
-  period: glslFloat(mediumOctavePeriod(o.rate))
-});
-var [VG_OCT0, VG_OCT1, VG_OCT2, VG_OCT3] = MEDIUM_TIME_OCTAVES.map(glslOctave);
-var VG_CURL_NOISE = `
-${VG_VALUE_NOISE}
-
-float vgHash31(float3 p) {
-  float h = dot(p, float3(127.1, 311.7, 74.7));
-  return fract(sin(h) * 43758.5453123);
-}
-
-// 3D value-noise: time is a third grid axis, not a coordinate shift. A shift would just SLIDE the
-// pattern (a "traveling" look, when motion is meant to read as random), while trilinear
-// interpolation over t CHANGES the pattern itself between grid nodes \u2014 nearby moments look alike,
-// distant ones don't, and no repeat ever shows up.
-float vgValueNoise3(float3 p) {
-  float3 i = floor(p);
-  float3 f = fract(p);
-  float3 u = f * f * (3.0 - 2.0 * f);
-  float n000 = vgHash31(i);
-  float n100 = vgHash31(i + float3(1.0, 0.0, 0.0));
-  float n010 = vgHash31(i + float3(0.0, 1.0, 0.0));
-  float n110 = vgHash31(i + float3(1.0, 1.0, 0.0));
-  float n001 = vgHash31(i + float3(0.0, 0.0, 1.0));
-  float n101 = vgHash31(i + float3(1.0, 0.0, 1.0));
-  float n011 = vgHash31(i + float3(0.0, 1.0, 1.0));
-  float n111 = vgHash31(i + float3(1.0, 1.0, 1.0));
-  float nx00 = mix(n000, n100, u.x);
-  float nx10 = mix(n010, n110, u.x);
-  float nx01 = mix(n001, n101, u.x);
-  float nx11 = mix(n011, n111, u.x);
-  float nxy0 = mix(nx00, nx10, u.y);
-  float nxy1 = mix(nx01, nx11, u.y);
-  return mix(nxy0, nxy1, u.z) * 2.0 - 1.0;
-}
-
-// Same as vgValueNoise3, but the z axis wraps at \`period\`: BOTH z-lattice neighbors (i.z and
-// i.z + 1.0) are folded into [0, period) before hashing, so this is EXACTLY the same function of
-// z and of z + period \u2014 not just close. vgPotential below calls this once per octave, each with
-// the period matching its own rate (MEDIUM_TIME_OCTAVES), so a phase that wraps at
-// MEDIUM_TIME_PERIOD reproduces the identical field instead of jumping to a new one.
-float vgValueNoise3Periodic(float3 p, float period) {
-  float3 i = floor(p);
-  float3 f = fract(p);
-  float3 u = f * f * (3.0 - 2.0 * f);
-  float z0 = mod(i.z, period);
-  float z1 = mod(i.z + 1.0, period);
-  float n000 = vgHash31(float3(i.xy, z0));
-  float n100 = vgHash31(float3(i.xy + float2(1.0, 0.0), z0));
-  float n010 = vgHash31(float3(i.xy + float2(0.0, 1.0), z0));
-  float n110 = vgHash31(float3(i.xy + float2(1.0, 1.0), z0));
-  float n001 = vgHash31(float3(i.xy, z1));
-  float n101 = vgHash31(float3(i.xy + float2(1.0, 0.0), z1));
-  float n011 = vgHash31(float3(i.xy + float2(0.0, 1.0), z1));
-  float n111 = vgHash31(float3(i.xy + float2(1.0, 1.0), z1));
-  float nx00 = mix(n000, n100, u.x);
-  float nx10 = mix(n010, n110, u.x);
-  float nx01 = mix(n001, n101, u.x);
-  float nx11 = mix(n011, n111, u.x);
-  float nxy0 = mix(nx00, nx10, u.y);
-  float nxy1 = mix(nx01, nx11, u.y);
-  return mix(nxy0, nxy1, u.z) * 2.0 - 1.0;
-}
-
-// The potential is an fbm of three octaves, each evolving over the field's PHASE at its own speed
-// (unrelated to the others, plus a phase offset): no single phase shift can align them all at
-// once, so no traveling pattern remains. Each octave wraps its own z-lattice at the period that
-// matches its rate (see MEDIUM_TIME_OCTAVES/vgValueNoise3Periodic), so
-// vgPotential(p, phase) === vgPotential(p, phase + ${glslFloat(MEDIUM_TIME_PERIOD)}) exactly \u2014 a
-// CPU-side phase accumulator can wrap at that period with no visible jump (see web/medium.ts). The
-// large-scale factor is a slow non-uniformity layered over the sum \u2014 without it, a field that's
-// uniform by statistics still reads as a regular cell pattern.
-float vgPotential(float2 p, float phase) {
-  float v = vgValueNoise3Periodic(float3(p * ${VG_OCT0.scale}, phase * ${VG_OCT0.rate} + ${VG_OCT0.offset}), ${VG_OCT0.period}) * 0.5;
-  v += vgValueNoise3Periodic(float3(p * ${VG_OCT1.scale}, phase * ${VG_OCT1.rate} + ${VG_OCT1.offset}), ${VG_OCT1.period}) * 0.25;
-  v += vgValueNoise3Periodic(float3(p * ${VG_OCT2.scale}, phase * ${VG_OCT2.rate} + ${VG_OCT2.offset}), ${VG_OCT2.period}) * 0.125;
-  float macro = vgValueNoise3Periodic(float3(p * ${VG_OCT3.scale}, phase * ${VG_OCT3.rate} + ${VG_OCT3.offset}), ${VG_OCT3.period});
-  return v * (0.7 + 0.3 * macro);
-}
-
-// Velocity = (dPsi/dy, -dPsi/dx) \u2014 the curl of a scalar field, solenoidal for any Psi. Central
-// differences instead of an analytic derivative: the potential is a sum of three value-noise
-// calls, and there is no cheaper way to differentiate it by hand than four extra samples.
-float2 vgCurlVelocity(float2 p, float phase) {
-  float e = 0.6;
-  float px1 = vgPotential(p + float2(e, 0.0), phase);
-  float px0 = vgPotential(p - float2(e, 0.0), phase);
-  float py1 = vgPotential(p + float2(0.0, e), phase);
-  float py0 = vgPotential(p - float2(0.0, e), phase);
-  return float2(py1 - py0, -(px1 - px0)) / (2.0 * e);
-}
-
-// vgPotential above is periodic in TIME only: the simulation domain is a torus (gl.REPEAT), but
-// the lattice itself never wraps in x/y, so velocity jumps at the domain seam and dye on either
-// side of it is transported differently \u2014 a straight seam, made worse wherever something re-reads
-// the field at a different scale (the far depth plane's tile boundary). vgValueNoise3Seamless
-// wraps ALL THREE lattice axes: xyPeriod/zPeriod fold BOTH neighbors of a cell into their own
-// period before hashing, so the field is EXACTLY the same one period over, in space exactly as it
-// already was in time.
-//
-// The period has to be an integer number of lattice cells, or the wrap would jump instead of
-// closing seamlessly (the same requirement MEDIUM_TIME_OCTAVES/mediumOctavePeriod enforces for
-// time) \u2014 but unlike time, the spatial period depends on the GRID SIZE, which this shader has no
-// notion of. So xyPeriod travels together with a per-octave spatial frequency the CPU computes to
-// make gridSize * frequency land on that exact integer (see computeMediumSpatialPeriods below);
-// both arrive together as one uniform per octave (u_spatialN.xy = frequency, .zw = period),
-// recomputed by web/medium.ts whenever the grid resizes.
-float vgValueNoise3Seamless(float3 p, float2 xyPeriod, float zPeriod) {
-  float3 i = floor(p);
-  float3 f = fract(p);
-  float3 u = f * f * (3.0 - 2.0 * f);
-  float x0 = mod(i.x, xyPeriod.x);
-  float x1 = mod(i.x + 1.0, xyPeriod.x);
-  float y0 = mod(i.y, xyPeriod.y);
-  float y1 = mod(i.y + 1.0, xyPeriod.y);
-  float z0 = mod(i.z, zPeriod);
-  float z1 = mod(i.z + 1.0, zPeriod);
-  float n000 = vgHash31(float3(x0, y0, z0));
-  float n100 = vgHash31(float3(x1, y0, z0));
-  float n010 = vgHash31(float3(x0, y1, z0));
-  float n110 = vgHash31(float3(x1, y1, z0));
-  float n001 = vgHash31(float3(x0, y0, z1));
-  float n101 = vgHash31(float3(x1, y0, z1));
-  float n011 = vgHash31(float3(x0, y1, z1));
-  float n111 = vgHash31(float3(x1, y1, z1));
-  float nx00 = mix(n000, n100, u.x);
-  float nx10 = mix(n010, n110, u.x);
-  float nx01 = mix(n001, n101, u.x);
-  float nx11 = mix(n011, n111, u.x);
-  float nxy0 = mix(nx00, nx10, u.y);
-  float nxy1 = mix(nx01, nx11, u.y);
-  return mix(nxy0, nxy1, u.z) * 2.0 - 1.0;
-}
-
-// Same four-octave fbm as vgPotential, but every octave reads the seamless lattice above at its
-// OWN (frequency, period) pair \u2014 sN.xy replaces that octave's compile-time \`scale\` constant (it
-// has to be a uniform now: the adjustment depends on the live grid size), sN.zw is the matching
-// integer period. \`p\` is still curlFreq-scaled exactly as vgPotential's caller scales it \u2014 only
-// the per-octave multiplier changed from a constant to a grid-dependent uniform, so the finite
-// difference in vgCurlVelocitySeamless below needs no epsilon change of its own.
-float vgPotentialSeamless(float2 p, float phase, float4 s0, float4 s1, float4 s2, float4 s3) {
-  float v = vgValueNoise3Seamless(float3(p * s0.xy, phase * ${VG_OCT0.rate} + ${VG_OCT0.offset}), s0.zw, ${VG_OCT0.period}) * 0.5;
-  v += vgValueNoise3Seamless(float3(p * s1.xy, phase * ${VG_OCT1.rate} + ${VG_OCT1.offset}), s1.zw, ${VG_OCT1.period}) * 0.25;
-  v += vgValueNoise3Seamless(float3(p * s2.xy, phase * ${VG_OCT2.rate} + ${VG_OCT2.offset}), s2.zw, ${VG_OCT2.period}) * 0.125;
-  float macro = vgValueNoise3Seamless(float3(p * s3.xy, phase * ${VG_OCT3.rate} + ${VG_OCT3.offset}), s3.zw, ${VG_OCT3.period});
-  return v * (0.7 + 0.3 * macro);
-}
-
-float2 vgCurlVelocitySeamless(float2 p, float phase, float4 s0, float4 s1, float4 s2, float4 s3) {
-  float e = 0.6;
-  float px1 = vgPotentialSeamless(p + float2(e, 0.0), phase, s0, s1, s2, s3);
-  float px0 = vgPotentialSeamless(p - float2(e, 0.0), phase, s0, s1, s2, s3);
-  float py1 = vgPotentialSeamless(p + float2(0.0, e), phase, s0, s1, s2, s3);
-  float py0 = vgPotentialSeamless(p - float2(0.0, e), phase, s0, s1, s2, s3);
-  return float2(py1 - py0, -(px1 - px0)) / (2.0 * e);
-}
-`;
-function hash31JS(x, y, z) {
-  const h = x * 127.1 + y * 311.7 + z * 74.7;
-  const s = Math.sin(h) * 43758.5453123;
-  return s - Math.floor(s);
-}
-var smoothstep3JS = (f) => f * f * (3 - 2 * f);
-var glslMod = (x, y) => x - y * Math.floor(x / y);
-function vgValueNoise3PeriodicJS(px, py, pz, period) {
-  const ix = Math.floor(px);
-  const iy = Math.floor(py);
-  const iz = Math.floor(pz);
-  const ux = smoothstep3JS(px - ix);
-  const uy = smoothstep3JS(py - iy);
-  const uz = smoothstep3JS(pz - iz);
-  const z0 = glslMod(iz, period);
-  const z1 = glslMod(iz + 1, period);
-  const n000 = hash31JS(ix, iy, z0);
-  const n100 = hash31JS(ix + 1, iy, z0);
-  const n010 = hash31JS(ix, iy + 1, z0);
-  const n110 = hash31JS(ix + 1, iy + 1, z0);
-  const n001 = hash31JS(ix, iy, z1);
-  const n101 = hash31JS(ix + 1, iy, z1);
-  const n011 = hash31JS(ix, iy + 1, z1);
-  const n111 = hash31JS(ix + 1, iy + 1, z1);
-  const nx00 = n000 + (n100 - n000) * ux;
-  const nx10 = n010 + (n110 - n010) * ux;
-  const nx01 = n001 + (n101 - n001) * ux;
-  const nx11 = n011 + (n111 - n011) * ux;
-  const nxy0 = nx00 + (nx10 - nx00) * uy;
-  const nxy1 = nx01 + (nx11 - nx01) * uy;
-  return (nxy0 + (nxy1 - nxy0) * uz) * 2 - 1;
-}
-function vgPotentialJS(px, py, phase) {
-  const [o0, o1, o2, o3] = MEDIUM_TIME_OCTAVES;
-  let v = vgValueNoise3PeriodicJS(px * o0.scale, py * o0.scale, phase * o0.rate + o0.offset, mediumOctavePeriod(o0.rate)) * 0.5;
-  v += vgValueNoise3PeriodicJS(px * o1.scale, py * o1.scale, phase * o1.rate + o1.offset, mediumOctavePeriod(o1.rate)) * 0.25;
-  v += vgValueNoise3PeriodicJS(px * o2.scale, py * o2.scale, phase * o2.rate + o2.offset, mediumOctavePeriod(o2.rate)) * 0.125;
-  const macro = vgValueNoise3PeriodicJS(
-    px * o3.scale,
-    py * o3.scale,
-    phase * o3.rate + o3.offset,
-    mediumOctavePeriod(o3.rate)
-  );
-  return v * (0.7 + 0.3 * macro);
-}
-var MIN_SPATIAL_PERIOD = 2;
-function computeMediumSpatialPeriods(gridWidth, gridHeight, curlFreq) {
-  const freq = Math.max(curlFreq, 1e-6);
-  return MEDIUM_TIME_OCTAVES.map((o) => {
-    const rawX = gridWidth * freq * o.scale;
-    const rawY = gridHeight * freq * o.scale;
-    const minRaw = Math.min(rawX, rawY);
-    const scaleUp = minRaw > 0 && minRaw < MIN_SPATIAL_PERIOD ? MIN_SPATIAL_PERIOD / minRaw : 1;
-    const periodX = Math.max(MIN_SPATIAL_PERIOD, Math.round(rawX * scaleUp));
-    const periodY = Math.max(MIN_SPATIAL_PERIOD, Math.round(rawY * scaleUp));
-    return {
-      freqX: periodX / (gridWidth * freq),
-      freqY: periodY / (gridHeight * freq),
-      periodX,
-      periodY
-    };
-  });
-}
-
-// src/medium/oklab.ts
-var LINEAR_TO_LMS = [
-  [0.4122214708, 0.5363325363, 0.0514459929],
-  [0.2119034982, 0.6806995451, 0.1073969566],
-  [0.0883024619, 0.2817188376, 0.6299787005]
-];
-var LMS_TO_OKLAB = [
-  [0.2104542553, 0.793617785, -0.0040720468],
-  [1.9779984951, -2.428592205, 0.4505937099],
-  [0.0259040371, 0.7827717662, -0.808675766]
-];
-var OKLAB_TO_LMS = [
-  [1, 0.3963377774, 0.2158037573],
-  [1, -0.1055613458, -0.0638541728],
-  [1, -0.0894841775, -1.291485548]
-];
-var LMS_TO_LINEAR = [
-  [4.0767416621, -3.3077115913, 0.2309699292],
-  [-1.2684380046, 2.6097574011, -0.3413193965],
-  [-0.0041960863, -0.7034186147, 1.707614701]
-];
-var glsl = (v) => Number.isInteger(v) ? v.toFixed(1) : String(v);
-var row = (m, i, vars) => m[i].map((k, j) => `${glsl(k)} * ${vars[j]}`).join(" + ");
-var VG_OKLAB_TO_SRGB = `
-float3 vgLinearToSrgb(float3 c) {
-  float3 lo = c * 12.92;
-  float3 hi = 1.055 * pow(max(c, float3(0.0)), float3(1.0 / 2.4)) - 0.055;
-  return mix(lo, hi, step(float3(0.0031308), c));
-}
-
-float3 vgOklabToLinear(float3 lab) {
-  float l_ = ${row(OKLAB_TO_LMS, 0, ["lab.x", "lab.y", "lab.z"])};
-  float m_ = ${row(OKLAB_TO_LMS, 1, ["lab.x", "lab.y", "lab.z"])};
-  float s_ = ${row(OKLAB_TO_LMS, 2, ["lab.x", "lab.y", "lab.z"])};
-  float l = l_ * l_ * l_;
-  float m = m_ * m_ * m_;
-  float s = s_ * s_ * s_;
-  return float3(
-    ${row(LMS_TO_LINEAR, 0, ["l", "m", "s"])},
-    ${row(LMS_TO_LINEAR, 1, ["l", "m", "s"])},
-    ${row(LMS_TO_LINEAR, 2, ["l", "m", "s"])}
-  );
-}
-`;
-var apply = (m, v) => [
-  m[0][0] * v[0] + m[0][1] * v[1] + m[0][2] * v[2],
-  m[1][0] * v[0] + m[1][1] * v[1] + m[1][2] * v[2],
-  m[2][0] * v[0] + m[2][1] * v[1] + m[2][2] * v[2]
-];
-var srgbChannelToLinear = (c) => c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
-var linearChannelToSrgb = (c) => c <= 31308e-7 ? c * 12.92 : 1.055 * Math.pow(Math.max(c, 0), 1 / 2.4) - 0.055;
-function srgbToOklab(rgb) {
-  const linear = rgb.map(srgbChannelToLinear);
-  const lms = apply(LINEAR_TO_LMS, linear);
-  return apply(LMS_TO_OKLAB, lms.map((v) => Math.cbrt(Math.max(v, 0))));
-}
-function oklabToSrgb(lab) {
-  const lms = apply(OKLAB_TO_LMS, lab).map((v) => v * v * v);
-  return apply(LMS_TO_LINEAR, lms).map(linearChannelToSrgb);
-}
-
-// src/medium/species.ts
-var MEDIUM_SPECIES_LIGHTNESS = 0.44;
-var MEDIUM_SPECIES_HUE_SPREAD = 32;
-var clamp01 = (v) => Math.min(1, Math.max(0, v));
-function characterOf(color) {
-  const [lightness, a, b] = srgbToOklab(color);
-  return {
-    hue: Math.atan2(b, a) * 180 / Math.PI,
-    chroma: Math.hypot(a, b),
-    lightness
-  };
-}
-function speciesFamily(character, spreadDeg = MEDIUM_SPECIES_HUE_SPREAD) {
-  const { hue, chroma, lightness } = character;
-  const tone = (deg) => {
-    const rad = deg * Math.PI / 180;
-    return oklabToSrgb([lightness, chroma * Math.cos(rad), chroma * Math.sin(rad)]).map(
-      clamp01
-    );
-  };
-  return [tone(hue - spreadDeg), tone(hue), tone(hue + spreadDeg)];
-}
-function neutralSpecies(baseColor) {
-  const { hue, chroma } = characterOf(baseColor);
-  return speciesFamily({ hue, chroma, lightness: MEDIUM_SPECIES_LIGHTNESS });
-}
-
-// src/medium/params.ts
-var MEDIUM_MAX_LIGHTS = 3;
-var BASE_COLOR = [0.07, 0.08, 0.1];
-var normalize2 = (v) => {
-  const len = Math.hypot(v[0], v[1]) || 1;
-  return [v[0] / len, v[1] / len];
-};
-var MEDIUM_DEFAULT_LIGHT_COLOR = [0.78, 0.85, 0.94];
-var MEDIUM_DEFAULT_LIGHTS = [
-  {
-    position: [0.5, 0],
-    direction: [0, 1],
-    coneAngle: Math.PI,
-    falloff: 16,
-    color: MEDIUM_DEFAULT_LIGHT_COLOR,
-    intensity: 0.28
-  },
-  {
-    position: [0.12, 1.45],
-    direction: normalize2([0.38, -1.03]),
-    coneAngle: 9 * Math.PI / 180,
-    falloff: 0.7,
-    color: MEDIUM_DEFAULT_LIGHT_COLOR,
-    intensity: 1.1
-  },
-  {
-    position: [0.9, 1.4],
-    direction: normalize2([-0.4, -0.98]),
-    coneAngle: 8 * Math.PI / 180,
-    falloff: 0.75,
-    color: MEDIUM_DEFAULT_LIGHT_COLOR,
-    intensity: 0.9
-  }
-];
-var MEDIUM_DEFAULTS = {
-  // A stamped track has to visibly broaden and fade within the reference's "roughly one to two
-  // seconds", not the ~11s half-life a 0.06 decay gives — measured against check-medium.mjs's track
-  // gate (birth vs +1.5s cross-section width and total density): 1.1 leaves ~30% of the peak at 1s
-  // and ~17% at 1.5s, comfortably faded without dying before MacCormack's own diffusion has time to
-  // visibly broaden the stamp.
-  decay: 1.1,
-  curlFreq: 0.045,
-  curlSpeed: 0.12,
-  advectSpeed: 26,
-  turbulence: 1,
-  condensationRate: 0.18,
-  condensationFloor: 0.12,
-  evaporationRate: 0.2,
-  condensateSettleSpeed: 8,
-  condensateSettleWiggle: 0.4,
-  condensateSpreadRate: 0.08,
-  condensateTint: 0.2,
-  condensateGain: 5,
-  condensateColor: [0.94, 0.95, 0.97],
-  channelColors: neutralSpecies(BASE_COLOR),
-  channelScatter: [1, 1, 1],
-  baseColor: BASE_COLOR,
-  baseWeight: 0.9,
-  depthFarScale: 1.6,
-  depthFarOffsetFrac: [0.47, 0.53],
-  depthFarBlurRadius: 5,
-  depthFarWeight: 0.5,
-  gravityVaporDrift: 0.6,
-  gravityBottomBoost: 2,
-  gravityBottomBoostStart: 0.75,
-  lights: MEDIUM_DEFAULT_LIGHTS,
-  shadowExtinction: 3,
-  trackLightFloor: 0.8,
-  trackLayerAmount: 1
-};
-function depthFarOffsetPx(offsetFrac, gridWidth, gridHeight) {
-  return [offsetFrac[0] * gridWidth, offsetFrac[1] * gridHeight];
-}
-var MEDIUM_TRACK_LAYER_LIFE_SECONDS = {
-  alpha: 1.8,
-  electron: 1.4,
-  muon: 2.2
-};
-var MEDIUM_TRACK_LAYER_MAX_TRACKS = 64;
-var MEDIUM_TRACK_LAYER_LOOK = {
-  alpha: {
-    sigmaFrac: 22e-4,
-    endSigmaMul: 1.9,
-    broaden: 3.2,
-    wiggleFrac: 0,
-    beadFrac: 6e-3,
-    dropletFrac: 35e-4,
-    dropletChance: 0.5,
-    startFrac: 0.035,
-    gain: 1.8
-  },
-  electron: {
-    sigmaFrac: 9e-4,
-    endSigmaMul: 1.3,
-    broaden: 6,
-    wiggleFrac: 0.012,
-    beadFrac: 8e-3,
-    dropletFrac: 6e-3,
-    dropletChance: 0.55,
-    startFrac: 0,
-    gain: 2.2
-  },
-  muon: {
-    sigmaFrac: 8e-4,
-    endSigmaMul: 1,
-    broaden: 5,
-    wiggleFrac: 0,
-    beadFrac: 7e-3,
-    dropletFrac: 5e-3,
-    dropletChance: 0.5,
-    startFrac: 0,
-    gain: 2.2
-  }
-};
-var MEDIUM_TRACK_LAYER_BURST_SPREAD = 1.6;
-var MEDIUM_TRACK_LAYER_BURST_ACCENT = 3;
-var MEDIUM_TRACK_LAYER_FADE_GAMMA = 1.6;
-var MEDIUM_TRACK_LAYER_GRAVITY_SAG = 0.018;
-var MEDIUM_TRACK_LAYER_CURL_PUSH = 0.05;
-
-// src/medium/seed-shader.ts
-var MEDIUM_SEED_SHADER = `
-uniform float2 u_spot0;
-uniform float2 u_spot1;
-uniform float2 u_spot2;
-uniform float  u_spotRadius;
-
-float vgSpot(float2 p, float2 c, float r) {
-  float d = length(p - c) / max(r, 1.0);
-  return exp(-d * d * 2.0);
-}
-
-half4 main(float2 xy) {
-  float3 dye = float3(
-    vgSpot(xy, u_spot0, u_spotRadius),
-    vgSpot(xy, u_spot1, u_spotRadius),
-    vgSpot(xy, u_spot2, u_spotRadius)
-  );
-  return half4(half3(dye), half(1.0));
-}
-`;
-
-// src/medium/resample-shader.ts
-var MEDIUM_RESAMPLE_SHADER = `
-uniform shader u_src;
-
-half4 main(float2 xy) {
-  float2 uv = xy / u_resolution;
-  float2 src = uv * u_srcSize;
-  return u_src.eval(float2(src.x, u_srcSize.y - src.y));
-}
-`;
-
-// src/medium/advect-shader.ts
-var MEDIUM_ADVECT_UNIFORMS = `
-uniform shader u_dye;
-uniform float  u_dt;
-uniform float  u_phase;
-uniform float  u_curlFreq;
-uniform float  u_advectSpeed;
-uniform float  u_turbulence;
-// One float4 per MEDIUM_TIME_OCTAVES entry: xy is that octave's seamless spatial frequency, zw its
-// matching integer lattice period \u2014 both grid-size-dependent, so they can't be compile-time
-// constants (see vgPotentialSeamless/computeMediumSpatialPeriods in noise.ts). Recomputed by
-// web/medium.ts's bindVelocityUniforms every frame from the live grid dimensions.
-uniform float4 u_spatial0;
-uniform float4 u_spatial1;
-uniform float4 u_spatial2;
-uniform float4 u_spatial3;
-
-${VG_CURL_NOISE}
-`;
-var MEDIUM_ADVECT_VELOCITY = `
-  float2 curl = vgCurlVelocitySeamless(xy * u_curlFreq, u_phase, u_spatial0, u_spatial1, u_spatial2, u_spatial3);
-  float2 vel = curl * u_advectSpeed * u_turbulence;
-`;
-var MEDIUM_ADVECT_VELOCITY_SETTLE = `
-${MEDIUM_ADVECT_VELOCITY}
-  vel.y += u_settleSpeed;
-  vel.x += curl.x * u_advectSpeed * u_settleWiggle;
-`;
-var MEDIUM_ADVECT_VELOCITY_VAPOR = `
-${MEDIUM_ADVECT_VELOCITY}
-  vel.y += u_vaporDrift;
-`;
-var MEDIUM_VAPOR_FORWARD_SHADER = `
-${MEDIUM_ADVECT_UNIFORMS}
-uniform float u_vaporDrift;
-
-half4 main(float2 xy) {
-${MEDIUM_ADVECT_VELOCITY_VAPOR}
-  float2 src = xy - vel * u_dt;
-  return u_dye.eval(float2(src.x, u_dyeSize.y - src.y));
-}
-`;
-var MEDIUM_CONDENSATE_FORWARD_SHADER = `
-${MEDIUM_ADVECT_UNIFORMS}
-uniform float u_settleSpeed;
-uniform float u_settleWiggle;
-
-half4 main(float2 xy) {
-${MEDIUM_ADVECT_VELOCITY_SETTLE}
-  float2 src = xy - vel * u_dt;
-  return u_dye.eval(float2(src.x, u_dyeSize.y - src.y));
-}
-`;
-var MEDIUM_MACCORMACK_CORRECT = `
-  float2 srcForward = xy - vel * u_dt;
-  float2 srcReverse = xy + vel * u_dt;
-  half4 forwardSelf = u_forward.eval(float2(xy.x, u_forwardSize.y - xy.y));
-  half4 forwardReverse = u_forward.eval(float2(srcReverse.x, u_forwardSize.y - srcReverse.y));
-  half4 prevSelf = u_dye.eval(float2(xy.x, u_dyeSize.y - xy.y));
-  half4 corrected = forwardSelf + half4(0.5) * (prevSelf - forwardReverse);
-
-  float2 src = float2(srcForward.x, u_dyeSize.y - srcForward.y);
-  float2 base = floor(src - 0.5);
-  half4 c00 = u_dye.eval(base + float2(0.5, 0.5));
-  half4 c10 = u_dye.eval(base + float2(1.5, 0.5));
-  half4 c01 = u_dye.eval(base + float2(0.5, 1.5));
-  half4 c11 = u_dye.eval(base + float2(1.5, 1.5));
-  half4 lo = min(min(c00, c10), min(c01, c11));
-  half4 hi = max(max(c00, c10), max(c01, c11));
-  half4 limited = clamp(corrected, lo, hi);
-`;
-var MEDIUM_VAPOR_CORRECT_SHADER = `
-${MEDIUM_ADVECT_UNIFORMS}
-uniform shader u_forward;
-uniform float u_vaporDrift;
-
-half4 main(float2 xy) {
-${MEDIUM_ADVECT_VELOCITY_VAPOR}
-${MEDIUM_MACCORMACK_CORRECT}
-  return limited;
-}
-`;
-var MEDIUM_CONDENSATE_CORRECT_SHADER = `
-${MEDIUM_ADVECT_UNIFORMS}
-uniform float u_settleSpeed;
-uniform float u_settleWiggle;
-uniform shader u_forward;
-
-half4 main(float2 xy) {
-${MEDIUM_ADVECT_VELOCITY_SETTLE}
-${MEDIUM_MACCORMACK_CORRECT}
-  return limited;
-}
-`;
-var MEDIUM_VAPOR_REACT_SHADER = `
-uniform shader u_transported;
-uniform shader u_condensateTransported;
-uniform float  u_dt;
-uniform float  u_condensationRate;
-uniform float  u_condensationFloor;
-uniform float  u_evaporationRate;
-uniform float  u_totalScale;
-
-half4 main(float2 xy) {
-  float3 prevVapor = float3(u_transported.eval(float2(xy.x, u_transportedSize.y - xy.y)).rgb);
-  float condensateAtXy = float(u_condensateTransported.eval(float2(xy.x, u_condensateTransportedSize.y - xy.y)).r);
-  float vaporTotal = prevVapor.r + prevVapor.g + prevVapor.b;
-
-  // Only the EXCESS of vapor above the background floor condenses, not any nonzero density \u2014
-  // otherwise condensate would exactly retrace the vapor spot's shape (the same outline, or
-  // softer from blur), leaving the two phases nowhere to visually diverge: vapor is already soft,
-  // and condensate needs to read brighter and sharper than it. The floor concentrates condensate
-  // in dense turbulence cores, leaving the sparse vapor around it uncondensed \u2014 that's where the
-  // contrast comes from.
-  float excess = max(0.0, vaporTotal - u_condensationFloor);
-  float condensedAmount = excess * (1.0 - exp(-u_condensationRate * u_dt));
-  float lossFraction = vaporTotal > 1e-6 ? condensedAmount / vaporTotal : 0.0;
-  float3 afterLoss = prevVapor * (1.0 - lossFraction);
-
-  float condKeep = exp(-u_evaporationRate * u_dt);
-  float returned = condensateAtXy * (1.0 - condKeep);
-
-  // Evaporated water is distributed by the CURRENT vapor proportion \u2014 the condensation/
-  // evaporation cycle doesn't shift the hue, water only oscillates between phases (color belongs
-  // to vapor).
-  float sumAfterLoss = afterLoss.r + afterLoss.g + afterLoss.b;
-  float3 hueShare = sumAfterLoss > 1e-6 ? afterLoss / sumAfterLoss : float3(1.0 / 3.0);
-  float3 vapor = (afterLoss + hueShare * returned) * u_totalScale;
-  return half4(half3(vapor), half(1.0));
-}
-`;
-var MEDIUM_CONDENSATE_REACT_SHADER = `
-uniform shader u_transported;
-uniform shader u_vaporTransported;
-uniform shader u_dye;
-uniform float  u_dt;
-uniform float  u_condensationRate;
-uniform float  u_condensationFloor;
-uniform float  u_evaporationRate;
-uniform float  u_spreadRate;
-uniform float  u_totalScale;
-
-half4 main(float2 xy) {
-  float prevCondensate = float(u_transported.eval(float2(xy.x, u_transportedSize.y - xy.y)).r);
-  float3 vaporAtXy = float3(u_vaporTransported.eval(float2(xy.x, u_vaporTransportedSize.y - xy.y)).rgb);
-  float vaporTotal = vaporAtXy.r + vaporAtXy.g + vaporAtXy.b;
-
-  float excess = max(0.0, vaporTotal - u_condensationFloor);
-  float condensed = excess * (1.0 - exp(-u_condensationRate * u_dt));
-  float condKeep = exp(-u_evaporationRate * u_dt);
-  float afterReaction = prevCondensate * condKeep + condensed;
-
-  // Growth is an Euler step separate from transport: the neighbors are sampled at THIS cell's own
-  // xy in the ORIGINAL (pre-transport-this-frame) field u_dye, not the already
-  // transported/corrected value. On a non-uniform flow, warping compresses the domain in some
-  // places and stretches it in others, and blurring at a warped point stacks those distortions \u2014
-  // the error accumulates frame over frame (measured: condensate steadily gained about 5% extra
-  // water alongside its own mass growth). Right on the grid, with no warp, the same blur is an
-  // honest averaging kernel that conserves the sum on a periodic domain.
-  float2 selfSrc = float2(xy.x, u_dyeSize.y - xy.y);
-  float n0 = float(u_dye.eval(float2(selfSrc.x + 1.0, selfSrc.y)).r);
-  float n1 = float(u_dye.eval(float2(selfSrc.x - 1.0, selfSrc.y)).r);
-  float n2 = float(u_dye.eval(float2(selfSrc.x, selfSrc.y - 1.0)).r);
-  float n3 = float(u_dye.eval(float2(selfSrc.x, selfSrc.y + 1.0)).r);
-  float neighborAvg = (n0 + n1 + n2 + n3) * 0.25;
-  float spreadWeight = 1.0 - exp(-u_spreadRate * u_dt);
-  float grown = mix(afterReaction, neighborAvg, spreadWeight) * u_totalScale;
-
-  return half4(half3(grown, 0.0, 0.0), half(1.0));
-}
-`;
-var MEDIUM_TRACK_ADVECT_SHADER = `
-${MEDIUM_ADVECT_UNIFORMS}
-uniform float u_decay;
-
-half4 main(float2 xy) {
-${MEDIUM_ADVECT_VELOCITY}
-  float2 back = xy - vel * u_dt;
-  half4 prev = u_dye.eval(float2(back.x, u_dyeSize.y - back.y));
-  float3 decayed = float3(prev.rgb) * exp(-u_decay * u_dt);
-  return half4(half3(decayed), half(1.0));
-}
-`;
-
-// src/medium/composite-shader.ts
-var VG_CUBIC_WEIGHTS = `
-float4 vgCubicWeights(float v) {
-  float4 n = float4(1.0, 2.0, 3.0, 4.0) - v;
-  float4 s = n * n * n;
-  float x = s.x;
-  float y = s.y - 4.0 * s.x;
-  float z = s.z - 4.0 * s.y + 6.0 * s.x;
-  float w = 6.0 - x - y - z;
-  return float4(x, y, z, w) * (1.0 / 6.0);
-}
-`;
-function vgBicubicSampler(fnName, textureName) {
-  return `
-half4 ${fnName}(float2 px) {
-  float2 shifted = px - 0.5;
-  float2 fxy = fract(shifted);
-  float2 base = shifted - fxy;
-  float4 xw = vgCubicWeights(fxy.x);
-  float4 yw = vgCubicWeights(fxy.y);
-  float2 sx = float2(xw.x + xw.y, xw.z + xw.w);
-  float2 sy = float2(yw.x + yw.y, yw.z + yw.w);
-  float2 offsetX = float2(base.x - 0.5 + xw.y / sx.x, base.x + 1.5 + xw.w / sx.y);
-  float2 offsetY = float2(base.y - 0.5 + yw.y / sy.x, base.y + 1.5 + yw.w / sy.y);
-  half4 s00 = ${textureName}.eval(float2(offsetX.x, offsetY.x));
-  half4 s10 = ${textureName}.eval(float2(offsetX.y, offsetY.x));
-  half4 s01 = ${textureName}.eval(float2(offsetX.x, offsetY.y));
-  half4 s11 = ${textureName}.eval(float2(offsetX.y, offsetY.y));
-  float wx = sx.x / (sx.x + sx.y);
-  float wy = sy.x / (sy.x + sy.y);
-  return mix(mix(s11, s01, wx), mix(s10, s00, wx), wy);
-}
-`;
-}
-var VG_LIGHT = `
-float vgLightAmount(float2 xy, float2 lightPosFrac, float2 lightDir, float cosCone, float falloff, float2 resolution, float seed) {
-  float2 rel = xy - lightPosFrac * resolution;
-  // A cone of 180\xB0 or more is an edge strip: light spreads from a line, not a point.
-  if (cosCone <= -0.999) {
-    float depth = max(dot(rel, lightDir), 0.0);
-    return exp(-(depth / max(resolution.y, 1.0)) * falloff);
-  }
-  float dist = length(rel);
-  float2 dirN = dist > 1e-4 ? rel / dist : lightDir;
-  float cosAngle = dot(dirN, lightDir);
-  // A soft lobe with half intensity at the cone angle and no boundary at all: a lamp in haze has
-  // no drawn edge.
-  float lobe = log(0.5) / log(clamp(cosCone, 0.05, 0.999));
-  float edge = pow(max(cosAngle, 0.0), lobe);
-  float atten = exp(-(dist / max(resolution.y, 1.0)) * falloff);
-  if (edge * atten < 0.001) return 0.0;
-  // Static shafts inside the beam: brightness varies with the angle around the lamp, so streaks
-  // fan out from the source the way light through dusty air does.
-  float angle = atan(dirN.x * lightDir.y - dirN.y * lightDir.x, cosAngle);
-  float shafts = 0.6 + 0.32 * vgValueNoise(float2(angle * 14.0, seed)) + 0.18 * vgValueNoise(float2(angle * 33.0, seed + 5.3));
-  return edge * atten * clamp(shafts, 0.0, 1.0);
-}
-`;
-var MEDIUM_COMPOSITE_SHADER = `
-uniform shader u_vapor;
-uniform shader u_condensate;
-uniform shader u_track;
-uniform shader u_shadow;
-uniform float2 u_dyeScale;
-uniform float3 u_lab0;
-uniform float3 u_lab1;
-uniform float3 u_lab2;
-uniform float3 u_labBg;
-uniform float3 u_labCondensate;
-uniform float  u_baseWeight;
-uniform float  u_condensateTint;
-uniform float  u_condensateGain;
-uniform float  u_farScale;
-uniform float2 u_farOffset;
-uniform float  u_farBlurRadius;
-uniform float  u_farWeight;
-uniform float  u_gravityBoost;
-uniform float  u_gravityBoostStart;
-uniform float3 u_channelScatter;
-uniform float2 u_light0Pos;
-uniform float2 u_light0Dir;
-uniform float  u_light0CosCone;
-uniform float  u_light0Falloff;
-uniform float3 u_light0Color;
-uniform float  u_light0Intensity;
-uniform float2 u_light1Pos;
-uniform float2 u_light1Dir;
-uniform float  u_light1CosCone;
-uniform float  u_light1Falloff;
-uniform float3 u_light1Color;
-uniform float  u_light1Intensity;
-uniform float2 u_light2Pos;
-uniform float2 u_light2Dir;
-uniform float  u_light2CosCone;
-uniform float  u_light2Falloff;
-uniform float3 u_light2Color;
-uniform float  u_light2Intensity;
-uniform float  u_trackLightFloor;
-
-${VG_OKLAB_TO_SRGB}
-${VG_CUBIC_WEIGHTS}
-${vgBicubicSampler("vgBicubicVapor", "u_vapor")}
-${vgBicubicSampler("vgBicubicCondensate", "u_condensate")}
-${VG_VALUE_NOISE}
-${VG_LIGHT}
-
-half4 main(float2 xy) {
-  float2 baseSrc = xy * u_dyeScale;
-
-  // Near plane \u2014 the calibrated look lives here. Bicubic (see the file header) on vapor and
-  // condensate; track stays a plain bilinear read.
-  half4 vapor = vgBicubicVapor(baseSrc);
-  half4 condensate = vgBicubicCondensate(baseSrc);
-  half4 track = u_track.eval(baseSrc);
-
-  // Far plane \u2014 the identical field, scaled and offset (see the file header). An 8-tap ring, not
-  // the near plane's \xB1x/\xB1y box: axis-aligned taps read the SAME column/row on both sides of any
-  // residual axis-aligned structure (a seam, a resize artifact), which is exactly how a straight
-  // line gets doubled into four parallel copies instead of softened away \u2014 measured directly via
-  // check-medium.mjs's isotropy gate (see its report). The ring is rotated a half-step (22.5\xB0) off
-  // the axes so no tap direction ever coincides with a grid row or column. Radius stays in the same
-  // far-plane texture-space unit as before (u_farBlurRadius, grid-px) \u2014 only the tap PATTERN
-  // changed, not what it measures in.
-  float2 farSrc = baseSrc * u_farScale + u_farOffset;
-  float2 ring0 = float2( 0.9238795,  0.3826834) * u_farBlurRadius;
-  float2 ring1 = float2( 0.3826834,  0.9238795) * u_farBlurRadius;
-  float2 ring2 = float2(-0.3826834,  0.9238795) * u_farBlurRadius;
-  float2 ring3 = float2(-0.9238795,  0.3826834) * u_farBlurRadius;
-  float2 ring4 = float2(-0.9238795, -0.3826834) * u_farBlurRadius;
-  float2 ring5 = float2(-0.3826834, -0.9238795) * u_farBlurRadius;
-  float2 ring6 = float2( 0.3826834, -0.9238795) * u_farBlurRadius;
-  float2 ring7 = float2( 0.9238795, -0.3826834) * u_farBlurRadius;
-  half4 vaporFar = (u_vapor.eval(farSrc + ring0) + u_vapor.eval(farSrc + ring1) +
-                     u_vapor.eval(farSrc + ring2) + u_vapor.eval(farSrc + ring3) +
-                     u_vapor.eval(farSrc + ring4) + u_vapor.eval(farSrc + ring5) +
-                     u_vapor.eval(farSrc + ring6) + u_vapor.eval(farSrc + ring7)) * half4(0.125);
-  half4 condensateFar = (u_condensate.eval(farSrc + ring0) + u_condensate.eval(farSrc + ring1) +
-                          u_condensate.eval(farSrc + ring2) + u_condensate.eval(farSrc + ring3) +
-                          u_condensate.eval(farSrc + ring4) + u_condensate.eval(farSrc + ring5) +
-                          u_condensate.eval(farSrc + ring6) + u_condensate.eval(farSrc + ring7)) * half4(0.125);
-
-  // Gravity's "denser layer at the bottom of the chamber" \u2014 a compositing-only boost (see
-  // MEDIUM_DEFAULTS.gravityBottomBoost): it scales how density already in the conserved buffers is
-  // DISPLAYED, never the buffers themselves, so it can't threaten water conservation. Shared by
-  // both planes: the chamber's floor is denser everywhere along its depth, not just up close.
-  //
-  // Verified with a headless render, not assumed: ramping this with xy.y directly lit up the TOP
-  // of the frame, not the bottom (contentTexture's own orientation contract flips y once more
-  // between this pass and the final scene \u2014 see the file header) \u2014 hence the 1.0 - below.
-  float bottomFrac = 1.0 - xy.y / u_resolution.y;
-  float bottomT = smoothstep(u_gravityBoostStart, 1.0, bottomFrac);
-  float bottomBoost = 1.0 + u_gravityBoost * bottomT;
-
-  float gasR = (float(vapor.r) + float(vaporFar.r) * u_farWeight) * bottomBoost;
-  float gasG = (float(vapor.g) + float(vaporFar.g) * u_farWeight) * bottomBoost;
-  float gasB = (float(vapor.b) + float(vaporFar.b) * u_farWeight) * bottomBoost;
-  float w0 = gasR + float(track.r);
-  float w1 = gasG + float(track.g);
-  float w2 = gasB + float(track.b);
-  float wBg = u_baseWeight;
-
-  // A faint condensate hint from the LOCAL vapor, not its own color (droplets scatter light
-  // rather than tint it) \u2014 a fraction of the way from white to the vapor tone sampled right here.
-  float vaporLocal = max(w0 + w1 + w2, 1e-4);
-  float3 vaporHue = (u_lab0 * w0 + u_lab1 * w1 + u_lab2 * w2) / vaporLocal;
-  float3 condensateLab = mix(u_labCondensate, vaporHue, u_condensateTint);
-  float wCondensate =
-    (float(condensate.r) + float(condensateFar.r) * u_farWeight) * u_condensateGain * bottomBoost;
-
-  float total = max(w0 + w1 + w2 + wBg + wCondensate, 1e-4);
-  float3 mixLab =
-    (u_labBg * wBg + u_lab0 * w0 + u_lab1 * w1 + u_lab2 * w2 + condensateLab * wCondensate) / total;
-  // The dark ambient base \u2014 this is where the OLD mechanism stops (see the file header on
-  // VG_LIGHT): unclamped here, clamped once at the very end, after the lit layer adds in.
-  float3 rgbLinearBase = vgOklabToLinear(mixLab);
-
-  // Spotlights reach this point dimmed by the gas in front of them (shadow-shader.ts).
-  half4 shadow = u_shadow.eval(baseSrc);
-  float light0 = vgLightAmount(xy, u_light0Pos, u_light0Dir, u_light0CosCone, u_light0Falloff, u_resolution, 1.7) * u_light0Intensity;
-  float light1 = vgLightAmount(xy, u_light1Pos, u_light1Dir, u_light1CosCone, u_light1Falloff, u_resolution, 4.1) * u_light1Intensity
-    * float(shadow.r);
-  float light2 = vgLightAmount(xy, u_light2Pos, u_light2Dir, u_light2CosCone, u_light2Falloff, u_resolution, 8.3) * u_light2Intensity
-    * float(shadow.g);
-  float3 illum = u_light0Color * light0 + u_light1Color * light1 + u_light2Color * light2;
-
-  float totalScatter = gasR * u_channelScatter.x + gasG * u_channelScatter.y + gasB * u_channelScatter.z;
-  float fogDensity = totalScatter + wCondensate;
-  float mist = 0.006 + fogDensity * 0.2;
-
-  // TRACKS: lit the same way as the mist, plus a floor so a track already on screen never vanishes
-  // entirely just because it drifted out of a cone (a fresh ionization trail reads brighter than
-  // ambient mist in a real chamber). The floor is added to ITS OWN color, not multiplied into illum:
-  // illum is exactly [0,0,0] in a fully unlit spot (every light's amount is 0 there), so a floor
-  // multiplied by illum would vanish exactly where it exists to help \u2014 it needs a color of its own
-  // (a neutral, self-luminous glow) rather than borrowing whichever light happens to be nearby.
-  float trackDensity = max(float(track.r), max(float(track.g), float(track.b)));
-  float3 trackGlow = (1.0 - exp(-trackDensity * 0.4)) * (illum + float3(u_trackLightFloor)) * 0.08;
-
-  float3 rgbLinear = rgbLinearBase * 0.025 + illum * mist + trackGlow;
-  rgbLinear = float3(1.0) - exp(-rgbLinear * 1.0);
-  float3 srgb = vgLinearToSrgb(rgbLinear);
-  return half4(half3(srgb), half(1.0));
-}
-`;
-
-// src/medium/emit-shader.ts
-var MEDIUM_EMIT_SHADER = `
-uniform float2 u_source;
-uniform float2 u_head;
-uniform float  u_headWidth;
-uniform float  u_tailWidth;
-uniform float  u_raggedAmp;
-uniform float  u_raggedFreq;
-uniform float  u_settle;
-uniform float  u_tailDim;
-uniform float  u_intensity;
-uniform float  u_seed;
-
-${VG_VALUE_NOISE}
-
-half4 main(float2 xy) {
-  float2 dir = u_head - u_source;
-  float len = max(length(dir), 1.0);
-  float2 side = float2(-dir.y, dir.x) / len;
-
-  float best = 0.0;
-  const int STEPS = 12;
-  for (int i = 0; i < STEPS; i++) {
-    float s = float(i) / float(STEPS - 1);
-    float tailness = 1.0 - s;
-    float ragged = u_raggedAmp * tailness * vgValueNoise(float2(s * u_raggedFreq + u_seed, u_seed * 3.7));
-    float2 p = mix(u_source, u_head, s) + side * ragged + float2(0.0, u_settle * tailness * tailness);
-    float w = max(mix(u_tailWidth, u_headWidth, s), 0.5);
-    float amp = mix(u_tailDim, 1.0, s);
-    float d = length(xy - p);
-    float v = amp * exp(-(d * d) / (2.0 * w * w));
-    best = max(best, v);
-  }
-
-  float3 dye = float3(best * u_intensity);
-  return half4(half3(dye), half(1.0));
-}
-`;
-
-// src/medium/shadow-shader.ts
-var MEDIUM_SHADOW_SHADER = `
-uniform shader u_vapor;
-uniform shader u_condensate;
-uniform float  u_condensateGain;
-uniform float2 u_light1Grid;
-uniform float2 u_light2Grid;
-uniform float  u_extinction;
-
-float vgOpticalDepth(float2 p, float2 lightP) {
-  float2 toLight = lightP - p;
-  float optical = 0.0;
-  for (int i = 1; i <= 24; i++) {
-    float2 q = p + toLight * (float(i) / 24.0);
-    float inside = step(0.0, q.x) * step(q.x, u_resolution.x) * step(0.0, q.y) * step(q.y, u_resolution.y);
-    half4 v = u_vapor.eval(q);
-    half4 c = u_condensate.eval(q);
-    optical += inside * (float(v.r + v.g + v.b) + float(c.r) * u_condensateGain);
-  }
-  return optical * length(toLight) / 24.0 / max(u_resolution.y, 1.0);
-}
-
-half4 main(float2 xy) {
-  float2 p = float2(xy.x, u_resolution.y - xy.y);
-  float t1 = exp(-vgOpticalDepth(p, u_light1Grid) * u_extinction);
-  float t2 = exp(-vgOpticalDepth(p, u_light2Grid) * u_extinction);
-  return half4(half(t1), half(t2), half(0.0), half(1.0));
-}
-`;
-
-// src/web/track-layer.ts
-function trackLayerFade(age, life) {
-  if (life <= 0) return 0;
-  const t = Math.min(Math.max(age / life, 0), 1);
-  return (1 - t) ** MEDIUM_TRACK_LAYER_FADE_GAMMA;
-}
-function trackLayerSigmaMul(age, broaden) {
-  return Math.sqrt(1 + broaden * Math.max(age, 0));
-}
-function hash01(n) {
-  const s = Math.sin(n * 91.3458) * 47453.5453;
-  return s - Math.floor(s);
-}
-function curlVelocityJS(px, py, phase) {
-  const e = 0.6;
-  const px1 = vgPotentialJS(px + e, py, phase);
-  const px0 = vgPotentialJS(px - e, py, phase);
-  const py1 = vgPotentialJS(px, py + e, phase);
-  const py0 = vgPotentialJS(px, py - e, phase);
-  return [(py1 - py0) / (2 * e), -(px1 - px0) / (2 * e)];
-}
-var CURL_SAMPLE_SCALE = 40;
-var PHASE_WRAP = 1e4;
-function createTrackLayer() {
-  let tracks = [];
-  let phase = 0;
-  function step(dt, emissions) {
-    phase = (phase + dt) % PHASE_WRAP;
-    const next = [];
-    for (const track of tracks) {
-      const life = MEDIUM_TRACK_LAYER_LIFE_SECONDS[track.emission.kind];
-      const age = track.age + dt;
-      if (age >= life) continue;
-      if (age <= 0) {
-        next.push({ ...track, age });
-        continue;
-      }
-      const midX = track.emission.source[0] + Math.cos(track.emission.angle) * track.emission.lengthFrac * 0.5;
-      const midY = track.emission.source[1] + Math.sin(track.emission.angle) * track.emission.lengthFrac * 0.5;
-      const [curlX, curlY] = curlVelocityJS(midX * CURL_SAMPLE_SCALE, midY * CURL_SAMPLE_SCALE, phase);
-      const activeDt = Math.min(dt, age);
-      next.push({
-        emission: track.emission,
-        age,
-        driftX: track.driftX + curlX * MEDIUM_TRACK_LAYER_CURL_PUSH * activeDt,
-        driftY: track.driftY + (curlY * MEDIUM_TRACK_LAYER_CURL_PUSH - MEDIUM_TRACK_LAYER_GRAVITY_SAG) * activeDt
-      });
-    }
-    let burstIndex = 0;
-    for (const emission of emissions) {
-      let age = 0;
-      if (emission.kind === "alpha") {
-        if (burstIndex >= MEDIUM_TRACK_LAYER_BURST_ACCENT) {
-          age = -hash01(emission.seed * 3.17 + burstIndex) * MEDIUM_TRACK_LAYER_BURST_SPREAD;
-        }
-        burstIndex += 1;
-      }
-      next.push({ emission, age, driftX: 0, driftY: 0 });
-    }
-    tracks = next.length > MEDIUM_TRACK_LAYER_MAX_TRACKS ? next.slice(next.length - MEDIUM_TRACK_LAYER_MAX_TRACKS) : next;
-    return tracks;
-  }
-  return { step };
-}
-var TRACK_LAYER_VERTEX_SOURCE = `#version 300 es
-layout(location = 0) in vec2 a_corner;
-layout(location = 1) in vec4 a_geom;
-layout(location = 2) in vec4 a_span;
-layout(location = 3) in vec4 a_path;
-layout(location = 4) in vec4 a_grain;
-
-uniform vec2 u_resolution;
-uniform float u_trackLightFloor;
-uniform sampler2D u_shadow;
-uniform vec2 u_light0Pos;
-uniform vec2 u_light0Dir;
-uniform float u_light0CosCone;
-uniform float u_light0Falloff;
-uniform vec3 u_light0Color;
-uniform float u_light0Intensity;
-uniform vec2 u_light1Pos;
-uniform vec2 u_light1Dir;
-uniform float u_light1CosCone;
-uniform float u_light1Falloff;
-uniform vec3 u_light1Color;
-uniform float u_light1Intensity;
-uniform vec2 u_light2Pos;
-uniform vec2 u_light2Dir;
-uniform float u_light2CosCone;
-uniform float u_light2Falloff;
-uniform vec3 u_light2Color;
-uniform float u_light2Intensity;
-
-out vec2 v_local;
-flat out vec4 v_span;
-flat out vec4 v_path;
-flat out vec4 v_grain;
-flat out float v_reach;
-out vec3 v_illum;
-
-float vgHash21(vec2 p) {
-  float h = dot(p, vec2(127.1, 311.7));
-  return fract(sin(h) * 43758.5453123);
-}
-
-float vgValueNoise(vec2 p) {
-  vec2 i = floor(p);
-  vec2 f = fract(p);
-  float a = vgHash21(i);
-  float b = vgHash21(i + vec2(1.0, 0.0));
-  float c = vgHash21(i + vec2(0.0, 1.0));
-  float d = vgHash21(i + vec2(1.0, 1.0));
-  vec2 u = f * f * (3.0 - 2.0 * f);
-  return mix(mix(a, b, u.x), mix(c, d, u.x), u.y) * 2.0 - 1.0;
-}
-
-// Keep in step with vgLightAmount in composite-shader.ts.
-float vgLightAmount(vec2 xy, vec2 lightPosFrac, vec2 lightDir, float cosCone, float falloff, vec2 resolution, float seed) {
-  vec2 rel = xy - lightPosFrac * resolution;
-  if (cosCone <= -0.999) {
-    float depth = max(dot(rel, lightDir), 0.0);
-    return exp(-(depth / max(resolution.y, 1.0)) * falloff);
-  }
-  float dist = length(rel);
-  vec2 dirN = dist > 1e-4 ? rel / dist : lightDir;
-  float cosAngle = dot(dirN, lightDir);
-  float lobe = log(0.5) / log(clamp(cosCone, 0.05, 0.999));
-  float edge = pow(max(cosAngle, 0.0), lobe);
-  float atten = exp(-(dist / max(resolution.y, 1.0)) * falloff);
-  if (edge * atten < 0.001) return 0.0;
-  float angle = atan(dirN.x * lightDir.y - dirN.y * lightDir.x, cosAngle);
-  float shafts = 0.6 + 0.32 * vgValueNoise(vec2(angle * 14.0, seed)) + 0.18 * vgValueNoise(vec2(angle * 33.0, seed + 5.3));
-  return edge * atten * clamp(shafts, 0.0, 1.0);
-}
-
-void main() {
-  vec2 dir = a_geom.zw;
-  vec2 side = vec2(-dir.y, dir.x);
-  // Beads widen sigma by up to 20%; 3.5 sigma leaves under 1% of the core outside the quad.
-  float reach = max(a_span.z, a_span.w) * 1.2 * 3.5 + 1.5;
-  float margin = reach + a_path.x * 1.7;
-  float u = mix(a_span.y - reach, a_span.x + reach, a_corner.y);
-  float s = a_corner.x * margin;
-  vec2 pos = a_geom.xy + dir * u + side * s;
-  v_local = vec2(u, s);
-  v_span = a_span;
-  v_path = a_path;
-  v_grain = a_grain;
-  v_reach = reach;
-  // Lit per corner: light varies over hundreds of px, a track is a few px wide. The backdrop
-  // target stores the scene top row at y = 0; lights use y up.
-  vec2 xy = vec2(pos.x, u_resolution.y - pos.y);
-  // The same gas shadow the composite applies to the spotlights (shadow-shader.ts, y up).
-  vec4 shadow = texture(u_shadow, xy / u_resolution);
-  float light0 = vgLightAmount(xy, u_light0Pos, u_light0Dir, u_light0CosCone, u_light0Falloff, u_resolution, 1.7) * u_light0Intensity;
-  float light1 = vgLightAmount(xy, u_light1Pos, u_light1Dir, u_light1CosCone, u_light1Falloff, u_resolution, 4.1) * u_light1Intensity * shadow.r;
-  float light2 = vgLightAmount(xy, u_light2Pos, u_light2Dir, u_light2CosCone, u_light2Falloff, u_resolution, 8.3) * u_light2Intensity * shadow.g;
-  v_illum = u_light0Color * light0 + u_light1Color * light1 + u_light2Color * light2 + vec3(u_trackLightFloor);
-  gl_Position = vec4((pos / u_resolution) * 2.0 - 1.0, 0.0, 1.0);
-}
-`;
-var TRACK_LAYER_FRAGMENT_SOURCE = `#version 300 es
-precision highp float;
-
-in vec2 v_local;
-flat in vec4 v_span;
-flat in vec4 v_path;
-flat in vec4 v_grain;
-flat in float v_reach;
-in vec3 v_illum;
-
-out vec4 fragColor;
-
-float vgHash(float a, float b) {
-  uint x = floatBitsToUint(a) * 0x9E3779B1u ^ (floatBitsToUint(b) + 0x7F4A7C15u);
-  x ^= x >> 16;
-  x *= 0x7FEB352Du;
-  x ^= x >> 15;
-  x *= 0x846CA68Bu;
-  x ^= x >> 16;
-  return float(x) * (1.0 / 4294967295.0);
-}
-
-float vgNoise1(float x, float salt) {
-  float i = floor(x);
-  float f = fract(x);
-  float u = f * f * (3.0 - 2.0 * f);
-  return mix(vgHash(i, salt), vgHash(i + 1.0, salt), u);
-}
-
-void main() {
-  float len = v_span.x;
-  float start = v_span.y;
-  float sigma0 = v_span.z;
-  float sigma1 = v_span.w;
-  float wiggleAmp = v_path.x;
-  float wiggleFreq = v_path.y;
-  float amp = v_path.z;
-  float seed = v_path.w;
-  float beadPx = v_grain.x;
-  float dropPx = v_grain.y;
-  float dropChance = v_grain.z;
-  float blur = v_grain.w;
-
-  float u = v_local.x;
-  float s = v_local.y;
-  float t = clamp((u - start) / max(len - start, 1.0), 0.0, 1.0);
-
-  float wiggle = 0.0;
-  if (wiggleAmp > 0.0) {
-    float x = u * wiggleFreq;
-    wiggle = wiggleAmp * smoothstep(0.0, 0.2, t) *
-      ((vgNoise1(x, seed) - 0.5) * 2.0 + (vgNoise1(x * 3.1, seed + 1.0) - 0.5) * 0.7);
-  }
-  float across = s - wiggle;
-  if (abs(across) > v_reach) discard;
-
-  float bead = vgNoise1(u / beadPx, seed + 2.0);
-  // Blur (age, defocus) washes the beads out rather than stretching them into ribs.
-  float sigma = mix(sigma0, sigma1, t * t) * (1.0 + (bead - 0.5) * 0.4 / blur);
-  float beyond = u < start ? start - u : max(u - len, 0.0);
-  float core = exp(-0.5 * (across * across + beyond * beyond) / (sigma * sigma));
-  float along = 1.0 - 0.35 / blur * vgNoise1(u / (beadPx * 2.3), seed + 3.0);
-
-  float drops = 0.0;
-  float cell0 = floor(u / dropPx);
-  for (int k = -1; k <= 1; k++) {
-    float c = cell0 + float(k);
-    if (vgHash(c, seed + 4.0) > dropChance) continue;
-    float cu = (c + vgHash(c, seed + 5.0)) * dropPx;
-    if (cu < start || cu > len) continue;
-    float cs = (vgHash(c, seed + 6.0) + vgHash(c, seed + 7.0) - 1.0) * 1.7 * sigma + wiggle;
-    float r = max(0.7, sigma * mix(0.35, 0.8, vgHash(c, seed + 8.0)));
-    float dx = u - cu;
-    float dy = s - cs;
-    drops += mix(0.35, 1.0, vgHash(c, seed + 9.0)) * exp(-0.5 * (dx * dx + dy * dy) / (r * r));
-  }
-
-  float lum = amp * (core * along + drops * 0.7 / (blur * blur));
-  if (lum < 0.002) discard;
-
-  vec3 glow = lum * v_illum;
-  fragColor = vec4(vec3(1.0) - exp(-glow), 1.0);
-}
-`;
-var FLOATS_PER_INSTANCE = 16;
-var DEFOCUS_FROM_DEPTH = 0.7;
-var DEFOCUS_MAX = 2.4;
-function buildTrackLayerInstances(tracks, contentWidth, contentHeight, amount) {
-  const minDim = Math.min(contentWidth, contentHeight);
-  const data = new Float32Array(tracks.length * FLOATS_PER_INSTANCE);
-  let count = 0;
-  if (amount <= 0) return { data, count };
-  for (const track of tracks) {
-    if (track.age < 0) continue;
-    const e = track.emission;
-    const fade = trackLayerFade(track.age, MEDIUM_TRACK_LAYER_LIFE_SECONDS[e.kind]);
-    if (fade <= 1e-4) continue;
-    const look = MEDIUM_TRACK_LAYER_LOOK[e.kind];
-    const sigmaMul = trackLayerSigmaMul(track.age, look.broaden);
-    const near = Math.max(0, (e.depth - DEFOCUS_FROM_DEPTH) / (1 - DEFOCUS_FROM_DEPTH));
-    const defocus = 1 + (DEFOCUS_MAX - 1) * near * near;
-    const sigma0 = Math.max(look.sigmaFrac * minDim, 0.6) * sigmaMul * defocus;
-    const o = count * FLOATS_PER_INSTANCE;
-    data[o + 0] = e.source[0] * contentWidth + track.driftX * minDim;
-    data[o + 1] = e.source[1] * contentHeight - track.driftY * minDim;
-    data[o + 2] = Math.cos(e.angle);
-    data[o + 3] = Math.sin(e.angle);
-    const len = e.lengthFrac * minDim;
-    data[o + 4] = len;
-    data[o + 5] = Math.min(look.startFrac * minDim, len * 0.5);
-    data[o + 6] = sigma0;
-    data[o + 7] = sigma0 * look.endSigmaMul;
-    data[o + 8] = e.raggedFrac > 0 ? look.wiggleFrac * minDim : 0;
-    data[o + 9] = e.raggedFreq / Math.max(len, 1);
-    data[o + 10] = e.intensity * look.gain * fade * amount / (sigmaMul ** 0.7 * defocus);
-    data[o + 11] = e.seed;
-    data[o + 12] = look.beadFrac * minDim;
-    data[o + 13] = look.dropletFrac * minDim;
-    data[o + 14] = look.dropletChance;
-    data[o + 15] = sigmaMul * defocus;
-    count += 1;
-  }
-  return { data, count };
-}
-function compile(gl, type, source, label) {
-  const shader = gl.createShader(type);
-  if (!shader) throw new Error(`vireuikit: track layer ${label} shader creation failed`);
-  gl.shaderSource(shader, source);
-  gl.compileShader(shader);
-  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-    throw new Error(`vireuikit: track layer ${label} shader failed:
-${gl.getShaderInfoLog(shader) ?? ""}`);
-  }
-  return shader;
-}
-function createTrackLayerProgram(gl) {
-  const vertex = compile(gl, gl.VERTEX_SHADER, TRACK_LAYER_VERTEX_SOURCE, "vertex");
-  const fragment = compile(gl, gl.FRAGMENT_SHADER, TRACK_LAYER_FRAGMENT_SOURCE, "fragment");
-  const program = gl.createProgram();
-  if (!program) throw new Error("vireuikit: track layer program creation failed");
-  gl.attachShader(program, vertex);
-  gl.attachShader(program, fragment);
-  gl.linkProgram(program);
-  gl.deleteShader(vertex);
-  gl.deleteShader(fragment);
-  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-    throw new Error(`vireuikit: track layer program failed to link:
-${gl.getProgramInfoLog(program) ?? ""}`);
-  }
-  const loc = web.locationCache(gl, program);
-  const quadBuffer = gl.createBuffer();
-  gl.bindBuffer(gl.ARRAY_BUFFER, quadBuffer);
-  gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, 0, 1, 0, -1, 1, 1, 1]), gl.STATIC_DRAW);
-  const instanceBuffer = gl.createBuffer();
-  const vao = gl.createVertexArray();
-  gl.bindVertexArray(vao);
-  gl.bindBuffer(gl.ARRAY_BUFFER, quadBuffer);
-  gl.enableVertexAttribArray(0);
-  gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
-  const stride = FLOATS_PER_INSTANCE * 4;
-  gl.bindBuffer(gl.ARRAY_BUFFER, instanceBuffer);
-  for (let location = 1; location <= 4; location += 1) {
-    gl.enableVertexAttribArray(location);
-    gl.vertexAttribPointer(location, 4, gl.FLOAT, false, stride, (location - 1) * 16);
-    gl.vertexAttribDivisor(location, 1);
-  }
-  gl.bindVertexArray(null);
-  function bindLight(slot, light) {
-    const position = light?.position ?? [0, 0];
-    const direction = light?.direction ?? [0, 1];
-    const dirLen = Math.hypot(direction[0], direction[1]) || 1;
-    web.setUniform(gl, loc(`u_light${slot}Pos`), position);
-    web.setUniform(gl, loc(`u_light${slot}Dir`), [direction[0] / dirLen, direction[1] / dirLen]);
-    web.setUniform(gl, loc(`u_light${slot}CosCone`), Math.cos(light?.coneAngle ?? 0));
-    web.setUniform(gl, loc(`u_light${slot}Falloff`), light?.falloff ?? 0);
-    web.setUniform(gl, loc(`u_light${slot}Color`), light?.color ?? [0, 0, 0]);
-    web.setUniform(gl, loc(`u_light${slot}Intensity`), light?.intensity ?? 0);
-  }
-  function draw(contentWidth, contentHeight, data, count, trackLightFloor, lights, shadow) {
-    if (count <= 0) return;
-    gl.useProgram(program);
-    gl.bindVertexArray(vao);
-    gl.bindBuffer(gl.ARRAY_BUFFER, instanceBuffer);
-    gl.bufferData(gl.ARRAY_BUFFER, data.subarray(0, count * FLOATS_PER_INSTANCE), gl.DYNAMIC_DRAW);
-    web.setUniform(gl, loc("u_resolution"), [contentWidth, contentHeight]);
-    web.setUniform(gl, loc("u_trackLightFloor"), trackLightFloor);
-    for (let slot = 0; slot < 3; slot += 1) bindLight(slot, lights[slot]);
-    web.bindTextureAt(gl, 0, shadow, program, "u_shadow");
-    gl.enable(gl.BLEND);
-    gl.blendFunc(gl.ONE, gl.ONE);
-    gl.disable(gl.DEPTH_TEST);
-    gl.viewport(0, 0, contentWidth, contentHeight);
-    gl.drawArraysInstanced(gl.TRIANGLE_STRIP, 0, 4, count);
-    gl.bindVertexArray(null);
-  }
-  function destroy() {
-    gl.deleteBuffer(quadBuffer);
-    gl.deleteBuffer(instanceBuffer);
-    gl.deleteVertexArray(vao);
-    gl.deleteProgram(program);
-  }
-  return { draw, destroy };
-}
-
-// src/web/medium.ts
-function pickDyeFormat(gl) {
-  const hasFloat = gl.getExtension("EXT_color_buffer_float") !== null;
-  return hasFloat ? { internalFormat: gl.RGBA16F, type: gl.HALF_FLOAT } : { internalFormat: gl.RGBA8, type: gl.UNSIGNED_BYTE };
-}
-function createMediumRuntime(gl, vertexSource) {
-  const format = pickDyeFormat(gl);
-  const vaporForwardProgram = web.createProgram(gl, vertexSource, vireglass.toGLSL(MEDIUM_VAPOR_FORWARD_SHADER));
-  const vaporCorrectProgram = web.createProgram(gl, vertexSource, vireglass.toGLSL(MEDIUM_VAPOR_CORRECT_SHADER));
-  const vaporReactProgram = web.createProgram(gl, vertexSource, vireglass.toGLSL(MEDIUM_VAPOR_REACT_SHADER));
-  const condensateForwardProgram = web.createProgram(gl, vertexSource, vireglass.toGLSL(MEDIUM_CONDENSATE_FORWARD_SHADER));
-  const condensateCorrectProgram = web.createProgram(gl, vertexSource, vireglass.toGLSL(MEDIUM_CONDENSATE_CORRECT_SHADER));
-  const condensateReactProgram = web.createProgram(gl, vertexSource, vireglass.toGLSL(MEDIUM_CONDENSATE_REACT_SHADER));
-  const trackAdvectProgram = web.createProgram(gl, vertexSource, vireglass.toGLSL(MEDIUM_TRACK_ADVECT_SHADER));
-  const compositeProgram = web.createProgram(gl, vertexSource, vireglass.toGLSL(MEDIUM_COMPOSITE_SHADER));
-  const seedProgram = web.createProgram(gl, vertexSource, vireglass.toGLSL(MEDIUM_SEED_SHADER));
-  const emitProgram = web.createProgram(gl, vertexSource, vireglass.toGLSL(MEDIUM_EMIT_SHADER));
-  const resampleProgram = web.createProgram(gl, vertexSource, vireglass.toGLSL(MEDIUM_RESAMPLE_SHADER));
-  const shadowProgram = web.createProgram(gl, vertexSource, vireglass.toGLSL(MEDIUM_SHADOW_SHADER));
-  const trackLayerProgram = createTrackLayerProgram(gl);
-  const trackLayer = createTrackLayer();
-  let liveTracks = [];
-  const vaporForwardLoc = web.locationCache(gl, vaporForwardProgram);
-  const vaporCorrectLoc = web.locationCache(gl, vaporCorrectProgram);
-  const vaporReactLoc = web.locationCache(gl, vaporReactProgram);
-  const condensateForwardLoc = web.locationCache(gl, condensateForwardProgram);
-  const condensateCorrectLoc = web.locationCache(gl, condensateCorrectProgram);
-  const condensateReactLoc = web.locationCache(gl, condensateReactProgram);
-  const trackAdvectLoc = web.locationCache(gl, trackAdvectProgram);
-  const compositeLoc = web.locationCache(gl, compositeProgram);
-  const seedLoc = web.locationCache(gl, seedProgram);
-  const emitLoc = web.locationCache(gl, emitProgram);
-  const resampleLoc = web.locationCache(gl, resampleProgram);
-  const shadowLoc = web.locationCache(gl, shadowProgram);
-  let gridW = 0;
-  let gridH = 0;
-  let vapor = null;
-  let condensate = null;
-  let track = null;
-  let vaporForward = null;
-  let vaporCorrected = null;
-  let condensateForward = null;
-  let condensateCorrected = null;
-  let shadow = null;
-  let front = 0;
-  function makeTarget(w, h) {
-    const texture = web.createTexture(gl, {
-      width: w,
-      height: h,
-      internalFormat: format.internalFormat,
-      type: format.type,
-      // REPEAT: a domain with no border — see TextureOptions.wrap. All buffers carry the same
-      // field, so the border needs to behave identically for each of them, or vapor would wrap
-      // while condensate or a track at the same coordinate cuts off. The MacCormack limiter also
-      // reads neighbors across this same border — it needs REPEAT exactly as much as transport does.
-      wrap: gl.REPEAT
-    });
-    const fbo = web.createFramebuffer(gl, texture);
-    return { texture, fbo };
-  }
-  function clearTarget(target, w, h) {
-    gl.bindFramebuffer(gl.FRAMEBUFFER, target.fbo);
-    gl.viewport(0, 0, w, h);
-    gl.clearColor(0, 0, 0, 1);
-    gl.clear(gl.COLOR_BUFFER_BIT);
-    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-  }
-  function destroyPair(pair) {
-    if (!pair) return;
-    for (const t of pair) {
-      gl.deleteTexture(t.texture);
-      gl.deleteFramebuffer(t.fbo);
-    }
-  }
-  function destroyTarget(target) {
-    if (!target) return;
-    gl.deleteTexture(target.texture);
-    gl.deleteFramebuffer(target.fbo);
-  }
-  function destroyTargets() {
-    destroyPair(vapor);
-    destroyPair(condensate);
-    destroyPair(track);
-    destroyTarget(vaporForward);
-    destroyTarget(vaporCorrected);
-    destroyTarget(condensateForward);
-    destroyTarget(condensateCorrected);
-    destroyTarget(shadow);
-    vapor = null;
-    condensate = null;
-    track = null;
-    vaporForward = null;
-    vaporCorrected = null;
-    condensateForward = null;
-    condensateCorrected = null;
-    shadow = null;
-  }
-  function seed(w, h) {
-    if (!vapor || !condensate || !track) return;
-    gl.bindFramebuffer(gl.FRAMEBUFFER, vapor[front].fbo);
-    gl.viewport(0, 0, w, h);
-    gl.disable(gl.BLEND);
-    gl.useProgram(seedProgram);
-    web.setUniform(gl, seedLoc("u_resolution"), [w, h]);
-    web.setUniform(gl, seedLoc("u_spot0"), [w * 0.28, h * 0.64]);
-    web.setUniform(gl, seedLoc("u_spot1"), [w * 0.7, h * 0.32]);
-    web.setUniform(gl, seedLoc("u_spot2"), [w * 0.48, h * 0.84]);
-    web.setUniform(gl, seedLoc("u_spotRadius"), Math.max(w, h) * 0.18);
-    web.drawFullscreenTriangle(gl);
-    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-    clearTarget(condensate[0], w, h);
-    clearTarget(condensate[1], w, h);
-    clearTarget(track[0], w, h);
-    clearTarget(track[1], w, h);
-  }
-  function resample(src, srcW, srcH, dst, dstW, dstH) {
-    gl.bindFramebuffer(gl.FRAMEBUFFER, dst.fbo);
-    gl.viewport(0, 0, dstW, dstH);
-    gl.disable(gl.BLEND);
-    gl.useProgram(resampleProgram);
-    web.bindTextureAt(gl, 0, src.texture, resampleProgram, "u_src");
-    web.setUniform(gl, resampleLoc("u_srcSize"), [srcW, srcH]);
-    web.setUniform(gl, resampleLoc("u_resolution"), [dstW, dstH]);
-    web.drawFullscreenTriangle(gl);
-    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-  }
-  function resizeGrid(w, h) {
-    if (!vapor || !condensate || !track) return;
-    const oldVapor = vapor;
-    const oldCondensate = condensate;
-    const oldTrack = track;
-    const oldW = gridW;
-    const oldH = gridH;
-    const newVaporFront = makeTarget(w, h);
-    const newCondensateFront = makeTarget(w, h);
-    const newTrackFront = makeTarget(w, h);
-    resample(oldVapor[front], oldW, oldH, newVaporFront, w, h);
-    resample(oldCondensate[front], oldW, oldH, newCondensateFront, w, h);
-    resample(oldTrack[front], oldW, oldH, newTrackFront, w, h);
-    destroyTargets();
-    gridW = w;
-    gridH = h;
-    vapor = [newVaporFront, makeTarget(w, h)];
-    condensate = [newCondensateFront, makeTarget(w, h)];
-    track = [newTrackFront, makeTarget(w, h)];
-    vaporForward = makeTarget(w, h);
-    vaporCorrected = makeTarget(w, h);
-    condensateForward = makeTarget(w, h);
-    condensateCorrected = makeTarget(w, h);
-    shadow = makeTarget(w, h);
-    front = 0;
-    const areaRatio = w * h / (oldW * oldH);
-    waterTargetTotal *= areaRatio;
-  }
-  function ensureGrid(gridWidth, gridHeight) {
-    const w = Math.max(2, Math.round(gridWidth));
-    const h = Math.max(2, Math.round(gridHeight));
-    if (vapor && condensate && track && w === gridW && h === gridH) return;
-    if (!vapor || !condensate || !track) {
-      gridW = w;
-      gridH = h;
-      vapor = [makeTarget(w, h), makeTarget(w, h)];
-      condensate = [makeTarget(w, h), makeTarget(w, h)];
-      track = [makeTarget(w, h), makeTarget(w, h)];
-      vaporForward = makeTarget(w, h);
-      vaporCorrected = makeTarget(w, h);
-      condensateForward = makeTarget(w, h);
-      condensateCorrected = makeTarget(w, h);
-      shadow = makeTarget(w, h);
-      front = 0;
-      seed(w, h);
-      waterTargetTotal = readTarget(vapor[front]) + readTarget(condensate[front]);
-      waterScale = 1;
-      timeSinceRenorm = 0;
-      framesSinceRenorm = 0;
-      return;
-    }
-    resizeGrid(w, h);
-  }
-  function bindLightUniforms(slot, light) {
-    const position = light?.position ?? [0, 0];
-    const direction = light?.direction ?? [0, 1];
-    const dirLen = Math.hypot(direction[0], direction[1]) || 1;
-    web.setUniform(gl, compositeLoc(`u_light${slot}Pos`), position);
-    web.setUniform(gl, compositeLoc(`u_light${slot}Dir`), [direction[0] / dirLen, direction[1] / dirLen]);
-    web.setUniform(gl, compositeLoc(`u_light${slot}CosCone`), Math.cos(light?.coneAngle ?? 0));
-    web.setUniform(gl, compositeLoc(`u_light${slot}Falloff`), light?.falloff ?? 0);
-    web.setUniform(gl, compositeLoc(`u_light${slot}Color`), light?.color ?? [0, 0, 0]);
-    web.setUniform(gl, compositeLoc(`u_light${slot}Intensity`), light?.intensity ?? 0);
-  }
-  function bindVelocityUniforms(loc, dt, phase2, p, spatial) {
-    web.setUniform(gl, loc("u_dyeSize"), [gridW, gridH]);
-    web.setUniform(gl, loc("u_resolution"), [gridW, gridH]);
-    web.setUniform(gl, loc("u_dt"), dt);
-    web.setUniform(gl, loc("u_phase"), phase2);
-    web.setUniform(gl, loc("u_curlFreq"), p.curlFreq);
-    web.setUniform(gl, loc("u_advectSpeed"), p.advectSpeed);
-    web.setUniform(gl, loc("u_turbulence"), p.turbulence);
-    web.setUniform(gl, loc("u_vaporDrift"), p.gravityVaporDrift);
-    web.setUniform(gl, loc("u_spatial0"), [spatial[0].freqX, spatial[0].freqY, spatial[0].periodX, spatial[0].periodY]);
-    web.setUniform(gl, loc("u_spatial1"), [spatial[1].freqX, spatial[1].freqY, spatial[1].periodX, spatial[1].periodY]);
-    web.setUniform(gl, loc("u_spatial2"), [spatial[2].freqX, spatial[2].freqY, spatial[2].periodX, spatial[2].periodY]);
-    web.setUniform(gl, loc("u_spatial3"), [spatial[3].freqX, spatial[3].freqY, spatial[3].periodX, spatial[3].periodY]);
-  }
-  let phase = 0;
-  function wrapPhase(value) {
-    const wrapped = value % MEDIUM_TIME_PERIOD;
-    return wrapped < 0 ? wrapped + MEDIUM_TIME_PERIOD : wrapped;
-  }
-  const WATER_RENORM_INTERVAL_S = 1;
-  let waterTargetTotal = 0;
-  let waterScale = 1;
-  let timeSinceRenorm = 0;
-  let framesSinceRenorm = 0;
-  function step(dt, params = {}) {
-    if (!vapor || !condensate || !track || !vaporForward || !vaporCorrected || !condensateForward || !condensateCorrected || !shadow) {
-      return;
-    }
-    const p = { ...MEDIUM_DEFAULTS, ...params };
-    const spatial = computeMediumSpatialPeriods(gridW, gridH, p.curlFreq);
-    const clampedDt = Math.min(Math.max(dt, 0), 1 / 15);
-    phase = wrapPhase(phase + clampedDt * p.curlSpeed);
-    const back = front === 0 ? 1 : 0;
-    const gridSize = [gridW, gridH];
-    gl.viewport(0, 0, gridW, gridH);
-    gl.disable(gl.BLEND);
-    gl.bindFramebuffer(gl.FRAMEBUFFER, vaporForward.fbo);
-    gl.useProgram(vaporForwardProgram);
-    web.bindTextureAt(gl, 0, vapor[front].texture, vaporForwardProgram, "u_dye");
-    bindVelocityUniforms(vaporForwardLoc, clampedDt, phase, p, spatial);
-    web.drawFullscreenTriangle(gl);
-    gl.bindFramebuffer(gl.FRAMEBUFFER, condensateForward.fbo);
-    gl.useProgram(condensateForwardProgram);
-    web.bindTextureAt(gl, 0, condensate[front].texture, condensateForwardProgram, "u_dye");
-    bindVelocityUniforms(condensateForwardLoc, clampedDt, phase, p, spatial);
-    web.setUniform(gl, condensateForwardLoc("u_settleSpeed"), p.condensateSettleSpeed);
-    web.setUniform(gl, condensateForwardLoc("u_settleWiggle"), p.condensateSettleWiggle);
-    web.drawFullscreenTriangle(gl);
-    gl.bindFramebuffer(gl.FRAMEBUFFER, vaporCorrected.fbo);
-    gl.useProgram(vaporCorrectProgram);
-    web.bindTextureAt(gl, 0, vapor[front].texture, vaporCorrectProgram, "u_dye");
-    web.bindTextureAt(gl, 1, vaporForward.texture, vaporCorrectProgram, "u_forward");
-    web.setUniform(gl, vaporCorrectLoc("u_forwardSize"), gridSize);
-    bindVelocityUniforms(vaporCorrectLoc, clampedDt, phase, p, spatial);
-    web.drawFullscreenTriangle(gl);
-    gl.bindFramebuffer(gl.FRAMEBUFFER, condensateCorrected.fbo);
-    gl.useProgram(condensateCorrectProgram);
-    web.bindTextureAt(gl, 0, condensate[front].texture, condensateCorrectProgram, "u_dye");
-    web.bindTextureAt(gl, 1, condensateForward.texture, condensateCorrectProgram, "u_forward");
-    web.setUniform(gl, condensateCorrectLoc("u_forwardSize"), gridSize);
-    bindVelocityUniforms(condensateCorrectLoc, clampedDt, phase, p, spatial);
-    web.setUniform(gl, condensateCorrectLoc("u_settleSpeed"), p.condensateSettleSpeed);
-    web.setUniform(gl, condensateCorrectLoc("u_settleWiggle"), p.condensateSettleWiggle);
-    web.drawFullscreenTriangle(gl);
-    gl.bindFramebuffer(gl.FRAMEBUFFER, vapor[back].fbo);
-    gl.useProgram(vaporReactProgram);
-    web.bindTextureAt(gl, 0, vaporCorrected.texture, vaporReactProgram, "u_transported");
-    web.bindTextureAt(gl, 1, condensateCorrected.texture, vaporReactProgram, "u_condensateTransported");
-    web.setUniform(gl, vaporReactLoc("u_transportedSize"), gridSize);
-    web.setUniform(gl, vaporReactLoc("u_condensateTransportedSize"), gridSize);
-    web.setUniform(gl, vaporReactLoc("u_resolution"), gridSize);
-    web.setUniform(gl, vaporReactLoc("u_dt"), clampedDt);
-    web.setUniform(gl, vaporReactLoc("u_condensationRate"), p.condensationRate);
-    web.setUniform(gl, vaporReactLoc("u_condensationFloor"), p.condensationFloor);
-    web.setUniform(gl, vaporReactLoc("u_evaporationRate"), p.evaporationRate);
-    web.setUniform(gl, vaporReactLoc("u_totalScale"), waterScale);
-    web.drawFullscreenTriangle(gl);
-    gl.bindFramebuffer(gl.FRAMEBUFFER, condensate[back].fbo);
-    gl.useProgram(condensateReactProgram);
-    web.bindTextureAt(gl, 0, condensateCorrected.texture, condensateReactProgram, "u_transported");
-    web.bindTextureAt(gl, 1, vaporCorrected.texture, condensateReactProgram, "u_vaporTransported");
-    web.bindTextureAt(gl, 2, condensate[front].texture, condensateReactProgram, "u_dye");
-    web.setUniform(gl, condensateReactLoc("u_transportedSize"), gridSize);
-    web.setUniform(gl, condensateReactLoc("u_vaporTransportedSize"), gridSize);
-    web.setUniform(gl, condensateReactLoc("u_dyeSize"), gridSize);
-    web.setUniform(gl, condensateReactLoc("u_resolution"), gridSize);
-    web.setUniform(gl, condensateReactLoc("u_dt"), clampedDt);
-    web.setUniform(gl, condensateReactLoc("u_condensationRate"), p.condensationRate);
-    web.setUniform(gl, condensateReactLoc("u_condensationFloor"), p.condensationFloor);
-    web.setUniform(gl, condensateReactLoc("u_evaporationRate"), p.evaporationRate);
-    web.setUniform(gl, condensateReactLoc("u_spreadRate"), p.condensateSpreadRate);
-    web.setUniform(gl, condensateReactLoc("u_totalScale"), waterScale);
-    web.drawFullscreenTriangle(gl);
-    gl.bindFramebuffer(gl.FRAMEBUFFER, track[back].fbo);
-    gl.useProgram(trackAdvectProgram);
-    web.bindTextureAt(gl, 0, track[front].texture, trackAdvectProgram, "u_dye");
-    bindVelocityUniforms(trackAdvectLoc, clampedDt, phase, p, spatial);
-    web.setUniform(gl, trackAdvectLoc("u_decay"), p.decay);
-    web.drawFullscreenTriangle(gl);
-    gl.bindFramebuffer(gl.FRAMEBUFFER, shadow.fbo);
-    gl.useProgram(shadowProgram);
-    web.bindTextureAt(gl, 0, vapor[back].texture, shadowProgram, "u_vapor");
-    web.bindTextureAt(gl, 1, condensate[back].texture, shadowProgram, "u_condensate");
-    web.setUniform(gl, shadowLoc("u_vaporSize"), gridSize);
-    web.setUniform(gl, shadowLoc("u_condensateSize"), gridSize);
-    web.setUniform(gl, shadowLoc("u_resolution"), gridSize);
-    web.setUniform(gl, shadowLoc("u_condensateGain"), p.condensateGain);
-    web.setUniform(gl, shadowLoc("u_extinction"), p.shadowExtinction);
-    for (const slot of [1, 2]) {
-      const position = p.lights[slot]?.position ?? [0, 0];
-      web.setUniform(gl, shadowLoc(`u_light${slot}Grid`), [position[0] * gridW, position[1] * gridH]);
-    }
-    web.drawFullscreenTriangle(gl);
-    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-    front = back;
-    framesSinceRenorm += 1;
-    timeSinceRenorm += clampedDt;
-    if (waterTargetTotal > 0 && timeSinceRenorm >= WATER_RENORM_INTERVAL_S && framesSinceRenorm > 0) {
-      const current = readTarget(vapor[front]) + readTarget(condensate[front]);
-      if (current > 1e-6) {
-        const totalRatio = waterTargetTotal / current;
-        const perFrame = Math.pow(totalRatio, 1 / framesSinceRenorm);
-        waterScale = Math.min(1.05, Math.max(0.95, perFrame));
-      }
-      timeSinceRenorm = 0;
-      framesSinceRenorm = 0;
-    }
-  }
-  function emit(emissions) {
-    if (!track || emissions.length === 0) return;
-    const minDim = Math.min(gridW, gridH);
-    gl.bindFramebuffer(gl.FRAMEBUFFER, track[front].fbo);
-    gl.viewport(0, 0, gridW, gridH);
-    gl.enable(gl.BLEND);
-    gl.blendFunc(gl.ONE, gl.ONE);
-    gl.useProgram(emitProgram);
-    web.setUniform(gl, emitLoc("u_resolution"), [gridW, gridH]);
-    for (const e of emissions) {
-      const source = [e.source[0] * gridW, e.source[1] * gridH];
-      const length = e.lengthFrac * minDim;
-      const head = [
-        source[0] + Math.cos(e.angle) * length,
-        source[1] + Math.sin(e.angle) * length
-      ];
-      web.setUniform(gl, emitLoc("u_source"), source);
-      web.setUniform(gl, emitLoc("u_head"), head);
-      web.setUniform(gl, emitLoc("u_headWidth"), e.headWidthFrac * minDim);
-      web.setUniform(gl, emitLoc("u_tailWidth"), e.tailWidthFrac * minDim);
-      web.setUniform(gl, emitLoc("u_raggedAmp"), e.raggedFrac * minDim);
-      web.setUniform(gl, emitLoc("u_raggedFreq"), e.raggedFreq);
-      web.setUniform(gl, emitLoc("u_settle"), e.settleFrac * minDim);
-      web.setUniform(gl, emitLoc("u_tailDim"), e.tailDim);
-      web.setUniform(gl, emitLoc("u_intensity"), e.intensity);
-      web.setUniform(gl, emitLoc("u_seed"), e.seed);
-      web.drawFullscreenTriangle(gl);
-    }
-    gl.disable(gl.BLEND);
-    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-  }
-  function stepTrackLayer(dt, emissions) {
-    liveTracks = trackLayer.step(dt, emissions);
-  }
-  function composite(contentWidth, contentHeight, params = {}) {
-    if (!vapor || !condensate || !track || !shadow) return;
-    const p = { ...MEDIUM_DEFAULTS, ...params };
-    gl.viewport(0, 0, contentWidth, contentHeight);
-    gl.disable(gl.BLEND);
-    gl.useProgram(compositeProgram);
-    web.bindTextureAt(gl, 0, vapor[front].texture, compositeProgram, "u_vapor");
-    web.bindTextureAt(gl, 1, condensate[front].texture, compositeProgram, "u_condensate");
-    web.bindTextureAt(gl, 2, track[front].texture, compositeProgram, "u_track");
-    web.bindTextureAt(gl, 3, shadow.texture, compositeProgram, "u_shadow");
-    web.setUniform(gl, compositeLoc("u_vaporSize"), [gridW, gridH]);
-    web.setUniform(gl, compositeLoc("u_condensateSize"), [gridW, gridH]);
-    web.setUniform(gl, compositeLoc("u_trackSize"), [gridW, gridH]);
-    web.setUniform(gl, compositeLoc("u_shadowSize"), [gridW, gridH]);
-    web.setUniform(gl, compositeLoc("u_resolution"), [contentWidth, contentHeight]);
-    web.setUniform(gl, compositeLoc("u_dyeScale"), [gridW / contentWidth, gridH / contentHeight]);
-    web.setUniform(gl, compositeLoc("u_lab0"), srgbToOklab(p.channelColors[0]));
-    web.setUniform(gl, compositeLoc("u_lab1"), srgbToOklab(p.channelColors[1]));
-    web.setUniform(gl, compositeLoc("u_lab2"), srgbToOklab(p.channelColors[2]));
-    web.setUniform(gl, compositeLoc("u_labBg"), srgbToOklab(p.baseColor));
-    web.setUniform(gl, compositeLoc("u_labCondensate"), srgbToOklab(p.condensateColor));
-    web.setUniform(gl, compositeLoc("u_baseWeight"), p.baseWeight);
-    web.setUniform(gl, compositeLoc("u_condensateTint"), p.condensateTint);
-    web.setUniform(gl, compositeLoc("u_condensateGain"), p.condensateGain);
-    web.setUniform(gl, compositeLoc("u_farScale"), p.depthFarScale);
-    web.setUniform(gl, compositeLoc("u_farOffset"), depthFarOffsetPx(p.depthFarOffsetFrac, gridW, gridH));
-    web.setUniform(gl, compositeLoc("u_farBlurRadius"), p.depthFarBlurRadius);
-    web.setUniform(gl, compositeLoc("u_farWeight"), p.depthFarWeight);
-    web.setUniform(gl, compositeLoc("u_gravityBoost"), p.gravityBottomBoost);
-    web.setUniform(gl, compositeLoc("u_gravityBoostStart"), p.gravityBottomBoostStart);
-    web.setUniform(gl, compositeLoc("u_channelScatter"), p.channelScatter);
-    for (let slot = 0; slot < MEDIUM_MAX_LIGHTS; slot += 1) bindLightUniforms(slot, p.lights[slot]);
-    web.setUniform(gl, compositeLoc("u_trackLightFloor"), p.trackLightFloor);
-    web.drawFullscreenTriangle(gl);
-    const { data, count } = buildTrackLayerInstances(liveTracks, contentWidth, contentHeight, p.trackLayerAmount);
-    trackLayerProgram.draw(contentWidth, contentHeight, data, count, p.trackLightFloor, p.lights, shadow.texture);
-  }
-  function readTarget(target) {
-    gl.bindFramebuffer(gl.FRAMEBUFFER, target.fbo);
-    let sum = 0;
-    if (format.type === gl.HALF_FLOAT) {
-      const buf = new Float32Array(gridW * gridH * 4);
-      gl.readPixels(0, 0, gridW, gridH, gl.RGBA, gl.FLOAT, buf);
-      for (let i = 0; i < buf.length; i += 4) sum += buf[i] + buf[i + 1] + buf[i + 2];
-    } else {
-      const buf = new Uint8Array(gridW * gridH * 4);
-      gl.readPixels(0, 0, gridW, gridH, gl.RGBA, gl.UNSIGNED_BYTE, buf);
-      for (let i = 0; i < buf.length; i += 4) sum += (buf[i] + buf[i + 1] + buf[i + 2]) / 255;
-    }
-    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-    return sum;
-  }
-  function readTotals() {
-    if (!vapor || !condensate || !track) return null;
-    return {
-      vapor: readTarget(vapor[front]),
-      condensate: readTarget(condensate[front]),
-      track: readTarget(track[front])
-    };
-  }
-  function readVaporGrid() {
-    if (!vapor) return null;
-    gl.bindFramebuffer(gl.FRAMEBUFFER, vapor[front].fbo);
-    const cells = gridW * gridH;
-    const data = new Array(cells * 3);
-    if (format.type === gl.HALF_FLOAT) {
-      const buf = new Float32Array(cells * 4);
-      gl.readPixels(0, 0, gridW, gridH, gl.RGBA, gl.FLOAT, buf);
-      for (let i = 0; i < cells; i += 1) {
-        data[i * 3] = buf[i * 4];
-        data[i * 3 + 1] = buf[i * 4 + 1];
-        data[i * 3 + 2] = buf[i * 4 + 2];
-      }
-    } else {
-      const buf = new Uint8Array(cells * 4);
-      gl.readPixels(0, 0, gridW, gridH, gl.RGBA, gl.UNSIGNED_BYTE, buf);
-      for (let i = 0; i < cells; i += 1) {
-        data[i * 3] = buf[i * 4] / 255;
-        data[i * 3 + 1] = buf[i * 4 + 1] / 255;
-        data[i * 3 + 2] = buf[i * 4 + 2] / 255;
-      }
-    }
-    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-    return { cols: gridW, rows: gridH, data };
-  }
-  function readCondensateGrid() {
-    if (!condensate) return null;
-    gl.bindFramebuffer(gl.FRAMEBUFFER, condensate[front].fbo);
-    const cells = gridW * gridH;
-    const data = new Array(cells);
-    if (format.type === gl.HALF_FLOAT) {
-      const buf = new Float32Array(cells * 4);
-      gl.readPixels(0, 0, gridW, gridH, gl.RGBA, gl.FLOAT, buf);
-      for (let i = 0; i < cells; i += 1) data[i] = buf[i * 4];
-    } else {
-      const buf = new Uint8Array(cells * 4);
-      gl.readPixels(0, 0, gridW, gridH, gl.RGBA, gl.UNSIGNED_BYTE, buf);
-      for (let i = 0; i < cells; i += 1) data[i] = buf[i * 4] / 255;
-    }
-    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-    return { cols: gridW, rows: gridH, data };
-  }
-  function readTrackGrid() {
-    if (!track) return null;
-    gl.bindFramebuffer(gl.FRAMEBUFFER, track[front].fbo);
-    const cells = gridW * gridH;
-    const data = new Array(cells);
-    if (format.type === gl.HALF_FLOAT) {
-      const buf = new Float32Array(cells * 4);
-      gl.readPixels(0, 0, gridW, gridH, gl.RGBA, gl.FLOAT, buf);
-      for (let i = 0; i < cells; i += 1) data[i] = buf[i * 4];
-    } else {
-      const buf = new Uint8Array(cells * 4);
-      gl.readPixels(0, 0, gridW, gridH, gl.RGBA, gl.UNSIGNED_BYTE, buf);
-      for (let i = 0; i < cells; i += 1) data[i] = buf[i * 4] / 255;
-    }
-    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-    return { cols: gridW, rows: gridH, data };
-  }
-  function destroy() {
-    destroyTargets();
-    gl.deleteProgram(vaporForwardProgram);
-    gl.deleteProgram(vaporCorrectProgram);
-    gl.deleteProgram(vaporReactProgram);
-    gl.deleteProgram(condensateForwardProgram);
-    gl.deleteProgram(condensateCorrectProgram);
-    gl.deleteProgram(condensateReactProgram);
-    gl.deleteProgram(trackAdvectProgram);
-    gl.deleteProgram(compositeProgram);
-    gl.deleteProgram(seedProgram);
-    gl.deleteProgram(emitProgram);
-    gl.deleteProgram(shadowProgram);
-    gl.deleteProgram(resampleProgram);
-    trackLayerProgram.destroy();
-  }
-  return {
-    ensureGrid,
-    step,
-    emit,
-    stepTrackLayer,
-    composite,
-    readTotals,
-    readVaporGrid,
-    readCondensateGrid,
-    readTrackGrid,
-    destroy
-  };
-}
-function createMediumBackdrop() {
-  let runtime = null;
-  let owner = null;
-  return {
-    pass: (frame) => (gl, target) => {
-      if (owner && owner !== gl) throw new Error("vireuikit: the medium is already bound to another WebGL context");
-      owner = gl;
-      runtime ??= createMediumRuntime(gl, web.FULLSCREEN_TRIANGLE_VERTEX_SOURCE);
-      runtime.ensureGrid(frame.gridWidth, frame.gridHeight);
-      runtime.step(frame.dt, frame.params);
-      runtime.emit(frame.emissions ?? []);
-      runtime.stepTrackLayer(frame.dt, frame.emissions ?? []);
-      gl.bindFramebuffer(gl.FRAMEBUFFER, target.framebuffer);
-      runtime.composite(target.width, target.height, frame.params);
-    },
-    readTotals: () => runtime?.readTotals() ?? null,
-    readVaporGrid: () => runtime?.readVaporGrid() ?? null,
-    readCondensateGrid: () => runtime?.readCondensateGrid() ?? null,
-    readTrackGrid: () => runtime?.readTrackGrid() ?? null,
-    destroy: () => {
-      runtime?.destroy();
-      runtime = null;
-      owner = null;
-    }
-  };
-}
-
-exports.buildTrackLayerInstances = buildTrackLayerInstances;
-exports.createMediumBackdrop = createMediumBackdrop;
-exports.createMediumRuntime = createMediumRuntime;
-exports.createTrackLayer = createTrackLayer;
-exports.createTrackLayerProgram = createTrackLayerProgram;
-exports.trackLayerFade = trackLayerFade;
-exports.trackLayerSigmaMul = trackLayerSigmaMul;
-//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map