@stll/folio-vue 0.2.0

package/dist/composables/useControllableBoolean.d.ts

@@ -0,0 +1,16 @@
+import { WritableComputedRef } from 'vue';
+/**
+ * A boolean that can run either controlled or uncontrolled, exposed as a
+ * writable ref so existing call sites can keep mutating `.value` directly.
+ *
+ * - Controlled (`controlled()` returns a boolean): the prop is the source of
+ *   truth. Internal state is bypassed; writes only call `onChange` (if provided)
+ *   and the consumer decides whether to honor them.
+ * - Uncontrolled (`controlled()` returns `undefined`): the composable owns the
+ *   value, and writes update internal state and call `onChange` so consumers can
+ *   observe without owning state.
+ *
+ * `onChange` is optional and does not fire when the value would be unchanged.
+ * Mirrors the React adapter's `useControllableBoolean` hook.
+ */
+export declare function useControllableBoolean(controlled: () => boolean | undefined, onChange?: (value: boolean) => void, defaultValue?: boolean): WritableComputedRef<boolean>;

package/dist/composables/useDocumentLifecycle.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+import { Document } from '@stll/folio-core/types/document';
+import { DocxInput } from '@stll/folio-core/utils/docxInput';
+export type UseDocumentLifecycleOptions = {
+    documentBuffer: () => DocxInput | null;
+    document: () => Document | null;
+    loadDocumentBuffer: (buffer: DocxInput) => Promise<void>;
+    loadDocument: (doc: Document) => void;
+    sidebarAutoOpenedRef: Ref<boolean>;
+};
+export declare function useDocumentLifecycle(opts: UseDocumentLifecycleOptions): void;

package/dist/composables/useDocxEditor.d.ts

