@pixerate/editor 0.243.0 → 0.244.0

package/dist/{chunk-XFYLA3ZO.cjs → chunk-VMROIWLL.cjs}

@@ -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 = Promise.resolve().then(() => _interopRequireWildcard(require("./kernel-wasm-6FPOLVUZ.cjs"))).then((m) => WebAssembly.compile(decode(shared ? m.WET_KERNEL_SHARED : m.WET_KERNEL_SINGLE)));
+    p = Promise.resolve().then(() => _interopRequireWildcard(require("./kernel-wasm-TTYRBGAK.cjs"))).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 (0, _chunk474IQG74cjs.TiledSurface)(1, /* @__PURE__ */ new Map(), 0);
+function newLane(id, index, params, flow, flowStrength, base, light) {
+  const l = _nullishCoalesce(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 = 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(_nullishCoalesce(options.params, () => ( {})), DEFAULT_WET_PARAMS),
-      flow: _nullishCoalesce(options.flow, () => ( null)),
-      flowStrength: options.flow ? _nullishCoalesce(options.flowStrength, () => ( 1)) : 0,
-      base: _nullishCoalesce(options.base, () => ( new (0, _chunk474IQG74cjs.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(_nullishCoalesce(options.params, () => ( {})), DEFAULT_WET_PARAMS), _nullishCoalesce(options.flow, () => ( null)), options.flow ? _nullishCoalesce(options.flowStrength, () => ( 1)) : 0, _nullishCoalesce(options.base, () => ( new (0, _chunk474IQG74cjs.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 = 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, _nullishCoalesce(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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = class {
         const a = Math.min(1, Math.max(0, amount * w));
         if (!(a > 0)) return;
         const key = _chunk474IQG74cjs.tileKey.call(void 0, x >> 8, y >> 8);
+        const li = (y & 255) * _chunk474IQG74cjs.TILE + (x & 255);
+        let lt = _optionalChain([lightTiles, 'optionalAccess', _19 => _19.get, 'call', _20 => _20(key)]);
+        if (lt && (_nullishCoalesce(lt.uniform, () => ( 1))) !== 0) {
+          if (!lightWritten.has(key)) {
+            const data = lt.data.length ? new Uint8ClampedArray(lt.data) : new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE).fill(_nullishCoalesce(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 = class {
       }
       this.setBase(id, new (0, _chunk474IQG74cjs.TiledSurface)(4, tiles, 0));
     }
+    if (lightWritten.size) {
+      for (const key of lightWritten) {
+        const t = _chunk474IQG74cjs.finishTile.call(void 0, lightTiles.get(key).data, 1, 0);
+        if (t) lightTiles.set(key, t);
+        else lightTiles.delete(key);
+      }
+      this.setLight(id, new (0, _chunk474IQG74cjs.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 = 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 = class {
     const lane = this.lanes[this.laneIndexOf(key)];
     const [tx, ty] = this.tileXY(key);
     const tk = _chunk474IQG74cjs.tileKey.call(void 0, tx, ty);
-    const src = _nullishCoalesce(_optionalChain([lane, 'access', _19 => _19.base, 'access', _20 => _20.tiles, 'access', _21 => _21.get, 'call', _22 => _22(tk), 'optionalAccess', _23 => _23.data]), () => ( null));
+    let lightChanged = false;
+    if (lane.lit) {
+      const lout = this.shadeLightSlot(key, _nullishCoalesce(lane.light.tiles.get(tk), () => ( null)), all ? "bake-all" : "bake");
+      if (lout) {
+        const tiles2 = new Map(lane.light.tiles);
+        const t2 = _chunk474IQG74cjs.finishTile.call(void 0, lout, 1, 0);
+        if (t2) tiles2.set(tk, t2);
+        else tiles2.delete(tk);
+        this.setLight(lane.id, new (0, _chunk474IQG74cjs.TiledSurface)(1, tiles2, 0));
+        lightChanged = true;
+      }
+    }
+    const src = _nullishCoalesce(_optionalChain([lane, 'access', _21 => _21.base, 'access', _22 => _22.tiles, 'access', _23 => _23.get, 'call', _24 => _24(tk), 'optionalAccess', _25 => _25.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 = _chunk474IQG74cjs.finishTile.call(void 0, out, 4, 0);
     if (t) tiles.set(tk, t);
@@ -1800,6 +1907,19 @@ var WetWorld = (_class = class {
     this.setBase(lane.id, new (0, _chunk474IQG74cjs.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(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE).fill(_nullishCoalesce(src.uniform, () => ( 0))) : null;
+    const out = full ? new Uint8ClampedArray(full) : new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.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 = class {
     const out = src ? new Uint8ClampedArray(src) : new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.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 = 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;
   }
@@ -1836,7 +1960,7 @@ var WetWorld = (_class = class {
     for (const key of this.active) {
       if (this.laneIndexOf(key) !== lane.index) continue;
       const tk = this.tileKeyOf(key);
-      const out = this.shadeSlot(key, _nullishCoalesce(_optionalChain([lane, 'access', _24 => _24.base, 'access', _25 => _25.tiles, 'access', _26 => _26.get, 'call', _27 => _27(tk), 'optionalAccess', _28 => _28.data]), () => ( null)), "bake-all");
+      const out = this.shadeSlot(key, _nullishCoalesce(_optionalChain([lane, 'access', _26 => _26.base, 'access', _27 => _27.tiles, 'access', _28 => _28.get, 'call', _29 => _29(tk), 'optionalAccess', _30 => _30.data]), () => ( null)), "bake-all");
       if (!out) continue;
       const t = _chunk474IQG74cjs.finishTile.call(void 0, out, 4, 0);
       if (t) tiles.set(tk, t);
@@ -1844,6 +1968,23 @@ var WetWorld = (_class = class {
     }
     return new (0, _chunk474IQG74cjs.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, _nullishCoalesce(lane.light.tiles.get(tk), () => ( null)), "bake-all");
+      if (!out) continue;
+      const t = _chunk474IQG74cjs.finishTile.call(void 0, out, 1, 0);
+      if (t) tiles.set(tk, t);
+      else tiles.delete(tk);
+    }
+    return new (0, _chunk474IQG74cjs.TiledSurface)(1, tiles, 0);
+  }
   // --- Reading -------------------------------------------------------------------
   /**
    * Sums over a footprint of a lane, weighted by coverage: `weight` (coverage), `water` (surface
@@ -1942,14 +2083,14 @@ var WetWorld = (_class = class {
   display(id, maxTiles = Infinity) {
     const lane = this.laneOf(id);
     const keys = this.active.filter((k) => this.laneIndexOf(k) === lane.index);
-    const stale = keys.filter((k) => _optionalChain([lane, 'access', _29 => _29.shaded, 'access', _30 => _30.get, 'call', _31 => _31(this.tileKeyOf(k)), 'optionalAccess', _32 => _32.stamp]) !== lane.stamp);
-    stale.sort((a, b) => Number(lane.urgent.has(this.tileKeyOf(b))) - Number(lane.urgent.has(this.tileKeyOf(a))) || (_nullishCoalesce(_optionalChain([lane, 'access', _33 => _33.shaded, 'access', _34 => _34.get, 'call', _35 => _35(this.tileKeyOf(a)), 'optionalAccess', _36 => _36.stamp]), () => ( 0))) - (_nullishCoalesce(_optionalChain([lane, 'access', _37 => _37.shaded, 'access', _38 => _38.get, 'call', _39 => _39(this.tileKeyOf(b)), 'optionalAccess', _40 => _40.stamp]), () => ( 0))));
+    const stale = keys.filter((k) => _optionalChain([lane, 'access', _31 => _31.shaded, 'access', _32 => _32.get, 'call', _33 => _33(this.tileKeyOf(k)), 'optionalAccess', _34 => _34.stamp]) !== lane.stamp);
+    stale.sort((a, b) => Number(lane.urgent.has(this.tileKeyOf(b))) - Number(lane.urgent.has(this.tileKeyOf(a))) || (_nullishCoalesce(_optionalChain([lane, 'access', _35 => _35.shaded, 'access', _36 => _36.get, 'call', _37 => _37(this.tileKeyOf(a)), 'optionalAccess', _38 => _38.stamp]), () => ( 0))) - (_nullishCoalesce(_optionalChain([lane, 'access', _39 => _39.shaded, 'access', _40 => _40.get, 'call', _41 => _41(this.tileKeyOf(b)), 'optionalAccess', _42 => _42.stamp]), () => ( 0))));
     const changed = [];
     let done = 0;
     for (const key of stale) {
       if (done >= maxTiles) break;
       const tk = this.tileKeyOf(key);
-      const src = _nullishCoalesce(_optionalChain([lane, 'access', _41 => _41.base, 'access', _42 => _42.tiles, 'access', _43 => _43.get, 'call', _44 => _44(tk), 'optionalAccess', _45 => _45.data]), () => ( null));
+      const src = _nullishCoalesce(_optionalChain([lane, 'access', _43 => _43.base, 'access', _44 => _44.tiles, 'access', _45 => _45.get, 'call', _46 => _46(tk), 'optionalAccess', _47 => _47.data]), () => ( null));
       const out = this.shadeSlot(key, src, "display");
       const tile = out ? _chunk474IQG74cjs.finishTile.call(void 0, out, 4, 0) : _nullishCoalesce(lane.base.tiles.get(tk), () => ( null));
       lane.shaded.set(tk, { stamp: lane.stamp, tile: _nullishCoalesce(tile, () => ( { data: new Uint8ClampedArray(0), uniform: 0 })) });
@@ -1972,6 +2113,38 @@ var WetWorld = (_class = 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 (_optionalChain([lane, 'access', _48 => _48.lightShaded, 'access', _49 => _49.get, 'call', _50 => _50(tk), 'optionalAccess', _51 => _51.stamp]) === lane.stamp) continue;
+      const src = _nullishCoalesce(lane.light.tiles.get(tk), () => ( null));
+      const out = this.shadeLightSlot(key2, src, "display");
+      lane.lightShaded.set(tk, { stamp: lane.stamp, tile: out ? _chunk474IQG74cjs.finishTile.call(void 0, 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 (0, _chunk474IQG74cjs.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 = 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();
@@ -2152,7 +2325,7 @@ var WetWorld = (_class = class {
     if (!this.gpu || this.busyFlag && !plan || !plan && !this.gpuDecide()) return { ...this.display(id, maxCpuTiles), gpu: false };
     const lane = this.laneOf(id);
     const keys = this.active.filter((k) => this.laneIndexOf(k) === lane.index);
-    const stale = plan ? keys : keys.filter((k) => _optionalChain([lane, 'access', _46 => _46.shaded, 'access', _47 => _47.get, 'call', _48 => _48(this.tileKeyOf(k)), 'optionalAccess', _49 => _49.stamp]) !== lane.stamp);
+    const stale = plan ? keys : keys.filter((k) => _optionalChain([lane, 'access', _52 => _52.shaded, 'access', _53 => _53.get, 'call', _54 => _54(this.tileKeyOf(k)), 'optionalAccess', _55 => _55.stamp]) !== lane.stamp);
     if (!stale.length) return { ...this.display(id, 0), gpu: true };
     let tiles;
     const stamp = lane.stamp;
@@ -2160,7 +2333,7 @@ var WetWorld = (_class = class {
     try {
       if (!plan) this.gpuSync();
       const parity = plan ? plan.parity + plan.done & 1 : this.parity;
-      tiles = await this.gpu.shade(this.gpuJobs(stale), parity, stale.map((k) => _nullishCoalesce(_optionalChain([base, 'access', _50 => _50.tiles, 'access', _51 => _51.get, 'call', _52 => _52(this.tileKeyOf(k)), 'optionalAccess', _53 => _53.data]), () => ( null))), [this.paperBytes[0], this.paperBytes[1], this.paperBytes[2]]);
+      tiles = await this.gpu.shade(this.gpuJobs(stale), parity, stale.map((k) => _nullishCoalesce(_optionalChain([base, 'access', _56 => _56.tiles, 'access', _57 => _57.get, 'call', _58 => _58(this.tileKeyOf(k)), 'optionalAccess', _59 => _59.data]), () => ( null))), [this.paperBytes[0], this.paperBytes[1], this.paperBytes[2]]);
     } catch (e) {
       this.gpuStop(`Wet paint stopped using the GPU (${e.message}).`);
       return { ...this.display(id, maxCpuTiles), gpu: false };
@@ -2189,11 +2362,11 @@ var WetWorld = (_class = 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 = 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: _nullishCoalesce(moved.base, () => ( l.base)), flow: moved.flow === void 0 ? l.flow : moved.flow };
+    return { ...l, base: _nullishCoalesce(moved.base, () => ( l.base)), light: _nullishCoalesce(moved.light, () => ( l.light)), flow: moved.flow === void 0 ? l.flow : moved.flow };
   });
   return { clock: snap.clock, tilt: { ...snap.tilt }, lanes, slots, bytes };
 }
@@ -2337,8 +2512,8 @@ function normalizeFlow(raw = {}, base = DEFAULT_FLOW) {
 }
 function flowField(spec, width, height) {
   const k = FLOW_ACCEL;
-  const cx = _nullishCoalesce(_optionalChain([spec, 'access', _54 => _54.center, 'optionalAccess', _55 => _55.x]), () => ( width / 2));
-  const cy = _nullishCoalesce(_optionalChain([spec, 'access', _56 => _56.center, 'optionalAccess', _57 => _57.y]), () => ( height / 2));
+  const cx = _nullishCoalesce(_optionalChain([spec, 'access', _60 => _60.center, 'optionalAccess', _61 => _61.x]), () => ( width / 2));
+  const cy = _nullishCoalesce(_optionalChain([spec, 'access', _62 => _62.center, 'optionalAccess', _63 => _63.y]), () => ( height / 2));
   const r0 = Math.max(width, height) / 2;
   switch (spec.kind) {
     case "none":
@@ -2396,6 +2571,7 @@ var WetMedium = (_class2 = class {
   }
   deposit(rect, cov, dep, paint, _pigment, field = null) {
     const { water, mass, body } = this.options;
+    const light = (_nullishCoalesce(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 = (_class2 = 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);
   }
 }, _class2);
 
@@ -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;
@@ -2780,7 +2976,7 @@ var UNIFORM = 64;
 var STORAGE = 128;
 function findWebGpu() {
   const nav = globalThis.navigator;
-  return _nullishCoalesce(_optionalChain([nav, 'optionalAccess', _58 => _58.gpu]), () => ( null));
+  return _nullishCoalesce(_optionalChain([nav, 'optionalAccess', _64 => _64.gpu]), () => ( null));
 }
 async function createWetGpuEngine(gpu = findWebGpu()) {
   const no = (reason, adapter2 = null) => ({ engine: null, support: { supported: false, reason, adapter: adapter2, maxSlots: 0 } });
@@ -2792,7 +2988,7 @@ async function createWetGpuEngine(gpu = findWebGpu()) {
     return no(`WebGPU gave no adapter (${e.message}); wet paint runs on the CPU.`);
   }
   if (!adapter) return no("WebGPU gave no adapter (the GPU may be blocklisted); wet paint runs on the CPU.");
-  const name = [_optionalChain([adapter, 'access', _59 => _59.info, 'optionalAccess', _60 => _60.vendor]), _optionalChain([adapter, 'access', _61 => _61.info, 'optionalAccess', _62 => _62.architecture])].filter(Boolean).join(" ") || null;
+  const name = [_optionalChain([adapter, 'access', _65 => _65.info, 'optionalAccess', _66 => _66.vendor]), _optionalChain([adapter, 'access', _67 => _67.info, 'optionalAccess', _68 => _68.architecture])].filter(Boolean).join(" ") || null;
   const binding = Math.min(_nullishCoalesce(adapter.limits.maxStorageBufferBindingSize, () => ( 0)), _nullishCoalesce(adapter.limits.maxBufferSize, () => ( 0)));
   const maxSlots = Math.min(MAX_WET_SLOTS, Math.floor(binding / SLOT_BYTES));
   if (maxSlots < 4) return no(`The GPU's storage buffers hold ${Math.max(0, maxSlots)} wet tiles; at least 4 are needed. Wet paint runs on the CPU.`, name);
@@ -2812,27 +3008,27 @@ async function createWetGpuEngine(gpu = findWebGpu()) {
     const engine = await WetGpuEngine.start(device, maxSlots, name);
     return { engine, support: { supported: true, reason: null, adapter: name, maxSlots } };
   } catch (e) {
-    _optionalChain([device, 'access', _63 => _63.destroy, 'optionalCall', _64 => _64()]);
+    _optionalChain([device, 'access', _69 => _69.destroy, 'optionalCall', _70 => _70()]);
     return no(`The wet-media shaders did not compile on this GPU (${e.message}); wet paint runs on the CPU.`, name);
   }
 }
 async function wetGpuSupport(gpu = findWebGpu()) {
   const { engine, support } = await createWetGpuEngine(gpu);
-  _optionalChain([engine, 'optionalAccess', _65 => _65.destroy, 'call', _66 => _66()]);
+  _optionalChain([engine, 'optionalAccess', _71 => _71.destroy, 'call', _72 => _72()]);
   return support;
 }
 async function pipeline(device, code, label) {
-  _optionalChain([device, 'access', _67 => _67.pushErrorScope, 'optionalCall', _68 => _68("validation")]);
+  _optionalChain([device, 'access', _73 => _73.pushErrorScope, 'optionalCall', _74 => _74("validation")]);
   const module = device.createShaderModule({ code, label });
-  const info = await _optionalChain([module, 'access', _69 => _69.getCompilationInfo, 'optionalCall', _70 => _70()]);
-  const errors = _nullishCoalesce(_optionalChain([info, 'optionalAccess', _71 => _71.messages, 'access', _72 => _72.filter, 'call', _73 => _73((m) => m.type === "error")]), () => ( []));
+  const info = await _optionalChain([module, 'access', _75 => _75.getCompilationInfo, 'optionalCall', _76 => _76()]);
+  const errors = _nullishCoalesce(_optionalChain([info, 'optionalAccess', _77 => _77.messages, 'access', _78 => _78.filter, 'call', _79 => _79((m) => m.type === "error")]), () => ( []));
   if (errors.length) {
-    await _optionalChain([device, 'access', _74 => _74.popErrorScope, 'optionalCall', _75 => _75()]);
+    await _optionalChain([device, 'access', _80 => _80.popErrorScope, 'optionalCall', _81 => _81()]);
     throw new Error(`${label}: ${errors.map((m) => `line ${m.lineNum}: ${m.message}`).join("; ")}`);
   }
   const desc = { layout: "auto", compute: { module, entryPoint: "main" }, label };
   const p = device.createComputePipelineAsync ? await device.createComputePipelineAsync(desc) : device.createComputePipeline(desc);
-  const err = await _optionalChain([device, 'access', _76 => _76.popErrorScope, 'optionalCall', _77 => _77()]);
+  const err = await _optionalChain([device, 'access', _82 => _82.popErrorScope, 'optionalCall', _83 => _83()]);
   if (err) throw new Error(`${label}: ${err.message}`);
   return p;
 }
@@ -2858,8 +3054,8 @@ var WetGpuEngine = (_class3 = class _WetGpuEngine {
       return b;
     });
     this.shadeUni = d.createBuffer({ size: 16, usage: UNIFORM | COPY_DST, label: "wet shade" });
-    void _optionalChain([device, 'access', _78 => _78.lost, 'optionalAccess', _79 => _79.then, 'call', _80 => _80((info) => {
-      this.lostReason = _optionalChain([info, 'optionalAccess', _81 => _81.message]) || _optionalChain([info, 'optionalAccess', _82 => _82.reason]) || "the GPU device was lost";
+    void _optionalChain([device, 'access', _84 => _84.lost, 'optionalAccess', _85 => _85.then, 'call', _86 => _86((info) => {
+      this.lostReason = _optionalChain([info, 'optionalAccess', _87 => _87.message]) || _optionalChain([info, 'optionalAccess', _88 => _88.reason]) || "the GPU device was lost";
     })]);
   }
   
@@ -2893,7 +3089,7 @@ var WetGpuEngine = (_class3 = class _WetGpuEngine {
   }
   /** Bytes of GPU memory in use. */
   memoryBytes() {
-    return this.state.size + this.jobs.size + (_nullishCoalesce(_optionalChain([this, 'access', _83 => _83.srcTiles, 'optionalAccess', _84 => _84.size]), () => ( 0))) + (_nullishCoalesce(_optionalChain([this, 'access', _85 => _85.outTiles, 'optionalAccess', _86 => _86.size]), () => ( 0))) * 2;
+    return this.state.size + this.jobs.size + (_nullishCoalesce(_optionalChain([this, 'access', _89 => _89.srcTiles, 'optionalAccess', _90 => _90.size]), () => ( 0))) + (_nullishCoalesce(_optionalChain([this, 'access', _91 => _91.outTiles, 'optionalAccess', _92 => _92.size]), () => ( 0))) * 2;
   }
   /** Slots the state buffer holds now. */
   get capacity() {
@@ -3042,9 +3238,9 @@ var WetGpuEngine = (_class3 = class _WetGpuEngine {
     const d = this.device;
     const tileBytes = TILE_WORDS * 4;
     if (n > this.tileCap || !this.outTiles || !this.outRead || !this.srcTiles) {
-      _optionalChain([this, 'access', _87 => _87.srcTiles, 'optionalAccess', _88 => _88.destroy, 'call', _89 => _89()]);
-      _optionalChain([this, 'access', _90 => _90.outTiles, 'optionalAccess', _91 => _91.destroy, 'call', _92 => _92()]);
-      _optionalChain([this, 'access', _93 => _93.outRead, 'optionalAccess', _94 => _94.destroy, 'call', _95 => _95()]);
+      _optionalChain([this, 'access', _93 => _93.srcTiles, 'optionalAccess', _94 => _94.destroy, 'call', _95 => _95()]);
+      _optionalChain([this, 'access', _96 => _96.outTiles, 'optionalAccess', _97 => _97.destroy, 'call', _98 => _98()]);
+      _optionalChain([this, 'access', _99 => _99.outRead, 'optionalAccess', _100 => _100.destroy, 'call', _101 => _101()]);
       this.tileCap = Math.max(n, this.tileCap * 2, 4);
       this.srcTiles = d.createBuffer({ size: this.tileCap * tileBytes, usage: STORAGE | COPY_DST, label: "wet base tiles" });
       this.outTiles = d.createBuffer({ size: this.tileCap * tileBytes, usage: STORAGE | COPY_SRC, label: "wet shaded tiles" });
@@ -3098,7 +3294,7 @@ var WetGpuEngine = (_class3 = class _WetGpuEngine {
     return this.device.queue.onSubmittedWorkDone();
   }
   destroy() {
-    for (const b of [this.state, this.params, this.jobs, this.flags, this.flagsRead, ...this.uni, this.shadeUni, this.srcTiles, this.outTiles, this.outRead]) _optionalChain([b, 'optionalAccess', _96 => _96.destroy, 'call', _97 => _97()]);
+    for (const b of [this.state, this.params, this.jobs, this.flags, this.flagsRead, ...this.uni, this.shadeUni, this.srcTiles, this.outTiles, this.outRead]) _optionalChain([b, 'optionalAccess', _102 => _102.destroy, 'call', _103 => _103()]);
     this.device.destroy();
   }
 }, _class3);
@@ -3124,7 +3320,7 @@ function pointerStrokeSample(e, toPoint) {
   return s;
 }
 function pointerStrokeSamples(e, toPoint) {
-  const events = _nullishCoalesce(_optionalChain([e, 'access', _98 => _98.getCoalescedEvents, 'optionalCall', _99 => _99()]), () => ( []));
+  const events = _nullishCoalesce(_optionalChain([e, 'access', _104 => _104.getCoalescedEvents, 'optionalCall', _105 => _105()]), () => ( []));
   return (events.length ? events : [e]).map((ev) => pointerStrokeSample(ev, toPoint));
 }
 
@@ -3219,4 +3415,8 @@ function pointerStrokeSamples(e, toPoint) {
 
 
 
-exports.createPigmentTools = createPigmentTools; exports.WET_TILE = WET_TILE; exports.SLOT_SIDE = SLOT_SIDE; exports.PLANE = PLANE; exports.PLANE_BYTES = PLANE_BYTES; exports.SET_PLANES = SET_PLANES; exports.P_RHO = P_RHO; exports.P_UX = P_UX; exports.P_UY = P_UY; exports.P_SW = P_SW; exports.P_P0 = P_P0; exports.P_EDGE = P_EDGE; exports.P_D0 = P_D0; exports.P_H = P_H; exports.P_FX = P_FX; exports.P_FY = P_FY; exports.SLOT_PLANES = SLOT_PLANES; exports.SLOT_BYTES = SLOT_BYTES; exports.PIGMENT_CHANNELS = PIGMENT_CHANNELS; exports.EX = EX; exports.EY = EY; exports.OPP = OPP; exports.W9 = W9; exports.DRY_EPS = DRY_EPS; exports.U_MAX = U_MAX; exports.STRIP = STRIP; exports.MAX_BATCH = MAX_BATCH; exports.FREE_INTERVAL = FREE_INTERVAL; exports.FLAG_ALIVE = FLAG_ALIVE; exports.FLAG_LEFT = FLAG_LEFT; exports.FLAG_RIGHT = FLAG_RIGHT; exports.FLAG_TOP = FLAG_TOP; exports.FLAG_BOTTOM = FLAG_BOTTOM; exports.FLAG_WET = FLAG_WET; exports.PARAM_FLOATS = PARAM_FLOATS; exports.PARAM = PARAM; exports.DEFAULT_WET_PARAMS = DEFAULT_WET_PARAMS; exports.WET_PARAM_KEYS = WET_PARAM_KEYS; exports.DEFAULT_WET_PAPER = DEFAULT_WET_PAPER; exports.FLAT = FLAT; exports.normalizeWetParams = normalizeWetParams; exports.normalizeTilt = normalizeTilt; exports.latticeViscosity = latticeViscosity; exports.PAPER_CAPACITY = PAPER_CAPACITY; exports.MAX_TILT_ACCEL = MAX_TILT_ACCEL; exports.packWetParams = packWetParams; exports.edgeBits = edgeBits; exports.PIGMENT_UNIT = PIGMENT_UNIT; exports.HIDE = HIDE; exports.BODY_SCATTER = BODY_SCATTER; exports.dexp = dexp; exports.dlog = dlog; exports.dpow = dpow; exports.SRGB_TO_LINEAR = SRGB_TO_LINEAR; exports.srgbByteToLinear = srgbByteToLinear; exports.linearToSrgb8 = linearToSrgb8; exports.pigmentOf = pigmentOf; exports.expNeg = expNeg; exports.filmReflectance = filmReflectance; exports.pigmentColor = pigmentColor; exports.filmPixel = filmPixel; exports.pixelPigment = pixelPigment; exports.shadeTile = shadeTile; exports.stepSlotTs = stepSlotTs; exports.loadWetKernel = loadWetKernel; exports.canShareMemory = canShareMemory; exports.wetSimdSupported = wetSimdSupported; exports.wetSupport = wetSupport; exports.WetWorkerPool = WetWorkerPool; exports.MAX_WET_LANES = MAX_WET_LANES; exports.MAX_WET_SLOTS = MAX_WET_SLOTS; exports.WetWorldError = WetWorldError; exports.WetWorld = WetWorld; exports.moveWetSnapshot = moveWetSnapshot; exports.WET_FLOW_KINDS = WET_FLOW_KINDS; exports.DEFAULT_FLOW = DEFAULT_FLOW; exports.dsincos = dsincos; exports.normalizeFlow = normalizeFlow; exports.flowField = flowField; exports.WetMedium = WetMedium; exports.WGSL_STEP = WGSL_STEP; exports.WGSL_HALO = WGSL_HALO; exports.WGSL_SHADE = WGSL_SHADE; exports.findWebGpu = findWebGpu; exports.createWetGpuEngine = createWetGpuEngine; exports.wetGpuSupport = wetGpuSupport; exports.WetGpuEngine = WetGpuEngine; exports.pointerPressure = pointerPressure; exports.pointerStrokeSample = pointerStrokeSample; exports.pointerStrokeSamples = pointerStrokeSamples;
+
+
+
+
+exports.createPigmentTools = createPigmentTools; exports.WET_TILE = WET_TILE; exports.SLOT_SIDE = SLOT_SIDE; exports.PLANE = PLANE; exports.PLANE_BYTES = PLANE_BYTES; exports.SET_PLANES = SET_PLANES; exports.P_RHO = P_RHO; exports.P_UX = P_UX; exports.P_UY = P_UY; exports.P_SW = P_SW; exports.P_P0 = P_P0; exports.P_L = P_L; exports.P_EDGE = P_EDGE; exports.P_D0 = P_D0; exports.P_DL = P_DL; exports.P_H = P_H; exports.P_FX = P_FX; exports.P_FY = P_FY; exports.SLOT_PLANES = SLOT_PLANES; exports.SLOT_BYTES = SLOT_BYTES; exports.PIGMENT_CHANNELS = PIGMENT_CHANNELS; exports.MASS_CHANNELS = MASS_CHANNELS; exports.EX = EX; exports.EY = EY; exports.OPP = OPP; exports.W9 = W9; exports.DRY_EPS = DRY_EPS; exports.U_MAX = U_MAX; exports.STRIP = STRIP; exports.MAX_BATCH = MAX_BATCH; exports.FREE_INTERVAL = FREE_INTERVAL; exports.FLAG_ALIVE = FLAG_ALIVE; exports.FLAG_LEFT = FLAG_LEFT; exports.FLAG_RIGHT = FLAG_RIGHT; exports.FLAG_TOP = FLAG_TOP; exports.FLAG_BOTTOM = FLAG_BOTTOM; exports.FLAG_WET = FLAG_WET; exports.PARAM_FLOATS = PARAM_FLOATS; exports.PARAM = PARAM; exports.DEFAULT_WET_PARAMS = DEFAULT_WET_PARAMS; exports.WET_PARAM_KEYS = WET_PARAM_KEYS; exports.DEFAULT_WET_PAPER = DEFAULT_WET_PAPER; exports.FLAT = FLAT; exports.normalizeWetParams = normalizeWetParams; exports.normalizeTilt = normalizeTilt; exports.latticeViscosity = latticeViscosity; exports.PAPER_CAPACITY = PAPER_CAPACITY; exports.MAX_TILT_ACCEL = MAX_TILT_ACCEL; exports.packWetParams = packWetParams; exports.edgeBits = edgeBits; exports.PIGMENT_UNIT = PIGMENT_UNIT; exports.HIDE = HIDE; exports.BODY_SCATTER = BODY_SCATTER; exports.dexp = dexp; exports.dlog = dlog; exports.dpow = dpow; exports.SRGB_TO_LINEAR = SRGB_TO_LINEAR; exports.srgbByteToLinear = srgbByteToLinear; exports.linearToSrgb8 = linearToSrgb8; exports.pigmentOf = pigmentOf; exports.expNeg = expNeg; exports.filmReflectance = filmReflectance; exports.pigmentColor = pigmentColor; exports.filmPixel = filmPixel; exports.pixelPigment = pixelPigment; exports.shadeTile = shadeTile; exports.shadeLightTile = shadeLightTile; exports.stepSlotTs = stepSlotTs; exports.loadWetKernel = loadWetKernel; exports.canShareMemory = canShareMemory; exports.wetSimdSupported = wetSimdSupported; exports.wetSupport = wetSupport; exports.WetWorkerPool = WetWorkerPool; exports.MAX_WET_LANES = MAX_WET_LANES; exports.MAX_WET_SLOTS = MAX_WET_SLOTS; exports.WetWorldError = WetWorldError; exports.WetWorld = WetWorld; exports.moveWetSnapshot = moveWetSnapshot; exports.WET_FLOW_KINDS = WET_FLOW_KINDS; exports.DEFAULT_FLOW = DEFAULT_FLOW; exports.dsincos = dsincos; exports.normalizeFlow = normalizeFlow; exports.flowField = flowField; exports.WetMedium = WetMedium; exports.WGSL_STEP = WGSL_STEP; exports.WGSL_HALO = WGSL_HALO; exports.WGSL_SHADE = WGSL_SHADE; exports.findWebGpu = findWebGpu; exports.createWetGpuEngine = createWetGpuEngine; exports.wetGpuSupport = wetGpuSupport; exports.WetGpuEngine = WetGpuEngine; exports.pointerPressure = pointerPressure; exports.pointerStrokeSample = pointerStrokeSample; exports.pointerStrokeSamples = pointerStrokeSamples;