zorya-classifier 0.2.0 → 0.2.2

package/dist/features/segmentation/region-result.js

@@ -0,0 +1,171 @@
+import { performance } from 'node:perf_hooks';
+import { z } from 'zod';
+import { pixelRectSchema } from '../../entities/contracts.js';
+import { decisionMetadataSchema } from '../../entities/decision.js';
+import { containsNonEmptyRect } from '../../entities/geometry.js';
+import { ClassifierError } from '../../entities/errors.js';
+const selectionSchema = z
+    .object({
+    choice: z.string().min(1),
+    nativeChoice: z.string().nullable(),
+    probabilities: z.record(z.number().finite()).nullable(),
+    ranking: z.array(z.string().min(1)).optional(),
+    confidence: z.number().finite().optional(),
+    probabilityRoundingStep: z.literal(0.01).optional(),
+    tied: z.array(z.string().min(1)),
+})
+    .strict();
+const normalizedRectSchema = z
+    .object({
+    left: z.number().finite().min(0).max(1),
+    top: z.number().finite().min(0).max(1),
+    width: z.number().finite().positive().max(1),
+    height: z.number().finite().positive().max(1),
+})
+    .strict();
+const localizationMetadataSchema = z
+    .object({
+    image: z
+        .object({
+        width: z.number().int().positive(),
+        height: z.number().int().positive(),
+        coordinateSpace: z.literal('oriented-source-pixels'),
+    })
+        .strict(),
+    stages: z.array(decisionMetadataSchema.strict()),
+    durationMs: z.number().finite().nonnegative(),
+    knownCostUsd: z.number().finite().nonnegative(),
+    unknownCostCount: z.number().int().nonnegative(),
+})
+    .strict();
+const refinementSchema = z.discriminatedUnion('status', [
+    z.object({ status: z.literal('refined'), region: pixelRectSchema, method: z.string() }).strict(),
+    z.object({ status: z.literal('unknown'), reason: z.string() }).strict(),
+]);
+const locatedSeedSchema = z
+    .object({
+    status: z.literal('located'),
+    region: pixelRectSchema,
+    normalizedRegion: normalizedRectSchema,
+    selection: selectionSchema,
+    method: z.literal('three-choice-grid-v1'),
+    refinement: refinementSchema.optional(),
+    metadata: localizationMetadataSchema,
+})
+    .strict();
+export function unresolved(seedLocation, segmentation, verification, started, source) {
+    const metadata = withMetadataDuration(seedLocation.metadata, started, source, verification);
+    return {
+        status: 'unknown',
+        reason: 'segmentation-uncertain',
+        seedLocation: { ...seedLocation, metadata },
+        metadata,
+        segmentation,
+        verification,
+    };
+}
+export function snapshotSeedLocation(value, source, roi) {
+    const parsed = locatedSeedSchema.safeParse(value);
+    if (!parsed.success)
+        throw new ClassifierError('INVALID_RESPONSE', 'Region locator returned an invalid result', {
+            paths: parsed.error.issues.map((issue) => issue.path.join('.')),
+        });
+    const seed = parsed.data;
+    if (seed.metadata.image.width !== source.width ||
+        seed.metadata.image.height !== source.height ||
+        !containsNonEmptyRect({ left: 0, top: 0, width: source.width, height: source.height }, seed.region) ||
+        !containsNonEmptyRect(roi, seed.region))
+        throw new ClassifierError('INVALID_RESPONSE', 'Region locator returned invalid source geometry');
+    return {
+        status: 'located',
+        region: { ...seed.region },
+        normalizedRegion: { ...seed.normalizedRegion },
+        selection: {
+            choice: seed.selection.choice,
+            nativeChoice: seed.selection.nativeChoice,
+            probabilities: seed.selection.probabilities ? { ...seed.selection.probabilities } : null,
+            ...(seed.selection.ranking ? { ranking: [...seed.selection.ranking] } : {}),
+            ...(seed.selection.confidence !== undefined ? { confidence: seed.selection.confidence } : {}),
+            ...(seed.selection.probabilityRoundingStep !== undefined
+                ? { probabilityRoundingStep: seed.selection.probabilityRoundingStep }
+                : {}),
+            tied: [...seed.selection.tied],
+        },
+        ...(seed.refinement !== undefined ? { refinement: { ...seed.refinement } } : {}),
+        method: 'three-choice-grid-v1',
+        metadata: snapshotLocalizationMetadata(seed.metadata),
+    };
+}
+function snapshotLocalizationMetadata(value) {
+    const parsed = localizationMetadataSchema.safeParse(value);
+    if (!parsed.success)
+        throw new ClassifierError('INVALID_RESPONSE', 'Region locator returned invalid metadata', {
+            paths: parsed.error.issues.map((issue) => issue.path.join('.')),
+        });
+    return {
+        ...parsed.data,
+        image: { ...parsed.data.image },
+        stages: parsed.data.stages.map((stage) => ({ ...stage })),
+    };
+}
+export function withLocalizationDuration(value, started, source) {
+    const metadata = withMetadataDuration(value.metadata, started, source);
+    return { ...value, metadata };
+}
+export function withMetadataDuration(value, started, source, verification) {
+    const metadata = snapshotLocalizationMetadata(value);
+    if (source && (metadata.image.width !== source.width || metadata.image.height !== source.height))
+        throw new ClassifierError('INVALID_RESPONSE', 'Region locator metadata source dimensions mismatch');
+    metadata.durationMs = Math.max(0, performance.now() - started);
+    for (const check of verification?.checks ?? []) {
+        metadata.stages.push({ ...check.metadata });
+        if (check.metadata.costUsd === null)
+            metadata.unknownCostCount++;
+        else
+            metadata.knownCostUsd += check.metadata.costUsd;
+    }
+    return metadata;
+}
+export function locatedFromMask(seed, box, image, roi, metadata) {
+    const touchesRoi = box.left === roi.left ||
+        box.top === roi.top ||
+        box.left + box.width === roi.left + roi.width ||
+        box.top + box.height === roi.top + roi.height;
+    return {
+        status: 'located',
+        kind: 'whole-object',
+        seedRegion: { ...seed.region },
+        region: { ...box },
+        normalizedRegion: {
+            left: box.left / image.width,
+            top: box.top / image.height,
+            width: box.width / image.width,
+            height: box.height / image.height,
+        },
+        bounds: boundsForMask(box),
+        completeness: touchesRoi ? 'boundary-limited' : 'visible-object',
+        method: 'region-checked-segmentation-v1',
+        center: { x: box.left + box.width / 2, y: box.top + box.height / 2 },
+        metadata,
+    };
+}
+export function boundsFor(roi) {
+    const right = roi.left + roi.width;
+    const bottom = roi.top + roi.height;
+    return {
+        left: { start: roi.left, endExclusive: right },
+        right: { start: roi.left, endExclusive: right },
+        top: { start: roi.top, endExclusive: bottom },
+        bottom: { start: roi.top, endExclusive: bottom },
+    };
+}
+function boundsForMask(box) {
+    const right = box.left + box.width;
+    const bottom = box.top + box.height;
+    return {
+        left: { start: box.left, endExclusive: box.left + 1 },
+        right: { start: right - 1, endExclusive: right },
+        top: { start: box.top, endExclusive: box.top + 1 },
+        bottom: { start: bottom - 1, endExclusive: bottom },
+    };
+}

