zorya-classifier 0.1.0 → 0.2.0

package/dist/infrastructure/segmentation/native-protocol.js

@@ -0,0 +1,242 @@
+import { z } from 'zod';
+import { pixelRectSchema } from '../../entities/contracts.js';
+/** Validate canonical RFC 4648 base64 without a large repeated-group RegExp. */
+function isCanonicalBase64(value) {
+    if (value.length % 4 !== 0)
+        return false;
+    if (value.length === 0)
+        return true;
+    const alphabet = (code) => {
+        if (code >= 65 && code <= 90)
+            return code - 65;
+        if (code >= 97 && code <= 122)
+            return code - 97 + 26;
+        if (code >= 48 && code <= 57)
+            return code - 48 + 52;
+        if (code === 43)
+            return 62;
+        if (code === 47)
+            return 63;
+        return -1;
+    };
+    const length = value.length;
+    const padding = value.charCodeAt(length - 1) === 61 ? (value.charCodeAt(length - 2) === 61 ? 2 : 1) : 0;
+    const contentEnd = length - padding;
+    for (let index = 0; index < contentEnd; index++)
+        if (alphabet(value.charCodeAt(index)) < 0)
+            return false;
+    for (let index = contentEnd; index < length; index++)
+        if (value.charCodeAt(index) !== 61)
+            return false;
+    // Padding must encode zero bits so there is exactly one spelling per byte sequence.
+    if (padding === 2)
+        return (alphabet(value.charCodeAt(length - 3)) & 15) === 0;
+    if (padding === 1)
+        return (alphabet(value.charCodeAt(length - 2)) & 3) === 0;
+    return true;
+}
+function base64Schema(maxLength) {
+    return z
+        .string()
+        .max(maxLength)
+        .refine((value) => value.length <= maxLength && isCanonicalBase64(value));
+}
+const modelOptionsSchema = z
+    .object({
+    encoderPath: z.string().min(1).max(4096),
+    decoderPath: z.string().min(1).max(4096),
+    executionProvider: z.enum(['cpu', 'dml']),
+    deviceId: z.number().int().min(0).max(32).optional(),
+    threads: z.number().int().min(1).max(8).default(2),
+})
+    .strict();
+const mobileSamProbeSchema = z
+    .object({
+    id: z.string().uuid(),
+    kind: z.literal('probe-mobile-sam'),
+    options: modelOptionsSchema,
+})
+    .strict();
+const grabCutProbeSchema = z
+    .object({
+    id: z.string().uuid(),
+    kind: z.literal('probe-grabcut'),
+    assetPath: z.string().min(1).max(4096),
+})
+    .strict();
+const mobileSamRequestSchema = z
+    .object({
+    id: z.string().uuid(),
+    kind: z.literal('mobile-sam'),
+    width: z.number().int().positive().max(16384),
+    height: z.number().int().positive().max(16384),
+    rgba: base64Schema(90_000_000),
+    seedRegion: pixelRectSchema,
+    wholeRegion: pixelRectSchema,
+    roi: pixelRectSchema,
+    prompt: z.enum(['whole-region', 'seed-region']).default('whole-region'),
+    options: modelOptionsSchema,
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.width * value.height > 16_777_216)
+        context.addIssue({ code: 'custom', message: 'Image exceeds segmentation pixel limit' });
+    for (const region of [value.seedRegion, value.wholeRegion, value.roi])
+        if (region.left + region.width > value.width || region.top + region.height > value.height)
+            context.addIssue({ code: 'custom', message: 'Segmentation region is outside the source' });
+});
+const mobileSamExpandRequestSchema = z
+    .object({
+    id: z.string().uuid(),
+    kind: z.literal('mobile-sam-expand'),
+    width: z.number().int().positive().max(16384),
+    height: z.number().int().positive().max(16384),
+    rgba: base64Schema(90_000_000),
+    previousMask: base64Schema(2_796_204),
+    seedRegion: pixelRectSchema,
+    wholeRegion: pixelRectSchema,
+    roi: pixelRectSchema,
+    prompt: z.enum(['whole-region', 'seed-region']).default('whole-region'),
+    options: modelOptionsSchema,
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.width * value.height > 16_777_216)
+        context.addIssue({ code: 'custom', message: 'Image exceeds segmentation pixel limit' });
+    const expectedMaskBytes = Math.ceil((value.width * value.height) / 8);
+    const padding = value.previousMask.endsWith('==') ? 2 : value.previousMask.endsWith('=') ? 1 : 0;
+    const decodedMaskBytes = (value.previousMask.length / 4) * 3 - padding;
+    if (decodedMaskBytes !== expectedMaskBytes)
+        context.addIssue({
+            code: 'custom',
+            message: 'Previous mask length does not match dimensions',
+        });
+    for (const region of [value.seedRegion, value.wholeRegion, value.roi])
+        if (region.left + region.width > value.width || region.top + region.height > value.height)
+            context.addIssue({ code: 'custom', message: 'Segmentation region is outside the source' });
+});
+// Proposal replies are deliberately packed before IPC; 36 full-resolution byte masks
+// would exceed the native child stdout budget by a wide margin.
+const mobileSamProposalsRequestSchema = z
+    .object({
+    id: z.string().uuid(),
+    kind: z.literal('mobile-sam-proposals'),
+    width: z.number().int().positive().max(16384),
+    height: z.number().int().positive().max(16384),
+    rgba: base64Schema(11_200_000),
+    seedRegion: pixelRectSchema,
+    roi: pixelRectSchema,
+    options: modelOptionsSchema.extend({ executionProvider: z.literal('cpu') }),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.width * value.height > 2_097_152)
+        context.addIssue({ code: 'custom', message: 'Image exceeds proposal pixel limit' });
+    for (const region of [value.seedRegion, value.roi])
+        if (region.left + region.width > value.width || region.top + region.height > value.height)
+            context.addIssue({ code: 'custom', message: 'Proposal region is outside the source' });
+});
+const grabCutRequestSchema = z
+    .object({
+    id: z.string().uuid(),
+    kind: z.literal('grabcut'),
+    width: z.number().int().positive().max(16384),
+    height: z.number().int().positive().max(16384),
+    rgba: base64Schema(90_000_000),
+    seedRegion: pixelRectSchema,
+    wholeRegion: pixelRectSchema,
+    roi: pixelRectSchema,
+    prompt: z.enum(['whole-region', 'seed-region']).default('whole-region'),
+    assetPath: z.string().min(1).max(4096),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.width * value.height > 16_777_216)
+        context.addIssue({ code: 'custom', message: 'Image exceeds segmentation pixel limit' });
+    for (const region of [value.seedRegion, value.wholeRegion, value.roi])
+        if (region.left + region.width > value.width || region.top + region.height > value.height)
+            context.addIssue({ code: 'custom', message: 'Segmentation region is outside the source' });
+});
+export const nativeSegmentationRequestSchema = z.union([
+    mobileSamProbeSchema,
+    grabCutProbeSchema,
+    mobileSamProposalsRequestSchema,
+    mobileSamRequestSchema,
+    mobileSamExpandRequestSchema,
+    grabCutRequestSchema,
+]);
+export const nativeSegmentationReplySchema = z
+    .object({
+    id: z.string().uuid(),
+    status: z.literal('segmented'),
+    width: z.number().int().positive(),
+    height: z.number().int().positive(),
+    mask: base64Schema(32_000_000),
+    method: z.string().min(1).max(128),
+})
+    .strict();
+export const nativeMobileSamExpansionReplySchema = z.discriminatedUnion('status', [
+    z
+        .object({
+        id: z.string().uuid(),
+        status: z.literal('expanded'),
+        width: z.number().int().positive().max(16384),
+        height: z.number().int().positive().max(16384),
+        mask: base64Schema(2_796_204),
+        method: z.literal('mobile-sam-enclosing-mask-v1'),
+        qualityScore: z.number().finite(),
+    })
+        .strict(),
+    z
+        .object({
+        id: z.string().uuid(),
+        status: z.literal('unknown'),
+        reason: z.literal('no-enclosing-mask'),
+        width: z.number().int().positive().max(16384),
+        height: z.number().int().positive().max(16384),
+        method: z.literal('mobile-sam-enclosing-mask-v1'),
+    })
+        .strict(),
+]);
+export const nativeObjectProposalReplySchema = z
+    .object({
+    id: z.string().uuid(),
+    status: z.literal('proposals'),
+    width: z.number().int().positive().max(16384),
+    height: z.number().int().positive().max(16384),
+    proposals: z
+        .array(z
+        .object({
+        id: z.string().regex(/^C(?:0[0-9]|1[0-9]|2[0-9]|3[0-5])$/),
+        mask: base64Schema(349_528),
+        qualityScore: z.number().finite(),
+    })
+        .strict())
+        .length(36),
+})
+    .strict();
+export const nativeProbeReplySchema = z
+    .object({
+    id: z.string().uuid(),
+    status: z.literal('ready'),
+    backend: z.enum(['mobile-sam', 'grabcut']),
+})
+    .strict();
+export const nativeErrorReplySchema = z
+    .object({
+    id: z.string().uuid(),
+    status: z.literal('error'),
+    code: z.enum([
+        'INVALID_INPUT',
+        'INVALID_RESPONSE',
+        'TIMEOUT',
+        'ABORTED',
+        'CAPACITY',
+        'DISPOSED',
+        'PROVIDER',
+        'UNSUPPORTED',
+        'RESOURCE_LIMIT',
+    ]),
+    message: z.string().min(1).max(300),
+})
+    .strict();

