@formicoidea/labre-core 0.50.0 → 0.52.0

package/dist/_pkgs/affine-block-surface/extensions/xml-reader.js

@@ -0,0 +1,570 @@
+/**
+ * A tolerant XML READER — the inverse of UML's `xml.ts` writer, and the one
+ * thing an importer cannot do without. Read by the XMI and draw.io importers,
+ * by BPMN and by the SVG sketch (through `xml-element.ts`), all four servable
+ * from the editor-free `./interchange` entry.
+ *
+ * ## Why not `DOMParser`
+ *
+ * BPMN and the SVG sketch used to call it, and the P0 import spike measured
+ * the cost on a server: a DOM to install (jsdom, 6 MB, behind `vm`), and a
+ * BPMN read that grew quadratically on it. An interchange parser is a PURE function of a string (`docs/adr/0012` P3) — the
+ * same function an editor command, a unit test and labre-mcp all call — and
+ * `DOMParser` is a DOM global that exists in exactly one of those three. A
+ * reader that needs `happy-dom` to be loaded is a reader with an environment in
+ * its signature.
+ *
+ * So: two hundred lines of scanner, and no global in sight.
+ *
+ * ## Tolerant, and what that costs
+ *
+ * **It never throws.** A file that stops mid-element, a close tag that names
+ * the wrong element, an attribute with no quotes, an entity nobody declared —
+ * every one of them produces a tree with a NOTE beside it rather than an
+ * exception. That is not sloppiness, it is the job: the files this reader is
+ * handed were written by Papyrus, StarUML, Enterprise Architect and a dozen
+ * scripts, and a user who exported a model from one of them is entitled to get
+ * back everything it said even when part of it is malformed. The alternative —
+ * one exception for one stray `&` — imports nothing at all.
+ *
+ * What it does NOT do is pretend to be a conformant parser. There is no DTD, no
+ * entity declaration, no namespace RESOLUTION (prefixes are kept exactly as the
+ * file spelled them — see {@link XmlNode.prefix}), no attribute-value
+ * normalization beyond the character references XML 1.0 §3.3.3 makes
+ * mandatory. Every one of those is a feature an XMI file in the wild does not
+ * use, and each would be a piece of surface with nothing behind it.
+ *
+ * ## Verbatim means the source's own bytes
+ *
+ * Every node records the byte RANGE it was read from ({@link XmlNode.range}),
+ * and {@link xmlFragmentOf} hands back that slice of the original string. So a
+ * quarantined fragment (ADR 0012 D5) is the file's own text — its comments, its
+ * whitespace, its attribute order, its prefixes — and not this reader's opinion
+ * of it. {@link serializeXmlNode} re-serializes from the tree instead, and is
+ * the fallback for a node assembled rather than read.
+ *
+ * ## Bounded, because a server reads it too
+ *
+ * The one exception to "never throws": a document past {@link XML_MAX_NODES}
+ * nodes or {@link XML_MAX_CHARACTERS} characters is refused with an
+ * {@link InterchangeImportError} carrying a static key, at the node that
+ * crosses the line and not after the tree is built. Each node costs about two
+ * hundred bytes of heap, and a 1.5 KiB `.drawio` inflates to a million of
+ * them (the 2026-10-14 security review: 3.2 s and 223 MiB before the cap). The
+ * scan is linear in the source otherwise: an orphan close tag is answered from
+ * a count of open names, not by searching the stack.
+ *
+ * Pure: a string in, a tree out. No `std`, no DOM, no clock.
+ */
+import { InterchangeImportError } from './interchange.js';
+/**
+ * Safe for a function with 256 MiB and two seconds: the largest file of the
+ * corpus holds a few thousand nodes, a reading at the cap about 40 MiB.
+ */
+export const XML_MAX_NODES = 200_000;
+/** Notes written in full; the rest are counted in one last note. */
+export const XML_MAX_NOTES = 100;
+/** A name as a note quotes it: its first 64 characters. */
+function shown(name) {
+    return name.length > 64 ? `${name.slice(0, 64)}…` : name;
+}
+/** 2 MiB of decoded characters, well past any drawing the canvas can show. */
+export const XML_MAX_CHARACTERS = 2 * 1024 * 1024;
+/** The reader's one refusal; static, so a server can hand the key on. */
+export const XML_READ_TOO_LARGE = [
+    'com.labre.interchange.xml.too-large',
+    'This file holds more than an import accepts, so it was not read.',
+];
+/* ── Entities ─────────────────────────────────────────────────────────── */
+/** The five XML 1.0 §4.6 predefined entities, and nothing else. */
+const NAMED_ENTITIES = {
+    amp: '&',
+    lt: '<',
+    gt: '>',
+    quot: '"',
+    apos: "'",
+};
+/**
+ * Character data as its characters — the five named entities and any numeric
+ * reference.
+ *
+ * An entity this reader does not know (`&nbsp;`, a DTD-declared one) is left
+ * EXACTLY as it was written, unresolved and unannounced. Two reasons, and the
+ * second is the one that matters: resolving it would need the DTD the file
+ * does not ship, and dropping it would lose a character; leaving the reference
+ * standing means a later re-serialization writes back what the file said, which
+ * is the promise `xmlFragmentOf` makes and this keeps true for text as well.
+ */
+export function decodeXmlText(value) {
+    if (!value.includes('&'))
+        return value;
+    return value.replaceAll(/&(#x[0-9a-fA-F]+|#\d+|[A-Za-z][\w.-]*);/g, (match, reference) => {
+        if (reference.startsWith('#')) {
+            const hex = reference[1] === 'x' || reference[1] === 'X';
+            const code = Number.parseInt(hex ? reference.slice(2) : reference.slice(1), hex ? 16 : 10);
+            // Out of Unicode's range is a reference no character answers, and
+            // `String.fromCodePoint` THROWS on one — which is the single place this
+            // reader could have raised. It hands back the reference instead.
+            return Number.isInteger(code) && code >= 0 && code <= 0x10ffff
+                ? String.fromCodePoint(code)
+                : match;
+        }
+        return NAMED_ENTITIES[reference] ?? match;
+    });
+}
+/* ── The scanner ──────────────────────────────────────────────────────── */
+/** A name character, generously: XML's NameChar minus the exotic ranges. */
+const NAME_CHAR = /[\w.:_\-À-￿]/;
+/** The prefix and the local half of a qualified name. */
+function splitName(name) {
+    const colon = name.indexOf(':');
+    return colon < 0
+        ? { prefix: '', local: name }
+        : { prefix: name.slice(0, colon), local: name.slice(colon + 1) };
+}
+/** A node with no children and no text, ready to be filled. */
+function nodeOf(name, start) {
+    const { prefix, local } = splitName(name);
+    return {
+        name,
+        prefix,
+        local,
+        // No prototype: an attribute may be called `__proto__` or `constructor`.
+        attrs: Object.create(null),
+        children: [],
+        range: [start, start],
+        content: [],
+    };
+}
+/**
+ * Read a document. Throws only past its size caps; see the header.
+ *
+ * The scan is a single left-to-right pass with an explicit stack, which is what
+ * makes the tolerance cheap: every recovery is "say what is wrong, and carry on
+ * from the next `<`", and there is no recursion to unwind. In conformant mode
+ * the first note STOPS the read: its callers refuse on any note, and a file
+ * built to raise twenty thousand of them must not get to.
+ */
+export function readXml(source, options = {}) {
+    const conformant = options.conformant === true;
+    const maxNodes = options.maxNodes ?? XML_MAX_NODES;
+    const maxCharacters = options.maxCharacters ?? XML_MAX_CHARACTERS;
+    const notes = [];
+    const roots = [];
+    const stack = [];
+    /** How many of each name are on `stack`: an orphan close costs O(1). */
+    const openNames = new Map();
+    /** Character data accumulated for the element currently open. */
+    const pending = [];
+    let cursor = 0;
+    let nodes = 0;
+    let spent = 0;
+    let stopped = false;
+    const spend = (length) => {
+        nodes += 1;
+        spent += length;
+        if (nodes > maxNodes || spent > maxCharacters) {
+            throw new InterchangeImportError(XML_READ_TOO_LARGE[1], {
+                messageKey: XML_READ_TOO_LARGE[0],
+            });
+        }
+    };
+    // A note quotes a name the file chose, and 140 KiB of faults used to make
+    // 20 000 notes and two billion characters, past what `JSON.stringify` takes
+    // (counter-review of 49aa247ce). So: a name is quoted to its first 64
+    // characters, and past XML_MAX_NOTES the rest are counted, not written.
+    let unlisted = 0;
+    const note = (line) => {
+        if (stopped)
+            return;
+        if (notes.length >= XML_MAX_NOTES) {
+            unlisted += 1;
+            return;
+        }
+        spend(0);
+        notes.push(line);
+        stopped = conformant;
+    };
+    const enter = (node) => {
+        stack.push(node);
+        openNames.set(node.name, (openNames.get(node.name) ?? 0) + 1);
+    };
+    const leave = () => {
+        const node = stack.pop();
+        openNames.set(node.name, (openNames.get(node.name) ?? 1) - 1);
+        return node;
+    };
+    /** Character data, kept for {@link XmlNode.text} and in order in `content`. */
+    const characters = (value) => {
+        if (value.length === 0)
+            return;
+        spend(value.length);
+        pending.push(value);
+        stack[stack.length - 1]?.content?.push({ kind: 'text', value });
+    };
+    /** Attach the text read since the last tag to whatever is open. */
+    const flushText = () => {
+        if (pending.length === 0)
+            return;
+        const text = pending.join('');
+        pending.length = 0;
+        const open = stack[stack.length - 1];
+        if (!open)
+            return;
+        // Whitespace between two indented children is layout, not content, and an
+        // element that held only that keeps no `text` at all — which is what lets a
+        // caller ask `if (node.text)` and mean "the file wrote something here".
+        if (!/\S/.test(text) && open.children.length > 0)
+            return;
+        if (!/\S/.test(text) && open.text === undefined)
+            return;
+        open.text = (open.text ?? '') + text;
+    };
+    const close = (node, end) => {
+        node.range[1] = end;
+        const parent = stack[stack.length - 1];
+        if (parent) {
+            parent.children.push(node);
+            parent.content?.push(node);
+        }
+        else {
+            if (conformant && roots.length === 1) {
+                note('This file has more than one top-level element.');
+            }
+            roots.push(node);
+        }
+    };
+    while (cursor < source.length && !stopped) {
+        const open = source.indexOf('<', cursor);
+        if (open < 0) {
+            characters(decodeXmlText(source.slice(cursor)));
+            break;
+        }
+        if (open > cursor)
+            characters(decodeXmlText(source.slice(cursor, open)));
+        /* ── The four things that are not an element ─────────────────────── */
+        if (source.startsWith('<!--', open)) {
+            const end = source.indexOf('-->', open + 4);
+            if (end < 0) {
+                note('A comment in this file is never closed; the rest was read.');
+                break;
+            }
+            const value = source.slice(open + 4, end);
+            spend(value.length);
+            stack[stack.length - 1]?.content?.push({ kind: 'comment', value });
+            cursor = end + 3;
+            continue;
+        }
+        if (source.startsWith('<![CDATA[', open)) {
+            const end = source.indexOf(']]>', open + 9);
+            if (end < 0) {
+                note('A CDATA section in this file is never closed.');
+                characters(source.slice(open + 9));
+                break;
+            }
+            // CDATA is character data with the escaping turned OFF, so it is pushed
+            // raw: decoding it would resolve a `&amp;` the author wrote literally.
+            characters(source.slice(open + 9, end));
+            cursor = end + 3;
+            continue;
+        }
+        if (source.startsWith('<?', open)) {
+            const end = source.indexOf('?>', open + 2);
+            if (end < 0) {
+                note('A processing instruction in this file is never closed.');
+                break;
+            }
+            const [, target = '', data = ''] = /^(\S*)\s*([\s\S]*)$/.exec(source.slice(open + 2, end)) ?? [];
+            spend(target.length + data.length);
+            stack[stack.length - 1]?.content?.push({ kind: 'pi', target, data });
+            cursor = end + 2;
+            continue;
+        }
+        if (source.startsWith('<!', open)) {
+            // A DOCTYPE, with or without an internal subset. The subset is skipped
+            // whole rather than parsed: this reader declares no entities, so what is
+            // in there could only change how a `&name;` it cannot resolve is read.
+            let scan = open + 2;
+            let depth = 0;
+            while (scan < source.length) {
+                const char = source[scan];
+                if (char === '[')
+                    depth += 1;
+                else if (char === ']')
+                    depth -= 1;
+                else if (char === '>' && depth <= 0)
+                    break;
+                scan += 1;
+            }
+            cursor = Math.min(scan + 1, source.length);
+            continue;
+        }
+        /* ── A close tag ─────────────────────────────────────────────────── */
+        if (source.startsWith('</', open)) {
+            const end = source.indexOf('>', open);
+            if (end < 0) {
+                note('A close tag in this file is never finished.');
+                break;
+            }
+            flushText();
+            const name = source.slice(open + 2, end).trim();
+            // Searched only when the name IS open, and then everything above the
+            // match is popped: linear overall, where `<a>`×N `</b>`×N was N².
+            const depth = openNames.get(name)
+                ? stack.findLastIndex(node => node.name === name)
+                : -1;
+            if (depth < 0) {
+                note(`</${shown(name)}> closes an element this file never opened; it was ignored.`);
+            }
+            else {
+                // Everything still open INSIDE the element being closed is closed with
+                // it, in order. `<a><b></a>` is a file that lost a tag, not a file with
+                // no `<b>` in it, and the tree keeps the `<b>`.
+                for (let index = stack.length - 1; index > depth; index -= 1) {
+                    const orphan = leave();
+                    note(`<${shown(orphan.name)}> is closed by </${shown(name)}> rather than by a tag of ` +
+                        `its own; it was read as far as it goes.`);
+                    close(orphan, open);
+                }
+                close(leave(), end + 1);
+            }
+            cursor = end + 1;
+            continue;
+        }
+        /* ── An open tag ─────────────────────────────────────────────────── */
+        let scan = open + 1;
+        while (scan < source.length && NAME_CHAR.test(source[scan]))
+            scan += 1;
+        const name = source.slice(open + 1, scan);
+        if (name.length === 0) {
+            // A bare `<` in character data — illegal, and every second hand-written
+            // file has one. It is kept as the character it is.
+            note('A "<" in this file starts no tag; it was read as a plain character.');
+            characters('<');
+            cursor = open + 1;
+            continue;
+        }
+        flushText();
+        spend(0);
+        const node = nodeOf(name, open);
+        /* ── Its attributes ──────────────────────────────────────────────── */
+        let selfClosing = false;
+        let tagEnd = source.length;
+        while (scan < source.length && !stopped) {
+            while (scan < source.length && /\s/.test(source[scan]))
+                scan += 1;
+            if (scan >= source.length)
+                break;
+            if (source.startsWith('/>', scan)) {
+                selfClosing = true;
+                tagEnd = scan + 2;
+                break;
+            }
+            if (source[scan] === '>') {
+                tagEnd = scan + 1;
+                break;
+            }
+            const attrStart = scan;
+            while (scan < source.length && NAME_CHAR.test(source[scan]))
+                scan += 1;
+            const attrName = source.slice(attrStart, scan);
+            if (attrName.length === 0) {
+                // Something that is neither a name, a `>` nor whitespace. Skipped one
+                // character at a time so the scan cannot stall on it.
+                scan += 1;
+                continue;
+            }
+            while (scan < source.length && /\s/.test(source[scan]))
+                scan += 1;
+            if (source[scan] !== '=') {
+                // A valueless attribute — HTML's habit, not XML's. Recorded as the
+                // empty string, which is what every tolerant reader does with one.
+                note(`The attribute "${shown(attrName)}" on <${shown(name)}> has no value; it was read ` +
+                    `as empty.`);
+                spend(0);
+                node.attrs[attrName] = '';
+                continue;
+            }
+            scan += 1;
+            while (scan < source.length && /\s/.test(source[scan]))
+                scan += 1;
+            const quote = source[scan];
+            let value = '';
+            if (quote === '"' || quote === "'") {
+                const end = source.indexOf(quote, scan + 1);
+                if (end < 0) {
+                    note(`The value of "${shown(attrName)}" on <${shown(name)}> is never closed; the ` +
+                        `rest of the file was read as its value.`);
+                    value = source.slice(scan + 1);
+                    scan = source.length;
+                }
+                else {
+                    value = source.slice(scan + 1, end);
+                    scan = end + 1;
+                }
+            }
+            else {
+                // Unquoted. Read to the next whitespace or tag end, which is the only
+                // reading available and the one every tolerant parser agrees on.
+                const start = scan;
+                while (scan < source.length && !/[\s>/]/.test(source[scan]))
+                    scan += 1;
+                value = source.slice(start, scan);
+                note(`The value of "${shown(attrName)}" on <${shown(name)}> is not quoted; it was read ` +
+                    `up to the next space.`);
+            }
+            // §3.3.3: literal whitespace normalizes BEFORE references decode, so a
+            // `&#10;` the writer escaped on purpose stays a newline.
+            const decoded = decodeXmlText(conformant ? value.replaceAll(/\r\n|[\t\n\r]/g, ' ') : value);
+            spend(decoded.length);
+            node.attrs[attrName] = decoded;
+        }
+        if (tagEnd === source.length && !selfClosing && source[scan] !== '>') {
+            note(`<${shown(name)}> is never finished; the file stops inside its tag.`);
+        }
+        if (selfClosing) {
+            close(node, tagEnd);
+        }
+        else {
+            enter(node);
+        }
+        cursor = tagEnd;
+    }
+    flushText();
+    // Whatever the file left open. Closed at the end of what there was, so the
+    // tree holds every element the file named even when it stops mid-document.
+    while (stack.length > 0) {
+        const orphan = leave();
+        note(`<${shown(orphan.name)}> is never closed; it was read to the end.`);
+        close(orphan, source.length);
+    }
+    if (unlisted > 0) {
+        notes.push(`+${unlisted} more problems of the kinds above were not listed.`);
+    }
+    return { root: roots[0], roots, notes };
+}
+/* ── Getting back out ─────────────────────────────────────────────────── */
+/**
+ * The element's own bytes, from the string it was read from.
+ *
+ * This is what a quarantined fragment is (ADR 0012 D5): the file's text, not a
+ * re-rendering of this reader's tree. Comments, attribute order, prefixes and
+ * whitespace all survive, because none of them was ever taken apart.
+ */
+export function xmlFragmentOf(source, node) {
+    return source.slice(node.range[0], node.range[1]);
+}
+/** The three characters that would otherwise start markup. */
+function escapeText(value) {
+    return value
+        .replaceAll('&', '&amp;')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;');
+}
+/** An attribute value — see `xml.ts`, whose escaping this mirrors exactly. */
+function escapeAttr(value) {
+    return escapeText(value)
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&apos;')
+        .replaceAll('\n', '&#10;')
+        .replaceAll('\r', '&#13;')
+        .replaceAll('\t', '&#9;');
+}
+/**
+ * A node back as XML, from the TREE rather than from the source.
+ *
+ * The fallback for a fragment that has no range to slice — one assembled by a
+ * caller, or read out of a document this function's caller no longer holds. It
+ * is faithful to what the tree records and therefore drops what the tree does
+ * not: comments, processing instructions, and the file's own indentation.
+ * Prefer {@link xmlFragmentOf} whenever the source string is still in hand.
+ */
+export function serializeXmlNode(node) {
+    // A stack of nodes still to open and close tags still to write: a tree as
+    // deep as its author chose costs a loop, not the call stack.
+    const out = [];
+    const stack = [node];
+    while (stack.length > 0) {
+        const next = stack.pop();
+        if (typeof next === 'string') {
+            out.push(next);
+            continue;
+        }
+        const attrs = Object.entries(next.attrs)
+            .map(([key, value]) => ` ${key}="${escapeAttr(value)}"`)
+            .join('');
+        const text = next.text === undefined ? '' : escapeText(next.text);
+        if (text.length === 0 && next.children.length === 0) {
+            out.push(`<${next.name}${attrs}/>`);
+            continue;
+        }
+        out.push(`<${next.name}${attrs}>`, text);
+        stack.push(`</${next.name}>`);
+        for (let index = next.children.length - 1; index >= 0; index -= 1) {
+            stack.push(next.children[index]);
+        }
+    }
+    return out.join('');
+}
+/* ── Reading a tree ───────────────────────────────────────────────────── */
+/** Children with this local name, whatever prefix the file gave them. */
+export function xmlChildren(node, local) {
+    return node.children.filter(child => child.local === local);
+}
+/** The first child with this local name, if any. */
+export function xmlChild(node, local) {
+    return node.children.find(child => child.local === local);
+}
+/**
+ * An attribute by LOCAL name — `xmi:id`, `xmi:ID` and a bare `id` all answer.
+ *
+ * Prefix-insensitive on purpose, and it is the difference between reading three
+ * tools and reading one: the XMI prefix is `xmi` by convention and by nothing
+ * else, Enterprise Architect has shipped files under `XMI`, and an
+ * attribute-defaulted file drops it altogether. The QUALIFIED name is still in
+ * `attrs` for anything that needs it, and {@link xmlFragmentOf} still writes
+ * back what the file said.
+ *
+ * The first match in document order wins, which only matters for a file that
+ * spells the same attribute twice under two prefixes.
+ */
+export function xmlAttr(node, local) {
+    const direct = node.attrs[local];
+    if (direct !== undefined)
+        return direct;
+    for (const [key, value] of Object.entries(node.attrs)) {
+        if (splitName(key).local === local)
+            return value;
+    }
+    return undefined;
+}
+/** Every `xmlns` / `xmlns:*` declaration on this element, by prefix (`''`). */
+export function xmlNamespaces(node) {
+    const declarations = {};
+    for (const [key, value] of Object.entries(node.attrs)) {
+        if (key === 'xmlns')
+            declarations[''] = value;
+        else if (key.startsWith('xmlns:'))
+            declarations[key.slice(6)] = value;
+    }
+    return declarations;
+}
+/**
+ * Every element under `node`, at any depth, in document order.
+ *
+ * An explicit stack rather than recursion: the depth of a file is whatever its
+ * author chose, and a hostile one nested a hundred thousand deep must cost a
+ * loop, not the call stack.
+ */
+export function xmlDescendants(node) {
+    const found = [];
+    const stack = [...node.children].reverse();
+    while (stack.length > 0) {
+        const next = stack.pop();
+        found.push(next);
+        for (let index = next.children.length - 1; index >= 0; index -= 1) {
+            stack.push(next.children[index]);
+        }
+    }
+    return found;
+}

