zorya-classifier 0.1.0 → 0.2.0

package/dist/infrastructure/segmentation/box-presentation.js

@@ -0,0 +1,136 @@
+import sharp from 'sharp';
+import { z } from 'zod';
+import { limits, pixelRectSchema } from '../../entities/contracts.js';
+import { ClassifierError, assertActive } from '../../entities/errors.js';
+const rasterSchema = z
+    .object({
+    data: z.instanceof(Uint8Array),
+    width: z.number().int().positive().max(16384),
+    height: z.number().int().positive().max(16384),
+    format: z.literal('rgba8'),
+})
+    .strict();
+const inputSchema = z
+    .object({
+    image: rasterSchema,
+    region: pixelRectSchema,
+    seedRegion: pixelRectSchema,
+    roi: pixelRectSchema,
+    target: z.string().trim().min(1).max(2000),
+    exclusions: z.array(z.string().trim().min(1).max(500)).max(16),
+    signal: z.custom((value) => value instanceof AbortSignal),
+})
+    .strict();
+function inside(rect, width, height) {
+    return rect.left + rect.width <= width && rect.top + rect.height <= height;
+}
+function overlaps(first, second) {
+    return (first.left < second.left + second.width &&
+        second.left < first.left + first.width &&
+        first.top < second.top + second.height &&
+        second.top < first.top + first.height);
+}
+function cloneRect(rect) {
+    return { left: rect.left, top: rect.top, width: rect.width, height: rect.height };
+}
+function snapshot(value) {
+    const parsed = inputSchema.safeParse(value);
+    if (!parsed.success)
+        throw new ClassifierError('INVALID_INPUT', 'Invalid segmentation box presentation input', {
+            paths: parsed.error.issues.map((issue) => issue.path.join('.')),
+        });
+    const input = parsed.data;
+    const pixels = input.image.width * input.image.height;
+    if (!Number.isSafeInteger(pixels) ||
+        pixels < 1 ||
+        pixels > limits.imagePixels ||
+        input.image.data.byteLength !== pixels * 4 ||
+        !inside(input.region, input.image.width, input.image.height) ||
+        !inside(input.seedRegion, input.image.width, input.image.height) ||
+        !inside(input.roi, input.image.width, input.image.height) ||
+        input.region.left < input.roi.left ||
+        input.region.top < input.roi.top ||
+        input.region.left + input.region.width > input.roi.left + input.roi.width ||
+        input.region.top + input.region.height > input.roi.top + input.roi.height ||
+        !overlaps(input.seedRegion, input.region) ||
+        !overlaps(input.seedRegion, input.roi))
+        throw new ClassifierError('INVALID_INPUT', 'Box, seed, image, and hard ROI geometry disagree');
+    const image = {
+        data: Uint8Array.from(input.image.data),
+        width: input.image.width,
+        height: input.image.height,
+        format: 'rgba8',
+    };
+    return {
+        image,
+        region: cloneRect(input.region),
+        seedRegion: cloneRect(input.seedRegion),
+        roi: cloneRect(input.roi),
+        target: input.target,
+        exclusions: [...input.exclusions],
+        signal: input.signal,
+    };
+}
+function overlaySvg(input) {
+    const { image, region, seedRegion, roi } = input;
+    const boxStroke = Math.min(3, region.width, region.height);
+    const x = region.left + boxStroke / 2;
+    const y = region.top + boxStroke / 2;
+    const w = Math.max(0, region.width - boxStroke);
+    const h = Math.max(0, region.height - boxStroke);
+    const roiStroke = Math.min(2, roi.width, roi.height);
+    const roiX = roi.left + roiStroke / 2;
+    const roiY = roi.top + roiStroke / 2;
+    const roiW = Math.max(0, roi.width - roiStroke);
+    const roiH = Math.max(0, roi.height - roiStroke);
+    // Use the same pixel-center convention as the native seed point: (size - 1) / 2.
+    const cx = seedRegion.left + (seedRegion.width - 1) / 2;
+    const cy = seedRegion.top + (seedRegion.height - 1) / 2;
+    const seedSize = Math.min(seedRegion.width, seedRegion.height);
+    const crossArm = Math.min(5, Math.max(0.5, (seedSize - 1) / 2));
+    const crossStroke = Math.min(2, Math.max(1, seedSize));
+    return Buffer.from(`<svg xmlns="http://www.w3.org/2000/svg" width="${image.width}" height="${image.height}"><rect x="${x}" y="${y}" width="${w}" height="${h}" fill="none" stroke="#ff00ff" stroke-width="${boxStroke}"/><rect x="${roiX}" y="${roiY}" width="${roiW}" height="${roiH}" fill="none" stroke="#ffbf00" stroke-width="${roiStroke}" stroke-dasharray="7 5"/><path d="M ${cx - crossArm} ${cy} H ${cx + crossArm} M ${cx} ${cy - crossArm} V ${cy + crossArm}" fill="none" stroke="#00ffff" stroke-width="${crossStroke}"/></svg>`);
+}
+export function createSharpSegmentationBoxPresentation() {
+    return {
+        async render(value) {
+            const input = snapshot(value);
+            const owned = input.image.data;
+            let pipeline;
+            const abort = () => pipeline?.destroy();
+            let listenerAdded = false;
+            try {
+                assertActive(input.signal);
+                pipeline = sharp(owned, {
+                    raw: { width: input.image.width, height: input.image.height, channels: 4 },
+                    limitInputPixels: limits.imagePixels,
+                    failOn: 'error',
+                })
+                    .composite([{ input: overlaySvg(input) }])
+                    .png({ compressionLevel: 6 });
+                input.signal.addEventListener('abort', abort, { once: true });
+                listenerAdded = true;
+                const { data, info } = await pipeline.toBuffer({ resolveWithObject: true });
+                assertActive(input.signal);
+                if (info.width !== input.image.width ||
+                    info.height !== input.image.height ||
+                    data.byteLength < 1 ||
+                    data.byteLength > limits.imageBytes)
+                    throw new ClassifierError('RESOURCE_LIMIT', 'Rendered box presentation exceeds image limits');
+                return { bytes: Uint8Array.from(data), width: info.width, height: info.height };
+            }
+            catch (error) {
+                assertActive(input.signal);
+                if (error instanceof ClassifierError)
+                    throw error;
+                throw new ClassifierError('PROVIDER', 'Box presentation renderer failed');
+            }
+            finally {
+                if (listenerAdded)
+                    input.signal.removeEventListener('abort', abort);
+                pipeline?.destroy();
+                owned.fill(0);
+            }
+        },
+    };
+}

