@liminis/editor 0.4.0 → 0.5.0

package/dist/host/defaults.js

@@ -43,5 +43,6 @@ export function resolveHostServices(services) {
         resolveWikiLinks: services?.resolveWikiLinks,
         onScrollToAnchor: services?.onScrollToAnchor,
         corrections: services?.corrections,
+        resolveTransclusion: services?.resolveTransclusion,
     };
 }

package/dist/host/messages.d.ts

@@ -19,7 +19,13 @@ export interface HostMessageApi {
     requestSettings: () => void;
     applyTextEdits: (edits: TextEdit[], reason: 'typing' | 'drag' | 'paste' | 'format') => void;
     writeAsset: (dataUri: string, suggestedName?: string) => void;
-    openLink: (url: string) => void;
+    /**
+     * `blockId` is additive (#119): a host that hasn't implemented block-aware
+     * navigation still receives `url` and opens the file exactly as before —
+     * FR-004's "degrades no worse than today's file-only wikilink navigation"
+     * falls out for free, with no host-side change required.
+     */
+    openLink: (url: string, blockId?: string) => void;
 }
 export declare function createHostMessageApi(bridge: EditorHostBridge, log: EditorLogger): HostMessageApi;
 /** Hook form of {@link createHostMessageApi}, bound to the ambient host services. */

package/dist/host/messages.js

@@ -31,9 +31,9 @@ export function createHostMessageApi(bridge, log) {
         writeAsset: (dataUri, suggestedName) => {
             postMessage({ type: 'WRITE_ASSET', dataUri, suggestedName });
         },
-        openLink: (url) => {
-            log.debug('openLink', { url });
-            postMessage({ type: 'OPEN_LINK', url });
+        openLink: (url, blockId) => {
+            log.debug('openLink', { url, blockId });
+            postMessage(blockId ? { type: 'OPEN_LINK', url, blockId } : { type: 'OPEN_LINK', url });
         },
     };
 }

package/dist/host/types.d.ts

@@ -70,6 +70,19 @@ export interface EditorHostServices {
     notifyError?: (message: string, description?: string) => void;
     /** Correction persistence + knowledge-graph services. */
     corrections?: CorrectionHostServices;
+    /**
+     * Resolve a workspace-global block reference (`file#^blockId`, #119) to
+     * that block's current markdown content. Backs both transclusion
+     * (`![[file#^id]]`) and existence-checking for block-scoped links
+     * (`[[file#^id]]`) — see `TransclusionComponent`/`WikiLinkExistencePlugin`.
+     *
+     * Returns `null` when the file or block id does not resolve (FR-009); the
+     * two are not distinguished here — a host that cares to tell them apart
+     * can encode that in its own lookup, but the contract only needs
+     * resolved-vs-not. Absent entirely (the default), transclusion renders an
+     * "unresolved" placeholder rather than throwing (FR-008).
+     */
+    resolveTransclusion?: (file: string, blockId: string) => Promise<string | null>;
 }
 /** `EditorHostServices` with every member resolved to a concrete implementation. */
-export type ResolvedEditorHostServices = Required<Pick<EditorHostServices, 'bridge' | 'logger' | 'notifyError'>> & Pick<EditorHostServices, 'resolveWikiLinks' | 'onScrollToAnchor' | 'corrections'>;
+export type ResolvedEditorHostServices = Required<Pick<EditorHostServices, 'bridge' | 'logger' | 'notifyError'>> & Pick<EditorHostServices, 'resolveWikiLinks' | 'onScrollToAnchor' | 'corrections' | 'resolveTransclusion'>;

package/dist/markdown/parse.js

@@ -14,6 +14,29 @@ import * as wikiLinkMdast from './vendor/mdast-util-wiki-link/index.js';
 // Wiki-link options: use | as the alias divider (Obsidian/Foam style)
 const wikiLinkOptions = { aliasDivider: '|' };
 const EMPTY_ALIAS_SENTINEL = '__EMPTY_ALIAS__';
