superdoc 2.2.1 → 2.3.0

package/dist/superdoc/src/core/collaboration/collaboration-comments.d.ts

@@ -0,0 +1,4 @@
+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;

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

@@ -0,0 +1,28 @@
+/**
+ * Main function to create a provider for collaboration.
+ * Currently only hocuspocus is actually supported.
+ *
+ * @deprecated Use external provider instead. Pass { ydoc, provider } to modules.collaboration config.
+ * @param {Object} param The config object
+ * @param {Object} param.config The configuration object
+ * @param {Object} param.ydoc The Yjs document
+ * @param {Object} param.user The user object
+ * @param {string} param.documentId The document ID
+ * @returns {Object} The provider and socket
+ */
+export function createProvider({ config, user, documentId, socket, superdocInstance }: {
+    config: Object;
+    ydoc: Object;
+    user: Object;
+    documentId: string;
+}): Object;
+/**
+ * Setup awareness handler for external providers.
+ * Wires up awareness 'change' events to emit superdoc 'awareness-update' events.
+ *
+ * @param {Object} provider The external provider (must have awareness property)
+ * @param {Object} superdocInstance The SuperDoc instance
+ * @param {Object} user The user object for local awareness state
+ * @returns {() => void} Cleanup function that removes the awareness listener
+ */
+export function setupAwarenessHandler(provider: Object, superdocInstance: Object, user: Object): () => void;

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

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

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

@@ -0,0 +1,19 @@
+export const PERMISSIONS: Readonly<{
+    RESOLVE_OWN: "RESOLVE_OWN";
+    RESOLVE_OTHER: "RESOLVE_OTHER";
+    REJECT_OWN: "REJECT_OWN";
+    REJECT_OTHER: "REJECT_OTHER";
+    COMMENTS_OVERFLOW_OWN: "COMMENTS_OVERFLOW";
+    COMMENTS_OVERFLOW_OTHER: "COMMENTS_OVERFLOW_OTHER";
+    COMMENTS_DELETE_OWN: "COMMENTS_DELETE_OWN";
+    COMMENTS_DELETE_OTHER: "COMMENTS_DELETE_OTHER";
+    UPLOAD_VERSION: "UPLOAD_VERSION";
+    VERSION_HISTORY: "VERSION_HISTORY";
+}>;
+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;

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

