@dxos/plugin-transcription 0.8.2-main.fbd8ed0 → 0.8.2-staging.4d6ad0f

package/src/transcriber/media-stream-recorder.ts

@@ -19,6 +19,13 @@ const initializeExtendableMediaRecorder = async () => {
   await register(await connect());
 };
 
+export type MediaStreamRecorderParams = {
+  mediaStreamTrack: MediaStreamTrack;
+  config: {
+    interval: number;
+  };
+};
+
 /**
  * Recorder that uses the MediaContext API and AudioNode API to record audio.
  *
@@ -30,14 +37,14 @@ export class MediaStreamRecorder implements AudioRecorder {
   /**
    * Default MediaRecorder implementation do not support wav encoding.
    */
-  private readonly _interval: number;
+  private readonly _config: MediaStreamRecorderParams['config'];
   private _mediaRecorder?: IMediaRecorder = undefined;
   private _header?: Uint8Array = undefined;
   private _onChunk?: (chunk: AudioChunk) => void;
 
-  constructor({ mediaStreamTrack, interval }: { mediaStreamTrack: MediaStreamTrack; interval: number }) {
+  constructor({ mediaStreamTrack, config }: MediaStreamRecorderParams) {
     this._mediaStreamTrack = mediaStreamTrack;
-    this._interval = interval;
+    this._config = config;
   }
 
   get wavConfig(): WavConfig {
@@ -57,7 +64,7 @@ export class MediaStreamRecorder implements AudioRecorder {
     this._onChunk = onChunk;
   }
 
-  async start() {
+  async start(): Promise<void> {
     await (initializingPromise ??= initializeExtendableMediaRecorder()).catch((err) =>
       log.info('initializeExtendableMediaRecorder', { err }),
     );
@@ -72,10 +79,10 @@ export class MediaStreamRecorder implements AudioRecorder {
     }
     invariant(this._onChunk, 'MediaStreamRecorder: onChunk is not set');
     this._mediaRecorder.ondataavailable = (event) => this._ondataavailable(event);
-    this._mediaRecorder.start(this._interval);
+    this._mediaRecorder.start(this._config.interval);
   }
 
-  async stop() {
+  async stop(): Promise<void> {
     if (this._mediaRecorder?.state !== 'recording') {
       return;
     }
@@ -83,7 +90,7 @@ export class MediaStreamRecorder implements AudioRecorder {
   }
 
   @synchronized
-  private async _ondataavailable(event: IBlobEvent) {
+  private async _ondataavailable(event: IBlobEvent): Promise<void> {
     const blob = event.data;
     const uint8Array = new Uint8Array(await blob.arrayBuffer());
 

package/src/transcriber/transcriber.browser.test.ts

@@ -194,14 +194,14 @@ class MockAudioRecorder implements AudioRecorder {
     };
   }
 
-  setOnChunk(onChunk: (chunk: AudioChunk) => void) {
+  setOnChunk(onChunk: (chunk: AudioChunk) => void): void {
     this._onChunk = onChunk;
   }
 
   /**
    * Emit a chunk in controlled manner for testing purposes.
    */
-  emitChunk() {
+  emitChunk(): void {
     const chunk = this.chunks.shift();
     if (!chunk) {
       return;
@@ -211,7 +211,7 @@ class MockAudioRecorder implements AudioRecorder {
   }
 
   @trace.span()
-  async start() {
+  async start(): Promise<void> {
     log.info('start mock audio recorder', { wavParams: this.wav.fmt });
     const now = Date.now();
     const samples = this.wav.getSamples();
@@ -226,5 +226,5 @@ class MockAudioRecorder implements AudioRecorder {
     }
   }
 
-  async stop() {}
+  async stop(): Promise<void> {}
 }

package/src/transcriber/transcriber.ts

@@ -65,6 +65,10 @@ export type TranscribeConfig = {
 export type TranscriberParams = {
   config: TranscribeConfig;
   recorder: AudioRecorder;
+  /**
+   * Callback to handle the transcribed segments, after all segment transformers are applied.
+   * @param segments - The transcribed segments.
+   */
   onSegments: (segments: DataType.MessageBlock.Transcription[]) => Promise<void>;
 };
 
@@ -93,7 +97,7 @@ export class Transcriber extends Resource {
     this._onSegments = onSegments;
   }
 
-  protected override async _open(ctx: Context) {
+  protected override async _open(ctx: Context): Promise<void> {
     log.info('opening');
     this._recorder.setOnChunk((chunk) => this._saveAudioChunk(chunk));
     await this._recorder.start();
@@ -101,14 +105,14 @@ export class Transcriber extends Resource {
     this._openTrigger.wake();
   }
 
-  protected override async _close() {
+  protected override async _close(): Promise<void> {
     log.info('closing');
     this._recording = false;
     this._transcribeTask = undefined;
     await this._recorder.stop();
   }
 
-  startChunksRecording() {
+  startChunksRecording(): void {
     log.info('starting');
     if (this._lifecycleState !== LifecycleState.OPEN) {
       return;
@@ -117,7 +121,7 @@ export class Transcriber extends Resource {
     this._recording = true;
   }
 
-  stopChunksRecording() {
+  stopChunksRecording(): void {
     if (this._lifecycleState !== LifecycleState.OPEN || !this._recording) {
       return;
     }
@@ -127,7 +131,7 @@ export class Transcriber extends Resource {
     log.info('stopped');
   }
 
-  private _saveAudioChunk(chunk: AudioChunk) {
+  private _saveAudioChunk(chunk: AudioChunk): void {
     log('saving audio chunk', { chunk });
     this._audioChunks.push(chunk);
 
@@ -143,7 +147,7 @@ export class Transcriber extends Resource {
     }
   }
 
-  private async _transcribe() {
+  private async _transcribe(): Promise<void> {
     log('transcribing', { chunks: this._audioChunks.length });
     const chunks = this._audioChunks;
     this._audioChunks = this._dropOldChunks();
@@ -163,14 +167,14 @@ export class Transcriber extends Resource {
     }
   }
 
-  private _dropOldChunks() {
+  private _dropOldChunks(): AudioChunk[] {
     return this._config.prefixBufferChunksAmount > 0
       ? this._audioChunks.slice(-this._config.prefixBufferChunksAmount)
       : [];
   }
 
   @trace.span({ showInBrowserTimeline: true })
-  private async _mergeAudioChunks(chunks: AudioChunk[]) {
+  private async _mergeAudioChunks(chunks: AudioChunk[]): Promise<string> {
     const file = new WaveFile();
     const wavConfig = this._recorder.wavConfig;
 
@@ -185,7 +189,7 @@ export class Transcriber extends Resource {
   }
 
   @trace.span({ showInBrowserTimeline: true })
-  private async _fetchTranscription(audio: string) {
+  private async _fetchTranscription(audio: string): Promise<WhisperSegment[]> {
     if (audio.length === 0) {
       this._audioChunks = [];
       throw new Error('No audio to send for transcribing');

package/src/transcriber/transcription-manager.ts

@@ -2,6 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
+import { signal } from '@preact/signals-core';
+
 import { synchronized } from '@dxos/async';
 import { Resource } from '@dxos/context';
 import { QueueImpl, type Queue } from '@dxos/echo-db';
@@ -52,7 +54,7 @@ export class TranscriptionManager extends Resource {
   private _mediaRecorder?: MediaStreamRecorder = undefined;
   private _transcriber?: Transcriber = undefined;
   private _queue?: Queue<DataType.Message> = undefined;
-  private _enabled = false;
+  private _enabled = signal(false);
 
   constructor(options: TranscriptionManagerOptions) {
     super();
@@ -60,14 +62,19 @@ export class TranscriptionManager extends Resource {
     this._messageEnricher = options.messageEnricher;
   }
 
-  protected override async _open() {
+  protected override async _open(): Promise<void> {
     await this._toggleTranscriber();
   }
 
-  protected override async _close() {
+  protected override async _close(): Promise<void> {
     void this._transcriber?.close();
   }
 
+  /** @reactive */
+  get enabled() {
+    return this._enabled.value;
+  }
+
   setQueue(queueDxn: DXN): TranscriptionManager {
     if (this._queue?.dxn.toString() !== queueDxn.toString()) {
       log.info('setQueue', { queueDxn: queueDxn.toString() });
@@ -84,7 +91,7 @@ export class TranscriptionManager extends Resource {
   }
 
   setRecording(recording?: boolean): TranscriptionManager {
-    if (!this.isOpen || !this._enabled) {
+    if (!this.isOpen || !this._enabled.value) {
       return this;
     }
 
@@ -101,18 +108,18 @@ export class TranscriptionManager extends Resource {
    * @param enabled - Whether to enable transcription.
    */
   @synchronized
-  async setEnabled(enabled?: boolean) {
-    if (this._enabled === enabled) {
+  async setEnabled(enabled?: boolean): Promise<void> {
+    if (this._enabled.value === enabled) {
       return;
     }
 
-    this._enabled = enabled ?? false;
+    this._enabled.value = enabled ?? false;
     // TODO(burdon): Why is toggle called here?
     this.isOpen && (await this._toggleTranscriber());
   }
 
   @synchronized
-  async setAudioTrack(track?: MediaStreamTrack) {
+  async setAudioTrack(track?: MediaStreamTrack): Promise<void> {
     if (this._audioStreamTrack === track) {
       return;
     }
@@ -122,11 +129,11 @@ export class TranscriptionManager extends Resource {
   }
 
   // TODO(burdon): Change this to setEnables (explicit), not toggle.
-  private async _toggleTranscriber() {
+  private async _toggleTranscriber(): Promise<void> {
     await this._maybeReinitTranscriber();
 
     // Open or close transcriber if transcription is enabled or disabled.
-    if (this._enabled) {
+    if (this._enabled.value) {
       await this._transcriber?.open();
       // TODO(burdon): Started and stopped blocks appear twice.
       const block = create(DataType.Message, {
@@ -146,8 +153,8 @@ export class TranscriptionManager extends Resource {
     }
   }
 
-  private async _maybeReinitTranscriber() {
-    if (!this._audioStreamTrack || !this._enabled) {
+  private async _maybeReinitTranscriber(): Promise<void> {
+    if (!this._audioStreamTrack || !this._enabled.value) {
       return;
     }
 
@@ -156,7 +163,7 @@ export class TranscriptionManager extends Resource {
     if (this._audioStreamTrack !== this._mediaRecorder?.mediaStreamTrack) {
       this._mediaRecorder = new MediaStreamRecorder({
         mediaStreamTrack: this._audioStreamTrack,
-        interval: RECORD_INTERVAL,
+        config: { interval: RECORD_INTERVAL },
       });
       needReinit = true;
     }
@@ -173,7 +180,7 @@ export class TranscriptionManager extends Resource {
     }
   }
 
-  private async _onSegments(segments: DataType.MessageBlock.Transcription[]) {
+  private async _onSegments(segments: DataType.MessageBlock.Transcription[]): Promise<void> {
     if (!this.isOpen || !this._queue) {
       return;
     }

package/src/translations.ts

@@ -16,9 +16,6 @@ export default [
         'plugin name': 'Transcription',
         'transcript companion label': 'Transcript',
 
-        'start transcription label': 'Start transcription',
-        'stop transcription label': 'Stop transcription',
-
         'delete button': 'Delete',
         'bookmark button': 'Bookmark',
         'scroll to end label': 'Scroll to latest',

package/src/types/schema.ts

@@ -10,8 +10,7 @@ import { Expando, Ref, TypedObject } from '@dxos/echo-schema';
  * Root transcript object created when the user starts a transcription.
  */
 export const TranscriptSchema = Schema.Struct({
-  name: Schema.String,
-
+  // TODO(wittjosiah): Remove?
   // TODO(burdon): Use Date or string?
   started: Schema.optional(Schema.String),
   ended: Schema.optional(Schema.String),

package/src/types/types.ts

@@ -4,8 +4,7 @@
 
 import { Schema } from 'effect';
 
-import { isInstanceOf } from '@dxos/echo-schema';
-import { isLiveObject, SpaceId } from '@dxos/react-client/echo';
+import { SpaceId } from '@dxos/react-client/echo';
 
 import { TranscriptType } from './schema';
 import { TRANSCRIPTION_PLUGIN } from '../meta';
@@ -31,16 +30,3 @@ export namespace TranscriptionAction {
     }),
   }) {}
 }
-
-export const isTranscript = (object: unknown): object is typeof TranscriptType => {
-  return isLiveObject(object) && isInstanceOf(TranscriptType, object);
-};
-
-// TODO(burdon): Create with decode consistently: Schema.decodeSync(TranscriptionSettingsSchema)({}))
-export const TranscriptionSettingsSchema = Schema.mutable(
-  Schema.Struct({
-    entityExtraction: Schema.optional(Schema.Boolean).pipe(Schema.withConstructorDefault(() => true)),
-  }),
-);
-
-export type TranscriptionSettingsProps = Schema.Schema.Type<typeof TranscriptionSettingsSchema>;

package/dist/lib/browser/TranscriptContainer-CXA4ZBHW.mjs

@@ -1,11 +0,0 @@
-import {
-  TranscriptContainer_default,
-  TranscriptionContainer
-} from "./chunk-K2LS2QOM.mjs";
-import "./chunk-LTIQFX4W.mjs";
-import "./chunk-6ZR5MDK3.mjs";
-export {
-  TranscriptionContainer,
-  TranscriptContainer_default as default
-};
-//# sourceMappingURL=TranscriptContainer-CXA4ZBHW.mjs.map