@dxos/pipeline-transcription 0.0.0

package/dist/types/src/PipelineRuntime.test.d.ts.map

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

package/dist/types/src/Stage.d.ts

@@ -0,0 +1,80 @@
+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 declare const StageWrite: Readonly<{
+    blocks: (blockUpdates: BlockUpdate[]) => StageWrite;
+    transcript: (transcriptUpdate: TranscriptUpdate) => StageWrite;
+    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>;
+}
+//# sourceMappingURL=Stage.d.ts.map

package/dist/types/src/Stage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Stage.d.ts","sourceRoot":"","sources":["../../../src/Stage.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAE7C,OAAO,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,YAAY,GAAG,UAAU,CAAC;AAEnE;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG,cAAc,CAAC;AAE9D,0DAA0D;AAC1D,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;IAC3B,UAAU,EAAE,YAAY,CAAC,SAAS,EAAE,CAAC;IACrC,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC,CAAC;AAEH,oGAAoG;AACpG,MAAM,MAAM,WAAW,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,UAAU,CAAC;AAEzD,iDAAiD;AACjD,MAAM,MAAM,gBAAgB,GAAG,OAAO,CAAC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;KAAE,EAAE,CAAC;CAChF,CAAC,CAAC;AAEH,+EAA+E;AAC/E,MAAM,MAAM,UAAU,GAAG;IACvB,YAAY,CAAC,EAAE,WAAW,EAAE,CAAC;IAC7B,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC,CAAC;AAEF,eAAO,MAAM,UAAU;2BACE,WAAW,EAAE,KAAG,UAAU;mCAClB,gBAAgB,KAAG,UAAU;iBACjD,UAAU;EACrB,CAAC;AAEH,0DAA0D;AAC1D,MAAM,MAAM,YAAY,GAAG;IACzB,0FAA0F;IAC1F,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B,0FAA0F;IAC1F,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,GAAG,CAAC;CACzB,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,WAAW,KAAK,CAAC,EAAE,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO;IAC9C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,2FAA2F;IAC3F,QAAQ,CAAC,MAAM,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACrC,QAAQ,CAAC,WAAW,EAAE,gBAAgB,CAAC;IACvC,kFAAkF;IAClF,QAAQ,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC;IACzB,wFAAwF;IACxF,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,CAAC,UAAU,EAAE,KAAK,EAAE,CAAC;IAC5D,4CAA4C;IAC5C,GAAG,CAAC,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;CACjE"}

package/dist/types/src/TranscriptEvent.d.ts

@@ -0,0 +1,23 @@
+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 declare const TranscriptEvent: Readonly<{
+    /** A new transcript block was appended by the ASR source. */
+    block: (block: ContentBlock.Transcript) => TranscriptEvent;
+    /** The speaker has been silent for `sinceMs` milliseconds. */
+    silence: (sinceMs: number) => TranscriptEvent;
+    /** Periodic timer tick (drives periodic-trigger stages). */
+    tick: () => TranscriptEvent;
+}>;
+//# sourceMappingURL=TranscriptEvent.d.ts.map

package/dist/types/src/TranscriptEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TranscriptEvent.d.ts","sourceRoot":"","sources":["../../../src/TranscriptEvent.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD;;;GAGG;AACH,MAAM,MAAM,eAAe,GACvB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,YAAY,CAAC,UAAU,CAAA;CAAE,GACjD;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAErB,eAAO,MAAM,eAAe;IAC1B,6DAA6D;mBAC9C,YAAY,CAAC,UAAU,KAAG,eAAe;IACxD,8DAA8D;uBAC3C,MAAM,KAAG,eAAe;IAC3C,4DAA4D;gBAClD,eAAe;EACzB,CAAC"}

package/dist/types/src/asr/audio-recorder.d.ts

@@ -0,0 +1,47 @@
+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>;
+}
+//# sourceMappingURL=audio-recorder.d.ts.map

package/dist/types/src/asr/audio-recorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio-recorder.d.ts","sourceRoot":"","sources":["../../../../src/asr/audio-recorder.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,UAAU,GAAG;IACvB;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,IAAI,EAAE,YAAY,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,SAAS,CAAC;IAErB;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,GAAG,IAAI,CAAC;IAEvD;;OAEG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB;;OAEG;IACH,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB"}

