diff --git a/src/v3/compiler/src/bootstrap_generated_without_parse_surface.rs b/src/v3/compiler/src/bootstrap_generated_without_parse_surface.rs
index a33915d84f7..271f8ad330b 100644
--- a/src/v3/compiler/src/bootstrap_generated_without_parse_surface.rs
+++ b/src/v3/compiler/src/bootstrap_generated_without_parse_surface.rs
@@ -9,7 +9,7 @@ pub(crate) fn bootstrapped_fixture_without_parse_surface_dag() -> Dag {
         diagnostics: bootstrapped_fixture_without_parse_surface_dag_diagnostics(),
         next_node_id: 844,
         next_declaration_id: 3147,
-        next_port_id: 1009,
+        next_port_id: 1051,
         primitives: PrimitiveCache::default(),
         substrate_markers: SubstrateMarkers::default(),
         realization_metas: RealizationMetaCache::default(),
@@ -9184,38 +9184,38 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(810),
             data: LiteralBits::String("+".to_string()),
-            output: PortId(971),
+            output: PortId(1013),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 886, 889),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(811),
             data: LiteralBits::String("-".to_string()),
-            output: PortId(972),
+            output: PortId(1014),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 905, 908),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(812),
             data: LiteralBits::String("*".to_string()),
-            output: PortId(973),
+            output: PortId(1015),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 924, 927),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(813),
             data: LiteralBits::String("/".to_string()),
-            output: PortId(974),
+            output: PortId(1016),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 943, 946),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Branch(BranchNode {
             id: NodeId(814),
-            input: PortId(970),
+            input: PortId(1012),
             paths: vec![
                 Path {
                     body: NodeId(810),
-                    output: PortId(971),
+                    output: PortId(1013),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Add".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 879, 882),
@@ -9224,7 +9224,7 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                 },
                 Path {
                     body: NodeId(811),
-                    output: PortId(972),
+                    output: PortId(1014),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Sub".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 898, 901),
@@ -9233,7 +9233,7 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                 },
                 Path {
                     body: NodeId(812),
-                    output: PortId(973),
+                    output: PortId(1015),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Mul".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 917, 920),
@@ -9242,7 +9242,7 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                 },
                 Path {
                     body: NodeId(813),
-                    output: PortId(974),
+                    output: PortId(1016),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Div".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 936, 939),
@@ -9250,59 +9250,59 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                     binding: None,
                 },
             ],
-            output: PortId(975),
+            output: PortId(1017),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 857, 954),
             emit_participation: Some(BranchEmitParticipation::UserMatch),
         }));
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(815),
             data: LiteralBits::String("==".to_string()),
-            output: PortId(977),
+            output: PortId(1019),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1012, 1016),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(816),
             data: LiteralBits::String("!=".to_string()),
-            output: PortId(978),
+            output: PortId(1020),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1031, 1035),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(817),
             data: LiteralBits::String("<".to_string()),
-            output: PortId(979),
+            output: PortId(1021),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1050, 1053),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(818),
             data: LiteralBits::String("<=".to_string()),
-            output: PortId(980),
+            output: PortId(1022),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1068, 1072),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(819),
             data: LiteralBits::String(">".to_string()),
-            output: PortId(981),
+            output: PortId(1023),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1087, 1090),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(820),
             data: LiteralBits::String(">=".to_string()),
