@qvac/sdk 0.6.1 → 0.7.0

package/dist/models/update-models/codegen.d.ts

@@ -0,0 +1,3 @@
+import type { ProcessedModel } from "./types";
+export declare function generateModelsFileContent(models: ProcessedModel[]): string;
+//# sourceMappingURL=codegen.d.ts.map

package/dist/models/update-models/codegen.js

@@ -0,0 +1,135 @@
+import { generateExportName } from "./naming.js";
+export function generateModelsFileContent(models) {
+    const usedNames = new Set();
+    const modelsWithNames = models.map((m) => ({
+        ...m,
+        name: generateExportName({
+            path: m.registryPath,
+            engine: m.engine,
+            name: m.modelName,
+            quantization: m.quantization,
+            params: m.params,
+            tags: m.tags,
+            usedNames,
+        }),
+    }));
+    return generateFileContentWithNames(modelsWithNames);
+}
+function generateFileContentWithNames(modelsWithNames) {
+    const entries = modelsWithNames
+        .map((m) => {
+        const addonAlias = m.addon;
+        let entry = `  {
+    name: "${m.name}",
+    registryPath: "${m.registryPath}",
+    registrySource: "${m.registrySource}",
+    blobCoreKey: "${m.blobCoreKey}",
+    blobBlockOffset: ${m.blobBlockOffset},
+    blobBlockLength: ${m.blobBlockLength},
+    blobByteOffset: ${m.blobByteOffset},
+    modelId: "${m.modelId}",
+    addon: "${addonAlias}",
+    expectedSize: ${m.expectedSize},
+    sha256Checksum: "${m.sha256Checksum}",
+    engine: "${m.engine}",
+    quantization: "${m.quantization || ""}",
+    params: "${m.params || ""}"`;
+        if (m.shardMetadata) {
+            entry += `,\n    shardMetadata: ${JSON.stringify(m.shardMetadata)}`;
+        }
+        entry += "\n  }";
+        return entry;
+    })
+        .join(",\n");
+    const exports = modelsWithNames
+        .map((m, i) => {
+        return `export const ${m.name} = {
+  name: "${m.name}",
+  src: \`registry://\${models[${i}].registrySource}/\${models[${i}].registryPath}\`,
+  registryPath: models[${i}].registryPath,
+  registrySource: models[${i}].registrySource,
+  blobCoreKey: models[${i}].blobCoreKey,
+  blobBlockOffset: models[${i}].blobBlockOffset,
+  blobBlockLength: models[${i}].blobBlockLength,
+  blobByteOffset: models[${i}].blobByteOffset,
+  modelId: models[${i}].modelId,
+  expectedSize: models[${i}].expectedSize,
+  sha256Checksum: models[${i}].sha256Checksum,
+  addon: models[${i}].addon,
+  engine: models[${i}].engine,
+  quantization: models[${i}].quantization,
+  params: models[${i}].params,
+} as const;`;
+    })
+        .join("\n\n");
+    return `// THIS FILE IS AUTO-GENERATED BY models/update-models
+// DO NOT MODIFY MANUALLY
+
+export type RegistryItem = {
+  name: string;
+  registryPath: string;
+  registrySource: string;
+  blobCoreKey: string;
+  blobBlockOffset: number;
+  blobBlockLength: number;
+  blobByteOffset: number;
+  modelId: string;
+  addon: "llm" | "whisper" | "embeddings" | "nmt" | "vad" | "tts" | "ocr" | "other";
+  expectedSize: number;
+  sha256Checksum: string;
+  engine: string;
+  quantization: string;
+  params: string;
+  shardMetadata?: readonly { 
+    filename: string; 
+    expectedSize: number; 
+    sha256Checksum: string; 
+    blobCoreKey: string; 
+    blobBlockOffset: number;
+    blobBlockLength: number;
+    blobByteOffset: number;
+  }[];
+};
+
+export type ModelConstant = {
+  name: string;
+  src: string;
+  registryPath: string;
+  registrySource: string;
+  blobCoreKey: string;
+  blobBlockOffset: number;
+  blobBlockLength: number;
+  blobByteOffset: number;
+  modelId: string;
+  expectedSize: number;
+  sha256Checksum: string;
+  addon: "llm" | "whisper" | "embeddings" | "nmt" | "vad" | "tts" | "ocr" | "other";
+  engine: string;
+  quantization: string;
+  params: string;
+};
+
+export const models = [
+${entries}
+] as const satisfies readonly RegistryItem[];
+
+// Individual model constants for direct import/use with loadModel
+// These contain all metadata and can be used directly: loadModel({ modelSrc: WHISPER_TINY, ... })
+${exports}
+
+// Helper function to get model by name
+export function getModelByName(name: string): RegistryItem | undefined {
+  return models.find((model) => model.name === name);
+}
+
+// Helper function to get model by registry path
+export function getModelByPath(registryPath: string): RegistryItem | undefined {
+  return models.find((model) => model.registryPath === registryPath);
+}
+
+// Helper function for blob-based lookups
+export function getModelBySrc(modelId: string, blobCoreKey: string): RegistryItem | undefined {
+  return models.find((model) => model.modelId === modelId && model.blobCoreKey === blobCoreKey);
+}
+`;
+}

