vireuikit 0.1.0 → 0.3.0

package/README.md

@@ -76,6 +76,33 @@ Turbulence and light-track emission in response to playback come from `createMed
 which is platform-neutral: feed `step()` a playback state, BPM and a deterministic position, and
 pass the `emissions` it returns on as `MediumFrame.emissions`.
 
+The backdrop reads as a chamber seen from the side, not a flat field, without a second simulation:
+the composite samples the same vapor/condensate grid twice, once at identity and once at a larger
+scale and a fixed offset (`MEDIUM_DEFAULTS.depthFarScale`/`depthFarOffsetFrac`, the offset as a
+fraction of the grid so it stays clear of the wrap at any grid size) — the far read is both slower
+on screen and finer-grained, since the field's own motion maps to screen motion as `v / scale`. An
+8-tap rotated ring blur on that far read (`depthFarBlurRadius`) supplies aerial perspective's
+softness and lower contrast in the same pass, weighted down (`depthFarWeight`) so it never competes
+with the near plane; the ring (not an axis-aligned box) keeps that blur from turning a residual
+seam or resize artifact into parallel straight lines. Gravity is two separate properties: a small
+downward drift on vapor's own velocity (`gravityVaporDrift`, a motion cue only — a uniform drift on
+this periodic grid cannot itself accumulate density) and a compositing-only density boost near the
+bottom of the frame (`gravityBottomBoost`/`gravityBottomBoostStart`, a steady-state property that
+cannot affect the conserved water total) that actually produces the "denser at the bottom" reading.
+Condensate settling adds a second, always-on share of the ambient curl field's own sideways push
+(`condensateSettleWiggle`) so a droplet falling at a constant speed doesn't trace a dead-straight
+vertical line when turbulence is otherwise low. Each emitted track also carries a `depth` (0 far …
+1 near) that scales its own width and intensity, so a track reads thinner, dimmer and softer the
+farther back it lives.
+
+The curl-noise potential itself is periodic over the simulation grid in space, the same way it
+already was in time: each octave's spatial frequency is adjusted, per grid size, to the nearest
+value that makes a full grid width (or height) an exact integer number of lattice cells
+(`computeMediumSpatialPeriods`) — so velocity never jumps at the domain's own wrap, and the far
+plane's tile boundary reads as an ordinary point in the field rather than a seam. The near plane's
+vapor and condensate reads use cubic B-spline reconstruction (4 bilinear taps) instead of plain
+bilinear, so the simulation grid's own cells don't read as squares at typical (coarse) grid sizes.
+
 ## License
 
 Apache-2.0. See [LICENSE](./LICENSE) and [NOTICE](./NOTICE).

package/dist/{chunk-ZFX2MLKK.js → chunk-2AFVQ65S.js}

@@ -98,14 +98,29 @@ var MEDIUM_DEFAULTS = {
   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
+  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 = {
@@ -150,6 +165,8 @@ 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 = `
@@ -281,7 +298,90 @@ float2 vgCurlVelocity(float2 p, float 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);
+}
 `;
+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/seed-shader.ts
 var MEDIUM_SEED_SHADER = `
@@ -324,21 +424,36 @@ 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 vel = vgCurlVelocity(xy * u_curlFreq, u_phase) * u_advectSpeed * u_turbulence;
+  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}
+${MEDIUM_ADVECT_VELOCITY_VAPOR}
   float2 src = xy - vel * u_dt;
   return u_dye.eval(float2(src.x, u_dyeSize.y - src.y));
 }
@@ -346,6 +461,7 @@ ${MEDIUM_ADVECT_VELOCITY}
 var MEDIUM_CONDENSATE_FORWARD_SHADER = `
 ${MEDIUM_ADVECT_UNIFORMS}
 uniform float u_settleSpeed;
+uniform float u_settleWiggle;
 
 half4 main(float2 xy) {
 ${MEDIUM_ADVECT_VELOCITY_SETTLE}
@@ -374,9 +490,10 @@ var MEDIUM_MACCORMACK_CORRECT = `
 var MEDIUM_VAPOR_CORRECT_SHADER = `
 ${MEDIUM_ADVECT_UNIFORMS}
 uniform shader u_forward;
+uniform float u_vaporDrift;
 
 half4 main(float2 xy) {
-${MEDIUM_ADVECT_VELOCITY}
+${MEDIUM_ADVECT_VELOCITY_VAPOR}
 ${MEDIUM_MACCORMACK_CORRECT}
   return limited;
 }
@@ -384,6 +501,7 @@ ${MEDIUM_MACCORMACK_CORRECT}
 var MEDIUM_CONDENSATE_CORRECT_SHADER = `
 ${MEDIUM_ADVECT_UNIFORMS}
 uniform float u_settleSpeed;
