@voithos-labs/aragonite 0.10.1

package/dist/testing/kind-conformance.js

@@ -0,0 +1,325 @@
+/**
+ * The generic per-kind conformance battery — the executable half of the closure matrix.
+ * Registering a block kind enrolls it: one cell per `ClosureColumn`, derived from the
+ * kind's `closure` block and `conformanceFixture`. A cell is executed only where its
+ * mechanism is headlessly observable; everything else is recorded as `boundary` or
+ * `exempt`, never stubbed green. Runner-agnostic — plain `Error`s, no runner import.
+ */
+import { displayLength, trimTrailingLineEnding } from '../core/lines';
+import { parse } from '../core/parser';
+import { serialize } from '../core/serializer';
+import { getBlockKindDescriptor } from '../schema/block-kind-descriptor';
+import { isMergeEligible } from '../schema/merge-rules';
+import { isWholeBlockUnit } from '../schema/whole-block-unit';
+import { collectCrossBlockText } from '../selection/clipboard-text';
+import { createSelectionState } from '../selection/selection-state.svelte';
+import { pathsEqual } from '../selection/path-math';
+import { scanDocument } from '../search/document-scan';
+import { compileMatcher } from '../search/matcher';
+import { createBlockEditActions } from '../editor-actions/block-edit';
+import { createUndoController } from '../editor-actions/commit/undo-controller';
+import { assert, assertIs, assertReasonDocumented, assertRebuildIsParseCanonical, fail, findFirstPathOfKind, nodeAtPath } from './conformance-core';
+import { createHeadlessActions } from './headless-actions';
+// ── Runner ───────────────────────────────────────────────────────────────────
+const CLOSURE_ORDER = [
+    'roundTrip',
+    'focus',
+    'mergeBackspace',
+    'selectionPaint',
+    'searchPaint',
+    'reorder',
+    'undo',
+    'clipboard',
+    'simOracle'
+];
+/**
+ * Execute every headless closure cell for `kind`, or throw an `Error` naming each failed
+ * cell. A `conformanceFixture` parsing to no node of the kind fails the run outright.
+ */
+export async function runKindConformance(kind, profile = {}) {
+    const descriptor = getBlockKindDescriptor(kind);
+    const ctx = buildContext(kind, descriptor);
+    const cells = [];
+    const failures = [];
+    for (const column of CLOSURE_ORDER) {
+        const cell = descriptor.closure[column];
+        try {
+            const custom = profile.cells?.[column]?.check;
+            const result = custom
+                ? await runCustomCheck(kind, column, cell, custom, ctx)
+                : await executeCell(column, cell, kind, descriptor, ctx);
+            if (result.status === 'exempt') {
+                assertReasonDocumented(result.detail, `${kind} ${column} exempt reason`);
+            }
+            cells.push({ column, mode: cell.mode, ...result });
+        }
+        catch (error) {
+            failures.push(`${column}: ${error.message}`);
+        }
+    }
+    if (failures.length > 0) {
+        fail(`kind conformance failed for "${kind}":\n  - ${failures.join('\n  - ')}`);
+    }
+    return { kind, cells };
+}
+function buildContext(kind, descriptor) {
+    const fixture = descriptor.conformanceFixture;
+    if (fixture === undefined)
+        return null;
+    const doc = parse(fixture);
+    const nodePath = findFirstPathOfKind(doc, kind);
+    if (!nodePath) {
+        fail(`kind conformance failed for "${kind}": conformanceFixture parses to no "${kind}" node`);
+    }
+    // The one place every executor receives the fixture, so the position contract they drive
+    // `doc.children[0]` on (undo deletes it, the byte-slice copy sweeps from it) is settled here.
+    if (nodePath[0] !== 0) {
+        fail(`kind conformance failed for "${kind}": conformanceFixture must open with the "${kind}" ` +
+            `block (found under top-level index ${nodePath[0]}) — the kit drives the fixture's first ` +
+            `block and rides its own sentinel beside it`);
+    }
+    return { kind, descriptor, fixture, doc, node: nodeAtPath(doc, nodePath), nodePath };
+}
+async function runCustomCheck(kind, column, cell, check, ctx) {
+    // On any mode but `implemented` a custom check contradicts the declaration and would
+    // silence the declared-mode executor, so reverting a profiled cell's mode goes red.
+    if (cell.mode !== 'implemented') {
+        fail(`profile supplies a "${column}" check for "${kind}", but its declared mode is ` +
+            `"${cell.mode}" — a custom check is only valid on an 'implemented' cell`);
+    }
+    if (!ctx) {
+        fail(`profile supplies a "${column}" check but "${kind}" has no conformanceFixture to run it over`);
+    }
+    await check(ctx);
+    return { status: 'executed', detail: 'profile custom check' };
+}
+// ── Cell executors ─────────────────────────────────────────────────────────
+const BROWSER_SWEEP = 'browser cell — executed in the browser sweep';
+async function executeCell(column, cell, kind, descriptor, ctx) {
+    switch (column) {
+        case 'roundTrip':
+            return execRoundTrip(kind, descriptor, ctx);
+        case 'mergeBackspace':
+            return execMergeBackspace(kind, descriptor.mergeRole);
+        case 'searchPaint':
+            return execSearchPaint(cell, ctx);
+        case 'undo':
+            return execUndo(cell, ctx);
+        case 'clipboard':
+            return execClipboard(cell, ctx);
+        case 'focus':
+            return { status: 'boundary', detail: `native caret / focus policy — ${BROWSER_SWEEP}` };
+        case 'selectionPaint':
+            return { status: 'boundary', detail: `selection cover paint — ${BROWSER_SWEEP}` };
+        case 'reorder':
+            return execReorder(cell);
+        case 'simOracle':
+            return {
+                status: 'boundary',
+                detail: 'note-taking simulation under the corruption oracles — run by the platform sweep ' +
+                    'over the kinds it enrolls, never by this runner'
+            };
+    }
+}
+function execRoundTrip(kind, descriptor, ctx) {
+    if (!ctx) {
+        return {
+            status: 'boundary',
+            detail: `no conformanceFixture — round-trip runs in the ${BROWSER_SWEEP}`
+        };
+    }
+    assertIs(serialize(parse(ctx.fixture)), ctx.fixture, `serialize(parse(fixture)) round-trips for "${kind}"`);
+    if (descriptor.rebuildRaw) {
+        const first = rebuildRawOf(kind, ctx.fixture, descriptor);
+        const second = rebuildRawOf(kind, ctx.fixture, descriptor);
+        assertIs(first, second, `"${kind}" rebuildRaw is deterministic`);
+        assertRebuildIsParseCanonical(descriptor, nodeAtPath(parse(ctx.fixture), ctx.nodePath), `"${kind}"`);
+        return {
+            status: 'executed',
+            detail: descriptor.containerContract === 'grid'
+                ? 'byte round-trip + rebuildRaw determinism'
+                : 'byte round-trip + rebuildRaw parse-identity + determinism'
+        };
+    }
+    return { status: 'executed', detail: 'byte round-trip' };
+}
+/**
+ * An independent restatement of the merge-role → Backspace-merge table
+ * (docs/design/editor.md); re-deriving it from `isMergeEligible` would be vacuous.
+ */
+const MERGE_ROLE_EXPECTATION = {
+    prose: { currentIntoProse: true, prevForProse: true, self: true },
+    'prose-absorber': { currentIntoProse: false, prevForProse: true, self: false },
+    container: { currentIntoProse: false, prevForProse: true, self: false },
+    'self-merge': { currentIntoProse: false, prevForProse: false, self: true },
+    'not-mergeable': { currentIntoProse: false, prevForProse: false, self: false }
+};
+function execMergeBackspace(kind, role) {
+    const expected = MERGE_ROLE_EXPECTATION[role];
+    assertIs(isMergeEligible('paragraph', kind), expected.currentIntoProse, `"${kind}" (${role}) Backspace-merges as the current block into a prose predecessor`);
+    assertIs(isMergeEligible(kind, 'paragraph'), expected.prevForProse, `"${kind}" (${role}) absorbs a following prose block`);
+    assertIs(isMergeEligible(kind, kind), expected.self, `"${kind}" (${role}) self-merge eligibility`);
+    return { status: 'executed', detail: `mergeRole=${role} eligibility` };
+}
+function execSearchPaint(cell, ctx) {
+    if (cell.mode !== 'not-supported') {
+        return { status: 'boundary', detail: `search-match mark overlay — ${BROWSER_SWEEP}` };
+    }
+    if (!ctx)
+        return { status: 'exempt', detail: cell.reason };
+    const needle = firstVisibleChar(ctx.node.raw);
+    if (needle === null)
+        return { status: 'exempt', detail: cell.reason };
+    const compiled = compileMatcher(needle, { caseSensitive: true, wholeWord: false, regex: false });
+    if (!compiled.ok)
+        return { status: 'exempt', detail: cell.reason };
+    // Non-vacuity: the needle IS present in the raw, so no match can only mean the scan
+    // deliberately skips this non-searchable kind.
+    assert(compiled.matcher.findAll(ctx.node.raw).length > 0, `needle "${needle}" is present in the "${ctx.kind}" raw`);
+    const hits = scanDocument(ctx.doc, compiled.matcher).filter((m) => pathsEqual(m.path, ctx.nodePath));
+    assertIs(hits.length, 0, `the document scan finds no match in the non-searchable "${ctx.kind}"`);
+    return { status: 'executed', detail: 'document scan finds no match (degradation)' };
+}
+function execReorder(cell) {
+    if (cell.mode === 'not-supported')
+        return { status: 'exempt', detail: cell.reason };
+    return {
+        status: 'boundary',
+        detail: `block reorder is an Alt+Arrow / drag gesture — ${BROWSER_SWEEP}`
+    };
+}
+async function execUndo(cell, ctx) {
+    if (cell.mode === 'not-supported')
+        return { status: 'exempt', detail: cell.reason };
+    if (cell.mode === 'implemented') {
+        return {
+            status: 'boundary',
+            detail: `kind-specific undo mechanism — supply a profile check or run it in the ${BROWSER_SWEEP}`
+        };
+    }
+    if (!ctx)
+        return {
+            status: 'boundary',
+            detail: `no conformanceFixture — undo depth runs in the ${BROWSER_SWEEP}`
+        };
+    const doc = parse(ctx.fixture + '\n\nundo sentinel\n');
+    assert(doc.children.length > 1, `the kit's trailing sentinel parses beside the "${ctx.kind}" fixture rather than being ` +
+        `swallowed by it, so there is a second block to delete`);
+    const { deps } = createHeadlessActions(doc.children);
+    const controller = createUndoController(deps);
+    const blockEdit = createBlockEditActions(deps, controller);
+    const before = deps.undoManager.getStacks().undo.length;
+    await blockEdit.deleteBlock(0);
+    const after = deps.undoManager.getStacks().undo.length;
+    assertIs(after - before, 1, `one structural op pushes exactly one undo entry over the "${ctx.kind}" fixture`);
+    return { status: 'executed', detail: 'one structural op → one undo entry' };
+}
+function execClipboard(cell, ctx) {
+    if (cell.mode === 'not-supported')
+        return { status: 'exempt', detail: cell.reason };
+    if (cell.mode === 'implemented') {
+        return {
+            status: 'boundary',
+            detail: `kind-specific clipboard mechanism — supply a profile check or run it in the ${BROWSER_SWEEP}`
+        };
+    }
+    if (!ctx)
+        return {
+            status: 'boundary',
+            detail: `no conformanceFixture — copy runs in the ${BROWSER_SWEEP}`
+        };
+    if (ctx.nodePath.length !== 1) {
+        return {
+            status: 'boundary',
+            detail: 'nested kind — copied as part of its container; the enclosing container cell covers its bytes'
+        };
+    }
+    checkCopyIsRawByteSlice(ctx.kind, ctx.fixture);
+    return { status: 'executed', detail: 'copy is a raw byte slice (no synthesis)' };
+}
+// ── Exported executors (direct-drive for regression tests) ───────────────────
+const TRAILING_SENTINEL = '\n\nclipboard sentinel\n';
+const LEADING_SENTINEL = 'clipboard lead\n\n';
+/**
+ * Assert the default cross-block copy over `kind`'s fixture carries its bytes with no
+ * kind-specific synthesis, at BOTH endpoint roles — the honest meaning of
+ * `clipboard: inherit-default`. Endpoints ride the real selection funnel, so the expectation is
+ * the contract, never a re-derivation of the slice under test. Fixture contract: `fixture`
+ * parses to `kind` at `children[0]`; the kit adds its sentinel block on the sweeping side.
+ */
+export function checkCopyIsRawByteSlice(kind, fixture) {
+    assertIs(parse(fixture).children[0]?.kind, kind, `"${kind}" is the top-level copy subject: a conformanceFixture must parse to its kind ` +
+        `at children[0], and the kit adds its own sentinel block on the sweeping side`);
+    checkCopyFromKind(kind, fixture);
+    checkCopyIntoKind(kind, fixture);
+}
+/** The kind as the range START: its tail, then the sentinel's head. */
+function checkCopyFromKind(kind, fixture) {
+    const doc = parse(fixture + TRAILING_SENTINEL);
+    const lastIndex = doc.children.length - 1;
+    assert(lastIndex >= 1, 'fixture + sentinel yields a second block to copy across');
+    const kindNode = doc.children[0];
+    const sentinel = doc.children[lastIndex];
+    const startOffset = interiorOffset(kindNode);
+    const endOffset = displayLength(sentinel.raw);
+    const copied = copyThroughFunnel(doc, { path: [0], offset: startOffset }, { path: [lastIndex], offset: endOffset });
+    const tail = isWholeBlockUnit(kindNode) ? kindNode.raw : kindNode.raw.slice(startOffset);
+    assertIs(copied, tail +
+        bytesBetween(doc.children, 1, lastIndex) +
+        sentinel.leadingTrivia +
+        sentinel.raw.slice(0, endOffset), `"${kind}" copy is a raw byte slice — no kind-specific synthesis`);
+}
+/** The kind as the range END, the role a start-only check never exercises. */
+function checkCopyIntoKind(kind, fixture) {
+    const doc = parse(LEADING_SENTINEL + fixture);
+    const kindIndex = doc.children.length - 1;
+    assert(kindIndex >= 1, 'sentinel + fixture yields a block to copy across from');
+    const sentinel = doc.children[0];
+    const kindNode = doc.children[kindIndex];
+    const startOffset = interiorOffset(sentinel);
+    const copied = copyThroughFunnel(doc, { path: [0], offset: startOffset }, { path: [kindIndex], offset: interiorOffset(kindNode) });
+    const head = isWholeBlockUnit(kindNode)
+        ? trimTrailingLineEnding(kindNode.raw)
+        : kindNode.raw.slice(0, interiorOffset(kindNode));
+    assertIs(copied, sentinel.raw.slice(startOffset) +
+        bytesBetween(doc.children, 1, kindIndex) +
+        kindNode.leadingTrivia +
+        head, `"${kind}" copy is a raw byte slice — no kind-specific synthesis`);
+}
+/** The blocks a sweep crosses whole: a blank run beside the sentinel materializes as these. */
+function bytesBetween(children, from, to) {
+    return children
+        .slice(from, to)
+        .map((node) => node.leadingTrivia + node.raw)
+        .join('');
+}
+/**
+ * The production mint→store→slice chain: endpoints normalize in `SelectionState` exactly as a
+ * gesture's would, so a kind whose offsets the funnel rewrites is copied as the editor copies it.
+ */
+function copyThroughFunnel(doc, anchor, focus) {
+    const selection = createSelectionState({ getDoc: () => doc });
+    selection.enterCrossBlock(anchor, focus);
+    const { start, end } = selection;
+    if (!start || !end)
+        fail('the selection funnel refused the cross-block endpoint pair');
+    return collectCrossBlockText(doc, start, end);
+}
+/** An offset strictly inside the block, so a kind that snaps its endpoints is seen doing it. */
+function interiorOffset(node) {
+    return displayLength(node.raw) > 1 ? 1 : 0;
+}
+// ── Internal helpers ─────────────────────────────────────────────────────────
+function rebuildRawOf(kind, fixture, descriptor) {
+    const doc = parse(fixture);
+    const node = nodeAtPath(doc, findFirstPathOfKind(doc, kind));
+    descriptor.rebuildRaw(node);
+    return node.raw;
+}
+function firstVisibleChar(raw) {
+    for (const ch of raw) {
+        if (!/\s/.test(ch))
+            return ch;
+    }
+    return null;
+}

