@sutrata/editor 0.1.0

package/dist/editor/EditorView.js

@@ -0,0 +1,78 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useRef } from 'react';
+import { EditorState } from 'prosemirror-state';
+import { EditorView as PmEditorView } from 'prosemirror-view';
+import { parse } from '@sutrata/parser';
+import { schema } from './schema';
+import { buildPlugins } from './plugins';
+import { sutraToProsemirror } from './sutra-to-prosemirror';
+import { prosemirrorToSutra } from './prosemirror-to-sutra';
+import { setEditorView, emit } from './editor-bus';
+import { useDocument } from '../context/DocumentContext';
+import { SceneHeadingView } from './scene-heading-view';
+import { FrontmatterFieldView } from './frontmatter-field-view';
+import { applyStyleVars } from '../styles/css-adapter';
+export function EditorView() {
+    const { text, setText, resolvedStyle } = useDocument();
+    const mountRef = useRef(null);
+    const viewRef = useRef(null);
+    const textRef = useRef(text);
+    textRef.current = text;
+    // When true, the next text change originated from the editor itself —
+    // the sync effect must skip it to avoid clobbering in-flight transactions.
+    const selfChangeRef = useRef(false);
+    // Mount once: create ProseMirror view
+    useEffect(() => {
+        if (!mountRef.current)
+            return;
+        const doc = sutraToProsemirror(parse(textRef.current));
+        const state = EditorState.create({ doc, schema, plugins: buildPlugins() });
+        const view = new PmEditorView(mountRef.current, {
+            state,
+            nodeViews: {
+                scene_heading: (node, view, getPos) => new SceneHeadingView(node, view, getPos),
+                frontmatter_field: (node, view, getPos) => new FrontmatterFieldView(node, view, getPos),
+            },
+            dispatchTransaction(tr) {
+                const newState = view.state.apply(tr);
+                view.updateState(newState);
+                if (tr.docChanged) {
+                    const newText = prosemirrorToSutra(newState.doc);
+                    if (newText !== textRef.current) {
+                        selfChangeRef.current = true;
+                        setText(newText);
+                    }
+                }
+                emit();
+            },
+        });
+        viewRef.current = view;
+        setEditorView(view);
+        return () => { setEditorView(null); view.destroy(); viewRef.current = null; };
+    }, []); // eslint-disable-line react-hooks/exhaustive-deps
+    // Sync external text changes into ProseMirror (e.g. switching from source mode).
+    // Skip when the editor itself produced the change — it already has the right state.
+    useEffect(() => {
+        if (selfChangeRef.current) {
+            selfChangeRef.current = false;
+            return;
+        }
+        const view = viewRef.current;
+        if (!view)
+            return;
+        const currentText = prosemirrorToSutra(view.state.doc);
+        if (currentText !== text) {
+            const doc = sutraToProsemirror(parse(text));
+            const state = EditorState.create({ doc, schema, plugins: buildPlugins() });
+            view.updateState(state);
+        }
+    }, [text]);
+    // Apply the document's resolved style as CSS custom properties on the mount element.
+    // Works identically for built-in and user-imported styles — both are plain
+    // ScreenplayStyleDefinition objects by the time they reach here.
+    useEffect(() => {
+        if (mountRef.current)
+            applyStyleVars(mountRef.current, resolvedStyle);
+    }, [resolvedStyle]);
+    return _jsx("div", { ref: mountRef, className: "cs-editor-mount" });
+}

package/dist/editor/SelectionMenu.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function SelectionMenu(): React.JSX.Element | null;

package/dist/editor/SelectionMenu.js

