@qvac/sdk 0.14.1 → 0.15.0

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

@@ -1,38 +1,37 @@
-import { getAddonFromEngine } from "../../schemas/engine-addon-map";
-import { detectShardedModel } from "./shards.js";
+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 '';
     return p
-        .replace(/ggml-?/gi, "")
-        .replace(/gguf-?/gi, "")
-        .replace(/instruct/gi, "inst")
-        .replace(/^-+|-+$/g, "")
+        .replace(/ggml-?/gi, '')
+        .replace(/gguf-?/gi, '')
+        .replace(/instruct/gi, 'inst')
+        .replace(/^-+|-+$/g, '')
         .toUpperCase()
-        .replace(/[^A-Z0-9]+/g, "_");
+        .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, }) {
+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";
+    if (addon === 'nmt' && tags.some((t) => t === 'generation' || t === 'multimodal')) {
+        addon = 'llm';
     }
-    let exportName = "";
-    const filename = decodeURIComponent(registryPath.split("/").pop() || registryPath);
+    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] || "";
+    const tagType = tags[1] || '';
+    const tagName = tags[2] || '';
+    const tagExtra = tags[3] || '';
     exportName = generateBaseName({
         addon,
         engine,
@@ -45,11 +44,11 @@ export function generateExportName({ path: registryPath, engine, name: modelName
         tagType,
         tagName,
         tagExtra,
-        tags,
+        tags
     });
-    exportName = exportName.replace(/^_+|_+$/g, "").replace(/_+/g, "_");
+    exportName = exportName.replace(/^_+|_+$/g, '').replace(/_+/g, '_');
     // Add suffix for metadata files (tensors.txt are shard metadata, not actual models)
-    if (lowerFilename.endsWith(".tensors.txt")) {
+    if (lowerFilename.endsWith('.tensors.txt')) {
         exportName = `${exportName}_TENSORS`;
     }
     // Add SHARD suffix for sharded models
@@ -60,7 +59,7 @@ export function generateExportName({ path: registryPath, engine, name: modelName
 }
 // Resolves name collisions by appending quantization or a sequential counter.
 function resolveCollision(exportName, quantization, usedNames) {
-    let finalName = exportName || "UNKNOWN_MODEL";
+    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
@@ -81,48 +80,48 @@ function resolveCollision(exportName, quantization, usedNames) {
 function generateBaseName(input) {
     const { addon, lowerFilename } = input;
     // Detect VAD Silero before whisper (same engine, different model type)
-    if (lowerFilename.includes("silero")) {
+    if (lowerFilename.includes('silero')) {
         return generateVadSileroName(input);
     }
     switch (addon) {
-        case "whisper":
+        case 'whisper':
             return generateWhisperName(input);
-        case "bci":
+        case 'bci':
             return generateBciName(input);
-        case "vad":
+        case 'vad':
             return generateVadName(input);
-        case "nmt":
+        case 'nmt':
             return generateNmtName(input);
-        case "llm":
+        case 'llm':
             return generateLlmName(input);
-        case "embeddings":
+        case 'embeddings':
             return generateEmbeddingsName(input);
-        case "tts":
+        case 'tts':
             return generateTtsName(input);
-        case "ocr":
+        case 'ocr':
             return generateOcrName(input);
-        case "parakeet":
+        case 'parakeet':
             return generateParakeetName(input);
-        case "diffusion":
+        case 'diffusion':
             return generateDiffusionName(input);
         default:
-            return cleanPart(input.filename.replace(/\.\w+$/, ""));
+            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("_")}`;
+    const version = versionMatch ? versionMatch[1] : '';
+    const nameParts = ['SILERO', version].filter((p) => p && p !== '');
+    return `VAD_${nameParts.map(cleanPart).join('_')}`;
 }
-function generateWhisperName({ filename, lowerFilename, quantization, }) {
+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");
+    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] : "";
+    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;
@@ -130,80 +129,78 @@ function generateWhisperName({ filename, lowerFilename, quantization, }) {
     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",
+            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");
+        nameParts.push('EN');
     }
     if (modelSize)
         nameParts.push(modelSize);
     if (fileQuant)
         nameParts.push(fileQuant);
-    return `WHISPER_${nameParts.map(cleanPart).join("_")}`;
+    return `WHISPER_${nameParts.map(cleanPart).join('_')}`;
 }
 function generateBciName({ filename, quantization }) {
     // Strip the engine/format prefix and a leading "BCI" token so role names
     // like "bci-embedder.bin" / "ggml-bci-windowed.bin" become EMBEDDER /
     // WINDOWED before we re-prefix with BCI_.
-    const role = cleanPart(filename.replace(/\.\w+$/, "")).replace(/^BCI_?/, "");
-    const nameParts = [role, quantization].filter((p) => p && p !== "");
-    return `BCI_${nameParts.map(cleanPart).join("_")}`;
+    const role = cleanPart(filename.replace(/\.\w+$/, '')).replace(/^BCI_?/, '');
+    const nameParts = [role, quantization].filter((p) => p && p !== '');
+    return `BCI_${nameParts.map(cleanPart).join('_')}`;
 }
-function generateVadName({ filename, tagType, tagName, }) {
+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("_")}`;
+    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")) {
+    if (lowerPath.includes('salamandra') || lowerFilename.includes('salamandra')) {
         return generateNmtSalamandraName(input);
     }
-    if (lowerPath.includes("indictrans") ||
-        lowerFilename.includes("indictrans")) {
+    if (lowerPath.includes('indictrans') || lowerFilename.includes('indictrans')) {
         return generateNmtIndictransName(input);
     }
-    if (lowerPath.includes("bergamot") || lowerFilename.includes("bergamot")) {
+    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("_")}`;
+    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}/, "");
+    const base = filename.replace(/\.\w+$/, '').replace(/-\d{5}-of-\d{5}/, '');
     return cleanPart(base);
 }
-function generateNmtIndictransName({ filename, quantization, }) {
+function generateNmtIndictransName({ filename, quantization }) {
     const langMatch = filename.match(/(en-indic|indic-en|indic-indic)/i);
-    const langDir = langMatch ? langMatch[1] : "";
+    const langDir = langMatch ? langMatch[1] : '';
     const langMap = {
-        "en-indic": "EN_HI",
-        "indic-en": "HI_EN",
-        "indic-indic": "HI_HI",
+        '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("_")}`;
+    const size = sizeMatch ? sizeMatch[1] : '';
+    const nameParts = [langPair, 'INDIC', size, quantization].filter((p) => p && p !== '');
+    return `MARIAN_${nameParts.map(cleanPart).join('_')}`;
 }
 function generateNmtBergamotName({ filename }) {
     const langMatch = filename.match(/[.]([a-z]{2,4})[.]/i);
-    let langPair = "";
+    let langPair = '';
     if (langMatch) {
         const code = langMatch[1];
         if (code.length === 4) {
@@ -213,183 +210,177 @@ function generateNmtBergamotName({ filename }) {
             langPair = code.toUpperCase();
         }
     }
-    let suffix = "";
-    if (filename.startsWith("model.")) {
-        suffix = "";
+    let suffix = '';
+    if (filename.startsWith('model.')) {
+        suffix = '';
     }
     else if (filename.match(/^vocab\./)) {
-        suffix = "_VOCAB";
+        suffix = '_VOCAB';
     }
     else if (filename.match(/^srcvocab\./)) {
-        suffix = "_SRCVOCAB";
+        suffix = '_SRCVOCAB';
     }
     else if (filename.match(/^trgvocab\./)) {
-        suffix = "_TRGVOCAB";
+        suffix = '_TRGVOCAB';
     }
-    else if (filename.startsWith("lex.")) {
-        suffix = "_LEX";
+    else if (filename.startsWith('lex.')) {
+        suffix = '_LEX';
     }
-    else if (filename === "metadata.json") {
-        suffix = "_METADATA";
+    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");
+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"));
+            .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();
+            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("_");
+    const nameParts = [familyName, params, type, quantization].filter((p) => p && p !== '');
+    let exportName = nameParts.map(cleanPart).join('_');
     if (isMMProj) {
-        exportName = "MMPROJ_" + exportName;
+        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 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";
+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("_")}`;
+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('_')}`;
 }
-function generateDiffusionName({ filename, modelName, quantization, params, tags, }) {
+function generateDiffusionName({ filename, modelName, quantization, params, tags }) {
     // VAE / auxiliary models (tagged "vae" instead of "generation")
-    if (tags.includes("vae")) {
-        const name = modelName || "SD";
+    if (tags.includes('vae')) {
+        const name = modelName || 'SD';
         return `${cleanPart(name)}_VAE`;
     }
     // Extract family name from filename
     let family = filename
-        .replace(/\.\w+$/, "")
-        .replace(/^stable-diffusion-xl/i, "SDXL")
-        .replace(/^stable-diffusion/i, "SD");
+        .replace(/\.\w+$/, '')
+        .replace(/^stable-diffusion-xl/i, 'SDXL')
+        .replace(/^stable-diffusion/i, 'SD');
     // Strip trailing params (e.g. "-4b") and quant (e.g. "-Q8_0") from family
     // to avoid duplication since they're appended separately
     if (params) {
-        const paramsEsc = params.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        family = family.replace(new RegExp(`[-_]${paramsEsc}[-_].*$`, "i"), "");
+        const paramsEsc = params.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        family = family.replace(new RegExp(`[-_]${paramsEsc}[-_].*$`, 'i'), '');
     }
     if (quantization) {
-        const quantEsc = quantization.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        family = family.replace(new RegExp(`[-_]${quantEsc}$`, "i"), "");
+        const quantEsc = quantization.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        family = family.replace(new RegExp(`[-_]${quantEsc}$`, 'i'), '');
     }
-    const nameParts = [family, params, quantization].filter((p) => p && p !== "");
-    return nameParts.map(cleanPart).join("_");
+    const nameParts = [family, params, quantization].filter((p) => p && p !== '');
+    return nameParts.map(cleanPart).join('_');
 }
-function generateParakeetName({ filename, lowerPath, quantization, }) {
+function generateParakeetName({ filename, lowerPath, quantization }) {
     const lower = filename.toLowerCase();
-    let variant = "";
-    if (lower.includes("sortformer") || lower.includes("diar_streaming")) {
-        variant = "SORTFORMER";
+    let variant = '';
+    if (lower.includes('sortformer') || lower.includes('diar_streaming')) {
+        variant = 'SORTFORMER';
     }
-    else if (lower.includes("ctc") || lowerPath.includes("parakeet-ctc")) {
-        variant = "CTC";
+    else if (lower.includes('ctc') || lowerPath.includes('parakeet-ctc')) {
+        variant = 'CTC';
     }
-    else if (lower.includes("eou") || lowerPath.includes("parakeet-rs")) {
-        variant = "EOU";
+    else if (lower.includes('eou') || lowerPath.includes('parakeet-rs')) {
+        variant = 'EOU';
     }
-    else if (lower.includes("tdt") || lowerPath.includes("parakeet-tdt")) {
-        variant = "TDT";
+    else if (lower.includes('tdt') || lowerPath.includes('parakeet-tdt')) {
+        variant = 'TDT';
     }
-    if (lower.endsWith(".gguf")) {
+    if (lower.endsWith('.gguf')) {
         const paramsMatch = filename.match(/(?:^|[-_])(\d+(?:\.\d+)?[mb])(?=[-_.])/i);
         const versionMatch = filename.match(/[-_]v(\d+(?:\.\d+)?)/i);
         const speakerMatch = filename.match(/(\d+spk)/i);
-        const paramsHint = paramsMatch ? paramsMatch[1] : "";
-        const versionHint = versionMatch ? `V${versionMatch[1]}` : "";
-        const speakerHint = speakerMatch ? speakerMatch[1] : "";
-        const nameParts = [
-            variant,
-            paramsHint,
-            speakerHint,
-            versionHint,
-            quantization,
-        ].filter((p) => p && p !== "");
-        return `PARAKEET_${nameParts.map(cleanPart).join("_")}`;
+        const paramsHint = paramsMatch ? paramsMatch[1] : '';
+        const versionHint = versionMatch ? `V${versionMatch[1]}` : '';
+        const speakerHint = speakerMatch ? speakerMatch[1] : '';
+        const nameParts = [variant, paramsHint, speakerHint, versionHint, quantization].filter((p) => p && p !== '');
+        return `PARAKEET_${nameParts.map(cleanPart).join('_')}`;
     }
-    let fileRole = "";
-    if (lower.includes("encoder") && (lower.endsWith(".data") || lower.endsWith(".onnx.data"))) {
-        fileRole = "ENCODER_DATA";
+    let fileRole = '';
+    if (lower.includes('encoder') && (lower.endsWith('.data') || lower.endsWith('.onnx.data'))) {
+        fileRole = 'ENCODER_DATA';
     }
-    else if (lower.includes("encoder")) {
-        fileRole = "ENCODER";
+    else if (lower.includes('encoder')) {
+        fileRole = 'ENCODER';
     }
-    else if (lower.includes("decoder")) {
-        fileRole = "DECODER";
+    else if (lower.includes('decoder')) {
+        fileRole = 'DECODER';
     }
-    else if (lower.includes("vocab")) {
-        fileRole = "VOCAB";
+    else if (lower.includes('vocab')) {
+        fileRole = 'VOCAB';
     }
-    else if (lower.includes("tokenizer")) {
-        fileRole = "TOKENIZER";
+    else if (lower.includes('tokenizer')) {
+        fileRole = 'TOKENIZER';
     }
-    else if (lower.includes("preprocessor") || lower.includes("nemo")) {
-        fileRole = "PREPROCESSOR";
+    else if (lower.includes('preprocessor') || lower.includes('nemo')) {
+        fileRole = 'PREPROCESSOR';
     }
-    else if (lower === "config.json") {
-        fileRole = "CONFIG";
+    else if (lower === 'config.json') {
+        fileRole = 'CONFIG';
     }
-    else if (lower.endsWith(".onnx.data") || lower.endsWith(".onnx_data")) {
-        fileRole = "DATA";
+    else if (lower.endsWith('.onnx.data') || lower.endsWith('.onnx_data')) {
+        fileRole = 'DATA';
     }
-    else if (lower.includes("sortformer")) {
-        fileRole = "";
+    else if (lower.includes('sortformer')) {
+        fileRole = '';
     }
-    else if (lower.endsWith(".onnx") || lower.endsWith(".int8.onnx")) {
-        fileRole = "";
+    else if (lower.endsWith('.onnx') || lower.endsWith('.int8.onnx')) {
+        fileRole = '';
     }
     else {
-        fileRole = cleanPart(filename.replace(/\.\w+$/, ""));
+        fileRole = cleanPart(filename.replace(/\.\w+$/, ''));
     }
-    const nameParts = [variant, fileRole, quantization].filter((p) => p && p !== "");
-    return `PARAKEET_${nameParts.map(cleanPart).join("_")}`;
+    const nameParts = [variant, fileRole, quantization].filter((p) => p && p !== '');
+    return `PARAKEET_${nameParts.map(cleanPart).join('_')}`;
 }

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

@@ -1,5 +1,5 @@
-import type { QVACModelEntry } from "@qvac/registry-client";
-import type { ProcessedModel } from "./types";
+import type { QVACModelEntry } from '@qvac/registry-client';
+import type { ProcessedModel } from './types';
 export declare function toHexString(value: Buffer | string | {
     data: number[];
 } | undefined): string;

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

@@ -1,26 +1,26 @@
-import { getAddonFromEngine, resolveCanonicalEngine, } from "../../schemas/engine-addon-map";
-import { detectShardedModel } from "./shards.js";
+import { getAddonFromEngine, resolveCanonicalEngine } from '../../schemas/engine-addon-map';
+import { detectShardedModel } from './shards.js';
 export function toHexString(value) {
     if (!value)
-        return "";
+        return '';
     if (Buffer.isBuffer(value))
-        return value.toString("hex");
-    if (typeof value === "string")
+        return value.toString('hex');
+    if (typeof value === 'string')
         return value;
-    if (typeof value === "object" && "data" in value) {
-        return Buffer.from(value.data).toString("hex");
+    if (typeof value === 'object' && 'data' in value) {
+        return Buffer.from(value.data).toString('hex');
     }
-    return "";
+    return '';
 }
 export function extractModelName(registryPath) {
-    const parts = registryPath.split("/");
+    const parts = registryPath.split('/');
     if (parts.length >= 2) {
-        return parts[1] || parts[0] || "";
+        return parts[1] || parts[0] || '';
     }
     return (registryPath
-        .split("/")
+        .split('/')
         .pop()
-        ?.replace(/\.\w+$/, "") || "");
+        ?.replace(/\.\w+$/, '') || '');
 }
 export function processRegistryModel(model) {
     const engine = resolveCanonicalEngine(model.engine);
@@ -28,7 +28,7 @@ export function processRegistryModel(model) {
         console.warn(`⚠️  Skipping model with unknown engine "${model.engine}": ${model.path}`);
         return null;
     }
-    const filename = model.path.split("/").pop() || model.path;
+    const filename = model.path.split('/').pop() || model.path;
     const blobBinding = model.blobBinding;
     const blobCoreKey = toHexString(blobBinding?.coreKey);
     const blobBlockOffset = blobBinding?.blockOffset ?? 0;
@@ -37,9 +37,7 @@ export function processRegistryModel(model) {
     const expectedSize = blobBinding?.byteLength ?? 0;
     // The sha256 lives on blobBinding at runtime (per the hyperschema),
     // even though the TS types define it on QVACModelEntry. Try blobBinding first.
-    const sha256Checksum = blobBinding?.["sha256"] ||
-        model.sha256 ||
-        "";
+    const sha256Checksum = blobBinding?.['sha256'] || model.sha256 || '';
     const addon = getAddonFromEngine(engine);
     const result = {
         registryPath: model.path,
@@ -54,9 +52,9 @@ export function processRegistryModel(model) {
         sha256Checksum,
         engine,
         modelName: extractModelName(model.path),
-        quantization: model.quantization || "",
-        params: model.params || "",
-        tags: model.tags || [],
+        quantization: model.quantization || '',
+        params: model.params || '',
+        tags: model.tags || []
     };
     const shardDetection = detectShardedModel(filename);
     if (shardDetection.isSharded) {