@voithos-labs/aragonite 0.10.1

package/dist/schema/child-spans.js

@@ -0,0 +1,161 @@
+/**
+ * Byte offsets of each child's rendered region inside its container's own `raw`, so a typing
+ * rewrite splices one region instead of re-joining every child (O(1) reads through the `$state`
+ * proxy rather than O(children)). Bookkeeping, never bytes: nothing serializes or renders it, and
+ * a span the invalidation seams missed fails the region check below and falls back to the full
+ * rebuild. A `Uint32Array` on purpose — Svelte proxies plain arrays, and the shift would mint a
+ * source per element.
+ */
+import { DEV } from 'esm-env';
+import { makeBlockNode } from '../core/nodes';
+import { assertInvariant } from '../assert';
+import { perfEnabled } from '../perf/instruments';
+import { concatChildren } from '../core/serializer';
+import { splitLines } from '../core/lines';
+/** Drop the spans a children-shape change invalidated; the next full rebuild reseeds them. */
+export function dropChildSpans(node) {
+    // Tested, not assigned blind: a bare write would mint the field on every node it passes.
+    if (node.childSpans)
+        node.childSpans = undefined;
+}
+// ── Rebuilds ─────────────────────────────────────────────────────────────────
+/** A container whose raw is its children's bytes joined (list). */
+export function rebuildConcatRaw(node, changed) {
+    const children = node.children;
+    if (changed &&
+        spliceChildRegion(node, children, changed, renderVerbatim) &&
+        spliceIsFaithful(node, rebuildConcatRaw)) {
+        return;
+    }
+    const spans = new Uint32Array(children.length * 2);
+    let out = '';
+    for (let i = 0; i < children.length; i++) {
+        // One indexed read per child: the array is a `$state` proxy and each one is a trap.
+        const child = children[i];
+        spans[i * 2] = out.length;
+        out += child.leadingTrivia + child.raw;
+        spans[i * 2 + 1] = out.length;
+    }
+    node.raw = out;
+    node.childSpans = spans;
+}
+/**
+ * A container whose raw re-prefixes every line of its body (blockquote, list item). `innerPrefix`
+ * is unread: these kinds open their body on their own first line, so no parse fills it (G1.5).
+ */
+export function rebuildStripRaw(node, prefix, changed) {
+    const children = node.children;
+    const render = (text, first) => renderPrefixed(text, prefix, first);
+    if (changed &&
+        spliceChildRegion(node, children, changed, render) &&
+        spliceIsFaithful(node, (scratch) => rebuildStripRaw(scratch, prefix))) {
+        return;
+    }
+    const spans = new Uint32Array(children.length * 2);
+    let out = '';
+    // A child ending mid-line shares that line with whatever follows, so the two would be
+    // prefixed separately: the whole-body rebuild is the only faithful answer for that shape.
+    let openLine = false;
+    for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        const text = child.leadingTrivia + child.raw;
+        if (openLine && text !== '')
+            return rebuildWholeStrip(node, prefix);
+        spans[i * 2] = out.length;
+        out += render(text, out.length === 0);
+        spans[i * 2 + 1] = out.length;
+        if (text !== '')
+            openLine = !text.endsWith('\n');
+    }
+    const suffix = node.innerSuffix ?? '';
+    if (suffix !== '') {
+        if (openLine)
+            return rebuildWholeStrip(node, prefix);
+        out += render(suffix, out.length === 0);
+    }
+    node.raw = out;
+    node.childSpans = spans;
+}
+function rebuildWholeStrip(node, prefix) {
+    node.childSpans = undefined;
+    node.raw = renderPrefixed(concatChildren(node.children) + (node.innerSuffix ?? ''), prefix, true);
+}
+// ── Rendering ────────────────────────────────────────────────────────────────
+const renderVerbatim = (text) => text;
+function renderPrefixed(text, prefix, first) {
+    if (text === '')
+        return '';
+    let out = '';
+    const lines = splitLines(text);
+    for (let i = 0; i < lines.length; i++) {
+        out += prefix(lines[i].text, first && i === 0) + lines[i].lineEnding;
+    }
+    return out;
+}
+/**
+ * G1.38: re-derives the whole raw on a scratch and refuses a splice that disagrees, so a sibling's
+ * bytes moving under the spans cannot ship. Dev only, and off under the perf instruments, whose
+ * numbers would otherwise be measuring this.
+ */
+function spliceIsFaithful(node, rebuildFull) {
+    if (!DEV || perfEnabled())
+        return true;
+    const scratch = makeBlockNode({
+        kind: node.kind,
+        leadingTrivia: node.leadingTrivia,
+        raw: node.raw,
+        metadata: node.metadata,
+        children: node.children,
+        innerPrefix: node.innerPrefix,
+        innerSuffix: node.innerSuffix
+    });
+    rebuildFull(scratch);
+    if (scratch.raw === node.raw)
+        return true;
+    assertInvariant('child-spans-faithful', () => ({
+        code: 'child-spans-faithful',
+        message: `${node.kind}: the spliced raw differs from a full rebuild of the same children`,
+        detail: { kind: node.kind }
+    }));
+    return false;
+}
+// ── The splice ───────────────────────────────────────────────────────────────
+/**
+ * Rewrite one child's region in place, or decline so the caller reseeds. Declines cover every
+ * way the spans can have stopped describing `raw`: the region check is what turns a span the
+ * invalidation seams missed into a slower rebuild instead of a corruption.
+ */
+function spliceChildRegion(node, children, changed, render) {
+    const spans = node.childSpans;
+    if (!spans || spans.length !== children.length * 2)
+        return false;
+    const child = children[changed.index];
+    if (!child)
+        return false;
+    const start = spans[changed.index * 2];
+    const end = spans[changed.index * 2 + 1];
+    const raw = node.raw;
+    if (start > end || end > raw.length)
+        return false;
+    const first = start === 0;
+    const trivia = child.leadingTrivia;
+    if (raw.slice(start, end) !== render(trivia + changed.previousRaw, first))
+        return false;
+    const rendered = render(trivia + child.raw, first);
+    if (end < raw.length) {
+        // Nothing may reach across the regions that follow: a body running past its own last
+        // line ending would share it, and an emptied opening region hands line 0 to the next child.
+        if (rendered !== '' && !rendered.endsWith('\n'))
+            return false;
+        if (first && end > start !== (rendered !== ''))
+            return false;
+    }
+    node.raw = raw.slice(0, start) + rendered + raw.slice(end);
+    const delta = rendered.length - (end - start);
+    if (delta !== 0) {
+        spans[changed.index * 2 + 1] = end + delta;
+        for (let i = changed.index * 2 + 2; i < spans.length; i++)
+            spans[i] += delta;
+    }
+    return true;
+}