@@ -0,0 +1,123 @@
+import { MaybeRefOrGetter, Ref } from 'vue';
+import { EditorState, Plugin } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import { FolioEditor } from '@stll/folio-core/controller/folioEditor';
+import { FolioSelectiveSaveFlags } from '@stll/folio-core/docx/selectiveSaveFlags';
+import { TripwireResult } from '@stll/folio-core/docx/selectiveSaveTripwire';
+import { FlowBlock, Layout, Measure } from '@stll/folio-core/layout-engine/types';
+import { CommandMap } from '@stll/folio-core/prosemirror/extensions/types';
+import { AnonymizationMatch } from '@stll/folio-core/prosemirror/plugins/anonymizationDecorations';
+import { TemplateSlashMenuKeyAction, TemplateSlashMenuState } from '@stll/folio-core/prosemirror/plugins/templateSlashMenu';
+import { Document } from '@stll/folio-core/types/document';
+import { DocxInput } from '@stll/folio-core/utils/docxInput';
+export type UseDocxEditorOptions = {
+    /** Container element that hosts the off-screen ProseMirror editor. */
+    hiddenContainer: Ref<HTMLElement | null>;
+    /** Container element the paginated pages are painted into. */
+    pagesContainer: Ref<HTMLElement | null>;
+    /** Whether the editor is read-only. Reactive. */
+    readOnly?: MaybeRefOrGetter<boolean>;
+    /** Gap between pages in pixels. */
+    pageGap?: number;
+    /**
+     * Stable identity of the loaded document (same across internal edits, distinct
+     * per loaded file). Threaded to the hidden-editor manager's external-load
+     * detection. Reactive.
+     */
+    documentKey?: MaybeRefOrGetter<string | undefined>;
+    /**
+     * Editor mode. `'suggesting'` activates the mounted suggestion-mode plugin so
+     * typed text becomes tracked changes. Reactive — flip at runtime.
+     */
+    editorMode?: MaybeRefOrGetter<"editing" | "suggesting" | "viewing">;
+    /** Author name attached to tracked changes minted in suggesting mode. */
+    author?: MaybeRefOrGetter<string>;
+    /** External ProseMirror plugins supplied by the host app. */
+    externalPlugins?: Plugin[];
+    /**
+     * Fires with the anonymization decoration plugin's current match list on
+     * mount, term push, and every doc edit. The anonymization plugin is always
+     * installed (inert until terms are pushed via `setAnonymizationTermsMeta`),
+     * mirroring the React adapter.
+     */
+    onAnonymizationMatchesChange?: (matches: readonly AnonymizationMatch[]) => void;
+    /**
+     * Install the template-directive + slash-menu plugins so `{{...}}` markers are
+     * scanned and the `/` trigger is active. Reactive: toggling reconfigures the
+     * live view's plugin set. Off for ordinary documents; on for the template
+     * editor. Mirrors React's `showTemplateDirectives` plugin gate.
+     */
+    showTemplateDirectives?: MaybeRefOrGetter<boolean | undefined>;
+    /** Fires when the slash-menu trigger opens, its query changes, or it closes. */
+    onSlashMenuChange?: (state: TemplateSlashMenuState) => void;
+    /** Resolves a navigation/commit key while the slash menu is open. */
+    onSlashMenuKeyAction?: (action: TemplateSlashMenuKeyAction) => boolean;
+    /** Callback on document change (debounced PM → Document model conversion). */
+    onChange?: (doc: Document) => void;
+    /** Callback on parse / layout / lifecycle error. */
+    onError?: (error: Error) => void;
+    /** Callback on every selection-bearing transaction. */
+    onSelectionUpdate?: (state: EditorState) => void;
+    /** Callback when the hidden EditorView is created or torn down. */
+    onEditorViewReady?: (view: EditorView | null) => void;
+    /** Callback when a read-only user action would mutate the document. */
+    onReadOnlyEditAttempt?: () => void;
+    /**
+     * Operational flags for the save path. Selective save and its tripwire mode
+     * are off by default; hosts opt in once their rollout pipeline is ready.
+     * Reactive — read fresh on each `save()`. Mirrors React's `featureFlags`.
+     */
+    featureFlags?: MaybeRefOrGetter<FolioSelectiveSaveFlags | undefined>;
+    /**
+     * Fired with the structured selective-vs-full comparison after a save when
+     * {@link FolioSelectiveSaveFlags.selectiveSaveTripwire} is on. Observability
+     * only — never blocks or poisons the save. Mirrors React's callback.
+     */
+    onSelectiveSaveTripwire?: ((result: TripwireResult) => void) | undefined;
+};
+export type UseDocxEditorReturn = {
+    /** The headless controller (imperative API + layout access + events). */
+    editor: FolioEditor;
+    /** Off-screen ProseMirror EditorView, or null before mount. */
+    editorView: Ref<EditorView | null>;
+    /** Latest editor state, updated on each transaction. */
+    editorState: Ref<EditorState | null>;
+    /** True once the hidden view is mounted and a document is loaded. */
+    isReady: Ref<boolean>;
+    /**
+     * True when the live PM state has doc edits not yet serialized by `save()`.
+     * Set on every doc-changing transaction, cleared on a successful save and on
+     * document load/swap. Backs the ref API's `hasPendingChanges` (OR-ed with the
+     * comment-list dirty flag).
+     */
+    isDirty: Ref<boolean>;
+    /** Last parse error message, or null if the most recent load succeeded. */
+    parseError: Ref<string | null>;
+    /** Computed page layout, or null before first paint. */
+    layout: Ref<Layout | null>;
+    /** Flow blocks from the latest layout pass — the range-projection fallback. */
+    blocks: Ref<FlowBlock[]>;
+    /** Measures from the latest layout pass — the range-projection fallback. */
+    measures: Ref<Measure[]>;
+    /** Load a DOCX from a binary buffer / Blob / File. */
+    loadBuffer: (buffer: DocxInput) => Promise<void>;
+    /** Load an already-parsed `Document` directly. */
+    loadDocument: (doc: Document) => void;
+    /** Serialize the current document to a DOCX blob. */
+    save: (options?: {
+        selective?: boolean;
+    }) => Promise<Blob | null>;
+    /** Snapshot the current document model. */
+    getDocument: () => Document | null;
+    /** Publish a fresh Document object (e.g. after HF materialisation). */
+    setDocument: (doc: Document) => void;
+    /** Access the extension command map for invoking marks / nodes / features. */
+    getCommands: () => CommandMap;
+    /** Focus the hidden ProseMirror view. */
+    focus: () => void;
+    /** Force a re-layout without a doc change (e.g. after page-setup edits). */
+    reLayout: () => void;
+    /** Destroy the editor view and clean up listeners. */
+    destroy: () => void;
+};
+export declare function useDocxEditor(options: UseDocxEditorOptions): UseDocxEditorReturn;

