superdoc 2.29.0-next.9 → 2.30.0-next.4

package/dist/superdoc/src/core/v2-integration/internal-vue-runtime.d.ts

@@ -1,59 +1,64 @@
-export function defineComponent(options: any, extraOptions: any): any;
-export function computed(...args: any[]): any;
-export function createApp(...args: any[]): any;
-export function createBlock(...args: any[]): any;
-export function createCommentVNode(...args: any[]): any;
-export function createElementBlock(...args: any[]): any;
-export function createElementVNode(...args: any[]): any;
-export function createStaticVNode(...args: any[]): any;
-export function createTextVNode(...args: any[]): any;
-export function createVNode(...args: any[]): any;
-export function defineAsyncComponent(...args: any[]): any;
-export function effectScope(...args: any[]): any;
-export function getCurrentInstance(...args: any[]): any;
-export function getCurrentScope(...args: any[]): any;
-export function guardReactiveProps(...args: any[]): any;
-export function h(...args: any[]): any;
-export function hasInjectionContext(...args: any[]): any;
-export function inject(...args: any[]): any;
-export function isReactive(...args: any[]): any;
-export function isRef(...args: any[]): any;
-export function markRaw(...args: any[]): any;
-export function mergeProps(...args: any[]): any;
-export function nextTick(...args: any[]): any;
-export function normalizeClass(...args: any[]): any;
-export function normalizeProps(...args: any[]): any;
-export function normalizeStyle(...args: any[]): any;
-export function onActivated(...args: any[]): any;
-export function onBeforeUnmount(...args: any[]): any;
-export function onDeactivated(...args: any[]): any;
-export function onMounted(...args: any[]): any;
-export function onScopeDispose(...args: any[]): any;
-export function openBlock(...args: any[]): any;
-export function provide(...args: any[]): any;
-export function reactive(...args: any[]): any;
-export function readonly(...args: any[]): any;
-export function ref(...args: any[]): any;
-export function renderList(...args: any[]): any;
-export function renderSlot(...args: any[]): any;
-export function resolveDirective(...args: any[]): any;
-export function resolveDynamicComponent(...args: any[]): any;
-export function shallowRef(...args: any[]): any;
-export function toDisplayString(...args: any[]): any;
-export function toRaw(...args: any[]): any;
-export function toRef(...args: any[]): any;
-export function toRefs(...args: any[]): any;
-export function unref(...args: any[]): any;
-export function useAttrs(...args: any[]): any;
-export function useSlots(...args: any[]): any;
-export function watch(...args: any[]): any;
-export function withCtx(...args: any[]): any;
-export function withDirectives(...args: any[]): any;
-export function withKeys(...args: any[]): any;
-export function withModifiers(...args: any[]): any;
-export function Transition(props: any, context: any): any;
-export const Fragment: unique symbol;
-export const Teleport: {};
-export const vModelCheckbox: {};
-export const vModelSelect: {};
-export const vModelText: {};
+import type * as Vue from 'vue';
+type VueRuntime = typeof Vue;
+type TransitionProps = Parameters<VueRuntime['Transition']>[0];
+type TransitionContext = Parameters<VueRuntime['Transition']>[1];
+export declare function defineComponent(options: object, extraOptions?: object): object;
+export declare const Transition: (props: TransitionProps, context: TransitionContext) => any;
+export declare const Fragment: unique symbol;
+export declare const Teleport: object;
+export declare function computed(...args: Parameters<VueRuntime['computed']>): ReturnType<VueRuntime['computed']>;
+export declare function createApp(...args: Parameters<VueRuntime['createApp']>): ReturnType<VueRuntime['createApp']>;
+export declare function createBlock(...args: Parameters<VueRuntime['createBlock']>): ReturnType<VueRuntime['createBlock']>;
+export declare function createCommentVNode(...args: Parameters<VueRuntime['createCommentVNode']>): ReturnType<VueRuntime['createCommentVNode']>;
+export declare function createElementBlock(...args: Parameters<VueRuntime['createElementBlock']>): ReturnType<VueRuntime['createElementBlock']>;
+export declare function createElementVNode(...args: Parameters<VueRuntime['createElementVNode']>): ReturnType<VueRuntime['createElementVNode']>;
+export declare function createStaticVNode(...args: Parameters<VueRuntime['createStaticVNode']>): ReturnType<VueRuntime['createStaticVNode']>;
+export declare function createTextVNode(...args: Parameters<VueRuntime['createTextVNode']>): ReturnType<VueRuntime['createTextVNode']>;
+export declare function createVNode(...args: Parameters<VueRuntime['createVNode']>): ReturnType<VueRuntime['createVNode']>;
+export declare function defineAsyncComponent(...args: Parameters<VueRuntime['defineAsyncComponent']>): ReturnType<VueRuntime['defineAsyncComponent']>;
+export declare function effectScope(...args: Parameters<VueRuntime['effectScope']>): ReturnType<VueRuntime['effectScope']>;
+export declare function getCurrentInstance(...args: Parameters<VueRuntime['getCurrentInstance']>): ReturnType<VueRuntime['getCurrentInstance']>;
+export declare function getCurrentScope(...args: Parameters<VueRuntime['getCurrentScope']>): ReturnType<VueRuntime['getCurrentScope']>;
+export declare function guardReactiveProps(...args: Parameters<VueRuntime['guardReactiveProps']>): ReturnType<VueRuntime['guardReactiveProps']>;
+export declare function h(...args: Parameters<VueRuntime['h']>): ReturnType<VueRuntime['h']>;
+export declare function hasInjectionContext(...args: Parameters<VueRuntime['hasInjectionContext']>): ReturnType<VueRuntime['hasInjectionContext']>;
+export declare function inject(...args: Parameters<VueRuntime['inject']>): ReturnType<VueRuntime['inject']>;
+export declare function isReactive(...args: Parameters<VueRuntime['isReactive']>): ReturnType<VueRuntime['isReactive']>;
+export declare function isRef(...args: Parameters<VueRuntime['isRef']>): ReturnType<VueRuntime['isRef']>;
+export declare function markRaw(...args: Parameters<VueRuntime['markRaw']>): ReturnType<VueRuntime['markRaw']>;
+export declare function mergeProps(...args: Parameters<VueRuntime['mergeProps']>): ReturnType<VueRuntime['mergeProps']>;
+export declare function nextTick(...args: Parameters<VueRuntime['nextTick']>): ReturnType<VueRuntime['nextTick']>;
+export declare function normalizeClass(...args: Parameters<VueRuntime['normalizeClass']>): ReturnType<VueRuntime['normalizeClass']>;
+export declare function normalizeProps(...args: Parameters<VueRuntime['normalizeProps']>): ReturnType<VueRuntime['normalizeProps']>;
+export declare function normalizeStyle(...args: Parameters<VueRuntime['normalizeStyle']>): ReturnType<VueRuntime['normalizeStyle']>;
+export declare function onActivated(...args: Parameters<VueRuntime['onActivated']>): ReturnType<VueRuntime['onActivated']>;
+export declare function onBeforeUnmount(...args: Parameters<VueRuntime['onBeforeUnmount']>): ReturnType<VueRuntime['onBeforeUnmount']>;
+export declare function onDeactivated(...args: Parameters<VueRuntime['onDeactivated']>): ReturnType<VueRuntime['onDeactivated']>;
+export declare function onMounted(...args: Parameters<VueRuntime['onMounted']>): ReturnType<VueRuntime['onMounted']>;
+export declare function onScopeDispose(...args: Parameters<VueRuntime['onScopeDispose']>): ReturnType<VueRuntime['onScopeDispose']>;
+export declare function openBlock(...args: Parameters<VueRuntime['openBlock']>): ReturnType<VueRuntime['openBlock']>;
+export declare function provide(...args: Parameters<VueRuntime['provide']>): ReturnType<VueRuntime['provide']>;
+export declare function reactive(...args: Parameters<VueRuntime['reactive']>): ReturnType<VueRuntime['reactive']>;
+export declare function readonly(...args: Parameters<VueRuntime['readonly']>): ReturnType<VueRuntime['readonly']>;
+export declare function ref(...args: Parameters<VueRuntime['ref']>): ReturnType<VueRuntime['ref']>;
+export declare function renderList(...args: Parameters<VueRuntime['renderList']>): ReturnType<VueRuntime['renderList']>;
+export declare function renderSlot(...args: Parameters<VueRuntime['renderSlot']>): ReturnType<VueRuntime['renderSlot']>;
+export declare function resolveDirective(...args: Parameters<VueRuntime['resolveDirective']>): ReturnType<VueRuntime['resolveDirective']>;
+export declare function resolveDynamicComponent(...args: Parameters<VueRuntime['resolveDynamicComponent']>): ReturnType<VueRuntime['resolveDynamicComponent']>;
+export declare function shallowRef(...args: Parameters<VueRuntime['shallowRef']>): ReturnType<VueRuntime['shallowRef']>;
+export declare function toDisplayString(...args: Parameters<VueRuntime['toDisplayString']>): ReturnType<VueRuntime['toDisplayString']>;
+export declare function toRaw(...args: Parameters<VueRuntime['toRaw']>): ReturnType<VueRuntime['toRaw']>;
+export declare function toRef(...args: Parameters<VueRuntime['toRef']>): ReturnType<VueRuntime['toRef']>;
+export declare function toRefs(...args: Parameters<VueRuntime['toRefs']>): ReturnType<VueRuntime['toRefs']>;
+export declare function unref(...args: Parameters<VueRuntime['unref']>): ReturnType<VueRuntime['unref']>;
+export declare function useAttrs(...args: Parameters<VueRuntime['useAttrs']>): ReturnType<VueRuntime['useAttrs']>;
+export declare function useSlots(...args: Parameters<VueRuntime['useSlots']>): ReturnType<VueRuntime['useSlots']>;
+export declare const vModelCheckbox: object;
+export declare const vModelSelect: object;
+export declare const vModelText: object;
+export declare function watch(...args: Parameters<VueRuntime['watch']>): ReturnType<VueRuntime['watch']>;
+export declare function withCtx(...args: Parameters<VueRuntime['withCtx']>): ReturnType<VueRuntime['withCtx']>;
+export declare function withDirectives(...args: Parameters<VueRuntime['withDirectives']>): ReturnType<VueRuntime['withDirectives']>;
+export declare function withKeys(...args: Parameters<VueRuntime['withKeys']>): ReturnType<VueRuntime['withKeys']>;
+export declare function withModifiers(...args: Parameters<VueRuntime['withModifiers']>): ReturnType<VueRuntime['withModifiers']>;
+export {};

