@bendyline/docblocks-react 2.7.4 → 2.7.6

package/dist/{SpeechToolbarControl-KNI2C4JJ.js → SpeechToolbarControl-E6OSJGHL.js}

@@ -5,11 +5,11 @@ import {
   hasDocumentNarration,
   planSpeech,
   useGenerateNarration
-} from "./chunk-I44HKDQX.js";
+} from "./chunk-3TSJQESW.js";
 import {
   AutoPlayGate,
   ProgressivePlayer
-} from "./chunk-2IYBBFQX.js";
+} from "./chunk-BZRYQENB.js";
 import {
   useMenuKeyboard
 } from "./chunk-GMA4KGGO.js";
@@ -89,44 +89,144 @@ function GenerateNarrationDialog({ speech, onClose }) {
 
 // src/Speech/useReadAloud.ts
 import { useCallback, useEffect, useRef, useState } from "react";
+var RESTART_SEGMENT_SECONDS = 2;
+var POLL_MS = 250;
+var SENTENCE_BREAK = /(?<=[.!?…])\s+/u;
+function* upcomingSentences(segments, segment, offset) {
+  for (let index = segment; index < segments.length; index += 1) {
+    const text = segments[index]?.text ?? "";
+    for (const sentence of (index === segment ? text.slice(offset) : text).split(SENTENCE_BREAK)) {
+      const length = sentence.trim().length;
+      if (length > 0) yield length;
+    }
+  }
+}
+function playIfReady(current) {
+  if (current.cancelled || current.userPaused || current.synthesizing === null) return;
+  const snapshot = current.player.snapshot();
+  if (snapshot.isPlaying) return;
+  const ready = current.gate.ready(
+    snapshot.bufferedDuration - snapshot.currentTime,
+    upcomingSentences(current.segments, current.synthesizing, current.synthesizedThrough),
+    performance.now()
+  );
+  if (ready) void current.player.play();
+}
+function endSession(current) {
+  current.cancelled = true;
+  current.handle?.cancel();
+  if (current.poll) clearInterval(current.poll);
+  current.player.dispose();
+}
+function sameState(a, b) {
+  if (a.phase === "reading" && b.phase === "reading") {
+    return a.playing === b.playing && a.waiting === b.waiting && a.segment === b.segment && a.segments === b.segments;
+  }
+  return a.phase === b.phase && a.phase !== "error";
+}
+function segmentAt(current, snapshot) {
+  const caughtUp = !snapshot.isPlaying && snapshot.currentTime >= snapshot.bufferedDuration - 0.05;
+  if (caughtUp && current.synthesizing !== null) return current.synthesizing;
+  if (snapshot.currentChunk === null) return current.firstSegment;
+  return current.chunkSegments[snapshot.currentChunk] ?? current.firstSegment;
+}
 function useReadAloud(speech) {
   const [state, setState] = useState({ phase: "idle" });
   const session = useRef(null);
   const stop = useCallback(() => {
     const current = session.current;
     session.current = null;
-    if (current) {
-      current.cancelled = true;
-      current.handle?.cancel();
-      current.player.dispose();
-    }
+    if (current) endSession(current);
     setState({ phase: "idle" });
   }, []);
   useEffect(() => stop, [stop]);
+  const fail = useCallback(
+    (message) => {
+      stop();
+      setState({ phase: "error", message });
+    },
+    [stop]
+  );
+  const refresh = useCallback(() => {
+    const current = session.current;
+    if (!current) return;
+    const snapshot = current.player.snapshot();
+    if (snapshot.complete && !snapshot.isPlaying && snapshot.currentTime >= snapshot.bufferedDuration - 0.05) {
+      session.current = null;
+      endSession(current);
+      setState({ phase: "idle" });
+      return;
+    }
+    if (snapshot.isPlaying) current.started = true;
+    const next2 = current.started ? {
+      phase: "reading",
+      playing: !current.userPaused,
+      waiting: !current.userPaused && !snapshot.isPlaying,
+      segment: segmentAt(current, snapshot),
+      segments: current.segments.length
+    } : { phase: "loading" };
+    setState((previous2) => sameState(previous2, next2) ? previous2 : next2);
+  }, []);
+  const synthesizeFrom = useCallback(
+    async (current, first, synthesize) => {
+      if (!synthesize) return;
+      current.run += 1;
+      const run = current.run;
+      const stale = () => current.cancelled || current.run !== run;
+      current.handle?.cancel();
+      current.handle = null;
+      current.firstSegment = first;
+      current.synthesizing = first;
+      current.segmentStarts.clear();
+      current.chunkSegments.length = 0;
+      current.gate.restart();
+      const { player, gate, segments } = current;
+      player.reset();
+      let chunkIndex = 0;
+      for (let index = first; index < segments.length; index += 1) {
+        if (stale()) return;
+        current.synthesizing = index;
+        current.synthesizedThrough = 0;
+        const handle = synthesize({ text: segments[index]?.text ?? "" }, (event) => {
+          if (stale() || event.kind !== "chunk") return;
+          const { chunk } = event;
+          if (!current.segmentStarts.has(index)) {
+            current.segmentStarts.set(index, player.snapshot().bufferedDuration);
+          }
+          current.chunkSegments[chunkIndex] = index;
+          player.append({ ...chunk, index: chunkIndex });
+          chunkIndex += 1;
+          gate.record(
+            chunk.textEnd - current.synthesizedThrough,
+            chunk.durationSec,
+            performance.now()
+          );
+          current.synthesizedThrough = chunk.textEnd;
+          playIfReady(current);
+        });
+        current.handle = handle;
+        const result = await handle.done;
+        if (stale()) return;
+        if (!result.ok) {
+          fail(result.error.message);
+          return;
+        }
+      }
+      current.handle = null;
+      current.synthesizing = null;
+      player.finish();
+      if (!player.snapshot().isPlaying && !current.userPaused) void player.play();
+    },
+    [fail]
+  );
   const start = useCallback(
     (markdown) => {
       const synthesize = speech?.synthesize;
       if (!synthesize) return;
       stop();
-      const onChange = (snapshot) => {
-        const current2 = session.current;
-        if (!current2 || current2.player !== player) return;
-        if (snapshot.complete && !snapshot.isPlaying && snapshot.currentTime >= snapshot.bufferedDuration - 0.05) {
-          session.current = null;
-          player.dispose();
-          setState({ phase: "idle" });
-          return;
-        }
-        const segment = snapshot.currentChunk === null ? 0 : current2.chunkSegments[snapshot.currentChunk] ?? 0;
-        setState({
-          phase: "reading",
-          playing: snapshot.isPlaying,
-          waiting: snapshot.waitingForAudio,
-          segment,
-          segments: current2.segments.length
-        });
-      };
-      const player = ProgressivePlayer.create(onChange);
+      const player = ProgressivePlayer.create(() => {
+        if (session.current?.player === player) refresh();
+      });
       if (!player) {
         setState({ phase: "error", message: "Audio playback is not available." });
         return;
@@ -134,12 +234,24 @@ function useReadAloud(speech) {
       player.prime();
       const current = {
         player,
-        chunkSegments: [],
+        gate: new AutoPlayGate(),
         segments: [],
+        run: 0,
+        firstSegment: 0,
+        synthesizing: null,
+        synthesizedThrough: 0,
+        poll: null,
+        segmentStarts: /* @__PURE__ */ new Map(),
+        chunkSegments: [],
         handle: null,
+        started: false,
         cancelled: false,
         userPaused: false
       };
+      current.poll = setInterval(() => {
+        playIfReady(current);
+        if (session.current === current) refresh();
+      }, POLL_MS);
       session.current = current;
       setState({ phase: "loading" });
       void (async () => {
@@ -147,67 +259,65 @@ function useReadAloud(speech) {
         if (current.cancelled) return;
         current.segments = plan.segments;
         if (plan.segments.length === 0) {
-          stop();
-          setState({ phase: "error", message: "There is nothing to read aloud." });
+          fail("There is nothing to read aloud.");
           return;
         }
-        const totalCharacters = plan.segments.reduce((sum, s) => sum + s.text.length, 0);
-        const gate = new AutoPlayGate();
-        let spokenCharacters = 0;
-        let chunkIndex = 0;
-        for (const [segmentIndex, segment] of plan.segments.entries()) {
-          if (current.cancelled) return;
-          const handle = synthesize({ text: segment.text }, (event) => {
-            if (current.cancelled || event.kind !== "chunk") return;
-            current.chunkSegments[chunkIndex] = segmentIndex;
-            player.append({ ...event.chunk, index: chunkIndex });
-            chunkIndex += 1;
-            const snapshot = player.snapshot();
-            const progress = {
-              completedCharacters: spokenCharacters + event.chunk.textEnd,
-              totalCharacters
-            };
-            if (!snapshot.isPlaying && !current.userPaused && gate.ready(snapshot, progress, performance.now())) {
-              void player.play();
-            }
-          });
-          current.handle = handle;
-          const result = await handle.done;
-          if (current.cancelled) return;
-          if (!result.ok) {
-            stop();
-            setState({ phase: "error", message: result.error.message });
-            return;
-          }
-          spokenCharacters += segment.text.length;
-        }
-        current.handle = null;
-        player.finish();
-        if (!player.snapshot().isPlaying && !current.userPaused) void player.play();
+        await synthesizeFrom(current, 0, synthesize);
       })().catch((error) => {
         if (current.cancelled) return;
-        stop();
-        setState({
-          phase: "error",
-          message: error instanceof Error ? error.message : "Reading aloud failed."
-        });
+        fail(error instanceof Error ? error.message : "Reading aloud failed.");
       });
     },
-    [speech, stop]
+    [speech, stop, fail, refresh, synthesizeFrom]
   );
   const pause = useCallback(() => {
     const current = session.current;
     if (!current) return;
     current.userPaused = true;
     current.player.pause();
-  }, []);
+    refresh();
+  }, [refresh]);
   const resume = useCallback(() => {
     const current = session.current;
     if (!current) return;
     current.userPaused = false;
+    current.player.prime();
     void current.player.play();
-  }, []);
-  return { state, start, pause, resume, stop };
+    refresh();
+  }, [refresh]);
+  const skip = useCallback(
+    (direction) => {
+      const current = session.current;
+      if (!current || current.segments.length === 0) return;
+      current.player.prime();
+      const snapshot = current.player.snapshot();
+      const segment = segmentAt(current, snapshot);
+      const segmentStart = current.segmentStarts.get(segment);
+      const restart = direction < 0 && segmentStart !== void 0 && snapshot.currentTime - segmentStart > RESTART_SEGMENT_SECONDS;
+      const target = restart ? segment : segment + direction;
+      if (target < 0 || target >= current.segments.length) {
+        if (target < 0 && segmentStart !== void 0) current.player.seek(segmentStart);
+        refresh();
+        return;
+      }
+      const start2 = current.segmentStarts.get(target);
+      if (start2 !== void 0) {
+        current.player.seek(start2);
+      } else if (target === current.synthesizing) {
+        current.player.seek(snapshot.bufferedDuration);
+      } else {
+        void synthesizeFrom(current, target, speech?.synthesize).catch((error) => {
+          if (current.cancelled) return;
+          fail(error instanceof Error ? error.message : "Reading aloud failed.");
+        });
+      }
+      refresh();
+    },
+    [speech, fail, refresh, synthesizeFrom]
+  );
+  const previous = useCallback(() => skip(-1), [skip]);
+  const next = useCallback(() => skip(1), [skip]);
+  return { state, start, pause, resume, previous, next, stop };
 }
 
 // src/Speech/SpeechToolbarControl.tsx
