@pixerate/editor 0.242.0 → 0.244.0

package/dist/{chunk-HLBTRSQJ.js → chunk-P3NIPIKS.js}

@@ -85,20 +85,23 @@ var WET_TILE = 256;
 var SLOT_SIDE = 258;
 var PLANE = SLOT_SIDE * SLOT_SIDE;
 var PLANE_BYTES = PLANE * 4;
-var SET_PLANES = 18;
+var SET_PLANES = 19;
 var P_RHO = 9;
 var P_UX = 10;
 var P_UY = 11;
 var P_SW = 12;
 var P_P0 = 13;
-var P_EDGE = 17;
+var P_L = P_P0 + 4;
+var P_EDGE = 18;
 var P_D0 = 2 * SET_PLANES;
-var P_H = P_D0 + 4;
+var P_DL = P_D0 + 4;
+var P_H = P_D0 + 5;
 var P_FX = P_H + 1;
 var P_FY = P_H + 2;
 var SLOT_PLANES = P_FY + 1;
 var SLOT_BYTES = SLOT_PLANES * PLANE_BYTES;
 var PIGMENT_CHANNELS = 4;
+var MASS_CHANNELS = 5;
 var EX = [0, 1, 0, -1, 0, 1, -1, -1, 1];
 var EY = [0, 0, 1, 0, -1, 1, 1, -1, -1];
 var OPP = [0, 3, 4, 1, 2, 7, 8, 5, 6];