package/dist/infrastructure/segmentation/native-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/infrastructure/segmentation/native-worker.js

@@ -0,0 +1,93 @@
+import { nativeSegmentationRequestSchema } from './native-protocol.js';
+import { ClassifierError } from '../../entities/errors.js';
+import { probeMobileSam, runMobileSamExpandTask, runMobileSamObjectProposalTask, runMobileSamTask, } from './mobile-sam/worker-inference.js';
+import { probeGrabCut, runGrabCutTask } from './grabcut/worker-inference.js';
+const stopOnParentLoss = () => {
+    process.exit(1);
+};
+let telemetryTimer;
+process.on('disconnect', stopOnParentLoss);
+process.on('message', (message) => {
+    if (typeof message !== 'object' ||
+        message === null ||
+        !('type' in message) ||
+        message.type !== 'telemetry' ||
+        !('enabled' in message))
+        return;
+    if (message.enabled === true && !telemetryTimer) {
+        sendMemory();
+        telemetryTimer = setInterval(() => process.send?.({ type: 'memory', memory: process.memoryUsage() }), 1000);
+        telemetryTimer.unref();
+    }
+    else if (message.enabled === false && telemetryTimer) {
+        clearInterval(telemetryTimer);
+        telemetryTimer = undefined;
+    }
+});
+process.send?.({ type: 'ready' });
+async function main() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.from(chunk));
+    const raw = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    const request = nativeSegmentationRequestSchema.parse(raw);
+    activeId = request.id;
+    const reply = request.kind === 'mobile-sam-expand'
+        ? await runMobileSamExpandTask(request)
+        : request.kind === 'mobile-sam-proposals'
+            ? await runMobileSamObjectProposalTask(request)
+            : request.kind === 'mobile-sam'
+                ? await runMobileSamTask(request)
+                : request.kind === 'grabcut'
+                    ? await runGrabCutTask(request)
+                    : request.kind === 'probe-mobile-sam'
+                        ? await probeMobileSam(request.options).then(() => ({
+                            id: request.id,
+                            status: 'ready',
+                            backend: 'mobile-sam',
+                        }))
+                        : await probeGrabCut(request.assetPath).then(() => ({
+                            id: request.id,
+                            status: 'ready',
+                            backend: 'grabcut',
+                        }));
+    sendMemory();
+    await new Promise((resolve, reject) => {
+        process.stdout.write(JSON.stringify(reply), (error) => {
+            if (error)
+                reject(error);
+            else
+                resolve();
+        });
+    });
+    if (telemetryTimer)
+        clearInterval(telemetryTimer);
+    process.off('disconnect', stopOnParentLoss);
+    process.disconnect();
+}
+main().catch(async (error) => {
+    const safe = classifyFailure(error);
+    await new Promise((resolve) => {
+        process.stdout.write(JSON.stringify({ id: activeId, status: 'error', ...safe }), () => resolve());
+    });
+    if (telemetryTimer)
+        clearInterval(telemetryTimer);
+    process.off('disconnect', stopOnParentLoss);
+    process.disconnect();
+});
+let activeId = '';
+function sendMemory() {
+    process.send?.({ type: 'memory', memory: process.memoryUsage() });
+}
+function classifyFailure(error) {
+    if (error instanceof ClassifierError)
+        return { code: error.code, message: error.message.slice(0, 300) };
+    const message = error instanceof Error ? error.message : 'Native segmentation failed';
+    if (/unavailable|not supported|not found|cannot find|module|pinned|asset|execution provider/i.test(message))
+        return { code: 'UNSUPPORTED', message: 'Required native backend or asset is unavailable' };
+    if (/limit|too large|queue full/i.test(message))
+        return { code: 'RESOURCE_LIMIT', message: 'Native segmentation exceeded a resource limit' };
+    if (/invalid|unexpected|mismatch|incompatible|non-finite/i.test(message))
+        return { code: 'INVALID_RESPONSE', message: 'Native backend returned invalid data' };
+    return { code: 'PROVIDER', message: 'Native segmentation backend failed' };
+}

