vireuikit 0.2.0 → 0.4.0

package/dist/{chunk-BV5P6MF7.js → chunk-VY22O2II.js}

@@ -87,9 +87,46 @@ function neutralSpecies(baseColor) {
 }
 
 // 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 = {
-  decay: 0.06,
+  // 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,
@@ -98,11 +135,13 @@ 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),
+  channelScatter: [1, 1, 1],
   baseColor: BASE_COLOR,
   baseWeight: 0.9,
   depthFarScale: 1.6,
@@ -111,7 +150,11 @@ var MEDIUM_DEFAULTS = {
   depthFarWeight: 0.5,
   gravityVaporDrift: 0.6,
   gravityBottomBoost: 2,
-  gravityBottomBoostStart: 0.75
+  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];
@@ -133,7 +176,7 @@ var MEDIUM_TRACK_PRESETS = {
     tailDim: 0.55,
     intensity: 1.15
   },
-  beta: {
+  electron: {
     lengthFrac: 0.42,
     headWidthFrac: 0.018,
     tailWidthFrac: 0.05,
@@ -141,17 +184,17 @@ var MEDIUM_TRACK_PRESETS = {
     raggedFreq: 5,
     settleFrac: 0.05,
     tailDim: 0.45,
-    intensity: 0.85
+    intensity: 0.6
   },
-  natural: {
-    lengthFrac: 0.13,
-    headWidthFrac: 0.02,
-    tailWidthFrac: 0.04,
-    raggedFrac: 0.02,
-    raggedFreq: 4,
-    settleFrac: 0.02,
-    tailDim: 0.5,
-    intensity: 0.4
+  muon: {
+    lengthFrac: 0.7,
+    headWidthFrac: 0.012,
+    tailWidthFrac: 0.02,
+    raggedFrac: 0,
+    raggedFreq: 0,
+    settleFrac: 0.01,
+    tailDim: 0.75,
+    intensity: 0.5
   }
 };
 var MEDIUM_DRIFT_TURBULENCE = 0.045;
@@ -160,12 +203,60 @@ 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_NATURAL_INTERVAL = 8;
+var MEDIUM_NATURAL_JITTER = 12;
 var MEDIUM_SENSITIVE_TOP = 0.55;
 var MEDIUM_SENSITIVE_BOTTOM = 0.95;
-var MEDIUM_TRACK_DEPTH_WIDTH_RANGE = [0.55, 1];
+var MEDIUM_ALPHA_BURST_RAYS = [8, 16];
+var MEDIUM_ALPHA_RAY_LENGTH_SCALE = [0.55, 1];
+var MEDIUM_TRACK_DEPTH_WIDTH_RANGE = [0.55, 1.2];
 var MEDIUM_TRACK_DEPTH_INTENSITY_RANGE = [0.4, 1];
+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/noise.ts
 var VG_VALUE_NOISE = `
@@ -297,7 +388,135 @@ 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);
+}
 `;
+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/seed-shader.ts
 var MEDIUM_SEED_SHADER = `
@@ -340,15 +559,25 @@ 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}
@@ -367,6 +596,7 @@ ${MEDIUM_ADVECT_VELOCITY_VAPOR}
 var MEDIUM_CONDENSATE_FORWARD_SHADER = `
 ${MEDIUM_ADVECT_UNIFORMS}
 uniform float u_settleSpeed;
+uniform float u_settleWiggle;
 
 half4 main(float2 xy) {
 ${MEDIUM_ADVECT_VELOCITY_SETTLE}
@@ -406,6 +636,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) {
@@ -505,10 +736,68 @@ ${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 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;
@@ -524,27 +813,68 @@ 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 sampled exactly as before the depth work; the calibrated look lives here.
-  half4 vapor = u_vapor.eval(baseSrc);
-  half4 condensate = u_condensate.eval(baseSrc);
+  // 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). A 4-tap box blur
-  // (no separate center sample, the cheapest isotropic blur available) supplies aerial perspective's
-  // blur and, as a side effect of averaging, its lower contrast too.
+  // 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 blurX = float2(u_farBlurRadius, 0.0);
-  float2 blurY = float2(0.0, u_farBlurRadius);
-  half4 vaporFar = (u_vapor.eval(farSrc + blurX) + u_vapor.eval(farSrc - blurX) +
-                     u_vapor.eval(farSrc + blurY) + u_vapor.eval(farSrc - blurY)) * half4(0.25);
-  half4 condensateFar = (u_condensate.eval(farSrc + blurX) + u_condensate.eval(farSrc - blurX) +
-                          u_condensate.eval(farSrc + blurY) + u_condensate.eval(farSrc - blurY)) * half4(0.25);
+  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
@@ -577,7 +907,34 @@ half4 main(float2 xy) {
   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));
+  // 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));
 }
@@ -595,7 +952,6 @@ uniform float  u_settle;
 uniform float  u_tailDim;
 uniform float  u_intensity;
 uniform float  u_seed;
-uniform float3 u_channelMask;
 
 ${VG_VALUE_NOISE}
 
@@ -618,20 +974,46 @@ half4 main(float2 xy) {
     best = max(best, v);
   }
 
-  float3 dye = u_channelMask * (best * u_intensity);
+  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/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;
 }
@@ -645,18 +1027,19 @@ function applyTrackDepth(preset, depth) {
     intensity: preset.intensity * intensityScale
   };
 }