package/dist/testing/mount-dom-stubs.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Install the jsdom gaps a mounted editor hits — the block-height `ResizeObserver` and the
+ * reveal's `scrollIntoView` — once, before the first mount. Each lands only where absent, so a
+ * runner supplying a real one keeps it and the call is inert in a browser. Windowing activates
+ * on ESTIMATED height in either scroll mode, so keep fixture documents small if a test asserts
+ * on a block being mounted; jsdom reports a zero viewport and mounts only the first few.
+ */
+export declare function installEditorDomStubsForTests(): void;

package/dist/testing/mount-dom-stubs.js

@@ -0,0 +1,19 @@
+class NoopResizeObserver {
+    observe() { }
+    unobserve() { }
+    disconnect() { }
+}
+/**
+ * Install the jsdom gaps a mounted editor hits — the block-height `ResizeObserver` and the
+ * reveal's `scrollIntoView` — once, before the first mount. Each lands only where absent, so a
+ * runner supplying a real one keeps it and the call is inert in a browser. Windowing activates
+ * on ESTIMATED height in either scroll mode, so keep fixture documents small if a test asserts
+ * on a block being mounted; jsdom reports a zero viewport and mounts only the first few.
+ */
+export function installEditorDomStubsForTests() {
+    const globals = globalThis;
+    globals.ResizeObserver ??= NoopResizeObserver;
+    if (typeof Element !== 'undefined' && !Element.prototype.scrollIntoView) {
+        Element.prototype.scrollIntoView = () => { };
+    }
+}

