voxtral-transcribe-ts 0.1.0

package/README.md

@@ -0,0 +1,231 @@
+# voxtral-transcribe-ts
+
+Minimal TypeScript wrapper for local transcription with `Voxtral Mini 4B Realtime` in Node.js.
+
+This package targets the ONNX checkpoint:
+
+- `onnx-community/Voxtral-Mini-4B-Realtime-2602-ONNX`
+
+It is intentionally small:
+
+- Node/TS only, no Python
+- thin wrapper around `@huggingface/transformers` + ONNX Runtime
+- 0 external audio decoder dependency
+
+The built-in file loader only supports `.wav` input so the package can stay lightweight. If you already have PCM samples in memory, use `transcribeAudio()`.
+
+Architecture and multi-target rollout plan: [PLAN.md](/home/antoinefa/src/voxtral-ts/PLAN.md)
+
+## Install
+
+```bash
+npm install voxtral-transcribe-ts
+```
+
+## Quick Start
+
+```ts
+import { VoxtralTranscriber } from "voxtral-transcribe-ts";
+
+const transcriber = new VoxtralTranscriber({
+  device: "cpu",
+  dtype: "q4",
+});
+
+const result = await transcriber.transcribeFile("./sample.wav");
+console.log(result.text);
+
+await transcriber.dispose();
+```
+
+By default, the package now auto-selects the audio decoder backend:
+
+- Node/local: `InternalWavDecoder`
+- Browser: `BrowserNativeAudioDecoder`
+
+The package now ships conditional entries:
+
+- package root in Node -> `dist/index.node.js`
+- package root in browser-aware bundlers -> `dist/index.browser.js`
+- explicit subpaths:
+  - `voxtral-transcribe-ts/node`
+  - `voxtral-transcribe-ts/browser`
+
+## Environment Matrix
+
+| Environment | Package entry | Inference runtime | Default decoder | File input strategy |
+|---|---|---|---|---|
+| Node / local | `voxtral-transcribe-ts` or `voxtral-transcribe-ts/node` | `@huggingface/transformers` + `onnxruntime-node` | `InternalWavDecoder` | `wav` by default, multiformat via `FfmpegDecoder` |
+| Browser | `voxtral-transcribe-ts` in browser-aware bundlers or `voxtral-transcribe-ts/browser` | browser-safe package entry | `BrowserNativeAudioDecoder` | URL, `Blob`, `File`, browser codec support dependent on runtime |
+| Server high-perf | `voxtral-transcribe-ts/node` | `@huggingface/transformers` + `onnxruntime-node` | `FfmpegDecoder` recommended | multiformat through `ffmpeg` |
+
+## Decoder Matrix
+
+| Decoder | Environment | Purpose | Notes |
+|---|---|---|---|
+| `InternalWavDecoder` | Node, browser | Minimal fallback | `wav` only |
+| `FfmpegDecoder` | Node / server | Best multiformat local path | Not available in browser builds |
+| `BrowserNativeAudioDecoder` | Browser | Native client-side decoding | Depends on browser codec support |
+
+You can override this with:
+
+- `target: "auto" | "node" | "browser"`
+- `audioDecoderBackend`
+- `inferenceBackend`
+
+## Raw Audio
+
+```ts
+import { transcribeAudio } from "voxtral-transcribe-ts";
+
+const samples = new Float32Array([/* mono PCM samples */]);
+
+const result = await transcribeAudio(samples, {
+  sampleRate: 16_000,
+});
+
+console.log(result.text);
+```
+
+## API
+
+### `new VoxtralTranscriber(options?)`
+
+Options:
+
+- `model`: defaults to `onnx-community/Voxtral-Mini-4B-Realtime-2602-ONNX`
+- `device`: defaults to `cpu`
+- `dtype`: defaults to `q4`
+- `cacheDir`
+- `localFilesOnly`
+- `revision`
+- `progressCallback`
+- `target`: defaults to `auto`
+
+### `await transcriber.load()`
+
+Preloads the processor and model.
+
+### `await transcriber.transcribeFile(path, options?)`
+
+Reads a WAV file, downmixes it to mono, resamples it to the model sample rate, and returns:
+
+```ts
+type VoxtralTranscriptionResult = {
+  decoder: string;
+  durationMs: number;
+  model: string;
+  sampleRate: number;
+  text: string;
+};
+```
+
+### `await transcriber.transcribeAudio(samples, options?)`
+
+Transcribes mono PCM samples already loaded in memory.
+
+Options:
+
+- `sampleRate`: defaults to `16000`
+- `maxNewTokens`
+- `skipSpecialTokens`: defaults to `true`
+
+## Advanced
+
+The transcriber now separates:
+
+- inference backend
+- audio decoder backend
+
+The current default pair is:
+
+- `TransformersInferenceBackend`
+- `InternalWavDecoder` in Node
+- `BrowserNativeAudioDecoder` in browsers
+
+For multiformat local/server decoding, use `FfmpegDecoder`.
+
+```ts
+import { FfmpegDecoder, VoxtralTranscriber } from "voxtral-transcribe-ts";
+
+const transcriber = new VoxtralTranscriber({
+  audioDecoderBackend: new FfmpegDecoder(),
+});
+
+const result = await transcriber.transcribeFile("./sample.mp3");
+console.log(result.text);
+```
+
+Browser inputs can be passed as URLs or `Blob` / `File` objects when using `BrowserNativeAudioDecoder` or the default browser auto-selection.
+
+You can also create an instance through `createTranscriber(options)`, which uses the same defaults and target rules as `new VoxtralTranscriber(options)`.
+
+## Browser Entry
+
+```ts
+import { createTranscriber } from "voxtral-transcribe-ts/browser";
+
+const transcriber = createTranscriber({
+  target: "browser",
+});
+```
+
+## Node Entry
+
+```ts
+import { createTranscriber, FfmpegDecoder } from "voxtral-transcribe-ts/node";
+
+const transcriber = createTranscriber({
+  target: "node",
+  audioDecoderBackend: new FfmpegDecoder(),
+});
+```
+
+## WAV Support
+
+The internal WAV decoder supports:
+
+- PCM 8/16/24/32-bit
+- IEEE float 32-bit
+- mono or multi-channel input, mixed down to mono
+
+For `mp3`, `m4a`, `ogg`, or `flac`, decode audio yourself and call `transcribeAudio()`.
+
+If you want the package to decode those formats for you on local/server, instantiate the transcriber with `FfmpegDecoder`.
+
+## Validation
+
+```bash
+npm run validate
+npm run test:smoke
+```
+
+## CI / Release
+
+The repository now ships a GitHub Actions workflow in `.github/workflows/typescript-ci.yml` modeled after `graphify`.
+
+It does four things:
+
+- runs `npm run validate` on Node `20` and `22`
+- builds a tarball and installs it in a clean directory
+- verifies the published root, `node`, and `browser` exports
+- publishes to npm on tags matching `v*`
+
+Publish strategy:
+
+- default: GitHub Actions trusted publishing with `id-token: write`
+- fallback: if `NPM_TOKEN` is configured as a repository secret, the workflow uses that token instead
+
+Local pre-publish check:
+
+```bash
+npm run test:smoke
+```
+
+Typical release flow:
+
+```bash
+npm version patch
+git push
+git push --tags
+```