@@ -0,0 +1,102 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { useLanguage } from '../i18n/LanguageContext';
+import { useDocument } from '../context/DocumentContext';
+import { insertSutra } from './insert-helper';
+import { VoiceConfirmDialog } from '../ai/VoiceConfirmDialog';
+import { SparklesIcon } from '../shell/icons';
+const VOICE_LANG_MAP = {
+    en: 'en-US',
+    hi: 'hi-IN',
+    ta: 'ta-IN',
+    te: 'te-IN',
+    ml: 'ml-IN',
+    kn: 'kn-IN',
+    bn: 'bn-IN',
+    gu: 'gu-IN',
+    mr: 'mr-IN',
+};
+function isSelectionInEditor(sel) {
+    if (sel.rangeCount === 0)
+        return false;
+    const range = sel.getRangeAt(0);
+    let node = range.commonAncestorContainer;
+    while (node) {
+        if (node instanceof HTMLElement) {
+            if (node.classList.contains('ProseMirror') || node.classList.contains('cm-content')) {
+                return true;
+            }
+        }
+        node = node.parentNode;
+    }
+    return false;
+}
+export function SelectionMenu() {
+    const { currentLanguage } = useLanguage();
+    const { mode } = useDocument();
+    const [menuPosition, setMenuPosition] = useState(null);
+    const [selectedText, setSelectedText] = useState('');
+    const [showConfirm, setShowConfirm] = useState(false);
+    useEffect(() => {
+        const handleSelectionChange = () => {
+            if (showConfirm)
+                return;
+            const sel = window.getSelection();
+            if (!sel || sel.isCollapsed || !isSelectionInEditor(sel)) {
+                setMenuPosition(null);
+                setSelectedText('');
+                return;
+            }
+            const text = sel.toString().trim();
+            if (!text) {
+                setMenuPosition(null);
+                setSelectedText('');
+                return;
+            }
+            const range = sel.getRangeAt(0);
+            const rect = range.getBoundingClientRect();
+            setMenuPosition({
+                x: rect.left + rect.width / 2,
+                y: rect.top - 8,
+            });
+            setSelectedText(sel.toString());
+        };
+        document.addEventListener('selectionchange', handleSelectionChange);
+        return () => {
+            document.removeEventListener('selectionchange', handleSelectionChange);
+        };
+    }, [showConfirm]);
+    const handleCut = (e) => {
+        e.preventDefault();
+        e.stopPropagation();
+        document.execCommand('cut');
+        setMenuPosition(null);
+    };
+    const handleCopy = (e) => {
+        e.preventDefault();
+        e.stopPropagation();
+        document.execCommand('copy');
+        setMenuPosition(null);
+    };
+    const handleFormat = (e) => {
+        e.preventDefault();
+        e.stopPropagation();
+        setShowConfirm(true);
+        setMenuPosition(null);
+    };
+    if (showConfirm) {
+        const langCode = VOICE_LANG_MAP[currentLanguage] || 'en-US';
+        return (_jsx(VoiceConfirmDialog, { rawTranscript: selectedText, langCode: langCode, onConfirm: (formattedText) => {
+                insertSutra(formattedText, mode);
+                setShowConfirm(false);
+            }, onCancel: () => {
+                setShowConfirm(false);
+            } }));
+    }
+    if (!menuPosition)
+        return null;
+    return (_jsxs("div", { className: "cs-selection-menu", style: {
+            left: `${menuPosition.x}px`,
+            top: `${menuPosition.y}px`,
+        }, role: "toolbar", "aria-label": "Text Selection Actions", children: [_jsxs("button", { type: "button", className: "cs-selection-btn cs-selection-btn-format", onClick: handleFormat, title: "Format selected text using AI", children: [_jsx(SparklesIcon, { size: 12 }), _jsx("span", { children: "Format" })] }), _jsx("div", { className: "cs-selection-sep" }), _jsx("button", { type: "button", className: "cs-selection-btn", onClick: handleCut, children: "Cut" }), _jsx("button", { type: "button", className: "cs-selection-btn", onClick: handleCopy, children: "Copy" })] }));
+}

package/dist/editor/attr-pencil-plugin.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Attribute pencil plugin — uniform inline editing affordance for scene
+ * attributes and title-page frontmatter.
+ *
+ * A pencil widget (visible on hover) sits at the end of every scene heading
+ * and at the top-right of the title page card.
+ *
+ * - Scene heading: opens a dropdown of attribute keys not yet present (plus a
+ *   custom-key input). Picking one inserts the node via a normal PM
+ *   transaction and places the cursor in the empty value, so there is no full
+ *   state rebuild and no cursor jump.
+ * - Title page: opens the sectioned title page form (TitlePageDialog), where
+ *   frontmatter fields are added and edited.
+ */
+import { Plugin, PluginKey } from 'prosemirror-state';
+export declare const attrPencilKey: PluginKey<any>;
+export declare function createAttrPencilPlugin(): Plugin;

