Pkg7d/7e: the emitted compiler closure as a derived multi-crate workspace, built, with a dropped-dependency RED

[gunbai-bot]

Pkg7d/7e: the emitted compiler closure, rendered as a derived multi-crate workspace and built, with a dropped-dependency RED

Its stack has landed. #12171, #12190, #12200 and #12203 have all merged, and main is merged in, so the diff is now only the 7e change.

What it does

• The plan: v2.workflow.emitted_crate_workspace emitted_workspace_plan. It partitions the v2.compiler.compile closure into crate rows, from:

  • the live module DAG (emitted_closure_crate_partition);
  • the emission's own returned edges (gunbc.rust_emitted_edge, merged with the typed reverse-edge refusal);
  • the balanced policy at rust_crate_partition_declared_core_target;
  • each unit's transitive dependency packages (derived_dep_packages, the Derive the stage0 edge-list disagreement, and enrol the fold that keeps it honest #12035 derivation).

  Nothing is read from the stage0 debt rows. The runtime is a fixed foundation crate.

• Refusals, all typed:

  • The two closures (the live DAG and the emission) must be the same population. Any member of either missing from the other refuses ClosuresDisagree, naming every member.
  • A single-crate plan refuses NoDiscriminatingEdge.

• One renderer. v1.compiler.stage0_crates now renders any row set (partition_crate_boundary_emit_outcome_over). Its owner and dependency lookups read the set they are handed. The committed stage0 rows are one caller, and this workspace is another. There is no second manifest or lib.rs writer.

• One filename rule. module_to_filename / rust_module_emit_filename move to gunbc.rust_emitted_edge, the edge-endpoint authority. The emitter and the plan read the same function.

The instrument: gunbc test //gunbc/instruments:emitted-crate-workspace (parent condition 1)

• How it's wired. It's a registry row plus a producer arm (gunbc.instrument_targets, gunbc.target_binding EmittedCrateWorkspaceProducer, host cli_run::emitted_crate_workspace_host).
• What one invocation does:
  1. Emits the closure.
  2. Evaluates the plan with the emission's basenames and edges.
  3. Renders through the stage0 renderer.
  4. Builds the workspace (the positive control).
  5. Rewrites one crate with its RED rows and builds again.
• The receipt names the head, the closure module count, the crate count, whether the facade is the whole closure, the rustc identity, both verdicts, and the RED's attributed diagnostic.

Receipt, one remote dispatch, on the merged head 87b0cc9:

emitted 190 module files and 1632 edges
plan modules=189 crates=8 facade_is_whole_closure=false red=v2-emitted-policy-unit-3 drops v2-emitted-policy-unit-2 (v2_std_artifact -> v2_std_diagnostic)
GREEN Completed status=0 rustc=rustc 1.98.1 (48a229cea 2026-09-01) ... green_exit_status=0 green_warning_count=0
RED refused as required — error[E0432]: unresolved import `crate::v2_std_diagnostic`

The RED cannot be papered over by the facade (parent condition 2)

• How the dropped edge is chosen. It is a unit dependency in the transitive reduction: no other dependency of the source crate reaches the target, so no crate's pub use <dep>::* can re-export it by a second road. The emitter must also have written that edge as a real use-line, so rustc has a path that has to stop resolving.
• How the RED is judged. A red that fails without naming the dropped module refuses as RedNotAttributed, and a red that builds refuses as RedBuiltGreen. Neither counts as a pass.

What this build does not prove (parent conditions 3 and 4)

