@pixerate/editor 0.208.0 → 0.210.0

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,
@@ -5103,6 +5105,7 @@ var ImageEditorController = class {
   /** The segmentation provider behind `selectSubject` (see `setSegmentationProvider`). */
   segmentation = null;
   selectionWorker = null;
+  documentOpener = null;
   /** The effects provider slot (see `setEffectsProvider`). */
   effects = new EffectsSlot();
   /** Renders provider effects: effect smart filter results and effect layers. */
@@ -5114,6 +5117,7 @@ var ImageEditorController = class {
     if (options.effects) this.effects.set(options.effects);
     if (options.segmentation) this.segmentation = options.segmentation;
     if (options.selectionWorker) this.selectionWorker = new SelectionWorkerClient(options.selectionWorker);
+    if (options.openDocument) this.documentOpener = options.openDocument;
     this.maxHistoryDepth = options.maxHistoryDepth ?? 50;
     if (options.textShaper !== void 0) this.textShaperValue = options.textShaper;
     this.maxHistoryBytes = options.maxHistoryBytes ?? 512 * 1024 * 1024;
@@ -5311,6 +5315,70 @@ var ImageEditorController = class {
     this.selectionWorker?.terminate();
     this.selectionWorker = factory ? new SelectionWorkerClient(factory) : null;
   }
+  /** Sets (or with `null` removes) how new documents are opened (see `DocumentOpener`). Not an edit. */
+  setDocumentOpener(opener) {
+    if (this.documentOpener === opener) return;
+    this.documentOpener = opener;
+    this.notify();
+  }
+  /** Whether the host can open new documents (the New Document outputs are available). */
+  get canOpenDocuments() {
+    return this.documentOpener !== null;
+  }
+  /**
+   * A new one-layer document from the selection (or `options.selection`) on a pixel layer
+   * (`layerId`, default the active one), the size of this image: the selected pixels on
+   * transparency, or with `withMask` the whole layer masked by the selection. This document is
+   * not changed. `decontaminate` (0..100) cleans the soft edge's colours as the new-layer
+   * outputs do.
+   */
+  documentFromSelection(options = {}) {
+    const id = options.layerId ?? this.state.activeLayerId;
+    if (!id) throw new LayerOperationError("No layer given and none is active; pass layerId (see list_layers).");
+    const layer = requireLayer(this.state.layers, id).layer;
+    if (layer.type !== "pixel") throw new LayerOperationError(`A new document needs a pixel layer; "${id}" is a ${layer.type} layer.`);
+    const sel = options.selection ?? this.state.selection;
+    if (!sel?.bounds) throw new LayerOperationError("Nothing is selected; select what goes in the new document first.");
+    const { width, height } = this.naturalSize;
+    const surface = this.surfaceOf(layer);
+    let copy;
+    if (options.withMask) {
+      let mask = this.maskFromSelection(sel);
+      if (layer.offset.x || layer.offset.y) mask = { ...mask, surface: translateSurface(mask.surface, -layer.offset.x, -layer.offset.y) };
+      copy = { ...layer, id: newLayerId(), surface, mask };
+    } else {
+      const sb = sel.bounds;
+      const src = { x: sb.x - layer.offset.x, y: sb.y - layer.offset.y, width: sb.width, height: sb.height };
+      const px2 = readRegion(surface, src);
+      const data = sel.data;
+      for (let y = 0; y < sb.height; y++) {
+        for (let x = 0; x < sb.width; x++) px2[(y * sb.width + x) * 4 + 3] = Math.round(px2[(y * sb.width + x) * 4 + 3] * (data[(sb.y + y) * width + sb.x + x] / 255));
+      }
+      copy = { ...layer, id: newLayerId(), surface: surfaceFromPixels({ width: src.width, height: src.height, data: px2 }, 4, src.x, src.y) };
+      delete copy.mask;
+    }
+    delete copy.source;
+    copy.visible = true;
+    const amount = Math.min(100, Math.max(0, options.decontaminate ?? 0)) / 100;
+    if (amount > 0) copy = { ...copy, surface: this.decontaminatedSurface(copy, layer, sel, amount, Math.max(4, options.radius ?? 0)) };
+    const { layers, assets, smartContents } = serializeLayers([copy]);
+    const out = {
+      version: LAYERED_SCHEMA_VERSION,
+      width,
+      height,
+      layers,
+      assets,
+      activeLayerId: copy.id,
+      crop: null,
+      transform: { ...DEFAULT_TRANSFORM },
+      opacity: 1
+    };
+    if (smartContents) out.smartContents = smartContents;
+    if (this.state.bitDepth === 16 || this.state.bitDepth === 32) out.bitDepth = this.state.bitDepth;
+    if (this.state.colorProfile) out.colorProfile = serializeColorProfile(this.state.colorProfile);
+    if (this.state.colorMode) out.colorMode = serializeColorMode(this.state.colorMode);
+    return out;
+  }
   /** Whether the long selections run in a worker. */
   get hasSelectionWorker() {
     return this.selectionWorker !== null;
@@ -7837,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.");
@@ -7848,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);
@@ -7882,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 };
@@ -8752,8 +8895,12 @@ var ImageEditorController = class {
       throw new Error("Object aware refinement needs a segmentation model (setSegmentationProvider); use refineMode color.");
     }
     const amount = Math.min(100, Math.max(0, options.decontaminate ?? 0)) / 100;
-    const toLayer = output === "new-layer" || output === "new-layer-with-mask";
-    if (amount > 0 && !toLayer) throw new Error("Decontaminate colors writes the cleaned colours to a new layer: use output new-layer or new-layer-with-mask.");
+    const toDocument = output === "new-document" || output === "new-document-with-mask";
+    const toLayer = output === "new-layer" || output === "new-layer-with-mask" || toDocument;
+    if (amount > 0 && !toLayer) throw new Error("Decontaminate colors writes the cleaned colours to a new layer or document: use output new-layer, new-layer-with-mask, new-document or new-document-with-mask.");
+    if (toDocument && !this.documentOpener) {
+      throw new Error("This editor cannot open new documents (no document opener is set); use output new-layer or new-layer-with-mask instead.");
+    }
     let layerId;
     if (output !== "selection") {
       layerId = options.layerId ?? this.state.activeLayerId ?? void 0;
@@ -8778,6 +8925,12 @@ var ImageEditorController = class {
     }
     const refined = refineSelection(pixels, sel, params, edited.refineBrush);
     if (!refined.bounds) throw new Error("Refining left nothing selected; use a smaller shiftEdge or contrast.");
+    if (toDocument) {
+      const document2 = this.documentFromSelection({ layerId, withMask: output === "new-document-with-mask", selection: refined, decontaminate: amount * 100, radius: params.radius });
+      const name = `${requireLayer(this.state.layers, layerId).layer.name || "Layer"} ${output === "new-document" ? "cutout" : "masked"}`;
+      const documentId = await this.documentOpener(document2, { name, from: "select-and-mask" });
+      return { output, layerId, refineMode, ...documentId ? { documentId } : {} };
+    }
     return this.asOneStep(() => {
       this.setSelection(refined);
       if (output === "selection") return { output, refineMode };
@@ -8808,6 +8961,16 @@ var ImageEditorController = class {
     const layer = requireLayer(this.state.layers, id).layer;
     const source = requireLayer(this.state.layers, sourceId).layer;
     if (layer.type !== "pixel" || source.type !== "pixel" || !coverage.bounds) return;
+    const surface = this.decontaminatedSurface(layer, source, coverage, amount, radius);
+    const next = mapLayer(this.state.layers, id, (l) => {
+      const updated = { ...l, surface };
+      delete updated.source;
+      return updated;
+    });
+    this.commitLayers(next);
+  }
+  /** `layer`'s surface with Decontaminate Colors applied along `coverage`'s soft edge, colours read from `source`. */
+  decontaminatedSurface(layer, source, coverage, amount, radius) {
     const { width, height } = this.naturalSize;
     const pad = Math.ceil(radius * 3);
     const b = coverage.bounds;
@@ -8823,12 +8986,7 @@ var ImageEditorController = class {
     for (let y = 0; y < box.height; y++) cov.set(all.subarray((box.y + y) * width + box.x, (box.y + y) * width + box.x + box.width), y * box.width);
     const cleaned = decontaminateColors(original, cov, box.width, box.height, amount, radius);
     for (let i = 3; i < cleaned.length; i += 4) cleaned[i] = rgba[i];
-    const next = mapLayer(this.state.layers, id, (l) => {
-      const updated = { ...l, surface: writeRegion(surface, src, cleaned) };
-      delete updated.source;
-      return updated;
-    });
-    this.commitLayers(next);
+    return writeRegion(surface, src, cleaned);
   }
   /**
    * Loads a selection from a mask image (an AI segmentation, a saved mask): a data URL / URL or
@@ -11805,7 +11963,9 @@ var REFINE_OUTPUTS = [
   { id: "selection", label: "Selection" },
   { id: "layer-mask", label: "Layer Mask" },
   { id: "new-layer", label: "New Layer" },
-  { id: "new-layer-with-mask", label: "New Layer with Layer Mask" }
+  { id: "new-layer-with-mask", label: "New Layer with Layer Mask" },
+  { id: "new-document", label: "New Document", needsDocuments: true },
+  { id: "new-document-with-mask", label: "New Document with Layer Mask", needsDocuments: true }
 ];
 function describeSelection(mask) {
   if (!mask || !mask.bounds) return "No selection";
@@ -11841,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 };
 }
@@ -12027,11 +12194,11 @@ function createImageSelectionTools(controller) {
         shiftEdge: { type: "number", minimum: -100, maximum: 100, description: "Move the edge out (+) or in (-), in percent." },
         output: {
           type: "string",
-          enum: ["selection", "layer-mask", "new-layer", "new-layer-with-mask"],
-          description: "Where the result goes (default selection). layer-mask keeps every pixel and is easiest to revise; new-layer-with-mask too, on a copy."
+          enum: ["selection", "layer-mask", "new-layer", "new-layer-with-mask", "new-document", "new-document-with-mask"],
+          description: "Where the result goes (default selection). layer-mask keeps every pixel and is easiest to revise; new-layer-with-mask too, on a copy. new-document and new-document-with-mask hand a new one-layer document to the host (only when the host can open documents; this one is unchanged) and return its documentId."
         },
         layerId: { type: "string", description: "The layer for layer outputs (default the active layer; see list_layers). New-layer outputs need a pixel layer." },
-        decontaminate: { type: "number", minimum: 0, maximum: 100, description: "Decontaminate Colors amount 0-100 (default 0), only with output new-layer or new-layer-with-mask." },
+        decontaminate: { type: "number", minimum: 0, maximum: 100, description: "Decontaminate Colors amount 0-100 (default 0), only with the new-layer and new-document outputs." },
         edits: {
           type: "array",
           description: "Strokes applied before refining, in order.",
@@ -12694,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
       });
     }
   };
@@ -17877,7 +18052,7 @@ var SelectAndMaskSession = class {
     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,
+      decontaminate: s.output === "selection" || s.output === "layer-mask" ? 0 : s.decontaminate,
       refineMode: s.refineMode
     });
   }
@@ -19539,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,
@@ -19564,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,
@@ -19574,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,