superdoc 2.3.0 → 2.4.0-next.10

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

@@ -5,9 +5,88 @@ import { DocumentFontOption, FontAssetUrlResolver, FontFamilyOption, FontLoadSum
 import { SuperDoc as SuperDocClass } from '../SuperDoc.js';
 import { SuperDocActiveEditorExtensions, SuperDocExtension } from '../extensions/index.js';
 import { BrowserDocumentApi } from '../../public/browser-document-api.js';
+import { CustomCommandContext } from '../../public/ui/types.js';
 export type { DocumentFontOption, FontAssetUrlContext, FontAssetUrlResolver, FontFaceSlot, FontFamilyOption, FontLoadResult, FontLoadStatus, FontLoadSummary, FontResolutionReason, FontResolutionRecord, GlyphException, ResolvedFontEvidence, SubstitutePolicyAction, SubstituteVerdict, } from '../../../../shared/font-system/src/index.js';
 export type SuperDoc = SuperDocClass;
 export type { BrowserDocumentApi } from '../../public/browser-document-api.js';
+/**
+ * A row in a custom dropdown's option list, and the value handed back to the
+ * `command` callback when one is chosen.
+ *
+ * `label` and `key` are what the toolbar reads: `handleSelect` uses `label` as
+ * the command argument (unless `dropdownValueKey` names another member) and
+ * `key` as the selection identity (`ButtonGroup.vue:167-169`).
+ *
+ * Both are optional here rather than required, because a `type: 'render'`
+ * entry is a custom-rendered row that the selection path explicitly skips
+ * (`ButtonGroup.vue:268`), so it carries neither. The index signature keeps
+ * the rest of the row open.
+ */
+export interface ToolbarDropdownOption {
+    /** Row text, and the default command argument when the row is chosen. */
+    label?: string;
+    /** Stable row identity, used for selection state. */
+    key?: string;
+    /** Attributes spread onto the rendered row. */
+    props?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/**
+ * The context a custom toolbar button's `command` callback receives.
+ *
+ * The runtime registers the callback as a custom command and invokes it with
+ * the controller's {@link CustomCommandContext} plus three toolbar-specific
+ * members (`built-in-toolbar.js:#prepareCustomButton`), so a consumer writing
+ * `({ execute, option }) => ...` gets both halves typed.
+ *
+ * `item` is deliberately `unknown`. It is the live Vue reactive object
+ * `useToolbarItem` returns — a bag of `ref`s whose shape is an implementation
+ * detail. Typing it would publish that internal and freeze it; see #1098 for
+ * the public toolbar-item contract that would replace it.
+ */
+export interface ToolbarCustomButtonContext extends CustomCommandContext {
+    /** The live toolbar item handle. Internal shape; see #1098. */
+    item: unknown;
+    /**
+     * The selected dropdown row, passed through verbatim, or `undefined` for a
+     * plain button that has no selection.
+     */
+    option?: ToolbarDropdownOption;
+    /** Argument threaded through the command payload. */
+    argument?: unknown;
+}
+/**
+ * A custom entry appended to the built-in toolbar's default item set.
+ *
+ * Intentionally loose. `name` and `command` are the two members the runtime
+ * contract already fixes, and the rest stays open because the public
+ * toolbar-item shape has not been decided yet (#1098).
+ *
+ * Tightening it further needs that contract first. `useToolbarItem` accepting
+ * a `type` only proves construction does not throw, not that the entry renders
+ * as a top-level toolbar item -- `options` has no render branch at all,
+ * `dropdown` needs rows and a trigger, and `overflow` draws only when the
+ * separately-built overflow list is non-empty, which `customButtons` cannot
+ * populate. Encoding those rules here would publish a contract on the strength
+ * of constructor behavior, and they need rendered-behavior tests rather than
+ * direct `useToolbarItem` construction to establish.
+ */
+export interface ToolbarCustomButton {
+    /** Unique item name. Also derives the registered command id. */
+    name: string;
+    /**
+     * What the entry does when activated. A function is registered as a custom
+     * command and invoked with {@link ToolbarCustomButtonContext}; a string is
+     * read as a canonical V2 command id and routed through the shared controller
+     * (`built-in-toolbar.js:948`).
+     *
+     * Optional because a separator has nothing to do. An actionable entry that
+     * omits it silently no-ops on click -- a real defect, but one this type
+     * cannot flag without the variant split that #1098 owns.
+     */
+    command?: string | ((context: ToolbarCustomButtonContext) => unknown);
+    [key: string]: unknown;
+}
 export type V2AuthoringSelectionCollapse = 'start' | 'end' | null;
 export type V2AuthoringResult = {
     ok: true;
@@ -284,6 +363,47 @@ export interface FontFamilyConfig {
     [key: string]: unknown;
 }
 export type FontConfig = FontFamilyConfig;
+/**
+ * One row in the toolbar's font-family dropdown.
+ *
+ * Distinct from {@link FontFamilyConfig}, which describes a family to load and
+ * measure. This describes a row to render.
+ *
+ * `label` and `key` are both required because the toolbar has no fallback for
+ * either. `label` is the value applied to the selection
+ * (`emitFontCommand(option.label)`) and what active-state matching compares
+ * against (`fontOptions.find((i) => i.label === fontFamily)`); `key` is the
+ * selection identity and the rendered list key. An entry missing either one
+ * produces a blank row or an undefined command value rather than a
+ * degraded-but-working option.
+ */
+export interface ToolbarFontOption {
+    /**
+     * Logical family name. Rendered as the row's text, written to the selection
+     * when chosen, and compared against the current font for active state.
+     */
+    label: string;
+    /** Stable option identity, used for selection state and the list key. */
+    key: string;
+    /**
+     * Attributes spread onto the rendered row, which is the only channel that
+     * reaches it: both renderers bind `option.props` and nothing else
+     * (`ToolbarComboBox.vue:559`, `ToolbarDropdown.vue:420`).
+     *
+     * `props.style.fontFamily` is the preview stack the row is drawn in;
+     * `normalizeFontOption` falls back to `label` then `key` when it is absent,
+     * so a row always previews in something. Weight and any other per-row style
+     * go here too — `props: { style: { fontWeight: 700 } }` renders, a top-level
+     * `fontWeight` does not.
+     */
+    props?: {
+        style?: {
+            fontFamily?: string;
+            [key: string]: unknown;
+        };
+        [key: string]: unknown;
+    };
+}
 export interface FontsConfig {
     bundled?: boolean | 'baseline' | 'full' | string[] | Record<string, unknown>;
     families?: FontFamilyConfig[];
@@ -723,6 +843,111 @@ export type LinkPopoverResolution = {
  * default popover.
  */
 export type LinkPopoverResolver = (ctx: LinkPopoverContext) => LinkPopoverResolution | null | undefined;
+/**
+ * Canonical presentation settings for the built-in comments UI.
+ *
+ * Presentation only, and deliberately not the whole of `modules.comments`.
+ * That block also carries `readOnly` and `allowResolve`, which resolve through
+ * `interaction.comments`, and `permissionResolver`, which is read off
+ * `modules.comments` or the top-level `Config`. All three are stripped from
+ * this bag: policy outlives the built-in UI, so an application drawing its own
+ * comment surface still has to honor it. See the fields themselves, which are
+ * rejected by name with the spelling that applies to each.
+ *
+ * Open on purpose, for the same reason `modules.comments` is: the runtime
+ * merges this bag over that block and spreads the result through the comments
+ * store, which accepts pass-through keys. Closing it would reject working
+ * configurations, which is a worse failure than the missing autocomplete it
+ * would buy. The named fields are the ones the shell reads.
+ */
+export type CommentsConfig = {
+    /** How comments present themselves as the surface narrows. */
+    displayMode?: 'auto' | 'sidebar' | 'inline';
+    /** CSS selector for an explicit width measurement target in `auto` mode. */
+    compactMeasurementSelector?: string;
+    /** Fixed compact-mode breakpoint override, in pixels. */
+    compactBreakpointPx?: number;
+    /** Comment highlight colors (internal/external and active overrides). */
+    highlightColors?: {
+        /** Base highlight color for internal comments. */
+        internal?: string;
+        /** Base highlight color for external comments. */
+        external?: string;
+        /** Active highlight color override for internal comments. */
+        activeInternal?: string;
+        /** Active highlight color override for external comments. */
+        activeExternal?: string;
+    };
+    /** Comment highlight opacity, active and inactive. */
+    highlightOpacity?: {
+        /** Opacity for the active comment highlight. */
+        active?: number;
+        /** Opacity for inactive comment highlights. */
+        inactive?: number;
+    };
+    /** Highlight color used while hovering a comment. */
+    highlightHoverColor?: string;
+    /** Tracked-change highlight colors. */
+    trackChangeHighlightColors?: TrackChangeHighlightColors;
+    /** Active tracked-change highlight colors (defaults to the above). */
+    trackChangeActiveHighlightColors?: TrackChangeHighlightColors;
+    /**
+     * Policy, not presentation. `normalizeUiConfig` strips all three from this
+     * bag before anything reads it, so accepting them here would advertise a
+     * setting that is silently discarded.
+     *
+     * `readOnly` and `allowResolve` belong on `interaction.comments`, where they
+     * resolve and keep applying to an application drawing its own comment
+     * surface.
+     *
+     * `permissionResolver` is collaboration wiring rather than policy, and has
+     * no `ui` spelling at all. `pickResolver` takes the first of
+     * `modules.comments.permissionResolver` and the top-level
+     * `Config.permissionResolver`, in that order, so either works and the
+     * comments-scoped one wins.
+     */
+    readOnly?: never;
+    allowResolve?: never;
+    permissionResolver?: never;
+} & Record<string, unknown>;
+/** Border and background colors for one tracked-change highlight state. */
+export interface TrackChangeHighlightColors {
+    /** Border color for inserted text. */
+    insertBorder?: string;
+    /** Background color for inserted text. */
+    insertBackground?: string;
+    /** Border color for deleted text. */
+    deleteBorder?: string;
+    /** Background color for deleted text. */
+    deleteBackground?: string;
+    /** Border color for a format change. */
+    formatBorder?: string;
+}
+/**
+ * Canonical configuration for the chrome drawn around content controls.
+ *
+ * `chrome` is the whole option bag this surface has. `'default'` and `'none'`
+ * are the only values the painter and the v2 host accept; anything else is
+ * coerced back to `'default'`.
+ */
+export interface ContentControlsConfig {
+    /** Whether SuperDoc draws its own chrome around each content control. */
+    chrome?: 'default' | 'none';
+}
+/**
+ * Canonical configuration for the built-in link popover.
+ *
+ * `popoverResolver` supersedes `modules.links.popoverResolver`, which stays
+ * supported for all of v2. Setting both keeps the canonical one; the legacy
+ * spelling only applies when the canonical one is absent.
+ */
+export interface LinkPopoverConfig {
+    /**
+     * Called when a user clicks a link, to decide which popover to show.
+     * Returning `null` or `undefined` falls back to the built-in popover.
+     */
+    popoverResolver?: LinkPopoverResolver;
+}
 /** Context object passed to context menu callbacks (showWhen, render, action, menuProvider). */
 export interface ContextMenuContext {
     /** The editor instance. */
@@ -779,8 +1004,24 @@ export interface ContextMenuItem {
     icon?: string;
     /** Custom Vue component to render this item. */
     component?: unknown;
-    /** Callback invoked when the item is clicked. */
+    /**
+     * Callback invoked when the item is clicked.
+     *
+     * @deprecated replaceWith=`onSelect` removeIn=v3.0 — V1 only. SuperDoc 2
+     * cannot invoke this: its first argument is a ProseMirror `Editor` the v2
+     * runtime does not have, and `ContextMenuContext` carries fields v2 does not
+     * expose. Items using it render and then do nothing when clicked, and the
+     * runtime warns once naming the replacement.
+     */
     action?: (editor: Editor, context: ContextMenuContext) => void;
+    /**
+     * Application-owned click handler. Runs after the menu dismisses.
+     *
+     * This is the supported way to attach a product action such as "copy the
+     * selection into our workflow"; the built-in `intent` union covers only what
+     * SuperDoc itself performs.
+     */
+    onSelect?: (payload: ContextMenuSelectPayload) => void | Promise<void>;
     /** Predicate controlling visibility. */
     showWhen?: (context: ContextMenuContext) => boolean;
     /** Custom renderer returning an HTML element. */
@@ -788,6 +1029,66 @@ export interface ContextMenuItem {
     /** Keyboard shortcut label displayed beside the item. */
     shortcut?: string;
 }
+/** The menu context a `ContextMenuItem.onSelect` handler receives. */
+export interface ContextMenuSelectContext {
+    /**
+     * Text selected when the menu opened. Empty when the caret was collapsed, and
+     * also empty when a worker-backed read had not settled by click time — await
+     * `selectedTextSettled` when accuracy matters more than the gesture.
+     */
+    selectedText: string;
+    /**
+     * The settled selection text.
+     *
+     * The handler is invoked synchronously so it keeps the click's user
+     * activation, which gesture-gated APIs such as `navigator.clipboard.write`,
+     * `window.open`, and `showOpenFilePicker` require. Awaiting this resolves the
+     * accurate text but spends that activation, so reach for it only when the
+     * handler does not need a gesture. Resolves to `selectedText` when the read
+     * had already settled or failed.
+     */
+    selectedTextSettled: Promise<string>;
+    hasSelection: boolean;
+    /** How the menu was opened. */
+    trigger: 'click' | 'slash';
+    isInTable: boolean;
+    isInList: boolean;
+    documentMode: 'editing' | 'suggesting' | 'viewing';
+    isEditable: boolean;
+}
+/** Repaint coordination handed alongside the Document API surface. */
+export interface ContextMenuSelectReadiness {
+    /** Render epoch of the mounted surface, or null when not mounted. */
+    getRenderEpoch(): number | null;
+    /** Resolves once a mutation's scheduled repaint has settled. */
+    whenPainted(input?: {
+        txId?: string;
+        afterEpoch?: number | null;
+    }): Promise<{
+        renderEpoch: number | null;
+    }>;
+}
+/**
+ * What a `ContextMenuItem.onSelect` handler is given.
+ *
+ * `document` is the async Document API surface, and it is a result rather than
+ * a handle: it reports `available: false` with a reason before the document is
+ * ready, so a handler has to check before reaching for `doc`. It is not the
+ * ProseMirror `Editor` the deprecated `action` callback took, which the v2
+ * runtime does not have.
+ */
+export interface ContextMenuSelectPayload {
+    document: {
+        available: true;
+        doc: BrowserDocumentApi;
+        readiness: ContextMenuSelectReadiness;
+    } | {
+        available: false;
+        reason: string;
+    };
+    /** The context captured when the menu opened, not the live document state. */
+    context: ContextMenuSelectContext | null;
+}
 /** A section (group) of items in the context menu. */
 export interface ContextMenuSection {
     /** Unique identifier for the section. */
@@ -1454,6 +1755,17 @@ export interface FindReplaceConfig {
         width?: number | string;
         maxWidth?: number | string;
         maxHeight?: number | string;
+        /**
+         * Focus the find input when the surface opens. Defaults to `true`; set
+         * `false` to leave focus wherever the user had it.
+         *
+         * Honored but undeclared until #1094: `useFindReplace` spreads this whole
+         * bag into the surface request, and `SurfaceManager` applies it last, over
+         * the `modules.surfaces.floating` defaults.
+         */
+        autoFocus?: boolean;
+        /** Close the surface on a pointer press outside it. Defaults to `false`. */
+        closeOnOutsidePointerDown?: boolean;
     };
 }
 /**
@@ -1675,18 +1987,31 @@ export interface Modules {
         icons?: Record<string, unknown>;
         /** Text/label overrides keyed by toolbar item id. Falls back to `Config.toolbarTexts`. */
         texts?: Record<string, string>;
-        /** Custom font list rendered in the font-family dropdown. */
-        fonts?: FontConfig[];
+        /**
+         * Custom font list rendered in the font-family dropdown.
+         *
+         * AIDEV-NOTE: legacy-public - accepts {@link FontFamilyConfig} entries
+         * alongside dropdown rows. This spelling was typed `FontConfig[]`,
+         * whose index signature let `{ family, label, key }` compile and work,
+         * so narrowing it to rows alone would break installs mid-2.x.
+         * Replaced by `ui.toolbar.fonts`, which takes rows only.
+         * Earliest removal: v3.0 (#853).
+         *
+         * The runtime uses the list verbatim and reads `label` and `key` off
+         * each entry, so a `family`-only entry renders a blank row either way.
+         */
+        fonts?: Array<FontConfig | ToolbarFontOption>;
         /** Hide buttons that overflow the available width (default: true). */
         hideButtons?: boolean;
         /** Recompute the visible toolbar item set on container resize (default: false). */
         responsiveToContainer?: boolean;
         /**
-         * Custom toolbar buttons appended to the default item set. Each entry is
-         * a `ToolbarItem`-shaped object (see the consumer-facing toolbar docs for
-         * the full shape). The internal `ToolbarItem` type is not yet on the
-         * public surface; this typedef accepts the structural shape consumers
-         * already pass through `modules.toolbar.customButtons`.
+         * Custom toolbar buttons appended to the default item set.
+         *
+         * AIDEV-NOTE: legacy-public - stays an open record. This spelling was
+         * typed `Array<Record<string, unknown>>`, so narrowing it now would
+         * reject entries that compile and work today. Replaced by
+         * `ui.toolbar.customButtons`. Earliest removal: v3.0 (#853).
          */
         customButtons?: Array<Record<string, unknown>>;
         /**
@@ -2161,7 +2486,7 @@ export interface SuperDocLayoutEngineOptions {
      * @experimental Diagnostic posture, not a supported product mode and not a
      * pipeline bypass: both settings route through the same canonical
      * render-pipeline engine. `true` (default) paints an initial window and
-     * appends as source streams in (the open-first-window and append engine
+     * (the canonical initial-render and incremental engine
      * passes); `false` makes EVERY mounted repaint wait for complete source
      * coverage and materialize the full body before painting — not only the
      * first paint — via the exact-complete engine pass, which can be much
@@ -2171,7 +2496,6 @@ export interface SuperDocLayoutEngineOptions {
      * render-readiness diagnostic. The render surface has no independent
      * first-paint timeout; callers and harnesses must provide their own.
      */
-    progressiveBodyStreaming?: boolean;
     /**
      * P6a: per-paint work-counter HUD (console table +
      * `data-v2-paint-hud-recent`) and the dark reuse-collapse tripwire for the
@@ -2411,28 +2735,63 @@ export interface UIConfig {
         icons?: Record<string, unknown>;
         /** Text overrides, merged over the built-in set. */
         texts?: Record<string, unknown>;
+        /**
+         * Hide buttons that overflow the available width (default: true).
+         *
+         * The runtime has always honored this through the toolbar options
+         * pass-through; it was only missing from this type, so passing it here
+         * failed excess-property checks while working at runtime.
+         */
+        hideButtons?: boolean;
         /** Size the toolbar to its container rather than the viewport. */
         responsiveToContainer?: boolean;
+        /**
+         * Custom font list rendered in the font-family dropdown. The runtime
+         * uses this list verbatim, so entries are dropdown rows
+         * ({@link ToolbarFontOption}), not families to load
+         * ({@link FontFamilyConfig}). Register loadable families through
+         * `fonts.families` instead.
+         */
+        fonts?: ToolbarFontOption[];
+        /**
+         * Custom toolbar buttons appended to the default item set.
+         *
+         * `name` and the `command` callback are typed; the rest of the
+         * `ToolbarItem` shape stays open because it is not yet public (#1098).
+         */
+        customButtons?: ToolbarCustomButton[];
+        /**
+         * Show the formatting marks (pilcrow) button in the toolbar. Off by
+         * default. Distinct from `layoutEngineOptions.showFormattingMarks`, which
+         * controls whether the marks render in the document.
+         */
+        showFormattingMarksButton?: boolean;
+        /** Show the table of contents insert button in the toolbar. Off by default. */
+        showTableOfContentsButton?: boolean;
     };
     /** Built-in comments UI. Enabled by default. */
-    comments?: boolean | Record<string, unknown>;
+    comments?: boolean | CommentsConfig;
     /** Built-in right-click and slash context menu. Enabled by default. */
-    contextMenu?: boolean | Record<string, unknown>;
+    contextMenu?: boolean | ContextMenuConfig;
     /**
      * Built-in find/replace surface. Disabled by default. Enabling it lets
      * SuperDoc intercept Cmd+F / Ctrl+F; `editor.ui.search` stays available to
      * custom UI either way.
      */
-    search?: boolean | Record<string, unknown>;
-    /** Built-in popover shown when a link is selected. Disabled by default. */
-    linkPopover?: boolean | Record<string, unknown>;
+    search?: boolean | FindReplaceConfig;
+    /**
+     * Built-in popover shown when a link is clicked. It renders by default;
+     * pass `false` (or `ui: false`) to suppress it. Supplying a
+     * {@link LinkPopoverConfig.popoverResolver} replaces it with your own UI.
+     */
+    linkPopover?: boolean | LinkPopoverConfig;
     /** Built-in ruler. Disabled by default. */
     ruler?: boolean | {
         /** Element or selector to render the ruler into. */
         container?: string | HTMLElement;
     };
     /** Built-in chrome drawn around content controls. Enabled by default. */
-    contentControls?: boolean | Record<string, unknown>;
+    contentControls?: boolean | ContentControlsConfig;
 }
 /**
  * What the user is permitted to do, as distinct from what SuperDoc draws.
@@ -2783,6 +3142,14 @@ export interface Config {
     lockedBy?: User;
     /** Whether to show the ruler in the editor. */
     rulers?: boolean;
+    /**
+     * Element or selector the ruler mounts into. Omit to render it inline above
+     * the editor.
+     *
+     * @deprecated replaceWith=`ui.ruler.container` removeIn=v3.0 — the runtime
+     * still honors it, and the canonical value wins when both are set.
+     */
+    rulerContainer?: string | HTMLElement;
     /** Whether to suppress default styles in docx mode. */
     suppressDefaultDocxStyles?: boolean;
     /** Provided JSON to override content with. */

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

@@ -1 +1 @@
-export function floor(val: any, precision: any): number;
+export function floor(val: number, precision?: number): number;

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

@@ -9,7 +9,12 @@
  * one authoritative catalog after render instead of issuing one read per id.
  */
 export function getV2TrackedChangeMutationImpact(event: any): {
+    allResolved?: any;
     upsertIds: Set<any>;
     removedIds: Set<any>;
+    remappedPairs: {
+        from: string;
+        to: string;
+    }[];
     reconcileMode: string;
 } | null;

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

@@ -12,7 +12,7 @@ export function createV2ReviewMutationReconciler({ getContext, reconcile, hydrat
     onReconciled: any;
 }): {
     enqueue: (impact: any) => void;
-    enqueueAfterPaint(impact: any, waitForPaint: any): void;
+    enqueueAfterPaint(impact: any, waitForPaint: any): Promise<any>;
     onRender: (supersedesInFlight?: boolean) => void;
     reset(): void;
     getPendingIds(): Set<any>;

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

@@ -29,7 +29,6 @@ export function mapFontFamilyOptionsToToolbar(options: ReadonlyArray<import('../
 export const TOOLBAR_FONTS: {
     label: string;
     key: string;
-    fontWeight: number;
     props: {
         style: {
             fontFamily: string;

package/dist/superdoc/src/internal/toolbar/compatibility-catalog.d.ts

@@ -36,7 +36,7 @@ export interface BuiltInToolbarItemEntry {
  * docs present them; it is documentation-only.
  *
  * Every documented `Available buttons` entry from
- * `apps/docs/editor/built-in-ui/toolbar.mdx` appears here exactly once, plus the
+ * the built-in UI documentation appears here exactly once, plus the
  * `customButtons` shell concept.
  */
 export declare const BUILT_IN_TOOLBAR_CATALOG: readonly BuiltInToolbarItemEntry[];

package/dist/superdoc/src/public/index.d.cts

@@ -9,14 +9,19 @@ import type { BorrowedSuperDocUI as __Cjs_BorrowedSuperDocUI } from './index.js'
 import type { CanPerformPermissionParams as __Cjs_CanPerformPermissionParams } from './index.js' with { "resolution-mode": "import" };
 import type { CollaborationConfig as __Cjs_CollaborationConfig } from './index.js' with { "resolution-mode": "import" };
 import type { CommentAddress as __Cjs_CommentAddress } from './index.js' with { "resolution-mode": "import" };
+import type { CommentsConfig as __Cjs_CommentsConfig } from './index.js' with { "resolution-mode": "import" };
 import type { CommentsType as __Cjs_CommentsType } from './index.js' with { "resolution-mode": "import" };
 import type { Config as __Cjs_Config } from './index.js' with { "resolution-mode": "import" };
 import type { ContentControlActiveChangePayload as __Cjs_ContentControlActiveChangePayload } from './index.js' with { "resolution-mode": "import" };
 import type { ContentControlClickPayload as __Cjs_ContentControlClickPayload } from './index.js' with { "resolution-mode": "import" };
+import type { ContentControlsConfig as __Cjs_ContentControlsConfig } from './index.js' with { "resolution-mode": "import" };
 import type { ContextMenuConfig as __Cjs_ContextMenuConfig } from './index.js' with { "resolution-mode": "import" };
 import type { ContextMenuContext as __Cjs_ContextMenuContext } from './index.js' with { "resolution-mode": "import" };
 import type { ContextMenuItem as __Cjs_ContextMenuItem } from './index.js' with { "resolution-mode": "import" };
 import type { ContextMenuSection as __Cjs_ContextMenuSection } from './index.js' with { "resolution-mode": "import" };
+import type { ContextMenuSelectContext as __Cjs_ContextMenuSelectContext } from './index.js' with { "resolution-mode": "import" };
+import type { ContextMenuSelectPayload as __Cjs_ContextMenuSelectPayload } from './index.js' with { "resolution-mode": "import" };
+import type { ContextMenuSelectReadiness as __Cjs_ContextMenuSelectReadiness } from './index.js' with { "resolution-mode": "import" };
 import type { DirectSurfaceRequest as __Cjs_DirectSurfaceRequest } from './index.js' with { "resolution-mode": "import" };
 import type { DocRange as __Cjs_DocRange } from './index.js' with { "resolution-mode": "import" };
 import type { Document as __Cjs_Document } from './index.js' with { "resolution-mode": "import" };
@@ -46,6 +51,7 @@ import type { LayoutFragment as __Cjs_LayoutFragment } from './index.js' with {
 import type { LayoutMetrics as __Cjs_LayoutMetrics } from './index.js' with { "resolution-mode": "import" };
 import type { LayoutMode as __Cjs_LayoutMode } from './index.js' with { "resolution-mode": "import" };
 import type { LayoutPage as __Cjs_LayoutPage } from './index.js' with { "resolution-mode": "import" };
+import type { LinkPopoverConfig as __Cjs_LinkPopoverConfig } from './index.js' with { "resolution-mode": "import" };
 import type { LinkPopoverContext as __Cjs_LinkPopoverContext } from './index.js' with { "resolution-mode": "import" };
 import type { LinkPopoverResolution as __Cjs_LinkPopoverResolution } from './index.js' with { "resolution-mode": "import" };
 import type { LinkPopoverResolver as __Cjs_LinkPopoverResolver } from './index.js' with { "resolution-mode": "import" };
@@ -161,6 +167,7 @@ import type { TextAddress as __Cjs_TextAddress } from './index.js' with { "resol
 import type { TextSegment as __Cjs_TextSegment } from './index.js' with { "resolution-mode": "import" };
 import type { TextTarget as __Cjs_TextTarget } from './index.js' with { "resolution-mode": "import" };
 import type { TrackChangeAuthor as __Cjs_TrackChangeAuthor } from './index.js' with { "resolution-mode": "import" };
+import type { TrackChangeHighlightColors as __Cjs_TrackChangeHighlightColors } from './index.js' with { "resolution-mode": "import" };
 import type { TrackChangesAuthorColorsConfig as __Cjs_TrackChangesAuthorColorsConfig } from './index.js' with { "resolution-mode": "import" };
 import type { TrackChangesModuleConfig as __Cjs_TrackChangesModuleConfig } from './index.js' with { "resolution-mode": "import" };
 import type { TrackChangesSemanticColorsConfig as __Cjs_TrackChangesSemanticColorsConfig } from './index.js' with { "resolution-mode": "import" };
@@ -185,15 +192,20 @@ export declare const buildTheme: typeof import('./index.js', { with: { "resoluti
 export type { __Cjs_CanPerformPermissionParams as CanPerformPermissionParams };
 export type { __Cjs_CollaborationConfig as CollaborationConfig };
 export type { __Cjs_CommentAddress as CommentAddress };
+export type { __Cjs_CommentsConfig as CommentsConfig };
 export type { __Cjs_CommentsType as CommentsType };
 export declare const compareVersions: typeof import('./index.js', { with: { "resolution-mode": "import" } }).compareVersions;
 export type { __Cjs_Config as Config };
 export type { __Cjs_ContentControlActiveChangePayload as ContentControlActiveChangePayload };
 export type { __Cjs_ContentControlClickPayload as ContentControlClickPayload };
+export type { __Cjs_ContentControlsConfig as ContentControlsConfig };
 export type { __Cjs_ContextMenuConfig as ContextMenuConfig };
 export type { __Cjs_ContextMenuContext as ContextMenuContext };
 export type { __Cjs_ContextMenuItem as ContextMenuItem };
 export type { __Cjs_ContextMenuSection as ContextMenuSection };
+export type { __Cjs_ContextMenuSelectContext as ContextMenuSelectContext };
+export type { __Cjs_ContextMenuSelectPayload as ContextMenuSelectPayload };
+export type { __Cjs_ContextMenuSelectReadiness as ContextMenuSelectReadiness };
 export declare const createTheme: typeof import('./index.js', { with: { "resolution-mode": "import" } }).createTheme;
 export declare const defineSuperDocExtension: typeof import('./index.js', { with: { "resolution-mode": "import" } }).defineSuperDocExtension;
 export type { __Cjs_DirectSurfaceRequest as DirectSurfaceRequest };
@@ -228,6 +240,7 @@ export type { __Cjs_LayoutFragment as LayoutFragment };
 export type { __Cjs_LayoutMetrics as LayoutMetrics };
 export type { __Cjs_LayoutMode as LayoutMode };
 export type { __Cjs_LayoutPage as LayoutPage };
+export type { __Cjs_LinkPopoverConfig as LinkPopoverConfig };
 export type { __Cjs_LinkPopoverContext as LinkPopoverContext };
 export type { __Cjs_LinkPopoverResolution as LinkPopoverResolution };
 export type { __Cjs_LinkPopoverResolver as LinkPopoverResolver };
@@ -345,6 +358,7 @@ export type { __Cjs_TextAddress as TextAddress };
 export type { __Cjs_TextSegment as TextSegment };
 export type { __Cjs_TextTarget as TextTarget };
 export type { __Cjs_TrackChangeAuthor as TrackChangeAuthor };
+export type { __Cjs_TrackChangeHighlightColors as TrackChangeHighlightColors };
 export type { __Cjs_TrackChangesAuthorColorsConfig as TrackChangesAuthorColorsConfig };
 export type { __Cjs_TrackChangesModuleConfig as TrackChangesModuleConfig };
 export type { __Cjs_TrackChangesSemanticColorsConfig as TrackChangesSemanticColorsConfig };

package/dist/superdoc/src/public/index.d.ts

@@ -72,6 +72,10 @@ export type { SuperDocLayoutEngineOptions as LayoutEngineOptions } from '../core
 export type { FlowBlock, FlowMode, Layout, Fragment as LayoutFragment, Page as LayoutPage } from '../../../layout-engine/contracts/src/index.js';
 export type { LayoutMetrics } from '../../../layout-engine/layout-bridge/src/index.js';
 export type { LayoutMode } from '../../../layout-engine/painters/dom/src/index.js';
+export type { CommentsConfig } from '../core/types/index.js';
+export type { TrackChangeHighlightColors } from '../core/types/index.js';
+export type { ContentControlsConfig } from '../core/types/index.js';
+export type { LinkPopoverConfig } from '../core/types/index.js';
 export type { LinkPopoverContext } from '../core/types/index.js';
 export type { LinkPopoverResolution } from '../core/types/index.js';
 export type { LinkPopoverResolver } from '../core/types/index.js';
@@ -176,4 +180,7 @@ export type { ContextMenuConfig } from '../core/types/index.js';
 export type { ContextMenuContext } from '../core/types/index.js';
 export type { ContextMenuItem } from '../core/types/index.js';
 export type { ContextMenuSection } from '../core/types/index.js';
+export type { ContextMenuSelectContext } from '../core/types/index.js';
+export type { ContextMenuSelectPayload } from '../core/types/index.js';
+export type { ContextMenuSelectReadiness } from '../core/types/index.js';
 export type { FindReplaceConfig } from '../core/types/index.js';