package/dist/composables/useDocxEditorRefApi.d.ts

@@ -0,0 +1,68 @@
+import { Ref } from 'vue';
+import { EditorView } from 'prosemirror-view';
+import { FolioEditor } from '@stll/folio-core/controller/folioEditor';
+import { Layout } from '@stll/folio-core/layout-engine';
+import { Document } from '@stll/folio-core/types/document';
+import { DocxInput } from '@stll/folio-core/utils/docxInput';
+import { DocxEditorRef } from '../components/DocxEditor/types';
+export type UseDocxEditorRefApiOptions = {
+    /** Headless controller handle (imperative API + events; Seam 6). */
+    editor: FolioEditor;
+    /** Off-screen ProseMirror EditorView, or null before mount. */
+    editorView: Ref<EditorView | null>;
+    /**
+     * Doc-dirty flag from useDocxEditor: live PM edits not yet serialized. Backs
+     * the doc side of `hasPendingChanges` (React's ParagraphChangeTracker signals).
+     */
+    isDirty: Readonly<Ref<boolean>>;
+    /**
+     * Comment-list dirty flag from useCommentManagement: comment mutations not yet
+     * serialized. Backs the comment side of `hasPendingChanges` (React's
+     * `commentsDirtyRef`).
+     */
+    commentsDirty: Readonly<Ref<boolean>>;
+    /**
+     * Clear {@link commentsDirty} after a successful save. Called from the `save`
+     * wrapper below — the single public save entry point — so the comment flag is
+     * reset alongside useDocxEditor's doc-dirty flag, mirroring React's handleSave.
+     */
+    clearCommentsDirty: () => void;
+    /** Computed page layout, or null before first paint. */
+    layout: Ref<Layout | null>;
+    /** Painted pages container (the `HTMLDivElement` the painter writes into). */
+    pagesRef: Ref<HTMLElement | null>;
+    /** Scrolling viewport wrapping the pages container. */
+    pagesViewportRef: Ref<HTMLElement | null>;
+    /** Current zoom factor (1 = 100%). */
+    zoom: Ref<number>;
+    /**
+     * Scroll the pages viewport so a PM document position is visible (from
+     * usePagesPointer). Backs the AI-edit / content-control scroll methods, the
+     * Vue analogue of React's `PagedEditorRef.scrollToPosition`.
+     */
+    scrollVisiblePositionIntoView: (pmPos: number) => void;
+    /** Editor author, used as the default operation author for AI edits. */
+    author: () => string;
+    /**
+     * Mint a comment for an AI-edit operation that carries comment text, append
+     * it to the thread list, and return its id (mirrors React's `createCommentId`
+     * closure over the comment manager). Wired from useCommentManagement.
+     */
+    createAIEditComment: (text: string) => number;
+    focus: () => void;
+    getDocument: () => Document | null;
+    setZoom: (zoom: number) => void;
+    /** useDocxEditor.save returns a Blob; the ref surface exposes an ArrayBuffer. */
+    save: (options?: {
+        selective?: boolean;
+    }) => Promise<Blob | null>;
+    loadDocument: (doc: Document) => void;
+    loadDocumentBuffer: (buffer: DocxInput) => Promise<void>;
+    /** Optional host hook for print. */
+    onPrint?: (() => void) | undefined;
+    /** Optional host hook fired with the serialized `.docx` bytes after `save()`. */
+    onSave?: ((buffer: ArrayBuffer) => void) | undefined;
+};
+export declare function useDocxEditorRefApi(opts: UseDocxEditorRefApiOptions): {
+    exposed: DocxEditorRef;
+};

