zorya-classifier 0.2.1 → 0.2.3

package/dist/infrastructure/{openrouter-common.d.ts → decision-transport/request.d.ts}

@@ -1,6 +1,4 @@
 import { z } from 'zod';
-import { ClassifierError } from '../entities/errors.js';
-import type { ErrorCode } from '../entities/errors.js';
 export declare const requestLimit: number;
 export declare const responseLimit: number;
 export declare const probability: z.ZodNumber;
@@ -19,29 +17,29 @@ export declare const requestSchema: z.ZodObject<{
             detail: "high";
         }>;
     }, "strict", z.ZodTypeAny, {
-        type: "image_url";
         image_url: {
             url: string;
             detail: "high";
         };
-    }, {
         type: "image_url";
+    }, {
         image_url: {
             url: string;
             detail: "high";
         };
-    }>]>, "many">, (string | {
         type: "image_url";
+    }>]>, "many">, (string | {
         image_url: {
             url: string;
             detail: "high";
         };
-    })[], (string | {
         type: "image_url";
+    })[], (string | {
         image_url: {
             url: string;
             detail: "high";
         };
+        type: "image_url";
     })[]>;
     questions: z.ZodEffects<z.ZodRecord<z.ZodEffects<z.ZodString, string, string>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         type: z.ZodLiteral<"choice">;
