@pixerate/editor 0.275.1 → 0.276.0

package/dist/paint-editor/index.js

@@ -14,7 +14,7 @@ import {
   mergeBrushPatch,
   multiColorSliders,
   patchBrushValue
-} from "../chunk-G5TCMKX5.js";
+} from "../chunk-IJ6NSWKM.js";
 import {
   createStickerTools,
   describeStickerRef
@@ -22,7 +22,7 @@ import {
 import {
   BRUSH_PREVIEW_DARK_PAPER,
   brushPreviewsOnDark
-} from "../chunk-RJGW3RQS.js";
+} from "../chunk-GHYJAMMS.js";
 import {
   toVideoFfmpeg
 } from "../chunk-S2XPXA47.js";
@@ -42,7 +42,7 @@ import {
   resolveExternalAssets,
   serializeLayers,
   serializeLayersExternal
-} from "../chunk-MSWLJI4G.js";
+} from "../chunk-XMSH66VU.js";
 import "../chunk-ADMRNWR7.js";
 import "../chunk-WJ4WQJCC.js";
 import {
@@ -68,7 +68,7 @@ import "../chunk-ZIF4UJJ6.js";
 import {
   createPigmentTools,
   pointerPressure
-} from "../chunk-HVO6XCI4.js";
+} from "../chunk-JPB65KQ6.js";
 import "../chunk-VWEWY4FY.js";
 import "../chunk-HVQVHUTV.js";
 import {
@@ -125,7 +125,7 @@ import {
   wetPaperInput,
   wetPigmentOf,
   withStrokePath
-} from "../chunk-Y2ISSVPH.js";
+} from "../chunk-4EM5NGCL.js";
 import {
   BRUSH_ID,
   BRUSH_PRESETS,
@@ -198,7 +198,7 @@ import {
   readBrushSource,
   resolveBrush,
   usesPaintExchange
-} from "../chunk-ZM7IKQ4X.js";
+} from "../chunk-XVPQNX7O.js";
 import {
   STAMP_KINDS,
   StickersSlot,
@@ -248,15 +248,18 @@ import {
   normalizeWetParams,
   pigmentOf,
   wetSupport
-} from "../chunk-LMG57L5A.js";
-import "../chunk-W6JDUXP3.js";
+} from "../chunk-CTHWXW5M.js";
+import "../chunk-J23JOHPR.js";
 import {
   CoverageMap,
+  DEFAULT_LIVE_PATTERNS,
   DEFAULT_PAINT_GRADIENT,
   DEFAULT_PAINT_GRADIENT_MAPPING,
   EMPTY_MIXER_LOAD,
   GRAIN_PATTERNS,
   GRAIN_TILE,
+  LIVE_PATTERN_KINDS,
+  LIVE_PATTERN_PRESETS,
   MAX_BRUSH_SIZE,
   PAINT_COLOR_JSON_SCHEMA,
   PAINT_GRADIENT_FULL_SPEED,
@@ -288,6 +291,7 @@ import {
   isGradientPaint,
   loadMixer,
   normalizeHexColor,
+  normalizeLivePatterns,
   paintGradientMappingFor,
   paintSourceColor,
   paintSourceCss,
@@ -300,7 +304,7 @@ import {
   scalePaintGradient,
   solidPaint,
   updatePaintGradientStop
-} from "../chunk-ACTHSQOI.js";
+} from "../chunk-LDZOXESA.js";
 import {
   TileableNoise,
   hash2,
@@ -5091,6 +5095,26 @@ async function replayPainting(source, target, options = {}) {
             if (e.layerId && target.getLayer(e.layerId)) target.wetPaper({ layerId: e.layerId, rect: sr(d.rect), amount: d.amount });
             break;
           }
+          case "live-patterns": {
+            const d = e.data;
+            if (e.layerId && target.getLayer(e.layerId)) {
+              target.setLivePatterns(e.layerId, d ? { ...d, scale: Math.min(4, d.scale * s), enabled: true } : { enabled: false });
+            }
+            break;
+          }
+          case "seed-live-patterns": {
+            const d = e.data;
+            if (e.layerId && target.getLayer(e.layerId) && Array.isArray(d.points)) {
+              target.seedLivePatterns({
+                layerId: e.layerId,
+                points: d.points.map((p) => ({ ...p, x: p.x * s, y: p.y * s })),
+                radius: Math.min(512, d.radius * s),
+                seed: d.seed,
+                ...d.settings ? { ...d.settings, ...d.settings.scale ? { scale: Math.min(4, d.settings.scale * s) } : {} } : {}
+              });
+            }
+            break;
+          }
           case "ghost-release": {
             const d = e.data;
             if (e.layerId && target.getLayer(e.layerId)) target.wet.releaseGhost(e.layerId, d?.linger);
@@ -6410,6 +6434,16 @@ var PaintEditorController = class _PaintEditorController {
           for (const [id, surface] of lights) if (findLayer(this.doc.layers, id)) light = withLayerLight(light, id, surface);
           this.doc = { ...this.doc, ...light ? { light } : {} };
         },
+        layerHeight: (id) => this.doc.thick?.[id]?.height ?? null,
+        updateHeights: (heights) => {
+          let thick = this.doc.thick;
+          for (const [id, height] of heights) {
+            if (!findLayer(this.doc.layers, id)) continue;
+            const prev = thick?.[id] ?? emptyThickChannels();
+            thick = { ...thick ?? {}, [id]: { ...prev, height } };
+          }
+          if (thick !== this.doc.thick) this.doc = { ...this.doc, ...thick ? { thick } : {} };
+        },
         changed: () => {
         }
       },
@@ -6860,7 +6894,7 @@ var PaintEditorController = class _PaintEditorController {
     this.extensions = {};
     this.guides = { ...this.guides, symmetry: { ...this.guides.symmetry, center: { x: next.canvas.width / 2, y: next.canvas.height / 2 } }, tracing: null };
     this.tracingVersion++;
-    if (this.wet.world) {
+    if (this.wet.world || this.wet.patterns.size) {
       this.beginWetOp();
       this.wet.reset();
     }
@@ -8823,7 +8857,19 @@ var PaintEditorController = class _PaintEditorController {
           s.result.wet = this.wet.isWet(s.layerId);
         }
         const l = this.getLayer(s.layerId);
-        const thick = withLayerThick(this.doc.thick, l.id, s.thickChannels());
+        let ch = s.thickChannels();
+        if (wetStroke) {
+          const f = this.wet.patterns.get(l.id);
+          if (f?.enabled) {
+            this.wet.settingsOf(l.id).livePatterns = { ...f.settings };
+            if (f.settings.relief > 0 && f.tiles.size > 0) {
+              const prevCh = ch ?? this.doc.thick?.[l.id] ?? emptyThickChannels();
+              const nextHeight = f.applyReliefHeight(prevCh.height);
+              if (nextHeight !== prevCh.height) ch = { ...prevCh, height: nextHeight };
+            }
+          }
+        }
+        const thick = withLayerThick(this.doc.thick, l.id, ch);
         const sprayed = s.stickers();
         const stickers = sprayed ? { ...this.doc.stickers ?? {}, [l.id]: [...this.doc.stickers?.[l.id] ?? [], ...sprayed] } : this.doc.stickers;
         const wetLight = wetStroke && this.wet.world?.hasLane(l.id) ? this.wet.world.lightDisplay(l.id) : null;
@@ -8976,7 +9022,19 @@ var PaintEditorController = class _PaintEditorController {
         }
         const l = findLayer(out.layers, s.layerId).layer;
         const offset = s.init.wet ? { x: 0, y: 0 } : l.offset;
-        const thick = withLayerThick(out.thick, l.id, s.thickChannels());
+        let ch = s.thickChannels();
+        if (s.init.wet) {
+          const f = this.wet.patterns.get(l.id);
+          if (f?.enabled) {
+            this.wet.settingsOf(l.id).livePatterns = { ...f.settings };
+            if (f.settings.relief > 0 && f.tiles.size > 0) {
+              const prevCh = ch ?? out.thick?.[l.id] ?? emptyThickChannels();
+              const nextHeight = f.applyReliefHeight(prevCh.height);
+              if (nextHeight !== prevCh.height) ch = { ...prevCh, height: nextHeight };
+            }
+          }
+        }
+        const thick = withLayerThick(out.thick, l.id, ch);
         const sprayed = s.stickers();
         const lit = s.lightChannel() ?? (s.init.wet && this.wet.world?.hasLane(l.id) ? this.wet.world.lightDisplay(l.id) : null);
         const fl = s.fluorChannel();
@@ -9640,6 +9698,149 @@ var PaintEditorController = class _PaintEditorController {
     if (this.wet.busy) return [];
     return this.wet.waterOverlay(rect);
   }
+  layerLivePatternsInfo(layerId) {
+    const info = this.wet.info(layerId);
+    const stats = this.wet.livePatternStats(layerId);
+    return {
+      layerId,
+      wet: info.wet,
+      wetCells: info.wetCells,
+      wetBounds: info.wetBounds,
+      ...stats
+    };
+  }
+  checkLivePatternsInput(input) {
+    if (!input) return {};
+    const out = {};
+    if (input.pattern !== void 0) {
+      if (!LIVE_PATTERN_KINDS.includes(input.pattern)) {
+        throw new PaintEditorError(`pattern must be one of ${LIVE_PATTERN_KINDS.join(", ")}, not ${JSON.stringify(input.pattern)}.`);
+      }
+      out.pattern = input.pattern;
+    }
+    if (input.feed !== void 0) {
+      if (!(Number.isFinite(input.feed) && input.feed >= 5e-3 && input.feed <= 0.1)) {
+        throw new PaintEditorError(`feed ${input.feed} is out of range; use 0.005..0.1.`);
+      }
+      out.feed = input.feed;
+    }
+    if (input.kill !== void 0) {
+      if (!(Number.isFinite(input.kill) && input.kill >= 0.02 && input.kill <= 0.08)) {
+        throw new PaintEditorError(`kill ${input.kill} is out of range; use 0.02..0.08.`);
+      }
+      out.kill = input.kill;
+    }
+    if (input.scale !== void 0) {
+      if (!(Number.isFinite(input.scale) && input.scale >= 0.25 && input.scale <= 4)) {
+        throw new PaintEditorError(`scale ${input.scale} is out of range; use 0.25..4.`);
+      }
+      out.scale = input.scale;
+    }
+    if (input.contrast !== void 0) {
+      if (!(Number.isFinite(input.contrast) && input.contrast >= 0 && input.contrast <= 2)) {
+        throw new PaintEditorError(`contrast ${input.contrast} is out of range; use 0..2.`);
+      }
+      out.contrast = input.contrast;
+    }
+    if (input.secondColor !== void 0) {
+      out.secondColor = input.secondColor === null ? null : parseColor(input.secondColor, "secondColor");
+    }
+    if (input.relief !== void 0) {
+      if (!(Number.isFinite(input.relief) && input.relief >= 0 && input.relief <= 1)) {
+        throw new PaintEditorError(`relief ${input.relief} is out of range; use 0..1.`);
+      }
+      out.relief = input.relief;
+    }
+    return out;
+  }
+  /**
+   * Reads a layer's Gray-Scott reaction-diffusion live patterns (`layerId`, default the active
+   * layer), plus all layers with wet paint or live patterns and the built-in Pearson presets.
+   */
+  getLivePatterns(layerId) {
+    const l = this.wetLayer(layerId, "read the live patterns of");
+    const primary = this.layerLivePatternsInfo(l.id);
+    const ids = /* @__PURE__ */ new Set([l.id, ...this.wet.wetLayerIds()]);
+    for (const [id, f] of this.wet.patterns) {
+      if ((f.enabled || f.tiles.size > 0) && findLayer(this.doc.layers, id)) ids.add(id);
+    }
+    for (const [id, s] of this.wet.settings) {
+      if (s.livePatterns && findLayer(this.doc.layers, id)) ids.add(id);
+    }
+    const layers = [...ids].map((id) => id === l.id ? primary : this.layerLivePatternsInfo(id));
+    return {
+      ...primary,
+      layers,
+      presets: LIVE_PATTERN_PRESETS,
+      brushPresets: ["turing-wash", "coral-ink"]
+    };
+  }
+  /**
+   * Configures a layer's Gray-Scott reaction-diffusion live patterns (or clears them with
+   * `enabled: false`). One undo step.
+   */
+  setLivePatterns(layerId, update) {
+    this.requireIdle("changing live patterns");
+    this.requireWetIdle("changing live patterns");
+    const l = this.wetLayer(layerId, "set the live patterns of");
+    if (isLayerLocked(l, "pixels")) throw new PaintEditorError(`Layer "${l.name}" has its pixels locked; unlock it first.`);
+    if (update.enabled !== void 0 && typeof update.enabled !== "boolean") {
+      throw new PaintEditorError("enabled must be true or false.");
+    }
+    const checked = this.checkLivePatternsInput(update);
+    const before = this.doc;
+    this.beginWetOp();
+    const next = this.wet.setLivePatterns(l.id, update.enabled === false ? null : checked);
+    this.logWet({ kind: "live-patterns", layerId: l.id, data: next });
+    this.commit("Live patterns", this.withWetEvents(this.doc), before);
+    return this.layerLivePatternsInfo(l.id);
+  }
+  /**
+   * Seeds Gray-Scott reaction-diffusion activator (`V`) discs into a layer's live-pattern field so
+   * patterns grow where the layer holds wet water and freeze where it dries. One undo step.
+   */
+  seedLivePatterns(options) {
+    this.requireIdle("seeding live patterns");
+    this.requireWetIdle("seeding live patterns");
+    const l = this.wetLayer(options.layerId, "seed live patterns on");
+    if (isLayerLocked(l, "pixels")) throw new PaintEditorError(`Layer "${l.name}" has its pixels locked; unlock it first.`);
+    if (!Array.isArray(options.points) || !options.points.length) {
+      throw new PaintEditorError("points is empty; give at least one {x, y} in document pixels.");
+    }
+    const { width, height } = this.doc.canvas;
+    const points = options.points.map((p, i) => {
+      if (!p || !Number.isFinite(p.x) || !Number.isFinite(p.y)) {
+        throw new PaintEditorError(`points[${i}] needs finite x and y in document pixels.`);
+      }
+      if (p.x < 0 || p.y < 0 || p.x >= width || p.y >= height) {
+        throw new PaintEditorError(`points[${i}] (${p.x}, ${p.y}) is outside the ${width}\xD7${height} canvas.`);
+      }
+      if (p.strength !== void 0 && !(Number.isFinite(p.strength) && p.strength > 0 && p.strength <= 1)) {
+        throw new PaintEditorError(`points[${i}].strength ${p.strength} is out of range; use above 0 up to 1.`);
+      }
+      return { x: p.x, y: p.y, ...p.strength !== void 0 ? { strength: p.strength } : {} };
+    });
+    const radius = options.radius ?? 16;
+    if (!(Number.isFinite(radius) && radius >= 1 && radius <= 512)) {
+      throw new PaintEditorError(`radius ${radius} is out of range; use 1..512 px.`);
+    }
+    const seed = options.seed ?? mix32(this.seedCounter++ * 2654435761 >>> 0) & 2147483647;
+    if (!Number.isInteger(seed) || seed < 0) {
+      throw new PaintEditorError(`seed ${seed} must be a whole number of 0 or more.`);
+    }
+    const hasSettings = options.pattern !== void 0 || options.feed !== void 0 || options.kill !== void 0 || options.scale !== void 0 || options.contrast !== void 0 || options.secondColor !== void 0 || options.relief !== void 0;
+    const settings = hasSettings ? this.checkLivePatternsInput(options) : void 0;
+    const before = this.doc;
+    this.beginWetOp();
+    const { seededCells } = this.wet.seedLivePatterns(l.id, points, radius, seed, settings);
+    this.logWet({
+      kind: "seed-live-patterns",
+      layerId: l.id,
+      data: { points, radius, seed, ...settings ? { settings } : {} }
+    });
+    this.commit("Seed live patterns", this.withWetEvents(this.doc), before);
+    return { ...this.layerLivePatternsInfo(l.id), seededCells };
+  }
   // --- Rendering -----------------------------------------------------------------
   sources() {
     return { width: this.doc.canvas.width, height: this.doc.canvas.height };
@@ -9895,7 +10096,12 @@ var PaintEditorController = class _PaintEditorController {
       const savedGhost = ghost?.trigger === "agent" ? null : ghost;
       const heldEvap = this.heldEvaporation.get(id);
       const params = heldEvap !== void 0 ? { ...set.params, evaporation: heldEvap } : { ...set.params };
-      layers[id] = { params, flow: { ...set.flow }, ...savedGhost ? { ghost: savedGhost } : {} };
+      layers[id] = {
+        params,
+        flow: { ...set.flow },
+        ...savedGhost ? { ghost: savedGhost } : {},
+        ...set.livePatterns ? { livePatterns: { ...set.livePatterns } } : {}
+      };
     }
     const flat = this.wet.tilt.angle === 0;
     if (!Object.keys(layers).length && flat) return void 0;
@@ -9914,7 +10120,14 @@ var PaintEditorController = class _PaintEditorController {
         }
         const x = v;
         const ghost = readWetGhost(x.ghost);
-        this.wet.settings.set(id, { params: normalizeWetParams(x.params ?? {}), flow: normalizeFlow(x.flow ?? {}), ...ghost ? { ghost } : {} });
+        const livePatterns = x.livePatterns ? normalizeLivePatterns(x.livePatterns) : null;
+        this.wet.settings.set(id, {
+          params: normalizeWetParams(x.params ?? {}),
+          flow: normalizeFlow(x.flow ?? {}),
+          ...ghost ? { ghost } : {},
+          ...livePatterns ? { livePatterns } : {}
+        });
+        if (livePatterns) this.wet.patternFieldOf(id).configure(livePatterns);
       }
     }
   }
@@ -12102,6 +12315,9 @@ function shiftDocument(doc, dx, dy) {
       if (e.kind === "dry" && typeof d.x === "number") return { ...e, data: moveRect(d, dx, dy) };
       if (e.kind === "wet-paper" && d.rect) return { ...e, data: { ...d, rect: moveRect(d.rect, dx, dy) } };
       if (e.kind === "flow" && d.center) return { ...e, data: { ...d, center: movePoint(d.center, dx, dy) } };
+      if (e.kind === "seed-live-patterns" && Array.isArray(d.points)) {
+        return { ...e, data: { ...d, points: d.points.map((p) => ({ ...p, x: p.x + dx, y: p.y + dy })) } };
+      }
       return e;
     });
   }