package/dist/audio-core-CYgIOxAr.d.ts

@@ -0,0 +1,50 @@
+import { DeviceType, DataType } from '@huggingface/transformers';
+
+interface InferenceBackendLoadOptions {
+    cacheDir?: string;
+    device: DeviceType;
+    dtype: DataType;
+    localFilesOnly?: boolean;
+    model: string;
+    progressCallback?: (progress: unknown) => void;
+    revision?: string;
+}
+type ProcessorLike = {
+    feature_extractor: {
+        config: {
+            sampling_rate: number;
+        };
+    };
+    batch_decode(output: unknown, options?: {
+        skip_special_tokens?: boolean;
+    }): string[];
+} & ((audio: Float32Array) => Promise<Record<string, unknown>>);
+interface ModelLike {
+    dispose(): Promise<unknown>;
+    generate(input: Record<string, unknown>): Promise<unknown>;
+}
+interface InferenceBackend {
+    load(options: InferenceBackendLoadOptions): Promise<{
+        model: ModelLike;
+        processor: ProcessorLike;
+    }>;
+}
+declare class TransformersInferenceBackend implements InferenceBackend {
+    load(options: InferenceBackendLoadOptions): Promise<{
+        model: ModelLike;
+        processor: ProcessorLike;
+    }>;
+}
+type VoxtralRuntime = InferenceBackend;
+declare class TransformersRuntime extends TransformersInferenceBackend {
+}
+
+interface DecodedWav {
+    channels: number;
+    sampleRate: number;
+    samples: Float32Array;
+}
+declare function decodeWav(buffer: Uint8Array | ArrayBuffer): DecodedWav;
+declare function resampleAudio(samples: Float32Array | readonly number[], fromSampleRate: number, toSampleRate: number): Float32Array;
+
+export { type DecodedWav as D, type InferenceBackend as I, type ModelLike as M, type ProcessorLike as P, TransformersInferenceBackend as T, type VoxtralRuntime as V, type InferenceBackendLoadOptions as a, TransformersRuntime as b, decodeWav as d, resampleAudio as r };

package/dist/chunk-J6JHGURB.js

@@ -0,0 +1,161 @@
+// src/audio-core.ts
+var RIFF_HEADER = "RIFF";
+var WAVE_HEADER = "WAVE";
+var FMT_CHUNK = "fmt ";
+var DATA_CHUNK = "data";
+var WAVE_FORMAT_PCM = 1;
+var WAVE_FORMAT_IEEE_FLOAT = 3;
+var WAVE_FORMAT_EXTENSIBLE = 65534;
+function readFourCC(view, offset) {
+  return String.fromCharCode(
+    view.getUint8(offset),
+    view.getUint8(offset + 1),
+    view.getUint8(offset + 2),
+    view.getUint8(offset + 3)
+  );
+}
+function clampChunkSize(buffer, offset, size) {
+  return Math.max(0, Math.min(size, buffer.byteLength - offset));
+}
+function decodeSample(view, offset, audioFormat, bitsPerSample) {
+  if (audioFormat === WAVE_FORMAT_IEEE_FLOAT) {
+    if (bitsPerSample !== 32) {
+      throw new Error(`Unsupported float WAV bit depth: ${bitsPerSample}.`);
+    }
+    return view.getFloat32(offset, true);
+  }
+  switch (bitsPerSample) {
+    case 8:
+      return (view.getUint8(offset) - 128) / 128;
+    case 16:
+      return view.getInt16(offset, true) / 32768;
+    case 24: {
+      const value = view.getUint8(offset) | view.getUint8(offset + 1) << 8 | view.getUint8(offset + 2) << 16;
+      const signed = value & 8388608 ? value | ~16777215 : value;
+      return signed / 8388608;
+    }
+    case 32:
+      return view.getInt32(offset, true) / 2147483648;
+    default:
+      throw new Error(`Unsupported PCM WAV bit depth: ${bitsPerSample}.`);
+  }
+}
+function decodeWav(buffer) {
+  const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (bytes.byteLength < 44) {
+    throw new Error("Invalid WAV file: file is too small.");
+  }
+  if (readFourCC(view, 0) !== RIFF_HEADER || readFourCC(view, 8) !== WAVE_HEADER) {
+    throw new Error("Invalid WAV file: missing RIFF/WAVE header.");
+  }
+  let offset = 12;
+  let audioFormat = 0;
+  let channels = 0;
+  let sampleRate = 0;
+  let bitsPerSample = 0;
+  let blockAlign = 0;
+  let dataOffset = -1;
+  let dataSize = 0;
+  while (offset + 8 <= bytes.byteLength) {
+    const chunkId = readFourCC(view, offset);
+    const chunkSize = clampChunkSize(bytes, offset + 8, view.getUint32(offset + 4, true));
+    const chunkDataOffset = offset + 8;
+    if (chunkId === FMT_CHUNK) {
+      if (chunkSize < 16) {
+        throw new Error("Invalid WAV file: incomplete fmt chunk.");
+      }
+      let format = view.getUint16(chunkDataOffset, true);
+      channels = view.getUint16(chunkDataOffset + 2, true);
+      sampleRate = view.getUint32(chunkDataOffset + 4, true);
+      blockAlign = view.getUint16(chunkDataOffset + 12, true);
+      bitsPerSample = view.getUint16(chunkDataOffset + 14, true);
+      if (format === WAVE_FORMAT_EXTENSIBLE) {
+        if (chunkSize < 40) {
+          throw new Error("Unsupported WAV extensible format: fmt chunk is too small.");
+        }
+        const subFormat = view.getUint16(chunkDataOffset + 24, true);
+        format = subFormat;
+      }
+      audioFormat = format;
+    } else if (chunkId === DATA_CHUNK) {
+      dataOffset = chunkDataOffset;
+      dataSize = chunkSize;
+    }
+    offset = chunkDataOffset + chunkSize + chunkSize % 2;
+  }
+  if (!audioFormat || !channels || !sampleRate || !bitsPerSample || !blockAlign) {
+    throw new Error("Invalid WAV file: missing audio format metadata.");
+  }
+  if (dataOffset < 0 || dataSize <= 0) {
+    throw new Error("Invalid WAV file: missing data chunk.");
+  }
+  if (audioFormat !== WAVE_FORMAT_PCM && audioFormat !== WAVE_FORMAT_IEEE_FLOAT) {
+    throw new Error(`Unsupported WAV format: ${audioFormat}.`);
+  }
+  const frameCount = Math.floor(dataSize / blockAlign);
+  const samples = new Float32Array(frameCount);
+  const bytesPerSample = bitsPerSample / 8;
+  for (let frame = 0; frame < frameCount; frame += 1) {
+    let mono = 0;
+    const frameOffset = dataOffset + frame * blockAlign;
+    for (let channel = 0; channel < channels; channel += 1) {
+      const sampleOffset = frameOffset + channel * bytesPerSample;
+      mono += decodeSample(view, sampleOffset, audioFormat, bitsPerSample);
+    }
+    samples[frame] = mono / channels;
+  }
+  return { channels, sampleRate, samples };
+}
+function resampleAudio(samples, fromSampleRate, toSampleRate) {
+  if (fromSampleRate <= 0 || toSampleRate <= 0) {
+    throw new Error("Sample rates must be strictly positive.");
+  }
+  const input = samples instanceof Float32Array ? samples : Float32Array.from(samples);
+  if (input.length === 0) {
+    return new Float32Array();
+  }
+  if (fromSampleRate === toSampleRate) {
+    return input.slice();
+  }
+  const targetLength = Math.max(1, Math.round(input.length * toSampleRate / fromSampleRate));
+  const output = new Float32Array(targetLength);
+  const ratio = fromSampleRate / toSampleRate;
+  for (let index = 0; index < targetLength; index += 1) {
+    const position = index * ratio;
+    const leftIndex = Math.floor(position);
+    const rightIndex = Math.min(leftIndex + 1, input.length - 1);
+    const interpolation = position - leftIndex;
+    output[index] = input[leftIndex] * (1 - interpolation) + input[rightIndex] * interpolation;
+  }
+  return output;
+}
+
+// src/runtime.ts
+var TransformersInferenceBackend = class {
+  async load(options) {
+    const { AutoProcessor, PreTrainedModel } = await import("@huggingface/transformers");
+    const shared = {
+      cache_dir: options.cacheDir,
+      local_files_only: options.localFilesOnly,
+      progress_callback: options.progressCallback,
+      revision: options.revision
+    };
+    const processor = await AutoProcessor.from_pretrained(options.model, shared);
+    const model = await PreTrainedModel.from_pretrained(options.model, {
+      ...shared,
+      device: options.device,
+      dtype: options.dtype
+    });
+    return { model, processor };
+  }
+};
+var TransformersRuntime = class extends TransformersInferenceBackend {
+};
+
+export {
+  decodeWav,
+  resampleAudio,
+  TransformersInferenceBackend,
+  TransformersRuntime
+};