package/dist/types/src/asr/index.d.ts

@@ -0,0 +1,5 @@
+export * from './audio-recorder';
+export * from './sentence-buffer';
+export * from './transcriber';
+export * from './pipeline';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/asr/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/asr/index.ts"],"names":[],"mappings":"AAIA,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC"}

package/dist/types/src/asr/pipeline.d.ts

@@ -0,0 +1,42 @@
+import { type ContentBlock } from '@dxos/types';
+import { type RunOptions } from '../PipelineRuntime';
+import { type AudioRecorder } from './audio-recorder';
+import { type TranscribeConfig, type TranscribeFn } from './transcriber';
+export type AsrPipelineOptions = Omit<RunOptions, 'source'> & {
+    /** Audio source — browser `MediaStreamRecorder` or any `AudioRecorder` implementation. */
+    recorder: AudioRecorder;
+    /** Optional ASR transport override (default: `fetch` to the edge transcription service). */
+    transcribe?: TranscribeFn;
+    /** Transcriber chunking configuration. */
+    config: TranscribeConfig;
+    /**
+     * Re-segment the ASR output into complete sentences before it enters the pipeline, merging
+     * fragments that the transcriber cut mid-sentence at chunk boundaries. @default false
+     */
+    segmentSentences?: boolean;
+    /** Optional raw-segment hook invoked before each block enters the pipeline (e.g. live display). */
+    onSegment?: (block: ContentBlock.Transcript) => void;
+    /** Silence (ms) reported on `end` so on-silence stages fire over the final window. */
+    drainSilenceMs?: number;
+};
+/** Imperative handle to a running ASR → pipeline session. */
+export type AsrPipeline = {
+    /** Open the recorder + transcriber. */
+    open: () => Promise<void>;
+    /** Begin capturing audio for transcription. */
+    start: () => void;
+    /** Stop capturing (buffered audio is still flushed by `end`). */
+    stop: () => void;
+    /** Abort the in-flight transcription request. */
+    abort: () => void;
+    /** Flush buffered audio, signal silence, and drain the pipeline. */
+    end: () => Promise<void>;
+};
+/**
+ * The single end-to-end wiring: an ASR source ({@link Transcriber}) feeding the live orchestration
+ * engine ({@link runLivePipeline}). Every consumer (editor driver, message-list recording, stories)
+ * differs only by recorder, stages, and commit sink — this is the one place audio → text → stages →
+ * sink is assembled.
+ */
+export declare const runAsrPipeline: ({ recorder, transcribe, config, segmentSentences, onSegment, drainSilenceMs, ...runOptions }: AsrPipelineOptions) => AsrPipeline;
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/types/src/asr/pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../../../src/asr/pipeline.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAGhD,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,YAAY,EAAe,MAAM,eAAe,CAAC;AAEtF,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,GAAG;IAC5D,0FAA0F;IAC1F,QAAQ,EAAE,aAAa,CAAC;IACxB,4FAA4F;IAC5F,UAAU,CAAC,EAAE,YAAY,CAAC;IAC1B,0CAA0C;IAC1C,MAAM,EAAE,gBAAgB,CAAC;IACzB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,mGAAmG;IACnG,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,CAAC,UAAU,KAAK,IAAI,CAAC;IACrD,sFAAsF;IACtF,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,6DAA6D;AAC7D,MAAM,MAAM,WAAW,GAAG;IACxB,uCAAuC;IACvC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,+CAA+C;IAC/C,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,iEAAiE;IACjE,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,iDAAiD;IACjD,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,oEAAoE;IACpE,GAAG,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,iGAQxB,kBAAkB,KAAG,WA8CvB,CAAC"}

package/dist/types/src/asr/sentence-buffer.d.ts