@@ -13139,6 +13355,43 @@ var WET_PARAM_SCHEMA = {
   bloom: UNIT("Blooms: water running into a drying wash pushes its pigment into cauliflower edges (default 0.4)."),
   bleed: UNIT("Colour bleed between touching wet areas (default 0.3).")
 };
+var LIVE_PATTERN_SCHEMA = {
+  pattern: {
+    type: "string",
+    enum: [...LIVE_PATTERN_KINDS],
+    description: "Pearson Gray-Scott preset: spots, stripes, coral, maze or worms (default spots). Sets feed and kill unless explicit feed/kill are also passed."
+  },
+  feed: {
+    type: "number",
+    minimum: 5e-3,
+    maximum: 0.1,
+    description: "Gray-Scott feed rate F, 0.005..0.1 (default: the pattern preset\u2019s feed rate)."
+  },
+  kill: {
+    type: "number",
+    minimum: 0.02,
+    maximum: 0.08,
+    description: "Gray-Scott kill rate k, 0.02..0.08 (default: the pattern preset\u2019s kill rate)."
+  },
+  scale: {
+    type: "number",
+    minimum: 0.25,
+    maximum: 4,
+    description: "Diffusion scale 0.25..4 (larger values grow broader pattern features; default 1)."
+  },
+  contrast: {
+    type: "number",
+    minimum: 0,
+    maximum: 2,
+    description: "How strongly V modulates the wet pigment or blends toward secondColor, 0..2 (default 0.85)."
+  },
+  secondColor: {
+    type: ["string", "null"],
+    pattern: "^#[0-9a-fA-F]{6}$",
+    description: "Optional #rrggbb colour that high-V pattern ridges blend toward, or null to modulate pigment contrast (default null)."
+  },
+  relief: UNIT("Impasto ridge height 0..1 written from V into the layer\u2019s thick height map so light catches the pattern (default 0).")
+};
 function createPaintWetTools(c) {
   const stillWet = () => c.wetState().wet;
   return [
@@ -13302,6 +13555,73 @@ function createPaintWetTools(c) {
       inputSchema: { type: "object", properties: { visible: { type: "boolean", description: "Show (true) or hide (false) the overlay." } }, required: ["visible"], additionalProperties: false },
       annotations: { title: "Show the water", ...SET2 },
       handler: ({ visible }) => ({ visible: c.setWaterOverlay(visible), stillWet: stillWet() })
+    },
+    {
+      name: "get_live_patterns",
+      title: "Get live patterns",
+      description: "Reads the Gray-Scott reaction-diffusion live patterns on a layer (layerId, default the active layer): whether live patterns are enabled, the active settings (pattern, feed, kill, scale, contrast, secondColor, relief), activeTiles, patternCells, wetPatternCells (pattern cells still holding water where the pattern can grow), meanV, maxV, bounds, wet coverage (wet, wetCells, wetBounds), layers (every layer with wet paint or live patterns), and presets (built-in Pearson feed/kill presets: spots, stripes, coral, maze, worms). Call it before or after advance_wet_paint and dry_paint to inspect pattern growth and freezing.",
+      inputSchema: { type: "object", properties: { layerId: LAYER_ID2 }, additionalProperties: false },
+      annotations: { title: "Get live patterns", ...READ3 },
+      coordinates: { out: ["wetBounds", "bounds", "layers[].wetBounds", "layers[].bounds"] },
+      handler: ({ layerId }) => c.getLivePatterns(layerId)
+    },
+    {
+      name: "set_live_patterns",
+      title: "Set live patterns",
+      description: "Configures a layer\u2019s Gray-Scott reaction-diffusion live patterns (or clears them with enabled: false). Patterns grow inside wet paint during advance_wet_paint and freeze when the paint dries (dry_paint). Choose a Pearson preset (spots, stripes, coral, maze, worms) or explicit feed and kill rates, scale, contrast, secondColor (#rrggbb or null to modulate pigment contrast) and relief (0..1, writes ridge height into thick paint so lighting catches the pattern). One undo step. Returns the layer\u2019s live-pattern stats and stillWet.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          layerId: LAYER_ID2,
+          enabled: { type: "boolean", description: "true (default) configures live patterns on the layer; false clears them." },
+          ...LIVE_PATTERN_SCHEMA
+        },
+        additionalProperties: false
+      },
+      annotations: { title: "Set live patterns", ...SET2 },
+      coordinates: { out: ["wetBounds", "bounds"] },
+      handler: async ({ layerId, ...update }) => {
+        await c.wetIdle();
+        return { ...c.setLivePatterns(layerId, update), stillWet: stillWet() };
+      }
+    },
+    {
+      name: "seed_live_patterns",
+      title: "Seed live patterns",
+      description: 'Seeds Gray-Scott reaction-diffusion activator (V) discs at points on a layer so reaction-diffusion patterns (spots, stripes, coral, maze, worms) grow where the layer holds wet water (advance_wet_paint) and freeze where it dries (dry_paint). Painting with a wet brush that has a livePatterns facet (such as preset "turing-wash" or "coral-ink") also seeds along the stroke automatically. One undo step. Returns seededCells, the layer\u2019s live-pattern stats (patternCells, wetPatternCells, meanV, maxV, bounds) and stillWet.',
+      inputSchema: {
+        type: "object",
+        properties: {
+          layerId: LAYER_ID2,
+          points: {
+            type: "array",
+            minItems: 1,
+            maxItems: 1024,
+            description: "Seed centres in document pixels where reaction-diffusion activator V is nucleated.",
+            items: {
+              type: "object",
+              properties: {
+                x: { type: "number", description: "Document x in pixels." },
+                y: { type: "number", description: "Document y in pixels." },
+                strength: { type: "number", exclusiveMinimum: 0, maximum: 1, description: "Seed strength 0..1 (default 1)." }
+              },
+              required: ["x", "y"],
+              additionalProperties: false
+            }
+          },
+          radius: { type: "number", minimum: 1, maximum: 512, description: "Seed disc radius in document pixels (default 16)." },
+          seed: { type: "integer", minimum: 0, description: "Deterministic noise seed for the nucleated discs (default: next editor seed)." },
+          ...LIVE_PATTERN_SCHEMA
+        },
+        required: ["points"],
+        additionalProperties: false
+      },
+      annotations: { title: "Seed live patterns", ...WRITE3 },
+      coordinates: { in: ["points"], out: ["wetBounds", "bounds"] },
+      handler: async (args) => {
+        await c.wetIdle();
+        return { ...c.seedLivePatterns(args), stillWet: stillWet() };
+      }
     }
   ];
 }