package/dist/features/segmentation/source-mask.d.ts

@@ -0,0 +1,6 @@
+import type { PixelRect } from '../../entities/contracts.js';
+import type { RgbaRaster } from '../../entities/representation.js';
+import type { BinaryMask } from '../../entities/segmentation.js';
+export declare function validateSourceMask(mask: BinaryMask, image: RgbaRaster, roi: PixelRect, seed: PixelRect): PixelRect | undefined;
+export declare function clearTransparentForeground(mask: BinaryMask, image: RgbaRaster): void;
+export declare function isEnclosingMask(previous: BinaryMask, previousBox: PixelRect, expanded: BinaryMask, box: PixelRect): boolean;

package/dist/features/segmentation/source-mask.js

@@ -0,0 +1,32 @@
+import { containsNonEmptyRect } from '../../entities/geometry.js';
+import { ClassifierError } from '../../entities/errors.js';
+import { validateMask } from './mask.js';
+export function validateSourceMask(mask, image, roi, seed) {
+    try {
+        return validateMask(mask, image, roi, seed);
+    }
+    catch {
+        throw new ClassifierError('INVALID_RESPONSE', 'Segmenter mask failed binary/source validation');
+    }
+}
+export function clearTransparentForeground(mask, image) {
+    for (let index = 0; index < mask.data.length; index++)
+        if (image.data[index * 4 + 3] === 0)
+            mask.data[index] = 0;
+}
+export function isEnclosingMask(previous, previousBox, expanded, box) {
+    if (!containsNonEmptyRect(box, previousBox) ||
+        (box.left === previousBox.left &&
+            box.top === previousBox.top &&
+            box.width === previousBox.width &&
+            box.height === previousBox.height))
+        return false;
+    let added = false;
+    for (let i = 0; i < previous.data.length; i++) {
+        if (previous.data[i] === 1 && expanded.data[i] !== 1)
+            return false;
+        if (previous.data[i] !== 1 && expanded.data[i] === 1)
+            added = true;
+    }
+    return added;
+}