package/dist/editor/attr-pencil-plugin.js

@@ -0,0 +1,158 @@
+/**
+ * Attribute pencil plugin — uniform inline editing affordance for scene
+ * attributes and title-page frontmatter.
+ *
+ * A pencil widget (visible on hover) sits at the end of every scene heading
+ * and at the top-right of the title page card.
+ *
+ * - Scene heading: opens a dropdown of attribute keys not yet present (plus a
+ *   custom-key input). Picking one inserts the node via a normal PM
+ *   transaction and places the cursor in the empty value, so there is no full
+ *   state rebuild and no cursor jump.
+ * - Title page: opens the sectioned title page form (TitlePageDialog), where
+ *   frontmatter fields are added and edited.
+ */
+import { Plugin, PluginKey, TextSelection } from 'prosemirror-state';
+import { Decoration, DecorationSet } from 'prosemirror-view';
+import { schema } from './schema';
+import { openTitlePageForm } from './editor-bus';
+const SCENE_META_KEYS = ['synopsis', 'status', 'tags', 'location', 'time', 'lang'];
+let openMenu = null;
+function closeMenu() {
+    if (openMenu) {
+        openMenu.remove();
+        openMenu = null;
+        document.removeEventListener('mousedown', onDocMousedown);
+    }
+}
+function onDocMousedown(e) {
+    if (openMenu && !openMenu.contains(e.target))
+        closeMenu();
+}
+function showMenu(anchor, options, onPick) {
+    closeMenu();
+    const menu = document.createElement('div');
+    menu.className = 'cs-attr-menu';
+    for (const key of options) {
+        const item = document.createElement('button');
+        item.type = 'button';
+        item.className = 'cs-attr-menu-item';
+        item.textContent = `+ ${key}`;
+        item.addEventListener('mousedown', e => {
+            e.preventDefault();
+            closeMenu();
+            onPick(key);
+        });
+        menu.appendChild(item);
+    }
+    const customRow = document.createElement('div');
+    customRow.className = 'cs-attr-menu-custom';
+    const input = document.createElement('input');
+    input.type = 'text';
+    input.placeholder = 'custom key…';
+    input.addEventListener('keydown', e => {
+        e.stopPropagation();
+        if (e.key === 'Enter') {
+            const k = input.value.trim();
+            if (k) {
+                closeMenu();
+                onPick(k);
+            }
+        }
+        else if (e.key === 'Escape') {
+            closeMenu();
+        }
+    });
+    input.addEventListener('mousedown', e => e.stopPropagation());
+    customRow.appendChild(input);
+    menu.appendChild(customRow);
+    const rect = anchor.getBoundingClientRect();
+    menu.style.left = `${rect.left}px`;
+    menu.style.top = `${rect.bottom + 4}px`;
+    document.body.appendChild(menu);
+    openMenu = menu;
+    // Defer so the click that opened the menu doesn't immediately close it
+    setTimeout(() => document.addEventListener('mousedown', onDocMousedown), 0);
+    input.focus();
+}
+/** Insert an attribute node and place the cursor inside its (empty) content. */
+function insertNode(view, pos, node) {
+    const tr = view.state.tr.insert(pos, node);
+    view.dispatch(tr.setSelection(TextSelection.near(tr.doc.resolve(pos + 1))));
+    view.focus();
+}
+/**
+ * For a scene heading at top-level index `index`, compute which attribute
+ * keys already exist and where a new attribute line should be inserted
+ * (after the heading, synopsis, and existing metadata lines).
+ */
+function sceneAttrContext(view, headingPos) {
+    const doc = view.state.doc;
+    const $heading = doc.resolve(headingPos);
+    const headingNode = doc.nodeAt(headingPos);
+    let pos = headingPos + headingNode.nodeSize;
+    let index = $heading.index(0) + 1;
+    const presentKeys = new Set();
+    while (index < doc.childCount) {
+        const sibling = doc.child(index);
+        if (sibling.type.name === 'scene_metadata') {
+            presentKeys.add(sibling.attrs['metaKey']);
+        }
+        else {
+            break;
+        }
+        pos += sibling.nodeSize;
+        index++;
+    }
+    return { insertPos: pos, presentKeys };
+}
+function makePencil(className, title, onClick) {
+    const btn = document.createElement('button');
+    btn.type = 'button';
+    btn.className = className;
+    btn.title = title;
+    btn.textContent = '✎';
+    btn.contentEditable = 'false';
+    btn.addEventListener('mousedown', e => {
+        e.preventDefault();
+        e.stopPropagation();
+        onClick(btn);
+    });
+    return btn;
+}
+export const attrPencilKey = new PluginKey('attrPencil');
+export function createAttrPencilPlugin() {
+    return new Plugin({
+        key: attrPencilKey,
+        props: {
+            decorations(state) {
+                const decos = [];
+                state.doc.forEach((node, offset) => {
+                    if (node.type.name === 'scene_heading') {
+                        // Widget inside the heading, after its text
+                        decos.push(Decoration.widget(offset + node.nodeSize - 1, view => makePencil('cs-attr-pencil', 'Add scene attribute', btn => {
+                            const ctx = sceneAttrContext(view, offset);
+                            const options = SCENE_META_KEYS.filter(k => !ctx.presentKeys.has(k));
+                            showMenu(btn, options, key => {
+                                const fresh = sceneAttrContext(view, offset);
+                                insertNode(view, fresh.insertPos, schema.nodes['scene_metadata'].create({ metaKey: key }));
+                            });
+                        }), { side: 1 }));
+                    }
+                    if (node.type.name === 'title_page') {
+                        // Title page fields are added and edited in the title page form; the pencil
+                        // (top-right of the card, positioned by CSS) opens it.
+                        decos.push(Decoration.widget(offset + 1, () => makePencil('cs-attr-pencil cs-tp-pencil', 'Edit title page', () => {
+                            closeMenu();
+                            openTitlePageForm();
+                        }), { side: -1, key: 'tp-pencil' }));
+                    }
+                });
+                return DecorationSet.create(state.doc, decos);
+            },
+        },
+        view() {
+            return { destroy: closeMenu };
+        },
+    });
+}

