@asmlift/core 0.10.0 → 0.11.0

package/src/rank-variations.ts

@@ -24,6 +24,7 @@ import {
   ORDERBASE_GATES,
   UNFOLDED_GATES,
 } from './l3/basecse';
+import { jumpToCaseEnds } from './l3/caseendgoto';
 import type { Gate } from './l3/gates';
 import type { HoistPlacement } from './l3/hoist';
 import { initFirstGuards } from './l3/initfirst';
@@ -55,7 +56,11 @@ import type { VariationName } from './variation-tokens';
  *  that setting's own lifted fn (a map-lifted shared lift spells const bases as gaddr, which would
  *  blind the /raw-globals siblings — the /addr-home lesson). `strip` opts the variation into the
  *  dropped-sibling closure: a candidate that applies it is skipped when its default sibling (the
- *  same setting without it) failed the boundary contracts. Which of these entries `structure()`'s
+ *  same setting without it) failed the boundary contracts. `offWitness` is the exact gate where
+ *  only the structuring itself knows whether the variation can change the tree: the OFF sibling
+ *  (the same setting without it, structured earlier in the same pass) runs with that hook, and a
+ *  setting whose OFF sibling never fired it is skipped, since it would build that sibling's tree
+ *  again. Which of these entries `structure()`'s
  *  `assertDefaultAccepts` guard does NOT reset — the ones that cannot unlock a function the default
  *  declines, and so carry a written argument in place of the guard — is stated ONCE, beside that
  *  guard in structure.ts, and derived from the guard's own reset list in
@@ -74,11 +79,15 @@ export interface StructureVariation {
     | 'signedCmp'
     | 'freshMerge'
     | 'copyDefPos'
-    | 'siteSense';
+    | 'siteSense'
+    | 'tailCopies'
+    | 'forContinue'
+    | 'caseGoto';
   name: VariationName;
   options: (on: boolean) => Parameters<typeof structureChecked>[1];
   sharedGate?: (sharedLift: Fn, defs: Map<Value, Op>) => boolean;
   perLiftGate?: (fn: Fn) => boolean;
+  offWitness?: 'onTailFallerKept' | 'onForOffered' | 'onCaseCopied';
   strip: boolean;
 }
 export const STRUCTURE_VARIATIONS: readonly StructureVariation[] = [
@@ -376,6 +385,80 @@ export const STRUCTURE_VARIATIONS: readonly StructureVariation[] = [
       ),
     strip: false,
   },
