@pixerate/editor 0.271.0 → 0.272.1

package/dist/paint-editor/index.js

@@ -6,12 +6,13 @@ import {
   BRUSH_PATCH_PROPERTIES,
   BRUSH_SLIDERS,
   BRUSH_UNSET_PROPERTY,
+  GHOST_SLIDERS,
   brushEngineControls,
   createBrushLibraryToolProvider,
   mergeBrushPatch,
   multiColorSliders,
   patchBrushValue
-} from "../chunk-ININNHLM.js";
+} from "../chunk-NAHJV3O6.js";
 import {
   createStickerTools,
   describeStickerRef
@@ -19,7 +20,7 @@ import {
 import {
   BRUSH_PREVIEW_DARK_PAPER,
   brushPreviewsOnDark
-} from "../chunk-LETF75CA.js";
+} from "../chunk-CLB2I2FU.js";
 import {
   toVideoFfmpeg
 } from "../chunk-S2XPXA47.js";
@@ -34,7 +35,7 @@ import {
   resolveExternalAssets,
   serializeLayers,
   serializeLayersExternal
-} from "../chunk-B5W677L7.js";
+} from "../chunk-5HP2VSAS.js";
 import "../chunk-ADMRNWR7.js";
 import "../chunk-WJ4WQJCC.js";
 import {
@@ -117,7 +118,7 @@ import {
   wetPaperInput,
   wetPigmentOf,
   withStrokePath
-} from "../chunk-TNHDCP4R.js";
+} from "../chunk-ZEI7ZEA4.js";
 import {
   BRUSH_ID,
   BRUSH_PRESETS,
@@ -129,6 +130,7 @@ import {
   DEFAULT_BRISTLE,
   DEFAULT_BRUSH_ID,
   DEFAULT_DYNAMICS,
+  DEFAULT_GHOST,
   DEFAULT_IMPASTO,
   DEFAULT_LIGHT,
   DEFAULT_MULTI_COLOR,
@@ -168,6 +170,7 @@ import {
   normalizeBristle,
   normalizeBrushSpec,
   normalizeDynamics,
+  normalizeGhost,
   normalizeImpasto,
   normalizeLight,
   normalizeMultiColor,
@@ -180,7 +183,7 @@ import {
   readBrushSource,
   resolveBrush,
   usesPaintExchange
-} from "../chunk-KZI3YWKW.js";
+} from "../chunk-UXYCY3HP.js";
 import {
   STAMP_KINDS,
   StickersSlot,
@@ -228,7 +231,7 @@ import {
   normalizeWetParams,
   pigmentOf,
   wetSupport
-} from "../chunk-GSTSZPSR.js";
+} from "../chunk-N3SKPQEH.js";
 import "../chunk-W6JDUXP3.js";
 import {
   CoverageMap,
@@ -6390,12 +6393,27 @@ var PaintEditorController = class _PaintEditorController {
     })();
     const brush = this.strokeBrush(init);
     if (this.previewing && isWetBrush(brush)) throw new PaintEditorError(`Wet paint can't be previewed; the ${brush.name} brush paints wet media. Suggest it with a dry brush.`);
+    if (brush.ghost) {
+      if (brush.light.amount > 0) throw new PaintEditorError(`Ghost paint (${brush.name}) shares the wet light channel and can't emit light; set light.amount to 0 or ghost to null (set_brush).`);
+      if (isPaintEffectPaint(init.paint) || init.paint === void 0 && init.color === void 0 && Boolean(this.effectPaint)) {
+        throw new PaintEditorError(`Ghost paint (${brush.name}) needs a single colour to subtract as it fades, so it can't paint with an effect; set a solid colour (set_color) or pass color to paint_stroke.`);
+      }
+      if (brush.behavior.multicolor.mode !== "off") throw new PaintEditorError(`Ghost paint (${brush.name}) needs a single colour to subtract as it fades, so it can't use multi-colour paint; set behavior.multicolor.mode to "off" (set_brush).`);
+      const gCol = init.color === void 0 ? this.ownColour(init.brushId) ?? this.color : parseColor(init.color);
+      if (this.strokeGradient(init, brush, gCol)) throw new PaintEditorError(`Ghost paint (${brush.name}) needs a single colour to subtract as it fades, so it can't paint a gradient; set a solid colour (set_color) or pass color to paint_stroke.`);
+      if (Boolean(doc.light?.[layer.id]?.tiles.size) || Boolean(this.wet.world?.hasLane(layer.id) && this.wet.world.isLit(layer.id))) {
+        throw new PaintEditorError(`Layer "${layer.name}" holds light paint, and ghost paint shares the wet light channel; paint on another layer (add_layer) or clear the light first (clear_light).`);
+      }
+    }
     const effect = this.strokeEffect(init, brush, points);
     if (!points && init.paint === void 0 && effect?.source.map?.by === "path" && isWetBrush(brush)) {
       throw new PaintEditorError(`The ${brush.name} brush paints wet media, which can't follow a path that isn't known until the stroke ends; paint with a dry brush, set_effect_paint with by: "stroke", or give the points to paint_stroke.`);
     }
     if (brush.light.amount > 0) {
       if (brush.engine === "sticker") throw new PaintEditorError(`The ${brush.name} brush sprays stickers, which don't take light yet; paint light with a dab or particle light brush (glow-gel, neon-marker; list_brush_presets lists them), or set light.amount to 0 (set_brush).`);
+      if (Boolean(this.wet.world?.hasLane(layer.id) && this.wet.world.getGhost(layer.id)) || Boolean(this.wet.settings.get(layer.id)?.ghost)) {
+        throw new PaintEditorError(`Layer "${layer.name}" has ghost paint fading on it, which uses the wet light channel; paint light on another layer (add_layer), or finish the ghost first (dry_paint).`);
+      }
     }
     if (doc.liveStrokes?.[layer.id]) {
       const why = liveStrokeRefusal(brush);
@@ -6448,7 +6466,8 @@ var PaintEditorController = class _PaintEditorController {
         copies: [IDENTITY_AFFINE, ...copiesW].map(affineCopy),
         mask: init.maskStencils ? this.stencilSelection(init.maskStencils) : init.stencils !== false ? this.stencilSelection() : null,
         paint: effect ? null : wetGradient,
-        effect: effect?.pixels ?? null
+        effect: effect?.pixels ?? null,
+        speed: this.wet.speed
       });
       init = { ...init, seed: seedW, load };
       wet = { driver, surface: () => world.display(id).surface };
@@ -7370,7 +7389,11 @@ var PaintEditorController = class _PaintEditorController {
   /** Wet settings saved with the document (`null` when they are all defaults). */
   wetJSON() {
     const layers = {};
-    for (const [id, set] of this.wet.settings) if (findLayer(this.doc.layers, id)) layers[id] = { params: { ...set.params }, flow: { ...set.flow } };
+    for (const [id, set] of this.wet.settings) {
+      if (!findLayer(this.doc.layers, id)) continue;
+      const ghost = this.wet.world?.hasLane(id) ? this.wet.world.getGhost(id) : set.ghost ?? null;
+      layers[id] = { params: { ...set.params }, flow: { ...set.flow }, ...ghost ? { ghost } : {} };
+    }
     const flat = this.wet.tilt.angle === 0;
     if (!Object.keys(layers).length && flat) return void 0;
     return { tilt: { ...this.wet.tilt }, layers };
@@ -7387,7 +7410,8 @@ var PaintEditorController = class _PaintEditorController {
           continue;
         }
         const x = v;
-        this.wet.settings.set(id, { params: normalizeWetParams(x.params ?? {}), flow: normalizeFlow(x.flow ?? {}) });
+        const ghost = readWetGhost(x.ghost);
+        this.wet.settings.set(id, { params: normalizeWetParams(x.params ?? {}), flow: normalizeFlow(x.flow ?? {}), ...ghost ? { ghost } : {} });
       }
     }
   }
@@ -8874,6 +8898,16 @@ function clipToCanvas(rect, canvas) {
 function toEffectPaintPixels(p, pixels) {
   return { width: pixels.width, height: pixels.height, data: new Uint8ClampedArray(pixels.data), ...p.map?.by === "stroke" ? { map: p.map } : {} };
 }
+function readWetGhost(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const g = raw;
+  if (!Array.isArray(g.pigment) || g.pigment.length !== 4 || !g.pigment.every((x) => typeof x === "number" && Number.isFinite(x))) return null;
+  const remaining = typeof g.remaining === "number" && Number.isFinite(g.remaining) ? Math.max(0, Math.round(g.remaining)) : 0;
+  if (remaining <= 0) return null;
+  const total = typeof g.total === "number" && Number.isFinite(g.total) ? Math.max(1, Math.round(g.total)) : remaining;
+  const linger = typeof g.linger === "number" && Number.isFinite(g.linger) ? Math.max(0.5, Math.min(60, g.linger)) : 4;
+  return { pigment: [g.pigment[0], g.pigment[1], g.pigment[2], g.pigment[3]], remaining, total, linger };
+}
 
 // src/paint-editor/presence.ts
 var PaintPresence = class extends PresenceStore {
@@ -9796,7 +9830,7 @@ function createPaintWetTools(c) {
     {
       name: "get_wet_paint",
       title: "Get the wet paint",
-      description: "Reads the wet media: whether any paint is still wet, the simulation clock (steps), whether time is paused, its speed (steps per second), the canvas tilt, the kernel running it (typescript, wasm, wasm-threads with the thread count, and a message when it runs slower than it could, e.g. without cross-origin isolation), and each wet layer: wet cells, where the water is (wetBounds), live tiles, its settings and flow map. Also engine: Engine B, the GPU accelerator: WebGPU in browsers, Metal in the Swift editors (mode auto/off, state, reason, adapter, minTiles, activeTiles). Call it after wet strokes to see what is still wet.",
+      description: "Reads the wet media: whether any paint is still wet, the simulation clock (steps), whether time is paused, its speed (steps per second), the canvas tilt, the kernel running it (typescript, wasm, wasm-threads with the thread count, and a message when it runs slower than it could, e.g. without cross-origin isolation), and each wet layer: wet cells, where the water is (wetBounds), live tiles, its settings, flow map, and ghost: { remaining } (seconds of simulated time left when ghost paint is fading on the layer). Also engine: Engine B, the GPU accelerator: WebGPU in browsers, Metal in the Swift editors (mode auto/off, state, reason, adapter, minTiles, activeTiles). Call it after wet strokes to see what is still wet.",
       inputSchema: EMPTY2,
       annotations: { title: "Get the wet paint", ...READ3 },
       coordinates: { out: ["layers[].wetBounds", "layers[].flow.center"] },
@@ -12385,7 +12419,7 @@ 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, 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, ghost: GHOST_SLIDERS, stroke: STROKE_SLIDERS, sticker: STICKER_SLIDERS },
     pathStrokeTapers: PATH_STROKE_TAPERS,
     padSampleSizes: PAD_SAMPLE_SIZES,
     wetGpu: WET_GPU_OPTIONS,
@@ -12462,6 +12496,7 @@ export {
   DEFAULT_DPI,
   DEFAULT_DYNAMICS,
   DEFAULT_FLOW,
+  DEFAULT_GHOST,
   DEFAULT_IMPASTO,
   DEFAULT_LIGHT,
   DEFAULT_LIGHTING,
@@ -12484,6 +12519,7 @@ export {
   DryStroke,
   EFFECT_MAP_REPEATS,
   EFFECT_STRIP_HEIGHT,
+  GHOST_SLIDERS,
   GPU_LEAD,
   GRAIN_PATTERNS,
   GRAIN_TILE,
@@ -12692,6 +12728,7 @@ export {
   normalizeCanvas,
   normalizeDynamics,
   normalizeFlow,
+  normalizeGhost,
   normalizeHexColor,
   normalizeImpasto,
   normalizeLight,

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

@@ -153,7 +153,7 @@ export declare function guideOverlay(controller: PaintEditorController, drag?: {
     to: Point2;
     kind: GuideOverlayKind;
 }>;
-export { BRUSH_SLIDERS, brushEngineControls, multiColorSliders, patchBrushValue, type BrushEngineControls, type SliderControl } from './brush-controls.cjs';
+export { BRUSH_SLIDERS, brushEngineControls, GHOST_SLIDERS, multiColorSliders, patchBrushValue, type BrushEngineControls, type SliderControl } from './brush-controls.cjs';
 import type { SliderControl } from './brush-controls.cjs';
 export declare const PAPER_SLIDERS: readonly SliderControl[];
 /** Reads `a.b` from an object. */

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

@@ -153,7 +153,7 @@ export declare function guideOverlay(controller: PaintEditorController, drag?: {
     to: Point2;
     kind: GuideOverlayKind;
 }>;
-export { BRUSH_SLIDERS, brushEngineControls, multiColorSliders, patchBrushValue, type BrushEngineControls, type SliderControl } from './brush-controls.js';
+export { BRUSH_SLIDERS, brushEngineControls, GHOST_SLIDERS, multiColorSliders, patchBrushValue, type BrushEngineControls, type SliderControl } from './brush-controls.js';
 import type { SliderControl } from './brush-controls.js';
 export declare const PAPER_SLIDERS: readonly SliderControl[];
 /** Reads `a.b` from an object. */

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

@@ -27,7 +27,7 @@ import { type PaintGradientSource } from '../paint/gradient-paint.cjs';
 import { type EffectPaintPixels } from './effect-paint.cjs';
 import { type WetParams, type WetTilt } from '../paint/wet/model.cjs';
 import { type WetGpuProvider } from '../paint/wet/gpu.cjs';
-import { WetWorld, type WetBackendInfo, type WetPaperInput, type WetSnapshot, type WetWorldOptions } from '../paint/wet/world.cjs';
+import { WetWorld, type WetBackendInfo, type WetGhostState, type WetPaperInput, type WetSnapshot, type WetWorldOptions } from '../paint/wet/world.cjs';
 import { TiledSurface, type RasterRect } from '../raster/surface.cjs';
 import type { PaintBrush, WetMediumKind } from './brushes.cjs';
 import { type PenPoint, type StrokeCopy } from './engine.cjs';
@@ -60,6 +60,8 @@ export interface WetStrokeInit {
      * the water like any pigment.
      */
     effect?: EffectPaintPixels | null;
+    /** Simulation steps per second (for ghost fade countdown). */
+    speed?: number;
 }
 /**
  * One wet-brush stroke: pen samples → dabs → wet tool edits. Points are applied only while the
@@ -110,6 +112,7 @@ export declare const WET_MEDIUM_PARAMS: Readonly<Record<WetMediumKind, Partial<W
 export interface WetLayerSettings {
     params: WetParams;
     flow: WetFlowSpec;
+    ghost?: WetGhostState | null;
 }
 /** One wet layer as tools describe it. */
 export interface WetLayerInfo {
@@ -124,6 +127,10 @@ export interface WetLayerInfo {
     activeTiles: number;
     params: WetParams;
     flow: WetFlowSpec;
+    /** Active ghost fade on the layer (`remaining` seconds of simulated time), when one is fading. */
+    ghost?: {
+        remaining: number;
+    };
 }
 /** An event recorded with the clock it happened at (strokes are recorded separately), for replays. */
 export interface WetEvent {

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

@@ -27,7 +27,7 @@ import { type PaintGradientSource } from '../paint/gradient-paint.js';
 import { type EffectPaintPixels } from './effect-paint.js';
 import { type WetParams, type WetTilt } from '../paint/wet/model.js';
 import { type WetGpuProvider } from '../paint/wet/gpu.js';
-import { WetWorld, type WetBackendInfo, type WetPaperInput, type WetSnapshot, type WetWorldOptions } from '../paint/wet/world.js';
+import { WetWorld, type WetBackendInfo, type WetGhostState, type WetPaperInput, type WetSnapshot, type WetWorldOptions } from '../paint/wet/world.js';
 import { TiledSurface, type RasterRect } from '../raster/surface.js';
 import type { PaintBrush, WetMediumKind } from './brushes.js';
 import { type PenPoint, type StrokeCopy } from './engine.js';
@@ -60,6 +60,8 @@ export interface WetStrokeInit {
      * the water like any pigment.
      */
     effect?: EffectPaintPixels | null;
+    /** Simulation steps per second (for ghost fade countdown). */
+    speed?: number;
 }
 /**
  * One wet-brush stroke: pen samples → dabs → wet tool edits. Points are applied only while the
@@ -110,6 +112,7 @@ export declare const WET_MEDIUM_PARAMS: Readonly<Record<WetMediumKind, Partial<W
 export interface WetLayerSettings {
     params: WetParams;
     flow: WetFlowSpec;
+    ghost?: WetGhostState | null;
 }
 /** One wet layer as tools describe it. */
 export interface WetLayerInfo {
@@ -124,6 +127,10 @@ export interface WetLayerInfo {
     activeTiles: number;
     params: WetParams;
     flow: WetFlowSpec;
+    /** Active ghost fade on the layer (`remaining` seconds of simulated time), when one is fading. */
+    ghost?: {
+        remaining: number;
+    };
 }
 /** An event recorded with the clock it happened at (strokes are recorded separately), for replays. */
 export interface WetEvent {