package/dist/features/segmentation/validation.d.ts

@@ -0,0 +1,9 @@
+import type { RasterImage } from '../../entities/contracts.js';
+import type { SegmentationResult } from '../../entities/segmentation.js';
+import type { RgbaRaster } from '../../entities/representation.js';
+/** Validates PNG magic bytes and returns an owned copy of the payload. */
+export declare function validateAndSnapshotPng(rawPng: unknown): Uint8Array;
+/** Validates and owns a segmenter's result before any subsequent asynchronous work. */
+export declare function validateSegmentationResult(value: unknown, width: number, height: number): SegmentationResult;
+export declare function assertRasterImage(image: RasterImage): void;
+export declare function validateAndSnapshotRgba(value: unknown, width: number, height: number): RgbaRaster;

package/dist/features/segmentation/validation.js

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+import { parse } from '../../entities/contracts.js';
+import { ClassifierError } from '../../entities/errors.js';
+import { segmentationMetadataSchema } from '../../entities/segmentation-metadata.js';
+const binaryMaskSchema = z
+    .object({
+    data: z.instanceof(Uint8Array),
+    width: z.number().int().positive(),
+    height: z.number().int().positive(),
+    format: z.literal('binary-u8'),
+})
+    .strict();
+const rgbaSchema = 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 segmentationResultSchema = z.discriminatedUnion('status', [
+    z
+        .object({
+        status: z.literal('segmented'),
+        mask: binaryMaskSchema,
+        metadata: segmentationMetadataSchema,
+    })
+        .strict(),
+    z
+        .object({
+        status: z.literal('unknown'),
+        reason: z.string().min(1).max(500),
+        metadata: segmentationMetadataSchema,
+    })
+        .strict(),
+]);
+const PNG_SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
+/** Validates PNG magic bytes and returns an owned copy of the payload. */
+export function validateAndSnapshotPng(rawPng) {
+    if (!(rawPng instanceof Uint8Array) ||
+        rawPng.byteLength < 8 ||
+        !PNG_SIGNATURE.every((byte, index) => rawPng[index] === byte))
+        throw new ClassifierError('INVALID_RESPONSE', 'Cutout raster port returned invalid PNG bytes');
+    return new Uint8Array(rawPng);
+}
+/** Validates and owns a segmenter's result before any subsequent asynchronous work. */
+export function validateSegmentationResult(value, width, height) {
+    const validation = segmentationResultSchema.safeParse(value);
+    if (!validation.success)
+        throw new ClassifierError('INVALID_RESPONSE', 'Segmenter returned an invalid result', {
+            paths: validation.error.issues.map((issue) => issue.path.join('.')),
+        });
+    if (validation.data.metadata.input.width !== width ||
+        validation.data.metadata.input.height !== height)
+        throw new ClassifierError('INVALID_RESPONSE', 'Segmenter metadata dimensions do not match the source image');
+    return validation.data.status === 'segmented'
+        ? {
+            status: 'segmented',
+            mask: { ...validation.data.mask, data: new Uint8Array(validation.data.mask.data) },
+            metadata: snapshotMetadata(validation.data.metadata),
+        }
+        : {
+            ...validation.data,
+            metadata: snapshotMetadata(validation.data.metadata),
+        };
+}
+export function assertRasterImage(image) {
+    if (!Number.isSafeInteger(image.width) ||
+        !Number.isSafeInteger(image.height) ||
+        image.width < 1 ||
+        image.height < 1 ||
+        image.width * image.height > 16_777_216 ||
+        image.bytes.byteLength < 1)
+        throw new ClassifierError('INVALID_RESPONSE', 'Raster normalizer returned invalid source dimensions');
+}
+export function validateAndSnapshotRgba(value, width, height) {
+    const image = parse(rgbaSchema, value, 'INVALID_RESPONSE');
+    if (image.format !== 'rgba8' ||
+        image.width !== width ||
+        image.height !== height ||
+        !(image.data instanceof Uint8Array) ||
+        image.data.length !== width * height * 4)
+        throw new ClassifierError('INVALID_RESPONSE', 'Cutout raster port returned invalid RGBA dimensions');
+    return { data: new Uint8Array(image.data), width, height, format: 'rgba8' };
+}
+function snapshotMetadata(metadata) {
+    return {
+        method: metadata.method,
+        backend: metadata.backend,
+        durationMs: metadata.durationMs,
+        input: { ...metadata.input },
+        ...(metadata.qualityScore !== undefined ? { qualityScore: metadata.qualityScore } : {}),
+    };
+}

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

