@kuralle-syrinx/vap 4.2.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Kuralle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,50 @@
+# @kuralle-syrinx/vap
+
+Voice Activity Projection (`VapInteractionPolicy`) for Syrinx turn-taking behind the interaction-policy seam.
+
+## Predictors
+
+| Class | Runtime | Model source |
+|-------|---------|--------------|
+| `StubVapPredictor` | Any | Deterministic placeholder for tests and integration without a checkpoint |
+| `LocalVapPredictor` | Node (`onnxruntime-node`) | DualTurn bundle at `bundle_path` / `model_path` or `packages/vap/models/dualturn` |
+| `WorkersVapPredictor` | Workers (`onnxruntime-web`) | `model_bytes` or `model_url` config |
+
+## Local DualTurn bundle
+
+Build the bundle remotely with:
+
+```bash
+modal run scripts/modal/export_dualturn_bundle.py
+```
+
+The script persists weights in the `syrinx-vap-models` Modal Volume. A local bundle directory contains:
+
+- `manifest.json` and `NOTICE.md`
+- Continuous Mimi ONNX + metadata (MAAI Kyoto, CC-BY-4.0; attribution in `NOTICE.md`)
+- DualTurn projection and all turn heads exported from its Apache-2.0 safetensors
+- a patched DualTurn Qwen backbone that consumes `inputs_embeds`, plus its external data file
+
+The published DualTurn ONNX is only the Qwen backbone. Its upstream example accepts an `embeds` argument but
+still feeds token IDs, so it is not audio-dependent as written. The Modal export replaces the embedding lookup
+with a real `inputs_embeds` graph input before the bundle is accepted.
+
+## Async/sync split
+
+`observe()` stays synchronous: it snapshots PCM and serializes `push(frame)` calls per `contextId`, while reading
+the latest cached probabilities. `LocalVapPredictor` owns per-context Mimi and Qwen causal state. User audio is
+channel 0 and assistant PCM attached to `playout_tick` is channel 1. Decisions may lag inference by one frame.
+Pass `semanticTranscriptFusion` as `fuseTranscript` to arm the C6 VAP+STT policy variant; transcript state is
+scoped and reset with the same `contextId` as predictor state.
+
+## Model sourcing status
+
+No model weights are committed. Use `StubVapPredictor` until the attributed bundle is exported and made available
+at the configured path. The Node predictor maps `max(user EOT, user BOT)` to `pShift`, user BC to
+`pBackchannel`, and user HOLD to `pHold`.
+
+## Ring-buffer invariant
+
+`RollingFeatureBuffer` writes through a ring cursor and exposes only chronological copies via `snapshot()`.
+The policy also copies every predictor frame before enqueueing it. Async inference therefore never observes a
+typed-array view being mutated by a later audio frame.

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@kuralle-syrinx/vap",
+  "version": "4.2.0",
+  "private": false,
+  "description": "Voice Activity Projection interaction policy for Syrinx — ONNX turn-taking for Node and Workers",
+  "keywords": [
+    "voice",
+    "voice-agent",
+    "speech",
+    "syrinx",
+    "vap",
+    "turn-taking",
+    "onnx"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/kuralle/syrinx#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kuralle/syrinx.git",
+    "directory": "packages/vap"
+  },
+  "bugs": {
+    "url": "https://github.com/kuralle/syrinx/issues"
+  },
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./workers": "./src/workers.ts"
+  },
+  "dependencies": {
+    "onnxruntime-node": "1.24.3",
+    "onnxruntime-web": "1.24.3",
+    "@kuralle-syrinx/core": "4.2.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.0"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}

package/src/dualturn-predictor.ts

