R1 split DAG operator authority from v3 projection

dsl/extdeps/languages/dag/syntax.dag

@@ -12,8 +12,8 @@ import std.syntax {
   ExprBody, BlockBody, TypeBody, ValueBody, NoBody,
   ServiceBody, ResourceBody,
   OperatorSpec, SyntaxSpec,
-  BinOp, Add, Sub, Mul, Div,
-  Eq, Ne, Lt, Gt, Le, Ge, And, Or,
+  BinOp, Add, Sub, Mul, Div, Mod,
+  Eq, Ne, Lt, Gt, Le, Ge, And, Or, NullCoalesce,
   LiteralValue, LitBool, LitNull
 }
 
@@ -91,14 +91,17 @@ data dag_non_name_keywords: Map<String, Bool> = {
   "acquire": true, "release": true
 }
 
-// Operator precedence table.
-// || < && < cmp < add < mul < |> < .
+// External .dag operator precedence authority.
+// This table models external .dag syntax reality, not the current v3-supported
+// tokenizer/parser/operator subset.
+// || < && < ?? < cmp < add < mul < |> < .
 // |> and . have binding power entries but their binop field is unused
 // (the expression loop handles them as pipe/field-access, not binary ops).
 
 data dag_operators: List<OperatorSpec> = [
   OperatorSpec { symbol: "||", left_bp: 5, right_bp: 6, binop: Or, algebra_field: none },
   OperatorSpec { symbol: "&&", left_bp: 7, right_bp: 8, binop: And, algebra_field: none },
+  OperatorSpec { symbol: "??", left_bp: 8, right_bp: 9, binop: NullCoalesce, algebra_field: none },
   OperatorSpec { symbol: "==", left_bp: 9, right_bp: 10, binop: Eq, algebra_field: none },
   OperatorSpec { symbol: "!=", left_bp: 9, right_bp: 10, binop: Ne, algebra_field: none },
   OperatorSpec { symbol: "<", left_bp: 11, right_bp: 12, binop: Lt, algebra_field: none },
@@ -109,10 +112,25 @@ data dag_operators: List<OperatorSpec> = [
   OperatorSpec { symbol: "-", left_bp: 13, right_bp: 14, binop: Sub, algebra_field: none },
   OperatorSpec { symbol: "*", left_bp: 15, right_bp: 16, binop: Mul, algebra_field: none },
   OperatorSpec { symbol: "/", left_bp: 15, right_bp: 16, binop: Div, algebra_field: none },
+  OperatorSpec { symbol: "%", left_bp: 15, right_bp: 16, binop: Mod, algebra_field: none },
   OperatorSpec { symbol: "|>", left_bp: 17, right_bp: 18, binop: none, algebra_field: none },
   OperatorSpec { symbol: ".", left_bp: 19, right_bp: 20, binop: none, algebra_field: none }
 ]
 
+// Current v3 capability projection.
+// v3 tokenizer/parser/operator validation consumes these explicit supported
+// symbols, then reads precedence/binop facts from `dag_operators`. This avoids
+// duplicating operator semantics while still fencing current v3 capability.
+// It intentionally excludes external `dag_operators` rows that v3 does not
+// parse end-to-end yet, including `??` and `%`.
+
+data v3_supported_dag_operators: Map<String, Bool> = {
+  "||": true, "&&": true,
+  "==": true, "!=": true, "<": true, ">": true, "<=": true, ">=": true,
+  "+": true, "-": true, "*": true, "/": true,
+  "|>": true, ".": true
+}
+
 data dag_syntax_spec: SyntaxSpec = SyntaxSpec {
   item_forms: dag_item_forms,
   operators: dag_operators,

src/v2/stage0/src/extdeps_languages_dag_syntax.rs

@@ -1,7 +1,9 @@
 // Generated by v2 compiler -- do not edit.
 // Source module: extdeps.languages.dag.syntax
 
-use crate::std_syntax::BinOp::{Add, And, Div, Eq, Ge, Gt, Le, Lt, Mul, Ne, Or, Sub};
+use crate::std_syntax::BinOp::{
+    Add, And, Div, Eq, Ge, Gt, Le, Lt, Mod, Mul, Ne, NullCoalesce, Or, Sub,
+};
 use crate::std_syntax::BodyKind::{
     BlockBody, ExprBody, NoBody, ResourceBody, ServiceBody, TypeBody, ValueBody,
 };
@@ -193,6 +195,12 @@ pub fn dag_operators() -> Rc<Vec<Rc<OperatorSpec>>> {
         right_bp: 8,
         binop: Some(BinOp::And),
         algebra_field: None,
+    }), Rc::new(OperatorSpec {
+        symbol: "??".to_string(),
+        left_bp: 8,
+        right_bp: 9,
+        binop: Some(BinOp::NullCoalesce),
+        algebra_field: None,
     }), Rc::new(OperatorSpec {
         symbol: "==".to_string(),
         left_bp: 9,
@@ -253,6 +261,12 @@ pub fn dag_operators() -> Rc<Vec<Rc<OperatorSpec>>> {
         right_bp: 16,
         binop: Some(BinOp::Div),
         algebra_field: None,
+    }), Rc::new(OperatorSpec {
+        symbol: "%".to_string(),
+        left_bp: 15,
+        right_bp: 16,
+        binop: Some(BinOp::Mod),
+        algebra_field: None,
     }), Rc::new(OperatorSpec {
         symbol: "|>".to_string(),
         left_bp: 17,
@@ -271,6 +285,30 @@ pub fn dag_operators() -> Rc<Vec<Rc<OperatorSpec>>> {
     CACHED.with(|c| c.clone())
 }
 
+pub fn v3_supported_dag_operators() -> Rc<HashMap<String, bool>> {
+    thread_local! {
+        static CACHED: Rc<HashMap<String, bool>> = {
+            let mut __m = HashMap::new();
+            __m.insert("||".to_string(), true);
+            __m.insert("&&".to_string(), true);
+            __m.insert("==".to_string(), true);
+            __m.insert("!=".to_string(), true);
+            __m.insert("<".to_string(), true);
+            __m.insert(">".to_string(), true);
+            __m.insert("<=".to_string(), true);
+            __m.insert(">=".to_string(), true);
+            __m.insert("+".to_string(), true);
+            __m.insert("-".to_string(), true);
+            __m.insert("*".to_string(), true);
+            __m.insert("/".to_string(), true);
+            __m.insert("|>".to_string(), true);
+            __m.insert(".".to_string(), true);
+            Rc::new(__m)
+        };
+    }
+    CACHED.with(|c| c.clone())
+}
+
 pub fn dag_syntax_spec() -> Rc<SyntaxSpec> {
     thread_local! {
             static CACHED: Rc<SyntaxSpec> = {

src/v3/compiler/src/bin/regen_tokenize.rs

@@ -519,7 +519,8 @@ fn collect_punct_rows(dag: &Dag, shared_syntax: &SharedSyntaxAuthority) -> Vec<(
     let mut covered_kinds = BTreeSet::new();
 
     for pattern in &shared_syntax.operators {
-        match classify_shared_operator_for_tokenizer(pattern) {
+        match classify_shared_operator_for_tokenizer(pattern, &shared_syntax.v3_supported_operators)
+        {
             SharedOperatorTokenizerBoundary::Tokenized { kind } => {
                 assert!(
                     punct_variants.contains(kind),
@@ -610,16 +611,24 @@ fn keyword_spelling_for_token_kind(kind: &str) -> String {
         .to_ascii_lowercase()
 }
 
-// SG-1a operator bridge: shared operators still lower through raw-source reads,
-// so every `dag_operators` symbol must be classified explicitly here as either
-// tokenizer punctuation or parser-only debt. Unknown symbols panic so upstream
-// authority edits cannot silently disappear.
+// SG-1a operator bridge: shared operators still lower through raw-source reads.
+// `v3_supported_dag_operators` is the single support/exclusion projection; this
+// table only maps supported symbols to their current tokenizer variant.
 enum SharedOperatorTokenizerBoundary {
     Tokenized { kind: &'static str },
     ParserOnlyDebt { reason: &'static str },
 }
 
-fn classify_shared_operator_for_tokenizer(pattern: &str) -> SharedOperatorTokenizerBoundary {
+fn classify_shared_operator_for_tokenizer(
+    pattern: &str,
+    v3_supported: &BTreeSet<String>,
+) -> SharedOperatorTokenizerBoundary {
+    if !v3_supported.contains(pattern) {
+        return SharedOperatorTokenizerBoundary::ParserOnlyDebt {
+            reason: "operator is declared in external dag_operators but excluded from \
+                     v3_supported_dag_operators until v3 parses it end-to-end",
+        };
+    }
     match pattern {
         "==" => SharedOperatorTokenizerBoundary::Tokenized { kind: "EqEq" },
         "!=" => SharedOperatorTokenizerBoundary::Tokenized { kind: "NotEq" },
@@ -635,25 +644,18 @@ fn classify_shared_operator_for_tokenizer(pattern: &str) -> SharedOperatorTokeni
         "||" => SharedOperatorTokenizerBoundary::Tokenized { kind: "PipePipe" },
         "|>" => SharedOperatorTokenizerBoundary::Tokenized { kind: "PipeArrow" },
         "." => SharedOperatorTokenizerBoundary::Tokenized { kind: "Dot" },
-        "??" => SharedOperatorTokenizerBoundary::ParserOnlyDebt {
-            reason: "null-coalescing is declared in shared syntax but the v3 tokenizer/parser \
-                     surface does not yet admit it as punctuation",
-        },
-        "%" => SharedOperatorTokenizerBoundary::ParserOnlyDebt {
-            reason: "modulo is declared in shared syntax but the v3 tokenizer/parser surface \
-                     does not yet admit it as punctuation",
-        },
         other => panic!(
-            "shared syntax operator `{other}` has no SG-1a tokenizer bridge classification. \
-             Update `classify_shared_operator_for_tokenizer` to mark it as tokenizer-owned \
-             punctuation or explicit parser-only debt so the authority boundary stays fail-closed."
+            "`v3_supported_dag_operators` includes `{other}`, but the SG-1a tokenizer bridge has \
+             no TokenKind mapping for it. Add tokenizer/parser/operator support or remove it from \
+             the v3 projection."
         ),
     }
 }
 
 struct SharedSyntaxAuthority {
     keywords: Vec<String>,
     operators: Vec<String>,
+    v3_supported_operators: BTreeSet<String>,
 }
 
 impl SharedSyntaxAuthority {
@@ -670,9 +672,15 @@ impl SharedSyntaxAuthority {
             extract_balanced_section(source, "data dag_operators", '[', ']'),
             "symbol",
         );
+        let v3_supported_operators: BTreeSet<_> = parse_all_string_literals(
+            extract_balanced_section(source, "data v3_supported_dag_operators", '{', '}'),
+        )
+        .into_iter()
+        .collect();
         Self {
             keywords,
             operators,
+            v3_supported_operators,
         }
     }
 }
@@ -730,6 +738,17 @@ fn parse_named_string_fields(section: &str, field_name: &str) -> Vec<String> {
     out
 }
 
+fn parse_all_string_literals(section: &str) -> Vec<String> {
+    let mut out = Vec::new();
+    let mut rest = section;
+    while let Some(idx) = rest.find('"') {
+        let (value, consumed) = parse_string_literal(&rest[idx..]);
+        out.push(value);
+        rest = &rest[idx + consumed..];
+    }
+    out
+}
+
 fn parse_string_literal(source: &str) -> (String, usize) {
     assert!(
         source.starts_with('"'),