@@ -0,0 +1,8 @@
+import type { z } from 'zod';
+import { ClassifierError } from '../../entities/errors.js';
+import type { ErrorCode } from '../../entities/errors.js';
+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 failure(error: unknown, signal: AbortSignal, cleanupFailed?: boolean): ClassifierError;

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

@@ -0,0 +1,34 @@
+import { ClassifierError } from '../../entities/errors.js';
+const localErrors = new WeakSet();
+export function ownedError(code, message, details = {}) {
+    const error = new ClassifierError(code, message, details);
+    localErrors.add(error);
+    return error;
+}
+export function invalid(code, message) {
+    return ownedError(code, message);
+}
+export function active(signal) {
+    if (!signal.aborted)
+        return;
+    const timeout = signal.reason instanceof ClassifierError && signal.reason.code === 'TIMEOUT';
+    throw ownedError(timeout ? 'TIMEOUT' : 'ABORTED', timeout ? 'Operation timed out' : 'Operation cancelled');
+}
+export function validated(schema, input, code) {
+    const parsed = schema.safeParse(input);
+    if (!parsed.success)
+        throw invalid(code, 'Decision schema validation failed');
+    return parsed.data;
+}
+export function failure(error, signal, cleanupFailed = false) {
+    const known = error instanceof ClassifierError && localErrors.has(error);
+    const incompleteCleanup = cleanupFailed || (known && error.details.cleanupFailed === true);
+    try {
+        active(signal);
+    }
+    catch (aborted) {
+        if (aborted instanceof ClassifierError)
+            return ownedError(aborted.code, aborted.message, incompleteCleanup ? { cleanupFailed: true } : {});
+    }
+    return ownedError(known ? error.code : 'PROVIDER', known ? error.message : 'Model provider transport failed', { ...(known ? error.details : {}), ...(incompleteCleanup ? { cleanupFailed: true } : {}) });
+}

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

@@ -0,0 +1 @@
+export declare function validateImage(url: string): void;

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

@@ -0,0 +1,52 @@
+import { invalid } from './errors.js';
+function imageSize(bytes, format) {
+    if (format === 'png') {
+        if (bytes.length < 33 ||
+            !bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])) ||
+            bytes.readUInt32BE(8) !== 13 ||
+            bytes.toString('ascii', 12, 16) !== 'IHDR')
+            throw invalid('INVALID_INPUT', 'Invalid PNG image header');
+        return [bytes.readUInt32BE(16), bytes.readUInt32BE(20)];
+    }
+    if (bytes[0] !== 255 || bytes[1] !== 216)
+        throw invalid('INVALID_INPUT', 'Invalid JPEG image header');
+    let offset = 2;
+    while (offset + 3 < bytes.length) {
+        if (bytes[offset++] !== 255)
+            break;
+        while (bytes[offset] === 255)
+            offset++;
+        const marker = bytes[offset++];
+        if (marker === undefined || marker === 218 || marker === 217)
+            break;
+        if (offset + 2 > bytes.length)
+            break;
+        const length = bytes.readUInt16BE(offset);
+        if (length < 2 || offset + length > bytes.length)
+            break;
+        if ([192, 193, 194, 195, 197, 198, 199, 201, 202, 203, 205, 206, 207].includes(marker)) {
+            if (length < 8)
+                break;
+            return [bytes.readUInt16BE(offset + 5), bytes.readUInt16BE(offset + 3)];
+        }
+        offset += length;
+    }
+    throw invalid('INVALID_INPUT', 'Invalid JPEG image dimensions');
+}
+export function validateImage(url) {
+    const prefix = /^data:image\/(png|jpeg);base64,/u.exec(url);
+    if (!prefix)
+        throw invalid('INVALID_INPUT', 'Only inline PNG or JPEG images are supported');
+    const encoded = url.slice(prefix[0].length);
+    const padding = encoded.endsWith('==') ? 2 : Number(encoded.endsWith('='));
+    if (!encoded.length ||
+        encoded.length % 4 !== 0 ||
+        !/^[A-Za-z0-9+/]+$/u.test(encoded.slice(0, encoded.length - padding)))
+        throw invalid('INVALID_INPUT', 'Invalid image base64');
+    const bytes = Buffer.from(encoded, 'base64');
+    if (bytes.length > 16 * 1024 * 1024 || bytes.toString('base64') !== encoded)
+        throw invalid('INVALID_INPUT', 'Invalid image byte representation');
+    const [width, height] = imageSize(bytes, prefix[1] ?? '');
+    if (width < 280 || height < 280 || width > 1568 || height > 1568)
+        throw invalid('INVALID_INPUT', 'Prepared image sides must be 280..1568 pixels');
+}

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