@@ -0,0 +1,448 @@
+// SPDX-License-Identifier: MIT
+
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { StreamingPcm16Resampler, optionalStringConfig, type PluginConfig } from "@kuralle-syrinx/core";
+import {
+  ZERO_VAP_PROBS,
+  type VapPredictor,
+  type VapPredictorFrame,
+  type VapProbs,
+} from "./vap-policy.js";
+
+type Ort = typeof import("onnxruntime-node");
+type InferenceSession = import("onnxruntime-node").InferenceSession;
+type Tensor = import("onnxruntime-node").Tensor;
+
+const DEFAULT_BUNDLE_PATH = fileURLToPath(new URL("../models/dualturn", import.meta.url));
+const MODEL_SAMPLE_RATE_HZ = 24_000;
+const MODEL_WINDOW_SAMPLES = 1_920;
+const QUEUE_CAPACITY_SAMPLES = MODEL_SAMPLE_RATE_HZ * 2;
+
+interface DualTurnManifest {
+  readonly format: "syrinx.dualturn.onnx.v1";
+  readonly context_frames: number;
+  readonly files: {
+    readonly mimi_model: string;
+    readonly mimi_metadata: string;
+    readonly projection: string;
+    readonly backbone: string;
+    readonly heads: string;
+  };
+}
+
+interface MimiMetadata {
+  readonly cache_position_len: number;
+  readonly max_past_len: number;
+  readonly contract: {
+    readonly spec: {
+      readonly padding_cache_shapes: readonly (readonly number[])[];
+      readonly past_key_value_shapes: readonly (readonly number[])[];
+    };
+  };
+}
+
+interface MimiStreamState {
+  cachePosition: number;
+  position: number;
+  states: Tensor[];
+}
+
+interface DualTurnContext {
+  readonly queues: Record<VapPredictorFrame["channel"], PcmSampleQueue>;
+  readonly resamplers: Map<string, StreamingPcm16Resampler>;
+  readonly mimi: Record<VapPredictorFrame["channel"], MimiStreamState>;
+  backbonePast: Tensor[];
+  backbonePosition: number;
+  probs: VapProbs;
+}
+
+export class LocalVapPredictor implements VapPredictor {
+  private ort: Ort | null = null;
+  private mimiSession: InferenceSession | null = null;
+  private projectionSession: InferenceSession | null = null;
+  private backboneSession: InferenceSession | null = null;
+  private headsSession: InferenceSession | null = null;
+  private manifest: DualTurnManifest | null = null;
+  private mimiMetadata: MimiMetadata | null = null;
+  private readonly contexts = new Map<string, DualTurnContext>();
+
+  async initialize(cfg: PluginConfig = {}): Promise<void> {
+    const bundlePath = optionalStringConfig(cfg, "bundle_path")
+      ?? optionalStringConfig(cfg, "model_path")
+      ?? DEFAULT_BUNDLE_PATH;
+    const manifest = parseManifest(await readJson(join(bundlePath, "manifest.json")));
+    const mimiMetadata = parseMimiMetadata(
+      await readJson(join(bundlePath, manifest.files.mimi_metadata)),
+    );
+    const ort = await import("onnxruntime-node");
+    const options = {
+      executionProviders: ["cpu"] as const,
+      interOpNumThreads: 1,
+      intraOpNumThreads: 1,
+    };
+    const [mimiSession, projectionSession, backboneSession, headsSession] = await Promise.all([
+      ort.InferenceSession.create(join(bundlePath, manifest.files.mimi_model), options),
+      ort.InferenceSession.create(join(bundlePath, manifest.files.projection), options),
+      ort.InferenceSession.create(join(bundlePath, manifest.files.backbone), options),
+      ort.InferenceSession.create(join(bundlePath, manifest.files.heads), options),
+    ]);
+    this.ort = ort;
+    this.manifest = manifest;
+    this.mimiMetadata = mimiMetadata;
+    this.mimiSession = mimiSession;
+    this.projectionSession = projectionSession;
+    this.backboneSession = backboneSession;
+    this.headsSession = headsSession;
+  }
+
+  async push(frame: VapPredictorFrame): Promise<VapProbs> {
+    this.assertInitialized();
+    const context = this.contextFor(frame.contextId);
+    const resampled = this.resample(context, frame);
+    context.queues[frame.channel].append(resampled);
+
+    while (this.hasReadyWindow(context)) {
+      const user = context.queues.user.length >= MODEL_WINDOW_SAMPLES
+        ? context.queues.user.drainNormalized(MODEL_WINDOW_SAMPLES)
+        : new Float32Array(MODEL_WINDOW_SAMPLES);
+      const assistant = context.queues.assistant.length >= MODEL_WINDOW_SAMPLES
+        ? context.queues.assistant.drainNormalized(MODEL_WINDOW_SAMPLES)
+        : new Float32Array(MODEL_WINDOW_SAMPLES);
+      context.probs = await this.inferWindow(context, user, assistant);
+    }
+    return context.probs;
+  }
+
+  reset(contextId: string): void {
+    this.contexts.delete(contextId);
+  }
+
+  async close(): Promise<void> {
+    this.contexts.clear();
+    this.mimiSession = null;
+    this.projectionSession = null;
+    this.backboneSession = null;
+    this.headsSession = null;
+    this.mimiMetadata = null;
+    this.manifest = null;
+    this.ort = null;
+  }
+
+  private contextFor(contextId: string): DualTurnContext {
+    let context = this.contexts.get(contextId);
+    if (!context) {
+      context = {
+        queues: {
+          user: new PcmSampleQueue(QUEUE_CAPACITY_SAMPLES),
+          assistant: new PcmSampleQueue(QUEUE_CAPACITY_SAMPLES),
+        },
+        resamplers: new Map(),
+        mimi: {
+          user: this.newMimiState(),
+          assistant: this.newMimiState(),
+        },
+        backbonePast: [],
+        backbonePosition: 0,
+        probs: ZERO_VAP_PROBS,
+      };
+      this.contexts.set(contextId, context);
+    }
+    return context;
+  }
+
+  private newMimiState(): MimiStreamState {
+    const ort = this.requireOrt();
+    const metadata = this.requireMimiMetadata();
+    const shapes = [
+      ...metadata.contract.spec.padding_cache_shapes,
+      ...metadata.contract.spec.past_key_value_shapes,
+    ];
+    return {
+      cachePosition: 0,
+      position: 0,
+      states: shapes.map((shape) => new ort.Tensor(
+        "float32",
+        new Float32Array(product(shape)),
+        [...shape],
+      )),
+    };
+  }
+
+  private resample(context: DualTurnContext, frame: VapPredictorFrame): Int16Array {
+    if (frame.sampleRateHz === MODEL_SAMPLE_RATE_HZ) return frame.audio;
+    const key = `${frame.channel}:${String(frame.sampleRateHz)}`;
+    let resampler = context.resamplers.get(key);
+    if (!resampler) {
+      resampler = new StreamingPcm16Resampler(frame.sampleRateHz, MODEL_SAMPLE_RATE_HZ);
+      context.resamplers.set(key, resampler);
+    }
+    return resampler.process(frame.audio);
+  }
+
+  private hasReadyWindow(context: DualTurnContext): boolean {
+    const userWindows = Math.floor(context.queues.user.length / MODEL_WINDOW_SAMPLES);
+    const assistantWindows = Math.floor(context.queues.assistant.length / MODEL_WINDOW_SAMPLES);
+    return (userWindows > 0 && assistantWindows > 0) || userWindows > 1 || assistantWindows > 1;
+  }
+
+  private async inferWindow(
+    context: DualTurnContext,
+    userAudio: Float32Array,
+    assistantAudio: Float32Array,
+  ): Promise<VapProbs> {
+    const [userFeatures, assistantFeatures] = await Promise.all([
+      this.encodeMimi(userAudio, context.mimi.user),
+      this.encodeMimi(assistantAudio, context.mimi.assistant),
+    ]);
+    const projection = await this.requireSession(this.projectionSession, "projection").run({
+      user_features: userFeatures,
+      assistant_features: assistantFeatures,
+    });
+    const inputsEmbeds = requireTensor(projection["inputs_embeds"], "inputs_embeds");
+    const hiddenStates = await this.runBackbone(context, inputsEmbeds);
+    const outputs = await this.requireSession(this.headsSession, "turn heads").run({
+      hidden_states: hiddenStates,
+    });
+    return mapTurnHeads(outputs);
+  }
+
+  private async encodeMimi(audio: Float32Array, state: MimiStreamState): Promise<Tensor> {
+    const ort = this.requireOrt();
+    const metadata = this.requireMimiMetadata();
+    const cpLength = metadata.cache_position_len;
+    const cachePosition = new BigInt64Array(cpLength);
+    const positionIds = new BigInt64Array(cpLength);
+    for (let index = 0; index < cpLength; index += 1) {
+      cachePosition[index] = BigInt((state.cachePosition + index) % metadata.max_past_len);
+      positionIds[index] = BigInt(state.position + index);
+    }
+    const feeds: Record<string, Tensor> = {
+      wave_24k: new ort.Tensor("float32", audio, [1, 1, MODEL_WINDOW_SAMPLES]),
+      cache_position: new ort.Tensor("int64", cachePosition, [cpLength]),
+      position_ids: new ort.Tensor("int64", positionIds, [cpLength]),
+    };
+    const paddingCount = metadata.contract.spec.padding_cache_shapes.length;
+    for (let index = 0; index < state.states.length; index += 1) {
+      const name = index < paddingCount
+        ? `pad_cache_${String(index)}`
+        : `past_${String(index - paddingCount)}`;
+      feeds[name] = state.states[index]!;
+    }
+    const output = await this.requireSession(this.mimiSession, "Mimi").run(feeds);
+    const cpOut = requireTensor(output["cache_position_out"], "cache_position_out");
+    const lastCachePosition = readLastInteger(cpOut);
+    state.cachePosition = lastCachePosition ?? ((state.cachePosition + cpLength) % metadata.max_past_len);
+    state.position += cpLength;
+    state.states = [
+      ...Array.from({ length: paddingCount }, (_, index) =>
+        requireTensor(output[`pad_cache_out_${String(index)}`], `pad_cache_out_${String(index)}`)),
+      ...Array.from({ length: metadata.contract.spec.past_key_value_shapes.length }, (_, index) =>
+        requireTensor(output[`past_out_${String(index)}`], `past_out_${String(index)}`)),
+    ];
+    return normalizeMimiFeatures(requireTensor(output["embeddings"], "embeddings"), ort);
+  }
+
+  private async runBackbone(context: DualTurnContext, inputsEmbeds: Tensor): Promise<Tensor> {
+    const ort = this.requireOrt();
+    const session = this.requireSession(this.backboneSession, "backbone");
+    const timeSteps = inputsEmbeds.dims[1] ?? 0;
+    const pastLength = context.backbonePast[0]?.dims[2] ?? 0;
+    const feeds: Record<string, Tensor> = {
+      inputs_embeds: inputsEmbeds,
+      attention_mask: new ort.Tensor(
+        "int64",
+        filledBigInt(pastLength + timeSteps, 1n),
+        [1, pastLength + timeSteps],
+      ),
+      position_ids: new ort.Tensor(
+        "int64",
+        rangeBigInt(context.backbonePosition, timeSteps),
+        [1, timeSteps],
+      ),
+    };
+    for (let layer = 0; layer < 24; layer += 1) {
+      const key = context.backbonePast[layer * 2]
+        ?? new ort.Tensor("float32", new Float32Array(0), [1, 2, 0, 64]);
+      const value = context.backbonePast[layer * 2 + 1]
+        ?? new ort.Tensor("float32", new Float32Array(0), [1, 2, 0, 64]);
+      feeds[`past_key_values.${String(layer)}.key`] = key;
+      feeds[`past_key_values.${String(layer)}.value`] = value;
+    }
+    const outputs = await session.run(feeds);
+    const hidden = requireTensor(outputs[session.outputNames[0]!], "backbone hidden states");
+    context.backbonePast = session.outputNames.slice(1).map((name) =>
+      trimQwenCache(requireTensor(outputs[name], name), this.requireManifest().context_frames, ort),
+    );
+    context.backbonePosition += timeSteps;
+    return hidden;
+  }
+
+  private assertInitialized(): void {
+    this.requireOrt();
+    this.requireManifest();
+    this.requireMimiMetadata();
+    this.requireSession(this.mimiSession, "Mimi");
+    this.requireSession(this.projectionSession, "projection");
+    this.requireSession(this.backboneSession, "backbone");
+    this.requireSession(this.headsSession, "turn heads");
+  }
+
+  private requireOrt(): Ort {
+    if (!this.ort) throw new Error("LocalVapPredictor is not initialized");
+    return this.ort;
+  }
+
+  private requireManifest(): DualTurnManifest {
+    if (!this.manifest) throw new Error("LocalVapPredictor bundle manifest is not loaded");
+    return this.manifest;
+  }
+
+  private requireMimiMetadata(): MimiMetadata {
+    if (!this.mimiMetadata) throw new Error("LocalVapPredictor Mimi metadata is not loaded");
+    return this.mimiMetadata;
+  }
+
+  private requireSession(session: InferenceSession | null, label: string): InferenceSession {
+    if (!session) throw new Error(`LocalVapPredictor ${label} session is not loaded`);
+    return session;
+  }
+}
+
+class PcmSampleQueue {
+  private readonly storage: Int16Array;
+  private readIndex = 0;
+  private writeIndex = 0;
+  private sampleCount = 0;
+
+  constructor(capacity: number) {
+    this.storage = new Int16Array(capacity);
+  }
+
+  get length(): number {
+    return this.sampleCount;
+  }
+
+  append(audio: Int16Array): void {
+    if (audio.length > this.storage.length - this.sampleCount) {
+      throw new Error("DualTurn audio queue overflowed while inference was backlogged");
+    }
+    for (const sample of audio) {
+      this.storage[this.writeIndex] = sample;
+      this.writeIndex = (this.writeIndex + 1) % this.storage.length;
+      this.sampleCount += 1;
+    }
+  }
+
+  drainNormalized(count: number): Float32Array {
+    if (count > this.sampleCount) throw new Error("DualTurn audio queue underflow");
+    const output = new Float32Array(count);
+    for (let index = 0; index < count; index += 1) {
+      output[index] = this.storage[this.readIndex]! / 32_768;
+      this.readIndex = (this.readIndex + 1) % this.storage.length;
+      this.sampleCount -= 1;
+    }
+    return output;
+  }
+}
+
+async function readJson(path: string): Promise<unknown> {
+  return JSON.parse(await readFile(path, "utf8")) as unknown;
+}
+
+function parseManifest(value: unknown): DualTurnManifest {
+  const manifest = value as Partial<DualTurnManifest>;
+  if (manifest.format !== "syrinx.dualturn.onnx.v1" || !manifest.files || !manifest.context_frames) {
+    throw new Error("Unsupported or invalid DualTurn bundle manifest");
+  }
+  return manifest as DualTurnManifest;
+}
+
+function parseMimiMetadata(value: unknown): MimiMetadata {
+  const metadata = value as Partial<MimiMetadata>;
+  if (!metadata.cache_position_len || !metadata.max_past_len || !metadata.contract?.spec) {
+    throw new Error("Invalid Continuous Mimi ONNX metadata");
+  }
+  return metadata as MimiMetadata;
+}
+
+function product(shape: readonly number[]): number {
+  return shape.reduce((size, dimension) => size * dimension, 1);
+}
+
+function requireTensor(tensor: Tensor | undefined, name: string): Tensor {
+  if (!tensor) throw new Error(`ONNX output ${name} is missing`);
+  return tensor;
+}
+
+function readLastInteger(tensor: Tensor): number | undefined {
+  const data = tensor.data;
+  const value = data[data.length - 1];
+  if (typeof value === "bigint") return Number(value);
+  if (typeof value === "number" && Number.isFinite(value)) return Math.trunc(value);
+  return undefined;
+}
+
+function normalizeMimiFeatures(tensor: Tensor, ort: Ort): Tensor {
+  const [batch = 0, first = 0, second = 0] = tensor.dims;
+  if (batch !== 1) throw new Error(`Mimi emitted unsupported batch size ${String(batch)}`);
+  if (second === 512) return tensor;
+  if (first !== 512) {
+    throw new Error(`Mimi emitted unsupported feature shape [${tensor.dims.join(",")}]`);
+  }
+  const source = tensor.data as Float32Array;
+  const output = new Float32Array(second * first);
+  for (let frame = 0; frame < second; frame += 1) {
+    for (let feature = 0; feature < first; feature += 1) {
+      output[frame * first + feature] = source[feature * second + frame]!;
+    }
+  }
+  return new ort.Tensor("float32", output, [1, second, first]);
+}
+
+function rangeBigInt(start: number, length: number): BigInt64Array {
+  const output = new BigInt64Array(length);
+  for (let index = 0; index < length; index += 1) output[index] = BigInt(start + index);
+  return output;
+}
+
+function filledBigInt(length: number, value: bigint): BigInt64Array {
+  const output = new BigInt64Array(length);
+  output.fill(value);
+  return output;
+}
+
+function trimQwenCache(tensor: Tensor, maxFrames: number, ort: Ort): Tensor {
+  const [batch = 0, heads = 0, frames = 0, headSize = 0] = tensor.dims;
+  if (frames <= maxFrames) return tensor;
+  if (batch !== 1) throw new Error("DualTurn Qwen cache only supports batch size 1");
+  const source = tensor.data as Float32Array;
+  const output = new Float32Array(heads * maxFrames * headSize);
+  for (let head = 0; head < heads; head += 1) {
+    const sourceStart = (head * frames + frames - maxFrames) * headSize;
+    const destinationStart = head * maxFrames * headSize;
+    output.set(source.subarray(sourceStart, sourceStart + maxFrames * headSize), destinationStart);
+  }
+  return new ort.Tensor("float32", output, [1, heads, maxFrames, headSize]);
+}
+
+function mapTurnHeads(output: Record<string, Tensor>): VapProbs {
+  const eot = requireFloatOutput(output["eot_probs"], "eot_probs");
+  const bot = requireFloatOutput(output["bot_probs"], "bot_probs");
+  const hold = requireFloatOutput(output["hold_probs"], "hold_probs");
+  const backchannel = requireFloatOutput(output["bc_probs"], "bc_probs");
+  const latestUserIndex = eot.length - 2;
+  return {
+    pShift: Math.max(eot[latestUserIndex] ?? 0, bot[latestUserIndex] ?? 0),
+    pBackchannel: backchannel[backchannel.length - 2] ?? 0,
+    pHold: hold[hold.length - 2] ?? 0,
+  };
+}
+
+function requireFloatOutput(tensor: Tensor | undefined, name: string): Float32Array {
+  const value = requireTensor(tensor, name).data;
+  if (!(value instanceof Float32Array)) throw new Error(`ONNX output ${name} must be float32`);
+  return value;
+}