package/dist/testing/parse-convergence.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The parse-convergence oracle. A byte round-trip after a mutation is a tautology (G2.1 makes
+ * `serialize∘parse` identity), so this compares the LIVE tree against `parse(serialize(live))`
+ * STRUCTURALLY instead: kinds, children shape, and parse-derived metadata. The comparison is
+ * exact: the parser materializes blank lines as blocks, so an empty paragraph reparses as itself.
+ * The reparse uses the ambient grammar, so an unregistered kind reads as a false divergence.
+ */
+import type { Document } from '../core/nodes';
+/** True when the live tree converges structurally with a fresh parse of its serialization. */
+export declare function parseConverges(doc: Document): boolean;
+/** The FIRST structural divergence from `parse(serialize(doc))`, or null when converged. */
+export declare function describeConvergence(doc: Document): string | null;
+/** Assert convergence, throwing a plain `Error` (runner-agnostic) on divergence. */
+export declare function assertParseConverged(doc: Document, label?: string): void;

package/dist/testing/parse-convergence.js

@@ -0,0 +1,81 @@
+/**
+ * The parse-convergence oracle. A byte round-trip after a mutation is a tautology (G2.1 makes
+ * `serialize∘parse` identity), so this compares the LIVE tree against `parse(serialize(live))`
+ * STRUCTURALLY instead: kinds, children shape, and parse-derived metadata. The comparison is
+ * exact: the parser materializes blank lines as blocks, so an empty paragraph reparses as itself.
+ * The reparse uses the ambient grammar, so an unregistered kind reads as a false divergence.
+ */
+import { parse } from '../core/parser';
+import { serialize } from '../core/serializer';
+import { show } from './conformance-core';
+// Typed against BlockMetadataByKind so a renamed or removed field is a compile error;
+// an ADDED field still needs enrolling by hand. Editor-level fields (childIds,
+// ownerEpoch) are not parse-derived, so the reparse never mints them.
+const METADATA_FIELDS = {
+    heading: ['level'],
+    setextHeading: ['level'],
+    fencedCode: ['fenceMarker', 'fenceLength', 'info', 'closed'],
+    thematicBreak: ['marker'],
+    linkReferenceDefinition: ['label', 'url', 'title'],
+    table: ['columnCount', 'alignments'],
+    tableRow: ['isHeader'],
+    blockquote: ['quoteDepth'],
+    list: ['ordered'],
+    listItem: ['marker', 'taskItem', 'taskChecked', 'taskMarker']
+};
+/** True when the live tree converges structurally with a fresh parse of its serialization. */
+export function parseConverges(doc) {
+    return describeConvergence(doc) === null;
+}
+/** The FIRST structural divergence from `parse(serialize(doc))`, or null when converged. */
+export function describeConvergence(doc) {
+    return diffChildren(doc, parse(serialize(doc)), []);
+}
+/** Assert convergence, throwing a plain `Error` (runner-agnostic) on divergence. */
+export function assertParseConverged(doc, label = 'parse convergence') {
+    const divergence = describeConvergence(doc);
+    if (divergence)
+        throw new Error(`${label}: ${divergence}`);
+}
+function diffChildren(live, reparsed, path) {
+    const liveKids = live.children ?? [];
+    const reKids = reparsed.children ?? [];
+    if (liveKids.length !== reKids.length) {
+        return `[${path.join(',')}] live has ${liveKids.length} children, reparsed has ${reKids.length}`;
+    }
+    for (let i = 0; i < liveKids.length; i++) {
+        const divergence = diffNode(liveKids[i], reKids[i], [...path, i]);
+        if (divergence)
+            return divergence;
+    }
+    return null;
+}
+function diffNode(live, reparsed, path) {
+    const at = `[${path.join(',')}]`;
+    if (live.kind !== reparsed.kind) {
+        return `${at} live kind "${live.kind}" != reparsed "${reparsed.kind}"`;
+    }
+    const metaDivergence = diffMetadata(live, reparsed, at);
+    if (metaDivergence)
+        return metaDivergence;
+    return diffChildren(live, reparsed, path);
+}
+function diffMetadata(live, reparsed, at) {
+    const fields = METADATA_FIELDS[live.kind];
+    if (!fields)
+        return null;
+    const liveMeta = (live.metadata ?? {});
+    const reMeta = (reparsed.metadata ?? {});
+    for (const field of fields) {
+        if (!valuesEqual(liveMeta[field], reMeta[field])) {
+            return `${at} ${live.kind}.${field}: live ${show(liveMeta[field])} != reparsed ${show(reMeta[field])}`;
+        }
+    }
+    return null;
+}
+function valuesEqual(a, b) {
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every((v, i) => v === b[i]);
+    }
+    return a === b;
+}