@@ -0,0 +1,25 @@
+import { type ContentBlock } from '@dxos/types';
+/**
+ * Splits text into complete sentences plus a trailing incomplete remainder.
+ *
+ * A run of `.`/`!`/`?` followed by whitespace or end-of-string terminates a sentence; an ellipsis
+ * (`..`+) is treated as non-terminal so mid-thought pauses keep accumulating. Abbreviations are not
+ * special-cased — this is a deterministic heuristic, not a full sentence tokenizer.
+ */
+export declare const splitSentences: (text: string) => {
+    sentences: string[];
+    rest: string;
+};
+/**
+ * Accumulates ASR fragments (which cut mid-sentence at chunk boundaries) and re-emits complete,
+ * sentence-aligned transcript blocks. Each emitted block inherits the `started` timestamp of the
+ * fragment that began the sentence. `flush` emits whatever remains (e.g. on stop).
+ */
+export declare class SentenceBuffer {
+    #private;
+    /** Append a fragment; returns any complete sentences it produced. */
+    push(block: ContentBlock.Transcript): ContentBlock.Transcript[];
+    /** Emit any buffered text as a final sentence. */
+    flush(): ContentBlock.Transcript[];
+}
+//# sourceMappingURL=sentence-buffer.d.ts.map

package/dist/types/src/asr/sentence-buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sentence-buffer.d.ts","sourceRoot":"","sources":["../../../../src/asr/sentence-buffer.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,SAAU,MAAM,KAAG;IAAE,SAAS,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CA0BhF,CAAC;AAEF;;;;GAIG;AACH,qBAAa,cAAc;;IAIzB,qEAAqE;IACrE,IAAI,CAAC,KAAK,EAAE,YAAY,CAAC,UAAU,GAAG,YAAY,CAAC,UAAU,EAAE,CAuB9D;IAED,kDAAkD;IAClD,KAAK,IAAI,YAAY,CAAC,UAAU,EAAE,CASjC;CACF"}

package/dist/types/src/asr/sentence-buffer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sentence-buffer.test.d.ts.map

package/dist/types/src/asr/sentence-buffer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sentence-buffer.test.d.ts","sourceRoot":"","sources":["../../../../src/asr/sentence-buffer.test.ts"],"names":[],"mappings":""}

package/dist/types/src/asr/transcriber.d.ts

@@ -0,0 +1,115 @@
+import { type Context, Resource } from '@dxos/context';
+import { type ContentBlock } from '@dxos/types';
+import { type AudioChunk, type AudioRecorder } from './audio-recorder';
+export type WhisperWord = {
+    word: string;
+    /**
+     * Time in seconds from the start of the audio.
+     */
+    start: number;
+    /**
+     * Time in seconds from the start of the audio.
+     */
+    end: number;
+};
+export type WhisperSegment = {
+    text: string;
+    /**
+     * Time in seconds from the start of the audio.
+     */
+    start: number;
+    /**
+     * Time in seconds from the start of the audio.
+     */
+    end: number;
+    /**
+     * Probability of no speech in the segment.
+     */
+    no_speech_prob: number;
+    words: WhisperWord[];
+};
+export type TranscribeConfig = {
+    /**
+     * Number of chunks to transcribe automatically after.
+     */
+    transcribeAfterChunksAmount: number;
+    /**
+     * Number of chunks to save before the user starts speaking.
+     * This is needed to catch the beginning of the user's speech.
+     */
+    prefixBufferChunksAmount: number;
+    /**
+     * Override the transcription endpoint base URL.
+     * Defaults to the DXOS calls service.
+     */
+    endpoint?: string;
+};
+/**
+ * Function that converts a base64-encoded WAV payload into Whisper segments.
+ * Allows callers to swap in alternative providers or mock the transport.
+ */
+export type TranscribeFn = (audio: string) => Promise<WhisperSegment[]>;
+export type TranscriberProps = {
+    config: TranscribeConfig;
+    recorder: AudioRecorder;
+    /**
+     * Optional override of the transcription transport. When provided, supersedes `config.endpoint`.
+     */
+    transcribe?: TranscribeFn;
+    /**
+     * Callback to handle the transcribed segments, after all segment transformers are applied.
+     * @param segments - The transcribed segments.
+     */
+    onSegments: (segments: ContentBlock.Transcript[]) => Promise<void>;
+};
+/**
+ * Handles transcription of audio chunks.
+ * If user is not speaking, the last `minChunksAmount` chunks are saved and transcribed.
+ * If user is speaking, the chunks are added to the buffer until the user is done talking.
+ */
+export declare class Transcriber extends Resource {
+    private _audioChunks;
+    private _lastTimestamp;
+    private readonly _openTrigger;
+    private readonly _config;
+    private readonly _recorder;
+    private readonly _onSegments;
+    private readonly _transcribeFn?;
+    private _recording;
+    private _transcribeTask?;
+    /** Aborts the in-flight transcription request (e.g. when the user cancels the drain). */
+    private _transcribeAbort?;
+    constructor({ config, recorder, onSegments, transcribe }: TranscriberProps);
+    protected _open(ctx: Context): Promise<void>;
+    protected _close(): Promise<void>;
+    /** Abort the in-flight transcription request (e.g. user cancelled the drain). */
+    abort(): void;
+    startChunksRecording(): void;
+    stopChunksRecording(): void;
+    /**
+     * Stop recording and transcribe any buffered audio, resolving once the final segments have been
+     * delivered via `onSegments`. Used to drain the pipeline when recording stops so the tail of speech
+     * (and its downstream enrichment) is not lost.
+     */
+    flush(): Promise<void>;
+    private _saveAudioChunk;
+    private _transcribe;
+    private _dropOldChunks;
+    private _mergeAudioChunks;
+    private _fetchTranscription;
+    private _alignSegments;
+}
+/**
+ * Pure helper that filters and absolute-timestamps Whisper segments against a chunk timeline.
+ * Exported for testing.
+ *
+ * @param segments - Raw segments returned by the Whisper service for `originalChunks`.
+ * @param originalChunks - Chunks fed into the transcription request (used for the zero timestamp).
+ * @param lastTimestamp - Most recent absolute timestamp already emitted; segments whose end
+ *   falls strictly before this point are deduped out, as are individual words whose start does.
+ */
+export declare const alignWhisperSegments: (segments: WhisperSegment[], originalChunks: AudioChunk[], lastTimestamp: number) => {
+    transcripts: ContentBlock.Transcript[];
+    lastTimestamp?: number;
+};
+//# sourceMappingURL=transcriber.d.ts.map