package/src/index.ts

@@ -0,0 +1,191 @@
+// SPDX-License-Identifier: MIT
+
+import type { PluginConfig } from "@kuralle-syrinx/core";
+import type { InteractionDecision, InteractionObservation, InteractionPolicy } from "@kuralle-syrinx/core";
+import {
+  DEFAULT_VAP_THRESHOLDS,
+  RollingFeatureBuffer,
+  ZERO_VAP_PROBS,
+  decideFromProbs,
+  type VapDecisionContext,
+  type VapPredictor,
+  type VapPredictorFrame,
+  type VapProbs,
+  type VapThresholds,
+  type VapTranscriptFusion,
+  type VapTranscriptObservation,
+} from "./vap-policy.js";
+
+export type {
+  VapPredictor,
+  VapPredictorFrame,
+  VapProbs,
+  VapThresholds,
+  VapDecisionContext,
+  VapTranscriptFusion,
+  VapTranscriptObservation,
+} from "./vap-policy.js";
+export {
+  DEFAULT_VAP_THRESHOLDS,
+  ZERO_VAP_PROBS,
+  decideFromProbs,
+  RollingFeatureBuffer,
+  semanticTranscriptFusion,
+} from "./vap-policy.js";
+
+export { LocalVapPredictor } from "./dualturn-predictor.js";
+
+export class StubVapPredictor implements VapPredictor {
+  private scripted: VapProbs[] = [];
+  private fallback: VapProbs = ZERO_VAP_PROBS;
+
+  script(probs: readonly VapProbs[]): void {
+    this.scripted = [...probs];
+  }
+
+  setFallback(probs: VapProbs): void {
+    this.fallback = probs;
+  }
+
+  async initialize(_cfg: PluginConfig = {}): Promise<void> {}
+
+  async push(_frame: VapPredictorFrame): Promise<VapProbs> {
+    return this.scripted.shift() ?? this.fallback;
+  }
+
+  reset(_contextId: string): void {}
+
+  async close(): Promise<void> {}
+}
+
+export interface VapInteractionPolicyDeps {
+  readonly predictor: VapPredictor;
+  readonly thresholds?: VapThresholds;
+  readonly fuseTranscript?: VapTranscriptFusion;
+}
+
+export class VapInteractionPolicy implements InteractionPolicy {
+  private readonly predictor: VapPredictor;
+  private readonly thresholds: VapThresholds;
+  private readonly fuseTranscript?: VapTranscriptFusion;
+  private readonly cachedProbs = new Map<string, VapProbs>();
+  private readonly transcripts = new Map<string, VapTranscriptObservation>();
+  private readonly inferenceChains = new Map<string, Promise<void>>();
+  private readonly contextEpochs = new Map<string, number>();
+  private ttsActive = false;
+  private ttsContextId = "";
+  private delegateInFlight = false;
+  private initialized = false;
+
+  constructor(deps: VapInteractionPolicyDeps) {
+    this.predictor = deps.predictor;
+    this.thresholds = deps.thresholds ?? DEFAULT_VAP_THRESHOLDS;
+    this.fuseTranscript = deps.fuseTranscript;
+  }
+
+  async initialize(cfg: PluginConfig = {}): Promise<void> {
+    await this.predictor.initialize(cfg);
+    this.initialized = true;
+  }
+
+  observe(obs: InteractionObservation): readonly InteractionDecision[] {
+    switch (obs.kind) {
+      case "playout_tick":
+        this.ttsActive = obs.ttsActive === true;
+        if (this.ttsActive) this.ttsContextId = obs.contextId;
+        if (obs.audio && obs.audio.length > 0) {
+          this.enqueueInference({
+            contextId: obs.contextId,
+            timestampMs: obs.timestampMs,
+            channel: "assistant",
+            audio: obs.audio,
+            sampleRateHz: obs.sampleRateHz ?? 16_000,
+          });
+        }
+        return [];
+      case "delegate_state":
+        this.delegateInFlight = obs.delegateInFlight === true;
+        return [];
+      case "stt_partial":
+      case "stt_final":
+        this.transcripts.set(obs.contextId, obs);
+        return [];
+      case "audio_frame":
+        return this.observeAudioFrame(obs);
+      default:
+        return [];
+    }
+  }
+
+  reset(contextId: string): void {
+    if (this.inferenceChains.has(contextId)) {
+      this.contextEpochs.set(contextId, (this.contextEpochs.get(contextId) ?? 0) + 1);
+    } else {
+      this.contextEpochs.delete(contextId);
+    }
+    this.cachedProbs.delete(contextId);
+    this.transcripts.delete(contextId);
+    this.predictor.reset(contextId);
+  }
+
+  async close(): Promise<void> {
+    await Promise.allSettled(this.inferenceChains.values());
+    await this.predictor.close();
+    this.cachedProbs.clear();
+    this.transcripts.clear();
+    this.inferenceChains.clear();
+    this.contextEpochs.clear();
+    this.initialized = false;
+  }
+
+  private observeAudioFrame(
+    obs: Extract<InteractionObservation, { kind: "audio_frame" }>,
+  ): readonly InteractionDecision[] {
+    if (!this.initialized) return [{ kind: "keep_listening" }];
+    if (obs.audio && obs.audio.length > 0) {
+      this.enqueueInference({
+        contextId: obs.contextId,
+        timestampMs: obs.timestampMs,
+        channel: "user",
+        audio: obs.audio,
+        sampleRateHz: obs.sampleRateHz ?? 16_000,
+      });
+    }
+    const rawProbs = this.cachedProbs.get(obs.contextId) ?? ZERO_VAP_PROBS;
+    const transcript = this.transcripts.get(obs.contextId);
+    const probs = transcript && this.fuseTranscript
+      ? this.fuseTranscript(rawProbs, transcript)
+      : rawProbs;
+    return decideFromProbs(probs, this.decisionContext());
+  }
+
+  private decisionContext(): VapDecisionContext {
+    return {
+      ttsActive: this.ttsActive,
+      ttsContextId: this.ttsContextId,
+      delegateInFlight: this.delegateInFlight,
+    };
+  }
+
+  private enqueueInference(frame: VapPredictorFrame): void {
+    const stableFrame = { ...frame, audio: frame.audio.slice() };
+    const epoch = this.contextEpochs.get(frame.contextId) ?? 0;
+    const previous = this.inferenceChains.get(frame.contextId) ?? Promise.resolve();
+    const next = previous
+      .catch(() => undefined)
+      .then(async () => {
+        if ((this.contextEpochs.get(frame.contextId) ?? 0) !== epoch) return;
+        const probs = await this.predictor.push(stableFrame);
+        if ((this.contextEpochs.get(frame.contextId) ?? 0) === epoch) {
+          this.cachedProbs.set(frame.contextId, probs);
+        }
+      });
+    const settled = next.catch(() => undefined).finally(() => {
+      if (this.inferenceChains.get(frame.contextId) === settled) {
+        this.inferenceChains.delete(frame.contextId);
+        this.contextEpochs.delete(frame.contextId);
+      }
+    });
+    this.inferenceChains.set(frame.contextId, settled);
+  }
+}

