diff --git a/dag/gunbc/emitted_crate_workspace_seed_growth.dag b/dag/gunbc/emitted_crate_workspace_seed_growth.dag
new file mode 100644
index 00000000000..a75a1ca7a47
--- /dev/null
+++ b/dag/gunbc/emitted_crate_workspace_seed_growth.dag
@@ -0,0 +1,33 @@
+module gunbc.emitted_crate_workspace_seed_growth
+
+import gunbc.roadmap_model { RoadmapNodeId }
+import gunbc.seed_growth { SeedGrowthJustification }
+import std.decl_ref { DeclarationRef, WholeDeclaration }
+
+data emitted_crate_workspace_seed_growth_justification: SeedGrowthJustification = SeedGrowthJustification {
+  hand_authored_declarations: [
+    DeclarationRef { module_path: "v1_compiler.cli_run.emitted_crate_workspace_host", decl_name: "WORKSPACE_ENTRY", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run.emitted_crate_workspace_host", decl_name: "PLAN_MODULE", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run.emitted_crate_workspace_host", decl_name: "EmittedCrateWorkspaceHeld", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run.emitted_crate_workspace_host", decl_name: "PlanRows", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run.emitted_crate_workspace_host", decl_name: "refusal", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run.emitted_crate_workspace_host", decl_name: "field", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run.emitted_crate_workspace_host", decl_name: "as_str", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run.emitted_crate_workspace_host", decl_name: "as_int", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run.emitted_crate_workspace_host", decl_name: "as_bool", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run.emitted_crate_workspace_host", decl_name: "as_str_list", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run.emitted_crate_workspace_host", decl_name: "str_list", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run.emitted_crate_workspace_host", decl_name: "row_from_value", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run.emitted_crate_workspace_host", decl_name: "rows_from_value", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run.emitted_crate_workspace_host", decl_name: "evaluate_plan", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run.emitted_crate_workspace_host", decl_name: "write_workspace", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run.emitted_crate_workspace_host", decl_name: "git_head", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.cli_run.emitted_crate_workspace_host", decl_name: "run_emitted_crate_workspace", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.target_invocation_host", decl_name: "run_emitted_crate_workspace", field: WholeDeclaration },
+    DeclarationRef { module_path: "v1_compiler.target_invocation_host", decl_name: "emitted_crate_workspace_source_roots", field: WholeDeclaration }
+  ],
+  reason: "The Pkg7e instrument //gunbc/instruments:emitted-crate-workspace (gunbc#12214). Every partition decision is modeled: v2.workflow.emitted_crate_workspace emitted_workspace_plan derives the crate rows, the dependency packages and the dropped RED edge, and v1.compiler.stage0_crates partition_crate_boundary_emit_outcome_over renders manifests and lib.rs files. What stays in host Rust is the effect boundary the interpreter cannot perform -- the in-process seed emission of v2.compiler.compile, file writes, git rev-parse for the receipt head, and two cargo runs through the existing emitted_closure_compile_host -- plus the TRANSPORT of values across it: the emission's basenames and edges into the plan as interpreter lists, and the plan's rows back out as GeneratedPartitionCrateRow structs (field, as_str, as_int, as_bool, as_str_list, str_list, row_from_value, rows_from_value). That transport carries no decision: an unexpected shape refuses PlanShapeUnexpected rather than defaulting. Admitted by purpose under gunbc.v1_maintenance_standing v1_seed_standing: it is the build that proves the emitted v2 compiler partitions into crates. It is an instrument, run by author invocation, not a required phase; the plan's refusals are gated separately through test.claim.emitted_crate_workspace_witness. Classified against the refused classes: no language behavior, no compatibility obligation, no escape hatch (every arm refuses typed), no seed feature (the seed compiles what it compiled), and no public surface beyond the one cli_run re-export of the runner and its receipt struct.",
+  owning_dissolution_lane: "v1-hand-queue-drain" as RoadmapNodeId,
+  trigger: "Delete this host module when host-effect emission lets the instrument be a .dag fold end to end: the emission, the workspace writes and the two cargo runs are emitted realizations of modeled effects (the capability gunbc.source_root_eval_driver_seed_growth names for its own shim -- the rendered main becoming one call into the fold), sufficient for the plan's rows to reach the renderer and the build as values inside one evaluated program, so no interpreter-value transport or hand effect sequencing remains. Preserve the green build, the attributed dropped-dependency RED and the typed plan refusals at that replacement boundary.",
+  current_boundary: "Host only: emitted_crate_workspace_host.rs (wired by mod in cli_run.rs, one pub use of run_emitted_crate_workspace and EmittedCrateWorkspaceHeld) and one registry row plus dispatch arm in target_invocation_host.rs. It calls existing seed producers (compile_entry_emission, lane_emit_compile_probe_root, probe_cargo_invocation, run_cargo, make_eval_context) and adds none. No generated mirror is hand-edited; the stage0_crates generalization it renders through is .dag with regenerated mirrors."
+}
diff --git a/dag/gunbc/instrument_targets.dag b/dag/gunbc/instrument_targets.dag
index 09185194d1c..9bb557db3ed 100644
--- a/dag/gunbc/instrument_targets.dag
+++ b/dag/gunbc/instrument_targets.dag
@@ -15,6 +15,7 @@ import gunbc.target_binding {
   FloorMemoryQualificationProducer,
   CompileCleanDiagnosticCensusProducer,
   EvaluationStoreAddressExactHeadProducer,
+  EmittedCrateWorkspaceProducer,
   CompileCleanDiagnosticCensusStanding,
   CompileCleanDiagnosticCensusCompleted,
   CompileCleanDiagnosticCensusRefused,
@@ -199,6 +200,28 @@ fn v2_native_cli_label() -> Label {
   Label { package: instruments_package() target: TargetName { name: "v2-native-cli" } }
 }
 
+// THE EMITTED CLOSURE AS A MULTI-CRATE WORKSPACE (Pkg7e). The seed emits `v2.compiler.compile`'s
+// closure, `v2.workflow.emitted_crate_workspace` `emitted_workspace_plan` partitions it into crate
+// rows from the derived module DAG, the emission's returned edges and the transitive unit
+// dependencies, `v1.compiler.stage0_crates` renders those rows with the one partition renderer,
+// and cargo builds the workspace -- the POSITIVE CONTROL. In the same invocation one derived
+// dependency is dropped from one crate, chosen from the transitive reduction so no other crate's
+// glob facade can re-export it, and the build must fail with an error naming the dropped target
+// module -- the RED. The receipt names the head, the closure's module count, the crate count, the
+// rustc identity, both verdicts and whether the facade degenerated to the whole closure.
+//
+// WHAT A GREEN DOES NOT ESTABLISH. The facade re-exports each crate's TRANSITIVE dependency closure,
+// an over-approximation of the direct edges, because the inline crate::<module>:: paths the
+// expression emitter writes are not returned as edges (gunbc.guarantee_stall
+// emitted_inline_crate_path_edges_unreturned_stall). And the crates carry no grounded interface
+// maps: that waits on host-effect emission of v2.compiler.source_authority
+// module_storage_bindings_for_source_roots (v2.workflow.rust_crate_partition
+// stage0_module_dag_interface_grounding). So a green says the derived partition compiles through
+// glob facades; it does not say each crate's public surface is minimal or grounded.
+fn emitted_crate_workspace_label() -> Label {
+  Label { package: instruments_package() target: TargetName { name: "emitted-crate-workspace" } }
+}
+
 // O(corpus) exact-head join of evaluation_store_address callers plus the fail-closed src/v2
 // call-form scan. Not a DiscoverySelection floor witness (enrolment_bound_without_ceiling);
 // not a required CI job. `gunbc test //gunbc/instruments:evaluation-store-address-exact-head`.
@@ -329,6 +352,10 @@ fn required_lane_resolution_census_target() -> BuildTarget {
   instrument_test_target(label: required_lane_resolution_census_label())
 }
 
+fn emitted_crate_workspace_binding() -> TargetBinding {
+  TargetBinding { target: emitted_crate_workspace_label() producer: EmittedCrateWorkspaceProducer {} }
+}
+
 fn v2_native_cli_binding() -> TargetBinding {
   TargetBinding { target: v2_native_cli_label() producer: V2NativeCliProducer {} }
 }
@@ -459,7 +486,8 @@ fn instrument_targets() -> List<Label> {
     evaluation_store_address_exact_head_label(), primitive_egress_census_label(),
     primitive_egress_census_v2_label(), primitive_egress_census_dag_label(),
     primitive_egress_census_seed_label(), floor_memory_qualification_label(),
-    required_lane_resolution_census_label(), bare_reference_channel_outcome_label()
+    required_lane_resolution_census_label(), bare_reference_channel_outcome_label(),
+    emitted_crate_workspace_label()
   ]
 }
 
@@ -471,7 +499,8 @@ fn instrument_bindings() -> List<TargetBinding> {
     evaluation_store_address_exact_head_binding(), primitive_egress_census_binding(),
     primitive_egress_census_v2_binding(), primitive_egress_census_dag_binding(),
     primitive_egress_census_seed_binding(), floor_memory_qualification_binding(),
-    required_lane_resolution_census_binding(), bare_reference_channel_outcome_binding()
+    required_lane_resolution_census_binding(), bare_reference_channel_outcome_binding(),
+    emitted_crate_workspace_binding()
   ]
 }
 
diff --git a/dag/gunbc/rust_emitted_edge.dag b/dag/gunbc/rust_emitted_edge.dag
index 796b4d65abf..69d413308de 100644
--- a/dag/gunbc/rust_emitted_edge.dag
+++ b/dag/gunbc/rust_emitted_edge.dag
@@ -32,6 +32,21 @@ type EmittedEdge {
   provenance: EmittedEdgeProvenance
 }
 
+// THE ENDPOINT NAME. An edge row names a module by the basename of the file the emitter writes for
+// it, so the projection from a module's dotted name to that basename is this module's fact, not the
+// emitter's private one: v1.compiler.emit_rust renders files and paths with it, and a partition
+// derived over dotted module names (v2.workflow.emitted_crate_workspace) maps onto edge endpoints
+// with the same function. `main` renders as `main_mod` because it collides with the crate's own
+// entry file.
+fn module_to_filename(name: String) -> String {
+  name |> split(delimiter: ".") |> join(separator: "_")
+}
+
+fn rust_module_emit_filename(module_name: String) -> String {
+  let raw = module_to_filename(name: module_name)
+  if raw == "main" { "main_mod" } else { raw }
+}
+
 // The runtime-support module every emitted module paths into. emit_prelude renders its prelude
 // lines from the rows below, so the module named in the text and the module named by the edge are
 // the same value.
