@pixerate/editor 0.266.1 → 0.267.0

package/dist/paint-editor/index.js

@@ -1,7 +1,7 @@
 import {
   StickerBrowser,
   editorStickers
-} from "../chunk-DOZ6F2K2.js";
+} from "../chunk-NSETJI74.js";
 import {
   BRUSH_PATCH_PROPERTIES,
   BRUSH_SLIDERS,
@@ -11,15 +11,15 @@ import {
   mergeBrushPatch,
   multiColorSliders,
   patchBrushValue
-} from "../chunk-3C33YTNN.js";
+} from "../chunk-JGWVZPT6.js";
 import {
   createStickerTools,
   describeStickerRef
-} from "../chunk-6JL2D5SG.js";
+} from "../chunk-VE6UKYQ2.js";
 import {
   BRUSH_PREVIEW_DARK_PAPER,
   brushPreviewsOnDark
-} from "../chunk-4ODRXQRW.js";
+} from "../chunk-EYSHTYLG.js";
 import {
   toVideoFfmpeg
 } from "../chunk-MWUZCEFT.js";
@@ -34,7 +34,8 @@ import {
   resolveExternalAssets,
   serializeLayers,
   serializeLayersExternal
-} from "../chunk-R44Y3EFS.js";
+} from "../chunk-FGJHJIMN.js";
+import "../chunk-ADMRNWR7.js";
 import "../chunk-WJ4WQJCC.js";
 import {
   LAYER_EFFECT_KINDS,
@@ -57,30 +58,9 @@ import {
 import "../chunk-OHKOFKBY.js";
 import "../chunk-ZIF4UJJ6.js";
 import {
-  DEFAULT_FLOW,
-  DEFAULT_WET_PARAMS,
-  FLAT,
-  MAX_WET_LANES,
-  PIGMENT_UNIT,
-  SRGB_TO_LINEAR,
-  WET_FLOW_KINDS,
-  WET_PARAM_KEYS,
-  WET_TILE,
-  WetMedium,
-  WetWorld,
   createPigmentTools,
-  createWetGpuEngine,
-  findWebGpu,
-  flowField,
-  linearToSrgb8,
-  moveWetSnapshot,
-  normalizeFlow,
-  normalizeTilt,
-  normalizeWetParams,
-  pigmentOf,
-  pointerPressure,
-  wetSupport
-} from "../chunk-XC6DPRYI.js";
+  pointerPressure
+} from "../chunk-7UKFXXWL.js";
 import "../chunk-VWEWY4FY.js";
 import "../chunk-HVQVHUTV.js";
 import {
@@ -92,7 +72,47 @@ import {
   realPresenceClock,
   tweenPresenceCursor
 } from "../chunk-IVSWRVB4.js";
-import "../chunk-T2LDTEXK.js";
+import {
+  DEFAULT_PAPER,
+  DryStroke,
+  EFFECT_MAP_REPEATS,
+  EFFECT_STRIP_HEIGHT,
+  GPU_LEAD,
+  IDENTITY_COPY,
+  PAPER_FAMILIES,
+  PAPER_LIBRARY,
+  PaintDabStroke,
+  PaintWetLayers,
+  PenDabWalker,
+  PenSmoother,
+  WET_GPU_MODES,
+  WET_MEDIUM_PARAMS,
+  WetStrokeDriver,
+  brushStickerRefs,
+  clonePaper,
+  effectDabField,
+  effectPaintKey,
+  effectPaintSize,
+  hexToRgb8,
+  isPaintEffectPaint,
+  mixerTip,
+  multiColorForDab,
+  multiColorGradient,
+  multiColorPalette,
+  normalizePaper,
+  paperPreset,
+  penOrientation,
+  readEffectStrokeMap,
+  readPaintEffectPaint,
+  renderPaper,
+  sampleEffectAt,
+  sampleEffectField,
+  stampSampler,
+  tiltToOrientation,
+  toStrokePoint,
+  wetPaperInput,
+  wetPigmentOf
+} from "../chunk-4IDUYB45.js";
 import {
   BRUSH_ID,
   BRUSH_PRESETS,
@@ -147,7 +167,7 @@ import {
   parseBrushLibrary,
   resolveBrush,
   usesPaintExchange
-} from "../chunk-CIJBSUM5.js";
+} from "../chunk-AGNUD5BI.js";
 import {
   STAMP_KINDS,
   StickersSlot,
@@ -156,7 +176,7 @@ import {
   stampCoverage,
   stickerIdFor,
   stickerVariantFor
-} from "../chunk-ACFSFUQH.js";
+} from "../chunk-JL6YH5WD.js";
 import "../chunk-M6DNZNVY.js";
 import {
   bezierPathToSvg,
@@ -180,6 +200,21 @@ import {
   resolveEffectValues
 } from "../chunk-MV7CYFMJ.js";
 import "../chunk-V2ZCJRDM.js";
+import {
+  DEFAULT_FLOW,
+  DEFAULT_WET_PARAMS,
+  MAX_WET_LANES,
+  SRGB_TO_LINEAR,
+  WET_FLOW_KINDS,
+  WET_PARAM_KEYS,
+  WetWorld,
+  linearToSrgb8,
+  normalizeFlow,
+  normalizeTilt,
+  normalizeWetParams,
+  pigmentOf,
+  wetSupport
+} from "../chunk-GSTSZPSR.js";
 import {
   GRAIN_PATTERNS,
   GRAIN_TILE,
@@ -213,15 +248,12 @@ import {
   TileMedium,
   addPaintGradientStop,
   applyStrokeToTile,
-  blenderDab,
   cleanMixer,
-  createBlenderScratch,
   dabRect,
   exchangeRates,
   hexToPaintRgb,
   isGradientPaint,
   loadMixer,
-  mixerRates,
   normalizeHexColor,
   paintGradientMappingFor,
   paintSourceColor,
@@ -259,7 +291,6 @@ import {
   PAINTERLY_BLEND_MODES,
   isBlendMode,
   isPainterlyBlendMode,
-  mixPigment8,
   mixPigments,
   standardBlendMode
 } from "../chunk-IRSTHLQQ.js";
@@ -277,996 +308,72 @@ import {
   tilesInRect,
   translateSurface,
   writeRegion
-} from "../chunk-HVVR5PZW.js";
-import "../chunk-QGHEDC7B.js";
-import "../chunk-SIFAIGB3.js";
-import "../chunk-CIQIM2IP.js";
-import "../chunk-VDGBHYC7.js";
-import {
-  EDITOR_DOCUMENT_FORMAT,
-  createEditorAssetRegistry,
-  defineEditorDocument,
-  toEditorDocumentFile
-} from "../chunk-XBQX76CT.js";
-import "../chunk-HF5QZS7Z.js";
-import "../chunk-M2TPMYJE.js";
-import "../chunk-2WPNAGHI.js";
-import {
-  HARMONY_KINDS,
-  colorHarmony,
-  hueToWheel,
-  wheelToHue
-} from "../chunk-2EUW2XZX.js";
-import "../chunk-E2V5DA3W.js";
-import "../chunk-VR6OGHU5.js";
-import "../chunk-JC2SHA4A.js";
-import {
-  linearToSrgb,
-  oklabToOklch,
-  oklabToRgb,
-  oklchToOklab,
-  rgbToOklab,
-  srgbToLinear
-} from "../chunk-MHLU6GRJ.js";
-import "../chunk-6ONMQ6WF.js";
-
-// src/paint-editor/paper.ts
-var PAPER_FAMILIES = ["watercolor", "drawing", "pastel", "canvas", "panel", "smooth"];
-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: o.seed ?? 1,
-    color,
-    scale: o.scale ?? 1,
-    tiling: "mirror",
-    depth: o.depth,
-    shading: o.shading ?? 0.5,
-    dry: tuning(o.contrast ?? 1),
-    wet: tuning(1),
-    absorption: o.absorption,
-    permeability: o.permeability,
-    roughness: o.roughness,
-    ...o.backlight ? { backlight: o.backlight, backlightColor: o.backlightColor ?? "#fff1d6" } : {}
-  };
-}
-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 }),
-  // Backlit: smooth paper on a lightbox, for glazes that glow like stained glass.
-  preset("stained-glass", "Stained glass (backlit)", "smooth", "smooth", "#ffffff", { depth: 0, absorption: 0.35, permeability: 0.25, roughness: 0.05, shading: 0, backlight: 0.8, backlightColor: "#fff1d6" })
-];
-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 }, ...p.offset ? { offset: { ...p.offset } } : {} };
-}
-function readOffset(raw, d) {
-  const o = raw && typeof raw === "object" ? raw : null;
-  const x = o && typeof o.x === "number" && Number.isFinite(o.x) ? Math.round(o.x) : d?.x ?? 0;
-  const y = o && typeof o.y === "number" && Number.isFinite(o.y) ? Math.round(o.y) : d?.y ?? 0;
-  return x || y ? { offset: { x, y } } : {};
-}
-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 = 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),
-    ...unit(r.metallic, b.metallic ?? 0) > 0 ? { metallic: unit(r.metallic, b.metallic ?? 0) } : {},
-    ...unit(r.backlight, b.backlight ?? 0) > 0 ? { backlight: unit(r.backlight, b.backlight ?? 0) } : {},
-    ...typeof r.backlightColor === "string" && HEX.test(r.backlightColor) ? { backlightColor: r.backlightColor.toLowerCase() } : b.backlightColor ? { backlightColor: b.backlightColor } : {},
-    ...readOffset(r.offset, b.offset)
-  };
-}
-function hexToRgb8(hex2) {
-  const n = parseInt(hex2.slice(1, 7), 16);
-  return [n >> 16 & 255, n >> 8 & 255, n & 255];
-}
-function renderPaper(paper, rect, grain = new PaperGrain(paper), light) {
-  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;
-  const metal = light ? paper.metallic ?? 0 : 0;
-  let hx = 0;
-  let hy = 0;
-  let hz = 1;
-  if (metal > 0 && light) {
-    const az = light.azimuth * Math.PI / 180;
-    const el = light.elevation * Math.PI / 180;
-    const lx = Math.cos(el) * Math.sin(az);
-    const ly = -Math.cos(el) * Math.cos(az);
-    const lz = Math.sin(el) + 1;
-    const n = Math.hypot(lx, ly, lz);
-    hx = lx / n;
-    hy = ly / n;
-    hz = lz / n;
-  }
-  for (let y = 0; y < rect.height; y++) {
-    for (let x = 0; x < rect.width; x++) {
-      const i = (y * rect.width + x) * 4;
-      const px = rect.x + x + 0.5;
-      const py = rect.y + y + 0.5;
-      const k = shade ? 1 - shade * (1 - grain.at(px, py)) : 1;
-      let spec = 0;
-      if (metal > 0) {
-        const gx = (grain.at(px + 1, py) - grain.at(px - 1, py)) * 4;
-        const gy = (grain.at(px, py + 1) - grain.at(px, py - 1)) * 4;
-        const nl = Math.hypot(gx, gy, 1);
-        const nh = Math.max(0, (-gx * hx - gy * hy + hz) / nl);
-        spec = metal * Math.pow(nh, 24) * 0.9;
-      }
-      out[i] = Math.min(255, r * k * (1 - 0.25 * metal) + spec * (r * 0.6 + 102));
-      out[i + 1] = Math.min(255, g * k * (1 - 0.25 * metal) + spec * (g * 0.6 + 102));
-      out[i + 2] = Math.min(255, b * k * (1 - 0.25 * metal) + spec * (b * 0.6 + 102));
-      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: emptySurface(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: options.width ?? 2048, height: options.height ?? 1536, dpi: options.dpi });
-  const layer = createPaintLayer("Layer 1");
-  return { canvas, paper: normalizePaper(options.paper ?? {}), layers: [layer], activeLayerId: layer.id, strokes: [] };
-}
-
-// src/paint-editor/effect-paint.ts
-var EFFECT_STRIP_HEIGHT = 256;
-var EFFECT_MAP_REPEATS = ["repeat", "mirror", "clamp"];
-function effectPaintSize(p, canvas) {
-  return p.map ? { width: p.map.length, height: EFFECT_STRIP_HEIGHT } : { width: canvas.width, height: canvas.height };
-}
-function readEffectStrokeMap(raw) {
-  if (raw === void 0 || raw === null || raw.by === "canvas") return void 0;
-  const r = raw;
-  if (r.by !== "stroke") throw new Error(`map.by ${JSON.stringify(r.by)} is not a mapping; use "canvas" (fixed to the canvas) or "stroke" (along each stroke).`);
-  const length = r.length === void 0 ? 300 : Number(r.length);
-  if (!(Number.isFinite(length) && length >= 16 && length <= 4096)) throw new Error(`map.length ${JSON.stringify(r.length)} is out of range; use 16..4096 px of stroke per repeat.`);
-  const repeat = r.repeat === void 0 ? "repeat" : r.repeat;
-  if (!EFFECT_MAP_REPEATS.includes(repeat)) throw new Error(`map.repeat ${JSON.stringify(r.repeat)} is not a repeat mode; use ${EFFECT_MAP_REPEATS.join(", ")}.`);
-  return { by: "stroke", length: Math.round(length), repeat };
-}
-function stripIndex(img, map, dab, x, y) {
-  const ca = Math.cos(dab.direction);
-  const sa = Math.sin(dab.direction);
-  const dx = x - dab.x;
-  const dy = y - dab.y;
-  let u = (dab.travel + dx * ca - dy * sa) / map.length;
-  if (map.repeat === "clamp") u = Math.min(1, Math.max(0, u));
-  else if (map.repeat === "mirror") {
-    const m = (u % 2 + 2) % 2;
-    u = m > 1 ? 2 - m : m;
-  } else u = (u % 1 + 1) % 1;
-  const v = Math.min(1, Math.max(0, ((dx * sa + dy * ca) / Math.max(0.5, dab.radius) + 1) / 2));
-  const px = Math.min(img.width - 1, Math.floor(u * img.width));
-  const py = Math.min(img.height - 1, Math.floor(v * img.height));
-  return (py * img.width + px) * 4;
-}
-function effectPaintKey(p) {
-  return JSON.stringify({ type: "effect", effect: p.effect, provider: p.provider, values: p.values, time: p.time, ...p.map ? { map: p.map } : {} });
-}
-function isPaintEffectPaint(raw) {
-  return Boolean(raw) && typeof raw === "object" && raw.type === "effect";
-}
-function readMapLeniently(raw) {
-  try {
-    return readEffectStrokeMap(raw);
-  } catch {
-    return void 0;
-  }
-}
-function readPaintEffectPaint(raw) {
-  if (!isPaintEffectPaint(raw)) return null;
-  const r = raw;
-  if (typeof r.effect !== "string" || !r.effect || !r.values || typeof r.values !== "object" || Array.isArray(r.values)) return null;
-  return {
-    type: "effect",
-    effect: r.effect,
-    provider: typeof r.provider === "string" ? r.provider : "",
-    values: JSON.parse(JSON.stringify(r.values)),
-    time: typeof r.time === "number" && Number.isFinite(r.time) && r.time > 0 ? r.time : 0,
-    ...readMapLeniently(r.map) ? { map: readMapLeniently(r.map) } : {},
-    ...r.live === true ? { live: true } : {}
-  };
-}
-function sampleEffectField(img, rect, vals, field, dab) {
-  const { width, height, data } = img;
-  if (img.map && dab) {
-    for (let yy = 0, k = 0; yy < rect.height; yy++) {
-      for (let xx = 0; xx < rect.width; xx++, k++) {
-        const i = stripIndex(img, img.map, dab, rect.x + xx + 0.5, rect.y + yy + 0.5);
-        const f = k * 3;
-        const a = data[i + 3];
-        if (a < 255) vals[k] *= a / 255;
-        field[f] = data[i] / 255;
-        field[f + 1] = data[i + 1] / 255;
-        field[f + 2] = data[i + 2] / 255;
-      }
-    }
-    return;
-  }
-  for (let yy = 0, k = 0; yy < rect.height; yy++) {
-    const y = rect.y + yy;
-    const inY = y >= 0 && y < height;
-    for (let xx = 0; xx < rect.width; xx++, k++) {
-      const x = rect.x + xx;
-      const f = k * 3;
-      if (!inY || x < 0 || x >= width) {
-        vals[k] = 0;
-        field[f] = field[f + 1] = field[f + 2] = 0;
-        continue;
-      }
-      const i = (y * width + x) * 4;
-      const a = data[i + 3];
-      if (a < 255) vals[k] *= a / 255;
-      field[f] = data[i] / 255;
-      field[f + 1] = data[i + 1] / 255;
-      field[f + 2] = data[i + 2] / 255;
-    }
-  }
-}
-function sampleEffectAt(img, x, y, out, dab) {
-  if (img.map && dab) {
-    const i2 = stripIndex(img, img.map, dab, x, y);
-    out[0] = img.data[i2] / 255;
-    out[1] = img.data[i2 + 1] / 255;
-    out[2] = img.data[i2 + 2] / 255;
-    return img.data[i2 + 3] / 255;
-  }
-  const px = Math.floor(x);
-  const py = Math.floor(y);
-  if (px < 0 || py < 0 || px >= img.width || py >= img.height) return 0;
-  const i = (py * img.width + px) * 4;
-  out[0] = img.data[i] / 255;
-  out[1] = img.data[i + 1] / 255;
-  out[2] = img.data[i + 2] / 255;
-  return img.data[i + 3] / 255;
-}
-function effectDabField(img, rect, cov, centre2, mixed, field, steps = 0, dab = null) {
-  sampleEffectField(img, rect, cov, field, dab);
-  const d0 = mixed[0] - centre2[0];
-  const d1 = mixed[1] - centre2[1];
-  const d2 = mixed[2] - centre2[2];
-  const n = rect.width * rect.height;
-  for (let k = 0; k < n; k++) {
-    if (steps) cov[k] = Math.round(cov[k] * steps) / steps;
-    const f = k * 3;
-    field[f] = Math.min(1, Math.max(0, field[f] + d0));
-    field[f + 1] = Math.min(1, Math.max(0, field[f + 1] + d1));
-    field[f + 2] = Math.min(1, Math.max(0, field[f + 2] + d2));
-  }
-}
-
-// src/paint-editor/stamp-tip.ts
-var samplers = /* @__PURE__ */ new WeakMap();
-function stampSampler(ref2, art) {
-  let kind = null;
-  try {
-    kind = editorStampOf(ref2.includes(":") ? ref2 : `editor:${ref2}`);
-  } catch {
-    return null;
-  }
-  if (kind) {
-    const k = kind;
-    return (u, v, seed) => stampCoverage(k, u, v, seed);
-  }
-  const a = art?.(ref2);
-  if (!a || !(a.width > 0 && a.height > 0)) return null;
-  const hit = samplers.get(a);
-  if (hit) return hit;
-  const { width: w, height: h, data } = a;
-  const scale = Math.max(w, h) / 2;
-  const alpha = (x, y) => x < 0 || y < 0 || x >= w || y >= h ? 0 : data[(y * w + x) * 4 + 3] / 255;
-  const sampler = (u, v) => {
-    const x = u * scale + w / 2 - 0.5;
-    const y = v * scale + h / 2 - 0.5;
-    const x0 = Math.floor(x);
-    const y0 = Math.floor(y);
-    const fx = x - x0;
-    const fy = y - y0;
-    return (alpha(x0, y0) * (1 - fx) + alpha(x0 + 1, y0) * fx) * (1 - fy) + (alpha(x0, y0 + 1) * (1 - fx) + alpha(x0 + 1, y0 + 1) * fx) * fy;
-  };
-  samplers.set(a, sampler);
-  return sampler;
-}
-function stampDabRect(d) {
-  const r = Math.max(0.5, d.radius) * Math.SQRT2 + 1.5;
-  const x0 = Math.floor(d.x - r);
-  const y0 = Math.floor(d.y - r);
-  return { x: x0, y: y0, width: Math.ceil(d.x + r) - x0, height: Math.ceil(d.y + r) - y0 };
-}
-function rasterizeStampDab(d, sample, seed, rect, out) {
-  const w = rect.width;
-  const h = rect.height;
-  out.fill(0, 0, w * h);
-  const r = Math.max(0.5, d.radius);
-  const ro = Math.min(1, Math.max(0.05, d.roundness));
-  const sn = Math.sin(d.angle);
-  const cs = Math.cos(d.angle);
-  const ss = r < 6 ? 3 : 1;
-  for (let yy = 0; yy < h; yy++) {
-    for (let xx = 0; xx < w; xx++) {
-      let sum = 0;
-      for (let sy = 0; sy < ss; sy++) {
-        for (let sx = 0; sx < ss; sx++) {
-          const dx = rect.x + xx + (sx + 0.5) / ss - d.x;
-          const dy = rect.y + yy + (sy + 0.5) / ss - d.y;
-          const u = (dx * cs - dy * sn) / r;
-          const v = (dx * sn + dy * cs) / (r * ro);
-          if (u > -1.05 && u < 1.05 && v > -1.05 && v < 1.05) sum += sample(u, v, seed);
-        }
-      }
-      const val = sum / (ss * ss);
-      if (val > 0) out[yy * w + xx] = Math.min(1, val) * d.alpha;
-    }
-  }
-}
-function brushStickerRefs(brush) {
-  const refs = brush.engine === "sticker" ? [...brush.sticker.stamps] : brush.engine === "particle" ? [...brush.particle.dotTextures] : brush.engine === "dab" && brush.stamp ? [brush.stamp] : [];
-  return [...new Set(refs.filter((r) => r.includes(":") && !r.startsWith("editor:")))];
-}
-function sprayDroplets(d, spray, seed) {
-  const count = 1 + Math.round(spray.density * 31);
-  const key = d.index * 131 + Math.round(d.travel * 8);
-  const out = [];
-  for (let i = 0; i < count; i++) {
-    const n = key * 64 + i;
-    const a = rand01(seed, n, 61) * Math.PI * 2;
-    const rr = Math.sqrt(rand01(seed, n, 67)) * d.radius;
-    out.push({ ...d, x: d.x + Math.cos(a) * rr, y: d.y + Math.sin(a) * rr, radius: Math.max(0.5, d.radius * spray.size * (0.6 + 0.8 * rand01(seed, n, 71))), roundness: 1, angle: rand01(seed, n, 73) * Math.PI * 2 });
-  }
-  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 = class {
-  pos = null;
-  pressure = null;
-  a;
-  ap;
-  constructor(position, pressure) {
-    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;
-  }
-};
-var IDENTITY_COPY = { map: (p) => p, linear: [1, 0, 0, 1] };
-var FULL_SPEED = 2.5;
-var PenDabWalker = class {
-  constructor(brush, seed = 0, linear = [1, 0, 0, 1]) {
-    this.brush = brush;
-    this.seed = seed;
-    this.linear = linear;
-  }
-  brush;
-  seed;
-  linear;
-  last = null;
-  nextAt = 0;
-  pendingFirst = null;
-  index = 0;
-  dir = 0;
-  lastT = null;
-  firstT = null;
-  speed = null;
-  travelled = 0;
-  sample(p) {
-    const o = penOrientation(p);
-    let speed = null;
-    let time = null;
-    if (this.last) this.travelled += Math.hypot(p.x - this.last.x, p.y - this.last.y);
-    if (typeof p.t === "number" && Number.isFinite(p.t)) {
-      if (this.firstT === null) this.firstT = p.t;
-      time = p.t - this.firstT;
-      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 = 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,
-      travel: this.travelled,
-      time
-    };
-  }
-  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,
-      direction: this.dir,
-      index: i,
-      travel: s.travel,
-      time: s.time,
-      lean: s.lean,
-      speed: s.speed
-    };
-  }
-  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,
-          travel: a.travel + this.nextAt,
-          time: a.time !== null && s.time !== null ? lerp(a.time, s.time) : s.time
-        };
-        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;
-    }
-  }
-};
-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 = class {
-  constructor(brush, options) {
-    this.brush = brush;
-    this.options = options;
-    this.stamp = brush.stamp ? stampSampler(brush.stamp, options.stampArt) : null;
-    this.smoother = new PenSmoother(brush.tip.smoothing, brush.pressureSmoothing);
-    this.copies = options.copies?.length ? options.copies : [IDENTITY_COPY];
-    this.walkers = this.copies.map((c, i) => new PenDabWalker(brush, (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;
-  }
-  brush;
-  options;
-  coverage = new CoverageMap();
-  dabCount = 0;
-  smoother;
-  walkers;
-  copies;
-  depth;
-  buf = new Float32Array(0);
-  field = new Float32Array(0);
-  lastRaw = null;
-  lastFed = null;
-  /** The stamp tip's shape, or `null` for the round computed tip. */
-  stamp;
-  /** 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 spray = this.brush.spray;
-    const seed = this.options.seed ?? 0;
-    for (const d of dabs) {
-      if (!spray) {
-        this.mark(d, d, rects);
-        continue;
-      }
-      for (const drop of sprayDroplets(d, spray, seed)) this.mark(drop, d, rects);
-    }
-    return rects;
-  }
-  /** Lays one mark (a dab, or a spray droplet of dab `d`): the round tip or the stamp, the paper grain, effect paint. */
-  mark(m, d, rects) {
-    const hardness = this.brush.tip.hardness;
-    const grain = this.options.grain;
-    const rect = this.stamp ? stampDabRect(m) : dabRect(m, hardness);
-    const n = rect.width * rect.height;
-    if (this.buf.length < n) this.buf = new Float32Array(n);
-    const vals = this.buf.subarray(0, n);
-    if (this.stamp) rasterizeStampDab(m, this.stamp, d.index, rect, vals);
-    else rasterizeDab(m, 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);
-        }
-      }
-    }
-    let field = null;
-    if (this.options.effect) {
-      if (this.field.length < n * 3) this.field = new Float32Array(n * 3);
-      field = this.field.subarray(0, n * 3);
-      sampleEffectField(this.options.effect, rect, vals, field, d);
-    }
-    this.coverage.accumulate(rect, vals, m.opacity, null, field);
-    rects.push(rect);
-    this.dabCount++;
-  }
-};
-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/dab-stroke.ts
-var GRADIENT_STEPS = 32;
-function multiColorPalette(mc, color, secondary) {
-  if (mc.colors.length >= 2) {
-    return mc.colors.map((h) => {
-      const n = parseInt(h.slice(1), 16);
-      return [(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255];
-    });
-  }
-  return [[...color], [...secondary]];
-}
-function soften(f, softness) {
-  if (softness >= 1) return f;
-  const w = Math.max(1e-3, softness);
-  return Math.min(1, Math.max(0, (f - 0.5) / w + 0.5));
-}
-function mixRgb(a, b, t, mixing) {
-  if (t <= 0) return [...a];
-  if (t >= 1) return [...b];
-  if (mixing === "pigment") {
-    const o = [0, 0, 0];
-    const q = (v) => Math.round(Math.min(1, Math.max(0, v)) * 255);
-    mixPigment8(q(a[0]), q(a[1]), q(a[2]), q(b[0]), q(b[1]), q(b[2]), t, o);
-    return [o[0], o[1], o[2]];
-  }
-  return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];
-}
-function multiColorGradient(palette, softness, mixing) {
-  const n = palette.length;
-  const out = [];
-  for (let j = 0; j < GRADIENT_STEPS; j++) {
-    const f = j / (GRADIENT_STEPS - 1) * (n - 1);
-    const i = Math.min(n - 2, Math.floor(f));
-    out.push(mixRgb(palette[i], palette[i + 1], soften(f - i, softness), mixing));
-  }
-  return out;
-}
-function multiColorForDab(mc, palette, index, seed, mixing) {
-  const n = palette.length;
-  if (mc.order === "random") {
-    const run = Math.floor(index / mc.length);
-    return [...palette[Math.min(n - 1, Math.floor(rand01(seed, run, 11) * n))]];
-  }
-  const f = index / mc.length % n;
-  const i = Math.floor(f);
-  return mixRgb(palette[i], palette[(i + 1) % n], soften(f - i, mc.softness), mixing);
-}
-var PaintDabStroke = class {
-  constructor(brush, options) {
-    this.brush = brush;
-    this.options = options;
-    this.stamp = brush.engine === "dab" && brush.stamp ? stampSampler(brush.stamp, options.stampArt) : null;
-    this.smoother = new PenSmoother(brush.tip.smoothing, brush.pressureSmoothing);
-    this.copies = options.copies?.length ? options.copies : [IDENTITY_COPY];
-    const exchanging = brush.engine === "mixer" || brush.engine === "dab";
-    const rates = brush.engine === "mixer" ? mixerRates(brush.mixer) : exchangeRates(brush.behavior.pickup, brush.behavior.mix, 1, brush.behavior.mixing);
-    this.mixing = brush.engine === "mixer" ? brush.mixer.mixing : brush.behavior.mixing;
-    this.states = this.copies.map((c, i) => ({
-      walker: new PenDabWalker(brush, (options.seed ?? 0) + i * 7919 | 0, c.linear),
-      exchange: exchanging ? new PaintExchange(rates, options.load) : null,
-      smudge: brush.engine === "smudge" ? new SmudgeTip(brush.smudge, brush.tip.size * (1 + brush.dynamics.tiltSize * 1.5)) : null
-    }));
-    this.medium = new TileMedium(options.target, brush.engine === "dab" ? { blend: brush.tip.blend } : {});
-    this.depth = options.grain && !options.grain.flat ? Math.min(1, Math.max(0, options.paperDepth * brush.grain)) : 0;
-    this.coverage = brush.engine === "dab" ? new CoverageMap() : null;
-    this.sampler = exchanging && options.paint ? new PaintGradientSampler(options.paint, options.seed ?? 0) : null;
-    const table = this.sampler?.acrossTip ? this.sampler.tipTable(GRADIENT_STEPS) : null;
-    this.gradient = table ? table.map((e) => e.rgb) : null;
-    this.gradientAlpha = table && table.some((e) => e.alpha < 1) ? table.map((e) => e.alpha) : null;
-    this.scratch = brush.engine === "blender" ? createBlenderScratch() : null;
-  }
-  brush;
-  options;
-  dabCount = 0;
-  smoother;
-  copies;
-  states;
-  medium;
-  depth;
-  coverage;
-  sampler;
-  sample = { rgb: [0, 0, 0], alpha: 1 };
-  gradient;
-  /** Opacity across the tip (`across-tip` gradients with opacity stops), or `null`. */
-  gradientAlpha;
-  alphaCov = new Float32Array(0);
-  fieldLut = [];
-  scratch;
-  mixing;
-  tip = new Float32Array(0);
-  cov = new Float32Array(0);
-  field = new Float32Array(0);
-  paint = [0, 0, 0];
-  lastRaw = null;
-  lastFed = null;
-  /** The stamp tip's shape (dab brushes), or `null` for the round computed tip. */
-  stamp;
-  /** What copy 0's brush carries after the dabs so far (mixer and wet-capable dab brushes). */
-  get load() {
-    return this.states[0].exchange?.load ?? null;
-  }
-  push(points) {
-    const rects = [];
-    for (const raw of points) {
-      this.lastRaw = raw;
-      const p = this.smoother.push(raw);
-      this.lastFed = p;
-      this.copies.forEach((c, i) => {
-        const dabs = [];
-        this.states[i].walker.push(c.map(p), dabs);
-        this.paintDabs(i, dabs, rects);
-      });
-    }
-    return rects;
-  }
-  /** Ends the stroke: the smoothed path catches up with the last raw sample; a tap paints one dab. */
-  finish() {
-    const rects = [];
-    const raw = this.lastRaw;
-    const fed = this.lastFed;
-    this.copies.forEach((c, i) => {
-      const dabs = [];
-      if (raw && fed && (raw.x !== fed.x || raw.y !== fed.y)) this.states[i].walker.push(c.map({ ...raw, pressure: fed.pressure }), dabs);
-      this.states[i].walker.finish(dabs);
-      this.paintDabs(i, dabs, rects);
-    });
-    return rects;
-  }
-  paintDabs(copy, dabs, rects) {
-    const spray = this.brush.engine === "dab" ? this.brush.spray : null;
-    for (const d of spray ? dabs.flatMap((dab) => sprayDroplets(dab, spray, (this.options.seed ?? 0) + copy * 7919)) : dabs) {
-      const rect = this.stamp ? stampDabRect(d) : dabRect(d, this.brush.tip.hardness);
-      if (rect.width <= 0 || rect.height <= 0) continue;
-      this.dab(copy, d, rect);
-      rects.push(rect);
-      this.dabCount++;
-    }
-  }
-  /** The tip's pure coverage (`tip`) and, with grain, what the paper catches of it (`cov`). */
-  rasterize(d, rect) {
-    const n = rect.width * rect.height;
-    if (this.tip.length < n) {
-      this.tip = new Float32Array(n);
-      this.cov = new Float32Array(n);
-    }
-    const tip = this.tip.subarray(0, n);
-    tip.fill(0);
-    if (this.stamp) rasterizeStampDab({ ...d, alpha: 1 }, this.stamp, d.index, rect, tip);
-    else rasterizeDab({ ...d, alpha: 1 }, this.brush.tip.hardness, rect, tip);
-    if (!(this.depth > 0 && this.options.grain)) return { tip, cov: tip };
-    const cov = this.cov.subarray(0, n);
-    const grain = this.options.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++) cov[k] = tip[k] > 0 ? tip[k] * grainCatch(grain.at(rect.x + xx + 0.5, y), this.depth, d.pressure) : 0;
-    }
-    return { tip, cov };
-  }
-  dab(copy, d, rect) {
-    const brush = this.brush;
-    const { tip, cov } = this.rasterize(d, rect);
-    const st = this.states[copy];
-    if (brush.engine === "blender") {
-      blenderDab(this.medium, rect, cov, d.opacity * d.alpha * brush.tip.opacity, d.radius, brush.blender, this.scratch);
-      return;
-    }
-    if (brush.engine === "smudge") {
-      st.smudge.dab(this.medium, { x: d.x, y: d.y, radius: d.radius, opacity: d.opacity * d.alpha * brush.tip.opacity }, rect, cov);
-      return;
-    }
-    const ex = st.exchange;
-    ex.pickUp(this.medium.sample(rect, tip));
-    let flow = 1;
-    if (this.options.effect) {
-      const rgb = [0, 0, 0];
-      flow = sampleEffectAt(this.options.effect, d.x, d.y, rgb, d);
-      ex.setReservoirColor(rgb[0], rgb[1], rgb[2]);
-    } else if (this.sampler && !this.gradient) {
-      const g = this.sampler.dab(d, this.sample);
-      ex.setReservoirColor(g.rgb[0], g.rgb[1], g.rgb[2]);
-      flow = g.alpha;
-    }
-    let field = null;
-    let total;
-    let laid = cov;
-    if (this.gradient) {
-      total = this.tipField(ex, d, rect);
-      field = this.field;
-      if (this.gradientAlpha) laid = this.tipAlpha(d, rect, cov);
-    } else total = ex.paint(this.paint);
-    if (total > 0 && flow > 0) {
-      if (this.coverage) this.depositWithCeiling(d, rect, laid, field, ex, flow);
-      else {
-        const dep = Math.min(1, total) * d.alpha * brush.tip.opacity * d.opacity * flow;
-        if (dep > 0) this.medium.deposit(rect, laid, dep, this.paint, ex.paintPigment, field);
-      }
-    }
-    ex.drain();
-  }
-  /** Fills `this.field` with the tip gradient (mixed with the carried paint) per pixel; returns the paint weight. */
-  tipField(ex, d, rect) {
-    const g = this.gradient;
-    const lut = this.fieldLut;
-    let total = 0;
-    for (let j = 0; j < g.length; j++) {
-      ex.setReservoirColor(g[j][0], g[j][1], g[j][2]);
-      const out = lut[j] ?? [0, 0, 0];
-      total = ex.paint(out);
-      lut[j] = out;
-    }
-    const n = rect.width * rect.height;
-    if (this.field.length < n * 3) this.field = new Float32Array(n * 3);
-    const f = this.field;
-    const nx = Math.sin(d.direction);
-    const ny = Math.cos(d.direction);
-    const r = Math.max(0.5, d.radius);
-    const last = g.length - 1;
-    for (let yy = 0, k = 0; yy < rect.height; yy++) {
-      const py = rect.y + yy + 0.5 - d.y;
-      for (let xx = 0; xx < rect.width; xx++, k++) {
-        const u = ((rect.x + xx + 0.5 - d.x) * nx + py * ny) / r;
-        const j = Math.min(last, Math.max(0, Math.round((u + 1) / 2 * last)));
-        f[k * 3] = lut[j][0];
-        f[k * 3 + 1] = lut[j][1];
-        f[k * 3 + 2] = lut[j][2];
-      }
-    }
-    return total;
-  }
-  /** `cov` scaled by the gradient's opacity across the tip. */
-  tipAlpha(d, rect, cov) {
-    const a = this.gradientAlpha;
-    const n = rect.width * rect.height;
-    if (this.alphaCov.length < n) this.alphaCov = new Float32Array(n);
-    const out = this.alphaCov.subarray(0, n);
-    const nx = Math.sin(d.direction);
-    const ny = Math.cos(d.direction);
-    const r = Math.max(0.5, d.radius);
-    const last = a.length - 1;
-    for (let yy = 0, k = 0; yy < rect.height; yy++) {
-      const py = rect.y + yy + 0.5 - d.y;
-      for (let xx = 0; xx < rect.width; xx++, k++) {
-        const u = ((rect.x + xx + 0.5 - d.x) * nx + py * ny) / r;
-        out[k] = cov[k] * a[Math.min(last, Math.max(0, Math.round((u + 1) / 2 * last)))];
-      }
-    }
-    return out;
-  }
-  /** A dab brush's deposit: only what this dab adds to the stroke's coverage, under its opacity ceiling. */
-  depositWithCeiling(d, rect, cov, field, ex, flow = 1) {
-    const map = this.coverage;
-    const n = rect.width * rect.height;
-    const before = new Float32Array(n);
-    const vals = new Float32Array(n);
-    for (let yy = 0, k = 0; yy < rect.height; yy++) {
-      for (let xx = 0; xx < rect.width; xx++, k++) {
-        if (cov[k] <= 0) continue;
-        before[k] = map.get(rect.x + xx, rect.y + yy);
-        vals[k] = cov[k] * d.alpha * flow;
-      }
-    }
-    map.accumulate(rect, vals, d.opacity);
-    const o = this.brush.tip.opacity;
-    for (let yy = 0, k = 0; yy < rect.height; yy++) {
-      for (let xx = 0; xx < rect.width; xx++, k++) {
-        if (cov[k] <= 0) {
-          vals[k] = 0;
-          continue;
-        }
-        const c0 = before[k] * o;
-        const c1 = map.get(rect.x + xx, rect.y + yy) * o;
-        vals[k] = c1 > c0 && c0 < 1 ? (c1 - c0) / (1 - c0) : 0;
-      }
-    }
-    this.medium.deposit(rect, vals, 1, this.paint, ex.paintPigment, field);
+} from "../chunk-HVVR5PZW.js";
+import "../chunk-QGHEDC7B.js";
+import "../chunk-SIFAIGB3.js";
+import "../chunk-CIQIM2IP.js";
+import "../chunk-VDGBHYC7.js";
+import {
+  EDITOR_DOCUMENT_FORMAT,
+  createEditorAssetRegistry,
+  defineEditorDocument,
+  toEditorDocumentFile
+} from "../chunk-XBQX76CT.js";
+import "../chunk-HF5QZS7Z.js";
+import "../chunk-M2TPMYJE.js";
+import "../chunk-2WPNAGHI.js";
+import {
+  HARMONY_KINDS,
+  colorHarmony,
+  hueToWheel,
+  wheelToHue
+} from "../chunk-2EUW2XZX.js";
+import "../chunk-E2V5DA3W.js";
+import "../chunk-VR6OGHU5.js";
+import "../chunk-JC2SHA4A.js";
+import {
+  linearToSrgb,
+  oklabToOklch,
+  oklabToRgb,
+  oklchToOklab,
+  rgbToOklab,
+  srgbToLinear
+} from "../chunk-MHLU6GRJ.js";
+import "../chunk-6ONMQ6WF.js";
+
+// 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: emptySurface(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: options.width ?? 2048, height: options.height ?? 1536, dpi: options.dpi });
+  const layer = createPaintLayer("Layer 1");
+  return { canvas, paper: normalizePaper(options.paper ?? {}), layers: [layer], activeLayerId: layer.id, strokes: [] };
+}
 
 // src/paint-editor/thick.ts
 var DEFAULT_LIGHTING = { azimuth: 315, elevation: 40, relief: 0.7 };
