@pixerate/editor 0.213.0 → 0.215.0

package/dist/image-editor/layers/edge-color.d.cts

@@ -0,0 +1,27 @@
+/**
+ * Edge colour on a layer's soft edge (`LayerEdgeColor`): decontamination and despill, run over the
+ * canvas by the compositor from the layer's own pixels and its mask, so nothing is baked. The live
+ * edge cast (`ambient`) needs what is behind the layer and runs in the compositor's blend step.
+ */
+import type { LayerEdgeColor, RasterMask } from '../../raster/layers.cjs';
+/** How far (px) the old background's colour is looked for around the edge. */
+export declare const EDGE_COLOR_RADIUS = 8;
+/** True when decontamination or despill is on (they need the layer's mask). */
+export declare function hasEdgeUnmix(edge: LayerEdgeColor | undefined): boolean;
+/**
+ * A mask's coverage (0..255) over the canvas, `width × height`, for a layer at `offset`: the
+ * painted mask with its feather (density only changes how much shows, not the matte).
+ */
+export declare function maskCoverageOverCanvas(mask: RasterMask, ox: number, oy: number, width: number, height: number): Uint8ClampedArray;
+/** True when a coverage has a soft band (some pixels partly covered). */
+export declare function hasSoftBand(coverage: ArrayLike<number>): boolean;
+/**
+ * Despill: along a soft edge, takes out (by `amount`, 0..1) the part of each pixel's colour that
+ * points the way of the old background's hue (its local mean, from what is fully outside within
+ * `radius`). Luminance is kept, pixels fully in or out are unchanged, and the outer edge (more
+ * background) gets the most. It does not remove light that bounced onto the subject itself.
+ * Works in place on RGBA `rgba` with `coverage` (0..255) over the same `w × h`.
+ */
+export declare function despillEdge(rgba: Uint8ClampedArray, coverage: ArrayLike<number>, w: number, h: number, amount: number, radius?: number): void;
+/** Decontamination, then despill, of canvas RGBA `rgba` (`w × h`) in place, given the mask's coverage. */
+export declare function applyEdgeUnmix(rgba: Uint8ClampedArray, coverage: ArrayLike<number>, w: number, h: number, edge: LayerEdgeColor): void;

package/dist/image-editor/layers/edge-color.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Edge colour on a layer's soft edge (`LayerEdgeColor`): decontamination and despill, run over the
+ * canvas by the compositor from the layer's own pixels and its mask, so nothing is baked. The live
+ * edge cast (`ambient`) needs what is behind the layer and runs in the compositor's blend step.
+ */
+import type { LayerEdgeColor, RasterMask } from '../../raster/layers.js';
+/** How far (px) the old background's colour is looked for around the edge. */
+export declare const EDGE_COLOR_RADIUS = 8;
+/** True when decontamination or despill is on (they need the layer's mask). */
+export declare function hasEdgeUnmix(edge: LayerEdgeColor | undefined): boolean;
+/**
+ * A mask's coverage (0..255) over the canvas, `width × height`, for a layer at `offset`: the
+ * painted mask with its feather (density only changes how much shows, not the matte).
+ */
+export declare function maskCoverageOverCanvas(mask: RasterMask, ox: number, oy: number, width: number, height: number): Uint8ClampedArray;
+/** True when a coverage has a soft band (some pixels partly covered). */
+export declare function hasSoftBand(coverage: ArrayLike<number>): boolean;
+/**
+ * Despill: along a soft edge, takes out (by `amount`, 0..1) the part of each pixel's colour that
+ * points the way of the old background's hue (its local mean, from what is fully outside within
+ * `radius`). Luminance is kept, pixels fully in or out are unchanged, and the outer edge (more
+ * background) gets the most. It does not remove light that bounced onto the subject itself.
+ * Works in place on RGBA `rgba` with `coverage` (0..255) over the same `w × h`.
+ */
+export declare function despillEdge(rgba: Uint8ClampedArray, coverage: ArrayLike<number>, w: number, h: number, amount: number, radius?: number): void;
+/** Decontamination, then despill, of canvas RGBA `rgba` (`w × h`) in place, given the mask's coverage. */
+export declare function applyEdgeUnmix(rgba: Uint8ClampedArray, coverage: ArrayLike<number>, w: number, h: number, edge: LayerEdgeColor): void;

