zorya-classifier 0.2.1 → 0.2.3

package/docs/v02-usage.md

@@ -1,6 +1,6 @@
 # Region-seeded masks and extraction (0.2)
 
-Everything in this guide—default region `locate`, `locate({ mode: 'whole-object' })`, `extract`, optional `RefinementPort`, `SegmentationPort`, box-check composition, `objectProposals`, and exported native factories—is **experimental and unqualified** for general use. Passing structural or lifecycle checks does not establish semantic object accuracy or mask quality. Further accuracy experiments on these paths are stopped; no spatial or extraction strategy is promoted. Historical metrics in `docs/evidence/**` are unchanged.
+Everything in this guide—default region `locate`, `locate({ mode: 'whole-object' })`, `extract`, optional `RefinementPort`, `SegmentationPort`, box-check composition, `objectProposals`, and exported native factories—is implemented and caller-configured. Passing structural or lifecycle checks does not establish semantic object accuracy or mask quality. The [H8a vs Jev DEV12 comparison](research/v03-jev-native-box-results.ru.md) documents one research box recipe; it is not default locate/extract. Historical metrics in `docs/evidence/**` are unchanged.
 
 The [accepted plan](0.2.0-plan.md) and [acceptance status](acceptance.md) distinguish implementation, offline checks, live quality and platform qualification. The frozen caller recipe passed admission with only 8/60 complete positive object boxes; 19/30 mask references had no prediction. Configure and test the model and segmenter for your own data. No text-image encoder qualified.
 
@@ -8,12 +8,12 @@ The library does not select or connect a model. Supply a `DecisionPort` to `crea
 
 ## Choose the operation
 
-| Operation                                               | Status       | Result                                                                       | Model requests                                 |
-| ------------------------------------------------------- | ------------ | ---------------------------------------------------------------------------- | ---------------------------------------------- |
-| `classify`                                              | Supported    | One supplied class                                                           | One                                            |
-| `locate` (default / `mode: 'region'`)                   | Experimental | A grid cell that may contain an object fragment                              | Up to three                                    |
-| `locate` with `mode: 'whole-object'` and `segmentation` | Experimental | Visible bounds and center derived from a mask                                | Up to five, plus local segmentation/correction |
-| `extract` with `segmentation`                           | Experimental | Mask-derived bounds, center, transparent PNG, cropped mask and source offset | Up to five, plus local segmentation/correction |
+| Operation                                               | Status    | Result                                                                       | Model requests                                 |
+| ------------------------------------------------------- | --------- | ---------------------------------------------------------------------------- | ---------------------------------------------- |
+| `classify`                                              | Supported | One supplied class                                                           | One                                            |
+| `locate` (default / `mode: 'region'`)                   | Available | A grid cell that may contain an object fragment                              | Up to three                                    |
+| `locate` with `mode: 'whole-object'` and `segmentation` | Available | Visible bounds and center derived from a mask                                | Up to five, plus local segmentation/correction |
+| `extract` with `segmentation`                           | Available | Mask-derived bounds, center, transparent PNG, cropped mask and source offset | Up to five, plus local segmentation/correction |
 
 The primary object workflow is the unchanged region locator followed by an explicitly configured segmenter. Segmentation receives the locator's seed prompt on the full EXIF-oriented source image; it does not receive a seed crop or treat the seed as an object box. Bounds and center come from actual foreground mask pixels. After the initial mask, a closed decision checks the original image with the actual mask box and original seed anchor: `complete`, `needs-expansion`, or `unknown`. It reuses the caller-supplied `DecisionPort`. An incomplete box permits one actual enclosing-mask correction and one final check; there is no separate extent search or generated model geometry. Default `locate` behavior remains compatible.
 
@@ -157,7 +157,7 @@ Successful extraction writes `<prefix>.png`, `<prefix>.mask.u8` and `<prefix>.js
 
 ## Experimental text-only images
 
-The reserved selector is `representation: { type: 'experimental-text', profile: 'text-image-v1' }`. Public composition currently rejects image operations with `UNSUPPORTED` before dispatch because no encoder is qualified. Ordinary text classification remains usable.
+The former experimental selector `representation: { type: 'experimental-text', profile: 'text-image-v1' }` was removed from the public runtime. Requests that include it fail strict validation with `INVALID_INPUT` before any `DecisionPort` call. Text-image encoders remain under `benchmarks/experiments/` only and are not pending public qualification. Ordinary string/`{ text }` classification and vision inputs (`{ type: 'vision' }` or omitted) remain supported. See [migration note (RU)](migrations/experimental-text-image-removal.ru.md).
 
 Research candidates compare normalized luma ASCII, color palette grids, SVG color runs, strict pixel RLE, binary/edge ASCII, and layered ASCII + SVG. No OCR, semantic helper or hidden vision call supplies object facts. Text adapters reject image parts rather than silently dropping them. Complete encoded views and metadata have a 64 KiB UTF-8 budget, allocated before encoding; output is never truncated to fit. Indistinguishable geometry returns a named unknown.
 

