vireuikit 0.3.0 → 0.5.0

package/dist/index.cjs

@@ -185,899 +185,17 @@ function stepGrowth(state, dt, open, reduceMotion = false, timing = DEFAULT_GROW
   return movedShrink || movedGrow;
 }
 
-// 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 BASE_COLOR = [0.07, 0.08, 0.1];
-var MEDIUM_DEFAULTS = {
-  decay: 0.06,
-  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),
-  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
-};
-function depthFarOffsetPx(offsetFrac, gridWidth, gridHeight) {
-  return [offsetFrac[0] * gridWidth, offsetFrac[1] * gridHeight];
-}
-function wrappedDistanceFromZero(value, period) {
-  const wrapped = (value % period + period) % period;
-  return Math.min(wrapped, period - wrapped);
-}
-var MEDIUM_PROBE_FLOOR_PX = 22;
-var MEDIUM_DEFAULT_CELL_PX = 26;
-var MEDIUM_TRACK_PRESETS = {
-  alpha: {
-    lengthFrac: 0.22,
-    headWidthFrac: 0.05,
-    tailWidthFrac: 0.12,
-    raggedFrac: 0,
-    raggedFreq: 0,
-    settleFrac: 0.02,
-    tailDim: 0.55,
-    intensity: 1.15
-  },
-  beta: {
-    lengthFrac: 0.42,
-    headWidthFrac: 0.018,
-    tailWidthFrac: 0.05,
-    raggedFrac: 0.045,
-    raggedFreq: 5,
-    settleFrac: 0.05,
-    tailDim: 0.45,
-    intensity: 0.85
-  },
-  natural: {
-    lengthFrac: 0.13,
-    headWidthFrac: 0.02,
-    tailWidthFrac: 0.04,
-    raggedFrac: 0.02,
-    raggedFreq: 4,
-    settleFrac: 0.02,
-    tailDim: 0.5,
-    intensity: 0.4
-  }
-};
-var MEDIUM_DRIFT_TURBULENCE = 0.045;
-var MEDIUM_PLAYING_TURBULENCE_RANGE = [0.55, 1.15];
-var MEDIUM_TURBULENCE_TAU = 2.5;
-var MEDIUM_EMISSION_BEATS = 4;
-var MEDIUM_EMISSION_PROBABILITY = 0.55;
-var MEDIUM_MIN_EMISSION_INTERVAL = 1.2;
-var MEDIUM_NATURAL_INTERVAL = 25;
-var MEDIUM_NATURAL_JITTER = 35;
-var MEDIUM_SENSITIVE_TOP = 0.55;
-var MEDIUM_SENSITIVE_BOTTOM = 0.95;
-var MEDIUM_TRACK_DEPTH_WIDTH_RANGE = [0.55, 1];
-var MEDIUM_TRACK_DEPTH_INTENSITY_RANGE = [0.4, 1];
-
-// 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);
-}
-`;
-
-// 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 MEDIUM_COMPOSITE_SHADER = `
-uniform shader u_vapor;
-uniform shader u_condensate;
-uniform shader u_track;
-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;
-
-${VG_OKLAB_TO_SRGB}
-${VG_CUBIC_WEIGHTS}
-${vgBicubicSampler("vgBicubicVapor", "u_vapor")}
-${vgBicubicSampler("vgBicubicCondensate", "u_condensate")}
-
-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;
-  float3 rgbLinear = clamp(vgOklabToLinear(mixLab), float3(0.0), float3(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;
-uniform float3 u_channelMask;
-
-${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 = u_channelMask * (best * u_intensity);
-  return half4(half3(dye), half(1.0));
-}
-`;
-
-// src/medium/dynamics.ts
-function hash01(n) {
-  const s = Math.sin(n * 12.9898) * 43758.5453;
-  return s - Math.floor(s);
-}
-function channelFromSeed(seed) {
-  const idx = Math.floor(hash01(seed * 1.37) * 3) % 3;
-  return idx === 0 ? [1, 0, 0] : idx === 1 ? [0, 1, 0] : [0, 0, 1];
-}
-function lerp(range, t) {
-  return range[0] + (range[1] - range[0]) * t;
-}
-function applyTrackDepth(preset, depth) {
-  const widthScale = lerp(MEDIUM_TRACK_DEPTH_WIDTH_RANGE, depth);
-  const intensityScale = lerp(MEDIUM_TRACK_DEPTH_INTENSITY_RANGE, depth);
-  return {
-    ...preset,
-    headWidthFrac: preset.headWidthFrac * widthScale,
-    tailWidthFrac: preset.tailWidthFrac * widthScale,
-    intensity: preset.intensity * intensityScale
-  };
-}
-function buildEmission(presetName, source, seed, intensityScale) {
-  const preset = MEDIUM_TRACK_PRESETS[presetName];
-  const depth = hash01(seed * 4.63);
-  const depthApplied = applyTrackDepth(preset, depth);
-  return {
-    ...depthApplied,
-    intensity: depthApplied.intensity * intensityScale,
-    source,
-    angle: hash01(seed * 7.31) * Math.PI * 2,
-    seed,
-    channel: channelFromSeed(seed),
-    depth
-  };
-}
-function createMediumDynamics() {
-  let turbulence = MEDIUM_DRIFT_TURBULENCE;
-  let lastBar = -1;
-  let idleClock = 0;
-  let naturalIndex = 0;
-  let nextNaturalAt = MEDIUM_NATURAL_INTERVAL * 0.5;
-  let simTime = 0;
-  let lastEmissionAt = -Infinity;
-  function step(input) {
-    const { state, bpm, amplitude, positionSeconds, sourcePoint, dt } = input;
-    simTime += dt;
-    const amp = Math.max(0, Math.min(1, amplitude));
-    const target = state === "playing" ? MEDIUM_PLAYING_TURBULENCE_RANGE[0] + (MEDIUM_PLAYING_TURBULENCE_RANGE[1] - MEDIUM_PLAYING_TURBULENCE_RANGE[0]) * amp : MEDIUM_DRIFT_TURBULENCE;
-    turbulence += (target - turbulence) * (1 - Math.exp(-dt / MEDIUM_TURBULENCE_TAU));
-    const emissions = [];
-    if (state === "playing" && bpm > 0) {
-      const beats = positionSeconds * bpm / 60;
-      const bar = Math.floor(beats / MEDIUM_EMISSION_BEATS);
-      if (bar !== lastBar) {
-        lastBar = bar;
-        const eligible = hash01(bar * 0.618) < MEDIUM_EMISSION_PROBABILITY && simTime - lastEmissionAt >= MEDIUM_MIN_EMISSION_INTERVAL;
-        if (eligible) {
-          lastEmissionAt = simTime;
-          const presetName = hash01(bar * 3.14) < 0.55 ? "alpha" : "beta";
-          emissions.push(buildEmission(presetName, sourcePoint, bar, 0.6 + 0.4 * amp));
-        }
-      }
-    } else if (state === "idle") {
-      idleClock += dt;
-      if (idleClock >= nextNaturalAt) {
-        const idx = naturalIndex;
-        naturalIndex += 1;
-        const randomSource = [
-          hash01(idx * 2.1 + 0.5),
-          MEDIUM_SENSITIVE_TOP + hash01(idx * 5.9 + 1.7) * (MEDIUM_SENSITIVE_BOTTOM - MEDIUM_SENSITIVE_TOP)
-        ];
-        emissions.push(buildEmission("natural", randomSource, idx, 1));
-        nextNaturalAt = idleClock + MEDIUM_NATURAL_INTERVAL + hash01(idx * 1.7) * MEDIUM_NATURAL_JITTER;
-      }
-    }
-    return { turbulence, emissions };
-  }
-  return { step };
-}
-
 exports.ATOM_AT_REST = ATOM_AT_REST;
 exports.DEFAULT_GROWTH_TIMING = DEFAULT_GROWTH_TIMING;
-exports.LINEAR_TO_LMS = LINEAR_TO_LMS;
-exports.LMS_TO_LINEAR = LMS_TO_LINEAR;
-exports.LMS_TO_OKLAB = LMS_TO_OKLAB;
-exports.MEDIUM_COMPOSITE_SHADER = MEDIUM_COMPOSITE_SHADER;
-exports.MEDIUM_CONDENSATE_CORRECT_SHADER = MEDIUM_CONDENSATE_CORRECT_SHADER;
-exports.MEDIUM_CONDENSATE_FORWARD_SHADER = MEDIUM_CONDENSATE_FORWARD_SHADER;
-exports.MEDIUM_CONDENSATE_REACT_SHADER = MEDIUM_CONDENSATE_REACT_SHADER;
-exports.MEDIUM_DEFAULTS = MEDIUM_DEFAULTS;
-exports.MEDIUM_DEFAULT_CELL_PX = MEDIUM_DEFAULT_CELL_PX;
-exports.MEDIUM_DRIFT_TURBULENCE = MEDIUM_DRIFT_TURBULENCE;
-exports.MEDIUM_EMISSION_BEATS = MEDIUM_EMISSION_BEATS;
-exports.MEDIUM_EMISSION_PROBABILITY = MEDIUM_EMISSION_PROBABILITY;
-exports.MEDIUM_EMIT_SHADER = MEDIUM_EMIT_SHADER;
-exports.MEDIUM_MIN_EMISSION_INTERVAL = MEDIUM_MIN_EMISSION_INTERVAL;
-exports.MEDIUM_NATURAL_INTERVAL = MEDIUM_NATURAL_INTERVAL;
-exports.MEDIUM_NATURAL_JITTER = MEDIUM_NATURAL_JITTER;
-exports.MEDIUM_PLAYING_TURBULENCE_RANGE = MEDIUM_PLAYING_TURBULENCE_RANGE;
-exports.MEDIUM_PROBE_FLOOR_PX = MEDIUM_PROBE_FLOOR_PX;
-exports.MEDIUM_RESAMPLE_SHADER = MEDIUM_RESAMPLE_SHADER;
-exports.MEDIUM_SEED_SHADER = MEDIUM_SEED_SHADER;
-exports.MEDIUM_SENSITIVE_BOTTOM = MEDIUM_SENSITIVE_BOTTOM;
-exports.MEDIUM_SENSITIVE_TOP = MEDIUM_SENSITIVE_TOP;
-exports.MEDIUM_SPECIES_HUE_SPREAD = MEDIUM_SPECIES_HUE_SPREAD;
-exports.MEDIUM_SPECIES_LIGHTNESS = MEDIUM_SPECIES_LIGHTNESS;
-exports.MEDIUM_TIME_PERIOD = MEDIUM_TIME_PERIOD;
-exports.MEDIUM_TRACK_ADVECT_SHADER = MEDIUM_TRACK_ADVECT_SHADER;
-exports.MEDIUM_TRACK_DEPTH_INTENSITY_RANGE = MEDIUM_TRACK_DEPTH_INTENSITY_RANGE;
-exports.MEDIUM_TRACK_DEPTH_WIDTH_RANGE = MEDIUM_TRACK_DEPTH_WIDTH_RANGE;
-exports.MEDIUM_TRACK_PRESETS = MEDIUM_TRACK_PRESETS;
-exports.MEDIUM_TURBULENCE_TAU = MEDIUM_TURBULENCE_TAU;
-exports.MEDIUM_VAPOR_CORRECT_SHADER = MEDIUM_VAPOR_CORRECT_SHADER;
-exports.MEDIUM_VAPOR_FORWARD_SHADER = MEDIUM_VAPOR_FORWARD_SHADER;
-exports.MEDIUM_VAPOR_REACT_SHADER = MEDIUM_VAPOR_REACT_SHADER;
-exports.OKLAB_TO_LMS = OKLAB_TO_LMS;
-exports.VG_CURL_NOISE = VG_CURL_NOISE;
-exports.VG_OKLAB_TO_SRGB = VG_OKLAB_TO_SRGB;
-exports.VG_VALUE_NOISE = VG_VALUE_NOISE;
-exports.applyTrackDepth = applyTrackDepth;
 exports.atomAtRest = atomAtRest;
 exports.atomLift = atomLift;
 exports.atomMaterial = atomMaterial;
-exports.characterOf = characterOf;
 exports.createGrowthState = createGrowthState;
-exports.createMediumDynamics = createMediumDynamics;
-exports.depthFarOffsetPx = depthFarOffsetPx;
 exports.growthFrame = growthFrame;
 exports.growthInk = growthInk;
 exports.growthPhase = growthPhase;
-exports.neutralSpecies = neutralSpecies;
-exports.oklabToSrgb = oklabToSrgb;
 exports.smoothstep = smoothstep;
-exports.speciesFamily = speciesFamily;
-exports.srgbToOklab = srgbToOklab;
 exports.stepGrowth = stepGrowth;
 exports.stepSpring = stepSpring;
-exports.wrappedDistanceFromZero = wrappedDistanceFromZero;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map