zorya-classifier 0.2.1 → 0.2.2

package/dist/infrastructure/raster.js

@@ -1,13 +1,8 @@
 import sharp from 'sharp';
 import { z } from 'zod';
 import { limits, parse, pixelRectSchema } from '../entities/contracts.js';
+import { containsRect } from '../entities/geometry.js';
 import { ClassifierError, assertActive } from '../entities/errors.js';
-function contains(outer, inner) {
-    return (inner.left >= outer.left &&
-        inner.top >= outer.top &&
-        inner.left + inner.width <= outer.left + outer.width &&
-        inner.top + inner.height <= outer.top + outer.height);
-}
 async function normalizeImage(bytes, signal) {
     assertActive(signal);
     const pipeline = sharp(bytes, { limitInputPixels: limits.imagePixels, failOn: 'error' });
@@ -40,7 +35,7 @@ async function normalizeImage(bytes, signal) {
 }
 async function cropImage(image, region, signal, scale = 1) {
     assertActive(signal);
-    if (!contains({ left: 0, top: 0, width: image.width, height: image.height }, region))
+    if (!containsRect({ left: 0, top: 0, width: image.width, height: image.height }, region))
         throw new ClassifierError('INVALID_INPUT', 'ROI lies outside oriented source image');
     const pipeline = sharp(image.bytes, { limitInputPixels: limits.imagePixels })
         .extract(region)
@@ -198,7 +193,7 @@ export function createVisionRepresentation(raster) {
                         content: pixelRectSchema,
                     }),
                 }), json, 'INVALID_RESPONSE');
