@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/testing/inline-conformance.js

@@ -1,9 +1,8 @@
 /**
- * The inline-rung conformance kit, published at `@voithos-labs/aragonite/testing` — sibling of the block
- * layer's `runKindConformance` and the container kit. Reads the LIVE registry, so it
- * composes with `resetPluginPlatformForTests()` cycles. The four profile-declared cells are
- * required, not optional, since every one is invisible to byte round-trip; an exemption the
- * kit can falsify, it falsifies. Failures throw a plain `Error`.
+ * The conformance kit for an inline syntax handler (`InlineRung`), published at
+ * `@voithos-labs/aragonite/testing`. It reads the live registry, so it works across
+ * `resetPluginPlatformForTests()` cycles. The four cells a profile declares are required because
+ * byte round-trip sees none of them, and the kit disproves an exemption where it can.
  */
 import { isBuiltinInlineKind } from '../core/nodes';
 import { parse } from '../core/parser';
@@ -13,55 +12,59 @@ import { renderInlineNodes } from '../core/inline-render';
 import { buildCoreInlineWidget, getInlineWidgetComponent, getInlineWidgetEditing, isInlineWidget, DELETE_GRANULARITIES, ON_EDGE_POLICIES } from '../core/inline/inline-widgets';
 import { INLINE_PRIORITIES, getInlineRungs, isReservedInlineTrigger, isScanProbeTrigger } from '../core/inline/scan/plugin-syntax';
 import { containerDomTextLength } from '../cursor/widget-offset';
-import { assert, assertExemptionDocumented, assertIs, fail } from './conformance-core';
+import { assert, assertIs, fail, runCells } from './conformance-core';
+import { defaultGrammarView } from '../schema/block-openers';
+const INLINE_CELLS = [
+    { cell: 'claims', run: ({ profile, rung }) => checkClaimsItsFixtures(profile, rung) },
+    { cell: 'roundTrip', run: ({ profile, rung }) => checkRoundTrip(profile, rung) },
+    {
+        cell: 'overlapDecline',
+        coverage: ({ profile }) => profile.overlapDecline,
+        run: ({ profile, rung }) => checkOverlapDecline(profile, rung),
+        falsify: ({ profile }) => refuseExcusedOverlap(profile)
+    },
+    {
+        cell: 'widget',
+        coverage: ({ profile }) => profile.widget,
+        run: ({ profile, rung }) => checkWidgetAtomicity(profile, rung),
+        falsify: ({ profile, rung }) => refuseExcusedWidget(profile, rung)
+    },
+    {
+        cell: 'editingPolicy',
+        coverage: ({ profile }) => profile.editingPolicy,
+        run: ({ profile, rung }) => checkEditingPolicy(profile, rung),
+        falsify: ({ profile }) => refuseExcusedEditingPolicy(profile)
+    },
+    {
+        cell: 'imageClaim',
+        coverage: ({ profile }) => profile.imageClaim,
+        run: ({ profile, rung }) => checkImageClaimStamp(profile, rung),
+        falsify: ({ profile, rung }) => refuseExcusedImageClaim(profile, rung)
+    },
+    {
+        cell: 'registration',
+        run: ({ profile, prefix, rung }) => checkRegistrationHygiene(profile, prefix, rung)
+    }
+];
 /**
- * Run every conformance cell for the registered rung the profile names. Returns the
+ * Runs every conformance cell for the registered handler the profile names. Resolves with the
  * coverage report, or throws an `Error` naming every failed cell.
  */