package/dist/testing.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Reset the plugin platform's process-global registration state so a plugin's test suite
+ * can re-install between cases: call it in `beforeEach`, then re-run your setup. Built-in
+ * schema registrations and all runtime state (undo stack, selection, DOM/CST) survive —
+ * except that the paste-surface reset clears ALL surfaces, so a case exercising built-in
+ * paste afterward must re-register. Throws outside a detected test environment.
+ */
+export declare function resetPluginPlatformForTests(): void;
+export { configureEditorEnv, resetEditorEnv } from './env';
+export { installEditorDomStubsForTests } from './testing/mount-dom-stubs';
+export { applyPasteTransforms } from './tree-operations/paste/paste-transforms';
+export { setDevWarnSink } from './dev-warn';
+export type { DevWarnEntry, DevWarnSink } from './dev-warn';
+export { runContainerConformance, reversedAncestryLeavesRootStale } from './testing/container-conformance';
+export type { ConformanceCoverage } from './testing/conformance-core';
+export type { ConformanceCell, ConformanceCellReport, ContainerConformanceProfile, ContainerConformanceReport, LocalIndexFixture } from './testing/container-conformance';
+export { runKindConformance, checkCopyIsRawByteSlice } from './testing/kind-conformance';
+export type { KindCellCheck, KindCellContext, KindCellReport, KindCellStatus, KindConformanceProfile, KindConformanceReport } from './testing/kind-conformance';
+export { runInlineKindConformance } from './testing/inline-conformance';
+export type { InlineCellReport, InlineConformanceCell, InlineConformanceProfile, InlineConformanceReport } from './testing/inline-conformance';

