Fixture-callable emitted-crate compilation: a witness route that reaches rustc over an emitted fixture closure

[gunbai-bot]

What was missing

A witness can already compile an in-memory .dag source and assert on the emitted text — compile_dag_rust_emit_check, substring includes and excludes. That is a spelling oracle. A meaning-level emitter defect — a host representation emitted where a structural carrier was declared, a dropped type argument, a reference emitted past its resolved binding — is invisible to it whenever the wrong bytes still contain the right substring, and it is exactly what rustc's type checker refuses.

v1_compiler.emitted_closure_compile_host does reach rustc, but its only entry point takes a rostered .dag entry path, so no fixture-authorable subject could be posed to it at all. Fixture-authorable subjects with no compiler behind them on one side; a real compiler with no fixture-authorable subjects on the other.

What landed

fixture_closure_rustc_verdict(source, probe_root) — the same in-memory .dag source shape compile_dag_rust_emit_check takes, emitted through the same compile_sources, written by the same crate writer (write_probe_crate_files, factored out of write_probe_crate) and handed to the same run_cargo. Sharing those three is the design: a separately authored fixture harness would make a green here and a green in the required phase two facts about two crates.

• FixtureClosureOutcome keeps gunbc's own refusal (SourceRefused) separate from a rustc verdict — collapsing them would report a fixture the compiler rejected as "rustc refused the emitted bytes".
• run_cargo's probe-line scan takes the caller's attribution symbol, threaded through all three existing call sites. The required phase attributes its own injected fault; the fixture route attributes the fixture's own emitted module.
• fixture_closure_reached_rustc is the fail-closed predicate: true only for a cargo run that completed and reported its own exit status. A red counts as reached; SourceRefused, CrateNotWritten, NotAttempted and DidNotComplete do not.
• Each arm reports its own diagnostic, not a Bool — a two-arm emitter discriminator separates its arms by what rustc said.

Executed, both directions

fixture-closure: control Measured files=6  cargo=Completed status=0
fixture-closure: red     Measured files=17 cargo=Completed status=101
   13 |     v1_rt::concat("x".to_string(), "y".to_string())
      = note: expected struct `Rc<im::Vector<i64>>`
                 found struct `std::string::String`
fixture-closure: red attribution --> src/fixture_closure_rustc_text_nonliteral_probe.rs:13:5
fixture-closure: pair PASSED

E0308, attributed to the fixture's own emitted module: the structural carrier against the host String. gunbc.rung_drop text_boundary_identity_wall's emitted-Rust half now has an executing probe instead of a sentence.

Where it executes — the honest grain

The route is #[cfg(test)] pub(crate) behind its own use, deliberately not in the production re-export (that would be PublicSurfaceGrowth on a seed frozen for growth). Its one consumer is fixture_closure_rustc_discrimination, authored in v1.compiler.compiler_tests_rust and emitted into compiler_tests.rs through the seed's own generator.

It is #[ignore]d. It is therefore ENROLLED AND AVAILABLE via cargo test --release -p v1-compiler --lib fixture_closure_rustc_discrimination -- --ignored, and does not execute by default on push or PR. rust-unit-tests is additionally not a needs of the required aggregate, so even un-ignored a red there would be visible and would not block through the required context.

So: candidate evidence, reviewable on demand, no wall. An #[ignore] is a cost decision and not a rung. It discharges no next-rung trigger naming this capability — the capability exists, the evidence does not execute.

Two claims this PR previously made that were FALSE

Recorded rather than silently edited, because a receipt that quietly changes what it certifies is worse than one that was wrong once.

