@dxos/pipeline-transcription 0.0.0

package/dist/lib/neutral/index.mjs

@@ -0,0 +1,886 @@
+import {
+  TranscriptEvent
+} from "./chunk-Y44GOMGN.mjs";
+
+// src/Stage.ts
+var StageWrite = Object.freeze({
+  blocks: (blockUpdates) => ({
+    blockUpdates
+  }),
+  transcript: (transcriptUpdate) => ({
+    transcriptUpdate
+  }),
+  empty: () => ({})
+});
+
+// src/lookup.ts
+import { Filter, Obj, Query, Ref } from "@dxos/echo";
+var makeDatabaseLookup = (db, { searchKind = "full-text", limit = 5 } = {}) => async (noun, context) => {
+  const entries = await db.query(Query.select(Filter.text(noun, {
+    type: searchKind
+  }))).runEntries();
+  const types = context?.types;
+  return entries.flatMap((entry) => {
+    if (!entry.result || types?.length && !types.includes(Obj.getTypename(entry.result) ?? "")) {
+      return [];
+    }
+    return [
+      {
+        id: entry.id,
+        ref: Ref.make(entry.result),
+        score: entry.match?.rank ?? 0
+      }
+    ];
+  }).sort((a, b) => b.score - a.score).slice(0, limit);
+};
+
+// src/PipelineConfig.ts
+import * as Schema from "effect/Schema";
+import { DXN, Obj as Obj2, Type } from "@dxos/echo";
+var DEFAULT_STAGE_MODEL = DXN.make("com.anthropic.model.claude-haiku-4-5.default");
+var 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())
+  }))
+});
+var PipelineConfig = class extends Type.makeObject(DXN.make("org.dxos.type.transcriptionPipelineConfig", "0.1.0"))(Schema.Struct({
+  name: Schema.String,
+  stages: Schema.mutable(Schema.Array(StageConfig))
+})) {
+};
+var PIPELINE_PRESETS = 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
+      }
+    ]
+  }
+]);
+var findPreset = (name) => PIPELINE_PRESETS.find((preset) => preset.name === name);
+var makeConfigFromPreset = (preset) => Obj2.make(PipelineConfig, {
+  name: preset.name,
+  stages: preset.stages.map((stage) => ({
+    ...stage
+  }))
+});
+
+// src/model-routing.ts
+import { DXN as DXN2 } from "@dxos/echo";
+var resolveModel = (stageConfig, stage, presetDefault) => (stageConfig?.model ? DXN2.tryMake(stageConfig.model) : void 0) ?? stage.model ?? presetDefault ?? DEFAULT_STAGE_MODEL;
+
+// src/PipelineRuntime.ts
+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 { log } from "@dxos/log";
+import { Pipeline, Stage as PipelineStage } from "@dxos/pipeline";
+var __dxlog_file = "/Users/jdw/Code/dxos/packages/core/compute/pipeline-transcription/src/PipelineRuntime.ts";
+var MAX_WINDOW = 128;
+var BROADCAST_BUFFER = 128;
+var StageContextService = class extends Context.Tag("@dxos/pipeline-transcription/StageContextService")() {
+};
+var triggerMatches = (stage, kind) => stage.trigger === "per-block" && kind === "block" || stage.trigger === "on-silence" && kind === "silence" || stage.trigger === "periodic" && kind === "tick";
+var triggerKind = (stage) => stage.trigger === "per-block" ? "block" : stage.trigger === "on-silence" ? "silence" : "tick";
+var windowTrigger = (stage, config) => {
+  const blocks = config?.window?.blocks ?? stage.window?.blocks;
+  return (input) => input.pipe(Stream.mapAccum([], (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 : void 0;
+    return [
+      next,
+      slice
+    ];
+  }), Stream.filter((slice) => slice !== void 0));
+};
+var runStage = (stage, config, presetDefault, onTelemetry) => {
+  const model = resolveModel(config, stage, presetDefault);
+  const trigger = triggerKind(stage);
+  return PipelineStage.map(stage.id, (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), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 70, S: void 0 });
+    onTelemetry?.({
+      stageId: stage.id,
+      model,
+      trigger,
+      durationMs: 0,
+      outcome: "error"
+    });
+    return void 0;
+  }))), {
+    overflow: stage.concurrency === "latest-wins" ? "sliding" : "dropping",
+    bufferSize: 1
+  });
+};
+var run = (options) => Effect.scoped(Effect.gen(function* () {
+  const { source, stages, commit, lookup, configs, presetDefault, onTelemetry } = options;
+  const configFor = (id) => 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);
+  }
+  const sink = ({ write, window }) => commit(write, window).pipe(Effect.catchAllCause((cause) => Effect.sync(() => log.catch(Cause.squash(cause), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 98, S: this }))));
+  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 = {
+      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
+  });
+}));
+var PipelineRuntime = Object.freeze({
+  run
+});
+
+// src/live.ts
+import * as Effect2 from "effect/Effect";
+import * as Queue from "effect/Queue";
+import * as Stream2 from "effect/Stream";
+import { EffectEx } from "@dxos/effect";
+var END = /* @__PURE__ */ Symbol("end");
+var runLivePipeline = (options) => {
+  const queue = Effect2.runSync(Queue.unbounded());
+  const source = Stream2.fromQueue(queue).pipe(Stream2.takeWhile((item) => item !== END));
+  const done = EffectEx.runPromise(PipelineRuntime.run({
+    ...options,
+    source
+  }));
+  const offer2 = (item) => Effect2.runSync(Queue.offer(queue, item));
+  return {
+    block: (block) => offer2(TranscriptEvent.block(block)),
+    silence: (sinceMs) => offer2(TranscriptEvent.silence(sinceMs)),
+    tick: () => offer2(TranscriptEvent.tick()),
+    end: async () => {
+      offer2(END);
+      await done;
+      Effect2.runSync(Queue.shutdown(queue));
+    }
+  };
+};
+
+// src/asr/sentence-buffer.ts
+var splitSentences = (text) => {
+  const sentences = [];
+  let start = 0;
+  for (let index = 0; index < text.length; index++) {
+    const char = text[index];
+    if (char !== "." && char !== "!" && char !== "?") {
+      continue;
+    }
+    let end = index;
+    while (end + 1 < text.length && (text[end + 1] === "." || text[end + 1] === "!" || text[end + 1] === "?")) {
+      end++;
+    }
+    const isEllipsis = text.slice(index, end + 1).startsWith("..");
+    const next = text[end + 1];
+    const atBoundary = next === void 0 || /\s/.test(next);
+    if (!isEllipsis && atBoundary) {
+      const sentence = text.slice(start, end + 1).trim();
+      if (sentence.length > 0) {
+        sentences.push(sentence);
+      }
+      start = end + 1;
+    }
+    index = end;
+  }
+  return {
+    sentences,
+    rest: text.slice(start).trim()
+  };
+};
+var SentenceBuffer = class {
+  #text = "";
+  #started;
+  /** Append a fragment; returns any complete sentences it produced. */
+  push(block) {
+    const fragment = block.text.trim();
+    if (fragment.length === 0) {
+      return [];
+    }
+    if (this.#text.length === 0) {
+      this.#started = block.started;
+    }
+    this.#text = this.#text.length === 0 ? fragment : `${this.#text} ${fragment}`;
+    const { sentences, rest } = splitSentences(this.#text);
+    if (sentences.length === 0) {
+      return [];
+    }
+    const startedForSentences = this.#started;
+    this.#text = rest;
+    this.#started = rest.length > 0 ? this.#started : void 0;
+    return sentences.map((text, index) => ({
+      _tag: "transcript",
+      started: index === 0 ? startedForSentences ?? block.started : block.started,
+      text
+    }));
+  }
+  /** Emit any buffered text as a final sentence. */
+  flush() {
+    const remaining = this.#text.trim();
+    this.#text = "";
+    const started = this.#started;
+    this.#started = void 0;
+    if (remaining.length === 0) {
+      return [];
+    }
+    return [
+      {
+        _tag: "transcript",
+        started: started ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+        text: remaining
+      }
+    ];
+  }
+};
+
+// src/asr/transcriber.ts
+import { WaveFile } from "wavefile";
+import { DeferredTask, Trigger, synchronized } from "@dxos/async";
+import { EDGE_SERVICE_DEFAULTS, EdgeServiceName } from "@dxos/config";
+import { LifecycleState, Resource } from "@dxos/context";
+import { log as log2 } from "@dxos/log";
+import { trace } from "@dxos/tracing";
+
+// src/asr/util.ts
+var mergeFloat64Arrays = (arrays) => {
+  const newArray = new Float64Array(arrays.reduce((acc, array) => array.length + acc, 0));
+  let offset = 0;
+  for (const array of arrays) {
+    newArray.set(array, offset);
+    offset += array.length;
+  }
+  return newArray;
+};
+
+// src/asr/transcriber.ts
+var __dxlog_file2 = "/Users/jdw/Code/dxos/packages/core/compute/pipeline-transcription/src/asr/transcriber.ts";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+var Transcriber = class extends Resource {
+  _audioChunks = [];
+  _lastTimestamp = 0;
+  _openTrigger = new Trigger({
+    autoReset: true
+  });
+  _config;
+  _recorder;
+  _onSegments;
+  _transcribeFn;
+  _recording = false;
+  _transcribeTask = void 0;
+  /** Aborts the in-flight transcription request (e.g. when the user cancels the drain). */
+  _transcribeAbort = void 0;
+  constructor({ config, recorder, onSegments, transcribe }) {
+    super();
+    this._config = config;
+    this._recorder = recorder;
+    this._onSegments = onSegments;
+    this._transcribeFn = transcribe;
+  }
+  async _open(ctx) {
+    log2.info("opening", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 42, S: this });
+    this._recorder.setOnChunk((chunk) => this._saveAudioChunk(chunk));
+    await this._recorder.start();
+    this._transcribeTask = new DeferredTask(ctx, async () => this._transcribe());
+    this._openTrigger.wake();
+  }
+  async _close() {
+    log2.info("closing", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 49, S: this });
+    this._recording = false;
+    this._transcribeTask = void 0;
+    this._transcribeAbort?.abort();
+    await this._recorder.stop();
+  }
+  /** Abort the in-flight transcription request (e.g. user cancelled the drain). */
+  abort() {
+    this._transcribeAbort?.abort();
+  }
+  startChunksRecording() {
+    log2.info("starting", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 59, S: this });
+    if (this._lifecycleState !== LifecycleState.OPEN) {
+      return;
+    }
+    this._recording = true;
+  }
+  stopChunksRecording() {
+    if (this._lifecycleState !== LifecycleState.OPEN || !this._recording) {
+      return;
+    }
+    this._recording = false;
+    this._transcribeTask?.schedule();
+    log2.info("stopped", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 71, S: this });
+  }
+  /**
+  * 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.
+  */
+  async flush() {
+    if (this._lifecycleState !== LifecycleState.OPEN) {
+      return;
+    }
+    this._recording = false;
+    await this._transcribe();
+  }
+  _saveAudioChunk(chunk) {
+    log2("saving audio chunk", {
+      chunk
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 85, S: this });
+    this._audioChunks.push(chunk);
+    if (!this._recording && (!this._transcribeTask || !this._transcribeTask.scheduled) && this._audioChunks.length >= this._config.prefixBufferChunksAmount) {
+      this._audioChunks = this._dropOldChunks();
+    } else if (this._audioChunks.length >= this._config.transcribeAfterChunksAmount && this._recording) {
+      this._transcribeTask?.schedule();
+    }
+  }
+  // Serialized so a threshold-scheduled run and a flush()/deferred run cannot read the same buffer
+  // concurrently and duplicate or drop tail segments.
+  async _transcribe() {
+    log2("transcribing", {
+      chunks: this._audioChunks.length
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 99, S: this });
+    const chunks = this._audioChunks;
+    this._audioChunks = this._dropOldChunks();
+    if (chunks.length === 0) {
+      return;
+    }
+    const audio = await this._mergeAudioChunks(chunks);
+    const segments = await this._fetchTranscription(audio);
+    if (!Array.isArray(segments) || segments.length === 0) {
+      return;
+    }
+    const alignedSegments = this._alignSegments(segments, chunks);
+    if (alignedSegments.length > 0) {
+      await this._onSegments(alignedSegments);
+    }
+  }
+  _dropOldChunks() {
+    return this._config.prefixBufferChunksAmount > 0 ? this._audioChunks.slice(-this._config.prefixBufferChunksAmount) : [];
+  }
+  async _mergeAudioChunks(chunks) {
+    const file = new WaveFile();
+    const wavConfig = this._recorder.wavConfig;
+    file.fromScratch(wavConfig.channels, wavConfig.sampleRate, wavConfig.bitDepthCode, mergeFloat64Arrays(chunks.map(({ data }) => data)));
+    return file.toBase64();
+  }
+  async _fetchTranscription(audio) {
+    if (audio.length === 0) {
+      throw new Error("No audio to send for transcribing");
+    }
+    let segments;
+    if (this._transcribeFn) {
+      segments = await this._transcribeFn(audio);
+    } else {
+      const endpoint = this._config.endpoint ?? EDGE_SERVICE_DEFAULTS[EdgeServiceName.Transcription];
+      this._transcribeAbort = new AbortController();
+      let response;
+      try {
+        response = await fetch(`${endpoint}/transcribe`, {
+          method: "POST",
+          body: JSON.stringify({
+            audio
+          }),
+          headers: {
+            "Content-Type": "application/json"
+          },
+          signal: this._transcribeAbort.signal
+        });
+      } catch (err) {
+        if (err instanceof DOMException && err.name === "AbortError") {
+          return [];
+        }
+        throw err;
+      } finally {
+        this._transcribeAbort = void 0;
+      }
+      if (!response.ok) {
+        throw new Error(`Transcription failed: ${response.statusText}`);
+      }
+      ({ segments } = await response.json());
+    }
+    if (!Array.isArray(segments)) {
+      throw new Error("Transcription response payload is invalid");
+    }
+    log2.info("transcription response", {
+      segments: segments.length
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 166, S: this });
+    return segments;
+  }
+  _alignSegments(segments, originalChunks) {
+    const result = alignWhisperSegments(segments, originalChunks, this._lastTimestamp);
+    if (result.lastTimestamp !== void 0) {
+      this._lastTimestamp = result.lastTimestamp;
+    }
+    return result.transcripts;
+  }
+};
+_ts_decorate([
+  synchronized
+], Transcriber.prototype, "_transcribe", null);
+_ts_decorate([
+  trace.span({
+    showInBrowserTimeline: true
+  })
+], Transcriber.prototype, "_mergeAudioChunks", null);
+_ts_decorate([
+  trace.span({
+    showInBrowserTimeline: true
+  })
+], Transcriber.prototype, "_fetchTranscription", null);
+var alignWhisperSegments = (segments, originalChunks, lastTimestamp) => {
+  if (originalChunks.length === 0) {
+    return {
+      transcripts: []
+    };
+  }
+  const zeroTimestamp = originalChunks[0].timestamp;
+  const filteredSegments = segments.filter((segment) => zeroTimestamp + segment.end * 1e3 >= lastTimestamp).map((segment) => {
+    const words = segment.words.filter((word) => zeroTimestamp + word.start * 1e3 >= lastTimestamp);
+    return {
+      ...segment,
+      words,
+      text: words.map((word) => word.word).join(""),
+      start: words.at(0)?.start ?? segment.end
+    };
+  }).filter((segment) => segment.words.length > 0);
+  if (filteredSegments.length === 0) {
+    return {
+      transcripts: []
+    };
+  }
+  return {
+    lastTimestamp: zeroTimestamp + filteredSegments.at(-1).end * 1e3,
+    transcripts: filteredSegments.map((segment) => ({
+      _tag: "transcript",
+      started: new Date(zeroTimestamp + segment.start * 1e3).toISOString(),
+      text: segment.text.trim()
+    }))
+  };
+};
+
+// src/asr/pipeline.ts
+var runAsrPipeline = ({ recorder, transcribe, config, segmentSentences = false, onSegment, drainSilenceMs = 5e3, ...runOptions }) => {
+  const live = runLivePipeline(runOptions);
+  const sentences = segmentSentences ? new SentenceBuffer() : void 0;
+  const emit = (block) => {
+    onSegment?.(block);
+    live.block(block);
+  };
+  const handle = (blocks) => {
+    for (const block of blocks) {
+      if (sentences) {
+        for (const sentence of sentences.push(block)) {
+          emit(sentence);
+        }
+      } else {
+        emit(block);
+      }
+    }
+  };
+  const transcriber = new Transcriber({
+    config,
+    recorder,
+    transcribe,
+    onSegments: async (blocks) => handle(blocks)
+  });
+  return {
+    open: async () => {
+      await transcriber.open();
+    },
+    start: () => transcriber.startChunksRecording(),
+    stop: () => transcriber.stopChunksRecording(),
+    abort: () => transcriber.abort(),
+    end: async () => {
+      await transcriber.flush();
+      if (sentences) {
+        for (const sentence of sentences.flush()) {
+          emit(sentence);
+        }
+      }
+      live.silence(drainSilenceMs);
+      await live.end();
+      await transcriber.close();
+    }
+  };
+};
+
+// src/dispatch.ts
+import * as Effect3 from "effect/Effect";
+import { Obj as Obj3 } from "@dxos/echo";
+var captureCommit = () => {
+  const writes = [];
+  const commit = (write) => Effect3.sync(() => {
+    writes.push(write);
+  });
+  return {
+    commit,
+    writes
+  };
+};
+var makeEchoCommit = (transcript) => (write, window) => Effect3.sync(() => {
+  for (const update of write.blockUpdates ?? []) {
+    const block = window[update.index];
+    if (!block) {
+      continue;
+    }
+    const { index: _index, ...patch } = update;
+    if (Obj3.isObject(block)) {
+      Obj3.update(block, (block2) => Object.assign(block2, patch));
+    } else {
+      Object.assign(block, patch);
+    }
+  }
+  if (write.transcriptUpdate) {
+    Obj3.update(transcript, (transcript2) => Object.assign(transcript2, write.transcriptUpdate));
+  }
+});
+
+// src/stages/index.ts
+import { log as log3 } from "@dxos/log";
+
+// src/stages/correction.ts
+import * as Effect4 from "effect/Effect";
+var correctText = (text) => {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) {
+    return trimmed;
+  }
+  const capitalized = trimmed.charAt(0).toUpperCase() + trimmed.slice(1);
+  if (/[.!?]$/.test(capitalized)) {
+    return capitalized;
+  }
+  return `${capitalized.replace(/[,;:]+$/, "")}.`;
+};
+var makeCorrectionStage = ({ correct } = {}) => ({
+  id: "correct",
+  trigger: "per-block",
+  window: {
+    blocks: 8
+  },
+  concurrency: "latest-wins",
+  model: DEFAULT_STAGE_MODEL,
+  run: ({ window }) => correct ? Effect4.promise(() => correct(window)).pipe(Effect4.map((updates) => updates.length > 0 ? StageWrite.blocks([
+    ...updates
+  ]) : StageWrite.empty())) : Effect4.sync(() => {
+    const updates = window.map((block, index) => ({
+      block,
+      index
+    })).filter(({ block }) => block.corrected === void 0).map(({ block, index }) => ({
+      index,
+      corrected: correctText(block.text)
+    }));
+    return updates.length > 0 ? StageWrite.blocks(updates) : StageWrite.empty();
+  })
+});
+
+// src/stages/diarization.ts
+import * as Effect5 from "effect/Effect";
+var makeDiarizationStage = () => ({
+  id: "diarize",
+  trigger: "per-block",
+  window: {
+    blocks: 1
+  },
+  concurrency: "latest-wins",
+  // TODO: implement diarization (assign speaker identity to the block).
+  run: () => Effect5.succeed(StageWrite.empty())
+});
+
+// src/stages/extraction.ts
+import * as Effect6 from "effect/Effect";
+import { insertReferences } from "@dxos/assistant/extraction";
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "I",
+  "Yes",
+  "No",
+  "But",
+  "And",
+  "Or",
+  "So",
+  "They",
+  "We",
+  "He",
+  "She",
+  "It",
+  "The",
+  "A",
+  "An",
+  "Is",
+  "Are",
+  "Was",
+  "Were",
+  "Be",
+  "Been",
+  "This",
+  "That"
+]);
+var extractProperNouns = (text) => {
+  const matches = text.match(/\b[A-Z][a-zA-Z]+(?:\s+[A-Z][a-zA-Z]+)*\b/g) ?? [];
+  return Array.from(new Set(matches.filter((word) => !STOP_WORDS.has(word))));
+};
+var isLinked = (text) => text.includes("](echo:");
+var resolveEntities = async (text, lookup) => {
+  const nouns = extractProperNouns(text);
+  const references = [];
+  const quotes = [];
+  const matched = /* @__PURE__ */ new Set();
+  if (lookup) {
+    for (const noun of nouns) {
+      const candidates2 = await lookup(noun);
+      const unambiguous = candidates2.length === 1 || candidates2.length > 1 && candidates2[0].score > candidates2[1].score;
+      if (candidates2.length > 0 && unambiguous) {
+        references.push(candidates2[0].ref);
+        quotes.push({
+          quote: noun,
+          id: candidates2[0].id
+        });
+        matched.add(noun.toLowerCase());
+      }
+    }
+  }
+  const candidates = nouns.filter((noun) => !matched.has(noun.toLowerCase())).map((noun) => {
+    const start = Math.max(0, text.indexOf(noun));
+    return {
+      text: noun,
+      kind: "proper-noun",
+      start,
+      end: start + noun.length
+    };
+  });
+  return {
+    references,
+    quotes,
+    candidates
+  };
+};
+var linkEntities = async (text, lookup) => {
+  if (isLinked(text)) {
+    return text;
+  }
+  const { quotes } = await resolveEntities(text, lookup);
+  return quotes.length > 0 ? insertReferences(text, {
+    references: quotes
+  }) : text;
+};
+var makeExtractionStage = () => ({
+  id: "extract",
+  trigger: "per-block",
+  window: {
+    blocks: 8
+  },
+  concurrency: "latest-wins",
+  model: DEFAULT_STAGE_MODEL,
+  run: ({ window }, ctx) => Effect6.gen(function* () {
+    const updates = [];
+    for (let index = 0; index < window.length; index++) {
+      const block = window[index];
+      const text = block.corrected ?? block.text;
+      if (isLinked(text)) {
+        continue;
+      }
+      const { references, quotes, candidates } = yield* Effect6.promise(() => resolveEntities(text, ctx.lookup));
+      const update = {
+        index
+      };
+      if (references.length > 0) {
+        update.references = references;
+      }
+      if (candidates.length > 0) {
+        update.candidates = candidates;
+      }
+      if (quotes.length > 0) {
+        update.corrected = insertReferences(text, {
+          references: quotes
+        });
+      }
+      if (update.references || update.candidates || update.corrected) {
+        updates.push(update);
+      }
+    }
+    return updates.length > 0 ? StageWrite.blocks(updates) : StageWrite.empty();
+  })
+});
+
+// src/stages/summarization.ts
+import * as Effect7 from "effect/Effect";
+var makeSummarizationStage = () => ({
+  id: "summarize",
+  trigger: "on-silence",
+  concurrency: "skip-if-busy",
+  model: DEFAULT_STAGE_MODEL,
+  run: ({ window }) => Effect7.sync(() => {
+    const utterances = window.map((block) => (block.corrected ?? block.text).trim()).filter(Boolean);
+    if (utterances.length === 0) {
+      return StageWrite.empty();
+    }
+    return StageWrite.transcript({
+      summary: utterances.join(" "),
+      summaryUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  })
+});
+
+// src/stages/translation.ts
+import * as Effect8 from "effect/Effect";
+var makeTranslationStage = (_targetLanguage = "en") => ({
+  id: "translate",
+  trigger: "per-block",
+  window: {
+    blocks: 1
+  },
+  concurrency: "latest-wins",
+  model: DEFAULT_STAGE_MODEL,
+  // TODO: implement translation (per-block; writes block.translation via a model call).
+  run: () => Effect8.succeed(StageWrite.empty())
+});
+
+// src/stages/correction-llm.ts
+import * as LanguageModel from "@effect/ai/LanguageModel";
+import * as Effect9 from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema2 from "effect/Schema";
+import { AiService } from "@dxos/ai";
+import { DXN as DXN3 } from "@dxos/echo";
+var CorrectionPayload = Schema2.Struct({
+  blocks: Schema2.Array(Schema2.Struct({
+    index: Schema2.Number,
+    corrected: Schema2.String
+  }))
+});
+var PROMPT = `You repair raw speech-to-text fragments. For each numbered fragment, return a cleaned version: fix capitalization and terminal punctuation, join words split across fragment boundaries, and drop filler/garbage tokens \u2014 without changing the meaning. Return exactly one entry per input fragment, preserving its index.`;
+var correctWithLanguageModel = (blocks, model = DEFAULT_STAGE_MODEL) => Effect9.gen(function* () {
+  const input = blocks.map((block, index) => `${index}: ${block.corrected ?? block.text}`).join("\n");
+  const response = yield* LanguageModel.generateObject({
+    schema: CorrectionPayload,
+    prompt: `${PROMPT}
+
+${input}`
+  });
+  return response.value.blocks.map((block) => ({
+    index: block.index,
+    corrected: block.corrected
+  }));
+}).pipe(Effect9.provide(AiService.model(DXN3.getName(model)).pipe(Layer.orDie)));
+
+// src/stages/index.ts
+var __dxlog_file3 = "/Users/jdw/Code/dxos/packages/core/compute/pipeline-transcription/src/stages/index.ts";
+var STAGE_FACTORIES = Object.freeze({
+  correct: makeCorrectionStage,
+  extract: makeExtractionStage,
+  summarize: makeSummarizationStage,
+  translate: makeTranslationStage,
+  diarize: makeDiarizationStage
+});
+var buildStages = (configs) => {
+  const unknown = configs.filter((config) => config.enabled && !STAGE_FACTORIES[config.id]).map((config) => config.id);
+  if (unknown.length > 0) {
+    log3.warn("ignoring unknown pipeline stage ids", {
+      unknown,
+      known: Object.keys(STAGE_FACTORIES)
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 31, S: void 0 });
+  }
+  return configs.filter((config) => config.enabled && STAGE_FACTORIES[config.id]).map((config) => STAGE_FACTORIES[config.id]());
+};
+export {
+  DEFAULT_STAGE_MODEL,
+  PIPELINE_PRESETS,
+  PipelineConfig,
+  PipelineRuntime,
+  STAGE_FACTORIES,
+  SentenceBuffer,
+  StageConfig,
+  StageWrite,
+  Transcriber,
+  TranscriptEvent,
+  alignWhisperSegments,
+  buildStages,
+  captureCommit,
+  correctText,
+  correctWithLanguageModel,
+  extractProperNouns,
+  findPreset,
+  isLinked,
+  linkEntities,
+  makeConfigFromPreset,
+  makeCorrectionStage,
+  makeDatabaseLookup,
+  makeDiarizationStage,
+  makeEchoCommit,
+  makeExtractionStage,
+  makeSummarizationStage,
+  makeTranslationStage,
+  resolveEntities,
+  resolveModel,
+  runAsrPipeline,
+  runLivePipeline,
+  splitSentences
+};
+//# sourceMappingURL=index.mjs.map