package/src/vap-policy.test.ts

@@ -0,0 +1,305 @@
+// SPDX-License-Identifier: MIT
+
+import { describe, expect, it } from "vitest";
+
+import {
+  DEFAULT_VAP_THRESHOLDS,
+  RollingFeatureBuffer,
+  decideFromProbs,
+  semanticTranscriptFusion,
+  type VapPredictor,
+  type VapPredictorFrame,
+  type VapProbs,
+} from "./vap-policy.js";
+import { StubVapPredictor, VapInteractionPolicy } from "./index.js";
+
+function audioFrame(contextId = "ctx-1", audio = new Int16Array(320)) {
+  return {
+    kind: "audio_frame" as const,
+    contextId,
+    timestampMs: Date.now(),
+    audio,
+    sampleRateHz: 16_000,
+  };
+}
+
+async function flushInference(): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+describe("decideFromProbs", () => {
+  it("maps each threshold path to the expected InteractionDecision", () => {
+    const thresholds = DEFAULT_VAP_THRESHOLDS;
+    expect(
+      decideFromProbs(
+        { pShift: thresholds.shift + 0.1, pBackchannel: 0, pHold: 0 },
+        { ttsActive: true, ttsContextId: "tts-1", delegateInFlight: false },
+        thresholds,
+      ),
+    ).toEqual([{ kind: "interrupt", interruptedContextId: "tts-1" }]);
+
+    expect(
+      decideFromProbs(
+        { pShift: 0, pBackchannel: thresholds.backchannel + 0.1, pHold: 0 },
+        { ttsActive: false, ttsContextId: "", delegateInFlight: true },
+        thresholds,
+      ),
+    ).toEqual([{ kind: "backchannel", cue: "mhmm" }]);
+
+    expect(
+      decideFromProbs(
+        { pShift: thresholds.take + 0.1, pBackchannel: 0, pHold: 0 },
+        { ttsActive: false, ttsContextId: "", delegateInFlight: false },
+        thresholds,
+      ),
+    ).toEqual([{ kind: "take_turn", confidence: thresholds.take + 0.1 }]);
+
+    expect(
+      decideFromProbs(
+        { pShift: 0, pBackchannel: 0, pHold: thresholds.hold + 0.1 },
+        { ttsActive: false, ttsContextId: "", delegateInFlight: false },
+        thresholds,
+      ),
+    ).toEqual([{ kind: "hold" }]);
+
+    expect(
+      decideFromProbs(
+        { pShift: 0.1, pBackchannel: 0.1, pHold: 0.1 },
+        { ttsActive: false, ttsContextId: "", delegateInFlight: false },
+        thresholds,
+      ),
+    ).toEqual([{ kind: "keep_listening" }]);
+  });
+});
+
+describe("VapInteractionPolicy", () => {
+  it("returns cached decisions synchronously from observe (test:vap-thresholds)", async () => {
+    const predictor = new StubVapPredictor();
+    predictor.script([
+      { pShift: DEFAULT_VAP_THRESHOLDS.take + 0.2, pBackchannel: 0, pHold: 0 },
+    ]);
+    const policy = new VapInteractionPolicy({ predictor });
+    await policy.initialize();
+
+    const first = policy.observe(audioFrame());
+    expect(first).toEqual([{ kind: "keep_listening" }]);
+
+    await flushInference();
+    const second = policy.observe(audioFrame());
+    expect(second).toEqual([
+      { kind: "take_turn", confidence: DEFAULT_VAP_THRESHOLDS.take + 0.2 },
+    ]);
+  });
+
+  it("gates interrupt on ttsActive and backchannel on delegateInFlight", async () => {
+    const predictor = new StubVapPredictor();
+    predictor.setFallback({
+      pShift: DEFAULT_VAP_THRESHOLDS.shift + 0.1,
+      pBackchannel: 0,
+      pHold: 0,
+    });
+    const policy = new VapInteractionPolicy({ predictor });
+    await policy.initialize();
+
+    policy.observe(audioFrame());
+    await flushInference();
+    expect(policy.observe(audioFrame())).toEqual([
+      { kind: "take_turn", confidence: DEFAULT_VAP_THRESHOLDS.shift + 0.1 },
+    ]);
+
+    policy.observe({
+      kind: "playout_tick",
+      contextId: "tts-ctx",
+      timestampMs: Date.now(),
+      ttsActive: true,
+    });
+    expect(policy.observe(audioFrame())).toEqual([
+      { kind: "interrupt", interruptedContextId: "tts-ctx" },
+    ]);
+
+    policy.observe({
+      kind: "playout_tick",
+      contextId: "tts-ctx",
+      timestampMs: Date.now(),
+      ttsActive: false,
+    });
+    predictor.setFallback({
+      pShift: 0,
+      pBackchannel: DEFAULT_VAP_THRESHOLDS.backchannel + 0.1,
+      pHold: 0,
+    });
+    policy.observe(audioFrame());
+    await flushInference();
+
+    policy.observe({
+      kind: "delegate_state",
+      contextId: "ctx-1",
+      timestampMs: Date.now(),
+      delegateInFlight: false,
+    });
+    expect(policy.observe(audioFrame())).toEqual([{ kind: "keep_listening" }]);
+
+    policy.observe({
+      kind: "delegate_state",
+      contextId: "ctx-1",
+      timestampMs: Date.now(),
+      delegateInFlight: true,
+    });
+    expect(policy.observe(audioFrame())).toEqual([{ kind: "backchannel", cue: "mhmm" }]);
+  });
+
+  it("serializes stable user and assistant frames and resets predictor state", async () => {
+    const pushed: VapPredictorFrame[] = [];
+    const resets: string[] = [];
+    const predictor: VapPredictor = {
+      async initialize() {},
+      async push(frame) {
+        pushed.push(frame);
+        return { pShift: 0, pBackchannel: 0, pHold: 0 };
+      },
+      reset(contextId) {
+        resets.push(contextId);
+      },
+      async close() {},
+    };
+    const policy = new VapInteractionPolicy({ predictor });
+    await policy.initialize();
+    const userAudio = new Int16Array([1, 2]);
+    const assistantAudio = new Int16Array([3, 4]);
+
+    policy.observe(audioFrame("duplex", userAudio));
+    policy.observe({
+      kind: "playout_tick",
+      contextId: "duplex",
+      timestampMs: 2,
+      ttsActive: true,
+      audio: assistantAudio,
+      sampleRateHz: 24_000,
+    });
+    userAudio[0] = 99;
+    assistantAudio[0] = 99;
+    await flushInference();
+
+    expect(pushed.map(({ channel, audio, sampleRateHz }) => ({
+      channel,
+      audio: [...audio],
+      sampleRateHz,
+    }))).toEqual([
+      { channel: "user", audio: [1, 2], sampleRateHz: 16_000 },
+      { channel: "assistant", audio: [3, 4], sampleRateHz: 24_000 },
+    ]);
+
+    policy.reset("duplex");
+    expect(resets).toEqual(["duplex"]);
+  });
+
+  it("does not run queued frames across reset and drains inference before close", async () => {
+    let releaseFirst!: () => void;
+    const firstPush = new Promise<void>((resolve) => {
+      releaseFirst = resolve;
+    });
+    const pushed: number[] = [];
+    let closed = false;
+    const predictor: VapPredictor = {
+      async initialize() {},
+      async push(frame) {
+        pushed.push(frame.audio[0] ?? 0);
+        if (pushed.length === 1) await firstPush;
+        return { pShift: 0, pBackchannel: 0, pHold: 0 };
+      },
+      reset() {},
+      async close() {
+        closed = true;
+      },
+    };
+    const policy = new VapInteractionPolicy({ predictor });
+    await policy.initialize();
+
+    policy.observe(audioFrame("reset", new Int16Array([1])));
+    policy.observe(audioFrame("reset", new Int16Array([2])));
+    await flushInference();
+    policy.reset("reset");
+    const closing = policy.close();
+
+    expect(closed).toBe(false);
+    releaseFirst();
+    await closing;
+    expect(pushed).toEqual([1]);
+    expect(closed).toBe(true);
+  });
+
+  it("can fuse per-context transcript evidence into cached VAP probabilities", async () => {
+    const predictor = new StubVapPredictor();
+    predictor.setFallback({ pShift: 0.8, pBackchannel: 0, pHold: 0 });
+    const policy = new VapInteractionPolicy({ predictor, fuseTranscript: semanticTranscriptFusion });
+    await policy.initialize();
+    policy.observe(audioFrame("fused"));
+    await flushInference();
+
+    policy.observe({
+      kind: "stt_partial",
+      contextId: "fused",
+      timestampMs: 1,
+      text: "I need to",
+    });
+    expect(policy.observe(audioFrame("fused"))).toEqual([{ kind: "keep_listening" }]);
+
+    policy.observe({
+      kind: "stt_final",
+      contextId: "fused",
+      timestampMs: 2,
+      text: "That is everything.",
+    });
+    expect(policy.observe(audioFrame("fused"))).toEqual([
+      { kind: "take_turn", confidence: 0.9 },
+    ]);
+
+    policy.reset("fused");
+    expect(policy.observe(audioFrame("fused"))).toEqual([{ kind: "keep_listening" }]);
+  });
+
+  it("observe audio_frame p99 stays <= 5ms on the sync path (test:vap-latency-bench)", async () => {
+    const predictor = new StubVapPredictor();
+    predictor.setFallback({
+      pShift: DEFAULT_VAP_THRESHOLDS.take + 0.2,
+      pBackchannel: 0,
+      pHold: 0,
+    });
+    const policy = new VapInteractionPolicy({ predictor });
+    await policy.initialize();
+
+    const frame = new Int16Array(320);
+    const samples = 1000;
+    const durations: number[] = [];
+    for (let i = 0; i < samples; i += 1) {
+      const start = performance.now();
+      policy.observe(audioFrame("bench", frame));
+      durations.push(performance.now() - start);
+    }
+
+    durations.sort((a, b) => a - b);
+    const p99 = durations[Math.floor(samples * 0.99) - 1] ?? durations[durations.length - 1] ?? 0;
+    expect(p99).toBeLessThanOrEqual(5);
+  });
+});
+
+describe("RollingFeatureBuffer", () => {
+  it("keeps chronological samples after wrap and returns stable snapshots", () => {
+    const buffer = new RollingFeatureBuffer(4);
+    buffer.append(new Int16Array([3_276, 6_553, 9_830]));
+    const first = buffer.snapshot();
+    buffer.append(new Int16Array([13_107, 16_384]));
+
+    expect([...first]).toEqual([
+      3_276 / 32_768,
+      6_553 / 32_768,
+      9_830 / 32_768,
+    ]);
+    expect([...buffer.snapshot()]).toEqual([
+      6_553 / 32_768,
+      9_830 / 32_768,
+      13_107 / 32_768,
+      16_384 / 32_768,
+    ]);
+  });
+});

