superdoc 2.28.0 → 2.29.0-next.13

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

@@ -1,33 +1,96 @@
-export function useFieldValueWatcher(field: any, originalValue: any): {
-    value: any;
+export interface FieldOptionDefinition {
+    itemdisplaylabel?: unknown;
+    itemlinkvalue?: unknown;
+    ischecked?: unknown;
+    itemid?: unknown;
+    annotationId?: unknown;
+}
+export interface FieldDefinition {
+    itemid: {
+        value?: unknown;
+    };
+    itemicon?: unknown;
+    itemiconpack?: unknown;
+    itemdisplaylabel?: unknown;
+    itemlinkvalue?: unknown;
+    itemplaceholdertext?: unknown;
+    itemtype?: string;
+    itemfieldtype?: unknown;
+    itemformat?: unknown;
+    itemoptions?: FieldOptionDefinition[] | null;
+    iteminputtype?: unknown;
+    fontfamily?: string | null;
+    font_size?: string | null;
+    original_font_size?: string | null;
+    logicrules?: unknown;
+    valueGetter?: (data: object) => string;
+}
+export declare function useFieldValueWatcher(originalValue: unknown): {
+    value: {};
 };
-export function useField(field: any): {
-    id: import('vue').Ref<any, any>;
-    icon: import('vue').Ref<any, any>;
-    iconPack: import('vue').Ref<any, any>;
-    label: import('vue').Ref<any, any>;
-    placeholder: any;
-    fieldType: import('vue').Ref<any, any>;
-    fieldSubType: import('vue').Ref<any, any>;
-    value: any;
-    format: import('vue').Ref<any, any>;
-    logicRules: import('vue').Ref<any, any>;
+export declare function useField(field: FieldDefinition): {
+    id: import('vue').Ref<{
+        value?: unknown;
+    }, {
+        value?: unknown;
+    } | {
+        value?: unknown;
+    }>;
+    icon: import('vue').Ref<unknown, unknown>;
+    iconPack: import('vue').Ref<unknown, unknown>;
+    label: import('vue').Ref<unknown, unknown>;
+    placeholder: unknown;
+    fieldType: import('vue').Ref<string | undefined, string | undefined>;
+    fieldSubType: import('vue').Ref<unknown, unknown>;
+    value: {};
+    format: import('vue').Ref<unknown, unknown>;
+    logicRules: import('vue').Ref<unknown, unknown>;
     hidden: import('vue').Ref<boolean, boolean>;
-    originalJSON: any;
+    originalJSON: FieldDefinition;
     fieldStyle: {
-        fontFamily: any;
-        fontSize: any;
-        originalFontSize: any;
+        fontFamily: string;
+        fontSize: string;
+        originalFontSize: string;
     };
-    valueGetter: any;
+    valueGetter: ((data: object) => string) | undefined;
 };
-export function useImageField(field: any): {
-    fontfamily: import('vue').Ref<any, any>;
-    iteminputtype: import('vue').Ref<any, any>;
+export declare function useImageField(field: Pick<FieldDefinition, 'fontfamily' | 'iteminputtype'>): {
+    fontfamily: import('vue').Ref<string | null | undefined, string | null | undefined>;
+    iteminputtype: import('vue').Ref<unknown, unknown>;
 };
-export function useSelectField(field: any): {
-    options: import('vue').Ref<any, any>;
+export declare function useSelectField(field: Pick<FieldDefinition, 'itemoptions'>): {
+    options: import('vue').Ref<{
+        itemdisplaylabel?: unknown;
+        itemlinkvalue?: unknown;
+        ischecked?: unknown;
+        itemid?: unknown;
+        annotationId?: unknown;
+    }[] | null | undefined, FieldOptionDefinition[] | {
+        itemdisplaylabel?: unknown;
+        itemlinkvalue?: unknown;
+        ischecked?: unknown;
+        itemid?: unknown;
+        annotationId?: unknown;
+    }[] | null | undefined>;
 };
-export function useCheckboxField(field: any): {
-    options: import('vue').Ref<any, any>;
+export declare function useCheckboxField(field: Pick<FieldDefinition, 'itemoptions'>): {
+    options: import('vue').Ref<{
+        label: unknown;
+        value: unknown;
+        checked: unknown;
+        id: unknown;
+        annotationId: unknown;
+    }[] | null | undefined, {
+        label: unknown;
+        value: unknown;
+        checked: unknown;
+        id: unknown;
+        annotationId: unknown;
+    }[] | {
+        label: unknown;
+        value: unknown;
+        checked: unknown;
+        id: unknown;
+        annotationId: unknown;
+    }[] | null | undefined>;
 };

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-password-prompt.d.ts

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

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

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

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

@@ -1,3 +1,41 @@
+import { Ref } from 'vue';
+import { SuperDoc } from '../core/SuperDoc.js';
+import { Editor, RuntimeDocument, SuperDocFitWidthOptions, SuperDocViewportMetrics, SuperDocZoomMode } from '../core/types/index.js';
+export type ResolvedFitWidthOptions = Required<SuperDocFitWidthOptions>;
+type EditorPageGeometry = Pick<Editor, 'pageMetrics'> & {
+    getPages?: () => Array<{
+        size?: {
+            w?: unknown;
+        };
+    } | null | undefined> | null | undefined;
+    getPageStyles?: () => {
+        pageSize?: {
+            width?: unknown;
+        };
+    } | null | undefined;
+};
+interface UseViewportFitOptions {
+    getSuperdoc: () => SuperDoc | 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: SuperDocFitWidthOptions | null | undefined) => 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 +59,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/composables/useUiFontFamily.d.ts

@@ -1,3 +1,4 @@
+import { ComputedRef } from 'vue';
 /**
  * Vue composable that returns the computed UI font-family for SuperDoc surfaces.
  *
@@ -9,16 +10,7 @@
  * The font-family is determined by checking the `uiDisplayFallbackFont` config property.
  * If it's a non-empty string, it will be used. Otherwise, the DEFAULT_UI_FONT_FAMILY
  * constant is returned.
- *
- * @returns {{ uiFontFamily: import('vue').ComputedRef<string> }} An object containing:
- *   - uiFontFamily: A computed reference to the UI font-family string
  */
-export function useUiFontFamily(): {
-    uiFontFamily: import('vue').ComputedRef<string>;
+export declare function useUiFontFamily(): {
+    uiFontFamily: ComputedRef<string>;
 };
-/**
- * The default font-family to use for SuperDoc UI surfaces when no custom font is configured.
- * This constant ensures consistency across the application.
- * @constant {string}
- */
-export const DEFAULT_UI_FONT_FAMILY: "Arial, Helvetica, sans-serif";

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

@@ -103,12 +103,6 @@ interface SuperDocEventMap {
     'source:complete': [];
     'source:signals-complete': [];
 }
-/**
- * SuperDoc class
- * Expects a config object
- *
- * @class
- */
 export declare class SuperDoc extends EventEmitter<SuperDocEventMap> {
     #private;
     static allowedTypes: ("application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/pdf")[];
@@ -345,7 +339,7 @@ export declare class SuperDoc extends EventEmitter<SuperDocEventMap> {
      * surface does not pull the Pinia comment model type graph.
      *
      */
-    getComment(commentId: string): Record<string, unknown> | null;
+    getComment(commentId: string): import('../stores/helpers/comment-identity.js').CommentIdentityRow | null;
     /**
      * Get the SuperDoc container element
      */
@@ -372,6 +366,7 @@ export declare class SuperDoc extends EventEmitter<SuperDocEventMap> {
      * @returns The attached room and document once the collaborative runtime is ready
      */
     upgradeToCollaboration(options: UpgradeToCollaborationOptions): Promise<UpgradeToCollaborationResult>;
+    setUser(user: User): Promise<void>;
     /**
      * Add a user to the shared users list. Requires the instance to be
      * ready; pre-ready mutations would be silently overwritten by the
@@ -692,7 +687,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/collaboration-comments.d.ts

@@ -1,4 +1,9 @@
-export function addYComment(yArray: any, ydoc: any, event: any, user: any): void;
-export function updateYComment(yArray: any, ydoc: any, event: any, user: any): void;
-export function deleteYComment(yArray: any, ydoc: any, event: any, user: any): void;
-export function getCommentIndex(yArray: any, comment: any): any;
+import { Array as YArray, Doc as YDoc } from 'yjs';
+import { User } from '../types/index.js';
+export type CollaborationCommentEvent = {
+    comment: unknown;
+};
+export declare const addYComment: (yArray: YArray<unknown>, ydoc: YDoc, event: CollaborationCommentEvent, user: User | undefined) => void;
+export declare const updateYComment: (yArray: YArray<unknown>, ydoc: YDoc, event: CollaborationCommentEvent, user: User | undefined) => void;
+export declare const deleteYComment: (yArray: YArray<unknown>, ydoc: YDoc, event: CollaborationCommentEvent, user: User | undefined) => void;
+export declare const getCommentIndex: (yArray: YArray<unknown>, comment: Record<string, unknown>) => number;

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

@@ -1,3 +1,20 @@
-export function loadCommentsFromYdoc(superdoc: Object): boolean;
-export function initCollaborationComments(superdoc: Object): void;
-export function syncCommentsToClients(superdoc: Object, event: Object): void;
+import { CommentEvent } from '../../../../../shared/common';
+import { SuperDoc } from '../SuperDoc.js';
+import { Modules, User } from '../types/index.js';
+import { CollaborationCommentEvent } from './collaboration-comments.js';
+import type * as Y from 'yjs';
+type CommentsSyncHost = {
+    isCollaborative?: boolean;
+    ydoc?: Y.Doc;
+    config?: {
+        modules?: Modules;
+        user?: User;
+    };
+};
+type CommentsSyncEvent = CollaborationCommentEvent & {
+    type: CommentEvent;
+};
+export declare const loadCommentsFromYdoc: (superdoc: SuperDoc | null | undefined) => boolean;
+export declare const initCollaborationComments: (superdoc: SuperDoc) => void;
+export declare const syncCommentsToClients: (superdoc: CommentsSyncHost, event: CommentsSyncEvent) => void;
+export {};

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

@@ -1,4 +1,6 @@
-export const PERMISSIONS: Readonly<{
+import { SuperDoc } from '../SuperDoc.js';
+import { CanPerformPermissionParams, PermissionResolver, User } from '../types/index.js';
+export declare const PERMISSIONS: Readonly<{
     RESOLVE_OWN: "RESOLVE_OWN";
     RESOLVE_OTHER: "RESOLVE_OTHER";
     REJECT_OWN: "REJECT_OWN";
@@ -10,11 +12,15 @@ export const PERMISSIONS: Readonly<{
     UPLOAD_VERSION: "UPLOAD_VERSION";
     VERSION_HISTORY: "VERSION_HISTORY";
 }>;
-export function createTrackedChangePermissionResolver(superdoc: any): (payload?: {}) => any;
-export function isAllowed(permission: string, role: string, isInternal: boolean, context?: {
-    comment?: object | null | undefined;
-    superdoc?: object | null | undefined;
-    currentUser?: object | null | undefined;
-    permissionResolver?: Function | undefined;
-    trackedChange?: object | null | undefined;
-}): boolean;
+interface PermissionContext {
+    comment?: object | null;
+    superdoc?: SuperDoc | null;
+    currentUser?: User | null;
+    permissionResolver?: PermissionResolver;
+    trackedChange?: object | null;
+}
+export declare const BUILT_IN_PERMISSION_METHOD: unique symbol;
+export declare const createTrackedChangePermissionResolver: (superdoc: SuperDoc) => (payload?: CanPerformPermissionParams) => boolean;
+export declare const readBuiltInTrackedChangePermissionDecision: (superdoc: unknown, canPerform: unknown, permission: string, trackedChange: unknown) => boolean | null;
+export declare const isAllowed: (permission: string, role: string | undefined, isInternal: boolean | undefined, context?: PermissionContext) => boolean;
+export {};

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-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';
+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.
  *
@@ -55,7 +55,7 @@ export interface NormalizedV2CollaborationTarget {
     /** Explicit room operation; join is the default at the untrusted input boundary. */
     roomMode: 'join' | 'create';
 }
-export type V2CollaborationTargetResolution = {
+type V2CollaborationTargetResolution = {
     ok: true;
     target: NormalizedV2CollaborationTarget;
 } | {
@@ -76,7 +76,7 @@ export interface LegacyCollaborationLike {
     url?: unknown;
     [key: string]: unknown;
 }
-export interface ResolveV2CollaborationTargetInput {
+interface ResolveV2CollaborationTargetInput {
     /** Preferred connection settings. Explicit null or invalid input never falls back to the alias. */
     collaboration?: unknown;
     /** Compatibility spelling for document-level connection settings. */
@@ -113,3 +113,4 @@ export declare function redactCollaborationUrl(url: unknown): string;
  * supported v2 room target, or a stable redacted diagnostic.
  */
 export declare function resolveV2CollaborationTarget(input: ResolveV2CollaborationTargetInput): V2CollaborationTargetResolution;
+export {};

package/dist/superdoc/src/core/collaboration/v2-awareness-bridge.d.ts

@@ -29,7 +29,7 @@ export interface V2AwarenessSnapshotLike {
     remoteActors: ReadonlyArray<V2AwarenessRemoteActor>;
 }
 /** Core `awareness-update` payload (the `superdoc` backref is added by the caller). */
-export interface V2AwarenessPayloadCore {
+interface V2AwarenessPayloadCore {
     states: AwarenessState[];
     added: number[];
     removed: number[];
@@ -55,3 +55,4 @@ export declare function createV2AwarenessDiffer(getLocalUser: () => User | null
     registry: V2AwarenessIdRegistry;
     next(snapshot: V2AwarenessSnapshotLike): V2AwarenessPayloadCore;
 };
+export {};

package/dist/superdoc/src/core/config/merge-comments-config.d.ts

@@ -3,9 +3,5 @@
  *
  * The responsive options can be migrated independently, so merge that nested
  * bag by field while keeping canonical values authoritative.
- *
- * @param {Record<string, unknown>} config
- * @param {Record<string, unknown>} presentation
- * @returns {Record<string, unknown>}
  */
-export function mergeCommentsConfig(config: Record<string, unknown>, presentation: Record<string, unknown>): Record<string, unknown>;
+export declare function mergeCommentsConfig(config: Record<string, unknown>, presentation: Record<string, unknown>): Record<string, unknown>;

package/dist/superdoc/src/core/config/merge-defined.d.ts

@@ -17,19 +17,14 @@
  *
  * Later sources win, as with spread. Non-object sources are ignored so callers
  * can pass a possibly-absent block without guarding first.
- *
- * @param {...unknown} sources
- * @returns {Record<string, unknown>}
  */
-export function mergeDefined(...sources: unknown[]): Record<string, unknown>;
+export declare function mergeDefined(...sources: unknown[]): Record<string, unknown>;
+export declare function mergeDefinedFields<T extends object>(...sources: Array<T | undefined>): Partial<T>;
 /**
  * Pick the first defined value, so `undefined` falls through but `null`,
  * `false`, and `0` are honored as deliberate choices.
  *
  * `??` already does this for null and undefined together, which is wrong when
  * `null` carries meaning — clearing an inherited resolver, for instance.
- *
- * @param {...unknown} values
- * @returns {unknown}
  */
-export function firstDefined(...values: unknown[]): unknown;
+export declare function firstDefined(...values: unknown[]): unknown;

package/dist/superdoc/src/core/config/normalize-hyperlinks-config.d.ts

@@ -1,23 +1,18 @@
+import { Config, HyperlinkActivationHandler, LinkPopoverResolver } from '../types/index.js';
+type HyperlinkHandler = HyperlinkActivationHandler | LinkPopoverResolver;
+type HyperlinkHandlerSource = 'hyperlinks.onActivate' | 'compatibility';
 /**
  * Resolve hyperlink activation behavior.
  *
  * A canonical handler remains active under `ui: false` because an application
  * may navigate or render its own interface. Without a canonical handler, the
  * existing UI suppression rules keep their current behavior.
- *
- * @param {Record<string, any>} [config] Raw consumer config.
- * @returns {{
- *   handler: import('../types/index.js').HyperlinkActivationHandler | import('../types/index.js').LinkPopoverResolver | undefined,
- *   handlerSource: 'hyperlinks.onActivate' | 'compatibility' | undefined,
- *   editableActivationDisabled: boolean,
- *   builtInEditorDisabled: boolean,
- *   interceptsNavigationOnly: boolean,
- * }}
  */
-export function normalizeHyperlinksConfig(config?: Record<string, any>): {
-    handler: import('../types/index.js').HyperlinkActivationHandler | import('../types/index.js').LinkPopoverResolver | undefined;
-    handlerSource: "hyperlinks.onActivate" | "compatibility" | undefined;
+export declare function normalizeHyperlinksConfig(config?: Pick<Config, 'hyperlinks' | 'ui' | 'modules'>): {
+    handler: HyperlinkHandler | undefined;
+    handlerSource: HyperlinkHandlerSource | undefined;
     editableActivationDisabled: boolean;
     builtInEditorDisabled: boolean;
     interceptsNavigationOnly: boolean;
 };
+export {};

package/dist/superdoc/src/core/config/normalize-surfaces-config.d.ts

@@ -1,3 +1,10 @@
+import { Config, SurfaceResolver, SurfacesConfig } from '../types/index.js';
+type SurfacesSource = Pick<Config, 'surfaces' | 'modules'>;
+type NormalizedSurfacesConfig = {
+    resolver: SurfaceResolver | null;
+    dialog: NonNullable<SurfacesConfig['dialog']>;
+    floating: NonNullable<SurfacesConfig['floating']>;
+};
 /**
  * Resolve the generic surface infrastructure config.
  *
@@ -8,16 +15,6 @@
  * The resolved shape mirrors the public `SurfacesConfig`, with every member
  * present: the presets are merged objects rather than optional, and `resolver`
  * is a function or `null` once a non-function value has been rejected.
- *
- * @param {Record<string, any>} [config] Raw consumer config.
- * @returns {{
- *   resolver: import('../types/index.js').SurfaceResolver | null,
- *   dialog: NonNullable<import('../types/index.js').SurfacesConfig['dialog']>,
- *   floating: NonNullable<import('../types/index.js').SurfacesConfig['floating']>,
- * }}
  */
-export function normalizeSurfacesConfig(config?: Record<string, any>): {
-    resolver: import('../types/index.js').SurfaceResolver | null;
-    dialog: NonNullable<import('../types/index.js').SurfacesConfig["dialog"]>;
-    floating: NonNullable<import('../types/index.js').SurfacesConfig["floating"]>;
-};
+export declare function normalizeSurfacesConfig(config?: SurfacesSource): NormalizedSurfacesConfig;
+export {};

package/dist/superdoc/src/core/config/normalize-ui-config.d.ts

@@ -40,21 +40,10 @@ type NormalizedUiConfig = {
         options: Record<string, unknown>;
     };
 };
-/** Surfaces that render when the consumer says nothing at all. */
-declare const HISTORICAL_DEFAULTS: Readonly<{
-    toolbar: true;
-    comments: true;
-    contextMenu: true;
-    loading: true;
-    search: false;
-    linkPopover: false;
-    ruler: false;
-    contentControls: true;
-}>;
 /** Every built-in surface `ui: false` turns off. */
 declare const BUILT_IN_SURFACES: readonly ("search" | "comments" | "contentControls" | "loading" | "ruler" | "toolbar" | "contextMenu" | "linkPopover")[];
 /**
  * Collapse a consumer config into the effective built-in UI profile.
  */
 export declare function normalizeUiConfig(config?: UiConfigSource): NormalizedUiConfig;
-export { BUILT_IN_SURFACES, HISTORICAL_DEFAULTS };
+export { BUILT_IN_SURFACES };

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

@@ -1,28 +1,17 @@
+import { App as VueApp } from 'vue';
+import { Pinia } from 'pinia';
 import { useSuperdocStore } from '../stores/superdoc-store.js';
 import { useCommentsStore } from '../stores/comments-store.js';
-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
- * by `SuperDoc.#initVueApp` and is not part of the public surface.
- */
-export type SuperdocVueAppRefs = {
-    /**
-     * The Vue 3 app instance
-     */
-    app: import('vue').App;
-    /**
-     * The Pinia store instance attached to `app`
-     */
-    pinia: import('pinia').Pinia;
-    /**
-     * The SuperDoc Pinia store
-     */
+import { HighContrastMode } from '../composables/use-high-contrast-mode.js';
+interface SuperdocVueAppOptions {
+    disablePiniaDevtools?: boolean;
+    highContrastMode: HighContrastMode;
+}
+interface SuperdocVueAppRefs {
+    app: VueApp;
+    pinia: Pinia;
     superdocStore: ReturnType<typeof useSuperdocStore>;
-    /**
-     * The Comments Pinia store
-     */
     commentsStore: ReturnType<typeof useCommentsStore>;
-};
+}
+export declare const createSuperdocVueApp: ({ disablePiniaDevtools, highContrastMode, }: SuperdocVueAppOptions) => SuperdocVueAppRefs;
+export {};

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

@@ -1,5 +1,5 @@
 import { EditorRuntime, EditorRuntimeDocumentMode, EditorRuntimeId, EditorRuntimeState } from '../index.js';
-export interface FakeV2RuntimeOptions {
+interface FakeV2RuntimeOptions {
     id?: EditorRuntimeId;
     documentId?: string;
     root?: HTMLElement;
@@ -7,3 +7,4 @@ export interface FakeV2RuntimeOptions {
     initialDocumentMode?: EditorRuntimeDocumentMode;
 }
 export declare function createFakeV2Runtime(options?: FakeV2RuntimeOptions): EditorRuntime;
+export {};