superdoc 2.28.0-next.9 → 2.29.0-next.1

package/dist/superdoc/src/components/CommentsLayer/CommentHeader.vue.d.ts

@@ -1,8 +1,8 @@
 declare const _default: import('vue').DefineComponent<{}, {
     $emit: (event: "reject" | "resolve" | "reopen" | "overflow-select", ...args: any[]) => void;
     config: Record<string, any>;
-    isPendingInput: boolean;
     isActive: boolean;
+    isPendingInput: boolean;
     resolveDisabledReason: string;
     rejectDisabledReason: string;
     reopenDisabledReason: string;
@@ -12,8 +12,8 @@ declare const _default: import('vue').DefineComponent<{}, {
     timestamp?: number | undefined;
     $props: {
         readonly config?: Record<string, any> | undefined;
-        readonly isPendingInput?: boolean | undefined;
         readonly isActive?: boolean | undefined;
+        readonly isPendingInput?: boolean | undefined;
         readonly resolveDisabledReason?: string | undefined;
         readonly rejectDisabledReason?: string | undefined;
         readonly reopenDisabledReason?: string | undefined;

package/dist/superdoc/src/components/CommentsLayer/CommentInput.vue.d.ts

@@ -2,14 +2,14 @@ declare const _default: import('vue').DefineComponent<{}, {
     focus: (options: any) => void;
     $emit: (event: "focus", ...args: any[]) => void;
     config: Record<string, any>;
-    users: unknown[];
     isFocused: boolean;
+    users: unknown[];
     includeHeader: boolean;
     comment?: Record<string, any> | undefined;
     $props: {
         readonly config?: Record<string, any> | undefined;
-        readonly users?: unknown[] | undefined;
         readonly isFocused?: boolean | undefined;
+        readonly users?: unknown[] | undefined;
         readonly includeHeader?: boolean | undefined;
         readonly comment?: Record<string, any> | undefined;
     };

package/dist/superdoc/src/components/CommentsLayer/FloatingComments.vue.d.ts

@@ -0,0 +1,24 @@
+import { PropType } from 'vue';
+import { Document as SuperDocDocument } from '../../core/types/index.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    currentDocument: {
+        type: PropType<SuperDocDocument>;
+        required: true;
+    };
+    parent: {
+        type: PropType<HTMLElement>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    currentDocument: {
+        type: PropType<SuperDocDocument>;
+        required: true;
+    };
+    parent: {
+        type: PropType<HTMLElement>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    floatingCommentsContainer: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/superdoc/src/components/CommentsLayer/PdfCommentsLayer.vue.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import('vue').DefineComponent<{}, {
+    $emit: (event: "anchor-activate", ...args: any[]) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/superdoc/src/components/general/Avatar.vue.d.ts

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

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

@@ -1,12 +1,30 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    $emit: (event: "close", ...args: any[]) => void;
-    surface: Record<string, any>;
-    scrollLockTarget: Record<string, any>;
-    $props: {
-        readonly surface?: Record<string, any> | undefined;
-        readonly scrollLockTarget?: Record<string, any> | undefined;
-    };
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+import { PropType } from 'vue';
+import { ActiveSurface } from '../../core/surface-manager.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    surface: {
+        type: PropType<ActiveSurface>;
+        required: true;
+    };
+    scrollLockTarget: {
+        type: PropType<HTMLElement | null>;
+        default: null;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    surface: {
+        type: PropType<ActiveSurface>;
+        required: true;
+    };
+    scrollLockTarget: {
+        type: PropType<HTMLElement | null>;
+        default: null;
+    };
+}>> & Readonly<{
+    onClose?: ((...args: any[]) => any) | undefined;
+}>, {
+    scrollLockTarget: HTMLElement | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     dialogRef: HTMLDivElement;
 }, HTMLDivElement>;
 export default _default;

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

@@ -1,19 +1,56 @@
-declare const _default: import('vue').DefineComponent<{}, {
-    close: Function;
-    mode: string;
-    resolve: Function;
-    request: Record<string, any>;
-    render: Function;
-    surfaceId: string;
-    $props: {
-        readonly close?: Function | undefined;
-        readonly mode?: string | undefined;
-        readonly resolve?: Function | undefined;
-        readonly request?: Record<string, any> | 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, {
+import { PropType } from 'vue';
+import { DirectSurfaceRequest, ExternalSurfaceRenderContext, SurfaceMode, SurfaceRequest } from '../../core/types/index.js';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    surfaceId: {
+        type: StringConstructor;
+        required: true;
+    };
+    mode: {
+        type: PropType<SurfaceMode>;
+        required: true;
+    };
+    request: {
+        type: PropType<SurfaceRequest>;
+        required: true;
+    };
+    render: {
+        type: PropType<NonNullable<DirectSurfaceRequest["render"]>>;
+        required: true;
+    };
+    resolve: {
+        type: PropType<ExternalSurfaceRenderContext["resolve"]>;
+        required: true;
+    };
+    close: {
+        type: PropType<ExternalSurfaceRenderContext["close"]>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    surfaceId: {
+        type: StringConstructor;
+        required: true;
+    };
+    mode: {
+        type: PropType<SurfaceMode>;
+        required: true;
+    };
+    request: {
+        type: PropType<SurfaceRequest>;
+        required: true;
+    };
+    render: {
+        type: PropType<NonNullable<DirectSurfaceRequest["render"]>>;
+        required: true;
+    };
+    resolve: {
+        type: PropType<ExternalSurfaceRenderContext["resolve"]>;
+        required: true;
+    };
+    close: {
+        type: PropType<ExternalSurfaceRenderContext["close"]>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     container: HTMLDivElement;
 }, HTMLDivElement>;
 export default _default;

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

@@ -1,4 +1,8 @@
-export function useHighContrastMode(): {
-    isHighContrastMode: import('vue').Ref<boolean, boolean>;
-    setHighContrastMode: (value: any) => void;
-};
+import { InjectionKey, Ref } from 'vue';
+export interface HighContrastMode {
+    isHighContrastMode: Readonly<Ref<boolean>>;
+    setHighContrastMode: (value: boolean) => void;
+}
+export declare const HIGH_CONTRAST_MODE_KEY: InjectionKey<HighContrastMode>;
+export declare function createHighContrastMode(): HighContrastMode;
+export declare function useHighContrastMode(): HighContrastMode;

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

@@ -1,6 +1,6 @@
 import { SurfaceManager } from '../core/surface-manager.js';
 import { DocumentMode, Editor, HyperlinkActivationHandler, LinkPopoverResolver } from '../core/types/index.js';
-import { SuperDocUI } from '../public/ui/types.js';
+import { BorrowedSuperDocUI } from '../public/ui/types.js';
 /**
  * The `v2-link-click` payload the shell relays from the v2 host's
  * `onLinkClick` callback.
@@ -17,9 +17,9 @@ interface LinkClickPayload {
     editableText?: boolean;
 }
 interface UseLinkPopoverOptions {
-    getSurfaceManager: () => SurfaceManager | null | undefined;
+    getSurfaceManager: () => Pick<SurfaceManager, 'open'> | null | undefined;
     getActiveEditor: () => Editor | null | undefined;
-    getUi: () => SuperDocUI | null | undefined;
+    getUi: () => BorrowedSuperDocUI | null | undefined;
     getActivationHandler: () => HyperlinkActivationHandler | LinkPopoverResolver | null | undefined;
     getActivationHandlerSource?: () => 'hyperlinks.onActivate' | 'compatibility' | null | undefined;
     getBuiltInEditorDisabled?: () => boolean;

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

@@ -0,0 +1,10 @@
+import { ComponentPublicInstance } from 'vue';
+import { SuperDoc } from '../core/SuperDoc.js';
+export type SuperDocComponentProxy = ComponentPublicInstance & {
+    $superdoc: SuperDoc;
+};
+export interface SuperDocInstanceAccess {
+    proxy: SuperDocComponentProxy;
+    superdoc: SuperDoc;
+}
+export declare function useSuperDocInstance(): SuperDocInstanceAccess;

package/dist/superdoc/src/core/SuperDoc.d.ts

@@ -206,10 +206,6 @@ export declare class SuperDoc extends EventEmitter<SuperDocEventMap> {
      * @private
      */
     private commentsStore;
-    /**
-     * @private
-     */
-    private highContrastModeStore;
     /**
      * Internal mount handle for the `SuperComments` Vue component, created
      * lazily by `addCommentsList()` and torn down by `removeCommentsList()`.
@@ -238,7 +234,7 @@ export declare class SuperDoc extends EventEmitter<SuperDocEventMap> {
      * internal source compilation.
      *
      * Same SD-3213f-style TS surface hide as
-     * `superdocStore` / `commentsStore` / `highContrastModeStore` /
+     * `superdocStore` / `commentsStore` /
      * `commentsList`; not runtime privacy.
      *
      * @private
@@ -696,7 +692,7 @@ export declare class SuperDoc extends EventEmitter<SuperDocEventMap> {
      * @deprecated replaceWith=`await superdoc.activeEditor.doc.getHtml({})` removeIn=v3.0
      * @param _options Ignored.
      */
-    getHTML(_options?: Parameters<Editor['getHTML']>[0]): unknown[];
+    getHTML(_options?: Parameters<NonNullable<Editor['getHTML']>>[0]): unknown[];
     /**
      * Lock the current superdoc and emit the `locked` event.
      *

package/dist/superdoc/src/core/collaboration/helpers.d.ts

@@ -1,8 +1,3 @@
 export function loadCommentsFromYdoc(superdoc: Object): boolean;
 export function initCollaborationComments(superdoc: Object): void;
-export function initSuperdocYdoc(superdoc: Object): {
-    ydoc: import('yjs').Doc;
-    provider: import('../types/index.js').CollaborationProvider;
-} | undefined;
-export function makeDocumentsCollaborative(superdoc: Object): any;
 export function syncCommentsToClients(superdoc: Object, event: Object): void;

package/dist/superdoc/src/core/collaboration/permissions.d.ts

@@ -11,6 +11,7 @@ export const PERMISSIONS: Readonly<{
     VERSION_HISTORY: "VERSION_HISTORY";
 }>;
 export function createTrackedChangePermissionResolver(superdoc: any): (payload?: {}) => any;
+export function readBuiltInTrackedChangePermissionDecision(superdoc: any, canPerform: any, permission: any, trackedChange: any): any;
 export function isAllowed(permission: string, role: string, isInternal: boolean, context?: {
     comment?: object | null | undefined;
     superdoc?: object | null | undefined;

package/dist/superdoc/src/core/collaboration/resolve-v2-collaboration-target.d.ts

@@ -21,7 +21,7 @@ export type SupportedV2ProviderFamily = 'y-websocket' | 'hocuspocus' | 'livebloc
  * collaboration room. These strings are part of the diagnostic contract and are
  * safe to assert against in tests; they never carry caller-provided values.
  */
-export type V2CollaborationUnsupportedReason = 'missing-target' | 'invalid-document-id' | 'invalid-server-url' | 'invalid-room-mode' | 'invalid-auth-endpoint' | 'invalid-adapter-id' | 'invalid-provider-options' | 'invalid-sync-timeout' | 'missing-auth' | 'mixed-auth' | 'unsupported-document-type' | 'unsupported-multi-document' | 'unsupported-legacy-provider' | 'unsupported-provider-family';
+export type V2CollaborationUnsupportedReason = 'missing-target' | 'invalid-document-id' | 'invalid-server-url' | 'invalid-room-mode' | 'invalid-auth-endpoint' | 'invalid-base-url' | 'invalid-adapter-id' | 'invalid-provider-options' | 'invalid-sync-timeout' | 'missing-auth' | 'mixed-auth' | 'unsupported-document-type' | 'unsupported-multi-document' | 'unsupported-legacy-provider' | 'unsupported-provider-family';
 /**
  * Normalized, supported v2 collaboration room target.
  *
@@ -45,6 +45,7 @@ export interface NormalizedV2CollaborationTarget {
     publicApiKey?: string;
     /** Liveblocks server-side auth endpoint mode. */
     authEndpoint?: string;
+    baseUrl?: string;
     /** Adapter registration key for a customer collaboration Worker. */
     adapterId?: string;
     /** Structured-clone-safe options interpreted by the registered adapter. */

package/dist/superdoc/src/core/create-app.d.ts

@@ -1,8 +1,8 @@
 import { useSuperdocStore } from '../stores/superdoc-store.js';
 import { useCommentsStore } from '../stores/comments-store.js';
-import { useHighContrastMode } from '../composables/use-high-contrast-mode.js';
-export function createSuperdocVueApp({ disablePiniaDevtools }?: {
+export function createSuperdocVueApp({ disablePiniaDevtools, highContrastMode }: {
     disablePiniaDevtools?: boolean | undefined;
+    highContrastMode: import('../composables/use-high-contrast-mode.js').HighContrastMode;
 }): SuperdocVueAppRefs;
 /**
  * Result of `createSuperdocVueApp()`. Internal-only: the shape is consumed
@@ -25,8 +25,4 @@ export type SuperdocVueAppRefs = {
      * The Comments Pinia store
      */
     commentsStore: ReturnType<typeof useCommentsStore>;
-    /**
-     * The high-contrast mode composable refs (`isHighContrastMode`, `setHighContrastMode`). Named `*Store` for historical reasons; this is a plain Vue composable, not a Pinia store.
-     */
-    highContrastModeStore: ReturnType<typeof useHighContrastMode>;
 };

package/dist/superdoc/src/core/editor-runtime/types.d.ts

@@ -140,6 +140,8 @@ export type EditorRuntimeRejectionCode = 'runtime-not-ready' | 'host-saving' | '
  * must not inspect these to invalidate document state.
  */
 export type EditorRuntimeCommandResult = {
+    status: 'selected';
+} | {
     status: 'committed';
     receipt?: unknown;
 } | {

package/dist/superdoc/src/core/editor-runtime/v2/v2-editor-runtime-adapter.d.ts

@@ -40,6 +40,8 @@ interface HostDispatchRejectionLike {
     readonly detail?: string;
 }
 type HostDispatchResultLike = {
+    readonly status: 'selected';
+} | {
     readonly status: 'committed';
     readonly receipt?: unknown;
 } | {

package/dist/superdoc/src/core/types/index.d.ts

@@ -500,7 +500,12 @@ export interface Editor {
     setHighContrastMode?: (isHighContrast: boolean) => unknown;
     on?: (...args: unknown[]) => unknown;
     off?: (...args: unknown[]) => unknown;
-    getHTML: (options?: Record<string, unknown>) => unknown;
+    /**
+     * Not implemented by the superdoc@2 active editor; guard before calling.
+     *
+     * @deprecated replaceWith=`await editor.doc.getHtml({})` removeIn=v3.0
+     */
+    getHTML?: (options?: Record<string, unknown>) => unknown;
     getDocumentId?: () => string | null | undefined;
     /**
      * Narrow v2 extension facet for command execution and diagnostics, backed by
@@ -651,6 +656,7 @@ export interface V2LiveblocksCollaborationConfig {
      * page; non-browser SDK/CLI callers must use an absolute HTTP(S) URL.
      */
     authEndpoint?: string;
+    baseUrl?: string;
     /** Maximum initial synchronization wait in milliseconds. Defaults to 30,000. */
     syncTimeoutMs?: number;
     /** Explicit room operation. Defaults to `'join'`; `'create'` never joins an existing room. */
@@ -2996,9 +3002,9 @@ export interface SuperDocTrackedChangesBulkDecisionPayload {
  * the editor it is bound to and ignore anything else.
  *
  * Typed `unknown` rather than `Editor`: the active editor can be a v2 facade
- * that does not satisfy `Editor` (`getHTML` is required there and absent on the
- * facade), so annotating it as `Editor` would promise methods that are not
- * present. It is an identity token to compare, not an object to call.
+ * whose runtime shape does not match `Editor`, so annotating it as `Editor`
+ * would promise members it does not have. It is an identity token to compare,
+ * not an object to call.
  */
 export interface SuperDocDocumentReplacedPayload {
     editor: unknown;

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

@@ -32,6 +32,7 @@ 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;

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

@@ -1,86 +1,106 @@
+import { Component } from 'vue';
 import { isSyntheticTrackedChangeCommentLaneItem } from '../../helpers/tracked-change-comment-lane.js';
-/**
- * Replace the package loader before engine loading starts. The CDN entry uses
- * this seam to fetch the exact engine version from its public package URL.
- *
- * @param {() => Promise<unknown>} loader
- */
-export function configureDefaultV2IntegrationLoader(loader: () => Promise<unknown>): void;
-/** Load the engine before Vue evaluates the synchronous integration seam. */
-export function loadDefaultV2Integration(): Promise<void>;
-/** Load the engine for editor startup, preserving the fail-closed stub on failure. */
-export function loadDefaultV2IntegrationOrFallback(): Promise<void>;
-/**
- * @param {{ trackedChange?: unknown, trackedChangeAnchorKey?: unknown } | null | undefined} row
- * @returns {boolean}
- */
-export function isV2SyntheticTrackedChangeRow(row: {
-    trackedChange?: unknown;
-    trackedChangeAnchorKey?: unknown;
-} | null | undefined): boolean;
-/**
- * @returns {SuperDocV2Integration}
- */
-export function createStubV2Integration(): SuperDocV2Integration;
-/**
- * Build the default v2 integration the runtime always uses. The v2
- * browser shell is the only source of the editor runtime; no customer-provided
- * integration is consulted. Falls back to the local stub only if the engine
- * shell throws during construction (defensive, never selects v1).
- *
- * @returns {SuperDocV2Integration}
- */
-export function createDefaultV2Integration(): SuperDocV2Integration;
-/**
- * @param {SuperDocV2Integration | null | undefined} integration
- * @returns {boolean}
- */
-export function hasRealV2Integration(integration: SuperDocV2Integration | null | undefined): boolean;
-/**
- * @typedef {Object} SuperDocV2Integration
- * @property {number} version Integration contract version.
- * @property {unknown} [capabilities] Optional capability snapshot/hints.
- * @property {unknown} EditorComponent Vue component that boots the V2 DOCX editor.
- * @property {unknown} [RulerComponent] Optional Vue component for the V2 ruler.
- * @property {(...args: unknown[]) => unknown} [createGeometryPublisher] Factory for the V2 geometry publisher.
- * @property {(...args: unknown[]) => unknown} [createReviewWindowController] Factory for the committed V2 review-window controller.
- * @property {(value: unknown) => boolean} [isSyntheticTrackedChangeCommentLaneItem] Predicate for synthetic tracked-change comment-lane items.
- * @property {(value: unknown) => boolean} [isV2SyntheticTrackedChangeRow] Predicate for synthesized V2 tracked-change rows.
- */
-/** Default version for the local stub integration (V1-compatible). */
-export const SUPERDOC_V2_INTEGRATION_VERSION: 1;
-export { isSyntheticTrackedChangeCommentLaneItem };
-export type SuperDocV2Integration = {
-    /**
-     * Integration contract version.
-     */
+export interface V2GeometryPublishOptions {
+    retainMissingTrackedChangeGeometry?: boolean;
+    retainedTrackedChangeIds?: Iterable<string>;
+    reason?: string;
+}
+export interface V2GeometryPayload {
+    mountContainer: HTMLElement | null;
+    epoch?: number | null;
+    host?: unknown;
+    mount?: unknown;
+}
+export type V2CommittedPageWindow = Readonly<Record<string, unknown>>;
+export interface V2GeometryPublisherOptions {
+    getLayersContainer: () => HTMLElement | null;
+    isCommentsEnabled: () => boolean;
+    publishPositions: (positions: Record<string, unknown>, options?: V2GeometryPublishOptions) => void;
+    clearPositions: () => void;
+    readCurrentPositions?: () => Record<string, unknown>;
+    setGeometryAvailable?: (value: boolean) => void;
+}
+export interface V2GeometryPublisher {
+    publish(payload: V2GeometryPayload | null, options?: V2GeometryPublishOptions): Promise<void> | void;
+    recollect(options?: V2GeometryPublishOptions): Promise<void> | void;
+    noteCommittedPageWindow?(window: V2CommittedPageWindow | null | undefined): void;
+    reset(): void;
+    getLastEpoch(): number | null;
+    getLastPayload(): V2GeometryPayload | null;
+}
+export interface V2ReviewWindowContext {
+    superdoc: unknown;
+    documentId: string;
+    commentsAdapter: unknown;
+    trackedChangesAdapter: unknown;
+    resolveReviewWindow: (input: unknown) => unknown;
+    moveFragmentWordIds: (ids: readonly string[]) => unknown;
+}
+export interface V2ReviewWindowResult {
+    comments?: {
+        items?: readonly unknown[];
+        requestedIds?: readonly string[];
+        unresolvedCommentIds?: readonly string[];
+    };
+    trackedChanges?: {
+        items?: readonly unknown[];
+        requestedIds?: readonly string[];
+        unresolvedTargets?: readonly unknown[];
+    };
+    preparedReview?: unknown;
+}
+export interface V2ReviewWindowControllerOptions {
+    applyReviewWindow?: ((context: V2ReviewWindowContext, result: V2ReviewWindowResult) => unknown) | null;
+}
+export interface V2ReviewMutationSettlement {
+    outcome: 'aborted' | 'rejected' | 'committed';
+    allResolved?: boolean;
+    resumeDomains?: readonly ('comments' | 'trackedChanges')[];
+    trackedRowCount?: number | null;
+}
+export interface V2ReviewWindowSnapshot {
+    readonly status: 'pending' | 'ready' | 'stale';
+    readonly [field: string]: unknown;
+}
+export interface V2ReviewWindowDiagnostics {
+    generation: number;
+    reviewEpoch: number;
+    hasContext: boolean;
+    inFlight: boolean;
+    queued: boolean;
+    mutationPaused: boolean;
+    records: readonly Record<string, unknown>[];
+}
+export interface V2ReviewWindowController {
+    setContext(context: V2ReviewWindowContext | null): void;
+    onCommittedPagePaint?(commit: V2CommittedPageWindow): void;
+    refreshCommittedWindow(reason?: string): void;
+    invalidate(reason?: string): void;
+    beginMutation(fact: string | {
+        token?: string;
+    } | null | undefined): void;
+    settleMutation(token: string | undefined, settlement?: V2ReviewMutationSettlement): void;
+    reset(reason?: string): void;
+    getSnapshot?(): V2ReviewWindowSnapshot | null;
+    subscribe?(listener: (snapshot: V2ReviewWindowSnapshot) => void): () => void;
+    getDiagnostics(): V2ReviewWindowDiagnostics | null;
+}
+export interface SuperDocV2Integration {
     version: number;
-    /**
-     * Optional capability snapshot/hints.
-     */
-    capabilities?: unknown;
-    /**
-     * Vue component that boots the V2 DOCX editor.
-     */
-    EditorComponent: unknown;
-    /**
-     * Optional Vue component for the V2 ruler.
-     */
-    RulerComponent?: unknown;
-    /**
-     * Factory for the V2 geometry publisher.
-     */
-    createGeometryPublisher?: ((...args: unknown[]) => unknown) | undefined;
-    /**
-     * Factory for the committed V2 review-window controller.
-     */
-    createReviewWindowController?: ((...args: unknown[]) => unknown) | undefined;
-    /**
-     * Predicate for synthetic tracked-change comment-lane items.
-     */
-    isSyntheticTrackedChangeCommentLaneItem?: ((value: unknown) => boolean) | undefined;
-    /**
-     * Predicate for synthesized V2 tracked-change rows.
-     */
-    isV2SyntheticTrackedChangeRow?: ((value: unknown) => boolean) | undefined;
-};
+    capabilities: unknown;
+    EditorComponent: Component;
+    RulerComponent: Component | null;
+    createGeometryPublisher: (options: V2GeometryPublisherOptions) => V2GeometryPublisher;
+    createReviewWindowController: (options: V2ReviewWindowControllerOptions) => V2ReviewWindowController;
+    isSyntheticTrackedChangeCommentLaneItem: (value: unknown) => boolean;
+    isV2SyntheticTrackedChangeRow: (value: unknown) => boolean;
+}
+export declare function configureDefaultV2IntegrationLoader(loader: () => Promise<unknown>): void;
+export declare function loadDefaultV2Integration(): Promise<void>;
+export declare function loadDefaultV2IntegrationOrFallback(): Promise<void>;
+export declare const SUPERDOC_V2_INTEGRATION_VERSION = 1;
+export { isSyntheticTrackedChangeCommentLaneItem };
+export declare function isV2SyntheticTrackedChangeRow(row: unknown): boolean;
+export declare function createStubV2Integration(): SuperDocV2Integration;
+export declare function createDefaultV2Integration(): SuperDocV2Integration;
+export declare function hasRealV2Integration(integration: SuperDocV2Integration | null | undefined): boolean;

package/dist/superdoc/src/helpers/is-finite-number.d.ts

@@ -0,0 +1 @@
+export declare function isFiniteNumber(value: unknown): value is number;

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

@@ -26,6 +26,8 @@ type CommentInvalidationInput = {
     superdoc?: SuperDoc | null;
     documentId?: string | null;
 };
+export declare function mutationCommittedEventChangedVisibleContent(event: Record<string, unknown>): boolean;
+export declare function mutationCommittedEventChangedDocument(event: Record<string, unknown>): boolean;
 /**
  * Classify the tracked-change identities carried by a v2 mutation event.
  *

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

@@ -12,12 +12,12 @@
  * event only fires on success, fires AFTER the diagnostics events on the
  * success path, and never fires at all for a failed attempt.
  *
- * @param {{generation?: unknown}} [payload]
+ * @param {{generation?: unknown} | null} [payload]
  * @returns {number}
  */
 export function getV2DiagnosticGeneration(payload?: {
     generation?: unknown;
-}): number;
+} | null): number;
 /**
  * Creates a dedupe tracker for diagnostic emissions, scoped by documentId
  * and generation. The key is `internalCode` only (per active generation) --

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

@@ -12,6 +12,11 @@ type RenderReadinessDiagnostic = {
     code?: string;
     reason?: string;
     severity?: string;
+    error?: {
+        name?: string;
+        message?: string;
+        stack?: string;
+    };
 };
 /**
  * Translates a `SDDiagnosticRecord`-shaped object (package-open / unzip