-            output: PortId(982),
+            output: PortId(1024),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1105, 1109),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Branch(BranchNode {
             id: NodeId(821),
-            input: PortId(976),
+            input: PortId(1018),
             paths: vec![
                 Path {
                     body: NodeId(815),
-                    output: PortId(977),
+                    output: PortId(1019),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Eq".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1006, 1008),
@@ -9311,7 +9311,7 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                 },
                 Path {
                     body: NodeId(816),
-                    output: PortId(978),
+                    output: PortId(1020),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Ne".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1025, 1027),
@@ -9320,7 +9320,7 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                 },
                 Path {
                     body: NodeId(817),
-                    output: PortId(979),
+                    output: PortId(1021),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Lt".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1044, 1046),
@@ -9329,7 +9329,7 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                 },
                 Path {
                     body: NodeId(818),
-                    output: PortId(980),
+                    output: PortId(1022),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Le".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1062, 1064),
@@ -9338,7 +9338,7 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                 },
                 Path {
                     body: NodeId(819),
-                    output: PortId(981),
+                    output: PortId(1023),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Gt".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1081, 1083),
@@ -9347,7 +9347,7 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                 },
                 Path {
                     body: NodeId(820),
-                    output: PortId(982),
+                    output: PortId(1024),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Ge".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1099, 1101),
@@ -9355,31 +9355,31 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                     binding: None,
                 },
             ],
-            output: PortId(983),
+            output: PortId(1025),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 985, 1117),
             emit_participation: Some(BranchEmitParticipation::UserMatch),
         }));
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(822),
             data: LiteralBits::String("&&".to_string()),
-            output: PortId(985),
+            output: PortId(1027),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1179, 1183),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(823),
             data: LiteralBits::String("||".to_string()),
-            output: PortId(986),
+            output: PortId(1028),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1198, 1202),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Branch(BranchNode {
             id: NodeId(824),
-            input: PortId(984),
+            input: PortId(1026),
             paths: vec![
                 Path {
                     body: NodeId(822),
-                    output: PortId(985),
+                    output: PortId(1027),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "And".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1172, 1175),
@@ -9388,7 +9388,7 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                 },
                 Path {
                     body: NodeId(823),
-                    output: PortId(986),
+                    output: PortId(1028),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Or".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1192, 1194),
@@ -9396,60 +9396,60 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                     binding: None,
                 },
             ],
-            output: PortId(987),
+            output: PortId(1029),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1148, 1210),
             emit_participation: Some(BranchEmitParticipation::UserMatch),
         }));
         nodes.push(Behavior::Branch(BranchNode {
             id: NodeId(825),
-            input: PortId(969),
+            input: PortId(1011),
             paths: vec![
                 Path {
                     body: NodeId(814),
-                    output: PortId(975),
+                    output: PortId(1017),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Arithmetic".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 830, 847),
                     },
                     binding: Some(PayloadBinding {
                         binding_name: "arith".to_string(),
-                        payload_port: PortId(970),
+                        payload_port: PortId(1012),
                     }),
                 },
                 Path {
                     body: NodeId(821),
-                    output: PortId(983),
+                    output: PortId(1025),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Comparison".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 959, 975),
                     },
                     binding: Some(PayloadBinding {
                         binding_name: "comp".to_string(),
-                        payload_port: PortId(976),
+                        payload_port: PortId(1018),
                     }),
                 },
                 Path {
                     body: NodeId(824),
-                    output: PortId(987),
+                    output: PortId(1029),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Logical".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1122, 1138),
                     },
                     binding: Some(PayloadBinding {
                         binding_name: "logical".to_string(),
-                        payload_port: PortId(984),
+                        payload_port: PortId(1026),
                     }),
                 },
             ],
-            output: PortId(988),
+            output: PortId(1030),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 815, 1214),
             emit_participation: Some(BranchEmitParticipation::UserMatch),
         }));
         nodes.push(Behavior::Bind(BindNode {
             id: NodeId(826),
             name: "symbol".to_string(),
-            value: PortId(988),
-            params: vec![PortId(969)],
+            value: PortId(1030),
+            params: vec![PortId(1011)],
             span: SourceSpan::new("src/v3/compiler/operators.dag", 815, 1214),
             lane2_workflow: None,
             emit_participation: Some(BindEmitParticipation::UserCallable),
@@ -9457,38 +9457,38 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(827),
             data: LiteralBits::String("add".to_string()),
-            output: PortId(991),
+            output: PortId(1033),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1341, 1346),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(828),
             data: LiteralBits::String("sub".to_string()),
-            output: PortId(992),
+            output: PortId(1034),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1362, 1367),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(829),
             data: LiteralBits::String("mul".to_string()),
-            output: PortId(993),
+            output: PortId(1035),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1383, 1388),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(830),
             data: LiteralBits::String("div".to_string()),
