@qvac/sdk 0.16.0 → 0.17.0

package/dist/commands/verify/resource-collectors.js

@@ -0,0 +1,261 @@
+import { promises as fsp } from 'node:fs';
+import path from 'node:path';
+import { createGzip } from 'node:zlib';
+import tarStream, {} from 'tar-stream';
+import { collectAddonsFromBundle } from '../../commands/verify/bundle-source.js';
+import { listBarePrebuildFiles } from '../../commands/verify/prebuilds.js';
+export const RESOURCE_COLLECTOR_PACKAGES = ['bare-cpu-info', 'bare-gpu-info'];
+export const RESOURCE_COLLECTOR_SIZE_BUDGETS = {
+    compressedBytes: 2 * 1024 * 1024,
+    uncompressedBytes: 5 * 1024 * 1024
+};
+const DEFAULT_MEASUREMENT_DEPENDENCIES = {
+    writeArchiveEntry
+};
+export async function acceptResourceCollectorPackaging(options) {
+    const addons = await collectAddonsFromBundle({
+        bundlePath: options.bundlePath,
+        projectRoot: options.projectRoot
+    });
+    const collectors = new Map(addons
+        .filter((addon) => isResourceCollectorPackage(addon.name))
+        .map((addon) => [addon.name, addon]));
+    const manifestResult = await readAddonsManifest(options.manifestPath);
+    const manifestAddons = new Set(manifestResult.manifest?.addons);
+    const issues = [];
+    const entriesByHost = new Map(options.hosts.map((host) => [host, []]));
+    const budgets = options.budgets ?? RESOURCE_COLLECTOR_SIZE_BUDGETS;
+    if (manifestResult.issue !== undefined)
+        issues.push(manifestResult.issue);
+    for (const packageName of RESOURCE_COLLECTOR_PACKAGES) {
+        const collector = collectors.get(packageName);
+        if (collector === undefined) {
+            issues.push({
+                code: 'missing-collector',
+                level: 'error',
+                package: packageName,
+                location: 'bundle',
+                message: `${packageName} is missing from the linked worker bundle graph.`
+            });
+        }
+        if (manifestResult.manifest !== undefined && !manifestAddons.has(packageName)) {
+            issues.push({
+                code: 'missing-collector',
+                level: 'error',
+                package: packageName,
+                location: 'manifest',
+                message: `${packageName} is missing from ${options.manifestPath}.`
+            });
+        }
+        if (collector === undefined)
+            continue;
+        for (const host of options.hosts) {
+            const hostDir = path.join(collector.packageRoot, 'prebuilds', host);
+            const files = await listBarePrebuildFiles(hostDir);
+            if (files.length === 0) {
+                issues.push({
+                    code: 'missing-prebuild',
+                    level: 'error',
+                    package: packageName,
+                    host,
+                    message: `${packageName} is missing a prebuild for ${host} ` +
+                        `(expected ${path.join(hostDir, '*.bare')}).`
+                });
+                continue;
+            }
+            for (const file of files) {
+                try {
+                    const contents = await fsp.readFile(file);
+                    entriesByHost.get(host)?.push({
+                        package: packageName,
+                        relativePath: normalizeArchivePath(path.relative(collector.packageRoot, file)),
+                        bytes: contents.byteLength,
+                        contents
+                    });
+                }
+                catch (error) {
+                    issues.push(measurementFailedIssue(packageName, host, error));
+                }
+            }
+        }
+    }
+    const targets = [];
+    for (const host of options.hosts) {
+        const entries = entriesByHost.get(host) ?? [];
+        entries.sort(compareMeasurementEntries);
+        try {
+            const target = await measureTarget(host, entries);
+            targets.push(target);
+            applyBudgets(target, budgets, issues);
+        }
+        catch (error) {
+            issues.push(measurementFailedIssue(entries[0]?.package ?? RESOURCE_COLLECTOR_PACKAGES[0], host, error));
+        }
+    }
+    return {
+        ok: issues.length === 0,
+        collectors: [...RESOURCE_COLLECTOR_PACKAGES],
+        hosts: [...options.hosts],
+        budgets,
+        targets,
+        issues
+    };
+}
+export function formatResourceCollectorAcceptanceReport(report) {
+    const lines = [
+        `Resource collector packaging: ${report.ok ? 'PASS' : 'FAIL'}`,
+        ...report.targets.map((target) => `${target.host}: ${target.compressedBytes} compressed / ` +
+            `${target.uncompressedBytes} uncompressed`),
+        `Budgets: ${formatMebibytes(report.budgets.compressedBytes)} compressed / ` +
+            `${formatMebibytes(report.budgets.uncompressedBytes)} uncompressed`
+    ];
+    for (const issue of report.issues) {
+        const details = [issue.code];
+        if ('host' in issue)
+            details.push(`host: ${issue.host}`);
+        if ('package' in issue)
+            details.push(`package: ${issue.package}`);
+        if ('actualBytes' in issue)
+            details.push(`actual: ${issue.actualBytes} bytes`);
+        if ('budgetBytes' in issue)
+            details.push(`limit: ${issue.budgetBytes} bytes`);
+        details.push(issue.message);
+        lines.push(`- ${details.join(' | ')}`);
+    }
+    return lines.join('\n');
+}
+function formatMebibytes(bytes) {
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MiB`;
+}
+function normalizeArchivePath(filePath) {
+    return filePath.replaceAll(path.sep, path.posix.sep);
+}
+function compareMeasurementEntries(left, right) {
+    const leftPath = `${left.package}/${left.relativePath}`;
+    const rightPath = `${right.package}/${right.relativePath}`;
+    if (leftPath < rightPath)
+        return -1;
+    if (leftPath > rightPath)
+        return 1;
+    return 0;
+}
+export async function measureTarget(host, entries, dependencies = DEFAULT_MEASUREMENT_DEPENDENCIES) {
+    const pack = tarStream.pack();
+    const gzip = createGzip({ level: 9 });
+    const compressedBytesPromise = countStreamBytes(gzip);
+    pack.pipe(gzip);
+    try {
+        for (const entry of entries) {
+            await dependencies.writeArchiveEntry(pack, entry);
+        }
+        pack.finalize();
+    }
+    catch (error) {
+        pack.destroy();
+        gzip.destroy();
+        await compressedBytesPromise.catch(() => { });
+        throw error;
+    }
+    return {
+        host,
+        files: entries.map(({ package: packageName, relativePath, bytes }) => ({
+            package: packageName,
+            relativePath,
+            bytes
+        })),
+        compressedBytes: await compressedBytesPromise,
+        uncompressedBytes: entries.reduce((total, entry) => total + entry.bytes, 0)
+    };
+}
+async function writeArchiveEntry(pack, entry) {
+    await new Promise((resolve, reject) => {
+        pack.entry({
+            name: `${entry.package}/${entry.relativePath}`,
+            mode: 0o644,
+            size: entry.bytes,
+            mtime: new Date(0)
+        }, entry.contents, (error) => {
+            if (error === null || error === undefined)
+                resolve();
+            else
+                reject(error);
+        });
+    });
+}
+async function countStreamBytes(stream) {
+    let bytes = 0;
+    for await (const chunk of stream)
+        bytes += Buffer.byteLength(chunk);
+    return bytes;
+}
+function applyBudgets(target, budgets, issues) {
+    if (target.compressedBytes > budgets.compressedBytes) {
+        issues.push({
+            code: 'compressed-budget-exceeded',
+            level: 'error',
+            host: target.host,
+            actualBytes: target.compressedBytes,
+            budgetBytes: budgets.compressedBytes,
+            message: `${target.host} resource collectors use ${target.compressedBytes} compressed bytes ` +
+                `(limit: ${budgets.compressedBytes}).`
+        });
+    }
+    if (target.uncompressedBytes > budgets.uncompressedBytes) {
+        issues.push({
+            code: 'uncompressed-budget-exceeded',
+            level: 'error',
+            host: target.host,
+            actualBytes: target.uncompressedBytes,
+            budgetBytes: budgets.uncompressedBytes,
+            message: `${target.host} resource collectors use ${target.uncompressedBytes} uncompressed bytes ` +
+                `(limit: ${budgets.uncompressedBytes}).`
+        });
+    }
+}
+function measurementFailedIssue(packageName, host, cause) {
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    return {
+        code: 'measurement-failed',
+        level: 'error',
+        package: packageName,
+        host,
+        message: `Could not measure ${packageName} for ${host}: ${reason}.`
+    };
+}
+function isResourceCollectorPackage(packageName) {
+    return RESOURCE_COLLECTOR_PACKAGES.some((collector) => collector === packageName);
+}
+async function readAddonsManifest(manifestPath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(await fsp.readFile(manifestPath, 'utf8'));
+    }
+    catch (error) {
+        return {
+            issue: invalidManifestIssue(manifestPath, error)
+        };
+    }
+    if (!isAddonsManifest(parsed)) {
+        return {
+            issue: invalidManifestIssue(manifestPath, 'manifest does not match the expected shape')
+        };
+    }
+    return { manifest: parsed };
+}
+function isAddonsManifest(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const manifest = value;
+    return (manifest['version'] === 1 &&
+        typeof manifest['bundleId'] === 'string' &&
+        Array.isArray(manifest['addons']) &&
+        manifest['addons'].every((addon) => typeof addon === 'string'));
+}
+function invalidManifestIssue(manifestPath, cause) {
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    return {
+        code: 'invalid-manifest',
+        level: 'error',
+        message: `Could not read a valid addon manifest at ${manifestPath}: ${reason}.`
+    };
+}

package/dist/constants/audio.js

@@ -1 +1 @@
-export { FORMATS_NEEDING_DECODE, SUPPORTED_AUDIO_FORMATS } from '@qvac/decoder-audio/constants.js';
+export { FORMATS_NEEDING_DECODE, SUPPORTED_AUDIO_FORMATS } from '@qvac/decoder-audio/constants';

package/dist/constants/index.d.ts

@@ -1,3 +1,3 @@
-export * from './audio';
-export * from './registry';
+export * from './audio.js';
+export * from './registry.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/examples/{transcription → asr}/parakeet-ctc-filesystem.js

@@ -2,7 +2,7 @@
  * Parakeet CTC transcription from a WAV file.
  *
  * Usage:
- *   bun run examples/transcription/parakeet-ctc-filesystem.ts <wav-file> [parakeet-ctc-gguf]
+ *   bun run examples/asr/parakeet-ctc-filesystem.ts <wav-file> [parakeet-ctc-gguf]
  *
  * Loads a single GGUF checkpoint (`PARAKEET_CTC_0_6B_Q8_0` by default) and
  * transcribes the file with the batch `transcribe` API. Omit the model
@@ -13,8 +13,7 @@
 import { loadModel, unloadModel, transcribe, PARAKEET_CTC_0_6B_Q8_0 } from '@qvac/sdk';
 const args = process.argv.slice(2);
 if (!args[0]) {
-    console.error('Usage: bun run examples/transcription/parakeet-ctc-filesystem.ts <wav-file> ' +
-        '[parakeet-ctc-gguf]');
+    console.error('Usage: bun run examples/asr/parakeet-ctc-filesystem.ts <wav-file> ' + '[parakeet-ctc-gguf]');
     console.error('\nIf the model path is omitted, defaults to the registry model.');
     process.exit(1);
 }

package/dist/examples/{transcription → asr}/parakeet-microphone-record.js

@@ -2,7 +2,7 @@
  * Microphone → Parakeet batch transcription (chunked `transcribe`).
  *
  * Usage:
- *   bun run examples/transcription/parakeet-microphone-record.ts
+ *   bun run examples/asr/parakeet-microphone-record.ts
  *
  * Captures 3 s s16le chunks from the microphone and sends each to `transcribe`
  * with the TDT model. Press Ctrl+C to stop.
@@ -11,7 +11,7 @@
  */
 import { loadModel, unloadModel, transcribe, PARAKEET_TDT_0_6B_V3_Q8_0 } from '@qvac/sdk';
 import { spawnSync } from 'child_process';
-import { startMicrophone } from '../audio/mic-input';
+import { startMicrophone } from '../audio/mic-input.js';
 const SAMPLE_RATE = 16000;
 const BYTES_PER_SAMPLE = 2; // s16le
 const CHUNK_DURATION_S = 3;

package/dist/examples/{transcription → asr}/parakeet-microphone-stream.js

@@ -2,7 +2,7 @@
  * Microphone → Parakeet duplex streaming (`transcribeStream`).
  *
  * Usage:
- *   bun run examples/transcription/parakeet-microphone-stream.ts
+ *   bun run examples/asr/parakeet-microphone-stream.ts
  *
  * Streams microphone audio through `transcribeStream` with
  * `parakeetStreamingConfig`. Uses the EOU checkpoint so you may see
@@ -13,7 +13,7 @@
  */
 import { loadModel, unloadModel, transcribeStream, PARAKEET_EOU_120M_V1_Q8_0 } from '@qvac/sdk';
 import { spawnSync } from 'child_process';
-import { startMicrophone } from '../audio/mic-input';
+import { startMicrophone } from '../audio/mic-input.js';
 const SAMPLE_RATE = 16000;
 try {
     const r = spawnSync('ffmpeg', ['-version'], { stdio: 'ignore' });

package/dist/examples/{transcription → asr}/parakeet-sortformer-streaming.js

@@ -2,7 +2,7 @@
  * Sortformer v2.1 streaming diarization via duplex `transcribeStream` + AOSC.
  *
  * Usage:
- *   bun run examples/transcription/parakeet-sortformer-streaming.ts <wav-file> [sortformer-gguf]
+ *   bun run examples/asr/parakeet-sortformer-streaming.ts <wav-file> [sortformer-gguf]
  *
  * Streams 16 kHz mono s16le audio in real-time-paced chunks (required for parakeet
  * duplex streaming). Loads v2.1 with AOSC knobs in `modelConfig`. Omit the model
@@ -28,7 +28,7 @@ const SORTFORMER_V21_AOSC_LOAD_CONFIG = {
 };
 const args = process.argv.slice(2);
 if (!args[0]) {
-    console.error('Usage: bun run examples/transcription/parakeet-sortformer-streaming.ts <wav-file-path> [sortformer-gguf]');
+    console.error('Usage: bun run examples/asr/parakeet-sortformer-streaming.ts <wav-file-path> [sortformer-gguf]');
     console.error('\nDefaults to the v2.1 q8_0 registry model (PARAKEET_SORTFORMER_4SPK_V2_1_Q8_0).');
     process.exit(1);
 }

package/dist/examples/{transcription → asr}/parakeet-sortformer.js

@@ -2,7 +2,7 @@
  * Parakeet Sortformer diarization + TDT transcription pipeline.
  *
  * Usage:
- *   bun run examples/transcription/parakeet-sortformer.ts [sortformer-gguf] [wav-file]
+ *   bun run examples/asr/parakeet-sortformer.ts [sortformer-gguf] [wav-file]
  *
  * Two-step flow: Sortformer v2.1 diarizes the audio, then TDT transcribes each
  * speaker segment. Defaults to registry GGUFs and

package/dist/examples/{transcription → asr}/parakeet-tdt-filesystem-chunked.js

@@ -2,7 +2,7 @@
  * Parakeet TDT transcription for long audio files.
  *
  * Usage:
- *   bun run examples/transcription/parakeet-tdt-filesystem-chunked.ts <audio-file> [parakeet-tdt-gguf]
+ *   bun run examples/asr/parakeet-tdt-filesystem-chunked.ts <audio-file> [parakeet-tdt-gguf]
  *
  * FFmpeg first detects silence, then this example selects boundaries near
  * 45 seconds and transcribes one segment at a time. Segments never exceed
@@ -143,7 +143,7 @@ function formatTimestamp(seconds) {
 }
 const args = process.argv.slice(2);
 if (!args[0]) {
-    console.error('Usage: bun run examples/transcription/parakeet-tdt-filesystem-chunked.ts ' +
+    console.error('Usage: bun run examples/asr/parakeet-tdt-filesystem-chunked.ts ' +
         '<audio-file> [parakeet-tdt-gguf]');
     process.exit(1);
 }

package/dist/examples/{transcription → asr}/parakeet-tdt-filesystem.js

@@ -2,7 +2,7 @@
  * Parakeet TDT transcription from a WAV file.
  *
  * Usage:
- *   bun run examples/transcription/parakeet-tdt-filesystem.ts <wav-file> [parakeet-tdt-gguf]
+ *   bun run examples/asr/parakeet-tdt-filesystem.ts <wav-file> [parakeet-tdt-gguf]
  *
  * Loads a single GGUF checkpoint (`PARAKEET_TDT_0_6B_V3_Q8_0` by default) and
  * transcribes the file with the batch `transcribe` API. Omit the model
@@ -13,7 +13,7 @@
 import { loadModel, unloadModel, transcribe, PARAKEET_TDT_0_6B_V3_Q8_0 } from '@qvac/sdk';
 const args = process.argv.slice(2);
 if (!args[0]) {
-    console.error('Usage: bun run examples/transcription/parakeet-tdt-filesystem.ts <wav-file-path> ' +
+    console.error('Usage: bun run examples/asr/parakeet-tdt-filesystem.ts <wav-file-path> ' +
         '[parakeet-tdt-gguf]');
     console.error('\nIf the model path is omitted, defaults to the registry model.');
     process.exit(1);

package/dist/examples/{transcription → asr}/whispercpp-filesystem-streaming.js

@@ -2,7 +2,7 @@
  * Test script: pipes a WAV file through transcribeStream to verify
  * the bidirectional streaming + addon processing works end-to-end.
  *
- * Usage: bun run examples/transcription/whispercpp-filesystem-streaming.ts
+ * Usage: bun run examples/asr/whispercpp-filesystem-streaming.ts
  *
  * Uses FFmpeg to convert the WAV to raw f32le and streams chunks
  * through the duplex RPC session to the whisper addon.

package/dist/examples/{transcription → asr}/whispercpp-filesystem.js

@@ -2,7 +2,7 @@ import { loadModel, unloadModel, transcribe, WHISPER_TINY } from '@qvac/sdk';
 // Parse command line arguments
 const args = process.argv.slice(2);
 if (!args[0]) {
-    console.error('Usage: bun run examples/whispercpp-filesystem.ts <wav-file-path>');
+    console.error('Usage: bun run examples/asr/whispercpp-filesystem.ts <wav-file-path>');
     process.exit(1);
 }
 const audioFilePath = args[0];

package/dist/examples/{transcription → asr}/whispercpp-microphone-conversation.js

@@ -18,7 +18,7 @@
  */
 import { loadModel, unloadModel, transcribeStream, WHISPER_TINY, VAD_SILERO_5_1_2 } from '@qvac/sdk';
 import { spawnSync } from 'child_process';
-import { startMicrophone } from '../audio/mic-input';
+import { startMicrophone } from '../audio/mic-input.js';
 const SAMPLE_RATE = 16000;
 try {
     const r = spawnSync('ffmpeg', ['-version'], { stdio: 'ignore' });

package/dist/examples/{transcription → asr}/whispercpp-microphone-record.js

@@ -1,7 +1,7 @@
 /**
  * Microphone → Whisper streaming transcription with native VAD.
  *
- * Usage: bun run examples/transcription/whispercpp-microphone-record.ts
+ * Usage: bun run examples/asr/whispercpp-microphone-record.ts
  *
  * Speak into your mic; transcriptions appear automatically when you pause.
  * Press Ctrl+C to quit.
@@ -10,7 +10,7 @@
  */
 import { loadModel, unloadModel, transcribeStream, WHISPER_TINY, VAD_SILERO_5_1_2 } from '@qvac/sdk';
 import { spawnSync } from 'child_process';
-import { startMicrophone } from '../audio/mic-input';
+import { startMicrophone } from '../audio/mic-input.js';
 const SAMPLE_RATE = 16000;
 // ── Main ──
 try {

package/dist/examples/{transcription → asr}/whispercpp-prompt.js

@@ -2,7 +2,7 @@
  * Whisper transcription with prompt example.
  *
  * Usage:
- *   bun examples/transcription/whispercpp-prompt.ts
+ *   bun examples/asr/whispercpp-prompt.ts
  *
  * This example requires a test audio file (default: examples/audio/sample-16khz.wav).
  * Sample audio files are available in the QVAC source repository, but not included in the published npm package.

package/dist/examples/audiogen/generate-music.d.ts

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

package/dist/examples/audiogen/generate-music.js

@@ -0,0 +1,112 @@
+import { writeFileSync } from 'node:fs';
+import { AUDIOGEN_ACESTEP_5HZ_LM_0_6B_Q8_0, AUDIOGEN_ACESTEP_V15_TURBO_Q4_K_M, AUDIOGEN_QWEN3_EMBEDDING_0_6B_Q8_0, AUDIOGEN_VAE_BF16, audioGen, loadModel, unloadModel } from '@qvac/sdk';
+// Usage:
+//   bun examples/audiogen/generate-music.ts "lo-fi hip hop, mellow piano" output.wav
+const caption = process.argv[2] ?? 'Lo-fi hip hop with mellow piano, soft drums, and a warm bass line';
+const outputPath = process.argv[3] ?? 'audiogen-output.wav';
+let modelId;
+const lastLoggedPercentageByDownload = new Map();
+const completedDownloads = new Set();
+try {
+    console.log('▸ Loading ACE-Step AudioGen models...');
+    modelId = await loadModel({
+        modelType: 'audiogen',
+        modelConfig: {
+            textEncModelSrc: AUDIOGEN_QWEN3_EMBEDDING_0_6B_Q8_0,
+            lmModelSrc: AUDIOGEN_ACESTEP_5HZ_LM_0_6B_Q8_0,
+            ditModelSrc: AUDIOGEN_ACESTEP_V15_TURBO_Q4_K_M,
+            vaeModelSrc: AUDIOGEN_VAE_BF16,
+            useGPU: true,
+            inferenceSteps: 8
+        },
+        onProgress: (progress) => {
+            const mb = (bytes) => (bytes / 1e6).toFixed(1);
+            const label = getDownloadLabel(progress.downloadKey);
+            const line = `▸ Downloading ${label}: ${progress.percentage.toFixed(0)}% ` +
+                `(${mb(progress.downloaded)}/${mb(progress.total)} MB)`;
+            if (process.stderr.isTTY) {
+                process.stderr.write(`\r${line}`);
+                if (progress.percentage >= 100 && !completedDownloads.has(progress.downloadKey)) {
+                    completedDownloads.add(progress.downloadKey);
+                    process.stderr.write('\n');
+                }
+                return;
+            }
+            const percentageBucket = Math.floor(progress.percentage / 5) * 5;
+            const lastLogged = lastLoggedPercentageByDownload.get(progress.downloadKey);
+            const isNewCompletion = progress.percentage >= 100 && lastLogged !== 100;
+            if (lastLogged === undefined || percentageBucket > lastLogged || isNewCompletion) {
+                lastLoggedPercentageByDownload.set(progress.downloadKey, percentageBucket);
+                process.stderr.write(`${line}\n`);
+            }
+        }
+    });
+    console.log(`▸ Model loaded: ${modelId}`);
+    console.log(`▸ Generating: ${caption}`);
+    const run = audioGen({
+        modelId,
+        caption,
+        lyrics: '[Instrumental]',
+        seed: 42,
+        duration: 10
+    });
+    console.log(`▸ requestId: ${run.requestId}`);
+    for await (const progress of run.progressStream) {
+        console.log(`▸ ${progress.stage}: ${progress.step}/${progress.total}`);
+    }
+    const [audio, stats] = await Promise.all([run.audio, run.stats]);
+    const wav = createWav(audio.pcm, audio.sampleRate, audio.channels, audio.bitsPerSample);
+    writeFileSync(outputPath, wav);
+    const samplesPerChannel = audio.pcm.byteLength / (audio.bitsPerSample / 8) / audio.channels;
+    console.log(`▸ Generated ${samplesPerChannel} samples per channel at ` +
+        `${audio.sampleRate} Hz (${audio.channels} channels)`);
+    if (stats)
+        console.log(`▸ Stats: ${JSON.stringify(stats)}`);
+    console.log(`▸ Saved ${outputPath}`);
+    await unloadModel({ modelId });
+    modelId = undefined;
+    console.log('▸ Model unloaded');
+    process.exit(0);
+}
+catch (error) {
+    if (modelId !== undefined) {
+        try {
+            await unloadModel({ modelId });
+        }
+        catch {
+            // Preserve the generation error as the primary failure.
+        }
+    }
+    console.error('✖', error);
+    process.exit(1);
+}
+function getDownloadLabel(downloadKey) {
+    return downloadKey.split('/').pop() ?? downloadKey;
+}
+function createWav(pcm, sampleRate, channels, bitsPerSample) {
+    const header = new ArrayBuffer(44);
+    const view = new DataView(header);
+    const blockAlign = channels * (bitsPerSample / 8);
+    writeAscii(view, 0, 'RIFF');
+    view.setUint32(4, 36 + pcm.byteLength, true);
+    writeAscii(view, 8, 'WAVE');
+    writeAscii(view, 12, 'fmt ');
+    view.setUint32(16, 16, true);
+    view.setUint16(20, 1, true);
+    view.setUint16(22, channels, true);
+    view.setUint32(24, sampleRate, true);
+    view.setUint32(28, sampleRate * blockAlign, true);
+    view.setUint16(32, blockAlign, true);
+    view.setUint16(34, bitsPerSample, true);
+    writeAscii(view, 36, 'data');
+    view.setUint32(40, pcm.byteLength, true);
+    const wav = new Uint8Array(44 + pcm.byteLength);
+    wav.set(new Uint8Array(header));
+    wav.set(pcm, 44);
+    return wav;
+}
+function writeAscii(view, offset, value) {
+    for (let index = 0; index < value.length; index++) {
+        view.setUint8(offset + index, value.charCodeAt(index));
+    }
+}

package/dist/examples/cache-management.js

@@ -1,5 +1,5 @@
 import { WHISPER_TINY } from '../models/registry/index.js';
-import { downloadAsset, getModelInfo, loadModel, unloadModel } from '..';
+import { downloadAsset, getModelInfo, loadModel, unloadModel } from '../index.js';
 const printModelStatus = (info, label) => {
     console.log(`\n▸ ${label}`);
     console.log(`▸ Model Name: ${info.name}`);

package/dist/examples/config-reload.js

@@ -1,4 +1,4 @@
-import { WHISPER_TINY, loadModel, transcribe, unloadModel } from '../index';
+import { WHISPER_TINY, loadModel, transcribe, unloadModel } from '../index.js';
 // Parse command line arguments
 const args = process.argv.slice(2);
 if (!args[0]) {

package/dist/examples/diffusion-txt2vid-wan22.d.ts

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