package/dist/superdoc/src/helpers/deprecation.d.ts

@@ -1,4 +1,13 @@
-import { Editor } from '../core/types/index.js';
+/**
+ * Deprecation utilities for steering consumers toward the Document API.
+ *
+ * ProseMirror will be removed in a future major version. These helpers emit
+ * one-time console warnings when deprecated properties are accessed on an
+ * editor instance handed to consumer callbacks (onEditorCreate, etc.).
+ *
+ * Internal code continues to use the raw Editor — only the consumer-facing
+ * boundary wraps the editor with a Proxy.
+ */
 /**
  * Log a console.warn once per key. Subsequent calls with the same key are no-ops.
  */
@@ -12,9 +21,9 @@ export declare function warnOnce(key: string, message: string): void;
  *
  * @returns Proxied editor (or the original if null/already wrapped)
  */
-export declare function createDeprecatedEditorProxy<T extends Editor | null | undefined>(editor: T): T;
+export declare function createDeprecatedEditorProxy<T extends object | null | undefined>(editor: T): T;
 /**
  * Unwrap a potentially proxied editor back to the raw Editor instance.
  * Safe to call on an already-raw editor — returns it unchanged.
  */
-export declare function unwrapEditor(editor: Editor | null | undefined): Editor | null | undefined;
+export declare function unwrapEditor<T extends object>(editor: T | null | undefined): T | null | undefined;

