@dxos/pipeline-transcription 0.0.0

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@dxos/pipeline-transcription",
+  "version": "0.0.0",
+  "description": "Streaming stage pipeline for transcription post-processing (correction, entity extraction, summarization).",
+  "homepage": "https://dxos.org",
+  "bugs": "https://github.com/dxos/dxos/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
+  "license": "FSL-1.1-Apache-2.0",
+  "author": "info@dxos.org",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/types/src/index.d.ts",
+      "default": "./dist/lib/neutral/index.mjs"
+    },
+    "./testing": {
+      "source": "./src/testing/index.ts",
+      "types": "./dist/types/src/testing/index.d.ts",
+      "default": "./dist/lib/neutral/testing/index.mjs"
+    }
+  },
+  "types": "dist/types/src/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@dxos/ai": "workspace:*",
+    "@dxos/assistant": "workspace:*",
+    "@dxos/async": "workspace:*",
+    "@dxos/compute": "workspace:*",
+    "@dxos/config": "workspace:*",
+    "@dxos/context": "workspace:*",
+    "@dxos/echo": "workspace:*",
+    "@dxos/effect": "workspace:*",
+    "@dxos/invariant": "workspace:*",
+    "@dxos/keys": "workspace:*",
+    "@dxos/log": "workspace:*",
+    "@dxos/pipeline": "workspace:*",
+    "@dxos/tracing": "workspace:*",
+    "@dxos/types": "workspace:*",
+    "@effect/ai": "catalog:",
+    "wavefile": "catalog:"
+  },
+  "devDependencies": {
+    "@dxos/echo-client": "workspace:*",
+    "effect": "catalog:"
+  },
+  "peerDependencies": {
+    "effect": "catalog:"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "beast": {}
+}

package/src/PipelineConfig.test.ts

@@ -0,0 +1,39 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { DXN } from '@dxos/echo';
+
+import { resolveModel } from './model-routing';
+import { DEFAULT_STAGE_MODEL, findPreset } from './PipelineConfig';
+import { makeCorrectionStage } from './stages';
+
+describe('PipelineConfig', () => {
+  test('meeting preset enables the three real stages in order', ({ expect }) => {
+    const enabled = findPreset('Meeting')!
+      .stages.filter((stage) => stage.enabled)
+      .map((stage) => stage.id);
+    expect(enabled).toEqual(['correct', 'extract', 'summarize']);
+  });
+
+  test('notes preset runs correction only', ({ expect }) => {
+    const enabled = findPreset('Notes')!
+      .stages.filter((stage) => stage.enabled)
+      .map((stage) => stage.id);
+    expect(enabled).toEqual(['correct']);
+  });
+});
+
+describe('resolveModel', () => {
+  test('config override beats stage default beats preset default', ({ expect }) => {
+    const stage = makeCorrectionStage();
+    const override = DXN.make('com.meta.model.llama-3-2-1b.instruct');
+    expect(resolveModel({ id: 'correct', enabled: true, model: override }, stage)).toEqual(override);
+    expect(resolveModel(undefined, stage)).toEqual(stage.model);
+    expect(resolveModel({ id: 'correct', enabled: true }, { ...stage, model: undefined }, DEFAULT_STAGE_MODEL)).toEqual(
+      DEFAULT_STAGE_MODEL,
+    );
+  });
+});

package/src/PipelineConfig.ts

