@bendyline/squisq-editor-react 1.6.2 → 2.0.0

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 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, Block, CustomTemplateDefinition, MediaEntry, SurfaceScheme, ImageEditDoc, ImageEditLayer } from '@bendyline/squisq/schemas';
-import { MarkdownDocument, HeadingAttributes } from '@bendyline/squisq/markdown';
+import { ReactNode, CSSProperties, RefObject, KeyboardEvent } from 'react';
+import { Doc, MediaProvider, Theme, CustomTemplateDefinition, ThemeSeedColors, ViewportPreset, ViewportConfig, Block, MediaEntry, DiagramEdgeAnchor, SurfaceScheme, ImageEditDoc, ImageEditLayer } from '@bendyline/squisq/schemas';
+import { MarkdownDocument } 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';
@@ -11,10 +11,14 @@ 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 { ConnectorRouting, AsciiDiagram, Tree, AsciiTimeline, AsciiTimelineSide, AsciiTimelineMarker } from '@bendyline/squisq/doc';
 import * as _tiptap_extension_heading from '@tiptap/extension-heading';
+import { DecorationSet } from '@tiptap/pm/view';
+import { Editor as Editor$1 } from '@tiptap/react';
+import { PluginKey } from '@tiptap/pm/state';
 import { Node } from '@tiptap/pm/model';
 import { SquisqAnnotatedSchema, JsonFormValidator, JsonFormValidationError } from '@bendyline/squisq/jsonForm';
+import { NarrationTrace, NarrationAlignment, NarrationScript, NarrationTimingJsonV3, VadConfig } from '@bendyline/squisq/narration';
 import { ImageEditExportFormat, ImageEditVersionManager } from '@bendyline/squisq/imageEdit';
 
 /**
@@ -23,24 +27,31 @@ import { ImageEditExportFormat, ImageEditVersionManager } from '@bendyline/squis
  * 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
+ * sceneTextChannel — an editor-owned channel 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.
+ * mirrors the handle into `activeSceneText`. Each EditorProvider creates its
+ * own channel, preventing focus in one editor from mutating another editor.
  */
 
 interface SceneTextHandle {
     editor: Editor;
     level: SceneTextLevel;
 }
+type Listener = (handle: SceneTextHandle | null) => void;
+interface SceneTextChannel {
+    set(handle: SceneTextHandle | null): void;
+    get(): SceneTextHandle | null;
+    subscribe(listener: Listener): () => void;
+}
 
 /** Monaco standalone code editor instance type */
 type MonacoEditor = editor.IStandaloneCodeEditor;
@@ -114,6 +125,11 @@ type LayoutMode = 'document' | 'block' | 'timeline';
  * colors. `'none'` opts out completely.
  */
 type ThemeInheritance = 'none' | 'fonts' | 'fonts-colors';
+/**
+ * When inline block-template tags are shown in the WYSIWYG surface.
+ * `'active'` shows tags for the cursor's block and the block under the pointer.
+ */
+type BlockTagVisibility = 'none' | 'active' | 'always';
 /**
  * Editor operating mode. `markdown` is the full experience (WYSIWYG +
  * Preview tabs, formatting toolbar). `code` is a Monaco-only view used
@@ -158,12 +174,11 @@ interface EditorState {
      * the toolbar can toggle it at runtime.
      */
     outlineVisible: boolean;
+    /** When inline block-template tags are shown in the WYSIWYG view. */
+    blockTagVisibility: BlockTagVisibility;
     /**
-     * Whether inline block-template tags (the chip next to each templated
-     * heading in the WYSIWYG view, plus the subtle affordance chip on plain
-     * headings) are currently visible. Initialized from the EditorShell
-     * `blockTags` prop (default true); the View menu in the toolbar can
-     * toggle it at runtime.
+     * Whether inline block-template tags can currently be visible.
+     * Kept for compatibility; prefer {@link blockTagVisibility}.
      */
     blockTagsVisible: boolean;
     /**
@@ -195,6 +210,13 @@ interface EditorState {
      * shell.
      */
     allowRecording: boolean;
+    /**
+     * Whether the Narrate (teleprompter) display mode is offered under the
+     * Use tab. Orthogonal to `allowRecording`: the teleprompter is useful
+     * without any capture (reading for external recording software), and a
+     * host may allow the recorder modal but not want a prompter surface.
+     */
+    allowNarrate: boolean;
     /**
      * Document layout mode. `'document'` (default) edits the whole document;
      * `'block'` activates the block-at-a-time card view. Initialized from the
@@ -254,6 +276,8 @@ interface EditorActions {
     setOutlineVisible: (visible: boolean) => void;
     /** Show or hide inline block-template tags at runtime (driven by the View menu). */
     setBlockTagsVisible: (visible: boolean) => void;
+    /** Choose when inline block-template tags are shown. */
+    setBlockTagVisibility: (visibility: BlockTagVisibility) => void;
     /** Change how much of the active Squisq theme the WYSIWYG surface mirrors. */
     setThemeInheritance: (mode: ThemeInheritance) => void;
     /** Insert text at the current cursor position in the active editor */
