@asmlift/core 0.4.0 → 0.5.0

package/src/l3/gates.ts

@@ -0,0 +1,67 @@
+// A pass's admission rules as DATA, so "does every sound gate have a test that fails without it?"
+// is a query instead of an audit.
+//
+// Because the table is a value, a test can drop one entry and re-run the pass: the real predicate,
+// on real input, with no test-only branch in the shipped path. That makes `sound` cost something to
+// declare — see `gateTableDefects` and the contract test that pairs with it.
+//
+// `why` is a LABEL, one line. The argument for why the rule is correct belongs in the file header,
+// which has room; duplicating it here is how a table stops paying for itself.
+export interface Gate<Ctx> {
+  /** stable, kebab-case; appears in test names and in the contract report */
+  readonly id: string;
+  /** one line: the reason the rule exists */
+  readonly why: string;
+  /** Remove it and some candidate is WRONG, not merely worse. Everything else is a codegen
+   *  heuristic the differ still referees. This flag is what makes `guardedBy` mandatory. */
+  readonly sound: boolean;
+  /** the test that fails when this gate is removed — required for a sound gate */
+  readonly guardedBy?: string;
+  /** true ⇒ REJECT this candidate */
+  readonly rejects: (c: Ctx) => boolean;
+}
+
+/** The id of the first gate that rejects `c`, or null when every gate admits it. FIRST, not all:
+ *  one decisive rule is what makes a refusal attributable, and it keeps the cost the same as the
+ *  `||` chain this replaces — evaluation still short-circuits. */
+export function firstRejection<Ctx>(gates: readonly Gate<Ctx>[], c: Ctx): string | null {
+  for (const g of gates) {
+    if (g.rejects(c)) {
+      return g.id;
+    }
+  }
+  return null;
+}
+
+/** A gate table with one entry removed — the ablation, as a value. Throws on an unknown id: a
+ *  typo'd ablation that silently tests nothing is the failure this file exists to prevent. */
+export function without<Ctx>(gates: readonly Gate<Ctx>[], id: string): readonly Gate<Ctx>[] {
+  if (!gates.some((g) => g.id === id)) {
+    throw new Error(`no gate '${id}' to ablate (have: ${gates.map((g) => g.id).join(', ')})`);
+  }
+  return gates.filter((g) => g.id !== id);
+}
+
+/** Structural defects in a gate table — the part checkable without running the pass. Returns
+ *  findings rather than throwing, so core stays free of a test-framework import. */
+export function gateTableDefects<Ctx>(gates: readonly Gate<Ctx>[]): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const g of gates) {
+    if (seen.has(g.id)) {
+      out.push(`duplicate gate id '${g.id}'`);
+    }
+    seen.add(g.id);
+    if (!/^[a-z][a-z0-9-]*$/.test(g.id)) {
+      out.push(`gate id '${g.id}' is not kebab-case`);
+    }
+    if (g.why.trim().length < 12) {
+      out.push(`gate '${g.id}' has no usable \`why\``);
+    }
+    // the one rule that costs something to declare
+    if (g.sound && !g.guardedBy?.trim()) {
+      out.push(`gate '${g.id}' is marked sound but names no guard`);
+    }
+  }
+  return out;
+}

package/src/l3/scopebase.ts

@@ -1,17 +1,20 @@
 // L3 re-spelling lever: hoist a reused global base into a pointer local at the INNERMOST scope
 // that contains all of its uses.
 //
+// The lever earns its place: returning `null` from `hoistScopedBases` costs
+// kleod:UpdateHUDCounterDisplay its match, so the benchmark's zero-lost gate guards this file.
+//
 // `l3/basecse.ts` already hoists a reused leaf base — but always to the FUNCTION TOP, and only for
 // an `addr`/`const` base. Both limits are load-bearing here, and each costs a real row:
 //
 //   PLACEMENT. A base used only inside one `if` arm, hoisted to the function top, is live across
 //   everything before that arm — a live range the original never had, which is the register-pressure