package/dist/composables/useDragAutoScroll.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+export type DragAutoScrollOptions = {
+    pagesContainer: Ref<HTMLElement | null>;
+    /** Called during auto-scroll to extend the selection at the current mouse position. */
+    onScrollExtendSelection: (clientX: number, clientY: number) => void;
+};
+export type UseDragAutoScrollReturn = {
+    updateMousePosition: (clientX: number, clientY: number) => void;
+    stopAutoScroll: () => void;
+};
+export declare function useDragAutoScroll({ pagesContainer, onScrollExtendSelection, }: DragAutoScrollOptions): UseDragAutoScrollReturn;

package/dist/composables/useFileIO.d.ts

@@ -0,0 +1,43 @@
+import { EditorView } from 'prosemirror-view';
+import { Document } from '@stll/folio-core/types/document';
+type DocxBufferInput = ArrayBuffer | Uint8Array | Blob | File;
+export type UseFileIOOptions = {
+    /** From useDocxEditor — loads a .docx buffer into the editor. */
+    loadBuffer: (buffer: DocxBufferInput) => Promise<void>;
+    /**
+     * Host override for File > Open / Cmd+O. When provided, the picked file is
+     * passed here instead of running the built-in local load — lets consumers
+     * route Open through their own import pipeline (e.g. a CRDT backend).
+     */
+    onOpen?: (file: File) => void | Promise<void>;
+    /** From useDocxEditor — loads an already-parsed Document model. */
+    loadParsedDocument: (doc: Document) => void;
+    /** From useDocxEditor — returns the current Document, or null. */
+    getDocument: () => Document | null;
+    /** From useDocxEditor — serializes the current state to a .docx Blob. */
+    saveBlob: () => Promise<Blob | null>;
+    /** Fired after load+extract so the next tick sees comments/tracked-changes. */
+    extractCommentsAndChanges: () => void;
+    /** SFC's emit function — re-emits ready / rename / update:document / error. */
+    emit: (event: string, ...args: unknown[]) => void;
+    /** Accessor — read freshly inside the handler so prop updates are honored. */
+    documentName: () => string | undefined;
+    onDocumentNameChange?: (name: string) => void;
+    /** Active editor view to insert images into — the header/footer being edited, else the body. */
+    getActiveView: () => EditorView | null;
+    /** Vue's `nextTick` — passed in so the composable doesn't require its own import wiring. */
+    nextTick: () => Promise<void>;
+};
+export declare function useFileIO(opts: UseFileIOOptions): {
+    docxInputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+    imageInputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+    handleImageFileChange: (event: Event) => void;
+    handleDocxFileChange: (event: Event) => Promise<void>;
+    handleDocumentNameChange: (name: string) => void;
+    downloadCurrentDocument: () => Promise<void>;
+    emitReadyAfterSidebarStateRefresh: () => Promise<void>;
+    loadDocumentBuffer: (buffer: DocxBufferInput) => Promise<void>;
+    loadDocument: (doc: Document) => void;
+    save: () => Promise<ArrayBuffer | null>;
+};
+export {};

package/dist/composables/useFindReplace.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Vue port of the find/replace UI-state container.
+ *
+ * PORT-BLOCKED (missing `utils/findReplace` UI-util): upstream builds this
+ * composable's entire state on three symbols from
+ * `@eigenpal/docx-editor-core/utils/findReplace` — the `FindMatch` and
+ * `FindOptions` data contracts and the `createDefaultFindOptions()` factory.
+ * That util is absent from our fork: it is neither in `@stll/folio-core`
+ * (whose search surface is the lower-level `prosemirror/findReplaceSelection`
+ * `FindMatchPosition` + `managers/FindReplaceManager`, a different shape) nor
+ * in our ported Vue `../utils/*`. Every field of the reactive state
+ * (`options: createDefaultFindOptions()`, `matches: FindMatch[]`, the
+ * `currentMatch`/`setMatches`/`goToMatch` surface) depends on those types, so
+ * there is no working subset to port without fabricating the data contract.
+ *
+ * Unblock: port upstream `packages/core/src/utils/findReplace.ts` (pure, no
+ * runtime deps) into the Vue package as `../utils/findReplace.ts`, reconciling
+ * its `FindMatch`/`FindOptions` with core's `FindMatchPosition` /
+ * `FindReplaceManager`, then restore the full composable — its body is a direct
+ * `reactive()` translation of the React hook with no other blockers.
+ */
+export {};

