@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/schema/block-commands.js

@@ -1,85 +1,95 @@
-import { mintCommandId, __resetMintedCommandIdsForTests } from './command-id';
-import { registerOnce } from './register-once';
-import { resolveBinding, resolveKindBinding, getCommand, warnDeadKeyCommand, isBuiltinCommandId, CROSS_BLOCK_RANGE_COMMAND_IDS, RANGE_DECLINED_COMMAND_IDS } from './commands';
-import { currentInstallingPlugin } from './plugin-install';
+import { mintCommandId } from './command-id';
+import { createPluginRegistry } from './plugin-registry';
+import { resolveBinding, resolveKindBinding, getCommand, isCommandRegistered, warnDeadKeyCommand, isBuiltinCommandId, runPluginCommand, CROSS_BLOCK_RANGE_COMMAND_IDS, RANGE_DECLINED_COMMAND_IDS } from './commands';
+import { pluginEditorFor } from './plugin-install';
 import { isReadingMode } from '../presentation-mode';
-const blockCommands = new Map();
+const blockCommands = createPluginRegistry({
+    label: 'registerBlockCommand',
+    isBuiltin: () => false
+});
 const compositeKey = (kind, id) => `${kind} ${id}`;
+// The two ids every block answers the same way, so they resolve here rather than per component.
+const MOVE_STEP = { 'block.moveUp': -1, 'block.moveDown': 1 };
 /**
- * Register-once check precedes the mint, so a duplicate `(kind, name)` reports as
- * "register-once" rather than as an already-minted collision. The name-validating mint runs
- * inside `apply` before the map write, so an invalid name never leaves an orphaned handler.
+ * A duplicate `(kind, name)` reports as a register-once conflict, not an id collision, and the
+ * name is validated before the handler is stored, so an invalid name leaves no orphaned handler.
  */
 export function registerBlockCommand(kind, name, handler) {
     const key = compositeKey(kind, name);
-    let id;
-    registerOnce(blockCommands.has(key), () => {
-        id = mintCommandId(name, currentInstallingPlugin());
-        blockCommands.set(key, handler);
-    }, `registerBlockCommand: (${kind}, ${name}) is already registered — block commands are register-once`);
+    // A taken key throws here, or on a dev server replaces the handler under the id it already has.
+    const id = blockCommands.has(key) ? name : mintCommandId(name);
+    blockCommands.register(key, handler, `registerBlockCommand: (${kind}, ${name}) is already registered — block commands are register-once`);
     return id;
 }