package/dist/models/update-models/history.d.ts

@@ -0,0 +1,13 @@
+import type { CurrentModel, ProcessedModel } from "./types";
+export declare function loadCurrentModels(outputFile: string): CurrentModel[];
+export declare function compareModels(remoteModels: ProcessedModel[], currentModels: CurrentModel[]): {
+    added: ProcessedModel[];
+    removed: CurrentModel[];
+};
+export declare function assignNames(models: ProcessedModel[]): (ProcessedModel & {
+    name: string;
+})[];
+export declare function createHistoryFile(added: (ProcessedModel & {
+    name: string;
+})[], removed: CurrentModel[], currentModels: CurrentModel[], historyDir: string): string | null;
+//# sourceMappingURL=history.d.ts.map

package/dist/models/update-models/history.js

@@ -0,0 +1,88 @@
+import fs from "fs";
+import { generateExportName } from "./naming.js";
+import { getCommitHash } from "./utils.js";
+export function loadCurrentModels(outputFile) {
+    try {
+        if (!fs.existsSync(outputFile)) {
+            return [];
+        }
+        const content = fs.readFileSync(outputFile, "utf-8");
+        const modelsMatch = content.match(/export const models = \[([\s\S]*?)\] as const/);
+        if (!modelsMatch?.[1]) {
+            return [];
+        }
+        const modelsArrayContent = modelsMatch[1];
+        const currentModels = [];
+        const modelRegex = /\{[^}]+name:\s*"([^"]+)"[^}]+(?:registryPath|hyperbeeKey):\s*"([^"]+)"[^}]+\}/g;
+        let match;
+        while ((match = modelRegex.exec(modelsArrayContent)) !== null) {
+            if (match[1] && match[2]) {
+                currentModels.push({
+                    name: match[1],
+                    registryPath: match[2],
+                });
+            }
+        }
+        return currentModels;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.warn("⚠️  Could not load current models:", message);
+        return [];
+    }
+}
+export function compareModels(remoteModels, currentModels) {
+    const currentPaths = new Set(currentModels.map((m) => m.registryPath));
+    const remotePaths = new Set(remoteModels.map((m) => m.registryPath));
+    const added = remoteModels.filter((m) => !currentPaths.has(m.registryPath));
+    const removed = currentModels.filter((m) => !remotePaths.has(m.registryPath));
+    return { added, removed };
+}
+export function assignNames(models) {
+    const usedNames = new Set();
+    return models.map((m) => ({
+        ...m,
+        name: generateExportName({
+            path: m.registryPath,
+            engine: m.engine,
+            name: m.modelName,
+            quantization: m.quantization,
+            params: m.params,
+            tags: m.tags,
+            usedNames,
+        }),
+    }));
+}
+export function createHistoryFile(added, removed, currentModels, historyDir) {
+    if (added.length === 0 && removed.length === 0) {
+        return null;
+    }
+    if (!fs.existsSync(historyDir)) {
+        fs.mkdirSync(historyDir, { recursive: true });
+    }
+    const shortHash = getCommitHash(true);
+    const fullHash = getCommitHash(false);
+    const timestamp = new Date().toISOString();
+    const filename = `${shortHash}.txt`;
+    const filepath = `${historyDir}/${filename}`;
+    let content = `commit=${fullHash}\n`;
+    content += `timestamp=${timestamp}\n`;
+    content += `previous_count=${currentModels.length}\n`;
+    content += `new_count=${currentModels.length + added.length - removed.length}\n`;
+    content += `\n`;
+    if (added.length > 0) {
+        content += `[added]\n`;
+        added.forEach((m) => {
+            content += `${m.name}\n`;
+        });
+        content += `\n`;
+    }
+    if (removed.length > 0) {
+        content += `[removed]\n`;
+        removed.forEach((m) => {
+            content += `${m.name}\n`;
+        });
+    }
+    fs.writeFileSync(filepath, content);
+    return filepath;
+}

