feat(rvcsi): rvcsi-runtime composition + rvcsi-node (napi-rs) + rvcsi-cli + @ruv/rvcsi TS SDK

- rvcsi-runtime — the composition layer (no FFI): CaptureRuntime (CsiSource +
  validate_frame + SignalPipeline + EventPipeline, with next_validated_frame /
  next_clean_frame / drain_events / health) plus one-shot helpers
  (summarize_capture → CaptureSummary, decode_nexmon_records, events_from_capture,
  export_capture_to_rf_memory, rf_memory_self_check). 10 tests.
- rvcsi-node — the napi-rs seam (cdylib+rlib, build.rs runs napi_build::setup):
  thin #[napi] wrappers over rvcsi-runtime — rvcsiVersion / nexmonShimAbiVersion /
  nexmonDecodeRecords / inspectCaptureFile / eventsFromCaptureFile /
  exportCaptureToRfMemory + an RvcsiRuntime streaming class. Everything that
  crosses the boundary is a validated/normalized rvCSI struct serialized to JSON
  (D6). deny(clippy::all).
- @ruv/rvcsi npm package (package.json + index.js + index.d.ts + README +
  __test__/api.test.cjs) — curated JS surface that JSON-parses the addon's
  output into plain CsiFrame/CsiWindow/CsiEvent/SourceHealth/CaptureSummary
  objects; lazy native-addon load with a helpful "not built" error.
- rvcsi-cli — the `rvcsi` binary: record (Nexmon dump → .rvcsi, validating),
  inspect, replay, stream, events, health, calibrate (v0 baseline), export
  ruvector. 7 tests exercising every subcommand against in-memory captures.
