@pixerate/editor 0.271.0 → 0.272.1

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

@@ -849,9 +849,13 @@ var SLOT_FLOATS = SLOT_PLANES * PLANE;
 var S2 = SLOT_SIDE;
 var SNAP_PLANES = SET_PLANES + MASS_CHANNELS;
 var noLight = () => new (0, _chunk474IQG74cjs.TiledSurface)(1, /* @__PURE__ */ new Map(), 0);
-function newLane(id, index, params, flow, flowStrength, base, light) {
+function cloneGhost(g) {
+  return g ? { pigment: [...g.pigment], remaining: g.remaining, total: g.total, linger: g.linger } : null;
+}
+function newLane(id, index, params, flow, flowStrength, base, light, ghost) {
   const l = _nullishCoalesce(light, () => ( noLight()));
-  return { id, index, params, flow, flowStrength, base, shaded: /* @__PURE__ */ new Map(), urgent: /* @__PURE__ */ new Set(), stamp: 1, display: null, shadedVersion: 0, displayKey: "", light: l, lit: l.tiles.size > 0, lightShaded: /* @__PURE__ */ new Map(), lightDisplay: null, lightKey: "" };
+  const g = cloneGhost(ghost);
+  return { id, index, params, flow, flowStrength, base, shaded: /* @__PURE__ */ new Map(), urgent: /* @__PURE__ */ new Set(), stamp: 1, display: null, shadedVersion: 0, displayKey: "", light: l, lit: !g && l.tiles.size > 0, ghost: g, lightShaded: /* @__PURE__ */ new Map(), lightDisplay: null, lightKey: "" };
 }
 var WetWorldError = class extends Error {
   constructor(message) {
@@ -1012,11 +1016,12 @@ var WetWorld = (_class = class {
       if (options.params) this.setParams(id, options.params);
       if (options.base) this.setBase(id, options.base);
       if (options.light) this.setLight(id, options.light);
+      if (options.ghost !== void 0) this.setGhost(id, options.ghost);
       return;
     }
     const index = this.lanes.indexOf(null);
     if (index < 0) throw new WetWorldError(`At most ${MAX_WET_LANES} layers can hold wet paint at once; dry one (dry_paint) first.`);
-    this.lanes[index] = newLane(id, index, normalizeWetParams(_nullishCoalesce(options.params, () => ( {})), DEFAULT_WET_PARAMS), _nullishCoalesce(options.flow, () => ( null)), options.flow ? _nullishCoalesce(options.flowStrength, () => ( 1)) : 0, _nullishCoalesce(options.base, () => ( new (0, _chunk474IQG74cjs.TiledSurface)(4, /* @__PURE__ */ new Map(), 0))), options.light);
+    this.lanes[index] = newLane(id, index, normalizeWetParams(_nullishCoalesce(options.params, () => ( {})), DEFAULT_WET_PARAMS), _nullishCoalesce(options.flow, () => ( null)), options.flow ? _nullishCoalesce(options.flowStrength, () => ( 1)) : 0, _nullishCoalesce(options.base, () => ( new (0, _chunk474IQG74cjs.TiledSurface)(4, /* @__PURE__ */ new Map(), 0))), options.light, options.ghost);
     this.pack(this.lanes[index]);
   }
   /** Drops a wet layer and its wet paint (nothing is baked). */
@@ -1089,17 +1094,46 @@ var WetWorld = (_class = class {
   }
   /** Whether a layer has light paint, under its wet paint or in it. */
   isLit(id) {
-    return this.laneOf(id).lit;
+    const l = this.laneOf(id);
+    return l.lit && !l.ghost;
   }
   /** Replaces the light paint under a layer's wet paint. */
   setLight(id, light) {
     const lane = this.laneOf(id);
     if (light === lane.light) return;
     lane.light = light;
-    if (light.tiles.size) lane.lit = true;
+    if (light.tiles.size && !lane.ghost) lane.lit = true;
     lane.lightShaded.clear();
     lane.stamp++;
   }
+  /** Active ghost paint state on the layer, or `null`. */
+  getGhost(id) {
+    return cloneGhost(this.laneOf(id).ghost);
+  }
+  /** Sets or clears a layer's active ghost paint state. */
+  setGhost(id, ghost) {
+    this.requireIdle();
+    const lane = this.laneOf(id);
+    lane.ghost = cloneGhost(ghost);
+    if (lane.ghost) lane.lit = false;
+  }
+  /**
+   * 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.
+   */
+  startGhost(id, pigment, linger, stepsPerSecond = 120) {
+    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);
+    }
+    const total = Math.max(1, Math.round(linger * stepsPerSecond / FREE_INTERVAL));
+    lane.ghost = { pigment: p, remaining: total, total, linger };
+    lane.lit = false;
+  }
   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);
@@ -1332,6 +1366,13 @@ var WetWorld = (_class = class {
     let woke = false;
     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;
+        const g = lane.ghost;
+        const amount = g.remaining <= 1 ? 1 : 1 / g.remaining;
+        g.remaining = Math.max(0, g.remaining - 1);
+        this.fadeGhost(lane.id, amount);
+      }
       const dead = this.active.filter((key) => {
         if (this.u32[lastBase + key] & FLAG_ALIVE) return false;
         const laneBase = this.laneIndexOf(key) * perLane;
@@ -1531,7 +1572,10 @@ var WetWorld = (_class = class {
   paint(id, rect, cov, water, pigment, field = null, light = 0) {
     if (!(water >= 0)) throw new WetWorldError(`water ${water} must be 0 or more.`);
     if (!(light >= 0)) throw new WetWorldError(`light ${light} must be 0 or more.`);
-    if (light > 0) this.laneOf(id).lit = true;
+    if (light > 0) {
+      const l = this.laneOf(id);
+      if (!l.ghost) l.lit = true;
+    }
     this.footprint(id, rect, cov, (c, w, x, y) => {
       const dw = Math.fround(water * w);
       if (dw > 0) this.addWaterAt(c, dw);
@@ -1683,12 +1727,12 @@ var WetWorld = (_class = class {
    * the paper as settled pigment, so water can move it again, and the same share of its light
    * paint (`light`) as settled light. Only where there is surface water.
    */
-  rewet(id, rect, cov, amount, paper) {
+  rewet(id, rect, cov, amount, paper, suspend = false) {
     const lane = this.laneOf(id);
     const pig = [0, 0, 0, 0];
     const tiles = new Map(lane.base.tiles);
     const written = /* @__PURE__ */ new Set();
-    const lightTiles = lane.lit ? new Map(lane.light.tiles) : null;
+    const lightTiles = lane.lit && !lane.ghost ? new Map(lane.light.tiles) : null;
     const lightWritten = /* @__PURE__ */ new Set();
     const scratch2 = new Uint8ClampedArray(4);
     this.footprint(
@@ -1701,7 +1745,7 @@ var WetWorld = (_class = class {
         if (!(a > 0)) return;
         const key = _chunk474IQG74cjs.tileKey.call(void 0, x >> 8, y >> 8);
         const li = (y & 255) * _chunk474IQG74cjs.TILE + (x & 255);
-        let lt = _optionalChain([lightTiles, 'optionalAccess', _19 => _19.get, 'call', _20 => _20(key)]);
+        let lt = _optionalChain([lightTiles, 'optionalAccess', _20 => _20.get, 'call', _21 => _21(key)]);
         if (lt && (_nullishCoalesce(lt.uniform, () => ( 1))) !== 0) {
           if (!lightWritten.has(key)) {
             const data = lt.data.length ? new Uint8ClampedArray(lt.data) : new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE).fill(_nullishCoalesce(lt.uniform, () => ( 0)));
@@ -1730,8 +1774,8 @@ var WetWorld = (_class = class {
         const clear = new Uint8ClampedArray([0, 0, 0, 0]);
         filmPixel(pig[0] * (1 - a), pig[1] * (1 - a), pig[2] * (1 - a), 0, clear, 0, paper, 0, scratch2, 0);
         tile.data.set(scratch2, i);
-        const d = this.single(c) + P_D0 * PLANE;
-        for (let q = 0; q < 3; q++) this.f32[d + q * PLANE] += Math.fround(pig[q] * a);
+        const into = suspend ? c + P_P0 * PLANE : this.single(c) + P_D0 * PLANE;
+        for (let q = 0; q < 3; q++) this.f32[into + q * PLANE] += Math.fround(pig[q] * a);
       },
       false
     );
@@ -1752,6 +1796,114 @@ var WetWorld = (_class = class {
       this.setLight(id, new (0, _chunk474IQG74cjs.TiledSurface)(1, lightTiles, 0));
     }
   }
+  /**
+   * Subtracts `amount` (0..1) of a ghost lane's remaining tracer (`P_L`, `P_DL`) and proportional
+   * ghost pigment (`lane.ghost.pigment`) across all live tiles of `id`. Speeds up in cells that
+   * are nearly dry so drying paint never pops. Clears the lane's `ghost` state once no tracer remains.
+   */
+  fadeGhost(id, amount) {
+    this.requireIdle();
+    const lane = this.laneOf(id);
+    if (!lane.ghost) return;
+    const keys = this.active.filter((k) => this.laneIndexOf(k) === lane.index);
+    let anyRemaining = false;
+    for (const key of keys) {
+      if (this.fadeGhostKey(key, lane, amount)) anyRemaining = true;
+    }
+    if (!anyRemaining || amount >= 1 - 1e-6) lane.ghost = null;
+    this.refreshHalos();
+  }
+  /** Whether any live tile of `lane` still holds ghost tracer (`P_L > 0` or `P_DL > 0`). */
+  hasGhostTracer(lane) {
+    const f = this.f32;
+    for (const key of this.active) {
+      if (this.laneIndexOf(key) !== lane.index) continue;
+      const b = this.slotBase(this.slotOf(key));
+      const cur = b + this.parity * SET_PLANES * PLANE;
+      for (let y = 1; y <= WET_TILE; y++) {
+        for (let x = 1; x <= WET_TILE; x++) {
+          const c = y * S2 + x;
+          if (f[cur + P_L * PLANE + c] > 0 || f[b + P_DL * PLANE + c] > 0) return true;
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Fades ghost tracer and pigment in one slot by `amount` (0..1). Returns whether any tracer
+   * remains in the slot.
+   */
+  fadeGhostKey(key, lane, amount) {
+    if (!lane.ghost) return false;
+    const pig = lane.ghost.pigment;
+    const slot = this.slotOf(key);
+    if (slot < 0) return false;
+    const b = this.slotBase(slot);
+    const cur = b + this.parity * SET_PLANES * PLANE;
+    const f = this.f32;
+    const baseAmt = Math.min(1, Math.max(0, amount));
+    let remainingTracer = false;
+    let yMin = WET_TILE + 1;
+    let yMax = 0;
+    for (let y = 1; y <= WET_TILE; y++) {
+      for (let x = 1; x <= WET_TILE; x++) {
+        const c = y * S2 + x;
+        const tl = f[cur + P_L * PLANE + c];
+        const dl = f[b + P_DL * PLANE + c];
+        if (!(tl > 0 || dl > 0)) continue;
+        const water = f[cur + P_RHO * PLANE + c] + f[cur + P_SW * PLANE + c];
+        const dryFade = water <= DRY_EPS ? 1 : water < 0.02 ? (1 - water / 0.02) * 0.5 : 0;
+        const a = baseAmt >= 1 - 1e-6 ? 1 : Math.min(1, Math.max(baseAmt, dryFade));
+        if (!(a > 0)) {
+          remainingTracer = true;
+          continue;
+        }
+        if (y < yMin) yMin = y;
+        if (y > yMax) yMax = y;
+        if (tl > 0) {
+          const done = a >= 1 || tl * (1 - a) <= 1e-7;
+          const dt = done ? tl : Math.fround(tl * a);
+          const tNew = done ? 0 : Math.fround(tl - dt);
+          f[cur + P_L * PLANE + c] = tNew;
+          for (let q = 0; q < 4; q++) {
+            const idx = cur + (P_P0 + q) * PLANE + c;
+            const eps = Math.max(1e-3, pig[q] * 2e-4);
+            const v = Math.max(0, Math.fround(f[idx] - Math.fround(dt * pig[q])));
+            f[idx] = tNew === 0 && v <= eps ? 0 : v;
+          }
+          if (tNew > 0) remainingTracer = true;
+        }
+        if (dl > 0) {
+          const done = a >= 1 || dl * (1 - a) <= 1e-7;
+          const dd = done ? dl : Math.fround(dl * a);
+          const dNew = done ? 0 : Math.fround(dl - dd);
+          f[b + P_DL * PLANE + c] = dNew;
+          for (let q = 0; q < 4; q++) {
+            const idx = b + (P_D0 + q) * PLANE + c;
+            const eps = Math.max(1e-3, pig[q] * 2e-4);
+            const v = Math.max(0, Math.fround(f[idx] - Math.fround(dd * pig[q])));
+            f[idx] = dNew === 0 && v <= eps ? 0 : v;
+          }
+          if (dNew > 0) remainingTracer = true;
+        }
+        if (f[cur + P_L * PLANE + c] === 0 && f[b + P_DL * PLANE + c] === 0) {
+          for (let q = 0; q < 4; q++) {
+            const eps = Math.max(1e-3, pig[q] * 2e-4);
+            const pi = cur + (P_P0 + q) * PLANE + c;
+            if (f[pi] <= eps) f[pi] = 0;
+            const di = b + (P_D0 + q) * PLANE + c;
+            if (f[di] <= eps) f[di] = 0;
+          }
+        }
+      }
+    }
+    if (yMax >= yMin) {
+      lane.urgent.add(this.tileKeyOf(key));
+      this.gpuDirtySlot(slot, yMin, yMax);
+      lane.stamp++;
+    }
+    return remainingTracer;
+  }
   /**
    * Dries wet paint at once (everything settles where it is, the water goes): in `rect`, or the
    * whole layer. Whole tiles that end up dry are baked into the base and freed. Returns the
@@ -1779,10 +1931,28 @@ var WetWorld = (_class = class {
         continue;
       }
       const f = this.f32;
+      const pig = _nullishCoalesce(_optionalChain([lane, 'access', _22 => _22.ghost, 'optionalAccess', _23 => _23.pigment]), () => ( null));
       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) {
+            const tl = f[c + P_L * PLANE];
+            const dl = f[d + 4 * PLANE];
+            if (tl > 0 || dl > 0) {
+              f[c + P_L * PLANE] = 0;
+              f[d + 4 * PLANE] = 0;
+              for (let q = 0; q < 4; q++) {
+                const eps = Math.max(1e-3, pig[q] * 2e-4);
+                const pi = c + (P_P0 + q) * PLANE;
+                const pv = Math.max(0, Math.fround(f[pi] - Math.fround(tl * pig[q])));
+                f[pi] = pv <= eps ? 0 : pv;
+                const di = d + q * PLANE;
+                const dv = Math.max(0, Math.fround(f[di] - Math.fround(dl * pig[q])));
+                f[di] = dv <= eps ? 0 : dv;
+              }
+            }
+          }
           for (let q = 0; q < MASS_CHANNELS; q++) {
             f[d + q * PLANE] += f[c + (P_P0 + q) * PLANE];
             f[c + (P_P0 + q) * PLANE] = 0;
@@ -1797,6 +1967,7 @@ var WetWorld = (_class = class {
       bounds = unionRect(bounds, { x: x0, y: y0, width: x1 - x0, height: y1 - y0 });
       this.markEdited(lane, x0, y0, x1, y1);
     }
+    if (lane.ghost && !this.hasGhostTracer(lane)) lane.ghost = null;
     this.syncList();
     this.refreshHalos();
     lane.stamp++;
@@ -1808,10 +1979,14 @@ var WetWorld = (_class = class {
    */
   bakeKey(key, all) {
     const lane = this.lanes[this.laneIndexOf(key)];
+    if (lane.ghost) {
+      this.fadeGhostKey(key, lane, 1);
+      if (!this.hasGhostTracer(lane)) lane.ghost = null;
+    }
     const [tx, ty] = this.tileXY(key);
     const tk = _chunk474IQG74cjs.tileKey.call(void 0, tx, ty);
     let lightChanged = false;
-    if (lane.lit) {
+    if (lane.lit && !lane.ghost) {
       const lout = this.shadeLightSlot(key, _nullishCoalesce(lane.light.tiles.get(tk), () => ( null)), all ? "bake-all" : "bake");
       if (lout) {
         const tiles2 = new Map(lane.light.tiles);
@@ -1822,7 +1997,7 @@ var WetWorld = (_class = class {
         lightChanged = true;
       }
     }
-    const src = _nullishCoalesce(_optionalChain([lane, 'access', _21 => _21.base, 'access', _22 => _22.tiles, 'access', _23 => _23.get, 'call', _24 => _24(tk), 'optionalAccess', _25 => _25.data]), () => ( null));
+    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 out = this.shadeSlot(key, src, all ? "bake-all" : "bake");
     if (!out) return lightChanged;
     const tiles = new Map(lane.base.tiles);
@@ -1857,7 +2032,8 @@ var WetWorld = (_class = class {
     const out = src ? new Uint8ClampedArray(src) : new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * 4);
     const w = Math.min(WET_TILE, this.width - tx * WET_TILE);
     const h = Math.min(WET_TILE, this.height - ty * WET_TILE);
-    const lit = this.lanes[this.laneIndexOf(key)].lit;
+    const lane = this.lanes[this.laneIndexOf(key)];
+    const lit = lane.lit && !lane.ghost;
     const changed = shadeTile(
       this.f32,
       PLANE,
@@ -1885,7 +2061,38 @@ var WetWorld = (_class = class {
     for (const key of this.active) {
       if (this.laneIndexOf(key) !== lane.index) continue;
       const tk = this.tileKeyOf(key);
-      const out = this.shadeSlot(key, _nullishCoalesce(_optionalChain([lane, 'access', _26 => _26.base, 'access', _27 => _27.tiles, 'access', _28 => _28.get, 'call', _29 => _29(tk), 'optionalAccess', _30 => _30.data]), () => ( null)), "bake-all");
+      let out;
+      if (lane.ghost) {
+        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);
+        const savedD = this.f32.slice(b + P_D0 * PLANE, b + (P_D0 + MASS_CHANNELS) * PLANE);
+        const pig = lane.ghost.pigment;
+        for (let y = 1; y <= WET_TILE; y++) {
+          for (let x = 1; x <= WET_TILE; x++) {
+            const c = y * S2 + x;
+            const tl = this.f32[cur + P_L * PLANE + c];
+            const dl = this.f32[b + P_DL * PLANE + c];
+            if (!(tl > 0 || dl > 0)) continue;
+            this.f32[cur + P_L * PLANE + c] = 0;
+            this.f32[b + P_DL * PLANE + c] = 0;
+            for (let q = 0; q < 4; q++) {
+              const eps = Math.max(1e-3, pig[q] * 2e-4);
+              const pi = cur + (P_P0 + q) * PLANE + c;
+              const pv = Math.max(0, Math.fround(this.f32[pi] - Math.fround(tl * pig[q])));
+              this.f32[pi] = pv <= eps ? 0 : pv;
+              const di = b + (P_D0 + q) * PLANE + c;
+              const dv = Math.max(0, Math.fround(this.f32[di] - Math.fround(dl * pig[q])));
+              this.f32[di] = dv <= eps ? 0 : dv;
+            }
+          }
+        }
+        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");
+        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");
+      }
       if (!out) continue;
       const t = _chunk474IQG74cjs.finishTile.call(void 0, out, 4, 0);
       if (t) tiles.set(tk, t);
@@ -1897,7 +2104,7 @@ var WetWorld = (_class = class {
   bakedLight(id) {
     this.requireIdle();
     const lane = this.laneOf(id);
-    if (!lane.lit) return lane.light;
+    if (!lane.lit || lane.ghost) return lane.light;
     const tiles = new Map(lane.light.tiles);
     for (const key of this.active) {
       if (this.laneIndexOf(key) !== lane.index) continue;
@@ -2008,14 +2215,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', _31 => _31.shaded, 'access', _32 => _32.get, 'call', _33 => _33(this.tileKeyOf(k)), 'optionalAccess', _34 => _34.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', _35 => _35.shaded, 'access', _36 => _36.get, 'call', _37 => _37(this.tileKeyOf(a)), 'optionalAccess', _38 => _38.stamp]), () => ( 0))) - (_nullishCoalesce(_optionalChain([lane, 'access', _39 => _39.shaded, 'access', _40 => _40.get, 'call', _41 => _41(this.tileKeyOf(b)), 'optionalAccess', _42 => _42.stamp]), () => ( 0))));
+    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 changed = [];
     let done = 0;
     for (const key of stale) {
       if (done >= maxTiles) break;
       const tk = this.tileKeyOf(key);
-      const src = _nullishCoalesce(_optionalChain([lane, 'access', _43 => _43.base, 'access', _44 => _44.tiles, 'access', _45 => _45.get, 'call', _46 => _46(tk), 'optionalAccess', _47 => _47.data]), () => ( null));
+      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 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 })) });
@@ -2045,14 +2252,14 @@ var WetWorld = (_class = class {
    */
   lightDisplay(id) {
     const lane = this.laneOf(id);
-    if (!lane.lit) return null;
+    if (!lane.lit || lane.ghost) return null;
     const keys = this.active.filter((k) => this.laneIndexOf(k) === lane.index);
     let changed = false;
     const live = /* @__PURE__ */ new Set();
     for (const key2 of keys) {
       const tk = this.tileKeyOf(key2);
       live.add(tk);
-      if (_optionalChain([lane, 'access', _48 => _48.lightShaded, 'access', _49 => _49.get, 'call', _50 => _50(tk), 'optionalAccess', _51 => _51.stamp]) === lane.stamp) continue;
+      if (_optionalChain([lane, 'access', _56 => _56.lightShaded, 'access', _57 => _57.get, 'call', _58 => _58(tk), 'optionalAccess', _59 => _59.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 });
@@ -2250,7 +2457,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', _52 => _52.shaded, 'access', _53 => _53.get, 'call', _54 => _54(this.tileKeyOf(k)), 'optionalAccess', _55 => _55.stamp]) !== lane.stamp);
+    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);
     if (!stale.length) return { ...this.display(id, 0), gpu: true };
     let tiles;
     const stamp = lane.stamp;
@@ -2258,7 +2465,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', _56 => _56.tiles, 'access', _57 => _57.get, 'call', _58 => _58(this.tileKeyOf(k)), 'optionalAccess', _59 => _59.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', _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]]);
     } catch (e) {
       this.gpuStop(`Wet paint stopped using the GPU (${e.message}).`);
       return { ...this.display(id, maxCpuTiles), gpu: false };
@@ -2291,7 +2498,7 @@ var WetWorld = (_class = class {
       slots.set(key, { planes, last: this.u32[(this.layout.last >> 2) + key] });
       bytes += planes.byteLength;
     }
-    const lanes = this.lanes.filter((l) => Boolean(l)).map((l) => ({ id: l.id, index: l.index, params: { ...l.params }, flow: l.flow, flowStrength: l.flowStrength, base: l.base, light: l.light, lit: l.lit }));
+    const lanes = this.lanes.filter((l) => Boolean(l)).map((l) => ({ id: l.id, index: l.index, params: { ...l.params }, flow: l.flow, flowStrength: l.flowStrength, base: l.base, light: l.light, lit: l.lit, ghost: cloneGhost(l.ghost) }));
     return { clock: this.clock, tilt: { ...this.tilt }, lanes, slots, bytes };
   }
   /** Puts a snapshot back exactly (the simulation then continues as it would have). */
@@ -2301,8 +2508,8 @@ var WetWorld = (_class = class {
     this.lanes.fill(null);
     this.tilt = { ...snap.tilt };
     for (const l of snap.lanes) {
-      const lane = newLane(l.id, l.index, { ...l.params }, l.flow, l.flowStrength, l.base, l.light);
-      lane.lit = lane.lit || Boolean(l.lit);
+      const lane = newLane(l.id, l.index, { ...l.params }, l.flow, l.flowStrength, l.base, l.light, l.ghost);
+      lane.lit = !lane.ghost && (lane.lit || Boolean(l.lit));
       this.lanes[l.index] = lane;
       this.pack(this.lanes[l.index]);
     }
@@ -2437,8 +2644,8 @@ function normalizeFlow(raw = {}, base = DEFAULT_FLOW) {
 }
 function flowField(spec, width, height) {
   const k = FLOW_ACCEL;
-  const cx = _nullishCoalesce(_optionalChain([spec, 'access', _60 => _60.center, 'optionalAccess', _61 => _61.x]), () => ( width / 2));
-  const cy = _nullishCoalesce(_optionalChain([spec, 'access', _62 => _62.center, 'optionalAccess', _63 => _63.y]), () => ( height / 2));
+  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 r0 = Math.max(width, height) / 2;
   switch (spec.kind) {
     case "none":
@@ -2901,7 +3108,7 @@ var UNIFORM = 64;
 var STORAGE = 128;
 function findWebGpu() {
   const nav = globalThis.navigator;
-  return _nullishCoalesce(_optionalChain([nav, 'optionalAccess', _64 => _64.gpu]), () => ( null));
+  return _nullishCoalesce(_optionalChain([nav, 'optionalAccess', _72 => _72.gpu]), () => ( null));
 }
 async function createWetGpuEngine(gpu = findWebGpu()) {
   const no = (reason, adapter2 = null) => ({ engine: null, support: { supported: false, reason, adapter: adapter2, maxSlots: 0 } });
@@ -2913,7 +3120,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', _65 => _65.info, 'optionalAccess', _66 => _66.vendor]), _optionalChain([adapter, 'access', _67 => _67.info, 'optionalAccess', _68 => _68.architecture])].filter(Boolean).join(" ") || null;
+  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 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);
@@ -2933,27 +3140,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', _69 => _69.destroy, 'optionalCall', _70 => _70()]);
+    _optionalChain([device, 'access', _77 => _77.destroy, 'optionalCall', _78 => _78()]);
     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', _71 => _71.destroy, 'call', _72 => _72()]);
+  _optionalChain([engine, 'optionalAccess', _79 => _79.destroy, 'call', _80 => _80()]);
   return support;
 }
 async function pipeline(device, code, label) {
-  _optionalChain([device, 'access', _73 => _73.pushErrorScope, 'optionalCall', _74 => _74("validation")]);
+  _optionalChain([device, 'access', _81 => _81.pushErrorScope, 'optionalCall', _82 => _82("validation")]);
   const module = device.createShaderModule({ code, label });
-  const info = await _optionalChain([module, 'access', _75 => _75.getCompilationInfo, 'optionalCall', _76 => _76()]);
-  const errors = _nullishCoalesce(_optionalChain([info, 'optionalAccess', _77 => _77.messages, 'access', _78 => _78.filter, 'call', _79 => _79((m) => m.type === "error")]), () => ( []));
+  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")]), () => ( []));
   if (errors.length) {
-    await _optionalChain([device, 'access', _80 => _80.popErrorScope, 'optionalCall', _81 => _81()]);
+    await _optionalChain([device, 'access', _88 => _88.popErrorScope, 'optionalCall', _89 => _89()]);
     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', _82 => _82.popErrorScope, 'optionalCall', _83 => _83()]);
+  const err = await _optionalChain([device, 'access', _90 => _90.popErrorScope, 'optionalCall', _91 => _91()]);
   if (err) throw new Error(`${label}: ${err.message}`);
   return p;
 }
@@ -2979,8 +3186,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', _84 => _84.lost, 'optionalAccess', _85 => _85.then, 'call', _86 => _86((info) => {
-      this.lostReason = _optionalChain([info, 'optionalAccess', _87 => _87.message]) || _optionalChain([info, 'optionalAccess', _88 => _88.reason]) || "the GPU device was lost";
+    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";
     })]);
   }
   
@@ -3014,7 +3221,7 @@ var WetGpuEngine = (_class3 = class _WetGpuEngine {
   }
   /** Bytes of GPU memory in use. */
   memoryBytes() {
-    return this.state.size + this.jobs.size + (_nullishCoalesce(_optionalChain([this, 'access', _89 => _89.srcTiles, 'optionalAccess', _90 => _90.size]), () => ( 0))) + (_nullishCoalesce(_optionalChain([this, 'access', _91 => _91.outTiles, 'optionalAccess', _92 => _92.size]), () => ( 0))) * 2;
+    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;
   }
   /** Slots the state buffer holds now. */
   get capacity() {
@@ -3163,9 +3370,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', _93 => _93.srcTiles, 'optionalAccess', _94 => _94.destroy, 'call', _95 => _95()]);
-      _optionalChain([this, 'access', _96 => _96.outTiles, 'optionalAccess', _97 => _97.destroy, 'call', _98 => _98()]);
-      _optionalChain([this, 'access', _99 => _99.outRead, 'optionalAccess', _100 => _100.destroy, 'call', _101 => _101()]);
+      _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()]);
       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" });
@@ -3219,7 +3426,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', _102 => _102.destroy, 'call', _103 => _103()]);
+    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()]);
     this.device.destroy();
   }
 }, _class3);

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

@@ -27,7 +27,7 @@ import {
   resolveEngine,
   summarizeBrushSource,
   withKeptIssues
-} from "./chunk-KZI3YWKW.js";
+} from "./chunk-UXYCY3HP.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", "motion", "colour"];
+var UNSETTABLE_BRUSH_FACETS = ["description", "tags", "medium", "variety", "marks", "dynamics", "behaviour", "light", "ghost", "motion", "colour"];
 var BRUSH_UNSET_PROPERTY = {
   type: "array",
   minItems: 1,
@@ -1117,9 +1117,13 @@ 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 }
 ];
+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 }
+];
 function brushEngineControls(brush) {
   const c = engineControls(brush);
-  const wetPaint = brush.engine === "wet" && brush.wet?.tool === "paint";
+  const wetPaint = brush.engine === "wet" && brush.wet?.tool === "paint" && !brush.ghost;
   if (!c || !(wetPaint || ["dab", "mixer", "particle", "bristle", "impasto"].includes(brush.engine))) return c;
   const extra = brush.engine === "impasto" ? [{ path: "impasto.rim", label: "Rim", min: 0, max: 1, step: 0.01 }, { path: "impasto.clarity", label: "Clarity", min: 0, max: 1, step: 0.01 }] : [];
   return { ...c, sliders: [...c.sliders, LIGHT_SLIDER, ...extra], light: true };
@@ -1203,6 +1207,7 @@ function engineControls(brush) {
       };
     case "wet": {
       const tool = brush.wet?.tool ?? "paint";
+      const ghost = tool === "paint" && Boolean(brush.ghost);
       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 },
@@ -1210,12 +1215,12 @@ 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 },
-        ...PICKUP_SLIDERS
+        ...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 }
       ] : [{ path: "wet.strength", label: "Strength", min: 0, max: 1, step: 0.01 }];
-      return { title: "Wet brush", sliders, mixingPath: tool === "paint" ? "behavior.mixing" : null, dirty: tool === "paint", multicolor: false, load: tool === "paint", wetTool: true };
+      return { title: "Wet brush", sliders, mixingPath: tool === "paint" ? "behavior.mixing" : null, dirty: tool === "paint" && !ghost, multicolor: false, load: tool === "paint" && !ghost, wetTool: true };
     }
     case "blender":
       return {
@@ -1284,6 +1289,7 @@ export {
   createBrushLibraryTools,
   createBrushLibraryToolProvider,
   BRUSH_SLIDERS,
+  GHOST_SLIDERS,
   brushEngineControls,
   multiColorSliders,
   patchBrushValue