@pixerate/editor 0.219.2 → 0.220.0

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

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

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

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

package/dist/image-editor/index.js

@@ -91,6 +91,7 @@ import {
   TINT_SCALE,
   TONE_LUT_SIZE,
   TRANSFORM_ANCHORS,
+  VECTOR_MASK_EDGE_DEFAULTS,
   VIBRANCE_GREY,
   XYZ_D50_TO_SRGB,
   activeAdjustmentLayers,
@@ -201,6 +202,7 @@ import {
   hueRangeTables,
   hueRangeWeight,
   hueSaturation,
+  hybridVectorMaskCoverage,
   identityCurve,
   identityLevels,
   identityTransform,
@@ -224,6 +226,7 @@ import {
   isValidWarp,
   kelvinToTemperature,
   layerEffectsOf,
+  layerGuide,
   layerMaskCoverage,
   layerMaskFromSelection,
   layerMaskKey,
@@ -383,8 +386,10 @@ import {
   updateTypeLayer,
   userErrorMessage,
   uvToXy,
+  validVectorMaskEdges,
   vectorMaskBounds,
   vectorMaskCoverage,
+  vectorMaskSegments,
   vectorMaskThumbnail,
   versionedDescriptorBytes,
   vibranceLinear,
@@ -400,7 +405,7 @@ import {
   writePsd,
   xyToTempTint,
   xyToUv
-} from "../chunk-F7Z2MKY2.js";
+} from "../chunk-S6KKLFZO.js";
 import {
   parseCssColor
 } from "../chunk-3CI7FRMK.js";
@@ -1822,10 +1827,22 @@ var ImageEditorRenderer = class {
           else ctx.lineTo(b.x, b.y);
         };
         ctx.beginPath();
-        e.curves.forEach(trace2);
+        e.curves.forEach((c, i) => (e.curveModes?.[i] ?? "hard") === "hard" && trace2(c));
         ctx.lineWidth = 1.5 * u;
         ctx.strokeStyle = OVERLAY_HANDLE_EDGE;
         ctx.stroke();
+        for (const [mode, color, width, dash] of [["feather", "#f59e0b", 2, [5, 3]], ["matte", "#d946ef", 3, []]]) {
+          if (!e.curveModes?.includes(mode)) continue;
+          ctx.beginPath();
+          e.curves.forEach((c, i) => e.curveModes[i] === mode && trace2(c));
+          ctx.lineWidth = width * u;
+          ctx.strokeStyle = color;
+          ctx.setLineDash(dash.map((d) => d * u));
+          ctx.stroke();
+          ctx.setLineDash([]);
+        }
+        ctx.lineWidth = 1.5 * u;
+        ctx.strokeStyle = OVERLAY_HANDLE_EDGE;
         if (e.preview) {
           ctx.beginPath();
           trace2(e.preview);
@@ -6931,6 +6948,8 @@ var ImageEditorController = class {
     return String(id);
   }
   /** The pixels a pixel layer, smart object or shape composites (the decoded source for the Background). */
+  /** A layer's real pixels for hybrid vector masks' matte guide (the Background's from the source). */
+  guideSurfaceOf = (layer) => layer.type === "pixel" || layer.type === "smart" || layer.type === "shape" || layer.type === "type" ? this.surfaceOf(layer) : void 0;
   surfaceOf(layer) {
     if (layer.type !== "pixel" || layer.source !== "document") return layer.surface;
     return this.sourceSurface() ?? layer.surface;
@@ -7149,7 +7168,7 @@ var ImageEditorController = class {
   /** 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);
+    const mask = effectiveLayerMask(layer, width, height, this.guideSurfaceOf);
     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;
@@ -7523,7 +7542,11 @@ var ImageEditorController = class {
       this.commitLayers(layers, void 0, commitToHistory);
     } else {
       const { vm } = this.requireVectorMask(target.layerId);
-      this.commitLayers(mapLayer(this.state.layers, target.layerId, (l) => ({ ...l, vectorMask: { ...vm, components: next } })), void 0, commitToHistory);
+      const edges = validVectorMaskEdges(vm.edges, next);
+      const nextVm = { ...vm, components: next };
+      if (edges.length) nextVm.edges = edges;
+      else delete nextVm.edges;
+      this.commitLayers(mapLayer(this.state.layers, target.layerId, (l) => ({ ...l, vectorMask: nextVm })), void 0, commitToHistory);
     }
   }
   /**
@@ -7618,6 +7641,9 @@ var ImageEditorController = class {
   setVectorMaskPath(id, path) {
     const { vm } = this.requireVectorMask(id);
     const next = { ...vm, components: this.vectorMaskComponents(path) };
+    const kept = validVectorMaskEdges(vm.edges, next.components);
+    if (kept.length) next.edges = kept;
+    else delete next.edges;
     if (path.fillRule === "evenodd") next.fillRule = "evenodd";
     else if (path.fillRule === "nonzero") delete next.fillRule;
     this.commitLayers(mapLayer(this.state.layers, id, (l) => ({ ...l, vectorMask: next })));
@@ -7667,7 +7693,7 @@ var ImageEditorController = class {
     const { width, height } = this.canvasSize;
     const raster = layer.mask;
     const plain3 = { ...layer, vectorMask: { ...layer.vectorMask, enabled: true }, mask: raster ? { surface: raster.surface, defaultValue: raster.defaultValue } : void 0 };
-    const baked = effectiveLayerMask(plain3, width, height);
+    const baked = effectiveLayerMask(plain3, width, height, this.guideSurfaceOf);
     const mask = raster ? { ...raster, surface: baked.surface, defaultValue: baked.defaultValue } : baked;
     this.commitLayers(
       mapLayer(this.state.layers, id, (l) => {
@@ -7703,8 +7729,55 @@ var ImageEditorController = class {
       density: vm.density ?? 1,
       feather: vm.feather ?? 0,
       bounds: b ? { x: r(b.x), y: r(b.y), width: r(b.width), height: r(b.height) } : null,
-      components: vm.components.map((c, index) => ({ index, op: c.op, live: c.live ? JSON.parse(JSON.stringify(c.live)) : null, subpaths: roundSubpaths(c.subpaths) }))
+      components: vm.components.map((c, index) => ({ index, op: c.op, live: c.live ? JSON.parse(JSON.stringify(c.live)) : null, subpaths: roundSubpaths(c.subpaths) })),
+      edges: validVectorMaskEdges(vm.edges, vm.components).map((e) => ({ ...e })),
+      segmentCount: vectorMaskSegments(vm.components).length
+    };
+  }
+  /**
+   * Hybrid mask: a vector mask segment's edge mode. `hard` (the default) is the path's own sharp
+   * edge; `feather` blurs across it by `radius` px (default 4); `matte` solves a corridor from
+   * `inner` px inside to `outer` px outside (defaults 4 and 8) from the layer's colours, for hair
+   * and fur. Modes blend where they meet. One undo step. Returns the vector mask's info.
+   */
+  setVectorMaskEdge(id, at, mode, options = {}, commitToHistory = true) {
+    const { layer, vm } = this.requireVectorMask(id);
+    const name = layer.name || id;
+    const sp = vm.components[at.component]?.subpaths[at.subpath];
+    const count = sp ? subpathSegmentCount(sp) : 0;
+    if (!sp || !Number.isInteger(at.segment) || at.segment < 0 || at.segment >= count) {
+      const where = vm.components.map((c, ci) => c.subpaths.map((p, si) => `component ${ci} subpath ${si}: segments 0..${subpathSegmentCount(p) - 1}`).join("; ")).join("; ");
+      throw new LayerOperationError(`The vector mask of "${name}" has no segment ${at.component}/${at.subpath}/${at.segment}; it has ${where || "no segments"} (see get_vector_mask).`);
+    }
+    if (mode !== "hard" && mode !== "feather" && mode !== "matte") throw new LayerOperationError(`mode must be hard, feather or matte, got "${String(mode)}".`);
+    const num3 = (v, what, lo, hi) => {
+      if (v === void 0) return void 0;
+      if (!(typeof v === "number" && Number.isFinite(v) && v >= lo && v <= hi)) throw new LayerOperationError(`${what} must be ${lo} to ${hi} px, got ${String(v)}.`);
+      return v;
     };
+    const radius = num3(options.radius, "radius", 0.5, 250);
+    const inner = num3(options.inner, "inner", 0.5, 200);
+    const outer = num3(options.outer, "outer", 0.5, 200);
+    if (mode !== "feather" && radius !== void 0) throw new LayerOperationError("radius is for feather edges; matte edges take inner and outer.");
+    if (mode !== "matte" && (inner !== void 0 || outer !== void 0)) throw new LayerOperationError("inner and outer are for matte edges; feather edges take radius.");
+    const same = (e) => e.component === at.component && e.subpath === at.subpath && e.segment === at.segment;
+    const edges = validVectorMaskEdges(vm.edges, vm.components).filter((e) => !same(e));
+    if (mode === "feather") edges.push({ ...at, mode, radius: radius ?? VECTOR_MASK_EDGE_DEFAULTS.radius });
+    else if (mode === "matte") edges.push({ ...at, mode, inner: inner ?? VECTOR_MASK_EDGE_DEFAULTS.inner, outer: outer ?? VECTOR_MASK_EDGE_DEFAULTS.outer });
+    const next = { ...vm };
+    if (edges.length) next.edges = edges;
+    else delete next.edges;
+    this.commitLayers(mapLayer(this.state.layers, layer.id, (l) => ({ ...l, vectorMask: next })), void 0, commitToHistory);
+    return this.getVectorMask(layer.id);
+  }
+  /** A layer's vector mask over the canvas as a selection mask, hybrid edges, feather and density included. */
+  vectorMaskSelection(layer) {
+    const { width, height } = this.naturalSize;
+    const vm = layer.vectorMask;
+    const v = vectorMaskCoverage(vm, width, height, vm.edges?.length ? layerGuide(layer, width, height, this.guideSurfaceOf) : null);
+    const bytes = new Uint8Array(v.length);
+    for (let i = 0; i < v.length; i++) bytes[i] = Math.round(v[i] * 255);
+    return createSelectionMask(width, height, bytes);
   }
   /** Changes any layer mask's density, feather, enabled or linked flag (pixels kept). Returns the mask. */
   setLayerMaskProps(id, props, commitToHistory = true) {
@@ -10546,9 +10619,8 @@ var ImageEditorController = class {
         mask = this.layerMaskCoverage(layer.id);
         if (!mask) throw new LayerOperationError(`Layer "${layer.name || layer.id}" has no painted mask; add one with add_layer_mask, or inspect its vector-mask.`);
       } else {
-        const { vm } = this.requireVectorMask(layer.id);
-        mask = pathToSelection(vm.components, width, height, { fillRule: vm.fillRule });
-        if (vm.inverted) mask = invertSelection(mask);
+        this.requireVectorMask(layer.id);
+        mask = this.vectorMaskSelection(layer);
       }
       if (!mask.bounds) throw new LayerOperationError(`The ${target} of "${layer.name || layer.id}" hides everything: there is no edge to inspect.`);
     } else {
@@ -10622,9 +10694,8 @@ var ImageEditorController = class {
       case "vector-mask": {
         const layer = this.getLayer(source.layerId);
         if (!layer) throw new LayerOperationError(`There is no layer "${source.layerId}" (see list_layers).`);
-        const { vm } = this.requireVectorMask(layer.id);
-        const mask = pathToSelection(vm.components, width, height, { fillRule: vm.fillRule });
-        return vm.inverted ? invertSelection(mask) : mask;
+        this.requireVectorMask(layer.id);
+        return this.vectorMaskSelection(layer);
       }
       default:
         throw new LayerOperationError(`Unknown selection source ${JSON.stringify(source)}. Use selection, history, channel, layer-mask or vector-mask.`);
@@ -11905,6 +11976,12 @@ var ImageEditorController = class {
       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 && isActiveVectorMask(layer.vectorMask) && layer.vectorMask.edges?.length) {
+        add2("Hybrid vector masks (soft edge segments) were baked into pixel masks", layer.name);
+        const baked = effectiveLayerMask(layer, width, height, this.guideSurfaceOf);
+        if (baked) p.mask = baked;
+        delete p.vectorMask;
+      }
       if (p?.blend === "pigment") add2("The Pigment blend mode has no PSD equivalent and was written as Normal", layer.name);
       return p;
     };
@@ -11980,7 +12057,7 @@ 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;
+      const unmixMask = hasEdgeUnmix(layer.edge) ? effectiveLayerMask(layer, width, height, this.guideSurfaceOf) : 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;
@@ -18645,6 +18722,37 @@ function createImageShapeTools(controller) {
       return { vectorMask: controller.getVectorMask(id) };
     }
   };
+  const setVectorMaskEdge = {
+    name: "set_vector_mask_edge",
+    title: "Set a vector mask segment's edge",
+    description: "Hybrid mask: gives one segment of a layer's vector mask its own edge, so one mask holds sharp edges and hair or fur. hard (default) is the path's sharp edge; feather blurs across it by radius px; matte solves a corridor from inner px inside the path to outer px outside it from the layer's colours (the colour-guided filter), so strands keep their detail. Modes blend where they meet. Address the segment with component, subpath and segment (the segment from anchor segment to the next; see get_vector_mask segmentCount and components). Check the result with inspect_mask_edge target vector-mask. One undo step. Returns the vector mask with its edges.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        layerId: LAYER,
+        component: { type: "integer", minimum: 0, description: "Component index of the path (0 for a single shape)." },
+        subpath: { type: "integer", minimum: 0, description: "Subpath index in the component (0 for a single outline)." },
+        segment: { type: "integer", minimum: 0, description: "Segment index in the subpath: from anchor segment to the next (the last closes back to anchor 0)." },
+        mode: { type: "string", enum: ["hard", "feather", "matte"], description: "hard (sharp, the default), feather (a soft falloff) or matte (a solved corridor for hair and fur)." },
+        radius: { type: "number", minimum: 0.5, maximum: 250, description: "feather only: Gaussian falloff in px across the curve (default 4)." },
+        inner: { type: "number", minimum: 0.5, maximum: 200, description: "matte only: how far inside the path the unsure corridor reaches, in px (default 4)." },
+        outer: { type: "number", minimum: 0.5, maximum: 200, description: "matte only: how far outside the path the unsure corridor reaches, in px (default 8; cover the longest strands)." }
+      },
+      required: ["layerId", "component", "subpath", "segment", "mode"],
+      additionalProperties: false
+    },
+    annotations: { title: "Set a vector mask segment's edge", ...WRITE_IDEMPOTENT5 },
+    handler: ({ layerId, component, subpath, segment, mode, radius, inner, outer }) => {
+      const id = layerArg(layerId);
+      const vectorMask = controller.setVectorMaskEdge(
+        id,
+        { component, subpath, segment },
+        mode,
+        { radius, inner, outer }
+      );
+      return { vectorMask };
+    }
+  };
   const rasterizeVectorMask = {
     name: "rasterize_vector_mask",
     title: "Rasterize a vector mask",
@@ -18787,6 +18895,7 @@ function createImageShapeTools(controller) {
     addVectorMask,
     setVectorMaskPath,
     setVectorMaskProps,
+    setVectorMaskEdge,
     rasterizeVectorMask,
     removeVectorMask,
     selectionToPath,
@@ -21649,6 +21758,7 @@ var PathEditGesture = class {
       return;
     }
     const seg = this.segmentAt(cs, p);
+    if (seg && mods.alt && mods.shift && this.target?.kind === "vector-mask") return this.cycleEdge(this.target.layerId, seg.ref);
     if (seg) {
       if (!mods.shift) this.selected.clear();
       this.drag = { kind: "segment", ...seg, base: cloneComponents(cs), moved: false };
@@ -21657,6 +21767,17 @@ var PathEditGesture = class {
     this.drag = { kind: "marquee", start: pt(p), end: pt(p), keep: mods.shift ? new Set(this.selected) : /* @__PURE__ */ new Set() };
     if (!mods.shift) this.selected.clear();
   }
+  /** Alt+Shift-click on a vector mask's segment: hard → feather → matte → hard (one undo step). */
+  cycleEdge(layerId, r) {
+    const at = { component: r.component, subpath: r.subpath, segment: r.anchor };
+    const now = this.controller.getVectorMask(layerId)?.edges.find((e) => e.component === at.component && e.subpath === at.subpath && e.segment === at.segment)?.mode ?? "hard";
+    const next = now === "hard" ? "feather" : now === "feather" ? "matte" : "hard";
+    try {
+      this.controller.setVectorMaskEdge(layerId, at, next);
+    } catch (e) {
+      this.error = e instanceof Error ? e.message : String(e);
+    }
+  }
   /** Alt-click: a corner anchor becomes smooth, a smooth one a corner (one undo step). */
   convert(cs, r) {
     const next = cloneComponents(cs);
@@ -21852,12 +21973,18 @@ var PathEditGesture = class {
     const cs = this.components();
     if (!cs) return null;
     const curves = [];
+    const curveModes = [];
+    const edges = this.target?.kind === "vector-mask" ? this.controller.getVectorMask(this.target.layerId)?.edges ?? [] : [];
+    const modeOf = (ci, si, k) => edges.find((e) => e.component === ci && e.subpath === si && e.segment === k)?.mode ?? "hard";
     const anchors = [];
     const handles = [];
     const selectedComponents = new Set(this.selection.map((r) => r.component));
     cs.forEach(
       (c, ci) => c.subpaths.forEach((sp, si) => {
-        for (let i = 0; i < subpathSegmentCount(sp); i++) curves.push(subpathSegment(sp, i).map(([x, y]) => ({ x, y })));
+        for (let i = 0; i < subpathSegmentCount(sp); i++) {
+          curves.push(subpathSegment(sp, i).map(([x, y]) => ({ x, y })));
+          curveModes.push(modeOf(ci, si, i));
+        }
         sp.anchors.forEach((a, ai) => {
           const selected = this.selected.has(key({ component: ci, subpath: si, anchor: ai }));
           if (tool === "path-select" && !selectedComponents.has(ci)) return;
@@ -21875,7 +22002,7 @@ var PathEditGesture = class {
       if (last) preview = last.out ? [pt(last), pt(last.out), this.pointer, this.pointer] : [pt(last), this.pointer];
     }
     const marquee = this.drag?.kind === "marquee" ? rect(this.drag.start, this.drag.end) : null;
-    return { curves, anchors, handles, marquee, preview };
+    return { curves, ...edges.length ? { curveModes } : {}, anchors, handles, marquee, preview };
   }
 };
 function rect(a, b) {
@@ -22453,6 +22580,7 @@ export {
   TypeToolGesture,
   UNITS,
   U_MAX,
+  VECTOR_MASK_EDGE_DEFAULTS,
   VIBRANCE_GREY,
   W9,
   WARP_GRID_OPTIONS,
@@ -22801,6 +22929,7 @@ export {
   hueRangeTables,
   hueRangeWeight,
   hueSaturation,
+  hybridVectorMaskCoverage,
   identityCurve,
   identityLevels,
   identityTransform,
@@ -22871,6 +23000,7 @@ export {
   layerEffectsBadge,
   layerEffectsOf,
   layerEffectsPanel,
+  layerGuide,
   layerHasThumbnail,
   layerLabel,
   layerMaskCoverage,
@@ -23276,11 +23406,13 @@ export {
   upscaleRegion,
   userErrorMessage,
   uvToXy,
+  validVectorMaskEdges,
   validateEffectGradient,
   validateLayerEffect,
   validateLayerEffects,
   vectorMaskBounds,
   vectorMaskCoverage,
+  vectorMaskSegments,
   vectorMaskThumbnail,
   vectorMaskThumbnailClick,
   versionedDescriptorBytes,

package/dist/image-editor/layers/hybrid-mask.d.cts

@@ -0,0 +1,31 @@
+/**
+ * Hybrid vector masks: a vector mask whose segments each have an edge mode. Hard segments are
+ * the path's own anti-aliased edge; feather segments blur across the curve; matte segments solve
+ * a corridor between two rails (inside by `inner`, outside by `outer`) from the layer's pixels
+ * with the colour-guided filter, so hair and fur keep their detail while the rest stays sharp.
+ * Where modes meet, they blend over a few pixels so there is no seam. Rendered on demand from
+ * the path and the pixels, and cached with the layer like any vector mask.
+ */
+import type { ShapeComponent, VectorMask, VectorMaskEdge } from './model.cjs';
+export type VectorMaskEdgeMode = 'hard' | 'feather' | 'matte';
+/** Defaults for a segment switched to a soft mode. */
+export declare const VECTOR_MASK_EDGE_DEFAULTS: {
+    readonly radius: 4;
+    readonly inner: 4;
+    readonly outer: 8;
+};
+/** The segments of a vector mask's path as `{ component, subpath, segment }` triples. */
+export declare function vectorMaskSegments(components: readonly ShapeComponent[]): Array<{
+    component: number;
+    subpath: number;
+    segment: number;
+}>;
+/** Edges whose segment still exists in `components` (after the path was edited). */
+export declare function validVectorMaskEdges(edges: readonly VectorMaskEdge[] | undefined, components: readonly ShapeComponent[]): VectorMaskEdge[];
+/**
+ * The hybrid coverage (0..1, `width × height`) from the path's hard coverage `hard` (as
+ * `componentsCoverage` gives it, before the mask's own feather and density) and the soft
+ * `edges`. `guide` is the layer's RGBA over the canvas, for matte corridors; without one a matte
+ * segment is feathered instead. Returns `hard` itself when no edge is soft.
+ */
+export declare function hybridVectorMaskCoverage(vm: Pick<VectorMask, 'components' | 'edges'>, hard: Float32Array, width: number, height: number, guide: ArrayLike<number> | null): Float32Array;

package/dist/image-editor/layers/hybrid-mask.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Hybrid vector masks: a vector mask whose segments each have an edge mode. Hard segments are
+ * the path's own anti-aliased edge; feather segments blur across the curve; matte segments solve
+ * a corridor between two rails (inside by `inner`, outside by `outer`) from the layer's pixels
+ * with the colour-guided filter, so hair and fur keep their detail while the rest stays sharp.
+ * Where modes meet, they blend over a few pixels so there is no seam. Rendered on demand from
+ * the path and the pixels, and cached with the layer like any vector mask.
+ */
+import type { ShapeComponent, VectorMask, VectorMaskEdge } from './model.js';
+export type VectorMaskEdgeMode = 'hard' | 'feather' | 'matte';
+/** Defaults for a segment switched to a soft mode. */
+export declare const VECTOR_MASK_EDGE_DEFAULTS: {
+    readonly radius: 4;
+    readonly inner: 4;
+    readonly outer: 8;
+};
+/** The segments of a vector mask's path as `{ component, subpath, segment }` triples. */
+export declare function vectorMaskSegments(components: readonly ShapeComponent[]): Array<{
+    component: number;
+    subpath: number;
+    segment: number;
+}>;
+/** Edges whose segment still exists in `components` (after the path was edited). */
+export declare function validVectorMaskEdges(edges: readonly VectorMaskEdge[] | undefined, components: readonly ShapeComponent[]): VectorMaskEdge[];
+/**
+ * The hybrid coverage (0..1, `width × height`) from the path's hard coverage `hard` (as
+ * `componentsCoverage` gives it, before the mask's own feather and density) and the soft
+ * `edges`. `guide` is the layer's RGBA over the canvas, for matte corridors; without one a matte
+ * segment is feathered instead. Returns `hard` itself when no edge is soft.
+ */
+export declare function hybridVectorMaskCoverage(vm: Pick<VectorMask, 'components' | 'edges'>, hard: Float32Array, width: number, height: number, guide: ArrayLike<number> | null): Float32Array;

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

@@ -51,6 +51,23 @@ export interface VectorMask {
     density?: number;
     /** Gaussian feather σ in px (default 0). */
     feather?: number;
+    /**
+     * Hybrid mask: soft edge modes per path segment (see `hybridVectorMaskCoverage`); segments not
+     * listed are hard. Indices follow the path's components, subpaths and segments.
+     */
+    edges?: VectorMaskEdge[];
+}
+/** One segment's edge mode in a hybrid vector mask. */
+export interface VectorMaskEdge {
+    component: number;
+    subpath: number;
+    /** Segment index in the subpath (from anchor `segment` to the next). */
+    segment: number;
+    /** `feather`: a Gaussian falloff of `radius` px across the curve; `matte`: a corridor from `inner` px inside to `outer` px outside, solved from the layer's colours. */
+    mode: 'hard' | 'feather' | 'matte';
+    radius?: number;
+    inner?: number;
+    outer?: number;
 }
 /** The base sliders of the old document-level adjustments, as a filter on one layer. */
 export interface DevelopSettings {

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

@@ -51,6 +51,23 @@ export interface VectorMask {
     density?: number;
     /** Gaussian feather σ in px (default 0). */
     feather?: number;
+    /**
+     * Hybrid mask: soft edge modes per path segment (see `hybridVectorMaskCoverage`); segments not
+     * listed are hard. Indices follow the path's components, subpaths and segments.
+     */
+    edges?: VectorMaskEdge[];
+}
+/** One segment's edge mode in a hybrid vector mask. */
+export interface VectorMaskEdge {
+    component: number;
+    subpath: number;
+    /** Segment index in the subpath (from anchor `segment` to the next). */
+    segment: number;
+    /** `feather`: a Gaussian falloff of `radius` px across the curve; `matte`: a corridor from `inner` px inside to `outer` px outside, solved from the layer's colours. */
+    mode: 'hard' | 'feather' | 'matte';
+    radius?: number;
+    inner?: number;
+    outer?: number;
 }
 /** The base sliders of the old document-level adjustments, as a filter on one layer. */
 export interface DevelopSettings {

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

@@ -57,6 +57,8 @@ export interface SerializedVectorMask {
     linked?: false;
     density?: number;
     feather?: number;
+    /** Hybrid mask: soft edge modes per segment. */
+    edges?: unknown[];
 }
 /** A layer's effects: the effect list as JSON plus the PSD block they came from (base64). */
 export interface SerializedLayerEffects {

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

@@ -57,6 +57,8 @@ export interface SerializedVectorMask {
     linked?: false;
     density?: number;
     feather?: number;
+    /** Hybrid mask: soft edge modes per segment. */
+    edges?: unknown[];
 }
 /** A layer's effects: the effect list as JSON plus the PSD block they came from (base64). */
 export interface SerializedLayerEffects {

package/dist/image-editor/layers/vector-mask.d.cts

@@ -6,26 +6,31 @@
  */
 import type { CropBox } from '../types.cjs';
 import type { AffineMatrix } from '../../geom/types.cjs';
+import { readRegion } from '../../raster/surface.cjs';
 import type { ImageLayer, RasterMask, VectorMask } from './model.cjs';
 /** Whether a vector mask takes part in compositing. */
 export declare function isActiveVectorMask(vm: VectorMask | undefined): vm is VectorMask;
 /**
- * The vector mask's coverage (0..1) over the `width × height` canvas, with its feather and
- * density applied.
+ * The vector mask's coverage (0..1) over the `width × height` canvas, with its hybrid edges,
+ * feather and density applied.
  */
-export declare function vectorMaskCoverage(vm: VectorMask, width: number, height: number): Float32Array;
+export declare function vectorMaskCoverage(vm: VectorMask, width: number, height: number, guide?: ArrayLike<number> | null): Float32Array;
+/** Where a layer's pixels really are (the Background's come from the source image). */
+export type LayerSurfaceOf = (layer: ImageLayer) => Parameters<typeof readRegion>[0] | undefined;
+/** A layer's own RGBA over the canvas (the guide for hybrid matte edges), or null without pixels. */
+export declare function layerGuide(layer: ImageLayer, width: number, height: number, surfaceOf?: LayerSurfaceOf): Uint8ClampedArray | null;
 /**
  * The raster mask a layer composites with: its raster mask times its vector mask (layer space,
  * feather and density baked in), or the raster mask alone when there is no active vector mask.
  * A depth (parametric) mask cannot be combined, so it wins.
  */
-export declare function effectiveLayerMask(layer: ImageLayer, width: number, height: number): RasterMask | undefined;
+export declare function effectiveLayerMask(layer: ImageLayer, width: number, height: number, surfaceOf?: LayerSurfaceOf): RasterMask | undefined;
 /**
  * The stack as the compositor should see it: each layer with an active vector mask replaced by a
  * copy whose `mask` is `effectiveLayerMask` (cached per layer object and canvas size, so the
  * engine's tile caches keep working). Returns `layers` itself when there are none.
  */
-export declare function resolveVectorMasks(layers: readonly ImageLayer[], width: number, height: number): readonly ImageLayer[];
+export declare function resolveVectorMasks(layers: readonly ImageLayer[], width: number, height: number, surfaceOf?: LayerSurfaceOf): readonly ImageLayer[];
 /** A vector mask moved by (dx, dy) document pixels. */
 export declare function offsetVectorMask(vm: VectorMask, dx: number, dy: number): VectorMask;
 /** A vector mask with its paths mapped by `f` (document space); `affine` keeps live shapes live. */

package/dist/image-editor/layers/vector-mask.d.ts

@@ -6,26 +6,31 @@
  */
 import type { CropBox } from '../types.js';
 import type { AffineMatrix } from '../../geom/types.js';
+import { readRegion } from '../../raster/surface.js';
 import type { ImageLayer, RasterMask, VectorMask } from './model.js';
 /** Whether a vector mask takes part in compositing. */
 export declare function isActiveVectorMask(vm: VectorMask | undefined): vm is VectorMask;
 /**
- * The vector mask's coverage (0..1) over the `width × height` canvas, with its feather and
- * density applied.
+ * The vector mask's coverage (0..1) over the `width × height` canvas, with its hybrid edges,
+ * feather and density applied.
  */
-export declare function vectorMaskCoverage(vm: VectorMask, width: number, height: number): Float32Array;
+export declare function vectorMaskCoverage(vm: VectorMask, width: number, height: number, guide?: ArrayLike<number> | null): Float32Array;
+/** Where a layer's pixels really are (the Background's come from the source image). */
+export type LayerSurfaceOf = (layer: ImageLayer) => Parameters<typeof readRegion>[0] | undefined;
+/** A layer's own RGBA over the canvas (the guide for hybrid matte edges), or null without pixels. */
+export declare function layerGuide(layer: ImageLayer, width: number, height: number, surfaceOf?: LayerSurfaceOf): Uint8ClampedArray | null;
 /**
  * The raster mask a layer composites with: its raster mask times its vector mask (layer space,
  * feather and density baked in), or the raster mask alone when there is no active vector mask.
  * A depth (parametric) mask cannot be combined, so it wins.
  */
-export declare function effectiveLayerMask(layer: ImageLayer, width: number, height: number): RasterMask | undefined;
+export declare function effectiveLayerMask(layer: ImageLayer, width: number, height: number, surfaceOf?: LayerSurfaceOf): RasterMask | undefined;
 /**
  * The stack as the compositor should see it: each layer with an active vector mask replaced by a
  * copy whose `mask` is `effectiveLayerMask` (cached per layer object and canvas size, so the
  * engine's tile caches keep working). Returns `layers` itself when there are none.
  */
-export declare function resolveVectorMasks(layers: readonly ImageLayer[], width: number, height: number): readonly ImageLayer[];
+export declare function resolveVectorMasks(layers: readonly ImageLayer[], width: number, height: number, surfaceOf?: LayerSurfaceOf): readonly ImageLayer[];
 /** A vector mask moved by (dx, dy) document pixels. */
 export declare function offsetVectorMask(vm: VectorMask, dx: number, dy: number): VectorMask;
 /** A vector mask with its paths mapped by `f` (document space); `affine` keeps live shapes live. */

package/dist/image-editor/path-edit.d.cts

@@ -22,6 +22,8 @@ export interface PathAnchorRef {
 export interface PathEditOverlay {
     /** The target's segments: 2 points for a line, 4 for a cubic. */
     curves: ImagePoint[][];
+    /** A hybrid vector mask's edge mode per curve (same order); missing: all hard. */
+    curveModes?: Array<'hard' | 'feather' | 'matte'>;
     /** Anchors shown; selected ones are drawn filled. */
     anchors: Array<{
         point: ImagePoint;
@@ -77,6 +79,8 @@ export declare class PathEditGesture {
     private selectComponent;
     private commit;
     down(p: ImagePoint, tool: PathEditTool, mods?: PathEditModifiers): void;
+    /** Alt+Shift-click on a vector mask's segment: hard → feather → matte → hard (one undo step). */
+    private cycleEdge;
     /** Alt-click: a corner anchor becomes smooth, a smooth one a corner (one undo step). */
     private convert;
     private penDown;

package/dist/image-editor/path-edit.d.ts

@@ -22,6 +22,8 @@ export interface PathAnchorRef {
 export interface PathEditOverlay {
     /** The target's segments: 2 points for a line, 4 for a cubic. */
     curves: ImagePoint[][];
+    /** A hybrid vector mask's edge mode per curve (same order); missing: all hard. */
+    curveModes?: Array<'hard' | 'feather' | 'matte'>;
     /** Anchors shown; selected ones are drawn filled. */
     anchors: Array<{
         point: ImagePoint;
@@ -77,6 +79,8 @@ export declare class PathEditGesture {
     private selectComponent;
     private commit;
     down(p: ImagePoint, tool: PathEditTool, mods?: PathEditModifiers): void;
+    /** Alt+Shift-click on a vector mask's segment: hard → feather → matte → hard (one undo step). */
+    private cycleEdge;
     /** Alt-click: a corner anchor becomes smooth, a smooth one a corner (one undo step). */
     private convert;
     private penDown;