@pixerate/editor 0.216.0 → 0.218.0

package/dist/paint-editor/index.js

@@ -32,6 +32,7 @@ import {
   SRGB_TO_LINEAR,
   WET_FLOW_KINDS,
   WET_PARAM_KEYS,
+  WET_TILE,
   WetMedium,
   WetWorld,
   createPigmentTools,
@@ -39,13 +40,14 @@ import {
   findWebGpu,
   flowField,
   linearToSrgb8,
+  moveWetSnapshot,
   normalizeFlow,
   normalizeTilt,
   normalizeWetParams,
   pigmentOf,
   pointerPressure,
   wetSupport
-} from "../chunk-WJ2RBZMM.js";
+} from "../chunk-HLBTRSQJ.js";
 import "../chunk-HVQVHUTV.js";
 import {
   writeZip
@@ -2162,15 +2164,50 @@ var PaintWetLayers = class {
       if (this.world.laneIds().length) throw new Error("The wet world is the wrong size; dry the paint before resizing the canvas.");
       this.dropWorld();
     }
-    if (!this.world) {
-      this.world = new WetWorld(width, height, wetPaperInput(this.host.paper()), { kernel: this.options.kernel, threads: this.options.threads });
-      this.world.setTilt(this.tilt);
-      this.world.gpuMinTiles = this.gpuMinTiles;
-      if (this.gpu) this.world.attachGpu(this.gpu);
-      else this.startGpu();
-    }
+    if (!this.world) this.world = this.makeWorld(width, height, this.host.paper());
     return this.world;
   }