package/dist/schema/closure.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The tier × subsystem closure matrix as a type: every block-kind registration carries a
+ * `ClosureBlock`, so a blank cell is a compile error (`docs/design/plugin-contract.md` § "Editable
+ * content and the closure matrix"). Dependency-free leaf — `core/directive/kinds.ts` imports
+ * it, so it must not import back toward core. Honesty rule (coherence-checked by G1.24):
+ * `implemented` names a real mechanism; never claim a capability to fill a cell.
+ */
+/** The cross-cutting systems a caret-bearing kind meets — one per matrix column. */
+export type ClosureColumn = 'roundTrip' | 'focus' | 'mergeBackspace' | 'selectionPaint' | 'searchPaint' | 'reorder' | 'undo' | 'clipboard' | 'simOracle';
+export type ClosureCell = {
+    mode: 'implemented';
+    via: string;
+} | {
+    mode: 'inherit-default';
+} | {
+    mode: 'not-supported';
+    reason: string;
+};
+/** `Record<ClosureColumn, …>` — a missing column is a compile error. */
+export type ClosureBlock = Record<ClosureColumn, ClosureCell>;
+/**
+ * `focus`, `searchPaint`, `undo`, and `simOracle` genuinely vary with the leaf's own component,
+ * so `simpleLeafClosure` requires them — the matrix's force-an-answer discipline kept exactly
+ * where the answer is the author's. The five baked columns stay optionally overridable.
+ */
+export type SimpleLeafClosureCells = Pick<ClosureBlock, 'focus' | 'searchPaint' | 'undo' | 'simOracle'> & Partial<Pick<ClosureBlock, 'roundTrip' | 'mergeBackspace' | 'selectionPaint' | 'reorder' | 'clipboard'>>;
+/** Sugar over the same required `closure` field: bakes the five structurally-fixed leaf columns, demands the four the author's component determines. */
+export declare function simpleLeafClosure(cells: SimpleLeafClosureCells): ClosureBlock;
+/**
+ * `roundTrip` is `implemented` for any container (its `rebuildRaw` IS the mechanism, G1.24), so
+ * the preset bakes the mode and demands only its `via`, making the inherit-default violation
+ * unrepresentable here. `focus`/`mergeBackspace`/`undo`/`simOracle` vary with the container, so
+ * they are required; the four structural columns stay overridable.
+ */
+export type ContainerClosureCells = {
+    roundTripVia: string;
+} & Pick<ClosureBlock, 'focus' | 'mergeBackspace' | 'undo' | 'simOracle'> & Partial<Pick<ClosureBlock, 'selectionPaint' | 'searchPaint' | 'reorder' | 'clipboard'>>;
+/** Sugar over the same required `closure` field: bakes the four structural strip-container columns and `roundTrip: implemented`, demands the container-specific cells. */
+export declare function containerClosure(cells: ContainerClosureCells): ClosureBlock;

package/dist/schema/closure.js

@@ -0,0 +1,55 @@
+/**
+ * The tier × subsystem closure matrix as a type: every block-kind registration carries a
+ * `ClosureBlock`, so a blank cell is a compile error (`docs/design/plugin-contract.md` § "Editable
+ * content and the closure matrix"). Dependency-free leaf — `core/directive/kinds.ts` imports
+ * it, so it must not import back toward core. Honesty rule (coherence-checked by G1.24):
+ * `implemented` names a real mechanism; never claim a capability to fill a cell.
+ */
+// ── Simple-leaf preset ──────────────────────────────────────────────────────
+/**
+ * The five columns every not-mergeable, childless, source-editable `createEditableLeaf` leaf
+ * answers identically — structurally fixed, so re-typing them teaches an author nothing.
+ * NOT for containers (G1.24 forces `roundTrip: implemented` on them) nor whole-block-focus
+ * opaque leaves (they paint a cover rect, not partial rects); those hand-write every column.
+ */
+const SIMPLE_LEAF_BAKED = {
+    roundTrip: { mode: 'inherit-default' },
+    mergeBackspace: {
+        mode: 'implemented',
+        via: 'not-mergeable — Backspace at the edge moves focus, never concatenates'
+    },
+    selectionPaint: { mode: 'implemented', via: 'measurePartialRects (raw offsets)' },
+    reorder: { mode: 'implemented', via: 'whole-block drag reorder through the parent BlockList' },
+    clipboard: { mode: 'inherit-default' }
+};
+/** Sugar over the same required `closure` field: bakes the five structurally-fixed leaf columns, demands the four the author's component determines. */
+export function simpleLeafClosure(cells) {
+    return { ...SIMPLE_LEAF_BAKED, ...cells };
+}
+// ── Strip-container preset ────────────────────────────────────────────────────
+/**
+ * The four columns every strip container answers the same structural way: its children are the
+ * paint and search surfaces, it reorders whole-block through the parent BlockList, and it holds
+ * no clipboard anchor of its own. `reorder`/`clipboard` stay overridable below.
+ */
+const STRIP_CONTAINER_BAKED = {
+    selectionPaint: {
+        mode: 'implemented',
+        via: 'child blocks paint natively; the container paints a cover rect spanning them'
+    },
+    searchPaint: {
+        mode: 'implemented',
+        via: 'search descends into the real child blocks; marks overlay per child'
+    },
+    reorder: { mode: 'implemented', via: 'whole-block reorder through the parent BlockList' },
+    clipboard: { mode: 'inherit-default' }
+};
+/** Sugar over the same required `closure` field: bakes the four structural strip-container columns and `roundTrip: implemented`, demands the container-specific cells. */
+export function containerClosure(cells) {
+    const { roundTripVia, ...rest } = cells;
+    return {
+        ...STRIP_CONTAINER_BAKED,
+        roundTrip: { mode: 'implemented', via: roundTripVia },
+        ...rest
+    };
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Plugin command-id brand + mint, mirroring the `PluginBlockKind` brand (core/nodes): a minted
+ * id is a plain branded string, so built-in `CommandId` switches stay exhaustive while the
+ * block-command registry keys plugin ids. Register-once.
+ */
+import { type CommandId } from './commands';
+declare const PluginCommandIdBrand: unique symbol;
+export type PluginCommandId = string & {
+    readonly [PluginCommandIdBrand]: true;
+};
+export type AnyCommandId = CommandId | PluginCommandId;
+/**
+ * Mint (or resolve) a plugin command id; `owner` is the installing plugin. The mint is
+ * name-global but dispatch is kind-scoped, so the same owner re-minting a name returns the
+ * existing brand; a different plugin (or an unattributed re-mint) throws, naming the prior owner.
+ */
+export declare function mintCommandId(name: string, owner?: string | null): PluginCommandId;
+export declare function isPluginCommandId(id: string): id is PluginCommandId;
+export declare function __resetMintedCommandIdsForTests(): void;
+export {};

package/dist/schema/command-id.js

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

package/dist/schema/commands.d.ts

@@ -0,0 +1,147 @@
+/**
+ * The command vocabulary, the global command registry, and chord→binding resolution. GLOBAL
+ * commands (undo/redo) are free functions over a minimal context; BLOCK-LOCAL ones run on the
+ * focused block or a registered block-command handler. The chord dispatchers live in
+ * `./block-commands`, not here, so this file carries no runtime edge to it. Schema leaf: it may
+ * not import action-contracts, so `GlobalCommandContext` is what `HistoryActions` satisfies.
+ */
+import type { AnyBlockKind } from '../core/nodes';
+import type { AnyCommandId } from './command-id';
+import { type KeyBinding } from './keybindings';
+import { type KeybindingOverrideMap } from './keybinding-overrides';
+import type { EditorContext } from './plugin-install';
+import type { PluginActivation } from './plugin-activation';
+import type { CommandErrorSink } from './block-commands';
+import type { PresentationMode } from '../presentation-mode';
+export declare const GLOBAL_COMMAND_IDS: readonly ["history.undo", "history.redo"];
+export declare const BLOCK_COMMAND_IDS: readonly ["block.split", "block.hardBreak", "block.insertTab", "block.mergePrev", "block.mergeNext", "block.moveUp", "block.moveDown", "format.toggleStrong", "format.toggleEmphasis", "format.toggleStrikethrough", "format.toggleCode", "link.openCard", "heading.cycle", "code.newline", "code.indent", "code.dedent", "code.backspace", "code.delete", "list.indent", "list.unindent", "cell.enter", "cell.tab", "cell.shiftTab", "table.insertRowBelow", "table.insertRowAbove", "table.insertColumnRight", "table.insertColumnLeft", "table.deleteRow", "table.deleteColumn", "table.moveRowUp", "table.moveRowDown", "table.moveColumnLeft", "table.moveColumnRight", "table.cycleAlignment", "chrome.descendToBody"];
+export type GlobalCommandId = (typeof GLOBAL_COMMAND_IDS)[number];
+export type BlockCommandId = (typeof BLOCK_COMMAND_IDS)[number];
+export type CommandId = GlobalCommandId | BlockCommandId;
+/**
+ * Commands whose arms rewrite one block's bytes around that block's own selection and have no
+ * cross-block reading: the dispatch seam declines them outright while a range is painted.
+ * Membership is the arm's shape, not the id's prefix — the link card mints its link over one
+ * block's offsets, and a range gives it no one block to mint into.
+ */
+export declare const RANGE_DECLINED_COMMAND_IDS: ReadonlySet<string>;
+/**
+ * The same one-block arms, but with a cross-block one behind them
+ * (`selection/cross-block/format-toggle.ts`), which the seam routes to through an injected
+ * router. Declined wherever no router is threaded, so a dispatch site that skips it cannot
+ * fall through to the focused block's own offsets.
+ */
+export declare const CROSS_BLOCK_RANGE_COMMAND_IDS: ReadonlySet<string>;
+/**
+ * The command ids a host's selection toolbar invokes through `EditorInstance.runCommand`. The
+ * rest of the vocabulary stays internal until the command registry unifies it.
+ */
+export declare const TOOLBAR_COMMANDS: {
+    readonly toggleStrong: "format.toggleStrong";
+    readonly toggleEmphasis: "format.toggleEmphasis";
+    readonly toggleStrikethrough: "format.toggleStrikethrough";
+    readonly toggleCode: "format.toggleCode";
+    /** The link editor Mod+K opens: over a selection it creates, inside a link it edits. */
+    readonly editLink: "link.openCard";
+};
+/** Minimal context a global command needs; HistoryActions is structurally compatible. */
+export interface GlobalCommandContext {
+    history: {
+        requestUndo(): void | Promise<void>;
+        requestRedo(): void | Promise<void>;
+    };
+    /** Per-instance context lookup, threaded from the dispatching editor; it resolves nothing
+     *  for a plugin installed in the process that this editor did not activate. */
+    pluginEditor?: (pluginName: string) => EditorContext | undefined;
+    /** The plugins the dispatching editor activated, so the process-global plugin-global tier
+     *  claims a chord only where its plugin is live. Required-nullable: a new dispatch context
+     *  must answer, and `undefined` is the answer of a caller holding no instance. */
+    activation: PluginActivation | undefined;
+    /** The effective presentation mode, read live — the reading-mode gate keys off this,
+     *  not the plugin lookup. Absent (a history-only context) means source. */
+    getPresentationMode?: () => PresentationMode;
+    /** Injected by dispatchKeyCommand — routes a contained handler throw. */
+    onCommandError?: CommandErrorSink;
+}
+export type GlobalCommandRun = (ctx: GlobalCommandContext) => boolean;
+export declare function registerCommand(id: AnyCommandId, run: GlobalCommandRun): void;
+export declare function getCommand(id: AnyCommandId): GlobalCommandRun | undefined;
+/** True when the id is in the closed built-in vocabulary. Takes a plain, unbranded name. */
+export declare function isBuiltinCommandId(id: string): boolean;
+/**
+ * Test-only. Removes every command outside the closed built-in vocabulary; the plugin-global
+ * chord keymap resets separately (`__resetPluginGlobalKeymapForTests`).
+ */
+export declare function __removePluginCommandsForTests(): void;
+/** Which seam found the command dead. Half the memo key below: a no-op at one seam must not
+ *  spend the one-time diagnostic another seam still owes. */
+export type CommandDispatchPath = 'chord' | 'door' | 'plugin-global' | 'global-chord';
+/**
+ * Dev-warn once per (id, path) that a command reached no runnable handler at `path` — a dead
+ * key. Unreachable, not unregistered: a minted command resolves only where the dispatch target
+ * supplies a command context.
+ */
+export declare function warnDeadKeyCommand(id: AnyCommandId, path: CommandDispatchPath): void;
+/** Test-only. Clears the dead-key warn memo so each test sees a first-time warn. */
+export declare function __resetCommandWarningsForTests(): void;
+export declare const GLOBAL_KEYMAP: KeyBinding[];
+/**
+ * True when the editor UI intercepts a chord outside the command resolvers. The single source
+ * both the plugin-global registration guard and the editor-root keydown handler read.
+ */
+export declare function isReservedUiChord(chord: string): boolean;
+/** The same pair, for the callers that must enumerate it rather than test one chord. */
+export declare function reservedUiChords(): readonly string[];
+/**
+ * `candidateCommand` is the id the incoming registration will bind (the mint is deterministic:
+ * name IS the id). A dev-server re-eval re-binding its OWN command to its OWN chord is an
+ * idempotent replace, not a collision; reserved chords and cross-command collisions still throw.
+ */
+export declare function assertPluginGlobalChordAvailable(rawChord: string, candidateCommand?: string): void;
+export declare function registerPluginGlobalBinding(binding: KeyBinding, plugin: string | null): void;
+export declare function pluginGlobalBinding(chord: string, activation: PluginActivation | undefined): KeyBinding | null;
+/** Every chord the plugin-global tier binds for `activation`. Registration is process-global,
+ *  so an absent activation reflects plugins any mounted editor installed. */
+export declare function pluginGlobalChords(activation: PluginActivation | undefined): readonly string[];
+export declare function __resetPluginGlobalKeymapForTests(): void;
+/**
+ * Container-bubble resolution: override(kind) → override(global) → built-in kind keymap. No
+ * built-in GLOBAL fallthrough — undo/redo belong to the focused leaf, and a bubble re-firing
+ * them would double-fire. Consumer overrides ARE honored at both scopes, so a global disable
+ * unbinds a chord a kind defines, and a global bind shadows the built-in kind binding.
+ */
+export declare function resolveKindBinding(chord: string, kind: AnyBlockKind, overrides?: KeybindingOverrideMap): KeyBinding | null;
+/**
+ * Leaf precedence: override(kind) → override(global) → built-in kind → built-in global. Override
+ * source dominates specificity, so a global disable suppresses a chord a kind defines.
+ */
+export declare function resolveBinding(chord: string, kind: AnyBlockKind, overrides: KeybindingOverrideMap | undefined, activation: PluginActivation | undefined): KeyBinding | null;
+/**
+ * True when the built-in keymap, or a plugin-global chord `activation` claims, binds this exact
+ * chord BEFORE any consumer override — never a modified variant like `Mod+Alt+Y`. Override-BLIND
+ * by design: it answers which chords carry a native browser default to suppress, not which
+ * command runs. A dispatch question reads `runGlobalChord`/`runGlobalChordOnKind`, which consult
+ * the override tier.
+ */
+export declare function isDefaultGlobalChord(chord: string, activation: PluginActivation | undefined): boolean;
+/**
+ * Resolve a chord at GLOBAL scope only, for input-layer sites with no focused block for a kind
+ * tier to apply to: a consumer global override, else the editor-global keymap.
+ */
+export declare function resolveGlobalBinding(chord: string, overrides: KeybindingOverrideMap | undefined, activation: PluginActivation | undefined): KeyBinding | null;
+/** Reading mode consumes a claimed chord and runs nothing: falling through would hand a
+ *  read-only document the browser's own history. */
+export interface GlobalChordContext extends GlobalCommandContext {
+    isReading: boolean;
+}
+/**
+ * Run whatever `chord` claims at global scope, for the surfaces with no focused block for a kind
+ * tier to apply to — the editor root's windowed-out caret, the gap caret's proxy. True means the
+ * press was CONSUMED, which a disabled chord is without running anything.
+ */
+export declare function runGlobalChord(chord: string, overrides: KeybindingOverrideMap | undefined, context: GlobalChordContext): boolean;
+/**
+ * The same, for a block that IS its own focus target: no inner leaf carries the global tier for
+ * it, so resolution takes the leaf precedence and a consumer's KIND-scoped rebind reaches here.
+ */
+export declare function runGlobalChordOnKind(chord: string, kind: AnyBlockKind, overrides: KeybindingOverrideMap | undefined, context: GlobalChordContext): boolean;