1. "A cargo-test-hosted consumer deadlocks on the outer cargo lock." Never measured — inferred from a 30-minute run that produced no output and was terminated. Measured properly: elapsed=215s status=Some(0) blocking_line=None. It completes. The silence was an ordinary rebuild (an inner cargo build --release from an outer cargo test --release does not share fingerprints). A gunbc.recurring_failure_mode row filed on that specimen has been deleted, not amended — per unbacked_execution_claim's own arms, a never-backed assertion has no past to record.
2. Two claim_executor CLI modes (--fixture-closure-compile, --fixture-closure-pair) and a --required-emit-compile conjunct. Withdrawn under the approval's test-facing-visibility condition. The prose describing them survived the code by one revision and was caught by review 58151; the citations now name the consumer that exists.

v1 growth, admitted under the PURPOSE test

Hand-Rust declarations added to a seed frozen for growth, admitted by the owning manager under gunbc.v1_maintenance_standing v1_seed_standing / DESIGN §3's PURPOSE test: it makes emitter meaning-level discriminators executable at all. It adds no new host cause — same crate writer, same run_cargo, same compile_sources. Every declaration is enumerated in gunbc.emitted_closure_compile_seed_growth; census re-derived at 75 declarations / 75 rows, zero stale, zero unaccounted.

The dissolution trigger is not minted here

It is the one that carrier already carries, quoted verbatim:

Delete this host when the phase's two host effects are modeled and a modeled actuator can perform them: writing an emitted file set to a directory, and invoking cargo over a manifest with a typed outcome. ... what is missing is the ACTUATION -- a modeled operation the required run can execute without the hermetic envelope refusing it.

The substrate-native form of this capability does not exist yet, and that is the more important half of this change. What lands here is the host form, dissolving on that trigger and no other.

Why not a .dag host builtin

Refused for a stronger reason than v1 growth: the required floor's hermetic envelope refuses host effects, and a witness reaching the live tree is DeclinedLiveTree. A builtin would buy a surface that cannot execute where witnesses execute.

Constraints held

No edit to v1_compiler_emit_rust or v1_compiler_infer_emit_info. No row added to required_emit_compile_entries. No new CLI flag, no RequiredCiPhase variant, no workflow change, no production re-export.

[gunbai-bot]

Review 58161's finding on fixtures/fixture_closure_rustc/text_nonliteral_probe.dag:3 — measured, and the import stays. Landed in 5b01992 as an annotation rather than a deletion.

The read is the natural one: the binding is never mentioned again, and the red is concat("x","y") at the return boundary. But v1_compiler.cli_run resolve_virtual_source_with_imports builds this fixture's source set only by following import statements transitively, so the import is the single mechanism that puts v2.std.text into the resolved closure. Running the route on the fixture with the import stripped:

WITHOUT IMPORT => SourceRefused hard=1
  UnresolvedType { name: "v2.std.text.String" } | reached_rustc=false

Deleting it does not tidy the fixture — it converts the red arm from a rustc verdict into a gunbc refusal and destroys the discrimination, while looking like cleanup.

Two things worth noting for the record. The wall holds if someone does it anyway: fixture_closure_reached_rustc (the fail-closed predicate from review 58120) refuses to count an arm that never reached rustc, so the pair goes red rather than passing on a refusal — the earlier repair catching exactly this. And the fixture now carries the reason and the measurement, because an apparently-unused import that is structurally load-bearing will draw the same finding from the next reader.

— sent from proud-moth-614

[briansrls]

APPROVE at exact head 7be507bf28cfc4bff3186d5c9a82dc3be2050dc0.

The fixture route satisfies the bounded v1 PURPOSE ruling: it reuses compile_sources, the existing crate writer, run_cargo, and CargoVerdict; keeps gunbc refusal, write failure, incomplete execution, and completed cargo outcomes distinct; is #[cfg(test)] pub(crate) with no CLI mode, required-phase row, workflow edit, or production re-export; and carries the exact seed-growth census. Exact-head CI is green.

The ignored consumer is accepted at its stated grain: callable candidate evidence, not default execution, not a merge gate, and not satisfaction of any trigger requiring unconditional execution on an acceptance path. The existing host deletion trigger remains controlling.