@@ -0,0 +1,99 @@
+/**
+ * Centralized v2 collaboration target resolver.
+ *
+ * This is the single authority that decides whether a constructor-time
+ * collaboration config or a late `upgradeToCollaboration(...)` call resolves to
+ * a **supported** SuperDoc v2 collaboration room. SuperDoc v2 ships three
+ * first-class single-doc provider families — y-websocket, Hocuspocus, and
+ * Liveblocks — each bound to one `Y.Doc`, one provider session, and one
+ * awareness channel (implemented inside the bundled v2 runtime) and surfaced
+ * publicly through {@link V2CollaborationConfig} (`Document.v2Collaboration`).
+ *
+ * The resolver never returns a "maybe collaborative" result: it either returns
+ * a normalized, supported target or a stable, redacted diagnostic. Tokens, auth
+ * keys, auth endpoints, and query strings are never echoed back in diagnostics.
+ */
+/** Provider families the shipped v2 single-doc runtime can drive. */
+export type SupportedV2ProviderFamily = 'y-websocket' | 'hocuspocus' | 'liveblocks';
+/**
+ * Stable, machine-readable reasons a target cannot be treated as a supported v2
+ * 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' | 'missing-auth' | 'mixed-auth' | 'unsupported-document-type' | 'unsupported-multi-document' | 'unsupported-legacy-provider' | 'unsupported-provider-family';
+/**
+ * Normalized, supported v2 collaboration room target.
+ *
+ * The shape is flat with provider-specific optional fields. y-websocket and
+ * Hocuspocus carry `serverUrl` (and Hocuspocus optionally `token`); Liveblocks
+ * carries exactly one of `publicApiKey` or `authEndpoint`. Only the fields that
+ * apply to the resolved family are present.
+ */
+export interface NormalizedV2CollaborationTarget {
+    providerFamily: SupportedV2ProviderFamily;
+    /** Stable shared document/room identity. */
+    documentId: string;
+    /** WebSocket server URL (y-websocket / Hocuspocus single-doc providers). */
+    serverUrl?: string;
+    /** Optional connection query params (e.g. auth token) forwarded verbatim. */
+    params?: Record<string, string>;
+    /** Hocuspocus auth-message token. */
+    token?: string;
+    /** Liveblocks anonymous public key auth mode. */
+    publicApiKey?: string;
+    /** Liveblocks server-side auth endpoint mode. */
+    authEndpoint?: string;
+    /** Explicit room operation; join is the default at the untrusted input boundary. */
+    roomMode: 'join' | 'create';
+}
+export type V2CollaborationTargetResolution = {
+    ok: true;
+    target: NormalizedV2CollaborationTarget;
+} | {
+    ok: false;
+    reason: V2CollaborationUnsupportedReason;
+    /** Human-readable, fully redacted diagnostic message. */
+    message: string;
+};
+/**
+ * Loose input shape for a legacy `modules.collaboration` / upgrade option block.
+ * Typed permissively because the resolver inspects arbitrary consumer input and
+ * must classify it without trusting its shape.
+ */
+export interface LegacyCollaborationLike {
+    ydoc?: unknown;
+    provider?: unknown;
+    providerType?: unknown;
+    url?: unknown;
+    [key: string]: unknown;
+}
+export interface ResolveV2CollaborationTargetInput {
+    /** Document-level v2 collaboration config (canonical supported entry point). */
+    v2Collaboration?: unknown;
+    /** Legacy provider-agnostic collaboration block (`modules.collaboration` / upgrade opts). */
+    legacyCollaboration?: LegacyCollaborationLike | null;
+    /** The single document's type. v2 collaboration supports DOCX only. */
+    documentType?: string | null;
+    /** Total number of mounted documents. v2 single-doc rooms support exactly one. */
+    documentCount?: number;
+    /**
+     * Browser URL used only to resolve a relative Liveblocks auth endpoint.
+     * Non-browser callers omit this so relative endpoints continue to fail
+     * closed when there is no origin against which to resolve them.
+     */
+    authEndpointBaseUrl?: string;
+}
+/**
+ * Redact a connection URL for safe inclusion in diagnostics and artifacts.
+ *
+ * Strips the query string, fragment, and any embedded credentials (userinfo)
+ * because those commonly carry auth tokens. Falls back to a coarse string scrub
+ * when the value is not a parseable absolute URL so a malformed value with an
+ * inline `?token=...` still cannot leak.
+ */
+export declare function redactCollaborationUrl(url: unknown): string;
+/**
+ * Resolve a constructor-time or upgrade-time collaboration request into a
+ * supported v2 room target, or a stable redacted diagnostic.
+ */
+export declare function resolveV2CollaborationTarget(input: ResolveV2CollaborationTargetInput): V2CollaborationTargetResolution;

package/dist/superdoc/src/core/collaboration/room-overwrite.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Overwrite the room's comment array with the current local comments.
+ *
+ * Performs an authoritative replacement — all existing room comments
+ * are removed and replaced with serialized local state.
+ *
+ * @param {import('yjs').Doc} ydoc The target Yjs document
+ * @param {Array} commentsList The local comments list (items with `getValues()`)
+ * @returns {void}
+ */
+export function overwriteRoomComments(ydoc: import('yjs').Doc, commentsList: any[]): void;
+/**
+ * Transfer the local lock state into the target room's meta map.
+ *
+ * @param {import('yjs').Doc} ydoc The target Yjs document
+ * @param {{ isLocked: boolean, lockedBy: Object | null }} lockState
+ * @returns {void}
+ */
+export function overwriteRoomLockState(ydoc: import('yjs').Doc, { isLocked, lockedBy }: {
+    isLocked: boolean;
+    lockedBy: Object | null;
+}): void;

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