package/dist/types/src/asr/transcriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcriber.d.ts","sourceRoot":"","sources":["../../../../src/asr/transcriber.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,OAAO,EAAkB,QAAQ,EAAE,MAAM,eAAe,CAAC;AAGvE,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGvE,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IAEZ;;OAEG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB,KAAK,EAAE,WAAW,EAAE,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;OAEG;IACH,2BAA2B,EAAE,MAAM,CAAC;IAEpC;;;OAGG;IACH,wBAAwB,EAAE,MAAM,CAAC;IAEjC;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC;AAExE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,gBAAgB,CAAC;IACzB,QAAQ,EAAE,aAAa,CAAC;IACxB;;OAEG;IACH,UAAU,CAAC,EAAE,YAAY,CAAC;IAC1B;;;OAGG;IACH,UAAU,EAAE,CAAC,QAAQ,EAAE,YAAY,CAAC,UAAU,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACpE,CAAC;AAEF;;;;GAIG;AACH,qBAAa,WAAY,SAAQ,QAAQ;IACvC,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,cAAc,CAAK;IAE3B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoC;IAEjE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgB;IAC1C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAiC;IAC7D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAe;IAE9C,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,eAAe,CAAC,CAA2B;IACnD,yFAAyF;IACzF,OAAO,CAAC,gBAAgB,CAAC,CAA8B;IAEvD,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,EAAE,gBAAgB,EAMzE;IAED,UAAyB,KAAK,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAM1D;IAED,UAAyB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAM/C;IAED,iFAAiF;IACjF,KAAK,IAAI,IAAI,CAEZ;IAED,oBAAoB,IAAI,IAAI,CAO3B;IAED,mBAAmB,IAAI,IAAI,CAQ1B;IAED;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAO3B;IAED,OAAO,CAAC,eAAe;YAmBT,WAAW;IAoBzB,OAAO,CAAC,cAAc;YAOR,iBAAiB;YAejB,mBAAmB;IA+CjC,OAAO,CAAC,cAAc;CAQvB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,aACrB,cAAc,EAAE,kBACV,UAAU,EAAE,iBACb,MAAM,KACpB;IAAE,WAAW,EAAE,YAAY,CAAC,UAAU,EAAE,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAgClE,CAAC"}

package/dist/types/src/asr/transcriber.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=transcriber.test.d.ts.map

package/dist/types/src/asr/transcriber.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcriber.test.d.ts","sourceRoot":"","sources":["../../../../src/asr/transcriber.test.ts"],"names":[],"mappings":""}