package/dist/index.browser.d.ts

@@ -0,0 +1,111 @@
+import { DeviceType, DataType } from '@huggingface/transformers';
+import { D as DecodedWav, I as InferenceBackend } from './audio-core-CYgIOxAr.js';
+export { a as InferenceBackendLoadOptions, M as ModelLike, P as ProcessorLike, T as TransformersInferenceBackend, b as TransformersRuntime, V as VoxtralRuntime, d as decodeWav, r as resampleAudio } from './audio-core-CYgIOxAr.js';
+
+interface DecodedAudio {
+    channels?: number;
+    sampleRate: number;
+    samples: Float32Array;
+}
+type VoxtralTarget = "auto" | "browser" | "node";
+type AudioDecoderInput = Blob | string | URL;
+interface DecodeFileOptions {
+    channels?: number;
+    sampleRate?: number;
+}
+interface AudioDecoderBackend {
+    readonly name: string;
+    decodeFile(input: AudioDecoderInput, options?: DecodeFileOptions): Promise<DecodedAudio>;
+}
+type AudioContextLike = {
+    close?: () => Promise<void>;
+    decodeAudioData(audioData: ArrayBuffer): Promise<{
+        length: number;
+        numberOfChannels: number;
+        sampleRate: number;
+        getChannelData(channel: number): Float32Array;
+    }>;
+};
+declare class InternalWavDecoder implements AudioDecoderBackend {
+    readonly name = "internal-wav";
+    decodeFile(input: AudioDecoderInput): Promise<DecodedAudio>;
+}
+interface FfmpegDecoderOptions {
+    channels?: number;
+    ffmpegPath?: string;
+    sampleRate?: number;
+}
+declare class FfmpegDecoder implements AudioDecoderBackend {
+    readonly name = "ffmpeg";
+    constructor(_options?: FfmpegDecoderOptions);
+    decodeFile(): Promise<DecodedAudio>;
+}
+interface BrowserNativeAudioDecoderOptions {
+    audioContextFactory?: (options?: {
+        sampleRate?: number;
+    }) => AudioContextLike;
+    fetcher?: typeof fetch;
+}
+declare class BrowserNativeAudioDecoder implements AudioDecoderBackend {
+    readonly name = "browser-native";
+    private readonly audioContextFactory?;
+    private readonly fetcher?;
+    constructor(options?: BrowserNativeAudioDecoderOptions);
+    decodeFile(input: AudioDecoderInput, options?: DecodeFileOptions): Promise<DecodedAudio>;
+    private createAudioContext;
+    private readInputAsArrayBuffer;
+}
+declare function createDefaultAudioDecoderBackend(target?: VoxtralTarget): AudioDecoderBackend;
+
+declare function readWavFile(input: Blob | string | URL): Promise<DecodedWav>;
+
+type VoxtralDevice = DeviceType;
+type VoxtralDtype = DataType;
+declare const DEFAULT_MODEL = "onnx-community/Voxtral-Mini-4B-Realtime-2602-ONNX";
+declare const DEFAULT_DEVICE: VoxtralDevice;
+declare const DEFAULT_DTYPE: VoxtralDtype;
+declare const DEFAULT_SAMPLE_RATE = 16000;
+declare const DEFAULT_TARGET: VoxtralTarget;
+interface VoxtralTranscriberOptions {
+    audioDecoderBackend?: AudioDecoderBackend;
+    cacheDir?: string;
+    device?: VoxtralDevice;
+    dtype?: VoxtralDtype;
+    inferenceBackend?: InferenceBackend;
+    localFilesOnly?: boolean;
+    model?: string;
+    progressCallback?: (progress: unknown) => void;
+    revision?: string;
+    target?: VoxtralTarget;
+}
+interface VoxtralTranscribeOptions {
+    maxNewTokens?: number;
+    sampleRate?: number;
+    skipSpecialTokens?: boolean;
+}
+interface VoxtralTranscriptionResult {
+    decoder: string;
+    durationMs: number;
+    model: string;
+    sampleRate: number;
+    text: string;
+}
+
+declare function createDefaultInferenceBackend(): InferenceBackend;
+declare class VoxtralTranscriber {
+    private readonly audioDecoderBackend;
+    private readonly inferenceBackend;
+    private readonly options;
+    private runtimePromise?;
+    constructor(options?: VoxtralTranscriberOptions, inferenceBackend?: InferenceBackend, audioDecoderBackend?: AudioDecoderBackend);
+    load(): Promise<void>;
+    transcribeAudio(audio: Float32Array | readonly number[], options?: VoxtralTranscribeOptions): Promise<VoxtralTranscriptionResult>;
+    transcribeFile(path: AudioDecoderInput, options?: Omit<VoxtralTranscribeOptions, "sampleRate">): Promise<VoxtralTranscriptionResult>;
+    dispose(): Promise<void>;
+    private ensureRuntime;
+}
+declare function createTranscriber(options?: VoxtralTranscriberOptions): VoxtralTranscriber;
+declare function transcribeAudio(audio: Float32Array | readonly number[], options?: VoxtralTranscriberOptions & VoxtralTranscribeOptions): Promise<VoxtralTranscriptionResult>;
+declare function transcribeFile(path: AudioDecoderInput, options?: VoxtralTranscriberOptions & Omit<VoxtralTranscribeOptions, "sampleRate">): Promise<VoxtralTranscriptionResult>;
+
+export { type AudioDecoderBackend, type AudioDecoderInput, BrowserNativeAudioDecoder, type BrowserNativeAudioDecoderOptions, DEFAULT_DEVICE, DEFAULT_DTYPE, DEFAULT_MODEL, DEFAULT_SAMPLE_RATE, DEFAULT_TARGET, type DecodeFileOptions, type DecodedAudio, DecodedWav, FfmpegDecoder, type FfmpegDecoderOptions, InferenceBackend, InternalWavDecoder, type VoxtralDevice, type VoxtralDtype, type VoxtralTarget, type VoxtralTranscribeOptions, VoxtralTranscriber, type VoxtralTranscriberOptions, type VoxtralTranscriptionResult, createDefaultAudioDecoderBackend, createDefaultInferenceBackend, createTranscriber, readWavFile, transcribeAudio, transcribeFile };