@@ -15435,6 +15755,18 @@ var WET_TILT_SLIDERS = [
   { path: "direction", label: "Downhill", min: 0, max: 359, step: 1 }
 ];
 var WET_SPEED_SLIDER = { path: "speed", label: "Speed", min: 15, max: 480, step: 15 };
+var LIVE_PATTERN_LABELS = {
+  spots: "Spots",
+  stripes: "Stripes",
+  coral: "Coral",
+  maze: "Maze",
+  worms: "Worms"
+};
+var LIVE_PATTERN_SLIDERS = [
+  { path: "scale", label: "Scale", min: 0.25, max: 4, step: 0.05 },
+  { path: "contrast", label: "Contrast", min: 0, max: 2, step: 0.05 },
+  { path: "relief", label: "Relief", min: 0, max: 1, step: 0.01 }
+];
 var WET_GPU_OPTIONS = [
   { value: "auto", label: "GPU for large washes" },
   { value: "off", label: "CPU only" }
@@ -16108,13 +16440,14 @@ function uiTables() {
     brushOptions: BRUSH_OPTION_CONTROLS,
     blendMenu: BLEND_MENU_GROUPS,
     layerEffects: LAYER_EFFECT_MENU.map(({ kind, label }) => ({ kind, label, controls: layerEffectControls(defaultLayerEffect(kind, kind)) })),
-    sliders: { paper: PAPER_SLIDERS, wet: WET_PARAM_SLIDERS, wetTilt: WET_TILT_SLIDERS, wetSpeed: WET_SPEED_SLIDER, light: LIGHT_SLIDERS, uvLight: UV_LIGHT_SLIDERS, viewTilt: VIEW_TILT_SLIDERS, ghost: GHOST_SLIDERS, mutation: MUTATION_SLIDERS, stroke: STROKE_SLIDERS, sticker: STICKER_SLIDERS },
+    sliders: { paper: PAPER_SLIDERS, wet: WET_PARAM_SLIDERS, wetTilt: WET_TILT_SLIDERS, wetSpeed: WET_SPEED_SLIDER, light: LIGHT_SLIDERS, uvLight: UV_LIGHT_SLIDERS, viewTilt: VIEW_TILT_SLIDERS, ghost: GHOST_SLIDERS, mutation: MUTATION_SLIDERS, livePatterns: LIVE_PATTERN_SLIDERS, stroke: STROKE_SLIDERS, sticker: STICKER_SLIDERS },
     pathStrokeTapers: PATH_STROKE_TAPERS,
     padSampleSizes: PAD_SAMPLE_SIZES,
     wetGpu: WET_GPU_OPTIONS,
     labels: {
       wetTools: WET_TOOL_LABELS,
       wetMedia: WET_MEDIUM_LABELS,
+      livePatterns: LIVE_PATTERN_LABELS,
       impastoTools: IMPASTO_TOOL_LABELS,
       particleKinds: PARTICLE_KIND_LABELS,
       particleRenders: PARTICLE_RENDER_LABELS,
@@ -16191,6 +16524,7 @@ export {
   DEFAULT_IRIDESCENCE,
   DEFAULT_LIGHT,
   DEFAULT_LIGHTING,
+  DEFAULT_LIVE_PATTERNS,
   DEFAULT_MULTI_COLOR,
   DEFAULT_MUTATION,
   DEFAULT_MUTATION_RATES,
@@ -16235,6 +16569,11 @@ export {
   IMPASTO_TOOL_LABELS,
   IRIDESCENCE_SLIDERS,
   LIGHT_SLIDERS,
+  LIVE_PATTERN_KINDS,
+  LIVE_PATTERN_LABELS,
+  LIVE_PATTERN_PRESETS,
+  LIVE_PATTERN_SCHEMA,
+  LIVE_PATTERN_SLIDERS,
   LIVE_STROKE_ENGINES,
   LitCache,
   MAX_BRUSH_SIZE,
@@ -16482,6 +16821,7 @@ export {
   normalizeImpasto,
   normalizeLight,
   normalizeLighting,
+  normalizeLivePatterns,
   normalizeMultiColor,
   normalizeMutation,
   normalizeMutationRates,

package/dist/paint-editor/ui.d.cts

@@ -10,7 +10,7 @@
  */
 import type { MixerLoad } from '../paint/exchange.cjs';
 import { type BlendModeInfo } from '../raster/blend.cjs';
-import type { ImpastoTool, WetMediumKind, WetTool } from './brushes.cjs';
+import type { ImpastoTool, WetMediumKind, WetTool, LivePatternKind } from './brushes.cjs';
 import type { FillRegionOptions, PaintEditorController } from './controller.cjs';
 import type { PenPoint } from './engine.cjs';
 import { type Point2 } from './guides.cjs';
@@ -204,6 +204,10 @@ export declare const WET_PARAM_SLIDERS: readonly SliderControl[];
 export declare const WET_TILT_SLIDERS: readonly SliderControl[];
 /** The speed slider (steps per second). */
 export declare const WET_SPEED_SLIDER: SliderControl;
+/** Labels of the Gray-Scott live pattern kinds. */
+export declare const LIVE_PATTERN_LABELS: Readonly<Record<LivePatternKind, string>>;
+/** The wet panel's sliders for a layer's live patterns. */
+export declare const LIVE_PATTERN_SLIDERS: readonly SliderControl[];
 /** The wet-engine choices a panel offers (Engine B, the WebGPU accelerator). */
 export declare const WET_GPU_OPTIONS: readonly {
     value: WetGpuMode;

package/dist/paint-editor/ui.d.ts

@@ -10,7 +10,7 @@
  */
 import type { MixerLoad } from '../paint/exchange.js';
 import { type BlendModeInfo } from '../raster/blend.js';
-import type { ImpastoTool, WetMediumKind, WetTool } from './brushes.js';
+import type { ImpastoTool, WetMediumKind, WetTool, LivePatternKind } from './brushes.js';
 import type { FillRegionOptions, PaintEditorController } from './controller.js';
 import type { PenPoint } from './engine.js';
 import { type Point2 } from './guides.js';
@@ -204,6 +204,10 @@ export declare const WET_PARAM_SLIDERS: readonly SliderControl[];
 export declare const WET_TILT_SLIDERS: readonly SliderControl[];
 /** The speed slider (steps per second). */
 export declare const WET_SPEED_SLIDER: SliderControl;
+/** Labels of the Gray-Scott live pattern kinds. */
+export declare const LIVE_PATTERN_LABELS: Readonly<Record<LivePatternKind, string>>;
+/** The wet panel's sliders for a layer's live patterns. */
+export declare const LIVE_PATTERN_SLIDERS: readonly SliderControl[];
 /** The wet-engine choices a panel offers (Engine B, the WebGPU accelerator). */
 export declare const WET_GPU_OPTIONS: readonly {
     value: WetGpuMode;

package/dist/paint-editor/wet-tools.d.cts

@@ -63,4 +63,46 @@ export declare const WET_PARAM_SCHEMA: {
         readonly description: string;
     };
 };
+export declare const LIVE_PATTERN_SCHEMA: {
+    readonly pattern: {
+        readonly type: "string";
+        readonly enum: readonly ["spots", "stripes", "coral", "maze", "worms"];
+        readonly description: "Pearson Gray-Scott preset: spots, stripes, coral, maze or worms (default spots). Sets feed and kill unless explicit feed/kill are also passed.";
+    };
+    readonly feed: {
+        readonly type: "number";
+        readonly minimum: 0.005;
+        readonly maximum: 0.1;
+        readonly description: "Gray-Scott feed rate F, 0.005..0.1 (default: the pattern preset’s feed rate).";
+    };
+    readonly kill: {
+        readonly type: "number";
+        readonly minimum: 0.02;
+        readonly maximum: 0.08;
+        readonly description: "Gray-Scott kill rate k, 0.02..0.08 (default: the pattern preset’s kill rate).";
+    };
+    readonly scale: {
+        readonly type: "number";
+        readonly minimum: 0.25;
+        readonly maximum: 4;
+        readonly description: "Diffusion scale 0.25..4 (larger values grow broader pattern features; default 1).";
+    };
+    readonly contrast: {
+        readonly type: "number";
+        readonly minimum: 0;
+        readonly maximum: 2;
+        readonly description: "How strongly V modulates the wet pigment or blends toward secondColor, 0..2 (default 0.85).";
+    };
+    readonly secondColor: {
+        readonly type: readonly ["string", "null"];
+        readonly pattern: "^#[0-9a-fA-F]{6}$";
+        readonly description: "Optional #rrggbb colour that high-V pattern ridges blend toward, or null to modulate pigment contrast (default null).";
+    };
+    readonly relief: {
+        readonly type: "number";
+        readonly minimum: 0;
+        readonly maximum: 1;
+        readonly description: string;
+    };
+};
 export declare function createPaintWetTools(c: PaintEditorController): PaintAgentTool[];