@dxos/plugin-transcription 0.7.5-main.b19bfc8

package/dist/lib/node/index.cjs

@@ -0,0 +1,661 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var node_exports = {};
+__export(node_exports, {
+  AppGraphBuilder: () => AppGraphBuilder,
+  IntentResolver: () => IntentResolver,
+  MediaStreamRecorder: () => MediaStreamRecorder,
+  ReactSurface: () => ReactSurface,
+  TRANSCRIPTION_PLUGIN: () => import_chunk_UIHEGU6Q.TRANSCRIPTION_PLUGIN,
+  Transcriber: () => Transcriber,
+  Transcript: () => import_chunk_Y2GCR535.Transcript,
+  TranscriptContainer: () => import_chunk_SQHF7N3B.TranscriptContainer,
+  TranscriptionCapabilities: () => TranscriptionCapabilities,
+  TranscriptionContainer: () => import_chunk_Y2GCR535.TranscriptionContainer,
+  TranscriptionPlugin: () => TranscriptionPlugin,
+  meta: () => import_chunk_UIHEGU6Q.meta,
+  useAudioFile: () => useAudioFile,
+  useAudioTrack: () => useAudioTrack,
+  useIsSpeaking: () => useIsSpeaking,
+  useTranscriber: () => useTranscriber,
+  useVoiceInput: () => useVoiceInput
+});
+module.exports = __toCommonJS(node_exports);
+var import_chunk_JBN3P6ZF = require("./chunk-JBN3P6ZF.cjs");
+var import_chunk_SQHF7N3B = require("./chunk-SQHF7N3B.cjs");
+var import_chunk_Y2GCR535 = require("./chunk-Y2GCR535.cjs");
+var import_chunk_UIHEGU6Q = require("./chunk-UIHEGU6Q.cjs");
+var import_app_framework = require("@dxos/app-framework");
+var import_app_framework2 = require("@dxos/app-framework");
+var import_react = require("react");
+var import_log = require("@dxos/log");
+var import_react2 = require("react");
+var import_react3 = require("react");
+var import_react4 = require("react");
+var import_extendable_media_recorder = require("extendable-media-recorder");
+var import_wavefile = require("wavefile");
+var import_async = require("@dxos/async");
+var import_invariant = require("@dxos/invariant");
+var import_log2 = require("@dxos/log");
+var import_tracing = require("@dxos/tracing");
+var import_wavefile2 = require("wavefile");
+var import_async2 = require("@dxos/async");
+var import_context = require("@dxos/context");
+var import_log3 = require("@dxos/log");
+var import_tracing2 = require("@dxos/tracing");
+var import_react5 = require("react");
+var import_async3 = require("@dxos/async");
+var import_context2 = require("@dxos/context");
+var import_log4 = require("@dxos/log");
+var import_react_ui_sfx = require("@dxos/react-ui-sfx");
+var import_app_framework3 = require("@dxos/app-framework");
+var import_plugin_client = require("@dxos/plugin-client");
+var TranscriptionCapabilities;
+(function(TranscriptionCapabilities2) {
+  TranscriptionCapabilities2.Transcription = (0, import_app_framework2.defineCapability)(`${import_chunk_UIHEGU6Q.TRANSCRIPTION_PLUGIN}/capability/transcription`);
+})(TranscriptionCapabilities || (TranscriptionCapabilities = {}));
+var AppGraphBuilder = (0, import_app_framework.lazy)(() => import("./app-graph-builder-YFBX3OTP.cjs"));
+var IntentResolver = (0, import_app_framework.lazy)(() => import("./intent-resolver-3KJZGGUQ.cjs"));
+var ReactSurface = (0, import_app_framework.lazy)(() => import("./react-surface-L4NQQWN4.cjs"));
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-transcription/src/hooks/useAudioFile.ts";
+var useAudioFile = (audioUrl) => {
+  const [{ audio, stream, track }, setStream] = (0, import_react.useState)({});
+  (0, import_react.useEffect)(() => {
+    const t = setTimeout(async () => {
+      const response = await fetch(audioUrl);
+      const blob = await response.blob();
+      const audio2 = new Audio();
+      audio2.src = URL.createObjectURL(blob);
+      await new Promise((resolve, reject) => {
+        audio2.addEventListener("error", (err) => {
+          import_log.log.error("error", {
+            err
+          }, {
+            F: __dxlog_file,
+            L: 27,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+          reject(err);
+        }, {
+          once: true
+        });
+        audio2.addEventListener("canplay", () => {
+          import_log.log.info("starting...", void 0, {
+            F: __dxlog_file,
+            L: 35,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+          resolve();
+        }, {
+          once: true
+        });
+        audio2.load();
+      });
+      const ctx = new AudioContext();
+      const destination = ctx.createMediaStreamDestination();
+      destination.channelCount = 1;
+      const source = ctx.createMediaElementSource(audio2);
+      source.connect(destination);
+      setStream({
+        audio: audio2,
+        stream: destination.stream,
+        track: destination.stream.getAudioTracks()[0]
+      });
+    });
+    return () => clearTimeout(t);
+  }, [
+    audioUrl
+  ]);
+  return {
+    audio,
+    stream,
+    track
+  };
+};
+var useAudioTrack = (active) => {
+  const [track, setTrack] = (0, import_react2.useState)();
+  (0, import_react2.useEffect)(() => {
+    if (!active) {
+      track?.stop();
+      setTrack(void 0);
+      return;
+    }
+    const initAudio = async () => {
+      const audio = new Audio();
+      audio.srcObject = await navigator.mediaDevices.getUserMedia({
+        audio: true
+      });
+      const [track2] = audio.srcObject.getAudioTracks();
+      if (track2) {
+        setTrack(track2);
+      }
+    };
+    if (active) {
+      void initAudio();
+    }
+  }, [
+    active
+  ]);
+  return track;
+};
+var useIsSpeaking = (mediaStreamTrack) => {
+  const [isSpeaking, setIsSpeaking] = (0, import_react3.useState)(false);
+  const isSpeakingRef = (0, import_react3.useRef)(isSpeaking);
+  (0, import_react3.useEffect)(() => {
+    if (!mediaStreamTrack) {
+      setIsSpeaking(false);
+      return;
+    }
+    isSpeakingRef.current = isSpeaking;
+    const interval = window.setInterval(() => {
+      if (isSpeaking === isSpeakingRef.current) {
+        return;
+      }
+      setIsSpeaking(isSpeakingRef.current);
+    }, 50);
+    return () => {
+      clearInterval(interval);
+    };
+  }, [
+    isSpeaking,
+    isSpeakingRef,
+    mediaStreamTrack
+  ]);
+  (0, import_react3.useEffect)(() => {
+    if (!mediaStreamTrack) {
+      return;
+    }
+    let timeout = -1;
+    const cleanup = (0, import_chunk_JBN3P6ZF.monitorAudioLevel)({
+      mediaStreamTrack,
+      onMeasure: (vol) => {
+        const audioLevelAboveThreshold = vol > (isSpeakingRef.current ? 0.02 : 0.05);
+        if (audioLevelAboveThreshold) {
+          clearTimeout(timeout);
+          timeout = -1;
+          isSpeakingRef.current = true;
+        } else if (timeout === -1) {
+          timeout = window.setTimeout(() => {
+            isSpeakingRef.current = false;
+            timeout = -1;
+          }, 1e3);
+        }
+      }
+    });
+    return () => {
+      cleanup();
+    };
+  }, [
+    isSpeaking,
+    mediaStreamTrack
+  ]);
+  return isSpeaking;
+};
+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 __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-transcription/src/transcriber/media-stream-recorder.ts";
+var initializingPromise;
+var initializeExtendableMediaRecorder = async () => {
+  const { connect } = await import("extendable-media-recorder-wav-encoder");
+  await (0, import_extendable_media_recorder.register)(await connect());
+};
+var MediaStreamRecorder = class {
+  constructor({ mediaStreamTrack, interval }) {
+    this._mediaRecorder = void 0;
+    this._header = void 0;
+    this._mediaStreamTrack = mediaStreamTrack;
+    this._interval = interval;
+  }
+  get wavConfig() {
+    const settings = this._mediaStreamTrack.getSettings();
+    return {
+      channels: settings.channelCount ?? 1,
+      sampleRate: settings.sampleRate ?? 16e3,
+      bitDepthCode: settings.sampleSize ? String(settings.sampleSize) : "16"
+    };
+  }
+  setOnChunk(onChunk) {
+    this._onChunk = onChunk;
+  }
+  async start() {
+    await (initializingPromise ??= initializeExtendableMediaRecorder()).catch((err) => import_log2.log.info("initializeExtendableMediaRecorder", {
+      err
+    }, {
+      F: __dxlog_file2,
+      L: 58,
+      S: this,
+      C: (f, a) => f(...a)
+    }));
+    if (!this._mediaRecorder) {
+      const stream = new MediaStream([
+        this._mediaStreamTrack
+      ]);
+      this._mediaRecorder = new import_extendable_media_recorder.MediaRecorder(stream, {
+        mimeType: "audio/wav"
+      });
+    }
+    if (this._mediaRecorder.state === "recording") {
+      return;
+    }
+    (0, import_invariant.invariant)(this._onChunk, "MediaStreamRecorder: onChunk is not set", {
+      F: __dxlog_file2,
+      L: 69,
+      S: this,
+      A: [
+        "this._onChunk",
+        "'MediaStreamRecorder: onChunk is not set'"
+      ]
+    });
+    this._mediaRecorder.ondataavailable = (event) => this._ondataavailable(event);
+    this._mediaRecorder.start(this._interval);
+  }
+  async stop() {
+    if (this._mediaRecorder?.state !== "recording") {
+      return;
+    }
+    this._mediaRecorder.stop();
+  }
+  async _ondataavailable(event) {
+    const blob = event.data;
+    const uint8Array = new Uint8Array(await blob.arrayBuffer());
+    const isHeader = uint8Array[0] === 82 && // R
+    uint8Array[1] === 73 && // I
+    uint8Array[2] === 70 && // F
+    uint8Array[3] === 70;
+    let wav;
+    if (isHeader) {
+      wav = new import_wavefile.WaveFile(uint8Array);
+      this._header = uint8Array.slice(0, 44);
+    } else if (this._header) {
+      wav = new import_wavefile.WaveFile(new Uint8Array([
+        ...this._header,
+        ...uint8Array
+      ]));
+    } else {
+      import_log2.log.warn("MediaStreamRecorder: no header", void 0, {
+        F: __dxlog_file2,
+        L: 100,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    this._onChunk({
+      timestamp: Date.now(),
+      data: wav.getSamples()
+    });
+  }
+};
+_ts_decorate([
+  import_async.synchronized
+], MediaStreamRecorder.prototype, "_ondataavailable", null);
+MediaStreamRecorder = _ts_decorate([
+  import_tracing.trace.resource()
+], MediaStreamRecorder);
+function _ts_decorate2(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 __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-transcription/src/transcriber/transcriber.ts";
+var Transcriber = class extends import_context.Resource {
+  constructor({ config, recorder, onSegments }) {
+    super();
+    this._audioChunks = [];
+    this._lastUsedTimestamp = 0;
+    this._openTrigger = new import_async2.Trigger({
+      autoReset: true
+    });
+    this._recording = false;
+    this._transcribeTask = void 0;
+    this._config = config;
+    this._recorder = recorder;
+    this._onSegments = onSegments;
+  }
+  async _open(ctx) {
+    this._recorder.setOnChunk((chunk) => this._saveAudioChunk(chunk));
+    await this._recorder.start();
+    this._transcribeTask = new import_async2.DeferredTask(ctx, async () => this._transcribe());
+    this._openTrigger.wake();
+  }
+  async _close() {
+    this._recording = false;
+    this._transcribeTask = void 0;
+    await this._recorder.stop();
+  }
+  startChunksRecording() {
+    if (this._lifecycleState !== import_context.LifecycleState.OPEN) {
+      return;
+    }
+    this._recording = true;
+  }
+  stopChunksRecording() {
+    if (this._lifecycleState !== import_context.LifecycleState.OPEN || !this._recording) {
+      return;
+    }
+    this._recording = false;
+    this._transcribeTask?.schedule();
+  }
+  _saveAudioChunk(chunk) {
+    (0, import_log3.log)("saving audio chunk", {
+      chunk
+    }, {
+      F: __dxlog_file3,
+      L: 124,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    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();
+    }
+  }
+  async _transcribe() {
+    (0, import_log3.log)("transcribing", {
+      chunks: this._audioChunks.length
+    }, {
+      F: __dxlog_file3,
+      L: 140,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    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 import_wavefile2.WaveFile();
+    const wavConfig = this._recorder.wavConfig;
+    file.fromScratch(wavConfig.channels, wavConfig.sampleRate, wavConfig.bitDepthCode, (0, import_chunk_JBN3P6ZF.mergeFloat64Arrays)(chunks.map(({ data }) => data)));
+    return file.toBase64();
+  }
+  async _fetchTranscription(audio) {
+    if (audio.length === 0) {
+      this._audioChunks = [];
+      throw new Error("No audio to send for transcribing");
+    }
+    const response = await fetch(`${import_chunk_UIHEGU6Q.TRANSCRIPTION_URL}/transcribe`, {
+      method: "POST",
+      body: JSON.stringify({
+        audio
+      }),
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      this._audioChunks = [];
+      throw new Error("Failed to transcribe");
+    }
+    const { segments } = await response.json();
+    import_log3.log.info("transcription response", {
+      segments,
+      string: segments.map((segments2) => segments2.text).join(" ")
+    }, {
+      F: __dxlog_file3,
+      L: 206,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    return segments;
+  }
+  _alignSegments(segments, originalChunks) {
+    const zeroTimestamp = originalChunks.at(0).timestamp;
+    const filteredSegments = segments.filter((segment) => zeroTimestamp + segment.end * 1e3 >= this._lastUsedTimestamp).map((segment) => {
+      const words = segment.words.filter((word) => zeroTimestamp + word.start * 1e3 >= this._lastUsedTimestamp);
+      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 [];
+    }
+    this._lastUsedTimestamp = zeroTimestamp + filteredSegments.at(-1).end * 1e3;
+    return filteredSegments.map((segment) => ({
+      started: new Date(zeroTimestamp + segment.start * 1e3),
+      text: segment.text
+    }));
+  }
+};
+_ts_decorate2([
+  import_tracing2.trace.span({
+    showInBrowserTimeline: true
+  })
+], Transcriber.prototype, "_mergeAudioChunks", null);
+_ts_decorate2([
+  import_tracing2.trace.span({
+    showInBrowserTimeline: true
+  })
+], Transcriber.prototype, "_fetchTranscription", null);
+var RECORD_INTERVAL = 200;
+var PREFIXED_CHUNKS_AMOUNT = 10;
+var TRANSCRIBE_AFTER_CHUNKS_AMOUNT = 50;
+var useTranscriber = ({ audioStreamTrack, onSegments }) => {
+  const transcriber = (0, import_react4.useMemo)(() => {
+    if (!onSegments || !audioStreamTrack) {
+      return void 0;
+    }
+    return new Transcriber({
+      config: {
+        transcribeAfterChunksAmount: TRANSCRIBE_AFTER_CHUNKS_AMOUNT,
+        prefixBufferChunksAmount: PREFIXED_CHUNKS_AMOUNT
+      },
+      recorder: new MediaStreamRecorder({
+        mediaStreamTrack: audioStreamTrack,
+        interval: RECORD_INTERVAL
+      }),
+      onSegments
+    });
+  }, [
+    audioStreamTrack,
+    onSegments
+  ]);
+  (0, import_react4.useEffect)(() => {
+    return () => {
+      void transcriber?.close();
+    };
+  }, [
+    transcriber
+  ]);
+  return transcriber;
+};
+var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-transcription/src/hooks/useVoiceInput.ts";
+var useVoiceInput = ({ active, onUpdate }) => {
+  const soundStart = (0, import_react_ui_sfx.useSoundEffect)("StartRecording");
+  const soundStop = (0, import_react_ui_sfx.useSoundEffect)("StopRecording");
+  const handleSegments = (0, import_react5.useCallback)(async (segments) => {
+    const text = segments.map((str) => str.text.trim().replace(/[^\w\s]/g, "")).join(" ");
+    onUpdate(text);
+  }, []);
+  const [recording, setRecording] = (0, import_react5.useState)(false);
+  const track = useAudioTrack(active);
+  const transcriber = useTranscriber({
+    audioStreamTrack: track,
+    onSegments: handleSegments
+  });
+  (0, import_react5.useEffect)(() => {
+    const ctx = new import_context2.Context(void 0, {
+      F: __dxlog_file4,
+      L: 43
+    });
+    (0, import_async3.scheduleMicroTask)(ctx, async () => {
+      if (active && transcriber) {
+        await transcriber.open();
+        import_log4.log.info("starting...", void 0, {
+          F: __dxlog_file4,
+          L: 47,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+        setRecording(true);
+        void soundStart.play();
+        transcriber.startChunksRecording();
+      } else if (!active && transcriber?.isOpen) {
+        transcriber?.stopChunksRecording();
+        await transcriber?.close();
+        import_log4.log.info("stopped", void 0, {
+          F: __dxlog_file4,
+          L: 54,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+        setRecording(false);
+        void soundStop.play();
+      }
+    });
+    return () => {
+      void ctx.dispose();
+    };
+  }, [
+    active,
+    transcriber
+  ]);
+  return {
+    recording
+  };
+};
+var translations_default = [
+  {
+    "en-US": {
+      [import_chunk_UIHEGU6Q.TranscriptType.typename]: {
+        "typename label": "Transcript"
+      },
+      [import_chunk_UIHEGU6Q.TRANSCRIPTION_PLUGIN]: {
+        "plugin name": "Transcription",
+        "calls label": "Transcript",
+        "calls panel label": "Transcription",
+        "create calls label": "Create transcription",
+        "delete calls label": "Delete",
+        "delete button": "Delete",
+        "bookmark button": "Bookmark",
+        "summary button": "Create summary",
+        "summarizing label": "Summarizing..."
+      }
+    }
+  }
+];
+var TranscriptionPlugin = () => (0, import_app_framework3.definePlugin)(import_chunk_UIHEGU6Q.meta, [
+  (0, import_app_framework3.defineModule)({
+    id: `${import_chunk_UIHEGU6Q.meta.id}/module/translations`,
+    activatesOn: import_app_framework3.Events.SetupTranslations,
+    activate: () => (0, import_app_framework3.contributes)(import_app_framework3.Capabilities.Translations, translations_default)
+  }),
+  (0, import_app_framework3.defineModule)({
+    id: `${import_chunk_UIHEGU6Q.meta.id}/module/transcription`,
+    activatesOn: import_app_framework3.Events.Startup,
+    activate: () => (0, import_app_framework3.contributes)(TranscriptionCapabilities.Transcription, null)
+  }),
+  (0, import_app_framework3.defineModule)({
+    id: `${import_chunk_UIHEGU6Q.meta.id}/module/metadata`,
+    activatesOn: import_app_framework3.Events.SetupMetadata,
+    activate: () => (0, import_app_framework3.contributes)(import_app_framework3.Capabilities.Metadata, {
+      id: import_chunk_UIHEGU6Q.TranscriptType.typename,
+      metadata: {
+        placeholder: [
+          "transcript title placeholder",
+          {
+            ns: import_chunk_UIHEGU6Q.TRANSCRIPTION_PLUGIN
+          }
+        ],
+        icon: "ph--subtitles--regular"
+      }
+    })
+  }),
+  (0, import_app_framework3.defineModule)({
+    id: `${import_chunk_UIHEGU6Q.meta.id}/module/schema`,
+    activatesOn: import_plugin_client.ClientEvents.SetupSchema,
+    activate: () => [
+      (0, import_app_framework3.contributes)(import_plugin_client.ClientCapabilities.Schema, [
+        import_chunk_UIHEGU6Q.TranscriptType
+      ])
+    ]
+  }),
+  (0, import_app_framework3.defineModule)({
+    id: `${import_chunk_UIHEGU6Q.meta.id}/module/react-surface`,
+    activatesOn: import_app_framework3.Events.SetupReactSurface,
+    activate: ReactSurface
+  }),
+  (0, import_app_framework3.defineModule)({
+    id: `${import_chunk_UIHEGU6Q.meta.id}/module/intent-resolver`,
+    activatesOn: import_app_framework3.Events.SetupIntentResolver,
+    activate: IntentResolver
+  }),
+  (0, import_app_framework3.defineModule)({
+    id: `${import_chunk_UIHEGU6Q.meta.id}/module/app-graph-builder`,
+    activatesOn: import_app_framework3.Events.SetupAppGraph,
+    activate: AppGraphBuilder
+  })
+]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppGraphBuilder,
+  IntentResolver,
+  MediaStreamRecorder,
+  ReactSurface,
+  TRANSCRIPTION_PLUGIN,
+  Transcriber,
+  Transcript,
+  TranscriptContainer,
+  TranscriptionCapabilities,
+  TranscriptionContainer,
+  TranscriptionPlugin,
+  meta,
+  useAudioFile,
+  useAudioTrack,
+  useIsSpeaking,
+  useTranscriber,
+  useVoiceInput
+});
+//# sourceMappingURL=index.cjs.map