@pixerate/editor 0.206.0 → 0.207.0

package/dist/image-editor/index.js

@@ -5320,7 +5320,7 @@ function segmentsToSelection(width, height, results) {
 }
 
 // src/image-editor/selection/refine-edits.ts
-var REFINE_EDIT_KINDS = ["quick-select", "brush", "refine-brush"];
+var REFINE_EDIT_KINDS = ["quick-select", "brush", "refine-brush", "lasso", "object"];
 function brushStrokeMask(width, height, points, size, hardness = 1) {
   const r = Math.max(0.5, size / 2);
   const solid = r * Math.min(1, Math.max(0, hardness));
@@ -5361,7 +5361,19 @@ function applyRefineEdits(pixels, selection, edits, width, height) {
   let sel = selection?.bounds ? selection : null;
   let band = null;
   for (const e of edits) {
+    if (e.kind === "object") {
+      if (!pixels) throw new Error("Object Selection needs the image pixels.");
+      if (!e.rect === !e.point) throw new Error("An object edit takes rect (a box around the object) or point (on it), not both.");
+      const region2 = selectObjectIn(pixels, e.rect ? { rect: e.rect } : { point: e.point });
+      sel = combineSelections(sel, region2, e.mode ?? "add");
+      continue;
+    }
     if (!e.points.length) throw new Error(`A ${e.kind} stroke needs at least one point.`);
+    if (e.kind === "lasso") {
+      if (e.points.length < 3) throw new Error("A lasso edit needs at least 3 points.");
+      sel = combineSelections(sel, polygonSelection(width, height, e.points, {}), e.mode ?? "add");
+      continue;
+    }
     if (e.kind === "refine-brush") {
       band = combineSelections(band, brushStrokeMask(width, height, e.points, e.size ?? 40), "add");
       continue;
@@ -13709,13 +13721,25 @@ function createImageSelectionTools(controller) {
           items: {
             type: "object",
             properties: {
-              kind: { type: "string", enum: ["quick-select", "brush", "refine-brush"], description: "quick-select grows to edges; brush paints directly; refine-brush marks soft detail (hair) for the edge to be re-estimated." },
-              points: { type: "array", minItems: 1, items: pointSchema, description: "The stroke path in natural image pixels (one point is a dab)." },
+              kind: {
+                type: "string",
+                enum: ["quick-select", "brush", "refine-brush", "lasso", "object"],
+                description: "quick-select grows to edges; brush paints directly; refine-brush marks soft detail (hair) for the edge to be re-estimated; lasso adds or removes a polygon; object adds or removes the object in rect or under point."
+              },
+              points: { type: "array", minItems: 1, items: pointSchema, description: "The stroke path (or lasso outline, 3+ points) in natural image pixels; one point is a dab. Not for object." },
+              rect: {
+                type: "object",
+                properties: rectProperties,
+                required: ["x", "y", "width", "height"],
+                additionalProperties: false,
+                description: "object: a box around the object, in natural image pixels."
+              },
+              point: { ...pointSchema, description: "object: a point on the object, in natural image pixels." },
               size: { type: "number", minimum: 1, maximum: 2500, description: "Brush diameter in natural image pixels (default 30 quick-select, 20 brush, 40 refine-brush)." },
-              mode: { type: "string", enum: ["add", "subtract"], description: "quick-select and brush: add (default) or subtract." },
+              mode: { type: "string", enum: ["add", "subtract"], description: "quick-select, brush, lasso and object: add (default) or subtract." },
               hardness: { type: "number", minimum: 0, maximum: 1, description: "brush: the solid share of the radius, 0..1 (default 1)." }
             },
-            required: ["kind", "points"],
+            required: ["kind"],
             additionalProperties: false
           }
         },
@@ -13725,8 +13749,13 @@ function createImageSelectionTools(controller) {
     },
     annotations: writeAnnotations("Refine the selection edge"),
     handler: async (params) => {
-      const edits = Array.isArray(params.edits) ? params.edits.map((e) => ({ ...e, points: (e.points ?? []).map((p) => ({ x: num2(p?.x, NaN), y: num2(p?.y, NaN) })) })) : [];
+      const edits = Array.isArray(params.edits) ? params.edits.map((e) => e.kind === "object" ? { ...e } : { ...e, points: (e.points ?? []).map((p) => ({ x: num2(p?.x, NaN), y: num2(p?.y, NaN) })) }) : [];
       for (const e of edits) {
+        if (e.kind === "object") {
+          if (!e.rect === !e.point) throw new Error("An object edit takes rect (a box around the object) or point (on it).");
+          continue;
+        }
+        if (!e.points.length) throw new Error(`A ${e.kind} edit needs points.`);
         if (!e.points.every((p) => Number.isFinite(p.x) && Number.isFinite(p.y))) throw new Error("Each edit needs points of { x, y } in natural image pixels.");
         if (e.kind === "refine-brush" && e.mode !== void 0) throw new Error("refine-brush strokes have no mode; they mark where the edge is re-estimated.");
       }
@@ -19127,6 +19156,374 @@ function downloadMaskImage(controller, source, name = "mask") {
   return { fileName, width, height };
 }
 
+// src/image-editor/selection/select-and-mask.ts
+var SELECT_AND_MASK_VIEWS = [
+  { id: "onion-skin", label: "Onion Skin", key: "o", opacity: 0.5 },
+  { id: "marching-ants", label: "Marching Ants", key: "m", opacity: 1 },
+  { id: "overlay", label: "Overlay", key: "v", opacity: 0.5 },
+  { id: "on-black", label: "On Black", key: "a", opacity: 1 },
+  { id: "on-white", label: "On White", key: "t", opacity: 1 },
+  { id: "black-white", label: "Black & White", key: "k", opacity: 1 },
+  { id: "on-layers", label: "On Layers", key: "y", opacity: 1 }
+];
+var SELECT_AND_MASK_TOOLS = [
+  { id: "quick-select", label: "Quick Selection", key: "w" },
+  { id: "refine-brush", label: "Refine Edge Brush", key: "r" },
+  { id: "brush", label: "Brush", key: "b" },
+  { id: "object", label: "Object Selection", key: "q" },
+  { id: "lasso", label: "Lasso", key: "l" },
+  { id: "hand", label: "Hand", key: "h" },
+  { id: "zoom", label: "Zoom", key: "z" }
+];
+var DEFAULT_SELECT_AND_MASK_SETTINGS = {
+  params: { ...DEFAULT_REFINE_EDGE_PARAMS },
+  output: "selection",
+  decontaminate: 0,
+  refineMode: "color",
+  view: "onion-skin",
+  opacity: 0.5,
+  showEdge: false,
+  showOriginal: false,
+  realTime: true,
+  highQuality: false,
+  remember: false,
+  tool: "quick-select",
+  brushSize: 30,
+  brushMode: "add"
+};
+var PREVIEW_SIZE = 1024;
+var remembered = null;
+function scalePixels(pixels, w, h) {
+  if (w === pixels.width && h === pixels.height) return pixels;
+  const { width: W, height: H, data } = pixels;
+  const sum = new Float64Array(w * h * 4);
+  const count = new Float64Array(w * h);
+  for (let y = 0; y < H; y++) {
+    const row = Math.min(h - 1, Math.floor(y * h / H)) * w;
+    for (let x = 0; x < W; x++) {
+      const o = row + Math.min(w - 1, Math.floor(x * w / W));
+      const p = (y * W + x) * 4;
+      for (let c = 0; c < 4; c++) sum[o * 4 + c] += data[p + c];
+      count[o]++;
+    }
+  }
+  const out = new Uint8ClampedArray(w * h * 4);
+  for (let i = 0; i < w * h; i++) for (let c = 0; c < 4; c++) out[i * 4 + c] = sum[i * 4 + c] / (count[i] || 1);
+  return { width: w, height: h, data: out };
+}
+function scaleEdit(edit, s) {
+  const pt = (p) => ({ x: p.x * s, y: p.y * s });
+  if (edit.kind === "object") {
+    return { ...edit, rect: edit.rect && { x: edit.rect.x * s, y: edit.rect.y * s, width: edit.rect.width * s, height: edit.rect.height * s }, point: edit.point && pt(edit.point) };
+  }
+  const scaled = { ...edit, points: edit.points.map(pt) };
+  if ("size" in edit && edit.size !== void 0) scaled.size = Math.max(1, edit.size * s);
+  return scaled;
+}
+function scaleParams(p, s) {
+  return { ...p, radius: p.radius * s, feather: p.feather * s };
+}
+var SelectAndMaskSession = class {
+  constructor(controller) {
+    this.controller = controller;
+    this.base = controller.getSelection();
+    this.settingsValue = remembered ? { ...remembered, params: { ...remembered.params }, showOriginal: false } : { ...DEFAULT_SELECT_AND_MASK_SETTINGS, params: { ...DEFAULT_SELECT_AND_MASK_SETTINGS.params } };
+  }
+  controller;
+  settingsValue;
+  editsList = [];
+  /** The edit being painted, shown in the preview but not yet in `edits`. */
+  live = null;
+  dragStart = null;
+  pixels = null;
+  previewPixels = null;
+  base;
+  previewMask = null;
+  baseMask = null;
+  listeners = /* @__PURE__ */ new Set();
+  /** Why the preview could not be made (no pixels), for the UI. */
+  error = null;
+  /** A note for the UI, such as object aware refinement applying only on OK. */
+  note = null;
+  /** Bumped each time the preview changes, so a UI can redraw. */
+  revision = 0;
+  get settings() {
+    return this.settingsValue;
+  }
+  get edits() {
+    return this.editsList;
+  }
+  /** Reads the image and makes the first preview. Resolves to false when the pixels are unavailable. */
+  async open() {
+    try {
+      this.pixels = await this.controller.getSamplePixels({});
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : String(err);
+    }
+    if (!this.pixels) {
+      this.error ??= "The image pixels are not available, so Select and Mask cannot preview.";
+      this.emit();
+      return false;
+    }
+    this.rescale();
+    this.recompute();
+    return true;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  emit() {
+    this.revision++;
+    for (const l of this.listeners) l();
+  }
+  /** Preview size and the scale from natural pixels to it. */
+  get previewSize() {
+    const p = this.previewPixels;
+    if (!p || !this.pixels) return { width: 0, height: 0, scale: 1 };
+    return { width: p.width, height: p.height, scale: p.width / this.pixels.width };
+  }
+  /** Changes settings; the preview follows. Choosing a view also sets its usual opacity. */
+  update(changes) {
+    const next = { ...this.settingsValue, ...changes, params: { ...this.settingsValue.params, ...changes.params ?? {} } };
+    if (changes.view && changes.view !== this.settingsValue.view && changes.opacity === void 0) {
+      next.opacity = SELECT_AND_MASK_VIEWS.find((v) => v.id === changes.view).opacity;
+    }
+    const rescale = next.highQuality !== this.settingsValue.highQuality;
+    this.settingsValue = next;
+    if (rescale) this.rescale();
+    this.recompute();
+  }
+  rescale() {
+    const px2 = this.pixels;
+    if (!px2) return;
+    const s = this.settingsValue.highQuality ? 1 : Math.min(1, PREVIEW_SIZE / Math.max(px2.width, px2.height));
+    const w = Math.max(1, Math.round(px2.width * s));
+    const h = Math.max(1, Math.round(px2.height * s));
+    this.previewPixels = scalePixels(px2, w, h);
+    this.baseMask = this.base?.bounds ? s === 1 ? this.base : resizeSelection(this.base, w, h) : null;
+  }
+  /** Recomputes the preview mask from the base selection, the strokes and the settings. */
+  recompute() {
+    const px2 = this.previewPixels;
+    if (!px2) return;
+    const { scale } = this.previewSize;
+    const edits = [...this.editsList, ...this.live ? [this.live] : []].map((e) => scaleEdit(e, scale));
+    this.note = this.settingsValue.refineMode === "object" ? "Object aware refinement asks the segmentation model on OK; the preview refines by colour." : null;
+    try {
+      const { selection, refineBrush } = applyRefineEdits(px2, this.baseMask, edits, px2.width, px2.height);
+      this.previewMask = selection?.bounds ? refineSelection(px2, selection, scaleParams(this.settingsValue.params, scale), refineBrush) : null;
+      this.error = null;
+    } catch (err) {
+      this.previewMask = null;
+      this.error = err instanceof Error ? err.message : String(err);
+    }
+    this.emit();
+  }
+  /** Coverage 0..1 of the preview at (x, y) in preview pixels (for tests and hover readouts). */
+  coverageAt(x, y) {
+    const m = this.settingsValue.showOriginal ? this.baseMask : this.previewMask;
+    if (!m) return 0;
+    const xi = Math.floor(x);
+    const yi = Math.floor(y);
+    if (xi < 0 || yi < 0 || xi >= m.width || yi >= m.height) return 0;
+    return m.data[yi * m.width + xi] / 255;
+  }
+  /** The preview drawn in the current view mode: RGBA at {@link previewSize}. */
+  render() {
+    const px2 = this.previewPixels;
+    if (!px2) return new Uint8ClampedArray(0);
+    const { width: w, height: h } = px2;
+    const n = w * h;
+    const s = this.settingsValue;
+    const mask = (s.showOriginal ? this.baseMask : this.previewMask) ?? createSelectionMask(w, h);
+    const m = mask.data;
+    const out = new Uint8ClampedArray(n * 4);
+    const k = Math.min(1, Math.max(0, s.opacity));
+    let edgeBand = null;
+    if (s.showEdge) {
+      edgeBand = new Uint8Array(n);
+      const r = Math.max(1, Math.round(Math.max(s.params.radius, 2) * this.previewSize.scale));
+      for (let y = 0; y < h; y++) {
+        for (let x = 0; x < w; x++) {
+          const v = m[y * w + x];
+          if (v <= 3 || v >= 252) continue;
+          for (let j = Math.max(0, y - r); j <= Math.min(h - 1, y + r); j++) edgeBand.fill(1, j * w + Math.max(0, x - r), j * w + Math.min(w, x + r + 1));
+        }
+      }
+    }
+    for (let i = 0; i < n; i++) {
+      const a = m[i] / 255;
+      const p = i * 4;
+      const r = px2.data[p];
+      const g = px2.data[p + 1];
+      const b = px2.data[p + 2];
+      let o;
+      const x = i % w;
+      const y = (i - x) / w;
+      const checker = ((x >> 3) + (y >> 3)) % 2 ? 204 : 255;
+      const hide = (1 - a) * k;
+      switch (s.view) {
+        case "black-white":
+          o = [m[i], m[i], m[i]];
+          break;
+        case "overlay":
+          o = [r + (255 - r) * hide, g * (1 - hide), b * (1 - hide)];
+          break;
+        case "on-black":
+          o = [r * (1 - hide), g * (1 - hide), b * (1 - hide)];
+          break;
+        case "on-white":
+          o = [r + (255 - r) * hide, g + (255 - g) * hide, b + (255 - b) * hide];
+          break;
+        case "marching-ants": {
+          o = [r, g, b];
+          const inside = m[i] >= 128;
+          const edge = x > 0 && m[i - 1] >= 128 !== inside || x + 1 < w && m[i + 1] >= 128 !== inside || y > 0 && m[i - w] >= 128 !== inside || y + 1 < h && m[i + w] >= 128 !== inside;
+          if (edge) {
+            const v = (x + y >> 2) % 2 ? 0 : 255;
+            o = [v, v, v];
+          }
+          break;
+        }
+        default:
+          o = [r + (checker - r) * hide, g + (checker - g) * hide, b + (checker - b) * hide];
+      }
+      if (edgeBand && !edgeBand[i]) o = [o[0] * 0.15, o[1] * 0.15, o[2] * 0.15];
+      out[p] = o[0];
+      out[p + 1] = o[1];
+      out[p + 2] = o[2];
+      out[p + 3] = 255;
+    }
+    return out;
+  }
+  /**
+   * Pointer down at `point` (natural pixels) with the current tool: starts a stroke (Quick
+   * Selection, brushes, lasso) or a box (Object Selection). Alt (or the subtract mode) removes.
+   * Hand and Zoom are the UI's own; they return false here.
+   */
+  begin(point, modifiers = {}) {
+    const s = this.settingsValue;
+    const mode = modifiers.altKey ? s.brushMode === "add" ? "subtract" : "add" : s.brushMode;
+    this.dragStart = point;
+    switch (s.tool) {
+      case "quick-select":
+        this.live = { kind: "quick-select", points: [point], size: s.brushSize, mode };
+        break;
+      case "brush":
+        this.live = { kind: "brush", points: [point], size: s.brushSize, mode };
+        break;
+      case "refine-brush":
+        this.live = { kind: "refine-brush", points: [point], size: s.brushSize };
+        break;
+      case "lasso":
+        this.live = { kind: "lasso", points: [point], mode };
+        break;
+      case "object":
+        this.live = { kind: "object", point, mode };
+        break;
+      default:
+        this.dragStart = null;
+        return false;
+    }
+    if (s.realTime && s.tool !== "lasso" && s.tool !== "object") this.recompute();
+    return true;
+  }
+  /** Pointer move while a stroke is down. */
+  move(point) {
+    const live = this.live;
+    if (!live || !this.dragStart) return;
+    if (live.kind === "object") {
+      const a = this.dragStart;
+      const rect = { x: Math.min(a.x, point.x), y: Math.min(a.y, point.y), width: Math.abs(point.x - a.x), height: Math.abs(point.y - a.y) };
+      this.live = rect.width >= 4 && rect.height >= 4 ? { kind: "object", rect, mode: live.mode } : { kind: "object", point: a, mode: live.mode };
+      return;
+    }
+    const last = live.points[live.points.length - 1];
+    if (Math.hypot(point.x - last.x, point.y - last.y) < 1) return;
+    live.points.push(point);
+    if (this.settingsValue.realTime && live.kind !== "lasso") this.recompute();
+  }
+  /** Pointer up: the stroke becomes an edit (one step of the workspace's own undo). */
+  end() {
+    const live = this.live;
+    this.live = null;
+    this.dragStart = null;
+    if (!live) return;
+    if (live.kind === "lasso" && live.points.length < 3) return;
+    this.editsList.push(live);
+    this.recompute();
+  }
+  /** Removes the last stroke (Ctrl/⌘+Z in the workspace). Returns false when there is none. */
+  undoEdit() {
+    if (!this.editsList.length) return false;
+    this.editsList.pop();
+    this.recompute();
+    return true;
+  }
+  /** Clears the strokes and goes back to the default settings (Reset). */
+  reset() {
+    this.editsList.length = 0;
+    this.settingsValue = { ...DEFAULT_SELECT_AND_MASK_SETTINGS, params: { ...DEFAULT_SELECT_AND_MASK_SETTINGS.params }, tool: this.settingsValue.tool };
+    this.rescale();
+    this.recompute();
+  }
+  /**
+   * Photoshop's keys in the workspace: a view letter, F (next view), X (all views off and on:
+   * Show Original), J (Show Edge), P (Show Original), a tool letter, [ and ] (brush size).
+   * Returns true when the key was used.
+   */
+  handleKey(key) {
+    const k = key.toLowerCase();
+    const view = SELECT_AND_MASK_VIEWS.find((v) => v.key === k);
+    if (view) {
+      this.update({ view: view.id });
+      return true;
+    }
+    const tool = SELECT_AND_MASK_TOOLS.find((t) => t.key === k);
+    if (tool) {
+      this.update({ tool: tool.id });
+      return true;
+    }
+    if (k === "f") {
+      const i = SELECT_AND_MASK_VIEWS.findIndex((v) => v.id === this.settingsValue.view);
+      this.update({ view: SELECT_AND_MASK_VIEWS[(i + 1) % SELECT_AND_MASK_VIEWS.length].id });
+      return true;
+    }
+    if (k === "p" || k === "x") {
+      this.update({ showOriginal: !this.settingsValue.showOriginal });
+      return true;
+    }
+    if (k === "j") {
+      this.update({ showEdge: !this.settingsValue.showEdge });
+      return true;
+    }
+    if (k === "[" || k === "]") {
+      const size = this.settingsValue.brushSize;
+      this.settingsValue = { ...this.settingsValue, brushSize: Math.max(1, Math.round(k === "]" ? size * 1.25 : size / 1.25)) };
+      this.emit();
+      return true;
+    }
+    return false;
+  }
+  /**
+   * OK: applies the strokes and settings to the image as one undo step (the same call an agent
+   * makes) and remembers the settings when asked to.
+   */
+  async commit() {
+    const s = this.settingsValue;
+    remembered = s.remember ? { ...s, params: { ...s.params } } : null;
+    return this.controller.refineSelectionTo(s.params, s.output, {
+      edits: [...this.editsList],
+      decontaminate: s.output === "new-layer" || s.output === "new-layer-with-mask" ? s.decontaminate : 0,
+      refineMode: s.refineMode
+    });
+  }
+};
+function forgetSelectAndMaskSettings() {
+  remembered = null;
+}
+
 // src/image-editor/mosaic-filter.ts
 function resolveMosaicRegionBounds(region, imgWidth, imgHeight) {
   if (imgWidth <= 0 || imgHeight <= 0 || region.width <= 0 || region.height <= 0) {
@@ -20826,6 +21223,7 @@ export {
   DEFAULT_REFINE_EDGE_PARAMS,
   DEFAULT_RETOUCH,
   DEFAULT_SELECTION_TOOL_OPTIONS,
+  DEFAULT_SELECT_AND_MASK_SETTINGS,
   DEFAULT_SHAPE_TOOL_OPTIONS,
   DEFAULT_SMUDGE,
   DEFAULT_TEXT_STYLE,
@@ -20943,6 +21341,7 @@ export {
   PIGMENT_WAVELENGTHS,
   PLANE,
   PLANE_BYTES,
+  PREVIEW_SIZE,
   PROOF_PROFILE_OPTIONS,
   PSD_BLEND_KEYS,
   PSD_FILE_ACCEPT,
@@ -20980,6 +21379,8 @@ export {
   SELECTION_MODE_LABELS,
   SELECTION_MODIFY_OPS,
   SELECTION_TOOLS,
+  SELECT_AND_MASK_TOOLS,
+  SELECT_AND_MASK_VIEWS,
   SET_PLANES,
   SHADOW_AMBIENT,
   SHAPE_KIND_LABELS,
@@ -20993,6 +21394,7 @@ export {
   SRGB_TO_LINEAR,
   STRIP,
   SUPPORTED_ADJUSTMENT_KEYS,
+  SelectAndMaskSession,
   SelectionGesture,
   ShapeDrawGesture,
   SmudgeTip,
@@ -21314,6 +21716,7 @@ export {
   focusArea,
   followLayerMove,
   fontOf,
+  forgetSelectAndMaskSettings,
   formatControlValue,
   fullSelection,
   gaussianBlur,

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

@@ -15,3 +15,4 @@ export * from './path.cjs';
 export * from './magnetic.cjs';
 export * from './segment/index.cjs';
 export * from './refine-edits.cjs';
+export * from './select-and-mask.cjs';

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

@@ -15,3 +15,4 @@ export * from './path.js';
 export * from './magnetic.js';
 export * from './segment/index.js';
 export * from './refine-edits.js';
+export * from './select-and-mask.js';

package/dist/image-editor/selection/refine-edits.d.cts

@@ -1,10 +1,10 @@
 /**
  * The Select and Mask workspace's strokes as plain data, so an agent can send what a person
  * paints: Quick Selection strokes (grow to the region's edges), Brush strokes (paint the
- * selection in or out directly) and Refine Edge Brush strokes (mark where the edge should be
- * re-estimated from the image, e.g. over hair).
+ * selection in or out directly), Refine Edge Brush strokes (mark where the edge should be
+ * re-estimated from the image, e.g. over hair), Lasso outlines and Object Selection boxes.
  */
-import type { ImagePoint } from '../types.cjs';
+import type { CropBox, ImagePoint } from '../types.cjs';
 import { type PixelBuffer, type SelectionMask } from './mask.cjs';
 /** One stroke in the workspace, in natural image pixels. */
 export type RefineEdit = {
@@ -22,8 +22,17 @@ export type RefineEdit = {
     kind: 'refine-brush';
     points: ImagePoint[];
     size?: number;
+} | {
+    kind: 'lasso';
+    points: ImagePoint[];
+    mode?: 'add' | 'subtract';
+} | {
+    kind: 'object';
+    rect?: CropBox;
+    point?: ImagePoint;
+    mode?: 'add' | 'subtract';
 };
-export declare const REFINE_EDIT_KINDS: readonly ["quick-select", "brush", "refine-brush"];
+export declare const REFINE_EDIT_KINDS: readonly ["quick-select", "brush", "refine-brush", "lasso", "object"];
 /**
  * Coverage of a round brush of diameter `size` dragged along `points` (one point is a dab), over
  * a `width × height` image. `hardness` 0..1 (default 1): the solid share of the radius; the rest

package/dist/image-editor/selection/refine-edits.d.ts

@@ -1,10 +1,10 @@
 /**
  * The Select and Mask workspace's strokes as plain data, so an agent can send what a person
  * paints: Quick Selection strokes (grow to the region's edges), Brush strokes (paint the
- * selection in or out directly) and Refine Edge Brush strokes (mark where the edge should be
- * re-estimated from the image, e.g. over hair).
+ * selection in or out directly), Refine Edge Brush strokes (mark where the edge should be
+ * re-estimated from the image, e.g. over hair), Lasso outlines and Object Selection boxes.
  */
-import type { ImagePoint } from '../types.js';
+import type { CropBox, ImagePoint } from '../types.js';
 import { type PixelBuffer, type SelectionMask } from './mask.js';
 /** One stroke in the workspace, in natural image pixels. */
 export type RefineEdit = {
@@ -22,8 +22,17 @@ export type RefineEdit = {
     kind: 'refine-brush';
     points: ImagePoint[];
     size?: number;
+} | {
+    kind: 'lasso';
+    points: ImagePoint[];
+    mode?: 'add' | 'subtract';
+} | {
+    kind: 'object';
+    rect?: CropBox;
+    point?: ImagePoint;
+    mode?: 'add' | 'subtract';
 };
-export declare const REFINE_EDIT_KINDS: readonly ["quick-select", "brush", "refine-brush"];
+export declare const REFINE_EDIT_KINDS: readonly ["quick-select", "brush", "refine-brush", "lasso", "object"];
 /**
  * Coverage of a round brush of diameter `size` dragged along `points` (one point is a dab), over
  * a `width × height` image. `hardness` 0..1 (default 1): the solid share of the radius; the rest