package/dist/editor/character-decoration-plugin.d.ts

@@ -0,0 +1,26 @@
+import { Plugin } from 'prosemirror-state';
+import { DecorationSet } from 'prosemirror-view';
+/**
+ * ProseMirror plugin that styles a character cue's trailing extension
+ * "(V.O.)"/"(O.S.)" and dual-dialogue "^" marker live, purely from the text
+ * pattern — there's no dedicated UI to set these; per the format spec, any
+ * content in parentheses at the end of a character line is an extension,
+ * and a trailing "^" marks dual dialogue. No node attrs or persisted marks
+ * are involved — decorations are recomputed from scratch on every doc
+ * change, the same way createLanguageClassPlugin() does for script classes.
+ */
+export declare function createCharacterDecorationPlugin(): Plugin<DecorationSet>;
+interface DecorationRanges {
+    parenStart?: number;
+    parenEnd?: number;
+    dualStart?: number;
+    dualEnd?: number;
+}
+/**
+ * Finds the trailing "(...)"-group span and/or trailing "^" span in a
+ * character cue's text, as character offsets into `text`. Either, both, or
+ * neither may be present. The "^" is checked (and stripped from
+ * consideration) first, since it comes after any extension groups.
+ */
+export declare function findCharacterDecorationRanges(text: string): DecorationRanges;
+export {};

package/dist/editor/character-decoration-plugin.js

