@qvac/sdk 0.15.0 → 0.17.0

package/dist/commands/bundle/index.js

@@ -1,15 +1,15 @@
 import fs, { promises as fsp } from 'node:fs';
 import path from 'node:path';
 import { createRequire } from 'node:module';
-import { DEFAULT_HOSTS, DEFAULT_SDK_NAME } from './constants.js';
+import { DEFAULT_HOSTS, DEFAULT_SDK_NAME } from '../../commands/bundle/constants.js';
 import { CONFIG_CANDIDATES, resolveConfigForProject } from '../../client/config-loader/resolve-config.node.js';
 import { getClientLogger } from '../../logging/index.js';
 import { BareImportsMapNotFoundError } from '../../utils/errors-client.js';
-import { resolvePluginSpecifiers, parseBuiltinSpecifier } from './plugins.js';
-import { generateWorkerEntry } from './entry-gen.js';
-import { runBarePack } from './bare-pack.js';
-import { generateAddonsManifest } from './manifest.js';
-import { createSdkImportResolver } from './resolve-sdk-import.js';
+import { resolvePluginSpecifiers, parseBuiltinSpecifier } from '../../commands/bundle/plugins.js';
+import { generateWorkerEntry } from '../../commands/bundle/entry-gen.js';
+import { runBarePack } from '../../commands/bundle/bare-pack.js';
+import { generateAddonsManifest } from '../../commands/bundle/manifest.js';
+import { createSdkImportResolver } from '../../commands/bundle/resolve-sdk-import.js';
 const require = createRequire(import.meta.url);
 function resolveSdkPath(projectRoot, explicitSdkPath) {
     if (explicitSdkPath) {

package/dist/commands/bundle/manifest.d.ts

@@ -1,4 +1,4 @@
-import type { Logger } from '../../logging/types';
+import type { Logger } from '../../logging/types.js';
 interface BarePackHeader {
     id?: string;
     resolutions?: Record<string, unknown>;

package/dist/commands/bundle/plugins.d.ts

@@ -1,5 +1,5 @@
-import type { Logger } from '../../logging/types';
-import type { QvacConfig } from '../../schemas/sdk-config';
+import type { Logger } from '../../logging/types.js';
+import type { QvacConfig } from '../../schemas/sdk-config.js';
 export declare function buildBuiltinSpecifier(sdkName: string, suffix: string): string;
 export declare function parseBuiltinSpecifier(specifier: string, sdkName: string): {
     suffix: string;

package/dist/commands/bundle/plugins.js

@@ -1,4 +1,4 @@
-import { BUILTIN_PLUGINS, BUILTIN_SUFFIXES } from './constants.js';
+import { BUILTIN_PLUGINS, BUILTIN_SUFFIXES } from '../../commands/bundle/constants.js';
 import { InvalidPluginSpecifierError } from '../../utils/errors-client.js';
 export function buildBuiltinSpecifier(sdkName, suffix) {
     return `${sdkName}/${suffix}/plugin`;

package/dist/commands/index.d.ts

@@ -1,5 +1,5 @@
-export { bundleSdk } from './bundle/index';
-export type { BundleSdkOptions, BundleSdkResult } from './bundle/index';
-export { verifyBundle, hasErrors, hasWarnings, formatVerifyBundleResult } from './verify/index';
-export type { VerifyBundleOptions, VerifyBundleResult, VerifyBundleIssue } from './verify/index';
+export { bundleSdk } from '../commands/bundle/index.js';
+export type { BundleSdkOptions, BundleSdkResult } from '../commands/bundle/index.js';
+export { verifyBundle, hasErrors, hasWarnings, formatVerifyBundleResult } from '../commands/verify/index.js';
+export type { VerifyBundleOptions, VerifyBundleResult, VerifyBundleIssue } from '../commands/verify/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/commands/index.js

@@ -1,2 +1,2 @@
-export { bundleSdk } from './bundle/index.js';
-export { verifyBundle, hasErrors, hasWarnings, formatVerifyBundleResult } from './verify/index.js';
+export { bundleSdk } from '../commands/bundle/index.js';
+export { verifyBundle, hasErrors, hasWarnings, formatVerifyBundleResult } from '../commands/verify/index.js';

package/dist/commands/verify/abi.d.ts

@@ -1,4 +1,4 @@
-import { type NativeAddon } from './addon-source';
+import { type NativeAddon } from '../../commands/verify/addon-source.js';
 export interface BareRuntime {
     version: string;
     source: 'flag' | 'config' | 'bare-runtime' | 'bare';

package/dist/commands/verify/abi.js

@@ -1,7 +1,7 @@
 import { promises as fsp } from 'node:fs';
 import path from 'node:path';
 import semver from 'semver';
-import { formatAddonId } from './addon-source.js';
+import { formatAddonId } from '../../commands/verify/addon-source.js';
 const RUNTIME_PACKAGES = [
     { source: 'bare-runtime', packageName: 'bare-runtime' },
     { source: 'bare', packageName: 'bare' }

package/dist/commands/verify/bundle-source.d.ts

@@ -1,4 +1,4 @@
-import { type CollectDiagnostics, type NativeAddon } from './addon-source';
+import { type CollectDiagnostics, type NativeAddon } from '../../commands/verify/addon-source.js';
 export declare class InvalidBundleSourceError extends Error {
     bundlePath: string;
     constructor(bundlePath: string, cause: unknown);

package/dist/commands/verify/bundle-source.js

@@ -1,6 +1,6 @@
 import { promises as fsp } from 'node:fs';
-import { buildNestedPathIndex, extractBarePackHeader, extractPackedString } from '../bundle/manifest.js';
-import { deduplicateAddons, readAddonPackageJson } from './addon-source.js';
+import { buildNestedPathIndex, extractBarePackHeader, extractPackedString } from '../../commands/bundle/manifest.js';
+import { deduplicateAddons, readAddonPackageJson } from '../../commands/verify/addon-source.js';
 export class InvalidBundleSourceError extends Error {
     bundlePath;
     constructor(bundlePath, cause) {

package/dist/commands/verify/index.d.ts

@@ -1,6 +1,6 @@
-import { type AddonSourceKind, type NativeAddon } from './addon-source';
-import { type MissingPrebuildIssue } from './prebuilds';
-import { type AbiIssue, type BareRuntimeResolution } from './abi';
+import { type AddonSourceKind, type NativeAddon } from '../../commands/verify/addon-source.js';
+import { type MissingPrebuildIssue } from '../../commands/verify/prebuilds.js';
+import { type AbiIssue, type BareRuntimeResolution } from '../../commands/verify/abi.js';
 export interface VerifyBundleOptions {
     projectRoot: string;
     addonsSource: string;

package/dist/commands/verify/index.js

@@ -1,11 +1,11 @@
 import { promises as fsp } from 'node:fs';
 import path from 'node:path';
 import { resolveConfigFileInProject, loadConfigFromPath } from '../../client/config-loader/resolve-config.node.js';
-import { createCollectDiagnostics, formatAddonId } from './addon-source.js';
-import { collectAddonsFromBundle, InvalidBundleSourceError } from './bundle-source.js';
-import { collectAddonsFromNodeModules, InvalidNodeModulesSourceError } from './node-modules-source.js';
-import { checkPrebuilds } from './prebuilds.js';
-import { checkAbi, formatConfigLabel, normalizeVersion, resolveBareRuntime } from './abi.js';
+import { createCollectDiagnostics, formatAddonId } from '../../commands/verify/addon-source.js';
+import { collectAddonsFromBundle, InvalidBundleSourceError } from '../../commands/verify/bundle-source.js';
+import { collectAddonsFromNodeModules, InvalidNodeModulesSourceError } from '../../commands/verify/node-modules-source.js';
+import { checkPrebuilds } from '../../commands/verify/prebuilds.js';
+import { checkAbi, formatConfigLabel, normalizeVersion, resolveBareRuntime } from '../../commands/verify/abi.js';
 export async function verifyBundle(options) {
     const { projectRoot, addonsSource, hosts, bareRuntimeVersion, configPath } = options;
     const resolvedAddonsSource = path.isAbsolute(addonsSource)

package/dist/commands/verify/node-modules-source.d.ts

@@ -1,4 +1,4 @@
-import { type CollectDiagnostics, type NativeAddon } from './addon-source';
+import { type CollectDiagnostics, type NativeAddon } from '../../commands/verify/addon-source.js';
 export declare class InvalidNodeModulesSourceError extends Error {
     nodeModulesPath: string;
     constructor(nodeModulesPath: string, cause: unknown);

package/dist/commands/verify/node-modules-source.js

@@ -1,6 +1,6 @@
 import { promises as fsp } from 'node:fs';
 import path from 'node:path';
-import { deduplicateAddons, readAddonPackageJson } from './addon-source.js';
+import { deduplicateAddons, readAddonPackageJson } from '../../commands/verify/addon-source.js';
 export class InvalidNodeModulesSourceError extends Error {
     nodeModulesPath;
     constructor(nodeModulesPath, cause) {

package/dist/commands/verify/prebuilds.d.ts

@@ -1,4 +1,4 @@
-import { type NativeAddon } from './addon-source';
+import { type NativeAddon } from '../../commands/verify/addon-source.js';
 export interface MissingPrebuildIssue {
     code: 'missing-prebuild';
     level: 'error';
@@ -12,4 +12,5 @@ export interface CheckPrebuildsOptions {
     hosts: string[];
 }
 export declare function checkPrebuilds(options: CheckPrebuildsOptions): Promise<MissingPrebuildIssue[]>;
+export declare function listBarePrebuildFiles(hostDir: string): Promise<string[]>;
 //# sourceMappingURL=prebuilds.d.ts.map

package/dist/commands/verify/prebuilds.js

@@ -1,12 +1,12 @@
 import { promises as fsp } from 'node:fs';
 import path from 'node:path';
-import { formatAddonId } from './addon-source.js';
+import { formatAddonId } from '../../commands/verify/addon-source.js';
 export async function checkPrebuilds(options) {
     const { addon, hosts } = options;
     const issues = [];
     for (const host of hosts) {
         const hostDir = path.join(addon.packageRoot, 'prebuilds', host);
-        const present = await hasBarePrebuild(hostDir);
+        const present = (await listBarePrebuildFiles(hostDir)).length > 0;
         if (!present) {
             issues.push({
                 code: 'missing-prebuild',
@@ -21,19 +21,16 @@ export async function checkPrebuilds(options) {
     }
     return issues;
 }
-async function hasBarePrebuild(hostDir) {
+export async function listBarePrebuildFiles(hostDir) {
     let entries;
     try {
         entries = await fsp.readdir(hostDir, { withFileTypes: true });
     }
     catch {
-        return false;
+        return [];
     }
-    for (const entry of entries) {
-        if (!entry.isFile() && !entry.isSymbolicLink())
-            continue;
-        if (entry.name.endsWith('.bare'))
-            return true;
-    }
-    return false;
+    return entries
+        .filter((entry) => (entry.isFile() || entry.isSymbolicLink()) && entry.name.endsWith('.bare'))
+        .map((entry) => path.resolve(hostDir, entry.name))
+        .sort();
 }

package/dist/commands/verify/resource-collectors.d.ts

@@ -0,0 +1,88 @@
+import { type Pack } from 'tar-stream';
+export declare const RESOURCE_COLLECTOR_PACKAGES: readonly ["bare-cpu-info", "bare-gpu-info"];
+export declare const RESOURCE_COLLECTOR_SIZE_BUDGETS: {
+    readonly compressedBytes: number;
+    readonly uncompressedBytes: number;
+};
+export interface ResourceCollectorAcceptanceOptions {
+    projectRoot: string;
+    bundlePath: string;
+    manifestPath: string;
+    hosts: string[];
+    budgets?: ResourceCollectorSizeBudgets;
+}
+export interface ResourceCollectorSizeBudgets {
+    compressedBytes: number;
+    uncompressedBytes: number;
+}
+export interface ResourceCollectorTargetMeasurement {
+    host: string;
+    files: Array<{
+        package: string;
+        relativePath: string;
+        bytes: number;
+    }>;
+    compressedBytes: number;
+    uncompressedBytes: number;
+}
+export interface ResourceCollectorAcceptanceReport {
+    ok: boolean;
+    collectors: string[];
+    hosts: string[];
+    budgets: ResourceCollectorSizeBudgets;
+    targets: ResourceCollectorTargetMeasurement[];
+    issues: ResourceCollectorAcceptanceIssue[];
+}
+export type ResourceCollectorAcceptanceIssue = {
+    code: 'missing-collector';
+    level: 'error';
+    package: string;
+    location: 'bundle' | 'manifest';
+    message: string;
+} | {
+    code: 'missing-prebuild';
+    level: 'error';
+    package: string;
+    host: string;
+    message: string;
+} | {
+    code: 'invalid-manifest';
+    level: 'error';
+    message: string;
+} | {
+    code: 'measurement-failed';
+    level: 'error';
+    package: string;
+    host: string;
+    message: string;
+} | {
+    code: 'compressed-budget-exceeded' | 'uncompressed-budget-exceeded';
+    level: 'error';
+    host: string;
+    actualBytes: number;
+    budgetBytes: number;
+    message: string;
+};
+interface MeasurementEntry {
+    package: string;
+    relativePath: string;
+    bytes: number;
+    contents: Buffer;
+}
+interface ResourceCollectorMeasurementDependencies {
+    writeArchiveEntry: (pack: Pack, entry: MeasurementEntry) => Promise<void>;
+}
+export declare function acceptResourceCollectorPackaging(options: ResourceCollectorAcceptanceOptions): Promise<ResourceCollectorAcceptanceReport>;
+export declare function formatResourceCollectorAcceptanceReport(report: ResourceCollectorAcceptanceReport): string;
+export declare function measureTarget(host: string, entries: MeasurementEntry[], dependencies?: ResourceCollectorMeasurementDependencies): Promise<{
+    host: string;
+    files: {
+        package: string;
+        relativePath: string;
+        bytes: number;
+    }[];
+    compressedBytes: number;
+    uncompressedBytes: number;
+}>;
+export {};
+//# sourceMappingURL=resource-collectors.d.ts.map

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/asr/parakeet-tdt-filesystem-chunked.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parakeet-tdt-filesystem-chunked.d.ts.map