diff --git a/dag/gunbc/seed_growth_admission.dag b/dag/gunbc/seed_growth_admission.dag
index 3f701f1e9f9..884eaa60899 100644
--- a/dag/gunbc/seed_growth_admission.dag
+++ b/dag/gunbc/seed_growth_admission.dag
@@ -47,6 +47,7 @@ import gunbc.source_root_eval_driver_seed_growth { source_root_eval_driver_seed_
 import gunbc.gen_one_executable_keep_seed_growth { gen_one_executable_keep_seed_growth_justification }
 import gunbc.roadmap_authority { observation_scoped_run_seed_growth_justification }
 import gunbc.target_invocation_seed_growth { target_invocation_seed_growth_justification }
+import gunbc.emitted_crate_workspace_seed_growth { emitted_crate_workspace_seed_growth_justification }
 import gunbc.bootstrap_operation_seed_growth {
   bootstrap_operation_seed_growth_justification,
   cli_dispatch_host_boundary_seed_growth_justification
@@ -286,6 +287,7 @@ fn seed_growth_justification_roster() -> List<SeedGrowthJustification> {
     qualified_pipe_callee_seed_growth_justification,
     regen_digest_spelling_seed_growth_justification,
     target_invocation_seed_growth_justification,
+    emitted_crate_workspace_seed_growth_justification,
     bootstrap_operation_seed_growth_justification,
     cli_dispatch_host_boundary_seed_growth_justification,
     generated_artifact_boundary_seed_growth_justification,
diff --git a/dag/gunbc/stage0/stage0_emitted_edge_admission.dag b/dag/gunbc/stage0/stage0_emitted_edge_admission.dag
index b97790114f8..b3df02ee62c 100644
--- a/dag/gunbc/stage0/stage0_emitted_edge_admission.dag
+++ b/dag/gunbc/stage0/stage0_emitted_edge_admission.dag
@@ -10,7 +10,7 @@ import gunbc.rust_emitted_edge {
   ReexportFacade,
   SemanticSourceReference
 }
-import gunbc.stage0_crate_partition_generated { generated_partition_crate_rows }
+import gunbc.stage0_crate_partition_generated { GeneratedPartitionCrateRow, generated_partition_crate_rows }
 import gunbc.stage0_partition_package_graph {
   stage0_host_shell_dependency_names,
   stage0_host_shell_package_name,
@@ -60,7 +60,11 @@ type Stage0EmittedEdgeAdmission
 // this too, so the crate a lib.rs includes a module into and the crate this admission places it in
 // are one answer.
 fn stage0_partition_module_owner_packages(module_basename: String) -> List<String> {
-  generated_partition_crate_rows
+  partition_module_owner_packages_over(module_basename: module_basename, rows: generated_partition_crate_rows)
+}
+
+fn partition_module_owner_packages_over(module_basename: String, rows: List<GeneratedPartitionCrateRow>) -> List<String> {
+  rows
     |> filter(row =>
       stage0_partition_row_is_module_bearing_package(row: row)
         && (row.modules |> any(m => m == module_basename))
diff --git a/dag/gunbc/stage0/stage0_partition_package_graph.dag b/dag/gunbc/stage0/stage0_partition_package_graph.dag
index 85185b0ea51..e09aa06ee22 100644
--- a/dag/gunbc/stage0/stage0_partition_package_graph.dag
+++ b/dag/gunbc/stage0/stage0_partition_package_graph.dag
@@ -46,16 +46,27 @@ fn stage0_partition_row_is_module_bearing_package(row: GeneratedPartitionCrateRo
 }
 
 fn stage0_partition_module_bearing_package_names() -> List<String> {
-  generated_partition_crate_rows
+  partition_module_bearing_package_names_over(rows: generated_partition_crate_rows)
+}
+
+fn stage0_partition_package_dependency_names(row: GeneratedPartitionCrateRow) -> List<String> {
+  partition_package_dependency_names_over(row: row, rows: generated_partition_crate_rows)
+}
+
+// The same edges over ANY row set of this shape: the committed stage0 rows above, or rows a
+// derivation produced (v2.workflow.emitted_crate_workspace). The emit shell's edges are a property
+// of the set it sits in, so the set is a parameter rather than read from the committed one.
+fn partition_module_bearing_package_names_over(rows: List<GeneratedPartitionCrateRow>) -> List<String> {
+  rows
     |> filter(row => stage0_partition_row_is_module_bearing_package(row: row))
     |> map(row => row.package_name)
 }
 
-fn stage0_partition_package_dependency_names(row: GeneratedPartitionCrateRow) -> List<String> {
+fn partition_package_dependency_names_over(row: GeneratedPartitionCrateRow, rows: List<GeneratedPartitionCrateRow>) -> List<String> {
   match row.kind {
     GeneratedFoundationCrate => []
     GeneratedLayeredCoreCrate => row.reexport_packages
-    GeneratedEmitCoreCrate => stage0_partition_module_bearing_package_names()
+    GeneratedEmitCoreCrate => partition_module_bearing_package_names_over(rows: rows)
   }
 }
 
diff --git a/dag/gunbc/target_binding.dag b/dag/gunbc/target_binding.dag
index 453e43b1776..0391797be3c 100644
--- a/dag/gunbc/target_binding.dag
+++ b/dag/gunbc/target_binding.dag
@@ -27,6 +27,7 @@ type TargetProducer
   | HeadsReadingDifferentialProducer
   | CompileCleanDiagnosticCensusProducer
   | V2NativeCliProducer
+  | EmittedCrateWorkspaceProducer
   | EvaluationStoreAddressExactHeadProducer
   | PrimitiveEgressCensusProducer
   | PrimitiveEgressCensusV2Producer
diff --git a/src/v1/05_emit_core_support.dag b/src/v1/05_emit_core_support.dag
index b19d8603053..db8cb505b09 100644
--- a/src/v1/05_emit_core_support.dag
+++ b/src/v1/05_emit_core_support.dag
@@ -10,7 +10,7 @@ import v1.std.core {
 }
 
 import v1.compiler.artifact { RenderTarget }
-import gunbc.rust_emitted_edge { EmittedEdge }
+import gunbc.rust_emitted_edge { EmittedEdge, module_to_filename }
 
 import v1.compiler.infer_items { ResolvedGraph, TypedModule, leaf_owner_modules_from_registry }
 
@@ -51,10 +51,6 @@ fn escape_json_string(s: String) -> String {
     |> split(delimiter: "\t") |> join(separator: "\\t")
 }
 
-fn module_to_filename(name: String) -> String {
-  name |> split(delimiter: ".") |> join(separator: "_")
-}
-
 type ModuleFilenameOwners {
   owners: Map<String, String>
   diagnostics: List<ErrorNode>
diff --git a/src/v1/05_emit_rust.dag b/src/v1/05_emit_rust.dag
index d4ba28f3eaa..82f95e7cd17 100644
--- a/src/v1/05_emit_rust.dag
+++ b/src/v1/05_emit_rust.dag
@@ -12,7 +12,7 @@ import std.repair_input_origin {
 import std.primitive_projection {
   primitive_identity_runtime_name, primitive_projection_row_for_declaration
 }
-import gunbc.rust_emitted_edge { EmittedEdge, rust_prelude_emitted_edges, emitted_edge_target_module, semantic_source_reference_edge, RuntimePrelude, ReexportFacade }
+import gunbc.rust_emitted_edge { EmittedEdge, rust_module_emit_filename, rust_prelude_emitted_edges, emitted_edge_target_module, semantic_source_reference_edge, RuntimePrelude, ReexportFacade }
 import gunbc.reference_derived_candidate {
   ReferenceDerivedCandidateDisposition,
   CandidateSurvived,
@@ -3594,15 +3594,10 @@ fn emit_rust_selected(typed: ResolvedGraph, selection: RustModuleRenderSelection
   EmitResult { files: files, diagnostics: module_refusals, emitted_edges: published_module_emissions |> flat_map(e => e.emitted_edges) }
 }
 
-// THE ONE PLACE A MODULE'S EMITTED FILENAME IS DECIDED, read by the renderer and by every
-// population-denominated aggregate that must name a module it did not render. `main` collides
-// with the crate's own entry file, so it renders as `main_mod`; that rename used to live inside
-// `emit_module_full` alone, where a second reader of the same fact had no way to reach it.
-fn rust_module_emit_filename(module_name: String) -> String {
-  let raw = module_to_filename(name: module_name)
-  if raw == "main" { "main_mod" } else { raw }
-}
-
+// A MODULE'S EMITTED PATH, read by the renderer and by every population-denominated aggregate that
+// must name a module it did not render. The basename is decided once, in gunbc.rust_emitted_edge
+// rust_module_emit_filename, because the emitter's edge rows name their endpoints by it and a
+// partition over dotted module names maps onto those endpoints with the same function.
 fn rust_module_emit_path(module_name: String) -> String {
   concat(rust_source_root(), rust_module_emit_filename(module_name: module_name), rust_source_ext())
 }
diff --git a/src/v1/stage0/src/cli_run.rs b/src/v1/stage0/src/cli_run.rs
index b6d6ae20d32..97acb90e6bc 100644
--- a/src/v1/stage0/src/cli_run.rs
+++ b/src/v1/stage0/src/cli_run.rs
@@ -89,6 +89,7 @@ mod census_heads;
 #[path = "declaration_index.rs"]
 pub mod declaration_index;
 pub mod derived_row_roster;
+mod emitted_crate_workspace_host;
 mod native_lane_runner;
 pub mod required_ci_measurement;
 mod required_floor_runner;
@@ -96,6 +97,7 @@ mod required_lane_roster;
 pub mod rostered_row_join;
 pub mod scope_rank_view;
 mod serve_budget_refusal;
+pub use emitted_crate_workspace_host::{run_emitted_crate_workspace, EmittedCrateWorkspaceHeld};
 pub use native_lane_runner::{
     run_required_v2_native, run_self_host, run_v2_native_cli, NativeMemberTermination,
     NativeRouteOutcome, SelfHostHeld, V2NativeCliHeld,
diff --git a/src/v1/stage0/src/cli_run/emitted_crate_workspace_host.rs b/src/v1/stage0/src/cli_run/emitted_crate_workspace_host.rs
new file mode 100644
index 00000000000..32f1e405c23
--- /dev/null
+++ b/src/v1/stage0/src/cli_run/emitted_crate_workspace_host.rs
@@ -0,0 +1,510 @@
+//! THE EMITTED CLOSURE, BUILT AS A MULTI-CRATE CARGO WORKSPACE (Pkg7e), with its discriminating red.
+//!
+//! `//gunbc/instruments:emitted-crate-workspace`. The seed emits `v2.compiler.compile`'s closure
+//! once; `v2.workflow.emitted_crate_workspace` `emitted_workspace_plan` partitions it into crate
+//! rows from the derived module DAG, the emission's own returned edges and the transitive unit
+//! dependencies; `v1.compiler.stage0_crates` `partition_crate_boundary_emit_outcome_over` renders
+//! those rows with the one partition renderer; this host writes the tree and runs cargo.
+//!
+//! WHAT THIS FILE DECIDES: nothing about the partition. Every row, dependency and the dropped edge
+//! come from the `.dag` plan; the manifests and lib.rs files come from the stage0 renderer. What is
+//! here is the effect boundary -- the emission, the file writes, the two cargo runs -- plus the
+//! transport that carries the emission's edges into the plan and the plan's rows back out.
+//!
+//! THE RED IS A DROPPED DERIVED DEPENDENCY THE GLOB FACADE CANNOT RE-EXPORT BY ANOTHER ROAD. The
+//! plan picks a unit dep edge in the transitive reduction that the emitter also wrote as a use-line;
+//! the red rows remove that package from its source crate's manifest and facade. A green there would
+//! mean the facade re-exports the target through some other dependency, which the reduction
+//! excludes, or that cargo never read the tree. Both runs are in one invocation.
+
+use std::path::Path;
+use std::rc::Rc;
+
+use crate::gunbc_stage0_crate_partition_generated::{
+    GeneratedPartitionCrateKind, GeneratedPartitionCrateRow,
+};
+use crate::v1_interpreter::{self, ExecutionMode, Value};
+
+const WORKSPACE_ENTRY: &str = "src/v2/compiler/00_compile.dag";
+const PLAN_MODULE: &str = "src/v2/workflow/emitted_crate_workspace.dag";
+
+pub struct EmittedCrateWorkspaceHeld {
+    pub head: String,
+    pub closure_modules: i64,
+    pub crate_count: i64,
+    pub facade_is_whole_closure: bool,
+    pub rustc_identity: String,
+    pub green_exit_status: i64,
+    pub green_warning_count: i64,
+    pub red_package: String,
+    pub red_dropped_package: String,
+    pub red_from_module: String,
+    pub red_to_module: String,
+    pub red_diagnostic: String,
+}
+
+struct PlanRows {
+    rows: Vec<GeneratedPartitionCrateRow>,
+    red_rows: Vec<GeneratedPartitionCrateRow>,
+    red_package: String,
+    red_dropped_package: String,
+    red_from_module: String,
+    red_to_module: String,
+    module_count: i64,
+    crate_count: i64,
+    facade_is_whole_closure: bool,
+}
+
+fn refusal(cause: &str, detail: impl std::fmt::Display) -> String {
+    format!("EMITTED-WORKSPACE REFUSAL cause={cause} — {detail}")
+}
+
+fn field<'a>(
+    ctx: &v1_interpreter::InterpContext,
+    fields: &'a [(v1_interpreter::Symbol, Value)],
+    name: &str,
+) -> Result<&'a Value, String> {
+    fields
+        .iter()
+        .find(|(sym, _)| ctx.sym_eq(*sym, name))
+        .map(|(_, v)| v)
+        .ok_or_else(|| refusal("PlanShapeUnexpected", format!("no field `{name}`")))
+}
+
+fn as_str(v: &Value, what: &str) -> Result<String, String> {
+    match v {
+        Value::Str(s) => Ok(s.to_string()),
+        other => Err(refusal(
+            "PlanShapeUnexpected",
+            format!("{what} is {} not a String", other.type_label_public()),
+        )),
+    }
+}
+
+fn as_int(v: &Value, what: &str) -> Result<i64, String> {
+    match v {
+        Value::Int(i) => Ok(*i),
+        other => Err(refusal(
+            "PlanShapeUnexpected",
+            format!("{what} is {} not an Int", other.type_label_public()),
+        )),
+    }
+}
+
+fn as_bool(v: &Value, what: &str) -> Result<bool, String> {
+    match v {
+        Value::Bool(b) => Ok(*b),
+        other => Err(refusal(
+            "PlanShapeUnexpected",
+            format!("{what} is {} not a Bool", other.type_label_public()),
+        )),
+    }
+}
+
+fn as_str_list(v: &Value, what: &str) -> Result<Vec<String>, String> {
+    match v {
+        Value::List(items) => items.iter().map(|i| as_str(i, what)).collect(),
+        other => Err(refusal(
+            "PlanShapeUnexpected",
+            format!("{what} is {} not a List", other.type_label_public()),
+        )),
+    }
+}
+
+fn str_list(xs: &[String]) -> Value {
+    Value::List(Rc::new(
+        xs.iter()
+            .map(|s| v1_interpreter::str_value(s))
+            .collect::<Vec<Value>>()
+            .into(),
+    ))
+}
+
+fn row_from_value(
+    ctx: &v1_interpreter::InterpContext,
+    v: &Value,
+) -> Result<GeneratedPartitionCrateRow, String> {
+    let Value::Record { fields, .. } = v else {
+        return Err(refusal(
+            "PlanShapeUnexpected",
+            "a crate row is not a record",
+        ));
+    };
+    let kind = match field(ctx, fields, "kind")? {
+        Value::Variant { variant_name, .. }
+            if ctx.sym_eq(*variant_name, "GeneratedFoundationCrate") =>
+        {
+            GeneratedPartitionCrateKind::GeneratedFoundationCrate
+        }
+        Value::Variant { variant_name, .. }
+            if ctx.sym_eq(*variant_name, "GeneratedLayeredCoreCrate") =>
+        {
+            GeneratedPartitionCrateKind::GeneratedLayeredCoreCrate
+        }
+        other => {
+            return Err(refusal(
+                "PlanShapeUnexpected",
+                format!(
+                "a crate row's kind is {} — the plan derives foundation and layered crates only",
+                other.type_label_public()
+            ),
+            ))
+        }
+    };
+    Ok(GeneratedPartitionCrateRow {
+        package_name: as_str(field(ctx, fields, "package_name")?, "package_name")?,
+        crate_dir: as_str(field(ctx, fields, "crate_dir")?, "crate_dir")?,
+        kind,
+        modules: Rc::new(
+            as_str_list(field(ctx, fields, "modules")?, "modules")?
+                .into_iter()
+                .collect(),
+        ),
+        reexport_packages: Rc::new(
+            as_str_list(
+                field(ctx, fields, "reexport_packages")?,
+                "reexport_packages",
+            )?
+            .into_iter()
+            .collect(),
+        ),
+        carries_non_empty_wrappers: as_bool(
+            field(ctx, fields, "carries_non_empty_wrappers")?,
+            "carries_non_empty_wrappers",
+        )?,
+    })
+}
+
+fn rows_from_value(
+    ctx: &v1_interpreter::InterpContext,
+    v: &Value,
+    what: &str,
+) -> Result<Vec<GeneratedPartitionCrateRow>, String> {
+    match v {
+        Value::List(items) => items.iter().map(|i| row_from_value(ctx, i)).collect(),
+        other => Err(refusal(
+            "PlanShapeUnexpected",
+            format!("{what} is {} not a List", other.type_label_public()),
+        )),
+    }
+}
+
+/// Evaluate `emitted_workspace_plan` over the emission's basenames and edges. The plan derives the
+/// module DAG from the live dependency facts itself, so the corpus it reads is the source roots.
+fn evaluate_plan(
+    source_roots: &[String],
+    emitted_basenames: &[String],
+    edge_froms: &[String],
+    edge_tos: &[String],
+    edge_provenances: &[String],
+) -> Result<PlanRows, String> {
+    let index = super::process_shared_index(source_roots);
+    let (graph, indices) =
+        super::resolve_entry_with_index_for_discovery_corpus(&index, PLAN_MODULE)
+            .map_err(|e| refusal("PlanModuleUnresolved", format!("{PLAN_MODULE}: {e}")))?;
+    let ctx = super::make_eval_context(&graph, indices, ExecutionMode::Wet);
+    let args = vec![
+        (
+            Some("emitted_basenames".to_string()),
+            str_list(emitted_basenames),
+        ),
+        (Some("edge_froms".to_string()), str_list(edge_froms)),
+        (Some("edge_tos".to_string()), str_list(edge_tos)),
+        (
+            Some("edge_provenances".to_string()),
+            str_list(edge_provenances),
+        ),
+    ];
+    let outcome = v1_interpreter::with_active_context(&ctx, || {
+        v1_interpreter::run_in_context_with_args(&ctx, "emitted_workspace_plan", &args, false)
+    })
+    .map_err(|e| refusal("PlanNotEvaluated", e))?;
+    let Value::Variant {
+        variant_name,
+        fields,
+        ..
+    } = &outcome
+    else {
+        return Err(refusal(
+            "PlanShapeUnexpected",
+            "the plan outcome is not a variant",
+        ));
+    };
+    if !ctx.sym_eq(*variant_name, "EmittedWorkspacePlanned") {
+        return Err(refusal("PlanRefused", format!("{outcome:?}")));
+    }
+    let Value::Record { fields: plan, .. } = field(&ctx, fields, "plan")? else {
+        return Err(refusal("PlanShapeUnexpected", "plan is not a record"));
+    };
+    let Value::Record { fields: red, .. } = field(&ctx, plan, "red")? else {
+        return Err(refusal("PlanShapeUnexpected", "red is not a record"));
+    };
+    Ok(PlanRows {
+        rows: rows_from_value(&ctx, field(&ctx, plan, "rows")?, "rows")?,
+        red_rows: rows_from_value(&ctx, field(&ctx, plan, "red_rows")?, "red_rows")?,
+        red_package: as_str(field(&ctx, red, "package")?, "red.package")?,
+        red_dropped_package: as_str(field(&ctx, red, "dropped_package")?, "red.dropped_package")?,
+        red_from_module: as_str(field(&ctx, red, "from_module")?, "red.from_module")?,
+        red_to_module: as_str(field(&ctx, red, "to_module")?, "red.to_module")?,
+        module_count: as_int(field(&ctx, plan, "module_count")?, "module_count")?,
+        crate_count: as_int(field(&ctx, plan, "crate_count")?, "crate_count")?,
+        facade_is_whole_closure: as_bool(
+            field(&ctx, plan, "facade_is_whole_closure")?,
+            "facade_is_whole_closure",
+        )?,
+    })
+}
+
+/// Render rows through the one partition renderer and write them, with the workspace manifest that
+/// lists exactly those crates. The emitted module files sit where the renderer's includes expect
+/// them (`src/v1/stage0/src`).
+fn write_workspace(root: &Path, rows: &[GeneratedPartitionCrateRow]) -> Result<(), String> {
+    let rows_value = Rc::new(rows.iter().cloned().map(Rc::new).collect());
+    let files = match &*crate::v1_compiler_stage0_crates::partition_crate_boundary_emit_outcome_over(rows_value) {
+        crate::v1_compiler_stage0_crates::Stage0CrateBoundaryEmitOutcome::Stage0CrateBoundaryEmitOk { files } => files.clone(),
+        crate::v1_compiler_stage0_crates::Stage0CrateBoundaryEmitOutcome::Stage0CrateBoundaryEmitRefused { cause } => {
+            return Err(refusal(
+                "RenderRefused",
+                crate::v1_compiler_stage0_crates::stage0_crate_boundary_emit_refusal_message(cause.clone()),
+            ))
+        }
+    };
+    for file in files.iter() {
+        let path = root.join(&*file.path);
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent).map_err(|e| {
+                refusal("WorkspaceNotWritten", format!("{}: {e}", parent.display()))
+            })?;
+        }
+        std::fs::write(&path, &*file.content)
+            .map_err(|e| refusal("WorkspaceNotWritten", format!("{}: {e}", path.display())))?;
+    }
+    let members = rows
+        .iter()
+        .map(|r| format!("    \"{}\",", r.crate_dir))
+        .collect::<Vec<_>>()
+        .join("\n");
+    std::fs::write(
+        root.join("Cargo.toml"),
+        format!("[workspace]\nresolver = \"2\"\nmembers = [\n{members}\n]\n"),
+    )
+    .map_err(|e| refusal("WorkspaceNotWritten", format!("root manifest: {e}")))
+}
+
+/// The receipt names the revision it measured; an unreadable head refuses rather than printing a
+/// receipt that cannot be joined to a tree.
+fn git_head(workspace: &Path) -> Result<String, String> {
+    let out = std::process::Command::new("git")
+        .args(["rev-parse", "HEAD"])
+        .current_dir(workspace)
+        .output()
+        .map_err(|e| refusal("HeadUnreadable", e))?;
+    if !out.status.success() {
+        return Err(refusal(
+            "HeadUnreadable",
+            String::from_utf8_lossy(&out.stderr),
+        ));
+    }
+    Ok(String::from_utf8_lossy(&out.stdout).trim().to_string())
+}
+
+pub fn run_emitted_crate_workspace(
+    source_roots: &[String],
+) -> Result<EmittedCrateWorkspaceHeld, String> {
+    let workspace = super::process_workspace_root();
+    let head = git_head(&workspace)?;
+    let probe_root =
+        super::lane_emit_compile_probe_root().map_err(|c| refusal("ProbeRootNotCreated", c))?;
+    eprintln!(
+        "emitted-crate-workspace: head={head} probe root {}",
+        probe_root.display()
+    );
+
+    eprintln!("emitted-crate-workspace: emitting {WORKSPACE_ENTRY} (seed, in-process)");
+    let run = super::compile_entry_emission(
+        source_roots,
+        WORKSPACE_ENTRY,
+        true,
+        crate::v1_compiler_artifact::RenderTarget::Rust,
+    );
+    match &run.disposition {
+        super::CompileDisposition::Completed { .. } => {}
+        super::CompileDisposition::Refused { phase, cause } => {
+            return Err(refusal("EmissionRefused", format!("stage={phase} {cause}")))
+        }
+        super::CompileDisposition::NotExecuted {
+            earlier_phase,
+            cause,
+        } => {
+            return Err(refusal(
+                "EmissionRefused",
+                format!("stage={earlier_phase} {cause}"),
+            ))
+        }
+    }
+    let emission = run
+        .emissions
+        .iter()
+        .find(|e| e.target_name == "rust")
+        .ok_or_else(|| refusal("EmissionRefused", "no rust target"))?;
+
+    // The module files the emission wrote, by basename; the crate root, entry file and population
+    // manifest are the single-crate assembly's and have no place in a partition crate.
+    let root = probe_root.target_dir().join("emitted_crate_workspace");
+    let _ = std::fs::remove_dir_all(&root);
+    let module_dir = root.join("src/v1/stage0/src");
+    std::fs::create_dir_all(&module_dir).map_err(|e| refusal("WorkspaceNotWritten", e))?;
+    let mut emitted_basenames = Vec::new();
+    for file in emission.result.files.iter() {
+        let Some(basename) = file
+            .path
+            .strip_prefix("src/")
+            .and_then(|p| p.strip_suffix(".rs"))
+        else {
+            continue;
+        };
+        if basename.contains('/') || matches!(basename, "lib" | "main" | "emitted_population") {
+            continue;
+        }
+        std::fs::write(module_dir.join(format!("{basename}.rs")), &*file.content)
+            .map_err(|e| refusal("WorkspaceNotWritten", format!("{basename}: {e}")))?;
+        emitted_basenames.push(basename.to_string());
+    }
+    let (mut froms, mut tos, mut provenances) = (Vec::new(), Vec::new(), Vec::new());
+    for edge in emission.result.emitted_edges.iter() {
+        froms.push(edge.from.clone());
+        tos.push(match &*edge.to {
+            crate::gunbc_rust_emitted_edge::EmittedEdgeTarget::EmittedModuleTarget { module } => {
+                module.clone()
+            }
+            crate::gunbc_rust_emitted_edge::EmittedEdgeTarget::EmittedCrateRootTarget => {
+                String::new()
+            }
+        });
+        provenances.push(
+            crate::gunbc_stage0_emitted_edge_admission::stage0_emitted_edge_provenance_name(
+                edge.provenance.clone(),
+            ),
+        );
+    }
+    eprintln!(
+        "emitted-crate-workspace: emitted {} module files and {} edges; evaluating the partition plan",
+        emitted_basenames.len(),
+        froms.len()
+    );
+    drop(run);
+    let _ = super::trim_retained_heap();
+
+    let plan = evaluate_plan(source_roots, &emitted_basenames, &froms, &tos, &provenances)?;
+    eprintln!(
+        "emitted-crate-workspace: plan modules={} crates={} facade_is_whole_closure={} red={} drops {} ({} -> {})",
+        plan.module_count, plan.crate_count, plan.facade_is_whole_closure, plan.red_package, plan.red_dropped_package,
+        plan.red_from_module, plan.red_to_module
+    );
+
+    let target_dir = probe_root
+        .target_dir()
+        .join("emitted_crate_workspace_target");
+    let invocation =
+        super::emitted_closure_compile_host::probe_cargo_invocation(&root, &target_dir)
+            .map_err(|c| refusal("CargoNotResolved", c))?;
+
+    // POSITIVE CONTROL: the derived partition builds.
+    write_workspace(&root, &plan.rows)?;
+    let green =
+        super::emitted_closure_compile_host::run_cargo(&root, &target_dir, &plan.red_to_module);
+    let (green_exit_status, green_warning_count) = match &green {
+        super::emitted_closure_compile_host::CargoVerdict::Completed {
+            status,
+            warning_count,
+            ..
+        } => (i64::from(*status), *warning_count as i64),
+        other => {
+            return Err(refusal(
+                "GreenBuildNotCompleted",
+                super::emitted_closure_compile_host::cargo_verdict_summary(other),
+            ))
+        }
+    };
+    eprintln!(
+        "emitted-crate-workspace: GREEN {} rustc={}",
+        super::emitted_closure_compile_host::cargo_verdict_summary(&green),
+        invocation.rustc_identity
+    );
+
+    if green_exit_status != 0 {
+        // The positive control did not build, so there is no clean baseline for a red to be read
+        // against. That is the observation not holding, reported with cargo's own tail; the red is
+        // not attempted rather than reported as refused.
+        return Ok(EmittedCrateWorkspaceHeld {
+            head,
+            closure_modules: plan.module_count,
+            crate_count: plan.crate_count,
+            facade_is_whole_closure: plan.facade_is_whole_closure,
+            rustc_identity: invocation.rustc_identity,
+            green_exit_status,
+            green_warning_count,
+            red_package: plan.red_package,
+            red_dropped_package: plan.red_dropped_package,
+            red_from_module: plan.red_from_module,
+            red_to_module: plan.red_to_module,
+            red_diagnostic: format!(
+                "not attempted: the positive control did not build — {}",
+                super::emitted_closure_compile_host::cargo_verdict_summary(&green)
+            ),
+        });
+    }
+
+    // RED: the same tree with one derived dependency dropped from one crate.
+    write_workspace(&root, &plan.red_rows)?;
+    let red =
+        super::emitted_closure_compile_host::run_cargo(&root, &target_dir, &plan.red_to_module);
+    let red_diagnostic = match &red {
+        super::emitted_closure_compile_host::CargoVerdict::Completed { status, .. } if *status != 0 => {
+            match (
+                super::emitted_closure_compile_host::cargo_verdict_probe_diagnostic(&red),
+                super::emitted_closure_compile_host::cargo_verdict_probe_line(&red),
+            ) {
+                (Some(diag), Some(line)) => format!("{diag} @ {line}"),
+                _ => {
+                    return Err(refusal(
+                        "RedNotAttributed",
+                        format!(
+                            "the red build failed but no error names {} — {}",
+                            plan.red_to_module,
+                            super::emitted_closure_compile_host::cargo_verdict_summary(&red)
+                        ),
+                    ))
+                }
+            }
+        }
+        super::emitted_closure_compile_host::CargoVerdict::Completed { .. } => {
+            return Err(refusal(
+                "RedBuiltGreen",
+                format!(
+                    "dropping {} from {} still built — the facade re-exports it by another road, or cargo never read the tree",
+                    plan.red_dropped_package, plan.red_package
+                ),
+            ))
+        }
+        other => return Err(refusal("RedBuildNotCompleted", super::emitted_closure_compile_host::cargo_verdict_summary(other))),
+    };
+    eprintln!("emitted-crate-workspace: RED refused as required — {red_diagnostic}");
+    // Leave the tree as the green plan rendered it, so the directory describes the positive control.
+    write_workspace(&root, &plan.rows)?;
+
+    Ok(EmittedCrateWorkspaceHeld {
+        head,
+        closure_modules: plan.module_count,
+        crate_count: plan.crate_count,
+        facade_is_whole_closure: plan.facade_is_whole_closure,
+        rustc_identity: invocation.rustc_identity,
+        green_exit_status,
+        green_warning_count,
+        red_package: plan.red_package,
+        red_dropped_package: plan.red_dropped_package,
+        red_from_module: plan.red_from_module,
+        red_to_module: plan.red_to_module,
+        red_diagnostic,
+    })
+}
diff --git a/src/v1/stage0/src/gunbc_rust_emitted_edge.rs b/src/v1/stage0/src/gunbc_rust_emitted_edge.rs
index d40b34df9ea..fcc446709ba 100644
--- a/src/v1/stage0/src/gunbc_rust_emitted_edge.rs
+++ b/src/v1/stage0/src/gunbc_rust_emitted_edge.rs
@@ -43,6 +43,27 @@ pub struct EmittedEdge {
     pub provenance: EmittedEdgeProvenance,
 }
 
+pub fn module_to_filename(name: String) -> String {
+    Rc::new(
+        name.clone()
+            .split(&".".to_string())
+            .map(|s| s.to_string())
+            .collect::<Vec<_>>(),
+    )
+    .join(&"_".to_string())
+}
+
+pub fn rust_module_emit_filename(module_name: String) -> String {
+    {
+        let raw = module_to_filename(module_name.clone());
+        if (raw.clone() == "main".to_string()) {
+            "main_mod".to_string()
+        } else {
+            raw.clone()
+        }
+    }
+}
+
 pub fn rust_runtime_prelude_module() -> String {
     thread_local! {
         static CACHED: String = {
diff --git a/src/v1/stage0/src/gunbc_stage0_emitted_edge_admission.rs b/src/v1/stage0/src/gunbc_stage0_emitted_edge_admission.rs
index 017df58f440..7a0353c7737 100644
--- a/src/v1/stage0/src/gunbc_stage0_emitted_edge_admission.rs
+++ b/src/v1/stage0/src/gunbc_stage0_emitted_edge_admission.rs
@@ -76,9 +76,16 @@ pub enum Stage0EmittedEdgeAdmission {
 }
 
 pub fn stage0_partition_module_owner_packages(module_basename: String) -> Rc<Vec<String>> {
+    partition_module_owner_packages_over(module_basename.clone(), generated_partition_crate_rows())
+}
+
+pub fn partition_module_owner_packages_over(
+    module_basename: String,
+    rows: Rc<Vec<Rc<GeneratedPartitionCrateRow>>>,
+) -> Rc<Vec<String>> {
     Rc::new({
         let mut __result = Vec::new();
-        for row in Rc::new({ let mut __result = Vec::new(); for row in generated_partition_crate_rows().iter().cloned() { if (crate::gunbc_stage0_partition_package_graph::stage0_partition_row_is_module_bearing_package(row.clone()) && { let mut __found = false; for m in row.modules.clone().iter().cloned() { if (m.clone() == module_basename.clone()) { __found = true; break; } } __found }) { __result.push(row); } } __result }).iter().cloned() { __result.push(row.package_name.clone()); }
+        for row in Rc::new({ let mut __result = Vec::new(); for row in rows.iter().cloned() { if (crate::gunbc_stage0_partition_package_graph::stage0_partition_row_is_module_bearing_package(row.clone()) && { let mut __found = false; for m in row.modules.clone().iter().cloned() { if (m.clone() == module_basename.clone()) { __found = true; break; } } __found }) { __result.push(row); } } __result }).iter().cloned() { __result.push(row.package_name.clone()); }
         __result
     })
 }
diff --git a/src/v1/stage0/src/gunbc_stage0_partition_package_graph.rs b/src/v1/stage0/src/gunbc_stage0_partition_package_graph.rs
index 247dc4ae1f8..9f5489301cb 100644
--- a/src/v1/stage0/src/gunbc_stage0_partition_package_graph.rs
+++ b/src/v1/stage0/src/gunbc_stage0_partition_package_graph.rs
@@ -30,11 +30,23 @@ pub fn stage0_partition_row_is_module_bearing_package(row: Rc<GeneratedPartition
 }
 
 pub fn stage0_partition_module_bearing_package_names() -> Rc<Vec<String>> {
+    partition_module_bearing_package_names_over(generated_partition_crate_rows())
+}
+
+pub fn stage0_partition_package_dependency_names(
+    row: Rc<GeneratedPartitionCrateRow>,
+) -> Rc<Vec<String>> {
+    partition_package_dependency_names_over(row.clone(), generated_partition_crate_rows())
+}
+
+pub fn partition_module_bearing_package_names_over(
+    rows: Rc<Vec<Rc<GeneratedPartitionCrateRow>>>,
+) -> Rc<Vec<String>> {
     Rc::new({
         let mut __result = Vec::new();
         for row in Rc::new({
             let mut __result = Vec::new();
-            for row in generated_partition_crate_rows().iter().cloned() {
+            for row in rows.iter().cloned() {
                 if stage0_partition_row_is_module_bearing_package(row.clone()) {
                     __result.push(row);
                 }
@@ -50,14 +62,15 @@ pub fn stage0_partition_module_bearing_package_names() -> Rc<Vec<String>> {
     })
 }
 
-pub fn stage0_partition_package_dependency_names(
+pub fn partition_package_dependency_names_over(
     row: Rc<GeneratedPartitionCrateRow>,
+    rows: Rc<Vec<Rc<GeneratedPartitionCrateRow>>>,
 ) -> Rc<Vec<String>> {
     match row.kind.clone() {
         GeneratedPartitionCrateKind::GeneratedFoundationCrate => Rc::new(vec![]),
         GeneratedPartitionCrateKind::GeneratedLayeredCoreCrate => row.reexport_packages.clone(),
         GeneratedPartitionCrateKind::GeneratedEmitCoreCrate => {
-            stage0_partition_module_bearing_package_names()
+            partition_module_bearing_package_names_over(rows.clone())
         }
     }
 }
diff --git a/src/v1/stage0/src/target_invocation_host.rs b/src/v1/stage0/src/target_invocation_host.rs
index 3b9768a349f..b4f8e26d3fc 100644
--- a/src/v1/stage0/src/target_invocation_host.rs
+++ b/src/v1/stage0/src/target_invocation_host.rs
@@ -249,6 +249,7 @@ pub fn parse_target_pattern(text: &str) -> Result<TargetPattern, TargetPatternRe
 pub enum TargetProducer {
     SelfHost,
     V2NativeCli,
+    EmittedCrateWorkspace,
     HeadsReadingDifferential,
     BehavioralReceiptPlan,
     BehavioralReceiptCensus,
@@ -285,6 +286,12 @@ fn v2_native_cli_source_roots() -> Vec<String> {
     vec!["dag".to_string(), "src/v2".to_string()]
 }
 
+/// `gunbc.instrument_targets` `emitted_crate_workspace_label`: the closure is emitted from the same
+/// corpus the self-host step emits from, so the two instruments measure one closure two ways.
+fn emitted_crate_workspace_source_roots() -> Vec<String> {
+    vec!["dag".to_string(), "src/v2".to_string()]
+}
+
 fn instrument_registry() -> Vec<(Label, TargetProducer)> {
     vec![
         (
@@ -315,6 +322,10 @@ fn instrument_registry() -> Vec<(Label, TargetProducer)> {
             instrument_label("v2-native-cli"),
             TargetProducer::V2NativeCli,
         ),
+        (
+            instrument_label("emitted-crate-workspace"),
+            TargetProducer::EmittedCrateWorkspace,
+        ),
         (
             instrument_label("evaluation-store-address-exact-head"),
             TargetProducer::EvaluationStoreAddressExactHead,
@@ -710,6 +721,9 @@ fn run_producer(producer: TargetProducer) -> InvocationOutcome {
         TargetProducer::CompileCleanDiagnosticCensus => run_compile_clean_diagnostic_census(),
         TargetProducer::SelfHost => run_self_host(&self_host_source_roots()),
         TargetProducer::V2NativeCli => run_v2_native_cli(&v2_native_cli_source_roots()),
+        TargetProducer::EmittedCrateWorkspace => {
+            run_emitted_crate_workspace(&emitted_crate_workspace_source_roots())
+        }
         TargetProducer::EvaluationStoreAddressExactHead => {
             run_evaluation_store_address_exact_head()
         }
@@ -1039,6 +1053,41 @@ fn run_v2_native_cli(source_roots: &[String]) -> InvocationOutcome {
     }
 }
 
+/// THE EMITTED-WORKSPACE PRODUCER (Pkg7e). SubjectUnreached when the emission, the plan, the render
+/// or either cargo run could not be reached or the red could not be attributed; the observation
+/// holds only when the derived partition built clean AND the dropped-dependency red refused with an
+/// error naming the dropped target module. Every refusal carries its typed cause from the runner.
+fn run_emitted_crate_workspace(source_roots: &[String]) -> InvocationOutcome {
+    match cli_run::run_emitted_crate_workspace(source_roots) {
+        Ok(held) => InvocationOutcome {
+            termination: if held.green_exit_status == 0 && held.green_warning_count == 0 {
+                Termination::ObservationHeld
+            } else {
+                Termination::ObservationDidNotHold
+            },
+            message: format!(
+                "emitted-crate-workspace: head={} closure_modules={} crates={}                  facade_is_whole_closure={} rustc={} green_exit_status={} green_warning_count={}                  red=drop {} from {} ({} -> {}) red_refused=\"{}\"",
+                held.head,
+                held.closure_modules,
+                held.crate_count,
+                held.facade_is_whole_closure,
+                held.rustc_identity,
+                held.green_exit_status,
+                held.green_warning_count,
+                held.red_dropped_package,
+                held.red_package,
+                held.red_from_module,
+                held.red_to_module,
+                held.red_diagnostic,
+            ),
+        },
+        Err(cause) => InvocationOutcome {
+            termination: Termination::SubjectUnreached,
+            message: cause,
+        },
+    }
+}
+
 /// THE DIAGNOSTIC CENSUS PRODUCER. The subject is the whole-tree compile-clean closure, which the
 /// census itself derives from `witness_layer_roots` — like the differential's roots, which corpus
 /// is measured is the instrument's own fact, not an invocation option.
diff --git a/src/v1/stage0/src/v1_compiler_emit.rs b/src/v1/stage0/src/v1_compiler_emit.rs
index 808ef1780f1..01bf97d7a8f 100644
--- a/src/v1/stage0/src/v1_compiler_emit.rs
+++ b/src/v1/stage0/src/v1_compiler_emit.rs
@@ -66,7 +66,6 @@ pub use crate::v1_compiler_infer_env::UnitVariantContribution;
 pub use crate::v1_compiler_infer_env::{authored_name, empty_symbol_index, lookup_type_for};
 pub use crate::v1_compiler_infer_env::{GlobalBareLookupState, TypeBinding, TypeEnv};
 pub use crate::v1_compiler_infer_items::item_is_effectful_callee;
-pub use crate::v1_compiler_infer_items::item_resource_names;
 pub use crate::v1_compiler_infer_items::{ItemInfo, ResolvedGraph, TypedModule};
 pub use crate::v1_compiler_infer_lookup::lookup_func_sig;
 pub use crate::v1_compiler_infer_service::{
@@ -1353,8 +1352,7 @@ pub fn test_file_path(module_name: String, target: RenderTarget) -> String {
             Some(dir) => dir.clone(),
             std::option::Option::None => "".to_string(),
         };
-        let filename =
-            crate::v1_compiler_emit_core_support::module_to_filename(module_name.clone());
+        let filename = crate::gunbc_rust_emitted_edge::module_to_filename(module_name.clone());
         v1_rt::concat(
             v1_rt::concat(
                 v1_rt::concat(
diff --git a/src/v1/stage0/src/v1_compiler_emit_core_support.rs b/src/v1/stage0/src/v1_compiler_emit_core_support.rs
index e60916a12ac..0de55d63563 100644
--- a/src/v1/stage0/src/v1_compiler_emit_core_support.rs
+++ b/src/v1/stage0/src/v1_compiler_emit_core_support.rs
@@ -1,6 +1,7 @@
 // Generated by v1 compiler -- do not edit.
 // Source module: v1.compiler.emit_core_support
 
+pub use crate::gunbc_rust_emitted_edge::module_to_filename;
 pub use crate::gunbc_rust_emitted_edge::EmittedEdge;
 pub use crate::v1_compiler_artifact::RenderTarget;
 use crate::v1_compiler_artifact::RenderTarget::*;
@@ -76,16 +77,6 @@ pub fn escape_json_string(s: String) -> String {
     .join(&"\\t".to_string())
 }
 
-pub fn module_to_filename(name: String) -> String {
-    Rc::new(
-        name.clone()
-            .split(&".".to_string())
-            .map(|s| s.to_string())
-            .collect::<Vec<_>>(),
-    )
-    .join(&"_".to_string())
-}
-
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct ModuleFilenameOwners {
     pub owners: Rc<HashMap<String, String>>,
@@ -104,7 +95,8 @@ pub fn module_filename_collision_diagnostics(typed: Rc<ResolvedGraph>) -> Rc<Vec
                     tm.type_env.clone().source_indices.clone(),
                     tm.module.clone(),
                 );
-                let filename = module_to_filename(module_name.clone());
+                let filename =
+                    crate::gunbc_rust_emitted_edge::module_to_filename(module_name.clone());
                 match v1_rt::map_get(&acc.owners.clone(), filename.clone()) {
                     Some(owner) => {
                         if (owner.clone() == module_name.clone()) {
diff --git a/src/v1/stage0/src/v1_compiler_emit_go.rs b/src/v1/stage0/src/v1_compiler_emit_go.rs
index 18fd1ae5a00..e7fc307192e 100644
--- a/src/v1/stage0/src/v1_compiler_emit_go.rs
+++ b/src/v1/stage0/src/v1_compiler_emit_go.rs
@@ -502,8 +502,7 @@ pub fn emit_go_module(
             __result
         })
         .join(&"\n\n".to_string());
-        let mod_dir =
-            crate::v1_compiler_emit_core_support::module_to_filename(mod_name_str.clone());
+        let mod_dir = crate::gunbc_rust_emitted_edge::module_to_filename(mod_name_str.clone());
         let filename = mod_dir.clone();
         let content = v1_rt::concat(
             v1_rt::concat(
@@ -630,7 +629,7 @@ pub fn emit_go_imports(
             let mut __result = Vec::new();
             for imp in imports.iter().cloned() {
                 __result.push({
-                    let mod_name = crate::v1_compiler_emit_core_support::module_to_filename(
+                    let mod_name = crate::gunbc_rust_emitted_edge::module_to_filename(
                         crate::v1_std_core::authored_name_at(source_indices.clone(), imp.clone()),
                     );
                     v1_rt::concat(
diff --git a/src/v1/stage0/src/v1_compiler_emit_python.rs b/src/v1/stage0/src/v1_compiler_emit_python.rs
index 36821e30cfa..382e5fa22c5 100644
--- a/src/v1/stage0/src/v1_compiler_emit_python.rs
+++ b/src/v1/stage0/src/v1_compiler_emit_python.rs
@@ -219,7 +219,7 @@ pub fn emit_init_py(modules: Rc<Vec<Rc<TypedModule>>>) -> Rc<TextFile> {
             let mut __result = Vec::new();
             for tm in modules.iter().cloned() {
                 __result.push({
-                    let mod_name = crate::v1_compiler_emit_core_support::module_to_filename(
+                    let mod_name = crate::gunbc_rust_emitted_edge::module_to_filename(
                         crate::v1_std_core::authored_name_at(
                             tm.type_env.clone().source_indices.clone(),
                             tm.module.clone(),
@@ -441,8 +441,7 @@ pub fn emit_py_module(
             __result
         })
         .join(&"\n\n\n".to_string());
-        let filename =
-            crate::v1_compiler_emit_core_support::module_to_filename(mod_name_str.clone());
+        let filename = crate::gunbc_rust_emitted_edge::module_to_filename(mod_name_str.clone());
         let content = v1_rt::concat(
             v1_rt::concat(
                 v1_rt::concat(
@@ -492,7 +491,7 @@ pub fn emit_py_imports(
                 let mut __result = Vec::new();
                 for imp in imports.iter().cloned() {
                     __result.push({
-                        let mod_name = crate::v1_compiler_emit_core_support::module_to_filename(
+                        let mod_name = crate::gunbc_rust_emitted_edge::module_to_filename(
                             crate::v1_std_core::authored_name_at(
                                 source_indices.clone(),
                                 imp.clone(),
diff --git a/src/v1/stage0/src/v1_compiler_emit_rust.rs b/src/v1/stage0/src/v1_compiler_emit_rust.rs
index bf3321ae949..171422ab9ee 100644
--- a/src/v1/stage0/src/v1_compiler_emit_rust.rs
+++ b/src/v1/stage0/src/v1_compiler_emit_rust.rs
@@ -49,7 +49,8 @@ pub use crate::gunbc_reference_derived_candidate::{
 pub use crate::gunbc_rust_decl_type_overlay::rust_decl_type_container_overlay_is_admitted;
 use crate::gunbc_rust_emitted_edge::EmittedEdgeProvenance::{ReexportFacade, RuntimePrelude};
 pub use crate::gunbc_rust_emitted_edge::{
-    emitted_edge_target_module, rust_prelude_emitted_edges, semantic_source_reference_edge,
+    emitted_edge_target_module, rust_module_emit_filename, rust_prelude_emitted_edges,
+    semantic_source_reference_edge,
 };
 pub use crate::gunbc_rust_emitted_edge::{EmittedEdge, EmittedEdgeProvenance};
 pub use crate::gunbc_stage0_crate_layout_generated::generated_pub_mod_block;
@@ -3460,9 +3461,8 @@ pub fn render_rust_alias_rhs_type(
                             std::option::Option::None => "".to_string(),
                         };
                     }
-                    let local_mod = crate::v1_compiler_emit_core_support::module_to_filename(
-                        module_name.clone(),
-                    );
+                    let local_mod =
+                        crate::gunbc_rust_emitted_edge::module_to_filename(module_name.clone());
                     let def_mod = alias_rhs_rust_qualify_module_filename(
                         leaf.clone(),
                         module_name.clone(),
@@ -5556,7 +5556,7 @@ pub fn emit_qualified_value_ref_crate_ident(
         v1_rt::concat(
             v1_rt::concat(
                 "crate::".to_string(),
-                crate::v1_compiler_emit_core_support::module_to_filename(info.module_name.clone()),
+                crate::gunbc_rust_emitted_edge::module_to_filename(info.module_name.clone()),
             ),
             "::".to_string(),
         ),
@@ -5733,8 +5733,7 @@ pub fn rust_test_file_path(module_name: String) -> String {
             Some(dir) => dir.clone(),
             std::option::Option::None => "".to_string(),
         };
-        let filename =
-            crate::v1_compiler_emit_core_support::module_to_filename(module_name.clone());
+        let filename = crate::gunbc_rust_emitted_edge::module_to_filename(module_name.clone());
         v1_rt::concat(
             v1_rt::concat(
                 v1_rt::concat(
@@ -6666,7 +6665,7 @@ pub fn build_emit_rust_context(typed: Rc<ResolvedGraph>) -> Rc<EmitRustContext>
                     }
                     __result
                 });
-                let mod_filename = crate::v1_compiler_emit_core_support::module_to_filename(
+                let mod_filename = crate::gunbc_rust_emitted_edge::module_to_filename(
                     crate::v1_std_core::authored_name_at(
                         tm.type_env.clone().source_indices.clone(),
                         tm.module.clone(),
@@ -7153,22 +7152,11 @@ pub fn emit_rust_selected(
     }
 }
 
-pub fn rust_module_emit_filename(module_name: String) -> String {
-    {
-        let raw = crate::v1_compiler_emit_core_support::module_to_filename(module_name.clone());
-        if (raw.clone() == "main".to_string()) {
-            "main_mod".to_string()
-        } else {
-            raw.clone()
-        }
-    }
-}
-
 pub fn rust_module_emit_path(module_name: String) -> String {
     v1_rt::concat(
         v1_rt::concat(
             rust_source_root(),
-            rust_module_emit_filename(module_name.clone()),
+            crate::gunbc_rust_emitted_edge::rust_module_emit_filename(module_name.clone()),
         ),
         rust_source_ext(),
     )
@@ -7188,7 +7176,9 @@ pub fn rust_module_render_selection_renders(
             for b in basenames.iter().cloned() {
                 if (b.clone()
                     == v1_rt::concat(
-                        rust_module_emit_filename(module_name.clone()),
+                        crate::gunbc_rust_emitted_edge::rust_module_emit_filename(
+                            module_name.clone(),
+                        ),
                         rust_source_ext(),
                     ))
                 {
@@ -7377,7 +7367,7 @@ pub fn registry_declares_module_filename(
     {
         let mut __found = false;
         for info in Rc::new(v1_rt::map_values(&registry)).iter().cloned() {
-            if (crate::v1_compiler_emit_core_support::module_to_filename(info.module_name.clone())
+            if (crate::gunbc_rust_emitted_edge::module_to_filename(info.module_name.clone())
                 == filename.clone())
             {
                 __found = true;
@@ -7408,7 +7398,7 @@ pub fn closure_references_module_filename(
                     {
                         if match v1_rt::map_get(&ctx.registry.clone(), name.clone()) {
                             Some(info) => {
-                                (crate::v1_compiler_emit_core_support::module_to_filename(
+                                (crate::gunbc_rust_emitted_edge::module_to_filename(
                                     info.module_name.clone(),
                                 ) == filename.clone())
                             }
@@ -10327,15 +10317,15 @@ let plan_module_env = match v1_rt::map_get(&module_index.by_name.clone(), this_m
     Some(tm) => Some(tm.type_env.clone()),
     std::option::Option::None => std::option::Option::None,
 };
-let block_lines = emit_specific_import_use_lines(provider.clone(), crate::v1_compiler_emit_core_support::module_to_filename(provider.clone()), names.clone(), applied_type_argument_names.clone(), emit_info.clone(), registry.clone(), local_type_names.clone(), export_sets.clone(), typed_modules.clone(), source_indices.clone(), module_index.clone(), plan_module_env.clone());
+let block_lines = emit_specific_import_use_lines(provider.clone(), crate::gunbc_rust_emitted_edge::module_to_filename(provider.clone()), names.clone(), applied_type_argument_names.clone(), emit_info.clone(), registry.clone(), local_type_names.clone(), export_sets.clone(), typed_modules.clone(), source_indices.clone(), module_index.clone(), plan_module_env.clone());
 let emitted_here = Rc::new({ let mut __result = Vec::new(); for l in block_lines.iter().cloned() { __result.extend((*imported_names_in_use_line(l.text.clone())).iter().cloned()); } __result });
 let fallback = Rc::new({ let mut __result = Vec::new(); for nm in names.iter().cloned() { __result.extend((*if ({ let mut __found = false; for e in emitted_here.iter().cloned() { if (e.clone() == nm.clone()) { __found = true; break; } } __found } || (crate::v1_compiler_infer_emit_info::is_known_variant(emit_info.type_summaries.clone(), nm.clone()) && !crate::v1_compiler_infer_types::emit_map_has(type_position_set.clone(), nm.clone()))) {
                 Rc::new(vec![])
             } else {
                 if provider_proven_exports_symbol(nm.clone(), provider.clone(), export_sets.clone(), typed_modules.clone(), source_indices.clone(), module_index.clone()) {
                     Rc::new(vec![Rc::new(RustUseLine {
-    target_module: crate::v1_compiler_emit_core_support::module_to_filename(provider.clone()),
-    text: v1_rt::concat(rust_visibility_prefix(), v1_rt::concat("use crate::".to_string(), v1_rt::concat(crate::v1_compiler_emit_core_support::module_to_filename(provider.clone()), v1_rt::concat("::".to_string(), v1_rt::concat(emit_import_name(provider.clone(), nm.clone(), registry.clone()), ";".to_string()))))),
+    target_module: crate::gunbc_rust_emitted_edge::module_to_filename(provider.clone()),
+    text: v1_rt::concat(rust_visibility_prefix(), v1_rt::concat("use crate::".to_string(), v1_rt::concat(crate::gunbc_rust_emitted_edge::module_to_filename(provider.clone()), v1_rt::concat("::".to_string(), v1_rt::concat(emit_import_name(provider.clone(), nm.clone(), registry.clone()), ";".to_string()))))),
 })])
                 } else {
                     Rc::new(vec![])
@@ -10392,7 +10382,7 @@ v1_rt::concat(block_lines.clone(), fallback.clone())
         let qualified_lines =
             qualified_type_reference_use_lines(qualified_rows.clone(), registry.clone());
         let this_module_filename =
-            crate::v1_compiler_emit_core_support::module_to_filename(this_module_name.clone());
+            crate::gunbc_rust_emitted_edge::module_to_filename(this_module_name.clone());
         Rc::new(ReferenceDerivedUseLinePlan {
             lines: v1_rt::concat(
                 lines.clone(),
@@ -10599,13 +10589,43 @@ pub fn qualified_type_reference_use_lines(
         let typed = Rc::new({
             let mut __result = Vec::new();
             for r in rows.iter().cloned() {
-                __result.extend((*match (*r.disposition.clone()).clone() {
-    ReferenceDerivedCandidateDisposition::CandidateSurvived { provider_module: provider, .. } => Rc::new(vec![Rc::new(RustUseLine {
-    target_module: crate::v1_compiler_emit_core_support::module_to_filename(provider.clone()),
-    text: v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(rust_visibility_prefix(), "use crate::".to_string()), crate::v1_compiler_emit_core_support::module_to_filename(provider.clone())), "::".to_string()), emit_import_name(provider.clone(), crate::v1_std_core::qualified_last_segment(r.name.clone()), registry.clone())), ";".to_string()),
-})]),
-    _ => Rc::new(vec![]),
-}).iter().cloned());
+                __result.extend(
+                    (*match (*r.disposition.clone()).clone() {
+                        ReferenceDerivedCandidateDisposition::CandidateSurvived {
+                            provider_module: provider,
+                            ..
+                        } => Rc::new(vec![Rc::new(RustUseLine {
+                            target_module: crate::gunbc_rust_emitted_edge::module_to_filename(
+                                provider.clone(),
+                            ),
+                            text: v1_rt::concat(
+                                v1_rt::concat(
+                                    v1_rt::concat(
+                                        v1_rt::concat(
+                                            v1_rt::concat(
+                                                rust_visibility_prefix(),
+                                                "use crate::".to_string(),
+                                            ),
+                                            crate::gunbc_rust_emitted_edge::module_to_filename(
+                                                provider.clone(),
+                                            ),
+                                        ),
+                                        "::".to_string(),
+                                    ),
+                                    emit_import_name(
+                                        provider.clone(),
+                                        crate::v1_std_core::qualified_last_segment(r.name.clone()),
+                                        registry.clone(),
+                                    ),
+                                ),
+                                ";".to_string(),
+                            ),
+                        })]),
+                        _ => Rc::new(vec![]),
+                    })
+                    .iter()
+                    .cloned(),
+                );
             }
             __result
         });
@@ -10888,7 +10908,7 @@ pub fn emit_module_full(
             module_index.clone(),
             typed_module.items.clone(),
             Some(scope.type_env.clone()),
-            crate::v1_compiler_emit_core_support::module_to_filename(this_module_name.clone()),
+            crate::gunbc_rust_emitted_edge::module_to_filename(this_module_name.clone()),
         );
         let imports_str = rendered_imports.text.clone();
         let dag_import_lines = if (imports_str.clone() == "".to_string()) {
@@ -10950,7 +10970,7 @@ pub fn emit_module_full(
         } else {
             v1_rt::concat("\n".to_string(), merged_imports.clone())
         };
-        let this_mod_filename = crate::v1_compiler_emit_core_support::module_to_filename(
+        let this_mod_filename = crate::gunbc_rust_emitted_edge::module_to_filename(
             crate::v1_compiler_infer_env::authored_name(scope.type_env.clone(), m.clone()),
         );
         let all_svc_names = Rc::new({
@@ -11389,7 +11409,7 @@ pub fn is_import_graph_type_name(
 ) -> bool {
     if has_physical_type_def_in_module_filename(
         name.clone(),
-        crate::v1_compiler_emit_core_support::module_to_filename(import_module.clone()),
+        crate::gunbc_rust_emitted_edge::module_to_filename(import_module.clone()),
         typed_modules.clone(),
         source_indices.clone(),
         module_index.clone(),
@@ -11468,7 +11488,7 @@ pub fn item_defining_module_filename(
     match v1_rt::map_get(&module_index.leaf_owner_modules.clone(), name.clone()) {
         Some(owner) => match (*owner.clone()).clone() {
             LeafOwner::SingleOwner { module: m, .. } => {
-                crate::v1_compiler_emit_core_support::module_to_filename(m.clone())
+                crate::gunbc_rust_emitted_edge::module_to_filename(m.clone())
             }
             LeafOwner::LeafAmbiguous => ambiguous_leaf_module_refusal(name.clone()),
         },
@@ -11506,7 +11526,7 @@ pub fn build_module_index(
         let by_filename = modules.iter().cloned().fold(
             v1_rt::rc_empty_map::<String, Rc<Vec<Rc<TypedModule>>>>(),
             |acc: Rc<HashMap<String, Rc<Vec<Rc<TypedModule>>>>>, tm: Rc<TypedModule>| {
-                let fname = crate::v1_compiler_emit_core_support::module_to_filename(
+                let fname = crate::gunbc_rust_emitted_edge::module_to_filename(
                     crate::v1_std_core::authored_name_at(
                         tm.type_env.clone().source_indices.clone(),
                         tm.module.clone(),
@@ -12357,7 +12377,7 @@ pub fn graph_type_import_module_filename(
             source_indices.clone(),
             module_index.clone(),
         ) {
-            Some(src) => crate::v1_compiler_emit_core_support::module_to_filename(src.clone()),
+            Some(src) => crate::gunbc_rust_emitted_edge::module_to_filename(src.clone()),
             std::option::Option::None => mod_name.clone(),
         }
     }
@@ -12395,9 +12415,7 @@ pub fn variant_defining_module_filename_for_import(
             module_index.clone(),
         ) {
             Some(_parent) => {
-                break crate::v1_compiler_emit_core_support::module_to_filename(
-                    import_module.clone(),
-                );
+                break crate::gunbc_rust_emitted_edge::module_to_filename(import_module.clone());
             }
             std::option::Option::None => {
                 match explicit_import_source_module_for_name(
@@ -12460,7 +12478,7 @@ pub fn variant_parent_defining_module_filename(
     ) {
         Some(local_parent) => {
             if (local_parent.clone() == parent_enum.clone()) {
-                crate::v1_compiler_emit_core_support::module_to_filename(import_module.clone())
+                crate::gunbc_rust_emitted_edge::module_to_filename(import_module.clone())
             } else {
                 variant_defining_module_filename_for_import(
                     variant_name.clone(),
@@ -12747,9 +12765,7 @@ pub fn alias_rhs_rust_qualify_module_filename(
                     source_indices.clone(),
                     module_index.clone(),
                 ) {
-                    Some(src) => {
-                        crate::v1_compiler_emit_core_support::module_to_filename(src.clone())
-                    }
+                    Some(src) => crate::gunbc_rust_emitted_edge::module_to_filename(src.clone()),
                     std::option::Option::None => spell_mod.clone(),
                 },
                 std::option::Option::None => spell_mod.clone(),
@@ -12770,8 +12786,7 @@ pub fn alias_rhs_base_module_filename(
     module_index: Rc<ModuleIndex>,
 ) -> String {
     {
-        let local_mod =
-            crate::v1_compiler_emit_core_support::module_to_filename(alias_module.clone());
+        let local_mod = crate::gunbc_rust_emitted_edge::module_to_filename(alias_module.clone());
         let owner_info =
             match v1_rt::map_get(&module_index.leaf_owner_modules.clone(), name.clone()) {
                 Some(owner) => match (*owner.clone()).clone() {
@@ -12891,7 +12906,7 @@ pub fn alias_rhs_base_module_from_import_or_registry(
     .cloned()
     {
         Some(import_module) => {
-            crate::v1_compiler_emit_core_support::module_to_filename(import_module.clone())
+            crate::gunbc_rust_emitted_edge::module_to_filename(import_module.clone())
         }
         std::option::Option::None => match Rc::new({
             let mut __result = Vec::new();
@@ -12943,7 +12958,7 @@ pub fn alias_rhs_base_module_from_import_or_registry(
         .cloned()
         {
             Some(import_module) => {
-                crate::v1_compiler_emit_core_support::module_to_filename(import_module.clone())
+                crate::gunbc_rust_emitted_edge::module_to_filename(import_module.clone())
             }
             std::option::Option::None => {
                 item_defining_module_filename(name.clone(), module_index.clone(), local_mod.clone())
@@ -13195,52 +13210,54 @@ pub fn rhs_base_has_rust_type_authority_in_module(
                         source_indices.clone(),
                         module_index.clone(),
                     ) {
-                        Some(mod_name) => match v1_rt::map_get(&export_sets, mod_name.clone()) {
-                            Some(exported) => {
-                                if (v1_rt::map_get(&exported, rhs_name.clone()) == Some(true)) {
-                                    match reexport_source_module_name(
-                                        rhs_name.clone(),
-                                        mod_name.clone(),
-                                        typed_modules.clone(),
-                                        export_sets.clone(),
-                                        source_indices.clone(),
-                                        module_index.clone(),
-                                    ) {
-                                        Some(src) => {
-                                            let __tco_0 = rhs_name;
-                                            let __tco_1 = crate::v1_compiler_emit_core_support::module_to_filename(src.clone());
-                                            let __tco_2 = module_name;
-                                            let __tco_3 = imports;
-                                            let __tco_4 = scope;
-                                            let __tco_5 = registry;
-                                            let __tco_6 = typed_modules;
-                                            let __tco_7 = export_sets;
-                                            let __tco_8 = source_indices;
-                                            let __tco_9 = module_index;
-                                            __tco_loop_rhs_name = __tco_0;
-                                            __tco_loop_def_mod_filename = __tco_1;
-                                            __tco_loop_module_name = __tco_2;
-                                            __tco_loop_imports = __tco_3;
-                                            __tco_loop_scope = __tco_4;
-                                            __tco_loop_registry = __tco_5;
-                                            __tco_loop_typed_modules = __tco_6;
-                                            __tco_loop_export_sets = __tco_7;
-                                            __tco_loop_source_indices = __tco_8;
-                                            __tco_loop_module_index = __tco_9;
-                                            continue;
-                                        }
-                                        std::option::Option::None => {
-                                            break false;
+                        Some(mod_name) => {
+                            match v1_rt::map_get(&export_sets, mod_name.clone()) {
+                                Some(exported) => {
+                                    if (v1_rt::map_get(&exported, rhs_name.clone()) == Some(true)) {
+                                        match reexport_source_module_name(
+                                            rhs_name.clone(),
+                                            mod_name.clone(),
+                                            typed_modules.clone(),
+                                            export_sets.clone(),
+                                            source_indices.clone(),
+                                            module_index.clone(),
+                                        ) {
+                                            Some(src) => {
+                                                let __tco_0 = rhs_name;
+                                                let __tco_1 = crate::gunbc_rust_emitted_edge::module_to_filename(src.clone());
+                                                let __tco_2 = module_name;
+                                                let __tco_3 = imports;
+                                                let __tco_4 = scope;
+                                                let __tco_5 = registry;
+                                                let __tco_6 = typed_modules;
+                                                let __tco_7 = export_sets;
+                                                let __tco_8 = source_indices;
+                                                let __tco_9 = module_index;
+                                                __tco_loop_rhs_name = __tco_0;
+                                                __tco_loop_def_mod_filename = __tco_1;
+                                                __tco_loop_module_name = __tco_2;
+                                                __tco_loop_imports = __tco_3;
+                                                __tco_loop_scope = __tco_4;
+                                                __tco_loop_registry = __tco_5;
+                                                __tco_loop_typed_modules = __tco_6;
+                                                __tco_loop_export_sets = __tco_7;
+                                                __tco_loop_source_indices = __tco_8;
+                                                __tco_loop_module_index = __tco_9;
+                                                continue;
+                                            }
+                                            std::option::Option::None => {
+                                                break false;
+                                            }
                                         }
+                                    } else {
+                                        break false;
                                     }
-                                } else {
+                                }
+                                std::option::Option::None => {
                                     break false;
                                 }
                             }
-                            std::option::Option::None => {
-                                break false;
-                            }
-                        },
+                        }
                         std::option::Option::None => {
                             break false;
                         }
@@ -15241,7 +15258,7 @@ pub fn emit_imports(
                 for import_module in import_modules.iter().cloned() {
                     __result.push({
                 let mod_imports = Rc::new({ let mut __result = Vec::new(); for imp in imports.iter().cloned() { if (crate::v1_std_core::authored_name_at(source_indices.clone(), imp.clone()) == import_module.clone()) { __result.push(imp); } } __result });
-let mod_name = crate::v1_compiler_emit_core_support::module_to_filename(import_module.clone());
+let mod_name = crate::gunbc_rust_emitted_edge::module_to_filename(import_module.clone());
 let mod_has_wildcard = { let mut __found = false; for imp in mod_imports.iter().cloned() { if crate::v1_std_core::import_is_all(imp.clone()) { __found = true; break; } } __found };
 let block = if mod_has_wildcard.clone() {
                     {
@@ -15393,7 +15410,7 @@ pub fn typed_closure_includes_module_filename(
     {
         let mut __found = false;
         for tm in typed_modules.iter().cloned() {
-            if (crate::v1_compiler_emit_core_support::module_to_filename(
+            if (crate::gunbc_rust_emitted_edge::module_to_filename(
                 crate::v1_std_core::authored_name_at(source_indices.clone(), tm.module.clone()),
             ) == filename.clone())
             {
@@ -15408,7 +15425,7 @@ pub fn typed_closure_includes_module_filename(
 pub fn emit_prelude(module_name: String) -> String {
     {
         let edges = crate::gunbc_rust_emitted_edge::rust_prelude_emitted_edges(
-            crate::v1_compiler_emit_core_support::module_to_filename(module_name.clone()),
+            crate::gunbc_rust_emitted_edge::module_to_filename(module_name.clone()),
         );
         let runtime_modules = Rc::new({
             let mut __result = Vec::new();
@@ -25540,7 +25557,7 @@ pub fn emit_typed_call(
                             v1_rt::concat(
                                 v1_rt::concat(
                                     "crate::".to_string(),
-                                    crate::v1_compiler_emit_core_support::module_to_filename(
+                                    crate::gunbc_rust_emitted_edge::module_to_filename(
                                         owner.clone(),
                                     ),
                                 ),
@@ -25563,30 +25580,39 @@ pub fn emit_typed_call(
                     primitive_name: unbridged_primitive,
                     projected_from,
                     ..
-                } => {
-                    match projected_from.clone() {
-                        Some(declared) => {
-                            if (declared.owner_module_path.clone() == scope.module_name.clone()) {
+                } => match projected_from.clone() {
+                    Some(declared) => {
+                        if (declared.owner_module_path.clone() == scope.module_name.clone()) {
+                            crate::v1_compiler_emit::emit_ident(
+                                declared.decl_name.clone(),
+                                RenderTarget::Rust,
+                            )
+                        } else {
+                            v1_rt::concat(
+                                v1_rt::concat(
+                                    v1_rt::concat(
+                                        "crate::".to_string(),
+                                        crate::gunbc_rust_emitted_edge::module_to_filename(
+                                            declared.owner_module_path.clone(),
+                                        ),
+                                    ),
+                                    "::".to_string(),
+                                ),
                                 crate::v1_compiler_emit::emit_ident(
                                     declared.decl_name.clone(),
                                     RenderTarget::Rust,
-                                )
-                            } else {
-                                v1_rt::concat(v1_rt::concat(v1_rt::concat("crate::".to_string(), crate::v1_compiler_emit_core_support::module_to_filename(declared.owner_module_path.clone())), "::".to_string()), crate::v1_compiler_emit::emit_ident(declared.decl_name.clone(), RenderTarget::Rust))
-                            }
-                        }
-                        std::option::Option::None => crate::v1_compiler_emit::emit_error_expr(
-                            v1_rt::concat(
-                                v1_rt::concat(
-                                    "primitive ".to_string(),
-                                    unbridged_primitive.clone(),
                                 ),
-                                " has no v1_rt realization and no declaration to emit".to_string(),
-                            ),
-                            RenderTarget::Rust,
-                        ),
+                            )
+                        }
                     }
-                }
+                    std::option::Option::None => crate::v1_compiler_emit::emit_error_expr(
+                        v1_rt::concat(
+                            v1_rt::concat("primitive ".to_string(), unbridged_primitive.clone()),
+                            " has no v1_rt realization and no declaration to emit".to_string(),
+                        ),
+                        RenderTarget::Rust,
+                    ),
+                },
             }
         };
         let func_name = if callee_self_capture.clone() {
@@ -32743,7 +32769,7 @@ pub fn rust_declaration_path(module_path: String, decl_name: String) -> String {
         v1_rt::concat(
             v1_rt::concat(
                 "crate::".to_string(),
-                crate::v1_compiler_emit_core_support::module_to_filename(module_path.clone()),
+                crate::gunbc_rust_emitted_edge::module_to_filename(module_path.clone()),
             ),
             "::".to_string(),
         ),
@@ -32781,7 +32807,7 @@ pub fn emit_rust_structural_comparison(
             v1_rt::concat(
                 v1_rt::concat(
                     "crate::".to_string(),
-                    crate::v1_compiler_emit_core_support::module_to_filename(
+                    crate::gunbc_rust_emitted_edge::module_to_filename(
                         binding.ordering.clone().module_path.clone(),
                     ),
                 ),
@@ -38097,7 +38123,7 @@ pub fn emit_test_file(
         } else {
             {
                 let filename =
-                    crate::v1_compiler_emit_core_support::module_to_filename(module_name.clone());
+                    crate::gunbc_rust_emitted_edge::module_to_filename(module_name.clone());
                 let tests_str = test_fns.clone().join(&"\n\n".to_string());
                 let content = v1_rt::concat(
                     v1_rt::concat(
@@ -39100,9 +39126,9 @@ pub fn emit_main_rs(
 pub fn emit_retained_host_main_mod_uses(crate_name: String, pipeline_module: String) -> String {
     {
         let pipeline_mod =
-            crate::v1_compiler_emit_core_support::module_to_filename(pipeline_module.clone());
+            crate::gunbc_rust_emitted_edge::module_to_filename(pipeline_module.clone());
         let core_mod =
-            crate::v1_compiler_emit_core_support::module_to_filename("v1.std.core".to_string());
+            crate::gunbc_rust_emitted_edge::module_to_filename("v1.std.core".to_string());
         v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat("\nuse im::HashMap;\n".to_string(), "use std::rc::Rc;\n".to_string()), "use ".to_string()), crate_name.clone()), "::".to_string()), pipeline_mod.clone()), ";\n".to_string()), "use ".to_string()), crate_name.clone()), "::".to_string()), pipeline_mod.clone()), "::PipelineResult;\n".to_string()), "use ".to_string()), crate_name.clone()), "::".to_string()), core_mod.clone()), "::".to_string()), "{".to_string()), "\n    diagnostic_to_message, diagnostic_to_span,\n".to_string()), "    byte_to_line_col, source_line_at, NewlineIndex,\n".to_string()), "    CompilerDiagnostic,\n".to_string()), "}".to_string()), ";\n".to_string()), "use ".to_string()), crate_name.clone()), "::cli_run;\n".to_string())
     }
 }
@@ -39113,7 +39139,7 @@ pub fn emit_direct_ingest_driver_main_rs(
 ) -> Rc<TextFile> {
     {
         let pipeline_mod =
-            crate::v1_compiler_emit_core_support::module_to_filename(pipeline_module.clone());
+            crate::gunbc_rust_emitted_edge::module_to_filename(pipeline_module.clone());
         Rc::new(TextFile {
     path: v1_rt::concat(v1_rt::concat(rust_source_root(), "main".to_string()), rust_source_ext()),
     content: v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat("// Generated by v1 compiler -- do not edit.\n\n".to_string(), "#![allow(unused_parens, clippy::all, clippy::disallowed_macros)]\n\n".to_string()), "fn main() {\n".to_string()), "    let source_path = match std::env::args().nth(1) {\n".to_string()), "        Some(path) => path,\n".to_string()), "        None => { eprintln!(\"REFUSED: no source path given -- usage: ".to_string()), crate_name.clone()), " <source.dag>\"); std::process::exit(2); }\n".to_string()), "    };\n".to_string()), "    let source_text = match std::fs::read_to_string(&source_path) {\n".to_string()), "        Ok(text) => text,\n".to_string()), "        Err(cause) => { eprintln!(\"REFUSED: could not read {}: {}\", source_path, cause); std::process::exit(2); }\n".to_string()), "    };\n".to_string()), "    match &*".to_string()), crate_name.clone()), "::".to_string()), pipeline_mod.clone()), "::compile_dag_source_to_target_text(source_text) {\n".to_string()), "        ".to_string()), crate_name.clone()), "::v2_std_diagnostic::Outcome::Accepted { value, .. } => {\n".to_string()), "            print!(\"{}\", value.carried);\n".to_string()), "            std::process::exit(0);\n".to_string()), "        }\n".to_string()), "        ".to_string()), crate_name.clone()), "::v2_std_diagnostic::Outcome::Rejected { diagnostics } => {\n".to_string()), "            eprintln!(\"REFUSED: {} did not compile\", source_path);\n".to_string()), "            eprintln!(\"{:#?}\", diagnostics);\n".to_string()), "            std::process::exit(1);\n".to_string()), "        }\n".to_string()), "    }\n".to_string()), "}\n".to_string()),
@@ -39128,7 +39154,7 @@ pub fn emit_host_source_root_read_rs() -> String {
 pub fn emit_native_cli_driver_main_rs(crate_name: String, pipeline_module: String) -> Rc<TextFile> {
     {
         let pipeline_mod =
-            crate::v1_compiler_emit_core_support::module_to_filename(pipeline_module.clone());
+            crate::gunbc_rust_emitted_edge::module_to_filename(pipeline_module.clone());
         Rc::new(TextFile {
     path: v1_rt::concat(v1_rt::concat(rust_source_root(), "main".to_string()), rust_source_ext()),
     content: v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat("// Generated by v1 compiler -- do not edit.".to_string(), "\n".to_string()), "\n".to_string()), "#![allow(unused_parens, clippy::all, clippy::disallowed_macros)]".to_string()), "\n".to_string()), "\n".to_string()), "use std::rc::Rc;".to_string()), "\n".to_string()), "\n".to_string()), "use ".to_string()), crate_name.clone()), "::extdeps_communication_medium::{DecodeFidelity, Medium};".to_string()), "\n".to_string()), "use ".to_string()), crate_name.clone()), "::v2_compiler_source_authority::{source_root_for_storage_path, DagSourceReadWitness};".to_string()), "\n".to_string()), "use ".to_string()), crate_name.clone()), "::v2_std_artifact::{Artifact, ArtifactKind};".to_string()), "\n".to_string()), "use ".to_string()), crate_name.clone()), "::std_process::ProcessExit;".to_string()), "\n".to_string()), "use ".to_string()), crate_name.clone()), "::".to_string()), pipeline_mod.clone()), "::{".to_string()), "\n".to_string()), "    v2_cli_exit, v2_cli_outcome_text, v2_cli_parse, v2_cli_plan_source_roots, v2_cli_run,".to_string()), "\n".to_string()), "};".to_string()), "\n".to_string()), "\n".to_string()), emit_host_source_root_read_rs()), "fn main() {".to_string()), "\n".to_string()), "    let argv: Vec<String> = std::env::args().skip(1).collect();".to_string()), "\n".to_string()), "    let plan = v2_cli_parse(Rc::new(argv.into()));".to_string()), "\n".to_string()), "    let roots: Vec<String> = v2_cli_plan_source_roots(plan.clone()).iter().cloned().collect();".to_string()), "\n".to_string()), "    let reads = read_ingest(&roots);".to_string()), "\n".to_string()), "    let outcome = v2_cli_run(plan, Rc::new(reads.into()));".to_string()), "\n".to_string()), "    let text = v2_cli_outcome_text(outcome.clone());".to_string()), "\n".to_string()), "    match &*v2_cli_exit(outcome) {".to_string()), "\n".to_string()), "        ProcessExit::ExitSuccess => {".to_string()), "\n".to_string()), "            print!(\"{text}\");".to_string()), "\n".to_string()), "            std::process::exit(0);".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "        ProcessExit::ExitFailure { code, reason } => {".to_string()), "\n".to_string()), "            eprintln!(\"REFUSED: {reason}\");".to_string()), "\n".to_string()), "            std::process::exit(*code as i32);".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "}".to_string()), "\n".to_string()),
@@ -39142,7 +39168,7 @@ pub fn emit_source_root_eval_driver_main_rs(
 ) -> Rc<TextFile> {
     {
         let pipeline_mod =
-            crate::v1_compiler_emit_core_support::module_to_filename(pipeline_module.clone());
+            crate::gunbc_rust_emitted_edge::module_to_filename(pipeline_module.clone());
         Rc::new(TextFile {
     path: v1_rt::concat(v1_rt::concat(rust_source_root(), "main".to_string()), rust_source_ext()),
     content: v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat("// Generated by v1 compiler -- do not edit.".to_string(), "\n".to_string()), "\n".to_string()), "#![allow(unused_parens, clippy::all, clippy::disallowed_macros)]".to_string()), "\n".to_string()), "\n".to_string()), "use std::rc::Rc;".to_string()), "\n".to_string()), "use std::time::Instant;".to_string()), "\n".to_string()), "\n".to_string()), "use ".to_string()), crate_name.clone()), "::extdeps_communication_medium::{DecodeFidelity, Medium};".to_string()), "\n".to_string()), "use ".to_string()), crate_name.clone()), "::gunbc_witness_v2_native_route::{NativeRouteEmittedBuild, NativeRouteMalformedControl, NativeRouteOldRouteControl};".to_string()), "\n".to_string()), "use ".to_string()), crate_name.clone()), "::".to_string()), pipeline_mod.clone()), "::{".to_string()), "\n".to_string()), "    native_census_module_completeness, native_census_module_resolution, native_census_modules,".to_string()), "\n".to_string()), "    native_census_residual_rows,".to_string()), "\n".to_string()), "    native_lane_controls, native_lane_file_refusal_index, native_lane_identity_row,".to_string()), "\n".to_string()), "    native_lane_module_inference,".to_string()), "\n".to_string()), "    native_lane_module_resolution,".to_string()), "\n".to_string()), "    native_lane_closure_ingest, native_lane_closure_modules, native_lane_closure_round_budget,".to_string()), "\n".to_string()), "    native_lane_ingest_matches_closure, native_lane_ingest_receipt, native_lane_receipt,".to_string()), "\n".to_string()), "    native_lane_source_facts, native_lane_universe_of_facts, native_test_context_absorb,".to_string()), "\n".to_string()), "    native_test_context_finish, native_test_context_from_ingest, native_test_context_state_empty,".to_string()), "\n".to_string()), "    native_test_front_end_prepare,".to_string()), "\n".to_string()), "    native_driver_parse, native_driver_plan_exit, native_driver_plan_source_roots,".to_string()), "\n".to_string()), "    NativeDriverPlan, NativeDriverVerb,".to_string()), "\n".to_string()), "    NativeCensusModuleOutcome,".to_string()), "\n".to_string()), "    NativeLaneHostFacts, NativeLaneModulePreparation, NativeLaneModuleResolution,".to_string()), "\n".to_string()), "    NativeRouteMemberRow,".to_string()), "\n".to_string()), "};".to_string()), "\n".to_string()), "use ".to_string()), crate_name.clone()), "::v2_compiler_program_assembly::{".to_string()), "\n".to_string()), "    program_assembly_measured_outcome, program_assembly_memo_hits,".to_string()), "\n".to_string()), "    program_assembly_memo_lookup_calls, program_assembly_memo_misses,".to_string()), "\n".to_string()), "    program_assembly_allocator_next, program_assembly_measured_alloc,".to_string()), "\n".to_string()), "    program_assembly_phase_normalize,".to_string()), "\n".to_string()), "    program_assembly_phase_parse_measured_seeded,".to_string()), "\n".to_string()), "    program_assembly_phase_token_count, program_assembly_phase_tokenize,".to_string()), "\n".to_string()), "};".to_string()), "\n".to_string()), "use ".to_string()), crate_name.clone()), "::gunbc_witness_v2_native_route::{".to_string()), "\n".to_string()), "    native_route_admission, native_route_admission_summary, native_route_admitted,".to_string()), "\n".to_string()), "    native_route_file_refusal_tally, native_route_member_row_text,".to_string()), "\n".to_string()), "};".to_string()), "\n".to_string()), "use ".to_string()), crate_name.clone()), "::v2_compiler_native_test_vocabulary::NativeTestVerdict;".to_string()), "\n".to_string()), "use ".to_string()), crate_name.clone()), "::v2_compiler_source_authority::{source_root_for_storage_path, DagSourceReadWitness};".to_string()), "\n".to_string()), "use ".to_string()), crate_name.clone()), "::v2_std_artifact::{Artifact, ArtifactKind};".to_string()), "\n".to_string()), "use ".to_string()), crate_name.clone()), "::v2_std_diagnostic::Outcome;".to_string()), "\n".to_string()), "use ".to_string()), crate_name.clone()), "::std_process::ProcessExit;".to_string()), "\n".to_string()), "use ".to_string()), crate_name.clone()), "::extdeps_bazel_target_pattern::TargetPattern;".to_string()), "\n".to_string()), "use ".to_string()), crate_name.clone()), "::std_compiler_entry::{".to_string()), "\n".to_string()), "    native_driver_cost_account, native_driver_cost_remainder_tolerance_nanos,".to_string()), "\n".to_string()), "    native_driver_exclusive_sum, NativeDriverCostAccounting,".to_string()), "\n".to_string()), "    native_driver_exclusive_rows, native_driver_exclusive_row_name,".to_string()), "\n".to_string()), "    NativeDriverExclusiveRowKey,".to_string()), "\n".to_string()), "};".to_string()), "\n".to_string()), "use ".to_string()), crate_name.clone()), "::std_measure::{nanosecond, nanosecond_count};".to_string()), "\n".to_string()), "\n".to_string()), emit_host_source_root_read_rs()), "fn host_fact(facts: &std::collections::HashMap<String, String>, key: &str) -> String {".to_string()), "\n".to_string()), "    match facts.get(key) {".to_string()), "\n".to_string()), "        Some(value) => value.clone(),".to_string()), "\n".to_string()), "        None => {".to_string()), "\n".to_string()), "            eprintln!(\"REFUSED: host facts file carries no {key} row\");".to_string()), "\n".to_string()), "            std::process::exit(2);".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "}".to_string()), "\n".to_string()), "\n".to_string()), "fn host_fact_int(facts: &std::collections::HashMap<String, String>, key: &str) -> i64 {".to_string()), "\n".to_string()), "    let value = host_fact(facts, key);".to_string()), "\n".to_string()), "    match value.parse::<i64>() {".to_string()), "\n".to_string()), "        Ok(parsed) => parsed,".to_string()), "\n".to_string()), "        Err(cause) => {".to_string()), "\n".to_string()), "            eprintln!(\"REFUSED: host fact {key} is not an integer: {value:?} ({cause})\");".to_string()), "\n".to_string()), "            std::process::exit(2);".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "}".to_string()), "\n".to_string()), "\n".to_string()), "fn read_host_facts(path: &str) -> NativeLaneHostFacts {".to_string()), "\n".to_string()), "    let text = match std::fs::read_to_string(path) {".to_string()), "\n".to_string()), "        Ok(text) => text,".to_string()), "\n".to_string()), "        Err(cause) => {".to_string()), "\n".to_string()), "            eprintln!(\"REFUSED: could not read host facts file {path}: {cause}\");".to_string()), "\n".to_string()), "            std::process::exit(2);".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "    };".to_string()), "\n".to_string()), "    let mut facts: std::collections::HashMap<String, String> = std::collections::HashMap::new();".to_string()), "\n".to_string()), "    for line in text.lines() {".to_string()), "\n".to_string()), "        if line.is_empty() {".to_string()), "\n".to_string()), "            continue;".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "        match line.split_once('\\t') {".to_string()), "\n".to_string()), "            Some((key, value)) if !key.is_empty() => {".to_string()), "\n".to_string()), "                if facts.insert(key.to_string(), value.to_string()).is_some() {".to_string()), "\n".to_string()), "                    eprintln!(\"REFUSED: duplicate host fact row: {key}\");".to_string()), "\n".to_string()), "                    std::process::exit(2);".to_string()), "\n".to_string()), "                }".to_string()), "\n".to_string()), "            }".to_string()), "\n".to_string()), "            _ => {".to_string()), "\n".to_string()), "                eprintln!(\"REFUSED: malformed host fact line (expected key<TAB>value): {line}\");".to_string()), "\n".to_string()), "                std::process::exit(2);".to_string()), "\n".to_string()), "            }".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "    let malformed_path = host_fact(&facts, \"malformed_control_path\");".to_string()), "\n".to_string()), "    let malformed_reason = host_fact(&facts, \"malformed_control_reason\");".to_string()), "\n".to_string()), "    let malformed_control = if malformed_path.is_empty() {".to_string()), "\n".to_string()), "        NativeRouteMalformedControl::MalformedSpecimenAccepted".to_string()), "\n".to_string()), "    } else {".to_string()), "\n".to_string()), "        NativeRouteMalformedControl::MalformedSpecimenRefused {".to_string()), "\n".to_string()), "            path: malformed_path,".to_string()), "\n".to_string()), "            reason: malformed_reason,".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "    };".to_string()), "\n".to_string()), "    let old_route_disposition = host_fact(&facts, \"old_route_disposition\");".to_string()), "\n".to_string()), "    let old_route_executable = host_fact(&facts, \"old_route_executable\");".to_string()), "\n".to_string()), "    let old_route_control = match old_route_disposition.as_str() {".to_string()), "\n".to_string()), "        \"withdrawn\" => NativeRouteOldRouteControl::OldRouteWithdrawn {".to_string()), "\n".to_string()), "            withdrawn_executable: old_route_executable,".to_string()), "\n".to_string()), "        },".to_string()), "\n".to_string()), "        \"not_present_at_window\" => NativeRouteOldRouteControl::OldRouteNotPresentAtWindow {".to_string()), "\n".to_string()), "            expected_executable: old_route_executable,".to_string()), "\n".to_string()), "        },".to_string()), "\n".to_string()), "        other => {".to_string()), "\n".to_string()), "            eprintln!(\"REFUSED: old_route_disposition names no control this route can record: {other} -- expected withdrawn or not_present_at_window\");".to_string()), "\n".to_string()), "            std::process::exit(2);".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "    };".to_string()), "\n".to_string()), "    // The emitted build is the host's observation of the cargo spawn this binary is the".to_string()), "\n".to_string()), "    // product of: six rows, the argv as one row per word under a length row. A count that".to_string()), "\n".to_string()), "    // does not parse, or an index row it promises that is missing, refuses like any other".to_string()), "\n".to_string()), "    // missing fact; nothing is defaulted.".to_string()), "\n".to_string()), "    let cargo_argv_len = host_fact_int(&facts, \"cargo_argv_len\");".to_string()), "\n".to_string()), "    let mut cargo_argv: Vec<String> = Vec::new();".to_string()), "\n".to_string()), "    for index in 0..cargo_argv_len {".to_string()), "\n".to_string()), "        cargo_argv.push(host_fact(&facts, &format!(\"cargo_argv_{index}\")));".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "    let emitted_build = NativeRouteEmittedBuild {".to_string()), "\n".to_string()), "        cargo_argv: Rc::new(cargo_argv.into()),".to_string()), "\n".to_string()), "        rustflags: host_fact(&facts, \"rustflags\"),".to_string()), "\n".to_string()), "        compiler_path: host_fact(&facts, \"compiler_path\"),".to_string()), "\n".to_string()), "        rustc_identity: host_fact(&facts, \"rustc_identity\"),".to_string()), "\n".to_string()), "        exit_status: host_fact_int(&facts, \"exit_status\"),".to_string()), "\n".to_string()), "        warning_count: host_fact_int(&facts, \"warning_count\"),".to_string()), "\n".to_string()), "    };".to_string()), "\n".to_string()), "    NativeLaneHostFacts {".to_string()), "\n".to_string()), "        tested_tree: host_fact(&facts, \"tested_tree\"),".to_string()), "\n".to_string()), "        preparation_seed_identity: host_fact(&facts, \"preparation_seed_identity\"),".to_string()), "\n".to_string()), "        emitted_closure_identity: host_fact(&facts, \"emitted_closure_identity\"),".to_string()), "\n".to_string()), "        executable_path: host_fact(&facts, \"executable_path\"),".to_string()), "\n".to_string()), "        executable_identity: host_fact(&facts, \"executable_identity\"),".to_string()), "\n".to_string()), "        old_route_control: Rc::new(old_route_control),".to_string()), "\n".to_string()), "        malformed_control: Rc::new(malformed_control),".to_string()), "\n".to_string()), "        emitted_build: Rc::new(emitted_build),".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "}".to_string()), "\n".to_string()), "\n".to_string()), "fn run_census(source_roots: &[String]) {".to_string()), "\n".to_string()), "    if source_roots.is_empty() {".to_string()), "\n".to_string()), "        eprintln!(\"REFUSED: no source roots given\");".to_string()), "\n".to_string()), "        std::process::exit(2);".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "    let reads = read_ingest(source_roots);".to_string()), "\n".to_string()), "    let context = match &*native_test_context_from_ingest(Rc::new(reads.into())) {".to_string()), "\n".to_string()), "        Outcome::Accepted { value, .. } => value.clone(),".to_string()), "\n".to_string()), "        Outcome::Rejected { diagnostics } => {".to_string()), "\n".to_string()), "            eprintln!(\"CONTEXT-REFUSED: {diagnostics:#?}\");".to_string()), "\n".to_string()), "            std::process::exit(1);".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "    };".to_string()), "\n".to_string()), "    for refusal in context.file_refusals.iter() {".to_string()), "\n".to_string()), "        println!(\"{}\", serde_json::json!({ \"file_refusal\": refusal }));".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "    println!(\"{}\", serde_json::json!({ \"_terminal\": \"complete\", \"mode\": \"census\", \"file_refusals\": context.file_refusals.len() }));".to_string()), "\n".to_string()), "}".to_string()), "\n".to_string()), "\n".to_string()), "// THE THIRD MODE: THE WHOLE TREE, RESOLVED PER MODULE.".to_string()), "\n".to_string()), "//".to_string()), "\n".to_string()), "// WHY IT IS NOT A FLAG ON `census`. That mode has a live consumer -- the malformed control,".to_string()), "\n".to_string()), "// which the host runner spawns over a ONE-FILE scratch root and reads one per-file refusal".to_string()), "\n".to_string()), "// from -- and teaching it to resolve would make that control pay a whole-tree resolve to".to_string()), "\n".to_string()), "// learn a fact the front end already answered. Two modes because they are two subjects: a".to_string()), "\n".to_string()), "// roster of front-end refusals, and a roster of resolve refusals over every ingested module.".to_string()), "\n".to_string()), "//".to_string()), "\n".to_string()), "// WHY IT IS NOT THE `adjudicate` LOOP WIDENED. That loop walks `universe.modules` -- the".to_string()), "\n".to_string()), "// v2.test.* modules discovery enrolled rows for -- over a context folded from the import".to_string()), "\n".to_string()), "// CLOSURE of those modules. Both narrowings are correct for what adjudication asks and wrong".to_string()), "\n".to_string()), "// for a census: a residual reported over the closure of the test corpus is not a residual over".to_string()), "\n".to_string()), "// the tree, and the absence of a refusal in a population that was never resolved establishes".to_string()), "\n".to_string()), "// nothing about the dependents outside it.".to_string()), "\n".to_string()), "//".to_string()), "\n".to_string()), "// THE RESOLVED TREE IS NOT KEPT. NativeCensusModuleOutcome carries the diagnostics of a refusal".to_string()), "\n".to_string()), "// and nothing on the accepted arm, so each module's tree dies with the call that made it. The".to_string()), "\n".to_string()), "// adjudicating loop drops its tree explicitly because it must hold one to infer from; this loop".to_string()), "\n".to_string()), "// never holds one, which is the property that makes the whole-tree grain affordable at all.".to_string()), "\n".to_string()), "fn run_census_resolve(source_roots: &[String]) {".to_string()), "\n".to_string()), "    if source_roots.is_empty() {".to_string()), "\n".to_string()), "        eprintln!(\"REFUSED: no source roots given\");".to_string()), "\n".to_string()), "        std::process::exit(2);".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "    let load_started = Instant::now();".to_string()), "\n".to_string()), "    let reads = read_ingest(source_roots);".to_string()), "\n".to_string()), "    let corpus_reads = reads.len();".to_string()), "\n".to_string()), "    let ingest = Rc::new(im::vector::Vector::from(reads));".to_string()), "\n".to_string()), "    let load_nanos = span_nanos(load_started);".to_string()), "\n".to_string()), "    let context_started = Instant::now();".to_string()), "\n".to_string()), "    let context = match &*native_test_context_from_ingest(ingest.clone()) {".to_string()), "\n".to_string()), "        Outcome::Accepted { value, .. } => value.clone(),".to_string()), "\n".to_string()), "        Outcome::Rejected { diagnostics } => {".to_string()), "\n".to_string()), "            eprintln!(\"CONTEXT-REFUSED: {diagnostics:#?}\");".to_string()), "\n".to_string()), "            std::process::exit(1);".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "    };".to_string()), "\n".to_string()), "    let context_nanos = span_nanos(context_started);".to_string()), "\n".to_string()), "    // The front-end refusals are reported in the same shape `census` reports them, because they".to_string()), "\n".to_string()), "    // are the same fact read from the same context: a module whose file the context refused is".to_string()), "\n".to_string()), "    // attributed there and is NOT re-reported below as a resolve refusal it never reached.".to_string()), "\n".to_string()), "    for refusal in context.file_refusals.iter() {".to_string()), "\n".to_string()), "        println!(\"{}\", serde_json::json!({ \"file_refusal\": refusal }));".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "    let refusal_index = native_lane_file_refusal_index(context.file_refusals.clone());".to_string()), "\n".to_string()), "    let roster_started = Instant::now();".to_string()), "\n".to_string()), "    let modules = native_census_modules(ingest.clone());".to_string()), "\n".to_string()), "    let roster_nanos = span_nanos(roster_started);".to_string()), "\n".to_string()), "    let mut resolve_total_nanos: u128 = 0;".to_string()), "\n".to_string()), "    let mut resolve_samples: Vec<u128> = Vec::new();".to_string()), "\n".to_string()), "    let mut resolved_ok: u64 = 0;".to_string()), "\n".to_string()), "    let mut file_refused: u64 = 0;".to_string()), "\n".to_string()), "    let mut resolve_refused: u64 = 0;".to_string()), "\n".to_string()), "    let mut residual_rows: u64 = 0;".to_string()), "\n".to_string()), "    for entry in modules.iter() {".to_string()), "\n".to_string()), "        let resolve_started = Instant::now();".to_string()), "\n".to_string()), "        let outcome = native_census_module_resolution(".to_string()), "\n".to_string()), "            context.clone(),".to_string()), "\n".to_string()), "            refusal_index.clone(),".to_string()), "\n".to_string()), "            entry.clone(),".to_string()), "\n".to_string()), "        );".to_string()), "\n".to_string()), "        let module_resolve_nanos = span_nanos(resolve_started);".to_string()), "\n".to_string()), "        let outcome_label = match &*outcome {".to_string()), "\n".to_string()), "            NativeCensusModuleOutcome::NativeCensusModuleFileRefused => {".to_string()), "\n".to_string()), "                file_refused += 1;".to_string()), "\n".to_string()), "                \"file_refused\"".to_string()), "\n".to_string()), "            }".to_string()), "\n".to_string()), "            NativeCensusModuleOutcome::NativeCensusModuleResolved => {".to_string()), "\n".to_string()), "                resolved_ok += 1;".to_string()), "\n".to_string()), "                \"resolved\"".to_string()), "\n".to_string()), "            }".to_string()), "\n".to_string()), "            NativeCensusModuleOutcome::NativeCensusModuleResolveRefused { first, rest, .. } => {".to_string()), "\n".to_string()), "                resolve_refused += 1;".to_string()), "\n".to_string()), "                // ONE ROW PER FAILURE CHAIN, WHICH IS ONE ROW PER REFUSED OCCURRENCE. The rows are".to_string()), "\n".to_string()), "                // written as they are decided rather than accumulated: the census is over the".to_string()), "\n".to_string()), "                // whole tree, and a population held to the end is a second corpus-sized".to_string()), "\n".to_string()), "                // allocation beside the context that produced it.".to_string()), "\n".to_string()), "                for row in native_census_residual_rows(entry.clone(), first.clone(), rest.clone()).iter() {".to_string()), "\n".to_string()), "                    residual_rows += 1;".to_string()), "\n".to_string()), "                    println!(\"{}\", serde_json::json!({ \"census_residual\": row }));".to_string()), "\n".to_string()), "                }".to_string()), "\n".to_string()), "                \"resolve_refused\"".to_string()), "\n".to_string()), "            }".to_string()), "\n".to_string()), "        };".to_string()), "\n".to_string()), "        resolve_total_nanos += module_resolve_nanos;".to_string()), "\n".to_string()), "        resolve_samples.push(module_resolve_nanos);".to_string()), "\n".to_string()), "        eprintln!(".to_string()), "\n".to_string()), "            \"[native-census-resolve] {}\",".to_string()), "\n".to_string()), "            serde_json::json!({".to_string()), "\n".to_string()), "                \"producer\": \"std.compiler_entry.SourceRootEvalDriver\",".to_string()), "\n".to_string()), "                \"module\": entry.module.clone(),".to_string()), "\n".to_string()), "                \"path\": entry.path.clone(),".to_string()), "\n".to_string()), "                \"resolve_nanos\": module_resolve_nanos,".to_string()), "\n".to_string()), "                \"outcome\": outcome_label,".to_string()), "\n".to_string()), "                \"occurrence_completeness\": native_census_module_completeness(outcome.clone()),".to_string()), "\n".to_string()), "            }),".to_string()), "\n".to_string()), "        );".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "    resolve_samples.sort_unstable();".to_string()), "\n".to_string()), "    // THE TERMINAL LINE CARRIES THE COST AND THE POPULATION TOGETHER, because the reading this".to_string()), "\n".to_string()), "    // mode exists to support is whether a whole-tree resolve is affordable at all, and a residual".to_string()), "\n".to_string()), "    // count without the wall and the peak beside it cannot answer that.".to_string()), "\n".to_string()), "    println!(".to_string()), "\n".to_string()), "        \"{}\",".to_string()), "\n".to_string()), "        serde_json::json!({".to_string()), "\n".to_string()), "            \"_terminal\": \"complete\",".to_string()), "\n".to_string()), "            \"mode\": \"census-resolve\",".to_string()), "\n".to_string()), "            \"corpus_reads\": corpus_reads,".to_string()), "\n".to_string()), "            \"modules\": modules.len(),".to_string()), "\n".to_string()), "            \"file_refusals\": context.file_refusals.len(),".to_string()), "\n".to_string()), "            \"resolved\": resolved_ok,".to_string()), "\n".to_string()), "            \"file_refused\": file_refused,".to_string()), "\n".to_string()), "            \"resolve_refused\": resolve_refused,".to_string()), "\n".to_string()), "            \"residual_rows\": residual_rows,".to_string()), "\n".to_string()), "            \"load_nanos\": load_nanos,".to_string()), "\n".to_string()), "            \"context_nanos\": context_nanos,".to_string()), "\n".to_string()), "            \"roster_nanos\": roster_nanos,".to_string()), "\n".to_string()), "            \"resolve_total_nanos\": resolve_total_nanos,".to_string()), "\n".to_string()), "            \"resolve_p50_nanos\": native_cost_quantile_nanos(&resolve_samples, 1, 2),".to_string()), "\n".to_string()), "            \"resolve_p95_nanos\": native_cost_quantile_nanos(&resolve_samples, 19, 20),".to_string()), "\n".to_string()), "            \"resolve_max_nanos\": resolve_samples.last().copied().unwrap_or(0),".to_string()), "\n".to_string()), "            \"peak_rss_bytes\": proc_status_kib(\"VmHWM\").map(|kib| kib * 1024),".to_string()), "\n".to_string()), "        }),".to_string()), "\n".to_string()), "    );".to_string()), "\n".to_string()), "}".to_string()), "\n".to_string()), "\n".to_string()), "fn native_cost_quantile_nanos(sorted: &[u128], numer: usize, denom: usize) -> u128 {".to_string()), "\n".to_string()), "    if sorted.is_empty() { return 0; }".to_string()), "\n".to_string()), "    let idx = (sorted.len() - 1) * numer / denom;".to_string()), "\n".to_string()), "    sorted[idx]".to_string()), "\n".to_string()), "}".to_string()), "\n".to_string()), "".to_string()), "\n".to_string()), "// A SPAN IS READ ONCE, THROUGH A READER THAT REFUSES A CLOCK THAT WENT BACKWARDS.".to_string()), "\n".to_string()), "// Instant::elapsed is Instant::now().duration_since(earlier), and duration_since SATURATES:".to_string()), "\n".to_string()), "// a monotonic clock that is not actually monotonic -- which happens on some virtualised and".to_string()), "\n".to_string()), "// migrated hosts -- yields Duration::ZERO rather than an error. That is the fabricated zero".to_string()), "\n".to_string()), "// this receipt forbids, arriving by a quieter route than the saturating_sub it replaced: a".to_string()), "\n".to_string()), "// phase would report as having taken no time and the partition would balance for the wrong".to_string()), "\n".to_string()), "// reason. checked_duration_since returns None instead, so the impossible reading is".to_string()), "\n".to_string()), "// REPRESENTABLE and can be refused.".to_string()), "\n".to_string()), "//".to_string()), "\n".to_string()), "// AN EARLIER REVISION OF THIS FILE CLAIMED THE CLASS WAS STRUCTURALLY IMPOSSIBLE ONCE THE".to_string()), "\n".to_string()), "// subtraction was gone. That was wrong and is corrected rather than softened: deleting the".to_string()), "\n".to_string()), "// explicit subtraction removed the visible clamp, not the saturation underneath it. The".to_string()), "\n".to_string()), "// honest rung is MITIGATED BY A TYPED REFUSAL at a declared boundary -- the host clock is".to_string()), "\n".to_string()), "// external reality, which DESIGN section 4b keeps off the ladder rather than on its top rung.".to_string()), "\n".to_string()), "fn span_nanos(started: Instant) -> u128 {".to_string()), "\n".to_string()), "    match Instant::now().checked_duration_since(started) {".to_string()), "\n".to_string()), "        Some(d) => d.as_nanos(),".to_string()), "\n".to_string()), "        None => {".to_string()), "\n".to_string()), "            eprintln!(\"REFUSED: the monotonic clock went backwards between two reads, so no span is measurable\");".to_string()), "\n".to_string()), "            std::process::exit(2);".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "}".to_string()), "\n".to_string()), "".to_string()), "\n".to_string()), "// A SPAN THAT DOES NOT FIT REFUSES RATHER THAN SATURATING (review 64474 control). This was".to_string()), "\n".to_string()), "// i64::try_from(n).unwrap_or(i64::MAX), which turns a failed conversion into a FIGURE -- and a".to_string()), "\n".to_string()), "// fabricated figure on a receipt is the state DESIGN section 5 forbids outright, whether the".to_string()), "\n".to_string()), "// invented number is a zero that reports a phase as instant or a maximum that reports it as".to_string()), "\n".to_string()), "// three centuries. The saturating arm also chose the direction that hides best: i64::MAX would".to_string()), "\n".to_string()), "// push the exclusive sum past the parent and surface as NativeDriverCostOverAttributed, a cost".to_string()), "\n".to_string()), "// verdict naming the wrong cause.".to_string()), "\n".to_string()), "//".to_string()), "\n".to_string()), "// ON REACHABILITY, STATED RATHER THAN LEFT AS AN IMPLIED CLAIM: i64 nanoseconds is about 292".to_string()), "\n".to_string()), "// years, so no span this driver measures reaches it, and the refusal below is not expected to".to_string()), "\n".to_string()), "// fire. It is written because the alternative is not silence but a LIE -- the arm has to answer".to_string()), "\n".to_string()), "// something, and the only honest answers are a real number or a refusal.".to_string()), "\n".to_string()), "fn native_cost_i64(n: u128) -> i64 {".to_string()), "\n".to_string()), "    match i64::try_from(n) {".to_string()), "\n".to_string()), "        Ok(v) => v,".to_string()), "\n".to_string()), "        Err(cause) => {".to_string()), "\n".to_string()), "            eprintln!(\"REFUSED: a measured span does not fit the cost carrier, so no partition can be reported: {n} ({cause})\");".to_string()), "\n".to_string()), "            std::process::exit(2);".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "}".to_string()), "\n".to_string()), "".to_string()), "\n".to_string()), "// AN UNREADABLE /proc IS ABSENT, NOT ZERO (review 64181). A zero here was printed as".to_string()), "\n".to_string()), "// peak_rss_bytes / rss_bytes and read as a measurement: a run on a host without /proc, or with".to_string()), "\n".to_string()), "// the key renamed, reported a process using no memory. Absence is carried as None and rendered".to_string()), "\n".to_string()), "// as JSON null, so the receipt says it does not know instead of inventing a figure. This is".to_string()), "\n".to_string()), "// telemetry on no receipt field, so it is the one place an Absent is carried rather than".to_string()), "\n".to_string()), "// refused: the run is still a valid observation of everything else.".to_string()), "\n".to_string()), "fn proc_status_kib(key: &str) -> Option<u64> {".to_string()), "\n".to_string()), "    let text = std::fs::read_to_string(\"/proc/self/status\").ok()?;".to_string()), "\n".to_string()), "    for line in text.lines() {".to_string()), "\n".to_string()), "        if let Some(rest) = line.strip_prefix(key) {".to_string()), "\n".to_string()), "            return rest".to_string()), "\n".to_string()), "                .trim_start_matches(':')".to_string()), "\n".to_string()), "                .trim()".to_string()), "\n".to_string()), "                .split_whitespace()".to_string()), "\n".to_string()), "                .next()".to_string()), "\n".to_string()), "                .and_then(|n| n.parse::<u64>().ok());".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "    None".to_string()), "\n".to_string()), "}".to_string()), "\n".to_string()), "".to_string()), "\n".to_string()), "// ONE CLOCK, AND IT IS THE MONOTONIC ONE (review 64474). Every exclusive phase span and the".to_string()), "\n".to_string()), "// parent span are read from Instant, so the partition compares readings from a single source.".to_string()), "\n".to_string()), "// They were split before this: the parent came from Instant while the phase spans came from".to_string()), "\n".to_string()), "// SystemTime, which is the wall clock and is free to step backwards under NTP or an operator".to_string()), "\n".to_string()), "// adjustment. A step between two phase reads could then push the exclusive sum past a parent".to_string()), "\n".to_string()), "// span that never moved, and the driver would refuse with NativeDriverCostOverAttributed --".to_string()), "\n".to_string()), "// a cost refusal whose real cause was the clock. That is a fabricated attribution: the numbers".to_string()), "\n".to_string()), "// would be wrong while the receipt read as a measurement.".to_string()), "\n".to_string()), "//".to_string()), "\n".to_string()), "// THE SUBTRACTION IS GONE RATHER THAN GUARDED, which is the point. A span used to be an".to_string()), "\n".to_string()), "// explicit saturating_sub of two readings, so a backwards step clamped the difference to zero".to_string()), "\n".to_string()), "// and reported a phase as having taken NO TIME -- the exact state the annotation beside it".to_string()), "\n".to_string()), "// forbade, reached by the arm meant to prevent it. Instant::elapsed cannot return a negative".to_string()), "\n".to_string()), "// duration, so there is no difference to clamp and no clamp to review: DESIGN section 5".to_string()), "\n".to_string()), "// construction over validation, and the class climbs from mitigated to structurally".to_string()), "\n".to_string()), "// impossible. The pre-epoch refusal that guarded the old wall-clock read is DELETED with it,".to_string()), "\n".to_string()), "// because the hazard it named cannot arise on this clock -- production handling dissolves on".to_string()), "\n".to_string()), "// the climb (DESIGN section 4b(4)); no evidence is retired here, since that arm had none.".to_string()), "\n".to_string()), "fn run_adjudication(facts_path: &str, pattern: Rc<TargetPattern>, source_roots: &[String]) {".to_string()), "\n".to_string()), "    let driver_start = Instant::now();".to_string()), "\n".to_string()), "    // A MISSING GITHUB_SHA IS ABSENT, NOT \"local\" (review 64181). The receipt line carries this".to_string()), "\n".to_string()), "    // as the tree the measurement describes; the literal \"local\" is a plausible identity that".to_string()), "\n".to_string()), "    // no reader can distinguish from a tree actually named local.".to_string()), "\n".to_string()), "    let head: Option<String> = std::env::var(\"GITHUB_SHA\").ok();".to_string()), "\n".to_string()), "    let facts = read_host_facts(facts_path);".to_string()), "\n".to_string()), "".to_string()), "\n".to_string()), "    // the load row: reading the declared roots off disk. Its own exclusive row rather than a".to_string()), "\n".to_string()), "    // field on another phase, so the IO is never mixed into a fold's number.".to_string()), "\n".to_string()), "    let load_started = Instant::now();".to_string()), "\n".to_string()), "    if source_roots.is_empty() {".to_string()), "\n".to_string()), "        eprintln!(\"REFUSED: no source roots given\");".to_string()), "\n".to_string()), "        std::process::exit(2);".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "    let reads = read_ingest(source_roots);".to_string()), "\n".to_string()), "    let corpus_reads = reads.len();".to_string()), "\n".to_string()), "    let ingest = Rc::new(im::vector::Vector::from(reads));".to_string()), "\n".to_string()), "    let load_nanos = span_nanos(load_started);".to_string()), "\n".to_string()), "".to_string()), "\n".to_string()), "    // universe_derivation: the floor's own per-file discovery fold plus the module-header and".to_string()), "\n".to_string()), "    // import scans, over EVERY read -- discovery is a corpus-wide question -- and then the".to_string()), "\n".to_string()), "    // import closure of the universe's modules, which is all the front end is given.".to_string()), "\n".to_string()), "    let universe_started = Instant::now();".to_string()), "\n".to_string()), "    let source_facts = native_lane_source_facts(ingest.clone());".to_string()), "\n".to_string()), "    // The universe is derived FROM THE FACTS ALREADY BOUND, not from the ingest again:".to_string()), "\n".to_string()), "    // the ingest-taking entry would re-run the whole-corpus discovery fold the line above".to_string()), "\n".to_string()), "    // just paid for, and that fold is the phase the pattern does NOT narrow. See".to_string()), "\n".to_string()), "    // v2.compiler.compile native_lane_universe_of_facts -- the pattern is threaded, so this".to_string()), "\n".to_string()), "    // is the same entry a narrower pattern reaches, never a filter over a default universe.".to_string()), "\n".to_string()), "    let universe = match &*native_lane_universe_of_facts(source_facts.clone(), pattern.clone()) {".to_string()), "\n".to_string()), "        Outcome::Accepted { value, .. } => value.clone(),".to_string()), "\n".to_string()), "        Outcome::Rejected { diagnostics } => {".to_string()), "\n".to_string()), "            eprintln!(\"DERIVATION-REFUSED: {diagnostics:#?}\");".to_string()), "\n".to_string()), "            std::process::exit(1);".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "    };".to_string()), "\n".to_string()), "    // The walk's budget exhausting is a refusal of the whole derivation, never a truncated".to_string()), "\n".to_string()), "    // closure: a narrowed ingest would surface only as unexplained resolve refusals later.".to_string()), "\n".to_string()), "    let closure = match &*native_lane_closure_modules(".to_string()), "\n".to_string()), "        source_facts.clone(),".to_string()), "\n".to_string()), "        universe.clone(),".to_string()), "\n".to_string()), "        native_lane_closure_round_budget(),".to_string()), "\n".to_string()), "    ) {".to_string()), "\n".to_string()), "        Outcome::Accepted { value, .. } => value.clone(),".to_string()), "\n".to_string()), "        Outcome::Rejected { diagnostics } => {".to_string()), "\n".to_string()), "            eprintln!(\"CLOSURE-REFUSED: {diagnostics:#?}\");".to_string()), "\n".to_string()), "            std::process::exit(1);".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "    };".to_string()), "\n".to_string()), "    let closure_ingest = native_lane_closure_ingest(ingest.clone(), source_facts.clone(), closure.clone());".to_string()), "\n".to_string()), "    let closure_reads = closure_ingest.len();".to_string()), "\n".to_string()), "    // The ingest receipt's identity join, asked by the route: every ingested source declares a".to_string()), "\n".to_string()), "    // closure module and every closure module some source declares was ingested. A miss is the".to_string()), "\n".to_string()), "    // hidden prepass (or a hidden narrowing) this receipt exists to refuse.".to_string()), "\n".to_string()), "    let ingest_receipt = native_lane_ingest_receipt(source_facts.clone(), closure.clone(), closure_ingest.clone());".to_string()), "\n".to_string()), "    // The join answers a typed refusal naming the offending identity, so the counts below are".to_string()), "\n".to_string()), "    // context for it rather than the whole diagnostic: a reader gets the module and the path,".to_string()), "\n".to_string()), "    // not a pair of totals to re-derive the offender from.".to_string()), "\n".to_string()), "    match &*native_lane_ingest_matches_closure(source_facts.clone(), ingest_receipt.clone(), closure_ingest.clone()) {".to_string()), "\n".to_string()), "        Outcome::Accepted { .. } => {}".to_string()), "\n".to_string()), "        Outcome::Rejected { diagnostics } => {".to_string()), "\n".to_string()), "            eprintln!(".to_string()), "\n".to_string()), "                \"INGEST-CLOSURE-REFUSED: {:#?} (scanned={} ingested={} closure_modules={})\",".to_string()), "\n".to_string()), "                diagnostics,".to_string()), "\n".to_string()), "                ingest_receipt.scanned_paths.len(),".to_string()), "\n".to_string()), "                ingest_receipt.ingested_paths.len(),".to_string()), "\n".to_string()), "                ingest_receipt.closure_modules.len(),".to_string()), "\n".to_string()), "            );".to_string()), "\n".to_string()), "            std::process::exit(1);".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "    let universe_nanos = span_nanos(universe_started);".to_string()), "\n".to_string()), "".to_string()), "\n".to_string()), "    // the context row: the front-end fold over the CLOSURE only, entered ONE PHASE AT A TIME.".to_string()), "\n".to_string()), "    // The driver owns the clock, so it is the only place a phase span can be read; the phases".to_string()), "\n".to_string()), "    // themselves are v2.compiler.program_assembly declarations and each binds the previous".to_string()), "\n".to_string()), "    // phase's Outcome, so each phase BODY is single-authored and only the ORDER and the".to_string()), "\n".to_string()), "    // inter-phase diagnostic merge exist twice -- here and in the modeled composition".to_string()), "\n".to_string()), "    // program_assembly_read_to_normalized_root_seeded. (It named the UNSEEDED composition".to_string()), "\n".to_string()), "    // until that one was deleted for having no caller; the seeded producer is now the single".to_string()), "\n".to_string()), "    // modeled per-file front end, and this loop is still its second spelling.)".to_string()), "\n".to_string()), "    //".to_string()), "\n".to_string()), "    // THAT SECOND SPELLING IS ADMITTED DEBT AND IS FILED, NOT ASSERTED AWAY (review 65068):".to_string()), "\n".to_string()), "    // gunbc.recurring_failure_mode.realization_respells_a_modeled_folds_sequencing_to_instrument_it.".to_string()), "\n".to_string()), "    // An earlier revision of this comment claimed the two are the same computation. Nothing".to_string()), "\n".to_string()), "    // executes that claim, and a .dag witness comparing the composition against its own phases".to_string()), "\n".to_string()), "    // CANNOT go red -- the composition is defined as the phase chain -- so the honest answer is".to_string()), "\n".to_string()), "    // the row and its trigger (a realization seam that yields per-phase spans FROM a modeled".to_string()), "\n".to_string()), "    // fold), not a green check. Reordering these calls or dropping the merge that".to_string()), "\n".to_string()), "    // program_assembly_phase_parse_measured_seeded performs would change the context with".to_string()), "\n".to_string()), "    // nothing red.".to_string()), "\n".to_string()), "    let context_started = Instant::now();".to_string()), "\n".to_string()), "    // THE ONCE-PER-FOLD INVARIANT IS PAID ONCE, HERE, AND CARRIED INTO EVERY FILE. A second".to_string()), "\n".to_string()), "    // dag_language_model() or prepare_grammar() call inside the loop would re-introduce at the".to_string()), "\n".to_string()), "    // realization layer exactly the per-file recompute the fold hoisted out.".to_string()), "\n".to_string()), "    let front_end = match &*native_test_front_end_prepare() {".to_string()), "\n".to_string()), "        Outcome::Accepted { value, .. } => value.clone(),".to_string()), "\n".to_string()), "        Outcome::Rejected { diagnostics } => {".to_string()), "\n".to_string()), "            eprintln!(\"CONTEXT-REFUSED: {diagnostics:#?}\");".to_string()), "\n".to_string()), "            std::process::exit(1);".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "    };".to_string()), "\n".to_string()), "    let front_end_nanos = span_nanos(context_started);".to_string()), "\n".to_string()), "    let mut context_state = native_test_context_state_empty();".to_string()), "\n".to_string()), "    let mut tokenize_nanos: u128 = 0;".to_string()), "\n".to_string()), "    let mut parse_nanos: u128 = 0;".to_string()), "\n".to_string()), "    let mut normalize_nanos: u128 = 0;".to_string()), "\n".to_string()), "    let mut absorb_nanos: u128 = 0;".to_string()), "\n".to_string()), "    let mut phase_calls: u64 = 0;".to_string()), "\n".to_string()), "    let mut token_total: u64 = 0;".to_string()), "\n".to_string()), "    let mut memo_hits_total: u64 = 0;".to_string()), "\n".to_string()), "    let mut memo_misses_total: u64 = 0;".to_string()), "\n".to_string()), "    let mut memo_lookups_total: u64 = 0;".to_string()), "\n".to_string()), "    let mut byte_total: u64 = 0;".to_string()), "\n".to_string()), "    let mut context_file_samples: Vec<u128> = Vec::new();".to_string()), "\n".to_string()), "    for read in closure_ingest.iter() {".to_string()), "\n".to_string()), "        let file_started = Instant::now();".to_string()), "\n".to_string()), "        let tokenize_started = Instant::now();".to_string()), "\n".to_string()), "        let tokens = program_assembly_phase_tokenize(read.clone(), front_end.lm.clone());".to_string()), "\n".to_string()), "        let file_tokenize_nanos = span_nanos(tokenize_started);".to_string()), "\n".to_string()), "        // The COUNT the time is read against: a span alone cannot separate a large file from a".to_string()), "\n".to_string()), "        // per-file constant. Counted outside every phase span so it prices none of them.".to_string()), "\n".to_string()), "        let file_tokens = program_assembly_phase_token_count(tokens.clone());".to_string()), "\n".to_string()), "        let parse_started = Instant::now();".to_string()), "\n".to_string()), "        // SEEDED FROM THE MARK THE CONTEXT HAS REACHED, because this loop IS a source graph:".to_string()), "\n".to_string()), "        // std.occurrence_identity occurrence_identity_scope_law requires one allocator threaded".to_string()), "\n".to_string()), "        // across every parsed source, and a per-file reset makes two files' occurrence #N the".to_string()), "\n".to_string()), "        // same value with different meanings. The modeled fold threads it internally; this".to_string()), "\n".to_string()), "        // respelling has to thread it explicitly or it keeps the reset the fold no longer has.".to_string()), "\n".to_string()), "        let file_seed = context_state.alloc.clone();".to_string()), "\n".to_string()), "        let file_seed_reported = file_seed.clone();".to_string()), "\n".to_string()), "        let measured = program_assembly_phase_parse_measured_seeded(".to_string()), "\n".to_string()), "            tokens.clone(),".to_string()), "\n".to_string()), "            front_end.prepared.clone(),".to_string()), "\n".to_string()), "            // The residue field is an Optional whose inner type rides a recursion cycle, so the".to_string()), "\n".to_string()), "            // emitted record BOXES it while the phase takes the option by value. Deref the box".to_string()), "\n".to_string()), "            // rather than clone it; the sibling fields above are Rc and clone correctly.".to_string()), "\n".to_string()), "            (*front_end.residue).clone(),".to_string()), "\n".to_string()), "            file_seed.clone(),".to_string()), "\n".to_string()), "        );".to_string()), "\n".to_string()), "        let file_parse_nanos = span_nanos(parse_started);".to_string()), "\n".to_string()), "        // The memo accounting rides BESIDE the outcome, so it reports on a refusal too --".to_string()), "\n".to_string()), "        // which is the expensive case this instrument exists to read. Counted outside every".to_string()), "\n".to_string()), "        // phase span so it prices none of them.".to_string()), "\n".to_string()), "        let file_memo_hits = program_assembly_memo_hits(measured.clone());".to_string()), "\n".to_string()), "        let file_memo_misses = program_assembly_memo_misses(measured.clone());".to_string()), "\n".to_string()), "        let file_memo_lookups = program_assembly_memo_lookup_calls(measured.clone());".to_string()), "\n".to_string()), "        // Read BEFORE program_assembly_measured_outcome consumes `measured`. On a refused parse".to_string()), "\n".to_string()), "        // this returns the seed unchanged. Not because nothing was minted -- a refused parse".to_string()), "\n".to_string()), "        // HAS minted ids -- but because ParseExprRejected carries no provenance state, so the".to_string()), "\n".to_string()), "        // mark the attempt reached is not recoverable. See the precondition on".to_string()), "\n".to_string()), "        // v2.compiler.compile native_test_context_absorb.".to_string()), "\n".to_string()), "        let file_alloc = program_assembly_measured_alloc(measured.clone(), file_seed);".to_string()), "\n".to_string()), "        let file_alloc_reported = file_alloc.clone();".to_string()), "\n".to_string()), "        let parsed = program_assembly_measured_outcome(measured);".to_string()), "\n".to_string()), "        let normalize_started = Instant::now();".to_string()), "\n".to_string()), "        let root = program_assembly_phase_normalize(parsed.clone());".to_string()), "\n".to_string()), "        let file_normalize_nanos = span_nanos(normalize_started);".to_string()), "\n".to_string()), "        // qualified-name read plus source-root index insertion: the half of the per-file step".to_string()), "\n".to_string()), "        // that is not the front end, timed separately because a quadratic accumulator would".to_string()), "\n".to_string()), "        // live here and nowhere else in this loop.".to_string()), "\n".to_string()), "        let absorb_started = Instant::now();".to_string()), "\n".to_string()), "        context_state = native_test_context_absorb(context_state.clone(), read.clone(), root.clone(), file_alloc);".to_string()), "\n".to_string()), "        let file_absorb_nanos = span_nanos(absorb_started);".to_string()), "\n".to_string()), "        let file_nanos = span_nanos(file_started);".to_string()), "\n".to_string()), "        tokenize_nanos += file_tokenize_nanos;".to_string()), "\n".to_string()), "        parse_nanos += file_parse_nanos;".to_string()), "\n".to_string()), "        normalize_nanos += file_normalize_nanos;".to_string()), "\n".to_string()), "        absorb_nanos += file_absorb_nanos;".to_string()), "\n".to_string()), "        phase_calls += 1;".to_string()), "\n".to_string()), "        token_total += file_tokens.max(0) as u64;".to_string()), "\n".to_string()), "        memo_hits_total += file_memo_hits.max(0) as u64;".to_string()), "\n".to_string()), "        memo_misses_total += file_memo_misses.max(0) as u64;".to_string()), "\n".to_string()), "        memo_lookups_total += file_memo_lookups.max(0) as u64;".to_string()), "\n".to_string()), "        let file_bytes = read.source.carried.len() as u64;".to_string()), "\n".to_string()), "        byte_total += file_bytes;".to_string()), "\n".to_string()), "        context_file_samples.push(file_nanos);".to_string()), "\n".to_string()), "        eprintln!(".to_string()), "\n".to_string()), "            \"[native-context-split] {}\",".to_string()), "\n".to_string()), "            serde_json::json!({".to_string()), "\n".to_string()), "                \"producer\": \"std.compiler_entry.SourceRootEvalDriver\",".to_string()), "\n".to_string()), "                \"path\": read.compilation_unit.clone(),".to_string()), "\n".to_string()), "                \"bytes\": file_bytes,".to_string()), "\n".to_string()), "                \"tokens\": file_tokens,".to_string()), "\n".to_string()), "                \"tokenize_nanos\": file_tokenize_nanos,".to_string()), "\n".to_string()), "                \"parse_nanos\": file_parse_nanos,".to_string()), "\n".to_string()), "                \"normalize_nanos\": file_normalize_nanos,".to_string()), "\n".to_string()), "                \"absorb_nanos\": file_absorb_nanos,".to_string()), "\n".to_string()), "                \"file_nanos\": file_nanos,".to_string()), "\n".to_string()), "                \"memo_hits\": file_memo_hits,".to_string()), "\n".to_string()), "                \"memo_misses\": file_memo_misses,".to_string()), "\n".to_string()), "                \"memo_lookup_calls\": file_memo_lookups,".to_string()), "\n".to_string()), "                // THE THREADING, MADE OBSERVABLE. occurrence_seed is the mark this file was".to_string()), "\n".to_string()), "                // handed and occurrence_next the mark it reached, so a multi-file run shows".to_string()), "\n".to_string()), "                // one sequence continuing across files instead of each file restarting at 0.".to_string()), "\n".to_string()), "                // A REFUSED file reports next == seed. That is the mark it was HANDED, not a".to_string()), "\n".to_string()), "                // claim that nothing was minted: a refused parse mints ids that the refusal".to_string()), "\n".to_string()), "                // discards unrecoverably. The next file continues from the seed rather than".to_string()), "\n".to_string()), "                // rewinding to zero.".to_string()), "\n".to_string()), "                \"occurrence_seed\": program_assembly_allocator_next(file_seed_reported),".to_string()), "\n".to_string()), "                \"occurrence_next\": program_assembly_allocator_next(file_alloc_reported),".to_string()), "\n".to_string()), "            }),".to_string()), "\n".to_string()), "        );".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "    let context = native_test_context_finish(context_state, front_end.clone(), closure_ingest.clone());".to_string()), "\n".to_string()), "    let context_nanos = span_nanos(context_started);".to_string()), "\n".to_string()), "    context_file_samples.sort_unstable();".to_string()), "\n".to_string()), "    let context_phase_sum = front_end_nanos + tokenize_nanos + parse_nanos + normalize_nanos + absorb_nanos;".to_string()), "\n".to_string()), "    eprintln!(".to_string()), "\n".to_string()), "        \"[native-context-partition] {}\",".to_string()), "\n".to_string()), "        serde_json::json!({".to_string()), "\n".to_string()), "            \"producer\": \"std.compiler_entry.SourceRootEvalDriver\",".to_string()), "\n".to_string()), "            \"basis\": \"context_span\",".to_string()), "\n".to_string()), "            \"basis_note\": \"exclusive phase rows partition context_nanos; residual is loop overhead and the eprintln per file\",".to_string()), "\n".to_string()), "            \"context_nanos\": context_nanos,".to_string()), "\n".to_string()), "            \"front_end_prepare_nanos\": front_end_nanos,".to_string()), "\n".to_string()), "            \"tokenize_nanos\": tokenize_nanos,".to_string()), "\n".to_string()), "            \"parse_nanos\": parse_nanos,".to_string()), "\n".to_string()), "            \"normalize_nanos\": normalize_nanos,".to_string()), "\n".to_string()), "            \"absorb_nanos\": absorb_nanos,".to_string()), "\n".to_string()), "            \"sum_phase_nanos\": context_phase_sum,".to_string()), "\n".to_string()), "            \"residual_nanos\": context_nanos.saturating_sub(context_phase_sum),".to_string()), "\n".to_string()), "            \"files\": phase_calls,".to_string()), "\n".to_string()), "            \"tokenize_calls\": phase_calls,".to_string()), "\n".to_string()), "            \"parse_calls\": phase_calls,".to_string()), "\n".to_string()), "            \"normalize_calls\": phase_calls,".to_string()), "\n".to_string()), "            \"absorb_calls\": phase_calls,".to_string()), "\n".to_string()), "            \"front_end_prepare_calls\": 1,".to_string()), "\n".to_string()), "            \"tokens\": token_total,".to_string()), "\n".to_string()), "            \"memo_hits\": memo_hits_total,".to_string()), "\n".to_string()), "            \"memo_misses\": memo_misses_total,".to_string()), "\n".to_string()), "            \"memo_lookup_calls\": memo_lookups_total,".to_string()), "\n".to_string()), "            \"bytes\": byte_total,".to_string()), "\n".to_string()), "            \"file_refusals\": context.file_refusals.len(),".to_string()), "\n".to_string()), "            \"file_p50_nanos\": native_cost_quantile_nanos(&context_file_samples, 1, 2),".to_string()), "\n".to_string()), "            \"file_p95_nanos\": native_cost_quantile_nanos(&context_file_samples, 19, 20),".to_string()), "\n".to_string()), "            \"file_max_nanos\": context_file_samples.last().copied().unwrap_or(0),".to_string()), "\n".to_string()), "        }),".to_string()), "\n".to_string()), "    );".to_string()), "\n".to_string()), "".to_string()), "\n".to_string()), "    // the prepare and eval rows, entered separately per module so the number the profile".to_string()), "\n".to_string()), "    // lane prices -- the eval row -- is the sum of native_lane_identity_row".to_string()), "\n".to_string()), "    // and nothing else: not ingest, not resolve, not infer.".to_string()), "\n".to_string()), "    let mut population: Vec<Rc<NativeRouteMemberRow>> = Vec::new();".to_string()), "\n".to_string()), "    let mut prepare_total_nanos: u128 = 0;".to_string()), "\n".to_string()), "    let mut evaluate_total_nanos: u128 = 0;".to_string()), "\n".to_string()), "    let mut prepare_samples: Vec<u128> = Vec::new();".to_string()), "\n".to_string()), "    let mut eval_samples: Vec<u128> = Vec::new();".to_string()), "\n".to_string()), "    let mut prepare_ok: u64 = 0;".to_string()), "\n".to_string()), "    let mut prepare_refused: u64 = 0;".to_string()), "\n".to_string()), "    let mut module_release_nanos: u128 = 0;".to_string()), "\n".to_string()), "    let mut relay_emit_nanos: u128 = 0;".to_string()), "\n".to_string()), "    // The per-path refusal index is built ONCE here rather than per module: this loop is the".to_string()), "\n".to_string()), "    // only place that knows a loop is about to happen, and the join it feeds was O(modules x".to_string()), "\n".to_string()), "    // refusals) when each module scanned the refusal list for itself.".to_string()), "\n".to_string()), "    let refusal_index = native_lane_file_refusal_index(context.file_refusals.clone());".to_string()), "\n".to_string()), "    for entry in universe.modules.iter() {".to_string()), "\n".to_string()), "        let prepare_started = Instant::now();".to_string()), "\n".to_string()), "        let mut identities: usize = 0;".to_string()), "\n".to_string()), "        let mut module_evaluate_nanos: u128 = 0;".to_string()), "\n".to_string()), "        let mut module_infer_nanos: u128 = 0;".to_string()), "\n".to_string()), "        // THE PREPARATION SPAN CLOSES WHEN THE PREPARATION OUTCOME IS ESTABLISHED, BEFORE ANY".to_string()), "\n".to_string()), "        // DECLARATION IS EVALUATED. prepare and eval are exclusive rows of one partition, so a".to_string()), "\n".to_string()), "        // prepare interval that contained its module's eval intervals would count that work".to_string()), "\n".to_string()), "        // twice and inflate the sum against the parent.".to_string()), "\n".to_string()), "        //".to_string()), "\n".to_string()), "        // THE CLOSE IS THE ARM'S VALUE, NOT AN ASSIGNMENT INSIDE IT. Assigning an outer binding".to_string()), "\n".to_string()), "        // from each arm left its initialiser dead, and a dead store is an ERROR in the emitted".to_string()), "\n".to_string()), "        // crate (RUSTFLAGS=\"-D warnings\"); silencing it with an allow would be the escape hatch".to_string()), "\n".to_string()), "        // DESIGN section 5 forbids. Each arm yields its own span instead, so there is one binding".to_string()), "\n".to_string()), "        // site, nothing to overwrite, and the order control has a single spelling to assert on.".to_string()), "\n".to_string()), "        let resolve_started = Instant::now();".to_string()), "\n".to_string()), "        let resolution = native_lane_module_resolution(context.clone(), refusal_index.clone(), entry.clone());".to_string()), "\n".to_string()), "        let module_resolve_nanos = span_nanos(resolve_started);".to_string()), "\n".to_string()), "        let (outcome_label, module_prepare_nanos) = match &*resolution {".to_string()), "\n".to_string()), "            NativeLaneModuleResolution::NativeLaneModuleContextRowsDecided { rows } => {".to_string()), "\n".to_string()), "                let this_prepare = span_nanos(prepare_started);".to_string()), "\n".to_string()), "                prepare_refused += 1;".to_string()), "\n".to_string()), "                for row in rows.iter() {".to_string()), "\n".to_string()), "                    population.push(row.clone());".to_string()), "\n".to_string()), "                    identities += 1;".to_string()), "\n".to_string()), "                }".to_string()), "\n".to_string()), "                (\"context_refused\", this_prepare)".to_string()), "\n".to_string()), "            }".to_string()), "\n".to_string()), "            NativeLaneModuleResolution::NativeLaneModuleResolveRowsDecided { rows } => {".to_string()), "\n".to_string()), "                let this_prepare = span_nanos(prepare_started);".to_string()), "\n".to_string()), "                prepare_refused += 1;".to_string()), "\n".to_string()), "                for row in rows.iter() {".to_string()), "\n".to_string()), "                    population.push(row.clone());".to_string()), "\n".to_string()), "                    identities += 1;".to_string()), "\n".to_string()), "                }".to_string()), "\n".to_string()), "                (\"resolve_refused\", this_prepare)".to_string()), "\n".to_string()), "            }".to_string()), "\n".to_string()), "            NativeLaneModuleResolution::NativeLaneModuleResolved { resolved } => {".to_string()), "\n".to_string()), "                let infer_started = Instant::now();".to_string()), "\n".to_string()), "                let preparation = native_lane_module_inference(entry.clone(), resolved.clone());".to_string()), "\n".to_string()), "                module_infer_nanos = span_nanos(infer_started);".to_string()), "\n".to_string()), "                let this_prepare = span_nanos(prepare_started);".to_string()), "\n".to_string()), "                match &*preparation {".to_string()), "\n".to_string()), "                    NativeLaneModulePreparation::NativeLaneModuleRowsDecided { rows } => {".to_string()), "\n".to_string()), "                        prepare_refused += 1;".to_string()), "\n".to_string()), "                        for row in rows.iter() {".to_string()), "\n".to_string()), "                            population.push(row.clone());".to_string()), "\n".to_string()), "                            identities += 1;".to_string()), "\n".to_string()), "                        }".to_string()), "\n".to_string()), "                        (\"infer_refused\", this_prepare)".to_string()), "\n".to_string()), "                    }".to_string()), "\n".to_string()), "                    NativeLaneModulePreparation::NativeLaneModulePrepared { prepared } => {".to_string()), "\n".to_string()), "                        prepare_ok += 1;".to_string()), "\n".to_string()), "                        for declaration in entry.declarations.iter() {".to_string()), "\n".to_string()), "                            let evaluate_started = Instant::now();".to_string()), "\n".to_string()), "                            let row = native_lane_identity_row(".to_string()), "\n".to_string()), "                                prepared.clone(),".to_string()), "\n".to_string()), "                                entry.module.clone(),".to_string()), "\n".to_string()), "                                declaration.clone(),".to_string()), "\n".to_string()), "                            );".to_string()), "\n".to_string()), "                            let this_eval = span_nanos(evaluate_started);".to_string()), "\n".to_string()), "                            module_evaluate_nanos += this_eval;".to_string()), "\n".to_string()), "                            eval_samples.push(this_eval);".to_string()), "\n".to_string()), "                            population.push(row);".to_string()), "\n".to_string()), "                            identities += 1;".to_string()), "\n".to_string()), "                        }".to_string()), "\n".to_string()), "                        (\"accepted\", this_prepare)".to_string()), "\n".to_string()), "                    }".to_string()), "\n".to_string()), "                }".to_string()), "\n".to_string()), "            }".to_string()), "\n".to_string()), "        };".to_string()), "\n".to_string()), "        prepare_total_nanos += module_prepare_nanos;".to_string()), "\n".to_string()), "        evaluate_total_nanos += module_evaluate_nanos;".to_string()), "\n".to_string()), "        prepare_samples.push(module_prepare_nanos);".to_string()), "\n".to_string()), "        // RELEASE IS MEASURED, NOT LEFT TO SCOPE EXIT. The resolved tree this module built is".to_string()), "\n".to_string()), "        // dropped HERE, inside a span, because dropping it at the end of the iteration paid real".to_string()), "\n".to_string()), "        // time that no exclusive row covered. An explicit drop makes the cost nameable; scope".to_string()), "\n".to_string()), "        // exit hides it. What that cost turned out to BE -- and whether it explains anything --".to_string()), "\n".to_string()), "        // is a fact of std.compiler_entry NativeDriverExclusiveRows, not of this template.".to_string()), "\n".to_string()), "        let release_started = Instant::now();".to_string()), "\n".to_string()), "        drop(resolution);".to_string()), "\n".to_string()), "        module_release_nanos += span_nanos(release_started);".to_string()), "\n".to_string()), "        // One stderr write per unique module, to a pipe the host runner drains. It is spanned".to_string()), "\n".to_string()), "        // because it was paid inside parent_span with no exclusive row over it. What the span".to_string()), "\n".to_string()), "        // has since MEASURED, and what the residual is, are facts of std.compiler_entry".to_string()), "\n".to_string()), "        // NativeDriverExclusiveRows and are deliberately not restated here: a number copied".to_string()), "\n".to_string()), "        // into a generated template rots in a place no fold can reach to correct it.".to_string()), "\n".to_string()), "        let relay_started = Instant::now();".to_string()), "\n".to_string()), "        eprintln!(\"[native-prepare-split] module={} resolve_nanos={module_resolve_nanos} infer_nanos={module_infer_nanos} prepare_nanos={module_prepare_nanos} decls={} outcome={outcome_label}\", entry.module, identities);".to_string()), "\n".to_string()), "        relay_emit_nanos += span_nanos(relay_started);".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "".to_string()), "\n".to_string()), "    // receipt_admission: minting the receipt and evaluating the authority's admission and summary".to_string()), "\n".to_string()), "    // over it. The controls are executed here because they are receipt inputs, not universe members.".to_string()), "\n".to_string()), "    let admission_started = Instant::now();".to_string()), "\n".to_string()), "    let receipt = native_lane_receipt(".to_string()), "\n".to_string()), "        context.clone(),".to_string()), "\n".to_string()), "        universe.clone(),".to_string()), "\n".to_string()), "        Rc::new(population.clone().into()),".to_string()), "\n".to_string()), "        native_lane_controls(context.clone()),".to_string()), "\n".to_string()), "        Rc::new(facts),".to_string()), "\n".to_string()), "    );".to_string()), "\n".to_string()), "    let admission = native_route_admission(receipt.clone());".to_string()), "\n".to_string()), "    let summary = native_route_admission_summary(admission.clone());".to_string()), "\n".to_string()), "    let file_refusal_tally: Vec<serde_json::Value> = native_route_file_refusal_tally(receipt.clone())".to_string()), "\n".to_string()), "        .iter()".to_string()), "\n".to_string()), "        .map(|row| serde_json::json!(row))".to_string()), "\n".to_string()), "        .collect();".to_string()), "\n".to_string()), "    let admitted = native_route_admitted(admission.clone());".to_string()), "\n".to_string()), "    let admission_nanos = span_nanos(admission_started);".to_string()), "\n".to_string()), "".to_string()), "\n".to_string()), "".to_string()), "\n".to_string()), "    // row_serialization: SERIALIZING THE OBSERVATIONS AND WRITING THEM, MEASURED (review".to_string()), "\n".to_string()), "    // 64181 named this span; #11105 made leaving it unattributed fatal). Every row the".to_string()), "\n".to_string()), "    // population carries is turned into JSON here and written to stdout, which is real work".to_string()), "\n".to_string()), "    // no other row covers -- eval is the identity fold and nothing else. It is TIMED, never".to_string()), "\n".to_string()), "    // derived as parent minus the others: a row defined as the remainder would force the".to_string()), "\n".to_string()), "    // residual to zero and make the tolerance arm unfireable by construction.".to_string()), "\n".to_string()), "    let serialization_started = Instant::now();".to_string()), "\n".to_string()), "    for refusal in receipt.file_refusals.iter() {".to_string()), "\n".to_string()), "        println!(\"{}\", serde_json::json!({ \"file_refusal\": refusal }));".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "    for row in population.iter() {".to_string()), "\n".to_string()), "        println!(\"{}\", serde_json::to_string(row).unwrap());".to_string()), "\n".to_string()), "        // THE OPERATOR'S LINE, BESIDE THE PERSISTED ROW. The JSON above is the receipt; this is".to_string()), "\n".to_string()), "        // the same value rendered by the authority for a reader of the command's output, so a".to_string()), "\n".to_string()), "        // row that did not pass names its subject, stage, cause and position without anyone".to_string()), "\n".to_string()), "        // re-deriving them from the bytes just written. Passing rows print nothing here: the".to_string()), "\n".to_string()), "        // terminal marker carries their count. EXHAUSTIVE ON PURPOSE -- a verdict arm added to".to_string()), "\n".to_string()), "        // the vocabulary must decide here whether it is operator-visible.".to_string()), "\n".to_string()), "        match &*row.verdict {".to_string()), "\n".to_string()), "            NativeTestVerdict::NativeTestPassed => {}".to_string()), "\n".to_string()), "            NativeTestVerdict::NativeTestReturnedFalse".to_string()), "\n".to_string()), "            | NativeTestVerdict::NativeTestReturnedOther".to_string()), "\n".to_string()), "            | NativeTestVerdict::NativeTestRefused { .. } => {".to_string()), "\n".to_string()), "                eprintln!(\"[native-verdict] {}\", native_route_member_row_text(row.clone()));".to_string()), "\n".to_string()), "            }".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "    let row_serialization_nanos = span_nanos(serialization_started);".to_string()), "\n".to_string()), "".to_string()), "\n".to_string()), "    // THE PARTITION, THROUGH THE ONE LAW. The rows are the row set std.compiler_entry owns and".to_string()), "\n".to_string()), "    // verdict is native_driver_cost_account over them -- not a second reconcile. The two rows".to_string()), "\n".to_string()), "    // this route pays that a driver handed a universe file does not (universe_derivation,".to_string()), "\n".to_string()), "    // receipt_admission) are members of the same exclusive sum, so an over-attribution through".to_string()), "\n".to_string()), "    // either is caught here rather than by a check of its own.".to_string()), "\n".to_string()), "    prepare_samples.sort_unstable();".to_string()), "\n".to_string()), "    eval_samples.sort_unstable();".to_string()), "\n".to_string()), "    let parent_span_nanos = span_nanos(driver_start);".to_string()), "\n".to_string()), "    // THE DRIVER IS EXHAUSTIVE OVER THE KEY WITH NO WILDCARD, deliberately: a row added to".to_string()), "\n".to_string()), "    // std.compiler_entry makes THIS match refuse to compile until the driver says what".to_string()), "\n".to_string()), "    // measures it. A wildcard here would answer zero for a span nobody wired up, which is".to_string()), "\n".to_string()), "    // the absorbing arm DESIGN section 5 forbids -- and it is what the old record literal".to_string()), "\n".to_string()), "    // did silently, three folds running.".to_string()), "\n".to_string()), "    let exclusive = native_driver_exclusive_rows(move |k| match k {".to_string()), "\n".to_string()), "        NativeDriverExclusiveRowKey::ExclusiveLoad => nanosecond(native_cost_i64(load_nanos)),".to_string()), "\n".to_string()), "        NativeDriverExclusiveRowKey::ExclusiveUniverseDerivation => nanosecond(native_cost_i64(universe_nanos)),".to_string()), "\n".to_string()), "        NativeDriverExclusiveRowKey::ExclusiveContext => nanosecond(native_cost_i64(context_nanos)),".to_string()), "\n".to_string()), "        NativeDriverExclusiveRowKey::ExclusivePrepare => nanosecond(native_cost_i64(prepare_total_nanos)),".to_string()), "\n".to_string()), "        NativeDriverExclusiveRowKey::ExclusiveEval => nanosecond(native_cost_i64(evaluate_total_nanos)),".to_string()), "\n".to_string()), "        NativeDriverExclusiveRowKey::ExclusiveReceiptAdmission => nanosecond(native_cost_i64(admission_nanos)),".to_string()), "\n".to_string()), "        NativeDriverExclusiveRowKey::ExclusiveRowSerialization => nanosecond(native_cost_i64(row_serialization_nanos)),".to_string()), "\n".to_string()), "        NativeDriverExclusiveRowKey::ExclusiveModuleRelease => nanosecond(native_cost_i64(module_release_nanos)),".to_string()), "\n".to_string()), "        NativeDriverExclusiveRowKey::ExclusiveRelayEmit => nanosecond(native_cost_i64(relay_emit_nanos)),".to_string()), "\n".to_string()), "    });".to_string()), "\n".to_string()), "    let exclusive_sum = nanosecond_count(native_driver_exclusive_sum(exclusive.clone())) as u128;".to_string()), "\n".to_string()), "    let tolerance_nanos = nanosecond_count(native_driver_cost_remainder_tolerance_nanos()) as u128;".to_string()), "\n".to_string()), "    let accounting = native_driver_cost_account(".to_string()), "\n".to_string()), "        nanosecond(native_cost_i64(parent_span_nanos)),".to_string()), "\n".to_string()), "        exclusive.clone(),".to_string()), "\n".to_string()), "        native_driver_cost_remainder_tolerance_nanos(),".to_string()), "\n".to_string()), "    );".to_string()), "\n".to_string()), "    // The remainder is the residual the accounting itself returns, never parent minus sum: on".to_string()), "\n".to_string()), "    // over-attributed arm there IS no remainder, and a clamped zero there would be a".to_string()), "\n".to_string()), "    // plausible number standing where the measurement is incoherent.".to_string()), "\n".to_string()), "    let (verdict, remainder_nanos) = match accounting.as_ref() {".to_string()), "\n".to_string()), "        NativeDriverCostAccounting::NativeDriverCostOverAttributed { .. } =>".to_string()), "\n".to_string()), "            (r#\"NativeDriverCostOverAttributed\"#, serde_json::Value::Null),".to_string()), "\n".to_string()), "        NativeDriverCostAccounting::NativeDriverCostRemainderExceedsTolerance { residual, .. } =>".to_string()), "\n".to_string()), "            (r#\"NativeDriverCostRemainderExceedsTolerance\"#, serde_json::json!(nanosecond_count(residual.clone()))),".to_string()), "\n".to_string()), "        NativeDriverCostAccounting::NativeDriverCostReconciled { residual, .. } =>".to_string()), "\n".to_string()), "            (r#\"NativeDriverCostReconciled\"#, serde_json::json!(nanosecond_count(residual.clone()))),".to_string()), "\n".to_string()), "    };".to_string()), "\n".to_string()), "    let identities = universe.identities.len() as u64;".to_string()), "\n".to_string()), "    let eval_mean = if eval_samples.is_empty() { 0 } else { evaluate_total_nanos / eval_samples.len() as u128 };".to_string()), "\n".to_string()), "    let prepare_mean = if prepare_samples.is_empty() { 0 } else { prepare_total_nanos / prepare_samples.len() as u128 };".to_string()), "\n".to_string()), "    // THE ROWS ARE PROJECTED FROM THE VALUE, NOT RE-LISTED (review 64181). The field names".to_string()), "\n".to_string()), "    // were written once to build NativeDriverExclusiveRows and again to render it, which is the".to_string()), "\n".to_string()), "    // second spelling this file warns about for prose, applied to the emitted object: a driver".to_string()), "\n".to_string()), "    // gaining a phase would have updated the struct and left the receipt short. Serializing the".to_string()), "\n".to_string()), "    // value carries the row set from the type, so the JSON cannot disagree with the fold. The".to_string()), "\n".to_string()), "    // rows therefore render as std.measure Nanosecond objects rather than bare integers -- the".to_string()), "\n".to_string()), "    // unit travels with the number, which is the point of the type.".to_string()), "\n".to_string()), "    // A NON-RECONCILED ARM IS A PROCESS REFUSAL (#11105, review 63891). The receipt is".to_string()), "\n".to_string()), "    // printed first so the numbers that caused the refusal are on the wire, and THEN the".to_string()), "\n".to_string()), "    // line stops: a verdict string with exit 0 is the inert lens DESIGN section 6 names.".to_string()), "\n".to_string()), "    // The full-N run of this route refused here on 158600186 ns against a 50000000 ns".to_string()), "\n".to_string()), "    // tolerance before row_serialization was a measured row, which is what put that row on".to_string()), "\n".to_string()), "    // the type rather than a wider tolerance on this arm.".to_string()), "\n".to_string()), "    eprintln!(\"[native-cost-partition] {}\", serde_json::json!({".to_string()), "\n".to_string()), "        \"basis\": \"native_driver_wall\",".to_string()), "\n".to_string()), "        \"basis_note\": \"single-threaded SourceRootEvalDriver wall; exclusive rows partition parent_span_nanos\",".to_string()), "\n".to_string()), "        \"producer\": \"std.compiler_entry.SourceRootEvalDriver\",".to_string()), "\n".to_string()), "        \"head\": head,".to_string()), "\n".to_string()), "        \"mode\": \"adjudicate\",".to_string()), "\n".to_string()), "        \"verdict\": verdict,".to_string()), "\n".to_string()), "        \"tolerance_nanos\": tolerance_nanos,".to_string()), "\n".to_string()), "        \"parent_span_nanos\": parent_span_nanos,".to_string()), "\n".to_string()), "        \"exclusive\": exclusive.rows.iter().map(|r| (".to_string()), "\n".to_string()), "            native_driver_exclusive_row_name(r.key.clone()),".to_string()), "\n".to_string()), "            serde_json::json!(r.nanos),".to_string()), "\n".to_string()), "        )).collect::<serde_json::Map<String, serde_json::Value>>(),".to_string()), "\n".to_string()), "        \"sum_exclusive_nanos\": exclusive_sum,".to_string()), "\n".to_string()), "        \"remainder_nanos\": remainder_nanos,".to_string()), "\n".to_string()), "        \"corpus_reads\": corpus_reads,".to_string()), "\n".to_string()), "        \"closure_reads\": closure_reads,".to_string()), "\n".to_string()), "        \"scanned_paths\": ingest_receipt.scanned_paths.len(),".to_string()), "\n".to_string()), "        \"ingested_paths\": ingest_receipt.ingested_paths.len(),".to_string()), "\n".to_string()), "        \"closure_modules\": closure.len(),".to_string()), "\n".to_string()), "        \"identities\": identities,".to_string()), "\n".to_string()), "        \"unique_modules\": universe.modules.len(),".to_string()), "\n".to_string()), "        \"file_refusals\": receipt.file_refusals.len(),".to_string()), "\n".to_string()), "        \"prepare_ok\": prepare_ok,".to_string()), "\n".to_string()), "        \"prepare_refused\": prepare_refused,".to_string()), "\n".to_string()), "        \"prepare_mean_nanos\": prepare_mean,".to_string()), "\n".to_string()), "        \"prepare_p50_nanos\": native_cost_quantile_nanos(&prepare_samples, 1, 2),".to_string()), "\n".to_string()), "        \"prepare_p95_nanos\": native_cost_quantile_nanos(&prepare_samples, 19, 20),".to_string()), "\n".to_string()), "        \"prepare_max_nanos\": prepare_samples.last().copied().unwrap_or(0),".to_string()), "\n".to_string()), "        \"eval_mean_nanos\": eval_mean,".to_string()), "\n".to_string()), "        \"eval_p50_nanos\": native_cost_quantile_nanos(&eval_samples, 1, 2),".to_string()), "\n".to_string()), "        \"eval_p95_nanos\": native_cost_quantile_nanos(&eval_samples, 19, 20),".to_string()), "\n".to_string()), "        \"eval_max_nanos\": eval_samples.last().copied().unwrap_or(0),".to_string()), "\n".to_string()), "        \"peak_rss_bytes\": proc_status_kib(\"VmHWM\").map(|kib| kib * 1024),".to_string()), "\n".to_string()), "        \"rss_bytes\": proc_status_kib(\"VmRSS\").map(|kib| kib * 1024),".to_string()), "\n".to_string()), "    }));".to_string()), "\n".to_string()), "    match accounting.as_ref() {".to_string()), "\n".to_string()), "        NativeDriverCostAccounting::NativeDriverCostReconciled { .. } => {}".to_string()), "\n".to_string()), "        NativeDriverCostAccounting::NativeDriverCostOverAttributed { sum_exclusive, parent_span } => {".to_string()), "\n".to_string()), "            eprintln!(".to_string()), "\n".to_string()), "                \"REFUSED: native driver cost OverAttributed {{ sum_exclusive_nanos: {}, parent_span_nanos: {} }}\",".to_string()), "\n".to_string()), "                nanosecond_count(sum_exclusive.clone()) as u128,".to_string()), "\n".to_string()), "                nanosecond_count(parent_span.clone()) as u128".to_string()), "\n".to_string()), "            );".to_string()), "\n".to_string()), "            std::process::exit(1);".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "        NativeDriverCostAccounting::NativeDriverCostRemainderExceedsTolerance { residual, tolerance } => {".to_string()), "\n".to_string()), "            eprintln!(".to_string()), "\n".to_string()), "                \"REFUSED: native driver cost RemainderExceedsTolerance {{ residual_nanos: {}, tolerance_nanos: {} }} -- unattributed driver work; name the span, do not widen the tolerance\",".to_string()), "\n".to_string()), "                nanosecond_count(residual.clone()) as u128,".to_string()), "\n".to_string()), "                nanosecond_count(tolerance.clone()) as u128".to_string()), "\n".to_string()), "            );".to_string()), "\n".to_string()), "            std::process::exit(1);".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "    println!(".to_string()), "\n".to_string()), "        \"{}\",".to_string()), "\n".to_string()), "        serde_json::json!({".to_string()), "\n".to_string()), "            \"_terminal\": \"complete\",".to_string()), "\n".to_string()), "            \"mode\": \"adjudicate\",".to_string()), "\n".to_string()), "            \"rows\": population.len(),".to_string()), "\n".to_string()), "            \"universe\": universe.identities.len(),".to_string()), "\n".to_string()), "            \"file_refusals\": receipt.file_refusals.len(),".to_string()), "\n".to_string()), "            \"file_refusal_tally\": file_refusal_tally,".to_string()), "\n".to_string()), "            \"admitted\": admitted,".to_string()), "\n".to_string()), "            \"summary\": summary,".to_string()), "\n".to_string()), "        })".to_string()), "\n".to_string()), "    );".to_string()), "\n".to_string()), "    if admitted {".to_string()), "\n".to_string()), "        std::process::exit(0);".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "    std::process::exit(1);".to_string()), "\n".to_string()), "}".to_string()), "\n".to_string()), "".to_string()), "\n".to_string()), "fn main() {".to_string()), "\n".to_string()), "    let argv: Vec<String> = std::env::args().skip(1).collect();".to_string()), "\n".to_string()), "    let plan = native_driver_parse(Rc::new(argv.into()));".to_string()), "\n".to_string()), "    if let ProcessExit::ExitFailure { code, reason } = &*native_driver_plan_exit(plan.clone()) {".to_string()), "\n".to_string()), "        eprintln!(\"{reason}\");".to_string()), "\n".to_string()), "        std::process::exit(*code as i32);".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "    let source_roots: Vec<String> = native_driver_plan_source_roots(plan.clone()).iter().cloned().collect();".to_string()), "\n".to_string()), "    match &*plan {".to_string()), "\n".to_string()), "        NativeDriverPlan::NativeDriverPlanRefused { reason, detail } => {".to_string()), "\n".to_string()), "            eprintln!(\"REFUSED: native driver plan refused ({reason:?}) but its exit was success -- {detail}\");".to_string()), "\n".to_string()), "            std::process::exit(70);".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "        NativeDriverPlan::NativeDriverPlanned { verb } => {".to_string()), "\n".to_string()), "            let verb: &NativeDriverVerb = verb;".to_string()), "\n".to_string()), "            match verb {".to_string()), "\n".to_string()), "                NativeDriverVerb::NativeDriverCensus { .. } => run_census(&source_roots),".to_string()), "\n".to_string()), "                NativeDriverVerb::NativeDriverCensusResolve { .. } => run_census_resolve(&source_roots),".to_string()), "\n".to_string()), "                NativeDriverVerb::NativeDriverAdjudicate { facts_path, pattern, .. } => run_adjudication(facts_path, Rc::new(TargetPattern::clone(pattern)), &source_roots),".to_string()), "\n".to_string()), "            }".to_string()), "\n".to_string()), "        }".to_string()), "\n".to_string()), "    }".to_string()), "\n".to_string()), "}".to_string()), "\n".to_string()), "\n".to_string()),