@@ -0,0 +1,77 @@
+import { Plugin } from 'prosemirror-state';
+import { Decoration, DecorationSet } from 'prosemirror-view';
+/**
+ * ProseMirror plugin that styles a character cue's trailing extension
+ * "(V.O.)"/"(O.S.)" and dual-dialogue "^" marker live, purely from the text
+ * pattern — there's no dedicated UI to set these; per the format spec, any
+ * content in parentheses at the end of a character line is an extension,
+ * and a trailing "^" marks dual dialogue. No node attrs or persisted marks
+ * are involved — decorations are recomputed from scratch on every doc
+ * change, the same way createLanguageClassPlugin() does for script classes.
+ */
+export function createCharacterDecorationPlugin() {
+    return new Plugin({
+        state: {
+            init(_config, state) {
+                return computeDecorations(state.doc);
+            },
+            apply(tr, set, _oldState, newState) {
+                if (tr.docChanged) {
+                    return computeDecorations(newState.doc);
+                }
+                return set;
+            },
+        },
+        props: {
+            decorations(state) {
+                return this.getState(state);
+            },
+        },
+    });
+}
+/**
+ * Finds the trailing "(...)"-group span and/or trailing "^" span in a
+ * character cue's text, as character offsets into `text`. Either, both, or
+ * neither may be present. The "^" is checked (and stripped from
+ * consideration) first, since it comes after any extension groups.
+ */
+export function findCharacterDecorationRanges(text) {
+    const ranges = {};
+    let working = text;
+    const dualMatch = /\s(\^)\s*$/.exec(text);
+    if (dualMatch) {
+        ranges.dualStart = dualMatch.index + dualMatch[0].indexOf('^');
+        ranges.dualEnd = ranges.dualStart + 1;
+        working = text.slice(0, dualMatch.index);
+    }
+    const parenMatch = /(\s+\([^()]*\))+\s*$/.exec(working);
+    if (parenMatch) {
+        const matched = parenMatch[0];
+        const leadingWs = matched.length - matched.trimStart().length;
+        ranges.parenStart = parenMatch.index + leadingWs;
+        ranges.parenEnd = parenMatch.index + matched.trimEnd().length;
+    }
+    return ranges;
+}
+function computeDecorations(doc) {
+    const decorations = [];
+    doc.forEach((node, pos) => {
+        if (node.type.name !== 'character')
+            return;
+        const text = node.textContent;
+        if (!text)
+            return;
+        const { parenStart, parenEnd, dualStart, dualEnd } = findCharacterDecorationRanges(text);
+        // +1: text content starts one position inside the block node
+        const contentStart = pos + 1;
+        if (parenStart !== undefined && parenEnd !== undefined) {
+            // class passed in both attrs (DOM rendering) and spec (testing/reference) —
+            // matches language-class-plugin.ts's convention.
+            decorations.push(Decoration.inline(contentStart + parenStart, contentStart + parenEnd, { class: 'cs-character-extension' }, { class: 'cs-character-extension' }));
+        }
+        if (dualStart !== undefined && dualEnd !== undefined) {
+            decorations.push(Decoration.inline(contentStart + dualStart, contentStart + dualEnd, { class: 'cs-character-dual-marker' }, { class: 'cs-character-dual-marker' }));
+        }
+    });
+    return DecorationSet.create(doc, decorations);
+}

package/dist/editor/character-view.d.ts