@@ -0,0 +1,57 @@
+import { AwarenessState, User } from '../types/index.js';
+/**
+ * Compatibility bridge from the v2 presence runtime to the legacy
+ * `awareness-update` public event.
+ *
+ * The shipped v2 presence facade reports normalized remote-actor snapshots
+ * from the bundled browser presence bridge. The legacy
+ * public `awareness-update` payload, by contrast, is a v1-shaped
+ * `{ states: AwarenessState[], added: number[], removed: number[] }` where
+ * `added` / `removed` are numeric client ids.
+ *
+ * v2 presence identifies actors with stable string ids, not numeric Yjs
+ * client ids. To preserve the documented `number[]` public contract this
+ * bridge maintains a deterministic string→number registry: each distinct
+ * actor key is assigned a stable numeric id the first time it is seen, and
+ * that id is reused for the lifetime of the bridge. The local actor always
+ * maps to client id `0`.
+ */
+/** Minimal remote-actor shape consumed from the v2 presence facade snapshot. */
+export interface V2AwarenessRemoteActor {
+    /** Stable label resolved by the presence facade (userId → displayName → fallback). */
+    actorLabel: string;
+    displayName?: string | null;
+    email?: string | null;
+    color?: string | null;
+}
+/** Minimal presence-facade snapshot shape the bridge reads. */
+export interface V2AwarenessSnapshotLike {
+    remoteActors: ReadonlyArray<V2AwarenessRemoteActor>;
+}
+/** Core `awareness-update` payload (the `superdoc` backref is added by the caller). */
+export interface V2AwarenessPayloadCore {
+    states: AwarenessState[];
+    added: number[];
+    removed: number[];
+}
+/**
+ * Stable string→number id registry. The local actor is reserved id `0`; remote
+ * actors are assigned monotonically increasing ids starting at `1`.
+ */
+export declare class V2AwarenessIdRegistry {
+    #private;
+    idFor(key: string): number;
+    /** True once a key has been assigned an id. */
+    has(key: string): boolean;
+}
+/**
+ * Create a stateful presence→awareness differ.
+ *
+ * Each call to `next(snapshot)` returns the legacy-shaped awareness payload
+ * core for that snapshot, computing `added` / `removed` against the previously
+ * observed remote-actor set. The local user is always included in `states`.
+ */
+export declare function createV2AwarenessDiffer(getLocalUser: () => User | null | undefined): {
+    registry: V2AwarenessIdRegistry;
+    next(snapshot: V2AwarenessSnapshotLike): V2AwarenessPayloadCore;
+};

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

@@ -0,0 +1,35 @@
+/**
+ * Merge config layers without letting an explicit `undefined` erase a value.
+ *
+ * Object spread treats a present-but-undefined key as a real assignment, so
+ * `{ ...legacy, ...next }` clobbers `legacy.closeOnEscape` whenever `next`
+ * carries `closeOnEscape: undefined`. That shape is common and unintentional:
+ * configs assembled from optional properties, spreads, or destructured
+ * arguments routinely carry keys whose value is undefined without the consumer
+ * meaning anything by it.
+ *
+ * Everywhere this migration merges a new spelling over a legacy one, the rule
+ * is the same as the single-value case: `undefined` means "unset, fall
+ * through", and only an explicit value overrides.
+ */
+/**
+ * Merge sources left to right, skipping keys whose value is `undefined`.
+ *
+ * Later sources win, as with spread. Non-object sources are ignored so callers
+ * can pass a possibly-absent block without guarding first.
+ *
+ * @param {...(Record<string, unknown> | undefined)} sources
+ * @returns {Record<string, unknown>}
+ */
+export function mergeDefined(...sources: (Record<string, unknown> | undefined)[]): Record<string, unknown>;
+/**
+ * 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;

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

@@ -0,0 +1,15 @@
+/**
+ * Resolve the effective interaction policy.
+ *
+ * Reads `interaction.comments` first, then the legacy fields on
+ * `modules.comments`, so both spellings work while the migration lands.
+ *
+ * @param {Record<string, any>} [config] Raw consumer config.
+ * @returns {{ comments: { readOnly: boolean, allowResolve: boolean } }}
+ */
+export function normalizeInteractionConfig(config?: Record<string, any>): {
+    comments: {
+        readOnly: boolean;
+        allowResolve: boolean;
+    };
+};

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