-            output: PortId(994),
+            output: PortId(1036),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1404, 1409),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Branch(BranchNode {
             id: NodeId(831),
-            input: PortId(990),
+            input: PortId(1032),
             paths: vec![
                 Path {
                     body: NodeId(827),
-                    output: PortId(991),
+                    output: PortId(1033),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Add".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1334, 1337),
@@ -9497,7 +9497,7 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                 },
                 Path {
                     body: NodeId(828),
-                    output: PortId(992),
+                    output: PortId(1034),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Sub".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1355, 1358),
@@ -9506,7 +9506,7 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                 },
                 Path {
                     body: NodeId(829),
-                    output: PortId(993),
+                    output: PortId(1035),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Mul".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1376, 1379),
@@ -9515,7 +9515,7 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                 },
                 Path {
                     body: NodeId(830),
-                    output: PortId(994),
+                    output: PortId(1036),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Div".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1397, 1400),
@@ -9523,59 +9523,59 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                     binding: None,
                 },
             ],
-            output: PortId(995),
+            output: PortId(1037),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1312, 1417),
             emit_participation: Some(BranchEmitParticipation::UserMatch),
         }));
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(832),
             data: LiteralBits::String("eq".to_string()),
-            output: PortId(997),
+            output: PortId(1039),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1475, 1479),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(833),
             data: LiteralBits::String("ne".to_string()),
-            output: PortId(998),
+            output: PortId(1040),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1494, 1498),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(834),
             data: LiteralBits::String("lt".to_string()),
-            output: PortId(999),
+            output: PortId(1041),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1513, 1517),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(835),
             data: LiteralBits::String("le".to_string()),
-            output: PortId(1000),
+            output: PortId(1042),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1532, 1536),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(836),
             data: LiteralBits::String("gt".to_string()),
-            output: PortId(1001),
+            output: PortId(1043),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1551, 1555),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(837),
             data: LiteralBits::String("ge".to_string()),
-            output: PortId(1002),
+            output: PortId(1044),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1570, 1574),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Branch(BranchNode {
             id: NodeId(838),
-            input: PortId(996),
+            input: PortId(1038),
             paths: vec![
                 Path {
                     body: NodeId(832),
-                    output: PortId(997),
+                    output: PortId(1039),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Eq".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1469, 1471),
@@ -9584,7 +9584,7 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                 },
                 Path {
                     body: NodeId(833),
-                    output: PortId(998),
+                    output: PortId(1040),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Ne".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1488, 1490),
@@ -9593,7 +9593,7 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                 },
                 Path {
                     body: NodeId(834),
-                    output: PortId(999),
+                    output: PortId(1041),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Lt".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1507, 1509),
@@ -9602,7 +9602,7 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                 },
                 Path {
                     body: NodeId(835),
-                    output: PortId(1000),
+                    output: PortId(1042),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Le".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1526, 1528),
@@ -9611,7 +9611,7 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                 },
                 Path {
                     body: NodeId(836),
-                    output: PortId(1001),
+                    output: PortId(1043),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Gt".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1545, 1547),
@@ -9620,7 +9620,7 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                 },
                 Path {
                     body: NodeId(837),
-                    output: PortId(1002),
+                    output: PortId(1044),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Ge".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1564, 1566),
@@ -9628,31 +9628,31 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                     binding: None,
                 },
             ],
-            output: PortId(1003),
+            output: PortId(1045),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1448, 1582),
             emit_participation: Some(BranchEmitParticipation::UserMatch),
         }));
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(839),
             data: LiteralBits::String("meet".to_string()),