package/dist/infrastructure/segmentation/probe-backend.d.ts

@@ -0,0 +1 @@
+export declare function probeBackend(workerUrl: URL, backend: 'mobile-sam' | 'grabcut', payload: Record<string, unknown>): Promise<void>;

package/dist/infrastructure/segmentation/probe-backend.js

@@ -0,0 +1,31 @@
+import { ClassifierError } from '../../entities/errors.js';
+import { NativeChildPool } from './native-child.js';
+import { nativeErrorReplySchema, nativeProbeReplySchema } from './native-protocol.js';
+export async function probeBackend(workerUrl, backend, payload) {
+    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', 'Backend probe error ID mismatch');
+                throw new ClassifierError(error.data.code, error.data.message);
+            }
+            const reply = nativeProbeReplySchema.safeParse(raw);
+            if (!reply.success || reply.data.id !== id || reply.data.backend !== backend)
+                throw new ClassifierError('INVALID_RESPONSE', 'Native backend probe returned an invalid reply');
+            return reply.data;
+        },
+    });
+    try {
+        await pool.run({ ...payload, kind: `probe-${backend}` }, new AbortController().signal);
+    }
+    finally {
+        await pool.dispose();
+    }
+}

package/dist/infrastructure/segmentation/proposal-presentation.d.ts

@@ -0,0 +1,3 @@
+import type { ObjectProposalPresentationPort } from '../../entities/object-proposals.js';
+/** Generic, bounded rendering for already-validated object mask aliases. */
+export declare function createSharpObjectProposalPresentation(): ObjectProposalPresentationPort;