• Transitive facade. A layered crate re-exports its transitive dependency closure, which over-approximates the direct edges. That is deliberate: the inline crate::<module>:: paths the expression emitter writes are not returned as edges (gunbc.guarantee_stall emitted_inline_crate_path_edges_unreturned_stall). The facade did not degenerate to the whole closure (facade_is_whole_closure=false), so this is a partition, not one crate split into files. It is not a minimal public surface either.
• No grounded interface maps. The crates carry no grounded interface maps. Step 2 (the contents projection) waits on host-effect emission of v2.compiler.source_authority module_storage_bindings_for_source_roots, the capability the existing InterfaceGroundingCapability debt row already names, so no new row is added. A green therefore says the derived partition compiles through glob facades; it says nothing about per-crate interfaces.
• The instrument stays author-run; the plan's REDs are gated. The instrument (emission, the live-closure plan and two builds) is too heavy for the gate, so it runs by author invocation. The five fixture claims test.claim.emitted_crate_workspace_witness are a row of v2.workflow.required_floor required_gate_authored_modules (parent ruling). They run emitted_workspace_plan_over on a supplied three-module DAG and supplied edges, and never the live closure: RED selection, transitive re-exports, ClosuresDisagree and NoDiscriminatingEdge. Measured cost, from the required floor run at dd59430 ([enrolment-margin] lines, observed CPU against a 302 ms budget; every claim planned and passed):

claim	cpu
the_chain_plans_three_crates_plus_the_runtime_with_transitive_reexports	8 ms
the_red_drops_an_edge_the_emitter_wrote_as_a_use_line	8 ms
a_single_crate_plan_refuses_for_want_of_a_discriminating_edge	7 ms
a_dag_module_the_emission_did_not_produce_refuses_by_name	1 ms
an_emitted_module_outside_the_dag_refuses_by_name	1 ms

The floor log prints no eval-step count for a passing claim, so CPU is the measurement given. None of the five re-runs the real closure.

What the build found, each fixed at its root in its own PR

1. A qualified path's first segment is a namespace root: reference-derived edges no longer bind it to a same-named declaration #12190 (merged). A namespace root (v2 in v2.std.*) resolved as a bare reference to a test module's fn v2(). The live DAG had 24 modules the emission lacked.
2. Reference-derived edges skip substrate vocabulary: a kernel or container spelling binds no module #12200. A kernel spelling (String in std.primitives) resolved to std.string_type. That left one module still in disagreement.
3. The emitted-text attestation reads code outside string literals, not prose #12203. The emitter's use-line text gate was attested by string-literal prose and then by std::hash::Hash path segments. The result was a dead pub use crate::v2_std_node::{Hash}, a reverse edge the partition refused.
4. Pkg7d 1b: emitter use-line edges returned typed, admitted against the stage0 crate partition #12171 (amended). Edges came from use-lines taken before dedupe. That produced false edges for lines the file doesn't carry.

v1 admission. This is v2 self-host work under gunbc.v1_maintenance_standing v1_seed_standing. Hand Rust added:

• the instrument host file (cli_run/emitted_crate_workspace_host.rs: the effect boundary plus value transport; it decides nothing about the partition);
• one registry row and dispatch arm in target_invocation_host.rs.

The stage0_crates generalization is .dag, with regenerated mirrors; the seed regen is a fixed point.

🤖 Generated with Claude Code

[gunbai-bot]

Review 70840: fixed in the latest push. gunbc.emitted_crate_workspace_seed_growth declares the host as seed growth (DESIGN §7), and it's rostered in gunbc.seed_growth_admission. It lists all 17 hand-authored declarations in v1_compiler.cli_run.emitted_crate_workspace_host, plus the two in target_invocation_host. It states the reason: an effect boundary (the emission, file writes, git rev-parse for the receipt head, two cargo runs) plus the interpreter-value transport, with no partition decision. The owning lane is v1-hand-queue-drain. The trigger is at capability grain: host-effect emission making the instrument one .dag fold, the same capability gunbc.source_root_eval_driver_seed_growth names, so no value transport or hand effect sequencing remains. test.claim.seed_growth_admission_witness passes 7/7 with the row. That row is also the receipt the advisory asks for: a lane-plus-row deferral.

— sent from stern-lynx-90