@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/schema/registration-pairs.js

@@ -0,0 +1,48 @@
+const wholeBlock = (r) => r.blockFocus === 'whole-block';
+export const INCOHERENT_REGISTRATION_PAIRS = [
+    {
+        id: 'content-start-without-range',
+        fields: 'contentStart with no contentStart.range',
+        reason: 'the content-start Backspace reads the range, so it would never fire',
+        holds: (r) => r.contentStart !== undefined && typeof r.contentStart.range !== 'function'
+    },
+    {
+        id: 'whole-block-inline',
+        fields: "blockFocus: 'whole-block' with supportsInline",
+        reason: 'a block focused as one unit has no caret positions for inline content to live at',
+        holds: (r) => wholeBlock(r) && r.supportsInline === true
+    },
+    {
+        id: 'whole-block-content-start',
+        fields: "blockFocus: 'whole-block' with contentStart",
+        reason: "no caret enters a block focused as one unit, so there's no content start",
+        holds: (r) => wholeBlock(r) && r.contentStart !== undefined
+    },
+    {
+        id: 'whole-block-title-row',
+        fields: "blockFocus: 'whole-block' with container.reservedChrome",
+        reason: 'a title row means the block is never childless, so whole-block focus never engages',
+        holds: (r) => wholeBlock(r) && r.container?.reservedChrome !== undefined
+    },
+    {
+        id: 'title-row-first-child-strategy',
+        fields: 'container.reservedChrome with unwrapRole.firstChildBackspace',
+        reason: 'Backspace at a title row always keeps it, so declare only middleChildBackspace',
+        holds: (r) => r.container?.reservedChrome !== undefined &&
+            r.container.unwrapRole?.firstChildBackspace !== undefined
+    },
+    {
+        id: 'keep-title-row-without-one',
+        fields: "firstChildBackspace: 'keep-reserved-chrome' with no container.reservedChrome",
+        reason: 'child 0 is body, so Backspace at its start would do nothing; declare a lifting one',
+        holds: (r) => r.container?.reservedChrome === undefined &&
+            r.container?.unwrapRole?.firstChildBackspace === 'keep-reserved-chrome'
+    }
+];
+export function rejectIncoherentPairs(kind, registration) {
+    for (const pair of INCOHERENT_REGISTRATION_PAIRS) {
+        if (!pair.holds(registration))
+            continue;
+        throw new Error(`registerBlockKind: "${kind}" declares ${pair.fields}; ${pair.reason}`);
+    }
+}

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

@@ -1,17 +1,15 @@
 /**
- * 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.
+ * The registrations waiting to be checked by `./registration-checks`. This module imports no
+ * registry on purpose: the registries that add to it register built-ins while their own module is
+ * still evaluating, so importing them back would run this module's code before its state exists.
  */
 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).
+ * Nothing queues before the first check, which covers the whole startup batch, except a late
+ * opener: a bare `parse()` uses the grammar without a check, so a later one waits for it (G1.17).
  */
 export declare function enqueueRegistrationCheck(kind: AnyBlockKind, origin?: 'descriptor' | 'opener'): void;