package/dist/_pkgs/affine-block-surface/framework-background/def.js

@@ -1,4 +1,4 @@
-import { NOTATION_NEUTRALS } from '../../affine-shared/consts/index.js';
+import { NOTATION_NEUTRALS } from '../../affine-shared/headless.js';
 /**
  * The default card: a plain rectangle in the shared notation scale's card
  * fill, no border, no radius.

package/dist/_pkgs/affine-block-surface/index.d.ts

@@ -4,6 +4,7 @@ export { SurfaceElementModel, SurfaceGroupLikeModel, } from './element-model/bas
 export { CanvasElementType } from './element-model/index.js';
 export { CanvasRenderer } from './renderer/canvas-renderer.js';
 export { DomRenderer } from './renderer/dom-renderer.js';
+export { isPainted } from './renderer/paint-predicate.js';
 export { ElementHighlightOverlay } from './renderer/element-highlight-overlay.js';
 export type { ElementRenderer } from './renderer/elements/index.js';
 export * from './renderer/elements/type.js';

package/dist/_pkgs/affine-block-surface/index.js

@@ -6,6 +6,7 @@ export { SurfaceElementModel, SurfaceGroupLikeModel, } from './element-model/bas
 export { CanvasElementType } from './element-model/index.js';
 export { CanvasRenderer } from './renderer/canvas-renderer.js';
 export { DomRenderer } from './renderer/dom-renderer.js';
+export { isPainted } from './renderer/paint-predicate.js';
 export { ElementHighlightOverlay } from './renderer/element-highlight-overlay.js';
 export * from './renderer/elements/type.js';
 export { Overlay, OverlayIdentifier } from './renderer/overlay.js';

package/dist/_pkgs/affine-block-surface/interchange-headless.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `@labre/affine-block-surface/interchange` — the interchange platform with no
+ * editor behind it (ADR 0012, P3 as amended 2026-10-14).
+ *
+ * The registry's types and helpers, `InterchangeImportError`, the generic SVG
+ * reader, the framework-background geometry and the constants a framework's
+ * reader shares with the editor. What
+ * is NOT here is the point: the graph of this entry imports no Lit, no
+ * `@atlaskit/pragmatic-drag-and-drop`, no `@labre/std` runtime and no block —
+ * so a server (the labre import function, labre-mcp) loads the readers in a
+ * few hundred kilobytes instead of the whole editor.
+ *
+ * Held by `interchange-headless.unit.spec.ts` in `packages/affine/all`, which
+ * bundles this entry and every framework's `./interchange` and fails on any
+ * forbidden module in the graph. A new export here is a new edge in that
+ * graph: import it from a file that is itself editor-free, never from the
+ * package index.
+ */
+export * from './extensions/export-svg/marker-version.js';
+export * from './extensions/interchange.js';
+export * from './extensions/legend-role.js';
+export * from './extensions/svg-sanitize.js';
+export * from './extensions/svg-sketch.js';
+export * from './extensions/svg-sketch-translations.js';
+export * from './extensions/xml-element.js';
+export * from './extensions/xml-reader.js';
+export * from './framework-background/def.js';
+export * from './framework-background/facts.js';
+export * from './framework-background/labels.js';

