@pixerate/editor 0.190.0 → 0.192.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,
@@ -383,7 +384,7 @@ import {
   writePsd,
   xyToTempTint,
   xyToUv
-} from "../chunk-7ZWLDVFH.js";
+} from "../chunk-TXYXF32N.js";
 import {
   parseCssColor
 } from "../chunk-3CI7FRMK.js";
@@ -630,6 +631,7 @@ import {
   roundSubpaths,
   spliceRuns,
   styleAt,
+  subpathsToBezier,
   textIndexAt,
   translateMatrix,
   warpMeshColumns,
@@ -641,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,
@@ -2426,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",
@@ -6273,21 +6338,61 @@ var ImageEditorController = class {
    * 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 = {}) {
+  addVectorMask(id, from = "reveal-all", path = {}, trace2 = {}) {
     this.vectorMaskLayer(id);
     let vm;
-    if (from === "path") {
+    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 or path.`);
+      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);
@@ -9241,6 +9346,62 @@ var ImageEditorController = class {
    * text wrapped in `box`. Refused without a text shaper. Returns its id.
    */
   addTextLayer(init) {
+    const layer = this.layoutTypeLayer(init);
+    if (init.opacity !== void 0 && !(Number.isFinite(init.opacity) && init.opacity >= 0 && init.opacity <= 1)) throw new LayerOperationError("opacity must be between 0 and 1.");
+    if (init.blend !== void 0 && !isBlendMode(init.blend)) throw new LayerOperationError(`Unknown blend mode "${String(init.blend)}".`);
+    if (init.opacity !== void 0) layer.opacity = init.opacity;
+    if (init.blend !== void 0) layer.blend = init.blend;
+    const next = placeLayer(this.state.layers, layer, this.newLayerPlacement(init));
+    this.commitLayers(next, () => {
+      this.state.activeLayerId = layer.id;
+      this.state.activeTarget = "pixels";
+    });
+    return layer.id;
+  }
+  /**
+   * Type Mask (horizontal or vertical): a selection in the shape of `text`, laid out and drawn as
+   * `addTextLayer` would place it (font, size, tracking, box, rotation), combined with the current
+   * selection by `mode`. Vertical type stacks the characters top to bottom, centred on `x`. No
+   * layer is added. One undo step. Returns whether anything is selected.
+   */
+  selectTextShape(init) {
+    const vertical = init.orientation === "vertical";
+    if (init.orientation !== void 0 && init.orientation !== "horizontal" && !vertical) throw new LayerOperationError("orientation must be horizontal or vertical.");
+    if (init.feather !== void 0 && !(init.feather >= 0 && init.feather <= 1e3)) throw new LayerOperationError("feather must be from 0 to 1000 px.");
+    let text = normalizeText(init.text);
+    if (!text.trim()) throw new LayerOperationError("The text is empty, so there is nothing to select; give some characters.");
+    let paragraph = init.paragraph;
+    if (vertical) {
+      if (/\n/.test(text)) throw new LayerOperationError("Vertical type masks take one column; select each column separately (mode add) instead of line breaks.");
+      if (init.box) throw new LayerOperationError("Vertical type masks are point text; leave out box.");
+      text = Array.from(text).join("\n");
+      paragraph = { align: "center", ...paragraph ?? {} };
+    }
+    const layer = this.layoutTypeLayer({ ...init, text, paragraph });
+    const { width, height } = this.naturalSize;
+    const b = contentBounds(layer.surface);
+    const x0 = Math.max(0, b?.x ?? 0);
+    const y0 = Math.max(0, b?.y ?? 0);
+    const x1 = Math.min(width, b ? b.x + b.width : 0);
+    const y1 = Math.min(height, b ? b.y + b.height : 0);
+    let mask;
+    if (!b || x1 <= x0 || y1 <= y0) mask = createSelectionMask(width, height);
+    else {
+      const rect = { x: x0, y: y0, width: x1 - x0, height: y1 - y0 };
+      const rgba = readRegion(layer.surface, rect);
+      const bytes = new Uint8Array(rect.width * rect.height);
+      const hard = init.antiAlias === false;
+      for (let i = 0; i < bytes.length; i++) {
+        const a = rgba[i * 4 + 3];
+        bytes[i] = hard ? a >= 128 ? 255 : 0 : a;
+      }
+      mask = selectionFromRegion(width, height, rect, bytes);
+    }
+    if ((init.feather ?? 0) > 0 && mask.bounds) mask = modifySelection(mask, "feather", init.feather);
+    return this.setSelection(mask.bounds ? mask : null, init.mode ?? "replace");
+  }
+  /** A type layer laid out and drawn from `init` (not added): the shared part of `addTextLayer` and the type masks. */
+  layoutTypeLayer(init) {
     const text = normalizeText(init.text);
     if (!Number.isFinite(init.x) || !Number.isFinite(init.y)) throw new LayerOperationError("x and y must be numbers (document pixels).");
     const style = patchTextStyle({ ...DEFAULT_TEXT_STYLE, color: this.state.paint.foreground }, init.style ?? {});
@@ -9252,19 +9413,9 @@ var ImageEditorController = class {
       frame = { kind: "box", width, height };
     }
     if (init.rotation !== void 0 && !Number.isFinite(init.rotation)) throw new LayerOperationError("rotation must be a number of degrees.");
-    if (init.opacity !== void 0 && !(Number.isFinite(init.opacity) && init.opacity >= 0 && init.opacity <= 1)) throw new LayerOperationError("opacity must be between 0 and 1.");
-    if (init.blend !== void 0 && !isBlendMode(init.blend)) throw new LayerOperationError(`Unknown blend mode "${String(init.blend)}".`);
     const t = [1, 0, 0, 1, init.x, init.y];
     const transform = init.rotation ? multiplyMatrices(t, rotateMatrix(init.rotation, { x: init.x, y: init.y })) : t;
-    const layer = createTypeLayer({ text, runs: [{ length: text.length, style }], paragraphs: [{ length: text.length, style: paragraph }], frame, transform, name: init.name ?? typeLayerName(text) }, this.textEnv());
-    if (init.opacity !== void 0) layer.opacity = init.opacity;
-    if (init.blend !== void 0) layer.blend = init.blend;
-    const next = placeLayer(this.state.layers, layer, this.newLayerPlacement(init));
-    this.commitLayers(next, () => {
-      this.state.activeLayerId = layer.id;
-      this.state.activeTarget = "pixels";
-    });
-    return layer.id;
+    return createTypeLayer({ text, runs: [{ length: text.length, style }], paragraphs: [{ length: text.length, style: paragraph }], frame, transform, name: init.name ?? typeLayerName(text) }, this.textEnv());
   }
   /**
    * Replaces text [start, end) (default all of it) with `text`; inserted text takes the style at
@@ -11150,7 +11301,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|select_text_shape)$/;
 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)$/;
@@ -11271,7 +11422,9 @@ var SELECTION_TOOLS = [
   { id: "column", label: "Single Column" },
   { id: "lasso", label: "Lasso" },
   { id: "polygon", label: "Polygonal Lasso" },
-  { id: "range", label: "Color Range" }
+  { id: "range", label: "Color Range" },
+  { id: "type", label: "Type Mask" },
+  { id: "type-vertical", label: "Vertical Type Mask" }
 ];
 var COLOR_RANGE_PRESET_LABELS = {
   reds: "Reds",
@@ -11302,7 +11455,10 @@ var DEFAULT_SELECTION_TOOL_OPTIONS = {
   feather: 0,
   fuzziness: 40,
   localized: 0,
-  rangeInvert: false
+  rangeInvert: false,
+  typeText: "Type",
+  typeSize: 72,
+  typeFamily: "sans-serif"
 };
 function selectionModeFromModifiers(modifiers, fallback) {
   if (modifiers.shiftKey && modifiers.altKey) return "intersect";
@@ -13684,6 +13840,24 @@ var SelectionGesture = class {
       }
       return;
     }
+    if (options.tool === "type" || options.tool === "type-vertical") {
+      this.start = null;
+      try {
+        this.controller.selectTextShape({
+          text: options.typeText || "Type",
+          x: point.x,
+          y: point.y,
+          orientation: options.tool === "type-vertical" ? "vertical" : "horizontal",
+          style: { fontSize: options.typeSize ?? 72, fontFamily: options.typeFamily || "sans-serif" },
+          mode: selectionModeFromModifiers(modifiers, options.mode),
+          feather: options.feather ?? 0,
+          antiAlias: options.antiAlias
+        });
+      } catch (err) {
+        this.error = err instanceof Error ? err.message : String(err);
+      }
+      return;
+    }
     if (options.tool === "wand" || options.tool === "range") {
       this.start = null;
       const common = {
@@ -15917,6 +16091,52 @@ function createImageShapeTools(controller) {
     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",
@@ -15928,14 +16148,15 @@ function createImageShapeTools(controller) {
   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; 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.",
+    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", "reveal-all", "hide-all"], description: "path (default when a shape, subpaths or components are given), reveal-all or hide-all (an empty path)." },
-        ...PATH_PROPS
+        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
@@ -15946,7 +16167,8 @@ function createImageShapeTools(controller) {
       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");
-      controller.addVectorMask(id, from, spec);
+      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) };
     }
   };
@@ -16010,7 +16232,7 @@ function createImageShapeTools(controller) {
       return { layerId: id, vectorMask: null };
     }
   };
-  return [get, add2, update, setComponent, addComponent, removeComponent, merge, getVectorMask, addVectorMask, setVectorMaskPath, setVectorMaskProps, rasterizeVectorMask, removeVectorMask];
+  return [get, add2, update, setComponent, addComponent, removeComponent, merge, getVectorMask, addVectorMask, setVectorMaskPath, setVectorMaskProps, rasterizeVectorMask, removeVectorMask, selectionToPath, pathToSelection2];
 }
 
 // src/image-editor/type-tools.ts
@@ -16180,7 +16402,43 @@ function createImageTypeTools(controller) {
       return { layer: layerSummary(id), shape: controller.getShapeLayer(id), warnings };
     }
   };
-  return [listFonts, get, add2, setText, setStyle, setParagraph, setFrame, toShape];
+  const typeMask = {
+    name: "select_text_shape",
+    title: "Select the shape of text",
+    description: "Horizontal / Vertical Type Mask: selects the shape of text laid out as add_text_layer would place it (font family, size, weight, tracking, box, rotation; colour is ignored), combined with the current selection by mode. No layer is added. Vertical stacks the characters top to bottom, centred on x (one column; add more with mode add). Use it to cut text out of an image (layer_via_copy), fill letters with a photo (add_layer_mask), or mask an adjustment. Check fonts with list_fonts first. One undo step. Returns the selection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: { type: "string", minLength: 1, description: "The text; \\n starts a new line (horizontal only)." },
+        x: { type: "number", description: "Document x of the origin, pixels (vertical: the column centre)." },
+        y: { type: "number", description: "Document y of the origin (the first baseline), pixels." },
+        orientation: { type: "string", enum: ["horizontal", "vertical"], description: "horizontal (default) or vertical (characters stacked top to bottom)." },
+        box: {
+          type: "object",
+          description: "Horizontal only: wrap in this box, pixels.",
+          properties: { width: { type: "number", minimum: 1, description: "Box width, pixels." }, height: { type: "number", minimum: 1, description: "Box height, pixels." } },
+          required: ["width", "height"],
+          additionalProperties: false
+        },
+        style: { type: "object", description: "Character style (size in px, family, weight, tracking\u2026; colour is ignored).", properties: STYLE, additionalProperties: false },
+        paragraph: { type: "object", description: "Paragraph style (alignment, leading\u2026).", properties: PARAGRAPH, additionalProperties: false },
+        rotation: { type: "number", description: "Degrees clockwise about the origin (default 0)." },
+        mode: { type: "string", enum: ["replace", "add", "subtract", "intersect"], description: "How it combines with the current selection (default replace)." },
+        feather: { type: "number", minimum: 0, maximum: 1e3, description: "Feather radius in px (default 0)." },
+        antiAlias: { type: "boolean", description: "Soft glyph edges (default true)." }
+      },
+      required: ["text", "x", "y"],
+      additionalProperties: false
+    },
+    annotations: { title: "Select the shape of text", ...WRITE9 },
+    handler: (args) => {
+      const init = pick2(args, ["text", "x", "y", "orientation", "box", "style", "paragraph", "rotation", "mode", "feather", "antiAlias"]);
+      controller.selectTextShape(init);
+      const sel = controller.getSelection();
+      return { empty: !sel, bounds: sel?.bounds ?? null, area: Math.round(sel ? selectionArea(sel) : 0) };
+    }
+  };
+  return [listFonts, get, add2, setText, setStyle, setParagraph, setFrame, toShape, typeMask];
 }
 
 // src/image-editor/tools.ts
@@ -16782,6 +17040,7 @@ function layerMenu(controller) {
     { 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) },
@@ -16860,6 +17119,9 @@ async function runLayerMenuAction(controller, action) {
       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;
@@ -18850,6 +19112,7 @@ export {
   patchTextStyle,
   pathStrokeCoverage,
   pathStrokeDabs,
+  pathToSelection,
   perDabStrength,
   photoFilterMatrix,
   pigment8,
@@ -18978,6 +19241,7 @@ export {
   selectionRing,
   selectionToCoverage,
   selectionToPixels,
+  selectionToSubpaths,
   selectionValueAt,
   serializeChannels,
   serializeColorMode,
@@ -19035,6 +19299,7 @@ export {
   stepSlotTs,
   strokeGrainCatch,
   styleAt,
+  subpathsToSvgPath,
   sumHistograms,
   surfaceBytes,
   surfaceDepth,

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

@@ -67,7 +67,7 @@ export type DropZone = 'above' | 'below' | 'inside';
 export declare function dropZone(fraction: number, isGroup: boolean): DropZone;
 /** The placement for `move_layer` when `dragId` is dropped on row `targetId` in `zone`, or `null` for a no-op. */
 export declare function dropPlacement(layers: readonly ImageLayer[], dragId: string, targetId: string, zone: DropZone): LayerPlacement | null;
-export type LayerMenuAction = 'new-layer' | 'new-group' | 'duplicate' | 'delete' | 'group-selected' | 'ungroup' | 'merge-down' | 'merge-visible' | 'flatten' | 'via-copy' | 'via-cut' | 'add-mask' | 'add-vector-mask' | 'add-vector-mask-hide' | 'delete-vector-mask' | 'toggle-vector-mask' | 'rasterize-vector-mask' | 'add-mask-selection' | 'add-mask-hide-selection' | 'add-mask-transparency' | 'select-transparency' | 'apply-mask' | 'delete-mask' | 'toggle-mask' | 'toggle-mask-link' | 'toggle-clip' | 'rasterize' | 'convert-smart' | 'edit-contents' | 'smart-via-copy' | 'add-filter-mask';
+export type LayerMenuAction = 'new-layer' | 'new-group' | 'duplicate' | 'delete' | 'group-selected' | 'ungroup' | 'merge-down' | 'merge-visible' | 'flatten' | 'via-copy' | 'via-cut' | 'add-mask' | 'add-vector-mask' | 'add-vector-mask-hide' | 'add-vector-mask-selection' | 'delete-vector-mask' | 'toggle-vector-mask' | 'rasterize-vector-mask' | 'add-mask-selection' | 'add-mask-hide-selection' | 'add-mask-transparency' | 'select-transparency' | 'apply-mask' | 'delete-mask' | 'toggle-mask' | 'toggle-mask-link' | 'toggle-clip' | 'rasterize' | 'convert-smart' | 'edit-contents' | 'smart-via-copy' | 'add-filter-mask';
 export interface LayerMenuItem {
     action: LayerMenuAction;
     label: string;

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

@@ -67,7 +67,7 @@ export type DropZone = 'above' | 'below' | 'inside';
 export declare function dropZone(fraction: number, isGroup: boolean): DropZone;
 /** The placement for `move_layer` when `dragId` is dropped on row `targetId` in `zone`, or `null` for a no-op. */
 export declare function dropPlacement(layers: readonly ImageLayer[], dragId: string, targetId: string, zone: DropZone): LayerPlacement | null;
-export type LayerMenuAction = 'new-layer' | 'new-group' | 'duplicate' | 'delete' | 'group-selected' | 'ungroup' | 'merge-down' | 'merge-visible' | 'flatten' | 'via-copy' | 'via-cut' | 'add-mask' | 'add-vector-mask' | 'add-vector-mask-hide' | 'delete-vector-mask' | 'toggle-vector-mask' | 'rasterize-vector-mask' | 'add-mask-selection' | 'add-mask-hide-selection' | 'add-mask-transparency' | 'select-transparency' | 'apply-mask' | 'delete-mask' | 'toggle-mask' | 'toggle-mask-link' | 'toggle-clip' | 'rasterize' | 'convert-smart' | 'edit-contents' | 'smart-via-copy' | 'add-filter-mask';
+export type LayerMenuAction = 'new-layer' | 'new-group' | 'duplicate' | 'delete' | 'group-selected' | 'ungroup' | 'merge-down' | 'merge-visible' | 'flatten' | 'via-copy' | 'via-cut' | 'add-mask' | 'add-vector-mask' | 'add-vector-mask-hide' | 'add-vector-mask-selection' | 'delete-vector-mask' | 'toggle-vector-mask' | 'rasterize-vector-mask' | 'add-mask-selection' | 'add-mask-hide-selection' | 'add-mask-transparency' | 'select-transparency' | 'apply-mask' | 'delete-mask' | 'toggle-mask' | 'toggle-mask-link' | 'toggle-clip' | 'rasterize' | 'convert-smart' | 'edit-contents' | 'smart-via-copy' | 'add-filter-mask';
 export interface LayerMenuItem {
     action: LayerMenuAction;
     label: string;

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

@@ -38,8 +38,8 @@ export declare function transformVectorMask(vm: VectorMask, f: (p: {
 }, affine?: AffineMatrix): VectorMask;
 /** A linked vector mask moved with its layer by (dx, dy); unlinked ones stay. */
 export declare function followLayerMove<T extends ImageLayer>(layer: T, dx: number, dy: number): T;
-/** Bounds of a vector mask's paths (document pixels), or `null` when it has none. */
-export declare function vectorMaskBounds(vm: VectorMask): CropBox | null;
+/** Bounds of the area a vector mask's paths enclose (document pixels, the curves themselves, not their handles), or `null` when it has none. */
+export declare function vectorMaskBounds(vm: Pick<VectorMask, 'components'>): CropBox | null;
 /**
  * A vector mask's thumbnail over the `width × height` canvas, at most `maxSide` px: grey RGBA,
  * white where the path reveals (cached per mask object).

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

@@ -38,8 +38,8 @@ export declare function transformVectorMask(vm: VectorMask, f: (p: {
 }, affine?: AffineMatrix): VectorMask;
 /** A linked vector mask moved with its layer by (dx, dy); unlinked ones stay. */
 export declare function followLayerMove<T extends ImageLayer>(layer: T, dx: number, dy: number): T;
-/** Bounds of a vector mask's paths (document pixels), or `null` when it has none. */
-export declare function vectorMaskBounds(vm: VectorMask): CropBox | null;
+/** Bounds of the area a vector mask's paths enclose (document pixels, the curves themselves, not their handles), or `null` when it has none. */
+export declare function vectorMaskBounds(vm: Pick<VectorMask, 'components'>): CropBox | null;
 /**
  * A vector mask's thumbnail over the `width × height` canvas, at most `maxSide` px: grey RGBA,
  * white where the path reveals (cached per mask object).

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

@@ -11,3 +11,4 @@ export * from './segmentation.cjs';
 export * from './stroke.cjs';
 export * from './channels.cjs';
 export * from './mask-files.cjs';
+export * from './path.cjs';

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

@@ -11,3 +11,4 @@ export * from './segmentation.js';
 export * from './stroke.js';
 export * from './channels.js';
 export * from './mask-files.js';
+export * from './path.js';

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

@@ -0,0 +1,37 @@
+/**
+ * Selections ⇄ paths (Photoshop's Make Work Path and Make Selection): a selection's outline traced
+ * into Bézier subpaths, and a path filled into a selection.
+ */
+import type { VectorSubpath } from '../../vector/types.cjs';
+import type { ShapeComponent, ShapeFillRule } from '../layers/model.cjs';
+import { type SelectionMask } from './mask.cjs';
+export interface SelectionToPathOptions {
+    /** How far (px) the path may stray from the outline (default 0.5; Photoshop's Make Work Path tolerance). */
+    tolerance?: number;
+    /** 0: straight sides and sharp corners; 1: as smooth as the outline allows (default 0.5). */
+    cornerRoundness?: number;
+    /** Islands and holes smaller than this many square pixels are left out (default 4). */
+    minArea?: number;
+    /** Coverage (0..255) where the outline runs (default 128, half selected). */
+    threshold?: number;
+}
+/**
+ * The outline of a selection as closed subpaths in document pixels (holes included, so fill them
+ * even-odd). Traced in the selection's bounds only; an empty selection gives none.
+ */
+export declare function selectionToSubpaths(mask: SelectionMask, options?: SelectionToPathOptions): VectorSubpath[];
+/** Subpaths as compact SVG path data (absolute, `precision` decimals). */
+export declare function subpathsToSvgPath(subpaths: readonly VectorSubpath[], precision?: number): string;
+export interface PathToSelectionOptions {
+    /** Feather radius in px applied after filling (default 0). */
+    feather?: number;
+    /** Soft edges (default true); false makes every pixel fully in or out. */
+    antiAlias?: boolean;
+    /** How overlapping subpaths fill (default nonzero). */
+    fillRule?: ShapeFillRule;
+}
+/**
+ * Make Selection: the area of `components` (document pixels, combined by their ops) over a
+ * `width × height` image, computed in the path's bounds only.
+ */
+export declare function pathToSelection(components: readonly ShapeComponent[], width: number, height: number, options?: PathToSelectionOptions): SelectionMask;

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

@@ -0,0 +1,37 @@
+/**
+ * Selections ⇄ paths (Photoshop's Make Work Path and Make Selection): a selection's outline traced
+ * into Bézier subpaths, and a path filled into a selection.
+ */
+import type { VectorSubpath } from '../../vector/types.js';
+import type { ShapeComponent, ShapeFillRule } from '../layers/model.js';
+import { type SelectionMask } from './mask.js';
+export interface SelectionToPathOptions {
+    /** How far (px) the path may stray from the outline (default 0.5; Photoshop's Make Work Path tolerance). */
+    tolerance?: number;
+    /** 0: straight sides and sharp corners; 1: as smooth as the outline allows (default 0.5). */
+    cornerRoundness?: number;
+    /** Islands and holes smaller than this many square pixels are left out (default 4). */
+    minArea?: number;
+    /** Coverage (0..255) where the outline runs (default 128, half selected). */
+    threshold?: number;
+}
+/**
+ * The outline of a selection as closed subpaths in document pixels (holes included, so fill them
+ * even-odd). Traced in the selection's bounds only; an empty selection gives none.
+ */
+export declare function selectionToSubpaths(mask: SelectionMask, options?: SelectionToPathOptions): VectorSubpath[];
+/** Subpaths as compact SVG path data (absolute, `precision` decimals). */
+export declare function subpathsToSvgPath(subpaths: readonly VectorSubpath[], precision?: number): string;
+export interface PathToSelectionOptions {
+    /** Feather radius in px applied after filling (default 0). */
+    feather?: number;
+    /** Soft edges (default true); false makes every pixel fully in or out. */
+    antiAlias?: boolean;
+    /** How overlapping subpaths fill (default nonzero). */
+    fillRule?: ShapeFillRule;
+}
+/**
+ * Make Selection: the area of `components` (document pixels, combined by their ops) over a
+ * `width × height` image, computed in the path's bounds only.
+ */
+export declare function pathToSelection(components: readonly ShapeComponent[], width: number, height: number, options?: PathToSelectionOptions): SelectionMask;

package/dist/image-editor/selection/tool-options.d.cts

@@ -2,7 +2,7 @@ import { type SelectionMask, type SelectionMode } from './mask.cjs';
 import type { ColorDistance, ColorRangePreset } from './wand.cjs';
 import type { RefineEdgeParams } from './refine.cjs';
 /** Selection tools of the image editor UI. */
-export type SelectionToolKind = 'wand' | 'rect' | 'ellipse' | 'row' | 'column' | 'lasso' | 'polygon' | 'range';
+export type SelectionToolKind = 'wand' | 'rect' | 'ellipse' | 'row' | 'column' | 'lasso' | 'polygon' | 'range' | 'type' | 'type-vertical';
 export declare const SELECTION_TOOLS: readonly {
     id: SelectionToolKind;
     label: string;
@@ -31,6 +31,12 @@ export interface SelectionToolOptions {
     localized?: number;
     /** Color Range: select everything except the sampled colours. */
     rangeInvert?: boolean;
+    /** Type Mask: the text to select (default "Type"). A click places its first baseline. */
+    typeText?: string;
+    /** Type Mask: font size in px (default 72). */
+    typeSize?: number;
+    /** Type Mask: font family (default sans-serif). */
+    typeFamily?: string;
 }
 export declare const DEFAULT_SELECTION_TOOL_OPTIONS: SelectionToolOptions;
 /**