@texuli/core 0.5.0 → 0.7.0

package/dist/editor/markdown.js

@@ -1,4 +1,5 @@
 import { normalizeDocument, paragraph } from "./document.js";
+import { acceptsExtensionId, EDITOR_EXTENSION_LIMITS, isExtensionIdChar, toInlineExtensions, } from "./extensions.js";
 import { markKey, normalizeInline, sortMarks } from "./inline.js";
 import { LoadBudget } from "./load.js";
 /**
@@ -299,9 +300,51 @@ class Scan {
     source;
     closers = new Map();
     brackets = null;
+    tokens = null;
     constructor(source) {
         this.source = source;
     }
+    /**
+     * The extension token `<sigil>{id|label}` whose sigil is at `at`, or null.
+     * Two linear passes the first time (the id-character run from each index,
+     * and the next unescaped `}` before a newline), then constant time.
+     */
+    extension(at) {
+        const { source } = this;
+        if (source[at + 1] !== '{')
+            return null;
+        if (!this.tokens) {
+            const n = source.length;
+            const idRun = new Int32Array(n + 1);
+            for (let j = n - 1; j >= 0; j -= 1)
+                idRun[j] = isExtensionIdChar(source.charCodeAt(j)) ? idRun[j + 1] + 1 : 0;
+            const escaped = new Uint8Array(n);
+            for (let j = 0; j < n; j += 1) {
+                if (source[j] === '\\') {
+                    if (j + 1 < n)
+                        escaped[j + 1] = 1;
+                    j += 1;
+                }
+            }
+            const close = new Int32Array(n + 1).fill(-1);
+            for (let j = n - 1; j >= 0; j -= 1) {
+                const c = source[j];
+                close[j] = c === '\n' ? -1 : c === '}' && !escaped[j] ? j : close[j + 1];
+            }
+            this.tokens = { idRun, close };
+        }
+        const idStart = at + 2;
+        const idEnd = idStart + (this.tokens.idRun[idStart] ?? 0);
+        if (idEnd === idStart || idEnd - idStart > EDITOR_EXTENSION_LIMITS.id)
+            return null;
+        if (source[idEnd] !== '|')
+            return null;
+        const labelStart = idEnd + 1;
+        const labelEnd = this.tokens.close[labelStart] ?? -1;
+        if (labelEnd <= labelStart || labelEnd - labelStart > EDITOR_EXTENSION_LIMITS.label)
+            return null;
+        return { idStart, idEnd, labelStart, labelEnd, end: labelEnd + 1 };
+    }
     /** The first valid closer of `marker` at or after `from`, or -1. */
     closer(marker, from) {
         let table = this.closers.get(marker);
@@ -373,16 +416,31 @@ class Scan {
 /** Inline Markdown into runs; `marks` are the marks open around `source`. */
 function parseInline(source, depth, marks, inLink, out, budget) {
     let buffer = '';
+    // Spaces at the end of `buffer`, kept as it grows: reading the buffer's
+    // last characters would flatten the string being built on every soft line
+    // break (quadratic in a long paragraph).
+    let spaces = 0;
+    const append = (text) => {
+        buffer += text;
+        let end = text.length;
+        while (end > 0 && text.charCodeAt(end - 1) === 32)
+            end -= 1;
+        spaces = end === 0 ? spaces + text.length : text.length - end;
+    };
     const flush = () => {
         if (buffer)
             out.push(...budget.inline(buffer.replace(/\n/g, ' '), marks));
         buffer = '';
+        spaces = 0;
     };
     const push = (text, extra) => {
         flush();
         out.push(...budget.inline(text, sortMarks([...marks, ...extra])));
     };
     const scan = new Scan(source);
+    const extensions = budget.extensions;
+    // The characters that can start an inline construct, registered sigils included.
+    const special = extensions.special;
     let i = 0;
     while (i < source.length) {
         const ch = source[i] ?? '';
@@ -396,17 +454,13 @@ function parseInline(source, depth, marks, inLink, out, budget) {
                 continue;
             }
             if (ESCAPABLE.test(next)) {
-                buffer += next;
+                append(next);
                 i += 2;
                 continue;
             }
         }
         if (ch === '\n') {
-            // Count trailing spaces by hand: an unanchored `/ {2,}$/` rescans the
-            // whole buffer on every soft line break (quadratic in a long paragraph).
-            let spaces = 0;
-            while (buffer.charCodeAt(buffer.length - 1 - spaces) === 32)
-                spaces += 1;
+            // Two or more trailing spaces make a hard break.
             if (spaces >= 2) {
                 buffer = buffer.slice(0, buffer.length - spaces);
                 flush();
@@ -414,10 +468,22 @@ function parseInline(source, depth, marks, inLink, out, budget) {
                 budget.chars += 1;
             }
             else
-                buffer += '\n';
+                append('\n');
             i += 1;
             continue;
         }
+        const extension = inLink ? undefined : extensions.bySigil.get(ch);
+        if (extension) {
+            const token = scan.extension(i);
+            const id = token ? source.slice(token.idStart, token.idEnd) : '';
+            if (token && acceptsExtensionId(extensions, extension.name, id)) {
+                push(unescapeMarkdown(source.slice(token.labelStart, token.labelEnd)), [
+                    { type: 'extension', name: extension.name, id },
+                ]);
+                i = token.end;
+                continue;
+            }
+        }
         if (ch === '`') {
             const run = /^`+/.exec(source.slice(i, i + 64))?.[0] ?? '`';
             const close = source.indexOf(run, i + run.length);
@@ -427,7 +493,7 @@ function parseInline(source, depth, marks, inLink, out, budget) {
                 i = close + run.length;
                 continue;
             }
-            buffer += run;
+            append(run);
             i += run.length;
             continue;
         }
@@ -443,7 +509,7 @@ function parseInline(source, depth, marks, inLink, out, budget) {
             if (ch === '!' && source[i + 1] === '[') {
                 const image = matchLink(scan, i + 1);
                 if (image) {
-                    buffer += unescapeMarkdown(source.slice(image.labelStart, image.labelEnd));
+                    append(unescapeMarkdown(source.slice(image.labelStart, image.labelEnd)));
                     i = image.end;
                     continue;
                 }
@@ -469,8 +535,12 @@ function parseInline(source, depth, marks, inLink, out, budget) {
                 }
             }
         }
-        buffer += ch;
-        i += 1;
+        // Plain text up to the next character that can open a construct is
+        // copied in one slice, not one character at a time.
+        special.lastIndex = i + 1;
+        const stop = special.test(source) ? special.lastIndex - 1 : source.length;
+        append(source.slice(i, stop));
+        i = stop;
     }
     flush();
 }
@@ -581,6 +651,15 @@ function readLinkTarget(source, open) {
 // ---------------------------------------------------------------------------
 // Writing
 const escapeText = (text) => text.replace(/[\\`*_[\]~<!]/g, '\\$&');
+/** Plain text: a registered sigil before `{` would read as a token, so `{` is escaped. */
+const escapePlain = (text, extensions) => extensions.literal ? escapeText(text).replace(extensions.literal, '$1\\{') : escapeText(text);
+/** An extension token: the label escaped so no closer or delimiter inside it counts. */
+function extensionToken(mark, label, extensions) {
+    const extension = extensions.byName.get(mark.name);
+    if (!extension)
+        return null;
+    return `${extension.sigil}{${mark.id}|${escapeText(label).replace(/[{}]/g, '\\$&')}}`;
+}
 /** A line that would start another block gets its first marker escaped. */
 function escapeLineStart(line) {
     const ordered = /^( {0,3}\d{1,9})([.)])([ \t]|$)/.exec(line);
@@ -598,71 +677,86 @@ function codeSpan(text) {
     const pad = text.startsWith('`') || text.endsWith('`') || /^ .* $/.test(text) ? ' ' : '';
     return `${fence}${pad}${text}${pad}${fence}`;
 }
-/** Move whitespace and trailing backslashes out of strong, em and strike spans (Markdown cannot open or close there). */
+/**
+ * Move whitespace and trailing backslashes out of strong, em and strike spans
+ * (Markdown cannot open or close there). Works on runs, splitting a run only
+ * where a span edge moves: one pass per mark type, no object per character.
+ */
 function prepareMarks(content) {
-    const chars = [];
-    for (const node of content) {
-        if (node.type === 'break')
-            chars.push(null);
-        else
-            for (const ch of node.text)
-                chars.push({ ch, marks: node.marks });
-    }
-    // The nearest character on each side of every position, so a run of
-    // breaks is crossed in constant time (linear, not quadratic, in breaks).
-    const previous = new Array(chars.length);
-    const next = new Array(chars.length);
-    for (let k = 0, last = -1; k < chars.length; k += 1) {
-        previous[k] = last;
-        if (chars[k] !== null)
-            last = k;
-    }
-    for (let k = chars.length - 1, last = chars.length; k >= 0; k -= 1) {
-        next[k] = last;
-        if (chars[k] !== null)
-            last = k;
-    }
+    let runs = content.flatMap((node) => node.type === 'break' ? [null] : node.text ? [{ text: node.text, marks: node.marks }] : []);
     for (const type of ['strong', 'em', 'strike']) {
+        const marked = (run) => run?.marks.some((m) => m.type === type) === true;
+        const strip = (run, text) => ({
+            text,
+            marks: run.marks.filter((m) => m.type !== type),
+        });
+        const out = [];
         let i = 0;
-        const marked = (c) => c?.marks.some((m) => m.type === type) === true;
-        // A break inside a span (marked text on both sides) does not end it.
-        const has = (k) => {
-            if (chars[k] !== null)
-                return marked(chars[k]);
-            const left = previous[k];
-            return left >= 0 && marked(chars[left]) && marked(chars[next[k]]);
-        };
-        while (i < chars.length) {
-            if (!has(i)) {
+        while (i < runs.length) {
+            if (!marked(runs[i])) {
+                out.push(runs[i]);
                 i += 1;
                 continue;
             }
+            // A span: marked text, and breaks with marked text on both sides.
             let end = i;
-            while (has(end + 1))
-                end += 1;
-            const drop = (k) => {
-                const c = chars[k];
-                chars[k] = { ch: c.ch, marks: c.marks.filter((m) => m.type !== type) };
-            };
-            let a = i;
-            while (a <= end && chars[a] && /\s/.test(chars[a].ch))
-                drop(a++);
-            let b = end;
-            while (b >= a && chars[b] && /[\s\\]/.test(chars[b].ch))
-                drop(b--);
+            for (let k = i + 1; k < runs.length; k += 1) {
+                if (runs[k] === null)
+                    continue;
+                if (!marked(runs[k]))
+                    break;
+                end = k;
+            }
+            const span = runs.slice(i, end + 1);
+            // Leading whitespace leaves the span, up to the first other character
+            // or break; then trailing whitespace and backslashes, from the end.
+            const head = [];
+            const tail = [];
+            let a = 0;
+            let b = span.length - 1;
+            for (; a <= b; a += 1) {
+                const run = span[a];
+                if (!run)
+                    break;
+                let cut = 0;
+                while (/\s/.test(run.text[cut] ?? ''))
+                    cut += 1;
+                if (cut)
+                    head.push(strip(run, run.text.slice(0, cut)));
+                if (cut < run.text.length) {
+                    span[a] = { text: run.text.slice(cut), marks: run.marks };
+                    break;
+                }
+            }
+            for (; b >= a; b -= 1) {
+                const run = span[b];
+                if (!run)
+                    break;
+                let cut = run.text.length;
+                while (/[\s\\]/.test(run.text[cut - 1] ?? ''))
+                    cut -= 1;
+                if (cut < run.text.length)
+                    tail.push(strip(run, run.text.slice(cut)));
+                if (cut) {
+                    span[b] = { text: run.text.slice(0, cut), marks: run.marks };
+                    break;
+                }
+            }
+            // One push per run: a spread of a long span could overflow the call stack.
+            for (const run of [...head, ...span.slice(a, b + 1), ...tail.reverse()])
+                out.push(run);
             i = end + 1;
         }
+        runs = out;
     }
-    const out = [];
-    for (const c of chars)
-        out.push(c ? { type: 'text', text: c.ch, marks: c.marks } : { type: 'break' });
-    return normalizeInline(out);
+    return normalizeInline(runs.map((run) => (run ? { type: 'text', ...run } : { type: 'break' })));
 }
-function writeInline(content, em) {
+function writeInline(content, em, extensions) {
     const open = { strong: '**', em, strike: '~~' };
     const texts = content.flatMap((node) => (node.type === 'text' ? [{ node }] : []));
     const stack = [];
-    const outer = (marks) => marks.filter((m) => m.type !== 'code');
+    // Code spans and extension tokens are leaves: other marks nest around them.
+    const outer = (marks) => marks.filter((m) => m.type !== 'code' && m.type !== 'extension');
     // Where the span of each mark starting at text `t` ends (marks that end
     // later nest outside), computed once from the end so long spans stay linear.
     const ends = new Array(texts.length);
@@ -691,7 +785,7 @@ function writeInline(content, em) {
     const close = (to) => {
         while (stack.length > to) {
             const mark = stack.pop();
-            out += mark.type === 'link' ? `](${encodeRef(mark.href)})` : open[mark.type];
+            out += mark.type === 'link' ? `](${encodeRef(mark.href)})` : (open[mark.type] ?? '');
         }
     };
     const keepCommon = (wanted) => {
@@ -716,10 +810,16 @@ function writeInline(content, em) {
         const wanted = ordered(t);
         const common = keepCommon(wanted);
         for (const mark of wanted.slice(common)) {
-            out += mark.type === 'link' ? '[' : open[mark.type];
+            out += mark.type === 'link' ? '[' : (open[mark.type] ?? '');
             stack.push(mark);
         }
-        out += node.marks.some((m) => m.type === 'code') ? codeSpan(node.text) : escapeText(node.text);
+        const entity = node.marks.find((m) => m.type === 'extension');
+        const token = entity ? extensionToken(entity, node.text, extensions) : null;
+        out +=
+            token ??
+                (node.marks.some((m) => m.type === 'code')
+                    ? codeSpan(node.text)
+                    : escapePlain(node.text, extensions));
         t += 1;
     });
     close(0);
@@ -733,8 +833,8 @@ const sameInline = (a, b) => a.length === b.length &&
         return (node.text === other.text && node.marks.map(markKey).join() === other.marks.map(markKey).join());
     });
 /** Read inline Markdown back without caps or policy changes (for the write check). */
-function reread(markdown) {
-    const budget = new LoadBudget({ trust: 'developer' });
+function reread(markdown, extensions) {
+    const budget = new LoadBudget({ trust: 'developer', extensions });
     const out = [];
     parseInline(markdown, 0, [], false, out, budget);
     return normalizeInline(out);
@@ -744,11 +844,11 @@ function reread(markdown) {
  * combination has no faithful spelling in the subset, the result drops the
  * least significant marks (em, then strike, then strong) until it does.
  */
-function inlineMarkdown(content, lineStart) {
-    let prepared = prepareMarks(content);
+function inlineMarkdown(content, lineStart, extensions) {
+    let prepared = prepareMarks(withRegistered(content, extensions));
     const attempt = (em) => {
-        const text = writeInline(prepared, em).split('\n').map(lineStart).join('\n');
-        return sameInline(reread(text), prepared) ? text : null;
+        const text = writeInline(prepared, em, extensions).split('\n').map(lineStart).join('\n');
+        return sameInline(reread(text, extensions), prepared) ? text : null;
     };
     for (const drop of [null, 'em', 'strike', 'strong']) {
         if (drop)
@@ -757,25 +857,34 @@ function inlineMarkdown(content, lineStart) {
         if (text !== null)
             return text;
     }
-    return writeInline(prepared, '*').split('\n').map(lineStart).join('\n');
+    return writeInline(prepared, '*', extensions).split('\n').map(lineStart).join('\n');
+}
+/** Extension marks of unregistered names leave (their label stays plain text). */
+function withRegistered(content, extensions) {
+    const foreign = (mark) => mark.type === 'extension' && !extensions.byName.has(mark.name);
+    if (!content.some((n) => n.type === 'text' && n.marks.some(foreign)))
+        return content;
+    return normalizeInline(content.map((n) => n.type === 'text' && n.marks.some(foreign)
+        ? { ...n, marks: n.marks.filter((m) => !foreign(m)) }
+        : n));
 }
 const indent = (text, by) => text
     .split('\n')
     .map((line) => (line ? by + line : line))
     .join('\n');
-function writeBlocks(blocks) {
+function writeBlocks(blocks, extensions) {
     return blocks
-        .map(writeBlock)
+        .map((block) => writeBlock(block, extensions))
         .filter((text) => text !== '')
         .join('\n\n');
 }
-function writeBlock(block) {
+function writeBlock(block, extensions) {
     switch (block.type) {
         case 'paragraph':
-            return inlineMarkdown(trimEdges(block.content), escapeLineStart);
+            return inlineMarkdown(trimEdges(block.content), escapeLineStart, extensions);
         case 'heading': {
             const flat = block.content.map((n) => (n.type === 'break' ? { type: 'text', text: ' ', marks: [] } : n));
-            const text = inlineMarkdown(trimEdges(normalizeInline(flat)), (line) => line);
+            const text = inlineMarkdown(trimEdges(normalizeInline(flat)), (line) => line, extensions);
             return `${'#'.repeat(block.level)}${text ? ` ${text}` : ''}${text.endsWith('#') ? ' #' : ''}`;
         }
         case 'code': {
@@ -792,13 +901,13 @@ function writeBlock(block) {
                         ? `- [${item.checked ? 'x' : ' '}] `
                         : '- ';
                 const [first, ...rest] = item.blocks;
-                const head = first ? indent(writeBlock(first), '    ').trimStart() : '';
-                const tail = writeBlocks(rest);
+                const head = first ? indent(writeBlock(first, extensions), '    ').trimStart() : '';
+                const tail = writeBlocks(rest, extensions);
                 return `${marker}${head}${tail ? `\n\n${indent(tail, '    ')}` : ''}`;
             })
                 .join('\n');
         case 'quote':
-            return writeBlocks(block.blocks)
+            return writeBlocks(block.blocks, extensions)
                 .split('\n')
                 .map((line) => (line ? `> ${line}` : '>'))
                 .join('\n');
@@ -815,7 +924,8 @@ function trimEdges(content) {
         out.shift();
     while (out.at(-1)?.type === 'break')
         out.pop();
-    const plain = (node) => node?.type === 'text' && !node.marks.some((mark) => mark.type === 'code');
+    const plain = (node) => node?.type === 'text' &&
+        !node.marks.some((mark) => mark.type === 'code' || mark.type === 'extension');
     const first = out[0];
     if (plain(first))
         out[0] = { ...first, text: first.text.trimStart() };
@@ -830,6 +940,6 @@ function trimEdges(content) {
  * paragraphs, breaks in headings (written as spaces), breaks at the edges of
  * a block, and whitespace at the edges of a paragraph or a mark.
  */
-export function toMarkdown(doc) {
-    return writeBlocks(doc.blocks);
+export function toMarkdown(doc, options = {}) {
+    return writeBlocks(doc.blocks, toInlineExtensions(options.extensions));
 }

package/dist/editor/model.d.ts

@@ -2,9 +2,11 @@
  * `@texuli/core/editor-model`: the rich text editor document model (ADR-003).
  * Types and caps, the closed vocabularies, constructors, normalization,
  * validation, the untrusted loader, selection helpers, grapheme and word
- * boundaries, and the nested inline interchange shape. Framework-free.
+ * boundaries, the nested inline interchange shape, and host inline
+ * extensions (mentions, references). Framework-free.
  */
 export { blockLength, blockText, createEditorIds, type EditorAncestor, type EditorIdSource, type EditorLocation, editorBlockCount, editorCharCount, editorLeaves, editorPlainText, emptyEditorDocument, isTextBlock, isVoidBlock, locateBlock, nextEditorId, normalizeDocument, paragraph, removeBlocks, replaceBlock, replaceItem, validateEditorDocument, } from './document.js';
+export { acceptsExtensionId, createInlineExtensions, EDITOR_EXTENSION_LIMITS, EDITOR_EXTENSION_SIGILS, type EditorExtensionSigil, type EditorInlineExtension, type EditorInlineExtensions, extensionHref, toInlineExtensions, } from './extensions.js';
 export { graphemeBoundaries, nextGrapheme, nextWord, previousGrapheme, previousWord, snapToGrapheme, } from './graphemes.js';
 export { cleanText, hasMark, inheritedMarks, inlineLength, inlineText, markKey, normalizeInline, sliceInline, sortMarks, textToInline, } from './inline.js';
 export { type EditorLoadOptions, type EditorLoadResult, loadEditorDocument } from './load.js';

package/dist/editor/model.js

@@ -2,9 +2,11 @@
  * `@texuli/core/editor-model`: the rich text editor document model (ADR-003).
  * Types and caps, the closed vocabularies, constructors, normalization,
  * validation, the untrusted loader, selection helpers, grapheme and word
- * boundaries, and the nested inline interchange shape. Framework-free.
+ * boundaries, the nested inline interchange shape, and host inline
+ * extensions (mentions, references). Framework-free.
  */
 export { blockLength, blockText, createEditorIds, editorBlockCount, editorCharCount, editorLeaves, editorPlainText, emptyEditorDocument, isTextBlock, isVoidBlock, locateBlock, nextEditorId, normalizeDocument, paragraph, removeBlocks, replaceBlock, replaceItem, validateEditorDocument, } from "./document.js";
+export { acceptsExtensionId, createInlineExtensions, EDITOR_EXTENSION_LIMITS, EDITOR_EXTENSION_SIGILS, extensionHref, toInlineExtensions, } from "./extensions.js";
 export { graphemeBoundaries, nextGrapheme, nextWord, previousGrapheme, previousWord, snapToGrapheme, } from "./graphemes.js";
 export { cleanText, hasMark, inheritedMarks, inlineLength, inlineText, markKey, normalizeInline, sliceInline, sortMarks, textToInline, } from "./inline.js";
 export { loadEditorDocument } from "./load.js";

package/dist/editor/transforms.d.ts

@@ -50,7 +50,7 @@ export declare function toggleQuote(state: EditorState, options?: EditorTransfor
  * it). At a caret it toggles the stored marks for the next typed text. Code
  * text takes only `link` besides `code`.
  */
-export declare function toggleMark(state: EditorState, type: Exclude<EditorMarkType, 'link'>, options?: EditorTransformOptions): EditorTransformResult;
+export declare function toggleMark(state: EditorState, type: Exclude<EditorMarkType, 'link' | 'extension'>, options?: EditorTransformOptions): EditorTransformResult;
 export interface SetLinkOptions extends EditorTransformOptions {
     /** URL policy tier. Default `untrusted`; pasted and typed URLs stay untrusted. */
     trust?: HrefTrust;

package/dist/editor/tree.d.ts

@@ -20,8 +20,18 @@ export type EditorInlineNode = {
     type: 'link';
     href: string;
     children: EditorInlineNode[];
+}
+/** A host inline extension entity (`name`, `id`) around its label. */
+ | {
+    type: 'extension';
+    name: string;
+    id: string;
+    children: EditorInlineNode[];
 };
-/** Fold runs into nested nodes, outermost mark first (`link`, `strong`, `em`, `strike`). */
+/**
+ * Fold runs into nested nodes, outermost mark first (`link`, `strong`, `em`,
+ * `strike`, then `extension` innermost around its label).
+ */
 export declare function inlineToTree(content: readonly EditorInline[]): EditorInlineNode[];
 /**
  * Flatten a nested inline tree (this shape, the catalog's or the blocks

package/dist/editor/tree.js

@@ -1,6 +1,9 @@
 import { markKey, normalizeInline, sortMarks } from "./inline.js";
 import { LoadBudget } from "./load.js";
-/** Fold runs into nested nodes, outermost mark first (`link`, `strong`, `em`, `strike`). */
+/**
+ * Fold runs into nested nodes, outermost mark first (`link`, `strong`, `em`,
+ * `strike`, then `extension` innermost around its label).
+ */
 export function inlineToTree(content) {
     const root = [];
     const stack = [];
@@ -22,7 +25,9 @@ export function inlineToTree(content) {
         for (const mark of wanted.slice(common)) {
             const node = mark.type === 'link'
                 ? { type: 'link', href: mark.href, children: [] }
-                : { type: mark.type, children: [] };
+                : mark.type === 'extension'
+                    ? { type: 'extension', name: mark.name, id: mark.id, children: [] }
+                    : { type: mark.type, children: [] };
             children().push(node);
             stack.push({ mark, node });
         }
@@ -90,6 +95,10 @@ export function inlineFromTree(nodes, options = {}) {
                 const href = budget.href(node.href);
                 visit(node.children, href ? sortMarks([...marks, { type: 'link', href }]) : marks, depth + 1);
             }
+            else if (type === 'extension') {
+                const extension = budget.extension(node.name, node.id);
+                visit(node.children, extension ? sortMarks([...marks, extension]) : marks, depth + 1);
+            }
             else {
                 budget.report('unknown-node', 'Unknown inline nodes kept only their text.');
                 if (text !== undefined)

package/dist/editor/types.d.ts

@@ -18,6 +18,16 @@ export type EditorMark = {
 } | {
     type: 'link';
     href: string;
+}
+/**
+ * A host inline extension entity (a mention, a reference) over its label
+ * text: `name` is a registered extension, `id` the entity (G48). Excludes
+ * `link` and `code` on the same run.
+ */
+ | {
+    type: 'extension';
+    name: string;
+    id: string;
 };
 export type EditorMarkType = EditorMark['type'];
 export type EditorInline = {

package/dist/editor/types.js

@@ -27,6 +27,7 @@ export const EDITOR_MARK_ORDER = [
     'em',
     'strike',
     'code',
+    'extension',
 ];
 export const EDITOR_BLOCK_TYPES = [
     'paragraph',

package/dist/inert/inert.d.ts

@@ -34,10 +34,21 @@ export interface InertExemptionInput {
     element: Element;
     /** Optional debug label (`toast-region`, `announcer`, …). */
     label?: string;
+    /**
+     * Whether the region stays above overlays opened after it (default `true`):
+     * when it is open as a popover, the overlay engine re-shows it in the top
+     * layer each time another overlay opens, so the toast region keeps painting
+     * on top. Pass `false` for exemptions that belong under later overlays: a
+     * dialog backdrop, or a menu or listbox opened inside a modal, which must
+     * never cover the overlay opened from it.
+     */
+    raise?: boolean;
 }
 export interface InertExemption {
     readonly element: Element;
     readonly label?: string;
+    /** `false` when the region must not be re-raised above later overlays (omitted means `true`). */
+    readonly raise?: false;
 }
 export interface InertExemptionHandle {
     /** Stop exempting this element (idempotent). Open scopes recompute. */

package/dist/inert/inert.js

@@ -142,9 +142,11 @@ export function createInertRegistry() {
             if (!isElement(input.element)) {
                 throw new TypeError('InertRegistry.exempt: element must be a DOM Element');
             }
-            const entry = input.label === undefined
-                ? { element: input.element }
-                : { element: input.element, label: input.label };
+            const entry = {
+                element: input.element,
+                ...(input.label === undefined ? {} : { label: input.label }),
+                ...(input.raise === false ? { raise: false } : {}),
+            };
             exemptions.push(entry);
             apply();
             let released = false;

package/dist/markup/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @texuli/core/markup: escaped XML and HTML builders (ADR-016). Typed nodes
+ * only, no raw-markup API; URL attributes go through the URL policy.
+ */
+export { el, escapeMarkupAttribute, escapeMarkupText, HTML_ELEMENTS, HTML_URL_ATTRIBUTES, type HtmlSerializeOptions, imageUrl, isMarkupUrl, linkUrl, type MarkupAttribute, type MarkupAttributeValue, type MarkupChild, type MarkupElement, type MarkupNode, type MarkupText, type MarkupUrl, sanitizeMarkupChars, serializeHtml, serializeXml, text, type XmlSerializeOptions, } from './markup.js';

package/dist/markup/index.js

@@ -0,0 +1,5 @@
+/**
+ * @texuli/core/markup: escaped XML and HTML builders (ADR-016). Typed nodes
+ * only, no raw-markup API; URL attributes go through the URL policy.
+ */
+export { el, escapeMarkupAttribute, escapeMarkupText, HTML_ELEMENTS, HTML_URL_ATTRIBUTES, imageUrl, isMarkupUrl, linkUrl, sanitizeMarkupChars, serializeHtml, serializeXml, text, } from "./markup.js";