@voithos-labs/aragonite 0.10.1

package/dist/schema/plugin-kind.js

@@ -0,0 +1,86 @@
+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.
+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`);
+    }
+    if (name in BLOCK_KIND_TABLE) {
+        throw new Error(`declarePluginKind: "${name}" is a built-in BlockKind`);
+    }
+    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);
+    return name;
+}
+/**
+ * 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.
+ */
+export function declaredPluginKind(name) {
+    if (!declaredPluginKinds.has(name)) {
+        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.
+ */
+export function isBlockKindDeclared(name) {
+    return declaredPluginKinds.has(name);
+}
+export function __clearDeclaredPluginKindsForTests() {
+    declaredPluginKinds.clear();
+}
+const declaredPluginInlineKinds = new Set();
+export function declarePluginInlineKind(name) {
+    if (!isValidPluginName(name)) {
+        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);
+    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`);
+    }
+    return name;
+}
+/** The inline mirror of {@link isBlockKindDeclared}. */
+export function isInlineKindDeclared(name) {
+    return declaredPluginInlineKinds.has(name);
+}
+export function __clearDeclaredPluginInlineKindsForTests() {
+    declaredPluginInlineKinds.clear();
+}

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

@@ -0,0 +1 @@
+export declare function isValidPluginName(name: string): boolean;

package/dist/schema/plugin-name.js

@@ -0,0 +1,7 @@
+// 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.
+const PLUGIN_NAME_PATTERN = /^[a-z][a-zA-Z0-9-]*$/;
+export function isValidPluginName(name) {
+    return PLUGIN_NAME_PATTERN.test(name);
+}

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

@@ -0,0 +1,9 @@
+/** True only on a dev server (not production, not a test run) — the one window the valve opens. */
+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.
+ */
+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

@@ -0,0 +1,35 @@
+/**
+ * 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.
+ */
+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. */
+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.
+ */
+export function registerOnce(isDuplicate, apply, conflict) {
+    if (isDuplicate) {
+        if (devReplacesRegistration()) {
+            devWarn('registry', `${conflict} — dev re-registration replaces (HMR/SSR survival)`);
+            apply();
+            return;
+        }
+        throw new Error(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

@@ -0,0 +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.
+ */
+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 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.
+ */
+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).
+ */
+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.
+ */
+export declare function checkInlineConstructPoliciesAtMount(report?: RegistrationCheckReport): void;

package/dist/schema/registration-checks.js

@@ -0,0 +1,122 @@
+/**
+ * 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.
+ */
+import { ALL_BLOCK_KINDS, isBuiltinInlineKind } from '../core/nodes';
+import { assertInvariant } from '../assert';
+import { checkRegistryCompleteness, checkOpenerRegistry, checkKeymapCoherence, checkReservedChromeCoherence, checkClosureCoherence, checkLateOpenerRegistration, checkMergeRoleVocabulary, checkContentStartBackspace, checkDescriptorFieldCoherence, checkInlineConstructPolicy } 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 { 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';
+const hasDescriptor = (kind) => tryGetBlockKindDescriptor(kind) !== undefined;
+const hasComponent = (kind) => getBlockComponent(kind) !== undefined;
+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 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.
+ */
+export const closureCoherenceEntry = (kind, d) => ({
+    kind,
+    notMergeable: d.mergeRole === 'not-mergeable',
+    hasContainerContract: d.containerContract !== undefined,
+    roundTripMode: d.closure.roundTrip.mode,
+    mergeBackspaceMode: d.closure.mergeBackspace.mode,
+    declaresWholeBlockFocus: d.blockFocus === 'whole-block',
+    focusVia: viaOf(d.closure.focus),
+    mergeBackspaceVia: viaOf(d.closure.mergeBackspace),
+    declaresReservedChrome: d.reservedChrome !== undefined,
+    clipboardMode: d.closure.clipboard.mode
+});
+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).
+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'
+        }
+    ];
+});
+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).
+ */
+export function flushPendingRegistrationChecks(report = assertInvariant) {
+    const work = takeRegistrationFlushWork();
+    if (!work)
+        return;
+    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.
+    const kinds = work.firstFlush ? getAllRegisteredKinds() : work.kinds;
+    report('opener-registry', () => checkOpenerRegistry(listRegisteredOpeners(), hasDescriptor));
+    report('keymap-coherence', () => checkKeymapCoherence(keymapEntries(kinds), isKnownCommandId, normalizeChord, isChordWellFormed));
+    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)));
+    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.
+ */
+export function checkInlineConstructPoliciesAtMount(report = assertInvariant) {
+    report('inline-construct-policy', () => checkInlineConstructPolicy(listInlineConstructPolicies(), isKnownInlineKind, isBuiltinInlineKind, isBuiltinCommandId));
+}

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