+uniform float u_settleWiggle;
 uniform shader u_forward;
 
 half4 main(float2 xy) {
@@ -483,6 +601,39 @@ ${MEDIUM_ADVECT_VELOCITY}
 `;
 
 // 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;
@@ -496,17 +647,71 @@ 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 src = xy * u_dyeScale;
-  half4 vapor = u_vapor.eval(src);
-  half4 condensate = u_condensate.eval(src);
-  half4 track = u_track.eval(src);
-  float w0 = float(vapor.r) + float(track.r);
-  float w1 = float(vapor.g) + float(track.g);
-  float w2 = float(vapor.b) + float(track.b);
+  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
@@ -514,7 +719,8 @@ half4 main(float2 xy) {
   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) * u_condensateGain;
+  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 =
@@ -574,15 +780,31 @@ 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 {
-    ...preset,
-    intensity: preset.intensity * intensityScale,
+    ...depthApplied,
+    intensity: depthApplied.intensity * intensityScale,
     source,
     angle: hash01(seed * 7.31) * Math.PI * 2,
     seed,
-    channel: channelFromSeed(seed)
+    channel: channelFromSeed(seed),
+    depth
   };
 }
 function createMediumDynamics() {
@@ -630,6 +852,6 @@ function createMediumDynamics() {
   return { step };
 }
 
-export { LINEAR_TO_LMS, LMS_TO_LINEAR, LMS_TO_OKLAB, MEDIUM_COMPOSITE_SHADER, MEDIUM_CONDENSATE_CORRECT_SHADER, MEDIUM_CONDENSATE_FORWARD_SHADER, MEDIUM_CONDENSATE_REACT_SHADER, MEDIUM_DEFAULTS, MEDIUM_DEFAULT_CELL_PX, MEDIUM_DRIFT_TURBULENCE, MEDIUM_EMISSION_BEATS, MEDIUM_EMISSION_PROBABILITY, MEDIUM_EMIT_SHADER, MEDIUM_MIN_EMISSION_INTERVAL, MEDIUM_NATURAL_INTERVAL, MEDIUM_NATURAL_JITTER, MEDIUM_PLAYING_TURBULENCE_RANGE, MEDIUM_PROBE_FLOOR_PX, MEDIUM_RESAMPLE_SHADER, MEDIUM_SEED_SHADER, MEDIUM_SENSITIVE_BOTTOM, MEDIUM_SENSITIVE_TOP, MEDIUM_SPECIES_HUE_SPREAD, MEDIUM_SPECIES_LIGHTNESS, MEDIUM_TIME_PERIOD, MEDIUM_TRACK_ADVECT_SHADER, MEDIUM_TRACK_PRESETS, MEDIUM_TURBULENCE_TAU, MEDIUM_VAPOR_CORRECT_SHADER, MEDIUM_VAPOR_FORWARD_SHADER, MEDIUM_VAPOR_REACT_SHADER, OKLAB_TO_LMS, VG_CURL_NOISE, VG_OKLAB_TO_SRGB, VG_VALUE_NOISE, characterOf, createMediumDynamics, neutralSpecies, oklabToSrgb, speciesFamily, srgbToOklab };
-//# sourceMappingURL=chunk-ZFX2MLKK.js.map
-//# sourceMappingURL=chunk-ZFX2MLKK.js.map
+export { LINEAR_TO_LMS, LMS_TO_LINEAR, LMS_TO_OKLAB, MEDIUM_COMPOSITE_SHADER, MEDIUM_CONDENSATE_CORRECT_SHADER, MEDIUM_CONDENSATE_FORWARD_SHADER, MEDIUM_CONDENSATE_REACT_SHADER, MEDIUM_DEFAULTS, MEDIUM_DEFAULT_CELL_PX, MEDIUM_DRIFT_TURBULENCE, MEDIUM_EMISSION_BEATS, MEDIUM_EMISSION_PROBABILITY, MEDIUM_EMIT_SHADER, MEDIUM_MIN_EMISSION_INTERVAL, MEDIUM_NATURAL_INTERVAL, MEDIUM_NATURAL_JITTER, MEDIUM_PLAYING_TURBULENCE_RANGE, MEDIUM_PROBE_FLOOR_PX, MEDIUM_RESAMPLE_SHADER, MEDIUM_SEED_SHADER, MEDIUM_SENSITIVE_BOTTOM, MEDIUM_SENSITIVE_TOP, MEDIUM_SPECIES_HUE_SPREAD, MEDIUM_SPECIES_LIGHTNESS, MEDIUM_TIME_PERIOD, MEDIUM_TRACK_ADVECT_SHADER, MEDIUM_TRACK_DEPTH_INTENSITY_RANGE, MEDIUM_TRACK_DEPTH_WIDTH_RANGE, MEDIUM_TRACK_PRESETS, MEDIUM_TURBULENCE_TAU, MEDIUM_VAPOR_CORRECT_SHADER, MEDIUM_VAPOR_FORWARD_SHADER, MEDIUM_VAPOR_REACT_SHADER, OKLAB_TO_LMS, VG_CURL_NOISE, VG_OKLAB_TO_SRGB, VG_VALUE_NOISE, applyTrackDepth, characterOf, computeMediumSpatialPeriods, createMediumDynamics, depthFarOffsetPx, neutralSpecies, oklabToSrgb, speciesFamily, srgbToOklab, wrappedDistanceFromZero };
+//# sourceMappingURL=chunk-2AFVQ65S.js.map
+//# sourceMappingURL=chunk-2AFVQ65S.js.map