@@ -0,0 +1,35 @@
+import type { Node as PmNode } from 'prosemirror-model';
+import type { EditorView, NodeView, ViewMutationRecord } from 'prosemirror-view';
+/**
+ * NodeView for character. Renders the name text (ProseMirror-managed) plus
+ * an editable extension input — "(V.O.)", "(O.S.)", etc. — on the right.
+ *
+ * Without this, character used the schema's plain static toDOM spec
+ * (['div', {class:'cs-character'}, 0]), whose content hole only renders
+ * PM's managed inline content (the name). extension is a real, populated
+ * node attr (captured correctly by the parser and carried correctly by
+ * sutra-to-prosemirror.ts/prosemirror-to-sutra.ts both ways) but nothing
+ * ever painted it to the screen — it was silently invisible. Mirrors
+ * SceneHeadingView's pattern for the same kind of "attr needs its own
+ * visible, editable-but-outside-the-PM-content-model widget" problem.
+ *
+ * The extension value is stored (and round-tripped to Sutra text) *with*
+ * its parentheses, e.g. "(V.O.)" — matching what the parser's CHARACTER
+ * regex captures — so a typed value without parens is auto-wrapped on commit.
+ */
+export declare class CharacterView implements NodeView {
+    dom: HTMLElement;
+    contentDOM: HTMLElement;
+    private input;
+    private pmView;
+    private getPos;
+    constructor(node: PmNode, view: EditorView, getPos: () => number | undefined);
+    private commit;
+    private focusEditorAfter;
+    private onInputKeydown;
+    private onInputBlur;
+    update(node: PmNode): boolean;
+    destroy(): void;
+    stopEvent(event: Event): boolean;
+    ignoreMutation(mutation: ViewMutationRecord): boolean;
+}

package/dist/editor/character-view.js

@@ -0,0 +1,112 @@
+import { TextSelection } from 'prosemirror-state';
+/**
+ * NodeView for character. Renders the name text (ProseMirror-managed) plus
+ * an editable extension input — "(V.O.)", "(O.S.)", etc. — on the right.
+ *
+ * Without this, character used the schema's plain static toDOM spec
+ * (['div', {class:'cs-character'}, 0]), whose content hole only renders
+ * PM's managed inline content (the name). extension is a real, populated
+ * node attr (captured correctly by the parser and carried correctly by
+ * sutra-to-prosemirror.ts/prosemirror-to-sutra.ts both ways) but nothing
+ * ever painted it to the screen — it was silently invisible. Mirrors
+ * SceneHeadingView's pattern for the same kind of "attr needs its own
+ * visible, editable-but-outside-the-PM-content-model widget" problem.
+ *
+ * The extension value is stored (and round-tripped to Sutra text) *with*
+ * its parentheses, e.g. "(V.O.)" — matching what the parser's CHARACTER
+ * regex captures — so a typed value without parens is auto-wrapped on commit.
+ */
+export class CharacterView {
+    dom;
+    contentDOM;
+    input;
+    pmView;
+    getPos;
+    constructor(node, view, getPos) {
+        this.pmView = view;
+        this.getPos = getPos;
+        this.dom = document.createElement('div');
+        this.dom.className = 'cs-character';
+        this.contentDOM = document.createElement('span');
+        this.contentDOM.className = 'cs-character-text';
+        this.dom.appendChild(this.contentDOM);
+        this.input = document.createElement('input');
+        this.input.type = 'text';
+        this.input.className = 'cs-character-extension';
+        this.input.placeholder = '(V.O.)';
+        this.input.value = node.attrs['extension'] ?? '';
+        this.input.setAttribute('aria-label', 'Character extension, e.g. (V.O.) or (O.S.)');
+        this.input.spellcheck = false;
+        this.input.addEventListener('keydown', this.onInputKeydown);
+        this.input.addEventListener('blur', this.onInputBlur);
+        this.input.addEventListener('mousedown', (e) => e.stopPropagation());
+        this.dom.appendChild(this.input);
+    }
+    commit() {
+        const raw = this.input.value.trim();
+        let extension = raw === '' ? null : raw;
+        if (extension && !(extension.startsWith('(') && extension.endsWith(')'))) {
+            extension = `(${extension})`;
+        }
+        this.input.value = extension ?? '';
+        const pos = this.getPos();
+        if (pos === undefined)
+            return;
+        const node = this.pmView.state.doc.nodeAt(pos);
+        if (!node)
+            return;
+        if (node.attrs['extension'] === extension)
+            return;
+        const tr = this.pmView.state.tr.setNodeMarkup(pos, undefined, { ...node.attrs, extension });
+        this.pmView.dispatch(tr);
+    }
+    focusEditorAfter() {
+        const pos = this.getPos();
+        if (pos === undefined)
+            return;
+        const node = this.pmView.state.doc.nodeAt(pos);
+        if (!node)
+            return;
+        const endOfText = pos + node.nodeSize - 1;
+        const sel = TextSelection.near(this.pmView.state.doc.resolve(endOfText), -1);
+        this.pmView.dispatch(this.pmView.state.tr.setSelection(sel));
+        this.pmView.focus();
+    }
+    onInputKeydown = (e) => {
+        if (e.key === 'Escape') {
+            e.preventDefault();
+            e.stopPropagation();
+            this.input.value = this.pmView.state.doc.nodeAt(this.getPos() ?? 0)?.attrs['extension'] ?? '';
+            this.pmView.focus();
+            return;
+        }
+        if (e.key === 'Enter' || e.key === 'Tab') {
+            e.preventDefault();
+            e.stopPropagation();
+            this.commit();
+            this.focusEditorAfter();
+            return;
+        }
+    };
+    onInputBlur = () => {
+        this.commit();
+    };
+    update(node) {
+        if (node.type.name !== 'character')
+            return false;
+        if (document.activeElement !== this.input) {
+            this.input.value = node.attrs['extension'] ?? '';
+        }
+        return true;
+    }
+    destroy() {
+        this.input.removeEventListener('keydown', this.onInputKeydown);
+        this.input.removeEventListener('blur', this.onInputBlur);
+    }
+    stopEvent(event) {
+        return event.target === this.input || this.input.contains(event.target);
+    }
+    ignoreMutation(mutation) {
+        return this.input.contains(mutation.target) || mutation.target === this.input;
+    }
+}