@@ -39498,10 +39524,9 @@ pub fn emit_bootstrap_dag_operation_match_arm(
 pub fn emit_main_pipeline_fns(crate_name: String, pipeline_module: String) -> String {
     {
         let pipeline_mod =
-            crate::v1_compiler_emit_core_support::module_to_filename(pipeline_module.clone());
-        let artifact_mod = crate::v1_compiler_emit_core_support::module_to_filename(
-            "v1.compiler.artifact".to_string(),
-        );
+            crate::gunbc_rust_emitted_edge::module_to_filename(pipeline_module.clone());
+        let artifact_mod =
+            crate::gunbc_rust_emitted_edge::module_to_filename("v1.compiler.artifact".to_string());
         v1_rt::concat(
             v1_rt::concat(
                 v1_rt::concat(
@@ -39553,7 +39578,7 @@ pub fn emit_resolve_transitively_fn(crate_name: String, pipeline_mod: String) ->
 pub fn emit_main_diagnostic_fns(crate_name: String) -> String {
     {
         let core_mod =
-            crate::v1_compiler_emit_core_support::module_to_filename("v1.std.core".to_string());
+            crate::gunbc_rust_emitted_edge::module_to_filename("v1.std.core".to_string());
         v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat(v1_rt::concat("\nfn render_diagnostics(result: &PipelineResult) {\n".to_string(), "    if result.diagnostics.is_empty() {\n".to_string()), "        return;\n".to_string()), "    }\n".to_string()), "\n".to_string()), "    let index_map: HashMap<String, Rc<NewlineIndex>> = result\n".to_string()), "        .newline_indices\n".to_string()), "        .iter()\n".to_string()), "        .map(|idx| (idx.file.clone(), idx.clone()))\n".to_string()), "        .collect();\n".to_string()), "\n".to_string()), "    for d in result.diagnostics.iter() {\n".to_string()), "        render_one_diagnostic(d, &index_map, \"\");\n".to_string()), "    }\n".to_string()), "\n".to_string()), "    eprintln!(\"\\n{} error(s)\", result.diagnostics.len());\n".to_string()), "}\n".to_string()), "\n".to_string()), "fn render_one_diagnostic(\n".to_string()), "    d: &".to_string()), crate_name.clone()), "::".to_string()), core_mod.clone()), "::ErrorNode,\n".to_string()), "    index_map: &HashMap<String, Rc<NewlineIndex>>,\n".to_string()), "    indent: &str,\n".to_string()), ") {\n".to_string()), "    let severity = \"error\";\n".to_string()), "    let message = diagnostic_to_message(d.diagnostic.clone());\n".to_string()), "    let span = diagnostic_to_span(d.diagnostic.clone());\n".to_string()), "\n".to_string()), "    let location = if !span.file.is_empty() {\n".to_string()), "        if let Some(idx) = index_map.get(&span.file) {\n".to_string()), "            let lc = byte_to_line_col(idx.clone(), span.start);\n".to_string()), "            format!(\"{}:{}:{}\", span.file, lc.line, lc.col)\n".to_string()), "        } else {\n".to_string()), "            span.file.clone()\n".to_string()), "        }\n".to_string()), "    } else if !d.module_name.is_empty() {\n".to_string()), "        d.module_name.clone()\n".to_string()), "    } else {\n".to_string()), "        String::new()\n".to_string()), "    };\n".to_string()), "\n".to_string()), "    if location.is_empty() {\n".to_string()), "        eprintln!(\"{}{}: {}\", indent, severity, message);\n".to_string()), "    } else {\n".to_string()), "        eprintln!(\"{}{}[{}]: {}\", indent, severity, location, message);\n".to_string()), "    }\n".to_string()), "\n".to_string()), "    if !span.file.is_empty() {\n".to_string()), "        if let Some(idx) = index_map.get(&span.file) {\n".to_string()), "            let lc = byte_to_line_col(idx.clone(), span.start);\n".to_string()), "            let line_text = source_line_at(idx.clone(), lc.line);\n".to_string()), "            let line_num = format!(\"{}\", lc.line);\n".to_string()), "            let gutter_width = line_num.len();\n".to_string()), "            eprintln!(\"{} {} |\", indent, \" \".repeat(gutter_width));\n".to_string()), "            eprintln!(\"{} {} | {}\", indent, line_num, line_text);\n".to_string()), "\n".to_string()), "            let span_len = std::cmp::max(1, (span.end - span.start) as usize);\n".to_string()), "            let col_offset = (lc.col - 1) as usize;\n".to_string()), "            eprintln!(\n".to_string()), "                \"{} {} | {}{}\",\n".to_string()), "                indent,\n".to_string()), "                \" \".repeat(gutter_width),\n".to_string()), "                \" \".repeat(col_offset),\n".to_string()), "                \"^\".repeat(std::cmp::min(span_len, line_text.len().saturating_sub(col_offset)))\n".to_string()), "            );\n".to_string()), "        }\n".to_string()), "    }\n".to_string()), "}\n".to_string())
     }
 }
