@pixerate/editor 0.270.0 → 0.272.0

package/dist/video-editor/index.js

@@ -149,7 +149,7 @@ import {
   videoTransitionEase,
   videoValueAt,
   videoWipeRect
-} from "../chunk-MWUZCEFT.js";
+} from "../chunk-S2XPXA47.js";
 import {
   namedWithSuggestion
 } from "../chunk-EUKY4KFX.js";
@@ -160,7 +160,7 @@ import {
   effectTemplateTools,
   fillEffectTemplate
 } from "../chunk-DHQPRKXF.js";
-import "../chunk-EHLOCVWB.js";
+import "../chunk-T2URHAJX.js";
 import {
   CAMERA_MOVE_MAX_MS,
   EffectsSlot,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pixerate/editor",
-  "version": "0.270.0",
+  "version": "0.272.0",
   "description": "UI-agnostic rich text and media editing core library",
   "author": "Pixerate",
   "license": "MIT",

package/skills/pixerate-brushes/SKILL.md

@@ -20,6 +20,7 @@ built-in presets (read-only) and the user's brushes, shared by every editor that
 | Dynamics | Pen feel: pressure to size and opacity, smoothing, tilt, velocity, jitter (`sizeJitter`, `angleJitter` for rotation, `opacityJitter`, `scatter`), rotation, `count` (dabs per spacing step, each jittered) and `flip` (mirror dabs at random: `x`, `y`, `xy`). |
 | Behaviour | `surface` `dry`, `wet` (`wet` settings) or `thick` (`thick` impasto settings); paper `grain`; `exchange` (pick-up and mix; a `reservoir` makes a Mixer Brush); tool `strength`. |
 | Light | Light the brush gives off (`amount`), plus suggested layer `spill` and `glow`. |
+| Ghost | On wet paint (`behaviour.surface: "wet"`): `linger` (0.5..60 s before the brush's own colour fades away) and `smear` (0..1, how much it lifts and drags the paint it crosses). Presets `ghost-wash`, `ghost-gouache`, `ghost-oil` and `invisible-ink`. |
 | Motion | Animation after painting (live effect paint, particle `waveSpeed`). |
 | Colour | A `default` colour, a `palette` of up to 16, `own` (always its own colour). Each is a hex or `rgba()` colour, a light / dark pair `{ light, dark }`, a gradient or effect paint. A gradient default is always painted; a solid or light / dark default becomes the editor's colour when the brush is chosen (unless the user locked theirs), resolved for the colour scheme. Canvas strokes and vector brushstrokes take it too, when they are given no colour. Canvas and vector have the same lock (`canvas.setColorLocked`, `vector.setColorLocked`), and a canvas colour taken from a light / dark default follows the scheme like the paint editor's; vector strokes already made keep theirs. |
 

package/skills/pixerate-paint-editor/SKILL.md

@@ -142,10 +142,7 @@ Which facet sets which engine setting: [references/brush-facets.md](references/b
 
 ## Wet media
 
-Watercolour, gouache and wet oil run on a fluid simulation: lay washes light to dark, let them
-flow (`advance_wet_paint`), dry them (`dry_paint`) before glazing. Nothing moves for an agent
-until you advance or dry it, and saving dries the paint. Load `pixerate-paint-watercolour`, and
-read [references/wet-media.md](references/wet-media.md) for the engine and the wet tools.
+Watercolour, gouache and wet oil run on a fluid simulation: lay washes light to dark, let them flow (`advance_wet_paint`), dry them (`dry_paint`) before glazing. Nothing moves for an agent until you advance or dry it, and saving dries the paint. Load `pixerate-paint-watercolour`, and read [references/wet-media.md](references/wet-media.md) for the engine and the wet tools. **Ghost paint and invisible ink** (`ghost` facet: `ghost-wash`, `ghost-gouache`, `ghost-oil`, `invisible-ink`) mix and flow while wet, then fade without leaving their own colour, leaving only a smear in the paint they touched: read [references/ghost.md](references/ghost.md).
 
 ## Oils and thick paint
 
@@ -235,7 +232,7 @@ When to use which:
 | The effect in a wash that flows, or in thick paint | `set_effect_paint` and a watercolour, gouache, oil or impasto brush |
 | The effect inside an exact shape, unchanged by water | Paint the shape, dry it, then `fill_layer_with_effect` with `lockTransparency: true` |
 | The effect over the whole sheet | `set_paper_effect` or `add_effect_layer` |
-| A pattern that follows the stroke, or paint that moves | `map: { by: "stroke" }`, `live: true` on a stroke layer |
+| A pattern that follows the stroke, or paint that moves | `map: { by: "stroke" }` (bends any effect as a strip), or `map: { by: "path" }` for effects with a path control (`accepts: ["path"]`: beams, trails, signatures); `live: true` on a stroke layer |
 
 ## Canvas-hosted layer
 
@@ -295,7 +292,7 @@ Listing, saving, sharing and previewing brushes are the brush library's tools (`
 | Tool | Use |
 | --- | --- |
 | `get_brush` | Read a brush as facets (`brush`), or the active brush as edited (no `id`), with the `engine` and `category` it paints with, `builtin` (an unchanged preset) and `strokePaint` (what its next stroke paints). Read before changing a brush you did not build. |
-| `set_brush` | Choose the active brush (`id`, from `list_brush_presets`) and / or lay facets over it: `tip`, `marks`, `dynamics`, `behaviour`, `light`, `motion`, `colour` (objects merge, lists replace; marks of another kind replace the marks), `unset` facets to drop. Editor state, not saved: `create_brush` stores a brush. Returns `brush` (facets), `engine` and `problems` (values clamped). The old flat fields (`particle`, `impasto`, `behavior`…) are refused. |
+| `set_brush` | Choose the active brush (`id`, from `list_brush_presets`) and / or lay facets over it: `tip`, `marks`, `dynamics`, `behaviour`, `light`, `ghost`, `motion`, `colour` (objects merge, lists replace; marks of another kind replace the marks), `unset` facets to drop. Editor state, not saved: `create_brush` stores a brush. Returns `brush` (facets), `engine` and `problems` (values clamped). The old flat fields (`particle`, `impasto`, `behavior`…) are refused. |
 
 ### Colour
 
@@ -345,7 +342,7 @@ Listing, saving, sharing and previewing brushes are the brush library's tools (`
 
 | Tool | Use |
 | --- | --- |
-| `get_wet_paint` | Read the wet paint: `wet`, the clock, `paused`, `speed`, `tilt`, the kernel (`backend`, `message` when it runs slower than it could, e.g. on one thread because the page is not cross-origin isolated (COOP / COEP)), the GPU accelerator (`engine`) and each wet layer (`wetCells`, `wetBounds`, `activeTiles`, settings, flow map). Call after wet strokes. |
+| `get_wet_paint` | Read the wet paint: `wet`, the clock, `paused`, `speed`, `tilt`, the kernel (`backend`, `message` when it runs slower than it could, e.g. on one thread because the page is not cross-origin isolated (COOP / COEP)), the GPU accelerator (`engine`) and each wet layer (`wetCells`, `wetBounds`, `activeTiles`, settings, flow map, and `ghost: { remaining }` while ghost paint is fading). Call after wet strokes. |
 | `advance_wet_paint` | Let time pass: `steps` (120 = one second at the default speed) or `seconds`. The paint spreads, blooms, runs and dries. Not an undo step. Returns `steps`, `clock`, `stillWet`, `layers`. Call after a group of wet strokes, before `render_preview`. |
 | `dry_paint` | Dry wet paint at once where it is (one layer with `layerId` or all, optionally inside `rect`). One undo step. Returns `dried` (layer ids and rectangles) and `stillWet`. Dry before glazing over a wash. |
 | `wet_paper` | Pre-wet the paper with clear water over `rect` (default the canvas) on a layer, `amount` 0..1, for wet-in-wet. One undo step. Returns the rectangle and `wet`. Then paint into it. |
@@ -394,7 +391,7 @@ Listing, saving, sharing and previewing brushes are the brush library's tools (`
 | `set_paper_effect` | Draw a generator over the paper (`values`, `opacity`, `blend` default `multiply`, `time`); `effect: null` removes it. One undo step. Returns the effect paper. |
 | `add_effect_layer` | Add a layer drawn by a generator, overlay or title effect (`values`, `name`, `aboveId`, `opacity`, `blend`, `time`); it becomes active. Returns the layer and its effect. |
 | `fill_layer_with_effect` | Composite a generator, overlay or title effect onto a layer (`layerId`, `values`, `opacity`, `lockTransparency`, `time`). One undo step. Returns the layer id and the effect. |
-| `set_effect_paint` | Paint with a generator, overlay or title effect (`effect`, `values`, `time` ms default 0): rendered once at the canvas size, strokes take each pixel's colour from it; `map` `{ by: "stroke", length, repeat }` lays it along each stroke; `live` keeps it playing on stroke layers. Call after `describe_effect`, then `paint_stroke`. Editor state, not an undo step. Returns `effectPaint`. |
+| `set_effect_paint` | Paint with a generator, overlay or title effect (`effect`, `values`, `time` ms default 0): rendered once at the canvas size, strokes take each pixel's colour from it; `map` `{ by: "stroke", length, repeat }` bends a strip along each stroke, or `{ by: "path" }` passes the stroke's centreline to an effect with a path control (`format: "svg-path"`, `accepts: ["path"]`); `live` keeps it playing on stroke layers. Call after `describe_effect`, then `paint_stroke`. Editor state, not an undo step. Returns `effectPaint`. |
 | `set_effect_playback` | Play or pause live effect paint in the view (`playing`) and cap its frame rate (`fps` 1..60). Editor state. Returns `playing`, `fps`, `time` and `animation` (what plays, or null). Export a moment with `export_image` / `export_psd` `time`. |
 
 ### Guides
@@ -476,11 +473,7 @@ The host may add the shared document tools (see `pixerate-agent-tools`). A paint
 - **Wet paint keeps changing.** A preview right after a wet stroke shows it before it has
   flowed; `advance_wet_paint` first. Paint that should stay exactly where it was laid needs
   `dry_paint` (or a dry medium).
-- **Wet strokes on one layer interact**; washes that must not mix go on separate layers, or dry
-  the first before painting the second (glazing). At most 8 layers hold wet paint at once, and the simulation holds at most 328 wet tiles (256 × 256 px each) across them; water that spreads past
-  that limit is lost (`dry_paint` frees tiles). Multi-threaded wet media needs a cross-origin isolated
-  page (COOP / COEP, for `SharedArrayBuffer`) and runs on one thread otherwise, more slowly but with
-  the same result.
+- **Wet strokes on one layer interact**; washes that must not mix go on separate layers, or dry the first before painting the second (glazing). Ghost paint (`ghost-wash`, `ghost-gouache`, `ghost-oil`, `invisible-ink`) only meets and smears paint on its own layer, so a ghost stroke on a new empty layer simply vanishes; ghost paint and light paint cannot share a layer while the ghost is fading. At most 8 layers hold wet paint at once, and the simulation holds at most 328 wet tiles (256 × 256 px each) across them; water that spreads past that limit is lost (`dry_paint` frees tiles). Multi-threaded wet media needs a cross-origin isolated page (COOP / COEP, for `SharedArrayBuffer`) and runs on one thread otherwise, more slowly but with the same result.
 - **Undoing far back** past the wet undo memory (512 MB by default) leaves that paint dry as it
   looked, rather than wet.
 - **Replays repeat what was recorded**: strokes, fills, clears, flattened relief and wet events.

package/skills/pixerate-paint-editor/references/brush-facets.md

@@ -20,6 +20,7 @@ more; this is where each one went.
 | Bristles | `tip.shape` `bristle` and `tip.bristle` |
 | A brush's own gradient (paint) | `colour.default` (a gradient); `unset: ['colour']` drops it |
 | Light | `light` (`amount`, `pressure`) |
+| Ghost paint (linger, smear) | `ghost` (`linger`, `smear`); `unset: ['ghost']` drops it |
 
 ## Examples
 

package/skills/pixerate-paint-editor/references/effect-paint.md

@@ -1,14 +1,36 @@
 # Effect paint along the stroke, and live effect paint
 
-- **Along the stroke** (`set_effect_paint` `map: { by: "stroke", length, repeat }`): the effect is
-  rendered as a strip `length` px long (16..4096, default 300) and 256 px across. Each pixel takes
+- **Along the stroke (native path)** (`set_effect_paint` `map: { by: "path" }`): when an effect has
+  a path control (`format: "svg-path"`, reported by `describe_effect` as `pathControls` and
+  `accepts: ["path"]`), each stroke passes its centreline `[x0, y0, x1, y1, …]` in canvas pixels
+  directly to that control and renders at the canvas size. The effect draws and lights itself along
+  the stroke's exact curve (e.g. a neon beam, laser trail or signature whose glow and lighting
+  belong to the path), while the brush's dabs and coverage still decide where paint lands. Strokes
+  with more than 256 points are evenly resampled to 256 points rather than refused. **Prefer
+  `by: "path"` over `by: "stroke"` whenever the effect has a path control** (`accepts: ["path"]`);
+  `set_effect_paint` refuses `by: "path"` on effects without a path control and tells you to use
+  `by: "stroke"` or `by: "canvas"`. Each stroke is a render of its own at the canvas size, so:
+  - A stroke painted by hand shows the effect along the path drawn so far while it is drawn,
+    re-rendered one render at a time, so it trails the pen by about one render. It is painted
+    again along its whole path when the pen lifts, as one undo step; if the preview already
+    rendered the whole path, at once. On a slow provider the editor is busy until that lands
+    (`effectPaintRendering`). `paint_stroke` and `stroke_path` know the path up front and paint
+    it at once.
+  - Wet brushes can't be painted by hand this way, as the simulation can't run twice; give them
+    the points through `paint_stroke`, or use `by: "stroke"`.
+  - With `live: true`, every stroke is a live source of its own, so at most 8 can play.
+  - Symmetry copies sample the same render, which only follows the original stroke: paint each
+    copy as its own stroke if it should draw too.
+- **Along the stroke (strip)** (`set_effect_paint` `map: { by: "stroke", length, repeat }`): for
+  effects without a path control, the effect is rendered as a strip `length` px long (16..4096,
+  default 300) and 256 px across. Each pixel takes
   the colour at its distance along the stroke and its place across the tip, so the pattern follows
   the stroke's turns instead of staying fixed to the canvas. `repeat` starts the strip again
   (default), `mirror` runs it back, `clamp` holds the last colour. Use it for ribbons, ropes,
-  flames and textures that should flow with the mark; use the default canvas mapping to reveal one
-  hidden picture across many strokes. Every colour-laying brush takes it (watercolour, gouache, oil
-  and impasto too; sprayed stickers at their centre); particle and bristle marks take the place of
-  their pen dab.
+  flames and textures that have no path control of their own; use the default canvas mapping to
+  reveal one hidden picture across many strokes. Every colour-laying brush takes it (watercolour,
+  gouache, oil and impasto too; sprayed stickers at their centre); particle and bristle marks take
+  the place of their pen dab.
   Scaled replays (`export_high_res`) scale `length` with the canvas.
 - **Live** (`live: true`): on a stroke layer (`add_layer {type: "strokes"}`) each stroke keeps
   playing the effect, so the paint moves. Paint the strokes, then `set_effect_playback`

package/skills/pixerate-paint-editor/references/ghost.md

@@ -0,0 +1,47 @@
+# Ghost paint and invisible ink
+
+Ghost paint is wet paint (`behaviour.surface: "wet"`) with a `ghost` facet (`linger` 0.5..60 s,
+default 4; `smear` 0..1, default 0.3). While wet it looks and behaves like any watercolour,
+gouache or wet oil: it flows with the water and its colour mixes visibly with the paint it meets.
+Then its own colour fades away completely, leaving only what it did to the paint already on the
+layer — a smear where it lifted and dragged that paint along. On bare paper it leaves nothing at
+all.
+
+## Presets and settings
+
+- **`ghost-wash`**: transparent watercolour ghost (`linger: 4`, `smear: 0.35`).
+- **`ghost-gouache`**: opaque gouache ghost that mixes strongly while wet, then vanishes (`linger: 4`, `smear: 0.45`).
+- **`ghost-oil`**: slow wet oil ghost (`linger: 8`, `smear: 0.55`).
+- **`invisible-ink`**: a ghost brush with `behaviour.wet.pigment: 0` and `smear: 0.6`. Nothing
+  shows on bare paper; it reveals itself only as a smear in the wet or dried paint it crosses.
+  Because it lays no pigment, it lays no tracer, needs no fade, and does not interrupt another
+  ghost already fading on the layer.
+- Any wet paint brush becomes a ghost brush with `set_brush` `{ ghost: { linger, smear } }`;
+  `unset: ["ghost"]` makes it ordinary wet paint again.
+
+## Working method
+
+1. **Paint on the layer that holds the paint you want to disturb.** Wet paint is per layer:
+   a ghost stroke on a new empty layer has nothing to smear and vanishes into bare paper.
+2. **Watch it mix while wet.** Call `advance_wet_paint` in short steps (`seconds: 0.5..1`) and
+   `render_preview` to see the ghost colour mixing and flowing with the layer's paint, and check
+   `get_wet_paint` (`layers[].ghost.remaining`, from 1 down to 0) to see how much of the fade is
+   left.
+3. **Finish the fade.** Advance past `linger` seconds, or call `dry_paint` (which finishes the
+   ghost fade at once before baking). With `smear: 0`, ghost paint passes over dried paint and
+   leaves it untouched; with `smear > 0`, it lifts dried paint along its path (`rewet` scaled by
+   `smear`) and drags both wet and lifted paint along the stroke.
+
+## Pitfalls
+
+- **Wet paint is per layer.** Ghost paint only meets paint on its own layer. Painting a ghost
+  stroke on a new empty layer leaves nothing behind once it fades.
+- **One ghost colour per layer at a time.** Painting a ghost stroke in a new colour on a layer
+  whose earlier ghost is still fading finishes the earlier ghost's colour fade at once (keeping
+  its smear) before starting the new colour.
+- **Ghost and light paint cannot share a layer.** The ghost tracer uses the wet layer's light
+  channel, so a ghost stroke is refused on a layer that has light paint (`clear_light` or paint on
+  another layer), and a light brush is refused on a layer where ghost paint is still fading
+  (`dry_paint` first or use another layer). Once the ghost has faded, the layer is free again.
+- **One solid colour per stroke.** Gradient paint, effect paint and multi-colour are refused on
+  ghost brushes.

package/skills/pixerate-paint-watercolour/SKILL.md

@@ -77,6 +77,7 @@ block the light. See `references/light-paint.md` in `pixerate-paint-editor`.
 | Cauliflower blooms | Add water into a drying wash; `bloom` up |
 | A glowing (neon) wash | Dark paper (`set_paper` `color`), `glow-wash` or `light.amount` on a wet brush; flow, dry, `get_light` |
 | Stained glass, a lightbox | `set_paper` `stained-glass` (or `backlight`); strong glazes for panes, opaque black lines above |
+| Disturb or smear a wash without adding colour | `ghost-wash`, `ghost-gouache` or `invisible-ink` (`ghost` `linger`, `smear`) on the same layer; see `references/ghost.md` |
 
 ## Recipes