@@ -286,6 +396,18 @@ function SpeechToolbarControl({
       }
     ),
     active && /* @__PURE__ */ jsxs2("div", { className: "db-speech-transport", role: "group", "aria-label": "Reading aloud", children: [
+      /* @__PURE__ */ jsx2(
+        "button",
+        {
+          type: "button",
+          className: "squisq-toolbar-button",
+          "aria-label": "Previous segment",
+          "data-tooltip": "Previous segment",
+          disabled: state.phase !== "reading",
+          onClick: () => readAloud.previous(),
+          children: /* @__PURE__ */ jsx2(PreviousGlyph, {})
+        }
+      ),
       state.phase === "reading" && state.playing ? /* @__PURE__ */ jsx2(
         "button",
         {
@@ -308,6 +430,18 @@ function SpeechToolbarControl({
           children: /* @__PURE__ */ jsx2(PlayGlyph, {})
         }
       ),
+      /* @__PURE__ */ jsx2(
+        "button",
+        {
+          type: "button",
+          className: "squisq-toolbar-button",
+          "aria-label": "Next segment",
+          "data-tooltip": "Next segment",
+          disabled: state.phase !== "reading" || state.segment >= state.segments - 1,
+          onClick: () => readAloud.next(),
+          children: /* @__PURE__ */ jsx2(NextGlyph, {})
+        }
+      ),
       /* @__PURE__ */ jsx2(
         "button",
         {
@@ -425,6 +559,18 @@ function PlayGlyph() {
 function PauseGlyph() {
   return /* @__PURE__ */ jsx2(Glyph, { children: /* @__PURE__ */ jsx2("path", { d: "M6.5 4.5v9M11.5 4.5v9" }) });
 }
+function PreviousGlyph() {
+  return /* @__PURE__ */ jsxs2(Glyph, { children: [
+    /* @__PURE__ */ jsx2("path", { d: "M5 4.5v9" }),
+    /* @__PURE__ */ jsx2("path", { d: "M13 4.5v9L6.5 9z" })
+  ] });
+}
+function NextGlyph() {
+  return /* @__PURE__ */ jsxs2(Glyph, { children: [
+    /* @__PURE__ */ jsx2("path", { d: "M13 4.5v9" }),
+    /* @__PURE__ */ jsx2("path", { d: "M5 4.5v9L11.5 9z" })
+  ] });
+}
 function StopGlyph() {
   return /* @__PURE__ */ jsx2(Glyph, { children: /* @__PURE__ */ jsx2("rect", { x: "5", y: "5", width: "8", height: "8", rx: "1" }) });
 }

package/dist/{TextFromNarration-EYOMW2IW.js → TextFromNarration-ME6FAYWO.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-6JJOGV6M.js";
 import {
   createSpeechInputProvider
-} from "./chunk-KBDZDFPU.js";
+} from "./chunk-BNKIPCXO.js";
 import {
   unavailableSentence,
   useAiStatus

package/dist/{WorkspaceSearchPanel-J6BKEZQJ.js → WorkspaceSearchPanel-MEBBTK7F.js}

@@ -1,9 +1,9 @@
+import {
+  FilesIcon
+} from "./chunk-KHQ44ZFA.js";
 import {
   HighlightedText
 } from "./chunk-TBLZBNQF.js";
-import {
-  FilesIcon
-} from "./chunk-DICE7VBJ.js";
 
 // src/WorkspaceSearch/WorkspaceSearchPanel.tsx
 import { useEffect as useEffect2, useMemo, useRef as useRef2, useState as useState2 } from "react";

package/dist/{chunk-I44HKDQX.js → chunk-3TSJQESW.js}

@@ -12,6 +12,14 @@ var FENCE = /^(?<indent> {0,3})(?<marker>`{3,}|~{3,})[^\n]*\n[\s\S]*?^\k<indent>
 function stripFencedCode(markdown) {
   return markdown.replace(FENCE, "");
 }
+function joinSoftBreaks(node) {
+  if (typeof node !== "object" || node === null) return;
+  const { type, value, children } = node;
+  if (type === "text" && typeof value === "string") {
+    node.value = value.replace(/\n/gu, " ");
+  }
+  if (Array.isArray(children)) for (const child of children) joinSoftBreaks(child);
+}
 function ensureSentenceEnd(text) {
   const trimmed = text.trimEnd();
   if (!trimmed) return trimmed;
@@ -54,11 +62,16 @@ async function planSpeech(markdown) {
     import("@bendyline/squisq/doc"),
     import("@bendyline/squisq/narration")
   ]);
-  const doc = markdownToDoc(parseMarkdown(stripFencedCode(markdown)));
+  const source = stripFencedCode(markdown);
+  const doc = markdownToDoc(parseMarkdown(source));
   const script = buildNarrationScript(doc);
+  const joined = parseMarkdown(source);
+  joinSoftBreaks(joined);
+  const joinedText = buildNarrationScript(markdownToDoc(joined)).sourceText;
+  const spoken = joinedText.length === script.sourceText.length ? joinedText : script.sourceText;
   const segments = [];
   for (const block of script.blocks) {
-    const text = script.sourceText.slice(block.charStart, block.charEnd);
+    const text = spoken.slice(block.charStart, block.charEnd);
     let bodyStart = block.charStart;
     const heading = block.heading?.trim();
     if (heading && text.startsWith(heading)) {
@@ -72,7 +85,7 @@ async function planSpeech(markdown) {
       bodyStart = block.charStart + heading.length;
     }
     const lines = /[^\n]+/gu;
-    const body = script.sourceText.slice(bodyStart, block.charEnd);
+    const body = spoken.slice(bodyStart, block.charEnd);
     for (const line of body.matchAll(lines)) {
       for (const piece of splitLongText(line[0], bodyStart + line.index)) {
         segments.push({