- rvcsi-cli no longer depends on rvcsi-node (a binary can't link the napi addon);
  the shared logic moved to rvcsi-runtime. .gitignore: ignore the generated
  *.node / binding.js / binding.d.ts / npm/ under rvcsi-node.

All rvcsi crates: build together OK, clippy-clean, 140 unit/integration tests +
2 doctests, 0 failures (core 29, dsp 28, events 18, adapter-file 20+1,
adapter-nexmon 9, ruvector 20+1, runtime 10, cli 7).

https://claude.ai/code/session_01CdYAPvRTjcch6YrYf42n1z

v2/crates/rvcsi-node/Cargo.toml

@@ -18,13 +18,12 @@ crate-type = ["cdylib", "rlib"]
 napi = { workspace = true }
 napi-derive = { workspace = true }
 rvcsi-core = { path = "../rvcsi-core" }
-rvcsi-dsp = { path = "../rvcsi-dsp" }
-rvcsi-events = { path = "../rvcsi-events" }
-rvcsi-adapter-file = { path = "../rvcsi-adapter-file" }
-rvcsi-adapter-nexmon = { path = "../rvcsi-adapter-nexmon" }
-rvcsi-ruvector = { path = "../rvcsi-ruvector" }
+rvcsi-runtime = { path = "../rvcsi-runtime" }
 serde = { workspace = true }
 serde_json = { workspace = true }
 
 [build-dependencies]
 napi-build = { workspace = true }
+
+[dev-dependencies]
+tempfile = "3.10"

v2/crates/rvcsi-node/README.md

@@ -0,0 +1,64 @@
+# @ruv/rvcsi
+
+Node.js bindings (napi-rs) for **rvCSI** — the edge RF sensing runtime: ingest
+WiFi CSI from files / Nexmon dumps, validate and normalize it, run reusable DSP,
+emit typed presence / motion / quality / anomaly events, and export temporal
+embeddings to an RF-memory store. See [ADR-095](../../../docs/adr/ADR-095-rvcsi-edge-rf-sensing-platform.md)
+and [ADR-096](../../../docs/adr/ADR-096-rvcsi-ffi-crate-layout.md).
+
+> This package wraps the Rust crates in `v2/crates/rvcsi-*`. The Rust side does
+> all the work (parsing, validation, DSP, events, embeddings); this is a thin,
+> safe JS surface — nothing crosses the boundary except validated/normalized
+> objects (delivered as JSON the SDK parses for you).
+
+## Build
+
+The native addon is produced from the `rvcsi-node` Rust crate:
+
+```bash
+# from v2/crates/rvcsi-node
+npm install              # installs @napi-rs/cli
+npm run build            # -> rvcsi-node.<triple>.node + binding.js + binding.d.ts
+```
+
+(`cargo build -p rvcsi-node` also compiles the addon as a `cdylib`; `napi build`
+additionally emits the platform loader and `.d.ts`.)
+
+## Usage
+
+```js
+const { RvCsi, inspectCaptureFile, eventsFromCaptureFile, nexmonDecodeRecords } = require('@ruv/rvcsi');
+
+// One-shot: summarize a capture
+const summary = inspectCaptureFile('lab.rvcsi');
+console.log(summary.frame_count, summary.channels, summary.mean_quality);
+
+// One-shot: replay a capture into events
+for (const e of eventsFromCaptureFile('lab.rvcsi')) {
+  console.log(e.kind, e.timestamp_ns, e.confidence);
+}
+
+// Streaming
+const rt = RvCsi.openCaptureFile('lab.rvcsi');
+let frame;
+while ((frame = rt.nextCleanFrame()) !== null) {
+  // frame.validation is 'Accepted' | 'Degraded' | 'Recovered' — never 'Pending'/'Rejected'
+  if (frame.quality_score > 0.5) { /* ... */ }
+}
+const events = rt.drainEvents();
+console.log(rt.health());
+
+// Decode raw Nexmon records (the napi-c shim format) straight from a Buffer
+const fs = require('fs');
+const frames = nexmonDecodeRecords(fs.readFileSync('nexmon.bin'), 'wlan0', 1);
+```
+
+TypeScript types ship in `index.d.ts` (`CsiFrame`, `CsiWindow`, `CsiEvent`,
+`SourceHealth`, `CaptureSummary`, `ValidationStatus`, `CsiEventKind`, ...).
+
+## What's here vs. not (yet)
+
+Implemented: file/replay + Nexmon sources, the validation pipeline, the DSP
+stages, window aggregation + the event state machines, RuVector-style RF-memory
+export. Not yet wired into this addon: live radio capture, the WebSocket daemon,
+and the MCP tool server — those come with `rvcsi-daemon` / `rvcsi-mcp`.

v2/crates/rvcsi-node/__test__/api.test.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+// Structural smoke test for the @ruv/rvcsi JS surface.
+//
+// Importing the package never throws (the native addon loads lazily). This test
+// asserts the public API shape; if the .node addon HAS been built (e.g. CI ran
+// `npm run build` first), it also checks `rvcsiVersion()` returns a string —
+// otherwise it asserts the error message is the helpful "not built" one.
+//
+// Run with: node --test  (Node >= 18)
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const rvcsi = require('../index.js');
+
+test('exports the expected functions and class', () => {
+  for (const fn of [
+    'rvcsiVersion',
+    'nexmonShimAbiVersion',
+    'nexmonDecodeRecords',
+    'inspectCaptureFile',
+    'eventsFromCaptureFile',
+    'exportCaptureToRfMemory',
+  ]) {
+    assert.equal(typeof rvcsi[fn], 'function', `${fn} should be a function`);
+  }
+  assert.equal(typeof rvcsi.RvCsi, 'function', 'RvCsi should be a class');
+  assert.equal(typeof rvcsi.RvCsi.openCaptureFile, 'function');
+  assert.equal(typeof rvcsi.RvCsi.openNexmonFile, 'function');
+});
+
+test('native calls either work (addon built) or fail with a helpful message', () => {
+  try {
+    const v = rvcsi.rvcsiVersion();
+    assert.equal(typeof v, 'string');
+    assert.match(v, /^\d+\.\d+\.\d+/);
+    assert.equal(typeof rvcsi.nexmonShimAbiVersion(), 'number');
+  } catch (e) {
+    assert.match(e.message, /native addon is not built/i);
+  }
+});

v2/crates/rvcsi-node/index.d.ts

@@ -0,0 +1,171 @@
+// rvCSI Node.js SDK — type declarations for the curated `index.js` surface.
+//
+// The shapes below mirror the Rust `rvcsi-core` schema (`CsiFrame`, `CsiWindow`,
+// `CsiEvent`, `SourceHealth`) and `rvcsi-runtime` (`CaptureSummary`). They are
+// what you get back after the SDK `JSON.parse`s the strings the napi-rs addon
+// returns (see ADR-095 §10 / ADR-096 §2.3).
+
+/** Outcome of the rvCSI validation pipeline for a frame. */
+export type ValidationStatus =
+  | 'Pending'
+  | 'Accepted'
+  | 'Degraded'
+  | 'Rejected'
+  | 'Recovered';
+
+/** Which adapter family produced a frame. */
+export type AdapterKind =
+  | 'File'
+  | 'Replay'
+  | 'Nexmon'
+  | 'Esp32'
+  | 'Intel'
+  | 'Atheros'
+  | 'Synthetic';
+
+/** Kinds of event the runtime emits. */
+export type CsiEventKind =
+  | 'PresenceStarted'
+  | 'PresenceEnded'
+  | 'MotionDetected'
+  | 'MotionSettled'
+  | 'BaselineChanged'
+  | 'SignalQualityDropped'
+  | 'DeviceDisconnected'
+  | 'BreathingCandidate'
+  | 'AnomalyDetected'
+  | 'CalibrationRequired';
+
+/** One normalized, validated CSI observation. */
+export interface CsiFrame {
+  frame_id: number;
+  session_id: number;
+  source_id: string;
+  adapter_kind: AdapterKind;
+  timestamp_ns: number;
+  channel: number;
+  bandwidth_mhz: number;
+  rssi_dbm: number | null;
+  noise_floor_dbm: number | null;
+  antenna_index: number | null;
+  tx_chain: number | null;
+  rx_chain: number | null;
+  subcarrier_count: number;
+  i_values: number[];
+  q_values: number[];
+  amplitude: number[];
+  phase: number[];
+  validation: ValidationStatus;
+  quality_score: number;
+  /** Present (non-empty) only when `validation` is `Degraded`. */
+  quality_reasons?: string[];
+  calibration_version: string | null;
+}
+
+/** A bounded window of frames, summarized. */
+export interface CsiWindow {
+  window_id: number;
+  session_id: number;
+  source_id: string;
+  start_ns: number;
+  end_ns: number;
+  frame_count: number;
+  mean_amplitude: number[];
+  phase_variance: number[];
+  motion_energy: number;
+  presence_score: number;
+  quality_score: number;
+}
+
+/** A detected event with confidence and the windows that justify it. */
+export interface CsiEvent {
+  event_id: number;
+  kind: CsiEventKind;
+  session_id: number;
+  source_id: string;
+  timestamp_ns: number;
+  confidence: number;
+  evidence_window_ids: number[];
+  calibration_version: string | null;
+  /** Free-form JSON string of event metadata. */
+  metadata_json: string;
+}
+
+/** Health snapshot for a source. */
+export interface SourceHealth {
+  connected: boolean;
+  frames_delivered: number;
+  frames_rejected: number;
+  status: string | null;
+}
+
+/** Per-`ValidationStatus` frame counts. */
+export interface ValidationBreakdown {
+  pending: number;
+  accepted: number;
+  degraded: number;
+  rejected: number;
+  recovered: number;
+}
+
+/** Compact summary of a `.rvcsi` capture file. */
+export interface CaptureSummary {
+  capture_version: number;
+  session_id: number;
+  source_id: string;
+  adapter_kind: string;
+  frame_count: number;
+  first_timestamp_ns: number;
+  last_timestamp_ns: number;
+  channels: number[];
+  subcarrier_counts: number[];
+  mean_quality: number;
+  validation_breakdown: ValidationBreakdown;
+  calibration_version: string | null;
+}
+
+/** rvCSI runtime version string. */
+export function rvcsiVersion(): string;
+
+/** ABI version of the linked napi-c Nexmon shim (`major<<16 | minor`). */
+export function nexmonShimAbiVersion(): number;
+
+/**
+ * Decode a Buffer of "rvCSI Nexmon records" (the napi-c shim format) into
+ * validated frames. Throws on a malformed record.
+ */
+export function nexmonDecodeRecords(
+  buf: Buffer | Uint8Array,
+  sourceId: string,
+  sessionId: number,
+): CsiFrame[];
+
+/** Summarize a `.rvcsi` capture file. */
+export function inspectCaptureFile(path: string): CaptureSummary;
+
+/** Replay a `.rvcsi` capture through the DSP + event pipeline. */
+export function eventsFromCaptureFile(path: string): CsiEvent[];
+
+/** Window a capture and store each window's embedding into a JSONL RF-memory file; returns the count. */
+export function exportCaptureToRfMemory(capturePath: string, outJsonlPath: string): number;
+
+/** Streaming capture runtime: a source + the DSP stage + the event pipeline. */
+export class RvCsi {
+  private constructor(rt: unknown);
+  /** Open a `.rvcsi` capture file. */
+  static openCaptureFile(path: string): RvCsi;
+  /** Open a Nexmon capture file (concatenated rvCSI Nexmon records). */
+  static openNexmonFile(path: string, sourceId: string, sessionId: number): RvCsi;
+  /** Next exposable, validated frame, or `null` at end-of-stream. */
+  nextFrame(): CsiFrame | null;
+  /** Like {@link RvCsi.nextFrame} but with the DSP pipeline applied. */
+  nextCleanFrame(): CsiFrame | null;
+  /** Drain the rest of the stream through DSP + the event pipeline. */
+  drainEvents(): CsiEvent[];
+  /** Current health snapshot. */
+  health(): SourceHealth;
+  /** Frames pulled from the source so far. */
+  readonly framesSeen: number;
+  /** Frames dropped by validation so far. */
+  readonly framesDropped: number;
+}

v2/crates/rvcsi-node/index.js

@@ -0,0 +1,156 @@
+'use strict';
+
+// rvCSI Node.js SDK — curated public surface over the napi-rs addon.
+//
+// The compiled addon (and its loader `binding.js`) are produced by
+// `napi build --platform --release --js binding.js --dts binding.d.ts`
+// in this directory (see package.json `build` script). Until that's run,
+// `require('@ruv/rvcsi')` still succeeds — only the calls that touch the
+// native code throw, with a message explaining how to build it.
+//
+// Everything the Rust side returns as JSON is parsed here so callers get
+// plain objects (CsiFrame / CsiWindow / CsiEvent / SourceHealth /
+// CaptureSummary — see index.d.ts).
+
+let _binding = null;
+let _bindingError = null;
+
+function binding() {
+  if (_binding) return _binding;
+  if (_bindingError) throw _bindingError;
+  try {
+    // The @napi-rs/cli loader (resolves the right prebuilt .node for this platform).
+    _binding = require('./binding.js');
+  } catch (e1) {
+    try {
+      // Fallback: a sibling .node placed next to this file (e.g. a debug build).
+      _binding = require('./rvcsi-node.node');
+    } catch (e2) {
+      _bindingError = new Error(
+        'rvcsi: the native addon is not built. Build it with ' +
+          '`npm run build` here, or `napi build --platform --release ' +
+          '--js binding.js --dts binding.d.ts` in v2/crates/rvcsi-node ' +
+          '(needs the Rust toolchain + @napi-rs/cli). ' +
+          'Loader error: ' + e1.message + ' | fallback error: ' + e2.message,
+      );
+      throw _bindingError;
+    }
+  }
+  return _binding;
+}
+
+const u32 = (n) => Number(n) >>> 0;
+
+/** rvCSI runtime version string. @returns {string} */
+function rvcsiVersion() {
+  return binding().rvcsiVersion();
+}
+
+/** ABI version of the linked napi-c Nexmon shim (`major<<16 | minor`). @returns {number} */
+function nexmonShimAbiVersion() {
+  return binding().nexmonShimAbiVersion();
+}
+
+/**
+ * Decode a Buffer of "rvCSI Nexmon records" (the napi-c shim format) into an
+ * array of validated CsiFrame objects.
+ * @param {Buffer|Uint8Array} buf
+ * @param {string} sourceId
+ * @param {number} sessionId
+ * @returns {import('./index').CsiFrame[]}
+ */
+function nexmonDecodeRecords(buf, sourceId, sessionId) {
+  return JSON.parse(binding().nexmonDecodeRecords(buf, String(sourceId), u32(sessionId)));
+}
+
+/**
+ * Summarize a `.rvcsi` capture file.
+ * @param {string} path
+ * @returns {import('./index').CaptureSummary}
+ */
+function inspectCaptureFile(path) {
+  return JSON.parse(binding().inspectCaptureFile(String(path)));
+}
+
+/**
+ * Replay a `.rvcsi` capture through the DSP + event pipeline.
+ * @param {string} path
+ * @returns {import('./index').CsiEvent[]}
+ */
+function eventsFromCaptureFile(path) {
+  return JSON.parse(binding().eventsFromCaptureFile(String(path)));
+}
+
+/**
+ * Window a capture and store each window's embedding into a JSONL RF-memory file.
+ * @param {string} capturePath
+ * @param {string} outJsonlPath
+ * @returns {number} windows stored
+ */
+function exportCaptureToRfMemory(capturePath, outJsonlPath) {
+  return binding().exportCaptureToRfMemory(String(capturePath), String(outJsonlPath));
+}
+
+/** Streaming capture runtime: a source + the DSP stage + the event pipeline. */
+class RvCsi {
+  /** @param {*} rt the underlying napi RvcsiRuntime handle */
+  constructor(rt) {
+    /** @private */
+    this._rt = rt;
+  }
+
+  /** Open a `.rvcsi` capture file. @param {string} path @returns {RvCsi} */
+  static openCaptureFile(path) {
+    return new RvCsi(binding().RvcsiRuntime.openCaptureFile(String(path)));
+  }
+
+  /**
+   * Open a Nexmon capture file (concatenated rvCSI Nexmon records).
+   * @param {string} path @param {string} sourceId @param {number} sessionId @returns {RvCsi}
+   */
+  static openNexmonFile(path, sourceId, sessionId) {
+    return new RvCsi(binding().RvcsiRuntime.openNexmonFile(String(path), String(sourceId), u32(sessionId)));
+  }
+
+  /** Next exposable, validated frame, or `null` at end-of-stream. @returns {import('./index').CsiFrame|null} */
+  nextFrame() {
+    const s = this._rt.nextFrameJson();
+    return s == null ? null : JSON.parse(s);
+  }
+
+  /** Like {@link RvCsi#nextFrame} but with the DSP pipeline applied. @returns {import('./index').CsiFrame|null} */
+  nextCleanFrame() {
+    const s = this._rt.nextCleanFrameJson();
+    return s == null ? null : JSON.parse(s);
+  }
+
+  /** Drain the rest of the stream through DSP + the event pipeline. @returns {import('./index').CsiEvent[]} */
+  drainEvents() {
+    return JSON.parse(this._rt.drainEventsJson());
+  }
+
+  /** Current health snapshot. @returns {import('./index').SourceHealth} */
+  health() {
+    return JSON.parse(this._rt.healthJson());
+  }
+
+  /** Frames pulled from the source so far. @returns {number} */
+  get framesSeen() {
+    return this._rt.framesSeen;
+  }
+
+  /** Frames dropped by validation so far. @returns {number} */
+  get framesDropped() {
+    return this._rt.framesDropped;
+  }
+}
+
+module.exports = {
+  rvcsiVersion,
+  nexmonShimAbiVersion,
+  nexmonDecodeRecords,
+  inspectCaptureFile,
+  eventsFromCaptureFile,
+  exportCaptureToRfMemory,
+  RvCsi,
+};

v2/crates/rvcsi-node/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@ruv/rvcsi",
+  "version": "0.3.0",
+  "description": "rvCSI — edge RF sensing runtime: Node.js bindings (napi-rs) over the Rust CSI pipeline (ADR-095, ADR-096)",
+  "keywords": ["wifi", "csi", "rf-sensing", "presence", "napi-rs", "rvcsi"],
+  "license": "MIT OR Apache-2.0",
+  "repository": "https://github.com/ruvnet/wifi-densepose",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "engines": {
+    "node": ">=14"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "binding.js",
+    "binding.d.ts",
+    "README.md",
+    "*.node"
+  ],
+  "napi": {
+    "name": "rvcsi-node",
+    "triples": {
+      "defaults": true
+    }
+  },
+  "scripts": {
+    "build": "napi build --platform --release --js binding.js --dts binding.d.ts",
+    "build:debug": "napi build --platform --js binding.js --dts binding.d.ts",
+    "test": "node --test"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^2.18.0"
+  }
+}

