@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/schema/child-spans.js

@@ -1,20 +1,18 @@
 /**
  * Byte offsets of each child's rendered region inside its container's own `raw`, so a typing
- * rewrite splices one region instead of re-joining every child (O(1) reads through the `$state`
- * proxy rather than O(children)). Bookkeeping, never bytes: nothing serializes or renders it, and
- * a span the invalidation seams missed fails the region check below and falls back to the full
- * rebuild. A `Uint32Array` on purpose — Svelte proxies plain arrays, and the shift would mint a
- * source per element.
+ * rewrite replaces one region instead of re-joining every child. Bookkeeping only: a span left
+ * stale fails the region check below and falls back to the full rebuild. A `Uint32Array` because
+ * Svelte proxies plain arrays, one reactive source per element.
  */
-import { DEV } from 'esm-env';
+import { isDevChecks } from '../env';
 import { makeBlockNode } from '../core/nodes';
 import { assertInvariant } from '../assert';
 import { perfEnabled } from '../perf/instruments';
 import { concatChildren } from '../core/serializer';
-import { splitLines } from '../core/lines';
-/** Drop the spans a children-shape change invalidated; the next full rebuild reseeds them. */
+import { isBlankLine, splitLines } from '../core/lines';
+/** Drop the spans a change to the children invalidated; the next full rebuild recomputes them. */
 export function dropChildSpans(node) {
-    // Tested, not assigned blind: a bare write would mint the field on every node it passes.
+    // Checked before writing: an unconditional write would add the field to every node passed in.
     if (node.childSpans)
         node.childSpans = undefined;
 }
