@bendyline/docblocks-react 2.6.2 → 2.7.1

package/dist/chunk-G4MFB3IO.js

@@ -0,0 +1,208 @@
+// src/editor.ts
+import { useEffect, useState } from "react";
+
+// src/components/FindButton.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function FindButton({ active, onActiveChange, shortcutLabel: shortcutLabel2 }) {
+  const tooltip = shortcutLabel2 ? `Find in document (${shortcutLabel2})` : "Find in document";
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      className: `squisq-toolbar-button${active ? " squisq-toolbar-button--active" : ""}`,
+      onClick: () => onActiveChange(!active),
+      "aria-label": "Find in document",
+      "aria-pressed": active,
+      "data-tooltip": tooltip,
+      children: /* @__PURE__ */ jsx(FindGlyph, {})
+    }
+  );
+}
+function FindGlyph() {
+  return /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      width: "16",
+      height: "16",
+      viewBox: "0 0 16 16",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "1.5",
+      strokeLinecap: "round",
+      "aria-hidden": "true",
+      children: [
+        /* @__PURE__ */ jsx("circle", { cx: "6.75", cy: "6.75", r: "4.25" }),
+        /* @__PURE__ */ jsx("path", { d: "m10 10 3.5 3.5" })
+      ]
+    }
+  );
+}
+
+// src/components/find-input.ts
+function focusFindInput(scope = document) {
+  const input = scope.querySelector(".squisq-find-input");
+  input?.focus();
+  input?.select();
+}
+
+// src/DocBlocksShell/keyboard-shortcuts.ts
+var SHELL_SHORTCUTS = Object.freeze([
+  // Must work mid-sentence; that is the entire point of a save shortcut.
+  { id: "save", key: "s", accel: true, label: "Ctrl+S", whileTyping: true },
+  // Find is mostly invoked from inside the document being searched.
+  { id: "find", key: "f", accel: true, label: "Ctrl+F", whileTyping: true },
+  // Jumping elsewhere is as likely mid-sentence as from the tree.
+  { id: "quick-open", key: "p", accel: true, label: "Ctrl+P", whileTyping: true },
+  {
+    id: "workspace-search",
+    key: "f",
+    accel: true,
+    shift: true,
+    label: "Ctrl+Shift+F",
+    whileTyping: true
+  },
+  // Deliberately NOT Cmd+B — Squisq owns that for Bold. Cmd+\ is the VS Code
+  // convention for toggling the side bar.
+  { id: "toggle-sidebar", key: "\\", accel: true, label: "Ctrl+\\", whileTyping: true },
+  { id: "focus-files", key: "e", accel: true, shift: true, label: "Ctrl+Shift+E" },
+  { id: "new-document", key: "n", accel: true, label: "Ctrl+N" },
+  { id: "new-folder", key: "n", accel: true, shift: true, label: "Ctrl+Shift+N" },
+  // Ctrl+, (settings) is deliberately absent: AppMenu owns that dialog's state
+  // internally and exposes no way to open it. Binding the key without first
+  // giving AppMenu a controlled `settingsOpen` prop would ship a dead shortcut.
+  { id: "close-overlay", key: "Escape", accel: false, label: "Esc", whileTyping: true }
+]);
+function isTypingTarget(target) {
+  if (!(target instanceof HTMLElement)) return false;
+  if (target.isContentEditable) return true;
+  const tag = target.tagName;
+  if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return true;
+  return target.closest(".monaco-editor") !== null;
+}
+function matchShortcut(event, _layoutMode) {
+  return SHELL_SHORTCUTS.find((binding) => bindingMatches(binding, event))?.id ?? null;
+}
+function bindingMatches(binding, event) {
+  if (event.altKey) return false;
+  const accel = event.ctrlKey || event.metaKey;
+  const key = event.key.length === 1 ? event.key.toLowerCase() : event.key;
+  if (binding.accel !== accel) return false;
+  if ((binding.shift ?? false) !== event.shiftKey) return false;
+  if (binding.key !== key) return false;
+  return binding.whileTyping === true || !isTypingTarget(event.target);
+}
+function isFindShortcut(event) {
+  const binding = SHELL_SHORTCUTS.find((candidate) => candidate.id === "find");
+  return binding !== void 0 && bindingMatches(binding, event);
+}
+function findShortcutLabel() {
+  return shortcutLabel("find", isApplePlatform());
+}
+function isApplePlatform() {
+  if (typeof navigator === "undefined") return false;
+  return /Mac|iPhone|iPad|iPod/u.test(navigator.platform || navigator.userAgent);
+}
+function shortcutLabel(id, isApple) {
+  const binding = SHELL_SHORTCUTS.find((candidate) => candidate.id === id);
+  if (!binding) return "";
+  return isApple ? binding.label.replace("Ctrl+", "\u2318") : binding.label;
+}
+
+// src/editor.ts
+var PORTRAIT_FORM_FACTOR_QUERY = "(orientation: portrait)";
+function previewViewportPresetForOrientation(isPortrait) {
+  return isPortrait ? "portrait" : "landscape";
+}
+function useResponsivePreviewViewportPreset() {
+  const [isPortrait, setIsPortrait] = useState(() => {
+    if (typeof globalThis.matchMedia !== "function") return false;
+    return globalThis.matchMedia(PORTRAIT_FORM_FACTOR_QUERY).matches;
+  });
+  useEffect(() => {
+    if (typeof globalThis.matchMedia !== "function") return;
+    const query = globalThis.matchMedia(PORTRAIT_FORM_FACTOR_QUERY);
+    const update = () => setIsPortrait(query.matches);
+    update();
+    query.addEventListener("change", update);
+    return () => query.removeEventListener("change", update);
+  }, []);
+  return previewViewportPresetForOrientation(isPortrait);
+}
+var EMPTY_DOCUMENT_PROMPTS = [
+  "Start typing your content, or drop images on top of me...",
+  "Write anything -- paste markdown, drag in images, or just start typing...",
+  "Type away. Markdown syntax works too...",
+  "Chapter 1 begins here...",
+  "Once upon a time...",
+  "A blank page. Exciting, isn't it?",
+  "The first word is always the hardest...",
+  "Plot twist: this is where it all starts...",
+  "Write something the future you will thank you for...",
+  "Begin at the beginning...",
+  "Let's begin.",
+  "We can be heroes...",
+  "Here comes the sun...",
+  "And so it begins...",
+  "Let it be, let it be...",
+  "Don't stop believing...",
+  "Started from the bottom...",
+  "This is the start of something new...",
+  "Ground control to Major Tom...",
+  "Come as you are...",
+  "Every new beginning...",
+  "Hello, is it me you're looking for?",
+  "Imagine all the people...",
+  "Anything you want, you got it...",
+  "Rise above...",
+  "Do you have the time...",
+  "Here we are now, entertain us...",
+  "All the small things...",
+  "Should I stay or should I go?",
+  "I am a patient boy -- I wait, I wait, I wait...",
+  "Destination unknown...",
+  "Easy like Sunday morning...",
+  "Dance, dance, dance to the radio...",
+  "New day rising...",
+  "Visit the world...",
+  "Positive mental attitude...",
+  "Better I sing than I cry...",
+  "Disconnect for a minute...",
+  "We need new noise...",
+  "Shoot the moon...",
+  "I'll surprise you sometime -- I'll come around...",
+  "Coming out of my cage, and doing just fine...",
+  "Throw me to the wolves -- I'll come back, leading the pack...",
+  "There comes a time -- no excuses...",
+  "It's up to me now, turn on the bright lights...",
+  "Do what you want...",
+  "Fingers crossed...",
+  "This is the start of how it all ends...",
+  "It has to start somewhere, it has to start sometime -- what better place than here? what better time than now?",
+  "I know myself, and I'll begin again...",
+  "Dig me out, dig me in...",
+  "Everybody's full of sugar, honey, ice and tea...",
+  "Take time with a wounded hand, 'cause it likes to heal...",
+  "Grab a brush and put on a little makeup...",
+  "Amber is the color of your energy...",
+  "Wait -- they don't love it like I love it...",
+  "A world's been buried, where love is the law; a you-topia..."
+];
+function pickEmptyDocumentPrompt(random = Math.random) {
+  const index = Math.floor(random() * EMPTY_DOCUMENT_PROMPTS.length);
+  return EMPTY_DOCUMENT_PROMPTS[index] ?? EMPTY_DOCUMENT_PROMPTS[0];
+}
+
+export {
+  FindButton,
+  focusFindInput,
+  matchShortcut,
+  isFindShortcut,
+  findShortcutLabel,
+  isApplePlatform,
+  shortcutLabel,
+  PORTRAIT_FORM_FACTOR_QUERY,
+  previewViewportPresetForOrientation,
+  useResponsivePreviewViewportPreset,
+  EMPTY_DOCUMENT_PROMPTS,
+  pickEmptyDocumentPrompt
+};

