@pixerate/editor 0.242.0 → 0.244.0

package/dist/paint-editor/index.js

@@ -7,7 +7,7 @@ import {
   resolveExternalAssets,
   serializeLayers,
   serializeLayersExternal
-} from "../chunk-NE6OOKWJ.js";
+} from "../chunk-7YQNKSQ7.js";
 import "../chunk-3CI7FRMK.js";
 import "../chunk-ZNA3IQZF.js";
 import {
@@ -44,7 +44,7 @@ import {
   pigmentOf,
   pointerPressure,
   wetSupport
-} from "../chunk-HLBTRSQJ.js";
+} from "../chunk-P3NIPIKS.js";
 import "../chunk-HVQVHUTV.js";
 import {
   writeZip
@@ -55,7 +55,7 @@ import {
   realPresenceClock,
   tweenPresenceCursor
 } from "../chunk-IVSWRVB4.js";
-import "../chunk-ILM6GYAX.js";
+import "../chunk-4EQY4TZJ.js";
 import {
   BRUSH_ID,
   BRUSH_ROTATIONS,
@@ -66,6 +66,7 @@ import {
   DEFAULT_BRUSH_ID,
   DEFAULT_DYNAMICS,
   DEFAULT_IMPASTO,
+  DEFAULT_LIGHT,
   DEFAULT_MULTI_COLOR,
   DEFAULT_PAPER,
   DEFAULT_PARTICLE,
@@ -107,6 +108,7 @@ import {
   normalizeBristle,
   normalizeDynamics,
   normalizeImpasto,
+  normalizeLight,
   normalizeMultiColor,
   normalizePaintBrush,
   normalizePaper,
@@ -131,7 +133,7 @@ import {
   tiltToOrientation,
   toStrokePoint,
   usesPaintExchange
-} from "../chunk-XBZK47LV.js";
+} from "../chunk-TBJEMELS.js";
 import "../chunk-M6DNZNVY.js";
 import "../chunk-WEIK3UYB.js";
 import "../chunk-PWBZH3FK.js";
@@ -256,7 +258,10 @@ import {
 } from "../chunk-BP6KSGVD.js";
 import "../chunk-6ADHGQ73.js";
 import "../chunk-JEGJP4OW.js";
-import "../chunk-F67XMVDI.js";
+import {
+  linearToSrgb,
+  srgbToLinear
+} from "../chunk-F67XMVDI.js";
 import "../chunk-6ONMQ6WF.js";
 
 // src/paint-editor/document.ts
@@ -838,7 +843,7 @@ var ThickStrokeDriver = 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;
@@ -878,34 +883,34 @@ var ThickStrokeDriver = 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 + hash2(Math.round(u * 6), 3, seed) * 6.28) + 0.15 * (hash2(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 * hash2(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 = 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 = class {
         const i = ((ly & 255) * 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 = raw.radius ?? base.radius;
+  const strength = 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 TiledSurface(1, /* @__PURE__ */ new Map(), 0);
+}
+var full = (t, channels) => {
+  if (t.data.length === TILE * TILE * channels) return t.data;
+  const out = new Uint8ClampedArray(TILE * TILE * channels);
+  const u = 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(TILE * 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 = finishTile(d, 4, 0);
+    if (t) tiles.set(key, t);
+  }
+  return new 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(TILE * 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 = finishTile(d, 1, 0);
+    if (t) tiles.set(key, t);
+  }
+  return new TiledSurface(1, tiles, 0);
+}
+function lightTwinBrush(brush) {
+  return normalizePaintBrush(
+    {
+      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 = finishTile(d, 1, 0);
+      if (t) tiles.set(key, t);
+    }
+  }
+  return new TiledSurface(1, tiles, 0);
+}
+function mergeLight(lower, upper, upperColor) {
+  if (!upper?.tiles.size) return lower;
+  const keys = /* @__PURE__ */ new Set([...lower?.tiles.keys() ?? [], ...upper.tiles.keys()]);
+  const tiles = /* @__PURE__ */ new Map();
+  for (const key of keys) {
+    const lo = lower?.tiles.get(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(TILE * 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 = finishTile(d, 1, 0);
+    if (t) tiles.set(key, t);
+  }
+  return new TiledSurface(1, tiles, 0);
+}
+function facing(h, x, y) {
+  const at = (xx, yy) => h[Math.min(TILE - 1, Math.max(0, yy)) * TILE + Math.min(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 = class {
+  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 (!light?.tiles.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 = light?.tiles.get(key);
+      const m = thick?.material.tiles.get(key);
+      const h = thick?.height.tiles.get(key);
+      if (!l && !clear(m)) continue;
+      seen.add(key);
+      const inputs = [tile, l ?? null, m ?? null, 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 < TILE; y++) {
+        for (let x = 0; x < 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(linearToSrgb(Math.min(1, srgbToLinear(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 TiledSurface(4, out, color.defaultValue);
+  }
+  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;
+  }
+};
+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 = readRegion(color, region);
+  const lit = readRegion(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] += srgbToLinear(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, linearToSrgb(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 surfaceFromPixels({ 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: pngDataUrl(b.width, b.height, readRegion(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 = parseDataUrl(r.light);
+  if (!parsed) throw new Error("the light is not a PNG data URL");
+  const img = decodePng(parsed.bytes, { keepGray: true });
+  const data = img.channels === 1 ? img.data : Uint8ClampedArray.from({ length: img.width * img.height }, (_, i) => img.data[i * 4]);
+  return surfaceFromPixels({ 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(TILE * TILE * surface.channels);
@@ -1000,7 +1267,7 @@ 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 = class {
+var PaintStrokeSession = class _PaintStrokeSession {
   constructor(host, init) {
     this.host = host;
     this.init = init;
@@ -1010,6 +1277,7 @@ var PaintStrokeSession = class {
     this.copies = init.copies.length ? init.copies : [IDENTITY_COPY];
     const brush = init.brush;
     if (init.wet) this.wetDriver = init.wet.driver;
+    if (init.light && !init.wet && !init.sticker) this.lightTwin = this.makeLightTwin(init.light.surface);
     const effect = init.effect?.pixels ?? null;
     this.apply = {
       mode: brush.engine === "eraser" ? "erase" : "paint",
@@ -1060,6 +1328,9 @@ var PaintStrokeSession = class {
   wetDriver = null;
   thickDriver = null;
   stickerSpray = null;
+  /** Light paint: the stroke's twin over the light channel, and what it left there. */
+  lightTwin = null;
+  lightResult = null;
   /** A wet stroke that ended while the simulation was mid-batch: it commits when the driver catches up. */
   wetEndPending = false;
   apply;
@@ -1070,6 +1341,41 @@ var PaintStrokeSession = class {
   result = null;
   /** The mask stencils this stroke was painted with when they are not the editor's (replays). */
   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,
@@ -1098,6 +1404,7 @@ var PaintStrokeSession = class {
     if (filter) points = points.map(filter);
     for (const p of points) this.points.push(p);
     this.lastRaw = points[points.length - 1];
+    this.lightTwin?.push(points);
     if (this.wetDriver) {
       this.wetUpdate(this.wetDriver.push(points));
       return;
@@ -1179,6 +1486,7 @@ var PaintStrokeSession = 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 (this.lightTwin?.open) this.lightTwin.end();
     const ch = this.base.channels;
     const tiles = new Map(this.base.tiles);
     let changed = false;
@@ -1202,9 +1510,19 @@ var PaintStrokeSession = class {
   cancel() {
     if (this.closed) return;
     this.closed = true;
+    if (this.lightTwin?.open) this.lightTwin.cancel();
+    this.lightResult = null;
     this.host.commit(this, null, true);
   }
 };
+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 loadMixer(current, color);
@@ -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) };
     }
@@ -1896,6 +2214,7 @@ function downloadBytes(bytes, fileName, mimeType) {
 // src/paint-editor/wet.ts
 var STROKE_WATER = 0.9;
 var STROKE_MASS = PIGMENT_UNIT * 2.5;
+var STROKE_LIGHT = 1.5;
 var COVERAGE_STEPS = 4096;
 function union2(a, b) {
   if (!a) return { ...b };
@@ -1927,8 +2246,10 @@ var WetStrokeDriver = class {
     this.medium = new 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 = exchangeRates(brush.behavior.pickup, brush.behavior.mix, wet.load, brush.behavior.mixing);
     this.states = copies.map((c, i) => ({
       walker: new PenDabWalker(brush, init.seed + i * 7919 | 0, c.linear),
@@ -1958,6 +2279,7 @@ var WetStrokeDriver = class {
   paint = [0, 0, 0];
   centre = [0, 0, 0];
   depth;
+  lightBase;
   sampler;
   sample = { rgb: [0, 0, 0], alpha: 1 };
   copies;
@@ -2056,6 +2378,7 @@ var WetStrokeDriver = 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) {
@@ -2244,6 +2567,7 @@ var PaintWetLayers = class {
       const flow = this.settings.get(l.id)?.flow;
       return {
         base: translateSurface(l.base, left, top),
+        ...l.light ? { light: translateSurface(l.light, left, top) } : {},
         flow: l.flow && flow && flow.kind !== "none" ? flowField(flow, width, height) : l.flow
       };
     });
@@ -2283,7 +2607,7 @@ var PaintWetLayers = class {
     if (!w.hasLane(layerId)) {
       const base = this.host.layerSurface(layerId) ?? new 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, flowField(s.flow, width, height), s.flow.strength);
     }
@@ -2341,6 +2665,7 @@ var PaintWetLayers = 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,9 +2681,21 @@ var PaintWetLayers = 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;
@@ -2366,7 +2703,9 @@ var PaintWetLayers = class {
     for (const id of w.laneIds()) {
       if (w.isActive(id) || this.driver?.init.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]]), []);
     }
   }
@@ -2485,6 +2824,12 @@ var PaintWetLayers = 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 (!w?.hasLane(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;
@@ -2605,6 +2950,7 @@ function paintTestStroke(surface, brush, paper, color, width, height) {
   const [r, g, b] = hexToRgb8(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 = s ?? result;
         thick = sess.thickChannels();
+        light = sess.lightChannel();
       }
     },
     {
@@ -2630,12 +2977,14 @@ function paintTestStroke(surface, brush, paper, color, width, height) {
       copies: [IDENTITY_COPY],
       mixerLoad: brushLoadForStroke(brush, 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, light ?? void 0, thick ?? void 0) : lit, light };
 }
 function renderBrushThumbnail(brush, options) {
   const width = Math.max(16, Math.min(512, Math.round(options.width ?? 160)));
@@ -2652,9 +3001,15 @@ function renderBrushThumbnail(brush, options) {
     surface = fillRect(surface, { x: 0, y: 0, width, height: half }, rgba);
     surface = fillRect(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 };
 }
 
@@ -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 paper.backlight ?? 0;
+}
+var LIN = new Float64Array(256);
+for (let i = 0; i < 256; i++) LIN[i] = srgbToLinear(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) / TILE);
+  const y0 = Math.floor((rect.y - offset.y) / TILE);
+  const x1 = Math.floor((rect.x - offset.x + rect.width - 1) / TILE);
+  const y1 = Math.floor((rect.y - offset.y + rect.height - 1) / TILE);
+  for (let ty = y0; ty <= y1; ty++) for (let tx = x0; tx <= x1; tx++) out.push(surface.tiles.get(tileKey(tx, ty)) ?? null);
+}
+var sameRefs = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
+var BacklightCache = class {
+  tiles = /* @__PURE__ */ new Map();
+  key = "";
+  spillOf = null;
+  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, 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 / TILE);
+    const tilesY = Math.ceil(height / TILE);
+    const refs = [];
+    for (let ty = 0; ty < tilesY; ty++) {
+      for (let tx = 0; tx < tilesX; tx++) {
+        const rect = { x: tx * TILE, y: ty * TILE, width: Math.min(TILE, width - tx * TILE), height: Math.min(TILE, height - ty * TILE) };
+        refs.length = 0;
+        for (const l of layers) {
+          tilesUnder(l.surface, rect, l.offset, refs);
+          tilesUnder(l.thick?.height, rect, l.offset, refs);
+          tilesUnder(l.thick?.material, rect, l.offset, refs);
+        }
+        const k = tileKey(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 TiledSurface(4, light, 0), color: new TiledSurface(4, color, 0), painted: new 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 TiledSurface(4, tiles, 0);
+    this.out = { parts, surface };
+    return surface;
+  }
+};
+var full4 = (t) => {
+  if (t.data.length === TILE * TILE * 4) return t.data;
+  const out = new Uint8ClampedArray(TILE * TILE * 4);
+  const u = 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(TILE * 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 finishTile(out, 4, 0);
+}
+function computeTile(paper, grain, amount, rect, layers) {
+  const n = rect.width * rect.height;
+  const [p0, p1, p2] = hexToRgb8(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] = hexToRgb8(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 = readRegion(l.surface, lr);
+    const h = l.thick?.height.tiles.size ? readRegion(l.thick.height, lr) : null;
+    const m = h && l.thick?.material.tiles.size ? readRegion(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(TILE * TILE * 4);
+  const color = new Uint8ClampedArray(TILE * TILE * 4);
+  const painted = new Uint8ClampedArray(TILE * TILE);
+  for (let y = 0, i = 0; y < rect.height; y++) {
+    for (let x = 0; x < rect.width; x++, i++) {
+      const o = (y * 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 * TILE + x] = pv;
+        color[o] = Math.round(linearToSrgb(add[0]) * 255);
+        color[o + 1] = Math.round(linearToSrgb(add[1]) * 255);
+        color[o + 2] = Math.round(linearToSrgb(add[2]) * 255);
+        color[o + 3] = 255;
+      }
+    }
+  }
+  return { light: finishTile(light, 4, 0), color: finishTile(color, 4, 0), painted: finishTile(painted, 1, 0) };
+}
+
 // src/paint-editor/replay.ts
 function replayItems(doc) {
   const items = [];
@@ -3535,6 +4097,12 @@ var PaintEditorController = class _PaintEditorController {
   dirty = "all";
   seedCounter = 1;
   strokeCounter = 1;
+  /** Light paint: each layer's spill settings (saved with the document, not undo steps; missing = the defaults). */
+  lightSpills = {};
+  lightCaches = /* @__PURE__ */ new Map();
+  /** Backlit paper: the light through the paint as drawn (live strokes too), and as committed (its spill). */
+  backlightView = new BacklightCache();
+  backlightCommitted = new BacklightCache();
   /** Live effect paint: playing and the frame rate cap (editor state), and the time the view shows. */
   effectPlaybackState = { playing: true, fps: 30 };
   effectTime = 0;
@@ -3596,6 +4164,12 @@ var PaintEditorController = class _PaintEditorController {
           this.doc = { ...this.doc, layers };
           this.emit(rects.length ? rects : "all");
         },
+        layerLight: (id) => this.doc.light?.[id] ?? null,
+        updateLights: (lights) => {
+          let light = this.doc.light;
+          for (const [id, surface] of lights) if (findLayer(this.doc.layers, id)) light = withLayerLight(light, id, surface);
+          this.doc = { ...this.doc, ...light ? { light } : {} };
+        },
         changed: () => {
         }
       },
@@ -4068,7 +4642,7 @@ var PaintEditorController = class _PaintEditorController {
     const layers = mapLayer(this.doc.layers, id, () => null);
     let active = this.doc.activeLayerId;
     if (active && !findLayer(layers, active)) active = flattenLayers(layers).filter((x) => x.type === "pixel").pop()?.id ?? null;
-    this.commit("Remove layer", { ...this.doc, layers, activeLayerId: active, ...this.thickWithout(flattenLayers([l]).map((x) => x.id)), ...this.stickersWithout(flattenLayers([l]).map((x) => x.id)), ...this.liveStrokesWithout(flattenLayers([l]).map((x) => x.id)) });
+    this.commit("Remove layer", { ...this.doc, layers, activeLayerId: active, ...this.thickWithout(flattenLayers([l]).map((x) => x.id)), ...this.stickersWithout(flattenLayers([l]).map((x) => x.id)), ...this.liveStrokesWithout(flattenLayers([l]).map((x) => x.id)), ...this.lightWithout(flattenLayers([l]).map((x) => x.id)) });
     return { removed: id, activeLayerId: active };
   }
   duplicateLayer(id) {
@@ -4082,8 +4656,11 @@ var PaintEditorController = class _PaintEditorController {
     const thick = { ...this.doc.thick ?? {} };
     const stickers = { ...this.doc.stickers ?? {} };
     const liveStrokes = { ...this.doc.liveStrokes ?? {} };
+    const light = { ...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 }));
@@ -4091,7 +4668,7 @@ var PaintEditorController = class _PaintEditorController {
     };
     const dup = { ...copy(loc.layer), name: `${loc.layer.name} copy` };
     const layers = insertLayer(this.doc.layers, dup, loc.parent?.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.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). */
@@ -4137,7 +4714,11 @@ var PaintEditorController = class _PaintEditorController {
     }
     const merged = { ...below, surface, offset: { x: 0, y: 0 } };
     const layers = mapLayer(mapLayer(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 ? translateSurface(t, l.offset.x, l.offset.y) : void 0;
+    const mergedLight = this.doc.light?.[upper.id] || this.doc.light?.[below.id] ? mergeLight(toDoc(this.doc.light?.[below.id], below), upper.visible ? toDoc(this.doc.light?.[upper.id], upper) : void 0, translateSurface(upper.surface, upper.offset.x, upper.offset.y)) : void 0;
+    const lightAfter = this.lightWithout([upper.id, below.id]).light ?? (this.doc.light ? { ...this.doc.light } : void 0);
+    const light = mergedLight ? { ...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 = class _PaintEditorController {
       this.wet.world.removeLane(l.id);
     }
     const bounds = this.describeLayer(l).bounds;
-    this.commit("Clear layer", this.withPaintEvent({ ...this.doc, layers: mapLayer(this.doc.layers, l.id, () => ({ ...l, surface: emptySurface(4) })), ...this.thickWithout([l.id]), ...this.stickersWithout([l.id]), ...this.doc.liveStrokes?.[l.id] ? { liveStrokes: { ...this.doc.liveStrokes, [l.id]: [] } } : {} }, { kind: "clear", layerId: l.id }));
+    this.commit("Clear layer", this.withPaintEvent({ ...this.doc, layers: mapLayer(this.doc.layers, l.id, () => ({ ...l, surface: emptySurface(4) })), ...this.thickWithout([l.id]), ...this.stickersWithout([l.id]), ...this.doc.liveStrokes?.[l.id] ? { liveStrokes: { ...this.doc.liveStrokes, [l.id]: [] } } : {}, ...this.lightWithout([l.id]) }, { kind: "clear", layerId: l.id }));
     return { layerId: l.id, bounds };
   }
   /**
@@ -4193,7 +4774,9 @@ var PaintEditorController = class _PaintEditorController {
       offset: l.offset
     };
     const surface = this.applyCoverage(l, coverage, rect, apply);
-    this.commit("Fill layer", this.withPaintEvent(this.withWetEvents({ ...this.doc, layers: mapLayer(this.doc.layers, l.id, () => ({ ...l, surface })) }), { kind: "fill", layerId: l.id, data: { color, opacity, grain: grainAmount, pressure, blend } }));
+    const lit = this.doc.light?.[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: mapLayer(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) {
@@ -4851,6 +5434,9 @@ var PaintEditorController = class _PaintEditorController {
     })();
     const brush = this.strokeBrush(init);
     const effect = this.strokeEffect(init, brush);
+    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 (doc.liveStrokes?.[layer.id]) {
       const why = liveStrokeRefusal(brush);
       if (why) throw new PaintEditorError(`Layer "${layer.name}" is a stroke layer. ${why}`);
@@ -4947,6 +5533,8 @@ var PaintEditorController = class _PaintEditorController {
       secondary: rgbaOf(this.secondaryColor),
       wet,
       thick: brush.engine === "impasto" ? { channels: doc.thick?.[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 || doc.light?.[layer.id]) ? { surface: doc.light?.[layer.id] ?? emptyLight() } : null,
       sticker: brush.engine === "sticker" ? { nextId: this.nextStickerNumber(doc) } : void 0,
       paint: effect ? null : this.strokeGradient(init, brush, color),
       effect
@@ -5029,7 +5617,9 @@ var PaintEditorController = class _PaintEditorController {
         const thick = ch ? { ...this.doc.thick ?? {}, [l.id]: ch } : this.doc.thick;
         const sprayed = s.stickers();
         const stickers = sprayed ? { ...this.doc.stickers ?? {}, [l.id]: [...this.doc.stickers?.[l.id] ?? [], ...sprayed] } : this.doc.stickers;
-        this.commit(`${brush.name} stroke`, this.withWetEvents(withLiveStroke({ ...this.doc, layers: mapLayer(this.doc.layers, l.id, () => ({ ...l, surface })), strokes: [...this.doc.strokes, stroke], ...thick ? { thick } : {}, ...stickers ? { stickers } : {} }, stroke)), wetStroke ? before : this.doc);
+        const wetLight = wetStroke && this.wet.world?.hasLane(l.id) ? this.wet.world.lightDisplay(l.id) : null;
+        const light = withLayerLight(this.doc.light, l.id, s.lightChannel() ?? wetLight);
+        this.commit(`${brush.name} stroke`, this.withWetEvents(withLiveStroke({ ...this.doc, layers: mapLayer(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;
@@ -5062,12 +5652,14 @@ var PaintEditorController = class _PaintEditorController {
         const offset = s.init.wet ? { x: 0, y: 0 } : l.offset;
         const ch = s.thickChannels();
         const sprayed = s.stickers();
+        const lit = s.lightChannel() ?? (s.init.wet && this.wet.world?.hasLane(l.id) ? this.wet.world.lightDisplay(l.id) : null);
         out = withLiveStroke({
           ...out,
           layers: mapLayer(out.layers, l.id, () => ({ ...l, surface, offset })),
           strokes: [...out.strokes, stroke],
           ...ch ? { thick: { ...out.thick ?? {}, [l.id]: ch } } : {},
-          ...sprayed ? { stickers: { ...out.stickers ?? {}, [l.id]: [...out.stickers?.[l.id] ?? [], ...sprayed] } } : {}
+          ...sprayed ? { stickers: { ...out.stickers ?? {}, [l.id]: [...out.stickers?.[l.id] ?? [], ...sprayed] } } : {},
+          ...lit ? { light: withLayerLight(out.light, l.id, lit) } : {}
         }, stroke);
       }
     };
@@ -5182,6 +5774,46 @@ var PaintEditorController = 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 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(this.doc.light?.[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) {
@@ -5530,8 +6162,62 @@ var PaintEditorController = 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 = this.doc.light ?? {};
+    const ids = /* @__PURE__ */ new Set([...Object.keys(light), ...Object.keys(this.doc.thick ?? {})]);
+    if (!ids.size) return layers;
+    let out = layers;
+    for (const id of ids) {
+      const l = findLayer(out, id)?.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], this.liveThick?.layerId === id ? this.liveThick.channels : this.doc.thick?.[id]);
+      if (glowed !== l.surface) out = mapLayer(out, id, () => ({ ...l, surface: glowed }));
+      const committed = findLayer(this.doc.layers, id)?.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 && this.liveThick?.layerId === l.id ? this.liveThick.channels : this.doc.thick?.[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((options.wet ?? "display") === "dried" ? this.driedLayers() : this.currentLayers());
+    const base = (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(findLayer(layers, id)?.layer ?? this.requireLayer(id));
@@ -5560,13 +6246,13 @@ var PaintEditorController = class _PaintEditorController {
   }
   /** The canvas (or some layers), scaled so the longest side is at most `maxSide`. */
   renderPreview(options = {}) {
-    const full = this.compositePixels({ ...options, wet: options.wet ?? "display" });
+    const full2 = this.compositePixels({ ...options, wet: options.wet ?? "display" });
     const side = Math.max(1, Math.round(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. */
@@ -5618,6 +6304,17 @@ var PaintEditorController = class _PaintEditorController {
     for (const [id, list] of Object.entries(this.doc.liveStrokes ?? {})) if (findLayer(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 light = {};
+    for (const [id, t] of Object.entries(this.doc.light ?? {})) {
+      if (!findLayer(this.doc.layers, id)) continue;
+      const saved = lightToJSON(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]) => findLayer(this.doc.layers, id)));
+    if (Object.keys(spills).length) ext.lightSpill = spills;
+    else delete ext.lightSpill;
     const effectLayers = effectLayersToJSON(this.doc.effectLayers ?? {}, (id) => isPixelLayer(findLayer(this.doc.layers, id)?.layer));
     if (effectLayers) ext.effectLayers = effectLayers;
     else delete ext.effectLayers;
@@ -5668,6 +6365,29 @@ var PaintEditorController = 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 (findLayer(state.layers, id)) this.lightSpills[id] = normalizeLightSpill(v ?? {});
+        } catch {
+          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(findLayer(state.layers, id)?.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 = {};
@@ -5709,6 +6429,8 @@ var PaintEditorController = class _PaintEditorController {
     }
     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 = class _PaintEditorController {
     return encodePng(img.width, img.height, img.data);
   }
   scaled(options) {
-    const full = this.compositePixels(options);
+    const full2 = this.compositePixels(options);
     const s = 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 = 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 = {
@@ -5802,6 +6526,12 @@ var PaintEditorController = class _PaintEditorController {
       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(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. */
@@ -6807,6 +7537,20 @@ var PaintEditorController = class _PaintEditorController {
 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 = { ...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 s.paint?.type === "effect" && s.paint.live === true;
 }
@@ -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: {
@@ -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",
@@ -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
 };
@@ -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)." };
@@ -8321,6 +9110,7 @@ function brushSummary(b) {
     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)
   };
 }
@@ -8431,7 +9221,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
   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,7 +9431,7 @@ 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: () => {
@@ -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: {
@@ -9545,7 +10337,8 @@ 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;
@@ -9594,11 +10387,19 @@ var BLEND_MENU_GROUPS = [
   { label: "Standard", modes: BLEND_MODES.filter((m) => !m.painterly && m.id !== "pigment") },
   { label: "Paint", modes: 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" && brush.wet?.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 {
@@ -10128,6 +10929,7 @@ function createPaintEditorDocument(controller, options = {}) {
   });
 }
 export {
+  BACKLIGHT_SPILL,
   BLEND_MENU_GROUPS,
   BLEND_MODES,
   BRUSH_ID,
@@ -10135,6 +10937,7 @@ export {
   BRUSH_SLIDERS,
   BUILTIN_BRUSHES,
   BristleStroke,
+  DEFAULT_BACKLIGHT_COLOR,
   DEFAULT_BEHAVIOR,
   DEFAULT_BRISTLE,
   DEFAULT_BRUSH_ID,
@@ -10142,6 +10945,7 @@ export {
   DEFAULT_DYNAMICS,
   DEFAULT_FLOW,
   DEFAULT_IMPASTO,
+  DEFAULT_LIGHT,
   DEFAULT_LIGHTING,
   DEFAULT_MULTI_COLOR,
   DEFAULT_PAINT_GRADIENT,
@@ -10259,6 +11063,7 @@ export {
   addPaintGradientStop,
   affineCopy,
   applyAffine,
+  backlightOf,
   brushEngineControls,
   brushLoadColor,
   brushLoadForStroke,
@@ -10340,6 +11145,7 @@ export {
   normalizeFlow,
   normalizeHexColor,
   normalizeImpasto,
+  normalizeLight,
   normalizeLighting,
   normalizeMultiColor,
   normalizePaintBrush,