-//   failure basecse's own loop gate exists for. Measured on kleod:UpdateHUDCounterDisplay by
-//   hand-editing the REFERENCE source: naming the `gBgTilemapBufs` store base inside the arm that
-//   uses it is byte-exact, and moving that same declaration to the function top costs 24. That is
-//   the reason the lever is scope-aware; it is NOT a claim about what the lever achieves. On that
-//   row it now declines outright (a later pass retired the phi it keyed on, so the base's uses span
-//   the function body), and the cluster fallback below is what recovers it.
+//   failure basecse's own loop gate exists for. That argument is why the lever is scope-aware; it is
+//   NOT a claim about what the lever achieves, and no committed measurement separates the two
+//   placements (the one that did edited a reference source by hand and cannot be re-run). On
+//   kleod:UpdateHUDCounterDisplay the primary path declines outright (a later pass retired the phi
+//   it keyed on, so the base's uses span the function body), and the cluster fallback below is what
+//   recovers it.
 //   basecse's header already names the gap — "a loop-body base is left
 //   inline for a future scope-aware hoist" — and this is that hoist.
 //
@@ -143,7 +146,8 @@ function collect(
     // CONDITION the same way. They do NOT agree about a `for`'s `init`: basecse counts it in-loop
     // (its `stmtChildren('for')` is `[init, inc, …body]`, recursed with `nested`), this pass counts
     // it at the enclosing cadence, which is the truthful reading — it runs once. Recorded because
-    // the divergence is real and an extraction has to pick one.
+    // the divergence is real and an extraction has to pick one; both readings are pinned in
+    // test/addr-placement.test.ts so the pick is deliberate rather than whichever survives.
     stmtExprs(s).forEach((e) => visit(e, isLoop));
     if (s.k === 'for') {
       // `init`/`inc` are typed as the full Stmt union, so a COMPOUND one is type-legal. `stmtExprs`

package/src/l3/tailmerge.ts

@@ -15,10 +15,14 @@
 //
 //     if (c) { } else { g[594] = g[659]; } v4 = 1;   →   if (!c) { g[594] = g[659]; } v4 = 1;
 //
-// Measured on kleod:UpdateHUDCounterDisplay: 60 → 33 (visible in the committed results.json). The
-// placement is not a matter of taste — peeling the same statements to ABOVE the `if` instead scores
-// 48 — but note that above-the-`if` is a THIRD option, unsound for its own reason (it crosses the
-// condition as well as both arms); the soundness argument here covers only below-vs-in-arms.
+// THE BENCHMARK DOES NOT GUARD THIS PASS. It fires on two of its 743 rows and both match with the
+// merge and without it, so no score moves if this file breaks — and none moves if the pipeline
+// simply stops calling it. `test/tailmerge.test.ts` covers that gap explicitly, end to end, on one
+// of those two functions; the rest of that file calls this pass directly and cannot see an unwiring.
+//
+// Placement is not a matter of taste: peeling the same statements ABOVE the `if` is a THIRD option,
+// unsound for its own reason (it crosses the condition as well as both arms). The soundness argument
+// above covers only below-vs-in-arms.
 //
 // KNOWN INTERACTIONS, both byte-level rather than soundness. This pass is unconditional like
 // `dce.ts` and `basecse.ts` rather than a differ-refereed lever, and the argument those files each

package/src/pipeline.ts

@@ -1,15 +1,21 @@
 // asmlift — the library entry point. `decompile(name, asm, target)` runs the raising tower and
 // returns structured results: the source, the per-level IR dumps, and diagnostics.
 import { cBackend } from './backend/c';
-import { ContractError, assertDerefsTyped, assertResolved, assertTypesRecovered } from './contracts';
+import {
+  ContractError,
+  assertDerefsTyped,
+  assertEffectsPreserved,
+  assertResolved,
+  assertTypesRecovered,
+} from './contracts';
 import type { AsmData } from './frontend/asmdata';
 import { FrontendUnsupportedError } from './frontend/errors';
 import { frontendFor } from './frontend/registry';
-import type { Fn } from './ir/core';
+import { type Block, type Fn, successorsOf } from './ir/core';
 import { print } from './ir/print';
 import { T } from './ir/types';
 import { VerifyError, verify } from './ir/verify';
-import { Expr, LanguageBackend, SFn, Stmt, exprChildren, stmtChildren, stmtExprs } from './l3/ast';
+import { Expr, LanguageBackend, SFn, Stmt, exprChildren, gapReasonFor, stmtChildren, stmtExprs } from './l3/ast';
 import { hoistReusedGlobalBases } from './l3/basecse';
 import { eliminateDeadStores } from './l3/dce';
 import { mergeCommonTails } from './l3/tailmerge';
@@ -189,9 +195,55 @@ export function raiseRecovered(fn: Fn, target: TargetDescription, hooks: RaiseHo
   }
 }
 
+/** Run `body`; if it declines, name the unmodelled instructions the function carries.
+ *
+ *  An `opaque` degrades its own value AND makes its block impure, so a shape recognizer refuses:
+ *  `headerPure` rejects a header holding one, and the loop declines with "unrecovered back-edge …".
+ *  True and useless — the shape is fine, an instruction is missing — and the benchmark classifies
+ *  declines by that text, so the round is filed as a loop-capability gap and the improvement loop
+ *  builds the wrong thing.
+ *
+ *  Only ADDS attribution: never converts a decline into a success, never fires without an
+ *  unmodelled instruction, reachable blocks only (one in dead code did not cause the refusal). */
+function attributeOpaques<T>(fn: Fn, body: () => T): T {
+  try {
+    return body();
+  } catch (e) {
+    // Attribution is a nicety, so it must not be able to throw: a crash here would replace a
+    // DESIGNED loud failure with an incidental one, which contract-invariant.test.ts rejects by name.
+    if (!(e instanceof StructureError) || !fn.blocks[0]) {
+      throw e;
+    }
+    const seen = new Set<Block>([fn.blocks[0]]);
+    for (const stack = [fn.blocks[0]]; stack.length;) {
+      for (const s of successorsOf(stack.pop()!)) {
+        if (!seen.has(s)) {
+          seen.add(s);
+          stack.push(s);
+        }
+      }
+    }
+    const names = new Set<string>();
+    for (const b of seen) {
+      for (const op of b.ops) {
+        if (op.opcode === 'opaque') {
+          names.add(typeof op.attrs.mnemonic === 'string' ? op.attrs.mnemonic : '?');
+        }
+      }
+    }
+    if (!names.size || /unmodelled instruction/.test(e.message)) {
+      throw e;
+    }
+    // Through `gapReasonFor`, so the classifier sees its canonical text — a hand-written variant
+    // misses the mnemonic-anchored classes and every attributed decline lands in the generic bucket.
+    const list = [...names].sort().map(gapReasonFor).join(', ');
+    throw new StructureError(`${e.message} — and the function carries ${list}, which is the more likely cause`);
+  }
+}
+
 /** Stage 4 — structure + its boundary contracts, always as a pair. */
 export function structureChecked(fn: Fn, opts: Parameters<typeof structure>[1]): SFn {
-  const raw = structure(fn, opts);
+  const raw = attributeOpaques(fn, () => structure(fn, opts));
   // BOTH boundary contracts run on the pre-DCE tree: the readability pass must never be able to
   // hide a structuring defect by dropping the dead statement that carries it. assertResolved
   // catches an unresolved `?` value; assertDerefsTyped catches an ill-typed deref (e.g. a pointer
@@ -199,6 +251,7 @@ export function structureChecked(fn: Fn, opts: Parameters<typeof structure>[1]):
   // removes statements/flips branches over an already-validated tree.
   assertResolved(raw);
   assertDerefsTyped(raw);
+  assertEffectsPreserved(fn, raw);
   // Then the readability/quality rewrites: merge a statement common to every arm of an if,
   // drop dead stores (whose empty-then peephole flips the arm the merge empties), then hoist a
   // reused aggregate-global
@@ -206,6 +259,9 @@ export function structureChecked(fn: Fn, opts: Parameters<typeof structure>[1]):
   // local's initializer, so re-validate deref typing on the rewritten tree.
   const sfn = hoistReusedGlobalBases(eliminateDeadStores(mergeCommonTails(raw)));
   assertDerefsTyped(sfn);
+  // Re-checked after the readability rewrites for the same reason deref typing is: a pass that
+  // merges arms or drops statements must not be able to lose or duplicate a call.
+  assertEffectsPreserved(fn, sfn);
   return sfn;
 }
 

package/src/raise/divpow2.ts

@@ -103,7 +103,8 @@ export function recognizeDivPow2(fn: Fn): boolean {
       for (const bias of preds.get(m)!) {
         // The BIAS arm: sole predecessor is the head, and it does nothing but bias (and possibly
         // shift). The whole block is DELETED, not hoisted, so anything else in it would be silently
-        // dropped — a store, a call or a live opaque there would simply stop happening.
+        // dropped — a store, a call or an opaque there would simply stop happening (an opaque
+        // whether or not its result is read: liveness says nothing about what the instruction did).
         const bt = term(bias);
         if (bt.opcode !== 'br' || bt.successors[0]?.block !== m || bias === fn.blocks[0]) {
           continue;

package/src/raise/gvn.ts

@@ -39,6 +39,9 @@
 // analysis.ts, whose materialize-into-a-local rule covers `const`, `call` and the memory reads, NOT
 // address ops), so the address is re-spelled at each access exactly as the original source did.
 // Hoisting therefore does not create the long live range that hoisting a LOADED value would.
+// That is a promise ANOTHER module keeps, so `test/addr-placement.test.ts` holds it to it: let
+// analysis.ts materialize an address op and the entry hoist becomes a function-top local — the one
+// this pass exists to delete, reintroduced one level up.
 //
 // SCOPE, deliberately narrow: `code: true` symbols (a promoted function pointer, spelled `(u32)Name`
 // rather than `&Name`) are numbered separately from data ones, because the attr is part of what the
@@ -47,15 +50,22 @@
 // THE WIN IS CONTINGENT ON THE SYMBOL MAP, which is worth knowing before relying on it. With a map
 // supplying an array's rank the accesses render as `gSym[0][i]`, a `var` base that
 // `l3/basecse.ts`'s `isHoistableBase` cannot see, so nothing re-creates the local this pass
-// deleted. WITHOUT a map (verified by running the row map-less) the same accesses spell as
-// `addr`, basecse sees the reuse, and it hoists a function-top `p0 = (u16 *)&gBgTilemapBufs` —
-// the same local, one level up. Three modules now answer "is this
-// address a local?" with independent policies (here: never; basecse: when reused 2+ times;
-// l3/scopebase.ts: at the innermost scope), and reconciling them is recorded debt.
+// deleted. WITHOUT one the same accesses spell as `addr`, basecse sees the reuse, and it hoists a
+// function-top `p0 = (u16 *)&gBgTilemapBufs` — the same local, one level up. Both arms are pinned
+// in `test/addr-placement.test.ts`; before that they rested on a run nobody could repeat.
+//
+// FOUR modules now answer "is this address a local?" with independent policies — here: never;
+// basecse: at the function top, when reused 2+ times; l3/scopebase.ts: at the innermost scope
+// holding the uses; l3/argbase.ts: immediately before a call whose arguments share it. Reconciling
+// them is recorded debt, and the same test pins the two places they actively disagree, because a
+// consolidation has to PICK rather than discover them: a `for`'s init (basecse reads it at loop
+// cadence and refuses, scopebase at the enclosing one and hoists) and a global name shadowed by a
+// local (scopebase must refuse — it re-spells the base as `&g` — while argbase may fire, because it
+// keeps the base expression verbatim).
 import { Block, Fn, Op, Value, mkOp, replaceAllUsesWith } from '../ir/core';
 
 /** Ops whose result depends on `attrs` alone — no operands, no memory, no control flow. */
-const NUMBERABLE = new Set(['gaddr']);
+const NUMBERABLE = new Set(['gaddr', 'laddr']); // laddr: same argument — operand-free, pure, attr-keyed
 
 /** The value-number key: the opcode plus every attribute, in a stable order. */
 function keyOf(op: Op): string {

package/src/raise/pre-recovery.ts

@@ -47,8 +47,10 @@ export const PRE_RECOVERY_PASSES: PreRecoveryPass[] = [
     // Numbering alone is not enough and not safe to ship alone: collapsing the duplicates leaves a
     // block param whose edges now all carry one value, and the structurer still destroys THAT into
     // a local (it only reuses a name a carrier already has, and an inlined `gaddr` has none).
-    // Measured: numbering without the phi cleanup made kleod:UpdateHUDCounterDisplay WORSE. So the
-    // pair is the atomic unit, expressed as a body rather than a sum of two unrelated counts.
+    // Numbering alone costs kleod:UpdateHUDCounterDisplay its match, so the pair is the atomic
+    // unit, expressed as a body rather than a sum of two unrelated counts. It is NOT monotone,
+    // which is worth knowing before tuning either half: dropping the cleanup IMPROVES
+    // kleod:ConfigureEntityBehavior and kleod:CountCollectedGems, neither of them near matching.
     run: (fn) => {
       const n = numberPureValues(fn);
       return n + simplifyTrivialPhis(fn);

package/src/raise/retsink.ts

@@ -68,10 +68,11 @@ export function sinkReturns(fn: Fn): boolean {
     //       i.e. BEFORE this one, so on `ifand`/`and3` shape (b) is the only one that ever fires.
     //
     //       The connective ALONE is not enough, and the extra requirement is BOTH arms being real
-    //       blocks (≥2 `br` preds). `return a || b` (synthetic:lor) also ends up as a `cond_br` on a
-    //       `logic_or`, but it is a value-merge: one edge runs from the head STRAIGHT into the merge,
-    //       so the merge has a single `br` pred. Sinking it replaces the merge variable that
-    //       byte-matches — measured, it cost that row its match. A two-armed diamond is what
+    //       blocks (≥2 `br` preds). `return a || b` (synthetic:lor:agbcc) also ends up as a
+    //       `cond_br` on a `logic_or`, but it is a value-merge: one edge runs from the head STRAIGHT
+    //       into the merge, so the merge has a single `br` pred. Sinking it replaces the merge
+    //       variable that byte-matches: dropping the `brPreds.length >= 2` half of this gate costs
+    //       that row its match. A two-armed diamond is what
     //       distinguishes `if (a && b) return X; return Y;` from every value-merge.
     //
     // A simple single-condition select is excluded by both arms of the gate for the same reason:

package/src/raise/shortcircuit.ts

@@ -319,11 +319,9 @@ export function recognizeBranchShortCircuit(fn: Fn): boolean {
         // ^g's body must be pure, and every value it defines must be consumed only by ^g itself —
         // see the REFUSALS note: an escaping or reused value becomes a statement hoisted out of the
         // short circuit.
-        // HOIST_UNSAFE_OPS, not EFFECTFUL_OPS: a live `opaque` is an instruction asmlift could not
-        // model, and moving it out of the arm that guards it is the reordering this refuses. Loud
-        // either way today (a decline under `onGap: 'strict'`, an ASMLIFT_ERROR marker under
-        // `annotate`, the CLI and benchmark default), so this closes a model gap rather than fixing
-        // an observed bug.
+        // HOIST_UNSAFE_OPS includes `opaque`: an instruction asmlift could not model, and moving it
+        // out of the arm that guards it is the reordering this refuses. Loud either way today — a
+        // decline under `onGap: 'strict'`, an ASMLIFT_ERROR marker under `annotate`.
         const body = g.ops.slice(0, -1);
         if (body.some((op) => HOIST_UNSAFE_OPS.has(op.opcode))) {
           continue;

package/src/raise/struct-arrays.ts

@@ -87,7 +87,8 @@ function withPadding(dataFields: StructField[], stride: number): StructField[] {
  *  rematerializes the same element address (several `add(base, i*stride)` ops for one logical
  *  array), and recovering them one-by-one would let the first claim the base and force its
  *  twins to decline — a mixed spelling that is worse than either pure form (found live on
- *  pokeemerald:GetGender, whose address is materialized twice). A base whose element pointers
+ *  pokeemerald:GetGenderFromSpeciesAndPersonality, whose address is materialized twice). A base
+ *  whose element pointers
  *  disagree on stride declines entirely: two strides over one base is a reinterpreted view or
  *  a 2D layout, genuinely ambiguous — decline over guess. */
 export function recognizeStructArrays(fn: Fn): number {

package/src/raise/structs.ts

@@ -178,6 +178,17 @@ export function recognizeStructs(fn: Fn): number {
     }
   }
 
+  // Which values are the address of a NAMED global (`gaddr`)? Consulted only when synthesis
+  // DECLINES: see the catch below.
+  const namedGlobal = new Set<Value>();
+  for (const b of fn.blocks) {
+    for (const op of b.ops as Op[]) {
+      if (op.opcode === 'gaddr') {
+        namedGlobal.add(op.results[0]);
+      }
+    }
+  }
+
   let count = 0;
   for (const base of order) {
     if (arrayBases.has(base)) {
@@ -186,11 +197,28 @@ export function recognizeStructs(fn: Fn): number {
     if (base.type.kind !== 'unknown') {
       continue;
     } // already typed (not a bare recovery target)
+
     const accesses = accessesOf.get(base)!;
     if (isArray(accesses)) {
       continue;
     } // uniform stride / single aligned access → array
-    base.type = T.ptr(buildStruct(`Struct${count}`, accesses));
+    try {
+      base.type = T.ptr(buildStruct(`Struct${count}`, accesses));
+    } catch (e) {
+      // A NAMED global whose accesses synthesis cannot reconcile is not a reason to decline the
+      // function: its declaration belongs to the project's own headers, and its constant-offset
+      // accesses render at L3 through the symbol context (member spelling when the map knows the
+      // layout, the honest cast spelling when it does not). The inhabitant is agbcc FUSING two
+      // adjacent u8 compares into one ldrh — `s.level == 8 && s.world == 6` reads offset 12 at
+      // widths 1 AND 2, which is not a union, just two spellings of declared bytes. An ANONYMOUS
+      // base (a loaded pointer, a parameter) has no other source of truth, so for it the decline
+      // stands exactly as before — this catch narrows nothing for the shapes that already worked,
+      // because a base synthesis succeeds on takes the same path it always took.
+      if (e instanceof RaiseUnsupportedError && namedGlobal.has(base)) {
+        continue;
+      }
+      throw e;
+    }
     count++;
   }
   return count;

package/src/rank.ts

@@ -12,6 +12,7 @@ import { cBackend } from './backend/c';
 import { assertDerefsTyped, assertResolved } from './contracts';
 import type { AsmData } from './frontend/asmdata';
 import { frontendFor } from './frontend/registry';
+import { globalCellOf } from './ir/alias';
 import { Fn, type Value, defOpMap } from './ir/core';
 import { T } from './ir/types';
 import { verify } from './ir/verify';
@@ -223,7 +224,7 @@ export function enumerateCandidates(
     [...opts.symbols.values()].some((infos) =>
       infos.some((i) => [...(i.layout ?? []), ...(i.pointee?.layout ?? [])].some((f) => f.bitWidth !== undefined)),
     );
-  const senseCands = mapHasBitfields
+  const bitfieldCands = mapHasBitfields
     ? [...baseSense, ...baseSense.map((s) => ({ ...s, suffix: `${s.suffix}/no-bitfield`, bitfields: false }))]
     : baseSense;
   // Probe: recover ONCE with no signedness pin, to learn which entry params are pointers/aggregates
@@ -239,6 +240,28 @@ export function enumerateCandidates(
   // Access facts for name-only symbol declarations (see bareGlobalAccessFacts) — derived once
   // from the probe: widths/offsets are lift-time facts, identical across every candidate.
   const accessFacts = opts.symbols ? bareGlobalAccessFacts(probe) : new Map<string, never>();
+  // `/reread-globals` — the VALUE-HOME axis (structure/analysis.ts AnalyzeOptions). Whether the
+  // source read a global once into a variable or re-read it at each use is not derivable from asm:
+  // the compiler CSEs the second spelling back into one load, and the round-5 dogfood watched agbcc
+  // land on both sides inside a single function (its highest-cost defect, 25 of 27 points on one
+  // klonoa function and 35/50 both ways on another). So both spellings are emitted and the differ
+  // referees — the same footing as signedness and branch sense, and never a default: the cached
+  // spelling stays the primary, so this can only ever ADD a winner.
+  //
+  // Gated on the function having a load that resolves to a named global at all — the only thing the
+  // axis can change. The dedup below collapses the pair wherever it changed nothing.
+  const probeDefs = defOpMap(probe);
+  const readsANamedGlobal = probe.blocks.some((b) =>
+    b.ops.some(
+      (op) => op.opcode === 'load' && globalCellOf(probeDefs, op.operands[0], op.attrs.off as number) !== null,
+    ),
+  );
+  const senseCands = readsANamedGlobal
+    ? [
+        ...bitfieldCands.map((s) => ({ ...s, reread: false })),
+        ...bitfieldCands.map((s) => ({ ...s, suffix: `${s.suffix}/reread-globals`, reread: true })),
+      ]
+    : bitfieldCands.map((s) => ({ ...s, reread: false }));
 
   const seen = new Set<string>();
   const out: Candidate[] = [];
@@ -273,9 +296,10 @@ export function enumerateCandidates(
             preserveDivergentBranchSense: s.sense,
             anchorConstCopies: s.anchor,
             spellBitfieldMembers: s.bitfields,
+            rereadGlobals: s.reread,
           });
         } catch (e) {
-          if (!s.anchor && s.bitfields) {
+          if (!s.anchor && s.bitfields && !s.reread) {
             throw e; // the base axes keep their behavior: a structuring failure aborts the row
           }
           // an anchored variant that fails structuring or its contracts is a dropped lever, never