@@ -30,7 +28,7 @@ export function rebuildConcatRaw(node, changed) {
     const spans = new Uint32Array(children.length * 2);
     let out = '';
     for (let i = 0; i < children.length; i++) {
-        // One indexed read per child: the array is a `$state` proxy and each one is a trap.
+        // One indexed read per child: the array is a `$state` proxy, so every read is a proxy trap.
         const child = children[i];
         spans[i * 2] = out.length;
         out += child.leadingTrivia + child.raw;
@@ -40,65 +38,93 @@ export function rebuildConcatRaw(node, changed) {
     node.childSpans = spans;
 }
 /**
- * A container whose raw re-prefixes every line of its body (blockquote, list item). `innerPrefix`
- * is unread: these kinds open their body on their own first line, so no parse fills it (G1.5).
+ * A container whose raw re-prefixes every line of its body (blockquote, list item). Its body opens
+ * on its own first line, so no parse fills `innerPrefix` and it is not read here (G1.5).
  */
 export function rebuildStripRaw(node, prefix, changed) {
     const children = node.children;
-    const render = (text, first) => renderPrefixed(text, prefix, first);
+    // A separator line stays bare, as the parser reads it. A blank line that belongs to a leaf and
+    // ends the body keeps the body's indent, or a reload would read it as outside the container.
+    const render = (trivia, raw, first, tailIsBlank, leaf) => {
+        const separators = renderPrefixed(trivia, prefix, first, () => false);
+        return (separators +
+            renderPrefixed(raw, prefix, first && separators === '', () => leaf && tailIsBlank()));
+    };
     if (changed &&
         spliceChildRegion(node, children, changed, render) &&
         spliceIsFaithful(node, (scratch) => rebuildStripRaw(scratch, prefix))) {
         return;
     }
+    // One indexed read per child: the array is a `$state` proxy, so every read is a proxy trap.
+    const parts = children.map((child) => ({
+        trivia: child.leadingTrivia,
+        raw: child.raw,
+        leaf: child.children === undefined
+    }));
+    const suffix = node.innerSuffix ?? '';
+    // Every child from `blankTail` on, and the suffix, holds whitespace only.
+    let blankTail = parts.length;
+    if (isWhitespaceOnly(suffix)) {
+        while (blankTail > 0 && isWhitespaceOnly(parts[blankTail - 1].raw))
+            blankTail--;
+    }
+    else {
+        blankTail = parts.length + 1;
+    }
     const spans = new Uint32Array(children.length * 2);
     let out = '';
     // A child ending mid-line shares that line with whatever follows, so the two would be
     // prefixed separately: the whole-body rebuild is the only faithful answer for that shape.
     let openLine = false;
-    for (let i = 0; i < children.length; i++) {
-        const child = children[i];
-        const text = child.leadingTrivia + child.raw;
+    for (let i = 0; i < parts.length; i++) {
+        const { trivia, raw, leaf } = parts[i];
+        const text = trivia + raw;
         if (openLine && text !== '')
             return rebuildWholeStrip(node, prefix);
         spans[i * 2] = out.length;
-        out += render(text, out.length === 0);
+        out += render(trivia, raw, out.length === 0, () => blankTail <= i + 1, leaf);
         spans[i * 2 + 1] = out.length;
         if (text !== '')
             openLine = !text.endsWith('\n');
     }
-    const suffix = node.innerSuffix ?? '';
     if (suffix !== '') {
         if (openLine)
             return rebuildWholeStrip(node, prefix);
-        out += render(suffix, out.length === 0);
+        out += renderPrefixed(suffix, prefix, out.length === 0, () => true);
     }
     node.raw = out;
     node.childSpans = spans;
 }
 function rebuildWholeStrip(node, prefix) {
     node.childSpans = undefined;
-    node.raw = renderPrefixed(concatChildren(node.children) + (node.innerSuffix ?? ''), prefix, true);
+    node.raw = renderPrefixed(concatChildren(node.children) + (node.innerSuffix ?? ''), prefix, true, () => true);
 }
 // ── Rendering ────────────────────────────────────────────────────────────────
-const renderVerbatim = (text) => text;
-function renderPrefixed(text, prefix, first) {
+const renderVerbatim = (trivia, raw) => trivia + raw;
+const isWhitespaceOnly = (text) => !/[^ \t\r\n]/.test(text);
+/** `inBlankTail` says whether the blank lines after the text's last content line end the body;
+ *  it is asked only when there are some, since answering can read every later sibling. */
+function renderPrefixed(text, prefix, first, inBlankTail) {
     if (text === '')
         return '';
     let out = '';
     const lines = splitLines(text);
+    let lastContent = lines.length - 1;
+    while (lastContent >= 0 && isBlankLine(lines[lastContent].text))
+        lastContent--;
+    const endsBlank = lastContent < lines.length - 1 && inBlankTail();
     for (let i = 0; i < lines.length; i++) {
-        out += prefix(lines[i].text, first && i === 0) + lines[i].lineEnding;
+        const line = lines[i];
+        out += prefix(line.text, first && i === 0, endsBlank && i > lastContent) + line.lineEnding;
     }
     return out;
 }
 /**
- * G1.38: re-derives the whole raw on a scratch and refuses a splice that disagrees, so a sibling's
- * bytes moving under the spans cannot ship. Dev only, and off under the perf instruments, whose
- * numbers would otherwise be measuring this.
+ * A dev-only comparison with a full rebuild on a scratch node, so a sibling's bytes moving under the
+ * spans cannot reach the document (G1.38). Skipped under the perf instruments, which would time it.
  */
 function spliceIsFaithful(node, rebuildFull) {
-    if (!DEV || perfEnabled())
+    if (!isDevChecks() || perfEnabled())
         return true;
     const scratch = makeBlockNode({
         kind: node.kind,
@@ -121,9 +147,8 @@ function spliceIsFaithful(node, rebuildFull) {
 }
 // ── The splice ───────────────────────────────────────────────────────────────
 /**
- * Rewrite one child's region in place, or decline so the caller reseeds. Declines cover every
- * way the spans can have stopped describing `raw`: the region check is what turns a span the
- * invalidation seams missed into a slower rebuild instead of a corruption.
+ * Rewrite one child's region in place, or decline so the caller rebuilds from scratch: a span that
+ * stopped describing `raw` costs a slower rebuild, never corrupted bytes.
  */
 function spliceChildRegion(node, children, changed, render) {
     const spans = node.childSpans;
@@ -139,12 +164,21 @@ function spliceChildRegion(node, children, changed, render) {
         return false;
     const first = start === 0;
     const trivia = child.leadingTrivia;
-    if (raw.slice(start, end) !== render(trivia + changed.previousRaw, first))
+    // A child turning blank, or back, decides whether the empty blocks before it end the body.
+    if (isWhitespaceOnly(changed.previousRaw) !== isWhitespaceOnly(child.raw))
         return false;
-    const rendered = render(trivia + child.raw, first);
+    const tailIsBlank = () => isWhitespaceOnly(node.innerSuffix ?? '') &&
+        children
+            .slice(changed.index + 1)
+            .every((later) => isWhitespaceOnly(later.leadingTrivia + later.raw));
+    const leaf = child.children === undefined;
+    if (raw.slice(start, end) !== render(trivia, changed.previousRaw, first, tailIsBlank, leaf)) {
+        return false;
+    }
+    const rendered = render(trivia, child.raw, first, tailIsBlank, leaf);
     if (end < raw.length) {
-        // Nothing may reach across the regions that follow: a body running past its own last
-        // line ending would share it, and an emptied opening region hands line 0 to the next child.
+        // Nothing may run into the regions that follow: a child not ending in a line ending would
+        // share its last line, and an emptied first region hands line 0 to the next child.
         if (rendered !== '' && !rendered.endsWith('\n'))
             return false;
         if (first && end > start !== (rendered !== ''))

package/dist/schema/closure.d.ts

@@ -1,12 +1,15 @@
 /**
- * The tier × subsystem closure matrix as a type: every block-kind registration carries a
- * `ClosureBlock`, so a blank cell is a compile error (`docs/design/plugin-contract.md` § "Editable
- * content and the closure matrix"). Dependency-free leaf — `core/directive/kinds.ts` imports
- * it, so it must not import back toward core. Honesty rule (coherence-checked by G1.24):
- * `implemented` names a real mechanism; never claim a capability to fill a cell.
+ * The closure matrix as a type: what each block kind does about each cross-cutting system, so a
+ * blank cell is a compile error
+ * (`docs/design/plugin-contract.md` § Editable content and the closure matrix). An `implemented`
+ * cell must name a real mechanism (G1.24). This file imports nothing: `core/directive/kinds.ts`
+ * imports it.
  */
-/** The cross-cutting systems a caret-bearing kind meets — one per matrix column. */
+/** The cross-cutting systems a kind with a caret has to answer for, one per matrix column. */
 export type ClosureColumn = 'roundTrip' | 'focus' | 'mergeBackspace' | 'selectionPaint' | 'searchPaint' | 'reorder' | 'undo' | 'clipboard' | 'simOracle';
+/** Every column once, so a loop over the matrix misses none: a new column fails to compile here
+ *  until it's listed. */
+export declare const CLOSURE_COLUMNS: Record<ClosureColumn, true>;
 export type ClosureCell = {
     mode: 'implemented';
     via: string;
@@ -16,24 +19,23 @@ export type ClosureCell = {
     mode: 'not-supported';
     reason: string;
 };
-/** `Record<ClosureColumn, …>` — a missing column is a compile error. */
+/** `Record<ClosureColumn, …>`: a missing column is a compile error. */
 export type ClosureBlock = Record<ClosureColumn, ClosureCell>;
 /**
- * `focus`, `searchPaint`, `undo`, and `simOracle` genuinely vary with the leaf's own component,
- * so `simpleLeafClosure` requires them — the matrix's force-an-answer discipline kept exactly
- * where the answer is the author's. The five baked columns stay optionally overridable.
+ * `focus`, `searchPaint`, `undo` and `simOracle` really do vary with the leaf's own component, so
+ * `simpleLeafClosure` requires them: the matrix forces an answer exactly where the answer is the
+ * author's. The five fixed columns can still be overridden.
  */
 export type SimpleLeafClosureCells = Pick<ClosureBlock, 'focus' | 'searchPaint' | 'undo' | 'simOracle'> & Partial<Pick<ClosureBlock, 'roundTrip' | 'mergeBackspace' | 'selectionPaint' | 'reorder' | 'clipboard'>>;
-/** Sugar over the same required `closure` field: bakes the five structurally-fixed leaf columns, demands the four the author's component determines. */
+/** Fills in the five fixed leaf columns and requires the four the author's component decides. */
 export declare function simpleLeafClosure(cells: SimpleLeafClosureCells): ClosureBlock;
 /**
- * `roundTrip` is `implemented` for any container (its `rebuildRaw` IS the mechanism, G1.24), so
- * the preset bakes the mode and demands only its `via`, making the inherit-default violation
- * unrepresentable here. `focus`/`mergeBackspace`/`undo`/`simOracle` vary with the container, so
- * they are required; the four structural columns stay overridable.
+ * A container's `rebuildRaw` is its round-trip mechanism, so the preset fixes `roundTrip` to
+ * `implemented` and asks only for its `via` (G1.24). The cells that vary with the container are
+ * required; the four structural columns stay overridable.
  */
 export type ContainerClosureCells = {
     roundTripVia: string;
 } & Pick<ClosureBlock, 'focus' | 'mergeBackspace' | 'undo' | 'simOracle'> & Partial<Pick<ClosureBlock, 'selectionPaint' | 'searchPaint' | 'reorder' | 'clipboard'>>;
-/** Sugar over the same required `closure` field: bakes the four structural strip-container columns and `roundTrip: implemented`, demands the container-specific cells. */
+/** Fills in the structural columns and `roundTrip: implemented`; requires the container's cells. */
 export declare function containerClosure(cells: ContainerClosureCells): ClosureBlock;

package/dist/schema/closure.js

@@ -1,16 +1,27 @@
 /**
- * The tier × subsystem closure matrix as a type: every block-kind registration carries a
- * `ClosureBlock`, so a blank cell is a compile error (`docs/design/plugin-contract.md` § "Editable
- * content and the closure matrix"). Dependency-free leaf — `core/directive/kinds.ts` imports
- * it, so it must not import back toward core. Honesty rule (coherence-checked by G1.24):
- * `implemented` names a real mechanism; never claim a capability to fill a cell.
+ * The closure matrix as a type: what each block kind does about each cross-cutting system, so a
+ * blank cell is a compile error
+ * (`docs/design/plugin-contract.md` § Editable content and the closure matrix). An `implemented`
+ * cell must name a real mechanism (G1.24). This file imports nothing: `core/directive/kinds.ts`
+ * imports it.
  */
+/** Every column once, so a loop over the matrix misses none: a new column fails to compile here
+ *  until it's listed. */
+export const CLOSURE_COLUMNS = {
+    roundTrip: true,
+    focus: true,
+    mergeBackspace: true,
+    selectionPaint: true,
+    searchPaint: true,
+    reorder: true,
+    undo: true,
+    clipboard: true,
+    simOracle: true
+};
 // ── Simple-leaf preset ──────────────────────────────────────────────────────
 /**
- * The five columns every not-mergeable, childless, source-editable `createEditableLeaf` leaf
- * answers identically — structurally fixed, so re-typing them teaches an author nothing.
- * NOT for containers (G1.24 forces `roundTrip: implemented` on them) nor whole-block-focus
- * opaque leaves (they paint a cover rect, not partial rects); those hand-write every column.
+ * The five columns every not-mergeable, childless, source-editable leaf answers alike. A container
+ * (its `roundTrip` must be `implemented`, G1.24) or a whole-block leaf writes every column itself.
  */
 const SIMPLE_LEAF_BAKED = {
     roundTrip: { mode: 'inherit-default' },
@@ -22,15 +33,14 @@ const SIMPLE_LEAF_BAKED = {
     reorder: { mode: 'implemented', via: 'whole-block drag reorder through the parent BlockList' },
     clipboard: { mode: 'inherit-default' }
 };
-/** Sugar over the same required `closure` field: bakes the five structurally-fixed leaf columns, demands the four the author's component determines. */
+/** Fills in the five fixed leaf columns and requires the four the author's component decides. */
 export function simpleLeafClosure(cells) {
     return { ...SIMPLE_LEAF_BAKED, ...cells };
 }
 // ── Strip-container preset ────────────────────────────────────────────────────
 /**
- * The four columns every strip container answers the same structural way: its children are the
- * paint and search surfaces, it reorders whole-block through the parent BlockList, and it holds
- * no clipboard anchor of its own. `reorder`/`clipboard` stay overridable below.
+ * The four columns every strip container answers alike: its children paint selection and search,
+ * it reorders whole through the parent BlockList, and it holds no clipboard position of its own.
  */
 const STRIP_CONTAINER_BAKED = {
     selectionPaint: {
@@ -44,7 +54,7 @@ const STRIP_CONTAINER_BAKED = {
     reorder: { mode: 'implemented', via: 'whole-block reorder through the parent BlockList' },
     clipboard: { mode: 'inherit-default' }
 };
-/** Sugar over the same required `closure` field: bakes the four structural strip-container columns and `roundTrip: implemented`, demands the container-specific cells. */
+/** Fills in the structural columns and `roundTrip: implemented`; requires the container's cells. */
 export function containerClosure(cells) {
     const { roundTripVia, ...rest } = cells;
     return {

package/dist/schema/command-id.d.ts

@@ -1,7 +1,7 @@
 /**
- * Plugin command-id brand + mint, mirroring the `PluginBlockKind` brand (core/nodes): a minted
- * id is a plain branded string, so built-in `CommandId` switches stay exhaustive while the
- * block-command registry keys plugin ids. Register-once.
+ * The plugin command id: a branded string created by `mintCommandId`, mirroring the
+ * `PluginBlockKind` brand in `core/nodes`. Built-in `CommandId` switches stay exhaustive while
+ * the block-command registry keys plugin ids. Register-once.
  */
 import { type CommandId } from './commands';
 declare const PluginCommandIdBrand: unique symbol;
@@ -10,11 +10,9 @@ export type PluginCommandId = string & {
 };
 export type AnyCommandId = CommandId | PluginCommandId;
 /**
- * Mint (or resolve) a plugin command id; `owner` is the installing plugin. The mint is
- * name-global but dispatch is kind-scoped, so the same owner re-minting a name returns the
- * existing brand; a different plugin (or an unattributed re-mint) throws, naming the prior owner.
+ * Names are global, so the plugin that created a name gets the same id when it asks again, while
+ * a different plugin or a call outside any install throws, naming the prior owner.
  */
-export declare function mintCommandId(name: string, owner?: string | null): PluginCommandId;
+export declare function mintCommandId(name: string): PluginCommandId;
 export declare function isPluginCommandId(id: string): id is PluginCommandId;
-export declare function __resetMintedCommandIdsForTests(): void;
 export {};

package/dist/schema/command-id.js

@@ -1,42 +1,37 @@
 /**
- * Plugin command-id brand + mint, mirroring the `PluginBlockKind` brand (core/nodes): a minted
- * id is a plain branded string, so built-in `CommandId` switches stay exhaustive while the
- * block-command registry keys plugin ids. Register-once.
+ * The plugin command id: a branded string created by `mintCommandId`, mirroring the
+ * `PluginBlockKind` brand in `core/nodes`. Built-in `CommandId` switches stay exhaustive while
+ * the block-command registry keys plugin ids. Register-once.
  */
 import { isBuiltinCommandId } from './commands';
-import { devReplacesRegistration } from './register-once';
+import { currentInstallingPlugin } from './plugin-install';
+import { createPluginRegistry } from './plugin-registry';
 const NAME_PATTERN = /^[a-z][a-zA-Z0-9-]*(\.[a-z][a-zA-Z0-9-]*)*$/;
-// name → installing plugin at mint time (null when minted outside an install). The owner
-// distinguishes a legitimate same-plugin re-mint from a cross-plugin collision.
-const mintedCommandIds = new Map();
+// The owner is the plugin installing when the id was created, which tells a plugin re-creating
+// its own id apart from a cross-plugin collision.
+const mintedCommandIds = createPluginRegistry({
+    label: 'mintCommandId',
+    isBuiltin: () => false
+});
 /**
- * Mint (or resolve) a plugin command id; `owner` is the installing plugin. The mint is
- * name-global but dispatch is kind-scoped, so the same owner re-minting a name returns the
- * existing brand; a different plugin (or an unattributed re-mint) throws, naming the prior owner.
+ * Names are global, so the plugin that created a name gets the same id when it asks again, while
+ * a different plugin or a call outside any install throws, naming the prior owner.
  */
-export function mintCommandId(name, owner = null) {
+export function mintCommandId(name) {
     if (!NAME_PATTERN.test(name)) {
-        throw new Error(`mintCommandId: invalid command name "${name}" — lowercase-first dot-separated segments of letters, digits, and hyphens`);
+        throw new Error(`mintCommandId: invalid command name "${name}"; lowercase-first dot-separated segments of letters, digits, and hyphens`);
     }
     if (isBuiltinCommandId(name)) {
         throw new Error(`mintCommandId: "${name}" is a built-in command id`);
     }
-    if (mintedCommandIds.has(name)) {
-        const priorOwner = mintedCommandIds.get(name) ?? null;
-        if (owner !== null && owner === priorOwner)
-            return name;
-        // Dev re-eval (HMR/SSR) re-mints a plugin's own id; return the existing brand
-        // rather than 500 the route. Production/test keep the collision throw.
-        if (devReplacesRegistration())
-            return name;
-        throw new Error(`mintCommandId: "${name}" was already minted by ${priorOwner ? `plugin "${priorOwner}"` : 'another registration'}`);
+    const owner = currentInstallingPlugin();
+    const priorOwner = mintedCommandIds.ownerOf(name);
+    if (mintedCommandIds.has(name) && owner !== null && owner === priorOwner) {
+        return name;
     }
-    mintedCommandIds.set(name, owner);
+    mintedCommandIds.register(name, true, `mintCommandId: "${name}" was already taken by ${priorOwner ? `plugin "${priorOwner}"` : 'another registration'}`);
     return name;
 }
 export function isPluginCommandId(id) {
     return mintedCommandIds.has(id);
 }
-export function __resetMintedCommandIdsForTests() {
-    mintedCommandIds.clear();
-}