@bendyline/squisq-editor-react 1.5.3 → 1.6.1

package/dist/index.d.ts

@@ -1,19 +1,47 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
 import { ReactNode, CSSProperties, RefObject } from 'react';
-import { Doc, MediaProvider, Theme, ViewportPreset, ViewportConfig, SurfaceScheme, ImageEditDoc, ImageEditLayer } from '@bendyline/squisq/schemas';
-import { MarkdownDocument } from '@bendyline/squisq/markdown';
+import { Doc, MediaProvider, Theme, ViewportPreset, ViewportConfig, CustomTemplateDefinition, SurfaceScheme, ImageEditDoc, ImageEditLayer } from '@bendyline/squisq/schemas';
+import { MarkdownDocument, HeadingAttributes } from '@bendyline/squisq/markdown';
 import { ContentContainer } from '@bendyline/squisq/storage';
 import { DocumentVersionManager, SaveVersionOptions, SaveVersionResult, PrunePolicy } from '@bendyline/squisq/versions';
 import * as _tiptap_core from '@tiptap/core';
-import { Editor } from '@tiptap/core';
+import { Editor, Extension } from '@tiptap/core';
+import * as monaco_editor from 'monaco-editor';
 import { editor } from 'monaco-editor';
 import { IconFamily } from '@bendyline/squisq/icons';
 import { DisplayMode, CaptionStyle } from '@bendyline/squisq-react';
+import { Editor as Editor$1 } from '@tiptap/react';
 import * as _tiptap_extension_heading from '@tiptap/extension-heading';
+import { Node } from '@tiptap/pm/model';
 import { SquisqAnnotatedSchema, JsonFormValidator, JsonFormValidationError } from '@bendyline/squisq/jsonForm';
 import { ImageEditExportFormat, ImageEditVersionManager } from '@bendyline/squisq/imageEdit';
 
+/**
+ * Configuration a Scene host (diagram / drawing / layout widget) supplies
+ * so the shared inline text editor knows how to read and write the text of
+ * a given layer. The Scene owns the editing UI (overlay + positioning);
+ * the host owns persistence (markdown heading vs. layout JSON blob).
+ */
+type SceneTextLevel = 'inline' | 'block' | 'rich';
+
+/**
+ * sceneTextChannel — a module singleton that bridges the canvas's inline
+ * text editor (which renders in a **detached React root** created by the
+ * Diagram/SceneBlock ProseMirror extensions, outside `<EditorProvider>`)
+ * to the provider, so the top formatting toolbar can target it.
+ *
+ * The active textbox's `SceneTextOverlay` publishes its Tiptap editor here
+ * on focus and clears it on blur/unmount; `EditorProvider` subscribes and
+ * mirrors the handle into `activeSceneText`. Singleton because only one
+ * canvas textbox can be focused at a time.
+ */
+
+interface SceneTextHandle {
+    editor: Editor;
+    level: SceneTextLevel;
+}
+
 /** Monaco standalone code editor instance type */
 type MonacoEditor = editor.IStandaloneCodeEditor;
 /**
@@ -63,7 +91,22 @@ interface DocumentLinkCandidate {
  */
 type DocumentLinkProvider = (query: string) => Promise<DocumentLinkCandidate[]>;
 type EditorView = 'raw' | 'wysiwyg' | 'preview';
-type EditorTheme = 'light' | 'dark';
+/**
+ * Light/dark chrome mode for the editor shell (toolbar, tabs, status bar,
+ * side panes). This is the editor's *UI color scheme* — distinct from a
+ * Squisq `Theme` object, which styles the rendered document. Renamed from
+ * the former `EditorTheme` to remove that ambiguity.
+ */
+type EditorColorScheme = 'light' | 'dark';
+/**
+ * Document layout mode. `'document'` shows the whole markdown document in
+ * the active view (the historical behavior). `'block'` is the
+ * block-at-a-time view — one heading-defined block on a card at a time,
+ * with the editor scoped to just that block. `'timeline'` is block mode plus
+ * a horizontal timeline track for editing block durations and media slices.
+ * See {@link useBlockNavigator}.
+ */
+type LayoutMode = 'document' | 'block' | 'timeline';
 /**
  * How much of the active Squisq theme the WYSIWYG editing surface
  * mirrors. `'fonts'` is the historical default — body and heading
@@ -90,8 +133,8 @@ interface EditorState {
     parseError: string | null;
     /** Whether a parse is pending */
     isParsing: boolean;
-    /** Current color theme */
-    theme: EditorTheme;
+    /** Current light/dark chrome color scheme for the editor shell. */
+    colorScheme: EditorColorScheme;
     /** Operating mode — 'markdown' for the full shell, 'code' for Monaco-only. */
     editorMode: EditorMode;
     /** Monaco language ID for the Raw editor. */