@@ -0,0 +1,71 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { DXN, Obj, Type } from '@dxos/echo';
+
+/** Cheap, fast default for all stages; same model used by `update-chat-name` / `qualifier`. */
+export const DEFAULT_STAGE_MODEL: DXN.DXN = DXN.make('com.anthropic.model.claude-haiku-4-5.default');
+
+/** Per-stage configuration entry within a {@link PipelineConfig}. */
+export const StageConfig = Schema.Struct({
+  /** Stage id (matches a registered `Stage.id`). */
+  id: Schema.String,
+  enabled: Schema.Boolean,
+  /** Optional per-stage model override (an NSID name); resolved by the runtime. */
+  model: Schema.optional(DXN.NameSchema),
+  /** Optional sliding-window override in blocks. Positive integer; bad values fail validation. */
+  window: Schema.optional(Schema.Struct({ blocks: Schema.Number.pipe(Schema.int(), Schema.positive()) })),
+});
+export type StageConfig = Schema.Schema.Type<typeof StageConfig>;
+
+/**
+ * Ordered, persisted configuration that drives a {@link PipelineRuntime}: which stages run, in what
+ * order, with which model and window. Presets ("Meeting", "Notes") are seeded instances.
+ */
+export class PipelineConfig extends Type.makeObject<PipelineConfig>(
+  DXN.make('org.dxos.type.transcriptionPipelineConfig', '0.1.0'),
+)(
+  Schema.Struct({
+    name: Schema.String,
+    stages: Schema.mutable(Schema.Array(StageConfig)),
+  }),
+) {}
+
+/** A plain preset descriptor (used to seed a {@link PipelineConfig} object). */
+export type PipelinePreset = {
+  name: string;
+  stages: StageConfig[];
+};
+
+/**
+ * Built-in presets. `Meeting` runs the three real stages; `Notes` runs correction (+ extraction)
+ * and streams into the editor without a cumulative summary.
+ */
+export const PIPELINE_PRESETS: readonly PipelinePreset[] = Object.freeze([
+  {
+    name: 'Meeting',
+    stages: [
+      { id: 'correct', enabled: true },
+      { id: 'extract', enabled: true },
+      { id: 'summarize', enabled: true },
+    ],
+  },
+  {
+    name: 'Notes',
+    stages: [
+      { id: 'correct', enabled: true },
+      { id: 'extract', enabled: false },
+      { id: 'summarize', enabled: false },
+    ],
+  },
+]);
+
+export const findPreset = (name: string): PipelinePreset | undefined =>
+  PIPELINE_PRESETS.find((preset) => preset.name === name);
+
+/** Instantiate a `PipelineConfig` ECHO object from a preset descriptor. */
+export const makeConfigFromPreset = (preset: PipelinePreset): PipelineConfig =>
+  Obj.make(PipelineConfig, { name: preset.name, stages: preset.stages.map((stage) => ({ ...stage })) });

package/src/PipelineRuntime.test.ts

@@ -0,0 +1,74 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Stream from 'effect/Stream';
+import { describe, test } from 'vitest';
+
+import { EffectEx } from '@dxos/effect';
+
+import { captureCommit } from './dispatch';
+import { PipelineRuntime, type TelemetryEvent } from './PipelineRuntime';
+import { type Stage, StageWrite } from './Stage';
+import { makeCorrectionStage, makeSummarizationStage } from './stages';
+import { SAMPLE_MEETING, scriptedSource } from './testing';
+import { TranscriptEvent } from './TranscriptEvent';
+
+describe('PipelineRuntime', () => {
+  test('runs correction per block and summarizes on silence', async ({ expect }) => {
+    const { commit, writes } = captureCommit();
+    await EffectEx.runPromise(
+      PipelineRuntime.run({
+        source: scriptedSource(SAMPLE_MEETING),
+        stages: [makeCorrectionStage(), makeSummarizationStage()],
+        commit,
+      }),
+    );
+
+    const corrected = writes.flatMap((write) => write.blockUpdates ?? []).map((update) => update.corrected);
+    expect(corrected).toContain('So i think we should ship munich on friday.');
+
+    const summaries = writes.map((write) => write.transcriptUpdate?.summary).filter(Boolean);
+    expect(summaries.length).toBeGreaterThan(0);
+  });
+
+  test('honours disabled stage config', async ({ expect }) => {
+    const { commit, writes } = captureCommit();
+    await EffectEx.runPromise(
+      PipelineRuntime.run({
+        source: scriptedSource(SAMPLE_MEETING),
+        stages: [makeCorrectionStage()],
+        configs: [{ id: 'correct', enabled: false }],
+        commit,
+      }),
+    );
+    expect(writes).toHaveLength(0);
+  });
+
+  test('latest-wins coalesces stale work under load without interrupting', async ({ expect }) => {
+    const telemetry: TelemetryEvent[] = [];
+    // A slow stage over three synchronously-delivered blocks: sliding overflow replaces stale queued
+    // work with the latest (rather than interrupting the in-flight run), so fewer than three runs
+    // commit and every reported outcome is a clean commit (no interrupt/error signal).
+    const slow: Stage<{ window: any[] }> = {
+      id: 'slow',
+      trigger: 'per-block',
+      concurrency: 'latest-wins',
+      run: () => Effect.sleep('50 millis').pipe(Effect.as(StageWrite.empty())),
+    };
+    const { commit } = captureCommit();
+    const source = Stream.fromIterable([
+      TranscriptEvent.block({ _tag: 'transcript', started: 's', text: 'one' }),
+      TranscriptEvent.block({ _tag: 'transcript', started: 's', text: 'two' }),
+      TranscriptEvent.block({ _tag: 'transcript', started: 's', text: 'three' }),
+    ]);
+    await EffectEx.runPromise(
+      PipelineRuntime.run({ source, stages: [slow], commit, onTelemetry: (event) => telemetry.push(event) }),
+    );
+    const committed = telemetry.filter((event) => event.outcome === 'committed');
+    expect(committed.length).toBeGreaterThan(0);
+    expect(committed.length).toBeLessThan(3);
+    expect(telemetry.every((event) => event.outcome === 'committed')).toBe(true);
+  });
+});

