@pixerate/editor 0.186.0 → 0.188.0

package/dist/paint-editor/index.cjs

@@ -7,7 +7,7 @@ var _chunkZ64NRDEHcjs = require('../chunk-Z64NRDEH.cjs');
 
 
 
-var _chunkX2KQQZBTcjs = require('../chunk-X2KQQZBT.cjs');
+var _chunkJYV4R62Mcjs = require('../chunk-JYV4R62M.cjs');
 require('../chunk-A2IS7EHE.cjs');
 
 
@@ -1653,11 +1653,11 @@ function header(state, options) {
   return out;
 }
 function serializePaintDocument(state, options = {}) {
-  const { layers, assets } = _chunkX2KQQZBTcjs.serializeLayers.call(void 0, state.layers);
+  const { layers, assets } = _chunkJYV4R62Mcjs.serializeLayers.call(void 0, state.layers);
   return { ...header(state, options), layers, assets };
 }
 async function serializePaintDocumentExternal(state, store, options = {}) {
-  const { layers, assets } = await _chunkX2KQQZBTcjs.serializeLayersExternal.call(void 0, state.layers, store);
+  const { layers, assets } = await _chunkJYV4R62Mcjs.serializeLayersExternal.call(void 0, state.layers, store);
   return { ...header(state, options), layers, assets };
 }
 function paintLayersOnly(layers, problems) {
@@ -1694,7 +1694,7 @@ function deserializePaintDocument(raw) {
   const canvas = normalizeCanvas({ width: r.width, height: r.height, dpi: _nullishCoalesce(r.dpi, () => ( void 0)) });
   const paper = _chunkYQ5C5BVKcjs.normalizePaper.call(void 0, _nullishCoalesce(r.paper, () => ( {})));
   const assets = r.assets && typeof r.assets === "object" ? r.assets : {};
-  const layers = paintLayersOnly(_chunkX2KQQZBTcjs.deserializeLayers.call(void 0, r.layers, { assets, problems }), problems);
+  const layers = paintLayersOnly(_chunkJYV4R62Mcjs.deserializeLayers.call(void 0, r.layers, { assets, problems }), problems);
   const wanted = typeof r.activeLayerId === "string" ? r.activeLayerId : null;
   const activeLayerId = wanted && _chunkHGTDMKNEcjs.findLayer.call(void 0, layers, wanted) ? wanted : _nullishCoalesce(_optionalChain([_chunkHGTDMKNEcjs.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") : [];
@@ -1710,7 +1710,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 _chunkX2KQQZBTcjs.resolveExternalAssets.call(void 0, _nullishCoalesce(r.assets, () => ( {})), store, problems);
+  const assets = await _chunkJYV4R62Mcjs.resolveExternalAssets.call(void 0, _nullishCoalesce(r.assets, () => ( {})), store, problems);
   const loaded = deserializePaintDocument({ ...r, assets });
   return { ...loaded, problems: [...problems, ...loaded.problems] };
 }
@@ -5409,7 +5409,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       return next.type === "group" ? { ...next, children: toStandard(next.children) } : next;
     });
     const layers = toStandard(dried);
-    const result = _chunkX2KQQZBTcjs.exportPsd.call(void 0, { width, height, layers: [paperLayer, ...layers], merged, resolution: dpi });
+    const result = _chunkJYV4R62Mcjs.exportPsd.call(void 0, { width, height, layers: [paperLayer, ...layers], merged, resolution: dpi });
     for (const [mode, names] of changed) {
       const label = _nullishCoalesce(_optionalChain([_chunkCWM3CUUXcjs.BLEND_MODES, 'access', _271 => _271.find, 'call', _272 => _272((m) => m.id === mode), 'optionalAccess', _273 => _273.label]), () => ( mode));
       const std = _nullishCoalesce(_optionalChain([_chunkCWM3CUUXcjs.BLEND_MODES, 'access', _274 => _274.find, 'call', _275 => _275((m) => m.id === _chunkCWM3CUUXcjs.standardBlendMode.call(void 0, mode)), 'optionalAccess', _276 => _276.label]), () => ( _chunkCWM3CUUXcjs.standardBlendMode.call(void 0, mode)));

package/dist/paint-editor/index.js

@@ -7,7 +7,7 @@ import {
   resolveExternalAssets,
   serializeLayers,
   serializeLayersExternal
-} from "../chunk-FW7N64XK.js";
+} from "../chunk-IGMNJM2H.js";
 import "../chunk-3CI7FRMK.js";
 import {
   EffectRendererPool

package/package.json

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

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

@@ -126,30 +126,9 @@ drawing or editing either.
    overall strength and `flow` for gradual build-up within the stroke.
 4. **Limit paint with a selection**, or lock transparency (`set_layer_properties`
    `locks.transparency`) to paint only where the layer already has pixels.
-5. **Mix paint colours with `mix_colors`** when the user names paints and amounts ("two parts
-   ultramarine to one part yellow", "a tint of red"). It mixes like pigment, so blue and yellow
-   make green and white makes a tint, where averaging RGB gives grey or a dull pastel. Pass its
-   `mixed` hex as the `color` of `paint_stroke` or `fill_pixels`. Give a strong dark paint a
-   `strength` above 1 when a little of it should tint a lot of white.
-6. **Blend and smear with the Mixer Brush** (`paint_stroke` with `tool: "mixer"`) when the
-   user wants paint to pick up and drag the colours already on the layer (wet blending, softening
-   an edge, pulling one colour into another). `mixer.wet` is how much it picks up (0 paints only
-   the loaded colour), `mixer.mix` how far each dab leans from the loaded colour to the picked-up
-   one, and `mixer.load` below 1 makes long strokes run dry. Use `mixing: "pigment"` for
-   painterly results (blue dragged through yellow goes green); keep `rgb` for retouching, where
-   colours should stay between the two you started with. A brush with `blend: "pigment"` mixes
-   its one colour into the layer; only the mixer carries picked-up colour along the stroke. A `brush.flow` around 0.3..0.6 keeps
-   some of the canvas under each dab and blends more naturally than 1. The stroke samples the
-   target layer only, so paint on the layer that holds the colours to blend.
-7. **Keep the mixer stateless unless you need a carried load.** By default each mixer stroke
-   loads `color` (or the foreground) and is cleaned afterwards, so every call is independent and
-   replays the same. To carry dirty paint from stroke to stroke, pass `mixer.loadEachStroke:
-   false` and `cleanEachStroke: false`, start with `load_mixer_brush`, read the brush with
-   `get_mixer_brush` when unsure, and reset it with `clean_mixer_brush`.
-8. **Gradient paint** (colour that changes as the stroke goes): `set_paint` with `{ type:
-   "gradient", stops, map }`, or `paint_stroke` `paint` for one stroke (brush only). `map.by`
-   `distance` (default 300 px, mirrored) for drag-it-out colour, `pressure`, `direction`,
-   `across-tip`, `random`; stops may be `"paint"` / `"secondary"` (foreground / background).
+5. **Mixing paint, the Mixer Brush and gradient paint**: `mix_colors` mixes named paints like
+   pigment; `paint_stroke` `tool: "mixer"` picks up and smears the layer's colours; gradient paint
+   changes colour along a stroke. Read [references/painting.md](references/painting.md) first.
 
 ### Colour management
 
@@ -401,6 +380,8 @@ in the source frame at the document's bit depth, colour mode and profile. Read
 | `set_channel_properties` | Rename a channel or change its overlay `color`, `opacity`, `indicates` (`masked` / `selected`) and `visible`. Returns the `channel`. |
 | `duplicate_channel` | Copy a channel (`name`, default "<name> copy"). Returns the copy. |
 | `delete_channel` | Delete a channel (undoable). Returns the remaining channels. |
+| `export_mask_image` | Read-only. The selection, a channel (`channelId`) or a layer's painted mask (`layerId`) as a greyscale PNG (white = selected), `invert`, `maxSide` (default 1024). Returns the image and its size. |
+| `load_channel_from_image` | Store a mask image (`image` data URL / URL; `channel`, `threshold`, `invert`, `name`) in a new channel without changing the selection. Returns the `channel`. |
 | `set_quick_mask` | Quick Mask mode (`enabled`): paint, fill and retouch tools without `layerId` edit the selection (white selects, black deselects); turn it off before painting layers. Returns the mode. |
 
 ### Save and open

package/skills/pixerate-image-editor/references/painting.md

@@ -0,0 +1,29 @@
+# Painting: mixing paint, the Mixer Brush and gradient paint
+
+Read this before `mix_colors`, a `paint_stroke` with `tool: "mixer"`, or gradient paint
+(`set_paint` / `paint_stroke` `paint`).
+
+1. **Mix paint colours with `mix_colors`** when the user names paints and amounts ("two parts
+   ultramarine to one part yellow", "a tint of red"). It mixes like pigment, so blue and yellow
+   make green and white makes a tint, where averaging RGB gives grey or a dull pastel. Pass its
+   `mixed` hex as the `color` of `paint_stroke` or `fill_pixels`. Give a strong dark paint a
+   `strength` above 1 when a little of it should tint a lot of white.
+2. **Blend and smear with the Mixer Brush** (`paint_stroke` with `tool: "mixer"`) when the
+   user wants paint to pick up and drag the colours already on the layer (wet blending, softening
+   an edge, pulling one colour into another). `mixer.wet` is how much it picks up (0 paints only
+   the loaded colour), `mixer.mix` how far each dab leans from the loaded colour to the picked-up
+   one, and `mixer.load` below 1 makes long strokes run dry. Use `mixing: "pigment"` for
+   painterly results (blue dragged through yellow goes green); keep `rgb` for retouching, where
+   colours should stay between the two you started with. A brush with `blend: "pigment"` mixes
+   its one colour into the layer; only the mixer carries picked-up colour along the stroke. A `brush.flow` around 0.3..0.6 keeps
+   some of the canvas under each dab and blends more naturally than 1. The stroke samples the
+   target layer only, so paint on the layer that holds the colours to blend.
+3. **Keep the mixer stateless unless you need a carried load.** By default each mixer stroke
+   loads `color` (or the foreground) and is cleaned afterwards, so every call is independent and
+   replays the same. To carry dirty paint from stroke to stroke, pass `mixer.loadEachStroke:
+   false` and `cleanEachStroke: false`, start with `load_mixer_brush`, read the brush with
+   `get_mixer_brush` when unsure, and reset it with `clean_mixer_brush`.
+4. **Gradient paint** (colour that changes as the stroke goes): `set_paint` with `{ type:
+   "gradient", stops, map }`, or `paint_stroke` `paint` for one stroke (brush only). `map.by`
+   `distance` (default 300 px, mirrored) for drag-it-out colour, `pressure`, `direction`,
+   `across-tip`, `random`; stops may be `"paint"` / `"secondary"` (foreground / background).

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

@@ -76,6 +76,10 @@ This skill is the method. `pixerate-image-editor` has the full tool reference.
 6. **Store.** `save_selection` with a clear name before you change a selection that took
    work, and whenever it will be needed again (a second adjustment, a later refinement). Load
    it with `load_selection_from_channel`; channels are saved with the document and in PSDs.
+   To hand a mask to another tool or service, or to look at it alone, `export_mask_image`
+   writes the selection, a channel or a layer mask as a greyscale PNG; a matte that comes
+   back goes into a channel with `load_channel_from_image` (or straight to the selection with
+   `load_selection_from_image`).
 7. **Verify.** `render_preview` at 1024 px or more, and `capture_view` on the edge at 2–8×.
    **Check:** no fringe of the old background colour, no stair-steps, no visible line where an
    adjustment ends. Fix by loading the mask back (`load_selection_from_mask`), refining, and
@@ -91,7 +95,7 @@ This skill is the method. `pixerate-image-editor` has the full tool reference.
 | A colour spread across the image (all the reds, a dress) | `select_color_range` with `samples` (several picks) or a hue `preset`; `localized` to keep one area |
 | Tones (shadows, highlights, a luminosity mask) | `select_color_range` with `preset` `shadows` / `midtones` / `highlights` |
 | Skin for retouching | `select_color_range` `preset: "skinTones"`, then `intersect` with a box around the face |
-| An AI matte or saved mask from the host | `load_selection_from_image` (soft: no `threshold`), then `refine_selection` |
+| An AI matte or saved mask from the host | `load_selection_from_image` (soft: no `threshold`), then `refine_selection`; `load_channel_from_image` to keep it for later |
 | An existing layer mask | `load_selection_from_mask` |
 | A cutout, shape or text already on its own layer | `select_layer_transparency` (exact, soft where the layer is) |
 | A dead pixel row or column | `select_line`, then fill or heal it |
@@ -178,6 +182,8 @@ This skill is the method. `pixerate-image-editor` has the full tool reference.
 - `reselect`: undo a deselect
 - `save_selection`, `load_selection_from_channel`, `list_channels`: keep selections as alpha channels
 - `set_channel_properties`, `duplicate_channel`, `delete_channel`: manage channels
+- `export_mask_image`: a selection, channel or layer mask as a greyscale PNG
+- `load_channel_from_image`: a mask image into a new channel
 - `set_quick_mask`: paint the selection
 - `fill_pixels`, `blur_stroke`: fill or soften the selection in Quick Mask mode
 - `magic_wand`: similar colour from a seed