CollectionOps consume Rust HO MethodTemplateContract refs

.github/workflows/ci.yml

@@ -320,7 +320,7 @@ jobs:
   self_host_ratchet:
     if: github.event.pull_request.draft != true
     runs-on: ${{ vars.CI_RUNNER || 'ubuntu-latest' }}
-    timeout-minutes: 20
+    timeout-minutes: 30
     needs: [v3]
     continue-on-error: true
     steps:

docs/audit/gunb-ai-workflowgen-action-wrapper-port.md

@@ -1,6 +1,6 @@
 # Audit: gunb.ai workflowgen — action-wrapper & constraint port survey
 
-**Dispatch:** T-Workflow-As-Data prep (survey / catalog only).  
+**Dispatch:** T-Workflow-As-Data prep (survey / catalog only).
 **Scope:** Read-only inspection of `gunb-ai/gunb.ai` — especially `tools/ci/workflowgen/actions/`, `tools/ci/workflowgen/constraints/`, and how generated workflows consume wrappers. **No** workflow YAML edits, **no** substrate carriers, **no** CI timing / job-DAG design beyond noting wrapper dependencies.
 
 **Surveyed revision:** shallow clone `gunb-ai/gunb.ai` @ `085febfb7279215039c6ce9fd15659726d7c1e3e` (oneline: `085febf Fix Docker push to GitHub Container Registry (#918)`).

src/v3/compiler/src/dag.rs

@@ -2386,6 +2386,14 @@ pub(crate) struct EmitAnchorCache {
     pub fold_method: Option<DeclarationId>,
     /// `std.list.is_empty_method` method declaration.
     pub is_empty_method: Option<DeclarationId>,
+    /// `std.list.filter_method` method declaration.
+    pub filter_method: Option<DeclarationId>,
+    /// `std.list.flat_map_method` method declaration.
+    pub flat_map_method: Option<DeclarationId>,
+    /// `std.list.any_method` method declaration.
+    pub any_method: Option<DeclarationId>,
+    /// `std.list.all_method` method declaration.
+    pub all_method: Option<DeclarationId>,
 }
 
 #[derive(Debug, Default, Clone)]
@@ -3248,6 +3256,26 @@ impl Dag {
         self.emit_anchors.is_empty_method
     }
 
+    /// `filter_method` method declaration.
+    pub(crate) fn filter_method_decl(&self) -> Option<DeclarationId> {
+        self.emit_anchors.filter_method
+    }
+
+    /// `flat_map_method` method declaration.
+    pub(crate) fn flat_map_method_decl(&self) -> Option<DeclarationId> {
+        self.emit_anchors.flat_map_method
+    }
+
+    /// `any_method` method declaration.
+    pub(crate) fn any_method_decl(&self) -> Option<DeclarationId> {
+        self.emit_anchors.any_method
+    }
+
+    /// `all_method` method declaration.
+    pub(crate) fn all_method_decl(&self) -> Option<DeclarationId> {
+        self.emit_anchors.all_method
+    }
+
     /// Typed accessor for the cached `PatternBindingRule` variant
     /// handles resolved from `src/v3/std/clean_emission.dag` at
     /// bootstrap end. Consumed by per-target emitters when
@@ -3896,6 +3924,11 @@ impl Dag {
         self.emit_anchors.fold_method = self.declaration_by_name("fold_method").map(|d| d.id);
         self.emit_anchors.is_empty_method =
             self.declaration_by_name("is_empty_method").map(|d| d.id);
+        self.emit_anchors.filter_method = self.declaration_by_name("filter_method").map(|d| d.id);
+        self.emit_anchors.flat_map_method =
+            self.declaration_by_name("flat_map_method").map(|d| d.id);
+        self.emit_anchors.any_method = self.declaration_by_name("any_method").map(|d| d.id);
+        self.emit_anchors.all_method = self.declaration_by_name("all_method").map(|d| d.id);
 
         // `PatternBindingRule` variant resolution. Walks the
         // `std/clean_emission.dag` declaration's `Disj` variants

src/v3/compiler/src/emit/collection_ops_method_contract.rs

@@ -3,7 +3,21 @@
 //! declaration must be a `MethodTemplateContract` data binding whose
 //! `dag_method.decl` resolves to the expected registry `*_method` row.
 
-use crate::dag::{Dag, DeclarationId, FieldValue, TypeConnective, ValueBody};
+use super::method_emit_template_variant_label;
+use crate::dag::{Dag, DeclarationId, FieldValue, LiteralBits, TypeConnective, ValueBody};
+
+/// 🟢 TERMINAL at the CollectionOps contract-consumer projection boundary.
+/// This mirrors the substrate `MethodEmitTemplate` coproduct exactly so Rust
+/// CollectionOps can choose the HO inline rendering without flattening or
+/// copying template text into a third authority.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) enum MethodTemplateContractEmitTemplate {
+    SingleTemplate(String),
+    HigherOrderTemplates {
+        inline_template: String,
+        fn_ref_template: String,
+    },
+}
 
 /// Fail closed unless `contract_decl` is a `MethodTemplateContract` instance
 /// whose `dag_method.decl` resolves to `expected_method_decl`.
@@ -13,6 +27,33 @@ pub(crate) fn require_method_template_contract_dag_method(
     collection_ops_field: &'static str,
     expected_method_decl: DeclarationId,
 ) -> Result<(), &'static str> {
