@bendyline/squisq-editor-react 2.4.0 → 2.4.2

package/dist/recorder-C0Tkyu5W.d.ts

@@ -0,0 +1,508 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { Doc, Theme, MediaProvider } from '@bendyline/squisq/schemas';
+import { ContentContainer } from '@bendyline/squisq/storage';
+import { i as TeleprompterRecordingDeps } from './useNarrationStage-Bqo18PBw.js';
+import { CSSProperties, RefObject } from 'react';
+
+/**
+ * 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';
+/** 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 / screen sources. */
+    videoConstraints?: MediaTrackConstraints | boolean;
+    /** 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;
+    /**
+     * 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;
+
+type RecorderColorScheme = 'light' | 'dark';
+/**
+ * Everything narration mode needs beyond the base recorder props. Supplying
+ * this (with non-null `recording`) surfaces the "Show narration mode"
+ * checkbox; when checked, the dialog expands and mounts the teleprompter
+ * beside the capture preview, and mic recording switches to the narration
+ * pipeline (voice-aligned v3 timing sidecar + document preamble insertion).
+ */
+interface RecorderNarrationOptions {
+    /** Parsed document the prompter script is built from. */
+    doc: Doc | null;
+    /** Theme for the prompter surface (colors/fonts). */
+    theme: Theme;
+    /** Editor plumbing for the narration save pipeline; null hides the checkbox. */
+    recording: TeleprompterRecordingDeps | null;
+}
+interface RecorderModalProps {
+    /** Required — recordings are written here. */
+    mediaProvider: MediaProvider;
+    /**
+     * Optional — when provided, narration-mode recordings drop a
+     * `.timing.json` sidecar at the matching container path so
+     * `resolveAudioMapping()` can auto-link them. Without it, only the
+     * raw recording is saved.
+     */
+    container?: ContentContainer | null;
+    /** Initial capture source. Defaults to `'mic'` (narration). */
+    initialMode?: RecorderSource;
+    /** Light/dark chrome scheme. Defaults to `'light'`. */
+    colorScheme?: RecorderColorScheme;
+    /** Called after the modal is dismissed (save or cancel). */
+    onClose: () => void;
+    /**
+     * Fired after a successful save. Hosts typically use this to insert a
+     * markdown reference at the cursor — see {@link RecorderSaveResult}
+     * for the fields a host needs to build that reference.
+     *
+     * NOT fired for narration-mode saves: the narration pipeline writes its
+     * own `{[audio …]}` document preamble (via `executeNarrationSave`), so a
+     * host insertion here would double up.
+     */
+    onSave?: (result: RecorderSaveResult) => void;
+    /** Enables the "Show narration mode" checkbox. Omit for the classic dialog. */
+    narration?: RecorderNarrationOptions | null;
+}
+/**
+ * The camera companion of a `'screen+camera'` save. Present only on that
+ * source's {@link RecorderSaveResult}; describes the picture-in-picture file
+ * that pairs with the screen recording in {@link RecorderSaveResult}.
+ */
+interface RecorderCameraSaveResult {
+    /** Path returned by `mediaProvider.addMedia()` for the camera file. */
+    relativePath: string;
+    /** Filename the modal chose for the camera file. */
+    filename: string;
+    /** MIME type of the saved camera blob. */
+    mimeType: string;
+    /** Camera recording length in seconds. */
+    duration: number;
+    /**
+     * Camera start minus screen start, in seconds (may be negative). Drives the
+     * PiP clip's `startAt`/`clipStart` so the bubble lines up with the screen.
+     */
+    offsetSec: number;
+}
+/** Payload handed to {@link RecorderModalProps.onSave} on a successful save. */
+interface RecorderSaveResult {
+    /** Path returned by `mediaProvider.addMedia()` — what the doc should reference.
+     * For `'screen+camera'` this is the SCREEN file (see {@link RecorderSaveResult.camera}). */
+    relativePath: string;
+    /** Filename the modal chose (e.g. `narration-20260516-091200.webm`). */
+    filename: string;
+    /** Capture source the user picked. */
+    source: RecorderSource;
+    /** MIME type of the saved blob. */
+    mimeType: string;
+    /** Recording length in seconds. */
+    duration: number;
+    /** Whether a narration sidecar was written. Always `false` for video sources. */
+    hasTimingSidecar: boolean;
+    /** Script text the user typed (narration only). */
+    sourceText?: string;
+    /** The paired camera file — present only for `source === 'screen+camera'`. */
+    camera?: RecorderCameraSaveResult;
+}
+declare function RecorderModal({ mediaProvider, container, initialMode, colorScheme, onClose, onSave, narration, }: RecorderModalProps): react_jsx_runtime.JSX.Element;
+
+interface RecorderButtonProps {
+    /** Where to write the resulting recording. Required. */
+    mediaProvider: MediaProvider;
+    /** Optional container for narration `.timing.json` sidecar writes. */
+    container?: ContentContainer | null;
+    /** Initial capture source. Defaults to `'mic'`. */
+    initialMode?: RecorderSource;
+    /** Light/dark chrome scheme copied onto the portaled modal. */
+    colorScheme?: RecorderColorScheme;
+    /** Fired after a successful save. */
+    onSave?: (result: RecorderSaveResult) => void;
+    /** Enables the modal's "Show narration mode" checkbox. */
+    narration?: RecorderNarrationOptions | null;
+    /** Button label. Defaults to `'Record'`. */
+    label?: string;
+    /** Optional inline button styles. */
+    style?: CSSProperties;
+    /** Whether the button is disabled. */
+    disabled?: boolean;
+}
+declare function RecorderButton({ mediaProvider, container, initialMode, colorScheme, onSave, narration, label, style, disabled, }: RecorderButtonProps): react_jsx_runtime.JSX.Element;
+
+interface RecorderPanelProps {
+    mediaProvider: MediaProvider;
+    container?: ContentContainer | null;
+    initialMode?: RecorderSource;
+    /** Light/dark chrome scheme copied onto the portaled modal. */
+    colorScheme?: RecorderColorScheme;
+    onSave?: (result: RecorderSaveResult) => void;
+    /** Enables the modal's "Show narration mode" checkbox. */
+    narration?: RecorderNarrationOptions | null;
+    /** ARIA / tooltip label. Defaults to `'Record media'`. */
+    tooltip?: string;
+    /** Optional className for the trigger button. */
+    className?: string;
+    /** Controlled modal state. Omit to let the panel manage its own state. */
+    open?: boolean;
+    /** Called whenever the trigger or modal requests an open-state change. */
+    onOpenChange?: (open: boolean) => void;
+    /** Render the built-in trigger button. Defaults to true. */
+    showTrigger?: boolean;
+}
+declare function RecorderPanel({ mediaProvider, container, initialMode, colorScheme, onSave, narration, tooltip, className, open: controlledOpen, onOpenChange, showTrigger, }: RecorderPanelProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * useStreamPreview — binds a `MediaStream` to a `<video>` element's
+ * `srcObject`. Decouples the preview surface from `useMediaRecorder`,
+ * letting hosts compose the preview element however they like.
+ */
+
+/**
+ * Assign `stream` to `<video>.srcObject` whenever either changes; clears
+ * it on unmount or when `stream` is `null`. The element is set to
+ * `playsInline` + `muted` automatically because previewing your own
+ * microphone with audio playthrough creates a feedback loop.
+ *
+ * @example
+ * ```tsx
+ * const videoRef = useRef<HTMLVideoElement>(null);
+ * const { stream } = useMediaRecorder({ source: 'camera' });
+ * useStreamPreview(videoRef, stream);
+ * return <video ref={videoRef} autoPlay />;
+ * ```
+ */
+declare function useStreamPreview(ref: RefObject<HTMLVideoElement | null>, stream: MediaStream | null): void;
+
+/**
+ * Microphone-only capture via `getUserMedia({ audio: true })`.
+ */
+/**
+ * Request a microphone-only `MediaStream`. Caller owns the stream and
+ * must stop its tracks when done.
+ *
+ * @param constraints - Optional audio constraints (sample rate, device
+ *   id, echo cancellation, etc.). Defaults to `true` — let the browser
+ *   pick.
+ * @throws When `mediaDevices` is unavailable, or when the user denies
+ *   permission (the underlying `getUserMedia` rejection propagates).
+ */
+declare function requestMicStream(constraints?: MediaTrackConstraints): Promise<MediaStream>;
+
+/**
+ * Camera + microphone capture via `getUserMedia({ video, audio })`.
+ */
+interface CameraStreamOptions {
+    /** Video track constraints (resolution, facing mode, frame rate). Pass `true` for browser default, or `false` to omit video. */
+    video?: boolean | MediaTrackConstraints;
+    /** Audio track constraints. Pass `true` for browser default, or `false` to omit audio. */
+    audio?: boolean | MediaTrackConstraints;
+}
+/**
+ * Request a camera + mic `MediaStream`. Caller owns the stream and must
+ * stop its tracks when done.
+ *
+ * Both tracks are requested by default. To capture video only, pass
+ * `audio: false`; to capture audio only use {@link requestMicStream}
+ * instead.
+ *
+ * @throws When `mediaDevices` is unavailable, or when the user denies
+ *   permission.
+ */
+declare function requestCameraStream(options?: CameraStreamOptions): Promise<MediaStream>;
+
+/**
+ * Screen capture via `getDisplayMedia`, with optional microphone mixing.
+ *
+ * The browser-native `getDisplayMedia({ audio: true })` flag only
+ * captures *system* audio (and only on Chromium on desktop). For
+ * narrated screencasts, hosts usually want the speaker's voice too —
+ * we provide an opt-in "include mic" path that pulls a parallel
+ * `getUserMedia` audio track and mixes it into the screen stream via
+ * `AudioContext`, so the resulting `MediaStream` carries a single audio
+ * track and a single video track.
+ */
+interface ScreenStreamOptions {
+    /** Video constraints for the screen surface. Pass `true` for browser default. */
+    video?: boolean | MediaTrackConstraints;
+    /**
+     * Whether to attempt to capture the system audio (tab / window / monitor
+     * audio). Browser support is limited (desktop Chromium only); when the
+     * platform doesn't honor this flag, the resulting stream simply omits
+     * the system audio track.
+     */
+    systemAudio?: boolean;
+    /**
+     * Whether to also pull the microphone via `getUserMedia` and mix it
+     * into the resulting stream's audio track. When both `systemAudio` and
+     * `includeMicrophone` produce tracks, they're combined via
+     * `AudioContext` into a single output track.
+     */
+    includeMicrophone?: boolean;
+    /** Microphone track constraints, when `includeMicrophone` is true. */
+    microphoneConstraints?: MediaTrackConstraints;
+}
+/**
+ * Handle returned by {@link requestScreenStream}. The `stream` is what
+ * gets handed to `MediaRecorder`; the `dispose()` callback shuts down
+ * any auxiliary resources (the mic-mix `AudioContext` plus the raw
+ * source tracks feeding it). Callers must also stop the stream's tracks
+ * via `stream.getTracks().forEach(t => t.stop())` when done —
+ * `dispose()` cleans up everything that isn't the stream itself.
+ *
+ * IMPORTANT for callers: when the microphone is mixed in, the raw
+ * system-audio / mic tracks are deliberately NOT members of `stream`
+ * (only the single mixed output track is). So stopping `stream`'s tracks
+ * alone leaves those captures live — `dispose()` is what releases them,
+ * and it must always be called alongside the stream teardown or the
+ * screen-share indicator stays lit.
+ */
+interface ScreenStreamHandle {
+    stream: MediaStream;
+    /** Auxiliary cleanup beyond the stream tracks. Safe to call multiple times. */
+    dispose: () => void;
+}
+/**
+ * Request a screen-capture `MediaStream`, optionally with a mixed-in
+ * microphone track. Caller owns the resulting stream.
+ *
+ * @throws When `getDisplayMedia` isn't available, or when the user
+ *   cancels the picker / denies permission.
+ */
+declare function requestScreenStream(options?: ScreenStreamOptions): Promise<ScreenStreamHandle>;
+
+/**
+ * Build the `.timing.json` sidecar that pairs with a narration recording.
+ *
+ * The shape matches what `resolveAudioMapping()` in
+ * `@bendyline/squisq` reads at runtime: `sourceText`, `duration`, and
+ * `bookmarks[]`. Sidecars are stored at `<audio-path>.timing.json`
+ * inside the same `ContentContainer`, so the recorder can drop them
+ * alongside its audio file and have the existing audio-mapping pipeline
+ * pick them up with no schema changes.
+ */
+/**
+ * Word-level timing bookmark — same shape as `AudioBookmark` in
+ * `@bendyline/squisq`. Recorder output produces an empty `bookmarks`
+ * array; word-level timing is the domain of TTS pipelines, not
+ * browser-side dictation.
+ */
+interface RecordedBookmark {
+    id: string;
+    time: number;
+    charOffset: number;
+    textFragment?: string;
+}
+interface TimingJson {
+    /** Plain text the user said (or intended to say) during the recording. */
+    sourceText: string;
+    /** Recording length in seconds. */
+    duration: number;
+    /** Word-level timing data. Empty by default — populated only when a downstream tool aligns the audio. */
+    bookmarks: RecordedBookmark[];
+}
+/**
+ * Build a `TimingJson` payload from a user-typed script and the
+ * recording's measured duration. Both fields are required by the
+ * downstream `parseTimingJson()` validator; missing them produces a
+ * sidecar that gets silently dropped by the audio-mapping pipeline.
+ */
+declare function buildTimingJson(sourceText: string, durationSec: number): TimingJson;
+/**
+ * Serialize a `TimingJson` payload to a `Uint8Array` ready to hand to
+ * `ContentContainer.writeFile()`. Pretty-printed so authors can hand-
+ * edit the sidecar if they ever want to.
+ */
+declare function encodeTimingJson(timing: TimingJson): Uint8Array;
+/**
+ * The container path convention `resolveAudioMapping()` expects:
+ * `<audio-path>.timing.json`. Pass the audio file's relative path
+ * (e.g. `'audio/narration-001.webm'`) and the matching sidecar path is
+ * returned (`'audio/narration-001.webm.timing.json'`).
+ */
+declare function timingPathFor(audioRelativePath: string): string;
+
+export { supportsMediaRecorder as A, supportsUserMedia as B, type CameraStreamOptions as C, timingPathFor as D, useMediaRecorder as E, useStreamPreview as F, type RecordedBookmark as R, type ScreenStreamHandle as S, type TimingJson as T, type UseMediaRecorderOptions as U, type CaptureKind as a, RecorderButton as b, type RecorderButtonProps as c, type RecorderCameraLane as d, type RecorderCameraSaveResult as e, type RecorderColorScheme as f, RecorderModal as g, type RecorderModalProps as h, type RecorderNarrationOptions as i, RecorderPanel as j, type RecorderPanelProps as k, type RecorderSaveResult as l, type RecorderSource as m, type RecorderState as n, type ResolvedFormat as o, type ScreenStreamOptions as p, type UseMediaRecorderResult as q, buildFilename as r, buildTimingJson as s, encodeTimingJson as t, getCaptureKind as u, requestCameraStream as v, requestMicStream as w, requestScreenStream as x, resolveFormat as y, supportsDisplayMedia as z };

package/dist/shell/index.d.ts

@@ -1,4 +1,4 @@
-export { B as BlockTagVisibility, D as DocumentLinkCandidate, b as DocumentLinkProvider, c as EditorActions, d as EditorColorScheme, e as EditorContextValue, E as EditorHostMode, f as EditorMode, g as EditorProvider, h as EditorProviderProps, i as EditorShell, j as EditorShellProps, k as EditorState, l as EditorView, I as ImageDisplayMode, L as LayoutMode, M as MentionCandidate, m as MentionProvider, P as PreviewPanel, n as PreviewPanelProps, R as RawEditor, o as RawEditorProps, T as ThemeInheritance, V as ViewPreferences, p as WysiwygEditor, q as WysiwygEditorProps, u as useEditorContext } from '../shell-9Kxzxjbn.js';
+export { B as BlockTagVisibility, D as DocumentLinkCandidate, b as DocumentLinkProvider, c as EditorActions, d as EditorColorScheme, e as EditorContextValue, E as EditorHostMode, f as EditorMode, g as EditorProvider, h as EditorProviderProps, i as EditorShell, j as EditorShellProps, k as EditorState, l as EditorView, I as ImageDisplayMode, L as LayoutMode, M as MentionCandidate, m as MentionProvider, P as PreviewPanel, n as PreviewPanelProps, R as RawEditor, o as RawEditorProps, T as ThemeInheritance, V as ViewPreferences, p as WysiwygEditor, q as WysiwygEditorProps, u as useEditorContext } from '../shell-CU4GpGuq.js';
 import 'react/jsx-runtime';
 import 'react';
 import '@bendyline/squisq/schemas';

package/dist/shell/index.js

@@ -5,14 +5,14 @@ import {
   RawEditor,
   WysiwygEditor,
   useEditorContext
-} from "../chunk-UPEGQYF4.js";
+} from "../chunk-XOMQK4JA.js";
 import "../chunk-V4NBQF5C.js";