@@ -0,0 +1,23 @@
+/**
+ * Resolve the generic surface infrastructure config.
+ *
+ * Reads top-level `surfaces` first, then the legacy `modules.surfaces` block,
+ * so both spellings work while the migration lands. Built-in surface intents
+ * are deliberately not read here; they belong to the UI profile.
+ *
+ * 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"]>;
+};

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

@@ -0,0 +1,62 @@
+/**
+ * Collapse a consumer config into the effective built-in UI profile.
+ *
+ * @param {Record<string, any>} [config] Raw consumer config.
+ * @returns {{
+ *   enabled: boolean,
+ *   toolbar: { enabled: boolean, container: string | HTMLElement | null, options: Record<string, unknown> },
+ *   comments: { enabled: boolean, options: Record<string, unknown> },
+ *   contextMenu: { enabled: boolean, suppressed: boolean, options: Record<string, unknown> },
+ *   search: { enabled: boolean, options: Record<string, unknown> },
+ *   linkPopover: { enabled: boolean, suppressed: boolean, options: Record<string, unknown> },
+ *   ruler: { enabled: boolean, suppressed: boolean, container: string | HTMLElement | null },
+ *   contentControls: { enabled: boolean, options: Record<string, unknown> },
+ * }}
+ */
+export function normalizeUiConfig(config?: Record<string, any>): {
+    enabled: boolean;
+    toolbar: {
+        enabled: boolean;
+        container: string | HTMLElement | null;
+        options: Record<string, unknown>;
+    };
+    comments: {
+        enabled: boolean;
+        options: Record<string, unknown>;
+    };
+    contextMenu: {
+        enabled: boolean;
+        suppressed: boolean;
+        options: Record<string, unknown>;
+    };
+    search: {
+        enabled: boolean;
+        options: Record<string, unknown>;
+    };
+    linkPopover: {
+        enabled: boolean;
+        suppressed: boolean;
+        options: Record<string, unknown>;
+    };
+    ruler: {
+        enabled: boolean;
+        suppressed: boolean;
+        container: string | HTMLElement | null;
+    };
+    contentControls: {
+        enabled: boolean;
+        options: Record<string, unknown>;
+    };
+};
+/** Every built-in surface `ui: false` turns off. */
+export const BUILT_IN_SURFACES: readonly string[];
+/** Surfaces that render when the consumer says nothing at all. */
+export const HISTORICAL_DEFAULTS: Readonly<{
+    toolbar: true;
+    comments: true;
+    contextMenu: true;
+    search: false;
+    linkPopover: false;
+    ruler: false;
+    contentControls: true;
+}>;

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

@@ -0,0 +1,32 @@
+import { useSuperdocStore } from '../stores/superdoc-store.js';
+import { useCommentsStore } from '../stores/comments-store.js';
+import { useHighContrastMode } from '../composables/use-high-contrast-mode.js';
+export function createSuperdocVueApp({ disablePiniaDevtools }?: {
+    disablePiniaDevtools?: boolean | undefined;
+}): 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
+     */
+    superdocStore: ReturnType<typeof useSuperdocStore>;
+    /**
+     * The Comments Pinia store
+     */
+    commentsStore: ReturnType<typeof useCommentsStore>;
+    /**
+     * The high-contrast mode composable refs (`isHighContrastMode`, `setHighContrastMode`). Named `*Store` for historical reasons; this is a plain Vue composable, not a Pinia store.
+     */
+    highContrastModeStore: ReturnType<typeof useHighContrastMode>;
+};

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

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

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