+  // `/tail-copies` — WHICH ARM KEEPS A CROSS-JUMPED TAIL (structure.ts `copyEveryTailEntrant`,
+  // switch-recover.ts `copySharedFallTargets`). A compiler that cross-jumps keeps one copy of the
+  // code two or more jump-table arms end in, so those arms all enter one sibling arm's body. The
+  // default writes the body back into every entrant but the one the arm-order policy puts directly
+  // above the sibling, which keeps its fall-through; this writes it into every entrant. Which arm
+  // the source wrote the tail under is not in the asm, and one compiler answers both ways at one
+  // set of flags: on KMC `-O2` and gcc 2.7.2 `-O1`, `synthetic:jt_xjcase` (case 1 written above
+  // case 2 and falling into it) recompiles only from the default, while the same arms written
+  // out of case order (`case 3`, `case 2`, `case 1`) are 24 objdump lines off from the default
+  // and 4 from this. So the differ referees it per row, like `/copy-defpos`.
+  //
+  // Gated EXACTLY, by its OFF sibling's structuring (`offWitness`): the two settings read
+  // different exits only where an entrant is left falling into a cross-jumped sibling
+  // (`copySharedFallTargets`' `onFallerKept`), so where the OFF sibling never left one the ON setting
+  // is not structured at all. No question of the raised fn answers that ahead of the pass: a block
+  // two arms reach is no sibling where it is the switch's merge (nearly every switch's post-switch
+  // code), and two entrants can reach their sibling through one shared cross-jumped block, so one
+  // in-edge. In the strip closure, and reset by `assertDefaultAccepts`: where the target language
+  // has no fall-through (Pascal) the default can still decline on the one fall-through it keeps,
+  // and copying every entrant would structure what the default refused.
+  {
+    flag: 'tailCopies',
+    name: 'tail-copies',
+    options: (on) => ({ copyEveryTailEntrant: on }),
+    offWitness: 'onTailFallerKept',
+    strip: true,
+  },
+  // `/for-continue` — A COUNTED LOOP AS `for` WHERE THE DEFAULT LIFTS IT AS `while (1)` (structure.ts
+  // `spellCountedLoopsFor`, `forPlanAt`). A loop whose latch steps one counter and tests it, entered
+  // through the same test, is one asm under both spellings, and the `for` is the one a jump-table arm
+  // inside it can `continue` and leave by `break;` after the switch. structure() reaches that `for`
+  // on its own only where every `while (1)` structuring declined (`ForRanking`); here it is ranked
+  // where the default lifts. Measured on agbcc, objdump instruction lines off the target, both lifts
+  // 0/20000 against the source in a host differential: a `for` whose five jump-table arms each
+  // `continue` or call and leave lifts as `while (1)` with the code after the loop copied into every
+  // arm at 54, and as the `for` at 27; two nested-loop probes go 81 → 68 and 55 → 44.
+  //
+  // Gated EXACTLY, by its OFF sibling's structuring (`offWitness`): only a `while (1)` loop that passes
+  // every one of `forPlanAt`'s checks can change, and the OFF sibling reports meeting one
+  // (`onForOffered`). In the strip closure, and reset by `assertDefaultAccepts`: a first run that
+  // spells every such loop `for` can structure a function the default (with its own reruns) refuses.
+  {
+    flag: 'forContinue',
+    name: 'for-continue',
+    options: (on) => ({ spellCountedLoopsFor: on }),
+    offWitness: 'onForOffered',
+    strip: true,
+  },
+  // `/case-goto` — TWO ARMS ENTERING ONE CASE'S BODY AS A `goto` TO ITS LABEL WHERE THE DEFAULT
+  // COPIES IT (structure.ts `jumpToSharedCases`, switch-recover.ts `jumpSharedFallTargets`). Where
+  // two or more jump-table arms enter one case arm's body, the default writes that body back into the
+  // entrants but one (`copySharedFallTargets`) and reads the goto only where every goto-free
+  // structuring of the function declines, in a switch none of them spelled goto-free
+  // (`JumpRanking`); this reads the goto first. The asm does not
+  // say which: a compiler that cross-jumps merges a source copy into the goto's bytes when the whole
+  // copy matches, and on agbcc it stops short where CSE has the arm re-use an address the copy
+  // re-forms, so the copy compiles to more code than the goto (`synthetic:sw_gotocase2`, case 1's copy
+  // re-reading `gE[i]`). The differ referees it per row, like `/tail-copies`, and a tie goes to the
+  // candidate without the goto (rank.ts `gotoCount`). It does not take `/tail-copies`' faller choice:
+  // the entrant directly above the case always falls, since a jump from it would land on the label
+  // right below it, a path its fall-through already spells — so `/tail-copies/case-goto` is no
+  // candidate of its own.
+  //
+  // Gated EXACTLY, by its OFF sibling's structuring (`offWitness`): the two settings read different
+  // exits only where the copies write a case arm's body into an entrant (`onCaseCopied`). In the
+  // strip closure, and reset by `assertDefaultAccepts`: read first, the jumps can leave a chain the
+  // copies after them structure where the default (copies, then jumps) declined.
+  {
+    flag: 'caseGoto',
+    name: 'case-goto',
+    options: (on) => ({ jumpToSharedCases: on }),
+    offWitness: 'onCaseCopied',
+    strip: true,
+  },
 ];
 
 /** The statement-order/shape members. */
@@ -467,8 +550,18 @@ export const STACKED_VARIATIONS = [...STACKED_SHAPES, ...STACKED_WIDTHS];
  *  `synthetic:ladidx1`, `synthetic:ladidx2`, `synthetic:revlad5s`. `bench regression` is an
  *  OUTCOME gate over all tiers, so every one of them turns it red — but `benchmark.yml` is
  *  `workflow_dispatch`, manual, with no cron, so nothing runs that gate on a PR. The scores and the
- *  method are in `apps/benchmark/dataset/synthetic.ts`'s `/unmerge` block. */
-export const PRE_RESPELL_VARIATIONS: typeof STACKED_VARIATIONS = [{ name: 'unmerge', apply: unmergeJoins }];
+ *  method are in `apps/benchmark/dataset/synthetic.ts`'s `/unmerge` block.
+ *
+ *  `/case-end-goto` (l3/caseendgoto.ts) is the second entry: a search loop's hit flag read where the
+ *  code after its loop ends the switch arm, rewritten as the case-end goto the source wrote. Here
+ *  rather than among the stacked members because the rest of the respell set must derive from the
+ *  goto tree (an `initfirst` or `sinkinit` over a tree that no longer declares the flag), and here
+ *  rather than as a structure variation for the cost l3/caseendgoto.ts's header gives. Each entry applies to
+ *  the structured tree on its own, so `/unmerge` and `/case-end-goto` never compose. */
+export const PRE_RESPELL_VARIATIONS: typeof STACKED_VARIATIONS = [
+  { name: 'unmerge', apply: unmergeJoins },
+  { name: 'case-end-goto', apply: jumpToCaseEnds },
+];
 
 /** Every subset of `xs`, the empty one first, each in `xs`' order. */
 const subsets = <X>(xs: readonly X[]): X[][] =>