-import "../chunk-MM3M2KUV.js";
+import "../chunk-WLJ623UZ.js";
 import "../chunk-V44VP242.js";
-import "../chunk-F4NBECWR.js";
+import "../chunk-PKGBWNUQ.js";
 import "../chunk-GS7QWYFT.js";
-import "../chunk-5JMHFAVW.js";
-import "../chunk-5Q4JN4I5.js";
+import "../chunk-V6Z7GG55.js";
+import "../chunk-PDCKJCOS.js";
 export {
   EditorProvider,
   EditorShell,

package/dist/{shell-9Kxzxjbn.d.ts → shell-CU4GpGuq.d.ts}

@@ -366,6 +366,13 @@ interface EditorContextValue extends EditorState, EditorActions {
      * host DOES resolve is unsupported. Executable schemes stay refused.
      */
     linkSchemes: readonly string[] | undefined;
+    /**
+     * File name the host opened this document as (e.g. `Longview Plan.md`), if
+     * any. Used as a display-title fallback — for example, the header of a
+     * heading-less leading "preamble" block in the slideshow preview when the
+     * document has no frontmatter `title:`.
+     */
+    fileName: string | undefined;
 }
 type ImageDisplayMode = 'inline' | 'thumbnail';
 /**
@@ -632,6 +639,18 @@ interface WriteCanvasSettings {
     textSize?: number;
     /** Unitless line-height multiplier for body text. */
     lineSpacing?: number;
+    /**
+     * CSS `font-family` value for Write-canvas headings. Applies only when no
+     * theme font override is active (the theme's title font always wins) — see
+     * the heading rule in `styles/editor.css`. Omit to inherit as before.
+     */
+    headerFont?: string;
+    /**
+     * CSS `font-family` value for Write-canvas body text. Applies only when no
+     * theme font override is active (the theme's body font always wins) — see
+     * the editor rule in `styles/editor.css`. Omit to inherit as before.
+     */
+    bodyFont?: string;
 }
 
 /**
@@ -749,6 +768,11 @@ interface EditorShellProps {
     onSaveVersion?: (result: SaveVersionResult) => void;
     /** Show the Files toggle in the toolbar. Defaults to true when mediaProvider is passed. */
     showFilesToggle?: boolean;