-export function runInlineKindConformance(profile) {
+export async function runInlineKindConformance(profile) {
     const prefix = profile.prefix ?? profile.trigger;
     validateProfile(profile, prefix);
     const rung = locateRung(profile, prefix);
-    const cells = [];
-    const failures = [];
-    const runCell = (cell, coverage, assertion) => {
-        try {
-            if (coverage.mode === 'assert') {
-                const outcome = assertion();
-                cells.push(typeof outcome === 'string'
-                    ? { cell, status: 'asserted', detail: outcome }
-                    : { cell, ...outcome });
-            }
-            else {
-                assertExemptionDocumented(coverage, `${prefix} ${cell}`);
-                falsifyExcuse(cell, profile, rung);
-                cells.push({ cell, status: coverage.mode, detail: coverage.reason });
-            }
-        }
-        catch (error) {
-            failures.push(`${cell}: ${error.message}`);
-        }
-    };
-    runCell('claims', { mode: 'assert' }, () => checkClaimsItsFixtures(profile, rung));
-    runCell('roundTrip', { mode: 'assert' }, () => checkRoundTrip(profile, rung));
-    runCell('overlapDecline', profile.overlapDecline, () => checkOverlapDecline(profile, rung));
-    runCell('widget', profile.widget, () => checkWidgetAtomicity(profile, rung));
-    runCell('editingPolicy', profile.editingPolicy, () => checkEditingPolicy(profile, rung));
-    runCell('imageClaim', profile.imageClaim, () => checkImageClaimStamp(profile, rung));
-    runCell('registration', { mode: 'assert' }, () => checkRegistrationHygiene(profile, prefix, rung));
-    if (failures.length > 0) {
-        fail(`inline conformance failed for rung "${prefix}":\n  - ${failures.join('\n  - ')}`);
-    }
+    const cells = await runCells(INLINE_CELLS, { profile, prefix, rung }, { subject: prefix, heading: `inline conformance failed for rung "${prefix}"` });
     return { trigger: profile.trigger, prefix, cells };
 }
-// ── Profile validation + rung lookup ─────────────────────────────────────────
+// ── Profile validation + handler lookup ──────────────────────────────────────
 function validateProfile(profile, prefix) {
     assertIs(profile.trigger.length, 1, 'trigger is a single character');
     assert(prefix.startsWith(profile.trigger), `prefix ${JSON.stringify(prefix)} begins with the trigger ${JSON.stringify(profile.trigger)}`);
     assert(profile.fixtures.length > 0, 'the profile supplies at least one fixture the rung claims');
     for (const fixture of profile.fixtures)
         assertSingleLine(fixture, 'fixture');
-    // A prefix rung is consulted BEFORE the built-in case it shadows, so the overlap
+    // A prefix handler is consulted before the built-in case it shadows, so the overlap
     // always exists and there is nothing to excuse.
     if (isReservedInlineTrigger(profile.trigger) && profile.overlapDecline.mode !== 'assert') {
         fail(`${JSON.stringify(profile.trigger)} is claimed by the built-in scanner, so this rung is ` +
@@ -92,11 +95,8 @@ function locateRung(profile, prefix) {
     return matches[0];
 }
 // ── Claim resolution ─────────────────────────────────────────────────────────
-/**
- * Every node this rung minted from `source`, in document order. Ownership reads two
- * ways because a rung's own kind carries no stamp by design: the declared kind, or the
- * claim the scan stamps on a BUILT-IN kind minted over the rung's bytes.
- */
+/** Every node this handler produced from `source`, in document order: its declared kind (which
+ *  carries no mark), or a built-in node the scan marked with the handler's `syntaxClaim`. */
 function mintedNodes(source, profile, rung) {
     const out = [];
     const visit = (nodes) => {
@@ -112,7 +112,7 @@ function mintedNodes(source, profile, rung) {
 }
 /**
  * Every claim in a fixture, or a failure naming it. A fixture may carry more than one
- * (`see [^a] and [^b]`), and every cell below walks all of them.
+ * (`see [^a] and [^b]`), and every cell below goes through all of them.
  */
 function claimsIn(fixture, profile, rung) {
     const minted = mintedNodes(fixture, profile, rung);
@@ -120,6 +120,16 @@ function claimsIn(fixture, profile, rung) {
         `the kit would enroll the rung without exercising it`);
     return minted;
 }
+/** The claims of `kind` across every fixture, failing when there is none, so a cell about the kind
+ *  never reports `asserted` over only the built-in nodes the handler claimed. */
+function claimsOfKind(profile, rung, kind) {
+    const claims = profile.fixtures.flatMap((fixture) => claimsIn(fixture, profile, rung)
+        .filter((node) => node.kind === kind)
+        .map((node) => ({ fixture, node })));
+    assert(claims.length > 0, `no fixture mints a "${kind}" node — the "${rung.prefix}" rung's claims are all built-ins ` +
+        `it stamps, which the imageClaim cell covers`);
+    return claims;
+}
 // ── claims ───────────────────────────────────────────────────────────────────
 function checkClaimsItsFixtures(profile, rung) {
     let claims = 0;
@@ -135,8 +145,8 @@ function checkClaimsItsFixtures(profile, rung) {
 }
 // ── roundTrip ────────────────────────────────────────────────────────────────
 /**
- * Adjacencies a rung's `end` arithmetic gets wrong: a construct starting where the
- * claim ended, the rung's own trigger on its edges, a wrapper contesting the bytes.
+ * The neighbours a handler's `end` arithmetic tends to get wrong: a construct starting where the
+ * claim ended, the handler's own trigger on either edge, a wrapper competing for the bytes.
  */
 function interleavings(fixture, trigger) {
     return [
@@ -152,11 +162,8 @@ function interleavings(fixture, trigger) {
         `${fixture}${trigger}`
     ];
 }
-/**
- * How far into `fixture` its own opener ends. Cutting a scan range there puts the last
- * consultation on a prefix whose closer is out of range — the shape a heading's
- * excluded `#` run makes of any construct straddling it.
- */
+/** How far into `fixture` its own opener ends; a scan range cut there strands a prefix whose
+ *  closer is out of range, as a heading's excluded `#` run does. */
 function openerWidth(fixture, prefix) {
     const at = fixture.indexOf(prefix);
     return at < 0 ? prefix.length : at + prefix.length;
@@ -168,10 +175,8 @@ function checkRoundTrip(profile, rung) {
             const withEnding = `${source}\n`;
             assertIs(serialize(parse(withEnding)), withEnding, `serialize(parse(source)) round-trips ${JSON.stringify(withEnding)}`);
             assertScanTiles(source, source.length);
-            // Scan ranges that stop short of the raw (a heading's excluded `#` run, a table
-            // cell's `|`): the tail is real grammar, so a terminator search written without
-            // an `end` bound reaches into it. Two cut points because where the boundary falls
-            // relative to a construct is the variable.
+            // A scan range short of the raw (a heading's excluded `#` run) catches a terminator
+            // search with no `end` bound; two cut points vary where the boundary falls.
             assertScanTiles(source + fixture, source.length);
             assertScanTiles(source + fixture, source.length + openerWidth(fixture, rung.prefix));
             count++;
@@ -179,12 +184,8 @@ function checkRoundTrip(profile, rung) {
     }
     return `${count} source(s) round-trip byte-for-byte and tile their scan range`;
 }
-/**
- * The inline layer's own byte round-trip: `serialize(parse(s))` is raw-driven and cannot
- * see a rung at all, so the property a rung can break is the scanner's contract — nodes
- * tile `[0, end)` with no gap or overlap and their slices reassemble the scanned bytes.
- * An overrun past `end` never reaches here; the dispatch throws on it (scan/index.ts).
- */
+/** Round-trip never sees a handler, so check the scanner's contract: the nodes tile `[0, end)`
+ *  with no gap or overlap and their slices reassemble the bytes. */
 function assertScanTiles(raw, end) {
     const nodes = parseInline(raw, 0, end);
     let cursor = 0;
@@ -196,11 +197,8 @@ function assertScanTiles(raw, end) {
     assertIs(nodes.map((n) => raw.slice(n.start, n.end)).join(''), raw.slice(0, end), `the scanned spans of ${JSON.stringify(raw.slice(0, end))} reassemble its bytes`);
 }
 // ── overlapDecline ───────────────────────────────────────────────────────────
-/**
- * At every position the scan would consult this rung the recognizer must return null.
- * A decline leaves the scan context untouched, so declining everywhere IS the guarantee
- * that the built-in reads byte-identical bytes.
- */
+/** At every position the scan would consult this handler the recognizer returns null, so the
+ *  built-in construct sees byte-identical input. */
 function checkOverlapDecline(profile, rung) {
     const fixtures = profile.overlapFixtures ?? [];
     let consulted = 0;
@@ -210,7 +208,7 @@ function checkOverlapDecline(profile, rung) {
             if (!source.startsWith(rung.prefix, pos))
                 continue;
             positions++;
-            const claimed = rung.recognizer(source, pos, source.length);
+            const claimed = rung.recognizer(source, pos, source.length, defaultGrammarView);
             if (claimed !== null) {
                 fail(`the "${rung.prefix}" rung swallowed the overlap in ${JSON.stringify(source)} at ` +
                     `offset ${pos} — it claimed [${claimed.start}, ${claimed.end}) as "${claimed.kind}", ` +
@@ -235,36 +233,30 @@ function checkWidgetAtomicity(profile, rung) {
     const kind = profile.kind;
     assert(kind !== undefined, 'the widget cell asserts but the profile names no kind — a rung minting only built-in ' +
         'kinds renders through the built-in widget and declares this cell exempt');
-    for (const fixture of profile.fixtures) {
-        for (const node of claimsIn(fixture, profile, rung)) {
-            assert(isInlineWidget(node, fixture), `the "${kind}" node from ${JSON.stringify(fixture)} is a registered live widget`);
-            assertSelfDelimiting(fixture, node, kind);
-        }
+    const claims = claimsOfKind(profile, rung, kind);
+    for (const { fixture, node } of claims) {
+        assert(isInlineWidget(node, fixture, defaultGrammarView), `the "${kind}" node from ${JSON.stringify(fixture)} is a registered live widget`);
+        assertSelfDelimiting(fixture, node, kind);
     }
-    // Both early exits report BOUNDARY, not asserted: the island contract did not run.
-    if (getInlineWidgetComponent(kind) !== undefined) {
+    // Both early exits report boundary, not asserted: the inline-widget contract did not run.
+    if (getInlineWidgetComponent(kind, defaultGrammarView) !== undefined) {
         return {
             status: 'boundary',
-            detail: `${RECOGNITION_HALF} executed; the island wrapper of a \`component\` kind is minted by ` +
+            detail: `${RECOGNITION_HALF} executed; the widget wrapper of a \`component\` kind is created by ` +
                 `the render layer, not by the plugin, so it is not the plugin’s to get wrong`
         };
     }
     if (typeof document === 'undefined') {
-        return { status: 'boundary', detail: `${RECOGNITION_HALF} executed — ${NO_DOM}` };
+        return { status: 'boundary', detail: `${RECOGNITION_HALF} executed: ${NO_DOM}` };
     }
-    for (const fixture of profile.fixtures) {
-        for (const node of claimsIn(fixture, profile, rung)) {
-            assertIslandContract(fixture, node, kind);
-        }
+    for (const { fixture, node } of claims)
+        assertIslandContract(fixture, node, kind);
+    for (const fixture of profile.fixtures)
         assertWalkLengthIsRawLength(fixture);
-    }
     return 'recognition, self-delimiting claim, island contract, and offset-walk length';
 }
-/**
- * The claimed bytes must stand alone: `data-source-*` hands exactly this slice to the
- * clipboard and to a source reveal, and a slice that only forms in its original context
- * pastes back as broken prose while the document it came from round-trips perfectly.
- */
+/** The claimed bytes must re-form on their own: `data-source-*` hands exactly this slice to the
+ *  clipboard and a source view, where a context-dependent slice pastes back broken. */
 function assertSelfDelimiting(fixture, node, kind) {
     const slice = fixture.slice(node.start, node.end);
     const alone = parseInline(slice, 0, slice.length);
@@ -273,21 +265,20 @@ function assertSelfDelimiting(fixture, node, kind) {
         `the bytes data-source-* hands the clipboard and the reveal`);
 }
 function assertIslandContract(fixture, node, kind) {
-    const island = buildCoreInlineWidget(node, fixture);
+    const island = buildCoreInlineWidget(node, fixture, undefined, defaultGrammarView);
     assert(island !== null, `the "${kind}" widget builds an island from ${JSON.stringify(fixture)}`);
     assert(island.hasAttribute('data-inline-widget'), `the "${kind}" island carries [data-inline-widget] — the offset walk's only handle`);
     assertIs(island.getAttribute('contenteditable'), 'false', `the "${kind}" island is contenteditable=false`);
     assertIs(Number(island.getAttribute('data-source-start')), node.start, `the "${kind}" island's data-source-start is the node's own offset`);
     assertIs(Number(island.getAttribute('data-source-end')), node.end, `the "${kind}" island's data-source-end is the node's own offset`);
 }
-/**
- * The offset walk counts a widget as its SOURCE span, never as what it renders — an
- * emoji island showing one glyph for seven raw bytes still walks seven. Every caret
- * offset in the block rides on this, and no byte moves when it is wrong.
- */
+/** The DOM-to-offset traversal counts a widget as its source span, not what it renders (seven
+ *  bytes for one emoji glyph); every caret offset in the block depends on it. */
 function assertWalkLengthIsRawLength(fixture) {
     const container = document.createElement('div');
-    container.appendChild(renderInlineNodes(parseInline(fixture, 0, fixture.length), fixture));
+    container.appendChild(renderInlineNodes(parseInline(fixture, 0, fixture.length), fixture, {
+        grammar: defaultGrammarView
+    }));
     assertIs(Number(containerDomTextLength(container)), fixture.length, `the offset walk over the rendered ${JSON.stringify(fixture)} measures its raw length`);
 }
 // ── editingPolicy ────────────────────────────────────────────────────────────
@@ -298,7 +289,7 @@ function assertWalkLengthIsRawLength(fixture) {
 function checkEditingPolicy(profile, rung) {
     const kind = profile.kind;
     assert(kind !== undefined, 'the editingPolicy cell asserts but the profile names no kind');
-    const policy = getInlineWidgetEditing(kind);
+    const policy = getInlineWidgetEditing(kind, defaultGrammarView);
     assert(policy !== undefined, `"${kind}" declares no editing policy — register one, or declare this cell exempt if the ` +
         `widget takes the default select-then-delete behavior deliberately`);
     // An all-absent object is what the dispatch reads as no policy, so accepting one lets a kind
@@ -307,13 +298,11 @@ function checkEditingPolicy(profile, rung) {
         `dispatch reads exactly as no policy at all — declare a field, or declare this cell exempt`);
     assertPolicyVocabulary(policy, kind);
     if (policy.deleteGranularity === 'atomic') {
-        for (const fixture of profile.fixtures) {
-            // One press deletes ONE widget, so each claim is excised on its own.
-            for (const node of claimsIn(fixture, profile, rung)) {
-                const excised = `${fixture.slice(0, node.start)}${fixture.slice(node.end)}\n`;
-                assertIs(serialize(parse(excised)), excised, `the one-press whole-delete of the claim at ${node.start} in ` +
-                    `${JSON.stringify(fixture)} leaves bytes that round-trip`);
-            }
+        // One keypress deletes one widget, so each claim is removed on its own.
+        for (const { fixture, node } of claimsOfKind(profile, rung, kind)) {
+            const excised = `${fixture.slice(0, node.start)}${fixture.slice(node.end)}\n`;
+            assertIs(serialize(parse(excised)), excised, `the one-press whole-delete of the claim at ${node.start} in ` +
+                `${JSON.stringify(fixture)} leaves bytes that round-trip`);
         }
         return 'policy vocabulary + atomic whole-delete leaves round-tripping bytes';
     }
@@ -337,12 +326,8 @@ function assertPolicyVocabulary(policy, kind) {
     }
 }
 // ── imageClaim ───────────────────────────────────────────────────────────────
-/**
- * A rung minting a BUILT-IN kind borrows the editor's model for bytes of its own, and the
- * editor's inverse emits the built-in grammar — so without `rewriteImage` a resize turns
- * `![[cat.png|300]]` into GFM. The document round-trips throughout; it is simply a
- * different document.
- */
+/** A handler producing a built-in kind borrows the editor's model for its own bytes, so without
+ *  `rewriteImage` a resize writes `![[cat.png|300]]` back as GFM, which still round-trips. */
 function checkImageClaimStamp(profile, rung) {
     let stamped = 0;
     for (const fixture of profile.fixtures) {
@@ -363,11 +348,8 @@ function checkImageClaimStamp(profile, rung) {
         `rung mints only its own kind`);
     return `${stamped} built-in node(s) stamped, rewriteImage reproduces its own input`;
 }
-/**
- * The hook must re-emit the node it was handed, unedited. A byte-identical result is
- * dropped by the commit's equality guard with no warning, so a hook that cannot
- * reproduce its own input surfaces as an edit that silently does nothing.
- */
+/** The hook must re-emit the node it was handed unedited; the commit drops a byte-identical
+ *  result, so a hook that cannot reproduce its input shows up as an edit that does nothing. */
 function assertRewriteReproducesSource(fixture, node, rung) {
     assert(rung.rewriteImage !== undefined, `the "${rung.prefix}" rung mints a built-in image but registers no rewriteImage — every ` +
         `image edit on it is declined, and without the hook the editor would write GFM over ` +
@@ -387,8 +369,8 @@ function assertRewriteReproducesSource(fixture, node, rung) {
 // ── registration ─────────────────────────────────────────────────────────────
 function checkRegistrationHygiene(profile, prefix, rung) {
     const reserved = isReservedInlineTrigger(profile.trigger);
-    // Two rungs MAY share a prefix at different priorities (emoji and the directive text
-    // tier coexist on `:`); two at the SAME priority could not be ordered by dispatch.
+    // Two handlers may share a prefix at different priorities (emoji and directive text both
+    // live on `:`), but two at the same priority could not be ordered by the dispatch.
     const sameRung = getInlineRungs(profile.trigger).filter((r) => r.prefix === prefix && r.priority === rung.priority);
     assertIs(sameRung.length, 1, `exactly one rung holds prefix ${JSON.stringify(prefix)} at priority ${rung.priority}`);
     if (reserved) {
@@ -397,8 +379,8 @@ function checkRegistrationHygiene(profile, prefix, rung) {
             `(${INLINE_PRIORITIES.builtin}) so its prefix outranks the built-in case; got ${rung.priority}`);
     }
     else {
-        // The scan's fast bail skips an unreserved trigger unless a registration turns
-        // its per-character probe on; without it the recognizer never runs in prose.
+        // The scan's fast bail skips an unreserved trigger unless a registration turns its
+        // per-character check on; without that the recognizer never runs in prose.
         assert(isScanProbeTrigger(profile.trigger), `the scan's fast bail visits ${JSON.stringify(profile.trigger)} — a trigger it skips ` +
             `makes the recognizer unreachable in plain text`);
     }
@@ -407,37 +389,38 @@ function checkRegistrationHygiene(profile, prefix, rung) {
         : `bare rung at priority ${rung.priority} on a scan-probed trigger`;
 }
 // ── Falsifiable excuses ──────────────────────────────────────────────────────
-/**
- * An excuse the kit can check, it checks: a reason is a claim about the rung, not a
- * waiver, so a profile excusing a cell that has something to bite on fails.
- */
-function falsifyExcuse(cell, profile, rung) {
-    if (cell === 'overlapDecline' && (profile.overlapFixtures?.length ?? 0) > 0) {
-        fail('the profile supplies overlapFixtures but declares overlapDecline excused — the fixtures ' +
-            'say the overlap exists, so assert the cell');
-    }
-    if (cell === 'widget' && profile.kind !== undefined) {
-        const claimed = profile.fixtures
-            .flatMap((f) => mintedNodes(f, profile, rung).map((n) => ({ f, n })))
-            .find(({ f, n }) => n.kind === profile.kind && isInlineWidget(n, f));
-        if (claimed) {
-            fail(`"${profile.kind}" IS a registered live widget (from ${JSON.stringify(claimed.f)}), so ` +
-                `the widget cell has something to bite on and cannot be excused`);
-        }
+// Where the kit can check an excuse, it does: a reason is a claim about the handler, not a waiver.
+function refuseExcusedOverlap(profile) {
+    if ((profile.overlapFixtures?.length ?? 0) === 0)
+        return;
+    fail('the profile supplies overlapFixtures but declares overlapDecline excused — the fixtures ' +
+        'say the overlap exists, so assert the cell');
+}
+function refuseExcusedWidget(profile, rung) {
+    if (profile.kind === undefined)
+        return;
+    const claimed = profile.fixtures
+        .flatMap((f) => mintedNodes(f, profile, rung).map((n) => ({ f, n })))
+        .find(({ f, n }) => n.kind === profile.kind && isInlineWidget(n, f, defaultGrammarView));
+    if (claimed) {
+        fail(`"${profile.kind}" is a registered live widget (from ${JSON.stringify(claimed.f)}), so ` +
+            `the widget cell has something to bite on and cannot be excused`);
     }
-    if (cell === 'editingPolicy' && profile.kind !== undefined) {
-        const policy = getInlineWidgetEditing(profile.kind);
-        if (policy && Object.keys(policy).length > 0) {
-            fail(`"${profile.kind}" declares an editing policy, so the editingPolicy cell cannot be excused`);
-        }
+}
+function refuseExcusedEditingPolicy(profile) {
+    if (profile.kind === undefined)
+        return;
+    const policy = getInlineWidgetEditing(profile.kind, defaultGrammarView);
+    if (policy && Object.keys(policy).length > 0) {
+        fail(`"${profile.kind}" declares an editing policy, so the editingPolicy cell cannot be excused`);
     }
-    if (cell === 'imageClaim') {
-        const stamped = profile.fixtures
-            .flatMap((f) => mintedNodes(f, profile, rung))
-            .find((n) => n.syntaxClaim?.prefix === rung.prefix);
-        if (stamped) {
-            fail(`a fixture mints a stamped built-in "${stamped.kind}", so the imageClaim cell has ` +
-                `something to bite on and cannot be excused`);
-        }
+}
+function refuseExcusedImageClaim(profile, rung) {
+    const stamped = profile.fixtures
+        .flatMap((f) => mintedNodes(f, profile, rung))
+        .find((n) => n.syntaxClaim?.prefix === rung.prefix);
+    if (stamped) {
+        fail(`a fixture mints a stamped built-in "${stamped.kind}", so the imageClaim cell has ` +
+            `something to bite on and cannot be excused`);
     }
 }

package/dist/testing/kind-conformance.d.ts

@@ -1,20 +1,18 @@
 /**
- * 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.
+ * The generic per-kind conformance battery: registering a block kind enrolls it, one cell per
+ * `ClosureColumn` plus the raw-write cell, read from its descriptor and `conformanceFixture`. A
+ * cell runs only where headless code can observe what it checks; the rest is reported `boundary`
+ * or `exempt`, never stubbed green.
  */
 import type { AnyBlockKind, CstNode, Document } from '../core/nodes';
-import type { ClosureCell, ClosureColumn } from '../schema/closure';
-import { type BlockKindDescriptor } from '../schema/block-kind-descriptor';
-export type KindCellStatus = 'executed' | 'boundary' | 'exempt';
-export interface KindCellReport {
-    column: ClosureColumn;
-    mode: ClosureCell['mode'];
-    status: KindCellStatus;
-    /** Why a cell is boundary/exempt, or which mechanism an executed cell drove. */
-    detail: string;
+import { type ClosureCell, type ClosureColumn } from '../schema/closure';
+import { type WriteRule } from '../schema/block-kind-descriptor';
+import { type CellReport } from './conformance-core';
+/** A closure column, plus `rawWrite`, which reads the descriptor rather than the closure block. */
+export type KindCell = ClosureColumn | 'rawWrite';
+export interface KindCellReport extends CellReport<KindCell> {
+    /** The closure mode the kind declared for the cell; absent on `rawWrite`. */
+    mode?: ClosureCell['mode'];
 }
 export interface KindConformanceReport {
     kind: AnyBlockKind;
@@ -23,7 +21,6 @@ export interface KindConformanceReport {
 /** The parsed fixture context a cell executor reads; absent without a `conformanceFixture`. */
 export interface KindCellContext {
     kind: AnyBlockKind;
-    descriptor: BlockKindDescriptor;
     fixture: string;
     doc: Document;
     node: CstNode;
@@ -40,15 +37,13 @@ export interface KindConformanceProfile {
     cells?: Partial<Record<ClosureColumn, KindCellCheck>>;
 }
 /**
- * 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.
+ * Runs every headless closure cell for `kind`, or throws an `Error` naming each failed cell. A
+ * `conformanceFixture` that parses to no node of the kind fails the run outright.
  */
 export declare function runKindConformance(kind: AnyBlockKind, profile?: KindConformanceProfile): Promise<KindConformanceReport>;
-/**
- * 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.
- */
+/** Asserts the default cross-block copy over `kind`'s fixture is a raw byte slice at both endpoint
+ *  roles, which is what `clipboard: inherit-default` means; the fixture opens with `kind`. */
 export declare function checkCopyIsRawByteSlice(kind: AnyBlockKind, fixture: string): void;
+/** Drives five writes over `kind`'s fixture through its `rawWrite` rule; each result must be a
+ *  fixed point of the rule, leave the next block its own, and have an agreeing caret map. */
+export declare function checkLeafRawWrite(kind: AnyBlockKind, fixture: string, rule?: WriteRule | undefined): void;