package/dist/testing.js

@@ -0,0 +1,61 @@
+// The plugin-testing surface, published at the `@voithos-labs/aragonite/testing` subpath. TEST
+// PROCESSES ONLY, and nothing here may import a test runner — the kits run inside an
+// author's own case, so failures surface as plain `Error`s. The registries are
+// register-once with no unregister (docs/contributing/casebook.md), so every registration
+// reachable from `@voithos-labs/aragonite/plugin` must wire its reset into the aggregate below.
+import { editorEnv } from './env';
+import { __resetSchemaRegistriesForTests } from './schema/registry-reset';
+import { __resetPasteSurfacesForTests } from './tree-operations/paste-surfaces';
+import { __resetPasteTransformsForTests } from './tree-operations/paste/paste-transforms';
+import { __resetInlineSyntaxForTests } from './core/inline/scan/plugin-syntax';
+import { __resetInlineWidgetsForTests } from './core/inline/inline-widgets';
+import { __clearDeclaredPluginInlineKindsForTests } from './schema/plugin-kind';
+import { __resetDirectiveRegistryForTests } from './core/directive/registry';
+/**
+ * Reset the plugin platform's process-global registration state so a plugin's test suite
+ * can re-install between cases: call it in `beforeEach`, then re-run your setup. Built-in
+ * schema registrations and all runtime state (undo stack, selection, DOM/CST) survive —
+ * except that the paste-surface reset clears ALL surfaces, so a case exercising built-in
+ * paste afterward must re-register. Throws outside a detected test environment.
+ */
+export function resetPluginPlatformForTests() {
+    if (!editorEnv.isTest) {
+        throw new Error('resetPluginPlatformForTests() is test-only — it wipes the process-global plugin ' +
+            'registries, which is corruption in a running editor. No test environment was ' +
+            'detected (process.env.VITEST is unset). Detection is Vitest-specific; another ' +
+            'runner opts in with configureEditorEnv({ isTest: true }), exported beside this.');
+    }
+    __resetSchemaRegistriesForTests();
+    __resetPasteSurfacesForTests();
+    __resetPasteTransformsForTests();
+    __resetInlineSyntaxForTests();
+    __resetInlineWidgetsForTests();
+    __clearDeclaredPluginInlineKindsForTests();
+    __resetDirectiveRegistryForTests();
+}
+// ── Editor env override ──────────────────────────────────────────────────────
+// The door the reset's own error names: a runner other than Vitest declares itself a
+// test environment here, and `resetEditorEnv` puts the detected defaults back.
+export { configureEditorEnv, resetEditorEnv } from './env';
+// ── Mounting the editor under a non-browser DOM ──────────────────────────────
+export { installEditorDomStubsForTests } from './testing/mount-dom-stubs';
+// ── Paste pipeline ───────────────────────────────────────────────────────────
+// The production pipeline itself, not a test-only seam: the very function every
+// clipboard→parse route runs (G4.11), so driving it observes the registered
+// transforms rather than a re-implementation of them.
+export { applyPasteTransforms } from './tree-operations/paste/paste-transforms';
+// ── Dev-warning sink ─────────────────────────────────────────────────────────
+// The channel every editor dev warning reaches, so a suite can build its own
+// fail-on-warn gate: register a sink, drain it per case, red on what nobody claimed.
+// Runner-agnostic by contract, and a registered sink silences the console line.
+export { setDevWarnSink } from './dev-warn';
+// ── Container conformance kit (G4.3) ─────────────────────────────────────────
+export { runContainerConformance, reversedAncestryLeavesRootStale } from './testing/container-conformance';
+// ── Generic per-kind conformance battery ─────────────────────────────────────
+// Registering a kind enrolls its headless closure cells; the browser sweep runs
+// the browser-only cells.
+export { runKindConformance, checkCopyIsRawByteSlice } from './testing/kind-conformance';
+// ── Inline-rung conformance kit ──────────────────────────────────────────────
+// The behavioral battery a registered inline rung is held to: what it claims, what
+// it declines, and whether its widget is one atomic unit.
+export { runInlineKindConformance } from './testing/inline-conformance';

