@qvac/sdk 0.17.0 → 0.18.0

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

@@ -1,24 +0,0 @@
-import type { CurrentModel, ProcessedModel } from './types.js';
-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 separateUpdates(added: (ProcessedModel & {
-    name: string;
-})[], removed: CurrentModel[]): {
-    added: (ProcessedModel & {
-        name: string;
-    })[];
-    updated: (ProcessedModel & {
-        name: string;
-    })[];
-    removed: CurrentModel[];
-};
-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

@@ -1,107 +0,0 @@
-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*(['"`])([^'"`]+)\1[^}]+(?:registryPath|hyperbeeKey):\s*(['"`])([^'"`]+)\3[^}]+\}/g;
-        let match;
-        while ((match = modelRegex.exec(modelsArrayContent)) !== null) {
-            if (match[2] && match[4]) {
-                currentModels.push({
-                    name: match[2],
-                    registryPath: match[4]
-                });
-            }
-        }
-        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 separateUpdates(added, removed) {
-    const removedNames = new Set(removed.map((m) => m.name));
-    const addedNames = new Set(added.map((m) => m.name));
-    const updatedNames = new Set([...addedNames].filter((name) => removedNames.has(name)));
-    return {
-        added: added.filter((m) => !updatedNames.has(m.name)),
-        updated: added.filter((m) => updatedNames.has(m.name)),
-        removed: removed.filter((m) => !updatedNames.has(m.name))
-    };
-}
-export function createHistoryFile(added, removed, currentModels, historyDir) {
-    if (added.length === 0 && removed.length === 0) {
-        return null;
-    }
-    const { added: trulyAdded, updated, removed: trulyRemoved } = separateUpdates(added, removed);
-    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 + trulyAdded.length - trulyRemoved.length}\n`;
-    content += `\n`;
-    if (trulyAdded.length > 0) {
-        content += `[added]\n`;
-        trulyAdded.forEach((m) => {
-            content += `${m.name}\n`;
-        });
-        content += `\n`;
-    }
-    if (updated.length > 0) {
-        content += `[updated]\n`;
-        updated.forEach((m) => {
-            content += `${m.name}\n`;
-        });
-        content += `\n`;
-    }
-    if (trulyRemoved.length > 0) {
-        content += `[removed]\n`;
-        trulyRemoved.forEach((m) => {
-            content += `${m.name}\n`;
-        });
-        content += `\n`;
-    }
-    fs.writeFileSync(filepath, content);
-    return filepath;
-}

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

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

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

@@ -1,123 +0,0 @@
-import fs from 'fs';
-import { fileURLToPath } from 'url';
-import { execSync } from 'child_process';
-import { generateModelsFileContent } from './codegen.js';
-import { assignNames, compareModels, createHistoryFile, loadCurrentModels, separateUpdates } 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: rawAdded, removed: rawRemoved } = compareModels(remoteModels, currentModels);
-        if (rawAdded.length === 0 && rawRemoved.length === 0) {
-            console.log(`✅ Models are up to date (${remoteModels.length} models)`);
-            process.exit(0);
-        }
-        const addedWithNames = assignNames(rawAdded);
-        const { added, updated, removed } = separateUpdates(addedWithNames, rawRemoved);
-        console.log('');
-        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-        if (added.length > 0) {
-            console.log(`✨ ${added.length} new model${added.length === 1 ? '' : 's'} available:`);
-            added.slice(0, 10).forEach((m) => {
-                console.log(`  + ${m.name} (${m.addon}, ${formatSize(m.expectedSize)})`);
-            });
-            if (added.length > 10) {
-                console.log(`  ... and ${added.length - 10} more`);
-            }
-        }
-        if (updated.length > 0) {
-            console.log(`\n🔄 ${updated.length} model${updated.length === 1 ? '' : 's'} updated:`);
-            updated.slice(0, 10).forEach((m) => {
-                console.log(`  ~ ${m.name} (${m.addon}, ${formatSize(m.expectedSize)})`);
-            });
-            if (updated.length > 10) {
-                console.log(`  ... and ${updated.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) {
-            const { added: trulyAdded, updated, removed: trulyRemoved } = separateUpdates(addedWithNames, removed);
-            console.log(`📜 Created history file → ${historyFile}`);
-            console.log(`   Added: ${trulyAdded.length}, Updated: ${updated.length}, Removed: ${trulyRemoved.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

@@ -1,4 +0,0 @@
-import type { ExportNameInput } from './types.js';
-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

@@ -1,396 +0,0 @@
-import { getAddonFromEngine } from '../../schemas/engine-addon-map.js';
-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 'bci':
-            return generateBciName(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);
-        case 'parakeet':
-            return generateParakeetName(input);
-        case 'diffusion':
-            return generateDiffusionName(input);
-        case 'audiogen':
-            return generateAudioGenName(input);
-        default:
-            return cleanPart(input.filename.replace(/\.\w+$/, ''));
-    }
-}
-function generateAudioGenName({ filename }) {
-    const modelName = cleanPart(filename.replace(/\.\w+$/, ''));
-    return `AUDIOGEN_${modelName}`;
-}
-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 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('_')}`;
-}
-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('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 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 familyTokens = cleanPart(familyName).split('_');
-    // Avoid duplicating params when the registry model name already ends with
-    // the same size (for example, Qwen3-4B + 4B).
-    const paramsAlreadyIncluded = params !== '' && familyTokens[familyTokens.length - 1] === cleanPart(params);
-    const nameParts = [familyName, paramsAlreadyIncluded ? '' : 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('_')}`;
-}
-function generateDiffusionName({ filename, modelName, quantization, params, tags }) {
-    // VAE / auxiliary models (tagged "vae" instead of "generation")
-    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');
-    // 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'), '');
-    }
-    if (quantization) {
-        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('_');
-}
-function generateParakeetName({ filename, lowerPath, quantization }) {
-    const lower = filename.toLowerCase();
-    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('eou') || lowerPath.includes('parakeet-rs')) {
-        variant = 'EOU';
-    }
-    else if (lower.includes('tdt') || lowerPath.includes('parakeet-tdt')) {
-        variant = 'TDT';
-    }
-    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('_')}`;
-    }
-    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('decoder')) {
-        fileRole = 'DECODER';
-    }
-    else if (lower.includes('vocab')) {
-        fileRole = 'VOCAB';
-    }
-    else if (lower.includes('tokenizer')) {
-        fileRole = 'TOKENIZER';
-    }
-    else if (lower.includes('preprocessor') || lower.includes('nemo')) {
-        fileRole = 'PREPROCESSOR';
-    }
-    else if (lower === 'config.json') {
-        fileRole = 'CONFIG';
-    }
-    else if (lower.endsWith('.onnx.data') || lower.endsWith('.onnx_data')) {
-        fileRole = 'DATA';
-    }
-    else if (lower.includes('sortformer')) {
-        fileRole = '';
-    }
-    else if (lower.endsWith('.onnx') || lower.endsWith('.int8.onnx')) {
-        fileRole = '';
-    }
-    else {
-        fileRole = cleanPart(filename.replace(/\.\w+$/, ''));
-    }
-    const nameParts = [variant, fileRole, quantization].filter((p) => p && p !== '');
-    return `PARAKEET_${nameParts.map(cleanPart).join('_')}`;
-}

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

@@ -1,8 +0,0 @@
-import type { QVACModelEntry } from '@qvac/registry-client';
-import type { ProcessedModel } from './types.js';
-export declare function toHexString(value: Buffer | string | {
-    data: number[];
-} | undefined): string;
-export declare function extractModelName(registryPath: string): string;
-export declare function processRegistryModel(model: QVACModelEntry): ProcessedModel | null;
-//# sourceMappingURL=processing.d.ts.map