@@ -0,0 +1,117 @@
+import { EditorRuntime, EditorRuntimeId } from './types.js';
+/**
+ * Payload emitted whenever the active runtime changes (including when the active
+ * runtime is unregistered and active state clears).
+ */
+export interface EditorRuntimeRegistryActiveChange {
+    /** Runtime id that was active before this change, or `null`. */
+    readonly previousRuntimeId: EditorRuntimeId | null;
+    /** Runtime id that is active after this change, or `null` when cleared. */
+    readonly nextRuntimeId: EditorRuntimeId | null;
+    /** Stable reason string describing why the active runtime changed. */
+    readonly reason: string;
+    /**
+     * The next active runtime's compatibility projection, if it exposes one. This
+     * is the value SuperDoc routes through `setActiveEditor(...)` to keep the
+     * `activeEditor` compatibility surface populated. `null` when the active
+     * runtime was cleared or the runtime has no legacy projection.
+     */
+    readonly legacyEditorProjection: unknown | null;
+}
+export type EditorRuntimeRegistryListener = (change: EditorRuntimeRegistryActiveChange) => void;
+export type EditorRuntimeRegistryUnsubscribe = () => void;
+/**
+ * Internal SuperDoc registry of mounted editor runtimes and the active-runtime
+ * routing policy. Not a public SDK surface.
+ */
+export declare class EditorRuntimeRegistry {
+    #private;
+    /**
+     * Register a mounted runtime.
+     *
+     * Does NOT auto-activate the runtime  -  activation is always an explicit
+     * `setActive(...)` decision so cleanup never silently retargets commands.
+     *
+     * @param runtime The runtime to register.
+     * @throws If a runtime with the same id is already registered, or a different
+     *   runtime is already registered against the same root element.
+     */
+    register(runtime: EditorRuntime): void;
+    /**
+     * Unregister a runtime by id.
+     *
+     * If the unregistered runtime is the active one, active state is CLEARED and an
+     * active-change event with `nextRuntimeId: null` is emitted. The registry must
+     * NOT auto-promote another runtime to active  -  that would silently retarget
+     * commands to a different document (the runtime contract, exit criteria §7).
+     *
+     * @param runtimeId The runtime id to remove.
+     * @returns `true` when a runtime was removed, `false` when none matched.
+     */
+    unregister(runtimeId: EditorRuntimeId): boolean;
+    /**
+     * Get a registered runtime by id.
+     *
+     * @param runtimeId The runtime id.
+     * @returns The runtime, or `null` when not registered.
+     */
+    get(runtimeId: EditorRuntimeId): EditorRuntime | null;
+    /**
+     * All registered runtimes, in registration order.
+     */
+    getAll(): EditorRuntime[];
+    /**
+     * All registered runtimes for a document id, in registration order.
+     *
+     * Returns every match rather than silently picking the first, because two
+     * runtimes can legitimately back the same document.
+     *
+     * @param documentId The document id to match.
+     * @returns The matching runtimes (possibly empty).
+     */
+    getAllByDocumentId(documentId: string): EditorRuntime[];
+    /**
+     * The currently active runtime, or `null` when none is active.
+     */
+    getActive(): EditorRuntime | null;
+    /**
+     * The currently active runtime id, or `null`.
+     */
+    getActiveId(): EditorRuntimeId | null;
+    /**
+     * Select the active runtime (or clear it with `null`).
+     *
+     * Idempotent: selecting the already-active runtime is a no-op and emits
+     * nothing, so it does not trigger a redundant toolbar rebind.
+     *
+     * @param runtimeId The runtime id to activate, or `null` to clear active state.
+     * @param reason Stable reason string for the active-change event.
+     * @throws If `runtimeId` is non-null and not registered.
+     */
+    setActive(runtimeId: EditorRuntimeId | null, reason: string): void;
+    /**
+     * Resolve the runtime that owns a DOM event target by walking up to the
+     * nearest element carrying the shell-owned root marker.
+     *
+     * This selects a runtime only; it performs no coordinate-to-position mapping
+     * and no command dispatch.
+     *
+     * @param target An event target (typically `event.target`), node, or `null`.
+     * @returns The owning runtime, or `null` when no marked root is found or the
+     *   marked id is not registered.
+     */
+    resolveFromEventTarget(target: EventTarget | null): EditorRuntime | null;
+    /**
+     * Subscribe to active-runtime changes.
+     *
+     * @param listener Called with each {@link EditorRuntimeRegistryActiveChange}.
+     * @returns An unsubscribe function.
+     */
+    subscribe(listener: EditorRuntimeRegistryListener): EditorRuntimeRegistryUnsubscribe;
+    /**
+     * Tear down the registry: drop all runtimes, root index, active state, and
+     * subscriptions. Used during SuperDoc destroy / document teardown. Does not
+     * emit  -  subscribers are being released alongside the registry.
+     */
+    clear(): void;
+}

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