package/dist/superdoc/src/helpers/object-guards.d.ts

@@ -1 +1,3 @@
 export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+export declare function isObjectRecord(value: unknown): value is Record<string, unknown>;
+export declare function isThenable(value: unknown): value is PromiseLike<unknown>;

package/dist/superdoc/src/helpers/v2-author-required-rejection.d.ts

@@ -1,16 +1,13 @@
-/**
- * @param {any} event - a `v2-host-event` payload.
- * @returns {boolean} true when the rejection means the session needs an author.
- */
-export function isV2AuthorRequiredRejection(event: any): boolean;
-export function createV2AuthorRequiredNotificationGate(): {
-    shouldNotify(scope: any, event: any): boolean;
-    clear(scope: any): void;
-};
+import { V2MutationRejectedEvent } from './v2-mutation-exception.js';
 /** Stable, non-terminal exception code surfaced to consumers. */
-export const V2_AUTHOR_REQUIRED_CODE: "author-required";
+export declare const V2_AUTHOR_REQUIRED_CODE = "author-required";
 /**
  * Content-safe, actionable message. Contains no document text, imported author,
  * email, path, or source key — only how to fix the configuration.
  */
-export const V2_AUTHOR_REQUIRED_MESSAGE: "This edit needs an author identity. Set `user.name` in your SuperDoc configuration and reopen the document to make tracked or revision-overlapping edits.";
+export declare const V2_AUTHOR_REQUIRED_MESSAGE = "This edit needs an author identity. Set `user.name` in your SuperDoc configuration and reopen the document to make tracked or revision-overlapping edits.";
+export declare function isV2AuthorRequiredRejection(event: unknown): event is V2MutationRejectedEvent;
+export declare function createV2AuthorRequiredNotificationGate(): {
+    shouldNotify(scope: string | null | undefined, event: unknown): boolean;
+    clear(scope: string | null | undefined): void;
+};