@@ -86,11 +84,11 @@ export declare const requestSchema: z.ZodObject<{
     }>>;
 }, "strict", z.ZodTypeAny, {
     state: (string | {
-        type: "image_url";
         image_url: {
             url: string;
             detail: "high";
         };
+        type: "image_url";
     })[];
     questions: Record<string, {
         type: "choice";
@@ -103,11 +101,11 @@ export declare const requestSchema: z.ZodObject<{
     }>;
 }, {
     state: (string | {
-        type: "image_url";
         image_url: {
             url: string;
             detail: "high";
         };
+        type: "image_url";
     })[];
     questions: Record<string, {
         type: "choice";
@@ -119,12 +117,5 @@ export declare const requestSchema: z.ZodObject<{
         instructions: string;
     }>;
 }>;
-export declare function ownedError(code: ErrorCode, message: string, details?: Readonly<Record<string, unknown>>): ClassifierError;
-export declare function invalid(code: 'INVALID_INPUT' | 'INVALID_RESPONSE', message: string): ClassifierError;
-export declare function active(signal: AbortSignal): void;
-export declare function validated<T>(schema: z.ZodType<T, z.ZodTypeDef, unknown>, input: unknown, code: 'INVALID_INPUT' | 'INVALID_RESPONSE'): T;
-export declare function validateImage(url: string): void;
 /** Bounded owned snapshot; schema parsing never receives caller iterators or accessors. */
 export declare function preflightJson(input: unknown, limit: number): unknown;
-export declare function failure(error: unknown, signal: AbortSignal, cleanupFailed?: boolean): ClassifierError;
-export declare function readResponse(response: Response, signal: AbortSignal, limit: number): Promise<string>;

package/dist/infrastructure/decision-transport/request.js

@@ -0,0 +1,162 @@
+import { isProxy } from 'node:util/types';
+import { z } from 'zod';
+import { invalid, ownedError } from './errors.js';
+export const requestLimit = 32 * 1024 * 1024;
+export const responseLimit = 1024 * 1024;
+export const probability = z.number().finite().min(0).max(1);
+export const key = z
+    .string()
+    .min(1)
+    .max(128)
+    .refine((value) => value !== '__proto__');
+const text = z.string().min(1).max(64_000);
+const imageSchema = z
+    .object({
+    type: z.literal('image_url'),
+    image_url: z.object({ url: z.string().max(22_369_656), detail: z.literal('high') }).strict(),
+})
+    .strict();
+const questionSchema = z.discriminatedUnion('type', [
+    z
+        .object({
+        type: z.literal('choice'),
+        rankingSize: z.union([z.literal(1), z.literal(4)]).default(4),
+        instructions: text,
+        criteria: z
+            .record(key, text)
+            .refine((value) => Object.keys(value).length >= 2 && Object.keys(value).length <= 255),
+    })
+        .strict(),
+    z.object({ type: z.literal('noul'), instructions: text }).strict(),
+]);
+export const requestSchema = z
+    .object({
+    state: z
+        .array(z.union([text, imageSchema]))
+        .min(1)
+        .max(64)
+        .refine((value) => value.filter((part) => typeof part !== 'string').length <= 9),
+    questions: z
+        .record(key, questionSchema)
+        .refine((value) => Object.keys(value).length >= 1 && Object.keys(value).length <= 16),
+})
+    .strict();
+/** Bounded owned snapshot; schema parsing never receives caller iterators or accessors. */
+export function preflightJson(input, limit) {
+    let remaining = limit;
+    let nodes = 0;
+    const ancestors = new Set();
+    function charge(bytes) {
+        remaining -= bytes;
+        if (remaining < 0)
+            throw ownedError('RESOURCE_LIMIT', 'Decision request exceeds byte limit');
+    }
+    function string(value) {
+        charge(2);
+        for (let index = 0; index < value.length; index++) {
+            const code = value.charCodeAt(index);
+            if (code < 32)
+                charge([8, 9, 10, 12, 13].includes(code) ? 2 : 6);
+            else if (code === 34 || code === 92)
+                charge(2);
+            else if (code < 128)
+                charge(1);
+            else if (code < 2048)
+                charge(2);
+            else if (code >= 0xd800 && code <= 0xdbff) {
+                const next = value.charCodeAt(index + 1);
+                if (next >= 0xdc00 && next <= 0xdfff) {
+                    charge(4);
+                    index++;
+                }
+                else
+                    charge(6);
+            }
+            else
+                charge(code >= 0xdc00 && code <= 0xdfff ? 6 : 3);
+        }
+    }
+    function visit(value, depth) {
+        if (++nodes > 10_000 || depth > 6)
+            throw invalid('INVALID_INPUT', 'Decision structure exceeds supported limits');
+        if (typeof value === 'string') {
+            string(value);
+            return value;
+        }
+        if (value === null || typeof value === 'boolean') {
+            charge(value === false ? 5 : 4);
+            return value;
+        }
+        if (typeof value === 'number' && Number.isFinite(value)) {
+            charge(String(value).length);
+            return value;
+        }
+        if (typeof value !== 'object' || value === null)
+            throw invalid('INVALID_INPUT', 'Unsupported decision value');
+        if (isProxy(value))
+            throw invalid('INVALID_INPUT', 'Decision input must contain plain values');
+        // Zod reads declared object fields even when they are not enumerable; JSON does not.
+        for (const name of [
+            'state',
+            'questions',
+            'type',
+            'image_url',
+            'url',
+            'detail',
+            'instructions',
+            'criteria',
+        ]) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, name);
+            if (descriptor && !descriptor.enumerable)
+                throw invalid('INVALID_INPUT', 'Decision fields must be enumerable');
+        }
+        if (ancestors.has(value))
+            throw invalid('INVALID_INPUT', 'Circular decision structure');
+        ancestors.add(value);
+        charge(2);
+        if (Array.isArray(value)) {
+            const copy = [];
+            if (value.length > 64)
+                throw invalid('INVALID_INPUT', 'Decision array exceeds supported limits');
+            for (let index = 0; index < value.length; index++) {
+                if (index)
+                    charge(1);
+                const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+                if (!descriptor || !Object.hasOwn(descriptor, 'value'))
+                    throw invalid('INVALID_INPUT', 'Decision input must contain plain values');
+                copy.push(visit(descriptor.value, depth + 1));
+            }
+            ancestors.delete(value);
+            return copy;
+        }
+        else {
+            const copy = {};
+            const prototype = Object.getPrototypeOf(value);
+            if (prototype !== Object.prototype && prototype !== null)
+                throw invalid('INVALID_INPUT', 'Decision input must contain plain objects');
+            let count = 0;
+            for (const name in value) {
+                if (!Object.hasOwn(value, name))
+                    continue;
+                if (++count > 255)
+                    throw invalid('INVALID_INPUT', 'Decision object exceeds supported limits');
+                if (count > 1)
+                    charge(1);
+                string(name);
+                charge(1);
+                const descriptor = Object.getOwnPropertyDescriptor(value, name);
+                if (!descriptor || !Object.hasOwn(descriptor, 'value'))
+                    throw invalid('INVALID_INPUT', 'Decision input must contain plain values');
+                Object.defineProperty(copy, name, {
+                    value: visit(descriptor.value, depth + 1),
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                });
+            }
+            ancestors.delete(value);
+            return copy;
+        }
+    }
+    return visit(input, 0);
+}

package/dist/infrastructure/decision-transport/response.d.ts

