@qvac/sdk 0.9.2 → 0.10.1

package/dist/server/bare/plugins/nmtcpp-translation/plugin.d.ts

@@ -4,35 +4,6 @@ export declare const nmtPlugin: {
     displayName: string;
     addonPackage: "@qvac/translation-nmtcpp";
     loadConfigSchema: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
-        mode: import("zod").ZodOptional<import("zod").ZodEnum<{
-            full: "full";
-        }>>;
-        beamsize: import("zod").ZodOptional<import("zod").ZodNumber>;
-        lengthpenalty: import("zod").ZodOptional<import("zod").ZodNumber>;
-        maxlength: import("zod").ZodOptional<import("zod").ZodNumber>;
-        repetitionpenalty: import("zod").ZodOptional<import("zod").ZodNumber>;
-        norepeatngramsize: import("zod").ZodOptional<import("zod").ZodNumber>;
-        temperature: import("zod").ZodOptional<import("zod").ZodNumber>;
-        topk: import("zod").ZodOptional<import("zod").ZodNumber>;
-        topp: import("zod").ZodOptional<import("zod").ZodNumber>;
-        engine: import("zod").ZodLiteral<"Opus">;
-        from: import("zod").ZodEnum<{
-            en: "en";
-            de: "de";
-            es: "es";
-            it: "it";
-            ru: "ru";
-            ja: "ja";
-        }>;
-        to: import("zod").ZodEnum<{
-            en: "en";
-            de: "de";
-            es: "es";
-            it: "it";
-            ru: "ru";
-            ja: "ja";
-        }>;
-    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
         mode: import("zod").ZodOptional<import("zod").ZodEnum<{
             full: "full";
         }>>;
@@ -46,58 +17,112 @@ export declare const nmtPlugin: {
         topp: import("zod").ZodOptional<import("zod").ZodNumber>;
         engine: import("zod").ZodLiteral<"Bergamot">;
         from: import("zod").ZodEnum<{
+            id: "id";
             en: "en";
-            de: "de";
-            es: "es";
-            it: "it";
-            ru: "ru";
-            ja: "ja";
             ar: "ar";
             bg: "bg";
             ca: "ca";
             cs: "cs";
+            de: "de";
+            es: "es";
             et: "et";
             fi: "fi";
             fr: "fr";
             hu: "hu";
             is: "is";
+            it: "it";
+            ja: "ja";
             ko: "ko";
             lt: "lt";
             lv: "lv";
             nl: "nl";
             pl: "pl";
             pt: "pt";
+            ru: "ru";
             sk: "sk";
             sl: "sl";
             uk: "uk";
             zh: "zh";
+            az: "az";
+            be: "be";
+            bn: "bn";
+            bs: "bs";
+            da: "da";
+            el: "el";
+            fa: "fa";
+            gu: "gu";
+            he: "he";
+            hi: "hi";
+            hr: "hr";
+            kn: "kn";
+            ml: "ml";
+            ms: "ms";
+            mt: "mt";
+            nb: "nb";
+            nn: "nn";
+            re: "re";
+            ro: "ro";
+            sq: "sq";
+            sr: "sr";
+            sv: "sv";
+            ta: "ta";
+            te: "te";
+            tr: "tr";
+            vi: "vi";
         }>;
         to: import("zod").ZodEnum<{
+            id: "id";
             en: "en";
-            de: "de";
-            es: "es";
-            it: "it";
-            ru: "ru";
-            ja: "ja";
             ar: "ar";
             bg: "bg";
             ca: "ca";
             cs: "cs";
+            de: "de";
+            es: "es";
             et: "et";
             fi: "fi";
             fr: "fr";
             hu: "hu";
             is: "is";
+            it: "it";
+            ja: "ja";
             ko: "ko";
             lt: "lt";
             lv: "lv";
             nl: "nl";
             pl: "pl";
             pt: "pt";
+            ru: "ru";
             sk: "sk";
             sl: "sl";
             uk: "uk";
             zh: "zh";
+            az: "az";
+            be: "be";
+            bn: "bn";
+            bs: "bs";
+            da: "da";
+            el: "el";
+            fa: "fa";
+            gu: "gu";
+            he: "he";
+            hi: "hi";
+            hr: "hr";
+            kn: "kn";
+            ml: "ml";
+            ms: "ms";
+            mt: "mt";
+            nb: "nb";
+            nn: "nn";
+            re: "re";
+            ro: "ro";
+            sq: "sq";
+            sr: "sr";
+            sv: "sv";
+            ta: "ta";
+            te: "te";
+            tr: "tr";
+            vi: "vi";
         }>;
         srcVocabSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
             src: import("zod").ZodString;
@@ -111,6 +136,7 @@ export declare const nmtPlugin: {
             expectedSize: import("zod").ZodOptional<import("zod").ZodNumber>;
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
+                embeddings: "embeddings";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -121,7 +147,6 @@ export declare const nmtPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";
@@ -141,6 +166,7 @@ export declare const nmtPlugin: {
             expectedSize: import("zod").ZodOptional<import("zod").ZodNumber>;
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
+                embeddings: "embeddings";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -151,7 +177,6 @@ export declare const nmtPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";
@@ -184,6 +209,7 @@ export declare const nmtPlugin: {
                 expectedSize: import("zod").ZodOptional<import("zod").ZodNumber>;
                 sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
                 addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
+                    embeddings: "embeddings";
                     "llamacpp-completion": "llamacpp-completion";
                     "whispercpp-transcription": "whispercpp-transcription";
                     "llamacpp-embedding": "llamacpp-embedding";
@@ -194,7 +220,6 @@ export declare const nmtPlugin: {
                     "sdcpp-generation": "sdcpp-generation";
                     llm: "llm";
                     whisper: "whisper";
-                    embeddings: "embeddings";
                     nmt: "nmt";
                     parakeet: "parakeet";
                     tts: "tts";
@@ -214,6 +239,7 @@ export declare const nmtPlugin: {
                 expectedSize: import("zod").ZodOptional<import("zod").ZodNumber>;
                 sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
                 addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
+                    embeddings: "embeddings";
                     "llamacpp-completion": "llamacpp-completion";
                     "whispercpp-transcription": "whispercpp-transcription";
                     "llamacpp-embedding": "llamacpp-embedding";
@@ -224,7 +250,6 @@ export declare const nmtPlugin: {
                     "sdcpp-generation": "sdcpp-generation";
                     llm: "llm";
                     whisper: "whisper";
-                    embeddings: "embeddings";
                     nmt: "nmt";
                     parakeet: "parakeet";
                     tts: "tts";
@@ -244,6 +269,7 @@ export declare const nmtPlugin: {
                 expectedSize: import("zod").ZodOptional<import("zod").ZodNumber>;
                 sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
                 addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
+                    embeddings: "embeddings";
                     "llamacpp-completion": "llamacpp-completion";
                     "whispercpp-transcription": "whispercpp-transcription";
                     "llamacpp-embedding": "llamacpp-embedding";
@@ -254,7 +280,6 @@ export declare const nmtPlugin: {
                     "sdcpp-generation": "sdcpp-generation";
                     llm: "llm";
                     whisper: "whisper";
-                    embeddings: "embeddings";
                     nmt: "nmt";
                     parakeet: "parakeet";
                     tts: "tts";

package/dist/server/bare/plugins/nmtcpp-translation/plugin.js

@@ -1,57 +1,44 @@
 import nmtAddonLogging from "@qvac/translation-nmtcpp/addonLogging.js";
 import TranslationNmtcpp, {} from "@qvac/translation-nmtcpp";
-import { definePlugin, defineHandler, translateRequestSchema, translateResponseSchema, ModelType, nmtConfigBaseSchema, ADDON_NMT, } from "../../../../schemas/index.js";
+import { definePlugin, defineHandler, translateRequestSchema, translateResponseSchema, ModelType, nmtConfigBaseSchema, ADDON_NMT, BERGAMOT_CJK_LANG_PAIRS, } from "../../../../schemas/index.js";
 import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
-import { parseModelPath } from "../../../utils/index.js";
-import FilesystemDL from "@qvac/dl-filesystem";
-import { ModelLoadFailedError } from "../../../../utils/errors-server.js";
-import { asLoader } from "../../utils/loader-adapter.js";
+import path from "bare-path";
 import { translate } from "../../ops/translate.js";
 import { attachModelExecutionMs } from "../../../../profiling/model-execution.js";
-const BERGAMOT_CJK_LANG_PAIRS = ["enja", "enko", "enzh"];
-function buildBergamotVocabSources(basePath, langPair) {
+import { resolveBergamotVocab, } from "./resolve-vocab.js";
+/**
+ * Derive absolute vocab paths from a resolved Bergamot model path.
+ * Works for both companion-set layout (colocated files) and any layout where
+ * vocab follows the standard naming convention beside the model binary.
+ * Returns null if modelPath is not a recognisable Bergamot model.
+ */
+function deriveColocatedBergamotVocabPaths(modelPath) {
+    const dirPath = path.dirname(modelPath);
+    const basePath = path.basename(modelPath);
+    const match = basePath.match(/^model\.([a-z]+)\.intgemm\.alphas\.bin$/);
+    if (!match?.[1])
+        return null;
+    const langPair = match[1];
     if (BERGAMOT_CJK_LANG_PAIRS.includes(langPair)) {
         return {
-            srcVocabSrc: `${basePath}srcvocab.${langPair}.spm`,
-            dstVocabSrc: `${basePath}trgvocab.${langPair}.spm`,
+            srcVocabPath: path.join(dirPath, `srcvocab.${langPair}.spm`),
+            dstVocabPath: path.join(dirPath, `trgvocab.${langPair}.spm`),
         };
     }
-    const sharedVocab = `${basePath}vocab.${langPair}.spm`;
-    return { srcVocabSrc: sharedVocab, dstVocabSrc: sharedVocab };
-}
-function deriveBergamotVocabSources(modelSrc) {
-    const match = modelSrc.match(/^pear:\/\/([a-f0-9]+)\/model\.([a-z]+)\.intgemm\.alphas\.bin$/);
-    if (!match?.[1] || !match[2])
-        return null;
-    const basePath = `pear://${match[1]}/`;
-    const langPair = match[2];
-    return buildBergamotVocabSources(basePath, langPair);
-}
-function deriveBergamotRegistryVocabSources(modelSrc) {
-    const match = modelSrc.match(/^(registry:\/\/.+\/)model\.([a-z]+)\.intgemm\.alphas\.bin$/);
-    if (!match?.[1] || !match[2])
-        return null;
-    const basePath = match[1];
-    const langPair = match[2];
-    return buildBergamotVocabSources(basePath, langPair);
+    const sharedPath = path.join(dirPath, `vocab.${langPair}.spm`);
+    return { srcVocabPath: sharedPath, dstVocabPath: sharedPath };
 }
 function createNmtModel(modelId, modelPath, nmtConfig, srcVocabPath, dstVocabPath, pivotModelPath, pivotSrcVocabPath, pivotDstVocabPath) {
-    const { dirPath, basePath } = parseModelPath(modelPath);
-    const loader = new FilesystemDL({ dirPath });
     const logger = createStreamLogger(modelId, ModelType.nmtcppTranslation);
     registerAddonLogger(modelId, ModelType.nmtcppTranslation, logger);
     const { mode, from, to, engine, beamsize, lengthpenalty, maxlength, repetitionpenalty, norepeatngramsize, temperature, topk, topp, } = nmtConfig;
-    const args = {
-        loader: asLoader(loader),
-        logger,
-        modelName: basePath,
-        diskPath: dirPath,
-        opts: { stats: true },
-        params: {
-            mode,
-            srcLang: from,
-            dstLang: to,
-        },
+    const files = {
+        model: modelPath,
+        ...(srcVocabPath && { srcVocab: srcVocabPath }),
+        ...(dstVocabPath && { dstVocab: dstVocabPath }),
+        ...(pivotModelPath && { pivotModel: pivotModelPath }),
+        ...(pivotSrcVocabPath && { pivotSrcVocab: pivotSrcVocabPath }),
+        ...(pivotDstVocabPath && { pivotDstVocab: pivotDstVocabPath }),
     };
     const generationParams = {
         beamsize,
@@ -67,33 +54,26 @@ function createNmtModel(modelId, modelPath, nmtConfig, srcVocabPath, dstVocabPat
         modelType: TranslationNmtcpp.ModelTypes[engine],
         ...generationParams,
         ...(nmtConfig.engine === "Bergamot" && {
-            ...(srcVocabPath && { srcVocabPath }),
-            ...(dstVocabPath && { dstVocabPath }),
             ...(nmtConfig.normalize !== undefined && {
                 normalize: nmtConfig.normalize,
             }),
-            // Add pivot model configuration if present
-            ...(nmtConfig.pivotModel && {
-                bergamotPivotModel: (() => {
+            ...(nmtConfig.pivotModel && pivotModelPath && {
+                pivotConfig: (() => {
                     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                    const { modelSrc, dstVocabSrc, srcVocabSrc, ...config } = nmtConfig.pivotModel;
-                    const { dirPath, basePath } = parseModelPath(pivotModelPath);
-                    return {
-                        loader: asLoader(new FilesystemDL({ dirPath })),
-                        modelName: basePath,
-                        diskPath: dirPath,
-                        config: {
-                            ...config,
-                            srcVocabPath: pivotSrcVocabPath,
-                            dstVocabPath: pivotDstVocabPath
-                        }
-                    };
+                    const { modelSrc, dstVocabSrc, srcVocabSrc, ...pivotGenConfig } = nmtConfig.pivotModel;
+                    return pivotGenConfig;
                 })(),
             }),
         }),
     };
-    const model = new TranslationNmtcpp(args, config);
-    return { model, loader };
+    const model = new TranslationNmtcpp({
+        files,
+        params: { mode, srcLang: from, dstLang: to },
+        config,
+        logger,
+        opts: { stats: true },
+    });
+    return { model };
 }
 export const nmtPlugin = definePlugin({
     modelType: ModelType.nmtcppTranslation,
@@ -101,69 +81,27 @@ export const nmtPlugin = definePlugin({
     addonPackage: ADDON_NMT,
     loadConfigSchema: nmtConfigBaseSchema,
     async resolveConfig(cfg, ctx) {
-        const { srcVocabSrc, dstVocabSrc, ...nmtConfig } = cfg;
+        const { srcVocabSrc, dstVocabSrc, pivotModel, ...nmtConfig } = cfg;
         if (nmtConfig.engine !== "Bergamot") {
             return { config: nmtConfig };
         }
-        let srcSrc = srcVocabSrc;
-        let dstSrc = dstVocabSrc;
-        if (!srcSrc || !dstSrc) {
-            const derived = ctx.modelSrc.startsWith("pear://")
-                ? deriveBergamotVocabSources(ctx.modelSrc)
-                : ctx.modelSrc.startsWith("registry://")
-                    ? deriveBergamotRegistryVocabSources(ctx.modelSrc)
-                    : null;
-            if (derived) {
-                srcSrc = srcSrc ?? derived.srcVocabSrc;
-                dstSrc = dstSrc ?? derived.dstVocabSrc;
-            }
-        }
-        if (!srcSrc || !dstSrc) {
-            throw new ModelLoadFailedError("Bergamot requires srcVocabSrc and dstVocabSrc. Provide them in modelConfig or use a pear:// or registry:// model source for auto-derivation.");
-        }
-        const pivotModel = nmtConfig.pivotModel;
-        if (!pivotModel) {
-            const [srcVocabPath, dstVocabPath] = await Promise.all([
-                ctx.resolveModelPath(srcSrc),
-                ctx.resolveModelPath(dstSrc),
-            ]);
-            return {
-                config: nmtConfig,
-                artifacts: { srcVocabPath, dstVocabPath },
-            };
-        }
-        let pivotSrcSrc = pivotModel.srcVocabSrc;
-        let pivotDstSrc = pivotModel.dstVocabSrc;
-        if (!pivotSrcSrc || !pivotDstSrc) {
-            const pivotDerived = pivotModel.modelSrc.startsWith("pear://")
-                ? deriveBergamotVocabSources(pivotModel.modelSrc)
-                : pivotModel.modelSrc.startsWith("registry://")
-                    ? deriveBergamotRegistryVocabSources(pivotModel.modelSrc)
-                    : null;
-            if (pivotDerived) {
-                pivotSrcSrc = pivotSrcSrc ?? pivotDerived.srcVocabSrc;
-                pivotDstSrc = pivotDstSrc ?? pivotDerived.dstVocabSrc;
-            }
-        }
-        if (!pivotSrcSrc || !pivotDstSrc) {
-            throw new ModelLoadFailedError("Bergamot pivot model requires srcVocabSrc and dstVocabSrc. Provide them in modelConfig or use a pear:// or registry:// model source for auto-derivation.");
-        }
-        const [srcVocabPath, dstVocabPath, pivotSrcVocabPath, pivotDstVocabPath, pivotModelPath] = await Promise.all([
-            ctx.resolveModelPath(srcSrc),
-            ctx.resolveModelPath(dstSrc),
-            ctx.resolveModelPath(pivotSrcSrc),
-            ctx.resolveModelPath(pivotDstSrc),
-            ctx.resolveModelPath(pivotModel.modelSrc),
-        ]);
-        return {
-            config: nmtConfig,
-            artifacts: { srcVocabPath, dstVocabPath, pivotSrcVocabPath, pivotDstVocabPath, pivotModelPath },
-        };
+        const bergamotConfig = { ...nmtConfig, ...(pivotModel && { pivotModel }) };
+        return resolveBergamotVocab(bergamotConfig, ctx, srcVocabSrc, dstVocabSrc, pivotModel);
     },
     createModel(params) {
         const nmtConfig = (params.modelConfig ?? {});
-        const { model, loader } = createNmtModel(params.modelId, params.modelPath, nmtConfig, params.artifacts?.["srcVocabPath"], params.artifacts?.["dstVocabPath"], params.artifacts?.["pivotModelPath"], params.artifacts?.["pivotSrcVocabPath"], params.artifacts?.["pivotDstVocabPath"]);
-        return { model, loader };
+        const artifacts = params.artifacts ?? {};
+        const derived = deriveColocatedBergamotVocabPaths(params.modelPath);
+        const srcVocabPath = artifacts["srcVocabPath"] ?? derived?.srcVocabPath;
+        const dstVocabPath = artifacts["dstVocabPath"] ?? derived?.dstVocabPath;
+        const pivotModelPath = artifacts["pivotModelPath"];
+        const pivotDerived = pivotModelPath
+            ? deriveColocatedBergamotVocabPaths(pivotModelPath)
+            : null;
+        const pivotSrcVocabPath = artifacts["pivotSrcVocabPath"] ?? pivotDerived?.srcVocabPath;
+        const pivotDstVocabPath = artifacts["pivotDstVocabPath"] ?? pivotDerived?.dstVocabPath;
+        const { model } = createNmtModel(params.modelId, params.modelPath, nmtConfig, srcVocabPath, dstVocabPath, pivotModelPath, pivotSrcVocabPath, pivotDstVocabPath);
+        return { model };
     },
     handlers: {
         translate: defineHandler({

package/dist/server/bare/plugins/nmtcpp-translation/resolve-vocab.d.ts

@@ -0,0 +1,32 @@
+import { type ModelSrcInput, type NmtConfig, type ResolveContext, type ResolveResult } from "../../../../schemas/index";
+export interface PivotModelConfig {
+    modelSrc: string;
+    srcVocabSrc?: ModelSrcInput;
+    dstVocabSrc?: ModelSrcInput;
+}
+export declare function buildBergamotVocabSources(basePath: string, langPair: string): {
+    srcVocabSrc: string;
+    dstVocabSrc: string;
+};
+export declare function deriveBergamotVocabSources(modelSrc: string): {
+    srcVocabSrc: string;
+    dstVocabSrc: string;
+} | null;
+export declare function deriveBergamotRegistryVocabSources(modelSrc: string): {
+    srcVocabSrc: string;
+    dstVocabSrc: string;
+} | null;
+/**
+ * Resolves Bergamot vocab sources to absolute filesystem paths via the SDK
+ * resolver context, optionally including a pivot model.
+ *
+ * For `registry://` sources with auto-derived vocabs, this skips per-vocab
+ * resolution because the companion-set download already colocates the vocabs
+ * next to the primary model under `sets/<setKey>/`. `createModel` then derives
+ * the colocated paths via `deriveColocatedBergamotVocabPaths`. This avoids a
+ * redundant flat-cache copy and sidesteps the dedup edge case in QVAC-18420
+ * where two directions of a bidirectional pair ship the same vocab blob under
+ * distinct registry paths and only one survives sha256 dedup.
+ */
+export declare function resolveBergamotVocab(nmtConfig: NmtConfig, ctx: ResolveContext, srcVocabSrc: ModelSrcInput | undefined, dstVocabSrc: ModelSrcInput | undefined, pivotModel?: PivotModelConfig): Promise<ResolveResult<Record<string, unknown>>>;
+//# sourceMappingURL=resolve-vocab.d.ts.map

package/dist/server/bare/plugins/nmtcpp-translation/resolve-vocab.js

@@ -0,0 +1,117 @@
+import { BERGAMOT_CJK_LANG_PAIRS, } from "../../../../schemas/index.js";
+import { ModelLoadFailedError } from "../../../../utils/errors-server.js";
+export function buildBergamotVocabSources(basePath, langPair) {
+    if (BERGAMOT_CJK_LANG_PAIRS.includes(langPair)) {
+        return {
+            srcVocabSrc: `${basePath}srcvocab.${langPair}.spm`,
+            dstVocabSrc: `${basePath}trgvocab.${langPair}.spm`,
+        };
+    }
+    const sharedVocab = `${basePath}vocab.${langPair}.spm`;
+    return { srcVocabSrc: sharedVocab, dstVocabSrc: sharedVocab };
+}
+export function deriveBergamotVocabSources(modelSrc) {
+    const match = modelSrc.match(/^pear:\/\/([a-f0-9]+)\/model\.([a-z]+)\.intgemm\.alphas\.bin$/);
+    if (!match?.[1] || !match[2])
+        return null;
+    const basePath = `pear://${match[1]}/`;
+    const langPair = match[2];
+    return buildBergamotVocabSources(basePath, langPair);
+}
+export function deriveBergamotRegistryVocabSources(modelSrc) {
+    const match = modelSrc.match(/^(registry:\/\/.+\/)model\.([a-z]+)\.intgemm\.alphas\.bin$/);
+    if (!match?.[1] || !match[2])
+        return null;
+    const basePath = match[1];
+    const langPair = match[2];
+    return buildBergamotVocabSources(basePath, langPair);
+}
+/**
+ * Resolves Bergamot vocab sources to absolute filesystem paths via the SDK
+ * resolver context, optionally including a pivot model.
+ *
+ * For `registry://` sources with auto-derived vocabs, this skips per-vocab
+ * resolution because the companion-set download already colocates the vocabs
+ * next to the primary model under `sets/<setKey>/`. `createModel` then derives
+ * the colocated paths via `deriveColocatedBergamotVocabPaths`. This avoids a
+ * redundant flat-cache copy and sidesteps the dedup edge case in QVAC-18420
+ * where two directions of a bidirectional pair ship the same vocab blob under
+ * distinct registry paths and only one survives sha256 dedup.
+ */
+export async function resolveBergamotVocab(nmtConfig, ctx, srcVocabSrc, dstVocabSrc, pivotModel) {
+    let srcSrc = srcVocabSrc;
+    let dstSrc = dstVocabSrc;
+    if (!srcSrc || !dstSrc) {
+        const derived = ctx.modelSrc.startsWith("pear://")
+            ? deriveBergamotVocabSources(ctx.modelSrc)
+            : ctx.modelSrc.startsWith("registry://")
+                ? deriveBergamotRegistryVocabSources(ctx.modelSrc)
+                : null;
+        if (derived) {
+            srcSrc = srcSrc ?? derived.srcVocabSrc;
+            dstSrc = dstSrc ?? derived.dstVocabSrc;
+        }
+    }
+    if (!srcSrc || !dstSrc) {
+        throw new ModelLoadFailedError("Bergamot requires srcVocabSrc and dstVocabSrc. Provide them in modelConfig or use a pear:// or registry:// model source for auto-derivation.");
+    }
+    if (!pivotModel) {
+        const modelIsRegistry = ctx.modelSrc.startsWith("registry://");
+        const vocabsAreDerived = !srcVocabSrc && !dstVocabSrc;
+        if (modelIsRegistry && vocabsAreDerived) {
+            return { config: nmtConfig };
+        }
+        const [srcVocabPath, dstVocabPath] = await Promise.all([
+            ctx.resolveModelPath(srcSrc),
+            ctx.resolveModelPath(dstSrc),
+        ]);
+        return {
+            config: nmtConfig,
+            artifacts: { srcVocabPath, dstVocabPath },
+        };
+    }
+    let pivotSrcSrc = pivotModel.srcVocabSrc;
+    let pivotDstSrc = pivotModel.dstVocabSrc;
+    if (!pivotSrcSrc || !pivotDstSrc) {
+        const pivotDerived = pivotModel.modelSrc.startsWith("pear://")
+            ? deriveBergamotVocabSources(pivotModel.modelSrc)
+            : pivotModel.modelSrc.startsWith("registry://")
+                ? deriveBergamotRegistryVocabSources(pivotModel.modelSrc)
+                : null;
+        if (pivotDerived) {
+            pivotSrcSrc = pivotSrcSrc ?? pivotDerived.srcVocabSrc;
+            pivotDstSrc = pivotDstSrc ?? pivotDerived.dstVocabSrc;
+        }
+    }
+    if (!pivotSrcSrc || !pivotDstSrc) {
+        throw new ModelLoadFailedError("Bergamot pivot model requires srcVocabSrc and dstVocabSrc. Provide them in modelConfig or use a pear:// or registry:// model source for auto-derivation.");
+    }
+    const modelIsRegistry = ctx.modelSrc.startsWith("registry://");
+    const pivotIsRegistry = pivotModel.modelSrc.startsWith("registry://");
+    const primaryVocabsAreDerived = !srcVocabSrc && !dstVocabSrc;
+    const pivotVocabsAreDerived = !pivotModel.srcVocabSrc && !pivotModel.dstVocabSrc;
+    if (modelIsRegistry &&
+        pivotIsRegistry &&
+        primaryVocabsAreDerived &&
+        pivotVocabsAreDerived) {
+        const pivotModelPath = await ctx.resolveModelPath(pivotModel.modelSrc);
+        return { config: nmtConfig, artifacts: { pivotModelPath } };
+    }
+    const [srcVocabPath, dstVocabPath, pivotSrcVocabPath, pivotDstVocabPath, pivotModelPath,] = await Promise.all([
+        ctx.resolveModelPath(srcSrc),
+        ctx.resolveModelPath(dstSrc),
+        ctx.resolveModelPath(pivotSrcSrc),
+        ctx.resolveModelPath(pivotDstSrc),
+        ctx.resolveModelPath(pivotModel.modelSrc),
+    ]);
+    return {
+        config: nmtConfig,
+        artifacts: {
+            srcVocabPath,
+            dstVocabPath,
+            pivotSrcVocabPath,
+            pivotDstVocabPath,
+            pivotModelPath,
+        },
+    };
+}

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

@@ -33,6 +33,7 @@ export declare const ocrPlugin: {
             expectedSize: import("zod").ZodOptional<import("zod").ZodNumber>;
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
+                embeddings: "embeddings";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -43,7 +44,6 @@ export declare const ocrPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";

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

@@ -54,7 +54,6 @@ function createOCRModel(modelId, detectorPath, recognizerPath, ocrConfig) {
         params,
         opts: { stats: true },
     };
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
     const model = new ONNXOcr(args);
     return model;
 }
@@ -83,7 +82,7 @@ export const ocrPlugin = definePlugin({
         }
         const model = createOCRModel(params.modelId, detectorModelPath, params.modelPath, // recognizerPath
         ocrConfig);
-        return { model, loader: null };
+        return { model };
     },
     handlers: {
         ocrStream: defineHandler({

package/dist/server/bare/plugins/onnx-tts/ops/text-to-speech-stream.d.ts

@@ -0,0 +1,7 @@
+import { type TextToSpeechStreamRequest, type TtsStats } from "../../../../../schemas/index";
+import { type TtsOpYield } from "../../../utils/tts-stats";
+export declare function textToSpeechStream(params: TextToSpeechStreamRequest, inputStream: AsyncIterable<Buffer>): AsyncGenerator<TtsOpYield, {
+    modelExecutionMs: number;
+    stats?: TtsStats;
+}, unknown>;
+//# sourceMappingURL=text-to-speech-stream.d.ts.map