@pixerate/editor 0.189.0 → 0.191.0

package/dist/image-editor/index.js

@@ -1,7 +1,8 @@
 import {
   loadOpenTypeFont,
-  parseOpenTypeFont
-} from "../chunk-M7XIC2FC.js";
+  parseOpenTypeFont,
+  traceField
+} from "../chunk-RQ2EM5TY.js";
 import {
   ADJUSTMENT_KEYS,
   ADJUSTMENT_KINDS,
@@ -99,6 +100,7 @@ import {
   combineSelections,
   compileAdjustmentLayer,
   componentPath,
+  componentsCoverage,
   compositeDeep,
   computeSelectionBounds,
   contentsBox,
@@ -137,6 +139,7 @@ import {
   distanceTransform,
   documentContents,
   duplicateLayer,
+  effectiveLayerMask,
   encodeDeepSurface,
   encodeRle,
   encodeSelectionRle,
@@ -148,6 +151,7 @@ import {
   filterMaskCoverage,
   flattenPath,
   flipCorners,
+  followLayerMove,
   fullSelection,
   geometryHomography,
   getAnnotationBounds,
@@ -177,6 +181,7 @@ import {
   invertMatrix3,
   invertSelection,
   isActiveFilter,
+  isActiveVectorMask,
   isAdjustmentKind,
   isContentsDecoded,
   isDefaultDepthMask,
@@ -237,6 +242,7 @@ import {
   offsetLayer,
   offsetShape,
   offsetSmartObject,
+  offsetVectorMask,
   parseAdjustmentBlock,
   parseBlend,
   parseLfx2,
@@ -290,6 +296,7 @@ import {
   rerenderText,
   resizeSelection,
   resolveExternalAssets,
+  resolveVectorMasks,
   rgbToGray,
   rgbToHsl,
   runLayerFilters,
@@ -341,6 +348,7 @@ import {
   transformMap,
   transformShapeComponents,
   transformTypeLayer,
+  transformVectorMask,
   transformedBox,
   transformedPoint,
   translateLayer,
@@ -359,6 +367,9 @@ import {
   updateTypeLayer,
   userErrorMessage,
   uvToXy,
+  vectorMaskBounds,
+  vectorMaskCoverage,
+  vectorMaskThumbnail,
   versionedDescriptorBytes,
   vibranceLinear,
   vibrancePixel,
@@ -373,7 +384,7 @@ import {
   writePsd,
   xyToTempTint,
   xyToUv
-} from "../chunk-ZEHTUR7Z.js";
+} from "../chunk-TXYXF32N.js";
 import {
   parseCssColor
 } from "../chunk-3CI7FRMK.js";
@@ -620,6 +631,7 @@ import {
   roundSubpaths,
   spliceRuns,
   styleAt,
+  subpathsToBezier,
   textIndexAt,
   translateMatrix,
   warpMeshColumns,
@@ -631,7 +643,9 @@ import {
 } from "../chunk-LPIKXPBM.js";
 import "../chunk-YXKLVD56.js";
 import "../chunk-M6DNZNVY.js";
-import "../chunk-WEIK3UYB.js";
+import {
+  bezierPathToSvg
+} from "../chunk-WEIK3UYB.js";
 import "../chunk-PWBZH3FK.js";
 import {
   EffectUnsupportedError,
@@ -2416,6 +2430,67 @@ function hexRgb(hex) {
   return [v >> 16 & 255, v >> 8 & 255, v & 255];
 }
 
+// src/image-editor/selection/path.ts
+function selectionToSubpaths(mask, options = {}) {
+  const b = mask.bounds;
+  if (!b) return [];
+  const x0 = Math.max(0, b.x - 1);
+  const y0 = Math.max(0, b.y - 1);
+  const x1 = Math.min(mask.width, b.x + b.width + 1);
+  const y1 = Math.min(mask.height, b.y + b.height + 1);
+  const w = x1 - x0;
+  const h = y1 - y0;
+  const data = mask.data;
+  const field = new Float32Array(w * h);
+  for (let y = 0; y < h; y++) {
+    const row = (y0 + y) * mask.width + x0;
+    for (let x = 0; x < w; x++) field[y * w + x] = data[row + x] / 255;
+  }
+  const threshold = Math.min(254, Math.max(1, options.threshold ?? 128)) / 255;
+  const subpaths = traceField(field, w, h, threshold, {
+    tolerance: Math.max(0.1, options.tolerance ?? 0.5),
+    cornerRoundness: options.cornerRoundness ?? 0.5,
+    minArea: options.minArea ?? 4,
+    squareCorners: true
+  });
+  return subpaths.map((sp) => mapSubpaths([sp], (p) => ({ x: p.x + x0, y: p.y + y0 }))[0]);
+}
+function subpathsToSvgPath(subpaths, precision = 2) {
+  return bezierPathToSvg(subpathsToBezier(subpaths), { precision });
+}
+function pathToSelection(components, width, height, options = {}) {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const c of components) {
+    for (const sp of c.subpaths) {
+      for (const a of sp.anchors) {
+        for (const p of [a, a.in, a.out]) {
+          if (!p) continue;
+          x0 = Math.min(x0, p.x);
+          y0 = Math.min(y0, p.y);
+          x1 = Math.max(x1, p.x);
+          y1 = Math.max(y1, p.y);
+        }
+      }
+    }
+  }
+  const rx0 = Math.max(0, Math.floor(x0));
+  const ry0 = Math.max(0, Math.floor(y0));
+  const rx1 = Math.min(width, Math.ceil(x1));
+  const ry1 = Math.min(height, Math.ceil(y1));
+  if (!(rx1 > rx0 && ry1 > ry0)) return createSelectionMask(width, height);
+  const rect = { x: rx0, y: ry0, width: rx1 - rx0, height: ry1 - ry0 };
+  const cov = componentsCoverage(components, rect, options.fillRule ?? "nonzero");
+  const hard = options.antiAlias === false;
+  const bytes = new Uint8Array(cov.length);
+  for (let i = 0; i < cov.length; i++) bytes[i] = hard ? cov[i] >= 0.5 ? 255 : 0 : coverageToByte(cov[i]);
+  const mask = selectionFromRegion(width, height, rect, bytes);
+  const feather = options.feather ?? 0;
+  return feather > 0 && mask.bounds ? modifySelection(mask, "feather", feather) : mask;
+}
+
 // src/image-editor/layers/shape-type-ui.ts
 var DEFAULT_SHAPE_TOOL_OPTIONS = {
   kind: "rect",
@@ -4164,6 +4239,24 @@ var FreeTransformSession = class {
   }
   /** Resamples every part for the current geometry and shows it (or returns it, for commit). */
   resample(final, preview = {}) {
+    const out = this.resampleContent(final, preview);
+    return { ...out, layers: this.moveVectorMask(out.layers) };
+  }
+  /** A linked vector mask follows the layer's content through the same document-space map. */
+  moveVectorMask(layers) {
+    const g = this.geometryValue;
+    if (!this.layerId || this.copyId || !this.moves.includes("pixels") || isIdentityTransform(g)) return layers;
+    const vm = findLayer(layers, this.layerId)?.layer.vectorMask;
+    if (!vm || vm.linked === false) return layers;
+    const warp = hasWarp(g);
+    const f = warp ? transformMap(g) : null;
+    const h = warp ? null : geometryHomography(g);
+    const affine = !warp && h && Math.abs(h[6]) < 1e-12 && Math.abs(h[7]) < 1e-12 && Math.abs(h[8] - 1) < 1e-12 ? [h[0], h[3], h[1], h[4], h[2], h[5]] : void 0;
+    const map = (p) => (f ? f(p) : h ? applyHomography(h, p) : p) ?? p;
+    const moved = transformVectorMask(vm, map, affine);
+    return mapLayer(layers, this.layerId, (l) => ({ ...l, vectorMask: moved }));
+  }
+  resampleContent(final, preview = {}) {
     if (this.smart) return { layers: this.resampleSmart(final, preview), selection: this.startSelection };
     if (this.typeTarget) return { layers: this.resampleType(), selection: this.startSelection };
     const g = this.geometryValue;
@@ -6167,6 +6260,7 @@ var ImageEditorController = class {
       let moved = { ...transformTypeLayer(layer, [1, 0, 0, 1, mx, my]), surface: translateSurface(layer.surface, mx, my) };
       const mask = layer.mask;
       if (mask && mask.linked !== false && !mask.source && (mx || my)) moved = { ...moved, mask: { ...mask, surface: translateSurface(mask.surface, mx, my) } };
+      moved = followLayerMove(moved, mx, my);
       this.commitLayers(mapLayer(this.state.layers, id, () => moved), void 0, commitToHistory);
       const t = moved.transform ?? [1, 0, 0, 1, 0, 0];
       return { offset: { x: Math.round(t[4]), y: Math.round(t[5]) }, bounds: this.getLayerBounds(id) };
@@ -6218,6 +6312,179 @@ var ImageEditorController = class {
       if (this.state.activeLayerId === id) this.state.activeTarget = "pixels";
     });
   }
+  // --- Vector masks ---
+  /** The layer for a vector mask command: not a shape layer (its path is its vector mask), not a depth-masked one. */
+  vectorMaskLayer(id) {
+    const layer = requireLayer(this.state.layers, id).layer;
+    const name = layer.name || id;
+    if (layer.type === "shape") throw new LayerOperationError(`Layer "${name}" is a shape layer, whose path already is its vector mask; change it with set_shape_component, or rasterize the layer first.`);
+    if (layer.mask?.source) throw new LayerOperationError(`Layer "${name}" has a depth mask, which cannot be combined with a vector mask; remove the depth mask first.`);
+    return layer;
+  }
+  requireVectorMask(id) {
+    const layer = this.vectorMaskLayer(id);
+    if (!layer.vectorMask) throw new LayerOperationError(`Layer "${layer.name || id}" has no vector mask; add one with add_vector_mask.`);
+    return { layer, vm: layer.vectorMask };
+  }
+  /** Components from a path spec: `components`, or one `shape` / `subpaths`. */
+  vectorMaskComponents(path) {
+    if (path.components?.length && (path.shape !== void 0 || path.subpaths !== void 0)) throw new LayerOperationError("Give components, or shape / subpaths, not both.");
+    if (path.fillRule !== void 0 && path.fillRule !== "nonzero" && path.fillRule !== "evenodd") throw new LayerOperationError("fillRule must be nonzero or evenodd.");
+    const specs = path.components?.length ? path.components : [path];
+    return specs.map((c, i) => this.componentFrom(c, path.components?.length ? `components[${i}].` : ""));
+  }
+  /**
+   * Layer › Vector Mask: `reveal-all` (an empty path showing everything), `hide-all` (an empty path
+   * hiding everything) or `path` (reveals inside the path given). Replaces an existing vector mask;
+   * the raster mask is kept and both apply. One undo step. Returns the vector mask.
+   */
+  addVectorMask(id, from = "reveal-all", path = {}, trace2 = {}) {
+    this.vectorMaskLayer(id);
+    let vm;
+    if (from === "selection") {
+      const subpaths = this.traceSelection(trace2);
+      vm = { components: [{ op: "combine", subpaths }], fillRule: "evenodd" };
+    } else if (from === "path") {
+      vm = { components: this.vectorMaskComponents(path) };
+      if (path.fillRule === "evenodd") vm.fillRule = "evenodd";
+    } else if (from === "reveal-all" || from === "hide-all") {
+      if (path.components?.length || path.shape !== void 0 || path.subpaths !== void 0) throw new LayerOperationError(`A ${from} vector mask starts empty; use from path to give a path.`);
+      vm = { components: [], ...from === "reveal-all" ? { inverted: true } : {} };
+    } else {
+      throw new LayerOperationError(`Unknown vector mask source "${String(from)}". Use reveal-all, hide-all, path or selection.`);
+    }
+    this.commitLayers(mapLayer(this.state.layers, id, (l) => ({ ...l, vectorMask: vm })));
+    return vm;
+  }
+  /** The selection's outline as subpaths; throws when nothing is selected or nothing is left to trace. */
+  traceSelection(options) {
+    const sel = this.state.selection;
+    if (!sel?.bounds) throw new LayerOperationError("Nothing is selected; select first, then make a path from the selection.");
+    if (options.tolerance !== void 0 && !(options.tolerance >= 0.1 && options.tolerance <= 10)) throw new LayerOperationError("tolerance must be from 0.1 to 10 px.");
+    const subpaths = selectionToSubpaths(sel, options);
+    if (!subpaths.length) throw new LayerOperationError("The selection is too small or too faint to trace (below minArea, or under half selected); lower minArea or threshold.");
+    return subpaths;
+  }
+  /**
+   * Make Work Path: the selection's outline as closed Bézier subpaths in document pixels, holes
+   * included (fill them even-odd), within `tolerance` px. Changes nothing. Throws without a selection.
+   */
+  selectionToPath(options = {}) {
+    const subpaths = this.traceSelection(options);
+    const b = vectorMaskBounds({ components: [{ op: "combine", subpaths }] });
+    const r = (n) => Math.round(n * 100) / 100;
+    return {
+      subpaths: roundSubpaths(subpaths),
+      svg: subpathsToSvgPath(subpaths),
+      fillRule: "evenodd",
+      bounds: b ? { x: r(b.x), y: r(b.y), width: r(b.width), height: r(b.height) } : null,
+      anchors: subpaths.reduce((n, sp) => n + sp.anchors.length, 0)
+    };
+  }
+  /**
+   * Make Selection: fills a path (`shape`, `subpaths` or `components`, document pixels) into a
+   * selection combined with the current one by `mode`, with `feather` px and `antiAlias`. One
+   * undo step. Returns whether anything is selected.
+   */
+  pathToSelection(path, options = {}) {
+    if (options.feather !== void 0 && !(options.feather >= 0 && options.feather <= 1e3)) throw new LayerOperationError("feather must be from 0 to 1000 px.");
+    const components = this.vectorMaskComponents(path);
+    const { width, height } = this.naturalSize;
+    const mask = pathToSelection(components, width, height, { ...options, fillRule: path.fillRule ?? options.fillRule });
+    return this.setSelection(mask, options.mode ?? "replace");
+  }
+  /** Replaces a vector mask's path (its properties are kept). One undo step. Returns the vector mask. */
+  setVectorMaskPath(id, path) {
+    const { vm } = this.requireVectorMask(id);
+    const next = { ...vm, components: this.vectorMaskComponents(path) };
+    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 })));
+    return next;
+  }
+  /** Changes a vector mask's enabled, linked, inverted, density or feather (the path is kept). One undo step. */
+  setVectorMaskProps(id, props) {
+    const { vm } = this.requireVectorMask(id);
+    if (props.density !== void 0 && !(props.density >= 0 && props.density <= 1)) throw new LayerOperationError("density must be from 0 to 1.");
+    if (props.feather !== void 0 && !(props.feather >= 0 && props.feather <= 1e3)) throw new LayerOperationError("feather must be from 0 to 1000 px.");
+    const next = { ...vm };
+    for (const k of ["enabled", "linked", "inverted"]) {
+      if (props[k] === void 0) continue;
+      if (typeof props[k] !== "boolean") throw new LayerOperationError(`${k} must be true or false.`);
+      if (k === "inverted" ? props[k] : !props[k]) next[k] = k === "inverted";
+      else delete next[k];
+    }
+    if (props.density !== void 0) {
+      if (props.density === 1) delete next.density;
+      else next.density = props.density;
+    }
+    if (props.feather !== void 0) {
+      if (props.feather === 0) delete next.feather;
+      else next.feather = props.feather;
+    }
+    this.commitLayers(mapLayer(this.state.layers, id, (l) => ({ ...l, vectorMask: next })));
+    return next;
+  }
+  /** Deletes a layer's vector mask (one undo step). */
+  removeVectorMask(id) {
+    this.requireVectorMask(id);
+    this.commitLayers(
+      mapLayer(this.state.layers, id, (l) => {
+        const next = { ...l };
+        delete next.vectorMask;
+        return next;
+      })
+    );
+  }
+  /**
+   * Layer › Rasterize › Vector Mask: multiplies the path (with its density and feather) into the
+   * layer's raster mask, adding one when there is none, and removes the vector mask. The raster
+   * mask keeps its own properties. One undo step. Returns the raster mask.
+   */
+  rasterizeVectorMask(id) {
+    const { layer } = this.requireVectorMask(id);
+    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 mask = raster ? { ...raster, surface: baked.surface, defaultValue: baked.defaultValue } : baked;
+    this.commitLayers(
+      mapLayer(this.state.layers, id, (l) => {
+        const next = { ...l, mask };
+        delete next.vectorMask;
+        return next;
+      })
+    );
+    return mask;
+  }
+  /** Load Selection from a vector mask's path (density and feather are not applied), inverted with `invert`. */
+  selectionFromVectorMask(id, mode = "replace", invert2 = false) {
+    const { vm } = this.requireVectorMask(id);
+    const { width, height } = this.naturalSize;
+    const cov = componentsCoverage(vm.components, { x: 0, y: 0, width, height }, vm.fillRule ?? "nonzero", vm.inverted === true !== invert2);
+    const bytes = new Uint8Array(cov.length);
+    for (let i = 0; i < cov.length; i++) bytes[i] = Math.round(Math.min(1, Math.max(0, cov[i])) * 255);
+    return this.setSelection(createSelectionMask(width, height, bytes), mode);
+  }
+  /** A layer's vector mask with its paths (rounded), or `null` without one. */
+  getVectorMask(id) {
+    const layer = requireLayer(this.state.layers, id).layer;
+    const vm = layer.vectorMask;
+    if (!vm) return null;
+    const b = vectorMaskBounds(vm);
+    const r = (n) => Math.round(n * 1e3) / 1e3;
+    return {
+      layerId: id,
+      enabled: vm.enabled !== false,
+      linked: vm.linked !== false,
+      inverted: vm.inverted === true,
+      fillRule: vm.fillRule ?? "nonzero",
+      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) }))
+    };
+  }
   /** Changes any layer mask's density, feather, enabled or linked flag (pixels kept). Returns the mask. */
   setLayerMaskProps(id, props, commitToHistory = true) {
     const layer = requireLayer(this.state.layers, id).layer;
@@ -10988,7 +11255,7 @@ var DEPTH_MASK_CONTROLS = [
 // src/image-editor/playback.ts
 var IMAGE_PLAYBACK_KIND = "layer";
 var PAINT = /^(paint_stroke|clone_stamp|heal_brush|spot_heal|dodge|burn|sponge|smudge|blur_stroke|sharpen_stroke|history_brush|set_clone_source|set_clone_transform|fill_pixels|clear_pixels|set_paint|set_retouch_options|load_mixer_brush|clean_mixer_brush)$/;
-var SELECT = /^(select_region|select_subject|select_by_color|select_all|deselect|invert_selection|select_rect|select_ellipse|select_polygon|select_line|magic_wand|grow_selection|select_similar|reselect|select_layer_transparency|select_color_range|load_selection_from_image|load_selection_from_mask|set_selection_display|modify_selection|refine_selection|transform_selection|apply_selection_as_mask|layer_via_copy|stroke_selection|content_aware_fill|copy_pixels|cut_pixels|paste_pixels|save_selection|load_selection_from_channel|set_channel_properties|duplicate_channel|delete_channel|load_channel_from_image|set_quick_mask)$/;
+var SELECT = /^(select_region|select_subject|select_by_color|select_all|deselect|invert_selection|select_rect|select_ellipse|select_polygon|select_line|magic_wand|grow_selection|select_similar|reselect|select_layer_transparency|select_color_range|load_selection_from_image|load_selection_from_mask|set_selection_display|modify_selection|refine_selection|transform_selection|apply_selection_as_mask|layer_via_copy|stroke_selection|content_aware_fill|copy_pixels|cut_pixels|paste_pixels|save_selection|load_selection_from_channel|set_channel_properties|duplicate_channel|delete_channel|load_channel_from_image|set_quick_mask|path_to_selection)$/;
 var ANNOTATE = /^(add_shape_layer|update_shape|add_shape_component|set_shape_component|remove_shape_component|merge_shape_components|add_text_layer|set_text|set_text_style|set_paragraph_style|set_text_frame|convert_text_to_shape)$/;
 var CROP = /^(set_crop|crop_to_selection|reset_crop|set_rotation|flip_image|transform_layer|warp_layer|flip_layer|offset_layer)$/;
 var ADJUST = /^(set_adjustments|add_adjustment_layer|update_adjustment_layer|remove_adjustment_layer|move_adjustment_layer)$/;
@@ -11658,11 +11925,12 @@ function createImageSelectionTools(controller) {
   const loadFromMask = {
     name: "load_selection_from_mask",
     title: "Load a selection from a layer mask",
-    description: "Load Selection from a layer's mask (Ctrl/\u2318-click its mask thumbnail): the mask's pixels become the selection, combined by mode (density and feather are not applied). Use it to reuse a mask on another layer or to edit it as a selection. Fails when the layer has no painted mask. One undoable step. Returns the selection.",
+    description: "Load Selection from a layer's mask (Ctrl/\u2318-click its mask thumbnail): the raster mask's pixels, or with source vector the vector mask's path, become the selection, combined by mode (density and feather are not applied). Use it to reuse a mask on another layer or to edit it as a selection. Fails when the layer has no such mask. One undoable step. Returns the selection.",
     inputSchema: {
       type: "object",
       properties: {
         layerId: { type: "string", minLength: 1, description: "The layer whose mask to load (see list_layers)." },
+        source: { type: "string", enum: ["pixels", "vector"], description: "pixels: the raster (layer) mask (default); vector: the vector mask's path." },
         invert: { type: "boolean", description: "Select what the mask hides instead (default false)." },
         mode: modeSchema
       },
@@ -11674,6 +11942,11 @@ function createImageSelectionTools(controller) {
       const id = String(args.layerId ?? "");
       const layer = controller.getLayer(id);
       if (!layer) throw new Error(`No layer "${id}". Call list_layers for ids.`);
+      if (args.source === "vector") {
+        if (!layer.vectorMask) throw new Error(`Layer "${id}" has no vector mask. Add one with add_vector_mask, or load its pixels mask (source pixels).`);
+        controller.selectionFromVectorMask(id, parseSelectionMode(args.mode), args.invert === true);
+        return summary(controller);
+      }
       if (!layer.mask) throw new Error(`Layer "${id}" has no mask. Add one with add_layer_mask, or pick a layer with a mask.`);
       if (layer.mask.source) throw new Error(`Layer "${id}" has a computed (depth) mask, not a painted one, so it cannot be loaded as a selection.`);
       controller.selectionFromLayerMask(id, parseSelectionMode(args.mode), args.invert === true);
@@ -12540,6 +12813,7 @@ function describeLayer(layer, activeId, boundsOf) {
     clipped: Boolean(layer.clipped),
     locks: layer.locks ? { ...layer.locks } : {},
     mask: maskSummary(layer.mask),
+    vectorMask: layer.vectorMask ? { enabled: layer.vectorMask.enabled !== false, linked: layer.vectorMask.linked !== false, inverted: layer.vectorMask.inverted === true, components: layer.vectorMask.components.length, bounds: vectorMaskBounds(layer.vectorMask) } : null,
     effects: layer.effects ? { enabled: layer.effects.enabled, scale: layer.effects.scale ?? 1, items: layer.effects.items.map((e) => ({ id: e.id, kind: e.kind, enabled: e.enabled })) } : null,
     active: layer.id === activeId
   };
@@ -15726,7 +16000,170 @@ function createImageShapeTools(controller) {
     annotations: { title: "Merge shape components", ...DESTRUCTIVE6 },
     handler: ({ layerId }) => controller.mergeShapeComponents(shapeId(layerId))
   };
-  return [get, add2, update, setComponent, addComponent, removeComponent, merge];
+  const layerArg = (v) => {
+    const id = String(v ?? "");
+    if (!controller.getLayer(id)) throw new Error(`No layer "${id}". Call list_layers for ids.`);
+    return id;
+  };
+  const pathSpec = (args) => {
+    const spec = { ...geometry(args) };
+    if (args.components !== void 0) spec.components = args.components.map(geometry);
+    if (args.fillRule !== void 0) spec.fillRule = args.fillRule;
+    return spec;
+  };
+  const PATH_PROPS = {
+    ...GEOMETRY2,
+    components: {
+      type: "array",
+      minItems: 1,
+      description: "Several components instead of shape / subpaths, bottom first, each with its path operation (combine, subtract, intersect, exclude).",
+      items: { type: "object", description: "One component.", properties: { ...GEOMETRY2, op: OP }, additionalProperties: false }
+    },
+    fillRule: { type: "string", enum: ["nonzero", "evenodd"], description: "Winding rule within a component (default nonzero)." }
+  };
+  const LAYER = { type: "string", minLength: 1, description: "The layer (see list_layers). Not a shape layer: its path already is its vector mask." };
+  const TRACE_PROPS = {
+    tolerance: { type: "number", minimum: 0.1, maximum: 10, description: "How far (px) the path may stray from the selection edge (default 0.5; lower is tighter, more anchors)." },
+    cornerRoundness: { type: "number", minimum: 0, maximum: 1, description: "0: straight sides and sharp corners; 1: as smooth as the outline allows (default 0.5)." },
+    minArea: { type: "number", minimum: 0, description: "Islands and holes smaller than this many square px are left out (default 4)." }
+  };
+  const TRACE_KEYS = ["tolerance", "cornerRoundness", "minArea"];
+  const traceOptions = (args) => {
+    const o = {};
+    for (const k of TRACE_KEYS) if (typeof args[k] === "number") o[k] = args[k];
+    return o;
+  };
+  const selectionToPath = {
+    name: "selection_to_path",
+    title: "Make a path from the selection",
+    description: "Make Work Path: traces the selection's outline (where it is at least half selected) into closed B\xE9zier subpaths in document pixels, holes included, within tolerance px. Changes nothing. Returns svg (compact SVG path data) and fillRule evenodd, ready for add_vector_mask, set_vector_mask_path or add_shape_layer (pass the svg as subpaths and fillRule evenodd), plus bounds and the anchor count. Use add_vector_mask from selection to do it in one step.",
+    inputSchema: { type: "object", properties: { ...TRACE_PROPS, anchors: { type: "boolean", description: "Also return the subpaths as anchors with handles (default false: svg only)." } }, additionalProperties: false },
+    annotations: { title: "Make a path from the selection", ...READ10 },
+    handler: (args) => {
+      const out = controller.selectionToPath(traceOptions(args));
+      const { subpaths, ...rest } = out;
+      return args.anchors === true ? out : rest;
+    }
+  };
+  const pathToSelection2 = {
+    name: "path_to_selection",
+    title: "Make a selection from a path",
+    description: "Make Selection: fills a path (a live shape, free subpaths or SVG path data, or components, in document pixels, as add_shape_layer takes) into a selection, combined with the current one by mode, with feather px and antiAlias. Use it to select along B\xE9zier curves, or to turn a path from selection_to_path or get_vector_mask back into a selection. One undo step. Returns the selection.",
+    inputSchema: {
+      type: "object",
+      $defs: DEFS2,
+      properties: {
+        ...PATH_PROPS,
+        feather: { type: "number", minimum: 0, maximum: 1e3, description: "Feather radius in px (default 0)." },
+        antiAlias: { type: "boolean", description: "Soft edges (default true); false makes every pixel fully in or out." },
+        mode: { type: "string", enum: ["replace", "add", "subtract", "intersect"], description: "How it combines with the current selection (default replace)." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "Make a selection from a path", ...WRITE8 },
+    handler: (args) => {
+      const mode = args.mode;
+      controller.pathToSelection(pathSpec(args), { feather: args.feather, antiAlias: args.antiAlias, mode });
+      const sel = controller.getSelection();
+      return { empty: !sel, bounds: sel?.bounds ?? null, area: Math.round(sel ? selectionArea(sel) : 0) };
+    }
+  };
+  const getVectorMask = {
+    name: "get_vector_mask",
+    title: "Read a vector mask",
+    description: "Reads a layer's vector mask: enabled, linked, inverted, fill rule, density, feather, the bounds of its path and its components (op, live shape, subpaths in document pixels). Use it before set_vector_mask_path to edit the path. Returns null when the layer has none.",
+    inputSchema: { type: "object", properties: { layerId: LAYER }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Read a vector mask", ...READ10 },
+    handler: ({ layerId }) => ({ vectorMask: controller.getVectorMask(layerArg(layerId)) })
+  };
+  const addVectorMask = {
+    name: "add_vector_mask",
+    title: "Add a vector mask",
+    description: "Layer \u203A Vector Mask: a path that reveals the layer inside it and stays sharp at any size, on top of any raster mask (both apply). from path takes a live shape, free subpaths or components like add_shape_layer; from selection traces the current selection (within tolerance px); reveal-all and hide-all start with an empty path. Use it for hard-edged geometric or traced cutouts that must stay editable; use add_layer_mask for soft or painted ones. A linked vector mask moves and transforms with the layer. Replaces an existing vector mask. One undo step. Returns the vector mask.",
+    inputSchema: {
+      type: "object",
+      $defs: DEFS2,
+      properties: {
+        layerId: LAYER,
+        from: { type: "string", enum: ["path", "selection", "reveal-all", "hide-all"], description: "path (default when a shape, subpaths or components are given), selection (trace the current selection), reveal-all or hide-all (an empty path)." },
+        ...PATH_PROPS,
+        ...TRACE_PROPS
+      },
+      required: ["layerId"],
+      additionalProperties: false
+    },
+    annotations: { title: "Add a vector mask", ...WRITE8 },
+    handler: (args) => {
+      const id = layerArg(args.layerId);
+      const spec = pathSpec(args);
+      const hasPath = spec.components?.length || spec.shape !== void 0 || spec.subpaths !== void 0;
+      const from = args.from ?? (hasPath ? "path" : "reveal-all");
+      if (from !== "selection" && TRACE_KEYS.some((k) => args[k] !== void 0)) throw new Error("tolerance, cornerRoundness and minArea apply only to from selection.");
+      controller.addVectorMask(id, from, spec, traceOptions(args));
+      return { vectorMask: controller.getVectorMask(id) };
+    }
+  };
+  const setVectorMaskPath = {
+    name: "set_vector_mask_path",
+    title: "Replace a vector mask path",
+    description: "Replaces the path of a layer's vector mask (shape, subpaths or components, document pixels); enabled, linked, inverted, density and feather are kept. Read the current path with get_vector_mask first to change part of it. One undo step. Returns the vector mask.",
+    inputSchema: { type: "object", $defs: DEFS2, properties: { layerId: LAYER, ...PATH_PROPS }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Replace a vector mask path", ...WRITE_IDEMPOTENT5 },
+    handler: (args) => {
+      const id = layerArg(args.layerId);
+      controller.setVectorMaskPath(id, pathSpec(args));
+      return { vectorMask: controller.getVectorMask(id) };
+    }
+  };
+  const setVectorMaskProps = {
+    name: "set_vector_mask_properties",
+    title: "Set vector mask properties",
+    description: "Changes a layer's vector mask without touching its path: enabled (false ignores it), linked (false: it stays put when the layer moves or transforms), inverted (reveal outside the path), density 0..1 and feather in px (soften the edge without losing the path). One undo step. Returns the vector mask.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        layerId: LAYER,
+        enabled: { type: "boolean", description: "false ignores the vector mask but keeps it." },
+        linked: { type: "boolean", description: "false keeps the path in place when the layer moves or transforms." },
+        inverted: { type: "boolean", description: "true reveals outside the path instead." },
+        density: { type: "number", minimum: 0, maximum: 1, description: "Density 0..1 (default 1): at 0.5 the hidden area still shows half." },
+        feather: { type: "number", minimum: 0, maximum: 1e3, description: "Feather \u03C3 in px (default 0)." }
+      },
+      required: ["layerId"],
+      additionalProperties: false
+    },
+    annotations: { title: "Set vector mask properties", ...WRITE_IDEMPOTENT5 },
+    handler: ({ layerId, ...props }) => {
+      const id = layerArg(layerId);
+      controller.setVectorMaskProps(id, props);
+      return { vectorMask: controller.getVectorMask(id) };
+    }
+  };
+  const rasterizeVectorMask = {
+    name: "rasterize_vector_mask",
+    title: "Rasterize a vector mask",
+    description: "Layer \u203A Rasterize \u203A Vector Mask: multiplies the path (with its density and feather) into the layer's raster mask, adding one if needed, and removes the vector mask, so the mask can be painted. The path can no longer be edited (undo_image brings it back). One undo step. Returns the layer's raster mask summary.",
+    inputSchema: { type: "object", properties: { layerId: LAYER }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Rasterize a vector mask", ...DESTRUCTIVE6 },
+    handler: ({ layerId }) => {
+      const id = layerArg(layerId);
+      const mask = controller.rasterizeVectorMask(id);
+      return { layerId: id, mask: { defaultValue: mask.defaultValue, density: mask.density ?? 1, feather: mask.feather ?? 0, enabled: mask.enabled !== false } };
+    }
+  };
+  const removeVectorMask = {
+    name: "remove_vector_mask",
+    title: "Delete a vector mask",
+    description: "Deletes a layer's vector mask without applying it (the raster mask, if any, stays). Disable it instead with set_vector_mask_properties enabled false to keep it. One undo step. Returns the layer id.",
+    inputSchema: { type: "object", properties: { layerId: LAYER }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Delete a vector mask", ...DESTRUCTIVE6 },
+    handler: ({ layerId }) => {
+      const id = layerArg(layerId);
+      controller.removeVectorMask(id);
+      return { layerId: id, vectorMask: null };
+    }
+  };
+  return [get, add2, update, setComponent, addComponent, removeComponent, merge, getVectorMask, addVectorMask, setVectorMaskPath, setVectorMaskProps, rasterizeVectorMask, removeVectorMask, selectionToPath, pathToSelection2];
 }
 
 // src/image-editor/type-tools.ts
@@ -16393,6 +16830,11 @@ function maskThumbnailClick(controller, layer, e) {
     controller.setActiveLayer(layer.id, "mask");
   }
 }
+function vectorMaskThumbnailClick(controller, layer, e) {
+  if (!layer.vectorMask) return;
+  if (e.ctrlKey || e.metaKey) controller.selectionFromVectorMask(layer.id, selectionModeFromModifiers(e, "replace"));
+  else if (e.shiftKey) controller.setVectorMaskProps(layer.id, { enabled: layer.vectorMask.enabled === false });
+}
 function layerThumbnailClick(controller, layer, e) {
   if (!(e.ctrlKey || e.metaKey)) return false;
   controller.selectLayerTransparency(layer.id, { mode: selectionModeFromModifiers(e, "replace") });
@@ -16491,6 +16933,12 @@ function layerMenu(controller) {
     { action: "delete-mask", label: "Delete Layer Mask", enabled: Boolean(active?.mask) },
     { action: "toggle-mask", label: active?.mask?.enabled === false ? "Enable Layer Mask" : "Disable Layer Mask", enabled: Boolean(active?.mask) },
     { action: "toggle-mask-link", label: active?.mask?.linked === false ? "Link Layer Mask" : "Unlink Layer Mask", enabled: Boolean(active?.mask && !active.mask.source) },
+    { action: "add-vector-mask", label: "Add Vector Mask (Reveal All)", enabled: Boolean(active && active.type !== "shape" && !active.mask?.source) },
+    { action: "add-vector-mask-hide", label: "Add Vector Mask (Hide All)", enabled: Boolean(active && active.type !== "shape" && !active.mask?.source) },
+    { action: "add-vector-mask-selection", label: "Add Vector Mask from Selection", enabled: Boolean(active && active.type !== "shape" && !active.mask?.source) && hasSel },
+    { action: "delete-vector-mask", label: "Delete Vector Mask", enabled: Boolean(active?.vectorMask) },
+    { action: "toggle-vector-mask", label: active?.vectorMask?.enabled === false ? "Enable Vector Mask" : "Disable Vector Mask", enabled: Boolean(active?.vectorMask) },
+    { action: "rasterize-vector-mask", label: "Rasterize Vector Mask", enabled: Boolean(active?.vectorMask) },
     { action: "rasterize", label: "Rasterize Layer", enabled: active?.type === "annotation" || active?.type === "smart" || active?.type === "shape" || active?.type === "type" || isPixel && Boolean(active?.type === "pixel" && active.filters?.length) },
     { action: "convert-smart", label: "Convert to Smart Object", enabled: Boolean(active && active.type !== "annotation") },
     { action: "edit-contents", label: "Edit Contents", enabled: active?.type === "smart" },
@@ -16562,6 +17010,22 @@ async function runLayerMenuAction(controller, action) {
       case "toggle-mask-link":
         if (id && active?.mask) controller.setLayerMaskProps(id, { linked: active.mask.linked === false });
         break;
+      case "add-vector-mask":
+      case "add-vector-mask-hide":
+        if (id) controller.addVectorMask(id, action === "add-vector-mask" ? "reveal-all" : "hide-all");
+        break;
+      case "add-vector-mask-selection":
+        if (id) controller.addVectorMask(id, "selection");
+        break;
+      case "delete-vector-mask":
+        if (id) controller.removeVectorMask(id);
+        break;
+      case "toggle-vector-mask":
+        if (id && active?.vectorMask) controller.setVectorMaskProps(id, { enabled: active.vectorMask.enabled === false });
+        break;
+      case "rasterize-vector-mask":
+        if (id) controller.rasterizeVectorMask(id);
+        break;
       case "rasterize":
         if (id) await controller.rasterizeLayer(id);
         break;
@@ -18154,6 +18618,7 @@ export {
   combineSelections,
   compileAdjustmentLayer,
   componentPath,
+  componentsCoverage,
   compositeDeep,
   compositeSurfaceOver,
   computeHistogram,
@@ -18273,6 +18738,7 @@ export {
   effectLayerTiming,
   effectPixelsToSurface,
   effectReach,
+  effectiveLayerMask,
   effectiveProof,
   effectsFingerprint,
   effectsMargin,
@@ -18309,6 +18775,7 @@ export {
   flattenPath,
   flipCorners,
   flowField,
+  followLayerMove,
   fontOf,
   formatControlValue,
   fullSelection,
@@ -18373,6 +18840,7 @@ export {
   invertMatrix3,
   invertSelection,
   isActiveFilter,
+  isActiveVectorMask,
   isAdjustmentKind,
   isBitDepth,
   isBlendMode,
@@ -18512,6 +18980,7 @@ export {
   offsetLayer,
   offsetShape,
   offsetSmartObject,
+  offsetVectorMask,
   openMaskFile,
   openPsdFile,
   packRgba,
@@ -18538,6 +19007,7 @@ export {
   patchTextStyle,
   pathStrokeCoverage,
   pathStrokeDabs,
+  pathToSelection,
   perDabStrength,
   photoFilterMatrix,
   pigment8,
@@ -18632,6 +19102,7 @@ export {
   resolveMosaicRegionBounds,
   resolvePaintGradient,
   resolveProfile,
+  resolveVectorMasks,
   restyleRange,
   retouchFilter,
   reversePaintGradient,
@@ -18665,6 +19136,7 @@ export {
   selectionRing,
   selectionToCoverage,
   selectionToPixels,
+  selectionToSubpaths,
   selectionValueAt,
   serializeChannels,
   serializeColorMode,
@@ -18722,6 +19194,7 @@ export {
   stepSlotTs,
   strokeGrainCatch,
   styleAt,
+  subpathsToSvgPath,
   sumHistograms,
   surfaceBytes,
   surfaceDepth,
@@ -18761,6 +19234,7 @@ export {
   transformShapeComponents,
   transformSurface,
   transformTypeLayer,
+  transformVectorMask,
   transformedBounds,
   transformedBox,
   transformedPoint,
@@ -18787,6 +19261,10 @@ export {
   validateEffectGradient,
   validateLayerEffect,
   validateLayerEffects,
+  vectorMaskBounds,
+  vectorMaskCoverage,
+  vectorMaskThumbnail,
+  vectorMaskThumbnailClick,
   versionedDescriptorBytes,
   vibranceLinear,
   vibrancePixel,