package/dist/infrastructure/segmentation/cutout-raster.d.ts

@@ -0,0 +1,3 @@
+import type { CutoutRasterPort } from '../../entities/cutout-raster.js';
+/** Sharp-backed decoder/encoder isolated behind the extraction raster port. */
+export declare function createSharpCutoutRaster(): CutoutRasterPort;

package/dist/infrastructure/segmentation/cutout-raster.js

@@ -0,0 +1,79 @@
+import sharp from 'sharp';
+import { ClassifierError, assertActive } from '../../entities/errors.js';
+const maxPixels = 16_777_216;
+/** Sharp-backed decoder/encoder isolated behind the extraction raster port. */
+export function createSharpCutoutRaster() {
+    return {
+        async rgba(image, signal) {
+            assertActive(signal);
+            validateRasterImage(image);
+            const pipeline = sharp(image.bytes, { limitInputPixels: maxPixels, failOn: 'error' });
+            try {
+                const output = await pipeline
+                    .toColourspace('srgb')
+                    .ensureAlpha()
+                    .raw()
+                    .toBuffer({ resolveWithObject: true });
+                assertActive(signal);
+                if (output.info.width !== image.width ||
+                    output.info.height !== image.height ||
+                    output.info.channels !== 4 ||
+                    output.data.length !== image.width * image.height * 4)
+                    throw new ClassifierError('INVALID_RESPONSE', 'Cutout raster decoder returned invalid canonical RGBA pixels');
+                return {
+                    data: new Uint8Array(output.data),
+                    width: image.width,
+                    height: image.height,
+                    format: 'rgba8',
+                };
+            }
+            catch (error) {
+                if (error instanceof ClassifierError)
+                    throw error;
+                throw new ClassifierError('INVALID_RESPONSE', 'Cutout raster decoder failed');
+            }
+            finally {
+                pipeline.destroy();
+            }
+        },
+        async png(image, signal) {
+            assertActive(signal);
+            validateRgbaRaster(image);
+            const pipeline = sharp(image.data, {
+                raw: { width: image.width, height: image.height, channels: 4 },
+            });
+            try {
+                const png = await pipeline.png().toBuffer();
+                assertActive(signal);
+                return new Uint8Array(png);
+            }
+            catch (error) {
+                if (error instanceof ClassifierError)
+                    throw error;
+                throw new ClassifierError('PROVIDER', 'Cutout PNG encoder failed');
+            }
+            finally {
+                pipeline.destroy();
+            }
+        },
+    };
+}
+function validateRasterImage(image) {
+    if (!Number.isSafeInteger(image.width) ||
+        !Number.isSafeInteger(image.height) ||
+        image.width < 1 ||
+        image.height < 1 ||
+        image.width * image.height > maxPixels ||
+        image.bytes.byteLength < 1)
+        throw new ClassifierError('INVALID_RESPONSE', 'Raster normalizer returned invalid source data');
+}
+function validateRgbaRaster(image) {
+    if (image.format !== 'rgba8' ||
+        !Number.isSafeInteger(image.width) ||
+        !Number.isSafeInteger(image.height) ||
+        image.width < 1 ||
+        image.height < 1 ||
+        image.width * image.height > maxPixels ||
+        image.data.length !== image.width * image.height * 4)
+        throw new ClassifierError('INVALID_RESPONSE', 'Extraction returned invalid canonical RGBA pixels');
+}

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

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import type { SegmentationPort } from '../../../entities/segmentation.js';
+declare const optionsSchema: z.ZodObject<{
+    assetPath: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    assetPath: string;
+}, {
+    assetPath: string;
+}>;
+export type GrabCutSegmenterOptions = z.input<typeof optionsSchema>;
+/** Explicit pinned OpenCV GrabCut adapter. The supplied native asset is never downloaded. */
+export declare function createGrabCutSegmenter(options: GrabCutSegmenterOptions): Promise<SegmentationPort>;
+export {};

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