-function buildEmission(presetName, source, seed, intensityScale) {
+function buildEmission(presetName, source, seed, intensityScale, angleOverride, lengthScale = 1) {
   const preset = MEDIUM_TRACK_PRESETS[presetName];
   const depth = hash01(seed * 4.63);
   const depthApplied = applyTrackDepth(preset, depth);
   return {
     ...depthApplied,
+    lengthFrac: depthApplied.lengthFrac * lengthScale,
     intensity: depthApplied.intensity * intensityScale,
     source,
-    angle: hash01(seed * 7.31) * Math.PI * 2,
+    angle: angleOverride ?? hash01(seed * 7.31) * Math.PI * 2,
     seed,
-    channel: channelFromSeed(seed),
-    depth
+    depth,
+    kind: presetName
   };
 }
 function createMediumDynamics() {
@@ -682,8 +1065,15 @@ function createMediumDynamics() {
         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));
+          const rayCount = Math.round(lerp(MEDIUM_ALPHA_BURST_RAYS, hash01(bar * 9.17)));
+          for (let i = 0; i < rayCount; i += 1) {
+            const raySeed = bar + (i + 1) * 0.0137;
+            const angle = (i + hash01(raySeed * 5.23)) / rayCount * Math.PI * 2;
+            const lengthScale = lerp(MEDIUM_ALPHA_RAY_LENGTH_SCALE, hash01(raySeed * 2.91));
+            emissions.push(
+              buildEmission("alpha", sourcePoint, raySeed, 0.6 + 0.4 * amp, angle, lengthScale)
+            );
+          }
         }
       }
     } else if (state === "idle") {
@@ -695,7 +1085,8 @@ function createMediumDynamics() {
           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));
+        const presetName = hash01(idx * 3.14) < 0.5 ? "electron" : "muon";
+        emissions.push(buildEmission(presetName, randomSource, idx, 1));
         nextNaturalAt = idleClock + MEDIUM_NATURAL_INTERVAL + hash01(idx * 1.7) * MEDIUM_NATURAL_JITTER;
       }
     }