package/docs/vision-results.md

@@ -2,7 +2,7 @@
 
 ## Current 0.2 region and extraction evidence
 
-Region `locate`, whole-object location, `extract`, proposal/refinement strategies, and native segmentation adapters are **experimental and unqualified** for general use; figures below are historical evidence for one documented recipe, not a promotion or universal accuracy claim. Further spatial accuracy experiments are stopped. H8 DEV recorded 7/9 positives with 2/3 false outputs and did not qualify.
+Region `locate`, whole-object location, `extract`, proposal/refinement strategies and native segmentation adapters are available public APIs. Results below describe specific model recipes, not general accuracy. In one exposed DEV12 pilot, the historical H8a output passed the strict same-instance box criterion on 7/9 positive tasks; a single native Jev 1.14 run passed on 3/9. The criterion requires IoU ≥0.5 and at least 90% reference-box coverage. See the [full v03 comparison (RU)](research/v03-jev-native-box-results.ru.md); H8a was not rerun for this comparison. The same H8a run produced false outputs on 2/3 tasks where the target was absent, so it failed its full gate; the single Jev run produced one such false output on 1/3 tasks.
 
 The final [frozen v3 heldout report](evidence/v02/region-seeded-heldout-v3/README.md) evaluates all 80 cases per profile. Classification is 65/80; positive seed hits 26/60; complete object boxes 8/60; false seeds and extractions 0/20 negatives. Of 30 exact-canvas mask references, eight pass IoU 0.8, three fail and 19 have no prediction. Both positive-photo paired seed intervals are [0.500, 0.833]. These are separate metrics; a successful seed or containment decision does not guarantee a tight mask. Candidate accounting includes 266 physical calls, two HTTP 502 failures and two unknown charges. The control made 80 image-free calls. This one controlled corpus admission and the resource/native checks qualify the documented recipe only; model choice stays with the caller. Development and failed historical evidence below is preserved.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "zorya-classifier",