package/dist/index.browser.js

@@ -0,0 +1,247 @@
+import {
+  TransformersInferenceBackend,
+  TransformersRuntime,
+  decodeWav,
+  resampleAudio
+} from "./chunk-J6JHGURB.js";
+
+// src/audio.browser.ts
+function isBlobLike(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+async function readWavFile(input) {
+  if (isBlobLike(input)) {
+    return decodeWav(new Uint8Array(await input.arrayBuffer()));
+  }
+  if (typeof fetch !== "function") {
+    throw new Error("readWavFile requires fetch in browser environments.");
+  }
+  const response = await fetch(input.toString());
+  if (!response.ok) {
+    throw new Error(`Failed to fetch WAV input "${input.toString()}": ${response.status} ${response.statusText}`);
+  }
+  return decodeWav(new Uint8Array(await response.arrayBuffer()));
+}
+
+// src/decoder.browser.ts
+function isBlobLike2(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function downmixToMono(channelData) {
+  if (channelData.length === 0) {
+    return new Float32Array();
+  }
+  if (channelData.length === 1) {
+    return channelData[0].slice();
+  }
+  const samples = new Float32Array(channelData[0].length);
+  for (let sampleIndex = 0; sampleIndex < samples.length; sampleIndex += 1) {
+    let sum = 0;
+    for (const channel of channelData) {
+      sum += channel[sampleIndex] ?? 0;
+    }
+    samples[sampleIndex] = sum / channelData.length;
+  }
+  return samples;
+}
+var InternalWavDecoder = class {
+  name = "internal-wav";
+  async decodeFile(input) {
+    if (isBlobLike2(input)) {
+      return decodeWav(new Uint8Array(await input.arrayBuffer()));
+    }
+    return await readWavFile(input);
+  }
+};
+var FfmpegDecoder = class {
+  name = "ffmpeg";
+  constructor(_options = {}) {
+  }
+  async decodeFile() {
+    throw new Error("FfmpegDecoder is not available in browser builds.");
+  }
+};
+var BrowserNativeAudioDecoder = class {
+  name = "browser-native";
+  audioContextFactory;
+  fetcher;
+  constructor(options = {}) {
+    this.audioContextFactory = options.audioContextFactory;
+    this.fetcher = options.fetcher;
+  }
+  async decodeFile(input, options = {}) {
+    const channels = options.channels ?? 1;
+    if (channels !== 1) {
+      throw new Error(`BrowserNativeAudioDecoder currently supports only mono output. Received channels=${channels}.`);
+    }
+    const fetcher = this.fetcher ?? globalThis.fetch;
+    const audioContext = this.createAudioContext(options.sampleRate);
+    const arrayBuffer = await this.readInputAsArrayBuffer(input, fetcher);
+    try {
+      const decoded = await audioContext.decodeAudioData(arrayBuffer.slice(0));
+      const channelData = Array.from({ length: decoded.numberOfChannels }, (_, channel) => decoded.getChannelData(channel));
+      return {
+        channels,
+        sampleRate: decoded.sampleRate,
+        samples: downmixToMono(channelData)
+      };
+    } finally {
+      await audioContext.close?.();
+    }
+  }
+  createAudioContext(sampleRate) {
+    if (this.audioContextFactory) {
+      return this.audioContextFactory(sampleRate ? { sampleRate } : void 0);
+    }
+    const AudioContextCtor = globalThis.AudioContext ?? globalThis.webkitAudioContext;
+    if (typeof AudioContextCtor !== "function") {
+      throw new Error("BrowserNativeAudioDecoder requires AudioContext or webkitAudioContext.");
+    }
+    return new AudioContextCtor(sampleRate ? { sampleRate } : void 0);
+  }
+  async readInputAsArrayBuffer(input, fetcher) {
+    if (isBlobLike2(input)) {
+      return await input.arrayBuffer();
+    }
+    if (typeof fetcher !== "function") {
+      throw new Error("BrowserNativeAudioDecoder requires fetch to load URL inputs.");
+    }
+    const response = await fetcher(input.toString());
+    if (!response.ok) {
+      throw new Error(`BrowserNativeAudioDecoder failed to fetch "${input.toString()}": ${response.status} ${response.statusText}`);
+    }
+    return await response.arrayBuffer();
+  }
+};
+function createDefaultAudioDecoderBackend(target = "auto") {
+  if (target === "node") {
+    return new InternalWavDecoder();
+  }
+  return new BrowserNativeAudioDecoder();
+}
+
+// src/index.browser.ts
+var DEFAULT_MODEL = "onnx-community/Voxtral-Mini-4B-Realtime-2602-ONNX";
+var DEFAULT_DEVICE = "cpu";
+var DEFAULT_DTYPE = "q4";
+var DEFAULT_SAMPLE_RATE = 16e3;
+var DEFAULT_TARGET = "auto";
+function createDefaultInferenceBackend() {
+  return new TransformersInferenceBackend();
+}
+var VoxtralTranscriber = class {
+  audioDecoderBackend;
+  inferenceBackend;
+  options;
+  runtimePromise;
+  constructor(options = {}, inferenceBackend = options.inferenceBackend ?? createDefaultInferenceBackend(), audioDecoderBackend = options.audioDecoderBackend ?? createDefaultAudioDecoderBackend(options.target ?? DEFAULT_TARGET)) {
+    this.options = {
+      cacheDir: options.cacheDir,
+      device: options.device ?? DEFAULT_DEVICE,
+      dtype: options.dtype ?? DEFAULT_DTYPE,
+      localFilesOnly: options.localFilesOnly,
+      model: options.model ?? DEFAULT_MODEL,
+      progressCallback: options.progressCallback,
+      revision: options.revision
+    };
+    this.inferenceBackend = inferenceBackend;
+    this.audioDecoderBackend = audioDecoderBackend;
+  }
+  async load() {
+    await this.ensureRuntime();
+  }
+  async transcribeAudio(audio, options = {}) {
+    const { model, processor } = await this.ensureRuntime();
+    const sourceSampleRate = options.sampleRate ?? DEFAULT_SAMPLE_RATE;
+    const targetSampleRate = processor.feature_extractor.config.sampling_rate ?? DEFAULT_SAMPLE_RATE;
+    const preparedAudio = resampleAudio(audio, sourceSampleRate, targetSampleRate);
+    const startedAt = performance.now();
+    const inputs = await processor(preparedAudio);
+    const outputs = await model.generate({
+      ...inputs,
+      max_new_tokens: options.maxNewTokens
+    });
+    const text = processor.batch_decode(outputs, { skip_special_tokens: options.skipSpecialTokens ?? true })[0]?.trim() ?? "";
+    return {
+      decoder: this.audioDecoderBackend.name,
+      durationMs: performance.now() - startedAt,
+      model: this.options.model,
+      sampleRate: targetSampleRate,
+      text
+    };
+  }
+  async transcribeFile(path, options = {}) {
+    const { processor } = await this.ensureRuntime();
+    const targetSampleRate = processor.feature_extractor.config.sampling_rate ?? DEFAULT_SAMPLE_RATE;
+    const decoded = await this.audioDecoderBackend.decodeFile(path, {
+      channels: 1,
+      sampleRate: targetSampleRate
+    });
+    return await this.transcribeAudio(decoded.samples, {
+      ...options,
+      sampleRate: decoded.sampleRate
+    });
+  }
+  async dispose() {
+    const runtime = this.runtimePromise ? await this.runtimePromise : void 0;
+    if (!runtime) {
+      return;
+    }
+    await runtime.model.dispose();
+    this.runtimePromise = void 0;
+  }
+  async ensureRuntime() {
+    if (!this.runtimePromise) {
+      this.runtimePromise = this.inferenceBackend.load({
+        cacheDir: this.options.cacheDir,
+        device: this.options.device,
+        dtype: this.options.dtype,
+        localFilesOnly: this.options.localFilesOnly,
+        model: this.options.model,
+        progressCallback: this.options.progressCallback,
+        revision: this.options.revision
+      });
+    }
+    return await this.runtimePromise;
+  }
+};
+function createTranscriber(options = {}) {
+  return new VoxtralTranscriber(options);
+}
+async function transcribeAudio(audio, options = {}) {
+  const transcriber = new VoxtralTranscriber(options);
+  try {
+    return await transcriber.transcribeAudio(audio, options);
+  } finally {
+    await transcriber.dispose();
+  }
+}
+async function transcribeFile(path, options = {}) {
+  const transcriber = new VoxtralTranscriber(options);
+  try {
+    return await transcriber.transcribeFile(path, options);
+  } finally {
+    await transcriber.dispose();
+  }
+}
+export {
+  BrowserNativeAudioDecoder,
+  DEFAULT_DEVICE,
+  DEFAULT_DTYPE,
+  DEFAULT_MODEL,
+  DEFAULT_SAMPLE_RATE,
+  DEFAULT_TARGET,
+  FfmpegDecoder,
+  InternalWavDecoder,
+  TransformersInferenceBackend,
+  TransformersRuntime,
+  VoxtralTranscriber,
+  createDefaultAudioDecoderBackend,
+  createDefaultInferenceBackend,
+  createTranscriber,
+  decodeWav,
+  readWavFile,
+  resampleAudio,
+  transcribeAudio,
+  transcribeFile
+};

package/dist/index.node.d.ts

@@ -0,0 +1,124 @@
+import { DeviceType, DataType } from '@huggingface/transformers';
+import { SpawnOptionsWithoutStdio } from 'node:child_process';
+import { Readable } from 'node:stream';
+import { D as DecodedWav, I as InferenceBackend } from './audio-core-CYgIOxAr.js';
+export { a as InferenceBackendLoadOptions, M as ModelLike, P as ProcessorLike, T as TransformersInferenceBackend, b as TransformersRuntime, V as VoxtralRuntime, d as decodeWav, r as resampleAudio } from './audio-core-CYgIOxAr.js';
+
+interface DecodedAudio {
+    channels?: number;
+    sampleRate: number;
+    samples: Float32Array;
+}
+type VoxtralTarget = "auto" | "browser" | "node";
+type AudioDecoderInput = Blob | string | URL;
+interface DecodeFileOptions {
+    channels?: number;
+    sampleRate?: number;
+}
+interface AudioDecoderBackend {
+    readonly name: string;
+    decodeFile(input: AudioDecoderInput, options?: DecodeFileOptions): Promise<DecodedAudio>;
+}
+type SpawnFactory = (command: string, args: readonly string[], options: SpawnOptionsWithoutStdio) => {
+    stdout: Readable;
+    stderr: Readable;
+    once(event: "error", listener: (error: Error) => void): unknown;
+    once(event: "close", listener: (code: number | null) => void): unknown;
+};
+type AudioContextLike = {
+    close?: () => Promise<void>;
+    decodeAudioData(audioData: ArrayBuffer): Promise<{
+        length: number;
+        numberOfChannels: number;
+        sampleRate: number;
+        getChannelData(channel: number): Float32Array;
+    }>;
+};
+declare class InternalWavDecoder implements AudioDecoderBackend {
+    readonly name = "internal-wav";
+    decodeFile(input: AudioDecoderInput): Promise<DecodedAudio>;
+}
+interface FfmpegDecoderOptions {
+    channels?: number;
+    ffmpegPath?: string;
+    sampleRate?: number;
+    spawnFactory?: SpawnFactory;
+}
+declare class FfmpegDecoder implements AudioDecoderBackend {
+    readonly name = "ffmpeg";
+    private readonly channels;
+    private readonly ffmpegPath;
+    private readonly sampleRate;
+    private readonly spawnFactory;
+    constructor(options?: FfmpegDecoderOptions);
+    decodeFile(input: AudioDecoderInput, options?: DecodeFileOptions): Promise<DecodedAudio>;
+}
+interface BrowserNativeAudioDecoderOptions {
+    audioContextFactory?: (options?: {
+        sampleRate?: number;
+    }) => AudioContextLike;
+    fetcher?: typeof fetch;
+}
+declare class BrowserNativeAudioDecoder implements AudioDecoderBackend {
+    readonly name = "browser-native";
+    private readonly audioContextFactory?;
+    private readonly fetcher?;
+    constructor(options?: BrowserNativeAudioDecoderOptions);
+    decodeFile(input: AudioDecoderInput, options?: DecodeFileOptions): Promise<DecodedAudio>;
+    private createAudioContext;
+    private readInputAsArrayBuffer;
+}
+declare function createDefaultAudioDecoderBackend(target?: VoxtralTarget): AudioDecoderBackend;
+
+declare function readWavFile(path: string | URL): Promise<DecodedWav>;
+
+type VoxtralDevice = DeviceType;
+type VoxtralDtype = DataType;
+declare const DEFAULT_MODEL = "onnx-community/Voxtral-Mini-4B-Realtime-2602-ONNX";
+declare const DEFAULT_DEVICE: VoxtralDevice;
+declare const DEFAULT_DTYPE: VoxtralDtype;
+declare const DEFAULT_SAMPLE_RATE = 16000;
+declare const DEFAULT_TARGET: VoxtralTarget;
+interface VoxtralTranscriberOptions {
+    audioDecoderBackend?: AudioDecoderBackend;
+    cacheDir?: string;
+    device?: VoxtralDevice;
+    dtype?: VoxtralDtype;
+    inferenceBackend?: InferenceBackend;
+    localFilesOnly?: boolean;
+    model?: string;
+    progressCallback?: (progress: unknown) => void;
+    revision?: string;
+    target?: VoxtralTarget;
+}
+interface VoxtralTranscribeOptions {
+    maxNewTokens?: number;
+    sampleRate?: number;
+    skipSpecialTokens?: boolean;
+}
+interface VoxtralTranscriptionResult {
+    decoder: string;
+    durationMs: number;
+    model: string;
+    sampleRate: number;
+    text: string;
+}
+
+declare function createDefaultInferenceBackend(): InferenceBackend;
+declare class VoxtralTranscriber {
+    private readonly audioDecoderBackend;
+    private readonly inferenceBackend;
+    private readonly options;
+    private runtimePromise?;
+    constructor(options?: VoxtralTranscriberOptions, inferenceBackend?: InferenceBackend, audioDecoderBackend?: AudioDecoderBackend);
+    load(): Promise<void>;
+    transcribeAudio(audio: Float32Array | readonly number[], options?: VoxtralTranscribeOptions): Promise<VoxtralTranscriptionResult>;
+    transcribeFile(path: AudioDecoderInput, options?: Omit<VoxtralTranscribeOptions, "sampleRate">): Promise<VoxtralTranscriptionResult>;
+    dispose(): Promise<void>;
+    private ensureRuntime;
+}
+declare function createTranscriber(options?: VoxtralTranscriberOptions): VoxtralTranscriber;
+declare function transcribeAudio(audio: Float32Array | readonly number[], options?: VoxtralTranscriberOptions & VoxtralTranscribeOptions): Promise<VoxtralTranscriptionResult>;
+declare function transcribeFile(path: AudioDecoderInput, options?: VoxtralTranscriberOptions & Omit<VoxtralTranscribeOptions, "sampleRate">): Promise<VoxtralTranscriptionResult>;
+
+export { type AudioDecoderBackend, type AudioDecoderInput, BrowserNativeAudioDecoder, type BrowserNativeAudioDecoderOptions, DEFAULT_DEVICE, DEFAULT_DTYPE, DEFAULT_MODEL, DEFAULT_SAMPLE_RATE, DEFAULT_TARGET, type DecodeFileOptions, type DecodedAudio, DecodedWav, FfmpegDecoder, type FfmpegDecoderOptions, InferenceBackend, InternalWavDecoder, type VoxtralDevice, type VoxtralDtype, type VoxtralTarget, type VoxtralTranscribeOptions, VoxtralTranscriber, type VoxtralTranscriberOptions, type VoxtralTranscriptionResult, createDefaultAudioDecoderBackend, createDefaultInferenceBackend, createTranscriber, readWavFile, transcribeAudio, transcribeFile };

package/dist/index.node.js

@@ -0,0 +1,328 @@
+import {
+  TransformersInferenceBackend,
+  TransformersRuntime,
+  decodeWav,
+  resampleAudio
+} from "./chunk-J6JHGURB.js";
+
+// src/audio.node.ts
+import { readFile } from "fs/promises";
+async function readWavFile(path) {
+  const buffer = await readFile(path);
+  return decodeWav(buffer);
+}
+
+// src/decoder.node.ts
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+function isBlobLike(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function downmixToMono(channelData) {
+  if (channelData.length === 0) {
+    return new Float32Array();
+  }
+  if (channelData.length === 1) {
+    return channelData[0].slice();
+  }
+  const samples = new Float32Array(channelData[0].length);
+  for (let sampleIndex = 0; sampleIndex < samples.length; sampleIndex += 1) {
+    let sum = 0;
+    for (const channel of channelData) {
+      sum += channel[sampleIndex] ?? 0;
+    }
+    samples[sampleIndex] = sum / channelData.length;
+  }
+  return samples;
+}
+function concatenateUint8Arrays(chunks) {
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+  const output = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    output.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return output;
+}
+function float32FromBytes(bytes) {
+  if (bytes.byteLength % 4 !== 0) {
+    throw new Error(`Invalid ffmpeg PCM output size: expected a multiple of 4 bytes, got ${bytes.byteLength}.`);
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const samples = new Float32Array(bytes.byteLength / 4);
+  for (let index = 0; index < samples.length; index += 1) {
+    samples[index] = view.getFloat32(index * 4, true);
+  }
+  return samples;
+}
+async function normalizeFfmpegInput(input) {
+  if (isBlobLike(input)) {
+    throw new Error("FfmpegDecoder does not accept Blob/File inputs. Use BrowserNativeAudioDecoder or transcribeAudio().");
+  }
+  if (input instanceof URL && input.protocol === "file:") {
+    return fileURLToPath(input);
+  }
+  return input.toString();
+}
+var InternalWavDecoder = class {
+  name = "internal-wav";
+  async decodeFile(input) {
+    if (isBlobLike(input)) {
+      return decodeWav(new Uint8Array(await input.arrayBuffer()));
+    }
+    return await readWavFile(input);
+  }
+};
+var FfmpegDecoder = class {
+  name = "ffmpeg";
+  channels;
+  ffmpegPath;
+  sampleRate;
+  spawnFactory;
+  constructor(options = {}) {
+    this.channels = options.channels ?? 1;
+    this.ffmpegPath = options.ffmpegPath ?? "ffmpeg";
+    this.sampleRate = options.sampleRate ?? 16e3;
+    this.spawnFactory = options.spawnFactory ?? ((command, args, spawnOptions) => spawn(command, args, spawnOptions));
+  }
+  async decodeFile(input, options = {}) {
+    const channels = options.channels ?? this.channels;
+    const sampleRate = options.sampleRate ?? this.sampleRate;
+    const normalizedInput = await normalizeFfmpegInput(input);
+    const child = this.spawnFactory(
+      this.ffmpegPath,
+      [
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-nostdin",
+        "-i",
+        normalizedInput,
+        "-ac",
+        String(channels),
+        "-ar",
+        String(sampleRate),
+        "-f",
+        "f32le",
+        "-acodec",
+        "pcm_f32le",
+        "pipe:1"
+      ],
+      { stdio: ["ignore", "pipe", "pipe"] }
+    );
+    return await new Promise((resolve, reject) => {
+      const stdoutChunks = [];
+      const stderrChunks = [];
+      child.stdout.on("data", (chunk) => {
+        stdoutChunks.push(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk));
+      });
+      child.stderr.on("data", (chunk) => {
+        stderrChunks.push(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk));
+      });
+      child.once("error", (error) => {
+        reject(new Error(`Failed to start ffmpeg decoder with "${this.ffmpegPath}": ${error.message}`));
+      });
+      child.once("close", (code) => {
+        if (code !== 0) {
+          const details = new TextDecoder().decode(concatenateUint8Arrays(stderrChunks)).trim();
+          reject(
+            new Error(
+              details ? `ffmpeg decoder failed (${code}): ${details}` : `ffmpeg decoder failed with exit code ${code}.`
+            )
+          );
+          return;
+        }
+        resolve({
+          channels,
+          sampleRate,
+          samples: float32FromBytes(concatenateUint8Arrays(stdoutChunks))
+        });
+      });
+    });
+  }
+};
+var BrowserNativeAudioDecoder = class {
+  name = "browser-native";
+  audioContextFactory;
+  fetcher;
+  constructor(options = {}) {
+    this.audioContextFactory = options.audioContextFactory;
+    this.fetcher = options.fetcher;
+  }
+  async decodeFile(input, options = {}) {
+    const channels = options.channels ?? 1;
+    if (channels !== 1) {
+      throw new Error(`BrowserNativeAudioDecoder currently supports only mono output. Received channels=${channels}.`);
+    }
+    const fetcher = this.fetcher ?? globalThis.fetch;
+    const audioContext = this.createAudioContext(options.sampleRate);
+    const arrayBuffer = await this.readInputAsArrayBuffer(input, fetcher);
+    try {
+      const decoded = await audioContext.decodeAudioData(arrayBuffer.slice(0));
+      const channelData = Array.from({ length: decoded.numberOfChannels }, (_, channel) => decoded.getChannelData(channel));
+      return {
+        channels,
+        sampleRate: decoded.sampleRate,
+        samples: downmixToMono(channelData)
+      };
+    } finally {
+      await audioContext.close?.();
+    }
+  }
+  createAudioContext(sampleRate) {
+    if (this.audioContextFactory) {
+      return this.audioContextFactory(sampleRate ? { sampleRate } : void 0);
+    }
+    const AudioContextCtor = globalThis.AudioContext ?? globalThis.webkitAudioContext;
+    if (typeof AudioContextCtor !== "function") {
+      throw new Error("BrowserNativeAudioDecoder requires AudioContext or webkitAudioContext.");
+    }
+    return new AudioContextCtor(sampleRate ? { sampleRate } : void 0);
+  }
+  async readInputAsArrayBuffer(input, fetcher) {
+    if (isBlobLike(input)) {
+      return await input.arrayBuffer();
+    }
+    if (typeof fetcher !== "function") {
+      throw new Error("BrowserNativeAudioDecoder requires fetch to load URL inputs.");
+    }
+    const response = await fetcher(input.toString());
+    if (!response.ok) {
+      throw new Error(`BrowserNativeAudioDecoder failed to fetch "${input.toString()}": ${response.status} ${response.statusText}`);
+    }
+    return await response.arrayBuffer();
+  }
+};
+function createDefaultAudioDecoderBackend(target = "auto") {
+  if (target === "browser") {
+    return new BrowserNativeAudioDecoder();
+  }
+  return new InternalWavDecoder();
+}
+
+// src/index.node.ts
+var DEFAULT_MODEL = "onnx-community/Voxtral-Mini-4B-Realtime-2602-ONNX";
+var DEFAULT_DEVICE = "cpu";
+var DEFAULT_DTYPE = "q4";
+var DEFAULT_SAMPLE_RATE = 16e3;
+var DEFAULT_TARGET = "auto";
+function createDefaultInferenceBackend() {
+  return new TransformersInferenceBackend();
+}
+var VoxtralTranscriber = class {
+  audioDecoderBackend;
+  inferenceBackend;
+  options;
+  runtimePromise;
+  constructor(options = {}, inferenceBackend = options.inferenceBackend ?? createDefaultInferenceBackend(), audioDecoderBackend = options.audioDecoderBackend ?? createDefaultAudioDecoderBackend(options.target ?? DEFAULT_TARGET)) {
+    this.options = {
+      cacheDir: options.cacheDir,
+      device: options.device ?? DEFAULT_DEVICE,
+      dtype: options.dtype ?? DEFAULT_DTYPE,
+      localFilesOnly: options.localFilesOnly,
+      model: options.model ?? DEFAULT_MODEL,
+      progressCallback: options.progressCallback,
+      revision: options.revision
+    };
+    this.inferenceBackend = inferenceBackend;
+    this.audioDecoderBackend = audioDecoderBackend;
+  }
+  async load() {
+    await this.ensureRuntime();
+  }
+  async transcribeAudio(audio, options = {}) {
+    const { model, processor } = await this.ensureRuntime();
+    const sourceSampleRate = options.sampleRate ?? DEFAULT_SAMPLE_RATE;
+    const targetSampleRate = processor.feature_extractor.config.sampling_rate ?? DEFAULT_SAMPLE_RATE;
+    const preparedAudio = resampleAudio(audio, sourceSampleRate, targetSampleRate);
+    const startedAt = performance.now();
+    const inputs = await processor(preparedAudio);
+    const outputs = await model.generate({
+      ...inputs,
+      max_new_tokens: options.maxNewTokens
+    });
+    const text = processor.batch_decode(outputs, { skip_special_tokens: options.skipSpecialTokens ?? true })[0]?.trim() ?? "";
+    return {
+      decoder: this.audioDecoderBackend.name,
+      durationMs: performance.now() - startedAt,
+      model: this.options.model,
+      sampleRate: targetSampleRate,
+      text
+    };
+  }
+  async transcribeFile(path, options = {}) {
+    const { processor } = await this.ensureRuntime();
+    const targetSampleRate = processor.feature_extractor.config.sampling_rate ?? DEFAULT_SAMPLE_RATE;
+    const decoded = await this.audioDecoderBackend.decodeFile(path, {
+      channels: 1,
+      sampleRate: targetSampleRate
+    });
+    return await this.transcribeAudio(decoded.samples, {
+      ...options,
+      sampleRate: decoded.sampleRate
+    });
+  }
+  async dispose() {
+    const runtime = this.runtimePromise ? await this.runtimePromise : void 0;
+    if (!runtime) {
+      return;
+    }
+    await runtime.model.dispose();
+    this.runtimePromise = void 0;
+  }
+  async ensureRuntime() {
+    if (!this.runtimePromise) {
+      this.runtimePromise = this.inferenceBackend.load({
+        cacheDir: this.options.cacheDir,
+        device: this.options.device,
+        dtype: this.options.dtype,
+        localFilesOnly: this.options.localFilesOnly,
+        model: this.options.model,
+        progressCallback: this.options.progressCallback,
+        revision: this.options.revision
+      });
+    }
+    return await this.runtimePromise;
+  }
+};
+function createTranscriber(options = {}) {
+  return new VoxtralTranscriber(options);
+}
+async function transcribeAudio(audio, options = {}) {
+  const transcriber = new VoxtralTranscriber(options);
+  try {
+    return await transcriber.transcribeAudio(audio, options);
+  } finally {
+    await transcriber.dispose();
+  }
+}
+async function transcribeFile(path, options = {}) {
+  const transcriber = new VoxtralTranscriber(options);
+  try {
+    return await transcriber.transcribeFile(path, options);
+  } finally {
+    await transcriber.dispose();
+  }
+}
+export {
+  BrowserNativeAudioDecoder,
+  DEFAULT_DEVICE,
+  DEFAULT_DTYPE,
+  DEFAULT_MODEL,
+  DEFAULT_SAMPLE_RATE,
+  DEFAULT_TARGET,
+  FfmpegDecoder,
+  InternalWavDecoder,
+  TransformersInferenceBackend,
+  TransformersRuntime,
+  VoxtralTranscriber,
+  createDefaultAudioDecoderBackend,
+  createDefaultInferenceBackend,
+  createTranscriber,
+  decodeWav,
+  readWavFile,
+  resampleAudio,
+  transcribeAudio,
+  transcribeFile
+};

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "voxtral-transcribe-ts",
+  "version": "0.1.0",
+  "description": "Minimal TypeScript wrapper for local Voxtral Mini 4B Realtime transcription in Node.js.",
+  "type": "module",
+  "main": "./dist/index.node.js",
+  "types": "./dist/index.node.d.ts",
+  "browser": "./dist/index.browser.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.node.d.ts",
+      "browser": "./dist/index.browser.js",
+      "import": "./dist/index.node.js",
+      "default": "./dist/index.node.js"
+    },
+    "./browser": {
+      "types": "./dist/index.browser.d.ts",
+      "import": "./dist/index.browser.js",
+      "default": "./dist/index.browser.js"
+    },
+    "./node": {
+      "types": "./dist/index.node.d.ts",
+      "import": "./dist/index.node.js",
+      "default": "./dist/index.node.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.node.ts src/index.browser.ts --format esm --dts --clean",
+    "check:browser-bundle": "esbuild src/index.browser.ts --bundle --platform=browser --format=esm --outfile=/tmp/voxtral-browser-check.js",
+    "check": "tsc --noEmit",
+    "test:smoke": "bash ./scripts/smoke-test.sh",
+    "test": "npm run build && node --test test/*.test.js",
+    "validate": "npm run check && npm run test && npm run check:browser-bundle",
+    "prepublishOnly": "npm run validate && npm run test:smoke"
+  },
+  "keywords": [
+    "voxtral",
+    "transcription",
+    "speech-to-text",
+    "mistral",
+    "onnx",
+    "transformers"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.11.0"
+  },
+  "dependencies": {
+    "@huggingface/transformers": "^3.8.1",
+    "onnxruntime-common": "1.21.0",
+    "onnxruntime-node": "1.21.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.17",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3"
+  }
+}