package/dist/types/src/asr/util.d.ts

@@ -0,0 +1,2 @@
+export declare const mergeFloat64Arrays: (arrays: Float64Array[]) => Float64Array<ArrayBuffer>;
+//# sourceMappingURL=util.d.ts.map

package/dist/types/src/asr/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../../src/asr/util.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,kBAAkB,WAAY,YAAY,EAAE,8BASxD,CAAC"}

package/dist/types/src/dispatch.d.ts

@@ -0,0 +1,19 @@
+import { type Transcript } from '@dxos/types';
+import { type CommitFn } from './PipelineRuntime';
+import { type StageWrite } from './Stage';
+/**
+ * In-memory commit sink: records every {@link StageWrite} for assertions and testbench rendering.
+ */
+export type CaptureCommit = {
+    readonly commit: CommitFn;
+    readonly writes: StageWrite[];
+};
+export declare const captureCommit: () => CaptureCommit;
+/**
+ * ECHO commit: applies a stage's output to live objects. Block patches are applied to the block
+ * objects in the window slice the stage was invoked with (the runtime passes that slice); the
+ * transcript patch is applied to the `Transcript` object. Mutating a live ECHO object propagates
+ * via reactivity; a containing `Obj.update` transaction (when present) batches the writes.
+ */
+export declare const makeEchoCommit: (transcript: Transcript.Transcript) => CommitFn;
+//# sourceMappingURL=dispatch.d.ts.map

package/dist/types/src/dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../../src/dispatch.ts"],"names":[],"mappings":"AAOA,OAAO,EAAqB,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAEjE,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,CAAC;CAC/B,CAAC;AAEF,eAAO,MAAM,aAAa,QAAO,aAOhC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,eACZ,UAAU,CAAC,UAAU,KAAG,QAmBjC,CAAC"}

package/dist/types/src/dispatch.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dispatch.test.d.ts.map

package/dist/types/src/dispatch.test.d.ts.map

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

package/dist/types/src/index.d.ts

@@ -0,0 +1,11 @@
+export * from './TranscriptEvent';
+export * from './Stage';
+export * from './lookup';
+export * from './PipelineConfig';
+export * from './model-routing';
+export * from './PipelineRuntime';
+export * from './live';
+export * from './asr';
+export * from './dispatch';
+export * from './stages';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAIA,cAAc,mBAAmB,CAAC;AAClC,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,QAAQ,CAAC;AACvB,cAAc,OAAO,CAAC;AACtB,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC"}

package/dist/types/src/live.d.ts

@@ -0,0 +1,24 @@
+import { type ContentBlock } from '@dxos/types';
+import { type RunOptions } from './PipelineRuntime';
+/**
+ * Imperative handle to a running pipeline fed by a live ASR source. The source pushes events as they
+ * arrive rather than yielding a pre-materialized stream.
+ */
+export type LivePipeline = {
+    /** Append a transcript block produced by the ASR source. */
+    block: (block: ContentBlock.Transcript) => void;
+    /** Report that the speaker has been silent for `sinceMs` (triggers on-silence stages). */
+    silence: (sinceMs: number) => void;
+    /** Emit a periodic tick (triggers periodic stages). */
+    tick: () => void;
+    /** Close the source; resolves once the stream ends and all in-flight stages have drained. */
+    end: () => Promise<void>;
+};
+/**
+ * Drives {@link PipelineRuntime} from a live ASR source: blocks pushed via the returned handle are
+ * enqueued onto the runtime's source stream; `end` closes the stream so the run drains and resolves.
+ * This is the single orchestration entry point for live capture — callers supply only the stages,
+ * commit sink, and (optional) lookup, mirroring a scripted `PipelineRuntime.run`.
+ */
+export declare const runLivePipeline: (options: Omit<RunOptions, 'source'>) => LivePipeline;
+//# sourceMappingURL=live.d.ts.map

package/dist/types/src/live.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live.d.ts","sourceRoot":"","sources":["../../../src/live.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGrE;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,4DAA4D;IAC5D,KAAK,EAAE,CAAC,KAAK,EAAE,YAAY,CAAC,UAAU,KAAK,IAAI,CAAC;IAChD,0FAA0F;IAC1F,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,uDAAuD;IACvD,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,6FAA6F;IAC7F,GAAG,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B,CAAC;AAOF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,YAAa,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,KAAG,YAerE,CAAC"}

