@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/schema/plugin-kind.js

@@ -1,14 +1,20 @@
+/**
+ * Declaring the names plugin kinds take, block and inline, and which plugin declared each: a
+ * kind's owner is the plugin whose setup declared it, and it decides where the kind resolves.
+ */
 import { BLOCK_KIND_TABLE, isBuiltinInlineKind } from '../core/nodes';
-import { currentInstallingPlugin, pluginKindOwner, recordPluginKindOwner } from './plugin-install';
 import { isValidPluginName } from './plugin-name';
-import { devReplacesRegistration } from './register-once';
-const declaredPluginKinds = new Set();
-// Structural sentinels a plugin kind must not shadow: `document` is `Document.kind` and
-// `global` is the keybinding-override scope, so neither is in BLOCK_KIND_TABLE below.
+import { createPluginRegistry } from './plugin-registry';
+const declaredPluginKinds = createPluginRegistry({
+    label: 'declarePluginKind',
+    isBuiltin: () => false
+});
+// Names a plugin kind must not take: `document` is `Document.kind` and `global` is the
+// keybinding-override scope, so neither appears in `BLOCK_KIND_TABLE`.
 const RESERVED_KIND_NAMES = new Set(['document', 'global']);
 export function declarePluginKind(name) {
     if (!isValidPluginName(name)) {
-        throw new Error(`declarePluginKind: invalid kind name "${name}" — lowercase first letter, then letters/digits/hyphens`);
+        throw new Error(`declarePluginKind: invalid kind name "${name}"; lowercase first letter, then letters/digits/hyphens`);
     }
     if (name in BLOCK_KIND_TABLE) {
         throw new Error(`declarePluginKind: "${name}" is a built-in BlockKind`);
@@ -16,71 +22,58 @@ export function declarePluginKind(name) {
     if (RESERVED_KIND_NAMES.has(name)) {
         throw new Error(`declarePluginKind: "${name}" is a reserved structural sentinel`);
     }
-    if (declaredPluginKinds.has(name)) {
-        // Dev re-eval (HMR/SSR) re-declares a plugin's own kind; return the existing
-        // brand rather than 500 the route. Production/test keep the collision throw.
-        if (devReplacesRegistration())
-            return name;
-        const owner = pluginKindOwner(name);
-        throw new Error(`declarePluginKind: "${name}" was already declared by another plugin` +
-            (owner ? ` — first declared by plugin '${owner}'` : ''));
-    }
-    declaredPluginKinds.add(name);
-    const installer = currentInstallingPlugin();
-    if (installer)
-        recordPluginKindOwner(name, installer);
+    const owner = declaredPluginKinds.ownerOf(name);
+    declaredPluginKinds.register(name, true, `declarePluginKind: "${name}" was already declared by another plugin` +
+        (owner ? ` — first declared by plugin '${owner}'` : ''));
     return name;
 }
+/** The plugin whose setup declared `kind`; null for a built-in or a kind declared outside one. */
+export function pluginKindOwner(kind) {
+    return declaredPluginKinds.ownerOf(kind);
+}
 /**
- * Recover the branded kind for an already-declared name, so a module that didn't mint it reaches
- * the brand without an unchecked cast. Throws for an undeclared name, so a typo can't silently
- * register against a kind that doesn't exist.
+ * The branded kind for a declared name, without an unchecked cast. Throws for an undeclared name,
+ * so a typo cannot quietly register against a kind that does not exist.
  */
 export function declaredPluginKind(name) {
     if (!declaredPluginKinds.has(name)) {
-        throw new Error(`declaredPluginKind: "${name}" has not been declared — call declarePluginKind first`);
+        throw new Error(`declaredPluginKind: "${name}" has not been declared; call declarePluginKind first`);
     }
     return name;
 }
 /**
- * Non-throwing declaration probe, so an idempotent module (HMR, a re-imported registrar) asks
- * before declaring instead of catching {@link declarePluginKind}'s or {@link declaredPluginKind}'s
- * throw.
+ * A module that may run twice (hot reload, a re-imported registration) asks this first instead of
+ * catching {@link declarePluginKind}'s or {@link declaredPluginKind}'s throw.
  */
 export function isBlockKindDeclared(name) {
     return declaredPluginKinds.has(name);
 }
-export function __clearDeclaredPluginKindsForTests() {
-    declaredPluginKinds.clear();
-}
-const declaredPluginInlineKinds = new Set();
+const declaredPluginInlineKinds = createPluginRegistry({
+    label: 'declarePluginInlineKind',
+    isBuiltin: () => false
+});
 export function declarePluginInlineKind(name) {
     if (!isValidPluginName(name)) {
-        throw new Error(`declarePluginInlineKind: invalid kind name "${name}" — lowercase first letter, then letters/digits/hyphens`);
+        throw new Error(`declarePluginInlineKind: invalid kind name "${name}"; lowercase first letter, then letters/digits/hyphens`);
     }
     if (isBuiltinInlineKind(name)) {
         throw new Error(`declarePluginInlineKind: "${name}" is a built-in InlineNodeKind`);
     }
-    if (declaredPluginInlineKinds.has(name)) {
-        // Dev re-eval survival — see declarePluginKind. Production/test keep the throw.
-        if (devReplacesRegistration())
-            return name;
-        throw new Error(`declarePluginInlineKind: "${name}" was already declared by another plugin`);
-    }
-    declaredPluginInlineKinds.add(name);
+    declaredPluginInlineKinds.register(name, true, `declarePluginInlineKind: "${name}" was already declared by another plugin`);
     return name;
 }
 /** The inline mirror of {@link declaredPluginKind}; throws for an undeclared name. */
 export function declaredPluginInlineKind(name) {
     if (!declaredPluginInlineKinds.has(name)) {
-        throw new Error(`declaredPluginInlineKind: "${name}" has not been declared — call declarePluginInlineKind first`);
+        throw new Error(`declaredPluginInlineKind: "${name}" has not been declared; call declarePluginInlineKind first`);
     }
     return name;
 }
+/** The inline mirror of {@link pluginKindOwner}. */
+export function pluginInlineKindOwner(kind) {
+    return declaredPluginInlineKinds.ownerOf(kind);
+}
 /** The inline mirror of {@link isBlockKindDeclared}. */
 export function isInlineKindDeclared(name) {
     return declaredPluginInlineKinds.has(name);
 }
-export function __clearDeclaredPluginInlineKindsForTests() {
-    declaredPluginInlineKinds.clear();
-}

package/dist/schema/plugin-name.js

@@ -1,6 +1,6 @@
-// The frozen plugin naming family, shared by plugin-kind.ts and plugin-install.ts. A
-// dependency-free leaf: plugin-kind already imports plugin-install, so hosting the pattern
-// there would close a cycle.
+// The frozen plugin name pattern, shared by `plugin-kind.ts` and `plugin-install.ts`. It sits in
+// its own file with no imports: `plugin-kind` already imports `plugin-install`, so keeping the
+// pattern there would close a cycle.
 const PLUGIN_NAME_PATTERN = /^[a-z][a-zA-Z0-9-]*$/;
 export function isValidPluginName(name) {
     return PLUGIN_NAME_PATTERN.test(name);

package/dist/schema/plugin-registry.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The store every registration a plugin can reach is built on. A registry is register-once (a
+ * dev server replaces), answers reads only through an editor's `PluginActivation`, and is cleared
+ * by the test reset except for built-ins. An entry answers to the plugin whose setup registered
+ * it, except in a kind registry, where a kind a plugin declared takes that plugin instead.
+ */
+import type { AnyBlockKind, AnyInlineKind } from '../core/nodes';
+import { type PluginActivation } from './plugin-activation';
+export interface RegistryRecord<K, V> {
+    readonly key: K;
+    readonly value: V;
+    /** The plugin whose activation the entry answers to. */
+    readonly owner: string | null;
+}
+export interface PluginRegistry<K, V> {
+    /** Throws on a taken key, `conflict` being the message; a dev server replaces instead. */
+    register(key: K, value: V, conflict?: string): void;
+    /** `register` for an editor built-in whose key `isBuiltin` can't recognize: owned by no plugin
+     *  and kept by the test reset. */
+    registerCore(key: K, value: V, conflict?: string): void;
+    /** Replace a registered key's value in place, keeping its owner and its position. */
+    update(key: K, value: V): void;
+    /** Registration-time question, blind to activation: is the key taken? */
+    has(key: K): boolean;
+    ownerOf(key: K): string | null;
+    /** The value where `activation` resolves its owner (`resolvesIn`), else undefined. */
+    get(key: K, activation: PluginActivation): V | undefined;
+    /** Every entry `activation` resolves, in registration order. */
+    entries(activation: PluginActivation): [K, V][];
+    /** For a read whose key only an already-filtered route can produce, or that must see every
+     *  entry (a descriptor, a registration check). */
+    getIgnoringActivation(key: K): V | undefined;
+    /** Every entry with its owner, in registration order, for an index a module derives and
+     *  filters with `resolvesIn` at its own read. */
+    records(): RegistryRecord<K, V>[];
+}
+/** A registry keyed by a block or inline kind. It has no `registerCore`: `isBuiltin` already
+ *  recognizes a built-in kind, so the reset keeps the entry the editor registered for it. */
+export type KindRegistry<K, V> = Omit<PluginRegistry<K, V>, 'registerCore'>;
+export interface PluginRegistryOptions<K> {
+    /** The registering function's name, which starts the default duplicate message. */
+    label: string;
+    /** A built-in key survives the test reset when no plugin registered it. */
+    isBuiltin: (key: K) => boolean;
+    /** Runs after every change, the reset included, so a derived cache can drop itself. */
+    onChange?: () => void;
+}
+type RefuseKindKey<K> = [K] extends [AnyBlockKind | AnyInlineKind] ? {
+    kindKeyNeedsAKindRegistry: never;
+} : unknown;
+export declare function createPluginRegistry<K, V>(options: PluginRegistryOptions<K> & RefuseKindKey<K>): PluginRegistry<K, V>;
+export declare function createBlockKindRegistry<V>(options: PluginRegistryOptions<AnyBlockKind>): KindRegistry<AnyBlockKind, V>;
+export declare function createInlineKindRegistry<V>(options: PluginRegistryOptions<AnyInlineKind>): KindRegistry<AnyInlineKind, V>;
+export {};

package/dist/schema/plugin-registry.js

@@ -0,0 +1,70 @@
+import { currentInstallingPlugin, registerAsCore } from './plugin-install';
+import { resolvesIn } from './plugin-activation';
+import { registerOnce } from './register-once';
+import { enrollTestReset } from './registry-reset';
+// Last: `plugin-kind` builds its registries at load, so everything they call must be loaded first.
+import { pluginInlineKindOwner, pluginKindOwner } from './plugin-kind';
+export function createPluginRegistry(options) {
+    return buildRegistry(options, (_key, registrant) => registrant);
+}
+export function createBlockKindRegistry(options) {
+    return buildRegistry(options, (key, registrant) => pluginKindOwner(key) ?? registrant);
+}
+export function createInlineKindRegistry(options) {
+    return buildRegistry(options, (key, registrant) => pluginInlineKindOwner(key) ?? registrant);
+}
+// Creating a registry enrolls its reset, so no registry can be left out of the reset.
+function buildRegistry(options, answersTo) {
+    const entries = new Map();
+    const changed = () => options.onChange?.();
+    const owner = (key, entry) => answersTo(key, entry.registrant);
+    enrollTestReset(() => {
+        for (const [key, entry] of entries) {
+            // The editor's own entries survive; a plugin's never do, whichever plugin it answers to.
+            const builtin = entry.registrant === null && options.isBuiltin(key);
+            if (!entry.core && !builtin)
+                entries.delete(key);
+        }
+        changed();
+    });
+    const store = (key, value, conflict, core) => {
+        const registrant = currentInstallingPlugin();
+        registerOnce(entries.has(key), () => {
+            entries.set(key, { value, registrant, core });
+            changed();
+        }, conflict ??
+            `${options.label}: "${String(key)}" is already registered. Registrations are register-once.`);
+    };
+    return {
+        register: (key, value, conflict) => store(key, value, conflict, false),
+        // The editor's bootstrap and the directive grammar run inside `registerAsCore` too, so one
+        // function decides what belongs to no plugin.
+        registerCore: (key, value, conflict) => registerAsCore(() => store(key, value, conflict, true)),
+        update(key, value) {
+            const entry = entries.get(key);
+            if (!entry)
+                throw new Error(`${options.label}: cannot update "${String(key)}"; it is not registered`);
+            entries.set(key, { ...entry, value });
+            changed();
+        },
+        has: (key) => entries.has(key),
+        ownerOf(key) {
+            const entry = entries.get(key);
+            return entry ? owner(key, entry) : null;
+        },
+        get(key, activation) {
+            const entry = entries.get(key);
+            return entry && resolvesIn(activation, owner(key, entry)) ? entry.value : undefined;
+        },
+        entries(activation) {
+            const out = [];
+            for (const [key, entry] of entries) {
+                if (resolvesIn(activation, owner(key, entry)))
+                    out.push([key, entry.value]);
+            }
+            return out;
+        },
+        getIgnoringActivation: (key) => entries.get(key)?.value,
+        records: () => [...entries].map(([key, entry]) => ({ key, value: entry.value, owner: owner(key, entry) }))
+    };
+}

package/dist/schema/reading.d.ts

@@ -0,0 +1,23 @@
+/**
+ * How one editor reads its own bytes: its grammar, its document's link-reference definitions and
+ * its presentation mode. The editor builds one and every internal parse, reparse and join cleanup
+ * takes it whole, so no read can pair this editor's bytes with another reading's parts.
+ * The resolver and the mode change while the editor lives: read them at use, never copy them.
+ */
+import type { LinkReferenceResolver } from '../core/inline/link-reference-resolver';
+import type { PresentationMode } from '../presentation-mode';
+import type { GrammarView } from './block-openers';
+export interface Reading {
+    /** The block and inline syntax this editor switched on, plugins included. */
+    readonly grammar: GrammarView;
+    /** Resolves reference links against the document's link-reference definitions; rebuilt after
+     *  each commit, absent with no definitions. */
+    readonly resolver: LinkReferenceResolver | undefined;
+    /** The definitions' fingerprint, which the inline cache compares. */
+    readonly resolverSignature: string;
+    /** Bumped with each rebuild of the resolver: a small key for render memos. */
+    readonly resolverEpoch: number;
+    mode(): PresentationMode;
+    /** Whether the caret's block draws no delimiters, where a rewrite may drop bytes nobody saw. */
+    hidesDelimitersAtCaret(): boolean;
+}

package/dist/schema/reading.js

@@ -0,0 +1,7 @@
+/**
+ * How one editor reads its own bytes: its grammar, its document's link-reference definitions and
+ * its presentation mode. The editor builds one and every internal parse, reparse and join cleanup
+ * takes it whole, so no read can pair this editor's bytes with another reading's parts.
+ * The resolver and the mode change while the editor lives: read them at use, never copy them.
+ */
+export {};

package/dist/schema/register-once.d.ts

@@ -1,9 +1,7 @@
-/** True only on a dev server (not production, not a test run) — the one window the valve opens. */
+/** True only on a dev server, not in production and not in a test run: the one case that replaces. */
 export declare function devReplacesRegistration(): boolean;
 /**
- * `apply` carries the registration and its side effects, and runs on a fresh register AND on a
- * dev replace, so a re-run registrar with changed content re-primes those seams.
+ * `apply` does the registration and its side effects. It runs both on a first registration and on
+ * a dev-server replacement, so re-running a plugin with changed content updates everything again.
  */
 export declare function registerOnce(isDuplicate: boolean, apply: () => void, conflict: string): void;
-/** The test-reset primitive the schema registries share: drop every non-built-in key. */
-export declare function deletePluginEntries<K>(map: Map<K, unknown>, isBuiltin: (key: K) => boolean): void;

package/dist/schema/register-once.js

@@ -1,24 +1,22 @@
 /**
- * Register-once with a DEV-only survival valve for HMR/SSR registrar re-eval. The frozen
- * contract (docs/design/plugin-contract.md § The registries: global, register-once) is
- * conflict-on-duplicate, and production and test keep the throw. On a dev server a re-run
- * registrar would otherwise 500 every route until restart, so there a duplicate replaces with a
- * note instead.
+ * Register-once: a duplicate is an error, and production and test keep the throw
+ * (`docs/design/plugin-contract.md` § The registries: global, register-once). On a dev server the
+ * throw would break every route until restart, so there a duplicate replaces the entry and warns.
  */
 import { editorEnv } from '../env';
 import { devWarn } from '../dev-warn';
-/** True only on a dev server (not production, not a test run) — the one window the valve opens. */
+/** True only on a dev server, not in production and not in a test run: the one case that replaces. */
 export function devReplacesRegistration() {
     return editorEnv.isDev && !editorEnv.isTest;
 }
 /**
- * `apply` carries the registration and its side effects, and runs on a fresh register AND on a
- * dev replace, so a re-run registrar with changed content re-primes those seams.
+ * `apply` does the registration and its side effects. It runs both on a first registration and on
+ * a dev-server replacement, so re-running a plugin with changed content updates everything again.
  */
 export function registerOnce(isDuplicate, apply, conflict) {
     if (isDuplicate) {
         if (devReplacesRegistration()) {
-            devWarn('registry', `${conflict} — dev re-registration replaces (HMR/SSR survival)`);
+            devWarn('registry', `${conflict}: dev re-registration replaces (HMR/SSR survival)`);
             apply();
             return;
         }
@@ -26,10 +24,3 @@ export function registerOnce(isDuplicate, apply, conflict) {
     }
     apply();
 }
-/** The test-reset primitive the schema registries share: drop every non-built-in key. */
-export function deletePluginEntries(map, isBuiltin) {
-    for (const key of map.keys()) {
-        if (!isBuiltin(key))
-            map.delete(key);
-    }
-}

package/dist/schema/registration-checks.d.ts

@@ -1,32 +1,28 @@
 /**
- * Registration-seam coherence: the registries enqueue every post-bootstrap registration and this
- * seam validates them at the next flush — Editor mount, or the parser's next grammar read
- * (`getOrderedOpeners`) — never mid-batch, so intra-batch forward references stay warn-free.
- * This module and block-openers reference each other, but only inside function bodies, and
- * neither calls the other during evaluation, so no cycle observes uninitialized state.
+ * Checks that the registrations agree with each other. Registrations made after startup queue up
+ * and are checked at the next Editor mount or parser read of the grammar, never part-way through a
+ * batch, so a forward reference within one batch warns about nothing. This module and
+ * `block-openers` import each other for use inside function bodies only, so the cycle is safe.
  */
 import { type AnyBlockKind } from '../core/nodes';
 import { type InvariantViolation } from '../assert';
 import { type ClosureCoherenceEntry } from '../invariants/registry';
 import { type BlockKindDescriptor } from './block-kind-descriptor';
-export { hasPendingRegistrationChecks, __resetRegistrationChecksForTests } from './registration-pending';
-/** Matches `assertInvariant` — the default sink; tests inject a collector. */
+export { hasPendingRegistrationChecks } from './registration-pending';
+/** The same shape as `assertInvariant`, which is the default; tests pass a collector instead. */
 export type RegistrationCheckReport = (tag: string, check: () => InvariantViolation | null) => void;
 /**
- * Descriptor → G1.24 entry. Exported so the suites project the same fields: a test-local copy
- * that missed a column would pass while the rule it claims to exercise went unread.
+ * The entry the closure coherence check reads (G1.24), exported so the suites build it the same
+ * way: a test-local copy missing a field would pass while the rule it tests went unchecked.
  */
 export declare const closureCoherenceEntry: (kind: AnyBlockKind, d: BlockKindDescriptor) => ClosureCoherenceEntry;
 /**
- * Run the registry coherence checks (G1.2/10/11/17/18/24/30/32/37). The first call sweeps the whole
- * world; later calls validate only the kinds registered since, plus opener coherence over the
- * full registry (a new opener's priority collision is inherently cross-entry).
+ * Run the registry checks. Later calls check only the kinds registered since the last, plus the
+ * openers as a whole, since a new opener's priority clash always involves another entry.
  */
 export declare function flushPendingRegistrationChecks(report?: RegistrationCheckReport): void;
 /**
- * G1.31, at the EDITOR-MOUNT flush alone. The rows register with the descriptors, but the
- * policy's function hooks patch in from the component layer, which a parse-only unit test
- * never loads — running this at the parser's flush would fire on an absence legal there.
- * Table-wide rather than per-registration, so it does not ride the pending-kinds queue.
+ * Mount-only, since the policy's functions come from the component layer, which a parse-only test
+ * never loads (G1.31). It reads the whole table, so it stays off the queue of pending kinds.
  */
 export declare function checkInlineConstructPoliciesAtMount(report?: RegistrationCheckReport): void;

package/dist/schema/registration-checks.js

@@ -1,38 +1,32 @@
 /**
- * Registration-seam coherence: the registries enqueue every post-bootstrap registration and this
- * seam validates them at the next flush — Editor mount, or the parser's next grammar read
- * (`getOrderedOpeners`) — never mid-batch, so intra-batch forward references stay warn-free.
- * This module and block-openers reference each other, but only inside function bodies, and
- * neither calls the other during evaluation, so no cycle observes uninitialized state.
+ * Checks that the registrations agree with each other. Registrations made after startup queue up
+ * and are checked at the next Editor mount or parser read of the grammar, never part-way through a
+ * batch, so a forward reference within one batch warns about nothing. This module and
+ * `block-openers` import each other for use inside function bodies only, so the cycle is safe.
  */
-import { ALL_BLOCK_KINDS, isBuiltinInlineKind } from '../core/nodes';
+import { ALL_BLOCK_KINDS, isBuiltinBlockKind, isBuiltinInlineKind } from '../core/nodes';
 import { assertInvariant } from '../assert';
-import { checkRegistryCompleteness, checkOpenerRegistry, checkKeymapCoherence, checkReservedChromeCoherence, checkClosureCoherence, checkLateOpenerRegistration, checkMergeRoleVocabulary, checkContentStartBackspace, checkDescriptorFieldCoherence, checkInlineConstructPolicy } from '../invariants/registry';
+import { checkRegistryCompleteness, checkOpenerRegistry, checkKeymapCoherence, checkReservedChromeCoherence, checkClosureCoherence, checkLateOpenerRegistration, checkMergeRoleVocabulary, checkDescriptorFieldCoherence, checkInlineConstructPolicy, checkBuiltinPresentationFacts } from '../invariants/registry';
 import { listInlineConstructPolicies } from './inline-construct-policy';
 import { isInlineKindDeclared } from './plugin-kind';
-import { tryGetBlockKindDescriptor, getAllRegisteredKinds, isKnownMergeRole, liftsFirstChild } from './block-kind-descriptor';
-import { getBlockComponent } from './block-component-registry';
+import { tryGetBlockKindDescriptor, getAllRegisteredKinds, isKnownMergeRole } from './block-kind-descriptor';
+import { isBlockComponentRegistered } from './block-component-registry';
 import { listRegisteredOpeners } from './block-openers';
 import { isBuiltinCommandId } from './commands';
 import { isPluginCommandId } from './command-id';
-import { normalizeChord, isChordWellFormed } from './keybindings';
 import { takeRegistrationFlushWork } from './registration-pending';
-export { hasPendingRegistrationChecks, __resetRegistrationChecksForTests } from './registration-pending';
+export { hasPendingRegistrationChecks } from './registration-pending';
 const hasDescriptor = (kind) => tryGetBlockKindDescriptor(kind) !== undefined;
-const hasComponent = (kind) => getBlockComponent(kind) !== undefined;
+const hasComponent = (kind) => isBlockComponentRegistered(kind);
 const keymapEntries = (kinds) => kinds.map((kind) => ({ kind, keymap: tryGetBlockKindDescriptor(kind)?.keymap }));
-const reservedChromeEntries = (kinds) => kinds.map((kind) => {
-    const d = tryGetBlockKindDescriptor(kind);
-    return {
-        kind,
-        isContainer: d?.isContainer ?? false,
-        reservedChromeKind: d?.reservedChrome?.kind
-    };
-});
+const reservedChromeEntries = (kinds) => kinds.map((kind) => ({
+    kind,
+    reservedChromeKind: tryGetBlockKindDescriptor(kind)?.reservedChrome?.kind
+}));
 const viaOf = (cell) => cell.mode === 'implemented' ? cell.via : undefined;
 /**
- * Descriptor → G1.24 entry. Exported so the suites project the same fields: a test-local copy
- * that missed a column would pass while the rule it claims to exercise went unread.
+ * The entry the closure coherence check reads (G1.24), exported so the suites build it the same
+ * way: a test-local copy missing a field would pass while the rule it tests went unchecked.
  */
 export const closureCoherenceEntry = (kind, d) => ({
     kind,
@@ -50,43 +44,36 @@ const closureEntries = (kinds) => kinds
     .map((kind) => ({ kind, d: tryGetBlockKindDescriptor(kind) }))
     .filter((e) => e.d !== undefined)
     .map(({ kind, d }) => closureCoherenceEntry(kind, d));
-// Widened to `string` on the way out: the vocabulary check exists for the callers the
-// `MergeRole` union cannot bind (a plugin registering through a cast).
+// Widened to `string` on the way out: the check exists for the callers the `MergeRole` union
+// cannot constrain, such as a plugin registering through a cast.
 const mergeRoleEntries = (kinds) => kinds.flatMap((kind) => {
     const mergeRole = tryGetBlockKindDescriptor(kind)?.mergeRole;
     return mergeRole === undefined ? [] : [{ kind, mergeRole }];
 });
-const contentStartBackspaceEntries = (kinds) => kinds.map((kind) => {
-    const d = tryGetBlockKindDescriptor(kind);
-    return {
-        kind,
-        demotesFirst: d?.contentStartBackspace === 'demote-first',
-        declaresContentRange: d?.getContentRange !== undefined
-    };
-});
 const descriptorFieldEntries = (kinds, openerKinds) => kinds.flatMap((kind) => {
     const d = tryGetBlockKindDescriptor(kind);
     if (!d)
         return [];
-    const firstChildBackspace = d.unwrapRole?.firstChildBackspace;
     return [
         {
             kind,
-            declaresWholeBlockFocus: d.blockFocus === 'whole-block',
-            supportsInline: d.supportsInline,
-            declaresReservedChrome: d.reservedChrome !== undefined,
             contextDependentKind: d.contextDependentKind === true,
-            hasOpener: openerKinds.has(kind),
-            unwrapLiftsFirstChild: firstChildBackspace !== undefined && liftsFirstChild(firstChildBackspace),
-            unwrapKeepsReservedChrome: firstChildBackspace === 'keep-reserved-chrome'
+            hasOpener: openerKinds.has(kind)
         }
     ];
 });
+const presentationFactEntries = (kinds) => kinds.filter(isBuiltinBlockKind).map((kind) => {
+    const d = tryGetBlockKindDescriptor(kind);
+    return {
+        kind,
+        declaresPageRole: d?.pageRole !== undefined,
+        declaresEstimateHeight: d?.estimateHeight !== undefined
+    };
+});
 const isKnownCommandId = (id) => isBuiltinCommandId(id) || isPluginCommandId(id);
 /**
- * Run the registry coherence checks (G1.2/10/11/17/18/24/30/32/37). The first call sweeps the whole
- * world; later calls validate only the kinds registered since, plus opener coherence over the
- * full registry (a new opener's priority collision is inherently cross-entry).
+ * Run the registry checks. Later calls check only the kinds registered since the last, plus the
+ * openers as a whole, since a new opener's priority clash always involves another entry.
  */
 export function flushPendingRegistrationChecks(report = assertInvariant) {
     const work = takeRegistrationFlushWork();
@@ -95,27 +82,24 @@ export function flushPendingRegistrationChecks(report = assertInvariant) {
     if (work.firstFlush) {
         report('registry-completeness', () => checkRegistryCompleteness(ALL_BLOCK_KINDS, hasDescriptor, hasComponent));
     }
-    // The first flush sweeps the live registry, not just ALL_BLOCK_KINDS. Completeness stays
-    // built-in-scoped: a plugin kind's component may register on its own schedule, so
-    // reservedChrome coherence is the plugin-kind bootstrap check instead.
+    // The first run covers every registered kind, plugin kinds included; the completeness check
+    // alone stays on built-ins, since a plugin kind's component may register later.
     const kinds = work.firstFlush ? getAllRegisteredKinds() : work.kinds;
     report('opener-registry', () => checkOpenerRegistry(listRegisteredOpeners(), hasDescriptor));
-    report('keymap-coherence', () => checkKeymapCoherence(keymapEntries(kinds), isKnownCommandId, normalizeChord, isChordWellFormed));
+    report('keymap-coherence', () => checkKeymapCoherence(keymapEntries(kinds), isKnownCommandId));
     report('reserved-chrome-coherence', () => checkReservedChromeCoherence(reservedChromeEntries(kinds), hasDescriptor, hasComponent));
     report('closure-coherence', () => checkClosureCoherence(closureEntries(kinds)));
     report('descriptor-field-coherence', () => checkDescriptorFieldCoherence(descriptorFieldEntries(kinds, new Set(listRegisteredOpeners().map((entry) => entry.kind)))));
     report('merge-role-vocabulary', () => checkMergeRoleVocabulary(mergeRoleEntries(kinds), isKnownMergeRole));
-    report('content-start-backspace', () => checkContentStartBackspace(contentStartBackspaceEntries(kinds)));
+    report('builtin-presentation-facts', () => checkBuiltinPresentationFacts(presentationFactEntries(kinds)));
     for (const kind of work.lateOpeners) {
         report('late-opener-registration', () => checkLateOpenerRegistration(kind, true));
     }
 }
 const isKnownInlineKind = (kind) => isBuiltinInlineKind(kind) || isInlineKindDeclared(kind);
 /**
- * G1.31, at the EDITOR-MOUNT flush alone. The rows register with the descriptors, but the
- * policy's function hooks patch in from the component layer, which a parse-only unit test
- * never loads — running this at the parser's flush would fire on an absence legal there.
- * Table-wide rather than per-registration, so it does not ride the pending-kinds queue.
+ * Mount-only, since the policy's functions come from the component layer, which a parse-only test
+ * never loads (G1.31). It reads the whole table, so it stays off the queue of pending kinds.
  */
 export function checkInlineConstructPoliciesAtMount(report = assertInvariant) {
     report('inline-construct-policy', () => checkInlineConstructPolicy(listInlineConstructPolicies(), isKnownInlineKind, isBuiltinInlineKind, isBuiltinCommandId));

package/dist/schema/registration-pairs.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Field pairs a block-kind registration can't mean together. The registration types refuse each
+ * one; this table refuses it again at runtime for a caller the types never reach (a cast, plain
+ * JavaScript). A new row needs a `@ts-expect-error [id]` pin in `descriptor-groups.types.test.ts`.
+ */
+import type { AnyBlockKind } from '../core/nodes';
+/** The registration fields the pairs read, loose enough to hold what a cast lets through. */
+interface RegistrationFields {
+    blockFocus?: string;
+    supportsInline?: boolean;
+    contentStart?: {
+        range?: unknown;
+    };
+    container?: {
+        reservedChrome?: unknown;
+        unwrapRole?: {
+            firstChildBackspace?: string;
+        };
+    };
+}
+export declare const INCOHERENT_REGISTRATION_PAIRS: readonly [{
+    readonly id: "content-start-without-range";
+    readonly fields: "contentStart with no contentStart.range";
+    readonly reason: "the content-start Backspace reads the range, so it would never fire";
+    readonly holds: (r: RegistrationFields) => boolean;
+}, {
+    readonly id: "whole-block-inline";
+    readonly fields: "blockFocus: 'whole-block' with supportsInline";
+    readonly reason: "a block focused as one unit has no caret positions for inline content to live at";
+    readonly holds: (r: RegistrationFields) => boolean;
+}, {
+    readonly id: "whole-block-content-start";
+    readonly fields: "blockFocus: 'whole-block' with contentStart";
+    readonly reason: "no caret enters a block focused as one unit, so there's no content start";
+    readonly holds: (r: RegistrationFields) => boolean;
+}, {
+    readonly id: "whole-block-title-row";
+    readonly fields: "blockFocus: 'whole-block' with container.reservedChrome";
+    readonly reason: "a title row means the block is never childless, so whole-block focus never engages";
+    readonly holds: (r: RegistrationFields) => boolean;
+}, {
+    readonly id: "title-row-first-child-strategy";
+    readonly fields: "container.reservedChrome with unwrapRole.firstChildBackspace";
+    readonly reason: "Backspace at a title row always keeps it, so declare only middleChildBackspace";
+    readonly holds: (r: RegistrationFields) => boolean;
+}, {
+    readonly id: "keep-title-row-without-one";
+    readonly fields: "firstChildBackspace: 'keep-reserved-chrome' with no container.reservedChrome";
+    readonly reason: "child 0 is body, so Backspace at its start would do nothing; declare a lifting one";
+    readonly holds: (r: RegistrationFields) => boolean;
+}];
+export type IncoherentPairId = (typeof INCOHERENT_REGISTRATION_PAIRS)[number]['id'];
+export declare function rejectIncoherentPairs(kind: AnyBlockKind, registration: RegistrationFields): void;
+export {};