@pixerate/editor 0.242.0 → 0.243.0

package/dist/paint-editor/index.js

@@ -7,7 +7,7 @@ import {
   resolveExternalAssets,
   serializeLayers,
   serializeLayersExternal
-} from "../chunk-NE6OOKWJ.js";
+} from "../chunk-SRXWDOUI.js";
 import "../chunk-3CI7FRMK.js";
 import "../chunk-ZNA3IQZF.js";
 import {
@@ -55,7 +55,7 @@ import {
   realPresenceClock,
   tweenPresenceCursor
 } from "../chunk-IVSWRVB4.js";
-import "../chunk-ILM6GYAX.js";
+import "../chunk-6L3WWIDW.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-HQZHOPNE.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) };
     }
@@ -2605,6 +2923,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 +2931,7 @@ function paintTestStroke(surface, brush, paper, color, width, height) {
       commit: (sess, s) => {
         result = s ?? result;
         thick = sess.thickChannels();
+        light = sess.lightChannel();
       }
     },
     {
@@ -2630,12 +2950,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 +2974,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 +3455,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;
 }
@@ -3535,6 +3864,9 @@ 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();
   /** Live effect paint: playing and the frame rate cap (editor state), and the time the view shows. */
   effectPlaybackState = { playing: true, fps: 30 };
   effectTime = 0;
@@ -4068,7 +4400,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 +4414,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 +4426,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 +4472,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 +4488,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 +4532,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 +5192,10 @@ var PaintEditorController = class _PaintEditorController {
     })();
     const brush = this.strokeBrush(init);
     const effect = this.strokeEffect(init, brush);
+    if (brush.light.amount > 0) {
+      if (brush.engine === "wet") throw new PaintEditorError(`The ${brush.name} brush paints wet media, which doesn't take light yet (glowing watercolour is planned in #494); paint light with a dab or impasto light brush (list_brushes category light), or set light.amount to 0 (set_brush).`);
+      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 +5292,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 +5376,8 @@ 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 light = withLayerLight(this.doc.light, l.id, s.lightChannel());
+        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;
@@ -5067,7 +5415,8 @@ var PaintEditorController = class _PaintEditorController {
           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] } } : {},
+          ...s.lightChannel() ? { light: withLayerLight(out.light, l.id, s.lightChannel()) } : {}
         }, stroke);
       }
     };
@@ -5182,6 +5531,45 @@ 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");
+    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 +5918,31 @@ 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;
+  }
   renderLayers(options, view = false) {
-    let layers = this.litLayers((options.wet ?? "display") === "dried" ? this.driedLayers() : this.currentLayers());
+    let layers = this.lightLayers(this.litLayers((options.wet ?? "display") === "dried" ? this.driedLayers() : this.currentLayers()));
     if (options.layerIds) {
       const picked = [];
       for (const id of options.layerIds) picked.push(findLayer(layers, id)?.layer ?? this.requireLayer(id));
@@ -5560,13 +5971,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 +6029,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(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 +6090,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 +6154,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 +6189,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 +6218,7 @@ var PaintEditorController = class _PaintEditorController {
    * pixels), and the composite as the merged image.
    */
   exportPsd() {
-    const dried = this.litLayers(this.driedLayers(this.doc.layers));
+    const dried = this.lightLayers(this.litLayers(this.driedLayers(this.doc.layers)));
     const { width, height, dpi } = this.doc.canvas;
     const paperPixels = this.compositePixels({ layerIds: [], paper: true });
     const paperLayer = {
@@ -5802,6 +6249,9 @@ 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 (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 +7257,19 @@ 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;
+}
+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;
 }
@@ -7955,6 +8418,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 +8701,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 and impasto brushes take it; wet 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 +8783,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 +8829,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)
   };
 }
@@ -8639,7 +9148,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; 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: () => {
@@ -9594,11 +10103,18 @@ 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);
+  if (!c || !["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 {
@@ -10142,6 +10658,7 @@ export {
   DEFAULT_DYNAMICS,
   DEFAULT_FLOW,
   DEFAULT_IMPASTO,
+  DEFAULT_LIGHT,
   DEFAULT_LIGHTING,
   DEFAULT_MULTI_COLOR,
   DEFAULT_PAINT_GRADIENT,
@@ -10340,6 +10857,7 @@ export {
   normalizeFlow,
   normalizeHexColor,
   normalizeImpasto,
+  normalizeLight,
   normalizeLighting,
   normalizeMultiColor,
   normalizePaintBrush,