package/dist/types/src/live.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=live.test.d.ts.map

package/dist/types/src/live.test.d.ts.map

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

package/dist/types/src/lookup.d.ts

@@ -0,0 +1,35 @@
+import { type Database, Ref } from '@dxos/echo';
+/**
+ * A candidate match for a surface noun: the matched object's id, a ref consumers can persist, and a
+ * relevance `score` (higher = better) from the search backend's match rank.
+ */
+export type EntityMatch = {
+    id: string;
+    ref: Ref.Ref<any>;
+    score: number;
+};
+/**
+ * Additional context that narrows a lookup. Grows over time (e.g. the conversation window, an
+ * expected role); backends ignore fields they do not support.
+ */
+export type LookupContext = {
+    /** Restrict matches to these typenames (e.g. the typename of `Person` / `Organization`). */
+    types?: string[];
+};
+/**
+ * Resolves a surface noun to its candidate matches, ranked best-first, backed by an index. The
+ * pipeline depends only on this function — not on ECHO/the database directly — so the backend
+ * (full-text, vector, a remote service, …) is an injected concern. Returning candidates (rather than
+ * a single match) lets a context-aware resolver disambiguate using the surrounding conversation.
+ * Empty when nothing matches.
+ */
+export type EntityLookup = (noun: string, context?: LookupContext) => Promise<EntityMatch[]>;
+export type DatabaseLookupOptions = {
+    /** Search backend. Full-text matches proper nouns precisely; vector matches semantically. */
+    searchKind?: 'full-text' | 'vector';
+    /** Maximum candidates returned per noun. */
+    limit?: number;
+};
+/** An {@link EntityLookup} backed by an ECHO database query (full-text by default). */
+export declare const makeDatabaseLookup: (db: Database.Database, { searchKind, limit }?: DatabaseLookupOptions) => EntityLookup;
+//# sourceMappingURL=lookup.d.ts.map

package/dist/types/src/lookup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lookup.d.ts","sourceRoot":"","sources":["../../../src/lookup.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,QAAQ,EAAsB,GAAG,EAAE,MAAM,YAAY,CAAC;AAEpE;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,4FAA4F;IAC5F,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,KAAK,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;AAE7F,MAAM,MAAM,qBAAqB,GAAG;IAClC,6FAA6F;IAC7F,UAAU,CAAC,EAAE,WAAW,GAAG,QAAQ,CAAC;IACpC,4CAA4C;IAC5C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,uFAAuF;AACvF,eAAO,MAAM,kBAAkB,OACxB,QAAQ,CAAC,QAAQ,0BAA2C,qBAAqB,KAAQ,YAgB7F,CAAC"}

package/dist/types/src/lookup.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lookup.test.d.ts.map

package/dist/types/src/lookup.test.d.ts.map

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

package/dist/types/src/model-routing.d.ts

@@ -0,0 +1,12 @@
+import { DXN } from '@dxos/echo';
+import { type StageConfig } from './PipelineConfig';
+import { type Stage } from './Stage';
+/**
+ * Resolve the model for a stage invocation. Precedence: per-stage config override → the stage's own
+ * default → the preset/pipeline default → the global {@link DEFAULT_STAGE_MODEL}.
+ *
+ * `StageConfig.model` is a validated NSID name in the schema (its format is checked, but it is not
+ * pinned to the current model catalog); it is parsed to a model DXN here for the `AiService` call.
+ */
+export declare const resolveModel: (stageConfig: StageConfig | undefined, stage: Stage<any, any>, presetDefault?: DXN.DXN) => DXN.DXN;
+//# sourceMappingURL=model-routing.d.ts.map

package/dist/types/src/model-routing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-routing.d.ts","sourceRoot":"","sources":["../../../src/model-routing.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACzE,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,gBACV,WAAW,GAAG,SAAS,SAC7B,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,kBACN,GAAG,CAAC,GAAG,KACtB,GAAG,CAAC,GAIc,CAAC"}

package/dist/types/src/pipeline-integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pipeline-integration.test.d.ts.map