@@ -358,10 +361,9 @@ function filmPixel(k0, k1, k2, s, px, i, paper, wet, out, o) {
   const e0 = linearToSrgb8(scratch[0] * dark);
   const e1 = linearToSrgb8(scratch[1] * dark);
   const e2 = linearToSrgb8(scratch[2] * dark);
-  let alpha = a;
-  alpha = needAlpha(e0, p0, alpha);
-  alpha = needAlpha(e1, p1, alpha);
-  alpha = needAlpha(e2, p2, alpha);
+  let alpha = needAlpha(e2, p2, needAlpha(e1, p1, needAlpha(e0, p0, 0)));
+  if (s > 0 && alpha < 1) alpha += (1 - expNeg(HIDE * s)) * (1 - alpha);
+  if (a > alpha) alpha = a;
   if (alpha <= 0) {
     out[o] = px[i];
     out[o + 1] = px[i + 1];
@@ -392,7 +394,7 @@ function pixelPigment(px, i, paper, out) {
   }
   out[3] = 0;
 }
-function shadeTile(f, plane, side, d, p, rho, sw, src, out, w, h, paper) {
+function shadeTile(f, plane, side, d, p, rho, sw, src, out, w, h, paper, dl = -1, pl = -1) {
   const p0 = paper[0];
   const p1 = paper[1];
   const p2 = paper[2];
@@ -445,14 +447,31 @@ function shadeTile(f, plane, side, d, p, rho, sw, src, out, w, h, paper) {
         r1 += hide * rinf(k1 * inv);
         r2 += hide * rinf(k2 * inv);
       }
+      if (dl >= 0) {
+        let l = f[dl + c];
+        if (pl >= 0) l += f[pl + c];
+        if (l > 1e-7) {
+          if (l > 1) l = 1;
+          let w0 = keep * expT(tab, 2 * k0);
+          let w1 = keep * expT(tab, 2 * k1);
+          let w2 = keep * expT(tab, 2 * k2);
+          if (hide > 0) {
+            w0 += hide * rinf(k0 * inv);
+            w1 += hide * rinf(k1 * inv);
+            w2 += hide * rinf(k2 * inv);
+          }
+          r0 += l * (w0 - r0);
+          r1 += l * (w1 - r1);
+          r2 += l * (w2 - r2);
+        }
+      }
       const dark = 1 - 0.07 * wet;
       const e0 = encode(enc, r0 * dark);
       const e1 = encode(enc, r1 * dark);
       const e2 = encode(enc, r2 * dark);
-      let alpha = a;
-      alpha = needAlpha(e0, p0, alpha);
-      alpha = needAlpha(e1, p1, alpha);
-      alpha = needAlpha(e2, p2, alpha);
+      let alpha = needAlpha(e2, p2, needAlpha(e1, p1, needAlpha(e0, p0, 0)));
+      if (hide > 0 && alpha < 1) alpha += hide * (1 - alpha);
+      if (a > alpha) alpha = a;
       if (alpha <= 0) {
         out[i + 3] = 0;
         continue;
@@ -483,6 +502,42 @@ function encode(enc, v) {
   if (v >= 1) return 255;
   return enc[Math.round(v * ENC_STEPS)];
 }
+function shadeLightTile(f, plane, side, d, p, dl, pl, src, out, w, h) {
+  const tab = EXP_TABLE;
+  let any = false;
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const c = (y + 1) * side + x + 1;
+      let l = f[dl + c];
+      if (pl >= 0) l += f[pl + c];
+      const i = y * 256 + x;
+      const old = src ? src[i] : 0;
+      if (!(l > 1e-7) && old === 0) continue;
+      let keep = 1;
+      if (old > 0) {
+        let k0 = f[d + c];
+        let k1 = f[d + plane + c];
+        let k2 = f[d + 2 * plane + c];
+        let s = f[d + 3 * plane + c];
+        if (p >= 0) {
+          k0 += f[p + c];
+          k1 += f[p + plane + c];
+          k2 += f[p + 2 * plane + c];
+          s += f[p + 3 * plane + c];
+        }
+        if (k0 > 1e-7 || k1 > 1e-7 || k2 > 1e-7 || s > 1e-7) {
+          const hide = s > 0 ? 1 - expT(tab, HIDE * s) : 0;
+          keep = (1 - hide) * (expT(tab, 2 * k0) + expT(tab, 2 * k1) + expT(tab, 2 * k2)) / 3;
+        }
+      }
+      const v = Math.round(Math.min(255, 255 * Math.min(1, l > 0 ? l : 0) + old * keep));
+      if (v === old) continue;
+      out[i] = v;
+      any = true;
+    }
+  }
+  return any;
+}
 
 // src/paint/wet/kernel.ts
 var F = Math.fround;
@@ -498,7 +553,7 @@ var DECAY = F(0.99);
 var NB = [0, -1, -S, 1, S, -S - 1, -S + 1, S + 1, S - 1];
 var OPP2 = [0, 3, 4, 1, 2, 7, 8, 5, 6];
 var fin = new Float32Array(9);
-var pNew = new Float32Array(4);
+var pNew = new Float32Array(MASS_CHANNELS);
 function stepSlotTs(f, base, parity, prm) {
   const src = base + parity * SET_PLANES * PLANE;
   const dst = base + (1 - parity) * SET_PLANES * PLANE;
@@ -632,13 +687,13 @@ function stepSlotTs(f, base, parity, prm) {
       const rxWet = !rxDry;
       const uxc = f[uxS + c];
       const uyc = f[uyS + c];
-      for (let q = 0; q < 4; q++) pNew[q] = f[pS + q * PLANE + c];
+      for (let q = 0; q < MASS_CHANNELS; q++) pNew[q] = f[pS + q * PLANE + c];
       for (let face = 0; face < 4; face++) {
         const nb = c + (face === 0 ? 1 : face === 1 ? -1 : face === 2 ? S : -S);
         const open = rxWet && f[rhoS + nb] >= EPS;
         const uf = face === 0 ? F(mobility * F(uxc + f[uxS + nb])) : face === 1 ? F(mobility * F(f[uxS + nb] + uxc)) : face === 2 ? F(mobility * F(uyc + f[uyS + nb])) : F(mobility * F(f[uyS + nb] + uyc));
         const out = face === 0 || face === 2;
-        for (let q = 0; q < 4; q++) {
+        for (let q = 0; q < MASS_CHANNELS; q++) {
           const pc = f[pS + q * PLANE + c];
           const pn = f[pS + q * PLANE + nb];
           const flux = out ? uf > 0 ? F(uf * pc) : F(uf * pn) : uf > 0 ? F(uf * pn) : F(uf * pc);
@@ -650,7 +705,7 @@ function stepSlotTs(f, base, parity, prm) {
       const dryNow = rhoNew < EPS;
       const rate = F(F(depRate * F(1 + F(gran * F(1 - hx)))) * F(1 + F(edgeDep * ex)));
       const lift = dryNow ? 0 : F(F(pickup * Math.min(rhoNew, 1)) * F(1 + F(bloom * Math.max(0, F(rhoNew - rx)))));
-      for (let q = 0; q < 4; q++) {
+      for (let q = 0; q < MASS_CHANNELS; q++) {
         const pq = Math.max(0, pNew[q]);
         const dq = f[dP + q * PLANE + c];
         const dep = dryNow ? pq : Math.min(pq, F(pq * rate));
@@ -686,7 +741,7 @@ function loadWetKernel(shared) {
   const key = shared ? "shared" : "single";
   let p = modules[key];
   if (!p) {
-    p = import("./kernel-wasm-WIMMJUF2.js").then((m) => WebAssembly.compile(decode(shared ? m.WET_KERNEL_SHARED : m.WET_KERNEL_SINGLE)));
+    p = import("./kernel-wasm-4KVONDAU.js").then((m) => WebAssembly.compile(decode(shared ? m.WET_KERNEL_SHARED : m.WET_KERNEL_SINGLE)));
     p.catch(() => {
       modules = { ...modules, [key]: void 0 };
     });
@@ -864,10 +919,15 @@ var WetWorkerPool = class _WetWorkerPool {
 
 // src/paint/wet/world.ts
 var MAX_WET_LANES = 8;
-var MAX_WET_SLOTS = 352;
+var MAX_WET_SLOTS = 328;
 var SLOT_FLOATS = SLOT_PLANES * PLANE;
 var S2 = SLOT_SIDE;
-var SNAP_PLANES = SET_PLANES + 4;
+var SNAP_PLANES = SET_PLANES + MASS_CHANNELS;
+var noLight = () => new TiledSurface(1, /* @__PURE__ */ new Map(), 0);
+function newLane(id, index, params, flow, flowStrength, base, light) {
+  const l = light ?? noLight();
+  return { id, index, params, flow, flowStrength, base, shaded: /* @__PURE__ */ new Map(), urgent: /* @__PURE__ */ new Set(), stamp: 1, display: null, shadedVersion: 0, displayKey: "", light: l, lit: l.tiles.size > 0, lightShaded: /* @__PURE__ */ new Map(), lightDisplay: null, lightKey: "" };
+}
 var WetWorldError = class extends Error {
   constructor(message) {
     super(message);
@@ -1026,24 +1086,12 @@ var WetWorld = class {
     if (existing) {
       if (options.params) this.setParams(id, options.params);
       if (options.base) this.setBase(id, options.base);
+      if (options.light) this.setLight(id, options.light);
       return;
     }
     const index = this.lanes.indexOf(null);
     if (index < 0) throw new WetWorldError(`At most ${MAX_WET_LANES} layers can hold wet paint at once; dry one (dry_paint) first.`);
-    this.lanes[index] = {
-      id,
-      index,
-      params: normalizeWetParams(options.params ?? {}, DEFAULT_WET_PARAMS),
-      flow: options.flow ?? null,
-      flowStrength: options.flow ? options.flowStrength ?? 1 : 0,
-      base: options.base ?? new TiledSurface(4, /* @__PURE__ */ new Map(), 0),
-      shaded: /* @__PURE__ */ new Map(),
-      urgent: /* @__PURE__ */ new Set(),
-      stamp: 1,
-      display: null,
-      shadedVersion: 0,
-      displayKey: ""
-    };
+    this.lanes[index] = newLane(id, index, normalizeWetParams(options.params ?? {}, DEFAULT_WET_PARAMS), options.flow ?? null, options.flow ? options.flowStrength ?? 1 : 0, options.base ?? new TiledSurface(4, /* @__PURE__ */ new Map(), 0), options.light);
     this.pack(this.lanes[index]);
   }
   /** Drops a wet layer and its wet paint (nothing is baked). */
@@ -1110,6 +1158,23 @@ var WetWorld = class {
     lane.shadedVersion++;
     lane.stamp++;
   }
+  /** The light paint under a layer's wet paint (one channel). */
+  getLight(id) {
+    return this.laneOf(id).light;
+  }
+  /** Whether a layer has light paint, under its wet paint or in it. */
+  isLit(id) {
+    return this.laneOf(id).lit;
+  }
+  /** Replaces the light paint under a layer's wet paint. */
+  setLight(id, light) {
+    const lane = this.laneOf(id);
+    if (light === lane.light) return;
+    lane.light = light;
+    if (light.tiles.size) lane.lit = true;
+    lane.lightShaded.clear();
+    lane.stamp++;
+  }
   pack(lane) {
     packWetParams(lane.params, this.paper ?? DEFAULT_WET_PAPER, this.tilt, lane.flowStrength, this.prm);
     this.f32.set(this.prm, this.layout.params + lane.index * PARAM_FLOATS * 4 >> 2);
@@ -1535,11 +1600,13 @@ var WetWorld = class {
   }
   /**
    * Lays paint: `water` depth and pigment mass `pigment` (K r, g, b, S) per unit of coverage, or
-   * per pixel from `field` (4 values per pixel of `rect`). Pigment without water lands straight in
-   * the paper (settled).
+   * per pixel from `field` (4 values per pixel of `rect`), and `light` (light paint mass) per unit
+   * of coverage. Pigment and light without water land straight in the paper (settled).
    */
-  paint(id, rect, cov, water, pigment, field = null) {
+  paint(id, rect, cov, water, pigment, field = null, light = 0) {
     if (!(water >= 0)) throw new WetWorldError(`water ${water} must be 0 or more.`);
+    if (!(light >= 0)) throw new WetWorldError(`light ${light} must be 0 or more.`);
+    if (light > 0) this.laneOf(id).lit = true;
     this.footprint(id, rect, cov, (c, w, x, y) => {
       const dw = Math.fround(water * w);
       if (dw > 0) this.addWaterAt(c, dw);
@@ -1548,6 +1615,7 @@ var WetWorld = class {
         const o = ((y - rect.y) * rect.width + (x - rect.x)) * 4;
         for (let q = 0; q < 4; q++) this.f32[into + q * PLANE] += field[o + q] * w;
       } else if (pigment) for (let q = 0; q < 4; q++) this.f32[into + q * PLANE] += pigment[q] * w;
+      if (light > 0) this.f32[into + 4 * PLANE] += light * w;
     });
   }
   /** Damp paper: fills the paper's water towards its capacity by `amount` (0..1) × coverage, plus a thin film of surface water. */
@@ -1581,10 +1649,10 @@ var WetWorld = class {
           f[c + P_RHO * PLANE] *= kw;
         }
         if (ks < 1) f[c + P_SW * PLANE] *= ks;
-        if (kp < 1) for (let q = 0; q < 4; q++) f[c + (P_P0 + q) * PLANE] *= kp;
+        if (kp < 1) for (let q = 0; q < MASS_CHANNELS; q++) f[c + (P_P0 + q) * PLANE] *= kp;
         if (kd < 1) {
           const d = this.single(c) + P_D0 * PLANE;
-          for (let q = 0; q < 4; q++) f[d + q * PLANE] *= kd;
+          for (let q = 0; q < MASS_CHANNELS; q++) f[d + q * PLANE] *= kd;
         }
       },
       false
@@ -1614,10 +1682,10 @@ var WetWorld = class {
       false
     );
   }
-  /** Blends wet paint: each wet cell's suspended pigment moves `strength` × coverage towards the footprint's mean. */
+  /** Blends wet paint: each wet cell's suspended pigment (and light) moves `strength` × coverage towards the footprint's mean. */
   blend(id, rect, cov, strength) {
     const lane = this.laneOf(id);
-    const sums = [0, 0, 0, 0];
+    const sums = [0, 0, 0, 0, 0];
     let wsum = 0;
     const cells = [];
     this.footprint(
@@ -1628,13 +1696,13 @@ var WetWorld = class {
         if (!(this.f32[c + P_RHO * PLANE] >= DRY_EPS)) return;
         cells.push([c, w]);
         wsum += w;
-        for (let q = 0; q < 4; q++) sums[q] += this.f32[c + (P_P0 + q) * PLANE] * w;
+        for (let q = 0; q < MASS_CHANNELS; q++) sums[q] += this.f32[c + (P_P0 + q) * PLANE] * w;
       },
       false
     );
     if (!(wsum > 0)) return;
     const k = Math.min(1, Math.max(0, strength));
-    for (const [c, w] of cells) for (let q = 0; q < 4; q++) {
+    for (const [c, w] of cells) for (let q = 0; q < MASS_CHANNELS; q++) {
       const i = c + (P_P0 + q) * PLANE;
       this.f32[i] += k * w * (sums[q] / wsum - this.f32[i]);
     }
@@ -1643,7 +1711,7 @@ var WetWorld = class {
   }
   /**
    * Drags wet paint by (`dx`, `dy`) cells: each footprint cell takes `strength` × coverage of the
-   * water and suspended pigment of the cell it came from (a smudge through wet paint).
+   * water and suspended pigment (and light) of the cell it came from (a smudge through wet paint).
    */
   drag(id, rect, cov, dx, dy, strength) {
     const lane = this.laneOf(id);
@@ -1664,14 +1732,14 @@ var WetWorld = class {
     );
     const f = this.f32;
     const taken = moves.map(([from, , a]) => {
-      const t = new Float32Array(14);
+      const t = new Float32Array(10 + MASS_CHANNELS);
       for (let k = 0; k < 9; k++) {
         t[k] = f[from + k * PLANE] * a;
         f[from + k * PLANE] -= t[k];
       }
       t[9] = f[from + P_RHO * PLANE] * a;
       f[from + P_RHO * PLANE] -= t[9];
-      for (let q = 0; q < 4; q++) {
+      for (let q = 0; q < MASS_CHANNELS; q++) {
         t[10 + q] = f[from + (P_P0 + q) * PLANE] * a;
         f[from + (P_P0 + q) * PLANE] -= t[10 + q];
       }
@@ -1681,19 +1749,22 @@ var WetWorld = class {
       const t = taken[i];
       for (let k = 0; k < 9; k++) f[to + k * PLANE] += t[k];
       f[to + P_RHO * PLANE] += t[9];
-      for (let q = 0; q < 4; q++) f[to + (P_P0 + q) * PLANE] += t[10 + q];
+      for (let q = 0; q < MASS_CHANNELS; q++) f[to + (P_P0 + q) * PLANE] += t[10 + q];
     });
     this.refreshHalos();
   }
   /**
    * Re-wetting: lifts `amount` × coverage of the dried paint in the layer's pixels (`base`) back into
-   * the paper as settled pigment, so water can move it again. Only where there is surface water.
+   * the paper as settled pigment, so water can move it again, and the same share of its light
+   * paint (`light`) as settled light. Only where there is surface water.
    */
   rewet(id, rect, cov, amount, paper) {
     const lane = this.laneOf(id);
     const pig = [0, 0, 0, 0];
     const tiles = new Map(lane.base.tiles);
     const written = /* @__PURE__ */ new Set();
+    const lightTiles = lane.lit ? new Map(lane.light.tiles) : null;
+    const lightWritten = /* @__PURE__ */ new Set();
     const scratch2 = new Uint8ClampedArray(4);
     this.footprint(
       id,
@@ -1704,6 +1775,22 @@ var WetWorld = class {
         const a = Math.min(1, Math.max(0, amount * w));
         if (!(a > 0)) return;
         const key = tileKey(x >> 8, y >> 8);
+        const li = (y & 255) * TILE + (x & 255);
+        let lt = lightTiles?.get(key);
+        if (lt && (lt.uniform ?? 1) !== 0) {
+          if (!lightWritten.has(key)) {
+            const data = lt.data.length ? new Uint8ClampedArray(lt.data) : new Uint8ClampedArray(TILE * TILE).fill(lt.uniform ?? 0);
+            lt = { data, uniform: null };
+            lightTiles.set(key, lt);
+            lightWritten.add(key);
+          }
+          const lv = lt.data[li];
+          if (lv > 0) {
+            const lifted = Math.round(lv * a);
+            lt.data[li] = lv - lifted;
+            this.f32[this.single(c) + P_DL * PLANE] += Math.fround(lifted / 255);
+          }
+        }
         let tile = tiles.get(key);
         if (!tile) return;
         if (!written.has(key)) {
@@ -1731,6 +1818,14 @@ var WetWorld = class {
       }
       this.setBase(id, new TiledSurface(4, tiles, 0));
     }
+    if (lightWritten.size) {
+      for (const key of lightWritten) {
+        const t = finishTile(lightTiles.get(key).data, 1, 0);
+        if (t) lightTiles.set(key, t);
+        else lightTiles.delete(key);
+      }
+      this.setLight(id, new TiledSurface(1, lightTiles, 0));
+    }
   }
   /**
    * Dries wet paint at once (everything settles where it is, the water goes): in `rect`, or the
@@ -1763,7 +1858,7 @@ var WetWorld = class {
         for (let x = x0; x < x1; x++) {
           const c = this.cell(lane, x, y);
           const d = this.single(c) + P_D0 * PLANE;
-          for (let q = 0; q < 4; q++) {
+          for (let q = 0; q < MASS_CHANNELS; q++) {
             f[d + q * PLANE] += f[c + (P_P0 + q) * PLANE];
             f[c + (P_P0 + q) * PLANE] = 0;
           }
@@ -1790,9 +1885,21 @@ var WetWorld = class {
     const lane = this.lanes[this.laneIndexOf(key)];
     const [tx, ty] = this.tileXY(key);
     const tk = tileKey(tx, ty);
+    let lightChanged = false;
+    if (lane.lit) {
+      const lout = this.shadeLightSlot(key, lane.light.tiles.get(tk) ?? null, all ? "bake-all" : "bake");
+      if (lout) {
+        const tiles2 = new Map(lane.light.tiles);
+        const t2 = finishTile(lout, 1, 0);
+        if (t2) tiles2.set(tk, t2);
+        else tiles2.delete(tk);
+        this.setLight(lane.id, new TiledSurface(1, tiles2, 0));
+        lightChanged = true;
+      }
+    }
     const src = lane.base.tiles.get(tk)?.data ?? null;
     const out = this.shadeSlot(key, src, all ? "bake-all" : "bake");
-    if (!out) return false;
+    if (!out) return lightChanged;
     const tiles = new Map(lane.base.tiles);
     const t = finishTile(out, 4, 0);
     if (t) tiles.set(tk, t);
@@ -1800,6 +1907,19 @@ var WetWorld = class {
     this.setBase(lane.id, new TiledSurface(4, tiles, 0));
     return true;
   }
+  /** `shadeSlot` for light paint: one channel over a light tile (see `shadeLightTile`); `null` when nothing would change. */
+  shadeLightSlot(key, src, mode) {
+    const [tx, ty] = this.tileXY(key);
+    const b = this.slotBase(this.slotOf(key));
+    const cur = b + this.parity * SET_PLANES * PLANE;
+    const full = src ? src.data.length ? src.data : new Uint8ClampedArray(TILE * TILE).fill(src.uniform ?? 0) : null;
+    const out = full ? new Uint8ClampedArray(full) : new Uint8ClampedArray(TILE * TILE);
+    const w = Math.min(WET_TILE, this.width - tx * WET_TILE);
+    const h = Math.min(WET_TILE, this.height - ty * WET_TILE);
+    const live = mode !== "bake";
+    const changed = shadeLightTile(this.f32, PLANE, S2, b + P_D0 * PLANE, live ? cur + P_P0 * PLANE : -1, b + P_DL * PLANE, live ? cur + P_L * PLANE : -1, full, out, w, h);
+    return changed ? out : null;
+  }
   /**
    * Shades one slot over a base tile. `display`: the wet look (suspended + settled, wet paper a
    * little darker); `bake`: settled pigment only; `bake-all`: suspended and settled (dry now).
@@ -1812,6 +1932,7 @@ var WetWorld = class {
     const out = src ? new Uint8ClampedArray(src) : new Uint8ClampedArray(TILE * TILE * 4);
     const w = Math.min(WET_TILE, this.width - tx * WET_TILE);
     const h = Math.min(WET_TILE, this.height - ty * WET_TILE);
+    const lit = this.lanes[this.laneIndexOf(key)].lit;
     const changed = shadeTile(
       this.f32,
       PLANE,
@@ -1824,7 +1945,10 @@ var WetWorld = class {
       out,
       w,
       h,
-      this.paperBytes
+      this.paperBytes,
+      // Glowing paint shows its own hue (see shadeTile).
+      lit ? b + P_DL * PLANE : -1,
+      lit && mode !== "bake" ? cur + P_L * PLANE : -1
     );
     return changed ? out : null;
   }
@@ -1844,6 +1968,23 @@ var WetWorld = class {
     }
     return new TiledSurface(4, tiles, 0);
   }
+  /** The layer's light paint with all its wet paint dried where it is (`bakedSurface` for light); changes nothing. */
+  bakedLight(id) {
+    this.requireIdle();
+    const lane = this.laneOf(id);
+    if (!lane.lit) return lane.light;
+    const tiles = new Map(lane.light.tiles);
+    for (const key of this.active) {
+      if (this.laneIndexOf(key) !== lane.index) continue;
+      const tk = this.tileKeyOf(key);
+      const out = this.shadeLightSlot(key, lane.light.tiles.get(tk) ?? null, "bake-all");
+      if (!out) continue;
+      const t = finishTile(out, 1, 0);
+      if (t) tiles.set(tk, t);
+      else tiles.delete(tk);
+    }
+    return new TiledSurface(1, tiles, 0);
+  }
   // --- Reading -------------------------------------------------------------------
   /**
    * Sums over a footprint of a lane, weighted by coverage: `weight` (coverage), `water` (surface
@@ -1972,6 +2113,38 @@ var WetWorld = class {
     lane.displayKey = displayKey;
     return { surface: lane.display, changed, pending: stale.length - done };
   }
+  /**
+   * The layer's light paint with its live light shaded in (`null` when the layer has none): the
+   * light under the wet paint with each live tile's light over it. Like `display`, every stale
+   * tile is reshaded (light tiles are cheap: one channel, no colour maths).
+   */
+  lightDisplay(id) {
+    const lane = this.laneOf(id);
+    if (!lane.lit) return null;
+    const keys = this.active.filter((k) => this.laneIndexOf(k) === lane.index);
+    let changed = false;
+    const live = /* @__PURE__ */ new Set();
+    for (const key2 of keys) {
+      const tk = this.tileKeyOf(key2);
+      live.add(tk);
+      if (lane.lightShaded.get(tk)?.stamp === lane.stamp) continue;
+      const src = lane.light.tiles.get(tk) ?? null;
+      const out = this.shadeLightSlot(key2, src, "display");
+      lane.lightShaded.set(tk, { stamp: lane.stamp, tile: out ? finishTile(out, 1, 0) : src });
+      changed = true;
+    }
+    for (const tk of [...lane.lightShaded.keys()]) if (!live.has(tk) && lane.lightShaded.delete(tk)) changed = true;
+    const key = `${lane.light.id}`;
+    if (!changed && lane.lightDisplay && lane.lightKey === key) return lane.lightDisplay;
+    const tiles = new Map(lane.light.tiles);
+    for (const [tk, { tile }] of lane.lightShaded) {
+      if (tile) tiles.set(tk, tile);
+      else tiles.delete(tk);
+    }
+    lane.lightDisplay = new TiledSurface(1, tiles, 0);
+    lane.lightKey = key;
+    return lane.lightDisplay;
+  }
   /**
    * The water as an overlay tile (RGBA, blue, alpha from surface depth and damp paper) for a
    * document tile, or `null` where nothing is wet.
@@ -2104,7 +2277,7 @@ var WetWorld = class {
       }
       const from = y0 * SLOT_SIDE;
       const to = (y1 + 1) * SLOT_SIDE;
-      const planes = [...Array(SET_PLANES).keys()].map((k) => this.parity * SET_PLANES + k).concat([P_D0, P_D0 + 1, P_D0 + 2, P_D0 + 3]);
+      const planes = [...Array(SET_PLANES).keys()].map((k) => this.parity * SET_PLANES + k).concat([...Array(MASS_CHANNELS).keys()].map((q) => P_D0 + q));
       for (const plane of planes) gpu.writeSlot(slot, plane * PLANE + from, this.f32.subarray(b + plane * PLANE + from, b + plane * PLANE + to));
     }
     this.gpuDirty.clear();
@@ -2189,11 +2362,11 @@ var WetWorld = class {
       const b = this.slotBase(this.slotOf(key));
       const planes = new Float32Array(SNAP_PLANES * PLANE);
       planes.set(this.f32.subarray(b + this.parity * SET_PLANES * PLANE, b + (this.parity + 1) * SET_PLANES * PLANE), 0);
-      planes.set(this.f32.subarray(b + P_D0 * PLANE, b + (P_D0 + 4) * PLANE), SET_PLANES * PLANE);
+      planes.set(this.f32.subarray(b + P_D0 * PLANE, b + (P_D0 + MASS_CHANNELS) * PLANE), SET_PLANES * PLANE);
       slots.set(key, { planes, last: this.u32[(this.layout.last >> 2) + key] });
       bytes += planes.byteLength;
     }
-    const lanes = this.lanes.filter((l) => Boolean(l)).map((l) => ({ id: l.id, index: l.index, params: { ...l.params }, flow: l.flow, flowStrength: l.flowStrength, base: l.base }));
+    const lanes = this.lanes.filter((l) => Boolean(l)).map((l) => ({ id: l.id, index: l.index, params: { ...l.params }, flow: l.flow, flowStrength: l.flowStrength, base: l.base, light: l.light, lit: l.lit }));
     return { clock: this.clock, tilt: { ...this.tilt }, lanes, slots, bytes };
   }
   /** Puts a snapshot back exactly (the simulation then continues as it would have). */
@@ -2203,7 +2376,9 @@ var WetWorld = class {
     this.lanes.fill(null);
     this.tilt = { ...snap.tilt };
     for (const l of snap.lanes) {
-      this.lanes[l.index] = { id: l.id, index: l.index, params: { ...l.params }, flow: l.flow, flowStrength: l.flowStrength, base: l.base, shaded: /* @__PURE__ */ new Map(), urgent: /* @__PURE__ */ new Set(), stamp: 1, display: null, shadedVersion: 0, displayKey: "" };
+      const lane = newLane(l.id, l.index, { ...l.params }, l.flow, l.flowStrength, l.base, l.light);
+      lane.lit = lane.lit || Boolean(l.lit);
+      this.lanes[l.index] = lane;
       this.pack(this.lanes[l.index]);
     }
     for (const [key, { planes, last }] of snap.slots) {
@@ -2260,7 +2435,7 @@ function moveWetSnapshot(snap, from, to, dx, dy, lane = () => ({})) {
   }
   const lanes = snap.lanes.map((l) => {
     const moved = lane(l);
-    return { ...l, base: moved.base ?? l.base, flow: moved.flow === void 0 ? l.flow : moved.flow };
+    return { ...l, base: moved.base ?? l.base, light: moved.light ?? l.light, flow: moved.flow === void 0 ? l.flow : moved.flow };
   });
   return { clock: snap.clock, tilt: { ...snap.tilt }, lanes, slots, bytes };
 }
@@ -2396,6 +2571,7 @@ var WetMedium = class {
   }
   deposit(rect, cov, dep, paint, _pigment, field = null) {
     const { water, mass, body } = this.options;
+    const light = (this.options.light ?? 0) * dep;
     if (field) {
       const n = rect.width * rect.height;
       const out = new Float32Array(n * 4);
@@ -2404,12 +2580,12 @@ var WetMedium = class {
         pigmentOf([field[p * 3], field[p * 3 + 1], field[p * 3 + 2]], body, one);
         for (let q = 0; q < 4; q++) out[p * 4 + q] = one[q] * mass * dep;
       }
-      this.world.paint(this.laneId, rect, cov, water * dep, null, out);
+      this.world.paint(this.laneId, rect, cov, water * dep, null, out, light);
       return;
     }
     pigmentOf(paint, body, this.pig);
     const pig = [0, 1, 2, 3].map((q) => this.pig[q] * mass * dep);
-    this.world.paint(this.laneId, rect, cov, water * dep, mass > 0 ? pig : null);
+    this.world.paint(this.laneId, rect, cov, water * dep, mass > 0 ? pig : null, null, light);
   }
 };
 
@@ -2482,7 +2658,10 @@ function faces() {
     let pn = vec4<f32>(st[pS + nb], st[pS + PL + nb], st[pS + 2u * PL + nb], st[pS + 3u * PL + nb]);
     let flux = ${outF ? "select(uf * pn, uf * pc, uf > 0.0)" : "select(uf * pc, uf * pn, uf > 0.0)"};
     let v = pNew ${outF ? "-" : "+"} flux + bleed * (pn - pc);
-    if (rxWet && st[rhoS + nb] >= EPS) { pNew = v; }
+    let ln = st[pS + 4u * PL + nb];
+    let fluxL = ${outF ? "select(uf * ln, uf * lc, uf > 0.0)" : "select(uf * lc, uf * ln, uf > 0.0)"};
+    let vL = lNew ${outF ? "-" : "+"} fluxL + bleed * (ln - lc);
+    if (rxWet && st[rhoS + nb] >= EPS) { pNew = v; lNew = vL; }
   }`;
   });
   return out;
@@ -2605,12 +2784,14 @@ ${stream()}
   st[dst + c] = (f0 + omega * (wr0 * (1.0 - usq) - f0)) * scale;
 ${collide()}
 
-  // 5. pigment: upwind advection with the last step's velocities, plus bleed
+  // 5. pigment and light: upwind advection with the last step's velocities, plus bleed
   let rxWet = !rxDry;
   let uxc = st[uxS + c];
   let uyc = st[uyS + c];
   var pNew = vec4<f32>(st[pS + c], st[pS + PL + c], st[pS + 2u * PL + c], st[pS + 3u * PL + c]);
   let pc = pNew;
+  var lNew = st[pS + 4u * PL + c];
+  let lc = lNew;
 ${faces()}
 
   // 6. deposition and pickup
@@ -2627,6 +2808,15 @@ ${faces()}
     st[dst + (${P_P0}u + q) * PL + c] = pq - dep + lq;
     st[dP + q * PL + c] = dq + dep - lq;
   }
+  {
+    let pq = max(0.0, lNew);
+    let dq = st[dP + 4u * PL + c];
+    var dep = min(pq, pq * rate);
+    if (dryNow) { dep = pq; }
+    let lq = dq * lift;
+    st[dst + ${P_P0 + 4}u * PL + c] = pq - dep + lq;
+    st[dP + 4u * PL + c] = dq + dep - lq;
+  }
   let mean4 = (st[eS + c + 1u] + st[eS + c - 1u] + st[eS + c + S] + st[eS + c - S]) * 0.25;
   let eNew = min(1.0, max(min(1.0, dryNb * 0.25), DECAY * mean4));
   st[dst + ${P_EDGE}u * PL + c] = select(eNew, 0.0, dryNow);
@@ -2754,12 +2944,18 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
   if (s > 1e-9) { inv = 1.0 / s; }
   var film = keep * exp(-2.0 * k.xyz) * below;
   if (hide > 0.0) { film = film + hide * vec3<f32>(rinf(k.x * inv), rinf(k.y * inv), rinf(k.z * inv)); }
+  // Light paint: glowing paint shows its own hue (the film over white), as shadeTile does.
+  let l = min(1.0, st[d + 4u * PL + c] + st[p + 4u * PL + c]);
+  if (l > 1e-7) {
+    var w = keep * exp(-2.0 * k.xyz);
+    if (hide > 0.0) { w = w + hide * vec3<f32>(rinf(k.x * inv), rinf(k.y * inv), rinf(k.z * inv)); }
+    film = film + l * (w - film);
+  }
   let dark = 1.0 - 0.07 * wet;
   let e = vec3<f32>(toByte(film.x * dark), toByte(film.y * dark), toByte(film.z * dark));
-  var alpha = a;
-  alpha = needAlpha(e.x, paper.x, alpha);
-  alpha = needAlpha(e.y, paper.y, alpha);
-  alpha = needAlpha(e.z, paper.z, alpha);
+  var alpha = needAlpha(e.z, paper.z, needAlpha(e.y, paper.y, needAlpha(e.x, paper.x, 0.0)));
+  if (hide > 0.0 && alpha < 1.0) { alpha = alpha + hide * (1.0 - alpha); }
+  alpha = max(alpha, a);
   if (alpha <= 0.0) { outTiles[o] = px & 0x00ffffffu; return; }
   let a8 = max(round(min(1.0, alpha) * 255.0), pr.w);
   let al = a8 / 255.0;
@@ -3140,14 +3336,17 @@ export {
   P_UY,
   P_SW,
   P_P0,
+  P_L,
   P_EDGE,
   P_D0,
+  P_DL,
   P_H,
   P_FX,
   P_FY,
   SLOT_PLANES,
   SLOT_BYTES,
   PIGMENT_CHANNELS,
+  MASS_CHANNELS,
   EX,
   EY,
   OPP,
@@ -3192,6 +3391,7 @@ export {
   filmPixel,
   pixelPigment,
   shadeTile,
+  shadeLightTile,
   stepSlotTs,
   loadWetKernel,
   canShareMemory,