@@ -0,0 +1 @@
+export declare function readResponse(response: Response, signal: AbortSignal, limit: number): Promise<string>;

package/dist/infrastructure/decision-transport/response.js

@@ -0,0 +1,72 @@
+import { active, failure, invalid, ownedError } from './errors.js';
+function statusError(status) {
+    const code = status === 401 || status === 403
+        ? 'AUTHENTICATION'
+        : status === 413
+            ? 'RESOURCE_LIMIT'
+            : status === 415
+                ? 'UNSUPPORTED'
+                : 'PROVIDER';
+    return ownedError(code, 'Model provider rejected the request', { status });
+}
+export async function readResponse(response, signal, limit) {
+    const reader = response.body?.getReader();
+    if (!reader) {
+        active(signal);
+        if (!response.ok)
+            throw statusError(response.status);
+        throw invalid('INVALID_RESPONSE', 'Provider response has no body');
+    }
+    let cancelTask;
+    function cancel() {
+        cancelTask ??= reader.cancel().then(() => true, () => false);
+    }
+    signal.addEventListener('abort', cancel, { once: true });
+    let caught;
+    let output = '';
+    let complete = false;
+    try {
+        active(signal);
+        if (!response.ok)
+            throw statusError(response.status);
+        const length = response.headers.get('content-length');
+        if (length !== null && (!/^\d+$/u.test(length) || Number(length) > limit))
+            throw ownedError('RESOURCE_LIMIT', 'Provider response exceeds byte limit');
+        const storage = Buffer.allocUnsafe(limit);
+        let bytes = 0;
+        while (true) {
+            active(signal);
+            const next = await reader.read();
+            active(signal);
+            if (next.done)
+                break;
+            if (next.value.byteLength > limit - bytes)
+                throw ownedError('RESOURCE_LIMIT', 'Provider response exceeds byte limit');
+            storage.set(next.value, bytes);
+            bytes += next.value.byteLength;
+        }
+        complete = true;
+        try {
+            output = new TextDecoder('utf-8', { fatal: true }).decode(storage.subarray(0, bytes));
+        }
+        catch {
+            throw invalid('INVALID_RESPONSE', 'Provider returned invalid UTF-8');
+        }
+    }
+    catch (error) {
+        caught = error;
+    }
+    finally {
+        signal.removeEventListener('abort', cancel);
+        if (!complete)
+            cancel();
+        const released = cancelTask ? await cancelTask : true;
+        reader.releaseLock();
+        if (!released)
+            caught = failure(caught, signal, true);
+    }
+    if (caught !== undefined)
+        throw failure(caught, signal);
+    active(signal);
+    return output;
+}

package/dist/infrastructure/decision-transport/route-identity.d.ts

@@ -0,0 +1,11 @@
+interface ResponseModelIdentity {
+    model: string;
+    responseModelIds?: readonly string[] | undefined;
+}
+export declare function acceptsResponseModel(value: string, identity: ResponseModelIdentity): boolean;
+interface PinnedProviderIdentity {
+    provider?: string | undefined;
+    providerName?: string | undefined;
+}
+export declare function unexpectedResponseProvider(envelopeProvider: string | null | undefined, pinned: PinnedProviderIdentity): boolean;
+export {};

package/dist/infrastructure/decision-transport/route-identity.js

@@ -0,0 +1,23 @@
+function routeName(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]/gu, '');
+}
+export function acceptsResponseModel(value, identity) {
+    if (value === identity.model || identity.responseModelIds?.includes(value))
+        return true;
+    if (!value.startsWith(identity.model + '-'))
+        return false;
+    const suffix = value.slice(identity.model.length + 1);
+    if (!/^\d{4}-?\d{2}-?\d{2}$/u.test(suffix))
+        return false;
+    const digits = suffix.replaceAll('-', ''), date = `${digits.slice(0, 4)}-${digits.slice(4, 6)}-${digits.slice(6, 8)}`;
+    const parsed = new Date(date + 'T00:00:00.000Z');
+    return Number.isFinite(parsed.valueOf()) && parsed.toISOString().slice(0, 10) === date;
+}
+export function unexpectedResponseProvider(envelopeProvider, pinned) {
+    if (!envelopeProvider)
+        return false;
+    const expected = pinned.providerName ?? pinned.provider;
+    if (expected === undefined)
+        return false;
+    return routeName(envelopeProvider) !== routeName(expected);
+}

package/dist/infrastructure/openrouter-vision.js

