zorya-classifier 0.2.1 → 0.2.2

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

package/dist/infrastructure/text-representation.d.ts

@@ -1,23 +0,0 @@
-import type { PixelRect } from '../entities/contracts.js';
-import type { ImageRepresentationPort, RepresentationView } from '../entities/representation.js';
-export interface TextPixelView {
-    id: string;
-    role: RepresentationView['role'];
-    sourceRegion: PixelRect;
-    width: number;
-    height: number;
-    /** Clean, resized, row-major RGBA8. Grid labels remain separately available as metadata. */
-    data: Uint8Array;
-    grid?: RepresentationView['grid'];
-}
-export interface TextRepresentationEncoder {
-    readonly profile: string;
-    /** Hard UTF-8 upper bound for one encoded view at these dimensions. */
-    maxEncodedBytes(width: number, height: number): number;
-    encode(view: TextPixelView, signal: AbortSignal): Promise<string>;
-}
-/**
- * Build request-wide text representations from clean canonical pixels. The injected encoder
- * is intentionally internal so research codecs do not become public package exports.
- */
-export declare function createTextRepresentation(encoder: TextRepresentationEncoder): ImageRepresentationPort;

package/dist/infrastructure/text-representation.js

@@ -1,226 +0,0 @@
-import sharp from 'sharp';
-import { limits } from '../entities/contracts.js';
-import { ClassifierError, assertActive } from '../entities/errors.js';
-import { representationLimits } from '../entities/representation.js';
-import { readCanonicalPixels } from './raster.js';
-function isContained(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 key(region) {
-    return `${region.left},${region.top},${region.width},${region.height}`;
-}
-function dimensions(region, maxSide) {
-    const scale = Math.min(1, maxSide / Math.max(region.width, region.height));
-    return {
-        width: Math.max(1, Math.round(region.width * scale)),
-        height: Math.max(1, Math.round(region.height * scale)),
-    };
-}
-function assertGridGeometry(view, width, height) {
-    if (!view.grid)
-        return;
-    const map = (rect) => ({
-        left: Math.round(((rect.left - view.sourceRegion.left) * width) / view.sourceRegion.width),
-        top: Math.round(((rect.top - view.sourceRegion.top) * height) / view.sourceRegion.height),
-        width: Math.round((rect.width * width) / view.sourceRegion.width),
-        height: Math.round((rect.height * height) / view.sourceRegion.height),
-    });
-    const mapped = view.grid.cells.map((cell) => map(cell.region));
-    if (view.grid.cells.some((cell) => !isContained(view.sourceRegion, cell.region)))
-        throw new ClassifierError('INVALID_INPUT', 'Grid geometry lies outside its source region');
-    if (mapped.some((rect) => rect.width < 1 || rect.height < 1))
-        throw new ClassifierError('RESOURCE_LIMIT', 'Distinct grid geometry is indistinguishable at the allocated resolution', { component: 'representation' });
-    const sourceKeys = new Set(view.grid.cells.map((cell) => key(cell.region)));
-    const mappedKeys = new Set(mapped.map((rect) => key(rect)));
-    if (sourceKeys.size !== mappedKeys.size)
-        throw new ClassifierError('RESOURCE_LIMIT', 'Distinct grid geometry collapses at the allocated resolution', {
-            component: 'representation',
-        });
-}
-async function cleanPixels(source, sourcePixels, view, width, height, signal) {
-    const region = view.sourceRegion;
-    if (!isContained({ left: 0, top: 0, width: source.width, height: source.height }, region))
-        throw new ClassifierError('INVALID_INPUT', 'Representation view lies outside the oriented source');
-    const raw = Buffer.from(sourcePixels.buffer, sourcePixels.byteOffset, sourcePixels.byteLength);
-    const pipeline = sharp(raw, {
-        raw: { width: source.width, height: source.height, channels: 4 },
-        limitInputPixels: limits.imagePixels,
-    })
-        .extract(region)
-        .resize(width, height, { kernel: 'nearest' })
-        .raw();
-    try {
-        const result = await pipeline.toBuffer({ resolveWithObject: true });
-        assertActive(signal);
-        if (result.info.channels !== 4 || result.data.byteLength !== width * height * 4)
-            throw new ClassifierError('INVALID_RESPONSE', 'Sharp returned an invalid canonical pixel view');
-        return {
-            id: view.id,
-            role: view.role,
-            sourceRegion: region,
-            width,
-            height,
-            data: result.data,
-            ...(view.grid ? { grid: view.grid } : {}),
-        };
-    }
-    finally {
-        pipeline.destroy();
-    }
-}
-function aliasesFor(view) {
-    return {
-        id: view.id,
-        role: view.role,
-        sourceRegion: view.sourceRegion,
-        ...(view.grid ? { grid: view.grid } : {}),
-    };
-}
-function gridMetadata(grid) {
-    if (!grid)
-        return undefined;
-    return {
-        cells: grid.cells.map((cell) => ({
-            id: cell.id,
-            column: cell.column,
-            row: cell.row,
-            region: cell.region,
-            label: grid.labels.get(cell.id) ?? null,
-        })),
-    };
-}
-function makePlan(groups, maxSide, encoder) {
-    const plan = [];
-    let totalBytes = 0;
-    for (const group of groups) {
-        const size = dimensions(group.sourceRegion, maxSide);
-        const metadataText = JSON.stringify({
-            representationView: {
-                id: group.aliases[0]?.id ?? group.primary.id,
-                aliases: group.aliases.map((alias) => ({
-                    id: alias.id,
-                    role: alias.role,
-                    sourceRegion: alias.sourceRegion,
-                })),
-                sourceRegion: group.sourceRegion,
-                dimensions: size,
-                scaleX: size.width / group.sourceRegion.width,
-                scaleY: size.height / group.sourceRegion.height,
-                grid: group.aliases.flatMap((alias) => {
-                    const value = gridMetadata(alias.grid);
-                    return value === undefined ? [] : [{ viewId: alias.id, cells: value.cells }];
-                }),
-            },
-        });
-        const bound = encoder.maxEncodedBytes(size.width, size.height);
-        const metadataBytes = Buffer.byteLength(metadataText, 'utf8');
-        if (!Number.isSafeInteger(bound) ||
-            bound < 0 ||
-            bound > representationLimits.partCharacters ||
-            metadataText.length > representationLimits.partCharacters)
-            return undefined;
-        totalBytes += metadataBytes + bound;
-        plan.push({ group, ...size, metadataText, maxEncodedBytes: bound });
-    }
-    return totalBytes <= representationLimits.totalBytes ? plan : undefined;
-}
-function buildGroups(views) {
-    const groups = new Map();
-    for (const view of views) {
-        const regionKey = key(view.sourceRegion);
-        const prior = groups.get(regionKey);
-        if (!prior) {
-            groups.set(regionKey, {
-                sourceRegion: view.sourceRegion,
-                primary: view,
-                aliases: [aliasesFor(view)],
-            });
-        }
-        else {
-            prior.aliases.push(aliasesFor(view));
-        }
-    }
-    return [...groups.values()];
-}
-/**
- * Build request-wide text representations from clean canonical pixels. The injected encoder
- * is intentionally internal so research codecs do not become public package exports.
- */
-export function createTextRepresentation(encoder) {
-    return {
-        async prepare(input) {
-            assertActive(input.signal);
-            if (input.views.length > representationLimits.maxViews)
-                throw new ClassifierError('RESOURCE_LIMIT', 'A representation request may contain at most nine views', {
-                    component: 'representation',
-                });
-            const groups = buildGroups(input.views);
-            for (const group of groups) {
-                if (!isContained({ left: 0, top: 0, width: input.source.width, height: input.source.height }, group.sourceRegion))
-                    throw new ClassifierError('INVALID_INPUT', 'Representation view lies outside the oriented source');
-            }
-            let plan;
-            for (let side = representationLimits.maxSide; side >= 1 && plan === undefined; side -= 1)
-                plan = makePlan(groups, side, encoder);
-            if (!plan)
-                throw new ClassifierError('RESOURCE_LIMIT', 'No bounded text representation allocation fits the request', {
-                    component: 'representation',
-                });
-            for (const item of plan)
-                for (const alias of item.group.aliases)
-                    if (alias.grid)
-                        assertGridGeometry({ ...item.group.primary, sourceRegion: item.group.sourceRegion, grid: alias.grid }, item.width, item.height);
-            const decoded = await readCanonicalPixels(input.source, input.signal);
-            const pixelViews = [];
-            for (const item of plan)
-                pixelViews.push(await cleanPixels(input.source, decoded.data, item.group.primary, item.width, item.height, input.signal));
-            const state = [];
-            const metadata = { profile: encoder.profile, bytes: 0, views: [] };
-            for (let index = 0; index < pixelViews.length; index += 1) {
-                const view = pixelViews[index];
-                const allocation = plan[index];
-                if (!view || !allocation)
-                    throw new ClassifierError('INVALID_RESPONSE', 'Text representation allocation was incomplete');
-                assertActive(input.signal);
-                state.push(allocation.metadataText);
-                metadata.bytes += Buffer.byteLength(allocation.metadataText, 'utf8');
-                let text;
-                try {
-                    text = await encoder.encode(view, input.signal);
-                }
-                catch (error) {
-                    if (error instanceof ClassifierError && error.code === 'RESOURCE_LIMIT')
-                        throw new ClassifierError(error.code, error.message, {
-                            ...error.details,
-                            component: 'representation',
-                        });
-                    throw error;
-                }
-                const bytes = Buffer.byteLength(text, 'utf8');
-                if (text.length > representationLimits.partCharacters || bytes > allocation.maxEncodedBytes)
-                    throw new ClassifierError('RESOURCE_LIMIT', 'Encoder output exceeds its declared per-view bound', {
-                        component: 'representation',
-                    });
-                if (metadata.bytes + bytes > representationLimits.totalBytes)
-                    throw new ClassifierError('RESOURCE_LIMIT', 'Encoded request exceeds the aggregate UTF-8 byte limit', {
-                        component: 'representation',
-                    });
-                metadata.bytes += bytes;
-                state.push(text);
-                metadata.views.push({
-                    id: view.id,
-                    sourceRegion: view.sourceRegion,
-                    width: view.width,
-                    height: view.height,
-                    scaleX: view.width / view.sourceRegion.width,
-                    scaleY: view.height / view.sourceRegion.height,
-                    content: { left: 0, top: 0, width: view.width, height: view.height },
-                });
-            }
-            return { state, metadata };
-        },
-    };
-}