package/dist/types/src/pipeline-integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline-integration.test.d.ts","sourceRoot":"","sources":["../../../src/pipeline-integration.test.ts"],"names":[],"mappings":""}

package/dist/types/src/stages/correction-llm.d.ts

@@ -0,0 +1,14 @@
+import * as Effect from 'effect/Effect';
+import { AiService } from '@dxos/ai';
+import { DXN } from '@dxos/echo';
+import { type ContentBlock } from '@dxos/types';
+/**
+ * LLM-backed correction over a window of transcript blocks (the {@link makeCorrectionStage} seam).
+ * Returns an Effect requiring the {@link AiService} — the consumer provides its model layer and adapts
+ * the Effect to the stage's Promise-shaped `CorrectFn` (e.g. `EffectEx.runPromise(... .pipe(Effect.provide(layer)))`).
+ */
+export declare const correctWithLanguageModel: (blocks: readonly ContentBlock.Transcript[], model?: DXN.DXN) => Effect.Effect<ReadonlyArray<{
+    index: number;
+    corrected: string;
+}>, unknown, AiService.AiService>;
+//# sourceMappingURL=correction-llm.d.ts.map

package/dist/types/src/stages/correction-llm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"correction-llm.d.ts","sourceRoot":"","sources":["../../../../src/stages/correction-llm.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAUhD;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,WAC3B,SAAS,YAAY,CAAC,UAAU,EAAE,UACnC,GAAG,CAAC,GAAG,KACb,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,EAAE,OAAO,EAAE,SAAS,CAAC,SAAS,CAUlB,CAAC"}

package/dist/types/src/stages/correction-llm.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=correction-llm.test.d.ts.map

package/dist/types/src/stages/correction-llm.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"correction-llm.test.d.ts","sourceRoot":"","sources":["../../../../src/stages/correction-llm.test.ts"],"names":[],"mappings":""}

package/dist/types/src/stages/correction.d.ts

@@ -0,0 +1,29 @@
+import { type ContentBlock } from '@dxos/types';
+import { type Stage } from '../Stage';
+export type CorrectionInput = {
+    window: ContentBlock.Transcript[];
+};
+/**
+ * Corrects a window of transcript blocks, returning a `{ index, corrected }` patch per block it
+ * changes. The deterministic default is used unless an LLM-backed corrector is injected (see
+ * `correctWithLanguageModel`); the consumer binds the AI service and adapts it to this Promise shape.
+ */
+export type CorrectFn = (blocks: readonly ContentBlock.Transcript[]) => Promise<ReadonlyArray<{
+    index: number;
+    corrected: string;
+}>>;
+export type CorrectionOptions = {
+    /** Inject an LLM-backed corrector; omit for the deterministic per-block correction. */
+    correct?: CorrectFn;
+};
+/**
+ * Deterministic correction: trim, capitalize the first letter, ensure terminal punctuation.
+ * The LLM seam (see `run`) replaces this with cross-batch repair over the window.
+ */
+export declare const correctText: (text: string) => string;
+/**
+ * Stage ①: clean up the most recent transcript block (punctuation, capitalization).
+ * Windowed for cross-batch context; emits a correction for the newest block.
+ */
+export declare const makeCorrectionStage: ({ correct }?: CorrectionOptions) => Stage<CorrectionInput>;
+//# sourceMappingURL=correction.d.ts.map

package/dist/types/src/stages/correction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"correction.d.ts","sourceRoot":"","sources":["../../../../src/stages/correction.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAGhD,OAAO,EAAE,KAAK,KAAK,EAAc,MAAM,UAAU,CAAC;AAElD,MAAM,MAAM,eAAe,GAAG;IAAE,MAAM,EAAE,YAAY,CAAC,UAAU,EAAE,CAAA;CAAE,CAAC;AAEpE;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG,CACtB,MAAM,EAAE,SAAS,YAAY,CAAC,UAAU,EAAE,KACvC,OAAO,CAAC,aAAa,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAAC;AAElE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,uFAAuF;IACvF,OAAO,CAAC,EAAE,SAAS,CAAC;CACrB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,WAAW,SAAU,MAAM,KAAG,MAY1C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,iBAAiB,iBAAiB,KAAQ,KAAK,CAAC,eAAe,CAsB7F,CAAC"}

package/dist/types/src/stages/correction.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=correction.test.d.ts.map