zorya-classifier 0.2.2 → 0.2.3

package/README.md

@@ -2,7 +2,21 @@
 
 [![npm version](https://img.shields.io/npm/v/zorya-classifier)](https://www.npmjs.com/package/zorya-classifier)
 
-Provider-independent text/image classification for Node.js and TypeScript, with experimental, unqualified spatial localization and object extraction. MIT application code. The library never selects or connects a model for you: create a client with an explicit `DecisionPort`, either injected by your application or built with an adapter you configure. The model and provider shown in examples are examples, not defaults. Ordinary vision language models and native decision APIs are both supported for closed classification.
+> **More complete object boxes without fine-tuning in this DEV pilot: H8a 7/9 vs native Jev 1.14 3/9**
+>
+> One exposed pilot compares a historical H8a run with one new Jev run: 12 tasks across 9 unique source images (the four UI targets share one screenshot), 9 tasks with the target and 3 without. **H8a** uses existing mask candidates with an explicitly configured OpenAI **gpt-6-luna** vision route; no fine-tuning was done for this comparison. **Jev 1.14** uses native Box+Noul and returns rectangles, not segmentation masks. The strict box criterion requires IoU ≥0.5 **and** at least 90% coverage of the same reference box. This is a development pilot, not a heldout qualification.
+>
+> | Measure                                           | H8a              | Jev 1.14      |
+> | ------------------------------------------------- | ---------------- | ------------- |
+> | Strict box criterion                              | 7/9              | 3/9           |
+> | IoU ≥0.5 only (secondary, not the gate)           | 7/9              | 8/9           |
+> | False outputs on 3 absent cases (lower is better) | 2/3 (Bowl, Undo) | 1/3 (Fighter) |
+>
+> [Full report (RU)](https://github.com/zoomplus/zorya-classifier/blob/v0.2.3/docs/research/v03-jev-native-box-results.ru.md) · [Evidence JSON](https://github.com/zoomplus/zorya-classifier/blob/v0.2.3/docs/evidence/v03/jev-native-box-dev12-20261025.json) · [Download visual comparison ZIP](https://github.com/zoomplus/zorya-classifier/releases/download/v0.2.3/jev-native-box-dev12-comparison.zip)
+>
+> H8a is a research/benchmark recipe only: it is not the default `locate`/`extract` path and is not an H8 strategy shipped in npm. This small pilot makes no general accuracy claim.
+
+Provider-independent text/image classification for Node.js and TypeScript, with available spatial localization and object extraction APIs. MIT application code. The library never selects or connects a model for you: create a client with an explicit `DecisionPort`, either injected by your application or built with an adapter you configure. The model and provider shown in examples are examples, not defaults. Ordinary vision language models and native decision APIs are both supported for closed classification.
 
 Use an explicitly configured image-capable model through a supported adapter, or implement the small `DecisionPort` for another protocol. OpenRouter is an optional adapter, not a mandatory service. A more capable model may help on a task, but model strength does not guarantee a monotonic accuracy improvement. Compatibility and quality vary; see the exact [tested models/results](docs/vision-results.md), [acceptance](docs/acceptance.md), and historical [Jev baseline](docs/results.md).
 
@@ -22,21 +36,21 @@ Node.js 22.12+ is required. Source: [zoomplus/zorya-classifier](https://github.c
 npm install zorya-classifier
 ```
 
-The release archive also installs with `npm install ./zorya-classifier-0.2.0.tgz` (filename follows `package.json` version; not a claim of a newly published release). Runtime dependencies are Zod and Sharp; model weights, Electron, a database and background services are not included. Optional local segmentation backends and their model assets are a separate responsibility of the caller; the library does not download or choose them.
+The release archive also installs with `npm install ./zorya-classifier-0.2.3.tgz` (filename follows `package.json` version). Runtime dependencies are Zod and Sharp; model weights, Electron, a database and background services are not included. Optional local segmentation backends and their model assets are a separate responsibility of the caller; the library does not download or choose them.
 
 ## Capability and status
 
-Further accuracy experiments on spatial workflows are stopped; no localization, extraction, or proposal strategy is promoted for general use. Historical metrics below and in `docs/evidence/**` are preserved as recorded.
+Spatial APIs are implemented and documented; the [H8a vs Jev DEV12 box comparison](https://github.com/zoomplus/zorya-classifier/blob/v0.2.3/docs/research/v03-jev-native-box-results.ru.md) is one research recipe, not a promoted default. Historical metrics below and in `docs/evidence/**` are preserved as recorded.
 
-| Capability                                                      | Status       | Notes                                                                 |
-| --------------------------------------------------------------- | ------------ | --------------------------------------------------------------------- |
-| `classify` with an explicit `DecisionPort` / supported adapters | Supported    | Closed class ID; no universal model accuracy claim                    |
-| Default `locate` (region grid search)                           | Experimental | Hypothesized grid cell, not whole-object geometry or proof of absence |
-| `RefinementPort`                                                | Experimental | No general quality qualification                                      |
-| `locate({ mode: 'whole-object' })`                              | Experimental | Interval or segmentation paths; unqualified                           |
-| `extract`, `SegmentationPort`, box-check composition            | Experimental | Structural checks ≠ semantic object or mask quality                   |
-| `objectProposals` / native segmentation factories               | Experimental | Caller-owned; unqualified                                             |
-| `representation: { type: 'experimental-text', … }`              | Rejected     | `UNSUPPORTED` until a profile qualifies                               |
+| Capability                                                      | Status    | Notes                                                                                |
+| --------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| `classify` with an explicit `DecisionPort` / supported adapters | Supported | Closed class ID; no universal model accuracy claim                                   |
+| Default `locate` (region grid search)                           | Available | Hypothesized grid cell, not whole-object geometry or proof of absence                |
+| `RefinementPort`                                                | Available | Optional legacy hook; caller-owned                                                   |
+| `locate({ mode: 'whole-object' })`                              | Available | Interval or caller segmentation paths                                                |
+| `extract`, `SegmentationPort`, box-check composition            | Available | Structural checks ≠ semantic object or mask quality                                  |
+| `objectProposals` / native segmentation factories               | Available | Caller-owned; model/runtime assets remain caller-supplied                            |
+| `representation: { type: 'experimental-text', … }`              | Removed   | Public input fails strict validation (`INVALID_INPUT`); encoders stay benchmark-only |
 
 Heldout region-seeded metrics (one documented recipe, not universal): 26/60 positive coarse seed hits; 8/60 complete whole-object boxes; 0 false seeds on 20 negatives. Among 30 exact-canvas masks: 8 reached IoU 0.8, 3 failed, 19 had no predicted mask. H8 DEV reported 7/9 positives with 2/3 false outputs and did not qualify. A narrow historical admission pass is not broad spatial qualification.
 
@@ -117,9 +131,9 @@ try {
 
 Supply the **full trusted chat-completions URL**, such as your local `http://localhost:8000/v1/chat/completions`, and the actual deployed model ID. Anonymous local servers can omit the key; custom headers support other authentication. These are integration examples, not a claim that every provider/model has been live-qualified. Other wire protocols can implement the exported `DecisionPort`. Keep keys on a trusted server, outside frontend bundles and Git.
 
-## Locate an object (experimental)
+## Locate an object
 
-Default region `locate` is experimental and unqualified. With either configured client:
+Default region `locate` is available; a returned cell is not whole-object geometry. With either configured client:
 
 ```ts
 const result = await client.locate({
@@ -133,9 +147,9 @@ if (result.status === 'located') console.log(result.region)
 
 The locator uses up to three sequential calls: coarse 4×4 regions, fine grids in four padded regions, then four enlarged candidates. Coordinates come from code, never free-form model coordinates. Ordinary-model rankings select candidates; independent present/absent/unknown answers govern abstention. Multiple matching physical instances are allowed; one candidate is returned. Localization requires the model/endpoint to accept multiple images per call (up to nine); single-image-only endpoints can still support `classify`.
 
-## Extract a mask-derived object (experimental)
+## Extract a mask-derived object
 
-Extraction and caller-owned segmentation are experimental and unqualified. For a visible object box, center, or transparent cutout, use `extract` with an explicitly configured caller-owned segmenter. The existing region locator supplies a seed; the segmenter receives that seed while processing the full oriented source image. The library derives the returned box and center from actual mask pixels only. After segmentation, the caller's decision port checks the full source with the mask-derived box and original seed anchor: `complete` yields the result (optional cutout); `needs-expansion` allows at most one enclosing-mask expansion and one final check (a final `complete` can still produce the result); unresolved checks, missing expansion support, no valid enclosing mask, or a failed final check yield `unknown` with no second expansion. Crops, resize and padding preserve source/mask alignment; box-check rendering uses injected `RasterPort.imageState` on the full canvas. This adds one or two closed checks to the normal region requests, without model-generated coordinates or an extent search. See the [0.2 usage guide](docs/v02-usage.md) and runnable [`extract-object.ts`](https://github.com/zoomplus/zorya-classifier/blob/main/examples/extract-object.ts). The classifier and segmenter are separately caller-owned and both must be disposed.
+Extraction uses caller-owned segmentation; mask quality and box checks measure different things. For a visible object box, center, or transparent cutout, use `extract` with an explicitly configured caller-owned segmenter. The existing region locator supplies a seed; the segmenter receives that seed while processing the full oriented source image. The library derives the returned box and center from actual mask pixels only. After segmentation, the caller's decision port checks the full source with the mask-derived box and original seed anchor: `complete` yields the result (optional cutout); `needs-expansion` allows at most one enclosing-mask expansion and one final check (a final `complete` can still produce the result); unresolved checks, missing expansion support, no valid enclosing mask, or a failed final check yield `unknown` with no second expansion. Crops, resize and padding preserve source/mask alignment; box-check rendering uses injected `RasterPort.imageState` on the full canvas. This adds one or two closed checks to the normal region requests, without model-generated coordinates or an extent search. See the [0.2 usage guide](docs/v02-usage.md) and runnable [`extract-object.ts`](https://github.com/zoomplus/zorya-classifier/blob/main/examples/extract-object.ts). The classifier and segmenter are separately caller-owned and both must be disposed.
 
 ## Development and limits
 

package/dist/app/classifier-contracts.d.ts

@@ -9,24 +9,24 @@ export interface ClassifierOptions {
     concurrency?: number;
     maxQueue?: number;
     maxInputBytes?: number;
-    /** @experimental Optional legacy region refinement; unqualified for general use. */
+    /** Optional legacy region refinement. */
     refinement?: RefinementPort;
-    /** Caller-owned; classifier disposal never disposes a shared segmenter. @experimental Unqualified segmentation adapter. */
+    /** Caller-owned; classifier disposal never disposes a shared segmenter. Segmentation adapter; structural checks do not establish semantic mask quality. */
     segmentation?: SegmentationPort;
-    /** Optional caller-owned containment checker; by default reuses the injected decision port. @experimental Unqualified box-check override. */
+    /** Optional caller-owned containment checker; by default reuses the injected decision port. Box-check override; verdicts are not universal spatial guarantees. */
     segmentationBoxCheck?: SegmentationBoxCheckPort;
-    /** Explicit, caller-owned pixel-mask proposal strategy for whole-object operations. @experimental Unqualified proposal path. */
+    /** Explicit, caller-owned pixel-mask proposal strategy for whole-object operations. */
     objectProposals?: ObjectProposalPort;
 }
 export interface Classifier {
     classify(input: ClassifyInput): Promise<ClassificationResult>;
-    /** @experimental Unqualified spatial localization; see {@link LocateInput} and {@link WholeObjectLocateInput}. */
+    /** Spatial localization; see {@link LocateInput} and {@link WholeObjectLocateInput}. */
     locate(input: WholeObjectLocateInput): Promise<WholeObjectLocalizationResult>;
-    /** @experimental Unqualified coarse region search; returns a hypothesized grid cell. */
+    /** Coarse region search; returns a hypothesized grid cell, not whole-object geometry. */
     locate(input: LocateInput): Promise<LocalizationResult>;
-    /** @experimental Unqualified spatial localization. */
+    /** Spatial localization. */
     locate(input: AnyLocateInput): Promise<LocalizationResult | WholeObjectLocalizationResult>;
-    /** @experimental Region-seeded extraction; unqualified for general mask or object accuracy. */
+    /** Region-seeded extraction; mask and box checks measure different things than semantic object accuracy. */
     extract(input: ExtractInput): Promise<ExtractionResult>;
     dispose(): Promise<void>;
 }

package/dist/app/composed-classifier.d.ts

@@ -0,0 +1,17 @@
+import type { ClassificationResult, ClassifyInput, LocalizationResult, LocateInput, Representation } from '../entities/contracts.js';
+import type { ExtractInput, ExtractionResult } from '../entities/segmentation.js';
+import type { AnyLocateInput, WholeObjectLocateInput, WholeObjectLocalizationResult } from '../entities/whole-object.js';
+export type WithRepresentationField<T extends {
+    representation?: unknown;
+}, R> = Omit<T, 'representation'> & {
+    representation?: R | undefined;
+};
+/** Internal composition surface; not exported from the public package entry. */
+export type ComposedClassifier<R = Representation> = {
+    classify(input: WithRepresentationField<ClassifyInput, R>): Promise<ClassificationResult>;
+    locate(input: WithRepresentationField<WholeObjectLocateInput, R>): Promise<WholeObjectLocalizationResult>;
+    locate(input: WithRepresentationField<LocateInput, R>): Promise<LocalizationResult>;
+    locate(input: WithRepresentationField<AnyLocateInput, R>): Promise<LocalizationResult | WholeObjectLocalizationResult>;
+    extract(input: WithRepresentationField<ExtractInput, R>): Promise<ExtractionResult>;
+    dispose(): Promise<void>;
+};

package/dist/app/composed-classifier.js

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

package/dist/app/create-classifier.d.ts

@@ -1,8 +1,14 @@
+import type { Representation } from '../entities/contracts.js';
 import type { WholeObjectIntervalPolicy } from '../processes/whole-object.js';
 import type { ImageRepresentationPort } from '../entities/representation.js';
 import type { BoundaryViewPort } from '../entities/boundary-view.js';
 import type { Classifier, ClassifierOptions } from './classifier-contracts.js';
+import type { ComposedClassifier } from './composed-classifier.js';
 export type { Classifier, ClassifierOptions } from './classifier-contracts.js';
+interface ResearchRepresentationHook {
+    representationPort: ImageRepresentationPort;
+    acceptsRepresentation(raw: unknown): boolean;
+}
 export declare function createClassifier(options: ClassifierOptions): Classifier;
 /** Internal composition seam for benchmark helpers; not re-exported from public entry points. */
-export declare function composeClassifier(options: ClassifierOptions, experimental?: ImageRepresentationPort, boundaryView?: BoundaryViewPort, intervalPolicy?: WholeObjectIntervalPolicy): Classifier;
+export declare function composeClassifier<R = Representation>(options: ClassifierOptions, research?: ResearchRepresentationHook, boundaryView?: BoundaryViewPort, intervalPolicy?: WholeObjectIntervalPolicy): ComposedClassifier<R>;

package/dist/app/create-classifier.js

@@ -10,14 +10,23 @@ import { createSharpObjectProposalPresentation } from '../infrastructure/segment
 import { createSegmentationBoxCheck } from '../features/segmentation/box-check.js';
 import { createSharpSegmentationBoxPresentation } from '../infrastructure/segmentation/box-presentation.js';
 import { validateClassifierOptions } from './classifier-config.js';
-import { createClassifierRepresentation } from './classifier-representation.js';
 import { createClassifierRuntime, parseOperationSignal } from './classifier-runtime.js';
 import { createClassifierSpatial } from './classifier-spatial.js';
+function prepareResearchOperationInput(rest, research) {
+    if (!research || rest.representation === undefined)
+        return { rest, port: undefined };
+    if (!research.acceptsRepresentation(rest.representation))
+        return { rest, port: undefined };
+    return {
+        rest: { ...rest, representation: { type: 'vision' } },
+        port: research.representationPort,
+    };
+}
 export function createClassifier(options) {
     return composeClassifier(options);
 }
 /** Internal composition seam for benchmark helpers; not re-exported from public entry points. */
-export function composeClassifier(options, experimental, boundaryView, intervalPolicy) {
+export function composeClassifier(options, research, boundaryView, intervalPolicy) {
     const { config, ports } = validateClassifierOptions(options);
     const { segmenter, objectProposals } = ports;
     const runtime = createClassifierRuntime(config);
@@ -40,7 +49,6 @@ export function composeClassifier(options, experimental, boundaryView, intervalP
             presentation: createSharpObjectProposalPresentation(),
         }
         : undefined;
-    const { representationFor } = createClassifierRepresentation(experimental);
     const spatial = createClassifierSpatial({
         getDecision: () => options.decision,
         raster,
@@ -57,14 +65,13 @@ export function composeClassifier(options, experimental, boundaryView, intervalP
             throw new ClassifierError('INVALID_INPUT', 'Expected locate input object');
         const { signal, ...rest } = input;
         const parent = parseOperationSignal(signal);
-        if (rest.mode === 'whole-object') {
-            const parsed = parse(wholeObjectSchema, rest);
-            const representation = representationFor(parsed.representation);
-            return runtime.withOwnedInput(parsed.image.byteLength, parent, () => ({ ...parsed, image: new Uint8Array(parsed.image) }), (snapshot, s) => spatial.locateWhole(snapshot, s, representation));
+        const { rest: rewritten, port } = prepareResearchOperationInput(rest, research);
+        if (rewritten.mode === 'whole-object') {
+            const parsed = parse(wholeObjectSchema, rewritten);
+            return runtime.withOwnedInput(parsed.image.byteLength, parent, () => ({ ...parsed, image: new Uint8Array(parsed.image) }), (snapshot, s) => spatial.locateWhole(snapshot, s, port));
         }
-        const parsed = parse(locateSchema, rest);
-        const representation = representationFor(parsed.representation);
-        return runtime.withOwnedInput(parsed.image.byteLength, parent, () => ({ ...parsed, image: new Uint8Array(parsed.image) }), (snapshot, s) => locateInput(snapshot, options.decision, raster, s, options.refinement, representation));
+        const parsed = parse(locateSchema, rewritten);
+        return runtime.withOwnedInput(parsed.image.byteLength, parent, () => ({ ...parsed, image: new Uint8Array(parsed.image) }), (snapshot, s) => locateInput(snapshot, options.decision, raster, s, options.refinement, port));
     }
     return {
         async classify(input) {
@@ -73,9 +80,10 @@ export function composeClassifier(options, experimental, boundaryView, intervalP
                 throw new ClassifierError('INVALID_INPUT', 'Expected classify input object');
             const { signal, ...rest } = input;
             const parent = parseOperationSignal(signal);
-            const parsed = parse(classifySchema, rest);
+            const { rest: rewritten, port } = prepareResearchOperationInput(rest, research);
+            const parsed = parse(classifySchema, rewritten);
             const hasImage = typeof parsed.input !== 'string' && parsed.input.image !== undefined;
-            const representation = hasImage ? representationFor(parsed.representation) : undefined;
+            const representation = hasImage ? port : undefined;
             const byteCount = typeof parsed.input === 'string'
                 ? Buffer.byteLength(parsed.input)
                 : (parsed.input.image?.byteLength ?? 0) + Buffer.byteLength(parsed.input.text ?? '');
@@ -97,14 +105,14 @@ export function composeClassifier(options, experimental, boundaryView, intervalP
                 throw new ClassifierError('INVALID_INPUT', 'Expected extract input object');
             const { signal, ...rest } = input;
             const parent = parseOperationSignal(signal);
-            const parsed = parse(extractSchema, rest);
+            const { rest: rewritten, port } = prepareResearchOperationInput(rest, research);
+            const parsed = parse(extractSchema, rewritten);
             if (!segmenter && !proposalDependencies)
                 throw new ClassifierError('UNSUPPORTED', 'extract requires an explicit SegmentationPort or ObjectProposalPort');
-            const representation = representationFor(parsed.representation);
             return runtime.withOwnedInput(parsed.image.byteLength, parent, () => ({ ...parsed, image: new Uint8Array(parsed.image) }), (snapshot, s) => {
                 if (segmenter)
-                    return spatial.extractRegion(snapshot, s, representation);
-                return spatial.extractWithProposals(snapshot, s, representation);
+                    return spatial.extractRegion(snapshot, s, port);
+                return spatial.extractWithProposals(snapshot, s, port);
             });
         },
         dispose: () => runtime.dispose(),

package/dist/cli.js

@@ -8,7 +8,7 @@ import { createMobileSamSegmenter, createGrabCutSegmenter } from './segmentation
 async function main() {
     const args = parseCliArguments(process.argv.slice(2));
     if (args.command === 'help') {
-        console.log('zorya-classifier classify-text <text> <classes.json>\nzorya-classifier classify-image <image> <classes.json>\nzorya-classifier locate <image> <target> [--mode region|whole-object]  (experimental, unqualified spatial search)\nzorya-classifier extract <image> <target> --output <prefix> --backend mobile-sam --encoder <path> --decoder <path> [--provider cpu|dml]  (experimental extraction)\nzorya-classifier extract <image> <target> --output <prefix> --backend grabcut --opencv <path>  (experimental extraction)\nSet ZORYA_MODEL. Default ZORYA_MODE=decisions; use chat for ordinary vision models/custom chat endpoints. OpenRouter: OPENROUTER_API_KEY + ZORYA_PROVIDER. Direct: ZORYA_ENDPOINT + optional ZORYA_API_KEY. Optional ZORYA_REASONING_EFFORT and ZORYA_RESPONSE_FORMAT. classify is supported; locate/extract/object backends are experimental and not qualified for general use. One classify request; up to three region or six whole-object requests. Extraction additionally runs the explicit local backend. Output files are never overwritten; native assets are never downloaded automatically.');
+        console.log('zorya-classifier classify-text <text> <classes.json>\nzorya-classifier classify-image <image> <classes.json>\nzorya-classifier locate <image> <target> [--mode region|whole-object]  (spatial search; grid cells are not whole-object boxes)\nzorya-classifier extract <image> <target> --output <prefix> --backend mobile-sam --encoder <path> --decoder <path> [--provider cpu|dml]  (extraction with caller-owned backend)\nzorya-classifier extract <image> <target> --output <prefix> --backend grabcut --opencv <path>  (extraction with caller-owned backend)\nSet ZORYA_MODEL. Default ZORYA_MODE=decisions; use chat for ordinary vision models/custom chat endpoints. OpenRouter: OPENROUTER_API_KEY + ZORYA_PROVIDER. Direct: ZORYA_ENDPOINT + optional ZORYA_API_KEY. Optional ZORYA_REASONING_EFFORT and ZORYA_RESPONSE_FORMAT. classify is supported; locate/extract/object backends are available—model, provider and native assets remain caller-supplied. One classify request; up to three region or six whole-object requests. Extraction additionally runs the explicit local backend. Output files are never overwritten; native assets are never downloaded automatically.');
         return;
     }
     const { command, value, target } = args;

package/dist/entities/classification.d.ts

@@ -44,22 +44,13 @@ export declare const classifySchema: z.ZodObject<{
         description: string;
     }[]>;
     instructions: z.ZodOptional<z.ZodString>;
-    representation: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    representation: z.ZodOptional<z.ZodObject<{
         type: z.ZodLiteral<"vision">;
     }, "strict", z.ZodTypeAny, {
         type: "vision";
     }, {
         type: "vision";
-    }>, z.ZodObject<{
-        type: z.ZodLiteral<"experimental-text">;
-        profile: z.ZodLiteral<"text-image-v1">;
-    }, "strict", z.ZodTypeAny, {
-        type: "experimental-text";
-        profile: "text-image-v1";
-    }, {
-        type: "experimental-text";
-        profile: "text-image-v1";
-    }>]>>;
+    }>>;
 }, "strict", z.ZodTypeAny, {
     input: string | {
         text?: string | undefined;
@@ -72,9 +63,6 @@ export declare const classifySchema: z.ZodObject<{
     instructions?: string | undefined;
     representation?: {
         type: "vision";
-    } | {
-        type: "experimental-text";
-        profile: "text-image-v1";
     } | undefined;
 }, {
     input: string | {
@@ -88,9 +76,6 @@ export declare const classifySchema: z.ZodObject<{
     instructions?: string | undefined;
     representation?: {
         type: "vision";
-    } | {
-        type: "experimental-text";
-        profile: "text-image-v1";
     } | undefined;
 }>;
 export type ClassifyInput = z.input<typeof classifySchema> & {

package/dist/entities/image.d.ts

@@ -9,22 +9,13 @@ export declare const limits: Readonly<{
     maxImages: 9;
 }>;
 export declare const imageSchema: z.ZodEffects<z.ZodType<Uint8Array<ArrayBufferLike>, z.ZodTypeDef, Uint8Array<ArrayBufferLike>>, Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
-export declare const representationSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+export declare const representationSchema: z.ZodObject<{
     type: z.ZodLiteral<"vision">;
 }, "strict", z.ZodTypeAny, {
     type: "vision";
 }, {
     type: "vision";
-}>, z.ZodObject<{
-    type: z.ZodLiteral<"experimental-text">;
-    profile: z.ZodLiteral<"text-image-v1">;
-}, "strict", z.ZodTypeAny, {
-    type: "experimental-text";
-    profile: "text-image-v1";
-}, {
-    type: "experimental-text";
-    profile: "text-image-v1";
-}>]>;
+}>;
 export type Representation = z.infer<typeof representationSchema>;
 export interface RasterImage {
     bytes: Uint8Array;

package/dist/entities/image.js

@@ -9,7 +9,4 @@ export const limits = Object.freeze({
 export const imageSchema = z
     .custom((value) => value instanceof Uint8Array)
     .refine((v) => v.byteLength > 0 && v.byteLength <= limits.imageBytes, 'Expected 1..16MiB image bytes');
-export const representationSchema = z.discriminatedUnion('type', [
-    z.object({ type: z.literal('vision') }).strict(),
-    z.object({ type: z.literal('experimental-text'), profile: z.literal('text-image-v1') }).strict(),
-]);
+export const representationSchema = z.object({ type: z.literal('vision') }).strict();

package/dist/entities/localization.d.ts

@@ -22,31 +22,19 @@ export declare const locateSchema: z.ZodObject<{
         height: number;
     }>>;
     mode: z.ZodOptional<z.ZodLiteral<"region">>;
-    representation: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    representation: z.ZodOptional<z.ZodObject<{
         type: z.ZodLiteral<"vision">;
     }, "strict", z.ZodTypeAny, {
         type: "vision";
     }, {
         type: "vision";
-    }>, z.ZodObject<{
-        type: z.ZodLiteral<"experimental-text">;
-        profile: z.ZodLiteral<"text-image-v1">;
-    }, "strict", z.ZodTypeAny, {
-        type: "experimental-text";
-        profile: "text-image-v1";
-    }, {
-        type: "experimental-text";
-        profile: "text-image-v1";
-    }>]>>;
+    }>>;
 }, "strict", z.ZodTypeAny, {
     image: Uint8Array<ArrayBufferLike>;
     target: string;
     exclusions: string[];
     representation?: {
         type: "vision";
-    } | {
-        type: "experimental-text";
-        profile: "text-image-v1";
     } | undefined;
     roi?: {
         left: number;
@@ -60,9 +48,6 @@ export declare const locateSchema: z.ZodObject<{
     target: string;
     representation?: {
         type: "vision";
-    } | {
-        type: "experimental-text";
-        profile: "text-image-v1";
     } | undefined;
     exclusions?: string[] | undefined;
     roi?: {
@@ -73,7 +58,7 @@ export declare const locateSchema: z.ZodObject<{
     } | undefined;
     mode?: "region" | undefined;
 }>;
-/** @experimental Unqualified coarse region search; a located grid cell is a hypothesis, not reliable whole-object geometry or proof of absence. */
+/** Coarse region search; a located grid cell is a hypothesis, not reliable whole-object geometry or proof of absence. */
 export type LocateInput = z.input<typeof locateSchema> & {
     signal?: AbortSignal;
 };
@@ -88,7 +73,7 @@ export interface LocalizationMetadata {
     knownCostUsd: number;
     unknownCostCount: number;
 }
-/** @experimental Outcome of unqualified spatial localization; grid regions are not semantic object boxes or masks. */
+/** Outcome of spatial localization; grid regions are not semantic object boxes or masks. */
 export type LocalizationResult = ({
     status: 'located';
     region: PixelRect;
@@ -105,7 +90,7 @@ export type LocalizationResult = ({
 }) & {
     metadata: LocalizationMetadata;
 };
-/** @experimental Optional legacy region refinement with no general quality qualification. */
+/** Optional legacy region refinement. */
 export type RefinementResult = {
     status: 'refined';
     region: PixelRect;
@@ -114,7 +99,7 @@ export type RefinementResult = {
     status: 'unknown';
     reason: string;
 };
-/** @experimental Caller-owned refinement hook; unqualified for general spatial accuracy. */
+/** Caller-owned refinement hook. */
 export interface RefinementPort {
     refine(input: {
         image: Uint8Array;

package/dist/entities/object-proposals.d.ts

@@ -35,7 +35,7 @@ export interface ObjectProposalBatch {
 }
 /**
  * Caller-owned. propose settles only after physical work closes; no model calls here.
- * @experimental Mask proposal strategy with no general quality qualification.
+ * Mask proposal strategy; no general quality qualification is implied.
  */
 export interface ObjectProposalPort {
     propose(input: ObjectProposalInput): Promise<ObjectProposalBatch>;

package/dist/entities/representation.d.ts

@@ -1,5 +1,4 @@
 import type { DecisionState, GridCell, PixelRect, RasterImage } from './contracts.js';
-import { z } from 'zod';
 /** Canonical oriented RGBA8. Alpha remains meaningful; transparent is not black. */
 export interface RgbaRaster {
     data: Uint8Array;
@@ -41,185 +40,3 @@ export interface ImageRepresentationPort {
         metadata: RepresentationMetadata;
     }>;
 }
-export declare const representationLimits: Readonly<{
-    totalBytes: number;
-    partCharacters: 64000;
-    maxSide: 64;
-    maxViews: 9;
-}>;
-export declare const preparedTextSchema: z.ZodObject<{
-    state: z.ZodArray<z.ZodString, "many">;
-    metadata: z.ZodObject<{
-        profile: z.ZodString;
-        bytes: z.ZodNumber;
-        views: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            sourceRegion: z.ZodObject<{
-                left: z.ZodNumber;
-                top: z.ZodNumber;
-                width: z.ZodNumber;
-                height: z.ZodNumber;
-            }, "strict", z.ZodTypeAny, {
-                left: number;
-                top: number;
-                width: number;
-                height: number;
-            }, {
-                left: number;
-                top: number;
-                width: number;
-                height: number;
-            }>;
-            width: z.ZodNumber;
-            height: z.ZodNumber;
-            scaleX: z.ZodNumber;
-            scaleY: z.ZodNumber;
-            content: z.ZodOptional<z.ZodObject<{
-                left: z.ZodNumber;
-                top: z.ZodNumber;
-                width: z.ZodNumber;
-                height: z.ZodNumber;
-            }, "strict", z.ZodTypeAny, {
-                left: number;
-                top: number;
-                width: number;
-                height: number;
-            }, {
-                left: number;
-                top: number;
-                width: number;
-                height: number;
-            }>>;
-        }, "strict", z.ZodTypeAny, {
-            width: number;
-            height: number;
-            id: string;
-            sourceRegion: {
-                left: number;
-                top: number;
-                width: number;
-                height: number;
-            };
-            scaleX: number;
-            scaleY: number;
-            content?: {
-                left: number;
-                top: number;
-                width: number;
-                height: number;
-            } | undefined;
-        }, {
-            width: number;
-            height: number;
-            id: string;
-            sourceRegion: {
-                left: number;
-                top: number;
-                width: number;
-                height: number;
-            };
-            scaleX: number;
-            scaleY: number;
-            content?: {
-                left: number;
-                top: number;
-                width: number;
-                height: number;
-            } | undefined;
-        }>, "many">;
-    }, "strict", z.ZodTypeAny, {
-        profile: string;
-        bytes: number;
-        views: {
-            width: number;
-            height: number;
-            id: string;
-            sourceRegion: {
-                left: number;
-                top: number;
-                width: number;
-                height: number;
-            };
-            scaleX: number;
-            scaleY: number;
-            content?: {
-                left: number;
-                top: number;
-                width: number;
-                height: number;
-            } | undefined;
-        }[];
-    }, {
-        profile: string;
-        bytes: number;
-        views: {
-            width: number;
-            height: number;
-            id: string;
-            sourceRegion: {
-                left: number;
-                top: number;
-                width: number;
-                height: number;
-            };
-            scaleX: number;
-            scaleY: number;
-            content?: {
-                left: number;
-                top: number;
-                width: number;
-                height: number;
-            } | undefined;
-        }[];
-    }>;
-}, "strict", z.ZodTypeAny, {
-    metadata: {
-        profile: string;
-        bytes: number;
-        views: {
-            width: number;
-            height: number;
-            id: string;
-            sourceRegion: {
-                left: number;
-                top: number;
-                width: number;
-                height: number;
-            };
-            scaleX: number;
-            scaleY: number;
-            content?: {
-                left: number;
-                top: number;
-                width: number;
-                height: number;
-            } | undefined;
-        }[];
-    };
-    state: string[];
-}, {
-    metadata: {
-        profile: string;
-        bytes: number;
-        views: {
-            width: number;
-            height: number;
-            id: string;
-            sourceRegion: {
-                left: number;
-                top: number;
-                width: number;
-                height: number;
-            };
-            scaleX: number;
-            scaleY: number;
-            content?: {
-                left: number;
-                top: number;
-                width: number;
-                height: number;
-            } | undefined;
-        }[];
-    };
-    state: string[];
-}>;