package/dist/tree-operations/blockquote.d.ts

@@ -0,0 +1,18 @@
+import type { CstNode } from '../core/nodes';
+import type { NodeView } from '../core/node-views';
+/**
+ * Unwrap a quote-shaped container's first child (Rule U2), returning fresh clones without
+ * mutating the input. It lifts whatever container it is handed; the `lift-first-child-drop-opener`
+ * strategy is what restricts the callers. The remainder is always a plain blockquote: a marker like
+ * `[!TYPE]` lives only on the opener line, so lifting a body child out drops it and the rest
+ * reparses as an ordinary quote.
+ */
+export declare function unwrapFirstChildFromQuote(container: NodeView): CstNode[];
+/**
+ * The parent-level replacement when Enter exits a quote-shaped container's empty trailing
+ * paragraph: `[trimmedContainer, exitParagraph]`, the caller's focus target at index 1.
+ * Kind-agnostic through the descriptor's `rebuildRaw`; input unmutated. The exit paragraph
+ * carries a separator like the list exit's, or a line typed there lazy-continues the
+ * container on reload.
+ */
+export declare function buildQuoteExitReplacement(container: NodeView): CstNode[];

package/dist/tree-operations/blockquote.js

@@ -0,0 +1,59 @@
+import { cloneMetadata, cloneNode } from './clone';
+import { rebuildBlockquoteRaw } from '../schema/container-rebuilders';
+import { rebuildContainerRaw } from '../schema/container-raw';
+import { assignIds } from '../block-id';
+import { emptyParagraph } from './node-ops';
+import { trailingLineEnding } from '../core/lines';
+/**
+ * Unwrap a quote-shaped container's first child (Rule U2), returning fresh clones without
+ * mutating the input. It lifts whatever container it is handed; the `lift-first-child-drop-opener`
+ * strategy is what restricts the callers. The remainder is always a plain blockquote: a marker like
+ * `[!TYPE]` lives only on the opener line, so lifting a body child out drops it and the rest
+ * reparses as an ordinary quote.
+ */
+export function unwrapFirstChildFromQuote(container) {
+    if (!container.children || container.children.length === 0) {
+        return [];
+    }
+    const clonedChildren = container.children.map(cloneNode);
+    const lifted = clonedChildren[0];
+    // The container's leading trivia is applied at the caller's splice point.
+    lifted.leadingTrivia = '';
+    if (clonedChildren.length === 1) {
+        return [lifted];
+    }
+    const remainingChildren = clonedChildren.slice(1);
+    remainingChildren[0].leadingTrivia = '';
+    const remaining = {
+        kind: 'blockquote',
+        leadingTrivia: '',
+        raw: '',
+        metadata: container.metadata && 'quoteDepth' in container.metadata
+            ? cloneMetadata(container.metadata)
+            : { quoteDepth: 1 },
+        children: remainingChildren,
+        childIds: assignIds(remainingChildren),
+        innerPrefix: container.innerPrefix ?? '',
+        innerSuffix: container.innerSuffix ?? ''
+    };
+    rebuildBlockquoteRaw(remaining);
+    return [lifted, remaining];
+}
+/**
+ * The parent-level replacement when Enter exits a quote-shaped container's empty trailing
+ * paragraph: `[trimmedContainer, exitParagraph]`, the caller's focus target at index 1.
+ * Kind-agnostic through the descriptor's `rebuildRaw`; input unmutated. The exit paragraph
+ * carries a separator like the list exit's, or a line typed there lazy-continues the
+ * container on reload.
+ */
+export function buildQuoteExitReplacement(container) {
+    if (!container.children || container.children.length <= 1)
+        return [];
+    const trimmed = cloneNode(container);
+    trimmed.children = trimmed.children.slice(0, -1);
+    trimmed.childIds = assignIds(trimmed.children);
+    rebuildContainerRaw(trimmed);
+    // Every byte this op mints is a line ending, so it takes the container's (G4.20).
+    const lineEnding = trailingLineEnding(container.raw);
+    return [trimmed, emptyParagraph(lineEnding, lineEnding)];
+}

package/dist/tree-operations/children.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Container children mutations that keep `childIds` in lockstep, for out-of-commit-scope
+ * writes (discovered descendants/ancestors — see the `node-ops.ts` header). Inside a
+ * commit scope the StructuralChange descriptor owns id/ref sync; here a hand-rolled
+ * splice would let the parallel id array drift and break Svelte's keyed-each rendering.
+ * The same shape change invalidates `childSpans`, so both parallel arrays settle here.
+ */
+import type { CstNode } from '../core/nodes';
+export declare function pushChild(container: CstNode, child: CstNode): void;
+/**
+ * Bring `childIds` back to `children`'s length after an in-place children swap. The
+ * surviving prefix keeps its ids — a blanket re-mint would remount every child under
+ * Svelte's keyed each, the identity the swapping branches exist to preserve. No-op when
+ * the array is absent; the mounting BlockList backfills it.
+ */
+export declare function resyncChildIds(container: CstNode): void;
+export declare function spliceChildren(container: CstNode, at: number, removeCount: number, items: readonly CstNode[]): void;