@@ -0,0 +1,28 @@
+/**
+ * Pending-registration ledger behind the registration-check seam (`./registration-checks`).
+ * Import-leaf on purpose: the registries that enqueue here register built-ins during their own
+ * module evaluation, so a back-import would call into this module before its state initializes.
+ */
+import type { AnyBlockKind } from '../core/nodes';
+/**
+ * Record a registration for the next coherence flush. The pending-kinds gate no-ops before the
+ * first flush, which validates the bootstrap batch whole. Lateness is recorded UNCONDITIONALLY,
+ * ahead of that gate: an editorless `parse()` trips grammar-consumption without flushing, so an
+ * opener registered after that is genuinely late and must survive to the first flush (G1.17).
+ */
+export declare function enqueueRegistrationCheck(kind: AnyBlockKind, origin?: 'descriptor' | 'opener'): void;
+/** Grammar-consumption latch: the parser's opener-dispatch read trips it. */
+export declare function markGrammarConsumed(): void;
+export declare function hasPendingRegistrationChecks(): boolean;
+export interface RegistrationFlushWork {
+    firstFlush: boolean;
+    kinds: AnyBlockKind[];
+    lateOpeners: AnyBlockKind[];
+}
+/**
+ * Claim the outstanding work, clearing it BEFORE any check runs — draining first is the
+ * re-entrancy guard, so a check that re-reads the grammar finds an empty pending set instead of
+ * recursing into another flush.
+ */
+export declare function takeRegistrationFlushWork(): RegistrationFlushWork | null;
+export declare function __resetRegistrationChecksForTests(): void;

package/dist/schema/registration-pending.js