package/dist/composables/useFixedDropdown.d.ts

@@ -0,0 +1,14 @@
+import { Ref, CSSProperties } from 'vue';
+export type UseFixedDropdownOptions = {
+    isOpen: Ref<boolean>;
+    onClose: () => void;
+    /** 'left' aligns dropdown left edge to trigger, 'right' aligns right edge. */
+    align?: "left" | "right";
+};
+export type UseFixedDropdownReturn = {
+    containerRef: Ref<HTMLElement | null>;
+    dropdownRef: Ref<HTMLElement | null>;
+    dropdownStyle: Ref<CSSProperties>;
+    handleMouseDown: (e: MouseEvent) => void;
+};
+export declare function useFixedDropdown({ isOpen, onClose, align, }: UseFixedDropdownOptions): UseFixedDropdownReturn;

package/dist/composables/useFormattingActions.d.ts

@@ -0,0 +1,21 @@
+import { Ref } from 'vue';
+import { EditorView } from 'prosemirror-view';
+import { Document } from '@stll/folio-core/types/document';
+export type UseFormattingActionsOptions = {
+    editorView: Ref<EditorView | null>;
+    /**
+     * The view interactive toolbar formatting should target. While a header or
+     * footer is being edited this is its EditorView, so toolbar actions land in
+     * the HF and not the body (#749). Falls back to the body `editorView`.
+     */
+    activeView?: Ref<EditorView | null>;
+    getDocument: () => Document | null;
+};
+export declare function useFormattingActions(opts: UseFormattingActionsOptions): {
+    handleClearFormatting: () => void;
+    handleApplyStyle: (styleId: string) => void;
+    handleInsertPageBreak: () => void;
+    handleInsertSectionBreakNextPage: () => void;
+    handleInsertSectionBreakContinuous: () => void;
+    handleInsertSymbol: (symbol: string) => void;
+};

package/dist/composables/useHistory.d.ts

@@ -0,0 +1,9 @@
+import { ComputedRef, Ref } from 'vue';
+import { EditorView } from 'prosemirror-view';
+export type UseHistoryReturn = {
+    canUndo: ComputedRef<boolean>;
+    canRedo: ComputedRef<boolean>;
+    undo: () => boolean;
+    redo: () => boolean;
+};
+export declare function useHistory(view: Ref<EditorView | null>, stateTick: Ref<number>): UseHistoryReturn;

package/dist/composables/useHostCallbacks.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Bridges the host-facing `onComment*` and `onEditorViewReady` props into the
+ * editor internals, keeping the host SFC lean.
+ *
+ * PORT-BLOCKED (missing `useCommentManagement` + comment props): upstream's
+ * primary output is a `CommentCallbacks` bundle
+ * (`onCommentAdd`/`onCommentResolve`/`onCommentDelete`/`onCommentReply`/
+ * `onCommentsChange`) whose type is exported by the sibling
+ * `./useCommentManagement` composable — not yet ported to our fork. It also
+ * reads four host props (`onCommentAdd`, `onCommentResolve`, `onCommentDelete`,
+ * `onCommentReply`) that do not exist on our `DocxEditorProps` (which currently
+ * exposes only `onCommentsChange` and `onEditorViewReady`). Both the
+ * `CommentCallbacks` contract and the props it wires are absent, so the
+ * comment-bridge cannot be built without fabricating an API.
+ *
+ * The `onEditorViewReady` watch is portable on its own, but it is a bare side
+ * effect (no return value) and not the composable's contract, so this is left
+ * as a full block rather than a degenerate stub.
+ *
+ * Unblock: port `useCommentManagement` (exporting `CommentCallbacks`) and add
+ * the four `onComment*` callbacks to `DocxEditorProps`, then restore the
+ * upstream body verbatim.
+ */
+export {};

package/dist/composables/useHyperlinkManagement.d.ts

