@qvac/sdk 0.15.0 → 0.17.0

package/dist/examples/asr/parakeet-tdt-filesystem-chunked.js

@@ -0,0 +1,203 @@
+/**
+ * Parakeet TDT transcription for long audio files.
+ *
+ * Usage:
+ *   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
+ * 60 seconds, which keeps audio and inference memory bounded. Any audio
+ * format supported by FFmpeg can be used.
+ */
+import { loadModel, unloadModel, transcribe, PARAKEET_TDT_0_6B_V3_Q8_0 } from '@qvac/sdk';
+import { spawn } from 'child_process';
+const SAMPLE_RATE = 16000;
+const SILENCE_NOISE_DB = -35;
+const SILENCE_DURATION_S = 0.5;
+const MIN_SEGMENT_S = 10;
+const TARGET_SEGMENT_S = 45;
+const MAX_SEGMENT_S = 60;
+function runCommand(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        const stdout = [];
+        const stderr = [];
+        child.stdout.on('data', (chunk) => stdout.push(chunk));
+        child.stderr.on('data', (chunk) => stderr.push(chunk));
+        child.on('error', reject);
+        child.on('close', (code) => {
+            const stderrText = Buffer.concat(stderr).toString();
+            if (code !== 0) {
+                reject(new Error(`${command} exited with code ${code}: ${stderrText.trim()}`));
+                return;
+            }
+            resolve({ stdout: Buffer.concat(stdout), stderr: stderrText });
+        });
+    });
+}
+async function getAudioDuration(audioPath) {
+    const result = await runCommand('ffprobe', [
+        '-v',
+        'error',
+        '-show_entries',
+        'format=duration',
+        '-of',
+        'default=noprint_wrappers=1:nokey=1',
+        audioPath
+    ]);
+    const duration = Number.parseFloat(result.stdout.toString().trim());
+    if (!Number.isFinite(duration) || duration <= 0) {
+        throw new Error(`Could not determine audio duration for ${audioPath}`);
+    }
+    return duration;
+}
+async function detectSilences(audioPath, duration) {
+    const result = await runCommand('ffmpeg', [
+        '-hide_banner',
+        '-nostats',
+        '-i',
+        audioPath,
+        '-vn',
+        '-af',
+        `silencedetect=noise=${SILENCE_NOISE_DB}dB:d=${SILENCE_DURATION_S}`,
+        '-f',
+        'null',
+        '-'
+    ]);
+    const intervals = [];
+    let currentStart = null;
+    for (const line of result.stderr.split('\n')) {
+        const startMatch = line.match(/silence_start:\s*([0-9.]+)/);
+        if (startMatch?.[1]) {
+            const start = Number.parseFloat(startMatch[1]);
+            if (Number.isFinite(start))
+                currentStart = start;
+        }
+        const endMatch = line.match(/silence_end:\s*([0-9.]+)/);
+        if (endMatch?.[1] && currentStart !== null) {
+            const end = Number.parseFloat(endMatch[1]);
+            if (Number.isFinite(end) && end > currentStart) {
+                intervals.push({ start: currentStart, end });
+            }
+            currentStart = null;
+        }
+    }
+    if (currentStart !== null && currentStart < duration) {
+        intervals.push({ start: currentStart, end: duration });
+    }
+    return intervals;
+}
+function createAudioSegments(duration, silences) {
+    const silenceMidpoints = silences.map(({ start, end }) => start + (end - start) / 2);
+    const segments = [];
+    let start = 0;
+    while (duration - start > MAX_SEGMENT_S) {
+        const target = start + TARGET_SEGMENT_S;
+        const minimumCut = start + MIN_SEGMENT_S;
+        const maximumCut = start + MAX_SEGMENT_S;
+        const candidates = silenceMidpoints.filter((candidate) => candidate >= minimumCut && candidate <= maximumCut);
+        const firstCandidate = candidates[0];
+        const cut = firstCandidate === undefined
+            ? Math.min(target, duration - MIN_SEGMENT_S)
+            : candidates.slice(1).reduce((best, candidate) => {
+                return Math.abs(candidate - target) < Math.abs(best - target) ? candidate : best;
+            }, firstCandidate);
+        segments.push({ start, end: cut });
+        start = cut;
+    }
+    if (duration > start) {
+        segments.push({ start, end: duration });
+    }
+    return segments;
+}
+async function decodeSegment(audioPath, segment) {
+    const result = await runCommand('ffmpeg', [
+        '-hide_banner',
+        '-loglevel',
+        'error',
+        '-ss',
+        segment.start.toFixed(3),
+        '-i',
+        audioPath,
+        '-t',
+        (segment.end - segment.start).toFixed(3),
+        '-vn',
+        '-ar',
+        String(SAMPLE_RATE),
+        '-ac',
+        '1',
+        '-sample_fmt',
+        's16',
+        '-f',
+        's16le',
+        'pipe:1'
+    ]);
+    return result.stdout;
+}
+function formatTimestamp(seconds) {
+    const totalTenths = Math.round(seconds * 10);
+    const hours = Math.floor(totalTenths / 36000);
+    const minutes = Math.floor((totalTenths % 36000) / 600);
+    const remainingSeconds = ((totalTenths % 600) / 10).toFixed(1).padStart(4, '0');
+    return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${remainingSeconds}`;
+}
+const args = process.argv.slice(2);
+if (!args[0]) {
+    console.error('Usage: bun run examples/asr/parakeet-tdt-filesystem-chunked.ts ' +
+        '<audio-file> [parakeet-tdt-gguf]');
+    process.exit(1);
+}
+const audioFilePath = args[0];
+const parakeetModelSrc = args[1] ?? PARAKEET_TDT_0_6B_V3_Q8_0;
+let modelId = null;
+try {
+    await runCommand('ffmpeg', ['-version']);
+    await runCommand('ffprobe', ['-version']);
+    console.log('▸ Detecting silence and planning bounded segments...');
+    const duration = await getAudioDuration(audioFilePath);
+    const silences = await detectSilences(audioFilePath, duration);
+    const segments = createAudioSegments(duration, silences);
+    console.log(`▸ Audio duration: ${formatTimestamp(duration)}; detected ${silences.length} silence interval(s); planned ${segments.length} segment(s)`);
+    console.log('▸ Loading Parakeet TDT model...');
+    modelId = await loadModel({
+        modelSrc: parakeetModelSrc,
+        modelType: 'parakeet-transcription',
+        onProgress: (p) => {
+            const mb = (n) => (n / 1e6).toFixed(1);
+            const line = `▸ Downloading ${p.percentage.toFixed(0)}% (${mb(p.downloaded)}/${mb(p.total)} MB)`;
+            process.stderr.write(process.stderr.isTTY ? `\r${line}` : `${line}\n`);
+            if (p.percentage >= 100)
+                process.stderr.write('\n');
+        }
+    });
+    console.log(`▸ Model loaded: ${modelId}`);
+    const transcript = [];
+    for (const [index, segment] of segments.entries()) {
+        console.log(`▸ Segment ${index + 1}/${segments.length}: ${formatTimestamp(segment.start)} - ${formatTimestamp(segment.end)}`);
+        const audioChunk = await decodeSegment(audioFilePath, segment);
+        const text = await transcribe({ modelId, audioChunk });
+        const normalizedText = text.trim();
+        if (normalizedText && !normalizedText.includes('[No speech detected]')) {
+            transcript.push(normalizedText);
+            console.log(normalizedText);
+        }
+    }
+    console.log('\n▸ Complete transcript');
+    console.log(transcript.join(' '));
+    await unloadModel({ modelId });
+    modelId = null;
+    console.log('▸ Done');
+    process.exit(0);
+}
+catch (error) {
+    console.error('✖', error);
+    if (modelId) {
+        try {
+            await unloadModel({ modelId });
+        }
+        catch (unloadError) {
+            console.error('✖ Failed to unload model:', unloadError);
+        }
+    }
+    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-ideogram.d.ts

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

package/dist/examples/diffusion-ideogram.js

@@ -0,0 +1,108 @@
+import { diffusion, loadModel, unloadModel } from '@qvac/sdk';
+import fs from 'fs';
+import path from 'path';
+const diffusionModelSrc = process.argv[2] ||
+    'https://huggingface.co/leejet/ideogram-4-GGUF/resolve/main/ideogram4-Q4_0.gguf';
+const uncondModelSrc = process.argv[3] ||
+    'https://huggingface.co/leejet/ideogram-4-GGUF/resolve/main/ideogram4_uncond-Q4_0.gguf';
+const llmModelSrc = process.argv[4] ||
+    'https://huggingface.co/unsloth/Qwen3-VL-8B-Instruct-GGUF/resolve/main/Qwen3-VL-8B-Instruct-Q4_K_M.gguf';
+const vaeModelSrc = process.argv[5] ||
+    'https://huggingface.co/Comfy-Org/flux2-dev/resolve/main/split_files/vae/flux2-vae.safetensors';
+const outputDir = process.argv[6] || '.';
+function formatMb(bytes) {
+    return (bytes / 1e6).toFixed(1);
+}
+// Ideogram 4 expects a JSON-serialized structured caption with explicit
+// bounding boxes. Plain-text prompts produce degenerate or placeholder output.
+const structuredPrompt = {
+    high_level_description: 'A bright product photo of one yellow coffee mug on a clean office desk with a tiny readable label that says IDEO.',
+    style_description: {
+        aesthetics: 'simple product photography, clean bright office desk, minimal composition',
+        lighting: 'soft studio light with gentle shadows',
+        photo: 'sharp focus, crisp readable label text',
+        medium: 'product photo',
+        color_palette: ['#FFD54A', '#FFFFFF', '#111111', '#7EC8E3']
+    },
+    compositional_deconstruction: {
+        canvas: 'Square canvas, upright orientation. All text is horizontal and readable.',
+        background: 'Clean white office desk with a soft blue background gradient.',
+        elements: [
+            {
+                type: 'obj',
+                bbox: [230, 260, 800, 740],
+                desc: 'Exactly one matte yellow ceramic coffee mug centered on the desk.'
+            },
+            {
+                type: 'text',
+                bbox: [510, 360, 620, 640],
+                text: 'IDEO',
+                desc: 'Small black label printed horizontally on the mug.'
+            }
+        ]
+    }
+};
+if (process.argv.includes('--help')) {
+    console.log('Usage: tsx examples/diffusion-ideogram.ts [model] [uncond] [llm] [vae] [output-dir]');
+    console.log('▸ Defaults use the four Hugging Face model URLs supported by the diffusion addon.');
+    process.exit(0);
+}
+let modelId;
+try {
+    console.log('▸ Loading Ideogram 4 split-layout model...');
+    modelId = await loadModel({
+        modelSrc: diffusionModelSrc,
+        modelType: 'sdcpp-generation',
+        modelConfig: {
+            device: 'gpu',
+            threads: 4,
+            diffusion_fa: true,
+            offload_to_cpu: true,
+            llmModelSrc,
+            vaeModelSrc,
+            uncondModelSrc
+        },
+        onProgress: (progress) => {
+            const line = `▸ Downloading ${progress.percentage.toFixed(0)}% (${formatMb(progress.downloaded)}/${formatMb(progress.total)} MB)`;
+            process.stderr.write(process.stderr.isTTY ? `\r${line}` : `${line}\n`);
+            if (progress.percentage >= 100)
+                process.stderr.write('\n');
+        }
+    });
+    console.log(`▸ Model loaded: ${modelId}`);
+    const { progressStream, outputs, stats } = diffusion({
+        modelId,
+        prompt: JSON.stringify(structuredPrompt),
+        width: 768,
+        height: 768,
+        steps: 16,
+        cfg_scale: 7,
+        seed: 42
+    });
+    for await (const { step, totalSteps } of progressStream) {
+        console.log(`▸ step ${step}/${totalSteps}`);
+    }
+    const buffers = await outputs;
+    for (let i = 0; i < buffers.length; i++) {
+        const outputPath = path.join(outputDir, `ideogram_${i}.png`);
+        fs.writeFileSync(outputPath, buffers[i]);
+        console.log(`▸ Saved ${outputPath}`);
+    }
+    console.log('▸ Stats:', await stats);
+    await unloadModel({ modelId, clearStorage: false });
+    modelId = undefined;
+    console.log('▸ Done');
+    process.exit(0);
+}
+catch (error) {
+    if (modelId) {
+        try {
+            await unloadModel({ modelId, clearStorage: false });
+        }
+        catch {
+            // Preserve the original error.
+        }
+    }
+    console.error('✖', error);
+    process.exit(1);
+}

package/dist/examples/diffusion-img2vid-ltx.d.ts

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

package/dist/examples/diffusion-img2vid-ltx.js

@@ -0,0 +1,98 @@
+import { loadModel, unloadModel, video } from '@qvac/sdk';
+import fs from 'fs';
+import path from 'path';
+// Image-to-video (+ synchronized audio) with LTX-2. Unlike Wan I2V, LTX-2
+// conditions on the first frame through its video VAE, so it needs NO CLIP
+// vision weights (clipVisionModelSrc) — the same LTX-2 layout used for
+// txt2vid works for img2vid, you just add an init_image at generation time.
+//
+// This example needs powerful hardware: LTX-2.3 is a ~21B model, budget at
+// least 20+ GB of video / unified memory.
+//
+// No LTX-2 model constants ship in the SDK registry, so the model sources
+// default to public HuggingFace URLs (the SDK downloads http(s) sources
+// directly). Pass your own paths / URLs via argv to override.
+const HF = 'https://huggingface.co';
+const initImagePath = process.argv[2];
+const prompt = process.argv[3] || 'the subject slowly turns and smiles, soft natural lighting, cinematic';
+const outputDir = process.argv[4] || '.';
+const diffusionModelSrc = process.argv[5] ||
+    `${HF}/QuantStack/LTX-2.3-GGUF/resolve/main/LTX-2.3-distilled-1.1/LTX-2.3-22B-distilled-1.1-Q5_K_M.gguf`;
+const llmModelSrc = process.argv[6] || `${HF}/unsloth/gemma-3-12b-it-GGUF/resolve/main/gemma-3-12b-it-UD-Q4_K_XL.gguf`;
+const vaeModelSrc = process.argv[7] ||
+    `${HF}/unsloth/LTX-2.3-GGUF/resolve/main/vae/ltx-2.3-22b-distilled_video_vae.safetensors`;
+const audioVaeModelSrc = process.argv[8] ||
+    `${HF}/unsloth/LTX-2.3-GGUF/resolve/main/vae/ltx-2.3-22b-distilled_audio_vae.safetensors`;
+const embeddingsConnectorsModelSrc = process.argv[9] ||
+    `${HF}/unsloth/LTX-2.3-GGUF/resolve/main/text_encoders/ltx-2.3-22b-distilled_embeddings_connectors.safetensors`;
+if (!initImagePath) {
+    console.error('✖ init image path is required');
+    console.error('Usage: bun run bare:example dist/examples/diffusion-img2vid-ltx.js ' +
+        '<initImagePath> [prompt] [outputDir] ' +
+        '[diffusionModelSrc] [llmModelSrc] [vaeModelSrc] [audioVaeModelSrc] [embeddingsConnectorsModelSrc]');
+    process.exit(1);
+}
+try {
+    console.log('▸ Loading LTX-2 model (diffusion + Gemma + video VAE + audio VAE + connectors)...');
+    // no clipVisionModelSrc — LTX-2 img2vid does not use CLIP vision.
+    const modelId = await loadModel({
+        modelSrc: diffusionModelSrc,
+        modelType: 'sdcpp-generation',
+        modelConfig: {
+            mode: 'video',
+            device: 'gpu',
+            threads: 4,
+            // Supplying embeddingsConnectorsModelSrc selects the LTX-2 layout.
+            llmModelSrc,
+            vaeModelSrc,
+            audioVaeModelSrc,
+            embeddingsConnectorsModelSrc,
+            diffusion_fa: true,
+            vae_tiling: true
+        },
+        onProgress: (p) => {
+            const mb = (n) => (n / 1e6).toFixed(1);
+            const line = `▸ Downloading ${p.percentage.toFixed(0)}% (${mb(p.downloaded)}/${mb(p.total)} MB)`;
+            process.stderr.write(process.stderr.isTTY ? `\r${line}` : `${line}\n`);
+            if (p.percentage >= 100)
+                process.stderr.write('\n');
+        }
+    });
+    console.log(`▸ Model loaded: ${modelId}`);
+    const init_image = new Uint8Array(fs.readFileSync(initImagePath));
+    console.log(`▸ Generating video for: "${prompt}"`);
+    const { progressStream, outputs, stats } = video({
+        modelId,
+        mode: 'img2vid',
+        prompt,
+        init_image,
+        negative_prompt: 'blurry, distorted, low quality, jittery, static, frozen, distorted audio',
+        strength: 0.85,
+        // LTX-2 requires width/height as multiples of 32 and (8*k + 1) frames (max 257).
+        width: 512,
+        height: 320,
+        video_frames: 121,
+        fps: 24,
+        steps: 10,
+        cfg_scale: 1.0,
+        seed: 42,
+        temporal_tiling: true
+    });
+    for await (const { step, totalSteps } of progressStream) {
+        console.log(`▸ step ${step}/${totalSteps}`);
+    }
+    const buffers = await outputs;
+    for (let i = 0; i < buffers.length; i++) {
+        const outputPath = path.join(outputDir, `ltx_i2v_${i}.avi`);
+        fs.writeFileSync(outputPath, buffers[i]);
+        console.log(`▸ Saved ${outputPath} (play in VLC to hear the muxed audio track)`);
+    }
+    console.log('▸ Stats:', await stats);
+    await unloadModel({ modelId, clearStorage: false });
+    console.log('▸ Done');
+    process.exit(0);
+}
+catch (error) {
+    console.error('✖', error);
+    process.exit(1);
+}

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

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