+    /**
+     * Whether the Files panel offers browser downloads for its binary entries.
+     * Defaults to true. Pass false to remove the built-in download affordance.
+     */
+    allowBinaryDownloads?: boolean;
     /** Content rendered at the left edge of the toolbar, before the view tabs. */
     toolbarSlotLeft?: ReactNode;
     /** Content rendered after the formatting controls (in the middle area of the toolbar). */
@@ -1041,7 +1065,7 @@ interface EditorShellProps {
  * Complete markdown editor shell with toolbar, view switcher, and three
  * editing modes: Raw (Monaco), WYSIWYG (Tiptap), and Preview.
  */
-declare function EditorShell({ initialMarkdown, initialView, hostMode, defaultViewportPreset, articleId, basePath, onChange, onLinkClick, colorScheme, className, height, minHeight, maxHeight, mediaProvider, workspaceContainer, allowVersioning, versionBasename, versioningPrunePolicy, versioningAutoSaveIdleMs, onSaveVersion, showFilesToggle, toolbarSlotLeft, toolbarSlotAfterActions, toolbarSlotRight, statusBarSlotRight, showPlayTab, allowPresentationWindow, allowPresentationFullscreen, allowPrint, submitOnEnter, codeContext, fullWidth, uxFont, thinMargins, writeCanvasSettings, showStatusBar, imageDisplayMode, fileName, language, findMode, onFindModeChange, mentionProvider, documentLinkProvider, linkSchemes, allowRecording, allowNarrate, preserveSourceWrapping, placeholder, readOnly, imageSrc, imageAlt, imageMode, imageEditorContainer, onImageExport, inlinePreview, inlinePreviewWidth, outline, outlineWidth, blockTags, blockTagVisibility, themeInheritance, viewPreferences, onViewPreferencesChange, themeOverride, }: EditorShellProps): react_jsx_runtime.JSX.Element;
+declare function EditorShell({ initialMarkdown, initialView, hostMode, defaultViewportPreset, articleId, basePath, onChange, onLinkClick, colorScheme, className, height, minHeight, maxHeight, mediaProvider, workspaceContainer, allowVersioning, versionBasename, versioningPrunePolicy, versioningAutoSaveIdleMs, onSaveVersion, showFilesToggle, allowBinaryDownloads, toolbarSlotLeft, toolbarSlotAfterActions, toolbarSlotRight, statusBarSlotRight, showPlayTab, allowPresentationWindow, allowPresentationFullscreen, allowPrint, submitOnEnter, codeContext, fullWidth, uxFont, thinMargins, writeCanvasSettings, showStatusBar, imageDisplayMode, fileName, language, findMode, onFindModeChange, mentionProvider, documentLinkProvider, linkSchemes, allowRecording, allowNarrate, preserveSourceWrapping, placeholder, readOnly, imageSrc, imageAlt, imageMode, imageEditorContainer, onImageExport, inlinePreview, inlinePreviewWidth, outline, outlineWidth, blockTags, blockTagVisibility, themeInheritance, viewPreferences, onViewPreferencesChange, themeOverride, }: EditorShellProps): react_jsx_runtime.JSX.Element;
 
 /**
  * RawEditor