perf(asap_types): decode each installed DAG once per validation

PrecomputePlan::validate and validate_catalog_contents decoded every
installed DAG inside the per-materialization loop, O(materializations x
DAGs) decodes. Decode lazily once per DAG; decode errors still surface
only where a DAG is used.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: zzylol

crates/asap_types/src/precompute_plan.rs

@@ -522,6 +522,12 @@ impl PrecomputePlan {
                     .chain(input.inputs.iter().copied())
             })
             .collect();
+        // Decode each DAG at most once; errors still surface only where used.
+        let dags = self
+            .executable_dags
+            .values()
+            .map(|installed| (installed, std::cell::OnceCell::new()))
+            .collect::<Vec<_>>();
         for config in &self.materializations {
             if !config.population_key_encoding.is_legacy()
                 && (self.ingest.protocol != IngestProtocol::PrometheusRemoteWriteV1
@@ -572,11 +578,11 @@ impl PrecomputePlan {
             }
             validated_source_window_cohort(config, &sources)?;
             let mut matched = false;
-            for installed in self.executable_dags.values() {
-                let dag = installed
-                    .document
-                    .decode()
-                    .map_err(PrecomputePlanError::CatalogContract)?;
+            for (installed, dag) in &dags {
+                let dag = dag
+                    .get_or_init(|| installed.document.decode())
+                    .as_ref()
+                    .map_err(|error| PrecomputePlanError::CatalogContract(error.clone()))?;
                 for sink in &installed.binding.precompute_sinks {
                     if !matches!(installed.binding.node(*sink),
                         Some(crate::executable_plan::BackendNodeBinding::Materialization { stored_output })

crates/asap_types/src/precompute_plan/catalog.rs

@@ -55,6 +55,12 @@ impl PrecomputePlan {
                 "stored output semantics differ from installed writer computation",
             ));
         }
+        // Decode each DAG at most once; errors still surface only where used.
+        let dags = self
+            .executable_dags
+            .values()
+            .map(|installed| (installed, std::cell::OnceCell::new()))
+            .collect::<Vec<_>>();
         for config in &self.materializations {
             if config.derived_input.is_some() && config.semantic_fragment.is_none() {
                 return Err(invalid(
@@ -63,16 +69,19 @@ impl PrecomputePlan {
             }
             if let Some(expected) = &config.semantic_fragment {
                 let mut found = false;
-                for installed in self.executable_dags.values() {
-                    let dag = installed.document.decode().map_err(invalid)?;
+                for (installed, dag) in &dags {
+                    let dag = dag
+                        .get_or_init(|| installed.document.decode())
+                        .as_ref()
+                        .map_err(|error| invalid(error.clone()))?;
                     for (id, binding) in &installed.binding.nodes {
                         if matches!(binding, crate::executable_plan::BackendNodeBinding::Materialization { stored_output }
                             if stored_output.fingerprint() == config.policy_fingerprint())
                         {
                             found = true;
                             let actual = match &self.ingest.dataset_identity {
-                                Some(dataset) => crate::semantic_fragment::SemanticFragment::from_stored_output_in_dataset(&dag, *id, dataset.clone()),
-                                None => crate::semantic_fragment::SemanticFragment::from_stored_output(&dag, *id),
+                                Some(dataset) => crate::semantic_fragment::SemanticFragment::from_stored_output_in_dataset(dag, *id, dataset.clone()),
+                                None => crate::semantic_fragment::SemanticFragment::from_stored_output(dag, *id),
                             }.map_err(invalid)?;
                             if &actual != expected {
                                 return Err(invalid(