@qvac/sdk 0.14.1 → 0.16.0

package/dist/server/bare/plugins/bci-whispercpp-transcription/plugin.js

@@ -1,11 +1,11 @@
-import bciAddonLogging from "@qvac/bci-whispercpp/addonLogging.js";
-import BCIWhispercpp, {} from "@qvac/bci-whispercpp";
-import { definePlugin, defineHandler, defineDuplexHandler, bciTranscribeRequestSchema, bciTranscribeResponseSchema, bciTranscribeStreamRequestSchema, bciTranscribeStreamResponseSchema, ModelType, bciConfigSchema, ADDON_BCI, } from "../../../../schemas/index.js";
-import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
-import { bciTranscribe, bciTranscribeStream, } from "../../ops/bci-transcribe.js";
-import { attachModelExecutionMs } from "../../../../profiling/model-execution.js";
-import { buildBciWhispercppArgs } from "./args.js";
-import { resolveBciConfig } from "./resolve-config.js";
+import bciAddonLogging from '@qvac/bci-whispercpp/addonLogging.js';
+import BCIWhispercpp, {} from '@qvac/bci-whispercpp';
+import { definePlugin, defineHandler, defineDuplexHandler, bciTranscribeRequestSchema, bciTranscribeResponseSchema, bciTranscribeStreamRequestSchema, bciTranscribeStreamResponseSchema, ModelType, bciConfigSchema, ADDON_BCI } from '../../../../schemas/index.js';
+import { createStreamLogger, registerAddonLogger } from '../../../../logging/index.js';
+import { bciTranscribe, bciTranscribeStream } from '../../ops/bci-transcribe.js';
+import { attachModelExecutionMs } from '../../../../profiling/model-execution.js';
+import { buildBciWhispercppArgs } from './args.js';
+import { resolveBciConfig } from './resolve-config.js';
 function createBciModel(modelId, modelPath, bciConfig, embedderPath) {
     const logger = createStreamLogger(modelId, ModelType.bciWhispercppTranscription);
     registerAddonLogger(modelId, ModelType.bciWhispercppTranscription, logger);
@@ -15,13 +15,13 @@ function createBciModel(modelId, modelPath, bciConfig, embedderPath) {
 }
 export const bciPlugin = definePlugin({
     modelType: ModelType.bciWhispercppTranscription,
-    displayName: "BCI (whisper.cpp)",
+    displayName: 'BCI (whisper.cpp)',
     addonPackage: ADDON_BCI,
     loadConfigSchema: bciConfigSchema,
     resolveConfig: resolveBciConfig,
     createModel(params) {
         const bciConfig = (params.modelConfig ?? {});
-        const { model } = createBciModel(params.modelId, params.modelPath, bciConfig, params.artifacts?.["embedderPath"] ?? "");
+        const { model } = createBciModel(params.modelId, params.modelPath, bciConfig, params.artifacts?.['embedderPath'] ?? '');
         return { model };
     },
     handlers: {
@@ -31,45 +31,45 @@ export const bciPlugin = definePlugin({
             streaming: true,
             // The BCI addon exposes a model-wide hard cancel — the running
             // neural-signal job is interrupted on `cancel()`.
-            cancel: { scope: "model", hard: true },
+            cancel: { scope: 'model', hard: true },
             handler: async function* (request) {
                 const metadata = request.metadata === true;
                 const stream = metadata
                     ? bciTranscribe({
                         modelId: request.modelId,
                         neuralData: request.neuralData,
-                        metadata: true,
+                        metadata: true
                     }, request.requestId)
                     : bciTranscribe({
                         modelId: request.modelId,
-                        neuralData: request.neuralData,
+                        neuralData: request.neuralData
                     }, request.requestId);
                 try {
                     let result = await stream.next();
                     while (!result.done) {
                         yield metadata
                             ? {
-                                type: "bciTranscribe",
-                                segment: result.value,
+                                type: 'bciTranscribe',
+                                segment: result.value
                             }
                             : {
-                                type: "bciTranscribe",
-                                text: result.value,
+                                type: 'bciTranscribe',
+                                text: result.value
                             };
                         result = await stream.next();
                     }
                     const { modelExecutionMs, stats } = result.value;
                     yield attachModelExecutionMs({
-                        type: "bciTranscribe",
-                        text: "",
+                        type: 'bciTranscribe',
+                        text: '',
                         done: true,
-                        ...(stats && { stats }),
+                        ...(stats && { stats })
                     }, modelExecutionMs);
                 }
                 finally {
                     await stream.return?.(undefined);
                 }
-            },
+            }
         }),
         bciTranscribeStream: defineDuplexHandler({
             requestSchema: bciTranscribeStreamRequestSchema,
@@ -79,7 +79,7 @@ export const bciPlugin = definePlugin({
             // Same model-wide hard cancel surface as `bciTranscribe` — the BCI
             // addon's `cancel()` tears down the active stream and interrupts the
             // running window job.
-            cancel: { scope: "model", hard: true },
+            cancel: { scope: 'model', hard: true },
             handler: async function* (request, inputStream) {
                 const metadata = request.metadata === true;
                 const iterator = metadata
@@ -88,24 +88,24 @@ export const bciPlugin = definePlugin({
                 for await (const value of iterator) {
                     yield metadata
                         ? {
-                            type: "bciTranscribeStream",
-                            segment: value,
+                            type: 'bciTranscribeStream',
+                            segment: value
                         }
                         : {
-                            type: "bciTranscribeStream",
-                            text: value,
+                            type: 'bciTranscribeStream',
+                            text: value
                         };
                 }
                 yield {
-                    type: "bciTranscribeStream",
-                    text: "",
-                    done: true,
+                    type: 'bciTranscribeStream',
+                    text: '',
+                    done: true
                 };
-            },
-        }),
+            }
+        })
     },
     logging: {
         module: bciAddonLogging,
-        namespace: ModelType.bciWhispercppTranscription,
-    },
+        namespace: ModelType.bciWhispercppTranscription
+    }
 });