-            output: PortId(1005),
+            output: PortId(1047),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1978, 1984),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Value(ValueNode {
             id: NodeId(840),
             data: LiteralBits::String("join".to_string()),
-            output: PortId(1006),
+            output: PortId(1048),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1999, 2005),
             lane2_workflow: None,
         }));
         nodes.push(Behavior::Branch(BranchNode {
             id: NodeId(841),
-            input: PortId(1004),
+            input: PortId(1046),
             paths: vec![
                 Path {
                     body: NodeId(839),
-                    output: PortId(1005),
+                    output: PortId(1047),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "And".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1971, 1974),
@@ -9661,7 +9661,7 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                 },
                 Path {
                     body: NodeId(840),
-                    output: PortId(1006),
+                    output: PortId(1048),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Or".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1993, 1995),
@@ -9669,60 +9669,60 @@ fn bootstrapped_fixture_without_parse_surface_dag_nodes() -> Vec<Behavior> {
                     binding: None,
                 },
             ],
-            output: PortId(1007),
+            output: PortId(1049),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1947, 2013),
             emit_participation: Some(BranchEmitParticipation::UserMatch),
         }));
         nodes.push(Behavior::Branch(BranchNode {
             id: NodeId(842),
-            input: PortId(989),
+            input: PortId(1031),
             paths: vec![
                 Path {
                     body: NodeId(831),
-                    output: PortId(995),
+                    output: PortId(1037),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Arithmetic".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1285, 1302),
                     },
                     binding: Some(PayloadBinding {
                         binding_name: "arith".to_string(),
-                        payload_port: PortId(990),
+                        payload_port: PortId(1032),
                     }),
                 },
                 Path {
                     body: NodeId(838),
-                    output: PortId(1003),
+                    output: PortId(1045),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Comparison".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1422, 1438),
                     },
                     binding: Some(PayloadBinding {
                         binding_name: "comp".to_string(),
-                        payload_port: PortId(996),
+                        payload_port: PortId(1038),
                     }),
                 },
                 Path {
                     body: NodeId(841),
-                    output: PortId(1007),
+                    output: PortId(1049),
                     pattern: BranchPattern::UnresolvedVariant {
                         name: "Logical".to_string(),
                         span: SourceSpan::new("src/v3/compiler/operators.dag", 1921, 1937),
                     },
                     binding: Some(PayloadBinding {
                         binding_name: "logical".to_string(),
-                        payload_port: PortId(1004),
+                        payload_port: PortId(1046),
                     }),
                 },
             ],
-            output: PortId(1008),
+            output: PortId(1050),
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1270, 2017),
             emit_participation: Some(BranchEmitParticipation::UserMatch),
         }));
         nodes.push(Behavior::Bind(BindNode {
             id: NodeId(843),
             name: "algebra_field_name".to_string(),
-            value: PortId(1008),
-            params: vec![PortId(989)],
+            value: PortId(1050),
+            params: vec![PortId(1031)],
             span: SourceSpan::new("src/v3/compiler/operators.dag", 1270, 2017),
             lane2_workflow: None,
             emit_participation: Some(BindEmitParticipation::UserCallable),
@@ -96350,7 +96350,7 @@ fn bootstrapped_fixture_without_parse_surface_dag_ports() -> HashMap<PortId, Por
             PortId(969),
             Port {
                 id: PortId(969),
-                state: PortState::Resolved(TypeShape::new(DeclarationId(806))),
+                state: PortState::Unresolved,
                 produced_by: None,
             },
         );
@@ -96358,7 +96358,7 @@ fn bootstrapped_fixture_without_parse_surface_dag_ports() -> HashMap<PortId, Por
             PortId(970),
             Port {
                 id: PortId(970),
-                state: PortState::Uninferred,
+                state: PortState::Unresolved,
                 produced_by: None,
             },
         );
@@ -96366,47 +96366,47 @@ fn bootstrapped_fixture_without_parse_surface_dag_ports() -> HashMap<PortId, Por
             PortId(971),
             Port {
                 id: PortId(971),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(810)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(972),
             Port {
                 id: PortId(972),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(811)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(973),
             Port {
                 id: PortId(973),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(812)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(974),
             Port {
                 id: PortId(974),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(813)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(975),
             Port {
                 id: PortId(975),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(814)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(976),
             Port {
                 id: PortId(976),
-                state: PortState::Uninferred,
+                state: PortState::Unresolved,
                 produced_by: None,
             },
         );
@@ -96414,63 +96414,63 @@ fn bootstrapped_fixture_without_parse_surface_dag_ports() -> HashMap<PortId, Por
             PortId(977),
             Port {
                 id: PortId(977),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(815)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(978),
             Port {
                 id: PortId(978),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(816)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(979),
             Port {
                 id: PortId(979),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(817)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(980),
             Port {
                 id: PortId(980),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(818)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(981),
             Port {
                 id: PortId(981),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(819)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(982),
             Port {
                 id: PortId(982),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(820)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(983),
             Port {
                 id: PortId(983),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(821)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(984),
             Port {
                 id: PortId(984),
-                state: PortState::Uninferred,
+                state: PortState::Unresolved,
                 produced_by: None,
             },
         );
@@ -96478,39 +96478,39 @@ fn bootstrapped_fixture_without_parse_surface_dag_ports() -> HashMap<PortId, Por
             PortId(985),
             Port {
                 id: PortId(985),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(822)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(986),
             Port {
                 id: PortId(986),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(823)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(987),
             Port {
                 id: PortId(987),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(824)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(988),
             Port {
                 id: PortId(988),
-                state: PortState::Resolved(TypeShape::new(DeclarationId(230))),
-                produced_by: Some(NodeId(825)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(989),
             Port {
                 id: PortId(989),
-                state: PortState::Resolved(TypeShape::new(DeclarationId(806))),
+                state: PortState::Unresolved,
                 produced_by: None,
             },
         );
@@ -96518,7 +96518,7 @@ fn bootstrapped_fixture_without_parse_surface_dag_ports() -> HashMap<PortId, Por
             PortId(990),
             Port {
                 id: PortId(990),
-                state: PortState::Uninferred,
+                state: PortState::Unresolved,
                 produced_by: None,
             },
         );
@@ -96526,47 +96526,47 @@ fn bootstrapped_fixture_without_parse_surface_dag_ports() -> HashMap<PortId, Por
             PortId(991),
             Port {
                 id: PortId(991),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(827)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(992),
             Port {
                 id: PortId(992),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(828)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(993),
             Port {
                 id: PortId(993),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(829)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(994),
             Port {
                 id: PortId(994),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(830)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(995),
             Port {
                 id: PortId(995),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(831)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(996),
             Port {
                 id: PortId(996),
-                state: PortState::Uninferred,
+                state: PortState::Unresolved,
                 produced_by: None,
             },
         );
@@ -96574,63 +96574,63 @@ fn bootstrapped_fixture_without_parse_surface_dag_ports() -> HashMap<PortId, Por
             PortId(997),
             Port {
                 id: PortId(997),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(832)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(998),
             Port {
                 id: PortId(998),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(833)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(999),
             Port {
                 id: PortId(999),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(834)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(1000),
             Port {
                 id: PortId(1000),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(835)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(1001),
             Port {
                 id: PortId(1001),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(836)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(1002),
             Port {
                 id: PortId(1002),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(837)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(1003),
             Port {
                 id: PortId(1003),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(838)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(1004),
             Port {
                 id: PortId(1004),
-                state: PortState::Uninferred,
+                state: PortState::Unresolved,
                 produced_by: None,
             },
         );
@@ -96638,30 +96638,366 @@ fn bootstrapped_fixture_without_parse_surface_dag_ports() -> HashMap<PortId, Por
             PortId(1005),
             Port {
                 id: PortId(1005),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(839)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(1006),
             Port {
                 id: PortId(1006),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(840)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(1007),
             Port {
                 id: PortId(1007),
-                state: PortState::Uninferred,
-                produced_by: Some(NodeId(841)),
+                state: PortState::Unresolved,
+                produced_by: None,
             },
         );
         ports.insert(
             PortId(1008),
             Port {
                 id: PortId(1008),
+                state: PortState::Unresolved,
+                produced_by: None,
+            },
+        );
+        ports.insert(
+            PortId(1009),
+            Port {
+                id: PortId(1009),
+                state: PortState::Unresolved,
+                produced_by: None,
+            },
+        );
+        ports.insert(
+            PortId(1010),
+            Port {
+                id: PortId(1010),
+                state: PortState::Unresolved,
+                produced_by: None,
+            },
+        );
+        ports.insert(
+            PortId(1011),
+            Port {
+                id: PortId(1011),
+                state: PortState::Resolved(TypeShape::new(DeclarationId(806))),
+                produced_by: None,
+            },
+        );
+        ports.insert(
+            PortId(1012),
+            Port {
+                id: PortId(1012),
+                state: PortState::Uninferred,
+                produced_by: None,
+            },
+        );
+        ports.insert(
+            PortId(1013),
+            Port {
+                id: PortId(1013),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(810)),
+            },
+        );
+        ports.insert(
+            PortId(1014),
+            Port {
+                id: PortId(1014),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(811)),
+            },
+        );
+        ports.insert(
+            PortId(1015),
+            Port {
+                id: PortId(1015),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(812)),
+            },
+        );
+        ports.insert(
+            PortId(1016),
+            Port {
+                id: PortId(1016),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(813)),
+            },
+        );
+        ports.insert(
+            PortId(1017),
+            Port {
+                id: PortId(1017),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(814)),
+            },
+        );
+        ports.insert(
+            PortId(1018),
+            Port {
+                id: PortId(1018),
+                state: PortState::Uninferred,
+                produced_by: None,
+            },
+        );
+        ports.insert(
+            PortId(1019),
+            Port {
+                id: PortId(1019),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(815)),
+            },
+        );
+        ports.insert(
+            PortId(1020),
+            Port {
+                id: PortId(1020),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(816)),
+            },
+        );
+        ports.insert(
+            PortId(1021),
+            Port {
+                id: PortId(1021),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(817)),
+            },
+        );
+        ports.insert(
+            PortId(1022),
+            Port {
+                id: PortId(1022),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(818)),
+            },
+        );
+        ports.insert(
+            PortId(1023),
+            Port {
+                id: PortId(1023),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(819)),
+            },
+        );
+        ports.insert(
+            PortId(1024),
+            Port {
+                id: PortId(1024),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(820)),
+            },
+        );
+        ports.insert(
+            PortId(1025),
+            Port {
+                id: PortId(1025),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(821)),
+            },
+        );
+        ports.insert(
+            PortId(1026),
+            Port {
+                id: PortId(1026),
+                state: PortState::Uninferred,
+                produced_by: None,
+            },
+        );
+        ports.insert(
+            PortId(1027),
+            Port {
+                id: PortId(1027),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(822)),
+            },
+        );
+        ports.insert(
+            PortId(1028),
+            Port {
+                id: PortId(1028),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(823)),
+            },
+        );
+        ports.insert(
+            PortId(1029),
+            Port {
+                id: PortId(1029),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(824)),
+            },
+        );
+        ports.insert(
+            PortId(1030),
+            Port {
+                id: PortId(1030),
+                state: PortState::Resolved(TypeShape::new(DeclarationId(230))),
+                produced_by: Some(NodeId(825)),
+            },
+        );
+        ports.insert(
+            PortId(1031),
+            Port {
+                id: PortId(1031),
+                state: PortState::Resolved(TypeShape::new(DeclarationId(806))),
+                produced_by: None,
+            },
+        );
+        ports.insert(
+            PortId(1032),
+            Port {
+                id: PortId(1032),
+                state: PortState::Uninferred,
+                produced_by: None,
+            },
+        );
+        ports.insert(
+            PortId(1033),
+            Port {
+                id: PortId(1033),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(827)),
+            },
+        );
+        ports.insert(
+            PortId(1034),
+            Port {
+                id: PortId(1034),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(828)),
+            },
+        );
+        ports.insert(
+            PortId(1035),
+            Port {
+                id: PortId(1035),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(829)),
+            },
+        );
+        ports.insert(
+            PortId(1036),
+            Port {
+                id: PortId(1036),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(830)),
+            },
+        );
+        ports.insert(
+            PortId(1037),
+            Port {
+                id: PortId(1037),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(831)),
+            },
+        );
+        ports.insert(
+            PortId(1038),
+            Port {
+                id: PortId(1038),
+                state: PortState::Uninferred,
+                produced_by: None,
+            },
+        );
+        ports.insert(
+            PortId(1039),
+            Port {
+                id: PortId(1039),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(832)),
+            },
+        );
+        ports.insert(
+            PortId(1040),
+            Port {
+                id: PortId(1040),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(833)),
+            },
+        );
+        ports.insert(
+            PortId(1041),
+            Port {
+                id: PortId(1041),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(834)),
+            },
+        );
+        ports.insert(
+            PortId(1042),
+            Port {
+                id: PortId(1042),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(835)),
+            },
+        );
+        ports.insert(
+            PortId(1043),
+            Port {
+                id: PortId(1043),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(836)),
+            },
+        );
+        ports.insert(
+            PortId(1044),
+            Port {
+                id: PortId(1044),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(837)),
+            },
+        );
+        ports.insert(
+            PortId(1045),
+            Port {
+                id: PortId(1045),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(838)),
+            },
+        );
+        ports.insert(
+            PortId(1046),
+            Port {
+                id: PortId(1046),
+                state: PortState::Uninferred,
+                produced_by: None,
+            },
+        );
+        ports.insert(
+            PortId(1047),
+            Port {
+                id: PortId(1047),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(839)),
+            },
+        );
+        ports.insert(
+            PortId(1048),
+            Port {
+                id: PortId(1048),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(840)),
+            },
+        );
+        ports.insert(
+            PortId(1049),
+            Port {
+                id: PortId(1049),
+                state: PortState::Uninferred,
+                produced_by: Some(NodeId(841)),
+            },
+        );
+        ports.insert(
+            PortId(1050),
+            Port {
+                id: PortId(1050),
                 state: PortState::Resolved(TypeShape::new(DeclarationId(230))),
                 produced_by: Some(NodeId(842)),
             },
@@ -96671,7 +97007,52 @@ fn bootstrapped_fixture_without_parse_surface_dag_ports() -> HashMap<PortId, Por
 }
 
 fn bootstrapped_fixture_without_parse_surface_dag_diagnostics() -> DiagnosticTable {
-    DiagnosticTable::new()
+    {
+        let mut table = DiagnosticTable::new();
+        table.insert(PortId(969), Diagnostic::ResolveError { name: "data `go_surface_module` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/go.dag", 18419, 18440), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(970), Diagnostic::ResolveError { name: "data `go_surface_item` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/go.dag", 18660, 18679), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(971), Diagnostic::ResolveError { name: "data `go_surface_param` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/go.dag", 18817, 18837), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(972), Diagnostic::ResolveError { name: "data `go_surface_field` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/go.dag", 19217, 19237), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(973), Diagnostic::ResolveError { name: "data `go_surface_variant` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/go.dag", 19530, 19552), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(974), Diagnostic::ResolveError { name: "data `go_variant_payload` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/go.dag", 19934, 19956), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(975), Diagnostic::ResolveError { name: "data `go_surface_type` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/go.dag", 20096, 20115), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(976), Diagnostic::ResolveError { name: "data `go_surface_record_field` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/go.dag", 20260, 20286), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(977), Diagnostic::ResolveError { name: "data `go_surface_map_entry` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/go.dag", 20670, 20693), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(978), Diagnostic::ResolveError { name: "data `go_surface_match_arm` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/go.dag", 21157, 21180), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(979), Diagnostic::ResolveError { name: "data `go_surface_pattern_field` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/go.dag", 21569, 21596), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(980), Diagnostic::ResolveError { name: "data `go_surface_pattern` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/go.dag", 21983, 22005), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(981), Diagnostic::ResolveError { name: "data `go_surface_literal` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/go.dag", 22148, 22170), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(982), Diagnostic::ResolveError { name: "data `go_surface_expr` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/go.dag", 22310, 22329), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(983), Diagnostic::ResolveError { name: "data `python_surface_module` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/python.dag", 9699, 9720), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(984), Diagnostic::ResolveError { name: "data `python_surface_item` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/python.dag", 9948, 9967), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(985), Diagnostic::ResolveError { name: "data `python_surface_param` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/python.dag", 10113, 10133), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(986), Diagnostic::ResolveError { name: "data `python_surface_field` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/python.dag", 10521, 10541), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(987), Diagnostic::ResolveError { name: "data `python_surface_variant` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/python.dag", 10842, 10864), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(988), Diagnostic::ResolveError { name: "data `python_variant_payload` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/python.dag", 11254, 11276), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(989), Diagnostic::ResolveError { name: "data `python_surface_type` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/python.dag", 11424, 11443), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(990), Diagnostic::ResolveError { name: "data `python_surface_record_field` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/python.dag", 11596, 11622), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(991), Diagnostic::ResolveError { name: "data `python_surface_map_entry` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/python.dag", 12014, 12037), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(992), Diagnostic::ResolveError { name: "data `python_surface_match_arm` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/python.dag", 12509, 12532), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(993), Diagnostic::ResolveError { name: "data `python_surface_pattern_field` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/python.dag", 12929, 12956), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(994), Diagnostic::ResolveError { name: "data `python_surface_pattern` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/python.dag", 13351, 13373), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(995), Diagnostic::ResolveError { name: "data `python_surface_literal` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/python.dag", 13524, 13546), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(996), Diagnostic::ResolveError { name: "data `python_surface_expr` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/python.dag", 13694, 13713), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(997), Diagnostic::ResolveError { name: "data `rust_surface_module` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/rust.dag", 25882, 25903), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(998), Diagnostic::ResolveError { name: "data `rust_surface_item` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/rust.dag", 26142, 26161), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(999), Diagnostic::ResolveError { name: "data `rust_surface_param` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/rust.dag", 26318, 26338), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(1000), Diagnostic::ResolveError { name: "data `rust_surface_field` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/rust.dag", 26737, 26757), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(1001), Diagnostic::ResolveError { name: "data `rust_surface_variant` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/rust.dag", 27069, 27091), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(1002), Diagnostic::ResolveError { name: "data `rust_variant_payload` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/rust.dag", 27492, 27514), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(1003), Diagnostic::ResolveError { name: "data `rust_surface_type` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/rust.dag", 27673, 27692), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(1004), Diagnostic::ResolveError { name: "data `rust_surface_record_field` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/rust.dag", 27856, 27882), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(1005), Diagnostic::ResolveError { name: "data `rust_surface_map_entry` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/rust.dag", 28285, 28308), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(1006), Diagnostic::ResolveError { name: "data `rust_surface_match_arm` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/rust.dag", 28791, 28814), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(1007), Diagnostic::ResolveError { name: "data `rust_surface_pattern_field` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/rust.dag", 29222, 29249), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(1008), Diagnostic::ResolveError { name: "data `rust_surface_pattern` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/rust.dag", 29655, 29677), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(1009), Diagnostic::ResolveError { name: "data `rust_surface_literal` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/rust.dag", 29839, 29861), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table.insert(PortId(1010), Diagnostic::ResolveError { name: "data `rust_surface_expr` field `target` must be a DeclarationRef edge; use an identifier or dotted path, not a record literal".to_string(), span: SourceSpan::new("src/v3/spec/rust.dag", 30020, 30039), fixes: vec![] }, DiagnosticAttribution::Unattributed);
+        table
+    }
 }
 
 fn bootstrapped_fixture_without_parse_surface_dag_clusters() -> Vec<Cluster> {