-                if (!contains({ left: 0, top: 0, ...transform.sourceImageTransform.output }, transform.sourceImageTransform.content))
+                if (!containsRect({ left: 0, top: 0, ...transform.sourceImageTransform.output }, transform.sourceImageTransform.content))
                     throw new ClassifierError('INVALID_RESPONSE', 'Vision raster content lies outside output');
                 metadata.views.push({
                     id: view.id,

package/dist/infrastructure/segmentation/grabcut/index.js

@@ -6,6 +6,7 @@ import { NativeChildPool } from '../native-child.js';
 import { nativeErrorReplySchema, nativeSegmentationReplySchema } from '../native-protocol.js';
 import { verifyPinnedAsset } from '../verify-asset.js';
 import { probeBackend } from '../probe-backend.js';
+import { grabcutOpenCvArtifact } from './model-asset.js';
 const optionsSchema = z.object({ assetPath: z.string().min(1).max(4096) }).strict();
 /**
  * Explicit pinned OpenCV GrabCut adapter. The supplied native asset is never downloaded.
@@ -16,10 +17,7 @@ export async function createGrabCutSegmenter(options) {
     if (!checked.success)
         throw new ClassifierError('INVALID_INPUT', 'Invalid GrabCut options');
     const parsed = checked.data;
-    await verifyPinnedAsset(parsed.assetPath, {
-        bytes: 10_964_323,
-        sha256: '63366510248adf3a7eddf3e793dd825404efb7df3749f4d6f8557c7fa4ca8aa0',
-    }, 'OpenCV.js');
+    await verifyPinnedAsset(parsed.assetPath, grabcutOpenCvArtifact, 'OpenCV.js');
     const workerUrl = new URL(import.meta.url.endsWith('.ts') ? '../native-worker.ts' : '../native-worker.js', import.meta.url);
     await probeBackend(workerUrl, 'grabcut', { assetPath: parsed.assetPath });
     const pool = new NativeChildPool({

package/dist/infrastructure/segmentation/grabcut/masks.d.ts

@@ -0,0 +1,49 @@
+import type { NativeSegmentationRequest } from '../native-protocol.js';
+export declare function getBytes(mat: {
+    data?: unknown;
+}, length: number): Uint8Array;
+export declare function initializeGrabCutMask(input: {
+    flags: Uint8Array;
+    width: number;
+    height: number;
+    seedRegion: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    wholeRegion: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    roi: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    prompt: 'whole-region' | 'seed-region';
+    labels: {
+        background: number;
+        foreground: number;
+        probableBackground: number;
+        probableForeground: number;
+    };
+}): void;
+/** Run native GrabCut, then reacquire Mat.data before copying its post-call flags. */
+export declare function runGrabCutAndCopyMask(mat: {
+    data?: unknown;
+}, width: number, height: number, roi: {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}, runNative: () => void, labels: {
+    foreground: number;
+    probableForeground: number;
+}): Uint8Array;
+export declare function seededComponents(mask: Uint8Array, width: number, height: number, input: NativeSegmentationRequest & {
+    kind: 'grabcut';
+}): Uint8Array;

package/dist/infrastructure/segmentation/grabcut/masks.js

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+export function getBytes(mat, length) {
+    const bytes = z.instanceof(Uint8Array).parse(mat.data);
+    if (bytes.length !== length)
+        throw new Error('OpenCV matrix dimensions do not match');
+    return bytes;
+}
+export function initializeGrabCutMask(input) {
+    if (input.flags.length !== input.width * input.height)
+        throw new Error('GrabCut mask dimensions do not match source');
+    input.flags.fill(input.labels.background);
+    if (input.prompt === 'whole-region') {
+        for (let y = input.wholeRegion.top; y < input.wholeRegion.top + input.wholeRegion.height; y++)
+            for (let x = input.wholeRegion.left; x < input.wholeRegion.left + input.wholeRegion.width; x++)
+                input.flags[y * input.width + x] = input.labels.probableForeground;
+    }
+    else {
+        for (let y = input.roi.top; y < input.roi.top + input.roi.height; y++)
+            for (let x = input.roi.left; x < input.roi.left + input.roi.width; x++)
+                input.flags[y * input.width + x] = input.labels.probableBackground;
+    }
+    const seedLeft = Math.max(input.seedRegion.left, input.roi.left);
+    const seedTop = Math.max(input.seedRegion.top, input.roi.top);
+    const seedRight = Math.min(input.seedRegion.left + input.seedRegion.width, input.roi.left + input.roi.width);
+    const seedBottom = Math.min(input.seedRegion.top + input.seedRegion.height, input.roi.top + input.roi.height);
+    if (seedLeft >= seedRight || seedTop >= seedBottom)
+        throw new Error('GrabCut seed region does not intersect hard ROI');
+    for (let y = seedTop; y < seedBottom; y++)
+        for (let x = seedLeft; x < seedRight; x++)
+            input.flags[y * input.width + x] = input.labels.foreground;
+}
+/** Run native GrabCut, then reacquire Mat.data before copying its post-call flags. */
+export function runGrabCutAndCopyMask(mat, width, height, roi, runNative, labels) {
+    runNative();
+    const flags = getBytes(mat, width * height);
+    const output = new Uint8Array(width * height);
+    for (let y = roi.top; y < roi.top + roi.height; y++) {
+        for (let x = roi.left; x < roi.left + roi.width; x++) {
+            const at = y * width + x;
+            const flag = flags[at];
+            if (flag === labels.foreground || flag === labels.probableForeground)
+                output[at] = 1;
+        }
+    }
+    return output;
+}
+export function seededComponents(mask, width, height, input) {
+    const visited = new Uint8Array(mask.length);
+    const output = new Uint8Array(mask.length);
+    const stack = [];
+    for (let start = 0; start < mask.length; start++) {
+        if (mask[start] !== 1 || visited[start] === 1)
+            continue;
+        stack.push(start);
+        visited[start] = 1;
+        const component = [];
+        let hitsSeed = false;
+        while (stack.length) {
+            const at = stack.pop();
+            if (at === undefined)
+                continue;
+            component.push(at);
+            const x = at % width;
+            const y = Math.floor(at / width);
+            if (x >= input.seedRegion.left &&
+                y >= input.seedRegion.top &&
+                x < input.seedRegion.left + input.seedRegion.width &&
+                y < input.seedRegion.top + input.seedRegion.height)
+                hitsSeed = true;
+            const neighbors = [at - 1, at + 1, at - width, at + width];
+            for (const neighbor of neighbors) {
+                if (neighbor < 0 ||
+                    neighbor >= mask.length ||
+                    visited[neighbor] === 1 ||
+                    mask[neighbor] !== 1)
+                    continue;
+                const nx = neighbor % width;
+                if (Math.abs(nx - x) + Math.abs(Math.floor(neighbor / width) - y) !== 1)
+                    continue;
+                visited[neighbor] = 1;
+                stack.push(neighbor);
+            }
+        }
+        if (hitsSeed)
+            for (const index of component)
+                output[index] = 1;
+    }
+    return output;
+}

package/dist/infrastructure/segmentation/grabcut/model-asset.d.ts

@@ -0,0 +1,4 @@
+export declare const grabcutOpenCvArtifact: Readonly<{
+    readonly bytes: 10964323;
+    readonly sha256: "63366510248adf3a7eddf3e793dd825404efb7df3749f4d6f8557c7fa4ca8aa0";
+}>;

package/dist/infrastructure/segmentation/grabcut/model-asset.js

@@ -0,0 +1,4 @@
+export const grabcutOpenCvArtifact = Object.freeze({
+    bytes: 10_964_323,
+    sha256: '63366510248adf3a7eddf3e793dd825404efb7df3749f4d6f8557c7fa4ca8aa0',
+});

package/dist/infrastructure/segmentation/grabcut/runtime.d.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+declare const cvSchema: z.ZodObject<{
+    Mat: z.ZodType<(...args: unknown[]) => unknown, z.ZodTypeDef, (...args: unknown[]) => unknown>;
+    Rect: z.ZodType<(...args: unknown[]) => unknown, z.ZodTypeDef, (...args: unknown[]) => unknown>;
+    cvtColor: z.ZodType<(...args: unknown[]) => unknown, z.ZodTypeDef, (...args: unknown[]) => unknown>;
+    grabCut: z.ZodType<(...args: unknown[]) => unknown, z.ZodTypeDef, (...args: unknown[]) => unknown>;
+    COLOR_RGBA2RGB: z.ZodNumber;
+    CV_8UC4: z.ZodNumber;
+    CV_8UC3: z.ZodNumber;
+    CV_8UC1: z.ZodNumber;
+    GC_BGD: z.ZodNumber;
+    GC_FGD: z.ZodNumber;
+    GC_PR_BGD: z.ZodNumber;
+    GC_PR_FGD: z.ZodNumber;
+    GC_INIT_WITH_MASK: z.ZodNumber;
+    GC_INIT_WITH_RECT: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    Mat: (...args: unknown[]) => unknown;
+    Rect: (...args: unknown[]) => unknown;
+    cvtColor: (...args: unknown[]) => unknown;
+    grabCut: (...args: unknown[]) => unknown;
+    COLOR_RGBA2RGB: number;
+    CV_8UC4: number;
+    CV_8UC3: number;
+    CV_8UC1: number;
+    GC_BGD: number;
+    GC_FGD: number;
+    GC_PR_BGD: number;
+    GC_PR_FGD: number;
+    GC_INIT_WITH_MASK: number;
+    GC_INIT_WITH_RECT: number;
+}, {
+    Mat: (...args: unknown[]) => unknown;
+    Rect: (...args: unknown[]) => unknown;
+    cvtColor: (...args: unknown[]) => unknown;
+    grabCut: (...args: unknown[]) => unknown;
+    COLOR_RGBA2RGB: number;
+    CV_8UC4: number;
+    CV_8UC3: number;
+    CV_8UC1: number;
+    GC_BGD: number;
+    GC_FGD: number;
+    GC_PR_BGD: number;
+    GC_PR_FGD: number;
+    GC_INIT_WITH_MASK: number;
+    GC_INIT_WITH_RECT: number;
+}>;
+export declare function loadOpenCv(path: string): Promise<{
+    Mat: (...args: unknown[]) => unknown;
+    Rect: (...args: unknown[]) => unknown;
+    cvtColor: (...args: unknown[]) => unknown;
+    grabCut: (...args: unknown[]) => unknown;
+    COLOR_RGBA2RGB: number;
+    CV_8UC4: number;
+    CV_8UC3: number;
+    CV_8UC1: number;
+    GC_BGD: number;
+    GC_FGD: number;
+    GC_PR_BGD: number;
+    GC_PR_FGD: number;
+    GC_INIT_WITH_MASK: number;
+    GC_INIT_WITH_RECT: number;
+}>;
+export declare function probeGrabCut(assetPath: string): Promise<void>;
+interface CvMat {
+    data?: unknown;
+    delete(): void;
+}
+export declare function matrix(cv: z.infer<typeof cvSchema>, args?: number[]): CvMat;
+export {};

package/dist/infrastructure/segmentation/grabcut/runtime.js

@@ -0,0 +1,96 @@
+import { createHash } from 'node:crypto';
+import { open } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { dirname, resolve } from 'node:path';
+import { Script } from 'node:vm';
+import { z } from 'zod';
+import { grabcutOpenCvArtifact } from './model-asset.js';
+const cvSchema = z.object({
+    Mat: z.custom((value) => typeof value === 'function'),
+    Rect: z.custom((value) => typeof value === 'function'),
+    cvtColor: z.custom((value) => typeof value === 'function'),
+    grabCut: z.custom((value) => typeof value === 'function'),
+    COLOR_RGBA2RGB: z.number().int(),
+    CV_8UC4: z.number().int(),
+    CV_8UC3: z.number().int(),
+    CV_8UC1: z.number().int(),
+    GC_BGD: z.number().int(),
+    GC_FGD: z.number().int(),
+    GC_PR_BGD: z.number().int(),
+    GC_PR_FGD: z.number().int(),
+    GC_INIT_WITH_MASK: z.number().int(),
+    GC_INIT_WITH_RECT: z.number().int(),
+});
+async function readVerifiedAsset(path) {
+    const handle = await open(path, 'r');
+    try {
+        const stat = await handle.stat();
+        if (!stat.isFile() || stat.size !== grabcutOpenCvArtifact.bytes)
+            throw new Error('Pinned OpenCV size mismatch');
+        const source = Buffer.alloc(grabcutOpenCvArtifact.bytes);
+        let offset = 0;
+        while (offset < source.length) {
+            const read = await handle.read(source, offset, source.length - offset, null);
+            if (!read.bytesRead)
+                throw new Error('Pinned OpenCV asset read was incomplete');
+            offset += read.bytesRead;
+        }
+        if ((await handle.read(Buffer.alloc(1), 0, 1, null)).bytesRead !== 0)
+            throw new Error('Pinned OpenCV asset changed while being read');
+        if (createHash('sha256').update(source).digest('hex') !== grabcutOpenCvArtifact.sha256)
+            throw new Error('Pinned OpenCV SHA256 mismatch');
+        return source.toString('utf8');
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function loadOpenCv(path) {
+    path = resolve(path);
+    const source = await readVerifiedAsset(path);
+    const wrapper = { exports: {} };
+    const factory = new Script('(function(exports,require,module,__filename,__dirname){' + source + '\n})', { filename: path }).runInThisContext();
+    if (typeof factory !== 'function')
+        throw new Error('Pinned OpenCV asset is not a module');
+    Reflect.apply(factory, undefined, [
+        wrapper.exports,
+        createRequire(path),
+        wrapper,
+        path,
+        dirname(path),
+    ]);
+    const exports = wrapper.exports;
+    if (typeof exports === 'object' && exports !== null && 'then' in exports) {
+        const then = Reflect.get(exports, 'then');
+        if (typeof then === 'function') {
+            return await new Promise((resolve, reject) => {
+                try {
+                    Reflect.apply(then, exports, [
+                        (value) => {
+                            const checked = cvSchema.safeParse(value);
+                            if (checked.success)
+                                resolve(checked.data);
+                            else
+                                reject(new Error('Pinned OpenCV namespace is invalid'));
+                        },
+                        reject,
+                    ]);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+    }
+    return cvSchema.parse(exports);
+}
+export async function probeGrabCut(assetPath) {
+    await loadOpenCv(assetPath);
+}
+const matShapeSchema = z
+    .object({ delete: z.custom((value) => typeof value === 'function') })
+    .passthrough();
+const matSchema = z.custom((value) => matShapeSchema.safeParse(value).success);
+export function matrix(cv, args = []) {
+    return matSchema.parse(Reflect.construct(cv.Mat, args));
+}

package/dist/infrastructure/segmentation/grabcut/worker-inference.d.ts

@@ -1,47 +1,8 @@
 import type { NativeSegmentationReply, NativeSegmentationRequest } from '../native-protocol.js';
-export declare function probeGrabCut(assetPath: string): Promise<void>;
-export declare function initializeGrabCutMask(input: {
-    flags: Uint8Array;
-    width: number;
-    height: number;
-    seedRegion: {
-        left: number;
-        top: number;
-        width: number;
-        height: number;
-    };
-    wholeRegion: {
-        left: number;
-        top: number;
-        width: number;
-        height: number;
-    };
-    roi: {
-        left: number;
-        top: number;
-        width: number;
-        height: number;
-    };
-    prompt: 'whole-region' | 'seed-region';
-    labels: {
-        background: number;
-        foreground: number;
-        probableBackground: number;
-        probableForeground: number;
-    };
-}): void;
-/** Run native GrabCut, then reacquire Mat.data before copying its post-call flags. */
-export declare function runGrabCutAndCopyMask(mat: {
-    data?: unknown;
-}, width: number, height: number, roi: {
-    left: number;
-    top: number;
-    width: number;
-    height: number;
-}, runNative: () => void, labels: {
-    foreground: number;
-    probableForeground: number;
-}): Uint8Array;
+import { initializeGrabCutMask, runGrabCutAndCopyMask } from './masks.js';
+import { probeGrabCut } from './runtime.js';
+export { initializeGrabCutMask, runGrabCutAndCopyMask };
+export { probeGrabCut };
 export declare function runGrabCutTask(request: Extract<NativeSegmentationRequest, {
     kind: 'grabcut';
 }>): Promise<NativeSegmentationReply>;

package/dist/infrastructure/segmentation/grabcut/worker-inference.js

@@ -1,190 +1,7 @@
-import { createHash } from 'node:crypto';
-import { open } from 'node:fs/promises';
-import { createRequire } from 'node:module';
-import { dirname, resolve } from 'node:path';
-import { Script } from 'node:vm';
-import { z } from 'zod';
-const artifact = {
-    bytes: 10_964_323,
-    sha256: '63366510248adf3a7eddf3e793dd825404efb7df3749f4d6f8557c7fa4ca8aa0',
-};
-const cvSchema = z.object({
-    Mat: z.custom((value) => typeof value === 'function'),
-    Rect: z.custom((value) => typeof value === 'function'),
-    cvtColor: z.custom((value) => typeof value === 'function'),
-    grabCut: z.custom((value) => typeof value === 'function'),
-    COLOR_RGBA2RGB: z.number().int(),
-    CV_8UC4: z.number().int(),
-    CV_8UC3: z.number().int(),
-    CV_8UC1: z.number().int(),
-    GC_BGD: z.number().int(),
-    GC_FGD: z.number().int(),
-    GC_PR_BGD: z.number().int(),
-    GC_PR_FGD: z.number().int(),
-    GC_INIT_WITH_MASK: z.number().int(),
-    GC_INIT_WITH_RECT: z.number().int(),
-});
-async function readVerifiedAsset(path) {
-    const handle = await open(path, 'r');
-    try {
-        const stat = await handle.stat();
-        if (!stat.isFile() || stat.size !== artifact.bytes)
-            throw new Error('Pinned OpenCV size mismatch');
-        const source = Buffer.alloc(artifact.bytes);
-        let offset = 0;
-        while (offset < source.length) {
-            const read = await handle.read(source, offset, source.length - offset, null);
-            if (!read.bytesRead)
-                throw new Error('Pinned OpenCV asset read was incomplete');
-            offset += read.bytesRead;
-        }
-        if ((await handle.read(Buffer.alloc(1), 0, 1, null)).bytesRead !== 0)
-            throw new Error('Pinned OpenCV asset changed while being read');
-        if (createHash('sha256').update(source).digest('hex') !== artifact.sha256)
-            throw new Error('Pinned OpenCV SHA256 mismatch');
-        return source.toString('utf8');
-    }
-    finally {
-        await handle.close();
-    }
-}
-async function loadOpenCv(path) {
-    path = resolve(path);
-    const source = await readVerifiedAsset(path);
-    const wrapper = { exports: {} };
-    const factory = new Script('(function(exports,require,module,__filename,__dirname){' + source + '\n})', { filename: path }).runInThisContext();
-    if (typeof factory !== 'function')
-        throw new Error('Pinned OpenCV asset is not a module');
-    Reflect.apply(factory, undefined, [
-        wrapper.exports,
-        createRequire(path),
-        wrapper,
-        path,
-        dirname(path),
-    ]);
-    const exports = wrapper.exports;
-    if (typeof exports === 'object' && exports !== null && 'then' in exports) {
-        const then = Reflect.get(exports, 'then');
-        if (typeof then === 'function') {
-            return await new Promise((resolve, reject) => {
-                try {
-                    Reflect.apply(then, exports, [
-                        (value) => {
-                            const checked = cvSchema.safeParse(value);
-                            if (checked.success)
-                                resolve(checked.data);
-                            else
-                                reject(new Error('Pinned OpenCV namespace is invalid'));
-                        },
-                        reject,
-                    ]);
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-        }
-    }
-    return cvSchema.parse(exports);
-}
-export async function probeGrabCut(assetPath) {
-    await loadOpenCv(assetPath);
-}
-const matShapeSchema = z
-    .object({ delete: z.custom((value) => typeof value === 'function') })
-    .passthrough();
-const matSchema = z.custom((value) => matShapeSchema.safeParse(value).success);
-function matrix(cv, args = []) {
-    return matSchema.parse(Reflect.construct(cv.Mat, args));
-}
-function getBytes(mat, length) {
-    const bytes = z.instanceof(Uint8Array).parse(mat.data);
-    if (bytes.length !== length)
-        throw new Error('OpenCV matrix dimensions do not match');
-    return bytes;
-}
-export function initializeGrabCutMask(input) {
-    if (input.flags.length !== input.width * input.height)
-        throw new Error('GrabCut mask dimensions do not match source');
-    input.flags.fill(input.labels.background);
-    if (input.prompt === 'whole-region') {
-        for (let y = input.wholeRegion.top; y < input.wholeRegion.top + input.wholeRegion.height; y++)
-            for (let x = input.wholeRegion.left; x < input.wholeRegion.left + input.wholeRegion.width; x++)
-                input.flags[y * input.width + x] = input.labels.probableForeground;
-    }
-    else {
-        for (let y = input.roi.top; y < input.roi.top + input.roi.height; y++)
-            for (let x = input.roi.left; x < input.roi.left + input.roi.width; x++)
-                input.flags[y * input.width + x] = input.labels.probableBackground;
-    }
-    const seedLeft = Math.max(input.seedRegion.left, input.roi.left);
-    const seedTop = Math.max(input.seedRegion.top, input.roi.top);
-    const seedRight = Math.min(input.seedRegion.left + input.seedRegion.width, input.roi.left + input.roi.width);
-    const seedBottom = Math.min(input.seedRegion.top + input.seedRegion.height, input.roi.top + input.roi.height);
-    if (seedLeft >= seedRight || seedTop >= seedBottom)
-        throw new Error('GrabCut seed region does not intersect hard ROI');
-    for (let y = seedTop; y < seedBottom; y++)
-        for (let x = seedLeft; x < seedRight; x++)
-            input.flags[y * input.width + x] = input.labels.foreground;
-}
-/** Run native GrabCut, then reacquire Mat.data before copying its post-call flags. */
-export function runGrabCutAndCopyMask(mat, width, height, roi, runNative, labels) {
-    runNative();
-    const flags = getBytes(mat, width * height);
-    const output = new Uint8Array(width * height);
-    for (let y = roi.top; y < roi.top + roi.height; y++) {
-        for (let x = roi.left; x < roi.left + roi.width; x++) {
-            const at = y * width + x;
-            const flag = flags[at];
-            if (flag === labels.foreground || flag === labels.probableForeground)
-                output[at] = 1;
-        }
-    }
-    return output;
-}
-function seededComponents(mask, width, height, input) {
-    const visited = new Uint8Array(mask.length);
-    const output = new Uint8Array(mask.length);
-    const stack = [];
-    for (let start = 0; start < mask.length; start++) {
-        if (mask[start] !== 1 || visited[start] === 1)
-            continue;
-        stack.push(start);
-        visited[start] = 1;
-        const component = [];
-        let hitsSeed = false;
-        while (stack.length) {
-            const at = stack.pop();
-            if (at === undefined)
-                continue;
-            component.push(at);
-            const x = at % width;
-            const y = Math.floor(at / width);
-            if (x >= input.seedRegion.left &&
-                y >= input.seedRegion.top &&
-                x < input.seedRegion.left + input.seedRegion.width &&
-                y < input.seedRegion.top + input.seedRegion.height)
-                hitsSeed = true;
-            const neighbors = [at - 1, at + 1, at - width, at + width];
-            for (const neighbor of neighbors) {
-                if (neighbor < 0 ||
-                    neighbor >= mask.length ||
-                    visited[neighbor] === 1 ||
-                    mask[neighbor] !== 1)
-                    continue;
-                const nx = neighbor % width;
-                if (Math.abs(nx - x) + Math.abs(Math.floor(neighbor / width) - y) !== 1)
-                    continue;
-                visited[neighbor] = 1;
-                stack.push(neighbor);
-            }
-        }
-        if (hitsSeed)
-            for (const index of component)
-                output[index] = 1;
-    }
-    return output;
-}
+import { getBytes, initializeGrabCutMask, runGrabCutAndCopyMask, seededComponents, } from './masks.js';
+import { loadOpenCv, matrix, probeGrabCut } from './runtime.js';
+export { initializeGrabCutMask, runGrabCutAndCopyMask };
+export { probeGrabCut };
 export async function runGrabCutTask(request) {
     const cv = await loadOpenCv(request.assetPath);
     const pixels = request.width * request.height;