@bendyline/squisq-editor-react 1.5.2 → 1.6.0

package/dist/index.d.ts

@@ -1,19 +1,46 @@
 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 { editor } from 'monaco-editor';
 import { IconFamily } from '@bendyline/squisq/icons';
 import { DisplayMode, CaptionStyle } from '@bendyline/squisq-react';
 import * as _tiptap_extension_heading from '@tiptap/extension-heading';
+import { Editor as Editor$1 } from '@tiptap/react';
+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;
 /**
@@ -64,6 +91,15 @@ interface DocumentLinkCandidate {
 type DocumentLinkProvider = (query: string) => Promise<DocumentLinkCandidate[]>;
 type EditorView = 'raw' | 'wysiwyg' | 'preview';
 type EditorTheme = '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
@@ -152,10 +188,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 */
@@ -201,6 +274,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
@@ -351,6 +432,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 +473,10 @@ 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, 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;
+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, layoutMode, viewPreferences, onViewPreferencesChange, children, }: EditorProviderProps): react_jsx_runtime.JSX.Element;
 
 interface EditorShellProps {
     /** Initial markdown content */
@@ -704,6 +793,225 @@ interface EditorShellProps {
  */
 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;
 
+/**
+ * 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
  *
@@ -994,16 +1302,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,8 +1322,23 @@ 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, }: ThemePickerProps): react_jsx_runtime.JSX.Element;
+declare function ThemePicker({ value, onChange, includeDefault, variant, ariaLabel, customThemes, onCreateCustom, onEditCustom, onDeleteCustom, }: ThemePickerProps): react_jsx_runtime.JSX.Element;
+
+/** Where a saved theme lands — mirrors `DesignerSaveTarget` for templates. */
+type ThemeSaveTarget = 'doc' | 'library';
 
 interface PreviewSettings {
     activePreset: ViewportPreset;
@@ -1040,6 +1353,22 @@ interface PreviewSettings {
     setSelectedTransformStyle: (id: string | null) => void;
     activeCaptionStyle: CaptionStyle;
     setSelectedCaptionStyle: (style: CaptionStyle | null) => 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 {
@@ -1164,7 +1493,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 +1505,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 function TemplatePicker({ value, onChange, compact, recommended }: TemplatePickerProps): react_jsx_runtime.JSX.Element;
+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 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). */
@@ -1421,6 +1934,213 @@ 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>;
+
+/**
+ * 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;
+
+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;
@@ -1535,6 +2255,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. */
@@ -1876,16 +2603,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 +2628,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 +2649,9 @@ type ImageEditorAction = {
 } | {
     type: 'set-tool';
     tool: ImageEditorTool;
+} | {
+    type: 'set-shape-kind';
+    kind: string;
 } | {
     type: 'select';
     layerId: string | null;
@@ -1995,4 +2732,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, DiagramCanvas, type DiagramCommand, type DiagramData, DiagramExtension, type DiagramRFEdge, type DiagramRFNode, DiagramWidget, type DirectionModel, type DocumentLinkCandidate, type DocumentLinkProvider, DocumentSettingsDialog, type DocumentSettingsDialogProps, type DragContentType, type DropTarget, DropZoneOverlay, type DropZoneOverlayProps, EMOJI_CATEGORIES, EMPTY_TRANSITION, 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, 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, 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, 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, useDiagramData, useEditorContext, useFileDrop, useImageEditor, useMediaRecorder, usePreviewSettings, useStreamPreview };