@@ -0,0 +1,118 @@
+import { performance } from 'node:perf_hooks';
+import { ClassifierError, assertActive } from '../../../entities/errors.js';
+import { z } from 'zod';
+import { limits, pixelRectSchema } from '../../../entities/contracts.js';
+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';
+const optionsSchema = z.object({ assetPath: z.string().min(1).max(4096) }).strict();
+/** Explicit pinned OpenCV GrabCut adapter. The supplied native asset is never downloaded. */
+export async function createGrabCutSegmenter(options) {
+    const checked = optionsSchema.safeParse(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');
+    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({
+        workerUrl,
+        maxActive: 1,
+        maxWaiting: 2,
+        jobTimeoutMs: 10_000,
+        abortGraceMs: 250,
+        encode: (job) => Buffer.from(JSON.stringify({ id: job.id, ...job.payload })),
+        decode: (raw, id) => {
+            const error = nativeErrorReplySchema.safeParse(raw);
+            if (error.success) {
+                if (error.data.id !== id)
+                    throw new ClassifierError('INVALID_RESPONSE', 'Native child error ID mismatch');
+                throw new ClassifierError(error.data.code, error.data.message);
+            }
+            const reply = nativeSegmentationReplySchema.safeParse(raw);
+            if (!reply.success || reply.data.id !== id)
+                throw new ClassifierError('INVALID_RESPONSE', 'Native child returned an invalid or mismatched reply');
+            return reply.data;
+        },
+    });
+    return {
+        async segment(input) {
+            const started = performance.now();
+            assertActive(input.signal);
+            let image;
+            const raw = await pool.runLazy(input.signal, () => {
+                image = snapshotInput(input);
+                return {
+                    kind: 'grabcut',
+                    width: image.width,
+                    height: image.height,
+                    rgba: Buffer.from(image.data).toString('base64'),
+                    seedRegion: image.seedRegion,
+                    wholeRegion: image.wholeRegion,
+                    roi: image.roi,
+                    prompt: image.prompt,
+                    assetPath: parsed.assetPath,
+                };
+            });
+            const reply = nativeSegmentationReplySchema.parse(raw);
+            const mask = Buffer.from(reply.mask, 'base64');
+            if (reply.width !== image.width ||
+                reply.height !== image.height ||
+                mask.length !== image.width * image.height ||
+                mask.toString('base64') !== reply.mask)
+                throw new ClassifierError('INVALID_RESPONSE', 'Native child mask dimensions or encoding are invalid');
+            return {
+                status: 'segmented',
+                mask: {
+                    data: new Uint8Array(mask),
+                    width: image.width,
+                    height: image.height,
+                    format: 'binary-u8',
+                },
+                metadata: {
+                    method: reply.method,
+                    backend: 'grabcut',
+                    durationMs: Math.max(0, performance.now() - started),
+                    input: { width: image.width, height: image.height },
+                },
+            };
+        },
+        settle: () => pool.settle(),
+        dispose: () => pool.dispose(),
+    };
+}
+function snapshotInput(input) {
+    const image = input.image;
+    const pixels = image.width * image.height;
+    const prompt = input.prompt ?? 'whole-region';
+    if (image.format !== 'rgba8' ||
+        !Number.isSafeInteger(image.width) ||
+        !Number.isSafeInteger(image.height) ||
+        !Number.isSafeInteger(pixels) ||
+        image.width < 1 ||
+        image.height < 1 ||
+        pixels > limits.imagePixels ||
+        image.data.length !== pixels * 4)
+        throw new ClassifierError('INVALID_INPUT', 'Segmentation requires canonical RGBA8 within the image pixel limit');
+    if ((prompt !== 'whole-region' && prompt !== 'seed-region') ||
+        !pixelRectSchema.safeParse(input.seedRegion).success ||
+        !pixelRectSchema.safeParse(input.wholeRegion).success ||
+        !pixelRectSchema.safeParse(input.roi).success)
+        throw new ClassifierError('INVALID_INPUT', 'Segmentation regions must be positive integer rectangles');
+    for (const region of [input.seedRegion, input.wholeRegion, input.roi])
+        if (region.left + region.width > image.width || region.top + region.height > image.height)
+            throw new ClassifierError('INVALID_INPUT', 'Segmentation region lies outside the source image');
+    return {
+        data: new Uint8Array(image.data),
+        width: image.width,
+        height: image.height,
+        seedRegion: { ...input.seedRegion },
+        wholeRegion: { ...input.wholeRegion },
+        roi: { ...input.roi },
+        prompt,
+    };
+}

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

@@ -0,0 +1,47 @@
+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;
+export declare function runGrabCutTask(request: Extract<NativeSegmentationRequest, {
+    kind: 'grabcut';
+}>): Promise<NativeSegmentationReply>;

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

@@ -0,0 +1,260 @@
+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;
+}
+export async function runGrabCutTask(request) {
+    const cv = await loadOpenCv(request.assetPath);
+    const pixels = request.width * request.height;
+    const rgbaBytes = Buffer.from(request.rgba, 'base64');
+    if (rgbaBytes.length !== pixels * 4)
+        throw new Error('Invalid GrabCut RGBA bytes');
+    const rgba = matrix(cv, [request.height, request.width, cv.CV_8UC4]);
+    const rgb = matrix(cv);
+    const mask = matrix(cv, [request.height, request.width, cv.CV_8UC1]);
+    const background = matrix(cv);
+    const foreground = matrix(cv);
+    const owned = [rgba, rgb, mask, background, foreground];
+    let result;
+    let releaseFailed = false;
+    try {
+        getBytes(rgba, pixels * 4).set(rgbaBytes);
+        Reflect.apply(cv.cvtColor, cv, [rgba, rgb, cv.COLOR_RGBA2RGB]);
+        const flags = getBytes(mask, pixels);
+        initializeGrabCutMask({
+            flags,
+            width: request.width,
+            height: request.height,
+            seedRegion: request.seedRegion,
+            wholeRegion: request.wholeRegion,
+            roi: request.roi,
+            prompt: request.prompt,
+            labels: {
+                background: cv.GC_BGD,
+                foreground: cv.GC_FGD,
+                probableBackground: cv.GC_PR_BGD,
+                probableForeground: cv.GC_PR_FGD,
+            },
+        });
+        const rect = Reflect.construct(cv.Rect, [0, 0, 0, 0]);
+        const maskResult = runGrabCutAndCopyMask(mask, request.width, request.height, request.roi, () => Reflect.apply(cv.grabCut, cv, [
+            rgb,
+            mask,
+            rect,
+            background,
+            foreground,
+            3,
+            cv.GC_INIT_WITH_MASK,
+        ]), { foreground: cv.GC_FGD, probableForeground: cv.GC_PR_FGD });
+        const grounded = seededComponents(maskResult, request.width, request.height, request);
+        if (!grounded.some((value) => value === 1))
+            throw new Error('GrabCut produced no seed-grounded mask');
+        result = {
+            id: request.id,
+            status: 'segmented',
+            width: request.width,
+            height: request.height,
+            mask: Buffer.from(grounded).toString('base64'),
+            method: request.prompt === 'seed-region' ? 'grabcut-seed-mask-v1' : 'grabcut-seeded-box-v1',
+        };
+    }
+    finally {
+        let failed = false;
+        for (const item of owned.reverse()) {
+            try {
+                item.delete();
+            }
+            catch {
+                failed = true;
+            }
+        }
+        releaseFailed = failed;
+    }
+    if (releaseFailed)
+        throw new Error('OpenCV matrices could not all be released');
+    if (!result)
+        throw new Error('GrabCut completed without a mask result');
+    return result;
+}

package/dist/infrastructure/segmentation/index.d.ts

@@ -0,0 +1,2 @@
+export { createMobileSamSegmenter } from './mobile-sam/index.js';
+export { createGrabCutSegmenter } from './grabcut/index.js';

package/dist/infrastructure/segmentation/index.js

@@ -0,0 +1,2 @@
+export { createMobileSamSegmenter } from './mobile-sam/index.js';
+export { createGrabCutSegmenter } from './grabcut/index.js';