@pixerate/editor 0.273.0 → 0.275.0

package/dist/{chunk-N5IMDAHM.cjs → chunk-DHC4E2DU.cjs}

@@ -850,7 +850,7 @@ var S2 = SLOT_SIDE;
 var SNAP_PLANES = SET_PLANES + MASS_CHANNELS;
 var noLight = () => new (0, _chunk474IQG74cjs.TiledSurface)(1, /* @__PURE__ */ new Map(), 0);
 function cloneGhost(g) {
-  return g ? { pigment: [...g.pigment], remaining: g.remaining, total: g.total, linger: g.linger } : null;
+  return g ? { pigment: [...g.pigment], remaining: g.remaining, total: g.total, linger: g.linger, ...g.trigger === "agent" ? { trigger: "agent" } : {} } : null;
 }
 function newLane(id, index, params, flow, flowStrength, base, light, ghost) {
   const l = _nullishCoalesce(light, () => ( noLight()));
@@ -1119,21 +1119,59 @@ var WetWorld = (_class = class {
   }
   /**
    * Starts a ghost paint fade on `id` with `pigment` per unit tracer and `linger` seconds. If an
-   * earlier ghost of a different colour is still fading on the layer, it finishes at once first.
+   * earlier ghost of a different colour is still fading on the layer, it finishes at once first
+   * (or keeps its paint when it was an unclaimed agent-triggered ghost).
    */
-  startGhost(id, pigment, linger, stepsPerSecond = 120) {
+  startGhost(id, pigment, linger, stepsPerSecond = 120, trigger = "immediate") {
     this.requireIdle();
     const lane = this.laneOf(id);
     const p = [Math.fround(pigment[0]), Math.fround(pigment[1]), Math.fround(pigment[2]), Math.fround(pigment[3])];
     if (lane.ghost) {
       const g = lane.ghost.pigment;
       const same = Math.abs(g[0] - p[0]) <= 1e-6 && Math.abs(g[1] - p[1]) <= 1e-6 && Math.abs(g[2] - p[2]) <= 1e-6 && Math.abs(g[3] - p[3]) <= 1e-6;
-      if (!same) this.fadeGhost(id, 1);
+      if (!same) {
+        if (lane.ghost.trigger === "agent") this.keepGhost(id);
+        else this.fadeGhost(id, 1);
+      }
     }
     const total = Math.max(1, Math.round(linger * stepsPerSecond / FREE_INTERVAL));
-    lane.ghost = { pigment: p, remaining: total, total, linger };
+    lane.ghost = { pigment: p, remaining: total, total, linger, ...trigger === "agent" ? { trigger: "agent" } : {} };
     lane.lit = false;
   }
+  /**
+   * Releases a held (`trigger: 'agent'`) ghost on `id` so its fade starts counting down on the
+   * simulation clock over `linger` seconds (default: the lane's configured `linger`).
+   */
+  releaseGhost(id, linger, stepsPerSecond = 120) {
+    this.requireIdle();
+    const lane = this.laneOf(id);
+    if (!lane.ghost) return;
+    const l = _nullishCoalesce(linger, () => ( lane.ghost.linger));
+    const total = Math.max(1, Math.round(l * stepsPerSecond / FREE_INTERVAL));
+    lane.ghost = { pigment: lane.ghost.pigment, remaining: total, total, linger: l };
+  }
+  /**
+   * Drops a ghost lane's tracer (`P_L`, `P_DL`) without subtracting its pigment, so an unclaimed
+   * or declined wet mutation stroke stays as ordinary wet paint.
+   */
+  keepGhost(id) {
+    this.requireIdle();
+    const lane = this.laneOf(id);
+    if (!lane.ghost) return;
+    const f = this.f32;
+    for (const key of this.active) {
+      if (this.laneIndexOf(key) !== lane.index) continue;
+      const slot = this.slotOf(key);
+      if (slot < 0) continue;
+      const b = this.slotBase(slot);
+      const cur = b + this.parity * SET_PLANES * PLANE;
+      f.fill(0, cur + P_L * PLANE, cur + (P_L + 1) * PLANE);
+      f.fill(0, b + P_DL * PLANE, b + (P_DL + 1) * PLANE);
+      this.gpuDirtySlot(slot, 1, WET_TILE);
+    }
+    lane.ghost = null;
+    this.refreshHalos();
+  }
   pack(lane) {
     packWetParams(lane.params, _nullishCoalesce(this.paper, () => ( DEFAULT_WET_PAPER)), this.tilt, lane.flowStrength, this.prm);
     this.f32.set(this.prm, this.layout.params + lane.index * PARAM_FLOATS * 4 >> 2);
@@ -1367,7 +1405,7 @@ var WetWorld = (_class = class {
     for (const key of wakeups) woke = this.activate(key) || woke;
     if (this.clock % FREE_INTERVAL === 0) {
       for (const lane of this.lanes) {
-        if (!_optionalChain([lane, 'optionalAccess', _19 => _19.ghost])) continue;
+        if (!_optionalChain([lane, 'optionalAccess', _19 => _19.ghost]) || lane.ghost.trigger === "agent") continue;
         const g = lane.ghost;
         const amount = g.remaining <= 1 ? 1 : 1 / g.remaining;
         g.remaining = Math.max(0, g.remaining - 1);
@@ -1931,12 +1969,16 @@ var WetWorld = (_class = class {
         continue;
       }
       const f = this.f32;
-      const pig = _nullishCoalesce(_optionalChain([lane, 'access', _22 => _22.ghost, 'optionalAccess', _23 => _23.pigment]), () => ( null));
+      const pig = lane.ghost && lane.ghost.trigger !== "agent" ? lane.ghost.pigment : null;
+      const clearTracer = Boolean(lane.ghost && lane.ghost.trigger === "agent");
       for (let y = y0; y < y1; y++) {
         for (let x = x0; x < x1; x++) {
           const c = this.cell(lane, x, y);
           const d = this.single(c) + P_D0 * PLANE;
-          if (pig) {
+          if (clearTracer) {
+            f[c + P_L * PLANE] = 0;
+            f[d + 4 * PLANE] = 0;
+          } else if (pig) {
             const tl = f[c + P_L * PLANE];
             const dl = f[d + 4 * PLANE];
             if (tl > 0 || dl > 0) {
@@ -1980,7 +2022,17 @@ var WetWorld = (_class = class {
   bakeKey(key, all) {
     const lane = this.lanes[this.laneIndexOf(key)];
     if (lane.ghost) {
-      this.fadeGhostKey(key, lane, 1);
+      if (lane.ghost.trigger === "agent") {
+        const slot = this.slotOf(key);
+        if (slot >= 0) {
+          const b = this.slotBase(slot);
+          const cur = b + this.parity * SET_PLANES * PLANE;
+          this.f32.fill(0, cur + P_L * PLANE, cur + (P_L + 1) * PLANE);
+          this.f32.fill(0, b + P_DL * PLANE, b + (P_DL + 1) * PLANE);
+        }
+      } else {
+        this.fadeGhostKey(key, lane, 1);
+      }
       if (!this.hasGhostTracer(lane)) lane.ghost = null;
     }
     const [tx, ty] = this.tileXY(key);
@@ -1997,7 +2049,7 @@ var WetWorld = (_class = class {
         lightChanged = true;
       }
     }
-    const src = _nullishCoalesce(_optionalChain([lane, 'access', _24 => _24.base, 'access', _25 => _25.tiles, 'access', _26 => _26.get, 'call', _27 => _27(tk), 'optionalAccess', _28 => _28.data]), () => ( null));
+    const src = _nullishCoalesce(_optionalChain([lane, 'access', _22 => _22.base, 'access', _23 => _23.tiles, 'access', _24 => _24.get, 'call', _25 => _25(tk), 'optionalAccess', _26 => _26.data]), () => ( null));
     const out = this.shadeSlot(key, src, all ? "bake-all" : "bake");
     if (!out) return lightChanged;
     const tiles = new Map(lane.base.tiles);
@@ -2062,7 +2114,7 @@ var WetWorld = (_class = class {
       if (this.laneIndexOf(key) !== lane.index) continue;
       const tk = this.tileKeyOf(key);
       let out;
-      if (lane.ghost) {
+      if (lane.ghost && lane.ghost.trigger !== "agent") {
         const b = this.slotBase(this.slotOf(key));
         const cur = b + this.parity * SET_PLANES * PLANE;
         const savedP = this.f32.slice(cur + P_P0 * PLANE, cur + (P_P0 + MASS_CHANNELS) * PLANE);
@@ -2087,11 +2139,11 @@ var WetWorld = (_class = class {
             }
           }
         }
-        out = this.shadeSlot(key, _nullishCoalesce(_optionalChain([lane, 'access', _29 => _29.base, 'access', _30 => _30.tiles, 'access', _31 => _31.get, 'call', _32 => _32(tk), 'optionalAccess', _33 => _33.data]), () => ( null)), "bake-all");
+        out = this.shadeSlot(key, _nullishCoalesce(_optionalChain([lane, 'access', _27 => _27.base, 'access', _28 => _28.tiles, 'access', _29 => _29.get, 'call', _30 => _30(tk), 'optionalAccess', _31 => _31.data]), () => ( null)), "bake-all");
         this.f32.set(savedP, cur + P_P0 * PLANE);
         this.f32.set(savedD, b + P_D0 * PLANE);
       } else {
-        out = this.shadeSlot(key, _nullishCoalesce(_optionalChain([lane, 'access', _34 => _34.base, 'access', _35 => _35.tiles, 'access', _36 => _36.get, 'call', _37 => _37(tk), 'optionalAccess', _38 => _38.data]), () => ( null)), "bake-all");
+        out = this.shadeSlot(key, _nullishCoalesce(_optionalChain([lane, 'access', _32 => _32.base, 'access', _33 => _33.tiles, 'access', _34 => _34.get, 'call', _35 => _35(tk), 'optionalAccess', _36 => _36.data]), () => ( null)), "bake-all");
       }
       if (!out) continue;
       const t = _chunk474IQG74cjs.finishTile.call(void 0, out, 4, 0);
@@ -2215,14 +2267,14 @@ var WetWorld = (_class = class {
   display(id, maxTiles = Infinity) {
     const lane = this.laneOf(id);
     const keys = this.active.filter((k) => this.laneIndexOf(k) === lane.index);
-    const stale = keys.filter((k) => _optionalChain([lane, 'access', _39 => _39.shaded, 'access', _40 => _40.get, 'call', _41 => _41(this.tileKeyOf(k)), 'optionalAccess', _42 => _42.stamp]) !== lane.stamp);
-    stale.sort((a, b) => Number(lane.urgent.has(this.tileKeyOf(b))) - Number(lane.urgent.has(this.tileKeyOf(a))) || (_nullishCoalesce(_optionalChain([lane, 'access', _43 => _43.shaded, 'access', _44 => _44.get, 'call', _45 => _45(this.tileKeyOf(a)), 'optionalAccess', _46 => _46.stamp]), () => ( 0))) - (_nullishCoalesce(_optionalChain([lane, 'access', _47 => _47.shaded, 'access', _48 => _48.get, 'call', _49 => _49(this.tileKeyOf(b)), 'optionalAccess', _50 => _50.stamp]), () => ( 0))));
+    const stale = keys.filter((k) => _optionalChain([lane, 'access', _37 => _37.shaded, 'access', _38 => _38.get, 'call', _39 => _39(this.tileKeyOf(k)), 'optionalAccess', _40 => _40.stamp]) !== lane.stamp);
+    stale.sort((a, b) => Number(lane.urgent.has(this.tileKeyOf(b))) - Number(lane.urgent.has(this.tileKeyOf(a))) || (_nullishCoalesce(_optionalChain([lane, 'access', _41 => _41.shaded, 'access', _42 => _42.get, 'call', _43 => _43(this.tileKeyOf(a)), 'optionalAccess', _44 => _44.stamp]), () => ( 0))) - (_nullishCoalesce(_optionalChain([lane, 'access', _45 => _45.shaded, 'access', _46 => _46.get, 'call', _47 => _47(this.tileKeyOf(b)), 'optionalAccess', _48 => _48.stamp]), () => ( 0))));
     const changed = [];
     let done = 0;
     for (const key of stale) {
       if (done >= maxTiles) break;
       const tk = this.tileKeyOf(key);
-      const src = _nullishCoalesce(_optionalChain([lane, 'access', _51 => _51.base, 'access', _52 => _52.tiles, 'access', _53 => _53.get, 'call', _54 => _54(tk), 'optionalAccess', _55 => _55.data]), () => ( null));
+      const src = _nullishCoalesce(_optionalChain([lane, 'access', _49 => _49.base, 'access', _50 => _50.tiles, 'access', _51 => _51.get, 'call', _52 => _52(tk), 'optionalAccess', _53 => _53.data]), () => ( null));
       const out = this.shadeSlot(key, src, "display");
       const tile = out ? _chunk474IQG74cjs.finishTile.call(void 0, out, 4, 0) : _nullishCoalesce(lane.base.tiles.get(tk), () => ( null));
       lane.shaded.set(tk, { stamp: lane.stamp, tile: _nullishCoalesce(tile, () => ( { data: new Uint8ClampedArray(0), uniform: 0 })) });
@@ -2259,7 +2311,7 @@ var WetWorld = (_class = class {
     for (const key2 of keys) {
       const tk = this.tileKeyOf(key2);
       live.add(tk);
-      if (_optionalChain([lane, 'access', _56 => _56.lightShaded, 'access', _57 => _57.get, 'call', _58 => _58(tk), 'optionalAccess', _59 => _59.stamp]) === lane.stamp) continue;
+      if (_optionalChain([lane, 'access', _54 => _54.lightShaded, 'access', _55 => _55.get, 'call', _56 => _56(tk), 'optionalAccess', _57 => _57.stamp]) === lane.stamp) continue;
       const src = _nullishCoalesce(lane.light.tiles.get(tk), () => ( null));
       const out = this.shadeLightSlot(key2, src, "display");
       lane.lightShaded.set(tk, { stamp: lane.stamp, tile: out ? _chunk474IQG74cjs.finishTile.call(void 0, out, 1, 0) : src });
@@ -2457,7 +2509,7 @@ var WetWorld = (_class = class {
     if (!this.gpu || this.busyFlag && !plan || !plan && !this.gpuDecide()) return { ...this.display(id, maxCpuTiles), gpu: false };
     const lane = this.laneOf(id);
     const keys = this.active.filter((k) => this.laneIndexOf(k) === lane.index);
-    const stale = plan ? keys : keys.filter((k) => _optionalChain([lane, 'access', _60 => _60.shaded, 'access', _61 => _61.get, 'call', _62 => _62(this.tileKeyOf(k)), 'optionalAccess', _63 => _63.stamp]) !== lane.stamp);
+    const stale = plan ? keys : keys.filter((k) => _optionalChain([lane, 'access', _58 => _58.shaded, 'access', _59 => _59.get, 'call', _60 => _60(this.tileKeyOf(k)), 'optionalAccess', _61 => _61.stamp]) !== lane.stamp);
     if (!stale.length) return { ...this.display(id, 0), gpu: true };
     let tiles;
     const stamp = lane.stamp;
@@ -2465,7 +2517,7 @@ var WetWorld = (_class = class {
     try {
       if (!plan) this.gpuSync();
       const parity = plan ? plan.parity + plan.done & 1 : this.parity;
-      tiles = await this.gpu.shade(this.gpuJobs(stale), parity, stale.map((k) => _nullishCoalesce(_optionalChain([base, 'access', _64 => _64.tiles, 'access', _65 => _65.get, 'call', _66 => _66(this.tileKeyOf(k)), 'optionalAccess', _67 => _67.data]), () => ( null))), [this.paperBytes[0], this.paperBytes[1], this.paperBytes[2]]);
+      tiles = await this.gpu.shade(this.gpuJobs(stale), parity, stale.map((k) => _nullishCoalesce(_optionalChain([base, 'access', _62 => _62.tiles, 'access', _63 => _63.get, 'call', _64 => _64(this.tileKeyOf(k)), 'optionalAccess', _65 => _65.data]), () => ( null))), [this.paperBytes[0], this.paperBytes[1], this.paperBytes[2]]);
     } catch (e) {
       this.gpuStop(`Wet paint stopped using the GPU (${e.message}).`);
       return { ...this.display(id, maxCpuTiles), gpu: false };
@@ -2644,8 +2696,8 @@ function normalizeFlow(raw = {}, base = DEFAULT_FLOW) {
 }
 function flowField(spec, width, height) {
   const k = FLOW_ACCEL;
-  const cx = _nullishCoalesce(_optionalChain([spec, 'access', _68 => _68.center, 'optionalAccess', _69 => _69.x]), () => ( width / 2));
-  const cy = _nullishCoalesce(_optionalChain([spec, 'access', _70 => _70.center, 'optionalAccess', _71 => _71.y]), () => ( height / 2));
+  const cx = _nullishCoalesce(_optionalChain([spec, 'access', _66 => _66.center, 'optionalAccess', _67 => _67.x]), () => ( width / 2));
+  const cy = _nullishCoalesce(_optionalChain([spec, 'access', _68 => _68.center, 'optionalAccess', _69 => _69.y]), () => ( height / 2));
   const r0 = Math.max(width, height) / 2;
   switch (spec.kind) {
     case "none":
@@ -3108,7 +3160,7 @@ var UNIFORM = 64;
 var STORAGE = 128;
 function findWebGpu() {
   const nav = globalThis.navigator;
-  return _nullishCoalesce(_optionalChain([nav, 'optionalAccess', _72 => _72.gpu]), () => ( null));
+  return _nullishCoalesce(_optionalChain([nav, 'optionalAccess', _70 => _70.gpu]), () => ( null));
 }
 async function createWetGpuEngine(gpu = findWebGpu()) {
   const no = (reason, adapter2 = null) => ({ engine: null, support: { supported: false, reason, adapter: adapter2, maxSlots: 0 } });
@@ -3120,7 +3172,7 @@ async function createWetGpuEngine(gpu = findWebGpu()) {
     return no(`WebGPU gave no adapter (${e.message}); wet paint runs on the CPU.`);
   }
   if (!adapter) return no("WebGPU gave no adapter (the GPU may be blocklisted); wet paint runs on the CPU.");
-  const name = [_optionalChain([adapter, 'access', _73 => _73.info, 'optionalAccess', _74 => _74.vendor]), _optionalChain([adapter, 'access', _75 => _75.info, 'optionalAccess', _76 => _76.architecture])].filter(Boolean).join(" ") || null;
+  const name = [_optionalChain([adapter, 'access', _71 => _71.info, 'optionalAccess', _72 => _72.vendor]), _optionalChain([adapter, 'access', _73 => _73.info, 'optionalAccess', _74 => _74.architecture])].filter(Boolean).join(" ") || null;
   const binding = Math.min(_nullishCoalesce(adapter.limits.maxStorageBufferBindingSize, () => ( 0)), _nullishCoalesce(adapter.limits.maxBufferSize, () => ( 0)));
   const maxSlots = Math.min(MAX_WET_SLOTS, Math.floor(binding / SLOT_BYTES));
   if (maxSlots < 4) return no(`The GPU's storage buffers hold ${Math.max(0, maxSlots)} wet tiles; at least 4 are needed. Wet paint runs on the CPU.`, name);
@@ -3140,27 +3192,27 @@ async function createWetGpuEngine(gpu = findWebGpu()) {
     const engine = await WetGpuEngine.start(device, maxSlots, name);
     return { engine, support: { supported: true, reason: null, adapter: name, maxSlots } };
   } catch (e) {
-    _optionalChain([device, 'access', _77 => _77.destroy, 'optionalCall', _78 => _78()]);
+    _optionalChain([device, 'access', _75 => _75.destroy, 'optionalCall', _76 => _76()]);
     return no(`The wet-media shaders did not compile on this GPU (${e.message}); wet paint runs on the CPU.`, name);
   }
 }
 async function wetGpuSupport(gpu = findWebGpu()) {
   const { engine, support } = await createWetGpuEngine(gpu);
-  _optionalChain([engine, 'optionalAccess', _79 => _79.destroy, 'call', _80 => _80()]);
+  _optionalChain([engine, 'optionalAccess', _77 => _77.destroy, 'call', _78 => _78()]);
   return support;
 }
 async function pipeline(device, code, label) {
-  _optionalChain([device, 'access', _81 => _81.pushErrorScope, 'optionalCall', _82 => _82("validation")]);
+  _optionalChain([device, 'access', _79 => _79.pushErrorScope, 'optionalCall', _80 => _80("validation")]);
   const module = device.createShaderModule({ code, label });
-  const info = await _optionalChain([module, 'access', _83 => _83.getCompilationInfo, 'optionalCall', _84 => _84()]);
-  const errors = _nullishCoalesce(_optionalChain([info, 'optionalAccess', _85 => _85.messages, 'access', _86 => _86.filter, 'call', _87 => _87((m) => m.type === "error")]), () => ( []));
+  const info = await _optionalChain([module, 'access', _81 => _81.getCompilationInfo, 'optionalCall', _82 => _82()]);
+  const errors = _nullishCoalesce(_optionalChain([info, 'optionalAccess', _83 => _83.messages, 'access', _84 => _84.filter, 'call', _85 => _85((m) => m.type === "error")]), () => ( []));
   if (errors.length) {
-    await _optionalChain([device, 'access', _88 => _88.popErrorScope, 'optionalCall', _89 => _89()]);
+    await _optionalChain([device, 'access', _86 => _86.popErrorScope, 'optionalCall', _87 => _87()]);
     throw new Error(`${label}: ${errors.map((m) => `line ${m.lineNum}: ${m.message}`).join("; ")}`);
   }
   const desc = { layout: "auto", compute: { module, entryPoint: "main" }, label };
   const p = device.createComputePipelineAsync ? await device.createComputePipelineAsync(desc) : device.createComputePipeline(desc);
-  const err = await _optionalChain([device, 'access', _90 => _90.popErrorScope, 'optionalCall', _91 => _91()]);
+  const err = await _optionalChain([device, 'access', _88 => _88.popErrorScope, 'optionalCall', _89 => _89()]);
   if (err) throw new Error(`${label}: ${err.message}`);
   return p;
 }
@@ -3186,8 +3238,8 @@ var WetGpuEngine = (_class3 = class _WetGpuEngine {
       return b;
     });
     this.shadeUni = d.createBuffer({ size: 16, usage: UNIFORM | COPY_DST, label: "wet shade" });
-    void _optionalChain([device, 'access', _92 => _92.lost, 'optionalAccess', _93 => _93.then, 'call', _94 => _94((info) => {
-      this.lostReason = _optionalChain([info, 'optionalAccess', _95 => _95.message]) || _optionalChain([info, 'optionalAccess', _96 => _96.reason]) || "the GPU device was lost";
+    void _optionalChain([device, 'access', _90 => _90.lost, 'optionalAccess', _91 => _91.then, 'call', _92 => _92((info) => {
+      this.lostReason = _optionalChain([info, 'optionalAccess', _93 => _93.message]) || _optionalChain([info, 'optionalAccess', _94 => _94.reason]) || "the GPU device was lost";
     })]);
   }
   
@@ -3221,7 +3273,7 @@ var WetGpuEngine = (_class3 = class _WetGpuEngine {
   }
   /** Bytes of GPU memory in use. */
   memoryBytes() {
-    return this.state.size + this.jobs.size + (_nullishCoalesce(_optionalChain([this, 'access', _97 => _97.srcTiles, 'optionalAccess', _98 => _98.size]), () => ( 0))) + (_nullishCoalesce(_optionalChain([this, 'access', _99 => _99.outTiles, 'optionalAccess', _100 => _100.size]), () => ( 0))) * 2;
+    return this.state.size + this.jobs.size + (_nullishCoalesce(_optionalChain([this, 'access', _95 => _95.srcTiles, 'optionalAccess', _96 => _96.size]), () => ( 0))) + (_nullishCoalesce(_optionalChain([this, 'access', _97 => _97.outTiles, 'optionalAccess', _98 => _98.size]), () => ( 0))) * 2;
   }
   /** Slots the state buffer holds now. */
   get capacity() {
@@ -3370,9 +3422,9 @@ var WetGpuEngine = (_class3 = class _WetGpuEngine {
     const d = this.device;
     const tileBytes = TILE_WORDS * 4;
     if (n > this.tileCap || !this.outTiles || !this.outRead || !this.srcTiles) {
-      _optionalChain([this, 'access', _101 => _101.srcTiles, 'optionalAccess', _102 => _102.destroy, 'call', _103 => _103()]);
-      _optionalChain([this, 'access', _104 => _104.outTiles, 'optionalAccess', _105 => _105.destroy, 'call', _106 => _106()]);
-      _optionalChain([this, 'access', _107 => _107.outRead, 'optionalAccess', _108 => _108.destroy, 'call', _109 => _109()]);
+      _optionalChain([this, 'access', _99 => _99.srcTiles, 'optionalAccess', _100 => _100.destroy, 'call', _101 => _101()]);
+      _optionalChain([this, 'access', _102 => _102.outTiles, 'optionalAccess', _103 => _103.destroy, 'call', _104 => _104()]);
+      _optionalChain([this, 'access', _105 => _105.outRead, 'optionalAccess', _106 => _106.destroy, 'call', _107 => _107()]);
       this.tileCap = Math.max(n, this.tileCap * 2, 4);
       this.srcTiles = d.createBuffer({ size: this.tileCap * tileBytes, usage: STORAGE | COPY_DST, label: "wet base tiles" });
       this.outTiles = d.createBuffer({ size: this.tileCap * tileBytes, usage: STORAGE | COPY_SRC, label: "wet shaded tiles" });
@@ -3426,7 +3478,7 @@ var WetGpuEngine = (_class3 = class _WetGpuEngine {
     return this.device.queue.onSubmittedWorkDone();
   }
   destroy() {
-    for (const b of [this.state, this.params, this.jobs, this.flags, this.flagsRead, ...this.uni, this.shadeUni, this.srcTiles, this.outTiles, this.outRead]) _optionalChain([b, 'optionalAccess', _110 => _110.destroy, 'call', _111 => _111()]);
+    for (const b of [this.state, this.params, this.jobs, this.flags, this.flagsRead, ...this.uni, this.shadeUni, this.srcTiles, this.outTiles, this.outRead]) _optionalChain([b, 'optionalAccess', _108 => _108.destroy, 'call', _109 => _109()]);
     this.device.destroy();
   }
 }, _class3);

package/dist/{chunk-NAHJV3O6.js → chunk-G5TCMKX5.js}

@@ -27,7 +27,7 @@ import {
   resolveEngine,
   summarizeBrushSource,
   withKeptIssues
-} from "./chunk-UXYCY3HP.js";
+} from "./chunk-ZM7IKQ4X.js";
 import {
   base64ToBytes
 } from "./chunk-OTTT5N3K.js";
@@ -44,7 +44,7 @@ var BRUSH_PATCH_PROPERTIES = (() => {
   const { required: _r, ...tip } = rest.tip;
   return { ...rest, tip: { ...tip, description: `${tip.description} In a patch, shape may be left out to keep it.` } };
 })();
-var UNSETTABLE_BRUSH_FACETS = ["description", "tags", "medium", "variety", "marks", "dynamics", "behaviour", "light", "ghost", "motion", "colour"];
+var UNSETTABLE_BRUSH_FACETS = ["description", "tags", "medium", "variety", "marks", "dynamics", "behaviour", "light", "fluorescence", "thermochromic", "iridescence", "ghost", "mutation", "motion", "colour"];
 var BRUSH_UNSET_PROPERTY = {
   type: "array",
   minItems: 1,
@@ -1113,6 +1113,11 @@ var BRUSH_SLIDERS = [
   { path: "dynamics.velocitySize", label: "Speed size", min: -1, max: 1, step: 0.01 }
 ];
 var LIGHT_SLIDER = { path: "light.amount", label: "Light", min: 0, max: 1, step: 0.01 };
+var IRIDESCENCE_SLIDERS = [
+  { path: "iridescence.thickness", label: "Film thickness (nm)", min: 100, max: 1e3, step: 5 },
+  { path: "iridescence.pressureToThickness", label: "Pressure \u2192 thickness", min: 0, max: 1, step: 0.01 },
+  { path: "iridescence.ior", label: "Refractive index", min: 1.2, max: 2, step: 0.01 }
+];
 var PICKUP_SLIDERS = [
   { path: "behavior.pickup", label: "Pick-up", min: 0, max: 1, step: 0.01 },
   { path: "behavior.mix", label: "Mix", min: 0, max: 1, step: 0.01 }
@@ -1121,12 +1126,22 @@ var GHOST_SLIDERS = [
   { path: "ghost.linger", label: "Linger", min: 0.5, max: 60, step: 0.5 },
   { path: "ghost.smear", label: "Smear", min: 0, max: 1, step: 0.01 }
 ];
+var MUTATION_SLIDERS = [
+  { path: "mutation.settle", label: "Settle", min: 0.5, max: 10, step: 0.5 },
+  { path: "mutation.patience", label: "Patience", min: 5, max: 300, step: 5 },
+  { path: "mutation.fade", label: "Fade", min: 0.5, max: 10, step: 0.5 }
+];
 function brushEngineControls(brush) {
   const c = engineControls(brush);
-  const wetPaint = brush.engine === "wet" && brush.wet?.tool === "paint" && !brush.ghost;
-  if (!c || !(wetPaint || ["dab", "mixer", "particle", "bristle", "impasto"].includes(brush.engine))) return c;
+  if (!c) return null;
+  const mut = brush.mutation ? MUTATION_SLIDERS : [];
+  const wetPaint = brush.engine === "wet" && brush.wet?.tool === "paint" && !brush.ghost && !brush.mutation;
+  if (!(wetPaint || ["dab", "mixer", "particle", "bristle", "impasto"].includes(brush.engine))) {
+    return mut.length ? { ...c, sliders: [...c.sliders, ...mut] } : c;
+  }
   const extra = brush.engine === "impasto" ? [{ path: "impasto.rim", label: "Rim", min: 0, max: 1, step: 0.01 }, { path: "impasto.clarity", label: "Clarity", min: 0, max: 1, step: 0.01 }] : [];
-  return { ...c, sliders: [...c.sliders, LIGHT_SLIDER, ...extra], light: true };
+  const film = brush.iridescence ? IRIDESCENCE_SLIDERS : [];
+  return { ...c, sliders: [...c.sliders, ...mut, LIGHT_SLIDER, ...extra, ...film], light: true, iridescence: true };
 }
 function engineControls(brush) {
   switch (brush.engine) {
@@ -1197,17 +1212,17 @@ function engineControls(brush) {
           { path: "impasto.load", label: "Load", min: 0, max: 1, step: 0.01 },
           { path: "impasto.thinner", label: "Thinner", min: 0, max: 1, step: 0.01 },
           { path: "impasto.drag", label: "Drag", min: 0, max: 1, step: 0.01 },
-          ...PICKUP_SLIDERS
+          ...brush.mutation ? [] : PICKUP_SLIDERS
         ],
         mixingPath: "behavior.mixing",
-        dirty: true,
+        dirty: !brush.mutation,
         multicolor: false,
-        load: true,
+        load: !brush.mutation,
         impastoTool: true
       };
     case "wet": {
       const tool = brush.wet?.tool ?? "paint";
-      const ghost = tool === "paint" && Boolean(brush.ghost);
+      const ghost = tool === "paint" && (Boolean(brush.ghost) || Boolean(brush.mutation));
       const sliders = tool === "paint" ? [
         { path: "wet.water", label: "Water", min: 0, max: 1, step: 0.01 },
         { path: "wet.pigment", label: "Pigment", min: 0, max: 1, step: 0.01 },
@@ -1215,7 +1230,7 @@ function engineControls(brush) {
         { path: "wet.rewet", label: "Re-wet", min: 0, max: 1, step: 0.01 },
         { path: "wet.load", label: "Load", min: 0, max: 1, step: 0.01 },
         { path: "wet.thinner", label: "Thinner", min: 0, max: 1, step: 0.01 },
-        ...ghost ? GHOST_SLIDERS : PICKUP_SLIDERS
+        ...brush.mutation ? [{ path: "ghost.smear", label: "Smear", min: 0, max: 1, step: 0.01 }] : ghost ? GHOST_SLIDERS : PICKUP_SLIDERS
       ] : tool === "water" ? [
         { path: "wet.water", label: "Water", min: 0, max: 1, step: 0.01 },
         { path: "wet.rewet", label: "Re-wet", min: 0, max: 1, step: 0.01 }
@@ -1249,7 +1264,7 @@ function engineControls(brush) {
     case "mixer":
       return { title: "Mixer Brush", sliders: [...PICKUP_SLIDERS, { path: "mixer.load", label: "Load", min: 0, max: 1, step: 0.01 }], mixingPath: "behavior.mixing", dirty: true, multicolor: true, load: true };
     case "dab":
-      return { title: "Paint behaviour", sliders: PICKUP_SLIDERS, mixingPath: "behavior.mixing", dirty: true, multicolor: true, load: true };
+      return { title: "Paint behaviour", sliders: brush.mutation ? [] : PICKUP_SLIDERS, mixingPath: "behavior.mixing", dirty: !brush.mutation, multicolor: !brush.mutation, load: !brush.mutation };
     default:
       return null;
   }
@@ -1289,7 +1304,9 @@ export {
   createBrushLibraryTools,
   createBrushLibraryToolProvider,
   BRUSH_SLIDERS,
+  IRIDESCENCE_SLIDERS,
   GHOST_SLIDERS,
+  MUTATION_SLIDERS,
   brushEngineControls,
   multiColorSliders,
   patchBrushValue

package/dist/{chunk-DZVRH63Y.js → chunk-IEEY5RJV.js}

@@ -74,7 +74,7 @@ function profileAlongPolyline(points, values, count = 32) {
 var round3 = (v) => Math.round(v * 1e3) / 1e3;
 var loading = null;
 function loadCanvasBrushstrokeRenderer() {
-  loading ??= import("./brushstrokeRender-DZGFU3J4.js").catch((error) => {
+  loading ??= import("./brushstrokeRender-WGY4DZHF.js").catch((error) => {
     loading = null;
     throw error;
   });

package/dist/{chunk-7W2EQQBP.cjs → chunk-JDXWLCXF.cjs}

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
-var _chunkGHGBIAWQcjs = require('./chunk-GHGBIAWQ.cjs');
+var _chunk6QNDGMK7cjs = require('./chunk-6QNDGMK7.cjs');
 
 
 var _chunkJBZRVLXVcjs = require('./chunk-JBZRVLXV.cjs');
@@ -33,25 +33,25 @@ var BRUSH_PREVIEW_FALLBACKS = {
   tools: { light: "#475569", dark: "#cbd5e1" }
 };
 function brushPreviewsOnDark(brush) {
-  return (_nullishCoalesce(_optionalChain([brush, 'access', _ => _.light, 'optionalAccess', _2 => _2.amount]), () => ( 0))) > 0 && _optionalChain([brush, 'access', _3 => _3.tip, 'optionalAccess', _4 => _4.blend]) !== "multiply";
+  return ((_nullishCoalesce(_optionalChain([brush, 'access', _ => _.light, 'optionalAccess', _2 => _2.amount]), () => ( 0))) > 0 || (_nullishCoalesce(_optionalChain([brush, 'access', _3 => _3.fluorescence, 'optionalAccess', _4 => _4.amount]), () => ( 0))) > 0) && _optionalChain([brush, 'access', _5 => _5.tip, 'optionalAccess', _6 => _6.blend]) !== "multiply";
 }
 var hexOf = (c) => _nullishCoalesce(_chunkJBZRVLXVcjs.brushColourHex.call(void 0, c, "light"), () => ( "#ffffff"));
 function brushPreviewStrength(brush) {
   const opacity = _nullishCoalesce(brush.tip.opacity, () => ( 1));
   const flow = _nullishCoalesce(brush.tip.flow, () => ( 1));
-  const grain = _nullishCoalesce(_optionalChain([brush, 'access', _5 => _5.behaviour, 'optionalAccess', _6 => _6.grain]), () => ( 0));
+  const grain = _nullishCoalesce(_optionalChain([brush, 'access', _7 => _7.behaviour, 'optionalAccess', _8 => _8.grain]), () => ( 0));
   return Math.max(0.25, Math.min(1, 0.85 * opacity * (0.6 + 0.4 * flow) * (1 - 0.3 * grain)));
 }
 var over = (fg, bg, alpha) => ({ r: fg.r * alpha + bg.r * (1 - alpha), g: fg.g * alpha + bg.g * (1 - alpha), b: fg.b * alpha + bg.b * (1 - alpha), a: 1 });
 function brushPreviewColours(brush, options = {}) {
-  const profile = _nullishCoalesce(options.profile, () => ( _chunkGHGBIAWQcjs.PAINT_PROFILE));
+  const profile = _nullishCoalesce(options.profile, () => ( _chunk6QNDGMK7cjs.PAINT_PROFILE));
   let background = profile.light === "full" && brushPreviewsOnDark(brush) ? BRUSH_PREVIEW_DARK_PAPER : hexOf(_nullishCoalesce(options.paper, () => ( "#ffffff")));
   if (!options.keepPaper && brush.tip.blend === "multiply" && _chunk5UEFBM2Mcjs.relativeLuminance.call(void 0, _chunk5UEFBM2Mcjs.parseColor.call(void 0, background)) < 0.18) background = "#ffffff";
   const bg = _chunk5UEFBM2Mcjs.parseColor.call(void 0, background);
   const scheme = _chunk5UEFBM2Mcjs.relativeLuminance.call(void 0, bg) < 0.18 ? "dark" : "light";
-  const own = brush.kind === "mark" ? _optionalChain([brush, 'access', _7 => _7.colour, 'optionalAccess', _8 => _8.default]) : void 0;
+  const own = brush.kind === "mark" ? _optionalChain([brush, 'access', _9 => _9.colour, 'optionalAccess', _10 => _10.default]) : void 0;
   const ownHex = typeof own === "string" || _chunkMLLTWAXHcjs.isDualColor.call(void 0, own) ? _chunkJBZRVLXVcjs.brushColourHex.call(void 0, own, scheme) : null;
-  if (ownHex && brush.tip.blend === "multiply" && (_nullishCoalesce(_optionalChain([brush, 'access', _9 => _9.light, 'optionalAccess', _10 => _10.amount]), () => ( 0))) > 0 && scheme === "light") return { background, color: ownHex, scheme };
+  if (ownHex && brush.tip.blend === "multiply" && (_nullishCoalesce(_optionalChain([brush, 'access', _11 => _11.light, 'optionalAccess', _12 => _12.amount]), () => ( 0))) > 0 && scheme === "light") return { background, color: ownHex, scheme };
   const group = brush.kind === "tool" ? "tools" : _nullishCoalesce(brush.medium, () => ( "other"));
   const color = _nullishCoalesce(ownHex, () => ( _chunkJBZRVLXVcjs.brushColourHex.call(void 0, _nullishCoalesce(BRUSH_PREVIEW_FALLBACKS[group], () => ( BRUSH_PREVIEW_FALLBACKS.other)), scheme)));
   const alpha = brushPreviewStrength(brush);

package/dist/{chunk-N3SKPQEH.js → chunk-LMG57L5A.js}

@@ -850,7 +850,7 @@ var S2 = SLOT_SIDE;
 var SNAP_PLANES = SET_PLANES + MASS_CHANNELS;
 var noLight = () => new TiledSurface(1, /* @__PURE__ */ new Map(), 0);
 function cloneGhost(g) {
-  return g ? { pigment: [...g.pigment], remaining: g.remaining, total: g.total, linger: g.linger } : null;
+  return g ? { pigment: [...g.pigment], remaining: g.remaining, total: g.total, linger: g.linger, ...g.trigger === "agent" ? { trigger: "agent" } : {} } : null;
 }
 function newLane(id, index, params, flow, flowStrength, base, light, ghost) {
   const l = light ?? noLight();
@@ -1119,21 +1119,59 @@ var WetWorld = class {
   }
   /**
    * Starts a ghost paint fade on `id` with `pigment` per unit tracer and `linger` seconds. If an
-   * earlier ghost of a different colour is still fading on the layer, it finishes at once first.
+   * earlier ghost of a different colour is still fading on the layer, it finishes at once first
+   * (or keeps its paint when it was an unclaimed agent-triggered ghost).
    */
-  startGhost(id, pigment, linger, stepsPerSecond = 120) {
+  startGhost(id, pigment, linger, stepsPerSecond = 120, trigger = "immediate") {
     this.requireIdle();
     const lane = this.laneOf(id);
     const p = [Math.fround(pigment[0]), Math.fround(pigment[1]), Math.fround(pigment[2]), Math.fround(pigment[3])];
     if (lane.ghost) {
       const g = lane.ghost.pigment;
       const same = Math.abs(g[0] - p[0]) <= 1e-6 && Math.abs(g[1] - p[1]) <= 1e-6 && Math.abs(g[2] - p[2]) <= 1e-6 && Math.abs(g[3] - p[3]) <= 1e-6;
-      if (!same) this.fadeGhost(id, 1);
+      if (!same) {
+        if (lane.ghost.trigger === "agent") this.keepGhost(id);
+        else this.fadeGhost(id, 1);
+      }
     }
     const total = Math.max(1, Math.round(linger * stepsPerSecond / FREE_INTERVAL));
-    lane.ghost = { pigment: p, remaining: total, total, linger };
+    lane.ghost = { pigment: p, remaining: total, total, linger, ...trigger === "agent" ? { trigger: "agent" } : {} };
     lane.lit = false;
   }
+  /**
+   * Releases a held (`trigger: 'agent'`) ghost on `id` so its fade starts counting down on the
+   * simulation clock over `linger` seconds (default: the lane's configured `linger`).
+   */
+  releaseGhost(id, linger, stepsPerSecond = 120) {
+    this.requireIdle();
+    const lane = this.laneOf(id);
+    if (!lane.ghost) return;
+    const l = linger ?? lane.ghost.linger;
+    const total = Math.max(1, Math.round(l * stepsPerSecond / FREE_INTERVAL));
+    lane.ghost = { pigment: lane.ghost.pigment, remaining: total, total, linger: l };
+  }
+  /**
+   * Drops a ghost lane's tracer (`P_L`, `P_DL`) without subtracting its pigment, so an unclaimed
+   * or declined wet mutation stroke stays as ordinary wet paint.
+   */
+  keepGhost(id) {
+    this.requireIdle();
+    const lane = this.laneOf(id);
+    if (!lane.ghost) return;
+    const f = this.f32;
+    for (const key of this.active) {
+      if (this.laneIndexOf(key) !== lane.index) continue;
+      const slot = this.slotOf(key);
+      if (slot < 0) continue;
+      const b = this.slotBase(slot);
+      const cur = b + this.parity * SET_PLANES * PLANE;
+      f.fill(0, cur + P_L * PLANE, cur + (P_L + 1) * PLANE);
+      f.fill(0, b + P_DL * PLANE, b + (P_DL + 1) * PLANE);
+      this.gpuDirtySlot(slot, 1, WET_TILE);
+    }
+    lane.ghost = null;
+    this.refreshHalos();
+  }
   pack(lane) {
     packWetParams(lane.params, this.paper ?? DEFAULT_WET_PAPER, this.tilt, lane.flowStrength, this.prm);
     this.f32.set(this.prm, this.layout.params + lane.index * PARAM_FLOATS * 4 >> 2);
@@ -1367,7 +1405,7 @@ var WetWorld = class {
     for (const key of wakeups) woke = this.activate(key) || woke;
     if (this.clock % FREE_INTERVAL === 0) {
       for (const lane of this.lanes) {
-        if (!lane?.ghost) continue;
+        if (!lane?.ghost || lane.ghost.trigger === "agent") continue;
         const g = lane.ghost;
         const amount = g.remaining <= 1 ? 1 : 1 / g.remaining;
         g.remaining = Math.max(0, g.remaining - 1);
@@ -1931,12 +1969,16 @@ var WetWorld = class {
         continue;
       }
       const f = this.f32;
-      const pig = lane.ghost?.pigment ?? null;
+      const pig = lane.ghost && lane.ghost.trigger !== "agent" ? lane.ghost.pigment : null;
+      const clearTracer = Boolean(lane.ghost && lane.ghost.trigger === "agent");
       for (let y = y0; y < y1; y++) {
         for (let x = x0; x < x1; x++) {
           const c = this.cell(lane, x, y);
           const d = this.single(c) + P_D0 * PLANE;
-          if (pig) {
+          if (clearTracer) {
+            f[c + P_L * PLANE] = 0;
+            f[d + 4 * PLANE] = 0;
+          } else if (pig) {
             const tl = f[c + P_L * PLANE];
             const dl = f[d + 4 * PLANE];
             if (tl > 0 || dl > 0) {
@@ -1980,7 +2022,17 @@ var WetWorld = class {
   bakeKey(key, all) {
     const lane = this.lanes[this.laneIndexOf(key)];
     if (lane.ghost) {
-      this.fadeGhostKey(key, lane, 1);
+      if (lane.ghost.trigger === "agent") {
+        const slot = this.slotOf(key);
+        if (slot >= 0) {
+          const b = this.slotBase(slot);
+          const cur = b + this.parity * SET_PLANES * PLANE;
+          this.f32.fill(0, cur + P_L * PLANE, cur + (P_L + 1) * PLANE);
+          this.f32.fill(0, b + P_DL * PLANE, b + (P_DL + 1) * PLANE);
+        }
+      } else {
+        this.fadeGhostKey(key, lane, 1);
+      }
       if (!this.hasGhostTracer(lane)) lane.ghost = null;
     }
     const [tx, ty] = this.tileXY(key);
@@ -2062,7 +2114,7 @@ var WetWorld = class {
       if (this.laneIndexOf(key) !== lane.index) continue;
       const tk = this.tileKeyOf(key);
       let out;
-      if (lane.ghost) {
+      if (lane.ghost && lane.ghost.trigger !== "agent") {
         const b = this.slotBase(this.slotOf(key));
         const cur = b + this.parity * SET_PLANES * PLANE;
         const savedP = this.f32.slice(cur + P_P0 * PLANE, cur + (P_P0 + MASS_CHANNELS) * PLANE);

package/dist/{chunk-5HP2VSAS.js → chunk-MSWLJI4G.js}

@@ -115,7 +115,7 @@ import {
   transformTextRect,
   translateMatrix,
   warpPresetMesh
-} from "./chunk-ZEI7ZEA4.js";
+} from "./chunk-Y2ISSVPH.js";
 import {
   bezierPathBounds,
   outlineStroke,