package/dist/{chunk-MRUK56JS.js → chunk-GMA4KGGO.js}

@@ -51,15 +51,19 @@ function useMenuKeyboard(open, setOpen) {
     (event) => {
       if (event.key === "ArrowDown" || event.key === "ArrowUp") {
         event.preventDefault();
-        pendingFocusRef.current = event.key === "ArrowUp" ? "last" : "first";
-        setOpen(true);
+        if (open) {
+          focusItem(event.key === "ArrowUp" ? items().length - 1 : 0);
+        } else {
+          pendingFocusRef.current = event.key === "ArrowUp" ? "last" : "first";
+          setOpen(true);
+        }
         return;
       }
       if (event.key === "Enter" || event.key === " ") {
         if (!open) pendingFocusRef.current = "first";
       }
     },
-    [open, setOpen]
+    [open, setOpen, focusItem, items]
   );
   const handleMenuKeyDown = useCallback(
     (event) => {

package/dist/chunk-I44HKDQX.js

@@ -0,0 +1,314 @@
+// src/Speech/useGenerateNarration.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useEditorContext } from "@bendyline/squisq-editor-react";
+import {
+  buildNarrationSavePlan,
+  executeNarrationSave
+} from "@bendyline/squisq-editor-react/teleprompter";
+
+// src/Speech/speakable-text.ts
+var MAX_SEGMENT_CHARACTERS = 4e3;
+var FENCE = /^(?<indent> {0,3})(?<marker>`{3,}|~{3,})[^\n]*\n[\s\S]*?^\k<indent>\k<marker>[ \t]*$/gmu;
+function stripFencedCode(markdown) {
+  return markdown.replace(FENCE, "");
+}
+function ensureSentenceEnd(text) {
+  const trimmed = text.trimEnd();
+  if (!trimmed) return trimmed;
+  return /[.!?…:;]["'”’)\]]*$/u.test(trimmed) ? trimmed : `${trimmed}.`;
+}
+function splitLongText(text, start, max = MAX_SEGMENT_CHARACTERS) {
+  const pieces = [];
+  let offset = 0;
+  while (offset < text.length) {
+    let end = Math.min(text.length, offset + max);
+    if (end < text.length) {
+      const window = text.slice(offset, end);
+      const sentence = Math.max(
+        window.lastIndexOf(". "),
+        window.lastIndexOf("! "),
+        window.lastIndexOf("? "),
+        window.lastIndexOf("\n")
+      );
+      const space = window.lastIndexOf(" ");
+      const cut = sentence > max / 4 ? sentence + 1 : space > max / 4 ? space : window.length;
+      end = offset + cut;
+    }
+    const piece = text.slice(offset, end);
+    const leading = piece.length - piece.trimStart().length;
+    const trimmed = piece.trim();
+    if (trimmed) {
+      pieces.push({
+        text: trimmed,
+        start: start + offset + leading,
+        end: start + offset + leading + trimmed.length
+      });
+    }
+    offset = end;
+  }
+  return pieces;
+}
+async function planSpeech(markdown) {
+  const [{ parseMarkdown }, { markdownToDoc }, { buildNarrationScript }] = await Promise.all([
+    import("@bendyline/squisq/markdown"),
+    import("@bendyline/squisq/doc"),
+    import("@bendyline/squisq/narration")
+  ]);
+  const doc = markdownToDoc(parseMarkdown(stripFencedCode(markdown)));
+  const script = buildNarrationScript(doc);
+  const segments = [];
+  for (const block of script.blocks) {
+    const text = script.sourceText.slice(block.charStart, block.charEnd);
+    let bodyStart = block.charStart;
+    const heading = block.heading?.trim();
+    if (heading && text.startsWith(heading)) {
+      segments.push({
+        text: ensureSentenceEnd(heading),
+        blockId: block.blockId,
+        kind: "heading",
+        sourceStart: block.charStart,
+        sourceEnd: block.charStart + heading.length
+      });
+      bodyStart = block.charStart + heading.length;
+    }
+    const lines = /[^\n]+/gu;
+    const body = script.sourceText.slice(bodyStart, block.charEnd);
+    for (const line of body.matchAll(lines)) {
+      for (const piece of splitLongText(line[0], bodyStart + line.index)) {
+        segments.push({
+          text: ensureSentenceEnd(piece.text),
+          blockId: block.blockId,
+          kind: "body",
+          sourceStart: piece.start,
+          sourceEnd: piece.end
+        });
+      }
+    }
+  }
+  return { sourceText: script.sourceText, segments, doc, script };
+}
+
+// src/Speech/tts-narration.ts
+function spokenSpanForChunk(chunk, segment, elapsed) {
+  const length = segment.sourceEnd - segment.sourceStart;
+  const sourceOffset = (offset) => segment.sourceStart + Math.min(offset, length);
+  return {
+    sourceStart: sourceOffset(chunk.textStart),
+    sourceEnd: sourceOffset(chunk.textEnd),
+    startSec: elapsed,
+    endSec: elapsed + chunk.durationSec,
+    ...chunk.wordTimings !== void 0 ? {
+      wordTimings: chunk.wordTimings.map((word) => ({
+        textStart: sourceOffset(word.textStart),
+        textEnd: sourceOffset(word.textEnd),
+        startSec: elapsed + word.startSec,
+        endSec: elapsed + word.endSec
+      })).filter((word) => word.textEnd > word.textStart)
+    } : {}
+  };
+}
+function buildTtsAlignment(script, spans, durationSec) {
+  const ordered = [...spans].sort((a, b) => a.sourceStart - b.sourceStart);
+  const spanOf = new Array(script.tokens.length).fill(-1);
+  let cursor = 0;
+  for (const [tokenIndex, token] of script.tokens.entries()) {
+    while (cursor < ordered.length && ordered[cursor].sourceEnd <= token.charOffset) cursor += 1;
+    const span = ordered[cursor];
+    if (span && token.charOffset >= span.sourceStart) spanOf[tokenIndex] = cursor;
+  }
+  const totals = new Array(ordered.length).fill(0);
+  for (const [tokenIndex, token] of script.tokens.entries()) {
+    const span = spanOf[tokenIndex];
+    if (span >= 0) totals[span] += Math.max(1, token.syllables);
+  }
+  const consumed = new Array(ordered.length).fill(0);
+  const modelWords = ordered.flatMap((span) => span.wordTimings ?? []);
+  const modelTimes = [];
+  let modelCursor = 0;
+  for (const token of script.tokens) {
+    while (modelCursor < modelWords.length && modelWords[modelCursor].textEnd <= token.charOffset)
+      modelCursor++;
+    const word = modelWords[modelCursor];
+    modelTimes.push(word && word.textStart < token.charEnd ? word.startSec : void 0);
+  }
+  const nextModelTimes = [];
+  let nextTime = durationSec;
+  for (let i = modelTimes.length - 1; i >= 0; i--) {
+    nextTime = modelTimes[i] ?? nextTime;
+    nextModelTimes[i] = nextTime;
+  }
+  const words = [];
+  let lastTime = 0;
+  for (const [tokenIndex, token] of script.tokens.entries()) {
+    const index = spanOf[tokenIndex];
+    const modelTime = modelTimes[tokenIndex];
+    const before = index >= 0 ? consumed[index] : 0;
+    if (index >= 0) consumed[index] = before + Math.max(1, token.syllables);
+    if (modelTime !== void 0) {
+      lastTime = Math.max(lastTime, modelTime);
+      words.push({ tokenIndex, tSec: lastTime, interpolated: false });
+      continue;
+    }
+    if (index < 0) {
+      const next = ordered.find((candidate) => candidate.sourceStart > token.charOffset);
+      lastTime = Math.max(
+        lastTime,
+        Math.min(next?.startSec ?? durationSec, nextModelTimes[tokenIndex])
+      );
+      words.push({ tokenIndex, tSec: lastTime, interpolated: true });
+      continue;
+    }
+    const span = ordered[index];
+    const t = span.startSec + (span.endSec - span.startSec) * (before / Math.max(1, totals[index]));
+    lastTime = Math.max(lastTime, Math.min(t, nextModelTimes[tokenIndex]));
+    words.push({ tokenIndex, tSec: lastTime, interpolated: true });
+  }
+  const blocks = [];
+  for (const [blockIndex, block] of script.blocks.entries()) {
+    const first = words[block.tokenStart];
+    blocks.push({
+      blockId: block.blockId,
+      ...block.heading !== void 0 ? { heading: block.heading } : {},
+      blockIndex,
+      charStart: block.charStart,
+      charEnd: block.charEnd,
+      startSec: blockIndex === 0 ? 0 : first?.tSec ?? 0,
+      endSec: durationSec
+    });
+  }
+  for (let i = 0; i < blocks.length - 1; i += 1) {
+    const current = blocks[i];
+    const next = blocks[i + 1];
+    blocks[i] = { ...current, endSec: Math.max(current.startSec, next.startSec) };
+  }
+  return { words, blocks, detectedSyllables: 0, cost: 0 };
+}
+
+// src/Speech/useGenerateNarration.ts
+var TTS_NARRATION_GENERATOR = { name: "docblocks-kokoro", method: "tts" };
+function hasDocumentNarration(markdown) {
+  return /\{\[audio\b[^\]]*\banchor=document\b[^\]]*\]\}/u.test(markdown);
+}
+function useGenerateNarration(speech) {
+  const {
+    markdownSource,
+    setMarkdownSource,
+    mediaProvider,
+    workspaceContainer,
+    bumpMediaRevision
+  } = useEditorContext();
+  const [state, setState] = useState({ phase: "idle" });
+  const sourceRef = useRef(markdownSource);
+  sourceRef.current = markdownSource;
+  const run = useRef(null);
+  const cancel = useCallback(() => {
+    if (run.current) {
+      run.current.cancelled = true;
+      run.current.handle?.cancel();
+      run.current = null;
+    }
+    setState({ phase: "idle" });
+  }, []);
+  useEffect(
+    () => () => {
+      if (run.current) {
+        run.current.cancelled = true;
+        run.current.handle?.cancel();
+      }
+    },
+    []
+  );
+  const generate = useCallback(() => {
+    const synthesize = speech.synthesize;
+    if (!synthesize || !mediaProvider || run.current) return;
+    const current = { cancelled: false, handle: null };
+    run.current = current;
+    setState({ phase: "generating", done: 0, total: 1 });
+    void (async () => {
+      const [plan, { createAudioFileEncoder }] = await Promise.all([
+        planSpeech(sourceRef.current),
+        import("@bendyline/squisq-video-react/encoder")
+      ]);
+      if (current.cancelled) return;
+      if (plan.segments.length === 0) throw new Error("There is nothing to narrate yet.");
+      const encoder = await createAudioFileEncoder({
+        format: "opus-webm",
+        sampleRate: 24e3,
+        channels: 1
+      });
+      try {
+        const spans = [];
+        let elapsed = 0;
+        let appending = Promise.resolve();
+        for (const [index, segment] of plan.segments.entries()) {
+          if (current.cancelled) return;
+          setState({ phase: "generating", done: index, total: plan.segments.length });
+          const handle = synthesize({ text: segment.text }, (event) => {
+            if (event.kind !== "chunk" || current.cancelled) return;
+            const { chunk } = event;
+            spans.push(spokenSpanForChunk(chunk, segment, elapsed));
+            elapsed += chunk.durationSec;
+            const samples = new Float32Array(chunk.pcm);
+            appending = appending.then(() => encoder.append([samples]));
+          });
+          current.handle = handle;
+          const result = await handle.done;
+          if (current.cancelled) return;
+          if (!result.ok) throw new Error(result.error.message);
+        }
+        await appending;
+        if (current.cancelled) return;
+        setState({ phase: "saving" });
+        const audio = await encoder.finish();
+        const savePlan = buildNarrationSavePlan({
+          script: plan.script,
+          alignment: buildTtsAlignment(plan.script, spans, elapsed),
+          durationSec: elapsed,
+          // Squisq's recorder extensions carry the dot (".webm").
+          audioExt: `.${encoder.extension}`,
+          cameraExt: null,
+          generator: TTS_NARRATION_GENERATOR
+        });
+        await executeNarrationSave(
+          savePlan,
+          { audioBlob: audio, audioMime: encoder.mimeType, cameraBlob: null, cameraMime: null },
+          {
+            mediaProvider,
+            container: workspaceContainer,
+            getMarkdownSource: () => sourceRef.current,
+            setMarkdownSource,
+            bumpMediaRevision
+          }
+        );
+        if (current.cancelled) return;
+        run.current = null;
+        setState({ phase: "done", durationSec: elapsed });
+      } finally {
+        if (current.cancelled) await encoder.cancel().catch(() => void 0);
+      }
+    })().catch((error) => {
+      if (current.cancelled) return;
+      run.current = null;
+      setState({
+        phase: "error",
+        message: error instanceof Error ? error.message : "Generating narration failed."
+      });
+    });
+  }, [bumpMediaRevision, mediaProvider, setMarkdownSource, speech, workspaceContainer]);
+  const reset = useCallback(() => {
+    if (!run.current) setState({ phase: "idle" });
+  }, []);
+  return {
+    state,
+    available: Boolean(speech.synthesize && mediaProvider),
+    generate,
+    cancel,
+    reset
+  };
+}
+
+export {
+  planSpeech,
+  hasDocumentNarration,
+  useGenerateNarration
+};

package/dist/chunk-K4I3NJFL.js

@@ -0,0 +1,49 @@
+// src/Ai/ai-status.ts
+import { useEffect, useState } from "react";
+function useAiStatus(ai) {
+  const [status, setStatus] = useState(null);
+  useEffect(() => {
+    let active = true;
+    const unsubscribe = ai.onStatus((next) => {
+      if (active) setStatus(next);
+    });
+    void ai.status().then(
+      (initial) => {
+        if (active) setStatus((current) => current ?? initial);
+      },
+      () => {
+        if (active) {
+          setStatus({
+            kind: "error",
+            error: { code: "unknown", message: "AI status is unavailable." },
+            retryable: true
+          });
+        }
+      }
+    );
+    return () => {
+      active = false;
+      unsubscribe();
+    };
+  }, [ai]);
+  return status;
+}
+function unavailableSentence(status) {
+  if (!status) return "Checking AI connection\u2026";
+  if (status.kind === "connecting") return "AI is getting ready\u2026";
+  if (status.kind === "error") return status.error.message;
+  if (status.kind === "ready" && !status.model) return "Add a model in Settings to use AI.";
+  if (status.kind === "unavailable") {
+    if (status.reason === "opt-out") return "Turn on AI features in Settings.";
+    if (status.reason === "disconnected") return "Built-in AI is starting\u2026";
+    if (status.reason === "not-installed") return "Built-in AI is not available in this build.";
+    if (status.reason === "not-running") return "Built-in AI is restarting\u2026";
+    return "AI is not available in this build.";
+  }
+  return "";
+}
+
+export {
+  useAiStatus,
+  unavailableSentence
+};

package/dist/chunk-KBDZDFPU.js

@@ -0,0 +1,61 @@
+// src/Speech/speech-input-provider.ts
+function toReadiness(readiness) {
+  return {
+    state: readiness.state,
+    ...readiness.reason ? { reason: readiness.reason } : {}
+  };
+}
+function abortable(promise, signal) {
+  if (signal.aborted) return Promise.reject(new DOMException("Aborted", "AbortError"));
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(new DOMException("Aborted", "AbortError"));
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    );
+  });
+}
+function createSpeechInputProvider(speech, options) {
+  const transcribe = speech.transcribe;
+  return {
+    id: "docblocks-dictation",
+    label: "Dictation",
+    async status() {
+      if (!transcribe) return { state: "unavailable" };
+      return toReadiness((await speech.status()).stt);
+    },
+    onStatus(listener) {
+      return speech.onStatus((status) => listener(toReadiness(status.stt)));
+    },
+    async prepare(signal) {
+      const result = await abortable(speech.prepare("stt"), signal);
+      if (!result.ok) throw new Error(result.error.message);
+    },
+    requestSetup: options.onRequestSetup,
+    async transcribe(wav, { prompt, language, signal }) {
+      if (!transcribe) throw new Error("Dictation is not available.");
+      const result = await abortable(
+        transcribe({
+          audio: wav,
+          mimeType: "audio/wav",
+          ...prompt ? { prompt } : {},
+          ...language ? { language } : {}
+        }),
+        signal
+      );
+      if (!result.ok) throw new Error(result.error.message);
+      return { text: result.value.text };
+    }
+  };
+}
+
+export {
+  createSpeechInputProvider
+};

package/dist/{chunk-FNSRCCBC.js → chunk-KWG6UP5O.js}

@@ -1,12 +1,3 @@
-// src/Export/image-save.ts
-function createImageSaveOutput(adapter) {
-  return async (blob, filename) => {
-    const target = await adapter.pickTarget(filename, null);
-    if (!target) return false;
-    return await adapter.saveBlob(blob, filename, target) !== null;
-  };
-}
-
 // src/Export/export-destination.ts
 function updateExportTargetExtension(targetPath, suggestedFilename) {
   const nextExtension = extensionOf(suggestedFilename);
@@ -36,6 +27,5 @@ function firstSuffixIndex(value) {
 }
 
 export {
-  createImageSaveOutput,
   updateExportTargetExtension
 };