@@ -0,0 +1,40 @@
+import { Ref } from 'vue';
+import { Command } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import { HyperlinkPopupData } from '../components/ui/hyperlinkPopupTypes';
+export type { HyperlinkPopupData };
+type CommandFactory = (...args: readonly unknown[]) => Command;
+export type UseHyperlinkManagementOptions = {
+    editorView: Ref<EditorView | null>;
+    getCommands: () => Record<string, CommandFactory>;
+};
+export type HyperlinkSubmitData = {
+    url?: string;
+    bookmark?: string;
+    displayText: string;
+    tooltip: string;
+};
+export declare function useHyperlinkManagement(opts: UseHyperlinkManagementOptions): {
+    hyperlinkPopupData: Ref<{
+        href: string;
+        displayText: string;
+        tooltip?: string;
+        position: {
+            top: number;
+            left: number;
+        };
+    } | null, HyperlinkPopupData | {
+        href: string;
+        displayText: string;
+        tooltip?: string;
+        position: {
+            top: number;
+            left: number;
+        };
+    } | null>;
+    handleHyperlinkSubmit: (data: HyperlinkSubmitData) => void;
+    handleHyperlinkRemove: () => void;
+    handleHyperlinkPopupNavigate: (href: string) => void;
+    handleHyperlinkPopupEdit: (displayText: string, href: string) => void;
+    handleHyperlinkPopupRemove: () => void;
+};

package/dist/composables/useImageActions.d.ts

@@ -0,0 +1,25 @@
+import { ComputedRef, Ref, ShallowRef } from 'vue';
+import { Command } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import { ImageSelectionInfo } from '../components/imageSelectionTypes';
+type CommandFactory = (...args: readonly unknown[]) => Command;
+export type UseImageActionsOptions = {
+    editorView: Ref<EditorView | null>;
+    zoom: Ref<number>;
+    stateTick: Ref<number>;
+    getCommands: () => Record<string, CommandFactory>;
+};
+export type ImageToolbarContext = {
+    wrapType: string;
+    displayMode: string;
+    cssFloat: string | null;
+};
+export type UseImageActionsReturn = {
+    selectedImage: ShallowRef<ImageSelectionInfo | null>;
+    imageInteracting: Ref<boolean>;
+    imageToolbarContext: ComputedRef<ImageToolbarContext | null>;
+    handleToolbarImageWrap: (value: string) => void;
+    handleImageTransform: (action: "rotateCW" | "rotateCCW" | "flipH" | "flipV") => void;
+};
+export declare function useImageActions(opts: UseImageActionsOptions): UseImageActionsReturn;
+export {};

package/dist/composables/useKeyboardShortcuts.d.ts

@@ -0,0 +1,25 @@
+import { Ref } from 'vue';
+export type UseKeyboardShortcutsOptions = {
+    showKeyboardShortcuts: Ref<boolean>;
+    showFindReplace: Ref<boolean>;
+    showHyperlink: Ref<boolean>;
+    /** From useZoom — handles Ctrl+= / Ctrl+- / Ctrl+0. */
+    handleZoomKeyDown: (e: KeyboardEvent) => void;
+    /**
+     * Host prop accessor — read freshly inside the handler so a host
+     * toggle at runtime is honored. (Capturing the prop value at setup
+     * time would freeze it.)
+     */
+    disableFindReplaceShortcuts?: () => boolean | undefined;
+    /**
+     * Whether `File > Open` / Cmd+O is enabled. Read freshly so a runtime host
+     * toggle is honored. When false (or `onOpenDocument` is absent), Cmd+O is
+     * left unhandled so the browser default stands.
+     */
+    showFileOpen?: () => boolean | undefined;
+    /** Opens the DOCX picker — wired to the same hidden input as File > Open. */
+    onOpenDocument?: () => void;
+};
+export declare function useKeyboardShortcuts(opts: UseKeyboardShortcutsOptions): {
+    handleKeyDown: (e: KeyboardEvent) => void;
+};

package/dist/composables/useMenuActions.d.ts

