@liminis/editor 0.4.1 → 0.6.0

package/README.md

@@ -16,7 +16,9 @@ travelled with the code, are recorded in [`docs/provenance.md`](./docs/provenanc
 - **`<Editor>`** — a WYSIWYG markdown editor. Tables, task lists (including in
   ordered lists), footnotes, definition lists, callouts, toggles, code blocks
   with Prism highlighting, images, LaTeX equations, Mermaid diagrams, C4
-  diagrams, YAML frontmatter, and wiki-links.
+  diagrams, YAML frontmatter, and wiki-links — including block-scoped links
+  and live transclusion (`[[file#^id]]` / `![[file#^id]]`), with a `^ULID`
+  block anchor at its definition site rendering as a compact, copyable badge.
 - **A markdown pipeline** — `parseMarkdown` / `stringifyMarkdown` and the mdast
   ↔ Lexical mappers, usable with no editor mounted.
 - **An annotation mechanism** — range-anchored markers over document text that
@@ -442,6 +444,69 @@ read-only editor still shows the floating toolbar with the configured
 affordance (formatting controls are omitted there, since they would be
 inert).
 
+## Block-scoped links and transclusion
+
+Wiki-links (`[[target]]` / `[[target|alias]]`) extend to an optional
+Obsidian-style block-id fragment: `[[file#^id]]` links to one specific block
+inside a file rather than the file as a whole, and `![[file#^id]]`
+**transcludes** it — renders that block's actual, current content inline at
+the reference site. This is a live view, not a copy: if the source block's
+text changes, every transclusion of it reflects that on next render.
+
+Resolving `file#^id` to content is host work, through one optional injected
+function:
+
+```tsx
+<EditorHostProvider services={{ resolveTransclusion: async (file, blockId) => {
+  // look up the block by id across your whole corpus — ids are workspace-global,
+  // not scoped to one file (matching Liminis's own `^ULID` convention)
+  return lookupBlockContent(file, blockId) // string | null
+} }}>
+  <Editor initialContent={markdown} onChange={setMarkdown} />
+</EditorHostProvider>
+```
+
+With no resolver injected, or one that returns `null`, `![[file#^id]]`
+renders a clearly marked "unresolved" placeholder rather than throwing —
+consistent with every other host service in this package. A transclusion
+cycle (block A transcludes B, which transcludes A — directly or through a
+longer chain) is detected and rendered as a "circular transclusion"
+indicator rather than hanging; nested transclusion is supported to a bounded
+depth, beyond which it degrades to a clear fallback rather than a crash.
+
+**If you are maintaining this package: do not remove the cycle/depth guard**
+in `src/app/editor/nodes/transclusion-render.tsx`, and **do not loosen the
+embed-marker detection** in `src/markdown/parse.ts` to a bare `!` lookahead
+— see `docs/markdown-pipeline.md`'s "Block-scoped links and transclusion"
+section for what each guards against and the regression fixture that pins
+it down.
+
+`[[file#^id]]` (link-only, no `!`) instead requests navigation to that
+specific block when the host supports it, and degrades no worse than
+today's file-only wiki-link navigation when it doesn't — no extra host
+wiring required beyond the resolver above, which also backs its
+"does this block exist" styling.
+
+## Block anchor badges
+
+A block anchor — a bare `^ULID` at the point it was defined, most commonly
+trailing an action-item checkbox (`- [ ] ... ^01M00VDX0S4JHMDNA7F776Y8R8`) —
+renders as a compact badge instead of the raw 26-character id sitting inline
+in the prose. Hover the badge to see the full id, or click it to copy the
+exact id to the clipboard — the same id a `[[file#^id]]` reference above
+needs. The underlying markdown, and the id itself, are never changed by
+this: it is a display concern only, and the badge edits and deletes like
+ordinary text.
+
+Detection accepts every id form `[[file#^id]]` and its resolver accept —
+ULIDs, raw-decimal snowflake ids, NanoID-style ids, mixed-case base62, UUIDs,
+short alphanumeric ids — so the badge and the resolver agree on what counts
+as an anchor. A caret in ordinary prose (`x^2`, `2^10`, `mc^2`, `a ^ b`) is
+never mistaken for one, by the same position rule the resolver itself uses:
+the caret must start a token, and the id must run to end of line — see
+`docs/markdown-pipeline.md`'s "Block anchor badges" section for the full
+rationale.
+
 ## Documentation
 
 - [`docs/editor-api.md`](./docs/editor-api.md) — the `<Editor>` props and the

package/dist/app/editor/LinkClickPlugin.js

@@ -43,7 +43,11 @@ export function LinkClickPlugin({ editable = true }) {
                 // URL is stored in data-href (not href) to prevent webview interception
                 const url = linkElement.getAttribute('data-href');
                 if (url) {
-                    openLink(url);
+                    // Block-scoped link (#119): additive, so a host that hasn't
+                    // implemented block-aware navigation still gets `url` and opens
+                    // the file exactly as before (FR-004).
+                    const blockId = linkElement.getAttribute('data-block-id') ?? undefined;
+                    openLink(url, blockId);
                 }
             }
             // In editable mode without modifier: No action needed - since there's no href,

package/dist/app/editor/WikiLinkExistencePlugin.d.ts

@@ -2,14 +2,24 @@
  * WikiLinkExistencePlugin - Checks wiki-links and marks broken ones
  *
  * This plugin scans for wiki-links in the editor DOM and checks if their
- * target files exist anywhere in the workspace. Links to non-existent files
- * get a CSS class applied to render them in red.
+ * target files (or, for a block-scoped link, target block — #119) exist
+ * anywhere in the workspace. Links that don't resolve get a CSS class
+ * applied to render them in red.
  *
- * Uses the host-supplied `resolveWikiLinks` service, which handles:
+ * A plain file-only link (`data-wiki-target`, no `data-block-id`) uses the
+ * host-supplied `resolveWikiLinks` service, which handles:
  * - Directory links (e.g., "entities/teams/") → resolves to index.md or README.md
  * - File links with extension (e.g., "notes.md") → checks directly
  * - File links without extension (e.g., "notes") → tries .md, .mdc
  *
+ * A block-scoped link (`data-block-id` present, `[[file#^id]]`) instead
+ * checks via `resolveTransclusion` — the same host resolver transclusion
+ * uses for content, per the Plan's "one resolver, two consumers" decision.
+ * `resolveTransclusion` returns content, not a boolean, but existence is
+ * exactly "did this resolve to something non-null" (FR-004's edge case: an
+ * id that doesn't exist is unresolved, not an error, with the same styling
+ * an unresolved file-only wikilink already gets).
+ *
  * The check is performed:
  * - When the document is loaded
  * - When the document content changes (debounced)

package/dist/app/editor/WikiLinkExistencePlugin.js

@@ -5,21 +5,31 @@ import { useEditorHost } from '../../host/context.js';
  * WikiLinkExistencePlugin - Checks wiki-links and marks broken ones
  *
  * This plugin scans for wiki-links in the editor DOM and checks if their
- * target files exist anywhere in the workspace. Links to non-existent files
- * get a CSS class applied to render them in red.
+ * target files (or, for a block-scoped link, target block — #119) exist
+ * anywhere in the workspace. Links that don't resolve get a CSS class
+ * applied to render them in red.
  *
- * Uses the host-supplied `resolveWikiLinks` service, which handles:
+ * A plain file-only link (`data-wiki-target`, no `data-block-id`) uses the
+ * host-supplied `resolveWikiLinks` service, which handles:
  * - Directory links (e.g., "entities/teams/") → resolves to index.md or README.md
  * - File links with extension (e.g., "notes.md") → checks directly
  * - File links without extension (e.g., "notes") → tries .md, .mdc
  *
+ * A block-scoped link (`data-block-id` present, `[[file#^id]]`) instead
+ * checks via `resolveTransclusion` — the same host resolver transclusion
+ * uses for content, per the Plan's "one resolver, two consumers" decision.
+ * `resolveTransclusion` returns content, not a boolean, but existence is
+ * exactly "did this resolve to something non-null" (FR-004's edge case: an
+ * id that doesn't exist is unresolved, not an error, with the same styling
+ * an unresolved file-only wikilink already gets).
+ *
  * The check is performed:
  * - When the document is loaded
  * - When the document content changes (debounced)
  */
 export function WikiLinkExistencePlugin() {
     const [editor] = useLexicalComposerContext();
-    const { resolveWikiLinks } = useEditorHost();
+    const { resolveWikiLinks, resolveTransclusion } = useEditorHost();
     const checkTimeoutRef = useRef(null);
     const lastCheckedRef = useRef(new Set());
     useEffect(() => {
@@ -27,47 +37,48 @@ export function WikiLinkExistencePlugin() {
         if (!rootElement)
             return;
         const checkWikiLinks = async () => {
-            // Find all wiki-link elements
+            // Find all wiki-link elements, split into plain (file-only) and
+            // block-scoped (carrying data-block-id) groups.
             const wikiLinks = rootElement.querySelectorAll('a[data-wiki-link="true"]');
             if (wikiLinks.length === 0)
                 return;
-            // Collect unique target paths
-            const targets = new Set();
+            const plainTargets = new Set();
+            const blockRefs = new Set();
             wikiLinks.forEach((link) => {
                 const target = link.getAttribute('data-wiki-target');
-                if (target) {
-                    targets.add(target);
+                if (!target)
+                    return;
+                const blockId = link.getAttribute('data-block-id');
+                if (blockId) {
+                    blockRefs.add(`${target}#^${blockId}`);
+                }
+                else {
+                    plainTargets.add(target);
                 }
             });
-            if (targets.size === 0)
+            if (plainTargets.size === 0 && blockRefs.size === 0)
                 return;
-            // Skip if we've already checked these exact targets
-            const targetsArray = Array.from(targets);
-            const targetKey = targetsArray.sort().join('|');
-            if (lastCheckedRef.current.has(targetKey)) {
+            // Skip if we've already checked this exact combination of targets.
+            const checkKey = [...plainTargets, ...blockRefs].sort().join('|');
+            if (lastCheckedRef.current.has(checkKey)) {
                 return;
             }
-            // Use the host-supplied resolver which handles directory links, etc.
             try {
-                if (!resolveWikiLinks) {
-                    console.warn('[WikiLinkExistencePlugin] resolveWikiLinks host service not available');
-                    return;
-                }
-                // Resolve all wiki-link paths
-                const resolved = await resolveWikiLinks(targetsArray);
-                lastCheckedRef.current.add(targetKey);
+                const plainResolved = await resolvePlainTargets(plainTargets, resolveWikiLinks);
+                const blockResolved = await resolveBlockRefs(blockRefs, resolveTransclusion);
+                lastCheckedRef.current.add(checkKey);
                 // Update CSS classes on wiki-links
                 wikiLinks.forEach((link) => {
                     const target = link.getAttribute('data-wiki-target');
-                    if (target) {
-                        // Link exists if resolver returned a non-null path
-                        const exists = resolved[target] !== null;
-                        if (!exists) {
-                            link.classList.add('editor-link-broken');
-                        }
-                        else {
-                            link.classList.remove('editor-link-broken');
-                        }
+                    if (!target)
+                        return;
+                    const blockId = link.getAttribute('data-block-id');
+                    const exists = blockId ? blockResolved.get(`${target}#^${blockId}`) : plainResolved.get(target);
+                    if (exists === false) {
+                        link.classList.add('editor-link-broken');
+                    }
+                    else {
+                        link.classList.remove('editor-link-broken');
                     }
                 });
             }
@@ -99,6 +110,54 @@ export function WikiLinkExistencePlugin() {
                 clearTimeout(checkTimeoutRef.current);
             }
         };
-    }, [editor, resolveWikiLinks]);
+    }, [editor, resolveWikiLinks, resolveTransclusion]);
     return null;
 }
+/**
+ * Resolve plain (file-only) wiki-link targets via `resolveWikiLinks`.
+ * Absent the resolver (or no targets to check), every target is left
+ * unresolved-status `undefined` so the caller leaves its styling alone
+ * rather than marking it broken — consistent with the rest of this host
+ * seam's "service missing = feature unavailable, do nothing" convention.
+ */
+async function resolvePlainTargets(targets, resolveWikiLinks) {
+    const result = new Map();
+    if (targets.size === 0 || !resolveWikiLinks) {
+        return result;
+    }
+    const resolved = await resolveWikiLinks([...targets]);
+    for (const target of targets) {
+        // A missing key (as opposed to an explicit `null`) is treated as
+        // existing, matching this plugin's pre-#119 behavior — resolveWikiLinks
+        // isn't contractually required to return an entry for every target, and
+        // FR-014 requires plain wikilink resolution to be unaffected by this
+        // feature.
+        result.set(target, resolved[target] !== null);
+    }
+    return result;
+}
+/**
+ * Resolve block-scoped references (`file#^blockId` keys) via
+ * `resolveTransclusion`, one call per unique reference (the resolver's
+ * contract is single-reference, unlike `resolveWikiLinks`'s batch shape).
+ */
+async function resolveBlockRefs(refs, resolveTransclusion) {
+    const result = new Map();
+    if (refs.size === 0 || !resolveTransclusion) {
+        return result;
+    }
+    await Promise.all([...refs].map(async (ref) => {
+        const separatorIndex = ref.indexOf('#^');
+        const file = ref.slice(0, separatorIndex);
+        const blockId = ref.slice(separatorIndex + 2);
+        try {
+            const content = await resolveTransclusion(file, blockId);
+            result.set(ref, content !== null && content !== undefined);
+        }
+        catch {
+            // FR-009: a rejected resolver is treated as "unresolved", not an error.
+            result.set(ref, false);
+        }
+    }));
+    return result;
+}

package/dist/app/editor/editorNodes.js

@@ -3,7 +3,7 @@ import { CodeNode, CodeHighlightNode } from '@lexical/code';
 import { AutoLinkNode } from '@lexical/link';
 import { MarkNode } from '@lexical/mark';
 import { TableNode, TableRowNode, TableCellNode } from '@lexical/table';
-import { CalloutNode, ToggleContainerNode, ToggleTitleNode, ToggleContentNode, ImageNode, HorizontalRuleNode, EquationNode, MermaidNode, C4Node, FrontmatterNode, FootnoteNode, HtmlNode, ListItemParagraphBreakNode, CustomLinkNode, CustomListNode, DefinitionListNode, DefinitionTermNode, DefinitionDescriptionNode, CustomListItemNode, } from './nodes/index.js';
+import { CalloutNode, ToggleContainerNode, ToggleTitleNode, ToggleContentNode, ImageNode, HorizontalRuleNode, EquationNode, MermaidNode, C4Node, FrontmatterNode, FootnoteNode, BlockAnchorNode, HtmlNode, ListItemParagraphBreakNode, CustomLinkNode, CustomListNode, DefinitionListNode, DefinitionTermNode, DefinitionDescriptionNode, CustomListItemNode, TransclusionNode, } from './nodes/index.js';
 export const editorNodes = [
     HeadingNode,
     QuoteNode,
@@ -24,9 +24,11 @@ export const editorNodes = [
     HorizontalRuleNode,
     EquationNode,
     MermaidNode,
+    TransclusionNode,
     C4Node,
     FrontmatterNode,
     FootnoteNode,
+    BlockAnchorNode,
     DefinitionListNode,
     DefinitionTermNode,
     DefinitionDescriptionNode,

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

@@ -0,0 +1,5 @@
+interface BlockAnchorComponentProps {
+    id: string;
+}
+export default function BlockAnchorComponent({ id }: BlockAnchorComponentProps): JSX.Element;
+export {};

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

@@ -0,0 +1,37 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * BlockAnchorComponent — the compact badge a `BlockAnchorNode` decorates
+ * itself with (#122).
+ *
+ * User Story 2 (the id must remain readable and copyable) is satisfied with
+ * no new interaction pattern: the full id is exposed via the native `title`
+ * tooltip on hover, and a click copies it via `navigator.clipboard.writeText`
+ * with brief "Copied" feedback — mirroring `CodeBlockPlugin.tsx`'s existing
+ * copy-button pattern.
+ */
+import { useCallback, useState } from 'react';
+const COPIED_FEEDBACK_MS = 1500;
+export default function BlockAnchorComponent({ id }) {
+    const [copied, setCopied] = useState(false);
+    const handleClick = useCallback(() => {
+        void navigator.clipboard.writeText(id).then(() => {
+            setCopied(true);
+            setTimeout(() => setCopied(false), COPIED_FEEDBACK_MS);
+        });
+    }, [id]);
+    return (_jsx("button", { type: "button", className: "block-anchor-badge", title: id, "aria-label": `Block anchor ${id}. Click to copy.`, onClick: handleClick, contentEditable: false, style: {
+            display: 'inline-block',
+            cursor: 'pointer',
+            border: 'none',
+            font: 'inherit',
+            fontSize: '0.75em',
+            lineHeight: '1.4em',
+            padding: '0 0.4em',
+            marginLeft: '0.3em',
+            borderRadius: '1em',
+            backgroundColor: 'var(--liminis-editor-muted-100)',
+            color: 'var(--liminis-editor-muted-foreground)',
+            userSelect: 'none',
+            verticalAlign: 'middle',
+        }, children: copied ? 'Copied' : '^' }));
+}

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

@@ -0,0 +1,42 @@
+/**
+ * BlockAnchorNode — Inline decorator node for a block anchor (`^ULID`, #122).
+ * Renders a compact badge at the anchor's definition site instead of the raw
+ * `^ULID` text, and preserves the id for byte-identical round-trip back to
+ * markdown (`stringify.ts`'s `blockAnchor` handler emits `^` + this id, and
+ * nothing else).
+ */
+import { DecoratorNode, DOMConversionMap, DOMExportOutput, LexicalNode, NodeKey, SerializedLexicalNode, Spread, TextFormatType } from 'lexical';
+export type SerializedBlockAnchorNode = Spread<{
+    id: string;
+    format?: number;
+    strongMarker?: '_' | '*' | null;
+    emphasisMarker?: '_' | '*' | null;
+}, SerializedLexicalNode>;
+export declare class BlockAnchorNode extends DecoratorNode<JSX.Element> {
+    __id: string;
+    __format: number;
+    __strongMarker: '_' | '*' | null;
+    __emphasisMarker: '_' | '*' | null;
+    static getType(): string;
+    static clone(node: BlockAnchorNode): BlockAnchorNode;
+    constructor(id: string, key?: NodeKey);
+    getId(): string;
+    isInline(): boolean;
+    static importJSON(serializedNode: SerializedBlockAnchorNode): BlockAnchorNode;
+    exportJSON(): SerializedBlockAnchorNode;
+    getFormat(): number;
+    hasFormat(type: TextFormatType): boolean;
+    setFormat(format: number): this;
+    toggleFormat(type: TextFormatType): this;
+    getStrongMarker(): '_' | '*' | null;
+    setStrongMarker(marker: '_' | '*' | null): this;
+    getEmphasisMarker(): '_' | '*' | null;
+    setEmphasisMarker(marker: '_' | '*' | null): this;
+    createDOM(): HTMLElement;
+    updateDOM(): boolean;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    decorate(): JSX.Element;
+}
+export declare function $createBlockAnchorNode(id: string): BlockAnchorNode;
+export declare function $isBlockAnchorNode(node: LexicalNode | null | undefined): node is BlockAnchorNode;

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

@@ -0,0 +1,151 @@
+/**
+ * BlockAnchorNode — Inline decorator node for a block anchor (`^ULID`, #122).
+ * Renders a compact badge at the anchor's definition site instead of the raw
+ * `^ULID` text, and preserves the id for byte-identical round-trip back to
+ * markdown (`stringify.ts`'s `blockAnchor` handler emits `^` + this id, and
+ * nothing else).
+ */
+import { DecoratorNode, TEXT_TYPE_TO_FORMAT, toggleTextFormatType, $applyNodeReplacement, } from 'lexical';
+import { createElement } from 'react';
+import BlockAnchorComponent from './BlockAnchorComponent.js';
+// ---------------------------------------------------------------------------
+// DOM conversion (copy/paste support)
+// ---------------------------------------------------------------------------
+function $convertBlockAnchorElement(domNode) {
+    const id = domNode.getAttribute('data-block-anchor-id');
+    if (id) {
+        return { node: $createBlockAnchorNode(id) };
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// BlockAnchorNode
+// ---------------------------------------------------------------------------
+export class BlockAnchorNode extends DecoratorNode {
+    __id;
+    __format;
+    __strongMarker;
+    __emphasisMarker;
+    static getType() {
+        return 'blockAnchor';
+    }
+    static clone(node) {
+        const cloned = new BlockAnchorNode(node.__id, node.__key);
+        cloned.__format = node.__format;
+        cloned.__strongMarker = node.__strongMarker;
+        cloned.__emphasisMarker = node.__emphasisMarker;
+        return cloned;
+    }
+    constructor(id, key) {
+        super(key);
+        this.__id = id;
+        this.__format = 0;
+        this.__strongMarker = null;
+        this.__emphasisMarker = null;
+    }
+    getId() {
+        return this.__id;
+    }
+    // Inline node — sits within text flow
+    isInline() {
+        return true;
+    }
+    // Serialization
+    static importJSON(serializedNode) {
+        const node = $createBlockAnchorNode(serializedNode.id).setFormat(serializedNode.format ?? 0);
+        if (serializedNode.strongMarker) {
+            node.setStrongMarker(serializedNode.strongMarker);
+        }
+        if (serializedNode.emphasisMarker) {
+            node.setEmphasisMarker(serializedNode.emphasisMarker);
+        }
+        return node;
+    }
+    exportJSON() {
+        return {
+            type: 'blockAnchor',
+            version: 1,
+            id: this.__id,
+            format: this.__format,
+            strongMarker: this.__strongMarker,
+            emphasisMarker: this.__emphasisMarker,
+        };
+    }
+    // Mirrors TextNode's format bitmask API so this node can carry
+    // bold/italic/strikethrough state through the mdast<->Lexical round-trip.
+    getFormat() {
+        return this.getLatest().__format;
+    }
+    hasFormat(type) {
+        const formatFlag = TEXT_TYPE_TO_FORMAT[type];
+        return (this.getFormat() & formatFlag) !== 0;
+    }
+    setFormat(format) {
+        const self = this.getWritable();
+        self.__format = format;
+        return self;
+    }
+    toggleFormat(type) {
+        const format = this.getFormat();
+        const newFormat = toggleTextFormatType(format, type, null);
+        return this.setFormat(newFormat);
+    }
+    // Mirrors TextNode's --md-strong-marker/--md-emphasis-marker style hooks
+    // (via setMarkdownMarker/getMarkdownMarker in the mappers) so a bare
+    // anchor sitting inside `**bold**`/`_italic_` still round-trips its
+    // original underscore-vs-asterisk marker on export.
+    getStrongMarker() {
+        return this.getLatest().__strongMarker;
+    }
+    setStrongMarker(marker) {
+        const self = this.getWritable();
+        self.__strongMarker = marker;
+        return self;
+    }
+    getEmphasisMarker() {
+        return this.getLatest().__emphasisMarker;
+    }
+    setEmphasisMarker(marker) {
+        const self = this.getWritable();
+        self.__emphasisMarker = marker;
+        return self;
+    }
+    // DOM creation (editor view)
+    createDOM() {
+        const el = document.createElement('span');
+        el.className = 'block-anchor';
+        return el;
+    }
+    updateDOM() {
+        return false;
+    }
+    // DOM export (copy/paste)
+    exportDOM() {
+        const el = document.createElement('span');
+        el.setAttribute('data-block-anchor-id', this.__id);
+        el.textContent = `^${this.__id}`;
+        return { element: el };
+    }
+    static importDOM() {
+        return {
+            span: (domNode) => {
+                if (!domNode.hasAttribute('data-block-anchor-id'))
+                    return null;
+                return { conversion: $convertBlockAnchorElement, priority: 1 };
+            },
+        };
+    }
+    // Render as React element
+    decorate() {
+        return createElement(BlockAnchorComponent, { id: this.__id });
+    }
+}
+// ---------------------------------------------------------------------------
+// Factory + type guard
+// ---------------------------------------------------------------------------
+export function $createBlockAnchorNode(id) {
+    return $applyNodeReplacement(new BlockAnchorNode(id));
+}
+export function $isBlockAnchorNode(node) {
+    return node instanceof BlockAnchorNode;
+}

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

@@ -3,6 +3,10 @@ import { DOMConversionMap, EditorConfig, LexicalNode } from 'lexical';
 export type SerializedCustomLinkNode = SerializedLinkNode & {
     wikiAliasState?: 'empty';
     wikiLinkOrigin?: true;
+    /** Obsidian-style `#^blockId` fragment (#119), carried as a field separate
+     * from `url` so it never has to round-trip through the lossy `.md#`
+     * URL-string channel the plain anchor-link path uses. */
+    blockId?: string;
 };
 /**
  * CustomLinkNode - Extends Lexical's LinkNode to prevent VS Code webview link interception
@@ -24,6 +28,14 @@ export declare class CustomLinkNode extends LinkNode {
      * @internal
      */
     __wikiLinkOrigin: boolean;
+    /**
+     * 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: string | null;
     constructor(url: string, attributes?: {
         rel?: null | string;
         target?: null | string;
@@ -48,6 +60,8 @@ export declare class CustomLinkNode extends LinkNode {
     getWikiAliasState(): 'empty' | null;
     setWikiLinkOrigin(origin: boolean): void;
     getWikiLinkOrigin(): boolean;
+    setBlockId(blockId: string | null): void;
+    getBlockId(): string | null;
 }
 export declare function $createCustomLinkNode(url: string, attributes?: {
     rel?: null | string;