@@ -152,10 +195,47 @@ interface EditorState {
      * shell.
      */
     allowRecording: boolean;
+    /**
+     * Document layout mode. `'document'` (default) edits the whole document;
+     * `'block'` activates the block-at-a-time card view. Initialized from the
+     * EditorShell `layoutMode` prop; the View menu can toggle it at runtime.
+     */
+    layoutMode: LayoutMode;
+    /**
+     * The markdown the active text editor should bind to: the full source in
+     * `'document'` mode, or just the active block's slice in `'block'` mode.
+     * Editors read this instead of `markdownSource` so the same surfaces work
+     * in both layouts.
+     */
+    editorSource: string;
+    /** Number of navigable blocks (cards) in the current document. */
+    blockCount: number;
+    /** Index of the block currently shown on the card (block mode). */
+    activeBlockKey: number;
+    /** 1-based source line where the active block begins, or null. */
+    activeBlockStartLine: number | null;
 }
 interface EditorActions {
     /** Set markdown source and trigger re-parse */
     setMarkdownSource: (source: string) => void;
+    /**
+     * Write through the active editor channel. In `'document'` mode this is
+     * `setMarkdownSource`; in `'block'` mode it splices the edited block back
+     * into the full document. Editors call this instead of `setMarkdownSource`.
+     */
+    setEditorSource: (source: string) => void;
+    /** Switch between Document and Block-at-a-time layouts. */
+    setLayoutMode: (mode: LayoutMode) => void;
+    /** Show a block by index in block mode (clamped to range). */
+    goToBlock: (key: number) => void;
+    /** Show the block that owns a given 1-based source line (used by the outline). */
+    goToBlockByLine: (line: number) => void;
+    /** Move the card to the previous block. */
+    prevBlock: () => void;
+    /** Move the card to the next block. */
+    nextBlock: () => void;
+    /** Insert a new heading block after the active one and move to it. */
+    addBlock: () => void;
     /** Set markdown from a MarkdownDocument (e.g. from WYSIWYG) */
     setMarkdownDoc: (doc: MarkdownDocument) => void;
     /** Switch the active view */
@@ -164,8 +244,8 @@ interface EditorActions {
     setTiptapEditor: (editor: Editor | null) => void;
     /** Register / unregister the Monaco editor instance (called by RawEditor) */
     setMonacoEditor: (editor: MonacoEditor | null) => void;
-    /** Set the color theme */
-    setTheme: (theme: EditorTheme) => void;
+    /** Set the light/dark chrome color scheme for the editor shell. */
+    setColorScheme: (colorScheme: EditorColorScheme) => void;
     /** Show or hide the inline preview gutter at runtime (driven by the View menu). */
     setInlinePreviewVisible: (visible: boolean) => void;
     /** Show or hide the bottom status bar at runtime (driven by the View menu). */
@@ -201,6 +281,14 @@ interface EditorContextValue extends EditorState, EditorActions {
     tiptapEditor: Editor | null;
     /** The live Monaco editor instance (null when Raw is not mounted) */
     monacoEditor: MonacoEditor | null;
+    /**
+     * The focused canvas textbox editor, if any — a small Tiptap instance for
+     * a diagram/drawing/layout textbox being edited inline. Published via
+     * `sceneTextChannel` (the canvas renders in a detached React root). The
+     * top formatting toolbar retargets to this when set. `level` gates which
+     * buttons apply (`inline` = marks only; `rich` = headings/lists too).
+     */
+    activeSceneText: SceneTextHandle | null;
     /**
      * Workspace-scoped `ContentContainer` for this document — the folder
      * holding the doc, its `_files/` sidecar, sibling documents, and any
@@ -259,8 +347,8 @@ interface EditorProviderProps {
     initialView?: EditorView;
     /** Article ID used when generating the Doc */
     articleId?: string;
-    /** Color theme */
-    theme?: EditorTheme;
+    /** Light/dark chrome color scheme for the editor shell. */
+    colorScheme?: EditorColorScheme;
     /**
      * Workspace-scoped `ContentContainer` for this document — the folder
      * holding the doc, its `_files/` sidecar, sibling documents, and any
@@ -351,6 +439,12 @@ interface EditorProviderProps {
      * toolbar's View menu can change it at runtime.
      */
     themeInheritance?: ThemeInheritance;
+    /**
+     * Initial layout mode. Defaults to `'document'` (whole-document editing).
+     * `'block'` boots into the block-at-a-time card view. The toolbar's View
+     * menu can toggle it at runtime.
+     */
+    layoutMode?: LayoutMode;
     /**
      * Bundled view preferences — a serializable JSON blob covering all
      * runtime-toggleable view options. When provided, individual values
@@ -386,8 +480,86 @@ interface ViewPreferences {
     blockTags?: boolean;
     /** How much of the active Squisq theme the WYSIWYG surface mirrors. */
     themeInheritance?: ThemeInheritance;
+    /** Document vs. block-at-a-time layout. */
+    layoutMode?: LayoutMode;
+}
+declare function EditorProvider({ initialMarkdown, initialView, articleId, colorScheme: initialColorScheme, workspaceContainer, allowVersioning, versionBasename, versioningPrunePolicy, versioningAutoSaveIdleMs, onSaveVersion, mediaProvider, imageDisplayMode, mentionProvider, documentLinkProvider, allowRecording, fileName, language, inlinePreview, showStatusBar, outline, blockTags, themeInheritance, layoutMode, viewPreferences, onViewPreferencesChange, children, }: EditorProviderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Host-supplied context sections rendered INSIDE the Monaco (raw/code)
+ * surface: collapsible markdown blurbs injected above anchor lines, plus an
+ * optional file-top summary. Squisq stays host-agnostic — anchors are plain
+ * line numbers, ids are opaque strings, links are intercepted via callback.
+ *
+ * Accessibility note: Monaco marks its view-zone layer `aria-hidden`, so
+ * sections are invisible to screen readers in v1.
+ */
+/**
+ * One host-supplied markdown blurb anchored above a line of the code buffer.
+ * Rendered as a compact one-line strip that expands in place to the full
+ * markdown body.
+ */
+interface CodeContextSection {
+    /**
+     * Stable identity used to reconcile zones across prop updates — e.g. a
+     * symbol id like 'resolveImportEdges@60'. Zones are diffed by id: same id +
+     * new line moves the zone; same id + new markdown re-renders in place; a
+     * new id creates a new zone.
+     */
+    id: string;
+    /**
+     * 1-based line the section renders ABOVE. Out-of-range values are clamped
+     * by Monaco. In editable buffers the zone rides Monaco's whitespace
+     * semantics — it shifts as lines are inserted/deleted above it and
+     * collapses onto the previous line if its anchor lines are deleted. Squisq
+     * never re-derives anchors from edits; the host re-supplies lines when it
+     * re-analyzes the file.
+     */
+    line: number;
+    /**
+     * Compact markdown for the collapsed strip. Rendered on one line (block
+     * structure flattened, overflow ellipsized). Links work here too and go
+     * through `onLinkClick`.
+     */
+    summaryMarkdown: string;
+    /**
+     * Full markdown body shown when expanded. Omit while still loading — the
+     * expanded view shows a muted loading row and fills in when a later prop
+     * update supplies it.
+     */
+    markdown?: string;
+    /** Start expanded. The user's toggle wins after first interaction. Default false. */
+    defaultExpanded?: boolean;
+}
+/** The full context dictionary passed to `EditorShell.codeContext`. */
+interface CodeContext {
+    /**
+     * Section pinned above line 1 (file summary). Rendered before any line-1
+     * `sections` entry. `line` is implicit.
+     */
+    fileTop?: Omit<CodeContextSection, 'line'>;
+    /** Line-anchored sections. Array order is preserved for equal lines. */
+    sections?: CodeContextSection[];
+    /**
+     * Extra URI schemes section links may use (e.g. `['gezel-nav']`).
+     * http/https/mailto/tel are always allowed; executable schemes
+     * (javascript:, data:) are never allowed regardless.
+     */
+    linkSchemes?: readonly string[];
+    /**
+     * Intercepts link clicks inside sections, receiving the href exactly as
+     * authored in the markdown. Return `false` to let the browser's default
+     * navigation proceed; any other return (or void) suppresses it. Fragment
+     * links of the form `#L<digits>` are handled natively by squisq (reveal
+     * that line in the editor) and never reach this callback. When omitted:
+     * http(s)/mailto links open normally, custom-scheme links do nothing.
+     */
+    onLinkClick?: (href: string, meta: {
+        sectionId: string;
+    }) => boolean | undefined;
+    /** Notified on expand/collapse — lets hosts lazy-load bodies on first expand. */
+    onToggleSection?: (sectionId: string, expanded: boolean) => void;
 }
-declare function EditorProvider({ initialMarkdown, initialView, articleId, theme: initialTheme, workspaceContainer, allowVersioning, versionBasename, versioningPrunePolicy, versioningAutoSaveIdleMs, onSaveVersion, mediaProvider, imageDisplayMode, mentionProvider, documentLinkProvider, allowRecording, fileName, language, inlinePreview, showStatusBar, outline, blockTags, themeInheritance, viewPreferences, onViewPreferencesChange, children, }: EditorProviderProps): react_jsx_runtime.JSX.Element;
 
 interface EditorShellProps {
     /** Initial markdown content */
@@ -401,8 +573,13 @@ interface EditorShellProps {
     basePath?: string;
     /** Called when markdown source changes */
     onChange?: (source: string) => void;
-    /** Color theme: 'light' or 'dark' (default: 'light') */
-    theme?: 'light' | 'dark';
+    /**
+     * Light/dark chrome color scheme for the editor shell — toolbar, tabs,
+     * status bar, and side panes (default: `'light'`). This is the editor's
+     * UI mode, **not** a Squisq `Theme` object; the rendered document's
+     * styling is controlled separately via `themeOverride` / `Doc.themeId`.
+     */
+    colorScheme?: 'light' | 'dark';
     /** Additional class name */
     className?: string;
     /** CSS height for the shell container (default: '100vh') */
@@ -497,6 +674,13 @@ interface EditorShellProps {
      * (Slack, Discord). When omitted, the editor behaves normally.
      */
     submitOnEnter?: () => void;
+    /**
+     * Host-supplied context dictionary rendered inside the Monaco (raw / code)
+     * surface: collapsible markdown sections injected above anchor lines, plus
+     * an optional file-top summary. See {@link CodeContext}. Ignored in
+     * WYSIWYG / preview / image surfaces.
+     */
+    codeContext?: CodeContext;
     /**
      * Let the WYSIWYG editing surface fill its container instead of rendering
      * as a centered 800px "page" column. Useful when embedding in chat
@@ -655,9 +839,11 @@ interface EditorShellProps {
      */
     outline?: boolean;
     /**
-     * Width in pixels for the outline pane. Defaults to 240. Only takes
-     * effect when {@link EditorShellProps.outline} is true (or the View
-     * menu has toggled it on).
+     * Fixed width in pixels for the outline pane. When omitted, the pane sizes
+     * responsively — never narrower than 260px, growing with the window and
+     * capped at 460px — so it stretches out when there's horizontal space to
+     * spare. Only takes effect when {@link EditorShellProps.outline} is true (or
+     * the View menu has toggled it on).
      */
     outlineWidth?: number;
     /**
@@ -702,7 +888,237 @@ 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, articleId, basePath, onChange, theme, className, height, minHeight, maxHeight, mediaProvider, workspaceContainer, container, allowVersioning, versionBasename, versioningPrunePolicy, versioningAutoSaveIdleMs, onSaveVersion, showFilesToggle, toolbarSlotLeft, toolbarSlotAfterActions, toolbarSlotRight, showPlayTab, submitOnEnter, fullWidth, uxFont, thinMargins, showStatusBar, imageDisplayMode, fileName, language, mentionProvider, documentLinkProvider, allowRecording, placeholder, readOnly, imageSrc, imageAlt, imageMode, imageEditorContainer, onImageExport, inlinePreview, inlinePreviewWidth, outline, outlineWidth, blockTags, themeInheritance, viewPreferences, onViewPreferencesChange, themeOverride, }: EditorShellProps): react_jsx_runtime.JSX.Element;
+declare function EditorShell({ initialMarkdown, initialView, articleId, basePath, onChange, colorScheme, className, height, minHeight, maxHeight, mediaProvider, workspaceContainer, container, allowVersioning, versionBasename, versioningPrunePolicy, versioningAutoSaveIdleMs, onSaveVersion, showFilesToggle, toolbarSlotLeft, toolbarSlotAfterActions, toolbarSlotRight, showPlayTab, submitOnEnter, codeContext, fullWidth, uxFont, thinMargins, showStatusBar, imageDisplayMode, fileName, language, mentionProvider, documentLinkProvider, allowRecording, placeholder, readOnly, imageSrc, imageAlt, imageMode, imageEditorContainer, onImageExport, inlinePreview, inlinePreviewWidth, outline, outlineWidth, blockTags, themeInheritance, viewPreferences, onViewPreferencesChange, themeOverride, }: EditorShellProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Bridges a host-supplied {@link CodeContext} onto the live Monaco editor:
+ * owns a {@link CodeContextZoneManager} per editor instance, reconciles zones
+ * when the context prop changes, and portals a `CodeContextSectionView` into
+ * each zone's dom node. Mounted by EditorShell in code mode; also exported
+ * for hosts composing a custom shell around `RawEditor`.
+ */
+declare function CodeContextZones({ options }: {
+    options: CodeContext;
+}): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * One entry in a {@link FolderView} — a file or subfolder. Host-defined
+ * `path` is opaque to this component: it's used as the React key and
+ * handed back verbatim to the open callbacks so the host can resolve it.
+ */
+interface FolderEntry {
+    /** Display name (basename). */
+    name: string;
+    /** Full host path. Opaque here; passed back on open. */
+    path: string;
+    isDirectory: boolean;
+}
+interface FolderViewProps {
+    /** Folder display name (basename) shown in the header. */
+    name: string;
+    /** Immediate children of the folder — subfolders and files. */
+    entries: FolderEntry[];
+    /** Open a file entry. The host decides what "open" means. */
+    onOpenFile: (entry: FolderEntry) => void;
+    /** Drill into a subfolder. */
+    onOpenFolder: (entry: FolderEntry) => void;
+    /** Primary action — create a new document in this folder. */
+    onNewDocument: () => void;
+    /** Secondary action — create a new subfolder. Omit to hide the button. */
+    onNewFolder?: () => void;
+    /** Color theme (default `'light'`). */
+    theme?: 'light' | 'dark';
+    /** CSS height for the container (default `'100%'`). */
+    height?: string;
+    /** Override the per-entry icon. Defaults to FontAwesome file/folder glyphs. */
+    iconFor?: (entry: FolderEntry) => ReactNode;
+}
+/**
+ * FolderView — a standalone folder browser surface.
+ *
+ * Lists a folder's files and subfolders plus a prominent "New document"
+ * action (and an optional "New folder"). It's the companion to
+ * {@link EditorShell}: where the shell edits a single document, this
+ * presents the directory around it.
+ *
+ * Like the shell, it's host-agnostic — the consumer supplies the
+ * `entries` and the open / new callbacks, and FolderView owns only the
+ * presentation and theming. It holds no state and reads nothing from
+ * disk, so it composes into any storage backend.
+ */
+declare function FolderView({ name, entries, onOpenFile, onOpenFolder, onNewDocument, onNewFolder, theme, height, iconFor, }: FolderViewProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * useBlockNavigator
+ *
+ * Standalone hook powering the block-at-a-time editing view. Given a
+ * `(source, setSource)` pair it slices the markdown into blocks (via
+ * `blockRange.ts`), tracks which block is active, and exposes a derived
+ * **content channel** (`editorSource` / `setEditorSource`) plus navigation.
+ *
+ * It depends only on its arguments — no `EditorContext`, no `EditorShell` —
+ * so any host (an embedded single-block editor, a chat composer, a review
+ * surface) can drive a block-at-a-time UI by calling it directly.
+ *
+ * When `enabled` is false the channel is an identity passthrough: the editors
+ * see and write the full source exactly as before.
+ */
+interface BlockNavigator {
+    /** What the bound editor should show: the active slice (block mode) or the full source. */
+    editorSource: string;
+    /** What the bound editor writes through: splices back into the full source (block mode). */
+    setEditorSource: (s: string) => void;
+    /** Number of navigable blocks in the current source. */
+    blockCount: number;
+    /** Index of the active block (clamped into range). */
+    activeBlockKey: number;
+    /** Jump to a block by index (clamped). */
+    goToBlock: (key: number) => void;
+    /**
+     * Select the block that owns a given 1-based source line — used by the
+     * outline, which knows a heading's source line but not its slice index
+     * (slice order includes the optional preamble, so it needn't match
+     * `flattenBlocks` order).
+     */
+    goToBlockByLine: (line: number) => void;
+    /** 1-based source line where the active block begins (for outline highlight). */
+    activeBlockStartLine: number | null;
+    /** Move to the previous block (no-op at the start). */
+    prevBlock: () => void;
+    /** Move to the next block (no-op at the end). */
+    nextBlock: () => void;
+    /** Insert a new heading-defined block after the active one and move to it. */
+    addBlock: () => void;
+}
+interface UseBlockNavigatorOptions {
+    /**
+     * When false (the default), the channel passes through to the full source
+     * and navigation is inert. Hosts flip this on to enter block-at-a-time mode.
+     */
+    enabled?: boolean;
+}
+declare function useBlockNavigator(source: string, setSource: (s: string) => void, opts?: UseBlockNavigatorOptions): BlockNavigator;
+
+interface BlockCardViewProps {
+    /** Total number of navigable blocks. */
+    blockCount: number;
+    /** Index of the block currently shown (0-based). */
+    activeBlockKey: number;
+    /** Move to the previous block. */
+    onPrev: () => void;
+    /** Move to the next block. */
+    onNext: () => void;
+    /** Insert a new block after the current one. Omit to hide the affordance. */
+    onAdd?: () => void;
+    /** The editor surface (or any content) for the active block. */
+    children: ReactNode;
+    /** Optional extra class for the outer container. */
+    className?: string;
+}
+declare function BlockCardView({ blockCount, activeBlockKey, onPrev, onNext, onAdd, children, className, }: BlockCardViewProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * blockRange
+ *
+ * Source-text-range slicing for the block-at-a-time editing view. Splits a
+ * full markdown document into ordered, contiguous slices — one per
+ * heading-defined block plus an optional leading preamble — so a single
+ * block can be shown in isolation and edits spliced back into the parent.
+ *
+ * A block runs from its heading line through the character just before the
+ * next heading at ANY depth (or EOF). Sub-headings therefore start their own
+ * slices — they are NOT folded into their parent — which matches the
+ * "don't see child blocks" requirement and the `slicePastHeading` boundary
+ * in `blockSlice.ts`. Ranges are half-open `[startOffset, endOffset)` and
+ * line-aligned, so trailing blank lines stay with the current block and
+ * `spliceBlock(src, range, getBlockSlices(src)[i].text) === src` for every i.
+ *
+ * These are pure functions over a markdown string — no React, no editor
+ * coupling — so any host can reuse them.
+ */
+/** Half-open character range into the full source: `[startOffset, endOffset)`. */
+interface BlockRange {
+    startOffset: number;
+    endOffset: number;
+}
+/** One block's source text plus the range it occupies in the full document. */
+interface BlockSlice {
+    text: string;
+    range: BlockRange;
+}
+/**
+ * Split `fullSource` into ordered block slices.
+ *
+ * - With no headings, the entire post-frontmatter body is a single slice
+ *   (so an empty or heading-less document still shows one editable card).
+ * - With headings, a leading preamble slice is included only when the text
+ *   before the first heading has non-whitespace content. Each heading then
+ *   yields one slice spanning up to the next heading (any depth) or EOF.
+ *
+ * Frontmatter is never part of any slice — slices start at the body offset.
+ */
+declare function getBlockSlices(fullSource: string): BlockSlice[];
+/** Replace the text in `range` with `newText`, returning the new full source. */
+declare function spliceBlock(fullSource: string, range: BlockRange, newText: string): string;
+/** Character offset of the start of 1-based `line` (clamps past EOF). */
+declare function lineToOffset(source: string, line: number): number;
+/** 1-based line number containing `offset`. */
+declare function offsetToLine(source: string, offset: number): number;
+/** Index of the slice whose range contains `offset`, or -1. */
+declare function sliceIndexAtOffset(slices: BlockSlice[], offset: number): number;
+
+/**
+ * TimelineTrack
+ *
+ * Horizontal timeline strip for the Timeline view. Shows every block as a bar
+ * (width ∝ duration, x ∝ startTime) with its media clips as sub-bars below.
+ * Clicking a block selects it (the editor above follows). Dragging a block's
+ * right edge changes its duration; dragging its left edge changes the previous
+ * block's duration (the boundary, since startTime is derived). Dragging a media
+ * clip moves its `startAt`; dragging the clip's right edge changes its length;
+ * double-clicking a clip toggles `spillover`. All edits are written back to the
+ * markdown source via {@link timelineSource}.
+ */
+interface TimelineTrackProps {
+    height?: number;
+}
+declare function TimelineTrack({ height }: TimelineTrackProps): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * timelineSource
+ *
+ * Line-level markdown rewrites for the timeline editor: set a block's
+ * `duration` on its heading's Pandoc attribute block, and patch a media
+ * clip's `startAt` / `clipStart` / `clipEnd` / `spillover` on its `{[audio …]}`
+ * / `{[video …]}` annotation line. Both preserve everything else on the line
+ * (template annotations, ids, classes, other params) by reusing the shared
+ * tokenizers rather than regex-replacing values.
+ */
+/** Format a seconds value compactly: integers bare, else up to 2 decimals. */
+declare function formatSeconds(seconds: number): string;
+/**
+ * Set/insert a `duration` on the heading at 1-based `line`, written in the
+ * squisq-native squiggly form — `{[duration=<seconds>]}` on its own, or
+ * folded into an existing `{[template …]}` annotation. Preserves any `{#id}`,
+ * classes, and other Pandoc params, and migrates a legacy Pandoc
+ * `{duration=…}` to the squiggly form (dropping the stale Pandoc key so the
+ * two can't disagree). Returns the new full source, or null when the line
+ * isn't an ATX heading.
+ */
+declare function setBlockDurationInSource(source: string, line: number, seconds: number): string | null;
+/** A patch to a media clip; numeric values are seconds, `null` removes the key. */
+interface MediaClipPatch {
+    startAt?: number | null;
+    clipStart?: number | null;
+    clipEnd?: number | null;
+    spillover?: boolean | null;
+}
+/**
+ * Patch the `{[audio …]}` / `{[video …]}` annotation at 1-based `line`.
+ * Preserves the template name and any params not in the patch. Returns the
+ * new full source, or null when the line isn't a media annotation.
+ */
+declare function setMediaClipInSource(source: string, line: number, patch: MediaClipPatch): string | null;
 
 /**
  * fileKind
@@ -772,8 +1188,14 @@ declare function ImageViewer({ src, alt, className, theme }: ImageViewerProps):
  * Syncs changes back to EditorContext on every keystroke (debounced).
  */
 interface RawEditorProps {
-    /** Monaco editor theme (default: 'vs-dark') */
-    theme?: string;
+    /**
+     * Monaco editor theme name (default: `'vs'`). Accepts Monaco's built-in
+     * theme ids (`'vs'`, `'vs-dark'`, `'hc-black'`) — which are transparently
+     * mapped to the Squisq-tinted variants — or any custom theme registered
+     * via `monaco.editor.defineTheme`. This is the *code editor* color
+     * theme, distinct from the shell's light/dark `colorScheme`.
+     */
+    monacoTheme?: string;
     /** Show minimap (default: false) */
     minimap?: boolean;
     /** Font size in pixels (default: 14) */
@@ -794,7 +1216,7 @@ interface RawEditorProps {
  * Raw markdown editor using Monaco Editor.
  * Binds to the shared EditorContext for source synchronization.
  */
-declare function RawEditor({ theme, minimap, fontSize, wordWrap, className, submitOnEnter, readOnly, }: RawEditorProps): react_jsx_runtime.JSX.Element;
+declare function RawEditor({ monacoTheme, minimap, fontSize, wordWrap, className, submitOnEnter, readOnly, }: RawEditorProps): react_jsx_runtime.JSX.Element;
 
 /**
  * WysiwygEditor
@@ -994,16 +1416,6 @@ interface DocumentSettingsDialogProps {
 }
 declare function DocumentSettingsDialog({ markdownSource, onSave, onClose, }: DocumentSettingsDialogProps): react_jsx_runtime.JSX.Element;
 
-/**
- * ThemePicker
- *
- * Custom theme dropdown that replaces a plain `<select>` with a popover
- * showing each theme as a card: the theme name rendered in the theme's
- * own background / foreground / title font, plus three color swatches
- * (primary, secondary, highlight). Used by both the play-mode preview
- * toolbar and the Document Settings dialog so authors see a
- * preview-on-hover style listing rather than a wall of names.
- */
 interface ThemePickerProps {
     /** Currently selected theme id. Empty string represents "default". */
     value: string;
@@ -1024,9 +1436,100 @@ interface ThemePickerProps {
     variant?: 'compact' | 'full';
     /** Accessible label, e.g. "Theme". */
     ariaLabel?: string;
+    /**
+     * User-authored themes to list in a "Custom" group (doc + library, from
+     * `useCustomThemes().allThemes`). When omitted, only built-ins show — so
+     * the base-theme picker and other embeds stay built-ins only.
+     */
+    customThemes?: Theme[];
+    /** When provided, renders a "+ Create custom theme" row that calls this. */
+    onCreateCustom?: () => void;
+    /** Per-custom-card edit affordance (opens the designer for that theme). */
+    onEditCustom?: (id: string) => void;
+    /** Per-custom-card delete affordance. */
+    onDeleteCustom?: (id: string) => void;
+}
+declare function ThemePicker({ value, onChange, includeDefault, variant, ariaLabel, customThemes, onCreateCustom, onEditCustom, onDeleteCustom, }: ThemePickerProps): react_jsx_runtime.JSX.Element;
+
+interface CustomThemeContextValue {
+    /** Themes inlined into the current doc's frontmatter. */
+    docThemes: Theme[];
+    /** Themes the user has saved to their browser-local library. */
+    libraryThemes: Theme[];
+    /**
+     * Convenience: the union of doc + library, with library entries skipped
+     * when a doc theme of the same id already exists. Used by the picker so a
+     * single "Custom" section covers both sources without duplicates.
+     */
+    allThemes: Theme[];
+    /**
+     * Persist a theme into the current doc. Replaces any existing entry with
+     * the same `id`. Triggers the host's `onDocThemesChange` so the doc's
+     * frontmatter ends up updated.
+     */
+    upsertDocTheme: (theme: Theme) => void;
+    /** Persist a theme into the user's library (replaces by id). */
+    upsertLibraryTheme: (theme: Theme) => void;
+    /** Remove a doc-level theme by id. */
+    removeDocTheme: (id: string) => void;
+    /** Remove a library theme by id. */
+    removeLibraryTheme: (id: string) => void;
+    /**
+     * Apply a theme to the current doc. If the theme is already in the doc,
+     * this is a no-op. If it's only in the library, it's copied into the doc
+     * so SSR / export work. Returns the resolved definition so callers can
+     * also write the `squisq-theme` selection.
+     */
+    applyTheme: (theme: Theme) => Theme;
+}
+interface CustomThemeProviderProps {
+    /** The current doc's custom themes (from `Doc.customThemes`). */
+    docThemes: Theme[];
+    /**
+     * Callback the host uses to persist a new doc-theme list back into the doc
+     * (e.g. by writing the encoded payload into the markdown's
+     * `squisq-custom-themes` frontmatter key).
+     */
+    onDocThemesChange: (next: Theme[]) => void;
+    children: ReactNode;
 }
-declare function ThemePicker({ value, onChange, includeDefault, variant, ariaLabel, }: ThemePickerProps): react_jsx_runtime.JSX.Element;
+declare function CustomThemeProvider({ docThemes, onDocThemesChange, children, }: CustomThemeProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook returning the current context. Returns null when no provider is
+ * mounted — callers can degrade to "no custom themes" rather than throwing,
+ * since the feature is optional.
+ */
+declare function useCustomThemes(): CustomThemeContextValue | null;
 
+/**
+ * useDocCustomThemes — read + persist the active doc's custom themes (the
+ * list inlined into the doc's frontmatter under `squisq-custom-themes`).
+ *
+ * The theme analog of `useDocCustomTemplates`. Both the CustomThemeProvider
+ * and any manager surface need the same two things: the current
+ * `Doc.customThemes` array and a way to write a new list back into the
+ * markdown source. Centralizing the frontmatter encoding here keeps call
+ * sites from drifting.
+ */
+
+interface DocCustomThemes {
+    /** Custom themes inlined in the active doc's frontmatter. */
+    docThemes: Theme[];
+    /**
+     * Persist a new custom-themes list back into the markdown source's
+     * frontmatter so the doc round-trips through save/load. The whole list is
+     * encoded as a single compact JSON string per the flat YAML frontmatter
+     * parser's constraint.
+     */
+    onDocThemesChange: (next: Theme[]) => void;
+}
+declare function useDocCustomThemes(): DocCustomThemes;
+
+/** Where a saved theme lands — mirrors `DesignerSaveTarget` for templates. */
+type ThemeSaveTarget = 'doc' | 'library';
+
+/** Caption selection: off, or one of the two enabled styles. */
+type CaptionMode = 'off' | CaptionStyle;
 interface PreviewSettings {
     activePreset: ViewportPreset;
     setSelectedPreset: (preset: ViewportPreset | null) => void;
@@ -1038,8 +1541,30 @@ interface PreviewSettings {
     activeTheme: Theme;
     activeTransformStyle: string;
     setSelectedTransformStyle: (id: string | null) => void;
+    /** The caption style used when captions are enabled. */
     activeCaptionStyle: CaptionStyle;
-    setSelectedCaptionStyle: (style: CaptionStyle | null) => void;
+    /** Whether captions are shown at all (the 'off' arm of the tri-state). */
+    activeCaptionsEnabled: boolean;
+    /** Set the caption mode: 'off' hides captions, 'standard'/'social' enable
+     *  that style. The single entry point so the toggle buttons persist in one
+     *  frontmatter write. */
+    setCaptionMode: (mode: CaptionMode) => void;
+    /** User-authored themes (doc + browser library) for the picker's "Custom" group. */
+    customThemes: Theme[];
+    /** Open the custom-theme designer for a theme (or null to create a new one). */
+    openThemeDesigner: (theme: Theme | null) => void;
+    /** Remove a custom theme from the doc and the library. */
+    deleteCustomTheme: (id: string) => void;
+    /** Config for the docked theme designer, or null when closed. Rendered by
+     *  `<ThemeDesignerDock>` in the editor's content row. */
+    themeDesigner: ThemeDesignerConfig | null;
+}
+/** Everything `<ThemeDesignerDock>` needs to render the designer pane. */
+interface ThemeDesignerConfig {
+    value: Theme | null;
+    onChange: (theme: Theme) => void;
+    onSave: (theme: Theme, target: ThemeSaveTarget) => void;
+    onClose: () => void;
 }
 declare function usePreviewSettings(): PreviewSettings;
 interface PreviewSettingsProviderProps {
@@ -1056,9 +1581,31 @@ interface PreviewSettingsProviderProps {
 declare function PreviewSettingsProvider({ doc, children, themeOverride, }: PreviewSettingsProviderProps): react_jsx_runtime.JSX.Element;
 /**
  * Inline preview controls rendered in the main toolbar row.
- * On narrow viewports, collapses into a single settings button with a dropdown.
+ *
+ * Collapse is *progressive* (a priority-plus pattern): rather than switch the
+ * whole row in and out at a fixed window-width breakpoint, the controls
+ * measure how many of them actually fit in the width the toolbar gives them
+ * and keep that many inline, folding the rest — from the low-priority end of
+ * {@link CONTROL_KEYS} — into a single settings (gear) button's popover. As
+ * the toolbar widens or narrows, controls migrate one at a time between the
+ * inline row and the menu, so the available space is always well used and the
+ * row never wraps onto a second line.
  */
 declare function PreviewToolbarControls(): react_jsx_runtime.JSX.Element;
+/**
+ * Segmented display-mode switch (Video / Slideshow / Document / Page) rendered
+ * as four connected buttons on the left of the Play toolbar — the prominent,
+ * one-click counterpart to the old "Mode:" dropdown. Reads and writes the same
+ * `activeDisplayMode` in preview settings.
+ */
+declare function PreviewModeSwitch(): react_jsx_runtime.JSX.Element;
+/**
+ * Segmented aspect-ratio switch (16:9 / 1:1 / 9:16 / 4:3) rendered as connected
+ * icon buttons on the left of the Play toolbar, next to the mode switch — the
+ * one-click counterpart to the old "Format:" dropdown. Reads and writes the
+ * same `activePreset` in preview settings.
+ */
+declare function PreviewFormatSwitch(): react_jsx_runtime.JSX.Element;
 
 /**
  * ViewSwitcher
@@ -1083,6 +1630,10 @@ interface ToolbarProps {
     onToggleFiles?: () => void;
     /** Content rendered at the left edge of the toolbar, before the view tabs. */
     slotLeft?: ReactNode;
+    /** Content rendered immediately after the view tabs, on the left side of the
+     *  toolbar (before the formatting controls). Used for the preview mode
+     *  switch in Play view. */
+    slotAfterTabs?: ReactNode;
     /** Content rendered after the formatting controls (in the middle area). */
     slotAfterActions?: ReactNode;
     /** Content rendered at the rightmost end of the toolbar, after all other elements. */
@@ -1099,7 +1650,7 @@ interface ToolbarProps {
  * - WYSIWYG: calls Tiptap chain commands (toggleBold, etc.)
  * - Raw: appends markdown syntax to the source
  */
-declare function Toolbar({ className, showFiles, onToggleFiles, slotLeft, slotAfterActions, slotRight, showPlayTab, }: ToolbarProps): react_jsx_runtime.JSX.Element;
+declare function Toolbar({ className, showFiles, onToggleFiles, slotLeft, slotAfterTabs, slotAfterActions, slotRight, showPlayTab, }: ToolbarProps): react_jsx_runtime.JSX.Element;
 
 /**
  * VersionHistoryPanel
@@ -1128,17 +1679,12 @@ declare function VersionHistoryPanel(): react_jsx_runtime.JSX.Element | null;
  */
 declare function ViewMenuPanel(): react_jsx_runtime.JSX.Element;
 
-/**
- * OutlinePanel
- *
- * Left-side companion to the InlinePreviewGutter. Renders a hierarchical
- * tree of the document's headings (h1 → h2 → h3 …) so the structure is
- * graspable at a glance and the user can jump to any section. Works in
- * BOTH the WYSIWYG and Markdown editor views — view-specific positioning
- * lives in `useHeadingLayout`.
- */
 interface OutlinePanelProps {
-    /** Width of the pane in pixels (default: 240). */
+    /**
+     * Fixed width of the pane in pixels. When omitted, the pane sizes
+     * responsively from `--squisq-outline-width` (falling back to
+     * {@link OUTLINE_RESPONSIVE_WIDTH}) so it stretches on wider screens.
+     */
     width?: number;
     /** Optional CSS class for the outer container. */
     className?: string;
@@ -1164,7 +1710,7 @@ declare function ThemeCustomizerPanel({ value, onChange, onSave, onReset, }: The
  * so existing documents keep showing a friendly label without first
  * normalizing their annotations.
  */
-declare function templateLabel(name: string): string;
+declare function templateLabel(name: string, customTemplates?: readonly CustomTemplateDefinition[]): string;
 interface TemplatePickerProps {
     value: string;
     onChange: (name: string) => void;
@@ -1176,8 +1722,192 @@ interface TemplatePickerProps {
      * single ungrouped grid (legacy behavior).
      */
     recommended?: readonly string[];
+    /**
+     * Optional callback fired when the user clicks the "+ New custom
+     * template" card pinned at the top of the gallery. The host wires this
+     * to open the modal `TemplateDesigner`. When omitted, the card is
+     * hidden.
+     */
+    onOpenDesigner?: () => void;
+}
+declare function TemplatePicker({ value, onChange, compact, recommended, onOpenDesigner, }: TemplatePickerProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * headingTransition
+ *
+ * Read and write a block's transition (`transition` / `transitionDirection` /
+ * `transitionDuration`) on a heading, in both editing surfaces:
+ *
+ * - Markdown (Monaco): operate on the raw heading line string.
+ * - WYSIWYG (Tiptap): operate on the heading node's `dataBlockAttrs` string
+ *   (the inner of the Pandoc `{…}` block, no braces — matching how
+ *   `tiptapBridge` stores and re-emits it).
+ *
+ * Transitions are stored in the Pandoc `{#id .class key=value}` attribute
+ * block, NOT the `{[template …]}` annotation. That mirrors the canonical
+ * serializer (`core/doc/docToMarkdown.ts` → `ensureTransitionAttributes`,
+ * which always emits the `{…}` form) and `diagram/diagramCommands.ts`, so a
+ * value set here round-trips through a Doc render without being duplicated
+ * or moved. Reads still look at the `{[…]}` params too, so a hand-typed
+ * `{[title transition=fade]}` shows up in the picker.
+ *
+ * All the brace-matching / tokenizing / serializing is delegated to the
+ * shared core helpers so this stays in lockstep with the parser by import
+ * rather than by copied regexes.
+ */
+/** Raw (un-coerced) transition attribute values for one block. */
+interface TransitionFields {
+    /** `transition` value. Empty string means "none" (`cut`). */
+    type: string;
+    /** `transitionDirection` value, or '' when unset. */
+    direction: string;
+    /** `transitionDuration` value (raw, e.g. `0.7` or `700ms`), or '' when unset. */
+    duration: string;
+}
+declare const EMPTY_TRANSITION: TransitionFields;
+/**
+ * Read the transition fields off a heading line. Looks in both the Pandoc
+ * `{…}` block (canonical) and the `{[…]}` template params (hand-typed),
+ * with the Pandoc block taking precedence. Returns the empty transition for
+ * non-heading lines.
+ */
+declare function readHeadingLineTransition(line: string): TransitionFields;
+/**
+ * Return `line` with its transition rewritten from `next`, writing into the
+ * Pandoc `{…}` block and leaving the `{[…]}` template annotation untouched.
+ * Non-heading lines are returned unchanged.
+ */
+declare function setHeadingLineTransition(line: string, next: TransitionFields): string;
+/**
+ * Read the transition fields from a heading node's `dataBlockAttrs` (Pandoc
+ * inner) plus `dataTemplateParams` (the `{[…]}` params). Pandoc wins.
+ */
+declare function readBlockAttrsTransition(blockAttrsInner: string | null | undefined, templateParams: string | null | undefined): TransitionFields;
+/**
+ * Rewrite the transition in a heading node's `dataBlockAttrs` inner string.
+ * Returns the new inner (no braces), or null when the block carries no
+ * attributes at all — matching how `tiptapBridge` stores `dataBlockAttrs`
+ * (absent attribute → null, not `{}`).
+ */
+declare function setBlockAttrsTransition(blockAttrsInner: string | null | undefined, next: TransitionFields): string | null;
+
+interface TransitionPickerProps {
+    value: TransitionFields;
+    onChange: (next: TransitionFields) => void;
 }
-declare function TemplatePicker({ value, onChange, compact, recommended }: TemplatePickerProps): react_jsx_runtime.JSX.Element;
+declare function TransitionPicker({ value, onChange }: TransitionPickerProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * transitionCatalog
+ *
+ * Editor-facing, curated presentation of the block transition vocabulary.
+ *
+ * Core's `TRANSITION_TYPES` (packages/core/src/schemas/Transitions.ts) lists
+ * ~80 names, including legacy aliases and near-duplicate spellings. This
+ * catalog hand-picks the distinct, useful transitions, gives each a friendly
+ * label, and groups them for the toolbar's transition flyout — the same
+ * "core holds the truth, the editor holds the presentation" split the block
+ * `TemplatePicker` uses.
+ *
+ * Every `value` here MUST be a real `TransitionType`; `transitionCatalog.test.ts`
+ * enforces that so a renamed/removed core transition fails the build instead
+ * of silently producing an invalid `transition=` annotation. The catalog is
+ * intentionally NOT exhaustive — aliases and redundant spellings are omitted.
+ */
+/**
+ * How a transition takes a direction, driving which direction sub-control
+ * the picker shows. Mirrors core's `getTransitionVisualClass` dispatch:
+ * - `lrud`: left / right / up / down (push, wipe, cover, uncover, reveal, pan)
+ * - `axis`: horizontal / vertical (split, blinds)
+ * Entries without a model take no `transitionDirection`.
+ */
+type DirectionModel = 'lrud' | 'axis';
+interface TransitionCatalogEntry {
+    /** Canonical `transition=` value — must be a core `TransitionType`. */
+    value: string;
+    /** Friendly label shown in the flyout and trigger. */
+    label: string;
+    /** Direction model, when the transition is directional. */
+    direction?: DirectionModel;
+}
+interface TransitionGroup {
+    title: string;
+    entries: TransitionCatalogEntry[];
+}
+declare const TRANSITION_GROUPS: readonly TransitionGroup[];
+/** Flat list of every catalog entry, in group order. */
+declare const TRANSITION_ENTRIES: readonly TransitionCatalogEntry[];
+/** Look up a catalog entry by its `transition=` value. */
+declare function findTransitionEntry(value: string): TransitionCatalogEntry | undefined;
+/**
+ * Human label for a transition value. Returns 'None' for the empty value and
+ * falls back to a camelCase-humanized form for any valid-but-uncurated type
+ * (e.g. a hand-typed alias) so the trigger still reads sensibly.
+ */
+declare function transitionLabel(value: string): string;
+
+/**
+ * blockProperties
+ *
+ * Generic read/write of a single block-meta key on a heading's Pandoc `{…}`
+ * attribute block (stored as the `dataBlockAttrs` inner string in the WYSIWYG
+ * heading node — no braces, matching `tiptapBridge`).
+ *
+ * The transition family (which spans three coupled keys) has its own helpers
+ * in `headingTransition.ts`; this module covers the standalone scalar keys the
+ * block-properties palette edits — `duration`, `startTime`, `x`, `y`, … — all
+ * of which are plain `key=value` params. Parse/serialize is delegated to the
+ * shared core helpers so quoting and ordering match the parser exactly.
+ */
+/** Parse a `dataBlockAttrs` inner string into its flat `key → value` map. */
+declare function readBlockAttrsParams(inner: string | null | undefined): Record<string, string>;
+/** Read a single block-meta param, or '' when unset. */
+declare function readBlockAttrsValue(inner: string | null | undefined, key: string): string;
+/**
+ * Set (or, when `value` is empty, remove) a single param in a `dataBlockAttrs`
+ * inner string. Returns the new inner (no braces), or null when the block is
+ * left with no attributes at all — matching how `tiptapBridge` stores an
+ * absent attribute (null, not `{}`).
+ */
+declare function setBlockAttrsValue(inner: string | null | undefined, key: string, value: string): string | null;
+/**
+ * A concise, human-readable summary of a block's authored properties for the
+ * on-canvas badge — e.g. `Doors · 1:30 start · 3:20 long`. Returns '' when no
+ * properties are set (the badge then shows just its icon). Reads transition
+ * from both the Pandoc block and the `{[…]}` params; timing from the block.
+ */
+declare function summarizeBlockProps(blockAttrs: string | null | undefined, templateParams: string | null | undefined): string;
+
+/**
+ * BlockPropertiesPopover
+ *
+ * The on-canvas "block properties" palette — the sibling of the block-template
+ * badge. Anchored at the `.squisq-props-badge` chip on a heading, it edits the
+ * block's playback/animation metadata, all stored in the heading's Pandoc `{…}`
+ * attribute block (`dataBlockAttrs`):
+ *
+ *   - Transition  (type / direction / duration) — reuses `TransitionPicker`
+ *   - Duration    (`duration`)  — how long the block is shown
+ *   - Start time  (`startTime`) — timeline position
+ *
+ * The popover holds the `dataBlockAttrs` inner string as working state and
+ * re-derives each control from it, so successive edits compose. Every change
+ * serializes a new inner and bubbles up through `onChange`; the host applies it
+ * to the heading node. Positioning/portal/outside-click mirror
+ * `TemplateBadgePopover`.
+ */
+interface BlockPropertiesPopoverProps {
+    /** DOMRect of the badge that triggered the popover (viewport coords). */
+    anchorRect: DOMRect;
+    /** Current `dataBlockAttrs` inner (Pandoc), or null when unset. */
+    blockAttrs: string | null;
+    /** `dataTemplateParams`, so a hand-typed `{[… transition=]}` reads through. */
+    templateParams: string | null;
+    /** Apply a new `dataBlockAttrs` inner to the heading (null clears it). */
+    onChange: (nextInner: string | null) => void;
+    onClose: () => void;
+}
+declare function BlockPropertiesPopover({ anchorRect, blockAttrs, templateParams, onChange, onClose, }: BlockPropertiesPopoverProps): react.ReactPortal;
 
 interface InlinePreviewGutterProps {
     /** Width of the gutter in pixels (default: 320). */
@@ -1355,6 +2085,155 @@ declare function processTextFile(file: File): Promise<string>;
  */
 declare function processTextFiles(files: File[]): Promise<string>;
 
+/**
+ * useMonacoLoader
+ *
+ * Idempotently dynamic-imports `monaco-editor` and points the
+ * `@monaco-editor/react` singleton loader at the bundled copy. Replaces
+ * the historical top-of-module `import * as monaco from 'monaco-editor';
+ * loader.config({ monaco })` pattern, which forced every consumer of
+ * `@bendyline/squisq-editor-react` — including ones that only import
+ * `JsonEditor` or a type — to drag in monaco's ~9MB worth of language
+ * services and workers at module evaluation time.
+ *
+ * Hosts that want the smallest possible bundle can keep aliasing
+ * `monaco-editor` to a slim entry as before; the behavior is identical
+ * once the dynamic import settles.
+ *
+ * The promise is cached at module scope so the first subscriber
+ * anywhere in the app pays the import cost and every later subscriber
+ * reuses the same settled value.
+ */
+interface UseMonacoLoaderResult {
+    /** The monaco namespace once loaded, or `null` while the import is in flight. */
+    monaco: typeof monaco_editor | null;
+    /** Flips to `true` after the import settles. Gate `<Editor>` / `<DiffEditor>` renders on this. */
+    ready: boolean;
+}
+/**
+ * Subscribe to the lazy-loaded monaco namespace. The first caller
+ * triggers `import('monaco-editor')` and configures the
+ * `@monaco-editor/react` loader; subsequent callers receive the same
+ * cached value.
+ */
+declare function useMonacoLoader(): UseMonacoLoaderResult;
+
+interface CustomTemplateContextValue {
+    /** Templates inlined into the current doc's frontmatter. */
+    docTemplates: CustomTemplateDefinition[];
+    /** Templates the user has saved to their browser-local library. */
+    libraryTemplates: CustomTemplateDefinition[];
+    /**
+     * Convenience: the union of doc + library, with library entries
+     * skipped when a doc template of the same name already exists.
+     * Used by the picker so a single "Custom" section covers both
+     * sources without duplicates.
+     */
+    allTemplates: CustomTemplateDefinition[];
+    /**
+     * Persist a template into the current doc. Replaces any existing
+     * entry with the same `name`. Triggers the host's
+     * `onDocTemplatesChange` so the doc's frontmatter ends up updated.
+     */
+    upsertDocTemplate: (def: CustomTemplateDefinition) => void;
+    /** Persist a template into the user's library (replaces by name). */
+    upsertLibraryTemplate: (def: CustomTemplateDefinition) => void;
+    /** Remove a doc-level template by name. */
+    removeDocTemplate: (name: string) => void;
+    /** Remove a library template by name. */
+    removeLibraryTemplate: (name: string) => void;
+    /**
+     * Apply a template to the current doc. If the template is already in
+     * the doc, this is a no-op. If it's only in the library, it's
+     * copied into the doc so SSR / export work. Returns the resolved
+     * definition so callers can also write the heading annotation.
+     */
+    applyTemplate: (def: CustomTemplateDefinition) => CustomTemplateDefinition;
+}
+interface CustomTemplateProviderProps {
+    /** The current doc's custom templates (from `Doc.customTemplates`). */
+    docTemplates: CustomTemplateDefinition[];
+    /**
+     * Callback the host uses to persist a new doc-template list back
+     * into the doc (e.g. by writing the encoded payload into the
+     * markdown's `squisq-custom-templates` frontmatter key).
+     */
+    onDocTemplatesChange: (next: CustomTemplateDefinition[]) => void;
+    children: ReactNode;
+}
+declare function CustomTemplateProvider({ docTemplates, onDocTemplatesChange, children, }: CustomTemplateProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook returning the current context. Returns null when no provider is
+ * mounted — callers can degrade to "no custom templates" rather than
+ * throwing, since the feature is optional.
+ */
+declare function useCustomTemplates(): CustomTemplateContextValue | null;
+
+/**
+ * useDocCustomTemplates — read + persist the active doc's custom
+ * templates (the list inlined into the doc's frontmatter under
+ * `squisq-custom-templates`).
+ *
+ * Both the WYSIWYG editor and the standalone Custom Layout Manager need
+ * the same two things: the current `Doc.customTemplates` array and a way
+ * to write a new list back into the markdown source. Centralizing the
+ * frontmatter encoding here keeps the two call sites from drifting.
+ */
+
+interface DocCustomTemplates {
+    /** Custom templates inlined in the active doc's frontmatter. */
+    docTemplates: CustomTemplateDefinition[];
+    /**
+     * Persist a new custom-templates list back into the markdown source's
+     * frontmatter so the doc round-trips through save/load. The whole list
+     * is encoded as a single base64-JSON string per the flat YAML
+     * frontmatter parser's constraint.
+     */
+    onDocTemplatesChange: (next: CustomTemplateDefinition[]) => void;
+}
+declare function useDocCustomTemplates(): DocCustomTemplates;
+
+/**
+ * Read diagram nodes + edges from the live Tiptap state.
+ *
+ * For a given parent heading position, walks the diagram section's child
+ * headings, builds synthetic `Block` objects from their text + Pandoc
+ * attributes, runs `computeDiagramLayout` from core to fill in missing
+ * positions, and returns the result in the shape React Flow consumes.
+ *
+ * The hook re-derives on every editor transaction — no caching layer
+ * means there's nothing to invalidate when the user types or the markdown
+ * is reloaded from disk.
+ */
+
+interface DiagramRFNode {
+    id: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    data: {
+        label: string;
+    };
+    type?: string;
+    /** Per-node width override (from the heading's `w=` Pandoc param). */
+    width?: number;
+    /** Per-node height override (from the heading's `h=` Pandoc param). */
+    height?: number;
+}
+interface DiagramRFEdge {
+    id: string;
+    source: string;
+    target: string;
+    label?: string;
+}
+interface DiagramData {
+    nodes: DiagramRFNode[];
+    edges: DiagramRFEdge[];
+    warnings: string[];
+}
+declare function useDiagramData(editor: Editor$1, parentPos: number): DiagramData;
+
 /**
  * Tiptap Bridge
  *
@@ -1421,6 +2300,172 @@ declare function buildPreviewDoc(doc: Doc): Doc;
  */
 declare const HeadingWithTemplate: _tiptap_core.Node<_tiptap_extension_heading.HeadingOptions, any>;
 
+/**
+ * DiagramExtension — Tiptap/ProseMirror plugin that:
+ *
+ * 1. Mounts a React-Flow canvas (`DiagramWidget`) immediately after every
+ *    heading whose `dataTemplate === 'diagram'`.
+ * 2. Hides the direct sub-headings of each diagram parent (until the next
+ *    equal-or-shallower heading) by tagging them with a `data-squisq-diagram-child`
+ *    attribute — CSS in `styles/diagram.css` does the actual hiding.
+ *
+ * Widgets are rendered as plain DOM nodes attached to a ProseMirror
+ * `Decoration.widget`. React is mounted into the widget DOM with
+ * `react-dom/client`'s `createRoot`, and unmounted on the widget's
+ * `destroy` hook.
+ */
+
+interface DiagramExtensionOptions {
+    /** When false, the extension is inert (no widgets, no decorations). */
+    enabled?: boolean;
+}
+declare const DiagramExtension: Extension<DiagramExtensionOptions, any>;
+
+type DiagramCommand = {
+    kind: 'moveNode';
+    nodeId: string;
+    x: number;
+    y: number;
+} | {
+    kind: 'resizeNode';
+    nodeId: string;
+    width: number;
+    height: number;
+} | {
+    kind: 'addConnection';
+    source: string;
+    target: string;
+    type?: string;
+} | {
+    kind: 'removeConnection';
+    source: string;
+    target: string;
+    type?: string;
+} | {
+    kind: 'renameNode';
+    nodeId: string;
+    newLabel: string;
+} | {
+    kind: 'addNode';
+    x: number;
+    y: number;
+} | {
+    kind: 'removeNode';
+    nodeId: string;
+};
+interface DiagramCanvasProps {
+    nodes: DiagramRFNode[];
+    edges: DiagramRFEdge[];
+    onCommand: (cmd: DiagramCommand) => void;
+    /** When true, render the maximize button. Click toggles `onToggleMaximize`. */
+    showMaximize?: boolean;
+    /** Whether the canvas is currently maximized (affects button icon). */
+    maximized?: boolean;
+    /** Callback when the maximize button is clicked. */
+    onToggleMaximize?: () => void;
+    /**
+     * Active tool id, controlled by the host (DiagramWidget) so the tool
+     * buttons can live in the shared toolbar above the canvas. Falls back
+     * to internal state when omitted.
+     */
+    activeToolId?: string;
+    onActiveToolIdChange?: (id: string) => void;
+    /** Forwarded to the Scene so the host can drive a Delete action. */
+    onSelectionChange?: (ids: ReadonlySet<string>) => void;
+}
+declare function DiagramCanvas({ nodes: incomingNodes, edges: incomingEdges, onCommand, showMaximize, maximized, onToggleMaximize, activeToolId: controlledToolId, onActiveToolIdChange, onSelectionChange, }: DiagramCanvasProps): react_jsx_runtime.JSX.Element;
+
+interface DiagramWidgetProps {
+    editor: Editor$1;
+    /** Stable id derived from the parent heading (slug / `#id`). */
+    headingKey: string;
+    /** Position of the parent heading at widget-creation time. Used as a
+     * fallback when the dynamic lookup fails (e.g. before the first
+     * transaction). */
+    fallbackParentPos: number;
+    /** Host element used for portal targeting by the maximize overlay. */
+    host?: HTMLElement | null;
+}
+declare function DiagramWidget({ editor, headingKey, fallbackParentPos, host }: DiagramWidgetProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Tiptap commands for diagram editing.
+ *
+ * Each command finds the relevant heading inside a diagram section (parent
+ * heading + its direct sub-headings until the next equal-or-shallower
+ * heading) and mutates either its `data-block-attrs` attribute or its
+ * text content. All edits flow back into markdown via the existing
+ * `tiptapBridge` round-trip — no parallel data store.
+ */
+
+interface HeadingLocation {
+    /** Node start position in the doc (absolute). */
+    pos: number;
+    /** The heading PMNode. */
+    node: Node;
+    /** Parsed attributes derived from the heading's `data-block-attrs` (always defined). */
+    attrs: HeadingAttributes;
+    /** Computed id: explicit `#id` if set, otherwise the slugified heading text. */
+    id: string;
+}
+/**
+ * Find the diagram section that starts at `parentPos` (the position of the
+ * parent heading with `dataTemplate === 'diagram'`). Returns the headings
+ * that should appear as diagram nodes — defined as every heading at the
+ * **shallowest** depth greater than the parent within the section, until
+ * the next equal-or-shallower heading.
+ *
+ * Using the shallowest deeper depth (rather than a strict parentDepth + 1)
+ * mirrors `markdownToDoc`'s stack behavior: when authors skip a level
+ * (e.g. `# parent` + `### child`), those `###` headings are still treated
+ * as direct children of the `#` parent. Any headings deeper than the
+ * detected child depth are sub-sections of a node and are not surfaced as
+ * separate diagram nodes.
+ */
+declare function listDiagramChildren(editor: Editor$1, parentPos: number): HeadingLocation[];
+/**
+ * Update a node's `x` / `y` attributes from a drag.
+ *
+ * Before writing the moved node, this also "freezes" any siblings that
+ * lack an explicit position by snapshotting their currently-displayed
+ * (auto-laid) coordinates. Without that, `computeDiagramLayout`'s grid
+ * auto-placement is relative to the bounding box of pinned nodes — so
+ * dragging one node would pull every unpinned sibling along behind it.
+ * Freezing converts the implicit layout into explicit per-node
+ * positions on the first interaction, after which each node moves
+ * independently.
+ */
+declare function moveNode(editor: Editor$1, parentPos: number, nodeId: string, x: number, y: number): boolean;
+/**
+ * Add a connection from `sourceId` to `targetId` (optionally typed). No-op
+ * if the same connection already exists.
+ */
+declare function addConnection(editor: Editor$1, parentPos: number, sourceId: string, targetId: string, type?: string): boolean;
+/**
+ * Remove a connection from `sourceId` to `targetId`. If `type` is provided,
+ * only the matching-typed entry is removed; otherwise the first match
+ * (regardless of type) is removed.
+ */
+declare function removeConnection(editor: Editor$1, parentPos: number, sourceId: string, targetId: string, type?: string): boolean;
+/**
+ * Replace a heading's text content (used when the user renames a node
+ * via a double-click in the canvas).
+ */
+declare function renameNode(editor: Editor$1, parentPos: number, nodeId: string, newText: string): boolean;
+/**
+ * Insert a new heading node at the end of the diagram section. The new
+ * heading carries `data-block-attrs` with the supplied id and position,
+ * so the freshly-inserted node appears in React Flow at the expected
+ * coordinates.
+ */
+declare function addNode(editor: Editor$1, parentPos: number, id: string, label: string, x: number, y: number): boolean;
+/**
+ * Remove a child node's heading (and any body content under it up to the
+ * next heading). Also strips inbound `connectsTo` references on remaining
+ * siblings so the diagram doesn't carry dangling targets.
+ */
+declare function removeNode(editor: Editor$1, parentPos: number, nodeId: string): boolean;
+
 interface JsonEditorProps {
     /** Schema describing the value's shape (with optional `squisq` hints). */
     schema: SquisqAnnotatedSchema;
@@ -1511,8 +2556,8 @@ type RecorderSource = 'mic' | 'camera' | 'screen' | 'screen+mic';
 /** Discriminated state describing what the recorder is currently doing. */
 type RecorderState = 'idle' | 'requesting' | 'ready' | 'recording' | 'stopping' | 'stopped' | 'error';
 interface UseMediaRecorderOptions {
-    /** Which capture pipeline to use. */
-    source: RecorderSource;
+    /** 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),
@@ -1535,6 +2580,13 @@ interface UseMediaRecorderOptions {
      * only); when unsupported the resulting stream simply omits it.
      */
     systemAudio?: boolean;
+    /**
+     * For `source === 'camera'`, whether to include the microphone track.
+     * Defaults to `true` (camera + mic). Set `false` to capture silent
+     * video. Ignored for other sources, whose mic handling is encoded in
+     * the source itself (`'mic'`, `'screen+mic'`).
+     */
+    includeMicrophone?: boolean;
 }
 interface UseMediaRecorderResult {
     /** Current recorder state. */
@@ -1582,7 +2634,7 @@ interface UseMediaRecorderResult {
  * (e.g. headless tests) can resolve a format up front.
  */
 declare function getCaptureKind(source: RecorderSource): CaptureKind;
-declare function useMediaRecorder(options: UseMediaRecorderOptions): UseMediaRecorderResult;
+declare function useMediaRecorder(options?: UseMediaRecorderOptions): UseMediaRecorderResult;
 
 interface RecorderModalProps {
     /** Required — recordings are written here. */
@@ -1876,16 +2928,17 @@ declare function ImageEditor(props: ImageEditorProps): react_jsx_runtime.JSX.Ele
  * version manager) lives in `useImageEditor.ts`.
  */
 
+type DOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
 /**
  * Layer payload accepted by the `add-layer` action — the `id` field is
  * optional and will be assigned by the underlying `addLayer` helper if
  * the caller doesn't supply one.
  */
-type ImageEditLayerInput = ImageEditLayer | (Omit<ImageEditLayer, 'id'> & {
+type ImageEditLayerInput = ImageEditLayer | (DOmit<ImageEditLayer, 'id'> & {
     id?: string;
 });
 /** The currently active interaction tool. */
-type ImageEditorTool = 'select' | 'text' | 'shape' | 'image' | 'crop';
+type ImageEditorTool = 'select' | 'text' | 'shape' | 'image' | 'crop' | 'zoom-rect';
 /** A pixel-space rectangle in canvas coordinates. */
 interface CanvasRect {
     x: number;
@@ -1900,6 +2953,12 @@ interface ImageEditorState {
     selectedLayerId: string | null;
     /** Active tool. */
     tool: ImageEditorTool;
+    /**
+     * The shape kind the shape tool will drop next (a drawing palette kind,
+     * e.g. `'rectangle'`, `'diamond'`, `'arrow-right'`). Set when the user
+     * picks from the shape palette; defaults to `'rectangle'`.
+     */
+    shapeKind: string;
     /**
      * Dirty flag — true when the in-memory doc has unsaved changes
      * relative to the last `markClean()` call. The hook uses this to
@@ -1915,6 +2974,9 @@ type ImageEditorAction = {
 } | {
     type: 'set-tool';
     tool: ImageEditorTool;
+} | {
+    type: 'set-shape-kind';
+    kind: string;
 } | {
     type: 'select';
     layerId: string | null;
@@ -1995,4 +3057,4 @@ interface UseImageEditorReturn {
 }
 declare function useImageEditor(options: UseImageEditorOptions): UseImageEditorReturn;
 
-export { ALL_EMOJIS, type CameraStreamOptions, type CanvasRect, type CaptureKind, type DocumentLinkCandidate, type DocumentLinkProvider, DocumentSettingsDialog, type DocumentSettingsDialogProps, type DragContentType, type DropTarget, DropZoneOverlay, type DropZoneOverlayProps, EMOJI_CATEGORIES, type EditorActions, type EditorContextValue, type EditorMode, EditorProvider, type EditorProviderProps, EditorShell, type EditorShellProps, type EditorState, type EditorTheme, type EditorView, type EmojiCategory, type EmojiEntry, EmojiPicker, type EmojiPickerProps, type FileCategory, type FileKind, HeadingWithTemplate, type ImageDisplayMode, ImageEditor, type ImageEditorAction, type ImageEditorProps, type ImageEditorState, type ImageEditorTool, ImageViewer, type ImageViewerProps, InlinePreviewGutter, type InlinePreviewGutterProps, JsonEditor, type JsonEditorProps, MediaBin, type MediaBinProps, type MentionCandidate, type MentionProvider, OutlinePanel, type OutlinePanelProps, PlainHtmlPreview, type PlainHtmlPreviewProps, PreviewPanel, type PreviewPanelProps, type PreviewSettings, PreviewSettingsProvider, PreviewToolbarControls, RawEditor, type RawEditorProps, type RecordedBookmark, RecorderButton, type RecorderButtonProps, RecorderModal, type RecorderModalProps, RecorderPanel, type RecorderPanelProps, type RecorderSaveResult, type RecorderSource, type RecorderState, type ResolvedFormat, type ScreenStreamHandle, type ScreenStreamOptions, StatusBar, type StatusBarProps, TemplatePicker, ThemeCustomizerPanel, type ThemeCustomizerPanelProps, type ThemeInheritance, ThemePicker, type ThemePickerProps, type TimingJson, Toolbar, type ToolbarProps, TooltipLayer, type UseFileDropOptions, type UseFileDropResult, type UseImageEditorOptions, type UseImageEditorReturn, type UseMediaRecorderOptions, type UseMediaRecorderResult, VersionHistoryPanel, ViewMenuPanel, type ViewPreferences, ViewSwitcher, type ViewSwitcherProps, WysiwygEditor, type WysiwygEditorProps, buildFilename, buildPreviewDoc, buildTimingJson, classifyFile, detectLanguageFromFileName, encodeTimingJson, getCaptureKind, imageEditorReducer, initialImageEditorState, markdownToTiptap, partitionFiles, processMediaFiles, processTextFile, processTextFiles, requestCameraStream, requestMicStream, requestScreenStream, resolveFileKind, resolveFormat, searchEmojis, supportsDisplayMedia, supportsMediaRecorder, supportsUserMedia, templateLabel, timingPathFor, tiptapToMarkdown, useEditorContext, useFileDrop, useImageEditor, useMediaRecorder, usePreviewSettings, useStreamPreview };
+export { ALL_EMOJIS, BlockCardView, type BlockCardViewProps, type BlockNavigator, BlockPropertiesPopover, type BlockPropertiesPopoverProps, type BlockRange, type BlockSlice, type CameraStreamOptions, type CanvasRect, type CaptureKind, type CodeContext, type CodeContextSection, CodeContextZones, type CustomTemplateContextValue, CustomTemplateProvider, type CustomTemplateProviderProps, type CustomThemeContextValue, CustomThemeProvider, type CustomThemeProviderProps, DiagramCanvas, type DiagramCommand, type DiagramData, DiagramExtension, type DiagramRFEdge, type DiagramRFNode, DiagramWidget, type DirectionModel, type DocCustomTemplates, type DocCustomThemes, type DocumentLinkCandidate, type DocumentLinkProvider, DocumentSettingsDialog, type DocumentSettingsDialogProps, type DragContentType, type DropTarget, DropZoneOverlay, type DropZoneOverlayProps, EMOJI_CATEGORIES, EMPTY_TRANSITION, type EditorActions, type EditorColorScheme, type EditorContextValue, type EditorMode, EditorProvider, type EditorProviderProps, EditorShell, type EditorShellProps, type EditorState, type EditorView, type EmojiCategory, type EmojiEntry, EmojiPicker, type EmojiPickerProps, type FileCategory, type FileKind, type FolderEntry, FolderView, type FolderViewProps, HeadingWithTemplate, type ImageDisplayMode, ImageEditor, type ImageEditorAction, type ImageEditorProps, type ImageEditorState, type ImageEditorTool, ImageViewer, type ImageViewerProps, InlinePreviewGutter, type InlinePreviewGutterProps, JsonEditor, type JsonEditorProps, type LayoutMode, MediaBin, type MediaBinProps, type MediaClipPatch, type MentionCandidate, type MentionProvider, OutlinePanel, type OutlinePanelProps, PlainHtmlPreview, type PlainHtmlPreviewProps, PreviewFormatSwitch, PreviewModeSwitch, PreviewPanel, type PreviewPanelProps, type PreviewSettings, PreviewSettingsProvider, PreviewToolbarControls, RawEditor, type RawEditorProps, type RecordedBookmark, RecorderButton, type RecorderButtonProps, RecorderModal, type RecorderModalProps, RecorderPanel, type RecorderPanelProps, type RecorderSaveResult, type RecorderSource, type RecorderState, type ResolvedFormat, type ScreenStreamHandle, type ScreenStreamOptions, StatusBar, type StatusBarProps, TRANSITION_ENTRIES, TRANSITION_GROUPS, TemplatePicker, ThemeCustomizerPanel, type ThemeCustomizerPanelProps, type ThemeInheritance, ThemePicker, type ThemePickerProps, TimelineTrack, type TimelineTrackProps, type TimingJson, Toolbar, type ToolbarProps, TooltipLayer, type TransitionCatalogEntry, type TransitionFields, type TransitionGroup, TransitionPicker, type TransitionPickerProps, type UseBlockNavigatorOptions, type UseFileDropOptions, type UseFileDropResult, type UseImageEditorOptions, type UseImageEditorReturn, type UseMediaRecorderOptions, type UseMediaRecorderResult, type UseMonacoLoaderResult, VersionHistoryPanel, ViewMenuPanel, type ViewPreferences, ViewSwitcher, type ViewSwitcherProps, WysiwygEditor, type WysiwygEditorProps, addConnection, addNode, buildFilename, buildPreviewDoc, buildTimingJson, classifyFile, detectLanguageFromFileName, encodeTimingJson, findTransitionEntry, formatSeconds, getBlockSlices, getCaptureKind, imageEditorReducer, initialImageEditorState, lineToOffset, listDiagramChildren, markdownToTiptap, moveNode, offsetToLine, partitionFiles, processMediaFiles, processTextFile, processTextFiles, readBlockAttrsParams, readBlockAttrsTransition, readBlockAttrsValue, readHeadingLineTransition, removeConnection, removeNode, renameNode, requestCameraStream, requestMicStream, requestScreenStream, resolveFileKind, resolveFormat, searchEmojis, setBlockAttrsTransition, setBlockAttrsValue, setBlockDurationInSource, setHeadingLineTransition, setMediaClipInSource, sliceIndexAtOffset, spliceBlock, summarizeBlockProps, supportsDisplayMedia, supportsMediaRecorder, supportsUserMedia, templateLabel, timingPathFor, tiptapToMarkdown, transitionLabel, useBlockNavigator, useCustomTemplates, useCustomThemes, useDiagramData, useDocCustomTemplates, useDocCustomThemes, useEditorContext, useFileDrop, useImageEditor, useMediaRecorder, useMonacoLoader, usePreviewSettings, useStreamPreview };