XL-0A: the emitted v2 compiler closure reaches rustc type checking (2779 typeck errors remain, one identity class dominant)

[gunbai-bot]

Part of #9664 — XL-0A: the emitted v2 compiler closure (src/v2/compiler/00_compile.dag) reaches rustc type checking. A phase-frontier increment, not the XL-0 gate.

XL-0 gate (cargo check errors = 0) NOT satisfied. On the frozen tree the closure emits (175 members: 174 .rs + Cargo.toml) and rustc completes name resolution, cycle detection and generic-arity checking for the first time; 2779 type-check errors remain, one identity class dominant (below). Result carrier: RustcTypeCheckFrontierReached { emitted_members, fixed_point_receipt, closed_pre_typeck_classes, typeck_error_population } — never XL0Passed / CompilerBuildable / NativeCompilerCandidate.

Accounting rule (binding for every later XL-0 report)

Compiler progress is ordered first by the furthest rustc phase reached, then by the error relation within that phase. A cargo error total is a census of the phase rustc aborted in: resolution errors (E0425) and cycle errors (E0391) stop rustc before type checking, so a smaller total that aborts earlier ranks BELOW a larger total that reaches typeck. The history of this PR, in that order:

frontier reached	instrument, aborting phase	total	tree
name resolution	cargo check, aborted at resolution (E0425 ×254)	261	main @ 6447dd4 (the issue's baseline)
later pre-typeck	aborted at resolution / async lowering (E0425, E0728, E0107)	20	ebf8dca
cycle / generic-arity	aborted at E0391 variance cycle + E0107	15	443f3de
first complete type check	typeck completed, all phases reported	2790 → 2799 → 2779	e9900e2 → 0773184 fixed point → c2dadc8 / 466811e fixed point

A future 12-error run that aborts pre-typeck ranks below the 2779 typeck run. I attributed the 2790 jump at e9900e2 to the change that closed the E0391 cycle and gated it; that was a measured non-event — diff -r of the 15-error and the fixed-point emitted trees is 34 files, almost all use lines. The typeck population was latent underneath every earlier number.

Frozen output

identity	value
freeze (authority) head	49482b0 — nothing after it but the regeneration commit
regeneration commit	c2dadc8 (the only mirror change after the freeze)
final branch head	466811e — one fixture-only commit after the regeneration (dag/test/claim witness file, outside the regen population; a regen round on this head, claim_executor --required-regen with gunbc=8eb02a1c36c8cd4d, exits 0 with first_generation_equal=true and no regen-population path changed — /tmp/xl0post.log on srv1)
main parent (merge-base)	5e80671
merged tree	CI builds refs/pull/9665/merge; its tree equals the branch tree while main stays at 5e80671 — merged tree digest a6aaba27091ee193b9dc8b31fb3ade008602502f
authority tree digest (git ls-tree -r HEAD -- dag src/v2 src/v1, stage0 excluded)	a79b275e332a394a
installed mirror digest (src/v1/stage0/src/*.rs, LC_ALL=C sorted, concatenated, sha256)	b1a0409ce9fc79d4
compiler artifact producing the final empty round	gunbc=974aafe864f743f6, built from the round-(N−1) installed tree
compiler artifact running the witnesses and falsifiers	gunbc=8eb02a1c36c8cd4d — the same installed tree b1a0409ce9fc79d4 rebuilt at head 466811e; src/v1/stage0/build.rs stamps git rev-parse HEAD into the binary, so the artifact hash is a function of (mirror bytes, HEAD) and the two ids name one compiler

Any push to this branch or movement of main after this table re-opens the gate.

Generation transaction (srv1, aarch64)

Criterion: byte fixed point over the regen population — every file the regen produces is byte-equal to its installed counterpart (cmp per file; main.rs is declared divergent by the regen itself; hand-authored files are outside its population). first_generation_equal and the changed-path list are not the criterion. The full workspace is rebuilt inside every round, so a mirror that does not compile stops the line at the round that produced it. No generated file was hand-edited.

round	compiler artifact	built from installed tree	regen-population paths changed
1	gunbc=14967ca810cb6609	db46176cc5cf5861 (the freeze's committed mirror)	v1_compiler_emit_rust.rs, v1_tests_claim_reference_derived_disposition_census_witness_test.rs
2	gunbc=5378a516528a6e0c	efa440bc86734f53	v1_compiler_trait_derive_emit.rs (retracts the unused pub use crate::std_types::List; the earlier qualified route synthesized)
3	gunbc=974aafe864f743f6	b1a0409ce9fc79d4	none — byte fixed point

Launched 2026-08-29T19:52:56Z (/tmp/xl0e2.sh → /tmp/xl0j2.log on srv1); regen commit c2dadc8 carries exactly the round-1 + round-2 candidate bytes (3 files, +224/−83), local digest re-derived b1a0409ce9fc79d4.

Cross-host control: the cycle from dc04b9d ran on both srv1 (aarch64) and BuildBuddy (amd64) and converged to the identical installed-tree digest 0479b0df9fc5598e through the same three rounds — the generator is host-independent.

Every changed mirror path is explained by an authority change in this PR:

mirror	authority
extdeps_languages_rust_emit.rs	dag/extdeps/languages/rust/emit.dag — rt_function_registry rows symbol_lexeme, symbol_intern_lexeme; rust_simple_method_specs row is_empty
std_primitive_projection.rs, std_primitive_identity.rs	dag/std/primitive_projection.dag, dag/std/primitive_identity.dag — the two symbol seams rostered HostRealizedSeam, with OrderFreeResult traversal facts
v1_compiler_emit_rust.rs	src/v1/05_emit_rust.dag — every emitter repair in the class table
v1_compiler_infer.rs, v1_compiler_infer_lookup.rs, v1_compiler_infer_sigs.rs, v1_std_core.rs	src/v1/04_infer.dag, 04_lookup.dag, 04_sigs.dag, 00_core.dag — CallTargetIdentity.RuntimePrimitiveCall.projected_from, DeclaredCallableIdentity hoisted to v1.std.core, decl_name = last segment
v1_compiler_runtime_rust.rs, v1_rt.rs	src/v1/runtime_rust.dag — symbol_lexeme / symbol_intern_lexeme identity realizations (v1_rt.rs lands one round later: it is rendered by the previously compiled rt_hash_ops)
v1_compiler_compile.rs	src/v1/compile.dag — serializer arm for the widened RuntimePrimitiveCall
std_algebra.rs, std_nat.rs, v1_compiler_trait_derive_emit.rs	arrow-typed fields and one qualified std.types.List reference re-rendered by the arrow-position and qualified-type routes of 05_emit_rust.dag

The instrument (#9664, verbatim)

gunbc compile --source-root dag --source-root src/v2 --entry src/v2/compiler/00_compile.dag --target rust --output-dir /tmp/v2emit
cd /tmp/v2emit && cargo check --message-format short

Over the frozen tree with gunbc=974aafe864f743f6: emit OK, 175 files emitted (the compiler's own count: 174 .rs + Cargo.toml; Cargo.lock is written by cargo check); cargo check errors = 2779 (rustc reaches and completes type checking).

Class table

Pre-typeck classes this PR closes (0 on the fixed point; each has a required-floor witness)

class	baseline	mechanism
C — qualified call carried the dotted path as decl_name (cannot find value v2/std)	102	04_lookup.dag: decl_name = qualified_last_segment(name) at 4 sites
length — v1_rt::length named a symbol the seed does not define	73	RuntimePrimitiveCall.projected_from; emission falls back to the declaration only for ModeledProjection, never HostRealizedSeam
B — algebra fallback asserted a bridge for a fn-typed record field / unregistered name	65	runtime_bridge = rust_runtime_primitive_has_bridge(name); is_empty template row; callable-field tier ahead of both template lookups, keyed on the receiver's OWN record (952ffa6: the first tier consumed the algebra profile and put 202 errors on the regenerated SEED, caught by the in-cycle build gate)
symbol seams — symbol_lexeme / symbol_intern_lexeme compiled as infinite recursion (silent)	0 (silent)	roster rows + v1_rt identity realizations
unrealized self-call seams (resolve_type_node, coproduct_nullary_inhabitants, 3 more)	0 (silent)	rust_host_seam_is_unrealized wall; generated refusal body per the seam ruling (a compile_error! cut took 20 more items down and is deleted)
witness carrier rendered an erased identity (UNRESOLVED_CompilerError)	1	rust_witness_carrier_from_type_node declines a CompilerError so the fn return decides
fold init took the Map declaration's formals (rc_empty_map::<K, V>)	4	the init turbofish asks the rendered-formal admission the lambda beside it already uses and defers unbound formals to rustc
lambda param annotated with a spurious generic (FreeMonoid<T>)	1	same rendered-string admission the fold element already uses
zero-param alias rendered with its RHS arguments (E0107 + the E0391 variance cycle — the phase-aborting class)	2	closed_alias_peels_zero_param asked at the expression-type position
arrow return dropped its applied binding (Rc<Medium>, E0107) / generic arrow return rendered its erased inference (Outcome<compile_error!>)	1 / 3 (latent)	every arrow position renders through render_rust_fn_sig_type, the renderer the parameter side already used; two intermediate cuts (an unconditioned second renderer, then a measured gate over it) are deleted
qualified type reference never earned its use-line (Determinism)	2	qualified_type_reference_rows: the qualifier is the provider the author named; a line is synthesized only when the registry declares the leaf as a TYPE in that module and the export proof holds; each decision is a census row. First regeneration synthesized use lines for qualified VARIANT heads (v2.std.nat.Succ { .. }, E0603 ×16) — closed by the type gate
service op in a service-free fn (filesystem.read(..).await?: E0425 + E0728)	4	the method arm asks the SAME predicate the signature authority asks (is_typed_service_call_receiver); declined → generated refusal body naming the seam

Member roster reconciliation (by identity). The a5120f1 run and this run both report compiled: 175 files emitted and their emitted rosters are identical file-for-file (diff of the two output trees' file lists, target/ excluded, is empty: 174 .rs + Cargo.toml, plus the Cargo.lock cargo check writes). The 174 in earlier receipts counted src/*.rs only — a counting convention, not a lost member; the typeck population and XL-1's effect-demand denominator are over the same 175.

Type-check population on the fixed point (open; by rustc code)

rustc code	count	reading
E0308	2671	the Symbol / kernel String / v2.std.text.String identity capture (~2400 sites in both directions, plus its nested forms); a handful of unrelated mismatches (Feature by reference, Coverage<..> vs CoverageDefectAcceptanceKey, Rc<Nat> vs integer)
E0277	34	trait bounds the emitter does not derive (A: Clone on generic params, staging combinators)
E0599	16	methods on generic params without bounds; im::Vector::Empty
E0618	12	a ! where a call was expected (host-refusal bodies used as callables)
E0369	12	arithmetic on Rc<i64>
E0282	9	inference holes at list_head-style calls
E0004	9	non-exhaustive matches after the Symbol capture
E0061	6	arity mismatches (v2.lens.coverage, enforcement_vocab)
E0310 / E0271 / E0631 / E0560 / E0533 / E0223	8	singletons
E0425 / E0603 / E0121 / E0107 / E0391 / E0728	0	the classes this PR closes
total	2779

Corpus probes on the same emitted tree: rc_empty_map::<K, V> 0 · CompileLensOutcome< 0 · Rc<Medium>> 0 · pub use crate::v2_std_nat::Succ; 0 · Rc<Outcome<_>>> 0 · use crate::std_determinism::{Determinism}; in v2_std_determinism.rs 1 · UNRESOLVED_CompilerError 1 — that one occurrence is prose inside a data-string annotation in v2_compiler_materialization_carriers.rs, not a rendered type (the probe is over-broad there).

The dominant class is a modeling gap, not a Rust spelling, and this PR does not touch it (ruling: it is its own model-first lane). Three names answer one question: v2.std.node type Symbol (opaque, kernel-named, projected by the seed as pub type Symbol = String), the kernel String, and v2.std.text type String (= Rc<Vec<i64>>, code points). The emitter renders a Symbol-typed position as the bare token String; in every module that import v2.std.text { String } that token is captured — v2.std.grammar, v2.std.compilers.target_model, v2.extdeps.languages.dag and their callers — so fn f(identity: Symbol) expects Rc<Vector<i64>> while callers pass host String (E0308 ×~2400, both directions). Compounding fact: Symbol in those modules is unimported and resolves only through the whole-corpus union pick (scoped to its import closure the same module refuses unresolved type 'Symbol'). The Symbol lane's renderer change (resolved DeclarationRef → representation → fully-qualified spelling, no bare-name fallback) is a joint seam with 05_emit_rust.dag; XL-0B resumes the remaining tail on top of it.

Witnesses (dag/test/claim/emitted_call_target_realization_witness_test.dag, 24 rows, required floor)

Executed over the frozen bytes with gunbc=8eb02a1c36c8cd4d (head 466811e, same mirror): 24/24 PASS, footer 24 witness(es), verdict count equals footer.

• w_qualified_call_emits_only_the_declaration_last_segment — PASS
• w_unbridged_modeled_primitive_emits_its_declaration — PASS
• w_bridged_modeled_primitive_still_lowers_to_the_bridge — PASS
• w_callable_record_field_lowers_as_a_field_not_a_bridge — PASS
• w_registered_bridge_method_still_reaches_the_bridge — PASS
• w_symbol_lexeme_reaches_its_host_realization_not_its_self_call — PASS
• w_unrealized_self_call_seam_refuses_instead_of_emitting_recursion — PASS
• w_unrealized_seam_refusal_preserves_the_declaration_signature — PASS
• w_ordinary_recursion_is_not_read_as_a_host_seam — PASS
• w_rostered_seam_resolves_realization_through_its_primitive_not_its_decl_name — PASS
• w_realized_seam_keeps_its_declaration_and_delegates_to_the_bridge — PASS
• w_is_empty_lowers_to_its_rust_realization_not_a_refusal — PASS
• w_callable_field_named_is_empty_is_not_captured_by_the_target_template — PASS
• w_callable_field_named_count_is_not_captured_by_the_target_template — PASS
• w_map_receiver_operation_is_not_read_as_a_callable_field — PASS
• w_witness_carrier_falls_back_to_the_fn_return_when_the_value_identity_is_erased — PASS
• w_fold_empty_map_init_renders_the_resolved_accumulator_not_the_declaration_formals — PASS
• w_lambda_param_annotation_declines_a_spurious_generic — PASS
• w_zero_param_alias_in_an_arrow_return_renders_without_its_rhs_arguments — PASS
• w_arrow_return_type_keeps_its_applied_binding — PASS
• w_qualified_type_reference_earns_the_leaf_use_line — PASS
• w_qualified_variant_head_earns_no_type_use_line — PASS
• w_generic_arrow_return_renders_the_fn_scope_generic — PASS
• w_service_op_in_a_service_free_fn_refuses_instead_of_awaiting_an_unbound_binding — PASS

Disposition grain (src/v1/tests/claim/reference_derived_disposition_census_witness_test.dag, 14 rows incl. a_known_variant_spelling_in_a_type_position_takes_the_registry_arm): 14/14 PASS on gunbc=974aafe864f743f6.

Falsifiers (mirror mutations over the frozen bytes; build-only, no regen; byte restore proven after)

Instrument: the emitted bytes for the classes this PR closes — must_contain / must_not_contain on the witness probes and occurrence counts on the emitted closure — never the cargo error count. Each mutation is a regex over the regenerated mirror that must match exactly its site (a miss is reported NON-EVENT, never green). Bar: the reddened set includes the named discriminator, unrelated controls stay green, byte restore reproduces the baseline verdict population.

Run on srv1 over the frozen mirror (/tmp/xl0post.log, /tmp/xl0post2.log): each row rebuilds claim_batch + gunbc from the mutated mirror, runs the 24 harness rows (and, in the follow-up pass, the 14 disposition-grain rows), and — for the closure-observable classes — re-emits the 00_compile closure and counts the class's token. Baseline probes on the unmutated tree: rc_empty_map::<K, V> 0 · use crate::std_determinism::{Determinism}; 1 · CompileLensOutcome< 0 · Rc<Medium>> 0 · pub use crate::v2_std_nat::Succ; 0 · Rc<Outcome<_>>> 0. Lean standard (one mutation per mechanism): m03 dropped (documented non-event: the callable-field tier answers every receiver the algebra fallback used to), m06 dropped (a second mutation of class C's site), m12 dropped (a second mutation of the qualified route).

mutation	mechanism	reddened (everything else green)	verdict
m01 symbol projection row removed	symbol seams	w_symbol_lexeme_reaches_its_host_realization_not_its_self_call, w_realized_seam_keeps_its_declaration_and_delegates_to_the_bridge	discriminating
m02 dotted decl_name restored	class C	w_qualified_call_emits_only_the_declaration_last_segment	discriminating
m04 length provenance removed	length	w_unbridged_modeled_primitive_emits_its_declaration	discriminating
m05 seam wall removed	unrealized self-call seams	w_unrealized_self_call_seam_refuses_instead_of_emitting_recursion, w_unrealized_seam_refusal_preserves_the_declaration_signature	discriminating
m07 callable-field candidate sweep restored	class B tier	w_map_receiver_operation_is_not_read_as_a_callable_field	discriminating
m08 witness carrier admits a CompilerError	witness carrier	w_witness_carrier_falls_back_to_the_fn_return_when_the_value_identity_is_erased	discriminating
m09 fold-init formal admission removed	fold init	no harness row (class observable only in the closure); corpus rc_empty_map::<K, V> 0 → 2	discriminating (closure)
m10 lambda spurious-generic admission removed	lambda annotation	w_lambda_param_annotation_declines_a_spurious_generic	discriminating
m11 arrow arm removed	arrow positions	w_zero_param_alias_in_an_arrow_return_renders_without_its_rhs_arguments, w_arrow_return_type_keeps_its_applied_binding, w_generic_arrow_return_renders_the_fn_scope_generic; corpus CompileLensOutcome< 0 → 1, Rc<Medium>> 0 → 1, UNRESOLVED_CompilerError 1 → 4	discriminating
m13 service refusal removed	service op	w_service_op_in_a_service_free_fn_refuses_instead_of_awaiting_an_unbound_binding	discriminating
m14 zero-param alias arm at the expression-type position removed	—	nothing, on either instrument (24/24, 14/14, CompileLensOutcome< stays 0)	non-event, stated: every arrow position now renders through render_rust_fn_sig_type, which carries its own closed_alias_peels_zero_param arm, so the expression-type-position arm no longer decides this class — m11 does (CompileLensOutcome< 0 → 1, w_zero_param_alias_in_an_arrow_return_renders_without_its_rhs_arguments red). The now-redundant arm is XL-0B's first deletion (§4b dissolution on climb)
m15 arrow positions through the second renderer (render_rust_type)	—	nothing, on either instrument	non-event, stated: with the fn generic scope threaded through the applied-binding hop (m18), the second renderer no longer reproduces the defect; the single-renderer change is a §2 consolidation, and the arrow class's repair is m11 + m18
m16 type-position exemption removed	Determinism (bare-name disposition)	corpus use crate::std_determinism::{Determinism}; 1 → 0; harness row unchanged (declared positive control); disposition-grain rows stay green under the MIRROR mutation because claim_batch runs src/v1/tests/claim through the interpreter over the .dag authority — so their red was taken at the .dag: reverting the exemption in 05_emit_rust.dag (1 site) reddens exactly a_known_variant_spelling_in_a_type_position_takes_the_registry_arm (13 controls green), restore 14/14 (/tmp/xl0unitmut.log)	discriminating (closure + unit grain)
m17 qualified-route registry type gate removed	—	nothing, on either instrument	non-event, stated: a variant head has no registry row, so the route declines it at the registry-absent arm; the gate decides only OtherItem rows (std.types.Map). Replaced by m19
m18 fn generic scope dropped at the applied-binding hop	generic arrow return	w_generic_arrow_return_renders_the_fn_scope_generic; corpus Rc<Outcome<_>>> 0 → 3	discriminating
m19 qualified route admits a registry-absent leaf as exported	E0603 variant use-lines	w_qualified_variant_head_earns_no_type_use_line; corpus pub use crate::v2_std_nat::Succ; 0 → 2 (the probe counts the Succ line only; the class was 16 lines over several variants)	discriminating
clean control	—	24/24 PASS; corpus probes identical to baseline	byte restore reproduces b1a0409ce9fc79d4

The fold-K,V class is only observable in the full closure (the harness pool resolves Map to the kernel container), so its falsifier is read off the closure occurrence count.

rust-unit-tests

cargo test --release -p v1-compiler --lib over the frozen bytes: 535 passed, 0 failed, 140 ignored (gunbc=974aafe864f743f6 tree). The d805243/952ffa6 red on function_value_named_application_controls_witness is classified GeneratedMirrorIncoherent: the merge commit deliberately carried the two mirrors the generated-artifact merge driver refused, so CI compiled an older infer than the merged authority; the same test passes on the regenerated bytes with no change to its subject. Every other red on this PR's history is a required-witnesses-build regen-drift red on an intermediate authority commit, the expected state before its regeneration commit. The freeze head 49482b0 itself is one: its build lane reports FAILED PHASE regen — generated surface drift: v1_compiler_emit_rust.rs, v1_tests_claim_reference_derived_disposition_census_witness_test.rs, exactly the two paths round 1 of the transaction regenerated — and rust-unit-tests passed on it. CI on the final head is the receipt that counts.

Seam census (for XL-1's HostSeamStanding join)

Whole-body self-call seams on the closure: 14 by identity (reconciled with XL-1). Realized 9 / unrealized 5 (v2.std.node.resolve_type_node, v2.std.node.coproduct_nullary_inhabitants and 3 more, all carrying the panic refusal body). Service-op seams: v2.compiler.source_authority::source_ref_for_observed_storage_path and ::dag_source_read_result_from_ref, op Filesystem.Read, unrealized (refusal body); neither is reached from the entry compile.

Non-goals

Host effect execution / transports (XL-1); the Symbol / String identity (its own lane); bootstrap promotion of the emitted crate; CLI or CI migration; product rewiring; broad v1 cleanup. No line was added to v1_rt.rs, v1_interpreter.rs or cli_run.rs by hand — the two v1_rt.rs functions are emitted from runtime_rust.dag.

🤖 Generated with Claude Code

https://claude.ai/code/session_01GXfYKNQTD3VfYyQcnJpxNU

[gunbai-bot]

Specimen hand-off from XL-1 (#9669), returned rather than fixed locally — this is call-target identity and Rust lowering, which is your lane by the ownership rule.

Measured by emitting three closures at 6447dd4564 and reading the emitted Rust. The HostRealizedSeam population splits into two shapes, and one of them is silent.

1. A rostered HostRealizedSeam declaration lowers to a compiling infinite loop. Not the f(x) self-call shape that was predicted — the emitter lowers the self-call to a tail-loop:

pub fn decl_facts(mut pool_roots: Rc<Vec<String>>) -> Rc<Vec<Rc<DeclFact>>> {
    loop { { continue; } }
}

It type-checks, has no return path rustc objects to, produces no diagnostic, and never returns. Same shape for export_signature_facts and data_decl_type_facts (v2_std_decl_index.rs, from --entry src/v2/std/decl_index.dag). concept_decl_facts / concept_decl_facts_live had 0 sites in these closures.

2. Every unrostered builtin already lowers as an rt bridge call, to a symbol v1_rt does not define — so these are loud (E0425), not silent:

emitted call	emitted file :: enclosing fn
v1_rt::module_declaration_facts	v2_lens_module_graph.rs::module_declaration_facts_live
v1_rt::import_resolution_facts	v2_lens_module_graph.rs::import_resolution_facts_live
v1_rt::reference_resolution_facts	v2_lens_module_graph.rs::reference_derived_import_resolution_facts_live
v1_rt::dependency_resolution_facts	v2_lens_module_graph.rs::dependency_resolution_facts_live
v1_rt::layer_import_facts	v2_std_layer.rs::layer_import_facts_live
v1_rt::filesystem_read	v2_lens_reference_deps.rs::reference_file_census, v2_lens_enforcement_grammar_coverage.rs::grammar_coverage_ingest_path
v1_rt::decl_facts	v2_std_decl_index.rs::decl_facts_count, v2_std_decl_index.rs::decl_facts_fn_item_count

The split is not "rostered vs unrostered" — it is declaration lowering vs call-site lowering, and decl_facts exhibits both at once: the nonterminating loop { continue; } declaration and two v1_rt::decl_facts(...) call sites.

The consequence for a census: shape 1 is invisible to any error list, so absence from an E0425 population is not evidence a seam is closed. Worth checking each seam for the tail-loop shape directly.

Two notes on scope, so this does not read as a request to build the effect substrate:

• XL-1 is not asking for these to be realized. Measured on the emitted compiler closure, the compile path reaches none of these call sites — they are import occupancy, reached only from lens/census/test consumers. Their compile-path demand is zero, so the fix here is lowering, not a transport.
• The _live wrappers are exactly the swappable producer seam dependency_edge_source_migration_note designates, so preserving the typed seam is the right move; XL-1 owns what executes behind it.

Reproduce: gunbc compile --source-root dag --source-root src/v2 --entry src/v2/std/decl_index.dag --output-dir <dir> and grep the emitted tree for pub fn decl_facts and v1_rt::.