@pixerate/editor 0.207.0 → 0.208.0

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

@@ -16,3 +16,4 @@ 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

@@ -16,3 +16,4 @@ 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/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

@@ -5,7 +5,8 @@
  * 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) and drawn as RGBA in the chosen view mode.
+ * 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';
@@ -72,6 +73,9 @@ export declare class SelectAndMaskSession {
     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[];
@@ -88,8 +92,14 @@ export declare class SelectAndMaskSession {
     /** 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. */
+    /**
+     * 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}. */

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

@@ -5,7 +5,8 @@
  * 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) and drawn as RGBA in the chosen view mode.
+ * 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';
@@ -72,6 +73,9 @@ export declare class SelectAndMaskSession {
     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[];
@@ -88,8 +92,14 @@ export declare class SelectAndMaskSession {
     /** 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. */
+    /**
+     * 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}. */

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;
+}

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

@@ -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.js';
+import { type PixelBuffer, type SelectionMask } from './mask.js';
+import { type RefineEdgeParams } from './refine.js';
+import { type RefineEdit } from './refine-edits.js';
+import { type FocusAreaOptions } from './segment/focus.js';
+import { type ObjectTarget } from './segment/grabcut.js';
+import { type SkyOptions } from './segment/sky.js';
+import type { SelectionProgress } from './segment/work.js';
+/** 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;
+}

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

@@ -0,0 +1,14 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkX4LUGTQXcjs = require('../chunk-X4LUGTQX.cjs');
+require('../chunk-QYLWG22N.cjs');
+require('../chunk-K6PXS6DO.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);
+}
+
+
+exports.startSelectionWorker = _chunkX4LUGTQXcjs.startSelectionWorker;

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

@@ -0,0 +1,12 @@
+/**
+ * The selection worker's entry: load it as a module worker and give the controller a factory, e.g.
+ * with Vite
+ *
+ *   import SelectionWorker from '@pixerate/editor/image-editor/selection-worker?worker';
+ *   controller.setSelectionWorker(() => new SelectionWorker());
+ *
+ * Outside a worker (Node, a page importing it by mistake) it does nothing. It also exports
+ * `startSelectionWorker`, for a host that writes its own worker file.
+ */
+import { startSelectionWorker } from './selection/worker.cjs';
+export { startSelectionWorker };

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

@@ -0,0 +1,12 @@
+/**
+ * The selection worker's entry: load it as a module worker and give the controller a factory, e.g.
+ * with Vite
+ *
+ *   import SelectionWorker from '@pixerate/editor/image-editor/selection-worker?worker';
+ *   controller.setSelectionWorker(() => new SelectionWorker());
+ *
+ * Outside a worker (Node, a page importing it by mistake) it does nothing. It also exports
+ * `startSelectionWorker`, for a host that writes its own worker file.
+ */
+import { startSelectionWorker } from './selection/worker.js';
+export { startSelectionWorker };

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

@@ -0,0 +1,14 @@
+import {
+  startSelectionWorker
+} from "../chunk-DWYQPL2A.js";
+import "../chunk-L3G23N5Y.js";
+import "../chunk-ZIF4UJJ6.js";
+import "../chunk-HVVR5PZW.js";
+
+// src/image-editor/selection-worker.ts
+if (typeof self !== "undefined" && typeof window === "undefined" && typeof self.postMessage === "function") {
+  startSelectionWorker(self);
+}
+export {
+  startSelectionWorker
+};

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

@@ -1,3 +1,4 @@
+import type { SelectionWorkerFactory } from './selection/worker.cjs';
 import type { GlobalLight } from '../raster/effects/model.cjs';
 import type { EffectPattern } from '../raster/effects/patterns.cjs';
 import type { BlendMode } from './blend.cjs';
@@ -448,6 +449,13 @@ export interface ImageEditorOptions {
      * `setSegmentationProvider`.
      */
     segmentation?: SegmentationProvider | null;
+    /**
+     * Makes the Web Worker the long selections run in (Select Subject, Object Selection, Focus
+     * Area, Select Sky, Quick Selection, the Select and Mask preview), e.g. with Vite
+     * `() => new SelectionWorker()` from `@pixerate/editor/image-editor/selection-worker?worker`.
+     * Without one they run on the page. Change it later with `setSelectionWorker`.
+     */
+    selectionWorker?: SelectionWorkerFactory | null;
 }
 export interface InpaintOptions {
     prompt: string;

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

@@ -1,3 +1,4 @@
+import type { SelectionWorkerFactory } from './selection/worker.js';
 import type { GlobalLight } from '../raster/effects/model.js';
 import type { EffectPattern } from '../raster/effects/patterns.js';
 import type { BlendMode } from './blend.js';
@@ -448,6 +449,13 @@ export interface ImageEditorOptions {
      * `setSegmentationProvider`.
      */
     segmentation?: SegmentationProvider | null;
+    /**
+     * Makes the Web Worker the long selections run in (Select Subject, Object Selection, Focus
+     * Area, Select Sky, Quick Selection, the Select and Mask preview), e.g. with Vite
+     * `() => new SelectionWorker()` from `@pixerate/editor/image-editor/selection-worker?worker`.
+     * Without one they run on the page. Change it later with `setSelectionWorker`.
+     */
+    selectionWorker?: SelectionWorkerFactory | null;
 }
 export interface InpaintOptions {
     prompt: string;