@@ -0,0 +1,36 @@
+import { Ref } from 'vue';
+import { EditorView } from 'prosemirror-view';
+import { Command } from 'prosemirror-state';
+/**
+ * A toolbar/menu command factory: called with whatever arguments the
+ * specific command needs, it returns a ProseMirror `Command`. The
+ * argument list is heterogeneous across commands (some take none,
+ * `insertTable` takes rows/cols), so it is typed structurally rather
+ * than per-command.
+ */
+type CommandFactory = (...args: readonly unknown[]) => Command;
+export type UseMenuActionsOptions = {
+    editorView: Ref<EditorView | null>;
+    getCommands: () => Record<string, CommandFactory>;
+    docxInputRef: Ref<HTMLInputElement | null>;
+    imageInputRef: Ref<HTMLInputElement | null>;
+    showPageSetup: Ref<boolean>;
+    showWatermark: Ref<boolean>;
+    showHyperlink: Ref<boolean>;
+    showInsertSymbol: Ref<boolean>;
+    showKeyboardShortcuts: Ref<boolean>;
+    handleClearFormatting: () => void;
+    handleInsertPageBreak: () => void;
+    handleInsertSectionBreakNextPage: () => void;
+    handleInsertSectionBreakContinuous: () => void;
+    handleToggleOutline: () => void;
+    handleToggleSidebar: () => void;
+    downloadCurrentDocument: () => Promise<void>;
+    emit: (event: string, ...args: unknown[]) => void;
+};
+export declare function useMenuActions(opts: UseMenuActionsOptions): {
+    handleMenuAction: (action: string) => void;
+    handleMenuTableInsert: (rows: number, cols: number) => void;
+    execSimpleCommand: (name: string) => void;
+};
+export {};

package/dist/composables/useOutlineSidebar.d.ts

@@ -0,0 +1,24 @@
+import { Ref } from 'vue';
+import { EditorView } from 'prosemirror-view';
+import { HeadingInfo } from '@stll/folio-core/utils/headingCollector';
+export type UseOutlineSidebarOptions = {
+    editorView: Ref<EditorView | null>;
+    showOutline: Ref<boolean>;
+    showSidebar: Ref<boolean>;
+    outlineHeadings: Ref<HeadingInfo[]>;
+    activeSidebarItem: Ref<string | null>;
+    extractCommentsAndChanges: () => void;
+    /**
+     * Scroll the VISIBLE paged viewport to a PM position. The hidden PM
+     * (`left: -9999px`) is never what the user sees, so `tr.scrollIntoView()`
+     * on it does nothing; the outline must drive the painter viewport instead
+     * (mirrors React's `scrollToPosition`; #930).
+     */
+    scrollToVisiblePosition: (pmPos: number) => void;
+};
+export declare function useOutlineSidebar(opts: UseOutlineSidebarOptions): {
+    handleToggleOutline: () => void;
+    handleOutlineNavigate: (pmPos: number) => void;
+    handleToggleSidebar: () => void;
+    handleEditorScrollMouseDown: (event: MouseEvent) => void;
+};

package/dist/composables/usePageSetupControls.d.ts

@@ -0,0 +1,28 @@
+import { Ref } from 'vue';
+import { EditorView } from 'prosemirror-view';
+import { Document, SectionProperties } from '@stll/folio-core/types/document';
+export type UsePageSetupControlsOptions = {
+    editorView: Ref<EditorView | null>;
+    getDocument: () => Document | null;
+    readOnly: Ref<boolean>;
+    stateTick: Ref<number>;
+    reLayout: () => void;
+    /**
+     * Notified after a direct section-properties write (margins, page size,
+     * orientation) so the host's `onChange` fires. These writes bypass the PM
+     * transaction pipeline, so this is their only change signal; ruler indent /
+     * tab-stop edits dispatch PM commands and notify via the pipeline instead.
+     */
+    onChange: (doc: Document) => void;
+};
+export declare function usePageSetupControls(opts: UsePageSetupControlsOptions): {
+    handlePageSetupApply: (sp: Partial<SectionProperties>) => void;
+    handleLeftMarginChange: (twips: number) => void;
+    handleRightMarginChange: (twips: number) => void;
+    handleTopMarginChange: (twips: number) => void;
+    handleBottomMarginChange: (twips: number) => void;
+    handleIndentLeftChange: (twips: number) => void;
+    handleIndentRightChange: (twips: number) => void;
+    handleFirstLineIndentChange: (twips: number) => void;
+    handleTabStopRemove: (positionTwips: number) => void;
+};

