@pixerate/editor 0.206.0 → 0.208.0

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

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

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

@@ -15,3 +15,5 @@ export * from './path.js';
 export * from './magnetic.js';
 export * from './segment/index.js';
 export * from './refine-edits.js';
+export * from './select-and-mask.js';
+export * from './worker.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

package/dist/image-editor/selection/segment/focus.d.cts

@@ -5,6 +5,7 @@
  * and fitted to the image's edges with a guided filter.
  */
 import type { PixelBuffer, SelectionMask } from '../mask.cjs';
+import { type SelectionProgress } from './work.cjs';
 export interface FocusAreaOptions {
     /** In-Focus Range 0..100 (default 50): higher takes in less sharp areas too. */
     range?: number;
@@ -12,6 +13,7 @@ export interface FocusAreaOptions {
     noise?: number;
     /** Soften the edge over this many natural pixels (default 4; 0 for a hard edge). */
     softness?: number;
+    onProgress?: SelectionProgress;
 }
 export interface FocusAreaResult {
     selection: SelectionMask;

package/dist/image-editor/selection/segment/focus.d.ts

@@ -5,6 +5,7 @@
  * and fitted to the image's edges with a guided filter.
  */
 import type { PixelBuffer, SelectionMask } from '../mask.js';
+import { type SelectionProgress } from './work.js';
 export interface FocusAreaOptions {
     /** In-Focus Range 0..100 (default 50): higher takes in less sharp areas too. */
     range?: number;
@@ -12,6 +13,7 @@ export interface FocusAreaOptions {
     noise?: number;
     /** Soften the edge over this many natural pixels (default 4; 0 for a hard edge). */
     softness?: number;
+    onProgress?: SelectionProgress;
 }
 export interface FocusAreaResult {
     selection: SelectionMask;

package/dist/image-editor/selection/segment/grabcut.d.cts

@@ -7,7 +7,7 @@
  */
 import type { CropBox, ImagePoint } from '../../types.cjs';
 import { type PixelBuffer, type SelectionMask } from '../mask.cjs';
-import { type Rect, type WorkImage } from './work.cjs';
+import { type Rect, type SelectionProgress, type WorkImage } from './work.cjs';
 /** A mixture of {@link K} full-covariance Gaussians over RGB. */
 export declare class ColorGmm {
     private readonly logWeight;
@@ -36,7 +36,8 @@ export interface GrabCutSetup {
     hardFg: Uint8Array | null;
 }
 /** GrabCut over the setup's window; returns 1 for the object per window pixel. */
-export declare function grabCutLabels(work: WorkImage, setup: GrabCutSetup, iterations: number): Uint8Array;
+/** GrabCut over the setup's window; `onRound` is called after each round with the share done. */
+export declare function grabCutLabels(work: WorkImage, setup: GrabCutSetup, iterations: number, onRound?: (fraction: number) => void): Uint8Array;
 /**
  * Keeps the object's main parts: the pieces (4-connected) holding `seed` (window index), or
  * without one, every piece at least a fifth the size of the largest.
@@ -47,6 +48,7 @@ export interface ObjectSelectionOptions {
     enhanceEdge?: boolean;
     /** Most rounds of fitting and cutting (default 5; it stops early once the labels settle). */
     iterations?: number;
+    onProgress?: SelectionProgress;
 }
 /** What to select: a box around the object, or a point on it (natural pixels). */
 export type ObjectTarget = {

package/dist/image-editor/selection/segment/grabcut.d.ts

@@ -7,7 +7,7 @@
  */
 import type { CropBox, ImagePoint } from '../../types.js';
 import { type PixelBuffer, type SelectionMask } from '../mask.js';
-import { type Rect, type WorkImage } from './work.js';
+import { type Rect, type SelectionProgress, type WorkImage } from './work.js';
 /** A mixture of {@link K} full-covariance Gaussians over RGB. */
 export declare class ColorGmm {
     private readonly logWeight;
@@ -36,7 +36,8 @@ export interface GrabCutSetup {
     hardFg: Uint8Array | null;
 }
 /** GrabCut over the setup's window; returns 1 for the object per window pixel. */
-export declare function grabCutLabels(work: WorkImage, setup: GrabCutSetup, iterations: number): Uint8Array;
+/** GrabCut over the setup's window; `onRound` is called after each round with the share done. */
+export declare function grabCutLabels(work: WorkImage, setup: GrabCutSetup, iterations: number, onRound?: (fraction: number) => void): Uint8Array;
 /**
  * Keeps the object's main parts: the pieces (4-connected) holding `seed` (window index), or
  * without one, every piece at least a fifth the size of the largest.
@@ -47,6 +48,7 @@ export interface ObjectSelectionOptions {
     enhanceEdge?: boolean;
     /** Most rounds of fitting and cutting (default 5; it stops early once the labels settle). */
     iterations?: number;
+    onProgress?: SelectionProgress;
 }
 /** What to select: a box around the object, or a point on it (natural pixels). */
 export type ObjectTarget = {

package/dist/image-editor/selection/segment/sky.d.cts

@@ -6,11 +6,13 @@
  * with the colour guided filter.
  */
 import { type PixelBuffer, type SelectionMask } from '../mask.cjs';
+import { type SelectionProgress } from './work.cjs';
 export interface SkyOptions {
     /** 0..100 (default 50): higher takes in less sky-like pixels (haze, a sunset glow). */
     threshold?: number;
     /** Soften the edge over this many natural pixels (default 4; 0 for a hard edge). */
     softness?: number;
+    onProgress?: SelectionProgress;
 }
 export interface FoundSky {
     selection: SelectionMask;

package/dist/image-editor/selection/segment/sky.d.ts

@@ -6,11 +6,13 @@
  * with the colour guided filter.
  */
 import { type PixelBuffer, type SelectionMask } from '../mask.js';
+import { type SelectionProgress } from './work.js';
 export interface SkyOptions {
     /** 0..100 (default 50): higher takes in less sky-like pixels (haze, a sunset glow). */
     threshold?: number;
     /** Soften the edge over this many natural pixels (default 4; 0 for a hard edge). */
     softness?: number;
+    onProgress?: SelectionProgress;
 }
 export interface FoundSky {
     selection: SelectionMask;

package/dist/image-editor/selection/segment/subject.d.cts

@@ -12,7 +12,7 @@
  * It cannot tell which object a description names: it selects what stands out.
  */
 import type { PixelBuffer, SelectionMask } from '../mask.cjs';
-import { type WorkImage } from './work.cjs';
+import { type SelectionProgress, type WorkImage } from './work.cjs';
 export interface Superpixels {
     /** Superpixel of each work pixel. */
     label: Int32Array;
@@ -41,4 +41,5 @@ export interface FoundSubject {
  */
 export declare function findSubject(pixels: PixelBuffer, options?: {
     enhanceEdge?: boolean;
+    onProgress?: SelectionProgress;
 }): FoundSubject;

package/dist/image-editor/selection/segment/subject.d.ts

@@ -12,7 +12,7 @@
  * It cannot tell which object a description names: it selects what stands out.
  */
 import type { PixelBuffer, SelectionMask } from '../mask.js';
-import { type WorkImage } from './work.js';
+import { type SelectionProgress, type WorkImage } from './work.js';
 export interface Superpixels {
     /** Superpixel of each work pixel. */
     label: Int32Array;
@@ -41,4 +41,5 @@ export interface FoundSubject {
  */
 export declare function findSubject(pixels: PixelBuffer, options?: {
     enhanceEdge?: boolean;
+    onProgress?: SelectionProgress;
 }): FoundSubject;

package/dist/image-editor/selection/segment/work.d.cts

@@ -3,6 +3,11 @@
  * Area) work on, and scaling their result back up to the image.
  */
 import { type PixelBuffer, type SelectionMask } from '../mask.cjs';
+/**
+ * Progress of a long selection: `fraction` 0..1 done and what it is doing. The segmentations call
+ * it between their stages; in a worker it is posted back to the page.
+ */
+export type SelectionProgress = (fraction: number, stage: string) => void;
 /** The reduced image the segmentations work on (sRGB, 0..255 per channel). */
 export interface WorkImage {
     /** Natural size of the image it was made from. */

package/dist/image-editor/selection/segment/work.d.ts

@@ -3,6 +3,11 @@
  * Area) work on, and scaling their result back up to the image.
  */
 import { type PixelBuffer, type SelectionMask } from '../mask.js';
+/**
+ * Progress of a long selection: `fraction` 0..1 done and what it is doing. The segmentations call
+ * it between their stages; in a worker it is posted back to the page.
+ */
+export type SelectionProgress = (fraction: number, stage: string) => void;
 /** The reduced image the segmentations work on (sRGB, 0..255 per channel). */
 export interface WorkImage {
     /** Natural size of the image it was made from. */

package/dist/image-editor/selection/select-and-mask.d.cts

@@ -0,0 +1,136 @@
+/**
+ * The Select and Mask workspace without a UI: its settings, strokes, preview and view modes, shared
+ * by the React and Svelte workspaces. Everything it holds is plain data (the strokes are
+ * `RefineEdit`s), and OK runs the same `refineSelectionTo` call an agent makes with `edits`, so
+ * the workspace and an agent produce the same result in one undo step.
+ *
+ * The preview is computed on a copy reduced to {@link PREVIEW_SIZE} px (or at full size with High
+ * Quality Preview), in the controller's selection worker when it has one, and drawn as RGBA in
+ * the chosen view mode.
+ */
+import type { ImageEditorController, RefineOutput, RefineOutputResult } from '../controller.cjs';
+import type { ImagePoint } from '../types.cjs';
+import { type RefineEdgeParams } from './refine.cjs';
+import { type RefineEdit } from './refine-edits.cjs';
+export type SelectAndMaskView = 'onion-skin' | 'marching-ants' | 'overlay' | 'on-black' | 'on-white' | 'black-white' | 'on-layers';
+export type SelectAndMaskTool = 'quick-select' | 'refine-brush' | 'brush' | 'object' | 'lasso' | 'hand' | 'zoom';
+/** The view modes with Photoshop's keys, in menu order. */
+export declare const SELECT_AND_MASK_VIEWS: readonly {
+    id: SelectAndMaskView;
+    label: string;
+    key: string;
+    opacity: number;
+}[];
+/** The workspace tools with Photoshop's keys. */
+export declare const SELECT_AND_MASK_TOOLS: readonly {
+    id: SelectAndMaskTool;
+    label: string;
+    key: string;
+}[];
+export interface SelectAndMaskSettings {
+    params: Required<RefineEdgeParams>;
+    output: RefineOutput;
+    /** Decontaminate Colors amount 0..100 (new-layer outputs). */
+    decontaminate: number;
+    refineMode: 'color' | 'object';
+    view: SelectAndMaskView;
+    /** How strongly the view shows what is not selected, 0..1. */
+    opacity: number;
+    /** Show only the area the refinement changes. */
+    showEdge: boolean;
+    /** Show the selection as it was, before the workspace. */
+    showOriginal: boolean;
+    /** Update the preview while painting (otherwise on release). */
+    realTime: boolean;
+    /** Preview at full size instead of a reduced copy. */
+    highQuality: boolean;
+    /** Keep these settings for the next time the workspace opens. */
+    remember: boolean;
+    tool: SelectAndMaskTool;
+    /** Brush diameter in natural pixels. */
+    brushSize: number;
+    brushMode: 'add' | 'subtract';
+}
+export declare const DEFAULT_SELECT_AND_MASK_SETTINGS: SelectAndMaskSettings;
+/** Long side of the reduced preview. */
+export declare const PREVIEW_SIZE = 1024;
+export declare class SelectAndMaskSession {
+    readonly controller: ImageEditorController;
+    private settingsValue;
+    private readonly editsList;
+    /** The edit being painted, shown in the preview but not yet in `edits`. */
+    private live;
+    private dragStart;
+    private pixels;
+    private previewPixels;
+    private base;
+    private previewMask;
+    private baseMask;
+    private readonly listeners;
+    /** Why the preview could not be made (no pixels), for the UI. */
+    error: string | null;
+    /** A note for the UI, such as object aware refinement applying only on OK. */
+    note: string | null;
+    /** Bumped each time the preview changes, so a UI can redraw. */
+    revision: number;
+    /** True while the worker computes a preview. */
+    computing: boolean;
+    private dirty;
+    constructor(controller: ImageEditorController);
+    get settings(): SelectAndMaskSettings;
+    get edits(): readonly RefineEdit[];
+    /** Reads the image and makes the first preview. Resolves to false when the pixels are unavailable. */
+    open(): Promise<boolean>;
+    subscribe(listener: () => void): () => void;
+    private emit;
+    /** Preview size and the scale from natural pixels to it. */
+    get previewSize(): {
+        width: number;
+        height: number;
+        scale: number;
+    };
+    /** Changes settings; the preview follows. Choosing a view also sets its usual opacity. */
+    update(changes: Partial<SelectAndMaskSettings>): void;
+    private rescale;
+    /**
+     * Recomputes the preview mask from the base selection, the strokes and the settings: at once on
+     * the page, or in the worker, where one job runs at a time and the newest state follows it.
+     */
+    recompute(): void;
+    private recomputeInWorker;
+    /** Resolves once no preview is being computed (immediately without a worker). */
+    idle(): Promise<void>;
+    /** Coverage 0..1 of the preview at (x, y) in preview pixels (for tests and hover readouts). */
+    coverageAt(x: number, y: number): number;
+    /** The preview drawn in the current view mode: RGBA at {@link previewSize}. */
+    render(): Uint8ClampedArray;
+    /**
+     * 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: ImagePoint, modifiers?: {
+        altKey?: boolean;
+    }): boolean;
+    /** Pointer move while a stroke is down. */
+    move(point: ImagePoint): void;
+    /** Pointer up: the stroke becomes an edit (one step of the workspace's own undo). */
+    end(): void;
+    /** Removes the last stroke (Ctrl/⌘+Z in the workspace). Returns false when there is none. */
+    undoEdit(): boolean;
+    /** Clears the strokes and goes back to the default settings (Reset). */
+    reset(): void;
+    /**
+     * 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: string): boolean;
+    /**
+     * 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.
+     */
+    commit(): Promise<RefineOutputResult>;
+}
+/** Forgets the remembered workspace settings. */
+export declare function forgetSelectAndMaskSettings(): void;

package/dist/image-editor/selection/select-and-mask.d.ts

@@ -0,0 +1,136 @@
+/**
+ * The Select and Mask workspace without a UI: its settings, strokes, preview and view modes, shared
+ * by the React and Svelte workspaces. Everything it holds is plain data (the strokes are
+ * `RefineEdit`s), and OK runs the same `refineSelectionTo` call an agent makes with `edits`, so
+ * the workspace and an agent produce the same result in one undo step.
+ *
+ * The preview is computed on a copy reduced to {@link PREVIEW_SIZE} px (or at full size with High
+ * Quality Preview), in the controller's selection worker when it has one, and drawn as RGBA in
+ * the chosen view mode.
+ */
+import type { ImageEditorController, RefineOutput, RefineOutputResult } from '../controller.js';
+import type { ImagePoint } from '../types.js';
+import { type RefineEdgeParams } from './refine.js';
+import { type RefineEdit } from './refine-edits.js';
+export type SelectAndMaskView = 'onion-skin' | 'marching-ants' | 'overlay' | 'on-black' | 'on-white' | 'black-white' | 'on-layers';
+export type SelectAndMaskTool = 'quick-select' | 'refine-brush' | 'brush' | 'object' | 'lasso' | 'hand' | 'zoom';
+/** The view modes with Photoshop's keys, in menu order. */
+export declare const SELECT_AND_MASK_VIEWS: readonly {
+    id: SelectAndMaskView;
+    label: string;
+    key: string;
+    opacity: number;
+}[];
+/** The workspace tools with Photoshop's keys. */
+export declare const SELECT_AND_MASK_TOOLS: readonly {
+    id: SelectAndMaskTool;
+    label: string;
+    key: string;
+}[];
+export interface SelectAndMaskSettings {
+    params: Required<RefineEdgeParams>;
+    output: RefineOutput;
+    /** Decontaminate Colors amount 0..100 (new-layer outputs). */
+    decontaminate: number;
+    refineMode: 'color' | 'object';
+    view: SelectAndMaskView;
+    /** How strongly the view shows what is not selected, 0..1. */
+    opacity: number;
+    /** Show only the area the refinement changes. */
+    showEdge: boolean;
+    /** Show the selection as it was, before the workspace. */
+    showOriginal: boolean;
+    /** Update the preview while painting (otherwise on release). */
+    realTime: boolean;
+    /** Preview at full size instead of a reduced copy. */
+    highQuality: boolean;
+    /** Keep these settings for the next time the workspace opens. */
+    remember: boolean;
+    tool: SelectAndMaskTool;
+    /** Brush diameter in natural pixels. */
+    brushSize: number;
+    brushMode: 'add' | 'subtract';
+}
+export declare const DEFAULT_SELECT_AND_MASK_SETTINGS: SelectAndMaskSettings;
+/** Long side of the reduced preview. */
+export declare const PREVIEW_SIZE = 1024;
+export declare class SelectAndMaskSession {
+    readonly controller: ImageEditorController;
+    private settingsValue;
+    private readonly editsList;
+    /** The edit being painted, shown in the preview but not yet in `edits`. */
+    private live;
+    private dragStart;
+    private pixels;
+    private previewPixels;
+    private base;
+    private previewMask;
+    private baseMask;
+    private readonly listeners;
+    /** Why the preview could not be made (no pixels), for the UI. */
+    error: string | null;
+    /** A note for the UI, such as object aware refinement applying only on OK. */
+    note: string | null;
+    /** Bumped each time the preview changes, so a UI can redraw. */
+    revision: number;
+    /** True while the worker computes a preview. */
+    computing: boolean;
+    private dirty;
+    constructor(controller: ImageEditorController);
+    get settings(): SelectAndMaskSettings;
+    get edits(): readonly RefineEdit[];
+    /** Reads the image and makes the first preview. Resolves to false when the pixels are unavailable. */
+    open(): Promise<boolean>;
+    subscribe(listener: () => void): () => void;
+    private emit;
+    /** Preview size and the scale from natural pixels to it. */
+    get previewSize(): {
+        width: number;
+        height: number;
+        scale: number;
+    };
+    /** Changes settings; the preview follows. Choosing a view also sets its usual opacity. */
+    update(changes: Partial<SelectAndMaskSettings>): void;
+    private rescale;
+    /**
+     * Recomputes the preview mask from the base selection, the strokes and the settings: at once on
+     * the page, or in the worker, where one job runs at a time and the newest state follows it.
+     */
+    recompute(): void;
+    private recomputeInWorker;
+    /** Resolves once no preview is being computed (immediately without a worker). */
+    idle(): Promise<void>;
+    /** Coverage 0..1 of the preview at (x, y) in preview pixels (for tests and hover readouts). */
+    coverageAt(x: number, y: number): number;
+    /** The preview drawn in the current view mode: RGBA at {@link previewSize}. */
+    render(): Uint8ClampedArray;
+    /**
+     * 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: ImagePoint, modifiers?: {
+        altKey?: boolean;
+    }): boolean;
+    /** Pointer move while a stroke is down. */
+    move(point: ImagePoint): void;
+    /** Pointer up: the stroke becomes an edit (one step of the workspace's own undo). */
+    end(): void;
+    /** Removes the last stroke (Ctrl/⌘+Z in the workspace). Returns false when there is none. */
+    undoEdit(): boolean;
+    /** Clears the strokes and goes back to the default settings (Reset). */
+    reset(): void;
+    /**
+     * 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: string): boolean;
+    /**
+     * 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.
+     */
+    commit(): Promise<RefineOutputResult>;
+}
+/** Forgets the remembered workspace settings. */
+export declare function forgetSelectAndMaskSettings(): void;

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

@@ -0,0 +1,126 @@
+/**
+ * Running the long selections (Select Subject, Object Selection, Focus Area, Select Sky, Quick
+ * Selection strokes and the Select and Mask preview) off the page in a Web Worker, with progress
+ * and cancelling.
+ *
+ * - `runSelectionJob` does one job synchronously; the worker and the page's fallback both use it.
+ * - `startSelectionWorker` answers jobs inside a worker (the `selection-worker` entry calls it).
+ * - `SelectionWorkerClient` sends jobs from the page. The image is sent once per pixel buffer and
+ *   kept in the worker; masks travel as their bounds and bytes. Cancelling terminates the worker
+ *   (a running job can't be interrupted otherwise) and the next job starts a fresh one.
+ */
+import type { CropBox, ImagePoint } from '../types.cjs';
+import { type PixelBuffer, type SelectionMask } from './mask.cjs';
+import { type RefineEdgeParams } from './refine.cjs';
+import { type RefineEdit } from './refine-edits.cjs';
+import { type FocusAreaOptions } from './segment/focus.cjs';
+import { type ObjectTarget } from './segment/grabcut.cjs';
+import { type SkyOptions } from './segment/sky.cjs';
+import type { SelectionProgress } from './segment/work.cjs';
+/** A selection as plain data: its size, bounds and the bytes inside the bounds. */
+export interface SerializedMask {
+    width: number;
+    height: number;
+    bounds: CropBox | null;
+    bytes: Uint8Array;
+}
+export declare function serializeMask(mask: SelectionMask): SerializedMask;
+export declare function deserializeMask(s: SerializedMask): SelectionMask;
+/** One long selection, as data. */
+export type SelectionJob = {
+    op: 'subject';
+    enhanceEdge?: boolean;
+} | {
+    op: 'object';
+    target: ObjectTarget;
+    enhanceEdge?: boolean;
+} | {
+    op: 'focus';
+    options?: Omit<FocusAreaOptions, 'onProgress'>;
+} | {
+    op: 'sky';
+    options?: Omit<SkyOptions, 'onProgress'>;
+} | {
+    op: 'quick';
+    stroke: ImagePoint[];
+    size?: number;
+    grow?: boolean;
+    enhanceEdge?: boolean;
+    selection?: SerializedMask | null;
+} | {
+    op: 'refine-preview';
+    base: SerializedMask | null;
+    edits: RefineEdit[];
+    params: RefineEdgeParams;
+};
+/** What a job found: a selection of the whole image, and the job's notes. */
+export interface SelectionJobResult {
+    mask: SelectionMask;
+    /** Why nothing was selected (subject, sky). */
+    reason?: string;
+    /** Focus Area: the noise level it measured. */
+    noiseLevel?: number;
+}
+/** Runs `job` on `pixels` here and now. */
+export declare function runSelectionJob(job: SelectionJob, pixels: PixelBuffer, onProgress?: SelectionProgress): SelectionJobResult;
+/** Messages from the page to the worker. */
+export type SelectionWorkerRequest = {
+    type: 'pixels';
+    key: number;
+    pixels: PixelBuffer;
+} | {
+    type: 'job';
+    id: number;
+    key: number;
+    job: SelectionJob;
+};
+/** Messages from the worker to the page. */
+export type SelectionWorkerResponse = {
+    type: 'progress';
+    id: number;
+    fraction: number;
+    stage: string;
+} | {
+    type: 'done';
+    id: number;
+    mask: SerializedMask;
+    reason?: string;
+    noiseLevel?: number;
+} | {
+    type: 'error';
+    id: number;
+    message: string;
+};
+/**
+ * The part of a worker (or its global scope) the protocol uses; a DOM `Worker` is one. The event
+ * parameters are loose so a `Worker`'s `MessageEvent` / `ErrorEvent` handlers fit.
+ */
+export interface SelectionWorkerLike {
+    postMessage(message: unknown, transfer?: Transferable[]): void;
+    onmessage: ((event: any) => void) | null;
+    onerror?: ((event: any) => void) | null;
+    terminate?(): void;
+}
+/** Makes a fresh selection worker, e.g. `() => new SelectionWorker()` with Vite's `?worker`. */
+export type SelectionWorkerFactory = () => SelectionWorkerLike;
+/** Answers selection jobs inside a worker: `scope` is the worker's global (`self`). */
+export declare function startSelectionWorker(scope: SelectionWorkerLike): void;
+/** Sends selection jobs to a worker made by `factory`, one worker at a time. */
+export declare class SelectionWorkerClient {
+    private readonly factory;
+    private worker;
+    /** Pixel buffers this worker already has, by their data array. */
+    private sent;
+    private nextKey;
+    private nextId;
+    private readonly pending;
+    constructor(factory: SelectionWorkerFactory);
+    /** Runs `job` on `pixels` in the worker. Aborting `signal` terminates the worker and rejects with an `AbortError`. */
+    run(job: SelectionJob, pixels: PixelBuffer, options?: {
+        signal?: AbortSignal;
+        onProgress?: SelectionProgress;
+    }): Promise<SelectionJobResult>;
+    /** Stops the worker; jobs still running reject with `reason` (default an `AbortError`). */
+    terminate(reason?: unknown): void;
+    private ensure;
+}