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

dag/extdeps/languages/rust/emit.dag

@@ -76,7 +76,8 @@ data rust_simple_method_specs: List<SimpleMethodSpec> = [
   { method_name: "enumerate", template: "\{recv\}.iter().cloned().enumerate().map(|(i, v)| (i as i64, v)).collect::<Vec<_>>()",         wraps_result: true },
   { method_name: "chars",     template: "\{recv\}.chars().map(|c| c as i64).collect::<Vec<_>>()",                                      wraps_result: true },
   { method_name: "skip",      template: "\{recv\}.iter().cloned().skip(\{arg\} as usize).collect::<Vec<_>>()",                         wraps_result: true },
-  { method_name: "take",      template: "\{recv\}.iter().cloned().take(\{arg\} as usize).collect::<Vec<_>>()",                         wraps_result: true }
+  { method_name: "take",      template: "\{recv\}.iter().cloned().take(\{arg\} as usize).collect::<Vec<_>>()",                         wraps_result: true },
+  { method_name: "is_empty",  template: "\{recv\}.is_empty()",                                                                       wraps_result: false }
 ]
 
 fn rust_method_templates() -> Map<String, String> {
@@ -255,7 +256,10 @@ data rt_function_registry: List<RuntimeFunction> = [
 
   { name: "is_xid_start",       bridge_name: "is_xid_start",     passes_by_ref: false, wraps_result: false },
   { name: "is_xid_continue",    bridge_name: "is_xid_continue",  passes_by_ref: false, wraps_result: false },
-  { name: "is_emoji_ident",     bridge_name: "is_emoji_ident",   passes_by_ref: false, wraps_result: false }
+  { name: "is_emoji_ident",     bridge_name: "is_emoji_ident",   passes_by_ref: false, wraps_result: false },
+
+  { name: "symbol_lexeme",        bridge_name: "symbol_lexeme",        passes_by_ref: false, wraps_result: false },
+  { name: "symbol_intern_lexeme", bridge_name: "symbol_intern_lexeme", passes_by_ref: false, wraps_result: false }
 ]
 
 fn rt_functions() -> Map<String, Bool> {

dag/std/primitive_identity.dag

@@ -31,6 +31,7 @@ import std.primitive_projection {
   primitive_length, primitive_map_insert, primitive_map_get, primitive_empty_map,
   primitive_decl_facts, primitive_export_signature_facts, primitive_data_decl_type_facts,
   primitive_concept_decl_facts, primitive_concept_decl_facts_live,
+  primitive_symbol_lexeme, primitive_symbol_intern_lexeme,
 }
 
 data primitive_identity_d0_scope_note: String = "D0 is NOT terminal acceptance and does NOT close the subject universe. Landed and executing: join mechanism across five carriers, five refusal variants typed, three refusal detectors executing with witnesses (see primitive_d0_refusal_execution_note), derived census across all five surfaces including InterpreterDispatch from gunbc.v1_interpreter_primitive_surface. D1 (interpreter-primitive-roster consumption): measurement scaffold deleted; primitive_surface_census_derived reads the roster authority. Population-wide identity join closure remains the terminal acceptance bar."
@@ -1010,6 +1011,8 @@ data primitive_projection_target_canonical_names: List<String> = [
   "data_decl_type_facts",
   "concept_decl_facts",
   "concept_decl_facts_live",
+  "symbol_lexeme",
+  "symbol_intern_lexeme",
 ]
 
 fn primitive_declared_definitions() -> List<PrimitiveDefinition> {
@@ -1314,6 +1317,21 @@ data primitive_concept_decl_facts_traversal: PrimitiveTraversalOrderFact = Primi
 
 data primitive_concept_decl_facts_live_traversal: PrimitiveTraversalOrderFact = PrimitiveTraversalOrderFact { primitive: primitive_concept_decl_facts_live, order: SourcePreservingOrder }
 
+// THE TWO SYMBOL BRIDGES TRAVERSE NOTHING, and OrderFreeResult is the honest arm rather than the
+// convenient one. Both are scalar: symbol_lexeme maps one Symbol to its text and
+// symbol_intern_lexeme is its inverse, so there is no collection to walk and the result is a
+// function of the input alone -- it cannot depend on an order because no order is consulted. That
+// is a different statement from HostUnspecifiedOrder, which would claim a real traversal whose
+// order the host does not pin, and asserting it here would fabricate a leak the primitive cannot
+// have. Adding these rows is an OBLIGATION of declaring the primitives, not bookkeeping beside it:
+// v2.lens.determinism closes its denominator over primitive_declared_definitions, so a primitive
+// with no traversal fact makes the closure false. That is how this was found -- nine reach_witness
+// rows went red, including determinism_denominator_is_closed_on_declared_primitives, the row whose
+// entire job is to notice exactly this.
+data primitive_symbol_lexeme_traversal: PrimitiveTraversalOrderFact = PrimitiveTraversalOrderFact { primitive: primitive_symbol_lexeme, order: OrderFreeResult }
+
+data primitive_symbol_intern_lexeme_traversal: PrimitiveTraversalOrderFact = PrimitiveTraversalOrderFact { primitive: primitive_symbol_intern_lexeme, order: OrderFreeResult }
+
 data primitive_projection_traversal_facts: List<PrimitiveTraversalOrderFact> = [
   primitive_length_traversal,
   primitive_map_insert_traversal,
@@ -1324,6 +1342,8 @@ data primitive_projection_traversal_facts: List<PrimitiveTraversalOrderFact> = [
   primitive_data_decl_type_facts_traversal,
   primitive_concept_decl_facts_traversal,
   primitive_concept_decl_facts_live_traversal,
+  primitive_symbol_lexeme_traversal,
+  primitive_symbol_intern_lexeme_traversal,
 ]
 
 fn primitive_declared_traversal_facts() -> List<PrimitiveTraversalOrderFact> {

dag/std/primitive_projection.dag

@@ -53,6 +53,14 @@ data primitive_export_signature_facts: PrimitiveIdentity = primitive_identity_sl
 data primitive_data_decl_type_facts: PrimitiveIdentity = primitive_identity_slug(name: "data_decl_type_facts")
 data primitive_concept_decl_facts: PrimitiveIdentity = primitive_identity_slug(name: "concept_decl_facts")
 data primitive_concept_decl_facts_live: PrimitiveIdentity = primitive_identity_slug(name: "concept_decl_facts_live")
+data primitive_symbol_lexeme: PrimitiveIdentity = primitive_identity_slug(name: "symbol_lexeme")
+data primitive_symbol_intern_lexeme: PrimitiveIdentity = primitive_identity_slug(name: "symbol_intern_lexeme")
+
+data symbol_lexeme_seam_disposition_note: String = "THE TWO SYMBOL BRIDGES WERE HOST SEAMS THAT NOTHING SAID WERE HOST SEAMS, and the cost of that silence is why they are rostered here rather than left alone. v2.std.compilers.lexing symbol_lexeme and symbol_intern_lexeme have self-call bodies -- the HostRealizedSeam shape exactly, correct by construction because reaching one recurses to the evaluation-budget refusal -- and the interpreter has carried real arms for both since they were written (gunbc.v1_interpreter_primitive_surface v4_bridge.symbol_lexeme, v4_bridge.symbol_intern_lexeme). But with no roster row the RESOLVER saw an ordinary declaration, so Rust emission emitted the declaration, and `pub fn symbol_lexeme(sym: String) -> String { symbol_lexeme(sym) }` COMPILES. The emitted v2 compiler closure therefore carried two functions that type-check, pass every gate we own, and diverge from the interpreter by not terminating -- the DESIGN section 5 fabricated-plausible-output failure in its quietest form, since unlike the sibling seams (decl_facts and friends, which at least refuse loudly as unresolved v1_rt symbols) nothing anywhere reports this one.
+
+WHAT MAKES THE RUST REALIZATION HONEST RATHER THAN A SHIM: extdeps.languages.rust.types already declares Symbol's target type as String, so on that target the interning table is the identity and both bridges ARE identity functions. That is a realization of the declared row, not a second opinion about it; a target where Symbol is NOT String would need a different realization and the registry is where it would say so. The interpreter's arms and the Rust registry rows now answer for the same two primitives, which is the agreement that was missing.
+
+THE RESIDUE IS NAMED, NOT CLOSED: a self-call body is a DECIDABLE structural marker of a host seam, so the compiler could refuse an unrealized one instead of emitting it. It does not yet, and until it does this roster is the only thing standing between a new v4_bridge declaration and another silently nonterminating emission. That check is this class's next-rung trigger."
 
 data primitive_projection_roster_note: String = "One row per declaration that is the modeled surface of a declared primitive. Every row was established by READING THE DECLARATION, not by matching its name: the HostRealizedSeam rows are declarations whose whole body is a self-call, and the ModeledProjection rows are declarations with a real body that the builtin arm intercepts ahead of. The single DivergentProjection row is v2.std.collection map_get, whose declared return type is Outcome<Optional<V>> against the primitive's Optional<V>; it is carried rather than omitted because omission and divergence are different answers -- omission means nobody has looked, divergence means someone looked and found two authorities. A consumer collecting call candidates must suppress the builtin co-candidate for the first two fidelities and must keep refusing on the third."
 
@@ -68,6 +76,8 @@ fn primitive_projection_roster() -> List<PrimitiveProjection> {
     primitive_projection_row(primitive: primitive_concept_decl_facts, module_path: "v2.std.concept_index", decl_name: "concept_decl_facts", fidelity: HostRealizedSeam),
     primitive_projection_row(primitive: primitive_concept_decl_facts_live, module_path: "v2.std.concept_index", decl_name: "concept_decl_facts_live", fidelity: HostRealizedSeam),
     primitive_projection_row(primitive: primitive_empty_map, module_path: "v2.std.collection", decl_name: "empty_map_primitive_delegate", fidelity: HostRealizedSeam),
+    primitive_projection_row(primitive: primitive_symbol_lexeme, module_path: "v2.std.compilers.lexing", decl_name: "symbol_lexeme", fidelity: HostRealizedSeam),
+    primitive_projection_row(primitive: primitive_symbol_intern_lexeme, module_path: "v2.std.compilers.lexing", decl_name: "symbol_intern_lexeme", fidelity: HostRealizedSeam),
     primitive_projection_row(primitive: primitive_length, module_path: "v2.std.algebra", decl_name: "length", fidelity: ModeledProjection),
     primitive_projection_row(primitive: primitive_map_insert, module_path: "v2.std.collection", decl_name: "map_insert", fidelity: ModeledProjection),
     primitive_projection_row(primitive: primitive_empty_map, module_path: "v2.std.collection", decl_name: "empty_map", fidelity: ModeledProjection),