package/src/PipelineRuntime.ts

@@ -0,0 +1,192 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Cause from 'effect/Cause';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import { pipe } from 'effect/Function';
+import * as Stream from 'effect/Stream';
+
+import { DXN } from '@dxos/echo';
+import { log } from '@dxos/log';
+import { Pipeline, Stage as PipelineStage } from '@dxos/pipeline';
+import { type ContentBlock } from '@dxos/types';
+
+import { type EntityLookup } from './lookup';
+import { resolveModel } from './model-routing';
+import { type StageConfig } from './PipelineConfig';
+import { type Stage, type StageContext, type StageWrite } from './Stage';
+import { type TranscriptEvent } from './TranscriptEvent';
+
+/** Upper bound on retained blocks; bounds memory for long sessions (stages slice their own window). */
+const MAX_WINDOW = 128;
+
+/** Backpressure lag (in chunks) the broadcast driver may run ahead of the slowest branch. */
+const BROADCAST_BUFFER = 128;
+
+/**
+ * Commits a stage's output to storage. Receives the exact window slice the stage was invoked with,
+ * so `BlockUpdate.index` can be resolved against the originating blocks.
+ */
+export type CommitFn = (write: StageWrite, window: readonly ContentBlock.Transcript[]) => Effect.Effect<void>;
+
+/**
+ * Outcome reported per stage invocation. The `sliding`/`dropping` overflow model has no fiber-level
+ * signal for stale work, so only `committed` and `error` are reported (the previous fiber-based
+ * runtime also surfaced `interrupted`/`skipped`).
+ */
+export type StageOutcome = 'committed' | 'error';
+
+export type TelemetryEvent = {
+  readonly stageId: string;
+  readonly model: DXN.DXN;
+  readonly trigger: TranscriptEvent['kind'];
+  readonly durationMs: number;
+  readonly outcome: StageOutcome;
+};
+
+export type RunOptions = {
+  /** The continuous transcript event stream (ASR source or a scripted fixture). */
+  readonly source: Stream.Stream<TranscriptEvent>;
+  /** Ordered stages to run. */
+  readonly stages: readonly Stage<any, any>[];
+  /** Sink for stage outputs (in-memory capture in tests; ECHO dispatcher in production). */
+  readonly commit: CommitFn;
+  /** Entity-reference resolver injected into each stage context (backend-agnostic). */
+  readonly lookup?: EntityLookup;
+  /** Per-stage configuration (enabled / model / window). Absent → stage runs with its defaults. */
+  readonly configs?: readonly StageConfig[];
+  /** Default model when neither config nor stage specifies one. */
+  readonly presetDefault?: DXN.DXN;
+  /** Optional telemetry sink (drives the testbench). */
+  readonly onTelemetry?: (event: TelemetryEvent) => void;
+};
+
+/** A window slice a stage is invoked over; the commit resolves `BlockUpdate.index` against it. */
+type Slice = ContentBlock.Transcript[];
+
+/** A stage invocation's output paired with the slice it ran over (needed by {@link CommitFn}). */
+type Enriched = { readonly write: StageWrite; readonly window: Slice };
+
+/**
+ * Private bridge between this module's plain `StageContext` object and `@dxos/pipeline`'s
+ * Requirements-based `Stage`. Not part of any public contract: stage authors (see `Stage.ts`) keep
+ * receiving `ctx: StageContext` as an explicit parameter; only this module's internal wiring into
+ * `@dxos/pipeline` goes through Effect's Context/Layer mechanism.
+ */
+class StageContextService extends Context.Tag('@dxos/pipeline-transcription/StageContextService')<
+  StageContextService,
+  StageContext
+>() {}
+
+const triggerMatches = (stage: Stage<any, any>, kind: TranscriptEvent['kind']): boolean =>
+  (stage.trigger === 'per-block' && kind === 'block') ||
+  (stage.trigger === 'on-silence' && kind === 'silence') ||
+  (stage.trigger === 'periodic' && kind === 'tick');
+
+const triggerKind = (stage: Stage<any, any>): TranscriptEvent['kind'] =>
+  stage.trigger === 'per-block' ? 'block' : stage.trigger === 'on-silence' ? 'silence' : 'tick';
+
+/**
+ * Per-stage window + trigger, as a `@dxos/pipeline` stage. Maintains this branch's own rolling block
+ * window (blocks appended, capped at {@link MAX_WINDOW}) and emits the window slice on events matching
+ * the stage's trigger; otherwise it filters the item out, so a non-triggering event never reaches
+ * {@link runStage}.
+ */
+const windowTrigger = (
+  stage: Stage<any, any>,
+  config: StageConfig | undefined,
+): PipelineStage.Stage<TranscriptEvent, Slice> => {
+  const blocks = config?.window?.blocks ?? stage.window?.blocks;
+  return (input) =>
+    input.pipe(
+      Stream.mapAccum([] as Slice, (window, event) => {
+        const next = event.kind === 'block' ? [...window, event.block].slice(-MAX_WINDOW) : window;
+        const slice = triggerMatches(stage, event.kind) ? (blocks ? next.slice(-blocks) : next) : undefined;
+        return [next, slice];
+      }),
+      Stream.filter((slice): slice is Slice => slice !== undefined),
+    );
+};
+
+/**
+ * Runs the stage over a triggered slice, pairing its write with that slice. Per-stage `overflow`
+ * enforces concurrency: `latest-wins → sliding` (a newer slice replaces the queued one), `skip-if-busy
+ * → dropping` (new slices dropped while a run is in flight). Neither interrupts the in-flight run —
+ * errors are logged + reported and swallowed (emit `undefined` → no commit), as before.
+ */
+const runStage = (
+  stage: Stage<any, any>,
+  config: StageConfig | undefined,
+  presetDefault: DXN.DXN | undefined,
+  onTelemetry?: (event: TelemetryEvent) => void,
+): PipelineStage.Stage<Slice, Enriched, never, StageContextService> => {
+  const model = resolveModel(config, stage, presetDefault);
+  const trigger = triggerKind(stage);
+  return PipelineStage.map(
+    stage.id,
+    (slice: Slice) =>
+      Effect.gen(function* () {
+        const context = yield* StageContextService;
+        const started = yield* Effect.sync(() => Date.now());
+        const input = stage.select ? stage.select(slice) : { window: slice };
+        const write = yield* stage.run(input, context);
+        const durationMs = (yield* Effect.sync(() => Date.now())) - started;
+        onTelemetry?.({ stageId: stage.id, model, trigger, durationMs, outcome: 'committed' });
+        return { write, window: slice };
+      }).pipe(
+        Effect.catchAllCause((cause) =>
+          Effect.sync(() => {
+            log.catch(Cause.squash(cause));
+            onTelemetry?.({ stageId: stage.id, model, trigger, durationMs: 0, outcome: 'error' });
+            return undefined;
+          }),
+        ),
+      ),
+    { overflow: stage.concurrency === 'latest-wins' ? 'sliding' : 'dropping', bufferSize: 1 },
+  );
+};
+
+/**
+ * Drive each stage's discrete invocations off the event stream. Stages are peers, not a chain: the
+ * event stream is broadcast to one `@dxos/pipeline` per enabled stage (each with its own window,
+ * trigger, and overflow), all committing to a shared sink. Resolves once the source ends and every
+ * branch has drained.
+ */
+const run = (options: RunOptions): Effect.Effect<void> =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const { source, stages, commit, lookup, configs, presetDefault, onTelemetry } = options;
+      const configFor = (id: string): StageConfig | undefined => configs?.find((config) => config.id === id);
+      const enabled = stages.filter((stage) => configFor(stage.id)?.enabled ?? true);
+      if (enabled.length === 0) {
+        return yield* Stream.runDrain(source);
+      }
+
+      // Isolate commit failures per write: a failed commit must not fail its branch (which, under the
+      // unbounded `Effect.forEach`, would interrupt the sibling branches). Log and drop instead.
+      const sink: Pipeline.Sink<Enriched> = ({ write, window }) =>
+        commit(write, window).pipe(Effect.catchAllCause((cause) => Effect.sync(() => log.catch(Cause.squash(cause)))));
+      const branches = yield* source.pipe(Stream.broadcast(enabled.length, BROADCAST_BUFFER));
+
+      yield* Effect.forEach(
+        branches,
+        (branch, index) => {
+          const stage = enabled[index];
+          const config = configFor(stage.id);
+          const context: StageContext = { lookup, model: resolveModel(config, stage, presetDefault) };
+          return pipe(
+            branch,
+            windowTrigger(stage, config),
+            runStage(stage, config, presetDefault, onTelemetry),
+            Pipeline.run({ sink }),
+            Effect.provideService(StageContextService, context),
+          );
+        },
+        { concurrency: 'unbounded', discard: true },
+      );
+    }),
+  );
+
+export const PipelineRuntime = Object.freeze({ run });

