S2 Self Emit

dag/gunbc/commit_workflow.dag

@@ -300,6 +300,24 @@ data commit_gate_roster: List<CommitCheckEnrollment> = [
     },
     surfaces: [GithubActionsCiJob]
   },
+  CommitCheckEnrollment {
+    check: CommitWitnessClaim {
+      entry: "src/v2/test/claim/self_host/std_logic_emit_probe_test.dag",
+      check_fns: ["std_logic_emit_probe_all_holds"],
+      kind: CorpusWitnessKind,
+      span: SpanUndeclared
+    },
+    surfaces: [GithubActionsCiJob]
+  },
+  CommitCheckEnrollment {
+    check: CommitWitnessClaim {
+      entry: "src/v2/test/claim/execution/std_logic_behavioral_selfhost_witness_test.dag",
+      check_fns: ["std_logic_behavioral_selfhost_all_holds"],
+      kind: ExecutionWitnessKind,
+      span: SpanUndeclared
+    },
+    surfaces: [GithubActionsCiJob]
+  },
   CommitCheckEnrollment {
     check: CommitCargoFmtCheck,
     surfaces: [GitPrePushHook]

src/v2/compiler/03_name_resolve.dag

@@ -6,6 +6,7 @@ import v2.compiler.resolve {
   DeclaredBinding,
   Namespace,
   ResolvedTree,
+  namespace_bindings_augment_from_module_atoms,
   resolve_with_namespace,
   try_edge_declared_binding
 }
@@ -517,7 +518,10 @@ fn namespace_for_subject(
                 Accepted {
                   value: AdmittedSubject {
                     namespace: Namespace {
-                      bindings: b,
+                      bindings: namespace_bindings_augment_from_module_atoms(
+                        root: subject_module_root,
+                        bindings: b
+                      ),
                       canonical_symbols: base.canonical_symbols
                     },
                     subject_root: subject_module_root

src/v2/compiler/03_resolve.dag

@@ -43,6 +43,7 @@ import v2.std.node {
   Bind,
   ComputationNode,
   Conj,
+  Disj,
   Edge,
   Named,
   Node,
@@ -54,6 +55,7 @@ import v2.std.node {
   Transform,
   TypeNode,
   fold_node,
+  node_subtree_nodes,
   node_with_occurrence_id,
   well_formed
 }
@@ -140,6 +142,63 @@ fn harvest_direct_atom_binding(root: Node, acc: Map<Symbol, Symbol>) -> Map<Symb
   )
 }
 
+data resolve_variant_visibility_dissolution_trigger: String = "🟡 dissolve-on: interim per-module Disj variant visibility — a bare variant name (e.g. `True` in `match a { True => .. }`) is made resolvable ONLY when exactly one type in the subject module declares it (module-unique); a name declared by >=2 types stays unbound and REFUSES (fail-closed, no silent mis-bind). Dissolves when patterns-via-scrutinee (namespace-only-resolution, rolled into the final self-host fan-out) adds scrutinee-type disambiguation of the ambiguous residue; at that point resolution reads the containment tree via SymbolIndex, not this per-module count."
+
+fn harvest_variant_count_of(counts: Map<Symbol, Int>, sym: Symbol) -> Int {
+  match map_get(counts, sym) {
+    Accepted { value: opt, diagnostics: _ } => match opt {
+      Present { value: n } => n
+      Absent => 0
+    }
+    Rejected { diagnostics: _ } => 0
+  }
+}
+
+fn harvest_disj_variant_counts(root: Node) -> Map<Symbol, Int> {
+  fold(
+    node_subtree_nodes(root: root),
+    init: empty_map(),
+    f: fn(counts, n) {
+      match n.kind {
+        TypeNode { connective: Disj } =>
+          fold(n.children, init: counts, f: fn(c, e) {
+            match e.label {
+              Named { name: sym } =>
+                map_insert(m: c, key: sym, value: harvest_variant_count_of(counts: c, sym: sym) + 1)
+              Positional => c
+            }
+          })
+        _ => counts
+      }
+    }
+  )
+}
+
+fn harvest_unique_disj_variant_bindings(root: Node, acc: Map<Symbol, Symbol>) -> Map<Symbol, Symbol> {
+  let counts = harvest_disj_variant_counts(root: root)
+  fold(
+    node_subtree_nodes(root: root),
+    init: acc,
+    f: fn(a, n) {
+      match n.kind {
+        TypeNode { connective: Disj } =>
+          fold(n.children, init: a, f: fn(a2, e) {
+            match e.label {
+              Named { name: sym } =>
+                if harvest_variant_count_of(counts: counts, sym: sym) == 1 {
+                  map_insert(m: a2, key: sym, value: sym)
+                } else {
+                  a2
+                }
+              Positional => a2
+            }
+          })
+        _ => a
+      }
+    }
+  )
+}
+
 fn add_module_named_exports(root: Node, acc: Map<Symbol, Symbol>) -> Map<Symbol, Symbol> {
   harvest_conj_named_bindings(root: root, acc: acc)
 }
@@ -189,6 +248,13 @@ fn build_program_namespace(tree: NormalizedTree, lm: LanguageModel) -> Namespace
   }
 }
 
+fn namespace_bindings_augment_from_module_atoms(
+  root: Node,
+  bindings: Map<Symbol, Symbol>
+) -> Map<Symbol, Symbol> {
+  harvest_unique_disj_variant_bindings(root: root, acc: bindings)
+}
+
 fn scope_from_namespace(namespace: Namespace) -> Scope {
   ScopeRoot { module: namespace }
 }