@@ -0,0 +1 @@
+export type { EditorRuntimeKind, EditorRuntimeId, EditorRuntimeDocumentMode, EditorRuntimeState, EditorRuntime, EditorRuntimeSnapshot, EditorRuntimeCapabilities, RuntimeLifecycleCapabilities, RuntimeSelectionCapabilities, RuntimeCommandCapabilities, RuntimeFindReplaceCapabilities, RuntimeAiCapabilities, RuntimeCommentCapabilities, RuntimeTrackedChangeCapabilities, RuntimeToolbarCapabilities, RuntimeLayoutCapabilities, RuntimeZoomCapabilities, RuntimeNavigationCapabilities, RuntimePersistenceCapabilities, EditorRuntimeCommand, EditorRuntimeCommandKind, EditorRuntimeCommandResult, EditorRuntimeRejectionCode, EditorRuntimeNoopReason, EditorRuntimeSelectionSnapshot, EditorRuntimeFindSessionSnapshot, EditorRuntimeToolbarState, EditorRuntimeLayoutSnapshot, EditorRuntimePositionToken, EditorRuntimeFocusOptions, EditorRuntimeSaveOptions, EditorRuntimeExportOptions, EditorRuntimeNavigationTarget, EditorRuntimeEvent, EditorRuntimeListener, EditorRuntimeUnsubscribe, RuntimeJsonPrimitive, RuntimeJsonValue, RuntimeJsonObject, } from './types.js';

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

@@ -0,0 +1,33 @@
+import { EditorRuntimeId } from './types.js';
+/**
+ * The data attribute the shell stamps on each runtime's host wrapper element.
+ * `EditorRuntimeRegistry.resolveFromEventTarget` walks up from an event target
+ * to the nearest element carrying this attribute.
+ */
+export declare const RUNTIME_ROOT_ATTRIBUTE = "data-superdoc-runtime-id";
+/**
+ * Mark a shell-owned host element as the root for a mounted runtime.
+ *
+ * Call this on the wrapper the shell owns around a runtime, not on painter DOM.
+ *
+ * @param root The shell-owned host wrapper element.
+ * @param id The runtime id to associate with this root.
+ */
+export declare function markRuntimeRoot(root: HTMLElement, id: EditorRuntimeId): void;
+/**
+ * Remove the runtime-root marker from a host element.
+ *
+ * @param root The shell-owned host wrapper element.
+ */
+export declare function unmarkRuntimeRoot(root: HTMLElement): void;
+/**
+ * Read the runtime id marked directly on an element, or `null` when absent.
+ *
+ * This reads the attribute off the given element only; it does not walk
+ * ancestors. Use `EditorRuntimeRegistry.resolveFromEventTarget` for the
+ * ancestor walk from an arbitrary event target.
+ *
+ * @param root The element to inspect.
+ * @returns The marked runtime id, or `null`.
+ */
+export declare function readRuntimeRootId(root: Element | null): EditorRuntimeId | null;