superdoc 2.29.0-next.9 → 2.29.0

package/dist/superdoc/src/components/CommentsLayer/tracked-change-threading.d.ts

@@ -1 +1,16 @@
-export function trackedChangeThreadParentIdForComment(comment: Record<string, any> | null | undefined): string | number | null;
+export type TrackedChangeThreadSource<Id> = {
+    trackedChangeThreadParentId?: Id | null;
+    trackedChangeParentId?: Id | null;
+    trackedChangeLink?: unknown;
+    trackedChangeType?: unknown;
+    trackedChangeDisplayType?: unknown;
+    trackedChangeText?: unknown;
+    deletedText?: unknown;
+    trackedChange?: unknown;
+};
+/**
+ * Resolve explicit thread provenance first, then the guarded legacy fallback.
+ * Spatial-only v2 comments carry neither the explicit field nor a legacy
+ * review signal and therefore remain standalone.
+ */
+export declare const trackedChangeThreadParentIdForComment: <Id>(comment: TrackedChangeThreadSource<Id> | null | undefined) => Id | null;

package/dist/superdoc/src/components/Whiteboard/WhiteboardLayer.vue.d.ts

@@ -1,13 +1,12 @@
 import { PropType } from 'vue';
-import { WhiteboardPage as WhiteboardPageModel } from '../../core/whiteboard/WhiteboardPage.js';
-import { WhiteboardDropTarget, WhiteboardPageOffset, WhiteboardPageSize } from './whiteboard-types.js';
+import { WhiteboardDropTarget, WhiteboardPageOffset, WhiteboardPageSize, WhiteboardPageView } from './whiteboard-types.js';
 declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     whiteboard: {
         type: PropType<WhiteboardDropTarget>;
         required: true;
     };
     pages: {
-        type: PropType<WhiteboardPageModel[]>;
+        type: PropType<WhiteboardPageView[]>;
         default: () => never[];
     };
     pageSizes: {
@@ -43,7 +42,7 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         required: true;
     };
     pages: {
-        type: PropType<WhiteboardPageModel[]>;
+        type: PropType<WhiteboardPageView[]>;
         default: () => never[];
     };
     pageSizes: {
@@ -76,7 +75,7 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
 }>> & Readonly<{}>, {
     enabled: boolean;
     opacity: number;
-    pages: WhiteboardPageModel[];
+    pages: WhiteboardPageView[];
     pageSizes: Record<number, WhiteboardPageSize>;
     pageOffsets: Record<number, WhiteboardPageOffset>;
     interactive: boolean | null;

package/dist/superdoc/src/components/Whiteboard/WhiteboardPage.vue.d.ts

@@ -1,13 +1,12 @@
 import { PropType } from 'vue';
-import { WhiteboardPage } from '../../core/whiteboard/WhiteboardPage.js';
-import { WhiteboardDropTarget, WhiteboardPageOffset, WhiteboardPageSize } from './whiteboard-types.js';
+import { WhiteboardDropTarget, WhiteboardPageOffset, WhiteboardPageSize, WhiteboardPageView } from './whiteboard-types.js';
 declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     whiteboard: {
         type: PropType<WhiteboardDropTarget>;
         required: true;
     };
     page: {
-        type: PropType<WhiteboardPage>;
+        type: PropType<WhiteboardPageView>;
         required: true;
     };
     pageSize: {
@@ -28,7 +27,7 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         required: true;
     };
     page: {
-        type: PropType<WhiteboardPage>;
+        type: PropType<WhiteboardPageView>;
         required: true;
     };
     pageSize: {

package/dist/superdoc/src/components/Whiteboard/whiteboard-types.d.ts

@@ -1,4 +1,5 @@
 import { Whiteboard } from '../../core/whiteboard/Whiteboard.js';
+import { WhiteboardPage } from '../../core/whiteboard/WhiteboardPage.js';
 export type WhiteboardPageSize = {
     width: number;
     height: number;
@@ -9,3 +10,4 @@ export type WhiteboardPageOffset = {
     left: number;
 };
 export type WhiteboardDropTarget = Pick<Whiteboard, 'getTool' | 'getType'>;
+export type WhiteboardPageView = Pick<WhiteboardPage, 'pageIndex' | 'size' | 'mount' | 'resize' | 'destroy' | 'addImage' | 'addText'>;

package/dist/superdoc/src/components/surfaces/watermark-surface-runtime.d.ts

@@ -1,8 +1,8 @@
-/** The runtime owns its Vue component; consumers only need the surface request value. */
-export function createWatermarkSurfaceRuntime(getContainer?: () => HTMLElement | null): {
-  component: unknown;
-  captureFocusReturn(): (isCurrent: () => boolean) => Promise<void>;
-  mount(): void;
-  announce(message: string): void;
-  destroy(): void;
+/** Keeps Vue rendering and post-dismissal announcements outside the public type graph. */
+export declare function createWatermarkSurfaceRuntime(getContainer?: () => HTMLElement | null): {
+    component: unknown;
+    captureFocusReturn(): (isCurrent: () => boolean) => Promise<void>;
+    mount(): void;
+    announce(message: string): void;
+    destroy(): void;
 };

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

@@ -1,10 +1,14 @@
-export function useCommentSmallScreen({ commentsModuleConfig, superdocRoot, layers }: {
-    commentsModuleConfig: any;
-    superdocRoot: any;
-    layers: any;
-}): {
-    superdocContainerWidth: import('vue').Ref<number, number>;
-    isCompactCommentsMode: import('vue').Ref<boolean, boolean>;
+import { Ref } from 'vue';
+import { CommentsConfig } from '../core/types/index.js';
+interface UseCommentSmallScreenOptions {
+    commentsModuleConfig: Readonly<Ref<CommentsConfig | null | undefined>>;
+    superdocRoot: Readonly<Ref<HTMLElement | null>>;
+    layers: Readonly<Ref<HTMLElement | null>>;
+}
+export declare function useCommentSmallScreen({ commentsModuleConfig, superdocRoot, layers }: UseCommentSmallScreenOptions): {
+    superdocContainerWidth: Ref<number, number>;
+    isCompactCommentsMode: Ref<boolean, boolean>;
     recalculateCompactCommentsMode: () => void;
     ensureCompactMeasurementObserver: () => void;
 };
+export {};

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

@@ -1,21 +1,47 @@
-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;
-    }>;
+import { Ref } from 'vue';
+import { RuntimeDocument } from '../core/types/index.js';
+type CompactComment = {
+    commentId?: unknown;
+    importedId?: unknown;
+    selection?: {
+        source?: unknown;
+    } | null;
+};
+type CompactSelectionPosition = {
+    top?: unknown;
+    bottom?: unknown;
+    source?: unknown;
+};
+type CommentPositionLookup = (commentOrId: unknown) => {
+    entry: {
+        bounds?: {
+            top?: unknown;
+            bottom?: unknown;
+        } | null;
+    } | null;
+};
+type PopoverStyle = {
+    top: string;
+    left?: string;
+    right: string;
+};
+interface UseCompactCommentPopoverOptions {
+    activeComment: Readonly<Ref<unknown>>;
+    pendingComment: Readonly<Ref<CompactComment | null | undefined>>;
+    activeCompactComment: Readonly<Ref<CompactComment | null | undefined>>;
+    showCommentsSidebar: Readonly<Ref<unknown>>;
+    selectionPosition: Readonly<Ref<CompactSelectionPosition | null | undefined>>;
+    activeZoom: Readonly<Ref<number | null | undefined>>;
+    superdocRoot: Readonly<Ref<HTMLElement | null>>;
+    layers: Readonly<Ref<HTMLElement | null>>;
+    documents: Readonly<Ref<readonly Pick<RuntimeDocument, 'type'>[] | null | undefined>>;
+    resolveCommentPositionEntry: CommentPositionLookup;
+    clearActiveComment: () => void;
+    clearPendingComment: () => void;
+}
+export declare function useCompactCommentPopover({ activeComment, pendingComment, activeCompactComment, showCommentsSidebar, selectionPosition, activeZoom, superdocRoot, layers, documents, resolveCommentPositionEntry, clearActiveComment, clearPendingComment, }: UseCompactCommentPopoverOptions): {
+    compactCommentPopoverStyle: import('vue').ComputedRef<PopoverStyle>;
     closeCompactCommentPopover: () => void;
     resetClickAnchor: () => void;
 };
+export {};

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

@@ -1,9 +1,19 @@
 import { Ref } from 'vue';
 import { SurfaceManager } from '../core/surface-manager.js';
 import { Editor, FindReplaceConfig } from '../core/types/index.js';
-import { SearchController } from '../public/ui/types.js';
+import { SearchController, SearchSnapshot } from '../public/ui/types.js';
+type FindReplaceSearchQuery = (...args: Parameters<SearchController['find']>) => Partial<SearchSnapshot>;
+export type FindReplaceSearch = Pick<SearchController, 'next' | 'previous' | 'clear' | 'replace' | 'replaceAll'> & {
+    getSnapshot: () => Partial<SearchSnapshot>;
+} & ({
+    find: FindReplaceSearchQuery;
+    search?: FindReplaceSearchQuery;
+} | {
+    find?: undefined;
+    search: FindReplaceSearchQuery;
+});
 type UseFindReplaceOptions = {
-    getSurfaceManager: () => SurfaceManager | null;
+    getSurfaceManager: () => Pick<SurfaceManager, 'open'> | null;
     getActiveEditor: () => Editor | null;
     activeEditorRef?: Ref<Editor | null | undefined>;
     getFindReplaceConfig?: () => boolean | FindReplaceConfig | undefined;
@@ -12,7 +22,7 @@ type UseFindReplaceOptions = {
      * slice is the single find/replace session authority.
      */
     getSuperDocUI?: () => {
-        search?: SearchController | null;
+        search?: FindReplaceSearch | null;
     } | null | undefined;
 };
 /**

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

@@ -10,7 +10,7 @@ export interface PasswordPromptException {
     editor?: Editor | null;
 }
 export interface UsePasswordPromptOptions {
-    getSurfaceManager: () => SurfaceManager | null;
+    getSurfaceManager: () => Pick<SurfaceManager, 'open'> | null;
     getPasswordPromptConfig: () => boolean | PasswordPromptConfig | undefined;
     /**
      * Called when a queued prompt cannot be shown (resolver returned `none`, config error, or resolver threw).

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

@@ -1,3 +1,63 @@
+import { Ref } from 'vue';
+import { RuntimeDocument, SuperDocFitWidthOptions, SuperDocViewportMetrics, SuperDocZoomConfig, SuperDocZoomMode } from '../core/types/index.js';
+import { PageMetricsPage, PageMetricsSnapshot } from '../public/ui/page-metrics.js';
+export type ResolvedFitWidthOptions = Required<SuperDocFitWidthOptions>;
+type PageWidthSnapshot = Partial<Pick<PageMetricsSnapshot, 'widestPageWidthPx'>> & {
+    pages?: ReadonlyArray<{
+        base?: Partial<Pick<PageMetricsPage['base'], 'widthPx'>>;
+    } | null | undefined>;
+};
+type EditorPageGeometry = {
+    pageMetrics?: {
+        getSnapshot?: () => PageWidthSnapshot | null | undefined;
+    } | null;
+    getPages?: () => Array<{
+        size?: {
+            w?: unknown;
+        };
+    } | null | undefined> | null | undefined;
+    getPageStyles?: () => {
+        pageSize?: {
+            width?: unknown;
+        };
+    } | null | undefined;
+};
+type ViewportFitEventName = 'editorCreate' | 'pagination-update' | 'pdf:document-ready';
+interface ViewportFitSuperDoc {
+    config?: {
+        zoom?: Pick<SuperDocZoomConfig, 'fitWidth'> | null;
+    } | null;
+    activeEditor?: EditorPageGeometry | null;
+    emit(event: 'zoomChange', payload: {
+        zoom: number;
+        mode: 'fit-width';
+    }): unknown;
+    emit(event: 'viewport-change', payload: SuperDocViewportMetrics): unknown;
+    on?(event: ViewportFitEventName, listener: () => void): unknown;
+    off?(event: ViewportFitEventName, listener: () => void): unknown;
+}
+interface UseViewportFitOptions {
+    getSuperdoc: () => ViewportFitSuperDoc | null | undefined;
+    superdocContainerWidth: Readonly<Ref<number>>;
+    isReady: Readonly<Ref<boolean>>;
+    activeZoom: Ref<number>;
+    zoomMode: Readonly<Ref<SuperDocZoomMode>>;
+    viewportMetrics: Ref<SuperDocViewportMetrics | null>;
+    showCommentsSidebar?: Readonly<Ref<unknown>>;
+    rightSidebarRef?: Readonly<Ref<HTMLElement | null>>;
+    superdocRoot: Readonly<Ref<HTMLElement | null>>;
+    documents?: Readonly<Ref<readonly RuntimeDocument[]>>;
+}
+export declare const FIT_WIDTH_DEFAULTS: Readonly<{
+    min: 10;
+    max: 100;
+    padding: 0;
+}>;
+export declare const resolveFitWidthOptions: (rawFitConfig: unknown) => ResolvedFitWidthOptions;
+export declare const computeFitZoom: (availableWidth: number, documentWidth: number) => number | null;
+export declare const computeAppliedFitZoom: (availableWidth: number, documentWidth: number, options: ResolvedFitWidthOptions) => number | null;
+export declare const normalizePdfPageMeasurement: (measured: number, scaleFactor: number, zoomFactor: number) => number | null;
+export declare const resolveEditorPageWidth: (editor: EditorPageGeometry | null | undefined) => number | null;
 /**
  * Viewport fit tracking. Maintains pure viewport metrics (available width,
  * document base width, fit zoom), stores them for `getViewportMetrics()`,
@@ -21,31 +81,7 @@
  * 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;
-}): {
+export declare function useViewportFit({ getSuperdoc, superdocContainerWidth, isReady, activeZoom, zoomMode, viewportMetrics, showCommentsSidebar, rightSidebarRef, superdocRoot, documents, }: UseViewportFitOptions): {
     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;
-export function resolveEditorPageWidth(editor: any): number | null;
+export {};

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

@@ -223,9 +223,9 @@ export declare class SuperDoc extends EventEmitter<SuperDocEventMap> {
      * mount/unmount, `provide()`, and `config.globalProperties` setup.
      * Not consumer API: no docs or examples reference `superdoc.app`,
      * and the only cross-file reader (`SuperComments.createVueApp()`
-     * at `super-comments-list.js:35`) is a `.js` file under
-     * `checkJs: false`, so the `@private` boundary does not break
-     * internal source compilation.
+     * in `super-comments-list.ts`) uses bracket access, which
+     * TypeScript allows for `private` members, so the `@private`
+     * boundary does not break internal source compilation.
      *
      * Same SD-3213f-style TS surface hide as
      * `superdocStore` / `commentsStore` /

package/dist/superdoc/src/core/pdf/pdf-adapter.d.ts

@@ -20,10 +20,14 @@ export declare class PDFJSAdapter extends PDFAdapter {
     workerSrc: string | undefined;
     constructor(config: PDFJSConfig);
     getDocument(file: PdfSource): Promise<PDFDocumentProxy>;
-    getPages(pdf: PDFDocumentProxy, firstPage: number, lastPage: number): Promise<PDFPageProxy[]>;
+    getPages<Page = PDFPageProxy>(pdf: {
+        getPage(pageNumber: number): Promise<Page>;
+    }, firstPage: number, lastPage: number): Promise<Page[]>;
 }
 export declare class PDFAdapterFactory {
-    static create(config: PDFConfig): PDFJSAdapter;
+    static create(config: PDFJSConfig & {
+        adapter: string;
+    }): PDFJSAdapter;
 }
 export declare function getWorkerSrcFromCDN(version: string): string;
 export {};

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

@@ -2919,6 +2919,7 @@ export interface EditorUpdateEvent {
      * available. Always present (defaults to `null`); may be `null`.
      */
     sectionType: string | null;
+    isRemote: boolean;
 }
 /**
  * Payload emitted with the `ready` event and passed to `Config.onReady`.
@@ -3071,18 +3072,50 @@ export interface SuperDocAwarenessUpdatePayload {
  * `Config.onCommentsUpdate`. Field set differs from older inline
  * declarations: the runtime emits `comment?` and `changes?` (never a
  * `data` field).
+ *
+ * A refused comment mutation emits `rejected: true` with a stable `reason`
+ * (e.g. `'adapter-threw'`, `'receipt-failure'`) and leaves the comment list
+ * unchanged so the user can retry. It may add the document receipt failure
+ * `code` (e.g. `'TARGET_NOT_FOUND'`), a `detail` (an error message or a
+ * structured description of the mismatch), and `committed: true` when the
+ * change reached the document but could not be confirmed in the comment list.
  */
 export interface SuperDocCommentsUpdatePayload {
-    /** Update kind (e.g. `'created'`, `'updated'`, `'deleted'`); set by the comments store. */
+    /** Update kind (e.g. `'add'`, `'update'`, `'deleted'`, `'resolved'`, `'pending'`); set by the comments store. */
     type: string;
-    /** The comment object the update refers to, when applicable. */
-    comment?: Comment;
-    /** Per-field change set when the update is a mutation. */
+    /** The comment object the update refers to, when applicable; `null` when a created comment could not be read back. */
+    comment?: Comment | null;
+    /** Per-field change set: `'deleted'` names the comment; `text`, `isInternal`, `resolvedTime` carry `value` (check its type, not just `key`). */
     changes?: Array<{
         key: string;
         commentId: string;
         fileId?: string | null;
+        value?: undefined;
+        previousValue?: undefined;
+    } | {
+        key: 'text';
+        value: string;
+        commentId?: undefined;
+        fileId?: undefined;
+        previousValue?: undefined;
+    } | {
+        key: 'isInternal';
+        value: boolean;
+        previousValue: boolean;
+        commentId?: undefined;
+        fileId?: undefined;
+    } | {
+        key: 'resolvedTime';
+        value: null;
+        commentId?: undefined;
+        fileId?: undefined;
+        previousValue?: undefined;
     }>;
+    rejected?: true;
+    reason?: string;
+    committed?: true;
+    code?: string;
+    detail?: unknown;
     /**
      * The Document API selection snapshot captured at the moment a
      * `'pending'` comment was started, before the pending mark is

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

@@ -1,3 +1,5 @@
-export function readSuperDocV2BrowserRuntime(globalObject?: typeof globalThis): any;
-export function installSuperDocV2BrowserRuntime(runtime?: {}, globalObject?: typeof globalThis): any;
-export const SUPERDOC_V2_BROWSER_RUNTIME_GLOBAL_KEY: "__SUPERDOC_V2_BROWSER_RUNTIME__";
+export declare const SUPERDOC_V2_BROWSER_RUNTIME_GLOBAL_KEY = "__SUPERDOC_V2_BROWSER_RUNTIME__";
+type SuperDocV2BrowserRuntime = Record<string, unknown>;
+export declare function readSuperDocV2BrowserRuntime(globalObject?: object): SuperDocV2BrowserRuntime | null;
+export declare function installSuperDocV2BrowserRuntime(runtime?: SuperDocV2BrowserRuntime, globalObject?: object): SuperDocV2BrowserRuntime;
+export {};

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

@@ -1,16 +1,6 @@
-/**
- * @param {typeof globalThis} globalObject
- * @param {string} engineVersion
- * @param {string | null} buildOverride
- */
-export function resolveDocxEngineCdnBaseUrl(globalObject: typeof globalThis, engineVersion: string, buildOverride?: string | null): any;
-/** @param {{ engineVersion: string, buildBaseUrl: string | null }} options */
-export function configureCdnEngineLoader({ engineVersion, buildBaseUrl }: {
+export declare function resolveDocxEngineCdnBaseUrl(globalObject: object, engineVersion: string, buildOverride?: string | null): string;
+export declare function configureCdnEngineLoader({ engineVersion, buildBaseUrl, }: {
     engineVersion: string;
     buildBaseUrl: string | null;
 }): void;
-/**
- * @param {string} url
- * @returns {Promise<void>}
- */
-export function loadStylesheetOnce(url: string): Promise<void>;
+export declare function loadStylesheetOnce(url: string): Promise<void>;

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/object-guards.d.ts

@@ -1 +1,2 @@
 export declare function isPlainObject(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;
+};