diff --git a/src/v1/stage0/src/v1_compiler_stage0_crates.rs b/src/v1/stage0/src/v1_compiler_stage0_crates.rs
index 7ab54b18e7d..2e51165a7be 100644
--- a/src/v1/stage0/src/v1_compiler_stage0_crates.rs
+++ b/src/v1/stage0/src/v1_compiler_stage0_crates.rs
@@ -35,8 +35,8 @@ use crate::gunbc_stage0_crate_partition_generated::GeneratedPartitionCrateKind::
 pub use crate::gunbc_stage0_crate_partition_generated::{
     GeneratedPartitionCrateKind, GeneratedPartitionCrateRow,
 };
-pub use crate::gunbc_stage0_emitted_edge_admission::stage0_partition_module_owner_packages;
-pub use crate::gunbc_stage0_partition_package_graph::stage0_partition_package_dependency_names;
+pub use crate::gunbc_stage0_emitted_edge_admission::partition_module_owner_packages_over;
+pub use crate::gunbc_stage0_partition_package_graph::partition_package_dependency_names_over;
 pub use crate::std_dissolution::unbound_dissolution;
 pub use crate::std_dissolution::DissolutionCondition;
 use crate::std_dissolution::DissolutionCondition::*;
@@ -75,6 +75,7 @@ pub struct Stage0CrateSpec {
     pub features: Rc<Vec<Rc<CargoFeature>>>,
     pub carries_non_empty_wrappers: bool,
     pub package_idents: Rc<Vec<Rc<PackageIdentBinding>>>,
+    pub partition_rows: Rc<Vec<Rc<GeneratedPartitionCrateRow>>>,
 }
 
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
@@ -305,11 +306,13 @@ pub enum Stage0CrateBoundaryEmitOutcome {
 
 pub fn stage0_lookup_module_owner_package_name(
     module_basename: String,
+    rows: Rc<Vec<Rc<GeneratedPartitionCrateRow>>>,
 ) -> Rc<Stage0ModuleOwnerLookup> {
     {
         let package_name =
-            crate::gunbc_stage0_emitted_edge_admission::stage0_partition_module_owner_packages(
+            crate::gunbc_stage0_emitted_edge_admission::partition_module_owner_packages_over(
                 module_basename.clone(),
+                rows.clone(),
             )
             .iter()
             .cloned()
@@ -334,11 +337,14 @@ pub fn stage0_lookup_module_owner_package_name(
     }
 }
 
-pub fn stage0_lookup_package_crate_dir(package_name: String) -> Rc<Stage0PackageCrateDirLookup> {
+pub fn stage0_lookup_package_crate_dir(
+    package_name: String,
+    rows: Rc<Vec<Rc<GeneratedPartitionCrateRow>>>,
+) -> Rc<Stage0PackageCrateDirLookup> {
     {
         let matches = Rc::new({
             let mut __result = Vec::new();
-            for row in generated_partition_crate_rows().iter().cloned() {
+            for row in rows.iter().cloned() {
                 if (row.package_name.clone() == package_name.clone()) {
                     __result.push(row);
                 }
@@ -461,6 +467,7 @@ pub fn stage0_foundation_runtime_dependencies() -> Rc<Vec<Rc<CargoDependency>>>
 
 pub fn stage0_reexport_path_dependencies_outcome(
     reexport_packages: Rc<Vec<String>>,
+    rows: Rc<Vec<Rc<GeneratedPartitionCrateRow>>>,
 ) -> Rc<Stage0ReexportPathDepsOutcome> {
     reexport_packages.iter().cloned().fold(
         Rc::new(Stage0ReexportPathDepsOutcome::Stage0ReexportPathDepsOk {
@@ -475,7 +482,7 @@ pub fn stage0_reexport_path_dependencies_outcome(
                 },
             ),
             Stage0ReexportPathDepsOutcome::Stage0ReexportPathDepsOk { deps: deps, .. } => {
-                match (*stage0_lookup_package_crate_dir(pkg.clone())).clone() {
+                match (*stage0_lookup_package_crate_dir(pkg.clone(), rows.clone())).clone() {
                     Stage0PackageCrateDirLookup::Stage0PackageCrateDirFound {
                         crate_dir: crate_dir,
                         ..
@@ -522,11 +529,14 @@ pub fn stage0_partition_row_header_doc(row: Rc<GeneratedPartitionCrateRow>) -> S
 
 pub fn stage0_partition_row_dependencies_outcome(
     row: Rc<GeneratedPartitionCrateRow>,
+    rows: Rc<Vec<Rc<GeneratedPartitionCrateRow>>>,
 ) -> Rc<Stage0PartitionRowDepsOutcome> {
     match (*stage0_reexport_path_dependencies_outcome(
-        crate::gunbc_stage0_partition_package_graph::stage0_partition_package_dependency_names(
+        crate::gunbc_stage0_partition_package_graph::partition_package_dependency_names_over(
             row.clone(),
+            rows.clone(),
         ),
+        rows.clone(),
     ))
     .clone()
     {
@@ -566,8 +576,9 @@ pub fn stage0_partition_row_features(
 pub fn stage0_partition_row_to_spec_outcome(
     row: Rc<GeneratedPartitionCrateRow>,
     package_idents: Rc<Vec<Rc<PackageIdentBinding>>>,
+    rows: Rc<Vec<Rc<GeneratedPartitionCrateRow>>>,
 ) -> Rc<Stage0PartitionRowSpecOutcome> {
-    match (*stage0_partition_row_dependencies_outcome(row.clone())).clone() {
+    match (*stage0_partition_row_dependencies_outcome(row.clone(), rows.clone())).clone() {
         Stage0PartitionRowDepsOutcome::Stage0PartitionRowDepsRefused { cause: cause, .. } => {
             Rc::new(
                 Stage0PartitionRowSpecOutcome::Stage0PartitionRowSpecRefused {
@@ -588,6 +599,7 @@ pub fn stage0_partition_row_to_spec_outcome(
                     features: stage0_partition_row_features(row.clone()),
                     carries_non_empty_wrappers: row.carries_non_empty_wrappers.clone(),
                     package_idents: package_idents.clone(),
+                    partition_rows: rows.clone(),
                 }),
             })
         }
@@ -820,6 +832,7 @@ pub fn render_stage0_layered_core_lib(
 pub fn stage0_emit_shell_module_reexports_outcome(
     modules: Rc<Vec<String>>,
     package_idents: Rc<Vec<Rc<PackageIdentBinding>>>,
+    rows: Rc<Vec<Rc<GeneratedPartitionCrateRow>>>,
 ) -> Rc<Stage0EmitShellReexportsOutcome> {
     modules.iter().cloned().fold(
         Rc::new(
@@ -846,56 +859,57 @@ pub fn stage0_emit_shell_module_reexports_outcome(
             ),
             Stage0EmitShellReexportsOutcome::Stage0EmitShellReexportsOk {
                 lines: lines, ..
-            } => {
-                match (*stage0_lookup_module_owner_package_name(module_basename.clone())).clone() {
-                    Stage0ModuleOwnerLookup::Stage0ModuleOwnerFound {
-                        package_name: owner,
-                        ..
-                    } => match crate::gunbc_rust_crate_package_ident::package_ident_bound(
-                        package_idents.clone(),
-                        owner.clone(),
-                    ) {
-                        std::option::Option::None => Rc::new(
-                            Stage0EmitShellReexportsOutcome::Stage0EmitShellReexportsIdentUnbound {
-                                package_name: owner.clone(),
-                            },
-                        ),
-                        Some(ident) => Rc::new(
-                            Stage0EmitShellReexportsOutcome::Stage0EmitShellReexportsOk {
-                                lines: v1_rt::concat(
-                                    lines.clone(),
-                                    Rc::new(vec![v1_rt::concat(
+            } => match (*stage0_lookup_module_owner_package_name(
+                module_basename.clone(),
+                rows.clone(),
+            ))
+            .clone()
+            {
+                Stage0ModuleOwnerLookup::Stage0ModuleOwnerFound {
+                    package_name: owner,
+                    ..
+                } => match crate::gunbc_rust_crate_package_ident::package_ident_bound(
+                    package_idents.clone(),
+                    owner.clone(),
+                ) {
+                    std::option::Option::None => Rc::new(
+                        Stage0EmitShellReexportsOutcome::Stage0EmitShellReexportsIdentUnbound {
+                            package_name: owner.clone(),
+                        },
+                    ),
+                    Some(ident) => Rc::new(
+                        Stage0EmitShellReexportsOutcome::Stage0EmitShellReexportsOk {
+                            lines: v1_rt::concat(
+                                lines.clone(),
+                                Rc::new(vec![v1_rt::concat(
+                                    v1_rt::concat(
                                         v1_rt::concat(
                                             v1_rt::concat(
                                                 v1_rt::concat(
                                                     v1_rt::concat(
-                                                        v1_rt::concat(
-                                                            "pub mod ".to_string(),
-                                                            module_basename.clone(),
-                                                        ),
-                                                        " {\n    pub use ".to_string(),
+                                                        "pub mod ".to_string(),
+                                                        module_basename.clone(),
                                                     ),
-                                                    ident.clone(),
+                                                    " {\n    pub use ".to_string(),
                                                 ),
-                                                "::".to_string(),
+                                                ident.clone(),
                                             ),
-                                            module_basename.clone(),
+                                            "::".to_string(),
                                         ),
-                                        "::*;\n}".to_string(),
-                                    )]),
-                                ),
-                            },
-                        ),
+                                        module_basename.clone(),
+                                    ),
+                                    "::*;\n}".to_string(),
+                                )]),
+                            ),
+                        },
+                    ),
+                },
+                Stage0ModuleOwnerLookup::Stage0ModuleOwnerRefused { cause: cause, .. } => Rc::new(
+                    Stage0EmitShellReexportsOutcome::Stage0EmitShellReexportsRefused {
+                        cause: cause.clone(),
                     },
-                    Stage0ModuleOwnerLookup::Stage0ModuleOwnerRefused { cause: cause, .. } => {
-                        Rc::new(
-                            Stage0EmitShellReexportsOutcome::Stage0EmitShellReexportsRefused {
-                                cause: cause.clone(),
-                            },
-                        )
-                    }
-                }
-            }
+                ),
+            },
         },
     )
 }
@@ -903,7 +917,7 @@ pub fn stage0_emit_shell_module_reexports_outcome(
 pub fn render_stage0_emit_core_lib_outcome(
     spec: Rc<Stage0CrateSpec>,
 ) -> Rc<Stage0CrateLibEmitOutcome> {
-    match (*stage0_emit_shell_module_reexports_outcome(spec.modules.clone(), spec.package_idents.clone())).clone() {
+    match (*stage0_emit_shell_module_reexports_outcome(spec.modules.clone(), spec.package_idents.clone(), spec.partition_rows.clone())).clone() {
     Stage0EmitShellReexportsOutcome::Stage0EmitShellReexportsRefused { cause: cause, .. } => Rc::new(Stage0CrateLibEmitOutcome::Stage0CrateLibEmitRefused {
     cause: cause.clone(),
 }),
@@ -942,9 +956,15 @@ pub fn emit_stage0_crate_lib_outcome(spec: Rc<Stage0CrateSpec>) -> Rc<Stage0Crat
 }
 
 pub fn stage0_crate_plan_outcome() -> Rc<Stage0CratePlanOutcome> {
+    partition_crate_plan_outcome_over(generated_partition_crate_rows())
+}
+
+pub fn partition_crate_plan_outcome_over(
+    rows: Rc<Vec<Rc<GeneratedPartitionCrateRow>>>,
+) -> Rc<Stage0CratePlanOutcome> {
     match (*crate::gunbc_rust_crate_package_ident::rust_crate_package_idents(Rc::new({
         let mut __result = Vec::new();
-        for row in generated_partition_crate_rows().iter().cloned() {
+        for row in rows.iter().cloned() {
             __result.push(row.package_name.clone());
         }
         __result
@@ -958,14 +978,15 @@ pub fn stage0_crate_plan_outcome() -> Rc<Stage0CratePlanOutcome> {
         }
         PackageIdentSetOutcome::PackageIdentSetOk {
             bindings: bindings, ..
-        } => stage0_crate_plan_from_admitted_rows(bindings.clone()),
+        } => stage0_crate_plan_from_admitted_rows(bindings.clone(), rows.clone()),
     }
 }
 
 pub fn stage0_crate_plan_from_admitted_rows(
     package_idents: Rc<Vec<Rc<PackageIdentBinding>>>,
+    rows: Rc<Vec<Rc<GeneratedPartitionCrateRow>>>,
 ) -> Rc<Stage0CratePlanOutcome> {
-    generated_partition_crate_rows().iter().cloned().fold(
+    rows.clone().iter().cloned().fold(
         Rc::new(Stage0CratePlanOutcome::Stage0CratePlanOk {
             plan: Rc::new(Stage0CratePlan {
                 crates: Rc::new(vec![]),
@@ -984,8 +1005,12 @@ pub fn stage0_crate_plan_from_admitted_rows(
                 })
             }
             Stage0CratePlanOutcome::Stage0CratePlanOk { plan: plan, .. } => {
-                match (*stage0_partition_row_to_spec_outcome(row.clone(), package_idents.clone()))
-                    .clone()
+                match (*stage0_partition_row_to_spec_outcome(
+                    row.clone(),
+                    package_idents.clone(),
+                    rows.clone(),
+                ))
+                .clone()
                 {
                     Stage0PartitionRowSpecOutcome::Stage0PartitionRowSpecRefused {
                         cause: cause,
@@ -1032,7 +1057,13 @@ pub fn emit_stage0_crate_boundary_files_outcome(
 }
 
 pub fn stage0_crate_boundary_emit_outcome() -> Rc<Stage0CrateBoundaryEmitOutcome> {
-    match (*stage0_crate_plan_outcome()).clone() {
+    partition_crate_boundary_emit_outcome_over(generated_partition_crate_rows())
+}
+
+pub fn partition_crate_boundary_emit_outcome_over(
+    rows: Rc<Vec<Rc<GeneratedPartitionCrateRow>>>,
+) -> Rc<Stage0CrateBoundaryEmitOutcome> {
+    match (*partition_crate_plan_outcome_over(rows.clone())).clone() {
     Stage0CratePlanOutcome::Stage0CratePlanRefused { cause: cause, .. } => Rc::new(Stage0CrateBoundaryEmitOutcome::Stage0CrateBoundaryEmitRefused {
     cause: stage0_map_package_dir_refusal_to_boundary(cause.clone()),
 }),
diff --git a/src/v1/stage0_crates.dag b/src/v1/stage0_crates.dag
index 5c48ac0a911..bbb588362a1 100644
--- a/src/v1/stage0_crates.dag
+++ b/src/v1/stage0_crates.dag
@@ -17,9 +17,9 @@ import gunbc.rust_crate_package_ident {
   rust_crate_package_idents
 }
 import gunbc.stage0_partition_package_graph {
-  stage0_partition_package_dependency_names
+  partition_package_dependency_names_over
 }
-import gunbc.stage0_emitted_edge_admission { stage0_partition_module_owner_packages }
+import gunbc.stage0_emitted_edge_admission { partition_module_owner_packages_over }
 import gunbc.stage0_crate_partition_generated {
   GeneratedEmitCoreCrate,
   GeneratedFoundationCrate,
@@ -45,6 +45,7 @@ type Stage0CrateSpec {
   features: List<CargoFeature>
   carries_non_empty_wrappers: Bool
   package_idents: List<PackageIdentBinding>
+  partition_rows: List<GeneratedPartitionCrateRow>
 }
 
 type Stage0CratePlan {
@@ -184,8 +185,8 @@ type Stage0CrateBoundaryEmitOutcome
   = Stage0CrateBoundaryEmitOk { files: List<TextFile> }
   | Stage0CrateBoundaryEmitRefused { cause: Stage0CrateBoundaryEmitRefusalCause }
 
-fn stage0_lookup_module_owner_package_name(module_basename: String) -> Stage0ModuleOwnerLookup {
-  let package_name = stage0_partition_module_owner_packages(module_basename: module_basename)
+fn stage0_lookup_module_owner_package_name(module_basename: String, rows: List<GeneratedPartitionCrateRow>) -> Stage0ModuleOwnerLookup {
+  let package_name = partition_module_owner_packages_over(module_basename: module_basename, rows: rows)
     |> fold(init: "", f: fn(acc, pkg) { if acc == "" { pkg } else { acc } })
   if package_name == "" {
     Stage0ModuleOwnerRefused {
@@ -196,8 +197,8 @@ fn stage0_lookup_module_owner_package_name(module_basename: String) -> Stage0Mod
   }
 }
 
-fn stage0_lookup_package_crate_dir(package_name: String) -> Stage0PackageCrateDirLookup {
-  let matches = generated_partition_crate_rows
+fn stage0_lookup_package_crate_dir(package_name: String, rows: List<GeneratedPartitionCrateRow>) -> Stage0PackageCrateDirLookup {
+  let matches = rows
     |> filter(row => row.package_name == package_name)
   let crate_dir = matches
     |> fold(init: "", f: fn(acc, row) { if acc == "" { row.crate_dir } else { acc } })
@@ -264,7 +265,8 @@ fn stage0_foundation_runtime_dependencies() -> List<CargoDependency> {
 }
 
 fn stage0_reexport_path_dependencies_outcome(
-  reexport_packages: List<String>
+  reexport_packages: List<String>,
+  rows: List<GeneratedPartitionCrateRow>
 ) -> Stage0ReexportPathDepsOutcome {
   reexport_packages
     |> fold(init: Stage0ReexportPathDepsOk { deps: [] }, f: fn(acc, pkg) {
@@ -272,7 +274,7 @@ fn stage0_reexport_path_dependencies_outcome(
         Stage0ReexportPathDepsRefused { cause: cause } =>
           Stage0ReexportPathDepsRefused { cause: cause }
         Stage0ReexportPathDepsOk { deps: deps } =>
-          match stage0_lookup_package_crate_dir(package_name: pkg) {
+          match stage0_lookup_package_crate_dir(package_name: pkg, rows: rows) {
             Stage0PackageCrateDirFound { crate_dir: crate_dir } =>
               Stage0ReexportPathDepsOk {
                 deps: deps |> concat([
@@ -314,10 +316,12 @@ fn stage0_partition_row_header_doc(row: GeneratedPartitionCrateRow) -> String {
 // here with the emit shell's rule written out a second time; they no longer differ at all, which
 // is what having one graph means.
 fn stage0_partition_row_dependencies_outcome(
-  row: GeneratedPartitionCrateRow
+  row: GeneratedPartitionCrateRow,
+  rows: List<GeneratedPartitionCrateRow>
 ) -> Stage0PartitionRowDepsOutcome {
   match stage0_reexport_path_dependencies_outcome(
-    reexport_packages: stage0_partition_package_dependency_names(row: row)
+    reexport_packages: partition_package_dependency_names_over(row: row, rows: rows),
+    rows: rows
   ) {
     Stage0ReexportPathDepsOk { deps: path_deps } =>
       Stage0PartitionRowDepsOk {
@@ -349,9 +353,10 @@ fn stage0_partition_row_features(row: GeneratedPartitionCrateRow) -> List<CargoF
 
 fn stage0_partition_row_to_spec_outcome(
   row: GeneratedPartitionCrateRow,
-  package_idents: List<PackageIdentBinding>
+  package_idents: List<PackageIdentBinding>,
+  rows: List<GeneratedPartitionCrateRow>
 ) -> Stage0PartitionRowSpecOutcome {
-  match stage0_partition_row_dependencies_outcome(row: row) {
+  match stage0_partition_row_dependencies_outcome(row: row, rows: rows) {
     Stage0PartitionRowDepsRefused { cause: cause } =>
       Stage0PartitionRowSpecRefused { cause: cause }
     Stage0PartitionRowDepsOk { deps: deps } =>
@@ -366,7 +371,8 @@ fn stage0_partition_row_to_spec_outcome(
           dependencies: deps,
           features: stage0_partition_row_features(row: row),
           carries_non_empty_wrappers: row.carries_non_empty_wrappers,
-          package_idents: package_idents
+          package_idents: package_idents,
+          partition_rows: rows
         }
       }
   }
@@ -465,7 +471,8 @@ fn render_stage0_layered_core_lib(spec: Stage0CrateSpec, reexport_idents: List<S
 
 fn stage0_emit_shell_module_reexports_outcome(
   modules: List<String>,
-  package_idents: List<PackageIdentBinding>
+  package_idents: List<PackageIdentBinding>,
+  rows: List<GeneratedPartitionCrateRow>
 ) -> Stage0EmitShellReexportsOutcome {
   modules
     |> fold(init: Stage0EmitShellReexportsOk { lines: [] }, f: fn(acc, module_basename) {
@@ -475,7 +482,7 @@ fn stage0_emit_shell_module_reexports_outcome(
         Stage0EmitShellReexportsIdentUnbound { package_name: missing } =>
           Stage0EmitShellReexportsIdentUnbound { package_name: missing }
         Stage0EmitShellReexportsOk { lines: lines } =>
-          match stage0_lookup_module_owner_package_name(module_basename: module_basename) {
+          match stage0_lookup_module_owner_package_name(module_basename: module_basename, rows: rows) {
             Stage0ModuleOwnerFound { package_name: owner } =>
               match package_ident_bound(bindings: package_idents, package_name: owner) {
                 Absent => Stage0EmitShellReexportsIdentUnbound { package_name: owner }
@@ -498,7 +505,7 @@ fn stage0_emit_shell_module_reexports_outcome(
 }
 
 fn render_stage0_emit_core_lib_outcome(spec: Stage0CrateSpec) -> Stage0CrateLibEmitOutcome {
-  match stage0_emit_shell_module_reexports_outcome(modules: spec.modules, package_idents: spec.package_idents) {
+  match stage0_emit_shell_module_reexports_outcome(modules: spec.modules, package_idents: spec.package_idents, rows: spec.partition_rows) {
     Stage0EmitShellReexportsRefused { cause: cause } =>
       Stage0CrateLibEmitRefused { cause: cause }
     Stage0EmitShellReexportsIdentUnbound { package_name: package_name } =>
@@ -559,16 +566,24 @@ fn emit_stage0_crate_lib_outcome(spec: Stage0CrateSpec) -> Stage0CrateLibEmitOut
 // names are hyphen-only and cannot collide, so this admission changes no rendered byte. It is landed
 // because the derived partition will supply names nobody reviewed one at a time.
 fn stage0_crate_plan_outcome() -> Stage0CratePlanOutcome {
+  partition_crate_plan_outcome_over(rows: generated_partition_crate_rows)
+}
+
+// ONE RENDERER FOR EVERY PARTITION ROW SET. The committed stage0 rows are one set; a derivation
+// that partitions an emitted closure (v2.workflow.emitted_crate_workspace) produces another of the
+// same shape, and it is rendered here rather than by a second manifest and lib.rs writer beside
+// this one. Every lookup below reads the set it was handed, never the committed one.
+fn partition_crate_plan_outcome_over(rows: List<GeneratedPartitionCrateRow>) -> Stage0CratePlanOutcome {
   match rust_crate_package_idents(
-    package_names: generated_partition_crate_rows |> map(row => row.package_name)
+    package_names: rows |> map(row => row.package_name)
   ) {
     PackageIdentSetRefused { cause: cause } => Stage0CratePlanIdentRefused { cause: cause }
-    PackageIdentSetOk { bindings: bindings } => stage0_crate_plan_from_admitted_rows(package_idents: bindings)
+    PackageIdentSetOk { bindings: bindings } => stage0_crate_plan_from_admitted_rows(package_idents: bindings, rows: rows)
   }
 }
 
-fn stage0_crate_plan_from_admitted_rows(package_idents: List<PackageIdentBinding>) -> Stage0CratePlanOutcome {
-  generated_partition_crate_rows
+fn stage0_crate_plan_from_admitted_rows(package_idents: List<PackageIdentBinding>, rows: List<GeneratedPartitionCrateRow>) -> Stage0CratePlanOutcome {
+  rows
     |> fold(init: Stage0CratePlanOk { plan: Stage0CratePlan { crates: [] } }, f: fn(acc, row) {
       match acc {
         Stage0CratePlanRefused { cause: cause } =>
@@ -576,7 +591,7 @@ fn stage0_crate_plan_from_admitted_rows(package_idents: List<PackageIdentBinding
         Stage0CratePlanIdentRefused { cause: cause } =>
           Stage0CratePlanIdentRefused { cause: cause }
         Stage0CratePlanOk { plan: plan } =>
-          match stage0_partition_row_to_spec_outcome(row: row, package_idents: package_idents) {
+          match stage0_partition_row_to_spec_outcome(row: row, package_idents: package_idents, rows: rows) {
             Stage0PartitionRowSpecRefused { cause: cause } =>
               Stage0CratePlanRefused { cause: cause }
             Stage0PartitionRowSpecOk { spec: spec } =>
@@ -621,7 +636,11 @@ fn emit_stage0_crate_boundary_files_outcome(
 }
 
 fn stage0_crate_boundary_emit_outcome() -> Stage0CrateBoundaryEmitOutcome {
-  match stage0_crate_plan_outcome() {
+  partition_crate_boundary_emit_outcome_over(rows: generated_partition_crate_rows)
+}
+
+fn partition_crate_boundary_emit_outcome_over(rows: List<GeneratedPartitionCrateRow>) -> Stage0CrateBoundaryEmitOutcome {
+  match partition_crate_plan_outcome_over(rows: rows) {
     Stage0CratePlanRefused { cause: cause } =>
       Stage0CrateBoundaryEmitRefused {
         cause: stage0_map_package_dir_refusal_to_boundary(cause: cause)
diff --git a/src/v2/test/claim/emitted_crate_workspace_witness_test.dag b/src/v2/test/claim/emitted_crate_workspace_witness_test.dag
new file mode 100644
index 00000000000..99dd93ec995
--- /dev/null
+++ b/src/v2/test/claim/emitted_crate_workspace_witness_test.dag
@@ -0,0 +1,133 @@
+module test.claim.emitted_crate_workspace_witness
+
+import std.types { Bool, List, String }
+import v2.std.collection { empty_map }
+import v2.std.compilers.compilation_unit { ModuleDag, ModuleDagEdge, ModuleId }
+import v2.std.live_tree { LiveTreeDisposition, SubstrateInputsOnly }
+import v2.workflow.emitted_crate_workspace {
+  EmittedWorkspacePlanned,
+  EmittedWorkspaceRefused,
+  EmittedWorkspaceClosuresDisagree,
+  EmittedWorkspaceNoDiscriminatingEdge,
+  emitted_workspace_plan_over,
+  emitted_workspace_runtime_package
+}
+
+data live_tree_disposition: LiveTreeDisposition = SubstrateInputsOnly
+
+// ── THE PLAN OVER A SUPPLIED CHAIN, a -> b -> c, ONE MODULE PER CRATE ─────────────────────────
+//
+// The subject is v2.workflow.emitted_crate_workspace emitted_workspace_plan_over: given a module
+// DAG, the basenames the emission wrote and its returned edges, which crate rows does it
+// derive and which dependency does the RED drop. The DAG and edges are supplied, because the claim
+// is about the plan, not about the live closure; the live closure is the instrument
+// //gunbc/instruments:emitted-crate-workspace's subject, which renders these rows and builds them.
+
+fn chain_dag() -> ModuleDag {
+  ModuleDag {
+    modules: ["fx.a" as ModuleId, "fx.b" as ModuleId, "fx.c" as ModuleId],
+    edges: [
+      ModuleDagEdge { from: "fx.a" as ModuleId, to: "fx.b" as ModuleId },
+      ModuleDagEdge { from: "fx.b" as ModuleId, to: "fx.c" as ModuleId }
+    ],
+    exports: empty_map(),
+    type_definitions: empty_map()
+  }
+}
+
+fn chain_emitted_basenames() -> List<String> { ["fx_a", "fx_b", "fx_c", "v1_rt"] }
+
+// The emission's own edges for the chain: every module's prelude into the runtime and the crate
+// root, and the use-lines a names b and b names c.
+fn chain_edge_froms() -> List<String> { ["fx_a", "fx_a", "fx_b", "fx_b", "fx_c", "fx_c", "fx_a", "fx_b"] }
+fn chain_edge_tos() -> List<String> { ["v1_rt", "", "v1_rt", "", "v1_rt", "", "fx_b", "fx_c"] }
+fn chain_edge_provenances() -> List<String> {
+  ["runtime-prelude", "reexport-facade", "runtime-prelude", "reexport-facade", "runtime-prelude", "reexport-facade",
+   "semantic-source-reference", "semantic-source-reference"]
+}
+
+// A crate's re-exports are its TRANSITIVE dependency packages plus the runtime; the top crate
+// therefore re-exports both crates below it, and the RED drops an IRREDUNDANT edge -- one no other
+// dependency re-exports by a second road.
+test fn the_chain_plans_three_crates_plus_the_runtime_with_transitive_reexports() -> Bool {
+  match emitted_workspace_plan_over(
+    module_dag: chain_dag(),
+    emitted_basenames: chain_emitted_basenames(),
+    edge_froms: chain_edge_froms(),
+    edge_tos: chain_edge_tos(),
+    edge_provenances: chain_edge_provenances(),
+    target_crate_count: 3
+  ) {
+    EmittedWorkspacePlanned { plan: plan } =>
+      plan.crate_count == 4
+        && plan.module_count == 3
+        && plan.rows |> any(r => r.package_name == emitted_workspace_runtime_package && r.modules |> any(m => m == "v1_rt"))
+        && plan.rows |> any(r => (r.modules |> any(m => m == "fx_a")) && (r.reexport_packages |> count) == 3)
+        && plan.rows |> any(r => (r.modules |> any(m => m == "fx_c")) && (r.reexport_packages |> count) == 1)
+    EmittedWorkspaceRefused { cause: _ } => false
+  }
+}
+
+test fn the_red_drops_an_edge_the_emitter_wrote_as_a_use_line() -> Bool {
+  match emitted_workspace_plan_over(
+    module_dag: chain_dag(),
+    emitted_basenames: chain_emitted_basenames(),
+    edge_froms: chain_edge_froms(),
+    edge_tos: chain_edge_tos(),
+    edge_provenances: chain_edge_provenances(),
+    target_crate_count: 3
+  ) {
+    EmittedWorkspacePlanned { plan: plan } =>
+      plan.red.package != plan.red.dropped_package
+        && ((plan.red.from_module == "fx_a" && plan.red.to_module == "fx_b") || (plan.red.from_module == "fx_b" && plan.red.to_module == "fx_c"))
+        && plan.red_rows |> any(r => r.package_name == plan.red.package && !(r.reexport_packages |> any(p => p == plan.red.dropped_package)))
+        && plan.rows |> any(r => r.package_name == plan.red.package && (r.reexport_packages |> any(p => p == plan.red.dropped_package)))
+    EmittedWorkspaceRefused { cause: _ } => false
+  }
+}
+
+// One crate: nothing crosses a crate boundary, so no RED is authorable, and the plan refuses
+// rather than reporting a build it cannot discriminate.
+test fn a_single_crate_plan_refuses_for_want_of_a_discriminating_edge() -> Bool {
+  match emitted_workspace_plan_over(
+    module_dag: chain_dag(),
+    emitted_basenames: chain_emitted_basenames(),
+    edge_froms: chain_edge_froms(),
+    edge_tos: chain_edge_tos(),
+    edge_provenances: chain_edge_provenances(),
+    target_crate_count: 1
+  ) {
+    EmittedWorkspaceRefused { cause: EmittedWorkspaceNoDiscriminatingEdge } => true
+    _ => false
+  }
+}
+
+test fn a_dag_module_the_emission_did_not_produce_refuses_by_name() -> Bool {
+  match emitted_workspace_plan_over(
+    module_dag: chain_dag(),
+    emitted_basenames: ["fx_a", "fx_b", "v1_rt"],
+    edge_froms: [],
+    edge_tos: [],
+    edge_provenances: [],
+    target_crate_count: 3
+  ) {
+    EmittedWorkspaceRefused { cause: EmittedWorkspaceClosuresDisagree { not_emitted: n, outside_dag: o } } =>
+      n == ["fx.c"] && (o |> count) == 0
+    _ => false
+  }
+}
+
+test fn an_emitted_module_outside_the_dag_refuses_by_name() -> Bool {
+  match emitted_workspace_plan_over(
+    module_dag: chain_dag(),
+    emitted_basenames: ["fx_a", "fx_b", "fx_c", "v1_rt", "fx_stray"],
+    edge_froms: [],
+    edge_tos: [],
+    edge_provenances: [],
+    target_crate_count: 3
+  ) {
+    EmittedWorkspaceRefused { cause: EmittedWorkspaceClosuresDisagree { not_emitted: n, outside_dag: o } } =>
+      (n |> count) == 0 && o == ["fx_stray"]
+    _ => false
+  }
+}
diff --git a/src/v2/workflow/emitted_crate_workspace.dag b/src/v2/workflow/emitted_crate_workspace.dag
new file mode 100644
index 00000000000..a503252d0bf
--- /dev/null
+++ b/src/v2/workflow/emitted_crate_workspace.dag
@@ -0,0 +1,471 @@
+module v2.workflow.emitted_crate_workspace
+
+import std.types { List, String, Bool, Int, NonEmptyStr }
+import v2.std.collection { empty_map, map_get, map_insert }
+import v2.std.optional { Absent, Optional, Present, optional_present }
+import v2.std.diagnostic { Accepted, Rejected }
+import v2.std.compilers.compilation_unit {
+  CompilationUnitId,
+  ModuleDag,
+  ModuleDagEdge,
+  ModuleId,
+  list_unique_sorted_ids
+}
+import gunbc.rust_emitted_edge {
+  EmittedEdge,
+  EmittedEdgeProvenance,
+  EmittedModuleTarget,
+  EmittedCrateRootTarget,
+  RuntimePrelude,
+  ReexportFacade,
+  SemanticSourceReference,
+  rust_module_emit_filename,
+  rust_runtime_prelude_module
+}
+import gunbc.stage0_crate_partition_generated {
+  GeneratedPartitionCrateRow,
+  GeneratedFoundationCrate,
+  GeneratedLayeredCoreCrate
+}
+import v2.workflow.emitted_closure_crate_partition {
+  ModuleDagDerivationRefusal,
+  ModuleDagDerived,
+  ModuleDagDerivationRefused,
+  emitted_compiler_closure_module_dag
+}
+import v2.workflow.rust_crate_partition {
+  EmittedEdgeRefusal,
+  ModuleDagEmittedMerged,
+  ModuleDagEmittedRefused,
+  PartitionPolicy,
+  PolicyPartitionParam,
+  ResolvePartitionOk,
+  ResolvePartitionRefused,
+  ResolvePartitionRefusalCause,
+  Stage0FoundationCrate,
+  Stage0LayeredCoreCrate,
+  Stage0PartitionCrateRow,
+  UnitDepEdge,
+  DerivedDepPackagesOk,
+  DerivedDepPackagesUnitHasNoRow,
+  assignment_unit_dep_edges,
+  derived_dep_packages,
+  module_dag_with_emitted_edges,
+  resolve_partition_outcome,
+  rust_crate_partition_declared_core_target,
+  unit_dep_closure,
+  unit_direct_deps
+}
+
+// THE EMITTED COMPILER CLOSURE AS A CARGO WORKSPACE, DERIVED (Pkg7d render, Pkg7e build).
+//
+// Every fact here is derived, and none is read from the committed stage0 rows: the module DAG is
+// v2.workflow.emitted_closure_crate_partition's derivation from the live dependency facts; the
+// emitter's own edges (gunbc.rust_emitted_edge, returned beside the text by the emission this
+// workspace is built from) are merged into it with the typed reverse-edge refusal; the balanced
+// policy assigns modules to units; and each unit's dependency packages are the TRANSITIVE CLOSURE
+// of the unit dep edges the assignment induces (rust_crate_partition derived_dep_packages, the
+// #12035 derivation). The rows produced here have the shape v1.compiler.stage0_crates renders, so
+// the manifests and lib.rs files come from the one partition renderer, not a second one.
+//
+// WHAT THE FACADE PROVES AND WHAT IT DOES NOT. A layered crate's lib.rs re-exports every package in
+// its transitive dependency closure as `pub use <ident>::*;`, which is how an emitted
+// `crate::<module>::` path resolves in a crate that does not own the module. That is an
+// OVER-APPROXIMATION of the direct edges, deliberately: the inline paths the expression emitter
+// writes are not returned as edges (gunbc.guarantee_stall
+// emitted_inline_crate_path_edges_unreturned_stall), so the facade must cover what the edge set
+// cannot name. The plan reports whether the facade degenerates to the whole closure
+// (facade_is_whole_closure) so a green over that degenerate case is never read as a partition.
+//
+// A DAG module is placed by the basename the emitter writes for it (gunbc.rust_emitted_edge
+// rust_module_emit_filename, the one home of that rule, which the edge rows name endpoints by). The
+// caller supplies the basenames the emission actually wrote. The two closures -- the one the live
+// dependency facts derive and the one the emission compiled -- must be the SAME population: a DAG
+// module whose file the emission did not produce, and an emitted file that is neither a DAG module
+// nor the runtime, are refused together, every member named, never narrowed to the intersection.
+
+type EmittedWorkspaceRefusal
+  = EmittedWorkspaceDagRefused { cause: ModuleDagDerivationRefusal }
+  | EmittedWorkspaceBasenameShared { basename: String }
+  | EmittedWorkspaceClosuresDisagree { not_emitted: List<String>, outside_dag: List<String> }
+  | EmittedWorkspaceEdgeListsMisaligned { froms: Int, tos: Int, provenances: Int }
+  | EmittedWorkspaceEdgeProvenanceUnknown { provenance: String }
+  | EmittedWorkspaceEdgeMergeRefused { cause: EmittedEdgeRefusal }
+  | EmittedWorkspacePartitionRefused { cause: ResolvePartitionRefusalCause }
+  | EmittedWorkspaceUnitHasNoRow { unit_id: CompilationUnitId }
+  | EmittedWorkspaceNoDiscriminatingEdge
+
+// The one crate dependency the RED drops: a direct unit dep edge in the TRANSITIVE REDUCTION (no
+// other dependency of the source crate reaches the target, so no glob facade can re-export it by
+// another road) that the emitter also wrote as a use-line from a source-crate module into a
+// target-crate module, so rustc has a path that must stop resolving.
+type EmittedWorkspaceRedDrop {
+  package: String
+  dropped_package: String
+  from_module: String
+  to_module: String
+}
+
+type EmittedWorkspacePlan {
+  rows: List<GeneratedPartitionCrateRow>
+  red_rows: List<GeneratedPartitionCrateRow>
+  red: EmittedWorkspaceRedDrop
+  module_count: Int
+  crate_count: Int
+  facade_is_whole_closure: Bool
+}
+
+type EmittedWorkspaceOutcome
+  = EmittedWorkspacePlanned { plan: EmittedWorkspacePlan }
+  | EmittedWorkspaceRefused { cause: EmittedWorkspaceRefusal }
+
+data emitted_workspace_runtime_package: String = "v2-emitted-runtime"
+
+fn emitted_workspace_package(unit_id: CompilationUnitId) -> String {
+  concat("v2-emitted-", unit_id as String)
+}
+
+fn emitted_workspace_crate_dir(package: String) -> String {
+  concat("src/v1/", package)
+}
+
+fn emitted_workspace_lookup(m: Map<String, String>, key: String) -> Optional<String> {
+  match map_get(m, key) {
+    Accepted { value: found, diagnostics: _ } => found
+    Rejected { diagnostics: _ } => Absent
+  }
+}
+
+fn emitted_workspace_provenance(name: String) -> Optional<EmittedEdgeProvenance> {
+  if name == "runtime-prelude" { optional_present(value: RuntimePrelude) }
+  else if name == "reexport-facade" { optional_present(value: ReexportFacade) }
+  else if name == "semantic-source-reference" { optional_present(value: SemanticSourceReference) }
+  else { Absent }
+}
+
+type SharedBasenameScan {
+  seen: Map<String, String>
+  shared: Optional<String>
+}
+
+// The DAG's modules by their emitted basename. Two modules projecting to one basename would write
+// one file, so that is refused rather than letting the second overwrite the first.
+fn emitted_workspace_basename_index(module_dag: ModuleDag) -> BasenameIndexBuild {
+  let scan = module_dag.modules |> fold(init: SharedBasenameScan { seen: empty_map(), shared: Absent }, f: fn(acc, m) {
+    match acc.shared {
+      Present { value: _ } => acc
+      Absent => {
+        let b = rust_module_emit_filename(module_name: m as String)
+        match emitted_workspace_lookup(m: acc.seen, key: b) {
+          Present { value: _ } => SharedBasenameScan { seen: acc.seen, shared: optional_present(value: b) }
+          Absent => SharedBasenameScan { seen: map_insert(acc.seen, b, m as String), shared: Absent }
+        }
+      }
+    }
+  })
+  match scan.shared {
+    Present { value: b } => BasenameIndexRefused { cause: EmittedWorkspaceBasenameShared { basename: b } }
+    Absent => BasenameIndexOk { module_by_basename: scan.seen }
+  }
+}
+
+type BasenameIndexBuild
+  = BasenameIndexOk { module_by_basename: Map<String, String> }
+  | BasenameIndexRefused { cause: EmittedWorkspaceRefusal }
+
+type EdgeListBuild
+  = EdgeListOk { edges: List<EmittedEdge> }
+  | EdgeListRefused { cause: EmittedWorkspaceRefusal }
+
+fn emitted_workspace_edges(froms: List<String>, tos: List<String>, provenances: List<String>) -> EdgeListBuild {
+  if ((froms |> count) != (tos |> count)) || ((froms |> count) != (provenances |> count)) {
+    EdgeListRefused { cause: EmittedWorkspaceEdgeListsMisaligned { froms: froms |> count, tos: tos |> count, provenances: provenances |> count } }
+  } else {
+    froms |> enumerate |> fold(init: EdgeListOk { edges: [] }, f: fn(acc, pair) {
+      match acc {
+        EdgeListRefused { cause: c } => EdgeListRefused { cause: c }
+        EdgeListOk { edges: edges } => {
+          let to = match tos |> get(pair.first) { Present { value: t } => t  Absent => "" }
+          let provenance_name = match provenances |> get(pair.first) { Present { value: n } => n  Absent => "" }
+          match emitted_workspace_provenance(name: provenance_name) {
+            Absent => EdgeListRefused { cause: EmittedWorkspaceEdgeProvenanceUnknown { provenance: provenance_name } }
+            Present { value: p } =>
+              EdgeListOk {
+                edges: edges |> list_push(EmittedEdge {
+                  from: pair.second,
+                  to: if to == "" { EmittedCrateRootTarget } else { EmittedModuleTarget { module: to } },
+                  provenance: p
+                })
+              }
+          }
+        }
+      }
+    })
+  }
+}
+
+// The derived DAG in BASENAME space, with the runtime module as a node, because that is the space
+// the emitter's edges and the rendered includes speak.
+type BasenameDagBuild
+  = BasenameDagOk { module_dag: ModuleDag }
+  | BasenameDagRefused { cause: EmittedWorkspaceRefusal }
+
+fn emitted_workspace_basename_dag(module_dag: ModuleDag, module_by_basename: Map<String, String>, emitted_basenames: List<String>) -> BasenameDagBuild {
+  let emitted_set = emitted_basenames |> fold(init: empty_map(), f: fn(acc, b) { map_insert(acc, b, b) })
+  let not_emitted = module_dag.modules |> filter(m =>
+    match emitted_workspace_lookup(m: emitted_set, key: rust_module_emit_filename(module_name: m as String)) { Present { value: _ } => false  Absent => true })
+  let outside = emitted_basenames |> filter(b =>
+    b != rust_runtime_prelude_module
+      && match emitted_workspace_lookup(m: module_by_basename, key: b) { Present { value: _ } => false  Absent => true })
+  if ((not_emitted |> count) + (outside |> count)) > 0 {
+    BasenameDagRefused {
+      cause: EmittedWorkspaceClosuresDisagree {
+        not_emitted: not_emitted |> map(m => m as String),
+        outside_dag: outside
+      }
+    }
+  } else {
+    BasenameDagOk {
+      module_dag: ModuleDag {
+        modules: concat(
+          module_dag.modules |> map(m => rust_module_emit_filename(module_name: m as String) as ModuleId),
+          [rust_runtime_prelude_module as ModuleId]
+        ),
+        edges: module_dag.edges |> map(e => ModuleDagEdge {
+          from: rust_module_emit_filename(module_name: e.from as String) as ModuleId,
+          to: rust_module_emit_filename(module_name: e.to as String) as ModuleId
+        }),
+        exports: empty_map(),
+        type_definitions: empty_map()
+      }
+    }
+  }
+}
+
+// The runtime is a FIXED foundation crate every unit depends on, so the policy partitions the
+// closure without it: an edge into the runtime is a dependency on the runtime package, never a
+// reason to place a closure module beside it.
+fn emitted_workspace_without_runtime(module_dag: ModuleDag) -> ModuleDag {
+  ModuleDag {
+    modules: module_dag.modules |> filter(m => (m as String) != rust_runtime_prelude_module),
+    edges: module_dag.edges |> filter(e => (e.from as String) != rust_runtime_prelude_module && (e.to as String) != rust_runtime_prelude_module),
+    exports: module_dag.exports,
+    type_definitions: module_dag.type_definitions
+  }
+}
+
+fn emitted_workspace_unit_rows(modules: List<ModuleId>, assignment: Map<ModuleId, CompilationUnitId>, unit_ids: List<CompilationUnitId>) -> List<Stage0PartitionCrateRow> {
+  unit_ids |> map(unit_id => {
+    let package = emitted_workspace_package(unit_id: unit_id)
+    Stage0PartitionCrateRow {
+      unit_id: unit_id,
+      package_name: package,
+      crate_dir: emitted_workspace_crate_dir(package: package),
+      kind: Stage0LayeredCoreCrate,
+      modules: modules |> filter(m => match map_get(assignment, m) {
+          Accepted { value: Present { value: u }, diagnostics: _ } => u == unit_id
+          Accepted { value: Absent, diagnostics: _ } => false
+          Rejected { diagnostics: _ } => false
+        }) |> map(m => m as String) |> sort_by(m => m),
+      reexport_packages: [],
+      carries_non_empty_wrappers: false
+    }
+  })
+}
+
+fn emitted_workspace_generated_row(row: Stage0PartitionCrateRow, reexports: List<String>) -> GeneratedPartitionCrateRow {
+  GeneratedPartitionCrateRow {
+    package_name: row.package_name,
+    crate_dir: row.crate_dir,
+    kind: GeneratedLayeredCoreCrate,
+    modules: row.modules,
+    reexport_packages: reexports,
+    carries_non_empty_wrappers: false
+  }
+}
+
+fn emitted_workspace_runtime_row() -> GeneratedPartitionCrateRow {
+  GeneratedPartitionCrateRow {
+    package_name: emitted_workspace_runtime_package,
+    crate_dir: emitted_workspace_crate_dir(package: emitted_workspace_runtime_package),
+    kind: GeneratedFoundationCrate,
+    modules: [rust_runtime_prelude_module],
+    reexport_packages: [],
+    carries_non_empty_wrappers: true
+  }
+}
+
+type DerivedRowsBuild
+  = DerivedRowsOk { rows: List<GeneratedPartitionCrateRow> }
+  | DerivedRowsRefused { cause: EmittedWorkspaceRefusal }
+
+fn emitted_workspace_derived_rows(unit_rows: List<Stage0PartitionCrateRow>, unit_edges: List<UnitDepEdge>) -> DerivedRowsBuild {
+  unit_rows |> fold(init: DerivedRowsOk { rows: [emitted_workspace_runtime_row()] }, f: fn(acc, row) {
+    match acc {
+      DerivedRowsRefused { cause: c } => DerivedRowsRefused { cause: c }
+      DerivedRowsOk { rows: rows } =>
+        match derived_dep_packages(edges: unit_edges, rows: unit_rows, row: row) {
+          DerivedDepPackagesUnitHasNoRow { unit_id: u } => DerivedRowsRefused { cause: EmittedWorkspaceUnitHasNoRow { unit_id: u } }
+          DerivedDepPackagesOk { packages: packages } =>
+            DerivedRowsOk {
+              rows: rows |> list_push(emitted_workspace_generated_row(
+                row: row,
+                reexports: concat([emitted_workspace_runtime_package], packages |> sort_by(p => p))
+              ))
+            }
+        }
+    }
+  })
+}
+
+fn emitted_workspace_unit_of(assignment: Map<ModuleId, CompilationUnitId>, module: String) -> Optional<CompilationUnitId> {
+  match map_get(assignment, module as ModuleId) {
+    Accepted { value: owner, diagnostics: _ } => owner
+    Rejected { diagnostics: _ } => Absent
+  }
+}
+
+// An edge (from_unit -> to_unit) of the unit graph is in the TRANSITIVE REDUCTION when no OTHER
+// direct dependency of from_unit reaches to_unit. Only such an edge can be dropped without another
+// crate's glob facade re-exporting the target by a second road.
+fn emitted_workspace_edge_is_irredundant(unit_edges: List<UnitDepEdge>, from_unit: CompilationUnitId, to_unit: CompilationUnitId) -> Bool {
+  let others = unit_direct_deps(edges: unit_edges, unit_id: from_unit) |> filter(d => d != to_unit)
+  !(unit_dep_closure(edges: unit_edges, acc: others, fuel: (unit_edges |> count) + 1) |> any(u => u == to_unit))
+}
+
+fn emitted_workspace_red(
+  edges: List<EmittedEdge>,
+  assignment: Map<ModuleId, CompilationUnitId>,
+  unit_edges: List<UnitDepEdge>
+) -> Optional<EmittedWorkspaceRedDrop> {
+  edges |> fold(init: Absent, f: fn(acc, edge) {
+    match acc {
+      Present { value: _ } => acc
+      Absent =>
+        match edge.provenance {
+          SemanticSourceReference =>
+            match edge.to {
+              EmittedCrateRootTarget => Absent
+              EmittedModuleTarget { module: to_module } =>
+                match emitted_workspace_unit_of(assignment: assignment, module: edge.from) {
+                  Absent => Absent
+                  Present { value: from_unit } =>
+                    match emitted_workspace_unit_of(assignment: assignment, module: to_module) {
+                      Absent => Absent
+                      Present { value: to_unit } =>
+                        if from_unit != to_unit && emitted_workspace_edge_is_irredundant(unit_edges: unit_edges, from_unit: from_unit, to_unit: to_unit) {
+                          optional_present(
+                            value: EmittedWorkspaceRedDrop {
+                              package: emitted_workspace_package(unit_id: from_unit),
+                              dropped_package: emitted_workspace_package(unit_id: to_unit),
+                              from_module: edge.from,
+                              to_module: to_module
+                            }
+                          )
+                        } else { Absent }
+                    }
+                }
+            }
+          _ => Absent
+        }
+    }
+  })
+}
+
+fn emitted_workspace_red_rows(rows: List<GeneratedPartitionCrateRow>, red: EmittedWorkspaceRedDrop) -> List<GeneratedPartitionCrateRow> {
+  rows |> map(row =>
+    if row.package_name == red.package {
+      GeneratedPartitionCrateRow {
+        package_name: row.package_name,
+        crate_dir: row.crate_dir,
+        kind: row.kind,
+        modules: row.modules,
+        reexport_packages: row.reexport_packages |> filter(p => p != red.dropped_package),
+        carries_non_empty_wrappers: row.carries_non_empty_wrappers
+      }
+    } else { row }
+  )
+}
+
+fn emitted_workspace_facade_is_whole_closure(rows: List<GeneratedPartitionCrateRow>) -> Bool {
+  let layered = rows |> filter(r => r.package_name != emitted_workspace_runtime_package)
+  layered |> all(r => (r.reexport_packages |> count) == (rows |> count) - 1)
+}
+
+fn emitted_workspace_plan_over(
+  module_dag: ModuleDag,
+  emitted_basenames: List<String>,
+  edge_froms: List<String>,
+  edge_tos: List<String>,
+  edge_provenances: List<String>,
+  target_crate_count: Int
+) -> EmittedWorkspaceOutcome {
+  match emitted_workspace_basename_index(module_dag: module_dag) {
+    BasenameIndexRefused { cause: c } => EmittedWorkspaceRefused { cause: c }
+    BasenameIndexOk { module_by_basename: module_by_basename } =>
+      match emitted_workspace_edges(froms: edge_froms, tos: edge_tos, provenances: edge_provenances) {
+        EdgeListRefused { cause: c } => EmittedWorkspaceRefused { cause: c }
+        EdgeListOk { edges: edges } =>
+          match emitted_workspace_basename_dag(module_dag: module_dag, module_by_basename: module_by_basename, emitted_basenames: emitted_basenames) {
+            BasenameDagRefused { cause: c } => EmittedWorkspaceRefused { cause: c }
+            BasenameDagOk { module_dag: basename_dag } =>
+              match module_dag_with_emitted_edges(module_dag: basename_dag, emitted: edges) {
+                ModuleDagEmittedRefused { cause: c } => EmittedWorkspaceRefused { cause: EmittedWorkspaceEdgeMergeRefused { cause: c } }
+                ModuleDagEmittedMerged { module_dag: merged } => {
+                  let closure_dag = emitted_workspace_without_runtime(module_dag: merged)
+                  match resolve_partition_outcome(
+                    parameter: PolicyPartitionParam { policy: PartitionPolicy { target_crate_count: target_crate_count } },
+                    module_dag: closure_dag
+                  ) {
+                    ResolvePartitionRefused { cause: c } => EmittedWorkspaceRefused { cause: EmittedWorkspacePartitionRefused { cause: c } }
+                    ResolvePartitionOk { assignment: assignment, provenance: _ } => {
+                      let unit_ids = list_unique_sorted_ids(items: assignment |> map_values)
+                      let unit_edges = assignment_unit_dep_edges(module_dag: closure_dag, assignment: assignment)
+                      match emitted_workspace_derived_rows(unit_rows: emitted_workspace_unit_rows(modules: closure_dag.modules, assignment: assignment, unit_ids: unit_ids), unit_edges: unit_edges) {
+                        DerivedRowsRefused { cause: c } => EmittedWorkspaceRefused { cause: c }
+                        DerivedRowsOk { rows: rows } =>
+                          match emitted_workspace_red(edges: edges, assignment: assignment, unit_edges: unit_edges) {
+                            Absent => EmittedWorkspaceRefused { cause: EmittedWorkspaceNoDiscriminatingEdge }
+                            Present { value: red } =>
+                              EmittedWorkspacePlanned {
+                                plan: EmittedWorkspacePlan {
+                                  rows: rows,
+                                  red_rows: emitted_workspace_red_rows(rows: rows, red: red),
+                                  red: red,
+                                  module_count: closure_dag.modules |> count,
+                                  crate_count: rows |> count,
+                                  facade_is_whole_closure: emitted_workspace_facade_is_whole_closure(rows: rows)
+                                }
+                              }
+                          }
+                      }
+                    }
+                  }
+                }
+              }
+          }
+      }
+  }
+}
+
+// THE PRODUCTION ENTRY: the live closure derivation, the emission's own basenames and edges, and
+// the declared core target the closure's policy partition already uses.
+fn emitted_workspace_plan(
+  emitted_basenames: List<String>,
+  edge_froms: List<String>,
+  edge_tos: List<String>,
+  edge_provenances: List<String>
+) -> EmittedWorkspaceOutcome {
+  match emitted_compiler_closure_module_dag() {
+    ModuleDagDerivationRefused { cause: c } => EmittedWorkspaceRefused { cause: EmittedWorkspaceDagRefused { cause: c } }
+    ModuleDagDerived { module_dag: module_dag } =>
+      emitted_workspace_plan_over(
+        module_dag: module_dag,
+        emitted_basenames: emitted_basenames,
+        edge_froms: edge_froms,
+        edge_tos: edge_tos,
+        edge_provenances: edge_provenances,
+        target_crate_count: rust_crate_partition_declared_core_target
+      )
+  }
+}
diff --git a/src/v2/workflow/required_floor.dag b/src/v2/workflow/required_floor.dag
index bcfa1cc5ded..12b08676e7d 100644
--- a/src/v2/workflow/required_floor.dag
+++ b/src/v2/workflow/required_floor.dag
@@ -735,12 +735,21 @@ fn required_gate_prefixes() -> List<String> {
 // admission over the REAL emission still runs only at author regen, and rides that drop. The
 // module declares SubstrateInputsOnly and adds no preparation beyond gunbc.rust_emitted_edge and
 // the stage0 partition rows.
+//
+// THE EMITTED-WORKSPACE PLAN'S WITNESSES (gunbc#12214, parent ruling msg_d375b91d from
+// loyal-swift-608). They run v2.workflow.emitted_crate_workspace emitted_workspace_plan_over over a
+// SUPPLIED three-module DAG and supplied edges -- the plan's RED selection, its transitive re-export
+// derivation and its ClosuresDisagree / NoDiscriminatingEdge refusals -- so the refusals keep
+// executing after merge (DESIGN 4b(4)). They never derive the live closure: that run, with the
+// emission and both cargo builds, stays in the author-run instrument
+// //gunbc/instruments:emitted-crate-workspace. SubstrateInputsOnly.
 fn required_gate_authored_modules() -> List<String> {
   [
     "test.claim.runner_capacity_plan_witness",
     "test.claim.runner_capacity_realize_witness",
     "test.claim.corpus_census_allowance_witness_test",
     "test.claim.stage0_emitted_edge_admission_witness",
+    "test.claim.emitted_crate_workspace_witness",
   ]
 }