Two emitter walls: the grounded shared carrier is wrapped once, and an unrecognised pipeline driver refuses

[gunbai-bot]

Two independent emitter defects, both found by compiling the required-v2-native lane's closure, both fixed at the emitter rather than worked around in the corpus. Split out of the route change (#10940) because main needs them regardless of it.

1. A closed coproduct read as a default arm — a silent wrong answer

std.compiler_entry declares exactly three drivers. emit_main_rs asked is_retained_host, then is_source_root_eval, and then returned the direct-ingest main unconditionally — so the third arm was not a variant match but the residue of two string comparisons over a name read back off the declaration's source span.

Observed: emitting src/v2/compiler/00_compile.dag — whose declaration reads = SourceRootEvalDriver — at a 404-module import closure rendered the direct-ingest main, a 25-line translator, while the same emission rendered compiler_pipeline_entry() -> CompilerEntryDriver::SourceRootEvalDriver into the same crate. Zero diagnostics of any severity. Bisected: the identical entry renders the eval-driver main at 173 and 177 modules and the direct-ingest main at 404.

That is silent wrongness, which DESIGN §5 puts outside the ladder. The partition is now closed by name (compiler_pipeline_entry_driver_is_known) and an unrecognised reading refuses with a located compile_error naming the module and the reading it got. Rostered as gunbc.recurring_failure_mode.closed_variant_partition_read_as_a_default_arm, with the bisect, the attainable ceiling (match the resolved variant, not a string read off the span) and its next-rung trigger.

The closure split that made the symptom go away is not the fix, and the row says so.

2. The grounded shared carrier, wrapped twice

Empty {} for a seed-host container emits the grounded shared value (emit_freemonoid_empty_rc_value, Rc::new(vec![])). The two record-literal sites then applied the sharing constructor again because the carrier's parent enum is a shared type, so Cons { head: x, tail: Empty {} } rendered (*Rc::new(Rc::new(vec![]))).clone() — rustc refuses with Rc<Vector<T>> where Vector<T> was expected.

43 of the required-v2-native emitted closure's 152 rustc errors were this one shape, every one a roster data row in v2.workflow.floor_expected_red / v2.workflow.floor_route_gap — the admission's own rosters.

The guard tests equality with the producer's own value rather than sniffing the rendered text: one authority produces that string, so "is this expression that value" is decidable, and a second grounded pre-shared arm would need its own row rather than widening this one.

Evidence

fixtures/grounded_shared_carrier/probe.dag + src/v1/tests/src/grounded_shared_carrier_wrap_test.rs: emits the probe through compile_entry_emission (the same entry path the lane uses) and asserts the single share, with the pre-fix double-wrap shape as the named red control.

• with the wall: test result: ok. 1 passed
• with the wall removed from the mirror and the seed rebuilt: FAILED, panicking on Cons must deref the carrier the grounded empty already shares

Where this executes, stated rather than assumed: no CI step runs a Rust unit test today (gunbc.rung_drop rust_unit_tests_off_the_merge_path). The clippy --all-targets step compiles this target; the executing evidence on a required lane is the required-v2-native job's own cargo build of the emitted closure, which refused before these walls and compiles after them — that lane change lands in #10940 on top of this.

The fixture lives under the repo-root fixtures/ tree, beside the native lane's malformed specimen: regen seeds every .dag under src/v1 into the stage0 emitted surface (it refused a probe there by name), and floor discovery walks dag/ and src/v2.

🤖 Generated with Claude Code

[gunbai-bot]

Addressed in 0ec1949 — the finding held, and chasing it produced a better result than the review asked for.

The RED is authorable at 17 modules, not only at 404. fixtures/unknown_pipeline_driver/probe.dag declares

data compiler_pipeline_entry: CompilerEntryDriver = std.compiler_entry.SourceRootEvalDriver

— an ordinary accepted program, spelled with its declaring module's qualifier, which resolves to the variant it names and which the arm selection (reading the authored name off the source span) cannot match by bare name. Measured both ways on that fixture:

• seed without the wall: emits the direct-ingest main (compile_dag_source_to_target_text, the translator arm), zero diagnostics of any severity
• seed with the wall: compile_error!("REFUSED: … declares a driver this emitter does not recognise (read as [std.compiler_entry.SourceRootEvalDriver]) …")

src/v1/tests/src/unknown_pipeline_driver_refusal_test.rs asserts the refusal and names the reading, with the pre-fix direct-ingest shape as the named red control. Both wall tests: test result: ok. 2 passed; 0 failed.

Two other fixture shapes were ruled out by measurement rather than assumption, which is what §4b asks before claiming a check's red is unauthorable: an undeclared driver name (= NotAModelledDriver) refuses at resolve with undefined variable, never reaching emission; and a second CompilerEntryDriver-annotated row trips the ambiguity arm first. The qualified spelling is the smallest shape that reaches the selection.

The failure-mode row is corrected, not merely extended. The cheap reproducer is now the subject — "any reading the span-read cannot match by bare name selects the residue arm, and a qualified spelling is the smallest such reading" — with the 404-module emission kept as the instance that surfaced the class and as the one showing the damage in production shape (emitted value and emitted entry point disagreeing inside one artifact). The rung sentence now says mitigation with executed evidence, naming the test, rather than claiming a rung nothing established.

One correction to my own earlier text while I was here: the harness refusal I was chasing turned out to be an invalid \' escape in the roster file itself, not in the fixture — fixed in the same commit.

— sent from deep-swift-530

[gunbai-bot]

Fixed in 919c528 — the finding was correct and the obligation is the authority's, not a preference.

The class home already existed, so this appends an occurrence receipt to dag/gunbc/recurring_failure_mode/accepted_source_emits_uncompilable_target.dag rather than minting a second class for one fact (that would be the §3 fork the ledger exists to avoid):

• invalid state: an emitted expression carrying one more sharing layer than its type
• harm, measured: 43 of the 152 rustc errors in the v2-native route's emitted closure were this one shape, every one a roster data row in v2.workflow.floor_expected_red / floor_route_gap — the admission's own rosters, so the route could not compile the authority that judges it
• what distinguishes it from that file's existing components: those are about which names the emitted program spells; this is about how many times one value is wrapped, and it is invisible to every name-level check because every name in the expression is correct. It also stayed latent exactly as the std.string_type component there records — accepted for as long as nobody emitted a corpus containing such a row
• rung found at: mitigatable (the crate failed loudly at cargo). Rung now: mechanically preventable, with the executing evidence named
• ceiling and why it is higher: you identified it exactly — the guard recovers a structural fact (this child already rendered the shared carrier) by comparing rendered target text, so it is decidable but string-keyed
• next-rung trigger, naming the capability rather than an artifact: the emitter carries sharing as a property of the rendered expression rather than of the type alone, sufficient that no site can wrap an already-shared value however many grounded producers exist

The in-file annotation at rust_expr_is_grounded_shared_value now cites that row and states it is below ceiling, instead of conceding the residue in place with nowhere to count it.

— sent from deep-swift-530

[gunbai-bot]

srv2 closure receipt for #10990 at head 254f5c9 (overlay on main 7086eb4; instrument closure_pr.sh, pinned producer claim_executor_pinned built from the overlay, route --v2-native-route --source-root dag --source-root src/v2).

Regressed files vs the main baseline (closure_main.sh at 199aee7): none.

• Emitted closure: 172 files, digest c17ed878e348… — identical to main's.
• Emitted compiler binary sha256 222baf0b1d78057b — byte-identical to main's. This PR changes the seed emitter (src/v1/05_emit_rust.dag and its stage0 mirrors), so the seed producer differs, but the compiler it emits from src/v2/compiler/00_compile.dag does not.
• Closure root 167 modules; native fold EXIT=0, _terminal: complete, wall 313 s, rss 1.23 GB.
• After-set: 29 file refusals (28 parse_g0_tokens_remain, 1 normalize_reason_post_normalize_not_well_formed on src/v2/std/runtime.dag), joined by path against the baseline's 29: 0 new, 0 cleared.

Receipt-neutral by execution; nothing blocks landing on the closure side.