@@ -3937,696 +3044,6 @@ function downloadBytes(bytes, fileName, mimeType) {
   setTimeout(() => g.URL.revokeObjectURL(url), 1e3);
 }
 
-// src/paint-editor/wet.ts
-var STROKE_WATER = 0.9;
-var STROKE_MASS = PIGMENT_UNIT * 2.5;
-var STROKE_LIGHT = 1.5;
-var COVERAGE_STEPS = 4096;
-function union2(a, b) {
-  if (!a) return { ...b };
-  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 };
-}
-function wetPaperInput(paper) {
-  const grain = new PaperGrain(paper, "wet");
-  const flat = grain.flat;
-  return {
-    absorption: paper.absorption,
-    permeability: paper.permeability,
-    roughness: flat ? 0 : paper.roughness,
-    color: hexToRgb8(paper.color),
-    heightAt: flat ? () => 0.5 : (x, y) => grain.at(x, y)
-  };
-}
-var WetStrokeDriver = class {
-  constructor(init) {
-    this.init = init;
-    const brush = init.brush;
-    this.smoother = new PenSmoother(brush.tip.smoothing, brush.pressureSmoothing);
-    const copies = init.copies.length ? init.copies : [IDENTITY_COPY];
-    const wet = brush.wet;
-    const spacing = Math.max(0.02, brush.tip.spacing);
-    const perDab = Math.min(1, spacing * 1.2);
-    const thin = wet.thinner;
-    this.medium = new WetMedium(init.world, init.laneId, {
-      water: STROKE_WATER * Math.min(1, wet.water * (1 + thin)) * perDab,
-      mass: STROKE_MASS * wet.pigment * (1 - 0.6 * thin) * perDab,
-      body: wet.body * (1 - thin),
-      light: 0
-    });
-    this.lightBase = wet.tool === "paint" ? STROKE_LIGHT * brush.light.amount * (1 - 0.6 * thin) * perDab : 0;
-    const rates = exchangeRates(brush.behavior.pickup, brush.behavior.mix, wet.load, brush.behavior.mixing);
-    this.states = copies.map((c, i) => ({
-      walker: new PenDabWalker(brush, init.seed + i * 7919 | 0, c.linear),
-      exchange: wet.tool === "paint" ? new PaintExchange(rates, init.load) : null,
-      last: null
-    }));
-    this.copies = copies;
-    this.depth = init.grain && !init.grain.flat ? Math.min(1, Math.max(0, init.paperDepth * brush.grain)) : 0;
-    const g = init.paint ?? null;
-    this.sampler = g ? new PaintGradientSampler(g.map.by === "across-tip" ? { ...g, map: { by: "distance", length: 300, repeat: "mirror" } } : g, init.seed) : null;
-  }
-  init;
-  dabCount = 0;
-  bounds = null;
-  /** The world's clock at which each raw point was applied (recorded with the stroke). */
-  steps = [];
-  smoother;
-  states;
-  medium;
-  queue = [];
-  finishing = false;
-  finished = false;
-  lastRaw = null;
-  lastFed = null;
-  tip = new Float32Array(0);
-  cov = new Float32Array(0);
-  paint = [0, 0, 0];
-  centre = [0, 0, 0];
-  depth;
-  lightBase;
-  sampler;
-  sample = { rgb: [0, 0, 0], alpha: 1 };
-  copies;
-  /** What copy 0's brush carries after the dabs so far. */
-  get load() {
-    return this.states[0].exchange?.load ?? null;
-  }
-  /** Whether every point (and the end) has been applied. */
-  get done() {
-    return this.finished;
-  }
-  /** Adds raw points; applies them now unless a batch is running. Returns where pixels changed. */
-  push(points) {
-    for (const p of points) this.queue.push(p);
-    return this.flush();
-  }
-  /** Asks for the end; it happens now unless a batch is running (then at the next `flush`). */
-  finish() {
-    this.finishing = true;
-    return this.flush();
-  }
-  /** Applies waiting points (and the end, when asked) if the world is between batches. */
-  flush() {
-    const rects = [];
-    if (this.init.world.busy || this.finished) return rects;
-    while (this.queue.length) {
-      const raw = this.queue.shift();
-      this.steps.push(this.init.world.clock);
-      this.lastRaw = raw;
-      const p = this.smoother.push(raw);
-      this.lastFed = p;
-      this.copies.forEach((c, i) => {
-        const dabs = [];
-        this.states[i].walker.push(c.map(p), dabs);
-        this.applyDabs(i, dabs, rects);
-      });
-    }
-    if (this.finishing) {
-      const raw = this.lastRaw;
-      const fed = this.lastFed;
-      this.copies.forEach((c, i) => {
-        const dabs = [];
-        if (raw && fed && (raw.x !== fed.x || raw.y !== fed.y)) this.states[i].walker.push(c.map({ ...raw, pressure: fed.pressure }), dabs);
-        this.states[i].walker.finish(dabs);
-        this.applyDabs(i, dabs, rects);
-      });
-      this.finished = true;
-    }
-    for (const r of rects) this.bounds = union2(this.bounds, r);
-    return rects;
-  }
-  applyDabs(copy, dabs, rects) {
-    for (const d of dabs) {
-      const rect = dabRect(d, this.init.brush.tip.hardness);
-      if (rect.width <= 0 || rect.height <= 0) continue;
-      this.dab(copy, d, rect);
-      rects.push(rect);
-      this.dabCount++;
-    }
-  }
-  /** The tip's coverage over `rect`, with the grain, quantised. */
-  coverage(d, rect) {
-    const n = rect.width * rect.height;
-    if (this.tip.length < n) {
-      this.tip = new Float32Array(n);
-      this.cov = new Float32Array(n);
-    }
-    const tip = this.tip.subarray(0, n);
-    const cov = this.cov.subarray(0, n);
-    tip.fill(0);
-    rasterizeDab({ ...d, alpha: 1 }, this.init.brush.tip.hardness, rect, tip);
-    const grain = this.depth > 0 ? this.init.grain : null;
-    const mask = this.init.mask;
-    for (let yy = 0, k = 0; yy < rect.height; yy++) {
-      for (let xx = 0; xx < rect.width; xx++, k++) {
-        if (mask && tip[k] > 0) {
-          const mx = rect.x + xx;
-          const my = rect.y + yy;
-          tip[k] *= mx >= 0 && my >= 0 && mx < mask.width && my < mask.height ? mask.data[my * mask.width + mx] / 255 : 0;
-        }
-        let v = tip[k];
-        if (v > 0 && grain) v *= grainCatch(grain.at(rect.x + xx + 0.5, rect.y + yy + 0.5), this.depth, d.pressure);
-        tip[k] = Math.round(tip[k] * COVERAGE_STEPS) / COVERAGE_STEPS;
-        cov[k] = Math.round(v * COVERAGE_STEPS) / COVERAGE_STEPS;
-      }
-    }
-    return { tip, cov };
-  }
-  dab(copy, d, rect) {
-    const { world, laneId, brush } = this.init;
-    const wet = brush.wet;
-    const st = this.states[copy];
-    const { tip, cov } = this.coverage(d, rect);
-    const k = Math.round(Math.min(1, d.alpha * d.opacity * brush.tip.opacity) * COVERAGE_STEPS) / COVERAGE_STEPS;
-    if (!(k > 0)) return;
-    switch (wet.tool) {
-      case "paint": {
-        const ex = st.exchange;
-        this.medium.options.light = this.lightBase * (brush.light.pressure ? d.pressure : 1);
-        let flow = 1;
-        const effect = this.init.effect;
-        if (effect) {
-          sampleEffectAt(effect, d.x, d.y, this.centre, d);
-          ex.setReservoirColor(this.centre[0], this.centre[1], this.centre[2]);
-        } else if (this.sampler) {
-          const g = this.sampler.dab(d, this.sample);
-          ex.setReservoirColor(g.rgb[0], g.rgb[1], g.rgb[2]);
-          flow = g.alpha;
-        }
-        ex.pickUp(this.medium.sample(rect, tip));
-        const total = ex.paint(this.paint);
-        if (total > 0 && flow > 0 && effect) {
-          const ec = cov.slice();
-          const field = new Float32Array(ec.length * 3);
-          effectDabField(effect, rect, ec, this.centre, this.paint, field, COVERAGE_STEPS, d);
-          this.medium.deposit(rect, ec, Math.min(1, total) * k, this.paint, null, field);
-        } else if (total > 0 && flow > 0) this.medium.deposit(rect, cov, Math.min(1, total) * k * flow, this.paint, null);
-        else world.paint(laneId, rect, cov, this.medium.options.water * k, null);
-        ex.drain();
-        if (wet.rewet > 0) world.rewet(laneId, rect, cov, wet.rewet * k * 0.15, this.init.paperColor);
-        break;
-      }
-      case "water": {
-        world.paint(laneId, rect, cov, this.medium.options.water * k * (wet.water > 0 ? 1 : 0), null);
-        if (wet.rewet > 0) world.rewet(laneId, rect, cov, wet.rewet * k * 0.15, this.init.paperColor);
-        break;
-      }
-      case "dry":
-        world.remove(laneId, rect, cov, wet.strength * 0.35 * k, 0, 0, wet.strength * 0.35 * k);
-        break;
-      case "blow": {
-        const s = wet.strength * 0.08 * k;
-        world.push(laneId, rect, cov, Math.cos(d.direction) * s, -Math.sin(d.direction) * s);
-        break;
-      }
-      case "blend":
-        world.blend(laneId, rect, cov, wet.strength * k);
-        break;
-      case "smudge": {
-        if (st.last) world.drag(laneId, rect, cov, d.x - st.last.x, d.y - st.last.y, wet.strength * k);
-        break;
-      }
-      case "blot":
-        world.remove(laneId, rect, cov, wet.strength * 0.8 * k, wet.strength * 0.6 * k, wet.strength * 0.15 * k, wet.strength * 0.5 * k);
-        break;
-    }
-    st.last = d;
-  }
-};
-var WET_MEDIUM_PARAMS = {
-  watercolor: {},
-  gouache: { viscosity: 0.45, evaporation: 0.1, edgeDarkening: 0.15, granulation: 0.1, bloom: 0.1, bleed: 0.15, pickup: 0.5, pigmentWeight: 0.5 },
-  oil: { viscosity: 0.95, evaporation: 0.03, edgeDarkening: 0, granulation: 0, bloom: 0, bleed: 0.08, pickup: 0.6, fixture: 0.02, pigmentWeight: 0.8 }
-};
-var WET_GPU_MODES = ["auto", "off"];
-var GPU_LEAD = 16;
-var DISPLAY_TILES_PER_TICK = 24;
-var PaintWetLayers = class {
-  constructor(host, options = {}) {
-    this.host = host;
-    this.options = options;
-    this.speed = Math.max(1, Math.min(2e3, options.speed ?? 120));
-    this.undoMemory = Math.max(0, options.undoMemory ?? 512 * 1024 * 1024);
-    this.gpuMode = options.gpu === "off" ? "off" : "auto";
-    this.gpuMinTiles = Math.max(1, Math.floor(options.gpuMinTiles ?? 16));
-  }
-  host;
-  options;
-  world = null;
-  tilt = { ...FLAT };
-  settings = /* @__PURE__ */ new Map();
-  paused = false;
-  /** Wet strokes dry as soon as they end (one undo step with the stroke). */
-  instantDry = false;
-  speed;
-  overlay = false;
-  undoMemory;
-  /** The live wet stroke, if any. */
-  driver = null;
-  lastTick = null;
-  ticking = null;
-  stepsOwed = 0;
-  displaying = null;
-  leadAt = 0;
-  gpuMode;
-  gpuMinTiles;
-  gpu = null;
-  gpuSupport = null;
-  gpuStarting = null;
-  // --- Engine B ------------------------------------------------------------------
-  /** Starts the GPU engine for the world (once; it may turn out unavailable). */
-  startGpu() {
-    if (this.gpuMode === "off" || this.gpu || this.gpuStarting || this.gpuSupport) return;
-    const provider = this.options.gpuProvider === void 0 ? findWebGpu() : this.options.gpuProvider;
-    this.gpuStarting = createWetGpuEngine(provider).then(({ engine, support }) => {
-      this.gpuSupport = support;
-      if (!engine) return;
-      if (this.gpuMode === "off" || !this.world) {
-        engine.destroy();
-        this.gpuSupport = null;
-        return;
-      }
-      this.gpu = engine;
-      this.world.gpuMinTiles = this.gpuMinTiles;
-      this.world.attachGpu(engine);
-    }).finally(() => {
-      this.gpuStarting = null;
-      this.host.changed();
-    });
-  }
-  /** Resolves once the GPU engine has started or turned out unavailable. */
-  async gpuReady() {
-    if (this.gpuStarting) await this.gpuStarting;
-    return this.engineInfo();
-  }
-  /** `auto`: use the GPU for large wet areas when there is one; `off`: the CPU only. */
-  setGpu(mode, minTiles) {
-    if (minTiles !== void 0) {
-      this.gpuMinTiles = Math.max(1, Math.floor(minTiles));
-      if (this.world) this.world.gpuMinTiles = this.gpuMinTiles;
-    }
-    if (mode === this.gpuMode) return this.engineInfo();
-    this.gpuMode = mode;
-    if (mode === "off") {
-      this.world?.attachGpu(null);
-      this.gpu?.destroy();
-      this.gpu = null;
-      this.gpuSupport = null;
-    } else if (this.world) this.startGpu();
-    return this.engineInfo();
-  }
-  engineInfo() {
-    const w = this.world;
-    const base = { mode: this.gpuMode, adapter: this.gpuSupport?.adapter ?? null, maxTiles: this.gpuSupport?.maxSlots ?? 0, minTiles: this.gpuMinTiles, activeTiles: w?.activeTiles() ?? 0, cpu: this.backend() };
-    if (this.gpuMode === "off") return { ...base, state: "off", reason: "Forced to the CPU." };
-    if (this.gpuStarting) return { ...base, state: "starting", reason: null };
-    if (w?.gpuError) return { ...base, state: "failed", reason: w.gpuError };
-    if (this.gpuSupport && !this.gpuSupport.supported) return { ...base, state: "unavailable", reason: this.gpuSupport.reason };
-    if (!this.gpu) return { ...base, state: "not-started", reason: "Starts with the first wet stroke." };
-    if (w?.gpuActive) return { ...base, state: "active", reason: null };
-    return { ...base, state: "standby", reason: `The GPU takes over at ${this.gpuMinTiles} wet tiles (256 px).` };
-  }
-  /** The world (made on first use, at the canvas size). */
-  ensureWorld() {
-    const { width, height } = this.host.canvas();
-    if (this.world && (this.world.width !== width || this.world.height !== height)) {
-      if (this.world.laneIds().length) throw new Error("The wet world is the wrong size; dry the paint before resizing the canvas.");
-      this.dropWorld();
-    }
-    if (!this.world) this.world = this.makeWorld(width, height, this.host.paper());
-    return this.world;
-  }
-  makeWorld(width, height, paper) {
-    const world = new WetWorld(width, height, wetPaperInput(paper), { kernel: this.options.kernel, threads: this.options.threads });
-    world.setTilt(this.tilt);
-    world.gpuMinTiles = this.gpuMinTiles;
-    if (this.gpu) world.attachGpu(this.gpu);
-    else this.startGpu();
-    return world;
-  }
-  /**
-   * Whether `extend` can keep the wet paint when the canvas grows by `left` / `top` on those
-   * sides: the shift has to be whole wet tiles (256 px), and no wet stroke may be live.
-   */
-  canExtend(left, top) {
-    return left % WET_TILE === 0 && top % WET_TILE === 0 && !this.driver;
-  }
-  /**
-   * Keeps the wet paint while the canvas grows to `width`×`height` by `left` / `top` on those
-   * sides (`canExtend` must hold): the world is made again at the new size with every wet layer
-   * moved by (left, top), still wet, its base and flow map with it; `paper` is the new
-   * document's paper (its grain moved with the paint). Wet settings' flow centres move too. The
-   * caller shows the layers again (`syncDisplays`) once the document is the new size.
-   */
-  extend(width, height, left, top, paper) {
-    if (!this.canExtend(left, top)) throw new Error("Wet paint only moves by whole 256 px tiles, between strokes.");
-    for (const [id, s] of this.settings) if (s.flow.center) this.settings.set(id, { ...s, flow: { ...s.flow, center: { x: s.flow.center.x + left, y: s.flow.center.y + top } } });
-    const old = this.world;
-    const snap = old?.laneIds().length ? old.snapshot() : null;
-    this.dropWorld();
-    this.lastTick = null;
-    this.stepsOwed = 0;
-    if (!old || !snap) return;
-    const moved = moveWetSnapshot(snap, old, { width, height }, left, top, (l) => {
-      const flow = this.settings.get(l.id)?.flow;
-      return {
-        base: translateSurface(l.base, left, top),
-        ...l.light ? { light: translateSurface(l.light, left, top) } : {},
-        flow: l.flow && flow && flow.kind !== "none" ? flowField(flow, width, height) : l.flow
-      };
-    });
-    this.world = this.makeWorld(width, height, paper);
-    this.world.restore(moved);
-  }
-  /** Whether any layer (or `layerId`) has wet paint. */
-  isWet(layerId) {
-    const w = this.world;
-    if (!w) return false;
-    if (layerId !== void 0) return w.hasLane(layerId) && w.isActive(layerId);
-    return w.laneIds().some((id) => w.isActive(id));
-  }
-  /** Layers holding a wet layer (wet or drying). */
-  wetLayerIds() {
-    return this.world?.laneIds() ?? [];
-  }
-  /** Whether a batch is running (edits wait). */
-  get busy() {
-    return Boolean(this.world?.busy);
-  }
-  /** Resolves when no batch is running. */
-  async idle() {
-    while (this.ticking) await this.ticking;
-  }
-  settingsOf(layerId, medium = "watercolor") {
-    let s = this.settings.get(layerId);
-    if (!s) {
-      s = { params: normalizeWetParams(WET_MEDIUM_PARAMS[medium], DEFAULT_WET_PARAMS), flow: { ...DEFAULT_FLOW } };
-      this.settings.set(layerId, s);
-    }
-    return s;
-  }
-  /** Puts a layer in the world (its current pixels become the base under the wet paint). */
-  ensureLane(layerId, medium) {
-    const w = this.ensureWorld();
-    if (!w.hasLane(layerId)) {
-      const base = this.host.layerSurface(layerId) ?? new TiledSurface(4, /* @__PURE__ */ new Map(), 0);
-      const s = this.settingsOf(layerId, medium);
-      w.ensureLane(layerId, { params: s.params, base, light: this.host.layerLight(layerId) });
-      const { width, height } = this.host.canvas();
-      if (s.flow.kind !== "none") w.setFlow(layerId, flowField(s.flow, width, height), s.flow.strength);
-    }
-    return w;
-  }
-  setParams(layerId, update) {
-    const s = this.settingsOf(layerId);
-    s.params = normalizeWetParams(update, s.params);
-    if (this.world?.hasLane(layerId)) this.world.setParams(layerId, s.params);
-    return { ...s.params };
-  }
-  setFlow(layerId, update) {
-    const s = this.settingsOf(layerId);
-    s.flow = normalizeFlow(update, s.flow);
-    if (this.world?.hasLane(layerId)) {
-      const { width, height } = this.host.canvas();
-      this.world.setFlow(layerId, flowField(s.flow, width, height), s.flow.strength);
-    }
-    return { ...s.flow };
-  }
-  setTilt(update) {
-    this.tilt = normalizeTilt(update, this.tilt);
-    this.world?.setTilt(this.tilt);
-    return { ...this.tilt };
-  }
-  /** The paper changed. */
-  paperChanged() {
-    this.world?.setPaper(wetPaperInput(this.host.paper()));
-  }
-  /** A layer as tools describe it. */
-  info(layerId) {
-    const s = this.settingsOf(layerId);
-    const st = this.world?.hasLane(layerId) ? this.world.stats(layerId) : null;
-    return {
-      layerId,
-      wet: Boolean(st && st.wetCells > 0),
-      wetCells: st?.wetCells ?? 0,
-      wetBounds: st?.wetBounds ?? null,
-      activeTiles: st?.activeTiles ?? 0,
-      params: { ...s.params },
-      flow: { ...s.flow }
-    };
-  }
-  backend() {
-    return this.world?.backend() ?? null;
-  }
-  /** Shows the current wet pixels (at most `maxTiles` reshaded per layer). */
-  syncDisplays(maxTiles = Infinity) {
-    const w = this.world;
-    if (!w) return [];
-    const surfaces = /* @__PURE__ */ new Map();
-    const rects = [];
-    for (const id of w.laneIds()) {
-      const d = w.display(id, maxTiles);
-      if (this.host.layerSurface(id) !== d.surface) surfaces.set(id, d.surface);
-      rects.push(...d.changed);
-    }
-    this.syncLights();
-    if (surfaces.size) this.host.updateSurfaces(surfaces, rects);
-    return rects;
-  }
-  /** Like `syncDisplays`, shading on the GPU when Engine B is active (all stale tiles at once). */
-  async syncDisplaysGpu(maxCpuTiles, lead = false) {
-    const w = this.world;
-    if (!w) return [];
-    const surfaces = /* @__PURE__ */ new Map();
-    const rects = [];
-    for (const id of w.laneIds()) {
-      const d = await w.displayGpu(id, maxCpuTiles, lead);
-      if (!w.hasLane(id)) continue;
-      if (this.host.layerSurface(id) !== d.surface) surfaces.set(id, d.surface);
-      rects.push(...d.changed);
-    }
-    this.syncLights();
-    if (surfaces.size) this.host.updateSurfaces(surfaces, rects);
-    return rects;
-  }
-  /** Shows each wet layer's live light paint (the light under it with the wet light shaded in). */
-  syncLights() {
-    const w = this.world;
-    if (!w) return;
-    const lights = /* @__PURE__ */ new Map();
-    for (const id of w.laneIds()) {
-      const l = w.lightDisplay(id);
-      if (l && this.host.layerLight(id) !== l) lights.set(id, l);
-    }
-    if (lights.size) this.host.updateLights(lights);
-  }
-  /** Drops the wet layers whose paint has all dried (they become ordinary pixel layers). */
-  retireDry() {
-    const w = this.world;
-    if (!w) return;
-    for (const id of w.laneIds()) {
-      if (w.isActive(id) || this.driver?.init.laneId === id) continue;
-      const base = w.getBase(id);
-      const light = w.isLit(id) ? w.getLight(id) : null;
-      w.removeLane(id);
-      if (light && this.host.layerLight(id) !== light) this.host.updateLights(/* @__PURE__ */ new Map([[id, light]]));
-      this.host.updateSurfaces(/* @__PURE__ */ new Map([[id, base]]), []);
-    }
-  }
-  /**
-   * Advances time by the wall clock (`now` in ms, e.g. `performance.now()`): `speed` steps per
-   * second, at most `maxSteps` per call. Call it every frame; it does nothing while paused or dry.
-   * Resolves when the steps are done and the display is up to date.
-   */
-  tick(now, maxSteps = 8) {
-    if (this.ticking) {
-      this.leadFrame(now);
-      return this.ticking;
-    }
-    if (this.displaying) return this.displaying;
-    const last = this.lastTick;
-    this.lastTick = now;
-    const w = this.world;
-    if (!w || this.paused || last === null) {
-      this.flushDriver();
-      return Promise.resolve();
-    }
-    if (!w.isActive()) {
-      this.flushDriver();
-      this.retireDry();
-      return Promise.resolve();
-    }
-    const lead = w.gpuActive && !this.driver;
-    w.gpuLeadMode = lead;
-    const most = lead ? Math.max(maxSteps, GPU_LEAD) : maxSteps;
-    this.stepsOwed = Math.min(most * 4, this.stepsOwed + (now - last) / 1e3 * this.speed);
-    const n = Math.min(most, Math.floor(this.stepsOwed));
-    this.leadAt = now;
-    if (n < 1) {
-      this.flushDriver();
-      return Promise.resolve();
-    }
-    this.stepsOwed -= n;
-    const run = (async () => {
-      try {
-        await w.step(n);
-      } finally {
-        this.ticking = null;
-      }
-      this.flushDriver();
-      if (w.gpuActive) {
-        const shading = this.syncDisplaysGpu(DISPLAY_TILES_PER_TICK).then(() => void 0);
-        this.displaying = shading;
-        try {
-          await shading;
-        } finally {
-          this.displaying = null;
-        }
-      } else this.syncDisplays(DISPLAY_TILES_PER_TICK);
-      this.retireDry();
-      this.host.changed();
-    })();
-    this.ticking = run;
-    return run;
-  }
-  /** Lead mode: steps the GPU on by the time since the last frame (within the running batch) and shows it. */
-  leadFrame(now) {
-    const w = this.world;
-    if (!w || this.displaying || this.driver || !w.gpuLeading) return;
-    const k = Math.max(1, Math.round((now - this.leadAt) / 1e3 * this.speed));
-    if (!w.gpuLead(k)) return;
-    this.leadAt = now;
-    const shading = this.syncDisplaysGpu(0, true).then(() => this.host.changed());
-    this.displaying = shading;
-    void shading.finally(() => {
-      if (this.displaying === shading) this.displaying = null;
-    });
-  }
-  flushDriver() {
-    const d = this.driver;
-    if (!d || !this.world) return;
-    const rects = d.flush();
-    if (rects.length) this.syncDisplays(DISPLAY_TILES_PER_TICK);
-    if (d.done) this.onDriverDone?.(d);
-  }
-  /** Called when a live stroke that ended mid-batch has finished applying. */
-  onDriverDone = null;
-  /** Steps `steps` times now (agents, tests). Returns the steps run. */
-  async advance(steps) {
-    await this.idle();
-    const w = this.world;
-    if (!w) return 0;
-    await w.ready;
-    await this.idle();
-    const start = w.clock;
-    const n = Math.max(0, Math.floor(steps));
-    const job = (async () => {
-      try {
-        await w.step(n);
-      } finally {
-        this.ticking = null;
-      }
-    })();
-    this.ticking = job;
-    await job;
-    if (w.gpuActive) await this.syncDisplaysGpu(Infinity);
-    else this.syncDisplays();
-    this.retireDry();
-    return w.clock - start;
-  }
-  /**
-   * Dries at once (everything settles where it is), on one layer or all, optionally only in a
-   * rectangle. Returns the layers and rectangles that dried.
-   */
-  dry(layerId, rect) {
-    const w = this.world;
-    if (!w) return [];
-    const ids = layerId !== void 0 ? w.hasLane(layerId) ? [layerId] : [] : w.laneIds();
-    const out = [];
-    for (const id of ids) out.push({ layerId: id, bounds: w.dry(id, rect) });
-    this.syncDisplays();
-    this.retireDry();
-    return out;
-  }
-  /** The layer's light paint with all its wet paint dried (`null` without a wet layer or light), without changing anything. */
-  bakedLight(layerId) {
-    const w = this.world;
-    if (!w?.hasLane(layerId) || !w.isLit(layerId)) return null;
-    return w.bakedLight(layerId);
-  }
-  /** The layer's pixels with all its wet paint dried (deterministic), without changing anything. */
-  bakedSurface(layerId) {
-    const w = this.world;
-    if (!w?.hasLane(layerId)) return null;
-    return w.bakedSurface(layerId);
-  }
-  /** A snapshot of the world for undo (`null` when there is none). */
-  snapshot() {
-    const w = this.world;
-    if (!w || !w.laneIds().length) return null;
-    return w.snapshot();
-  }
-  /** Puts a snapshot back (`null`: no wet layers). Returns the layer surfaces it implies. */
-  restore(snap) {
-    if (!snap) {
-      if (this.world) for (const id of this.world.laneIds()) this.world.removeLane(id);
-      return;
-    }
-    const { width, height } = this.host.canvas();
-    if (this.world && (this.world.width !== width || this.world.height !== height)) this.dropWorld();
-    this.ensureWorld().restore(snap);
-    this.syncDisplays();
-  }
-  dropWorld() {
-    this.world?.destroy();
-    this.world = null;
-    this.driver = null;
-  }
-  /** Forgets everything wet (a new canvas, a resize, opening a document). */
-  reset() {
-    this.world?.destroy();
-    this.world = null;
-    this.driver = null;
-    this.settings.clear();
-    this.lastTick = null;
-    this.stepsOwed = 0;
-  }
-  /** Water overlay tiles (RGBA) over a document rectangle, for the view. */
-  waterOverlay(rect) {
-    const w = this.world;
-    if (!w) return [];
-    const out = [];
-    const tx0 = Math.max(0, Math.floor(rect.x / TILE));
-    const ty0 = Math.max(0, Math.floor(rect.y / TILE));
-    const tx1 = Math.floor((rect.x + rect.width - 1) / TILE);
-    const ty1 = Math.floor((rect.y + rect.height - 1) / TILE);
-    for (let ty = ty0; ty <= ty1; ty++)
-      for (let tx = tx0; tx <= tx1; tx++) {
-        let merged = null;
-        for (const id of w.laneIds()) {
-          const t = w.waterOverlay(id, tx, ty);
-          if (!t) continue;
-          if (!merged) merged = t;
-          else for (let i = 3; i < t.length; i += 4) merged[i] = Math.max(merged[i], t[i]);
-        }
-        if (merged) out.push({ tx, ty, data: merged });
-      }
-    return out;
-  }
-  destroy() {
-    this.world?.destroy();
-    this.world = null;
-    this.gpu?.destroy();
-    this.gpu = null;
-  }
-};
-function wetPigmentOf(hex2, body) {
-  const [r, g, b] = hexToRgb8(hex2);
-  return Array.from(pigmentOf([r / 255, g / 255, b / 255], body));
-}
-
 // src/paint-editor/thumbnails.ts
 var thumbWorld = null;
 function paintWetTestStroke(brush, paper, color, width, height) {
@@ -4922,9 +3339,9 @@ function perspectiveGuideLines(g, size, count = 12) {
 }
 
 // src/paint-editor/color.ts
-var HEX2 = /^#?([0-9a-f]{6})$/i;
+var HEX = /^#?([0-9a-f]{6})$/i;
 function parseHexColor(value, what = "color") {
-  const m = typeof value === "string" ? HEX2.exec(value.trim()) : null;
+  const m = typeof value === "string" ? HEX.exec(value.trim()) : null;
   if (!m) throw new Error(`${what} is ${JSON.stringify(value)}; use #rrggbb, e.g. "#2a4b8d".`);
   const n = parseInt(m[1], 16);
   return [n >> 16 & 255, n >> 8 & 255, n & 255];
@@ -5279,6 +3696,8 @@ function samplePath(d, options = {}) {
   if (!(spacing >= 0.25 && spacing <= 100)) throw new Error(`spacing ${spacing} is out of range; use 0.25..100 document pixels.`);
   const profile = options.pressure;
   if (profile && (!profile.length || profile.some((p) => !(p >= 0 && p <= 1)))) throw new Error("pressure needs one or more values from 0 to 1, e.g. [0.2, 1, 0.2] for a taper.");
+  const speed = options.speed;
+  if (speed !== void 0 && !(speed >= 0.01 && speed <= 100)) throw new Error(`speed ${speed} is out of range; use 0.01..100 document pixels per millisecond.`);
   let contours;
   try {
     contours = pathToContours(d);
@@ -5306,7 +3725,10 @@ function samplePath(d, options = {}) {
       const b = line[Math.min(j + 1, line.length - 1)];
       const x = Math.round((a[0] + (b[0] - a[0]) * f) * 1e3) / 1e3;
       const y = Math.round((a[1] + (b[1] - a[1]) * f) * 1e3) / 1e3;
-      points.push(profile ? { x, y, pressure: Math.round(profileAt(profile, k / n) * 1e3) / 1e3 } : { x, y });
+      const p = { x, y };
+      if (profile) p.pressure = Math.round(profileAt(profile, k / n) * 1e3) / 1e3;
+      if (speed !== void 0) p.t = Math.round(at / speed * 1e3) / 1e3;
+      points.push(p);
     }
     out.push(points);
   }
@@ -5904,10 +4326,10 @@ async function libraryCall(call) {
     throw e instanceof BrushLibraryError ? new PaintEditorError(e.message) : e;
   }
 }
-var HEX3 = /^#[0-9a-f]{6}$/i;
+var HEX2 = /^#[0-9a-f]{6}$/i;
 var MAX_ADD_STICKERS = 500;
 function parseColor(value, what = "color") {
-  if (typeof value !== "string" || !HEX3.test(value.trim())) throw new PaintEditorError(`${what} is ${JSON.stringify(value)}; use #rrggbb, e.g. "#2a4b8d".`);
+  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(hex2) {
@@ -6141,36 +4563,82 @@ var PaintEditorController = class _PaintEditorController {
   }
   /**
    * Runs `fn` as one undo step named `label`: every change it makes (strokes, fills, new layers) is
-   * undone together. Wet paint can't be grouped. Nested groups join the outer one. If `fn` throws,
-   * its changes are put back and nothing is recorded.
+   * undone together. When `fn` returns a promise, the group holds until it settles; until then other
+   * changes (the user's strokes, undo) are refused, except those `fn` makes through `within`, so
+   * nothing else lands in (or is lost with) the group's step. Nested groups join the outer one. If
+   * `fn` throws or rejects, its changes are put back and nothing is recorded.
    */
   group(label, fn) {
-    if (this.grouping) return fn();
+    if (this.grouping && (!this.grouping.pending || this.grouping.inside)) return fn((step) => step());
     this.requireIdle("grouping changes");
     const before = this.doc;
     const revision = this.docRevision;
-    this.grouping = { label, before, changed: false };
-    let result;
-    try {
-      result = fn();
-    } catch (e) {
+    const strokesBefore = this.strokeCounter;
+    const origin = this.getOrigin();
+    const g = { label, before, changed: false, pending: false, inside: 0 };
+    this.grouping = g;
+    const within = (step) => {
+      if (this.grouping !== g) return step();
+      g.inside++;
+      try {
+        return step();
+      } finally {
+        g.inside--;
+      }
+    };
+    const rollback = () => {
       this.grouping = null;
+      this.strokeCounter = strokesBefore;
+      if (this.wetOp) {
+        const snap = this.wetOp.before;
+        this.wetOp = null;
+        this.pendingWetEvents = [];
+        this.wet.restore(snap);
+      }
       if (this.doc !== before) {
         this.doc = before;
         this.docRevision = revision + 1;
+        this.wet.syncDisplays();
+        this.emit();
+      }
+    };
+    const finish = () => {
+      this.grouping = null;
+      if (g.changed && this.doc !== before || this.wetOp) {
+        const entry = { label: g.label, origin, before, after: this.doc };
+        if (this.wetOp) {
+          entry.wet = { before: this.wetOp.before, after: this.wet.snapshot(), lost: false };
+          this.wetOp = null;
+        }
+        this.undoStack.push(entry);
+        if (this.undoStack.length > this.historyLimit) this.undoStack.shift();
+        this.redoStack = [];
+        this.trimWetHistory();
+        this.notifyCommit({ kind: "execute", label: g.label, origin: entry.origin });
         this.emit();
       }
+    };
+    let result;
+    try {
+      result = fn(within);
+    } catch (e) {
+      rollback();
       throw e;
     }
-    const g = this.grouping;
-    this.grouping = null;
-    if (g.changed && this.doc !== before) {
-      this.undoStack.push({ label, origin: this.getOrigin(), before, after: this.doc });
-      if (this.undoStack.length > this.historyLimit) this.undoStack.shift();
-      this.redoStack = [];
-      this.notifyCommit({ kind: "execute", label, origin: this.getOrigin() });
-      this.emit();
+    if (result && typeof result.then === "function") {
+      g.pending = true;
+      return Promise.resolve(result).then(
+        (val) => {
+          finish();
+          return val;
+        },
+        (e) => {
+          rollback();
+          throw e;
+        }
+      );
     }
+    finish();
     return result;
   }
   /**
@@ -6297,11 +4765,13 @@ var PaintEditorController = class _PaintEditorController {
   /** Why the document cannot be replaced or stepped through right now, or `null`. */
   busyReason() {
     if (this.session) return "A stroke is in progress; end or cancel it first.";
+    if (this.grouping?.pending && !this.grouping.inside) return `"${this.grouping.label}" is still being painted; wait for it to finish first.`;
     if (this.wet.busy) return "Wet paint is mid-step; wait a moment (wetIdle()) first.";
     return null;
   }
   requireIdle(what) {
     if (this.session) throw new PaintEditorError(`A stroke is in progress; end or cancel it before ${what}.`);
+    if (this.grouping?.pending && !this.grouping.inside) throw new PaintEditorError(`"${this.grouping.label}" is still being painted (one undo step); wait for it to finish before ${what}.`);
   }
   commit(label, next, before = this.doc) {
     if (this.grouping) {
@@ -7968,7 +6438,7 @@ var PaintEditorController = class _PaintEditorController {
     } catch (e) {
       throw new PaintEditorError(e instanceof Error ? e.message : String(e));
     }
-    const { path: _path, spacing: _spacing, pressure: _pressure, ...stroke } = init;
+    const { path: _path, spacing: _spacing, pressure: _pressure, speed: _speed, ...stroke } = init;
     const before = this.doc;
     let doc = this.doc;
     let bounds = null;
@@ -10164,6 +8634,9 @@ var PaintDirector = class {
       case "stroke":
         await this.say(id, command.note, 500);
         return this.stroke(id, command.stroke);
+      case "strokes":
+        await this.say(id, command.note, 500);
+        return this.strokes(id, command.strokes, command.label);
       case "fill": {
         await this.say(id, command.note, 500);
         const { width, height } = c.getState().document.canvas;
@@ -10189,11 +8662,11 @@ var PaintDirector = class {
     }
   }
   /** Paints a stroke live: begins it, pushes its points frame by frame as the cursor reaches them, then ends it (one undo step). */
-  async stroke(id, init) {
+  async stroke(id, init, within = (step) => step()) {
     const c = this.controller;
     const points = c.checkPoints(init.points);
     const { points: _points, ...rest } = init;
-    const session = c.beginStroke({ snapToPerspective: false, start: points[0], ...rest });
+    const session = within(() => c.beginStroke({ snapToPerspective: false, start: points[0], ...rest }));
     try {
       await this.glide(id, points[0]);
       this.presence.set({ id, pressed: true });
@@ -10221,7 +8694,46 @@ var PaintDirector = class {
       throw error;
     }
   }
+  /** Paints several strokes live in turn and commits them as one undo step (e.g. a path's subpaths). */
+  async strokes(id, inits, label) {
+    const c = this.controller;
+    if (!Array.isArray(inits) || !inits.length) throw new PaintEditorError("strokes is empty; give at least one stroke.");
+    const checked = inits.map((s) => ({ ...s, points: c.checkPoints(s.points) }));
+    const first = checked[0];
+    const base = first.brushId ? c.getBrush(first.brushId) : c.getState().brush;
+    const stepLabel = label ?? `${base?.name ?? "Brush"} path stroke`;
+    return c.group(stepLabel, async (within) => {
+      let layerId = first.layerId ?? c.document.activeLayerId ?? "";
+      let bounds = null;
+      let dabs = 0;
+      const strokeIds = [];
+      let last = null;
+      for (const s of checked) {
+        const r = await this.stroke(id, s, within);
+        layerId = r.layerId;
+        bounds = unionRect2(bounds, r.bounds);
+        dabs += r.dabs;
+        if (r.strokeId) strokeIds.push(r.strokeId);
+        last = r;
+      }
+      return {
+        layerId,
+        bounds,
+        dabs,
+        strokeIds,
+        ...last?.mixerLoad ? { mixerLoad: last.mixerLoad } : {},
+        ...last?.wet !== void 0 ? { wet: last.wet } : {}
+      };
+    });
+  }
 };
+function unionRect2(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 };
+}
 
 // src/paint-editor/playback.ts
 var WET = /^(advance_wet_paint|dry_paint|wet_paper|set_wet_settings|set_flow_map|set_canvas_tilt|pause_wet_paint|set_wet_engine|set_water_overlay)$/;
@@ -10253,7 +8765,7 @@ function planPaintToolPlayback(tool, _args) {
   if (control) steps.push({ type: "target", ref: control }, { type: "press" }, { type: "release" });
   return steps.length ? steps : null;
 }
-var DIRECTED = /* @__PURE__ */ new Set(["paint_stroke", "fill_layer", "replay_strokes"]);
+var DIRECTED = /* @__PURE__ */ new Set(["paint_stroke", "stroke_path", "fill_layer", "replay_strokes"]);
 function withPaintPlayback(provider, options) {
   const plan = (tool) => {
     if (tool.plan || tool.playback !== void 0) return tool;
@@ -11288,7 +9800,8 @@ function createPaintEditorToolProvider(controller, options = {}) {
   const add = (t) => tools.push(t);
   const act = async (command, direct) => {
     if (!options.director) return direct();
-    const [r] = await options.director.perform(options.actor ?? { id: "agent", name: "Agent" }, [command]);
+    const cmd = typeof command === "function" ? command() : command;
+    const [r] = await options.director.perform(options.actor ?? { id: "agent", name: "Agent" }, [cmd]);
     if (!r || !r.ok) throw new Error(r && !r.ok ? r.message : "The director did not run the command.");
     return r.result;
   };
@@ -11394,7 +9907,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
     annotations: { title: "Get the paper", ...READ6 },
     handler: () => JSON.parse(JSON.stringify(c.document.paper))
   });
-  const tuning2 = {
+  const tuning = {
     type: "object",
     properties: {
       contrast: { type: "number", minimum: 0, maximum: 3, description: "Height contrast around the middle (default 1)." },
@@ -11417,8 +9930,8 @@ function createPaintEditorToolProvider(controller, options = {}) {
         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 (the grain water and pigment follow)." },
+        dry: { ...tuning, description: "Height map tuning for dry media." },
+        wet: { ...tuning, description: "Height map tuning for wet media (the grain water and pigment follow)." },
         absorption: { type: "number", minimum: 0, maximum: 1, description: "Wet media: how fast the paper soaks up water (high: washes stop spreading sooner)." },
         permeability: { type: "number", minimum: 0, maximum: 1, description: "Wet media: how freely water flows over the fibres (low: more ragged, slower spreading)." },
         roughness: { type: "number", minimum: 0, maximum: 1, description: "Wet media: how much the grain pins wet edges and catches granulating pigment." },
@@ -11737,13 +10250,14 @@ function createPaintEditorToolProvider(controller, options = {}) {
   add({
     name: "stroke_path",
     title: "Brush along a path",
-    description: "Brushes vector path data (SVG path d in document pixels: M, L, H, V, C, S, Q, T, A and Z) on a pixel layer with a library brush or the active one, as if drawn by hand along it: the outline of a shape, a lettering guide, a curve from a vector tool. Each subpath becomes one recorded stroke, sampled every spacing px, with an optional pressure profile spread along each subpath (a taper such as [0.2, 1, 0.2]); closed subpaths end where they start. Brushes behave as in paint_stroke (grain, pick-up, wet and thick paint, guides off). One undo step for the whole path. Returns the layer id, changed bounds, dab count and the recorded strokeIds (for replay_strokes, update_stroke).",
+    description: "Brushes vector path data (SVG path d in document pixels: M, L, H, V, C, S, Q, T, A and Z) on a pixel layer with a library brush or the active one, as if drawn by hand along it: the outline of a shape, a lettering guide, a curve from a vector tool. Each subpath becomes one recorded stroke, sampled every spacing px, with an optional pressure profile spread along each subpath (a taper such as [0.2, 1, 0.2]); closed subpaths end where they start. Brushes behave as in paint_stroke (grain, pick-up, wet and thick paint, guides off). With an agent cursor (a director), each subpath is painted live in turn. One undo step for the whole path. Returns the layer id, changed bounds, dab count and the recorded strokeIds (for replay_strokes, update_stroke).",
     inputSchema: {
       type: "object",
       properties: {
         path: { type: "string", minLength: 1, description: 'SVG path data in document pixels, e.g. "M 40 200 C 120 40 280 40 360 200". Several subpaths paint several strokes.' },
         spacing: { type: "number", minimum: 0.25, maximum: 100, description: "Distance between samples along the path in document pixels (default 2); the brush spaces its own dabs, so this only sets how closely curves are followed." },
         pressure: { type: "array", minItems: 1, maxItems: 64, items: { type: "number", minimum: 0, maximum: 1 }, description: "Pen pressure along each subpath, spread evenly from start to end (default full pressure); [0.2, 1, 0.2] tapers both ends." },
+        speed: { type: "number", minimum: 0.01, maximum: 100, description: "Drawing speed in document pixels per millisecond (optional; gives each sample a time t so playback has a pace and speed-sensitive brushes respond)." },
         layerId: LAYER_ID4,
         brushId: { type: "string", description: "Brush id from list_brush_presets (default the active brush)." },
         brush: { type: "object", description: "Facets to change for this stroke only, laid over brushId or the active brush (as set_brush takes them).", properties: BRUSH_PATCH_PROPERTIES, additionalProperties: false },
@@ -11765,7 +10279,30 @@ function createPaintEditorToolProvider(controller, options = {}) {
         if (refs.length) await c.prepareStickers(refs);
       }
       const path = options.origin && typeof a.path === "string" && a.path.trim() ? bezierPathToSvg(a.path, { offset: { x: -options.origin.x, y: -options.origin.y } }) : a.path;
-      const r = c.strokePath({ path, spacing: a.spacing, pressure: a.pressure, layerId: a.layerId, brushId: a.brushId, brush, color: a.color, paint: a.paint, seed: a.seed });
+      const init = { path, spacing: a.spacing, pressure: a.pressure, speed: a.speed, layerId: a.layerId, brushId: a.brushId, brush, color: a.color, paint: a.paint, seed: a.seed };
+      const r = await act(
+        () => {
+          if (typeof path !== "string" || !path.trim()) throw new PaintEditorError('path is empty; give SVG path data in document pixels, e.g. "M 10 10 C 40 0 80 60 120 30".');
+          let subpaths;
+          try {
+            subpaths = samplePath(path, init);
+          } catch (e) {
+            throw new PaintEditorError(e instanceof Error ? e.message : String(e));
+          }
+          const { path: _path, spacing: _spacing, pressure: _pressure, speed: _speed, ...stroke } = init;
+          return {
+            kind: "strokes",
+            label: `${base?.name ?? "Brush"} path stroke`,
+            strokes: subpaths.map((points, i) => ({
+              ...stroke,
+              ...stroke.seed !== void 0 ? { seed: stroke.seed + i } : {},
+              snapToPerspective: false,
+              points
+            }))
+          };
+        },
+        () => c.strokePath(init)
+      );
       return r.mixerLoad ? { ...r, mixerLoad: loadResult(r.mixerLoad) } : r;
     }
   });
@@ -13058,7 +11595,7 @@ function createPaintChangeFeed(controller, options = {}) {
     }
   };
 }
-var HEX4 = /^#[0-9a-f]{6}$/i;
+var HEX3 = /^#[0-9a-f]{6}$/i;
 var DRY_ENGINES = /* @__PURE__ */ new Set(["dab", "particle", "bristle", "mixer"]);
 function suggestionBrushRefusal(brush) {
   if (!DRY_ENGINES.has(brush.engine)) return `The ${brush.name} brush (${brush.engine}) can't paint a suggestion: suggestions are dry paint on a layer of their own. Use a dab, particle, bristle or mixer brush.`;
@@ -13098,20 +11635,20 @@ function createPaintProposals(options) {
       if (op.kind === "stroke") {
         if (!op.points?.length) throw new PaintEditorError(`${at}: a stroke needs points in document pixels.`);
         points += op.points.length;
-        if (op.color !== void 0 && !HEX4.test(op.color)) throw new PaintEditorError(`${at}: color "${op.color}" is not #rrggbb.`);
+        if (op.color !== void 0 && !HEX3.test(op.color)) throw new PaintEditorError(`${at}: color "${op.color}" is not #rrggbb.`);
         const brush = op.brushId ? controller.getBrush(op.brushId) : controller.getState().brush;
         if (!brush) throw new PaintEditorError(`${at}: unknown brush "${op.brushId}". Call list_brush_presets for the ids.`);
         const refusal = suggestionBrushRefusal(brush);
         if (refusal) throw new PaintEditorError(`${at}: ${refusal}`);
         if (op.size !== void 0 && !(op.size > 0)) throw new PaintEditorError(`${at}: size must be above 0 (document pixels).`);
       } else if (op.kind === "wash") {
-        if (!HEX4.test(op.color ?? "")) throw new PaintEditorError(`${at}: a wash needs color as #rrggbb.`);
+        if (!HEX3.test(op.color ?? "")) throw new PaintEditorError(`${at}: a wash needs color as #rrggbb.`);
         if (op.opacity !== void 0 && !(op.opacity > 0 && op.opacity <= 1)) throw new PaintEditorError(`${at}: opacity must be in (0, 1].`);
       } else if (op.kind === "echo") {
         if (!op.strokeIds?.length) throw new PaintEditorError(`${at}: an echo needs strokeIds (list_strokes).`);
         const unknown = op.strokeIds.filter((id) => !known.has(id));
         if (unknown.length) throw new PaintEditorError(`${at}: unknown stroke ${unknown.map((u) => `"${u}"`).join(", ")}. Call list_strokes for the ids.`);
-        if (op.color !== void 0 && !HEX4.test(op.color)) throw new PaintEditorError(`${at}: color "${op.color}" is not #rrggbb.`);
+        if (op.color !== void 0 && !HEX3.test(op.color)) throw new PaintEditorError(`${at}: color "${op.color}" is not #rrggbb.`);
         if (op.repeat !== void 0 && !(Number.isInteger(op.repeat) && op.repeat >= 1 && op.repeat <= 50)) throw new PaintEditorError(`${at}: repeat must be a whole number from 1 to 50.`);
         for (const id of op.strokeIds) {
           const stroke = controller.getStrokes().find((s) => s.id === id);