-export function getBlockCommand(kind, id) {
-    return blockCommands.get(compositeKey(kind, id));
-}
-export function __resetBlockCommandsForTests() {
-    blockCommands.clear();
-    __resetMintedCommandIdsForTests();
+/** The handler where `activation` resolves the plugin that registered it. */
+export function getBlockCommand(kind, id, activation) {
+    return blockCommands.get(compositeKey(kind, id), activation);
 }
 /**
- * The kind tiers, in dispatch order. A GLOBAL id resolves DEAD here: the leaf path has already
- * run it, and the container bubble deliberately has no global tier, so a container can never
- * re-fire the focused leaf's undo.
+ * The block-level lookups, in dispatch order. A global id resolves as dead here, since the leaf
+ * already ran it and a container must never re-fire the focused leaf's undo.
  */
-function resolveBlockLocalCommand(id, target) {
+function resolveBlockLocalCommand(id, target, activation) {
     if (!target)
         return { tier: 'no-surface' };
-    if (getCommand(id))
+    if (getCommand(id, activation))
         return { tier: 'dead' };
-    const handler = getBlockCommand(target.kind, id);
+    const handler = getBlockCommand(target.kind, id, activation);
     // A context is built only where a handler matched, so a built-in id costs nothing extra on the
     // read a host may run per selection change.
     const context = handler ? target.getCommandContext?.() : undefined;
-    if (handler && context)
-        return { tier: 'minted', target, handler, context };
-    return isBuiltinCommandId(id) ? { tier: 'builtin', target } : { tier: 'dead' };
+    if (handler && context) {
+        const owner = blockCommands.ownerOf(compositeKey(target.kind, id));
+        return { tier: 'minted', target, handler, context, owner };
+    }
+    const dir = MOVE_STEP[id];
+    if (dir && target.getPath)
+        return { tier: 'move', target, path: target.getPath, dir };
+    if (isBuiltinCommandId(id)) {
+        return target.runCommand ? { tier: 'builtin', target } : { tier: 'no-surface' };
+    }
+    const installedElsewhere = isCommandRegistered(id) || blockCommands.has(compositeKey(target.kind, id));
+    return installedElsewhere && !handler ? { tier: 'unlisted' } : { tier: 'dead' };
 }
-/** The full walk: global first, then the kind tiers. Both the dispatch and the admissibility
- *  read spend this one, so a greyed affordance cannot disagree with the click under it. */
-function resolveCommand(id, target) {
-    const globalRun = getCommand(id);
+/** The full lookup: global commands first, then the block-level ones. Both the dispatch and the
+ *  "can this run" read use it, so a greyed-out button cannot disagree with the click under it. */
+function resolveCommand(id, target, activation) {
+    const globalRun = getCommand(id, activation);
     if (globalRun)
         return { tier: 'global', run: globalRun };
-    return resolveBlockLocalCommand(id, target);
+    return resolveBlockLocalCommand(id, target, activation);
 }
-/**
- * Spend a resolved kind tier. Containment is unconditional — the safety guarantee lives here, not
- * at the call sites, so an unwired caller still turns a plugin throw into a no-op, it just doesn't
- * report. A dead id declines loudly rather than reaching a `runCommand` with no arm for it.
- */
-function runBlockLocalCommand(resolved, id, arg, path, onCommandError) {
+/** Run a resolved block-level command, catching and reporting a plugin throw; an id no handler
+ *  answers declines with a warning. */
+function runBlockLocalCommand(resolved, id, arg, path, ctx) {
     switch (resolved.tier) {
-        case 'minted':
-            try {
-                return resolved.handler({ ...resolved.context, arg });
-            }
-            catch (error) {
-                onCommandError?.({ kind: resolved.target.kind, command: id, error });
-                return true;
-            }
+        case 'minted': {
+            const { owner, handler, context, target } = resolved;
+            const editor = pluginEditorFor(ctx.pluginEditor, owner);
+            return runPluginCommand(owner, { kind: target.kind, command: id }, ctx.onCommandError, () => handler({ ...context, editor, arg }));
+        }
         case 'builtin':
-            return resolved.target.runCommand(id, arg);
+            return resolved.target.runCommand?.(id, arg) ?? false;
+        case 'move': {
+            const { target, path, dir } = resolved;
+            const move = () => void ctx.reorder.nudgeReorderUnit(path(), dir);
+            if (target.afterSourceCommit)
+                target.afterSourceCommit(move);
+            else
+                move();
+            return true;
+        }
         case 'dead':
             warnDeadKeyCommand(id, path);
             return false;
         case 'no-surface':
+        case 'unlisted':
             return false;
     }
 }
 /**
- * Where an id goes with a range painted. The one-block arms have no host block to take their
- * offsets from, so they either route to the cross-block arm or decline; everything else is
- * range-safe and runs on the focused surface (`RANGE_DECLINED_COMMAND_IDS` in `./commands`).
+ * While a selection spans blocks, a single-block command routes to the cross-block handler or
+ * declines (`RANGE_DECLINED_COMMAND_IDS`); anything else runs on the focused block.
  */
 function rangeRouteFor(id, gates) {
     // Called directly, not optionally: a caller without the getter throws rather than skipping.
@@ -90,24 +100,11 @@ function rangeRouteFor(id, gates) {
     if (!CROSS_BLOCK_RANGE_COMMAND_IDS.has(id))
         return { kind: 'block-local', ranged: true };
     const router = gates.crossBlockCommands;
-    return router?.canRun(id) ? { kind: 'cross-block', router } : { kind: 'decline' };
+    return router.canRun(id) ? { kind: 'cross-block', router } : { kind: 'decline' };
 }
-/**
- * The gates every entry path owes, whatever resolved the id. Reading mode is inert: the whole
- * vocabulary dead-keys, and navigation never routes through commands, so a reader loses nothing.
- */
-function commandIsAdmissible(id, gates) {
-    if (isReadingMode(gates.getPresentationMode))
-        return false;
-    return rangeRouteFor(id, gates).kind !== 'decline';
-}
-/**
- * The id-keyed seam: chord dispatch enters with a resolved binding, `EditorInstance.runCommand`
- * with the id itself, so both meet the same gates and the same arms. Precedence is the leaf
- * order: global (undo/redo) → minted block command → built-in kind command. A null target means
- * no focused surface, where the global tier still runs and the block-local tiers decline.
- */
-function runResolvedCommand(id, arg, target, ctx, path, onCommandError) {
+/** The one dispatch keyed by id, which a chord and `EditorInstance.runCommand` both reach. With no
+ *  focused block (a null target) only global commands run; reading mode runs none. */
+function runResolvedCommand(id, arg, target, ctx, path) {
     if (isReadingMode(ctx.getPresentationMode))
         return false;
     const route = rangeRouteFor(id, ctx);
@@ -115,18 +112,14 @@ function runResolvedCommand(id, arg, target, ctx, path, onCommandError) {
         return false;
     if (route.kind === 'cross-block')
         return route.router.run(id);
-    const resolved = resolveCommand(id, target);
-    // Inject the sink so a plugin-global handler's contained throw reports through the same
-    // channel as a block command's; the global tier is the only path reaching one.
+    const resolved = resolveCommand(id, target, ctx.activation);
     if (resolved.tier === 'global')
-        return resolved.run({ ...ctx, onCommandError });
-    return runBlockLocalCommand(resolved, id, arg, path, onCommandError);
+        return resolved.run({ ...ctx, arg });
+    return runBlockLocalCommand(resolved, id, arg, path, ctx);
 }
 /**
- * The door's admissibility read: the gates plus the same tier walk the dispatch spends, never a
- * second derivation of them. Silent by design — a host may ask on every selection change, so an
- * unreachable id spends none of the dispatch's one-time dead-key diagnostics.
- * See `editor-props.ts` for the contract this answers.
+ * The read behind `EditorInstance.canRunCommand`, through the dispatch's own checks and lookup.
+ * Silent, since a host may ask on every selection change and must not spend the dead-key warnings.
  */
 export function canRunCommandById(id, target, gates) {
     if (isReadingMode(gates.getPresentationMode))
@@ -134,46 +127,40 @@ export function canRunCommandById(id, target, gates) {
     const route = rangeRouteFor(id, gates);
     if (route.kind !== 'block-local')
         return route.kind === 'cross-block';
-    const { tier } = resolveCommand(id, target);
-    return tier !== 'dead' && tier !== 'no-surface';
+    const { tier } = resolveCommand(id, target, gates.activation);
+    return tier === 'global' || tier === 'minted' || tier === 'builtin' || tier === 'move';
 }
-/** The door's pressed-state read, `canRunCommandById`'s sibling: state rather than
- *  admissibility, so a disabled affordance may still paint pressed. Whoever would spend the
- *  press answers — the cross-block arm over a range, the focused surface at a caret. */
+/** The read behind `EditorInstance.isCommandActive`: state, not permission, so a disabled button
+ *  may still show pressed. Whoever would run the command answers. */
 export function isCommandActiveById(id, target, gates) {
     const route = rangeRouteFor(id, gates);
     if (route.kind === 'cross-block')
         return route.router.isActive(id);
-    // A range no arm reads has no pressed state: the focused surface holds a parked caret, whose
-    // bytes are not the ones a press would rewrite.
+    // A selection no handler reads has no pressed state: the focused block only holds a resting
+    // caret, whose bytes are not the ones the command would rewrite.
     if (route.kind === 'decline' || route.ranged)
         return false;
     return target?.isCommandActive?.(id) ?? false;
 }
-/** The `EditorInstance.runCommand` door: an id with no keystroke behind it. */
-export function runCommandById(id, arg, target, ctx, onCommandError) {
-    return runResolvedCommand(id, arg, target, ctx, 'door', onCommandError);
+/** The `EditorInstance.runCommand` entry point: an id with no keystroke behind it. */
+export function runCommandById(id, arg, target, ctx) {
+    return runResolvedCommand(id, arg, target, ctx, 'door');
 }
-/** Leaf-path chord dispatch (the focused editable/chrome surface). */
-export function dispatchKeyCommand(chord, target, ctx, overrides, onCommandError) {
-    const binding = resolveBinding(chord, target.kind, overrides, ctx.activation);
+/** Chord dispatch on the focused leaf: an editable block, or a container's title row. */
+export function dispatchKeyCommand(chord, target, ctx) {
+    const binding = resolveBinding(chord, target.kind, ctx.keybindingOverrides(), ctx.activation);
     if (!binding)
         return false;
-    return runResolvedCommand(binding.command, binding.arg, target, ctx, 'chord', onCommandError);
+    return runResolvedCommand(binding.command, binding.arg, target, ctx, 'chord');
 }
-/**
- * Container-bubble dispatch. Kind-only, no global tier: undo/redo belong to the focused leaf,
- * and a container bubble re-firing them would double-fire (`resolveKindBinding` in `./commands`).
- * The bubble callers hold no GlobalCommandContext, so they pass the gates directly — and an
- * override that resolves a GLOBAL id here resolves DEAD, declining loudly rather than being
- * dropped by a `runCommand` that has no arm for it.
- */
-export function dispatchKindCommand(chord, target, gates, overrides, onCommandError) {
-    const binding = resolveKindBinding(chord, target.kind, overrides);
-    if (!binding)
+/** Dispatch for a chord at a container: kind commands only, since undo/redo and the range
+ *  commands belong to the focused leaf and would otherwise fire twice. */
+export function dispatchKindCommand(chord, target, ctx) {
+    const binding = resolveKindBinding(chord, target.kind, ctx.keybindingOverrides());
+    if (!binding || isReadingMode(ctx.getPresentationMode))
         return false;
-    if (!commandIsAdmissible(binding.command, gates))
+    if (rangeRouteFor(binding.command, ctx).kind !== 'block-local')
         return false;
-    const resolved = resolveBlockLocalCommand(binding.command, target);
-    return runBlockLocalCommand(resolved, binding.command, binding.arg, 'chord', onCommandError);
+    const resolved = resolveBlockLocalCommand(binding.command, target, ctx.activation);
+    return runBlockLocalCommand(resolved, binding.command, binding.arg, 'chord', ctx);
 }

package/dist/schema/block-completions.d.ts

@@ -1,15 +1,15 @@
 /**
  * Per-kind Enter-completion registry, the block-opener registry's sibling: an opener recognizes
- * a line while parsing, a completer recognizes a lone typed line at an Enter press and answers
- * the canonical lines that complete it. Published on `plugin.ts`, so its plugin entries clear
- * through `registry-reset.ts` like every other public register-once seam.
+ * a line while parsing, a completer recognizes a lone typed line when Enter is pressed and
+ * returns the canonical lines that complete it.
  */
 import { type AnyBlockKind } from '../core/nodes';
+import type { GrammarView } from './block-openers';
 /**
- * The replacement, as lines WITHOUT endings — the seam attaches the block's own (G4.20) — plus
- * where the caret seats: `path` is child indices inside the minted block, empty for the block,
- * and `line`/`column` address a position inside THAT node. Line-relative rather than a byte
- * offset because the seam picks the line ending after the claim, so only it can count bytes.
+ * The replacement, as lines with no line endings: the Enter handler attaches the block's own, else
+ * the document's. `caret.path` is the child indices inside the new block, empty for the block itself,
+ * and `line`/`column` are a position inside that node. Line-relative rather than a byte offset
+ * because the Enter handler picks the line ending afterwards, so only it can count bytes.
  */
 export interface CompletionResult {
     lines: string[];
@@ -20,22 +20,19 @@ export interface CompletionResult {
     };
 }
 export interface BlockCompleter {
-    /** Attempt to complete `line`; null declines, as does a claim whose lines would paint nothing. */
+    /** Attempt to complete `line`; null declines, and so does a result whose lines render nothing. */
     tryComplete(line: string): CompletionResult | null;
     /**
-     * Also consulted as the line is TYPED, not only at Enter — for a claim that can only ever mean
-     * one thing the moment it is complete (a lone `$$`), so the block forms as a ` ``` ` fence does.
-     * Off by default: a table's header row is a prefix of a longer row the user may still be typing.
+     * Also tried as the line is typed, for a line that means one thing once complete (a lone `$$`).
+     * Off by default, since a table's header row may be a longer row the user is still typing.
      */
     onType?: boolean;
 }
 export declare function registerBlockCompleter(kind: AnyBlockKind, completer: BlockCompleter): void;
-/** The first claim on `line`, or null when no registered completer takes it. */
-export declare function completeTypedLine(line: string): CompletionResult | null;
-/** The first claim on `line` among the completers that answer as the line is typed. */
-export declare function completeLineOnType(line: string): CompletionResult | null;
-/** Whether `kind` already owns a completer — the probe a registrar re-run reads before it
- *  registers, so a re-installed plugin never trips the register-once throw. */
+/** The first completion for `line`, or null when no completer the editor's grammar allows takes it. */
+export declare function completeTypedLine(line: string, grammar: GrammarView): CompletionResult | null;
+/** The first completion for `line` among the completers that answer as the line is typed. */
+export declare function completeLineOnType(line: string, grammar: GrammarView): CompletionResult | null;
+/** Does `kind` already have a completer? A plugin that may register twice checks this first,
+ *  so re-installing it never trips the register-once throw. */
 export declare function isBlockCompleterRegistered(kind: string): boolean;
-export declare function __resetBlockCompletersForTests(): void;
-export declare function __removePluginCompletersForTests(): void;

package/dist/schema/block-completions.js

@@ -1,42 +1,44 @@
 /**
  * Per-kind Enter-completion registry, the block-opener registry's sibling: an opener recognizes
- * a line while parsing, a completer recognizes a lone typed line at an Enter press and answers
- * the canonical lines that complete it. Published on `plugin.ts`, so its plugin entries clear
- * through `registry-reset.ts` like every other public register-once seam.
+ * a line while parsing, a completer recognizes a lone typed line when Enter is pressed and
+ * returns the canonical lines that complete it.
  */
 import { isBuiltinBlockKind } from '../core/nodes';
-import { deletePluginEntries, registerOnce } from './register-once';
-const completers = new Map();
+import { resolvesIn } from './plugin-activation';
+import { createBlockKindRegistry } from './plugin-registry';
 let orderedCache = null;
+const completers = createBlockKindRegistry({
+    label: 'registerBlockCompleter',
+    isBuiltin: isBuiltinBlockKind,
+    onChange: () => (orderedCache = null)
+});
 export function registerBlockCompleter(kind, completer) {
-    registerOnce(completers.has(kind), () => {
-        completers.set(kind, completer);
-        orderedCache = null;
-    }, `registerBlockCompleter: "${kind}" is already registered. Completers are register-once.`);
+    completers.register(kind, completer, `registerBlockCompleter: "${kind}" is already registered. Completers are register-once.`);
 }
-// Kind-name order, so which completer is consulted first is a pure function of the declarations
-// and never of registration order — the openers' rule, minus a priority no conflict has asked for.
+// Kind-name order, so which completer runs first never depends on registration order.
 function ordered() {
     if (!orderedCache) {
-        orderedCache = [...completers.entries()]
-            .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
-            .map(([, completer]) => completer);
+        orderedCache = completers
+            .records()
+            .sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
     }
     return orderedCache;
 }
-/** The first claim on `line`, or null when no registered completer takes it. */
-export function completeTypedLine(line) {
-    for (const completer of ordered()) {
+/** The first completion for `line`, or null when no completer the editor's grammar allows takes it. */
+export function completeTypedLine(line, grammar) {
+    for (const { value: completer, owner } of ordered()) {
+        if (!resolvesIn(grammar.activation, owner))
+            continue;
         const claim = completer.tryComplete(line);
         if (claim)
             return claim;
     }
     return null;
 }
-/** The first claim on `line` among the completers that answer as the line is typed. */
-export function completeLineOnType(line) {
-    for (const completer of ordered()) {
-        if (!completer.onType)
+/** The first completion for `line` among the completers that answer as the line is typed. */
+export function completeLineOnType(line, grammar) {
+    for (const { value: completer, owner } of ordered()) {
+        if (!completer.onType || !resolvesIn(grammar.activation, owner))
             continue;
         const claim = completer.tryComplete(line);
         if (claim)
@@ -44,17 +46,8 @@ export function completeLineOnType(line) {
     }
     return null;
 }
-/** Whether `kind` already owns a completer — the probe a registrar re-run reads before it
- *  registers, so a re-installed plugin never trips the register-once throw. */
+/** Does `kind` already have a completer? A plugin that may register twice checks this first,
+ *  so re-installing it never trips the register-once throw. */
 export function isBlockCompleterRegistered(kind) {
     return completers.has(kind);
 }
-export function __resetBlockCompletersForTests() {
-    completers.clear();
-    orderedCache = null;
-}
-// The unified schema reset preserves built-ins for tests that merely add plugin kinds.
-export function __removePluginCompletersForTests() {
-    deletePluginEntries(completers, isBuiltinBlockKind);
-    orderedCache = null;
-}

package/dist/schema/block-component-registry.d.ts

@@ -6,28 +6,27 @@ import type { Component } from 'svelte';
 import { type AnyBlockKind } from '../core/nodes';
 import type { NodeView } from '../core/node-views';
 import type { BlockComponentExports, BlockComponentProps } from '../block-component';
+import type { PluginActivation } from './plugin-activation';
+import { type EditorContext } from './plugin-install';
 export interface BlockComponentEntry {
     /**
-     * Declaring `BlockComponentExports` as the Exports lets BlockHost's `bind:this` type-check
-     * against a runtime-picked component, and pins the two shapes a block may publish: the
-     * surface itself (a leaf) or a container's single `containerApi`.
+     * Typed with `BlockComponentExports` so BlockHost's `bind:this` type-checks a component picked
+     * at runtime, which must expose a leaf's editable element or a container's `containerApi`.
      */
     component: Component<Record<string, unknown>, BlockComponentExports>;
     extraProps?: (node: NodeView) => Record<string, unknown>;
 }
 /**
- * Typed constructor for a registry entry: the component publishes one of the two sanctioned
- * surface shapes, and its props are a subset of what BlockHost passes. A container that forgot
- * its `containerApi` fails here rather than mounting as a block nothing can focus. The internal
- * cast widens contravariant props to the registry's `Record<string, unknown>`.
+ * Typed constructor for a registry entry, so a container that forgot its `containerApi`, or props
+ * BlockHost never passes, fail to compile rather than mount as a block nothing can focus.
  */
 export declare function defineBlockComponent<P extends Partial<BlockComponentProps> & Record<string, unknown>>(component: Component<P, BlockComponentExports>, extraProps?: (node: NodeView) => Record<string, unknown>): BlockComponentEntry;
 export declare function registerBlockComponent(kind: AnyBlockKind, entry: BlockComponentEntry): void;
-export declare function getBlockComponent(kind: AnyBlockKind): BlockComponentEntry | undefined;
-/**
- * Probe whether a component is registered — `registerBlockComponent` throws on duplicate, so a
- * plugin registering idempotently (HMR / re-import) guards on this. Takes a plain name.
- */
+/** The kind's component where `activation` resolves the plugin that owns the kind. */
+export declare function getBlockComponent(kind: AnyBlockKind, activation: PluginActivation): BlockComponentEntry | undefined;
+/** An editor's `EditorContext` for the plugin the kind's component answers to, which is the
+ *  context the component's `getEditor` reads. */
+export declare function componentPluginEditor(pluginEditor: ((pluginName: string) => EditorContext | undefined) | undefined, kind: AnyBlockKind): EditorContext | undefined;
+/** `registerBlockComponent` throws on a duplicate, so a plugin that may register twice (hot
+ *  reload, re-import) checks this first. */
 export declare function isBlockComponentRegistered(kind: string): boolean;
-/** Test-only. Removes every non-built-in component entry; built-ins survive. */
-export declare function __removePluginComponentsForTests(): void;

package/dist/schema/block-component-registry.js

@@ -3,31 +3,33 @@
  * kinds register a descriptor plus a component entry.
  */
 import { isBuiltinBlockKind } from '../core/nodes';
-import { deletePluginEntries, registerOnce } from './register-once';
+import { pluginEditorFor } from './plugin-install';
+import { createBlockKindRegistry } from './plugin-registry';
 /**
- * Typed constructor for a registry entry: the component publishes one of the two sanctioned
- * surface shapes, and its props are a subset of what BlockHost passes. A container that forgot
- * its `containerApi` fails here rather than mounting as a block nothing can focus. The internal
- * cast widens contravariant props to the registry's `Record<string, unknown>`.
+ * Typed constructor for a registry entry, so a container that forgot its `containerApi`, or props
+ * BlockHost never passes, fail to compile rather than mount as a block nothing can focus.
  */
 export function defineBlockComponent(component, extraProps) {
     return { component: component, extraProps };
 }
-const registry = new Map();
+const registry = createBlockKindRegistry({
+    label: 'registerBlockComponent',
+    isBuiltin: isBuiltinBlockKind
+});
 export function registerBlockComponent(kind, entry) {
-    registerOnce(registry.has(kind), () => registry.set(kind, entry), `registerBlockComponent: "${kind}" is already registered. Components are register-once.`);
+    registry.register(kind, entry, `registerBlockComponent: "${kind}" is already registered. Components are register-once.`);
 }
-export function getBlockComponent(kind) {
-    return registry.get(kind);
+/** The kind's component where `activation` resolves the plugin that owns the kind. */
+export function getBlockComponent(kind, activation) {
+    return registry.get(kind, activation);
 }
-/**
- * Probe whether a component is registered — `registerBlockComponent` throws on duplicate, so a
- * plugin registering idempotently (HMR / re-import) guards on this. Takes a plain name.
- */
+/** An editor's `EditorContext` for the plugin the kind's component answers to, which is the
+ *  context the component's `getEditor` reads. */
+export function componentPluginEditor(pluginEditor, kind) {
+    return pluginEditorFor(pluginEditor, registry.ownerOf(kind));
+}
+/** `registerBlockComponent` throws on a duplicate, so a plugin that may register twice (hot
+ *  reload, re-import) checks this first. */
 export function isBlockComponentRegistered(kind) {
     return registry.has(kind);
 }
-/** Test-only. Removes every non-built-in component entry; built-ins survive. */
-export function __removePluginComponentsForTests() {
-    deletePluginEntries(registry, isBuiltinBlockKind);
-}