@bendyline/squisq-editor-react 2.4.5 → 2.4.6

package/dist/useNarrationStage-Bk3mdW75.d.ts

@@ -0,0 +1,560 @@
+import { SyntheticEvent } from 'react';
+import { Doc, MediaProvider } from '@bendyline/squisq/schemas';
+import { ContentContainer } from '@bendyline/squisq/storage';
+import { NarrationScript, VadConfig, NarrationTrace, NarrationAlignment } from '@bendyline/squisq/narration';
+
+/**
+ * Format probing for MediaRecorder.
+ *
+ * Different browsers expose different container/codec combinations. Chrome
+ * and Firefox produce WebM (VP8/VP9 + Opus); Safari produces MP4 (H.264 +
+ * AAC). We probe at runtime via `MediaRecorder.isTypeSupported()` and pick
+ * the best supported option, falling back to whatever the browser hands
+ * back when no probe succeeds.
+ */
+/** What the recorded stream is intended to capture. */
+type CaptureKind = 'audio' | 'video';
+/** A probed format choice — what to pass to `MediaRecorder` and where to write it. */
+interface ResolvedFormat {
+    /** MIME type to pass to `new MediaRecorder(stream, { mimeType })`. Empty string means "let the browser pick". */
+    mimeType: string;
+    /** File extension to use when writing to the container, including the leading dot. */
+    extension: string;
+    /** Container directory inside the `ContentContainer` (no trailing slash). */
+    directory: 'audio' | 'video';
+}
+/**
+ * Resolve the format the recorder will use for a given capture kind. If a
+ * `preferred` MIME type is supported, it wins; otherwise we fall through
+ * the priority list. When nothing matches (extremely old browser), we
+ * return an empty `mimeType` — `MediaRecorder` will pick a default and we
+ * tag the file with `.webm` as a best guess.
+ */
+declare function resolveFormat(kind: CaptureKind, preferred?: string): ResolvedFormat;
+/**
+ * `MediaRecorder` support probe. Returns false when running in a
+ * non-browser environment (e.g. SSR) or on a browser that doesn't
+ * implement the API at all.
+ */
+declare function supportsMediaRecorder(): boolean;
+/**
+ * `getUserMedia` support probe (for mic / camera capture).
+ */
+declare function supportsUserMedia(): boolean;
+/**
+ * `getDisplayMedia` support probe (for screen capture). Browsers may
+ * implement `mediaDevices` without `getDisplayMedia` (Firefox on Android
+ * being the long-standing example), so this is its own probe.
+ */
+declare function supportsDisplayMedia(): boolean;
+/**
+ * Build a default filename for a recording. `basename` is a hint
+ * (e.g. user-typed name); when omitted, a sortable timestamp is used so
+ * concurrent recordings don't collide. General recorder callers can supply a
+ * source-aware `seed`; dedicated narration callers omit it and retain the
+ * historical `narration-*` default.
+ */
+type RecordingFilenameSeed = 'audio' | 'camera' | 'camera-audio' | 'screen' | 'screen-audio';
+declare function buildFilename(kind: CaptureKind, extension: string, basename?: string, seed?: RecordingFilenameSeed): string;
+
+/**
+ * useMediaRecorder
+ *
+ * React wrapper around `MediaRecorder` that handles stream acquisition,
+ * the recorder lifecycle, and produces a single `Blob` on stop. Selects
+ * a browser-supported MIME type via {@link resolveFormat}.
+ *
+ * Mirrors the shape of `useVideoExport` in `@bendyline/squisq-video-react`
+ * (request → start → stop → blob), inverted for capture rather than
+ * export.
+ *
+ * The `'screen+camera'` source is the one exception to "one stream, one
+ * blob": it drives TWO `MediaRecorder`s in lockstep (screen + system audio
+ * on the primary lane, camera + mic on a secondary lane), because a single
+ * recorder can only hold one video track. The secondary lane surfaces as
+ * {@link UseMediaRecorderResult.camera}; every other source leaves it null.
+ * The two lanes' start skew is measured (`cameraOffsetSec`) so the composed
+ * playback can line the presenter bubble up with the screen.
+ */
+
+/**
+ * Which capture source to use. `screen+mic` mixes the microphone into the
+ * screen stream (one file); `screen+camera` records screen and camera as two
+ * separate files in lockstep.
+ */
+type RecorderSource = 'mic' | 'camera' | 'screen' | 'screen+mic' | 'screen+camera';
+type RecorderAudioBitrateMode = 'constant' | 'variable';
+/**
+ * MediaRecorder options standardized after the DOM library fields currently
+ * shipped by TypeScript. They are passed through only when explicitly set.
+ */
+interface RecorderExtendedMediaOptions {
+    audioBitrateMode?: RecorderAudioBitrateMode;
+    videoKeyFrameIntervalDuration?: number;
+    videoKeyFrameIntervalCount?: number;
+}
+/** Discriminated state describing what the recorder is currently doing. */
+type RecorderState = 'idle' | 'requesting' | 'ready' | 'recording' | 'stopping' | 'stopped' | 'error';
+/**
+ * The camera companion lane, present only for `source === 'screen+camera'`
+ * (null for every other source). Its `blob` is null until the take stops.
+ */
+interface RecorderCameraLane {
+    /** Camera stream (video + mic when requested); inactive after stop, null after teardown. */
+    stream: MediaStream | null;
+    /** Final camera `Blob` after `stop()` resolves, or null while recording. */
+    blob: Blob | null;
+    /** MIME type of the camera lane (shares the video format with the screen lane). */
+    mimeType: string | null;
+    /** File extension matching `mimeType` (e.g. `.webm`). */
+    extension: string | null;
+}
+interface UseMediaRecorderOptions {
+    /** Which capture pipeline to use (default: `'mic'`). */
+    source?: RecorderSource;
+    /**
+     * Preferred MIME type override. When the browser supports it, this
+     * wins over the default candidate list. When unset (or unsupported),
+     * the hook probes a built-in priority list.
+     */
+    mimeType?: string;
+    /**
+     * Video track constraints for camera sources. Also used for screen capture
+     * when `screenVideoConstraints` is omitted, preserving the original API.
+     */
+    videoConstraints?: MediaTrackConstraints | boolean;
+    /**
+     * Display-video constraints for screen sources. Keeping this independent
+     * lets a dual screen+camera take request different dimensions/aspect ratios
+     * for each lane.
+     */
+    screenVideoConstraints?: MediaTrackConstraints | boolean;
+    /** Audio-track constraints specific to getDisplayMedia system audio. */
+    screenAudioConstraints?: MediaTrackConstraints;
+    /** Audio track constraints for mic / camera / screen+mic sources. */
+    audioConstraints?: MediaTrackConstraints | boolean;
+    /**
+     * Bits-per-second hint passed to `MediaRecorder`. Most browsers cap to
+     * reasonable defaults internally; leaving this undefined is usually
+     * fine.
+     */
+    bitsPerSecond?: number;
+    /** Audio bitrate hint passed to `MediaRecorder`. */
+    audioBitsPerSecond?: number;
+    /** Video bitrate hint passed to `MediaRecorder`. */
+    videoBitsPerSecond?: number;
+    /** Constant/variable audio encoder preference, when supported. */
+    audioBitrateMode?: RecorderAudioBitrateMode;
+    /** Requested milliseconds between video keyframes. Mutually exclusive with count. */
+    videoKeyFrameIntervalDuration?: number;
+    /** Requested frames between video keyframes. Mutually exclusive with duration. */
+    videoKeyFrameIntervalCount?: number;
+    /**
+     * Whether to capture system (tab/monitor) audio. Browser support is limited
+     * (desktop Chromium only); when unsupported the resulting stream simply omits
+     * it. How it is obtained depends on the source:
+     * - `'screen'` / `'screen+mic'` / `'screen+camera'` — folded into the screen
+     *   lane's `getDisplayMedia` (rides the SCREEN file for the dual source).
+     * - `'mic'` / `'camera'` — captured via a SEPARATE `getDisplayMedia` whose
+     *   video is discarded, then mixed into the mic/camera file. The browser still
+     *   shows the screen/tab picker (audio-only display capture isn't allowed).
+     */
+    systemAudio?: boolean;
+    /**
+     * For `source === 'camera'`, whether to include the microphone track.
+     * Defaults to `true` (camera + mic). Set `false` to capture silent
+     * video. Ignored for `'mic'`/`'screen'`/`'screen+mic'`, whose mic
+     * handling is encoded in the source itself. For `'screen+camera'` this
+     * gates the microphone on the CAMERA lane (the screen lane never carries
+     * the mic — system audio rides it instead).
+     */
+    includeMicrophone?: boolean;
+}
+interface UseMediaRecorderResult {
+    /** Current recorder state. */
+    state: RecorderState;
+    /** `MediaStream` acquired by `request()`; live during preview/recording and
+     * inactive after stop. For `'screen+camera'` this is the SCREEN stream (see
+     * `camera` for the other). */
+    stream: MediaStream | null;
+    /** Final `Blob` after `stop()` resolves, or `null` while recording. For
+     * `'screen+camera'` this is the SCREEN file. */
+    blob: Blob | null;
+    /** MIME type the recorder actually used (after `request()`). */
+    mimeType: string | null;
+    /** File extension matching `mimeType` (e.g. `.webm`). */
+    extension: string | null;
+    /** Suggested container directory (`'audio'` for mic, `'video'` for camera/screen). */
+    directory: 'audio' | 'video' | null;
+    /** Milliseconds elapsed since `start()` was called. Updates ~10× per second while recording. */
+    durationMs: number;
+    /** Most recent error, if any. */
+    error: Error | null;
+    /**
+     * The camera companion lane for `source === 'screen+camera'`, else null.
+     * Its `blob` lands together with the primary `blob` when `stop()` resolves.
+     */
+    camera: RecorderCameraLane | null;
+    /**
+     * Camera onstart minus screen onstart, in seconds (positive = camera
+     * started later). Null until both lanes have reported `onstart`, and for
+     * every non-dual source.
+     */
+    cameraOffsetSec: number | null;
+    /**
+     * Acquire the stream and prepare a `MediaRecorder`. After this resolves
+     * the hook is in `'ready'` state and a `<video>`/`<audio>` element can
+     * preview `stream`. Call `start()` to begin recording.
+     */
+    request: () => Promise<void>;
+    /** Start recording. Must be called from `'ready'`. */
+    start: () => void;
+    /**
+     * Stop recording and resolve with the resulting `Blob`. Safe to call
+     * from `'recording'`; a no-op from any other state (resolves with the
+     * existing `blob`, or `null`). Once the take has flushed, all capture
+     * tracks are stopped so browser sharing / camera / microphone indicators
+     * do not remain active during review.
+     */
+    stop: () => Promise<Blob | null>;
+    /**
+     * Tear everything down — stops the recorder if running, releases all
+     * tracks, disposes the AudioContext mixer (if any), and returns to
+     * `'idle'`. Always safe to call.
+     */
+    cancel: () => void;
+    /** Clear the current take. A new permission request may be needed before re-recording. */
+    reset: () => void;
+}
+/**
+ * Returns the kind of capture that the given source produces. Exposed
+ * separately from {@link useMediaRecorder} so non-React callers
+ * (e.g. headless tests) can resolve a format up front.
+ */
+declare function getCaptureKind(source: RecorderSource): CaptureKind;
+declare function useMediaRecorder(options?: UseMediaRecorderOptions): UseMediaRecorderResult;
+
+/**
+ * Mic capture + PCM transport for the teleprompter.
+ *
+ * getUserMedia → AudioContext → AudioWorklet tap → subscriber callbacks
+ * with 1024-sample Float32Array hops on the main thread. The DSP itself
+ * lives in core (`@bendyline/squisq/narration`) — this hook only moves
+ * samples. Falls back to a ScriptProcessorNode when `audioWorklet` is
+ * unavailable (same push model, so pacing still isn't tied to rAF).
+ */
+type MicAnalysisStatus = 'idle' | 'starting' | 'live' | 'error';
+type PcmHopListener = (pcm: Float32Array, audioTimeSec: number) => void;
+interface MicAnalysisHandle {
+    status: MicAnalysisStatus;
+    error: Error | null;
+    /** The live mic stream (feeds the narration recorder too), or null. */
+    stream: MediaStream | null;
+    /** AudioContext sample rate once live. */
+    sampleRate: number | null;
+    /** Known audio inputs (labels appear after the first grant). */
+    devices: MediaDeviceInfo[];
+    /**
+     * Start (or restart) capture. Resolves with the live stream — callers
+     * that need it immediately must use the return value, not the `stream`
+     * state field, which only updates on the NEXT render (stale-closure
+     * hazard right after an await). Null on failure/supersession.
+     */
+    start: (deviceId: string | null) => Promise<MediaStream | null>;
+    stop: () => void;
+    /** Subscribe to PCM hops; returns an unsubscribe. */
+    subscribeHop: (listener: PcmHopListener) => () => void;
+}
+declare function useMicAnalysis(constraints?: MediaTrackConstraints): MicAnalysisHandle;
+
+/**
+ * Shared types for the Narrate (teleprompter) display mode.
+ */
+interface TeleprompterPrefs {
+    /** Prompter type size in px (28–96). */
+    fontSizePx: number;
+    /** Beam-splitter mirror flip. */
+    mirrored: boolean;
+    /** Base speaking rate in words per minute (80–260). */
+    baseWpm: number;
+    /** Voice-adaptive pacing on/off; off = constant-rate manual mode. */
+    voiceTracking: boolean;
+    /** VAD sensitivity 0–1 (0.5 = engine defaults). */
+    vadSensitivity: number;
+    /** Countdown before the prompter starts rolling. */
+    countdownSec: 0 | 3 | 5 | 10;
+    /** Eye-line chevrons + focus band. */
+    lineGuide: boolean;
+    /** Preferred mic device id (null = system default). */
+    micDeviceId: string | null;
+}
+declare const DEFAULT_TELEPROMPTER_PREFS: TeleprompterPrefs;
+declare const TELEPROMPTER_PREF_LIMITS: Readonly<{
+    fontSizePx: {
+        min: number;
+        max: number;
+    };
+    baseWpm: {
+        min: number;
+        max: number;
+    };
+    vadSensitivity: {
+        min: number;
+        max: number;
+    };
+    micDeviceIdMaxLength: 1024;
+}>;
+/**
+ * Validate persisted or externally supplied preferences and return a complete,
+ * bounded value. Unknown keys are ignored; invalid fields retain `fallback`.
+ */
+declare function normalizeTeleprompterPrefs(value: unknown, fallback?: TeleprompterPrefs): TeleprompterPrefs;
+type PrompterTransport = 'stopped' | 'countdown' | 'rolling' | 'paused' | 'finished';
+/** Floating-surface tier, best first. */
+type FloatTier = 'document-pip' | 'video-pip' | 'popup' | 'docked';
+
+/**
+ * The teleprompter controller — single source of truth, always in the
+ * MAIN window (floats are render targets only).
+ *
+ * Loop-ownership rule: **the audio worklet owns time; the main window
+ * owns state; the visible surface owns pixels.** Voice-mode position
+ * advances on worklet PCM hops (immune to rAF/timer throttling while
+ * the browser is occluded by recording software); manual constant-rate
+ * mode uses rAF and is documented as best-effort under occlusion. React
+ * state publishes at ~15 Hz; per-hop subscribers (`subscribeTick`)
+ * exist for the video-PiP canvas pump.
+ */
+
+interface TeleprompterKeyEvent {
+    readonly defaultPrevented: boolean;
+    readonly key: string;
+    readonly repeat: boolean;
+    readonly target: EventTarget | null;
+    preventDefault: () => void;
+}
+interface TeleprompterController {
+    script: NarrationScript | null;
+    transport: PrompterTransport;
+    countdownRemaining: number | null;
+    /** Fractional word position (published ~15 Hz). */
+    wordPos: number;
+    /** Smoothed mic level 0–1 for the meter. */
+    micLevel: number;
+    /** VAD flag for the meter tint. */
+    voiceActive: boolean;
+    mic: MicAnalysisHandle;
+    prefs: TeleprompterPrefs;
+    setPrefs: (patch: Partial<TeleprompterPrefs>) => void;
+    play: () => void;
+    pause: () => void;
+    restart: () => void;
+    /** Move by spoken words and re-anchor voice tracking. */
+    nudge: (deltaWords: number) => void;
+    /** Jump to an absolute token index (e.g. click a block marker). */
+    seekToToken: (tokenIndex: number) => void;
+    /** Per-analysis-tick subscription (video-PiP pump). Not throttled. */
+    subscribeTick: (cb: (wordPos: number) => void) => () => void;
+    handleKeyDown: (event: TeleprompterKeyEvent) => void;
+}
+/** Map the 0–1 sensitivity pref onto VAD thresholds (0.5 = engine defaults). */
+declare function vadConfigForSensitivity(sensitivity: number): Partial<VadConfig>;
+declare function useTeleprompter(opts: {
+    doc: Doc | null;
+    micConstraints?: MediaTrackConstraints;
+}): TeleprompterController;
+
+/**
+ * Floating-teleprompter window manager — framework-free.
+ *
+ * Capability ladder, best first:
+ *   1. `document-pip` — Document Picture-in-Picture (Chromium 116+,
+ *      Firefox 151+): a true always-on-top window hosting live DOM; the
+ *      React surface portals into it.
+ *   2. `video-pip`   — canvas → `captureStream(0)` → `<video>` →
+ *      `requestPictureInPicture()` (Safari's only always-on-top path;
+ *      `webkitSetPresentationMode` fallback). Read-only: the main
+ *      window draws frames and calls `requestFrame()` on analysis
+ *      ticks — never rAF, which throttles under occlusion.
+ *   3. `popup`       — `window.open` (positionable, not always-on-top).
+ *   4. `docked`      — no float.
+ *
+ * Every tier is feature-detected at open time and falls through to the
+ * next on ANY failure. All interactive state stays in the main window;
+ * floats are render targets only.
+ */
+
+interface FloatOpenOptions {
+    width: number;
+    height: number;
+    /** Try this tier first; the ladder continues below it on failure. */
+    preferredTier?: FloatTier;
+    title: string;
+}
+interface CanvasSink {
+    canvas: HTMLCanvasElement;
+    width: number;
+    height: number;
+    /** Push the freshly drawn canvas frame into the PiP video. */
+    requestFrame: () => void;
+}
+type FloatEvent = 'closed' | 'tierchange';
+interface FloatingWindowManager {
+    readonly tier: FloatTier;
+    readonly isOpen: boolean;
+    /** Resolves with the tier that actually opened ('docked' if none could). */
+    open(opts: FloatOpenOptions): Promise<FloatTier>;
+    /** Idempotent; restores docked and emits 'closed'. */
+    close(): void;
+    /** Portal container for 'document-pip' | 'popup'; null otherwise. */
+    getPortalTarget(): HTMLElement | null;
+    /** Canvas sink for 'video-pip'; null otherwise. */
+    getCanvasSink(): CanvasSink | null;
+    on(event: FloatEvent, cb: (tier: FloatTier) => void): () => void;
+    /** Tear everything down (unmount); like close() but silent-safe. */
+    dispose(): void;
+}
+/** Feature-detect the available float tiers, best first. */
+declare function detectFloatTiers(): FloatTier[];
+declare function createFloatingWindowManager(deps: {
+    styleCss: string;
+}): FloatingWindowManager;
+
+/**
+ * React binding over {@link createFloatingWindowManager}: exposes the
+ * current tier + portal target as state and guarantees the float closes
+ * when the owning view unmounts (mode switch, Use-tab exit, shell
+ * teardown).
+ */
+
+interface FloatingWindowHandle {
+    tier: FloatTier;
+    isOpen: boolean;
+    /** Non-docked tiers this browser supports, best first. */
+    supportedTiers: FloatTier[];
+    portalTarget: HTMLElement | null;
+    canvasSink: CanvasSink | null;
+    open: (preferredTier?: FloatTier) => Promise<void>;
+    close: () => void;
+}
+declare function useFloatingWindow(styleCss: string): FloatingWindowHandle;
+
+/**
+ * Narration recorder for the teleprompter — an in-place (no modal)
+ * capture flow.
+ *
+ * Audio records THE MIC ANALYSIS STREAM (what paces the prompter is
+ * exactly what lands in the take); the optional camera is a separate
+ * video-only capture whose start skew vs the audio recorder is measured
+ * and persisted (`cameraOffsetSec`) — the audio file is the doc clock,
+ * so camera skew never affects narration timing. While recording, a
+ * sparse live trace of the prompter position is sampled; after stop,
+ * the take is decoded and run through core's offline aligner
+ * (`alignNarration`) to produce word/block timestamps for the sidecar.
+ * Decode/alignment failure degrades gracefully: saving still works,
+ * just without re-timing.
+ */
+
+type NarrationRecorderState = 'idle' | 'starting' | 'recording' | 'processing' | 'review' | 'saving' | 'error';
+type NarrationMediaRecorderOptions = MediaRecorderOptions & RecorderExtendedMediaOptions;
+interface NarrationTake {
+    audioBlob: Blob;
+    audioMime: string;
+    audioExt: string;
+    cameraBlob: Blob | null;
+    cameraMime: string | null;
+    cameraExt: string | null;
+    durationSec: number;
+    cameraOffsetSec: number | undefined;
+    trace: NarrationTrace;
+    alignment: NarrationAlignment | null;
+    script: NarrationScript;
+}
+interface UseNarrationRecorderOptions {
+    mic: MicAnalysisHandle;
+    getScript: () => NarrationScript | null;
+    /** Live prompter position, sampled into the trace while recording. */
+    getWordPos: () => number;
+    getMicDeviceId: () => string | null;
+    /** Constraints for the optional, video-only camera companion. */
+    cameraConstraints?: MediaTrackConstraints | boolean;
+    /** MediaRecorder hints for the primary narration audio file. */
+    audioRecorderOptions?: NarrationMediaRecorderOptions;
+    /** MediaRecorder hints for the camera companion file. */
+    cameraRecorderOptions?: NarrationMediaRecorderOptions;
+    /** Fired when capture actually starts (View starts the prompter). */
+    onRecordingStart?: () => void;
+    onRecordingStop?: () => void;
+}
+interface NarrationRecorderController {
+    state: NarrationRecorderState;
+    error: Error | null;
+    withCamera: boolean;
+    setWithCamera: (on: boolean) => void;
+    /** Live camera stream for the self-view while recording. */
+    cameraStream: MediaStream | null;
+    take: NarrationTake | null;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+    retake: () => void;
+    discard: () => void;
+    /** Transition into/out of 'saving'; the View owns the actual I/O. */
+    beginSave: () => void;
+    finishSave: (ok: boolean, error?: Error) => void;
+}
+declare function useNarrationRecorder(options: UseNarrationRecorderOptions): NarrationRecorderController;
+
+/**
+ * useNarrationStage — the state/orchestration half of the narration stage,
+ * extracted from TeleprompterView so other hosts (the Record media dialog)
+ * can mount the same prompter + recorder + save pipeline.
+ *
+ * Owns the teleprompter controller (single source of truth in the main
+ * window), the floating-window handle, the narration recorder, and the
+ * retry-idempotent save flow. Pair with <NarrationStage> for the DOM.
+ *
+ * Recording is prop-gated: pass `recording` deps (media provider + markdown
+ * writers) to enable capture; without them this is a pure prompter with zero
+ * capture code paths.
+ */
+
+/** Editor plumbing the recording flow needs; omit for prompter-only use. */
+interface TeleprompterRecordingDeps {
+    mediaProvider: MediaProvider;
+    container: ContentContainer | null;
+    markdownSource: string;
+    setMarkdownSource: (next: string) => void;
+    bumpMediaRevision: () => void;
+}
+interface UseNarrationStageOptions {
+    doc: Doc | null;
+    /** Recording deps; null/omitted disables the Record affordance. */
+    recording?: TeleprompterRecordingDeps | null;
+    /** Optional user-chosen filename base threaded into the save plan. */
+    getAudioBasename?: () => string | undefined;
+    /** Microphone constraints shared by voice analysis and audio recording. */
+    micConstraints?: MediaTrackConstraints;
+    /** Constraints for the optional narration camera lane. */
+    cameraConstraints?: MediaTrackConstraints;
+    /** MediaRecorder hints for the narration audio file. */
+    audioRecorderOptions?: NarrationMediaRecorderOptions;
+    /** MediaRecorder hints for the optional narration camera file. */
+    cameraRecorderOptions?: NarrationMediaRecorderOptions;
+}
+interface NarrationStageHandle {
+    controller: TeleprompterController;
+    float: FloatingWindowHandle;
+    recorder: NarrationRecorderController;
+    /** Pass-through so the stage component can gate its record slot. */
+    recording: TeleprompterRecordingDeps | null;
+    saveNotice: string | null;
+    dismissSaveNotice: () => void;
+    handleSave: () => Promise<void>;
+    handleRetake: () => void;
+    handleDiscard: () => void;
+    reviewAudioUrl: string | null;
+    handleReviewTimeUpdate: (event: SyntheticEvent<HTMLAudioElement>) => void;
+}
+declare function useNarrationStage(opts: UseNarrationStageOptions): NarrationStageHandle;
+
+export { useMediaRecorder as A, useMicAnalysis as B, type CanvasSink as C, DEFAULT_TELEPROMPTER_PREFS as D, useNarrationRecorder as E, type FloatOpenOptions as F, useNarrationStage as G, useTeleprompter as H, vadConfigForSensitivity as I, TELEPROMPTER_PREF_LIMITS as J, normalizeTeleprompterPrefs as K, type MicAnalysisHandle as M, type NarrationRecorderController as N, type PrompterTransport as P, type RecorderAudioBitrateMode as R, type TeleprompterController as T, type UseMediaRecorderOptions as U, type CaptureKind as a, type FloatTier as b, type FloatingWindowHandle as c, type FloatingWindowManager as d, type MicAnalysisStatus as e, type NarrationRecorderState as f, type NarrationStageHandle as g, type NarrationTake as h, type RecorderCameraLane as i, type RecorderExtendedMediaOptions as j, type RecorderSource as k, type RecorderState as l, type ResolvedFormat as m, type TeleprompterPrefs as n, type TeleprompterRecordingDeps as o, type UseMediaRecorderResult as p, type UseNarrationStageOptions as q, buildFilename as r, createFloatingWindowManager as s, detectFloatTiers as t, getCaptureKind as u, resolveFormat as v, supportsDisplayMedia as w, supportsMediaRecorder as x, supportsUserMedia as y, useFloatingWindow as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bendyline/squisq-editor-react",
-  "version": "2.4.5",
+  "version": "2.4.6",
   "description": "React editor shell with raw/WYSIWYG/preview modes for Squisq documents",
   "license": "MIT",
   "author": "Bendyline",
@@ -84,9 +84,9 @@
     "react-dom": "^18.0.0 || ^19.0.0"
   },
   "dependencies": {
-    "@bendyline/squisq": "2.4.3",
-    "@bendyline/squisq-formats": "2.3.7",
-    "@bendyline/squisq-react": "2.4.5",
+    "@bendyline/squisq": "2.4.4",
+    "@bendyline/squisq-formats": "2.3.8",
+    "@bendyline/squisq-react": "2.4.6",
     "@fortawesome/fontawesome-free": "7.2.0",
     "@tiptap/core": "2.27.2",
     "@tiptap/extension-heading": "2.27.2",