+// Private-Use-Area sentinel marking a `!` that immediately precedes `[[`
+// (candidate transclusion/embed marker, #119). The next free codepoint after
+// `annotate-sentinels.ts`'s E000-E003 range and `stringify.ts`'s E004.
+//
+// Why substitute at all, rather than just checking "does the wikiLink node
+// have a `!` text sibling" after parsing: the micromark wiki-link tokenizer
+// is not vendored (see the vendor README) and only hooks the `[` character.
+// A literal `!` immediately before `[[` is claimed *first* by the default
+// image-label-start construct (hooked on `!`), and when that construct fails
+// to find a following `(url)`/`[ref]` — which it always will here, since
+// `[[target]]` is not image syntax — CommonMark's own bracket-resolution
+// falls the *entire* `![[target]]` span back to one literal text node,
+// without ever giving the wiki-link tokenizer a chance to fire on the inner
+// `[[`. A backslash-escaped `\!` sidesteps the image construct entirely (it
+// is consumed as a plain escaped character, not a construct trigger) and
+// `[[target]]` parses normally — confirmed empirically against
+// `micromark-extension-wiki-link@0.0.4`'s tokenizer. Swapping the raw `!`
+// for this sentinel *before* parsing reproduces that same escape-shaped
+// bypass without a real backslash reaching the output, so `[[target]]` parses
+// as a normal wikiLink node with the sentinel left on the preceding text
+// node — which `resolveWikiEmbeds` (below) then reads to decide embed vs.
+// plain link, and always strips before the tree leaves `parseMarkdown`.
+const EMBED_MARKER_SENTINEL = '\u{E005}';
 /**
  * Escape pipes inside wiki-links: [[target|alias]] → [[target\|alias]]
  * This prevents GFM table parsing from splitting wiki-links at the pipe.
@@ -57,6 +80,200 @@ function escapeWikiLinkPipes(text) {
     result += text.slice(cursor);
     return { text: result, replacements };
 }
+/**
+ * Swap a `!` for {@link EMBED_MARKER_SENTINEL}, but only when it is
+ * immediately followed by a *complete, single-line* `[[...]]` span with no
+ * internal `]` — i.e. exactly the shape the wiki-link tokenizer's own
+ * `consumeTarget`/`consumeAlias` states require to succeed (a bare `]` not
+ * immediately followed by a second `]` aborts the whole construct; so does a
+ * line ending). One codepoint swapped for one codepoint, so — unlike
+ * `escapeWikiLinkPipes`/`normalizeWikiLinks` above — this never shifts any
+ * subsequent offset and needs no `Replacement` tracking of its own.
+ *
+ * The "complete span" requirement is load-bearing, not a nicety: an `!`
+ * immediately before `[` is *also* how a real image's alt text starting with
+ * a literal `[` looks at the character level (`![[leading] bracket](x.png)`
+ * is `![` + alt text `[leading] bracket` + `](x.png)`, i.e. contains the raw
+ * substring `![[`). Matching on `!(?=\[\[)` alone — with no lookahead past
+ * the second `[` — can't tell that case apart from a genuine embed candidate
+ * and would substitute inside it, preventing the image construct (which
+ * needs the literal `!`) from ever being tried and corrupting the image
+ * (caught by the `903-image-alt-leading-bracket` regression fixture).
+ * Requiring the run between `[[` and `]]` to contain no internal `]` rules
+ * that case out: `[leading] bracket](x.png)` hits an un-doubled `]` right
+ * after `leading`, so the pattern below never matches there, `!` survives
+ * untouched, and the image construct parses exactly as before this feature
+ * existed (FR-014).
+ *
+ * A `!` that is already backslash-escaped (`\![[...]]`) is left alone: that
+ * spelling already means "literal `!`, then a normal wiki-link" with no
+ * substitution needed (CommonMark consumes the escape before the image
+ * construct ever sees the `!`) — see FR-013's requirement that an author can
+ * explicitly opt out of transclusion for a `#^id`-bearing target.
+ *
+ * "Escaped" here means CommonMark backslash-*parity*, not merely "a `\`
+ * immediately precedes the `!`": an even run of backslashes (`\\!`, `\\\\!`,
+ * ...) pairs off into literal backslashes and does not escape the `!`, while
+ * an odd run (`\!`, `\\\!`, ...) does. A naive one-character lookbehind gets
+ * every even run ≥ 2 wrong (treats the `!` as escaped when it isn't), so the
+ * preceding backslash run is captured and its length checked explicitly.
+ *
+ * A match inside a fenced code block or inline code span must be skipped
+ * entirely, not just left un-embedded: inside those constructs the wiki-link
+ * tokenizer never runs at all (code content is verbatim), so a substituted
+ * sentinel would never get a `wikiLink` node to attach to and restore from —
+ * `resolveWikiEmbeds`'s leftover-sentinel sweep only walks `text` nodes, not
+ * a `code`/`inlineCode` node's `value`, so the sentinel would otherwise leak
+ * through as a literal, invisible Private-Use-Area character in the final
+ * output instead of being restored to `!`. {@link findProtectedRanges}
+ * identifies those spans so the substitution can leave them untouched.
+ */
+function substituteEmbedMarker(text) {
+    const protectedRanges = findProtectedRanges(text);
+    return text.replace(/(\\*)!(\[\[[^\]\n]*\]\])/g, (match, backslashes, bracketed, offset) => {
+        if (protectedRanges.some((r) => offset >= r.start && offset < r.end)) {
+            return match;
+        }
+        return backslashes.length % 2 === 1
+            ? `${backslashes}!${bracketed}`
+            : `${backslashes}${EMBED_MARKER_SENTINEL}${bracketed}`;
+    });
+}
+/**
+ * Finds fenced code blocks and inline code spans in raw markdown text, so
+ * {@link substituteEmbedMarker} can avoid mutating their (verbatim) content.
+ * Deliberately approximate rather than a full CommonMark tokenizer — good
+ * enough to protect the common cases (``` fences, `inline` spans) without
+ * duplicating the real tokenizer this file elsewhere avoids vendoring.
+ */
+function findProtectedRanges(text) {
+    const ranges = [];
+    // Fenced code blocks: a line of (up to 3 leading spaces then) 3+ backticks
+    // or tildes opens one; it's closed by a later line of at least as many of
+    // the same character (optionally indented, nothing else on the line).
+    const fenceOpenRe = /^ {0,3}(`{3,}|~{3,})/;
+    let fenceChar = null;
+    let fenceLen = 0;
+    let fenceStart = -1;
+    let cursor = 0;
+    for (const line of text.split('\n')) {
+        const lineEnd = cursor + line.length;
+        if (fenceChar === null) {
+            const m = fenceOpenRe.exec(line);
+            if (m) {
+                fenceChar = m[1][0];
+                fenceLen = m[1].length;
+                fenceStart = cursor;
+            }
+        }
+        else {
+            const closeRe = new RegExp(`^ {0,3}\\${fenceChar}{${fenceLen},}\\s*$`);
+            if (closeRe.test(line)) {
+                ranges.push({ start: fenceStart, end: lineEnd });
+                fenceChar = null;
+                fenceLen = 0;
+                fenceStart = -1;
+            }
+        }
+        cursor = lineEnd + 1; // +1 for the '\n' consumed by split
+    }
+    if (fenceChar !== null) {
+        ranges.push({ start: fenceStart, end: text.length });
+    }
+    // Inline code spans, outside any fenced block already found: a backtick
+    // run opens a span, closed by the next run of the *same* length (a run of
+    // a different length is span content, not a delimiter) — CommonMark's own
+    // code-span rule. An opening run with no matching close is not a code
+    // span at all (its backticks are literal), so it protects nothing.
+    const isInFence = (pos) => ranges.some((r) => pos >= r.start && pos < r.end);
+    const backtickRun = /`+/g;
+    let pendingOpen = null;
+    let match;
+    while ((match = backtickRun.exec(text)) !== null) {
+        if (isInFence(match.index))
+            continue;
+        const len = match[0].length;
+        if (pendingOpen === null) {
+            pendingOpen = { start: match.index, len };
+        }
+        else if (len === pendingOpen.len) {
+            ranges.push({ start: pendingOpen.start, end: match.index + len });
+            pendingOpen = null;
+        }
+    }
+    return ranges;
+}
+/**
+ * Retype a `wikiLink` node to `wikiEmbed` when it was immediately preceded by
+ * an {@link EMBED_MARKER_SENTINEL} *and* carries a `data.blockId` (#119).
+ *
+ * Two outcomes when a sentinel-terminated text node precedes a `wikiLink`:
+ *  - **Has `blockId`**: this is a genuine transclusion. Strip the sentinel
+ *    off the preceding text (dropping the text node entirely if it was the
+ *    sentinel alone) and retype the node to `wikiEmbed`, carrying the same
+ *    `value`/`data`.
+ *  - **No `blockId`**: FR-013 — `![[file]]` with no anchor is not a supported
+ *    construct in v1. Restore the literal `!` in the preceding text and leave
+ *    the node as an ordinary `wikiLink`, so it degrades to ordinary
+ *    file-only link treatment (no embedding), matching what plain
+ *    `\![[file]]` already does without any sentinel involved.
+ *
+ * A final sweep restores any sentinel left over from a `!` that didn't end up
+ * immediately before a completed `wikiLink` (e.g. the target never closed) —
+ * this sentinel must never leak into rendered/round-tripped content.
+ */
+function resolveWikiEmbeds(root) {
+    function walkChildren(children) {
+        const result = [];
+        for (const rawChild of children) {
+            const child = walk(rawChild);
+            if (child?.type === 'wikiLink' && result.length > 0) {
+                const prevIndex = result.length - 1;
+                const prev = result[prevIndex];
+                if (prev.type === 'text' && typeof prev.value === 'string' && prev.value.endsWith(EMBED_MARKER_SENTINEL)) {
+                    const blockId = child.data?.blockId;
+                    const hasBlockId = typeof blockId === 'string' && blockId.length > 0;
+                    const strippedValue = prev.value.slice(0, -1);
+                    if (hasBlockId) {
+                        if (strippedValue.length === 0) {
+                            result.pop();
+                        }
+                        else {
+                            result[prevIndex] = { ...prev, value: strippedValue };
+                        }
+                        result.push({ ...child, type: 'wikiEmbed' });
+                        continue;
+                    }
+                    result[prevIndex] = { ...prev, value: strippedValue + '!' };
+                    result.push(child);
+                    continue;
+                }
+            }
+            result.push(child);
+        }
+        return result;
+    }
+    function walk(node) {
+        if (!node || typeof node !== 'object')
+            return node;
+        if (node.children && Array.isArray(node.children)) {
+            return { ...node, children: walkChildren(node.children) };
+        }
+        return node;
+    }
+    function restoreLeftoverSentinels(node) {
+        if (!node || typeof node !== 'object')
+            return node;
+        if (node.type === 'text' && typeof node.value === 'string' && node.value.includes(EMBED_MARKER_SENTINEL)) {
+            return { ...node, value: node.value.split(EMBED_MARKER_SENTINEL).join('!') };
+        }
+        if (node.children && Array.isArray(node.children)) {
+            return { ...node, children: node.children.map(restoreLeftoverSentinels) };
+        }
+        return node;
+    }
+    return restoreLeftoverSentinels(walk(root));
+}
 /**
  * Combine two sets of replacements from sequential preprocessing steps.
  * The second set of replacements refers to positions in text AFTER the first set was applied.
@@ -434,8 +651,12 @@ function addCheckboxesToOrderedLists(root) {
 }
 export function parseMarkdown(text, _options = {}) {
     // Pre-process to handle edge cases
+    // Step 0: Swap a `!` immediately before `[[` for a sentinel so the
+    // wiki-link tokenizer gets a chance to fire (#119; see EMBED_MARKER_SENTINEL).
+    // Same-length, so it needs no offset-replacement tracking of its own.
+    const embedMarked = substituteEmbedMarker(text);
     // Step 1: Escape pipes inside wiki-links to protect from GFM table parsing
-    const { text: pipesEscaped, replacements: pipeReplacements } = escapeWikiLinkPipes(text);
+    const { text: pipesEscaped, replacements: pipeReplacements } = escapeWikiLinkPipes(embedMarked);
     // Step 2: Normalize empty aliases (existing logic)
     const { text: normalizedText, replacements: aliasReplacements } = normalizeWikiLinks(pipesEscaped);
     // Combine replacements for offset mapping (pipeReplacements first, then adjust aliasReplacements)
@@ -458,6 +679,9 @@ export function parseMarkdown(text, _options = {}) {
     root = stripEscapedPipeFromWikiLinks(root);
     // Post-process: mark wiki-links that had empty aliases in the source
     root = markEmptyAliasWikiLinks(root);
+    // Post-process: retype a sentinel-preceded wiki-link with a blockId to a
+    // transclusion/embed node, and restore the literal `!` everywhere else (#119)
+    root = resolveWikiEmbeds(root);
     // Post-process: annotate emphasis/strong marker characters from original source
     root = annotateEmphasisMarkers(root, text, replacements);
     // Post-process: split out backslash-escaped punctuation so its escape can

package/dist/markdown/stringify.js

@@ -214,7 +214,7 @@ function normalizeWikiLinkNodes(node) {
     if (!node || typeof node !== 'object') {
         return node;
     }
-    if (node.type === 'wikiLink') {
+    if (node.type === 'wikiLink' || node.type === 'wikiEmbed') {
         const data = node.data && typeof node.data === 'object' ? { ...node.data } : {};
         return {
             ...node,
@@ -289,6 +289,27 @@ function widenTableDelimiterDashes(markdown) {
     }
     return lines.join('\n');
 }
+/**
+ * Format the `[[target...]]` (or `[[target...|alias]]`) body shared by the
+ * `wikiLink` and `wikiEmbed` handlers below — everything between the double
+ * brackets, minus the brackets themselves and (for `wikiEmbed`) the leading
+ * `!`. `data.blockId`, when present, is re-appended as `#^blockId` (#119),
+ * mirroring the vendored `mdast-util-wiki-link/to-markdown.ts` — duplicated
+ * rather than shared because this handler otherwise diverges from the
+ * vendored one already (see the module comment above `stringifyMarkdown`).
+ */
+function formatWikiLinkBody(node) {
+    const value = node.value ?? '';
+    const data = node.data && typeof node.data === 'object' ? node.data : {};
+    const blockId = typeof data.blockId === 'string' && data.blockId.length > 0 ? data.blockId : null;
+    const target = blockId ? `${value}#^${blockId}` : value;
+    const alias = typeof data.alias === 'string' ? data.alias : '';
+    const hasAlias = alias.length > 0 && alias !== value;
+    const emptyAlias = data._emptyAlias === true;
+    const divider = wikiLinkOptions.aliasDivider;
+    const aliasPart = hasAlias ? `${divider}${alias}` : emptyAlias ? divider : '';
+    return `${target}${aliasPart}`;
+}
 export function stringifyMarkdown(root, options = {}) {
     // Pre-process: add checkbox text to ordered list items (GFM only outputs for unordered)
     let processedRoot = addCheckboxTextToOrderedLists(root);
@@ -327,15 +348,14 @@ export function stringifyMarkdown(root, options = {}) {
                         return marker + content + marker;
                     },
                     escapedChar: (node) => `${FORCE_ESCAPE_PLACEHOLDER}${node.value}${FORCE_ESCAPE_PLACEHOLDER}`,
-                    wikiLink: (node) => {
-                        const value = node.value ?? '';
-                        const data = node.data && typeof node.data === 'object' ? node.data : {};
-                        const alias = typeof data.alias === 'string' ? data.alias : '';
-                        const hasAlias = alias.length > 0 && alias !== value;
-                        const emptyAlias = data._emptyAlias === true;
-                        const aliasPart = hasAlias ? `${wikiLinkOptions.aliasDivider}${alias}` : emptyAlias ? `${wikiLinkOptions.aliasDivider}` : '';
-                        return `[[${value}${aliasPart}]]`;
-                    },
+                    wikiLink: (node) => `[[${formatWikiLinkBody(node)}]]`,
+                    // Transclusion/embed (#119): the `!`-prefixed form of a block-scoped
+                    // wiki-link. `formatWikiLinkBody` requires `data.blockId` be present
+                    // to have been produced by `resolveWikiEmbeds` in parse.ts in the
+                    // first place (FR-013 never lets a blockId-less node reach this
+                    // type), but nothing here depends on that — this handler just emits
+                    // whatever the node carries, `!` and all.
+                    wikiEmbed: (node) => `![[${formatWikiLinkBody(node)}]]`,
                     // Override mdast-util-definition-list's default (`:` + 3 spaces, i.e. a
                     // 4-char marker matching a 4-space continuation indent) with the
                     // single-space `: ` marker convention used throughout PHP Markdown

package/dist/markdown/vendor/mdast-util-wiki-link/README.md

@@ -37,5 +37,22 @@ upstream pulled in.
 
 3. **Types.** The `any`-typed option and node shapes are given real types.
 
+4. **`#^blockId` fragment splitting (#119).** `from-markdown.ts` splits a
+   trailing `#^blockId` fragment off the target into `data.blockId` before
+   `pageResolver` runs, so `data.permalink`/`data.exists` are computed from
+   the file target alone; `to-markdown.ts` re-appends it on the way back out.
+   An ordinary heading anchor (`[[file#heading]]`, no caret) is untouched —
+   only the caret-prefixed Obsidian block-reference form matches. This is
+   deliberately scoped to the `wikiLink` node shape only: the `!`-prefixed
+   transclusion/embed form (`![[file#^id]]`) is *not* handled here — that
+   detection lives in `src/markdown/parse.ts`/`stringify.ts` (a same-length
+   sentinel substitution around the unvendored micromark tokenizer, since a
+   leading `!` before `[[` today makes the *whole* `![[...]]` span fall back
+   to inert text — see the tokenizer's `text: {33: ...}` image-label
+   precedence). A raw `./markdown`-subpath consumer therefore gets
+   `data.blockId` for free but not embed/transclusion detection; this
+   asymmetry is deliberate (documented in `docs/markdown-pipeline.md`) rather
+   than duplicating the sentinel machinery into a second vendored package.
+
 Parse and serialize behaviour is otherwise unchanged. Parity is covered by
 `src/markdown/__tests__/vendor-wiki-link.test.ts`.

package/dist/markdown/vendor/mdast-util-wiki-link/from-markdown.d.ts

@@ -8,7 +8,7 @@
  * package would silently get different — and wrong — wiki-link behaviour inside
  * markdown tables (#347). Vendoring makes the package self-contained.
  *
- * Four deliberate divergences from upstream:
+ * Five deliberate divergences from upstream:
  *   1. The trailing-backslash strip (see `exitWikiLink`), previously carried as
  *      `liminis-app/patches/mdast-util-wiki-link@0.1.2.patch` in `verveguy/liminis`.
  *   2. Real types instead of `any` on the public option and node shapes.
@@ -16,6 +16,11 @@
  *      closure variable shared by every handler in one `fromMarkdown()` call.
  *   4. `top()` asserts the stack frame is actually a wiki-link, so the
  *      cannot-nest assumption fails loudly rather than corrupting a sibling node.
+ *   5. A trailing `#^blockId` fragment (Obsidian block-reference syntax, #119)
+ *      is split off `value` into `data.blockId` before `pageResolver` runs, so
+ *      `data.permalink`/`data.exists` are computed from the file target alone.
+ *      An ordinary heading anchor (`#heading`, no caret) is untouched — this
+ *      only matches the caret-prefixed block-id form.
  *
  * Nothing else about the parse behaviour changes: `value`, `data.alias`,
  * `data.permalink`, `data.exists`, `data.hName`, `data.hProperties` and
@@ -37,6 +42,8 @@ interface WikiLinkNode {
         alias: string | null;
         permalink: string | null;
         exists: boolean | null;
+        /** Obsidian-style `#^blockId` fragment split off `value`, if present (#119). */
+        blockId?: string | null;
         hName?: string;
         hProperties?: {
             className: string;

package/dist/markdown/vendor/mdast-util-wiki-link/from-markdown.js

@@ -8,7 +8,7 @@
  * package would silently get different — and wrong — wiki-link behaviour inside
  * markdown tables (#347). Vendoring makes the package self-contained.
  *
- * Four deliberate divergences from upstream:
+ * Five deliberate divergences from upstream:
  *   1. The trailing-backslash strip (see `exitWikiLink`), previously carried as
  *      `liminis-app/patches/mdast-util-wiki-link@0.1.2.patch` in `verveguy/liminis`.
  *   2. Real types instead of `any` on the public option and node shapes.
@@ -16,11 +16,24 @@
  *      closure variable shared by every handler in one `fromMarkdown()` call.
  *   4. `top()` asserts the stack frame is actually a wiki-link, so the
  *      cannot-nest assumption fails loudly rather than corrupting a sibling node.
+ *   5. A trailing `#^blockId` fragment (Obsidian block-reference syntax, #119)
+ *      is split off `value` into `data.blockId` before `pageResolver` runs, so
+ *      `data.permalink`/`data.exists` are computed from the file target alone.
+ *      An ordinary heading anchor (`#heading`, no caret) is untouched — this
+ *      only matches the caret-prefixed block-id form.
  *
  * Nothing else about the parse behaviour changes: `value`, `data.alias`,
  * `data.permalink`, `data.exists`, `data.hName`, `data.hProperties` and
  * `data.hChildren` are computed exactly as upstream computes them.
  */
+/**
+ * Matches a trailing `#^blockId` fragment — the Obsidian block-reference
+ * convention — at the end of a wiki-link target. Deliberately narrower than a
+ * general `#fragment` match: an ordinary heading anchor (`[[file#heading]]`)
+ * has no caret and must keep flowing through the pre-existing same-file-anchor
+ * handling in the mapper untouched (FR-014).
+ */
+const BLOCK_ID_PATTERN = /#\^([^\s\]#]+)$/;
 /**
  * The node currently being built, read off the compile stack.
  *
@@ -57,6 +70,7 @@ export function fromMarkdown(opts = {}) {
                 alias: null,
                 permalink: null,
                 exists: null,
+                blockId: null,
             },
         };
         this.enter(node, token);
@@ -92,6 +106,17 @@ export function fromMarkdown(opts = {}) {
             wikiLink.value = wikiLink.value.slice(0, -1);
         }
         // --------------------------------------------------------------------------
+        // --- Liminis divergence from upstream (#119) ------------------------------
+        // Split a trailing `#^blockId` fragment off the target before resolving,
+        // so `data.permalink`/`data.exists` are derived from the file target
+        // alone and a block-scoped link (`[[file#^id]]`) resolves exactly like
+        // today's file-only `[[file]]` for existence-checking purposes.
+        const blockIdMatch = wikiLink.value ? BLOCK_ID_PATTERN.exec(wikiLink.value) : null;
+        if (blockIdMatch) {
+            wikiLink.data.blockId = blockIdMatch[1];
+            wikiLink.value = wikiLink.value.slice(0, blockIdMatch.index);
+        }
+        // --------------------------------------------------------------------------
         const pagePermalinks = pageResolver(wikiLink.value);
         const target = pagePermalinks.find((p) => permalinks.includes(p));
         const exists = target !== undefined;

package/dist/markdown/vendor/mdast-util-wiki-link/to-markdown.d.ts

@@ -2,13 +2,19 @@
  * Vendored from `mdast-util-wiki-link@0.1.2` (MIT, Mark Hudnall — see LICENSE
  * in this directory).
  *
- * One deliberate divergence from upstream: upstream imports
- * `mdast-util-to-markdown/lib/util/safe` from **v0.6.5** of that package, a
- * deep import into a v0 duplicate of the v2 `mdast-util-to-markdown` this
- * package already uses. That duplicate (and upstream's `@babel/runtime`
- * dependency) exists solely to serve this file. Here the same escaping is done
- * through v2's `state.safe()`, which is the supported API and produces the same
- * result for the `{ before: '[', after: ']' }` case this handler uses.
+ * Two deliberate divergences from upstream:
+ *   1. Upstream imports `mdast-util-to-markdown/lib/util/safe` from **v0.6.5**
+ *      of that package, a deep import into a v0 duplicate of the v2
+ *      `mdast-util-to-markdown` this package already uses. That duplicate
+ *      (and upstream's `@babel/runtime` dependency) exists solely to serve
+ *      this file. Here the same escaping is done through v2's `state.safe()`,
+ *      which is the supported API and produces the same result for the
+ *      `{ before: '[', after: ']' }` case this handler uses.
+ *   2. A `data.blockId` fragment (#119) is re-appended as `#^blockId` after
+ *      the target, mirroring the split `from-markdown.ts` performs on the way
+ *      in — so a raw `./markdown`-subpath consumer building `wikiLink` nodes
+ *      by hand (not just `parseMarkdown`) gets byte-identical round-tripping
+ *      of the block-id fragment.
  */
 import type { Options as ToMarkdownExtension } from 'mdast-util-to-markdown';
 export interface WikiLinkToMarkdownOptions {

package/dist/markdown/vendor/mdast-util-wiki-link/to-markdown.js

@@ -4,6 +4,8 @@ export function toMarkdown(opts = {}) {
         const wikiLink = node;
         const exit = state.enter('wikiLink');
         const nodeValue = state.safe(wikiLink.value, { before: '[', after: ']' });
+        const blockId = wikiLink.data?.blockId;
+        const targetText = typeof blockId === 'string' && blockId.length > 0 ? `${nodeValue}#^${blockId}` : nodeValue;
         // Second deliberate divergence from upstream. Upstream passes the alias
         // through `safe()` unconditionally; `safe(undefined)` yields `''`, which is
         // then unequal to a non-empty target, so a node carrying *no* alias
@@ -17,7 +19,7 @@ export function toMarkdown(opts = {}) {
         const rawAlias = wikiLink.data?.alias;
         const hasAlias = typeof rawAlias === 'string' && rawAlias.length > 0;
         const nodeAlias = hasAlias ? state.safe(rawAlias, { before: '[', after: ']' }) : nodeValue;
-        const value = nodeAlias !== nodeValue ? `[[${nodeValue}${aliasDivider}${nodeAlias}]]` : `[[${nodeValue}]]`;
+        const value = nodeAlias !== nodeValue ? `[[${targetText}${aliasDivider}${nodeAlias}]]` : `[[${targetText}]]`;
         exit();
         return value;
     };

package/dist/styles.css

@@ -669,6 +669,54 @@ body {
   opacity: 0.8;
 }
 
+/* Block transclusion (#119): live-rendered content from `![[file#^id]]`. Five
+   states — do not collapse "unresolved"/"circular"/"depth-exceeded" into one
+   style; each needs to read as a distinct failure mode at a glance. */
+.editor-transclusion-content {
+  display: inline;
+  padding: 0 0.2em;
+  border-left: 2px solid var(--liminis-editor-border);
+  background: var(--liminis-editor-code-bg);
+}
+
+.editor-transclusion-loading {
+  color: var(--liminis-editor-foreground-muted);
+  font-style: italic;
+}
+
+.editor-transclusion-unresolved,
+.editor-transclusion-circular,
+.editor-transclusion-depth-exceeded {
+  color: var(--liminis-editor-errorForeground);
+  border: 1px dashed var(--liminis-editor-errorForeground);
+  border-radius: 3px;
+  padding: 0 0.3em;
+  font-style: italic;
+  font-size: 0.9em;
+}
+
+.editor-transclusion-paragraph {
+  display: inline;
+}
+
+.editor-transclusion-list,
+.editor-transclusion-list-item {
+  display: inline;
+}
+
+.editor-transclusion-list-item + .editor-transclusion-list-item::before {
+  content: ' ';
+}
+
+.editor-transclusion-list-item input[type='checkbox'] {
+  margin-right: 0.2em;
+  vertical-align: middle;
+}
+
+.editor-transclusion-heading {
+  font-weight: 600;
+}
+
 /* Tables */
 .editor-table {
   width: 100%;

package/dist/types.d.ts

@@ -290,6 +290,7 @@ export type UIToHostMessage = {
 } | {
     type: 'OPEN_LINK';
     url: string;
+    blockId?: string;
 };
 export declare function validateHostToUIMessage(data: unknown): HostToUIMessage | null;
 export type BlockType = 'paragraph' | 'heading1' | 'heading2' | 'heading3' | 'bulletList' | 'numberedList' | 'todoList' | 'quote' | 'code' | 'divider' | 'image' | 'table' | 'toggle' | 'callout' | 'link';