package/dist/models/update-models/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/models/update-models/index.js

@@ -0,0 +1,124 @@
+import fs from "fs";
+import { fileURLToPath } from "url";
+import { execSync } from "child_process";
+import { generateModelsFileContent } from "./codegen.js";
+import { generateExportName } from "./naming.js";
+import { assignNames, compareModels, createHistoryFile, loadCurrentModels, } from "./history.js";
+import { collectModels } from "./registry.js";
+import { formatSize } from "./utils.js";
+const OUTPUT_FILE = fileURLToPath(new URL("../registry/models.ts", import.meta.url));
+const HISTORY_DIR = fileURLToPath(new URL("../history", import.meta.url));
+async function checkOnly(nonBlocking = false, showDuplicates = false) {
+    const timeoutMs = 30000;
+    let timedOut = false;
+    const timeoutPromise = new Promise((resolve) => {
+        setTimeout(() => {
+            timedOut = true;
+            console.log("⏱️  Model check timed out");
+            console.log("   Run 'bun check-models' manually to retry");
+            resolve(null);
+        }, timeoutMs);
+    });
+    try {
+        const result = await Promise.race([
+            (async () => {
+                const remoteModels = await collectModels({ showDuplicates });
+                const currentModels = loadCurrentModels(OUTPUT_FILE);
+                remoteModels.sort((a, b) => a.addon.localeCompare(b.addon) ||
+                    a.registryPath.localeCompare(b.registryPath));
+                return { remoteModels, currentModels };
+            })(),
+            timeoutPromise,
+        ]);
+        if (timedOut || !result) {
+            process.exit(nonBlocking ? 0 : 1);
+        }
+        const { remoteModels, currentModels } = result;
+        const { added, removed } = compareModels(remoteModels, currentModels);
+        if (added.length === 0 && removed.length === 0) {
+            console.log(`✅ Models are up to date (${remoteModels.length} models)`);
+            process.exit(0);
+        }
+        console.log("");
+        console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+        if (added.length > 0) {
+            console.log(`✨ ${added.length} new model${added.length === 1 ? "" : "s"} available:`);
+            const usedNames = new Set();
+            added.slice(0, 10).forEach((m) => {
+                const exportName = generateExportName({
+                    path: m.registryPath,
+                    engine: m.engine,
+                    name: m.modelName,
+                    quantization: m.quantization,
+                    params: m.params,
+                    tags: m.tags,
+                    usedNames,
+                });
+                console.log(`  + ${exportName} (${m.addon}, ${formatSize(m.expectedSize)})`);
+            });
+            if (added.length > 10) {
+                console.log(`  ... and ${added.length - 10} more`);
+            }
+        }
+        if (removed.length > 0) {
+            console.log(`\n⚠️  ${removed.length} model${removed.length === 1 ? "" : "s"} removed:`);
+            removed.slice(0, 5).forEach((m) => {
+                console.log(`  - ${m.name}`);
+            });
+            if (removed.length > 5) {
+                console.log(`  ... and ${removed.length - 5} more`);
+            }
+        }
+        console.log("");
+        console.log(`💡 Run 'bun update-models' to sync changes`);
+        console.log("");
+        if (nonBlocking) {
+            console.log("💡 Commit will proceed - update models when ready");
+        }
+        console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+        console.log("");
+        process.exit(nonBlocking ? 0 : 1);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error("❌ Model check failed:", message);
+        process.exit(nonBlocking ? 0 : 1);
+    }
+}
+async function updateModels(showDuplicates = false, noDedup = false) {
+    console.log("🔄 Fetching models from QVAC Registry...\n");
+    const currentModels = loadCurrentModels(OUTPUT_FILE);
+    const models = await collectModels({ showDuplicates, noDedup });
+    const { added, removed } = compareModels(models, currentModels);
+    models.sort((a, b) => a.addon.localeCompare(b.addon) ||
+        a.registryPath.localeCompare(b.registryPath));
+    fs.writeFileSync(OUTPUT_FILE, generateModelsFileContent(models));
+    try {
+        execSync(`npx prettier --write "${OUTPUT_FILE}"`, { stdio: "pipe" });
+    }
+    catch {
+        // prettier not available, skip formatting
+    }
+    console.log(`✅ Generated ${models.length} models → ${OUTPUT_FILE}`);
+    const addedWithNames = assignNames(added);
+    if (added.length > 0 || removed.length > 0) {
+        const historyFile = createHistoryFile(addedWithNames, removed, currentModels, HISTORY_DIR);
+        if (historyFile) {
+            console.log(`📜 Created history file → ${historyFile}`);
+            console.log(`   Added: ${added.length}, Removed: ${removed.length}`);
+        }
+    }
+}
+async function main() {
+    const CHECK_ONLY = process.argv.includes("--check");
+    const NON_BLOCKING = process.argv.includes("--non-blocking");
+    const SHOW_DUPLICATES = process.argv.includes("--show-duplicates");
+    const NO_DEDUP = process.argv.includes("--no-dedup");
+    if (CHECK_ONLY) {
+        await checkOnly(NON_BLOCKING, SHOW_DUPLICATES);
+    }
+    else {
+        await updateModels(SHOW_DUPLICATES, NO_DEDUP);
+    }
+}
+main().catch(console.error);

