@bendyline/squisq-editor-react 2.11.18 → 2.11.20

package/dist/{chunk-2XXBDECJ.js → chunk-OCQEWWHI.js}

@@ -1,6 +1,6 @@
 import {
   MARKDOWN_ESCAPE_ATTR
-} from "./chunk-DPAMJV6A.js";
+} from "./chunk-HSWWEWT4.js";
 
 // src/MarkdownEscape.ts
 import { Mark, mergeAttributes } from "@tiptap/core";

package/dist/{chunk-U6NVT3BY.js → chunk-UFK47ZAI.js}

@@ -20,7 +20,7 @@ import {
   timingPathFor,
   useNarrationStage,
   useStreamPreview
-} from "./chunk-CGENKHWY.js";
+} from "./chunk-ZS6G2P57.js";
 import {
   buildFilename,
   requestMicStream,
@@ -2612,6 +2612,7 @@ function RecorderModal({
   const narrationRecording = narrationOn && Boolean(narration?.recording);
   const expanded = isExpandedPanel(panelMode);
   const [narrationRequesting, setNarrationRequesting] = useState3(false);
+  const [countingIn, setCountingIn] = useState3(false);
   const [narrationPreview, setNarrationPreview] = useState3(null);
   const [deviceSettings, setDeviceSettings] = useState3(() => ({
     ...DEFAULT_RECORDER_DEVICE_SETTINGS,
@@ -2927,17 +2928,27 @@ function RecorderModal({
     } catch {
     }
   }, [recorder]);
-  const handleStart = useCallback4(() => {
+  const handleStart = useCallback4(async () => {
     setSaveError(null);
     dualSaveProgressRef.current = {};
+    if (narrationOn) {
+      setCountingIn(true);
+      const rolled = await stageRef.current.controller.countIn();
+      setCountingIn(false);
+      if (!rolled) return;
+    }
     recorder.start();
     const blockId = slideDeckRef.current[slideIndexRef.current]?.blockId;
     setAdvanceLog(blockId ? recordSlideShown(EMPTY_ADVANCE_LOG, blockId, 0) : EMPTY_ADVANCE_LOG);
-  }, [recorder]);
+  }, [narrationOn, recorder]);
   const handleStop = useCallback4(async () => {
     setSaveError(null);
+    if (countingIn) {
+      stageRef.current.controller.pause();
+      return;
+    }
     await recorder.stop();
-  }, [recorder]);
+  }, [countingIn, recorder]);
   const writeSlideTimingSidecar = useCallback4(
     async (mediaRelativePath, durationSec) => {
       const doc = slides?.doc;
@@ -3130,8 +3141,8 @@ function RecorderModal({
   );
   const isAudioOnly = recordedMediaKind(source, recorder.stream, recorder.mimeType) === "audio";
   const showPreview = recorder.state !== "idle" && recorder.state !== "error";
-  const canRecord = recorder.state === "ready";
-  const canStop = recorder.state === "recording";
+  const canRecord = recorder.state === "ready" && !countingIn;
+  const canStop = recorder.state === "recording" || countingIn;
   const canSave = recorder.state === "stopped" && recorder.blob !== null;
   const isBusy = recorder.state === "requesting" || recorder.state === "stopping" || isSaving;
   const slidesTimingCapture = slidesOn && slidesCaptureTimings;
@@ -3185,7 +3196,7 @@ function RecorderModal({
     sourceText
   ]);
   const slideCoverageWarning = slideCoverage ? unshownSlidesWarning(slideCoverage.total, slideCoverage.unshown) : null;
-  const togglesLocked = recorder.state === "recording" || recorder.state === "requesting" || recorder.state === "stopping" || canSave;
+  const togglesLocked = countingIn || recorder.state === "recording" || recorder.state === "requesting" || recorder.state === "stopping" || canSave;
   const toggleLockReason = canSave ? "Save or discard this recording before changing sources" : void 0;
   const systemAudioHasCompanion = micOn || cameraOn || screenOn;
   const simpleToggleProps = (key) => {
@@ -3680,24 +3691,33 @@ function RecorderModal({
                             children: recorder.state === "requesting" ? "Requesting\u2026" : "Start preview"
                           }
                         ),
-                        canRecord && /* @__PURE__ */ jsxs5("button", { type: "button", style: btnRecord, onClick: handleStart, disabled: isBusy, children: [
-                          /* @__PURE__ */ jsx6(
-                            "span",
-                            {
-                              className: "squisq-recorder-record-dot",
-                              style: recordDotFrameStyle,
-                              "aria-hidden": "true",
-                              children: /* @__PURE__ */ jsx6(
+                        canRecord && /* @__PURE__ */ jsxs5(
+                          "button",
+                          {
+                            type: "button",
+                            style: btnRecord,
+                            onClick: () => void handleStart(),
+                            disabled: isBusy,
+                            children: [
+                              /* @__PURE__ */ jsx6(
                                 "span",
                                 {
-                                  className: "squisq-recorder-record-dot-center",
-                                  style: recordDotStyle
+                                  className: "squisq-recorder-record-dot",
+                                  style: recordDotFrameStyle,
+                                  "aria-hidden": "true",
+                                  children: /* @__PURE__ */ jsx6(
+                                    "span",
+                                    {
+                                      className: "squisq-recorder-record-dot-center",
+                                      style: recordDotStyle
+                                    }
+                                  )
                                 }
-                              )
-                            }
-                          ),
-                          "Record"
-                        ] }),
+                              ),
+                              "Record"
+                            ]
+                          }
+                        ),
                         canStop && /* @__PURE__ */ jsx6("button", { type: "button", style: btnDanger, onClick: handleStop, disabled: isBusy, children: "Stop" }),
                         canSave && /* @__PURE__ */ jsxs5(Fragment3, { children: [
                           /* @__PURE__ */ jsx6(

package/dist/{chunk-UBFNLWCN.js → chunk-V2OLZOYJ.js}

@@ -1,10 +1,10 @@
 import {
   MarkdownEscape
-} from "./chunk-2XXBDECJ.js";
+} from "./chunk-OCQEWWHI.js";
 import {
   markdownToTiptap,
   tiptapToMarkdown
-} from "./chunk-DPAMJV6A.js";
+} from "./chunk-HSWWEWT4.js";
 
 // src/jsonEditor/JsonEditorContext.tsx
 import { createContext, useContext, useEffect, useMemo } from "react";

package/dist/{chunk-CGENKHWY.js → chunk-ZS6G2P57.js}

@@ -429,6 +429,7 @@ function useTeleprompter(opts) {
   const levelRef = useRef2(0);
   const voiceRef = useRef2(false);
   const countdownTimerRef = useRef2(null);
+  const countInWaitersRef = useRef2([]);
   scriptRef.current = script;
   prefsRef.current = prefs;
   transportRef.current = transport;
@@ -453,13 +454,19 @@ function useTeleprompter(opts) {
   const notifyTick = useCallback2(() => {
     for (const cb of tickSubsRef.current) cb(wordPosRef.current);
   }, []);
+  const settleCountIn = useCallback2((rolled) => {
+    const waiters = countInWaitersRef.current;
+    countInWaitersRef.current = [];
+    for (const resolve of waiters) resolve(rolled);
+  }, []);
   const clearCountdown = useCallback2(() => {
     if (countdownTimerRef.current !== null) {
       clearInterval(countdownTimerRef.current);
       countdownTimerRef.current = null;
     }
     setCountdownRemaining(null);
-  }, []);
+    settleCountIn(false);
+  }, [settleCountIn]);
   const finish = useCallback2(() => {
     setTransport("finished");
     transportRef.current = "finished";
@@ -533,13 +540,14 @@ function useTeleprompter(opts) {
     return () => cancelAnimationFrame(raf);
   }, [transport, mic.status, finish, notifyTick, publish]);
   const beginRolling = useCallback2(() => {
+    settleCountIn(true);
     clearCountdown();
     if (sessionRef.current) {
       sessionRef.current = reanchorSession(sessionRef.current, wordPosRef.current);
     }
     setTransport("rolling");
     transportRef.current = "rolling";
-  }, [clearCountdown]);
+  }, [clearCountdown, settleCountIn]);
   const play = useCallback2(() => {
     if (transportRef.current === "rolling" || transportRef.current === "countdown") return;
     if (transportRef.current === "finished") {
@@ -564,6 +572,14 @@ function useTeleprompter(opts) {
       beginRolling();
     }
   }, [beginRolling, mic, publish]);
+  const countIn = useCallback2(() => {
+    if (transportRef.current === "rolling") return Promise.resolve(true);
+    const rolled = new Promise((resolve) => {
+      countInWaitersRef.current.push(resolve);
+    });
+    play();
+    return rolled;
+  }, [play]);
   const pause = useCallback2(() => {
     if (transportRef.current === "countdown") {
       clearCountdown();
@@ -699,6 +715,7 @@ function useTeleprompter(opts) {
     prefs,
     setPrefs,
     play,
+    countIn,
     pause,
     restart,
     nudge,
@@ -1450,6 +1467,11 @@ function useNarrationRecorder(options) {
         cameraMime = videoFormat.mimeType;
         cameraExt = videoFormat.extension;
       }
+      if (opts.countIn) {
+        setCameraStream(camera);
+        if (!await opts.countIn()) throw new StartAborted();
+        if (superseded()) throw new StartAborted();
+      }
       const capture = {
         audioRecorder,
         audioChunks: [],
@@ -1527,6 +1549,7 @@ function useNarrationRecorder(options) {
     if (!capture) {
       if (startingRef.current) {
         cancelPendingStart();
+        optionsRef.current.onRecordingStop?.();
         setState("idle");
       }
       return;
@@ -1826,7 +1849,8 @@ function useNarrationStage(opts) {
     maxRecordingBytes: opts.maxRecordingBytes,
     audioRecorderOptions: opts.audioRecorderOptions,
     cameraRecorderOptions: opts.cameraRecorderOptions,
-    onRecordingStart: () => controllerRef.current.play(),
+    // The take starts when the countdown ends, with the prompter already rolling.
+    countIn: () => controllerRef.current.countIn(),
     onRecordingStop: () => controllerRef.current.pause()
   });
   const recorderRef = useRef5(recorder);

package/dist/deviceSettings-BSkIQncC.d.ts

@@ -0,0 +1,83 @@
+import { S as ScreenCaptureRegion } from './screenRegion-Ci_RsCzG.js';
+
+/**
+ * User-configurable recorder device/encoding settings.
+ *
+ * Values stay serializable so the modal can include them in its capture key:
+ * changing a setting releases any prepared preview before a new stream is
+ * requested. Numeric and string track values are expressed as either `ideal`
+ * (best effort) or `exact` (fail when unavailable) constraints. Display
+ * capture is the exception: the screen-capture standard rejects exact
+ * constraints during its user picker, so those values always remain ideal.
+ */
+
+type RecorderConstraintMode = 'ideal' | 'exact';
+interface RecorderAudioDeviceSettings {
+    deviceId: string;
+    groupId?: string;
+    autoGainControl?: boolean;
+    channelCount?: number;
+    echoCancellation?: boolean;
+    latency?: number;
+    noiseSuppression?: boolean;
+    sampleRate?: number;
+    sampleSize?: number;
+}
+interface RecorderCameraDeviceSettings {
+    deviceId: string;
+    groupId?: string;
+    aspectRatio?: number;
+    backgroundBlur?: boolean;
+    facingMode?: string;
+    frameRate?: number;
+    height?: number;
+    resizeMode?: string;
+    width?: number;
+}
+interface RecorderScreenDeviceSettings {
+    /** Crop in captured pixels, relative to the chosen surface (not the desktop). */
+    crop?: ScreenCaptureRegion;
+    aspectRatio?: number;
+    cursor?: string;
+    displaySurface?: string;
+    frameRate?: number;
+    height?: number;
+    logicalSurface?: boolean;
+    resizeMode?: string;
+    width?: number;
+}
+interface RecorderScreenAudioSettings {
+    restrictOwnAudio?: boolean;
+    suppressLocalAudioPlayback?: boolean;
+}
+interface RecorderEncodingSettings {
+    audioMimeType: string;
+    videoMimeType: string;
+    bitsPerSecond?: number;
+    audioBitsPerSecond?: number;
+    videoBitsPerSecond?: number;
+    audioBitrateMode?: 'constant' | 'variable';
+    videoKeyFrameIntervalDuration?: number;
+    videoKeyFrameIntervalCount?: number;
+}
+interface RecorderDeviceSettings {
+    constraintMode: RecorderConstraintMode;
+    audio: RecorderAudioDeviceSettings;
+    camera: RecorderCameraDeviceSettings;
+    screen: RecorderScreenDeviceSettings;
+    screenAudio: RecorderScreenAudioSettings;
+    encoding: RecorderEncodingSettings;
+}
+declare const DEFAULT_RECORDER_DEVICE_SETTINGS: RecorderDeviceSettings;
+/** Build microphone constraints from the advanced settings form. */
+declare function buildRecorderAudioConstraints(settings: RecorderDeviceSettings): MediaTrackConstraints;
+/** Build camera constraints from the advanced settings form. */
+declare function buildRecorderCameraConstraints(settings: RecorderDeviceSettings): MediaTrackConstraints;
+/** Build display-capture constraints independently from camera constraints. */
+declare function buildRecorderScreenConstraints(settings: RecorderDeviceSettings): MediaTrackConstraints;
+/** Build the audio-track constraints specific to getDisplayMedia. */
+declare function buildRecorderScreenAudioConstraints(settings: RecorderDeviceSettings): MediaTrackConstraints;
+/** Convert the form's kbps values to the bps values MediaRecorder expects. */
+declare function recorderBitsPerSecond(value: number | undefined): number | undefined;
+
+export { DEFAULT_RECORDER_DEVICE_SETTINGS as D, type RecorderDeviceSettings as R, type RecorderAudioDeviceSettings as a, type RecorderCameraDeviceSettings as b, type RecorderConstraintMode as c, type RecorderEncodingSettings as d, type RecorderScreenAudioSettings as e, type RecorderScreenDeviceSettings as f, buildRecorderAudioConstraints as g, buildRecorderCameraConstraints as h, buildRecorderScreenAudioConstraints as i, buildRecorderScreenConstraints as j, recorderBitsPerSecond as r };

package/dist/{dictationSession-PN3OT5LJ.js → dictationSession-SLDNYIZ2.js}

@@ -1,6 +1,7 @@
 import {
-  SPEECH_INPUT_SAMPLE_RATE
-} from "./chunk-DNEVUOBZ.js";
+  microphoneTakeAsWav
+} from "./chunk-K56KR27T.js";
+import "./chunk-DNEVUOBZ.js";
 import {
   DEFAULT_RECORDER_DEVICE_SETTINGS,
   buildRecorderAudioConstraints
@@ -320,137 +321,6 @@ function extendRecognitionPrompt(previous, transcript) {
   return (firstWhitespace >= 0 ? tail.slice(firstWhitespace + 1) : tail).trim();
 }
 
-// src/speech/speechAudioWav.ts
-async function microphoneTakeAsWav(blob) {
-  const encoded = await blobBytes(blob);
-  let audio;
-  try {
-    audio = await decodeAt16k(encoded);
-  } catch (caught) {
-    const detail = caught instanceof Error && caught.message ? ` (${caught.message})` : "";
-    throw new Error(`This recording could not be prepared for speech recognition${detail}`);
-  }
-  const channels = Array.from(
-    { length: audio.numberOfChannels },
-    (_, index) => audio.getChannelData(index)
-  );
-  const mono = downmixToMono(channels);
-  const samples = audio.sampleRate === SPEECH_INPUT_SAMPLE_RATE ? mono : resampleLinear(mono, audio.sampleRate, SPEECH_INPUT_SAMPLE_RATE);
-  return encodeMonoPcm16Wav([samples], SPEECH_INPUT_SAMPLE_RATE).buffer;
-}
-function blobBytes(blob) {
-  if (typeof blob.arrayBuffer === "function") return blob.arrayBuffer();
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onload = () => {
-      const result = reader.result;
-      if (result instanceof ArrayBuffer) resolve(result);
-      else reject(new Error("The recording could not be read."));
-    };
-    reader.onerror = () => reject(reader.error ?? new Error("The recording could not be read."));
-    reader.readAsArrayBuffer(blob);
-  });
-}
-async function decodeAt16k(encoded) {
-  if (typeof OfflineAudioContext !== "undefined") {
-    let offline = null;
-    try {
-      offline = new OfflineAudioContext(1, 1, SPEECH_INPUT_SAMPLE_RATE);
-    } catch {
-      offline = null;
-    }
-    if (offline) return offline.decodeAudioData(encoded);
-  }
-  if (typeof AudioContext === "undefined") {
-    throw new Error("Web Audio is unavailable");
-  }
-  const context = new AudioContext();
-  try {
-    return await context.decodeAudioData(encoded);
-  } finally {
-    await context.close().catch(() => void 0);
-  }
-}
-function downmixToMono(channels) {
-  const sampleCount = channels[0]?.length ?? 0;
-  if (channels.length === 0 || sampleCount === 0) {
-    throw new Error("The microphone recording was empty.");
-  }
-  if (channels.length === 1) return channels[0];
-  if (channels.some((channel) => channel.length !== sampleCount)) {
-    throw new Error("The microphone recording channels have different lengths.");
-  }
-  const mono = new Float32Array(sampleCount);
-  for (let index = 0; index < sampleCount; index += 1) {
-    let sum = 0;
-    for (const channel of channels) sum += channel[index] ?? 0;
-    mono[index] = sum / channels.length;
-  }
-  return mono;
-}
-function resampleLinear(samples, fromRate, toRate) {
-  if (!Number.isFinite(fromRate) || fromRate <= 0 || !Number.isFinite(toRate) || toRate <= 0) {
-    throw new Error("The microphone recording has an invalid sample rate.");
-  }
-  if (fromRate === toRate) return samples;
-  const outputLength = Math.max(1, Math.round(samples.length * toRate / fromRate));
-  const output = new Float32Array(outputLength);
-  const step = fromRate / toRate;
-  for (let index = 0; index < outputLength; index += 1) {
-    const position = index * step;
-    const left = Math.floor(position);
-    const right = Math.min(left + 1, samples.length - 1);
-    const fraction = position - left;
-    const a = samples[Math.min(left, samples.length - 1)] ?? 0;
-    const b = samples[right] ?? 0;
-    output[index] = a + (b - a) * fraction;
-  }
-  return output;
-}
-function encodeMonoPcm16Wav(channels, sampleRate) {
-  const sampleCount = channels[0]?.length ?? 0;
-  if (channels.length === 0 || sampleCount === 0) {
-    throw new Error("The microphone recording was empty.");
-  }
-  if (!Number.isFinite(sampleRate) || sampleRate <= 0) {
-    throw new Error("The microphone recording has an invalid sample rate.");
-  }
-  if (channels.some((channel) => channel.length !== sampleCount)) {
-    throw new Error("The microphone recording channels have different lengths.");
-  }
-  const rate = Math.round(sampleRate);
-  const bytesPerSample = 2;
-  const dataBytes = sampleCount * bytesPerSample;
-  const buffer = new ArrayBuffer(44 + dataBytes);
-  const view = new DataView(buffer);
-  writeAscii(view, 0, "RIFF");
-  view.setUint32(4, 36 + dataBytes, true);
-  writeAscii(view, 8, "WAVE");
-  writeAscii(view, 12, "fmt ");
-  view.setUint32(16, 16, true);
-  view.setUint16(20, 1, true);
-  view.setUint16(22, 1, true);
-  view.setUint32(24, rate, true);
-  view.setUint32(28, rate * bytesPerSample, true);
-  view.setUint16(32, bytesPerSample, true);
-  view.setUint16(34, 16, true);
-  writeAscii(view, 36, "data");
-  view.setUint32(40, dataBytes, true);
-  for (let index = 0; index < sampleCount; index += 1) {
-    let mono = 0;
-    for (const channel of channels) mono += channel[index] ?? 0;
-    mono = Math.max(-1, Math.min(1, mono / channels.length));
-    const pcm = mono < 0 ? Math.round(mono * 32768) : Math.round(mono * 32767);
-    view.setInt16(44 + index * bytesPerSample, pcm, true);
-  }
-  return new Uint8Array(buffer);
-}
-function writeAscii(view, offset, value) {
-  for (let index = 0; index < value.length; index += 1) {
-    view.setUint8(offset + index, value.charCodeAt(index));
-  }
-}
-
 // src/speech/dictationSession.ts
 function dictationAudioConstraints(settings = DEFAULT_RECORDER_DEVICE_SETTINGS) {
   return {