package/dist/_pkgs/affine-block-surface/interchange-headless.js

@@ -0,0 +1,32 @@
+/**
+ * `@labre/affine-block-surface/interchange` — the interchange platform with no
+ * editor behind it (ADR 0012, P3 as amended 2026-10-14).
+ *
+ * The registry's types and helpers, `InterchangeImportError`, the generic SVG
+ * reader, the framework-background geometry and the constants a framework's
+ * reader shares with the editor. What
+ * is NOT here is the point: the graph of this entry imports no Lit, no
+ * `@atlaskit/pragmatic-drag-and-drop`, no `@labre/std` runtime and no block —
+ * so a server (the labre import function, labre-mcp) loads the readers in a
+ * few hundred kilobytes instead of the whole editor.
+ *
+ * Held by `interchange-headless.unit.spec.ts` in `packages/affine/all`, which
+ * bundles this entry and every framework's `./interchange` and fails on any
+ * forbidden module in the graph. A new export here is a new edge in that
+ * graph: import it from a file that is itself editor-free, never from the
+ * package index.
+ */
+export * from './extensions/export-svg/marker-version.js';
+export * from './extensions/interchange.js';
+export * from './extensions/legend-role.js';
+export * from './extensions/svg-sanitize.js';
+export * from './extensions/svg-sketch.js';
+export * from './extensions/svg-sketch-translations.js';
+export * from './extensions/xml-element.js';
+export * from './extensions/xml-reader.js';
+// The board geometry an exporter and a reader both compute with: a
+// background's declaration, its plot and its instance zones. Pure data and
+// arithmetic, editor-free like the rest.
+export * from './framework-background/def.js';
+export * from './framework-background/facts.js';
+export * from './framework-background/labels.js';