package/dist/server/bare/plugins/bci-whispercpp-transcription/resolve-config.d.ts

@@ -1,4 +1,4 @@
-import type { BciConfig, ResolveContext } from "../../../../schemas/index";
+import type { BciConfig, ResolveContext } from '../../../../schemas/index';
 export declare function resolveBciConfig(cfg: BciConfig, ctx: ResolveContext): Promise<{
     config: {
         whisperConfig?: {

package/dist/server/bare/plugins/bci-whispercpp-transcription/resolve-config.js

@@ -6,6 +6,6 @@ export async function resolveBciConfig(cfg, ctx) {
     const embedderPath = await ctx.resolveModelPath(embedderModelSrc);
     return {
         config: bciConfig,
-        artifacts: { embedderPath },
+        artifacts: { embedderPath }
     };
 }

package/dist/server/bare/plugins/ggml-classification/ops/classify.d.ts

@@ -1,4 +1,4 @@
-import { type ClassifyRequest, type ClassificationResult } from "../../../../../schemas/index";
+import { type ClassifyRequest, type ClassificationResult } from '../../../../../schemas/index';
 export declare function classify(params: ClassifyRequest): Promise<{
     results: ClassificationResult[];
     modelExecutionMs: number;

package/dist/server/bare/plugins/ggml-classification/ops/classify.js

@@ -1,19 +1,19 @@
-import { getModel } from "../../../registry/model-registry.js";
-import { classifyRequestSchema } from "../../../../../schemas/index.js";
-import { nowMs } from "../../../../../profiling/index.js";
+import { getModel } from '../../../registry/model-registry.js';
+import { classifyRequestSchema } from '../../../../../schemas/index.js';
+import { nowMs } from '../../../../../profiling/index.js';
 function hasClassify(model) {
-    return (typeof model === "object" &&
+    return (typeof model === 'object' &&
         model !== null &&
-        "classify" in model &&
-        typeof model.classify === "function");
+        'classify' in model &&
+        typeof model.classify === 'function');
 }
 export async function classify(params) {
     const { modelId, image, topK, width, height, channels } = classifyRequestSchema.parse(params);
     const model = getModel(modelId);
     if (!hasClassify(model)) {
-        throw new Error("Loaded model does not support classify()");
+        throw new Error('Loaded model does not support classify()');
     }
-    const imageBytes = Buffer.from(image, "base64");
+    const imageBytes = Buffer.from(image, 'base64');
     const opts = {};
     if (topK !== undefined)
         opts.topK = topK;

package/dist/server/bare/plugins/ggml-classification/plugin.d.ts

@@ -1,4 +1,4 @@
-import { type CreateModelParams, type PluginModelResult } from "../../../../schemas/index";
+import { type CreateModelParams, type PluginModelResult } from '../../../../schemas/index';
 export declare const classificationPlugin: {
     modelType: "ggml-classification";
     displayName: string;

package/dist/server/bare/plugins/ggml-classification/plugin.js

@@ -1,10 +1,10 @@
-import ImageClassifier from "@qvac/classification-ggml";
-import { definePlugin, defineHandler, classifyRequestSchema, classifyResponseSchema, ModelType, classificationConfigSchema, ADDON_CLASSIFICATION, } from "../../../../schemas/index.js";
-import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
-import { classify } from "./ops/classify.js";
+import ImageClassifier from '@qvac/classification-ggml';
+import { definePlugin, defineHandler, classifyRequestSchema, classifyResponseSchema, ModelType, classificationConfigSchema, ADDON_CLASSIFICATION } from '../../../../schemas/index.js';
+import { createStreamLogger, registerAddonLogger } from '../../../../logging/index.js';
+import { classify } from './ops/classify.js';
 export const classificationPlugin = definePlugin({
     modelType: ModelType.ggmlClassification,
-    displayName: "Image Classification (GGML)",
+    displayName: 'Image Classification (GGML)',
     addonPackage: ADDON_CLASSIFICATION,
     loadConfigSchema: classificationConfigSchema,
     skipPrimaryModelPathValidation: true,
@@ -16,7 +16,7 @@ export const classificationPlugin = definePlugin({
         const inner = new ImageClassifier({
             ...(resolvedModelPath ? { modelPath: resolvedModelPath } : {}),
             logger,
-            nativeLogger: config.nativeLogger ?? false,
+            nativeLogger: config.nativeLogger ?? false
         });
         // Apply the load-time `topK` as a default for classify() calls so the
         // load-config field is not silently ignored. Per-request `topK` (passed
@@ -26,9 +26,9 @@ export const classificationPlugin = definePlugin({
             load: () => inner.load(),
             classify: (image, opts = {}) => inner.classify(image, {
                 ...(defaultTopK !== undefined && { topK: defaultTopK }),
-                ...opts,
+                ...opts
             }),
-            unload: () => inner.unload(),
+            unload: () => inner.unload()
         };
         return { model };
     },
@@ -40,16 +40,16 @@ export const classificationPlugin = definePlugin({
             // Classification is a single forward pass with no addon-side cancel
             // surface — mirrors `ocr`/`tts`/`upscale`. The yield-once handler
             // can't be interrupted partway, so we declare scope:"none".
-            cancel: { scope: "none" },
+            cancel: { scope: 'none' },
             handler: async function* (request) {
                 const { results, modelExecutionMs } = await classify(request);
                 yield {
-                    type: "classify",
+                    type: 'classify',
                     results,
                     done: true,
-                    modelExecutionMs,
+                    modelExecutionMs
                 };
-            },
-        }),
-    },
+            }
+        })
+    }
 });

package/dist/server/bare/plugins/ggml-ocr/ops/ocr-stream.d.ts

@@ -1,4 +1,4 @@
-import { type OCRParams, type OCRTextBlock, type OCRStats } from "../../../../../schemas/index";
+import { type OCRParams, type OCRTextBlock, type OCRStats } from '../../../../../schemas/index';
 export declare function ocr(params: OCRParams): AsyncGenerator<{
     blocks: OCRTextBlock[];
 }, {

package/dist/server/bare/plugins/ggml-ocr/ops/ocr-stream.js

@@ -1,33 +1,30 @@
-import { getModel } from "../../../registry/model-registry.js";
-import fs from "bare-fs";
-import path from "bare-path";
-import {} from "../../../../../schemas/index.js";
-import { buildStreamResult, hasDefinedValues } from "../../../../../profiling/model-execution.js";
-import { getCacheDir } from "../../../../utils/index.js";
-import { ImageFileNotFoundError, InvalidImageInputError, } from "../../../../../utils/errors-server.js";
-import { nowMs } from "../../../../../profiling/index.js";
+import { getModel } from '../../../registry/model-registry.js';
+import fs from 'bare-fs';
+import path from 'bare-path';
+import {} from '../../../../../schemas/index.js';
+import { buildStreamResult, hasDefinedValues } from '../../../../../profiling/model-execution.js';
+import { getCacheDir } from '../../../../utils/index.js';
+import { ImageFileNotFoundError, InvalidImageInputError } from '../../../../../utils/errors-server.js';
+import { nowMs } from '../../../../../profiling/index.js';
 function polygonToBbox(polygon) {
     const xs = polygon.map((p) => p[0]);
     const ys = polygon.map((p) => p[1]);
     return [Math.min(...xs), Math.min(...ys), Math.max(...xs), Math.max(...ys)];
 }
 function normalizeBlock(block) {
-    if (block &&
-        typeof block === "object" &&
-        !Array.isArray(block) &&
-        "text" in block) {
+    if (block && typeof block === 'object' && !Array.isArray(block) && 'text' in block) {
         const obj = block;
         return {
-            text: obj.text || "",
+            text: obj.text || '',
             ...(obj.bbox && { bbox: obj.bbox }),
-            ...(obj.confidence !== undefined && { confidence: obj.confidence }),
+            ...(obj.confidence !== undefined && { confidence: obj.confidence })
         };
     }
     // Addon format: [polygon, text, confidence] where polygon is [[x1,y1], [x2,y2], [x3,y3], [x4,y4]]
     if (Array.isArray(block) && block.length >= 2) {
         const blockArr = block;
         const [polygonOrBbox, text, confidence] = blockArr;
-        const textStr = typeof text === "string" ? text : "";
+        const textStr = typeof text === 'string' ? text : '';
         if (Array.isArray(polygonOrBbox) &&
             polygonOrBbox.length === 4 &&
             Array.isArray(polygonOrBbox[0]) &&
@@ -35,16 +32,16 @@ function normalizeBlock(block) {
             return {
                 text: textStr,
                 bbox: polygonToBbox(polygonOrBbox),
-                ...(confidence !== undefined && { confidence: Number(confidence) }),
+                ...(confidence !== undefined && { confidence: Number(confidence) })
             };
         }
         if (Array.isArray(polygonOrBbox) &&
             polygonOrBbox.length === 4 &&
-            typeof polygonOrBbox[0] === "number") {
+            typeof polygonOrBbox[0] === 'number') {
             return {
                 text: textStr,
                 bbox: polygonOrBbox,
-                ...(confidence !== undefined && { confidence: Number(confidence) }),
+                ...(confidence !== undefined && { confidence: Number(confidence) })
             };
         }
     }
@@ -55,16 +52,16 @@ export async function* ocr(params) {
     let imagePath;
     let cleanupPath = null;
     switch (params.image.type) {
-        case "base64": {
-            const tempDir = getCacheDir("tmp");
+        case 'base64': {
+            const tempDir = getCacheDir('tmp');
             const suffix = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
             const tempPath = path.join(tempDir, `ocr-${suffix}.png`);
-            fs.writeFileSync(tempPath, Buffer.from(params.image.value, "base64"));
+            fs.writeFileSync(tempPath, Buffer.from(params.image.value, 'base64'));
             imagePath = tempPath;
             cleanupPath = tempPath;
             break;
         }
-        case "filePath": {
+        case 'filePath': {
             imagePath = params.image.value;
             try {
                 fs.accessSync(imagePath);
@@ -81,7 +78,7 @@ export async function* ocr(params) {
         const modelStart = nowMs();
         const response = (await model.run({
             path: imagePath,
-            ...(params.options && { options: params.options }),
+            ...(params.options && { options: params.options })
         }));
         const rawData = [];
         await response
@@ -99,9 +96,13 @@ export async function* ocr(params) {
             yield { blocks };
         }
         const stats = {
-            ...(response.stats?.detectionTime !== undefined && { detectionTime: response.stats.detectionTime }),
-            ...(response.stats?.recognitionTime !== undefined && { recognitionTime: response.stats.recognitionTime }),
-            ...(response.stats?.totalTime !== undefined && { totalTime: response.stats.totalTime }),
+            ...(response.stats?.detectionTime !== undefined && {
+                detectionTime: response.stats.detectionTime
+            }),
+            ...(response.stats?.recognitionTime !== undefined && {
+                recognitionTime: response.stats.recognitionTime
+            }),
+            ...(response.stats?.totalTime !== undefined && { totalTime: response.stats.totalTime })
         };
         return buildStreamResult(modelExecutionMs, hasDefinedValues(stats) ? stats : undefined);
     }

package/dist/server/bare/plugins/ggml-ocr/plugin.d.ts

@@ -1,4 +1,4 @@
-import { type CreateModelParams, type PluginModelResult, type OCRConfig, type ResolveContext, type ResolveResult } from "../../../../schemas/index";
+import { type CreateModelParams, type PluginModelResult, type OCRConfig, type ResolveContext, type ResolveResult } from '../../../../schemas/index';
 export declare const ocrPlugin: {
     modelType: "ggml-ocr";
     displayName: string;

package/dist/server/bare/plugins/ggml-ocr/plugin.js

@@ -1,87 +1,66 @@
-import { definePlugin, defineHandler, ocrStreamRequestSchema, ocrStreamResponseSchema, ModelType, ocrConfigSchema, ADDON_OCR, } from "../../../../schemas/index.js";
-import { ModelLoadFailedError } from "../../../../utils/errors-server.js";
-import { hyperdriveUrlSchema } from "../../../../schemas/load-model.js";
-import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
-import ocrAddonLogging from "@qvac/ocr-ggml/addonLogging.js";
-import { OcrGgml } from "@qvac/ocr-ggml";
-import { ocr } from "./ops/ocr-stream.js";
-import { attachModelExecutionMs } from "../../../../profiling/model-execution.js";
-import { OCR_CRAFT } from "../../../../models/registry/index.js";
-const OCR_DETECTOR_FILENAME = "craft_mlt_25k.gguf";
-function deriveDetectorSource(modelSrc) {
-    if (modelSrc.startsWith("pear://")) {
-        const { key } = hyperdriveUrlSchema.parse(modelSrc);
-        return `pear://${key}/${OCR_DETECTOR_FILENAME}`;
-    }
-    if (modelSrc.startsWith("registry://")) {
-        return OCR_CRAFT.src;
-    }
-    return undefined;
-}
+import { definePlugin, defineHandler, ocrStreamRequestSchema, ocrStreamResponseSchema, ModelType, ocrConfigSchema, ADDON_OCR } from '../../../../schemas/index.js';
+import { ModelLoadFailedError } from '../../../../utils/errors-server.js';
+import { createStreamLogger, registerAddonLogger } from '../../../../logging/index.js';
+import ocrAddonLogging from '@qvac/ocr-ggml/addonLogging.js';
+import { OcrGgml } from '@qvac/ocr-ggml';
+import { ocr } from './ops/ocr-stream.js';
+import { attachModelExecutionMs } from '../../../../profiling/model-execution.js';
+import { resolveOcrConfig } from './resolve-config.js';
 function createOCRModel(modelId, detectorPath, recognizerPath, ocrConfig) {
     const logger = createStreamLogger(modelId, ModelType.ggmlOcr);
     registerAddonLogger(modelId, ModelType.ggmlOcr, logger);
     const params = {
         pathDetector: detectorPath,
         pathRecognizer: recognizerPath,
-        langList: ocrConfig.langList || ["en"],
+        langList: ocrConfig.langList || ['en'],
         ...(ocrConfig.pipelineType !== undefined && {
-            pipelineType: ocrConfig.pipelineType,
+            pipelineType: ocrConfig.pipelineType
         }),
         ...(ocrConfig.magRatio !== undefined && { magRatio: ocrConfig.magRatio }),
         ...(ocrConfig.canvasSize !== undefined && {
-            canvasSize: ocrConfig.canvasSize,
+            canvasSize: ocrConfig.canvasSize
         }),
         ...(ocrConfig.defaultRotationAngles !== undefined && {
-            defaultRotationAngles: ocrConfig.defaultRotationAngles,
+            defaultRotationAngles: ocrConfig.defaultRotationAngles
         }),
         ...(ocrConfig.contrastRetry !== undefined && {
-            contrastRetry: ocrConfig.contrastRetry,
+            contrastRetry: ocrConfig.contrastRetry
         }),
         ...(ocrConfig.lowConfidenceThreshold !== undefined && {
-            lowConfidenceThreshold: ocrConfig.lowConfidenceThreshold,
+            lowConfidenceThreshold: ocrConfig.lowConfidenceThreshold
         }),
         ...(ocrConfig.recognizerBatchSize !== undefined && {
-            recognizerBatchSize: ocrConfig.recognizerBatchSize,
+            recognizerBatchSize: ocrConfig.recognizerBatchSize
         }),
         ...(ocrConfig.nThreads !== undefined && { nThreads: ocrConfig.nThreads }),
         ...(ocrConfig.backendDevice !== undefined && {
-            backendDevice: ocrConfig.backendDevice,
+            backendDevice: ocrConfig.backendDevice
         }),
         ...(ocrConfig.gpuDevice !== undefined && {
-            gpuDevice: ocrConfig.gpuDevice,
-        }),
+            gpuDevice: ocrConfig.gpuDevice
+        })
     };
     const args = {
         logger,
         params,
-        opts: { stats: true },
+        opts: { stats: true }
     };
     const model = new OcrGgml(args);
     return model;
 }
 export const ocrPlugin = definePlugin({
     modelType: ModelType.ggmlOcr,
-    displayName: "OCR (GGML)",
+    displayName: 'OCR (GGML)',
     addonPackage: ADDON_OCR,
     loadConfigSchema: ocrConfigSchema,
     async resolveConfig(cfg, ctx) {
-        const { detectorModelSrc, ...ocrConfig } = cfg;
-        const detectorSrc = detectorModelSrc ?? deriveDetectorSource(ctx.modelSrc);
-        if (!detectorSrc) {
-            throw new ModelLoadFailedError("Detector model required for OCR. Use a hyperdrive source or provide detectorModelSrc");
-        }
-        const detectorModelPath = await ctx.resolveModelPath(detectorSrc);
-        return {
-            config: ocrConfig,
-            artifacts: { detectorModelPath },
-        };
+        return resolveOcrConfig(cfg, ctx);
     },
     createModel(params) {
         const ocrConfig = (params.modelConfig ?? {});
-        const detectorModelPath = params.artifacts?.["detectorModelPath"];
+        const detectorModelPath = params.artifacts?.['detectorModelPath'];
         if (!detectorModelPath) {
-            throw new ModelLoadFailedError("Detector model path missing. Ensure detectorModelSrc is provided in modelConfig.");
+            throw new ModelLoadFailedError('Detector model path missing. Ensure detectorModelSrc is provided in modelConfig.');
         }
         const model = createOCRModel(params.modelId, detectorModelPath, params.modelPath, // recognizerPath
         ocrConfig);
@@ -94,38 +73,38 @@ export const ocrPlugin = definePlugin({
             streaming: true,
             // GGML OCR does not expose a cancel surface — SDK falls back
             // to soft-cancel.
-            cancel: { scope: "none" },
+            cancel: { scope: 'none' },
             handler: async function* (request) {
                 const stream = ocr({
                     modelId: request.modelId,
                     image: request.image,
-                    options: request.options,
+                    options: request.options
                 });
                 try {
                     let result = await stream.next();
                     while (!result.done) {
                         yield {
-                            type: "ocrStream",
-                            blocks: result.value.blocks,
+                            type: 'ocrStream',
+                            blocks: result.value.blocks
                         };
                         result = await stream.next();
                     }
                     const { modelExecutionMs, stats } = result.value;
                     yield attachModelExecutionMs({
-                        type: "ocrStream",
+                        type: 'ocrStream',
                         blocks: [],
                         done: true,
-                        ...(stats && { stats }),
+                        ...(stats && { stats })
                     }, modelExecutionMs);
                 }
                 finally {
                     await stream.return?.(undefined);
                 }
-            },
-        }),
+            }
+        })
     },
     logging: {
         module: ocrAddonLogging,
-        namespace: ModelType.ggmlOcr,
-    },
+        namespace: ModelType.ggmlOcr
+    }
 });

package/dist/server/bare/plugins/ggml-ocr/resolve-config.d.ts

@@ -0,0 +1,6 @@
+import { type OCRConfig, type ResolveContext, type ResolveResult } from '../../../../schemas/index';
+type OcrPipelineType = NonNullable<OCRConfig['pipelineType']>;
+export declare const DETECTOR_FILENAMES: Record<OcrPipelineType, string>;
+export declare function resolveOcrConfig(cfg: OCRConfig, ctx: ResolveContext): Promise<ResolveResult<Record<string, unknown>, 'detectorModelPath'>>;
+export {};
+//# sourceMappingURL=resolve-config.d.ts.map

package/dist/server/bare/plugins/ggml-ocr/resolve-config.js

@@ -0,0 +1,73 @@
+import {} from '../../../../schemas/index.js';
+import { ModelLoadFailedError } from '../../../../utils/errors-server.js';
+import { hyperdriveUrlSchema } from '../../../../schemas/load-model.js';
+import { OCR_CRAFT, OCR_DOCTR_1 } from '../../../../models/registry/index.js';
+// Detector weights paired with each pipeline. EasyOCR runs CRAFT
+// detection, DocTR runs DBNet detection — the addon cannot load one
+// pipeline's detector into the other.
+export const DETECTOR_FILENAMES = {
+    easyocr: 'craft_mlt_25k.gguf',
+    doctr: 'db_mobilenet_v3_large.gguf'
+};
+const DETECTOR_REGISTRY_SOURCES = {
+    easyocr: OCR_CRAFT.src,
+    doctr: OCR_DOCTR_1.src
+};
+// The addon defaults to the EasyOCR pipeline, so a DocTR recognizer
+// loaded without an explicit `pipelineType` dies deep in the EasyOCR
+// CRNN weight loader with a raw missing-tensor error (QVAC-22514).
+// Recognize the known DocTR registry artifacts by name and opt in to
+// the DocTR pipeline automatically.
+function inferPipelineType(recognizerSrc) {
+    const path = srcPathname(recognizerSrc);
+    const filename = path.split('/').pop() ?? '';
+    if (filename === 'crnn_mobilenet_v3_small.gguf' || path.includes('/gguf/doctr')) {
+        return 'doctr';
+    }
+    return undefined;
+}
+function srcPathname(src) {
+    return (src.split(/[?#]/)[0] ?? '').toLowerCase();
+}
+function srcToString(src) {
+    return typeof src === 'string' ? src : src.src;
+}
+// The registry still lists legacy `.onnx` OCR artifacts under the
+// "@qvac/ocr-onnx" engine; the ggml-ocr addon can only open GGUF, so a
+// raw "failed to open GGUF" surfaces mid-load. Fail fast with the
+// supported configurations instead (QVAC-22514).
+function assertGgufSource(src, role) {
+    if (!srcPathname(src).endsWith('.onnx'))
+        return;
+    throw new ModelLoadFailedError(`ggml-ocr only loads GGUF models, but the ${role} source points to an ONNX file: ${src}. ` +
+        'The .onnx OCR registry entries are legacy artifacts of the removed "onnx-ocr" engine. ' +
+        'Supported registry configurations: EasyOCR (default) — modelSrc: OCR_LATIN.src (detector OCR_CRAFT auto-derived); ' +
+        'DocTR — modelSrc: OCR_DOCTR.src (pipelineType and detector OCR_DOCTR_1 auto-derived).');
+}
+function deriveDetectorSource(modelSrc, pipelineType) {
+    if (modelSrc.startsWith('pear://')) {
+        const { key } = hyperdriveUrlSchema.parse(modelSrc);
+        return `pear://${key}/${DETECTOR_FILENAMES[pipelineType]}`;
+    }
+    if (modelSrc.startsWith('registry://')) {
+        return DETECTOR_REGISTRY_SOURCES[pipelineType];
+    }
+    return undefined;
+}
+export async function resolveOcrConfig(cfg, ctx) {
+    const { detectorModelSrc, ...ocrConfig } = cfg;
+    assertGgufSource(ctx.modelSrc, 'recognizer');
+    const pipelineType = ocrConfig.pipelineType ?? inferPipelineType(ctx.modelSrc) ?? 'easyocr';
+    const detectorSrc = detectorModelSrc ?? deriveDetectorSource(ctx.modelSrc, pipelineType);
+    if (!detectorSrc) {
+        throw new ModelLoadFailedError(`Detector model required for OCR (${pipelineType} pipeline expects ` +
+            `${DETECTOR_FILENAMES[pipelineType]}). Use a hyperdrive or registry ` +
+            'source, or provide detectorModelSrc');
+    }
+    assertGgufSource(srcToString(detectorSrc), 'detector');
+    const detectorModelPath = await ctx.resolveModelPath(detectorSrc);
+    return {
+        config: { ...ocrConfig, pipelineType },
+        artifacts: { detectorModelPath }
+    };
+}

package/dist/server/bare/plugins/ggml-vla/ops/vla-hparams.d.ts

@@ -1,3 +1,3 @@
-import { type VlaHparamsRequest, type VlaHparamsResponse } from "../../../../../schemas/index";
+import { type VlaHparamsRequest, type VlaHparamsResponse } from '../../../../../schemas/index';
 export declare function vlaGetHparams(request: VlaHparamsRequest): Promise<VlaHparamsResponse>;
 //# sourceMappingURL=vla-hparams.d.ts.map