-  "version": "0.2.1",
-  "description": "Provider-independent classification with experimental localization and object extraction for Node.js",
+  "version": "0.2.3",
+  "description": "Provider-independent Node.js classification, spatial localization, and caller-owned mask-based object extraction",
   "type": "module",
   "license": "MIT",
   "engines": {
@@ -42,7 +42,9 @@
     "lint": "eslint . --max-warnings 0",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
-    "test": "node --import tsx --test --test-concurrency=2 test/*.test.ts",
+    "test": "node --import tsx scripts/run-classified-tests.mjs portable",
+    "test:local-evidence": "node --import tsx scripts/run-classified-tests.mjs local-evidence",
+    "test:python-native": "node --import tsx scripts/run-classified-tests.mjs python-native",
     "check": "npm run secrets:check && npm run typecheck && npm run lint && npm run boundaries && npm run dead-code:ci && npm test && npm run build",
     "boundaries": "node scripts/boundaries.mjs",
     "dead-code:ci": "knip --no-progress",

package/dist/infrastructure/boundary-view.d.ts

@@ -1,2 +0,0 @@
-import type { BoundaryViewPort } from '../entities/boundary-view.js';
-export declare function createSharpBoundaryView(): BoundaryViewPort;

package/dist/infrastructure/boundary-view.js

@@ -1,263 +0,0 @@
-import sharp from 'sharp';
-import { z } from 'zod';
-import { limits, pixelRectSchema } from '../entities/contracts.js';
-import { ClassifierError, assertActive } from '../entities/errors.js';
-const sourceSchema = z
-    .object({
-    bytes: z
-        .custom((v) => v instanceof Uint8Array)
-        .refine((v) => v.byteLength > 0 && v.byteLength <= limits.imageBytes),
-    width: z.number().int().positive().max(16384),
-    height: z.number().int().positive().max(16384),
-})
-    .strict();
-const candidateSchema = z
-    .object({
-    id: z
-        .string()
-        .min(1)
-        .max(128)
-        .regex(/^[A-Za-z][A-Za-z0-9_-]*$/),
-    display: z
-        .string()
-        .min(1)
-        .max(8)
-        .regex(/^[A-Za-z0-9_-]+$/),
-    interval: z
-        .object({
-        start: z.number().int().nonnegative().safe(),
-        endExclusive: z.number().int().positive().safe(),
-    })
-        .strict()
-        .refine((v) => v.start < v.endExclusive),
-})
-    .strict();
-const inputSchema = z
-    .object({
-    source: sourceSchema,
-    sourceRegion: pixelRectSchema,
-    axis: z.enum(['left', 'right', 'top', 'bottom']),
-    candidates: z.array(candidateSchema).min(1).max(16),
-    signal: z.custom((v) => v instanceof AbortSignal),
-})
-    .strict();
-const maxContentSide = 1280;
-const maxOutputSide = 1567;
-const axisGutter = 210;
-const outerGutter = 10;
-const maxRenderedBytes = limits.imageBytes;
-function contained(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);
-}
-function escapeXml(value) {
-    return value.replace(/[&<>"']/gu, (char) => {
-        switch (char) {
-            case '&':
-                return '&amp;';
-            case '<':
-                return '&lt;';
-            case '>':
-                return '&gt;';
-            case '"':
-                return '&quot;';
-            default:
-                return '&apos;';
-        }
-    });
-}
-function failInput(message) {
-    throw new ClassifierError('INVALID_INPUT', message, { component: 'boundary-view' });
-}
-function validate(input) {
-    const parsed = inputSchema.safeParse(input);
-    if (!parsed.success)
-        failInput('Invalid boundary-view request');
-    const value = parsed.data;
-    if (value.source.width * value.source.height > limits.imagePixels)
-        throw new ClassifierError('RESOURCE_LIMIT', 'Source raster exceeds pixel limits', {
-            component: 'boundary-view',
-        });
-    const full = { left: 0, top: 0, width: value.source.width, height: value.source.height };
-    if (!contained(full, value.sourceRegion))
-        failInput('Source region lies outside the oriented image');
-    const xAxis = value.axis === 'left' || value.axis === 'right';
-    const axisSize = xAxis ? value.source.width : value.source.height;
-    const axisStart = xAxis ? value.sourceRegion.left : value.sourceRegion.top;
-    const axisEnd = axisStart + (xAxis ? value.sourceRegion.width : value.sourceRegion.height);
-    const ids = new Set();
-    const displays = new Set();
-    let priorEnd = -1;
-    for (const candidate of value.candidates) {
-        if (ids.has(candidate.id) || displays.has(candidate.display))
-            failInput('Boundary candidate IDs and display labels must be unique');
-        ids.add(candidate.id);
-        displays.add(candidate.display);
-        if (candidate.interval.endExclusive > axisSize)
-            failInput('Boundary interval lies outside the oriented source');
-        if (candidate.interval.start < axisStart || candidate.interval.endExclusive > axisEnd)
-            failInput('Boundary interval lies outside the source region');
-        if (candidate.interval.start < priorEnd)
-            failInput('Boundary intervals must be ordered and non-overlapping');
-        priorEnd = candidate.interval.endExclusive;
-    }
-    return value;
-}
-function svgOverlay(axis, candidates, region, contentWidth, contentHeight, contentLeft, contentTop, outputWidth, outputHeight) {
-    const vertical = axis === 'left' || axis === 'right';
-    const axisLength = vertical ? region.width : region.height;
-    const outputLength = vertical ? contentWidth : contentHeight;
-    const sourceOffset = vertical ? region.left : region.top;
-    const unit = outputLength / axisLength;
-    const strokes = [];
-    // Presentation is tied to the coordinate dimension, never to the semantic side being located.
-    const color = vertical ? '#ff6b5f' : '#49d6a1';
-    const title = vertical ? 'X coordinates' : 'Y coordinates';
-    strokes.push(vertical
-        ? `<text x="${outputWidth - outerGutter - 2}" y="${outerGutter + 10}" text-anchor="end" font-family="DejaVu Sans,sans-serif" font-size="9" fill="#f3f4f6">${title}</text>`
-        : `<text x="${outerGutter}" y="${outerGutter + 10}" font-family="DejaVu Sans,sans-serif" font-size="9" fill="#f3f4f6">${title}</text>`);
-    const positions = candidates.map((candidate) => {
-        const begin = (candidate.interval.start - sourceOffset) * unit;
-        const end = (candidate.interval.endExclusive - sourceOffset) * unit;
-        return (begin + end) / 2;
-    });
-    const labelBaselines = vertical
-        ? (() => {
-            const pitch = 12;
-            const lanes = [];
-            const rightEdges = [];
-            return candidates.map((candidate, index) => {
-                const center = contentLeft + (positions[index] ?? 0);
-                const width = candidate.display.length * 7 + 6;
-                let lane = rightEdges.findIndex((right) => right + 3 <= center - width / 2);
-                if (lane < 0) {
-                    lane = rightEdges.length;
-                    rightEdges.push(Number.NEGATIVE_INFINITY);
-                }
-                rightEdges[lane] = center + width / 2;
-                lanes[index] = lane;
-                return contentTop - 5 - (lane + 1) * pitch;
-            });
-        })()
-        : (() => {
-            const min = outerGutter + 10;
-            const max = outputHeight - outerGutter - 3;
-            const pitch = 12;
-            const desired = positions.map((position) => contentTop + position + 4);
-            const placed = desired.map((position) => Math.max(min, Math.min(max, position)));
-            for (let index = 1; index < placed.length; index++)
-                placed[index] = Math.max(placed[index] ?? min, (placed[index - 1] ?? min) + pitch);
-            if ((placed.at(-1) ?? max) > max) {
-                placed[placed.length - 1] = max;
-                for (let index = placed.length - 2; index >= 0; index--)
-                    placed[index] = Math.min(placed[index] ?? max, (placed[index + 1] ?? max) - pitch);
-            }
-            return placed;
-        })();
-    for (const [index, candidate] of candidates.entries()) {
-        const start = (candidate.interval.start - sourceOffset) * unit;
-        const end = (candidate.interval.endExclusive - sourceOffset) * unit;
-        const lo = Math.min(start, end);
-        const hi = Math.max(start, end);
-        const midpoint = (lo + hi) / 2;
-        const label = escapeXml(candidate.display);
-        if (vertical) {
-            const center = contentLeft + midpoint;
-            const halfWidth = candidate.display.length * 3.5 + 3;
-            const labelCenter = Math.max(contentLeft + halfWidth, Math.min(contentLeft + contentWidth - halfWidth, center));
-            const baseline = labelBaselines[index] ?? contentTop - 17;
-            strokes.push(`<rect x="${contentLeft + lo}" y="${contentTop}" width="${Math.max(1, hi - lo)}" height="${contentHeight}" fill="${color}" fill-opacity="0.045"/>`, `<line x1="${contentLeft + start}" y1="${contentTop}" x2="${contentLeft + start}" y2="${contentTop + contentHeight}" stroke="${color}" stroke-opacity="0.9" stroke-width="2"/>`, `<line x1="${contentLeft + end}" y1="${contentTop}" x2="${contentLeft + end}" y2="${contentTop + contentHeight}" stroke="${color}" stroke-opacity="0.9" stroke-width="2"/>`, `<path d="M ${center} ${contentTop} L ${center} ${baseline + 4} L ${labelCenter} ${baseline + 4}" fill="none" stroke="${color}" stroke-width="1"/>`, `<text x="${labelCenter}" y="${baseline}" text-anchor="middle" font-family="DejaVu Sans,sans-serif" font-size="10" font-weight="bold" fill="${color}">${label}</text>`);
-        }
-        else {
-            const midpointY = contentTop + midpoint;
-            const baseline = labelBaselines[index] ?? midpointY + 4;
-            const elbowX = contentLeft - 12 - index * 3;
-            const labelX = contentLeft - 82;
-            strokes.push(`<rect x="${contentLeft}" y="${contentTop + lo}" width="${contentWidth}" height="${Math.max(1, hi - lo)}" fill="${color}" fill-opacity="0.045"/>`, `<line x1="${contentLeft}" y1="${contentTop + start}" x2="${contentLeft + contentWidth}" y2="${contentTop + start}" stroke="${color}" stroke-opacity="0.9" stroke-width="2"/>`, `<line x1="${contentLeft}" y1="${contentTop + end}" x2="${contentLeft + contentWidth}" y2="${contentTop + end}" stroke="${color}" stroke-opacity="0.9" stroke-width="2"/>`, `<path d="M ${contentLeft} ${midpointY} L ${elbowX} ${midpointY} L ${elbowX} ${baseline} L ${labelX + 4} ${baseline}" fill="none" stroke="${color}" stroke-width="1"/>`, `<text x="${labelX}" y="${baseline}" text-anchor="end" font-family="DejaVu Sans,sans-serif" font-size="10" font-weight="bold" fill="${color}">${label}</text>`);
-        }
-    }
-    const sourceBounds = `<rect x="${contentLeft}" y="${contentTop}" width="${contentWidth}" height="${contentHeight}" fill="none" stroke="#f3f4f6" stroke-opacity="0.65" stroke-width="1"/>`;
-    return Buffer.from(`<svg xmlns="http://www.w3.org/2000/svg" width="${outputWidth}" height="${outputHeight}">${sourceBounds}${strokes.join('')}</svg>`);
-}
-async function render(input) {
-    assertActive(input.signal);
-    const value = validate(input);
-    assertActive(value.signal);
-    // Sharp retains its input through an asynchronous pipeline; take ownership before awaiting.
-    const ownedBytes = Buffer.from(value.source.bytes);
-    const candidates = value.candidates.map((candidate) => ({
-        id: candidate.id,
-        display: candidate.display,
-        interval: { ...candidate.interval },
-    }));
-    const { sourceRegion: region } = value;
-    const scale = Math.min(maxContentSide / Math.max(region.width, region.height), Math.max(1, 768 / Math.min(region.width, region.height)));
-    const contentWidth = Math.max(1, Math.round(region.width * scale));
-    const contentHeight = Math.max(1, Math.round(region.height * scale));
-    const vertical = value.axis === 'left' || value.axis === 'right';
-    const contentLeft = vertical ? outerGutter : axisGutter;
-    const contentTop = vertical ? axisGutter : outerGutter;
-    const outputWidth = Math.max(280, contentLeft + contentWidth + outerGutter);
-    const outputHeight = Math.max(280, contentTop + contentHeight + outerGutter);
-    if (outputWidth > maxOutputSide || outputHeight > maxOutputSide)
-        throw new ClassifierError('RESOURCE_LIMIT', 'Boundary view exceeds output side limit', {
-            component: 'boundary-view',
-        });
-    const pixels = outputWidth * outputHeight;
-    if (pixels > limits.imagePixels)
-        throw new ClassifierError('RESOURCE_LIMIT', 'Boundary view exceeds output pixel limit', {
-            component: 'boundary-view',
-        });
-    const overlay = svgOverlay(value.axis, candidates, region, contentWidth, contentHeight, contentLeft, contentTop, outputWidth, outputHeight);
-    if (overlay.byteLength > 128 * 1024)
-        throw new ClassifierError('RESOURCE_LIMIT', 'Boundary overlay exceeds byte budget', {
-            component: 'boundary-view',
-        });
-    let pipeline;
-    try {
-        assertActive(value.signal);
-        pipeline = sharp(ownedBytes, { limitInputPixels: limits.imagePixels, failOn: 'error' })
-            .extract(region)
-            .resize(contentWidth, contentHeight, { kernel: 'nearest' })
-            .extend({
-            left: contentLeft,
-            top: contentTop,
-            right: outputWidth - contentLeft - contentWidth,
-            bottom: outputHeight - contentTop - contentHeight,
-            background: { r: 17, g: 24, b: 39, alpha: 1 },
-        })
-            .composite([{ input: overlay }]);
-        const result = await pipeline.png().toBuffer();
-        assertActive(value.signal);
-        if (result.byteLength > maxRenderedBytes)
-            throw new ClassifierError('RESOURCE_LIMIT', 'Rendered boundary view exceeds byte limit', {
-                component: 'boundary-view',
-            });
-        return {
-            image: { bytes: result, width: outputWidth, height: outputHeight },
-            sourceRegion: { ...region },
-            content: { left: contentLeft, top: contentTop, width: contentWidth, height: contentHeight },
-            scaleX: contentWidth / region.width,
-            scaleY: contentHeight / region.height,
-            candidates,
-        };
-    }
-    catch (error) {
-        assertActive(value.signal);
-        if (error instanceof ClassifierError)
-            throw error;
-        throw new ClassifierError('INVALID_INPUT', 'Boundary view could not be rendered', {
-            component: 'boundary-view',
-        });
-    }
-    finally {
-        pipeline?.destroy();
-        ownedBytes.fill(0);
-        overlay.fill(0);
-    }
-}
-export function createSharpBoundaryView() {
-    return { render };
-}

package/dist/infrastructure/openrouter-common.js

@@ -1,317 +0,0 @@
-import { isProxy } from 'node:util/types';
-import { z } from 'zod';
-import { ClassifierError } from '../entities/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();
-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;
-}
-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');
-}
-/** 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);
-}
-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 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 } : {}) });
-}
-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;
-}