mandrel 2.23.0 → 2.24.0

package/.agents/schemas/story-deliver-terminal.schema.json

@@ -87,7 +87,8 @@
         "statusResync",
         "refCleanup",
         "baseFastForward",
-        "tempPurge"
+        "tempPurge",
+        "leaseRelease"
       ],
       "properties": {
         "followUps": { "type": "boolean" },
@@ -98,6 +99,10 @@
           "type": "boolean",
           "description": "Story #4794 — the merged Story's spent temp artifacts (gate transcripts, validation evidence) were purged under delivery.tempRetention. A disabled policy reports true: the operator turned the purge off, so doing nothing IS the correct outcome. Only a real failure — an unreadable temp root, an undeletable artifact — reports false, and like every tail step that degrades the report, never the land."
         },
+        "leaseRelease": {
+          "type": "boolean",
+          "description": "Story #4860 — the operator's assignee-lease on the Story was released now that the merge is confirmed. The close deliberately no longer releases it at PR creation, so the ticket stays assigned for the whole time its PR is open; every non-merged ending (merge.unlanded block, exhausted wait budget, --no-wait-merge, --no-auto-merge) retains the claim and never reaches this step. A no-op release — the operator is no longer the recorded owner, as on a re-run or a belated manual confirm — reports true: an already-unassigned ticket is the desired end state. Only a throw reports false, and like every tail step that degrades the report, never the land."
+        },
         "details": {
           "type": "object",
           "description": "Per-step diagnostic detail — the reason a false step reported false.",

package/.agents/scripts/deliver-light.js

@@ -61,10 +61,10 @@ import { parseArgs } from 'node:util';
 import { runAsCli } from './lib/cli-utils.js';
 import { resolveConfig } from './lib/config-resolver.js';
 import { Logger, routeAllOutputToStderr } from './lib/Logger.js';
-import { computeChangeSet } from './lib/orchestration/change-set.js';
+import { resolveBackstopOutcome } from './lib/orchestration/light-backstop.js';
+import { recordGateRefusal } from './lib/orchestration/light-escalation.js';
 import {
   buildReceiptStoryTicket,
-  checkLightDiffBackstop,
   deriveLightSuitability,
   resolveLightGateOutcome,
 } from './lib/orchestration/light-suitability.js';
@@ -121,7 +121,11 @@ Gate options:
                      envelope and ENDS the session (no prompt, no fallback).
 
 Backstop options:
-  --backstop         Re-check the ACTUAL diff after implementation.
+  --backstop         Re-check the ACTUAL diff after implementation. Bounds the
+                     change's IMPLEMENTATION half by magnitude (changed lines +
+                     file sprawl); test/doc/baseline companions are exempt from
+                     the counts but still matched for sensitive paths. A block
+                     emits a nextCommand recycling the receipt through /plan.
   --story <id>       Story issue number whose story-<id> branch to diff.
 
   --pretty           Pretty-print the JSON envelope.
@@ -130,8 +134,6 @@ Backstop options:
 
 /** Exit code when the gate did not resolve to proceed-light. */
 const EXIT_NOT_PROCEED = 2;
-/** Exit code when the diff backstop blocked the land. */
-const EXIT_BACKSTOP_BLOCKED = 3;
 
 /**
  * Split a comma-separated path list into trimmed, non-empty entries.
@@ -292,33 +294,6 @@ export function buildNextCommands(storyId) {
   };
 }
 
-/**
- * Run the diff backstop against a Story branch's actual change set.
- *
- * @param {{
- *   storyId: number,
- *   baseRef?: string,
- *   cwd?: string,
- *   computeFn?: typeof computeChangeSet,
- *   injectedRules?: object,
- * }} args
- * @returns {ReturnType<typeof checkLightDiffBackstop>}
- */
-export function runDiffBackstop({
-  storyId,
-  baseRef = 'main',
-  cwd = process.cwd(),
-  computeFn = computeChangeSet,
-  injectedRules,
-} = {}) {
-  const { files } = computeFn({
-    baseRef,
-    headRef: `story-${storyId}`,
-    cwd,
-  });
-  return checkLightDiffBackstop({ changedFiles: files, injectedRules });
-}
-
 /**
  * Was a non-blank `--operator-proceed-light` supplied? The gate core decides
  * whether it *applies*; this only asks whether the operator typed one, so the
@@ -348,27 +323,28 @@ function emit(envelope, pretty) {
 }
 
 /**
- * Backstop mode — re-check the actual diff.
+ * Backstop mode — re-check the actual diff. The decision lives in
+ * {@link module:lib/orchestration/light-backstop}; this branches and prints.
  *
- * @param {{ story?: string, pretty: boolean }} values
+ * @param {object} values Parsed CLI values.
+ * @param {{ resolveFn?: typeof resolveBackstopOutcome }} [deps]
  * @returns {Promise<number>}
  */