package/src/vap-policy.ts

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: MIT
+
+import type { InteractionDecision, InteractionObservation, PluginConfig } from "@kuralle-syrinx/core";
+
+export interface VapPredictor {
+  initialize(cfg: PluginConfig): Promise<void>;
+  push(frame: VapPredictorFrame): Promise<VapProbs>;
+  reset(contextId: string): void;
+  close(): Promise<void>;
+}
+
+export interface VapPredictorFrame {
+  readonly contextId: string;
+  readonly timestampMs: number;
+  readonly channel: "user" | "assistant";
+  readonly audio: Int16Array;
+  readonly sampleRateHz: number;
+}
+
+export interface VapProbs {
+  readonly pShift: number;
+  readonly pBackchannel: number;
+  readonly pHold: number;
+}
+
+export type VapTranscriptObservation = Extract<
+  InteractionObservation,
+  { kind: "stt_partial" | "stt_final" }
+>;
+
+export type VapTranscriptFusion = (
+  probs: VapProbs,
+  transcript: VapTranscriptObservation,
+) => VapProbs;
+
+export interface VapThresholds {
+  readonly shift: number;
+  readonly backchannel: number;
+  readonly take: number;
+  readonly hold: number;
+}
+
+export const DEFAULT_VAP_THRESHOLDS: VapThresholds = {
+  shift: 0.75,
+  backchannel: 0.5,
+  take: 0.6,
+  hold: 0.5,
+};
+
+export const ZERO_VAP_PROBS: VapProbs = { pShift: 0, pBackchannel: 0, pHold: 0 };
+
+export interface VapDecisionContext {
+  readonly ttsActive: boolean;
+  readonly ttsContextId: string;
+  readonly delegateInFlight: boolean;
+}
+
+export function decideFromProbs(
+  probs: VapProbs,
+  ctx: VapDecisionContext,
+  thresholds: VapThresholds = DEFAULT_VAP_THRESHOLDS,
+): readonly InteractionDecision[] {
+  if (ctx.ttsActive && probs.pShift > thresholds.shift) {
+    return [{ kind: "interrupt", interruptedContextId: ctx.ttsContextId }];
+  }
+  if (probs.pBackchannel > thresholds.backchannel && ctx.delegateInFlight) {
+    return [{ kind: "backchannel", cue: "mhmm" }];
+  }
+  if (probs.pShift > thresholds.take) {
+    return [{ kind: "take_turn", confidence: probs.pShift }];
+  }
+  if (probs.pHold > thresholds.hold) {
+    return [{ kind: "hold" }];
+  }
+  return [{ kind: "keep_listening" }];
+}
+
+/** Conservative transcript evidence used by the C6 VAP+STT arm. */
+export function semanticTranscriptFusion(
+  probs: VapProbs,
+  transcript: VapTranscriptObservation,
+): VapProbs {
+  const text = transcript.text.trim().replace(/\s+/g, " ");
+  if (!text) return probs;
+  const incomplete = /\b(and|but|or|so|because|if|when|while|although|since|unless|until|the|a|an|to|for|of|in|on|at|with|about|from|by|please|just|also|then|well|um|uh|i|we|you|my|your|our|this)$/i.test(text)
+    || text.endsWith(",");
+  if (incomplete) return { ...probs, pShift: Math.min(probs.pShift, 0.49) };
+  if (/[.!?]["')]*$/.test(text)) return { ...probs, pShift: Math.max(probs.pShift, 0.9) };
+  return probs;
+}
+
+const DEFAULT_MAX_SAMPLES = 16_000;
+
+export class RollingFeatureBuffer {
+  private readonly storage: Float32Array;
+  private length = 0;
+  private writeIndex = 0;
+
+  constructor(private readonly maxSamples = DEFAULT_MAX_SAMPLES) {
+    this.storage = new Float32Array(maxSamples);
+  }
+
+  append(audio?: Int16Array): void {
+    if (audio && audio.length > 0) {
+      for (let i = 0; i < audio.length; i += 1) {
+        const sample = audio[i] ?? 0;
+        this.storage[this.writeIndex] = sample / 32768;
+        this.writeIndex = (this.writeIndex + 1) % this.maxSamples;
+        this.length = Math.min(this.length + 1, this.maxSamples);
+      }
+    }
+  }
+
+  /** Returns an immutable chronological copy suitable for async inference. */
+  snapshot(): Float32Array {
+    const snapshot = new Float32Array(this.length);
+    const start = (this.writeIndex - this.length + this.maxSamples) % this.maxSamples;
+    const firstLength = Math.min(this.length, this.maxSamples - start);
+    snapshot.set(this.storage.subarray(start, start + firstLength));
+    if (firstLength < this.length) {
+      snapshot.set(this.storage.subarray(0, this.length - firstLength), firstLength);
+    }
+    return snapshot;
+  }
+
+  reset(): void {
+    this.length = 0;
+    this.writeIndex = 0;
+  }
+}

package/src/workers.ts

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: MIT
+
+import type { PluginConfig } from "@kuralle-syrinx/core";
+import { optionalStringConfig } from "@kuralle-syrinx/core";
+import {
+  RollingFeatureBuffer,
+  ZERO_VAP_PROBS,
+  type VapPredictor,
+  type VapPredictorFrame,
+  type VapProbs,
+} from "./vap-policy.js";
+
+type Ort = typeof import("onnxruntime-web");
+type InferenceSession = import("onnxruntime-web").InferenceSession;
+
+export class WorkersVapPredictor implements VapPredictor {
+  private ort: Ort | null = null;
+  private session: InferenceSession | null = null;
+
+  async initialize(cfg: PluginConfig = {}): Promise<void> {
+    this.ort = await import("onnxruntime-web");
+    this.session = await this.ort.InferenceSession.create(await readModelBytes(cfg), {
+      executionProviders: ["wasm"],
+    });
+  }
+
+  private readonly buffers = new Map<string, RollingFeatureBuffer>();
+  private readonly cachedProbs = new Map<string, VapProbs>();
+
+  async push(frame: VapPredictorFrame): Promise<VapProbs> {
+    if (!this.session || !this.ort) {
+      throw new Error("WorkersVapPredictor is not initialized");
+    }
+    if (frame.channel === "assistant") {
+      return this.cachedProbs.get(frame.contextId) ?? ZERO_VAP_PROBS;
+    }
+    const buffer = this.bufferFor(frame.contextId);
+    buffer.append(frame.audio);
+    const features = buffer.snapshot();
+    const output = await this.session.run({
+      features: new this.ort.Tensor("float32", features, [1, features.length]),
+    });
+    const probs = mapOnnxOutput(output);
+    this.cachedProbs.set(frame.contextId, probs);
+    return probs;
+  }
+
+  reset(contextId: string): void {
+    this.buffers.delete(contextId);
+    this.cachedProbs.delete(contextId);
+  }
+
+  async close(): Promise<void> {
+    this.session = null;
+    this.ort = null;
+    this.buffers.clear();
+    this.cachedProbs.clear();
+  }
+
+  private bufferFor(contextId: string): RollingFeatureBuffer {
+    let buffer = this.buffers.get(contextId);
+    if (!buffer) {
+      buffer = new RollingFeatureBuffer();
+      this.buffers.set(contextId, buffer);
+    }
+    return buffer;
+  }
+}
+
+async function readModelBytes(cfg: PluginConfig): Promise<Uint8Array> {
+  const bytes = cfg["model_bytes"];
+  if (bytes instanceof Uint8Array) return bytes;
+  if (bytes instanceof ArrayBuffer) return new Uint8Array(bytes);
+  const url = optionalStringConfig(cfg, "model_url");
+  if (!url) {
+    throw new Error("WorkersVapPredictor requires model_bytes or model_url");
+  }
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch VAP model from ${url}: ${response.status}`);
+  }
+  return new Uint8Array(await response.arrayBuffer());
+}
+
+function mapOnnxOutput(output: Record<string, import("onnxruntime-web").Tensor>): VapProbs {
+  const shift = readScalar(output["p_shift"] ?? output["pShift"] ?? output["shift"]);
+  const backchannel = readScalar(output["p_backchannel"] ?? output["pBackchannel"] ?? output["backchannel"]);
+  const hold = readScalar(output["p_hold"] ?? output["pHold"] ?? output["hold"]);
+  return { pShift: shift, pBackchannel: backchannel, pHold: hold };
+}
+
+function readScalar(tensor: import("onnxruntime-web").Tensor | undefined): number {
+  const value = tensor?.data?.[0];
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitReturns": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}