-/** Grammar-consumption latch: the parser's opener-dispatch read trips it. */
+/** Marks the grammar as used; the parser sets it the first time it reads the opener order. */
 export declare function markGrammarConsumed(): void;
 export declare function hasPendingRegistrationChecks(): boolean;
 export interface RegistrationFlushWork {
@@ -20,9 +18,7 @@ export interface RegistrationFlushWork {
     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.
+ * Take the outstanding work and clear it before any check runs: clearing first is what keeps a
+ * check that re-reads the grammar from starting another round of checks.
  */
 export declare function takeRegistrationFlushWork(): RegistrationFlushWork | null;
-export declare function __resetRegistrationChecksForTests(): void;

package/dist/schema/registration-pending.js

@@ -1,12 +1,11 @@
+import { enrollTestReset } from './registry-reset';
 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).
+ * Nothing queues before the first check, which covers the whole startup batch, except a late
+ * opener: a bare `parse()` uses the grammar without a check, so a later one waits for it (G1.17).
  */
 export function enqueueRegistrationCheck(kind, origin = 'descriptor') {
     if (origin === 'opener' && grammarConsumed)
@@ -15,7 +14,7 @@ export function enqueueRegistrationCheck(kind, origin = 'descriptor') {
         return;
     pendingKinds.add(kind);
 }
-/** Grammar-consumption latch: the parser's opener-dispatch read trips it. */
+/** Marks the grammar as used; the parser sets it the first time it reads the opener order. */
 export function markGrammarConsumed() {
     grammarConsumed = true;
 }
@@ -23,9 +22,8 @@ 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.
+ * Take the outstanding work and clear it before any check runs: clearing first is what keeps a
+ * check that re-reads the grammar from starting another round of checks.
  */
 export function takeRegistrationFlushWork() {
     if (didFirstFlush && pendingKinds.size === 0 && pendingLateOpeners.size === 0)
@@ -40,9 +38,11 @@ export function takeRegistrationFlushWork() {
     pendingLateOpeners.clear();
     return work;
 }
-export function __resetRegistrationChecksForTests() {
+function __resetRegistrationChecksForTests() {
     pendingKinds.clear();
     pendingLateOpeners.clear();
     didFirstFlush = false;
     grammarConsumed = false;
 }
+// A flag left behind by a cleared registry would make the next registrations look late.
+enrollTestReset(__resetRegistrationChecksForTests);

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

@@ -1,7 +1,11 @@
 /**
- * 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.
+ * The one test reset of the plugin platform: every registry and every piece of state that
+ * mirrors one enrolls its own reset here when its module loads, and the reset runs them all.
+ * Imports nothing, so any schema module may enroll without an import cycle.
  */
+/** Add process-global plugin state to the reset. A registry from `createPluginRegistry` enrolls
+ *  itself; other state that mirrors a registry enrolls when its module loads. */
+export declare function enrollTestReset(reset: () => void): void;
+/** Test-only. Drops every registration that is not a built-in, and the state that mirrors one
+ *  (installed plugins, registration checks, warning memos). `resetPluginPlatformForTests` runs it. */
 export declare function __resetSchemaRegistriesForTests(): void;

package/dist/schema/registry-reset.js

@@ -1,30 +1,17 @@
-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.
+ * The one test reset of the plugin platform: every registry and every piece of state that
+ * mirrors one enrolls its own reset here when its module loads, and the reset runs them all.
+ * Imports nothing, so any schema module may enroll without an import cycle.
  */
+const testResets = [];
+/** Add process-global plugin state to the reset. A registry from `createPluginRegistry` enrolls
+ *  itself; other state that mirrors a registry enrolls when its module loads. */
+export function enrollTestReset(reset) {
+    testResets.push(reset);
+}
+/** Test-only. Drops every registration that is not a built-in, and the state that mirrors one
+ *  (installed plugins, registration checks, warning memos). `resetPluginPlatformForTests` runs it. */
 export function __resetSchemaRegistriesForTests() {
-    __removePluginBlockKindsForTests();
-    __removePluginComponentsForTests();
-    __removePluginCompletersForTests();
-    __removePluginOpenersForTests();
-    __removePluginCommandsForTests();
-    __resetBlockCommandsForTests();
-    __resetInlineConstructPoliciesForTests();
-    __resetPluginGlobalKeymapForTests();
-    __resetCommandWarningsForTests();
-    __clearDeclaredPluginKindsForTests();
-    __resetRegistrationChecksForTests();
-    __resetInstalledPluginsForTests();
+    for (const reset of testResets)
+        reset();
 }

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

@@ -1,30 +1,42 @@
 /**
- * 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.
+ * Per-editor resolution over the process-wide definitions
+ * (`docs/design/plugin-contract.md` § Per-instance enablement). The default view resolves every
+ * installed plugin, as a bare `parse()` does; `plugins` leaves out an unlisted plugin's entries
+ * and `syntax` a switched-off syntax. The descriptor is never filtered: a disabled kind needs it.
  */
 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. */
+import { type PluginActivation } from './plugin-activation';
+/** `false` disables a plugin kind for one editor; built-ins are switched only by `syntax`. */
 export type KindEnablement = (kind: AnyBlockKind) => boolean;
+/** GFM syntaxes a host can switch off for one editor (the `syntax` prop); each is on by default. */
+export interface SyntaxOptions {
+    /** A line indented four columns (or by a tab) opens a code block. */
+    indentedCode?: boolean;
+    /** A `===` or `---` line under paragraph text makes it a heading. */
+    setextHeading?: boolean;
+}
 export interface RegistryView {
-    /** The kind's component, or `undefined` when unregistered OR disabled for this instance. */
+    /** The kind's component, or `undefined` when it is unregistered or disabled for this editor. */
     component(kind: AnyBlockKind): BlockComponentEntry | undefined;
-    /** The kind's descriptor — never filtered (required infrastructure); throws when absent. */
+    /** The kind's descriptor, never filtered because every kind needs one; throws when absent. */
     descriptor(kind: AnyBlockKind): BlockKindDescriptor;
     tryDescriptor(kind: AnyBlockKind): BlockKindDescriptor | undefined;
-    /** The block grammar this instance parses through (`parse(source, { grammar })`). */
+    /** The block grammar this editor 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;
+/**
+ * A kind whose plugin this editor did not activate, or whose setup threw, resolves no component
+ * and drops its opener; a kind no plugin owns, built-ins included, is never filtered.
+ */
+export declare function kindEnablementFor(activation: PluginActivation): KindEnablement;
 export declare function createRegistryView(opts?: {
+    /** The plugins this editor lists; absent activates every installed plugin. */
+    plugins?: PluginActivation;
+    /** A further kind filter, narrowing what `plugins` allows. */
     isEnabled?: KindEnablement;
+    syntax?: SyntaxOptions;
 }): RegistryView;
 export declare const defaultRegistryView: RegistryView;

package/dist/schema/registry-view.js

@@ -1,38 +1,44 @@
 /**
- * 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.
+ * Per-editor resolution over the process-wide definitions
+ * (`docs/design/plugin-contract.md` § Per-instance enablement). The default view resolves every
+ * installed plugin, as a bare `parse()` does; `plugins` leaves out an unlisted plugin's entries
+ * and `syntax` a switched-off syntax. The descriptor is never filtered: a disabled kind needs it.
  */
 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);
+import { everyInstalledPlugin, resolvesIn } from './plugin-activation';
+import { pluginKindOwner } from './plugin-kind';
+/**
+ * A kind whose plugin this editor did not activate, or whose setup threw, resolves no component
+ * and drops its opener; a kind no plugin owns, built-ins included, is never filtered.
+ */
+export function kindEnablementFor(activation) {
+    return (kind) => resolvesIn(activation, pluginKindOwner(kind));
 }
 export function createRegistryView(opts) {
-    const filter = opts?.isEnabled;
-    if (!filter)
+    const plugins = opts?.plugins;
+    const indentedCode = opts?.syntax?.indentedCode ?? true;
+    const setextHeading = opts?.syntax?.setextHeading ?? true;
+    if (!plugins && !opts?.isEnabled && indentedCode && setextHeading)
         return defaultRegistryView;
-    const enabled = (kind) => isBuiltinBlockKind(kind) || filter(kind);
+    const activation = plugins ?? everyInstalledPlugin;
+    const resolves = kindEnablementFor(activation);
+    const narrowed = opts?.isEnabled;
+    const enabled = (kind) => isBuiltinBlockKind(kind) || (resolves(kind) && (!narrowed || narrowed(kind)));
+    // A switched-off syntax leaves the grammar only: a block of that kind still renders.
+    const opens = (kind) => enabled(kind) && (indentedCode || kind !== 'indentedCode');
     return {
-        component: (kind) => (enabled(kind) ? getBlockComponent(kind) : undefined),
+        component: (kind) => (enabled(kind) ? getBlockComponent(kind, activation) : undefined),
         descriptor: (kind) => getBlockKindDescriptor(kind),
         tryDescriptor: (kind) => tryGetBlockKindDescriptor(kind),
-        grammar: createGrammarView(enabled)
+        grammar: createGrammarView(opens, { setextHeading, activation })
     };
 }
+const everyInstalledKind = kindEnablementFor(everyInstalledPlugin);
 export const defaultRegistryView = {
-    component: (kind) => getBlockComponent(kind),
+    component: (kind) => everyInstalledKind(kind) ? getBlockComponent(kind, everyInstalledPlugin) : undefined,
     descriptor: (kind) => getBlockKindDescriptor(kind),
     tryDescriptor: (kind) => tryGetBlockKindDescriptor(kind),
     grammar: defaultGrammarView

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

@@ -1,8 +1,8 @@
 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. */
+/** One library file that reads a KeyboardEvent modifier flag, and the chords it consumes. */
 export interface HardcodedChordSite {
-    /** Path under `src/lib`, as G4.29's scan reports it. */
+    /** Path under `src/lib`, as the source scan reports it. */
     file: string;
     /** Modifier chords the file consumes outside every keymap. */
     chords: readonly string[];
@@ -13,23 +13,22 @@ export interface HardcodedChordSite {
 }
 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
+    /** The instance's live `searchBar` value: with the bar off the editor consumes 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;
+    /** The plugins this instance activated: a chord another editor's plugin bound is not this
+     *  editor's. */
+    activation: PluginActivation;
 }
 /**
  * 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.
+ * plugin chords 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.
+ * True when `chords` holds this keystroke, under the editor's own normalization: Ctrl and Cmd
+ * both become `Mod`, so a consumer never re-derives the platform rule.
  */
 export declare function chordIsClaimed(event: KeyboardEvent, chords: ReadonlySet<string>): boolean;