package/dist/image-editor/layers/serialize.d.cts

@@ -1,3 +1,12 @@
+/**
+ * Schema version 3 of the image editor document: the layer tree, with pixel layers and painted
+ * masks stored as PNG assets (cropped to their content and placed by position), plus the
+ * document-level crop, transform, output opacity, migrated blur and selection.
+ *
+ * Encoding is synchronous and exact (see `png.ts`). Each surface's encoding is memoised, so
+ * saving an unchanged layer again costs nothing.
+ */
+import type { LayerEdgeColor } from '../../raster/layers.cjs';
 import type { SerializedDocumentPath } from '../paths.cjs';
 import type { Annotation, CropBox, DepthMaskOptions, ImageTransform } from '../types.cjs';
 import type { SerializedSelection } from '../selection/mask.cjs';
@@ -36,6 +45,8 @@ interface SerializedLayerBase {
     vectorMask?: SerializedVectorMask;
     locks?: LayerLocks;
     effects?: SerializedLayerEffects;
+    /** Edge colour amounts 0..1 and the cast colour (see `LayerEdgeColor`). */
+    edge?: LayerEdgeColor;
 }
 /** A stored vector mask: its components as JSON (document pixels) and its properties. */
 export interface SerializedVectorMask {
@@ -271,6 +282,8 @@ export interface SerializeContext {
     /** Stores a smart object's contents (once per id). Without it, smart objects cannot be written. */
     addContents?(contents: SmartContents): void;
 }
+/** Stored edge colour, with amounts clamped to 0..1 (none when nothing is on). */
+export declare function readEdgeColor(raw: unknown): LayerEdgeColor | undefined;
 export declare function serializeEffects(effects: LayerEffects): SerializedLayerEffects;
 /** Reads stored effects (leniently: broken effects are dropped), or `undefined`. */
 export declare function deserializeEffects(raw: unknown): LayerEffects | undefined;

package/dist/image-editor/layers/serialize.d.ts

@@ -1,3 +1,12 @@
+/**
+ * Schema version 3 of the image editor document: the layer tree, with pixel layers and painted
+ * masks stored as PNG assets (cropped to their content and placed by position), plus the
+ * document-level crop, transform, output opacity, migrated blur and selection.
+ *
+ * Encoding is synchronous and exact (see `png.ts`). Each surface's encoding is memoised, so
+ * saving an unchanged layer again costs nothing.
+ */
+import type { LayerEdgeColor } from '../../raster/layers.js';
 import type { SerializedDocumentPath } from '../paths.js';
 import type { Annotation, CropBox, DepthMaskOptions, ImageTransform } from '../types.js';
 import type { SerializedSelection } from '../selection/mask.js';
@@ -36,6 +45,8 @@ interface SerializedLayerBase {
     vectorMask?: SerializedVectorMask;
     locks?: LayerLocks;
     effects?: SerializedLayerEffects;
+    /** Edge colour amounts 0..1 and the cast colour (see `LayerEdgeColor`). */
+    edge?: LayerEdgeColor;
 }
 /** A stored vector mask: its components as JSON (document pixels) and its properties. */
 export interface SerializedVectorMask {
@@ -271,6 +282,8 @@ export interface SerializeContext {
     /** Stores a smart object's contents (once per id). Without it, smart objects cannot be written. */
     addContents?(contents: SmartContents): void;
 }
+/** Stored edge colour, with amounts clamped to 0..1 (none when nothing is on). */
+export declare function readEdgeColor(raw: unknown): LayerEdgeColor | undefined;
 export declare function serializeEffects(effects: LayerEffects): SerializedLayerEffects;
 /** Reads stored effects (leniently: broken effects are dropped), or `undefined`. */
 export declare function deserializeEffects(raw: unknown): LayerEffects | undefined;

package/dist/image-editor/selection/index.d.cts

@@ -17,3 +17,4 @@ export * from './segment/index.cjs';
 export * from './refine-edits.cjs';
 export * from './select-and-mask.cjs';
 export * from './worker.cjs';
+export * from './inspect.cjs';

package/dist/image-editor/selection/index.d.ts

@@ -17,3 +17,4 @@ export * from './segment/index.js';
 export * from './refine-edits.js';
 export * from './select-and-mask.js';
 export * from './worker.js';
+export * from './inspect.js';

package/dist/image-editor/selection/inspect.d.cts

@@ -0,0 +1,70 @@
+/**
+ * A measured report on a mask's edge (`inspect_mask_edge`), so an agent can check a selection or
+ * a mask without looking at it: halo (old background left just inside the edge), how much of the
+ * edge sits on the image's own edges, how jagged the outline is, how soft it is, holes and stray
+ * islands, and the worst places to look at. Read-only; works in the mask's bounds.
+ */
+import type { CropBox } from '../types.cjs';
+import type { PixelBuffer, SelectionMask } from './mask.cjs';
+export interface InspectMaskEdgeOptions {
+    /** Holes and islands smaller than this many pixels are left out (default 16). */
+    minArea?: number;
+}
+/** A hole or island: its area in pixels and bounds. */
+export interface MaskRegion {
+    area: number;
+    bounds: CropBox;
+}
+export interface MaskEdgeReport {
+    /** Pixels at least half covered. */
+    area: number;
+    bounds: CropBox;
+    /** Pixels along the edge (inside, at least half covered, beside one less than half). */
+    edgeLength: number;
+    /**
+     * 0–1: how close the colour just inside the edge is to the colour just outside it, relative to
+     * the colour further in (0: the edge ring looks like the subject; 1: it looks like the
+     * background). Measured only where the inside and outside differ.
+     */
+    haloScore: number;
+    /** 0–1: the share of the edge within 2 px of a strong image edge. */
+    edgeAlignment: number;
+    /** Turning of the outline beyond what closing it needs, in radians per 100 px of outline (0: smooth). */
+    jaggedness: number;
+    /** 0–1: the share of edge pixels that are partly covered (0 < α < 1). */
+    softFraction: number;
+    /** Unselected areas enclosed by the selection, largest first (at most 10 listed). */
+    holes: {
+        count: number;
+        totalArea: number;
+        largest: MaskRegion[];
+    };
+    /** Selected pieces apart from the largest one, largest first (at most 10 listed). */
+    islands: {
+        count: number;
+        totalArea: number;
+        largest: MaskRegion[];
+    };
+    /** Up to 5 places to look at first (for `capture_view`), worst first. */
+    worst: Array<{
+        bounds: CropBox;
+        reason: string;
+    }>;
+    /** Plain-language findings with a suggested fix, empty when the edge looks clean. */
+    issues: string[];
+}
+/** Report thresholds (also in the masking skill). */
+export declare const MASK_EDGE_THRESHOLDS: {
+    readonly halo: 0.35;
+    readonly alignment: 0.5;
+    readonly jaggedness: 15;
+    readonly soft: 0.9;
+};
+/**
+ * Inspects `mask`'s edge against `image` (RGBA, straight alpha, covering document pixels from
+ * `image.x`, `image.y`; outside it counts as transparent). Throws for an empty mask.
+ */
+export declare function inspectMaskEdge(mask: SelectionMask, image: PixelBuffer & {
+    x: number;
+    y: number;
+}, options?: InspectMaskEdgeOptions): MaskEdgeReport;

package/dist/image-editor/selection/inspect.d.ts

@@ -0,0 +1,70 @@
+/**
+ * A measured report on a mask's edge (`inspect_mask_edge`), so an agent can check a selection or
+ * a mask without looking at it: halo (old background left just inside the edge), how much of the
+ * edge sits on the image's own edges, how jagged the outline is, how soft it is, holes and stray
+ * islands, and the worst places to look at. Read-only; works in the mask's bounds.
+ */
+import type { CropBox } from '../types.js';
+import type { PixelBuffer, SelectionMask } from './mask.js';
+export interface InspectMaskEdgeOptions {
+    /** Holes and islands smaller than this many pixels are left out (default 16). */
+    minArea?: number;
+}
+/** A hole or island: its area in pixels and bounds. */
+export interface MaskRegion {
+    area: number;
+    bounds: CropBox;
+}
+export interface MaskEdgeReport {
+    /** Pixels at least half covered. */
+    area: number;
+    bounds: CropBox;
+    /** Pixels along the edge (inside, at least half covered, beside one less than half). */
+    edgeLength: number;
+    /**
+     * 0–1: how close the colour just inside the edge is to the colour just outside it, relative to
+     * the colour further in (0: the edge ring looks like the subject; 1: it looks like the
+     * background). Measured only where the inside and outside differ.
+     */
+    haloScore: number;
+    /** 0–1: the share of the edge within 2 px of a strong image edge. */
+    edgeAlignment: number;
+    /** Turning of the outline beyond what closing it needs, in radians per 100 px of outline (0: smooth). */
+    jaggedness: number;
+    /** 0–1: the share of edge pixels that are partly covered (0 < α < 1). */
+    softFraction: number;
+    /** Unselected areas enclosed by the selection, largest first (at most 10 listed). */
+    holes: {
+        count: number;
+        totalArea: number;
+        largest: MaskRegion[];
+    };
+    /** Selected pieces apart from the largest one, largest first (at most 10 listed). */
+    islands: {
+        count: number;
+        totalArea: number;
+        largest: MaskRegion[];
+    };
+    /** Up to 5 places to look at first (for `capture_view`), worst first. */
+    worst: Array<{
+        bounds: CropBox;
+        reason: string;
+    }>;
+    /** Plain-language findings with a suggested fix, empty when the edge looks clean. */
+    issues: string[];
+}
+/** Report thresholds (also in the masking skill). */
+export declare const MASK_EDGE_THRESHOLDS: {
+    readonly halo: 0.35;
+    readonly alignment: 0.5;
+    readonly jaggedness: 15;
+    readonly soft: 0.9;
+};
+/**
+ * Inspects `mask`'s edge against `image` (RGBA, straight alpha, covering document pixels from
+ * `image.x`, `image.y`; outside it counts as transparent). Throws for an empty mask.
+ */
+export declare function inspectMaskEdge(mask: SelectionMask, image: PixelBuffer & {
+    x: number;
+    y: number;
+}, options?: InspectMaskEdgeOptions): MaskEdgeReport;

package/dist/image-editor/selection-worker.cjs

@@ -1,15 +1,15 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkL52VMQZScjs = require('../chunk-L52VMQZS.cjs');
-require('../chunk-QYLWG22N.cjs');
+var _chunkUC3PWFM3cjs = require('../chunk-UC3PWFM3.cjs');
+require('../chunk-SS53NNZO.cjs');
 require('../chunk-K6PXS6DO.cjs');
 require('../chunk-MQDIP4CF.cjs');
 require('../chunk-474IQG74.cjs');
 
 // src/image-editor/selection-worker.ts
 if (typeof self !== "undefined" && typeof window === "undefined" && typeof self.postMessage === "function") {
-  _chunkL52VMQZScjs.startSelectionWorker.call(void 0, self);
+  _chunkUC3PWFM3cjs.startSelectionWorker.call(void 0, self);
 }
 
 
-exports.startSelectionWorker = _chunkL52VMQZScjs.startSelectionWorker;
+exports.startSelectionWorker = _chunkUC3PWFM3cjs.startSelectionWorker;

package/dist/image-editor/selection-worker.js

@@ -1,7 +1,7 @@
 import {
   startSelectionWorker
-} from "../chunk-LQ5SALHK.js";
-import "../chunk-L3G23N5Y.js";
+} from "../chunk-U7C655AM.js";
+import "../chunk-ZNA3IQZF.js";
 import "../chunk-ZIF4UJJ6.js";
 import "../chunk-XI2NV5U7.js";
 import "../chunk-HVVR5PZW.js";