@@ -0,0 +1,48 @@
+const pendingKinds = new Set();
+const pendingLateOpeners = new Set();
+let didFirstFlush = false;
+let grammarConsumed = false;
+/**
+ * Record a registration for the next coherence flush. The pending-kinds gate no-ops before the
+ * first flush, which validates the bootstrap batch whole. Lateness is recorded UNCONDITIONALLY,
+ * ahead of that gate: an editorless `parse()` trips grammar-consumption without flushing, so an
+ * opener registered after that is genuinely late and must survive to the first flush (G1.17).
+ */
+export function enqueueRegistrationCheck(kind, origin = 'descriptor') {
+    if (origin === 'opener' && grammarConsumed)
+        pendingLateOpeners.add(kind);
+    if (!didFirstFlush)
+        return;
+    pendingKinds.add(kind);
+}
+/** Grammar-consumption latch: the parser's opener-dispatch read trips it. */
+export function markGrammarConsumed() {
+    grammarConsumed = true;
+}
+export function hasPendingRegistrationChecks() {
+    return pendingKinds.size > 0;
+}
+/**
+ * Claim the outstanding work, clearing it BEFORE any check runs — draining first is the
+ * re-entrancy guard, so a check that re-reads the grammar finds an empty pending set instead of
+ * recursing into another flush.
+ */
+export function takeRegistrationFlushWork() {
+    if (didFirstFlush && pendingKinds.size === 0 && pendingLateOpeners.size === 0)
+        return null;
+    const work = {
+        firstFlush: !didFirstFlush,
+        kinds: [...pendingKinds],
+        lateOpeners: [...pendingLateOpeners]
+    };
+    didFirstFlush = true;
+    pendingKinds.clear();
+    pendingLateOpeners.clear();
+    return work;
+}
+export function __resetRegistrationChecksForTests() {
+    pendingKinds.clear();
+    pendingLateOpeners.clear();
+    didFirstFlush = false;
+    grammarConsumed = false;
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Test-only. Clears every non-built-in registration; built-ins survive. Also clears the warn
+ * dedup, the registration-check latches, and the installed-plugin set — state that shadows a
+ * registry must never outlive its reset. The single-slot registrations (live split rebalancer,
+ * join-seam cleaner) keep their own doors: only a suite testing a slot wants it emptied.
+ */
+export declare function __resetSchemaRegistriesForTests(): void;

package/dist/schema/registry-reset.js

@@ -0,0 +1,30 @@
+import { __removePluginBlockKindsForTests } from './block-kind-descriptor';
+import { __removePluginComponentsForTests } from './block-component-registry';
+import { __removePluginCompletersForTests } from './block-completions';
+import { __removePluginOpenersForTests } from './block-openers';
+import { __removePluginCommandsForTests, __resetCommandWarningsForTests, __resetPluginGlobalKeymapForTests } from './commands';
+import { __resetBlockCommandsForTests } from './block-commands';
+import { __clearDeclaredPluginKindsForTests } from './plugin-kind';
+import { __resetRegistrationChecksForTests } from './registration-checks';
+import { __resetInstalledPluginsForTests } from './plugin-install';
+import { __resetInlineConstructPoliciesForTests } from './inline-construct-policy';
+/**
+ * Test-only. Clears every non-built-in registration; built-ins survive. Also clears the warn
+ * dedup, the registration-check latches, and the installed-plugin set — state that shadows a
+ * registry must never outlive its reset. The single-slot registrations (live split rebalancer,
+ * join-seam cleaner) keep their own doors: only a suite testing a slot wants it emptied.
+ */
+export function __resetSchemaRegistriesForTests() {
+    __removePluginBlockKindsForTests();
+    __removePluginComponentsForTests();
+    __removePluginCompletersForTests();
+    __removePluginOpenersForTests();
+    __removePluginCommandsForTests();
+    __resetBlockCommandsForTests();
+    __resetInlineConstructPoliciesForTests();
+    __resetPluginGlobalKeymapForTests();
+    __resetCommandWarningsForTests();
+    __clearDeclaredPluginKindsForTests();
+    __resetRegistrationChecksForTests();
+    __resetInstalledPluginsForTests();
+}

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

@@ -0,0 +1,30 @@
+/**
+ * Per-instance resolution over the process-global block definitions (docs/design/plugin-contract.md
+ * § Schema registries). The default view resolves every kind VERBATIM, so an editorless `parse()`
+ * and every bare component mount stay byte-identical. An `isEnabled` view resolves no component
+ * for a disabled plugin kind and drops its opener; the DESCRIPTOR is never filtered, since a
+ * disabled kind still needs it to degrade rather than throw. The `plugins` prop sources the
+ * predicate: `plugin-activation.ts` turns an instance's listed set into one.
+ */
+import { type AnyBlockKind } from '../core/nodes';
+import { type BlockComponentEntry } from './block-component-registry';
+import { type BlockKindDescriptor } from './block-kind-descriptor';
+import { type GrammarView } from './block-openers';
+/** `false` disables a PLUGIN kind for one instance; built-ins are never disableable. */
+export type KindEnablement = (kind: AnyBlockKind) => boolean;
+export interface RegistryView {
+    /** The kind's component, or `undefined` when unregistered OR disabled for this instance. */
+    component(kind: AnyBlockKind): BlockComponentEntry | undefined;
+    /** The kind's descriptor — never filtered (required infrastructure); throws when absent. */
+    descriptor(kind: AnyBlockKind): BlockKindDescriptor;
+    tryDescriptor(kind: AnyBlockKind): BlockKindDescriptor | undefined;
+    /** The block grammar this instance parses through (`parse(source, { grammar })`). */
+    grammar: GrammarView;
+}
+/** Both predicates must admit the kind, so a second filter can only narrow the first.
+ *  An absent side admits everything. */
+export declare function bothEnable(a: KindEnablement | undefined, b: KindEnablement | undefined): KindEnablement | undefined;
+export declare function createRegistryView(opts?: {
+    isEnabled?: KindEnablement;
+}): RegistryView;
+export declare const defaultRegistryView: RegistryView;

package/dist/schema/registry-view.js

@@ -0,0 +1,39 @@
+/**
+ * Per-instance resolution over the process-global block definitions (docs/design/plugin-contract.md
+ * § Schema registries). The default view resolves every kind VERBATIM, so an editorless `parse()`
+ * and every bare component mount stay byte-identical. An `isEnabled` view resolves no component
+ * for a disabled plugin kind and drops its opener; the DESCRIPTOR is never filtered, since a
+ * disabled kind still needs it to degrade rather than throw. The `plugins` prop sources the
+ * predicate: `plugin-activation.ts` turns an instance's listed set into one.
+ */
+import { isBuiltinBlockKind } from '../core/nodes';
+import { getBlockComponent } from './block-component-registry';
+import { getBlockKindDescriptor, tryGetBlockKindDescriptor } from './block-kind-descriptor';
+import { defaultGrammarView, createGrammarView } from './block-openers';
+/** Both predicates must admit the kind, so a second filter can only narrow the first.
+ *  An absent side admits everything. */
+export function bothEnable(a, b) {
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    return (kind) => a(kind) && b(kind);
+}
+export function createRegistryView(opts) {
+    const filter = opts?.isEnabled;
+    if (!filter)
+        return defaultRegistryView;
+    const enabled = (kind) => isBuiltinBlockKind(kind) || filter(kind);
+    return {
+        component: (kind) => (enabled(kind) ? getBlockComponent(kind) : undefined),
+        descriptor: (kind) => getBlockKindDescriptor(kind),
+        tryDescriptor: (kind) => tryGetBlockKindDescriptor(kind),
+        grammar: createGrammarView(enabled)
+    };
+}
+export const defaultRegistryView = {
+    component: (kind) => getBlockComponent(kind),
+    descriptor: (kind) => getBlockKindDescriptor(kind),
+    tryDescriptor: (kind) => tryGetBlockKindDescriptor(kind),
+    grammar: defaultGrammarView
+};

package/dist/schema/reserved-chords.d.ts

@@ -0,0 +1,35 @@
+import type { KeybindingOverrideMap } from './keybinding-overrides';
+import type { PluginActivation } from './plugin-activation';
+/** One library file that reads a KeyboardEvent modifier flag, and what it claims. */
+export interface HardcodedChordSite {
+    /** Path under `src/lib`, as G4.29's scan reports it. */
+    file: string;
+    /** Modifier chords the file consumes outside every keymap. */
+    chords: readonly string[];
+    /** Key literals the file compares — the scan's evidence that `chords` is still current. */
+    keys: readonly string[];
+    /** Why the chord list is what it is, where the branches alone don't say. */
+    note?: string;
+}
+export declare const HARDCODED_CHORD_SITES: readonly HardcodedChordSite[];
+export interface ReservedChordOptions {
+    /** The instance's live `searchBar` value: with the bar off the editor claims neither
+     *  Find nor Replace. */
+    searchBar: boolean;
+    /** The instance's compiled `keybindings` prop, so an override's binds and disables show. */
+    keybindings?: KeybindingOverrideMap;
+    /** The plugins this instance activated: a chord another editor's plugin claimed is not
+     *  this editor's. Required-nullable, so a new caller must answer; `undefined` is every
+     *  installed plugin. */
+    activation: PluginActivation | undefined;
+}
+/**
+ * Every modifier chord this editor consumes, normalized. Composed on each call: kind keymaps,
+ * the plugin tiers and the override map all change under a live editor.
+ */
+export declare function collectReservedChords(options: ReservedChordOptions): ReadonlySet<string>;
+/**
+ * True when `chords` claims this keystroke, under the editor's own normalization — Ctrl and
+ * Cmd both fold to `Mod`, so a consumer never re-derives the platform rule.
+ */
+export declare function chordIsClaimed(event: KeyboardEvent, chords: ReadonlySet<string>): boolean;