@dxos/plugin-transcription 0.8.3 → 0.8.4-main.28f8d3d

package/dist/lib/node/chunk-CVUN3UO7.cjs

@@ -1,778 +0,0 @@
-"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 chunk_CVUN3UO7_exports = {};
-__export(chunk_CVUN3UO7_exports, {
-  IntentResolver: () => IntentResolver,
-  ReactSurface: () => ReactSurface,
-  Transcriber: () => Transcriber,
-  Transcript: () => Transcript,
-  TranscriptContainer_default: () => TranscriptContainer_default,
-  TranscriptionContainer: () => TranscriptionContainer,
-  renderMarkdown: () => renderMarkdown,
-  useAudioFile: () => useAudioFile,
-  useAudioTrack: () => useAudioTrack,
-  useQueueModelAdapter: () => useQueueModelAdapter,
-  useTranscriber: () => useTranscriber,
-  useVoiceInput: () => useVoiceInput
-});
-module.exports = __toCommonJS(chunk_CVUN3UO7_exports);
-var import_chunk_FKDJNJ57 = require("./chunk-FKDJNJ57.cjs");
-var import_tracking = require("@preact-signals/safe-react/tracking");
-var import_react = __toESM(require("react"));
-var import_echo = require("@dxos/client/echo");
-var import_echo2 = require("@dxos/react-client/echo");
-var import_react_ui_stack = require("@dxos/react-ui-stack");
-var import_tracking2 = require("@preact-signals/safe-react/tracking");
-var import_react2 = __toESM(require("react"));
-var import_react_ui = require("@dxos/react-ui");
-var import_react_ui_editor = require("@dxos/react-ui-editor");
-var import_react_ui_theme = require("@dxos/react-ui-theme");
-var import_util = require("@dxos/util");
-var import_state = require("@codemirror/state");
-var import_view = require("@codemirror/view");
-var import_format = require("date-fns/format");
-var import_intervalToDuration = require("date-fns/intervalToDuration");
-var import_async = require("@dxos/async");
-var import_state2 = require("@codemirror/state");
-var import_async2 = require("@dxos/async");
-var import_invariant = require("@dxos/invariant");
-var import_log = require("@dxos/log");
-var import_react3 = require("react");
-var import_async3 = require("@dxos/async");
-var import_context = require("@dxos/context");
-var import_log2 = require("@dxos/log");
-var import_react4 = require("react");
-var import_react5 = require("react");
-var import_react6 = require("react");
-var import_app_framework = require("@dxos/app-framework");
-var import_app_framework2 = require("@dxos/app-framework");
-var import_react7 = require("react");
-var import_async4 = require("@dxos/async");
-var import_context2 = require("@dxos/context");
-var import_log3 = require("@dxos/log");
-var import_react_ui_sfx = require("@dxos/react-ui-sfx");
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/plugin-transcription/src/model/model.ts";
-var DocumentAdapter = class {
-  constructor(_view) {
-    this._view = _view;
-  }
-  /** The document must always have at least one line. */
-  lineCount() {
-    return this._view.state.doc.lines - 1;
-  }
-  replaceLines(from, remove, insert) {
-    (0, import_log.log)("replaceLines", {
-      count: this._view.state.doc.lines,
-      from,
-      remove,
-      insert
-    }, {
-      F: __dxlog_file,
-      L: 39,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const numLines = this._view.state.doc.lines;
-    const posFrom = this._view.state.doc.line(from).from;
-    const posTo = remove === 0 ? posFrom : this._view.state.doc.line(Math.min(numLines, from + remove)).from;
-    let text = insert.join("\n");
-    if (posTo === this._view.state.doc.length) {
-      text += "\n";
-    }
-    this._view.dispatch({
-      changes: {
-        from: posFrom,
-        to: posTo,
-        insert: text
-      }
-    });
-  }
-};
-var SerializationModel = class {
-  constructor(_renderer, initialChunks = []) {
-    this._renderer = _renderer;
-    this._chunks = [];
-    this._chunkLineCounts = /* @__PURE__ */ new Map();
-    this._lineToChunk = /* @__PURE__ */ new Map();
-    this._changes = [];
-    this.update = new import_async2.Event();
-    initialChunks.forEach((chunk) => {
-      this.appendChunk(chunk);
-    });
-  }
-  toJSON() {
-    return {
-      chunks: this._chunks.length,
-      changes: this._changes.length
-    };
-  }
-  get doc() {
-    return import_state2.Text.of([
-      ...this._chunks.flatMap((chunk, index) => this._renderer(chunk, index)),
-      ""
-    ]);
-  }
-  get chunks() {
-    return this._chunks;
-  }
-  /**
-  * Get the block ID at the given line number.
-  */
-  getChunkAtLine(line) {
-    return this._lineToChunk.get(line);
-  }
-  reset() {
-    this._chunks.length = 0;
-    this._chunkLineCounts.clear();
-    this._lineToChunk.clear();
-    this.update.emit();
-    return this;
-  }
-  appendChunk(chunk) {
-    const index = this._chunks.length;
-    this._chunks.push(chunk);
-    this._changes.push({
-      type: "append",
-      index,
-      chunk
-    });
-    this.update.emit();
-    return this;
-  }
-  updateChunk(chunk) {
-    const index = this._chunks.findIndex((c) => c.id === chunk.id);
-    (0, import_invariant.invariant)(index !== -1, void 0, {
-      F: __dxlog_file,
-      L: 147,
-      S: this,
-      A: [
-        "index !== -1",
-        ""
-      ]
-    });
-    this._chunks[index] = chunk;
-    this._changes.push({
-      type: "update",
-      index,
-      chunk
-    });
-    this.update.emit();
-    return this;
-  }
-  deleteBlock(id) {
-    const index = this._chunks.findIndex((c) => c.id === id);
-    (0, import_invariant.invariant)(index !== -1, void 0, {
-      F: __dxlog_file,
-      L: 156,
-      S: this,
-      A: [
-        "index !== -1",
-        ""
-      ]
-    });
-    this._chunks.splice(index, 1);
-    this._changes.push({
-      type: "delete",
-      index,
-      id
-    });
-    this.update.emit();
-    return this;
-  }
-  /**
-  * Syncs the tracked changes with the ChunkDocument.
-  */
-  sync(document2) {
-    (0, import_log.log)("sync", {
-      changes: this._changes
-    }, {
-      F: __dxlog_file,
-      L: 167,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    for (const change of this._changes) {
-      switch (change.type) {
-        case "append": {
-          const lines = this._renderer(change.chunk, change.index);
-          const lastLine = document2.lineCount();
-          document2.replaceLines(lastLine + 1, 0, lines);
-          break;
-        }
-        case "update": {
-          let lineStart = 1;
-          for (let i = 0; i < change.index; i++) {
-            lineStart += this._chunkLineCounts.get(this._chunks[i].id);
-          }
-          const previousLineCount = this._chunkLineCounts.get(change.chunk.id);
-          const newLines = this._renderer(change.chunk, change.index);
-          document2.replaceLines(lineStart, previousLineCount, newLines);
-          break;
-        }
-        case "delete": {
-          let lineStart = 1;
-          for (let i = 0; i < change.index; i++) {
-            lineStart += this._chunkLineCounts.get(this._chunks[i].id);
-          }
-          const previousLineCount = this._chunkLineCounts.get(change.id);
-          document2.replaceLines(lineStart, previousLineCount, []);
-          break;
-        }
-      }
-    }
-    this._lineToChunk.clear();
-    let currentLine = 1;
-    for (const [index, chunk] of this._chunks.entries()) {
-      const lineCount = this._renderer(chunk, index).length;
-      this._chunkLineCounts.set(chunk.id, lineCount);
-      this._lineToChunk.set(currentLine, chunk);
-      currentLine += lineCount;
-    }
-    const chunkIds = new Set(this._chunks.map((chunk) => chunk.id));
-    for (const id of this._chunkLineCounts.keys()) {
-      if (!chunkIds.has(id)) {
-        this._chunkLineCounts.delete(id);
-      }
-    }
-    this._changes.length = 0;
-    return this;
-  }
-};
-var transcript = ({ model, started, renderButton }) => {
-  return [
-    // Show timestamps in the gutter.
-    (0, import_view.gutter)({
-      class: "cm-timestamp-gutter",
-      lineMarkerChange: (update) => update.docChanged || update.viewportChanged,
-      markers: (view) => {
-        const start = getStartTime(started, model.chunks[0]);
-        const builder = new import_state.RangeSetBuilder();
-        for (const { from, to } of view.visibleRanges) {
-          let line = view.state.doc.lineAt(from);
-          while (line.from <= to) {
-            const block = model.getChunkAtLine(line.number)?.blocks[0];
-            const timestamp = block?.type === "transcription" && block.started;
-            if (timestamp) {
-              builder.add(line.from, line.from, new TimestampMarker(line.number, new Date(timestamp), start));
-            }
-            if (line.to + 1 > view.state.doc.length) {
-              break;
-            }
-            line = view.state.doc.lineAt(line.to + 1);
-          }
-        }
-        return builder.finish();
-      }
-    }),
-    // Listen for model updates.
-    import_view.ViewPlugin.fromClass(class {
-      constructor(view) {
-        this._initialized = false;
-        this._adapter = new DocumentAdapter(view);
-        const scroller = view.scrollDOM;
-        let isAutoScrolling = false;
-        let hasScrolled = false;
-        let timeout;
-        const scrollToBottom = (smooth = false) => {
-          scroller.style.scrollBehavior = smooth ? "smooth" : "";
-          scroller.classList.add("cm-hide-scrollbar");
-          isAutoScrolling = true;
-          clearTimeout(timeout);
-          timeout = setTimeout(() => {
-            this._controls?.classList.add("opacity-0");
-            scroller.classList.remove("cm-hide-scrollbar");
-            isAutoScrolling = false;
-          }, 500);
-          view.dispatch({
-            effects: import_view.EditorView.scrollIntoView(view.state.doc.length, {
-              y: "end"
-            })
-          });
-        };
-        if (renderButton) {
-          this._controls = document.createElement("div");
-          this._controls.classList.add("cm-controls", "transition-opacity", "duration-300", "opacity-0");
-          view.dom.appendChild(this._controls);
-          renderButton(this._controls, {
-            onClick: () => {
-              scrollToBottom(false);
-            }
-          }, view);
-        }
-        this._cleanup = (0, import_async.combine)((0, import_async.addEventListener)(view.scrollDOM, "scroll", () => {
-          if (!isAutoScrolling) {
-            hasScrolled = true;
-            this._controls?.classList.remove("opacity-0");
-          }
-        }), model.update.on(() => {
-          const autoScroll = scroller.scrollHeight - scroller.scrollTop - scroller.clientHeight === 0 || !hasScrolled;
-          model.sync(this._adapter);
-          if (autoScroll) {
-            scrollToBottom(true);
-          }
-        }));
-      }
-      update(update) {
-        if (!this._initialized) {
-          this._initialized = true;
-          setTimeout(() => {
-            model.sync(this._adapter);
-          });
-        }
-      }
-      destroy() {
-        this._controls?.remove();
-        this._cleanup();
-      }
-    }),
-    import_view.EditorView.theme({
-      ".cm-scroller": {
-        overflowY: "scroll"
-      },
-      ".cm-hide-scrollbar": {
-        scrollbarWidth: "none",
-        "-ms-overflow-style": "none"
-      },
-      ".cm-hide-scrollbar::-webkit-scrollbar": {
-        display: "none"
-      },
-      ".cm-controls": {
-        position: "absolute",
-        bottom: "0.5rem",
-        right: "0.5rem",
-        zIndex: 1e3
-      },
-      ".cm-line": {
-        paddingRight: "1rem"
-      },
-      ".cm-timestamp-gutter": {
-        width: "6rem",
-        paddingRight: "1rem"
-      },
-      ".cm-timestamp-gutter > .cm-gutterElement > div": {
-        display: "inline-flex",
-        textAlign: "right",
-        padding: "3px"
-      }
-    })
-  ];
-};
-var TimestampMarker = class extends import_view.GutterMarker {
-  constructor(_line, _timestamp, _started) {
-    super(), this._line = _line, this._timestamp = _timestamp, this._started = _started;
-  }
-  eq(other) {
-    return other._timestamp === this._timestamp;
-  }
-  toDOM(view) {
-    const el = document.createElement("div");
-    el.className = "text-sm text-subdued hover:bg-hoverSurface cursor-pointer";
-    el.textContent = formatTimestamp(this._timestamp, this._started);
-    el.onclick = () => {
-      const pos = view.state.doc.line(this._line).from;
-      view.dispatch({
-        effects: import_view.EditorView.scrollIntoView(pos, {
-          y: "start"
-        })
-      });
-    };
-    return el;
-  }
-};
-var getStartTime = (started, message) => {
-  if (started) {
-    return started;
-  }
-  if (message?.blocks[0]?.type === "transcription" && message.blocks[0].started) {
-    return new Date(message.blocks[0].started);
-  }
-  return void 0;
-};
-var formatTimestamp = (timestamp, relative) => {
-  if (relative) {
-    const pad = (n = 0) => String(n).padStart(2, "0");
-    const { hours, minutes, seconds } = (0, import_intervalToDuration.intervalToDuration)({
-      start: relative,
-      end: timestamp
-    });
-    return `${pad(hours)}:${pad(minutes)}:${pad(seconds)}`;
-  } else {
-    return (0, import_format.format)(timestamp, "HH:mm:ss");
-  }
-};
-var renderMarkdown = (identities) => (message, index, debug = false) => {
-  if (message.sender.role === "assistant") {
-    return [
-      message.blocks.find((block) => block.type === "transcription")?.text ?? "",
-      ""
-    ];
-  }
-  const identity = identities.find((identity2) => identity2.did === message.sender.identityDid);
-  const name = identity?.profile?.displayName ?? message.sender.contact?.target?.fullName ?? message.sender.name ?? message.sender.email ?? message.sender.identityDid;
-  const blocks = message.blocks.filter((block) => block.type === "transcription");
-  return [
-    `###### ${name}` + (debug ? ` [${index}]:${message.id}` : ""),
-    blocks.map((block) => block.text.trim()).join(" "),
-    ""
-  ];
-};
-var Transcript = ({ classNames, transcript: object, space, model, attendableId, ignoreAttention }) => {
-  var _effect = (0, import_tracking2.useSignals)();
-  try {
-    const { themeMode } = (0, import_react_ui.useThemeContext)();
-    const { parentRef } = (0, import_react_ui_editor.useTextEditor)(() => {
-      return {
-        extensions: [
-          (0, import_react_ui_editor.createBasicExtensions)({
-            readOnly: true,
-            lineWrapping: true
-          }),
-          (0, import_react_ui_editor.createMarkdownExtensions)({
-            themeMode
-          }),
-          (0, import_react_ui_editor.createThemeExtensions)({
-            themeMode
-          }),
-          (0, import_react_ui_editor.decorateMarkdown)(),
-          space && (0, import_react_ui_editor.preview)(),
-          transcript({
-            model,
-            started: object?.started ? new Date(object.started) : void 0,
-            renderButton: (0, import_react_ui_editor.createRenderer)(({ onClick }) => /* @__PURE__ */ import_react2.default.createElement(import_react_ui.IconButton, {
-              icon: "ph--arrow-line-down--regular",
-              iconOnly: true,
-              label: "Scroll to bottom",
-              onClick
-            }))
-          })
-        ].filter(import_util.isNotFalsy)
-      };
-    }, [
-      space,
-      model
-    ]);
-    return /* @__PURE__ */ import_react2.default.createElement("div", {
-      ref: parentRef,
-      className: (0, import_react_ui_theme.mx)("flex grow overflow-hidden", import_react_ui_editor.editorWidth, classNames),
-      "data-popover-collision-boundary": true
-    });
-  } finally {
-    _effect.f();
-  }
-};
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-transcription/src/hooks/useAudioFile.ts";
-var useAudioFile = (audioUrl, constraints) => {
-  const [{ audio, stream, track }, setStream] = (0, import_react3.useState)({});
-  (0, import_react3.useEffect)(() => {
-    const ctx = new import_context.Context(void 0, {
-      F: __dxlog_file2,
-      L: 20
-    });
-    (0, import_async3.scheduleTask)(ctx, async () => {
-      const response = await fetch(audioUrl);
-      const blob = await response.blob();
-      const objectUrl = URL.createObjectURL(blob);
-      ctx.onDispose(() => {
-        URL.revokeObjectURL(objectUrl);
-      });
-      const audio2 = new Audio();
-      audio2.src = objectUrl;
-      await new Promise((resolve, reject) => {
-        audio2.addEventListener("error", (err) => {
-          import_log2.log.error("error", {
-            err
-          }, {
-            F: __dxlog_file2,
-            L: 37,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-          reject(err);
-        }, {
-          once: true
-        });
-        audio2.addEventListener("canplay", async () => {
-          import_log2.log.info("starting...", void 0, {
-            F: __dxlog_file2,
-            L: 45,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-          try {
-            await audio2.play();
-            resolve();
-          } catch (playError) {
-            import_log2.log.error("Play failed", {
-              playError
-            }, {
-              F: __dxlog_file2,
-              L: 51,
-              S: void 0,
-              C: (f, a) => f(...a)
-            });
-            resolve();
-          }
-        }, {
-          once: true
-        });
-        audio2.load();
-      });
-      const audioCtx = new AudioContext();
-      if (audioCtx.state === "suspended") {
-        await audioCtx.resume();
-      }
-      const destination = audioCtx.createMediaStreamDestination();
-      destination.channelCount = 1;
-      const source = audioCtx.createMediaElementSource(audio2);
-      source.connect(destination);
-      const track2 = destination.stream.getAudioTracks()[0];
-      if (constraints) {
-        await track2.applyConstraints(constraints).catch((err) => import_log2.log.catch(err, void 0, {
-          F: __dxlog_file2,
-          L: 75,
-          S: void 0,
-          C: (f, a) => f(...a)
-        }));
-      }
-      setStream({
-        audio: audio2,
-        stream: destination.stream,
-        track: destination.stream.getAudioTracks()[0]
-      });
-    });
-    return () => {
-      void ctx.dispose();
-    };
-  }, [
-    audioUrl
-  ]);
-  return {
-    audio,
-    stream,
-    track
-  };
-};
-var useAudioTrack = (active, constraints) => {
-  const [track, setTrack] = (0, import_react4.useState)();
-  (0, import_react4.useEffect)(() => {
-    if (!active) {
-      track?.stop();
-      setTrack(void 0);
-      return;
-    }
-    const initAudio = async () => {
-      const audio = new Audio();
-      audio.srcObject = await navigator.mediaDevices.getUserMedia({
-        audio: constraints ?? true
-      });
-      const [track2] = audio.srcObject.getAudioTracks();
-      if (track2) {
-        setTrack(track2);
-      }
-    };
-    if (active) {
-      void initAudio();
-    }
-  }, [
-    active
-  ]);
-  return track;
-};
-var useQueueModelAdapter = (renderer, queue, initialChunks = []) => {
-  const model = (0, import_react5.useMemo)(() => new SerializationModel(renderer, initialChunks), [
-    queue
-  ]);
-  const [loaded, setLoaded] = (0, import_react5.useState)(false);
-  (0, import_react5.useEffect)(() => {
-    if (!queue) {
-      return;
-    }
-    const update = () => {
-      for (const block of queue?.objects ?? []) {
-        model.appendChunk(block);
-      }
-      setLoaded(true);
-    };
-    let i;
-    if (queue.isLoading) {
-      i = setInterval(() => {
-        if (!queue?.isLoading) {
-          clearInterval(i);
-          update();
-        }
-      }, 1e3);
-    } else {
-      update();
-    }
-    return () => clearTimeout(i);
-  }, [
-    model,
-    queue
-  ]);
-  (0, import_react5.useEffect)(() => {
-    if (!loaded || !queue || model.chunks.length === queue.objects.length) {
-      return;
-    }
-    const chunk = queue.objects.at(-1);
-    if (chunk) {
-      model.appendChunk(chunk);
-    }
-  }, [
-    model,
-    loaded,
-    queue?.objects.length
-  ]);
-  return model;
-};
-var IntentResolver = (0, import_app_framework2.lazy)(() => import("./intent-resolver-LL3TTI4H.cjs"));
-var ReactSurface = (0, import_app_framework2.lazy)(() => import("./react-surface-N25TBBG4.cjs"));
-var Transcriber = (0, import_app_framework2.lazy)(() => import("./transcriber-6J4FVFSZ.cjs"));
-var useTranscriber = ({ audioStreamTrack, onSegments, transcriberConfig, recorderConfig }) => {
-  const [getTranscriber] = (0, import_app_framework.useCapabilities)(import_chunk_FKDJNJ57.TranscriptionCapabilities.Transcriber);
-  const transcriber = (0, import_react6.useMemo)(() => {
-    if (!onSegments || !audioStreamTrack || !getTranscriber) {
-      return void 0;
-    }
-    return getTranscriber({
-      audioStreamTrack,
-      onSegments,
-      transcriberConfig,
-      recorderConfig
-    });
-  }, [
-    audioStreamTrack,
-    onSegments,
-    getTranscriber,
-    transcriberConfig,
-    recorderConfig
-  ]);
-  (0, import_react6.useEffect)(() => {
-    return () => {
-      void transcriber?.close();
-    };
-  }, [
-    transcriber
-  ]);
-  return transcriber;
-};
-var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/plugins/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_react7.useCallback)(async (segments) => {
-    const text = segments.map((str) => str.text.trim().replace(/[^\w\s]/g, "")).join(" ");
-    onUpdate(text);
-  }, []);
-  const [recording, setRecording] = (0, import_react7.useState)(false);
-  const track = useAudioTrack(active);
-  const transcriber = useTranscriber({
-    audioStreamTrack: track,
-    onSegments: handleSegments
-  });
-  (0, import_react7.useEffect)(() => {
-    const ctx = new import_context2.Context(void 0, {
-      F: __dxlog_file3,
-      L: 43
-    });
-    (0, import_async4.scheduleMicroTask)(ctx, async () => {
-      if (active && transcriber) {
-        await transcriber.open();
-        import_log3.log.info("starting...", void 0, {
-          F: __dxlog_file3,
-          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_log3.log.info("stopped", void 0, {
-          F: __dxlog_file3,
-          L: 54,
-          S: void 0,
-          C: (f, a) => f(...a)
-        });
-        setRecording(false);
-        void soundStop.play();
-      }
-    });
-    return () => {
-      void ctx.dispose();
-    };
-  }, [
-    active,
-    transcriber
-  ]);
-  return {
-    recording
-  };
-};
-var TranscriptionContainer = ({ role, transcript: transcript2 }) => {
-  var _effect = (0, import_tracking.useSignals)();
-  try {
-    const attendableId = (0, import_echo.fullyQualifiedId)(transcript2);
-    const space = (0, import_echo.getSpace)(transcript2);
-    const members = (0, import_echo2.useMembers)(space?.key).map((member) => member.identity);
-    const queue = (0, import_echo2.useQueue)(transcript2.queue.dxn, {
-      pollInterval: 1e3
-    });
-    const model = useQueueModelAdapter(renderMarkdown(members), queue);
-    return /* @__PURE__ */ import_react.default.createElement(import_react_ui_stack.StackItem.Content, {
-      role,
-      classNames: "container-max-width pli-2"
-    }, /* @__PURE__ */ import_react.default.createElement(Transcript, {
-      attendableId,
-      space,
-      model,
-      transcript: transcript2
-    }));
-  } finally {
-    _effect.f();
-  }
-};
-var TranscriptContainer_default = TranscriptionContainer;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  IntentResolver,
-  ReactSurface,
-  Transcriber,
-  Transcript,
-  TranscriptContainer_default,
-  TranscriptionContainer,
-  renderMarkdown,
-  useAudioFile,
-  useAudioTrack,
-  useQueueModelAdapter,
-  useTranscriber,
-  useVoiceInput
-});
-//# sourceMappingURL=chunk-CVUN3UO7.cjs.map