@@ -289,6 +313,8 @@ interface EditorContextValue extends EditorState, EditorActions {
      * buttons apply (`inline` = marks only; `rich` = headings/lists too).
      */
     activeSceneText: SceneTextHandle | null;
+    /** Instance-owned bridge used by detached scene widget roots. */
+    sceneTextChannel: SceneTextChannel;
     /**
      * Workspace-scoped `ContentContainer` for this document — the folder
      * holding the doc, its `_files/` sidecar, sibling documents, and any
@@ -405,6 +431,12 @@ interface EditorProviderProps {
      * surfaces where camera/screen prompts would be jarring).
      */
     allowRecording?: boolean;
+    /**
+     * Whether the Narrate (teleprompter) display mode is offered under the
+     * Use tab. Defaults to true. When false the mode button is hidden and a
+     * frontmatter-forced `display-mode: narrate` clamps back to video.
+     */
+    allowNarrate?: boolean;
     /**
      * File name (e.g. `foo.ts`) or bare extension — used to pick a Monaco
      * language and decide between markdown vs. code mode.
@@ -428,10 +460,16 @@ interface EditorProviderProps {
      */
     outline?: boolean;
     /**
-     * Initial visibility of inline block-template tags on headings.
-     * Defaults to true. The toolbar's View menu can toggle it at runtime.
+     * Legacy initial visibility of inline block-template tags on headings.
+     * `true` maps to always visible and `false` maps to hidden. When omitted,
+     * {@link blockTagVisibility} defaults to `'active'`.
      */
     blockTags?: boolean;
+    /**
+     * Initial block-tag visibility mode. When set, this takes precedence over
+     * the legacy boolean {@link blockTags} prop. Defaults to `'active'`.
+     */
+    blockTagVisibility?: BlockTagVisibility;
     /**
      * Initial value for how much of the active Squisq theme the WYSIWYG
      * editing surface should mirror. Defaults to `'fonts'` — the
@@ -449,9 +487,9 @@ interface EditorProviderProps {
      * Bundled view preferences — a serializable JSON blob covering all
      * runtime-toggleable view options. When provided, individual values
      * here override the matching individual props (`inlinePreview`,
-     * `showStatusBar`, `outline`). Hosts wiring this up typically load
-     * the blob from their own preferences storage and pair it with
-     * {@link onViewPreferencesChange}.
+     * `showStatusBar`, `outline`, `blockTagVisibility`, `blockTags`). Hosts
+     * wiring this up typically load the blob from their own preferences storage
+     * and pair it with {@link onViewPreferencesChange}.
      */
     viewPreferences?: ViewPreferences;
     /**
@@ -478,12 +516,14 @@ interface ViewPreferences {
     showStatusBar?: boolean;
     /** Whether inline block-template tags on headings are visible. */
     blockTags?: boolean;
+    /** When inline block-template tags are shown. Takes precedence over `blockTags`. */
+    blockTagVisibility?: BlockTagVisibility;
     /** 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;
+declare function EditorProvider({ initialMarkdown, initialView, articleId, colorScheme: initialColorScheme, workspaceContainer, allowVersioning, versionBasename, versioningPrunePolicy, versioningAutoSaveIdleMs, onSaveVersion, mediaProvider, imageDisplayMode, mentionProvider, documentLinkProvider, allowRecording, allowNarrate, fileName, language, inlinePreview, showStatusBar, outline, blockTags, blockTagVisibility: initialBlockTagVisibility, themeInheritance, layoutMode, viewPreferences, onViewPreferencesChange, children, }: EditorProviderProps): react_jsx_runtime.JSX.Element;
 
 /**
  * Host-supplied context sections rendered INSIDE the Monaco (raw/code)
@@ -611,12 +651,6 @@ interface EditorShellProps {
      * this container via `createMediaProviderFromContainer`.
      */
     workspaceContainer?: ContentContainer | null;
-    /**
-     * @deprecated Renamed to `workspaceContainer` to make the workspace-
-     * vs. doc-scoped distinction explicit. Still accepted as a fallback
-     * for now; remove in the next breaking release.
-     */
-    container?: ContentContainer | null;
     /**
      * Enable version history. Snapshots are stored at
      * `.versions/<basename>.<timestamp>.md` inside the same
@@ -768,6 +802,14 @@ interface EditorShellProps {
      * the button is hidden regardless of this prop.
      */
     allowRecording?: boolean;
+    /**
+     * Whether the Narrate (teleprompter) display mode is offered under the
+     * Use tab. Defaults to true. Orthogonal to `allowRecording` — the
+     * prompter is useful without capture (reading for external recording
+     * software), and the in-mode Record affordance additionally requires
+     * `allowRecording` + a `mediaProvider`.
+     */
+    allowNarrate?: boolean;
     /**
      * Placeholder text shown in the WYSIWYG editor while the document is
      * empty. When omitted, the editor rotates through its own generic
@@ -847,12 +889,16 @@ interface EditorShellProps {
      */
     outlineWidth?: number;
     /**
-     * Initial visibility of inline block-template tags on headings — the
-     * chip rendered next to each heading in the WYSIWYG view that opens
-     * the block-template picker. Defaults to true; the View menu can
-     * toggle it at runtime regardless of the initial value.
+     * Legacy initial visibility of inline block-template tags on headings.
+     * `true` maps to always visible and `false` maps to hidden. When omitted,
+     * {@link blockTagVisibility} defaults to `'active'`.
      */
     blockTags?: boolean;
+    /**
+     * Initial block-tag visibility mode. Takes precedence over `blockTags`.
+     * Defaults to `'active'` (selected/hovered block only).
+     */
+    blockTagVisibility?: BlockTagVisibility;
     /**
      * How much of the active Squisq theme the WYSIWYG editing surface
      * mirrors. Defaults to `'fonts'` — the historical behavior of
@@ -864,7 +910,8 @@ interface EditorShellProps {
      * Bundled view preferences — a serializable JSON blob covering the
      * runtime-toggleable view options surfaced in the View menu. When
      * provided, fields here override the corresponding individual props
-     * (`outline`, `inlinePreview`, `showStatusBar`). Pair with
+     * (`outline`, `inlinePreview`, `showStatusBar`, `blockTagVisibility`,
+     * `blockTags`). Pair with
      * {@link onViewPreferencesChange} to externalize storage of these
      * preferences in the host.
      */
@@ -888,7 +935,7 @@ interface EditorShellProps {
  * Complete markdown editor shell with toolbar, view switcher, and three
  * editing modes: Raw (Monaco), WYSIWYG (Tiptap), and Preview.
  */
-declare function EditorShell({ initialMarkdown, initialView, 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;
+declare function EditorShell({ initialMarkdown, initialView, articleId, basePath, onChange, colorScheme, className, height, minHeight, maxHeight, mediaProvider, workspaceContainer, allowVersioning, versionBasename, versioningPrunePolicy, versioningAutoSaveIdleMs, onSaveVersion, showFilesToggle, toolbarSlotLeft, toolbarSlotAfterActions, toolbarSlotRight, showPlayTab, submitOnEnter, codeContext, fullWidth, uxFont, thinMargins, showStatusBar, imageDisplayMode, fileName, language, mentionProvider, documentLinkProvider, allowRecording, allowNarrate, placeholder, readOnly, imageSrc, imageAlt, imageMode, imageEditorContainer, onImageExport, inlinePreview, inlinePreviewWidth, outline, outlineWidth, blockTags, blockTagVisibility, themeInheritance, viewPreferences, onViewPreferencesChange, themeOverride, }: EditorShellProps): react_jsx_runtime.JSX.Element;
 
 /**
  * Bridges a host-supplied {@link CodeContext} onto the live Monaco editor:
@@ -1299,8 +1346,10 @@ interface PlainHtmlPreviewProps {
     theme?: Theme;
     className?: string;
     style?: CSSProperties;
+    /** Let unmodified Up/Down arrows scroll the preview without requiring iframe focus. */
+    globalKeyboardShortcuts?: boolean;
 }
-declare function PlainHtmlPreview({ markdown, title, images, mediaProvider, mediaRevision, theme, className, style, }: PlainHtmlPreviewProps): react_jsx_runtime.JSX.Element;
+declare function PlainHtmlPreview({ markdown, title, images, mediaProvider, mediaRevision, theme, className, style, globalKeyboardShortcuts, }: PlainHtmlPreviewProps): react_jsx_runtime.JSX.Element;
 
 /**
  * Emoji Dataset
@@ -1316,29 +1365,6 @@ declare function PlainHtmlPreview({ markdown, title, images, mediaProvider, medi
  * because the picker is meant for quick insertion, not exhaustive
  * lookup; the user can paste anything we don't have.
  */
-interface EmojiEntry {
-    /** The actual emoji glyph (may be multi-codepoint, e.g. ZWJ sequences). */
-    char: string;
-    /** Display name shown in the tooltip. */
-    name: string;
-    /** Lowercase keywords for the search index — name words plus aliases. */
-    keywords: string;
-}
-interface EmojiCategory {
-    id: string;
-    label: string;
-    /** Single-glyph icon shown on the tab. */
-    icon: string;
-    emojis: EmojiEntry[];
-}
-declare const EMOJI_CATEGORIES: EmojiCategory[];
-/**
- * Flat list of every emoji across all categories — used as the search
- * corpus and to expose a `getEmojiByChar` lookup.
- */
-declare const ALL_EMOJIS: EmojiEntry[];
-/** Search for emoji whose name or keywords contain the query (case-insensitive). */
-declare function searchEmojis(query: string, limit?: number): EmojiEntry[];
 
 /**
  * Discriminated picker entry. The picker UI dispatches on `kind` to
@@ -1359,6 +1385,29 @@ type PickerEntry = {
     /** Canonical token used in the markdown source (bare or qualified). */
     token: string;
 };
+interface PickerCategory {
+    id: string;
+    label: string;
+    /** What to render on the category tab. Emoji glyph or FA class. */
+    tab: {
+        kind: 'emoji';
+        char: string;
+    } | {
+        kind: 'icon';
+        family: IconFamily;
+        name: string;
+    };
+    entries: PickerEntry[];
+}
+/**
+ * The full picker category list — emoji buckets followed by the three
+ * FontAwesome families. Drives the EmojiPicker tabs.
+ */
+declare const PICKER_CATEGORIES: PickerCategory[];
+/** Flat corpus for the picker search index. */
+declare const ALL_PICKER_ENTRIES: PickerEntry[];
+/** Lowercase substring search across emoji + icon entries. */
+declare function searchPickerEntries(query: string, limit?: number): PickerEntry[];
 
 interface EmojiPickerProps {
     /** Whether the picker is visible. */
@@ -1527,6 +1576,97 @@ declare function useDocCustomThemes(): DocCustomThemes;
 
 /** Where a saved theme lands — mirrors `DesignerSaveTarget` for templates. */
 type ThemeSaveTarget = 'doc' | 'library';
+/** Extra assets riding along with a theme save (file-import byproducts). */
+interface ThemeSaveExtras {
+    /** Custom layout templates inferred from an imported PPTX. */
+    templates?: CustomTemplateDefinition[];
+}
+
+/**
+ * themeDraft — the editable subset of the Theme schema, shared by the
+ * ThemeCustomizerPanel popover and the CustomThemeDialog.
+ *
+ * A `Draft` mirrors the handful of fields a user actually edits (name, seed
+ * colors, N accents, fonts, style presets, and a base theme to inherit from).
+ * `compileDraft` turns it into a full validated `Theme` via `compileTheme`;
+ * everything the draft doesn't mention inherits from the chosen base (or the
+ * compiler's neutral STARTER_THEME when no base is picked).
+ */
+
+declare const BORDER_RADIUS_PRESETS: {
+    readonly sharp: 0;
+    readonly soft: 6;
+    readonly rounded: 16;
+};
+type BorderRadiusPreset = keyof typeof BORDER_RADIUS_PRESETS;
+declare const ANIMATION_SPEED_PRESETS: {
+    readonly static: 0;
+    readonly subtle: 1.4;
+    readonly normal: 1;
+    readonly expressive: 0.7;
+};
+type AnimationSpeedPreset = keyof typeof ANIMATION_SPEED_PRESETS;
+declare const TEXT_SHADOW_PRESETS: {
+    readonly off: false;
+    readonly on: true;
+};
+type TextShadowPreset = keyof typeof TEXT_SHADOW_PRESETS;
+declare const CONTRAST_PRESETS: readonly ["subtle", "balanced", "high"];
+type ContrastPreset = (typeof CONTRAST_PRESETS)[number];
+declare const IMAGE_TREATMENT_PRESETS: readonly ["none", "mono", "duotone", "warm", "cool"];
+type ImageTreatmentPreset = (typeof IMAGE_TREATMENT_PRESETS)[number];
+declare const FALLBACK_OPTIONS: readonly ["sans-serif", "serif", "monospace", "system-ui"];
+type FallbackOption = (typeof FALLBACK_OPTIONS)[number];
+interface CustomFontInput {
+    kind: 'curated' | 'custom';
+    stackId?: string;
+    customName?: string;
+    customFallback?: FallbackOption;
+}
+/** One editable accent: a color plus the colorScheme key it maps to. */
+interface AccentInput {
+    key: string;
+    color: string;
+}
+interface Draft {
+    name: string;
+    /** Id of the base theme this draft inherits render style / layout from. */
+    baseId?: string;
+    seeds: ThemeSeedColors;
+    /** The "N accents" — each becomes a `colorSchemes` entry. */
+    accents: AccentInput[];
+    /** True once the user has touched the accent list; gates wholesale replace. */
+    accentsEdited: boolean;
+    titleFont: CustomFontInput;
+    bodyFont: CustomFontInput;
+    borderRadius: BorderRadiusPreset;
+    animationSpeed: AnimationSpeedPreset;
+    textShadow: TextShadowPreset;
+    contrast: ContrastPreset;
+    imageTreatment: ImageTreatmentPreset;
+}
+/**
+ * Draft patch from a theme inferred from an imported office file: name,
+ * seeds, accents (marked authored so the file's schemes survive a re-save),
+ * and fonts. Deliberately leaves `baseId` and the style presets untouched —
+ * the user's in-progress choices there aren't the file's to overwrite.
+ */
+declare function draftPatchFromImportedTheme(theme: Theme): Partial<Draft>;
+
+interface ImportedThemeResult {
+    theme: Theme;
+    /** PPTX only, when `allowLayouts`: custom templates derived from slide layouts. */
+    layouts?: CustomTemplateDefinition[];
+    warnings: string[];
+    fileName: string;
+}
+interface ImportThemeSectionProps {
+    /** Fired on successful inference with the draft patch + full result. */
+    onImported: (patch: Partial<Draft>, result: ImportedThemeResult) => void;
+    /** Also derive PPTX slide layouts as custom templates. Default false. */
+    allowLayouts?: boolean;
+}
+declare function ImportThemeSection({ onImported, allowLayouts }: ImportThemeSectionProps): react_jsx_runtime.JSX.Element;
 
 /** Caption selection: off, or one of the two enabled styles. */
 type CaptionMode = 'off' | CaptionStyle;
@@ -1567,7 +1707,7 @@ interface PreviewSettings {
 interface ThemeDesignerConfig {
     value: Theme | null;
     onChange: (theme: Theme) => void;
-    onSave: (theme: Theme, target: ThemeSaveTarget) => void;
+    onSave: (theme: Theme, target: ThemeSaveTarget, extras?: ThemeSaveExtras) => void;
     onClose: () => void;
 }
 declare function usePreviewSettings(): PreviewSettings;
@@ -1597,11 +1737,21 @@ declare function PreviewSettingsProvider({ doc, children, themeOverride, }: Prev
  */
 declare function PreviewToolbarControls(): react_jsx_runtime.JSX.Element;
 /**
- * Segmented display-mode switch (Video / Slideshow / Document / Page), used
- * inline in the Use toolbar and inside its overflow popover. Reads and writes
- * the same `activeDisplayMode` in preview settings.
+ * Segmented display-mode switch retained as a public, embeddable control.
+ * The editor shell uses {@link PreviewModeMenu} beside its Use tab instead.
+ * Narrate is hidden when the host disables `allowNarrate`.
  */
 declare function PreviewModeSwitch(): react_jsx_runtime.JSX.Element;
+/**
+ * Dropdown trigger rendered directly beside the Use tab. Selecting a mode
+ * also enters the Use view, so the menu works from Write and Source as well
+ * as from an already-active preview.
+ */
+interface PreviewModeMenuProps {
+    /** Incremented by the parent to open the menu from another control. */
+    openRequest?: number;
+}
+declare function PreviewModeMenu({ openRequest }: PreviewModeMenuProps): react_jsx_runtime.JSX.Element;
 /**
  * Segmented aspect-ratio switch (16:9 / 1:1 / 9:16 / 4:3), used inline in the
  * Use toolbar and inside its overflow popover. Reads and writes the same
@@ -1692,8 +1842,10 @@ interface OutlinePanelProps {
     width?: number;
     /** Optional CSS class for the outer container. */
     className?: string;
+    /** Disable heading-level changes and section reordering. */
+    readOnly?: boolean;
 }
-declare function OutlinePanel({ width, className }: OutlinePanelProps): react_jsx_runtime.JSX.Element;
+declare function OutlinePanel({ width, className, readOnly }: OutlinePanelProps): react_jsx_runtime.JSX.Element;
 
 interface ThemeCustomizerPanelProps {
     /** Current custom theme (or null to start from defaults). */
@@ -1715,6 +1867,7 @@ interface TemplatePreviewSource {
     viewport: ViewportConfig;
     basePath?: string;
     mediaProvider?: MediaProvider | null;
+    customTemplates?: readonly CustomTemplateDefinition[];
 }
 
 /**
@@ -1817,18 +1970,16 @@ interface HeadingTransitionAttrs {
  * from `dataBlockAttrs`.
  */
 declare function setHeadingAttrsTransition(blockAttrsInner: string | null | undefined, templateParams: string | null | undefined, next: TransitionFields): HeadingTransitionAttrs;
-/**
- * Legacy single-channel writer for callers that only own `dataBlockAttrs`.
- * Internal editor surfaces should use {@link setHeadingAttrsTransition} so new
- * transition edits land in the squisq-native `{[…]}` params.
- */
-declare function setBlockAttrsTransition(blockAttrsInner: string | null | undefined, next: TransitionFields): string | null;
 
 interface TransitionPickerProps {
     value: TransitionFields;
     onChange: (next: TransitionFields) => void;
+    /** Surface scheme copied onto the portaled flyout so it can style independently of the shell. */
+    colorScheme?: 'light' | 'dark';
+    /** Active document-theme accent used for open and selected states. */
+    accentColor?: string;
 }
-declare function TransitionPicker({ value, onChange }: TransitionPickerProps): react_jsx_runtime.JSX.Element;
+declare function TransitionPicker({ value, onChange, colorScheme, accentColor, }: TransitionPickerProps): react_jsx_runtime.JSX.Element;
 
 /**
  * transitionCatalog
@@ -1938,13 +2089,17 @@ interface BlockPropertiesPopoverProps {
     /** Apply a new `dataBlockAttrs` inner to the heading (null clears it). */
     onChange: (nextInner: string | null) => void;
     /** Apply a paired `dataBlockAttrs` / `dataTemplateParams` transition rewrite. */
-    onAnnotationChange?: (next: {
+    onAnnotationChange: (next: {
         blockAttrsInner: string | null;
         templateParams: string | null;
     }) => void;
+    /** Editor surface scheme. Required explicitly because this popover is portaled to `<body>`. */
+    colorScheme?: 'light' | 'dark';
+    /** Active document-theme accent used for focus and selected-state highlights. */
+    accentColor?: string;
     onClose: () => void;
 }
-declare function BlockPropertiesPopover({ anchorRect, blockAttrs, templateParams, onChange, onAnnotationChange, onClose, }: BlockPropertiesPopoverProps): react.ReactPortal;
+declare function BlockPropertiesPopover({ anchorRect, blockAttrs, templateParams, onChange, onAnnotationChange, colorScheme, accentColor, onClose, }: BlockPropertiesPopoverProps): react.ReactPortal;
 
 interface InlinePreviewGutterProps {
     /** Width of the gutter in pixels (default: 320). */
@@ -1979,8 +2134,8 @@ interface MediaBinProps {
     /** Relative media paths currently referenced by the document. */
     usedMediaPaths?: ReadonlySet<string>;
     /**
-     * Fired after a successful upload via the MediaBin's own "+ Upload"
-     * button. `relativePath` is what the provider returned (the same
+     * Fired after a successful upload via the MediaBin's "+ Upload"
+     * button or image drop target. `relativePath` is what the provider returned (the same
      * value embedded in markdown refs, e.g. `attachments/xyz.png`);
      * `name` is the uploader-chosen filename before storage renamed
      * it. Consumers typically use this to insert a markdown image ref
@@ -2164,6 +2319,63 @@ interface UseMonacoLoaderResult {
  */
 declare function useMonacoLoader(): UseMonacoLoaderResult;
 
+/**
+ * Monaco language-service worker wiring.
+ *
+ * Monaco offloads its heavy language services — css / html / json / typescript
+ * IntelliSense — plus a base editor service (word-based completions, link
+ * detection, diffing) to web workers. Those worker bundles must be produced by
+ * the HOST application's bundler: the mechanisms for it (Vite's `?worker`
+ * import suffix, `new Worker(new URL(...))`, webpack loaders) are all
+ * bundler-specific and cannot live inside this tsup-built library.
+ *
+ * So the division of labor is: the host supplies the five worker constructors
+ * (one line each with Vite's `?worker`), and this helper owns the
+ * `label → worker` mapping — the part that's fiddly and easy to get wrong.
+ *
+ * Call once, before the first editor mounts (typically in the app entry):
+ *
+ * ```ts
+ * import { configureMonacoWorkers } from '@bendyline/squisq-editor-react';
+ * import EditorWorker from 'monaco-editor/esm/vs/editor/editor.worker?worker';
+ * import JsonWorker   from 'monaco-editor/esm/vs/language/json/json.worker?worker';
+ * import CssWorker    from 'monaco-editor/esm/vs/language/css/css.worker?worker';
+ * import HtmlWorker   from 'monaco-editor/esm/vs/language/html/html.worker?worker';
+ * import TsWorker     from 'monaco-editor/esm/vs/language/typescript/ts.worker?worker';
+ *
+ * configureMonacoWorkers({
+ *   editor: EditorWorker, json: JsonWorker, css: CssWorker,
+ *   html: HtmlWorker, ts: TsWorker,
+ * });
+ * ```
+ *
+ * This is purely additive: without it, highlighting, editing, and custom
+ * completion providers (e.g. the `{[template]}` typeahead) still work — they
+ * run on the main thread. Only the language-service IntelliSense is dormant
+ * until the workers are wired.
+ */
+/** Zero-arg worker constructor, as produced by Vite's `?worker` import. */
+type MonacoWorkerConstructor = new () => Worker;
+interface MonacoWorkerConstructors {
+    /** Base editor worker (word completions, links, diff). Required. */
+    editor: MonacoWorkerConstructor;
+    /** JSON language service. */
+    json?: MonacoWorkerConstructor;
+    /** CSS/SCSS/LESS language service. */
+    css?: MonacoWorkerConstructor;
+    /** HTML/Handlebars/Razor language service. */
+    html?: MonacoWorkerConstructor;
+    /** TypeScript service — also handles JavaScript. */
+    ts?: MonacoWorkerConstructor;
+}
+/**
+ * Install `globalThis.MonacoEnvironment.getWorker` so Monaco routes each
+ * language to the matching worker, falling back to the base editor worker for
+ * any label without a dedicated service (which is every plain language — its
+ * grammar-based highlighting needs no worker).
+ */
+declare function configureMonacoWorkers(workers: MonacoWorkerConstructors): void;
+
 interface CustomTemplateContextValue {
     /** Templates inlined into the current doc's frontmatter. */
     docTemplates: CustomTemplateDefinition[];
@@ -2239,20 +2451,9 @@ interface DocCustomTemplates {
 }
 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.
- */
+/** Data shapes consumed by `DiagramCanvas` / `buildDiagramScene`. */
 
-interface DiagramRFNode {
+interface DiagramNode {
     id: string;
     position: {
         x: number;
@@ -2262,23 +2463,29 @@ interface DiagramRFNode {
         label: string;
     };
     type?: string;
-    /** Per-node width override (from the heading's `w=` Pandoc param). */
+    /** Per-node width override in canvas units. */
     width?: number;
-    /** Per-node height override (from the heading's `h=` Pandoc param). */
+    /** Per-node height override in canvas units. */
     height?: number;
+    /** Render as a background container card (top-anchored label, muted fill). */
+    kind?: 'container';
 }
-interface DiagramRFEdge {
+interface DiagramEdge {
     id: string;
     source: string;
     target: string;
     label?: string;
+    /** False → no end arrowhead. Undefined keeps the diagram default (arrow). */
+    directed?: boolean;
+    sourceAnchor?: DiagramEdgeAnchor;
+    targetAnchor?: DiagramEdgeAnchor;
+    routing?: ConnectorRouting;
 }
 interface DiagramData {
-    nodes: DiagramRFNode[];
-    edges: DiagramRFEdge[];
+    nodes: DiagramNode[];
+    edges: DiagramEdge[];
     warnings: string[];
 }
-declare function useDiagramData(editor: Editor$1, parentPos: number): DiagramData;
 
 /**
  * Tiptap Bridge
@@ -2329,9 +2536,10 @@ declare function buildPreviewDoc(doc: Doc): Doc;
 /**
  * TemplateAnnotation — Tiptap Heading Extension
  *
- * Extends Tiptap's built-in Heading node to support `data-template` and
- * `data-template-params` HTML attributes. These attributes store which block
- * template should be used for a heading section.
+ * Extends Tiptap's built-in Heading node to support `data-template`,
+ * `data-template-params`, and `data-template-empty` HTML attributes. These
+ * attributes store the authored template annotation without exposing its raw
+ * `{[…]}` syntax in the Write view.
  *
  * When present, the heading renders a visible badge (styled CSS chip)
  * showing the template name, e.g. `[chart]`.
@@ -2346,27 +2554,6 @@ 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;
@@ -2400,8 +2587,8 @@ type DiagramCommand = {
     nodeId: string;
 };
 interface DiagramCanvasProps {
-    nodes: DiagramRFNode[];
-    edges: DiagramRFEdge[];
+    nodes: DiagramNode[];
+    edges: DiagramEdge[];
     onCommand: (cmd: DiagramCommand) => void;
     /** When true, render the maximize button. Click toggles `onToggleMaximize`. */
     showMaximize?: boolean;
@@ -2418,99 +2605,525 @@ interface DiagramCanvasProps {
     onActiveToolIdChange?: (id: string) => void;
     /** Forwarded to the Scene so the host can drive a Delete action. */
     onSelectionChange?: (ids: ReadonlySet<string>) => void;
+    /** Per-editor toolbar bridge for detached scene roots. */
+    textChannel?: SceneTextChannel;
+}
+declare function DiagramCanvas({ nodes: incomingNodes, edges: incomingEdges, onCommand, showMaximize, maximized, onToggleMaximize, activeToolId: controlledToolId, onActiveToolIdChange, onSelectionChange, textChannel, }: DiagramCanvasProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * AsciiDiagramExtension — Tiptap/ProseMirror plugin that turns code blocks
+ * containing ASCII box-and-line diagrams into interactive diagram canvases.
+ *
+ * The FENCE TEXT REMAINS THE SOURCE OF TRUTH: the plugin never converts
+ * the document. For each qualifying codeBlock it:
+ * 1. hides the `<pre>` via a node decoration (or tags it visible-monospace
+ *    when the user toggles "source" mode), and
+ * 2. mounts an `AsciiDiagramWidget` after it via a widget decoration.
+ *
+ * Identity: codeBlocks have no persisted id and their content changes on
+ * every canvas edit (self-inflicted fence rewrite), so neither a content
+ * hash nor a raw position can key the widget. Instead the plugin keeps a
+ * POSITION REGISTRY in its state: each qualifying block gets a synthetic
+ * session id (`ascii-N`); on every doc change old positions are remapped
+ * through `tr.mapping` and matched against the new doc walk. Same id →
+ * same widget decoration key → ProseMirror keeps the DOM + React root
+ * alive (pan/zoom survives), exactly like the heading-key trick the
+ * legacy DiagramExtension used.
+ *
+ * Hysteresis: a NEW block must pass full detection (`detectAsciiDiagram`,
+ * ≥2 boxes + thresholds); an already-registered block stays interactive
+ * while its fence still parses to ≥1 box, so deleting down to one node
+ * doesn't kick the user back to a raw code block mid-edit.
+ */
+
+interface AsciiDiagramBlockEntry {
+    /** Synthetic session id (`ascii-N`), stable across edits for one block. */
+    id: string;
+    /** Document position of the codeBlock node at the current state. */
+    pos: number;
+}
+interface AsciiDiagramPluginState {
+    entries: AsciiDiagramBlockEntry[];
+    decorations: DecorationSet;
+    sourceVisible: ReadonlySet<string>;
+    /** Monotonic id allocator. */
+    seq: number;
+}
+/** Resolve a registered block's current doc position (null when gone). */
+declare function findAsciiDiagramBlockPos(editor: Editor$1, blockId: string): number | null;
+declare function isAsciiSourceVisible(editor: Editor$1, blockId: string): boolean;
+/** Toggle the raw-fence view for one diagram block (meta-only transaction). */
+declare function toggleAsciiSource(editor: Editor$1, blockId: string): void;
+interface AsciiDiagramExtensionOptions {
+    /** When false, the extension is inert (no widgets, no decorations). */
+    enabled?: boolean;
+    textChannel?: SceneTextChannel;
 }
-declare function DiagramCanvas({ nodes: incomingNodes, edges: incomingEdges, onCommand, showMaximize, maximized, onToggleMaximize, activeToolId: controlledToolId, onActiveToolIdChange, onSelectionChange, }: DiagramCanvasProps): react_jsx_runtime.JSX.Element;
+declare const AsciiDiagramExtension: Extension<AsciiDiagramExtensionOptions, any>;
 
-interface DiagramWidgetProps {
+interface AsciiDiagramWidgetProps {
     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;
+    /** Session id from the extension's position registry. */
+    blockId: string;
+    /** Position at widget-creation time — display-only fallback. */
+    fallbackPos: number;
     /** Host element used for portal targeting by the maximize overlay. */
     host?: HTMLElement | null;
+    textChannel?: SceneTextChannel;
 }
-declare function DiagramWidget({ editor, headingKey, fallbackParentPos, host }: DiagramWidgetProps): react_jsx_runtime.JSX.Element;
+declare function AsciiDiagramWidget({ editor, blockId, host, textChannel, }: AsciiDiagramWidgetProps): react_jsx_runtime.JSX.Element | null;
 
 /**
- * Tiptap commands for diagram editing.
+ * Read direction of the ASCII diagram loop: fence text → canvas data.
  *
- * 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.
+ * `useAsciiDiagramData` re-derives on every editor transaction (mirroring
+ * the philosophy of the old heading-based `useDiagramData`: no store, so
+ * nothing to invalidate). Parsing is memoized per PMNode instance by the
+ * extension's WeakMap caches, so untouched fences cost nothing.
+ */
+
+interface AsciiDiagramView {
+    /** Canvas nodes, containers ordered first so their cards paint behind. */
+    nodes: DiagramNode[];
+    edges: DiagramEdge[];
+    warnings: string[];
+    style: 'unicode' | 'ascii';
+    /** The current fence text. */
+    text: string;
+    /** The parse behind `nodes`/`edges` (grid units) — ops operate on this. */
+    diagram: AsciiDiagram;
+}
+/** Grid model → canvas model, containers-first for paint order. */
+declare function asciiDiagramToCanvas(diagram: AsciiDiagram): Pick<AsciiDiagramView, 'nodes' | 'edges'>;
+/**
+ * Live view of one registered ASCII diagram block. Returns null when the
+ * block no longer exists or no longer parses (the extension will drop the
+ * widget on its next pass).
  */
+declare function useAsciiDiagramData(editor: Editor$1, blockId: string): AsciiDiagramView | null;
 
-interface HeadingLocation {
-    /** Node start position in the doc (absolute). */
+/**
+ * Write direction of the ASCII diagram loop: canvas command → fence rewrite.
+ *
+ * Every semantic edit is one functional transformation of the fence text
+ * (`renderAscii(applyOp(parseAscii(text)))`) committed as a single
+ * ProseMirror transaction (= a single undo step). Before committing, the
+ * rendered art is re-parsed and verified — if the renderer ever produced
+ * something the parser disagrees with, the command aborts instead of
+ * corrupting the fence.
+ */
+
+/**
+ * Replace the TEXT inside the codeBlock at `pos` and, when `ensureLanguage`
+ * is given, promote its `language` attribute in the SAME transaction (one
+ * undo step). Promoting the language to the explicit `diagram`/`tree` tag is
+ * how a semantic edit makes the block's identity "sticky" — the language
+ * class survives markdown ↔ Tiptap round-trips, so a once-edited diagram/tree
+ * is re-recognized even after it's flattened. No-op (returns false) only when
+ * BOTH the text is already identical AND the language already matches, so
+ * history stays clean on a true no-op.
+ */
+declare function replaceAsciiFenceText(editor: Editor$1, pos: number, nextText: string, ensureLanguage?: string): boolean;
+/**
+ * Reconstruct a broken box-art fence into clean, `diagram`-tagged art in a
+ * single transaction (one undo step). The AsciiDiagramExtension then claims
+ * the tagged fence and mounts the interactive canvas. Returns false when the
+ * block is gone or nothing recoverable (the button simply no-ops).
+ */
+declare function applyRepairCommand(editor: Editor$1, blockId: string): boolean;
+/** Full pipeline for a canvas command against a registered fence block. */
+declare function applyAsciiDiagramCommand(editor: Editor$1, blockId: string, cmd: DiagramCommand): boolean;
+
+/**
+ * RepairableDiagramExtension — mounts an inline "Repair as diagram" button on
+ * code fences that hold BROKEN box-and-line art.
+ *
+ * The three states of a box-drawing fence partition cleanly:
+ *  - a clean diagram        → AsciiDiagramExtension mounts the canvas;
+ *  - a file tree / outline  → TreeViewExtension mounts the outline;
+ *  - broken box art         → neither claims it (it renders as a faithful
+ *                             code block), and THIS extension offers a button
+ *                             to reconstruct it via `repairAsciiDiagram`.
+ *
+ * Unlike the diagram/tree extensions it does NOT hide the fence or mount a
+ * persistent interactive widget — the code stays visible and editable, and a
+ * single click rewrites the fence to clean `diagram`-tagged art (which the
+ * AsciiDiagramExtension then turns into a canvas). So the position registry
+ * only needs to survive until the click; it mirrors the other extensions'
+ * mapping so the button always resolves the right fence.
+ */
+
+interface RepairableBlockEntry {
+    /** Synthetic session id (`repair-N`), stable across edits for one block. */
+    id: string;
+    /** Document position of the codeBlock node at the current state. */
     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. */
+}
+interface RepairablePluginState {
+    entries: RepairableBlockEntry[];
+    decorations: DecorationSet;
+    seq: number;
+}
+declare const REPAIRABLE_KEY: PluginKey<RepairablePluginState>;
+/** True when a codeBlock holds broken box art worth offering to repair. */
+declare function isRepairableFence(node: Node): boolean;
+/** Resolve a registered block's current doc position (null when gone). */
+declare function findRepairableBlockPos(editor: Editor$1, blockId: string): number | null;
+/** Handler the mounted button invokes; wired by the host via extension options. */
+interface RepairableDiagramExtensionOptions {
+    enabled?: boolean;
+    /** Invoked when a repair button is clicked, with the block's synthetic id. */
+    onRepair?: (editor: Editor$1, blockId: string) => void;
+}
+declare const RepairableDiagramExtension: Extension<RepairableDiagramExtensionOptions, any>;
+
+/**
+ * Pure data operations over the ASCII diagram model — the write-direction
+ * half of the fence-is-source-of-truth loop:
+ *
+ *   fence text → parseAsciiDiagram → op → renderAsciiDiagram → fence text
+ *
+ * Every op returns a new AsciiDiagram (inputs are never mutated) and
+ * maintains the invariants the renderer/parser fixpoint relies on:
+ * container moves translate whole subtrees, removals promote children and
+ * drop incident edges, sizes never fall below what a label needs.
+ */
+
+/**
+ * Make arbitrary (rename-dialog) input safe as a box label: box-drawing /
+ * arrow glyphs would corrupt the art, and the Scene's inline editor is
+ * single-line, so newlines collapse to spaces.
+ */
+declare function sanitizeAsciiLabel(label: string): string;
+/** Move a node to (col, row); a container drags its whole subtree along. */
+declare function moveNodeOp(diagram: AsciiDiagram, nodeId: string, col: number, row: number): AsciiDiagram;
+/** Resize a node (grid cells). Clamped so the label always fits. */
+declare function resizeNodeOp(diagram: AsciiDiagram, nodeId: string, wCols: number, hRows: number): AsciiDiagram;
+/** Add a directed edge; duplicates (same source/target/label) are no-ops. */
+declare function addEdgeOp(diagram: AsciiDiagram, source: string, target: string, label?: string): AsciiDiagram;
+/**
+ * Remove an edge. A label-qualified call removes the exact match; without
+ * a label the first (source, target) match goes — mirroring the legacy
+ * `removeConnection` semantics.
+ */
+declare function removeEdgeOp(diagram: AsciiDiagram, source: string, target: string, label?: string): AsciiDiagram;
+/**
+ * Rename a node. The label drives the node's parse-derived id, so edges
+ * and containment references are rewritten to the id the next parse will
+ * produce. (Selection in the canvas drops after a rename — documented.)
+ */
+declare function renameNodeOp(diagram: AsciiDiagram, nodeId: string, label: string): AsciiDiagram;
+/** Add a node at (col, row). Inherits a container when placed inside one. */
+declare function addNodeOp(diagram: AsciiDiagram, opts: {
+    col: number;
+    row: number;
+    label?: string;
+}): {
+    diagram: AsciiDiagram;
+    label: string;
+};
+/**
+ * Remove a node: incident edges (both directions) drop, direct children
+ * are promoted to the removed node's own container (or top level).
+ */
+declare function removeNodeOp(diagram: AsciiDiagram, nodeId: string): AsciiDiagram;
+
+/**
+ * Paste gate for bare (unfenced) ASCII diagram art.
+ *
+ * `+--+ | |` art pasted as plain text is otherwise mangled: its `| x |`
+ * rows match the GFM table-row pattern in `detectMarkdown`, so the paste
+ * handler routes it through the markdown converter, fails table
+ * validation, and emits one broken paragraph per line. When this gate
+ * matches, the paste handler inserts the text verbatim into a fresh code
+ * block instead — which the AsciiDiagramExtension then picks up as an
+ * interactive diagram.
+ */
+declare function shouldPasteAsAsciiFence(text: string): boolean;
+
+/**
+ * TreeViewExtension — Tiptap/ProseMirror plugin that turns code blocks
+ * containing ASCII file-tree / outline art into interactive outline editors.
+ *
+ * Structurally identical to AsciiDiagramExtension (position registry, stable
+ * synthetic ids, hysteresis, self-rewrite-survival via the decoration key);
+ * only the detect/parse gates and class names differ. The fence text stays
+ * the source of truth — every edit re-renders the tree art.
+ *
+ * Mutual exclusion with the diagram extension: a fence with ≥2 closed boxes
+ * is a diagram, never a tree (checked in both gates), so at most one
+ * extension claims any given fence.
+ */
+
+interface TreeBlockEntry {
+    /** Synthetic session id (`tree-N`), stable across edits for one block. */
     id: string;
+    /** Document position of the codeBlock node at the current state. */
+    pos: number;
+}
+interface TreeViewPluginState {
+    entries: TreeBlockEntry[];
+    decorations: DecorationSet;
+    seq: number;
+}
+declare function findTreeBlockPos(editor: Editor$1, blockId: string): number | null;
+interface TreeViewExtensionOptions {
+    /** When false, the extension is inert (no widgets, no decorations). */
+    enabled?: boolean;
+}
+declare const TreeViewExtension: Extension<TreeViewExtensionOptions, any>;
+
+interface TreeOutlineWidgetProps {
+    editor: Editor$1;
+    blockId: string;
+    fallbackPos: number;
+    host?: HTMLElement | null;
+}
+declare function TreeOutlineWidget({ editor, blockId }: TreeOutlineWidgetProps): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * Read direction of the tree loop: fence text → outline view.
+ *
+ * `useTreeViewData` re-derives on every editor transaction; parsing is
+ * memoized per PMNode by the extension's WeakMap caches, so untouched
+ * fences cost nothing.
+ */
+
+interface TreeViewData {
+    tree: Tree;
+    text: string;
+    warnings: string[];
 }
+/** Live view of one registered tree block; null when it no longer parses. */
+declare function useTreeViewData(editor: Editor$1, blockId: string): TreeViewData | null;
+
 /**
- * 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.
+ * Write direction of the tree loop: outline command → fence rewrite.
  *
- * 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.
+ * parse → op → render → verify-reparse → single-transaction fence replace
+ * (one undo step). Reuses the generic `replaceAsciiFenceText` (it only
+ * touches codeBlock text, attributes untouched).
  */
-declare function listDiagramChildren(editor: Editor$1, parentPos: number): HeadingLocation[];
+
+type TreeCommand = {
+    kind: 'addItem';
+    targetId: string;
+    position: 'child' | 'siblingAfter';
+    label?: string;
+    isDir?: boolean;
+} | {
+    kind: 'renameItem';
+    id: string;
+    label: string;
+} | {
+    kind: 'indentItem';
+    id: string;
+} | {
+    kind: 'outdentItem';
+    id: string;
+} | {
+    kind: 'moveItemUp';
+    id: string;
+} | {
+    kind: 'moveItemDown';
+    id: string;
+} | {
+    kind: 'removeItem';
+    id: string;
+} | {
+    kind: 'toggleDir';
+    id: string;
+};
+
+declare function applyTreeCommand(editor: Editor$1, blockId: string, cmd: TreeCommand): boolean;
+
+/**
+ * Pure outline operations over the tree model — the write-direction half of
+ * the fence-is-source-of-truth loop:
+ *
+ *   fence text → parseTree → op → renderTree → fence text
+ *
+ * Every op returns a NEW Tree (inputs untouched). These are the genuinely
+ * new operations with no diagram analog: indent / outdent (re-parent a node
+ * carrying its subtree), move-up / move-down (reorder siblings), plus
+ * add / rename / remove / toggle-directory. Connector rails re-derive in
+ * render, so ops only touch structure + labels.
+ */
+
+/** Make an arbitrary rename safe as a tree label: no connector glyphs / newlines. */
+declare function sanitizeTreeLabel(label: string): string;
+declare function renameItemOp(tree: Tree, id: string, label: string): Tree;
+declare function addItemOp(tree: Tree, targetId: string, position: 'child' | 'siblingAfter', label?: string, isDir?: boolean): Tree;
+declare function removeItemOp(tree: Tree, id: string): Tree;
+/** Node becomes the last child of its immediate preceding sibling. */
+declare function indentItemOp(tree: Tree, id: string): Tree;
+/** Node becomes a sibling of its parent, inserted directly after it (subtree carried). */
+declare function outdentItemOp(tree: Tree, id: string): Tree;
+declare function moveItemUpOp(tree: Tree, id: string): Tree;
+declare function moveItemDownOp(tree: Tree, id: string): Tree;
+/** Toggle the trailing-slash directory marker on a node's label. */
+declare function toggleDirOp(tree: Tree, id: string): Tree;
+
+/**
+ * Paste gate for bare (unfenced) ASCII tree art. `├──`/`└──` file-tree lines
+ * would otherwise route through the markdown converter and mangle; when this
+ * matches, the paste handler drops the text verbatim into a fresh code block
+ * that the TreeViewExtension picks up as an interactive outline.
+ */
+declare function shouldPasteAsTreeFence(text: string): boolean;
+
+/**
+ * TimelineViewExtension — mounts a WYSIWYG timeline editor over qualifying
+ * authored timeline code fences while keeping the fence text as source of
+ * truth. Every semantic edit is rendered back through the core codec.
+ */
+
+interface TimelineBlockEntry {
+    /** Synthetic session id, stable across edits to one fence. */
+    id: string;
+    /** Current document position of the codeBlock node. */
+    pos: number;
+}
+interface TimelineViewPluginState {
+    entries: TimelineBlockEntry[];
+    decorations: DecorationSet;
+    seq: number;
+}
+declare const TIMELINE_VIEW_KEY: PluginKey<TimelineViewPluginState>;
+/** Conservative full-detection gate used when first claiming a code fence. */
+declare function getTimelineForNode(node: Node): AsciiTimeline | null;
+/** Relaxed/sticky gate for a block already registered by this extension. */
+declare function parseTimelineForNode(node: Node): AsciiTimeline | null;
+declare function findTimelineBlockPos(editor: Editor$1, blockId: string): number | null;
+interface TimelineViewExtensionOptions {
+    /** When false, the extension does not claim fences or mount widgets. */
+    enabled?: boolean;
+}
+declare const TimelineViewExtension: Extension<TimelineViewExtensionOptions, any>;
+
+interface TimelineEditorWidgetProps {
+    editor: Editor$1;
+    blockId: string;
+}
+declare function TimelineEditorWidget({ editor, blockId }: TimelineEditorWidgetProps): react_jsx_runtime.JSX.Element | null;
+
+/** Live read-direction adapter from a registered timeline fence to React. */
+
+interface TimelineViewData {
+    timeline: AsciiTimeline;
+    text: string;
+    warnings: string[];
+}
+declare function useTimelineData(editor: Editor$1, blockId: string): TimelineViewData | null;
+
 /**
- * Update a node's `x` / `y` attributes from a drag.
+ * Pure edits over the authored ASCII timeline model.
  *
- * 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.
+ * The code fence remains the source of truth. Canvas coordinates are
+ * normalized to the same global, shared scale used by
+ * `asciiTimelineToTemplateData`; commands render the edited model back into
+ * canonical fence text after applying one of these operations.
  */
-declare function moveNode(editor: Editor$1, parentPos: number, nodeId: string, x: number, y: number): boolean;
+
+interface TimelineEventPatch {
+    label?: string;
+    /** `null` clears the optional description. */
+    description?: string | null;
+    side?: AsciiTimelineSide;
+    /** `null` restores the label side/default placement. */
+    descriptionSide?: AsciiTimelineSide | null;
+    callout?: boolean;
+    marker?: AsciiTimelineMarker;
+    /** Normalized position on the global timeline scale. */
+    position?: number;
+}
+interface AddTimelineEventOptions {
+    id?: string;
+    label?: string;
+    description?: string;
+    side?: AsciiTimelineSide;
+    descriptionSide?: AsciiTimelineSide;
+    callout?: boolean;
+    marker?: AsciiTimelineMarker;
+}
+interface AddTimelineEventResult {
+    timeline: AsciiTimeline;
+    eventId: string;
+}
 /**
- * Add a connection from `sourceId` to `targetId` (optionally typed). No-op
- * if the same connection already exists.
+ * Normalize editable one-line prose exactly as the canonical core renderer
+ * does. This prevents the verified command path from accepting a value that
+ * is silently reinterpreted as timeline syntax on its first render.
  */
-declare function addConnection(editor: Editor$1, parentPos: number, sourceId: string, targetId: string, type?: string): boolean;
+declare function sanitizeTimelineText(value: string): string;
+/** Return a globally unique, renderer-safe event id. */
+declare function nextTimelineEventId(timeline: AsciiTimeline, base?: string): string;
 /**
- * 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.
+ * Add a visible point to `trackId` at a normalized global rail position.
+ * Returns the stable id so the canvas can select/focus the new point after
+ * the fence rewrite.
  */
-declare function removeConnection(editor: Editor$1, parentPos: number, sourceId: string, targetId: string, type?: string): boolean;
+declare function addTimelineEventOp(timeline: AsciiTimeline, trackId: string, position: number, options?: AddTimelineEventOptions): AddTimelineEventResult | null;
+/** Update one point without changing its stable id or branch endpoints. */
+declare function updateTimelineEventOp(timeline: AsciiTimeline, eventId: string, patch: TimelineEventPatch): AsciiTimeline;
 /**
- * Replace a heading's text content (used when the user renames a node
- * via a double-click in the canvas).
+ * Remove a point and every incident branch. Empty tracks are removed because
+ * the canonical renderer cannot represent them. The last point in the whole
+ * timeline is retained so an edit cannot erase its own source fence/widget.
  */
-declare function renameNode(editor: Editor$1, parentPos: number, nodeId: string, newText: string): boolean;
+declare function removeTimelineEventOp(timeline: AsciiTimeline, eventId: string): AsciiTimeline;
+
 /**
- * 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.
+ * Write direction for the WYSIWYG timeline editor:
+ *
+ *   fence text -> parse -> pure op -> render -> verify -> one fence rewrite
+ *
+ * The original code block remains the source of truth and every successful
+ * edit is a single ProseMirror transaction/undo step.
  */
-declare function addNode(editor: Editor$1, parentPos: number, id: string, label: string, x: number, y: number): boolean;
+
+type TimelineCommand = {
+    kind: 'addEvent';
+    trackId: string;
+    /** Normalized position on the global timeline rail. */
+    position: number;
+    id?: string;
+    label?: string;
+    description?: string;
+    side?: AsciiTimelineSide;
+    descriptionSide?: AsciiTimelineSide;
+    callout?: boolean;
+    marker?: AsciiTimelineMarker;
+} | {
+    kind: 'updateEvent';
+    eventId: string;
+    patch: TimelineEventPatch;
+} | {
+    kind: 'removeEvent';
+    eventId: string;
+};
+interface TimelineCommandResult {
+    applied: boolean;
+    /** Present after add so the widget can select/focus the new marker. */
+    eventId?: string;
+    /** Why an otherwise valid semantic edit was deliberately blocked. */
+    reason?: 'read-only' | 'unsafe-source';
+}
 /**
- * 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.
+ * Semantic operations replace the whole fence with canonical rendered art.
+ * Fail closed when that would discard source the timeline model cannot
+ * represent. Warnings catch unresolved/unlabeled constructs; the semantic
+ * round-trip catches renderer normalization that changes modeled content;
+ * exact metadata validation rejects partially consumed attrs; and a linear
+ * semantic-residue comparison catches ignored prose/symbol rows without
+ * reparsing a successively shorter document for every source line.
  */
-declare function removeNode(editor: Editor$1, parentPos: number, nodeId: string): boolean;
+declare function isTimelineSourceSafeForSemanticEdit(source: string, timeline: AsciiTimeline): boolean;
+/** Apply one semantic timeline command to a registered fence block. */
+declare function applyTimelineCommand(editor: Editor$1, blockId: string, command: TimelineCommand): TimelineCommandResult;
+
+/** Paste gate for bare, high-confidence Unicode timeline art. */
+declare function shouldPasteAsTimelineFence(text: string): boolean;
 
 interface JsonEditorProps {
     /** Schema describing the value's shape (with optional `squisq` hints). */
@@ -2915,6 +3528,443 @@ declare function encodeTimingJson(timing: TimingJson): Uint8Array;
  */
 declare function timingPathFor(audioRelativePath: string): string;
 
+/** Editor plumbing the recording flow needs; omit for prompter-only use. */
+interface TeleprompterRecordingDeps {
+    mediaProvider: MediaProvider;
+    container: ContentContainer | null;
+    markdownSource: string;
+    setMarkdownSource: (next: string) => void;
+    bumpMediaRevision: () => void;
+}
+interface TeleprompterViewProps {
+    doc: Doc | null;
+    theme: Theme;
+    /** Kept for API symmetry with PreviewPanel; recording uses `recording.container`. */
+    workspaceContainer?: ContentContainer | null;
+    /** Media base path (reserved for future preview integrations). */
+    basePath?: string;
+    /**
+     * Optional audience-window portal owned by the editor's Presentation mode.
+     * The main controller remains authoritative; only this live surface is
+     * mirrored into the target.
+     */
+    presentationTarget?: HTMLElement | null;
+    /** Recording deps; null/omitted disables the Record affordance. */
+    recording?: TeleprompterRecordingDeps | null;
+}
+declare function TeleprompterView(props: TeleprompterViewProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Mic capture + PCM transport for the teleprompter.
+ *
+ * getUserMedia → AudioContext → AudioWorklet tap → subscriber callbacks
+ * with 1024-sample Float32Array hops on the main thread. The DSP itself
+ * lives in core (`@bendyline/squisq/narration`) — this hook only moves
+ * samples. Falls back to a ScriptProcessorNode when `audioWorklet` is
+ * unavailable (same push model, so pacing still isn't tied to rAF).
+ */
+type MicAnalysisStatus = 'idle' | 'starting' | 'live' | 'error';
+type PcmHopListener = (pcm: Float32Array, audioTimeSec: number) => void;
+interface MicAnalysisHandle {
+    status: MicAnalysisStatus;
+    error: Error | null;
+    /** The live mic stream (feeds the narration recorder too), or null. */
+    stream: MediaStream | null;
+    /** AudioContext sample rate once live. */
+    sampleRate: number | null;
+    /** Known audio inputs (labels appear after the first grant). */
+    devices: MediaDeviceInfo[];
+    /**
+     * Start (or restart) capture. Resolves with the live stream — callers
+     * that need it immediately must use the return value, not the `stream`
+     * state field, which only updates on the NEXT render (stale-closure
+     * hazard right after an await). Null on failure/supersession.
+     */
+    start: (deviceId: string | null) => Promise<MediaStream | null>;
+    stop: () => void;
+    /** Subscribe to PCM hops; returns an unsubscribe. */
+    subscribeHop: (listener: PcmHopListener) => () => void;
+}
+declare function useMicAnalysis(): MicAnalysisHandle;
+
+/**
+ * Narration recorder for the teleprompter — an in-place (no modal)
+ * capture flow.
+ *
+ * Audio records THE MIC ANALYSIS STREAM (what paces the prompter is
+ * exactly what lands in the take); the optional camera is a separate
+ * video-only capture whose start skew vs the audio recorder is measured
+ * and persisted (`cameraOffsetSec`) — the audio file is the doc clock,
+ * so camera skew never affects narration timing. While recording, a
+ * sparse live trace of the prompter position is sampled; after stop,
+ * the take is decoded and run through core's offline aligner
+ * (`alignNarration`) to produce word/block timestamps for the sidecar.
+ * Decode/alignment failure degrades gracefully: saving still works,
+ * just without re-timing.
+ */
+
+type NarrationRecorderState = 'idle' | 'starting' | 'recording' | 'processing' | 'review' | 'saving' | 'error';
+interface NarrationTake {
+    audioBlob: Blob;
+    audioMime: string;
+    audioExt: string;
+    cameraBlob: Blob | null;
+    cameraMime: string | null;
+    cameraExt: string | null;
+    durationSec: number;
+    cameraOffsetSec: number | undefined;
+    trace: NarrationTrace;
+    alignment: NarrationAlignment | null;
+    script: NarrationScript;
+}
+interface UseNarrationRecorderOptions {
+    mic: MicAnalysisHandle;
+    getScript: () => NarrationScript | null;
+    /** Live prompter position, sampled into the trace while recording. */
+    getWordPos: () => number;
+    getMicDeviceId: () => string | null;
+    /** Fired when capture actually starts (View starts the prompter). */
+    onRecordingStart?: () => void;
+    onRecordingStop?: () => void;
+}
+interface NarrationRecorderController {
+    state: NarrationRecorderState;
+    error: Error | null;
+    withCamera: boolean;
+    setWithCamera: (on: boolean) => void;
+    /** Live camera stream for the self-view while recording. */
+    cameraStream: MediaStream | null;
+    take: NarrationTake | null;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+    retake: () => void;
+    discard: () => void;
+    /** Transition into/out of 'saving'; the View owns the actual I/O. */
+    beginSave: () => void;
+    finishSave: (ok: boolean, error?: Error) => void;
+}
+declare function useNarrationRecorder(options: UseNarrationRecorderOptions): NarrationRecorderController;
+
+/**
+ * Pure save-plan builder for a narration take, plus its executor.
+ *
+ * Follows the recorder's conventions (`RecorderModal.handleSave`):
+ * audio at `audio/<narration-…>` via `MediaProvider.addMedia` (the
+ * RETURNED path is authoritative — providers may rename), the timing
+ * sidecar at `<audio>.timing.json` via `container.writeFile` (falling
+ * back to `addMedia` with a warning), and ONE `setMarkdownSource` write
+ * composing every markdown edit from a single snapshot (the single-write
+ * rule — successive writes each derive from stale source and clobber
+ * each other).
+ *
+ * Block timings deliberately do NOT get baked into heading `duration=`
+ * pins: pins outrank narration in `applyNarrationTiming`, so baking
+ * them would shadow every retake. The sidecar owns the timing.
+ */
+
+interface NarrationSavePlanArgs {
+    script: NarrationScript;
+    /** Null when decode/alignment failed — the sidecar still saves (empty timing). */
+    alignment: NarrationAlignment | null;
+    durationSec: number;
+    audioExt: string;
+    cameraExt: string | null;
+    baseWpm: number;
+    cameraOffsetSec?: number;
+}
+interface NarrationSavePlan {
+    audioRelativeName: string;
+    cameraRelativeName: string | null;
+    sidecarPayload: NarrationTimingJsonV3;
+    /** Sidecar path for a given (possibly renamed) saved audio path. */
+    sidecarPathFor: (savedAudioPath: string) => string;
+    /** Compose ALL markdown edits from one source snapshot. */
+    nextMarkdown: (currentSource: string, savedAudioPath: string, savedCameraPath: string | null) => string;
+}
+declare function buildNarrationSavePlan(args: NarrationSavePlanArgs): NarrationSavePlan;
+interface ExecuteNarrationSaveDeps {
+    mediaProvider: MediaProvider;
+    container: ContentContainer | null;
+    markdownSource: string;
+    setMarkdownSource: (next: string) => void;
+    bumpMediaRevision: () => void;
+}
+interface NarrationSaveResult {
+    audioPath: string;
+    cameraPath: string | null;
+    sidecarPath: string;
+}
+/** Execute a save plan: media writes, sidecar, then the single markdown write. */
+declare function executeNarrationSave(plan: NarrationSavePlan, take: {
+    audioBlob: Blob;
+    audioMime: string;
+    cameraBlob: Blob | null;
+    cameraMime: string | null;
+}, deps: ExecuteNarrationSaveDeps): Promise<NarrationSaveResult>;
+
+/**
+ * Pure markdown edit: insert (or replace) the narration reference at the
+ * start of the document.
+ *
+ * The narration take is referenced by a preamble media annotation —
+ * `{[audio src=audio/narration-….webm anchor=document]}` — the canonical
+ * authored form `markdownToDoc` lifts into `doc.documentMedia`. A prior
+ * teleprompter take's line (matched by the `audio/narration-` prefix +
+ * `anchor=document`) is replaced, so retakes swap the reference instead
+ * of stacking narrations. The optional camera companion rides on the
+ * next line as an inline `<video>` (deliberately NOT doc-anchored:
+ * document-anchored video renders full-bleed behind every block and is
+ * excluded from export audio — not a talking head).
+ */
+declare function narrationAnnotationLine(audioPath: string): string;
+declare function cameraVideoLine(cameraPath: string): string;
+/**
+ * Insert the narration preamble after the frontmatter (or at the top),
+ * replacing any previous teleprompter take's lines.
+ */
+declare function insertNarrationPreamble(source: string, audioPath: string, cameraPath: string | null): string;
+
+interface TeleprompterSurfaceProps {
+    script: NarrationScript;
+    /** Fractional word position; floor is the active token. */
+    wordPos: number;
+    fontSizePx: number;
+    mirrored: boolean;
+    lineGuide: boolean;
+    countdownRemaining: number | null;
+    recordingIndicator: boolean;
+    theme: Theme;
+    /** Hide block markers / tighten padding for small float windows. */
+    compact?: boolean;
+    /** Click a word to jump the prompter there. */
+    onSeekToken?: (tokenIndex: number) => void;
+}
+declare function TeleprompterSurface({ script, wordPos, fontSizePx, mirrored, lineGuide, countdownRemaining, recordingIndicator, theme, compact, onSeekToken, }: TeleprompterSurfaceProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Shared types for the Narrate (teleprompter) display mode.
+ */
+interface TeleprompterPrefs {
+    /** Prompter type size in px (28–96). */
+    fontSizePx: number;
+    /** Beam-splitter mirror flip. */
+    mirrored: boolean;
+    /** Base speaking rate in words per minute (80–260). */
+    baseWpm: number;
+    /** Voice-adaptive pacing on/off; off = constant-rate manual mode. */
+    voiceTracking: boolean;
+    /** VAD sensitivity 0–1 (0.5 = engine defaults). */
+    vadSensitivity: number;
+    /** Countdown before the prompter starts rolling. */
+    countdownSec: 0 | 3 | 5 | 10;
+    /** Eye-line chevrons + focus band. */
+    lineGuide: boolean;
+    /** Preferred mic device id (null = system default). */
+    micDeviceId: string | null;
+}
+declare const DEFAULT_TELEPROMPTER_PREFS: TeleprompterPrefs;
+type PrompterTransport = 'stopped' | 'countdown' | 'rolling' | 'paused' | 'finished';
+/** Floating-surface tier, best first. */
+type FloatTier = 'document-pip' | 'video-pip' | 'popup' | 'docked';
+
+/**
+ * The teleprompter controller — single source of truth, always in the
+ * MAIN window (floats are render targets only).
+ *
+ * Loop-ownership rule: **the audio worklet owns time; the main window
+ * owns state; the visible surface owns pixels.** Voice-mode position
+ * advances on worklet PCM hops (immune to rAF/timer throttling while
+ * the browser is occluded by recording software); manual constant-rate
+ * mode uses rAF and is documented as best-effort under occlusion. React
+ * state publishes at ~15 Hz; per-hop subscribers (`subscribeTick`)
+ * exist for the video-PiP canvas pump.
+ */
+
+interface TeleprompterController {
+    script: NarrationScript | null;
+    transport: PrompterTransport;
+    countdownRemaining: number | null;
+    /** Fractional word position (published ~15 Hz). */
+    wordPos: number;
+    /** Smoothed mic level 0–1 for the meter. */
+    micLevel: number;
+    /** VAD flag for the meter tint. */
+    voiceActive: boolean;
+    mic: MicAnalysisHandle;
+    prefs: TeleprompterPrefs;
+    setPrefs: (patch: Partial<TeleprompterPrefs>) => void;
+    play: () => void;
+    pause: () => void;
+    restart: () => void;
+    /** Move the prompter by whole tokens and re-anchor voice tracking. */
+    nudge: (deltaTokens: number) => void;
+    /** Jump to an absolute token index (e.g. click a block marker). */
+    seekToToken: (tokenIndex: number) => void;
+    /** Per-analysis-tick subscription (video-PiP pump). Not throttled. */
+    subscribeTick: (cb: (wordPos: number) => void) => () => void;
+    handleKeyDown: (event: KeyboardEvent<HTMLElement>) => void;
+}
+/** Map the 0–1 sensitivity pref onto VAD thresholds (0.5 = engine defaults). */
+declare function vadConfigForSensitivity(sensitivity: number): Partial<VadConfig>;
+declare function useTeleprompter(opts: {
+    doc: Doc | null;
+}): TeleprompterController;
+
+/**
+ * Floating-teleprompter window manager — framework-free.
+ *
+ * Capability ladder, best first:
+ *   1. `document-pip` — Document Picture-in-Picture (Chromium 116+,
+ *      Firefox 151+): a true always-on-top window hosting live DOM; the
+ *      React surface portals into it.
+ *   2. `video-pip`   — canvas → `captureStream(0)` → `<video>` →
+ *      `requestPictureInPicture()` (Safari's only always-on-top path;
+ *      `webkitSetPresentationMode` fallback). Read-only: the main
+ *      window draws frames and calls `requestFrame()` on analysis
+ *      ticks — never rAF, which throttles under occlusion.
+ *   3. `popup`       — `window.open` (positionable, not always-on-top).
+ *   4. `docked`      — no float.
+ *
+ * Every tier is feature-detected at open time and falls through to the
+ * next on ANY failure. All interactive state stays in the main window;
+ * floats are render targets only.
+ */
+
+interface FloatOpenOptions {
+    width: number;
+    height: number;
+    /** Try this tier first; the ladder continues below it on failure. */
+    preferredTier?: FloatTier;
+    title: string;
+}
+interface CanvasSink {
+    canvas: HTMLCanvasElement;
+    width: number;
+    height: number;
+    /** Push the freshly drawn canvas frame into the PiP video. */
+    requestFrame: () => void;
+}
+type FloatEvent = 'closed' | 'tierchange';
+interface FloatingWindowManager {
+    readonly tier: FloatTier;
+    readonly isOpen: boolean;
+    /** Resolves with the tier that actually opened ('docked' if none could). */
+    open(opts: FloatOpenOptions): Promise<FloatTier>;
+    /** Idempotent; restores docked and emits 'closed'. */
+    close(): void;
+    /** Portal container for 'document-pip' | 'popup'; null otherwise. */
+    getPortalTarget(): HTMLElement | null;
+    /** Canvas sink for 'video-pip'; null otherwise. */
+    getCanvasSink(): CanvasSink | null;
+    on(event: FloatEvent, cb: (tier: FloatTier) => void): () => void;
+    /** Tear everything down (unmount); like close() but silent-safe. */
+    dispose(): void;
+}
+/** Feature-detect the available float tiers, best first. */
+declare function detectFloatTiers(): FloatTier[];
+declare function createFloatingWindowManager(deps: {
+    styleCss: string;
+}): FloatingWindowManager;
+
+/**
+ * React binding over {@link createFloatingWindowManager}: exposes the
+ * current tier + portal target as state and guarantees the float closes
+ * when the owning view unmounts (mode switch, Use-tab exit, shell
+ * teardown).
+ */
+
+interface FloatingWindowHandle {
+    tier: FloatTier;
+    isOpen: boolean;
+    /** Non-docked tiers this browser supports, best first. */
+    supportedTiers: FloatTier[];
+    portalTarget: HTMLElement | null;
+    canvasSink: CanvasSink | null;
+    open: (preferredTier?: FloatTier) => Promise<void>;
+    close: () => void;
+}
+declare function useFloatingWindow(styleCss: string): FloatingWindowHandle;
+
+interface TeleprompterControlsProps {
+    controller: TeleprompterController;
+    float: FloatingWindowHandle;
+    /** Phase B mounts the narration Record button here. */
+    recordSlot?: ReactNode;
+}
+declare function TeleprompterControls({ controller, float, recordSlot }: TeleprompterControlsProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * The PCM tap AudioWorklet, shipped as an inline source string.
+ *
+ * Why inline → Blob URL instead of a bundled asset: `audioWorklet
+ * .addModule(url)` resolves relative to the host DOCUMENT, so a
+ * dist-relative asset would need every consumer's bundler to rewrite
+ * and serve it (editor-react ships zero runtime assets today). The
+ * worklet is ~30 lines with no imports; inlining follows the
+ * `PLAYER_BUNDLE` source-string precedent and needs zero bundler
+ * config. The worklet does NO DSP — it batches 128-sample render
+ * quanta into 1024-sample frames and posts them (transferably) to the
+ * main thread, where the pure engine in `@bendyline/squisq/narration`
+ * runs. The audio render thread never throttles, so pacing keeps
+ * working while the browser window is fully occluded by recording
+ * software — the whole point of the teleprompter's scenario 2.
+ */
+declare const PCM_WORKLET_NAME = "squisq-pcm-tap";
+declare const PCM_WORKLET_SOURCE = "\nclass SquisqPcmTap extends AudioWorkletProcessor {\n  constructor() {\n    super();\n    this._buf = new Float32Array(1024);\n    this._len = 0;\n  }\n  process(inputs) {\n    const channel = inputs[0] && inputs[0][0];\n    if (channel && channel.length > 0) {\n      let i = 0;\n      while (i < channel.length) {\n        const n = Math.min(channel.length - i, this._buf.length - this._len);\n        this._buf.set(channel.subarray(i, i + n), this._len);\n        this._len += n;\n        i += n;\n        if (this._len === this._buf.length) {\n          const out = this._buf;\n          this._buf = new Float32Array(1024);\n          this._len = 0;\n          // Clone, don't transfer: Chrome recycles buffers transferred out\n          // of the worklet scope once the receiving handler returns, so a\n          // transferred hop reads as zeros if anything retains it. A 4 KB\n          // structured clone at ~47 Hz is negligible.\n          this.port.postMessage({ pcm: out, audioTime: currentTime });\n        }\n      }\n    }\n    return true;\n  }\n}\nregisterProcessor('squisq-pcm-tap', SquisqPcmTap);\n";
+/** Register the tap on an AudioContext via a same-origin Blob URL. */
+declare function registerPcmWorklet(ctx: AudioContext): Promise<void>;
+
+/**
+ * Pure scroll math for the teleprompter surface.
+ *
+ * The surface renders the whole script into one absolutely-positioned
+ * column and translates it so the active word sits at the eye-line
+ * (~35% from the top). These helpers are DOM-free except for the
+ * measurement entry point, which only reads layout.
+ */
+interface TokenLineMap {
+    /** Top offset (px, within the scroll column) of each token span. */
+    tokenTops: number[];
+    /** Height of each token's line box (px). */
+    tokenHeights: number[];
+}
+/** Fraction of the viewport height where the active line is held. */
+declare const EYE_LINE_FRACTION = 0.35;
+/**
+ * Measure the top offset of every `[data-token-idx]` span inside the
+ * scroll column. Layout read only — call on mount, resize, and font-size
+ * changes, not per frame.
+ */
+declare function measureTokenLines(scrollColumn: HTMLElement): TokenLineMap;
+/**
+ * The translateY offset (px) that puts the (fractional) word position on
+ * the eye-line. Interpolates between the current and next token tops so
+ * the column glides instead of stepping line by line.
+ */
+declare function targetOffsetFor(wordPos: number, lines: TokenLineMap, viewportHeightPx: number, eyeLine?: number): number;
+/**
+ * Advance the current scroll offset toward the target: exponential
+ * approach (critically-damped feel) with an absolute speed clamp so a
+ * hard resync glides rather than teleporting.
+ */
+declare function stepScroll(currentPx: number, targetPx: number, dtMs: number, maxPxPerSec?: number): number;
+
+/**
+ * Self-contained styling for the teleprompter.
+ *
+ * Everything the prompter surface needs ships as one CSS string plus a
+ * set of inline `--squisq-prompter-*` custom properties derived from the
+ * doc Theme. The docked surface, a Document-PiP window, and a popup all
+ * inject the SAME string, so the surface never depends on the host
+ * page's cascade (the VideoExportModal self-theming strategy).
+ */
+
+/** Inline CSS vars for the surface root, derived from the doc theme. */
+declare function prompterVarsFromTheme(theme: Theme): Record<string, string>;
+/** Inject {@link TELEPROMPTER_CSS} into a document once (main doc or a float window). */
+declare function ensureTeleprompterStyles(doc: Document): void;
+declare const TELEPROMPTER_CSS = "\n.squisq-teleprompter-root {\n  display: flex;\n  flex-direction: column;\n  width: 100%;\n  height: 100%;\n  min-height: 0;\n  background: var(--squisq-bg, #f5f5f5);\n  outline: none;\n}\n.squisq-teleprompter-stage {\n  position: relative;\n  flex: 1;\n  min-height: 0;\n  display: flex;\n}\n\n.squisq-teleprompter-surface {\n  position: relative;\n  flex: 1;\n  min-height: 0;\n  overflow: hidden;\n  background: var(--squisq-prompter-bg, #101014);\n  color: var(--squisq-prompter-text, #f5f5f2);\n  font-family: var(--squisq-prompter-font, system-ui, sans-serif);\n  user-select: none;\n}\n.squisq-teleprompter-flip {\n  position: absolute;\n  inset: 0;\n}\n.squisq-teleprompter-surface--mirrored .squisq-teleprompter-flip {\n  transform: scaleX(-1);\n}\n.squisq-teleprompter-scroll {\n  position: absolute;\n  left: 0;\n  right: 0;\n  top: 0;\n  will-change: transform;\n  padding: 40vh 8% 60vh;\n  box-sizing: border-box;\n}\n.squisq-teleprompter-line-guide {\n  position: absolute;\n  left: 0;\n  right: 0;\n  pointer-events: none;\n  z-index: 2;\n}\n.squisq-teleprompter-line-guide::before,\n.squisq-teleprompter-line-guide::after {\n  content: '';\n  position: absolute;\n  top: 50%;\n  border: 9px solid transparent;\n  transform: translateY(-50%);\n}\n.squisq-teleprompter-line-guide::before {\n  left: 6px;\n  border-left-color: var(--squisq-prompter-accent, #e8b64c);\n}\n.squisq-teleprompter-line-guide::after {\n  right: 6px;\n  border-right-color: var(--squisq-prompter-accent, #e8b64c);\n}\n.squisq-teleprompter-guide-band {\n  position: absolute;\n  left: 0;\n  right: 0;\n  background: color-mix(in srgb, var(--squisq-prompter-accent, #e8b64c) 9%, transparent);\n  pointer-events: none;\n  z-index: 1;\n}\n\n.squisq-teleprompter-block-marker {\n  display: block;\n  margin: 1.1em 0 0.35em;\n  font-size: 0.38em;\n  font-weight: 600;\n  letter-spacing: 0.14em;\n  text-transform: uppercase;\n  color: var(--squisq-prompter-muted, #9a9aa0);\n  border-top: 1px solid color-mix(in srgb, var(--squisq-prompter-muted, #9a9aa0) 35%, transparent);\n  padding-top: 0.6em;\n}\n.squisq-teleprompter-para {\n  margin: 0 0 0.55em;\n  line-height: 1.4;\n  font-weight: 500;\n}\n.squisq-teleprompter-word {\n  opacity: 0.45;\n  transition: color 0.1s linear, opacity 0.1s linear;\n}\n.squisq-teleprompter-word--read {\n  opacity: 0.9;\n}\n.squisq-teleprompter-word--active {\n  opacity: 1;\n  font-weight: 800;\n  color: var(--squisq-prompter-accent, #e8b64c);\n}\n\n.squisq-teleprompter-countdown {\n  position: absolute;\n  inset: 0;\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  z-index: 3;\n  background: color-mix(in srgb, var(--squisq-prompter-bg, #101014) 72%, transparent);\n}\n.squisq-teleprompter-countdown-digit {\n  font-size: 18vmin;\n  font-weight: 800;\n  color: var(--squisq-prompter-accent, #e8b64c);\n  animation: squisq-prompter-pulse 1s ease-in-out infinite;\n}\n.squisq-teleprompter-recdot {\n  position: absolute;\n  top: 14px;\n  right: 16px;\n  z-index: 4;\n  width: 14px;\n  height: 14px;\n  border-radius: 50%;\n  background: #e5484d;\n  box-shadow: 0 0 0 3px color-mix(in srgb, #e5484d 30%, transparent);\n  animation: squisq-prompter-pulse 1.4s ease-in-out infinite;\n}\n/* Counter-flip overlays so they stay readable in mirror mode. */\n.squisq-teleprompter-surface--mirrored .squisq-teleprompter-countdown,\n.squisq-teleprompter-surface--mirrored .squisq-teleprompter-recdot {\n  transform: scaleX(-1);\n}\n\n.squisq-teleprompter-selfview {\n  position: absolute;\n  right: 14px;\n  bottom: 14px;\n  width: 160px;\n  border-radius: 8px;\n  border: 2px solid color-mix(in srgb, #e5484d 60%, transparent);\n  z-index: 5;\n  background: #000;\n}\n\n.squisq-teleprompter-review {\n  display: flex;\n  align-items: center;\n  flex-wrap: wrap;\n  gap: 10px;\n  padding: 8px 12px;\n  border-top: 1px solid var(--squisq-border, #e5e7eb);\n  background: var(--squisq-surface, var(--squisq-bg, #fff));\n  color: var(--squisq-text, #111827);\n  font-size: 12.5px;\n}\n.squisq-teleprompter-review audio {\n  height: 28px;\n  max-width: 260px;\n}\n.squisq-teleprompter-review button {\n  font: inherit;\n  color: inherit;\n  background: var(--squisq-input-bg, #fff);\n  border: 1px solid var(--squisq-border, #d1d5db);\n  border-radius: 6px;\n  padding: 4px 10px;\n  cursor: pointer;\n}\n\n.squisq-teleprompter-float-note {\n  flex: 1;\n  display: flex;\n  flex-direction: column;\n  align-items: center;\n  justify-content: center;\n  gap: 12px;\n  color: var(--squisq-text-muted, #6b7280);\n  font-size: 14px;\n}\n\n.squisq-teleprompter-controls {\n  display: flex;\n  align-items: center;\n  flex-wrap: wrap;\n  gap: 10px;\n  padding: 8px 12px;\n  border-top: 1px solid var(--squisq-border, #e5e7eb);\n  background: var(--squisq-surface, var(--squisq-bg, #fff));\n  color: var(--squisq-text, #111827);\n  font-size: 12.5px;\n}\n.squisq-teleprompter-controls .squisq-teleprompter-group {\n  display: inline-flex;\n  align-items: center;\n  gap: 6px;\n  white-space: nowrap;\n}\n.squisq-teleprompter-controls button {\n  font: inherit;\n  color: inherit;\n  background: var(--squisq-input-bg, #fff);\n  border: 1px solid var(--squisq-border, #d1d5db);\n  border-radius: 6px;\n  padding: 4px 10px;\n  cursor: pointer;\n}\n.squisq-teleprompter-controls button:hover {\n  background: var(--squisq-surface-hover, #f3f4f6);\n}\n.squisq-teleprompter-controls button[aria-pressed='true'] {\n  background: var(--squisq-text, #111827);\n  color: var(--squisq-bg, #fff);\n  border-color: var(--squisq-text, #111827);\n}\n.squisq-teleprompter-controls select,\n.squisq-teleprompter-controls input[type='range'] {\n  font: inherit;\n  color: inherit;\n  background: var(--squisq-input-bg, #fff);\n  border: 1px solid var(--squisq-border, #d1d5db);\n  border-radius: 6px;\n  max-width: 170px;\n}\n.squisq-teleprompter-controls input[type='range'] {\n  border: none;\n  background: transparent;\n  width: 110px;\n}\n.squisq-teleprompter-meter {\n  position: relative;\n  width: 64px;\n  height: 8px;\n  border-radius: 4px;\n  overflow: hidden;\n  background: var(--squisq-border, #e5e7eb);\n}\n.squisq-teleprompter-meter-fill {\n  position: absolute;\n  inset: 0 auto 0 0;\n  background: #9ca3af;\n  transition: width 0.08s linear;\n}\n.squisq-teleprompter-meter--voice .squisq-teleprompter-meter-fill {\n  background: #30a46c;\n}\n\n@keyframes squisq-prompter-pulse {\n  0%, 100% { opacity: 1; }\n  50% { opacity: 0.45; }\n}\n@media (prefers-reduced-motion: reduce) {\n  .squisq-teleprompter-countdown-digit,\n  .squisq-teleprompter-recdot {\n    animation: none;\n  }\n  .squisq-teleprompter-word {\n    transition: none;\n  }\n}\n";
+
 interface ImageEditorProps {
     /**
      * Scoped sidecar container for this image — typically
@@ -3103,4 +4153,4 @@ interface UseImageEditorReturn {
 }
 declare function useImageEditor(options: UseImageEditorOptions): UseImageEditorReturn;
 
-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, type HeadingTransitionAttrs, 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, setHeadingAttrsTransition, 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 };
+export { ALL_PICKER_ENTRIES, type AddTimelineEventOptions, type AddTimelineEventResult, type AsciiDiagramBlockEntry, AsciiDiagramExtension, type AsciiDiagramExtensionOptions, type AsciiDiagramPluginState, type AsciiDiagramView, AsciiDiagramWidget, BlockCardView, type BlockCardViewProps, type BlockNavigator, BlockPropertiesPopover, type BlockPropertiesPopoverProps, type BlockRange, type BlockSlice, type BlockTagVisibility, type CameraStreamOptions, type CanvasRect, type CanvasSink, type CaptureKind, type CodeContext, type CodeContextSection, CodeContextZones, type CustomTemplateContextValue, CustomTemplateProvider, type CustomTemplateProviderProps, type CustomThemeContextValue, CustomThemeProvider, type CustomThemeProviderProps, DEFAULT_TELEPROMPTER_PREFS, DiagramCanvas, type DiagramCommand, type DiagramData, type DiagramEdge, type DiagramNode, type DirectionModel, type DocCustomTemplates, type DocCustomThemes, type DocumentLinkCandidate, type DocumentLinkProvider, DocumentSettingsDialog, type DocumentSettingsDialogProps, type DragContentType, type DropTarget, DropZoneOverlay, type DropZoneOverlayProps, EMPTY_TRANSITION, EYE_LINE_FRACTION, type EditorActions, type EditorColorScheme, type EditorContextValue, type EditorMode, EditorProvider, type EditorProviderProps, EditorShell, type EditorShellProps, type EditorState, type EditorView, EmojiPicker, type EmojiPickerProps, type FileCategory, type FileKind, type FloatOpenOptions, type FloatTier, type FloatingWindowHandle, type FloatingWindowManager, type FolderEntry, FolderView, type FolderViewProps, type HeadingTransitionAttrs, HeadingWithTemplate, type ImageDisplayMode, ImageEditor, type ImageEditorAction, type ImageEditorProps, type ImageEditorState, type ImageEditorTool, ImageViewer, type ImageViewerProps, ImportThemeSection, type ImportThemeSectionProps, type ImportedThemeResult, InlinePreviewGutter, type InlinePreviewGutterProps, JsonEditor, type JsonEditorProps, type LayoutMode, MediaBin, type MediaBinProps, type MediaClipPatch, type MentionCandidate, type MentionProvider, type MicAnalysisHandle, type MicAnalysisStatus, type MonacoWorkerConstructor, type MonacoWorkerConstructors, type NarrationRecorderController, type NarrationRecorderState, type NarrationSavePlan, type NarrationSaveResult, type NarrationTake, OutlinePanel, type OutlinePanelProps, PCM_WORKLET_NAME, PCM_WORKLET_SOURCE, PICKER_CATEGORIES, type PickerCategory, type PickerEntry, PlainHtmlPreview, type PlainHtmlPreviewProps, PreviewFormatSwitch, PreviewModeMenu, PreviewModeSwitch, PreviewPanel, type PreviewPanelProps, type PreviewSettings, PreviewSettingsProvider, PreviewToolbarControls, type PrompterTransport, REPAIRABLE_KEY, RawEditor, type RawEditorProps, type RecordedBookmark, RecorderButton, type RecorderButtonProps, RecorderModal, type RecorderModalProps, RecorderPanel, type RecorderPanelProps, type RecorderSaveResult, type RecorderSource, type RecorderState, type RepairableBlockEntry, RepairableDiagramExtension, type RepairableDiagramExtensionOptions, type RepairablePluginState, type ResolvedFormat, type ScreenStreamHandle, type ScreenStreamOptions, StatusBar, type StatusBarProps, TELEPROMPTER_CSS, TIMELINE_VIEW_KEY, TRANSITION_ENTRIES, TRANSITION_GROUPS, type TeleprompterController, TeleprompterControls, type TeleprompterControlsProps, type TeleprompterPrefs, type TeleprompterRecordingDeps, TeleprompterSurface, type TeleprompterSurfaceProps, TeleprompterView, type TeleprompterViewProps, TemplatePicker, ThemeCustomizerPanel, type ThemeCustomizerPanelProps, type ThemeInheritance, ThemePicker, type ThemePickerProps, type ThemeSaveExtras, type TimelineBlockEntry, type TimelineCommand, type TimelineCommandResult, TimelineEditorWidget, type TimelineEditorWidgetProps, type TimelineEventPatch, TimelineTrack, type TimelineTrackProps, type TimelineViewData, TimelineViewExtension, type TimelineViewExtensionOptions, type TimelineViewPluginState, type TimingJson, type TokenLineMap, Toolbar, type ToolbarProps, TooltipLayer, type TransitionCatalogEntry, type TransitionFields, type TransitionGroup, TransitionPicker, type TransitionPickerProps, type TreeBlockEntry, type TreeCommand, TreeOutlineWidget, type TreeViewData, TreeViewExtension, type TreeViewExtensionOptions, type TreeViewPluginState, 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, addEdgeOp, addItemOp, addNodeOp, addTimelineEventOp, applyAsciiDiagramCommand, applyRepairCommand, applyTimelineCommand, applyTreeCommand, asciiDiagramToCanvas, buildFilename, buildNarrationSavePlan, buildPreviewDoc, buildTimingJson, cameraVideoLine, classifyFile, configureMonacoWorkers, createFloatingWindowManager, detectFloatTiers, detectLanguageFromFileName, draftPatchFromImportedTheme, encodeTimingJson, ensureTeleprompterStyles, executeNarrationSave, findAsciiDiagramBlockPos, findRepairableBlockPos, findTimelineBlockPos, findTransitionEntry, findTreeBlockPos, formatSeconds, getBlockSlices, getCaptureKind, getTimelineForNode, imageEditorReducer, indentItemOp, initialImageEditorState, insertNarrationPreamble, isAsciiSourceVisible, isRepairableFence, isTimelineSourceSafeForSemanticEdit, lineToOffset, markdownToTiptap, measureTokenLines, moveItemDownOp, moveItemUpOp, moveNodeOp, narrationAnnotationLine, nextTimelineEventId, offsetToLine, outdentItemOp, parseTimelineForNode, partitionFiles, processMediaFiles, processTextFile, processTextFiles, prompterVarsFromTheme, readBlockAttrsParams, readBlockAttrsTransition, readBlockAttrsValue, readHeadingLineTransition, registerPcmWorklet, removeEdgeOp, removeItemOp, removeNodeOp, removeTimelineEventOp, renameItemOp, renameNodeOp, replaceAsciiFenceText, replaceAsciiFenceText as replaceTreeFenceText, requestCameraStream, requestMicStream, requestScreenStream, resizeNodeOp, resolveFileKind, resolveFormat, sanitizeAsciiLabel, sanitizeTimelineText, sanitizeTreeLabel, searchPickerEntries, setBlockAttrsValue, setBlockDurationInSource, setHeadingAttrsTransition, setHeadingLineTransition, setMediaClipInSource, shouldPasteAsAsciiFence, shouldPasteAsTimelineFence, shouldPasteAsTreeFence, sliceIndexAtOffset, spliceBlock, stepScroll, summarizeBlockProps, supportsDisplayMedia, supportsMediaRecorder, supportsUserMedia, targetOffsetFor, templateLabel, timingPathFor, tiptapToMarkdown, toggleAsciiSource, toggleDirOp, transitionLabel, updateTimelineEventOp, useAsciiDiagramData, useBlockNavigator, useCustomTemplates, useCustomThemes, useDocCustomTemplates, useDocCustomThemes, useEditorContext, useFileDrop, useFloatingWindow, useImageEditor, useMediaRecorder, useMicAnalysis, useMonacoLoader, useNarrationRecorder, usePreviewSettings, useStreamPreview, useTeleprompter, useTimelineData, useTreeViewData, vadConfigForSensitivity };