package/dist/composables/usePagesPointer.d.ts

@@ -0,0 +1,87 @@
+import { Ref, ShallowRef } from 'vue';
+import { Command } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import { HeaderFooter, BlockContent } from '@stll/folio-core/types/content';
+import { Document } from '@stll/folio-core/types/document';
+import { Layout } from '@stll/folio-core/layout-engine';
+import { ImageSelectionInfo } from '../components/imageSelectionTypes';
+import { HyperlinkPopupData } from '../components/ui/hyperlinkPopupTypes';
+type CommandFactory = (...args: readonly unknown[]) => Command;
+type Commands = Record<string, CommandFactory>;
+type TableResizeApi = {
+    tryStartResize: (e: MouseEvent, view: EditorView) => boolean;
+    isResizing: Ref<boolean>;
+};
+export type TableInsertButton = {
+    type: "row" | "column";
+    x: number;
+    y: number;
+    cellPmPos: number;
+};
+export type HfEditState = {
+    position: "header" | "footer";
+    rId: string | null;
+    headerFooter: HeaderFooter | null;
+    targetRect: {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    } | null;
+};
+export type ScrollPageInfo = {
+    currentPage: number;
+    totalPages: number;
+    visible: boolean;
+};
+export type UsePagesPointerOptions = {
+    editorView: Ref<EditorView | null>;
+    pagesRef: Ref<HTMLElement | null>;
+    pagesViewportRef: Ref<HTMLElement | null>;
+    selectedImage: ShallowRef<ImageSelectionInfo | null>;
+    imageInteracting: Ref<boolean>;
+    hyperlinkPopupData: Ref<HyperlinkPopupData | null>;
+    readOnly: Ref<boolean>;
+    zoom: Ref<number>;
+    layout: Ref<Layout | null>;
+    tableResize: TableResizeApi;
+    getCommands: () => Commands;
+    getDocument: () => Document | null;
+    reLayout: () => void;
+    emit: (event: string, ...args: unknown[]) => void;
+    clearOverlay: () => void;
+    /**
+     * Re-mount HF EditorViews when `package.headers/footers` content changes —
+     * exposed by `useDocxEditor.syncHfPMs`. Called after every save so the
+     * persistent PM points at the new HeaderFooter object. Optional so existing
+     * consumers can no-op until they wire it through.
+     */
+    syncHfPMs?: () => void;
+    /** Resolve the persistent EditorView for an HF instance (for click routing). */
+    getHfPmView?: (hf: HeaderFooter) => EditorView | null;
+    /**
+     * Replace the loaded Document — used by HF materialisation to publish a
+     * fresh Document object instead of mutating in place. Optional; if absent,
+     * callers fall back to in-place mutation + `syncHfPMs()`.
+     */
+    setDocument?: (doc: Document) => void;
+};
+export type UsePagesPointerReturn = {
+    tableInsertButton: Ref<TableInsertButton | null>;
+    hfEdit: ShallowRef<HfEditState | null>;
+    scrollPageInfo: Ref<ScrollPageInfo>;
+    resolvePos: (clientX: number, clientY: number) => number | null;
+    setPmSelection: (anchor: number, head?: number) => void;
+    scrollVisiblePositionIntoView: (pmPos: number) => void;
+    navigateToBookmark: (bookmarkName: string) => void;
+    handlePagesMouseDown: (event: MouseEvent) => void;
+    handlePagesMouseMove: (event: MouseEvent) => void;
+    handlePagesClick: (event: MouseEvent) => void;
+    handlePagesDoubleClick: (event: MouseEvent) => void;
+    handleTableInsertClick: (event: MouseEvent) => void;
+    clearTableInsertTimer: () => void;
+    handleHfSave: (content: BlockContent[]) => void;
+    handleHfRemove: () => void;
+};
+export declare function usePagesPointer(opts: UsePagesPointerOptions): UsePagesPointerReturn;
+export {};