@@ -704,6 +1095,54 @@ 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_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, createMediumDynamics, depthFarOffsetPx, neutralSpecies, oklabToSrgb, speciesFamily, srgbToOklab, wrappedDistanceFromZero };
-//# sourceMappingURL=chunk-BV5P6MF7.js.map
-//# sourceMappingURL=chunk-BV5P6MF7.js.map
+// src/medium/light-rig.ts
+var clamp012 = (v) => Math.min(1, Math.max(0, v));
+var EDGE_STRIP_CONE_ANGLE = Math.PI - 1e-6;
+var EDGE_STRIP_TINT_MIX = 0.22;
+var GEL_LIGHTNESS = 0.7;
+var LIGHT_HUE_SPREAD = MEDIUM_SPECIES_HUE_SPREAD / 2;
+function retint(base, hueDeg, chroma, mix) {
+  const [baseL, a, b] = srgbToOklab(base);
+  const l = baseL + (Math.min(baseL, GEL_LIGHTNESS) - baseL) * mix;
+  const rad = hueDeg * Math.PI / 180;
+  const targetA = chroma * Math.cos(rad);
+  const targetB = chroma * Math.sin(rad);
+  const mixedA = a + (targetA - a) * mix;
+  const mixedB = b + (targetB - b) * mix;
+  let lo = 0;
+  let hi = 1;
+  if (inGamut(oklabToSrgb([l, mixedA, mixedB]))) lo = 1;
+  else {
+    for (let i = 0; i < 12; i += 1) {
+      const mid = (lo + hi) / 2;
+      if (inGamut(oklabToSrgb([l, mixedA * mid, mixedB * mid]))) lo = mid;
+      else hi = mid;
+    }
+  }
+  const rgb = oklabToSrgb([l, mixedA * lo, mixedB * lo]).map(clamp012);
+  const gain = Math.max(...base) / Math.max(...rgb, 1e-6);
+  return rgb.map((v) => clamp012(v * gain));
+}
+var inGamut = (rgb) => rgb.every((v) => v >= -1e-4 && v <= 1 + 1e-4);
+function lightRigForCharacter(character, baseLights = MEDIUM_DEFAULT_LIGHTS) {
+  const spotlightIndices = [];
+  baseLights.forEach((light, i) => {
+    if (light.coneAngle < EDGE_STRIP_CONE_ANGLE) spotlightIndices.push(i);
+  });
+  const spotlightCount = spotlightIndices.length;
+  return baseLights.map((light, i) => {
+    if (light.coneAngle >= EDGE_STRIP_CONE_ANGLE) {
+      return { ...light, color: retint(light.color, character.hue, character.chroma, EDGE_STRIP_TINT_MIX) };
+    }
+    const slot = spotlightIndices.indexOf(i);
+    const hueOffset = spotlightCount > 1 ? LIGHT_HUE_SPREAD * (2 * slot / (spotlightCount - 1) - 1) : 0;
+    return { ...light, color: retint(light.color, character.hue + hueOffset, character.chroma, 1) };
+  });
+}
+function lightRigForCover(cover, baseLights = MEDIUM_DEFAULT_LIGHTS) {
+  return lightRigForCharacter(characterOf(cover), baseLights);
+}
+
+export { LINEAR_TO_LMS, LMS_TO_LINEAR, LMS_TO_OKLAB, MEDIUM_ALPHA_BURST_RAYS, MEDIUM_ALPHA_RAY_LENGTH_SCALE, MEDIUM_COMPOSITE_SHADER, MEDIUM_CONDENSATE_CORRECT_SHADER, MEDIUM_CONDENSATE_FORWARD_SHADER, MEDIUM_CONDENSATE_REACT_SHADER, MEDIUM_DEFAULTS, MEDIUM_DEFAULT_CELL_PX, MEDIUM_DEFAULT_LIGHTS, MEDIUM_DRIFT_TURBULENCE, MEDIUM_EMISSION_BEATS, MEDIUM_EMISSION_PROBABILITY, MEDIUM_EMIT_SHADER, MEDIUM_MAX_LIGHTS, 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_SHADOW_SHADER, 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_LAYER_BURST_ACCENT, MEDIUM_TRACK_LAYER_BURST_SPREAD, MEDIUM_TRACK_LAYER_CURL_PUSH, MEDIUM_TRACK_LAYER_FADE_GAMMA, MEDIUM_TRACK_LAYER_GRAVITY_SAG, MEDIUM_TRACK_LAYER_LIFE_SECONDS, MEDIUM_TRACK_LAYER_LOOK, MEDIUM_TRACK_LAYER_MAX_TRACKS, 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, lightRigForCharacter, lightRigForCover, neutralSpecies, oklabToSrgb, speciesFamily, srgbToOklab, vgPotentialJS, wrappedDistanceFromZero };
+//# sourceMappingURL=chunk-VY22O2II.js.map
+//# sourceMappingURL=chunk-VY22O2II.js.map