@liminis/editor 0.4.1 → 0.6.0

package/dist/app/editor/nodes/CustomLinkNode.js

@@ -19,10 +19,19 @@ export class CustomLinkNode extends LinkNode {
      * @internal
      */
     __wikiLinkOrigin;
+    /**
+     * Obsidian-style `#^blockId` fragment (#119), when this link is a
+     * block-scoped wiki-link (`[[file#^id]]`). `null` for an ordinary
+     * file-only or heading-anchor wiki-link. Deliberately a field separate
+     * from `__url` — see `mdastToLexical.ts`/`lexicalToMdast.ts` for why.
+     * @internal
+     */
+    __blockId;
     constructor(url, attributes, key) {
         super(url, attributes, key);
         this.__wikiAliasState = null;
         this.__wikiLinkOrigin = false;
+        this.__blockId = null;
     }
     static getType() {
         return 'link'; // Use same type to replace the default LinkNode
@@ -31,6 +40,7 @@ export class CustomLinkNode extends LinkNode {
         const cloned = new CustomLinkNode(node.__url, { rel: node.__rel, target: node.__target, title: node.__title }, node.__key);
         cloned.__wikiAliasState = node.__wikiAliasState;
         cloned.__wikiLinkOrigin = node.__wikiLinkOrigin;
+        cloned.__blockId = node.__blockId;
         return cloned;
     }
     createDOM(config) {
@@ -54,6 +64,9 @@ export class CustomLinkNode extends LinkNode {
         if (this.isWikiLink()) {
             element.setAttribute('data-wiki-link', 'true');
             element.setAttribute('data-wiki-target', this.__url);
+            if (this.__blockId) {
+                element.setAttribute('data-block-id', this.__blockId);
+            }
         }
         else if (this.isExternalLink()) {
             // External links get blue styling to differentiate from wiki-links
@@ -97,6 +110,7 @@ export class CustomLinkNode extends LinkNode {
             else {
                 anchor.removeAttribute('data-wiki-link');
                 anchor.removeAttribute('data-wiki-target');
+                anchor.removeAttribute('data-block-id');
                 anchor.classList.remove('editor-link-broken');
                 if (this.isExternalLink()) {
                     anchor.classList.add('editor-link-external');
@@ -106,6 +120,14 @@ export class CustomLinkNode extends LinkNode {
                 }
             }
         }
+        if (this.__blockId !== prevNode.__blockId) {
+            if (this.__blockId && this.isWikiLink()) {
+                anchor.setAttribute('data-block-id', this.__blockId);
+            }
+            else {
+                anchor.removeAttribute('data-block-id');
+            }
+        }
         if (target !== prevNode.__target) {
             if (target) {
                 anchor.target = target;
@@ -155,6 +177,9 @@ export class CustomLinkNode extends LinkNode {
         if (serializedNode.wikiLinkOrigin) {
             node.__wikiLinkOrigin = true;
         }
+        if (serializedNode.blockId) {
+            node.__blockId = serializedNode.blockId;
+        }
         node.setFormat(serializedNode.format);
         node.setIndent(serializedNode.indent);
         node.setDirection(serializedNode.direction);
@@ -167,6 +192,7 @@ export class CustomLinkNode extends LinkNode {
             version: 1,
             wikiAliasState: this.__wikiAliasState ?? undefined,
             wikiLinkOrigin: this.__wikiLinkOrigin ? true : undefined,
+            blockId: this.__blockId ?? undefined,
         };
     }
     setWikiAliasState(state) {
@@ -183,6 +209,13 @@ export class CustomLinkNode extends LinkNode {
     getWikiLinkOrigin() {
         return this.__wikiLinkOrigin;
     }
+    setBlockId(blockId) {
+        const writable = this.getWritable();
+        writable.__blockId = blockId;
+    }
+    getBlockId() {
+        return this.__blockId;
+    }
 }
 function convertAnchorElement(domNode) {
     let node = null;
@@ -195,6 +228,10 @@ function convertAnchorElement(domNode) {
                 target: domNode.getAttribute('target'),
                 title: domNode.getAttribute('title'),
             });
+            const blockId = domNode.getAttribute('data-block-id');
+            if (blockId) {
+                node.__blockId = blockId;
+            }
         }
     }
     return { node };

package/dist/app/editor/nodes/TransclusionComponent.d.ts

@@ -0,0 +1,8 @@
+import { NodeKey } from 'lexical';
+interface TransclusionComponentProps {
+    file: string;
+    blockId: string;
+    nodeKey: NodeKey;
+}
+export default function TransclusionComponent({ file, blockId }: TransclusionComponentProps): JSX.Element;
+export {};

package/dist/app/editor/nodes/TransclusionComponent.js

@@ -0,0 +1,65 @@
+/**
+ * TransclusionComponent - resolves and renders a block transclusion
+ * (`![[file#^id]]`, #119)
+ *
+ * Mirrors `MermaidComponent`'s split: `TransclusionNode` is a static,
+ * serializable value (`file`/`blockId`/`alias`); the actual host-resolver
+ * call happens here, inside the lazily-loaded component, since resolution is
+ * `Promise`-based and the mdast<->Lexical mapper is synchronous.
+ */
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { useEffect, useRef, useState } from 'react';
+import { useEditorHost } from '../../../host/context.js';
+import { resolveAndRenderTransclusion, renderTransclusionState, } from './transclusion-render.js';
+import { renderTransclusionLoading } from './transclusion-loading.js';
+// Matches WikiLinkExistencePlugin's debounce window for the same reason:
+// both re-run a host resolver on every dirty editor update, and without
+// debouncing that fires one resolver call (potentially I/O-bound) per
+// keystroke per visible reference.
+const RESOLVE_DEBOUNCE_MS = 300;
+export default function TransclusionComponent({ file, blockId }) {
+    const [editor] = useLexicalComposerContext();
+    const { resolveTransclusion } = useEditorHost();
+    const [state, setState] = useState(null);
+    // Guards against a stale resolution landing after a newer one already
+    // started (e.g. file/blockId changed, or two update-listener firings
+    // overlap) — only the most recent request is allowed to commit state.
+    const generationRef = useRef(0);
+    useEffect(() => {
+        let cancelled = false;
+        let debounceTimeout = null;
+        const resolve = async () => {
+            const generation = ++generationRef.current;
+            const result = await resolveAndRenderTransclusion(file, blockId, resolveTransclusion, []);
+            if (!cancelled && generation === generationRef.current) {
+                setState(result);
+            }
+        };
+        void resolve();
+        // FR-006/SC-002: re-resolve on every document change so an edit to the
+        // source block — in this document, or elsewhere once the host's own
+        // resolver reflects it — shows up without the host having to remount
+        // the editor. Pull-based and unmemoized (every dirty update re-resolves
+        // every visible transclusion): an accepted v1 cost, not a correctness
+        // gap — see the Plan's "no push/invalidation channel" risk note. The
+        // debounce below only bounds *how often* that cost is paid per burst of
+        // edits, mirroring WikiLinkExistencePlugin's existing convention.
+        const unregister = editor.registerUpdateListener(({ dirtyElements, dirtyLeaves }) => {
+            if (dirtyElements.size > 0 || dirtyLeaves.size > 0) {
+                if (debounceTimeout)
+                    clearTimeout(debounceTimeout);
+                debounceTimeout = setTimeout(() => { void resolve(); }, RESOLVE_DEBOUNCE_MS);
+            }
+        });
+        return () => {
+            cancelled = true;
+            if (debounceTimeout)
+                clearTimeout(debounceTimeout);
+            unregister();
+        };
+    }, [editor, file, blockId, resolveTransclusion]);
+    if (state === null) {
+        return renderTransclusionLoading();
+    }
+    return renderTransclusionState(state);
+}

package/dist/app/editor/nodes/TransclusionNode.d.ts

@@ -0,0 +1,48 @@
+/**
+ * TransclusionNode - Live-rendered block transclusion (`![[file#^id]]`, #119)
+ *
+ * An **inline** DecoratorNode, unlike the block-level `MermaidNode`: a
+ * `wikiEmbed` mdast node is phrasing content (same family as `wikiLink`/
+ * `image`), so this matches where it actually sits in the tree rather than
+ * forcing paragraph-promotion logic to accommodate it.
+ *
+ * `file`/`blockId` are the sole identity the node carries; `alias` is stored
+ * only for byte-identical round-trip (`![[file#^id|alias]]`) — an embed
+ * renders the resolved block's *live content*, never the alias text, so
+ * nothing here displays it. Content resolution is async and host-resolver-
+ * driven (see `transclusion-render.tsx`), so — mirroring `MermaidNode` — the
+ * actual resolver call happens inside the lazily-loaded `TransclusionComponent`
+ * at decorate-time, not here: this node is a static, serializable value.
+ */
+import { DecoratorNode, DOMConversionMap, DOMExportOutput, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from 'lexical';
+export type SerializedTransclusionNode = Spread<{
+    file: string;
+    blockId: string;
+    alias: string | null;
+    emptyAlias: boolean;
+}, SerializedLexicalNode>;
+export declare class TransclusionNode extends DecoratorNode<JSX.Element> {
+    __file: string;
+    __blockId: string;
+    __alias: string | null;
+    __emptyAlias: boolean;
+    static getType(): string;
+    static clone(node: TransclusionNode): TransclusionNode;
+    constructor(file: string, blockId: string, alias?: string | null, emptyAlias?: boolean, key?: NodeKey);
+    static importJSON(serializedNode: SerializedTransclusionNode): TransclusionNode;
+    exportJSON(): SerializedTransclusionNode;
+    createDOM(): HTMLElement;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    updateDOM(): boolean;
+    isInline(): boolean;
+    getFile(): string;
+    getBlockId(): string;
+    getAlias(): string | null;
+    setAlias(alias: string | null): void;
+    getEmptyAlias(): boolean;
+    setEmptyAlias(emptyAlias: boolean): void;
+    decorate(): JSX.Element;
+}
+export declare function $createTransclusionNode(file: string, blockId: string, alias?: string | null, emptyAlias?: boolean): TransclusionNode;
+export declare function $isTransclusionNode(node: LexicalNode | null | undefined): node is TransclusionNode;

package/dist/app/editor/nodes/TransclusionNode.js

@@ -0,0 +1,141 @@
+/* eslint-disable react-refresh/only-export-components */
+/**
+ * TransclusionNode - Live-rendered block transclusion (`![[file#^id]]`, #119)
+ *
+ * An **inline** DecoratorNode, unlike the block-level `MermaidNode`: a
+ * `wikiEmbed` mdast node is phrasing content (same family as `wikiLink`/
+ * `image`), so this matches where it actually sits in the tree rather than
+ * forcing paragraph-promotion logic to accommodate it.
+ *
+ * `file`/`blockId` are the sole identity the node carries; `alias` is stored
+ * only for byte-identical round-trip (`![[file#^id|alias]]`) — an embed
+ * renders the resolved block's *live content*, never the alias text, so
+ * nothing here displays it. Content resolution is async and host-resolver-
+ * driven (see `transclusion-render.tsx`), so — mirroring `MermaidNode` — the
+ * actual resolver call happens inside the lazily-loaded `TransclusionComponent`
+ * at decorate-time, not here: this node is a static, serializable value.
+ */
+import { DecoratorNode, $applyNodeReplacement, } from 'lexical';
+import { createElement, lazy, Suspense } from 'react';
+import { renderTransclusionLoading } from './transclusion-loading.js';
+const TransclusionComponent = lazy(() => import('./TransclusionComponent.js'));
+function $convertTransclusionElement(domNode) {
+    const file = domNode.getAttribute('data-lexical-transclusion-file');
+    const blockId = domNode.getAttribute('data-lexical-transclusion-block-id');
+    if (file && blockId) {
+        const alias = domNode.getAttribute('data-lexical-transclusion-alias');
+        const emptyAlias = domNode.getAttribute('data-lexical-transclusion-empty-alias') === 'true';
+        const node = $createTransclusionNode(file, blockId, alias, emptyAlias);
+        return { node };
+    }
+    return null;
+}
+export class TransclusionNode extends DecoratorNode {
+    __file;
+    __blockId;
+    __alias;
+    __emptyAlias;
+    static getType() {
+        return 'transclusion';
+    }
+    static clone(node) {
+        return new TransclusionNode(node.__file, node.__blockId, node.__alias, node.__emptyAlias, node.__key);
+    }
+    constructor(file, blockId, alias = null, emptyAlias = false, key) {
+        super(key);
+        this.__file = file;
+        this.__blockId = blockId;
+        this.__alias = alias;
+        this.__emptyAlias = emptyAlias;
+    }
+    static importJSON(serializedNode) {
+        return $createTransclusionNode(serializedNode.file, serializedNode.blockId, serializedNode.alias, serializedNode.emptyAlias);
+    }
+    exportJSON() {
+        return {
+            type: 'transclusion',
+            version: 1,
+            file: this.__file,
+            blockId: this.__blockId,
+            alias: this.__alias,
+            emptyAlias: this.__emptyAlias,
+        };
+    }
+    createDOM() {
+        const element = document.createElement('span');
+        element.className = 'editor-transclusion';
+        return element;
+    }
+    exportDOM() {
+        const element = document.createElement('span');
+        element.setAttribute('data-lexical-transclusion-file', this.__file);
+        element.setAttribute('data-lexical-transclusion-block-id', this.__blockId);
+        if (this.__alias !== null) {
+            element.setAttribute('data-lexical-transclusion-alias', this.__alias);
+        }
+        if (this.__emptyAlias) {
+            element.setAttribute('data-lexical-transclusion-empty-alias', 'true');
+        }
+        element.className = 'transclusion-export';
+        // Never crash a copy/paste-shaped export by trying to resolve content
+        // synchronously (FR-008) — a plain placeholder is a faithful, inert
+        // stand-in for the live view this node otherwise renders.
+        element.textContent = renderPlaceholderText(this.__file, this.__blockId);
+        return { element };
+    }
+    static importDOM() {
+        return {
+            span: (domNode) => {
+                if (!domNode.hasAttribute('data-lexical-transclusion-file')) {
+                    return null;
+                }
+                return {
+                    conversion: $convertTransclusionElement,
+                    priority: 2,
+                };
+            },
+        };
+    }
+    updateDOM() {
+        return false;
+    }
+    isInline() {
+        return true;
+    }
+    getFile() {
+        return this.__file;
+    }
+    getBlockId() {
+        return this.__blockId;
+    }
+    getAlias() {
+        return this.__alias;
+    }
+    setAlias(alias) {
+        const writable = this.getWritable();
+        writable.__alias = alias;
+    }
+    getEmptyAlias() {
+        return this.__emptyAlias;
+    }
+    setEmptyAlias(emptyAlias) {
+        const writable = this.getWritable();
+        writable.__emptyAlias = emptyAlias;
+    }
+    decorate() {
+        return createElement(Suspense, { fallback: renderTransclusionLoading() }, createElement(TransclusionComponent, {
+            file: this.__file,
+            blockId: this.__blockId,
+            nodeKey: this.__key,
+        }));
+    }
+}
+function renderPlaceholderText(file, blockId) {
+    return `![[${file}#^${blockId}]]`;
+}
+export function $createTransclusionNode(file, blockId, alias = null, emptyAlias = false) {
+    return $applyNodeReplacement(new TransclusionNode(file, blockId, alias, emptyAlias));
+}
+export function $isTransclusionNode(node) {
+    return node instanceof TransclusionNode;
+}

package/dist/app/editor/nodes/index.d.ts

@@ -10,6 +10,8 @@ export { EquationNode, $createEquationNode, $isEquationNode } from './EquationNo
 export type { SerializedEquationNode } from './EquationNode.js';
 export { MermaidNode, $createMermaidNode, $isMermaidNode } from './MermaidNode.js';
 export type { SerializedMermaidNode } from './MermaidNode.js';
+export { TransclusionNode, $createTransclusionNode, $isTransclusionNode } from './TransclusionNode.js';
+export type { SerializedTransclusionNode } from './TransclusionNode.js';
 export { C4Node, $createC4Node, $isC4Node } from './C4Node.js';
 export type { SerializedC4Node } from './C4Node.js';
 export { FrontmatterNode, $createFrontmatterNode, $isFrontmatterNode } from './FrontmatterNode.js';
@@ -22,6 +24,8 @@ export { CustomListItemNode, $createCustomListItemNode, $isCustomListItemNode }
 export type { SerializedCustomListItemNode } from './CustomListItemNode.js';
 export { FootnoteNode, $createFootnoteNode, $isFootnoteNode } from './FootnoteNode.js';
 export type { SerializedFootnoteNode } from './FootnoteNode.js';
+export { BlockAnchorNode, $createBlockAnchorNode, $isBlockAnchorNode } from './BlockAnchorNode.js';
+export type { SerializedBlockAnchorNode } from './BlockAnchorNode.js';
 export { DefinitionListNode, DefinitionTermNode, DefinitionDescriptionNode, $createDefinitionListNode, $createDefinitionTermNode, $createDefinitionDescriptionNode, $isDefinitionListNode, $isDefinitionTermNode, $isDefinitionDescriptionNode, } from './DefinitionListNode.js';
 export type { SerializedDefinitionListNode, SerializedDefinitionTermNode, SerializedDefinitionDescriptionNode, } from './DefinitionListNode.js';
 export { HtmlNode, $createHtmlNode, $isHtmlNode } from './HtmlNode.js';

package/dist/app/editor/nodes/index.js

@@ -6,12 +6,14 @@ export { ImageNode, $createImageNode, $isImageNode } from './ImageNode.js';
 export { HorizontalRuleNode, $createHorizontalRuleNode, $isHorizontalRuleNode } from './HorizontalRuleNode.js';
 export { EquationNode, $createEquationNode, $isEquationNode } from './EquationNode.js';
 export { MermaidNode, $createMermaidNode, $isMermaidNode } from './MermaidNode.js';
+export { TransclusionNode, $createTransclusionNode, $isTransclusionNode } from './TransclusionNode.js';
 export { C4Node, $createC4Node, $isC4Node } from './C4Node.js';
 export { FrontmatterNode, $createFrontmatterNode, $isFrontmatterNode } from './FrontmatterNode.js';
 export { CustomLinkNode, $createCustomLinkNode, $isCustomLinkNode } from './CustomLinkNode.js';
 export { CustomListNode, $createCustomListNode, $isCustomListNode } from './CustomListNode.js';
 export { CustomListItemNode, $createCustomListItemNode, $isCustomListItemNode } from './CustomListItemNode.js';
 export { FootnoteNode, $createFootnoteNode, $isFootnoteNode } from './FootnoteNode.js';
+export { BlockAnchorNode, $createBlockAnchorNode, $isBlockAnchorNode } from './BlockAnchorNode.js';
 export { DefinitionListNode, DefinitionTermNode, DefinitionDescriptionNode, $createDefinitionListNode, $createDefinitionTermNode, $createDefinitionDescriptionNode, $isDefinitionListNode, $isDefinitionTermNode, $isDefinitionDescriptionNode, } from './DefinitionListNode.js';
 export { HtmlNode, $createHtmlNode, $isHtmlNode } from './HtmlNode.js';
 export { ListItemParagraphBreakNode, $createListItemParagraphBreakNode, $isListItemParagraphBreakNode, } from './ListItemParagraphBreakNode.js';

package/dist/app/editor/nodes/transclusion-loading.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The transient "waiting" visual for block transclusion (#119) — split into
+ * its own, deliberately dependency-light module.
+ *
+ * `TransclusionNode.tsx` needs this for its `Suspense` fallback, and
+ * `TransclusionNode.tsx` is part of the `./nodes` subpath's *static* (eagerly
+ * evaluated) import graph — unlike `TransclusionComponent.tsx`, which is only
+ * ever reached through a dynamic `import()`. `transclusion-render.tsx`
+ * imports `parseMarkdown` (and, transitively, the whole micromark/mdast-util
+ * pipeline) to do its real work; if `TransclusionNode.tsx` imported this
+ * function from that module instead, `./nodes` would statically pull in the
+ * entire markdown pipeline it does not otherwise need — exactly the weight
+ * `src/__tests__/nodes-subpath.test.ts` exists to keep out. Keeping this one
+ * function here, with no import of `transclusion-render.tsx`, is what keeps
+ * that boundary intact.
+ */
+import { type ReactNode } from 'react';
+/**
+ * The transient "resolver call in flight" state — not part of
+ * `TransclusionRenderState` (`transclusion-render.tsx`) because it is a UI
+ * concern of the lazily-mounted `TransclusionComponent`, not an outcome the
+ * pure resolver ever produces (it only returns once fully settled). Also
+ * used as the `Suspense` fallback in `TransclusionNode.decorate()` while the
+ * component's own code chunk is still loading, so both "waiting" cases look
+ * the same.
+ */
+export declare function renderTransclusionLoading(): ReactNode;

package/dist/app/editor/nodes/transclusion-loading.js

@@ -0,0 +1,29 @@
+/**
+ * The transient "waiting" visual for block transclusion (#119) — split into
+ * its own, deliberately dependency-light module.
+ *
+ * `TransclusionNode.tsx` needs this for its `Suspense` fallback, and
+ * `TransclusionNode.tsx` is part of the `./nodes` subpath's *static* (eagerly
+ * evaluated) import graph — unlike `TransclusionComponent.tsx`, which is only
+ * ever reached through a dynamic `import()`. `transclusion-render.tsx`
+ * imports `parseMarkdown` (and, transitively, the whole micromark/mdast-util
+ * pipeline) to do its real work; if `TransclusionNode.tsx` imported this
+ * function from that module instead, `./nodes` would statically pull in the
+ * entire markdown pipeline it does not otherwise need — exactly the weight
+ * `src/__tests__/nodes-subpath.test.ts` exists to keep out. Keeping this one
+ * function here, with no import of `transclusion-render.tsx`, is what keeps
+ * that boundary intact.
+ */
+import { createElement } from 'react';
+/**
+ * The transient "resolver call in flight" state — not part of
+ * `TransclusionRenderState` (`transclusion-render.tsx`) because it is a UI
+ * concern of the lazily-mounted `TransclusionComponent`, not an outcome the
+ * pure resolver ever produces (it only returns once fully settled). Also
+ * used as the `Suspense` fallback in `TransclusionNode.decorate()` while the
+ * component's own code chunk is still loading, so both "waiting" cases look
+ * the same.
+ */
+export function renderTransclusionLoading() {
+    return createElement('span', { className: 'editor-transclusion-loading' }, 'Loading…');
+}

package/dist/app/editor/nodes/transclusion-render.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Pure, host-resolver-driven resolution and rendering for block transclusion
+ * (`![[file#^id]]`, #119). Split out from `TransclusionComponent.tsx` so the
+ * cycle/depth guard and the mdast->JSX mini renderer are unit-testable
+ * without mounting Lexical or React.
+ *
+ * Not a second `LexicalComposer`: transclusion is render-only (bidirectional
+ * editing of transcluded content is explicitly out of scope), so resolved
+ * block content is parsed once with the existing `parseMarkdown` and walked
+ * into plain React elements by a small dedicated renderer here, rather than
+ * mounting a second editable surface.
+ */
+import { type ReactNode } from 'react';
+/** A host-injected resolver, matching `EditorHostServices.resolveTransclusion`. */
+export type TransclusionResolver = (file: string, blockId: string) => Promise<string | null>;
+/**
+ * Nested transclusion depth bound (FR-011). A Plan-stage numeric choice, not
+ * derived from anything structural — deep enough that legitimate nesting
+ * (a summary block quoting a handful of sub-tasks, one level each) never
+ * hits it, shallow enough that a missed-cycle edge case still terminates
+ * fast. Checked *before* the resolver call at each level, so a document
+ * that would exceed it never spends host I/O on content that gets discarded.
+ */
+export declare const MAX_TRANSCLUSION_DEPTH = 8;
+export type TransclusionRenderState = {
+    kind: 'resolved';
+    content: ReactNode;
+} | {
+    kind: 'unresolved';
+} | {
+    kind: 'circular';
+} | {
+    kind: 'depth-exceeded';
+};
+/**
+ * Resolve a `file#^blockId` reference to rendered content, guarding against
+ * cycles and unbounded nesting.
+ *
+ * `visitedPath` is the chain of `file#^blockId` keys already open on *this*
+ * branch of the resolution tree (ancestors, not a single global "already
+ * transcluded anywhere" set) — the same block transcluded from two unrelated
+ * sites in the same document must not falsely trip the cycle guard for the
+ * second site.
+ */
+export declare function resolveAndRenderTransclusion(file: string, blockId: string, resolver: TransclusionResolver | undefined, visitedPath?: readonly string[]): Promise<TransclusionRenderState>;
+/** Render a {@link TransclusionRenderState} to a React node, for both the
+ * top-level `TransclusionComponent` and a nested `wikiEmbed` inside
+ * resolved content — the two share the same visual vocabulary. */
+export declare function renderTransclusionState(state: TransclusionRenderState): ReactNode;