package/dist/superdoc/src/helpers/v2-bulk-decision-event.d.ts

@@ -1,7 +1,9 @@
-export function toV2BulkDecisionEvent(documentId: any, fact: any): {
-    documentId: string | null;
-    decision: any;
-    requestedCount: any;
-    successfulCount: any;
-    permissionDeniedCount: any;
-} | null;
+import { SuperDocTrackedChangesBulkDecisionPayload } from '../core/types/index.js';
+export type V2TrackedChangeBulkDecisionFact = {
+    schemaVersion: number;
+    decision: string;
+    requestedCount: number;
+    appliedCount: number;
+    deniedCount: number;
+};
+export declare function toV2BulkDecisionEvent(documentId: string | null | undefined, fact: V2TrackedChangeBulkDecisionFact | null | undefined): SuperDocTrackedChangesBulkDecisionPayload | null;

package/dist/superdoc/src/helpers/v2-keyboard-edit-rejection.d.ts

@@ -1,13 +1,14 @@
-export function isV2KeyboardEditRejection(event: any): boolean;
-export function createV2KeyboardEditRejectionException(documentId: any, event: any): {
+import { V2MutationRejectedEvent } from './v2-mutation-exception.js';
+export declare const V2_EDIT_REJECTED_CODE = "edit-rejected";
+export declare const V2_EDIT_REJECTED_MESSAGE = "This edit couldn\u2019t be completed. Adjust the selection and try again.";
+export declare function isV2KeyboardEditRejection(event: unknown): event is V2MutationRejectedEvent;
+export declare function createV2KeyboardEditRejectionException(documentId: string | null | undefined, event?: unknown): {
     documentId?: string | undefined;
     error: Error;
     code: string;
     editor: null;
 };
-export function createV2KeyboardEditRejectionNotificationGate(): {
-    shouldNotify(scope: any, event: any): boolean;
-    clear(scope: any): void;
+export declare function createV2KeyboardEditRejectionNotificationGate(): {
+    shouldNotify(scope: string | null | undefined, event: unknown): boolean;
+    clear(scope: string | null | undefined): void;
 };
-export const V2_EDIT_REJECTED_CODE: "edit-rejected";
-export const V2_EDIT_REJECTED_MESSAGE: "This edit couldn\u2019t be completed. Adjust the selection and try again.";

package/dist/superdoc/src/helpers/v2-mutation-exception.d.ts

@@ -1,10 +1,14 @@
-export function createV2MutationRejectionCause(event: any): {
-    editableCommandKind?: any;
-    inputKind?: any;
-    reason?: string | undefined;
-    failureSource?: any;
+export type V2MutationRejectedEvent = Record<string, unknown> & {
+    type: 'mutation:rejected';
 };
-export function createV2MutationRejectionNotificationGate(matches: any): {
-    shouldNotify(scope: any, event: any): boolean;
-    clear(scope: any): void;
+export type V2MutationRejectionCause = {
+    failureSource?: string;
+    reason?: string;
+    inputKind?: string;
+    editableCommandKind?: string;
+};
+export declare function createV2MutationRejectionCause(event: unknown): V2MutationRejectionCause;
+export declare function createV2MutationRejectionNotificationGate(matches: (event: unknown) => event is V2MutationRejectedEvent): {
+    shouldNotify(scope: string | null | undefined, event: unknown): boolean;
+    clear(scope: string | null | undefined): void;
 };

package/dist/superdoc/src/helpers/v2-review-geometry-delivery.d.ts

@@ -0,0 +1,22 @@
+export interface ReviewGeometryDeliveryPayload extends Readonly<Record<string, unknown>> {
+    documentEpoch?: unknown;
+    paintEpoch?: unknown;
+    commitSequence?: unknown;
+    generation?: unknown;
+    pageIndices?: unknown;
+    zoomScale?: unknown;
+    reviewGeometry?: unknown;
+}
+type Render = {
+    mountContainer: HTMLElement | null;
+    documentId?: string | null;
+    epoch?: number | null;
+};
+export declare function createReviewGeometryDelivery<T extends Render>(deliver: (value: T, payload: ReviewGeometryDeliveryPayload) => void): {
+    notify: (documentId: string, payload: ReviewGeometryDeliveryPayload, current: T | null, ready?: boolean) => boolean;
+    observe: (current: T) => void;
+    flush(current: T): boolean;
+    replay(current: T): boolean;
+    reset(): void;
+};
+export {};

package/dist/superdoc/src/helpers/v2-review-target.d.ts

@@ -1,7 +1,17 @@
+type V2ReviewTargetInput = {
+    entityId?: unknown;
+    entityType?: unknown;
+};
+type V2ReviewTargetComment = {
+    trackedChange?: unknown;
+    commentId?: unknown;
+    importedId?: unknown;
+};
 /**
  * Resolve the comments-store identity for a document-origin v2 review target.
  * Painted review carriers can become interactive before the asynchronous row
  * hydration finishes. In that window the host's canonical entity id remains
  * the correct pending active identity; once hydrated, the row aliases win.
  */
-export function resolveV2ReviewTargetCommentId(target: any, getComment: any): any;
+export declare function resolveV2ReviewTargetCommentId(target: V2ReviewTargetInput | null | undefined, getComment: ((id: string) => V2ReviewTargetComment | null | undefined) | null | undefined): string | null;
+export {};

package/dist/superdoc/src/helpers/v2-selection-sync.d.ts

@@ -1,15 +1,41 @@
-export function isV2RangeSnapshot(snapshot: {
-    anchor?: {
-        blockId?: unknown;
-        blockOffset?: unknown;
-    };
-    focus?: {
-        blockId?: unknown;
-        blockOffset?: unknown;
-    };
-} | null | undefined): boolean;
-export function hasOutsideV2DomRangeSelection(selection: Selection | null | undefined, root: Node | null | undefined): boolean;
-export function shouldPreserveHostV2Selection(documentMode: string | null | undefined, hostSnapshot: unknown): boolean;
-export function shouldRetainV2FloatingSelection(hasHostRange: boolean, selectionPosition: {
+type V2SelectionPoint = {
+    blockId?: unknown;
+    blockOffset?: unknown;
+};
+type V2RangeSnapshotInput = {
+    anchor?: V2SelectionPoint | null;
+    focus?: V2SelectionPoint | null;
+};
+/**
+ * A logical v2 selection snapshot represents a non-empty range when its anchor
+ * and focus point at different block positions. Mirrors the range check the v2
+ * shell uses when it emits `v2-selection-changed`.
+ */
+export declare const isV2RangeSnapshot: (snapshot: V2RangeSnapshotInput | null | undefined) => boolean;
+/**
+ * Detect a real browser text selection whose endpoints are outside the active
+ * v2 mount. Editable host selections can have no native DOM range, so an
+ * absent range must not count as an outside selection.
+ */
+export declare const hasOutsideV2DomRangeSelection: (selection: Selection | null | undefined, root: Node | null | undefined) => boolean;
+/**
+ * Decide whether the DOM-selection sync pass should keep the affordance driven
+ * by the v2 host's logical selection instead of clearing it.
+ *
+ * In editable modes the host owns pointer text selection, so native DOM ranges
+ * may be absent or stale. In that case the pointerup sync must defer to the
+ * host snapshot rather than clobber the selection the host just published.
+ * Only editable modes use the host snapshot. Viewing mode keeps native DOM
+ * selection, and unknown modes should not preserve stale host state.
+ */
+export declare const shouldPreserveHostV2Selection: (documentMode: string | null | undefined, hostSnapshot: V2RangeSnapshotInput | null | undefined) => boolean;
+/**
+ * A V2 paint can briefly have no DOM anchor while a selected control is being
+ * rebuilt. Keep an already-positioned comment affordance during that gap when
+ * the host still owns a range; otherwise the button unmounts and remounts on
+ * consecutive paint frames, making it blink and intercepting its own click.
+ */
+export declare const shouldRetainV2FloatingSelection: (hasHostRange: boolean, selectionPosition: {
     source?: unknown;
-} | null | undefined): boolean;
+} | null | undefined) => boolean;
+export {};

package/dist/superdoc/src/helpers/v2-typing-mutation-event.d.ts

@@ -1,5 +1,14 @@
-export function isV2EditableTextMutationEvent(event: {
-    type?: string;
-    origin?: string;
-    editableCommandKind?: string;
-} | null | undefined): boolean;
+/**
+ * True when a forwarded v2 host event is a committed editable-input mutation
+ * of the sustained-typing class, i.e. review-row hydration for it should be
+ * debounced rather than fired immediately.
+ *
+ * Events without a forwarded `editableCommandKind` (programmatic Document API
+ * mutations, history commits, unclassified structural commands) return false
+ * so they keep hydrating immediately.
+ */
+export declare const isV2EditableTextMutationEvent: (event: {
+    type?: unknown;
+    origin?: unknown;
+    editableCommandKind?: unknown;
+} | null | undefined) => boolean;

package/dist/superdoc/src/icons.d.ts

@@ -1,19 +1,11 @@
-import { default as commentIconSvg } from '../../../shared/common/icons/comment-solid.svg?raw';
-import { default as caretDownIconSvg } from '../../../shared/common/icons/caret-down-solid.svg?raw';
-import { default as userCheckIconSvg } from '../../../shared/common/icons/user-check-solid.svg?raw';
-import { default as usersIconSvg } from '../../../shared/common/icons/users-solid.svg?raw';
-import { default as checkIconSvg } from '../../../shared/common/icons/check-solid.svg?raw';
-import { default as xmarkIconSvg } from '../../../shared/common/icons/xmark-solid.svg?raw';
-import { default as ellipsisVerticalSvg } from '../../../shared/common/icons/ellipsis-vertical-solid.svg?raw';
-import { default as rotateLeftSvg } from '../../../shared/common/icons/rotate-left-solid.svg?raw';
-export namespace superdocIcons {
-    export { commentIconSvg as comment };
-    export { caretDownIconSvg as caretDown };
-    export { userCheckIconSvg as internal };
-    export { usersIconSvg as external };
-    export { checkIconSvg as markDone };
-    export { checkIconSvg as acceptChange };
-    export { xmarkIconSvg as rejectChange };
-    export { ellipsisVerticalSvg as overflow };
-    export { rotateLeftSvg as reopen };
-}
+export declare const superdocIcons: {
+    comment: string;
+    caretDown: string;
+    internal: string;
+    external: string;
+    markDone: string;
+    acceptChange: string;
+    rejectChange: string;
+    overflow: string;
+    reopen: string;
+};

package/dist/superdoc/src/internal/diagnostics/translate-diagnostic.d.ts

@@ -13,9 +13,9 @@ type RenderReadinessDiagnostic = {
     reason?: string;
     severity?: string;
     error?: {
-        name?: string;
-        message?: string;
-        stack?: string;
+        name?: unknown;
+        message?: unknown;
+        stack?: unknown;
     };
 };
 /**
@@ -27,7 +27,9 @@ export declare function translateUnzipDiagnostic(record: DiagnosticRecord | null
  * Translates a `V2RenderReadinessDiagnostic`-shaped object (render stage)
  * into a public diagnostic payload, or `null` if out of scope.
  */
-export declare function translateRenderReadinessDiagnostic(diag: RenderReadinessDiagnostic | null | undefined, ctx?: DiagnosticTranslationContext): SuperDocExceptionDiagnosticPayload | null;
+export declare function translateRenderReadinessDiagnostic(diag: RenderReadinessDiagnostic | null | undefined, ctx?: DiagnosticTranslationContext): (SuperDocExceptionDiagnosticPayload & {
+    error: Error;
+}) | null;
 /**
  * Translates a boot/open failure into a public diagnostic payload, or
  * `null` if out of scope.

package/dist/superdoc/src/internal/toolbar/built-in/PageNumberMenu.vue.d.ts

@@ -1,6 +1,16 @@
 import { PropType } from 'vue';
 import { HeaderFooterKind, HeaderFooterPageNumberAlignment, HeaderFooterPageNumbersInfo, SectionPageNumberingFormat } from '../../../../../document-api/src/index.js';
 import { CommandExecutionResult, CommandState } from '../../../public/ui/types.js';
+type CommandReceipt = Exclude<CommandExecutionResult, boolean>;
+type FailedCommandReceipt = Extract<CommandReceipt, {
+    success: false;
+}>;
+type PageNumberCommandResult = boolean | Pick<Extract<CommandReceipt, {
+    success: true;
+}>, 'success'> | (Pick<FailedCommandReceipt, 'success'> & {
+    failure: Pick<FailedCommandReceipt['failure'], 'code' | 'details'>;
+});
+type PageNumberCommandState = Pick<CommandState, 'enabled'> & Partial<CommandState>;
 type PagePosition = 'top' | 'bottom';
 interface PageNumberChoice {
     position: PagePosition;
@@ -26,12 +36,12 @@ type PageNumberMenuOutcome = {
 declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     /** Command state of `page-numbers-apply`, read when the popover opens. */
     pageNumbersState: {
-        type: PropType<CommandState | null>;
+        type: PropType<PageNumberCommandState | null>;
         default: null;
     };
     /** Command state of `page-number-insert` (insert at the header/footer cursor). */
     atCursorState: {
-        type: PropType<CommandState | null>;
+        type: PropType<PageNumberCommandState | null>;
         default: null;
     };
     /** Header/footer structure cannot be suggested, so numbering needs Editing. */
@@ -51,17 +61,17 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     };
     /** Runs `page-numbers-apply` with `{ position, alignment?, showOnFirstPage?, format?, start? }`. */
     applyPageNumbers: {
-        type: PropType<(choice: PageNumberChoice) => Promise<CommandExecutionResult>>;
+        type: PropType<(choice: PageNumberChoice) => Promise<PageNumberCommandResult>>;
         required: true;
     };
     /** Runs `page-numbers-remove`. */
     removePageNumbers: {
-        type: PropType<() => Promise<CommandExecutionResult>>;
+        type: PropType<() => Promise<PageNumberCommandResult>>;
         required: true;
     };
     /** Runs `page-number-insert` at the header/footer cursor. */
     insertAtCursor: {
-        type: PropType<() => Promise<CommandExecutionResult>>;
+        type: PropType<() => Promise<PageNumberCommandResult>>;
         required: true;
     };
     /** Closes the popover after a successful action. */
@@ -71,18 +81,18 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     };
     /** Last choice made in this session, used when the section has no numbers yet. */
     initialChoice: {
-        type: PropType<RememberedChoice | null>;
+        type: PropType<Partial<RememberedChoice> | null>;
         default: null;
     };
 }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     /** Command state of `page-numbers-apply`, read when the popover opens. */
     pageNumbersState: {
-        type: PropType<CommandState | null>;
+        type: PropType<PageNumberCommandState | null>;
         default: null;
     };
     /** Command state of `page-number-insert` (insert at the header/footer cursor). */
     atCursorState: {
-        type: PropType<CommandState | null>;
+        type: PropType<PageNumberCommandState | null>;
         default: null;
     };
     /** Header/footer structure cannot be suggested, so numbering needs Editing. */
@@ -102,17 +112,17 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     };
     /** Runs `page-numbers-apply` with `{ position, alignment?, showOnFirstPage?, format?, start? }`. */
     applyPageNumbers: {
-        type: PropType<(choice: PageNumberChoice) => Promise<CommandExecutionResult>>;
+        type: PropType<(choice: PageNumberChoice) => Promise<PageNumberCommandResult>>;
         required: true;
     };
     /** Runs `page-numbers-remove`. */
     removePageNumbers: {
-        type: PropType<() => Promise<CommandExecutionResult>>;
+        type: PropType<() => Promise<PageNumberCommandResult>>;
         required: true;
     };
     /** Runs `page-number-insert` at the header/footer cursor. */
     insertAtCursor: {
-        type: PropType<() => Promise<CommandExecutionResult>>;
+        type: PropType<() => Promise<PageNumberCommandResult>>;
         required: true;
     };
     /** Closes the popover after a successful action. */