+    let fields = method_template_contract_fields(dag, contract_decl)?;
+    require_method_template_contract_fields_dag_method(
+        fields,
+        collection_ops_field,
+        expected_method_decl,
+    )
+}
+
+pub(crate) fn method_template_contract_decl_emit_template(
+    dag: &Dag,
+    contract_decl: DeclarationId,
+    collection_ops_field: &'static str,
+    expected_method_decl: DeclarationId,
+) -> Result<MethodTemplateContractEmitTemplate, &'static str> {
+    let fields = method_template_contract_fields(dag, contract_decl)?;
+    require_method_template_contract_fields_dag_method(
+        fields,
+        collection_ops_field,
+        expected_method_decl,
+    )?;
+    method_template_contract_fields_emit_template(dag, fields)
+}
+
+fn method_template_contract_fields(
+    dag: &Dag,
+    contract_decl: DeclarationId,
+) -> Result<&[(String, FieldValue)], &'static str> {
     let mtc_type_id = dag
         .method_template_contract_decl()
         .ok_or("internal: MethodTemplateContract type missing from dag")?;
@@ -43,7 +84,37 @@ pub(crate) fn require_method_template_contract_dag_method(
             );
         }
     };
+    Ok(fields)
+}
 
+fn require_method_template_contract_fields_dag_method(
+    fields: &[(String, FieldValue)],
+    collection_ops_field: &'static str,
+    expected_method_decl: DeclarationId,
+) -> Result<(), &'static str> {
+    let method_id = method_template_contract_fields_dag_method(fields)?;
+    if method_id != expected_method_decl {
+        return Err(match collection_ops_field {
+            "fold_contract" => "CollectionOps.fold_contract must target fold_method",
+            "concat_contract" => "CollectionOps.concat_contract must target concat_method",
+            "length_contract" => "CollectionOps.length_contract must target length_method",
+            "filter_contract" => "CollectionOps.filter_contract must target filter_method",
+            "flat_map_contract" => "CollectionOps.flat_map_contract must target flat_map_method",
+            "any_contract" => "CollectionOps.any_contract must target any_method",
+            "all_contract" => "CollectionOps.all_contract must target all_method",
+            "is_empty_contract" => {
+                "CollectionOps.is_empty_contract must target is_empty_method (FreeMonoid<T>.is_empty -> Bool)"
+            }
+            _ => "CollectionOps contract dag_method does not match expected registry method",
+        });
+    }
+
+    Ok(())
+}
+
+fn method_template_contract_fields_dag_method(
+    fields: &[(String, FieldValue)],
+) -> Result<DeclarationId, &'static str> {
     let dag_method = fields
         .iter()
         .find(|(l, _)| l == "dag_method")
@@ -62,17 +133,50 @@ pub(crate) fn require_method_template_contract_dag_method(
             );
         }
     };
-    if method_id != expected_method_decl {
-        return Err(match collection_ops_field {
-            "fold_contract" => "CollectionOps.fold_contract must target fold_method",
-            "concat_contract" => "CollectionOps.concat_contract must target concat_method",
-            "length_contract" => "CollectionOps.length_contract must target length_method",
-            "is_empty_contract" => {
-                "CollectionOps.is_empty_contract must target is_empty_method (FreeMonoid<T>.is_empty -> Bool)"
-            }
-            _ => "CollectionOps contract dag_method does not match expected registry method",
-        });
-    }
+    Ok(method_id)
+}
 
-    Ok(())
+fn method_template_contract_fields_emit_template(
+    dag: &Dag,
+    fields: &[(String, FieldValue)],
+) -> Result<MethodTemplateContractEmitTemplate, &'static str> {
+    let emit_value = fields
+        .iter()
+        .find(|(label, _)| label == "emit_template")
+        .map(|(_, v)| v)
+        .ok_or("MethodTemplateContract missing emit_template field")?;
+    let FieldValue::Variant {
+        constructor,
+        payload,
+    } = emit_value
+    else {
+        return Err("MethodTemplateContract.emit_template must be a sum variant");
+    };
+    let ctor_name = method_emit_template_variant_label(dag, *constructor).ok_or(
+        "MethodTemplateContract.emit_template variant not found under MethodEmitTemplate disj",
+    )?;
+    match ctor_name {
+        "SingleTemplate" => {
+            let [FieldValue::Literal(LiteralBits::String(template))] = payload.as_slice() else {
+                return Err("SingleTemplate must carry exactly one string template payload");
+            };
+            Ok(MethodTemplateContractEmitTemplate::SingleTemplate(
+                template.replace("%Q", "\""),
+            ))
+        }
+        "HigherOrderTemplates" => {
+            let [FieldValue::Literal(LiteralBits::String(inline_template)), FieldValue::Literal(LiteralBits::String(fn_ref_template))] =
+                payload.as_slice()
+            else {
+                return Err(
+                    "HigherOrderTemplates must carry inline_template and fn_ref_template strings",
+                );
+            };
+            Ok(MethodTemplateContractEmitTemplate::HigherOrderTemplates {
+                inline_template: inline_template.replace("%Q", "\""),
+                fn_ref_template: fn_ref_template.replace("%Q", "\""),
+            })
+        }
+        _ => Err("MethodTemplateContract.emit_template uses an unknown MethodEmitTemplate variant"),
+    }
 }