package/src/rank.ts

@@ -20,7 +20,9 @@
 //                  names, and which of those names a declaration must refuse to claim.
 import { cBackend } from './backend/c';
 import {
+  assertCaseGotosNarrow,
   assertDerefsTyped,
+  assertEffectsPreserved,
   assertFrameUnionsViewed,
   assertLocalStorageStaysInteger,
   assertLocalsWritten,
@@ -30,6 +32,7 @@ import {
   assertResolved,
 } from './contracts';
 import type { AsmData } from './frontend/asmdata';
+import type { CalleeBodies } from './frontend/callee-body';
 import { hasSetupArgsNarrowing, narrowToSetupArgs, setupArgsDiscardsPassedResult } from './frontend/ssa';
 import { Fn, Value, defOpMap } from './ir/core';
 import { T } from './ir/types';
@@ -62,7 +65,15 @@ import { volatileValueLocals } from './l3/volatileval';
 import { volatileDeviceStores } from './l3/volstore';
 import { zeroSubNegates } from './l3/zerosub';
 import { RewritePattern } from './pattern/engine';
-import { applyIdiomPatterns, liftStamped, raiseRecovered, stampBehaviorsFor, structureChecked } from './pipeline';
+import {
+  applyIdiomPatterns,
+  liftStamped,
+  offsetNameBehaviorsFor,
+  raiseRecovered,
+  sourceLineCount,
+  structureChecked,
+  structureReturnTailReading,
+} from './pipeline';
 import { type FnProto, type Prototypes, declaresVoidReturn, prototypesFromSymbols } from './proto';
 import { type ContextGlobals, splitOwnContext } from './proto-context';
 import { inferGlobalArrays, orderLicensedGlobals, sameDerivedShape } from './raise/globalshape';
@@ -96,7 +107,13 @@ import {
   sameBases,
 } from './rank-variations';
 import { type Stillborn, stillbornVerdict } from './stillborn';
-import { DefaultAcceptsMemo, DefaultAcceptsMemoMisuse, hasDivergentSharedRet } from './structure/structure';
+import {
+  DefaultAcceptsMemo,
+  DefaultAcceptsMemoMisuse,
+  FOR_BOUND_GATES,
+  StructureError,
+  hasDivergentSharedRet,
+} from './structure/structure';
 import {
   type SymbolInfo,
   type SymbolMap,
@@ -170,6 +187,8 @@ export interface EnumerateOptions {
   contextGlobals?: ContextGlobals;
   /** same contract as DecompileOptions.ownContextProto */
   ownContextProto?: FnProto;
+  /** same contract as DecompileOptions.calleeBodies */
+  calleeBodies?: CalleeBodies;
   /** Called when a respell variation THROWS or fails a boundary contract, so the failure is visible
    *  instead of the candidate silently not existing. Enumeration continues either way — the default
    *  candidate is unaffected — but a variation that never fires because it always throws is a defect,
@@ -492,6 +511,27 @@ interface TreeSource {
   signedUnsignedCompare?: true;
 }
 
+/** Did `bound-plus-one-counter-wraps` CAUSE this structuring's decline? The rule fires from every
+ *  attempt `forPlanAt` makes, committed or not, and on loops the thrown refusal never reaches
+ *  (`synthetic:sw_gotocase_inner:ido7.1` fires it and declines on its switches' cases), so its firing
+ *  alone says nothing about the decline. The question is asked the one way that answers it: the
+ *  same structuring with that rule off. Where that one structures, the refusal was the rule's, and
+ *  the other pin, whose counter the rule admits, can take the loop; where it still throws, the
+ *  decline is the function's and the row aborts as any other default decline does. The tree the
+ *  ablated run builds is discarded — it is the `for` the rule refuses as wrong under this pin.
+ *  Not holding every pinnable decline instead: that would let the signed pin past any structure
+ *  refusal that reads a declared type, not only this one, and re-lift every declined row. */
+function declinesOnCounterSign(fn: Fn, opts: Parameters<typeof structureChecked>[1]): boolean {
+  try {
+    structureChecked(fn, opts, {
+      forBoundGates: FOR_BOUND_GATES.filter((g) => g.id !== 'bound-plus-one-counter-wraps'),
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /** Emit the DISTINCT type/branch-sense candidates for `name` — PURE, no scoring.
  *  It differs from `decompile()` in exactly two arguments to the shared spine — the signedness
  *  pin, injected between pre-recovery and recoverTypes via the `beforeRecover` hook, and the
@@ -515,6 +555,17 @@ export function enumerateCandidates(
   /** The last refusal from a backend asked to spell a tree — what the empty-enumeration check
    *  below reports, so "this backend can spell nothing here" names its reason. */
   let lastEmitError: unknown = null;
+  /** THE UNSIGNED PIN'S DECLINE, HELD FOR THE SIGNED ONE. The default candidate's structuring aborts
+   *  the row (`abortsRow`) on the premise that a structure refusal does not depend on the pin. One
+   *  does: `forPlanAt`'s `bound-plus-one-counter-wraps` reads the counter's declared type, so IDO's
+   *  counted loop (`synthetic:sw_gotocase2:ido7.1`) takes its `for` under the `s32` pin and not the
+   *  `u32` one, and without the `for` the switch's loop exit cannot be spelled at all. The decline is
+   *  held only where that rule CAUSED it (`declinesOnCounterSign`), and then the rest of the unsigned
+   *  pin is skipped: its other settings would run behind a declined default, which `abortsRow` exists
+   *  to forbid. The signed pin runs as it would have; a row that then produces no candidate declines
+   *  with the held error. Nothing the signed pin builds is new: it is the same pass, under its own
+   *  default setting and its own gates. */
+  let heldPinDecline: unknown = undefined;
   // Same merge as `decompile`: the project's DWARF signatures fill in what the caller did not
   // state, so both the annotate pass and the ranked candidates reason about one prototype table.
   const ownContext = splitOwnContext(opts.prototypes, name, opts.ownContextProto);
@@ -526,6 +577,7 @@ export function enumerateCandidates(
     // every candidate carries it, the whole row).
     spellSwitchFallthrough: backend.spellsSwitchFallthrough,
     spellSwitchBreak: backend.spellsSwitchBreak,
+    spellEarlyReturns: backend.spellsEarlyReturn,
     ...(opts.symbols ? { symbols: symbolsByName(opts.symbols) } : {}),
     ...(opts.contextGlobals ? { contextGlobals: opts.contextGlobals } : {}),
   };
@@ -663,7 +715,7 @@ export function enumerateCandidates(
     opts.asmData,
     opts.symbols,
     opts.contextGlobals,
-    undefined,
+    { calleeBodies: opts.calleeBodies },
     ownContext.ownContextProto,
   );
   // The ARRAY SHAPES the input assembly evidences (raise/globalshape.ts), for the DECLARATION
@@ -736,7 +788,7 @@ export function enumerateCandidates(
       opts.asmData,
       symbols,
       opts.contextGlobals,
-      undefined,
+      { calleeBodies: opts.calleeBodies },
       ownContext.ownContextProto,
     );
     applyIdiomPatterns(p, target, opts.patterns);
@@ -1164,6 +1216,7 @@ export function enumerateCandidates(
     // `assertEffectsPreserved` is the fourth and is NOT here: it needs the L1 `fn`, and
     // `respellTree`'s parameter list is the invariant the tree-dedup skip rests on (see its header).
     // Widening it for a contract is a defensible change and an argued one — not a silent import.
+    // The PRE-RESPELL loop below has `fn` in scope and no such invariant, so it runs it there.
     // A respell variation returns its tree, or `{ sfn, needsProof }` when it cannot establish its own
     // semantics from inside the pass (Candidate.matchOnly carries the argument).
     const respell = (variations: readonly Variation[], make: () => RespellResult, alreadyShaped = false): void => {
@@ -1184,6 +1237,7 @@ export function enumerateCandidates(
         assertNoOrphanedLocals(sfn, alt);
         assertLocalStorageStaysInteger(sfn, alt);
         assertFrameUnionsViewed(alt);
+        assertCaseGotosNarrow(alt);
         sources.push({
           variations,
           source: backend.emit(alt),
@@ -1236,6 +1290,7 @@ export function enumerateCandidates(
                 assertNoOrphanedLocals(alt, shaped.out);
                 assertLocalStorageStaysInteger(alt, shaped.out);
                 assertFrameUnionsViewed(shaped.out);
+                assertCaseGotosNarrow(shaped.out);
                 assertPlacementSurvives(alt, shaped.out, minted);
                 sources.push({
                   variations: [...variations, ...shaped.variations],
@@ -1982,7 +2037,7 @@ export function enumerateCandidates(
     // Read off the pin's OWN call, per symbol-map setting — the `/raw-globals` setting lifts without
     // the map and answers for itself, so no lift is governed by a fact measured on a different one.
     let pinnable = false;
-    for (const cand of SIGNEDNESS) {
+    pins: for (const cand of SIGNEDNESS) {
       if (cand.signed && !pinnable) {
         break;
       }
@@ -1999,6 +2054,7 @@ export function enumerateCandidates(
           onTailSlot: () => {
             tailSlot = true;
           },
+          calleeBodies: opts.calleeBodies,
         },
         ownContext.ownContextProto,
       );
@@ -2143,7 +2199,7 @@ export function enumerateCandidates(
                   opts.asmData,
                   symbolSetting.symbols,
                   opts.contextGlobals,
-                  { keepTailSlots: liftSetting.keepTailSlots },
+                  { keepTailSlots: liftSetting.keepTailSlots, calleeBodies: opts.calleeBodies },
                   ownContext.ownContextProto,
                 );
           if (liftSetting.narrow && !narrowToSetupArgs(fn)) {
@@ -2181,9 +2237,10 @@ export function enumerateCandidates(
           // …and the NAMES the map holds for the addresses this lift built by arithmetic off a
           // named one (raise/offsetnames.ts). Per lift setting, off that setting's own map: the
           // `/raw-globals` sibling has no map and so no name to reach. AFTER the two readings, and
-          // the staleness that leaves them is priced in pipeline.ts's copy of this note.
+          // the staleness that leaves them is priced in pipeline.ts's copy of this note, which also
+          // states the one-spelling-per-cell decline the pass throws from here.
           if (symbolSetting.symbols) {
-            OFFSET_NAME_PASS.run(fn, symbolSetting.symbols, stampBehaviorsFor(target, opts.contextGlobals));
+            OFFSET_NAME_PASS.run(fn, symbolSetting.symbols, offsetNameBehaviorsFor(target, opts.contextGlobals));
           }
           for (const [n, si] of [...inferredSymbols]) {
             if (baseOpts.symbols?.has(n) === true || !sameDerivedShape(declSymbols.get(n), si)) {
@@ -2229,6 +2286,33 @@ export function enumerateCandidates(
           reportThrow(settingVariations, e);
           continue;
         }
+        // THE OTHER RETURN-TAIL READING, `/ret-copy` or `/ret-join`, in its own `reading` pass
+        // between the follow and the sink. The default pass structures each setting both ways where
+        // the join past early returns took a join somewhere (`onJoinPastReturns`), and publishes one
+        // (pipeline.ts `structureReturnTailReading`). On a target that declares the join its default
+        // (`joinPastReturnsByDefault`: mwcc 2.4.2 and 2.3.3) it structures the join first
+        // and publishes the copies (`copyReturnTails`) only where they spell the function in fewer
+        // lines, the layout shows a cross-jumped return tail, or an early return keeps a
+        // branch-proven constant unfolded. On every other target it structures the copies first and publishes them, and the
+        // join only where the copies refuse. This pass
+        // enumerates the tree it did not publish, so neither reading is structured twice:
+        //   - `/ret-copy`, the copies, where the join was published. A chain of `if`s each holding
+        //     an early `return;` has no CFG join (`synthetic:retchain`), and where the early returns
+        //     cross-jump into one return tail the follow lands on that tail
+        //     (`synthetic:retchain_xj`); without the join both copy the code below every such `if`
+        //     into its arms, and a switch with a `case` that returns early likewise. The copies are
+        //     kept as a candidate because some rows' bytes are them (`synthetic:sw_fall:ido7.1`);
+        //   - `/ret-join`, the join, where the copies were published: the join copies a return tail
+        //     into each early return in its turn, and where that is the longer spelling it is kept
+        //     as a candidate beside the copies.
+        // A setting whose structuring never took the join has one reading, and pays no candidate.
+        // With both in the fan, the bound moves a ranked score nowhere: `compareScored` orders a
+        // score tie by goto, cast and line counts before enumeration order.
+        //
+        // The shared-tail passes below structure with the copies too: their follow and sink were
+        // ranked against the copies, their winners hold those trees, and crossing them with the join
+        // is a reading nothing has measured.
+        //
         // THE SHARED-TAIL VARIATIONS: the same raised fn, structured again with `followEarlyReturns`,
         // in two passes after the default one.
         //   - `/shared-ret` is the follow ALONE, on the fn as raised. Some divergent `if` shares a
@@ -2271,12 +2355,24 @@ export function enumerateCandidates(
         // `droppedDefault` is the DEFAULT pass's drops. Each shared-tail pass reads it and keeps its
         // own drops in a copy, so one pass's structuring failure never removes the other's candidate.
         const droppedDefault = new Set<string>();
+        // Per DEFAULT-pass setting whose structuring was a choice between the join past early
+        // returns and the return-tail copies (pipeline.ts `structureReturnTailReading`), the reading
+        // it did not publish: the only trees the `reading` pass enumerates, as `/ret-copy` where the
+        // join was published and `/ret-join` where the copies were.
+        const unpublishedDefault = new Map<string, { readonly reading: 'copies' | 'join'; readonly sfn: SFn }>();
+        // DEFAULT-pass settings whose copies were dropped (they declined or failed a boundary
+        // contract) or barred: the strip closure over them, as `dropped` is over whole settings, so
+        // `X/merge-names` never publishes or offers the copies where `X`'s copies failed.
+        const copiesDropped = new Set<string>();
         // What `assertDefaultAccepts` learned about this fn, shared by every setting structured from it.
         let acceptsMemo = new DefaultAcceptsMemo(fn);
-        for (const pass of ['default', 'follow', 'sink'] as const) {
+        for (const pass of ['default', 'follow', 'reading', 'sink'] as const) {
           if (pass === 'follow' && !hasDivergentSharedRet(fn)) {
             continue;
           }
+          if (pass === 'reading' && unpublishedDefault.size === 0) {
+            continue;
+          }
           if (pass === 'sink') {
             let sunk: boolean;
             try {
@@ -2310,6 +2406,8 @@ export function enumerateCandidates(
           const settingsForLift = usableStructureSettings.filter((s) =>
             offForThisLift.every((variation) => !s[variation.flag]),
           );
+          // Per setting key structured in THIS pass, the `offWitness` hooks its structuring fired.
+          const witnessed = new Map<string, Set<NonNullable<StructureVariation['offWitness']>>>();
           // `/merge-names` combinations whose un-merged sibling was DROPPED. `structure()` already
           // refuses to let the variation unlock a function the default declines, but it can only see its own
           // refusals — a boundary contract fails out here, in `structureChecked`. Without this a
@@ -2326,14 +2424,50 @@ export function enumerateCandidates(
             if (alternative && droppedDefault.has(key)) {
               continue;
             }
-            if (
+            // THE OTHER RETURN-TAIL READING: the tree the default pass structured and did not publish,
+            // enumerated as it is. It is the same setting's, so the witness and the strip closure
+            // below already answered for it there.
+            const otherReading = pass === 'reading' ? unpublishedDefault.get(key) : undefined;
+            if (pass === 'reading' && otherReading === undefined) {
+              continue;
+            }
+            const settingLiftVariations: readonly Variation[] =
+              otherReading === undefined
+                ? liftVariations
+                : [...liftSetting.variations, otherReading.reading === 'copies' ? 'ret-copy' : 'ret-join'];
+            // THE OFF-SIBLING WITNESS (`StructureVariation.offWitness`): a setting whose variation's
+            // OFF sibling structured without firing the witness would rebuild that sibling's tree, so
+            // it is skipped and reported as the tree dedup it is. A sibling not structured in this
+            // pass (dropped, or skipped above) witnessed nothing, and the setting is structured.
+            //
+            // A setting skipped HERE builds its sibling's structuring, so it fires the hooks the
+            // sibling fired, and it is recorded with the sibling's set. Without that the gate does
+            // not compose: a setting carrying two witnessed variations (`tail-copies/for-continue`)
+            // finds each sibling unrecorded and is structured however inert both are. A setting
+            // skipped here in the default pass has no reading of its own in the `reading` pass:
+            // the sibling's fired set is the union of both its readings' (`structureReturnTailReading`),
+            // so both of this setting's readings are the sibling's trees, which the sibling enumerates.
+            const sameAs = STRUCTURE_VARIATIONS.flatMap((variation) => {
+              if (otherReading !== undefined || variation.offWitness === undefined || !s[variation.flag]) {
+                return [];
+              }
+              const sibling = s.variations.filter((v) => v !== variation.name).join('/');
+              const seen = witnessed.get(sibling);
+              return seen !== undefined && !seen.has(variation.offWitness) ? [seen] : [];
+            });
+            if (sameAs.length > 0) {
+              witnessed.set(key, sameAs[0]);
+              opts.onTreeDeduped?.();
+              continue;
+            }
+            const stripped = (set: ReadonlySet<string>): boolean =>
               STRUCTURE_VARIATIONS.some(
                 (variation) =>
                   variation.strip &&
                   s[variation.flag] &&
-                  dropped.has(s.variations.filter((v) => v !== variation.name).join('/')),
-              )
-            ) {
+                  set.has(s.variations.filter((v) => v !== variation.name).join('/')),
+              );
+            if (otherReading === undefined && stripped(dropped)) {
               // A SKIPPED setting is recorded exactly like a dropped one, or the closure would not be
               // transitive: with plain X dropped and X/inplace skipped-but-unrecorded,
               // X/inplace/merge-names would find neither stripped key and run — shipping a
@@ -2345,36 +2479,97 @@ export function enumerateCandidates(
             // which it re-derives from its map on every call, so both branch senses structure the same
             // recovered function without re-lifting.
             let sfn: SFn;
+            const fired = new Set<NonNullable<StructureVariation['offWitness']>>();
+            const witnessHooks = Object.fromEntries(
+              STRUCTURE_VARIATIONS.flatMap((variation) =>
+                variation.offWitness !== undefined && !s[variation.flag]
+                  ? [[variation.offWitness, () => fired.add(variation.offWitness!)]]
+                  : [],
+              ),
+            );
+            let counterSignRefused = false;
+            const structOpts = {
+              ...symbolSettingOpts,
+              ...(inferredSymbols.size ? { inferredSymbols } : {}),
+              ...(orderLicensed.size ? { orderLicensedGlobals: orderLicensed } : {}),
+              preserveDivergentBranchSense: s.sense,
+              negateJoinedBranchSense: s.join ? !defSense : defSense,
+              ...(s.flipSites ? { branchSenseFlipSites: s.flipSites } : {}),
+              anchorConstCopies: s.anchor,
+              anchorLoopEntryConsts: s.entry,
+              spellBitfieldMembers: s.bitfields,
+              spellPtrMemberElements: s.ptrElems,
+              spellDeclaredSubscripts: s.declRank,
+              ...STRUCTURE_VARIATIONS.reduce(
+                (acc, variation) => ({ ...acc, ...variation.options(s[variation.flag]) }),
+                {},
+              ),
+              ...(alternative ? { followEarlyReturns: true, copyReturnTails: true } : {}),
+            };
+            const hooks = {
+              ...witnessHooks,
+              onCounterSignRefused: () => {
+                counterSignRefused = true;
+              },
+            };
             try {
-              sfn = structureChecked(
-                fn,
-                {
-                  ...symbolSettingOpts,
-                  ...(inferredSymbols.size ? { inferredSymbols } : {}),
-                  ...(orderLicensed.size ? { orderLicensedGlobals: orderLicensed } : {}),
-                  preserveDivergentBranchSense: s.sense,
-                  negateJoinedBranchSense: s.join ? !defSense : defSense,
-                  ...(s.flipSites ? { branchSenseFlipSites: s.flipSites } : {}),
-                  anchorConstCopies: s.anchor,
-                  anchorLoopEntryConsts: s.entry,
-                  spellBitfieldMembers: s.bitfields,
-                  spellPtrMemberElements: s.ptrElems,
-                  spellDeclaredSubscripts: s.declRank,
-                  ...STRUCTURE_VARIATIONS.reduce(
-                    (acc, variation) => ({ ...acc, ...variation.options(s[variation.flag]) }),
-                    {},
-                  ),
-                  ...(alternative ? { followEarlyReturns: true } : {}),
-                },
-                undefined,
-                acceptsMemo,
-              );
+              if (otherReading !== undefined) {
+                sfn = otherReading.sfn;
+              } else if (pass === 'default') {
+                // THE RETURN-TAIL READING, bounded by size and read off the layout (pipeline.ts
+                // `structureReturnTailReading`): on a target that declares the join past early
+                // returns its default, the join, or the copies where they spell this setting's
+                // function shorter or the asm layout or an unfolded return marks them; on every other
+                // target the copies, structured first, and the join only where they refuse, with
+                // their refusal reported under `ret-copy` (the reading the fan then cannot hold). A
+                // setting fails only where both refuse, and that failure is handled below as any
+                // structuring failure. The losing tree is kept for the `reading` pass, so neither
+                // reading is structured twice.
+                const copiesBarred = stripped(copiesDropped);
+                const read = structureReturnTailReading(
+                  fn,
+                  { ...structOpts, joinPastReturns: copiesBarred },
+                  (t) => backend.emit(t),
+                  hooks,
+                  acceptsMemo,
+                );
+                sfn = read.sfn;
+                if (read.unpublished === undefined) {
+                  if (copiesBarred) {
+                    copiesDropped.add(key);
+                  }
+                } else if ('error' in read.unpublished) {
+                  copiesDropped.add(key);
+                  reportThrow(
+                    [...liftVariations, 'ret-copy', ...s.variations, ...symbolSetting.variations],
+                    read.unpublished.error,
+                  );
+                } else {
+                  unpublishedDefault.set(key, read.unpublished);
+                }
+                witnessed.set(key, fired);
+              } else {
+                sfn = structureChecked(fn, structOpts, hooks, acceptsMemo);
+                witnessed.set(key, fired);
+              }
             } catch (e) {
               if (e instanceof DefaultAcceptsMemoMisuse) {
                 throw e; // a memo wired to the wrong fn is a defect here, never a dropped variation
               }
               if (abortsRow([...liftVariations, ...symbolSetting.variations], s)) {
-                throw e; // the default lift's default setting keeps its behavior: a failure aborts the row
+                if (!(
+                  counterSignRefused &&
+                  !cand.signed &&
+                  pinnable &&
+                  e instanceof StructureError &&
+                  declinesOnCounterSign(fn, structOpts)
+                )) {
+                  throw e; // the default lift's default setting keeps its behavior: a failure aborts the row
+                }
+                // THE UNSIGNED PIN'S DECLINE, HELD FOR THE SIGNED ONE — and the rest of the unsigned
+                // pin is not built: every other setting of it would run behind a declined default.
+                heldPinDecline ??= e;
+                continue pins;
               }
               // Recorded for EVERY dropped setting: a candidate with more variations on looks its siblings
               // up by stripping one variation at a time, and the stripped key can itself carry the other.
@@ -2425,7 +2620,13 @@ export function enumerateCandidates(
             // The PRE-RESPELL variations (PRE_RESPELL_VARIATIONS, the last composition the POLICY note
             // names): rewrite the TREE, then run the whole respell set over the result, so every
             // respell variation derives from the rewrite instead of composing onto it. The gate is the pass's
-            // own decline; the contracts are `respell`'s three, for `respell`'s reasons.
+            // own decline; the contracts are `respell`'s, for `respell`'s reasons, plus the effect count
+            // `respell` cannot run (its note above): a pre-respell rewrite moves control, not just
+            // spelling — `/unmerge` copies a join into its arms, `/case-end-goto` jumps over the code
+            // between a loop and its arm's end — and the per-path count is what refuses a rewrite that
+            // runs a call twice on one path or drops one. It is also the only production reader of
+            // that count's case-end-goto paths (contracts.ts `PathCounts.end`): structuring never
+            // writes the goto, so without it those paths are read by unit tests alone.
             for (const pf of PRE_RESPELL_VARIATIONS) {
               try {
                 const made = pf.apply(sfn);
@@ -2450,6 +2651,7 @@ export function enumerateCandidates(
                 assertNoOrphanedLocals(sfn, made);
                 assertLocalStorageStaysInteger(sfn, made);
                 assertFrameUnionsViewed(made);
+                assertEffectsPreserved(fn, made);
                 // A backend refusal on this REWRITTEN tree is not a refusal of the row's own
                 // tree, so it never becomes the row's stated cause: `TreeSources.emit` is dropped
                 // here and only the call over the row's own tree above records one.
@@ -2525,7 +2727,7 @@ export function enumerateCandidates(
               }
               const variations: readonly Variation[] = [
                 cand.variation,
-                ...liftVariations,
+                ...settingLiftVariations,
                 ...s.variations,
                 ...sp.variations,
                 ...symbolSetting.variations,
@@ -2559,6 +2761,9 @@ export function enumerateCandidates(
   // Every tree the fan produced was refused by the backend. Each refusal on its own is a dropped
   // candidate; all of them together is the row, and it stays LOUD — the alternative is a caller
   // ranking an empty list and reporting no match for a function nothing ever tried to spell.
+  if (out.length === 0 && heldPinDecline !== undefined) {
+    throw heldPinDecline;
+  }
   if (out.length === 0) {
     throw new NoSpellableCandidateError(
       `no spellable candidate for '${name}': ${firstLine(lastEmitError ?? 'no candidate produced')}`,
@@ -2748,18 +2953,28 @@ export function compareScored<S extends { score: number }>(
     a.preference - b.preference ||
     (b.deviceVolatile ?? 0) - (a.deviceVolatile ?? 0) ||
     (a.farStoreCast ? 1 : 0) - (b.farStoreCast ? 1 : 0) ||
+    gotoCount(a.source) - gotoCount(b.source) ||
     castCount(a.source) - castCount(b.source) ||
     lineCount(a.source) - lineCount(b.source) ||
     a.order - b.order
   );
 }
 
-/** Non-blank lines in a candidate's rendered source — the compactness tie-break above, counted
- *  exactly as `quality.ts` counts `lines`. Deterministic, and total on any string. */
-function lineCount(source: string): number {
-  return source.split('\n').filter((l) => l.trim().length > 0).length;
+/** `goto` statements in a candidate's rendered source — the readability tie-break above, asked
+ *  before the casts. Each goto asmlift writes (l3/ast.ts: a jump to a case label of the switch it
+ *  sits in, or to the `break;` that ends its arm) is a ranked spelling against a goto-free one —
+ *  copies (`/case-goto`) or a flag (`/case-end-goto`) — and where the two score alike the goto-free
+ *  one is published: a goto is the narrow exception the differ has to earn, never a tie's winner.
+ *  Deterministic, and total on any string. */
+export function gotoCount(source: string): number {
+  return source.match(/\bgoto [A-Za-z_]\w*;/g)?.length ?? 0;
 }
 
+/** Non-blank lines in a candidate's rendered source — the compactness tie-break above, counted
+ *  exactly as `quality.ts` counts `lines`, and the one count the default's return-tail reading is
+ *  bounded by (pipeline.ts `sourceLineCount`). Deterministic, and total on any string. */
+const lineCount = sourceLineCount;
+
 /** Scalar casts in a candidate's rendered source — the readability tie-break above.
  *
  *  A WITHIN-PREFERENCE tie-break over two spellings of ONE function, and deliberately NARROWER than