@pixerate/editor 0.101.0 → 0.103.0

package/dist/paint-editor/index.cjs

@@ -0,0 +1,3330 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7;
+
+
+
+
+
+var _chunkVSMM7B3Pcjs = require('../chunk-VSMM7B3P.cjs');
+
+
+
+
+
+
+
+
+
+var _chunkWSTEXEKDcjs = require('../chunk-WSTEXEKD.cjs');
+require('../chunk-MUUXNRU4.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkPV42JITTcjs = require('../chunk-PV42JITT.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkCRMAXIUVcjs = require('../chunk-CRMAXIUV.cjs');
+require('../chunk-DWGZUSES.cjs');
+
+// src/paint-editor/noise.ts
+function mix32(h) {
+  h ^= h >>> 16;
+  h = Math.imul(h, 2246822507);
+  h ^= h >>> 13;
+  h = Math.imul(h, 3266489909);
+  h ^= h >>> 16;
+  return h >>> 0;
+}
+function hash2(x, y, salt) {
+  const h = mix32((Math.imul(x | 0, 668265261) ^ mix32((y | 0) + Math.imul(salt | 0, 374761393))) >>> 0);
+  return h / 4294967296;
+}
+function rand01(seed, index, stream) {
+  return hash2(index, stream, seed);
+}
+function randSigned(seed, index, stream) {
+  return rand01(seed, index, stream) * 2 - 1;
+}
+function seedFromString(text) {
+  let h = 2166136261;
+  for (let i = 0; i < text.length; i++) {
+    h ^= text.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return mix32(h >>> 0);
+}
+var smooth = (t) => t * t * (3 - 2 * t);
+var Lattice = class {
+  constructor(px, py, salt) {
+    this.px = px;
+    this.py = py;
+    this.values = new Float32Array(px * py);
+    for (let j = 0; j < py; j++) for (let i = 0; i < px; i++) this.values[j * px + i] = hash2(i, j, salt);
+  }
+  
+  
+  
+  /** Value noise at (x, y) in lattice cells; wraps every `px` / `py` cells. */
+  at(x, y) {
+    const { px, py } = this;
+    const x0 = Math.floor(x);
+    const y0 = Math.floor(y);
+    const tx = smooth(x - x0);
+    const ty = smooth(y - y0);
+    const i0 = (x0 % px + px) % px;
+    const j0 = (y0 % py + py) % py;
+    const i1 = (i0 + 1) % px;
+    const j1 = (j0 + 1) % py;
+    const v = this.values;
+    const a = v[j0 * px + i0] + (v[j0 * px + i1] - v[j0 * px + i0]) * tx;
+    const b = v[j1 * px + i0] + (v[j1 * px + i1] - v[j1 * px + i0]) * tx;
+    return a + (b - a) * ty;
+  }
+};
+var TileableNoise = (_class = class {
+  constructor(size, cellsX, cellsY, octaves, salt) {;_class.prototype.__init.call(this);
+    this.size = size;
+    let cx = Math.max(1, Math.round(cellsX));
+    let cy = Math.max(1, Math.round(cellsY));
+    for (let o = 0; o < octaves; o++) {
+      this.octaves.push(new Lattice(cx, cy, salt + o * 7919 | 0));
+      cx *= 2;
+      cy *= 2;
+    }
+  }
+  
+  __init() {this.octaves = []}
+  /** Fractal noise at pixel (x, y). */
+  at(x, y) {
+    let sum = 0;
+    let amp = 1;
+    let norm = 0;
+    const u = x / this.size;
+    const v = y / this.size;
+    for (const l of this.octaves) {
+      sum += l.at(u * l.px, v * l.py) * amp;
+      norm += amp;
+      amp *= 0.5;
+    }
+    return norm > 0 ? sum / norm : 0.5;
+  }
+}, _class);
+
+// src/paint-editor/paper.ts
+var GRAIN_PATTERNS = ["smooth", "cold-pressed", "hot-pressed", "rough", "vellum", "laid", "ingres", "sanded", "canvas", "linen", "gesso"];
+var PAPER_FAMILIES = ["watercolor", "drawing", "pastel", "canvas", "panel", "smooth"];
+var GRAIN_TILE = 256;
+var unit = (v, d) => typeof v === "number" && Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : d;
+var clampNum = (v, lo, hi, d) => typeof v === "number" && Number.isFinite(v) ? Math.min(hi, Math.max(lo, v)) : d;
+var HEX = /^#[0-9a-f]{6}$/i;
+var tuning = (contrast = 1, invert = false) => ({ contrast, invert });
+function preset(id, name, family, pattern, color, o) {
+  return {
+    preset: id,
+    name,
+    family,
+    pattern,
+    seed: _nullishCoalesce(o.seed, () => ( 1)),
+    color,
+    scale: _nullishCoalesce(o.scale, () => ( 1)),
+    tiling: "mirror",
+    depth: o.depth,
+    shading: _nullishCoalesce(o.shading, () => ( 0.5)),
+    dry: tuning(_nullishCoalesce(o.contrast, () => ( 1))),
+    wet: tuning(1),
+    absorption: o.absorption,
+    permeability: o.permeability,
+    roughness: o.roughness
+  };
+}
+var PAPER_LIBRARY = [
+  preset("cold-pressed", "Cold pressed watercolour", "watercolor", "cold-pressed", "#f7f3ea", { depth: 0.5, absorption: 0.7, permeability: 0.5, roughness: 0.6 }),
+  preset("hot-pressed", "Hot pressed watercolour", "watercolor", "hot-pressed", "#f8f6ef", { depth: 0.25, absorption: 0.55, permeability: 0.4, roughness: 0.25 }),
+  preset("rough-watercolor", "Rough watercolour", "watercolor", "rough", "#f5f0e4", { depth: 0.75, absorption: 0.8, permeability: 0.6, roughness: 0.85 }),
+  preset("cartridge", "Cartridge", "drawing", "vellum", "#fbfaf6", { depth: 0.3, absorption: 0.4, permeability: 0.3, roughness: 0.35 }),
+  preset("laid", "Laid paper", "drawing", "laid", "#f3ecdc", { depth: 0.45, absorption: 0.45, permeability: 0.35, roughness: 0.45 }),
+  preset("ingres", "Charcoal paper", "drawing", "ingres", "#ede6d6", { depth: 0.6, absorption: 0.4, permeability: 0.3, roughness: 0.65 }),
+  preset("sanded-pastel", "Sanded pastel paper", "pastel", "sanded", "#d8cfc0", { depth: 0.7, absorption: 0.3, permeability: 0.2, roughness: 0.9, shading: 0.35 }),
+  preset("pastel-card", "Grey pastel card", "pastel", "sanded", "#9c978e", { depth: 0.55, absorption: 0.3, permeability: 0.2, roughness: 0.75, scale: 1.5, shading: 0.3 }),
+  preset("cotton-canvas", "Cotton canvas", "canvas", "canvas", "#efe9dc", { depth: 0.55, absorption: 0.35, permeability: 0.25, roughness: 0.6 }),
+  preset("fine-linen", "Fine linen", "canvas", "linen", "#e9e2d2", { depth: 0.45, absorption: 0.3, permeability: 0.25, roughness: 0.5 }),
+  preset("gesso", "Gesso panel", "panel", "gesso", "#f6f4ef", { depth: 0.35, absorption: 0.2, permeability: 0.15, roughness: 0.4 }),
+  preset("smooth", "Smooth bristol", "smooth", "smooth", "#ffffff", { depth: 0, absorption: 0.3, permeability: 0.2, roughness: 0.05, shading: 0 })
+];
+var DEFAULT_PAPER = PAPER_LIBRARY[0];
+function paperPreset(id) {
+  const p = PAPER_LIBRARY.find((x) => x.preset === id);
+  return p ? clonePaper(p) : void 0;
+}
+function clonePaper(p) {
+  return { ...p, dry: { ...p.dry }, wet: { ...p.wet } };
+}
+function readTuning(raw, d) {
+  const r = raw && typeof raw === "object" ? raw : {};
+  return { contrast: clampNum(r.contrast, 0, 3, d.contrast), invert: typeof r.invert === "boolean" ? r.invert : d.invert };
+}
+function normalizePaper(raw = {}, base) {
+  const r = raw;
+  const b = _nullishCoalesce(_nullishCoalesce(base, () => ( (typeof r.preset === "string" ? paperPreset(r.preset) : void 0))), () => ( clonePaper(DEFAULT_PAPER)));
+  return {
+    preset: typeof r.preset === "string" && r.preset ? r.preset : b.preset,
+    name: typeof r.name === "string" && r.name.trim() ? r.name.trim() : b.name,
+    family: PAPER_FAMILIES.includes(r.family) ? r.family : b.family,
+    pattern: GRAIN_PATTERNS.includes(r.pattern) ? r.pattern : b.pattern,
+    seed: typeof r.seed === "number" && Number.isFinite(r.seed) ? Math.round(Math.abs(r.seed)) % 2147483647 : b.seed,
+    color: typeof r.color === "string" && HEX.test(r.color) ? r.color.toLowerCase() : b.color,
+    scale: clampNum(r.scale, 0.25, 8, b.scale),
+    tiling: r.tiling === "repeat" || r.tiling === "mirror" ? r.tiling : b.tiling,
+    depth: unit(r.depth, b.depth),
+    shading: unit(r.shading, b.shading),
+    dry: readTuning(r.dry, b.dry),
+    wet: readTuning(r.wet, b.wet),
+    absorption: unit(r.absorption, b.absorption),
+    permeability: unit(r.permeability, b.permeability),
+    roughness: unit(r.roughness, b.roughness)
+  };
+}
+var clamp01 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+function patternHeights(pattern, n, seed) {
+  const out = new Float32Array(n * n);
+  const salt = Math.imul(seed | 0, 2654435761) + 17;
+  if (pattern === "smooth") return out.fill(1);
+  const noise = (cx, cy, oct, s = 0) => new TileableNoise(n, cx, cy, oct, salt + s);
+  const k = n / GRAIN_TILE;
+  switch (pattern) {
+    case "cold-pressed": {
+      const base = noise(20 * k, 20 * k, 4);
+      const fine = noise(64 * k, 64 * k, 2, 3);
+      for (let y = 0; y < n; y++)
+        for (let x = 0; x < n; x++) out[y * n + x] = clamp01((base.at(x, y) - 0.5) * 1.8 + 0.5 + (fine.at(x, y) - 0.5) * 0.5 + (hash2(x, y, salt) - 0.5) * 0.12);
+      break;
+    }
+    case "hot-pressed": {
+      const base = noise(40 * k, 40 * k, 3);
+      for (let y = 0; y < n; y++) for (let x = 0; x < n; x++) out[y * n + x] = clamp01((base.at(x, y) - 0.5) * 1.1 + 0.6 + (hash2(x, y, salt) - 0.5) * 0.08);
+      break;
+    }
+    case "rough": {
+      const base = noise(10 * k, 10 * k, 5);
+      const blot = noise(28 * k, 28 * k, 2, 5);
+      for (let y = 0; y < n; y++)
+        for (let x = 0; x < n; x++) out[y * n + x] = clamp01((base.at(x, y) - 0.5) * 2.4 + 0.5 + (blot.at(x, y) - 0.5) * 0.7 + (hash2(x, y, salt) - 0.5) * 0.15);
+      break;
+    }
+    case "vellum": {
+      const base = noise(40 * k, 40 * k, 3);
+      for (let y = 0; y < n; y++) for (let x = 0; x < n; x++) out[y * n + x] = clamp01((base.at(x, y) - 0.5) * 1.6 + 0.55 + (hash2(x, y, salt) - 0.5) * 0.2);
+      break;
+    }
+    case "laid": {
+      const pulp = noise(32 * k, 32 * k, 3);
+      const chain = n / 8;
+      for (let y = 0; y < n; y++) {
+        const laid = 0.5 + 0.5 * Math.cos(2 * Math.PI * y / 4);
+        for (let x = 0; x < n; x++) {
+          const c = Math.abs((x + 0.5) % chain - chain / 2) / (chain / 2);
+          const chainLine = c > 0.94 ? -0.35 : 0;
+          out[y * n + x] = clamp01(0.3 + 0.5 * laid + chainLine + (pulp.at(x, y) - 0.5) * 0.6);
+        }
+      }
+      break;
+    }
+    case "ingres": {
+      const fibres = noise(64 * k, 12 * k, 3);
+      const base = noise(16 * k, 16 * k, 3, 7);
+      for (let y = 0; y < n; y++)
+        for (let x = 0; x < n; x++) {
+          const g = hash2(x, y, salt ^ 85);
+          out[y * n + x] = clamp01((fibres.at(x, y) - 0.5) * 1.5 + (base.at(x, y) - 0.5) * 0.7 + 0.55 + (g < 0.1 ? -0.3 : 0));
+        }
+      break;
+    }
+    case "sanded": {
+      const grit = noise(96 * k, 96 * k, 2);
+      for (let y = 0; y < n; y++)
+        for (let x = 0; x < n; x++) {
+          const h = hash2(x, y, salt);
+          out[y * n + x] = clamp01((grit.at(x, y) - 0.5) * 2.4 + 0.5 + (h - 0.5) * 0.7);
+        }
+      break;
+    }
+    case "canvas":
+    case "linen": {
+      const period = (pattern === "canvas" ? 8 : 5) * k;
+      const threads = Math.max(2, 2 * Math.round(n / period / 2));
+      const p = n / threads;
+      const slub = noise(threads, threads, 2, 11);
+      for (let y = 0; y < n; y++)
+        for (let x = 0; x < n; x++) {
+          const fx = (x + 0.5) / p;
+          const fy = (y + 0.5) / p;
+          const cx = Math.floor(fx);
+          const cy = Math.floor(fy);
+          const warp = Math.sin(Math.PI * (fx - cx));
+          const weft = Math.sin(Math.PI * (fy - cy));
+          const top = (cx + cy) % 2 === 0 ? warp : weft;
+          const irregular = pattern === "linen" ? (slub.at(x, y) - 0.5) * 0.5 : 0;
+          out[y * n + x] = clamp01(0.2 + 0.7 * top + irregular + (hash2(x, y, salt) - 0.5) * 0.15);
+        }
+      break;
+    }
+    case "gesso": {
+      const streaks = noise(2 * k, 28 * k, 3);
+      const tooth = noise(64 * k, 64 * k, 2, 13);
+      for (let y = 0; y < n; y++)
+        for (let x = 0; x < n; x++) out[y * n + x] = clamp01((streaks.at(x, y) - 0.5) * 1.8 + (tooth.at(x, y) - 0.5) * 0.9 + 0.55);
+      break;
+    }
+  }
+  return out;
+}
+var rawCache = /* @__PURE__ */ new Map();
+function grainHeights(pattern, seed, size = GRAIN_TILE) {
+  const key = `${pattern}:${seed}:${size}`;
+  let h = rawCache.get(key);
+  if (!h) {
+    h = patternHeights(pattern, size, seed);
+    if (rawCache.size > 32) rawCache.delete(rawCache.keys().next().value);
+    rawCache.set(key, h);
+  }
+  return h;
+}
+var PaperGrain = (_class2 = class {
+  __init2() {this.size = GRAIN_TILE}
+  
+  
+  
+  
+  constructor(paper, media = "dry") {;_class2.prototype.__init2.call(this);
+    const raw = grainHeights(paper.pattern, paper.seed);
+    const t = paper[media];
+    this.flat = paper.pattern === "smooth";
+    if (t.contrast === 1 && !t.invert) this.heights = raw;
+    else {
+      const out = new Float32Array(raw.length);
+      for (let i = 0; i < raw.length; i++) {
+        const v = clamp01((raw[i] - 0.5) * t.contrast + 0.5);
+        out[i] = t.invert ? 1 - v : v;
+      }
+      this.heights = out;
+    }
+    this.scale = paper.scale;
+    this.mirror = paper.tiling === "mirror";
+  }
+  /** Tile cell index for a coordinate in grain pixels (mirrored on odd tiles when mirroring). */
+  wrap(v) {
+    const n = this.size;
+    if (!this.mirror) return (v % n + n) % n;
+    const p = (v % (2 * n) + 2 * n) % (2 * n);
+    return p < n ? p : 2 * n - 1 - p;
+  }
+  /** Height 0..1 at document position (x, y). */
+  at(x, y) {
+    const u = x / this.scale - 0.5;
+    const v = y / this.scale - 0.5;
+    const x0 = Math.floor(u);
+    const y0 = Math.floor(v);
+    const fx = u - x0;
+    const fy = v - y0;
+    const n = this.size;
+    const h = this.heights;
+    const a = this.wrap(x0);
+    const b = this.wrap(x0 + 1);
+    const c = this.wrap(y0) * n;
+    const d = this.wrap(y0 + 1) * n;
+    const top = h[c + a] + (h[c + b] - h[c + a]) * fx;
+    const bot = h[d + a] + (h[d + b] - h[d + a]) * fx;
+    return top + (bot - top) * fy;
+  }
+}, _class2);
+function grainCatch(h, depth, pressure) {
+  if (depth <= 0) return 1;
+  const t = depth * (0.75 - 0.65 * Math.min(1, Math.max(0, pressure)));
+  const u = clamp01((h - t + 0.18) / 0.36);
+  return 1 - depth + depth * u * u * (3 - 2 * u);
+}
+function hexToRgb8(hex) {
+  const n = parseInt(hex.slice(1, 7), 16);
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+}
+function renderPaper(paper, rect, grain = new PaperGrain(paper)) {
+  const [r, g, b] = hexToRgb8(paper.color);
+  const out = new Uint8ClampedArray(rect.width * rect.height * 4);
+  const shade = grain.flat ? 0 : paper.shading * 0.16;
+  for (let y = 0; y < rect.height; y++) {
+    for (let x = 0; x < rect.width; x++) {
+      const i = (y * rect.width + x) * 4;
+      const k = shade ? 1 - shade * (1 - grain.at(rect.x + x + 0.5, rect.y + y + 0.5)) : 1;
+      out[i] = r * k;
+      out[i + 1] = g * k;
+      out[i + 2] = b * k;
+      out[i + 3] = 255;
+    }
+  }
+  return out;
+}
+
+// src/paint-editor/document.ts
+var MIN_CANVAS_SIDE = 1;
+var MAX_CANVAS_SIDE = 16384;
+var DEFAULT_DPI = 300;
+var nextId = 1;
+function newPaintLayerId() {
+  return `pl${Date.now().toString(36)}${(nextId++).toString(36)}`;
+}
+function createPaintLayer(name, id = newPaintLayerId()) {
+  return { type: "pixel", id, name, visible: true, opacity: 1, blend: "normal", surface: _chunkCRMAXIUVcjs.emptySurface.call(void 0, 4), offset: { x: 0, y: 0 } };
+}
+var PaintDocumentError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PaintDocumentError";
+  }
+};
+function normalizeCanvas(raw) {
+  const side = (v, what) => {
+    if (typeof v !== "number" || !Number.isFinite(v)) throw new PaintDocumentError(`${what} must be a number of pixels (${MIN_CANVAS_SIDE}..${MAX_CANVAS_SIDE}).`);
+    const n = Math.round(v);
+    if (n < MIN_CANVAS_SIDE || n > MAX_CANVAS_SIDE) throw new PaintDocumentError(`${what} ${n} is out of range; use ${MIN_CANVAS_SIDE}..${MAX_CANVAS_SIDE} pixels.`);
+    return n;
+  };
+  const dpi = raw.dpi === void 0 ? DEFAULT_DPI : raw.dpi;
+  if (typeof dpi !== "number" || !Number.isFinite(dpi) || dpi < 1 || dpi > 1e4) throw new PaintDocumentError(`dpi ${dpi} is out of range; use 1..10000.`);
+  return { width: side(raw.width, "width"), height: side(raw.height, "height"), dpi: Math.round(dpi * 100) / 100 };
+}
+function createPaintDocument(options = {}) {
+  const canvas = normalizeCanvas({ width: _nullishCoalesce(options.width, () => ( 2048)), height: _nullishCoalesce(options.height, () => ( 1536)), dpi: options.dpi });
+  const layer = createPaintLayer("Layer 1");
+  return { canvas, paper: normalizePaper(_nullishCoalesce(options.paper, () => ( {}))), layers: [layer], activeLayerId: layer.id, strokes: [] };
+}
+
+// src/paint-editor/brushes.ts
+var PAINT_BRUSH_ENGINES = ["dab", "eraser", "mixer"];
+var PAINT_BRUSH_CATEGORIES = ["pencil", "pastel", "charcoal", "airbrush", "marker", "ink", "eraser", "blender", "smudge", "mixer", "custom"];
+var BRUSH_ROTATIONS = ["fixed", "stroke", "barrel"];
+var DEFAULT_DYNAMICS = {
+  minSize: 0,
+  pressureFlow: 0,
+  tiltSize: 0,
+  tiltRoundness: 0,
+  tiltOpacity: 0,
+  velocitySize: 0,
+  velocityOpacity: 0,
+  sizeJitter: 0,
+  angleJitter: 0,
+  opacityJitter: 0,
+  scatter: 0
+};
+var unit2 = (v, d) => typeof v === "number" && Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : d;
+var range = (v, lo, hi, d) => typeof v === "number" && Number.isFinite(v) ? Math.min(hi, Math.max(lo, v)) : d;
+function normalizeDynamics(raw = {}, base = DEFAULT_DYNAMICS) {
+  return {
+    minSize: unit2(raw.minSize, base.minSize),
+    pressureFlow: unit2(raw.pressureFlow, base.pressureFlow),
+    tiltSize: unit2(raw.tiltSize, base.tiltSize),
+    tiltRoundness: unit2(raw.tiltRoundness, base.tiltRoundness),
+    tiltOpacity: unit2(raw.tiltOpacity, base.tiltOpacity),
+    velocitySize: range(raw.velocitySize, -1, 1, base.velocitySize),
+    velocityOpacity: range(raw.velocityOpacity, -1, 1, base.velocityOpacity),
+    sizeJitter: unit2(raw.sizeJitter, base.sizeJitter),
+    angleJitter: unit2(raw.angleJitter, base.angleJitter),
+    opacityJitter: unit2(raw.opacityJitter, base.opacityJitter),
+    scatter: range(raw.scatter, 0, 4, base.scatter)
+  };
+}
+var BRUSH_ID = /^[a-z0-9][a-z0-9-]{0,63}$/;
+function normalizePaintBrush(raw = {}, base) {
+  const b = _nullishCoalesce(base, () => ( BASE_BRUSH));
+  const id = typeof raw.id === "string" && BRUSH_ID.test(raw.id) ? raw.id : b.id;
+  return {
+    id,
+    name: typeof raw.name === "string" && raw.name.trim() ? raw.name.trim().slice(0, 80) : b.name,
+    category: PAINT_BRUSH_CATEGORIES.includes(raw.category) ? raw.category : b.category,
+    engine: PAINT_BRUSH_ENGINES.includes(raw.engine) ? raw.engine : b.engine,
+    tip: _chunkPV42JITTcjs.normalizeBrush.call(void 0, { ...b.tip, ..._nullishCoalesce(raw.tip, () => ( {})) }),
+    grain: unit2(raw.grain, b.grain),
+    pressureSmoothing: range(raw.pressureSmoothing, 0, 0.95, b.pressureSmoothing),
+    rotation: BRUSH_ROTATIONS.includes(raw.rotation) ? raw.rotation : b.rotation,
+    dynamics: normalizeDynamics(_nullishCoalesce(raw.dynamics, () => ( {})), b.dynamics),
+    mixer: _chunkPV42JITTcjs.normalizeMixer.call(void 0, { ...b.mixer, ..._nullishCoalesce(raw.mixer, () => ( {})) }),
+    loadsColor: typeof raw.loadsColor === "boolean" ? raw.loadsColor : b.loadsColor,
+    ...raw.builtin ? { builtin: true } : {}
+  };
+}
+var BASE_BRUSH = {
+  id: "round",
+  name: "Round",
+  category: "custom",
+  engine: "dab",
+  tip: { ..._chunkPV42JITTcjs.DEFAULT_BRUSH },
+  grain: 0,
+  pressureSmoothing: 0,
+  rotation: "fixed",
+  dynamics: { ...DEFAULT_DYNAMICS },
+  mixer: { ..._chunkPV42JITTcjs.DEFAULT_MIXER },
+  loadsColor: true
+};
+var builtin = (init) => ({ ...normalizePaintBrush(init), builtin: true });
+var BUILTIN_BRUSHES = [
+  builtin({
+    id: "pencil-hb",
+    name: "HB pencil",
+    category: "pencil",
+    tip: { size: 4, hardness: 0.7, spacing: 0.08, opacity: 0.85, flow: 0.55, smoothing: 0.25, pressureSize: true, pressureOpacity: true },
+    grain: 0.85,
+    pressureSmoothing: 0.3,
+    dynamics: { minSize: 0.55, tiltSize: 0.9, tiltRoundness: 0.7, tiltOpacity: 0.5 }
+  }),
+  builtin({
+    id: "pencil-6b",
+    name: "6B pencil",
+    category: "pencil",
+    tip: { size: 7, hardness: 0.55, spacing: 0.07, opacity: 1, flow: 0.75, smoothing: 0.2, pressureSize: true, pressureOpacity: true },
+    grain: 0.7,
+    pressureSmoothing: 0.3,
+    dynamics: { minSize: 0.5, tiltSize: 1, tiltRoundness: 0.75, tiltOpacity: 0.35 }
+  }),
+  builtin({
+    id: "soft-pastel",
+    name: "Soft pastel",
+    category: "pastel",
+    rotation: "stroke",
+    tip: { size: 32, hardness: 0.55, spacing: 0.05, angle: 90, roundness: 0.55, opacity: 1, flow: 0.7, smoothing: 0.15, pressureSize: false, pressureOpacity: true },
+    grain: 1,
+    pressureSmoothing: 0.25,
+    dynamics: { sizeJitter: 0.06, angleJitter: 0.02 }
+  }),
+  builtin({
+    id: "oil-pastel",
+    name: "Oil pastel",
+    category: "pastel",
+    rotation: "stroke",
+    tip: { size: 26, hardness: 0.8, spacing: 0.05, angle: 90, roundness: 0.7, opacity: 1, flow: 0.9, smoothing: 0.15, pressureSize: true, pressureOpacity: false, blend: "pigment" },
+    grain: 0.5,
+    pressureSmoothing: 0.25,
+    dynamics: { minSize: 0.6 }
+  }),
+  builtin({
+    id: "charcoal-stick",
+    name: "Charcoal stick",
+    category: "charcoal",
+    rotation: "stroke",
+    tip: { size: 26, hardness: 0.4, spacing: 0.05, angle: 90, roundness: 0.35, opacity: 0.95, flow: 0.5, smoothing: 0.15, pressureSize: false, pressureOpacity: true },
+    grain: 0.95,
+    pressureSmoothing: 0.2,
+    dynamics: { sizeJitter: 0.1, angleJitter: 0.03, tiltSize: 0.6 }
+  }),
+  builtin({
+    id: "vine-charcoal",
+    name: "Vine charcoal",
+    category: "charcoal",
+    tip: { size: 10, hardness: 0.3, spacing: 0.06, opacity: 0.75, flow: 0.45, smoothing: 0.2, pressureSize: true, pressureOpacity: true },
+    grain: 0.9,
+    pressureSmoothing: 0.2,
+    dynamics: { minSize: 0.4, tiltSize: 0.8, tiltRoundness: 0.5, tiltOpacity: 0.3, sizeJitter: 0.08 }
+  }),
+  builtin({
+    id: "airbrush",
+    name: "Airbrush",
+    category: "airbrush",
+    tip: { size: 90, hardness: 0, spacing: 0.04, opacity: 1, flow: 0.06, smoothing: 0.3, pressureSize: false, pressureOpacity: false },
+    grain: 0,
+    pressureSmoothing: 0.3,
+    dynamics: { pressureFlow: 1, tiltSize: 0.5, tiltRoundness: 0.6 }
+  }),
+  builtin({
+    id: "marker",
+    name: "Chisel marker",
+    category: "marker",
+    tip: { size: 24, hardness: 0.85, spacing: 0.04, angle: 45, roundness: 0.35, opacity: 0.6, flow: 1, smoothing: 0.3, pressureSize: false, pressureOpacity: false, blend: "multiply" },
+    grain: 0.1
+  }),
+  builtin({
+    id: "ink-pen",
+    name: "Ink pen",
+    category: "ink",
+    tip: { size: 4, hardness: 1, spacing: 0.05, opacity: 1, flow: 1, smoothing: 0.5, pressureSize: true, pressureOpacity: false },
+    pressureSmoothing: 0.4,
+    dynamics: { minSize: 0.25, velocitySize: -0.45 }
+  }),
+  builtin({
+    id: "brush-pen",
+    name: "Brush pen",
+    category: "ink",
+    rotation: "stroke",
+    tip: { size: 14, hardness: 0.9, spacing: 0.04, roundness: 0.8, opacity: 1, flow: 1, smoothing: 0.5, pressureSize: true, pressureOpacity: false },
+    pressureSmoothing: 0.45,
+    dynamics: { minSize: 0.05, velocitySize: -0.3 }
+  }),
+  builtin({
+    id: "eraser-soft",
+    name: "Soft eraser",
+    category: "eraser",
+    engine: "eraser",
+    tip: { size: 40, hardness: 0.2, spacing: 0.08, opacity: 1, flow: 0.6, pressureSize: false, pressureOpacity: true }
+  }),
+  builtin({
+    id: "eraser-hard",
+    name: "Hard eraser",
+    category: "eraser",
+    engine: "eraser",
+    tip: { size: 16, hardness: 0.9, spacing: 0.06, opacity: 1, flow: 1, pressureSize: true, pressureOpacity: false },
+    grain: 0.3,
+    dynamics: { minSize: 0.5 }
+  }),
+  builtin({
+    id: "blender",
+    name: "Blender",
+    category: "blender",
+    engine: "mixer",
+    loadsColor: false,
+    tip: { size: 34, hardness: 0.4, spacing: 0.08, opacity: 1, flow: 0.35, smoothing: 0.2, pressureSize: false, pressureOpacity: true },
+    mixer: { wet: 0.7, load: 0, mix: 1, loadEachStroke: false, cleanEachStroke: true, mixing: "pigment" }
+  }),
+  builtin({
+    id: "smudge",
+    name: "Smudge",
+    category: "smudge",
+    engine: "mixer",
+    loadsColor: false,
+    tip: { size: 26, hardness: 0.6, spacing: 0.06, opacity: 1, flow: 0.8, smoothing: 0.2, pressureSize: false, pressureOpacity: true },
+    mixer: { wet: 1, load: 0, mix: 1, loadEachStroke: false, cleanEachStroke: true, mixing: "rgb" }
+  }),
+  builtin({
+    id: "mixer-brush",
+    name: "Mixer Brush",
+    category: "mixer",
+    engine: "mixer",
+    tip: { size: 30, hardness: 0.7, spacing: 0.1, opacity: 1, flow: 0.5, smoothing: 0.2, pressureSize: true, pressureOpacity: false },
+    mixer: { wet: 0.5, load: 0.95, mix: 0.5, loadEachStroke: true, cleanEachStroke: true, mixing: "pigment" },
+    dynamics: { minSize: 0.5 }
+  })
+];
+var DEFAULT_BRUSH_ID = "pencil-6b";
+function brushToJSON(brush) {
+  const { builtin: _b, ...rest } = brush;
+  return JSON.parse(JSON.stringify(rest));
+}
+function parseBrushLibrary(raw, problems = []) {
+  const list = Array.isArray(raw) ? raw : raw && typeof raw === "object" && Array.isArray(raw.brushes) ? raw.brushes : null;
+  if (!list) throw new Error('Not a brush library: expected {"format":"pixerate-brushes","version":1,"brushes":[...]} or an array of brushes.');
+  const out = [];
+  list.forEach((item, i) => {
+    if (!item || typeof item !== "object") {
+      problems.push(`brushes[${i}] is not an object; skipped.`);
+      return;
+    }
+    const r = item;
+    if (typeof r.id !== "string" || !BRUSH_ID.test(r.id)) {
+      problems.push(`brushes[${i}] has no valid id (lowercase letters, digits and dashes); skipped.`);
+      return;
+    }
+    if (typeof r.name !== "string" || !r.name.trim()) {
+      problems.push(`brushes[${i}] ("${r.id}") has no name; skipped.`);
+      return;
+    }
+    const { builtin: _b, ...rest } = r;
+    out.push(normalizePaintBrush(rest));
+  });
+  return out;
+}
+
+// src/paint-editor/engine.ts
+function penOrientation(p) {
+  if (typeof p.altitude === "number" && Number.isFinite(p.altitude)) {
+    const altitude = Math.min(Math.PI / 2, Math.max(0, p.altitude));
+    const azimuth = typeof p.azimuth === "number" && Number.isFinite(p.azimuth) ? p.azimuth : 0;
+    return { altitude, azimuth };
+  }
+  const hasX = typeof p.tiltX === "number" && Number.isFinite(p.tiltX);
+  const hasY = typeof p.tiltY === "number" && Number.isFinite(p.tiltY);
+  if (!hasX && !hasY) return null;
+  return tiltToOrientation(hasX ? p.tiltX : 0, hasY ? p.tiltY : 0);
+}
+function tiltToOrientation(tiltX, tiltY) {
+  const clampT = (v) => Math.min(89.999, Math.max(-89.999, v));
+  const tx = Math.tan(clampT(tiltX) * Math.PI / 180);
+  const ty = Math.tan(clampT(tiltY) * Math.PI / 180);
+  const r = Math.hypot(tx, ty);
+  if (r < 1e-9) return { altitude: Math.PI / 2, azimuth: 0 };
+  let azimuth = Math.atan2(ty, tx);
+  if (azimuth < 0) azimuth += 2 * Math.PI;
+  return { altitude: Math.atan(1 / r), azimuth };
+}
+var pressureOf = (p) => typeof p.pressure === "number" && Number.isFinite(p.pressure) ? Math.min(1, Math.max(0, p.pressure)) : 1;
+var PenSmoother = (_class3 = class {
+  __init3() {this.pos = null}
+  __init4() {this.pressure = null}
+  
+  
+  constructor(position, pressure) {;_class3.prototype.__init3.call(this);_class3.prototype.__init4.call(this);
+    this.a = 1 - Math.min(0.95, Math.max(0, position));
+    this.ap = 1 - Math.min(0.95, Math.max(0, pressure));
+  }
+  push(p) {
+    const pr = pressureOf(p);
+    if (!this.pos) {
+      this.pos = { x: p.x, y: p.y };
+      this.pressure = pr;
+      return p;
+    }
+    this.pos = { x: this.pos.x + (p.x - this.pos.x) * this.a, y: this.pos.y + (p.y - this.pos.y) * this.a };
+    this.pressure = this.pressure + (pr - this.pressure) * this.ap;
+    return { ...p, x: this.pos.x, y: this.pos.y, pressure: this.pressure };
+  }
+  /** Where the smoothed position is now (or `null` before the first sample). */
+  get position() {
+    return this.pos;
+  }
+}, _class3);
+var IDENTITY_COPY = { map: (p) => p, linear: [1, 0, 0, 1] };
+var FULL_SPEED = 2.5;
+var PenDabWalker = (_class4 = class {
+  constructor(brush, seed = 0, linear = [1, 0, 0, 1]) {;_class4.prototype.__init5.call(this);_class4.prototype.__init6.call(this);_class4.prototype.__init7.call(this);_class4.prototype.__init8.call(this);_class4.prototype.__init9.call(this);_class4.prototype.__init10.call(this);_class4.prototype.__init11.call(this);
+    this.brush = brush;
+    this.seed = seed;
+    this.linear = linear;
+  }
+  
+  
+  
+  __init5() {this.last = null}
+  __init6() {this.nextAt = 0}
+  __init7() {this.pendingFirst = null}
+  __init8() {this.index = 0}
+  __init9() {this.dir = 0}
+  __init10() {this.lastT = null}
+  __init11() {this.speed = null}
+  sample(p) {
+    const o = penOrientation(p);
+    let speed = null;
+    if (typeof p.t === "number" && Number.isFinite(p.t)) {
+      if (this.last && this.lastT !== null && p.t > this.lastT) {
+        const v = Math.hypot(p.x - this.last.x, p.y - this.last.y) / (p.t - this.lastT);
+        this.speed = this.speed === null ? v : this.speed + (v - this.speed) * 0.35;
+      }
+      this.lastT = p.t;
+      speed = _nullishCoalesce(this.speed, () => ( 0));
+    }
+    return {
+      x: p.x,
+      y: p.y,
+      pressure: pressureOf(p),
+      lean: o ? 1 - o.altitude / (Math.PI / 2) : 0,
+      azimuth: o ? o.azimuth : 0,
+      twist: typeof p.twist === "number" && Number.isFinite(p.twist) ? p.twist : null,
+      speed
+    };
+  }
+  diameter(s) {
+    const tip = this.brush.tip;
+    const dyn = this.brush.dynamics;
+    let d = tip.size;
+    if (tip.pressureSize) d *= dyn.minSize + (1 - dyn.minSize) * s.pressure;
+    d *= 1 + dyn.tiltSize * s.lean * 1.5;
+    if (s.speed !== null && dyn.velocitySize) d *= Math.max(0.05, 1 + dyn.velocitySize * Math.min(1, s.speed / FULL_SPEED) * (dyn.velocitySize < 0 ? 0.85 : 1));
+    return d;
+  }
+  stepLen(s) {
+    return Math.max(0.5, Math.max(1, this.diameter(s)) * Math.max(0.01, this.brush.tip.spacing));
+  }
+  /** A rasterizer angle (CCW, y up) mapped through this copy's linear part. */
+  mapAngle(theta) {
+    const [a, b, c, d] = this.linear;
+    if (a === 1 && b === 0 && c === 0 && d === 1) return theta;
+    const vx = Math.cos(theta);
+    const vy = -Math.sin(theta);
+    return Math.atan2(-(c * vx + d * vy), a * vx + b * vy);
+  }
+  dab(s) {
+    const { tip, dynamics: dyn, rotation } = this.brush;
+    const i = this.index++;
+    const seed = this.seed;
+    let diameter = this.diameter(s);
+    if (dyn.sizeJitter) diameter *= Math.max(0.05, 1 + dyn.sizeJitter * randSigned(seed, i, 1 /* Size */));
+    const base = tip.angle * Math.PI / 180;
+    let angle;
+    if (rotation === "stroke") angle = this.dir + base;
+    else if (rotation === "barrel" && s.twist !== null) angle = this.mapAngle(base - s.twist * Math.PI / 180);
+    else if (dyn.tiltRoundness > 0 && s.lean > 0.02) angle = this.mapAngle(base - s.azimuth);
+    else angle = this.mapAngle(base);
+    if (dyn.angleJitter) angle += dyn.angleJitter * Math.PI * randSigned(seed, i, 2 /* Angle */);
+    let opacity = tip.pressureOpacity ? s.pressure : 1;
+    opacity *= 1 - dyn.tiltOpacity * s.lean * 0.8;
+    if (s.speed !== null && dyn.velocityOpacity) opacity *= Math.max(0, 1 + dyn.velocityOpacity * (Math.min(1, s.speed / FULL_SPEED) - 0.5));
+    if (dyn.opacityJitter) opacity *= 1 - dyn.opacityJitter * (randSigned(seed, i, 3 /* Opacity */) * 0.5 + 0.5);
+    const flow = tip.flow * (1 - dyn.pressureFlow + dyn.pressureFlow * s.pressure);
+    let { x, y } = s;
+    if (dyn.scatter) {
+      const off = dyn.scatter * diameter * randSigned(seed, i, 4 /* Scatter */);
+      x += Math.sin(this.dir) * off;
+      y += Math.cos(this.dir) * off;
+    }
+    return {
+      x,
+      y,
+      radius: Math.max(0.5, diameter / 2),
+      alpha: Math.min(1, Math.max(0, flow)),
+      opacity: Math.min(1, Math.max(0, opacity)),
+      angle,
+      roundness: Math.min(1, Math.max(0.01, tip.roundness * (1 - dyn.tiltRoundness * s.lean * 0.8))),
+      pressure: s.pressure
+    };
+  }
+  push(p, out) {
+    const a = this.last;
+    const s = this.sample(p);
+    if (!a) {
+      this.last = s;
+      this.pendingFirst = s;
+      this.nextAt = this.stepLen(s);
+      return;
+    }
+    const dx = s.x - a.x;
+    const dy = s.y - a.y;
+    const len = Math.hypot(dx, dy);
+    if (len > 1e-9) this.dir = Math.atan2(-dy, dx);
+    if (this.pendingFirst) {
+      out.push(this.dab(this.pendingFirst));
+      this.pendingFirst = null;
+    }
+    if (len > 1e-9) {
+      while (this.nextAt <= len + 1e-9) {
+        const f = Math.min(1, this.nextAt / len);
+        const lerp = (u, v) => u + (v - u) * f;
+        const q = {
+          x: a.x + dx * f,
+          y: a.y + dy * f,
+          pressure: lerp(a.pressure, s.pressure),
+          lean: lerp(a.lean, s.lean),
+          azimuth: lerpAngle(a.azimuth, s.azimuth, f),
+          twist: a.twist !== null && s.twist !== null ? lerpDegrees(a.twist, s.twist, f) : s.twist,
+          speed: a.speed !== null && s.speed !== null ? lerp(a.speed, s.speed) : s.speed
+        };
+        out.push(this.dab(q));
+        this.nextAt += this.stepLen(q);
+      }
+      this.nextAt -= len;
+    }
+    this.last = s;
+  }
+  finish(out) {
+    if (this.pendingFirst) {
+      out.push(this.dab(this.pendingFirst));
+      this.pendingFirst = null;
+    }
+  }
+}, _class4);
+function lerpAngle(a, b, t) {
+  let d = b - a;
+  while (d > Math.PI) d -= 2 * Math.PI;
+  while (d < -Math.PI) d += 2 * Math.PI;
+  return a + d * t;
+}
+function lerpDegrees(a, b, t) {
+  let d = b - a;
+  while (d > 180) d -= 360;
+  while (d < -180) d += 360;
+  return a + d * t;
+}
+var DryStroke = (_class5 = class {
+  constructor(brush, options) {;_class5.prototype.__init12.call(this);_class5.prototype.__init13.call(this);_class5.prototype.__init14.call(this);_class5.prototype.__init15.call(this);_class5.prototype.__init16.call(this);
+    this.brush = brush;
+    this.options = options;
+    this.smoother = new PenSmoother(brush.tip.smoothing, brush.pressureSmoothing);
+    this.copies = _optionalChain([options, 'access', _ => _.copies, 'optionalAccess', _2 => _2.length]) ? options.copies : [IDENTITY_COPY];
+    this.walkers = this.copies.map((c, i) => new PenDabWalker(brush, (_nullishCoalesce(options.seed, () => ( 0))) + i * 7919 | 0, c.linear));
+    this.depth = options.grain && !options.grain.flat ? Math.min(1, Math.max(0, options.paperDepth * brush.grain)) : 0;
+  }
+  
+  
+  __init12() {this.coverage = new (0, _chunkPV42JITTcjs.CoverageMap)()}
+  __init13() {this.dabCount = 0}
+  
+  
+  
+  
+  __init14() {this.buf = new Float32Array(0)}
+  __init15() {this.lastRaw = null}
+  __init16() {this.lastFed = null}
+  /** Feeds raw pen samples; returns the document rectangles the new dabs touched. */
+  push(points) {
+    const dabs = [];
+    for (const raw of points) {
+      this.lastRaw = raw;
+      const p = this.smoother.push(raw);
+      this.lastFed = p;
+      this.copies.forEach((c, i) => this.walkers[i].push(c.map(p), dabs));
+    }
+    return this.paint(dabs);
+  }
+  /** Ends the stroke: the smoothed path catches up with the last raw sample; a single tap paints one dab. */
+  finish() {
+    const dabs = [];
+    const raw = this.lastRaw;
+    const fed = this.lastFed;
+    if (raw && fed && (raw.x !== fed.x || raw.y !== fed.y)) this.copies.forEach((c, i) => this.walkers[i].push(c.map({ ...raw, pressure: fed.pressure }), dabs));
+    for (const w of this.walkers) w.finish(dabs);
+    return this.paint(dabs);
+  }
+  paint(dabs) {
+    const rects = [];
+    const hardness = this.brush.tip.hardness;
+    const grain = this.options.grain;
+    for (const d of dabs) {
+      const rect = _chunkPV42JITTcjs.dabRect.call(void 0, d, hardness);
+      const n = rect.width * rect.height;
+      if (this.buf.length < n) this.buf = new Float32Array(n);
+      const vals = this.buf.subarray(0, n);
+      _chunkPV42JITTcjs.rasterizeDab.call(void 0, d, hardness, rect, vals);
+      if (this.depth > 0 && grain) {
+        for (let yy = 0, k = 0; yy < rect.height; yy++) {
+          const y = rect.y + yy + 0.5;
+          for (let xx = 0; xx < rect.width; xx++, k++) {
+            if (vals[k] > 0) vals[k] *= grainCatch(grain.at(rect.x + xx + 0.5, y), this.depth, d.pressure);
+          }
+        }
+      }
+      this.coverage.accumulate(rect, vals, d.opacity);
+      rects.push(rect);
+      this.dabCount++;
+    }
+    return rects;
+  }
+}, _class5);
+function mixerTip(brush) {
+  return { ...brush.tip, smoothing: 0, pressureSize: brush.tip.pressureSize };
+}
+function toStrokePoint(p) {
+  return { x: p.x, y: p.y, pressure: pressureOf(p), ...typeof p.t === "number" ? { t: p.t } : {} };
+}
+
+// src/paint-editor/stroke.ts
+function defaultTile(surface) {
+  const data = new Uint8ClampedArray(_chunkCRMAXIUVcjs.TILE * _chunkCRMAXIUVcjs.TILE * surface.channels);
+  if (surface.defaultValue) data.fill(surface.defaultValue);
+  return data;
+}
+function sameTile(a, b) {
+  if (!a || !b) return !a && !b;
+  if (a === b) return true;
+  if (a.uniform !== null || b.uniform !== null) return a.uniform === b.uniform;
+  for (let i = 0; i < a.data.length; i++) if (a.data[i] !== b.data[i]) return false;
+  return true;
+}
+function union(a, b) {
+  if (!a) return { ...b };
+  const x = Math.min(a.x, b.x);
+  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 = (_class6 = class {
+  constructor(host, init) {;_class6.prototype.__init17.call(this);_class6.prototype.__init18.call(this);_class6.prototype.__init19.call(this);_class6.prototype.__init20.call(this);_class6.prototype.__init21.call(this);_class6.prototype.__init22.call(this);_class6.prototype.__init23.call(this);_class6.prototype.__init24.call(this);_class6.prototype.__init25.call(this);_class6.prototype.__init26.call(this);
+    this.host = host;
+    this.init = init;
+    this.layerId = init.layerId;
+    this.base = init.surface;
+    this.live = new Map(this.base.tiles);
+    this.copies = init.copies.length ? init.copies : [IDENTITY_COPY];
+    const brush = init.brush;
+    this.apply = {
+      mode: brush.engine === "eraser" ? "erase" : "paint",
+      color: init.color,
+      background: init.background,
+      opacity: brush.tip.opacity,
+      blend: brush.tip.blend,
+      lockTransparency: init.lockTransparency,
+      selection: null,
+      offset: init.offset
+    };
+    if (brush.engine === "mixer") {
+      this.mixerSmoother = new PenSmoother(brush.tip.smoothing, brush.pressureSmoothing);
+      const load = init.mixerLoad;
+      for (let i = 0; i < this.copies.length; i++) this.mixers.push(new (0, _chunkPV42JITTcjs.MixerStroke)(mixerTip(brush), brush.mixer, load, this.mixerTarget()));
+    } else {
+      this.dry = new DryStroke(brush, { grain: init.grain, paperDepth: init.paperDepth, seed: init.seed, copies: this.copies });
+    }
+  }
+  
+  
+  
+  /** The raw input so far (what a replay feeds back in). */
+  __init17() {this.points = []}
+  
+  
+  __init18() {this.touched = /* @__PURE__ */ new Set()}
+  __init19() {this.fresh = /* @__PURE__ */ new Set()}
+  __init20() {this.dry = null}
+  __init21() {this.mixers = []}
+  __init22() {this.mixerSmoother = null}
+  
+  
+  __init23() {this.bounds = null}
+  __init24() {this.lastRaw = null}
+  __init25() {this.closed = false}
+  __init26() {this.result = null}
+  mixerTarget() {
+    return {
+      offset: this.init.offset,
+      lockTransparency: this.init.lockTransparency,
+      selection: null,
+      readTile: (tx, ty) => _nullishCoalesce(_optionalChain([this, 'access', _3 => _3.live, 'access', _4 => _4.get, 'call', _5 => _5(_chunkCRMAXIUVcjs.tileKey.call(void 0, tx, ty)), 'optionalAccess', _6 => _6.data]), () => ( null)),
+      writeTile: (tx, ty) => {
+        const key = _chunkCRMAXIUVcjs.tileKey.call(void 0, tx, ty);
+        if (!this.touched.has(key)) {
+          const src = _nullishCoalesce(_optionalChain([this, 'access', _7 => _7.base, 'access', _8 => _8.tiles, 'access', _9 => _9.get, 'call', _10 => _10(key), 'optionalAccess', _11 => _11.data]), () => ( defaultTile(this.base)));
+          this.live.set(key, { data: new Uint8ClampedArray(src), uniform: null });
+          this.touched.add(key);
+        }
+        this.fresh.add(key);
+        return this.live.get(key).data;
+      }
+    };
+  }
+  get open() {
+    return !this.closed;
+  }
+  /** Adds raw pen samples (document pixels). */
+  push(points) {
+    if (this.closed || !points.length) return;
+    for (const p of points) this.points.push(p);
+    this.lastRaw = points[points.length - 1];
+    if (this.dry) this.update(this.dry.push(points));
+    else {
+      const rects = [];
+      for (const raw of points) {
+        const p = toStrokePoint(this.mixerSmoother.push(raw));
+        this.copies.forEach((c, i) => rects.push(...this.mixers[i].push([toStrokePoint(c.map(p))])));
+      }
+      this.update(rects);
+    }
+  }
+  update(rects) {
+    if (!rects.length) return;
+    for (const r of rects) this.bounds = union(this.bounds, r);
+    const ch = this.base.channels;
+    if (!this.dry) {
+      for (const key of this.fresh) this.live.set(key, { data: this.live.get(key).data, uniform: null });
+      this.fresh.clear();
+      this.host.update(this.layerId, new (0, _chunkCRMAXIUVcjs.TiledSurface)(ch, new Map(this.live), this.base.defaultValue), rects);
+      return;
+    }
+    const off = this.init.offset;
+    const regions = /* @__PURE__ */ new Map();
+    for (const r of rects) {
+      for (const t of _chunkCRMAXIUVcjs.tilesInRect.call(void 0, { x: r.x - off.x, y: r.y - off.y, width: r.width, height: r.height })) {
+        const key = _chunkCRMAXIUVcjs.tileKey.call(void 0, t.tx, t.ty);
+        const cur = regions.get(key);
+        regions.set(key, { tx: t.tx, ty: t.ty, r: cur ? union(cur.r, r) : r });
+      }
+    }
+    for (const [key, { tx, ty, r }] of regions) {
+      const src = _nullishCoalesce(_optionalChain([this, 'access', _12 => _12.base, 'access', _13 => _13.tiles, 'access', _14 => _14.get, 'call', _15 => _15(key), 'optionalAccess', _16 => _16.data]), () => ( defaultTile(this.base)));
+      const prev = this.touched.has(key) ? _optionalChain([this, 'access', _17 => _17.live, 'access', _18 => _18.get, 'call', _19 => _19(key), 'optionalAccess', _20 => _20.data]) : void 0;
+      this.touched.add(key);
+      const data = _chunkPV42JITTcjs.applyStrokeToTile.call(void 0, this.dry.coverage, src, ch, tx, ty, this.apply, prev ? { into: prev, region: r } : {});
+      this.live.set(key, { data, uniform: null });
+    }
+    this.host.update(this.layerId, new (0, _chunkCRMAXIUVcjs.TiledSurface)(ch, new Map(this.live), this.base.defaultValue), rects);
+  }
+  /** Ends the stroke (one undo step) and returns what changed. */
+  end() {
+    if (this.closed) throw new Error("This stroke has already ended.");
+    if (this.dry) this.update(this.dry.finish());
+    else {
+      const rects = [];
+      const last = this.lastRaw ? toStrokePoint(this.lastRaw) : void 0;
+      this.copies.forEach((c, i) => rects.push(...this.mixers[i].finish(last ? toStrokePoint(c.map(last)) : void 0)));
+      this.update(rects);
+    }
+    this.closed = true;
+    const ch = this.base.channels;
+    const tiles = new Map(this.base.tiles);
+    let changed = false;
+    for (const key of this.touched) {
+      const tile = _chunkCRMAXIUVcjs.finishTile.call(void 0, this.live.get(key).data, ch, this.base.defaultValue);
+      const prev = this.base.tiles.get(key);
+      if (tile) tiles.set(key, tile);
+      else tiles.delete(key);
+      if (!sameTile(prev, tile)) changed = true;
+    }
+    const surface = changed ? new (0, _chunkCRMAXIUVcjs.TiledSurface)(ch, tiles, this.base.defaultValue) : null;
+    const dabs = this.dry ? this.dry.dabCount : this.mixers.reduce((n, m) => n + m.dabCount, 0);
+    this.result = { layerId: this.layerId, bounds: changed ? this.bounds : null, dabs, strokeId: null };
+    if (this.mixers.length) {
+      const brush = this.init.brush;
+      let load = this.mixers[0].load;
+      if (brush.mixer.cleanEachStroke) load = _chunkPV42JITTcjs.cleanMixer.call(void 0, load);
+      this.result.mixerLoad = load;
+    }
+    this.host.commit(this, surface, false);
+    return this.result;
+  }
+  /** Abandons the stroke and restores the layer. */
+  cancel() {
+    if (this.closed) return;
+    this.closed = true;
+    this.host.commit(this, null, true);
+  }
+}, _class6);
+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 _chunkPV42JITTcjs.loadMixer.call(void 0, current, color);
+  return current;
+}
+
+// src/paint-editor/strokes.ts
+var IDENTITY_AFFINE = [1, 0, 0, 1, 0, 0];
+function applyAffine(m, x, y) {
+  return { x: m[0] * x + m[1] * y + m[4], y: m[2] * x + m[3] * y + m[5] };
+}
+function composeAffine(a, b) {
+  return [
+    a[0] * b[0] + a[1] * b[2],
+    a[0] * b[1] + a[1] * b[3],
+    a[2] * b[0] + a[3] * b[2],
+    a[2] * b[1] + a[3] * b[3],
+    a[0] * b[4] + a[1] * b[5] + a[4],
+    a[2] * b[4] + a[3] * b[5] + a[5]
+  ];
+}
+function invertAffine(m) {
+  const det = m[0] * m[3] - m[1] * m[2];
+  if (Math.abs(det) < 1e-12) throw new Error("The transform is not invertible (scale 0?).");
+  const a = m[3] / det;
+  const b = -m[1] / det;
+  const c = -m[2] / det;
+  const d = m[0] / det;
+  return [a, b, c, d, -(a * m[4] + b * m[5]), -(c * m[4] + d * m[5])];
+}
+function mapPenPoint(m, p) {
+  const q = applyAffine(m, p.x, p.y);
+  return { ...p, x: q.x, y: q.y };
+}
+function affineCopy(m) {
+  const linear = [m[0], m[1], m[2], m[3]];
+  return { map: (p) => mapPenPoint(m, p), linear };
+}
+var finite = (v) => typeof v === "number" && Number.isFinite(v);
+function readPoint(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  if (!finite(r.x) || !finite(r.y)) return null;
+  const p = { x: r.x, y: r.y };
+  for (const k of ["pressure", "t", "tiltX", "tiltY", "altitude", "azimuth", "twist"]) if (finite(r[k])) p[k] = r[k];
+  return p;
+}
+function readAffine(raw) {
+  return Array.isArray(raw) && raw.length === 6 && raw.every(finite) ? raw : null;
+}
+function normalizeBrushStroke(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  if (typeof r.id !== "string" || typeof r.layerId !== "string" || !Array.isArray(r.points)) return null;
+  const points = r.points.map(readPoint).filter((p) => p !== null);
+  if (!points.length) return null;
+  const out = {
+    id: r.id,
+    layerId: r.layerId,
+    brush: normalizePaintBrush(_nullishCoalesce(r.brush, () => ( {}))),
+    color: typeof r.color === "string" && /^#[0-9a-f]{6}$/i.test(r.color) ? r.color.toLowerCase() : "#000000",
+    points,
+    seed: finite(r.seed) ? r.seed | 0 : 0
+  };
+  const copies = Array.isArray(r.copies) ? r.copies.map(readAffine).filter((m) => m !== null) : [];
+  if (copies.length) out.copies = copies;
+  return out;
+}
+function strokeBounds(points) {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const p of points) {
+    if (p.x < x0) x0 = p.x;
+    if (p.y < y0) y0 = p.y;
+    if (p.x > x1) x1 = p.x;
+    if (p.y > y1) y1 = p.y;
+  }
+  return { x: x0, y: y0, width: x1 - x0, height: y1 - y0 };
+}
+function variationAffine(v, origin) {
+  const s = _nullishCoalesce(v.scale, () => ( 1));
+  const a = (_nullishCoalesce(v.rotate, () => ( 0))) * Math.PI / 180;
+  const cos = Math.cos(a) * s;
+  const sin = Math.sin(a) * s;
+  const fx = v.flipX ? -1 : 1;
+  const linear = [cos * fx, -sin, sin * fx, cos, 0, 0];
+  const toOrigin = [1, 0, 0, 1, -origin.x, -origin.y];
+  const back = [1, 0, 0, 1, origin.x + (_nullishCoalesce(v.dx, () => ( 0))), origin.y + (_nullishCoalesce(v.dy, () => ( 0)))];
+  return composeAffine(back, composeAffine(linear, toOrigin));
+}
+function varyStroke(stroke, m, v) {
+  const s = Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2]));
+  const ps = _nullishCoalesce(v.pressureScale, () => ( 1));
+  const points = stroke.points.map((p) => {
+    const q = mapPenPoint(m, p);
+    if (ps !== 1) q.pressure = Math.min(1, Math.max(0, (_nullishCoalesce(p.pressure, () => ( 1))) * ps));
+    return q;
+  });
+  const brush = s !== 1 ? normalizePaintBrush({ ...stroke.brush, tip: { ...stroke.brush.tip, size: stroke.brush.tip.size * s } }) : stroke.brush;
+  const out = { ...stroke, brush, points };
+  if (_optionalChain([stroke, 'access', _21 => _21.copies, 'optionalAccess', _22 => _22.length])) {
+    const inv = invertAffine(m);
+    out.copies = stroke.copies.map((c) => composeAffine(m, composeAffine(c, inv)));
+  }
+  return out;
+}
+
+// src/paint-editor/render.ts
+var PAPER_NODE_ID = "__paper";
+var TRACING_NODE_ID = "__tracing";
+function paperKey(p) {
+  return JSON.stringify([p.pattern, p.seed, p.color, p.scale, p.tiling, p.shading, p.dry]);
+}
+var paperNodes = /* @__PURE__ */ new WeakMap();
+function paperNode(paper) {
+  let n = paperNodes.get(paper);
+  if (!n) {
+    n = { type: "paper", id: PAPER_NODE_ID, name: "Paper", visible: true, opacity: 1, blend: "normal", paper };
+    paperNodes.set(paper, n);
+  }
+  return n;
+}
+var grainCache = /* @__PURE__ */ new Map();
+var tileCache = /* @__PURE__ */ new Map();
+function paperGrain(paper) {
+  const key = JSON.stringify([paper.pattern, paper.seed, paper.scale, paper.tiling, paper.dry]);
+  let g = grainCache.get(key);
+  if (!g) {
+    g = new PaperGrain(paper, "dry");
+    if (grainCache.size > 16) grainCache.delete(grainCache.keys().next().value);
+    grainCache.set(key, g);
+  }
+  return g;
+}
+function paperTile(paper, r) {
+  const key = `${paperKey(paper)}|${r.x},${r.y},${r.width},${r.height}`;
+  let t = tileCache.get(key);
+  if (!t) {
+    t = renderPaper(paper, r, paperGrain(paper));
+    if (tileCache.size > 512) tileCache.delete(tileCache.keys().next().value);
+    tileCache.set(key, t);
+  }
+  return t;
+}
+var PROFILE = {
+  contentTile(layer, r) {
+    if (layer.type === "paper") return paperTile(layer.paper, r);
+    if (layer.type === "image") {
+      const { image } = layer;
+      const out = new Uint8ClampedArray(r.width * r.height * 4);
+      const x0 = Math.max(0, r.x);
+      const y0 = Math.max(0, r.y);
+      const x1 = Math.min(image.width, r.x + r.width);
+      const y1 = Math.min(image.height, r.y + r.height);
+      if (x1 <= x0 || y1 <= y0) return null;
+      for (let y = y0; y < y1; y++) out.set(image.data.subarray((y * image.width + x0) * 4, (y * image.width + x1) * 4), ((y - r.y) * r.width + (x0 - r.x)) * 4);
+      return out;
+    }
+    return null;
+  },
+  layerKey(layer) {
+    if (layer.type === "paper") return paperKey(layer.paper);
+    if (layer.type === "image") return layer.version;
+    return void 0;
+  }
+};
+function createPaintCompositor() {
+  return new (0, _chunkWSTEXEKDcjs.RasterCompositor)(PROFILE);
+}
+function downsampleRgba(data, width, height, tw, th) {
+  tw = Math.max(1, Math.round(tw));
+  th = Math.max(1, Math.round(th));
+  if (tw >= width && th >= height) return Uint8ClampedArray.from(data);
+  const out = new Uint8ClampedArray(tw * th * 4);
+  const sx = width / tw;
+  const sy = height / th;
+  for (let y = 0; y < th; y++) {
+    const y0 = y * sy;
+    const y1 = y0 + sy;
+    for (let x = 0; x < tw; x++) {
+      const x0 = x * sx;
+      const x1 = x0 + sx;
+      let r = 0;
+      let g = 0;
+      let b = 0;
+      let a = 0;
+      let w = 0;
+      for (let yy = Math.floor(y0); yy < Math.ceil(y1) && yy < height; yy++) {
+        const wy = Math.min(y1, yy + 1) - Math.max(y0, yy);
+        for (let xx = Math.floor(x0); xx < Math.ceil(x1) && xx < width; xx++) {
+          const wgt = wy * (Math.min(x1, xx + 1) - Math.max(x0, xx));
+          const i = (yy * width + xx) * 4;
+          const al = data[i + 3] * wgt;
+          r += data[i] * al;
+          g += data[i + 1] * al;
+          b += data[i + 2] * al;
+          a += al;
+          w += wgt;
+        }
+      }
+      const o = (y * tw + x) * 4;
+      if (a > 0) {
+        out[o] = r / a;
+        out[o + 1] = g / a;
+        out[o + 2] = b / a;
+      }
+      out[o + 3] = w > 0 ? a / w : 0;
+    }
+  }
+  return out;
+}
+
+// src/paint-editor/serialize.ts
+var PAINT_FORMAT = "pixerate-paint";
+var PAINT_SCHEMA_VERSION = 1;
+var KNOWN = /* @__PURE__ */ new Set(["format", "version", "width", "height", "dpi", "paper", "layers", "assets", "activeLayerId", "strokes"]);
+function documentExtensions(raw) {
+  const out = {};
+  for (const [k, v] of Object.entries(raw)) if (!KNOWN.has(k)) out[k] = v;
+  return out;
+}
+function header(state, options) {
+  const out = {
+    ..._nullishCoalesce(options.extensions, () => ( {})),
+    format: PAINT_FORMAT,
+    version: PAINT_SCHEMA_VERSION,
+    width: state.canvas.width,
+    height: state.canvas.height,
+    dpi: state.canvas.dpi,
+    paper: { ...state.paper, dry: { ...state.paper.dry }, wet: { ...state.paper.wet } },
+    activeLayerId: state.activeLayerId
+  };
+  if (options.strokes !== false && state.strokes.length) out.strokes = JSON.parse(JSON.stringify(state.strokes));
+  return out;
+}
+function serializePaintDocument(state, options = {}) {
+  const { layers, assets } = _chunkVSMM7B3Pcjs.serializeLayers.call(void 0, state.layers);
+  return { ...header(state, options), layers, assets };
+}
+async function serializePaintDocumentExternal(state, store, options = {}) {
+  const { layers, assets } = await _chunkVSMM7B3Pcjs.serializeLayersExternal.call(void 0, state.layers, store);
+  return { ...header(state, options), layers, assets };
+}
+function paintLayersOnly(layers, problems) {
+  const out = [];
+  for (const l of layers) {
+    if (l.type === "pixel") {
+      const { filters, source, ...rest } = l;
+      if (_optionalChain([filters, 'optionalAccess', _23 => _23.length])) problems.push(`Layer "${l.name}": its filters are an image editor feature and were dropped.`);
+      if (source) problems.push(`Layer "${l.name}" refers to an image editor source image; it loads empty.`);
+      out.push(rest);
+    } else if (l.type === "group") out.push({ ...l, children: paintLayersOnly(l.children, problems) });
+    else problems.push(`Layer "${l.name}" is an image editor ${l.type} layer, which the paint editor does not have; it was left out.`);
+  }
+  return out;
+}
+function readStrokes(raw, problems) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  raw.forEach((s, i) => {
+    const stroke = normalizeBrushStroke(s);
+    if (stroke) out.push(stroke);
+    else problems.push(`strokes[${i}] is not a recorded stroke; skipped.`);
+  });
+  return out;
+}
+function deserializePaintDocument(raw) {
+  if (!raw || typeof raw !== "object") throw new Error("Not a paint document: expected a JSON object.");
+  const r = raw;
+  if (r.format !== PAINT_FORMAT) throw new Error(`Not a paint document: format is ${JSON.stringify(r.format)}, expected "${PAINT_FORMAT}".`);
+  if (typeof r.version !== "number" || r.version > PAINT_SCHEMA_VERSION) {
+    throw new Error(`Paint document version ${JSON.stringify(r.version)} is newer than this editor reads (${PAINT_SCHEMA_VERSION}); update @pixerate/editor.`);
+  }
+  const problems = [];
+  const canvas = normalizeCanvas({ width: r.width, height: r.height, dpi: _nullishCoalesce(r.dpi, () => ( void 0)) });
+  const paper = normalizePaper(_nullishCoalesce(r.paper, () => ( {})));
+  const assets = r.assets && typeof r.assets === "object" ? r.assets : {};
+  const layers = paintLayersOnly(_chunkVSMM7B3Pcjs.deserializeLayers.call(void 0, r.layers, { assets, problems }), problems);
+  const wanted = typeof r.activeLayerId === "string" ? r.activeLayerId : null;
+  const activeLayerId = wanted && _chunkWSTEXEKDcjs.findLayer.call(void 0, layers, wanted) ? wanted : _nullishCoalesce(_optionalChain([_chunkWSTEXEKDcjs.flattenLayers.call(void 0, layers), 'access', _24 => _24.filter, 'call', _25 => _25((l) => l.type === "pixel"), 'access', _26 => _26.pop, 'call', _27 => _27(), 'optionalAccess', _28 => _28.id]), () => ( null));
+  return { state: { canvas, paper, layers, activeLayerId, strokes: readStrokes(r.strokes, problems) }, extensions: documentExtensions(r), problems };
+}
+async function deserializePaintDocumentAsync(raw, store) {
+  if (!raw || typeof raw !== "object") throw new Error("Not a paint document: expected a JSON object.");
+  const r = raw;
+  const problems = [];
+  const assets = await _chunkVSMM7B3Pcjs.resolveExternalAssets.call(void 0, _nullishCoalesce(r.assets, () => ( {})), store, problems);
+  const loaded = deserializePaintDocument({ ...r, assets });
+  return { ...loaded, problems: [...problems, ...loaded.problems] };
+}
+
+// src/paint-editor/view.ts
+var MIN_ZOOM = 0.02;
+var MAX_ZOOM = 64;
+var DEFAULT_VIEW = { zoom: 1, pan: { x: 0, y: 0 }, rotation: 0, mirror: false };
+function normalizeRotation(deg) {
+  if (!Number.isFinite(deg)) return 0;
+  let r = deg % 360;
+  if (r > 180) r -= 360;
+  if (r <= -180) r += 360;
+  return Math.round(r * 1e3) / 1e3;
+}
+function normalizeView(raw, base = DEFAULT_VIEW) {
+  const zoom = typeof raw.zoom === "number" && Number.isFinite(raw.zoom) ? Math.min(MAX_ZOOM, Math.max(MIN_ZOOM, raw.zoom)) : base.zoom;
+  const pan = raw.pan && Number.isFinite(raw.pan.x) && Number.isFinite(raw.pan.y) ? { x: raw.pan.x, y: raw.pan.y } : { ...base.pan };
+  return {
+    zoom,
+    pan,
+    rotation: typeof raw.rotation === "number" ? normalizeRotation(raw.rotation) : base.rotation,
+    mirror: typeof raw.mirror === "boolean" ? raw.mirror : base.mirror
+  };
+}
+function viewMatrix(view, canvas, viewport) {
+  const a = view.rotation * Math.PI / 180;
+  const z = view.zoom;
+  const m = view.mirror ? -1 : 1;
+  const cos = Math.cos(a) * z;
+  const sin = Math.sin(a) * z;
+  const cx = canvas.width / 2;
+  const cy = canvas.height / 2;
+  const sx = viewport.width / 2 + view.pan.x;
+  const sy = viewport.height / 2 + view.pan.y;
+  const A = cos * m;
+  const B = -sin;
+  const C = sin * m;
+  const D = cos;
+  return [A, B, C, D, sx - (A * cx + B * cy), sy - (C * cx + D * cy)];
+}
+function screenToDocument(view, canvas, viewport, x, y) {
+  return applyAffine(invertAffine(viewMatrix(view, canvas, viewport)), x, y);
+}
+function documentToScreen(view, canvas, viewport, x, y) {
+  return applyAffine(viewMatrix(view, canvas, viewport), x, y);
+}
+function viewCssTransform(view, canvas, viewport) {
+  const m = viewMatrix(view, canvas, viewport);
+  const f = (v) => Math.round(v * 1e4) / 1e4;
+  return `matrix(${f(m[0])}, ${f(m[2])}, ${f(m[1])}, ${f(m[3])}, ${f(m[4])}, ${f(m[5])})`;
+}
+function fitZoom(canvas, viewport, margin = 24) {
+  const w = Math.max(1, viewport.width - 2 * margin);
+  const h = Math.max(1, viewport.height - 2 * margin);
+  return Math.min(MAX_ZOOM, Math.max(MIN_ZOOM, Math.min(w / canvas.width, h / canvas.height)));
+}
+function viewPenToDocument(view, p) {
+  if (!view.rotation && !view.mirror) return p;
+  const out = { ...p };
+  const r = view.rotation * Math.PI / 180;
+  if (typeof p.azimuth === "number") {
+    let a = p.azimuth - r;
+    if (view.mirror) a = Math.PI - a;
+    out.azimuth = (a % (2 * Math.PI) + 2 * Math.PI) % (2 * Math.PI);
+  }
+  if (typeof p.twist === "number") {
+    let t = p.twist - view.rotation;
+    if (view.mirror) t = -t;
+    out.twist = (t % 360 + 360) % 360;
+  }
+  return out;
+}
+
+// src/paint-editor/input.ts
+function samplePressure(e) {
+  if (e.pointerType === "pen" && typeof e.pressure === "number" && e.pressure > 0) return Math.min(1, e.pressure);
+  return 1;
+}
+function pointerToPenPoint(e, x, y, view) {
+  const p = { x, y, pressure: samplePressure(e) };
+  if (typeof e.timeStamp === "number" && Number.isFinite(e.timeStamp)) p.t = e.timeStamp;
+  if (e.pointerType !== "pen") return p;
+  const o = penOrientation({
+    x,
+    y,
+    altitude: typeof e.altitudeAngle === "number" ? e.altitudeAngle : void 0,
+    azimuth: typeof e.azimuthAngle === "number" ? e.azimuthAngle : void 0,
+    tiltX: e.tiltX,
+    tiltY: e.tiltY
+  });
+  if (o && o.altitude < Math.PI / 2 - 1e-6) {
+    p.altitude = o.altitude;
+    p.azimuth = o.azimuth;
+  }
+  if (typeof e.twist === "number" && Number.isFinite(e.twist) && e.twist !== 0) p.twist = e.twist;
+  return view ? viewPenToDocument(view, p) : p;
+}
+function isPalmTouch(touch, pen, hand) {
+  if (!pen) return false;
+  const dx = touch.x - pen.x;
+  const dy = touch.y - pen.y;
+  const side = hand === "right" ? dx : -dx;
+  return dy > -40 && side > -40 && Math.hypot(dx, dy) < 600;
+}
+
+// src/paint-editor/encode.ts
+function defaultImageEncoder() {
+  const g = globalThis;
+  if (typeof g.OffscreenCanvas !== "function" || typeof g.ImageData !== "function") return null;
+  const Canvas = g.OffscreenCanvas;
+  const Data = g.ImageData;
+  return async (image, format, quality) => {
+    const canvas = new Canvas(image.width, image.height);
+    const ctx = canvas.getContext("2d");
+    if (!ctx) throw new Error("No 2D context to encode with.");
+    ctx.putImageData(new Data(new Uint8ClampedArray(image.data), image.width, image.height), 0, 0);
+    const blob = await canvas.convertToBlob({ type: format, quality });
+    if (blob.type !== format) throw new Error(`This browser cannot encode ${format} (it produced ${blob.type || "nothing"}); export PNG instead.`);
+    return new Uint8Array(await blob.arrayBuffer());
+  };
+}
+
+// src/paint-editor/thumbnails.ts
+function thumbnailStroke(width, height) {
+  const pts = [];
+  const n = 64;
+  const mx = width * 0.1;
+  const my = height * 0.5;
+  for (let i = 0; i <= n; i++) {
+    const t = i / n;
+    const pressure = t < 0.5 ? 0.15 + 1.7 * t : 1 - 1.4 * (t - 0.5);
+    pts.push({ x: mx + (width - 2 * mx) * t, y: my - Math.sin(t * Math.PI * 2) * height * 0.22, pressure, t: i * 12 });
+  }
+  return pts;
+}
+function paintTestStroke(surface, brush, paper, color, width, height) {
+  const [r, g, b] = hexToRgb8(color);
+  let result = surface;
+  const session = new PaintStrokeSession(
+    { update: () => {
+    }, commit: (_s, s) => result = _nullishCoalesce(s, () => ( result)) },
+    {
+      layerId: "thumbnail",
+      surface,
+      offset: { x: 0, y: 0 },
+      lockTransparency: false,
+      brush,
+      color: [r, g, b, 255],
+      background: [...hexToRgb8(paper.color), 255],
+      grain: paperGrain(paper),
+      paperDepth: paper.depth,
+      seed: 7,
+      colorHex: color,
+      affineCopies: [],
+      copies: [IDENTITY_COPY],
+      mixerLoad: brush.engine === "mixer" ? mixerLoadForStroke(brush, _chunkPV42JITTcjs.EMPTY_MIXER_LOAD, [r / 255, g / 255, b / 255]) : _chunkPV42JITTcjs.EMPTY_MIXER_LOAD
+    }
+  );
+  session.push(thumbnailStroke(width, height));
+  session.end();
+  return result;
+}
+function renderBrushThumbnail(brush, options) {
+  const width = Math.max(16, Math.min(512, Math.round(_nullishCoalesce(options.width, () => ( 160)))));
+  const height = Math.max(16, Math.min(512, Math.round(_nullishCoalesce(options.height, () => ( 48)))));
+  const maxSize = height * 0.42;
+  const b = brush.tip.size > maxSize ? normalizePaintBrush({ tip: { ...brush.tip, size: maxSize } }, brush) : brush;
+  const rgba = [...hexToRgb8(options.color), 255];
+  let surface = _chunkCRMAXIUVcjs.emptySurface.call(void 0, 4);
+  if (b.engine === "eraser") {
+    surface = _chunkCRMAXIUVcjs.fillRect.call(void 0, surface, { x: 0, y: 0, width, height }, rgba);
+  } else if (b.engine === "mixer" && !b.loadsColor) {
+    const half = Math.ceil(height / 2);
+    surface = _chunkCRMAXIUVcjs.fillRect.call(void 0, surface, { x: 0, y: 0, width, height: half }, rgba);
+    surface = _chunkCRMAXIUVcjs.fillRect.call(void 0, surface, { x: 0, y: half, width, height: height - half }, [232, 196, 64, 255]);
+  }
+  surface = 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 });
+  return { width, height, data };
+}
+
+// src/paint-editor/controller.ts
+var PaintEditorError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PaintEditorError";
+  }
+};
+var HEX2 = /^#[0-9a-f]{6}$/i;
+function parseColor(value, what = "color") {
+  if (typeof value !== "string" || !HEX2.test(value.trim())) throw new PaintEditorError(`${what} is ${JSON.stringify(value)}; use #rrggbb, e.g. "#2a4b8d".`);
+  return value.trim().toLowerCase();
+}
+function rgbaOf(hex) {
+  const [r, g, b] = hexToRgb8(hex);
+  return [r, g, b, 255];
+}
+function rgbToHex(r, g, b) {
+  return "#" + [r, g, b].map((v) => Math.round(Math.min(255, Math.max(0, v))).toString(16).padStart(2, "0")).join("");
+}
+function unionRect(a, b) {
+  if (!a) return b ? { ...b } : null;
+  if (!b) return { ...a };
+  const x = Math.min(a.x, b.x);
+  const y = Math.min(a.y, b.y);
+  return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
+}
+var isPixelLayer = (l) => _optionalChain([l, 'optionalAccess', _29 => _29.type]) === "pixel";
+var PaintEditorController = (_class7 = class {
+  
+  __init27() {this.extensions = {}}
+  __init28() {this.undoStack = []}
+  __init29() {this.redoStack = []}
+  
+  
+  
+  
+  __init30() {this.secondaryColor = "#ffffff"}
+  __init31() {this.mixerLoad = _chunkPV42JITTcjs.EMPTY_MIXER_LOAD}
+  __init32() {this.view = { ...DEFAULT_VIEW, pan: { ...DEFAULT_VIEW.pan } }}
+  
+  
+  __init33() {this.listeners = /* @__PURE__ */ new Set()}
+  __init34() {this.version = 0}
+  __init35() {this.cached = null}
+  __init36() {this.session = null}
+  __init37() {this.live = null}
+  __init38() {this.liveLayers = null}
+  __init39() {this.dirty = "all"}
+  __init40() {this.seedCounter = 1}
+  __init41() {this.strokeCounter = 1}
+  __init42() {this.viewCompositor = createPaintCompositor()}
+  __init43() {this.exportCompositor = createPaintCompositor()}
+  constructor(options = {}) {;_class7.prototype.__init27.call(this);_class7.prototype.__init28.call(this);_class7.prototype.__init29.call(this);_class7.prototype.__init30.call(this);_class7.prototype.__init31.call(this);_class7.prototype.__init32.call(this);_class7.prototype.__init33.call(this);_class7.prototype.__init34.call(this);_class7.prototype.__init35.call(this);_class7.prototype.__init36.call(this);_class7.prototype.__init37.call(this);_class7.prototype.__init38.call(this);_class7.prototype.__init39.call(this);_class7.prototype.__init40.call(this);_class7.prototype.__init41.call(this);_class7.prototype.__init42.call(this);_class7.prototype.__init43.call(this);
+    this.historyLimit = Math.max(1, _nullishCoalesce(options.historyLimit, () => ( 200)));
+    this.doc = createPaintDocument({ width: options.width, height: options.height, dpi: options.dpi, paper: this.resolvePaper(options.paper) });
+    this.userBrushes = (_nullishCoalesce(options.brushes, () => ( []))).map((b) => normalizePaintBrush({ ...b, builtin: false }));
+    const start = _nullishCoalesce(this.findBrush(_nullishCoalesce(options.brushId, () => ( DEFAULT_BRUSH_ID))), () => ( this.findBrush(DEFAULT_BRUSH_ID)));
+    this.brush = normalizePaintBrush(start);
+    this.color = options.color ? parseColor(options.color) : "#1f2937";
+    this.hand = options.hand === "left" ? "left" : "right";
+    this.encodeImage = options.encodeImage;
+  }
+  // --- State and events ----------------------------------------------------------
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  emit(dirty = "all") {
+    if (dirty === "all" || this.dirty === "all") this.dirty = "all";
+    else this.dirty.push(...dirty);
+    this.version++;
+    this.cached = null;
+    for (const l of [...this.listeners]) l();
+  }
+  /** A snapshot of the editor (the same object until something changes). */
+  getState() {
+    if (this.cached) return this.cached;
+    const last = this.undoStack[this.undoStack.length - 1];
+    const next = this.redoStack[this.redoStack.length - 1];
+    this.cached = {
+      document: this.doc,
+      brush: this.brush,
+      brushes: [...BUILTIN_BRUSHES, ...this.userBrushes],
+      color: this.color,
+      secondaryColor: this.secondaryColor,
+      mixerLoad: this.mixerLoad,
+      view: this.view,
+      hand: this.hand,
+      canUndo: this.undoStack.length > 0 && !this.session,
+      canRedo: this.redoStack.length > 0 && !this.session,
+      undoLabel: _nullishCoalesce(_optionalChain([last, 'optionalAccess', _30 => _30.label]), () => ( null)),
+      redoLabel: _nullishCoalesce(_optionalChain([next, 'optionalAccess', _31 => _31.label]), () => ( null)),
+      stroking: Boolean(this.session),
+      version: this.version
+    };
+    return this.cached;
+  }
+  get document() {
+    return this.doc;
+  }
+  /**
+   * Where the rendered stack changed since the last call: rectangles (a stroke's dabs) or `'all'`.
+   * The viewport passes it to `compositeTiles` as `dirty`.
+   */
+  takeDirty() {
+    const d = this.dirty;
+    this.dirty = [];
+    return d;
+  }
+  // --- History -------------------------------------------------------------------
+  requireIdle(what) {
+    if (this.session) throw new PaintEditorError(`A stroke is in progress; end or cancel it before ${what}.`);
+  }
+  commit(label, next) {
+    this.undoStack.push({ label, before: this.doc, after: next });
+    if (this.undoStack.length > this.historyLimit) this.undoStack.shift();
+    this.redoStack = [];
+    this.doc = next;
+    this.emit();
+  }
+  undo() {
+    this.requireIdle("undoing");
+    const e = this.undoStack.pop();
+    if (!e) return null;
+    this.redoStack.push(e);
+    this.doc = e.before;
+    this.emit();
+    return e.label;
+  }
+  redo() {
+    this.requireIdle("redoing");
+    const e = this.redoStack.pop();
+    if (!e) return null;
+    this.undoStack.push(e);
+    this.doc = e.after;
+    this.emit();
+    return e.label;
+  }
+  /** Labels of the undo steps, oldest first. */
+  historyLabels() {
+    return { undo: this.undoStack.map((e) => e.label), redo: this.redoStack.map((e) => e.label).reverse() };
+  }
+  // --- Canvas and paper ----------------------------------------------------------
+  resolvePaper(paper) {
+    if (typeof paper === "string") {
+      const p = paperPreset(paper);
+      if (!p) throw new PaintEditorError(`Unknown paper "${paper}". Call list_papers for the ids.`);
+      return p;
+    }
+    return _nullishCoalesce(paper, () => ( {}));
+  }
+  /** Starts a new canvas: one empty layer over the paper (one undo step; undo brings the old one back). */
+  newCanvas(options = {}) {
+    this.requireIdle("starting a new canvas");
+    const next = createPaintDocument({
+      width: _nullishCoalesce(options.width, () => ( this.doc.canvas.width)),
+      height: _nullishCoalesce(options.height, () => ( this.doc.canvas.height)),
+      dpi: _nullishCoalesce(options.dpi, () => ( this.doc.canvas.dpi)),
+      paper: options.paper === void 0 ? this.doc.paper : this.resolvePaper(options.paper)
+    });
+    this.extensions = {};
+    this.commit("New canvas", next);
+    return next;
+  }
+  /** Changes the canvas size (keeping the pixels where they are, anchored top-left) or resolution. */
+  setCanvas(update) {
+    this.requireIdle("changing the canvas");
+    const canvas = normalizeCanvas({
+      width: _nullishCoalesce(update.width, () => ( this.doc.canvas.width)),
+      height: _nullishCoalesce(update.height, () => ( this.doc.canvas.height)),
+      dpi: _nullishCoalesce(update.dpi, () => ( this.doc.canvas.dpi))
+    });
+    this.commit("Canvas size", { ...this.doc, canvas });
+    return canvas;
+  }
+  /** Changes the paper: a library preset (`preset`), and / or any of its settings (one undo step). */
+  setPaper(update) {
+    this.requireIdle("changing the paper");
+    let base = this.doc.paper;
+    if (update.preset !== void 0 && update.preset !== this.doc.paper.preset) {
+      const p = paperPreset(update.preset);
+      if (!p) throw new PaintEditorError(`Unknown paper "${update.preset}". Call list_papers for the ids.`);
+      base = p;
+    }
+    const { preset: _p, ...rest } = update;
+    if (rest.color !== void 0) parseColor(rest.color, "paper color");
+    const paper = normalizePaper({ ...rest, preset: base.preset }, base);
+    const changedKeys = Object.keys(rest).filter((k) => k !== "name");
+    if (changedKeys.length && update.preset === void 0) paper.preset = base.preset;
+    this.commit("Paper", { ...this.doc, paper });
+    return clonePaper(paper);
+  }
+  // --- Layers --------------------------------------------------------------------
+  getLayer(id) {
+    return _optionalChain([_chunkWSTEXEKDcjs.findLayer.call(void 0, this.doc.layers, id), 'optionalAccess', _32 => _32.layer]);
+  }
+  /** The active pixel layer (or `undefined`). */
+  getActiveLayer() {
+    return this.doc.activeLayerId ? this.getLayer(this.doc.activeLayerId) : void 0;
+  }
+  /** Every layer, top first, as panels and tools describe them. */
+  listLayers() {
+    const out = [];
+    const walk = (list, parentId, depth) => {
+      for (let i = list.length - 1; i >= 0; i--) {
+        const l = list[i];
+        out.push(this.describeLayer(l, parentId, depth));
+        if (l.type === "group") walk(l.children, l.id, depth + 1);
+      }
+    };
+    walk(this.doc.layers, null, 0);
+    return out;
+  }
+  describeLayer(l, parentId = _nullishCoalesce(_optionalChain([_chunkWSTEXEKDcjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _33 => _33.parent, 'optionalAccess', _34 => _34.id]), () => ( null)), depth = _nullishCoalesce(_optionalChain([_chunkWSTEXEKDcjs.findLayer.call(void 0, this.doc.layers, l.id), 'optionalAccess', _35 => _35.path, 'access', _36 => _36.length]), () => ( 0))) {
+    let bounds = null;
+    if (l.type === "pixel") {
+      const b = _chunkCRMAXIUVcjs.contentBounds.call(void 0, l.surface);
+      bounds = b ? { ...b, x: b.x + l.offset.x, y: b.y + l.offset.y } : null;
+    } else for (const c of _chunkWSTEXEKDcjs.flattenLayers.call(void 0, l.children)) if (c.type === "pixel") bounds = unionRect(bounds, this.describeLayer(c, l.id, depth + 1).bounds);
+    return {
+      id: l.id,
+      name: l.name,
+      type: l.type,
+      visible: l.visible,
+      opacity: l.opacity,
+      blend: l.blend,
+      clipped: Boolean(l.clipped),
+      locks: { ..._nullishCoalesce(l.locks, () => ( {})) },
+      active: l.id === this.doc.activeLayerId,
+      bounds,
+      parentId,
+      depth
+    };
+  }
+  requireLayer(id) {
+    const l = this.getLayer(id);
+    if (!l) throw new PaintEditorError(`Unknown layer "${id}". Call list_layers for the ids.`);
+    return l;
+  }
+  /** The pixel layer a paint operation targets, checked for locks and visibility. */
+  paintTarget(layerId, what) {
+    const id = _nullishCoalesce(layerId, () => ( this.doc.activeLayerId));
+    if (!id) throw new PaintEditorError(`There is no active layer to ${what}; add one with add_layer.`);
+    const l = this.requireLayer(id);
+    if (!isPixelLayer(l)) throw new PaintEditorError(`Layer "${l.name}" is a group; ${what} a pixel layer inside it.`);
+    if (_chunkWSTEXEKDcjs.isLayerLocked.call(void 0, l, "pixels")) throw new PaintEditorError(`Layer "${l.name}" has its pixels locked; unlock it (update_layer locks) before you ${what} it.`);
+    if (!l.visible) throw new PaintEditorError(`Layer "${l.name}" is hidden; show it (update_layer visible true) before you ${what} it.`);
+    return l;
+  }
+  setActiveLayer(id) {
+    this.requireLayer(id);
+    if (this.doc.activeLayerId === id) return;
+    this.doc = { ...this.doc, activeLayerId: id };
+    this.emit();
+  }
+  /** Adds an empty pixel layer or group above `aboveId` (default: the active layer) and makes it active. */
+  addLayer(options = {}) {
+    this.requireIdle("adding a layer");
+    const count = _chunkWSTEXEKDcjs.flattenLayers.call(void 0, this.doc.layers).length;
+    const type = _nullishCoalesce(options.type, () => ( "pixel"));
+    const name = _optionalChain([options, 'access', _37 => _37.name, 'optionalAccess', _38 => _38.trim, 'call', _39 => _39()]) || (type === "group" ? `Group ${count + 1}` : `Layer ${count + 1}`);
+    const layer = type === "group" ? { type: "group", id: newPaintLayerId(), name, visible: true, opacity: 1, blend: "pass-through", children: [] } : createPaintLayer(name);
+    let parentId = null;
+    let index;
+    const above = _nullishCoalesce(options.aboveId, () => ( (options.parentId === void 0 ? this.doc.activeLayerId : null)));
+    if (options.parentId !== void 0 && options.parentId !== null) {
+      const g = this.requireLayer(options.parentId);
+      if (g.type !== "group") throw new PaintEditorError(`Layer "${g.name}" is not a group; pass a group id as parentId.`);
+      parentId = g.id;
+    } else if (above) {
+      const loc = _chunkWSTEXEKDcjs.findLayer.call(void 0, this.doc.layers, above);
+      if (!loc) throw new PaintEditorError(`Unknown layer "${above}". Call list_layers for the ids.`);
+      parentId = _nullishCoalesce(_optionalChain([loc, 'access', _40 => _40.parent, 'optionalAccess', _41 => _41.id]), () => ( null));
+      index = loc.index + 1;
+    }
+    const layers = _chunkWSTEXEKDcjs.insertLayer.call(void 0, this.doc.layers, layer, parentId, index);
+    this.commit(type === "group" ? "Add group" : "Add layer", { ...this.doc, layers, activeLayerId: layer.id });
+    return this.describeLayer(layer);
+  }
+  updateLayer(id, update) {
+    this.requireIdle("changing a layer");
+    const l = this.requireLayer(id);
+    if (_chunkWSTEXEKDcjs.isLayerLocked.call(void 0, l, "all") && Object.keys(update).some((k) => k !== "locks")) throw new PaintEditorError(`Layer "${l.name}" is fully locked; unlock it first (locks {all: false}).`);
+    if (update.opacity !== void 0 && !(update.opacity >= 0 && update.opacity <= 1)) throw new PaintEditorError(`opacity ${update.opacity} is out of range; use 0..1.`);
+    if (update.blend !== void 0 && !_chunkCRMAXIUVcjs.isBlendMode.call(void 0, update.blend) && !(l.type === "group" && update.blend === "pass-through")) {
+      throw new PaintEditorError(`Unknown blend mode "${update.blend}". Call get_canvas_info for the blend modes.`);
+    }
+    if (update.name !== void 0 && !update.name.trim()) throw new PaintEditorError("name is empty; give the layer a name.");
+    const next = { ...l };
+    if (update.name !== void 0) next.name = update.name.trim();
+    if (update.visible !== void 0) next.visible = update.visible;
+    if (update.opacity !== void 0) next.opacity = update.opacity;
+    if (update.blend !== void 0) next.blend = update.blend;
+    if (update.clipped !== void 0) next.clipped = update.clipped || void 0;
+    if (update.locks !== void 0) {
+      const locks = { ..._nullishCoalesce(l.locks, () => ( {})), ...update.locks };
+      next.locks = Object.values(locks).some(Boolean) ? locks : void 0;
+    }
+    this.commit("Layer properties", { ...this.doc, layers: _chunkWSTEXEKDcjs.mapLayer.call(void 0, this.doc.layers, id, () => next) });
+    return this.describeLayer(next);
+  }
+  removeLayer(id) {
+    this.requireIdle("removing a layer");
+    const l = this.requireLayer(id);
+    if (_chunkWSTEXEKDcjs.isLayerLocked.call(void 0, l, "all")) throw new PaintEditorError(`Layer "${l.name}" is fully locked; unlock it before removing it.`);
+    const layers = _chunkWSTEXEKDcjs.mapLayer.call(void 0, this.doc.layers, id, () => null);
+    let active = this.doc.activeLayerId;
+    if (active && !_chunkWSTEXEKDcjs.findLayer.call(void 0, layers, active)) active = _nullishCoalesce(_optionalChain([_chunkWSTEXEKDcjs.flattenLayers.call(void 0, layers), 'access', _42 => _42.filter, 'call', _43 => _43((x) => x.type === "pixel"), 'access', _44 => _44.pop, 'call', _45 => _45(), 'optionalAccess', _46 => _46.id]), () => ( null));
+    this.commit("Remove layer", { ...this.doc, layers, activeLayerId: active });
+    return { removed: id, activeLayerId: active };
+  }
+  duplicateLayer(id) {
+    this.requireIdle("duplicating a layer");
+    const loc = _chunkWSTEXEKDcjs.findLayer.call(void 0, this.doc.layers, id);
+    if (!loc) throw new PaintEditorError(`Unknown layer "${id}". Call list_layers for the ids.`);
+    const copy = (l) => l.type === "group" ? { ...l, id: newPaintLayerId(), children: l.children.map(copy) } : { ...l, id: newPaintLayerId() };
+    const dup = { ...copy(loc.layer), name: `${loc.layer.name} copy` };
+    const layers = _chunkWSTEXEKDcjs.insertLayer.call(void 0, this.doc.layers, dup, _nullishCoalesce(_optionalChain([loc, 'access', _47 => _47.parent, 'optionalAccess', _48 => _48.id]), () => ( null)), loc.index + 1);
+    this.commit("Duplicate layer", { ...this.doc, layers, activeLayerId: dup.id });
+    return this.describeLayer(dup);
+  }
+  /** Moves a layer to `index` (0 = bottom) within `parentId` (default its own parent; `null` = top level). */
+  moveLayer(id, index, parentId) {
+    this.requireIdle("moving a layer");
+    const loc = _chunkWSTEXEKDcjs.findLayer.call(void 0, this.doc.layers, id);
+    if (!loc) throw new PaintEditorError(`Unknown layer "${id}". Call list_layers for the ids.`);
+    const target = parentId === void 0 ? _nullishCoalesce(_optionalChain([loc, 'access', _49 => _49.parent, 'optionalAccess', _50 => _50.id]), () => ( null)) : parentId;
+    if (target) {
+      const g = this.requireLayer(target);
+      if (g.type !== "group") throw new PaintEditorError(`Layer "${g.name}" is not a group; pass a group id as parentId.`);
+      if (target === id || loc.layer.type === "group" && _chunkWSTEXEKDcjs.findLayer.call(void 0, loc.layer.children, target)) throw new PaintEditorError("A group cannot move into itself.");
+    }
+    const without = _chunkWSTEXEKDcjs.mapLayer.call(void 0, this.doc.layers, id, () => null);
+    const siblings = target ? _chunkWSTEXEKDcjs.findLayer.call(void 0, without, target).layer.children : without;
+    if (!Number.isInteger(index) || index < 0 || index > siblings.length) throw new PaintEditorError(`index ${index} is out of range; use 0..${siblings.length} (0 is the bottom).`);
+    const layers = _chunkWSTEXEKDcjs.insertLayer.call(void 0, without, loc.layer, target, index);
+    this.commit("Move layer", { ...this.doc, layers });
+    return this.describeLayer(loc.layer);
+  }
+  /** Merges a pixel layer into the pixel layer below it (keeping the lower one's settings). */
+  mergeDown(id) {
+    this.requireIdle("merging");
+    const loc = _chunkWSTEXEKDcjs.findLayer.call(void 0, this.doc.layers, id);
+    if (!loc) throw new PaintEditorError(`Unknown layer "${id}". Call list_layers for the ids.`);
+    const siblings = loc.parent ? loc.parent.children : this.doc.layers;
+    const below = siblings[loc.index - 1];
+    const upper = loc.layer;
+    if (!isPixelLayer(upper) || !isPixelLayer(below)) throw new PaintEditorError("Merge down needs a pixel layer directly above another pixel layer in the same group.");
+    if (_chunkWSTEXEKDcjs.isLayerLocked.call(void 0, below, "pixels")) throw new PaintEditorError(`Layer "${below.name}" has its pixels locked; unlock it to merge into it.`);
+    const rect = unionRect(this.describeLayer(below).bounds, this.describeLayer(upper).bounds);
+    let surface = _chunkCRMAXIUVcjs.emptySurface.call(void 0, 4);
+    if (rect) {
+      const base = { ...below, opacity: 1, blend: "normal", visible: true, clipped: void 0, mask: void 0 };
+      const px = createPaintCompositor().composite([base, upper.visible ? upper : { ...upper, opacity: 0 }], rect, this.sources());
+      surface = _chunkCRMAXIUVcjs.surfaceFromPixels.call(void 0, { width: rect.width, height: rect.height, data: px }, 4, rect.x, rect.y);
+    }
+    const merged = { ...below, surface, offset: { x: 0, y: 0 } };
+    const layers = _chunkWSTEXEKDcjs.mapLayer.call(void 0, _chunkWSTEXEKDcjs.mapLayer.call(void 0, this.doc.layers, upper.id, () => null), below.id, () => merged);
+    this.commit("Merge down", { ...this.doc, layers, activeLayerId: below.id });
+    return this.describeLayer(merged);
+  }
+  /** Removes every pixel of a layer. */
+  clearLayer(layerId) {
+    this.requireIdle("clearing");
+    const l = this.paintTarget(layerId, "clear");
+    const bounds = this.describeLayer(l).bounds;
+    this.commit("Clear layer", { ...this.doc, layers: _chunkWSTEXEKDcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface: _chunkCRMAXIUVcjs.emptySurface.call(void 0, 4) })) });
+    return { layerId: l.id, bounds };
+  }
+  /**
+   * Fills a layer across the canvas with a colour. With `grain` above 0 the fill follows the paper
+   * grain (it catches the peaks, as pastel or charcoal rubbed across the sheet).
+   */
+  fillLayer(options = {}) {
+    this.requireIdle("filling");
+    const l = this.paintTarget(options.layerId, "fill");
+    const color = options.color === void 0 ? this.color : parseColor(options.color);
+    const opacity = _nullishCoalesce(options.opacity, () => ( 1));
+    if (!(opacity >= 0 && opacity <= 1)) throw new PaintEditorError(`opacity ${opacity} is out of range; use 0..1.`);
+    const grainAmount = _nullishCoalesce(options.grain, () => ( 0));
+    if (!(grainAmount >= 0 && grainAmount <= 1)) throw new PaintEditorError(`grain ${grainAmount} is out of range; use 0..1.`);
+    const pressure = _nullishCoalesce(options.pressure, () => ( 0.5));
+    const blend = _nullishCoalesce(options.blend, () => ( "normal"));
+    if (!_chunkCRMAXIUVcjs.isBlendMode.call(void 0, blend)) throw new PaintEditorError(`Unknown blend mode "${blend}".`);
+    const { width, height } = this.doc.canvas;
+    const rect = { x: 0, y: 0, width, height };
+    const coverage = new (0, _chunkPV42JITTcjs.CoverageMap)();
+    const depth = grainAmount * this.doc.paper.depth;
+    const grain = depth > 0 ? paperGrain(this.doc.paper) : null;
+    for (const { tx, ty } of _chunkCRMAXIUVcjs.tilesInRect.call(void 0, rect)) {
+      const r = { x: tx * _chunkCRMAXIUVcjs.TILE, y: ty * _chunkCRMAXIUVcjs.TILE, width: Math.min(_chunkCRMAXIUVcjs.TILE, width - tx * _chunkCRMAXIUVcjs.TILE), height: Math.min(_chunkCRMAXIUVcjs.TILE, height - ty * _chunkCRMAXIUVcjs.TILE) };
+      const vals = new Float32Array(r.width * r.height);
+      for (let y = 0, k = 0; y < r.height; y++) for (let x = 0; x < r.width; x++, k++) vals[k] = grain ? grainCatch(grain.at(r.x + x + 0.5, r.y + y + 0.5), depth, pressure) : 1;
+      coverage.accumulate(r, vals, 1);
+    }
+    const apply = {
+      mode: "paint",
+      color: rgbaOf(color),
+      background: rgbaOf(this.doc.paper.color),
+      opacity,
+      blend,
+      lockTransparency: _chunkWSTEXEKDcjs.isLayerLocked.call(void 0, l, "transparency"),
+      selection: null,
+      offset: l.offset
+    };
+    const surface = this.applyCoverage(l, coverage, rect, apply);
+    this.commit("Fill layer", { ...this.doc, layers: _chunkWSTEXEKDcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface })) });
+    return { layerId: l.id, bounds: rect };
+  }
+  applyCoverage(l, coverage, rect, apply) {
+    const base = l.surface;
+    const tiles = new Map(base.tiles);
+    for (const { tx, ty } of _chunkCRMAXIUVcjs.tilesInRect.call(void 0, { x: rect.x - l.offset.x, y: rect.y - l.offset.y, width: rect.width, height: rect.height })) {
+      const key = _chunkCRMAXIUVcjs.tileKey.call(void 0, tx, ty);
+      const src = _nullishCoalesce(_optionalChain([base, 'access', _51 => _51.tiles, 'access', _52 => _52.get, 'call', _53 => _53(key), 'optionalAccess', _54 => _54.data]), () => ( new Uint8ClampedArray(_chunkCRMAXIUVcjs.TILE * _chunkCRMAXIUVcjs.TILE * 4)));
+      const tile = _chunkCRMAXIUVcjs.finishTile.call(void 0, _chunkPV42JITTcjs.applyStrokeToTile.call(void 0, coverage, src, 4, tx, ty, apply), 4, 0);
+      if (tile) tiles.set(key, tile);
+      else tiles.delete(key);
+    }
+    return new (0, _chunkCRMAXIUVcjs.TiledSurface)(4, tiles, 0);
+  }
+  // --- Brushes -------------------------------------------------------------------
+  findBrush(id) {
+    return _nullishCoalesce(BUILTIN_BRUSHES.find((b) => b.id === id), () => ( this.userBrushes.find((b) => b.id === id)));
+  }
+  /** A library brush by id (`undefined` when unknown). */
+  getBrush(id) {
+    const b = this.findBrush(id);
+    return b ? normalizePaintBrush(b, b) : void 0;
+  }
+  requireBrush(id) {
+    const b = this.findBrush(id);
+    if (!b) throw new PaintEditorError(`Unknown brush "${id}". Call list_brushes for the ids.`);
+    return b;
+  }
+  /**
+   * Chooses the active brush (`id`: a library brush) and / or changes its settings. Editor state,
+   * not an undo step. Returns the active brush.
+   */
+  setBrush(update = {}) {
+    const { id, ...changes } = update;
+    const base = id !== void 0 ? this.requireBrush(id) : this.brush;
+    const next = normalizePaintBrush({ ...changes, id: base.id }, base);
+    if (base.builtin && !Object.keys(changes).length) next.builtin = true;
+    else delete next.builtin;
+    this.brush = next;
+    this.emit([]);
+    return this.brush;
+  }
+  /** Saves the active brush (or `brush`) into the user library under `id` / `name`. */
+  saveBrush(options) {
+    if (!BRUSH_ID.test(options.id)) throw new PaintEditorError(`Brush id "${options.id}" is invalid; use lowercase letters, digits and dashes (e.g. "my-pencil").`);
+    if (BUILTIN_BRUSHES.some((b) => b.id === options.id)) throw new PaintEditorError(`"${options.id}" is a built-in brush; save under another id.`);
+    const source = options.brush ? normalizePaintBrush(options.brush, this.brush) : this.brush;
+    const saved = normalizePaintBrush({ ...source, id: options.id, name: _nullishCoalesce(options.name, () => ( source.name)) });
+    delete saved.builtin;
+    const i = this.userBrushes.findIndex((b) => b.id === options.id);
+    if (i >= 0) this.userBrushes[i] = saved;
+    else this.userBrushes.push(saved);
+    this.emit([]);
+    return saved;
+  }
+  removeBrush(id) {
+    if (BUILTIN_BRUSHES.some((b) => b.id === id)) throw new PaintEditorError(`"${id}" is a built-in brush and cannot be removed.`);
+    const i = this.userBrushes.findIndex((b) => b.id === id);
+    if (i < 0) throw new PaintEditorError(`Unknown brush "${id}". Call list_brushes for the ids.`);
+    this.userBrushes.splice(i, 1);
+    this.emit([]);
+  }
+  /** The user's saved brushes. */
+  getUserBrushes() {
+    return this.userBrushes.map((b) => normalizePaintBrush(b, b));
+  }
+  /** A brush library file of the given brushes (default: the user's brushes). */
+  exportBrushes(ids) {
+    const list = ids ? ids.map((id) => this.requireBrush(id)) : this.userBrushes;
+    return { format: "pixerate-brushes", version: 1, brushes: list.map(brushToJSON) };
+  }
+  /**
+   * Adds the brushes of a library file to the user library. A brush whose id is taken is skipped
+   * unless `replace` (built-in ids are always skipped). Returns the ids added and the problems.
+   */
+  importBrushes(file, options = {}) {
+    const problems = [];
+    let list;
+    try {
+      list = parseBrushLibrary(file, problems);
+    } catch (e) {
+      throw new PaintEditorError(e.message);
+    }
+    const added = [];
+    const skipped = [];
+    for (const b of list) {
+      if (BUILTIN_BRUSHES.some((x) => x.id === b.id)) {
+        skipped.push(b.id);
+        problems.push(`"${b.id}" is a built-in brush id; rename it to import it.`);
+        continue;
+      }
+      const i = this.userBrushes.findIndex((x) => x.id === b.id);
+      if (i >= 0 && !options.replace) {
+        skipped.push(b.id);
+        continue;
+      }
+      if (i >= 0) this.userBrushes[i] = b;
+      else this.userBrushes.push(b);
+      added.push(b.id);
+    }
+    if (added.length) this.emit([]);
+    return { added, skipped, problems };
+  }
+  /** A thumbnail of a brush: a test stroke on the current paper. */
+  brushThumbnail(id, options = {}) {
+    const b = id === this.brush.id ? this.brush : this.requireBrush(id);
+    return renderBrushThumbnail(b, { paper: this.doc.paper, width: options.width, height: options.height, color: options.color ? parseColor(options.color) : this.color });
+  }
+  // --- Colour --------------------------------------------------------------------
+  setColor(color) {
+    this.color = parseColor(color);
+    this.emit([]);
+    return this.color;
+  }
+  setSecondaryColor(color) {
+    this.secondaryColor = parseColor(color);
+    this.emit([]);
+    return this.secondaryColor;
+  }
+  swapColors() {
+    [this.color, this.secondaryColor] = [this.secondaryColor, this.color];
+    this.emit([]);
+  }
+  /** The colour at a document pixel: of the composite (paper included) or of one layer. */
+  pickColor(x, y, options = {}) {
+    const { width, height } = this.doc.canvas;
+    const px = Math.floor(x);
+    const py = Math.floor(y);
+    if (!(px >= 0 && py >= 0 && px < width && py < height)) throw new PaintEditorError(`(${x}, ${y}) is outside the ${width}\xD7${height} canvas.`);
+    if (options.layerId !== void 0) {
+      const l = this.requireLayer(options.layerId);
+      if (!isPixelLayer(l)) throw new PaintEditorError(`Layer "${l.name}" is a group; pick from a pixel layer or the composite.`);
+      const [r, g, b, a] = _chunkCRMAXIUVcjs.readPixel.call(void 0, l.surface, px - l.offset.x, py - l.offset.y);
+      return { color: rgbToHex(r, g, b), alpha: Math.round(a / 255 * 1e3) / 1e3 };
+    }
+    const d = this.exportCompositor.composite(this.renderLayers({}), { x: px, y: py, width: 1, height: 1 }, this.sources());
+    return { color: rgbToHex(d[0], d[1], d[2]), alpha: Math.round(d[3] / 255 * 1e3) / 1e3 };
+  }
+  // --- Mixer Brush ---------------------------------------------------------------
+  /** Fills the Mixer Brush reservoir with a colour (default the editor colour). */
+  loadMixerBrush(color) {
+    const [r, g, b] = hexToRgb8(color === void 0 ? this.color : parseColor(color));
+    this.mixerLoad = _chunkPV42JITTcjs.loadMixer.call(void 0, this.mixerLoad, [r / 255, g / 255, b / 255]);
+    this.emit([]);
+    return this.mixerLoad;
+  }
+  /** Empties the pickup well (and with `emptyReservoir` the loaded paint too). */
+  cleanMixerBrush(emptyReservoir = false) {
+    this.mixerLoad = emptyReservoir ? _chunkPV42JITTcjs.EMPTY_MIXER_LOAD : _chunkPV42JITTcjs.cleanMixer.call(void 0, this.mixerLoad);
+    this.emit([]);
+    return this.mixerLoad;
+  }
+  // --- View and hand -------------------------------------------------------------
+  /** Zoom, pan, rotation and mirroring: view state only, the pixels never resample. */
+  setView(update) {
+    this.view = normalizeView(update, this.view);
+    this.emit([]);
+    return this.view;
+  }
+  resetView() {
+    return this.setView({ ...DEFAULT_VIEW, pan: { x: 0, y: 0 } });
+  }
+  setHand(hand) {
+    if (hand !== "left" && hand !== "right") throw new PaintEditorError(`hand is ${JSON.stringify(hand)}; use "left" or "right".`);
+    this.hand = hand;
+    this.emit([]);
+    return hand;
+  }
+  // --- Strokes -------------------------------------------------------------------
+  strokeBrush(init) {
+    let brush = init.brushId !== void 0 ? this.requireBrush(init.brushId) : this.brush;
+    if (init.brush) brush = normalizePaintBrush({ ...init.brush, id: brush.id }, brush);
+    return brush;
+  }
+  /** Extra copies every new stroke paints (the painting guides add mirror and kaleidoscope copies). */
+  strokeCopies() {
+    return [];
+  }
+  sessionFor(doc, init, host) {
+    const layer = (() => {
+      const id = _nullishCoalesce(init.layerId, () => ( doc.activeLayerId));
+      if (!id) throw new PaintEditorError("There is no active layer to paint on; add one with add_layer.");
+      const loc = _chunkWSTEXEKDcjs.findLayer.call(void 0, doc.layers, id);
+      if (!loc) throw new PaintEditorError(`Unknown layer "${id}". Call list_layers for the ids.`);
+      const l = loc.layer;
+      if (!isPixelLayer(l)) throw new PaintEditorError(`Layer "${l.name}" is a group; paint on a pixel layer inside it.`);
+      if (_chunkWSTEXEKDcjs.isLayerLocked.call(void 0, l, "pixels")) throw new PaintEditorError(`Layer "${l.name}" has its pixels locked; unlock it (update_layer locks) to paint on it.`);
+      if (!l.visible) throw new PaintEditorError(`Layer "${l.name}" is hidden; show it (update_layer visible true) to paint on it.`);
+      return l;
+    })();
+    const brush = this.strokeBrush(init);
+    const color = init.color === void 0 ? this.color : parseColor(init.color);
+    const rgba = rgbaOf(color);
+    const seed = _nullishCoalesce(init.seed, () => ( mix32(this.seedCounter++ * 2654435761 >>> 0) & 2147483647));
+    const copies = (_nullishCoalesce(init.copies, () => ( this.strokeCopies()))).filter((m) => m.some((v, i) => v !== IDENTITY_AFFINE[i]));
+    const session = new PaintStrokeSession(host, {
+      layerId: layer.id,
+      surface: layer.surface,
+      offset: layer.offset,
+      lockTransparency: _chunkWSTEXEKDcjs.isLayerLocked.call(void 0, layer, "transparency"),
+      brush,
+      color: rgba,
+      background: rgbaOf(doc.paper.color),
+      grain: paperGrain(doc.paper),
+      paperDepth: doc.paper.depth,
+      seed,
+      colorHex: color,
+      affineCopies: copies,
+      copies: [IDENTITY_AFFINE, ...copies].map(affineCopy),
+      mixerLoad: brush.engine === "mixer" ? mixerLoadForStroke(brush, this.mixerLoad, [rgba[0] / 255, rgba[1] / 255, rgba[2] / 255]) : _chunkPV42JITTcjs.EMPTY_MIXER_LOAD
+    });
+    return session;
+  }
+  record(session) {
+    const init = session.init;
+    const stroke = {
+      id: `s${this.strokeCounter++}`,
+      layerId: session.layerId,
+      brush: brushToJSON(init.brush),
+      color: init.colorHex,
+      points: session.points.map((p) => ({ ...p })),
+      seed: init.seed
+    };
+    if (init.affineCopies.length) stroke.copies = init.affineCopies.map((m) => [...m]);
+    return stroke;
+  }
+  /**
+   * Starts a live stroke for pointer input: `push` raw pen samples (document pixels), then `end()`
+   * (one undo step) or `cancel()`.
+   */
+  beginStroke(init = {}) {
+    this.requireIdle("starting another");
+    const host = {
+      update: (layerId, surface, rects) => {
+        this.live = { layerId, surface };
+        this.emit(rects);
+      },
+      commit: (s, surface, cancelled) => {
+        this.session = null;
+        this.live = null;
+        this.liveLayers = null;
+        const brush = s.init.brush;
+        if (!cancelled && _optionalChain([s, 'access', _55 => _55.result, 'optionalAccess', _56 => _56.mixerLoad]) && brush.loadsColor) this.mixerLoad = s.result.mixerLoad;
+        if (cancelled || !surface) {
+          this.emit();
+          return;
+        }
+        const stroke = this.record(s);
+        s.result.strokeId = stroke.id;
+        const l = this.getLayer(s.layerId);
+        this.commit(`${brush.name} stroke`, { ...this.doc, layers: _chunkWSTEXEKDcjs.mapLayer.call(void 0, this.doc.layers, l.id, () => ({ ...l, surface })), strokes: [...this.doc.strokes, stroke] });
+      }
+    };
+    const session = this.sessionFor(this.doc, init, host);
+    this.session = session;
+    this.emit([]);
+    return session;
+  }
+  /** The current live stroke, if any. */
+  get activeStroke() {
+    return this.session;
+  }
+  /** Runs a whole stroke against `doc` without touching the editor; returns the new document. */
+  runStroke(doc, init, points) {
+    let out = doc;
+    const host = {
+      update: () => {
+      },
+      commit: (s, surface, cancelled) => {
+        if (cancelled || !surface) return;
+        const stroke = this.record(s);
+        s.result.strokeId = stroke.id;
+        const l = _chunkWSTEXEKDcjs.findLayer.call(void 0, out.layers, s.layerId).layer;
+        out = { ...out, layers: _chunkWSTEXEKDcjs.mapLayer.call(void 0, out.layers, l.id, () => ({ ...l, surface })), strokes: [...out.strokes, stroke] };
+      }
+    };
+    const session = this.sessionFor(doc, init, host);
+    session.push(points);
+    const result = session.end();
+    return { doc: out, result, brush: session.init.brush };
+  }
+  /** Paints one stroke from data (one undo step). */
+  paintStroke(init) {
+    this.requireIdle("painting");
+    const points = this.checkPoints(init.points);
+    const { doc, result, brush } = this.runStroke(this.doc, init, points);
+    if (result.mixerLoad && brush.loadsColor) this.mixerLoad = result.mixerLoad;
+    if (doc !== this.doc) this.commit(`${brush.name} stroke`, doc);
+    else this.emit([]);
+    return result;
+  }
+  checkPoints(points) {
+    if (!Array.isArray(points) || !points.length) throw new PaintEditorError("points is empty; give at least one {x, y} in document pixels.");
+    const out = [];
+    points.forEach((p, i) => {
+      if (!p || !Number.isFinite(p.x) || !Number.isFinite(p.y)) throw new PaintEditorError(`points[${i}] needs finite x and y in document pixels.`);
+      if (p.pressure !== void 0 && !(p.pressure >= 0 && p.pressure <= 1)) throw new PaintEditorError(`points[${i}].pressure ${p.pressure} is out of range; use 0..1.`);
+      out.push(p);
+    });
+    return out;
+  }
+  /** Every recorded stroke, oldest first. */
+  getStrokes() {
+    return this.doc.strokes;
+  }
+  /**
+   * Replays recorded strokes, varied (moved, scaled, rotated, flipped, recoloured, with another
+   * brush or layer), `repeat` times: all of it one undo step. Returns the new strokes.
+   */
+  replayStrokes(options) {
+    this.requireIdle("replaying");
+    if (!_optionalChain([options, 'access', _57 => _57.strokeIds, 'optionalAccess', _58 => _58.length])) throw new PaintEditorError("strokeIds is empty; pass ids from list_strokes.");
+    const strokes = options.strokeIds.map((id) => {
+      const s = this.doc.strokes.find((x) => x.id === id);
+      if (!s) throw new PaintEditorError(`Unknown stroke "${id}". Call list_strokes for the ids.`);
+      return s;
+    });
+    const repeat = _nullishCoalesce(options.repeat, () => ( 1));
+    if (!Number.isInteger(repeat) || repeat < 1 || repeat > 100) throw new PaintEditorError(`repeat ${repeat} is out of range; use 1..100.`);
+    if (options.scale !== void 0 && !(options.scale > 0 && options.scale <= 20)) throw new PaintEditorError(`scale ${options.scale} is out of range; use above 0 up to 20.`);
+    if (options.color !== void 0) parseColor(options.color);
+    if (options.brushId !== void 0) this.requireBrush(options.brushId);
+    if (options.layerId !== void 0) this.paintTarget(options.layerId, "replay onto");
+    let origin = options.origin;
+    if (!origin) {
+      const b = strokeBounds(strokes.flatMap((s) => s.points));
+      origin = { x: b.x + b.width / 2, y: b.y + b.height / 2 };
+    }
+    const step = variationAffine(options, origin);
+    let doc = this.doc;
+    let bounds = null;
+    const ids = [];
+    const layerIds = /* @__PURE__ */ new Set();
+    let m = IDENTITY_AFFINE;
+    for (let k = 0; k < repeat; k++) {
+      m = [step[0] * m[0] + step[1] * m[2], step[0] * m[1] + step[1] * m[3], step[2] * m[0] + step[3] * m[2], step[2] * m[1] + step[3] * m[3], step[0] * m[4] + step[1] * m[5] + step[4], step[2] * m[4] + step[3] * m[5] + step[5]];
+      for (const s of strokes) {
+        const v = varyStroke(s, m, options);
+        let brush = v.brush;
+        if (options.brushId !== void 0) {
+          const b = this.requireBrush(options.brushId);
+          brush = normalizePaintBrush({ tip: { ...b.tip, size: b.tip.size * (v.brush.tip.size / s.brush.tip.size) } }, b);
+        }
+        const layerId = _nullishCoalesce(options.layerId, () => ( s.layerId));
+        if (!_chunkWSTEXEKDcjs.findLayer.call(void 0, doc.layers, layerId)) throw new PaintEditorError(`Stroke "${s.id}" was painted on layer "${layerId}", which no longer exists; pass layerId to replay it elsewhere.`);
+        const run = this.runStroke(doc, { layerId, color: _nullishCoalesce(options.color, () => ( s.color)), brush, seed: s.seed, copies: _nullishCoalesce(v.copies, () => ( [])) }, v.points);
+        doc = run.doc;
+        bounds = unionRect(bounds, run.result.bounds);
+        if (run.result.strokeId) ids.push(run.result.strokeId);
+        layerIds.add(layerId);
+      }
+    }
+    if (doc !== this.doc) this.commit(strokes.length === 1 && repeat === 1 ? "Replay stroke" : "Replay strokes", doc);
+    return { strokeIds: ids, bounds, layerIds: [...layerIds] };
+  }
+  // --- Rendering -----------------------------------------------------------------
+  sources() {
+    return { width: this.doc.canvas.width, height: this.doc.canvas.height };
+  }
+  /** The layers with the live stroke's surface in place. */
+  currentLayers() {
+    const live = this.live;
+    if (!live) return this.doc.layers;
+    if (_optionalChain([this, 'access', _59 => _59.liveLayers, 'optionalAccess', _60 => _60.key]) === live.surface) return this.liveLayers.layers;
+    const layers = _chunkWSTEXEKDcjs.mapLayer.call(void 0, this.doc.layers, live.layerId, (l) => ({ ...l, surface: live.surface }));
+    this.liveLayers = { key: live.surface, layers };
+    return layers;
+  }
+  /** View-only layers between the paper and the paint (the painting guides add the tracing image). */
+  underlayLayers() {
+    return [];
+  }
+  renderLayers(options, view = false) {
+    let layers = this.currentLayers();
+    if (options.layerIds) {
+      const picked = [];
+      for (const id of options.layerIds) picked.push(this.requireLayer(id));
+      layers = picked.map((l) => ({ ...l, visible: true }));
+    }
+    const under = options.paper === false ? [] : [paperNode(this.doc.paper)];
+    if (view) under.push(...this.underlayLayers());
+    return [...under, ...layers];
+  }
+  /**
+   * Composites the viewport stack (paper, view-only underlays, layers with the live stroke) tile by
+   * tile over `rect`, calling `onTile` with each 256 px tile's RGBA (cached: unchanged tiles come back
+   * as the same buffer). Pass `takeDirty()` as `dirty`.
+   */
+  compositeTiles(rect, onTile, options = {}) {
+    const dirty = options.dirty === "all" ? void 0 : options.dirty;
+    this.viewCompositor.compositeTiles(this.renderLayers({}, true), rect, this.sources(), onTile, { dirty, checkpointLayerId: _nullishCoalesce(_optionalChain([this, 'access', _61 => _61.live, 'optionalAccess', _62 => _62.layerId]), () => ( this.doc.activeLayerId)) });
+  }
+  /** The canvas as canvas-sized RGBA (paper included by default). */
+  compositePixels(options = {}) {
+    const { width, height } = this.doc.canvas;
+    const data = this.exportCompositor.composite(this.renderLayers(options), { x: 0, y: 0, width, height }, this.sources());
+    return { width, height, data };
+  }
+  /** The canvas (or some layers), scaled so the longest side is at most `maxSide`. */
+  renderPreview(options = {}) {
+    const full = this.compositePixels(options);
+    const side = Math.max(1, Math.round(_nullishCoalesce(options.maxSide, () => ( 512))));
+    const k = Math.min(1, side / Math.max(full.width, full.height));
+    if (k >= 1) return full;
+    const w = Math.max(1, Math.round(full.width * k));
+    const h = Math.max(1, Math.round(full.height * k));
+    return { width: w, height: h, data: downsampleRgba(full.data, full.width, full.height, w, h) };
+  }
+  // --- Save, load and export -------------------------------------------------------
+  /** The document as JSON with inline PNG assets. */
+  toJSON(options = {}) {
+    return serializePaintDocument(this.doc, { strokes: options.strokes, extensions: this.extensions });
+  }
+  /** The document as JSON with each PNG stored in `store`. */
+  toJSONExternal(store, options = {}) {
+    return serializePaintDocumentExternal(this.doc, store, { strokes: options.strokes, extensions: this.extensions });
+  }
+  adopt(loaded) {
+    this.extensions = loaded.extensions;
+    for (const s of loaded.state.strokes) {
+      const n = Number(_nullishCoalesce(_optionalChain([/^s(\d+)$/, 'access', _63 => _63.exec, 'call', _64 => _64(s.id), 'optionalAccess', _65 => _65[1]]), () => ( 0)));
+      if (n >= this.strokeCounter) this.strokeCounter = n + 1;
+    }
+    this.undoStack = [];
+    this.redoStack = [];
+    this.doc = loaded.state;
+    this.viewCompositor.clear();
+    this.emit();
+    return loaded.problems;
+  }
+  /** Opens a saved document (clears the history). Returns what could not be read. */
+  loadJSON(raw) {
+    this.requireIdle("opening a document");
+    try {
+      return this.adopt(deserializePaintDocument(raw));
+    } catch (e) {
+      throw new PaintEditorError(e.message);
+    }
+  }
+  /** Opens a saved document whose assets may live in `store`. */
+  async loadJSONAsync(raw, store) {
+    this.requireIdle("opening a document");
+    try {
+      return this.adopt(await deserializePaintDocumentAsync(raw, store));
+    } catch (e) {
+      throw new PaintEditorError(e.message);
+    }
+  }
+  /** The canvas as PNG bytes (paper included by default; `scale` below 1 shrinks it). */
+  exportPng(options = {}) {
+    const img = this.scaled(options);
+    return _chunkWSTEXEKDcjs.encodePng.call(void 0, img.width, img.height, img.data);
+  }
+  scaled(options) {
+    const full = this.compositePixels(options);
+    const s = _nullishCoalesce(options.scale, () => ( 1));
+    if (!(s > 0 && s <= 1)) throw new PaintEditorError(`scale ${s} is out of range; use above 0 up to 1 (exports never upscale pixels).`);
+    if (s === 1) return full;
+    const w = Math.max(1, Math.round(full.width * s));
+    const h = Math.max(1, Math.round(full.height * s));
+    return { width: w, height: h, data: downsampleRgba(full.data, full.width, full.height, w, h) };
+  }
+  /**
+   * The canvas as PNG, JPEG or WebP bytes. JPEG has no alpha, so it always includes the paper.
+   * JPEG and WebP need a canvas (a browser or Worker) or the `encodeImage` option.
+   */
+  async exportImage(options = {}) {
+    const format = _nullishCoalesce(options.format, () => ( "image/png"));
+    if (format === "image/png") return this.exportPng(options);
+    if (format !== "image/jpeg" && format !== "image/webp") throw new PaintEditorError(`format ${JSON.stringify(format)} is not supported; use image/png, image/jpeg or image/webp.`);
+    const quality = _nullishCoalesce(options.quality, () => ( 0.92));
+    if (!(quality >= 0 && quality <= 1)) throw new PaintEditorError(`quality ${quality} is out of range; use 0..1.`);
+    const img = this.scaled({ ...options, paper: format === "image/jpeg" ? true : options.paper });
+    const encode = _nullishCoalesce(this.encodeImage, () => ( defaultImageEncoder()));
+    if (!encode) throw new PaintEditorError(`${format} needs a canvas to encode and there is none here; pass encodeImage to the controller, or export PNG.`);
+    return encode(img, format, quality);
+  }
+  /**
+   * The document as an 8-bit RGB PSD through the shared PSD writer: every layer and group, with
+   * the paper as a locked "Paper" pixel layer at the bottom (it is generated, so PSD gets its
+   * pixels), and the composite as the merged image.
+   */
+  exportPsd() {
+    const { width, height, dpi } = this.doc.canvas;
+    const paperPixels = this.compositePixels({ layerIds: [], paper: true });
+    const paperLayer = {
+      type: "pixel",
+      id: "paper",
+      name: "Paper",
+      visible: true,
+      opacity: 1,
+      blend: "normal",
+      locks: { all: true },
+      surface: _chunkCRMAXIUVcjs.surfaceFromPixels.call(void 0, paperPixels, 4),
+      offset: { x: 0, y: 0 }
+    };
+    const merged = this.compositePixels({ paper: true }).data;
+    const result = _chunkVSMM7B3Pcjs.exportPsd.call(void 0, { width, height, layers: [paperLayer, ...this.doc.layers], merged, resolution: dpi });
+    const pigment = _chunkWSTEXEKDcjs.flattenLayers.call(void 0, this.doc.layers).filter((l) => l.blend === "pigment");
+    if (pigment.length) result.warnings.push(`Pigment blending has no PSD equivalent; ${pigment.map((l) => `"${l.name}"`).join(", ")} ${pigment.length === 1 ? "was" : "were"} written as Normal, so ${pigment.length === 1 ? "it looks" : "they look"} different in Photoshop.`);
+    return result;
+  }
+  /** `render_preview` as a base64 PNG. */
+  previewPngBase64(options = {}) {
+    const img = this.renderPreview(options);
+    return { data: _chunkWSTEXEKDcjs.bytesToBase64.call(void 0, _chunkWSTEXEKDcjs.encodePng.call(void 0, img.width, img.height, img.data)), width: img.width, height: img.height };
+  }
+  /** A layer's tile surface (live while stroking), for thumbnails. */
+  layerSurface(id) {
+    const l = _optionalChain([_chunkWSTEXEKDcjs.findLayer.call(void 0, this.currentLayers(), id), 'optionalAccess', _66 => _66.layer]);
+    return isPixelLayer(l) ? l.surface : null;
+  }
+}, _class7);
+
+// src/paint-editor/tools.ts
+var READ = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var SET = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var DESTRUCTIVE = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+var EMPTY = { type: "object", properties: {}, additionalProperties: false };
+var COLOR = { type: "string", pattern: "^#[0-9a-fA-F]{6}$", description: 'Colour #rrggbb, e.g. "#2a4b8d".' };
+var LAYER_ID = { type: "string", description: "Layer id from list_layers (default the active layer)." };
+var TIP = {
+  type: "object",
+  description: "The tip (the shared brush engine). Missing fields keep their current values.",
+  properties: {
+    size: { type: "number", minimum: 1, maximum: _chunkPV42JITTcjs.MAX_BRUSH_SIZE, description: "Diameter in document pixels." },
+    hardness: { type: "number", minimum: 0, maximum: 1, description: "Edge hardness, 0 (soft) .. 1 (hard)." },
+    spacing: { type: "number", minimum: 0.01, maximum: 10, description: "Dab spacing as a fraction of the diameter (0.05 is smooth, 1 is dotted)." },
+    angle: { type: "number", minimum: -360, maximum: 360, description: "Tip angle in degrees, counter-clockwise; with rotation stroke or barrel it is added to the stroke direction or pen rotation." },
+    roundness: { type: "number", minimum: 0.01, maximum: 1, description: "Tip roundness: 1 round, lower is a flat ellipse (a pastel or chisel tip)." },
+    opacity: { type: "number", minimum: 0, maximum: 1, description: "Stroke opacity ceiling: overlapping dabs never exceed it." },
+    flow: { type: "number", minimum: 0, maximum: 1, description: "Build-up per dab towards the opacity (low flow builds up softly, like an airbrush)." },
+    smoothing: { type: "number", minimum: 0, maximum: 0.95, description: "Position smoothing of the input, 0..0.95." },
+    pressureSize: { type: "boolean", description: "Pressure scales the size (down to dynamics.minSize)." },
+    pressureOpacity: { type: "boolean", description: "Pressure scales the opacity." },
+    blend: { type: "string", enum: _chunkCRMAXIUVcjs.BLEND_MODES.map((m) => m.id), description: "How paint combines with the layer. pigment mixes it in like real paint (blue into yellow gives green); multiply darkens like marker ink." }
+  },
+  additionalProperties: false
+};
+var DYNAMICS = {
+  type: "object",
+  description: "Pen dynamics and jitter. Missing fields keep their current values.",
+  properties: {
+    minSize: { type: "number", minimum: 0, maximum: 1, description: "Size at zero pressure as a fraction of the full size (when pressureSize)." },
+    pressureFlow: { type: "number", minimum: 0, maximum: 1, description: "How much pressure scales flow." },
+    tiltSize: { type: "number", minimum: 0, maximum: 1, description: "Laying the pen down widens the tip (up to 2.5\xD7)." },
+    tiltRoundness: { type: "number", minimum: 0, maximum: 1, description: "Laying the pen down flattens the tip along the tilt (side-of-the-pencil shading)." },
+    tiltOpacity: { type: "number", minimum: 0, maximum: 1, description: "Laying the pen down lightens the mark." },
+    velocitySize: { type: "number", minimum: -1, maximum: 1, description: "Positive grows the tip on fast strokes, negative thins it (needs point times t)." },
+    velocityOpacity: { type: "number", minimum: -1, maximum: 1, description: "Positive darkens fast marks, negative lightens them (needs point times t)." },
+    sizeJitter: { type: "number", minimum: 0, maximum: 1, description: "Random size change per dab." },
+    angleJitter: { type: "number", minimum: 0, maximum: 1, description: "Random angle per dab, as a fraction of \xB1180\xB0." },
+    opacityJitter: { type: "number", minimum: 0, maximum: 1, description: "Random opacity drop per dab." },
+    scatter: { type: "number", minimum: 0, maximum: 4, description: "Random offset across the stroke, in diameters." }
+  },
+  additionalProperties: false
+};
+var MIXER = {
+  type: "object",
+  description: "Mixer engine settings (Mixer Brush, blender, smudge). Missing fields keep their current values.",
+  properties: {
+    wet: { type: "number", minimum: 0, maximum: 1, description: "How much canvas colour each dab picks up, 0 (dry) .. 1." },
+    load: { type: "number", minimum: 0, maximum: 1, description: "How much paint the reservoir holds; below 1 it drains per dab, so long strokes run dry." },
+    mix: { type: "number", minimum: 0, maximum: 1, description: "How far each dab's paint moves from the reservoir towards the picked-up colour." },
+    loadEachStroke: { type: "boolean", description: "Refill the reservoir with the colour before each stroke." },
+    cleanEachStroke: { type: "boolean", description: "Empty the pickup well after each stroke." },
+    mixing: { type: "string", enum: [..._chunkPV42JITTcjs.MIXING_MODELS], description: "rgb: RGB averages. pigment: mixes like paint (Kubelka-Munk)." }
+  },
+  additionalProperties: false
+};
+var BRUSH_FIELDS = {
+  name: { type: "string", minLength: 1, maxLength: 80, description: "Display name." },
+  category: { type: "string", enum: [...PAINT_BRUSH_CATEGORIES], description: "Library category." },
+  engine: { type: "string", enum: [...PAINT_BRUSH_ENGINES], description: "dab: paints dabs; eraser: removes paint; mixer: picks up and moves paint (Mixer Brush, blender, smudge)." },
+  tip: TIP,
+  grain: { type: "number", minimum: 0, maximum: 1, description: "Paper grain response: 0 ignores the grain, 1 catches only its peaks at light pressure (pencil, pastel, charcoal). Multiplied by the paper depth." },
+  pressureSmoothing: { type: "number", minimum: 0, maximum: 0.95, description: "Pressure smoothing, separate from the tip position smoothing." },
+  rotation: { type: "string", enum: [...BRUSH_ROTATIONS], description: "What turns the tip: fixed (tip.angle), stroke (follows the direction of travel) or barrel (the pen barrel rotation, twist)." },
+  dynamics: DYNAMICS,
+  mixer: MIXER,
+  loadsColor: { type: "boolean", description: "Mixer engine: load the colour each stroke (false for blender and smudge, which only move paint)." }
+};
+var POINTS = {
+  type: "array",
+  minItems: 1,
+  maxItems: 2e4,
+  description: "The path in document pixels (raw samples; the brush smooths them). One point paints one dab.",
+  items: {
+    type: "object",
+    properties: {
+      x: { type: "number", description: "Document x in pixels." },
+      y: { type: "number", description: "Document y in pixels." },
+      pressure: { type: "number", minimum: 0, maximum: 1, description: "Pen pressure 0..1 (default 1)." },
+      t: { type: "number", description: "Time in milliseconds (optional; drives velocity dynamics, e.g. an ink pen thinning on fast strokes)." },
+      tiltX: { type: "number", minimum: -90, maximum: 90, description: "Pen tilt in degrees towards +x (Pointer Events tiltX)." },
+      tiltY: { type: "number", minimum: -90, maximum: 90, description: "Pen tilt in degrees towards +y (Pointer Events tiltY)." },
+      altitude: { type: "number", minimum: 0, maximum: 1.5708, description: "Pen altitude in radians: 1.5708 upright, 0 lying flat (overrides tiltX / tiltY)." },
+      azimuth: { type: "number", minimum: 0, maximum: 6.2832, description: "Where the pen leans, radians clockwise from +x (with altitude)." },
+      twist: { type: "number", minimum: 0, maximum: 359, description: "Barrel rotation in degrees (brushes with rotation barrel)." }
+    },
+    required: ["x", "y"],
+    additionalProperties: false
+  }
+};
+function loadResult(load) {
+  const hex = (c) => c ? "#" + c.map((v) => Math.round(Math.min(1, Math.max(0, v)) * 255).toString(16).padStart(2, "0")).join("") : null;
+  return { reservoir: hex(load.reservoir), amount: Math.round(load.amount * 1e3) / 1e3, pickup: hex(load.pickup) };
+}
+function brushSummary(b) {
+  return { id: b.id, name: b.name, category: b.category, engine: b.engine, size: b.tip.size, grain: b.grain, rotation: b.rotation, builtin: Boolean(b.builtin) };
+}
+function createPaintEditorToolProvider(controller, options = {}) {
+  const c = controller;
+  const tools = [];
+  const add = (t) => tools.push(t);
+  add({
+    name: "get_canvas_info",
+    title: "Get the canvas",
+    description: "Reads the canvas: size in pixels and dpi, the paper (preset, colour, grain depth), the active layer, the active brush id, the paint colour, the view (zoom, rotation, mirror), the hand, how many strokes are recorded, the undo / redo labels, and the blend modes. Call it first.",
+    inputSchema: EMPTY,
+    annotations: { title: "Get the canvas", ...READ },
+    handler: () => {
+      const s = c.getState();
+      const d = s.document;
+      return {
+        width: d.canvas.width,
+        height: d.canvas.height,
+        dpi: d.canvas.dpi,
+        paper: { preset: d.paper.preset, name: d.paper.name, color: d.paper.color, depth: d.paper.depth },
+        activeLayerId: d.activeLayerId,
+        layerCount: c.listLayers().length,
+        brushId: s.brush.id,
+        color: s.color,
+        secondaryColor: s.secondaryColor,
+        view: { zoom: s.view.zoom, rotation: s.view.rotation, mirror: s.view.mirror },
+        hand: s.hand,
+        strokes: d.strokes.length,
+        undo: s.undoLabel,
+        redo: s.redoLabel,
+        blendModes: _chunkCRMAXIUVcjs.BLEND_MODES.map((m) => m.id)
+      };
+    }
+  });
+  add({
+    name: "new_canvas",
+    title: "Start a new canvas",
+    description: "Replaces the document with a blank canvas: one empty layer over the paper. Size and dpi default to the current ones, the paper to the current paper (or a preset id from list_papers). One undo step (undo brings the old painting back). Returns the new size, paper and layer id.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        width: { type: "integer", minimum: 1, maximum: MAX_CANVAS_SIDE, description: "Width in pixels (default the current width)." },
+        height: { type: "integer", minimum: 1, maximum: MAX_CANVAS_SIDE, description: "Height in pixels (default the current height)." },
+        dpi: { type: "number", minimum: 1, maximum: 1e4, description: "Pixels per inch for print sizes and PSD (default the current dpi)." },
+        paper: { type: "string", description: "Paper preset id from list_papers (default the current paper)." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "Start a new canvas", ...DESTRUCTIVE },
+    handler: (a) => {
+      const d = c.newCanvas({ width: a.width, height: a.height, dpi: a.dpi, paper: a.paper });
+      return { width: d.canvas.width, height: d.canvas.height, dpi: d.canvas.dpi, paper: d.paper.preset, layerId: d.activeLayerId };
+    }
+  });
+  add({
+    name: "set_canvas",
+    title: "Resize the canvas",
+    description: "Changes the canvas size (pixels stay where they are, anchored at the top-left; anything outside is kept on the layers but not shown) and / or its dpi. One undo step. Returns the canvas.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        width: { type: "integer", minimum: 1, maximum: MAX_CANVAS_SIDE, description: "Width in pixels (default unchanged)." },
+        height: { type: "integer", minimum: 1, maximum: MAX_CANVAS_SIDE, description: "Height in pixels (default unchanged)." },
+        dpi: { type: "number", minimum: 1, maximum: 1e4, description: "Pixels per inch (default unchanged)." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "Resize the canvas", ...SET },
+    handler: (a) => c.setCanvas({ width: a.width, height: a.height, dpi: a.dpi })
+  });
+  add({
+    name: "list_papers",
+    title: "List papers",
+    description: "Lists the built-in paper library (generated grain, no textures): id, name, family, grain pattern, colour, grain depth and the wet-media properties (absorption, permeability, roughness). Use an id with set_paper or new_canvas.",
+    inputSchema: EMPTY,
+    annotations: { title: "List papers", ...READ },
+    handler: () => ({
+      papers: PAPER_LIBRARY.map((p) => ({ id: p.preset, name: p.name, family: p.family, pattern: p.pattern, color: p.color, depth: p.depth, absorption: p.absorption, permeability: p.permeability, roughness: p.roughness })),
+      families: [...PAPER_FAMILIES],
+      patterns: [...GRAIN_PATTERNS]
+    })
+  });
+  add({
+    name: "get_paper",
+    title: "Get the paper",
+    description: "Reads every setting of the current paper (preset, pattern, seed, colour, scale, tiling, depth, shading, dry and wet tuning, absorption, permeability, roughness).",
+    inputSchema: EMPTY,
+    annotations: { title: "Get the paper", ...READ },
+    handler: () => JSON.parse(JSON.stringify(c.document.paper))
+  });
+  const tuning2 = {
+    type: "object",
+    properties: {
+      contrast: { type: "number", minimum: 0, maximum: 3, description: "Height contrast around the middle (default 1)." },
+      invert: { type: "boolean", description: "Swap peaks and valleys." }
+    },
+    additionalProperties: false
+  };
+  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.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        preset: { type: "string", description: "Paper id from list_papers (its settings, then the other fields here on top)." },
+        color: { ...COLOR, description: "Paper colour #rrggbb." },
+        depth: { type: "number", minimum: 0, maximum: 1, description: "Grain depth 0..1 (0: brushes ignore the grain)." },
+        scale: { type: "number", minimum: 0.25, maximum: 8, description: "Grain scale: 1 natural, 2 twice as coarse." },
+        seed: { type: "integer", minimum: 0, description: "Grain seed: another sheet of the same paper." },
+        pattern: { type: "string", enum: [...GRAIN_PATTERNS], description: "Grain pattern." },
+        tiling: { type: "string", enum: ["repeat", "mirror"], description: "How the grain tile repeats (mirror hides seams)." },
+        shading: { type: "number", minimum: 0, maximum: 1, description: "How much the grain shades the paper colour." },
+        dry: { ...tuning2, description: "Height map tuning for dry media." },
+        wet: { ...tuning2, description: "Height map tuning for wet media (stored for later)." },
+        absorption: { type: "number", minimum: 0, maximum: 1, description: "Wet media: how fast the paper takes water (stored for later)." },
+        permeability: { type: "number", minimum: 0, maximum: 1, description: "Wet media: how far water spreads in the paper (stored for later)." },
+        roughness: { type: "number", minimum: 0, maximum: 1, description: "Wet media: how much the grain catches pigment (stored for later)." },
+        name: { type: "string", minLength: 1, description: "Display name." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "Set the paper", ...SET },
+    handler: (a) => c.setPaper(a)
+  });
+  add({
+    name: "list_layers",
+    title: "List layers",
+    description: "Lists the layers top first: id, name, type (pixel or group), visibility, opacity, blend, clipping, locks, whether it is active, the painted bounds in document pixels (null when empty), parent and depth.",
+    inputSchema: EMPTY,
+    annotations: { title: "List layers", ...READ },
+    handler: () => ({ layers: c.listLayers(), activeLayerId: c.document.activeLayerId })
+  });
+  add({
+    name: "add_layer",
+    title: "Add a layer",
+    description: "Adds an empty pixel layer (or a group) above the active layer, or above aboveId, or at the top of parentId; it becomes the active layer. One undo step. Returns the layer.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", minLength: 1, description: 'Layer name (default "Layer n").' },
+        type: { type: "string", enum: ["pixel", "group"], description: "pixel (default) or group." },
+        aboveId: { type: "string", description: "Put it directly above this layer (default the active layer)." },
+        parentId: { type: "string", description: "Put it at the top of this group instead." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "Add a layer", ...WRITE },
+    handler: (a) => c.addLayer({ name: a.name, type: a.type, aboveId: a.aboveId, parentId: a.parentId })
+  });
+  add({
+    name: "update_layer",
+    title: "Change a layer",
+    description: "Changes a layer: name, visibility, opacity, blend mode, clipping to the layer below, locks. One undo step. Returns the layer.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        layerId: { type: "string", description: "Layer id from list_layers." },
+        name: { type: "string", minLength: 1, description: "New name." },
+        visible: { type: "boolean", description: "Show or hide." },
+        opacity: { type: "number", minimum: 0, maximum: 1, description: "Layer opacity 0..1." },
+        blend: { type: "string", enum: [..._chunkCRMAXIUVcjs.BLEND_MODES.map((m) => m.id), "pass-through"], description: "Blend mode (pass-through for groups only)." },
+        clipped: { type: "boolean", description: "Clip to the layer below (paint only shows where it has paint)." },
+        locks: {
+          type: "object",
+          description: "Locks to change (others keep their values).",
+          properties: {
+            pixels: { type: "boolean", description: "Refuse painting." },
+            transparency: { type: "boolean", description: "Paint only where the layer already has paint." },
+            position: { type: "boolean", description: "Refuse moving." },
+            all: { type: "boolean", description: "All of the above, plus property changes and removal." }
+          },
+          additionalProperties: false
+        }
+      },
+      required: ["layerId"],
+      additionalProperties: false
+    },
+    annotations: { title: "Change a layer", ...SET },
+    handler: ({ layerId, ...u }) => c.updateLayer(layerId, u)
+  });
+  add({
+    name: "set_active_layer",
+    title: "Choose the active layer",
+    description: "Makes a layer active: strokes, fills and clears without a layerId go to it. Editor state, not an undo step. Returns the layer.",
+    inputSchema: { type: "object", properties: { layerId: { type: "string", description: "Layer id from list_layers." } }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Choose the active layer", ...SET },
+    handler: ({ layerId }) => {
+      c.setActiveLayer(layerId);
+      return c.describeLayer(c.getLayer(layerId));
+    }
+  });
+  add({
+    name: "remove_layer",
+    title: "Remove a layer",
+    description: "Removes a layer (a group with its children). One undo step. Returns the removed id and the new active layer.",
+    inputSchema: { type: "object", properties: { layerId: { type: "string", description: "Layer id from list_layers." } }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Remove a layer", ...DESTRUCTIVE },
+    handler: ({ layerId }) => c.removeLayer(layerId)
+  });
+  add({
+    name: "duplicate_layer",
+    title: "Duplicate a layer",
+    description: "Copies a layer (a group with its children) directly above it; the copy becomes active. One undo step. Returns the copy.",
+    inputSchema: { type: "object", properties: { layerId: { type: "string", description: "Layer id from list_layers." } }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Duplicate a layer", ...WRITE },
+    handler: ({ layerId }) => c.duplicateLayer(layerId)
+  });
+  add({
+    name: "move_layer",
+    title: "Reorder a layer",
+    description: "Moves a layer to a position in its group or another (0 is the bottom). One undo step. Returns the layer with its new parent.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        layerId: { type: "string", description: "Layer id from list_layers." },
+        index: { type: "integer", minimum: 0, description: "New position among its siblings, 0 = bottom." },
+        parentId: { type: ["string", "null"], description: "Group id to move into, or null for the top level (default its current parent)." }
+      },
+      required: ["layerId", "index"],
+      additionalProperties: false
+    },
+    annotations: { title: "Reorder a layer", ...WRITE },
+    handler: ({ layerId, index, parentId }) => c.moveLayer(layerId, index, parentId)
+  });
+  add({
+    name: "merge_layer_down",
+    title: "Merge a layer down",
+    description: "Merges a pixel layer into the pixel layer directly below it, which keeps its name, opacity and blend. One undo step. Returns the merged layer.",
+    inputSchema: { type: "object", properties: { layerId: { type: "string", description: "The upper layer, from list_layers." } }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Merge a layer down", ...DESTRUCTIVE },
+    handler: ({ layerId }) => c.mergeDown(layerId)
+  });
+  add({
+    name: "fill_layer",
+    title: "Fill a layer",
+    description: "Fills a whole pixel layer with a colour: a flat block-in, or with grain above 0 a fill that follows the paper grain like pastel or charcoal rubbed across the sheet (pressure decides how far it reaches into the valleys). Good for a ground colour or a tonal layer to paint over. One undo step. Returns the layer id and the filled bounds.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        layerId: LAYER_ID,
+        color: { ...COLOR, description: "Fill colour #rrggbb (default the paint colour)." },
+        opacity: { type: "number", minimum: 0, maximum: 1, description: "Opacity 0..1 (default 1)." },
+        grain: { type: "number", minimum: 0, maximum: 1, description: "Paper grain response 0..1 (default 0: flat)." },
+        pressure: { type: "number", minimum: 0, maximum: 1, description: "With grain: how far into the valleys, 0..1 (default 0.5)." },
+        blend: { type: "string", enum: _chunkCRMAXIUVcjs.BLEND_MODES.map((m) => m.id), description: "Blend mode (default normal; pigment mixes like paint)." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "Fill a layer", ...WRITE },
+    handler: (a) => c.fillLayer(a)
+  });
+  add({
+    name: "clear_layer",
+    title: "Clear a layer",
+    description: "Removes every pixel of a pixel layer. One undo step. Returns the layer id and the bounds that were cleared (null if it was empty).",
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID }, additionalProperties: false },
+    annotations: { title: "Clear a layer", ...DESTRUCTIVE },
+    handler: ({ layerId }) => c.clearLayer(layerId)
+  });
+  add({
+    name: "list_brushes",
+    title: "List brushes",
+    description: "Lists the brush library: built-in dry media (pencils, pastels, charcoal, airbrush, marker, ink, erasers, blender, smudge, Mixer Brush) and saved user brushes, with id, name, category, engine, size, grain response and rotation mode, plus the active brush id.",
+    inputSchema: EMPTY,
+    annotations: { title: "List brushes", ...READ },
+    handler: () => {
+      const s = c.getState();
+      return { activeBrushId: s.brush.id, activeEdited: !s.brush.builtin && Boolean(_optionalChain([c, 'access', _67 => _67.getBrush, 'call', _68 => _68(s.brush.id), 'optionalAccess', _69 => _69.builtin])), brushes: s.brushes.map(brushSummary) };
+    }
+  });
+  add({
+    name: "get_brush",
+    title: "Get a brush",
+    description: "Reads every setting of a brush (tip, grain, pressure smoothing, rotation, dynamics, mixer). Without id, the active brush as edited.",
+    inputSchema: { type: "object", properties: { id: { type: "string", description: "Brush id from list_brushes (default the active brush)." } }, additionalProperties: false },
+    annotations: { title: "Get a brush", ...READ },
+    handler: ({ id }) => {
+      if (id === void 0) return brushToJSON(c.getState().brush);
+      const b = c.getBrush(id);
+      if (!b) throw new Error(`Unknown brush "${id}". Call list_brushes for the ids.`);
+      return { ...brushToJSON(b), builtin: Boolean(b.builtin) };
+    }
+  });
+  add({
+    name: "set_brush",
+    title: "Set the brush",
+    description: "Chooses the active brush (id) and / or changes its settings; strokes without a brush use it. Editor state, not an undo step. Changes stay on the active brush until save_brush stores them. Returns the active brush.",
+    inputSchema: { type: "object", properties: { id: { type: "string", description: "Brush id from list_brushes to start from." }, ...BRUSH_FIELDS }, additionalProperties: false },
+    annotations: { title: "Set the brush", ...SET },
+    handler: (a) => brushToJSON(c.setBrush(a))
+  });
+  add({
+    name: "save_brush",
+    title: "Save a brush",
+    description: "Saves the active brush (with its changes) into the user library under a new or existing user id. Built-in ids are refused. Library state, not an undo step. Returns the saved brush.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", pattern: "^[a-z0-9][a-z0-9-]{0,63}$", description: "Library id: lowercase letters, digits and dashes." },
+        name: { type: "string", minLength: 1, maxLength: 80, description: "Display name (default the brush name)." }
+      },
+      required: ["id"],
+      additionalProperties: false
+    },
+    annotations: { title: "Save a brush", ...SET },
+    handler: ({ id, name }) => brushToJSON(c.saveBrush({ id, name }))
+  });
+  add({
+    name: "remove_brush",
+    title: "Remove a saved brush",
+    description: "Removes a user brush from the library (built-in brushes cannot be removed). Library state, not an undo step. Returns the removed id.",
+    inputSchema: { type: "object", properties: { id: { type: "string", description: "User brush id from list_brushes." } }, required: ["id"], additionalProperties: false },
+    annotations: { title: "Remove a saved brush", ...DESTRUCTIVE },
+    handler: ({ id }) => {
+      c.removeBrush(id);
+      return { removed: id };
+    }
+  });
+  add({
+    name: "export_brushes",
+    title: "Export brushes",
+    description: "Returns a brush library file (JSON: format pixerate-brushes, version 1, brushes) of the given brushes, or of every user brush. Changes nothing.",
+    inputSchema: {
+      type: "object",
+      properties: { ids: { type: "array", items: { type: "string", description: "Brush id." }, description: "Brush ids from list_brushes (default every user brush)." } },
+      additionalProperties: false
+    },
+    annotations: { title: "Export brushes", ...READ },
+    handler: ({ ids }) => c.exportBrushes(ids)
+  });
+  add({
+    name: "import_brushes",
+    title: "Import brushes",
+    description: "Adds the brushes of a brush library file (as export_brushes returns) to the user library. Taken ids are skipped unless replace is true; built-in ids are always skipped. Library state, not an undo step. Returns the ids added and skipped and any problems.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        library: { type: "object", description: 'The library file: {format: "pixerate-brushes", version: 1, brushes: [...]}.' },
+        replace: { type: "boolean", description: "Replace user brushes with the same id (default false)." }
+      },
+      required: ["library"],
+      additionalProperties: false
+    },
+    annotations: { title: "Import brushes", ...WRITE },
+    handler: ({ library, replace }) => c.importBrushes(library, { replace })
+  });
+  add({
+    name: "render_brush_thumbnail",
+    title: "Render a brush thumbnail",
+    description: "Renders a brush as a PNG: a test stroke (an S-curve swelling and fading in pressure) on the current paper, so you can see what it does before painting. Changes nothing.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Brush id from list_brushes (default the active brush)." },
+        width: { type: "integer", minimum: 16, maximum: 512, description: "Width in pixels (default 160)." },
+        height: { type: "integer", minimum: 16, maximum: 512, description: "Height in pixels (default 48)." },
+        color: { ...COLOR, description: "Stroke colour (default the paint colour)." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "Render a brush thumbnail", ...READ },
+    handler: ({ id, width, height, color }) => {
+      const t = c.brushThumbnail(_nullishCoalesce(id, () => ( c.getState().brush.id)), { width, height, color });
+      return {
+        content: [
+          { type: "image", data: _chunkWSTEXEKDcjs.bytesToBase64.call(void 0, _chunkWSTEXEKDcjs.encodePng.call(void 0, t.width, t.height, t.data)), mimeType: "image/png" },
+          { type: "text", text: `Brush ${_nullishCoalesce(id, () => ( c.getState().brush.id))} ${t.width}\xD7${t.height}` }
+        ]
+      };
+    }
+  });
+  add({
+    name: "set_color",
+    title: "Set the paint colour",
+    description: "Sets the paint colour (and optionally the second colour) that strokes and fills use by default. Editor state, not an undo step. Returns both colours.",
+    inputSchema: {
+      type: "object",
+      properties: { color: { ...COLOR, description: "Paint colour #rrggbb." }, secondaryColor: { ...COLOR, description: "Second colour #rrggbb." } },
+      additionalProperties: false
+    },
+    annotations: { title: "Set the paint colour", ...SET },
+    handler: ({ color, secondaryColor }) => {
+      if (color !== void 0) c.setColor(color);
+      if (secondaryColor !== void 0) c.setSecondaryColor(secondaryColor);
+      const s = c.getState();
+      return { color: s.color, secondaryColor: s.secondaryColor };
+    }
+  });
+  add({
+    name: "pick_color",
+    title: "Pick a colour",
+    description: "Reads the colour at a document pixel: of the painting with its paper, or of one layer (with its alpha). Changes nothing. Returns #rrggbb and alpha 0..1.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        x: { type: "number", description: "Document x in pixels." },
+        y: { type: "number", description: "Document y in pixels." },
+        layerId: { type: "string", description: "Pick from this layer only (default the painting as shown)." }
+      },
+      required: ["x", "y"],
+      additionalProperties: false
+    },
+    annotations: { title: "Pick a colour", ...READ },
+    handler: ({ x, y, layerId }) => c.pickColor(x, y, { layerId })
+  });
+  add({
+    name: "get_mixer_brush",
+    title: "Get the Mixer Brush load",
+    description: "Reads what the Mixer Brush carries between strokes: reservoir #rrggbb or null, amount 0..1 left, pickup #rrggbb or null. Call before painting with mixer-brush when its loadEachStroke is false.",
+    inputSchema: EMPTY,
+    annotations: { title: "Get the Mixer Brush load", ...READ },
+    handler: () => loadResult(c.getState().mixerLoad)
+  });
+  add({
+    name: "load_mixer_brush",
+    title: "Load the Mixer Brush",
+    description: "Fills the Mixer Brush reservoir with a colour (amount 1), keeping what it picked up. Editor state, not an undo step. Returns the load.",
+    inputSchema: { type: "object", properties: { color: { ...COLOR, description: "Colour #rrggbb (default the paint colour)." } }, additionalProperties: false },
+    annotations: { title: "Load the Mixer Brush", ...SET },
+    handler: ({ color }) => loadResult(c.loadMixerBrush(color))
+  });
+  add({
+    name: "clean_mixer_brush",
+    title: "Clean the Mixer Brush",
+    description: "Empties the Mixer Brush pickup well (and with emptyReservoir its paint too). Editor state, not an undo step. Returns the load.",
+    inputSchema: { type: "object", properties: { emptyReservoir: { type: "boolean", description: "Also drop the loaded paint (default false)." } }, additionalProperties: false },
+    annotations: { title: "Clean the Mixer Brush", ...SET },
+    handler: ({ emptyReservoir }) => loadResult(c.cleanMixerBrush(emptyReservoir === true))
+  });
+  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, blender, smudge) picks up and moves paint already on the layer. The painting guides add their mirror copies. One undo step. Returns the layer id, changed bounds, dab count, the recorded strokeId (for replay_strokes) and, for the mixer, its load after the stroke.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        points: POINTS,
+        layerId: LAYER_ID,
+        brushId: { type: "string", description: "Brush id from list_brushes (default the active brush)." },
+        brush: { type: "object", description: "Brush changes for this stroke only.", properties: BRUSH_FIELDS, additionalProperties: false },
+        color: { ...COLOR, description: "Paint colour #rrggbb (default the paint colour)." },
+        seed: { type: "integer", minimum: 0, description: "Jitter seed (default a new one); the same seed and points give the same marks." }
+      },
+      required: ["points"],
+      additionalProperties: false
+    },
+    annotations: { title: "Paint a brush stroke", ...WRITE },
+    handler: (a) => {
+      const r = c.paintStroke({ points: a.points, layerId: a.layerId, brushId: a.brushId, brush: a.brush, color: a.color, seed: a.seed });
+      return r.mixerLoad ? { ...r, mixerLoad: loadResult(r.mixerLoad) } : r;
+    }
+  });
+  add({
+    name: "list_strokes",
+    title: "List recorded strokes",
+    description: "Lists the recorded strokes, oldest first (every stroke is kept as data): id, layer, brush id and name, colour, point count, bounds and seed. With ids, also the points. Use the ids with replay_strokes.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        ids: { type: "array", items: { type: "string", description: "Stroke id." }, description: "Only these strokes, with their points." },
+        last: { type: "integer", minimum: 1, maximum: 1e3, description: "Only the most recent n strokes (default 100)." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "List recorded strokes", ...READ },
+    handler: ({ ids, last }) => {
+      const all = c.getStrokes();
+      const picked = ids ? all.filter((s) => ids.includes(s.id)) : all.slice(-(_nullishCoalesce(last, () => ( 100))));
+      if (ids) {
+        for (const id of ids) if (!all.some((s) => s.id === id)) throw new Error(`Unknown stroke "${id}". Call list_strokes without ids for the ids.`);
+      }
+      return {
+        total: all.length,
+        strokes: picked.map((s) => {
+          const xs = s.points.map((p) => p.x);
+          const ys = s.points.map((p) => p.y);
+          const pad = s.brush.tip.size / 2;
+          return {
+            id: s.id,
+            layerId: s.layerId,
+            brushId: s.brush.id,
+            brushName: s.brush.name,
+            color: s.color,
+            points: ids ? s.points : s.points.length,
+            seed: s.seed,
+            copies: _nullishCoalesce(_optionalChain([s, 'access', _70 => _70.copies, 'optionalAccess', _71 => _71.length]), () => ( 0)),
+            bounds: { x: Math.floor(Math.min(...xs) - pad), y: Math.floor(Math.min(...ys) - pad), width: Math.ceil(Math.max(...xs) - Math.min(...xs) + 2 * pad), height: Math.ceil(Math.max(...ys) - Math.min(...ys) + 2 * pad) }
+          };
+        })
+      };
+    }
+  });
+  add({
+    name: "replay_strokes",
+    title: "Replay strokes, varied",
+    description: "Paints recorded strokes again, moved, scaled, rotated, flipped, recoloured, with another brush or on another layer, repeat times (each repeat applies the variation again: a row, a fan, a spiral). Strokes replay exactly (same seed). All of it is one undo step. Returns the new stroke ids, the changed bounds and layer ids.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        strokeIds: { type: "array", minItems: 1, maxItems: 500, items: { type: "string", description: "Stroke id." }, description: "Stroke ids from list_strokes." },
+        dx: { type: "number", description: "Move right by this many pixels per repeat (default 0)." },
+        dy: { type: "number", description: "Move down by this many pixels per repeat (default 0)." },
+        scale: { type: "number", exclusiveMinimum: 0, maximum: 20, description: "Scale per repeat about the origin; brush size scales too (default 1)." },
+        rotate: { type: "number", minimum: -360, maximum: 360, description: "Rotate per repeat about the origin, degrees clockwise (default 0)." },
+        flipX: { type: "boolean", description: "Mirror left to right about the origin (default false)." },
+        origin: {
+          type: "object",
+          description: "Centre for scale, rotate and flip (default the centre of the strokes).",
+          properties: { x: { type: "number", description: "Document x." }, y: { type: "number", description: "Document y." } },
+          required: ["x", "y"],
+          additionalProperties: false
+        },
+        pressureScale: { type: "number", minimum: 0, maximum: 4, description: "Multiply every pressure (default 1)." },
+        color: { ...COLOR, description: "Recolour (default each stroke\u2019s colour)." },
+        brushId: { type: "string", description: "Replay with this brush from list_brushes (default each stroke\u2019s brush)." },
+        layerId: { type: "string", description: "Paint on this layer (default each stroke\u2019s layer)." },
+        repeat: { type: "integer", minimum: 1, maximum: 100, description: "How many copies (default 1)." }
+      },
+      required: ["strokeIds"],
+      additionalProperties: false
+    },
+    annotations: { title: "Replay strokes, varied", ...WRITE },
+    handler: (a) => c.replayStrokes(a)
+  });
+  add({
+    name: "set_view",
+    title: "Rotate, mirror or zoom the view",
+    description: "Changes the view only (the pixels never resample): zoom, rotation and mirroring, as an artist turns the paper or checks the drawing in a mirror. Editor state, not an undo step. Returns the view.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        zoom: { type: "number", minimum: MIN_ZOOM, maximum: MAX_ZOOM, description: "Screen pixels per document pixel." },
+        rotation: { type: "number", minimum: -360, maximum: 360, description: "Rotation in degrees clockwise." },
+        mirror: { type: "boolean", description: "Mirror left to right." },
+        reset: { type: "boolean", description: "Back to 100 %, no rotation, no mirror, centred (applied first)." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "Rotate, mirror or zoom the view", ...SET },
+    handler: ({ reset, ...v }) => {
+      if (reset) c.resetView();
+      return c.setView(v);
+    }
+  });
+  add({
+    name: "set_hand",
+    title: "Set the drawing hand",
+    description: "Says which hand holds the pen; palm rejection ignores touches on that side of the pen. Editor state, not an undo step. Returns the hand.",
+    inputSchema: { type: "object", properties: { hand: { type: "string", enum: ["right", "left"], description: "right or left." } }, required: ["hand"], additionalProperties: false },
+    annotations: { title: "Set the drawing hand", ...SET },
+    handler: ({ hand }) => ({ hand: c.setHand(hand) })
+  });
+  add({
+    name: "undo_paint",
+    title: "Undo",
+    description: "Undoes the last step (a stroke, a fill, a layer or paper change). Returns the label undone (null when there was nothing) and what can be undone and redone next.",
+    inputSchema: EMPTY,
+    annotations: { title: "Undo", ...WRITE },
+    handler: () => {
+      const undone = c.undo();
+      const s = c.getState();
+      return { undone, nextUndo: s.undoLabel, nextRedo: s.redoLabel };
+    }
+  });
+  add({
+    name: "redo_paint",
+    title: "Redo",
+    description: "Redoes the last undone step. Returns the label redone (null when there was nothing) and what can be undone and redone next.",
+    inputSchema: EMPTY,
+    annotations: { title: "Redo", ...WRITE },
+    handler: () => {
+      const redone = c.redo();
+      const s = c.getState();
+      return { redone, nextUndo: s.undoLabel, nextRedo: s.redoLabel };
+    }
+  });
+  add({
+    name: "render_preview",
+    title: "Render a preview",
+    description: "Renders the painting (with its paper unless paper is false) or some layers as a PNG whose longest side is at most maxSide. Changes nothing. Look at it after each block of work.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        maxSide: { type: "integer", minimum: 16, maximum: 2048, description: "Longest side in pixels (default 512)." },
+        layerIds: { type: "array", items: { type: "string", description: "Layer id." }, description: "Only these layers (default all)." },
+        paper: { type: "boolean", description: "Include the paper (default true)." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "Render a preview", ...READ },
+    handler: ({ maxSide, layerIds, paper }) => {
+      if (layerIds) {
+        for (const id of layerIds) if (!c.getLayer(id)) throw new Error(`Unknown layer "${id}". Call list_layers for the ids.`);
+      }
+      const p = c.previewPngBase64({ maxSide: _nullishCoalesce(maxSide, () => ( 512)), layerIds, paper });
+      return { content: [{ type: "image", data: p.data, mimeType: "image/png" }, { type: "text", text: `Preview ${p.width}\xD7${p.height}` }] };
+    }
+  });
+  add({
+    name: "export_image",
+    title: "Export the painting",
+    description: "Exports the painting as PNG, JPEG or WebP (base64). JPEG always includes the paper; JPEG and WebP need a browser canvas. Changes nothing. Returns the data, its MIME type and size.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        format: { type: "string", enum: ["image/png", "image/jpeg", "image/webp"], description: "File type (default image/png)." },
+        quality: { type: "number", minimum: 0, maximum: 1, description: "JPEG / WebP quality 0..1 (default 0.92)." },
+        scale: { type: "number", exclusiveMinimum: 0, maximum: 1, description: "Shrink by this factor (default 1)." },
+        paper: { type: "boolean", description: "Include the paper (default true)." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "Export the painting", ...READ },
+    handler: async ({ format, quality, scale, paper }) => {
+      const bytes = await c.exportImage({ format, quality, scale, paper });
+      return { mimeType: _nullishCoalesce(format, () => ( "image/png")), bytes: bytes.length, data: _chunkWSTEXEKDcjs.bytesToBase64.call(void 0, bytes) };
+    }
+  });
+  add({
+    name: "export_psd",
+    title: "Export as PSD",
+    description: 'Writes the painting as an 8-bit RGB PSD (PSB above 30000 px) through the shared PSD writer: every layer and group with its opacity, blend, mask and locks, the paper as a locked "Paper" pixel layer at the bottom, and the composite as the merged image. Changes nothing. Returns the file as base64, its size, whether it is a PSB, and warnings (pigment blending has no PSD equivalent).',
+    inputSchema: EMPTY,
+    annotations: { title: "Export as PSD", ...READ },
+    handler: () => {
+      const r = c.exportPsd();
+      return { data: _chunkWSTEXEKDcjs.bytesToBase64.call(void 0, r.bytes), bytes: r.bytes.length, psb: r.psb, warnings: r.warnings };
+    }
+  });
+  add({
+    name: "save_document",
+    title: "Save the document",
+    description: "Returns the document as JSON (format pixerate-paint, version 1): canvas, paper, layers with PNG data URLs, and the recorded strokes unless strokes is false. Changes nothing.",
+    inputSchema: { type: "object", properties: { strokes: { type: "boolean", description: "Include the recorded strokes (default true)." } }, additionalProperties: false },
+    annotations: { title: "Save the document", ...READ },
+    handler: ({ strokes }) => c.toJSON({ strokes })
+  });
+  add({
+    name: "open_document",
+    title: "Open a document",
+    description: "Opens a saved paint document (as save_document returns), replacing the painting and clearing the undo history. Returns the canvas, the layers and anything that could not be read.",
+    inputSchema: { type: "object", properties: { document: { type: "object", description: "The saved document JSON." } }, required: ["document"], additionalProperties: false },
+    annotations: { title: "Open a document", ...DESTRUCTIVE },
+    handler: ({ document }) => {
+      const problems = c.loadJSON(document);
+      const d = c.document;
+      return { width: d.canvas.width, height: d.canvas.height, layers: c.listLayers(), strokes: d.strokes.length, problems };
+    }
+  });
+  tools.push(..._chunkPV42JITTcjs.createPigmentTools.call(void 0, ));
+  return { id: _nullishCoalesce(options.id, () => ( "paint-editor")), namespace: options.namespace, tools };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.BRUSH_ID = BRUSH_ID; exports.BRUSH_ROTATIONS = BRUSH_ROTATIONS; exports.BUILTIN_BRUSHES = BUILTIN_BRUSHES; exports.DEFAULT_BRUSH_ID = DEFAULT_BRUSH_ID; exports.DEFAULT_DPI = DEFAULT_DPI; exports.DEFAULT_DYNAMICS = DEFAULT_DYNAMICS; exports.DEFAULT_PAPER = DEFAULT_PAPER; exports.DEFAULT_VIEW = DEFAULT_VIEW; exports.DryStroke = DryStroke; exports.GRAIN_PATTERNS = GRAIN_PATTERNS; exports.GRAIN_TILE = GRAIN_TILE; exports.IDENTITY_AFFINE = IDENTITY_AFFINE; exports.IDENTITY_COPY = IDENTITY_COPY; exports.MAX_BRUSH_SIZE = _chunkPV42JITTcjs.MAX_BRUSH_SIZE; exports.MAX_CANVAS_SIDE = MAX_CANVAS_SIDE; exports.MAX_ZOOM = MAX_ZOOM; exports.MIN_CANVAS_SIDE = MIN_CANVAS_SIDE; exports.MIN_ZOOM = MIN_ZOOM; exports.PAINT_BRUSH_CATEGORIES = PAINT_BRUSH_CATEGORIES; exports.PAINT_BRUSH_ENGINES = PAINT_BRUSH_ENGINES; exports.PAINT_FORMAT = PAINT_FORMAT; exports.PAINT_SCHEMA_VERSION = PAINT_SCHEMA_VERSION; exports.PAPER_FAMILIES = PAPER_FAMILIES; exports.PAPER_LIBRARY = PAPER_LIBRARY; exports.PAPER_NODE_ID = PAPER_NODE_ID; exports.PaintDocumentError = PaintDocumentError; exports.PaintEditorController = PaintEditorController; exports.PaintEditorError = PaintEditorError; exports.PaintStrokeSession = PaintStrokeSession; exports.PaperGrain = PaperGrain; exports.PenDabWalker = PenDabWalker; exports.PenSmoother = PenSmoother; exports.TRACING_NODE_ID = TRACING_NODE_ID; exports.TileableNoise = TileableNoise; exports.affineCopy = affineCopy; exports.applyAffine = applyAffine; exports.brushToJSON = brushToJSON; exports.clonePaper = clonePaper; exports.composeAffine = composeAffine; exports.createPaintCompositor = createPaintCompositor; exports.createPaintDocument = createPaintDocument; exports.createPaintEditorToolProvider = createPaintEditorToolProvider; exports.createPaintLayer = createPaintLayer; exports.defaultImageEncoder = defaultImageEncoder; exports.deserializePaintDocument = deserializePaintDocument; exports.deserializePaintDocumentAsync = deserializePaintDocumentAsync; exports.documentExtensions = documentExtensions; exports.documentToScreen = documentToScreen; exports.downsampleRgba = downsampleRgba; exports.fitZoom = fitZoom; exports.grainCatch = grainCatch; exports.grainHeights = grainHeights; exports.hash2 = hash2; exports.hexToRgb8 = hexToRgb8; exports.invertAffine = invertAffine; exports.isPalmTouch = isPalmTouch; exports.mapPenPoint = mapPenPoint; exports.mix32 = mix32; exports.mixerLoadForStroke = mixerLoadForStroke; exports.mixerTip = mixerTip; exports.newPaintLayerId = newPaintLayerId; exports.normalizeBrushStroke = normalizeBrushStroke; exports.normalizeCanvas = normalizeCanvas; exports.normalizeDynamics = normalizeDynamics; exports.normalizePaintBrush = normalizePaintBrush; exports.normalizePaper = normalizePaper; exports.normalizeRotation = normalizeRotation; exports.normalizeView = normalizeView; exports.paperGrain = paperGrain; exports.paperKey = paperKey; exports.paperNode = paperNode; exports.paperPreset = paperPreset; exports.parseBrushLibrary = parseBrushLibrary; exports.penOrientation = penOrientation; exports.pointerToPenPoint = pointerToPenPoint; exports.rand01 = rand01; exports.randSigned = randSigned; exports.renderBrushThumbnail = renderBrushThumbnail; exports.renderPaper = renderPaper; exports.samplePressure = samplePressure; exports.screenToDocument = screenToDocument; exports.seedFromString = seedFromString; exports.serializePaintDocument = serializePaintDocument; exports.serializePaintDocumentExternal = serializePaintDocumentExternal; exports.strokeBounds = strokeBounds; exports.thumbnailStroke = thumbnailStroke; exports.tiltToOrientation = tiltToOrientation; exports.toStrokePoint = toStrokePoint; exports.variationAffine = variationAffine; exports.varyStroke = varyStroke; exports.viewCssTransform = viewCssTransform; exports.viewMatrix = viewMatrix; exports.viewPenToDocument = viewPenToDocument;
+//# sourceMappingURL=index.cjs.map