pyannote-cpp-node 0.1.0

package/README.md

@@ -0,0 +1,765 @@
+# pyannote-cpp-node
+
+Node.js native bindings for real-time speaker diarization
+
+![Platform](https://img.shields.io/badge/platform-macOS-lightgrey)
+![Node](https://img.shields.io/badge/node-%3E%3D18-brightgreen)
+
+## Overview
+
+`pyannote-cpp-node` provides Node.js bindings to a high-performance C++ port of the [`pyannote/speaker-diarization-community-1`](https://huggingface.co/pyannote/speaker-diarization-community-1) pipeline. It achieves **39x real-time** performance on Apple Silicon by leveraging CoreML acceleration (Neural Engine + GPU) for neural network inference and optimized C++ implementations of clustering algorithms.
+
+The library supports two modes:
+
+- **Offline diarization**: Process an entire audio file at once and receive speaker-labeled segments
+- **Streaming diarization**: Process audio incrementally in real-time, receive voice activity detection (VAD) as audio arrives, and trigger speaker clustering on demand
+
+All heavy operations are asynchronous and run on libuv worker threads, ensuring the Node.js event loop remains responsive.
+
+## Features
+
+- **Offline diarization** — Process full audio files and get speaker-labeled segments
+- **Streaming diarization** — Push audio incrementally, receive real-time VAD, recluster on demand
+- **Async/await API** — All heavy operations return Promises and run on worker threads
+- **CoreML acceleration** — Neural networks run on Apple's Neural Engine, GPU, and CPU
+- **TypeScript-first** — Full type definitions included
+- **Zero-copy audio input** — Direct `Float32Array` input for maximum efficiency
+- **Byte-identical output** — Streaming finalize produces identical results to offline pipeline
+
+## Requirements
+
+- **macOS** with Apple Silicon (M1/M2/M3/M4) or Intel x64
+- **Node.js** >= 18
+- **Model files**:
+  - Segmentation GGUF model (`segmentation.gguf`)
+  - Embedding GGUF model (`embedding.gguf`)
+  - PLDA GGUF model (`plda.gguf`)
+  - Segmentation CoreML model package (`segmentation.mlpackage/`)
+  - Embedding CoreML model package (`embedding.mlpackage/`)
+
+Model files can be obtained by converting the original PyTorch models using the conversion scripts in the parent repository.
+
+## Installation
+
+```bash
+npm install pyannote-cpp-node
+```
+
+Or with pnpm:
+
+```bash
+pnpm add pyannote-cpp-node
+```
+
+The package uses `optionalDependencies` to automatically install the correct platform-specific native addon (`@pyannote-cpp-node/darwin-arm64` or `@pyannote-cpp-node/darwin-x64`).
+
+## Quick Start
+
+```typescript
+import { Pyannote } from 'pyannote-cpp-node';
+import { readFileSync } from 'node:fs';
+
+// Load model (validates all paths exist)
+const model = await Pyannote.load({
+  segModelPath: './models/segmentation.gguf',
+  embModelPath: './models/embedding.gguf',
+  pldaPath: './models/plda.gguf',
+  coremlPath: './models/embedding.mlpackage',
+  segCoremlPath: './models/segmentation.mlpackage',
+});
+
+// Load audio (16kHz mono Float32Array - see "Audio Format Requirements")
+const audio = loadWavFile('./audio.wav');
+
+// Run diarization
+const result = await model.diarize(audio);
+
+// Print results
+for (const segment of result.segments) {
+  console.log(
+    `[${segment.start.toFixed(2)}s - ${(segment.start + segment.duration).toFixed(2)}s] ${segment.speaker}`
+  );
+}
+
+// Clean up
+model.close();
+```
+
+## API Reference
+
+### `Pyannote` Class
+
+The main entry point for loading diarization models.
+
+#### `static async load(config: ModelConfig): Promise<Pyannote>`
+
+Factory method for loading a diarization model. Validates that all model paths exist before initializing. CoreML model compilation happens synchronously during initialization and is typically fast.
+
+**Parameters:**
+- `config: ModelConfig` — Configuration object with paths to all required model files
+
+**Returns:** `Promise<Pyannote>` — Initialized model instance
+
+**Throws:**
+- `Error` if any model path does not exist or is invalid
+
+**Example:**
+```typescript
+const model = await Pyannote.load({
+  segModelPath: './models/segmentation.gguf',
+  embModelPath: './models/embedding.gguf',
+  pldaPath: './models/plda.gguf',
+  coremlPath: './models/embedding.mlpackage',
+  segCoremlPath: './models/segmentation.mlpackage',
+});
+```
+
+#### `async diarize(audio: Float32Array): Promise<DiarizationResult>`
+
+Performs offline diarization on the entire audio file. Audio must be 16kHz mono in `Float32Array` format with values in the range [-1.0, 1.0].
+
+Internally, this method uses the streaming API: it initializes a streaming session, pushes all audio in 1-second chunks, calls finalize, and cleans up. The operation runs on a worker thread and is non-blocking.
+
+**Parameters:**
+- `audio: Float32Array` — Audio samples (16kHz mono, values in [-1.0, 1.0])
+
+**Returns:** `Promise<DiarizationResult>` — Diarization result with speaker-labeled segments sorted by start time
+
+**Throws:**
+- `Error` if model is closed
+- `TypeError` if audio is not a `Float32Array`
+- `Error` if audio is empty
+
+**Example:**
+```typescript
+const result = await model.diarize(audio);
+console.log(`Detected ${result.segments.length} segments`);
+```
+
+#### `createStreamingSession(): StreamingSession`
+
+Creates a new independent streaming session. Each session maintains its own internal state and can be used to process audio incrementally.
+
+**Returns:** `StreamingSession` — New streaming session instance
+
+**Throws:**
+- `Error` if model is closed
+
+**Example:**
+```typescript
+const session = model.createStreamingSession();
+```
+
+#### `close(): void`
+
+Releases all native resources associated with the model. This method is idempotent and safe to call multiple times.
+
+Once closed, the model cannot be used for diarization or creating new streaming sessions. Existing streaming sessions should be closed before closing the model.
+
+**Example:**
+```typescript
+model.close();
+console.log(model.isClosed); // true
+```
+
+#### `get isClosed: boolean`
+
+Indicates whether the model has been closed.
+
+**Returns:** `boolean` — `true` if the model is closed, `false` otherwise
+
+### `StreamingSession` Class
+
+Handles incremental audio processing for real-time diarization.
+
+#### `async push(audio: Float32Array): Promise<VADChunk[]>`
+
+Pushes audio samples to the streaming session. Audio must be 16kHz mono `Float32Array`. Typically, push 1 second of audio (16,000 samples) at a time.
+
+The first chunk requires 10 seconds of accumulated audio to produce output (the segmentation model uses a 10-second window). After that, each subsequent push returns approximately one `VADChunk` (depending on the 1-second hop size).
+
+The returned VAD chunks contain frame-level voice activity (OR of all speakers) for the newly processed 10-second windows.
+
+**Parameters:**
+- `audio: Float32Array` — Audio samples (16kHz mono, values in [-1.0, 1.0])
+
+**Returns:** `Promise<VADChunk[]>` — Array of VAD chunks (empty until 10 seconds accumulated)
+
+**Throws:**
+- `Error` if session is closed
+- `TypeError` if audio is not a `Float32Array`
+
+**Example:**
+```typescript
+const vadChunks = await session.push(audioChunk);
+for (const chunk of vadChunks) {
+  console.log(`VAD chunk ${chunk.chunkIndex}: ${chunk.numFrames} frames`);
+}
+```
+
+#### `async recluster(): Promise<DiarizationResult>`
+
+Triggers full clustering on all accumulated audio data. This runs the complete diarization pipeline (embedding extraction → PLDA scoring → hierarchical clustering → VBx refinement → speaker assignment) and returns speaker-labeled segments with global speaker IDs.
+
+**Warning:** This method mutates the internal session state. Specifically, it replaces the internal embedding and chunk index arrays with filtered versions (excluding silent speakers). Calling `push` after `recluster` may produce unexpected results. Use `recluster` sparingly (e.g., every 30 seconds for live progress updates) or only call `finalize` when the stream ends.
+
+The operation runs on a worker thread and is non-blocking.
+
+**Returns:** `Promise<DiarizationResult>` — Complete diarization result with global speaker labels
+
+**Throws:**
+- `Error` if session is closed
+
+**Example:**
+```typescript
+// Trigger intermediate clustering after accumulating data
+const intermediateResult = await session.recluster();
+console.log(`Current speaker count: ${new Set(intermediateResult.segments.map(s => s.speaker)).size}`);
+```
+
+#### `async finalize(): Promise<DiarizationResult>`
+
+Processes any remaining audio (zero-padding partial chunks to match the offline pipeline's chunk count formula), then performs final clustering. This method produces byte-identical output to the offline `diarize()` method when given the same input audio.
+
+Call this method when the audio stream has ended to get the final diarization result.
+
+The operation runs on a worker thread and is non-blocking.
+
+**Returns:** `Promise<DiarizationResult>` — Final diarization result
+
+**Throws:**
+- `Error` if session is closed
+
+**Example:**
+```typescript
+const finalResult = await session.finalize();
+console.log(`Final result: ${finalResult.segments.length} segments`);
+```
+
+#### `close(): void`
+
+Releases all native resources associated with the streaming session. This method is idempotent and safe to call multiple times.
+
+**Example:**
+```typescript
+session.close();
+```
+
+#### `get isClosed: boolean`
+
+Indicates whether the session has been closed.
+
+**Returns:** `boolean` — `true` if the session is closed, `false` otherwise
+
+### Types
+
+#### `ModelConfig`
+
+Configuration object for loading diarization models.
+
+```typescript
+interface ModelConfig {
+  segModelPath: string;    // Path to segmentation GGUF model file
+  embModelPath: string;    // Path to embedding GGUF model file
+  pldaPath: string;        // Path to PLDA GGUF model file
+  coremlPath: string;      // Path to embedding CoreML .mlpackage directory
+  segCoremlPath: string;   // Path to segmentation CoreML .mlpackage directory
+}
+```
+
+#### `VADChunk`
+
+Voice activity detection result for a single 10-second audio chunk.
+
+```typescript
+interface VADChunk {
+  chunkIndex: number;      // Zero-based chunk number (increments every 1 second)
+  startTime: number;       // Absolute start time in seconds (chunkIndex * 1.0)
+  duration: number;        // Always 10.0 (chunk window size)
+  numFrames: number;       // Always 589 (segmentation model output frames)
+  vad: Float32Array;       // [589] frame-level voice activity: 1.0 if any speaker active, 0.0 otherwise
+}
+```
+
+The `vad` array contains 589 frames, each representing approximately 17ms of audio. A value of 1.0 indicates speech activity (any speaker), 0.0 indicates silence.
+
+#### `Segment`
+
+A contiguous speech segment with speaker label.
+
+```typescript
+interface Segment {
+  start: number;           // Start time in seconds
+  duration: number;        // Duration in seconds
+  speaker: string;         // Speaker label (e.g., "SPEAKER_00", "SPEAKER_01", ...)
+}
+```
+
+#### `DiarizationResult`
+
+Complete diarization output with speaker-labeled segments.
+
+```typescript
+interface DiarizationResult {
+  segments: Segment[];     // Array of segments, sorted by start time
+}
+```
+
+## Usage Examples
+
+### Example 1: Offline Diarization
+
+Process an entire audio file and print a timeline of speaker segments.
+
+```typescript
+import { Pyannote } from 'pyannote-cpp-node';
+import { readFileSync } from 'node:fs';
+
+// Helper to load 16-bit PCM WAV and convert to Float32Array
+function loadWavFile(filePath: string): Float32Array {
+  const buffer = readFileSync(filePath);
+  const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+
+  // Find data chunk
+  let offset = 12; // Skip RIFF header
+  while (offset < view.byteLength - 8) {
+    const chunkId = String.fromCharCode(
+      view.getUint8(offset),
+      view.getUint8(offset + 1),
+      view.getUint8(offset + 2),
+      view.getUint8(offset + 3)
+    );
+    const chunkSize = view.getUint32(offset + 4, true);
+    offset += 8;
+
+    if (chunkId === 'data') {
+      // Convert Int16 PCM to Float32 by dividing by 32768
+      const numSamples = chunkSize / 2;
+      const float32 = new Float32Array(numSamples);
+      for (let i = 0; i < numSamples; i++) {
+        float32[i] = view.getInt16(offset + i * 2, true) / 32768.0;
+      }
+      return float32;
+    }
+
+    offset += chunkSize;
+    if (chunkSize % 2 !== 0) offset++; // Align to word boundary
+  }
+
+  throw new Error('No data chunk found in WAV file');
+}
+
+async function main() {
+  // Load model
+  const model = await Pyannote.load({
+    segModelPath: './models/segmentation.gguf',
+    embModelPath: './models/embedding.gguf',
+    pldaPath: './models/plda.gguf',
+    coremlPath: './models/embedding.mlpackage',
+    segCoremlPath: './models/segmentation.mlpackage',
+  });
+
+  // Load audio
+  const audio = loadWavFile('./audio.wav');
+  console.log(`Loaded ${audio.length} samples (${(audio.length / 16000).toFixed(1)}s)`);
+
+  // Diarize
+  const result = await model.diarize(audio);
+
+  // Print timeline
+  console.log(`\nDetected ${result.segments.length} segments:`);
+  for (const segment of result.segments) {
+    const startTime = segment.start.toFixed(2);
+    const endTime = (segment.start + segment.duration).toFixed(2);
+    console.log(`[${startTime}s - ${endTime}s] ${segment.speaker}`);
+  }
+
+  // Count speakers
+  const speakers = new Set(result.segments.map(s => s.speaker));
+  console.log(`\nTotal speakers: ${speakers.size}`);
+
+  model.close();
+}
+
+main();
+```
+
+### Example 2: Streaming Diarization
+
+Process audio incrementally in 1-second chunks, displaying real-time VAD.
+
+```typescript
+import { Pyannote } from 'pyannote-cpp-node';
+
+async function streamingDiarization() {
+  const model = await Pyannote.load({
+    segModelPath: './models/segmentation.gguf',
+    embModelPath: './models/embedding.gguf',
+    pldaPath: './models/plda.gguf',
+    coremlPath: './models/embedding.mlpackage',
+    segCoremlPath: './models/segmentation.mlpackage',
+  });
+
+  const session = model.createStreamingSession();
+
+  // Load full audio file
+  const audio = loadWavFile('./audio.wav');
+
+  // Push audio in 1-second chunks (16,000 samples)
+  const CHUNK_SIZE = 16000;
+  let totalChunks = 0;
+
+  for (let offset = 0; offset < audio.length; offset += CHUNK_SIZE) {
+    const end = Math.min(offset + CHUNK_SIZE, audio.length);
+    const chunk = audio.slice(offset, end);
+
+    const vadChunks = await session.push(chunk);
+
+    // VAD chunks are returned after first 10 seconds
+    for (const vad of vadChunks) {
+      // Count active frames (speech detected)
+      const activeFrames = vad.vad.filter(v => v > 0.5).length;
+      const speechRatio = (activeFrames / vad.numFrames * 100).toFixed(1);
+      
+      console.log(
+        `Chunk ${vad.chunkIndex}: ${vad.startTime.toFixed(1)}s - ${(vad.startTime + vad.duration).toFixed(1)}s | ` +
+        `Speech: ${speechRatio}%`
+      );
+      totalChunks++;
+    }
+  }
+
+  console.log(`\nProcessed ${totalChunks} chunks`);
+
+  // Get final diarization result
+  console.log('\nFinalizing...');
+  const result = await session.finalize();
+
+  console.log(`\nFinal result: ${result.segments.length} segments`);
+  for (const segment of result.segments) {
+    console.log(
+      `[${segment.start.toFixed(2)}s - ${(segment.start + segment.duration).toFixed(2)}s] ${segment.speaker}`
+    );
+  }
+
+  session.close();
+  model.close();
+}
+
+streamingDiarization();
+```
+
+### Example 3: On-Demand Reclustering
+
+Push audio and trigger reclustering every 30 seconds to get intermediate results.
+
+```typescript
+import { Pyannote } from 'pyannote-cpp-node';
+
+async function reclusteringExample() {
+  const model = await Pyannote.load({
+    segModelPath: './models/segmentation.gguf',
+    embModelPath: './models/embedding.gguf',
+    pldaPath: './models/plda.gguf',
+    coremlPath: './models/embedding.mlpackage',
+    segCoremlPath: './models/segmentation.mlpackage',
+  });
+
+  const session = model.createStreamingSession();
+  const audio = loadWavFile('./audio.wav');
+
+  const CHUNK_SIZE = 16000; // 1 second
+  const RECLUSTER_INTERVAL = 30; // Recluster every 30 seconds
+
+  let secondsProcessed = 0;
+
+  for (let offset = 0; offset < audio.length; offset += CHUNK_SIZE) {
+    const end = Math.min(offset + CHUNK_SIZE, audio.length);
+    const chunk = audio.slice(offset, end);
+
+    await session.push(chunk);
+    secondsProcessed++;
+
+    // Recluster every 30 seconds
+    if (secondsProcessed % RECLUSTER_INTERVAL === 0) {
+      console.log(`\n--- Reclustering at ${secondsProcessed}s ---`);
+      const intermediateResult = await session.recluster();
+      
+      const speakers = new Set(intermediateResult.segments.map(s => s.speaker));
+      console.log(`Current speakers detected: ${speakers.size}`);
+      console.log(`Current segments: ${intermediateResult.segments.length}`);
+    }
+  }
+
+  // Final result
+  console.log('\n--- Final result ---');
+  const finalResult = await session.finalize();
+  const speakers = new Set(finalResult.segments.map(s => s.speaker));
+  console.log(`Total speakers: ${speakers.size}`);
+  console.log(`Total segments: ${finalResult.segments.length}`);
+
+  session.close();
+  model.close();
+}
+
+reclusteringExample();
+```
+
+### Example 4: Generating RTTM Output
+
+Format diarization results into standard RTTM (Rich Transcription Time Marked) format.
+
+```typescript
+import { Pyannote, type DiarizationResult } from 'pyannote-cpp-node';
+import { writeFileSync } from 'node:fs';
+
+function toRTTM(result: DiarizationResult, filename: string = 'audio'): string {
+  const lines = result.segments.map(segment => {
+    // RTTM format: SPEAKER <file> <chnl> <tbeg> <tdur> <ortho> <stype> <name> <conf> <slat>
+    return [
+      'SPEAKER',
+      filename,
+      '1',
+      segment.start.toFixed(3),
+      segment.duration.toFixed(3),
+      '<NA>',
+      '<NA>',
+      segment.speaker,
+      '<NA>',
+      '<NA>',
+    ].join(' ');
+  });
+
+  return lines.join('\n') + '\n';
+}
+
+async function generateRTTM() {
+  const model = await Pyannote.load({
+    segModelPath: './models/segmentation.gguf',
+    embModelPath: './models/embedding.gguf',
+    pldaPath: './models/plda.gguf',
+    coremlPath: './models/embedding.mlpackage',
+    segCoremlPath: './models/segmentation.mlpackage',
+  });
+
+  const audio = loadWavFile('./audio.wav');
+  const result = await model.diarize(audio);
+
+  // Generate RTTM
+  const rttm = toRTTM(result, 'audio');
+  
+  // Write to file
+  writeFileSync('./output.rttm', rttm);
+  console.log('RTTM file written to output.rttm');
+
+  // Also print to console
+  console.log('\nRTTM output:');
+  console.log(rttm);
+
+  model.close();
+}
+
+generateRTTM();
+```
+
+## Architecture
+
+The diarization pipeline consists of four main stages:
+
+### 1. Segmentation (SincNet + BiLSTM)
+
+The segmentation model processes 10-second audio windows and outputs 7-class powerset logits for 589 frames (approximately one frame every 17ms). The model architecture:
+
+- **SincNet**: Learnable sinc filter bank for feature extraction
+- **4-layer BiLSTM**: Bidirectional long short-term memory layers
+- **Linear classifier**: Projects to 7 powerset classes with log-softmax
+
+The 7 powerset classes represent all possible combinations of up to 3 simultaneous speakers:
+- Class 0: silence (no speakers)
+- Classes 1-3: single speakers
+- Classes 4-6: speaker overlaps
+
+### 2. Powerset Decoding
+
+Converts the 7-class powerset predictions into binary speaker activity for 3 local speakers per chunk. Each frame is decoded to indicate which of the 3 local speaker "slots" are active.
+
+### 3. Embedding Extraction (WeSpeaker ResNet34)
+
+For each active speaker in each chunk, the embedding model extracts a 256-dimensional speaker vector:
+
+- **Mel filterbank**: 80-bin log-mel spectrogram features
+- **ResNet34**: Deep residual network for speaker representation
+- **Output**: 256-dimensional L2-normalized embedding
+
+Silent speakers receive NaN embeddings, which are filtered before clustering.
+
+### 4. Clustering (PLDA + AHC + VBx)
+
+The final stage maps local speaker labels to global speaker identities:
+
+- **PLDA transformation**: Probabilistic Linear Discriminant Analysis projects embeddings from 256 to 128 dimensions
+- **Agglomerative Hierarchical Clustering (AHC)**: fastcluster implementation with O(n²) complexity, using centroid linkage and a distance threshold of 0.6
+- **VBx refinement**: Variational Bayes diarization with parameters FA=0.07, FB=0.8, maximum 20 iterations
+
+The clustering stage computes speaker centroids and assigns each embedding to the closest centroid while respecting the constraint that two local speakers in the same chunk cannot map to the same global speaker.
+
+### CoreML Acceleration
+
+Both neural networks run on Apple's CoreML framework, which automatically distributes computation across:
+
+- **Neural Engine**: Dedicated ML accelerator on Apple Silicon
+- **GPU**: Metal-accelerated operations
+- **CPU**: Fallback for unsupported operations
+
+CoreML models use Float16 computation for optimal performance while maintaining accuracy within acceptable bounds (cosine similarity > 0.999 vs Float32).
+
+### Streaming Architecture
+
+The streaming API uses a sliding 10-second window with a 1-second hop (9 seconds of overlap between consecutive chunks). Three data stores maintain the state:
+
+- **`audio_buffer`**: Sliding window (~10s, ~640 KB for 1 hour) — old samples are discarded
+- **`embeddings`**: Grows forever (~11 MB for 1 hour) — stores 3 × 256-dim vectors per chunk (NaN for silent speakers)
+- **`binarized`**: Grows forever (~25 MB for 1 hour) — stores 589 × 3 binary activity masks per chunk
+
+During reclustering, all accumulated embeddings are used to compute soft cluster assignments, and all binarized segmentations are used to reconstruct the global timeline. This is why the `embeddings` and `binarized` arrays must persist for the entire session.
+
+### Constants
+
+| Constant | Value | Description |
+|----------|-------|-------------|
+| SAMPLE_RATE | 16000 Hz | Audio sample rate |
+| CHUNK_SAMPLES | 160000 | 10-second window size |
+| STEP_SAMPLES | 16000 | 1-second hop between chunks |
+| FRAMES_PER_CHUNK | 589 | Segmentation output frames |
+| NUM_LOCAL_SPEAKERS | 3 | Maximum speakers per chunk |
+| EMBEDDING_DIM | 256 | Speaker embedding dimension |
+| FBANK_NUM_BINS | 80 | Mel filterbank bins |
+
+## Audio Format Requirements
+
+The library expects raw PCM audio in a specific format:
+
+- **Sample rate**: 16000 Hz (16 kHz) — **required**
+- **Channels**: Mono (single channel) — **required**
+- **Format**: `Float32Array` with values in the range **[-1.0, 1.0]**
+
+The library does **not** handle audio decoding. You must provide raw PCM samples.
+
+### Loading Audio Files
+
+For WAV files, you can use the `loadWavFile` function from Example 1, or use third-party libraries:
+
+```bash
+npm install node-wav
+```
+
+```typescript
+import { read } from 'node-wav';
+import { readFileSync } from 'node:fs';
+
+const buffer = readFileSync('./audio.wav');
+const wav = read(buffer);
+
+// Convert to mono if stereo
+const mono = wav.channelData.length > 1
+  ? wav.channelData[0].map((v, i) => (v + wav.channelData[1][i]) / 2)
+  : wav.channelData[0];
+
+// Resample to 16kHz if needed (using a resampling library)
+// ...
+
+const audio = new Float32Array(mono);
+```
+
+For other audio formats (MP3, M4A, etc.), use ffmpeg to convert to 16kHz mono WAV first:
+
+```bash
+ffmpeg -i input.mp3 -ar 16000 -ac 1 -f f32le -acodec pcm_f32le - | \
+  node process.js
+```
+
+## Important Notes and Caveats
+
+### Platform Limitations
+
+- **macOS only**: The library requires CoreML for neural network inference. There is currently no fallback implementation for other platforms.
+- **No Linux/Windows support**: CoreML is exclusive to Apple platforms.
+
+### `recluster()` Mutates State
+
+The `recluster()` method overwrites the internal session state, specifically replacing the `embeddings` and chunk index arrays with filtered versions (excluding NaN embeddings from silent speakers). This means:
+
+- Calling `push()` after `recluster()` may produce incorrect results
+- Subsequent `recluster()` calls may not work as expected
+- The data structure assumes the original unfiltered layout (3 embeddings per chunk)
+
+**Best practice**: Use `recluster()` sparingly for live progress updates (e.g., every 30 seconds), or avoid it entirely and only call `finalize()` when the stream ends.
+
+### Operations Are Serialized
+
+Operations on a streaming session are serialized internally. Do not call `push()` while another `push()`, `recluster()`, or `finalize()` is in progress. Wait for the Promise to resolve before making the next call.
+
+### Resource Management
+
+- **Close sessions before models**: Always close streaming sessions before closing the parent model
+- **Idempotent close**: Both `model.close()` and `session.close()` are safe to call multiple times
+- **No reuse after close**: Once closed, models and sessions cannot be reused
+
+### Model Loading
+
+- **Path validation**: `Pyannote.load()` validates that all paths exist using `fs.accessSync()` before initialization
+- **CoreML compilation**: The CoreML framework compiles `.mlpackage` models internally on first load (typically fast, ~100ms)
+- **No explicit loading step**: Model weights are loaded synchronously in the constructor
+
+### Threading Model
+
+All heavy operations (`diarize`, `push`, `recluster`, `finalize`) run on libuv worker threads and never block the Node.js event loop. However, the operations do hold native locks internally, so concurrent operations on the same session are serialized.
+
+### Memory Usage
+
+For a 1-hour audio file:
+- `audio_buffer`: ~640 KB (sliding window)
+- `embeddings`: ~11 MB (grows throughout session)
+- `binarized`: ~25 MB (grows throughout session)
+- CoreML models: ~50 MB (loaded once per model)
+
+Total memory footprint: approximately 100 MB for a 1-hour streaming session.
+
+## Performance
+
+Measured on Apple M2 Pro with 16 GB RAM:
+
+| Component | Time per Chunk | Notes |
+|-----------|----------------|-------|
+| Segmentation (CoreML) | ~12ms | 10-second audio window, 589 frames |
+| Embedding (CoreML) | ~13ms | Per speaker per chunk (up to 3 speakers) |
+| AHC Clustering | ~0.8s | 3000 embeddings (1000 chunks) |
+| VBx Refinement | ~1.2s | 20 iterations, 3000 embeddings |
+| **Full Pipeline (offline)** | **39x real-time** | 45-minute audio processed in 70 seconds |
+
+### Streaming Performance
+
+- **First chunk latency**: 10 seconds (requires full window)
+- **Incremental latency**: ~30ms per 1-second push (after first chunk)
+- **Recluster latency**: ~2 seconds for 30 minutes of audio (~1800 embeddings)
+
+Streaming mode has higher per-chunk overhead due to the incremental nature but enables real-time applications.
+
+## Supported Platforms
+
+| Platform | Architecture | Status |
+|----------|--------------|--------|
+| macOS | arm64 (Apple Silicon) | ✅ Supported |
+| macOS | x64 (Intel) | 🔜 Planned |
+| Linux | any | ❌ Not supported (CoreML unavailable) |
+| Windows | any | ❌ Not supported (CoreML unavailable) |
+
+Intel macOS support is planned but not yet available. The CoreML dependency makes cross-platform support challenging without alternative inference backends.
+
+## License
+
+MIT
+
+---
+
+For issues, feature requests, or contributions, please visit the [GitHub repository](https://github.com/predict-woo/pyannote-ggml).

package/dist/Pyannote.d.ts

@@ -0,0 +1,12 @@
+import { StreamingSession } from './StreamingSession.js';
+import type { DiarizationResult, ModelConfig } from './types.js';
+export declare class Pyannote {
+    private native;
+    private constructor();
+    static load(config: ModelConfig): Promise<Pyannote>;
+    diarize(audio: Float32Array): Promise<DiarizationResult>;
+    createStreamingSession(): StreamingSession;
+    close(): void;
+    get isClosed(): boolean;
+}
+//# sourceMappingURL=Pyannote.d.ts.map

package/dist/Pyannote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Pyannote.d.ts","sourceRoot":"","sources":["../src/Pyannote.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEjE,qBAAa,QAAQ;IACnB,OAAO,CAAC,MAAM,CAAsB;IAEpC,OAAO;WAIM,IAAI,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IAkBnD,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAa9D,sBAAsB,IAAI,gBAAgB;IAQ1C,KAAK,IAAI,IAAI;IAIb,IAAI,QAAQ,IAAI,OAAO,CAEtB;CACF"}

package/dist/Pyannote.js

@@ -0,0 +1,50 @@
+import { accessSync } from 'node:fs';
+import { getBinding } from './binding.js';
+import { StreamingSession } from './StreamingSession.js';
+export class Pyannote {
+    native;
+    constructor(native) {
+        this.native = native;
+    }
+    static async load(config) {
+        const paths = [
+            config.segModelPath,
+            config.embModelPath,
+            config.pldaPath,
+            config.coremlPath,
+            config.segCoremlPath,
+        ];
+        for (const path of paths) {
+            accessSync(path);
+        }
+        const binding = getBinding();
+        const native = new binding.PyannoteModel(config);
+        return new Pyannote(native);
+    }
+    async diarize(audio) {
+        if (this.native.isClosed) {
+            throw new Error('Model is closed');
+        }
+        if (!(audio instanceof Float32Array)) {
+            throw new TypeError('Expected Float32Array');
+        }
+        if (audio.length === 0) {
+            throw new Error('Audio must not be empty');
+        }
+        return this.native.diarize(audio);
+    }
+    createStreamingSession() {
+        if (this.native.isClosed) {
+            throw new Error('Model is closed');
+        }
+        const nativeSession = this.native.createStreamingSession();
+        return new StreamingSession(nativeSession);
+    }
+    close() {
+        this.native.close();
+    }
+    get isClosed() {
+        return this.native.isClosed;
+    }
+}
+//# sourceMappingURL=Pyannote.js.map

package/dist/Pyannote.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Pyannote.js","sourceRoot":"","sources":["../src/Pyannote.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErC,OAAO,EAAE,UAAU,EAA4B,MAAM,cAAc,CAAC;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAGzD,MAAM,OAAO,QAAQ;IACX,MAAM,CAAsB;IAEpC,YAAoB,MAA2B;QAC7C,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,MAAmB;QACnC,MAAM,KAAK,GAAG;YACZ,MAAM,CAAC,YAAY;YACnB,MAAM,CAAC,YAAY;YACnB,MAAM,CAAC,QAAQ;YACf,MAAM,CAAC,UAAU;YACjB,MAAM,CAAC,aAAa;SACrB,CAAC;QAEF,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,UAAU,CAAC,IAAI,CAAC,CAAC;QACnB,CAAC;QAED,MAAM,OAAO,GAAG,UAAU,EAAE,CAAC;QAC7B,MAAM,MAAM,GAAG,IAAI,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;QACjD,OAAO,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC9B,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,KAAmB;QAC/B,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YACzB,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;QACrC,CAAC;QACD,IAAI,CAAC,CAAC,KAAK,YAAY,YAAY,CAAC,EAAE,CAAC;YACrC,MAAM,IAAI,SAAS,CAAC,uBAAuB,CAAC,CAAC;QAC/C,CAAC;QACD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvB,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;QAC7C,CAAC;QACD,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACpC,CAAC;IAED,sBAAsB;QACpB,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YACzB,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;QACrC,CAAC;QACD,MAAM,aAAa,GAAG,IAAI,CAAC,MAAM,CAAC,sBAAsB,EAAE,CAAC;QAC3D,OAAO,IAAI,gBAAgB,CAAC,aAAa,CAAC,CAAC;IAC7C,CAAC;IAED,KAAK;QACH,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;IACtB,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC;IAC9B,CAAC;CACF"}

package/dist/StreamingSession.d.ts

@@ -0,0 +1,12 @@
+import type { NativeStreamingSession } from './binding.js';
+import type { DiarizationResult, VADChunk } from './types.js';
+export declare class StreamingSession {
+    private native;
+    constructor(native: NativeStreamingSession);
+    push(audio: Float32Array): Promise<VADChunk[]>;
+    recluster(): Promise<DiarizationResult>;
+    finalize(): Promise<DiarizationResult>;
+    close(): void;
+    get isClosed(): boolean;
+}
+//# sourceMappingURL=StreamingSession.d.ts.map

package/dist/StreamingSession.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StreamingSession.d.ts","sourceRoot":"","sources":["../src/StreamingSession.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE9D,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAyB;gBAE3B,MAAM,EAAE,sBAAsB;IAIpC,IAAI,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;IAU9C,SAAS,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAOvC,QAAQ,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAO5C,KAAK,IAAI,IAAI;IAIb,IAAI,QAAQ,IAAI,OAAO,CAEtB;CACF"}

package/dist/StreamingSession.js

@@ -0,0 +1,34 @@
+export class StreamingSession {
+    native;
+    constructor(native) {
+        this.native = native;
+    }
+    async push(audio) {
+        if (this.native.isClosed) {
+            throw new Error('Session is closed');
+        }
+        if (!(audio instanceof Float32Array)) {
+            throw new TypeError('Expected Float32Array');
+        }
+        return this.native.push(audio);
+    }
+    async recluster() {
+        if (this.native.isClosed) {
+            throw new Error('Session is closed');
+        }
+        return this.native.recluster();
+    }
+    async finalize() {
+        if (this.native.isClosed) {
+            throw new Error('Session is closed');
+        }
+        return this.native.finalize();
+    }
+    close() {
+        this.native.close();
+    }
+    get isClosed() {
+        return this.native.isClosed;
+    }
+}
+//# sourceMappingURL=StreamingSession.js.map

package/dist/StreamingSession.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StreamingSession.js","sourceRoot":"","sources":["../src/StreamingSession.ts"],"names":[],"mappings":"AAGA,MAAM,OAAO,gBAAgB;IACnB,MAAM,CAAyB;IAEvC,YAAY,MAA8B;QACxC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,KAAmB;QAC5B,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YACzB,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC;QACvC,CAAC;QACD,IAAI,CAAC,CAAC,KAAK,YAAY,YAAY,CAAC,EAAE,CAAC;YACrC,MAAM,IAAI,SAAS,CAAC,uBAAuB,CAAC,CAAC;QAC/C,CAAC;QACD,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;IAED,KAAK,CAAC,SAAS;QACb,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YACzB,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC;QACvC,CAAC;QACD,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;IACjC,CAAC;IAED,KAAK,CAAC,QAAQ;QACZ,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YACzB,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC;QACvC,CAAC;QACD,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;IAChC,CAAC;IAED,KAAK;QACH,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;IACtB,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC;IAC9B,CAAC;CACF"}

package/dist/binding.d.ts

@@ -0,0 +1,20 @@
+import type { DiarizationResult, ModelConfig, VADChunk } from './types.js';
+export interface NativePyannoteModel {
+    diarize(audio: Float32Array): Promise<DiarizationResult>;
+    createStreamingSession(): NativeStreamingSession;
+    close(): void;
+    isClosed: boolean;
+}
+export interface NativeStreamingSession {
+    push(audio: Float32Array): Promise<VADChunk[]>;
+    recluster(): Promise<DiarizationResult>;
+    finalize(): Promise<DiarizationResult>;
+    close(): void;
+    isClosed: boolean;
+}
+export interface NativeBinding {
+    PyannoteModel: new (config: ModelConfig) => NativePyannoteModel;
+    StreamingSession: new (...args: unknown[]) => NativeStreamingSession;
+}
+export declare function getBinding(): NativeBinding;
+//# sourceMappingURL=binding.d.ts.map

package/dist/binding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding.d.ts","sourceRoot":"","sources":["../src/binding.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAI3E,MAAM,WAAW,mBAAmB;IAClC,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACzD,sBAAsB,IAAI,sBAAsB,CAAC;IACjD,KAAK,IAAI,IAAI,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,sBAAsB;IACrC,IAAI,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC/C,SAAS,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACxC,QAAQ,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACvC,KAAK,IAAI,IAAI,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,aAAa;IAC5B,aAAa,EAAE,KAAK,MAAM,EAAE,WAAW,KAAK,mBAAmB,CAAC;IAChE,gBAAgB,EAAE,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,sBAAsB,CAAC;CACtE;AAoCD,wBAAgB,UAAU,IAAI,aAAa,CAyB1C"}

package/dist/binding.js

@@ -0,0 +1,43 @@
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+let cachedBinding = null;
+function getPackageName() {
+    if (process.platform !== 'darwin') {
+        throw new Error(`Unsupported platform: ${process.platform}. pyannote-cpp-node currently supports macOS only.`);
+    }
+    if (process.arch === 'arm64') {
+        return '@pyannote-cpp-node/darwin-arm64';
+    }
+    if (process.arch === 'x64') {
+        return '@pyannote-cpp-node/darwin-x64';
+    }
+    throw new Error(`Unsupported architecture on macOS: ${process.arch}. Supported architectures are arm64 and x64.`);
+}
+function isNativeBinding(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.PyannoteModel === 'function' &&
+        typeof candidate.StreamingSession === 'function');
+}
+export function getBinding() {
+    if (cachedBinding !== null) {
+        return cachedBinding;
+    }
+    const packageName = getPackageName();
+    let loaded;
+    try {
+        loaded = require(packageName);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to load native module '${packageName}'. Ensure the platform package is installed. Original error: ${message}`);
+    }
+    if (!isNativeBinding(loaded)) {
+        throw new Error(`Invalid native module export from '${packageName}'. Expected PyannoteModel and StreamingSession constructors.`);
+    }
+    cachedBinding = loaded;
+    return cachedBinding;
+}
+//# sourceMappingURL=binding.js.map

package/dist/binding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding.js","sourceRoot":"","sources":["../src/binding.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAIvC,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAsB/C,IAAI,aAAa,GAAyB,IAAI,CAAC;AAE/C,SAAS,cAAc;IACrB,IAAI,OAAO,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;QAClC,MAAM,IAAI,KAAK,CACb,yBAAyB,OAAO,CAAC,QAAQ,oDAAoD,CAC9F,CAAC;IACJ,CAAC;IAED,IAAI,OAAO,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QAC7B,OAAO,iCAAiC,CAAC;IAC3C,CAAC;IAED,IAAI,OAAO,CAAC,IAAI,KAAK,KAAK,EAAE,CAAC;QAC3B,OAAO,+BAA+B,CAAC;IACzC,CAAC;IAED,MAAM,IAAI,KAAK,CACb,sCAAsC,OAAO,CAAC,IAAI,8CAA8C,CACjG,CAAC;AACJ,CAAC;AAED,SAAS,eAAe,CAAC,KAAc;IACrC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAChD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,SAAS,GAAG,KAAgC,CAAC;IACnD,OAAO,CACL,OAAO,SAAS,CAAC,aAAa,KAAK,UAAU;QAC7C,OAAO,SAAS,CAAC,gBAAgB,KAAK,UAAU,CACjD,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,UAAU;IACxB,IAAI,aAAa,KAAK,IAAI,EAAE,CAAC;QAC3B,OAAO,aAAa,CAAC;IACvB,CAAC;IAED,MAAM,WAAW,GAAG,cAAc,EAAE,CAAC;IAErC,IAAI,MAAe,CAAC;IACpB,IAAI,CAAC;QACH,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IAChC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACvE,MAAM,IAAI,KAAK,CACb,iCAAiC,WAAW,gEAAgE,OAAO,EAAE,CACtH,CAAC;IACJ,CAAC;IAED,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CACb,sCAAsC,WAAW,8DAA8D,CAChH,CAAC;IACJ,CAAC;IAED,aAAa,GAAG,MAAM,CAAC;IACvB,OAAO,aAAa,CAAC;AACvB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { Pyannote } from './Pyannote.js';
+export { StreamingSession } from './StreamingSession.js';
+export type { DiarizationResult, ModelConfig, Segment, VADChunk, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,YAAY,EACV,iBAAiB,EACjB,WAAW,EACX,OAAO,EACP,QAAQ,GACT,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { Pyannote } from './Pyannote.js';
+export { StreamingSession } from './StreamingSession.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,23 @@
+export interface ModelConfig {
+    segModelPath: string;
+    embModelPath: string;
+    pldaPath: string;
+    coremlPath: string;
+    segCoremlPath: string;
+}
+export interface VADChunk {
+    chunkIndex: number;
+    startTime: number;
+    duration: number;
+    numFrames: number;
+    vad: Float32Array;
+}
+export interface Segment {
+    start: number;
+    duration: number;
+    speaker: string;
+}
+export interface DiarizationResult {
+    segments: Segment[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,QAAQ;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,YAAY,CAAC;CACnB;AAED,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "pyannote-cpp-node",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/**/*.js.map",
+    "dist/**/*.d.ts.map"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "optionalDependencies": {
+    "@pyannote-cpp-node/darwin-arm64": "0.1.0",
+    "@pyannote-cpp-node/darwin-x64": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run"
+  }
+}