package/src/Stage.ts

@@ -0,0 +1,86 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import type * as Effect from 'effect/Effect';
+
+import { DXN, type Ref } from '@dxos/echo';
+import { type ContentBlock } from '@dxos/types';
+
+import { type EntityLookup } from './lookup';
+
+/**
+ * When a stage's discrete computation fires, relative to the pipeline stream.
+ * - `per-block`: on every new transcript block.
+ * - `on-silence`: when the speaker pauses (silence edge).
+ * - `periodic`: on a timer tick.
+ */
+export type StageTrigger = 'per-block' | 'on-silence' | 'periodic';
+
+/**
+ * Policy applied when a stage is triggered while a previous invocation is still in flight.
+ * - `latest-wins`: interrupt the in-flight invocation and start a new one over the latest window.
+ * - `skip-if-busy`: drop the new trigger and let the in-flight invocation complete.
+ */
+export type StageConcurrency = 'latest-wins' | 'skip-if-busy';
+
+/** Fields of a transcript block that stages may patch. */
+export type BlockPatch = Partial<{
+  corrected: string;
+  references: Ref.Ref<any>[];
+  candidates: ContentBlock.Candidate[];
+  translation: string;
+}>;
+
+/** A patch to a single block, keyed by its index within the window snapshot passed to the stage. */
+export type BlockUpdate = { index: number } & BlockPatch;
+
+/** A patch to the `Transcript` object itself. */
+export type TranscriptUpdate = Partial<{
+  summary: string;
+  summaryUpdatedAt: string;
+  resolvedReferents: { surface: string; referent: string; ref?: Ref.Ref<any> }[];
+}>;
+
+/** The result of a stage invocation: a typed description of ECHO mutations. */
+export type StageWrite = {
+  blockUpdates?: BlockUpdate[];
+  transcriptUpdate?: TranscriptUpdate;
+};
+
+export const StageWrite = Object.freeze({
+  blocks: (blockUpdates: BlockUpdate[]): StageWrite => ({ blockUpdates }),
+  transcript: (transcriptUpdate: TranscriptUpdate): StageWrite => ({ transcriptUpdate }),
+  empty: (): StageWrite => ({}),
+});
+
+/** Context supplied to a stage's `run` by the runtime. */
+export type StageContext = {
+  /** Resolves entity references for extraction. Backend-agnostic (full-text, vector, …). */
+  readonly lookup?: EntityLookup;
+  /** The model resolved for this stage by the runtime (config → stage → preset default). */
+  readonly model: DXN.DXN;
+};
+
+/**
+ * A pipeline stage: a discrete, repeatedly-invoked transform over a window of the transcript stream.
+ *
+ * The runtime — not the stage — owns the continuous stream; it builds `input` from a window snapshot
+ * (`select`) and invokes `run` once per trigger, enforcing `concurrency` and injecting `model`.
+ *
+ * LLM-backed stages delegate `run` to an `Operation` (typed I/O, memoized-LLM tests, standalone
+ * re-invocation). Pure stages implement `run` directly.
+ */
+export interface Stage<In = unknown, E = unknown> {
+  readonly id: string;
+  readonly trigger: StageTrigger;
+  /** Sliding context size in blocks. Absent → the runtime passes the full current window. */
+  readonly window?: { blocks: number };
+  readonly concurrency: StageConcurrency;
+  /** Default model for the stage; overridden by per-stage config in the runtime. */
+  readonly model?: DXN.DXN;
+  /** Build the stage input from the current window snapshot. Defaults to `{ window }`. */
+  readonly select?: (window: ContentBlock.Transcript[]) => In;
+  /** The discrete per-trigger computation. */
+  run(input: In, ctx: StageContext): Effect.Effect<StageWrite, E>;
+}