v2/crates/rvcsi-node/src/lib.rs

@@ -1,14 +1,55 @@
-//! # rvCSI Node.js bindings — napi-rs (skeleton; completed during integration)
+//! # rvCSI Node.js bindings — napi-rs (ADR-095 D3/D4, ADR-096)
 //!
-//! The safe TypeScript-facing surface over the rvCSI Rust runtime
-//! (ADR-095 D3/D4, ADR-096). Nothing here exposes raw pointers; every value
-//! that crosses the boundary is a validated/normalized struct or a JSON string.
+//! The safe TypeScript-facing surface over the rvCSI Rust runtime. Nothing here
+//! exposes raw pointers; every value that crosses the boundary is either a
+//! normalized rvCSI struct *serialized to JSON* or a scalar. Frames are run
+//! through [`rvcsi_core::validate_frame`] inside [`rvcsi_runtime`] before they
+//! reach JS (D6), so a JS caller never sees a `Pending` or `Rejected` frame.
+//!
+//! All real logic lives in the `rvcsi-runtime` crate (plain Rust, unit-tested
+//! without a Node env); the `#[napi]` items below are one-liner wrappers.
+//!
+//! ## JS surface (also see the generated `index.d.ts` in the npm package)
+//!
+//! Free functions:
+//! * `rvcsiVersion(): string`
+//! * `nexmonShimAbiVersion(): number` — ABI of the linked napi-c shim
+//! * `nexmonDecodeRecords(buf: Buffer, sourceId: string, sessionId: number): string`
+//!   — JSON array of validated `CsiFrame`s decoded from the C-shim record format
+//! * `inspectCaptureFile(path: string): string` — JSON `CaptureSummary`
+//! * `eventsFromCaptureFile(path: string): string` — JSON array of `CsiEvent`s
+//! * `exportCaptureToRfMemory(capturePath: string, outJsonlPath: string): number`
+//!   — windows stored
+//!
+//! Class `RvcsiRuntime` (streaming):
+//! * `RvcsiRuntime.openCaptureFile(path): RvcsiRuntime`
+//! * `RvcsiRuntime.openNexmonFile(path, sourceId, sessionId): RvcsiRuntime`
+//! * `.nextFrameJson(): string | null` / `.nextCleanFrameJson(): string | null`
+//! * `.drainEventsJson(): string` — JSON array of `CsiEvent`s
+//! * `.healthJson(): string` — JSON `SourceHealth`
+//! * `.framesSeen` / `.framesDropped` (getters)
 
 #![deny(clippy::all)]
 
 #[macro_use]
 extern crate napi_derive;
 