-async function runBackstopMode(values) {
+async function runBackstopMode(values, deps = {}) {
+  const { resolveFn = resolveBackstopOutcome } = deps;
   const storyId = Number.parseInt(String(values.story ?? ''), 10);
   if (!Number.isInteger(storyId) || storyId <= 0) {
     process.stderr.write(HELP);
     throw new Error('[deliver-light] --backstop requires --story <id>');
   }
-  const result = runDiffBackstop({ storyId });
-  emit({ mode: 'backstop', storyId, ...result }, values.pretty);
-  if (result.blocked) {
-    Logger.warn(
-      `[deliver-light] diff backstop BLOCKED Story #${storyId}: ${result.reasons.join('; ')}`,
-    );
-    return EXIT_BACKSTOP_BLOCKED;
-  }
-  Logger.info(`[deliver-light] diff backstop clean for Story #${storyId}.`);
-  return 0;
+  const { result, nextCommand, exitCode, message } = await resolveFn({
+    storyId,
+  });
+  const extra = nextCommand === null ? {} : { nextCommand };
+  emit({ mode: 'backstop', storyId, ...result, ...extra }, values.pretty);
+  if (result.blocked) Logger.warn(message);
+  else Logger.info(message);
+  return exitCode;
 }
 
 /**
@@ -407,6 +383,7 @@ export async function runGateMode(values, deps = {}) {
     createReceiptFn = createLightReceipt,
     emitFn = emit,
     emitTerminalFn = emitTerminalEnvelope,
+    recordRefusalFn = recordGateRefusal,
   } = deps;
 
   if (!values.prompt || String(values.prompt).trim() === '') {
@@ -457,6 +434,7 @@ export async function runGateMode(values, deps = {}) {
       { mode: 'gate', action: gate.action, outcome: gate.outcome },
       values.pretty,
     );
+    await recordRefusalFn({ gate, amends: values.amends });
     Logger.warn(
       `[deliver-light] gate did not proceed light (${gate.action}): ${gate.outcome.reasons.join('; ')}`,
     );

package/.agents/scripts/lib/audit-suite/lens-diff-floor.js

@@ -28,6 +28,7 @@
  */
 
 import { gitSpawn } from '../git-utils.js';
+import { readNumstatRows } from '../orchestration/diff-magnitude.js';
 import { selectSensitivePathClasses } from './selector.js';
 
 /**
@@ -58,6 +59,12 @@ export function resolveLensDiffFloor(config) {
  * Count the changed lines (additions + deletions) in the
  * `baseRef...headRef` diff via `git diff --numstat`.
  *
+ * The read and the parse are shared with the light path's magnitude backstop
+ * ({@link module:lib/orchestration/diff-magnitude.readNumstatRows}) so the two
+ * cannot disagree about how a diff is measured. This one keeps a whole-diff
+ * total: the lens floor asks "is this diff small", not "is its implementation
+ * half small", so it deliberately does **not** apply the companion exemption.
+ *
  * Total — never throws. Returns `null` (the neutral "count unknown" signal
  * the floor fails open on) for any git failure or unparseable output, and
  * `0` for a genuinely empty diff. Binary rows (`-\t-\tpath`) contribute 0
@@ -77,31 +84,9 @@ export function countChangedLines({
   cwd = process.cwd(),
   gitSpawnFn = gitSpawn,
 } = {}) {
-  if (typeof baseRef !== 'string' || baseRef.length === 0) return null;
-  if (typeof headRef !== 'string' || headRef.length === 0) return null;
-  try {
-    const result = gitSpawnFn(
-      cwd,
-      'diff',
-      '--numstat',
-      `${baseRef}...${headRef}`,
-    );
-    if (!result || result.status !== 0 || typeof result.stdout !== 'string') {
-      return null;
-    }
-    let total = 0;
-    for (const line of result.stdout.split('\n')) {
-      const trimmedEnd = line.replace(/\s+$/, '');
-      if (trimmedEnd.length === 0) continue;
-      const match = /^(\d+|-)\t(\d+|-)\t/.exec(trimmedEnd);
-      if (!match) return null; // Unexpected format — the count is not trustworthy.
-      if (match[1] !== '-') total += Number(match[1]);
-      if (match[2] !== '-') total += Number(match[2]);
-    }
-    return total;
-  } catch {
-    return null;
-  }
+  const rows = readNumstatRows({ baseRef, headRef, cwd, gitSpawnFn });
+  if (rows === null) return null;
+  return rows.reduce((total, row) => total + row.additions + row.deletions, 0);
 }
 
 /**

package/.agents/scripts/lib/baselines/kinds/maintainability.js

@@ -30,10 +30,25 @@ export const name = 'maintainability';
 export const keyField = 'path';
 
 /**
- * Files the maintainability scorer cannot measure because `typhonjs-escomplex`
- * (the upstream kernel) parse-fails on syntax the runtime supports but the
- * library has never been updated for. Each entry must carry a one-line reason
- * so a future engine bump can audit the list and drop the exclusion.
+ * Files the maintainability scorer cannot measure because the upstream kernel
+ * throws on them. Each entry must carry a one-line reason so a future engine
+ * bump can audit the list and drop the exclusion.
+ *
+ * **This list is empty, and the goal is to keep it that way.** It previously
+ * held seven paths, all attributed to escomplex "choking on modern
+ * destructuring / regex-property patterns". That diagnosis was wrong. The real
+ * defect is that `typhonjs-escomplex`'s code generator is written against
+ * ESTree while its own parser emits Babel, so a regex literal in a loop head,
+ * an `await` in a loop head, a `?.`, a dynamic `import()`, or an object spread
+ * in a default parameter aborted the whole file's analysis. That is now
+ * repaired at the kernel boundary by `lib/escomplex-ast-compat.js`, which makes
+ * all four surviving entries scorable — and the audit incidentally showed the
+ * other three had been pointing at deleted files, because nothing audits an
+ * allowlist whose only effect is to suppress output.
+ *
+ * Before adding a path here, check whether `escomplex-ast-compat.js` can handle
+ * the construct instead. An entry here is a file nobody measures; a handler
+ * there gets it measured for every consumer.
  *
  * Story #2467 / Task #2494 — the prior behaviour stored these files with
  * `mi: 0` in `baselines/maintainability.json`, which corrupted the global
@@ -44,34 +59,7 @@ export const keyField = 'path';
  *
  * Canonicalised POSIX repo-relative paths.
  */
-export const MAINTAINABILITY_EXCLUSIONS = Object.freeze(
-  new Set([
-    // escomplex: "Cannot read properties of undefined (reading 'pattern')" —
-    // chokes on modern destructuring / regex-property patterns used in the
-    // reconciler's spec walker.
-    '.agents/scripts/acceptance-spec-reconciler.js',
-    // escomplex: same "pattern" parse failure as acceptance-spec-reconciler;
-    // both files share the lifecycle-lint regex-driven scan helpers.
-    '.agents/scripts/check-lifecycle-lint.js',
-    // escomplex: "this[node.callee.type] is not a function" — the cyclomatic
-    // visitor lacks a handler for one of the quality-watch CLI's call shapes.
-    '.agents/scripts/quality-watch.js',
-    // escomplex: "Cannot read properties of undefined (reading 'pattern')" —
-    // the audit-to-stories parser reuses the same regex-property scan
-    // patterns as acceptance-spec-reconciler.
-    '.agents/scripts/lib/audit-to-stories/parse-audit-md.js',
-    // escomplex: same "pattern" parse failure family — the BDD scanner walks
-    // source trees with regex visitors that hit the upstream destructuring
-    // bug.
-    '.agents/scripts/lib/bdd-scenario-scanner.js',
-    // escomplex: same "pattern" parse failure — the wave-runner tick uses
-    // the regex-property destructuring escomplex chokes on.
-    '.agents/scripts/lib/wave-runner/tick.js',
-    // escomplex: same "pattern" parse failure — exercises the same
-    // destructuring shape in a test fixture.
-    'tests/scripts/story-close-merge-subject.test.js',
-  ]),
-);
+export const MAINTAINABILITY_EXCLUSIONS = Object.freeze(new Set());
 
 /**
  * Filter parse-unscorable files out of a rows array. Used by the scorer

package/.agents/scripts/lib/escomplex-ast-compat.js

@@ -0,0 +1,360 @@
+/**
+ * escomplex-ast-compat.js — reconcile the `typhonjs-escomplex` code generator
+ * with the Babel AST that `typhonjs-escomplex`'s own default parser emits.
+ *
+ * ## The upstream defect
+ *
+ * `typhonjs-escomplex` parses with `@typhonjs/babel-parser`, so every AST it
+ * analyses is a **Babel** AST. But `typhonjs-escomplex-commons`'
+ * `utils/ast/astSyntax.js` — the code generator that `ASTGenerator` drives —
+ * was written against **ESTree**. The two disagree on node names
+ * (`OptionalMemberExpression` vs a `MemberExpression` with `optional: true`)
+ * and on node shapes (Babel's `RegExpLiteral` carries `pattern`/`flags`
+ * directly; ESTree wraps them in a `regex` object on a `Literal`).
+ *
+ * That mismatch is invisible for most code because the metric traversal runs
+ * off the syntax plugin's trait tables, not off `astSyntax`. `astSyntax` is
+ * only reached where a trait re-serialises a **sub-AST** to synthesise a
+ * Halstead operand or a function signature — nine traits do this:
+ * `For`/`ForIn`/`ForOf` heads, `Function`/`FunctionExpression`/
+ * `ArrowFunctionExpression` parameter lists, `Class`/`ClassExpression`
+ * bodies, and `YieldExpression` arguments.
+ *
+ * Reach one of those with a Babel-only node and `analyzeModule()` throws —
+ * aborting the whole module, not just the sub-expression. The constructs that
+ * trip it are ordinary modern JavaScript:
+ *
+ * ```js
+ * for (const t of s.split(/[^a-z]+/)) {}   // TypeError: …reading 'pattern'
+ * for (const t of await xs()) {}           // …generator[node.type] is not a function
+ * for (const t of a?.b) {}                 // …generator[node.type] is not a function
+ * function f(a = () => import('x')) {}     // …this[node.callee.type] is not a function
+ * function f(a = { ...b }) {}              // TypeError: …reading 'type'
+ * function f(a = { m() {} }) {}            // TypeError: …reading 'generator'
+ * function f(a = class { m() {} }) {}      // …this[statement.type] is not a function
+ * ```
+ *
+ * The `{ ...b }` case is upstream issue #24, open and untouched since
+ * 2020-12-16 with a byte-identical stack trace. The package last published in
+ * June 2022 and the repo that holds the defective file has issues *disabled*,
+ * so waiting for an upstream release is not a plan. Consumers of this kernel
+ * previously absorbed the breakage as an allowlist of "unscorable" files that
+ * grew every time someone wrote a `?.` in a loop head.
+ *
+ * ## What this module does
+ *
+ * Installs the missing handlers and repairs the two shape assumptions, on the
+ * shared `astSyntax` table, once per process. Every patch is **conditional**:
+ * a handler is only installed where the table lacks one, and the two repairs
+ * wrap the original rather than replacing its behaviour. If a future kernel
+ * bump fixes any of this upstream, the corresponding patch silently stops
+ * applying and `install()` reports a shorter list — which
+ * `tests/lib/escomplex-ast-compat.test.js` asserts on, so the shrinkage is
+ * visible rather than silent.
+ *
+ * Nothing here changes the score of a file that already parses: the patched
+ * paths are exactly the paths that previously threw.
+ *
+ * @see https://github.com/typhonjs-node-escomplex/typhonjs-escomplex/issues/24
+ */
+
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+/** Marker set on every function this module installs, for idempotency. */
+const PATCH_MARKER = Symbol.for('mandrel.escomplexAstCompat');
+
+/** Memoised result of the one-time install. */
+let installResult = null;
+
+/**
+ * Resolve the shared `astSyntax` generator table.
+ *
+ * This is a deep import into a transitive dependency's `dist/`, which is
+ * exactly as fragile as it looks — hence the soft failure. If upstream ever
+ * restructures, `install()` reports `available: false` and the engine falls
+ * back to today's behaviour (unscorable files, now reported explicitly by
+ * the engine rather than silently scored 0).
+ *
+ * The patch must land on the *same* `typhonjs-escomplex-commons` instance the
+ * kernel loads, so `commons` is resolved **through `typhonjs-escomplex`'s own
+ * resolution** rather than from here. Resolving it directly would be a coin
+ * flip: under a hoisting installer it usually finds the same copy, but under
+ * pnpm's isolated layout — or as soon as anything declares `commons` directly —
+ * it can find a *different* physical copy, and the patch then lands on a table
+ * nobody reads while `install()` cheerfully reports success. Anchoring makes
+ * that failure mode unreachable.
+ *
+ * `requireFn` is the test seam: a cross-checkout verification harness passes
+ * its own `createRequire` so the anchor starts from that checkout's escomplex.
+ *
+ * @param {NodeJS.Require} [requireFn]
+ * @returns {Record<string, Function>|null}
+ */
+function resolveSyntaxTable(requireFn = require) {
+  try {
+    const fromKernel = createRequire(requireFn.resolve('typhonjs-escomplex'));
+    const mod = fromKernel(
+      'typhonjs-escomplex-commons/dist/utils/ast/astSyntax.js',
+    );
+    const table = mod?.default ?? mod;
+    if (!table || typeof table !== 'object') return null;
+    // Sanity-check that this is the table we think it is before mutating it.
+    if (typeof table.MemberExpression !== 'function') return null;
+    if (Object.isFrozen(table)) return null;
+    return table;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Tag a handler as ours so a second `install()` is a no-op.
+ *
+ * @template {Function} F
+ * @param {F} fn
+ * @returns {F}
+ */
+function mark(fn) {
+  fn[PATCH_MARKER] = true;
+  return fn;
+}
+
+/**
+ * Install `name` only if the table has no handler for it. Returns whether the
+ * install happened, so the caller can report the applied surface.
+ *
+ * @param {Record<string, Function>} table
+ * @param {string} name
+ * @param {Function} handler
+ * @returns {boolean}
+ */
+function addMissing(table, name, handler) {
+  if (typeof table[name] === 'function') return false;
+  table[name] = mark(handler);
+  return true;
+}
+
+/**
+ * Build an ESTree-shaped stand-in for a Babel `ObjectMethod` / `ClassMethod`,
+ * whose function bits sit on the node itself rather than under `value`.
+ * `MethodDefinition` reads `node.value.{generator,params,body}`, so handing it
+ * a synthesized `value` lets the original handler do the work unchanged.
+ *
+ * @param {object} node
+ * @returns {object}
+ */
+function asMethodDefinition(node) {
+  return {
+    ...node,
+    kind:
+      typeof node.kind === 'string' && node.kind.length > 0
+        ? node.kind
+        : 'init',
+    value: {
+      type: 'FunctionExpression',
+      generator: Boolean(node.generator),
+      async: Boolean(node.async),
+      params: node.params ?? [],
+      body: node.body,
+    },
+  };
+}
+
+/**
+ * Patch the shared `astSyntax` table. Idempotent; safe to call from every
+ * entry point that is about to run `analyzeModule`.
+ *
+ * @param {{ requireFn?: NodeJS.Require, memoise?: boolean }} [options] Test
+ *   seam only — see {@link resolveSyntaxTable}. Production callers pass
+ *   nothing.
+ * @returns {{ available: boolean, applied: string[] }} `available` is false
+ *   when the upstream internals could not be resolved. `applied` names each
+ *   patch that was actually needed, so an upstream fix shows up as a
+ *   shorter list.
+ */
+export function install(options = {}) {
+  const { requireFn, memoise = true } = options;
+  if (memoise && installResult !== null) return installResult;
+
+  const table = resolveSyntaxTable(requireFn);
+  if (table === null) {
+    const unavailable = { available: false, applied: [] };
+    if (memoise) installResult = unavailable;
+    return unavailable;
+  }
+
+  const applied = [];
+  const add = (name, handler) => {
+    if (addMissing(table, name, handler)) applied.push(name);
+  };
+
+  // ---- Repair 1: Babel's RegExpLiteral shape -------------------------------
+  // Upstream reads `node.regex.pattern`, which only exists on an ESTree
+  // `Literal`. Babel puts `pattern`/`flags` on the node. Wrapped rather than
+  // replaced so the ESTree delegate path (`Literal` → `RegExpLiteral`) keeps
+  // its exact original output.
+  if (
+    typeof table.RegExpLiteral === 'function' &&
+    !table.RegExpLiteral[PATCH_MARKER]
+  ) {
+    const original = table.RegExpLiteral;
+    table.RegExpLiteral = mark(function RegExpLiteral(node, state) {
+      if (node?.regex === undefined) {
+        state.output.write(
+          `new RegExp(${JSON.stringify(node?.pattern ?? '')}, ` +
+            `${JSON.stringify(node?.flags ?? '')})`,
+        );
+        return;
+      }
+      return original.call(this, node, state);
+    });
+    applied.push('RegExpLiteral');
+  }
+
+  // ---- Repair 2: ObjectExpression's hard `this.Property()` dispatch --------
+  // `ObjectExpression` calls `this.Property(el)` on every element regardless
+  // of the element's actual type. Two Babel shapes get mis-routed by that:
+  //
+  //   `{ ...b }`    → a `SpreadElement` lands in `Property`, which reads
+  //                   `node.key.type` and throws. Upstream issue #24.
+  //   `{ m() {} }`  → an `ObjectMethod` has `kind: 'method'`, so `Property`'s
+  //                   `node.kind[0] !== 'i'` test sends the raw Babel node to
+  //                   `MethodDefinition`, which reads `node.value.generator`
+  //                   and throws.
+  //
+  // Patching `Property` rather than `ObjectExpression` keeps the patch small
+  // and leaves the indentation-sensitive object serialisation untouched:
+  // anything arriving here that is not actually a property node gets
+  // re-dispatched on its real type.
+  //
+  // `Property` and `ObjectProperty` are excluded from re-dispatch because the
+  // table aliases `ObjectProperty` to `Property` — re-dispatching either would
+  // recurse into this wrapper forever.
+  if (typeof table.Property === 'function' && !table.Property[PATCH_MARKER]) {
+    const original = table.Property;
+    const PROPERTY_TYPES = new Set(['Property', 'ObjectProperty']);
+    table.Property = mark(function Property(node, state) {
+      const type = node?.type;
+      if (
+        typeof type === 'string' &&
+        !PROPERTY_TYPES.has(type) &&
+        typeof this[type] === 'function'
+      ) {
+        return this[type](node, state);
+      }
+      return original.call(this, node, state);
+    });
+    applied.push('Property');
+  }
+
+  // ---- Missing handlers: Babel-only node types ----------------------------
+
+  // `await x` — mirrors upstream's `YieldExpression`.
+  add('AwaitExpression', function AwaitExpression(node, state) {
+    const output = state.output;
+    output.write('await ');
+    output.operators.push('await');
+    if (node.argument) this[node.argument.type](node.argument, state);
+  });
+
+  // `a?.b` / `a?.[b]` — mirrors upstream's `MemberExpression`, with `?.`
+  // recorded as its own operator so optional access is not counted as plain
+  // member access.
+  add(
+    'OptionalMemberExpression',
+    function OptionalMemberExpression(node, state) {
+      const output = state.output;
+      this[node.object.type](node.object, state);
+      if (node.computed) {
+        output.write('?.[');
+        this[node.property.type](node.property, state);
+        output.write(']');
+        output.operators.push('?.[]');
+      } else {
+        output.write('?.');
+        output.operators.push('?.');
+        this[node.property.type](node.property, state);
+      }
+    },
+  );
+
+  // `a?.()` — mirrors upstream's `CallExpression`.
+  add('OptionalCallExpression', function OptionalCallExpression(node, state) {
+    this[node.callee.type](node.callee, state);
+    state.output.write('?.');
+    state.output.operators.push('?.()');
+    ASTUtil().formatSequence(node.arguments ?? [], state, this);
+  });
+
+  // The callee node of a dynamic `import(...)`. Babel models the `import`
+  // keyword as its own node type; ESTree has no equivalent.
+  add('Import', function Import(_node, state) {
+    state.output.write('import');
+    state.output.operators.push('import()');
+  });
+
+  // `{ m() {} }` / `{ get m() {} }` — Babel's ObjectMethod.
+  add('ObjectMethod', function ObjectMethod(node, state) {
+    return this.MethodDefinition(asMethodDefinition(node), state);
+  });
+
+  // `class { m() {} }` — Babel's ClassMethod (ESTree: MethodDefinition).
+  add('ClassMethod', function ClassMethod(node, state) {
+    return this.MethodDefinition(asMethodDefinition(node), state);
+  });
+
+  // `class { p = 1 }` — Babel's ClassProperty (ESTree: PropertyDefinition).
+  const classProperty = function ClassProperty(node, state) {
+    const output = state.output;
+    if (node.static) {
+      output.write('static ');
+      output.operators.push('static');
+    }
+    if (node.computed) {
+      output.write('[');
+      this[node.key.type](node.key, state);
+      output.write(']');
+    } else {
+      this[node.key.type](node.key, state);
+    }
+    if (node.value) {
+      output.write(' = ');
+      output.operators.push('=');
+      this[node.value.type](node.value, state);
+    }
+    output.write(';');
+  };
+  add('ClassProperty', classProperty);
+  add('PropertyDefinition', classProperty);
+
+  const result = { available: true, applied };
+  if (memoise) installResult = result;
+  return result;
+}
+
+/**
+ * `ASTUtil` is only needed by the `OptionalCallExpression` handler, and only at
+ * call time — resolving it lazily keeps `install()` free of a second deep
+ * import that could fail at module load. Anchored through the kernel for the
+ * same reason as {@link resolveSyntaxTable}.
+ *
+ * `formatSequence` is a pure helper that takes the traveler and state as
+ * arguments, so which copy answers is immaterial — but resolving it the same
+ * way keeps one rule in this file rather than two.
+ *
+ * @returns {{ formatSequence: Function }}
+ */
+function ASTUtil() {
+  const fromKernel = createRequire(require.resolve('typhonjs-escomplex'));
+  const mod = fromKernel(
+    'typhonjs-escomplex-commons/dist/utils/ast/ASTUtil.js',
+  );
+  return mod?.default ?? mod;
+}
+
+// A test that needs to re-run the install against the already-patched table
+// passes `{ memoise: false }` rather than resetting module state — the patches
+// are self-detecting via PATCH_MARKER, so a non-memoised re-run is exactly the
+// idempotency assertion worth making.