+  makeWorld(width, height, paper) {
+    const world = new WetWorld(width, height, wetPaperInput(paper), { kernel: this.options.kernel, threads: this.options.threads });
+    world.setTilt(this.tilt);
+    world.gpuMinTiles = this.gpuMinTiles;
+    if (this.gpu) world.attachGpu(this.gpu);
+    else this.startGpu();
+    return world;
+  }
+  /**
+   * Whether `extend` can keep the wet paint when the canvas grows by `left` / `top` on those
+   * sides: the shift has to be whole wet tiles (256 px), and no wet stroke may be live.
+   */
+  canExtend(left, top) {
+    return left % WET_TILE === 0 && top % WET_TILE === 0 && !this.driver;
+  }
+  /**
+   * Keeps the wet paint while the canvas grows to `width`×`height` by `left` / `top` on those
+   * sides (`canExtend` must hold): the world is made again at the new size with every wet layer
+   * moved by (left, top), still wet, its base and flow map with it; `paper` is the new
+   * document's paper (its grain moved with the paint). Wet settings' flow centres move too. The
+   * caller shows the layers again (`syncDisplays`) once the document is the new size.
+   */
+  extend(width, height, left, top, paper) {
+    if (!this.canExtend(left, top)) throw new Error("Wet paint only moves by whole 256 px tiles, between strokes.");
+    for (const [id, s] of this.settings) if (s.flow.center) this.settings.set(id, { ...s, flow: { ...s.flow, center: { x: s.flow.center.x + left, y: s.flow.center.y + top } } });
+    const old = this.world;
+    const snap = old?.laneIds().length ? old.snapshot() : null;
+    this.dropWorld();
+    this.lastTick = null;
+    this.stepsOwed = 0;
+    if (!old || !snap) return;
+    const moved = moveWetSnapshot(snap, old, { width, height }, left, top, (l) => {
+      const flow = this.settings.get(l.id)?.flow;
+      return {
+        base: translateSurface(l.base, left, top),
+        flow: l.flow && flow && flow.kind !== "none" ? flowField(flow, width, height) : l.flow
+      };
+    });
+    this.world = this.makeWorld(width, height, paper);
+    this.world.restore(moved);
+  }
   /** Whether any layer (or `layerId`) has wet paint. */
   isWet(layerId) {
     const w = this.world;
@@ -3709,9 +3746,11 @@ var PaintEditorController = class _PaintEditorController {
    * move by (left, top) in document pixels, `document.origin` moves by (−left, −top), and the view
    * pans so the picture stays still on screen.
    *
-   * Wet paint dries first (the wet simulation is canvas-sized), as with `setCanvas`; one undo step
-   * (undo brings back the old size, origin and guides, and the wet paint). Returns the new canvas,
-   * where it sits in the previous document's pixels, and the origin.
+   * Wet paint stays wet and moves with the picture when `left` and `top` are whole 256 px tiles
+   * (so a host growing a canvas while someone paints should grow it in tile steps); otherwise it
+   * dries first (the wet simulation is canvas-sized), as with `setCanvas`. One undo step (undo
+   * brings back the old size, origin and guides, and the wet paint). Returns the new canvas, where
+   * it sits in the previous document's pixels, and the origin.
    */
   extendCanvas(by) {
     this.requireIdle("extending the canvas");
@@ -3731,14 +3770,29 @@ var PaintEditorController = class _PaintEditorController {
     if (width > MAX_CANVAS_SIDE || height > MAX_CANVAS_SIDE) {
       throw new PaintEditorError(`The canvas would be ${width}\xD7${height}; the limit is ${MAX_CANVAS_SIDE} px per side. Extend by less (it is ${was.width}\xD7${was.height} now).`);
     }
+    let keptWet = [];
     if (this.wet.world) {
       this.requireWetIdle("extending the canvas");
-      this.dryLayersFirst(this.wet.wetLayerIds());
-      const settings = [...this.wet.settings];
-      this.wet.reset();
-      for (const [id, s] of settings) this.wet.settings.set(id, s.flow.center ? { ...s, flow: { ...s.flow, center: { x: s.flow.center.x + left, y: s.flow.center.y + top } } } : s);
+      if (this.wet.canExtend(left, top)) {
+        keptWet = this.wet.wetLayerIds();
+        if (keptWet.length) this.beginWetOp();
+      } else {
+        this.dryLayersFirst(this.wet.wetLayerIds());
+      }
+    }
+    let next = { ...shiftDocument(this.withWetEvents(this.doc), left, top), canvas: { ...was, width, height } };
+    for (const id of keptWet) {
+      const l = findLayer(next.layers, id)?.layer;
+      if (isPixelLayer(l)) next = { ...next, layers: mapLayer(next.layers, id, () => ({ ...l, surface: translateSurface(l.surface, l.offset.x, l.offset.y), offset: { x: 0, y: 0 } })) };
+    }
+    if (this.wet.world) {
+      if (keptWet.length) this.wet.extend(width, height, left, top, next.paper);
+      else {
+        const settings = [...this.wet.settings];
+        this.wet.reset();
+        for (const [id, s] of settings) this.wet.settings.set(id, s.flow.center ? { ...s, flow: { ...s.flow, center: { x: s.flow.center.x + left, y: s.flow.center.y + top } } } : s);
+      }
     }
-    const next = { ...shiftDocument(this.withWetEvents(this.doc), left, top), canvas: { ...was, width, height } };
     const m = viewMatrix(this.view, was, { width: 0, height: 0 });
     const dx = (right - left) / 2;
     const dy = (bottom - top) / 2;
@@ -3746,6 +3800,7 @@ var PaintEditorController = class _PaintEditorController {
     const guidesBefore = this.guides;
     if (left || top) this.restoreGuides(shiftGuides(this.guides, left, top));
     this.commit("Extend canvas", next);
+    if (keptWet.length) this.wet.syncDisplays();
     if (this.guides !== guidesBefore) this.undoStack[this.undoStack.length - 1].guides = { before: guidesBefore, after: this.guides };
     const origin = { ...next.origin ?? { x: 0, y: 0 } };
     return { canvas: { ...next.canvas }, rect: { x: 0 - left, y: 0 - top, width, height }, origin };
@@ -7433,7 +7488,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
   add({
     name: "extend_canvas",
     title: "Extend the canvas",
-    description: "Grows the canvas by adding pixels on any side, keeping everything painted. Adding on the left or top moves the whole picture (layers, paper grain, guides, stencils, recorded strokes) right or down by that much in document pixels, so coordinates you read before change by (+left, +top). Wet paint dries first. One undo step. Returns the canvas, rect (the new canvas in the previous coordinates: x -left, y -top) and origin.",
+    description: "Grows the canvas by adding pixels on any side, keeping everything painted. Adding on the left or top moves the whole picture (layers, paper grain, guides, stencils, recorded strokes) right or down by that much in document pixels, so coordinates you read before change by (+left, +top). Wet paint stays wet and moves with it when left and top are multiples of 256; otherwise it dries first. One undo step. Returns the canvas, rect (the new canvas in the previous coordinates: x -left, y -top) and origin.",
     inputSchema: {
       type: "object",
       properties: { left: EXTEND_SIDE("left"), top: EXTEND_SIDE("top"), right: EXTEND_SIDE("right"), bottom: EXTEND_SIDE("bottom") },

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

@@ -214,6 +214,20 @@ export declare class PaintWetLayers {
     engineInfo(): WetEngineInfo;
     /** The world (made on first use, at the canvas size). */
     ensureWorld(): WetWorld;
+    private makeWorld;
+    /**
+     * Whether `extend` can keep the wet paint when the canvas grows by `left` / `top` on those
+     * sides: the shift has to be whole wet tiles (256 px), and no wet stroke may be live.
+     */
+    canExtend(left: number, top: number): boolean;
+    /**
+     * Keeps the wet paint while the canvas grows to `width`×`height` by `left` / `top` on those
+     * sides (`canExtend` must hold): the world is made again at the new size with every wet layer
+     * moved by (left, top), still wet, its base and flow map with it; `paper` is the new
+     * document's paper (its grain moved with the paint). Wet settings' flow centres move too. The
+     * caller shows the layers again (`syncDisplays`) once the document is the new size.
+     */
+    extend(width: number, height: number, left: number, top: number, paper: PaperSettings): void;
     /** Whether any layer (or `layerId`) has wet paint. */
     isWet(layerId?: string): boolean;
     /** Layers holding a wet layer (wet or drying). */

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

@@ -214,6 +214,20 @@ export declare class PaintWetLayers {
     engineInfo(): WetEngineInfo;
     /** The world (made on first use, at the canvas size). */
     ensureWorld(): WetWorld;
+    private makeWorld;
+    /**
+     * Whether `extend` can keep the wet paint when the canvas grows by `left` / `top` on those
+     * sides: the shift has to be whole wet tiles (256 px), and no wet stroke may be live.
+     */
+    canExtend(left: number, top: number): boolean;
+    /**
+     * Keeps the wet paint while the canvas grows to `width`×`height` by `left` / `top` on those
+     * sides (`canExtend` must hold): the world is made again at the new size with every wet layer
+     * moved by (left, top), still wet, its base and flow map with it; `paper` is the new
+     * document's paper (its grain moved with the paint). Wet settings' flow centres move too. The
+     * caller shows the layers again (`syncDisplays`) once the document is the new size.
+     */
+    extend(width: number, height: number, left: number, top: number, paper: PaperSettings): void;
     /** Whether any layer (or `layerId`) has wet paint. */
     isWet(layerId?: string): boolean;
     /** Layers holding a wet layer (wet or drying). */

package/package.json

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

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

@@ -120,8 +120,7 @@ Keep outlines as paths (`make_work_path`, `add_path`) and edit their anchors: se
 
 ### Colour management
 
-The working space, Assign / Convert to Profile with intents, soft proofing with a gamut warning
-and colour conversions for print briefs: read [references/color-management.md](references/color-management.md).
+Working space, profiles, soft proofing and print conversions: read [references/color-management.md](references/color-management.md).
 ### Retouching
 
 Clone Stamp, Healing Brush, Spot Healing, Smudge, Dodge, Burn, Sponge, Blur, Sharpen and the
@@ -209,6 +208,7 @@ in the source frame at the document's bit depth, colour mode and profile. Read
 | `list_controls` | Get every base control (id, label, section, min, max, step, default, `requiresProcess`), each layer kind's settable controls (plus `opacity`), the blend mode ids and the `layers.<layerId>.<controlId>` path format. Call once per session before writing. |
 | `get_selection` | Read the active selection: `empty`, `bounds` (natural pixels), `area` in pixels, `percent` of the image and a description. Check it after every select or modify step and before masking: a wand that covered 90% of the image is the wrong selection. |
 | `inspect_mask_edge` | Measure an edge without looking: the selection (default) or a layer's `layer-mask` / `vector-mask` (`layerId`). Returns `haloScore`, `edgeAlignment`, `jaggedness`, `softFraction`, `holes`, `islands`, `worst` regions for `capture_view` and `issues` with fixes. Inspect, fix, inspect again (see `pixerate-image-selection-masking`). |
+| `compare_selections` | What changed between two selections: `a` (default the one before the last undo step) and `b` (default current), each `selection`, `history` (`steps`), `channel` or a layer's `layer-mask` / `vector-mask`. Returns `added` / `removed` (area, largest pieces with bounds), `iou` and `identical`; `show` tints the change on the canvas. Check every modify or refine step. |
 | `list_channels` | Read the alpha channels (saved selections): id, name, bounds, percent, overlay and visibility, and whether Quick Mask mode is on. |
 | `select_subject` | Select › Subject. With a host segmentation model, `target` describes what to select ("the dog", "the sky") and the model's outlines are selected (`maxSegments` 1 for one). Without one, the subject that stands out most is found classically; `target` can't choose it (`method: "saliency"`, `note`). Combined by `mode`. Returns the selection, `found` (label, bounds) and `method`; nothing found leaves the selection unchanged. |
 | `list_layers` | Read the layer stack bottom to top as a tree: id, type (`pixel`, `adjustment`, `group`, `shape`, `annotation`, `smart`; smart objects add their `contents`, `smartFilters` and `filterMask`; shapes a `shape` summary of component ops and kinds and paint types, and `annotation` when migrated from one), name, document `bounds` of pixel layers, visibility, opacity, `fillOpacity`, blend, `clipped`, locks, a `mask` summary, an `effects` summary (master switch, scale, effect ids and kinds), pixel-layer `filters` (the Background's `develop` filter is the base adjustments), adjustment `kind` and `params`, group `children`, and which layer is `active`. Call it to understand a document with more than the Background before changing it; adjustment layer ids work with every adjustment-layer tool. |

package/skills/pixerate-image-selection-masking/SKILL.md

@@ -65,8 +65,8 @@ This skill is the method. `pixerate-image-editor` has the full tool reference.
      can open the same edits in the workspace. With a host model, `refineMode: "object"`
      refines from the model's outline.
    - `shiftEdge` −10..−30 % tightens a refined edge that picked up background.
-   **Check:** `percent` changed by roughly what you intended (a few percent at most for a
-   cleanup).
+   **Check:** `compare_selections` after the step: `added` / `removed` are what you meant and
+   `iou` stays near 1 for a cleanup (it tints the change on the canvas).
 5. **Output.** Choose by goal:
    - A local adjustment: `add_adjustment_layer` while the selection is active (it is masked
      by it), or `apply_selection_as_mask` with `kind`. Filters (`apply_effect`,
@@ -239,7 +239,7 @@ This skill is the method. `pixerate-image-editor` has the full tool reference.
 - `modify_selection`: expand, contract, feather, border, smooth
 - `refine_selection`: snap the edge to the image
 - `transform_selection`: move or scale the outline only
-- `inspect_mask_edge`: measured halo, alignment, jaggedness, softness, holes and islands of an edge
+- `inspect_mask_edge`, `compare_selections`: measure an edge (halo, alignment, jaggedness, holes, islands) and what a step changed (IoU)
 - `set_edge_decontamination`, `set_edge_despill`, `set_edge_ambient`, `get_edge_color`: live edge colour on a masked cutout
 - `capture_view`, `render_preview`: look at the edge at pixel level; check the result
 - `apply_selection_as_mask`: a masked adjustment layer in one step

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

@@ -283,7 +283,7 @@ view), so work with the tools you are given.
 | `get_canvas_info` | Read the canvas size and dpi, its `origin` (moved by `extend_canvas`), paper (preset, colour, depth), active layer, layer count, active brush id, colours, view, hand, number of recorded strokes, undo / redo labels and the blend modes. Call first. |
 | `new_canvas` | Start over with a blank canvas: one empty layer over the paper. `width`, `height` (1..16384 px), `dpi`, `paper` preset id; missing ones keep the current values. Undo brings the old painting back. Returns the size, paper and layer id. |
 | `set_canvas` | Resize the canvas (pixels stay put, anchored top-left) or change its `dpi`. Returns the canvas. |
-| `extend_canvas` | Add pixels on any side (`left`, `top`, `right`, `bottom`, default 0) keeping everything painted, the paper grain and the guides in place relative to each other. `left` / `top` move all document coordinates by that much. Wet paint dries first; one undo step. Returns `canvas`, `rect` (the new canvas in the previous coordinates) and `origin` (also in `get_canvas_info`). |
+| `extend_canvas` | Add pixels on any side (`left`, `top`, `right`, `bottom`, default 0) keeping everything painted, the paper grain and the guides in place relative to each other. `left` / `top` move all document coordinates by that much. Wet paint stays wet and moves with it when `left` and `top` are multiples of 256; otherwise it dries first. One undo step. Returns `canvas`, `rect` (the new canvas in the previous coordinates) and `origin` (also in `get_canvas_info`). |
 | `list_papers` | Read the paper library: id, name, family, grain pattern, colour, depth and the wet-media properties (absorption, permeability, roughness, stored for later wet media). Call before `set_paper`. |
 | `get_paper` | Read every setting of the current paper (pattern, seed, scale, tiling, depth, shading, dry and wet tuning). |
 | `set_paper` | Change the paper: `preset`, then any of `color`, `depth` (0..1), `scale` (0.25..8), `seed` (another sheet), `pattern`, `tiling`, `shading`, `dry` / `wet` tuning (`contrast` 0..3, `invert`). Affects new strokes' grain and how the paper shows; strokes already painted keep their pixels. Returns the paper. |