@pixerate/editor 0.209.0 → 0.210.0

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

@@ -67,3 +67,4 @@ export * from './provider-effect-tools.cjs';
 export * from './playback.cjs';
 export * from './tool-groups.cjs';
 export * from './editorDocument.cjs';
+export * from './content-aware-fill-session.cjs';

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

@@ -67,3 +67,4 @@ export * from './provider-effect-tools.js';
 export * from './playback.js';
 export * from './tool-groups.js';
 export * from './editorDocument.js';
+export * from './content-aware-fill-session.js';

package/dist/image-editor/index.js

@@ -52,7 +52,7 @@ import {
   workImage,
   workLuma,
   workPlanes
-} from "../chunk-DWYQPL2A.js";
+} from "../chunk-LQ5SALHK.js";
 import {
   ADJUSTMENT_KEYS,
   ADJUSTMENT_KINDS,
@@ -523,33 +523,35 @@ import {
   TransformedPixelSource,
   applyRetouchToTile,
   applyToneToDeepTile,
-  bestOffset,
   boxBlurPixels,
   cloneSamplePoint,
-  contentAwareFill,
-  dilateMask,
   dodgeBurn,
   dodgeBurnCurve,
   healPixels,
   isIdentityCloneTransform,
   luma,
-  maskBounds,
-  membraneFill,
   normalizeRetouch,
   perDabStrength,
   readSourceRegion,
   retouchFilter,
   rgbaViewOfGrey,
   saturationOf,
-  seamlessClone,
   smudgeEffect,
-  solveMembrane,
   sponge,
   spongeEffect,
   spotHealPixels,
   spotHealWindow,
   toneOf
-} from "../chunk-USQCKRZG.js";
+} from "../chunk-ZGJGSCUW.js";
+import {
+  bestOffset,
+  contentAwareFill,
+  dilateMask,
+  maskBounds,
+  membraneFill,
+  seamlessClone,
+  solveMembrane
+} from "../chunk-XI2NV5U7.js";
 import {
   BODY_SCATTER,
   DEFAULT_FLOW,
@@ -7903,9 +7905,46 @@ var ImageEditorController = class {
    * (PatchMatch, as the Spot Healing Brush's content-aware mode), blended by the selection's
    * coverage. `output` `current` paints into the layer; `new-layer` puts the fill on a new layer
    * above it. Samples within `sampleRadius` px of the selection (default its larger side, at
-   * least 32). Deterministic for a `seed`. One undo step. 8-bit documents only for now.
+   * least 32), or from the given sampling area. Deterministic for a `seed`. One undo step.
+   * 8-bit documents only for now. Runs here; see `contentAwareFillAsync` for the worker.
    */
   contentAwareFill(options = {}) {
+    const plan = this.prepareContentAwareFill(options);
+    const filled = contentAwareFill(plan.window.width, plan.window.height, 4, plan.before, plan.hole, { seed: options.seed ?? 0, exclude: plan.exclude });
+    return this.applyContentAwareFill(plan, Uint8ClampedArray.from(filled), options.output ?? "current");
+  }
+  /**
+   * `contentAwareFill` with the synthesis in the selection worker when there is one, with
+   * `signal` and `onProgress`. The layer is checked again before the result lands.
+   */
+  async contentAwareFillAsync(options = {}) {
+    const plan = this.prepareContentAwareFill(options);
+    const filled = await this.synthesiseFill(plan, options.seed ?? 0, options);
+    return this.applyContentAwareFill(plan, filled, options.output ?? "current");
+  }
+  /**
+   * The fill without changing anything: the window, its pixels before and after (RGBA, the fill
+   * blended by the selection's coverage) and the sampling area used, for a preview.
+   */
+  async previewContentAwareFill(options = {}) {
+    const plan = this.prepareContentAwareFill(options);
+    const filled = await this.synthesiseFill(plan, options.seed ?? 0, options);
+    return { plan, after: this.blendFill(plan, filled, "current") };
+  }
+  async synthesiseFill(plan, seed, options) {
+    const { width, height } = plan.window;
+    const { pixels } = await this.runSelectionJob(
+      { op: "fill", hole: plan.hole, exclude: plan.exclude, seed },
+      { width, height, data: plan.before },
+      options
+    );
+    return pixels;
+  }
+  /**
+   * Checks and gathers what a Content-Aware Fill needs: the selection, the 8-bit pixel layer, the
+   * window around the selection (and the sampling area), and which pixels it may copy from.
+   */
+  prepareContentAwareFill(options = {}) {
     const sel = this.state.selection;
     if (!sel?.bounds) throw new LayerOperationError("Nothing is selected; select what to remove, then fill it.");
     if (this.bitDepth !== 8) throw new LayerOperationError("Content-Aware Fill works on 8-bit documents for now; set_bit_depth 8 first, or use spot_heal.");
@@ -7914,33 +7953,70 @@ var ImageEditorController = class {
     const target = this.paintTarget(options.layerId, "pixels", "fill");
     const { width, height } = this.naturalSize;
     const b = sel.bounds;
-    const margin = Math.max(32, Math.round(options.sampleRadius ?? Math.max(b.width, b.height)));
-    const x0 = Math.max(0, b.x - margin);
-    const y0 = Math.max(0, b.y - margin);
-    const win = { x: x0, y: y0, width: Math.min(width, b.x + b.width + margin) - x0, height: Math.min(height, b.y + b.height + margin) - y0 };
-    if (win.width * win.height > 16e6) throw new LayerOperationError("The area to fill and sample is too large (over 16 MP); fill a smaller selection or lower sampleRadius.");
-    const layerRect = { x: win.x - target.offset.x, y: win.y - target.offset.y, width: win.width, height: win.height };
-    const before = readRegion(target.surface, layerRect);
-    const img = new Float32Array(before.length);
-    for (let i = 0; i < before.length; i++) img[i] = before[i];
-    const coverage = new Float32Array(win.width * win.height);
-    const hole = new Uint8Array(win.width * win.height);
+    let area = options.samplingArea ?? null;
+    if (!area && options.samplingChannelId) area = this.requireChannel(options.samplingChannelId).mask;
+    if (!area && options.sampleRects?.length) {
+      for (const r of options.sampleRects) area = combineSelections(area, rectSelection(width, height, r, { antiAlias: false }), "add");
+    }
+    if (area && !area.bounds) throw new LayerOperationError("The sampling area is empty; paint or give an area to sample from.");
+    let win;
+    if (area?.bounds) {
+      const a = area.bounds;
+      const x0 = Math.max(0, Math.min(b.x - 8, a.x));
+      const y0 = Math.max(0, Math.min(b.y - 8, a.y));
+      win = { x: x0, y: y0, width: Math.min(width, Math.max(b.x + b.width + 8, a.x + a.width)) - x0, height: Math.min(height, Math.max(b.y + b.height + 8, a.y + a.height)) - y0 };
+    } else {
+      const margin = Math.max(32, Math.round(options.sampleRadius ?? Math.max(b.width, b.height)));
+      const x0 = Math.max(0, b.x - margin);
+      const y0 = Math.max(0, b.y - margin);
+      win = { x: x0, y: y0, width: Math.min(width, b.x + b.width + margin) - x0, height: Math.min(height, b.y + b.height + margin) - y0 };
+    }
+    if (win.width * win.height > 16e6) throw new LayerOperationError("The area to fill and sample is too large (over 16 MP); fill a smaller selection or sample from a smaller area.");
+    const before = readRegion(target.surface, { x: win.x - target.offset.x, y: win.y - target.offset.y, width: win.width, height: win.height });
+    const n = win.width * win.height;
+    const coverage = new Uint8Array(n);
+    const hole = new Uint8Array(n);
+    const selData = sel.data;
     for (let y = 0; y < win.height; y++) {
       for (let x = 0; x < win.width; x++) {
-        const c = sel.data[(win.y + y) * sel.width + win.x + x] / 255;
+        const c = selData[(win.y + y) * sel.width + win.x + x];
         coverage[y * win.width + x] = c;
         hole[y * win.width + x] = c > 0 ? 1 : 0;
       }
     }
-    const filled = contentAwareFill(win.width, win.height, 4, img, hole, { seed: options.seed ?? 0 });
+    let exclude = null;
+    if (area || options.excludeRects?.length) {
+      exclude = new Uint8Array(n);
+      if (area) {
+        const ad = area.data;
+        for (let y = 0; y < win.height; y++) for (let x = 0; x < win.width; x++) if (ad[(win.y + y) * width + win.x + x] < 128) exclude[y * win.width + x] = 1;
+      }
+      for (const r of options.excludeRects ?? []) {
+        for (let y = Math.max(0, Math.floor(r.y) - win.y); y < Math.min(win.height, Math.ceil(r.y + r.height) - win.y); y++) {
+          for (let x = Math.max(0, Math.floor(r.x) - win.x); x < Math.min(win.width, Math.ceil(r.x + r.width) - win.x); x++) exclude[y * win.width + x] = 1;
+        }
+      }
+    }
+    return { layerId: target.id, window: win, bounds: { ...b }, before, hole, coverage, exclude };
+  }
+  /** The window's pixels with `filled` blended in by the coverage (`current`), or the fill alone, its alpha by the coverage (`new-layer`). */
+  blendFill(plan, filled, output) {
+    const { before, coverage } = plan;
     const out = new Uint8ClampedArray(before.length);
     for (let i = 0; i < coverage.length; i++) {
-      const k = coverage[i];
+      const k = coverage[i] / 255;
       for (let c = 0; c < 4; c++) {
         const p = i * 4 + c;
         out[p] = output === "new-layer" ? c === 3 ? Math.round(filled[p] * k) : filled[p] : before[p] + (filled[p] - before[p]) * k;
       }
     }
+    return out;
+  }
+  /** Puts a computed fill into the document as one undo step. */
+  applyContentAwareFill(plan, filled, output) {
+    const target = this.paintTarget(plan.layerId, "pixels", "fill");
+    const { window: win, bounds: b } = plan;
+    const out = this.blendFill(plan, filled, output);
     if (output === "new-layer") {
       const crop = { x: b.x - win.x, y: b.y - win.y, width: b.width, height: b.height };
       const data = new Uint8ClampedArray(b.width * b.height * 4);
@@ -7948,6 +8024,7 @@ var ImageEditorController = class {
       const id = this.addPixelLayer({ name: "Content-Aware Fill", pixels: { width: b.width, height: b.height, data }, x: b.x, y: b.y, aboveId: target.id });
       return { layerId: id, bounds: { ...b }, output };
     }
+    const layerRect = { x: win.x - target.offset.x, y: win.y - target.offset.y, width: win.width, height: win.height };
     const surface = writeRegion(target.surface, layerRect, out);
     this.commitLayers(mapLayer(this.state.layers, target.id, (l) => this.withSurface(l, "pixels", surface)));
     return { layerId: target.id, bounds: { ...b }, output };
@@ -11924,6 +12001,13 @@ var rectProperties = {
   width: { type: "number", exclusiveMinimum: 0, description: "Width in natural image pixels." },
   height: { type: "number", exclusiveMinimum: 0, description: "Height in natural image pixels." }
 };
+var rectSchemaStrict = {
+  type: "object",
+  properties: rectProperties,
+  required: ["x", "y", "width", "height"],
+  additionalProperties: false,
+  description: "A rectangle in natural image pixels."
+};
 function shapeOptions(args) {
   return { mode: parseSelectionMode(args.mode), feather: num2(args.feather, 0), antiAlias: args.antiAlias !== false };
 }
@@ -12777,25 +12861,33 @@ function createImageSelectionTools(controller) {
   const fillTool = {
     name: "content_aware_fill",
     title: "Content-Aware Fill",
-    description: "Edit \u203A Content-Aware Fill: removes what is selected by filling it with texture and edges synthesised from around it (on a pixel layer, default the active one). Select the object with a small margin (expand 2\u20134 px) first. output current paints into the layer; new-layer puts the fill on its own layer above it, so it can be masked or removed (recommended). sampleRadius limits where it samples from. Deterministic for a seed. 8-bit documents. One undo step. Returns the layer id and filled bounds.",
+    description: "Edit \u203A Content-Aware Fill: removes what is selected by filling it with texture and edges synthesised from around it (on a pixel layer, default the active one). Select the object with a small margin (expand 2\u20134 px) first. output current paints into the layer; new-layer puts the fill on its own layer above it, so it can be masked or removed (recommended). sampleRadius limits where it samples from; sampleRects (only these areas), samplingChannelId (a saved alpha channel) and excludeRects (never these, e.g. another object that would be copied in) set the sampling area as the Content-Aware Fill workspace does. Deterministic for a seed. 8-bit documents. One undo step. Returns the layer id and filled bounds.",
     inputSchema: {
       type: "object",
       properties: {
         output: { type: "string", enum: ["new-layer", "current"], description: "new-layer or current (default current)." },
         sampleRadius: { type: "number", minimum: 32, maximum: 4e3, description: "Sample within this many pixels of the selection (default its larger side)." },
         seed: { type: "integer", minimum: 0, description: "Random seed; another seed gives another fill to choose from (default 0)." },
+        sampleRects: { type: "array", minItems: 1, items: rectSchemaStrict, description: "Sample only from these rectangles (natural image pixels), instead of the ring around the selection." },
+        excludeRects: { type: "array", minItems: 1, items: rectSchemaStrict, description: "Never sample from these rectangles (natural image pixels)." },
+        samplingChannelId: { type: "string", description: "Sample only where this alpha channel is selected (see list_channels)." },
         layerId: layerIdSchema
       },
       additionalProperties: false
     },
     annotations: writeAnnotations("Content-Aware Fill"),
-    handler: (args) => {
+    handler: async (args, context) => {
       if (!controller.getSelection()) throw new Error("Nothing is selected; select what to remove first.");
-      return controller.contentAwareFill({
+      const rects = (v) => Array.isArray(v) ? v.map((r) => ({ x: num2(r?.x, NaN), y: num2(r?.y, NaN), width: num2(r?.width, NaN), height: num2(r?.height, NaN) })) : void 0;
+      return controller.contentAwareFillAsync({
         output: args.output,
         sampleRadius: args.sampleRadius,
         seed: args.seed,
-        layerId: requireLayerId(args.layerId)
+        layerId: requireLayerId(args.layerId),
+        sampleRects: rects(args.sampleRects),
+        excludeRects: rects(args.excludeRects),
+        samplingChannelId: typeof args.samplingChannelId === "string" ? args.samplingChannelId : void 0,
+        signal: context?.signal
       });
     }
   };
@@ -19622,6 +19714,278 @@ function createImageEditorDocument(controller, options = {}) {
     }
   });
 }
+
+// src/image-editor/content-aware-fill-session.ts
+var CONTENT_AWARE_FILL_TOOLS = [
+  { id: "sampling-brush", label: "Sampling Brush", key: "b" },
+  { id: "hand", label: "Hand", key: "h" },
+  { id: "zoom", label: "Zoom", key: "z" }
+];
+var CONTENT_AWARE_FILL_SAMPLING = [
+  { id: "auto", label: "Auto" },
+  { id: "rectangular", label: "Rectangular" },
+  { id: "custom", label: "Custom" }
+];
+var DEFAULT_CONTENT_AWARE_FILL_SETTINGS = {
+  sampling: "auto",
+  showSampling: true,
+  opacity: 0.5,
+  tool: "sampling-brush",
+  brushSize: 40,
+  brushMode: "add",
+  seed: 0,
+  output: "new-layer",
+  livePreview: true
+};
+var ContentAwareFillSession = class {
+  constructor(controller) {
+    this.controller = controller;
+  }
+  controller;
+  settingsValue = { ...DEFAULT_CONTENT_AWARE_FILL_SETTINGS };
+  plan = null;
+  /** The source view's window (document pixels): the selection with room around it to sample. */
+  win = null;
+  before = null;
+  hole = null;
+  /** 1 where the fill may copy from, per window pixel. */
+  area = null;
+  after = null;
+  lastPoint = null;
+  listeners = /* @__PURE__ */ new Set();
+  dirty = false;
+  /** Why the workspace can't fill (nothing selected, not a pixel layer), for the UI. */
+  error = null;
+  computing = false;
+  revision = 0;
+  get settings() {
+    return this.settingsValue;
+  }
+  /** The source view's window in document pixels (`null` until opened). */
+  get window() {
+    return this.win;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  emit() {
+    this.revision++;
+    for (const l of this.listeners) l();
+  }
+  /**
+   * Reads the layer around the selection and makes the first preview. The window holds the
+   * selection and room around it to sample from (its larger side, at least 64 px, each way).
+   */
+  async open() {
+    try {
+      const sel = this.controller.getSelection();
+      const b = sel?.bounds;
+      const margin = b ? Math.max(64, Math.max(b.width, b.height)) : 64;
+      this.plan = this.controller.prepareContentAwareFill({ sampleRadius: margin });
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : String(err);
+      this.emit();
+      return false;
+    }
+    this.win = this.plan.window;
+    this.before = this.plan.before;
+    this.hole = this.plan.hole;
+    this.applySampling("auto");
+    this.emit();
+    await this.refresh();
+    return true;
+  }
+  /** Sets the area to a preset: Auto (a band around the selection), Rectangular (the whole window). */
+  applySampling(mode) {
+    const win = this.win;
+    const hole = this.hole;
+    const n = win.width * win.height;
+    const area = this.area && mode === "custom" ? this.area : new Uint8Array(n);
+    if (mode === "rectangular") {
+      for (let i = 0; i < n; i++) area[i] = hole[i] ? 0 : 1;
+    } else if (mode === "auto") {
+      const b = this.plan.bounds;
+      const reach = Math.max(24, Math.max(b.width, b.height) / 2);
+      const d = distanceTransform(hole, win.width, win.height);
+      for (let i = 0; i < n; i++) area[i] = !hole[i] && d[i] <= reach ? 1 : 0;
+    }
+    this.area = area;
+  }
+  /** Changes settings; a sampling preset replaces the area, and the preview follows when live. */
+  update(changes) {
+    const prev = this.settingsValue;
+    this.settingsValue = { ...prev, ...changes };
+    if (!this.win) {
+      this.emit();
+      return;
+    }
+    if (changes.sampling && changes.sampling !== prev.sampling && changes.sampling !== "custom") this.applySampling(changes.sampling);
+    this.emit();
+    const fillChanged = changes.sampling !== void 0 || changes.seed !== void 0;
+    if (fillChanged && this.settingsValue.livePreview) void this.refresh();
+  }
+  /** The sampling area as a selection of the whole image (what OK samples from). */
+  samplingMask() {
+    if (!this.win || !this.area) return null;
+    const { width, height } = this.controller.getState().imageDimensions;
+    const bytes = new Uint8Array(this.area.length);
+    for (let i = 0; i < bytes.length; i++) bytes[i] = this.area[i] ? 255 : 0;
+    return selectionFromRegion(width, height, this.win, bytes);
+  }
+  /** Whether (x, y) in document pixels is in the sampling area. */
+  samplesAt(x, y) {
+    const win = this.win;
+    if (!win || !this.area) return false;
+    const xi = Math.floor(x - win.x);
+    const yi = Math.floor(y - win.y);
+    if (xi < 0 || yi < 0 || xi >= win.width || yi >= win.height) return false;
+    return this.area[yi * win.width + xi] === 1;
+  }
+  /** Paints the sampling area with the brush along a stroke segment (document pixels). */
+  paint(from, to, add2) {
+    const win = this.win;
+    const area = this.area;
+    const hole = this.hole;
+    const r = Math.max(0.5, this.settingsValue.brushSize / 2);
+    const x0 = Math.max(0, Math.floor(Math.min(from.x, to.x) - r - win.x));
+    const y0 = Math.max(0, Math.floor(Math.min(from.y, to.y) - r - win.y));
+    const x1 = Math.min(win.width - 1, Math.ceil(Math.max(from.x, to.x) + r - win.x));
+    const y1 = Math.min(win.height - 1, Math.ceil(Math.max(from.y, to.y) + r - win.y));
+    const dx = to.x - from.x;
+    const dy = to.y - from.y;
+    const len2 = dx * dx + dy * dy;
+    for (let y = y0; y <= y1; y++) {
+      for (let x = x0; x <= x1; x++) {
+        const px2 = win.x + x + 0.5 - from.x;
+        const py = win.y + y + 0.5 - from.y;
+        const t = len2 > 0 ? Math.min(1, Math.max(0, (px2 * dx + py * dy) / len2)) : 0;
+        if ((px2 - t * dx) ** 2 + (py - t * dy) ** 2 > r * r) continue;
+        const i = y * win.width + x;
+        area[i] = add2 && !hole[i] ? 1 : 0;
+      }
+    }
+  }
+  /** Pointer down with the Sampling Brush (Alt flips add and subtract). Returns false for other tools. */
+  begin(point, modifiers = {}) {
+    if (this.settingsValue.tool !== "sampling-brush" || !this.win) return false;
+    const add2 = this.settingsValue.brushMode === "add" !== Boolean(modifiers.altKey);
+    this.settingsValue = { ...this.settingsValue, sampling: "custom" };
+    this.lastPoint = point;
+    this.strokeAdds = add2;
+    this.paint(point, point, add2);
+    this.emit();
+    return true;
+  }
+  strokeAdds = true;
+  move(point) {
+    if (!this.lastPoint) return;
+    this.paint(this.lastPoint, point, this.strokeAdds);
+    this.lastPoint = point;
+    this.emit();
+  }
+  /** Pointer up: the preview follows the new area when live. */
+  end() {
+    if (!this.lastPoint) return;
+    this.lastPoint = null;
+    if (this.settingsValue.livePreview) void this.refresh();
+  }
+  /** Recomputes the preview: one at a time, the newest area following when one is running. */
+  async refresh() {
+    if (!this.win) return;
+    if (this.computing) {
+      this.dirty = true;
+      return;
+    }
+    this.computing = true;
+    this.emit();
+    do {
+      this.dirty = false;
+      try {
+        const area = this.samplingMask();
+        if (!area?.bounds) throw new Error("The sampling area is empty; paint where the fill may copy from.");
+        const { plan, after } = await this.controller.previewContentAwareFill({ layerId: this.plan.layerId, samplingArea: area, seed: this.settingsValue.seed });
+        const win = this.win;
+        const out = Uint8ClampedArray.from(this.before);
+        const pw = plan.window;
+        for (let y = 0; y < pw.height; y++) {
+          out.set(after.subarray(y * pw.width * 4, (y + 1) * pw.width * 4), ((pw.y - win.y + y) * win.width + (pw.x - win.x)) * 4);
+        }
+        this.after = out;
+        this.error = null;
+      } catch (err) {
+        this.after = null;
+        this.error = err instanceof Error ? err.message : String(err);
+      }
+      this.emit();
+    } while (this.dirty);
+    this.computing = false;
+    this.emit();
+  }
+  /** Resolves once no preview is being computed. */
+  async idle() {
+    while (this.computing) await new Promise((r) => setTimeout(r, 5));
+  }
+  /** The source view: the layer's pixels, the selection tinted red, the sampling area green. RGBA at the window's size. */
+  renderSource() {
+    if (!this.before || !this.area || !this.hole) return new Uint8ClampedArray(0);
+    const out = Uint8ClampedArray.from(this.before);
+    const k = this.settingsValue.showSampling ? Math.min(1, Math.max(0, this.settingsValue.opacity)) : 0;
+    for (let i = 0; i < this.area.length; i++) {
+      const p = i * 4;
+      if (this.hole[i]) {
+        out[p] = out[p] + (220 - out[p]) * 0.5;
+        out[p + 1] *= 0.5;
+        out[p + 2] *= 0.5;
+      } else if (this.area[i] && k) {
+        out[p] *= 1 - k;
+        out[p + 1] = out[p + 1] + (200 - out[p + 1]) * k;
+        out[p + 2] *= 1 - k;
+      }
+      out[p + 3] = 255;
+    }
+    return out;
+  }
+  /** The preview: the window with the fill in place (the source until the first preview). */
+  renderPreview() {
+    const src = this.after ?? this.before;
+    if (!src) return new Uint8ClampedArray(0);
+    const out = Uint8ClampedArray.from(src);
+    for (let i = 3; i < out.length; i += 4) out[i] = 255;
+    return out;
+  }
+  /** Clears painting and goes back to Auto. */
+  reset() {
+    if (!this.win) return;
+    this.settingsValue = { ...DEFAULT_CONTENT_AWARE_FILL_SETTINGS, tool: this.settingsValue.tool };
+    this.applySampling("auto");
+    this.emit();
+    if (this.settingsValue.livePreview) void this.refresh();
+  }
+  /**
+   * Keys: B, H, Z for the tools, [ and ] for the brush size. Returns true when the key was used.
+   */
+  handleKey(key) {
+    const k = key.toLowerCase();
+    const tool = CONTENT_AWARE_FILL_TOOLS.find((t) => t.key === k);
+    if (tool) {
+      this.update({ tool: tool.id });
+      return true;
+    }
+    if (k === "[" || k === "]") {
+      const size = this.settingsValue.brushSize;
+      this.update({ brushSize: Math.max(1, Math.round(k === "]" ? size * 1.25 : size / 1.25)) });
+      return true;
+    }
+    return false;
+  }
+  /** OK: fills with this sampling area, seed and output as one undo step. */
+  async commit(options = {}) {
+    const area = this.samplingMask();
+    if (!this.plan || !area?.bounds) throw new Error(this.error ?? "The sampling area is empty; paint where the fill may copy from.");
+    return this.controller.contentAwareFillAsync({ layerId: this.plan.layerId, samplingArea: area, seed: this.settingsValue.seed, output: this.settingsValue.output, signal: options.signal });
+  }
+};
 export {
   ADJUSTMENT_KEYS,
   ADJUSTMENT_KINDS,
@@ -19647,7 +20011,10 @@ export {
   COLOR_MODE_OPTIONS,
   COLOR_RANGE_PRESETS,
   COLOR_RANGE_PRESET_LABELS,
+  CONTENT_AWARE_FILL_SAMPLING,
+  CONTENT_AWARE_FILL_TOOLS,
   ColorGmm,
+  ContentAwareFillSession,
   CoverageMap,
   D50,
   D65,
@@ -19657,6 +20024,7 @@ export {
   DEFAULT_BRUSH,
   DEFAULT_CANVAS_VIEWPORT,
   DEFAULT_CHANNEL_COLOR,
+  DEFAULT_CONTENT_AWARE_FILL_SETTINGS,
   DEFAULT_DEPTH_MASK,
   DEFAULT_FLOW,
   DEFAULT_GLOBAL_LIGHT,

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

@@ -52,6 +52,13 @@ export type SelectionJob = {
     base: SerializedMask | null;
     edits: RefineEdit[];
     params: RefineEdgeParams;
+}
+/** Content-Aware Fill's synthesis on a window (the pixels): `hole` to fill, `exclude` not to copy from. */
+ | {
+    op: 'fill';
+    hole: Uint8Array;
+    exclude: Uint8Array | null;
+    seed: number;
 };
 /** What a job found: a selection of the whole image, and the job's notes. */
 export interface SelectionJobResult {
@@ -60,6 +67,8 @@ export interface SelectionJobResult {
     reason?: string;
     /** Focus Area: the noise level it measured. */
     noiseLevel?: number;
+    /** Content-Aware Fill: the window's pixels with the hole filled (RGBA). */
+    pixels?: Uint8ClampedArray;
 }
 /** Runs `job` on `pixels` here and now. */
 export declare function runSelectionJob(job: SelectionJob, pixels: PixelBuffer, onProgress?: SelectionProgress): SelectionJobResult;
@@ -86,6 +95,7 @@ export type SelectionWorkerResponse = {
     mask: SerializedMask;
     reason?: string;
     noiseLevel?: number;
+    pixels?: Uint8ClampedArray;
 } | {
     type: 'error';
     id: number;

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

@@ -52,6 +52,13 @@ export type SelectionJob = {
     base: SerializedMask | null;
     edits: RefineEdit[];
     params: RefineEdgeParams;
+}
+/** Content-Aware Fill's synthesis on a window (the pixels): `hole` to fill, `exclude` not to copy from. */
+ | {
+    op: 'fill';
+    hole: Uint8Array;
+    exclude: Uint8Array | null;
+    seed: number;
 };
 /** What a job found: a selection of the whole image, and the job's notes. */
 export interface SelectionJobResult {
@@ -60,6 +67,8 @@ export interface SelectionJobResult {
     reason?: string;
     /** Focus Area: the noise level it measured. */
     noiseLevel?: number;
+    /** Content-Aware Fill: the window's pixels with the hole filled (RGBA). */
+    pixels?: Uint8ClampedArray;
 }
 /** Runs `job` on `pixels` here and now. */
 export declare function runSelectionJob(job: SelectionJob, pixels: PixelBuffer, onProgress?: SelectionProgress): SelectionJobResult;
@@ -86,6 +95,7 @@ export type SelectionWorkerResponse = {
     mask: SerializedMask;
     reason?: string;
     noiseLevel?: number;
+    pixels?: Uint8ClampedArray;
 } | {
     type: 'error';
     id: number;

package/dist/image-editor/selection-worker.cjs

@@ -1,14 +1,15 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkX4LUGTQXcjs = require('../chunk-X4LUGTQX.cjs');
+var _chunkL52VMQZScjs = require('../chunk-L52VMQZS.cjs');
 require('../chunk-QYLWG22N.cjs');
 require('../chunk-K6PXS6DO.cjs');
+require('../chunk-MQDIP4CF.cjs');
 require('../chunk-474IQG74.cjs');
 
 // src/image-editor/selection-worker.ts
 if (typeof self !== "undefined" && typeof window === "undefined" && typeof self.postMessage === "function") {
-  _chunkX4LUGTQXcjs.startSelectionWorker.call(void 0, self);
+  _chunkL52VMQZScjs.startSelectionWorker.call(void 0, self);
 }
 
 
-exports.startSelectionWorker = _chunkX4LUGTQXcjs.startSelectionWorker;
+exports.startSelectionWorker = _chunkL52VMQZScjs.startSelectionWorker;

package/dist/image-editor/selection-worker.js

@@ -1,8 +1,9 @@
 import {
   startSelectionWorker
-} from "../chunk-DWYQPL2A.js";
+} from "../chunk-LQ5SALHK.js";
 import "../chunk-L3G23N5Y.js";
 import "../chunk-ZIF4UJJ6.js";
+import "../chunk-XI2NV5U7.js";
 import "../chunk-HVVR5PZW.js";
 
 // src/image-editor/selection-worker.ts

package/dist/paint/heal.d.cts

@@ -29,9 +29,11 @@ export declare function bestOffset(w: number, h: number, ch: number, img: ArrayL
  * continue across it: PatchMatch nearest-neighbour fields over 7 × 7 patches with patch voting
  * (Wexler et al. / Barnes et al.), run coarse to fine from a smooth fill. Deterministic for the
  * same input. Returns the filled image; pixels outside `hole` are unchanged. Falls back to a
- * smooth fill when there is no whole patch to copy from.
+ * smooth fill when there is no whole patch to copy from. `exclude` marks pixels no source patch
+ * may include (Content-Aware Fill's sampling area is everything else).
  */
 export declare function contentAwareFill(w: number, h: number, ch: number, img: ArrayLike<number>, hole: ArrayLike<boolean | number>, options?: {
     iterations?: number;
     seed?: number;
+    exclude?: ArrayLike<boolean | number> | null;
 }): Float32Array;