@pixerate/editor 0.209.0 → 0.211.0

package/dist/paint/index.js

@@ -10,33 +10,35 @@ import {
   TransformedPixelSource,
   applyRetouchToTile,
   applyToneToDeepTile,
-  bestOffset,
   boxBlurPixels,
   cloneSamplePoint,
-  contentAwareFill,
-  dilateMask,
   dodgeBurn,
   dodgeBurnCurve,
   healPixels,
   isIdentityCloneTransform,
   luma,
-  maskBounds,
-  membraneFill,
   normalizeRetouch,
   perDabStrength,
   readSourceRegion,
   retouchFilter,
   rgbaViewOfGrey,
   saturationOf,
-  seamlessClone,
   smudgeEffect,
-  solveMembrane,
   sponge,
   spongeEffect,
   spotHealPixels,
   spotHealWindow,
   toneOf
-} from "../chunk-USQCKRZG.js";
+} from "../chunk-ZGJGSCUW.js";
+import {
+  bestOffset,
+  contentAwareFill,
+  dilateMask,
+  maskBounds,
+  membraneFill,
+  seamlessClone,
+  solveMembrane
+} from "../chunk-XI2NV5U7.js";
 import {
   BODY_SCATTER,
   DEFAULT_FLOW,

package/dist/paint-editor/index.cjs

@@ -7,7 +7,7 @@ var _chunkZ64NRDEHcjs = require('../chunk-Z64NRDEH.cjs');
 
 
 
-var _chunkQE7D7TZRcjs = require('../chunk-QE7D7TZR.cjs');
+var _chunkH65IBXFIcjs = require('../chunk-H65IBXFI.cjs');
 require('../chunk-A2IS7EHE.cjs');
 require('../chunk-QYLWG22N.cjs');
 
@@ -1657,11 +1657,11 @@ function header(state, options) {
   return out;
 }
 function serializePaintDocument(state, options = {}) {
-  const { layers, assets } = _chunkQE7D7TZRcjs.serializeLayers.call(void 0, state.layers);
+  const { layers, assets } = _chunkH65IBXFIcjs.serializeLayers.call(void 0, state.layers);
   return { ...header(state, options), layers, assets };
 }
 async function serializePaintDocumentExternal(state, store, options = {}) {
-  const { layers, assets } = await _chunkQE7D7TZRcjs.serializeLayersExternal.call(void 0, state.layers, store);
+  const { layers, assets } = await _chunkH65IBXFIcjs.serializeLayersExternal.call(void 0, state.layers, store);
   return { ...header(state, options), layers, assets };
 }
 function paintLayersOnly(layers, problems) {
@@ -1698,7 +1698,7 @@ function deserializePaintDocument(raw) {
   const canvas = normalizeCanvas({ width: r.width, height: r.height, dpi: _nullishCoalesce(r.dpi, () => ( void 0)) });
   const paper = _chunkROVK6AXXcjs.normalizePaper.call(void 0, _nullishCoalesce(r.paper, () => ( {})));
   const assets = r.assets && typeof r.assets === "object" ? r.assets : {};
-  const layers = paintLayersOnly(_chunkQE7D7TZRcjs.deserializeLayers.call(void 0, r.layers, { assets, problems }), problems);
+  const layers = paintLayersOnly(_chunkH65IBXFIcjs.deserializeLayers.call(void 0, r.layers, { assets, problems }), problems);
   const wanted = typeof r.activeLayerId === "string" ? r.activeLayerId : null;
   const activeLayerId = wanted && _chunkUOGKSVRQcjs.findLayer.call(void 0, layers, wanted) ? wanted : _nullishCoalesce(_optionalChain([_chunkUOGKSVRQcjs.flattenLayers.call(void 0, layers), 'access', _70 => _70.filter, 'call', _71 => _71((l) => l.type === "pixel"), 'access', _72 => _72.pop, 'call', _73 => _73(), 'optionalAccess', _74 => _74.id]), () => ( null));
   const wetEvents = Array.isArray(r.wetEvents) ? r.wetEvents.filter((e) => e && typeof e === "object" && Number.isInteger(e.clock) && typeof e.kind === "string") : [];
@@ -1714,7 +1714,7 @@ async function deserializePaintDocumentAsync(raw, store) {
   if (!raw || typeof raw !== "object") throw new Error("Not a paint document: expected a JSON object.");
   const r = raw;
   const problems = [];
-  const assets = await _chunkQE7D7TZRcjs.resolveExternalAssets.call(void 0, _nullishCoalesce(r.assets, () => ( {})), store, problems);
+  const assets = await _chunkH65IBXFIcjs.resolveExternalAssets.call(void 0, _nullishCoalesce(r.assets, () => ( {})), store, problems);
   const loaded = deserializePaintDocument({ ...r, assets });
   return { ...loaded, problems: [...problems, ...loaded.problems] };
 }
@@ -5413,7 +5413,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       return next.type === "group" ? { ...next, children: toStandard(next.children) } : next;
     });
     const layers = toStandard(dried);
-    const result = _chunkQE7D7TZRcjs.exportPsd.call(void 0, { width, height, layers: [paperLayer, ...layers], merged, resolution: dpi });
+    const result = _chunkH65IBXFIcjs.exportPsd.call(void 0, { width, height, layers: [paperLayer, ...layers], merged, resolution: dpi });
     for (const [mode, names] of changed) {
       const label = _nullishCoalesce(_optionalChain([_chunkOLNIPTB3cjs.BLEND_MODES, 'access', _271 => _271.find, 'call', _272 => _272((m) => m.id === mode), 'optionalAccess', _273 => _273.label]), () => ( mode));
       const std = _nullishCoalesce(_optionalChain([_chunkOLNIPTB3cjs.BLEND_MODES, 'access', _274 => _274.find, 'call', _275 => _275((m) => m.id === _chunkOLNIPTB3cjs.standardBlendMode.call(void 0, mode)), 'optionalAccess', _276 => _276.label]), () => ( _chunkOLNIPTB3cjs.standardBlendMode.call(void 0, mode)));

package/dist/paint-editor/index.js

@@ -7,7 +7,7 @@ import {
   resolveExternalAssets,
   serializeLayers,
   serializeLayersExternal
-} from "../chunk-KFIOEOCQ.js";
+} from "../chunk-W3TOZTL7.js";
 import "../chunk-3CI7FRMK.js";
 import "../chunk-L3G23N5Y.js";
 import {

package/package.json

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

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

@@ -96,25 +96,13 @@ drawing or editing either.
 
 ### Layer effects
 
-1. **Effects are live and per layer**: drop and inner shadows, outer and inner glows,
-   bevel & emboss, satin, colour / gradient / pattern overlays and strokes go on pixel,
-   annotation and group layers (not adjustment layers) and follow the layer's pixels as they
-   change. Add them with `add_layer_effect` (`kind` plus only the `settings` that differ from
-   Photoshop's defaults), tune them with `update_layer_effect` and read them back with
-   `list_layer_effects`. Each call is one undo step and returns the layer's effects. In the UI
-   they are the **Layer Style** section of **Layer Properties**; the separate **Effects** panel is
-   for provider effects (effect layers and filters), so say "layer style" when you tell the user
-   where a drop shadow or stroke lives.
-2. **Keep the ids**: `add_layer_effect` returns `effectId`; `update_layer_effect` and
-   `remove_layer_effect` need it. `list_layers` shows which layers have effects (ids and kinds
-   only).
-3. **Light consistently**: shadows and bevels follow the document's global light while
-   `useGlobalLight` is true (the default). Change the light for all of them with
-   `set_global_light`; give one effect its own `angle` only when it must differ.
-4. **Compare and size as a whole**: `set_layer_effects_enabled` with `enabled: false` hides
-   every effect of a layer (each keeps its own `enabled`); `scale` resizes them all (Scale
-   Effects), e.g. after resizing a layer's content.
-5. **Look after each change**: `render_preview` (with `layerId` for one layer alone).
+Live per-layer effects (shadows, glows, bevel, overlays, strokes): see `references/layer-effects.md`.
+
+### Paths
+
+1. **Keep outlines as paths**: `make_work_path` turns the selection into the Work Path (the next
+   one replaces it; `rename_path` saves it), `add_path` adds one from geometry.
+2. **Use them**: `path_to_selection` / `add_vector_mask` with `pathId`, `fill_path`, `stroke_path`.
 
 ### Painting
 
@@ -320,13 +308,23 @@ in the source frame at the document's bit depth, colour mode and profile. Read
 | `remove_shape_component` | Delete one component (not the last: delete the layer instead). Returns the shape. |
 | `merge_shape_components` | Merge Shape Components: the combined area becomes one plain component (live shapes become paths); the look does not change. Returns the shape. |
 | `get_vector_mask` | Read-only. A layer's vector mask: enabled, linked, inverted, fill rule, density, feather, bounds and components (subpaths in document px), or null. Read it before editing the path. |
-| `add_vector_mask` | Layer › Vector Mask on any layer but a shape: `from` `path` (a `shape`, `subpaths` or `components`, like `add_shape_layer`), `selection` (traced, `tolerance` px), `reveal-all` or `hide-all` (empty path). Reveals inside the path, sharp at any size; it combines with the raster mask. Returns the vector mask. |
+| `add_vector_mask` | Layer › Vector Mask on any layer but a shape: `from` `path` (a `shape`, `subpaths` or `components`, like `add_shape_layer`, or a document path's `pathId`), `selection` (traced, `tolerance` px), `reveal-all` or `hide-all` (empty path). Reveals inside the path, sharp at any size; it combines with the raster mask. Returns the vector mask. |
 | `set_vector_mask_path` | Replace the vector mask's path (properties kept). Returns the vector mask. |
 | `set_vector_mask_properties` | `enabled`, `linked` (false: stays put when the layer moves), `inverted`, `density`, `feather` px; the path is kept. Returns the vector mask. |
 | `rasterize_vector_mask` | Multiply the path into the raster mask (adding one) and drop the vector mask, so it can be painted. Returns the mask summary. |
 | `remove_vector_mask` | Delete the vector mask (the raster mask stays). |
 | `selection_to_path` | Read-only. Make Work Path: the selection's outline as closed Bézier subpaths (`tolerance` px, `cornerRoundness`, `minArea`); returns `svg` and `fillRule: "evenodd"` to pass to `add_vector_mask`, `set_vector_mask_path` or `add_shape_layer`. |
-| `path_to_selection` | Make Selection: fill a path (`shape`, `subpaths`, `components`) into the selection by `mode`, with `feather` and `antiAlias`. Returns the selection. |
+| `path_to_selection` | Make Selection: fill a path (`shape`, `subpaths`, `components`, or a document path's `pathId`) into the selection by `mode`, with `feather` and `antiAlias`. Returns the selection. |
+| `list_paths` | Paths panel: saved paths and the Work Path (`work: true`) with ids, names, anchor counts and bounds. Read before the other path tools. |
+| `get_path` | One document path: summary, `svg` and `components` (anchors with handles) to edit and pass to `set_path_geometry`. |
+| `make_work_path` | Paths › Make Work Path: trace the selection into the Work Path (replacing the last one); `tolerance` px. Returns the path. |
+| `add_path` | A saved path from `shape`, `subpaths` (or SVG data) or `components`, with `name`. Returns the path. |
+| `set_path_geometry` | Replace a path's geometry (name kept). Returns the path. |
+| `rename_path` | Rename a path; renaming the Work Path saves it. Returns the path. |
+| `duplicate_path` | Copy a path as a saved path. Returns the copy. |
+| `delete_path` | Delete a path (undo brings it back). Returns the remaining paths. |
+| `fill_path` | Paths › Fill Path: fill a path's area on a pixel layer (`layerId`, `color`, `opacity`); the selection is untouched. |
+| `stroke_path` | Paths › Stroke Path: stroke along a path, `width` px centred, on a pixel layer; the selection is untouched. |
 | `convert_to_smart_object` | Convert sibling `layerIds` (default the active layer) to one smart object at the top one's position, optional `name`. One pixel layer keeps its id, look and properties (filters become smart filters); several layers, groups or adjustments nest as a layer document. Returns the `layer` and the `smartObject` summary. |
 | `rasterize_smart_object` | Turn a smart object into a pixel layer holding what it shows now (smart filters baked; same id, mask, effects, opacity, blend). Destructive: the contents and filters are gone. Returns the layer. |
 | `set_smart_object_transform` | Set a smart object's transform absolutely: `corners`, `matrix` (contents → document), or `scaleX` / `scaleY` (percent of the contents), `rotate`, `skewX`, `skewY`, `x`, `y` (where the contents' centre goes; unset numbers keep their values); `warp` preset or mesh in contents px, `null` removes it; `interpolation`. Re-renders from the contents. Returns `placement`, `masksMoved` and `bounds`. |
@@ -386,7 +384,7 @@ in the source frame at the document's bit depth, colour mode and profile. Read
 | `apply_selection_as_mask` | Mask a layer with the current selection: pass `layerId` to mask an existing layer, or `kind` (plus optional `params`) to create a new masked layer in one step. `density` 0..1 and `feather` px soften the mask non-destructively. Returns `layerId`, kind, mask info and the selection summary. |
 | `stroke_selection` | Edit › Stroke: a band `width` px (≤ 250) `outside` (default), `inside` or `center` on the selection edge, with `color`, `opacity`, `blend`, on a layer's pixels or mask (`channel`). One undo step. Returns the changed `bounds`. |
 | `crop_to_selection` | Set the crop box to the selection's bounds (non-destructive; `reset_crop` undoes it). Returns the `crop`. |
-| `content_aware_fill` | Remove what is selected by synthesising texture from around it on a pixel layer; `output` `new-layer` (keeps the fill separate, recommended) or `current`; `sampleRadius`, `seed` (another seed, another fill). Select with a 2–4 px margin. 8-bit only. Returns `layerId` and `bounds`. |
+| `content_aware_fill` | Remove what is selected by synthesising texture from around it on a pixel layer; `output` `new-layer` (keeps the fill separate, recommended) or `current`; `sampleRadius`, `seed` (another seed, another fill); the sampling area with `sampleRects`, `samplingChannelId` and `excludeRects` (never copy from these). Select with a 2–4 px margin. 8-bit only. Returns `layerId` and `bounds`. |
 | `copy_pixels` | Copy the selected pixels of a layer (or with `merged` the visible image) to the editor clipboard, cropped to the selection with its soft edge. No undo step. Returns `width`, `height`, `x`, `y`. |
 | `cut_pixels` | Copy, then clear the selected pixels (one undo step). Returns the size and position. |
 | `paste_pixels` | Paste the clipboard as a new layer: `mode` `new-layer` (centred on the selection or canvas), `in-place`, `into` (masked by the selection) or `outside` (masked by its inverse). One undo step. Returns `layerId`, `bounds`, `masked`. |

package/skills/pixerate-image-editor/references/layer-effects.md

@@ -0,0 +1,24 @@
+# Layer effects: drop shadows, glows, bevels, overlays and strokes
+
+Read this before `add_layer_effect`, `update_layer_effect`, `set_global_light` or
+`set_layer_effects_enabled`.
+
+1. **Effects are live and per layer**: drop and inner shadows, outer and inner glows,
+   bevel & emboss, satin, colour / gradient / pattern overlays and strokes go on pixel,
+   annotation and group layers (not adjustment layers) and follow the layer's pixels as they
+   change. Add them with `add_layer_effect` (`kind` plus only the `settings` that differ from
+   Photoshop's defaults), tune them with `update_layer_effect` and read them back with
+   `list_layer_effects`. Each call is one undo step and returns the layer's effects. In the UI
+   they are the **Layer Style** section of **Layer Properties**; the separate **Effects** panel is
+   for provider effects (effect layers and filters), so say "layer style" when you tell the user
+   where a drop shadow or stroke lives.
+2. **Keep the ids**: `add_layer_effect` returns `effectId`; `update_layer_effect` and
+   `remove_layer_effect` need it. `list_layers` shows which layers have effects (ids and kinds
+   only).
+3. **Light consistently**: shadows and bevels follow the document's global light while
+   `useGlobalLight` is true (the default). Change the light for all of them with
+   `set_global_light`; give one effect its own `angle` only when it must differ.
+4. **Compare and size as a whole**: `set_layer_effects_enabled` with `enabled: false` hides
+   every effect of a layer (each keeps its own `enabled`); `scale` resizes them all (Scale
+   Effects), e.g. after resizing a layer's content.
+5. **Look after each change**: `render_preview` (with `layerId` for one layer alone).

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

@@ -151,7 +151,8 @@ This skill is the method. `pixerate-image-editor` has the full tool reference.
   `set_layer_properties`; no selection is needed.
 - **Remove an object:** select it with a 2–4 px margin (`modify_selection` `expand`), then
   `content_aware_fill` `output: "new-layer"`; try another `seed` if the fill repeats texture,
-  and mask out what is wrong.
+  and mask out what is wrong. If it copies in something it shouldn't (a person, a sign), pass
+  `excludeRects` over that, or `sampleRects` over the background it should continue.
 - **Outline a cutout:** `select_layer_transparency` on it, then `stroke_selection`
   `location: "outside"` on a new layer below it.
 - **Crop to a subject:** select it, then `crop_to_selection` (non-destructive).