package/src/TranscriptEvent.ts

@@ -0,0 +1,23 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type ContentBlock } from '@dxos/types';
+
+/**
+ * Events flowing through the pipeline stream. The runtime owns this continuous stream and slices
+ * it into bounded windows that drive discrete stage invocations.
+ */
+export type TranscriptEvent =
+  | { kind: 'block'; block: ContentBlock.Transcript }
+  | { kind: 'silence'; sinceMs: number }
+  | { kind: 'tick' };
+
+export const TranscriptEvent = Object.freeze({
+  /** A new transcript block was appended by the ASR source. */
+  block: (block: ContentBlock.Transcript): TranscriptEvent => ({ kind: 'block', block }),
+  /** The speaker has been silent for `sinceMs` milliseconds. */
+  silence: (sinceMs: number): TranscriptEvent => ({ kind: 'silence', sinceMs }),
+  /** Periodic timer tick (drives periodic-trigger stages). */
+  tick: (): TranscriptEvent => ({ kind: 'tick' }),
+});

package/src/asr/audio-recorder.ts

@@ -0,0 +1,56 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export type AudioChunk = {
+  /**
+   * Timestamp of the beginning of the chunk.
+   */
+  timestamp: number;
+
+  /**
+   * 16-bit PCM data.
+   */
+  data: Float64Array;
+};
+
+export type WavConfig = {
+  channels: number;
+  sampleRate: number;
+  bitDepthCode: string;
+};
+
+/**
+ * Records MediaStreamTrack to Uint8Array 16-bit PCM data.
+ * The data is passed to the onChunk callback with the timestamp of the chunk.
+ * All chunks are aligned and sequential.
+ * Time ─────────────────────────────────────────────────►
+ *
+ * Recording:
+ * t1    ┌──────┐
+ * t2    ┌──────┬──────┐
+ * t3    ┌──────┬──────┬──────┐
+ * t4    ┌──────┬──────┬──────┬──────┐
+ *       └──────┴──────┴──────┴──────┘
+ *         1st     2nd     3rd     4th
+ *        chunk   chunk   chunk   chunk
+ *
+ */
+export interface AudioRecorder {
+  wavConfig: WavConfig;
+
+  /**
+   * Sets callback for receiving audio chunks.
+   */
+  setOnChunk(onChunk: (chunk: AudioChunk) => void): void;
+
+  /**
+   * Starts the recorder.
+   */
+  start(): Promise<void>;
+
+  /**
+   * Stops the recorder.
+   */
+  stop(): Promise<void>;
+}

package/src/asr/index.ts

@@ -0,0 +1,8 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './audio-recorder';
+export * from './sentence-buffer';
+export * from './transcriber';
+export * from './pipeline';