superdoc 2.2.0 → 2.3.0

package/dist/superdoc/src/components/surfaces/SurfaceExternalMount.vue.d.ts

@@ -0,0 +1,19 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    close: Function;
+    resolve: Function;
+    request: Record<string, any>;
+    mode: string;
+    render: Function;
+    surfaceId: string;
+    $props: {
+        readonly close?: Function | undefined;
+        readonly resolve?: Function | undefined;
+        readonly request?: Record<string, any> | undefined;
+        readonly mode?: string | undefined;
+        readonly render?: Function | undefined;
+        readonly surfaceId?: string | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    container: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/superdoc/src/components/surfaces/SurfaceFloating.vue.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    rootEl: import('vue').Ref<null, null>;
+    surface: Record<string, any>;
+    $props: {
+        readonly surface?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    floatingRef: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/superdoc/src/components/surfaces/SurfaceHost.vue.d.ts

@@ -0,0 +1,31 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    geometryTarget: Record<string, any>;
+    $props: {
+        readonly geometryTarget?: Record<string, any> | undefined;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    hostRef: HTMLDivElement;
+    floatingRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
+        rootEl: import('vue').Ref<null, null>;
+        surface: Record<string, any>;
+        $props: {
+            readonly surface?: Record<string, any> | undefined;
+        };
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        floatingRef: HTMLDivElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{}> & Readonly<{}>, {
+        rootEl: import('vue').Ref<null, null>;
+        surface: Record<string, any>;
+        $props: {
+            readonly surface?: Record<string, any> | undefined;
+        };
+    }, {}, {}, {}, {}> | null;
+}, any>;
+export default _default;

package/dist/superdoc/src/components/surfaces/focusable-selector.d.ts

@@ -0,0 +1,5 @@
+/**
+ * CSS selector matching all focusable elements within a surface shell.
+ * Used by SurfaceDialog (focus trap, initial focus) and SurfaceFloating (initial focus).
+ */
+export const FOCUSABLE_SELECTOR: string;

package/dist/superdoc/src/composables/find-shortcut-owner.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Make `owner` the ambient find-shortcut owner. Call on mount and on user
+ * interaction (pointerdown / focusin inside the instance) so "the SuperDoc the
+ * user last touched" wins the ambient shortcut.
+ * @param {unknown} owner
+ */
+export function claimFindShortcut(owner: unknown): void;
+/**
+ * Clear ownership if `owner` currently holds it. Call on unmount.
+ * @param {unknown} owner
+ */
+export function releaseFindShortcut(owner: unknown): void;
+/**
+ * Whether `owner` may handle the ambient (no-focus) find shortcut. With no
+ * claimed owner any instance may handle it (single-instance pages), relying on
+ * the `defaultPrevented` check in {@link shouldHandleFindShortcut} to keep the
+ * shortcut single-fire.
+ * @param {unknown} owner
+ */
+export function ownsAmbientFindShortcut(owner: unknown): boolean;
+/**
+ * Decide whether one SuperDoc instance's capture listener should handle a
+ * find-shortcut keydown. `defaultPrevented` covers the cross-instance race
+ * directly: the first instance to act marks the event, and sibling capture
+ * listeners on the same node skip it.
+ * @param {KeyboardEvent} event
+ * @param {{ focusInside: boolean, owner: unknown }} context
+ */
+export function shouldHandleFindShortcut(event: KeyboardEvent, { focusInside, owner }: {
+    focusInside: boolean;
+    owner: unknown;
+}): boolean;

package/dist/superdoc/src/composables/replace-continuation.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The find/replace panel's settled-replace continuation.
+ *
+ * A worker-backed replace resolves asynchronously, and the session it belongs to
+ * can be gone by the time it does: the search handle is reassigned when the
+ * active editor changes and nulled on teardown. Publishing the resolved snapshot
+ * anyway would repopulate the panel with matches from a document the user is no
+ * longer looking at.
+ *
+ * A leaf module rather than a closure inside `useFindReplace`, following
+ * `find-shortcut-owner.js`. The guard previously lived in two byte-identical
+ * inline closures, each of which needed a full composable driving a
+ * worker-backed host caught mid-swap to reach one branch. Nothing could, so it
+ * shipped with a comment admitting it was verified by inspection only. The
+ * duplication was the tell: logic worth stating twice is worth naming once.
+ */
+/**
+ * Build the continuation that publishes a settled replace back into the panel.
+ *
+ * The session handle itself is the identity. `onSettled` always runs, including
+ * when the write is skipped: it clears the pending flag that gates the replace
+ * controls, and leaving it set would disable them with nothing left to settle.
+ *
+ * @param {{ getSnapshot: () => unknown }} session The handle captured when the replace was issued.
+ * @param {object} deps
+ * @param {() => unknown} deps.getCurrentSession Reads the live session identity.
+ * @param {(snapshot: unknown) => void} deps.applySlice Publishes a snapshot into the panel.
+ * @param {() => void} deps.onSettled Runs whether or not the write was skipped.
+ * @returns {() => void}
+ */
+export function createReplaceContinuation(session: {
+    getSnapshot: () => unknown;
+}, { getCurrentSession, applySlice, onSettled }: {
+    getCurrentSession: () => unknown;
+    applySlice: (snapshot: unknown) => void;
+    onSettled: () => void;
+}): () => void;

package/dist/superdoc/src/composables/use-ai.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Composable to manage AI layer and AI writer functionality
+ *
+ * @param {Object} options - Configuration options
+ * @param {Object} options.activeEditorRef - Ref to the active editor
+ * @returns {Object} - AI state and methods
+ */
+export function useAi({ activeEditorRef }: {
+    activeEditorRef: Object;
+}): Object;

package/dist/superdoc/src/composables/use-comment-small-screen.d.ts

@@ -0,0 +1,10 @@
+export function useCommentSmallScreen({ commentsModuleConfig, superdocRoot, layers }: {
+    commentsModuleConfig: any;
+    superdocRoot: any;
+    layers: any;
+}): {
+    superdocContainerWidth: import('vue').Ref<number, number>;
+    isCompactCommentsMode: import('vue').Ref<boolean, boolean>;
+    recalculateCompactCommentsMode: () => void;
+    ensureCompactMeasurementObserver: () => void;
+};

package/dist/superdoc/src/composables/use-compact-comment-popover.d.ts

@@ -0,0 +1,21 @@
+export function useCompactCommentPopover({ activeComment, pendingComment, activeCompactComment, showCommentsSidebar, selectionPosition, activeZoom, superdocRoot, layers, documents, resolveCommentPositionEntry, clearActiveComment, clearPendingComment, }: {
+    activeComment: any;
+    pendingComment: any;
+    activeCompactComment: any;
+    showCommentsSidebar: any;
+    selectionPosition: any;
+    activeZoom: any;
+    superdocRoot: any;
+    layers: any;
+    documents: any;
+    resolveCommentPositionEntry: any;
+    clearActiveComment: any;
+    clearPendingComment: any;
+}): {
+    compactCommentPopoverStyle: import('vue').ComputedRef<{
+        top: string;
+        right: string;
+    }>;
+    closeCompactCommentPopover: () => void;
+    resetClickAnchor: () => void;
+};

package/dist/superdoc/src/composables/use-document.d.ts

@@ -0,0 +1,34 @@
+export default function useDocument(params: any, superdocConfig: any): {
+    id: any;
+    data: any;
+    html: any;
+    markdown: any;
+    password: any;
+    type: string;
+    config: any;
+    state: any;
+    role: any;
+    core: import('vue').Ref<null, null>;
+    editorMountNonce: import('vue').Ref<number, number>;
+    ydoc: import('vue').ShallowRef<any, any>;
+    provider: import('vue').ShallowRef<any, any>;
+    socket: import('vue').ShallowRef<any, any>;
+    isNewFile: import('vue').Ref<any, any>;
+    v2Collaboration: import('vue').ShallowRef<any, any>;
+    container: import('vue').Ref<null, null>;
+    pageContainers: import('vue').Ref<never[], never[]>;
+    isReady: import('vue').Ref<boolean, boolean>;
+    rulers: import('vue').Ref<any, any>;
+    rawFields: import('vue').Ref<any, any>;
+    fields: import('vue').Ref<any, any>;
+    annotations: import('vue').Ref<any, any>;
+    conversations: import('vue').Ref<any, any>;
+    commentThreadingProfile: import('vue').Ref<any, any>;
+    setEditor: (ref: any) => any;
+    getEditor: () => null;
+    setDocumentRuntime: (ref: any) => any;
+    getDocumentRuntime: () => null;
+    removeComments: () => void;
+    restoreComments: () => void;
+    removeConversation: (conversationId: any) => void;
+};

package/dist/superdoc/src/composables/use-field.d.ts

@@ -0,0 +1,33 @@
+export function useFieldValueWatcher(field: any, originalValue: any): {
+    value: any;
+};
+export function useField(field: any): {
+    id: import('vue').Ref<any, any>;
+    icon: import('vue').Ref<any, any>;
+    iconPack: import('vue').Ref<any, any>;
+    label: import('vue').Ref<any, any>;
+    placeholder: any;
+    fieldType: import('vue').Ref<any, any>;
+    fieldSubType: import('vue').Ref<any, any>;
+    value: any;
+    format: import('vue').Ref<any, any>;
+    logicRules: import('vue').Ref<any, any>;
+    hidden: import('vue').Ref<boolean, boolean>;
+    originalJSON: any;
+    fieldStyle: {
+        fontFamily: any;
+        fontSize: any;
+        originalFontSize: any;
+    };
+    valueGetter: any;
+};
+export function useImageField(field: any): {
+    fontfamily: import('vue').Ref<any, any>;
+    iteminputtype: import('vue').Ref<any, any>;
+};
+export function useSelectField(field: any): {
+    options: import('vue').Ref<any, any>;
+};
+export function useCheckboxField(field: any): {
+    options: import('vue').Ref<any, any>;
+};

package/dist/superdoc/src/composables/use-find-replace.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Composable that manages a find/replace floating surface.
+ *
+ * Owns all search state (query, toggles, match count, active index) and the
+ * resolution chain for custom/external/built-in rendering. The component
+ * receives a FindReplaceHandle with reactive state and actions.
+ *
+ * @param {Object} options
+ * @param {() => import('../core/surface-manager.js').SurfaceManager | null} options.getSurfaceManager
+ * @param {() => SearchEditor | null} options.getActiveEditor
+ * @param {import('vue').Ref} [options.activeEditorRef] - Reactive ref to the active editor (for watching switches)
+ * @param {() => boolean | FindReplaceConfig | undefined} [options.getFindReplaceConfig] - Config getter
+ * @param {() => { search?: any } | null | undefined} [options.getSuperDocUI] - Getter for the
+ *   SuperDoc-owned UI controller (`superdoc.ui`). Its `.search` slice is the single V2
+ *   find/replace session authority; the V2 driver never touches `editor.commands`.
+ */
+export function useFindReplace({ getSurfaceManager, getActiveEditor, activeEditorRef, getFindReplaceConfig, getSuperDocUI, }: {
+    getSurfaceManager: () => import('../core/surface-manager.js').SurfaceManager | null;
+    getActiveEditor: () => SearchEditor | null;
+    activeEditorRef?: import('vue').Ref<any, any> | undefined;
+    getFindReplaceConfig?: (() => boolean | FindReplaceConfig | undefined) | undefined;
+    getSuperDocUI?: (() => {
+        search?: any;
+    } | null | undefined) | undefined;
+}): {
+    open: () => Promise<void>;
+    close: () => void;
+    isOpen: import('vue').Ref<boolean, boolean>;
+    wouldOpen: () => boolean;
+    destroy: () => void;
+};
+/**
+ * The shape of `setSearchSession`,
+ *   `nextSearchMatch`, `previousSearchMatch`, `replaceSearchMatch` returns.
+ *   The Search extension is renderer-owned; this composable only consumes
+ *   the two fields below.
+ */
+export type SearchResult = {
+    matches: {
+        length: number;
+    }[];
+    activeMatchIndex: number;
+};
+/**
+ * The search command subset consumed here.
+ */
+export type SearchCommands = {
+    clearSearchSession: () => void;
+    setSearchSession: (query: string, options: {
+        caseSensitive: boolean;
+        ignoreDiacritics: boolean;
+        highlight: boolean;
+        searchModel: "raw" | "visible";
+    }) => SearchResult;
+    nextSearchMatch: () => SearchResult;
+    previousSearchMatch: () => SearchResult;
+    replaceSearchMatch: (replacement: string) => SearchResult;
+    replaceAllSearchMatches: (replacement: string) => void;
+};
+export type SearchEditor = import('../core/types/index.js').Editor & {
+    commands: SearchCommands;
+    extensionStorage?: Record<string, unknown>;
+    storage?: Record<string, unknown>;
+};
+/**
+ * The Search extension's storage shape.
+ *   The Search extension is renderer-owned; this composable only
+ *   needs the fields it reads to detect a live search session and resync
+ *   from external mutations.
+ */
+export type SearchStorage = {
+    searchIndex?: unknown;
+    searchResults?: unknown;
+    activeMatchIndex?: number | undefined;
+    matches?: {
+        length: number;
+    }[] | undefined;
+};
+export type FindReplaceConfig = import('../core/types/index.js').FindReplaceConfig;
+export type ResolvedFindReplaceTexts = import('../core/types/index.js').ResolvedFindReplaceTexts;
+export type FindReplaceHandle = import('../core/types/index.js').FindReplaceHandle;
+export type FindReplaceContext = import('../core/types/index.js').FindReplaceContext;
+export type FindReplaceResolution = import('../core/types/index.js').FindReplaceResolution;

package/dist/superdoc/src/composables/use-high-contrast-mode.d.ts

@@ -0,0 +1,4 @@
+export function useHighContrastMode(): {
+    isHighContrastMode: import('vue').Ref<boolean, boolean>;
+    setHighContrastMode: (value: any) => void;
+};

package/dist/superdoc/src/composables/use-link-popover.d.ts

@@ -0,0 +1,221 @@
+/**
+ * @param {Object} options
+ * @param {() => SurfaceManager | null | undefined} options.getSurfaceManager
+ * @param {() => Editor | null | undefined} options.getActiveEditor
+ * @param {() => SuperDocUI | null | undefined} options.getUi
+ * @param {() => LinkPopoverResolver | null | undefined} options.getResolver
+ * @param {() => HTMLElement | null | undefined} options.getLayerElement
+ * @param {(payload: { error: Error, source: string }) => void} options.emitException
+ */
+export function useLinkPopover({ getSurfaceManager, getActiveEditor, getUi, getResolver, getLayerElement, emitException, }: {
+    getSurfaceManager: () => SurfaceManager | null | undefined;
+    getActiveEditor: () => Editor | null | undefined;
+    getUi: () => SuperDocUI | null | undefined;
+    getResolver: () => LinkPopoverResolver | null | undefined;
+    getLayerElement: () => HTMLElement | null | undefined;
+    emitException: (payload: {
+        error: Error;
+        source: string;
+    }) => void;
+}): {
+    handleLinkClick: (payload: LinkClickPayload | null | undefined) => void;
+    closeCurrentPopover: (reason?: string) => void;
+    destroy: () => void;
+};
+export type LinkPopoverContext = import('../core/types/index.js').LinkPopoverContext;
+export type LinkPopoverResolution = import('../core/types/index.js').LinkPopoverResolution;
+export type LinkPopoverResolver = import('../core/types/index.js').LinkPopoverResolver;
+export type SurfaceManager = import('../core/surface-manager.js').SurfaceManager;
+export type SurfaceHandle = import('../core/types/index.js').SurfaceHandle;
+export type SurfaceOutcome = import('../core/types/index.js').SurfaceOutcome;
+export type SurfaceRequest = import('../core/types/index.js').SurfaceRequest;
+export type DirectSurfaceRequest = import('../core/types/index.js').DirectSurfaceRequest;
+export type ExternalSurfaceRenderContext = import('../core/types/index.js').ExternalSurfaceRenderContext;
+export type DocumentMode = import('../core/types/index.js').DocumentMode;
+export type Editor = import('../core/types/index.js').Editor;
+export type SuperDocUI = import('../public/ui/types.js').SuperDocUI;
+/**
+ * A single-block text-selection target in the Document API `query.match`
+ * result shape.
+ */
+export type TextSelectionTarget = {
+    kind: "selection";
+    start: {
+        kind: "text";
+        blockId: string;
+        offset: number;
+    };
+    end: {
+        kind: "text";
+        blockId: string;
+        offset: number;
+    };
+};
+/**
+ * Block-anchored address carried by a Document API hyperlink record.
+ */
+export type HyperlinkAddress = {
+    anchor?: {
+        start?: {
+            blockId?: string;
+            offset?: number;
+        };
+        end?: {
+            blockId?: string;
+            offset?: number;
+        };
+    } | undefined;
+};
+/**
+ * The subset of a Document API hyperlink record this composable reads. The
+ * records come from the async `doc.hyperlinks` facade, so every field is
+ * optional here.
+ */
+export type HyperlinkRecord = {
+    rId?: string | undefined;
+    text?: string | undefined;
+    externalTarget?: string | undefined;
+    anchor?: string | undefined;
+    targetKind?: string | undefined;
+    hyperlinkNodeId?: string | undefined;
+    address?: HyperlinkAddress | undefined;
+};
+/**
+ * A block record as read from `doc.blocks.list()`.
+ */
+export type BlockRecord = {
+    ordinal?: number | undefined;
+    nodeId?: string | undefined;
+};
+/**
+ * Result of `doc.blocks.list()` as read here.
+ */
+export type BlocksListResult = {
+    blocks?: BlockRecord[] | undefined;
+};
+/**
+ * One item of a `doc.query.match` result as read here.
+ */
+export type QueryMatchItem = {
+    target?: TextSelectionTarget | undefined;
+};
+/**
+ * Result of `doc.query.match` as read here.
+ */
+export type QueryMatchResult = {
+    items?: QueryMatchItem[] | undefined;
+};
+/**
+ * One story entry of a `doc.hyperlinks.list()` result.
+ */
+export type HyperlinkStory = {
+    storyId?: string | undefined;
+    hyperlinks?: HyperlinkRecord[] | undefined;
+};
+/**
+ * Result of `doc.hyperlinks.list()` as read here.
+ */
+export type HyperlinksListResult = {
+    stories?: HyperlinkStory[] | undefined;
+};
+/**
+ * Result of `doc.hyperlinks.get()` as read here.
+ */
+export type HyperlinkGetResult = {
+    success?: boolean | undefined;
+    hyperlink?: HyperlinkRecord | undefined;
+};
+/**
+ * Result of `doc.bookmarks.get()` as read here (Document API `BookmarkInfo`).
+ * `range.from.blockId` is the bookmark's `w14:paraId`, used to find/reveal
+ * the target paragraph. `address.story` is populated for non-body
+ * bookmarks (omitted for body) — used to scope this fix to body targets,
+ * since `revealBodyTarget`/`pageIndexForBodyTarget` are body-only.
+ */
+export type BookmarkGetResult = {
+    address?: {
+        story?: {
+            kind?: string;
+            storyType?: string;
+        };
+    } | undefined;
+    range?: {
+        from?: {
+            blockId?: string;
+        };
+    } | undefined;
+};
+/**
+ * The narrow Document API subset this composable reads. The host facade
+ * (`Editor['doc']`) carries no typed surface, so the facades and their results
+ * are declared structurally here with every field optional; the call sites
+ * keep their runtime narrowing (`Array.isArray`, `typeof`, `?.`) before use.
+ * The async-capable facades may return promises, so their results are awaited
+ * through `Promise.resolve(...)`.
+ */
+export type LinkPopoverDocumentApi = {
+    blocks?: {
+        list?: () => BlocksListResult | null | undefined;
+    } | null | undefined;
+    query?: {
+        match?: (query: {
+            select: {
+                type: "text";
+                pattern: string;
+                caseSensitive: boolean;
+            };
+            require: "any";
+        }) => QueryMatchResult | null | undefined;
+    } | null | undefined;
+    hyperlinks?: {
+        list?: () => HyperlinksListResult | Promise<HyperlinksListResult | null | undefined> | null | undefined;
+        get?: (input: {
+            storyId: string;
+            hyperlinkNodeId: string;
+        }) => HyperlinkGetResult | Promise<HyperlinkGetResult | null | undefined> | null | undefined;
+    } | null | undefined;
+    bookmarks?: {
+        get?: (input: {
+            target: {
+                kind: "entity";
+                entityType: "bookmark";
+                name: string;
+            };
+        }) => BookmarkGetResult | Promise<BookmarkGetResult | null | undefined> | null | undefined;
+    } | null | undefined;
+};
+/**
+ * Result of `activeEditor.pageMetrics.revealBodyTarget()` as read here
+ * (`V2EditorHostRevealBodyTargetResult`). Only available in editing/
+ * suggesting mode — the host rejects with `editing-not-mounted` in
+ * viewing mode.
+ */
+export type RevealBodyTargetResult = {
+    status?: "rejected" | "revealed" | undefined;
+    reason?: string | undefined;
+};
+/**
+ * The `v2-link-click` payload the shell relays from the v2 host's
+ * `onLinkClick` callback.
+ */
+export type LinkClickPayload = {
+    href: string;
+    target: string | null;
+    rel: string | null;
+    tooltip: string | null;
+    element: HTMLAnchorElement;
+    clientX: number;
+    clientY: number;
+    documentMode: DocumentMode;
+};
+/**
+ * Hyperlink identity resolved from the Document API for a clicked anchor.
+ */
+export type ResolvedHyperlinkTarget = {
+    storyId: string;
+    hyperlinkNodeId: string | undefined;
+    href: string;
+    text: string | undefined;
+    targetKind: string | undefined;
+    textTarget: TextSelectionTarget | null;
+};

package/dist/superdoc/src/composables/use-password-prompt.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Composable that coordinates password-prompt dialogs for encrypted DOCX files.
+ *
+ * Owns a FIFO queue of pending prompts (one active dialog at a time), and a
+ * `pendingSignals` map that bridges the async gap between triggering a remount
+ * and observing the result via `onEditorReady` / `onEditorException`.
+ *
+ * @param {Object} options
+ * @param {() => import('../core/surface-manager.js').SurfaceManager | null} options.getSurfaceManager
+ * @param {() => boolean | PasswordPromptConfig | undefined} options.getPasswordPromptConfig
+ * @param {(doc: any, errorCode: string, originalException?: { error?: Error, editor?: any }) => void} [options.onUnhandled] Called when a queued prompt cannot be shown (resolver returned `none`, config error, or resolver threw). Receives the original exception payload so the host can re-emit it unchanged.
+ */
+export function usePasswordPrompt({ getSurfaceManager, getPasswordPromptConfig, onUnhandled }: {
+    getSurfaceManager: () => import('../core/surface-manager.js').SurfaceManager | null;
+    getPasswordPromptConfig: () => boolean | PasswordPromptConfig | undefined;
+    onUnhandled?: ((doc: any, errorCode: string, originalException?: {
+        error?: Error;
+        editor?: any;
+    }) => void) | undefined;
+}): {
+    handleEncryptionError: (doc: any, errorCode: string, originalException?: {
+        error?: Error;
+        editor?: any;
+    }) => boolean;
+    handleEditorReady: (doc: any) => void;
+    destroy: () => void;
+};
+export type PasswordPromptConfig = import('../core/types/index.js').PasswordPromptConfig;
+export type ResolvedPasswordPromptTexts = import('../core/types/index.js').ResolvedPasswordPromptTexts;
+export type PasswordPromptHandle = import('../core/types/index.js').PasswordPromptHandle;
+export type PasswordPromptContext = import('../core/types/index.js').PasswordPromptContext;
+export type PasswordPromptResolution = import('../core/types/index.js').PasswordPromptResolution;
+export type PasswordPromptAttemptResult = import('../core/types/index.js').PasswordPromptAttemptResult;

package/dist/superdoc/src/composables/use-selected-text.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Composable to get the currently selected text from an editor.
+ *
+ * When a mounted editor runtime is active and can read selected text, route the
+ * synchronous read through the runtime boundary. The legacy direct editor-state
+ * read remains as a fallback for startup and bare-editor callers.
+ *
+ * @param {Object} editorRef - Ref to the editor instance
+ * @param {Object} [options]
+ * @param {() => (import('../core/editor-runtime/index.js').EditorRuntime | null | undefined)} [options.getActiveRuntime]
+ *   Accessor for the active editor runtime.
+ * @returns {Object} - Object containing the selected text as a computed property
+ */
+export function useSelectedText(editorRef: Object, options?: {
+    getActiveRuntime?: (() => (import('../core/editor-runtime/index.js').EditorRuntime | null | undefined)) | undefined;
+}): Object;

package/dist/superdoc/src/composables/use-viewport-fit.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Viewport fit tracking. Maintains pure viewport metrics (available width,
+ * document base width, fit zoom), stores them for `getViewportMetrics()`,
+ * emits `viewport-change` when the fit they imply changes, and applies the
+ * `fit-width` policy while `zoomMode` is `'fit-width'`.
+ *
+ * Metrics are policy-free measurements: `availableWidth` is the container
+ * width minus the comments sidebar when visible; `fitZoom` is the raw
+ * available/document ratio. The fit policy (and only the policy) accounts
+ * for `config.zoom.fitWidth` padding and clamping.
+ *
+ * The base page width is re-resolved on every evaluation (never latched):
+ * DOCX uses the widest laid-out page with page-styles fallback, PDF uses
+ * rendered pages normalized by their actual scale factor, and HTML reflows
+ * so it contributes no fixed width. A zoom-normalized DOM measurement is
+ * the last-resort fallback for a DOCX editor without page geometry.
+ *
+ * The fit application writes the zoom state directly instead of calling
+ * `setZoom()`, which by contract switches the mode to `manual`.
+ *
+ * Must be called inside a component `setup()` (registers watchers and an
+ * unmount hook).
+ */
+export function useViewportFit({ getSuperdoc, superdocContainerWidth, isReady, activeZoom, zoomMode, viewportMetrics, showCommentsSidebar, rightSidebarRef, superdocRoot, documents, }: {
+    getSuperdoc: any;
+    superdocContainerWidth: any;
+    isReady: any;
+    activeZoom: any;
+    zoomMode: any;
+    viewportMetrics: any;
+    showCommentsSidebar: any;
+    rightSidebarRef: any;
+    superdocRoot: any;
+    documents: any;
+}): {
+    evaluateViewport: () => void;
+};
+export const FIT_WIDTH_DEFAULTS: Readonly<{
+    min: 10;
+    max: 100;
+    padding: 0;
+}>;
+export function resolveFitWidthOptions(rawFitConfig: any): {
+    min: number;
+    max: number;
+    padding: any;
+};
+export function computeFitZoom(availableWidth: any, documentWidth: any): number | null;
+export function computeAppliedFitZoom(availableWidth: any, documentWidth: any, options: any): number | null;
+export function normalizePdfPageMeasurement(measured: any, scaleFactor: any, zoomFactor: any): any;