+use napi::bindgen_prelude::Buffer;
+
+use rvcsi_runtime::{self as runtime, CaptureRuntime};
+
+fn napi_err(e: impl std::fmt::Display) -> napi::Error {
+    napi::Error::from_reason(e.to_string())
+}
+
+fn to_json<T: serde::Serialize>(v: &T) -> napi::Result<String> {
+    serde_json::to_string(v).map_err(napi_err)
+}
+
+// ---------------------------------------------------------------------------
+// Free functions
+// ---------------------------------------------------------------------------
+
 /// rvCSI runtime version (the workspace crate version).
 #[napi]
 pub fn rvcsi_version() -> String {
@@ -18,5 +59,108 @@ pub fn rvcsi_version() -> String {
 /// ABI version of the linked napi-c Nexmon shim (`major << 16 | minor`).
 #[napi]
 pub fn nexmon_shim_abi_version() -> u32 {
-    rvcsi_adapter_nexmon::shim_abi_version()
+    runtime::nexmon_shim_abi_version()
+}
+
+/// Decode a `Buffer` of "rvCSI Nexmon records" (the napi-c shim format) into a
+/// JSON array of validated `CsiFrame`s. Throws on a malformed record.
+#[napi]
+pub fn nexmon_decode_records(buf: Buffer, source_id: String, session_id: u32) -> napi::Result<String> {
+    let frames = runtime::decode_nexmon_records(buf.as_ref(), &source_id, session_id as u64).map_err(napi_err)?;
+    to_json(&frames)
+}
+
+/// Summarize a `.rvcsi` capture file; returns JSON for a `CaptureSummary`.
+#[napi]
+pub fn inspect_capture_file(path: String) -> napi::Result<String> {
+    let summary = runtime::summarize_capture(&path).map_err(napi_err)?;
+    to_json(&summary)
+}
+
+/// Replay a `.rvcsi` capture through the DSP + event pipeline; returns a JSON
+/// array of `CsiEvent`s.
+#[napi]
+pub fn events_from_capture_file(path: String) -> napi::Result<String> {
+    let events = runtime::events_from_capture(&path).map_err(napi_err)?;
+    to_json(&events)
+}
+
+/// Replay a `.rvcsi` capture, window it, and store each window's embedding into
+/// a JSONL RF-memory file; returns the number of windows stored.
+#[napi]
+pub fn export_capture_to_rf_memory(capture_path: String, out_jsonl_path: String) -> napi::Result<u32> {
+    let n = runtime::export_capture_to_rf_memory(&capture_path, &out_jsonl_path).map_err(napi_err)?;
+    Ok(n as u32)
+}
+
+// ---------------------------------------------------------------------------
+// Streaming runtime class
+// ---------------------------------------------------------------------------
+
+/// A streaming capture runtime: a source + the DSP stage + the event pipeline.
+#[napi]
+pub struct RvcsiRuntime {
+    inner: CaptureRuntime,
+}
+
+#[napi]
+impl RvcsiRuntime {
+    /// Open a `.rvcsi` capture file as the source.
+    #[napi(factory)]
+    pub fn open_capture_file(path: String) -> napi::Result<RvcsiRuntime> {
+        Ok(RvcsiRuntime {
+            inner: CaptureRuntime::open_capture_file(&path).map_err(napi_err)?,
+        })
+    }
+
+    /// Open a Nexmon capture file (concatenated rvCSI Nexmon records) as the source.
+    #[napi(factory)]
+    pub fn open_nexmon_file(path: String, source_id: String, session_id: u32) -> napi::Result<RvcsiRuntime> {
+        Ok(RvcsiRuntime {
+            inner: CaptureRuntime::open_nexmon_file(&path, &source_id, session_id as u64).map_err(napi_err)?,
+        })
+    }
+
+    /// Next exposable, validated frame as JSON, or `null` at end-of-stream.
+    #[napi]
+    pub fn next_frame_json(&mut self) -> napi::Result<Option<String>> {
+        match self.inner.next_validated_frame().map_err(napi_err)? {
+            Some(f) => Ok(Some(to_json(&f)?)),
+            None => Ok(None),
+        }
+    }
+
+    /// Like `nextFrameJson` but with the DSP pipeline applied (cleaned amplitude/phase).
+    #[napi]
+    pub fn next_clean_frame_json(&mut self) -> napi::Result<Option<String>> {
+        match self.inner.next_clean_frame().map_err(napi_err)? {
+            Some(f) => Ok(Some(to_json(&f)?)),
+            None => Ok(None),
+        }
+    }
+
+    /// Drain the rest of the stream through DSP + the event pipeline; JSON array of `CsiEvent`s.
+    #[napi]
+    pub fn drain_events_json(&mut self) -> napi::Result<String> {
+        let events = self.inner.drain_events().map_err(napi_err)?;
+        to_json(&events)
+    }
+
+    /// Health snapshot as JSON (`SourceHealth`).
+    #[napi]
+    pub fn health_json(&self) -> napi::Result<String> {
+        to_json(&self.inner.health())
+    }
+
+    /// Frames pulled from the source so far.
+    #[napi(getter)]
+    pub fn frames_seen(&self) -> u32 {
+        self.inner.frames_seen() as u32
+    }
+
+    /// Frames dropped by validation so far.
+    #[napi(getter)]
+    pub fn frames_dropped(&self) -> u32 {
+        self.inner.frames_dropped() as u32
+    }
 }