@@ -1,5 +1,5 @@
 import { createVisionChat, visionOptionsSchema } from './vision-chat.js';
-import { validated } from './openrouter-common.js';
+import { validated } from './decision-transport/errors.js';
 import { z } from 'zod';
 const schema = visionOptionsSchema
     .omit({ endpoint: true, headers: true })

package/dist/infrastructure/openrouter.js

@@ -1,7 +1,11 @@
 import { z } from 'zod';
 import { ClassifierError } from '../entities/errors.js';
 import { acceptsChoiceMass } from '../shared/choice-mass.js';
-import { active, validated, ownedError, invalid, preflightJson, requestSchema, validateImage, failure, readResponse, requestLimit, responseLimit, probability, key, } from './openrouter-common.js';
+import { active, failure, invalid, ownedError, validated } from './decision-transport/errors.js';
+import { validateImage } from './decision-transport/images.js';
+import { key, preflightJson, probability, requestLimit, requestSchema, responseLimit, } from './decision-transport/request.js';
+import { readResponse } from './decision-transport/response.js';
+import { acceptsResponseModel, unexpectedResponseProvider, } from './decision-transport/route-identity.js';
 const endpoint = 'https://openrouter.ai/api/alpha/decisions';
 const responseSchema = z
     .object({
@@ -59,9 +63,6 @@ const optionsSchema = legacyOptionsSchema
     probabilityRoundingStep: z.literal(0.01).optional(),
 })
     .strict();
-function routeName(value) {
-    return value.toLowerCase().replace(/[^a-z0-9]/gu, '');
-}
 function serialize(input, maxBytes, options) {
     const envelope = {
         model: options.model,
@@ -83,18 +84,6 @@ function serialize(input, maxBytes, options) {
             validateImage(part.image_url.url);
     return { request, body };
 }
-function acceptedModel(value, options) {
-    if (value === options.model || options.responseModelIds?.includes(value))
-        return true;
-    if (!value.startsWith(options.model + '-'))
-        return false;
-    const suffix = value.slice(options.model.length + 1);
-    if (!/^\d{4}-?\d{2}-?\d{2}$/u.test(suffix))
-        return false;
-    const digits = suffix.replaceAll('-', ''), date = `${digits.slice(0, 4)}-${digits.slice(4, 6)}-${digits.slice(6, 8)}`;
-    const parsed = new Date(date + 'T00:00:00.000Z');
-    return Number.isFinite(parsed.valueOf()) && parsed.toISOString().slice(0, 10) === date;
-}
 function result(raw, request, response, durationMs, options) {
     let json;
     try {
@@ -104,10 +93,9 @@ function result(raw, request, response, durationMs, options) {
         throw invalid('INVALID_RESPONSE', 'Provider returned invalid JSON');
     }
     const value = validated(responseSchema, json, 'INVALID_RESPONSE');
-    if (value.model && !acceptedModel(value.model, options))
+    if (value.model && !acceptsResponseModel(value.model, options))
         throw invalid('INVALID_RESPONSE', 'Provider returned an unexpected model');
-    if (value.provider &&
-        routeName(value.provider) !== routeName(options.providerName ?? options.provider))
+    if (value.provider && unexpectedResponseProvider(value.provider, options))
         throw invalid('INVALID_RESPONSE', 'Provider returned an unexpected route');
     const questionIds = Object.keys(request.questions);
     if (Object.keys(value.answers).length !== questionIds.length)

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.d.ts

@@ -7,11 +7,11 @@ declare const optionsSchema: z.ZodObject<{
 }, {
     assetPath: string;
 }>;
-/** @experimental Options for the unqualified GrabCut segmentation factory. */
+/** Options for the GrabCut segmentation factory (caller-supplied pinned assets). */
 export type GrabCutSegmenterOptions = z.input<typeof optionsSchema>;
 /**
  * Explicit pinned OpenCV GrabCut adapter. The supplied native asset is never downloaded.
- * @experimental Native segmentation adapter; unqualified for general mask or object accuracy.
+ * Structural validation does not establish semantic mask or object quality.
  */
 export declare function createGrabCutSegmenter(options: GrabCutSegmenterOptions): Promise<SegmentationPort>;
 export {};

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

@@ -6,20 +6,18 @@ 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.
- * @experimental Native segmentation adapter; unqualified for general mask or object accuracy.
+ * Structural validation does not establish semantic mask or object quality.
  */
 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');
+    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',
+});