@pixerate/editor 0.214.0 → 0.215.0

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

@@ -37,6 +37,7 @@ export * from './layers/smart.cjs';
 export * from './smart-tools.cjs';
 export * from './layers/shape.cjs';
 export * from './layers/vector-mask.cjs';
+export * from './layers/edge-color.cjs';
 export * from './shape-tools.cjs';
 export * from './layers/text.cjs';
 export * from './layers/text-shapers.cjs';

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

@@ -37,6 +37,7 @@ export * from './layers/smart.js';
 export * from './smart-tools.js';
 export * from './layers/shape.js';
 export * from './layers/vector-mask.js';
+export * from './layers/edge-color.js';
 export * from './shape-tools.js';
 export * from './layers/text.js';
 export * from './layers/text-shapers.js';

package/dist/image-editor/index.js

@@ -7,9 +7,7 @@ import {
 } from "../chunk-DJBYJOHM.js";
 import {
   ColorGmm,
-  DEFAULT_REFINE_EDGE_PARAMS,
   GAMMA,
-  GUIDED_FILTER_EPS,
   GridGraph,
   REFINE_EDIT_KINDS,
   SelectionWorkerClient,
@@ -17,31 +15,22 @@ import {
   WORK_SIZE,
   applyRefineEdits,
   boxBlur,
-  boxMean,
   brushStrokeMask,
-  decontaminateColors,
   deserializeMask,
-  edgeWidth,
   ellipsePoints,
   ellipseSelection,
   findSky,
   findSubject,
   focusArea,
   grabCutLabels,
-  guidePlanes,
-  guidedFilterColor,
   keepMainPieces,
   normalizeRect,
-  normalizeRefineEdgeParams,
   otsuThreshold,
   polygonCoverage,
   polygonCoverageBox,
   polygonSelection,
   quickSelectStroke,
   rectSelection,
-  refineCoverage,
-  refineEdgeHalo,
-  refineSelection,
   runSelectionJob,
   selectObjectIn,
   serializeMask,
@@ -54,7 +43,7 @@ import {
   workImage,
   workLuma,
   workPlanes
-} from "../chunk-LQ5SALHK.js";
+} from "../chunk-U7C655AM.js";
 import {
   ADJUSTMENT_KEYS,
   ADJUSTMENT_KINDS,
@@ -72,6 +61,7 @@ import {
   DEFAULT_MITER_LIMIT,
   DEFAULT_TRANSFORM_VALUES,
   DEVELOP_FILTER_ID,
+  EDGE_COLOR_RADIUS,
   FREE_TRANSFORM_MODES,
   HUE_RANGE_LABELS,
   IDENTITY_MATRIX3,
@@ -127,6 +117,7 @@ import {
   applyBoxBlur,
   applyBoxBlurFloat,
   applyDepthMask,
+  applyEdgeUnmix,
   applyImageProjectionToContext,
   applyLegacyAdjustments,
   applyLegacyFloat,
@@ -175,6 +166,7 @@ import {
   deserializeLayer,
   deserializeLayers,
   deserializePatterns,
+  despillEdge,
   developFilter,
   developFromAdjustments,
   developTarget,
@@ -197,7 +189,9 @@ import {
   getViewportMetrics,
   getViewportProjection,
   groupLayers,
+  hasEdgeUnmix,
   hasResampledLegacyMask,
+  hasSoftBand,
   hasSurface,
   hasWarp,
   hexToRgb,
@@ -248,6 +242,7 @@ import {
   liveShapeSubpaths,
   mapCropHandle,
   mapSubpaths,
+  maskCoverageOverCanvas,
   matrixFromCorners,
   matrixFromParams,
   mergeShapeComponents,
@@ -302,6 +297,7 @@ import {
   rasterMaskFromLegacy,
   rasterizeCoverage,
   rasterizeSmartObject,
+  readEdgeColor,
   readPsd,
   readShapeComponents,
   referencePoint,
@@ -404,34 +400,45 @@ import {
   writePsd,
   xyToTempTint,
   xyToUv
-} from "../chunk-W3TOZTL7.js";
+} from "../chunk-F7Z2MKY2.js";
 import {
   parseCssColor
 } from "../chunk-3CI7FRMK.js";
 import {
+  DEFAULT_REFINE_EDGE_PARAMS,
   EMPTY_DISTANCE,
+  GUIDED_FILTER_EPS,
   SELECTION_MODES,
   SELECTION_MODIFY_OPS,
   borderCoverage,
+  boxMean,
   combineSelections,
   computeSelectionBounds,
   contractCoverage,
   coverageToByte,
   createSelectionMask,
   decodeSelectionRle,
+  decontaminateColors,
   deserializeSelection,
   distanceTransform,
+  edgeWidth,
   encodeSelectionRle,
   expandCoverage,
   featherCoverage,
   fullSelection,
   greyMorphology,
+  guidePlanes,
+  guidedFilterColor,
   hashMaskContent,
   invertSelection,
   isSelectionEmpty,
   isSelectionMode,
   modifySelection,
+  normalizeRefineEdgeParams,
   parseSelectionMode,
+  refineCoverage,
+  refineEdgeHalo,
+  refineSelection,
   resizeSelection,
   selectionArea,
   selectionFromCoverage,
@@ -444,7 +451,7 @@ import {
   serializeSelection,
   shiftCoverage,
   smoothCoverage
-} from "../chunk-L3G23N5Y.js";
+} from "../chunk-ZNA3IQZF.js";
 import {
   EffectRendererPool
 } from "../chunk-EHLOCVWB.js";
@@ -500,7 +507,7 @@ import {
   validateLayerEffects,
   warpSurface,
   workingToSamples
-} from "../chunk-YBJXCQTR.js";
+} from "../chunk-QXY4YTRI.js";
 import {
   applyHomography,
   boxQuad,
@@ -2777,7 +2784,7 @@ function inspectMaskEdge(mask, image, options = {}) {
   const worst = candidates.sort((p, q) => q.severity - p.severity).slice(0, 5).map(({ bounds, reason }) => ({ bounds, reason }));
   const issues = [];
   if (haloScore >= T2.halo)
-    issues.push(`Halo (haloScore ${r3(haloScore)} \u2265 ${T2.halo}): background colour is left inside the edge. Contract the edge (modify_selection contract 1\u20132 px, or refine_selection shiftEdge -20 to -40), or decontaminate on a new-layer output.`);
+    issues.push(`Halo (haloScore ${r3(haloScore)} \u2265 ${T2.halo}): background colour is left inside the edge. Contract the edge (modify_selection contract 1\u20132 px, or refine_selection shiftEdge -20 to -40), or on a masked cutout set_edge_decontamination 80\u2013100.`);
   if (edgeLength >= 16 && edgeAlignment < T2.alignment)
     issues.push(`Off the image's edges (edgeAlignment ${r3(edgeAlignment)} < ${T2.alignment}): much of the edge does not follow edges in the image. Rebuild it with select_subject, select_object or quick_select, or refine_selection with a larger radius.`);
   if (jaggedness >= T2.jaggedness) issues.push(`Jagged (jaggedness ${r3(jaggedness)} \u2265 ${T2.jaggedness}): the outline zigzags. Smooth it (refine_selection smooth 20\u201340, or modify_selection smooth).`);
@@ -6822,6 +6829,85 @@ var ImageEditorController = class {
     this.commitLayers(next);
     return { parentId: loc.parent?.id ?? null, index: loc.index };
   }
+  /** A layer's edge colour as percentages (see `setEdgeColor`). */
+  getEdgeColor(id) {
+    const layer = this.requireEdgeLayer(id);
+    const e = layer.edge ?? {};
+    const pct2 = (v) => Math.round((v ?? 0) * 1e3) / 10;
+    const hex = (c) => "#" + c.map((v) => v.toString(16).padStart(2, "0")).join("");
+    return { layerId: layer.id, decontaminate: pct2(e.decontaminate), despill: pct2(e.despill), ambient: pct2(e.ambient), ambientSource: e.ambientColor ? hex(e.ambientColor) : "auto" };
+  }
+  requireEdgeLayer(id) {
+    const layer = this.getLayer(id);
+    if (!layer) throw new LayerOperationError(`There is no layer "${id}" (see list_layers).`);
+    if (layer.type === "group" || layer.type === "adjustment" || layer.type === "annotation")
+      throw new LayerOperationError(`Edge colour works on pixel, shape, type and smart object layers; "${layer.name || id}" is a ${layer.type} layer.`);
+    return layer;
+  }
+  /** Whether the layer's mask (painted and vector, with feather) has a soft band. */
+  maskHasSoftBand(layer) {
+    const { width, height } = this.naturalSize;
+    const mask = effectiveLayerMask(layer, width, height);
+    if (!mask || mask.enabled === false || mask.source) return false;
+    const ox = layer.type === "pixel" ? layer.offset.x : 0;
+    const oy = layer.type === "pixel" ? layer.offset.y : 0;
+    return hasSoftBand(maskCoverageOverCanvas(mask, ox, oy, width, height));
+  }
+  /**
+   * Edge colour on a layer's soft edge, applied when compositing (nothing is baked); amounts in
+   * percent, 0 turns one off. `decontaminate` unmixes the old background (the pixels the mask
+   * hides) from the edge and `despill` limits its hue there: both need a pixel layer whose mask
+   * (painted or vector) has a soft band. `ambient` pulls the edge toward what is behind the layer
+   * (`ambientColor` null: sampled live) or a fixed `#rrggbb`; it needs a soft mask or soft
+   * pixels at the edge. Validates everything before changing anything; one undo step (none with
+   * `commitToHistory` false, for the later moves of a slider drag). Returns the effective settings.
+   */
+  setEdgeColor(id, change, commitToHistory = true) {
+    const layer = this.requireEdgeLayer(id);
+    const name = layer.name || id;
+    const next = { ...layer.edge ?? {} };
+    for (const k of ["decontaminate", "despill", "ambient"]) {
+      const v = change[k];
+      if (v === void 0) continue;
+      if (typeof v !== "number" || !Number.isFinite(v) || v < 0 || v > 100) throw new LayerOperationError(`${k} must be a percentage from 0 to 100, got ${String(v)}.`);
+      if (v > 0) next[k] = v / 100;
+      else delete next[k];
+    }
+    if (change.ambientColor !== void 0) {
+      if (change.ambientColor === null || change.ambientColor === "auto") delete next.ambientColor;
+      else {
+        const m = /^#([0-9a-f]{6})$/i.exec(String(change.ambientColor));
+        if (!m) throw new LayerOperationError(`ambient colour must be "auto" or #rrggbb, got "${String(change.ambientColor)}".`);
+        const n = parseInt(m[1], 16);
+        next.ambientColor = [n >> 16 & 255, n >> 8 & 255, n & 255];
+      }
+    }
+    const unmix = (next.decontaminate ?? 0) > 0 || (next.despill ?? 0) > 0;
+    const turningOn = (k) => (change[k] ?? 0) > 0;
+    if (unmix && (turningOn("decontaminate") || turningOn("despill"))) {
+      if (layer.type !== "pixel") throw new LayerOperationError(`Decontamination and despill need a pixel layer with a soft-edged mask; "${name}" is a ${layer.type} layer (rasterize it, or use ambient).`);
+      if (!this.maskHasSoftBand(layer))
+        throw new LayerOperationError(`"${name}" has no mask with a soft edge: decontamination and despill work in the partly hidden band of a layer mask. Add one with add_layer_mask from a refined selection (refine_selection), or feather the mask (set_layer_mask_properties feather).`);
+    }
+    if (turningOn("ambient") && !this.maskHasSoftBand(layer) && layer.type === "pixel") {
+      const px2 = this.getLayerPixels(layer.id);
+      let soft = false;
+      if (px2) for (let i = 3; i < px2.data.length && !soft; i += 4) soft = px2.data[i] > 5 && px2.data[i] < 250;
+      if (!soft) throw new LayerOperationError(`"${name}" has no soft edge (no soft-edged mask and no partly transparent pixels) for the edge cast to work on.`);
+    }
+    const edge = next.decontaminate || next.despill || next.ambient || next.ambientColor ? next : void 0;
+    this.commitLayers(
+      mapLayer(this.state.layers, layer.id, (l) => {
+        const out = { ...l };
+        if (edge) out.edge = edge;
+        else delete out.edge;
+        return out;
+      }),
+      void 0,
+      commitToHistory
+    );
+    return this.getEdgeColor(layer.id);
+  }
   /**
    * Changes name, visibility, opacity, fill, blend, clipping, locks or (groups) collapsed state, as
    * one undo step (`commitToHistory = false` for the moves of a slider drag). Returns the layer.
@@ -11372,7 +11458,9 @@ var ImageEditorController = class {
       return baked;
     };
     const prepare = async (layer) => {
+      if (layer.edge?.ambient) add2("The live edge cast (set_edge_ambient) has no PSD equivalent and was left out", layer.name);
       const p = await prepareLayer(layer);
+      if (p?.edge) delete p.edge;
       if (p?.blend === "pigment") add2("The Pigment blend mode has no PSD equivalent and was written as Normal", layer.name);
       return p;
     };
@@ -11448,6 +11536,14 @@ var ImageEditorController = class {
       }
       if (layer.filters?.some((f) => !f.enabled)) add2("Disabled layer filters were left out", layer.name);
       delete out.filters;
+      const unmixMask = hasEdgeUnmix(layer.edge) ? effectiveLayerMask(layer, width, height) : void 0;
+      if (unmixMask && !unmixMask.source && unmixMask.enabled !== false) {
+        add2("Edge decontamination and despill were baked into the pixels", layer.name);
+        const { x: ox, y: oy } = layer.offset;
+        const data = readRegion(out.surface, { x: -ox, y: -oy, width, height });
+        applyEdgeUnmix(data, maskCoverageOverCanvas(unmixMask, ox, oy, width, height), width, height, layer.edge);
+        out = { ...out, surface: surfaceFromPixels({ width, height, data }, 4, -ox, -oy) };
+      }
       const mask = bakeMask(layer);
       if (mask) out.mask = mask;
       else delete out.mask;
@@ -14809,6 +14905,49 @@ function createImageLayerTools(controller) {
       return { view: shown?.mode ?? "off", layerId: shown?.layerId ?? null };
     }
   };
+  const AMOUNT = (what) => ({ type: "number", minimum: 0, maximum: 100, description: `${what}, in percent 0-100; 0 turns it off.` });
+  const EDGE_RETURNS = "Returns the layer's effective edge colour: { layerId, decontaminate, despill, ambient (percent), ambientSource }.";
+  const getEdge = {
+    name: "get_edge_color",
+    title: "Read edge colour",
+    description: `A layer's edge colour settings, applied when compositing: decontaminate, despill and ambient (percent) and ambientSource (auto or #rrggbb). ${EDGE_RETURNS}`,
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID2 }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Read edge colour", ...READ2 },
+    handler: ({ layerId }) => controller.getEdgeColor(String(layerId))
+  };
+  const setDecontaminate = {
+    name: "set_edge_decontamination",
+    title: "Decontaminate edge colour",
+    description: `Removes the old background's colour from a cutout's soft edge at composite time (nothing is baked; change or turn it off any time): each partly hidden edge pixel is unmixed from the background next to it (the pixels the layer's mask hides). Needs a pixel layer whose mask (painted or vector) has a soft band, e.g. add_layer_mask from a refined selection. Check with inspect_mask_edge (haloScore) and capture_view. One undo step. ${EDGE_RETURNS}`,
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID2, amount: AMOUNT("How much to replace edge colour with the subject's own (80-100 typical)") }, required: ["layerId", "amount"], additionalProperties: false },
+    annotations: { title: "Decontaminate edge colour", ...WRITE_IDEMPOTENT2 },
+    handler: ({ layerId, amount }) => controller.setEdgeColor(String(layerId), { decontaminate: amount })
+  };
+  const setDespill = {
+    name: "set_edge_despill",
+    title: "Despill edge colour",
+    description: `Limits how much of the old background's hue a cutout's soft edge carries (a green-screen or coloured-wall fringe), at composite time: the edge colour's component toward the background's hue is taken out, luminance kept, most at the outer edge. A heuristic: it does not remove light that bounced onto the subject itself. Needs a pixel layer whose mask has a soft band. Pixels fully inside the mask never change. One undo step. ${EDGE_RETURNS}`,
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID2, amount: AMOUNT("How much of the background hue to take out (50-100 typical)") }, required: ["layerId", "amount"], additionalProperties: false },
+    annotations: { title: "Despill edge colour", ...WRITE_IDEMPOTENT2 },
+    handler: ({ layerId, amount }) => controller.setEdgeColor(String(layerId), { despill: amount })
+  };
+  const setAmbient = {
+    name: "set_edge_ambient",
+    title: "Cast the scene onto an edge",
+    description: `Tints a cutout's soft edge with what is behind it now, live at composite time, so a subject moved onto a new background picks up its colour at the edge (more where the edge is more transparent). source auto samples the layers below as they change; #rrggbb uses a fixed colour. Works on soft-edged masks or partly transparent pixels (pixel, shape, type and smart object layers). One undo step. ${EDGE_RETURNS}`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        layerId: LAYER_ID2,
+        amount: AMOUNT("How far edge colour moves toward the background (20-50 typical)"),
+        source: { type: "string", pattern: "^(auto|#[0-9a-fA-F]{6})$", description: "auto (default): what is behind the layer, sampled live; or a fixed #rrggbb." }
+      },
+      required: ["layerId", "amount"],
+      additionalProperties: false
+    },
+    annotations: { title: "Cast the scene onto an edge", ...WRITE_IDEMPOTENT2 },
+    handler: ({ layerId, amount, source }) => controller.setEdgeColor(String(layerId), { ambient: amount, ambientColor: source ?? "auto" })
+  };
   const maskProps = {
     name: "set_layer_mask_properties",
     title: "Set layer mask properties",
@@ -14951,6 +15090,10 @@ function createImageLayerTools(controller) {
     removeMask,
     maskView,
     maskProps,
+    getEdge,
+    setDecontaminate,
+    setDespill,
+    setAmbient,
     viaCopy,
     rasterize,
     addFilter,
@@ -21578,6 +21721,7 @@ export {
   DIRECT_GAUSSIAN_MAX_SIGMA,
   DRY_EPS,
   DabWalker,
+  EDGE_COLOR_RADIUS,
   EFFECT_LAYER_USES,
   EMPTY_DISTANCE,
   EMPTY_MIXER_LOAD,
@@ -21820,6 +21964,7 @@ export {
   applyBoxBlur,
   applyBoxBlurFloat,
   applyDepthMask,
+  applyEdgeUnmix,
   applyHomography,
   applyImageProjectionToContext,
   applyLegacyAdjustments,
@@ -21995,6 +22140,7 @@ export {
   deserializeMask,
   deserializePatterns,
   deserializeSelection,
+  despillEdge,
   developFilter,
   developFromAdjustments,
   developTarget,
@@ -22090,8 +22236,10 @@ export {
   handleQuickMaskKey,
   handleSelectionShortcut,
   hasActiveEffects,
+  hasEdgeUnmix,
   hasLayersBelow,
   hasResampledLegacyMask,
+  hasSoftBand,
   hasSurface,
   hasWarp,
   hash2,
@@ -22221,6 +22369,7 @@ export {
   mapLayer,
   mapSubpaths,
   maskBounds,
+  maskCoverageOverCanvas,
   maskFileName,
   maskNameFromFile,
   maskSummary,
@@ -22363,6 +22512,7 @@ export {
   rasterizeSmartObject,
   readAdjustmentControls,
   readDeepRegion,
+  readEdgeColor,
   readPaintSource,
   readPaths,
   readPixel,

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-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";