package/dist/models/update-models/naming.d.ts

@@ -0,0 +1,4 @@
+import type { ExportNameInput } from "./types";
+export declare function cleanPart(p: string): string;
+export declare function generateExportName({ path: registryPath, engine, name: modelName, quantization, params, tags, usedNames, }: ExportNameInput): string;
+//# sourceMappingURL=naming.d.ts.map

package/dist/models/update-models/naming.js

@@ -0,0 +1,314 @@
+import { getAddonFromEngine } from "../../schemas/engine-addon-map";
+import { detectShardedModel } from "./shards.js";
+// Normalizes a name part to a valid JS export name fragment.
+// Strips ggml/gguf prefixes, shortens "instruct" to "inst",
+// and uppercases with underscore separators.
+export function cleanPart(p) {
+    if (!p)
+        return "";
+    return p
+        .replace(/ggml-?/gi, "")
+        .replace(/gguf-?/gi, "")
+        .replace(/instruct/gi, "inst")
+        .replace(/^-+|-+$/g, "")
+        .toUpperCase()
+        .replace(/[^A-Z0-9]+/g, "_");
+}
+// Generates a unique export constant name for a model based on its
+// registry metadata, engine type, tags, and filename.
+export function generateExportName({ path: registryPath, engine, name: modelName, quantization, params, tags, usedNames, }) {
+    let addon = getAddonFromEngine(engine);
+    // Override addon classification when tags clearly indicate a different type.
+    // e.g. SmolVLM2 f16 uses translation-llamacpp engine (→nmt) but is actually a multimodal LLM.
+    if (addon === "nmt" &&
+        tags.some((t) => t === "generation" || t === "multimodal")) {
+        addon = "llm";
+    }
+    let exportName = "";
+    const filename = decodeURIComponent(registryPath.split("/").pop() || registryPath);
+    const lowerFilename = filename.toLowerCase();
+    const lowerPath = registryPath.toLowerCase();
+    // Extract structured info from tags array.
+    // Tags typically contain: [function, type, modelName, langPair/other]
+    const tagType = tags[1] || "";
+    const tagName = tags[2] || "";
+    const tagExtra = tags[3] || "";
+    exportName = generateBaseName({
+        addon,
+        engine,
+        filename,
+        lowerFilename,
+        lowerPath,
+        modelName,
+        quantization,
+        params,
+        tagType,
+        tagName,
+        tagExtra,
+        tags,
+    });
+    exportName = exportName.replace(/^_+|_+$/g, "").replace(/_+/g, "_");
+    // Add suffix for metadata files (tensors.txt are shard metadata, not actual models)
+    if (lowerFilename.endsWith(".tensors.txt")) {
+        exportName = `${exportName}_TENSORS`;
+    }
+    // Add SHARD suffix for sharded models
+    if (detectShardedModel(filename).isSharded) {
+        exportName = `${exportName}_SHARD`;
+    }
+    return resolveCollision(exportName, quantization, usedNames);
+}
+// Resolves name collisions by appending quantization or a sequential counter.
+function resolveCollision(exportName, quantization, usedNames) {
+    let finalName = exportName || "UNKNOWN_MODEL";
+    if (usedNames.has(finalName) && quantization) {
+        const cleanedQuant = cleanPart(quantization);
+        // Only append quantization if it's not already at the end of the name
+        if (cleanedQuant && !exportName.endsWith(cleanedQuant)) {
+            const withQuant = `${exportName}_${cleanedQuant}`;
+            if (!usedNames.has(withQuant)) {
+                finalName = withQuant;
+            }
+        }
+    }
+    let counter = 1;
+    while (usedNames.has(finalName)) {
+        finalName = `${exportName}_${counter++}`;
+    }
+    usedNames.add(finalName);
+    return finalName;
+}
+function generateBaseName(input) {
+    const { addon, lowerFilename } = input;
+    // Detect VAD Silero before whisper (same engine, different model type)
+    if (lowerFilename.includes("silero")) {
+        return generateVadSileroName(input);
+    }
+    switch (addon) {
+        case "whisper":
+            return generateWhisperName(input);
+        case "vad":
+            return generateVadName(input);
+        case "nmt":
+            return generateNmtName(input);
+        case "llm":
+            return generateLlmName(input);
+        case "embeddings":
+            return generateEmbeddingsName(input);
+        case "tts":
+            return generateTtsName(input);
+        case "ocr":
+            return generateOcrName(input);
+        default:
+            return cleanPart(input.filename.replace(/\.\w+$/, ""));
+    }
+}
+function generateVadSileroName({ filename }) {
+    const versionMatch = filename.match(/v(\d+\.\d+\.\d+)/i);
+    const version = versionMatch ? versionMatch[1] : "";
+    const nameParts = ["SILERO", version].filter((p) => p && p !== "");
+    return `VAD_${nameParts.map(cleanPart).join("_")}`;
+}
+function generateWhisperName({ filename, lowerFilename, quantization, }) {
+    // Extract language from filename prefix (e.g. "de-tiny-ggml-model-f16.bin")
+    const langPrefixMatch = filename.match(/^([a-z]{2})-/i);
+    // Detect English-only models from ".en" or ".en-" in filename
+    const isEnglishOnly = /\.en[-.]/.test(lowerFilename) || lowerFilename.endsWith(".en.bin");
+    // Extract size from filename
+    const sizeMatch = filename.match(/\b(tiny|base|small|medium|large(?:-v[0-9]+)?(?:-turbo)?)\b/i);
+    const modelSize = sizeMatch ? sizeMatch[1] : "";
+    // Extract quant from filename (f16, q8_0, etc.)
+    const quantMatch = filename.match(/[-_](f16|q[0-9]+[_][0-9]+|q8)\b/i);
+    const fileQuant = quantMatch ? quantMatch[1] : quantization;
+    const nameParts = [];
+    if (langPrefixMatch) {
+        const langCode = langPrefixMatch[1].toLowerCase();
+        const langMap = {
+            de: "GERMAN",
+            es: "SPANISH",
+            fr: "FRENCH",
+            it: "ITALIAN",
+            ja: "JAPANESE",
+            pt: "PORTUGUESE",
+            ru: "RUSSIAN",
+            nb: "NORWEGIAN",
+            en: "ENGLISH",
+        };
+        const langName = langMap[langCode] || langCode.toUpperCase();
+        nameParts.push(langName);
+    }
+    else if (isEnglishOnly) {
+        nameParts.push("EN");
+    }
+    if (modelSize)
+        nameParts.push(modelSize);
+    if (fileQuant)
+        nameParts.push(fileQuant);
+    return `WHISPER_${nameParts.map(cleanPart).join("_")}`;
+}
+function generateVadName({ filename, tagType, tagName, }) {
+    const versionMatch = filename.match(/v(\d+\.\d+\.\d+)/i);
+    const version = versionMatch ? versionMatch[1] : "";
+    const typeName = tagType || tagName || "SILERO";
+    const nameParts = [typeName, version].filter((p) => p && p !== "");
+    return `VAD_${nameParts.map(cleanPart).join("_")}`;
+}
+function generateNmtName(input) {
+    const { lowerPath, lowerFilename } = input;
+    if (lowerPath.includes("salamandra") ||
+        lowerFilename.includes("salamandra")) {
+        return generateNmtSalamandraName(input);
+    }
+    if (lowerPath.includes("indictrans") ||
+        lowerFilename.includes("indictrans")) {
+        return generateNmtIndictransName(input);
+    }
+    if (lowerPath.includes("opus") || lowerFilename.includes("opus")) {
+        return generateNmtOpusName(input);
+    }
+    if (lowerPath.includes("bergamot") || lowerFilename.includes("bergamot")) {
+        return generateNmtBergamotName(input);
+    }
+    const nameParts = [input.modelName, input.quantization].filter((p) => p && p !== "");
+    return `NMT_${nameParts.map(cleanPart).join("_")}`;
+}
+function generateNmtSalamandraName({ filename }) {
+    const base = filename.replace(/\.\w+$/, "").replace(/-\d{5}-of-\d{5}/, "");
+    return cleanPart(base);
+}
+function generateNmtIndictransName({ filename, quantization, }) {
+    const langMatch = filename.match(/(en-indic|indic-en|indic-indic)/i);
+    const langDir = langMatch ? langMatch[1] : "";
+    const langMap = {
+        "en-indic": "EN_HI",
+        "indic-en": "HI_EN",
+        "indic-indic": "HI_HI",
+    };
+    const langPair = langMap[langDir.toLowerCase()] || cleanPart(langDir);
+    const sizeMatch = filename.match(/(\d+[MB])/i);
+    const size = sizeMatch ? sizeMatch[1] : "";
+    const nameParts = [langPair, "INDIC", size, quantization].filter((p) => p && p !== "");
+    return `MARIAN_${nameParts.map(cleanPart).join("_")}`;
+}
+function generateNmtOpusName({ filename, quantization, tagExtra, }) {
+    const langMatch = filename.match(/-([a-z]{2,3})-([a-z]{2,3})\./i);
+    let langPair = "";
+    if (langMatch) {
+        langPair = `${langMatch[1].toUpperCase()}_${langMatch[2].toUpperCase()}`;
+    }
+    else {
+        const tagLang = tagExtra || "";
+        if (tagLang.match(/^[a-z]{2}-[a-z]{2}$/i)) {
+            const [src, tgt] = tagLang.split("-");
+            langPair = `${src.toUpperCase()}_${tgt.toUpperCase()}`;
+        }
+    }
+    if (!langPair) {
+        const roaMatch = filename.match(/-([a-z]{2,3})-([a-z]{2,3})-f16/i);
+        if (roaMatch) {
+            langPair = `${roaMatch[1].toUpperCase()}_${roaMatch[2].toUpperCase()}`;
+        }
+    }
+    const nameParts = [langPair, quantization].filter((p) => p && p !== "");
+    return `MARIAN_OPUS_${nameParts.map(cleanPart).join("_")}`;
+}
+function generateNmtBergamotName({ filename }) {
+    const langMatch = filename.match(/[.]([a-z]{2,4})[.]/i);
+    let langPair = "";
+    if (langMatch) {
+        const code = langMatch[1];
+        if (code.length === 4) {
+            langPair = `${code.slice(0, 2).toUpperCase()}_${code.slice(2).toUpperCase()}`;
+        }
+        else {
+            langPair = code.toUpperCase();
+        }
+    }
+    let suffix = "";
+    if (filename.startsWith("model.")) {
+        suffix = "";
+    }
+    else if (filename.match(/^vocab\./)) {
+        suffix = "_VOCAB";
+    }
+    else if (filename.match(/^srcvocab\./)) {
+        suffix = "_SRCVOCAB";
+    }
+    else if (filename.match(/^trgvocab\./)) {
+        suffix = "_TRGVOCAB";
+    }
+    else if (filename.startsWith("lex.")) {
+        suffix = "_LEX";
+    }
+    else if (filename === "metadata.json") {
+        suffix = "_METADATA";
+    }
+    return `BERGAMOT_${langPair}${suffix}`;
+}
+function generateLlmName({ filename, tagType, tagName, modelName, quantization, params, }) {
+    const type = tagType || "";
+    const name = tagName || modelName || "";
+    const isMMProj = filename.includes("mmproj");
+    // Try to extract model family from filename to recover version info
+    // that tags may omit (e.g., tag "qwen" but filename "Qwen3-1.7B-...")
+    let familyName = name;
+    if (params) {
+        const parseFn = filename
+            .replace(/^mmproj[-_]/i, "")
+            .replace(/\.tensors\.txt$/, "")
+            .replace(/\.\w+$/, "")
+            .replace(/-\d{5}-of-\d{5}/, "");
+        const paramsEsc = params.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const familyMatch = parseFn.match(new RegExp(`^(.+?)[-_]${paramsEsc}`, "i"));
+        if (familyMatch?.[1]) {
+            const candidate = familyMatch[1];
+            // Use filename family only if it extends the tag name
+            // Strip common engine/format suffixes from tag before comparing
+            const tagCore = name.replace(/[-_](ggml|cpp|onnx|llamacpp|metal)$/i, "");
+            const cleanedCandidate = candidate.replace(/[-_.]/g, "").toLowerCase();
+            const cleanedTagCore = tagCore.replace(/[-_.]/g, "").toLowerCase();
+            if (cleanedCandidate.startsWith(cleanedTagCore) &&
+                cleanedCandidate.length >= cleanedTagCore.length) {
+                familyName = candidate;
+            }
+        }
+    }
+    const nameParts = [familyName, params, type, quantization].filter((p) => p && p !== "");
+    let exportName = nameParts.map(cleanPart).join("_");
+    if (isMMProj) {
+        exportName = "MMPROJ_" + exportName;
+    }
+    return exportName;
+}
+function generateEmbeddingsName({ tagName, modelName, params, quantization, }) {
+    const name = tagName || modelName || "";
+    const nameParts = [name, params, quantization].filter((p) => p && p !== "");
+    return nameParts.map(cleanPart).join("_");
+}
+function generateTtsName({ filename, tagName, modelName, tagExtra, tagType, quantization, }) {
+    const name = tagName || modelName || "";
+    const language = tagExtra || "";
+    const type = tagType || "";
+    const nameParts = [name, language, type, quantization].filter((p) => p && p !== "");
+    let exportName = `TTS_${nameParts.map(cleanPart).join("_")}`;
+    if (filename.endsWith(".onnx.json") || filename.includes("config.json")) {
+        exportName = exportName + "_CONFIG";
+    }
+    if (filename.endsWith(".onnx_data")) {
+        exportName = exportName + "_DATA";
+    }
+    return exportName;
+}
+function generateOcrName({ filename, tagName, modelName, tagExtra, }) {
+    const name = tagName || modelName || "";
+    const language = tagExtra || "";
+    let fileType = "";
+    if (filename.includes("detector")) {
+        fileType = "DETECTOR";
+    }
+    else if (filename.includes("recognizer")) {
+        fileType = "RECOGNIZER";
+    }
+    const nameParts = [name, language, fileType].filter((p) => p && p !== "");
+    return `OCR_${nameParts.map(cleanPart).join("_")}`;
+}