package/dist/editor/editor-bus.d.ts

@@ -0,0 +1,14 @@
+import type { EditorView } from 'prosemirror-view';
+import type { Command } from 'prosemirror-state';
+import type { EditorView as CmEditorView } from '@codemirror/view';
+export declare function setEditorView(view: EditorView | null): void;
+export declare function getEditorView(): EditorView | null;
+export declare function setSourceView(view: CmEditorView | null): void;
+export declare function getSourceView(): CmEditorView | null;
+export declare function runCommand(cmd: Command): void;
+export declare function activeBlockType(): string | null;
+export declare function subscribe(fn: () => void): () => void;
+export declare function emit(): void;
+/** Window event that opens the title page form (TitlePageDialog, mounted by AppShell). */
+export declare const OPEN_TITLE_PAGE_EVENT = "cs:open-title-page";
+export declare function openTitlePageForm(): void;

package/dist/editor/editor-bus.js

@@ -0,0 +1,39 @@
+let currentView = null;
+let currentSourceView = null;
+const listeners = new Set();
+export function setEditorView(view) {
+    currentView = view;
+    emit();
+}
+export function getEditorView() {
+    return currentView;
+}
+export function setSourceView(view) {
+    currentSourceView = view;
+}
+export function getSourceView() {
+    return currentSourceView;
+}
+export function runCommand(cmd) {
+    if (!currentView)
+        return;
+    cmd(currentView.state, currentView.dispatch, currentView);
+    currentView.focus();
+}
+export function activeBlockType() {
+    if (!currentView)
+        return null;
+    return currentView.state.selection.$from.parent.type.name;
+}
+export function subscribe(fn) {
+    listeners.add(fn);
+    return () => listeners.delete(fn);
+}
+export function emit() {
+    listeners.forEach(fn => fn());
+}
+/** Window event that opens the title page form (TitlePageDialog, mounted by AppShell). */
+export const OPEN_TITLE_PAGE_EVENT = 'cs:open-title-page';
+export function openTitlePageForm() {
+    window.dispatchEvent(new CustomEvent(OPEN_TITLE_PAGE_EVENT));
+}

package/dist/editor/find-highlight-plugin.d.ts

@@ -0,0 +1,7 @@
+import { Plugin } from 'prosemirror-state';
+import type { PmMatch } from '../findreplace/scroll-to-match';
+/** Called by FindReplace whenever matches or active index change. */
+export declare function setFindHighlights(matches: PmMatch[], activeIndex: number): void;
+/** Called by FindReplace when the panel closes — clears all highlights. */
+export declare function clearFindHighlights(): void;
+export declare function createFindHighlightPlugin(): Plugin;