@@ -122,15 +132,15 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     };
     /** Last choice made in this session, used when the section has no numbers yet. */
     initialChoice: {
-        type: PropType<RememberedChoice | null>;
+        type: PropType<Partial<RememberedChoice> | null>;
         default: null;
     };
 }>> & Readonly<{}>, {
     suggesting: boolean;
-    pageNumbersState: CommandState | null;
-    atCursorState: CommandState | null;
+    pageNumbersState: PageNumberCommandState | null;
+    atCursorState: PageNumberCommandState | null;
     inHeaderFooter: boolean;
     loadCurrent: () => Promise<HeaderFooterPageNumbersInfo | null>;
-    initialChoice: RememberedChoice | null;
+    initialChoice: Partial<RememberedChoice> | null;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 export default _default;

package/dist/superdoc/src/internal/toolbar/built-in/ToolbarButton.vue.d.ts

@@ -16,6 +16,7 @@ interface ToolbarButtonItem {
     attributes: Ref<{
         className?: unknown;
         ariaLabel?: string;
+        ariaBusy?: boolean;
     }>;
     nestedOptions?: Ref<{
         label?: string;

package/dist/superdoc/src/internal/toolbar/built-in/constants.d.ts

@@ -1,7 +1,8 @@
 import { DocumentFontOption, FontFamilyOption } from '../../../../../shared/font-system/src/index.js';
 import { ToolbarFontOption } from '../../../core/types/index.js';
 export declare const TOOLBAR_FONTS: ToolbarFontOption[];
-export declare function composeToolbarFontOptions(documentOptions: readonly DocumentFontOption[] | null | undefined, configFonts?: readonly ToolbarFontOption[]): readonly ToolbarFontOption[] | undefined;
+type ToolbarDocumentFontOption = Pick<DocumentFontOption, 'logicalFamily' | 'previewFamily'>;
+export declare function composeToolbarFontOptions(documentOptions: readonly ToolbarDocumentFontOption[] | null | undefined, configFonts?: readonly ToolbarFontOption[]): readonly ToolbarFontOption[] | undefined;
 export declare function mapFontFamilyOptionsToToolbar(options: readonly FontFamilyOption[] | null | undefined): ToolbarFontOption[] | undefined;
 export declare const TOOLBAR_FONT_SIZES: {
     label: string;
@@ -16,3 +17,4 @@ export declare const RESPONSIVE_BREAKPOINTS: {
     lg: number;
     xl: number;
 };
+export {};

package/dist/superdoc/src/internal/toolbar/built-in/font-options.d.ts

@@ -1 +1,15 @@
-export function normalizeFontOption(option: any): any;
+import { ToolbarFontOption } from '../../../core/types/index.js';
+/**
+ * Normalize a font dropdown option so each row renders in its own typeface.
+ *
+ * Consumers can pass a minimal `{ label, key }` shape. The toolbar dropdown
+ * spreads `option.props` onto each rendered `<li>`, so without an inline
+ * `style.fontFamily` every row inherits the toolbar's UI font and the
+ * dropdown loses its visual font preview. This fills that in from
+ * `props.style.fontFamily` → `label` → `key` and keeps the existing
+ * `data-item` hook that e2e selectors rely on.
+ *
+ * Idempotent: if `props.style.fontFamily` and `data-item` are already set,
+ * the option is returned with those values preserved.
+ */
+export declare const normalizeFontOption: <T extends ToolbarFontOption>(option: T) => T;