@pixerate/editor 0.242.0 → 0.244.0

package/dist/paint-editor/index.cjs

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14;
 
 var _chunkXNZFVYC2cjs = require('../chunk-XNZFVYC2.cjs');
 
@@ -7,7 +7,7 @@ var _chunkXNZFVYC2cjs = require('../chunk-XNZFVYC2.cjs');
 
 
 
-var _chunkHW72ABGRcjs = require('../chunk-HW72ABGR.cjs');
+var _chunkM6JORA5Zcjs = require('../chunk-M6JORA5Z.cjs');
 require('../chunk-A2IS7EHE.cjs');
 require('../chunk-SS53NNZO.cjs');
 
@@ -44,7 +44,7 @@ require('../chunk-K6PXS6DO.cjs');
 
 
 
-var _chunkXFYLA3ZOcjs = require('../chunk-XFYLA3ZO.cjs');
+var _chunkVMROIWLLcjs = require('../chunk-VMROIWLL.cjs');
 require('../chunk-BROJYMWU.cjs');
 
 
@@ -55,7 +55,7 @@ var _chunkJLWLX52Lcjs = require('../chunk-JLWLX52L.cjs');
 
 
 var _chunkK7ENM55Pcjs = require('../chunk-K7ENM55P.cjs');
-require('../chunk-KCMV2534.cjs');
+require('../chunk-IZL5V5RK.cjs');
 
 
 
@@ -131,7 +131,9 @@ require('../chunk-KCMV2534.cjs');
 
 
 
-var _chunk5BR7LC24cjs = require('../chunk-5BR7LC24.cjs');
+
+
+var _chunk4T47Z4J3cjs = require('../chunk-4T47Z4J3.cjs');
 require('../chunk-CVFAAZXE.cjs');
 require('../chunk-GF2RBSDM.cjs');
 require('../chunk-NM3G4VQT.cjs');
@@ -256,7 +258,10 @@ require('../chunk-A6QWKBJP.cjs');
 var _chunk7PT4RJL5cjs = require('../chunk-7PT4RJL5.cjs');
 require('../chunk-PPFJHTW5.cjs');
 require('../chunk-RD7RX52G.cjs');
-require('../chunk-7AHBW2CQ.cjs');
+
+
+
+var _chunk7AHBW2CQcjs = require('../chunk-7AHBW2CQ.cjs');
 require('../chunk-IPJ3TEYR.cjs');
 
 // src/paint-editor/document.ts
@@ -290,7 +295,7 @@ function normalizeCanvas(raw) {
 function createPaintDocument(options = {}) {
   const canvas = normalizeCanvas({ width: _nullishCoalesce(options.width, () => ( 2048)), height: _nullishCoalesce(options.height, () => ( 1536)), dpi: options.dpi });
   const layer = createPaintLayer("Layer 1");
-  return { canvas, paper: _chunk5BR7LC24cjs.normalizePaper.call(void 0, _nullishCoalesce(options.paper, () => ( {}))), layers: [layer], activeLayerId: layer.id, strokes: [] };
+  return { canvas, paper: _chunk4T47Z4J3cjs.normalizePaper.call(void 0, _nullishCoalesce(options.paper, () => ( {}))), layers: [layer], activeLayerId: layer.id, strokes: [] };
 }
 
 // src/paint-editor/dab-stroke.ts
@@ -344,13 +349,13 @@ var PaintDabStroke = (_class = class {
   constructor(brush, options) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);_class.prototype.__init8.call(this);_class.prototype.__init9.call(this);_class.prototype.__init10.call(this);
     this.brush = brush;
     this.options = options;
-    this.smoother = new (0, _chunk5BR7LC24cjs.PenSmoother)(brush.tip.smoothing, brush.pressureSmoothing);
-    this.copies = _optionalChain([options, 'access', _2 => _2.copies, 'optionalAccess', _3 => _3.length]) ? options.copies : [_chunk5BR7LC24cjs.IDENTITY_COPY];
+    this.smoother = new (0, _chunk4T47Z4J3cjs.PenSmoother)(brush.tip.smoothing, brush.pressureSmoothing);
+    this.copies = _optionalChain([options, 'access', _2 => _2.copies, 'optionalAccess', _3 => _3.length]) ? options.copies : [_chunk4T47Z4J3cjs.IDENTITY_COPY];
     const exchanging = brush.engine === "mixer" || brush.engine === "dab";
     const rates = brush.engine === "mixer" ? _chunkPQ3H2AANcjs.mixerRates.call(void 0, brush.mixer) : _chunkPQ3H2AANcjs.exchangeRates.call(void 0, brush.behavior.pickup, brush.behavior.mix, 1, brush.behavior.mixing);
     this.mixing = brush.engine === "mixer" ? brush.mixer.mixing : brush.behavior.mixing;
     this.states = this.copies.map((c, i) => ({
-      walker: new (0, _chunk5BR7LC24cjs.PenDabWalker)(brush, (_nullishCoalesce(options.seed, () => ( 0))) + i * 7919 | 0, c.linear),
+      walker: new (0, _chunk4T47Z4J3cjs.PenDabWalker)(brush, (_nullishCoalesce(options.seed, () => ( 0))) + i * 7919 | 0, c.linear),
       exchange: exchanging ? new (0, _chunkPQ3H2AANcjs.PaintExchange)(rates, options.load) : null,
       smudge: brush.engine === "smudge" ? new (0, _chunkPQ3H2AANcjs.SmudgeTip)(brush.smudge, brush.tip.size * (1 + brush.dynamics.tiltSize * 1.5)) : null
     }));
@@ -463,7 +468,7 @@ var PaintDabStroke = (_class = class {
     let flow = 1;
     if (this.options.effect) {
       const rgb = [0, 0, 0];
-      flow = _chunk5BR7LC24cjs.sampleEffectAt.call(void 0, this.options.effect, d.x, d.y, rgb, d);
+      flow = _chunk4T47Z4J3cjs.sampleEffectAt.call(void 0, this.options.effect, d.x, d.y, rgb, d);
       ex.setReservoirColor(rgb[0], rgb[1], rgb[2]);
     } else if (this.sampler && !this.gradient) {
       const g = this.sampler.dab(d, this.sample);
@@ -631,10 +636,10 @@ function lightTile(color, height, heightAround, material, light) {
       const nh = Math.max(0, nx * hx + ny * hy + nz * hz);
       const spec = Math.max(0, Math.pow(nh, shininess) - Math.pow(hz, shininess)) * (0.25 + 0.75 * gloss) * light.relief;
       for (let c = 0; c < 3; c++) {
-        const a = _chunkXFYLA3ZOcjs.SRGB_TO_LINEAR[color[i + c]];
+        const a = _chunkVMROIWLLcjs.SRGB_TO_LINEAR[color[i + c]];
         const tint = metal * a + (1 - metal);
         const v = a * shade * (1 - 0.35 * metal) + spec * tint * (1 + metal);
-        out[i + c] = _chunkXFYLA3ZOcjs.linearToSrgb8.call(void 0, v);
+        out[i + c] = _chunkVMROIWLLcjs.linearToSrgb8.call(void 0, v);
       }
     }
   }
@@ -694,12 +699,12 @@ var ThickStrokeDriver = (_class3 = class {
   constructor(init) {;_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);_class3.prototype.__init15.call(this);_class3.prototype.__init16.call(this);_class3.prototype.__init17.call(this);_class3.prototype.__init18.call(this);_class3.prototype.__init19.call(this);_class3.prototype.__init20.call(this);_class3.prototype.__init21.call(this);
     this.init = init;
     const b = init.brush;
-    this.smoother = new (0, _chunk5BR7LC24cjs.PenSmoother)(b.tip.smoothing, b.pressureSmoothing);
-    const copies = init.copies.length ? init.copies : [_chunk5BR7LC24cjs.IDENTITY_COPY];
+    this.smoother = new (0, _chunk4T47Z4J3cjs.PenSmoother)(b.tip.smoothing, b.pressureSmoothing);
+    const copies = init.copies.length ? init.copies : [_chunk4T47Z4J3cjs.IDENTITY_COPY];
     this.copies = copies;
     const rates = _chunkPQ3H2AANcjs.exchangeRates.call(void 0, b.behavior.pickup, b.behavior.mix, 1, b.behavior.mixing);
     this.states = copies.map((c, i) => ({
-      walker: new (0, _chunk5BR7LC24cjs.PenDabWalker)(b, init.seed + i * 7919 | 0, c.linear),
+      walker: new (0, _chunk4T47Z4J3cjs.PenDabWalker)(b, init.seed + i * 7919 | 0, c.linear),
       exchange: new (0, _chunkPQ3H2AANcjs.PaintExchange)(rates, init.load),
       smudge: b.impasto.tool === "knife" ? new (0, _chunkPQ3H2AANcjs.SmudgeTip)({ strength: 0.85, length: 0.6 + 0.38 * b.impasto.drag, mixing: b.behavior.mixing }, b.tip.size * 1.2) : null,
       carried: null,
@@ -838,14 +843,14 @@ var ThickStrokeDriver = (_class3 = class {
     if (im.tool === "knife") {
       st.smudge.dab(this.medium, { x: d.x, y: d.y, radius: d.radius, opacity: k }, rect, tip);
       this.knifeHeight(st, d, rect, tip, k, im.drag);
-      this.paintMaterial(rect, tip, k * 0.6, im.gloss, im.metallic);
+      this.paintMaterial(rect, tip, k * 0.6, im.gloss, im.metallic, im.rim, im.clarity);
       return;
     }
     const ex = st.exchange;
     let flow = 1;
     const effect = this.init.effect;
     if (effect) {
-      _chunk5BR7LC24cjs.sampleEffectAt.call(void 0, effect, d.x, d.y, this.centre, d);
+      _chunk4T47Z4J3cjs.sampleEffectAt.call(void 0, effect, d.x, d.y, this.centre, d);
       ex.setReservoirColor(this.centre[0], this.centre[1], this.centre[2]);
     } else if (this.sampler) {
       const g = this.sampler.dab(d, this.sample);
@@ -862,7 +867,7 @@ var ThickStrokeDriver = (_class3 = class {
       let field = null;
       if (effect) {
         field = new Float32Array(n * 3);
-        _chunk5BR7LC24cjs.effectDabField.call(void 0, effect, rect, cov, this.centre, this.paint, field, 0, d);
+        _chunk4T47Z4J3cjs.effectDabField.call(void 0, effect, rect, cov, this.centre, this.paint, field, 0, d);
       }
       this.medium.deposit(rect, cov, dep, this.paint, ex.paintPigment, field);
     }
@@ -878,34 +883,34 @@ var ThickStrokeDriver = (_class3 = class {
         const u = ((dx + 0.5 - d.x) * nxs + (dy + 0.5 - d.y) * nys) / r;
         const h0 = this.getH(lx, ly);
         let h = h0;
-        const full = 255 * thick * k;
+        const full2 = 255 * thick * k;
         switch (im.tool) {
           case "brush": {
             const ridge = 0.6 + 0.4 * Math.sin(u * 9 + _chunkPQ3H2AANcjs.hash2.call(void 0, Math.round(u * 6), 3, seed) * 6.28) + 0.15 * (_chunkPQ3H2AANcjs.hash2.call(void 0, lx, ly, seed) - 0.5);
-            const target = full * c * ridge;
+            const target = full2 * c * ridge;
             h = Math.max(h0 * (1 - 0.25 * c * im.drag), Math.min(255, h0 * 0.35 + target));
             break;
           }
           case "tube": {
             const dome = Math.sqrt(Math.max(0, c));
-            h = Math.max(h0, Math.min(255, full * dome * 1.1));
+            h = Math.max(h0, Math.min(255, full2 * dome * 1.1));
             break;
           }
           case "gloop": {
             const dome = Math.sqrt(Math.max(0, 1 - Math.min(1, Math.abs(u)) ** 2));
-            h = Math.max(h0, Math.min(255, full * dome * (c > 0.2 ? 1 : c * 5)));
+            h = Math.max(h0, Math.min(255, full2 * dome * (c > 0.2 ? 1 : c * 5)));
             break;
           }
           case "roller": {
             const stipple = 0.75 + 0.5 * _chunkPQ3H2AANcjs.hash2.call(void 0, lx >> 1, ly >> 1, seed);
-            h = h0 + (Math.min(255, full * 0.6 * stipple) - h0) * Math.min(1, c * 1.5);
+            h = h0 + (Math.min(255, full2 * 0.6 * stipple) - h0) * Math.min(1, c * 1.5);
             break;
           }
         }
         this.setH(lx, ly, Math.round(Math.max(0, Math.min(255, h))));
       }
     }
-    this.paintMaterial(rect, tip, k, im.gloss * (1 - 0.3 * im.thinner), im.metallic);
+    this.paintMaterial(rect, tip, k, im.gloss * (1 - 0.3 * im.thinner), im.metallic, im.rim, im.clarity);
   }
   /** The knife: flattens the relief under it and carries some of it along (a patch, like a smudge). */
   knifeHeight(st, d, rect, tip, k, drag) {
@@ -934,7 +939,12 @@ var ThickStrokeDriver = (_class3 = class {
     for (let p = 0; p < n; p++) pick[p] = Math.max(0, cur[p] - next[p]) + (carried ? carried[p] * (1 - drag) * 0.5 : 0);
     st.carried = pick;
   }
-  paintMaterial(rect, tip, k, gloss, metal) {
+  /**
+   * Material: R gloss, G metallic, B rim (light paint, 0..255), A opacity for light paint's clarity
+   * (255 solid .. 1 clearest; 0 is no material, read as solid).
+   */
+  paintMaterial(rect, tip, k, gloss, metal, rim = 0, clarity = 0) {
+    const opacity = 255 - clarity * 254;
     const off = this.init.target.offset;
     for (let yy = 0, p = 0; yy < rect.height; yy++) {
       for (let xx = 0; xx < rect.width; xx++, p++) {
@@ -946,7 +956,9 @@ var ThickStrokeDriver = (_class3 = class {
         const i = ((ly & 255) * _chunk474IQG74cjs.TILE + (lx & 255)) * 4;
         t[i] = Math.round(t[i] + (gloss * 255 - t[i]) * c);
         t[i + 1] = Math.round(t[i + 1] + (metal * 255 - t[i + 1]) * c);
-        t[i + 3] = 255;
+        t[i + 2] = Math.round(t[i + 2] + (rim * 255 - t[i + 2]) * c);
+        const a = t[i + 3] || 255;
+        t[i + 3] = Math.max(1, Math.round(a + (opacity - a) * c));
       }
     }
   }
@@ -981,6 +993,261 @@ function thickFromJSON(raw) {
   };
 }
 
+// src/paint-editor/light.ts
+var GLOW = 1.5;
+var DEFAULT_LIGHT_SPILL = { radius: 24, strength: 1 };
+function normalizeLightSpill(raw, base = DEFAULT_LIGHT_SPILL) {
+  const radius = _nullishCoalesce(raw.radius, () => ( base.radius));
+  const strength = _nullishCoalesce(raw.strength, () => ( base.strength));
+  if (!(Number.isFinite(radius) && radius >= 0 && radius <= 512)) throw new Error(`radius ${radius} is out of range; use 0..512 px (0 turns spill off).`);
+  if (!(Number.isFinite(strength) && strength >= 0 && strength <= 2)) throw new Error(`strength ${strength} is out of range; use 0..2.`);
+  return { radius, strength };
+}
+function emptyLight() {
+  return new (0, _chunk474IQG74cjs.TiledSurface)(1, /* @__PURE__ */ new Map(), 0);
+}
+var full = (t, channels) => {
+  if (t.data.length === _chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * channels) return t.data;
+  const out = new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * channels);
+  const u = _nullishCoalesce(t.uniform, () => ( 0));
+  if (channels === 1) out.fill(u & 255);
+  else {
+    const bytes = [u >>> 24 & 255, u >>> 16 & 255, u >>> 8 & 255, u & 255];
+    for (let i = 0; i < out.length; i += 4) out.set(bytes, i);
+  }
+  return out;
+};
+function lightToShadow(light) {
+  const tiles = /* @__PURE__ */ new Map();
+  for (const [key, tile] of light.tiles) {
+    const l = full(tile, 1);
+    const d = new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * 4);
+    for (let i = 0, j = 0; i < l.length; i++, j += 4) {
+      if (!l[i]) continue;
+      d[j] = d[j + 1] = d[j + 2] = 255;
+      d[j + 3] = l[i];
+    }
+    const t = _chunk474IQG74cjs.finishTile.call(void 0, d, 4, 0);
+    if (t) tiles.set(key, t);
+  }
+  return new (0, _chunk474IQG74cjs.TiledSurface)(4, tiles, 0);
+}
+function shadowToLight(shadow) {
+  const tiles = /* @__PURE__ */ new Map();
+  for (const [key, tile] of shadow.tiles) {
+    const s = full(tile, 4);
+    const d = new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE);
+    for (let i = 0, j = 0; i < d.length; i++, j += 4) if (s[j + 3]) d[i] = Math.round((s[j] + s[j + 1] + s[j + 2]) / 3 * s[j + 3] / 255);
+    const t = _chunk474IQG74cjs.finishTile.call(void 0, d, 1, 0);
+    if (t) tiles.set(key, t);
+  }
+  return new (0, _chunk474IQG74cjs.TiledSurface)(1, tiles, 0);
+}
+function lightTwinBrush(brush) {
+  return _chunk4T47Z4J3cjs.normalizePaintBrush.call(void 0, 
+    {
+      tip: { ...brush.tip, blend: "normal", pressureOpacity: brush.tip.pressureOpacity || brush.light.pressure },
+      behavior: { ...brush.behavior, mixing: "rgb" },
+      paint: null,
+      ...brush.engine === "mixer" ? { mixer: { ...brush.mixer, mixing: "rgb" } } : {},
+      ...brush.engine === "blender" ? { blender: { ...brush.blender, mixing: "rgb" } } : {},
+      ...brush.engine === "smudge" ? { smudge: { ...brush.smudge, mixing: "rgb" } } : {}
+    },
+    brush
+  );
+}
+function lightInfo(light) {
+  if (!light) return { bounds: null, peak: 0 };
+  let peak = 0;
+  for (const t of light.tiles.values()) {
+    if (t.uniform !== null) peak = Math.max(peak, t.uniform & 255);
+    else for (let i = 0; i < t.data.length; i++) if (t.data[i] > peak) peak = t.data[i];
+  }
+  return { bounds: peak ? light.bounds : null, peak };
+}
+function scaleLight(light, k) {
+  if (k >= 1) return light;
+  const tiles = /* @__PURE__ */ new Map();
+  if (k > 0) {
+    for (const [key, tile] of light.tiles) {
+      const d = Uint8ClampedArray.from(full(tile, 1), (v) => Math.round(v * k));
+      const t = _chunk474IQG74cjs.finishTile.call(void 0, d, 1, 0);
+      if (t) tiles.set(key, t);
+    }
+  }
+  return new (0, _chunk474IQG74cjs.TiledSurface)(1, tiles, 0);
+}
+function mergeLight(lower, upper, upperColor) {
+  if (!_optionalChain([upper, 'optionalAccess', _15 => _15.tiles, 'access', _16 => _16.size])) return lower;
+  const keys = /* @__PURE__ */ new Set([..._nullishCoalesce(_optionalChain([lower, 'optionalAccess', _17 => _17.tiles, 'access', _18 => _18.keys, 'call', _19 => _19()]), () => ( [])), ...upper.tiles.keys()]);
+  const tiles = /* @__PURE__ */ new Map();
+  for (const key of keys) {
+    const lo = _optionalChain([lower, 'optionalAccess', _20 => _20.tiles, 'access', _21 => _21.get, 'call', _22 => _22(key)]);
+    const up = upper.tiles.get(key);
+    const col = upperColor.tiles.get(key);
+    const l = lo ? full(lo, 1) : null;
+    const u = up ? full(up, 1) : null;
+    const c = col ? full(col, 4) : null;
+    const d = new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE);
+    for (let i = 0; i < d.length; i++) {
+      const a = c ? c[i * 4 + 3] / 255 : 0;
+      d[i] = Math.round((u ? u[i] : 0) + (l ? l[i] : 0) * (1 - a));
+    }
+    const t = _chunk474IQG74cjs.finishTile.call(void 0, d, 1, 0);
+    if (t) tiles.set(key, t);
+  }
+  return new (0, _chunk474IQG74cjs.TiledSurface)(1, tiles, 0);
+}
+function facing(h, x, y) {
+  const at = (xx, yy) => h[Math.min(_chunk474IQG74cjs.TILE - 1, Math.max(0, yy)) * _chunk474IQG74cjs.TILE + Math.min(_chunk474IQG74cjs.TILE - 1, Math.max(0, xx))];
+  const k = 7 / 255;
+  const dx = (at(x + 1, y) - at(x - 1, y)) / 2 * k;
+  const dy = (at(x, y + 1) - at(x, y - 1)) / 2 * k;
+  return 1 / Math.hypot(dx, dy, 1);
+}
+var LightCache = (_class4 = class {constructor() { _class4.prototype.__init22.call(this);_class4.prototype.__init23.call(this); }
+  __init22() {this.tiles = /* @__PURE__ */ new Map()}
+  glow(color, light, thick) {
+    const clear = (m) => !!m && (m.uniform === null ? m.data.some((v, i) => i % 4 === 3 && v > 0 && v < 255) : (m.uniform & 255) > 0 && (m.uniform & 255) < 255);
+    if (!_optionalChain([light, 'optionalAccess', _23 => _23.tiles, 'access', _24 => _24.size]) && !(thick && [...thick.material.tiles.values()].some(clear))) return color;
+    const out = new Map(color.tiles);
+    const seen = /* @__PURE__ */ new Set();
+    for (const [key, tile] of color.tiles) {
+      const l = _optionalChain([light, 'optionalAccess', _25 => _25.tiles, 'access', _26 => _26.get, 'call', _27 => _27(key)]);
+      const m = _optionalChain([thick, 'optionalAccess', _28 => _28.material, 'access', _29 => _29.tiles, 'access', _30 => _30.get, 'call', _31 => _31(key)]);
+      const h = _optionalChain([thick, 'optionalAccess', _32 => _32.height, 'access', _33 => _33.tiles, 'access', _34 => _34.get, 'call', _35 => _35(key)]);
+      if (!l && !clear(m)) continue;
+      seen.add(key);
+      const inputs = [tile, _nullishCoalesce(l, () => ( null)), _nullishCoalesce(m, () => ( null)), _nullishCoalesce(h, () => ( null))];
+      const cached = this.tiles.get(key);
+      if (cached && cached.inputs.every((v, i) => v === inputs[i])) {
+        out.set(key, cached.tile);
+        continue;
+      }
+      const c = full(tile, 4);
+      const ld = l ? full(l, 1) : null;
+      const md = m ? full(m, 4) : null;
+      const hd = h ? full(h, 1) : null;
+      const d = new Uint8ClampedArray(c);
+      for (let y = 0, i = 0; y < _chunk474IQG74cjs.TILE; y++) {
+        for (let x = 0; x < _chunk474IQG74cjs.TILE; x++, i++) {
+          const j = i * 4;
+          if (!d[j + 3]) continue;
+          const rim = md ? md[j + 2] / 255 : 0;
+          const opacity = md && md[j + 3] ? md[j + 3] : 255;
+          const f = (rim > 0 || opacity < 255) && hd ? facing(hd, x, y) : 1;
+          const g = ld && ld[i] ? ld[i] / 255 * (1 - rim + rim * 2 * (1 - f) ** 3) : 0;
+          if (g > 0) {
+            for (let ch = 0; ch < 3; ch++) d[j + ch] = Math.round(_chunk7AHBW2CQcjs.linearToSrgb.call(void 0, Math.min(1, _chunk7AHBW2CQcjs.srgbToLinear.call(void 0, d[j + ch] / 255) * (1 + GLOW * g))) * 255);
+          }
+          if (opacity < 255) d[j + 3] = Math.round(d[j + 3] * (1 - (255 - opacity) / 254 * f));
+        }
+      }
+      const lit = { data: d, uniform: null };
+      this.tiles.set(key, { inputs, tile: lit });
+      out.set(key, lit);
+    }
+    for (const key of [...this.tiles.keys()]) if (!seen.has(key)) this.tiles.delete(key);
+    return new (0, _chunk474IQG74cjs.TiledSurface)(4, out, color.defaultValue);
+  }
+  __init23() {this.spillCache = null}
+  /**
+   * The layer's spill (layer space, RGBA for Linear Dodge (Add)): `light × colour` blurred by
+   * `radius` px at a reduced resolution, times `strength`; `null` without light or spill.
+   */
+  spill(color, light, spill) {
+    const inputs = [color, light, spill.radius, spill.strength];
+    if (this.spillCache && this.spillCache.inputs.every((v, i) => v === inputs[i])) return this.spillCache.surface;
+    const surface = computeSpill(color, light, spill);
+    this.spillCache = { inputs, surface };
+    return surface;
+  }
+}, _class4);
+function computeSpill(color, light, spill) {
+  const b = light ? lightInfo(light).bounds : null;
+  if (!light || !b || spill.radius <= 0 || spill.strength <= 0) return null;
+  const r = Math.ceil(spill.radius);
+  const region = { x: b.x - r, y: b.y - r, width: b.width + 2 * r, height: b.height + 2 * r };
+  const col = _chunk474IQG74cjs.readRegion.call(void 0, color, region);
+  const lit = _chunk474IQG74cjs.readRegion.call(void 0, light, region);
+  const f = Math.max(1, Math.floor(spill.radius / 6));
+  const w = Math.ceil(region.width / f);
+  const h = Math.ceil(region.height / f);
+  const e = [new Float32Array(w * h), new Float32Array(w * h), new Float32Array(w * h)];
+  for (let y = 0; y < region.height; y++) {
+    for (let x = 0; x < region.width; x++) {
+      const i = y * region.width + x;
+      const l = lit[i];
+      if (!l) continue;
+      const j = i * 4;
+      const k = l / 255 * (col[j + 3] / 255) / (f * f);
+      const cell = Math.floor(y / f) * w + Math.floor(x / f);
+      for (let ch = 0; ch < 3; ch++) e[ch][cell] += _chunk7AHBW2CQcjs.srgbToLinear.call(void 0, col[j + ch] / 255) * k;
+    }
+  }
+  const box = Math.max(1, Math.round(spill.radius / f / 2.5));
+  for (const plane of e) for (let pass = 0; pass < 3; pass++) boxBlur(plane, w, h, box);
+  const out = new Uint8ClampedArray(region.width * region.height * 4);
+  for (let y = 0; y < region.height; y++) {
+    for (let x = 0; x < region.width; x++) {
+      const fx = Math.min(w - 1, Math.max(0, (x + 0.5) / f - 0.5));
+      const fy = Math.min(h - 1, Math.max(0, (y + 0.5) / f - 0.5));
+      const x0 = Math.floor(fx);
+      const y0 = Math.floor(fy);
+      const x1 = Math.min(w - 1, x0 + 1);
+      const y1 = Math.min(h - 1, y0 + 1);
+      const tx = fx - x0;
+      const ty = fy - y0;
+      const rgb = e.map((p) => (p[y0 * w + x0] * (1 - tx) + p[y0 * w + x1] * tx) * (1 - ty) + (p[y1 * w + x0] * (1 - tx) + p[y1 * w + x1] * tx) * ty);
+      const add = rgb.map((v) => Math.min(1, _chunk7AHBW2CQcjs.linearToSrgb.call(void 0, Math.min(1, v * spill.strength))));
+      const a = Math.max(add[0], add[1], add[2]);
+      if (a <= 1 / 255) continue;
+      const o = (y * region.width + x) * 4;
+      out[o] = Math.round(add[0] / a * 255);
+      out[o + 1] = Math.round(add[1] / a * 255);
+      out[o + 2] = Math.round(add[2] / a * 255);
+      out[o + 3] = Math.round(a * 255);
+    }
+  }
+  return _chunk474IQG74cjs.surfaceFromPixels.call(void 0, { width: region.width, height: region.height, data: out }, 4, region.x, region.y);
+}
+function boxBlur(p, w, h, r) {
+  const tmp = new Float32Array(Math.max(w, h));
+  const n = 2 * r + 1;
+  for (let y = 0; y < h; y++) {
+    let sum = 0;
+    for (let k = -r; k <= r; k++) sum += p[y * w + Math.min(w - 1, Math.max(0, k))];
+    for (let x = 0; x < w; x++) {
+      tmp[x] = sum / n;
+      sum += p[y * w + Math.min(w - 1, x + r + 1)] - p[y * w + Math.max(0, x - r)];
+    }
+    for (let x = 0; x < w; x++) p[y * w + x] = tmp[x];
+  }
+  for (let x = 0; x < w; x++) {
+    let sum = 0;
+    for (let k = -r; k <= r; k++) sum += p[Math.min(h - 1, Math.max(0, k)) * w + x];
+    for (let y = 0; y < h; y++) {
+      tmp[y] = sum / n;
+      sum += p[Math.min(h - 1, y + r + 1) * w + x] - p[Math.max(0, y - r) * w + x];
+    }
+    for (let y = 0; y < h; y++) p[y * w + x] = tmp[y];
+  }
+}
+function lightToJSON(light) {
+  const b = lightInfo(light).bounds;
+  if (!b) return null;
+  return { rect: { ...b }, light: _chunkOLNIPTB3cjs.pngDataUrl.call(void 0, b.width, b.height, _chunk474IQG74cjs.readRegion.call(void 0, light, b), 1) };
+}
+function lightFromJSON(raw) {
+  const r = raw;
+  if (!r || typeof r !== "object" || !r.rect || typeof r.light !== "string") throw new Error("not a saved light channel");
+  const parsed = _chunkOLNIPTB3cjs.parseDataUrl.call(void 0, r.light);
+  if (!parsed) throw new Error("the light is not a PNG data URL");
+  const img = _chunkOLNIPTB3cjs.decodePng.call(void 0, parsed.bytes, { keepGray: true });
+  const data = img.channels === 1 ? img.data : Uint8ClampedArray.from({ length: img.width * img.height }, (_, i) => img.data[i * 4]);
+  return _chunk474IQG74cjs.surfaceFromPixels.call(void 0, { width: img.width, height: img.height, data }, 1, r.rect.x, r.rect.y);
+}
+
 // src/paint-editor/stroke.ts
 function defaultTile(surface) {
   const data = new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * surface.channels);
@@ -1000,17 +1267,18 @@ function union(a, b) {
   const y = Math.min(a.y, b.y);
   return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
 }
-var PaintStrokeSession = (_class4 = class {
-  constructor(host, init) {;_class4.prototype.__init22.call(this);_class4.prototype.__init23.call(this);_class4.prototype.__init24.call(this);_class4.prototype.__init25.call(this);_class4.prototype.__init26.call(this);_class4.prototype.__init27.call(this);_class4.prototype.__init28.call(this);_class4.prototype.__init29.call(this);_class4.prototype.__init30.call(this);_class4.prototype.__init31.call(this);_class4.prototype.__init32.call(this);_class4.prototype.__init33.call(this);_class4.prototype.__init34.call(this);_class4.prototype.__init35.call(this);
+var PaintStrokeSession = (_class5 = class _PaintStrokeSession {
+  constructor(host, init) {;_class5.prototype.__init24.call(this);_class5.prototype.__init25.call(this);_class5.prototype.__init26.call(this);_class5.prototype.__init27.call(this);_class5.prototype.__init28.call(this);_class5.prototype.__init29.call(this);_class5.prototype.__init30.call(this);_class5.prototype.__init31.call(this);_class5.prototype.__init32.call(this);_class5.prototype.__init33.call(this);_class5.prototype.__init34.call(this);_class5.prototype.__init35.call(this);_class5.prototype.__init36.call(this);_class5.prototype.__init37.call(this);_class5.prototype.__init38.call(this);_class5.prototype.__init39.call(this);
     this.host = host;
     this.init = init;
     this.layerId = init.layerId;
     this.base = init.surface;
     this.live = new Map(this.base.tiles);
-    this.copies = init.copies.length ? init.copies : [_chunk5BR7LC24cjs.IDENTITY_COPY];
+    this.copies = init.copies.length ? init.copies : [_chunk4T47Z4J3cjs.IDENTITY_COPY];
     const brush = init.brush;
     if (init.wet) this.wetDriver = init.wet.driver;
-    const effect = _nullishCoalesce(_optionalChain([init, 'access', _15 => _15.effect, 'optionalAccess', _16 => _16.pixels]), () => ( null));
+    if (init.light && !init.wet && !init.sticker) this.lightTwin = this.makeLightTwin(init.light.surface);
+    const effect = _nullishCoalesce(_optionalChain([init, 'access', _36 => _36.effect, 'optionalAccess', _37 => _37.pixels]), () => ( null));
     this.apply = {
       mode: brush.engine === "eraser" ? "erase" : "paint",
       color: init.color,
@@ -1023,11 +1291,11 @@ var PaintStrokeSession = (_class4 = class {
     };
     if (this.wetDriver) {
     } else if (init.sticker) {
-      this.stickerSpray = new (0, _chunk5BR7LC24cjs.StickerSpray)({ brush, target: this.tileTarget(), color: init.colorHex, seed: init.seed, copies: this.copies, nextId: init.sticker.nextId, paint: _nullishCoalesce(init.paint, () => ( null)), effect });
+      this.stickerSpray = new (0, _chunk4T47Z4J3cjs.StickerSpray)({ brush, target: this.tileTarget(), color: init.colorHex, seed: init.seed, copies: this.copies, nextId: init.sticker.nextId, paint: _nullishCoalesce(init.paint, () => ( null)), effect });
     } else if (init.thick) {
       const rgb = (c) => [c[0] / 255, c[1] / 255, c[2] / 255];
       this.thickDriver = new ThickStrokeDriver({ brush, target: this.tileTarget(), channels: init.thick.channels, color: rgb(init.color), load: init.mixerLoad, seed: init.seed, copies: this.copies, paint: _nullishCoalesce(init.paint, () => ( null)), effect });
-    } else if (brush.engine === "mixer" || brush.engine === "blender" || brush.engine === "smudge" || _chunk5BR7LC24cjs.usesPaintExchange.call(void 0, brush, Boolean(init.paint))) {
+    } else if (brush.engine === "mixer" || brush.engine === "blender" || brush.engine === "smudge" || _chunk4T47Z4J3cjs.usesPaintExchange.call(void 0, brush, Boolean(init.paint))) {
       const rgb = (c) => [c[0] / 255, c[1] / 255, c[2] / 255];
       this.wet = new PaintDabStroke(brush, {
         target: this.tileTarget(),
@@ -1043,43 +1311,81 @@ var PaintStrokeSession = (_class4 = class {
       });
     } else {
       const opts = { grain: init.grain, paperDepth: init.paperDepth, seed: init.seed, copies: this.copies, paint: _nullishCoalesce(init.paint, () => ( null)), effect };
-      this.dry = brush.engine === "particle" ? new (0, _chunk5BR7LC24cjs.ParticleStroke)(brush, opts) : brush.engine === "bristle" ? new (0, _chunk5BR7LC24cjs.BristleStroke)(brush, opts) : new (0, _chunk5BR7LC24cjs.DryStroke)(brush, opts);
+      this.dry = brush.engine === "particle" ? new (0, _chunk4T47Z4J3cjs.ParticleStroke)(brush, opts) : brush.engine === "bristle" ? new (0, _chunk4T47Z4J3cjs.BristleStroke)(brush, opts) : new (0, _chunk4T47Z4J3cjs.DryStroke)(brush, opts);
     }
   }
   
   
   
   /** The raw input so far (what a replay feeds back in). */
-  __init22() {this.points = []}
+  __init24() {this.points = []}
   
   
-  __init23() {this.touched = /* @__PURE__ */ new Set()}
-  __init24() {this.fresh = /* @__PURE__ */ new Set()}
-  __init25() {this.dry = null}
-  __init26() {this.wet = null}
-  __init27() {this.wetDriver = null}
-  __init28() {this.thickDriver = null}
-  __init29() {this.stickerSpray = null}
+  __init25() {this.touched = /* @__PURE__ */ new Set()}
+  __init26() {this.fresh = /* @__PURE__ */ new Set()}
+  __init27() {this.dry = null}
+  __init28() {this.wet = null}
+  __init29() {this.wetDriver = null}
+  __init30() {this.thickDriver = null}
+  __init31() {this.stickerSpray = null}
+  /** Light paint: the stroke's twin over the light channel, and what it left there. */
+  __init32() {this.lightTwin = null}
+  __init33() {this.lightResult = null}
   /** A wet stroke that ended while the simulation was mid-batch: it commits when the driver catches up. */
-  __init30() {this.wetEndPending = false}
+  __init34() {this.wetEndPending = false}
   
   
-  __init31() {this.bounds = null}
-  __init32() {this.lastRaw = null}
-  __init33() {this.closed = false}
-  __init34() {this.result = null}
+  __init35() {this.bounds = null}
+  __init36() {this.lastRaw = null}
+  __init37() {this.closed = false}
+  __init38() {this.result = null}
   /** The mask stencils this stroke was painted with when they are not the editor's (replays). */
-  __init35() {this.maskStencils = null}
+  __init39() {this.maskStencils = null}
+  /** The stroke's twin over the light channel: the same marks in grey at the brush's light amount (see `light.ts`). */
+  makeLightTwin(light) {
+    const init = this.init;
+    const grey = Math.round(init.brush.light.amount * 255);
+    const g = grey / 255;
+    const hex = "#" + grey.toString(16).padStart(2, "0").repeat(3);
+    const host = {
+      update: () => {
+      },
+      commit: (_s, surface) => {
+        this.lightResult = surface ? shadowToLight(surface) : null;
+      }
+    };
+    const effect = init.effect ? { source: init.effect.source, pixels: { ...init.effect.pixels, data: greyPixels(init.effect.pixels.data, grey) } } : null;
+    const paint = init.paint ? { ...init.paint, stops: init.paint.stops.map((st) => ({ ...st, color: hex })) } : null;
+    return new _PaintStrokeSession(host, {
+      ...init,
+      surface: lightToShadow(light),
+      lockTransparency: false,
+      brush: lightTwinBrush(init.brush),
+      color: [grey, grey, grey, 255],
+      colorHex: hex,
+      secondary: [grey, grey, grey, 255],
+      inputFilter: void 0,
+      mixerLoad: { reservoir: init.mixerLoad.reservoir ? [g, g, g] : null, amount: init.mixerLoad.amount, pickup: null },
+      thick: init.thick,
+      paint,
+      effect,
+      light: null
+    });
+  }
+  /** Light paint: the layer's light channel after the stroke, or `null` when the stroke has no twin or left it unchanged. */
+  lightChannel() {
+    return this.lightResult;
+  }
   tileTarget() {
     return {
       offset: this.init.offset,
       lockTransparency: this.init.lockTransparency,
       selection: _nullishCoalesce(this.init.selection, () => ( null)),
-      readTile: (tx, ty) => _nullishCoalesce(_optionalChain([this, 'access', _17 => _17.live, 'access', _18 => _18.get, 'call', _19 => _19(_chunk474IQG74cjs.tileKey.call(void 0, tx, ty)), 'optionalAccess', _20 => _20.data]), () => ( null)),
+      readTile: (tx, ty) => _nullishCoalesce(_optionalChain([this, 'access', _38 => _38.live, 'access', _39 => _39.get, 'call', _40 => _40(_chunk474IQG74cjs.tileKey.call(void 0, tx, ty)), 'optionalAccess', _41 => _41.data]), () => ( null)),
       writeTile: (tx, ty) => {
         const key = _chunk474IQG74cjs.tileKey.call(void 0, tx, ty);
         if (!this.touched.has(key)) {
-          const src = _nullishCoalesce(_optionalChain([this, 'access', _21 => _21.base, 'access', _22 => _22.tiles, 'access', _23 => _23.get, 'call', _24 => _24(key), 'optionalAccess', _25 => _25.data]), () => ( defaultTile(this.base)));
+          const src = _nullishCoalesce(_optionalChain([this, 'access', _42 => _42.base, 'access', _43 => _43.tiles, 'access', _44 => _44.get, 'call', _45 => _45(key), 'optionalAccess', _46 => _46.data]), () => ( defaultTile(this.base)));
           this.live.set(key, { data: new Uint8ClampedArray(src), uniform: null });
           this.touched.add(key);
         }
@@ -1098,6 +1404,7 @@ var PaintStrokeSession = (_class4 = class {
     if (filter) points = points.map(filter);
     for (const p of points) this.points.push(p);
     this.lastRaw = points[points.length - 1];
+    _optionalChain([this, 'access', _47 => _47.lightTwin, 'optionalAccess', _48 => _48.push, 'call', _49 => _49(points)]);
     if (this.wetDriver) {
       this.wetUpdate(this.wetDriver.push(points));
       return;
@@ -1110,7 +1417,7 @@ var PaintStrokeSession = (_class4 = class {
   }
   /** Impasto strokes: the layer's thick-paint channels with the stroke so far. */
   thickChannels() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _26 => _26.thickDriver, 'optionalAccess', _27 => _27.channels, 'call', _28 => _28()]), () => ( null));
+    return _nullishCoalesce(_optionalChain([this, 'access', _50 => _50.thickDriver, 'optionalAccess', _51 => _51.channels, 'call', _52 => _52()]), () => ( null));
   }
   /** Shows a wet stroke's progress (the wet layer's display). */
   wetUpdate(rects) {
@@ -1156,8 +1463,8 @@ var PaintStrokeSession = (_class4 = class {
       }
     }
     for (const [key, { tx, ty, r }] of regions) {
-      const src = _nullishCoalesce(_optionalChain([this, 'access', _29 => _29.base, 'access', _30 => _30.tiles, 'access', _31 => _31.get, 'call', _32 => _32(key), 'optionalAccess', _33 => _33.data]), () => ( defaultTile(this.base)));
-      const prev = this.touched.has(key) ? _optionalChain([this, 'access', _34 => _34.live, 'access', _35 => _35.get, 'call', _36 => _36(key), 'optionalAccess', _37 => _37.data]) : void 0;
+      const src = _nullishCoalesce(_optionalChain([this, 'access', _53 => _53.base, 'access', _54 => _54.tiles, 'access', _55 => _55.get, 'call', _56 => _56(key), 'optionalAccess', _57 => _57.data]), () => ( defaultTile(this.base)));
+      const prev = this.touched.has(key) ? _optionalChain([this, 'access', _58 => _58.live, 'access', _59 => _59.get, 'call', _60 => _60(key), 'optionalAccess', _61 => _61.data]) : void 0;
       this.touched.add(key);
       const data = _chunkPQ3H2AANcjs.applyStrokeToTile.call(void 0, this.dry.coverage, src, ch, tx, ty, this.apply, prev ? { into: prev, region: r } : {});
       this.live.set(key, { data, uniform: null });
@@ -1179,6 +1486,7 @@ var PaintStrokeSession = (_class4 = class {
     }
     this.update(this.dry ? this.dry.finish() : this.thickDriver ? this.thickDriver.finish() : this.stickerSpray ? this.stickerSpray.finish() : this.wet.finish());
     this.closed = true;
+    if (_optionalChain([this, 'access', _62 => _62.lightTwin, 'optionalAccess', _63 => _63.open])) this.lightTwin.end();
     const ch = this.base.channels;
     const tiles = new Map(this.base.tiles);
     let changed = false;
@@ -1193,7 +1501,7 @@ var PaintStrokeSession = (_class4 = class {
     const surface = changed ? new (0, _chunk474IQG74cjs.TiledSurface)(ch, tiles, this.base.defaultValue) : null;
     const dabs = this.dry ? this.dry.dabCount : this.thickDriver ? this.thickDriver.dabCount : this.stickerSpray ? this.stickerSpray.dabCount : this.wet.dabCount;
     this.result = { layerId: this.layerId, bounds: changed ? this.bounds : null, dabs, strokeId: null };
-    const carried = _nullishCoalesce(_optionalChain([this, 'access', _38 => _38.wet, 'optionalAccess', _39 => _39.load]), () => ( _optionalChain([this, 'access', _40 => _40.thickDriver, 'optionalAccess', _41 => _41.load])));
+    const carried = _nullishCoalesce(_optionalChain([this, 'access', _64 => _64.wet, 'optionalAccess', _65 => _65.load]), () => ( _optionalChain([this, 'access', _66 => _66.thickDriver, 'optionalAccess', _67 => _67.load])));
     if (carried) this.result.mixerLoad = this.init.brush.behavior.dirty ? carried : _chunkPQ3H2AANcjs.cleanMixer.call(void 0, carried);
     this.host.commit(this, surface, false);
     return this.result;
@@ -1202,9 +1510,19 @@ var PaintStrokeSession = (_class4 = class {
   cancel() {
     if (this.closed) return;
     this.closed = true;
+    if (_optionalChain([this, 'access', _68 => _68.lightTwin, 'optionalAccess', _69 => _69.open])) this.lightTwin.cancel();
+    this.lightResult = null;
     this.host.commit(this, null, true);
   }
-}, _class4);
+}, _class5);
+function greyPixels(data, grey) {
+  const out = new Uint8ClampedArray(data.length);
+  for (let i = 0; i < data.length; i += 4) {
+    out[i] = out[i + 1] = out[i + 2] = grey;
+    out[i + 3] = data[i + 3];
+  }
+  return out;
+}
 function mixerLoadForStroke(brush, current, color) {
   if (!brush.loadsColor) return { reservoir: null, amount: 0, pickup: brush.mixer.cleanEachStroke ? null : current.pickup };
   if (brush.mixer.loadEachStroke || !current.reservoir) return _chunkPQ3H2AANcjs.loadMixer.call(void 0, current, color);
@@ -1214,7 +1532,7 @@ function brushLoadForStroke(brush, current, color) {
   if (brush.engine === "mixer") return mixerLoadForStroke(brush, current, color);
   if (brush.engine === "impasto") return { reservoir: [color[0], color[1], color[2]], amount: 1, pickup: brush.behavior.dirty ? current.pickup : null };
   if (brush.engine === "wet") return brush.wet.tool === "paint" ? { reservoir: [color[0], color[1], color[2]], amount: 1, pickup: brush.behavior.dirty ? current.pickup : null } : _chunkPQ3H2AANcjs.EMPTY_MIXER_LOAD;
-  if (_chunk5BR7LC24cjs.usesPaintExchange.call(void 0, brush)) return { reservoir: [color[0], color[1], color[2]], amount: 1, pickup: brush.behavior.dirty ? current.pickup : null };
+  if (_chunk4T47Z4J3cjs.usesPaintExchange.call(void 0, brush)) return { reservoir: [color[0], color[1], color[2]], amount: 1, pickup: brush.behavior.dirty ? current.pickup : null };
   return _chunkPQ3H2AANcjs.EMPTY_MIXER_LOAD;
 }
 
@@ -1224,36 +1542,36 @@ var STENCIL_SHAPES = ["rect", "ellipse", "polygon"];
 var finite = (v) => typeof v === "number" && Number.isFinite(v);
 var pt = (p) => p && finite(p.x) && finite(p.y) ? { x: p.x, y: p.y } : void 0;
 function normalizeStencil(raw, id, base) {
-  const kind = STENCIL_KINDS.includes(raw.kind) ? raw.kind : _optionalChain([base, 'optionalAccess', _42 => _42.kind]);
+  const kind = STENCIL_KINDS.includes(raw.kind) ? raw.kind : _optionalChain([base, 'optionalAccess', _70 => _70.kind]);
   if (!kind) throw new Error(`kind ${JSON.stringify(raw.kind)} is not a stencil; use ${STENCIL_KINDS.join(", ")}.`);
   const s = {
     id,
     kind,
-    mode: raw.mode === "guide" || raw.mode === "mask" ? raw.mode : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _43 => _43.mode]), () => ( (kind === "ruler" || kind === "arc" ? "guide" : "mask"))),
-    enabled: typeof raw.enabled === "boolean" ? raw.enabled : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _44 => _44.enabled]), () => ( true)),
-    invert: typeof raw.invert === "boolean" ? raw.invert : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _45 => _45.invert]), () => ( false)),
-    snap: finite(raw.snap) ? Math.min(400, Math.max(1, raw.snap)) : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _46 => _46.snap]), () => ( 40)),
-    feather: finite(raw.feather) ? Math.min(100, Math.max(0, raw.feather)) : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _47 => _47.feather]), () => ( 1))
+    mode: raw.mode === "guide" || raw.mode === "mask" ? raw.mode : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _71 => _71.mode]), () => ( (kind === "ruler" || kind === "arc" ? "guide" : "mask"))),
+    enabled: typeof raw.enabled === "boolean" ? raw.enabled : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _72 => _72.enabled]), () => ( true)),
+    invert: typeof raw.invert === "boolean" ? raw.invert : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _73 => _73.invert]), () => ( false)),
+    snap: finite(raw.snap) ? Math.min(400, Math.max(1, raw.snap)) : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _74 => _74.snap]), () => ( 40)),
+    feather: finite(raw.feather) ? Math.min(100, Math.max(0, raw.feather)) : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _75 => _75.feather]), () => ( 1))
   };
   if (kind === "ruler" || kind === "line") {
-    s.from = _nullishCoalesce(pt(raw.from), () => ( _optionalChain([base, 'optionalAccess', _48 => _48.from])));
-    s.to = _nullishCoalesce(pt(raw.to), () => ( _optionalChain([base, 'optionalAccess', _49 => _49.to])));
+    s.from = _nullishCoalesce(pt(raw.from), () => ( _optionalChain([base, 'optionalAccess', _76 => _76.from])));
+    s.to = _nullishCoalesce(pt(raw.to), () => ( _optionalChain([base, 'optionalAccess', _77 => _77.to])));
     if (!s.from || !s.to) throw new Error(`A ${kind} needs from and to points ({x, y} in document pixels).`);
     if (Math.hypot(s.to.x - s.from.x, s.to.y - s.from.y) < 1) throw new Error(`A ${kind}'s from and to must be at least 1 px apart.`);
   } else if (kind === "arc") {
-    s.center = _nullishCoalesce(pt(raw.center), () => ( _optionalChain([base, 'optionalAccess', _50 => _50.center])));
-    s.radius = finite(raw.radius) ? raw.radius : _optionalChain([base, 'optionalAccess', _51 => _51.radius]);
+    s.center = _nullishCoalesce(pt(raw.center), () => ( _optionalChain([base, 'optionalAccess', _78 => _78.center])));
+    s.radius = finite(raw.radius) ? raw.radius : _optionalChain([base, 'optionalAccess', _79 => _79.radius]);
     if (!s.center || !(s.radius > 0)) throw new Error("An arc needs a center ({x, y}) and a radius above 0.");
-    s.startAngle = finite(raw.startAngle) ? raw.startAngle : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _52 => _52.startAngle]), () => ( 0));
-    s.endAngle = finite(raw.endAngle) ? raw.endAngle : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _53 => _53.endAngle]), () => ( 360));
+    s.startAngle = finite(raw.startAngle) ? raw.startAngle : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _80 => _80.startAngle]), () => ( 0));
+    s.endAngle = finite(raw.endAngle) ? raw.endAngle : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _81 => _81.endAngle]), () => ( 360));
   } else {
-    s.shape = STENCIL_SHAPES.includes(raw.shape) ? raw.shape : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _54 => _54.shape]), () => ( "rect"));
+    s.shape = STENCIL_SHAPES.includes(raw.shape) ? raw.shape : _nullishCoalesce(_optionalChain([base, 'optionalAccess', _82 => _82.shape]), () => ( "rect"));
     if (s.shape === "polygon") {
-      const pts = Array.isArray(raw.points) ? raw.points.map(pt).filter((p) => Boolean(p)) : _optionalChain([base, 'optionalAccess', _55 => _55.points]);
+      const pts = Array.isArray(raw.points) ? raw.points.map(pt).filter((p) => Boolean(p)) : _optionalChain([base, 'optionalAccess', _83 => _83.points]);
       if (!pts || pts.length < 3) throw new Error("A polygon stencil needs at least 3 points.");
       s.points = pts;
     } else {
-      const r = _nullishCoalesce(raw.rect, () => ( _optionalChain([base, 'optionalAccess', _56 => _56.rect])));
+      const r = _nullishCoalesce(raw.rect, () => ( _optionalChain([base, 'optionalAccess', _84 => _84.rect])));
       if (!r || !finite(r.x) || !finite(r.y) || !(r.width > 0) || !(r.height > 0)) throw new Error(`A ${s.shape} stencil needs rect {x, y, width, height} with a width and height above 0.`);
       s.rect = { x: r.x, y: r.y, width: r.width, height: r.height };
     }
@@ -1308,8 +1626,8 @@ function nearestOnStencil(s, p) {
   if (s.kind === "arc") {
     const c = s.center;
     const ang = Math.atan2(p.y - c.y, p.x - c.x);
-    const full = Math.abs(s.endAngle - s.startAngle) >= 360;
-    if (full) {
+    const full2 = Math.abs(s.endAngle - s.startAngle) >= 360;
+    if (full2) {
       const q = { x: c.x + Math.cos(ang) * s.radius, y: c.y + Math.sin(ang) * s.radius };
       return { point: q, distance: Math.hypot(p.x - q.x, p.y - q.y) };
     }
@@ -1335,7 +1653,7 @@ var StencilSnapper = class {
         const { distance } = nearestOnStencil(s, p);
         if (distance <= s.snap && (!best || distance < best.d)) best = { s, d: distance };
       }
-      this.guide = _nullishCoalesce(_optionalChain([best, 'optionalAccess', _57 => _57.s]), () => ( null));
+      this.guide = _nullishCoalesce(_optionalChain([best, 'optionalAccess', _85 => _85.s]), () => ( null));
     }
     if (!this.guide) return p;
     const q = nearestOnStencil(this.guide, p).point;
@@ -1482,7 +1800,7 @@ function normalizeBrushStroke(raw) {
   const out = {
     id: r.id,
     layerId: r.layerId,
-    brush: _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, _nullishCoalesce(r.brush, () => ( {}))),
+    brush: _chunk4T47Z4J3cjs.normalizePaintBrush.call(void 0, _nullishCoalesce(r.brush, () => ( {}))),
     color: typeof r.color === "string" && /^#[0-9a-f]{6}$/i.test(r.color) ? r.color.toLowerCase() : "#000000",
     points,
     seed: finite2(r.seed) ? r.seed | 0 : 0
@@ -1495,13 +1813,13 @@ function normalizeBrushStroke(raw) {
     const st = [];
     for (const raw2 of r.stencils) {
       try {
-        st.push(normalizeStencil(raw2, typeof _optionalChain([raw2, 'optionalAccess', _58 => _58.id]) === "string" ? raw2.id : "stencil"));
+        st.push(normalizeStencil(raw2, typeof _optionalChain([raw2, 'optionalAccess', _86 => _86.id]) === "string" ? raw2.id : "stencil"));
       } catch (e2) {
       }
     }
     if (st.length) out.stencils = st;
   }
-  const effect = _chunk5BR7LC24cjs.readPaintEffectPaint.call(void 0, r.paint);
+  const effect = _chunk4T47Z4J3cjs.readPaintEffectPaint.call(void 0, r.paint);
   const paint = effect ? null : _chunkPQ3H2AANcjs.readPaintSource.call(void 0, r.paint);
   if (effect) out.paint = effect;
   else if (paint && paint.type === "gradient") out.paint = paint;
@@ -1541,11 +1859,11 @@ function varyStroke(stroke, m, v) {
     if (ps !== 1) q.pressure = Math.min(1, Math.max(0, (_nullishCoalesce(p.pressure, () => ( 1))) * ps));
     return q;
   });
-  const brush = s !== 1 ? _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { ...stroke.brush, tip: { ...stroke.brush.tip, size: stroke.brush.tip.size * s } }) : stroke.brush;
+  const brush = s !== 1 ? _chunk4T47Z4J3cjs.normalizePaintBrush.call(void 0, { ...stroke.brush, tip: { ...stroke.brush.tip, size: stroke.brush.tip.size * s } }) : stroke.brush;
   const out = { ...stroke, brush, points };
-  if (_optionalChain([stroke, 'access', _59 => _59.paint, 'optionalAccess', _60 => _60.type]) === "gradient" && s !== 1) out.paint = _chunkPQ3H2AANcjs.scalePaintGradient.call(void 0, stroke.paint, s);
-  if (_optionalChain([stroke, 'access', _61 => _61.paint, 'optionalAccess', _62 => _62.type]) === "effect" && stroke.paint.map && s !== 1) out.paint = { ...stroke.paint, map: { ...stroke.paint.map, length: Math.min(4096, Math.max(16, Math.round(stroke.paint.map.length * s))) } };
-  if (_optionalChain([stroke, 'access', _63 => _63.copies, 'optionalAccess', _64 => _64.length])) {
+  if (_optionalChain([stroke, 'access', _87 => _87.paint, 'optionalAccess', _88 => _88.type]) === "gradient" && s !== 1) out.paint = _chunkPQ3H2AANcjs.scalePaintGradient.call(void 0, stroke.paint, s);
+  if (_optionalChain([stroke, 'access', _89 => _89.paint, 'optionalAccess', _90 => _90.type]) === "effect" && stroke.paint.map && s !== 1) out.paint = { ...stroke.paint, map: { ...stroke.paint.map, length: Math.min(4096, Math.max(16, Math.round(stroke.paint.map.length * s))) } };
+  if (_optionalChain([stroke, 'access', _91 => _91.copies, 'optionalAccess', _92 => _92.length])) {
     const inv = invertAffine(m);
     out.copies = stroke.copies.map((c) => composeAffine(m, composeAffine(c, inv)));
   }
@@ -1564,7 +1882,7 @@ var paperNodes = /* @__PURE__ */ new WeakMap();
 function paperNode(paper, light) {
   let n = paperNodes.get(paper);
   const metal = (_nullishCoalesce(paper.metallic, () => ( 0))) > 0;
-  if (!n || metal && (_optionalChain([n, 'access', _65 => _65.light, 'optionalAccess', _66 => _66.azimuth]) !== _optionalChain([light, 'optionalAccess', _67 => _67.azimuth]) || _optionalChain([n, 'access', _68 => _68.light, 'optionalAccess', _69 => _69.elevation]) !== _optionalChain([light, 'optionalAccess', _70 => _70.elevation]))) {
+  if (!n || metal && (_optionalChain([n, 'access', _93 => _93.light, 'optionalAccess', _94 => _94.azimuth]) !== _optionalChain([light, 'optionalAccess', _95 => _95.azimuth]) || _optionalChain([n, 'access', _96 => _96.light, 'optionalAccess', _97 => _97.elevation]) !== _optionalChain([light, 'optionalAccess', _98 => _98.elevation]))) {
     n = { type: "paper", id: PAPER_NODE_ID, name: "Paper", visible: true, opacity: 1, blend: "normal", paper, ...metal && light ? { light: { azimuth: light.azimuth, elevation: light.elevation } } : {} };
     paperNodes.set(paper, n);
   }
@@ -1586,7 +1904,7 @@ function paperTile(paper, r, light) {
   const key = `${paperKey(paper, light)}|${r.x},${r.y},${r.width},${r.height}`;
   let t = tileCache.get(key);
   if (!t) {
-    t = _chunk5BR7LC24cjs.renderPaper.call(void 0, paper, r, paperGrain(paper), light);
+    t = _chunk4T47Z4J3cjs.renderPaper.call(void 0, paper, r, paperGrain(paper), light);
     if (tileCache.size > 512) tileCache.delete(tileCache.keys().next().value);
     tileCache.set(key, t);
   }
@@ -1685,17 +2003,17 @@ function header(state, options) {
   if (options.swatches !== void 0) out.swatches = JSON.parse(JSON.stringify(options.swatches));
   if (options.mixingPad !== void 0) out.mixingPad = JSON.parse(JSON.stringify(options.mixingPad));
   if (options.wet !== void 0) out.wet = JSON.parse(JSON.stringify(options.wet));
-  if (_optionalChain([state, 'access', _71 => _71.wetEvents, 'optionalAccess', _72 => _72.length])) out.wetEvents = JSON.parse(JSON.stringify(state.wetEvents));
-  if (_optionalChain([state, 'access', _73 => _73.paintEvents, 'optionalAccess', _74 => _74.length])) out.paintEvents = JSON.parse(JSON.stringify(state.paintEvents));
+  if (_optionalChain([state, 'access', _99 => _99.wetEvents, 'optionalAccess', _100 => _100.length])) out.wetEvents = JSON.parse(JSON.stringify(state.wetEvents));
+  if (_optionalChain([state, 'access', _101 => _101.paintEvents, 'optionalAccess', _102 => _102.length])) out.paintEvents = JSON.parse(JSON.stringify(state.paintEvents));
   if (state.origin && (state.origin.x || state.origin.y)) out.origin = { ...state.origin };
   return out;
 }
 function serializePaintDocument(state, options = {}) {
-  const { layers, assets } = _chunkHW72ABGRcjs.serializeLayers.call(void 0, state.layers);
+  const { layers, assets } = _chunkM6JORA5Zcjs.serializeLayers.call(void 0, state.layers);
   return { ...header(state, options), layers, assets };
 }
 async function serializePaintDocumentExternal(state, store, options = {}) {
-  const { layers, assets } = await _chunkHW72ABGRcjs.serializeLayersExternal.call(void 0, state.layers, store);
+  const { layers, assets } = await _chunkM6JORA5Zcjs.serializeLayersExternal.call(void 0, state.layers, store);
   return { ...header(state, options), layers, assets };
 }
 function paintLayersOnly(layers, problems) {
@@ -1703,7 +2021,7 @@ function paintLayersOnly(layers, problems) {
   for (const l of layers) {
     if (l.type === "pixel") {
       const { filters, source, ...rest } = l;
-      if (_optionalChain([filters, 'optionalAccess', _75 => _75.length])) problems.push(`Layer "${l.name}": its filters are an image editor feature and were dropped.`);
+      if (_optionalChain([filters, 'optionalAccess', _103 => _103.length])) problems.push(`Layer "${l.name}": its filters are an image editor feature and were dropped.`);
       if (source) problems.push(`Layer "${l.name}" refers to an image editor source image; it loads empty.`);
       out.push(rest);
     } else if (l.type === "group") out.push({ ...l, children: paintLayersOnly(l.children, problems) });
@@ -1730,11 +2048,11 @@ function deserializePaintDocument(raw) {
   }
   const problems = [];
   const canvas = normalizeCanvas({ width: r.width, height: r.height, dpi: _nullishCoalesce(r.dpi, () => ( void 0)) });
-  const paper = _chunk5BR7LC24cjs.normalizePaper.call(void 0, _nullishCoalesce(r.paper, () => ( {})));
+  const paper = _chunk4T47Z4J3cjs.normalizePaper.call(void 0, _nullishCoalesce(r.paper, () => ( {})));
   const assets = r.assets && typeof r.assets === "object" ? r.assets : {};
-  const layers = paintLayersOnly(_chunkHW72ABGRcjs.deserializeLayers.call(void 0, r.layers, { assets, problems }), problems);
+  const layers = paintLayersOnly(_chunkM6JORA5Zcjs.deserializeLayers.call(void 0, r.layers, { assets, problems }), problems);
   const wanted = typeof r.activeLayerId === "string" ? r.activeLayerId : null;
-  const activeLayerId = wanted && _chunkHB4ICNNAcjs.findLayer.call(void 0, layers, wanted) ? wanted : _nullishCoalesce(_optionalChain([_chunkHB4ICNNAcjs.flattenLayers.call(void 0, layers), 'access', _76 => _76.filter, 'call', _77 => _77((l) => l.type === "pixel"), 'access', _78 => _78.pop, 'call', _79 => _79(), 'optionalAccess', _80 => _80.id]), () => ( null));
+  const activeLayerId = wanted && _chunkHB4ICNNAcjs.findLayer.call(void 0, layers, wanted) ? wanted : _nullishCoalesce(_optionalChain([_chunkHB4ICNNAcjs.flattenLayers.call(void 0, layers), 'access', _104 => _104.filter, 'call', _105 => _105((l) => l.type === "pixel"), 'access', _106 => _106.pop, 'call', _107 => _107(), 'optionalAccess', _108 => _108.id]), () => ( null));
   const wetEvents = Array.isArray(r.wetEvents) ? r.wetEvents.filter((e) => e && typeof e === "object" && Number.isInteger(e.clock) && typeof e.kind === "string") : [];
   const state = { canvas, paper, layers, activeLayerId, strokes: readStrokes(r.strokes, problems) };
   if (wetEvents.length) state.wetEvents = wetEvents;
@@ -1748,7 +2066,7 @@ async function deserializePaintDocumentAsync(raw, store) {
   if (!raw || typeof raw !== "object") throw new Error("Not a paint document: expected a JSON object.");
   const r = raw;
   const problems = [];
-  const assets = await _chunkHW72ABGRcjs.resolveExternalAssets.call(void 0, _nullishCoalesce(r.assets, () => ( {})), store, problems);
+  const assets = await _chunkM6JORA5Zcjs.resolveExternalAssets.call(void 0, _nullishCoalesce(r.assets, () => ( {})), store, problems);
   const loaded = deserializePaintDocument({ ...r, assets });
   return { ...loaded, problems: [...problems, ...loaded.problems] };
 }
@@ -1825,13 +2143,13 @@ function viewPenToDocument(view, p) {
 
 // src/paint-editor/input.ts
 function samplePressure(e) {
-  return _chunkXFYLA3ZOcjs.pointerPressure.call(void 0, e);
+  return _chunkVMROIWLLcjs.pointerPressure.call(void 0, e);
 }
 function pointerToPenPoint(e, x, y, view) {
   const p = { x, y, pressure: samplePressure(e) };
   if (typeof e.timeStamp === "number" && Number.isFinite(e.timeStamp)) p.t = e.timeStamp;
   if (e.pointerType !== "pen") return p;
-  const o = _chunk5BR7LC24cjs.penOrientation.call(void 0, {
+  const o = _chunk4T47Z4J3cjs.penOrientation.call(void 0, {
     x,
     y,
     altitude: typeof e.altitudeAngle === "number" ? e.altitudeAngle : void 0,
@@ -1879,7 +2197,7 @@ async function decodeImageBlob(blob) {
   if (!ctx) throw new Error("No 2D context to decode with.");
   ctx.drawImage(bitmap, 0, 0);
   const data = new Uint8ClampedArray(ctx.getImageData(0, 0, bitmap.width, bitmap.height).data);
-  _optionalChain([bitmap, 'access', _81 => _81.close, 'optionalCall', _82 => _82()]);
+  _optionalChain([bitmap, 'access', _109 => _109.close, 'optionalCall', _110 => _110()]);
   return { width: bitmap.width, height: bitmap.height, data };
 }
 function downloadBytes(bytes, fileName, mimeType) {
@@ -1895,7 +2213,8 @@ function downloadBytes(bytes, fileName, mimeType) {
 
 // src/paint-editor/wet.ts
 var STROKE_WATER = 0.9;
-var STROKE_MASS = _chunkXFYLA3ZOcjs.PIGMENT_UNIT * 2.5;
+var STROKE_MASS = _chunkVMROIWLLcjs.PIGMENT_UNIT * 2.5;
+var STROKE_LIGHT = 1.5;
 var COVERAGE_STEPS = 4096;
 function union2(a, b) {
   if (!a) return { ...b };
@@ -1910,28 +2229,30 @@ function wetPaperInput(paper) {
     absorption: paper.absorption,
     permeability: paper.permeability,
     roughness: flat ? 0 : paper.roughness,
-    color: _chunk5BR7LC24cjs.hexToRgb8.call(void 0, paper.color),
+    color: _chunk4T47Z4J3cjs.hexToRgb8.call(void 0, paper.color),
     heightAt: flat ? () => 0.5 : (x, y) => grain.at(x, y)
   };
 }
-var WetStrokeDriver = (_class5 = class {
-  constructor(init) {;_class5.prototype.__init36.call(this);_class5.prototype.__init37.call(this);_class5.prototype.__init38.call(this);_class5.prototype.__init39.call(this);_class5.prototype.__init40.call(this);_class5.prototype.__init41.call(this);_class5.prototype.__init42.call(this);_class5.prototype.__init43.call(this);_class5.prototype.__init44.call(this);_class5.prototype.__init45.call(this);_class5.prototype.__init46.call(this);_class5.prototype.__init47.call(this);_class5.prototype.__init48.call(this);
+var WetStrokeDriver = (_class6 = class {
+  constructor(init) {;_class6.prototype.__init40.call(this);_class6.prototype.__init41.call(this);_class6.prototype.__init42.call(this);_class6.prototype.__init43.call(this);_class6.prototype.__init44.call(this);_class6.prototype.__init45.call(this);_class6.prototype.__init46.call(this);_class6.prototype.__init47.call(this);_class6.prototype.__init48.call(this);_class6.prototype.__init49.call(this);_class6.prototype.__init50.call(this);_class6.prototype.__init51.call(this);_class6.prototype.__init52.call(this);
     this.init = init;
     const brush = init.brush;
-    this.smoother = new (0, _chunk5BR7LC24cjs.PenSmoother)(brush.tip.smoothing, brush.pressureSmoothing);
-    const copies = init.copies.length ? init.copies : [_chunk5BR7LC24cjs.IDENTITY_COPY];
+    this.smoother = new (0, _chunk4T47Z4J3cjs.PenSmoother)(brush.tip.smoothing, brush.pressureSmoothing);
+    const copies = init.copies.length ? init.copies : [_chunk4T47Z4J3cjs.IDENTITY_COPY];
     const wet = brush.wet;
     const spacing = Math.max(0.02, brush.tip.spacing);
     const perDab = Math.min(1, spacing * 1.2);
     const thin = wet.thinner;
-    this.medium = new (0, _chunkXFYLA3ZOcjs.WetMedium)(init.world, init.laneId, {
+    this.medium = new (0, _chunkVMROIWLLcjs.WetMedium)(init.world, init.laneId, {
       water: STROKE_WATER * Math.min(1, wet.water * (1 + thin)) * perDab,
       mass: STROKE_MASS * wet.pigment * (1 - 0.6 * thin) * perDab,
-      body: wet.body * (1 - thin)
+      body: wet.body * (1 - thin),
+      light: 0
     });
+    this.lightBase = wet.tool === "paint" ? STROKE_LIGHT * brush.light.amount * (1 - 0.6 * thin) * perDab : 0;
     const rates = _chunkPQ3H2AANcjs.exchangeRates.call(void 0, brush.behavior.pickup, brush.behavior.mix, wet.load, brush.behavior.mixing);
     this.states = copies.map((c, i) => ({
-      walker: new (0, _chunk5BR7LC24cjs.PenDabWalker)(brush, init.seed + i * 7919 | 0, c.linear),
+      walker: new (0, _chunk4T47Z4J3cjs.PenDabWalker)(brush, init.seed + i * 7919 | 0, c.linear),
       exchange: wet.tool === "paint" ? new (0, _chunkPQ3H2AANcjs.PaintExchange)(rates, init.load) : null,
       last: null
     }));
@@ -1941,29 +2262,30 @@ var WetStrokeDriver = (_class5 = class {
     this.sampler = g ? new (0, _chunkPQ3H2AANcjs.PaintGradientSampler)(g.map.by === "across-tip" ? { ...g, map: { by: "distance", length: 300, repeat: "mirror" } } : g, init.seed) : null;
   }
   
-  __init36() {this.dabCount = 0}
-  __init37() {this.bounds = null}
+  __init40() {this.dabCount = 0}
+  __init41() {this.bounds = null}
   /** The world's clock at which each raw point was applied (recorded with the stroke). */
-  __init38() {this.steps = []}
+  __init42() {this.steps = []}
   
   
   
-  __init39() {this.queue = []}
-  __init40() {this.finishing = false}
-  __init41() {this.finished = false}
-  __init42() {this.lastRaw = null}
-  __init43() {this.lastFed = null}
-  __init44() {this.tip = new Float32Array(0)}
-  __init45() {this.cov = new Float32Array(0)}
-  __init46() {this.paint = [0, 0, 0]}
-  __init47() {this.centre = [0, 0, 0]}
+  __init43() {this.queue = []}
+  __init44() {this.finishing = false}
+  __init45() {this.finished = false}
+  __init46() {this.lastRaw = null}
+  __init47() {this.lastFed = null}
+  __init48() {this.tip = new Float32Array(0)}
+  __init49() {this.cov = new Float32Array(0)}
+  __init50() {this.paint = [0, 0, 0]}
+  __init51() {this.centre = [0, 0, 0]}
   
   
-  __init48() {this.sample = { rgb: [0, 0, 0], alpha: 1 }}
+  
+  __init52() {this.sample = { rgb: [0, 0, 0], alpha: 1 }}
   
   /** What copy 0's brush carries after the dabs so far. */
   get load() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _83 => _83.states, 'access', _84 => _84[0], 'access', _85 => _85.exchange, 'optionalAccess', _86 => _86.load]), () => ( null));
+    return _nullishCoalesce(_optionalChain([this, 'access', _111 => _111.states, 'access', _112 => _112[0], 'access', _113 => _113.exchange, 'optionalAccess', _114 => _114.load]), () => ( null));
   }
   /** Whether every point (and the end) has been applied. */
   get done() {
@@ -2056,10 +2378,11 @@ var WetStrokeDriver = (_class5 = class {
     switch (wet.tool) {
       case "paint": {
         const ex = st.exchange;
+        this.medium.options.light = this.lightBase * (brush.light.pressure ? d.pressure : 1);
         let flow = 1;
         const effect = this.init.effect;
         if (effect) {
-          _chunk5BR7LC24cjs.sampleEffectAt.call(void 0, effect, d.x, d.y, this.centre, d);
+          _chunk4T47Z4J3cjs.sampleEffectAt.call(void 0, effect, d.x, d.y, this.centre, d);
           ex.setReservoirColor(this.centre[0], this.centre[1], this.centre[2]);
         } else if (this.sampler) {
           const g = this.sampler.dab(d, this.sample);
@@ -2071,7 +2394,7 @@ var WetStrokeDriver = (_class5 = class {
         if (total > 0 && flow > 0 && effect) {
           const ec = cov.slice();
           const field = new Float32Array(ec.length * 3);
-          _chunk5BR7LC24cjs.effectDabField.call(void 0, effect, rect, ec, this.centre, this.paint, field, COVERAGE_STEPS, d);
+          _chunk4T47Z4J3cjs.effectDabField.call(void 0, effect, rect, ec, this.centre, this.paint, field, COVERAGE_STEPS, d);
           this.medium.deposit(rect, ec, Math.min(1, total) * k, this.paint, null, field);
         } else if (total > 0 && flow > 0) this.medium.deposit(rect, cov, Math.min(1, total) * k * flow, this.paint, null);
         else world.paint(laneId, rect, cov, this.medium.options.water * k, null);
@@ -2105,7 +2428,7 @@ var WetStrokeDriver = (_class5 = class {
     }
     st.last = d;
   }
-}, _class5);
+}, _class6);
 var WET_MEDIUM_PARAMS = {
   watercolor: {},
   gouache: { viscosity: 0.45, evaporation: 0.1, edgeDarkening: 0.15, granulation: 0.1, bloom: 0.1, bleed: 0.15, pickup: 0.5, pigmentWeight: 0.5 },
@@ -2114,8 +2437,8 @@ var WET_MEDIUM_PARAMS = {
 var WET_GPU_MODES = ["auto", "off"];
 var GPU_LEAD = 16;
 var DISPLAY_TILES_PER_TICK = 24;
-var PaintWetLayers = (_class6 = class {
-  constructor(host, options = {}) {;_class6.prototype.__init49.call(this);_class6.prototype.__init50.call(this);_class6.prototype.__init51.call(this);_class6.prototype.__init52.call(this);_class6.prototype.__init53.call(this);_class6.prototype.__init54.call(this);_class6.prototype.__init55.call(this);_class6.prototype.__init56.call(this);_class6.prototype.__init57.call(this);_class6.prototype.__init58.call(this);_class6.prototype.__init59.call(this);_class6.prototype.__init60.call(this);_class6.prototype.__init61.call(this);_class6.prototype.__init62.call(this);_class6.prototype.__init63.call(this);_class6.prototype.__init64.call(this);
+var PaintWetLayers = (_class7 = class {
+  constructor(host, options = {}) {;_class7.prototype.__init53.call(this);_class7.prototype.__init54.call(this);_class7.prototype.__init55.call(this);_class7.prototype.__init56.call(this);_class7.prototype.__init57.call(this);_class7.prototype.__init58.call(this);_class7.prototype.__init59.call(this);_class7.prototype.__init60.call(this);_class7.prototype.__init61.call(this);_class7.prototype.__init62.call(this);_class7.prototype.__init63.call(this);_class7.prototype.__init64.call(this);_class7.prototype.__init65.call(this);_class7.prototype.__init66.call(this);_class7.prototype.__init67.call(this);_class7.prototype.__init68.call(this);
     this.host = host;
     this.options = options;
     this.speed = Math.max(1, Math.min(2e3, _nullishCoalesce(options.speed, () => ( 120))));
@@ -2125,33 +2448,33 @@ var PaintWetLayers = (_class6 = class {
   }
   
   
-  __init49() {this.world = null}
-  __init50() {this.tilt = { ..._chunkXFYLA3ZOcjs.FLAT }}
-  __init51() {this.settings = /* @__PURE__ */ new Map()}
-  __init52() {this.paused = false}
+  __init53() {this.world = null}
+  __init54() {this.tilt = { ..._chunkVMROIWLLcjs.FLAT }}
+  __init55() {this.settings = /* @__PURE__ */ new Map()}
+  __init56() {this.paused = false}
   /** Wet strokes dry as soon as they end (one undo step with the stroke). */
-  __init53() {this.instantDry = false}
+  __init57() {this.instantDry = false}
   
-  __init54() {this.overlay = false}
+  __init58() {this.overlay = false}
   
   /** The live wet stroke, if any. */
-  __init55() {this.driver = null}
-  __init56() {this.lastTick = null}
-  __init57() {this.ticking = null}
-  __init58() {this.stepsOwed = 0}
-  __init59() {this.displaying = null}
-  __init60() {this.leadAt = 0}
+  __init59() {this.driver = null}
+  __init60() {this.lastTick = null}
+  __init61() {this.ticking = null}
+  __init62() {this.stepsOwed = 0}
+  __init63() {this.displaying = null}
+  __init64() {this.leadAt = 0}
   
   
-  __init61() {this.gpu = null}
-  __init62() {this.gpuSupport = null}
-  __init63() {this.gpuStarting = null}
+  __init65() {this.gpu = null}
+  __init66() {this.gpuSupport = null}
+  __init67() {this.gpuStarting = null}
   // --- Engine B ------------------------------------------------------------------
   /** Starts the GPU engine for the world (once; it may turn out unavailable). */
   startGpu() {
     if (this.gpuMode === "off" || this.gpu || this.gpuStarting || this.gpuSupport) return;
-    const provider = this.options.gpuProvider === void 0 ? _chunkXFYLA3ZOcjs.findWebGpu.call(void 0, ) : this.options.gpuProvider;
-    this.gpuStarting = _chunkXFYLA3ZOcjs.createWetGpuEngine.call(void 0, provider).then(({ engine, support }) => {
+    const provider = this.options.gpuProvider === void 0 ? _chunkVMROIWLLcjs.findWebGpu.call(void 0, ) : this.options.gpuProvider;
+    this.gpuStarting = _chunkVMROIWLLcjs.createWetGpuEngine.call(void 0, provider).then(({ engine, support }) => {
       this.gpuSupport = support;
       if (!engine) return;
       if (this.gpuMode === "off" || !this.world) {
@@ -2181,8 +2504,8 @@ var PaintWetLayers = (_class6 = class {
     if (mode === this.gpuMode) return this.engineInfo();
     this.gpuMode = mode;
     if (mode === "off") {
-      _optionalChain([this, 'access', _87 => _87.world, 'optionalAccess', _88 => _88.attachGpu, 'call', _89 => _89(null)]);
-      _optionalChain([this, 'access', _90 => _90.gpu, 'optionalAccess', _91 => _91.destroy, 'call', _92 => _92()]);
+      _optionalChain([this, 'access', _115 => _115.world, 'optionalAccess', _116 => _116.attachGpu, 'call', _117 => _117(null)]);
+      _optionalChain([this, 'access', _118 => _118.gpu, 'optionalAccess', _119 => _119.destroy, 'call', _120 => _120()]);
       this.gpu = null;
       this.gpuSupport = null;
     } else if (this.world) this.startGpu();
@@ -2190,13 +2513,13 @@ var PaintWetLayers = (_class6 = class {
   }
   engineInfo() {
     const w = this.world;
-    const base = { mode: this.gpuMode, adapter: _nullishCoalesce(_optionalChain([this, 'access', _93 => _93.gpuSupport, 'optionalAccess', _94 => _94.adapter]), () => ( null)), maxTiles: _nullishCoalesce(_optionalChain([this, 'access', _95 => _95.gpuSupport, 'optionalAccess', _96 => _96.maxSlots]), () => ( 0)), minTiles: this.gpuMinTiles, activeTiles: _nullishCoalesce(_optionalChain([w, 'optionalAccess', _97 => _97.activeTiles, 'call', _98 => _98()]), () => ( 0)), cpu: this.backend() };
+    const base = { mode: this.gpuMode, adapter: _nullishCoalesce(_optionalChain([this, 'access', _121 => _121.gpuSupport, 'optionalAccess', _122 => _122.adapter]), () => ( null)), maxTiles: _nullishCoalesce(_optionalChain([this, 'access', _123 => _123.gpuSupport, 'optionalAccess', _124 => _124.maxSlots]), () => ( 0)), minTiles: this.gpuMinTiles, activeTiles: _nullishCoalesce(_optionalChain([w, 'optionalAccess', _125 => _125.activeTiles, 'call', _126 => _126()]), () => ( 0)), cpu: this.backend() };
     if (this.gpuMode === "off") return { ...base, state: "off", reason: "Forced to the CPU." };
     if (this.gpuStarting) return { ...base, state: "starting", reason: null };
-    if (_optionalChain([w, 'optionalAccess', _99 => _99.gpuError])) return { ...base, state: "failed", reason: w.gpuError };
+    if (_optionalChain([w, 'optionalAccess', _127 => _127.gpuError])) return { ...base, state: "failed", reason: w.gpuError };
     if (this.gpuSupport && !this.gpuSupport.supported) return { ...base, state: "unavailable", reason: this.gpuSupport.reason };
     if (!this.gpu) return { ...base, state: "not-started", reason: "Starts with the first wet stroke." };
-    if (_optionalChain([w, 'optionalAccess', _100 => _100.gpuActive])) return { ...base, state: "active", reason: null };
+    if (_optionalChain([w, 'optionalAccess', _128 => _128.gpuActive])) return { ...base, state: "active", reason: null };
     return { ...base, state: "standby", reason: `The GPU takes over at ${this.gpuMinTiles} wet tiles (256 px).` };
   }
   /** The world (made on first use, at the canvas size). */
@@ -2210,7 +2533,7 @@ var PaintWetLayers = (_class6 = class {
     return this.world;
   }
   makeWorld(width, height, paper) {
-    const world = new (0, _chunkXFYLA3ZOcjs.WetWorld)(width, height, wetPaperInput(paper), { kernel: this.options.kernel, threads: this.options.threads });
+    const world = new (0, _chunkVMROIWLLcjs.WetWorld)(width, height, wetPaperInput(paper), { kernel: this.options.kernel, threads: this.options.threads });
     world.setTilt(this.tilt);
     world.gpuMinTiles = this.gpuMinTiles;
     if (this.gpu) world.attachGpu(this.gpu);
@@ -2222,7 +2545,7 @@ var PaintWetLayers = (_class6 = class {
    * sides: the shift has to be whole wet tiles (256 px), and no wet stroke may be live.
    */
   canExtend(left, top) {
-    return left % _chunkXFYLA3ZOcjs.WET_TILE === 0 && top % _chunkXFYLA3ZOcjs.WET_TILE === 0 && !this.driver;
+    return left % _chunkVMROIWLLcjs.WET_TILE === 0 && top % _chunkVMROIWLLcjs.WET_TILE === 0 && !this.driver;
   }
   /**
    * Keeps the wet paint while the canvas grows to `width`×`height` by `left` / `top` on those
@@ -2235,16 +2558,17 @@ var PaintWetLayers = (_class6 = class {
     if (!this.canExtend(left, top)) throw new Error("Wet paint only moves by whole 256 px tiles, between strokes.");
     for (const [id, s] of this.settings) if (s.flow.center) this.settings.set(id, { ...s, flow: { ...s.flow, center: { x: s.flow.center.x + left, y: s.flow.center.y + top } } });
     const old = this.world;
-    const snap = _optionalChain([old, 'optionalAccess', _101 => _101.laneIds, 'call', _102 => _102(), 'access', _103 => _103.length]) ? old.snapshot() : null;
+    const snap = _optionalChain([old, 'optionalAccess', _129 => _129.laneIds, 'call', _130 => _130(), 'access', _131 => _131.length]) ? old.snapshot() : null;
     this.dropWorld();
     this.lastTick = null;
     this.stepsOwed = 0;
     if (!old || !snap) return;
-    const moved = _chunkXFYLA3ZOcjs.moveWetSnapshot.call(void 0, snap, old, { width, height }, left, top, (l) => {
-      const flow = _optionalChain([this, 'access', _104 => _104.settings, 'access', _105 => _105.get, 'call', _106 => _106(l.id), 'optionalAccess', _107 => _107.flow]);
+    const moved = _chunkVMROIWLLcjs.moveWetSnapshot.call(void 0, snap, old, { width, height }, left, top, (l) => {
+      const flow = _optionalChain([this, 'access', _132 => _132.settings, 'access', _133 => _133.get, 'call', _134 => _134(l.id), 'optionalAccess', _135 => _135.flow]);
       return {
         base: _chunk474IQG74cjs.translateSurface.call(void 0, l.base, left, top),
-        flow: l.flow && flow && flow.kind !== "none" ? _chunkXFYLA3ZOcjs.flowField.call(void 0, flow, width, height) : l.flow
+        ...l.light ? { light: _chunk474IQG74cjs.translateSurface.call(void 0, l.light, left, top) } : {},
+        flow: l.flow && flow && flow.kind !== "none" ? _chunkVMROIWLLcjs.flowField.call(void 0, flow, width, height) : l.flow
       };
     });
     this.world = this.makeWorld(width, height, paper);
@@ -2259,11 +2583,11 @@ var PaintWetLayers = (_class6 = class {
   }
   /** Layers holding a wet layer (wet or drying). */
   wetLayerIds() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _108 => _108.world, 'optionalAccess', _109 => _109.laneIds, 'call', _110 => _110()]), () => ( []));
+    return _nullishCoalesce(_optionalChain([this, 'access', _136 => _136.world, 'optionalAccess', _137 => _137.laneIds, 'call', _138 => _138()]), () => ( []));
   }
   /** Whether a batch is running (edits wait). */
   get busy() {
-    return Boolean(_optionalChain([this, 'access', _111 => _111.world, 'optionalAccess', _112 => _112.busy]));
+    return Boolean(_optionalChain([this, 'access', _139 => _139.world, 'optionalAccess', _140 => _140.busy]));
   }
   /** Resolves when no batch is running. */
   async idle() {
@@ -2272,7 +2596,7 @@ var PaintWetLayers = (_class6 = class {
   settingsOf(layerId, medium = "watercolor") {
     let s = this.settings.get(layerId);
     if (!s) {
-      s = { params: _chunkXFYLA3ZOcjs.normalizeWetParams.call(void 0, WET_MEDIUM_PARAMS[medium], _chunkXFYLA3ZOcjs.DEFAULT_WET_PARAMS), flow: { ..._chunkXFYLA3ZOcjs.DEFAULT_FLOW } };
+      s = { params: _chunkVMROIWLLcjs.normalizeWetParams.call(void 0, WET_MEDIUM_PARAMS[medium], _chunkVMROIWLLcjs.DEFAULT_WET_PARAMS), flow: { ..._chunkVMROIWLLcjs.DEFAULT_FLOW } };
       this.settings.set(layerId, s);
     }
     return s;
@@ -2283,52 +2607,52 @@ var PaintWetLayers = (_class6 = class {
     if (!w.hasLane(layerId)) {
       const base = _nullishCoalesce(this.host.layerSurface(layerId), () => ( new (0, _chunk474IQG74cjs.TiledSurface)(4, /* @__PURE__ */ new Map(), 0)));
       const s = this.settingsOf(layerId, medium);
-      w.ensureLane(layerId, { params: s.params, base });
+      w.ensureLane(layerId, { params: s.params, base, light: this.host.layerLight(layerId) });
       const { width, height } = this.host.canvas();
-      if (s.flow.kind !== "none") w.setFlow(layerId, _chunkXFYLA3ZOcjs.flowField.call(void 0, s.flow, width, height), s.flow.strength);
+      if (s.flow.kind !== "none") w.setFlow(layerId, _chunkVMROIWLLcjs.flowField.call(void 0, s.flow, width, height), s.flow.strength);
     }
     return w;
   }
   setParams(layerId, update) {
     const s = this.settingsOf(layerId);
-    s.params = _chunkXFYLA3ZOcjs.normalizeWetParams.call(void 0, update, s.params);
-    if (_optionalChain([this, 'access', _113 => _113.world, 'optionalAccess', _114 => _114.hasLane, 'call', _115 => _115(layerId)])) this.world.setParams(layerId, s.params);
+    s.params = _chunkVMROIWLLcjs.normalizeWetParams.call(void 0, update, s.params);
+    if (_optionalChain([this, 'access', _141 => _141.world, 'optionalAccess', _142 => _142.hasLane, 'call', _143 => _143(layerId)])) this.world.setParams(layerId, s.params);
     return { ...s.params };
   }
   setFlow(layerId, update) {
     const s = this.settingsOf(layerId);
-    s.flow = _chunkXFYLA3ZOcjs.normalizeFlow.call(void 0, update, s.flow);
-    if (_optionalChain([this, 'access', _116 => _116.world, 'optionalAccess', _117 => _117.hasLane, 'call', _118 => _118(layerId)])) {
+    s.flow = _chunkVMROIWLLcjs.normalizeFlow.call(void 0, update, s.flow);
+    if (_optionalChain([this, 'access', _144 => _144.world, 'optionalAccess', _145 => _145.hasLane, 'call', _146 => _146(layerId)])) {
       const { width, height } = this.host.canvas();
-      this.world.setFlow(layerId, _chunkXFYLA3ZOcjs.flowField.call(void 0, s.flow, width, height), s.flow.strength);
+      this.world.setFlow(layerId, _chunkVMROIWLLcjs.flowField.call(void 0, s.flow, width, height), s.flow.strength);
     }
     return { ...s.flow };
   }
   setTilt(update) {
-    this.tilt = _chunkXFYLA3ZOcjs.normalizeTilt.call(void 0, update, this.tilt);
-    _optionalChain([this, 'access', _119 => _119.world, 'optionalAccess', _120 => _120.setTilt, 'call', _121 => _121(this.tilt)]);
+    this.tilt = _chunkVMROIWLLcjs.normalizeTilt.call(void 0, update, this.tilt);
+    _optionalChain([this, 'access', _147 => _147.world, 'optionalAccess', _148 => _148.setTilt, 'call', _149 => _149(this.tilt)]);
     return { ...this.tilt };
   }
   /** The paper changed. */
   paperChanged() {
-    _optionalChain([this, 'access', _122 => _122.world, 'optionalAccess', _123 => _123.setPaper, 'call', _124 => _124(wetPaperInput(this.host.paper()))]);
+    _optionalChain([this, 'access', _150 => _150.world, 'optionalAccess', _151 => _151.setPaper, 'call', _152 => _152(wetPaperInput(this.host.paper()))]);
   }
   /** A layer as tools describe it. */
   info(layerId) {
     const s = this.settingsOf(layerId);
-    const st = _optionalChain([this, 'access', _125 => _125.world, 'optionalAccess', _126 => _126.hasLane, 'call', _127 => _127(layerId)]) ? this.world.stats(layerId) : null;
+    const st = _optionalChain([this, 'access', _153 => _153.world, 'optionalAccess', _154 => _154.hasLane, 'call', _155 => _155(layerId)]) ? this.world.stats(layerId) : null;
     return {
       layerId,
       wet: Boolean(st && st.wetCells > 0),
-      wetCells: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _128 => _128.wetCells]), () => ( 0)),
-      wetBounds: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _129 => _129.wetBounds]), () => ( null)),
-      activeTiles: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _130 => _130.activeTiles]), () => ( 0)),
+      wetCells: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _156 => _156.wetCells]), () => ( 0)),
+      wetBounds: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _157 => _157.wetBounds]), () => ( null)),
+      activeTiles: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _158 => _158.activeTiles]), () => ( 0)),
       params: { ...s.params },
       flow: { ...s.flow }
     };
   }
   backend() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _131 => _131.world, 'optionalAccess', _132 => _132.backend, 'call', _133 => _133()]), () => ( null));
+    return _nullishCoalesce(_optionalChain([this, 'access', _159 => _159.world, 'optionalAccess', _160 => _160.backend, 'call', _161 => _161()]), () => ( null));
   }
   /** Shows the current wet pixels (at most `maxTiles` reshaded per layer). */
   syncDisplays(maxTiles = Infinity) {
@@ -2341,6 +2665,7 @@ var PaintWetLayers = (_class6 = class {
       if (this.host.layerSurface(id) !== d.surface) surfaces.set(id, d.surface);
       rects.push(...d.changed);
     }
+    this.syncLights();
     if (surfaces.size) this.host.updateSurfaces(surfaces, rects);
     return rects;
   }
@@ -2356,17 +2681,31 @@ var PaintWetLayers = (_class6 = class {
       if (this.host.layerSurface(id) !== d.surface) surfaces.set(id, d.surface);
       rects.push(...d.changed);
     }
+    this.syncLights();
     if (surfaces.size) this.host.updateSurfaces(surfaces, rects);
     return rects;
   }
+  /** Shows each wet layer's live light paint (the light under it with the wet light shaded in). */
+  syncLights() {
+    const w = this.world;
+    if (!w) return;
+    const lights = /* @__PURE__ */ new Map();
+    for (const id of w.laneIds()) {
+      const l = w.lightDisplay(id);
+      if (l && this.host.layerLight(id) !== l) lights.set(id, l);
+    }
+    if (lights.size) this.host.updateLights(lights);
+  }
   /** Drops the wet layers whose paint has all dried (they become ordinary pixel layers). */
   retireDry() {
     const w = this.world;
     if (!w) return;
     for (const id of w.laneIds()) {
-      if (w.isActive(id) || _optionalChain([this, 'access', _134 => _134.driver, 'optionalAccess', _135 => _135.init, 'access', _136 => _136.laneId]) === id) continue;
+      if (w.isActive(id) || _optionalChain([this, 'access', _162 => _162.driver, 'optionalAccess', _163 => _163.init, 'access', _164 => _164.laneId]) === id) continue;
       const base = w.getBase(id);
+      const light = w.isLit(id) ? w.getLight(id) : null;
       w.removeLane(id);
+      if (light && this.host.layerLight(id) !== light) this.host.updateLights(/* @__PURE__ */ new Map([[id, light]]));
       this.host.updateSurfaces(/* @__PURE__ */ new Map([[id, base]]), []);
     }
   }
@@ -2444,10 +2783,10 @@ var PaintWetLayers = (_class6 = class {
     if (!d || !this.world) return;
     const rects = d.flush();
     if (rects.length) this.syncDisplays(DISPLAY_TILES_PER_TICK);
-    if (d.done) _optionalChain([this, 'access', _137 => _137.onDriverDone, 'optionalCall', _138 => _138(d)]);
+    if (d.done) _optionalChain([this, 'access', _165 => _165.onDriverDone, 'optionalCall', _166 => _166(d)]);
   }
   /** Called when a live stroke that ended mid-batch has finished applying. */
-  __init64() {this.onDriverDone = null}
+  __init68() {this.onDriverDone = null}
   /** Steps `steps` times now (agents, tests). Returns the steps run. */
   async advance(steps) {
     await this.idle();
@@ -2485,10 +2824,16 @@ var PaintWetLayers = (_class6 = class {
     this.retireDry();
     return out;
   }
+  /** The layer's light paint with all its wet paint dried (`null` without a wet layer or light), without changing anything. */
+  bakedLight(layerId) {
+    const w = this.world;
+    if (!_optionalChain([w, 'optionalAccess', _167 => _167.hasLane, 'call', _168 => _168(layerId)]) || !w.isLit(layerId)) return null;
+    return w.bakedLight(layerId);
+  }
   /** The layer's pixels with all its wet paint dried (deterministic), without changing anything. */
   bakedSurface(layerId) {
     const w = this.world;
-    if (!_optionalChain([w, 'optionalAccess', _139 => _139.hasLane, 'call', _140 => _140(layerId)])) return null;
+    if (!_optionalChain([w, 'optionalAccess', _169 => _169.hasLane, 'call', _170 => _170(layerId)])) return null;
     return w.bakedSurface(layerId);
   }
   /** A snapshot of the world for undo (`null` when there is none). */
@@ -2509,13 +2854,13 @@ var PaintWetLayers = (_class6 = class {
     this.syncDisplays();
   }
   dropWorld() {
-    _optionalChain([this, 'access', _141 => _141.world, 'optionalAccess', _142 => _142.destroy, 'call', _143 => _143()]);
+    _optionalChain([this, 'access', _171 => _171.world, 'optionalAccess', _172 => _172.destroy, 'call', _173 => _173()]);
     this.world = null;
     this.driver = null;
   }
   /** Forgets everything wet (a new canvas, a resize, opening a document). */
   reset() {
-    _optionalChain([this, 'access', _144 => _144.world, 'optionalAccess', _145 => _145.destroy, 'call', _146 => _146()]);
+    _optionalChain([this, 'access', _174 => _174.world, 'optionalAccess', _175 => _175.destroy, 'call', _176 => _176()]);
     this.world = null;
     this.driver = null;
     this.settings.clear();
@@ -2545,32 +2890,32 @@ var PaintWetLayers = (_class6 = class {
     return out;
   }
   destroy() {
-    _optionalChain([this, 'access', _147 => _147.world, 'optionalAccess', _148 => _148.destroy, 'call', _149 => _149()]);
+    _optionalChain([this, 'access', _177 => _177.world, 'optionalAccess', _178 => _178.destroy, 'call', _179 => _179()]);
     this.world = null;
-    _optionalChain([this, 'access', _150 => _150.gpu, 'optionalAccess', _151 => _151.destroy, 'call', _152 => _152()]);
+    _optionalChain([this, 'access', _180 => _180.gpu, 'optionalAccess', _181 => _181.destroy, 'call', _182 => _182()]);
     this.gpu = null;
   }
-}, _class6);
+}, _class7);
 function wetPigmentOf(hex, body) {
-  const [r, g, b] = _chunk5BR7LC24cjs.hexToRgb8.call(void 0, hex);
-  return Array.from(_chunkXFYLA3ZOcjs.pigmentOf.call(void 0, [r / 255, g / 255, b / 255], body));
+  const [r, g, b] = _chunk4T47Z4J3cjs.hexToRgb8.call(void 0, hex);
+  return Array.from(_chunkVMROIWLLcjs.pigmentOf.call(void 0, [r / 255, g / 255, b / 255], body));
 }
 
 // src/paint-editor/thumbnails.ts
 var thumbWorld = null;
 function paintWetTestStroke(brush, paper, color, width, height) {
   if (!thumbWorld || thumbWorld.width !== width || thumbWorld.height !== height) {
-    _optionalChain([thumbWorld, 'optionalAccess', _153 => _153.destroy, 'call', _154 => _154()]);
-    thumbWorld = new (0, _chunkXFYLA3ZOcjs.WetWorld)(width, height, wetPaperInput(paper), { kernel: "typescript", threads: 0 });
+    _optionalChain([thumbWorld, 'optionalAccess', _183 => _183.destroy, 'call', _184 => _184()]);
+    thumbWorld = new (0, _chunkVMROIWLLcjs.WetWorld)(width, height, wetPaperInput(paper), { kernel: "typescript", threads: 0 });
   } else thumbWorld.setPaper(wetPaperInput(paper));
   const w = thumbWorld;
   if (w.hasLane("thumb")) w.removeLane("thumb");
   w.ensureLane("thumb");
-  const [r, g, b] = _chunk5BR7LC24cjs.hexToRgb8.call(void 0, color);
+  const [r, g, b] = _chunk4T47Z4J3cjs.hexToRgb8.call(void 0, color);
   if (brush.wet.tool !== "paint" && brush.wet.tool !== "water") {
     const half = Math.ceil(height / 2);
-    w.paint("thumb", { x: 0, y: 0, width, height: half }, null, 0.4, Array.from(_chunkXFYLA3ZOcjs.pigmentOf.call(void 0, [r / 255, g / 255, b / 255], 0), (v) => v * 0.05));
-    w.paint("thumb", { x: 0, y: half, width, height: height - half }, null, 0.4, Array.from(_chunkXFYLA3ZOcjs.pigmentOf.call(void 0, [232 / 255, 196 / 255, 64 / 255], 0), (v) => v * 0.05));
+    w.paint("thumb", { x: 0, y: 0, width, height: half }, null, 0.4, Array.from(_chunkVMROIWLLcjs.pigmentOf.call(void 0, [r / 255, g / 255, b / 255], 0), (v) => v * 0.05));
+    w.paint("thumb", { x: 0, y: half, width, height: height - half }, null, 0.4, Array.from(_chunkVMROIWLLcjs.pigmentOf.call(void 0, [232 / 255, 196 / 255, 64 / 255], 0), (v) => v * 0.05));
   }
   const driver = new WetStrokeDriver({
     world: w,
@@ -2580,9 +2925,9 @@ function paintWetTestStroke(brush, paper, color, width, height) {
     load: brushLoadForStroke(brush, _chunkPQ3H2AANcjs.EMPTY_MIXER_LOAD, [r / 255, g / 255, b / 255]),
     grain: paperGrain(paper),
     paperDepth: paper.depth,
-    paperColor: _chunk5BR7LC24cjs.hexToRgb8.call(void 0, paper.color),
+    paperColor: _chunk4T47Z4J3cjs.hexToRgb8.call(void 0, paper.color),
     seed: 7,
-    copies: [_chunk5BR7LC24cjs.IDENTITY_COPY]
+    copies: [_chunk4T47Z4J3cjs.IDENTITY_COPY]
   });
   driver.push(thumbnailStroke(width, height));
   driver.finish();
@@ -2602,9 +2947,10 @@ function thumbnailStroke(width, height) {
   return pts;
 }
 function paintTestStroke(surface, brush, paper, color, width, height) {
-  const [r, g, b] = _chunk5BR7LC24cjs.hexToRgb8.call(void 0, color);
+  const [r, g, b] = _chunk4T47Z4J3cjs.hexToRgb8.call(void 0, color);
   let result = surface;
   let thick = null;
+  let light = null;
   const session = new PaintStrokeSession(
     {
       update: () => {
@@ -2612,6 +2958,7 @@ function paintTestStroke(surface, brush, paper, color, width, height) {
       commit: (sess, s) => {
         result = _nullishCoalesce(s, () => ( result));
         thick = sess.thickChannels();
+        light = sess.lightChannel();
       }
     },
     {
@@ -2621,28 +2968,30 @@ function paintTestStroke(surface, brush, paper, color, width, height) {
       lockTransparency: false,
       brush,
       color: [r, g, b, 255],
-      background: [..._chunk5BR7LC24cjs.hexToRgb8.call(void 0, paper.color), 255],
+      background: [..._chunk4T47Z4J3cjs.hexToRgb8.call(void 0, paper.color), 255],
       grain: paperGrain(paper),
       paperDepth: paper.depth,
       seed: 7,
       colorHex: color,
       affineCopies: [],
-      copies: [_chunk5BR7LC24cjs.IDENTITY_COPY],
+      copies: [_chunk4T47Z4J3cjs.IDENTITY_COPY],
       mixerLoad: brushLoadForStroke(brush, _chunkPQ3H2AANcjs.EMPTY_MIXER_LOAD, [r / 255, g / 255, b / 255]),
       thick: brush.engine === "impasto" ? { channels: emptyThickChannels() } : void 0,
-      sticker: brush.engine === "sticker" ? { nextId: 1 } : void 0
+      sticker: brush.engine === "sticker" ? { nextId: 1 } : void 0,
+      light: brush.light.amount > 0 && brush.engine !== "wet" && brush.engine !== "sticker" ? { surface: emptyLight() } : null
     }
   );
   session.push(thumbnailStroke(width, height));
   session.end();
-  return thick ? new LitCache().lit(result, thick, DEFAULT_LIGHTING) : result;
+  const lit = thick ? new LitCache().lit(result, thick, DEFAULT_LIGHTING) : result;
+  return { surface: light || thick ? new LightCache().glow(lit, _nullishCoalesce(light, () => ( void 0)), _nullishCoalesce(thick, () => ( void 0))) : lit, light };
 }
 function renderBrushThumbnail(brush, options) {
   const width = Math.max(16, Math.min(512, Math.round(_nullishCoalesce(options.width, () => ( 160)))));
   const height = Math.max(16, Math.min(512, Math.round(_nullishCoalesce(options.height, () => ( 48)))));
   const maxSize = height * 0.42;
-  const b = brush.tip.size > maxSize ? _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { tip: { ...brush.tip, size: maxSize } }, brush) : brush;
-  const rgba = [..._chunk5BR7LC24cjs.hexToRgb8.call(void 0, options.color), 255];
+  const b = brush.tip.size > maxSize ? _chunk4T47Z4J3cjs.normalizePaintBrush.call(void 0, { tip: { ...brush.tip, size: maxSize } }, brush) : brush;
+  const rgba = [..._chunk4T47Z4J3cjs.hexToRgb8.call(void 0, options.color), 255];
   let surface = _chunk474IQG74cjs.emptySurface.call(void 0, 4);
   if (b.engine === "eraser") {
     surface = _chunk474IQG74cjs.fillRect.call(void 0, surface, { x: 0, y: 0, width, height }, rgba);
@@ -2652,9 +3001,15 @@ function renderBrushThumbnail(brush, options) {
     surface = _chunk474IQG74cjs.fillRect.call(void 0, surface, { x: 0, y: 0, width, height: half }, rgba);
     surface = _chunk474IQG74cjs.fillRect.call(void 0, surface, { x: 0, y: half, width, height: height - half }, [232, 196, 64, 255]);
   }
-  surface = b.engine === "wet" ? paintWetTestStroke(b, options.paper, options.color, width, height) : paintTestStroke(surface, b, options.paper, options.color, width, height);
+  let light = null;
+  if (b.engine === "wet") surface = paintWetTestStroke(b, options.paper, options.color, width, height);
+  else ({ surface, light } = paintTestStroke(surface, b, options.paper, options.color, width, height));
   const layer = { type: "pixel", id: "thumbnail", name: "thumbnail", visible: true, opacity: 1, blend: "normal", surface, offset: { x: 0, y: 0 } };
-  const data = createPaintCompositor().composite([paperNode(options.paper), layer], { x: 0, y: 0, width, height }, { width, height });
+  const paper = light ? { ...options.paper, color: "#141414" } : options.paper;
+  const spill = light ? computeSpill(surface, light, { radius: Math.max(4, height / 6), strength: 1 }) : null;
+  const layers = [paperNode(paper), layer];
+  if (spill) layers.push({ type: "pixel", id: "thumbnail-light", name: "light", visible: true, opacity: 1, blend: "linear-dodge", surface: spill, offset: { x: 0, y: 0 } });
+  const data = createPaintCompositor().composite(layers, { x: 0, y: 0, width, height }, { width, height });
   return { width, height, data };
 }
 
@@ -2783,13 +3138,13 @@ function perspectiveDirections(g, p) {
   return out;
 }
 var SNAP_DECIDE_DISTANCE = 6;
-var PerspectiveSnapper = (_class7 = class {
-  constructor(guide) {;_class7.prototype.__init65.call(this);_class7.prototype.__init66.call(this);
+var PerspectiveSnapper = (_class8 = class {
+  constructor(guide) {;_class8.prototype.__init69.call(this);_class8.prototype.__init70.call(this);
     this.guide = guide;
   }
   
-  __init65() {this.start = null}
-  __init66() {this.dir = null}
+  __init69() {this.start = null}
+  __init70() {this.dir = null}
   /** The line the stroke follows, once chosen. */
   get line() {
     return this.start && this.dir ? { from: this.start, direction: this.dir } : null;
@@ -2822,7 +3177,7 @@ var PerspectiveSnapper = (_class7 = class {
     const t = (p.x - s.x) * d.x + (p.y - s.y) * d.y;
     return { ...p, x: s.x + d.x * t, y: s.y + d.y * t };
   }
-}, _class7);
+}, _class8);
 function perspectiveGuideLines(g, size, count = 12) {
   const out = [];
   const far = Math.hypot(size.width, size.height) * 4;
@@ -2895,11 +3250,11 @@ function readSwatch(raw) {
   if (!raw || typeof raw !== "object") return null;
   const r = raw;
   const g = _chunkPQ3H2AANcjs.readPaintSource.call(void 0, r.paint);
-  const color = typeof r.color === "string" && /^#[0-9a-f]{6}$/i.test(r.color) ? r.color.toLowerCase() : _optionalChain([g, 'optionalAccess', _155 => _155.type]) === "gradient" ? _chunkPQ3H2AANcjs.paintSourceColor.call(void 0, g) : null;
+  const color = typeof r.color === "string" && /^#[0-9a-f]{6}$/i.test(r.color) ? r.color.toLowerCase() : _optionalChain([g, 'optionalAccess', _185 => _185.type]) === "gradient" ? _chunkPQ3H2AANcjs.paintSourceColor.call(void 0, g) : null;
   if (!color) return null;
   const out = { color };
   if (typeof r.name === "string" && r.name.trim()) out.name = r.name.trim().slice(0, 80);
-  if (_optionalChain([g, 'optionalAccess', _156 => _156.type]) === "gradient") out.paint = g;
+  if (_optionalChain([g, 'optionalAccess', _186 => _186.type]) === "gradient") out.paint = g;
   return out;
 }
 var DEFAULT_SWATCHES = [
@@ -2918,7 +3273,7 @@ var DEFAULT_SWATCHES = [
 // src/paint-editor/mixing-pad.ts
 var MIXING_PAD_WIDTH = 360;
 var MIXING_PAD_HEIGHT = 220;
-var PAD_PAINT = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, {
+var PAD_PAINT = _chunk4T47Z4J3cjs.normalizePaintBrush.call(void 0, {
   id: "pad-paint",
   name: "Pad paint",
   category: "mixer",
@@ -2926,7 +3281,7 @@ var PAD_PAINT = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, {
   tip: { size: 28, hardness: 0.75, spacing: 0.1, opacity: 1, flow: 0.7, pressureSize: false, pressureOpacity: false },
   mixer: { wet: 0.45, load: 1, mix: 0.4, loadEachStroke: true, cleanEachStroke: true, mixing: "pigment" }
 });
-var PAD_KNIFE = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, {
+var PAD_KNIFE = _chunk4T47Z4J3cjs.normalizePaintBrush.call(void 0, {
   id: "pad-knife",
   name: "Palette knife",
   category: "smudge",
@@ -2936,19 +3291,19 @@ var PAD_KNIFE = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, {
   // A knife drags streaks of paint and folds them into each other, mixing them as pigment.
   smudge: { strength: 0.6, length: 0.8, mixing: "pigment" }
 });
-var PAD_BLOB = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, {
+var PAD_BLOB = _chunk4T47Z4J3cjs.normalizePaintBrush.call(void 0, {
   id: "pad-blob",
   name: "Pad blob",
   category: "custom",
   engine: "dab",
   tip: { size: 20, hardness: 1, spacing: 0.1, opacity: 1, flow: 1, pressureSize: false, pressureOpacity: false }
 });
-var MixingPad = (_class8 = class {constructor() { _class8.prototype.__init67.call(this);_class8.prototype.__init68.call(this);_class8.prototype.__init69.call(this);_class8.prototype.__init70.call(this); }
-  __init67() {this.width = MIXING_PAD_WIDTH}
-  __init68() {this.height = MIXING_PAD_HEIGHT}
-  __init69() {this.surface = _chunk474IQG74cjs.emptySurface.call(void 0, 4)}
+var MixingPad = (_class9 = class {constructor() { _class9.prototype.__init71.call(this);_class9.prototype.__init72.call(this);_class9.prototype.__init73.call(this);_class9.prototype.__init74.call(this); }
+  __init71() {this.width = MIXING_PAD_WIDTH}
+  __init72() {this.height = MIXING_PAD_HEIGHT}
+  __init73() {this.surface = _chunk474IQG74cjs.emptySurface.call(void 0, 4)}
   /** Increments on every change (for redrawing). */
-  __init70() {this.version = 0}
+  __init74() {this.version = 0}
   /** Paints (`paint`, with `color`) or smears (`knife`) through `points` in pad pixels. */
   stroke(points, options) {
     if (!points.length) throw new Error("points is empty; give at least one {x, y} in pad pixels.");
@@ -2958,12 +3313,12 @@ var MixingPad = (_class8 = class {constructor() { _class8.prototype.__init67.cal
       }
     }
     let brush = options.tool === "knife" ? PAD_KNIFE : PAD_PAINT;
-    if (options.size !== void 0) brush = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { tip: { ...brush.tip, size: options.size } }, brush);
+    if (options.size !== void 0) brush = _chunk4T47Z4J3cjs.normalizePaintBrush.call(void 0, { tip: { ...brush.tip, size: options.size } }, brush);
     return this.run(brush, points, options.color);
   }
   /** Paints `points` with `brush` in `color` on the pad. */
   run(brush, points, color) {
-    const [r, g, b] = _chunk5BR7LC24cjs.hexToRgb8.call(void 0, color);
+    const [r, g, b] = _chunk4T47Z4J3cjs.hexToRgb8.call(void 0, color);
     let result = null;
     const session = new PaintStrokeSession(
       { update: () => {
@@ -2981,7 +3336,7 @@ var MixingPad = (_class8 = class {constructor() { _class8.prototype.__init67.cal
         seed: 1,
         colorHex: color,
         affineCopies: [],
-        copies: [_chunk5BR7LC24cjs.IDENTITY_COPY],
+        copies: [_chunk4T47Z4J3cjs.IDENTITY_COPY],
         mixerLoad: brushLoadForStroke(brush, _chunkPQ3H2AANcjs.EMPTY_MIXER_LOAD, [r / 255, g / 255, b / 255])
       }
     );
@@ -3057,10 +3412,10 @@ var MixingPad = (_class8 = class {constructor() { _class8.prototype.__init67.cal
       const off = used.length === 1 ? 0 : 0.45 * R;
       const x = Math.min(cx + R - r, Math.max(cx - R + r, cx + Math.cos(a) * off));
       const y = Math.min(cy + R - r, Math.max(cy - R + r, cy + Math.sin(a) * off));
-      const blob = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { tip: { ...PAD_BLOB.tip, size: Math.max(2, 2 * r) } }, PAD_BLOB);
+      const blob = _chunk4T47Z4J3cjs.normalizePaintBrush.call(void 0, { tip: { ...PAD_BLOB.tip, size: Math.max(2, 2 * r) } }, PAD_BLOB);
       this.run(blob, [{ x, y }], p.color.toLowerCase());
     });
-    const knife = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { tip: { ...PAD_KNIFE.tip, size: Math.max(12, R * 0.5) } }, PAD_KNIFE);
+    const knife = _chunk4T47Z4J3cjs.normalizePaintBrush.call(void 0, { tip: { ...PAD_KNIFE.tip, size: Math.max(12, R * 0.5) } }, PAD_KNIFE);
     for (let k = 0; k < passes; k++) {
       const stir = [];
       const turns = 1.6;
@@ -3072,10 +3427,10 @@ var MixingPad = (_class8 = class {constructor() { _class8.prototype.__init67.cal
       this.run(knife, stir, "#000000");
     }
     const mixed = _chunkOLNIPTB3cjs.mixPigments.call(void 0, 
-      paints.map((p) => _chunk5BR7LC24cjs.hexToRgb8.call(void 0, p.color).map((v) => v / 255)),
+      paints.map((p) => _chunk4T47Z4J3cjs.hexToRgb8.call(void 0, p.color).map((v) => v / 255)),
       paints.map((p) => p.parts)
     );
-    const core = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { tip: { ...PAD_BLOB.tip, size: R * 1.1, hardness: 0.55 } }, PAD_BLOB);
+    const core = _chunk4T47Z4J3cjs.normalizePaintBrush.call(void 0, { tip: { ...PAD_BLOB.tip, size: R * 1.1, hardness: 0.55 } }, PAD_BLOB);
     const hex = "#" + mixed.map((v) => Math.round(v * 255).toString(16).padStart(2, "0")).join("");
     this.run(core, [{ x: cx, y: cy }], hex);
     return { color: this.pick(cx, cy, 2), bounds };
@@ -3086,7 +3441,7 @@ var MixingPad = (_class8 = class {constructor() { _class8.prototype.__init67.cal
   }
   /** Replaces the pad with a PNG (data URL or base64) of the pad's size, as `toPng` writes. */
   fromPng(png) {
-    const bytes = png.startsWith("data:") ? _optionalChain([_chunkOLNIPTB3cjs.parseDataUrl.call(void 0, png), 'optionalAccess', _157 => _157.bytes]) : _chunkOLNIPTB3cjs.base64ToBytes.call(void 0, png);
+    const bytes = png.startsWith("data:") ? _optionalChain([_chunkOLNIPTB3cjs.parseDataUrl.call(void 0, png), 'optionalAccess', _187 => _187.bytes]) : _chunkOLNIPTB3cjs.base64ToBytes.call(void 0, png);
     if (!bytes || !_chunkOLNIPTB3cjs.isPng.call(void 0, bytes)) throw new Error("The pad image is not a PNG data URL or base64 PNG.");
     const img = _chunkOLNIPTB3cjs.decodePng.call(void 0, bytes);
     if (img.width !== this.width || img.height !== this.height) throw new Error(`The pad image is ${img.width}\xD7${img.height}; a mixing pad is ${this.width}\xD7${this.height}.`);
@@ -3109,7 +3464,7 @@ var MixingPad = (_class8 = class {constructor() { _class8.prototype.__init67.cal
     }
     return px;
   }
-}, _class8);
+}, _class9);
 
 // src/paint-editor/live-strokes.ts
 var LIVE_STROKE_ENGINES = ["dab", "particle", "bristle", "mixer"];
@@ -3127,6 +3482,7 @@ function liveStrokeRefusal(brush) {
     case "smudge":
       return `The ${brush.name} brush moves the paint under it, so it can't be redrawn on its own; rasterize the layer first (rasterize_stroke_layer) or blend on a pixel layer.`;
   }
+  if (brush.light.amount > 0) return `The ${brush.name} brush lays light, which a stroke layer doesn't redraw yet; paint light on a pixel layer (add_layer), or set light.amount to 0 (set_brush).`;
   if (brush.behavior.pickup > 0) return `The ${brush.name} brush picks up the paint under it (pickup ${brush.behavior.pickup}), so it can't be redrawn on its own; set behavior.pickup to 0 (set_brush) or paint on a pixel layer.`;
   return null;
 }
@@ -3148,6 +3504,212 @@ function liveStrokeBounds(stroke) {
   return { x: Math.floor(x0 - pad), y: Math.floor(y0 - pad), width: Math.ceil(x1 - x0 + 2 * pad), height: Math.ceil(y1 - y0 + 2 * pad) };
 }
 
+// src/paint-editor/backlight.ts
+var DEFAULT_BACKLIGHT_COLOR = "#fff1d6";
+var BACKLIGHT_SPILL = { radius: 24, strength: 1.5 };
+var BLOCK_HEIGHT = 96;
+var VALLEY_GAIN = 0.35;
+function backlightOf(paper) {
+  return _nullishCoalesce(paper.backlight, () => ( 0));
+}
+var LIN = new Float64Array(256);
+for (let i = 0; i < 256; i++) LIN[i] = _chunk7AHBW2CQcjs.srgbToLinear.call(void 0, i / 255);
+function needAlpha(e, p) {
+  if (e < p) return 1 - e / p;
+  if (e > p) return (e - p) / (255 - p);
+  return 0;
+}
+function tilesUnder(surface, rect, offset, out) {
+  if (!surface) {
+    out.push(null);
+    return;
+  }
+  const x0 = Math.floor((rect.x - offset.x) / _chunk474IQG74cjs.TILE);
+  const y0 = Math.floor((rect.y - offset.y) / _chunk474IQG74cjs.TILE);
+  const x1 = Math.floor((rect.x - offset.x + rect.width - 1) / _chunk474IQG74cjs.TILE);
+  const y1 = Math.floor((rect.y - offset.y + rect.height - 1) / _chunk474IQG74cjs.TILE);
+  for (let ty = y0; ty <= y1; ty++) for (let tx = x0; tx <= x1; tx++) out.push(_nullishCoalesce(surface.tiles.get(_chunk474IQG74cjs.tileKey.call(void 0, tx, ty)), () => ( null)));
+}
+var sameRefs = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
+var BacklightCache = (_class10 = class {constructor() { _class10.prototype.__init75.call(this);_class10.prototype.__init76.call(this);_class10.prototype.__init77.call(this);_class10.prototype.__init78.call(this); }
+  __init75() {this.tiles = /* @__PURE__ */ new Map()}
+  __init76() {this.key = ""}
+  __init77() {this.spillOf = null}
+  __init78() {this.out = null}
+  /**
+   * The backlight layer's pixels for `layers` (bottom first) on `paper` over a `width` × `height`
+   * canvas, or `null` when the paper has no backlight. `spillFrom` is the committed painting (the
+   * spill is drawn from it, so a stroke in progress does not redo the blur every frame).
+   */
+  surface(paper, grain, width, height, layers, spillFrom) {
+    const amount = backlightOf(paper);
+    if (!(amount > 0)) return null;
+    const key = JSON.stringify([amount, _nullishCoalesce(paper.backlightColor, () => ( DEFAULT_BACKLIGHT_COLOR)), paper.color, paper.depth, grain.flat, width, height, layers.length, layers.map((l) => [l.opacity, l.offset.x, l.offset.y, l.surface.channels])]);
+    if (key !== this.key) {
+      this.tiles.clear();
+      this.key = key;
+    }
+    const light = /* @__PURE__ */ new Map();
+    const color = /* @__PURE__ */ new Map();
+    const painted = /* @__PURE__ */ new Map();
+    const tilesX = Math.ceil(width / _chunk474IQG74cjs.TILE);
+    const tilesY = Math.ceil(height / _chunk474IQG74cjs.TILE);
+    const refs = [];
+    for (let ty = 0; ty < tilesY; ty++) {
+      for (let tx = 0; tx < tilesX; tx++) {
+        const rect = { x: tx * _chunk474IQG74cjs.TILE, y: ty * _chunk474IQG74cjs.TILE, width: Math.min(_chunk474IQG74cjs.TILE, width - tx * _chunk474IQG74cjs.TILE), height: Math.min(_chunk474IQG74cjs.TILE, height - ty * _chunk474IQG74cjs.TILE) };
+        refs.length = 0;
+        for (const l of layers) {
+          tilesUnder(l.surface, rect, l.offset, refs);
+          tilesUnder(_optionalChain([l, 'access', _188 => _188.thick, 'optionalAccess', _189 => _189.height]), rect, l.offset, refs);
+          tilesUnder(_optionalChain([l, 'access', _190 => _190.thick, 'optionalAccess', _191 => _191.material]), rect, l.offset, refs);
+        }
+        const k = _chunk474IQG74cjs.tileKey.call(void 0, tx, ty);
+        let r = this.tiles.get(k);
+        if (!r || !sameRefs(r.refs, refs)) {
+          r = { refs: [...refs], ...computeTile(paper, grain, amount, rect, layers) };
+          this.tiles.set(k, r);
+        }
+        if (r.light) light.set(k, r.light);
+        if (r.color) color.set(k, r.color);
+        if (r.painted) painted.set(k, r.painted);
+      }
+    }
+    return { light: new (0, _chunk474IQG74cjs.TiledSurface)(4, light, 0), color: new (0, _chunk474IQG74cjs.TiledSurface)(4, color, 0), painted: new (0, _chunk474IQG74cjs.TiledSurface)(1, painted, 0) };
+  }
+  /**
+   * The full Backlight layer: the light through the paint (`current`) plus the spill of the light
+   * through the committed paint (`committed`), both Linear Dodge. Cached on their tiles.
+   */
+  layer(current, committed, amount) {
+    let spill = null;
+    if (committed) {
+      const s = this.spillOf;
+      if (s && s.color.id === committed.color.id && s.painted.id === committed.painted.id) spill = s.out;
+      else {
+        spill = computeSpill(committed.color, committed.painted, { radius: BACKLIGHT_SPILL.radius, strength: BACKLIGHT_SPILL.strength * amount });
+        this.spillOf = { color: committed.color, painted: committed.painted, out: spill };
+      }
+    }
+    if (!spill) return current.light;
+    const parts = [...current.light.tiles.values(), ...spill.tiles.values()];
+    if (this.out && sameRefs(this.out.parts, parts)) return this.out.surface;
+    const keys = /* @__PURE__ */ new Set([...current.light.tiles.keys(), ...spill.tiles.keys()]);
+    const tiles = /* @__PURE__ */ new Map();
+    for (const key of keys) {
+      const a = current.light.tiles.get(key);
+      const b = spill.tiles.get(key);
+      const t = !a ? b : !b ? a : addTiles(a, b);
+      if (t) tiles.set(key, t);
+    }
+    const surface = new (0, _chunk474IQG74cjs.TiledSurface)(4, tiles, 0);
+    this.out = { parts, surface };
+    return surface;
+  }
+}, _class10);
+var full4 = (t) => {
+  if (t.data.length === _chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * 4) return t.data;
+  const out = new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * 4);
+  const u = _nullishCoalesce(t.uniform, () => ( 0));
+  const bytes = [u >>> 24 & 255, u >>> 16 & 255, u >>> 8 & 255, u & 255];
+  for (let i = 0; i < out.length; i += 4) out.set(bytes, i);
+  return out;
+};
+function addTiles(a, b) {
+  const x = full4(a);
+  const y = full4(b);
+  const out = new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * 4);
+  for (let i = 0; i < out.length; i += 4) {
+    const ay = y[i + 3] / 255;
+    const r = x[i] + y[i] * ay;
+    const g = x[i + 1] + y[i + 1] * ay;
+    const bl = x[i + 2] + y[i + 2] * ay;
+    if (r < 0.5 && g < 0.5 && bl < 0.5) continue;
+    out[i] = Math.round(r);
+    out[i + 1] = Math.round(g);
+    out[i + 2] = Math.round(bl);
+    out[i + 3] = 255;
+  }
+  return _chunk474IQG74cjs.finishTile.call(void 0, out, 4, 0);
+}
+function computeTile(paper, grain, amount, rect, layers) {
+  const n = rect.width * rect.height;
+  const [p0, p1, p2] = _chunk4T47Z4J3cjs.hexToRgb8.call(void 0, paper.color);
+  const pb = [p0, p1, p2];
+  const pl = [Math.max(1e-4, LIN[p0]), Math.max(1e-4, LIN[p1]), Math.max(1e-4, LIN[p2])];
+  const [c0, c1, c2] = _chunk4T47Z4J3cjs.hexToRgb8.call(void 0, _nullishCoalesce(paper.backlightColor, () => ( DEFAULT_BACKLIGHT_COLOR)));
+  const t0 = new Float32Array(n).fill(amount * LIN[c0]);
+  const t1 = new Float32Array(n).fill(amount * LIN[c1]);
+  const t2 = new Float32Array(n).fill(amount * LIN[c2]);
+  const depth = grain.flat ? 0 : paper.depth;
+  if (depth > 0) {
+    for (let y = 0, i = 0; y < rect.height; y++)
+      for (let x = 0; x < rect.width; x++, i++) {
+        const g = 1 + VALLEY_GAIN * depth * (0.5 - grain.at(rect.x + x + 0.5, rect.y + y + 0.5));
+        t0[i] *= g;
+        t1[i] *= g;
+        t2[i] *= g;
+      }
+  }
+  const clear = new Float32Array(n).fill(1);
+  for (const l of layers) {
+    const lr = { x: rect.x - l.offset.x, y: rect.y - l.offset.y, width: rect.width, height: rect.height };
+    if (!l.surface.tiles.size) continue;
+    const px = _chunk474IQG74cjs.readRegion.call(void 0, l.surface, lr);
+    const h = _optionalChain([l, 'access', _192 => _192.thick, 'optionalAccess', _193 => _193.height, 'access', _194 => _194.tiles, 'access', _195 => _195.size]) ? _chunk474IQG74cjs.readRegion.call(void 0, l.thick.height, lr) : null;
+    const m = h && _optionalChain([l, 'access', _196 => _196.thick, 'optionalAccess', _197 => _197.material, 'access', _198 => _198.tiles, 'access', _199 => _199.size]) ? _chunk474IQG74cjs.readRegion.call(void 0, l.thick.material, lr) : null;
+    const op = l.opacity;
+    for (let i = 0; i < n; i++) {
+      const a8 = px[i * 4 + 3];
+      if (!a8 && !(h && h[i])) continue;
+      const a = a8 / 255;
+      let aMin = 0;
+      const tr = [1, 1, 1];
+      for (let c = 0; c < 3; c++) {
+        const e = a * px[i * 4 + c] + (1 - a) * pb[c];
+        aMin = Math.max(aMin, needAlpha(e, pb[c]));
+        tr[c] = Math.min(1, LIN[Math.round(e)] / pl[c]);
+      }
+      const hide = aMin < 1 && a > aMin ? (a - aMin) / (1 - aMin) : 0;
+      let k = 1 - hide;
+      if (h && h[i]) {
+        const ma = m ? m[i * 4 + 3] : 0;
+        const clarity = ma ? (255 - ma) / 254 : 0;
+        k *= 1 - Math.min(1, h[i] / BLOCK_HEIGHT) * (1 - clarity);
+      }
+      t0[i] *= 1 - op + op * tr[0] * k;
+      t1[i] *= 1 - op + op * tr[1] * k;
+      t2[i] *= 1 - op + op * tr[2] * k;
+      clear[i] *= 1 - op * Math.max(a, h && h[i] ? 1 : 0);
+    }
+  }
+  const light = new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * 4);
+  const color = new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * 4);
+  const painted = new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE);
+  for (let y = 0, i = 0; y < rect.height; y++) {
+    for (let x = 0; x < rect.width; x++, i++) {
+      const o = (y * _chunk474IQG74cjs.TILE + x) * 4;
+      const add = [Math.min(1, t0[i]), Math.min(1, t1[i]), Math.min(1, t2[i])];
+      const mx = Math.max(add[0], add[1], add[2]);
+      if (mx > 0.5 / 255) {
+        light[o] = Math.round(add[0] * 255);
+        light[o + 1] = Math.round(add[1] * 255);
+        light[o + 2] = Math.round(add[2] * 255);
+        light[o + 3] = 255;
+      }
+      const pv = Math.round((1 - clear[i]) * 255);
+      if (pv && mx > 0.5 / 255) {
+        painted[y * _chunk474IQG74cjs.TILE + x] = pv;
+        color[o] = Math.round(_chunk7AHBW2CQcjs.linearToSrgb.call(void 0, add[0]) * 255);
+        color[o + 1] = Math.round(_chunk7AHBW2CQcjs.linearToSrgb.call(void 0, add[1]) * 255);
+        color[o + 2] = Math.round(_chunk7AHBW2CQcjs.linearToSrgb.call(void 0, add[2]) * 255);
+        color[o + 3] = 255;
+      }
+    }
+  }
+  return { light: _chunk474IQG74cjs.finishTile.call(void 0, light, 4, 0), color: _chunk474IQG74cjs.finishTile.call(void 0, color, 4, 0), painted: _chunk474IQG74cjs.finishTile.call(void 0, painted, 1, 0) };
+}
+
 // src/paint-editor/replay.ts
 function replayItems(doc) {
   const items = [];
@@ -3170,7 +3732,7 @@ async function replayPainting(source, target, options = {}) {
   const maxStrokes = _nullishCoalesce(options.strokes, () => ( source.strokes.length));
   const chunk = Math.max(1, _nullishCoalesce(options.wetChunk, () => ( 0))) || Infinity;
   let strokes = 0;
-  await target.prepareEffectPaints(source.strokes.slice(0, maxStrokes).flatMap((st) => _optionalChain([st, 'access', _158 => _158.paint, 'optionalAccess', _159 => _159.type]) === "effect" ? [st.paint] : []));
+  await target.prepareEffectPaints(source.strokes.slice(0, maxStrokes).flatMap((st) => _optionalChain([st, 'access', _200 => _200.paint, 'optionalAccess', _201 => _201.type]) === "effect" ? [st.paint] : []));
   const advanceTo = async (clock) => {
     const now = target.getState().wet.clock;
     let left = clock - now;
@@ -3178,7 +3740,7 @@ async function replayPainting(source, target, options = {}) {
       const n = Math.min(left, chunk);
       await target.advanceWet({ steps: n });
       left -= n;
-      if (Number.isFinite(chunk)) await _optionalChain([options, 'access', _160 => _160.onWetSteps, 'optionalCall', _161 => _161(target.getState().wet.clock)]);
+      if (Number.isFinite(chunk)) await _optionalChain([options, 'access', _202 => _202.onWetSteps, 'optionalCall', _203 => _203(target.getState().wet.clock)]);
     }
   };
   const sr = (r) => ({ x: r.x * s, y: r.y * s, width: r.width * s, height: r.height * s });
@@ -3191,14 +3753,14 @@ async function replayPainting(source, target, options = {}) {
       else if (e.kind === "clear") target.clearLayer(e.layerId);
       else if (e.kind === "live-strokes") {
         const d = e.data;
-        if (_optionalChain([d, 'optionalAccess', _162 => _162.rasterized])) target.replaceLiveStrokes(e.layerId, null);
+        if (_optionalChain([d, 'optionalAccess', _204 => _204.rasterized])) target.replaceLiveStrokes(e.layerId, null);
         else {
-          const list = (_nullishCoalesce(_optionalChain([d, 'optionalAccess', _163 => _163.strokes]), () => ( []))).map((st2) => s === 1 ? st2 : { ...varyStroke(st2, scaleM, { scale: s }), ...st2.stencils ? { stencils: st2.stencils.map((x) => scaleStencil(x, s)) } : {} });
-          await target.prepareEffectPaints(list.flatMap((st2) => _optionalChain([st2, 'access', _164 => _164.paint, 'optionalAccess', _165 => _165.type]) === "effect" ? [st2.paint] : []));
+          const list = (_nullishCoalesce(_optionalChain([d, 'optionalAccess', _205 => _205.strokes]), () => ( []))).map((st2) => s === 1 ? st2 : { ...varyStroke(st2, scaleM, { scale: s }), ...st2.stencils ? { stencils: st2.stencils.map((x) => scaleStencil(x, s)) } : {} });
+          await target.prepareEffectPaints(list.flatMap((st2) => _optionalChain([st2, 'access', _206 => _206.paint, 'optionalAccess', _207 => _207.type]) === "effect" ? [st2.paint] : []));
           target.replaceLiveStrokes(e.layerId, list);
         }
       } else if (e.kind === "stickers") {
-        const list = (_nullishCoalesce(_optionalChain([e, 'access', _166 => _166.data, 'optionalAccess', _167 => _167.stickers]), () => ( []))).map((x) => s === 1 ? x : { ...x, x: x.x * s, y: x.y * s, size: x.size * s });
+        const list = (_nullishCoalesce(_optionalChain([e, 'access', _208 => _208.data, 'optionalAccess', _209 => _209.stickers]), () => ( []))).map((x) => s === 1 ? x : { ...x, x: x.x * s, y: x.y * s, size: x.size * s });
         target.replaceStickers(e.layerId, list);
       } else target.flattenRelief(e.layerId);
       continue;
@@ -3211,8 +3773,8 @@ async function replayPainting(source, target, options = {}) {
         switch (e.kind) {
           case "dry": {
             const rect = e.data;
-            const ids = _optionalChain([e, 'access', _168 => _168.layerId, 'optionalAccess', _169 => _169.split, 'call', _170 => _170(","), 'access', _171 => _171.filter, 'call', _172 => _172(Boolean)]);
-            if (_optionalChain([ids, 'optionalAccess', _173 => _173.length])) for (const id of ids) target.dryPaint({ layerId: id, rect: rect ? sr(rect) : void 0 });
+            const ids = _optionalChain([e, 'access', _210 => _210.layerId, 'optionalAccess', _211 => _211.split, 'call', _212 => _212(","), 'access', _213 => _213.filter, 'call', _214 => _214(Boolean)]);
+            if (_optionalChain([ids, 'optionalAccess', _215 => _215.length])) for (const id of ids) target.dryPaint({ layerId: id, rect: rect ? sr(rect) : void 0 });
             else target.dryPaint({ rect: rect ? sr(rect) : void 0 });
             break;
           }
@@ -3243,7 +3805,7 @@ async function replayPainting(source, target, options = {}) {
     strokes++;
     if (!target.getLayer(st.layerId)) continue;
     const init = { layerId: st.layerId, color: st.color, brush: st.brush, seed: st.seed, copies: _nullishCoalesce(st.copies, () => ( [])), ...st.load ? { load: st.load } : {}, ...st.paint ? { paint: st.paint } : {}, snapToPerspective: false, stencils: false, maskStencils: (_nullishCoalesce(st.stencils, () => ( []))).map((x) => s === 1 ? x : scaleStencil(x, s)) };
-    if (st.brush.engine === "wet" && _optionalChain([st, 'access', _174 => _174.steps, 'optionalAccess', _175 => _175.length]) === st.points.length) {
+    if (st.brush.engine === "wet" && _optionalChain([st, 'access', _216 => _216.steps, 'optionalAccess', _217 => _217.length]) === st.points.length) {
       await target.wetIdle();
       await advanceTo(st.steps[0]);
       const session = target.beginStroke({ ...init, start: st.points[0] });
@@ -3263,7 +3825,7 @@ async function replayPainting(source, target, options = {}) {
       await target.wetIdle();
       target.paintStroke({ ...init, points: st.points });
     }
-    await _optionalChain([options, 'access', _176 => _176.onStroke, 'optionalCall', _177 => _177(strokes)]);
+    await _optionalChain([options, 'access', _218 => _218.onStroke, 'optionalCall', _219 => _219(strokes)]);
   }
   void IDENTITY_AFFINE;
 }
@@ -3308,7 +3870,7 @@ async function buildTimeLapse(source, target, options = {}) {
     wetChunk: wetEvery > 0 ? wetEvery : 0,
     onStroke: (i) => {
       if (i % perFrame === 0 || i === total) shoot(i);
-      _optionalChain([options, 'access', _178 => _178.onProgress, 'optionalCall', _179 => _179(total ? i / total : 1)]);
+      _optionalChain([options, 'access', _220 => _220.onProgress, 'optionalCall', _221 => _221(total ? i / total : 1)]);
     },
     onWetSteps: wetEvery > 0 ? () => shoot(-1) : void 0
   });
@@ -3395,10 +3957,10 @@ function mixPixels(before, after, amount) {
   }
   return out;
 }
-var PaintEffectsRenderer = (_class9 = class {constructor() { _class9.prototype.__init71.call(this);_class9.prototype.__init72.call(this);_class9.prototype.__init73.call(this); }
-  __init71() {this.pool = new (0, _chunkPY4GWSE2cjs.EffectRendererPool)({ maxRenderers: 3 })}
-  __init72() {this.descriptions = /* @__PURE__ */ new Map()}
-  __init73() {this.provider = null}
+var PaintEffectsRenderer = (_class11 = class {constructor() { _class11.prototype.__init79.call(this);_class11.prototype.__init80.call(this);_class11.prototype.__init81.call(this); }
+  __init79() {this.pool = new (0, _chunkPY4GWSE2cjs.EffectRendererPool)({ maxRenderers: 3 })}
+  __init80() {this.descriptions = /* @__PURE__ */ new Map()}
+  __init81() {this.provider = null}
   /** Forgets cached descriptions and renderers when the provider changes. */
   follow(provider) {
     if (provider === this.provider) return;
@@ -3428,7 +3990,7 @@ var PaintEffectsRenderer = (_class9 = class {constructor() { _class9.prototype._
     this.pool.clear();
     this.descriptions.clear();
   }
-}, _class9);
+}, _class11);
 var sourceOut = (s) => ({
   effect: s.effect,
   ...s.provider ? { provider: s.provider } : {},
@@ -3483,7 +4045,7 @@ function parseColor(value, what = "color") {
   return value.trim().toLowerCase();
 }
 function rgbaOf(hex) {
-  const [r, g, b] = _chunk5BR7LC24cjs.hexToRgb8.call(void 0, hex);
+  const [r, g, b] = _chunk4T47Z4J3cjs.hexToRgb8.call(void 0, hex);
   return [r, g, b, 255];
 }
 function rgbToHex(r, g, b) {
@@ -3496,87 +4058,93 @@ function unionRect(a, b) {
   const y = Math.min(a.y, b.y);
   return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
 }
-var isPixelLayer = (l) => _optionalChain([l, 'optionalAccess', _180 => _180.type]) === "pixel";
-var PaintEditorController = (_class10 = class _PaintEditorController {
+var isPixelLayer = (l) => _optionalChain([l, 'optionalAccess', _222 => _222.type]) === "pixel";
+var PaintEditorController = (_class12 = class _PaintEditorController {
   
-  __init74() {this.extensions = {}}
-  __init75() {this.undoStack = []}
-  __init76() {this.redoStack = []}
+  __init82() {this.extensions = {}}
+  __init83() {this.undoStack = []}
+  __init84() {this.redoStack = []}
   
   
   
   /** The library list in the state (the same array until the user brushes change, so thumbnails are not redrawn). */
-  __init77() {this.library = null}
+  __init85() {this.library = null}
   
-  __init78() {this.secondaryColor = "#ffffff"}
+  __init86() {this.secondaryColor = "#ffffff"}
   /** Gradient paint chosen with `setPaint` (`null`: the paint colour). */
-  __init79() {this.gradient = null}
+  __init87() {this.gradient = null}
   /** Effect paint chosen with `setEffectPaint` (rendered), and one still rendering. */
-  __init80() {this.effectPaint = null}
-  __init81() {this.effectPaintPending = null}
+  __init88() {this.effectPaint = null}
+  __init89() {this.effectPaintPending = null}
   /** Changes whenever the paint is chosen, so an effect paint that finishes rendering late does not take over. */
-  __init82() {this.paintEpoch = 0}
+  __init90() {this.paintEpoch = 0}
   /** Rendered effect paints by `effectPaintKey` (most recently used last). */
-  __init83() {this.effectPaintPixels = /* @__PURE__ */ new Map()}
-  __init84() {this.mixerLoad = _chunkPQ3H2AANcjs.EMPTY_MIXER_LOAD}
-  __init85() {this.view = { ...DEFAULT_VIEW, pan: { ...DEFAULT_VIEW.pan } }}
+  __init91() {this.effectPaintPixels = /* @__PURE__ */ new Map()}
+  __init92() {this.mixerLoad = _chunkPQ3H2AANcjs.EMPTY_MIXER_LOAD}
+  __init93() {this.view = { ...DEFAULT_VIEW, pan: { ...DEFAULT_VIEW.pan } }}
   
-  __init86() {this.selectedStroke = null}
-  __init87() {this.selectedSticker = null}
+  __init94() {this.selectedStroke = null}
+  __init95() {this.selectedSticker = null}
   /** A sticker drag in progress (`previewSticker`): the document before it, so the drop undoes in one step, and the one it showed last. */
-  __init88() {this.stickerPreview = null}
+  __init96() {this.stickerPreview = null}
   
-  __init89() {this.listeners = /* @__PURE__ */ new Set()}
-  __init90() {this.version = 0}
-  __init91() {this.cached = null}
-  __init92() {this.session = null}
-  __init93() {this.live = null}
-  __init94() {this.liveLayers = null}
-  __init95() {this.dirty = "all"}
-  __init96() {this.seedCounter = 1}
-  __init97() {this.strokeCounter = 1}
+  __init97() {this.listeners = /* @__PURE__ */ new Set()}
+  __init98() {this.version = 0}
+  __init99() {this.cached = null}
+  __init100() {this.session = null}
+  __init101() {this.live = null}
+  __init102() {this.liveLayers = null}
+  __init103() {this.dirty = "all"}
+  __init104() {this.seedCounter = 1}
+  __init105() {this.strokeCounter = 1}
+  /** Light paint: each layer's spill settings (saved with the document, not undo steps; missing = the defaults). */
+  __init106() {this.lightSpills = {}}
+  __init107() {this.lightCaches = /* @__PURE__ */ new Map()}
+  /** Backlit paper: the light through the paint as drawn (live strokes too), and as committed (its spill). */
+  __init108() {this.backlightView = new BacklightCache()}
+  __init109() {this.backlightCommitted = new BacklightCache()}
   /** Live effect paint: playing and the frame rate cap (editor state), and the time the view shows. */
-  __init98() {this.effectPlaybackState = { playing: true, fps: 30 }}
-  __init99() {this.effectTime = 0}
+  __init110() {this.effectPlaybackState = { playing: true, fps: 30 }}
+  __init111() {this.effectTime = 0}
   /** While a frame is drawn: the time live effect strokes are drawn at (else their own time). */
-  __init100() {this.liveEffectAt = null}
+  __init112() {this.liveEffectAt = null}
   /** The view's stroke layers at `effectTime`, each with the document surface it was drawn from (stale once that changes). */
-  __init101() {this.animatedLayers = /* @__PURE__ */ new Map()}
+  __init113() {this.animatedLayers = /* @__PURE__ */ new Map()}
   /** `renderAnimationFrame` / `withEffectTime`: layer surfaces at another time, for one render. */
-  __init102() {this.frameOverride = null}
+  __init114() {this.frameOverride = null}
   /** The area each stroke painted (document pixels; `null`: nothing), learnt as it is painted or drawn, so a stroke layer edit redraws only where it changes (see `drawLiveStrokes`). */
-  __init103() {this.paintedBounds = /* @__PURE__ */ new WeakMap()}
+  __init115() {this.paintedBounds = /* @__PURE__ */ new WeakMap()}
   
-  __init104() {this.swatches = DEFAULT_SWATCHES.map((s) => ({ ...s }))}
-  __init105() {this.pad = new MixingPad()}
-  __init106() {this.savedPads = []}
-  __init107() {this.nextPadId = 1}
-  __init108() {this.tracingVersion = 1}
-  __init109() {this.tracingCache = null}
-  __init110() {this.imagePixels = /* @__PURE__ */ new Map()}
-  __init111() {this.nextReferenceId = 1}
-  __init112() {this.viewCompositor = createPaintCompositor()}
-  __init113() {this.exportCompositor = createPaintCompositor()}
+  __init116() {this.swatches = DEFAULT_SWATCHES.map((s) => ({ ...s }))}
+  __init117() {this.pad = new MixingPad()}
+  __init118() {this.savedPads = []}
+  __init119() {this.nextPadId = 1}
+  __init120() {this.tracingVersion = 1}
+  __init121() {this.tracingCache = null}
+  __init122() {this.imagePixels = /* @__PURE__ */ new Map()}
+  __init123() {this.nextReferenceId = 1}
+  __init124() {this.viewCompositor = createPaintCompositor()}
+  __init125() {this.exportCompositor = createPaintCompositor()}
   /** Wet media: the simulation, its settings and time. */
   
   
   /** Where the light comes from for thick paint (saved with the document, not undo steps). */
-  __init114() {this.lighting = { ...DEFAULT_LIGHTING }}
-  __init115() {this.litCaches = /* @__PURE__ */ new Map()}
+  __init126() {this.lighting = { ...DEFAULT_LIGHTING }}
+  __init127() {this.litCaches = /* @__PURE__ */ new Map()}
   /** The live impasto stroke's channels. */
-  __init116() {this.liveThick = null}
+  __init128() {this.liveThick = null}
   /** Set while an operation that changes wet paint runs: the simulation before it (for undo). */
-  __init117() {this.wetOp = null}
+  __init129() {this.wetOp = null}
   /** The effects provider slot (see `setEffectsProvider`). */
-  __init118() {this.effects = new (0, _chunkGHCSC2WPcjs.EffectsSlot)()}
-  __init119() {this.effectsRenderer = new PaintEffectsRenderer()}
-  __init120() {this.paperEffectNodeCache = null}
-  constructor(options = {}) {;_class10.prototype.__init74.call(this);_class10.prototype.__init75.call(this);_class10.prototype.__init76.call(this);_class10.prototype.__init77.call(this);_class10.prototype.__init78.call(this);_class10.prototype.__init79.call(this);_class10.prototype.__init80.call(this);_class10.prototype.__init81.call(this);_class10.prototype.__init82.call(this);_class10.prototype.__init83.call(this);_class10.prototype.__init84.call(this);_class10.prototype.__init85.call(this);_class10.prototype.__init86.call(this);_class10.prototype.__init87.call(this);_class10.prototype.__init88.call(this);_class10.prototype.__init89.call(this);_class10.prototype.__init90.call(this);_class10.prototype.__init91.call(this);_class10.prototype.__init92.call(this);_class10.prototype.__init93.call(this);_class10.prototype.__init94.call(this);_class10.prototype.__init95.call(this);_class10.prototype.__init96.call(this);_class10.prototype.__init97.call(this);_class10.prototype.__init98.call(this);_class10.prototype.__init99.call(this);_class10.prototype.__init100.call(this);_class10.prototype.__init101.call(this);_class10.prototype.__init102.call(this);_class10.prototype.__init103.call(this);_class10.prototype.__init104.call(this);_class10.prototype.__init105.call(this);_class10.prototype.__init106.call(this);_class10.prototype.__init107.call(this);_class10.prototype.__init108.call(this);_class10.prototype.__init109.call(this);_class10.prototype.__init110.call(this);_class10.prototype.__init111.call(this);_class10.prototype.__init112.call(this);_class10.prototype.__init113.call(this);_class10.prototype.__init114.call(this);_class10.prototype.__init115.call(this);_class10.prototype.__init116.call(this);_class10.prototype.__init117.call(this);_class10.prototype.__init118.call(this);_class10.prototype.__init119.call(this);_class10.prototype.__init120.call(this);_class10.prototype.__init121.call(this);_class10.prototype.__init122.call(this);_class10.prototype.__init123.call(this);_class10.prototype.__init124.call(this);
+  __init130() {this.effects = new (0, _chunkGHCSC2WPcjs.EffectsSlot)()}
+  __init131() {this.effectsRenderer = new PaintEffectsRenderer()}
+  __init132() {this.paperEffectNodeCache = null}
+  constructor(options = {}) {;_class12.prototype.__init82.call(this);_class12.prototype.__init83.call(this);_class12.prototype.__init84.call(this);_class12.prototype.__init85.call(this);_class12.prototype.__init86.call(this);_class12.prototype.__init87.call(this);_class12.prototype.__init88.call(this);_class12.prototype.__init89.call(this);_class12.prototype.__init90.call(this);_class12.prototype.__init91.call(this);_class12.prototype.__init92.call(this);_class12.prototype.__init93.call(this);_class12.prototype.__init94.call(this);_class12.prototype.__init95.call(this);_class12.prototype.__init96.call(this);_class12.prototype.__init97.call(this);_class12.prototype.__init98.call(this);_class12.prototype.__init99.call(this);_class12.prototype.__init100.call(this);_class12.prototype.__init101.call(this);_class12.prototype.__init102.call(this);_class12.prototype.__init103.call(this);_class12.prototype.__init104.call(this);_class12.prototype.__init105.call(this);_class12.prototype.__init106.call(this);_class12.prototype.__init107.call(this);_class12.prototype.__init108.call(this);_class12.prototype.__init109.call(this);_class12.prototype.__init110.call(this);_class12.prototype.__init111.call(this);_class12.prototype.__init112.call(this);_class12.prototype.__init113.call(this);_class12.prototype.__init114.call(this);_class12.prototype.__init115.call(this);_class12.prototype.__init116.call(this);_class12.prototype.__init117.call(this);_class12.prototype.__init118.call(this);_class12.prototype.__init119.call(this);_class12.prototype.__init120.call(this);_class12.prototype.__init121.call(this);_class12.prototype.__init122.call(this);_class12.prototype.__init123.call(this);_class12.prototype.__init124.call(this);_class12.prototype.__init125.call(this);_class12.prototype.__init126.call(this);_class12.prototype.__init127.call(this);_class12.prototype.__init128.call(this);_class12.prototype.__init129.call(this);_class12.prototype.__init130.call(this);_class12.prototype.__init131.call(this);_class12.prototype.__init132.call(this);_class12.prototype.__init133.call(this);_class12.prototype.__init134.call(this);_class12.prototype.__init135.call(this);_class12.prototype.__init136.call(this);
     this.historyLimit = Math.max(1, _nullishCoalesce(options.historyLimit, () => ( 200)));
     this.doc = createPaintDocument({ width: options.width, height: options.height, dpi: options.dpi, paper: this.resolvePaper(options.paper) });
-    this.userBrushes = (_nullishCoalesce(options.brushes, () => ( []))).map((b) => _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { ...b, builtin: false }));
-    const start = _nullishCoalesce(this.findBrush(_nullishCoalesce(options.brushId, () => ( _chunk5BR7LC24cjs.DEFAULT_BRUSH_ID))), () => ( this.findBrush(_chunk5BR7LC24cjs.DEFAULT_BRUSH_ID)));
-    this.brush = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, start);
+    this.userBrushes = (_nullishCoalesce(options.brushes, () => ( []))).map((b) => _chunk4T47Z4J3cjs.normalizePaintBrush.call(void 0, { ...b, builtin: false }));
+    const start = _nullishCoalesce(this.findBrush(_nullishCoalesce(options.brushId, () => ( _chunk4T47Z4J3cjs.DEFAULT_BRUSH_ID))), () => ( this.findBrush(_chunk4T47Z4J3cjs.DEFAULT_BRUSH_ID)));
+    this.brush = _chunk4T47Z4J3cjs.normalizePaintBrush.call(void 0, start);
     this.color = options.color ? parseColor(options.color) : "#1f2937";
     this.hand = options.hand === "left" ? "left" : "right";
     this.encodeImage = options.encodeImage;
@@ -3587,7 +4155,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
         canvas: () => this.doc.canvas,
         paper: () => this.doc.paper,
         layerSurface: (id) => {
-          const l = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _181 => _181.layer]);
+          const l = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _223 => _223.layer]);
           return isPixelLayer(l) ? l.surface : null;
         },
         updateSurfaces: (surfaces, rects) => {
@@ -3596,12 +4164,18 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
           this.doc = { ...this.doc, layers };
           this.emit(rects.length ? rects : "all");
         },
+        layerLight: (id) => _nullishCoalesce(_optionalChain([this, 'access', _224 => _224.doc, 'access', _225 => _225.light, 'optionalAccess', _226 => _226[id]]), () => ( null)),
+        updateLights: (lights) => {
+          let light = this.doc.light;
+          for (const [id, surface] of lights) if (_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id)) light = withLayerLight(light, id, surface);
+          this.doc = { ...this.doc, ...light ? { light } : {} };
+        },
         changed: () => {
         }
       },
       options.wet
     );
-    this.wet.onDriverDone = () => _optionalChain([this, 'access', _182 => _182.session, 'optionalAccess', _183 => _183.completeWetEnd, 'call', _184 => _184()]);
+    this.wet.onDriverDone = () => _optionalChain([this, 'access', _227 => _227.session, 'optionalAccess', _228 => _228.completeWetEnd, 'call', _229 => _229()]);
   }
   // --- State and events ----------------------------------------------------------
   subscribe(listener) {
@@ -3623,7 +4197,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     this.cached = {
       document: this.doc,
       brush: this.brush,
-      brushes: this.library ??= [..._chunk5BR7LC24cjs.BUILTIN_BRUSHES, ...this.userBrushes],
+      brushes: this.library ??= [..._chunk4T47Z4J3cjs.BUILTIN_BRUSHES, ...this.userBrushes],
       color: this.color,
       secondaryColor: this.secondaryColor,
       paint: _nullishCoalesce(this.gradient, () => ( { type: "color", color: this.color })),
@@ -3637,8 +4211,8 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       selectedSticker: this.selectedSticker,
       canUndo: this.undoStack.length > 0 && !this.session,
       canRedo: this.redoStack.length > 0 && !this.session,
-      undoLabel: _nullishCoalesce(_optionalChain([last, 'optionalAccess', _185 => _185.label]), () => ( null)),
-      redoLabel: _nullishCoalesce(_optionalChain([next, 'optionalAccess', _186 => _186.label]), () => ( null)),
+      undoLabel: _nullishCoalesce(_optionalChain([last, 'optionalAccess', _230 => _230.label]), () => ( null)),
+      redoLabel: _nullishCoalesce(_optionalChain([next, 'optionalAccess', _231 => _231.label]), () => ( null)),
       guides: this.guides,
       swatches: this.swatches,
       mixingPadVersion: this.pad.version,
@@ -3651,10 +4225,10 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
         overlay: this.wet.overlay,
         instantDry: this.wet.instantDry,
         speed: this.wet.speed,
-        clock: _nullishCoalesce(_optionalChain([this, 'access', _187 => _187.wet, 'access', _188 => _188.world, 'optionalAccess', _189 => _189.clock]), () => ( 0)),
+        clock: _nullishCoalesce(_optionalChain([this, 'access', _232 => _232.wet, 'access', _233 => _233.world, 'optionalAccess', _234 => _234.clock]), () => ( 0)),
         tilt: { ...this.wet.tilt },
         gpu: this.wet.gpuMode,
-        gpuActive: Boolean(_optionalChain([this, 'access', _190 => _190.wet, 'access', _191 => _191.world, 'optionalAccess', _192 => _192.gpuActive]))
+        gpuActive: Boolean(_optionalChain([this, 'access', _235 => _235.wet, 'access', _236 => _236.world, 'optionalAccess', _237 => _237.gpuActive]))
       },
       version: this.version
     };
@@ -3673,7 +4247,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     return d;
   }
   // --- History -------------------------------------------------------------------
-  __init121() {this.docRevision = 0}
+  __init133() {this.docRevision = 0}
   /**
    * Bumped on every change to the painting (a committed or amended step, undo, redo, opening a
    * document), not on wet-paint frames or view changes. `createPaintEditorDocument` uses it.
@@ -3756,9 +4330,9 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     return wetIds;
   }
   /** Records a wet event (for replays) in the document being built. */
-  __init122() {this.pendingWetEvents = []}
+  __init134() {this.pendingWetEvents = []}
   logWet(e) {
-    this.pendingWetEvents.push({ clock: _nullishCoalesce(_optionalChain([this, 'access', _193 => _193.wet, 'access', _194 => _194.world, 'optionalAccess', _195 => _195.clock]), () => ( 0)), at: this.doc.strokes.length, ...e });
+    this.pendingWetEvents.push({ clock: _nullishCoalesce(_optionalChain([this, 'access', _238 => _238.wet, 'access', _239 => _239.world, 'optionalAccess', _240 => _240.clock]), () => ( 0)), at: this.doc.strokes.length, ...e });
   }
   /** The document with a paint event appended (for replays). */
   withPaintEvent(doc, e) {
@@ -3819,7 +4393,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   // --- Canvas and paper ----------------------------------------------------------
   resolvePaper(paper) {
     if (typeof paper === "string") {
-      const p = _chunk5BR7LC24cjs.paperPreset.call(void 0, paper);
+      const p = _chunk4T47Z4J3cjs.paperPreset.call(void 0, paper);
       if (!p) throw new PaintEditorError(`Unknown paper "${paper}". Call list_papers for the ids.`);
       return p;
     }
@@ -3902,7 +4476,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     }
     let next = { ...shiftDocument(this.withWetEvents(this.doc), left, top), canvas: { ...was, width, height } };
     for (const id of keptWet) {
-      const l = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, next.layers, id), 'optionalAccess', _196 => _196.layer]);
+      const l = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, next.layers, id), 'optionalAccess', _241 => _241.layer]);
       if (isPixelLayer(l)) next = { ...next, layers: _chunkHB4ICNNAcjs.mapLayer.call(void 0, next.layers, id, () => ({ ...l, surface: _chunk474IQG74cjs.translateSurface.call(void 0, l.surface, l.offset.x, l.offset.y), offset: { x: 0, y: 0 } })) };
     }
     if (this.wet.world) {
@@ -3930,23 +4504,23 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     this.requireIdle("changing the paper");
     let base = this.doc.paper;
     if (update.preset !== void 0 && update.preset !== this.doc.paper.preset) {
-      const p = _chunk5BR7LC24cjs.paperPreset.call(void 0, update.preset);
+      const p = _chunk4T47Z4J3cjs.paperPreset.call(void 0, update.preset);
       if (!p) throw new PaintEditorError(`Unknown paper "${update.preset}". Call list_papers for the ids.`);
       base = p;
     }
     const { preset: _p, ...rest } = update;
     if (rest.color !== void 0) parseColor(rest.color, "paper color");
-    const paper = _chunk5BR7LC24cjs.normalizePaper.call(void 0, { ...rest, preset: base.preset, offset: _nullishCoalesce(rest.offset, () => ( this.doc.paper.offset)) }, base);
+    const paper = _chunk4T47Z4J3cjs.normalizePaper.call(void 0, { ...rest, preset: base.preset, offset: _nullishCoalesce(rest.offset, () => ( this.doc.paper.offset)) }, base);
     const changedKeys = Object.keys(rest).filter((k) => k !== "name");
     if (changedKeys.length && update.preset === void 0) paper.preset = base.preset;
     if (this.wet.world) this.beginWetOp();
     this.commit("Paper", { ...this.doc, paper });
     this.wet.paperChanged();
-    return _chunk5BR7LC24cjs.clonePaper.call(void 0, paper);
+    return _chunk4T47Z4J3cjs.clonePaper.call(void 0, paper);
   }
   // --- Layers --------------------------------------------------------------------
   getLayer(id) {
-    return _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _197 => _197.layer]);
+    return _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _242 => _242.layer]);
   }
   /** The active pixel layer (or `undefined`). */
   getActiveLayer() {
@@ -3965,7 +4539,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     walk(this.doc.layers, null, 0);
     return out;
   }
-  describeLayer(l, parentId = _nullishCoalesce(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _198 => _198.parent, 'optionalAccess', _199 => _199.id]), () => ( null)), depth = _nullishCoalesce(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _200 => _200.path, 'access', _201 => _201.length]), () => ( 0))) {
+  describeLayer(l, parentId = _nullishCoalesce(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _243 => _243.parent, 'optionalAccess', _244 => _244.id]), () => ( null)), depth = _nullishCoalesce(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _245 => _245.path, 'access', _246 => _246.length]), () => ( 0))) {
     let bounds = null;
     if (l.type === "pixel") {
       const b = _chunk474IQG74cjs.contentBounds.call(void 0, l.surface);
@@ -3982,7 +4556,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       locks: { ..._nullishCoalesce(l.locks, () => ( {})) },
       active: l.id === this.doc.activeLayerId,
       bounds,
-      ..._optionalChain([this, 'access', _202 => _202.doc, 'access', _203 => _203.liveStrokes, 'optionalAccess', _204 => _204[l.id]]) ? { liveStrokes: this.doc.liveStrokes[l.id].length } : {},
+      ..._optionalChain([this, 'access', _247 => _247.doc, 'access', _248 => _248.liveStrokes, 'optionalAccess', _249 => _249[l.id]]) ? { liveStrokes: this.doc.liveStrokes[l.id].length } : {},
       parentId,
       depth
     };
@@ -4014,7 +4588,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     this.requireIdle("adding a layer");
     const count = _chunkHB4ICNNAcjs.flattenLayers.call(void 0, this.doc.layers).length;
     const type = _nullishCoalesce(options.type, () => ( "pixel"));
-    const name = _optionalChain([options, 'access', _205 => _205.name, 'optionalAccess', _206 => _206.trim, 'call', _207 => _207()]) || (type === "group" ? `Group ${count + 1}` : type === "strokes" ? `Strokes ${count + 1}` : `Layer ${count + 1}`);
+    const name = _optionalChain([options, 'access', _250 => _250.name, 'optionalAccess', _251 => _251.trim, 'call', _252 => _252()]) || (type === "group" ? `Group ${count + 1}` : type === "strokes" ? `Strokes ${count + 1}` : `Layer ${count + 1}`);
     const layer = type === "group" ? { type: "group", id: newPaintLayerId(), name, visible: true, opacity: 1, blend: "pass-through", children: [] } : createPaintLayer(name);
     let parentId = null;
     let index;
@@ -4026,7 +4600,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     } else if (above) {
       const loc = _chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, above);
       if (!loc) throw new PaintEditorError(`Unknown layer "${above}". Call list_layers for the ids.`);
-      parentId = _nullishCoalesce(_optionalChain([loc, 'access', _208 => _208.parent, 'optionalAccess', _209 => _209.id]), () => ( null));
+      parentId = _nullishCoalesce(_optionalChain([loc, 'access', _253 => _253.parent, 'optionalAccess', _254 => _254.id]), () => ( null));
       index = loc.index + 1;
     }
     const layers = _chunkHB4ICNNAcjs.insertLayer.call(void 0, this.doc.layers, layer, parentId, index);
@@ -4067,8 +4641,8 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     }
     const layers = _chunkHB4ICNNAcjs.mapLayer.call(void 0, this.doc.layers, id, () => null);
     let active = this.doc.activeLayerId;
-    if (active && !_chunkHB4ICNNAcjs.findLayer.call(void 0, layers, active)) active = _nullishCoalesce(_optionalChain([_chunkHB4ICNNAcjs.flattenLayers.call(void 0, layers), 'access', _210 => _210.filter, 'call', _211 => _211((x) => x.type === "pixel"), 'access', _212 => _212.pop, 'call', _213 => _213(), 'optionalAccess', _214 => _214.id]), () => ( null));
-    this.commit("Remove layer", { ...this.doc, layers, activeLayerId: active, ...this.thickWithout(_chunkHB4ICNNAcjs.flattenLayers.call(void 0, [l]).map((x) => x.id)), ...this.stickersWithout(_chunkHB4ICNNAcjs.flattenLayers.call(void 0, [l]).map((x) => x.id)), ...this.liveStrokesWithout(_chunkHB4ICNNAcjs.flattenLayers.call(void 0, [l]).map((x) => x.id)) });
+    if (active && !_chunkHB4ICNNAcjs.findLayer.call(void 0, layers, active)) active = _nullishCoalesce(_optionalChain([_chunkHB4ICNNAcjs.flattenLayers.call(void 0, layers), 'access', _255 => _255.filter, 'call', _256 => _256((x) => x.type === "pixel"), 'access', _257 => _257.pop, 'call', _258 => _258(), 'optionalAccess', _259 => _259.id]), () => ( null));
+    this.commit("Remove layer", { ...this.doc, layers, activeLayerId: active, ...this.thickWithout(_chunkHB4ICNNAcjs.flattenLayers.call(void 0, [l]).map((x) => x.id)), ...this.stickersWithout(_chunkHB4ICNNAcjs.flattenLayers.call(void 0, [l]).map((x) => x.id)), ...this.liveStrokesWithout(_chunkHB4ICNNAcjs.flattenLayers.call(void 0, [l]).map((x) => x.id)), ...this.lightWithout(_chunkHB4ICNNAcjs.flattenLayers.call(void 0, [l]).map((x) => x.id)) });
     return { removed: id, activeLayerId: active };
   }
   duplicateLayer(id) {
@@ -4082,16 +4656,19 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const thick = { ..._nullishCoalesce(this.doc.thick, () => ( {})) };
     const stickers = { ..._nullishCoalesce(this.doc.stickers, () => ( {})) };
     const liveStrokes = { ..._nullishCoalesce(this.doc.liveStrokes, () => ( {})) };
+    const light = { ..._nullishCoalesce(this.doc.light, () => ( {})) };
     const copy = (l) => {
       const id2 = newPaintLayerId();
+      if (light[l.id]) light[id2] = light[l.id];
+      if (this.lightSpills[l.id]) this.lightSpills[id2] = { ...this.lightSpills[l.id] };
       if (thick[l.id]) thick[id2] = thick[l.id];
       if (stickers[l.id]) stickers[id2] = stickers[l.id].map((x) => ({ ...x }));
       if (liveStrokes[l.id]) liveStrokes[id2] = liveStrokes[l.id].map((x) => ({ ...x, id: `s${this.strokeCounter++}`, layerId: id2 }));
       return l.type === "group" ? { ...l, id: id2, children: l.children.map(copy) } : { ...l, id: id2 };
     };
     const dup = { ...copy(loc.layer), name: `${loc.layer.name} copy` };
-    const layers = _chunkHB4ICNNAcjs.insertLayer.call(void 0, this.doc.layers, dup, _nullishCoalesce(_optionalChain([loc, 'access', _215 => _215.parent, 'optionalAccess', _216 => _216.id]), () => ( null)), loc.index + 1);
-    this.commit("Duplicate layer", this.withWetEvents({ ...this.doc, layers, activeLayerId: dup.id, ...this.doc.thick ? { thick } : {}, ...this.doc.stickers ? { stickers } : {}, ...this.doc.liveStrokes ? { liveStrokes } : {} }));
+    const layers = _chunkHB4ICNNAcjs.insertLayer.call(void 0, this.doc.layers, dup, _nullishCoalesce(_optionalChain([loc, 'access', _260 => _260.parent, 'optionalAccess', _261 => _261.id]), () => ( null)), loc.index + 1);
+    this.commit("Duplicate layer", this.withWetEvents({ ...this.doc, layers, activeLayerId: dup.id, ...this.doc.thick ? { thick } : {}, ...this.doc.stickers ? { stickers } : {}, ...this.doc.liveStrokes ? { liveStrokes } : {}, ...this.doc.light ? { light } : {} }));
     return this.describeLayer(dup);
   }
   /** Moves a layer to `index` (0 = bottom) within `parentId` (default its own parent; `null` = top level). */
@@ -4099,7 +4676,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     this.requireIdle("moving a layer");
     const loc = _chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id);
     if (!loc) throw new PaintEditorError(`Unknown layer "${id}". Call list_layers for the ids.`);
-    const target = parentId === void 0 ? _nullishCoalesce(_optionalChain([loc, 'access', _217 => _217.parent, 'optionalAccess', _218 => _218.id]), () => ( null)) : parentId;
+    const target = parentId === void 0 ? _nullishCoalesce(_optionalChain([loc, 'access', _262 => _262.parent, 'optionalAccess', _263 => _263.id]), () => ( null)) : parentId;
     if (target) {
       const g = this.requireLayer(target);
       if (g.type !== "group") throw new PaintEditorError(`Layer "${g.name}" is not a group; pass a group id as parentId.`);
@@ -4118,7 +4695,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const pre = _chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id);
     if (pre) {
       const sib = pre.parent ? pre.parent.children : this.doc.layers;
-      this.dryLayersFirst([id, _optionalChain([sib, 'access', _219 => _219[pre.index - 1], 'optionalAccess', _220 => _220.id])].filter((x) => Boolean(x)));
+      this.dryLayersFirst([id, _optionalChain([sib, 'access', _264 => _264[pre.index - 1], 'optionalAccess', _265 => _265.id])].filter((x) => Boolean(x)));
     }
     const loc = _chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id);
     if (!loc) throw new PaintEditorError(`Unknown layer "${id}". Call list_layers for the ids.`);
@@ -4137,7 +4714,11 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     }
     const merged = { ...below, surface, offset: { x: 0, y: 0 } };
     const layers = _chunkHB4ICNNAcjs.mapLayer.call(void 0, _chunkHB4ICNNAcjs.mapLayer.call(void 0, this.doc.layers, upper.id, () => null), below.id, () => merged);
-    this.commit("Merge down", this.withWetEvents({ ...this.doc, layers, activeLayerId: below.id, ...this.thickWithout([upper.id]), ...this.stickersWithout([upper.id, below.id]), ...this.liveStrokesWithout([upper.id, below.id]) }));
+    const toDoc = (t, l) => t ? _chunk474IQG74cjs.translateSurface.call(void 0, t, l.offset.x, l.offset.y) : void 0;
+    const mergedLight = _optionalChain([this, 'access', _266 => _266.doc, 'access', _267 => _267.light, 'optionalAccess', _268 => _268[upper.id]]) || _optionalChain([this, 'access', _269 => _269.doc, 'access', _270 => _270.light, 'optionalAccess', _271 => _271[below.id]]) ? mergeLight(toDoc(_optionalChain([this, 'access', _272 => _272.doc, 'access', _273 => _273.light, 'optionalAccess', _274 => _274[below.id]]), below), upper.visible ? toDoc(_optionalChain([this, 'access', _275 => _275.doc, 'access', _276 => _276.light, 'optionalAccess', _277 => _277[upper.id]]), upper) : void 0, _chunk474IQG74cjs.translateSurface.call(void 0, upper.surface, upper.offset.x, upper.offset.y)) : void 0;
+    const lightAfter = _nullishCoalesce(this.lightWithout([upper.id, below.id]).light, () => ( (this.doc.light ? { ...this.doc.light } : void 0)));
+    const light = mergedLight ? { ..._nullishCoalesce(lightAfter, () => ( {})), [below.id]: mergedLight } : lightAfter;
+    this.commit("Merge down", this.withWetEvents({ ...this.doc, layers, activeLayerId: below.id, ...this.thickWithout([upper.id]), ...this.stickersWithout([upper.id, below.id]), ...this.liveStrokesWithout([upper.id, below.id]), ...light ? { light } : {} }));
     return this.describeLayer(merged);
   }
   /** Removes every pixel of a layer. */
@@ -4149,7 +4730,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       this.wet.world.removeLane(l.id);
     }
     const bounds = this.describeLayer(l).bounds;
-    this.commit("Clear layer", this.withPaintEvent({ ...this.doc, layers: _chunkHB4ICNNAcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface: _chunk474IQG74cjs.emptySurface.call(void 0, 4) })), ...this.thickWithout([l.id]), ...this.stickersWithout([l.id]), ..._optionalChain([this, 'access', _221 => _221.doc, 'access', _222 => _222.liveStrokes, 'optionalAccess', _223 => _223[l.id]]) ? { liveStrokes: { ...this.doc.liveStrokes, [l.id]: [] } } : {} }, { kind: "clear", layerId: l.id }));
+    this.commit("Clear layer", this.withPaintEvent({ ...this.doc, layers: _chunkHB4ICNNAcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface: _chunk474IQG74cjs.emptySurface.call(void 0, 4) })), ...this.thickWithout([l.id]), ...this.stickersWithout([l.id]), ..._optionalChain([this, 'access', _278 => _278.doc, 'access', _279 => _279.liveStrokes, 'optionalAccess', _280 => _280[l.id]]) ? { liveStrokes: { ...this.doc.liveStrokes, [l.id]: [] } } : {}, ...this.lightWithout([l.id]) }, { kind: "clear", layerId: l.id }));
     return { layerId: l.id, bounds };
   }
   /**
@@ -4159,8 +4740,8 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   fillLayer(options = {}) {
     this.requireIdle("filling");
     const fillTarget = this.paintTarget(options.layerId, "fill");
-    if (_optionalChain([this, 'access', _224 => _224.doc, 'access', _225 => _225.stickers, 'optionalAccess', _226 => _226[fillTarget.id], 'optionalAccess', _227 => _227.length])) throw new PaintEditorError(`Layer "${fillTarget.name}" is a sticker layer; fill another layer (add_layer).`);
-    if (_optionalChain([this, 'access', _228 => _228.doc, 'access', _229 => _229.liveStrokes, 'optionalAccess', _230 => _230[fillTarget.id]])) throw new PaintEditorError(`Layer "${fillTarget.name}" is a stroke layer (its pixels are drawn from its strokes); fill another layer (add_layer), or rasterize it first (rasterize_stroke_layer).`);
+    if (_optionalChain([this, 'access', _281 => _281.doc, 'access', _282 => _282.stickers, 'optionalAccess', _283 => _283[fillTarget.id], 'optionalAccess', _284 => _284.length])) throw new PaintEditorError(`Layer "${fillTarget.name}" is a sticker layer; fill another layer (add_layer).`);
+    if (_optionalChain([this, 'access', _285 => _285.doc, 'access', _286 => _286.liveStrokes, 'optionalAccess', _287 => _287[fillTarget.id]])) throw new PaintEditorError(`Layer "${fillTarget.name}" is a stroke layer (its pixels are drawn from its strokes); fill another layer (add_layer), or rasterize it first (rasterize_stroke_layer).`);
     this.dryLayersFirst([_nullishCoalesce(_nullishCoalesce(options.layerId, () => ( this.doc.activeLayerId)), () => ( ""))]);
     const l = this.paintTarget(options.layerId, "fill");
     const color = options.color === void 0 ? this.color : parseColor(options.color);
@@ -4193,7 +4774,9 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       offset: l.offset
     };
     const surface = this.applyCoverage(l, coverage, rect, apply);
-    this.commit("Fill layer", this.withPaintEvent(this.withWetEvents({ ...this.doc, layers: _chunkHB4ICNNAcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface })) }), { kind: "fill", layerId: l.id, data: { color, opacity, grain: grainAmount, pressure, blend } }));
+    const lit = _optionalChain([this, 'access', _288 => _288.doc, 'access', _289 => _289.light, 'optionalAccess', _290 => _290[l.id]]);
+    const light = lit ? withLayerLight(this.doc.light, l.id, scaleLight(lit, 1 - opacity)) : void 0;
+    this.commit("Fill layer", this.withPaintEvent(this.withWetEvents({ ...this.doc, layers: _chunkHB4ICNNAcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface })), ...light ? { light } : {} }), { kind: "fill", layerId: l.id, data: { color, opacity, grain: grainAmount, pressure, blend } }));
     return { layerId: l.id, bounds: rect };
   }
   applyCoverage(l, coverage, rect, apply) {
@@ -4201,7 +4784,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const tiles = new Map(base.tiles);
     for (const { tx, ty } of _chunk474IQG74cjs.tilesInRect.call(void 0, { x: rect.x - l.offset.x, y: rect.y - l.offset.y, width: rect.width, height: rect.height })) {
       const key = _chunk474IQG74cjs.tileKey.call(void 0, tx, ty);
-      const src = _nullishCoalesce(_optionalChain([base, 'access', _231 => _231.tiles, 'access', _232 => _232.get, 'call', _233 => _233(key), 'optionalAccess', _234 => _234.data]), () => ( new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * 4)));
+      const src = _nullishCoalesce(_optionalChain([base, 'access', _291 => _291.tiles, 'access', _292 => _292.get, 'call', _293 => _293(key), 'optionalAccess', _294 => _294.data]), () => ( new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * 4)));
       const tile = _chunk474IQG74cjs.finishTile.call(void 0, _chunkPQ3H2AANcjs.applyStrokeToTile.call(void 0, coverage, src, 4, tx, ty, apply), 4, 0);
       if (tile) tiles.set(key, tile);
       else tiles.delete(key);
@@ -4234,7 +4817,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   }
   /** The effect a layer is drawn from, or `undefined` for other layers. */
   getEffectLayer(layerId) {
-    return _chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, layerId) ? _optionalChain([this, 'access', _235 => _235.doc, 'access', _236 => _236.effectLayers, 'optionalAccess', _237 => _237[layerId]]) : void 0;
+    return _chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, layerId) ? _optionalChain([this, 'access', _295 => _295.doc, 'access', _296 => _296.effectLayers, 'optionalAccess', _297 => _297[layerId]]) : void 0;
   }
   /** The effect paper (without its pixels), or `null`. */
   getPaperEffect() {
@@ -4271,8 +4854,8 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   /** A pixel layer that takes effect pixels: unlocked, visible, no sticker layer, no wet paint. */
   effectTarget(layerId, what) {
     const l = this.paintTarget(layerId, what);
-    if (_optionalChain([this, 'access', _238 => _238.doc, 'access', _239 => _239.stickers, 'optionalAccess', _240 => _240[l.id], 'optionalAccess', _241 => _241.length])) throw new PaintEditorError(`Layer "${l.name}" is a sticker layer; ${what} another layer (add_layer).`);
-    if (_optionalChain([this, 'access', _242 => _242.doc, 'access', _243 => _243.liveStrokes, 'optionalAccess', _244 => _244[l.id]])) throw new PaintEditorError(`Layer "${l.name}" is a stroke layer (its pixels are drawn from its strokes); ${what} another layer (add_layer), or rasterize it first (rasterize_stroke_layer).`);
+    if (_optionalChain([this, 'access', _298 => _298.doc, 'access', _299 => _299.stickers, 'optionalAccess', _300 => _300[l.id], 'optionalAccess', _301 => _301.length])) throw new PaintEditorError(`Layer "${l.name}" is a sticker layer; ${what} another layer (add_layer).`);
+    if (_optionalChain([this, 'access', _302 => _302.doc, 'access', _303 => _303.liveStrokes, 'optionalAccess', _304 => _304[l.id]])) throw new PaintEditorError(`Layer "${l.name}" is a stroke layer (its pixels are drawn from its strokes); ${what} another layer (add_layer), or rasterize it first (rasterize_stroke_layer).`);
     if (this.wet.wetLayerIds().includes(l.id)) throw new PaintEditorError(`Layer "${l.name}" holds wet paint; effects go on dried paint, so dry it first (dry_paint) and try again.`);
     return l;
   }
@@ -4311,8 +4894,8 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const was = this.doc.paperEffect;
     const paperEffect = {
       ...this.sourceOf(d, values, options.time),
-      opacity: _nullishCoalesce(_nullishCoalesce(options.opacity, () => ( _optionalChain([was, 'optionalAccess', _245 => _245.opacity]))), () => ( 1)),
-      blend: _nullishCoalesce(_nullishCoalesce(options.blend, () => ( _optionalChain([was, 'optionalAccess', _246 => _246.blend]))), () => ( "multiply")),
+      opacity: _nullishCoalesce(_nullishCoalesce(options.opacity, () => ( _optionalChain([was, 'optionalAccess', _305 => _305.opacity]))), () => ( 1)),
+      blend: _nullishCoalesce(_nullishCoalesce(options.blend, () => ( _optionalChain([was, 'optionalAccess', _306 => _306.blend]))), () => ( "multiply")),
       image: { width: pixels.width, height: pixels.height, data: new Uint8ClampedArray(pixels.data) },
       version: nextPaperEffectVersion()
     };
@@ -4365,8 +4948,8 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const above = _nullishCoalesce(options.aboveId, () => ( this.doc.activeLayerId));
     const loc = above ? _chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, above) : null;
     if (options.aboveId !== void 0 && !loc) throw new PaintEditorError(`Layer "${options.aboveId}" was removed while the effect rendered.`);
-    const layer = { ...createPaintLayer(_optionalChain([options, 'access', _247 => _247.name, 'optionalAccess', _248 => _248.trim, 'call', _249 => _249()]) || d.name), surface: _chunk474IQG74cjs.surfaceFromPixels.call(void 0, pixels, 4), opacity: _nullishCoalesce(options.opacity, () => ( 1)), blend: _nullishCoalesce(options.blend, () => ( "normal")) };
-    const layers = _chunkHB4ICNNAcjs.insertLayer.call(void 0, this.doc.layers, layer, _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _250 => _250.parent, 'optionalAccess', _251 => _251.id]), () => ( null)), loc ? loc.index + 1 : void 0);
+    const layer = { ...createPaintLayer(_optionalChain([options, 'access', _307 => _307.name, 'optionalAccess', _308 => _308.trim, 'call', _309 => _309()]) || d.name), surface: _chunk474IQG74cjs.surfaceFromPixels.call(void 0, pixels, 4), opacity: _nullishCoalesce(options.opacity, () => ( 1)), blend: _nullishCoalesce(options.blend, () => ( "normal")) };
+    const layers = _chunkHB4ICNNAcjs.insertLayer.call(void 0, this.doc.layers, layer, _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _310 => _310.parent, 'optionalAccess', _311 => _311.id]), () => ( null)), loc ? loc.index + 1 : void 0);
     const source = this.sourceOf(d, values, options.time);
     this.commit("Add effect layer", { ...this.doc, layers, activeLayerId: layer.id, effectLayers: { ..._nullishCoalesce(this.doc.effectLayers, () => ( {})), [layer.id]: source } });
     return { layer: this.describeLayer(layer), source };
@@ -4444,7 +5027,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     this.checkTime(source.time);
     let map;
     try {
-      map = _chunk5BR7LC24cjs.readEffectStrokeMap.call(void 0, source.map);
+      map = _chunk4T47Z4J3cjs.readEffectStrokeMap.call(void 0, source.map);
     } catch (e) {
       throw new PaintEditorError(e.message);
     }
@@ -4475,9 +5058,9 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   }
   /** The rendered pixels of an effect paint at the current canvas size, or `null` when it has not been rendered. */
   effectPaintImage(p) {
-    const key = _chunk5BR7LC24cjs.effectPaintKey.call(void 0, p);
+    const key = _chunk4T47Z4J3cjs.effectPaintKey.call(void 0, p);
     const img = this.effectPaintPixels.get(key);
-    const size = _chunk5BR7LC24cjs.effectPaintSize.call(void 0, p, this.doc.canvas);
+    const size = _chunk4T47Z4J3cjs.effectPaintSize.call(void 0, p, this.doc.canvas);
     if (!img || img.width !== size.width || img.height !== size.height) return null;
     this.effectPaintPixels.delete(key);
     this.effectPaintPixels.set(key, img);
@@ -4491,7 +5074,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const what = `the effect "${p.effect}"${p.provider ? ` from provider "${p.provider}"` : ""}`;
     if (!provider) throw new PaintEditorError(`Effect paint needs ${what}, but no effects provider is registered; register it (setEffectsProvider) and try again.`);
     if (p.provider && provider.id !== p.provider) throw new PaintEditorError(`Effect paint needs ${what}, but the registered provider is "${provider.id}"; register "${p.provider}" (setEffectsProvider) and try again.`);
-    const { width, height } = _chunk5BR7LC24cjs.effectPaintSize.call(void 0, p, this.doc.canvas);
+    const { width, height } = _chunk4T47Z4J3cjs.effectPaintSize.call(void 0, p, this.doc.canvas);
     let pixels;
     try {
       pixels = await this.effectsRenderer.render(provider, p.effect, { width, height }, { time: p.time, values: p.values });
@@ -4499,7 +5082,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       throw new PaintEditorError(`Effect paint could not render ${what}: ${e instanceof Error ? e.message : String(e)}`);
     }
     const img = { width, height, data: new Uint8ClampedArray(pixels.data), ...p.map ? { map: p.map } : {} };
-    this.effectPaintPixels.set(_chunk5BR7LC24cjs.effectPaintKey.call(void 0, p), img);
+    this.effectPaintPixels.set(_chunk4T47Z4J3cjs.effectPaintKey.call(void 0, p), img);
     while (this.effectPaintPixels.size > _PaintEditorController.EFFECT_PAINT_CACHE) this.effectPaintPixels.delete(this.effectPaintPixels.keys().next().value);
     return img;
   }
@@ -4510,7 +5093,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   async prepareEffectPaints(paints) {
     const seen = /* @__PURE__ */ new Set();
     for (const p of paints) {
-      const key = _chunk5BR7LC24cjs.effectPaintKey.call(void 0, p);
+      const key = _chunk4T47Z4J3cjs.effectPaintKey.call(void 0, p);
       if (seen.has(key)) continue;
       seen.add(key);
       await this.renderEffectPaint(p);
@@ -4519,7 +5102,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   /** Renders the effect paints of recorded strokes (default all of them) before a replay. */
   async prepareStrokeEffects(strokeIds) {
     const ids = strokeIds ? new Set(strokeIds) : null;
-    const paints = this.doc.strokes.filter((s) => (!ids || ids.has(s.id)) && _optionalChain([s, 'access', _252 => _252.paint, 'optionalAccess', _253 => _253.type]) === "effect").map((s) => s.paint);
+    const paints = this.doc.strokes.filter((s) => (!ids || ids.has(s.id)) && _optionalChain([s, 'access', _312 => _312.paint, 'optionalAccess', _313 => _313.type]) === "effect").map((s) => s.paint);
     await this.prepareEffectPaints(paints);
   }
   /** A small preview of the effect paint (a PNG data URL `size` px wide), or `null` without a rendered one. */
@@ -4548,11 +5131,11 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
    * its pixels are not rendered.
    */
   strokeEffect(init, brush) {
-    if (!_chunk5BR7LC24cjs.brushTakesPaint.call(void 0, brush)) return null;
+    if (!_chunk4T47Z4J3cjs.brushTakesPaint.call(void 0, brush)) return null;
     let source = null;
     if (init.paint !== void 0) {
-      if (!_chunk5BR7LC24cjs.isPaintEffectPaint.call(void 0, init.paint)) return null;
-      source = _chunk5BR7LC24cjs.readPaintEffectPaint.call(void 0, init.paint);
+      if (!_chunk4T47Z4J3cjs.isPaintEffectPaint.call(void 0, init.paint)) return null;
+      source = _chunk4T47Z4J3cjs.readPaintEffectPaint.call(void 0, init.paint);
       if (!source) throw new PaintEditorError("The stroke's effect paint needs an effect id and values (getEffectPaint returns one).");
     } else if (init.color === void 0 && !brush.paint) {
       if (this.effectPaintPending) throw new PaintEditorError(`The effect paint "${this.effectPaintPending.effect}" is still rendering; wait for set_effect_paint to finish, then paint.`);
@@ -4582,14 +5165,14 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const before = _chunk474IQG74cjs.readRegion.call(void 0, l.surface, rect);
     const inputs = { source: { width: rect.width, height: rect.height, data: before } };
     const heightInput = d.inputs.find((i) => i.kind === "image" && /^(height|depth|relief)$/i.test(i.name));
-    const relief = _optionalChain([this, 'access', _254 => _254.doc, 'access', _255 => _255.thick, 'optionalAccess', _256 => _256[l.id]]);
+    const relief = _optionalChain([this, 'access', _314 => _314.doc, 'access', _315 => _315.thick, 'optionalAccess', _316 => _316[l.id]]);
     if (heightInput && relief) {
       const h = _chunk474IQG74cjs.readRegion.call(void 0, relief.height, rect);
       const rgba = new Uint8ClampedArray(rect.width * rect.height * 4);
       for (let i = 0; i < h.length; i++) rgba.set([h[i], h[i], h[i], 255], i * 4);
       inputs[heightInput.name] = { width: rect.width, height: rect.height, data: rgba };
     }
-    const sourceInput = _nullishCoalesce(_optionalChain([d, 'access', _257 => _257.inputs, 'access', _258 => _258.find, 'call', _259 => _259((i) => i.kind === "image" && i.name !== _optionalChain([heightInput, 'optionalAccess', _260 => _260.name])), 'optionalAccess', _261 => _261.name]), () => ( "source"));
+    const sourceInput = _nullishCoalesce(_optionalChain([d, 'access', _317 => _317.inputs, 'access', _318 => _318.find, 'call', _319 => _319((i) => i.kind === "image" && i.name !== _optionalChain([heightInput, 'optionalAccess', _320 => _320.name])), 'optionalAccess', _321 => _321.name]), () => ( "source"));
     if (sourceInput !== "source") {
       inputs[sourceInput] = inputs.source;
       delete inputs.source;
@@ -4602,12 +5185,12 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   }
   // --- Brushes -------------------------------------------------------------------
   findBrush(id) {
-    return _nullishCoalesce(_chunk5BR7LC24cjs.BUILTIN_BRUSHES.find((b) => b.id === id), () => ( this.userBrushes.find((b) => b.id === id)));
+    return _nullishCoalesce(_chunk4T47Z4J3cjs.BUILTIN_BRUSHES.find((b) => b.id === id), () => ( this.userBrushes.find((b) => b.id === id)));
   }
   /** A library brush by id (`undefined` when unknown). */
   getBrush(id) {
     const b = this.findBrush(id);
-    return b ? _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, b, b) : void 0;
+    return b ? _chunk4T47Z4J3cjs.normalizePaintBrush.call(void 0, b, b) : void 0;
   }
   requireBrush(id) {
     const b = this.findBrush(id);
@@ -4622,7 +5205,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const { id, ...changes } = update;
     const base = id !== void 0 ? this.requireBrush(id) : this.brush;
     if (changes.paint !== void 0 && changes.paint !== null) this.readStrokePaint(changes.paint);
-    const next = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { ...changes, id: base.id }, base);
+    const next = _chunk4T47Z4J3cjs.normalizePaintBrush.call(void 0, { ...changes, id: base.id }, base);
     if (base.builtin && !Object.keys(changes).length) next.builtin = true;
     else delete next.builtin;
     this.brush = next;
@@ -4631,10 +5214,10 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   }
   /** Saves the active brush (or `brush`) into the user library under `id` / `name`. */
   saveBrush(options) {
-    if (!_chunk5BR7LC24cjs.BRUSH_ID.test(options.id)) throw new PaintEditorError(`Brush id "${options.id}" is invalid; use lowercase letters, digits and dashes (e.g. "my-pencil").`);
-    if (_chunk5BR7LC24cjs.BUILTIN_BRUSHES.some((b) => b.id === options.id)) throw new PaintEditorError(`"${options.id}" is a built-in brush; save under another id.`);
-    const source = options.brush ? _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, options.brush, this.brush) : this.brush;
-    const saved = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { ...source, id: options.id, name: _nullishCoalesce(options.name, () => ( source.name)) });
+    if (!_chunk4T47Z4J3cjs.BRUSH_ID.test(options.id)) throw new PaintEditorError(`Brush id "${options.id}" is invalid; use lowercase letters, digits and dashes (e.g. "my-pencil").`);
+    if (_chunk4T47Z4J3cjs.BUILTIN_BRUSHES.some((b) => b.id === options.id)) throw new PaintEditorError(`"${options.id}" is a built-in brush; save under another id.`);
+    const source = options.brush ? _chunk4T47Z4J3cjs.normalizePaintBrush.call(void 0, options.brush, this.brush) : this.brush;
+    const saved = _chunk4T47Z4J3cjs.normalizePaintBrush.call(void 0, { ...source, id: options.id, name: _nullishCoalesce(options.name, () => ( source.name)) });
     delete saved.builtin;
     const i = this.userBrushes.findIndex((b) => b.id === options.id);
     if (i >= 0) this.userBrushes[i] = saved;
@@ -4644,7 +5227,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     return saved;
   }
   removeBrush(id) {
-    if (_chunk5BR7LC24cjs.BUILTIN_BRUSHES.some((b) => b.id === id)) throw new PaintEditorError(`"${id}" is a built-in brush and cannot be removed.`);
+    if (_chunk4T47Z4J3cjs.BUILTIN_BRUSHES.some((b) => b.id === id)) throw new PaintEditorError(`"${id}" is a built-in brush and cannot be removed.`);
     const i = this.userBrushes.findIndex((b) => b.id === id);
     if (i < 0) throw new PaintEditorError(`Unknown brush "${id}". Call list_brushes for the ids.`);
     this.userBrushes.splice(i, 1);
@@ -4653,12 +5236,12 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   }
   /** The user's saved brushes. */
   getUserBrushes() {
-    return this.userBrushes.map((b) => _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, b, b));
+    return this.userBrushes.map((b) => _chunk4T47Z4J3cjs.normalizePaintBrush.call(void 0, b, b));
   }
   /** A brush library file of the given brushes (default: the user's brushes). */
   exportBrushes(ids) {
     const list = ids ? ids.map((id) => this.requireBrush(id)) : this.userBrushes;
-    return { format: "pixerate-brushes", version: 1, brushes: list.map(_chunk5BR7LC24cjs.brushToJSON) };
+    return { format: "pixerate-brushes", version: 1, brushes: list.map(_chunk4T47Z4J3cjs.brushToJSON) };
   }
   /**
    * Adds the brushes of a library file to the user library. A brush whose id is taken is skipped
@@ -4668,14 +5251,14 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const problems = [];
     let list;
     try {
-      list = _chunk5BR7LC24cjs.parseBrushLibrary.call(void 0, file, problems);
+      list = _chunk4T47Z4J3cjs.parseBrushLibrary.call(void 0, file, problems);
     } catch (e) {
       throw new PaintEditorError(e.message);
     }
     const added = [];
     const skipped = [];
     for (const b of list) {
-      if (_chunk5BR7LC24cjs.BUILTIN_BRUSHES.some((x) => x.id === b.id)) {
+      if (_chunk4T47Z4J3cjs.BUILTIN_BRUSHES.some((x) => x.id === b.id)) {
         skipped.push(b.id);
         problems.push(`"${b.id}" is a built-in brush id; rename it to import it.`);
         continue;
@@ -4740,10 +5323,10 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
    * brush's gradient, else the editor's gradient paint. Erasers, blenders and smudges take none.
    */
   strokeGradient(init, brush, color) {
-    if (!_chunk5BR7LC24cjs.brushTakesPaint.call(void 0, brush)) return null;
+    if (!_chunk4T47Z4J3cjs.brushTakesPaint.call(void 0, brush)) return null;
     let g = null;
     if (init.paint !== void 0) {
-      if (_chunk5BR7LC24cjs.isPaintEffectPaint.call(void 0, init.paint)) return null;
+      if (_chunk4T47Z4J3cjs.isPaintEffectPaint.call(void 0, init.paint)) return null;
       const p = this.readStrokePaint(init.paint);
       g = p.type === "gradient" ? p : null;
     } else g = _nullishCoalesce(brush.paint, () => ( (init.color === void 0 ? this.gradient : null)));
@@ -4787,7 +5370,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   // --- Mixer Brush ---------------------------------------------------------------
   /** Fills the Mixer Brush reservoir with a colour (default the editor colour). */
   loadMixerBrush(color) {
-    const [r, g, b] = _chunk5BR7LC24cjs.hexToRgb8.call(void 0, color === void 0 ? this.color : parseColor(color));
+    const [r, g, b] = _chunk4T47Z4J3cjs.hexToRgb8.call(void 0, color === void 0 ? this.color : parseColor(color));
     this.mixerLoad = _chunkPQ3H2AANcjs.loadMixer.call(void 0, this.mixerLoad, [r / 255, g / 255, b / 255]);
     this.emit([]);
     return this.mixerLoad;
@@ -4817,7 +5400,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   // --- Strokes -------------------------------------------------------------------
   strokeBrush(init) {
     let brush = init.brushId !== void 0 ? this.requireBrush(init.brushId) : this.brush;
-    if (init.brush) brush = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { ...init.brush, id: brush.id }, brush);
+    if (init.brush) brush = _chunk4T47Z4J3cjs.normalizePaintBrush.call(void 0, { ...init.brush, id: brush.id }, brush);
     return brush;
   }
   /**
@@ -4833,7 +5416,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     return symmetryCopies(this.guides.symmetry);
   }
   sessionFor(doc, init, host) {
-    if (init.paint !== void 0 && !_chunk5BR7LC24cjs.isPaintEffectPaint.call(void 0, init.paint)) {
+    if (init.paint !== void 0 && !_chunk4T47Z4J3cjs.isPaintEffectPaint.call(void 0, init.paint)) {
       const p = this.readStrokePaint(init.paint);
       if (p.type === "color") init = { ...init, color: p.color, paint: void 0 };
       else init = { ...init, paint: p };
@@ -4851,25 +5434,28 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     })();
     const brush = this.strokeBrush(init);
     const effect = this.strokeEffect(init, brush);
-    if (_optionalChain([doc, 'access', _262 => _262.liveStrokes, 'optionalAccess', _263 => _263[layer.id]])) {
+    if (brush.light.amount > 0) {
+      if (brush.engine === "sticker") throw new PaintEditorError(`The ${brush.name} brush sprays stickers, which don't take light yet; paint light with a dab or particle light brush (list_brushes category light), or set light.amount to 0 (set_brush).`);
+    }
+    if (_optionalChain([doc, 'access', _322 => _322.liveStrokes, 'optionalAccess', _323 => _323[layer.id]])) {
       const why = liveStrokeRefusal(brush);
       if (why) throw new PaintEditorError(`Layer "${layer.name}" is a stroke layer. ${why}`);
     }
-    if (_optionalChain([doc, 'access', _264 => _264.liveStrokes, 'optionalAccess', _265 => _265[layer.id]]) && _optionalChain([effect, 'optionalAccess', _266 => _266.source, 'access', _267 => _267.live])) {
-      const key = _chunk5BR7LC24cjs.effectPaintKey.call(void 0, effect.source);
+    if (_optionalChain([doc, 'access', _324 => _324.liveStrokes, 'optionalAccess', _325 => _325[layer.id]]) && _optionalChain([effect, 'optionalAccess', _326 => _326.source, 'access', _327 => _327.live])) {
+      const key = _chunk4T47Z4J3cjs.effectPaintKey.call(void 0, effect.source);
       const { sources } = this.liveEffects(doc);
-      if (!sources.some((p) => _chunk5BR7LC24cjs.effectPaintKey.call(void 0, p) === key) && sources.length >= MAX_LIVE_EFFECT_SOURCES) {
+      if (!sources.some((p) => _chunk4T47Z4J3cjs.effectPaintKey.call(void 0, p) === key) && sources.length >= MAX_LIVE_EFFECT_SOURCES) {
         throw new PaintEditorError(`The painting already plays ${MAX_LIVE_EFFECT_SOURCES} live effects, the most it can; paint with one of them, or set_effect_paint with live false to bake this one.`);
       }
     }
-    const stickerLayer = Boolean(_optionalChain([doc, 'access', _268 => _268.stickers, 'optionalAccess', _269 => _269[layer.id], 'optionalAccess', _270 => _270.length]));
+    const stickerLayer = Boolean(_optionalChain([doc, 'access', _328 => _328.stickers, 'optionalAccess', _329 => _329[layer.id], 'optionalAccess', _330 => _330.length]));
     if (brush.engine === "sticker") {
       if (!stickerLayer && _chunk474IQG74cjs.contentBounds.call(void 0, layer.surface)) throw new PaintEditorError(`Layer "${layer.name}" already has paint; spray stickers onto an empty layer (add_layer) so they stay editable.`);
     } else if (stickerLayer) {
       throw new PaintEditorError(`Layer "${layer.name}" is a sticker layer (its pixels are drawn from its stickers); paint on another layer (add_layer).`);
     }
     let wet;
-    if (_chunk5BR7LC24cjs.isWetBrush.call(void 0, brush)) {
+    if (_chunk4T47Z4J3cjs.isWetBrush.call(void 0, brush)) {
       this.requireWetIdle("painting");
       if (layer.offset.x || layer.offset.y) {
         const moved = { ...layer, surface: _chunk474IQG74cjs.translateSurface.call(void 0, layer.surface, layer.offset.x, layer.offset.y), offset: { x: 0, y: 0 } };
@@ -4877,14 +5463,14 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
         if (doc !== this.doc) doc = { ...doc, layers: _chunkHB4ICNNAcjs.mapLayer.call(void 0, doc.layers, layer.id, () => moved) };
         layer = moved;
       }
-      if (!this.wet.wetLayerIds().includes(layer.id) && this.wet.wetLayerIds().length >= _chunkXFYLA3ZOcjs.MAX_WET_LANES) {
-        throw new PaintEditorError(`At most ${_chunkXFYLA3ZOcjs.MAX_WET_LANES} layers can hold wet paint at once; dry one first (dry_paint).`);
+      if (!this.wet.wetLayerIds().includes(layer.id) && this.wet.wetLayerIds().length >= _chunkVMROIWLLcjs.MAX_WET_LANES) {
+        throw new PaintEditorError(`At most ${_chunkVMROIWLLcjs.MAX_WET_LANES} layers can hold wet paint at once; dry one first (dry_paint).`);
       }
       this.beginWetOp();
       const world = this.wet.ensureLane(layer.id, brush.wet.medium);
       const id = layer.id;
       const wetColor = init.color === void 0 ? this.color : parseColor(init.color);
-      const [r, g, b] = _chunk5BR7LC24cjs.hexToRgb8.call(void 0, wetColor);
+      const [r, g, b] = _chunk4T47Z4J3cjs.hexToRgb8.call(void 0, wetColor);
       const wetGradient = this.strokeGradient(init, brush, wetColor);
       const load = _nullishCoalesce(init.load, () => ( brushLoadForStroke(brush, this.mixerLoad, [r / 255, g / 255, b / 255])));
       const seedW = _nullishCoalesce(init.seed, () => ( _chunkPQ3H2AANcjs.mix32.call(void 0, this.seedCounter * 2654435761 >>> 0) & 2147483647));
@@ -4897,12 +5483,12 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
         load,
         grain: paperGrain(doc.paper),
         paperDepth: doc.paper.depth,
-        paperColor: _chunk5BR7LC24cjs.hexToRgb8.call(void 0, doc.paper.color),
+        paperColor: _chunk4T47Z4J3cjs.hexToRgb8.call(void 0, doc.paper.color),
         seed: seedW,
         copies: [IDENTITY_AFFINE, ...copiesW].map(affineCopy),
         mask: init.maskStencils ? this.stencilSelection(init.maskStencils) : init.stencils !== false ? this.stencilSelection() : null,
         paint: effect ? null : wetGradient,
-        effect: _nullishCoalesce(_optionalChain([effect, 'optionalAccess', _271 => _271.pixels]), () => ( null))
+        effect: _nullishCoalesce(_optionalChain([effect, 'optionalAccess', _331 => _331.pixels]), () => ( null))
       });
       init = { ...init, seed: seedW, load };
       wet = { driver, surface: () => world.display(id).surface };
@@ -4913,7 +5499,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     }
     let color = init.color === void 0 ? this.color : parseColor(init.color);
     const tracing = this.guides.tracing;
-    if (init.color === void 0 && init.start && _optionalChain([tracing, 'optionalAccess', _272 => _272.visible]) && tracing.sampleColors) color = _nullishCoalesce(this.sampleTracingColor(init.start.x, init.start.y), () => ( color));
+    if (init.color === void 0 && init.start && _optionalChain([tracing, 'optionalAccess', _332 => _332.visible]) && tracing.sampleColors) color = _nullishCoalesce(this.sampleTracingColor(init.start.x, init.start.y), () => ( color));
     const perspective = this.guides.perspective;
     const snapper = init.snapToPerspective && perspective.enabled && perspective.snap ? new PerspectiveSnapper(perspective) : null;
     const useStencils = init.stencils !== false;
@@ -4946,7 +5532,9 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       mixerLoad: _nullishCoalesce(init.load, () => ( brushLoadForStroke(brush, this.mixerLoad, [rgba[0] / 255, rgba[1] / 255, rgba[2] / 255]))),
       secondary: rgbaOf(this.secondaryColor),
       wet,
-      thick: brush.engine === "impasto" ? { channels: _nullishCoalesce(_optionalChain([doc, 'access', _273 => _273.thick, 'optionalAccess', _274 => _274[layer.id]]), () => ( emptyThickChannels())) } : void 0,
+      thick: brush.engine === "impasto" ? { channels: _nullishCoalesce(_optionalChain([doc, 'access', _333 => _333.thick, 'optionalAccess', _334 => _334[layer.id]]), () => ( emptyThickChannels())) } : void 0,
+      // Light paint: a twin of the stroke paints the light channel (laying, dimming, moving light).
+      light: !wet && brush.engine !== "sticker" && (brush.light.amount > 0 || _optionalChain([doc, 'access', _335 => _335.light, 'optionalAccess', _336 => _336[layer.id]])) ? { surface: _nullishCoalesce(_optionalChain([doc, 'access', _337 => _337.light, 'optionalAccess', _338 => _338[layer.id]]), () => ( emptyLight())) } : null,
       sticker: brush.engine === "sticker" ? { nextId: this.nextStickerNumber(doc) } : void 0,
       paint: effect ? null : this.strokeGradient(init, brush, color),
       effect
@@ -4960,7 +5548,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const stroke = {
       id: `s${this.strokeCounter++}`,
       layerId: session.layerId,
-      brush: _chunk5BR7LC24cjs.brushToJSON.call(void 0, init.brush),
+      brush: _chunk4T47Z4J3cjs.brushToJSON.call(void 0, init.brush),
       color: init.colorHex,
       points: session.points.map((p) => ({ ...p })),
       seed: init.seed
@@ -4985,12 +5573,12 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const before = this.doc;
     const host = {
       update: (layerId, surface, rects) => {
-        if (_optionalChain([this, 'access', _275 => _275.session, 'optionalAccess', _276 => _276.init, 'access', _277 => _277.wet])) {
+        if (_optionalChain([this, 'access', _339 => _339.session, 'optionalAccess', _340 => _340.init, 'access', _341 => _341.wet])) {
           this.wet.syncDisplays();
           return;
         }
         this.live = { layerId, surface };
-        const ch = _optionalChain([this, 'access', _278 => _278.session, 'optionalAccess', _279 => _279.thickChannels, 'call', _280 => _280()]);
+        const ch = _optionalChain([this, 'access', _342 => _342.session, 'optionalAccess', _343 => _343.thickChannels, 'call', _344 => _344()]);
         this.liveThick = ch ? { layerId, channels: ch } : null;
         this.emit(rects);
       },
@@ -5002,7 +5590,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
         const wetStroke = Boolean(s.init.wet);
         if (wetStroke) this.wet.driver = null;
         const brush = s.init.brush;
-        if (!cancelled && _optionalChain([s, 'access', _281 => _281.result, 'optionalAccess', _282 => _282.mixerLoad])) this.keepLoad(brush, s.result.mixerLoad);
+        if (!cancelled && _optionalChain([s, 'access', _345 => _345.result, 'optionalAccess', _346 => _346.mixerLoad])) this.keepLoad(brush, s.result.mixerLoad);
         if (cancelled || !surface) {
           if (this.wetOp) {
             const snap = this.wetOp.before;
@@ -5017,7 +5605,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
         }
         const stroke = this.record(s);
         s.result.strokeId = stroke.id;
-        this.paintedBounds.set(stroke, _nullishCoalesce(_optionalChain([s, 'access', _283 => _283.result, 'optionalAccess', _284 => _284.bounds]), () => ( null)));
+        this.paintedBounds.set(stroke, _nullishCoalesce(_optionalChain([s, 'access', _347 => _347.result, 'optionalAccess', _348 => _348.bounds]), () => ( null)));
         if (wetStroke && this.wet.instantDry) {
           this.wet.dry(s.layerId);
           this.logWet({ kind: "dry", layerId: s.layerId, at: this.doc.strokes.length + 1 });
@@ -5028,8 +5616,10 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
         const ch = s.thickChannels();
         const thick = ch ? { ..._nullishCoalesce(this.doc.thick, () => ( {})), [l.id]: ch } : this.doc.thick;
         const sprayed = s.stickers();
-        const stickers = sprayed ? { ..._nullishCoalesce(this.doc.stickers, () => ( {})), [l.id]: [..._nullishCoalesce(_optionalChain([this, 'access', _285 => _285.doc, 'access', _286 => _286.stickers, 'optionalAccess', _287 => _287[l.id]]), () => ( [])), ...sprayed] } : this.doc.stickers;
-        this.commit(`${brush.name} stroke`, this.withWetEvents(withLiveStroke({ ...this.doc, layers: _chunkHB4ICNNAcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface })), strokes: [...this.doc.strokes, stroke], ...thick ? { thick } : {}, ...stickers ? { stickers } : {} }, stroke)), wetStroke ? before : this.doc);
+        const stickers = sprayed ? { ..._nullishCoalesce(this.doc.stickers, () => ( {})), [l.id]: [..._nullishCoalesce(_optionalChain([this, 'access', _349 => _349.doc, 'access', _350 => _350.stickers, 'optionalAccess', _351 => _351[l.id]]), () => ( [])), ...sprayed] } : this.doc.stickers;
+        const wetLight = wetStroke && _optionalChain([this, 'access', _352 => _352.wet, 'access', _353 => _353.world, 'optionalAccess', _354 => _354.hasLane, 'call', _355 => _355(l.id)]) ? this.wet.world.lightDisplay(l.id) : null;
+        const light = withLayerLight(this.doc.light, l.id, _nullishCoalesce(s.lightChannel(), () => ( wetLight)));
+        this.commit(`${brush.name} stroke`, this.withWetEvents(withLiveStroke({ ...this.doc, layers: _chunkHB4ICNNAcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface })), strokes: [...this.doc.strokes, stroke], ...thick ? { thick } : {}, ...stickers ? { stickers } : {}, ...light ? { light } : {} }, stroke)), wetStroke ? before : this.doc);
       }
     };
     let session;
@@ -5057,17 +5647,19 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
         if (cancelled || !surface) return;
         const stroke = this.record(s);
         s.result.strokeId = stroke.id;
-        this.paintedBounds.set(stroke, _nullishCoalesce(_optionalChain([s, 'access', _288 => _288.result, 'optionalAccess', _289 => _289.bounds]), () => ( null)));
+        this.paintedBounds.set(stroke, _nullishCoalesce(_optionalChain([s, 'access', _356 => _356.result, 'optionalAccess', _357 => _357.bounds]), () => ( null)));
         const l = _chunkHB4ICNNAcjs.findLayer.call(void 0, out.layers, s.layerId).layer;
         const offset = s.init.wet ? { x: 0, y: 0 } : l.offset;
         const ch = s.thickChannels();
         const sprayed = s.stickers();
+        const lit = _nullishCoalesce(s.lightChannel(), () => ( (s.init.wet && _optionalChain([this, 'access', _358 => _358.wet, 'access', _359 => _359.world, 'optionalAccess', _360 => _360.hasLane, 'call', _361 => _361(l.id)]) ? this.wet.world.lightDisplay(l.id) : null)));
         out = withLiveStroke({
           ...out,
           layers: _chunkHB4ICNNAcjs.mapLayer.call(void 0, out.layers, l.id, () => ({ ...l, surface, offset })),
           strokes: [...out.strokes, stroke],
           ...ch ? { thick: { ..._nullishCoalesce(out.thick, () => ( {})), [l.id]: ch } } : {},
-          ...sprayed ? { stickers: { ..._nullishCoalesce(out.stickers, () => ( {})), [l.id]: [..._nullishCoalesce(_optionalChain([out, 'access', _290 => _290.stickers, 'optionalAccess', _291 => _291[l.id]]), () => ( [])), ...sprayed] } } : {}
+          ...sprayed ? { stickers: { ..._nullishCoalesce(out.stickers, () => ( {})), [l.id]: [..._nullishCoalesce(_optionalChain([out, 'access', _362 => _362.stickers, 'optionalAccess', _363 => _363[l.id]]), () => ( [])), ...sprayed] } } : {},
+          ...lit ? { light: withLayerLight(out.light, l.id, lit) } : {}
         }, stroke);
       }
     };
@@ -5125,7 +5717,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
    */
   replayStrokes(options) {
     this.requireIdle("replaying");
-    if (!_optionalChain([options, 'access', _292 => _292.strokeIds, 'optionalAccess', _293 => _293.length])) throw new PaintEditorError("strokeIds is empty; pass ids from list_strokes.");
+    if (!_optionalChain([options, 'access', _364 => _364.strokeIds, 'optionalAccess', _365 => _365.length])) throw new PaintEditorError("strokeIds is empty; pass ids from list_strokes.");
     const strokes = options.strokeIds.map((id) => {
       const s = this.doc.strokes.find((x) => x.id === id);
       if (!s) throw new PaintEditorError(`Unknown stroke "${id}". Call list_strokes for the ids.`);
@@ -5139,7 +5731,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     if (options.layerId !== void 0) this.paintTarget(options.layerId, "replay onto");
     if (options.color === void 0) {
       for (const s of strokes) {
-        if (_optionalChain([s, 'access', _294 => _294.paint, 'optionalAccess', _295 => _295.type]) === "effect" && !this.effectPaintImage(s.paint)) {
+        if (_optionalChain([s, 'access', _366 => _366.paint, 'optionalAccess', _367 => _367.type]) === "effect" && !this.effectPaintImage(s.paint)) {
           throw new PaintEditorError(`Stroke "${s.id}" paints with the effect "${s.paint.effect}"${s.paint.provider ? ` from provider "${s.paint.provider}"` : ""}, which is not rendered in this editor; render it first (prepareStrokeEffects; the replay_strokes tool does this) or recolour the replay with color.`);
         }
       }
@@ -5162,13 +5754,13 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
         let brush = v.brush;
         if (options.brushId !== void 0) {
           const b = this.requireBrush(options.brushId);
-          brush = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { tip: { ...b.tip, size: b.tip.size * (v.brush.tip.size / s.brush.tip.size) } }, b);
+          brush = _chunk4T47Z4J3cjs.normalizePaintBrush.call(void 0, { tip: { ...b.tip, size: b.tip.size * (v.brush.tip.size / s.brush.tip.size) } }, b);
         }
         const layerId = _nullishCoalesce(options.layerId, () => ( s.layerId));
         if (!_chunkHB4ICNNAcjs.findLayer.call(void 0, doc.layers, layerId)) throw new PaintEditorError(`Stroke "${s.id}" was painted on layer "${layerId}", which no longer exists; pass layerId to replay it elsewhere.`);
         let load = s.load;
         if (load && options.color !== void 0 && load.reservoir) {
-          const [r, g, b] = _chunk5BR7LC24cjs.hexToRgb8.call(void 0, options.color);
+          const [r, g, b] = _chunk4T47Z4J3cjs.hexToRgb8.call(void 0, options.color);
           load = { ...load, reservoir: [r / 255, g / 255, b / 255] };
         }
         const paint = v.paint && options.color === void 0 ? { paint: v.paint } : {};
@@ -5182,6 +5774,46 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     if (doc !== this.doc) this.commit(strokes.length === 1 && repeat === 1 ? "Replay stroke" : "Replay strokes", doc);
     return { strokeIds: ids, bounds, layerIds: [...layerIds] };
   }
+  // --- Light paint --------------------------------------------------------------------
+  /** The document's `light` without these layers (as a spread: `{}` when unchanged). */
+  lightWithout(ids) {
+    const t = this.doc.light;
+    if (!t || !ids.some((id) => t[id])) return {};
+    const out = { ...t };
+    for (const id of ids) delete out[id];
+    return { light: out };
+  }
+  lightSpillOf(layerId) {
+    return _nullishCoalesce(this.lightSpills[layerId], () => ( DEFAULT_LIGHT_SPILL));
+  }
+  /** A layer's light paint: whether it has any, where (document pixels), its brightest value 0..255, and its spill. */
+  lightOf(layerId) {
+    const l = this.wetLayer(layerId, "read the light of");
+    const info = lightInfo(_optionalChain([this, 'access', _368 => _368.doc, 'access', _369 => _369.light, 'optionalAccess', _370 => _370[l.id]]));
+    const bounds = info.bounds ? { ...info.bounds, x: info.bounds.x + l.offset.x, y: info.bounds.y + l.offset.y } : null;
+    return { layerId: l.id, hasLight: info.peak > 0, bounds, peak: info.peak, spill: { ...this.lightSpillOf(l.id) } };
+  }
+  /** How far a layer's light spills (px; 0 turns it off) and how strongly (0..2). Saved with the document, not an undo step; nothing is repainted. */
+  setLightSpill(layerId, update) {
+    const l = this.wetLayer(layerId, "set the light spill of");
+    try {
+      this.lightSpills[l.id] = normalizeLightSpill(update, this.lightSpillOf(l.id));
+    } catch (e) {
+      throw new PaintEditorError(e.message);
+    }
+    this.emit("all");
+    return { ...this.lightSpills[l.id] };
+  }
+  /** Takes a layer's light away; its paint keeps its colour. One undo step. Returns whether there was any. */
+  clearLight(layerId) {
+    this.requireIdle("clearing light");
+    const l = this.paintTarget(layerId, "clear the light of");
+    if (this.wet.bakedLight(l.id)) this.dryLayersFirst([l.id]);
+    const t = this.lightWithout([l.id]);
+    if (!t.light) return { layerId: l.id, cleared: false };
+    this.commit("Clear light", { ...this.doc, light: t.light });
+    return { layerId: l.id, cleared: true };
+  }
   // --- Thick paint and light -------------------------------------------------------
   /** The document's `thick` without these layers (as a spread: `{}` when unchanged). */
   thickWithout(ids) {
@@ -5208,7 +5840,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const id = _nullishCoalesce(layerId, () => ( this.doc.activeLayerId));
     if (!id) return null;
     this.requireLayer(id);
-    const ch = _optionalChain([this, 'access', _296 => _296.doc, 'access', _297 => _297.thick, 'optionalAccess', _298 => _298[id]]);
+    const ch = _optionalChain([this, 'access', _371 => _371.doc, 'access', _372 => _372.thick, 'optionalAccess', _373 => _373[id]]);
     if (!ch) return null;
     const r = reliefInfo(ch);
     return { layerId: id, bounds: r.bounds, maxHeight: r.maxHeight };
@@ -5316,7 +5948,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   wetState() {
     const st = this.getState().wet;
     const backend = this.wet.backend();
-    return { ...st, layers: this.wet.wetLayerIds().map((id) => this.wet.info(id)), backend, message: _nullishCoalesce(_optionalChain([backend, 'optionalAccess', _299 => _299.message]), () => ( _chunkXFYLA3ZOcjs.wetSupport.call(void 0, ).message)), engine: this.wet.engineInfo() };
+    return { ...st, layers: this.wet.wetLayerIds().map((id) => this.wet.info(id)), backend, message: _nullishCoalesce(_optionalChain([backend, 'optionalAccess', _374 => _374.message]), () => ( _chunkVMROIWLLcjs.wetSupport.call(void 0, ).message)), engine: this.wet.engineInfo() };
   }
   /**
    * Engine B, the WebGPU accelerator for large wet areas: whether it may run, its state (`off`,
@@ -5389,7 +6021,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const amount = _nullishCoalesce(options.amount, () => ( 1));
     if (!(amount > 0 && amount <= 1)) throw new PaintEditorError(`amount ${amount} is out of range; use above 0 up to 1.`);
     const rect = _nullishCoalesce(this.checkRect(options.rect), () => ( { x: 0, y: 0, width: this.doc.canvas.width, height: this.doc.canvas.height }));
-    if (!this.wet.wetLayerIds().includes(l.id) && this.wet.wetLayerIds().length >= _chunkXFYLA3ZOcjs.MAX_WET_LANES) throw new PaintEditorError(`At most ${_chunkXFYLA3ZOcjs.MAX_WET_LANES} layers can hold wet paint at once; dry one first (dry_paint).`);
+    if (!this.wet.wetLayerIds().includes(l.id) && this.wet.wetLayerIds().length >= _chunkVMROIWLLcjs.MAX_WET_LANES) throw new PaintEditorError(`At most ${_chunkVMROIWLLcjs.MAX_WET_LANES} layers can hold wet paint at once; dry one first (dry_paint).`);
     const before = this.doc;
     this.beginWetOp();
     const world = this.wet.ensureLane(l.id);
@@ -5401,7 +6033,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   }
   /** Records a settings change as a wet event (not an undo step). */
   recordWetSetting(e) {
-    this.doc = { ...this.doc, wetEvents: [..._nullishCoalesce(this.doc.wetEvents, () => ( [])), { clock: _nullishCoalesce(_optionalChain([this, 'access', _300 => _300.wet, 'access', _301 => _301.world, 'optionalAccess', _302 => _302.clock]), () => ( 0)), at: this.doc.strokes.length, ...e }] };
+    this.doc = { ...this.doc, wetEvents: [..._nullishCoalesce(this.doc.wetEvents, () => ( [])), { clock: _nullishCoalesce(_optionalChain([this, 'access', _375 => _375.wet, 'access', _376 => _376.world, 'optionalAccess', _377 => _377.clock]), () => ( 0)), at: this.doc.strokes.length, ...e }] };
   }
   /** Changes a layer's wet settings (viscosity, evaporation, granulation…). Editor settings saved with the document, not an undo step. */
   setWetParams(layerId, update) {
@@ -5470,7 +6102,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     if (override) return Array.from(override).reduce((ls, [id, surface]) => _chunkHB4ICNNAcjs.mapLayer.call(void 0, ls, id, (l) => ({ ...l, surface })), this.doc.layers);
     const live = this.live;
     if (!live) return this.animatedView();
-    if (_optionalChain([this, 'access', _303 => _303.liveLayers, 'optionalAccess', _304 => _304.key]) === live.surface) return this.liveLayers.layers;
+    if (_optionalChain([this, 'access', _378 => _378.liveLayers, 'optionalAccess', _379 => _379.key]) === live.surface) return this.liveLayers.layers;
     const layers = _chunkHB4ICNNAcjs.mapLayer.call(void 0, this.doc.layers, live.layerId, (l) => ({ ...l, surface: live.surface }));
     this.liveLayers = { key: live.surface, layers };
     return layers;
@@ -5493,7 +6125,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   tracingNode(t) {
     const { width, height } = this.doc.canvas;
     const key = this.tracingVersion * 100003 + width * 7 + height;
-    if (_optionalChain([this, 'access', _305 => _305.tracingCache, 'optionalAccess', _306 => _306.key]) === key && this.tracingCache.node.opacity === t.opacity) return this.tracingCache.node;
+    if (_optionalChain([this, 'access', _380 => _380.tracingCache, 'optionalAccess', _381 => _381.key]) === key && this.tracingCache.node.opacity === t.opacity) return this.tracingCache.node;
     const src = _nullishCoalesce(this.imagePixels.get(t.src), () => ( this.decodeImage(t.src)));
     const image = resampleInto(src, t.rect, width, height);
     const node = { type: "image", id: TRACING_NODE_ID, name: "Tracing", visible: true, opacity: t.opacity, blend: "normal", image, version: key + Math.round(t.opacity * 1e3) / 1e4 };
@@ -5520,8 +6152,8 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     let out = layers;
     const ids = /* @__PURE__ */ new Set([...Object.keys(_nullishCoalesce(thick, () => ( {}))), ...live ? [live.layerId] : []]);
     for (const id of ids) {
-      const ch = _optionalChain([live, 'optionalAccess', _307 => _307.layerId]) === id ? live.channels : _optionalChain([thick, 'optionalAccess', _308 => _308[id]]);
-      const l = ch && _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, out, id), 'optionalAccess', _309 => _309.layer]);
+      const ch = _optionalChain([live, 'optionalAccess', _382 => _382.layerId]) === id ? live.channels : _optionalChain([thick, 'optionalAccess', _383 => _383[id]]);
+      const l = ch && _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, out, id), 'optionalAccess', _384 => _384.layer]);
       if (!ch || !isPixelLayer(l)) continue;
       let cache = this.litCaches.get(id);
       if (!cache) this.litCaches.set(id, cache = new LitCache());
@@ -5530,11 +6162,65 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     }
     return out;
   }
+  /**
+   * Light paint over the (lit) layers: glow, rim and clarity in each layer's pixels, and its spill
+   * as a Linear Dodge (Add) layer directly above it (from the painting as committed, so a stroke in
+   * progress does not redraw the blur every frame).
+   */
+  lightLayers(layers) {
+    const light = _nullishCoalesce(this.doc.light, () => ( {}));
+    const ids = /* @__PURE__ */ new Set([...Object.keys(light), ...Object.keys(_nullishCoalesce(this.doc.thick, () => ( {})))]);
+    if (!ids.size) return layers;
+    let out = layers;
+    for (const id of ids) {
+      const l = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, out, id), 'optionalAccess', _385 => _385.layer]);
+      if (!isPixelLayer(l)) continue;
+      let cache = this.lightCaches.get(id);
+      if (!cache) this.lightCaches.set(id, cache = new LightCache());
+      const glowed = cache.glow(l.surface, light[id], _optionalChain([this, 'access', _386 => _386.liveThick, 'optionalAccess', _387 => _387.layerId]) === id ? this.liveThick.channels : _optionalChain([this, 'access', _388 => _388.doc, 'access', _389 => _389.thick, 'optionalAccess', _390 => _390[id]]));
+      if (glowed !== l.surface) out = _chunkHB4ICNNAcjs.mapLayer.call(void 0, out, id, () => ({ ...l, surface: glowed }));
+      const committed = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _391 => _391.layer]);
+      const spill = light[id] && isPixelLayer(committed) ? cache.spill(committed.surface, light[id], this.lightSpillOf(id)) : null;
+      if (spill) out = insertAfter(out, id, { type: "pixel", id: `${id}${SPILL_SUFFIX}`, name: `${l.name} light`, visible: l.visible, opacity: l.opacity, blend: "linear-dodge", surface: spill, offset: { ...l.offset } });
+    }
+    return out;
+  }
+  /** Visible pixel layers bottom first, as the backlight reads them (group opacities multiplied in). */
+  backlitLayers(layers, committed, opacity = 1, out = []) {
+    for (const l of layers) {
+      if (!l.visible) continue;
+      if (l.type === "group") this.backlitLayers(l.children, committed, opacity * l.opacity, out);
+      else if (isPixelLayer(l)) {
+        const thick = !committed && _optionalChain([this, 'access', _392 => _392.liveThick, 'optionalAccess', _393 => _393.layerId]) === l.id ? this.liveThick.channels : _optionalChain([this, 'access', _394 => _394.doc, 'access', _395 => _395.thick, 'optionalAccess', _396 => _396[l.id]]);
+        out.push({ surface: l.surface, offset: l.offset, opacity: opacity * l.opacity, ...thick ? { thick } : {} });
+      }
+    }
+    return out;
+  }
+  /**
+   * Backlit paper: the light that makes it through `base` (the layers as drawn), with the spill of
+   * the light through the committed painting, as a Linear Dodge (Add) layer for the top of the
+   * stack; `null` when the paper has no backlight.
+   */
+  backlightLayer(base) {
+    const paper = this.doc.paper;
+    const amount = backlightOf(paper);
+    if (!(amount > 0)) return null;
+    const { width, height } = this.doc.canvas;
+    const grain = paperGrain(paper);
+    const current = this.backlightView.surface(paper, grain, width, height, this.backlitLayers(base, false), null);
+    const committed = base === this.doc.layers ? current : this.backlightCommitted.surface(paper, grain, width, height, this.backlitLayers(this.doc.layers, true), null);
+    const surface = this.backlightView.layer(current, committed, amount);
+    return { type: "pixel", id: BACKLIGHT_LAYER_ID, name: "Backlight", visible: true, opacity: 1, blend: "linear-dodge", surface, offset: { x: 0, y: 0 } };
+  }
   renderLayers(options, view = false) {
-    let layers = this.litLayers((_nullishCoalesce(options.wet, () => ( "display"))) === "dried" ? this.driedLayers() : this.currentLayers());
+    const base = (_nullishCoalesce(options.wet, () => ( "display"))) === "dried" ? this.driedLayers() : this.currentLayers();
+    let layers = this.lightLayers(this.litLayers(base));
+    const backlight = options.paper !== false && !options.layerIds ? this.backlightLayer(base) : null;
+    if (backlight) layers = [...layers, backlight];
     if (options.layerIds) {
       const picked = [];
-      for (const id of options.layerIds) picked.push(_nullishCoalesce(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, layers, id), 'optionalAccess', _310 => _310.layer]), () => ( this.requireLayer(id))));
+      for (const id of options.layerIds) picked.push(_nullishCoalesce(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, layers, id), 'optionalAccess', _397 => _397.layer]), () => ( this.requireLayer(id))));
       layers = picked.map((l) => ({ ...l, visible: true }));
     }
     const under = options.paper === false ? [] : [paperNode(this.doc.paper, this.lighting)];
@@ -5550,7 +6236,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
    */
   compositeTiles(rect, onTile, options = {}) {
     const dirty = options.dirty === "all" ? void 0 : options.dirty;
-    this.viewCompositor.compositeTiles(this.renderLayers({ paper: options.paper }, true), rect, this.sources(), onTile, { dirty, checkpointLayerId: _nullishCoalesce(_optionalChain([this, 'access', _311 => _311.live, 'optionalAccess', _312 => _312.layerId]), () => ( this.doc.activeLayerId)) });
+    this.viewCompositor.compositeTiles(this.renderLayers({ paper: options.paper }, true), rect, this.sources(), onTile, { dirty, checkpointLayerId: _nullishCoalesce(_optionalChain([this, 'access', _398 => _398.live, 'optionalAccess', _399 => _399.layerId]), () => ( this.doc.activeLayerId)) });
   }
   /** The canvas as canvas-sized RGBA (paper included by default). */
   compositePixels(options = {}) {
@@ -5560,13 +6246,13 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   }
   /** The canvas (or some layers), scaled so the longest side is at most `maxSide`. */
   renderPreview(options = {}) {
-    const full = this.compositePixels({ ...options, wet: _nullishCoalesce(options.wet, () => ( "display")) });
+    const full2 = this.compositePixels({ ...options, wet: _nullishCoalesce(options.wet, () => ( "display")) });
     const side = Math.max(1, Math.round(_nullishCoalesce(options.maxSide, () => ( 512))));
-    const k = Math.min(1, side / Math.max(full.width, full.height));
-    if (k >= 1) return full;
-    const w = Math.max(1, Math.round(full.width * k));
-    const h = Math.max(1, Math.round(full.height * k));
-    return { width: w, height: h, data: downsampleRgba(full.data, full.width, full.height, w, h) };
+    const k = Math.min(1, side / Math.max(full2.width, full2.height));
+    if (k >= 1) return full2;
+    const w = Math.max(1, Math.round(full2.width * k));
+    const h = Math.max(1, Math.round(full2.height * k));
+    return { width: w, height: h, data: downsampleRgba(full2.data, full2.width, full2.height, w, h) };
   }
   // --- Save, load and export -------------------------------------------------------
   /** The document as JSON with inline PNG assets. */
@@ -5587,7 +6273,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     this.wet.reset();
     if (!raw || typeof raw !== "object") return;
     const r = raw;
-    this.wet.setTilt(_chunkXFYLA3ZOcjs.normalizeTilt.call(void 0, _nullishCoalesce(r.tilt, () => ( {}))));
+    this.wet.setTilt(_chunkVMROIWLLcjs.normalizeTilt.call(void 0, _nullishCoalesce(r.tilt, () => ( {}))));
     if (r.layers && typeof r.layers === "object") {
       for (const [id, v] of Object.entries(r.layers)) {
         if (!v || typeof v !== "object") {
@@ -5595,7 +6281,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
           continue;
         }
         const x = v;
-        this.wet.settings.set(id, { params: _chunkXFYLA3ZOcjs.normalizeWetParams.call(void 0, _nullishCoalesce(x.params, () => ( {}))), flow: _chunkXFYLA3ZOcjs.normalizeFlow.call(void 0, _nullishCoalesce(x.flow, () => ( {}))) });
+        this.wet.settings.set(id, { params: _chunkVMROIWLLcjs.normalizeWetParams.call(void 0, _nullishCoalesce(x.params, () => ( {}))), flow: _chunkVMROIWLLcjs.normalizeFlow.call(void 0, _nullishCoalesce(x.flow, () => ( {}))) });
       }
     }
   }
@@ -5618,7 +6304,18 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     for (const [id, list] of Object.entries(_nullishCoalesce(this.doc.liveStrokes, () => ( {})))) if (_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id)) liveStrokes[id] = list.map((x) => JSON.parse(JSON.stringify(x)));
     if (Object.keys(liveStrokes).length) ext.liveStrokes = liveStrokes;
     else delete ext.liveStrokes;
-    const effectLayers = effectLayersToJSON(_nullishCoalesce(this.doc.effectLayers, () => ( {})), (id) => isPixelLayer(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _313 => _313.layer])));
+    const light = {};
+    for (const [id, t] of Object.entries(_nullishCoalesce(this.doc.light, () => ( {})))) {
+      if (!_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id)) continue;
+      const saved = lightToJSON(_nullishCoalesce(this.wet.bakedLight(id), () => ( t)));
+      if (saved) light[id] = saved;
+    }
+    if (Object.keys(light).length) ext.light = light;
+    else delete ext.light;
+    const spills = Object.fromEntries(Object.entries(this.lightSpills).filter(([id]) => _chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id)));
+    if (Object.keys(spills).length) ext.lightSpill = spills;
+    else delete ext.lightSpill;
+    const effectLayers = effectLayersToJSON(_nullishCoalesce(this.doc.effectLayers, () => ( {})), (id) => isPixelLayer(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _400 => _400.layer])));
     if (effectLayers) ext.effectLayers = effectLayers;
     else delete ext.effectLayers;
     if (this.doc.paperEffect) ext.paperEffect = paperEffectToJSON(this.doc.paperEffect);
@@ -5635,7 +6332,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       const stickers = {};
       for (const [id, list] of Object.entries(ext.stickers)) {
         if (!_chunkHB4ICNNAcjs.findLayer.call(void 0, state.layers, id) || !Array.isArray(list)) continue;
-        const ok = list.filter((x) => x && typeof x.id === "string" && _chunk5BR7LC24cjs.STAMP_KINDS.includes(x.stamp) && Number.isFinite(x.x) && Number.isFinite(x.y) && x.size > 0);
+        const ok = list.filter((x) => x && typeof x.id === "string" && _chunk4T47Z4J3cjs.STAMP_KINDS.includes(x.stamp) && Number.isFinite(x.x) && Number.isFinite(x.y) && x.size > 0);
         if (ok.length !== list.length) problems.push(`Some stickers of layer "${id}" could not be read; they were dropped.`);
         stickers[id] = ok.map((x) => ({ ...x }));
       }
@@ -5644,7 +6341,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     if (ext.liveStrokes && typeof ext.liveStrokes === "object") {
       const liveStrokes = {};
       for (const [id, list] of Object.entries(ext.liveStrokes)) {
-        if (!isPixelLayer(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _314 => _314.layer])) || !Array.isArray(list)) continue;
+        if (!isPixelLayer(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _401 => _401.layer])) || !Array.isArray(list)) continue;
         const ok = list.map(normalizeBrushStroke).filter((x) => x !== null).map((x) => ({ ...x, layerId: id }));
         if (ok.length !== list.length) problems.push(`Some strokes of stroke layer "${id}" could not be read; they were dropped (the layer's pixels are kept until a stroke is edited).`);
         liveStrokes[id] = ok;
@@ -5654,7 +6351,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     if (ext.effectLayers && typeof ext.effectLayers === "object") {
       const effectLayers = {};
       for (const [id, v] of Object.entries(ext.effectLayers)) {
-        if (!isPixelLayer(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _315 => _315.layer]))) continue;
+        if (!isPixelLayer(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _402 => _402.layer]))) continue;
         const source = readPaintEffectSource(v);
         if (source) effectLayers[id] = source;
         else problems.push(`The effect of layer "${id}" could not be read; it loads as a plain layer.`);
@@ -5668,6 +6365,29 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
         problems.push(`The effect paper could not be read (${e.message}); the plain paper shows.`);
       }
     }
+    this.lightSpills = {};
+    this.lightCaches.clear();
+    if (ext.lightSpill && typeof ext.lightSpill === "object") {
+      for (const [id, v] of Object.entries(ext.lightSpill)) {
+        try {
+          if (_chunkHB4ICNNAcjs.findLayer.call(void 0, state.layers, id)) this.lightSpills[id] = normalizeLightSpill(_nullishCoalesce(v, () => ( {})));
+        } catch (e4) {
+          problems.push(`The light spill of layer "${id}" could not be read; it takes the defaults.`);
+        }
+      }
+    }
+    if (ext.light && typeof ext.light === "object") {
+      const light = {};
+      for (const [id, v] of Object.entries(ext.light)) {
+        if (!isPixelLayer(_optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, state.layers, id), 'optionalAccess', _403 => _403.layer]))) continue;
+        try {
+          light[id] = lightFromJSON(v);
+        } catch (e) {
+          problems.push(`The light paint of layer "${id}" could not be read (${e.message}); it loads without light.`);
+        }
+      }
+      if (Object.keys(light).length) state = { ...state, light };
+    }
     const raw = ext.layerChannels;
     if (!raw || typeof raw !== "object") return state;
     const thick = {};
@@ -5695,7 +6415,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     this.readGuides(loaded.guides, loaded.state, loaded.problems);
     if (Array.isArray(loaded.swatches)) this.swatches = loaded.swatches.map(readSwatch).filter((x) => x !== null);
     for (const s of loaded.state.strokes) {
-      const n = Number(_nullishCoalesce(_optionalChain([/^s(\d+)$/, 'access', _316 => _316.exec, 'call', _317 => _317(s.id), 'optionalAccess', _318 => _318[1]]), () => ( 0)));
+      const n = Number(_nullishCoalesce(_optionalChain([/^s(\d+)$/, 'access', _404 => _404.exec, 'call', _405 => _405(s.id), 'optionalAccess', _406 => _406[1]]), () => ( 0)));
       if (n >= this.strokeCounter) this.strokeCounter = n + 1;
     }
     this.undoStack = [];
@@ -5703,12 +6423,14 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     this.doc = this.readThick(loaded.state, loaded.extensions, loaded.problems);
     for (const list of Object.values(_nullishCoalesce(this.doc.liveStrokes, () => ( {})))) {
       for (const s of list) {
-        const n = Number(_nullishCoalesce(_optionalChain([/^s(\d+)$/, 'access', _319 => _319.exec, 'call', _320 => _320(s.id), 'optionalAccess', _321 => _321[1]]), () => ( 0)));
+        const n = Number(_nullishCoalesce(_optionalChain([/^s(\d+)$/, 'access', _407 => _407.exec, 'call', _408 => _408(s.id), 'optionalAccess', _409 => _409[1]]), () => ( 0)));
         if (n >= this.strokeCounter) this.strokeCounter = n + 1;
       }
     }
     this.docRevision++;
     delete this.extensions.layerChannels;
+    delete this.extensions.light;
+    delete this.extensions.lightSpill;
     delete this.extensions.lighting;
     delete this.extensions.stickers;
     delete this.extensions.liveStrokes;
@@ -5742,13 +6464,13 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     return _chunkOLNIPTB3cjs.encodePng.call(void 0, img.width, img.height, img.data);
   }
   scaled(options) {
-    const full = this.compositePixels(options);
+    const full2 = this.compositePixels(options);
     const s = _nullishCoalesce(options.scale, () => ( 1));
     if (!(s > 0 && s <= 1)) throw new PaintEditorError(`scale ${s} is out of range; use above 0 up to 1 (exports never upscale pixels).`);
-    if (s === 1) return full;
-    const w = Math.max(1, Math.round(full.width * s));
-    const h = Math.max(1, Math.round(full.height * s));
-    return { width: w, height: h, data: downsampleRgba(full.data, full.width, full.height, w, h) };
+    if (s === 1) return full2;
+    const w = Math.max(1, Math.round(full2.width * s));
+    const h = Math.max(1, Math.round(full2.height * s));
+    return { width: w, height: h, data: downsampleRgba(full2.data, full2.width, full2.height, w, h) };
   }
   /**
    * The canvas as PNG, JPEG or WebP bytes. JPEG has no alpha, so it always includes the paper.
@@ -5771,7 +6493,9 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
    * pixels), and the composite as the merged image.
    */
   exportPsd() {
-    const dried = this.litLayers(this.driedLayers(this.doc.layers));
+    const driedBase = this.driedLayers(this.doc.layers);
+    const backlight = this.backlightLayer(driedBase);
+    const dried = [...this.lightLayers(this.litLayers(driedBase)), ...backlight ? [backlight] : []];
     const { width, height, dpi } = this.doc.canvas;
     const paperPixels = this.compositePixels({ layerIds: [], paper: true });
     const paperLayer = {
@@ -5794,14 +6518,20 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       return next.type === "group" ? { ...next, children: toStandard(next.children) } : next;
     });
     const layers = toStandard(dried);
-    const result = _chunkHW72ABGRcjs.exportPsd.call(void 0, { width, height, layers: [paperLayer, ...layers], merged, resolution: dpi });
+    const result = _chunkM6JORA5Zcjs.exportPsd.call(void 0, { width, height, layers: [paperLayer, ...layers], merged, resolution: dpi });
     for (const [mode, names] of changed) {
-      const label = _nullishCoalesce(_optionalChain([_chunkOLNIPTB3cjs.BLEND_MODES, 'access', _322 => _322.find, 'call', _323 => _323((m) => m.id === mode), 'optionalAccess', _324 => _324.label]), () => ( mode));
-      const std = _nullishCoalesce(_optionalChain([_chunkOLNIPTB3cjs.BLEND_MODES, 'access', _325 => _325.find, 'call', _326 => _326((m) => m.id === _chunkOLNIPTB3cjs.standardBlendMode.call(void 0, mode)), 'optionalAccess', _327 => _327.label]), () => ( _chunkOLNIPTB3cjs.standardBlendMode.call(void 0, mode)));
+      const label = _nullishCoalesce(_optionalChain([_chunkOLNIPTB3cjs.BLEND_MODES, 'access', _410 => _410.find, 'call', _411 => _411((m) => m.id === mode), 'optionalAccess', _412 => _412.label]), () => ( mode));
+      const std = _nullishCoalesce(_optionalChain([_chunkOLNIPTB3cjs.BLEND_MODES, 'access', _413 => _413.find, 'call', _414 => _414((m) => m.id === _chunkOLNIPTB3cjs.standardBlendMode.call(void 0, mode)), 'optionalAccess', _415 => _415.label]), () => ( _chunkOLNIPTB3cjs.standardBlendMode.call(void 0, mode)));
       const list = names.map((n) => `"${n}"`).join(", ");
       const one = names.length === 1;
       result.warnings.push(`${label} blending has no PSD equivalent; ${list} ${one ? "was" : "were"} written as ${std}, the nearest Photoshop mode, so ${one ? "it looks" : "they look"} different in Photoshop (the merged image is exact).`);
     }
+    if (backlight) {
+      result.warnings.push('Backlit paper is written as pixels: the light that comes through the paint is a "Backlight" Linear Dodge (Add) layer at the top. Opening the PSD again gives a plain pixel layer, not a backlight.');
+    }
+    if (Object.values(_nullishCoalesce(this.doc.light, () => ( {}))).some((l) => l.tiles.size)) {
+      result.warnings.push('Light paint is written as pixels: each layer with its glow, and its spill as a "\u2039layer\u203A light" Linear Dodge (Add) layer above it. Opening the PSD again gives plain pixel layers, not editable light.');
+    }
     return result;
   }
   /** `render_preview` as a base64 PNG. */
@@ -5913,7 +6643,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const { src, pixels } = this.importImage(options, "The reference image");
     const ref2 = {
       id: `ref${this.nextReferenceId++}`,
-      name: _optionalChain([options, 'access', _328 => _328.name, 'optionalAccess', _329 => _329.trim, 'call', _330 => _330()]) || `Reference ${this.guides.references.length + 1}`,
+      name: _optionalChain([options, 'access', _416 => _416.name, 'optionalAccess', _417 => _417.trim, 'call', _418 => _418()]) || `Reference ${this.guides.references.length + 1}`,
       src,
       width: pixels.width,
       height: pixels.height,
@@ -5992,7 +6722,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
         try {
           const px = this.decodeImage(ref2.src, `Reference "${ref2.name}"`);
           guides.references.push({ id: ref2.id, name: String(_nullishCoalesce(ref2.name, () => ( ref2.id))), src: ref2.src, width: px.width, height: px.height, x: Number(ref2.x) || 0, y: Number(ref2.y) || 0, displayWidth: Number(ref2.displayWidth) || 240, visible: ref2.visible !== false });
-          const n = Number(_nullishCoalesce(_optionalChain([/^ref(\d+)$/, 'access', _331 => _331.exec, 'call', _332 => _332(ref2.id), 'optionalAccess', _333 => _333[1]]), () => ( 0)));
+          const n = Number(_nullishCoalesce(_optionalChain([/^ref(\d+)$/, 'access', _419 => _419.exec, 'call', _420 => _420(ref2.id), 'optionalAccess', _421 => _421[1]]), () => ( 0)));
           if (n >= this.nextReferenceId) this.nextReferenceId = n + 1;
         } catch (e) {
           problems.push(e.message);
@@ -6003,7 +6733,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       guides.stencils = [];
       r.stencils.forEach((raw2, i) => {
         try {
-          const id = typeof _optionalChain([raw2, 'optionalAccess', _334 => _334.id]) === "string" && /^stencil\d+$/.test(raw2.id) ? raw2.id : `stencil${this.nextStencilId}`;
+          const id = typeof _optionalChain([raw2, 'optionalAccess', _422 => _422.id]) === "string" && /^stencil\d+$/.test(raw2.id) ? raw2.id : `stencil${this.nextStencilId}`;
           guides.stencils.push(normalizeStencil(raw2, id));
           const n = Number(id.slice(7));
           if (n >= this.nextStencilId) this.nextStencilId = n + 1;
@@ -6026,12 +6756,12 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   /** The next free sticker number (ids `st<n>` are unique across the document). */
   nextStickerNumber(doc = this.doc) {
     let n = 0;
-    for (const list of Object.values(_nullishCoalesce(doc.stickers, () => ( {})))) for (const st of list) n = Math.max(n, Number(_nullishCoalesce(_optionalChain([/^st(\d+)$/, 'access', _335 => _335.exec, 'call', _336 => _336(st.id), 'optionalAccess', _337 => _337[1]]), () => ( 0))));
+    for (const list of Object.values(_nullishCoalesce(doc.stickers, () => ( {})))) for (const st of list) n = Math.max(n, Number(_nullishCoalesce(_optionalChain([/^st(\d+)$/, 'access', _423 => _423.exec, 'call', _424 => _424(st.id), 'optionalAccess', _425 => _425[1]]), () => ( 0))));
     return n + 1;
   }
   stickerLayer(layerId) {
     const l = this.wetLayer(layerId, "edit the stickers of");
-    const stickers = _optionalChain([this, 'access', _338 => _338.doc, 'access', _339 => _339.stickers, 'optionalAccess', _340 => _340[l.id]]);
+    const stickers = _optionalChain([this, 'access', _426 => _426.doc, 'access', _427 => _427.stickers, 'optionalAccess', _428 => _428[l.id]]);
     if (!stickers) throw new PaintEditorError(`Layer "${l.name}" has no stickers; spray some with a sticker brush (list_brushes category sticker).`);
     return { layer: l, stickers };
   }
@@ -6040,7 +6770,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const id = _nullishCoalesce(layerId, () => ( this.doc.activeLayerId));
     if (!id) return [];
     this.requireLayer(id);
-    return (_nullishCoalesce(_optionalChain([this, 'access', _341 => _341.doc, 'access', _342 => _342.stickers, 'optionalAccess', _343 => _343[id]]), () => ( []))).map((s) => ({ ...s }));
+    return (_nullishCoalesce(_optionalChain([this, 'access', _429 => _429.doc, 'access', _430 => _430.stickers, 'optionalAccess', _431 => _431[id]]), () => ( []))).map((s) => ({ ...s }));
   }
   /**
    * Replaces a layer's stickers and redraws its pixels from them (one undo step). With `dirty`,
@@ -6056,15 +6786,15 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   }
   redrawStickers(layer, stickers, dirty) {
     const partial = dirty && !layer.offset.x && !layer.offset.y;
-    return partial ? _chunk5BR7LC24cjs.stickerSurface.call(void 0, stickers, layer.surface, dirty) : _chunk5BR7LC24cjs.stickerSurface.call(void 0, stickers);
+    return partial ? _chunk4T47Z4J3cjs.stickerSurface.call(void 0, stickers, layer.surface, dirty) : _chunk4T47Z4J3cjs.stickerSurface.call(void 0, stickers);
   }
   /** The document from before the sticker preview on screen, or `null` when none is (anything else changed the document since). */
   previewBase() {
-    return _optionalChain([this, 'access', _344 => _344.stickerPreview, 'optionalAccess', _345 => _345.shown]) === this.doc ? this.stickerPreview.base : null;
+    return _optionalChain([this, 'access', _432 => _432.stickerPreview, 'optionalAccess', _433 => _433.shown]) === this.doc ? this.stickerPreview.base : null;
   }
   readStickerUpdate(update) {
     try {
-      return _chunk5BR7LC24cjs.normalizeStickerUpdate.call(void 0, update);
+      return _chunk4T47Z4J3cjs.normalizeStickerUpdate.call(void 0, update);
     } catch (e) {
       throw new PaintEditorError(e.message);
     }
@@ -6075,7 +6805,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const id = _nullishCoalesce(layerId, () => ( this.doc.activeLayerId));
     if (!id) return null;
     this.requireLayer(id);
-    const hit = _chunk5BR7LC24cjs.stickerAt.call(void 0, _nullishCoalesce(_optionalChain([this, 'access', _346 => _346.doc, 'access', _347 => _347.stickers, 'optionalAccess', _348 => _348[id]]), () => ( [])), x, y);
+    const hit = _chunk4T47Z4J3cjs.stickerAt.call(void 0, _nullishCoalesce(_optionalChain([this, 'access', _434 => _434.doc, 'access', _435 => _435.stickers, 'optionalAccess', _436 => _436[id]]), () => ( [])), x, y);
     return hit ? { ...hit } : null;
   }
   /** Picks a sticker for the panel and canvas (`null` for none). Editor state, not an undo step. */
@@ -6096,7 +6826,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     if (i < 0) throw new PaintEditorError(`Layer "${layer.name}" has no sticker "${id}". Call list_stickers for the ids.`);
     const next = { ...stickers[i], ...this.readStickerUpdate(update) };
     const list = stickers.map((s, j) => j === i ? next : s);
-    const dirty = [_chunk5BR7LC24cjs.stickerRect.call(void 0, stickers[i]), _chunk5BR7LC24cjs.stickerRect.call(void 0, next)];
+    const dirty = [_chunk4T47Z4J3cjs.stickerRect.call(void 0, stickers[i]), _chunk4T47Z4J3cjs.stickerRect.call(void 0, next)];
     const base = _nullishCoalesce(this.previewBase(), () => ( this.doc));
     const surface = this.redrawStickers(layer, list, dirty);
     this.doc = { ...this.doc, layers: _chunkHB4ICNNAcjs.mapLayer.call(void 0, this.doc.layers, layer.id, () => ({ ...layer, surface, offset: { x: 0, y: 0 } })), stickers: { ..._nullishCoalesce(this.doc.stickers, () => ( {})), [layer.id]: list } };
@@ -6119,7 +6849,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     if (i < 0) throw new PaintEditorError(`Layer "${layer.name}" has no sticker "${id}". Call list_stickers for the ids.`);
     const u = this.readStickerUpdate(update);
     const next = { ...stickers[i], ...u };
-    this.commitStickers("Edit sticker", layer, stickers.map((s, j) => j === i ? next : s), [_chunk5BR7LC24cjs.stickerRect.call(void 0, stickers[i]), _chunk5BR7LC24cjs.stickerRect.call(void 0, next)]);
+    this.commitStickers("Edit sticker", layer, stickers.map((s, j) => j === i ? next : s), [_chunk4T47Z4J3cjs.stickerRect.call(void 0, stickers[i]), _chunk4T47Z4J3cjs.stickerRect.call(void 0, next)]);
     return { ...next };
   }
   /**
@@ -6131,8 +6861,8 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const layer = this.wetLayer(layerId, "add stickers to");
     if (!input.length) throw new PaintEditorError("Pass at least one sticker (stamp, x, y).");
     if (input.length > MAX_ADD_STICKERS) throw new PaintEditorError(`At most ${MAX_ADD_STICKERS} stickers per call; split them over several calls.`);
-    const existing = _optionalChain([this, 'access', _349 => _349.doc, 'access', _350 => _350.stickers, 'optionalAccess', _351 => _351[layer.id]]);
-    if (!_optionalChain([existing, 'optionalAccess', _352 => _352.length])) {
+    const existing = _optionalChain([this, 'access', _437 => _437.doc, 'access', _438 => _438.stickers, 'optionalAccess', _439 => _439[layer.id]]);
+    if (!_optionalChain([existing, 'optionalAccess', _440 => _440.length])) {
       if (this.wet.wetLayerIds().includes(layer.id) || _chunk474IQG74cjs.contentBounds.call(void 0, layer.surface)) throw new PaintEditorError(`Layer "${layer.name}" already has paint; add stickers to an empty layer (add_layer) or a sticker layer so they stay editable.`);
     }
     let n = this.nextStickerNumber();
@@ -6148,7 +6878,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       const id = n++;
       return { id: `st${id}`, size: 48, rotation: 0, color: this.color, opacity: 1, seed: _nullishCoalesce(raw.seed, () => ( _chunkPQ3H2AANcjs.mix32.call(void 0, id * 2654435761 >>> 0) & 2147483647)), ...u };
     });
-    this.commitStickers("Add stickers", layer, [..._nullishCoalesce(existing, () => ( [])), ...added], _optionalChain([existing, 'optionalAccess', _353 => _353.length]) ? added.map(_chunk5BR7LC24cjs.stickerRect) : void 0);
+    this.commitStickers("Add stickers", layer, [..._nullishCoalesce(existing, () => ( [])), ...added], _optionalChain([existing, 'optionalAccess', _441 => _441.length]) ? added.map(_chunk4T47Z4J3cjs.stickerRect) : void 0);
     return added.map((s) => ({ ...s }));
   }
   /** Brings stickers to the top (`front`) or bottom of their layer (one undo step). */
@@ -6158,7 +6888,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const picked = stickers.filter((s) => ids.includes(s.id));
     const rest = stickers.filter((s) => !ids.includes(s.id));
     const next = to === "front" ? [...rest, ...picked] : [...picked, ...rest];
-    this.commitStickers("Arrange stickers", layer, next, picked.map(_chunk5BR7LC24cjs.stickerRect));
+    this.commitStickers("Arrange stickers", layer, next, picked.map(_chunk4T47Z4J3cjs.stickerRect));
     return next.map((s) => s.id);
   }
   /** Deletes stickers (`ids`, or all of them on the layer) (one undo step). Returns the ids removed. */
@@ -6168,7 +6898,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       for (const id of ids) if (!stickers.some((s) => s.id === id)) throw new PaintEditorError(`Layer "${layer.name}" has no sticker "${id}". Call list_stickers for the ids.`);
     }
     const removed = ids ? [...ids] : stickers.map((s) => s.id);
-    this.commitStickers("Remove stickers", layer, stickers.filter((s) => !removed.includes(s.id)), ids ? stickers.filter((s) => removed.includes(s.id)).map(_chunk5BR7LC24cjs.stickerRect) : void 0);
+    this.commitStickers("Remove stickers", layer, stickers.filter((s) => !removed.includes(s.id)), ids ? stickers.filter((s) => removed.includes(s.id)).map(_chunk4T47Z4J3cjs.stickerRect) : void 0);
     return removed;
   }
   /** Sets a layer's stickers (replays). */
@@ -6187,20 +6917,20 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   }
   liveStrokeLayer(layerId, what) {
     const l = this.wetLayer(layerId, what);
-    const strokes = _optionalChain([this, 'access', _354 => _354.doc, 'access', _355 => _355.liveStrokes, 'optionalAccess', _356 => _356[l.id]]);
+    const strokes = _optionalChain([this, 'access', _442 => _442.doc, 'access', _443 => _443.liveStrokes, 'optionalAccess', _444 => _444[l.id]]);
     if (!strokes) throw new PaintEditorError(`Layer "${l.name}" is not a stroke layer; add one with add_layer {type: "strokes"} (or convert_to_stroke_layer on an empty layer), then paint on it.`);
     return { layer: l, strokes };
   }
   /** Whether a layer is a live stroke layer. */
   isLiveStrokeLayer(layerId) {
-    return Boolean(_optionalChain([this, 'access', _357 => _357.doc, 'access', _358 => _358.liveStrokes, 'optionalAccess', _359 => _359[layerId]]));
+    return Boolean(_optionalChain([this, 'access', _445 => _445.doc, 'access', _446 => _446.liveStrokes, 'optionalAccess', _447 => _447[layerId]]));
   }
   /** Makes an empty pixel layer a live stroke layer (one undo step). */
   convertToLiveStrokes(layerId) {
     this.requireIdle("converting a layer");
     const l = this.paintTarget(layerId, "convert");
-    if (_optionalChain([this, 'access', _360 => _360.doc, 'access', _361 => _361.liveStrokes, 'optionalAccess', _362 => _362[l.id]])) return this.describeLayer(l);
-    if (_optionalChain([this, 'access', _363 => _363.doc, 'access', _364 => _364.stickers, 'optionalAccess', _365 => _365[l.id], 'optionalAccess', _366 => _366.length])) throw new PaintEditorError(`Layer "${l.name}" is a sticker layer; add a stroke layer instead (add_layer {type: "strokes"}).`);
+    if (_optionalChain([this, 'access', _448 => _448.doc, 'access', _449 => _449.liveStrokes, 'optionalAccess', _450 => _450[l.id]])) return this.describeLayer(l);
+    if (_optionalChain([this, 'access', _451 => _451.doc, 'access', _452 => _452.stickers, 'optionalAccess', _453 => _453[l.id], 'optionalAccess', _454 => _454.length])) throw new PaintEditorError(`Layer "${l.name}" is a sticker layer; add a stroke layer instead (add_layer {type: "strokes"}).`);
     if (_chunk474IQG74cjs.contentBounds.call(void 0, l.surface) || this.wet.wetLayerIds().includes(l.id)) throw new PaintEditorError(`Layer "${l.name}" already has paint, which isn't kept as strokes; convert an empty layer or add a stroke layer (add_layer {type: "strokes"}).`);
     this.commit("Convert to stroke layer", { ...this.doc, liveStrokes: { ..._nullishCoalesce(this.doc.liveStrokes, () => ( {})), [l.id]: [] } });
     return this.describeLayer(this.getLayer(l.id));
@@ -6213,7 +6943,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   findLiveStroke(id) {
     for (const [layerId, strokes] of Object.entries(_nullishCoalesce(this.doc.liveStrokes, () => ( {})))) {
       const index = strokes.findIndex((x) => x.id === id);
-      const layer = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, layerId), 'optionalAccess', _367 => _367.layer]);
+      const layer = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.doc.layers, layerId), 'optionalAccess', _455 => _455.layer]);
       if (index >= 0 && isPixelLayer(layer)) return { layer, strokes, index };
     }
     const baked = this.doc.strokes.some((x) => x.id === id);
@@ -6233,15 +6963,15 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     let brush = was.brush;
     if (update.brushId !== void 0) {
       const b = this.requireBrush(update.brushId);
-      brush = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { tip: { ...b.tip, size: was.brush.tip.size } }, b);
+      brush = _chunk4T47Z4J3cjs.normalizePaintBrush.call(void 0, { tip: { ...b.tip, size: was.brush.tip.size } }, b);
     }
     if (update.brush !== void 0) {
       if (!update.brush || typeof update.brush !== "object") throw new PaintEditorError("brush must be an object of brush settings (as set_brush takes).");
-      brush = _chunk5BR7LC24cjs.normalizePaintBrush.call(void 0, { ...update.brush, id: brush.id }, brush);
+      brush = _chunk4T47Z4J3cjs.normalizePaintBrush.call(void 0, { ...update.brush, id: brush.id }, brush);
     }
     const why = liveStrokeRefusal(brush);
     if (why) throw new PaintEditorError(why);
-    const next = { ...was, brush: _chunk5BR7LC24cjs.brushToJSON.call(void 0, brush) };
+    const next = { ...was, brush: _chunk4T47Z4J3cjs.brushToJSON.call(void 0, brush) };
     if (update.seed !== void 0) {
       if (!Number.isInteger(update.seed) || update.seed < 0) throw new PaintEditorError(`seed ${update.seed} must be a whole number of 0 or more.`);
       next.seed = update.seed;
@@ -6252,7 +6982,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     }
     if (update.paint !== void 0) {
       if (update.paint === null) delete next.paint;
-      else if (_chunk5BR7LC24cjs.isPaintEffectPaint.call(void 0, update.paint)) {
+      else if (_chunk4T47Z4J3cjs.isPaintEffectPaint.call(void 0, update.paint)) {
         if (!this.effectPaintImage(update.paint)) throw new PaintEditorError(`The effect "${update.paint.effect}" is not rendered yet; render it first (prepareEffectPaints; the update_stroke tool does this).`);
         next.paint = JSON.parse(JSON.stringify(update.paint));
       } else {
@@ -6263,7 +6993,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
         } else next.paint = JSON.parse(JSON.stringify(p));
       }
     }
-    const rgb = _chunk5BR7LC24cjs.hexToRgb8.call(void 0, next.color).map((v) => v / 255);
+    const rgb = _chunk4T47Z4J3cjs.hexToRgb8.call(void 0, next.color).map((v) => v / 255);
     const load = brushLoadForStroke(brush, _chunkPQ3H2AANcjs.EMPTY_MIXER_LOAD, rgb);
     if (load.reservoir || load.pickup) next.load = load;
     else delete next.load;
@@ -6308,9 +7038,9 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const layers = /* @__PURE__ */ new Map();
     for (const f of found) layers.set(f.layer.id, f.layer);
     for (const [layerId, layer] of layers) {
-      const gone = (_nullishCoalesce(_optionalChain([doc, 'access', _368 => _368.liveStrokes, 'optionalAccess', _369 => _369[layerId]]), () => ( []))).filter((x) => ids.includes(x.id));
+      const gone = (_nullishCoalesce(_optionalChain([doc, 'access', _456 => _456.liveStrokes, 'optionalAccess', _457 => _457[layerId]]), () => ( []))).filter((x) => ids.includes(x.id));
       for (const x of gone) bounds = unionRect(bounds, this.strokeArea(x));
-      doc = this.withLiveStrokes(doc, layer, (_nullishCoalesce(_optionalChain([doc, 'access', _370 => _370.liveStrokes, 'optionalAccess', _371 => _371[layerId]]), () => ( []))).filter((x) => !ids.includes(x.id)), this.strokeAreas(gone));
+      doc = this.withLiveStrokes(doc, layer, (_nullishCoalesce(_optionalChain([doc, 'access', _458 => _458.liveStrokes, 'optionalAccess', _459 => _459[layerId]]), () => ( []))).filter((x) => !ids.includes(x.id)), this.strokeAreas(gone));
     }
     this.commit(ids.length === 1 ? "Remove stroke" : "Remove strokes", doc);
     return { removed: [...ids], bounds };
@@ -6378,7 +7108,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   }
   withLiveStrokes(doc, layer, list, dirty) {
     if (_chunkHB4ICNNAcjs.isLayerLocked.call(void 0, layer, "pixels")) throw new PaintEditorError(`Layer "${layer.name}" has its pixels locked; unlock it (update_layer locks) first.`);
-    const current = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, doc.layers, layer.id), 'optionalAccess', _372 => _372.layer]);
+    const current = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, doc.layers, layer.id), 'optionalAccess', _460 => _460.layer]);
     const surface = this.drawLiveStrokes(_nullishCoalesce(current, () => ( layer)), list, dirty);
     const next = { ...doc, layers: _chunkHB4ICNNAcjs.mapLayer.call(void 0, doc.layers, layer.id, (l) => ({ ...l, surface, offset: { x: 0, y: 0 } })), liveStrokes: { ..._nullishCoalesce(doc.liveStrokes, () => ( {})), [layer.id]: [...list] } };
     return this.withPaintEvent(next, { kind: "live-strokes", layerId: layer.id, data: { strokes: list.map((x) => JSON.parse(JSON.stringify(x))) } });
@@ -6456,7 +7186,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     if (!this.animatedLayers.size) return this.doc.layers;
     let layers = this.doc.layers;
     for (const [id, a] of this.animatedLayers) {
-      const l = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, layers, id), 'optionalAccess', _373 => _373.layer]);
+      const l = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, layers, id), 'optionalAccess', _461 => _461.layer]);
       if (isPixelLayer(l) && l.surface === a.base) layers = _chunkHB4ICNNAcjs.mapLayer.call(void 0, layers, id, () => ({ ...l, surface: a.surface }));
     }
     return layers;
@@ -6466,11 +7196,11 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     const layers = [];
     const sources = /* @__PURE__ */ new Map();
     for (const [id, strokes] of Object.entries(_nullishCoalesce(doc.liveStrokes, () => ( {})))) {
-      const layer = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, doc.layers, id), 'optionalAccess', _374 => _374.layer]);
+      const layer = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, doc.layers, id), 'optionalAccess', _462 => _462.layer]);
       const live = strokes.filter(isLiveEffect);
       if (!isPixelLayer(layer) || !live.length) continue;
       layers.push({ layer, strokes });
-      for (const st of live) sources.set(_chunk5BR7LC24cjs.effectPaintKey.call(void 0, st.paint), st.paint);
+      for (const st of live) sources.set(_chunk4T47Z4J3cjs.effectPaintKey.call(void 0, st.paint), st.paint);
     }
     return { layers, sources: [...sources.values()] };
   }
@@ -6591,13 +7321,13 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
     return this.withEffectTime(time, () => this.compositePixels(options));
   }
   // --- Stencils --------------------------------------------------------------------
-  __init123() {this.stencilCache = null}
-  __init124() {this.nextStencilId = 1}
+  __init135() {this.stencilCache = null}
+  __init136() {this.nextStencilId = 1}
   /** The mask stencils' coverage over the canvas (cached), or `null` when none masks. */
   stencilSelection(stencils = this.guides.stencils) {
     const { width, height } = this.doc.canvas;
     const size = `${width}x${height}`;
-    if (_optionalChain([this, 'access', _375 => _375.stencilCache, 'optionalAccess', _376 => _376.key]) === stencils && this.stencilCache.size === size) return this.stencilCache.mask;
+    if (_optionalChain([this, 'access', _463 => _463.stencilCache, 'optionalAccess', _464 => _464.key]) === stencils && this.stencilCache.size === size) return this.stencilCache.mask;
     const mask = stencilMask(stencils, width, height);
     this.stencilCache = { key: stencils, size, mask };
     return mask;
@@ -6659,7 +7389,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   makeSwatch(color, name) {
     const p = typeof color === "string" ? { type: "color", color: parseColor(color) } : this.readStrokePaint(color);
     const out = { color: _chunkPQ3H2AANcjs.paintSourceColor.call(void 0, p, { paint: this.color, secondary: this.secondaryColor }) };
-    if (_optionalChain([name, 'optionalAccess', _377 => _377.trim, 'call', _378 => _378()])) out.name = name.trim();
+    if (_optionalChain([name, 'optionalAccess', _465 => _465.trim, 'call', _466 => _466()])) out.name = name.trim();
     if (p.type === "gradient") out.paint = p;
     return out;
   }
@@ -6711,7 +7441,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
    * mix becomes the paint colour. Returns the mixed colour and the pile's bounds.
    */
   mixOnPad(paints, options = {}) {
-    const parsed = (_nullishCoalesce(paints, () => ( []))).map((p, i) => ({ color: parseColor(_optionalChain([p, 'optionalAccess', _379 => _379.color]), `paints[${i}].color`), parts: _optionalChain([p, 'optionalAccess', _380 => _380.parts]) }));
+    const parsed = (_nullishCoalesce(paints, () => ( []))).map((p, i) => ({ color: parseColor(_optionalChain([p, 'optionalAccess', _467 => _467.color]), `paints[${i}].color`), parts: _optionalChain([p, 'optionalAccess', _468 => _468.parts]) }));
     let r;
     try {
       r = this.pad.mix(parsed, options);
@@ -6800,15 +7530,29 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
   }
   /** A layer's tile surface (live while stroking), for thumbnails. */
   layerSurface(id) {
-    const l = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.currentLayers(), id), 'optionalAccess', _381 => _381.layer]);
+    const l = _optionalChain([_chunkHB4ICNNAcjs.findLayer.call(void 0, this.currentLayers(), id), 'optionalAccess', _469 => _469.layer]);
     return isPixelLayer(l) ? l.surface : null;
   }
-}, _class10.__initStatic(), _class10);
+}, _class12.__initStatic(), _class12);
 var MAX_IMAGE_SIDE = 8192;
 var movePoint = (p, dx, dy) => ({ x: p.x + dx, y: p.y + dy });
 var moveRect = (r, dx, dy) => ({ ...r, x: r.x + dx, y: r.y + dy });
+var SPILL_SUFFIX = "::light";
+function withLayerLight(light, layerId, next) {
+  if (!next) return light ? { ...light } : void 0;
+  const out = { ..._nullishCoalesce(light, () => ( {})) };
+  if (next.tiles.size) out[layerId] = next;
+  else delete out[layerId];
+  return out;
+}
+var BACKLIGHT_LAYER_ID = "__backlight";
+function insertAfter(layers, id, node) {
+  const i = layers.findIndex((l) => l.id === id);
+  if (i >= 0) return [...layers.slice(0, i + 1), node, ...layers.slice(i + 1)];
+  return layers.map((l) => l.type === "group" ? { ...l, children: insertAfter(l.children, id, node) } : l);
+}
 function isLiveEffect(s) {
-  return _optionalChain([s, 'access', _382 => _382.paint, 'optionalAccess', _383 => _383.type]) === "effect" && s.paint.live === true;
+  return _optionalChain([s, 'access', _470 => _470.paint, 'optionalAccess', _471 => _471.type]) === "effect" && s.paint.live === true;
 }
 function framePaint(p, t) {
   return { ...p, time: p.time + t };
@@ -6833,7 +7577,7 @@ function clipRect(r, width, height) {
   return x1 > x0 && y1 > y0 ? { x: x0, y: y0, width: x1 - x0, height: y1 - y0 } : null;
 }
 function withLiveStroke(doc, stroke) {
-  const list = _optionalChain([doc, 'access', _384 => _384.liveStrokes, 'optionalAccess', _385 => _385[stroke.layerId]]);
+  const list = _optionalChain([doc, 'access', _472 => _472.liveStrokes, 'optionalAccess', _473 => _473[stroke.layerId]]);
   return list ? { ...doc, liveStrokes: { ...doc.liveStrokes, [stroke.layerId]: [...list, stroke] } } : doc;
 }
 function shiftDocument(doc, dx, dy) {
@@ -6860,9 +7604,9 @@ function shiftDocument(doc, dx, dy) {
   if (doc.liveStrokes) out.liveStrokes = Object.fromEntries(Object.entries(doc.liveStrokes).map(([id, list]) => [id, list.map(moveStroke)]));
   if (doc.paintEvents) {
     out.paintEvents = doc.paintEvents.map((e) => {
-      const list = e.kind === "stickers" ? _optionalChain([e, 'access', _386 => _386.data, 'optionalAccess', _387 => _387.stickers]) : void 0;
+      const list = e.kind === "stickers" ? _optionalChain([e, 'access', _474 => _474.data, 'optionalAccess', _475 => _475.stickers]) : void 0;
       if (list) return { ...e, data: { ...e.data, stickers: moveStickers(list) } };
-      const strokes = e.kind === "live-strokes" ? _optionalChain([e, 'access', _388 => _388.data, 'optionalAccess', _389 => _389.strokes]) : void 0;
+      const strokes = e.kind === "live-strokes" ? _optionalChain([e, 'access', _476 => _476.data, 'optionalAccess', _477 => _477.strokes]) : void 0;
       return strokes ? { ...e, data: { ...e.data, strokes: strokes.map(moveStroke) } } : e;
     });
   }
@@ -6944,8 +7688,8 @@ function strokeSchedule(points) {
   return total > 0 ? acc.map((d) => d / total) : points.map(() => 1);
 }
 function strokeDuration(points, max = 1800) {
-  const t0 = _optionalChain([points, 'access', _390 => _390[0], 'optionalAccess', _391 => _391.t]);
-  const t1 = _optionalChain([points, 'access', _392 => _392[points.length - 1], 'optionalAccess', _393 => _393.t]);
+  const t0 = _optionalChain([points, 'access', _478 => _478[0], 'optionalAccess', _479 => _479.t]);
+  const t1 = _optionalChain([points, 'access', _480 => _480[points.length - 1], 'optionalAccess', _481 => _481.t]);
   let ms;
   if (points.every((p) => Number.isFinite(p.t)) && t1 > t0) ms = t1 - t0;
   else {
@@ -6999,7 +7743,7 @@ var PaintDirector = class {
   }
   where(id) {
     const a = this.presence.get(id);
-    return { x: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _394 => _394.x]), () => ( 0)), y: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _395 => _395.y]), () => ( 0)) };
+    return { x: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _482 => _482.x]), () => ( 0)), y: _nullishCoalesce(_optionalChain([a, 'optionalAccess', _483 => _483.y]), () => ( 0)) };
   }
   /** Glides to `to`; an actor that just appeared starts there instead of the corner. */
   async glide(id, to, ms = 380) {
@@ -7046,8 +7790,8 @@ var PaintDirector = class {
       }
       case "replay": {
         await this.say(id, command.note, 500);
-        const source = c.getStrokes().filter((s) => _optionalChain([command, 'access', _396 => _396.replay, 'access', _397 => _397.strokeIds, 'optionalAccess', _398 => _398.includes, 'call', _399 => _399(s.id)]));
-        const first = _optionalChain([source, 'access', _400 => _400[0], 'optionalAccess', _401 => _401.points, 'access', _402 => _402[0]]);
+        const source = c.getStrokes().filter((s) => _optionalChain([command, 'access', _484 => _484.replay, 'access', _485 => _485.strokeIds, 'optionalAccess', _486 => _486.includes, 'call', _487 => _487(s.id)]));
+        const first = _optionalChain([source, 'access', _488 => _488[0], 'optionalAccess', _489 => _489.points, 'access', _490 => _490[0]]);
         if (first) await this.glide(id, first);
         const result = c.replayStrokes(command.replay);
         if (result.bounds) await this.glide(id, centre(result.bounds), 520);
@@ -7228,7 +7972,7 @@ function createPaintStickerTools(c) {
             items: {
               type: "object",
               properties: {
-                stamp: { type: "string", enum: [..._chunk5BR7LC24cjs.STAMP_KINDS], description: "The stamp." },
+                stamp: { type: "string", enum: [..._chunk4T47Z4J3cjs.STAMP_KINDS], description: "The stamp." },
                 x: { type: "number", description: "Centre x in document pixels." },
                 y: { type: "number", description: "Centre y in document pixels." },
                 size: { type: "number", minimum: 2, maximum: 2048, description: "Diameter in pixels (default 48)." },
@@ -7258,7 +8002,7 @@ function createPaintStickerTools(c) {
         properties: {
           layerId: LAYER_ID,
           id: { type: "string", description: "Sticker id from list_stickers." },
-          stamp: { type: "string", enum: [..._chunk5BR7LC24cjs.STAMP_KINDS], description: "Another stamp." },
+          stamp: { type: "string", enum: [..._chunk4T47Z4J3cjs.STAMP_KINDS], description: "Another stamp." },
           x: { type: "number", description: "Centre x in document pixels." },
           y: { type: "number", description: "Centre y in document pixels." },
           size: { type: "number", minimum: 2, maximum: 2048, description: "Diameter in pixels." },
@@ -7796,7 +8540,7 @@ function createPaintWetTools(c) {
     {
       name: "advance_wet_paint",
       title: "Let the wet paint flow",
-      description: "Lets time pass for wet paint: the water spreads, runs downhill on a tilted canvas, granulates, blooms and evaporates, and pigment settles. Give steps (simulation steps; at the default 120 per second, 120 steps is one second) or seconds (default 1). Not an undo step, as time passing never is. Returns the steps run, the clock, stillWet and each wet layer\u2019s state. Paint dries by itself after a few thousand steps; dry_paint dries it at once.",
+      description: "Lets time pass for wet paint: the water spreads, runs downhill on a tilted canvas, granulates, blooms and evaporates, and pigment settles. Give steps (simulation steps; at the default 120 per second, 120 steps is one second) or seconds (default 1). Not an undo step, as time passing never is. Returns the steps run, the clock, stillWet and each wet layer\u2019s state. Paint dries by itself after a few thousand steps; dry_paint dries it at once. Wet light paint (wet brushes with light.amount) flows with the pigment and settles where it dries into the layer\u2019s light (get_light).",
       inputSchema: {
         type: "object",
         properties: {
@@ -7858,7 +8602,7 @@ function createPaintWetTools(c) {
         type: "object",
         properties: {
           layerId: LAYER_ID2,
-          kind: { type: "string", enum: [..._chunkXFYLA3ZOcjs.WET_FLOW_KINDS], description: "none, linear, swirl, radial or turbulent." },
+          kind: { type: "string", enum: [..._chunkVMROIWLLcjs.WET_FLOW_KINDS], description: "none, linear, swirl, radial or turbulent." },
           strength: UNIT("How hard it pushes, 0..1 (1 is about a 25\xB0 tilt; default 0.5)."),
           angle: { type: "number", minimum: -360, maximum: 360, description: "linear: direction in degrees clockwise from canvas down (default 0)." },
           center: {
@@ -7955,6 +8699,39 @@ var WRITE4 = { readOnlyHint: false, destructiveHint: false, idempotentHint: fals
 var LAYER_ID3 = { type: "string", description: "Pixel layer id from list_layers (default the active layer)." };
 function createPaintThickTools(c) {
   return [
+    {
+      name: "get_light",
+      title: "Read a layer\u2019s light paint",
+      description: "Reads a layer\u2019s light paint (laid by brushes with light.amount above 0): whether it has any, where it is (bounds, document pixels), its brightest value (peak 0..255) and its spill (radius px, strength). Changes nothing.",
+      inputSchema: { type: "object", properties: { layerId: LAYER_ID3 }, additionalProperties: false },
+      annotations: { title: "Read a layer\u2019s light paint", ...READ4 },
+      coordinates: { out: ["bounds"] },
+      handler: ({ layerId }) => c.lightOf(layerId)
+    },
+    {
+      name: "set_light_spill",
+      title: "Set how far a layer\u2019s light spills",
+      description: "Sets how far a layer\u2019s light paint spills onto the paint and paper around it, in each stroke\u2019s own colour: radius (px, 0 turns spill off, default 24) and strength (0..2, default 1). Nothing is repainted; saved with the document, not an undo step. Returns the layer\u2019s spill.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          layerId: LAYER_ID3,
+          radius: { type: "number", minimum: 0, maximum: 512, description: "How far the light reaches, px (0 turns spill off; default 24)." },
+          strength: { type: "number", minimum: 0, maximum: 2, description: "How strong the spill is, 0..2 (default 1)." }
+        },
+        additionalProperties: false
+      },
+      annotations: { title: "Set how far a layer\u2019s light spills", ...SET3 },
+      handler: ({ layerId, radius, strength }) => c.setLightSpill(layerId, { radius, strength })
+    },
+    {
+      name: "clear_light",
+      title: "Clear a layer\u2019s light",
+      description: "Takes a layer\u2019s light paint away; its paint keeps its colour (and relief). One undo step. Returns whether anything was cleared.",
+      inputSchema: { type: "object", properties: { layerId: LAYER_ID3 }, additionalProperties: false },
+      annotations: { title: "Clear a layer\u2019s light", ...WRITE4 },
+      handler: ({ layerId }) => c.clearLight(layerId)
+    },
     {
       name: "set_lighting",
       title: "Move the light",
@@ -8136,7 +8913,7 @@ var BEHAVIOR = {
       type: "object",
       description: "Multi-coloured brush (the older form of paint, the brush's own gradient: tip is across-tip, dab is distance in dabs or random). Read back from paint when it has a multi-colour equivalent. Missing fields keep their current values.",
       properties: {
-        mode: { type: "string", enum: [..._chunk5BR7LC24cjs.MULTI_COLOR_MODES], description: "off; tip: the colours lie side by side across the tip (stripes along the stroke, like a brush loaded with several paints); dab: the colour changes along the stroke." },
+        mode: { type: "string", enum: [..._chunk4T47Z4J3cjs.MULTI_COLOR_MODES], description: "off; tip: the colours lie side by side across the tip (stripes along the stroke, like a brush loaded with several paints); dab: the colour changes along the stroke." },
         colors: { type: "array", maxItems: 8, items: { ...COLOR3 }, description: "2..8 colours #rrggbb; fewer than 2 uses the paint colour and the secondary colour." },
         order: { type: "string", enum: ["sequence", "random"], description: "dab mode: sequence runs through the colours in order, blending between them; random picks one per run of dabs (seeded)." },
         length: { type: "integer", minimum: 1, maximum: 500, description: "dab mode: dabs per colour (default 12)." },
@@ -8177,10 +8954,10 @@ var WET_BRUSH = {
   properties: {
     tool: {
       type: "string",
-      enum: [..._chunk5BR7LC24cjs.WET_TOOLS],
+      enum: [..._chunk4T47Z4J3cjs.WET_TOOLS],
       description: "paint: water and pigment (picks up and mixes wet paint by behavior.pickup / mix); water: clear water (with rewet it lifts dried paint); dry: a hair dryer, takes water; blow: pushes the water along the stroke; blend: evens out wet pigment; smudge: drags wet paint; blot: a tissue, takes wet paint up (erase wet)."
     },
-    medium: { type: "string", enum: [..._chunk5BR7LC24cjs.WET_MEDIA], description: "The medium: watercolor, gouache or oil. A layer takes the medium's wet settings the first time it holds wet paint (oil: thick, barely flows, stays wet long and blends into the wet paint it meets)." },
+    medium: { type: "string", enum: [..._chunk4T47Z4J3cjs.WET_MEDIA], description: "The medium: watercolor, gouache or oil. A layer takes the medium's wet settings the first time it holds wet paint (oil: thick, barely flows, stays wet long and blends into the wet paint it meets)." },
     load: { type: "number", minimum: 0, maximum: 1, description: "Paint loading: 1 never runs out; lower, the brush runs dry along a long stroke (each stroke reloads)." },
     thinner: { type: "number", minimum: 0, maximum: 1, description: "Thinner (water or solvent): more transparent, runnier paint." },
     water: { type: "number", minimum: 0, maximum: 1, description: "Wetness: water laid per stroke, 0.2 a damp brush .. 1 a dripping one." },
@@ -8197,7 +8974,7 @@ var IMPASTO_BRUSH = {
   properties: {
     tool: {
       type: "string",
-      enum: [..._chunk5BR7LC24cjs.IMPASTO_TOOLS],
+      enum: [..._chunk4T47Z4J3cjs.IMPASTO_TOOLS],
       description: "brush: thick paint with bristle ridges along the stroke; tube: blobs squeezed from the tube; knife: a palette knife that scrapes the relief flat and smears the paint; roller: a flat stippled band; gloop: a thick, glossy, rounded bead."
     },
     thickness: { type: "number", minimum: 0, maximum: 1, description: "How far the paint stands up." },
@@ -8205,7 +8982,18 @@ var IMPASTO_BRUSH = {
     metallic: { type: "number", minimum: 0, maximum: 1, description: "Metallic paint: highlights take the paint colour (gold, copper, silver)." },
     load: { type: "number", minimum: 0, maximum: 1, description: "Paint loading: 1 never runs out; lower, the stroke thins and fades as the brush empties." },
     thinner: { type: "number", minimum: 0, maximum: 1, description: "Thinner: flatter, more transparent paint." },
-    drag: { type: "number", minimum: 0, maximum: 1, description: "Knife and brush: how much of the paint under the tool is dragged along." }
+    drag: { type: "number", minimum: 0, maximum: 1, description: "Knife and brush: how much of the paint under the tool is dragged along." },
+    rim: { type: "number", minimum: 0, maximum: 1, description: "Light paint (with light.amount): the bead's light is stronger where its surface turns away, as on backlit glass (default 0)." },
+    clarity: { type: "number", minimum: 0, maximum: 1, description: "Glassy paint: the middle of a bead lets the layers below show through while its edges stay solid (default 0). flatten_relief clears it." }
+  },
+  additionalProperties: false
+};
+var LIGHT_BRUSH = {
+  type: "object",
+  description: "Light paint: the light the brush lays with its colour, glowing in the paint's own colour and spilling onto its surroundings (set_light_spill). Dab, particle, bristle, Mixer Brush, impasto and wet paint brushes take it (wet light flows, pools, granulates and blooms with the pigment until the paint dries, then is ordinary light paint); wet tools other than paint lay none, and sticker brushes refuse light above 0. Missing fields keep their current values.",
+  properties: {
+    amount: { type: "number", minimum: 0, maximum: 1, description: "Light each dab lays, scaled by its coverage and flow (0 none, default; 1 full)." },
+    pressure: { type: "boolean", description: "Pressure scales the light (default false)." }
   },
   additionalProperties: false
 };
@@ -8213,8 +9001,8 @@ var PARTICLE_BRUSH = {
   type: "object",
   description: "Particle engine settings (procedural brushes). Missing fields keep their current values.",
   properties: {
-    kind: { type: "string", enum: [..._chunk5BR7LC24cjs.PARTICLE_KINDS], description: "string: strands of masses on springs dragged behind the pen (hair, fur, wet string); spring: particles on springs to the pen, overshooting and wobbling; orbit: particles circling the pen (curls); flow: particles thrown off the pen into a swirling flow until they fade." },
-    render: { type: "string", enum: [..._chunk5BR7LC24cjs.PARTICLE_RENDERS], description: "dot: a mark at each step; line: each particle draws a continuous line; sequence: beads spaced along each path." },
+    kind: { type: "string", enum: [..._chunk4T47Z4J3cjs.PARTICLE_KINDS], description: "string: strands of masses on springs dragged behind the pen (hair, fur, wet string); spring: particles on springs to the pen, overshooting and wobbling; orbit: particles circling the pen (curls); flow: particles thrown off the pen into a swirling flow until they fade." },
+    render: { type: "string", enum: [..._chunk4T47Z4J3cjs.PARTICLE_RENDERS], description: "dot: a mark at each step; line: each particle draws a continuous line; sequence: beads spaced along each path." },
     count: { type: "integer", minimum: 1, maximum: 64, description: "Particles (flow: how many are thrown per tip of travel)." },
     size: { type: "number", minimum: 0, maximum: 1, description: "Mark size as a fraction of the tip size." },
     spread: { type: "number", minimum: 0, maximum: 1, description: "How far apart the particles start, as a fraction of the tip size." },
@@ -8244,7 +9032,7 @@ var STICKER_BRUSH = {
   type: "object",
   description: "Sticker engine settings: stamps sprayed along the stroke as editable stickers. Missing fields keep their current values.",
   properties: {
-    stamps: { type: "array", minItems: 1, maxItems: 9, items: { type: "string", enum: [..._chunk5BR7LC24cjs.STAMP_KINDS], description: "A stamp." }, description: "The stamps to spray (one picked at random per sticker)." },
+    stamps: { type: "array", minItems: 1, maxItems: 9, items: { type: "string", enum: [..._chunk4T47Z4J3cjs.STAMP_KINDS], description: "A stamp." }, description: "The stamps to spray (one picked at random per sticker)." },
     density: { type: "number", minimum: 0, maximum: 1, description: "How closely stickers follow each other: about density \xD7 4 stickers per tip diameter of travel (0.25 \u2248 one per diameter, 1 \u2248 four). Default 0.4." },
     sizeJitter: { type: "number", minimum: 0, maximum: 1, description: "Random size change." },
     rotationJitter: { type: "number", minimum: 0, maximum: 1, description: "Random turn as a fraction of \xB1180\xB0." },
@@ -8255,16 +9043,16 @@ var STICKER_BRUSH = {
 };
 var BRUSH_FIELDS = {
   name: { type: "string", minLength: 1, maxLength: 80, description: "Display name." },
-  category: { type: "string", enum: [..._chunk5BR7LC24cjs.PAINT_BRUSH_CATEGORIES], description: "Library category." },
+  category: { type: "string", enum: [..._chunk4T47Z4J3cjs.PAINT_BRUSH_CATEGORIES], description: "Library category." },
   engine: {
     type: "string",
-    enum: [..._chunk5BR7LC24cjs.PAINT_BRUSH_ENGINES],
+    enum: [..._chunk4T47Z4J3cjs.PAINT_BRUSH_ENGINES],
     description: "dab: paints dabs (with behavior.pickup or gradient paint it paints dab by dab, lifting and mixing paint); eraser: removes paint; mixer: the Mixer Brush (a reservoir plus picked-up paint); blender: mixes the colours under and near the tip; smudge: drags paint along the stroke; wet: watercolour, gouache, oil and the wet tools on a simulated wet layer (see wet); impasto: thick paint with relief (see impasto); particle: procedural particle brushes (see particle); bristle: a tuft of bristles that bend and splay (see bristle); sticker: sprays editable sticker stamps (see sticker)."
   },
   tip: TIP,
   grain: { type: "number", minimum: 0, maximum: 1, description: "Paper grain response: 0 ignores the grain, 1 catches only its peaks at light pressure (pencil, pastel, charcoal). Multiplied by the paper depth." },
   pressureSmoothing: { type: "number", minimum: 0, maximum: 0.95, description: "Pressure smoothing, separate from the tip position smoothing." },
-  rotation: { type: "string", enum: [..._chunk5BR7LC24cjs.BRUSH_ROTATIONS], description: "What turns the tip: fixed (tip.angle), stroke (follows the direction of travel) or barrel (the pen barrel rotation, twist)." },
+  rotation: { type: "string", enum: [..._chunk4T47Z4J3cjs.BRUSH_ROTATIONS], description: "What turns the tip: fixed (tip.angle), stroke (follows the direction of travel) or barrel (the pen barrel rotation, twist)." },
   dynamics: DYNAMICS,
   mixer: MIXER,
   loadsColor: { type: "boolean", description: "Mixer engine: load the colour each stroke (false for a mixer that only moves paint)." },
@@ -8276,6 +9064,7 @@ var BRUSH_FIELDS = {
   particle: PARTICLE_BRUSH,
   bristle: BRISTLE_BRUSH,
   sticker: STICKER_BRUSH,
+  light: LIGHT_BRUSH,
   paint: BRUSH_PAINT
 };
 var TIME = { type: "number", minimum: 0, description: "Draw live effect paint (strokes on stroke layers painted with live effect paint) this many ms into its animation (default: as painted, its own time)." };
@@ -8315,12 +9104,13 @@ function brushSummary(b) {
     size: b.tip.size,
     grain: b.grain,
     rotation: b.rotation,
-    wetCapable: _chunk5BR7LC24cjs.isWetCapable.call(void 0, b),
+    wetCapable: _chunk4T47Z4J3cjs.isWetCapable.call(void 0, b),
     pickup: b.behavior.pickup,
     dirty: b.behavior.dirty,
     multicolor: b.behavior.multicolor.mode,
     ...b.engine === "wet" ? { wetTool: b.wet.tool, medium: b.wet.medium } : {},
     ...b.engine === "impasto" ? { impastoTool: b.impasto.tool } : {},
+    ...b.light.amount > 0 ? { light: b.light.amount } : {},
     builtin: Boolean(b.builtin)
   };
 }
@@ -8423,15 +9213,15 @@ function createPaintEditorToolProvider(controller, options = {}) {
     inputSchema: EMPTY3,
     annotations: { title: "List papers", ...READ6 },
     handler: () => ({
-      papers: _chunk5BR7LC24cjs.PAPER_LIBRARY.map((p) => ({ id: p.preset, name: p.name, family: p.family, pattern: p.pattern, color: p.color, depth: p.depth, absorption: p.absorption, permeability: p.permeability, roughness: p.roughness })),
-      families: [..._chunk5BR7LC24cjs.PAPER_FAMILIES],
+      papers: _chunk4T47Z4J3cjs.PAPER_LIBRARY.map((p) => ({ id: p.preset, name: p.name, family: p.family, pattern: p.pattern, color: p.color, depth: p.depth, absorption: p.absorption, permeability: p.permeability, roughness: p.roughness })),
+      families: [..._chunk4T47Z4J3cjs.PAPER_FAMILIES],
       patterns: [..._chunkPQ3H2AANcjs.GRAIN_PATTERNS]
     })
   });
   add({
     name: "get_paper",
     title: "Get the paper",
-    description: "Reads every setting of the current paper (preset, pattern, seed, colour, scale, tiling, depth, shading, dry and wet tuning, absorption, permeability, roughness).",
+    description: "Reads every setting of the current paper (preset, pattern, seed, colour, scale, tiling, depth, shading, dry and wet tuning, absorption, permeability, roughness, and metallic, backlight and backlightColor when set).",
     inputSchema: EMPTY3,
     annotations: { title: "Get the paper", ...READ6 },
     handler: () => JSON.parse(JSON.stringify(c.document.paper))
@@ -8447,7 +9237,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
   add({
     name: "set_paper",
     title: "Set the paper",
-    description: "Changes the paper under the whole painting: a preset from list_papers and / or its settings. Grain depth decides how much grain-responsive brushes (pencil, pastel, charcoal) skip the valleys; changing it re-renders the paper but not strokes already painted. One undo step. Returns the paper.",
+    description: "Changes the paper under the whole painting: a preset from list_papers and / or its settings. Grain depth decides how much grain-responsive brushes (pencil, pastel, charcoal) skip the valleys; changing it re-renders the paper but not strokes already painted. backlight lights the paper from behind (the stained-glass preset has it on). One undo step. Returns the paper.",
     inputSchema: {
       type: "object",
       properties: {
@@ -8465,6 +9255,8 @@ function createPaintEditorToolProvider(controller, options = {}) {
         permeability: { type: "number", minimum: 0, maximum: 1, description: "Wet media: how freely water flows over the fibres (low: more ragged, slower spreading)." },
         roughness: { type: "number", minimum: 0, maximum: 1, description: "Wet media: how much the grain pins wet edges and catches granulating pigment." },
         metallic: { type: "number", minimum: 0, maximum: 1, description: "Metallic paper (gold or silver leaf, pearlescent card): the grain catches the light (see set_lighting). 0 by default." },
+        backlight: { type: "number", minimum: 0, maximum: 1, description: "Backlit paper (a lightbox, stained glass): light from behind the paper, 0 (none, the default) .. 1. Transparent glazes (watercolour, airbrush, thin marker) glow in their own colour; opaque paint (gouache, oil, solid ink) and thick paint block it; the light through paint spills softly around it. Nothing is repainted." },
+        backlightColor: { ...COLOR3, description: "The backlight\u2019s colour #rrggbb (default #fff1d6, warm white)." },
         name: { type: "string", minLength: 1, description: "Display name." }
       },
       additionalProperties: false
@@ -8639,12 +9431,12 @@ function createPaintEditorToolProvider(controller, options = {}) {
   add({
     name: "list_brushes",
     title: "List brushes",
-    description: "Lists the brush library: built-in dry media (pencils, pastels, charcoal, airbrush, marker, ink, erasers), paint brushes (dirty round, multi-colour flat, palette dabber), blending tools (blender, smudge, pigment smudge, Mixer Brush) and saved user brushes, with id, name, category, engine, size, grain response, rotation mode, whether it can pick up paint (wetCapable), its pick-up ratio, dirty and multi-colour mode, plus the active brush id.",
+    description: "Lists the brush library: built-in dry media (pencils, pastels, charcoal, airbrush, marker, ink, erasers), paint brushes (dirty round, multi-colour flat, palette dabber), blending tools (blender, smudge, pigment smudge, Mixer Brush), light paint (category light: glow gel, neon marker, light airbrush, spark trail, glow wash; light is the amount they lay) and saved user brushes, with id, name, category, engine, size, grain response, rotation mode, whether it can pick up paint (wetCapable), its pick-up ratio, dirty and multi-colour mode, plus the active brush id.",
     inputSchema: EMPTY3,
     annotations: { title: "List brushes", ...READ6 },
     handler: () => {
       const s = c.getState();
-      return { activeBrushId: s.brush.id, activeEdited: !s.brush.builtin && Boolean(_optionalChain([c, 'access', _403 => _403.getBrush, 'call', _404 => _404(s.brush.id), 'optionalAccess', _405 => _405.builtin])), brushes: s.brushes.map(brushSummary) };
+      return { activeBrushId: s.brush.id, activeEdited: !s.brush.builtin && Boolean(_optionalChain([c, 'access', _491 => _491.getBrush, 'call', _492 => _492(s.brush.id), 'optionalAccess', _493 => _493.builtin])), brushes: s.brushes.map(brushSummary) };
     }
   });
   add({
@@ -8655,10 +9447,10 @@ function createPaintEditorToolProvider(controller, options = {}) {
     annotations: { title: "Get a brush", ...READ6 },
     handler: ({ id }) => {
       const st = c.getState();
-      if (id === void 0) return { ..._chunk5BR7LC24cjs.brushToJSON.call(void 0, st.brush), strokePaint: _nullishCoalesce(st.brush.paint, () => ( st.paint)) };
+      if (id === void 0) return { ..._chunk4T47Z4J3cjs.brushToJSON.call(void 0, st.brush), strokePaint: _nullishCoalesce(st.brush.paint, () => ( st.paint)) };
       const b = c.getBrush(id);
       if (!b) throw new Error(`Unknown brush "${id}". Call list_brushes for the ids.`);
-      return { ..._chunk5BR7LC24cjs.brushToJSON.call(void 0, b), builtin: Boolean(b.builtin), strokePaint: _nullishCoalesce(b.paint, () => ( st.paint)) };
+      return { ..._chunk4T47Z4J3cjs.brushToJSON.call(void 0, b), builtin: Boolean(b.builtin), strokePaint: _nullishCoalesce(b.paint, () => ( st.paint)) };
     }
   });
   add({
@@ -8667,7 +9459,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     description: "Chooses the active brush (id) and / or changes its settings; strokes without a brush use it. Editor state, not an undo step. Changes stay on the active brush until save_brush stores them. Returns the active brush.",
     inputSchema: { type: "object", properties: { id: { type: "string", description: "Brush id from list_brushes to start from." }, ...BRUSH_FIELDS }, additionalProperties: false },
     annotations: { title: "Set the brush", ...SET4 },
-    handler: (a) => _chunk5BR7LC24cjs.brushToJSON.call(void 0, c.setBrush(a))
+    handler: (a) => _chunk4T47Z4J3cjs.brushToJSON.call(void 0, c.setBrush(a))
   });
   add({
     name: "save_brush",
@@ -8683,7 +9475,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       additionalProperties: false
     },
     annotations: { title: "Save a brush", ...SET4 },
-    handler: ({ id, name }) => _chunk5BR7LC24cjs.brushToJSON.call(void 0, c.saveBrush({ id, name }))
+    handler: ({ id, name }) => _chunk4T47Z4J3cjs.brushToJSON.call(void 0, c.saveBrush({ id, name }))
   });
   add({
     name: "remove_brush",
@@ -8823,7 +9615,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
   add({
     name: "paint_stroke",
     title: "Paint a brush stroke",
-    description: "Paints one stroke through points (document pixels, with optional pressure, time, tilt and barrel rotation) on a pixel layer with a library brush or the active one, optionally changed for this stroke. Grain-responsive brushes follow the paper; the mixer engine (mixer-brush) picks up and mixes paint already on the layer, the blender mixes nearby colours, the smudge drags paint, and dab brushes with behavior.pickup lift and carry paint, and wet brushes (engine wet: watercolour, gouache, add water, dry, blow, wet blend, wet smudge, blot) paint on the layer\u2019s wet layer, where the paint keeps moving until it dries (the result says wet: true while it is; see advance_wet_paint and dry_paint; a dry brush on wet paint dries it first; wet oil brushes blend into the wet oil they meet), impasto brushes (engine impasto: impasto brush, paint tube, palette knife, roller, gloop pen, metallic paint) lay thick paint whose relief is lit by set_lighting, particle and bristle brushes draw procedural marks, and sticker brushes spray editable stickers onto an empty or sticker layer (list_stickers). Guide stencils make strokes that start near them follow them; mask stencils keep paint inside them. The symmetry guide adds its mirror copies; with a tracing image that samples colours, a stroke without color takes the image colour at its first point. With an agent cursor (a director), the stroke is painted live along the points at the pace of their times. One undo step. Returns the layer id, changed bounds, dab count, the recorded strokeId (for replay_strokes), for wet brushes wet (paint still wet) and, for brushes that pick up paint, mixerLoad: what the brush carries after the stroke.",
+    description: "Paints one stroke through points (document pixels, with optional pressure, time, tilt and barrel rotation) on a pixel layer with a library brush or the active one, optionally changed for this stroke. Grain-responsive brushes follow the paper; the mixer engine (mixer-brush) picks up and mixes paint already on the layer, the blender mixes nearby colours, the smudge drags paint, and dab brushes with behavior.pickup lift and carry paint, and wet brushes (engine wet: watercolour, gouache, add water, dry, blow, wet blend, wet smudge, blot) paint on the layer\u2019s wet layer, where the paint keeps moving until it dries (the result says wet: true while it is; see advance_wet_paint and dry_paint; a dry brush on wet paint dries it first; wet oil brushes blend into the wet oil they meet; with light.amount, as glow-wash has, their light flows with the paint), impasto brushes (engine impasto: impasto brush, paint tube, palette knife, roller, gloop pen, metallic paint) lay thick paint whose relief is lit by set_lighting, particle and bristle brushes draw procedural marks, and sticker brushes spray editable stickers onto an empty or sticker layer (list_stickers). Guide stencils make strokes that start near them follow them; mask stencils keep paint inside them. The symmetry guide adds its mirror copies; with a tracing image that samples colours, a stroke without color takes the image colour at its first point. With an agent cursor (a director), the stroke is painted live along the points at the pace of their times. One undo step. Returns the layer id, changed bounds, dab count, the recorded strokeId (for replay_strokes), for wet brushes wet (paint still wet) and, for brushes that pick up paint, mixerLoad: what the brush carries after the stroke.",
     inputSchema: {
       type: "object",
       properties: {
@@ -8874,7 +9666,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
       if (ids) {
         for (const id of ids) if (!all.some((s) => s.id === id)) throw new Error(`Unknown stroke "${id}". Call list_strokes without ids for the ids.`);
       }
-      return { total: all.length, strokes: picked.map((s) => strokeSummary(s, Boolean(ids), live ? true : liveIds.has(s.id) && _optionalChain([c, 'access', _406 => _406.document, 'access', _407 => _407.liveStrokes, 'optionalAccess', _408 => _408[s.layerId], 'optionalAccess', _409 => _409.includes, 'call', _410 => _410(s)]) === true)) };
+      return { total: all.length, strokes: picked.map((s) => strokeSummary(s, Boolean(ids), live ? true : liveIds.has(s.id) && _optionalChain([c, 'access', _494 => _494.document, 'access', _495 => _495.liveStrokes, 'optionalAccess', _496 => _496[s.layerId], 'optionalAccess', _497 => _497.includes, 'call', _498 => _498(s)]) === true)) };
     }
   });
   add({
@@ -9150,7 +9942,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
   tools.push(...createPaintThickTools(c));
   tools.push(...createPaintReplayTools(c));
   tools.push(...createPaintStickerTools(c));
-  tools.push(..._chunkXFYLA3ZOcjs.createPigmentTools.call(void 0, ));
+  tools.push(..._chunkVMROIWLLcjs.createPigmentTools.call(void 0, ));
   const exclude = new Set(_nullishCoalesce(options.exclude, () => ( [])));
   const description = "Natural-media painting: paper and grain, dry and wet brushes, the brush library, strokes as data, pigment mixing, stencils, guides, layers and export.";
   return withPaintPlayback({
@@ -9164,16 +9956,16 @@ function createPaintEditorToolProvider(controller, options = {}) {
 }
 function hostTool({ coordinates, ...tool }, { origin, onChange }) {
   if (!origin && !onChange) return tool;
-  const write = !_optionalChain([tool, 'access', _411 => _411.annotations, 'optionalAccess', _412 => _412.readOnlyHint]);
+  const write = !_optionalChain([tool, 'access', _499 => _499.annotations, 'optionalAccess', _500 => _500.readOnlyHint]);
   const done = (result) => {
-    if (write) _optionalChain([onChange, 'optionalCall', _413 => _413({ tool: tool.name })]);
-    return origin && _optionalChain([coordinates, 'optionalAccess', _414 => _414.out]) ? fromDocument(result, coordinates.out, origin) : result;
+    if (write) _optionalChain([onChange, 'optionalCall', _501 => _501({ tool: tool.name })]);
+    return origin && _optionalChain([coordinates, 'optionalAccess', _502 => _502.out]) ? fromDocument(result, coordinates.out, origin) : result;
   };
   return {
     ...tool,
     ...origin ? { description: hostedText(_nullishCoalesce(tool.description, () => ( ""))), inputSchema: hostedSchema(tool.inputSchema) } : {},
     handler: (args, context) => {
-      const r = tool.handler(origin && _optionalChain([coordinates, 'optionalAccess', _415 => _415.in]) ? toDocument(args, coordinates.in, origin) : args, context);
+      const r = tool.handler(origin && _optionalChain([coordinates, 'optionalAccess', _503 => _503.in]) ? toDocument(args, coordinates.in, origin) : args, context);
       return r instanceof Promise ? r.then(done) : done(r);
     }
   };
@@ -9190,7 +9982,7 @@ function strokeSummary(s, withPoints, live) {
     color: s.color,
     points: withPoints ? s.points : s.points.length,
     seed: s.seed,
-    copies: _nullishCoalesce(_optionalChain([s, 'access', _416 => _416.copies, 'optionalAccess', _417 => _417.length]), () => ( 0)),
+    copies: _nullishCoalesce(_optionalChain([s, 'access', _504 => _504.copies, 'optionalAccess', _505 => _505.length]), () => ( 0)),
     live,
     bounds: { x: Math.floor(Math.min(...xs) - pad), y: Math.floor(Math.min(...ys) - pad), width: Math.ceil(Math.max(...xs) - Math.min(...xs) + 2 * pad), height: Math.ceil(Math.max(...ys) - Math.min(...ys) + 2 * pad) }
   };
@@ -9205,21 +9997,21 @@ var PAINT_TOOLS = [
   { id: "pan", label: "Pan", key: "h" },
   { id: "rotate", label: "Rotate view", key: "r" }
 ];
-var PaintGesture = (_class11 = class {
-  constructor(controller, box) {;_class11.prototype.__init125.call(this);_class11.prototype.__init126.call(this);_class11.prototype.__init127.call(this);_class11.prototype.__init128.call(this);_class11.prototype.__init129.call(this);_class11.prototype.__init130.call(this);
+var PaintGesture = (_class13 = class {
+  constructor(controller, box) {;_class13.prototype.__init137.call(this);_class13.prototype.__init138.call(this);_class13.prototype.__init139.call(this);_class13.prototype.__init140.call(this);_class13.prototype.__init141.call(this);_class13.prototype.__init142.call(this);
     this.controller = controller;
     this.box = box;
   }
   
   
-  __init125() {this.tool = "brush"}
+  __init137() {this.tool = "brush"}
   /** The last refusal (a hidden or locked layer), for the editor to show. */
-  __init126() {this.error = null}
+  __init138() {this.error = null}
   /** The predicted tail of the current stroke in document pixels (draw it as a thin preview). */
-  __init127() {this.predicted = []}
-  __init128() {this.mode = null}
-  __init129() {this.penAt = null}
-  __init130() {this.penDown = false}
+  __init139() {this.predicted = []}
+  __init140() {this.mode = null}
+  __init141() {this.penAt = null}
+  __init142() {this.penDown = false}
   doc(e) {
     const b = this.box();
     const s = this.controller.getState();
@@ -9275,13 +10067,13 @@ var PaintGesture = (_class11 = class {
     const p = this.doc(e);
     const s = this.controller.getState();
     const layerId = s.document.activeLayerId;
-    if (!layerId || !_optionalChain([s, 'access', _418 => _418.document, 'access', _419 => _419.liveStrokes, 'optionalAccess', _420 => _420[layerId]])) {
+    if (!layerId || !_optionalChain([s, 'access', _506 => _506.document, 'access', _507 => _507.liveStrokes, 'optionalAccess', _508 => _508[layerId]])) {
       this.error = "Pick a stroke layer in the Layers panel (or add one) to select its strokes.";
       return false;
     }
     try {
       const hit = this.controller.liveStrokeAt(layerId, p.x, p.y);
-      this.controller.selectStroke(_nullishCoalesce(_optionalChain([hit, 'optionalAccess', _421 => _421.id]), () => ( null)));
+      this.controller.selectStroke(_nullishCoalesce(_optionalChain([hit, 'optionalAccess', _509 => _509.id]), () => ( null)));
       if (!hit) return false;
       this.mode = { kind: "move-stroke", pointerId: e.pointerId, id: hit.id, from: p, to: p };
       return true;
@@ -9293,7 +10085,7 @@ var PaintGesture = (_class11 = class {
   /** While a stroke is dragged: how far it has moved (document pixels), to draw its outline there. */
   get strokeDrag() {
     const m = this.mode;
-    return _optionalChain([m, 'optionalAccess', _422 => _422.kind]) === "move-stroke" ? { id: m.id, dx: m.to.x - m.from.x, dy: m.to.y - m.from.y } : null;
+    return _optionalChain([m, 'optionalAccess', _510 => _510.kind]) === "move-stroke" ? { id: m.id, dx: m.to.x - m.from.x, dy: m.to.y - m.from.y } : null;
   }
   /**
    * The Stickers tool: pressing a sticker picks it and dragging moves it (one undo step at the
@@ -9367,7 +10159,7 @@ var PaintGesture = (_class11 = class {
     if (!m || m.pointerId !== e.pointerId) return;
     this.mode = null;
     this.predicted = [];
-    if (m.kind === "stroke") _optionalChain([this, 'access', _423 => _423.controller, 'access', _424 => _424.activeStroke, 'optionalAccess', _425 => _425.end, 'call', _426 => _426()]);
+    if (m.kind === "stroke") _optionalChain([this, 'access', _511 => _511.controller, 'access', _512 => _512.activeStroke, 'optionalAccess', _513 => _513.end, 'call', _514 => _514()]);
     if (m.kind === "move-stroke") {
       const dx = Math.round((this.doc(e).x - m.from.x) * 100) / 100;
       const dy = Math.round((this.doc(e).y - m.from.y) * 100) / 100;
@@ -9391,8 +10183,8 @@ var PaintGesture = (_class11 = class {
   cancel() {
     this.penDown = false;
     this.predicted = [];
-    if (_optionalChain([this, 'access', _427 => _427.mode, 'optionalAccess', _428 => _428.kind]) === "stroke") _optionalChain([this, 'access', _429 => _429.controller, 'access', _430 => _430.activeStroke, 'optionalAccess', _431 => _431.cancel, 'call', _432 => _432()]);
-    if (_optionalChain([this, 'access', _433 => _433.mode, 'optionalAccess', _434 => _434.kind]) === "sticker") this.controller.cancelStickerPreview();
+    if (_optionalChain([this, 'access', _515 => _515.mode, 'optionalAccess', _516 => _516.kind]) === "stroke") _optionalChain([this, 'access', _517 => _517.controller, 'access', _518 => _518.activeStroke, 'optionalAccess', _519 => _519.cancel, 'call', _520 => _520()]);
+    if (_optionalChain([this, 'access', _521 => _521.mode, 'optionalAccess', _522 => _522.kind]) === "sticker") this.controller.cancelStickerPreview();
     this.mode = null;
   }
   get active() {
@@ -9412,7 +10204,7 @@ var PaintGesture = (_class11 = class {
     const py = e.clientY - b.top - b.height / 2;
     this.controller.setView({ zoom, pan: { x: px - (px - s.view.pan.x) * k, y: py - (py - s.view.pan.y) * k } });
   }
-}, _class11);
+}, _class13);
 var round2 = (v) => Math.round(v * 100) / 100;
 function handlePaintShortcut(controller, gesture, e) {
   const mod = e.ctrlKey || e.metaKey;
@@ -9453,14 +10245,14 @@ function handlePaintShortcut(controller, gesture, e) {
   }
   return false;
 }
-var PaintCanvasPresenter = (_class12 = class {
-  constructor(controller) {;_class12.prototype.__init131.call(this);_class12.prototype.__init132.call(this);_class12.prototype.__init133.call(this);
+var PaintCanvasPresenter = (_class14 = class {
+  constructor(controller) {;_class14.prototype.__init143.call(this);_class14.prototype.__init144.call(this);_class14.prototype.__init145.call(this);
     this.controller = controller;
   }
   
-  __init131() {this.uploaded = /* @__PURE__ */ new Map()}
-  __init132() {this.scratch = null}
-  __init133() {this.size = ""}
+  __init143() {this.uploaded = /* @__PURE__ */ new Map()}
+  __init144() {this.scratch = null}
+  __init145() {this.size = ""}
   /** Draws what changed into `ctx` (a canvas the size of the document); returns the tiles drawn. */
   render(ctx) {
     const { width, height } = this.controller.document.canvas;
@@ -9486,13 +10278,13 @@ var PaintCanvasPresenter = (_class12 = class {
     }, { dirty });
     return drawn;
   }
-}, _class12);
+}, _class14);
 function guideOverlay(controller, drag) {
   const s = controller.getState();
   const size = s.document.canvas;
   const out = [];
   const layerId = s.document.activeLayerId;
-  const strokePicked = layerId && s.selectedStroke ? _optionalChain([s, 'access', _435 => _435.document, 'access', _436 => _436.liveStrokes, 'optionalAccess', _437 => _437[layerId], 'optionalAccess', _438 => _438.some, 'call', _439 => _439((x) => x.id === s.selectedStroke)]) : false;
+  const strokePicked = layerId && s.selectedStroke ? _optionalChain([s, 'access', _523 => _523.document, 'access', _524 => _524.liveStrokes, 'optionalAccess', _525 => _525[layerId], 'optionalAccess', _526 => _526.some, 'call', _527 => _527((x) => x.id === s.selectedStroke)]) : false;
   const area = strokePicked ? controller.liveStrokeArea(s.selectedStroke) : null;
   if (area) {
     const dx = drag && drag.id === s.selectedStroke ? drag.dx : 0;
@@ -9505,7 +10297,7 @@ function guideOverlay(controller, drag) {
     ];
     for (let i = 0; i < 4; i++) out.push({ from: box[i], to: box[(i + 1) % 4], kind: "stroke" });
   }
-  const picked = layerId && s.selectedSticker ? _optionalChain([s, 'access', _440 => _440.document, 'access', _441 => _441.stickers, 'optionalAccess', _442 => _442[layerId], 'optionalAccess', _443 => _443.find, 'call', _444 => _444((x) => x.id === s.selectedSticker)]) : void 0;
+  const picked = layerId && s.selectedSticker ? _optionalChain([s, 'access', _528 => _528.document, 'access', _529 => _529.stickers, 'optionalAccess', _530 => _530[layerId], 'optionalAccess', _531 => _531.find, 'call', _532 => _532((x) => x.id === s.selectedSticker)]) : void 0;
   if (picked) {
     const r = picked.size / 2 + 2;
     const a = picked.rotation * Math.PI / 180;
@@ -9545,11 +10337,12 @@ var PAPER_SLIDERS = [
   { path: "absorption", label: "Absorption", min: 0, max: 1, step: 0.01 },
   { path: "permeability", label: "Permeability", min: 0, max: 1, step: 0.01 },
   { path: "roughness", label: "Roughness", min: 0, max: 1, step: 0.01 },
-  { path: "metallic", label: "Metallic", min: 0, max: 1, step: 0.01 }
+  { path: "metallic", label: "Metallic", min: 0, max: 1, step: 0.01 },
+  { path: "backlight", label: "Backlight", min: 0, max: 1, step: 0.01 }
 ];
 function readPath(obj, path) {
   let v = obj;
-  for (const k of path.split(".")) v = _optionalChain([v, 'optionalAccess', _445 => _445[k]]);
+  for (const k of path.split(".")) v = _optionalChain([v, 'optionalAccess', _533 => _533[k]]);
   return typeof v === "number" ? v : 0;
 }
 function patchPath(obj, path, value) {
@@ -9594,11 +10387,19 @@ var BLEND_MENU_GROUPS = [
   { label: "Standard", modes: _chunkOLNIPTB3cjs.BLEND_MODES.filter((m) => !m.painterly && m.id !== "pigment") },
   { label: "Paint", modes: _chunkOLNIPTB3cjs.BLEND_MODES.filter((m) => m.painterly || m.id === "pigment") }
 ];
+var LIGHT_SLIDER = { path: "light.amount", label: "Light", min: 0, max: 1, step: 0.01 };
 var PICKUP_SLIDERS = [
   { path: "behavior.pickup", label: "Pick-up", min: 0, max: 1, step: 0.01 },
   { path: "behavior.mix", label: "Mix", min: 0, max: 1, step: 0.01 }
 ];
 function brushEngineControls(brush) {
+  const c = engineControls(brush);
+  const wetPaint = brush.engine === "wet" && _optionalChain([brush, 'access', _534 => _534.wet, 'optionalAccess', _535 => _535.tool]) === "paint";
+  if (!c || !(wetPaint || ["dab", "mixer", "particle", "bristle", "impasto"].includes(brush.engine))) return c;
+  const extra = brush.engine === "impasto" ? [{ path: "impasto.rim", label: "Rim", min: 0, max: 1, step: 0.01 }, { path: "impasto.clarity", label: "Clarity", min: 0, max: 1, step: 0.01 }] : [];
+  return { ...c, sliders: [...c.sliders, LIGHT_SLIDER, ...extra], light: true };
+}
+function engineControls(brush) {
   switch (brush.engine) {
     case "particle":
       return {
@@ -9671,7 +10472,7 @@ function brushEngineControls(brush) {
         impastoTool: true
       };
     case "wet": {
-      const tool = _nullishCoalesce(_optionalChain([brush, 'access', _446 => _446.wet, 'optionalAccess', _447 => _447.tool]), () => ( "paint"));
+      const tool = _nullishCoalesce(_optionalChain([brush, 'access', _536 => _536.wet, 'optionalAccess', _537 => _537.tool]), () => ( "paint"));
       const sliders = tool === "paint" ? [
         { path: "wet.water", label: "Water", min: 0, max: 1, step: 0.01 },
         { path: "wet.pigment", label: "Pigment", min: 0, max: 1, step: 0.01 },
@@ -9804,7 +10605,7 @@ function startWetClock(controller, frame, cancel) {
   id = raf(loop);
   return () => {
     stopped = true;
-    _optionalChain([caf, 'optionalCall', _448 => _448(id)]);
+    _optionalChain([caf, 'optionalCall', _538 => _538(id)]);
   };
 }
 function drawWaterOverlay(controller, ctx) {
@@ -10450,4 +11251,9 @@ function createPaintEditorDocument(controller, options = {}) {
 
 
 
-exports.BLEND_MENU_GROUPS = BLEND_MENU_GROUPS; exports.BLEND_MODES = _chunkOLNIPTB3cjs.BLEND_MODES; exports.BRUSH_ID = _chunk5BR7LC24cjs.BRUSH_ID; exports.BRUSH_ROTATIONS = _chunk5BR7LC24cjs.BRUSH_ROTATIONS; exports.BRUSH_SLIDERS = BRUSH_SLIDERS; exports.BUILTIN_BRUSHES = _chunk5BR7LC24cjs.BUILTIN_BRUSHES; exports.BristleStroke = _chunk5BR7LC24cjs.BristleStroke; exports.DEFAULT_BEHAVIOR = _chunk5BR7LC24cjs.DEFAULT_BEHAVIOR; exports.DEFAULT_BRISTLE = _chunk5BR7LC24cjs.DEFAULT_BRISTLE; exports.DEFAULT_BRUSH_ID = _chunk5BR7LC24cjs.DEFAULT_BRUSH_ID; exports.DEFAULT_DPI = DEFAULT_DPI; exports.DEFAULT_DYNAMICS = _chunk5BR7LC24cjs.DEFAULT_DYNAMICS; exports.DEFAULT_FLOW = _chunkXFYLA3ZOcjs.DEFAULT_FLOW; exports.DEFAULT_IMPASTO = _chunk5BR7LC24cjs.DEFAULT_IMPASTO; exports.DEFAULT_LIGHTING = DEFAULT_LIGHTING; exports.DEFAULT_MULTI_COLOR = _chunk5BR7LC24cjs.DEFAULT_MULTI_COLOR; exports.DEFAULT_PAINT_GRADIENT = _chunkPQ3H2AANcjs.DEFAULT_PAINT_GRADIENT; exports.DEFAULT_PAINT_GRADIENT_MAPPING = _chunkPQ3H2AANcjs.DEFAULT_PAINT_GRADIENT_MAPPING; exports.DEFAULT_PAPER = _chunk5BR7LC24cjs.DEFAULT_PAPER; exports.DEFAULT_PARTICLE = _chunk5BR7LC24cjs.DEFAULT_PARTICLE; exports.DEFAULT_STICKER = _chunk5BR7LC24cjs.DEFAULT_STICKER; exports.DEFAULT_SWATCHES = DEFAULT_SWATCHES; exports.DEFAULT_VIEW = DEFAULT_VIEW; exports.DEFAULT_WET_BRUSH = _chunk5BR7LC24cjs.DEFAULT_WET_BRUSH; exports.DEFAULT_WET_PARAMS = _chunkXFYLA3ZOcjs.DEFAULT_WET_PARAMS; exports.DryStroke = _chunk5BR7LC24cjs.DryStroke; exports.EFFECT_MAP_REPEATS = _chunk5BR7LC24cjs.EFFECT_MAP_REPEATS; exports.EFFECT_STRIP_HEIGHT = _chunk5BR7LC24cjs.EFFECT_STRIP_HEIGHT; exports.GPU_LEAD = GPU_LEAD; exports.GRAIN_PATTERNS = _chunkPQ3H2AANcjs.GRAIN_PATTERNS; exports.GRAIN_TILE = _chunkPQ3H2AANcjs.GRAIN_TILE; exports.HARMONY_KINDS = _chunk7PT4RJL5cjs.HARMONY_KINDS; exports.IDENTITY_AFFINE = IDENTITY_AFFINE; exports.IDENTITY_COPY = _chunk5BR7LC24cjs.IDENTITY_COPY; exports.IMPASTO_TOOLS = _chunk5BR7LC24cjs.IMPASTO_TOOLS; exports.IMPASTO_TOOL_LABELS = IMPASTO_TOOL_LABELS; exports.LIGHT_SLIDERS = LIGHT_SLIDERS; exports.LIVE_STROKE_ENGINES = LIVE_STROKE_ENGINES; exports.LitCache = LitCache; exports.MAX_BRUSH_SIZE = _chunkPQ3H2AANcjs.MAX_BRUSH_SIZE; exports.MAX_CANVAS_SIDE = MAX_CANVAS_SIDE; exports.MAX_COORDINATE = MAX_COORDINATE; exports.MAX_IMAGE_SIDE = MAX_IMAGE_SIDE; exports.MAX_LIVE_EFFECT_SOURCES = MAX_LIVE_EFFECT_SOURCES; exports.MAX_ZOOM = MAX_ZOOM; exports.MIN_CANVAS_SIDE = MIN_CANVAS_SIDE; exports.MIN_ZOOM = MIN_ZOOM; exports.MIXING_PAD_HEIGHT = MIXING_PAD_HEIGHT; exports.MIXING_PAD_WIDTH = MIXING_PAD_WIDTH; exports.MULTI_COLOR_MODES = _chunk5BR7LC24cjs.MULTI_COLOR_MODES; exports.MixingPad = MixingPad; exports.PAD_SAMPLE_SIZES = PAD_SAMPLE_SIZES; exports.PAINTERLY_BLEND_MODES = _chunkOLNIPTB3cjs.PAINTERLY_BLEND_MODES; exports.PAINT_BRUSH_CATEGORIES = _chunk5BR7LC24cjs.PAINT_BRUSH_CATEGORIES; exports.PAINT_BRUSH_ENGINES = _chunk5BR7LC24cjs.PAINT_BRUSH_ENGINES; exports.PAINT_COLOR_JSON_SCHEMA = _chunkPQ3H2AANcjs.PAINT_COLOR_JSON_SCHEMA; exports.PAINT_EFFECT_PLACES = PAINT_EFFECT_PLACES; exports.PAINT_FORMAT = PAINT_FORMAT; exports.PAINT_GRADIENT_FULL_SPEED = _chunkPQ3H2AANcjs.PAINT_GRADIENT_FULL_SPEED; exports.PAINT_GRADIENT_JSON_SCHEMA = _chunkPQ3H2AANcjs.PAINT_GRADIENT_JSON_SCHEMA; exports.PAINT_GRADIENT_KIT = _chunkPQ3H2AANcjs.PAINT_GRADIENT_KIT; exports.PAINT_GRADIENT_MAPPINGS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_MAPPINGS; exports.PAINT_GRADIENT_MAPPING_LABELS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_MAPPING_LABELS; exports.PAINT_GRADIENT_PRESETS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_PRESETS; exports.PAINT_GRADIENT_REPEATS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_REPEATS; exports.PAINT_GRADIENT_REPEAT_LABELS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_REPEAT_LABELS; exports.PAINT_GRADIENT_SPACES = _chunkPQ3H2AANcjs.PAINT_GRADIENT_SPACES; exports.PAINT_GRADIENT_SPACE_LABELS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_SPACE_LABELS; exports.PAINT_SCHEMA_VERSION = PAINT_SCHEMA_VERSION; exports.PAINT_SOURCE_JSON_SCHEMA = _chunkPQ3H2AANcjs.PAINT_SOURCE_JSON_SCHEMA; exports.PAINT_TARGET = PAINT_TARGET; exports.PAINT_TOOLS = PAINT_TOOLS; exports.PAPER_EFFECT_BLENDS = PAPER_EFFECT_BLENDS; exports.PAPER_EFFECT_NODE_ID = PAPER_EFFECT_NODE_ID; exports.PAPER_FAMILIES = _chunk5BR7LC24cjs.PAPER_FAMILIES; exports.PAPER_LIBRARY = _chunk5BR7LC24cjs.PAPER_LIBRARY; exports.PAPER_NODE_ID = PAPER_NODE_ID; exports.PAPER_SLIDERS = PAPER_SLIDERS; exports.PAPER_TARGET = PAPER_TARGET; exports.PARTICLE_KINDS = _chunk5BR7LC24cjs.PARTICLE_KINDS; exports.PARTICLE_KIND_LABELS = PARTICLE_KIND_LABELS; exports.PARTICLE_RENDERS = _chunk5BR7LC24cjs.PARTICLE_RENDERS; exports.PARTICLE_RENDER_LABELS = PARTICLE_RENDER_LABELS; exports.PaintCanvasPresenter = PaintCanvasPresenter; exports.PaintDabStroke = PaintDabStroke; exports.PaintDirector = PaintDirector; exports.PaintDocumentError = PaintDocumentError; exports.PaintEditorController = PaintEditorController; exports.PaintEditorError = PaintEditorError; exports.PaintEffectsRenderer = PaintEffectsRenderer; exports.PaintGesture = PaintGesture; exports.PaintGradientSampler = _chunkPQ3H2AANcjs.PaintGradientSampler; exports.PaintPresence = PaintPresence; exports.PaintSourceError = _chunkPQ3H2AANcjs.PaintSourceError; exports.PaintStrokeSession = PaintStrokeSession; exports.PaintWetLayers = PaintWetLayers; exports.PaperGrain = _chunkPQ3H2AANcjs.PaperGrain; exports.ParticleStroke = _chunk5BR7LC24cjs.ParticleStroke; exports.PenDabWalker = _chunk5BR7LC24cjs.PenDabWalker; exports.PenSmoother = _chunk5BR7LC24cjs.PenSmoother; exports.PerspectiveSnapper = PerspectiveSnapper; exports.SNAP_DECIDE_DISTANCE = SNAP_DECIDE_DISTANCE; exports.STAMP_KINDS = _chunk5BR7LC24cjs.STAMP_KINDS; exports.STAMP_LABELS = STAMP_LABELS; exports.STENCIL_KINDS = STENCIL_KINDS; exports.STENCIL_SHAPES = STENCIL_SHAPES; exports.STICKER_SLIDERS = STICKER_SLIDERS; exports.STROKE_SLIDERS = STROKE_SLIDERS; exports.SYMMETRY_MODES = SYMMETRY_MODES; exports.StencilSnapper = StencilSnapper; exports.StickerSpray = _chunk5BR7LC24cjs.StickerSpray; exports.TRACING_NODE_ID = TRACING_NODE_ID; exports.ThickStrokeDriver = ThickStrokeDriver; exports.TileableNoise = _chunkPQ3H2AANcjs.TileableNoise; exports.WET_FLOW_KINDS = _chunkXFYLA3ZOcjs.WET_FLOW_KINDS; exports.WET_GPU_MODES = WET_GPU_MODES; exports.WET_GPU_OPTIONS = WET_GPU_OPTIONS; exports.WET_MEDIA = _chunk5BR7LC24cjs.WET_MEDIA; exports.WET_MEDIUM_LABELS = WET_MEDIUM_LABELS; exports.WET_MEDIUM_PARAMS = WET_MEDIUM_PARAMS; exports.WET_PARAM_KEYS = _chunkXFYLA3ZOcjs.WET_PARAM_KEYS; exports.WET_PARAM_SCHEMA = WET_PARAM_SCHEMA; exports.WET_PARAM_SLIDERS = WET_PARAM_SLIDERS; exports.WET_SPEED_SLIDER = WET_SPEED_SLIDER; exports.WET_TILT_SLIDERS = WET_TILT_SLIDERS; exports.WET_TOOLS = _chunk5BR7LC24cjs.WET_TOOLS; exports.WET_TOOL_LABELS = WET_TOOL_LABELS; exports.WetStrokeDriver = WetStrokeDriver; exports.addPaintGradientStop = _chunkPQ3H2AANcjs.addPaintGradientStop; exports.affineCopy = affineCopy; exports.applyAffine = applyAffine; exports.brushEngineControls = brushEngineControls; exports.brushLoadColor = brushLoadColor; exports.brushLoadForStroke = brushLoadForStroke; exports.brushTakesPaint = _chunk5BR7LC24cjs.brushTakesPaint; exports.brushToJSON = _chunk5BR7LC24cjs.brushToJSON; exports.buildTimeLapse = buildTimeLapse; exports.checkPaintEffectPlace = checkPaintEffectPlace; exports.clonePaper = _chunk5BR7LC24cjs.clonePaper; exports.colorHarmony = colorHarmony2; exports.composeAffine = composeAffine; exports.contactSheet = contactSheet; exports.createPaintCompositor = createPaintCompositor; exports.createPaintDocument = createPaintDocument; exports.createPaintEditorDocument = createPaintEditorDocument; exports.createPaintEditorToolProvider = createPaintEditorToolProvider; exports.createPaintEffectsToolProvider = createPaintEffectsToolProvider; exports.createPaintLayer = createPaintLayer; exports.createPaintReplayTools = createPaintReplayTools; exports.createPaintStickerTools = createPaintStickerTools; exports.createPaintThickTools = createPaintThickTools; exports.createPaintWetTools = createPaintWetTools; exports.decodeImageBlob = decodeImageBlob; exports.defaultGuides = defaultGuides; exports.defaultImageEncoder = defaultImageEncoder; exports.deserializePaintDocument = deserializePaintDocument; exports.deserializePaintDocumentAsync = deserializePaintDocumentAsync; exports.documentExtensions = documentExtensions; exports.documentToScreen = documentToScreen; exports.downloadBytes = downloadBytes; exports.downsampleRgba = downsampleRgba; exports.drawSticker = _chunk5BR7LC24cjs.drawSticker; exports.drawWaterOverlay = drawWaterOverlay; exports.effectDabField = _chunk5BR7LC24cjs.effectDabField; exports.effectLayersToJSON = effectLayersToJSON; exports.effectPaintKey = _chunk5BR7LC24cjs.effectPaintKey; exports.effectPaintSize = _chunk5BR7LC24cjs.effectPaintSize; exports.emptiedLayers = emptiedLayers; exports.emptyThickChannels = emptyThickChannels; exports.fitZoom = fitZoom; exports.grainCatch = _chunkPQ3H2AANcjs.grainCatch; exports.grainHeights = _chunkPQ3H2AANcjs.grainHeights; exports.guideOverlay = guideOverlay; exports.handlePaintShortcut = handlePaintShortcut; exports.hash2 = _chunkPQ3H2AANcjs.hash2; exports.hexToPaintRgb = _chunkPQ3H2AANcjs.hexToPaintRgb; exports.hexToRgb8 = _chunk5BR7LC24cjs.hexToRgb8; exports.hslToRgb = hslToRgb; exports.hsvToRgb = hsvToRgb; exports.hueToWheel = _chunk7PT4RJL5cjs.hueToWheel; exports.invertAffine = invertAffine; exports.isBlendMode = _chunkOLNIPTB3cjs.isBlendMode; exports.isGradientPaint = _chunkPQ3H2AANcjs.isGradientPaint; exports.isPaintEffectPaint = _chunk5BR7LC24cjs.isPaintEffectPaint; exports.isPainterlyBlendMode = _chunkOLNIPTB3cjs.isPainterlyBlendMode; exports.isPalmTouch = isPalmTouch; exports.isWetBrush = _chunk5BR7LC24cjs.isWetBrush; exports.isWetCapable = _chunk5BR7LC24cjs.isWetCapable; exports.lightTile = lightTile; exports.lightingKey = lightingKey; exports.liveStrokeBounds = liveStrokeBounds; exports.liveStrokeRefusal = liveStrokeRefusal; exports.mapPenPoint = mapPenPoint; exports.mix32 = _chunkPQ3H2AANcjs.mix32; exports.mixPixels = mixPixels; exports.mixerLoadForStroke = mixerLoadForStroke; exports.mixerTip = _chunk5BR7LC24cjs.mixerTip; exports.multiColorForDab = multiColorForDab; exports.multiColorGradient = multiColorGradient; exports.multiColorPalette = multiColorPalette; exports.multiColorSliders = multiColorSliders; exports.multiColorToPaint = _chunk5BR7LC24cjs.multiColorToPaint; exports.newPaintLayerId = newPaintLayerId; exports.nextPaperEffectVersion = nextPaperEffectVersion; exports.normalizeBehavior = _chunk5BR7LC24cjs.normalizeBehavior; exports.normalizeBristle = _chunk5BR7LC24cjs.normalizeBristle; exports.normalizeBrushStroke = normalizeBrushStroke; exports.normalizeCanvas = normalizeCanvas; exports.normalizeDynamics = _chunk5BR7LC24cjs.normalizeDynamics; exports.normalizeFlow = _chunkXFYLA3ZOcjs.normalizeFlow; exports.normalizeHexColor = _chunkPQ3H2AANcjs.normalizeHexColor; exports.normalizeImpasto = _chunk5BR7LC24cjs.normalizeImpasto; exports.normalizeLighting = normalizeLighting; exports.normalizeMultiColor = _chunk5BR7LC24cjs.normalizeMultiColor; exports.normalizePaintBrush = _chunk5BR7LC24cjs.normalizePaintBrush; exports.normalizePaper = _chunk5BR7LC24cjs.normalizePaper; exports.normalizeParticle = _chunk5BR7LC24cjs.normalizeParticle; exports.normalizePerspective = normalizePerspective; exports.normalizeRotation = normalizeRotation; exports.normalizeStencil = normalizeStencil; exports.normalizeStickerSettings = _chunk5BR7LC24cjs.normalizeStickerSettings; exports.normalizeStickerUpdate = _chunk5BR7LC24cjs.normalizeStickerUpdate; exports.normalizeSymmetry = normalizeSymmetry; exports.normalizeView = normalizeView; exports.normalizeWetBrush = _chunk5BR7LC24cjs.normalizeWetBrush; exports.normalizeWetParams = _chunkXFYLA3ZOcjs.normalizeWetParams; exports.overPixels = overPixels; exports.padSampleRadius = padSampleRadius; exports.paintGradientMappingFor = _chunkPQ3H2AANcjs.paintGradientMappingFor; exports.paintPlaybackPanel = paintPlaybackPanel; exports.paintSourceColor = _chunkPQ3H2AANcjs.paintSourceColor; exports.paintSourceCss = _chunkPQ3H2AANcjs.paintSourceCss; exports.paintToMultiColor = _chunk5BR7LC24cjs.paintToMultiColor; exports.paperEffectFromJSON = paperEffectFromJSON; exports.paperEffectToJSON = paperEffectToJSON; exports.paperGrain = paperGrain; exports.paperKey = paperKey; exports.paperNode = paperNode; exports.paperPreset = _chunk5BR7LC24cjs.paperPreset; exports.parseBrushLibrary = _chunk5BR7LC24cjs.parseBrushLibrary; exports.parseHexColor = parseHexColor; exports.parsePaintSource = _chunkPQ3H2AANcjs.parsePaintSource; exports.patchBrushValue = patchBrushValue; exports.patchPath = patchPath; exports.penOrientation = _chunk5BR7LC24cjs.penOrientation; exports.perspectiveDirections = perspectiveDirections; exports.perspectiveGuideLines = perspectiveGuideLines; exports.planPaintToolPlayback = planPaintToolPlayback; exports.pointerToPenPoint = pointerToPenPoint; exports.quickStencil = quickStencil; exports.rand01 = _chunkPQ3H2AANcjs.rand01; exports.randSigned = _chunkPQ3H2AANcjs.randSigned; exports.readEffectStrokeMap = _chunk5BR7LC24cjs.readEffectStrokeMap; exports.readPaintEffectPaint = _chunk5BR7LC24cjs.readPaintEffectPaint; exports.readPaintEffectSource = readPaintEffectSource; exports.readPaintSource = _chunkPQ3H2AANcjs.readPaintSource; exports.readPath = readPath; exports.readSwatch = readSwatch; exports.reliefInfo = reliefInfo; exports.removePaintGradientStop = _chunkPQ3H2AANcjs.removePaintGradientStop; exports.renderBrushThumbnail = renderBrushThumbnail; exports.renderColorWheel = renderColorWheel; exports.renderPaper = _chunk5BR7LC24cjs.renderPaper; exports.renderStickers = _chunk5BR7LC24cjs.renderStickers; exports.replayFrame = replayFrame; exports.replayItems = replayItems; exports.replayPainting = replayPainting; exports.resolvePaintGradient = _chunkPQ3H2AANcjs.resolvePaintGradient; exports.reversePaintGradient = _chunkPQ3H2AANcjs.reversePaintGradient; exports.rgbToHexColor = rgbToHexColor; exports.rgbToHsl = rgbToHsl; exports.rgbToHsv = rgbToHsv; exports.sampleEffectAt = _chunk5BR7LC24cjs.sampleEffectAt; exports.sampleEffectField = _chunk5BR7LC24cjs.sampleEffectField; exports.samplePressure = samplePressure; exports.scalePaintGradient = _chunkPQ3H2AANcjs.scalePaintGradient; exports.scaleStencil = scaleStencil; exports.screenToDocument = screenToDocument; exports.seedFromString = _chunkPQ3H2AANcjs.seedFromString; exports.serializePaintDocument = serializePaintDocument; exports.serializePaintDocumentExternal = serializePaintDocumentExternal; exports.solidPaint = _chunkPQ3H2AANcjs.solidPaint; exports.stampCoverage = _chunk5BR7LC24cjs.stampCoverage; exports.standardBlendMode = _chunkOLNIPTB3cjs.standardBlendMode; exports.startWetClock = startWetClock; exports.stencilMask = stencilMask; exports.stencilOutline = stencilOutline; exports.stickerAt = _chunk5BR7LC24cjs.stickerAt; exports.stickerRect = _chunk5BR7LC24cjs.stickerRect; exports.stickerSurface = _chunk5BR7LC24cjs.stickerSurface; exports.strokeBounds = strokeBounds; exports.strokeDuration = strokeDuration; exports.strokeSchedule = strokeSchedule; exports.sweepPath = sweepPath; exports.symmetryAxisAngles = symmetryAxisAngles; exports.symmetryAxisSegments = symmetryAxisSegments; exports.symmetryCopies = symmetryCopies; exports.thickFromJSON = thickFromJSON; exports.thickToJSON = thickToJSON; exports.thumbnailStroke = thumbnailStroke; exports.tiltToOrientation = _chunk5BR7LC24cjs.tiltToOrientation; exports.timeLapseVideo = timeLapseVideo; exports.timeLapseZip = timeLapseZip; exports.toStrokePoint = _chunk5BR7LC24cjs.toStrokePoint; exports.toggleStamp = toggleStamp; exports.translateStencil = translateStencil; exports.updatePaintGradientStop = _chunkPQ3H2AANcjs.updatePaintGradientStop; exports.usesPaintExchange = _chunk5BR7LC24cjs.usesPaintExchange; exports.variationAffine = variationAffine; exports.varyStroke = varyStroke; exports.viewCssTransform = viewCssTransform; exports.viewMatrix = viewMatrix; exports.viewPenToDocument = viewPenToDocument; exports.wetEngineSummary = wetEngineSummary; exports.wetPaperInput = wetPaperInput; exports.wetPigmentOf = wetPigmentOf; exports.wetSupport = _chunkXFYLA3ZOcjs.wetSupport; exports.wheelAngle = wheelAngle; exports.wheelPick = wheelPick; exports.wheelPoint = wheelPoint; exports.wheelToHue = _chunk7PT4RJL5cjs.wheelToHue; exports.withPaintPlayback = withPaintPlayback;
+
+
+
+
+
+exports.BACKLIGHT_SPILL = BACKLIGHT_SPILL; exports.BLEND_MENU_GROUPS = BLEND_MENU_GROUPS; exports.BLEND_MODES = _chunkOLNIPTB3cjs.BLEND_MODES; exports.BRUSH_ID = _chunk4T47Z4J3cjs.BRUSH_ID; exports.BRUSH_ROTATIONS = _chunk4T47Z4J3cjs.BRUSH_ROTATIONS; exports.BRUSH_SLIDERS = BRUSH_SLIDERS; exports.BUILTIN_BRUSHES = _chunk4T47Z4J3cjs.BUILTIN_BRUSHES; exports.BristleStroke = _chunk4T47Z4J3cjs.BristleStroke; exports.DEFAULT_BACKLIGHT_COLOR = DEFAULT_BACKLIGHT_COLOR; exports.DEFAULT_BEHAVIOR = _chunk4T47Z4J3cjs.DEFAULT_BEHAVIOR; exports.DEFAULT_BRISTLE = _chunk4T47Z4J3cjs.DEFAULT_BRISTLE; exports.DEFAULT_BRUSH_ID = _chunk4T47Z4J3cjs.DEFAULT_BRUSH_ID; exports.DEFAULT_DPI = DEFAULT_DPI; exports.DEFAULT_DYNAMICS = _chunk4T47Z4J3cjs.DEFAULT_DYNAMICS; exports.DEFAULT_FLOW = _chunkVMROIWLLcjs.DEFAULT_FLOW; exports.DEFAULT_IMPASTO = _chunk4T47Z4J3cjs.DEFAULT_IMPASTO; exports.DEFAULT_LIGHT = _chunk4T47Z4J3cjs.DEFAULT_LIGHT; exports.DEFAULT_LIGHTING = DEFAULT_LIGHTING; exports.DEFAULT_MULTI_COLOR = _chunk4T47Z4J3cjs.DEFAULT_MULTI_COLOR; exports.DEFAULT_PAINT_GRADIENT = _chunkPQ3H2AANcjs.DEFAULT_PAINT_GRADIENT; exports.DEFAULT_PAINT_GRADIENT_MAPPING = _chunkPQ3H2AANcjs.DEFAULT_PAINT_GRADIENT_MAPPING; exports.DEFAULT_PAPER = _chunk4T47Z4J3cjs.DEFAULT_PAPER; exports.DEFAULT_PARTICLE = _chunk4T47Z4J3cjs.DEFAULT_PARTICLE; exports.DEFAULT_STICKER = _chunk4T47Z4J3cjs.DEFAULT_STICKER; exports.DEFAULT_SWATCHES = DEFAULT_SWATCHES; exports.DEFAULT_VIEW = DEFAULT_VIEW; exports.DEFAULT_WET_BRUSH = _chunk4T47Z4J3cjs.DEFAULT_WET_BRUSH; exports.DEFAULT_WET_PARAMS = _chunkVMROIWLLcjs.DEFAULT_WET_PARAMS; exports.DryStroke = _chunk4T47Z4J3cjs.DryStroke; exports.EFFECT_MAP_REPEATS = _chunk4T47Z4J3cjs.EFFECT_MAP_REPEATS; exports.EFFECT_STRIP_HEIGHT = _chunk4T47Z4J3cjs.EFFECT_STRIP_HEIGHT; exports.GPU_LEAD = GPU_LEAD; exports.GRAIN_PATTERNS = _chunkPQ3H2AANcjs.GRAIN_PATTERNS; exports.GRAIN_TILE = _chunkPQ3H2AANcjs.GRAIN_TILE; exports.HARMONY_KINDS = _chunk7PT4RJL5cjs.HARMONY_KINDS; exports.IDENTITY_AFFINE = IDENTITY_AFFINE; exports.IDENTITY_COPY = _chunk4T47Z4J3cjs.IDENTITY_COPY; exports.IMPASTO_TOOLS = _chunk4T47Z4J3cjs.IMPASTO_TOOLS; exports.IMPASTO_TOOL_LABELS = IMPASTO_TOOL_LABELS; exports.LIGHT_SLIDERS = LIGHT_SLIDERS; exports.LIVE_STROKE_ENGINES = LIVE_STROKE_ENGINES; exports.LitCache = LitCache; exports.MAX_BRUSH_SIZE = _chunkPQ3H2AANcjs.MAX_BRUSH_SIZE; exports.MAX_CANVAS_SIDE = MAX_CANVAS_SIDE; exports.MAX_COORDINATE = MAX_COORDINATE; exports.MAX_IMAGE_SIDE = MAX_IMAGE_SIDE; exports.MAX_LIVE_EFFECT_SOURCES = MAX_LIVE_EFFECT_SOURCES; exports.MAX_ZOOM = MAX_ZOOM; exports.MIN_CANVAS_SIDE = MIN_CANVAS_SIDE; exports.MIN_ZOOM = MIN_ZOOM; exports.MIXING_PAD_HEIGHT = MIXING_PAD_HEIGHT; exports.MIXING_PAD_WIDTH = MIXING_PAD_WIDTH; exports.MULTI_COLOR_MODES = _chunk4T47Z4J3cjs.MULTI_COLOR_MODES; exports.MixingPad = MixingPad; exports.PAD_SAMPLE_SIZES = PAD_SAMPLE_SIZES; exports.PAINTERLY_BLEND_MODES = _chunkOLNIPTB3cjs.PAINTERLY_BLEND_MODES; exports.PAINT_BRUSH_CATEGORIES = _chunk4T47Z4J3cjs.PAINT_BRUSH_CATEGORIES; exports.PAINT_BRUSH_ENGINES = _chunk4T47Z4J3cjs.PAINT_BRUSH_ENGINES; exports.PAINT_COLOR_JSON_SCHEMA = _chunkPQ3H2AANcjs.PAINT_COLOR_JSON_SCHEMA; exports.PAINT_EFFECT_PLACES = PAINT_EFFECT_PLACES; exports.PAINT_FORMAT = PAINT_FORMAT; exports.PAINT_GRADIENT_FULL_SPEED = _chunkPQ3H2AANcjs.PAINT_GRADIENT_FULL_SPEED; exports.PAINT_GRADIENT_JSON_SCHEMA = _chunkPQ3H2AANcjs.PAINT_GRADIENT_JSON_SCHEMA; exports.PAINT_GRADIENT_KIT = _chunkPQ3H2AANcjs.PAINT_GRADIENT_KIT; exports.PAINT_GRADIENT_MAPPINGS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_MAPPINGS; exports.PAINT_GRADIENT_MAPPING_LABELS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_MAPPING_LABELS; exports.PAINT_GRADIENT_PRESETS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_PRESETS; exports.PAINT_GRADIENT_REPEATS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_REPEATS; exports.PAINT_GRADIENT_REPEAT_LABELS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_REPEAT_LABELS; exports.PAINT_GRADIENT_SPACES = _chunkPQ3H2AANcjs.PAINT_GRADIENT_SPACES; exports.PAINT_GRADIENT_SPACE_LABELS = _chunkPQ3H2AANcjs.PAINT_GRADIENT_SPACE_LABELS; exports.PAINT_SCHEMA_VERSION = PAINT_SCHEMA_VERSION; exports.PAINT_SOURCE_JSON_SCHEMA = _chunkPQ3H2AANcjs.PAINT_SOURCE_JSON_SCHEMA; exports.PAINT_TARGET = PAINT_TARGET; exports.PAINT_TOOLS = PAINT_TOOLS; exports.PAPER_EFFECT_BLENDS = PAPER_EFFECT_BLENDS; exports.PAPER_EFFECT_NODE_ID = PAPER_EFFECT_NODE_ID; exports.PAPER_FAMILIES = _chunk4T47Z4J3cjs.PAPER_FAMILIES; exports.PAPER_LIBRARY = _chunk4T47Z4J3cjs.PAPER_LIBRARY; exports.PAPER_NODE_ID = PAPER_NODE_ID; exports.PAPER_SLIDERS = PAPER_SLIDERS; exports.PAPER_TARGET = PAPER_TARGET; exports.PARTICLE_KINDS = _chunk4T47Z4J3cjs.PARTICLE_KINDS; exports.PARTICLE_KIND_LABELS = PARTICLE_KIND_LABELS; exports.PARTICLE_RENDERS = _chunk4T47Z4J3cjs.PARTICLE_RENDERS; exports.PARTICLE_RENDER_LABELS = PARTICLE_RENDER_LABELS; exports.PaintCanvasPresenter = PaintCanvasPresenter; exports.PaintDabStroke = PaintDabStroke; exports.PaintDirector = PaintDirector; exports.PaintDocumentError = PaintDocumentError; exports.PaintEditorController = PaintEditorController; exports.PaintEditorError = PaintEditorError; exports.PaintEffectsRenderer = PaintEffectsRenderer; exports.PaintGesture = PaintGesture; exports.PaintGradientSampler = _chunkPQ3H2AANcjs.PaintGradientSampler; exports.PaintPresence = PaintPresence; exports.PaintSourceError = _chunkPQ3H2AANcjs.PaintSourceError; exports.PaintStrokeSession = PaintStrokeSession; exports.PaintWetLayers = PaintWetLayers; exports.PaperGrain = _chunkPQ3H2AANcjs.PaperGrain; exports.ParticleStroke = _chunk4T47Z4J3cjs.ParticleStroke; exports.PenDabWalker = _chunk4T47Z4J3cjs.PenDabWalker; exports.PenSmoother = _chunk4T47Z4J3cjs.PenSmoother; exports.PerspectiveSnapper = PerspectiveSnapper; exports.SNAP_DECIDE_DISTANCE = SNAP_DECIDE_DISTANCE; exports.STAMP_KINDS = _chunk4T47Z4J3cjs.STAMP_KINDS; exports.STAMP_LABELS = STAMP_LABELS; exports.STENCIL_KINDS = STENCIL_KINDS; exports.STENCIL_SHAPES = STENCIL_SHAPES; exports.STICKER_SLIDERS = STICKER_SLIDERS; exports.STROKE_SLIDERS = STROKE_SLIDERS; exports.SYMMETRY_MODES = SYMMETRY_MODES; exports.StencilSnapper = StencilSnapper; exports.StickerSpray = _chunk4T47Z4J3cjs.StickerSpray; exports.TRACING_NODE_ID = TRACING_NODE_ID; exports.ThickStrokeDriver = ThickStrokeDriver; exports.TileableNoise = _chunkPQ3H2AANcjs.TileableNoise; exports.WET_FLOW_KINDS = _chunkVMROIWLLcjs.WET_FLOW_KINDS; exports.WET_GPU_MODES = WET_GPU_MODES; exports.WET_GPU_OPTIONS = WET_GPU_OPTIONS; exports.WET_MEDIA = _chunk4T47Z4J3cjs.WET_MEDIA; exports.WET_MEDIUM_LABELS = WET_MEDIUM_LABELS; exports.WET_MEDIUM_PARAMS = WET_MEDIUM_PARAMS; exports.WET_PARAM_KEYS = _chunkVMROIWLLcjs.WET_PARAM_KEYS; exports.WET_PARAM_SCHEMA = WET_PARAM_SCHEMA; exports.WET_PARAM_SLIDERS = WET_PARAM_SLIDERS; exports.WET_SPEED_SLIDER = WET_SPEED_SLIDER; exports.WET_TILT_SLIDERS = WET_TILT_SLIDERS; exports.WET_TOOLS = _chunk4T47Z4J3cjs.WET_TOOLS; exports.WET_TOOL_LABELS = WET_TOOL_LABELS; exports.WetStrokeDriver = WetStrokeDriver; exports.addPaintGradientStop = _chunkPQ3H2AANcjs.addPaintGradientStop; exports.affineCopy = affineCopy; exports.applyAffine = applyAffine; exports.backlightOf = backlightOf; exports.brushEngineControls = brushEngineControls; exports.brushLoadColor = brushLoadColor; exports.brushLoadForStroke = brushLoadForStroke; exports.brushTakesPaint = _chunk4T47Z4J3cjs.brushTakesPaint; exports.brushToJSON = _chunk4T47Z4J3cjs.brushToJSON; exports.buildTimeLapse = buildTimeLapse; exports.checkPaintEffectPlace = checkPaintEffectPlace; exports.clonePaper = _chunk4T47Z4J3cjs.clonePaper; exports.colorHarmony = colorHarmony2; exports.composeAffine = composeAffine; exports.contactSheet = contactSheet; exports.createPaintCompositor = createPaintCompositor; exports.createPaintDocument = createPaintDocument; exports.createPaintEditorDocument = createPaintEditorDocument; exports.createPaintEditorToolProvider = createPaintEditorToolProvider; exports.createPaintEffectsToolProvider = createPaintEffectsToolProvider; exports.createPaintLayer = createPaintLayer; exports.createPaintReplayTools = createPaintReplayTools; exports.createPaintStickerTools = createPaintStickerTools; exports.createPaintThickTools = createPaintThickTools; exports.createPaintWetTools = createPaintWetTools; exports.decodeImageBlob = decodeImageBlob; exports.defaultGuides = defaultGuides; exports.defaultImageEncoder = defaultImageEncoder; exports.deserializePaintDocument = deserializePaintDocument; exports.deserializePaintDocumentAsync = deserializePaintDocumentAsync; exports.documentExtensions = documentExtensions; exports.documentToScreen = documentToScreen; exports.downloadBytes = downloadBytes; exports.downsampleRgba = downsampleRgba; exports.drawSticker = _chunk4T47Z4J3cjs.drawSticker; exports.drawWaterOverlay = drawWaterOverlay; exports.effectDabField = _chunk4T47Z4J3cjs.effectDabField; exports.effectLayersToJSON = effectLayersToJSON; exports.effectPaintKey = _chunk4T47Z4J3cjs.effectPaintKey; exports.effectPaintSize = _chunk4T47Z4J3cjs.effectPaintSize; exports.emptiedLayers = emptiedLayers; exports.emptyThickChannels = emptyThickChannels; exports.fitZoom = fitZoom; exports.grainCatch = _chunkPQ3H2AANcjs.grainCatch; exports.grainHeights = _chunkPQ3H2AANcjs.grainHeights; exports.guideOverlay = guideOverlay; exports.handlePaintShortcut = handlePaintShortcut; exports.hash2 = _chunkPQ3H2AANcjs.hash2; exports.hexToPaintRgb = _chunkPQ3H2AANcjs.hexToPaintRgb; exports.hexToRgb8 = _chunk4T47Z4J3cjs.hexToRgb8; exports.hslToRgb = hslToRgb; exports.hsvToRgb = hsvToRgb; exports.hueToWheel = _chunk7PT4RJL5cjs.hueToWheel; exports.invertAffine = invertAffine; exports.isBlendMode = _chunkOLNIPTB3cjs.isBlendMode; exports.isGradientPaint = _chunkPQ3H2AANcjs.isGradientPaint; exports.isPaintEffectPaint = _chunk4T47Z4J3cjs.isPaintEffectPaint; exports.isPainterlyBlendMode = _chunkOLNIPTB3cjs.isPainterlyBlendMode; exports.isPalmTouch = isPalmTouch; exports.isWetBrush = _chunk4T47Z4J3cjs.isWetBrush; exports.isWetCapable = _chunk4T47Z4J3cjs.isWetCapable; exports.lightTile = lightTile; exports.lightingKey = lightingKey; exports.liveStrokeBounds = liveStrokeBounds; exports.liveStrokeRefusal = liveStrokeRefusal; exports.mapPenPoint = mapPenPoint; exports.mix32 = _chunkPQ3H2AANcjs.mix32; exports.mixPixels = mixPixels; exports.mixerLoadForStroke = mixerLoadForStroke; exports.mixerTip = _chunk4T47Z4J3cjs.mixerTip; exports.multiColorForDab = multiColorForDab; exports.multiColorGradient = multiColorGradient; exports.multiColorPalette = multiColorPalette; exports.multiColorSliders = multiColorSliders; exports.multiColorToPaint = _chunk4T47Z4J3cjs.multiColorToPaint; exports.newPaintLayerId = newPaintLayerId; exports.nextPaperEffectVersion = nextPaperEffectVersion; exports.normalizeBehavior = _chunk4T47Z4J3cjs.normalizeBehavior; exports.normalizeBristle = _chunk4T47Z4J3cjs.normalizeBristle; exports.normalizeBrushStroke = normalizeBrushStroke; exports.normalizeCanvas = normalizeCanvas; exports.normalizeDynamics = _chunk4T47Z4J3cjs.normalizeDynamics; exports.normalizeFlow = _chunkVMROIWLLcjs.normalizeFlow; exports.normalizeHexColor = _chunkPQ3H2AANcjs.normalizeHexColor; exports.normalizeImpasto = _chunk4T47Z4J3cjs.normalizeImpasto; exports.normalizeLight = _chunk4T47Z4J3cjs.normalizeLight; exports.normalizeLighting = normalizeLighting; exports.normalizeMultiColor = _chunk4T47Z4J3cjs.normalizeMultiColor; exports.normalizePaintBrush = _chunk4T47Z4J3cjs.normalizePaintBrush; exports.normalizePaper = _chunk4T47Z4J3cjs.normalizePaper; exports.normalizeParticle = _chunk4T47Z4J3cjs.normalizeParticle; exports.normalizePerspective = normalizePerspective; exports.normalizeRotation = normalizeRotation; exports.normalizeStencil = normalizeStencil; exports.normalizeStickerSettings = _chunk4T47Z4J3cjs.normalizeStickerSettings; exports.normalizeStickerUpdate = _chunk4T47Z4J3cjs.normalizeStickerUpdate; exports.normalizeSymmetry = normalizeSymmetry; exports.normalizeView = normalizeView; exports.normalizeWetBrush = _chunk4T47Z4J3cjs.normalizeWetBrush; exports.normalizeWetParams = _chunkVMROIWLLcjs.normalizeWetParams; exports.overPixels = overPixels; exports.padSampleRadius = padSampleRadius; exports.paintGradientMappingFor = _chunkPQ3H2AANcjs.paintGradientMappingFor; exports.paintPlaybackPanel = paintPlaybackPanel; exports.paintSourceColor = _chunkPQ3H2AANcjs.paintSourceColor; exports.paintSourceCss = _chunkPQ3H2AANcjs.paintSourceCss; exports.paintToMultiColor = _chunk4T47Z4J3cjs.paintToMultiColor; exports.paperEffectFromJSON = paperEffectFromJSON; exports.paperEffectToJSON = paperEffectToJSON; exports.paperGrain = paperGrain; exports.paperKey = paperKey; exports.paperNode = paperNode; exports.paperPreset = _chunk4T47Z4J3cjs.paperPreset; exports.parseBrushLibrary = _chunk4T47Z4J3cjs.parseBrushLibrary; exports.parseHexColor = parseHexColor; exports.parsePaintSource = _chunkPQ3H2AANcjs.parsePaintSource; exports.patchBrushValue = patchBrushValue; exports.patchPath = patchPath; exports.penOrientation = _chunk4T47Z4J3cjs.penOrientation; exports.perspectiveDirections = perspectiveDirections; exports.perspectiveGuideLines = perspectiveGuideLines; exports.planPaintToolPlayback = planPaintToolPlayback; exports.pointerToPenPoint = pointerToPenPoint; exports.quickStencil = quickStencil; exports.rand01 = _chunkPQ3H2AANcjs.rand01; exports.randSigned = _chunkPQ3H2AANcjs.randSigned; exports.readEffectStrokeMap = _chunk4T47Z4J3cjs.readEffectStrokeMap; exports.readPaintEffectPaint = _chunk4T47Z4J3cjs.readPaintEffectPaint; exports.readPaintEffectSource = readPaintEffectSource; exports.readPaintSource = _chunkPQ3H2AANcjs.readPaintSource; exports.readPath = readPath; exports.readSwatch = readSwatch; exports.reliefInfo = reliefInfo; exports.removePaintGradientStop = _chunkPQ3H2AANcjs.removePaintGradientStop; exports.renderBrushThumbnail = renderBrushThumbnail; exports.renderColorWheel = renderColorWheel; exports.renderPaper = _chunk4T47Z4J3cjs.renderPaper; exports.renderStickers = _chunk4T47Z4J3cjs.renderStickers; exports.replayFrame = replayFrame; exports.replayItems = replayItems; exports.replayPainting = replayPainting; exports.resolvePaintGradient = _chunkPQ3H2AANcjs.resolvePaintGradient; exports.reversePaintGradient = _chunkPQ3H2AANcjs.reversePaintGradient; exports.rgbToHexColor = rgbToHexColor; exports.rgbToHsl = rgbToHsl; exports.rgbToHsv = rgbToHsv; exports.sampleEffectAt = _chunk4T47Z4J3cjs.sampleEffectAt; exports.sampleEffectField = _chunk4T47Z4J3cjs.sampleEffectField; exports.samplePressure = samplePressure; exports.scalePaintGradient = _chunkPQ3H2AANcjs.scalePaintGradient; exports.scaleStencil = scaleStencil; exports.screenToDocument = screenToDocument; exports.seedFromString = _chunkPQ3H2AANcjs.seedFromString; exports.serializePaintDocument = serializePaintDocument; exports.serializePaintDocumentExternal = serializePaintDocumentExternal; exports.solidPaint = _chunkPQ3H2AANcjs.solidPaint; exports.stampCoverage = _chunk4T47Z4J3cjs.stampCoverage; exports.standardBlendMode = _chunkOLNIPTB3cjs.standardBlendMode; exports.startWetClock = startWetClock; exports.stencilMask = stencilMask; exports.stencilOutline = stencilOutline; exports.stickerAt = _chunk4T47Z4J3cjs.stickerAt; exports.stickerRect = _chunk4T47Z4J3cjs.stickerRect; exports.stickerSurface = _chunk4T47Z4J3cjs.stickerSurface; exports.strokeBounds = strokeBounds; exports.strokeDuration = strokeDuration; exports.strokeSchedule = strokeSchedule; exports.sweepPath = sweepPath; exports.symmetryAxisAngles = symmetryAxisAngles; exports.symmetryAxisSegments = symmetryAxisSegments; exports.symmetryCopies = symmetryCopies; exports.thickFromJSON = thickFromJSON; exports.thickToJSON = thickToJSON; exports.thumbnailStroke = thumbnailStroke; exports.tiltToOrientation = _chunk4T47Z4J3cjs.tiltToOrientation; exports.timeLapseVideo = timeLapseVideo; exports.timeLapseZip = timeLapseZip; exports.toStrokePoint = _chunk4T47Z4J3cjs.toStrokePoint; exports.toggleStamp = toggleStamp; exports.translateStencil = translateStencil; exports.updatePaintGradientStop = _chunkPQ3H2AANcjs.updatePaintGradientStop; exports.usesPaintExchange = _chunk4T47Z4J3cjs.usesPaintExchange; exports.variationAffine = variationAffine; exports.varyStroke = varyStroke; exports.viewCssTransform = viewCssTransform; exports.viewMatrix = viewMatrix; exports.viewPenToDocument = viewPenToDocument; exports.wetEngineSummary = wetEngineSummary; exports.wetPaperInput = wetPaperInput; exports.wetPigmentOf = wetPigmentOf; exports.wetSupport = _chunkVMROIWLLcjs.wetSupport; exports.wheelAngle = wheelAngle; exports.wheelPick = wheelPick; exports.wheelPoint = wheelPoint; exports.wheelToHue = _chunk7PT4RJL5cjs.wheelToHue; exports.withPaintPlayback = withPaintPlayback;