From 0daa1a672b82981906e320ed4c6dcd8e3949ffb7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Sat, 14 Jun 2025 03:43:24 +0300
Subject: [PATCH 01/29] feat: implement cache output parsing and validation for
 v1 recipes as per CEP specification

---
 src/recipe/parser.rs                     |  14 +
 src/recipe/parser/cache.rs               |  13 +-
 src/recipe/parser/cache_output.rs        | 409 ++++++++++++++++++++++
 src/recipe/parser/common_output.rs       | 302 ++++++++++++++++
 src/recipe/parser/output.rs              |  49 +--
 src/recipe/parser/output_v2.rs           | 420 +++++++++++++++++++++++
 src/recipe/parser/output_with_inherit.rs | 176 ++++++++++
 src/recipe/parser/parsing_utils.rs       | 200 +++++++++++
 8 files changed, 1533 insertions(+), 50 deletions(-)
 create mode 100644 src/recipe/parser/cache_output.rs
 create mode 100644 src/recipe/parser/common_output.rs
 create mode 100644 src/recipe/parser/output_v2.rs
 create mode 100644 src/recipe/parser/output_with_inherit.rs
 create mode 100644 src/recipe/parser/parsing_utils.rs

diff --git a/src/recipe/parser.rs b/src/recipe/parser.rs
index 787164db8..a10ae4e41 100644
--- a/src/recipe/parser.rs
+++ b/src/recipe/parser.rs
@@ -22,10 +22,15 @@ use crate::{
 mod about;
 mod build;
 mod cache;
+mod cache_output;
+mod common_output;
 mod glob_vec;
 mod helper;
 mod output;
+mod output_v2;
+mod output_with_inherit;
 mod package;
+mod parsing_utils;
 mod regex;
 mod requirements;
 mod script;
@@ -37,9 +42,18 @@ pub use self::{
     about::About,
     build::{Build, BuildString, DynamicLinking, PrefixDetection, Python},
     cache::Cache,
+    cache_output::{CacheBuild, CacheOutput, CacheRequirements},
+    common_output::{ALLOWED_KEYS_MULTI_OUTPUTS, DEEP_MERGE_KEYS, InheritSpec},
     glob_vec::{GlobCheckerVec, GlobVec, GlobWithSource},
     output::find_outputs_from_src,
+    output_v2::{find_outputs_v2, resolve_inheritance},
+    output_with_inherit::{OutputType, OutputWithInherit},
     package::{OutputPackage, Package},
+    parsing_utils::{
+        StandardTryConvert, invalid_field_error, missing_field_error, parse_bool,
+        parse_optional_string, parse_required_string, validate_mapping_keys,
+        validate_multi_output_root_keys,
+    },
     regex::SerializableRegex,
     requirements::{
         Dependency, IgnoreRunExports, Language, PinCompatible, PinSubpackage, Requirements,
diff --git a/src/recipe/parser/cache.rs b/src/recipe/parser/cache.rs
index 4da1f7c47..9b9eab929 100644
--- a/src/recipe/parser/cache.rs
+++ b/src/recipe/parser/cache.rs
@@ -9,7 +9,7 @@ use crate::{
 };
 use serde::{Deserialize, Serialize};
 
-use super::{Build, Requirements, Source};
+use super::{Build, Requirements, Source, cache_output::CacheOutput};
 
 /// A cache build that can be used to split up a build into multiple outputs
 #[derive(Debug, Default, Clone, Serialize, Deserialize)]
@@ -21,6 +21,9 @@ pub struct Cache {
     pub build: Build,
     /// The requirements for building the cache
     pub requirements: Requirements,
+    /// Cache outputs that define intermediate build artifacts
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub outputs: Vec<CacheOutput>,
 }
 
 impl TryConvertNode<Cache> for RenderedNode {
@@ -35,13 +38,7 @@ impl TryConvertNode<Cache> for RenderedMappingNode {
     fn try_convert(&self, _name: &str) -> Result<Cache, Vec<PartialParsingError>> {
         let mut cache = Cache::default();
 
-        validate_keys! {
-            cache,
-            self.iter(),
-            source,
-            build,
-            requirements
-        };
+        validate_keys!(cache, self.iter(), source, build, requirements, outputs);
 
         Ok(cache)
     }
diff --git a/src/recipe/parser/cache_output.rs b/src/recipe/parser/cache_output.rs
new file mode 100644
index 000000000..3eee3c5b5
--- /dev/null
+++ b/src/recipe/parser/cache_output.rs
@@ -0,0 +1,409 @@
+//! Cache output structures for v1 recipes according to the CEP specification
+//!
+//! This module defines the cache output type which is an intermediate build artifact
+//! that can be inherited by regular package outputs.
+
+use crate::{
+    _partialerror,
+    recipe::{
+        custom_yaml::{HasSpan, RenderedMappingNode, RenderedNode, TryConvertNode},
+        error::{ErrorKind, PartialParsingError},
+        parser::{
+            StandardTryConvert, invalid_field_error, missing_field_error, parse_required_string,
+            validate_mapping_keys,
+        },
+    },
+};
+use serde::{Deserialize, Serialize};
+
+use super::{Script, Source};
+
+/// A cache output that produces intermediate build artifacts
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CacheOutput {
+    /// The name of the cache output
+    pub name: String,
+    /// Sources for this cache output
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub source: Vec<Source>,
+    /// Build configuration for the cache  
+    pub build: CacheBuild,
+    /// Requirements for building the cache (only build and host allowed)
+    pub requirements: CacheRequirements,
+    /// Run exports to ignore
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ignore_run_exports: Option<super::requirements::IgnoreRunExports>,
+}
+
+/// Build configuration specific to cache outputs
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct CacheBuild {
+    /// The build script - only script key is allowed for cache outputs
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub script: Option<Script>,
+}
+
+/// Requirements specific to cache outputs (no run or run_constraints allowed)
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct CacheRequirements {
+    /// Build requirements
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub build: Vec<super::requirements::Dependency>,
+    /// Host requirements
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub host: Vec<super::requirements::Dependency>,
+}
+
+// Implement StandardTryConvert for automatic RenderedNode conversion
+impl StandardTryConvert for CacheOutput {
+    const TYPE_NAME: &'static str = "CacheOutput";
+
+    fn from_mapping(
+        mapping: &RenderedMappingNode,
+        _name: &str,
+    ) -> Result<Self, Vec<PartialParsingError>> {
+        let mut name = None;
+        let mut source = Vec::new();
+        let mut build = CacheBuild::default();
+        let mut requirements = CacheRequirements::default();
+        let mut ignore_run_exports = None;
+
+        for (key, value) in mapping.iter() {
+            match key.as_str() {
+                "cache" => {
+                    // Parse the cache mapping
+                    let cache_mapping = value.as_mapping().ok_or_else(|| {
+                        vec![_partialerror!(*value.span(), ErrorKind::ExpectedMapping)]
+                    })?;
+
+                    // Validate that only 'name' is allowed inside cache
+                    validate_mapping_keys(cache_mapping, &["name"], "cache")?;
+
+                    // Parse the name field
+                    if let Some(name_value) = cache_mapping.get("name") {
+                        name = Some(parse_required_string(name_value, "name", "cache")?);
+                    }
+                }
+                "source" => {
+                    source = value.try_convert("cache.source")?;
+                }
+                "build" => {
+                    build = parse_cache_build(value)?;
+                }
+                "requirements" => {
+                    requirements = parse_cache_requirements(value)?;
+                }
+                "ignore_run_exports" => {
+                    ignore_run_exports = Some(value.try_convert("cache.ignore_run_exports")?);
+                }
+                _ => {
+                    return Err(vec![invalid_field_error(
+                        *key.span(),
+                        key.as_str(),
+                        Some(
+                            "valid fields for cache outputs are: 'cache', 'source', 'build', 'requirements', and 'ignore_run_exports'",
+                        ),
+                    )]);
+                }
+            }
+        }
+
+        let name = name.ok_or_else(|| {
+            vec![missing_field_error(
+                *mapping.span(),
+                "name",
+                "cache outputs",
+            )]
+        })?;
+
+        Ok(CacheOutput {
+            name,
+            source,
+            build,
+            requirements,
+            ignore_run_exports,
+        })
+    }
+}
+
+/// Parse cache build section, ensuring only 'script' is allowed
+fn parse_cache_build(value: &RenderedNode) -> Result<CacheBuild, Vec<PartialParsingError>> {
+    let build_node = value
+        .as_mapping()
+        .ok_or_else(|| vec![_partialerror!(*value.span(), ErrorKind::ExpectedMapping)])?;
+
+    let mut build = CacheBuild::default();
+
+    // Validate allowed keys
+    validate_mapping_keys(
+        build_node,
+        &["script"],
+        "cache build section (only 'script' is allowed)",
+    )?;
+
+    if let Some(script_value) = build_node.get("script") {
+        build.script = Some(script_value.try_convert("cache.build.script")?);
+    }
+
+    Ok(build)
+}
+
+/// Parse cache requirements, ensuring only 'build' and 'host' are allowed
+fn parse_cache_requirements(
+    value: &RenderedNode,
+) -> Result<CacheRequirements, Vec<PartialParsingError>> {
+    let req_node = value
+        .as_mapping()
+        .ok_or_else(|| vec![_partialerror!(*value.span(), ErrorKind::ExpectedMapping)])?;
+
+    let mut requirements = CacheRequirements::default();
+    let mut errors = Vec::new();
+
+    for (req_key, req_value) in req_node.iter() {
+        match req_key.as_str() {
+            "build" => match req_value.try_convert("cache.requirements.build") {
+                Ok(deps) => requirements.build = deps,
+                Err(errs) => errors.extend(errs),
+            },
+            "host" => match req_value.try_convert("cache.requirements.host") {
+                Ok(deps) => requirements.host = deps,
+                Err(errs) => errors.extend(errs),
+            },
+            "run" | "run_constraints" => {
+                errors.push(invalid_field_error(
+                    *req_key.span(),
+                    req_key.as_str(),
+                    Some("cache outputs cannot have 'run' or 'run_constraints' requirements"),
+                ));
+            }
+            _ => {
+                errors.push(invalid_field_error(
+                    *req_key.span(),
+                    req_key.as_str(),
+                    Some("cache outputs can only have 'build' and 'host' requirements"),
+                ));
+            }
+        }
+    }
+
+    if !errors.is_empty() {
+        return Err(errors);
+    }
+
+    Ok(requirements)
+}
+
+// For compatibility with Vec<CacheOutput> parsing
+impl TryConvertNode<CacheOutput> for crate::recipe::custom_yaml::RenderedScalarNode {
+    fn try_convert(&self, _name: &str) -> Result<CacheOutput, Vec<PartialParsingError>> {
+        Err(vec![_partialerror!(
+            *self.span(),
+            ErrorKind::ExpectedMapping,
+            help = "cache outputs must be mappings, not scalars"
+        )])
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::recipe::parser::{OutputType, find_outputs_v2, resolve_inheritance};
+
+    #[test]
+    fn test_basic_cache_output() {
+        let yaml = r#"
+schema_version: 1
+
+outputs:
+  - cache:
+      name: foo-cache
+
+    source:
+      - url: https://foo.bar/source.tar.bz2
+        sha256: 0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef
+
+    requirements:
+      build:
+        - gcc
+        - cmake
+        - ninja
+      host:
+        - libzlib
+        - libfoo
+
+    build:
+      script: build_cache.sh
+
+  - package:
+      name: foo-headers
+
+    inherit:
+      from: foo-cache
+      run_exports: false
+
+    build:
+      files:
+        - include/
+
+  - package:
+      name: foo
+
+    inherit: foo-cache
+"#;
+
+        let outputs = find_outputs_v2(yaml).expect("Failed to parse outputs");
+        assert_eq!(outputs.len(), 3);
+
+        match &outputs[0] {
+            OutputType::Cache(cache) => {
+                assert_eq!(cache.name, "foo-cache");
+                assert_eq!(cache.source.len(), 1);
+                assert_eq!(cache.requirements.build.len(), 3);
+                assert_eq!(cache.requirements.host.len(), 2);
+            }
+            _ => panic!("Expected cache output"),
+        }
+
+        match &outputs[1] {
+            OutputType::Package(pkg) => {
+                assert_eq!(pkg.package.name().as_normalized(), "foo-headers");
+                assert!(pkg.inherit.is_some());
+                let inherit = pkg.inherit.as_ref().unwrap();
+                assert_eq!(inherit.cache_name(), "foo-cache");
+                assert!(!inherit.inherit_run_exports());
+            }
+            _ => panic!("Expected package output"),
+        }
+
+        match &outputs[2] {
+            OutputType::Package(pkg) => {
+                assert_eq!(pkg.package.name().as_normalized(), "foo");
+                assert!(pkg.inherit.is_some());
+                let inherit = pkg.inherit.as_ref().unwrap();
+                assert_eq!(inherit.cache_name(), "foo-cache");
+                assert!(inherit.inherit_run_exports());
+            }
+            _ => panic!("Expected package output"),
+        }
+    }
+
+    #[test]
+    fn test_file_patterns() {
+        let yaml = r#"
+outputs:
+  - cache:
+      name: build-cache
+
+    build:
+      script: |
+        mkdir -p include lib bin
+        touch include/foo.h lib/libfoo.so bin/foo
+
+  - package:
+      name: headers
+
+    inherit: build-cache
+
+    build:
+      files:
+        - include/**/*.h
+
+  - package:
+      name: libs
+
+    inherit: build-cache
+
+    build:
+      files:
+        include:
+          - lib/**/*.so
+        exclude:
+          - lib/**/*.a
+"#;
+
+        let outputs = find_outputs_v2(yaml).expect("Failed to parse outputs");
+        assert_eq!(outputs.len(), 3);
+        match &outputs[1] {
+            OutputType::Package(pkg) => {
+                // Files are in build.files, not pkg.files
+                assert!(!pkg.build.files.is_empty());
+            }
+            _ => panic!("Expected package output"),
+        }
+    }
+
+    #[test]
+    fn test_cache_without_run_requirements() {
+        // This should succeed - cache outputs cannot have run requirements
+        let yaml = r#"
+outputs:
+  - cache:
+      name: test-cache
+
+    requirements:
+      build:
+        - cmake
+      host:
+        - libfoo
+"#;
+
+        let outputs = find_outputs_v2(yaml).expect("Failed to parse outputs");
+        assert_eq!(outputs.len(), 1);
+    }
+
+    #[test]
+    fn test_cache_with_run_requirements_fails() {
+        // This should fail - cache outputs cannot have run requirements
+        let yaml = r#"
+outputs:
+  - cache:
+      name: test-cache
+
+    requirements:
+      run:
+        - python
+"#;
+
+        let result = find_outputs_v2(yaml);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_inheritance_resolution() {
+        let yaml = r#"
+outputs:
+  - cache:
+      name: common-build
+
+    source:
+      - url: https://example.com/source.tar.gz
+        sha256: 0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef
+
+    build:
+      script: build.sh
+
+  - package:
+      name: pkg1
+
+    inherit: common-build
+
+  - package:
+      name: pkg2
+
+    inherit:
+      from: common-build
+      run_exports: false
+"#;
+
+        let mut outputs = find_outputs_v2(yaml).expect("Failed to parse outputs");
+        resolve_inheritance(&mut outputs).expect("Failed to resolve inheritance");
+
+        for output in outputs.iter().skip(1).take(2) {
+            match output {
+                OutputType::Package(pkg) => {
+                    assert!(pkg.inherit.is_some());
+                }
+                _ => panic!("Expected package output"),
+            }
+        }
+    }
+}
diff --git a/src/recipe/parser/common_output.rs b/src/recipe/parser/common_output.rs
new file mode 100644
index 000000000..3dd61b5f2
--- /dev/null
+++ b/src/recipe/parser/common_output.rs
@@ -0,0 +1,302 @@
+//! Common types and utilities shared between different output parsing modules
+
+use crate::{
+    _partialerror,
+    recipe::{
+        ParsingError,
+        custom_yaml::{HasSpan, RenderedMappingNode, RenderedNode, TryConvertNode},
+        error::{ErrorKind, PartialParsingError},
+    },
+    source_code::SourceCode,
+};
+use serde::{Deserialize, Serialize};
+
+/// Represents how inheritance should be handled
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum InheritSpec {
+    /// Short form - just the cache name (inherits run_exports by default)
+    Short(String),
+    /// Long form - specifying what to inherit
+    Long {
+        /// The cache name to inherit from
+        from: String,
+        /// Whether to inherit run_exports (default: true)
+        #[serde(default = "default_true")]
+        run_exports: bool,
+    },
+}
+
+fn default_true() -> bool {
+    true
+}
+
+impl InheritSpec {
+    /// Get the cache name to inherit from
+    pub fn cache_name(&self) -> &str {
+        match self {
+            InheritSpec::Short(name) => name,
+            InheritSpec::Long { from, .. } => from,
+        }
+    }
+
+    /// Check if run_exports should be inherited
+    pub fn inherit_run_exports(&self) -> bool {
+        match self {
+            InheritSpec::Short(_) => true,
+            InheritSpec::Long { run_exports, .. } => *run_exports,
+        }
+    }
+}
+
+impl TryConvertNode<InheritSpec> for RenderedNode {
+    fn try_convert(&self, _name: &str) -> Result<InheritSpec, Vec<PartialParsingError>> {
+        // Try short form first (just a string)
+        if let Some(scalar) = self.as_scalar() {
+            return Ok(InheritSpec::Short(scalar.as_str().to_string()));
+        }
+
+        // Try long form (mapping)
+        if let Some(mapping) = self.as_mapping() {
+            let mut from = None;
+            let mut run_exports = true;
+
+            for (key, value) in mapping.iter() {
+                match key.as_str() {
+                    "from" => {
+                        from = Some(
+                            value
+                                .as_scalar()
+                                .ok_or_else(|| {
+                                    vec![_partialerror!(
+                                        *value.span(),
+                                        ErrorKind::ExpectedScalar,
+                                        help = "expected a string"
+                                    )]
+                                })?
+                                .as_str()
+                                .to_string(),
+                        );
+                    }
+                    "run_exports" => {
+                        let scalar = value.as_scalar().ok_or_else(|| {
+                            vec![_partialerror!(
+                                *value.span(),
+                                ErrorKind::ExpectedScalar,
+                                help = "expected a boolean"
+                            )]
+                        })?;
+                        run_exports = scalar.as_bool().ok_or_else(|| {
+                            vec![_partialerror!(
+                                *value.span(),
+                                ErrorKind::ExpectedScalar,
+                                help = "expected a boolean"
+                            )]
+                        })?;
+                    }
+                    _ => {
+                        return Err(vec![_partialerror!(
+                            *key.span(),
+                            ErrorKind::InvalidField(key.as_str().to_string().into())
+                        )]);
+                    }
+                }
+            }
+
+            let from = from.ok_or_else(|| {
+                vec![_partialerror!(
+                    *mapping.span(),
+                    ErrorKind::MissingField("from".to_string().into()),
+                    help = "inherit mapping must have a 'from' field"
+                )]
+            })?;
+
+            return Ok(InheritSpec::Long { from, run_exports });
+        }
+
+        Err(vec![_partialerror!(
+            *self.span(),
+            ErrorKind::ExpectedMapping,
+            help = "inherit must be either a string or a mapping"
+        )])
+    }
+}
+
+/// Keys that should be deep merged when combining top-level and output-specific values
+pub static DEEP_MERGE_KEYS: [&str; 4] = ["package", "about", "extra", "build"];
+
+/// Allowed keys in the root mapping for multi-output recipes
+pub static ALLOWED_KEYS_MULTI_OUTPUTS: [&str; 9] = [
+    "context",
+    "recipe",
+    "source",
+    "build",
+    "outputs",
+    "about",
+    "extra",
+    "cache",
+    "schema_version",
+];
+
+/// Deep merge two mapping nodes for specific keys
+#[allow(dead_code)]
+pub fn deep_merge_mapping(
+    output_map: &mut marked_yaml::types::MarkedMappingNode,
+    root_map: &marked_yaml::types::MarkedMappingNode,
+    keys_to_merge: &[&str],
+) -> Result<(), Vec<PartialParsingError>> {
+    for (key, value) in root_map.iter() {
+        let key_str = key.as_str();
+
+        if !output_map.contains_key(key) {
+            output_map.insert(key.clone(), value.clone());
+        } else if keys_to_merge.contains(&key_str) {
+            // Deep merge specific keys
+            let output_value = output_map.get_mut(key).unwrap();
+            let output_value_span = *output_value.span();
+            let output_value_map = output_value.as_mapping_mut().ok_or_else(|| {
+                vec![_partialerror!(
+                    output_value_span,
+                    ErrorKind::ExpectedMapping
+                )]
+            })?;
+
+            let mut root_value = value.clone();
+            let root_value_map = root_value
+                .as_mapping_mut()
+                .ok_or_else(|| vec![_partialerror!(*value.span(), ErrorKind::ExpectedMapping)])?;
+
+            merge_mapping_if_not_exists(output_value_map, root_value_map);
+        }
+    }
+
+    Ok(())
+}
+
+/// Merge items from source mapping into target mapping if keys don't already exist
+pub fn merge_mapping_if_not_exists(
+    target: &mut marked_yaml::types::MarkedMappingNode,
+    source: &marked_yaml::types::MarkedMappingNode,
+) {
+    for (k, v) in source.iter() {
+        if !target.contains_key(k) {
+            target.insert(k.clone(), v.clone());
+        }
+    }
+}
+
+/// Merge items from source mapping into target mapping if keys don't already exist (RenderedMappingNode version)
+pub fn merge_rendered_mapping_if_not_exists(
+    target: &mut RenderedMappingNode,
+    source: &RenderedMappingNode,
+) {
+    for (k, v) in source.iter() {
+        if !target.contains_key(k.as_str()) {
+            target.insert(k.clone(), v.clone());
+        }
+    }
+}
+
+/// Validate recipe mapping and extract version
+/// This helper validates that the recipe mapping only contains 'name' and 'version' fields
+fn validate_and_extract_version<'a, S, K, V, I, F, G>(
+    recipe_mapping: I,
+    src: &S,
+    key_to_str: F,
+    key_span: G,
+) -> Result<Option<V>, ParsingError<S>>
+where
+    S: SourceCode,
+    K: 'a,
+    V: Clone + 'a,
+    I: Iterator<Item = (&'a K, &'a V)>,
+    F: Fn(&K) -> &str,
+    G: Fn(&K) -> marked_yaml::Span,
+{
+    let mut recipe_version: Option<V> = None;
+
+    for (k, v) in recipe_mapping {
+        match key_to_str(k) {
+            "name" => {}
+            "version" => recipe_version = Some(v.clone()),
+            _ => {
+                return Err(ParsingError::from_partial(
+                    src.clone(),
+                    _partialerror!(
+                        key_span(k),
+                        ErrorKind::InvalidField(key_to_str(k).to_string().into()),
+                        help = "recipe can only contain `name` and `version` fields"
+                    ),
+                ));
+            }
+        }
+    }
+
+    Ok(recipe_version)
+}
+
+/// Extract recipe version from the recipe mapping (marked_yaml version)
+pub fn extract_recipe_version_marked<S: SourceCode>(
+    root_map: &marked_yaml::types::MarkedMappingNode,
+    src: &S,
+) -> Result<Option<marked_yaml::types::Node>, ParsingError<S>> {
+    let Some(recipe_node) = root_map.get("recipe") else {
+        return Ok(None);
+    };
+
+    let Some(recipe_mapping) = recipe_node.as_mapping() else {
+        return Ok(None);
+    };
+
+    validate_and_extract_version(recipe_mapping.iter(), src, |k| k.as_str(), |k| *k.span())
+}
+
+/// Extract recipe version from the recipe mapping (RenderedNode version)
+pub fn extract_recipe_version_rendered<S: SourceCode>(
+    root_map: &RenderedMappingNode,
+    src: &S,
+) -> Result<Option<RenderedNode>, ParsingError<S>> {
+    let Some(recipe_node) = root_map.get("recipe") else {
+        return Ok(None);
+    };
+
+    let Some(recipe_mapping) = recipe_node.as_mapping() else {
+        return Ok(None);
+    };
+
+    validate_and_extract_version(recipe_mapping.iter(), src, |k| k.as_str(), |k| *k.span())
+}
+
+/// Validate that outputs is a sequence and return it (RenderedNode version)
+pub fn validate_outputs_sequence_rendered<'a, S: SourceCode>(
+    outputs: &'a RenderedNode,
+    src: &S,
+) -> Result<&'a crate::recipe::custom_yaml::RenderedSequenceNode, ParsingError<S>> {
+    outputs.as_sequence().ok_or_else(|| {
+        ParsingError::from_partial(
+            src.clone(),
+            _partialerror!(
+                *outputs.span(),
+                ErrorKind::ExpectedSequence,
+                help = "`outputs` must always be a sequence"
+            ),
+        )
+    })
+}
+
+/// Parse root node as mapping (RenderedNode version)
+pub fn parse_root_as_mapping_rendered<'a, S: SourceCode>(
+    root_node: &'a RenderedNode,
+    src: &S,
+) -> Result<&'a RenderedMappingNode, ParsingError<S>> {
+    root_node.as_mapping().ok_or_else(|| {
+        ParsingError::from_partial(
+            src.clone(),
+            _partialerror!(
+                *root_node.span(),
+                ErrorKind::ExpectedMapping,
+                help = "root node must always be a mapping"
+            ),
+        )
+    })
+}
diff --git a/src/recipe/parser/output.rs b/src/recipe/parser/output.rs
index 61165f6f3..31bef66a2 100644
--- a/src/recipe/parser/output.rs
+++ b/src/recipe/parser/output.rs
@@ -16,18 +16,10 @@ use crate::{
     source_code::SourceCode,
 };
 
-static DEEP_MERGE_KEYS: [&str; 4] = ["package", "about", "extra", "build"];
-static ALLOWED_KEYS_MULTI_OUTPUTS: [&str; 9] = [
-    "context",
-    "recipe",
-    "source",
-    "build",
-    "outputs",
-    "about",
-    "extra",
-    "cache",
-    "schema_version",
-];
+use super::common_output::{
+    ALLOWED_KEYS_MULTI_OUTPUTS, DEEP_MERGE_KEYS, extract_recipe_version_marked,
+    merge_mapping_if_not_exists,
+};
 
 // Check if the `cache` top-level key is present. If it does not contain a
 // source, but there is a top-level `source` key, then we should warn the user
@@ -122,31 +114,8 @@ pub fn find_outputs_from_src<S: SourceCode>(src: S) -> Result<Vec<Node>, Parsing
         return Ok(vec![recipe]);
     };
 
-    let mut recipe_version: Option<marked_yaml::Node> = None;
-    // If `recipe` exists in root we will use the version as default for all outputs
-    // We otherwise ignore the `recipe.name` value.
-    if let Some(recipe_mapping) = root_map
-        .get("recipe")
-        .and_then(|recipe| recipe.as_mapping())
-    {
-        // make sure that mapping only contains name and version
-        for (k, v) in recipe_mapping.iter() {
-            match k.as_str() {
-                "name" => {}
-                "version" => recipe_version = Some(v.clone()),
-                _ => {
-                    return Err(ParsingError::from_partial(
-                        src,
-                        _partialerror!(
-                            *k.span(),
-                            ErrorKind::InvalidField(k.as_str().to_string().into()),
-                            help = "recipe can only contain `name` and `version` fields"
-                        ),
-                    ));
-                }
-            }
-        }
-    }
+    // Extract recipe version from the recipe mapping
+    let recipe_version = extract_recipe_version_marked(root_map, &src)?;
 
     let Some(outputs) = outputs.as_sequence() else {
         return Err(ParsingError::from_partial(
@@ -220,11 +189,7 @@ pub fn find_outputs_from_src<S: SourceCode>(src: S) -> Result<Vec<Node>, Parsing
                         ));
                     };
 
-                    for (key, value) in root_value_map.iter() {
-                        if !output_value_map.contains_key(key) {
-                            output_value_map.insert(key.clone(), value.clone());
-                        }
-                    }
+                    merge_mapping_if_not_exists(output_value_map, root_value_map);
                 }
             }
         }
diff --git a/src/recipe/parser/output_v2.rs b/src/recipe/parser/output_v2.rs
new file mode 100644
index 000000000..970003bd2
--- /dev/null
+++ b/src/recipe/parser/output_v2.rs
@@ -0,0 +1,420 @@
+//! Enhanced output parsing that supports cache outputs according to CEP specification
+
+use crate::{
+    _partialerror,
+    recipe::{
+        ParsingError,
+        custom_yaml::{HasSpan, RenderedMappingNode, RenderedNode, TryConvertNode},
+        error::{ErrorKind, PartialParsingError},
+    },
+    source_code::SourceCode,
+};
+
+use super::cache_output::CacheOutput;
+use super::common_output::{
+    ALLOWED_KEYS_MULTI_OUTPUTS, DEEP_MERGE_KEYS, extract_recipe_version_rendered,
+    merge_rendered_mapping_if_not_exists, parse_root_as_mapping_rendered,
+    validate_outputs_sequence_rendered,
+};
+use super::output_with_inherit::{OutputType, OutputWithInherit};
+
+/// Convert a vector of PartialParsingError to a single ParsingError
+fn convert_errors<S: SourceCode>(errors: Vec<PartialParsingError>, src: S) -> ParsingError<S> {
+    let converted_errors = errors
+        .into_iter()
+        .map(|e| ParsingError::from_partial(src.clone(), e))
+        .collect::<Vec<_>>();
+    converted_errors.into_iter().next().unwrap()
+}
+
+/// Validates root keys for multi-output recipes (RenderedMappingNode version)
+fn validate_multi_output_root_v2(
+    root_map: &RenderedMappingNode,
+    has_outputs: bool,
+) -> Result<(), PartialParsingError> {
+    if !has_outputs {
+        return Ok(());
+    }
+
+    if root_map.contains_key("package") {
+        let key = root_map
+            .keys()
+            .find(|k| k.as_str() == "package")
+            .expect("unreachable we preemptively check for if contains");
+        return Err(_partialerror!(
+            *key.span(),
+            ErrorKind::InvalidField("package".to_string().into()),
+            help = "recipe cannot have both `outputs` and `package` fields. Rename `package` to `recipe` or remove `outputs`"
+        ));
+    }
+
+    if root_map.contains_key("requirements") {
+        let key = root_map
+            .keys()
+            .find(|k| k.as_str() == "requirements")
+            .expect("unreachable we preemptively check for if contains");
+        return Err(_partialerror!(
+            *key.span(),
+            ErrorKind::InvalidField("requirements".to_string().into()),
+            help = "multi-output recipes cannot have a top-level requirements field. Move `requirements` inside the individual output."
+        ));
+    }
+
+    for key in root_map.keys() {
+        if !ALLOWED_KEYS_MULTI_OUTPUTS.contains(&key.as_str()) {
+            return Err(_partialerror!(
+                *key.span(),
+                ErrorKind::InvalidField(key.as_str().to_string().into()),
+                help = format!("invalid key `{}` in root node", key.as_str())
+            ));
+        }
+    }
+
+    Ok(())
+}
+
+/// Parse outputs from source with support for cache outputs
+pub fn find_outputs_v2<S: SourceCode>(src: S) -> Result<Vec<OutputType>, ParsingError<S>> {
+    let root_node = RenderedNode::parse_yaml(0, src.clone())?;
+    let root_map = parse_root_as_mapping_rendered(&root_node, &src)?;
+
+    let Some(outputs) = root_map.get("outputs") else {
+        return Err(ParsingError::from_partial(
+            src,
+            _partialerror!(
+                *root_node.span(),
+                ErrorKind::MissingField("outputs".into()),
+                help = "v2 recipes must have an 'outputs' field"
+            ),
+        ));
+    };
+
+    if let Err(err) = validate_multi_output_root_v2(root_map, true) {
+        return Err(ParsingError::from_partial(src, err));
+    }
+
+    let outputs = validate_outputs_sequence_rendered(outputs, &src)?;
+
+    let mut res = Vec::with_capacity(outputs.len());
+
+    let recipe_version = extract_recipe_version_rendered(root_map, &src)?;
+
+    for output in outputs.iter() {
+        let Some(output_map) = output.as_mapping() else {
+            return Err(ParsingError::from_partial(
+                src,
+                _partialerror!(
+                    *output.span(),
+                    ErrorKind::ExpectedMapping,
+                    help = "individual `output` must always be a mapping"
+                ),
+            ));
+        };
+
+        let is_cache = output_map.contains_key("cache");
+        let is_package = output_map.contains_key("package");
+
+        if is_cache && is_package {
+            return Err(ParsingError::from_partial(
+                src,
+                _partialerror!(
+                    *output.span(),
+                    ErrorKind::InvalidField("output".into()),
+                    help = "output cannot have both 'cache' and 'package' keys"
+                ),
+            ));
+        }
+
+        if !is_cache && !is_package {
+            return Err(ParsingError::from_partial(
+                src,
+                _partialerror!(
+                    *output.span(),
+                    ErrorKind::InvalidField("output".into()),
+                    help = "output must have either 'cache' or 'package' key"
+                ),
+            ));
+        }
+
+        let parsed_output = if is_cache {
+            let cache_output: CacheOutput =
+                match TryConvertNode::<CacheOutput>::try_convert(output, "outputs.cache") {
+                    Ok(cache) => cache,
+                    Err(err) => return Err(convert_errors(err, src.clone())),
+                };
+            OutputType::Cache(Box::new(cache_output))
+        } else {
+            let output_span = *output.span();
+            let mut processed_map = output_map.clone();
+
+            for (key, value) in root_map.iter() {
+                if key.as_str() == "outputs"
+                    || key.as_str() == "recipe"
+                    || key.as_str() == "schema_version"
+                    || key.as_str() == "cache"
+                {
+                    continue;
+                }
+
+                if !processed_map.contains_key(key.as_str()) {
+                    processed_map.insert(key.clone(), value.clone());
+                } else if DEEP_MERGE_KEYS.contains(&key.as_str()) {
+                    if let (Some(output_value), Some(root_value_map)) = (
+                        processed_map.get(key.as_str()).and_then(|v| v.as_mapping()),
+                        value.as_mapping(),
+                    ) {
+                        let mut merged_map = output_value.clone();
+                        merge_rendered_mapping_if_not_exists(&mut merged_map, root_value_map);
+                        processed_map.insert(key.clone(), RenderedNode::from(merged_map));
+                    }
+                }
+            }
+
+            if let Some(version) = recipe_version.as_ref() {
+                if let Some(package_node) = processed_map.get("package") {
+                    if let Some(package_map) = package_node.as_mapping() {
+                        if !package_map.contains_key("version") {
+                            let mut new_package_map = package_map.clone();
+                            new_package_map.insert("version".into(), version.clone());
+                            processed_map
+                                .insert("package".into(), RenderedNode::from(new_package_map));
+                        }
+                    }
+                } else {
+                    return Err(ParsingError::from_partial(
+                        src.clone(),
+                        _partialerror!(
+                            output_span,
+                            ErrorKind::MissingField("package".to_string().into())
+                        ),
+                    ));
+                }
+            }
+
+            let processed_output_node = RenderedNode::from(processed_map);
+            let output_with_inherit: OutputWithInherit =
+                match TryConvertNode::<OutputWithInherit>::try_convert(
+                    &processed_output_node,
+                    "output",
+                ) {
+                    Ok(output) => output,
+                    Err(err) => return Err(convert_errors(err, src.clone())),
+                };
+            OutputType::Package(Box::new(output_with_inherit))
+        };
+
+        res.push(parsed_output);
+    }
+
+    if let Err(errs) = resolve_inheritance(&mut res) {
+        return Err(convert_errors(errs, src));
+    }
+
+    Ok(res)
+}
+
+/// Resolve inheritance relationships between cache and package outputs
+pub fn resolve_inheritance(outputs: &mut [OutputType]) -> Result<(), Vec<PartialParsingError>> {
+    let mut cache_outputs = std::collections::HashMap::new();
+
+    for (idx, output) in outputs.iter().enumerate() {
+        if let OutputType::Cache(cache) = output {
+            if cache_outputs.contains_key(&cache.name) {
+                return Err(vec![_partialerror!(
+                    marked_yaml::Span::new_blank(),
+                    ErrorKind::InvalidField(
+                        format!("duplicate cache output name: {}", cache.name).into()
+                    ),
+                    help = format!(
+                        "Each cache output must have a unique name. Rename one of the cache outputs with name '{}'.",
+                        cache.name
+                    )
+                )]);
+            }
+            cache_outputs.insert(cache.name.clone(), idx);
+        }
+    }
+
+    let mut inheritance_todo = Vec::new();
+
+    for (idx, output) in outputs.iter().enumerate() {
+        if let OutputType::Package(package) = output {
+            if let Some(inherit_spec) = &package.inherit {
+                let cache_name = inherit_spec.cache_name();
+
+                let cache_idx = *cache_outputs.get(cache_name).ok_or_else(|| {
+                    let available_caches = cache_outputs.keys()
+                        .map(|name| format!("'{}'", name))
+                        .collect::<Vec<_>>()
+                        .join(", ");
+
+                    let help_text = if available_caches.is_empty() {
+                        format!("No cache outputs are defined in this recipe. Add a cache output with name '{}' or remove the inherit field.", cache_name)
+                    } else {
+                        format!("Available cache outputs: {}. Make sure the cache name is spelled correctly.", available_caches)
+                    };
+
+                    vec![_partialerror!(
+                        marked_yaml::Span::new_blank(),
+                        ErrorKind::InvalidField(
+                            format!("cache output '{}' not found", cache_name).into()
+                        ),
+                        help = help_text
+                    )]
+                })?;
+
+                inheritance_todo.push((idx, cache_idx));
+            }
+        }
+    }
+
+    for (pkg_idx, cache_idx) in inheritance_todo {
+        let cache_clone = if let OutputType::Cache(cache) = &outputs[cache_idx] {
+            (**cache).clone()
+        } else {
+            continue;
+        };
+
+        if let OutputType::Package(package) = &mut outputs[pkg_idx] {
+            package.apply_cache_inheritance(&cache_clone);
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_cache_output_parsing() {
+        let yaml = r#"
+outputs:
+  - cache:
+      name: foo-cache
+    source:
+      - url: https://foo.bar/source.tar.bz2
+        sha256: 0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef
+    requirements:
+      build:
+        - cmake
+      host:
+        - libfoo
+    build:
+      script: build_cache.sh
+
+  - package:
+      name: foo-headers
+    inherit:
+      from: foo-cache
+      run_exports: false
+    build:
+      files:
+        - include/
+
+  - package:
+      name: foo
+    inherit: foo-cache
+"#;
+
+        let outputs = find_outputs_v2(yaml).unwrap();
+        assert_eq!(outputs.len(), 3);
+
+        assert!(matches!(&outputs[0], OutputType::Cache(_)));
+        assert!(matches!(&outputs[1], OutputType::Package(_)));
+        assert!(matches!(&outputs[2], OutputType::Package(_)));
+    }
+
+    #[test]
+    fn test_error_messages() {
+        let yaml = r#"
+outputs:
+  - cache:
+      name: foo-cache
+    build:
+      script: build_cache.sh
+
+  - package:
+      name: foo
+    inherit: non-existent-cache
+"#;
+
+        let result = find_outputs_v2(yaml);
+        assert!(result.is_err());
+        let err = result.unwrap_err();
+        let err_str = format!("{:?}", err);
+        assert!(err_str.contains("cache output 'non-existent-cache' not found"));
+        assert!(err_str.contains("Available cache outputs: 'foo-cache'"));
+
+        let yaml = r#"
+outputs:
+  - cache:
+      name: foo-cache
+    build:
+      script: build_cache.sh
+
+  - cache:
+      name: foo-cache
+    build:
+      script: another_script.sh
+"#;
+
+        let result = find_outputs_v2(yaml);
+        assert!(result.is_err());
+        let err = result.unwrap_err();
+        let err_str = format!("{:?}", err);
+        assert!(err_str.contains("duplicate cache output name: foo-cache"));
+        assert!(err_str.contains("Each cache output must have a unique name"));
+
+        let yaml = r#"
+outputs:
+  - cache:
+      name: foo-cache
+    invalid_field: value
+    build:
+      script: build_cache.sh
+"#;
+
+        let result = find_outputs_v2(yaml);
+        assert!(result.is_err());
+        let err = result.unwrap_err();
+        let err_str = format!("{:?}", err);
+        assert!(err_str.contains("InvalidField(\"invalid_field\")"));
+        assert!(err_str.contains("valid fields for cache outputs are:"));
+
+        let yaml = r#"
+outputs:
+  - cache:
+      name: foo-cache
+    build:
+      script: build_cache.sh
+      invalid_field: value
+"#;
+
+        let result = find_outputs_v2(yaml);
+        assert!(result.is_err());
+        let err = result.unwrap_err();
+        let err_str = format!("{:?}", err);
+        assert!(err_str.contains("InvalidField(\"invalid_field\")"));
+        assert!(err_str.contains("only 'script' is allowed"));
+
+        let yaml = r#"
+outputs:
+  - cache:
+      name: foo-cache
+    build:
+      script: build_cache.sh
+    requirements:
+      invalid_field:
+        - package
+"#;
+
+        let result = find_outputs_v2(yaml);
+        assert!(result.is_err());
+        let err = result.unwrap_err();
+        let err_str = format!("{:?}", err);
+        assert!(err_str.contains("InvalidField(\"invalid_field\")"));
+        assert!(err_str.contains("cache outputs can only have 'build' and 'host' requirements"));
+    }
+}
diff --git a/src/recipe/parser/output_with_inherit.rs b/src/recipe/parser/output_with_inherit.rs
new file mode 100644
index 000000000..87a0a69b8
--- /dev/null
+++ b/src/recipe/parser/output_with_inherit.rs
@@ -0,0 +1,176 @@
+//! Enhanced output structures that support inheritance from cache outputs
+
+use crate::{
+    _partialerror,
+    recipe::{
+        custom_yaml::{HasSpan, RenderedMappingNode, RenderedNode, TryConvertNode},
+        error::{ErrorKind, PartialParsingError},
+    },
+};
+use serde::{Deserialize, Serialize};
+
+use super::common_output::InheritSpec;
+use super::{About, Build, OutputPackage, Requirements, Source, TestType};
+
+/// An output that can inherit from a cache
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct OutputWithInherit {
+    /// Package information for this output
+    pub package: OutputPackage,
+
+    /// Optional inheritance specification
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub inherit: Option<InheritSpec>,
+
+    /// Sources for this output
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub source: Vec<Source>,
+
+    /// Build configuration
+    #[serde(default)]
+    pub build: Build,
+
+    /// Requirements for this output
+    #[serde(default)]
+    pub requirements: Requirements,
+
+    /// Tests for this output
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub tests: Vec<TestType>,
+
+    /// About information
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub about: Option<About>,
+}
+
+/// Represents the type of output in a multi-output recipe
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum OutputType {
+    /// A cache output that produces intermediate artifacts
+    Cache(Box<super::cache_output::CacheOutput>),
+    /// A regular package output that may inherit from cache
+    Package(Box<OutputWithInherit>),
+}
+
+impl TryConvertNode<OutputType> for RenderedNode {
+    fn try_convert(&self, name: &str) -> Result<OutputType, Vec<PartialParsingError>> {
+        let mapping = self
+            .as_mapping()
+            .ok_or_else(|| vec![_partialerror!(*self.span(), ErrorKind::ExpectedMapping)])?;
+
+        if mapping.contains_key("cache") {
+            let cache_node = mapping.get("cache").ok_or_else(|| {
+                vec![_partialerror!(
+                    *self.span(),
+                    ErrorKind::MissingField("cache".into())
+                )]
+            })?;
+            let cache_output = cache_node.try_convert("outputs.cache")?;
+            return Ok(OutputType::Cache(Box::new(cache_output)));
+        }
+
+        if mapping.contains_key("package") {
+            let output = mapping.try_convert(name)?;
+            return Ok(OutputType::Package(Box::new(output)));
+        }
+
+        Err(vec![_partialerror!(
+            *self.span(),
+            ErrorKind::ExpectedMapping,
+            help = "output must have either 'cache' or 'package' key"
+        )])
+    }
+}
+
+impl TryConvertNode<OutputWithInherit> for RenderedNode {
+    fn try_convert(&self, name: &str) -> Result<OutputWithInherit, Vec<PartialParsingError>> {
+        self.as_mapping()
+            .ok_or_else(|| vec![_partialerror!(*self.span(), ErrorKind::ExpectedMapping)])
+            .and_then(|m| m.try_convert(name))
+    }
+}
+
+impl TryConvertNode<OutputWithInherit> for RenderedMappingNode {
+    fn try_convert(&self, _name: &str) -> Result<OutputWithInherit, Vec<PartialParsingError>> {
+        let mut package = None;
+        let mut inherit = None;
+        let mut source = Vec::new();
+        let mut build = Build::default();
+        let mut requirements = Requirements::default();
+        let mut tests = Vec::new();
+        let mut about = None;
+
+        for (key, value) in self.iter() {
+            match key.as_str() {
+                "package" => {
+                    package = Some(value.try_convert("output.package")?);
+                }
+                "inherit" => {
+                    inherit = Some(value.try_convert("output.inherit")?);
+                }
+                "source" => {
+                    source = value.try_convert("output.source")?;
+                }
+                "build" => {
+                    build = value.try_convert("output.build")?;
+                }
+                "requirements" => {
+                    requirements = value.try_convert("output.requirements")?;
+                }
+                "tests" => {
+                    tests = value.try_convert("output.tests")?;
+                }
+                "about" => {
+                    about = Some(value.try_convert("output.about")?);
+                }
+                _ => {
+                    return Err(vec![_partialerror!(
+                        *key.span(),
+                        ErrorKind::InvalidField(key.as_str().to_string().into())
+                    )]);
+                }
+            }
+        }
+
+        let package = package.ok_or_else(|| {
+            vec![_partialerror!(
+                *self.span(),
+                ErrorKind::MissingField("package".to_string().into()),
+                help = "outputs must have a 'package' field"
+            )]
+        })?;
+
+        Ok(OutputWithInherit {
+            package,
+            inherit,
+            source,
+            build,
+            requirements,
+            tests,
+            about,
+        })
+    }
+}
+
+impl OutputWithInherit {
+    /// Check if this output inherits from top-level
+    pub fn inherits_from_toplevel(&self) -> bool {
+        self.inherit.is_none()
+    }
+
+    /// Apply inheritance from a cache output
+    pub fn apply_cache_inheritance(&mut self, cache: &super::cache_output::CacheOutput) {
+        let script_backup = self.build.script.clone();
+        self.build.script = script_backup;
+
+        if let Some(inherit_spec) = &self.inherit {
+            if inherit_spec.inherit_run_exports() {
+                if let Some(cache_ignore) = &cache.ignore_run_exports {
+                    self.requirements.ignore_run_exports =
+                        self.requirements.ignore_run_exports(Some(cache_ignore));
+                }
+            }
+        }
+    }
+}
diff --git a/src/recipe/parser/parsing_utils.rs b/src/recipe/parser/parsing_utils.rs
new file mode 100644
index 000000000..aa4c5ff93
--- /dev/null
+++ b/src/recipe/parser/parsing_utils.rs
@@ -0,0 +1,200 @@
+//! Common parsing utilities to reduce code duplication in output parsing
+//!
+//! This module provides shared functionality for parsing YAML nodes into
+//! strongly-typed structures, reducing duplication across cache_output.rs,
+//! output_with_inherit.rs, and other parsing modules.
+
+use crate::{
+    _partialerror,
+    recipe::{
+        custom_yaml::{HasSpan, RenderedMappingNode, RenderedNode, TryConvertNode},
+        error::{ErrorKind, PartialParsingError},
+    },
+};
+
+/// A trait for types that can be parsed from a RenderedNode using a standard pattern
+pub trait StandardTryConvert: Sized {
+    /// The name to use in error messages (e.g., "CacheOutput", "OutputWithInherit")
+    const TYPE_NAME: &'static str;
+
+    /// Convert from a RenderedMappingNode
+    fn from_mapping(
+        mapping: &RenderedMappingNode,
+        name: &str,
+    ) -> Result<Self, Vec<PartialParsingError>>;
+}
+
+/// Generic implementation for converting RenderedNode to any type that implements StandardTryConvert
+impl<T: StandardTryConvert> TryConvertNode<T> for RenderedNode {
+    fn try_convert(&self, name: &str) -> Result<T, Vec<PartialParsingError>> {
+        self.as_mapping()
+            .ok_or_else(|| vec![_partialerror!(*self.span(), ErrorKind::ExpectedMapping)])
+            .and_then(|m| T::from_mapping(m, name))
+    }
+}
+
+/// Helper to parse a required string field
+pub fn parse_required_string(
+    value: &RenderedNode,
+    field_name: &str,
+    context: &str,
+) -> Result<String, Vec<PartialParsingError>> {
+    Ok(value
+        .as_scalar()
+        .ok_or_else(|| {
+            vec![_partialerror!(
+                *value.span(),
+                ErrorKind::ExpectedScalar,
+                help = format!("expected a string for {} in {}", field_name, context)
+            )]
+        })?
+        .as_str()
+        .to_string())
+}
+
+/// Helper to parse an optional string field
+pub fn parse_optional_string(
+    value: &RenderedNode,
+    field_name: &str,
+    context: &str,
+) -> Result<Option<String>, Vec<PartialParsingError>> {
+    Ok(Some(parse_required_string(value, field_name, context)?))
+}
+
+/// Helper to parse a boolean field
+pub fn parse_bool(
+    value: &RenderedNode,
+    field_name: &str,
+    context: &str,
+) -> Result<bool, Vec<PartialParsingError>> {
+    let scalar = value.as_scalar().ok_or_else(|| {
+        vec![_partialerror!(
+            *value.span(),
+            ErrorKind::ExpectedScalar,
+            help = format!("expected a boolean for {} in {}", field_name, context)
+        )]
+    })?;
+
+    scalar.as_bool().ok_or_else(|| {
+        vec![_partialerror!(
+            *value.span(),
+            ErrorKind::ExpectedScalar,
+            help = format!("expected a boolean for {} in {}", field_name, context)
+        )]
+    })
+}
+
+/// Helper to create a missing field error
+pub fn missing_field_error(
+    span: marked_yaml::Span,
+    field_name: &str,
+    type_name: &str,
+) -> PartialParsingError {
+    _partialerror!(
+        span,
+        ErrorKind::MissingField(field_name.to_string().into()),
+        help = format!("{} must have a '{}' field", type_name, field_name)
+    )
+}
+
+/// Helper to create an invalid field error
+pub fn invalid_field_error(
+    span: marked_yaml::Span,
+    field_name: &str,
+    help_text: Option<&str>,
+) -> PartialParsingError {
+    if let Some(help) = help_text {
+        let help_string = help.to_string();
+        _partialerror!(
+            span,
+            ErrorKind::InvalidField(field_name.to_string().into()),
+            help = help_string
+        )
+    } else {
+        _partialerror!(span, ErrorKind::InvalidField(field_name.to_string().into()))
+    }
+}
+
+/// Helper to validate that a mapping only contains allowed keys
+pub fn validate_mapping_keys(
+    mapping: &RenderedMappingNode,
+    allowed_keys: &[&str],
+    context: &str,
+) -> Result<(), Vec<PartialParsingError>> {
+    let mut errors = Vec::new();
+
+    for (key, _) in mapping.iter() {
+        if !allowed_keys.contains(&key.as_str()) {
+            errors.push(invalid_field_error(
+                *key.span(),
+                key.as_str(),
+                Some(&format!(
+                    "allowed keys in {} are: {}",
+                    context,
+                    allowed_keys.join(", ")
+                )),
+            ));
+        }
+    }
+
+    if errors.is_empty() {
+        Ok(())
+    } else {
+        Err(errors)
+    }
+}
+
+/// Macro to generate standard field parsing match arms
+#[macro_export]
+macro_rules! parse_field {
+    // Required field with custom parser
+    ($field:ident, $value:expr, $parser:expr, $context:expr) => {
+        $field = Some($parser($value, $context)?);
+    };
+
+    // Optional field with custom parser
+    (optional $field:ident, $value:expr, $parser:expr, $context:expr) => {
+        $field = $parser($value, $context)?;
+    };
+
+    // Direct try_convert
+    ($field:ident, $value:expr, $context:expr) => {
+        $field = Some($value.try_convert($context)?);
+    };
+
+    // Optional direct try_convert
+    (optional $field:ident, $value:expr, $context:expr) => {
+        $field = $value.try_convert($context)?;
+    };
+}
+
+/// Helper for validating multi-output recipe root keys
+pub fn validate_multi_output_root_keys(
+    root_map: &RenderedMappingNode,
+) -> Result<(), PartialParsingError> {
+    if root_map.contains_key("package") {
+        let key = root_map
+            .keys()
+            .find(|k| k.as_str() == "package")
+            .expect("key exists");
+        return Err(_partialerror!(
+            *key.span(),
+            ErrorKind::InvalidField("package".to_string().into()),
+            help = "recipe cannot have both `outputs` and `package` fields. Rename `package` to `recipe` or remove `outputs`"
+        ));
+    }
+
+    if root_map.contains_key("requirements") {
+        let key = root_map
+            .keys()
+            .find(|k| k.as_str() == "requirements")
+            .expect("key exists");
+        return Err(_partialerror!(
+            *key.span(),
+            ErrorKind::InvalidField("requirements".to_string().into()),
+            help = "multi-output recipes cannot have a top-level requirements field. Move `requirements` inside the individual output."
+        ));
+    }
+
+    Ok(())
+}

From a1d62b6cb4a756b7e8a6f8617fea5b1f8e05186e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Sat, 14 Jun 2025 03:50:34 +0300
Subject: [PATCH 02/29] whitelines

---
 src/recipe/parser/cache_output.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/recipe/parser/cache_output.rs b/src/recipe/parser/cache_output.rs
index 3eee3c5b5..105b81981 100644
--- a/src/recipe/parser/cache_output.rs
+++ b/src/recipe/parser/cache_output.rs
@@ -26,7 +26,7 @@ pub struct CacheOutput {
     /// Sources for this cache output
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub source: Vec<Source>,
-    /// Build configuration for the cache  
+    /// Build configuration for the cache
     pub build: CacheBuild,
     /// Requirements for building the cache (only build and host allowed)
     pub requirements: CacheRequirements,

From af549e5d320f49f8b15558655a2d8a2e2fae200b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Mon, 16 Jun 2025 16:10:32 +0300
Subject: [PATCH 03/29] whitelines

---
 src/recipe/parser.rs                          |  4 +--
 ...utput_with_inherit.rs => output_parser.rs} | 29 ++++++++++++-------
 src/recipe/parser/output_v2.rs                | 20 +++++++++----
 src/recipe/parser/parsing_utils.rs            |  4 +--
 4 files changed, 37 insertions(+), 20 deletions(-)
 rename src/recipe/parser/{output_with_inherit.rs => output_parser.rs} (86%)

diff --git a/src/recipe/parser.rs b/src/recipe/parser.rs
index a10ae4e41..8849c4a7f 100644
--- a/src/recipe/parser.rs
+++ b/src/recipe/parser.rs
@@ -27,8 +27,8 @@ mod common_output;
 mod glob_vec;
 mod helper;
 mod output;
+mod output_parser;
 mod output_v2;
-mod output_with_inherit;
 mod package;
 mod parsing_utils;
 mod regex;
@@ -46,8 +46,8 @@ pub use self::{
     common_output::{ALLOWED_KEYS_MULTI_OUTPUTS, DEEP_MERGE_KEYS, InheritSpec},
     glob_vec::{GlobCheckerVec, GlobVec, GlobWithSource},
     output::find_outputs_from_src,
+    output_parser::{Output, OutputType},
     output_v2::{find_outputs_v2, resolve_inheritance},
-    output_with_inherit::{OutputType, OutputWithInherit},
     package::{OutputPackage, Package},
     parsing_utils::{
         StandardTryConvert, invalid_field_error, missing_field_error, parse_bool,
diff --git a/src/recipe/parser/output_with_inherit.rs b/src/recipe/parser/output_parser.rs
similarity index 86%
rename from src/recipe/parser/output_with_inherit.rs
rename to src/recipe/parser/output_parser.rs
index 87a0a69b8..922008b54 100644
--- a/src/recipe/parser/output_with_inherit.rs
+++ b/src/recipe/parser/output_parser.rs
@@ -9,12 +9,13 @@ use crate::{
 };
 use serde::{Deserialize, Serialize};
 
+use super::cache_output::CacheOutput;
 use super::common_output::InheritSpec;
 use super::{About, Build, OutputPackage, Requirements, Source, TestType};
 
 /// An output that can inherit from a cache
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct OutputWithInherit {
+pub struct Output {
     /// Package information for this output
     pub package: OutputPackage,
 
@@ -41,6 +42,10 @@ pub struct OutputWithInherit {
     /// About information
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub about: Option<About>,
+
+    /// List of caches that this output depends on (in the right order)
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub caches: Vec<CacheOutput>,
 }
 
 /// Represents the type of output in a multi-output recipe
@@ -48,9 +53,9 @@ pub struct OutputWithInherit {
 #[serde(untagged)]
 pub enum OutputType {
     /// A cache output that produces intermediate artifacts
-    Cache(Box<super::cache_output::CacheOutput>),
+    Cache(Box<CacheOutput>),
     /// A regular package output that may inherit from cache
-    Package(Box<OutputWithInherit>),
+    Package(Box<Output>),
 }
 
 impl TryConvertNode<OutputType> for RenderedNode {
@@ -83,16 +88,16 @@ impl TryConvertNode<OutputType> for RenderedNode {
     }
 }
 
-impl TryConvertNode<OutputWithInherit> for RenderedNode {
-    fn try_convert(&self, name: &str) -> Result<OutputWithInherit, Vec<PartialParsingError>> {
+impl TryConvertNode<Output> for RenderedNode {
+    fn try_convert(&self, name: &str) -> Result<Output, Vec<PartialParsingError>> {
         self.as_mapping()
             .ok_or_else(|| vec![_partialerror!(*self.span(), ErrorKind::ExpectedMapping)])
             .and_then(|m| m.try_convert(name))
     }
 }
 
-impl TryConvertNode<OutputWithInherit> for RenderedMappingNode {
-    fn try_convert(&self, _name: &str) -> Result<OutputWithInherit, Vec<PartialParsingError>> {
+impl TryConvertNode<Output> for RenderedMappingNode {
+    fn try_convert(&self, _name: &str) -> Result<Output, Vec<PartialParsingError>> {
         let mut package = None;
         let mut inherit = None;
         let mut source = Vec::new();
@@ -141,7 +146,7 @@ impl TryConvertNode<OutputWithInherit> for RenderedMappingNode {
             )]
         })?;
 
-        Ok(OutputWithInherit {
+        Ok(Output {
             package,
             inherit,
             source,
@@ -149,18 +154,19 @@ impl TryConvertNode<OutputWithInherit> for RenderedMappingNode {
             requirements,
             tests,
             about,
+            caches: Vec::new(), // Caches will be populated during inheritance resolution
         })
     }
 }
 
-impl OutputWithInherit {
+impl Output {
     /// Check if this output inherits from top-level
     pub fn inherits_from_toplevel(&self) -> bool {
         self.inherit.is_none()
     }
 
     /// Apply inheritance from a cache output
-    pub fn apply_cache_inheritance(&mut self, cache: &super::cache_output::CacheOutput) {
+    pub fn apply_cache_inheritance(&mut self, cache: &CacheOutput) {
         let script_backup = self.build.script.clone();
         self.build.script = script_backup;
 
@@ -172,5 +178,8 @@ impl OutputWithInherit {
                 }
             }
         }
+
+        // Add the cache to the list of dependencies
+        self.caches.push(cache.clone());
     }
 }
diff --git a/src/recipe/parser/output_v2.rs b/src/recipe/parser/output_v2.rs
index 970003bd2..f55d5cd56 100644
--- a/src/recipe/parser/output_v2.rs
+++ b/src/recipe/parser/output_v2.rs
@@ -16,7 +16,7 @@ use super::common_output::{
     merge_rendered_mapping_if_not_exists, parse_root_as_mapping_rendered,
     validate_outputs_sequence_rendered,
 };
-use super::output_with_inherit::{OutputType, OutputWithInherit};
+use super::output_parser::{Output, OutputType};
 
 /// Convert a vector of PartialParsingError to a single ParsingError
 fn convert_errors<S: SourceCode>(errors: Vec<PartialParsingError>, src: S) -> ParsingError<S> {
@@ -192,11 +192,8 @@ pub fn find_outputs_v2<S: SourceCode>(src: S) -> Result<Vec<OutputType>, Parsing
             }
 
             let processed_output_node = RenderedNode::from(processed_map);
-            let output_with_inherit: OutputWithInherit =
-                match TryConvertNode::<OutputWithInherit>::try_convert(
-                    &processed_output_node,
-                    "output",
-                ) {
+            let output_with_inherit: Output =
+                match TryConvertNode::<Output>::try_convert(&processed_output_node, "output") {
                     Ok(output) => output,
                     Err(err) => return Err(convert_errors(err, src.clone())),
                 };
@@ -324,6 +321,17 @@ outputs:
         assert!(matches!(&outputs[0], OutputType::Cache(_)));
         assert!(matches!(&outputs[1], OutputType::Package(_)));
         assert!(matches!(&outputs[2], OutputType::Package(_)));
+
+        // Check that packages have the cache in their caches list (inheritance is already resolved in find_outputs_v2)
+        if let OutputType::Package(pkg) = &outputs[1] {
+            assert_eq!(pkg.caches.len(), 1);
+            assert_eq!(pkg.caches[0].name, "foo-cache");
+        }
+
+        if let OutputType::Package(pkg) = &outputs[2] {
+            assert_eq!(pkg.caches.len(), 1);
+            assert_eq!(pkg.caches[0].name, "foo-cache");
+        }
     }
 
     #[test]
diff --git a/src/recipe/parser/parsing_utils.rs b/src/recipe/parser/parsing_utils.rs
index aa4c5ff93..c9aa0239e 100644
--- a/src/recipe/parser/parsing_utils.rs
+++ b/src/recipe/parser/parsing_utils.rs
@@ -2,7 +2,7 @@
 //!
 //! This module provides shared functionality for parsing YAML nodes into
 //! strongly-typed structures, reducing duplication across cache_output.rs,
-//! output_with_inherit.rs, and other parsing modules.
+//! output_parser.rs, and other parsing modules.
 
 use crate::{
     _partialerror,
@@ -14,7 +14,7 @@ use crate::{
 
 /// A trait for types that can be parsed from a RenderedNode using a standard pattern
 pub trait StandardTryConvert: Sized {
-    /// The name to use in error messages (e.g., "CacheOutput", "OutputWithInherit")
+    /// The name to use in error messages (e.g., "CacheOutput", "Output")
     const TYPE_NAME: &'static str;
 
     /// Convert from a RenderedMappingNode

From 1257b9a738b632be497e3a851e0d9e9aa7fbb5e8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Wed, 1 Oct 2025 02:54:18 +0300
Subject: [PATCH 04/29] cleanup

---
 src/recipe/parser.rs               | 2 +-
 src/recipe/parser/output_parser.rs | 3 ---
 src/recipe/parser/output_v2.rs     | 5 ++++-
 src/recipe/parser/parsing_utils.rs | 9 ---------
 4 files changed, 5 insertions(+), 14 deletions(-)

diff --git a/src/recipe/parser.rs b/src/recipe/parser.rs
index 8849c4a7f..db60d680d 100644
--- a/src/recipe/parser.rs
+++ b/src/recipe/parser.rs
@@ -51,7 +51,7 @@ pub use self::{
     package::{OutputPackage, Package},
     parsing_utils::{
         StandardTryConvert, invalid_field_error, missing_field_error, parse_bool,
-        parse_optional_string, parse_required_string, validate_mapping_keys,
+        parse_required_string, validate_mapping_keys,
         validate_multi_output_root_keys,
     },
     regex::SerializableRegex,
diff --git a/src/recipe/parser/output_parser.rs b/src/recipe/parser/output_parser.rs
index 922008b54..d3cb39e9f 100644
--- a/src/recipe/parser/output_parser.rs
+++ b/src/recipe/parser/output_parser.rs
@@ -167,9 +167,6 @@ impl Output {
 
     /// Apply inheritance from a cache output
     pub fn apply_cache_inheritance(&mut self, cache: &CacheOutput) {
-        let script_backup = self.build.script.clone();
-        self.build.script = script_backup;
-
         if let Some(inherit_spec) = &self.inherit {
             if inherit_spec.inherit_run_exports() {
                 if let Some(cache_ignore) = &cache.ignore_run_exports {
diff --git a/src/recipe/parser/output_v2.rs b/src/recipe/parser/output_v2.rs
index f55d5cd56..dd89bf29d 100644
--- a/src/recipe/parser/output_v2.rs
+++ b/src/recipe/parser/output_v2.rs
@@ -24,7 +24,10 @@ fn convert_errors<S: SourceCode>(errors: Vec<PartialParsingError>, src: S) -> Pa
         .into_iter()
         .map(|e| ParsingError::from_partial(src.clone(), e))
         .collect::<Vec<_>>();
-    converted_errors.into_iter().next().unwrap()
+    converted_errors
+        .into_iter()
+        .next()
+        .expect("convert_errors requires at least one PartialParsingError")
 }
 
 /// Validates root keys for multi-output recipes (RenderedMappingNode version)
diff --git a/src/recipe/parser/parsing_utils.rs b/src/recipe/parser/parsing_utils.rs
index c9aa0239e..8518c9335 100644
--- a/src/recipe/parser/parsing_utils.rs
+++ b/src/recipe/parser/parsing_utils.rs
@@ -52,15 +52,6 @@ pub fn parse_required_string(
         .to_string())
 }
 
-/// Helper to parse an optional string field
-pub fn parse_optional_string(
-    value: &RenderedNode,
-    field_name: &str,
-    context: &str,
-) -> Result<Option<String>, Vec<PartialParsingError>> {
-    Ok(Some(parse_required_string(value, field_name, context)?))
-}
-
 /// Helper to parse a boolean field
 pub fn parse_bool(
     value: &RenderedNode,

From a5a6579f54f4ac6e2d9e75e0f7fe9db63ff9aee4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Wed, 1 Oct 2025 08:50:41 +0300
Subject: [PATCH 05/29] cleanup: remove collecting error(s), we only need one

---
 src/recipe/parser/output_v2.rs | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/recipe/parser/output_v2.rs b/src/recipe/parser/output_v2.rs
index dd89bf29d..fd7288ff5 100644
--- a/src/recipe/parser/output_v2.rs
+++ b/src/recipe/parser/output_v2.rs
@@ -20,14 +20,11 @@ use super::output_parser::{Output, OutputType};
 
 /// Convert a vector of PartialParsingError to a single ParsingError
 fn convert_errors<S: SourceCode>(errors: Vec<PartialParsingError>, src: S) -> ParsingError<S> {
-    let converted_errors = errors
+    errors
         .into_iter()
         .map(|e| ParsingError::from_partial(src.clone(), e))
-        .collect::<Vec<_>>();
-    converted_errors
-        .into_iter()
         .next()
-        .expect("convert_errors requires at least one PartialParsingError")
+        .expect("convert_errors called with empty vector")
 }
 
 /// Validates root keys for multi-output recipes (RenderedMappingNode version)

From 260b818cf89d0f52b7c1a34fb9bc631bc8a594cb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Mon, 13 Oct 2025 05:56:57 +0300
Subject: [PATCH 06/29] will need more polishing and tests

---
 src/build.rs                        |  71 ++++-
 src/cache.rs                        | 413 +++++++++++++++++++++++-
 src/lib.rs                          |  58 +++-
 src/metadata.rs                     |  11 +
 src/recipe/jinja.rs                 |   5 +-
 src/recipe/parser.rs                |  72 ++++-
 src/recipe/parser/about.rs          |  26 ++
 src/recipe/parser/build.rs          |  43 +++
 src/recipe/parser/cache.rs          |  10 +
 src/recipe/parser/cache_output.rs   | 280 +++++-----------
 src/recipe/parser/common_output.rs  |  64 +---
 src/recipe/parser/output.rs         | 473 +++++++++++++++++++++++++++-
 src/recipe/parser/output_v2.rs      | 428 -------------------------
 src/recipe/parser/requirements.rs   |  11 +
 src/render/resolved_dependencies.rs |  57 ++--
 src/source/copy_dir.rs              |  22 +-
 src/source/mod.rs                   |  21 ++
 src/variant_config.rs               |  35 +-
 src/variant_render.rs               |  33 +-
 19 files changed, 1352 insertions(+), 781 deletions(-)
 delete mode 100644 src/recipe/parser/output_v2.rs

diff --git a/src/build.rs b/src/build.rs
index 100caac77..a7c9867d9 100644
--- a/src/build.rs
+++ b/src/build.rs
@@ -112,8 +112,38 @@ pub async fn run_build(
 
     let directories = output.build_configuration.directories.clone();
 
+    // Handle cache outputs first
     let output = if output.recipe.cache.is_some() {
-        output.build_or_fetch_cache(tool_configuration).await?
+        let output = output.build_or_fetch_cache(tool_configuration).await?;
+        
+        // Warn if output defines additional sources on top of cache
+        if !output.recipe.sources().is_empty() && output.finalized_cache_sources.is_some() {
+            tracing::warn!(
+                "Output defines sources in addition to cache sources. \
+                 This may overwrite files from the cache. \
+                 Consider using 'target_directory' in source definitions to avoid conflicts."
+            );
+        }
+        output
+    } else if !output.cache_outputs_to_build.is_empty() {
+        // Cache outputs from outputs array
+        let mut current_output = output;
+        let cache_outputs = current_output.cache_outputs_to_build.clone();
+        for cache_output in &cache_outputs {
+            current_output = current_output
+                .build_or_fetch_cache_output(cache_output, tool_configuration)
+                .await?;
+        }
+        
+        // Warn if output defines additional sources on top of cache
+        if !current_output.recipe.sources().is_empty() && current_output.finalized_cache_sources.is_some() {
+            tracing::warn!(
+                "Output defines sources in addition to cache sources. \
+                 This may overwrite files from the cache. \
+                 Consider using 'target_directory' in source definitions to avoid conflicts."
+            );
+        }
+        current_output
     } else {
         output
             .fetch_sources(tool_configuration)
@@ -126,22 +156,33 @@ pub async fn run_build(
         .await
         .into_diagnostic()?;
 
-    output
-        .install_environments(tool_configuration)
-        .await
-        .into_diagnostic()?;
+    // Fast-path: If this output used a cache (inherit) and has no explicit build script,
+    // skip environment installation and script execution. We only distribute files based on build.files.
+    let use_fast_path = output.finalized_cache_dependencies.is_some()
+        && output.recipe.build().script().is_default();
 
-    match output.run_build_script().await {
-        Ok(_) => {}
-        Err(InterpreterError::Debug(info)) => {
-            tracing::info!("{}", info);
-            return Err(miette::miette!(
-                "Script not executed because debug mode is enabled"
-            ));
-        }
-        Err(InterpreterError::ExecutionFailed(_)) => {
-            return Err(miette::miette!("Script failed to execute"));
+    if !use_fast_path {
+        output
+            .install_environments(tool_configuration)
+            .await
+            .into_diagnostic()?;
+
+        match output.run_build_script().await {
+            Ok(_) => {}
+            Err(InterpreterError::Debug(info)) => {
+                tracing::info!("{}", info);
+                return Err(miette::miette!(
+                    "Script not executed because debug mode is enabled"
+                ));
+            }
+            Err(InterpreterError::ExecutionFailed(_)) => {
+                return Err(miette::miette!("Script failed to execute"));
+            }
         }
+    } else {
+        tracing::info!(
+            "Using fast-path: inherited cache detected and no build.script specified; skipping env setup and script execution."
+        );
     }
 
     // Package all the new files
diff --git a/src/cache.rs b/src/cache.rs
index fb5165c84..d166198f2 100644
--- a/src/cache.rs
+++ b/src/cache.rs
@@ -59,9 +59,91 @@ pub struct Cache {
     /// The prefix that was used at build time (needs to be replaced when
     /// restoring the files)
     pub prefix: PathBuf,
+
+    /// The work_dir that was used at build time (used to rewrite restored files
+    /// if the absolute path changes between cache build and restore)
+    #[serde(default)]
+    pub work_dir: PathBuf,
+
+    /// The run exports declared by the cache at build time (rendered form is computed later)
+    #[serde(default)]
+    pub run_exports: crate::recipe::parser::RunExports,
+
+    /// Files (relative to prefix/work_dir) that contain the old prefix string and
+    /// should be rewritten when restoring to a different location.
+    #[serde(default)]
+    pub files_with_prefix: Vec<PathBuf>,
+
+    /// Files (relative to work_dir) that contain the old work_dir path and
+    /// should be rewritten when restoring to a different location.
+    #[serde(default)]
+    pub files_with_work_dir: Vec<PathBuf>,
+
+    /// Source files from the cache build (relative to work_dir)
+    /// Used to detect potential conflicts when outputs add additional sources
+    #[serde(default)]
+    pub source_files: Vec<PathBuf>,
 }
 
 impl Output {
+    /// Compute cache key for a specific cache output
+    pub fn cache_key_for(
+        &self,
+        cache_name: &str,
+        cache_reqs: &crate::recipe::parser::CacheRequirements,
+    ) -> Result<String, CacheKeyError> {
+        let mut requirement_names: HashSet<_> = cache_reqs
+            .build
+            .iter()
+            .chain(cache_reqs.host.iter())
+            .filter_map(|x| {
+                if let crate::recipe::parser::Dependency::Spec(spec) = x {
+                    if spec.version.is_none() && spec.build.is_none() {
+                        spec.name.as_ref().map(|n| n.as_normalized().to_string())
+                    } else {
+                        None
+                    }
+                } else {
+                    None
+                }
+            })
+            .collect();
+
+        // Also include explicit variant.use keys from the cache build (if any)
+        if let Some(cache) = &self.recipe.cache {
+            for key in cache.build.variant.use_keys.iter() {
+                requirement_names.insert(key.clone());
+            }
+        }
+
+        let mut selected_variant = BTreeMap::new();
+        for key in &requirement_names {
+            if let Some(value) = self.variant().get(&key.as_str().into()) {
+                selected_variant.insert(key.as_str(), value.clone());
+            }
+        }
+
+        selected_variant.insert(
+            "host_platform",
+            self.host_platform().platform.to_string().into(),
+        );
+        selected_variant.insert(
+            "build_platform",
+            self.build_configuration
+                .build_platform
+                .platform
+                .to_string()
+                .into(),
+        );
+
+        // Include cache name for uniqueness. Do NOT include absolute paths to keep
+        // the cache key stable across different build roots.
+        let rebuild_key = (cache_name, cache_reqs, selected_variant);
+        let mut hasher = Sha256::new();
+        rebuild_key.serialize(&mut serde_json::Serializer::new(&mut hasher))?;
+        Ok(format!("{:x}", hasher.finalize()))
+    }
+
     /// Compute a cache key that contains all the information that was used to
     /// build the cache, including the relevant variant information.
     pub fn cache_key(&self) -> Result<String, CacheKeyError> {
@@ -108,7 +190,9 @@ impl Output {
                     .into(),
             );
 
-            let cache_key = (cache, selected_variant, self.prefix());
+            // Do NOT include absolute paths to keep the cache key stable across
+            // different build roots.
+            let cache_key = (cache, selected_variant);
             // serialize to json and hash
             let mut hasher = Sha256::new();
             cache_key.serialize(&mut serde_json::Serializer::new(&mut hasher))?;
@@ -126,6 +210,13 @@ impl Output {
     ) -> Result<Output, miette::Error> {
         let cache_prefix_dir = cache_dir.join("prefix");
         let copied_prefix = CopyDir::new(&cache_prefix_dir, self.prefix())
+            .overwrite(true)
+            .on_overwrite(|path| {
+                tracing::warn!(
+                    "File {} restored from cache will be overwritten during output build",
+                    path.display()
+                );
+            })
             .run()
             .into_diagnostic()?;
 
@@ -135,25 +226,338 @@ impl Output {
             &cache_dir_work,
             &self.build_configuration.directories.work_dir,
         )
+        .overwrite(true)
+        .on_overwrite(|path| {
+            tracing::warn!(
+                "File {} restored from cache will be overwritten during output build",
+                path.display()
+            );
+        })
         .run()
         .into_diagnostic()?;
 
-        let combined_files = copied_prefix.copied_paths().len() + copied_cache.copied_paths().len();
+        // Track cached files for conflict detection.
+        let cached_prefix_files = copied_prefix.copied_paths_owned();
+        let cached_work_files = copied_cache.copied_paths_owned();
+
+        // If the output also specifies additional sources, proactively warn when
+        // extraction would clobber files restored from cache work_dir.
+        if !self.recipe.source.is_empty() {
+            for rel in &cached_work_files {
+                let target = self.build_configuration.directories.work_dir.join(rel);
+                if target.exists() {
+                    tracing::warn!(
+                        "Source extraction may overwrite restored cache work file: {}",
+                        target.display()
+                    );
+                    self.record_warning(&format!(
+                        "Source extraction may overwrite restored cache work file: {}",
+                        target.display()
+                    ));
+                }
+            }
+        }
+        let combined_files = cached_prefix_files.len() + cached_work_files.len();
         tracing::info!(
             "Restored {} source and prefix files from cache",
             combined_files
         );
 
+        // If the cache was built under a different prefix, rewrite occurrences of
+        // the old prefix in restored text files.
+        if cache.prefix != *self.prefix() {
+            let old = cache.prefix.to_string_lossy().to_string();
+            let new = self.prefix().to_string_lossy().to_string();
+            for rel in cache.files_with_prefix.iter() {
+                for base in [self.prefix(), &self.build_configuration.directories.work_dir] {
+                    let path = base.join(rel);
+                    if !path.exists() {
+                        continue;
+                    }
+                    if let Ok(contents) = fs::read_to_string(&path) {
+                        if contents.contains(&old) {
+                            let replaced = contents.replace(&old, &new);
+                            if let Err(e) = fs::write(&path, replaced) {
+                                tracing::warn!(
+                                    "Failed to rewrite restored file {}: {}",
+                                    path.display(),
+                                    e
+                                );
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // If the cache was built under a different work_dir, rewrite occurrences
+        // of the old work_dir path in restored text files located under the new work_dir.
+        if !cache.work_dir.as_os_str().is_empty()
+            && cache.work_dir != self.build_configuration.directories.work_dir
+        {
+            let old = cache.work_dir.to_string_lossy().to_string();
+            let new = self
+                .build_configuration
+                .directories
+                .work_dir
+                .to_string_lossy()
+                .to_string();
+            for rel in cache.files_with_work_dir.iter() {
+                let path = self.build_configuration.directories.work_dir.join(rel);
+                if !path.exists() {
+                    continue;
+                }
+                if let Ok(contents) = fs::read_to_string(&path) {
+                    if contents.contains(&old) {
+                        let replaced = contents.replace(&old, &new);
+                        if let Err(e) = fs::write(&path, replaced) {
+                            tracing::warn!(
+                                "Failed to rewrite restored work_dir file {}: {}",
+                                path.display(),
+                                e
+                            );
+                        }
+                    }
+                }
+            }
+        }
+
         Ok(Output {
             finalized_cache_dependencies: Some(cache.finalized_dependencies.clone()),
             finalized_cache_sources: Some(cache.finalized_sources.clone()),
+            // Also merge cache-declared run_exports into the recipe
+            recipe: {
+                let mut recipe = self.recipe.clone();
+                recipe.requirements.run_exports.extend_from(&cache.run_exports);
+                recipe
+            },
+            restored_cache_prefix_files: Some(cached_prefix_files),
+            restored_cache_work_dir_files: Some(cached_work_files.clone()),
             ..self.clone()
         })
     }
 
+    /// Build or fetch a specific cache output
+    pub async fn build_or_fetch_cache_output(
+        mut self,
+        cache_output: &crate::recipe::parser::CacheOutput,
+        tool_configuration: &crate::tool_configuration::Configuration,
+    ) -> Result<Self, miette::Error> {
+        let cache_name = &cache_output.name;
+        let cache_key = self
+            .cache_key_for(cache_name, &cache_output.requirements)
+            .into_diagnostic()?;
+
+        tracing::info!("Building cache: {} with key: {}", cache_name, cache_key);
+
+        let cache_dir = self
+            .build_configuration
+            .directories
+            .cache_dir
+            .join(format!("{}_{}", cache_name, cache_key));
+
+        // Check if cache exists
+        if cache_dir.exists() {
+            let cache_json = cache_dir.join("cache.json");
+            if let Ok(text) = fs::read_to_string(&cache_json) {
+                match serde_json::from_str::<Cache>(&text) {
+                    Ok(cache) => {
+                        tracing::info!("Restoring cache from {:?}", cache_dir);
+                        self = self
+                            .fetch_sources(tool_configuration)
+                            .await
+                            .into_diagnostic()?;
+                        return self.restore_cache(cache, cache_dir).await;
+                    }
+                    Err(e) => {
+                        tracing::warn!(
+                            "Failed to parse cache.json at {}: {} - rebuilding",
+                            cache_json.display(),
+                            e
+                        );
+                        fs::remove_dir_all(&cache_dir).into_diagnostic()?;
+                    }
+                }
+            }
+        }
+
+        // Build the cache
+        let rendered_sources = fetch_sources(
+            &cache_output.source,
+            &self.build_configuration.directories,
+            &self.system_tools,
+            tool_configuration,
+        )
+        .await
+        .into_diagnostic()?;
+
+        let target_platform = self.build_configuration.target_platform;
+        let mut env_vars = env_vars::vars(&self, "BUILD");
+        env_vars.extend(env_vars::os_vars(self.prefix(), &target_platform));
+
+        let channels = build_reindexed_channels(&self.build_configuration, tool_configuration)
+            .await
+            .into_diagnostic()?;
+
+        // Convert CacheRequirements to Requirements
+        let requirements = crate::recipe::parser::Requirements {
+            build: cache_output.requirements.build.clone(),
+            host: cache_output.requirements.host.clone(),
+            run: Vec::new(),
+            run_constraints: Vec::new(),
+            run_exports: crate::recipe::parser::RunExports::default(),
+            ignore_run_exports: cache_output.ignore_run_exports.clone().unwrap_or_default(),
+        };
+
+        let finalized_dependencies =
+            resolve_dependencies(&requirements, &self, &channels, tool_configuration)
+                .await
+                .unwrap();
+
+        install_environments(&self, &finalized_dependencies, tool_configuration)
+            .await
+            .into_diagnostic()?;
+
+        let selector_config = self.build_configuration.selector_config();
+        let mut jinja = Jinja::new(selector_config);
+        for (k, v) in self.recipe.context.iter() {
+            jinja.context_mut().insert(k.clone(), v.clone().into());
+        }
+
+        let build_prefix = if cache_output.build.script.is_some() {
+            Some(&self.build_configuration.directories.build_prefix)
+        } else {
+            None
+        };
+
+        if let Some(script) = &cache_output.build.script {
+            script
+                .run_script(
+                    env_vars,
+                    &self.build_configuration.directories.work_dir,
+                    &self.build_configuration.directories.recipe_dir,
+                    &self.build_configuration.directories.host_prefix,
+                    build_prefix,
+                    Some(jinja),
+                    None,
+                    self.build_configuration.debug,
+                )
+                .await
+                .into_diagnostic()?;
+        }
+
+        // Collect new files and save cache
+        let new_files = Files::from_prefix(
+            self.prefix(),
+            cache_output.build.always_include_files(),
+            cache_output.build.files(),
+        )
+        .into_diagnostic()?;
+
+        fs::create_dir_all(&cache_dir).into_diagnostic()?;
+        let prefix_cache_dir = cache_dir.join("prefix");
+        fs::create_dir_all(&prefix_cache_dir).into_diagnostic()?;
+
+        let mut copied_files = Vec::new();
+        let copy_options = CopyOptions::default();
+        let mut creation_cache = HashSet::new();
+
+        // Track files that contain the old prefix for later path rewriting
+        let mut files_with_prefix: Vec<PathBuf> = Vec::new();
+        let old_prefix_str = self.prefix().to_string_lossy().to_string();
+
+        for file in &new_files.new_files {
+            if file.is_dir() && !file.is_symlink() {
+                continue;
+            }
+            let stripped = file.strip_prefix(self.prefix()).unwrap();
+            let dest = prefix_cache_dir.join(stripped);
+            copy_file(file, &dest, &mut creation_cache, &copy_options).into_diagnostic()?;
+            copied_files.push(stripped.to_path_buf());
+            if let Ok(contents) = fs::read_to_string(file) {
+                if contents.contains(&old_prefix_str) {
+                    files_with_prefix.push(stripped.to_path_buf());
+                }
+            }
+        }
+
+        let work_dir_files = CopyDir::new(
+            &self.build_configuration.directories.work_dir,
+            &cache_dir.join("work_dir"),
+        )
+        .run()
+        .into_diagnostic()?;
+
+        let cache = Cache {
+            requirements: requirements.clone(),
+            finalized_dependencies: finalized_dependencies.clone(),
+            finalized_sources: rendered_sources.clone(),
+            prefix_files: copied_files,
+            work_dir_files: work_dir_files.copied_paths().to_vec(),
+            prefix: self.prefix().to_path_buf(),
+            work_dir: self.build_configuration.directories.work_dir.clone(),
+            run_exports: cache_output.run_exports.clone(),
+            files_with_prefix,
+            files_with_work_dir: {
+                let mut files = Vec::new();
+                let old_work_dir_str = self
+                    .build_configuration
+                    .directories
+                    .work_dir
+                    .to_string_lossy()
+                    .to_string();
+                for rel in work_dir_files.copied_paths() {
+                    let abs = self.build_configuration.directories.work_dir.join(rel);
+                    if abs.is_dir() {
+                        continue;
+                    }
+                    if let Ok(contents) = fs::read_to_string(&abs) {
+                        if contents.contains(&old_work_dir_str) {
+                            files.push(rel.to_path_buf());
+                        }
+                    }
+                }
+                files
+            },
+            source_files: work_dir_files.copied_paths().to_vec(),
+        };
+
+        fs::write(
+            cache_dir.join("cache.json"),
+            serde_json::to_string(&cache).unwrap(),
+        )
+        .into_diagnostic()?;
+
+        fs::remove_dir_all(self.prefix()).into_diagnostic()?;
+        CopyDir::new(&prefix_cache_dir, self.prefix())
+            .run()
+            .into_diagnostic()?;
+
+        Ok(Output {
+            finalized_cache_dependencies: Some(finalized_dependencies),
+            finalized_cache_sources: Some(rendered_sources),
+            ..self
+        })
+    }
+
     /// This will fetch sources and build the cache if it doesn't exist
     /// Note: this modifies the output in place
     pub(crate) async fn build_or_fetch_cache(
+        self,
+        tool_configuration: &crate::tool_configuration::Configuration,
+    ) -> Result<Self, miette::Error> {
+        if let Some(synthetic_cache) = self.recipe.synthetic_cache_output() {
+            // Convert to synthetic cache output
+            self.build_or_fetch_cache_output(&synthetic_cache, tool_configuration)
+                .await
+        } else {
+            Ok(self)
+        }
+    }
+
+    /// Didn't remove this one completely just in case.
+    #[allow(dead_code)]
+    async fn build_or_fetch_cache_legacy(
         mut self,
         tool_configuration: &crate::tool_configuration::Configuration,
     ) -> Result<Self, miette::Error> {
@@ -301,6 +705,11 @@ impl Output {
                 prefix_files: copied_files,
                 work_dir_files: work_dir_files.copied_paths().to_vec(),
                 prefix: self.prefix().to_path_buf(),
+                work_dir: self.build_configuration.directories.work_dir.clone(),
+                run_exports: crate::recipe::parser::RunExports::default(),
+                files_with_prefix: Vec::new(),
+                files_with_work_dir: Vec::new(),
+                source_files: work_dir_files.copied_paths().to_vec(),
             };
 
             let cache_file = cache_dir.join("cache.json");
diff --git a/src/lib.rs b/src/lib.rs
index e7248d27b..527606b3e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -72,7 +72,7 @@ use rattler_conda_types::{
 use rattler_package_streaming::write::CompressionLevel;
 use rattler_solve::SolveStrategy;
 use rattler_virtual_packages::{VirtualPackage, VirtualPackageOverrides};
-use recipe::parser::{Dependency, TestType, find_outputs_from_src};
+use recipe::parser::{Dependency, Recipe, TestType, find_outputs_from_src};
 use selectors::SelectorConfig;
 use source_code::Source;
 use system_tools::SystemTools;
@@ -220,7 +220,45 @@ pub async fn get_build_output(
 
     // First find all outputs from the recipe
     let named_source = Source::from_path(recipe_path).into_diagnostic()?;
-    let outputs = find_outputs_from_src(named_source.clone())?;
+    let mut outputs = find_outputs_from_src(named_source.clone())?;
+    let has_cache_or_inheritance = outputs.iter().any(|output| {
+        if let Some(mapping) = output.as_mapping() {
+            mapping.contains_key("cache")
+                || (mapping.contains_key("package")
+                    && mapping
+                        .get("package")
+                        .and_then(|p| p.as_mapping())
+                        .and_then(|pm| pm.get("inherit"))
+                        .is_some())
+        } else {
+            false
+        }
+    });
+
+    let mut global_cache_outputs = Vec::new();
+    let mut inheritance_relationships = std::collections::HashMap::new();
+
+    if has_cache_or_inheritance {
+        let has_toplevel_cache = outputs.iter().any(|output| {
+            if let Ok(recipe) = Recipe::from_node(output, SelectorConfig::default()) {
+                recipe.cache.is_some()
+            } else {
+                false
+            }
+        });
+
+        let jinja = recipe::Jinja::new(selector_config.clone());
+        let (resolved_outputs, cache_outputs, relationships) =
+            recipe::parser::output::resolve_cache_inheritance_with_caches(
+                outputs,
+                has_toplevel_cache,
+                selector_config.experimental,
+                &jinja,
+            )?;
+        outputs = resolved_outputs;
+        global_cache_outputs = cache_outputs;
+        inheritance_relationships = relationships;
+    }
 
     // Check if there is a `variants.yaml` or `conda_build_config.yaml` file next to
     // the recipe that we should potentially use.
@@ -255,8 +293,13 @@ pub async fn get_build_output(
 
     let variant_config = VariantConfig::from_files(&variant_configs, &selector_config)?;
 
-    let outputs_and_variants =
-        variant_config.find_variants(&outputs, named_source, &selector_config)?;
+    let outputs_and_variants = variant_config.find_variants(
+        &outputs,
+        named_source,
+        &selector_config,
+        &global_cache_outputs,
+        &inheritance_relationships,
+    )?;
 
     tracing::info!("Found {} variants\n", outputs_and_variants.len());
     for discovered_output in &outputs_and_variants {
@@ -398,6 +441,13 @@ pub async fn get_build_output(
             finalized_sources: None,
             finalized_cache_dependencies: None,
             finalized_cache_sources: None,
+            restored_cache_prefix_files: None,
+            restored_cache_work_dir_files: None,
+            cache_outputs_to_build: recipe.get_cache_outputs_for_package(
+                recipe.package.name.as_normalized(),
+                &global_cache_outputs,
+                &inheritance_relationships,
+            ),
             system_tools: SystemTools::new(),
             build_summary: Arc::new(Mutex::new(BuildSummary::default())),
             extra_meta: Some(
diff --git a/src/metadata.rs b/src/metadata.rs
index 2dc64b2b4..30ff8522f 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -459,6 +459,17 @@ pub struct Output {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub finalized_cache_sources: Option<Vec<Source>>,
 
+    /// Files restored from cache prefix
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub restored_cache_prefix_files: Option<Vec<std::path::PathBuf>>,
+    /// Files restored from cache work dir
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub restored_cache_work_dir_files: Option<Vec<std::path::PathBuf>>,
+
+    /// Cache outputs that need to be built before this package output
+    #[serde(skip_serializing_if = "Vec::is_empty", default)]
+    pub cache_outputs_to_build: Vec<crate::recipe::parser::CacheOutput>,
+
     /// Summary of the build
     #[serde(skip)]
     pub build_summary: Arc<Mutex<BuildSummary>>,
diff --git a/src/recipe/jinja.rs b/src/recipe/jinja.rs
index facef7a8a..9780b2534 100644
--- a/src/recipe/jinja.rs
+++ b/src/recipe/jinja.rs
@@ -9,7 +9,7 @@ use std::sync::Arc;
 use std::{collections::BTreeMap, str::FromStr};
 
 use minijinja::value::{Kwargs, Object, from_args};
-use minijinja::{Environment, Value};
+use minijinja::{AutoEscape, Environment, Value};
 use rattler_conda_types::{Arch, PackageName, ParseStrictness, Platform, Version, VersionSpec};
 
 use crate::normalized_key::NormalizedKey;
@@ -57,7 +57,8 @@ pub struct Jinja {
 impl Jinja {
     /// Create a new Jinja instance with the given selector configuration.
     pub fn new(config: SelectorConfig) -> Self {
-        let env = set_jinja(&config);
+        let mut env = set_jinja(&config);
+        env.set_auto_escape_callback(|_| AutoEscape::None);
         let context = config.into_context();
         Self { env, context }
     }
diff --git a/src/recipe/parser.rs b/src/recipe/parser.rs
index db60d680d..1e95ec1ee 100644
--- a/src/recipe/parser.rs
+++ b/src/recipe/parser.rs
@@ -26,9 +26,8 @@ mod cache_output;
 mod common_output;
 mod glob_vec;
 mod helper;
-mod output;
+pub mod output;
 mod output_parser;
-mod output_v2;
 mod package;
 mod parsing_utils;
 mod regex;
@@ -47,12 +46,10 @@ pub use self::{
     glob_vec::{GlobCheckerVec, GlobVec, GlobWithSource},
     output::find_outputs_from_src,
     output_parser::{Output, OutputType},
-    output_v2::{find_outputs_v2, resolve_inheritance},
     package::{OutputPackage, Package},
     parsing_utils::{
         StandardTryConvert, invalid_field_error, missing_field_error, parse_bool,
-        parse_required_string, validate_mapping_keys,
-        validate_multi_output_root_keys,
+        parse_required_string, validate_mapping_keys, validate_multi_output_root_keys,
     },
     regex::SerializableRegex,
     requirements::{
@@ -98,6 +95,12 @@ pub struct Recipe {
     /// Extra information as a map with string keys and any value
     #[serde(default, skip_serializing_if = "IndexMap::is_empty")]
     pub extra: IndexMap<String, serde_yaml::Value>,
+    /// Cache outputs discovered during inheritance resolution
+    #[serde(skip)]
+    pub cache_outputs: Vec<CacheOutput>,
+    /// Cache inheritance relationships (package name -> cache names)
+    #[serde(skip)]
+    pub cache_inheritance: std::collections::HashMap<String, Vec<String>>,
 }
 
 pub(crate) trait CollectErrors<K, V>: Iterator<Item = Result<K, V>> + Sized {
@@ -267,6 +270,8 @@ impl Recipe {
         let mut about = About::default();
         let mut cache = None;
         let mut extra = IndexMap::default();
+        let mut cache_outputs_result = Vec::new();
+        let mut cache_inheritance = std::collections::HashMap::new();
 
         rendered_node
             .iter()
@@ -330,7 +335,7 @@ impl Recipe {
             );
         }
 
-        let recipe = Recipe {
+        let mut recipe = Recipe {
             schema_version,
             context,
             package: package.ok_or_else(|| {
@@ -348,6 +353,8 @@ impl Recipe {
             tests,
             about,
             extra,
+            cache_outputs: cache_outputs_result,
+            cache_inheritance,
         };
 
         Ok(recipe)
@@ -382,6 +389,59 @@ impl Recipe {
     pub const fn about(&self) -> &About {
         &self.about
     }
+
+    /// Convert top-level cache to a synthetic CacheOutput
+    pub fn synthetic_cache_output(&self) -> Option<CacheOutput> {
+        self.cache.as_ref().map(|cache| CacheOutput {
+            name: format!("__recipe_{}_cache", self.package.name.as_normalized()),
+            source: cache.source.clone(),
+            build: CacheBuild {
+                script: Some(cache.build.script.clone()),
+                files: cache.build.files.clone(),
+                always_include_files: cache.build.always_include_files.clone(),
+            },
+            requirements: CacheRequirements {
+                build: cache.requirements.build.clone(),
+                host: cache.requirements.host.clone(),
+            },
+            run_exports: RunExports::default(),
+            ignore_run_exports: Some(cache.requirements.ignore_run_exports.clone()),
+            about: None,
+        })
+    }
+
+    /// Check if recipe uses legacy top-level cache format
+    pub fn has_toplevel_cache(&self) -> bool {
+        self.cache.is_some()
+    }
+
+    /// Extract cache outputs from resolved inheritance
+    /// This method looks at the resolved outputs and extracts cache outputs that this package depends on
+    pub fn extract_cache_outputs_from_inheritance(&self) -> Vec<CacheOutput> {
+        self.cache_outputs.clone()
+    }
+
+    /// Get cache outputs that this package depends on based on inheritance
+    /// This is called during Output creation to populate cache_outputs_to_build
+    pub fn get_cache_outputs_for_package(
+        &self,
+        package_name: &str,
+        all_cache_outputs: &[CacheOutput],
+        inheritance_relationships: &std::collections::HashMap<String, Vec<String>>,
+    ) -> Vec<CacheOutput> {
+        if let Some(cache_names) = inheritance_relationships.get(package_name) {
+            let mut result = Vec::new();
+            for cache_name in cache_names {
+                if let Some(cache_output) = all_cache_outputs.iter().find(|c| &c.name == cache_name)
+                {
+                    result.push(cache_output.clone());
+                }
+            }
+            result
+        } else {
+            Vec::new()
+        }
+    }
 }
 
 #[cfg(test)]
diff --git a/src/recipe/parser/about.rs b/src/recipe/parser/about.rs
index baa2dbfad..4869120e6 100644
--- a/src/recipe/parser/about.rs
+++ b/src/recipe/parser/about.rs
@@ -61,6 +61,32 @@ impl About {
     pub fn is_default(&self) -> bool {
         self == &Self::default()
     }
+
+    /// Deep merge another About into this one
+    /// Values in self take precedence over values in other
+    pub fn merge_from(&mut self, other: &About) {
+        macro_rules! merge_field {
+            ($field:ident) => {
+                if self.$field.is_none() && other.$field.is_some() {
+                    self.$field = other.$field.clone();
+                }
+            };
+        }
+
+        merge_field!(homepage);
+        merge_field!(repository);
+        merge_field!(documentation);
+        merge_field!(license);
+        merge_field!(license_family);
+        merge_field!(license_url);
+        merge_field!(summary);
+        merge_field!(description);
+        merge_field!(prelink_message);
+
+        if self.license_file.is_empty() && !other.license_file.is_empty() {
+            self.license_file = other.license_file.clone();
+        }
+    }
 }
 
 impl TryConvertNode<About> for RenderedNode {
diff --git a/src/recipe/parser/build.rs b/src/recipe/parser/build.rs
index 3b1749435..f90745cfb 100644
--- a/src/recipe/parser/build.rs
+++ b/src/recipe/parser/build.rs
@@ -82,6 +82,7 @@ pub struct Build {
     pub skip: Skip,
     /// The build script can be either a list of commands or a path to a script. By
     /// default, the build script is set to `build.sh` or `build.bat` on Unix and Windows respectively.
+    /// When using multi-output recipes, the default script is not automatically inferred; you must set it explicitly.
     #[serde(default, skip_serializing_if = "Script::is_default")]
     pub script: Script,
     /// A noarch package runs on any platform. It can be either a python package or a generic package.
@@ -207,6 +208,48 @@ pub struct PostProcess {
 }
 
 impl Build {
+    /// Deep merge another Build into this one
+    /// Values in self take precedence over values in other
+    pub fn merge_from(&mut self, other: &Build) {
+        if self.python.is_default() && !other.python.is_default() {
+            self.python = other.python.clone();
+        }
+
+        if self.dynamic_linking.is_default() && !other.dynamic_linking.is_default() {
+            self.dynamic_linking = other.dynamic_linking.clone();
+        }
+
+        if self.prefix_detection.is_default() && !other.prefix_detection.is_default() {
+            self.prefix_detection = other.prefix_detection.clone();
+        }
+
+        if self.variant.is_default() && !other.variant.is_default() {
+            self.variant = other.variant.clone();
+        }
+
+        if self.post_process.is_empty() && !other.post_process.is_empty() {
+            self.post_process = other.post_process.clone();
+        }
+
+        if !self.merge_build_and_host_envs && other.merge_build_and_host_envs {
+            self.merge_build_and_host_envs = other.merge_build_and_host_envs;
+        }
+
+        if self.noarch.is_none() && !other.noarch.is_none() {
+            self.noarch = other.noarch;
+        }
+
+        if self.files.is_empty() && !other.files.is_empty() {
+            self.files = other.files.clone();
+        }
+        if self.always_include_files.is_empty() && !other.always_include_files.is_empty() {
+            self.always_include_files = other.always_include_files.clone();
+        }
+        if self.always_copy_files.is_empty() && !other.always_copy_files.is_empty() {
+            self.always_copy_files = other.always_copy_files.clone();
+        }
+    }
+
     /// Get the merge build host flag.
     pub const fn merge_build_and_host_envs(&self) -> bool {
         self.merge_build_and_host_envs
diff --git a/src/recipe/parser/cache.rs b/src/recipe/parser/cache.rs
index 9b9eab929..ac41edc88 100644
--- a/src/recipe/parser/cache.rs
+++ b/src/recipe/parser/cache.rs
@@ -40,6 +40,16 @@ impl TryConvertNode<Cache> for RenderedMappingNode {
 
         validate_keys!(cache, self.iter(), source, build, requirements, outputs);
 
+        for (key, value) in self.iter() {
+            match key.as_str() {
+                "source" => cache.source = value.try_convert("cache.source")?,
+                "build" => cache.build = value.try_convert("cache.build")?,
+                "requirements" => cache.requirements = value.try_convert("cache.requirements")?,
+                "outputs" => cache.outputs = value.try_convert("cache.outputs")?,
+                _ => {}
+            }
+        }
+
         Ok(cache)
     }
 }
diff --git a/src/recipe/parser/cache_output.rs b/src/recipe/parser/cache_output.rs
index 105b81981..c42bcc7fc 100644
--- a/src/recipe/parser/cache_output.rs
+++ b/src/recipe/parser/cache_output.rs
@@ -17,6 +17,8 @@ use crate::{
 use serde::{Deserialize, Serialize};
 
 use super::{Script, Source};
+use super::requirements::RunExports;
+use super::glob_vec::GlobVec;
 
 /// A cache output that produces intermediate build artifacts
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -30,9 +32,18 @@ pub struct CacheOutput {
     pub build: CacheBuild,
     /// Requirements for building the cache (only build and host allowed)
     pub requirements: CacheRequirements,
+    /// Run exports declared by the cache; can be inherited by packages
+    #[serde(default, skip_serializing_if = "RunExports::is_empty")]
+    pub run_exports: RunExports,
     /// Run exports to ignore
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub ignore_run_exports: Option<super::requirements::IgnoreRunExports>,
+    /// About information that can be inherited by packages
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub about: Option<super::About>,
+    /// Span of the output mapping (for diagnostics)
+    #[serde(skip)]
+    pub span: marked_yaml::Span,
 }
 
 /// Build configuration specific to cache outputs
@@ -41,6 +52,24 @@ pub struct CacheBuild {
     /// The build script - only script key is allowed for cache outputs
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub script: Option<Script>,
+    /// Include files in the cache (glob patterns to select files)
+    #[serde(default, skip_serializing_if = "GlobVec::is_empty")]
+    pub files: GlobVec,
+    /// Files that are always included in the cache
+    #[serde(default, skip_serializing_if = "GlobVec::is_empty")]
+    pub always_include_files: GlobVec,
+}
+
+impl CacheBuild {
+    /// Get the files settings for this cache build
+    pub fn files(&self) -> &GlobVec {
+        &self.files
+    }
+
+    /// Get the always_include_files settings for this cache build
+    pub fn always_include_files(&self) -> &GlobVec {
+        &self.always_include_files
+    }
 }
 
 /// Requirements specific to cache outputs (no run or run_constraints allowed)
@@ -66,7 +95,11 @@ impl StandardTryConvert for CacheOutput {
         let mut source = Vec::new();
         let mut build = CacheBuild::default();
         let mut requirements = CacheRequirements::default();
+        let mut run_exports = RunExports::default();
         let mut ignore_run_exports = None;
+        let mut about = None;
+
+        let span = *mapping.span();
 
         for (key, value) in mapping.iter() {
             match key.as_str() {
@@ -93,15 +126,30 @@ impl StandardTryConvert for CacheOutput {
                 "requirements" => {
                     requirements = parse_cache_requirements(value)?;
                 }
+                "run_exports" => {
+                    run_exports = value.try_convert("cache.run_exports")?;
+                }
                 "ignore_run_exports" => {
                     ignore_run_exports = Some(value.try_convert("cache.ignore_run_exports")?);
                 }
+                "about" => {
+                    about = Some(value.try_convert("cache.about")?);
+                }
+                "inherit" => {
+                    return Err(vec![invalid_field_error(
+                        *key.span(),
+                        key.as_str(),
+                        Some(
+                            "cache outputs cannot use 'inherit' - caches must be built from scratch and cannot inherit from packages or other caches",
+                        ),
+                    )]);
+                }
                 _ => {
                     return Err(vec![invalid_field_error(
                         *key.span(),
                         key.as_str(),
                         Some(
-                            "valid fields for cache outputs are: 'cache', 'source', 'build', 'requirements', and 'ignore_run_exports'",
+                            "valid fields for cache outputs are: 'cache', 'source', 'build', 'requirements', 'run_exports', 'ignore_run_exports', and 'about'",
                         ),
                     )]);
                 }
@@ -116,17 +164,28 @@ impl StandardTryConvert for CacheOutput {
             )]
         })?;
 
+        if build.script.is_none() {
+            return Err(vec![missing_field_error(
+                *mapping.span(),
+                "build.script",
+                "cache outputs (cache outputs require an explicit build script)",
+            )]);
+        }
+
         Ok(CacheOutput {
             name,
             source,
             build,
             requirements,
+            run_exports,
             ignore_run_exports,
+            about,
+            span,
         })
     }
 }
 
-/// Parse cache build section, ensuring only 'script' is allowed
+/// Parse cache build section, ensuring only allowed keys are present
 fn parse_cache_build(value: &RenderedNode) -> Result<CacheBuild, Vec<PartialParsingError>> {
     let build_node = value
         .as_mapping()
@@ -137,14 +196,23 @@ fn parse_cache_build(value: &RenderedNode) -> Result<CacheBuild, Vec<PartialPars
     // Validate allowed keys
     validate_mapping_keys(
         build_node,
-        &["script"],
-        "cache build section (only 'script' is allowed)",
+        &["script", "files", "always_include_files"],
+        "cache build section (only 'script', 'files', and 'always_include_files' are allowed)",
     )?;
 
     if let Some(script_value) = build_node.get("script") {
         build.script = Some(script_value.try_convert("cache.build.script")?);
     }
 
+    if let Some(files_value) = build_node.get("files") {
+        build.files = files_value.try_convert("cache.build.files")?;
+    }
+
+    if let Some(always_include_value) = build_node.get("always_include_files") {
+        build.always_include_files =
+            always_include_value.try_convert("cache.build.always_include_files")?;
+    }
+
     Ok(build)
 }
 
@@ -203,207 +271,3 @@ impl TryConvertNode<CacheOutput> for crate::recipe::custom_yaml::RenderedScalarN
         )])
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use crate::recipe::parser::{OutputType, find_outputs_v2, resolve_inheritance};
-
-    #[test]
-    fn test_basic_cache_output() {
-        let yaml = r#"
-schema_version: 1
-
-outputs:
-  - cache:
-      name: foo-cache
-
-    source:
-      - url: https://foo.bar/source.tar.bz2
-        sha256: 0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef
-
-    requirements:
-      build:
-        - gcc
-        - cmake
-        - ninja
-      host:
-        - libzlib
-        - libfoo
-
-    build:
-      script: build_cache.sh
-
-  - package:
-      name: foo-headers
-
-    inherit:
-      from: foo-cache
-      run_exports: false
-
-    build:
-      files:
-        - include/
-
-  - package:
-      name: foo
-
-    inherit: foo-cache
-"#;
-
-        let outputs = find_outputs_v2(yaml).expect("Failed to parse outputs");
-        assert_eq!(outputs.len(), 3);
-
-        match &outputs[0] {
-            OutputType::Cache(cache) => {
-                assert_eq!(cache.name, "foo-cache");
-                assert_eq!(cache.source.len(), 1);
-                assert_eq!(cache.requirements.build.len(), 3);
-                assert_eq!(cache.requirements.host.len(), 2);
-            }
-            _ => panic!("Expected cache output"),
-        }
-
-        match &outputs[1] {
-            OutputType::Package(pkg) => {
-                assert_eq!(pkg.package.name().as_normalized(), "foo-headers");
-                assert!(pkg.inherit.is_some());
-                let inherit = pkg.inherit.as_ref().unwrap();
-                assert_eq!(inherit.cache_name(), "foo-cache");
-                assert!(!inherit.inherit_run_exports());
-            }
-            _ => panic!("Expected package output"),
-        }
-
-        match &outputs[2] {
-            OutputType::Package(pkg) => {
-                assert_eq!(pkg.package.name().as_normalized(), "foo");
-                assert!(pkg.inherit.is_some());
-                let inherit = pkg.inherit.as_ref().unwrap();
-                assert_eq!(inherit.cache_name(), "foo-cache");
-                assert!(inherit.inherit_run_exports());
-            }
-            _ => panic!("Expected package output"),
-        }
-    }
-
-    #[test]
-    fn test_file_patterns() {
-        let yaml = r#"
-outputs:
-  - cache:
-      name: build-cache
-
-    build:
-      script: |
-        mkdir -p include lib bin
-        touch include/foo.h lib/libfoo.so bin/foo
-
-  - package:
-      name: headers
-
-    inherit: build-cache
-
-    build:
-      files:
-        - include/**/*.h
-
-  - package:
-      name: libs
-
-    inherit: build-cache
-
-    build:
-      files:
-        include:
-          - lib/**/*.so
-        exclude:
-          - lib/**/*.a
-"#;
-
-        let outputs = find_outputs_v2(yaml).expect("Failed to parse outputs");
-        assert_eq!(outputs.len(), 3);
-        match &outputs[1] {
-            OutputType::Package(pkg) => {
-                // Files are in build.files, not pkg.files
-                assert!(!pkg.build.files.is_empty());
-            }
-            _ => panic!("Expected package output"),
-        }
-    }
-
-    #[test]
-    fn test_cache_without_run_requirements() {
-        // This should succeed - cache outputs cannot have run requirements
-        let yaml = r#"
-outputs:
-  - cache:
-      name: test-cache
-
-    requirements:
-      build:
-        - cmake
-      host:
-        - libfoo
-"#;
-
-        let outputs = find_outputs_v2(yaml).expect("Failed to parse outputs");
-        assert_eq!(outputs.len(), 1);
-    }
-
-    #[test]
-    fn test_cache_with_run_requirements_fails() {
-        // This should fail - cache outputs cannot have run requirements
-        let yaml = r#"
-outputs:
-  - cache:
-      name: test-cache
-
-    requirements:
-      run:
-        - python
-"#;
-
-        let result = find_outputs_v2(yaml);
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn test_inheritance_resolution() {
-        let yaml = r#"
-outputs:
-  - cache:
-      name: common-build
-
-    source:
-      - url: https://example.com/source.tar.gz
-        sha256: 0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef
-
-    build:
-      script: build.sh
-
-  - package:
-      name: pkg1
-
-    inherit: common-build
-
-  - package:
-      name: pkg2
-
-    inherit:
-      from: common-build
-      run_exports: false
-"#;
-
-        let mut outputs = find_outputs_v2(yaml).expect("Failed to parse outputs");
-        resolve_inheritance(&mut outputs).expect("Failed to resolve inheritance");
-
-        for output in outputs.iter().skip(1).take(2) {
-            match output {
-                OutputType::Package(pkg) => {
-                    assert!(pkg.inherit.is_some());
-                }
-                _ => panic!("Expected package output"),
-            }
-        }
-    }
-}
diff --git a/src/recipe/parser/common_output.rs b/src/recipe/parser/common_output.rs
index 3dd61b5f2..392bee85a 100644
--- a/src/recipe/parser/common_output.rs
+++ b/src/recipe/parser/common_output.rs
@@ -4,7 +4,7 @@ use crate::{
     _partialerror,
     recipe::{
         ParsingError,
-        custom_yaml::{HasSpan, RenderedMappingNode, RenderedNode, TryConvertNode},
+        custom_yaml::{HasSpan, RenderedNode, TryConvertNode},
         error::{ErrorKind, PartialParsingError},
     },
     source_code::SourceCode,
@@ -185,18 +185,6 @@ pub fn merge_mapping_if_not_exists(
     }
 }
 
-/// Merge items from source mapping into target mapping if keys don't already exist (RenderedMappingNode version)
-pub fn merge_rendered_mapping_if_not_exists(
-    target: &mut RenderedMappingNode,
-    source: &RenderedMappingNode,
-) {
-    for (k, v) in source.iter() {
-        if !target.contains_key(k.as_str()) {
-            target.insert(k.clone(), v.clone());
-        }
-    }
-}
-
 /// Validate recipe mapping and extract version
 /// This helper validates that the recipe mapping only contains 'name' and 'version' fields
 fn validate_and_extract_version<'a, S, K, V, I, F, G>(
@@ -250,53 +238,3 @@ pub fn extract_recipe_version_marked<S: SourceCode>(
 
     validate_and_extract_version(recipe_mapping.iter(), src, |k| k.as_str(), |k| *k.span())
 }
-
-/// Extract recipe version from the recipe mapping (RenderedNode version)
-pub fn extract_recipe_version_rendered<S: SourceCode>(
-    root_map: &RenderedMappingNode,
-    src: &S,
-) -> Result<Option<RenderedNode>, ParsingError<S>> {
-    let Some(recipe_node) = root_map.get("recipe") else {
-        return Ok(None);
-    };
-
-    let Some(recipe_mapping) = recipe_node.as_mapping() else {
-        return Ok(None);
-    };
-
-    validate_and_extract_version(recipe_mapping.iter(), src, |k| k.as_str(), |k| *k.span())
-}
-
-/// Validate that outputs is a sequence and return it (RenderedNode version)
-pub fn validate_outputs_sequence_rendered<'a, S: SourceCode>(
-    outputs: &'a RenderedNode,
-    src: &S,
-) -> Result<&'a crate::recipe::custom_yaml::RenderedSequenceNode, ParsingError<S>> {
-    outputs.as_sequence().ok_or_else(|| {
-        ParsingError::from_partial(
-            src.clone(),
-            _partialerror!(
-                *outputs.span(),
-                ErrorKind::ExpectedSequence,
-                help = "`outputs` must always be a sequence"
-            ),
-        )
-    })
-}
-
-/// Parse root node as mapping (RenderedNode version)
-pub fn parse_root_as_mapping_rendered<'a, S: SourceCode>(
-    root_node: &'a RenderedNode,
-    src: &S,
-) -> Result<&'a RenderedMappingNode, ParsingError<S>> {
-    root_node.as_mapping().ok_or_else(|| {
-        ParsingError::from_partial(
-            src.clone(),
-            _partialerror!(
-                *root_node.span(),
-                ErrorKind::ExpectedMapping,
-                help = "root node must always be a mapping"
-            ),
-        )
-    })
-}
diff --git a/src/recipe/parser/output.rs b/src/recipe/parser/output.rs
index 31bef66a2..80786bc40 100644
--- a/src/recipe/parser/output.rs
+++ b/src/recipe/parser/output.rs
@@ -9,8 +9,8 @@ use marked_yaml::types::MarkedMappingNode;
 use crate::{
     _partialerror,
     recipe::{
-        ParsingError,
-        custom_yaml::{Node, parse_yaml},
+        ParsingError, Render,
+        custom_yaml::{HasSpan, Node, RenderedNode, TryConvertNode, parse_yaml},
         error::{ErrorKind, PartialParsingError},
     },
     source_code::SourceCode,
@@ -21,6 +21,16 @@ use super::common_output::{
     merge_mapping_if_not_exists,
 };
 
+/// Result type for resolve_cache_inheritance_with_caches function
+type CacheInheritanceResult = Result<
+    (
+        Vec<Node>,
+        Vec<crate::recipe::parser::CacheOutput>,
+        std::collections::HashMap<String, Vec<String>>,
+    ),
+    ParsingError<&'static str>,
+>;
+
 // Check if the `cache` top-level key is present. If it does not contain a
 // source, but there is a top-level `source` key, then we should warn the user
 // because this key was moved to the `cache`
@@ -106,6 +116,39 @@ pub fn find_outputs_from_src<S: SourceCode>(src: S) -> Result<Vec<Node>, Parsing
                 ));
             }
         }
+
+        // Require explicit build scripts for multi-output recipes
+        if !root_map.contains_key("build") {
+            if let Some(outputs_value) = root_map.get("outputs") {
+                if let Some(outputs_seq) = outputs_value.as_sequence() {
+                    let missing_script = outputs_seq.iter().any(|output| {
+                        output
+                            .as_mapping()
+                            .and_then(|mapping| mapping.get("cache").or_else(|| mapping.get("package")))
+                            .map(|subnode| {
+                                subnode
+                                    .as_mapping()
+                                    .and_then(|mapping| mapping.get("build"))
+                                    .is_none()
+                            })
+                            .unwrap_or(true)
+                    });
+
+                    if missing_script {
+                        let key = outputs_value
+                            .span();
+                        return Err(ParsingError::from_partial(
+                            src,
+                            _partialerror!(
+                                *key,
+                                ErrorKind::MissingField("build.script".into()),
+                                help = "Multi-output recipes must specify `build.script` for each output; implicit build/script.sh is not supported"
+                            ),
+                        ));
+                    }
+                }
+            }
+        }
     }
 
     let Some(outputs) = root_map.get("outputs") else {
@@ -134,18 +177,7 @@ pub fn find_outputs_from_src<S: SourceCode>(src: S) -> Result<Vec<Node>, Parsing
     // sequence of outputs and if-selectors. We need to handle all of these
     // cases but for now, lets handle only sequence of outputs
     for output in outputs.iter() {
-        // 1. clone the root node
-        // 2. remove the `outputs` key
-        // 3. substitute repeated value (make sure to preserve the spans)
-        // 4. merge skip values (make sure to preserve the spans)
-        // Note: Make sure to preserve the spans of the original root span so the error
-        // messages remain accurate and point the correct part of the original recipe
-        // src
-        let mut root = root_map.clone();
-        root.remove("outputs");
-
         let mut output_node = output.clone();
-
         let Some(output_map) = output_node.as_mapping_mut() else {
             return Err(ParsingError::from_partial(
                 src,
@@ -157,6 +189,18 @@ pub fn find_outputs_from_src<S: SourceCode>(src: S) -> Result<Vec<Node>, Parsing
             ));
         };
 
+        // Check if this is a cache output
+        if output_map.contains_key("cache") {
+            // Parse as cache output - don't merge top-level fields into cache outputs
+            let cache_node = Node::try_from(output_node)
+                .map_err(|err| ParsingError::from_partial(src.clone(), err))?;
+            res.push(cache_node);
+            continue;
+        }
+
+        let mut root = root_map.clone();
+        root.remove("outputs");
+
         for (key, value) in root.iter() {
             if !output_map.contains_key(key) {
                 output_map.insert(key.clone(), value.clone());
@@ -189,6 +233,11 @@ pub fn find_outputs_from_src<S: SourceCode>(src: S) -> Result<Vec<Node>, Parsing
                         ));
                     };
 
+                    // Do not merge top-level build.script into outputs
+                    if key.as_str() == "build" {
+                        root_value_map.remove("script");
+                    }
+
                     merge_mapping_if_not_exists(output_value_map, root_value_map);
                 }
             }
@@ -213,6 +262,43 @@ pub fn find_outputs_from_src<S: SourceCode>(src: S) -> Result<Vec<Node>, Parsing
             }
         }
 
+        let inherit_spec = output_map
+            .get("package")
+            .and_then(|pkg_node| pkg_node.as_mapping())
+            .and_then(|pkg_map| pkg_map.get("inherit"));
+
+        match inherit_spec {
+            Some(inherit_node) if inherit_node.is_null() => {}
+            Some(_) => {
+            }
+            None => {
+                if let Some(req_node) = output_map.get("requirements") {
+                    return Err(ParsingError::from_partial(
+                        src.clone(),
+                        _partialerror!(
+                            *req_node.span(),
+                            ErrorKind::InvalidField("requirements".to_string().into()),
+                            help = "When inheriting from top-level, outputs must not define `requirements`."
+                        ),
+                    ));
+                }
+                if let Some(build_node) = output_map.get("build") {
+                    if let Some(build_map) = build_node.as_mapping() {
+                        if build_map.contains_key("script") {
+                            return Err(ParsingError::from_partial(
+                                src.clone(),
+                                _partialerror!(
+                                    *build_node.span(),
+                                    ErrorKind::InvalidField("build.script".to_string().into()),
+                                    help = "When inheriting from top-level, outputs must not define `build.script`."
+                                ),
+                            ));
+                        }
+                    }
+                }
+            }
+        }
+
         output_map.remove("recipe");
 
         let recipe = match Node::try_from(output_node) {
@@ -224,6 +310,367 @@ pub fn find_outputs_from_src<S: SourceCode>(src: S) -> Result<Vec<Node>, Parsing
     Ok(res)
 }
 
+/// Resolve cache inheritance relationships between package outputs and cache outputs
+///
+/// This function validates that cache inheritance references are valid.
+/// The actual inheritance resolution happens during recipe parsing.
+pub fn resolve_cache_inheritance(
+    outputs: Vec<Node>,
+    has_toplevel_cache: bool,
+) -> Result<Vec<Node>, ParsingError<&'static str>> {
+    use std::collections::HashSet;
+
+    // Collect cache names from outputs array
+    let mut cache_names = HashSet::new();
+    let mut duplicate_caches = Vec::new();
+
+    let mut cache_name_spans = std::collections::HashMap::new();
+
+    for output in outputs.iter() {
+        if let Some(cache_output) = parse_cache_output_from_node(output)? {
+            let cache_name = cache_output.name.clone();
+            if !cache_names.insert(cache_name.clone()) {
+                duplicate_caches.push(cache_name);
+            } else {
+                cache_name_spans.insert(cache_output.name.clone(), cache_output.span);
+            }
+        }
+    }
+
+    if !duplicate_caches.is_empty() {
+        return Err(ParsingError::from_partial(
+            "",
+            _partialerror!(
+                marked_yaml::Span::new_blank(),
+                ErrorKind::InvalidField(
+                    format!("duplicate cache names: {}", duplicate_caches.join(", ")).into()
+                ),
+                help = "Each cache output must have a unique name"
+            ),
+        ));
+    }
+
+    for output in outputs.iter() {
+        if let Some(mapping) = output.as_mapping() {
+            if mapping.contains_key("package") {
+                if let Some(package_node) = mapping.get("package") {
+                    if let Some(package_mapping) = package_node.as_mapping() {
+                        if let Some(inherit_node) = package_mapping.get("inherit") {
+                            let cache_name = if let Some(inherit_scalar) = inherit_node.as_scalar()
+                            {
+                                inherit_scalar.as_str().to_string()
+                            } else if let Some(inherit_mapping) = inherit_node.as_mapping() {
+                                if let Some(from_node) = inherit_mapping.get("from") {
+                                    if let Some(from_scalar) = from_node.as_scalar() {
+                                        from_scalar.as_str().to_string()
+                                    } else {
+                                        continue;
+                                    }
+                                } else {
+                                    continue;
+                                }
+                            } else {
+                                continue;
+                            };
+
+                            // Check if cache exists (in outputs array)
+                            // Note: Explicit inheritance takes precedence over top-level cache.
+                            // If an output explicitly inherits from a named cache, it must exist
+                            // in the outputs array.
+                            if !cache_names.contains(&cache_name) {
+                                let available: Vec<_> =
+                                    cache_names.iter().map(|n| format!("'{}'", n)).collect();
+                                let help_msg = if available.is_empty() {
+                                    if has_toplevel_cache {
+                                        "No cache outputs defined in outputs array. To use top-level cache, omit the 'inherit' key.".to_string()
+                                    } else {
+                                        "No cache outputs defined".to_string()
+                                    }
+                                } else {
+                                    format!("Available caches: {}", available.join(", "))
+                                };
+                                return Err(ParsingError::from_partial(
+                                    "",
+                                    _partialerror!(
+                                        *output.span(),
+                                        ErrorKind::InvalidField(
+                                            format!("cache '{}' not found", cache_name).into()
+                                        ),
+                                        help = help_msg
+                                    ),
+                                ));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(outputs)
+}
+
+/// Parse a cache output from a Node using proper TryConvertNode
+fn parse_cache_output_from_node(
+    output: &Node,
+) -> Result<Option<crate::recipe::parser::CacheOutput>, ParsingError<&'static str>> {
+    // Convert Node to RenderedNode to use TryConvertNode
+    // For now, we'll use a simplified approach since we don't have jinja context here
+    // In a full implementation, we would need to render the node first
+
+    if let Some(mapping) = output.as_mapping() {
+        if mapping.contains_key("cache") {
+            if let Some(cache_node) = mapping.get("cache") {
+                if let Some(cache_mapping) = cache_node.as_mapping() {
+                    let name = if let Some(name_node) = cache_mapping.get("name") {
+                        if let Some(name_scalar) = name_node.as_scalar() {
+                            Some(name_scalar.as_str().to_string())
+                        } else {
+                            return Err(ParsingError::from_partial(
+                                "",
+                                _partialerror!(
+                                    *name_node.span(),
+                                    ErrorKind::ExpectedScalar,
+                                    help = "cache name must be a string"
+                                ),
+                            ));
+                        }
+                    } else {
+                        None
+                    };
+
+                    // For now, create a basic cache output with defaults
+                    return Ok(Some(crate::recipe::parser::CacheOutput {
+                        name: name.unwrap_or_else(|| "default".to_string()),
+                        source: Vec::new(),
+                        build: crate::recipe::parser::CacheBuild::default(),
+                        requirements: crate::recipe::parser::CacheRequirements::default(),
+                        run_exports: crate::recipe::parser::RunExports::default(),
+                        ignore_run_exports: None,
+                    }));
+                }
+            }
+        }
+    }
+    Ok(None)
+}
+
+/// Parse inheritance relationships from outputs
+fn parse_inheritance_relationships(
+    outputs: &[Node],
+) -> Result<std::collections::HashMap<String, Vec<String>>, ParsingError<&'static str>> {
+    let mut relationships = std::collections::HashMap::new();
+
+    for output in outputs {
+        if let Some(mapping) = output.as_mapping() {
+            if mapping.contains_key("package") {
+                if let Some(package_node) = mapping.get("package") {
+                    if let Some(package_mapping) = package_node.as_mapping() {
+                        let package_name = if let Some(name_node) = package_mapping.get("name") {
+                            if let Some(name_scalar) = name_node.as_scalar() {
+                                name_scalar.as_str().to_string()
+                            } else {
+                                continue;
+                            }
+                        } else {
+                            continue;
+                        };
+
+                        if let Some(inherit_node) = package_mapping.get("inherit") {
+                            let cache_name = if let Some(inherit_scalar) = inherit_node.as_scalar()
+                            {
+                                inherit_scalar.as_str().to_string()
+                            } else if let Some(inherit_mapping) = inherit_node.as_mapping() {
+                                if let Some(from_node) = inherit_mapping.get("from") {
+                                    if let Some(from_scalar) = from_node.as_scalar() {
+                                        from_scalar.as_str().to_string()
+                                    } else {
+                                        continue;
+                                    }
+                                } else {
+                                    continue;
+                                }
+                            } else {
+                                continue;
+                            };
+
+                            relationships
+                                .entry(package_name)
+                                .or_insert_with(Vec::new)
+                                .push(cache_name);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(relationships)
+}
+
+/// Parse cache outputs using proper TryConvertNode with jinja context
+fn parse_cache_outputs_with_context(
+    outputs: &[Node],
+    jinja: &crate::recipe::Jinja,
+) -> Result<Vec<crate::recipe::parser::CacheOutput>, ParsingError<&'static str>> {
+    use super::output_parser::OutputType;
+    let mut cache_outputs = Vec::new();
+
+    for output in outputs {
+        let rendered_node: RenderedNode = output.render(jinja, "output").map_err(|e| {
+            ParsingError::from_partial_vec("", e)
+                .into_iter()
+                .next()
+                .unwrap_or_else(|| {
+                    ParsingError::from_partial(
+                        "",
+                        _partialerror!(
+                            marked_yaml::Span::new_blank(),
+                            ErrorKind::ExpectedMapping,
+                            help = "Failed to render output for inheritance resolution"
+                        ),
+                    )
+                })
+        })?;
+
+        match rendered_node.try_convert("output") {
+            Ok(OutputType::Cache(cache)) => {
+                cache_outputs.push(*cache);
+            }
+            Ok(OutputType::Package(_)) => {
+                continue;
+            }
+            Err(_) => {
+                continue;
+            }
+        }
+    }
+
+    Ok(cache_outputs)
+}
+
+/// Apply cache inheritance to package outputs during parsing
+fn apply_inheritance_to_outputs(
+    outputs: &[Node],
+    cache_outputs: &[crate::recipe::parser::CacheOutput],
+    inheritance_relationships: &std::collections::HashMap<String, Vec<String>>,
+    jinja: &crate::recipe::Jinja,
+) -> Result<Vec<Node>, ParsingError<&'static str>> {
+    use super::output_parser::OutputType;
+    let mut resolved_outputs = Vec::new();
+
+    for output in outputs {
+        let rendered_node: RenderedNode = output.render(jinja, "output").map_err(|e| {
+            ParsingError::from_partial_vec("", e)
+                .into_iter()
+                .next()
+                .unwrap_or_else(|| {
+                    ParsingError::from_partial(
+                        "",
+                        _partialerror!(
+                            marked_yaml::Span::new_blank(),
+                            ErrorKind::ExpectedMapping,
+                            help = "Failed to render output for inheritance resolution"
+                        ),
+                    )
+                })
+        })?;
+
+        match rendered_node.try_convert("output") {
+            Ok(OutputType::Package(mut package_output)) => {
+                let package_name = package_output.package.name().as_normalized().to_string();
+                if let Some(cache_names) = inheritance_relationships.get(&package_name) {
+                    for cache_name in cache_names {
+                        if let Some(cache_output) =
+                            cache_outputs.iter().find(|c| &c.name == cache_name)
+                        {
+                            package_output.apply_cache_inheritance(cache_output);
+                        }
+                    }
+                }
+                let rendered = serde_yaml::to_value(&package_output)
+                    .map_err(|err| ParsingError::from_partial(
+                        "",
+                        _partialerror!(
+                            marked_yaml::Span::new_blank(),
+                            ErrorKind::Other,
+                            label = format!("Failed to serialize inherited output: {}", err)
+                        ),
+                    ))?;
+                let node = Node::try_from(rendered)
+                    .map_err(|err| ParsingError::from_partial("", err))?;
+                resolved_outputs.push(node);
+            }
+            Ok(OutputType::Cache(_)) => {
+                resolved_outputs.push(output.clone());
+            }
+            Err(_) => {
+                resolved_outputs.push(output.clone());
+            }
+        }
+    }
+
+    Ok(resolved_outputs)
+}
+
+/// Resolve cache inheritance and return both outputs and cache outputs
+///
+/// This function validates inheritance and collects cache outputs for use in Output creation.
+/// It uses the proper TryConvertNode for full parsing.
+pub fn resolve_cache_inheritance_with_caches(
+    outputs: Vec<Node>,
+    has_toplevel_cache: bool,
+    experimental_enabled: bool,
+    jinja: &crate::recipe::Jinja,
+) -> CacheInheritanceResult {
+    if !experimental_enabled {
+        for output in &outputs {
+            if let Some(mapping) = output.as_mapping() {
+                if let Some(cache_node) = mapping.get("cache") {
+                    return Err(ParsingError::from_partial(
+                        "",
+                        _partialerror!(
+                            *cache_node.span(),
+                            ErrorKind::ExperimentalOnly("cache outputs".to_string()),
+                            help = "Cache outputs require enabling experimental mode (`--experimental`)"
+                        ),
+                    ));
+                }
+
+                if let Some(package_node) = mapping.get("package") {
+                    if let Some(package_mapping) = package_node.as_mapping() {
+                        if let Some(inherit_node) = package_mapping.get("inherit") {
+                            return Err(ParsingError::from_partial(
+                                "",
+                                _partialerror!(
+                                    *inherit_node.span(),
+                                    ErrorKind::ExperimentalOnly("inherit".to_string()),
+                                    help = "The `inherit` key requires enabling experimental mode (`--experimental`)"
+                                ),
+                            ));
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    let all_cache_outputs = parse_cache_outputs_with_context(&outputs, jinja)?;
+    let inheritance_relationships = parse_inheritance_relationships(&outputs)?;
+    let resolved_outputs = apply_inheritance_to_outputs(
+        &outputs,
+        &all_cache_outputs,
+        &inheritance_relationships,
+        jinja,
+    )?;
+
+    Ok((
+        resolved_outputs,
+        all_cache_outputs,
+        inheritance_relationships,
+    ))
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/recipe/parser/output_v2.rs b/src/recipe/parser/output_v2.rs
deleted file mode 100644
index fd7288ff5..000000000
--- a/src/recipe/parser/output_v2.rs
+++ /dev/null
@@ -1,428 +0,0 @@
-//! Enhanced output parsing that supports cache outputs according to CEP specification
-
-use crate::{
-    _partialerror,
-    recipe::{
-        ParsingError,
-        custom_yaml::{HasSpan, RenderedMappingNode, RenderedNode, TryConvertNode},
-        error::{ErrorKind, PartialParsingError},
-    },
-    source_code::SourceCode,
-};
-
-use super::cache_output::CacheOutput;
-use super::common_output::{
-    ALLOWED_KEYS_MULTI_OUTPUTS, DEEP_MERGE_KEYS, extract_recipe_version_rendered,
-    merge_rendered_mapping_if_not_exists, parse_root_as_mapping_rendered,
-    validate_outputs_sequence_rendered,
-};
-use super::output_parser::{Output, OutputType};
-
-/// Convert a vector of PartialParsingError to a single ParsingError
-fn convert_errors<S: SourceCode>(errors: Vec<PartialParsingError>, src: S) -> ParsingError<S> {
-    errors
-        .into_iter()
-        .map(|e| ParsingError::from_partial(src.clone(), e))
-        .next()
-        .expect("convert_errors called with empty vector")
-}
-
-/// Validates root keys for multi-output recipes (RenderedMappingNode version)
-fn validate_multi_output_root_v2(
-    root_map: &RenderedMappingNode,
-    has_outputs: bool,
-) -> Result<(), PartialParsingError> {
-    if !has_outputs {
-        return Ok(());
-    }
-
-    if root_map.contains_key("package") {
-        let key = root_map
-            .keys()
-            .find(|k| k.as_str() == "package")
-            .expect("unreachable we preemptively check for if contains");
-        return Err(_partialerror!(
-            *key.span(),
-            ErrorKind::InvalidField("package".to_string().into()),
-            help = "recipe cannot have both `outputs` and `package` fields. Rename `package` to `recipe` or remove `outputs`"
-        ));
-    }
-
-    if root_map.contains_key("requirements") {
-        let key = root_map
-            .keys()
-            .find(|k| k.as_str() == "requirements")
-            .expect("unreachable we preemptively check for if contains");
-        return Err(_partialerror!(
-            *key.span(),
-            ErrorKind::InvalidField("requirements".to_string().into()),
-            help = "multi-output recipes cannot have a top-level requirements field. Move `requirements` inside the individual output."
-        ));
-    }
-
-    for key in root_map.keys() {
-        if !ALLOWED_KEYS_MULTI_OUTPUTS.contains(&key.as_str()) {
-            return Err(_partialerror!(
-                *key.span(),
-                ErrorKind::InvalidField(key.as_str().to_string().into()),
-                help = format!("invalid key `{}` in root node", key.as_str())
-            ));
-        }
-    }
-
-    Ok(())
-}
-
-/// Parse outputs from source with support for cache outputs
-pub fn find_outputs_v2<S: SourceCode>(src: S) -> Result<Vec<OutputType>, ParsingError<S>> {
-    let root_node = RenderedNode::parse_yaml(0, src.clone())?;
-    let root_map = parse_root_as_mapping_rendered(&root_node, &src)?;
-
-    let Some(outputs) = root_map.get("outputs") else {
-        return Err(ParsingError::from_partial(
-            src,
-            _partialerror!(
-                *root_node.span(),
-                ErrorKind::MissingField("outputs".into()),
-                help = "v2 recipes must have an 'outputs' field"
-            ),
-        ));
-    };
-
-    if let Err(err) = validate_multi_output_root_v2(root_map, true) {
-        return Err(ParsingError::from_partial(src, err));
-    }
-
-    let outputs = validate_outputs_sequence_rendered(outputs, &src)?;
-
-    let mut res = Vec::with_capacity(outputs.len());
-
-    let recipe_version = extract_recipe_version_rendered(root_map, &src)?;
-
-    for output in outputs.iter() {
-        let Some(output_map) = output.as_mapping() else {
-            return Err(ParsingError::from_partial(
-                src,
-                _partialerror!(
-                    *output.span(),
-                    ErrorKind::ExpectedMapping,
-                    help = "individual `output` must always be a mapping"
-                ),
-            ));
-        };
-
-        let is_cache = output_map.contains_key("cache");
-        let is_package = output_map.contains_key("package");
-
-        if is_cache && is_package {
-            return Err(ParsingError::from_partial(
-                src,
-                _partialerror!(
-                    *output.span(),
-                    ErrorKind::InvalidField("output".into()),
-                    help = "output cannot have both 'cache' and 'package' keys"
-                ),
-            ));
-        }
-
-        if !is_cache && !is_package {
-            return Err(ParsingError::from_partial(
-                src,
-                _partialerror!(
-                    *output.span(),
-                    ErrorKind::InvalidField("output".into()),
-                    help = "output must have either 'cache' or 'package' key"
-                ),
-            ));
-        }
-
-        let parsed_output = if is_cache {
-            let cache_output: CacheOutput =
-                match TryConvertNode::<CacheOutput>::try_convert(output, "outputs.cache") {
-                    Ok(cache) => cache,
-                    Err(err) => return Err(convert_errors(err, src.clone())),
-                };
-            OutputType::Cache(Box::new(cache_output))
-        } else {
-            let output_span = *output.span();
-            let mut processed_map = output_map.clone();
-
-            for (key, value) in root_map.iter() {
-                if key.as_str() == "outputs"
-                    || key.as_str() == "recipe"
-                    || key.as_str() == "schema_version"
-                    || key.as_str() == "cache"
-                {
-                    continue;
-                }
-
-                if !processed_map.contains_key(key.as_str()) {
-                    processed_map.insert(key.clone(), value.clone());
-                } else if DEEP_MERGE_KEYS.contains(&key.as_str()) {
-                    if let (Some(output_value), Some(root_value_map)) = (
-                        processed_map.get(key.as_str()).and_then(|v| v.as_mapping()),
-                        value.as_mapping(),
-                    ) {
-                        let mut merged_map = output_value.clone();
-                        merge_rendered_mapping_if_not_exists(&mut merged_map, root_value_map);
-                        processed_map.insert(key.clone(), RenderedNode::from(merged_map));
-                    }
-                }
-            }
-
-            if let Some(version) = recipe_version.as_ref() {
-                if let Some(package_node) = processed_map.get("package") {
-                    if let Some(package_map) = package_node.as_mapping() {
-                        if !package_map.contains_key("version") {
-                            let mut new_package_map = package_map.clone();
-                            new_package_map.insert("version".into(), version.clone());
-                            processed_map
-                                .insert("package".into(), RenderedNode::from(new_package_map));
-                        }
-                    }
-                } else {
-                    return Err(ParsingError::from_partial(
-                        src.clone(),
-                        _partialerror!(
-                            output_span,
-                            ErrorKind::MissingField("package".to_string().into())
-                        ),
-                    ));
-                }
-            }
-
-            let processed_output_node = RenderedNode::from(processed_map);
-            let output_with_inherit: Output =
-                match TryConvertNode::<Output>::try_convert(&processed_output_node, "output") {
-                    Ok(output) => output,
-                    Err(err) => return Err(convert_errors(err, src.clone())),
-                };
-            OutputType::Package(Box::new(output_with_inherit))
-        };
-
-        res.push(parsed_output);
-    }
-
-    if let Err(errs) = resolve_inheritance(&mut res) {
-        return Err(convert_errors(errs, src));
-    }
-
-    Ok(res)
-}
-
-/// Resolve inheritance relationships between cache and package outputs
-pub fn resolve_inheritance(outputs: &mut [OutputType]) -> Result<(), Vec<PartialParsingError>> {
-    let mut cache_outputs = std::collections::HashMap::new();
-
-    for (idx, output) in outputs.iter().enumerate() {
-        if let OutputType::Cache(cache) = output {
-            if cache_outputs.contains_key(&cache.name) {
-                return Err(vec![_partialerror!(
-                    marked_yaml::Span::new_blank(),
-                    ErrorKind::InvalidField(
-                        format!("duplicate cache output name: {}", cache.name).into()
-                    ),
-                    help = format!(
-                        "Each cache output must have a unique name. Rename one of the cache outputs with name '{}'.",
-                        cache.name
-                    )
-                )]);
-            }
-            cache_outputs.insert(cache.name.clone(), idx);
-        }
-    }
-
-    let mut inheritance_todo = Vec::new();
-
-    for (idx, output) in outputs.iter().enumerate() {
-        if let OutputType::Package(package) = output {
-            if let Some(inherit_spec) = &package.inherit {
-                let cache_name = inherit_spec.cache_name();
-
-                let cache_idx = *cache_outputs.get(cache_name).ok_or_else(|| {
-                    let available_caches = cache_outputs.keys()
-                        .map(|name| format!("'{}'", name))
-                        .collect::<Vec<_>>()
-                        .join(", ");
-
-                    let help_text = if available_caches.is_empty() {
-                        format!("No cache outputs are defined in this recipe. Add a cache output with name '{}' or remove the inherit field.", cache_name)
-                    } else {
-                        format!("Available cache outputs: {}. Make sure the cache name is spelled correctly.", available_caches)
-                    };
-
-                    vec![_partialerror!(
-                        marked_yaml::Span::new_blank(),
-                        ErrorKind::InvalidField(
-                            format!("cache output '{}' not found", cache_name).into()
-                        ),
-                        help = help_text
-                    )]
-                })?;
-
-                inheritance_todo.push((idx, cache_idx));
-            }
-        }
-    }
-
-    for (pkg_idx, cache_idx) in inheritance_todo {
-        let cache_clone = if let OutputType::Cache(cache) = &outputs[cache_idx] {
-            (**cache).clone()
-        } else {
-            continue;
-        };
-
-        if let OutputType::Package(package) = &mut outputs[pkg_idx] {
-            package.apply_cache_inheritance(&cache_clone);
-        }
-    }
-
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_cache_output_parsing() {
-        let yaml = r#"
-outputs:
-  - cache:
-      name: foo-cache
-    source:
-      - url: https://foo.bar/source.tar.bz2
-        sha256: 0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef
-    requirements:
-      build:
-        - cmake
-      host:
-        - libfoo
-    build:
-      script: build_cache.sh
-
-  - package:
-      name: foo-headers
-    inherit:
-      from: foo-cache
-      run_exports: false
-    build:
-      files:
-        - include/
-
-  - package:
-      name: foo
-    inherit: foo-cache
-"#;
-
-        let outputs = find_outputs_v2(yaml).unwrap();
-        assert_eq!(outputs.len(), 3);
-
-        assert!(matches!(&outputs[0], OutputType::Cache(_)));
-        assert!(matches!(&outputs[1], OutputType::Package(_)));
-        assert!(matches!(&outputs[2], OutputType::Package(_)));
-
-        // Check that packages have the cache in their caches list (inheritance is already resolved in find_outputs_v2)
-        if let OutputType::Package(pkg) = &outputs[1] {
-            assert_eq!(pkg.caches.len(), 1);
-            assert_eq!(pkg.caches[0].name, "foo-cache");
-        }
-
-        if let OutputType::Package(pkg) = &outputs[2] {
-            assert_eq!(pkg.caches.len(), 1);
-            assert_eq!(pkg.caches[0].name, "foo-cache");
-        }
-    }
-
-    #[test]
-    fn test_error_messages() {
-        let yaml = r#"
-outputs:
-  - cache:
-      name: foo-cache
-    build:
-      script: build_cache.sh
-
-  - package:
-      name: foo
-    inherit: non-existent-cache
-"#;
-
-        let result = find_outputs_v2(yaml);
-        assert!(result.is_err());
-        let err = result.unwrap_err();
-        let err_str = format!("{:?}", err);
-        assert!(err_str.contains("cache output 'non-existent-cache' not found"));
-        assert!(err_str.contains("Available cache outputs: 'foo-cache'"));
-
-        let yaml = r#"
-outputs:
-  - cache:
-      name: foo-cache
-    build:
-      script: build_cache.sh
-
-  - cache:
-      name: foo-cache
-    build:
-      script: another_script.sh
-"#;
-
-        let result = find_outputs_v2(yaml);
-        assert!(result.is_err());
-        let err = result.unwrap_err();
-        let err_str = format!("{:?}", err);
-        assert!(err_str.contains("duplicate cache output name: foo-cache"));
-        assert!(err_str.contains("Each cache output must have a unique name"));
-
-        let yaml = r#"
-outputs:
-  - cache:
-      name: foo-cache
-    invalid_field: value
-    build:
-      script: build_cache.sh
-"#;
-
-        let result = find_outputs_v2(yaml);
-        assert!(result.is_err());
-        let err = result.unwrap_err();
-        let err_str = format!("{:?}", err);
-        assert!(err_str.contains("InvalidField(\"invalid_field\")"));
-        assert!(err_str.contains("valid fields for cache outputs are:"));
-
-        let yaml = r#"
-outputs:
-  - cache:
-      name: foo-cache
-    build:
-      script: build_cache.sh
-      invalid_field: value
-"#;
-
-        let result = find_outputs_v2(yaml);
-        assert!(result.is_err());
-        let err = result.unwrap_err();
-        let err_str = format!("{:?}", err);
-        assert!(err_str.contains("InvalidField(\"invalid_field\")"));
-        assert!(err_str.contains("only 'script' is allowed"));
-
-        let yaml = r#"
-outputs:
-  - cache:
-      name: foo-cache
-    build:
-      script: build_cache.sh
-    requirements:
-      invalid_field:
-        - package
-"#;
-
-        let result = find_outputs_v2(yaml);
-        assert!(result.is_err());
-        let err = result.unwrap_err();
-        let err_str = format!("{:?}", err);
-        assert!(err_str.contains("InvalidField(\"invalid_field\")"));
-        assert!(err_str.contains("cache outputs can only have 'build' and 'host' requirements"));
-    }
-}
diff --git a/src/recipe/parser/requirements.rs b/src/recipe/parser/requirements.rs
index d76759004..860c9b62f 100644
--- a/src/recipe/parser/requirements.rs
+++ b/src/recipe/parser/requirements.rs
@@ -464,6 +464,17 @@ impl RunExports {
     pub fn weak_constraints(&self) -> &[Dependency] {
         self.weak_constraints.as_slice()
     }
+
+    /// Extend this RunExports with entries from another instance
+    pub fn extend_from(&mut self, other: &RunExports) {
+        self.noarch.extend(other.noarch.iter().cloned());
+        self.strong.extend(other.strong.iter().cloned());
+        self.strong_constraints
+            .extend(other.strong_constraints.iter().cloned());
+        self.weak.extend(other.weak.iter().cloned());
+        self.weak_constraints
+            .extend(other.weak_constraints.iter().cloned());
+    }
 }
 
 impl TryConvertNode<RunExports> for RenderedNode {
diff --git a/src/render/resolved_dependencies.rs b/src/render/resolved_dependencies.rs
index 843cb012b..18da40cf7 100644
--- a/src/render/resolved_dependencies.rs
+++ b/src/render/resolved_dependencies.rs
@@ -689,14 +689,28 @@ pub(crate) async fn resolve_dependencies(
 
     let mut compatibility_specs = HashMap::new();
 
-    let build_env = if !requirements.build.is_empty() && !merge_build_host {
-        let build_env_specs = apply_variant(
+    // Build env: include both output build requirements and cache build requirements
+    // If merge_build_host is enabled, we still compute a separate build env to propagate run_exports correctly.
+    let build_env = {
+        let mut build_env_specs = apply_variant(
             requirements.build(),
             &output.build_configuration,
             &compatibility_specs,
             true,
         )?;
 
+        // Merge in Cache build specs if available
+        if let Some(cache) = &output.finalized_cache_dependencies {
+            if let Some(cache_build) = &cache.build {
+                build_env_specs.extend(cache_build.specs.iter().cloned());
+            }
+        }
+
+        if build_env_specs.is_empty() || merge_build_host {
+            // If there are no specs (and we are not merging separately), skip creating a separate build env
+            // unless merge_build_host is false and we really have specs to solve.
+        }
+
         let match_specs = build_env_specs
             .iter()
             .map(|s| s.spec().clone())
@@ -739,12 +753,7 @@ pub(crate) async fn resolve_dependencies(
             compatibility_specs.insert(r.package_record.name.clone(), r.package_record.clone());
         });
 
-        Some(ResolvedDependencies {
-            specs: build_env_specs,
-            resolved,
-        })
-    } else {
-        None
+        Some(ResolvedDependencies { specs: build_env_specs, resolved })
     };
 
     // host env
@@ -755,6 +764,13 @@ pub(crate) async fn resolve_dependencies(
         true,
     )?;
 
+    // Merge in Cache host specs
+    if let Some(cache) = &output.finalized_cache_dependencies {
+        if let Some(cache_host) = &cache.host {
+            host_env_specs.extend(cache_host.specs.iter().cloned());
+        }
+    }
+
     // Apply the strong run exports from the build environment to the host
     // environment
     let mut build_run_exports = HashMap::new();
@@ -857,31 +873,6 @@ pub(crate) async fn resolve_dependencies(
         false,
     )?;
 
-    // add in dependencies from the finalized cache
-    if let Some(finalized_cache) = &output.finalized_cache_dependencies {
-        tracing::info!(
-            "Adding dependencies from finalized cache: {:?}",
-            finalized_cache.run.depends
-        );
-
-        depends = depends
-            .iter()
-            .chain(finalized_cache.run.depends.iter())
-            .filter(|c| !matches!(c, DependencyInfo::RunExport(_)))
-            .cloned()
-            .collect();
-
-        tracing::info!(
-            "Adding constraints from finalized cache: {:?}",
-            finalized_cache.run.constraints
-        );
-        constraints = constraints
-            .iter()
-            .chain(finalized_cache.run.constraints.iter())
-            .filter(|c| !matches!(c, DependencyInfo::RunExport(_)))
-            .cloned()
-            .collect();
-    }
 
     let rendered_run_exports = render_run_exports(output, &compatibility_specs)?;
 
diff --git a/src/source/copy_dir.rs b/src/source/copy_dir.rs
index 14004c2cb..85ab38804 100644
--- a/src/source/copy_dir.rs
+++ b/src/source/copy_dir.rs
@@ -23,6 +23,8 @@ pub struct CopyOptions {
     pub skip_exist: bool,
     /// Buffer size for copying files (default: 8 MiB)
     pub buffer_size: usize,
+    /// Optional callback invoked when a destination file is about to be overwritten
+    pub on_overwrite: Option<Box<dyn Fn(&Path) + Send + Sync + 'static>>,
 }
 
 impl Default for CopyOptions {
@@ -31,6 +33,7 @@ impl Default for CopyOptions {
             overwrite: false,
             skip_exist: false,
             buffer_size: 8 * 1024 * 1024,
+            on_overwrite: None,
         }
     }
 }
@@ -113,7 +116,11 @@ pub(crate) fn copy_file(
                 } else if options.skip_exist {
                     tracing::warn!("File already exists! Skipping file: {:?}", dest_path);
                 } else if options.overwrite {
-                    tracing::warn!("File already exists! Overwriting file: {:?}", dest_path);
+                    if let Some(callback) = &options.on_overwrite {
+                        callback(dest_path);
+                    } else {
+                        tracing::warn!("File already exists! Overwriting file: {:?}", dest_path);
+                    }
                 }
             }
             reflink_or_copy(path, dest_path, options).map_err(SourceError::FileSystemError)?;
@@ -202,6 +209,15 @@ impl<'a> CopyDir<'a> {
         self
     }
 
+    #[allow(unused)]
+    pub fn on_overwrite<F>(mut self, callback: F) -> Self
+    where
+        F: Fn(&Path) + Send + Sync + 'static,
+    {
+        self.copy_options.on_overwrite = Some(Box::new(callback));
+        self
+    }
+
     pub fn run(self) -> Result<CopyDirResult, SourceError> {
         // Create the to path because we're going to copy the contents only
         create_dir_all(self.to_path)?;
@@ -455,6 +471,10 @@ impl CopyDirResult {
         &self.copied_paths
     }
 
+    pub fn copied_paths_owned(&self) -> Vec<PathBuf> {
+        self.copied_paths.clone()
+    }
+
     pub fn include_globs(&self) -> &HashMap<String, Match> {
         &self.include_globs
     }
diff --git a/src/source/mod.rs b/src/source/mod.rs
index 67c05c298..6aa5895b6 100644
--- a/src/source/mod.rs
+++ b/src/source/mod.rs
@@ -137,6 +137,13 @@ pub async fn fetch_sources(
                     || {
                         copy_dir::CopyDir::new(&result.0, &dest_dir)
                             .use_gitignore(false)
+                            .overwrite(true)
+                            .on_overwrite(|p| {
+                                tracing::warn!(
+                                    "Source file {} overwrote an existing file in work dir (possible clobber)",
+                                    p.display()
+                                );
+                            })
                             .run()
                     },
                 )?;
@@ -182,6 +189,13 @@ pub async fn fetch_sources(
                         || {
                             copy_dir::CopyDir::new(&res, &dest_dir)
                                 .use_gitignore(false)
+                                .overwrite(true)
+                                .on_overwrite(|p| {
+                                    tracing::warn!(
+                                        "Source file {} overwrote an existing file in work dir (possible clobber)",
+                                        p.display()
+                                    );
+                                })
                                 .run()
                         },
                     )?;
@@ -230,6 +244,13 @@ pub async fn fetch_sources(
                             copy_dir::CopyDir::new(&src_path, &dest_dir)
                                 .use_gitignore(src.use_gitignore())
                                 .with_globvec(&src.filter)
+                                .overwrite(true)
+                                .on_overwrite(|p| {
+                                    tracing::warn!(
+                                        "Source file {} overwrote an existing file in work dir (possible clobber)",
+                                        p.display()
+                                    );
+                                })
                                 .run()
                         },
                     )?;
diff --git a/src/variant_config.rs b/src/variant_config.rs
index d0393cadd..d714f8140 100644
--- a/src/variant_config.rs
+++ b/src/variant_config.rs
@@ -508,9 +508,18 @@ impl VariantConfig {
         outputs: &[Node],
         recipe: S,
         selector_config: &SelectorConfig,
+        cache_outputs: &[crate::recipe::parser::CacheOutput],
+        inheritance_relationships: &std::collections::HashMap<String, Vec<String>>,
     ) -> Result<IndexSet<DiscoveredOutput>, VariantError<S>> {
         // find all jinja variables
-        let stage_0 = stage_0_render(outputs, recipe, selector_config, self)?;
+        let stage_0 = stage_0_render(
+            outputs,
+            recipe,
+            selector_config,
+            self,
+            cache_outputs,
+            inheritance_relationships,
+        )?;
         let stage_1 = stage_1_render(stage_0, selector_config, self)?;
 
         // Now we need to convert the stage 1 renders to DiscoveredOutputs
@@ -771,7 +780,13 @@ mod tests {
         let outputs = crate::recipe::parser::find_outputs_from_src(recipe_text.as_str()).unwrap();
         let variant_config = VariantConfig::from_files(&[yaml_file], &selector_config).unwrap();
         let outputs_and_variants = variant_config
-            .find_variants(&outputs, recipe_text.as_str(), &selector_config)
+            .find_variants(
+                &outputs,
+                recipe_text.as_str(),
+                &selector_config,
+                &[],
+                &std::collections::HashMap::new(),
+            )
             .unwrap();
 
         let used_variables_all: Vec<&BTreeMap<NormalizedKey, Variable>> = outputs_and_variants
@@ -852,7 +867,13 @@ mod tests {
                 crate::recipe::parser::find_outputs_from_src(recipe_text.as_str()).unwrap();
             let variant_config = VariantConfig::from_files(&[], &selector_config).unwrap();
             let outputs_and_variants = variant_config
-                .find_variants(&outputs, recipe_text.as_str(), &selector_config)
+                .find_variants(
+                    &outputs,
+                    recipe_text.as_str(),
+                    &selector_config,
+                    &[],
+                    &std::collections::HashMap::new(),
+                )
                 .unwrap();
 
             // assert output order
@@ -882,7 +903,13 @@ mod tests {
         let outputs = crate::recipe::parser::find_outputs_from_src(recipe_text.as_str()).unwrap();
         let variant_config = VariantConfig::from_files(&[yaml_file], &selector_config).unwrap();
         let outputs_and_variants = variant_config
-            .find_variants(&outputs, recipe_text.as_str(), &selector_config)
+            .find_variants(
+                &outputs,
+                recipe_text.as_str(),
+                &selector_config,
+                &[],
+                &std::collections::HashMap::new(),
+            )
             .unwrap();
 
         let used_variables_all: Vec<&BTreeMap<NormalizedKey, Variable>> = outputs_and_variants
diff --git a/src/variant_render.rs b/src/variant_render.rs
index 2bbdce18b..5b1218cf0 100644
--- a/src/variant_render.rs
+++ b/src/variant_render.rs
@@ -55,6 +55,8 @@ pub(crate) fn stage_0_render<S: SourceCode>(
     source: S,
     selector_config: &SelectorConfig,
     variant_config: &VariantConfig,
+    cache_outputs: &[crate::recipe::parser::CacheOutput],
+    inheritance_relationships: &std::collections::HashMap<String, Vec<String>>,
 ) -> Result<Vec<Stage0Render<S>>, VariantError<S>> {
     let used_vars = outputs
         .iter()
@@ -98,7 +100,7 @@ pub(crate) fn stage_0_render<S: SourceCode>(
             let config_with_variant =
                 selector_config.with_variant(combination.clone(), selector_config.target_platform);
 
-            let parsed_recipe = Recipe::from_node(output, config_with_variant)
+            let mut parsed_recipe = Recipe::from_node(output, config_with_variant)
                 .map_err(|err| {
                     let errs: ParseErrors<_> = err
                         .into_iter()
@@ -109,6 +111,22 @@ pub(crate) fn stage_0_render<S: SourceCode>(
                 })
                 .map_err(VariantConfigError::from)?;
 
+            let package_name = parsed_recipe.package.name.as_normalized().to_string();
+            if let Some(caches) = inheritance_relationships.get(&package_name) {
+                let mut cache_list = Vec::new();
+                for cache_name in caches {
+                    if let Some(cache_output) = cache_outputs.iter().find(|c| &c.name == cache_name)
+                    {
+                        cache_list.push(cache_output.clone());
+                    }
+                }
+                parsed_recipe.cache_outputs = cache_list;
+            }
+
+            if let Some(synthetic) = parsed_recipe.synthetic_cache_output() {
+                parsed_recipe.cache_outputs.push(synthetic);
+            }
+
             rendered_outputs.push(parsed_recipe);
         }
 
@@ -316,7 +334,6 @@ pub(crate) fn stage_1_render<S: SourceCode>(
 ) -> Result<Vec<Stage1Render<S>>, VariantError<S>> {
     let mut stage_1_renders = Vec::new();
 
-    // TODO we need to add variables from the cache output here!
     for r in stage0_renders {
         let mut extra_vars_per_output: Vec<HashSet<NormalizedKey>> = Vec::new();
         let mut exact_pins_per_output: Vec<HashSet<PackageName>> = Vec::new();
@@ -336,6 +353,18 @@ pub(crate) fn stage_1_render<S: SourceCode>(
                 }
             }
 
+            // Add variant keys from cache build if present (for top-level cache)
+            if let Some(cache) = &output.cache {
+                let cache_use_keys = cache
+                    .build
+                    .variant()
+                    .use_keys
+                    .iter()
+                    .map(|k| k.as_str().into())
+                    .collect::<Vec<NormalizedKey>>();
+                additional_variables.extend(cache_use_keys);
+            }
+
             // We want to add something to packages that are requiring a subpackage
             // _exactly_ because that creates additional variants
             for pin in output.requirements.all_pin_subpackage() {

From f48e76d0d8de59873ecb210869e07381d038c6fd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Sat, 18 Oct 2025 00:25:32 +0300
Subject: [PATCH 07/29] only tests remain, this was big

---
 src/build.rs                        |  25 +-
 src/cache.rs                        |  20 +-
 src/metadata.rs                     |   5 +
 src/packaging.rs                    |  26 +-
 src/packaging/file_finder.rs        |  68 ++++
 src/recipe/parser.rs                |  23 +-
 src/recipe/parser/cache_output.rs   | 181 +++++++--
 src/recipe/parser/common_output.rs  |  34 +-
 src/recipe/parser/output.rs         | 582 +++++++++++++++++++++-------
 src/recipe/parser/output_parser.rs  |  39 +-
 src/recipe/parser/requirements.rs   |   6 +
 src/render/resolved_dependencies.rs |   6 +-
 src/source/copy_dir.rs              |   4 +-
 src/variant_render.rs               |  58 ++-
 14 files changed, 857 insertions(+), 220 deletions(-)

diff --git a/src/build.rs b/src/build.rs
index a7c9867d9..66f7f6d25 100644
--- a/src/build.rs
+++ b/src/build.rs
@@ -115,7 +115,7 @@ pub async fn run_build(
     // Handle cache outputs first
     let output = if output.recipe.cache.is_some() {
         let output = output.build_or_fetch_cache(tool_configuration).await?;
-        
+
         // Warn if output defines additional sources on top of cache
         if !output.recipe.sources().is_empty() && output.finalized_cache_sources.is_some() {
             tracing::warn!(
@@ -134,9 +134,11 @@ pub async fn run_build(
                 .build_or_fetch_cache_output(cache_output, tool_configuration)
                 .await?;
         }
-        
+
         // Warn if output defines additional sources on top of cache
-        if !current_output.recipe.sources().is_empty() && current_output.finalized_cache_sources.is_some() {
+        if !current_output.recipe.sources().is_empty()
+            && current_output.finalized_cache_sources.is_some()
+        {
             tracing::warn!(
                 "Output defines sources in addition to cache sources. \
                  This may overwrite files from the cache. \
@@ -156,11 +158,22 @@ pub async fn run_build(
         .await
         .into_diagnostic()?;
 
-    // Fast-path: If this output used a cache (inherit) and has no explicit build script,
-    // skip environment installation and script execution. We only distribute files based on build.files.
+    // Fast-path optimization: When an output inherits from a cache and has no explicit build script,
+    // we can skip environment installation and script execution entirely. This is a key benefit
+    // of the outputs-based cache approach as it allows for significant performance
+    // improvements when building multiple outputs that depend on the same intermediate artifacts.
     let use_fast_path = output.finalized_cache_dependencies.is_some()
         && output.recipe.build().script().is_default();
 
+    // Verify that requirements inheritance is properly handled in fast path
+    // If there are inherited requirements but no build script, we still need to check if
+    // environment setup is needed for other purposes beyond script execution
+    if use_fast_path {
+        tracing::info!(
+            "Using fast-path optimization: output inherited cache and has no build.script; skipping environment setup and script execution for improved performance."
+        );
+    }
+
     if !use_fast_path {
         output
             .install_environments(tool_configuration)
@@ -181,7 +194,7 @@ pub async fn run_build(
         }
     } else {
         tracing::info!(
-            "Using fast-path: inherited cache detected and no build.script specified; skipping env setup and script execution."
+            "Using fast-path optimization: output inherited cache and has no build.script; skipping environment setup and script execution for improved performance."
         );
     }
 
diff --git a/src/cache.rs b/src/cache.rs
index d166198f2..5476120b9 100644
--- a/src/cache.rs
+++ b/src/cache.rs
@@ -269,7 +269,10 @@ impl Output {
             let old = cache.prefix.to_string_lossy().to_string();
             let new = self.prefix().to_string_lossy().to_string();
             for rel in cache.files_with_prefix.iter() {
-                for base in [self.prefix(), &self.build_configuration.directories.work_dir] {
+                for base in [
+                    self.prefix(),
+                    &self.build_configuration.directories.work_dir,
+                ] {
                     let path = base.join(rel);
                     if !path.exists() {
                         continue;
@@ -325,12 +328,9 @@ impl Output {
         Ok(Output {
             finalized_cache_dependencies: Some(cache.finalized_dependencies.clone()),
             finalized_cache_sources: Some(cache.finalized_sources.clone()),
-            // Also merge cache-declared run_exports into the recipe
-            recipe: {
-                let mut recipe = self.recipe.clone();
-                recipe.requirements.run_exports.extend_from(&cache.run_exports);
-                recipe
-            },
+            // Recipe already has run_exports merged during inheritance resolution,
+            // so we don't need to merge them again here
+            recipe: self.recipe.clone(),
             restored_cache_prefix_files: Some(cached_prefix_files),
             restored_cache_work_dir_files: Some(cached_work_files.clone()),
             ..self.clone()
@@ -343,7 +343,7 @@ impl Output {
         cache_output: &crate::recipe::parser::CacheOutput,
         tool_configuration: &crate::tool_configuration::Configuration,
     ) -> Result<Self, miette::Error> {
-        let cache_name = &cache_output.name;
+        let cache_name = cache_output.name.as_normalized();
         let cache_key = self
             .cache_key_for(cache_name, &cache_output.requirements)
             .into_diagnostic()?;
@@ -449,8 +449,8 @@ impl Output {
         // Collect new files and save cache
         let new_files = Files::from_prefix(
             self.prefix(),
-            cache_output.build.always_include_files(),
-            cache_output.build.files(),
+            &cache_output.build.always_include_files,
+            &cache_output.build.files,
         )
         .into_diagnostic()?;
 
diff --git a/src/metadata.rs b/src/metadata.rs
index 30ff8522f..702939c6b 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -551,6 +551,11 @@ impl Output {
         &self.build_configuration.directories.host_prefix
     }
 
+    /// Check if this output has restored cache files
+    pub fn has_restored_cache_files(&self) -> bool {
+        self.restored_cache_prefix_files.is_some() || self.restored_cache_work_dir_files.is_some()
+    }
+
     /// Shorthand to retrieve the build prefix for this output
     pub fn build_prefix(&self) -> &Path {
         &self.build_configuration.directories.build_prefix
diff --git a/src/packaging.rs b/src/packaging.rs
index 3ee172e90..81a81ea5f 100644
--- a/src/packaging.rs
+++ b/src/packaging.rs
@@ -563,20 +563,30 @@ fn create_empty_build_folder(
 }
 
 impl Output {
-    /// Create a conda package from any new files in the host prefix. Note: the
+    /// Create a conda package from files in the host prefix. Note: the
     /// previous stages should have been completed before calling this
     /// function.
     pub async fn create_package(
         &self,
         tool_configuration: &tool_configuration::Configuration,
     ) -> Result<(PathBuf, PathsJson), PackagingError> {
-        let span = tracing::info_span!("Packaging new files");
-        let _enter = span.enter();
-        let files_after = Files::from_prefix(
-            &self.build_configuration.directories.host_prefix,
-            self.recipe.build().always_include_files(),
-            self.recipe.build().files(),
-        )?;
+        // When cache files are present, the output's build.files should apply to all
+        // relevant files, not just "new" ones compared to conda-meta
+        let files_after = if self.has_restored_cache_files() {
+            Files::from_prefix_with_filters(
+                &self.build_configuration.directories.host_prefix,
+                self.recipe.build().always_include_files(),
+                self.recipe.build().files(),
+                self.restored_cache_prefix_files.as_ref(),
+                self.restored_cache_work_dir_files.as_ref(),
+            )?
+        } else {
+            Files::from_prefix(
+                &self.build_configuration.directories.host_prefix,
+                self.recipe.build().always_include_files(),
+                self.recipe.build().files(),
+            )?
+        };
 
         package_conda(self, tool_configuration, &files_after)
     }
diff --git a/src/packaging/file_finder.rs b/src/packaging/file_finder.rs
index 0d68c9e78..b420050ab 100644
--- a/src/packaging/file_finder.rs
+++ b/src/packaging/file_finder.rs
@@ -213,6 +213,74 @@ impl Files {
         })
     }
 
+    /// Find all files in the given prefix and apply the provided filters, including restored cache files.
+    /// This method is used when cache files have been restored to the prefix and we need to select files
+    /// based on the output's build configuration.
+    pub fn from_prefix_with_filters(
+        prefix: &Path,
+        always_include: &GlobVec,
+        files: &GlobVec,
+        restored_cache_prefix_files: Option<&Vec<PathBuf>>,
+        _restored_cache_work_dir_files: Option<&Vec<PathBuf>>,
+    ) -> Result<Self, io::Error> {
+        if !prefix.exists() {
+            return Ok(Files {
+                new_files: HashSet::new(),
+                old_files: HashSet::new(),
+                prefix: prefix.to_owned(),
+            });
+        }
+
+        let current_files = record_files(prefix)?;
+        let mut selected_files = HashSet::new();
+        for file in &current_files {
+            if let Ok(file_without_prefix) = file.strip_prefix(prefix) {
+                if files.is_empty()
+                    || files.is_match(file_without_prefix)
+                    || always_include.is_match(file_without_prefix)
+                {
+                    if always_include.is_match(file_without_prefix) {
+                        tracing::info!("Forcing inclusion of file: {:?}", file_without_prefix);
+                    }
+                    selected_files.insert(file.clone());
+                }
+            }
+        }
+
+        if let Some(cache_files) = restored_cache_prefix_files {
+            for cache_file in cache_files {
+                let full_path = prefix.join(cache_file);
+                if let Ok(file_without_prefix) = full_path.strip_prefix(prefix) {
+                    if (files.is_empty()
+                        || files.is_match(file_without_prefix)
+                        || always_include.is_match(file_without_prefix))
+                        && current_files.contains(&full_path)
+                    {
+                        selected_files.insert(full_path);
+                    }
+                }
+            }
+        }
+
+        let previous_files = if prefix.join("conda-meta").exists() {
+            let prefix_records: Vec<PrefixRecord> = PrefixRecord::collect_from_prefix(prefix)?;
+            let mut previous_files = prefix_records
+                .into_iter()
+                .flat_map(|record| record.files.into_iter().map(|f| prefix.join(f)))
+                .collect::<HashSet<_>>();
+            previous_files.extend(record_files(&prefix.join("conda-meta"))?);
+            previous_files
+        } else {
+            HashSet::new()
+        };
+
+        Ok(Files {
+            new_files: selected_files,
+            old_files: previous_files,
+            prefix: prefix.to_owned(),
+        })
+    }
+
     /// Copy the new files to a temporary directory and return the temporary directory and the files that were copied.
     pub fn to_temp_folder(&self, output: &Output) -> Result<TempFiles, PackagingError> {
         let temp_dir = TempDir::with_prefix(output.name().as_normalized())?;
diff --git a/src/recipe/parser.rs b/src/recipe/parser.rs
index 1e95ec1ee..7e90d9a9f 100644
--- a/src/recipe/parser.rs
+++ b/src/recipe/parser.rs
@@ -3,6 +3,7 @@
 //! This phase parses YAML and [`SelectorConfig`] into a [`Recipe`], where
 //! if-selectors are handled and any jinja string is processed, resulting in a rendered recipe.
 use indexmap::IndexMap;
+use rattler_conda_types::PackageName;
 use serde::{Deserialize, Serialize};
 use std::borrow::Cow;
 use std::fmt::Debug;
@@ -18,6 +19,7 @@ use crate::{
     selectors::SelectorConfig,
     source_code::SourceCode,
 };
+use marked_yaml;
 
 mod about;
 mod build;
@@ -270,8 +272,8 @@ impl Recipe {
         let mut about = About::default();
         let mut cache = None;
         let mut extra = IndexMap::default();
-        let mut cache_outputs_result = Vec::new();
-        let mut cache_inheritance = std::collections::HashMap::new();
+        let cache_outputs_result = Vec::new();
+        let cache_inheritance = std::collections::HashMap::new();
 
         rendered_node
             .iter()
@@ -335,7 +337,7 @@ impl Recipe {
             );
         }
 
-        let mut recipe = Recipe {
+        let recipe = Recipe {
             schema_version,
             context,
             package: package.ok_or_else(|| {
@@ -393,12 +395,16 @@ impl Recipe {
     /// Convert top-level cache to a synthetic CacheOutput
     pub fn synthetic_cache_output(&self) -> Option<CacheOutput> {
         self.cache.as_ref().map(|cache| CacheOutput {
-            name: format!("__recipe_{}_cache", self.package.name.as_normalized()),
+            name: PackageName::new_unchecked(format!(
+                "__recipe_{}_cache",
+                self.package.name.as_normalized()
+            )),
             source: cache.source.clone(),
             build: CacheBuild {
                 script: Some(cache.build.script.clone()),
-                files: cache.build.files.clone(),
-                always_include_files: cache.build.always_include_files.clone(),
+                variant: cache.build.variant().clone(),
+                files: GlobVec::default(),
+                always_include_files: GlobVec::default(),
             },
             requirements: CacheRequirements {
                 build: cache.requirements.build.clone(),
@@ -407,6 +413,7 @@ impl Recipe {
             run_exports: RunExports::default(),
             ignore_run_exports: Some(cache.requirements.ignore_run_exports.clone()),
             about: None,
+            span: marked_yaml::Span::new_blank(),
         })
     }
 
@@ -432,7 +439,9 @@ impl Recipe {
         if let Some(cache_names) = inheritance_relationships.get(package_name) {
             let mut result = Vec::new();
             for cache_name in cache_names {
-                if let Some(cache_output) = all_cache_outputs.iter().find(|c| &c.name == cache_name)
+                if let Some(cache_output) = all_cache_outputs
+                    .iter()
+                    .find(|c| c.name.as_normalized() == cache_name.as_str())
                 {
                     result.push(cache_output.clone());
                 }
diff --git a/src/recipe/parser/cache_output.rs b/src/recipe/parser/cache_output.rs
index c42bcc7fc..64a2b5387 100644
--- a/src/recipe/parser/cache_output.rs
+++ b/src/recipe/parser/cache_output.rs
@@ -2,6 +2,10 @@
 //!
 //! This module defines the cache output type which is an intermediate build artifact
 //! that can be inherited by regular package outputs.
+//!
+//! Cache outputs enable the "fast path" optimization where package outputs that inherit
+//! from a cache and specify no explicit build script can skip environment installation
+//! and script execution, significantly speeding up the build process.
 
 use crate::{
     _partialerror,
@@ -9,22 +13,30 @@ use crate::{
         custom_yaml::{HasSpan, RenderedMappingNode, RenderedNode, TryConvertNode},
         error::{ErrorKind, PartialParsingError},
         parser::{
-            StandardTryConvert, invalid_field_error, missing_field_error, parse_required_string,
+            StandardTryConvert, build::VariantKeyUsage, invalid_field_error, missing_field_error,
             validate_mapping_keys,
         },
     },
 };
+use marked_yaml::Span;
+use rattler_conda_types::PackageName;
+use serde::de::{self, Deserialize as DeserializeTrait, Deserializer};
 use serde::{Deserialize, Serialize};
 
-use super::{Script, Source};
-use super::requirements::RunExports;
 use super::glob_vec::GlobVec;
+use super::requirements::RunExports;
+use super::{Script, Source};
 
 /// A cache output that produces intermediate build artifacts
-#[derive(Debug, Clone, Serialize, Deserialize)]
+///
+/// Cache outputs can be inherited by package outputs using the `inherit` key in the
+/// package output definition. This enables the "fast path" optimization where package
+/// outputs that inherit from a cache and have no explicit build script can skip
+/// environment installation and script execution, significantly improving build performance.
+#[derive(Debug, Clone, Serialize)]
 pub struct CacheOutput {
     /// The name of the cache output
-    pub name: String,
+    pub name: PackageName,
     /// Sources for this cache output
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub source: Vec<Source>,
@@ -46,31 +58,138 @@ pub struct CacheOutput {
     pub span: marked_yaml::Span,
 }
 
+#[derive(Deserialize)]
+#[serde(field_identifier, rename_all = "lowercase")]
+enum Field {
+    Name,
+    Source,
+    Build,
+    Requirements,
+    RunExports,
+    IgnoreRunExports,
+    About,
+}
+
+// Manual implementation of Deserialize for CacheOutput
+impl<'de> DeserializeTrait<'de> for CacheOutput {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct CacheOutputVisitor;
+
+        impl<'de> de::Visitor<'de> for CacheOutputVisitor {
+            type Value = CacheOutput;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("struct CacheOutput")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> Result<CacheOutput, V::Error>
+            where
+                V: de::MapAccess<'de>,
+            {
+                let mut name = None;
+                let mut source = None;
+                let mut build = None;
+                let mut requirements = None;
+                let mut run_exports = None;
+                let mut ignore_run_exports = None;
+                let mut about = None;
+
+                while let Some(key) = map.next_key()? {
+                    match key {
+                        Field::Name => {
+                            if name.is_some() {
+                                return Err(de::Error::duplicate_field("name"));
+                            }
+                            name = Some(map.next_value()?);
+                        }
+                        Field::Source => {
+                            if source.is_some() {
+                                return Err(de::Error::duplicate_field("source"));
+                            }
+                            source = Some(map.next_value()?);
+                        }
+                        Field::Build => {
+                            if build.is_some() {
+                                return Err(de::Error::duplicate_field("build"));
+                            }
+                            build = Some(map.next_value()?);
+                        }
+                        Field::Requirements => {
+                            if requirements.is_some() {
+                                return Err(de::Error::duplicate_field("requirements"));
+                            }
+                            requirements = Some(map.next_value()?);
+                        }
+                        Field::RunExports => {
+                            if run_exports.is_some() {
+                                return Err(de::Error::duplicate_field("run_exports"));
+                            }
+                            run_exports = Some(map.next_value()?);
+                        }
+                        Field::IgnoreRunExports => {
+                            if ignore_run_exports.is_some() {
+                                return Err(de::Error::duplicate_field("ignore_run_exports"));
+                            }
+                            ignore_run_exports = Some(map.next_value()?);
+                        }
+                        Field::About => {
+                            if about.is_some() {
+                                return Err(de::Error::duplicate_field("about"));
+                            }
+                            about = Some(map.next_value()?);
+                        }
+                    }
+                }
+
+                let name = name.ok_or_else(|| de::Error::missing_field("name"))?;
+                let source = source.unwrap_or_else(Vec::new);
+                let build = build.ok_or_else(|| de::Error::missing_field("build"))?;
+                let requirements = requirements.unwrap_or_else(CacheRequirements::default);
+                let run_exports = run_exports.unwrap_or_else(RunExports::default);
+                let ignore_run_exports = ignore_run_exports;
+                let about = about;
+
+                Ok(CacheOutput {
+                    name,
+                    source,
+                    build,
+                    requirements,
+                    run_exports,
+                    ignore_run_exports,
+                    about,
+                    span: Span::new_blank(),
+                })
+            }
+        }
+
+        deserializer.deserialize_map(CacheOutputVisitor)
+    }
+}
+
 /// Build configuration specific to cache outputs
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct CacheBuild {
     /// The build script - only script key is allowed for cache outputs
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub script: Option<Script>,
-    /// Include files in the cache (glob patterns to select files)
+
+    /// Variant ignore and use keys for cache outputs
+    #[serde(default)]
+    pub variant: VariantKeyUsage,
+
+    /// Include files in the cache
     #[serde(default, skip_serializing_if = "GlobVec::is_empty")]
     pub files: GlobVec,
-    /// Files that are always included in the cache
+
+    /// Setting to control whether to always include a file (even if it is already present in the host env)
     #[serde(default, skip_serializing_if = "GlobVec::is_empty")]
     pub always_include_files: GlobVec,
 }
 
-impl CacheBuild {
-    /// Get the files settings for this cache build
-    pub fn files(&self) -> &GlobVec {
-        &self.files
-    }
-
-    /// Get the always_include_files settings for this cache build
-    pub fn always_include_files(&self) -> &GlobVec {
-        &self.always_include_files
-    }
-}
+impl CacheBuild {}
 
 /// Requirements specific to cache outputs (no run or run_constraints allowed)
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
@@ -114,7 +233,7 @@ impl StandardTryConvert for CacheOutput {
 
                     // Parse the name field
                     if let Some(name_value) = cache_mapping.get("name") {
-                        name = Some(parse_required_string(name_value, "name", "cache")?);
+                        name = Some(name_value.try_convert("cache.name")?);
                     }
                 }
                 "source" => {
@@ -135,21 +254,13 @@ impl StandardTryConvert for CacheOutput {
                 "about" => {
                     about = Some(value.try_convert("cache.about")?);
                 }
-                "inherit" => {
-                    return Err(vec![invalid_field_error(
-                        *key.span(),
-                        key.as_str(),
-                        Some(
-                            "cache outputs cannot use 'inherit' - caches must be built from scratch and cannot inherit from packages or other caches",
-                        ),
-                    )]);
-                }
+                "inherit" => {}
                 _ => {
                     return Err(vec![invalid_field_error(
                         *key.span(),
                         key.as_str(),
                         Some(
-                            "valid fields for cache outputs are: 'cache', 'source', 'build', 'requirements', 'run_exports', 'ignore_run_exports', and 'about'",
+                            "valid fields for cache outputs are: 'cache', 'source', 'build', 'requirements', 'run_exports', 'ignore_run_exports', 'about', and 'inherit'",
                         ),
                     )]);
                 }
@@ -185,7 +296,7 @@ impl StandardTryConvert for CacheOutput {
     }
 }
 
-/// Parse cache build section, ensuring only allowed keys are present
+/// Parse cache build section
 fn parse_cache_build(value: &RenderedNode) -> Result<CacheBuild, Vec<PartialParsingError>> {
     let build_node = value
         .as_mapping()
@@ -193,17 +304,21 @@ fn parse_cache_build(value: &RenderedNode) -> Result<CacheBuild, Vec<PartialPars
 
     let mut build = CacheBuild::default();
 
-    // Validate allowed keys
+    let allowed_keys = ["script", "variant", "files", "always_include_files"];
     validate_mapping_keys(
         build_node,
-        &["script", "files", "always_include_files"],
-        "cache build section (only 'script', 'files', and 'always_include_files' are allowed)",
+        &allowed_keys,
+        "cache build section (valid keys are 'script', 'variant', 'files', 'always_include_files')",
     )?;
 
     if let Some(script_value) = build_node.get("script") {
         build.script = Some(script_value.try_convert("cache.build.script")?);
     }
 
+    if let Some(variant_value) = build_node.get("variant") {
+        build.variant = variant_value.try_convert("cache.build.variant")?;
+    }
+
     if let Some(files_value) = build_node.get("files") {
         build.files = files_value.try_convert("cache.build.files")?;
     }
diff --git a/src/recipe/parser/common_output.rs b/src/recipe/parser/common_output.rs
index 392bee85a..453cb51ad 100644
--- a/src/recipe/parser/common_output.rs
+++ b/src/recipe/parser/common_output.rs
@@ -24,6 +24,9 @@ pub enum InheritSpec {
         /// Whether to inherit run_exports (default: true)
         #[serde(default = "default_true")]
         run_exports: bool,
+        /// Whether to inherit requirements (default: false)
+        #[serde(default)]
+        requirements: bool,
     },
 }
 
@@ -47,6 +50,14 @@ impl InheritSpec {
             InheritSpec::Long { run_exports, .. } => *run_exports,
         }
     }
+
+    /// Check if requirements should be inherited
+    pub fn inherit_requirements(&self) -> bool {
+        match self {
+            InheritSpec::Short(_) => false,
+            InheritSpec::Long { requirements, .. } => *requirements,
+        }
+    }
 }
 
 impl TryConvertNode<InheritSpec> for RenderedNode {
@@ -60,6 +71,7 @@ impl TryConvertNode<InheritSpec> for RenderedNode {
         if let Some(mapping) = self.as_mapping() {
             let mut from = None;
             let mut run_exports = true;
+            let mut requirements = false;
 
             for (key, value) in mapping.iter() {
                 match key.as_str() {
@@ -94,6 +106,22 @@ impl TryConvertNode<InheritSpec> for RenderedNode {
                             )]
                         })?;
                     }
+                    "requirements" => {
+                        let scalar = value.as_scalar().ok_or_else(|| {
+                            vec![_partialerror!(
+                                *value.span(),
+                                ErrorKind::ExpectedScalar,
+                                help = "expected a boolean"
+                            )]
+                        })?;
+                        requirements = scalar.as_bool().ok_or_else(|| {
+                            vec![_partialerror!(
+                                *value.span(),
+                                ErrorKind::ExpectedScalar,
+                                help = "expected a boolean"
+                            )]
+                        })?;
+                    }
                     _ => {
                         return Err(vec![_partialerror!(
                             *key.span(),
@@ -111,7 +139,11 @@ impl TryConvertNode<InheritSpec> for RenderedNode {
                 )]
             })?;
 
-            return Ok(InheritSpec::Long { from, run_exports });
+            return Ok(InheritSpec::Long {
+                from,
+                run_exports,
+                requirements,
+            });
         }
 
         Err(vec![_partialerror!(
diff --git a/src/recipe/parser/output.rs b/src/recipe/parser/output.rs
index 80786bc40..8ce859155 100644
--- a/src/recipe/parser/output.rs
+++ b/src/recipe/parser/output.rs
@@ -5,6 +5,7 @@
 //! `test`, and `about` fields.
 
 use marked_yaml::types::MarkedMappingNode;
+use std::collections::{HashMap, HashSet};
 
 use crate::{
     _partialerror,
@@ -16,6 +17,8 @@ use crate::{
     source_code::SourceCode,
 };
 
+use rattler_conda_types::PackageName;
+
 use super::common_output::{
     ALLOWED_KEYS_MULTI_OUTPUTS, DEEP_MERGE_KEYS, extract_recipe_version_marked,
     merge_mapping_if_not_exists,
@@ -31,6 +34,34 @@ type CacheInheritanceResult = Result<
     ParsingError<&'static str>,
 >;
 
+// Extract inherit information
+fn inherit_name_from(node: &Node) -> Option<String> {
+    node.as_scalar()
+        .map(|s| s.as_str().to_string())
+        .or_else(|| {
+            node.as_mapping()?
+                .get("from")?
+                .as_scalar()
+                .map(|s| s.as_str().to_string())
+        })
+}
+
+fn pkg_inherit_node(output: &Node) -> Option<&Node> {
+    output
+        .as_mapping()?
+        .get("package")?
+        .as_mapping()?
+        .get("inherit")
+}
+
+fn cache_inherit_node(output: &Node) -> Option<&Node> {
+    output
+        .as_mapping()?
+        .get("cache")?
+        .as_mapping()?
+        .get("inherit")
+}
+
 // Check if the `cache` top-level key is present. If it does not contain a
 // source, but there is a top-level `source` key, then we should warn the user
 // because this key was moved to the `cache`
@@ -124,7 +155,9 @@ pub fn find_outputs_from_src<S: SourceCode>(src: S) -> Result<Vec<Node>, Parsing
                     let missing_script = outputs_seq.iter().any(|output| {
                         output
                             .as_mapping()
-                            .and_then(|mapping| mapping.get("cache").or_else(|| mapping.get("package")))
+                            .and_then(|mapping| {
+                                mapping.get("cache").or_else(|| mapping.get("package"))
+                            })
                             .map(|subnode| {
                                 subnode
                                     .as_mapping()
@@ -135,14 +168,13 @@ pub fn find_outputs_from_src<S: SourceCode>(src: S) -> Result<Vec<Node>, Parsing
                     });
 
                     if missing_script {
-                        let key = outputs_value
-                            .span();
+                        let key = outputs_value.span();
                         return Err(ParsingError::from_partial(
                             src,
                             _partialerror!(
                                 *key,
                                 ErrorKind::MissingField("build.script".into()),
-                                help = "Multi-output recipes must specify `build.script` for each output; implicit build/script.sh is not supported"
+                                help = "Multi-output recipes must specify `build.script` for each output; implicit build/script.sh is not supported. This is a breaking change from single-output recipes that default to script.sh."
                             ),
                         ));
                     }
@@ -268,31 +300,28 @@ pub fn find_outputs_from_src<S: SourceCode>(src: S) -> Result<Vec<Node>, Parsing
             .and_then(|pkg_map| pkg_map.get("inherit"));
 
         match inherit_spec {
-            Some(inherit_node) if inherit_node.is_null() => {}
-            Some(_) => {
-            }
+            Some(inherit_node)
+                if inherit_node
+                    .as_scalar()
+                    .is_some_and(|s| s.as_str().is_empty()) => {}
+            Some(_) => {}
             None => {
-                if let Some(req_node) = output_map.get("requirements") {
-                    return Err(ParsingError::from_partial(
-                        src.clone(),
-                        _partialerror!(
-                            *req_node.span(),
-                            ErrorKind::InvalidField("requirements".to_string().into()),
-                            help = "When inheriting from top-level, outputs must not define `requirements`."
-                        ),
-                    ));
+                // When inheriting from top-level, requirements and build.script are ignored (not forbidden)
+                // rather than throwing errors, we just warn about them
+                if let Some(_req_node) = output_map.get("requirements") {
+                    tracing::warn!(
+                        "When inheriting from top-level, the `requirements` field will be ignored. \
+                         The output will inherit all requirements from the top-level recipe."
+                    );
                 }
                 if let Some(build_node) = output_map.get("build") {
                     if let Some(build_map) = build_node.as_mapping() {
                         if build_map.contains_key("script") {
-                            return Err(ParsingError::from_partial(
-                                src.clone(),
-                                _partialerror!(
-                                    *build_node.span(),
-                                    ErrorKind::InvalidField("build.script".to_string().into()),
-                                    help = "When inheriting from top-level, outputs must not define `build.script`."
-                                ),
-                            ));
+                            tracing::warn!(
+                                "When inheriting from top-level (implicit inheritance), the `build.script` field will be ignored. \
+                                 This is a breaking change from older versions where explicit script definitions in output were used. \
+                                 The output will use the top-level recipe's build script instead."
+                            );
                         }
                     }
                 }
@@ -318,21 +347,24 @@ pub fn resolve_cache_inheritance(
     outputs: Vec<Node>,
     has_toplevel_cache: bool,
 ) -> Result<Vec<Node>, ParsingError<&'static str>> {
-    use std::collections::HashSet;
+    use std::collections::{HashMap, HashSet};
 
     // Collect cache names from outputs array
     let mut cache_names = HashSet::new();
     let mut duplicate_caches = Vec::new();
-
-    let mut cache_name_spans = std::collections::HashMap::new();
+    let mut cache_name_spans = HashMap::new();
+    let mut cache_inheritance = HashMap::new();
 
     for output in outputs.iter() {
         if let Some(cache_output) = parse_cache_output_from_node(output)? {
-            let cache_name = cache_output.name.clone();
+            let cache_name = cache_output.name.as_normalized().to_string();
             if !cache_names.insert(cache_name.clone()) {
                 duplicate_caches.push(cache_name);
             } else {
-                cache_name_spans.insert(cache_output.name.clone(), cache_output.span);
+                cache_name_spans.insert(
+                    cache_output.name.as_normalized().to_string(),
+                    cache_output.span,
+                );
             }
         }
     }
@@ -350,64 +382,179 @@ pub fn resolve_cache_inheritance(
         ));
     }
 
+    // Validate package outputs inheriting from cache outputs
     for output in outputs.iter() {
-        if let Some(mapping) = output.as_mapping() {
-            if mapping.contains_key("package") {
-                if let Some(package_node) = mapping.get("package") {
-                    if let Some(package_mapping) = package_node.as_mapping() {
-                        if let Some(inherit_node) = package_mapping.get("inherit") {
-                            let cache_name = if let Some(inherit_scalar) = inherit_node.as_scalar()
-                            {
-                                inherit_scalar.as_str().to_string()
-                            } else if let Some(inherit_mapping) = inherit_node.as_mapping() {
-                                if let Some(from_node) = inherit_mapping.get("from") {
-                                    if let Some(from_scalar) = from_node.as_scalar() {
-                                        from_scalar.as_str().to_string()
-                                    } else {
-                                        continue;
-                                    }
-                                } else {
-                                    continue;
-                                }
-                            } else {
-                                continue;
-                            };
+        let Some(cache_name) = pkg_inherit_node(output).and_then(inherit_name_from) else {
+            continue;
+        };
 
-                            // Check if cache exists (in outputs array)
-                            // Note: Explicit inheritance takes precedence over top-level cache.
-                            // If an output explicitly inherits from a named cache, it must exist
-                            // in the outputs array.
-                            if !cache_names.contains(&cache_name) {
-                                let available: Vec<_> =
-                                    cache_names.iter().map(|n| format!("'{}'", n)).collect();
-                                let help_msg = if available.is_empty() {
-                                    if has_toplevel_cache {
-                                        "No cache outputs defined in outputs array. To use top-level cache, omit the 'inherit' key.".to_string()
-                                    } else {
-                                        "No cache outputs defined".to_string()
-                                    }
-                                } else {
-                                    format!("Available caches: {}", available.join(", "))
-                                };
-                                return Err(ParsingError::from_partial(
-                                    "",
-                                    _partialerror!(
-                                        *output.span(),
-                                        ErrorKind::InvalidField(
-                                            format!("cache '{}' not found", cache_name).into()
-                                        ),
-                                        help = help_msg
-                                    ),
-                                ));
-                            }
-                        }
+        // Check if cache exists (in outputs array)
+        // Note: Explicit inheritance takes precedence over top-level cache.
+        // If an output explicitly inherits from a named cache, it must exist
+        // in the outputs array.
+        if !cache_names.contains(&cache_name) {
+            let available: Vec<_> = cache_names.iter().map(|n| format!("'{}'", n)).collect();
+            let help_msg = if available.is_empty() {
+                if has_toplevel_cache {
+                    "No cache outputs defined in outputs array. To use top-level cache, omit the 'inherit' key.".to_string()
+                } else {
+                    "No cache outputs defined".to_string()
+                }
+            } else {
+                format!("Available caches: {}", available.join(", "))
+            };
+            return Err(ParsingError::from_partial(
+                "",
+                _partialerror!(
+                    *output.span(),
+                    ErrorKind::InvalidField(format!("cache '{}' not found", cache_name).into()),
+                    help = help_msg
+                ),
+            ));
+        }
+    }
+
+    for output in outputs.iter() {
+        let Some(cache_mapping) = output
+            .as_mapping()
+            .and_then(|mapping| mapping.get("cache"))
+            .and_then(|cache_node| cache_node.as_mapping())
+        else {
+            continue;
+        };
+
+        let Some(inherit_node) = cache_mapping.get("inherit") else {
+            continue;
+        };
+
+        let Some(cache_name_to_inherit) = inherit_name_from(inherit_node) else {
+            continue;
+        };
+
+        let Some(this_cache_name) = cache_mapping
+            .get("name")
+            .and_then(|name_node| name_node.as_scalar())
+            .map(|name_scalar| name_scalar.as_str().to_string())
+        else {
+            continue;
+        };
+
+        // Cache outputs can only inherit from other cache outputs, not from package outputs
+        // Check if the cache to inherit from exists in the cache names we collected
+        if !cache_names.contains(&cache_name_to_inherit) {
+            let available: Vec<_> = cache_names.iter().map(|n| format!("'{}'", n)).collect();
+            let help_msg = if available.is_empty() {
+                "No cache outputs defined".to_string()
+            } else {
+                format!("Available caches: {}", available.join(", "))
+            };
+            return Err(ParsingError::from_partial(
+                "",
+                _partialerror!(
+                    *output.span(),
+                    ErrorKind::InvalidField(
+                        format!(
+                            "cache '{}' not found for cache inheritance",
+                            cache_name_to_inherit
+                        )
+                        .into()
+                    ),
+                    help = help_msg
+                ),
+            ));
+        }
+
+        // Store the inheritance relationship for cycle detection
+        cache_inheritance
+            .entry(this_cache_name.clone())
+            .or_insert_with(Vec::new)
+            .push(cache_name_to_inherit.clone());
+    }
+
+    // Detect cycles in cache-to-cache inheritance
+    if let Some(cycle) = detect_cache_inheritance_cycles(&cache_inheritance) {
+        return Err(ParsingError::from_partial(
+            "",
+            _partialerror!(
+                marked_yaml::Span::new_blank(),
+                ErrorKind::InvalidField(
+                    format!("cache inheritance cycle detected: {}", cycle.join(" -> ")).into()
+                ),
+                help = "Cache outputs cannot form inheritance cycles"
+            ),
+        ));
+    }
+
+    Ok(outputs)
+}
+
+/// Detect cycles in cache inheritance relationships using DFS
+fn detect_cache_inheritance_cycles(
+    inheritance: &HashMap<String, Vec<String>>,
+) -> Option<Vec<String>> {
+    let mut visited = std::collections::HashMap::new();
+    let mut recursion_stack = std::collections::HashMap::new();
+    let mut parent = std::collections::HashMap::new();
+
+    for cache_name in inheritance.keys() {
+        if !(*visited.get(cache_name).unwrap_or(&false)) {
+            let path = dfs_visit(
+                cache_name,
+                inheritance,
+                &mut visited,
+                &mut recursion_stack,
+                &mut parent,
+            );
+            if let Some(cycle_path) = path {
+                return Some(cycle_path);
+            }
+        }
+    }
+    None
+}
+
+/// Depth-first search to find cycles
+fn dfs_visit(
+    cache: &str,
+    inheritance: &HashMap<String, Vec<String>>,
+    visited: &mut std::collections::HashMap<String, bool>,
+    recursion_stack: &mut std::collections::HashMap<String, bool>,
+    parent: &mut std::collections::HashMap<String, String>,
+) -> Option<Vec<String>> {
+    visited.insert(cache.to_string(), true);
+    recursion_stack.insert(cache.to_string(), true);
+
+    if let Some(dependencies) = inheritance.get(cache) {
+        for dependency in dependencies {
+            if !(*visited.get(dependency).unwrap_or(&false)) {
+                parent.insert(dependency.clone(), cache.to_string());
+                if let Some(cycle) =
+                    dfs_visit(dependency, inheritance, visited, recursion_stack, parent)
+                {
+                    return Some(cycle);
+                }
+            } else if *recursion_stack.get(dependency).unwrap_or(&false) {
+                let mut cycle = vec![dependency.clone()];
+                let mut current = cache.to_string();
+
+                while current != *dependency {
+                    cycle.push(current.clone());
+                    if let Some(parent_cache) = parent.get(&current) {
+                        current = parent_cache.clone();
+                    } else {
+                        break;
                     }
                 }
+                cycle.push(dependency.clone());
+                cycle.reverse();
+
+                return Some(cycle);
             }
         }
     }
 
-    Ok(outputs)
+    recursion_stack.insert(cache.to_string(), false);
+    None
 }
 
 /// Parse a cache output from a Node using proper TryConvertNode
@@ -424,7 +571,19 @@ fn parse_cache_output_from_node(
                 if let Some(cache_mapping) = cache_node.as_mapping() {
                     let name = if let Some(name_node) = cache_mapping.get("name") {
                         if let Some(name_scalar) = name_node.as_scalar() {
-                            Some(name_scalar.as_str().to_string())
+                            match PackageName::try_from(name_scalar.as_str().to_string()) {
+                                Ok(package_name) => package_name,
+                                Err(err) => {
+                                    return Err(ParsingError::from_partial(
+                                        "",
+                                        _partialerror!(
+                                            *name_node.span(),
+                                            ErrorKind::from(err),
+                                            help = "cache name must be a valid package name"
+                                        ),
+                                    ));
+                                }
+                            }
                         } else {
                             return Err(ParsingError::from_partial(
                                 "",
@@ -436,17 +595,31 @@ fn parse_cache_output_from_node(
                             ));
                         }
                     } else {
-                        None
+                        match PackageName::try_from("default".to_string()) {
+                            Ok(package_name) => package_name,
+                            Err(_) => {
+                                return Err(ParsingError::from_partial(
+                                    "",
+                                    _partialerror!(
+                                        marked_yaml::Span::new_blank(),
+                                        ErrorKind::InvalidField("default".to_string().into()),
+                                        help = "internal error: default cache name is invalid"
+                                    ),
+                                ));
+                            }
+                        }
                     };
 
                     // For now, create a basic cache output with defaults
                     return Ok(Some(crate::recipe::parser::CacheOutput {
-                        name: name.unwrap_or_else(|| "default".to_string()),
+                        name,
                         source: Vec::new(),
                         build: crate::recipe::parser::CacheBuild::default(),
                         requirements: crate::recipe::parser::CacheRequirements::default(),
                         run_exports: crate::recipe::parser::RunExports::default(),
                         ignore_run_exports: None,
+                        about: None,
+                        span: *output.span(),
                     }));
                 }
             }
@@ -549,68 +722,103 @@ fn parse_cache_outputs_with_context(
     Ok(cache_outputs)
 }
 
-/// Apply cache inheritance to package outputs during parsing
-fn apply_inheritance_to_outputs(
+/// Parse cache-to-cache inheritance relationships from outputs
+fn parse_cache_to_cache_inheritance(
     outputs: &[Node],
-    cache_outputs: &[crate::recipe::parser::CacheOutput],
-    inheritance_relationships: &std::collections::HashMap<String, Vec<String>>,
-    jinja: &crate::recipe::Jinja,
-) -> Result<Vec<Node>, ParsingError<&'static str>> {
-    use super::output_parser::OutputType;
-    let mut resolved_outputs = Vec::new();
+) -> Result<HashMap<String, Vec<String>>, ParsingError<&'static str>> {
+    let mut relationships: HashMap<String, Vec<String>> = HashMap::new();
 
     for output in outputs {
-        let rendered_node: RenderedNode = output.render(jinja, "output").map_err(|e| {
-            ParsingError::from_partial_vec("", e)
-                .into_iter()
-                .next()
-                .unwrap_or_else(|| {
-                    ParsingError::from_partial(
-                        "",
-                        _partialerror!(
-                            marked_yaml::Span::new_blank(),
-                            ErrorKind::ExpectedMapping,
-                            help = "Failed to render output for inheritance resolution"
-                        ),
+        if let Some(mapping) = output
+            .as_mapping()
+            .and_then(|m| m.get("cache"))
+            .and_then(|c| c.as_mapping())
+        {
+            let cache_name = mapping
+                .get("name")
+                .and_then(|n| n.as_scalar())
+                .map(|s| s.as_str().to_string());
+
+            let inherited_name = mapping.get("inherit").and_then(|inherit| {
+                inherit
+                    .as_scalar()
+                    .map(|s| s.as_str().to_string())
+                    .or_else(|| {
+                        inherit
+                            .as_mapping()
+                            .and_then(|m| m.get("from"))
+                            .and_then(|f| f.as_scalar())
+                            .map(|s| s.as_str().to_string())
+                    })
+            });
+
+            if let (Some(cache_name), Some(inherited_name)) = (cache_name, inherited_name) {
+                relationships
+                    .entry(cache_name)
+                    .or_default()
+                    .push(inherited_name);
+            }
+        }
+    }
+
+    Ok(relationships)
+}
+
+/// Apply cache-to-cache inheritance to the cache outputs
+fn apply_cache_to_cache_inheritance(
+    cache_outputs: Vec<crate::recipe::parser::CacheOutput>,
+    cache_inheritance_relationships: HashMap<String, Vec<String>>,
+) -> Vec<crate::recipe::parser::CacheOutput> {
+    let mut cache_map: HashMap<String, crate::recipe::parser::CacheOutput> = cache_outputs
+        .into_iter()
+        .map(|cache| (cache.name.as_normalized().to_string(), cache))
+        .collect();
+
+    for (cache_name, ancestors) in cache_inheritance_relationships {
+        let ancestor_data: Vec<_> = ancestors
+            .iter()
+            .filter_map(|ancestor_name| {
+                cache_map.get(ancestor_name).map(|ancestor_cache| {
+                    (
+                        ancestor_cache.run_exports.clone(),
+                        ancestor_cache.about.clone(),
+                        ancestor_cache.ignore_run_exports.clone(),
+                        ancestor_cache.requirements.build.clone(),
+                        ancestor_cache.requirements.host.clone(),
                     )
                 })
-        })?;
+            })
+            .collect();
+
+        if let Some(target_cache) = cache_map.get_mut(&cache_name) {
+            for (run_exports, about, ignore_run_exports, build_reqs, host_reqs) in ancestor_data {
+                // Apply inheritance from ancestor cache
+                target_cache.run_exports.extend_from(&run_exports);
+
+                // Inherit about section
+                if let Some(ancestor_about) = about {
+                    target_cache
+                        .about
+                        .get_or_insert_with(|| ancestor_about.clone())
+                        .merge_from(&ancestor_about);
+                }
 
-        match rendered_node.try_convert("output") {
-            Ok(OutputType::Package(mut package_output)) => {
-                let package_name = package_output.package.name().as_normalized().to_string();
-                if let Some(cache_names) = inheritance_relationships.get(&package_name) {
-                    for cache_name in cache_names {
-                        if let Some(cache_output) =
-                            cache_outputs.iter().find(|c| &c.name == cache_name)
-                        {
-                            package_output.apply_cache_inheritance(cache_output);
-                        }
-                    }
+                // Inherit ignore_run_exports
+                if let Some(ancestor_ignore) = ignore_run_exports {
+                    target_cache
+                        .ignore_run_exports
+                        .get_or_insert_with(|| ancestor_ignore.clone())
+                        .merge_from(&ancestor_ignore);
                 }
-                let rendered = serde_yaml::to_value(&package_output)
-                    .map_err(|err| ParsingError::from_partial(
-                        "",
-                        _partialerror!(
-                            marked_yaml::Span::new_blank(),
-                            ErrorKind::Other,
-                            label = format!("Failed to serialize inherited output: {}", err)
-                        ),
-                    ))?;
-                let node = Node::try_from(rendered)
-                    .map_err(|err| ParsingError::from_partial("", err))?;
-                resolved_outputs.push(node);
-            }
-            Ok(OutputType::Cache(_)) => {
-                resolved_outputs.push(output.clone());
-            }
-            Err(_) => {
-                resolved_outputs.push(output.clone());
+
+                // Inherit requirements (build and host)
+                target_cache.requirements.build.extend(build_reqs);
+                target_cache.requirements.host.extend(host_reqs);
             }
         }
     }
 
-    Ok(resolved_outputs)
+    cache_map.into_values().collect()
 }
 
 /// Resolve cache inheritance and return both outputs and cache outputs
@@ -655,20 +863,104 @@ pub fn resolve_cache_inheritance_with_caches(
         }
     }
 
+    // Parse caches with context first
     let all_cache_outputs = parse_cache_outputs_with_context(&outputs, jinja)?;
-    let inheritance_relationships = parse_inheritance_relationships(&outputs)?;
-    let resolved_outputs = apply_inheritance_to_outputs(
-        &outputs,
-        &all_cache_outputs,
-        &inheritance_relationships,
-        jinja,
-    )?;
-
-    Ok((
-        resolved_outputs,
+
+    // Duplicate detection using a set (no nesting)
+    let mut seen = HashSet::new();
+    let mut duplicates = Vec::new();
+    for name in all_cache_outputs
+        .iter()
+        .map(|c| c.name.as_normalized().to_string())
+    {
+        if !seen.insert(name.clone()) {
+            duplicates.push(name);
+        }
+    }
+    if !duplicates.is_empty() {
+        return Err(ParsingError::from_partial(
+            "",
+            _partialerror!(
+                marked_yaml::Span::new_blank(),
+                ErrorKind::InvalidField(
+                    format!("duplicate cache names: {}", duplicates.join(", ")).into()
+                ),
+                help = "Each cache output must have a unique name"
+            ),
+        ));
+    }
+    let cache_names: HashSet<_> = seen;
+
+    // Validate package -> cache inheritance using iterator chains
+    if let Some((bad_output, bad_name)) = outputs
+        .iter()
+        .filter_map(|o| pkg_inherit_node(o).map(|n| (o, n)))
+        .filter_map(|(o, n)| inherit_name_from(n).map(|name| (o, name)))
+        .find(|(_, name)| !cache_names.contains(name))
+    {
+        let help_msg = if cache_names.is_empty() {
+            if has_toplevel_cache {
+                "No cache outputs defined in outputs array. To use top-level cache, omit the 'inherit' key.".to_string()
+            } else {
+                "No cache outputs defined".to_string()
+            }
+        } else {
+            format!(
+                "Available caches: {}",
+                cache_names
+                    .iter()
+                    .map(|n| format!("'{}'", n))
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            )
+        };
+        return Err(ParsingError::from_partial(
+            "",
+            _partialerror!(
+                *bad_output.span(),
+                ErrorKind::InvalidField(format!("cache '{}' not found", bad_name).into()),
+                help = help_msg
+            ),
+        ));
+    }
+
+    // Validate cache -> cache inheritance using iterator chains
+    if let Some((bad_output, bad_name)) = outputs
+        .iter()
+        .filter_map(|o| cache_inherit_node(o).map(|n| (o, n)))
+        .filter_map(|(o, n)| inherit_name_from(n).map(|name| (o, name)))
+        .find(|(_, name)| !cache_names.contains(name))
+    {
+        let help_msg = format!(
+            "Available caches: {}",
+            cache_names
+                .iter()
+                .map(|n| format!("'{}'", n))
+                .collect::<Vec<_>>()
+                .join(", ")
+        );
+        return Err(ParsingError::from_partial(
+            "",
+            _partialerror!(
+                *bad_output.span(),
+                ErrorKind::InvalidField(
+                    format!("cache '{}' not found for cache inheritance", bad_name).into()
+                ),
+                help = help_msg
+            ),
+        ));
+    }
+
+    // Cache-to-cache graph + application
+    let cache_to_cache_inheritance_relationships = parse_cache_to_cache_inheritance(&outputs)?;
+    let inherited_cache_outputs = apply_cache_to_cache_inheritance(
         all_cache_outputs,
-        inheritance_relationships,
-    ))
+        cache_to_cache_inheritance_relationships,
+    );
+
+    let inheritance_relationships = parse_inheritance_relationships(&outputs)?;
+
+    Ok((outputs, inherited_cache_outputs, inheritance_relationships))
 }
 
 #[cfg(test)]
diff --git a/src/recipe/parser/output_parser.rs b/src/recipe/parser/output_parser.rs
index d3cb39e9f..fb82992c8 100644
--- a/src/recipe/parser/output_parser.rs
+++ b/src/recipe/parser/output_parser.rs
@@ -167,12 +167,39 @@ impl Output {
 
     /// Apply inheritance from a cache output
     pub fn apply_cache_inheritance(&mut self, cache: &CacheOutput) {
-        if let Some(inherit_spec) = &self.inherit {
-            if inherit_spec.inherit_run_exports() {
-                if let Some(cache_ignore) = &cache.ignore_run_exports {
-                    self.requirements.ignore_run_exports =
-                        self.requirements.ignore_run_exports(Some(cache_ignore));
-                }
+        let should_inherit_run_exports = if let Some(inherit_spec) = &self.inherit {
+            if inherit_spec.inherit_requirements() {
+                self.requirements
+                    .build
+                    .extend(cache.requirements.build.iter().cloned());
+                self.requirements
+                    .host
+                    .extend(cache.requirements.host.iter().cloned());
+            }
+            inherit_spec.inherit_run_exports()
+        } else {
+            true
+        };
+
+        if should_inherit_run_exports {
+            self.requirements
+                .run_exports
+                .extend_from(&cache.run_exports);
+        }
+
+        if let Some(cache_ignore) = &cache.ignore_run_exports {
+            self.requirements.ignore_run_exports =
+                self.requirements.ignore_run_exports(Some(cache_ignore));
+        }
+
+        // Deep merge the build section from cache, excluding the script
+        let cache_build_for_merge = Build::default();
+        self.build.merge_from(&cache_build_for_merge);
+        if let Some(cache_about) = &cache.about {
+            if self.about.is_none() {
+                self.about = Some(cache_about.clone());
+            } else if let Some(ref mut about) = self.about {
+                about.merge_from(cache_about);
             }
         }
 
diff --git a/src/recipe/parser/requirements.rs b/src/recipe/parser/requirements.rs
index 860c9b62f..afae1db32 100644
--- a/src/recipe/parser/requirements.rs
+++ b/src/recipe/parser/requirements.rs
@@ -558,6 +558,12 @@ impl IgnoreRunExports {
     pub fn is_empty(&self) -> bool {
         self.by_name.is_empty() && self.from_package.is_empty()
     }
+
+    /// Merge IgnoreRunExports with another
+    pub fn merge_from(&mut self, other: &IgnoreRunExports) {
+        self.by_name.extend(other.by_name.iter().cloned());
+        self.from_package.extend(other.from_package.iter().cloned());
+    }
 }
 
 impl TryConvertNode<IgnoreRunExports> for RenderedNode {
diff --git a/src/render/resolved_dependencies.rs b/src/render/resolved_dependencies.rs
index 18da40cf7..3fd4c6b23 100644
--- a/src/render/resolved_dependencies.rs
+++ b/src/render/resolved_dependencies.rs
@@ -753,7 +753,10 @@ pub(crate) async fn resolve_dependencies(
             compatibility_specs.insert(r.package_record.name.clone(), r.package_record.clone());
         });
 
-        Some(ResolvedDependencies { specs: build_env_specs, resolved })
+        Some(ResolvedDependencies {
+            specs: build_env_specs,
+            resolved,
+        })
     };
 
     // host env
@@ -873,7 +876,6 @@ pub(crate) async fn resolve_dependencies(
         false,
     )?;
 
-
     let rendered_run_exports = render_run_exports(output, &compatibility_specs)?;
 
     let mut host_run_exports = HashMap::new();
diff --git a/src/source/copy_dir.rs b/src/source/copy_dir.rs
index 85ab38804..c591ef9fe 100644
--- a/src/source/copy_dir.rs
+++ b/src/source/copy_dir.rs
@@ -15,6 +15,8 @@ use crate::recipe::parser::{GlobVec, GlobWithSource};
 
 use super::SourceError;
 
+type OverwriteCallback = dyn Fn(&Path) + Send + Sync + 'static;
+
 /// The copy options for the copy_dir function.
 pub struct CopyOptions {
     /// Overwrite files if they already exist (default: false)
@@ -24,7 +26,7 @@ pub struct CopyOptions {
     /// Buffer size for copying files (default: 8 MiB)
     pub buffer_size: usize,
     /// Optional callback invoked when a destination file is about to be overwritten
-    pub on_overwrite: Option<Box<dyn Fn(&Path) + Send + Sync + 'static>>,
+    pub on_overwrite: Option<Box<OverwriteCallback>>,
 }
 
 impl Default for CopyOptions {
diff --git a/src/variant_render.rs b/src/variant_render.rs
index 5b1218cf0..057320fdc 100644
--- a/src/variant_render.rs
+++ b/src/variant_render.rs
@@ -115,7 +115,9 @@ pub(crate) fn stage_0_render<S: SourceCode>(
             if let Some(caches) = inheritance_relationships.get(&package_name) {
                 let mut cache_list = Vec::new();
                 for cache_name in caches {
-                    if let Some(cache_output) = cache_outputs.iter().find(|c| &c.name == cache_name)
+                    if let Some(cache_output) = cache_outputs
+                        .iter()
+                        .find(|c| c.name.as_normalized() == cache_name.as_str())
                     {
                         cache_list.push(cache_output.clone());
                     }
@@ -365,6 +367,33 @@ pub(crate) fn stage_1_render<S: SourceCode>(
                 additional_variables.extend(cache_use_keys);
             }
 
+            // Add variant keys from specific cache outputs referenced via inherit
+            for cache_output in &output.cache_outputs {
+                for dep in &cache_output.requirements.build {
+                    if let crate::recipe::parser::Dependency::Spec(spec) = dep {
+                        if spec.version.is_none() && spec.build.is_none() {
+                            if let Some(name) = &spec.name {
+                                additional_variables.insert(name.as_normalized().into());
+                            }
+                        }
+                    }
+                }
+
+                for dep in &cache_output.requirements.host {
+                    if let crate::recipe::parser::Dependency::Spec(spec) = dep {
+                        if spec.version.is_none() && spec.build.is_none() {
+                            if let Some(name) = &spec.name {
+                                additional_variables.insert(name.as_normalized().into());
+                            }
+                        }
+                    }
+                }
+
+                for key in &cache_output.build.variant.use_keys {
+                    additional_variables.insert(key.as_str().into());
+                }
+            }
+
             // We want to add something to packages that are requiring a subpackage
             // _exactly_ because that creates additional variants
             for pin in output.requirements.all_pin_subpackage() {
@@ -387,6 +416,33 @@ pub(crate) fn stage_1_render<S: SourceCode>(
 
             additional_variables.extend(extra_use_keys);
 
+            // Add variant keys from specific cache outputs referenced via inherit
+            for cache_output in &output.cache_outputs {
+                for dep in &cache_output.requirements.build {
+                    if let crate::recipe::parser::Dependency::Spec(spec) = dep {
+                        if spec.version.is_none() && spec.build.is_none() {
+                            if let Some(name) = &spec.name {
+                                additional_variables.insert(name.as_normalized().into());
+                            }
+                        }
+                    }
+                }
+
+                for dep in &cache_output.requirements.host {
+                    if let crate::recipe::parser::Dependency::Spec(spec) = dep {
+                        if spec.version.is_none() && spec.build.is_none() {
+                            if let Some(name) = &spec.name {
+                                additional_variables.insert(name.as_normalized().into());
+                            }
+                        }
+                    }
+                }
+
+                for key in &cache_output.build.variant.use_keys {
+                    additional_variables.insert(key.as_str().into());
+                }
+            }
+
             // If the recipe is `noarch: python` we can remove an empty python key that
             // comes from the dependencies
             if output.build().noarch().is_python() {

From e55944b109fe4f647a4ce2c982bbcf0e8e8662cb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Sat, 18 Oct 2025 03:11:59 +0300
Subject: [PATCH 08/29] fix tests

---
 src/recipe/parser/output.rs                   | 34 ----------
 ...recipe__parser__tests__recipe_windows.snap |  2 +
 ...d__recipe__parser__tests__unix_recipe.snap |  2 +
 src/render/resolved_dependencies.rs           | 67 +++++++++++++------
 4 files changed, 52 insertions(+), 53 deletions(-)

diff --git a/src/recipe/parser/output.rs b/src/recipe/parser/output.rs
index 8ce859155..5c1af3cf4 100644
--- a/src/recipe/parser/output.rs
+++ b/src/recipe/parser/output.rs
@@ -147,40 +147,6 @@ pub fn find_outputs_from_src<S: SourceCode>(src: S) -> Result<Vec<Node>, Parsing
                 ));
             }
         }
-
-        // Require explicit build scripts for multi-output recipes
-        if !root_map.contains_key("build") {
-            if let Some(outputs_value) = root_map.get("outputs") {
-                if let Some(outputs_seq) = outputs_value.as_sequence() {
-                    let missing_script = outputs_seq.iter().any(|output| {
-                        output
-                            .as_mapping()
-                            .and_then(|mapping| {
-                                mapping.get("cache").or_else(|| mapping.get("package"))
-                            })
-                            .map(|subnode| {
-                                subnode
-                                    .as_mapping()
-                                    .and_then(|mapping| mapping.get("build"))
-                                    .is_none()
-                            })
-                            .unwrap_or(true)
-                    });
-
-                    if missing_script {
-                        let key = outputs_value.span();
-                        return Err(ParsingError::from_partial(
-                            src,
-                            _partialerror!(
-                                *key,
-                                ErrorKind::MissingField("build.script".into()),
-                                help = "Multi-output recipes must specify `build.script` for each output; implicit build/script.sh is not supported. This is a breaking change from single-output recipes that default to script.sh."
-                            ),
-                        ));
-                    }
-                }
-            }
-        }
     }
 
     let Some(outputs) = root_map.get("outputs") else {
diff --git a/src/recipe/snapshots/rattler_build__recipe__parser__tests__recipe_windows.snap b/src/recipe/snapshots/rattler_build__recipe__parser__tests__recipe_windows.snap
index 823a127bc..b00126106 100644
--- a/src/recipe/snapshots/rattler_build__recipe__parser__tests__recipe_windows.snap
+++ b/src/recipe/snapshots/rattler_build__recipe__parser__tests__recipe_windows.snap
@@ -471,4 +471,6 @@ Recipe {
             String("some-maintainer"),
         ],
     },
+    cache_outputs: [],
+    cache_inheritance: {},
 }
diff --git a/src/recipe/snapshots/rattler_build__recipe__parser__tests__unix_recipe.snap b/src/recipe/snapshots/rattler_build__recipe__parser__tests__unix_recipe.snap
index 87f6d40a7..195f58ba8 100644
--- a/src/recipe/snapshots/rattler_build__recipe__parser__tests__unix_recipe.snap
+++ b/src/recipe/snapshots/rattler_build__recipe__parser__tests__unix_recipe.snap
@@ -494,4 +494,6 @@ Recipe {
             String("some-maintainer"),
         ],
     },
+    cache_outputs: [],
+    cache_inheritance: {},
 }
diff --git a/src/render/resolved_dependencies.rs b/src/render/resolved_dependencies.rs
index 3fd4c6b23..19d5e48c8 100644
--- a/src/render/resolved_dependencies.rs
+++ b/src/render/resolved_dependencies.rs
@@ -887,7 +887,18 @@ pub(crate) async fn resolve_dependencies(
     }
 
     // And filter the run exports
-    let mut host_run_exports = output_ignore_run_exports.filter(&host_run_exports, "host")?;
+    // Use cache ignore_run_exports if available, otherwise use output ignore_run_exports
+    let host_ignore_run_exports = output
+        .recipe
+        .cache
+        .as_ref()
+        .map(|cache_section| {
+            cache_section
+                .requirements
+                .ignore_run_exports(Some(&output_ignore_run_exports))
+        })
+        .unwrap_or_else(|| output_ignore_run_exports.clone());
+    let mut host_run_exports = host_ignore_run_exports.filter(&host_run_exports, "host")?;
 
     if let Some(cache) = &output.finalized_cache_dependencies {
         if let Some(cache_host_env) = &cache.host {
@@ -921,25 +932,43 @@ pub(crate) async fn resolve_dependencies(
     if let Some(cache) = &output.finalized_cache_dependencies {
         // add in the run exports from the cache
         // filter run dependencies that came from run exports
-        let ignore_run_exports = requirements.ignore_run_exports(None);
-        // Note: these run exports are already filtered
-        let _cache_run_exports = cache.run.depends.iter().filter(|c| match c {
-            DependencyInfo::RunExport(run_export) => {
-                let source_package: Option<PackageName> = run_export.source_package.parse().ok();
-                let spec_name = &run_export.spec.name;
-
-                let by_name = spec_name
-                    .as_ref()
-                    .map(|n| ignore_run_exports.by_name().contains(n))
-                    .unwrap_or(false);
-                let by_package = source_package
-                    .map(|s| ignore_run_exports.from_package().contains(&s))
-                    .unwrap_or(false);
-
-                !by_name && !by_package
+        let cache_run_exports: Vec<_> = cache
+            .run
+            .depends
+            .iter()
+            .filter(|c| match c {
+                DependencyInfo::RunExport(run_export) => {
+                    let source_package: Option<PackageName> =
+                        run_export.source_package.parse().ok();
+                    let spec_name = &run_export.spec.name;
+
+                    let by_name = spec_name
+                        .as_ref()
+                        .map(|n| output_ignore_run_exports.by_name().contains(n))
+                        .unwrap_or(false);
+                    let by_package = source_package
+                        .map(|s| output_ignore_run_exports.from_package().contains(&s))
+                        .unwrap_or(false);
+
+                    !by_name && !by_package
+                }
+                _ => false,
+            })
+            .cloned()
+            .collect();
+
+        for cache_dep in cache_run_exports {
+            let already_exists = depends.iter().any(|existing_dep| {
+                matches!((existing_dep, &cache_dep),
+                    (DependencyInfo::RunExport(existing), DependencyInfo::RunExport(cache))
+                    if existing.spec == cache.spec
+                )
+            });
+
+            if !already_exists {
+                depends.push(cache_dep);
             }
-            _ => false,
-        });
+        }
     }
 
     let run_specs = FinalizedRunDependencies {

From e533aaacd17578e7bae00bad4cb3b037869ba848 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Sat, 18 Oct 2025 15:38:40 +0300
Subject: [PATCH 09/29] unit tests

---
 src/packaging/file_finder.rs | 55 ++++++++++++++++++++++++++++++++++++
 src/recipe/parser/about.rs   | 38 +++++++++++++++++++++++++
 2 files changed, 93 insertions(+)

diff --git a/src/packaging/file_finder.rs b/src/packaging/file_finder.rs
index b420050ab..02e881684 100644
--- a/src/packaging/file_finder.rs
+++ b/src/packaging/file_finder.rs
@@ -330,6 +330,7 @@ impl TempFiles {
 mod test {
     use std::{collections::HashSet, path::PathBuf};
 
+    use super::*;
     use crate::packaging::file_finder::{check_is_case_sensitive, find_new_files};
 
     #[test]
@@ -396,4 +397,58 @@ mod test {
         // but we can verify the function doesn't panic and returns a boolean
         let _is_case_sensitive = result.unwrap();
     }
+
+    #[test]
+    fn test_from_prefix_with_filters() {
+        let temp_dir = TempDir::new().unwrap();
+        let prefix = temp_dir.path();
+        let test_files = [
+            ("bin/executable", "test"),
+            ("lib/library.so", "test"),
+            ("README.md", "test"),
+            ("config.txt", "test"),
+            ("bin/cached_executable", "cached"),
+            ("lib/cached_library.so", "cached"),
+            ("README.cached", "cached"),
+        ];
+
+        for (path, content) in &test_files {
+            if path.contains('/') {
+                fs::create_dir_all(prefix.join(path).parent().unwrap()).unwrap();
+            }
+            fs::write(prefix.join(path), content).unwrap();
+        }
+
+        let files_glob = GlobVec::from_vec(["bin/*", "lib/*"].to_vec(), None);
+        let always_include_glob = GlobVec::from_vec(["README.*"].to_vec(), None);
+        let cache_files = vec![
+            "bin/cached_executable".into(),
+            "lib/cached_library.so".into(),
+            "README.cached".into(),
+        ];
+
+        let result = Files::from_prefix_with_filters(
+            prefix,
+            &always_include_glob,
+            &files_glob,
+            Some(&cache_files),
+            None,
+        )
+        .unwrap();
+
+        let expected_files = [
+            "bin/executable",
+            "lib/library.so",
+            "README.md",
+            "bin/cached_executable",
+            "lib/cached_library.so",
+            "README.cached",
+        ];
+
+        for file in &expected_files {
+            assert!(result.new_files.contains(&prefix.join(file)));
+        }
+        assert!(!result.new_files.contains(&prefix.join("config.txt")));
+        assert_eq!(result.new_files.len(), 6);
+    }
 }
diff --git a/src/recipe/parser/about.rs b/src/recipe/parser/about.rs
index 4869120e6..9d6a09e5e 100644
--- a/src/recipe/parser/about.rs
+++ b/src/recipe/parser/about.rs
@@ -170,11 +170,13 @@ impl TryConvertNode<License> for RenderedScalarNode {
 
 #[cfg(test)]
 mod test {
+    use super::*;
     use crate::{
         assert_miette_snapshot,
         recipe::{Recipe, jinja::SelectorConfig},
         variant_config::ParseErrors,
     };
+    use std::path::Path;
 
     #[test]
     fn invalid_url() {
@@ -211,4 +213,40 @@ mod test {
 
         assert_miette_snapshot!(err);
     }
+
+    #[test]
+    fn test_merge_from() {
+        let mut about1 = About {
+            homepage: Some(Url::parse("https://example.com").unwrap()),
+            repository: Some(Url::parse("https://github.com/example/repo").unwrap()),
+            summary: Some("Original summary".to_string()),
+            description: None,
+            license_family: None,
+            license_file: GlobVec::from_vec(vec!["LICENSE"], None),
+            ..Default::default()
+        };
+
+        let about2 = About {
+            homepage: Some(Url::parse("https://other.com").unwrap()),
+            description: Some("Other description".to_string()),
+            license_family: Some("MIT".to_string()),
+            license_file: GlobVec::from_vec(vec!["COPYING"], None),
+            ..Default::default()
+        };
+
+        about1.merge_from(&about2);
+
+        assert_eq!(
+            about1.homepage.as_ref().unwrap().as_str(),
+            "https://example.com/"
+        );
+        assert_eq!(
+            about1.repository.as_ref().unwrap().as_str(),
+            "https://github.com/example/repo"
+        );
+        assert_eq!(about1.summary.as_ref().unwrap(), "Original summary");
+        assert!(about1.license_file.is_match(Path::new("LICENSE")));
+        assert_eq!(about1.description.as_ref().unwrap(), "Other description");
+        assert_eq!(about1.license_family.as_ref().unwrap(), "MIT");
+    }
 }

From b4e0a8976a4d6524089a51b3496ab01597979225 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Sun, 19 Oct 2025 00:09:36 +0300
Subject: [PATCH 10/29] e2e tests and fixes

---
 src/build.rs                                  |   2 +-
 src/cache.rs                                  |  17 +-
 src/lib.rs                                    |  24 ++-
 src/packaging/file_finder.rs                  |  74 ++++----
 src/post_process/checks.rs                    |  19 +-
 src/recipe/parser.rs                          |  67 +++++--
 src/recipe/parser/output.rs                   | 168 +++++++++++-------
 src/recipe/parser/output_parser.rs            |   8 +-
 src/recipe/parser/package.rs                  |   1 +
 src/render/resolved_dependencies.rs           |  54 ++++--
 src/variant_render.rs                         |  87 ++++++++-
 .../cache_inherit_requirements/recipe.yaml    |  33 ++++
 .../cache_multiple_outputs/recipe.yaml        |  41 +++++
 .../recipes/cache_run_exports/recipe.yaml     |  36 ++++
 .../test_simple/test_pin_compatible.json      |   4 +-
 .../test_simple/test_python_min_render.json   |   4 +-
 .../test_recipe_variant_render.json           |   8 +-
 test/end-to-end/test_simple.py                |  66 +++++++
 18 files changed, 554 insertions(+), 159 deletions(-)
 create mode 100644 test-data/recipes/cache_inherit_requirements/recipe.yaml
 create mode 100644 test-data/recipes/cache_multiple_outputs/recipe.yaml
 create mode 100644 test-data/recipes/cache_run_exports/recipe.yaml

diff --git a/src/build.rs b/src/build.rs
index 66f7f6d25..30bce03ad 100644
--- a/src/build.rs
+++ b/src/build.rs
@@ -129,7 +129,7 @@ pub async fn run_build(
         // Cache outputs from outputs array
         let mut current_output = output;
         let cache_outputs = current_output.cache_outputs_to_build.clone();
-        for cache_output in &cache_outputs {
+        for cache_output in cache_outputs.iter() {
             current_output = current_output
                 .build_or_fetch_cache_output(cache_output, tool_configuration)
                 .await?;
diff --git a/src/cache.rs b/src/cache.rs
index 5476120b9..efbeb5a02 100644
--- a/src/cache.rs
+++ b/src/cache.rs
@@ -528,14 +528,23 @@ impl Output {
         )
         .into_diagnostic()?;
 
-        fs::remove_dir_all(self.prefix()).into_diagnostic()?;
-        CopyDir::new(&prefix_cache_dir, self.prefix())
-            .run()
-            .into_diagnostic()?;
+        // The files are already in PREFIX from the build script, so we don't need to restore them.
+        // However, we need to track them so subsequent cache builds that inherit from this one
+        // know which files are available (e.g., extended-cache inheriting from base-cache).
+        // The files will remain in PREFIX for the next cache build in the sequence.
+
+        let mut all_restored_prefix_files = self.restored_cache_prefix_files.unwrap_or_default();
+        all_restored_prefix_files.extend(cache.prefix_files.clone());
+
+        let mut all_restored_work_dir_files =
+            self.restored_cache_work_dir_files.unwrap_or_default();
+        all_restored_work_dir_files.extend(cache.work_dir_files.clone());
 
         Ok(Output {
             finalized_cache_dependencies: Some(finalized_dependencies),
             finalized_cache_sources: Some(rendered_sources),
+            restored_cache_prefix_files: Some(all_restored_prefix_files),
+            restored_cache_work_dir_files: Some(all_restored_work_dir_files),
             ..self
         })
     }
diff --git a/src/lib.rs b/src/lib.rs
index 527606b3e..448b5fccf 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -74,6 +74,7 @@ use rattler_solve::SolveStrategy;
 use rattler_virtual_packages::{VirtualPackage, VirtualPackageOverrides};
 use recipe::parser::{Dependency, Recipe, TestType, find_outputs_from_src};
 use selectors::SelectorConfig;
+use serde_json::{Value, to_string_pretty, to_value};
 use source_code::Source;
 use system_tools::SystemTools;
 use tool_configuration::{Configuration, ContinueOnFailure, SkipExisting, TestStrategy};
@@ -1025,10 +1026,25 @@ pub async fn build_recipes(
             outputs
         };
 
-        println!(
-            "{}",
-            serde_json::to_string_pretty(&outputs).into_diagnostic()?
-        );
+        let mut json_value = to_value(&outputs).into_diagnostic()?;
+        if let Value::Array(outputs_array) = &mut json_value {
+            for output in outputs_array {
+                if let Some(Value::Object(recipe)) = output.get_mut("recipe") {
+                    let requirements = recipe
+                        .entry("requirements".to_string())
+                        .or_insert_with(|| Value::Object(Default::default()));
+                    if let Value::Object(requirements) = requirements {
+                        for key in ["build", "host", "run", "run_constraints"] {
+                            requirements
+                                .entry(key.to_string())
+                                .or_insert_with(|| Value::Array(Vec::new()));
+                        }
+                    }
+                }
+            }
+        }
+
+        println!("{}", to_string_pretty(&json_value).into_diagnostic()?);
         return Ok(());
     }
 
diff --git a/src/packaging/file_finder.rs b/src/packaging/file_finder.rs
index 02e881684..a5b82cf6b 100644
--- a/src/packaging/file_finder.rs
+++ b/src/packaging/file_finder.rs
@@ -230,38 +230,8 @@ impl Files {
                 prefix: prefix.to_owned(),
             });
         }
-
+        let fs_is_case_sensitive = check_is_case_sensitive()?;
         let current_files = record_files(prefix)?;
-        let mut selected_files = HashSet::new();
-        for file in &current_files {
-            if let Ok(file_without_prefix) = file.strip_prefix(prefix) {
-                if files.is_empty()
-                    || files.is_match(file_without_prefix)
-                    || always_include.is_match(file_without_prefix)
-                {
-                    if always_include.is_match(file_without_prefix) {
-                        tracing::info!("Forcing inclusion of file: {:?}", file_without_prefix);
-                    }
-                    selected_files.insert(file.clone());
-                }
-            }
-        }
-
-        if let Some(cache_files) = restored_cache_prefix_files {
-            for cache_file in cache_files {
-                let full_path = prefix.join(cache_file);
-                if let Ok(file_without_prefix) = full_path.strip_prefix(prefix) {
-                    if (files.is_empty()
-                        || files.is_match(file_without_prefix)
-                        || always_include.is_match(file_without_prefix))
-                        && current_files.contains(&full_path)
-                    {
-                        selected_files.insert(full_path);
-                    }
-                }
-            }
-        }
-
         let previous_files = if prefix.join("conda-meta").exists() {
             let prefix_records: Vec<PrefixRecord> = PrefixRecord::collect_from_prefix(prefix)?;
             let mut previous_files = prefix_records
@@ -274,6 +244,48 @@ impl Files {
             HashSet::new()
         };
 
+        let mut selected_files = find_new_files(
+            &current_files,
+            &previous_files,
+            prefix,
+            fs_is_case_sensitive,
+        );
+
+        if !files.is_empty() {
+            selected_files.retain(|f| {
+                files.is_match(f.strip_prefix(prefix).expect("File should be in prefix"))
+            });
+        }
+
+        if !always_include.is_empty() {
+            for file in &current_files {
+                let file_without_prefix =
+                    file.strip_prefix(prefix).expect("File should be in prefix");
+                if always_include.is_match(file_without_prefix) {
+                    tracing::info!("Forcing inclusion of file: {:?}", file_without_prefix);
+                    selected_files.insert(file.clone());
+                }
+            }
+        }
+
+        if let Some(cache_files) = restored_cache_prefix_files {
+            for cache_file in cache_files {
+                let full_path = prefix.join(cache_file);
+                if !current_files.contains(&full_path) {
+                    continue;
+                }
+                let file_without_prefix = full_path
+                    .strip_prefix(prefix)
+                    .expect("File should be in prefix");
+                if files.is_empty()
+                    || files.is_match(file_without_prefix)
+                    || always_include.is_match(file_without_prefix)
+                {
+                    selected_files.insert(full_path);
+                }
+            }
+        }
+
         Ok(Files {
             new_files: selected_files,
             old_files: previous_files,
diff --git a/src/post_process/checks.rs b/src/post_process/checks.rs
index 84e792dce..fc8edb8a5 100644
--- a/src/post_process/checks.rs
+++ b/src/post_process/checks.rs
@@ -16,6 +16,7 @@ use crate::{
 use crate::render::resolved_dependencies::RunExportDependency;
 use globset::{Glob, GlobSet, GlobSetBuilder};
 use rattler_conda_types::{PackageName, PrefixRecord};
+use tracing::warn;
 
 #[derive(thiserror::Error, Debug)]
 pub enum LinkingCheckError {
@@ -204,14 +205,20 @@ fn find_system_libs(output: &Output) -> Result<GlobSet, globset::Error> {
             .directories
             .build_prefix
             .join(prefix_record_name);
-        let record = PrefixRecord::from_path(sysroot_path).unwrap();
-        let so_glob = Glob::new("*.so*")?.compile_matcher();
-        for file in record.files {
-            if let Some(file_name) = file.file_name() {
-                if so_glob.is_match(file_name) {
-                    system_libs.add(Glob::new(&file_name.to_string_lossy())?);
+        if let Ok(record) = PrefixRecord::from_path(sysroot_path.clone()) {
+            let so_glob = Glob::new("*.so*")?.compile_matcher();
+            for file in record.files {
+                if let Some(file_name) = file.file_name() {
+                    if so_glob.is_match(file_name) {
+                        system_libs.add(Glob::new(&file_name.to_string_lossy())?);
+                    }
                 }
             }
+        } else {
+            warn!(
+                "Skipping sysroot linking check; prefix record missing at {}",
+                sysroot_path.display()
+            );
         }
     }
     system_libs.build()
diff --git a/src/recipe/parser.rs b/src/recipe/parser.rs
index 7e90d9a9f..bcfe06cdc 100644
--- a/src/recipe/parser.rs
+++ b/src/recipe/parser.rs
@@ -6,6 +6,7 @@ use indexmap::IndexMap;
 use rattler_conda_types::PackageName;
 use serde::{Deserialize, Serialize};
 use std::borrow::Cow;
+use std::collections::{HashMap, HashSet};
 use std::fmt::Debug;
 
 use crate::{
@@ -102,7 +103,7 @@ pub struct Recipe {
     pub cache_outputs: Vec<CacheOutput>,
     /// Cache inheritance relationships (package name -> cache names)
     #[serde(skip)]
-    pub cache_inheritance: std::collections::HashMap<String, Vec<String>>,
+    pub cache_inheritance: HashMap<String, Vec<String>>,
 }
 
 pub(crate) trait CollectErrors<K, V>: Iterator<Item = Result<K, V>> + Sized {
@@ -273,7 +274,7 @@ impl Recipe {
         let mut cache = None;
         let mut extra = IndexMap::default();
         let cache_outputs_result = Vec::new();
-        let cache_inheritance = std::collections::HashMap::new();
+        let cache_inheritance = HashMap::new();
 
         rendered_node
             .iter()
@@ -281,7 +282,9 @@ impl Recipe {
                 let key_str = key.as_str();
                 match key_str {
                     "schema_version" => schema_version = value.try_convert(key_str)?,
-                    "package" => package = Some(value.try_convert(key_str)?),
+                    "package" => {
+                        package = Some(value.try_convert(key_str)?);
+                    }
                     "recipe" => {
                         return Err(vec![_partialerror!(
                         *key.span(),
@@ -306,6 +309,8 @@ impl Recipe {
                     "requirements" => requirements = value.try_convert(key_str)?,
                     "tests" => tests = value.try_convert(key_str)?,
                     "about" => about = value.try_convert(key_str)?,
+                    "inherit" => {
+                    }
                     "context" => {}
                     "extra" => extra = value.as_mapping().ok_or_else(|| {
                                             vec![_partialerror!(
@@ -430,26 +435,58 @@ impl Recipe {
 
     /// Get cache outputs that this package depends on based on inheritance
     /// This is called during Output creation to populate cache_outputs_to_build
+    /// Includes transitive dependencies (e.g., if A inherits from B and B inherits from C,
+    /// then A depends on both C and B, in that order)
     pub fn get_cache_outputs_for_package(
         &self,
         package_name: &str,
         all_cache_outputs: &[CacheOutput],
-        inheritance_relationships: &std::collections::HashMap<String, Vec<String>>,
+        inheritance_relationships: &HashMap<String, Vec<String>>,
     ) -> Vec<CacheOutput> {
-        if let Some(cache_names) = inheritance_relationships.get(package_name) {
-            let mut result = Vec::new();
-            for cache_name in cache_names {
-                if let Some(cache_output) = all_cache_outputs
-                    .iter()
-                    .find(|c| c.name.as_normalized() == cache_name.as_str())
-                {
-                    result.push(cache_output.clone());
+        let mut result = Vec::new();
+        let mut seen = HashSet::new();
+
+        // Function to collect all transitive dependencies
+        fn collect_dependencies(
+            name: &str,
+            all_cache_outputs: &[CacheOutput],
+            inheritance_relationships: &HashMap<String, Vec<String>>,
+            result: &mut Vec<CacheOutput>,
+            seen: &mut HashSet<String>,
+        ) {
+            if let Some(cache_names) = inheritance_relationships.get(name) {
+                for cache_name in cache_names {
+                    // First, recursively collect dependencies of this cache
+                    collect_dependencies(
+                        cache_name,
+                        all_cache_outputs,
+                        inheritance_relationships,
+                        result,
+                        seen,
+                    );
+
+                    // Then add the cache itself if we haven't seen it yet
+                    if !seen.contains(cache_name) {
+                        if let Some(cache_output) = all_cache_outputs
+                            .iter()
+                            .find(|c| c.name.as_normalized() == cache_name)
+                        {
+                            result.push(cache_output.clone());
+                            seen.insert(cache_name.to_string());
+                        }
+                    }
                 }
             }
-            result
-        } else {
-            Vec::new()
         }
+
+        collect_dependencies(
+            package_name,
+            all_cache_outputs,
+            inheritance_relationships,
+            &mut result,
+            &mut seen,
+        );
+        result
     }
 }
 
diff --git a/src/recipe/parser/output.rs b/src/recipe/parser/output.rs
index 5c1af3cf4..08284da3f 100644
--- a/src/recipe/parser/output.rs
+++ b/src/recipe/parser/output.rs
@@ -601,47 +601,52 @@ fn parse_inheritance_relationships(
     let mut relationships = std::collections::HashMap::new();
 
     for output in outputs {
-        if let Some(mapping) = output.as_mapping() {
-            if mapping.contains_key("package") {
-                if let Some(package_node) = mapping.get("package") {
-                    if let Some(package_mapping) = package_node.as_mapping() {
-                        let package_name = if let Some(name_node) = package_mapping.get("name") {
-                            if let Some(name_scalar) = name_node.as_scalar() {
-                                name_scalar.as_str().to_string()
-                            } else {
-                                continue;
-                            }
-                        } else {
-                            continue;
-                        };
+        let Some(mapping) = output.as_mapping() else {
+            continue;
+        };
 
-                        if let Some(inherit_node) = package_mapping.get("inherit") {
-                            let cache_name = if let Some(inherit_scalar) = inherit_node.as_scalar()
-                            {
-                                inherit_scalar.as_str().to_string()
-                            } else if let Some(inherit_mapping) = inherit_node.as_mapping() {
-                                if let Some(from_node) = inherit_mapping.get("from") {
-                                    if let Some(from_scalar) = from_node.as_scalar() {
-                                        from_scalar.as_str().to_string()
-                                    } else {
-                                        continue;
-                                    }
-                                } else {
-                                    continue;
-                                }
-                            } else {
-                                continue;
-                            };
-
-                            relationships
-                                .entry(package_name)
-                                .or_insert_with(Vec::new)
-                                .push(cache_name);
-                        }
-                    }
+        let Some(package_node) = mapping.get("package") else {
+            continue;
+        };
+
+        let Some(package_mapping) = package_node.as_mapping() else {
+            continue;
+        };
+        let Some(name_node) = package_mapping.get("name") else {
+            continue;
+        };
+        let Some(name_scalar) = name_node.as_scalar() else {
+            continue;
+        };
+        let package_name = name_scalar.as_str().to_string();
+
+        let Some(inherit_node) = package_mapping
+            .get("inherit")
+            .or_else(|| mapping.get("inherit"))
+        else {
+            continue;
+        };
+
+        let cache_name = if let Some(inherit_scalar) = inherit_node.as_scalar() {
+            inherit_scalar.as_str().to_string()
+        } else if let Some(inherit_mapping) = inherit_node.as_mapping() {
+            if let Some(from_node) = inherit_mapping.get("from") {
+                if let Some(from_scalar) = from_node.as_scalar() {
+                    from_scalar.as_str().to_string()
+                } else {
+                    continue;
                 }
+            } else {
+                continue;
             }
-        }
+        } else {
+            continue;
+        };
+
+        relationships
+            .entry(package_name)
+            .or_insert_with(Vec::new)
+            .push(cache_name);
     }
 
     Ok(relationships)
@@ -695,35 +700,43 @@ fn parse_cache_to_cache_inheritance(
     let mut relationships: HashMap<String, Vec<String>> = HashMap::new();
 
     for output in outputs {
-        if let Some(mapping) = output
-            .as_mapping()
-            .and_then(|m| m.get("cache"))
-            .and_then(|c| c.as_mapping())
-        {
-            let cache_name = mapping
-                .get("name")
-                .and_then(|n| n.as_scalar())
-                .map(|s| s.as_str().to_string());
-
-            let inherited_name = mapping.get("inherit").and_then(|inherit| {
-                inherit
-                    .as_scalar()
-                    .map(|s| s.as_str().to_string())
-                    .or_else(|| {
-                        inherit
-                            .as_mapping()
-                            .and_then(|m| m.get("from"))
-                            .and_then(|f| f.as_scalar())
-                            .map(|s| s.as_str().to_string())
-                    })
-            });
+        let Some(mapping) = output.as_mapping() else {
+            continue;
+        };
+        let Some(cache_node) = mapping.get("cache") else {
+            continue;
+        };
+        let Some(cache_mapping) = cache_node.as_mapping() else {
+            continue;
+        };
 
-            if let (Some(cache_name), Some(inherited_name)) = (cache_name, inherited_name) {
-                relationships
-                    .entry(cache_name)
-                    .or_default()
-                    .push(inherited_name);
-            }
+        let cache_name = cache_mapping
+            .get("name")
+            .and_then(|n| n.as_scalar())
+            .map(|s| s.as_str().to_string());
+
+        let inherit_node = mapping
+            .get("inherit")
+            .or_else(|| cache_mapping.get("inherit"));
+
+        let inherited_name = inherit_node.and_then(|inherit| {
+            inherit
+                .as_scalar()
+                .map(|s| s.as_str().to_string())
+                .or_else(|| {
+                    inherit
+                        .as_mapping()
+                        .and_then(|m| m.get("from"))
+                        .and_then(|f| f.as_scalar())
+                        .map(|s| s.as_str().to_string())
+                })
+        });
+
+        if let (Some(cache_name), Some(inherited_name)) = (cache_name, inherited_name) {
+            relationships
+                .entry(cache_name)
+                .or_default()
+                .push(inherited_name);
         }
     }
 
@@ -921,12 +934,29 @@ pub fn resolve_cache_inheritance_with_caches(
     let cache_to_cache_inheritance_relationships = parse_cache_to_cache_inheritance(&outputs)?;
     let inherited_cache_outputs = apply_cache_to_cache_inheritance(
         all_cache_outputs,
-        cache_to_cache_inheritance_relationships,
+        cache_to_cache_inheritance_relationships.clone(),
     );
 
-    let inheritance_relationships = parse_inheritance_relationships(&outputs)?;
+    let package_outputs: Vec<Node> = outputs
+        .into_iter()
+        .filter(|output| output.as_mapping().and_then(|m| m.get("package")).is_some())
+        .collect();
+
+    let mut inheritance_relationships = parse_inheritance_relationships(&package_outputs)?;
+
+    // Merge cache-to-cache relationships into the main inheritance map
+    for (cache_name, parent_caches) in cache_to_cache_inheritance_relationships {
+        inheritance_relationships
+            .entry(cache_name)
+            .or_default()
+            .extend(parent_caches);
+    }
 
-    Ok((outputs, inherited_cache_outputs, inheritance_relationships))
+    Ok((
+        package_outputs,
+        inherited_cache_outputs,
+        inheritance_relationships,
+    ))
 }
 
 #[cfg(test)]
diff --git a/src/recipe/parser/output_parser.rs b/src/recipe/parser/output_parser.rs
index fb82992c8..c26d6f0fc 100644
--- a/src/recipe/parser/output_parser.rs
+++ b/src/recipe/parser/output_parser.rs
@@ -65,13 +65,7 @@ impl TryConvertNode<OutputType> for RenderedNode {
             .ok_or_else(|| vec![_partialerror!(*self.span(), ErrorKind::ExpectedMapping)])?;
 
         if mapping.contains_key("cache") {
-            let cache_node = mapping.get("cache").ok_or_else(|| {
-                vec![_partialerror!(
-                    *self.span(),
-                    ErrorKind::MissingField("cache".into())
-                )]
-            })?;
-            let cache_output = cache_node.try_convert("outputs.cache")?;
+            let cache_output = self.try_convert("outputs.cache")?;
             return Ok(OutputType::Cache(Box::new(cache_output)));
         }
 
diff --git a/src/recipe/parser/package.rs b/src/recipe/parser/package.rs
index e2e97f23b..ba794d1f3 100644
--- a/src/recipe/parser/package.rs
+++ b/src/recipe/parser/package.rs
@@ -55,6 +55,7 @@ impl TryConvertNode<Package> for RenderedMappingNode {
                 match key_str {
                     "name" => name_val = value.try_convert(key_str)?,
                     "version" => version = value.try_convert(key_str)?,
+                    "inherit" => {}
                     invalid => {
                         return Err(vec![_partialerror!(
                             *key.span(),
diff --git a/src/render/resolved_dependencies.rs b/src/render/resolved_dependencies.rs
index 19d5e48c8..0a7a092d4 100644
--- a/src/render/resolved_dependencies.rs
+++ b/src/render/resolved_dependencies.rs
@@ -22,7 +22,7 @@ use super::pin::PinError;
 use crate::{
     metadata::{BuildConfiguration, Output, build_reindexed_channels},
     package_cache_reporter::PackageCacheReporter,
-    recipe::parser::{Dependency, Requirements},
+    recipe::parser::{Dependency, IgnoreRunExports, Requirements},
     render::{
         pin::PinArgs,
         solver::{install_packages, solve_environment},
@@ -32,6 +32,30 @@ use crate::{
     tool_configuration::Configuration,
 };
 
+/// Helper function to get cache ignore_run_exports from either legacy cache or new cache outputs
+fn get_cache_ignore_run_exports(
+    output: &Output,
+    output_ignore_run_exports: &IgnoreRunExports,
+) -> IgnoreRunExports {
+    if let Some(legacy_cache) = &output.recipe.cache {
+        legacy_cache
+            .requirements
+            .ignore_run_exports(Some(output_ignore_run_exports))
+    } else if let Some(cache_ignore) = output
+        .cache_outputs_to_build
+        .last()
+        .and_then(|c| c.ignore_run_exports.as_ref())
+    {
+        Requirements {
+            ignore_run_exports: cache_ignore.clone(),
+            ..Default::default()
+        }
+        .ignore_run_exports(Some(output_ignore_run_exports))
+    } else {
+        output_ignore_run_exports.clone()
+    }
+}
+
 /// A enum to keep track of where a given Dependency comes from
 #[serde_as]
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -785,16 +809,14 @@ pub(crate) async fn resolve_dependencies(
     let mut build_run_exports = output_ignore_run_exports.filter(&build_run_exports, "build")?;
 
     if let Some(cache) = &output.finalized_cache_dependencies {
+        // Process build environment cache
         if let Some(cache_build_env) = &cache.build {
             let cache_build_run_exports = cache_build_env.run_exports(true);
-            let filtered = output
-                .recipe
-                .cache
-                .as_ref()
-                .expect("recipe should have cache section")
-                .requirements
-                .ignore_run_exports(Some(&output_ignore_run_exports))
-                .filter(&cache_build_run_exports, "cache-build")?;
+            let cache_ignore_run_exports =
+                get_cache_ignore_run_exports(output, &output_ignore_run_exports);
+
+            let filtered =
+                cache_ignore_run_exports.filter(&cache_build_run_exports, "cache-build")?;
             build_run_exports.extend(&filtered);
         }
     }
@@ -900,17 +922,15 @@ pub(crate) async fn resolve_dependencies(
         .unwrap_or_else(|| output_ignore_run_exports.clone());
     let mut host_run_exports = host_ignore_run_exports.filter(&host_run_exports, "host")?;
 
+    // Process host environment cache
     if let Some(cache) = &output.finalized_cache_dependencies {
         if let Some(cache_host_env) = &cache.host {
             let cache_host_run_exports = cache_host_env.run_exports(true);
-            let filtered = output
-                .recipe
-                .cache
-                .as_ref()
-                .expect("recipe should have cache section")
-                .requirements
-                .ignore_run_exports(Some(&output_ignore_run_exports))
-                .filter(&cache_host_run_exports, "cache-host")?;
+            let cache_ignore_run_exports =
+                get_cache_ignore_run_exports(output, &output_ignore_run_exports);
+
+            let filtered =
+                cache_ignore_run_exports.filter(&cache_host_run_exports, "cache-host")?;
             host_run_exports.extend(&filtered);
         }
     }
diff --git a/src/variant_render.rs b/src/variant_render.rs
index 057320fdc..e295c8919 100644
--- a/src/variant_render.rs
+++ b/src/variant_render.rs
@@ -24,6 +24,34 @@ use crate::{
     },
 };
 
+fn inherit_flags_from_output(output: &Node) -> (bool, bool) {
+    let inherit_node = output.as_mapping().and_then(|m| {
+        m.get("package")
+            .and_then(|p| p.as_mapping().and_then(|pm| pm.get("inherit")))
+            .or_else(|| m.get("inherit"))
+    });
+
+    match inherit_node {
+        Some(node) if node.as_scalar().is_some() => (true, false),
+        Some(node) => {
+            if let Some(mapping) = node.as_mapping() {
+                let run_exports = mapping
+                    .get("run_exports")
+                    .and_then(|n| n.as_scalar()?.as_bool())
+                    .unwrap_or(true);
+                let requirements = mapping
+                    .get("requirements")
+                    .and_then(|n| n.as_scalar()?.as_bool())
+                    .unwrap_or(false);
+                (run_exports, requirements)
+            } else {
+                (true, false)
+            }
+        }
+        _ => (true, false),
+    }
+}
+
 /// All the raw outputs of a single recipe.yaml
 #[derive(Clone, Debug)]
 pub struct RawOutputVec {
@@ -112,6 +140,8 @@ pub(crate) fn stage_0_render<S: SourceCode>(
                 .map_err(VariantConfigError::from)?;
 
             let package_name = parsed_recipe.package.name.as_normalized().to_string();
+            let (inherit_run_exports, inherit_requirements) = inherit_flags_from_output(output);
+
             if let Some(caches) = inheritance_relationships.get(&package_name) {
                 let mut cache_list = Vec::new();
                 for cache_name in caches {
@@ -120,6 +150,29 @@ pub(crate) fn stage_0_render<S: SourceCode>(
                         .find(|c| c.name.as_normalized() == cache_name.as_str())
                     {
                         cache_list.push(cache_output.clone());
+
+                        if inherit_requirements {
+                            parsed_recipe
+                                .requirements
+                                .build
+                                .extend(cache_output.requirements.build.iter().cloned());
+                            parsed_recipe
+                                .requirements
+                                .host
+                                .extend(cache_output.requirements.host.iter().cloned());
+                        }
+
+                        if inherit_run_exports {
+                            parsed_recipe
+                                .requirements
+                                .run_exports
+                                .extend_from(&cache_output.run_exports);
+                            if let Some(cache_ignore) = &cache_output.ignore_run_exports {
+                                parsed_recipe.requirements.ignore_run_exports = parsed_recipe
+                                    .requirements
+                                    .ignore_run_exports(Some(cache_ignore));
+                            }
+                        }
                     }
                 }
                 parsed_recipe.cache_outputs = cache_list;
@@ -498,7 +551,7 @@ pub(crate) fn stage_1_render<S: SourceCode>(
                 let config_with_variant = selector_config
                     .with_variant(combination.clone(), selector_config.target_platform);
 
-                let parsed_recipe = Recipe::from_node(output, config_with_variant.clone())
+                let mut parsed_recipe = Recipe::from_node(output, config_with_variant.clone())
                     .map_err(|err| {
                         let errs: ParseErrors<_> = err
                             .into_iter()
@@ -509,6 +562,38 @@ pub(crate) fn stage_1_render<S: SourceCode>(
                     })
                     .map_err(VariantConfigError::from)?;
 
+                // Preserve cache_outputs and inherited requirements from stage 0
+                let stage0_output = &r.rendered_outputs[idx];
+                parsed_recipe.cache_outputs = stage0_output.cache_outputs.clone();
+
+                // Re-apply inheritance from cache outputs (run_exports, requirements, ignore)
+                // This is needed because we re-parsed from the raw node
+                let (inherit_run_exports, inherit_requirements) = inherit_flags_from_output(output);
+                for cache_output in &parsed_recipe.cache_outputs {
+                    if inherit_requirements {
+                        parsed_recipe
+                            .requirements
+                            .build
+                            .extend(cache_output.requirements.build.iter().cloned());
+                        parsed_recipe
+                            .requirements
+                            .host
+                            .extend(cache_output.requirements.host.iter().cloned());
+                    }
+
+                    if inherit_run_exports {
+                        parsed_recipe
+                            .requirements
+                            .run_exports
+                            .extend_from(&cache_output.run_exports);
+                        if let Some(cache_ignore) = &cache_output.ignore_run_exports {
+                            parsed_recipe.requirements.ignore_run_exports = parsed_recipe
+                                .requirements
+                                .ignore_run_exports(Some(cache_ignore));
+                        }
+                    }
+                }
+
                 inner.push(Stage1Inner {
                     used_vars_from_dependencies: extra_vars_per_output[idx].clone(),
                     exact_pins: exact_pins_per_output[idx].clone(),
diff --git a/test-data/recipes/cache_inherit_requirements/recipe.yaml b/test-data/recipes/cache_inherit_requirements/recipe.yaml
new file mode 100644
index 000000000..41fd2c23b
--- /dev/null
+++ b/test-data/recipes/cache_inherit_requirements/recipe.yaml
@@ -0,0 +1,33 @@
+outputs:
+  - cache:
+      name: build-cache
+    requirements:
+      build:
+        - cmake
+        - ninja
+      host:
+        - zlib
+    build:
+      script:
+        - mkdir -p $PREFIX/lib
+        - echo "build environment setup" > $PREFIX/lib/setup.txt
+
+  - package:
+      name: with-reqs-inherited
+      version: 0.1.0
+    inherit:
+      from: build-cache
+      requirements: true
+    build:
+      files:
+        - lib/*
+    # should have cmake, ninja in build and zlib in host
+  
+  - package:
+      name: without-reqs-inherited
+      version: 0.1.0
+    inherit: build-cache
+    build:
+      files:
+        - lib/*
+    # should NOT have requirements (default behavior)
diff --git a/test-data/recipes/cache_multiple_outputs/recipe.yaml b/test-data/recipes/cache_multiple_outputs/recipe.yaml
new file mode 100644
index 000000000..f77c0f4de
--- /dev/null
+++ b/test-data/recipes/cache_multiple_outputs/recipe.yaml
@@ -0,0 +1,41 @@
+outputs:
+  - cache:
+      name: base-cache
+    build:
+      script:
+        - mkdir -p $PREFIX/lib
+        - mkdir -p $PREFIX/include
+        - echo "This is the base library" > $PREFIX/lib/base.txt
+        - echo "// Base header" > $PREFIX/include/base.h
+    requirements:
+      build:
+        - cmake
+    
+  - cache:
+      name: extended-cache
+    inherit: base-cache
+    build:
+      script:
+        - echo "This is the extended library" > $PREFIX/lib/extended.txt
+        - echo "// Extended header" > $PREFIX/include/extended.h
+    requirements:
+      build:
+        - ninja
+
+  - package:
+      name: pkg-from-base
+      version: 0.1.0
+    inherit: base-cache
+    build:
+      files:
+        - lib/base.txt
+        - include/base.h
+  
+  - package:
+      name: pkg-from-extended
+      version: 0.1.0
+    inherit: extended-cache
+    build:
+      files:
+        - lib/*
+        - include/*
diff --git a/test-data/recipes/cache_run_exports/recipe.yaml b/test-data/recipes/cache_run_exports/recipe.yaml
new file mode 100644
index 000000000..1f29232f4
--- /dev/null
+++ b/test-data/recipes/cache_run_exports/recipe.yaml
@@ -0,0 +1,36 @@
+outputs:
+  - cache:
+      name: lib-cache
+    requirements:
+      build:
+        - ${{ compiler('c') }}
+    run_exports:
+      weak:
+        - libfoo
+      strong:
+        - libbar
+    build:
+      script:
+        - mkdir -p $PREFIX/lib
+        - echo "library content" > $PREFIX/lib/libfoo.so
+        - echo "library content" > $PREFIX/lib/libbar.so
+
+  - package:
+      name: lib-package
+      version: 0.1.0
+    inherit: lib-cache
+    build:
+      files:
+        - lib/*
+    # inherits run_exports by default
+  
+  - package:
+      name: dev-package
+      version: 0.1.0
+    inherit:
+      from: lib-cache
+      run_exports: false
+    build:
+      files:
+        - lib/*
+    # does not inherit run_exports
diff --git a/test/end-to-end/__snapshots__/test_simple/test_pin_compatible.json b/test/end-to-end/__snapshots__/test_simple/test_pin_compatible.json
index 985c0e504..c951f2a80 100644
--- a/test/end-to-end/__snapshots__/test_simple/test_pin_compatible.json
+++ b/test/end-to-end/__snapshots__/test_simple/test_pin_compatible.json
@@ -1,4 +1,5 @@
 {
+  "build": [],
   "host": [
     "python"
   ],
@@ -9,5 +10,6 @@
         "name": "python"
       }
     }
-  ]
+  ],
+  "run_constraints": []
 }
diff --git a/test/end-to-end/__snapshots__/test_simple/test_python_min_render.json b/test/end-to-end/__snapshots__/test_simple/test_python_min_render.json
index 207528c66..c00099a23 100644
--- a/test/end-to-end/__snapshots__/test_simple/test_python_min_render.json
+++ b/test/end-to-end/__snapshots__/test_simple/test_python_min_render.json
@@ -1,4 +1,5 @@
 {
+  "build": [],
   "host": [
     "python >=3.8.0",
     "python 3.8.0.*",
@@ -8,5 +9,6 @@
     "python >=3.8.0",
     "python 3.8.0.*",
     "python 3.8.0.*,<4.0a0"
-  ]
+  ],
+  "run_constraints": []
 }
diff --git a/test/end-to-end/__snapshots__/test_simple/test_recipe_variant_render.json b/test/end-to-end/__snapshots__/test_simple/test_recipe_variant_render.json
index 1e4bac2b5..fccb4cd7d 100644
--- a/test/end-to-end/__snapshots__/test_simple/test_recipe_variant_render.json
+++ b/test/end-to-end/__snapshots__/test_simple/test_recipe_variant_render.json
@@ -3,18 +3,22 @@
     "build": [
       "python"
     ],
+    "host": [],
     "run": [
       "python",
       "__unix"
-    ]
+    ],
+    "run_constraints": []
   },
   {
     "build": [
       "python"
     ],
+    "host": [],
     "run": [
       "python",
       "__unix"
-    ]
+    ],
+    "run_constraints": []
   }
 ]
diff --git a/test/end-to-end/test_simple.py b/test/end-to-end/test_simple.py
index 9cb3db401..3dd534d4e 100644
--- a/test/end-to-end/test_simple.py
+++ b/test/end-to-end/test_simple.py
@@ -2164,3 +2164,69 @@ def test_caseinsensitive(rattler_build: RattlerBuild, recipes: Path, tmp_path: P
         assert "cmake/test_file.txt" in paths
         assert "TEST.txt" in paths
         assert "test.txt" in paths
+
+
+def test_cache_multiple_outputs(
+    rattler_build: RattlerBuild, recipes: Path, tmp_path: Path
+):
+    """Test multiple cache outputs with cache-to-cache and package-to-cache inheritance"""
+    rattler_build.build(
+        recipes / "cache_multiple_outputs",
+        tmp_path,
+        extra_args=["--experimental"],
+    )
+
+    pkg_base = get_extracted_package(tmp_path, "pkg-from-base")
+    pkg_extended = get_extracted_package(tmp_path, "pkg-from-extended")
+
+    assert (pkg_base / "lib/base.txt").exists()
+    assert (pkg_extended / "include/extended.h").exists()
+
+    paths_json = json.loads((pkg_extended / "info/paths.json").read_text())
+    paths = [p["_path"] for p in paths_json["paths"]]
+    assert "include/extended.h" in paths
+
+
+def test_cache_run_exports_inheritance(
+    rattler_build: RattlerBuild, recipes: Path, tmp_path: Path
+):
+    """Test run_exports inheritance from cache outputs"""
+    rattler_build.build(
+        recipes / "cache_run_exports",
+        tmp_path,
+        extra_args=["--experimental"],
+    )
+
+    lib_pkg = get_extracted_package(tmp_path, "lib-package")
+    dev_pkg = get_extracted_package(tmp_path, "dev-package")
+
+    assert (lib_pkg / "info/run_exports.json").exists()
+    run_exports = json.loads((lib_pkg / "info/run_exports.json").read_text())
+    assert "weak" in run_exports
+    assert not (dev_pkg / "info/run_exports.json").exists()
+
+
+def test_cache_requirements_inheritance(
+    rattler_build: RattlerBuild, recipes: Path, tmp_path: Path
+):
+    """Test requirements inheritance control via inherit spec"""
+    rendered = rattler_build.render(
+        recipes / "cache_inherit_requirements",
+        tmp_path,
+        extra_args=["--experimental"],
+    )
+
+    with_reqs = next(
+        o for o in rendered if o["recipe"]["package"]["name"] == "with-reqs-inherited"
+    )
+    without_reqs = next(
+        o
+        for o in rendered
+        if o["recipe"]["package"]["name"] == "without-reqs-inherited"
+    )
+
+    with_build_reqs = with_reqs["recipe"]["requirements"]["build"]
+    without_build_reqs = without_reqs["recipe"]["requirements"]["build"]
+
+    assert any("cmake" in str(req) for req in with_build_reqs)
+    assert not any("cmake" in str(req) for req in without_build_reqs)

From 2324b8a178120feefab5155a61bc92d407f8babe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Sun, 19 Oct 2025 00:42:12 +0300
Subject: [PATCH 11/29] extra fixes

---
 src/build.rs                                  |  9 ----
 src/lib.rs                                    |  2 +-
 src/recipe/parser/build.rs                    | 11 ++++-
 src/recipe/parser/output.rs                   | 42 ++++++++++++++++++-
 src/recipe/parser/output_parser.rs            | 23 ++++++++--
 src/render/resolved_dependencies.rs           | 16 +------
 .../cache_inherit_requirements/recipe.yaml    |  2 +-
 .../cache_multiple_outputs/recipe.yaml        |  4 +-
 .../recipes/cache_run_exports/recipe.yaml     |  2 +-
 9 files changed, 76 insertions(+), 35 deletions(-)

diff --git a/src/build.rs b/src/build.rs
index 30bce03ad..3708db902 100644
--- a/src/build.rs
+++ b/src/build.rs
@@ -165,15 +165,6 @@ pub async fn run_build(
     let use_fast_path = output.finalized_cache_dependencies.is_some()
         && output.recipe.build().script().is_default();
 
-    // Verify that requirements inheritance is properly handled in fast path
-    // If there are inherited requirements but no build script, we still need to check if
-    // environment setup is needed for other purposes beyond script execution
-    if use_fast_path {
-        tracing::info!(
-            "Using fast-path optimization: output inherited cache and has no build.script; skipping environment setup and script execution for improved performance."
-        );
-    }
-
     if !use_fast_path {
         output
             .install_environments(tool_configuration)
diff --git a/src/lib.rs b/src/lib.rs
index 448b5fccf..81574ae50 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -241,7 +241,7 @@ pub async fn get_build_output(
 
     if has_cache_or_inheritance {
         let has_toplevel_cache = outputs.iter().any(|output| {
-            if let Ok(recipe) = Recipe::from_node(output, SelectorConfig::default()) {
+            if let Ok(recipe) = Recipe::from_node(output, selector_config.clone()) {
                 recipe.cache.is_some()
             } else {
                 false
diff --git a/src/recipe/parser/build.rs b/src/recipe/parser/build.rs
index f90745cfb..0058a8ca2 100644
--- a/src/recipe/parser/build.rs
+++ b/src/recipe/parser/build.rs
@@ -208,8 +208,15 @@ pub struct PostProcess {
 }
 
 impl Build {
-    /// Deep merge another Build into this one
-    /// Values in self take precedence over values in other
+    /// Deep merge another Build into this one.
+    /// Values in self take precedence over values in other.
+    ///
+    /// Merged fields: python, dynamic_linking, prefix_detection, variant,
+    /// post_process, merge_build_and_host_envs, noarch, files,
+    /// always_include_files, always_copy_files
+    ///
+    /// Excluded fields (preserved from self): number, string, skip, script
+    /// These fields are treated as identity fields specific to each output.
     pub fn merge_from(&mut self, other: &Build) {
         if self.python.is_default() && !other.python.is_default() {
             self.python = other.python.clone();
diff --git a/src/recipe/parser/output.rs b/src/recipe/parser/output.rs
index 08284da3f..650190a6d 100644
--- a/src/recipe/parser/output.rs
+++ b/src/recipe/parser/output.rs
@@ -743,6 +743,40 @@ fn parse_cache_to_cache_inheritance(
     Ok(relationships)
 }
 
+/// Topological sort to process caches in dependency order (ancestors before descendants)
+fn topological_sort(inheritance: &HashMap<String, Vec<String>>) -> Vec<String> {
+    let mut in_degree: HashMap<String, usize> = inheritance
+        .iter()
+        .map(|(node, ancestors)| (node.clone(), ancestors.len()))
+        .collect();
+
+    let all_nodes: HashSet<_> = inheritance
+        .keys()
+        .chain(inheritance.values().flat_map(|v| v.iter()))
+        .cloned()
+        .collect();
+
+    let mut queue: Vec<_> = all_nodes
+        .iter()
+        .filter(|node| in_degree.get(*node).copied().unwrap_or(0) == 0)
+        .cloned()
+        .collect();
+
+    let mut result = Vec::new();
+    while let Some(node) = queue.pop() {
+        result.push(node.clone());
+        // Decrease in-degree for dependents of this node
+        for (dependent, _) in inheritance.iter().filter(|(_, and)| and.contains(&node)) {
+            let degree = in_degree.get_mut(dependent).unwrap();
+            *degree -= 1;
+            if *degree == 0 {
+                queue.push(dependent.clone());
+            }
+        }
+    }
+    result
+}
+
 /// Apply cache-to-cache inheritance to the cache outputs
 fn apply_cache_to_cache_inheritance(
     cache_outputs: Vec<crate::recipe::parser::CacheOutput>,
@@ -753,7 +787,13 @@ fn apply_cache_to_cache_inheritance(
         .map(|cache| (cache.name.as_normalized().to_string(), cache))
         .collect();
 
-    for (cache_name, ancestors) in cache_inheritance_relationships {
+    // Compute topological order to process dependencies first
+    let processing_order = topological_sort(&cache_inheritance_relationships);
+
+    for cache_name in processing_order {
+        let Some(ancestors) = cache_inheritance_relationships.get(&cache_name) else {
+            continue;
+        };
         let ancestor_data: Vec<_> = ancestors
             .iter()
             .filter_map(|ancestor_name| {
diff --git a/src/recipe/parser/output_parser.rs b/src/recipe/parser/output_parser.rs
index c26d6f0fc..55bd7c140 100644
--- a/src/recipe/parser/output_parser.rs
+++ b/src/recipe/parser/output_parser.rs
@@ -186,9 +186,26 @@ impl Output {
                 self.requirements.ignore_run_exports(Some(cache_ignore));
         }
 
-        // Deep merge the build section from cache, excluding the script
-        let cache_build_for_merge = Build::default();
-        self.build.merge_from(&cache_build_for_merge);
+        // Deep merge compatible build fields from cache (script is intentionally excluded)
+        let variant_is_default = |v: &super::build::VariantKeyUsage| {
+            v.use_keys.is_empty() && v.ignore_keys.is_empty() && v.down_prioritize_variant.is_none()
+        };
+        if variant_is_default(&self.build.variant) && !variant_is_default(&cache.build.variant) {
+            self.build.variant = cache.build.variant.clone();
+        }
+        [
+            (&mut self.build.files, &cache.build.files),
+            (
+                &mut self.build.always_include_files,
+                &cache.build.always_include_files,
+            ),
+        ]
+        .iter_mut()
+        .for_each(|(self_field, cache_field)| {
+            if self_field.is_empty() && !cache_field.is_empty() {
+                **self_field = (*cache_field).clone();
+            }
+        });
         if let Some(cache_about) = &cache.about {
             if self.about.is_none() {
                 self.about = Some(cache_about.clone());
diff --git a/src/render/resolved_dependencies.rs b/src/render/resolved_dependencies.rs
index 0a7a092d4..2fdb40eb6 100644
--- a/src/render/resolved_dependencies.rs
+++ b/src/render/resolved_dependencies.rs
@@ -730,11 +730,6 @@ pub(crate) async fn resolve_dependencies(
             }
         }
 
-        if build_env_specs.is_empty() || merge_build_host {
-            // If there are no specs (and we are not merging separately), skip creating a separate build env
-            // unless merge_build_host is false and we really have specs to solve.
-        }
-
         let match_specs = build_env_specs
             .iter()
             .map(|s| s.spec().clone())
@@ -910,16 +905,7 @@ pub(crate) async fn resolve_dependencies(
 
     // And filter the run exports
     // Use cache ignore_run_exports if available, otherwise use output ignore_run_exports
-    let host_ignore_run_exports = output
-        .recipe
-        .cache
-        .as_ref()
-        .map(|cache_section| {
-            cache_section
-                .requirements
-                .ignore_run_exports(Some(&output_ignore_run_exports))
-        })
-        .unwrap_or_else(|| output_ignore_run_exports.clone());
+    let host_ignore_run_exports = get_cache_ignore_run_exports(output, &output_ignore_run_exports);
     let mut host_run_exports = host_ignore_run_exports.filter(&host_run_exports, "host")?;
 
     // Process host environment cache
diff --git a/test-data/recipes/cache_inherit_requirements/recipe.yaml b/test-data/recipes/cache_inherit_requirements/recipe.yaml
index 41fd2c23b..46819a065 100644
--- a/test-data/recipes/cache_inherit_requirements/recipe.yaml
+++ b/test-data/recipes/cache_inherit_requirements/recipe.yaml
@@ -22,7 +22,7 @@ outputs:
       files:
         - lib/*
     # should have cmake, ninja in build and zlib in host
-  
+
   - package:
       name: without-reqs-inherited
       version: 0.1.0
diff --git a/test-data/recipes/cache_multiple_outputs/recipe.yaml b/test-data/recipes/cache_multiple_outputs/recipe.yaml
index f77c0f4de..7db781bb6 100644
--- a/test-data/recipes/cache_multiple_outputs/recipe.yaml
+++ b/test-data/recipes/cache_multiple_outputs/recipe.yaml
@@ -10,7 +10,7 @@ outputs:
     requirements:
       build:
         - cmake
-    
+
   - cache:
       name: extended-cache
     inherit: base-cache
@@ -30,7 +30,7 @@ outputs:
       files:
         - lib/base.txt
         - include/base.h
-  
+
   - package:
       name: pkg-from-extended
       version: 0.1.0
diff --git a/test-data/recipes/cache_run_exports/recipe.yaml b/test-data/recipes/cache_run_exports/recipe.yaml
index 1f29232f4..77c3a649a 100644
--- a/test-data/recipes/cache_run_exports/recipe.yaml
+++ b/test-data/recipes/cache_run_exports/recipe.yaml
@@ -23,7 +23,7 @@ outputs:
       files:
         - lib/*
     # inherits run_exports by default
-  
+
   - package:
       name: dev-package
       version: 0.1.0

From 6a39c9435d5ff41ee681ce14abbe28f26e08d629 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Sun, 19 Oct 2025 12:41:07 +0300
Subject: [PATCH 12/29] merge fix

---
 src/cache.rs               | 16 +++++++++++-----
 src/recipe/parser/about.rs |  1 -
 2 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/src/cache.rs b/src/cache.rs
index 79036097e..e1be01270 100644
--- a/src/cache.rs
+++ b/src/cache.rs
@@ -365,7 +365,7 @@ impl Output {
                     Ok(cache) => {
                         tracing::info!("Restoring cache from {:?}", cache_dir);
                         self = self
-                            .fetch_sources(tool_configuration)
+                            .fetch_sources(tool_configuration, apply_patch_custom)
                             .await
                             .into_diagnostic()?;
                         return self.restore_cache(cache, cache_dir).await;
@@ -388,6 +388,7 @@ impl Output {
             &self.build_configuration.directories,
             &self.system_tools,
             tool_configuration,
+            apply_patch_custom,
         )
         .await
         .into_diagnostic()?;
@@ -410,10 +411,15 @@ impl Output {
             ignore_run_exports: cache_output.ignore_run_exports.clone().unwrap_or_default(),
         };
 
-        let finalized_dependencies =
-            resolve_dependencies(&requirements, &self, &channels, tool_configuration)
-                .await
-                .unwrap();
+        let finalized_dependencies = resolve_dependencies(
+            &requirements,
+            &self,
+            &channels,
+            tool_configuration,
+            RunExportsDownload::DownloadMissing,
+        )
+        .await
+        .unwrap();
 
         install_environments(&self, &finalized_dependencies, tool_configuration)
             .await
diff --git a/src/recipe/parser/about.rs b/src/recipe/parser/about.rs
index 9adb2022e..9dcf9f817 100644
--- a/src/recipe/parser/about.rs
+++ b/src/recipe/parser/about.rs
@@ -75,7 +75,6 @@ impl About {
         merge_field!(documentation);
         merge_field!(license);
         merge_field!(license_family);
-        merge_field!(license_url);
         merge_field!(summary);
         merge_field!(description);
         merge_field!(prelink_message);

From 44125e623cb949f970aa0f6f32ea86186d86cc4f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Sun, 19 Oct 2025 13:40:49 +0300
Subject: [PATCH 13/29] hmm

---
 src/console_utils.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/console_utils.rs b/src/console_utils.rs
index df2b0f92c..1847b0081 100644
--- a/src/console_utils.rs
+++ b/src/console_utils.rs
@@ -543,8 +543,8 @@ impl<S: Subscriber> Layer<S> for GitHubActionsLayer {
         let message = String::from_utf8_lossy(&message);
 
         match *metadata.level() {
-            Level::ERROR => println!("::error ::{}", message),
-            Level::WARN => println!("::warning ::{}", message),
+            Level::ERROR => eprintln!("::error ::{}", message),
+            Level::WARN => eprintln!("::warning ::{}", message),
             _ => {}
         }
     }

From 9ef33d0427e2241461cd97e88d6db51a61946ff6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Sun, 19 Oct 2025 14:31:47 +0300
Subject: [PATCH 14/29] extra fixes and circular dependency protection

---
 src/cache.rs                        |  2 +-
 src/recipe/parser.rs                | 14 ++++++++++++++
 src/render/resolved_dependencies.rs |  7 +++++--
 src/variant_render.rs               | 27 ---------------------------
 4 files changed, 20 insertions(+), 30 deletions(-)

diff --git a/src/cache.rs b/src/cache.rs
index 7bf218739..7f22808c2 100644
--- a/src/cache.rs
+++ b/src/cache.rs
@@ -420,7 +420,7 @@ impl Output {
             RunExportsDownload::DownloadMissing,
         )
         .await
-        .unwrap();
+        .into_diagnostic()?;
 
         install_environments(&self, &finalized_dependencies, tool_configuration)
             .await
diff --git a/src/recipe/parser.rs b/src/recipe/parser.rs
index 171f8636f..1210f2215 100644
--- a/src/recipe/parser.rs
+++ b/src/recipe/parser.rs
@@ -445,6 +445,7 @@ impl Recipe {
     ) -> Vec<CacheOutput> {
         let mut result = Vec::new();
         let mut seen = HashSet::new();
+        let mut visiting = HashSet::new();
 
         // Function to collect all transitive dependencies
         fn collect_dependencies(
@@ -453,7 +454,16 @@ impl Recipe {
             inheritance_relationships: &HashMap<String, Vec<String>>,
             result: &mut Vec<CacheOutput>,
             seen: &mut HashSet<String>,
+            visiting: &mut HashSet<String>,
         ) {
+            // Detect circular dependencies
+            if visiting.contains(name) {
+                // Circular dependency detected, skip to prevent infinite recursion
+                return;
+            }
+
+            visiting.insert(name.to_string());
+
             if let Some(cache_names) = inheritance_relationships.get(name) {
                 for cache_name in cache_names {
                     // First, recursively collect dependencies of this cache
@@ -463,6 +473,7 @@ impl Recipe {
                         inheritance_relationships,
                         result,
                         seen,
+                        visiting,
                     );
 
                     // Then add the cache itself if we haven't seen it yet
@@ -477,6 +488,8 @@ impl Recipe {
                     }
                 }
             }
+
+            visiting.remove(name);
         }
 
         collect_dependencies(
@@ -485,6 +498,7 @@ impl Recipe {
             inheritance_relationships,
             &mut result,
             &mut seen,
+            &mut visiting,
         );
         result
     }
diff --git a/src/render/resolved_dependencies.rs b/src/render/resolved_dependencies.rs
index e3d37beb6..56dbc2851 100644
--- a/src/render/resolved_dependencies.rs
+++ b/src/render/resolved_dependencies.rs
@@ -1014,6 +1014,9 @@ pub(crate) async fn resolve_dependencies(
     if let Some(cache) = &output.finalized_cache_dependencies {
         // add in the run exports from the cache
         // filter run dependencies that came from run exports
+        let cache_ignore_run_exports =
+            get_cache_ignore_run_exports(output, &output_ignore_run_exports);
+
         let cache_run_exports: Vec<_> = cache
             .run
             .depends
@@ -1026,10 +1029,10 @@ pub(crate) async fn resolve_dependencies(
 
                     let by_name = spec_name
                         .as_ref()
-                        .map(|n| output_ignore_run_exports.by_name().contains(n))
+                        .map(|n| cache_ignore_run_exports.by_name().contains(n))
                         .unwrap_or(false);
                     let by_package = source_package
-                        .map(|s| output_ignore_run_exports.from_package().contains(&s))
+                        .map(|s| cache_ignore_run_exports.from_package().contains(&s))
                         .unwrap_or(false);
 
                     !by_name && !by_package
diff --git a/src/variant_render.rs b/src/variant_render.rs
index e295c8919..a35857365 100644
--- a/src/variant_render.rs
+++ b/src/variant_render.rs
@@ -469,33 +469,6 @@ pub(crate) fn stage_1_render<S: SourceCode>(
 
             additional_variables.extend(extra_use_keys);
 
-            // Add variant keys from specific cache outputs referenced via inherit
-            for cache_output in &output.cache_outputs {
-                for dep in &cache_output.requirements.build {
-                    if let crate::recipe::parser::Dependency::Spec(spec) = dep {
-                        if spec.version.is_none() && spec.build.is_none() {
-                            if let Some(name) = &spec.name {
-                                additional_variables.insert(name.as_normalized().into());
-                            }
-                        }
-                    }
-                }
-
-                for dep in &cache_output.requirements.host {
-                    if let crate::recipe::parser::Dependency::Spec(spec) = dep {
-                        if spec.version.is_none() && spec.build.is_none() {
-                            if let Some(name) = &spec.name {
-                                additional_variables.insert(name.as_normalized().into());
-                            }
-                        }
-                    }
-                }
-
-                for key in &cache_output.build.variant.use_keys {
-                    additional_variables.insert(key.as_str().into());
-                }
-            }
-
             // If the recipe is `noarch: python` we can remove an empty python key that
             // comes from the dependencies
             if output.build().noarch().is_python() {

From 455397ad32c6dc4162fd01c548f5e2cc7b322df5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Sun, 19 Oct 2025 15:22:50 +0300
Subject: [PATCH 15/29] fixes

---
 src/variant_render.rs                         | 143 ++++++++----------
 .../cache_multiple_outputs/recipe.yaml        |  24 ++-
 .../recipes/cache_run_exports/recipe.yaml     |  12 +-
 3 files changed, 90 insertions(+), 89 deletions(-)

diff --git a/src/variant_render.rs b/src/variant_render.rs
index a35857365..a4de9c8fb 100644
--- a/src/variant_render.rs
+++ b/src/variant_render.rs
@@ -52,6 +52,40 @@ fn inherit_flags_from_output(output: &Node) -> (bool, bool) {
     }
 }
 
+/// Extract normalized names from unversioned dependency specs (specs without version or build constraints)
+fn collect_unversioned_deps<'a>(
+    deps: impl Iterator<Item = &'a Dependency> + 'a,
+) -> impl Iterator<Item = NormalizedKey> + 'a {
+    deps.filter_map(|dep| match dep {
+        Dependency::Spec(spec) if spec.version.is_none() && spec.build.is_none() => {
+            spec.name.as_ref().map(|n| n.as_normalized().into())
+        }
+        _ => None,
+    })
+}
+
+/// Apply cache inheritance to a parsed recipe from a cache output
+fn apply_cache_inheritance(
+    recipe: &mut Recipe,
+    cache: &crate::recipe::parser::CacheOutput,
+    inherit_run_exports: bool,
+    inherit_requirements: bool,
+) {
+    let reqs = &mut recipe.requirements;
+
+    if inherit_requirements {
+        reqs.build.extend(cache.requirements.build.iter().cloned());
+        reqs.host.extend(cache.requirements.host.iter().cloned());
+    }
+
+    if inherit_run_exports {
+        reqs.run_exports.extend_from(&cache.run_exports);
+        if let Some(ignore) = &cache.ignore_run_exports {
+            reqs.ignore_run_exports = reqs.ignore_run_exports(Some(ignore));
+        }
+    }
+}
+
 /// All the raw outputs of a single recipe.yaml
 #[derive(Clone, Debug)]
 pub struct RawOutputVec {
@@ -150,29 +184,12 @@ pub(crate) fn stage_0_render<S: SourceCode>(
                         .find(|c| c.name.as_normalized() == cache_name.as_str())
                     {
                         cache_list.push(cache_output.clone());
-
-                        if inherit_requirements {
-                            parsed_recipe
-                                .requirements
-                                .build
-                                .extend(cache_output.requirements.build.iter().cloned());
-                            parsed_recipe
-                                .requirements
-                                .host
-                                .extend(cache_output.requirements.host.iter().cloned());
-                        }
-
-                        if inherit_run_exports {
-                            parsed_recipe
-                                .requirements
-                                .run_exports
-                                .extend_from(&cache_output.run_exports);
-                            if let Some(cache_ignore) = &cache_output.ignore_run_exports {
-                                parsed_recipe.requirements.ignore_run_exports = parsed_recipe
-                                    .requirements
-                                    .ignore_run_exports(Some(cache_ignore));
-                            }
-                        }
+                        apply_cache_inheritance(
+                            &mut parsed_recipe,
+                            cache_output,
+                            inherit_run_exports,
+                            inherit_requirements,
+                        );
                     }
                 }
                 parsed_recipe.cache_outputs = cache_list;
@@ -396,17 +413,7 @@ pub(crate) fn stage_1_render<S: SourceCode>(
             let mut additional_variables = HashSet::<NormalizedKey>::new();
             let mut exact_pins = HashSet::<PackageName>::new();
             // Add in variants from the dependencies as we find them
-            for dep in output.build_time_requirements() {
-                if let Dependency::Spec(spec) = dep {
-                    let is_simple = spec.version.is_none() && spec.build.is_none();
-                    // add in the variant key for this dependency that has no version specifier
-                    if is_simple {
-                        if let Some(ref name) = spec.name {
-                            additional_variables.insert(name.as_normalized().into());
-                        }
-                    }
-                }
-            }
+            additional_variables.extend(collect_unversioned_deps(output.build_time_requirements()));
 
             // Add variant keys from cache build if present (for top-level cache)
             if let Some(cache) = &output.cache {
@@ -422,29 +429,21 @@ pub(crate) fn stage_1_render<S: SourceCode>(
 
             // Add variant keys from specific cache outputs referenced via inherit
             for cache_output in &output.cache_outputs {
-                for dep in &cache_output.requirements.build {
-                    if let crate::recipe::parser::Dependency::Spec(spec) = dep {
-                        if spec.version.is_none() && spec.build.is_none() {
-                            if let Some(name) = &spec.name {
-                                additional_variables.insert(name.as_normalized().into());
-                            }
-                        }
-                    }
-                }
-
-                for dep in &cache_output.requirements.host {
-                    if let crate::recipe::parser::Dependency::Spec(spec) = dep {
-                        if spec.version.is_none() && spec.build.is_none() {
-                            if let Some(name) = &spec.name {
-                                additional_variables.insert(name.as_normalized().into());
-                            }
-                        }
-                    }
-                }
-
-                for key in &cache_output.build.variant.use_keys {
-                    additional_variables.insert(key.as_str().into());
-                }
+                additional_variables.extend(collect_unversioned_deps(
+                    cache_output
+                        .requirements
+                        .build
+                        .iter()
+                        .chain(cache_output.requirements.host.iter()),
+                ));
+                additional_variables.extend(
+                    cache_output
+                        .build
+                        .variant
+                        .use_keys
+                        .iter()
+                        .map(|k| k.as_str().into()),
+                );
             }
 
             // We want to add something to packages that are requiring a subpackage
@@ -542,29 +541,13 @@ pub(crate) fn stage_1_render<S: SourceCode>(
                 // Re-apply inheritance from cache outputs (run_exports, requirements, ignore)
                 // This is needed because we re-parsed from the raw node
                 let (inherit_run_exports, inherit_requirements) = inherit_flags_from_output(output);
-                for cache_output in &parsed_recipe.cache_outputs {
-                    if inherit_requirements {
-                        parsed_recipe
-                            .requirements
-                            .build
-                            .extend(cache_output.requirements.build.iter().cloned());
-                        parsed_recipe
-                            .requirements
-                            .host
-                            .extend(cache_output.requirements.host.iter().cloned());
-                    }
-
-                    if inherit_run_exports {
-                        parsed_recipe
-                            .requirements
-                            .run_exports
-                            .extend_from(&cache_output.run_exports);
-                        if let Some(cache_ignore) = &cache_output.ignore_run_exports {
-                            parsed_recipe.requirements.ignore_run_exports = parsed_recipe
-                                .requirements
-                                .ignore_run_exports(Some(cache_ignore));
-                        }
-                    }
+                for cache_output in &parsed_recipe.cache_outputs.clone() {
+                    apply_cache_inheritance(
+                        &mut parsed_recipe,
+                        cache_output,
+                        inherit_run_exports,
+                        inherit_requirements,
+                    );
                 }
 
                 inner.push(Stage1Inner {
diff --git a/test-data/recipes/cache_multiple_outputs/recipe.yaml b/test-data/recipes/cache_multiple_outputs/recipe.yaml
index 7db781bb6..3d0868413 100644
--- a/test-data/recipes/cache_multiple_outputs/recipe.yaml
+++ b/test-data/recipes/cache_multiple_outputs/recipe.yaml
@@ -3,10 +3,17 @@ outputs:
       name: base-cache
     build:
       script:
-        - mkdir -p $PREFIX/lib
-        - mkdir -p $PREFIX/include
-        - echo "This is the base library" > $PREFIX/lib/base.txt
-        - echo "// Base header" > $PREFIX/include/base.h
+        - if: unix
+          then:
+            - mkdir -p $PREFIX/lib
+            - mkdir -p $PREFIX/include
+            - echo "This is the base library" > $PREFIX/lib/base.txt
+            - echo "// Base header" > $PREFIX/include/base.h
+          else:
+            - mkdir %PREFIX%\lib
+            - mkdir %PREFIX%\include
+            - (echo This is the base library) > %PREFIX%\lib\base.txt
+            - (echo // Base header) > %PREFIX%\include\base.h
     requirements:
       build:
         - cmake
@@ -16,8 +23,13 @@ outputs:
     inherit: base-cache
     build:
       script:
-        - echo "This is the extended library" > $PREFIX/lib/extended.txt
-        - echo "// Extended header" > $PREFIX/include/extended.h
+        - if: unix
+          then:
+            - echo "This is the extended library" > $PREFIX/lib/extended.txt
+            - echo "// Extended header" > $PREFIX/include/extended.h
+          else:
+            - (echo This is the extended library) > %PREFIX%\lib\extended.txt
+            - (echo // Extended header) > %PREFIX%\include\extended.h
     requirements:
       build:
         - ninja
diff --git a/test-data/recipes/cache_run_exports/recipe.yaml b/test-data/recipes/cache_run_exports/recipe.yaml
index 77c3a649a..b97b474fe 100644
--- a/test-data/recipes/cache_run_exports/recipe.yaml
+++ b/test-data/recipes/cache_run_exports/recipe.yaml
@@ -11,9 +11,15 @@ outputs:
         - libbar
     build:
       script:
-        - mkdir -p $PREFIX/lib
-        - echo "library content" > $PREFIX/lib/libfoo.so
-        - echo "library content" > $PREFIX/lib/libbar.so
+        - if: unix
+          then:
+            - mkdir -p $PREFIX/lib
+            - echo "library content" > $PREFIX/lib/libfoo.so
+            - echo "library content" > $PREFIX/lib/libbar.so
+          else:
+            - mkdir %PREFIX%\lib
+            - (echo library content) > %PREFIX%\lib\libfoo.so
+            - (echo library content) > %PREFIX%\lib\libbar.so
 
   - package:
       name: lib-package

From 92596bfdc2ac5053ad2bc149de355f6deac4fe48 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Sun, 19 Oct 2025 16:07:09 +0300
Subject: [PATCH 16/29] extra logging

---
 src/recipe/parser.rs              | 5 ++++-
 src/recipe/parser/cache_output.rs | 8 +++++++-
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/recipe/parser.rs b/src/recipe/parser.rs
index 1210f2215..e59dd79b2 100644
--- a/src/recipe/parser.rs
+++ b/src/recipe/parser.rs
@@ -458,7 +458,10 @@ impl Recipe {
         ) {
             // Detect circular dependencies
             if visiting.contains(name) {
-                // Circular dependency detected, skip to prevent infinite recursion
+                tracing::warn!(
+                    "Circular cache dependency detected involving '{}' - this likely indicates a configuration error",
+                    name
+                );
                 return;
             }
 
diff --git a/src/recipe/parser/cache_output.rs b/src/recipe/parser/cache_output.rs
index 64a2b5387..87396ca96 100644
--- a/src/recipe/parser/cache_output.rs
+++ b/src/recipe/parser/cache_output.rs
@@ -91,7 +91,7 @@ impl<'de> DeserializeTrait<'de> for CacheOutput {
             {
                 let mut name = None;
                 let mut source = None;
-                let mut build = None;
+                let mut build: Option<CacheBuild> = None;
                 let mut requirements = None;
                 let mut run_exports = None;
                 let mut ignore_run_exports = None;
@@ -147,6 +147,12 @@ impl<'de> DeserializeTrait<'de> for CacheOutput {
                 let name = name.ok_or_else(|| de::Error::missing_field("name"))?;
                 let source = source.unwrap_or_else(Vec::new);
                 let build = build.ok_or_else(|| de::Error::missing_field("build"))?;
+                if build.script.is_none() {
+                    return Err(de::Error::custom(
+                        "cache outputs require an explicit build script (build.script field is required)",
+                    ));
+                }
+
                 let requirements = requirements.unwrap_or_else(CacheRequirements::default);
                 let run_exports = run_exports.unwrap_or_else(RunExports::default);
                 let ignore_run_exports = ignore_run_exports;

From 8f94109404ae71344007c9ea1615a77b68387c75 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Sun, 19 Oct 2025 17:45:19 +0300
Subject: [PATCH 17/29] unwrap to into diagnostic

---
 src/cache.rs | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/cache.rs b/src/cache.rs
index 7f22808c2..b4233b6d2 100644
--- a/src/cache.rs
+++ b/src/cache.rs
@@ -530,11 +530,8 @@ impl Output {
             source_files: work_dir_files.copied_paths().to_vec(),
         };
 
-        fs::write(
-            cache_dir.join("cache.json"),
-            serde_json::to_string(&cache).unwrap(),
-        )
-        .into_diagnostic()?;
+        let cache_json = serde_json::to_string(&cache).into_diagnostic()?;
+        fs::write(cache_dir.join("cache.json"), cache_json).into_diagnostic()?;
 
         // The files are already in PREFIX from the build script, so we don't need to restore them.
         // However, we need to track them so subsequent cache builds that inherit from this one
@@ -736,7 +733,8 @@ impl Output {
             };
 
             let cache_file = cache_dir.join("cache.json");
-            fs::write(cache_file, serde_json::to_string(&cache).unwrap()).into_diagnostic()?;
+            let cache_json = serde_json::to_string(&cache).into_diagnostic()?;
+            fs::write(cache_file, cache_json).into_diagnostic()?;
 
             // remove prefix to get it in pristine state and restore the cache
             fs::remove_dir_all(self.prefix()).into_diagnostic()?;

From ad5ff8062991eab6ffc83c3615cbdbb73864bc1e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Sun, 19 Oct 2025 17:55:12 +0300
Subject: [PATCH 18/29] inherit error out outside of output

---
 src/recipe/parser.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/recipe/parser.rs b/src/recipe/parser.rs
index e59dd79b2..8d284202e 100644
--- a/src/recipe/parser.rs
+++ b/src/recipe/parser.rs
@@ -310,6 +310,12 @@ impl Recipe {
                     "tests" => tests = value.try_convert(key_str)?,
                     "about" => about = value.try_convert(key_str)?,
                     "inherit" => {
+                        return Err(vec![_partialerror!(
+                            *key.span(),
+                            ErrorKind::InvalidField("inherit".to_string().into()),
+                            help = "The 'inherit' key is only valid in outputs, not at the recipe level. \
+                                    To use top-level cache, use the 'cache' key instead and omit 'inherit' in outputs."
+                        )]);
                     }
                     "context" => {}
                     "extra" => extra = value.as_mapping().ok_or_else(|| {

From e145eb415db6ecf49a2ad12d1694fefe0062654d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Sun, 19 Oct 2025 18:13:16 +0300
Subject: [PATCH 19/29] cleanup

---
 src/lib.rs            | 2 +-
 src/variant_config.rs | 8 ++++----
 src/variant_render.rs | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 07931025d..3be2457db 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -228,7 +228,7 @@ pub async fn get_build_output(
     });
 
     let mut global_cache_outputs = Vec::new();
-    let mut inheritance_relationships = std::collections::HashMap::new();
+    let mut inheritance_relationships = HashMap::new();
 
     if has_cache_or_inheritance {
         let has_toplevel_cache = outputs.iter().any(|output| {
diff --git a/src/variant_config.rs b/src/variant_config.rs
index cbdecb8f2..be9d46c67 100644
--- a/src/variant_config.rs
+++ b/src/variant_config.rs
@@ -510,7 +510,7 @@ impl VariantConfig {
         recipe: S,
         selector_config: &SelectorConfig,
         cache_outputs: &[crate::recipe::parser::CacheOutput],
-        inheritance_relationships: &std::collections::HashMap<String, Vec<String>>,
+        inheritance_relationships: &HashMap<String, Vec<String>>,
     ) -> Result<IndexSet<DiscoveredOutput>, VariantError<S>> {
         // find all jinja variables
         let stage_0 = stage_0_render(
@@ -786,7 +786,7 @@ mod tests {
                 recipe_text.as_str(),
                 &selector_config,
                 &[],
-                &std::collections::HashMap::new(),
+                &HashMap::new(),
             )
             .unwrap();
 
@@ -934,7 +934,7 @@ compiler:
                     recipe_text.as_str(),
                     &selector_config,
                     &[],
-                    &std::collections::HashMap::new(),
+                    &HashMap::new(),
                 )
                 .unwrap();
 
@@ -970,7 +970,7 @@ compiler:
                 recipe_text.as_str(),
                 &selector_config,
                 &[],
-                &std::collections::HashMap::new(),
+                &HashMap::new(),
             )
             .unwrap();
 
diff --git a/src/variant_render.rs b/src/variant_render.rs
index a4de9c8fb..a20772fba 100644
--- a/src/variant_render.rs
+++ b/src/variant_render.rs
@@ -118,7 +118,7 @@ pub(crate) fn stage_0_render<S: SourceCode>(
     selector_config: &SelectorConfig,
     variant_config: &VariantConfig,
     cache_outputs: &[crate::recipe::parser::CacheOutput],
-    inheritance_relationships: &std::collections::HashMap<String, Vec<String>>,
+    inheritance_relationships: &HashMap<String, Vec<String>>,
 ) -> Result<Vec<Stage0Render<S>>, VariantError<S>> {
     let used_vars = outputs
         .iter()

From 1cab8940e98fe565a3258877d735b72a25c3cb87 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Sun, 19 Oct 2025 20:04:43 +0300
Subject: [PATCH 20/29] fixes

---
 src/lib.rs                  |  2 +-
 src/recipe/parser.rs        | 42 ++++++++++++++++++++++++++++++-------
 src/recipe/parser/output.rs |  2 +-
 src/variant_render.rs       | 23 ++++++++++----------
 4 files changed, 49 insertions(+), 20 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 3be2457db..9da3bb58d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -232,7 +232,7 @@ pub async fn get_build_output(
 
     if has_cache_or_inheritance {
         let has_toplevel_cache = outputs.iter().any(|output| {
-            if let Ok(recipe) = Recipe::from_node(output, selector_config.clone()) {
+            if let Ok(recipe) = Recipe::from_output_node(output, selector_config.clone()) {
                 recipe.cache.is_some()
             } else {
                 false
diff --git a/src/recipe/parser.rs b/src/recipe/parser.rs
index 8d284202e..374a23771 100644
--- a/src/recipe/parser.rs
+++ b/src/recipe/parser.rs
@@ -188,6 +188,22 @@ impl Recipe {
     pub fn from_node(
         root_node: &Node,
         jinja_opt: SelectorConfig,
+    ) -> Result<Self, Vec<PartialParsingError>> {
+        Self::from_node_with_options(root_node, jinja_opt, false)
+    }
+
+    /// Create recipes from an output [`Node`] that may contain inheritance metadata.
+    pub fn from_output_node(
+        root_node: &Node,
+        jinja_opt: SelectorConfig,
+    ) -> Result<Self, Vec<PartialParsingError>> {
+        Self::from_node_with_options(root_node, jinja_opt, true)
+    }
+
+    fn from_node_with_options(
+        root_node: &Node,
+        jinja_opt: SelectorConfig,
+        allow_inherit: bool,
     ) -> Result<Self, Vec<PartialParsingError>> {
         let experimental = jinja_opt.experimental;
         let mut jinja = Jinja::new(jinja_opt);
@@ -310,12 +326,24 @@ impl Recipe {
                     "tests" => tests = value.try_convert(key_str)?,
                     "about" => about = value.try_convert(key_str)?,
                     "inherit" => {
-                        return Err(vec![_partialerror!(
-                            *key.span(),
-                            ErrorKind::InvalidField("inherit".to_string().into()),
-                            help = "The 'inherit' key is only valid in outputs, not at the recipe level. \
-                                    To use top-level cache, use the 'cache' key instead and omit 'inherit' in outputs."
-                        )]);
+                        if allow_inherit {
+                            if experimental {
+                                value.try_convert::<InheritSpec>("output.inherit")?;
+                            } else {
+                                return Err(vec![_partialerror!(
+                                    *value.span(),
+                                    ErrorKind::ExperimentalOnly("inherit".to_string()),
+                                    help = "The `inherit` key requires enabling experimental mode (`--experimental`)"
+                                )]);
+                            }
+                        } else {
+                            return Err(vec![_partialerror!(
+                                *key.span(),
+                                ErrorKind::InvalidField("inherit".to_string().into()),
+                                help = "The 'inherit' key is only valid in outputs, not at the recipe level. \
+                                        To use top-level cache, use the 'cache' key instead and omit 'inherit' in outputs."
+                            )]);
+                        }
                     }
                     "context" => {}
                     "extra" => extra = value.as_mapping().ok_or_else(|| {
@@ -574,7 +602,7 @@ mod tests {
             include_str!("../../test-data/recipes/test-parsing/recipe_bad_skip_multi.yaml");
         let recipes = find_outputs_from_src(raw_recipe).unwrap();
         for recipe in recipes {
-            let recipe = Recipe::from_node(&recipe, SelectorConfig::default());
+            let recipe = Recipe::from_output_node(&recipe, SelectorConfig::default());
             if recipe.is_ok() {
                 assert_eq!(recipe.unwrap().package().name().as_normalized(), "zlib-dev");
                 continue;
diff --git a/src/recipe/parser/output.rs b/src/recipe/parser/output.rs
index 650190a6d..76eeb0ab7 100644
--- a/src/recipe/parser/output.rs
+++ b/src/recipe/parser/output.rs
@@ -1025,7 +1025,7 @@ mod tests {
         let src = fs::read_to_string(yaml_file).unwrap();
         let nodes = find_outputs_from_src(src.as_str()).unwrap();
         let parsed_recipe =
-            Recipe::from_node(&nodes[0], SelectorConfig::default()).map_err(|err| {
+            Recipe::from_output_node(&nodes[0], SelectorConfig::default()).map_err(|err| {
                 err.into_iter()
                     .map(|err| ParsingError::from_partial(src.as_str(), err))
                     .collect::<Vec<_>>()
diff --git a/src/variant_render.rs b/src/variant_render.rs
index a20772fba..8fe1a5db2 100644
--- a/src/variant_render.rs
+++ b/src/variant_render.rs
@@ -162,7 +162,7 @@ pub(crate) fn stage_0_render<S: SourceCode>(
             let config_with_variant =
                 selector_config.with_variant(combination.clone(), selector_config.target_platform);
 
-            let mut parsed_recipe = Recipe::from_node(output, config_with_variant)
+            let mut parsed_recipe = Recipe::from_output_node(output, config_with_variant)
                 .map_err(|err| {
                     let errs: ParseErrors<_> = err
                         .into_iter()
@@ -523,16 +523,17 @@ pub(crate) fn stage_1_render<S: SourceCode>(
                 let config_with_variant = selector_config
                     .with_variant(combination.clone(), selector_config.target_platform);
 
-                let mut parsed_recipe = Recipe::from_node(output, config_with_variant.clone())
-                    .map_err(|err| {
-                        let errs: ParseErrors<_> = err
-                            .into_iter()
-                            .map(|err| ParsingError::from_partial(r.source.clone(), err))
-                            .collect::<Vec<_>>()
-                            .into();
-                        errs
-                    })
-                    .map_err(VariantConfigError::from)?;
+                let mut parsed_recipe =
+                    Recipe::from_output_node(output, config_with_variant.clone())
+                        .map_err(|err| {
+                            let errs: ParseErrors<_> = err
+                                .into_iter()
+                                .map(|err| ParsingError::from_partial(r.source.clone(), err))
+                                .collect::<Vec<_>>()
+                                .into();
+                            errs
+                        })
+                        .map_err(VariantConfigError::from)?;
 
                 // Preserve cache_outputs and inherited requirements from stage 0
                 let stage0_output = &r.rendered_outputs[idx];

From f377e8c972ad2cdc1f8bd8adf52870e34fc42b4c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Sun, 19 Oct 2025 20:09:25 +0300
Subject: [PATCH 21/29] fix

---
 src/recipe/parser.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/recipe/parser.rs b/src/recipe/parser.rs
index 374a23771..2e67b35f3 100644
--- a/src/recipe/parser.rs
+++ b/src/recipe/parser.rs
@@ -328,7 +328,8 @@ impl Recipe {
                     "inherit" => {
                         if allow_inherit {
                             if experimental {
-                                value.try_convert::<InheritSpec>("output.inherit")?;
+                                let _: InheritSpec =
+                                    value.try_convert("output.inherit")?;
                             } else {
                                 return Err(vec![_partialerror!(
                                     *value.span(),

From 96c46931b23877b2c496ccbc5b234a983783089c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Sun, 19 Oct 2025 22:35:34 +0300
Subject: [PATCH 22/29] binary

---
 src/cache.rs              | 134 +++++++++++++++++++++++++-------------
 src/packaging/metadata.rs |  65 ++++++++++++++++++
 2 files changed, 154 insertions(+), 45 deletions(-)

diff --git a/src/cache.rs b/src/cache.rs
index b4233b6d2..0715cb09b 100644
--- a/src/cache.rs
+++ b/src/cache.rs
@@ -1,9 +1,11 @@
 //! Functions to deal with the build cache
 use std::{
     collections::{BTreeMap, HashSet},
-    path::PathBuf,
+    io,
+    path::Path,
 };
 
+use content_inspector::ContentType;
 use fs_err as fs;
 use miette::{Context, IntoDiagnostic};
 use serde::{Deserialize, Serialize};
@@ -11,9 +13,14 @@ use sha2::{Digest, Sha256};
 
 use crate::{
     env_vars,
-    metadata::Output,
-    metadata::build_reindexed_channels,
-    packaging::Files,
+    metadata::{Output, build_reindexed_channels},
+    packaging::{
+        Files,
+        metadata::{
+            contains_prefix_binary, contains_prefix_text,
+            rewrite_prefix_in_file,
+        },
+    },
     recipe::{
         Jinja,
         parser::{Dependency, Requirements, Source},
@@ -28,6 +35,40 @@ use crate::{
     },
 };
 
+/// Check if a file contains the prefix and determine if it's binary or text
+/// Returns (has_prefix, is_text)
+fn check_file_for_prefix(file_path: &Path, prefix: &Path, prefix_str: &str) -> (bool, bool) {
+    let content_type = content_inspector::inspect_path(file_path);
+    let is_text = content_type.is_text()
+        && matches!(content_type, ContentType::UTF_8 | ContentType::UTF_8_BOM);
+    
+    if is_text {
+        match contains_prefix_text(file_path, prefix) {
+            Ok(Some(_)) => (true, true),
+            Ok(None) => (false, true),
+            Err(_) => (false, true),
+        }
+    } else {
+        #[cfg(target_family = "unix")]
+        {
+            match contains_prefix_binary(file_path, prefix) {
+                Ok(has_prefix) => (has_prefix, false),
+                Err(_) => (false, false),
+            }
+        }
+        #[cfg(target_family = "windows")]
+        {
+            if let Ok(contents) = fs::read(file_path) {
+                let prefix_bytes = prefix.to_string_lossy().as_bytes();
+                (contents.windows(prefix_bytes.len()).any(|window| window == prefix_bytes), false)
+            } else {
+                (false, false)
+            }
+        }
+    }
+}
+
+
 /// Error type for cache key generation
 #[derive(Debug, thiserror::Error)]
 pub enum CacheKeyError {
@@ -76,6 +117,11 @@ pub struct Cache {
     #[serde(default)]
     pub files_with_prefix: Vec<PathBuf>,
 
+    /// Files (relative to prefix/work_dir) that contain the old prefix string and
+    /// are binary files. These need to be handled during prefix replacement.
+    #[serde(default)]
+    pub binary_files_with_prefix: Vec<PathBuf>,
+
     /// Files (relative to work_dir) that contain the old work_dir path and
     /// should be rewritten when restoring to a different location.
     #[serde(default)]
@@ -266,11 +312,9 @@ impl Output {
         );
 
         // If the cache was built under a different prefix, rewrite occurrences of
-        // the old prefix in restored text files.
+        // the old prefix in restored text and binary files.
         if cache.prefix != *self.prefix() {
-            let old = cache.prefix.to_string_lossy().to_string();
-            let new = self.prefix().to_string_lossy().to_string();
-            for rel in cache.files_with_prefix.iter() {
+            for rel in cache.files_with_prefix.iter().chain(cache.binary_files_with_prefix.iter()) {
                 for base in [
                     self.prefix(),
                     &self.build_configuration.directories.work_dir,
@@ -279,17 +323,13 @@ impl Output {
                     if !path.exists() {
                         continue;
                     }
-                    if let Ok(contents) = fs::read_to_string(&path) {
-                        if contents.contains(&old) {
-                            let replaced = contents.replace(&old, &new);
-                            if let Err(e) = fs::write(&path, replaced) {
-                                tracing::warn!(
-                                    "Failed to rewrite restored file {}: {}",
-                                    path.display(),
-                                    e
-                                );
-                            }
-                        }
+                    
+                    if let Err(e) = rewrite_prefix_in_file(&path, &cache.prefix, self.prefix()) {
+                        tracing::warn!(
+                            "Failed to rewrite restored file {}: {}",
+                            path.display(),
+                            e
+                        );
                     }
                 }
             }
@@ -300,29 +340,17 @@ impl Output {
         if !cache.work_dir.as_os_str().is_empty()
             && cache.work_dir != self.build_configuration.directories.work_dir
         {
-            let old = cache.work_dir.to_string_lossy().to_string();
-            let new = self
-                .build_configuration
-                .directories
-                .work_dir
-                .to_string_lossy()
-                .to_string();
             for rel in cache.files_with_work_dir.iter() {
                 let path = self.build_configuration.directories.work_dir.join(rel);
                 if !path.exists() {
                     continue;
                 }
-                if let Ok(contents) = fs::read_to_string(&path) {
-                    if contents.contains(&old) {
-                        let replaced = contents.replace(&old, &new);
-                        if let Err(e) = fs::write(&path, replaced) {
-                            tracing::warn!(
-                                "Failed to rewrite restored work_dir file {}: {}",
-                                path.display(),
-                                e
-                            );
-                        }
-                    }
+                if let Err(e) = rewrite_prefix_in_file(&path, &cache.work_dir, &self.build_configuration.directories.work_dir) {
+                    tracing::warn!(
+                        "Failed to rewrite restored work_dir file {}: {}",
+                        path.display(),
+                        e
+                    );
                 }
             }
         }
@@ -472,6 +500,7 @@ impl Output {
 
         // Track files that contain the old prefix for later path rewriting
         let mut files_with_prefix: Vec<PathBuf> = Vec::new();
+        let mut binary_files_with_prefix: Vec<PathBuf> = Vec::new();
         let old_prefix_str = self.prefix().to_string_lossy().to_string();
 
         for file in &new_files.new_files {
@@ -482,9 +511,12 @@ impl Output {
             let dest = prefix_cache_dir.join(stripped);
             copy_file(file, &dest, &mut creation_cache, &copy_options).into_diagnostic()?;
             copied_files.push(stripped.to_path_buf());
-            if let Ok(contents) = fs::read_to_string(file) {
-                if contents.contains(&old_prefix_str) {
-                    files_with_prefix.push(stripped.to_path_buf());
+            let (has_prefix, is_text) = check_file_for_prefix(file, self.prefix(), &old_prefix_str);
+            
+            if has_prefix {
+                match is_text {
+                    true => files_with_prefix.push(stripped.to_path_buf()),
+                    false => binary_files_with_prefix.push(stripped.to_path_buf()),
                 }
             }
         }
@@ -506,6 +538,7 @@ impl Output {
             work_dir: self.build_configuration.directories.work_dir.clone(),
             run_exports: cache_output.run_exports.clone(),
             files_with_prefix,
+            binary_files_with_prefix,
             files_with_work_dir: {
                 let mut files = Vec::new();
                 let old_work_dir_str = self
@@ -519,10 +552,10 @@ impl Output {
                     if abs.is_dir() {
                         continue;
                     }
-                    if let Ok(contents) = fs::read_to_string(&abs) {
-                        if contents.contains(&old_work_dir_str) {
-                            files.push(rel.to_path_buf());
-                        }
+                    match contains_prefix_text(&abs, &self.build_configuration.directories.work_dir) {
+                        Ok(Some(_)) => files.push(rel.to_path_buf()),
+                        Ok(None) => {},
+                        Err(_) => {},
                     }
                 }
                 files
@@ -694,6 +727,9 @@ impl Output {
             let mut creation_cache = HashSet::new();
             let mut copied_files = Vec::new();
             let copy_options = CopyOptions::default();
+            let mut files_with_prefix: Vec<PathBuf> = Vec::new();
+            let mut binary_files_with_prefix: Vec<PathBuf> = Vec::new();
+            let old_prefix_str = self.prefix().to_string_lossy().to_string();
 
             for file in &new_files.new_files {
                 // skip directories (if they are not a symlink)
@@ -707,6 +743,13 @@ impl Output {
                 let dest = &prefix_cache_dir.join(stripped);
                 copy_file(file, dest, &mut creation_cache, &copy_options).into_diagnostic()?;
                 copied_files.push(stripped.to_path_buf());
+                let (has_prefix, is_text) = check_file_for_prefix(file, self.prefix(), &old_prefix_str);
+                if has_prefix {
+                    match is_text {
+                        true => files_with_prefix.push(stripped.to_path_buf()),
+                        false => binary_files_with_prefix.push(stripped.to_path_buf()),
+                    }
+                }
             }
 
             // We also need to copy the work dir files to the cache
@@ -727,7 +770,8 @@ impl Output {
                 prefix: self.prefix().to_path_buf(),
                 work_dir: self.build_configuration.directories.work_dir.clone(),
                 run_exports: crate::recipe::parser::RunExports::default(),
-                files_with_prefix: Vec::new(),
+                files_with_prefix,
+                binary_files_with_prefix,
                 files_with_work_dir: Vec::new(),
                 source_files: work_dir_files.copied_paths().to_vec(),
             };
diff --git a/src/packaging/metadata.rs b/src/packaging/metadata.rs
index 156820b8c..1bf26a3c5 100644
--- a/src/packaging/metadata.rs
+++ b/src/packaging/metadata.rs
@@ -118,6 +118,71 @@ pub fn contains_prefix_text(
     Ok(detected_prefix)
 }
 
+/// Rewrite prefix in a file by determining if it's binary or text and replace them
+pub fn rewrite_prefix_in_file(
+    file_path: &Path,
+    old_prefix: &Path,
+    new_prefix: &Path,
+) -> Result<(), PackagingError> {
+    let content_type = content_inspector::inspect_path(file_path);
+    let is_text = content_type.is_text()
+        && matches!(content_type, ContentType::UTF_8 | ContentType::UTF_8_BOM);
+    
+    match is_text {
+        true => {
+            let old_prefix_str = old_prefix.to_string_lossy();
+            let new_prefix_str = new_prefix.to_string_lossy();
+            let contents = fs::read_to_string(file_path)?;
+            let replaced = contents.replace(&old_prefix_str, &new_prefix_str);
+            fs::write(file_path, replaced)?;
+            Ok(())
+        }
+        false => {
+            #[cfg(target_family = "unix")]
+            {
+                use std::os::unix::prelude::OsStrExt;
+                
+                let old_prefix_bytes = old_prefix.as_os_str().as_bytes();
+                let new_prefix_bytes = new_prefix.as_os_str().as_bytes();
+                
+                if new_prefix_bytes.len() > old_prefix_bytes.len() {
+                    return Err(PackagingError::IoError(std::io::Error::new(
+                        std::io::ErrorKind::InvalidInput,
+                        "New prefix is longer than old prefix, cannot replace in binary file",
+                    )));
+                }
+                
+                let mut file = File::options()
+                    .read(true)
+                    .write(true)
+                    .open(file_path)?;
+                
+                let mmap = unsafe { memmap2::MmapOptions::new().map_mut(&file) }?;
+                let mut pos = 0;
+                while pos <= mmap.len().saturating_sub(old_prefix_bytes.len()) {
+                    if &mmap[pos..pos + old_prefix_bytes.len()] == old_prefix_bytes {
+                        mmap[pos..pos + new_prefix_bytes.len()].copy_from_slice(new_prefix_bytes);
+                        let padding_len = old_prefix_bytes.len() - new_prefix_bytes.len();
+                        for i in 0..padding_len {
+                            mmap[pos + new_prefix_bytes.len() + i] = 0;
+                        }
+                    }
+                    pos += 1;
+                }
+                
+                Ok(())
+            }
+            #[cfg(target_family = "windows")]
+            {
+                Err(PackagingError::IoError(std::io::Error::new(
+                    std::io::ErrorKind::Unsupported,
+                    "Binary prefix replacement is not supported on Windows",
+                )))
+            }
+        }
+    }
+}
+
 /// Create a prefix placeholder object for the given file and prefix.
 /// This function will also search in the file for the prefix and determine if
 /// the file is binary or text.

From ccb6752fa9e1737b5116c74ff3cd9a26994e83c8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Sun, 19 Oct 2025 22:59:13 +0300
Subject: [PATCH 23/29] fixes

---
 src/cache.rs              | 70 +++++++++++++++++++--------------------
 src/packaging.rs          |  4 ++-
 src/packaging/metadata.rs | 24 ++++++--------
 3 files changed, 48 insertions(+), 50 deletions(-)

diff --git a/src/cache.rs b/src/cache.rs
index 0715cb09b..b041ad157 100644
--- a/src/cache.rs
+++ b/src/cache.rs
@@ -1,8 +1,7 @@
 //! Functions to deal with the build cache
 use std::{
     collections::{BTreeMap, HashSet},
-    io,
-    path::Path,
+    path::{Path, PathBuf},
 };
 
 use content_inspector::ContentType;
@@ -14,13 +13,7 @@ use sha2::{Digest, Sha256};
 use crate::{
     env_vars,
     metadata::{Output, build_reindexed_channels},
-    packaging::{
-        Files,
-        metadata::{
-            contains_prefix_binary, contains_prefix_text,
-            rewrite_prefix_in_file,
-        },
-    },
+    packaging::{Files, contains_prefix_binary, contains_prefix_text, rewrite_prefix_in_file},
     recipe::{
         Jinja,
         parser::{Dependency, Requirements, Source},
@@ -37,11 +30,15 @@ use crate::{
 
 /// Check if a file contains the prefix and determine if it's binary or text
 /// Returns (has_prefix, is_text)
-fn check_file_for_prefix(file_path: &Path, prefix: &Path, prefix_str: &str) -> (bool, bool) {
-    let content_type = content_inspector::inspect_path(file_path);
+fn check_file_for_prefix(file_path: &Path, prefix: &Path) -> (bool, bool) {
+    let content = match fs::read(file_path) {
+        Ok(content) => content,
+        Err(_) => return (false, false),
+    };
+    let content_type = content_inspector::inspect(&content);
     let is_text = content_type.is_text()
         && matches!(content_type, ContentType::UTF_8 | ContentType::UTF_8_BOM);
-    
+
     if is_text {
         match contains_prefix_text(file_path, prefix) {
             Ok(Some(_)) => (true, true),
@@ -60,7 +57,12 @@ fn check_file_for_prefix(file_path: &Path, prefix: &Path, prefix_str: &str) -> (
         {
             if let Ok(contents) = fs::read(file_path) {
                 let prefix_bytes = prefix.to_string_lossy().as_bytes();
-                (contents.windows(prefix_bytes.len()).any(|window| window == prefix_bytes), false)
+                (
+                    contents
+                        .windows(prefix_bytes.len())
+                        .any(|window| window == prefix_bytes),
+                    false,
+                )
             } else {
                 (false, false)
             }
@@ -68,7 +70,6 @@ fn check_file_for_prefix(file_path: &Path, prefix: &Path, prefix_str: &str) -> (
     }
 }
 
-
 /// Error type for cache key generation
 #[derive(Debug, thiserror::Error)]
 pub enum CacheKeyError {
@@ -314,7 +315,11 @@ impl Output {
         // If the cache was built under a different prefix, rewrite occurrences of
         // the old prefix in restored text and binary files.
         if cache.prefix != *self.prefix() {
-            for rel in cache.files_with_prefix.iter().chain(cache.binary_files_with_prefix.iter()) {
+            for rel in cache
+                .files_with_prefix
+                .iter()
+                .chain(cache.binary_files_with_prefix.iter())
+            {
                 for base in [
                     self.prefix(),
                     &self.build_configuration.directories.work_dir,
@@ -323,13 +328,9 @@ impl Output {
                     if !path.exists() {
                         continue;
                     }
-                    
+
                     if let Err(e) = rewrite_prefix_in_file(&path, &cache.prefix, self.prefix()) {
-                        tracing::warn!(
-                            "Failed to rewrite restored file {}: {}",
-                            path.display(),
-                            e
-                        );
+                        tracing::warn!("Failed to rewrite restored file {}: {}", path.display(), e);
                     }
                 }
             }
@@ -345,7 +346,11 @@ impl Output {
                 if !path.exists() {
                     continue;
                 }
-                if let Err(e) = rewrite_prefix_in_file(&path, &cache.work_dir, &self.build_configuration.directories.work_dir) {
+                if let Err(e) = rewrite_prefix_in_file(
+                    &path,
+                    &cache.work_dir,
+                    &self.build_configuration.directories.work_dir,
+                ) {
                     tracing::warn!(
                         "Failed to rewrite restored work_dir file {}: {}",
                         path.display(),
@@ -501,7 +506,6 @@ impl Output {
         // Track files that contain the old prefix for later path rewriting
         let mut files_with_prefix: Vec<PathBuf> = Vec::new();
         let mut binary_files_with_prefix: Vec<PathBuf> = Vec::new();
-        let old_prefix_str = self.prefix().to_string_lossy().to_string();
 
         for file in &new_files.new_files {
             if file.is_dir() && !file.is_symlink() {
@@ -511,8 +515,8 @@ impl Output {
             let dest = prefix_cache_dir.join(stripped);
             copy_file(file, &dest, &mut creation_cache, &copy_options).into_diagnostic()?;
             copied_files.push(stripped.to_path_buf());
-            let (has_prefix, is_text) = check_file_for_prefix(file, self.prefix(), &old_prefix_str);
-            
+            let (has_prefix, is_text) = check_file_for_prefix(file, self.prefix());
+
             if has_prefix {
                 match is_text {
                     true => files_with_prefix.push(stripped.to_path_buf()),
@@ -541,21 +545,16 @@ impl Output {
             binary_files_with_prefix,
             files_with_work_dir: {
                 let mut files = Vec::new();
-                let old_work_dir_str = self
-                    .build_configuration
-                    .directories
-                    .work_dir
-                    .to_string_lossy()
-                    .to_string();
                 for rel in work_dir_files.copied_paths() {
                     let abs = self.build_configuration.directories.work_dir.join(rel);
                     if abs.is_dir() {
                         continue;
                     }
-                    match contains_prefix_text(&abs, &self.build_configuration.directories.work_dir) {
+                    match contains_prefix_text(&abs, &self.build_configuration.directories.work_dir)
+                    {
                         Ok(Some(_)) => files.push(rel.to_path_buf()),
-                        Ok(None) => {},
-                        Err(_) => {},
+                        Ok(None) => {}
+                        Err(_) => {}
                     }
                 }
                 files
@@ -729,7 +728,6 @@ impl Output {
             let copy_options = CopyOptions::default();
             let mut files_with_prefix: Vec<PathBuf> = Vec::new();
             let mut binary_files_with_prefix: Vec<PathBuf> = Vec::new();
-            let old_prefix_str = self.prefix().to_string_lossy().to_string();
 
             for file in &new_files.new_files {
                 // skip directories (if they are not a symlink)
@@ -743,7 +741,7 @@ impl Output {
                 let dest = &prefix_cache_dir.join(stripped);
                 copy_file(file, dest, &mut creation_cache, &copy_options).into_diagnostic()?;
                 copied_files.push(stripped.to_path_buf());
-                let (has_prefix, is_text) = check_file_for_prefix(file, self.prefix(), &old_prefix_str);
+                let (has_prefix, is_text) = check_file_for_prefix(file, self.prefix());
                 if has_prefix {
                     match is_text {
                         true => files_with_prefix.push(stripped.to_path_buf()),
diff --git a/src/packaging.rs b/src/packaging.rs
index f38333252..c161657e3 100644
--- a/src/packaging.rs
+++ b/src/packaging.rs
@@ -21,7 +21,9 @@ mod file_finder;
 mod file_mapper;
 mod metadata;
 pub use file_finder::{Files, TempFiles, content_type};
-pub use metadata::{contains_prefix_binary, contains_prefix_text, create_prefix_placeholder};
+pub use metadata::{
+    contains_prefix_binary, contains_prefix_text, create_prefix_placeholder, rewrite_prefix_in_file,
+};
 use tempfile::NamedTempFile;
 
 use crate::{
diff --git a/src/packaging/metadata.rs b/src/packaging/metadata.rs
index 1bf26a3c5..26ce574f3 100644
--- a/src/packaging/metadata.rs
+++ b/src/packaging/metadata.rs
@@ -124,16 +124,17 @@ pub fn rewrite_prefix_in_file(
     old_prefix: &Path,
     new_prefix: &Path,
 ) -> Result<(), PackagingError> {
-    let content_type = content_inspector::inspect_path(file_path);
+    let content = fs::read(file_path)?;
+    let content_type = content_inspector::inspect(&content);
     let is_text = content_type.is_text()
         && matches!(content_type, ContentType::UTF_8 | ContentType::UTF_8_BOM);
-    
+
     match is_text {
         true => {
             let old_prefix_str = old_prefix.to_string_lossy();
             let new_prefix_str = new_prefix.to_string_lossy();
             let contents = fs::read_to_string(file_path)?;
-            let replaced = contents.replace(&old_prefix_str, &new_prefix_str);
+            let replaced = contents.replace(&*old_prefix_str, &new_prefix_str);
             fs::write(file_path, replaced)?;
             Ok(())
         }
@@ -141,23 +142,20 @@ pub fn rewrite_prefix_in_file(
             #[cfg(target_family = "unix")]
             {
                 use std::os::unix::prelude::OsStrExt;
-                
+
                 let old_prefix_bytes = old_prefix.as_os_str().as_bytes();
                 let new_prefix_bytes = new_prefix.as_os_str().as_bytes();
-                
+
                 if new_prefix_bytes.len() > old_prefix_bytes.len() {
                     return Err(PackagingError::IoError(std::io::Error::new(
                         std::io::ErrorKind::InvalidInput,
                         "New prefix is longer than old prefix, cannot replace in binary file",
                     )));
                 }
-                
-                let mut file = File::options()
-                    .read(true)
-                    .write(true)
-                    .open(file_path)?;
-                
-                let mmap = unsafe { memmap2::MmapOptions::new().map_mut(&file) }?;
+
+                let file = File::options().read(true).write(true).open(file_path)?;
+
+                let mut mmap = unsafe { memmap2::MmapOptions::new().map_mut(&file) }?;
                 let mut pos = 0;
                 while pos <= mmap.len().saturating_sub(old_prefix_bytes.len()) {
                     if &mmap[pos..pos + old_prefix_bytes.len()] == old_prefix_bytes {
@@ -169,7 +167,7 @@ pub fn rewrite_prefix_in_file(
                     }
                     pos += 1;
                 }
-                
+
                 Ok(())
             }
             #[cfg(target_family = "windows")]

From ff5a2b56665d8e9c950163a2bc383240d91eefd9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Sun, 19 Oct 2025 23:19:49 +0300
Subject: [PATCH 24/29] cleanup

---
 src/packaging/file_finder.rs | 46 ++++--------------------------------
 1 file changed, 4 insertions(+), 42 deletions(-)

diff --git a/src/packaging/file_finder.rs b/src/packaging/file_finder.rs
index a5b82cf6b..91cac74f2 100644
--- a/src/packaging/file_finder.rs
+++ b/src/packaging/file_finder.rs
@@ -230,43 +230,9 @@ impl Files {
                 prefix: prefix.to_owned(),
             });
         }
-        let fs_is_case_sensitive = check_is_case_sensitive()?;
-        let current_files = record_files(prefix)?;
-        let previous_files = if prefix.join("conda-meta").exists() {
-            let prefix_records: Vec<PrefixRecord> = PrefixRecord::collect_from_prefix(prefix)?;
-            let mut previous_files = prefix_records
-                .into_iter()
-                .flat_map(|record| record.files.into_iter().map(|f| prefix.join(f)))
-                .collect::<HashSet<_>>();
-            previous_files.extend(record_files(&prefix.join("conda-meta"))?);
-            previous_files
-        } else {
-            HashSet::new()
-        };
 
-        let mut selected_files = find_new_files(
-            &current_files,
-            &previous_files,
-            prefix,
-            fs_is_case_sensitive,
-        );
-
-        if !files.is_empty() {
-            selected_files.retain(|f| {
-                files.is_match(f.strip_prefix(prefix).expect("File should be in prefix"))
-            });
-        }
-
-        if !always_include.is_empty() {
-            for file in &current_files {
-                let file_without_prefix =
-                    file.strip_prefix(prefix).expect("File should be in prefix");
-                if always_include.is_match(file_without_prefix) {
-                    tracing::info!("Forcing inclusion of file: {:?}", file_without_prefix);
-                    selected_files.insert(file.clone());
-                }
-            }
-        }
+        let mut result = Self::from_prefix(prefix, always_include, files)?;
+        let current_files = record_files(prefix)?;
 
         if let Some(cache_files) = restored_cache_prefix_files {
             for cache_file in cache_files {
@@ -281,16 +247,12 @@ impl Files {
                     || files.is_match(file_without_prefix)
                     || always_include.is_match(file_without_prefix)
                 {
-                    selected_files.insert(full_path);
+                    result.new_files.insert(full_path);
                 }
             }
         }
 
-        Ok(Files {
-            new_files: selected_files,
-            old_files: previous_files,
-            prefix: prefix.to_owned(),
-        })
+        Ok(result)
     }
 
     /// Copy the new files to a temporary directory and return the temporary directory and the files that were copied.

From 07ca09a7a6430a2bd27c1cc572261b764cb2b7b5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Mon, 20 Oct 2025 00:35:36 +0300
Subject: [PATCH 25/29] refactor

---
 src/build.rs                       | 101 +++++-----
 src/cache.rs                       | 152 +++++++--------
 src/lib.rs                         |  62 +++---
 src/packaging.rs                   |  11 +-
 src/packaging/metadata.rs          | 113 ++++++-----
 src/recipe/parser.rs               |  64 +++----
 src/recipe/parser/about.rs         |  32 ++--
 src/recipe/parser/build.rs         |  79 ++++----
 src/recipe/parser/cache_output.rs  |  72 ++++---
 src/recipe/parser/common_output.rs |  87 ++++-----
 src/recipe/parser/output.rs        | 292 +++++++++++++----------------
 src/recipe/parser/output_parser.rs |  41 +++-
 src/recipe/parser/parsing_utils.rs |  37 ++--
 src/source/copy_dir.rs             |   9 -
 src/variant_render.rs              |  41 ++--
 15 files changed, 578 insertions(+), 615 deletions(-)

diff --git a/src/build.rs b/src/build.rs
index 2f0e7bd50..2279baafb 100644
--- a/src/build.rs
+++ b/src/build.rs
@@ -125,10 +125,8 @@ pub async fn run_build(
     let directories = output.build_configuration.directories.clone();
 
     // Handle cache outputs first
-    let output = if output.recipe.cache.is_some() {
-        let output = output.build_or_fetch_cache(tool_configuration).await?;
-
-        // Warn if output defines additional sources on top of cache
+    let mut output = output;
+    let warn_additional_sources = |output: &Output| {
         if !output.recipe.sources().is_empty() && output.finalized_cache_sources.is_some() {
             tracing::warn!(
                 "Output defines sources in addition to cache sources. \
@@ -136,34 +134,32 @@ pub async fn run_build(
                  Consider using 'target_directory' in source definitions to avoid conflicts."
             );
         }
-        output
-    } else if !output.cache_outputs_to_build.is_empty() {
-        // Cache outputs from outputs array
-        let mut current_output = output;
-        let cache_outputs = current_output.cache_outputs_to_build.clone();
-        for cache_output in cache_outputs.iter() {
-            current_output = current_output
-                .build_or_fetch_cache_output(cache_output, tool_configuration)
-                .await?;
-        }
+    };
 
-        // Warn if output defines additional sources on top of cache
-        if !current_output.recipe.sources().is_empty()
-            && current_output.finalized_cache_sources.is_some()
-        {
-            tracing::warn!(
-                "Output defines sources in addition to cache sources. \
-                 This may overwrite files from the cache. \
-                 Consider using 'target_directory' in source definitions to avoid conflicts."
-            );
+    match (
+        output.recipe.cache.is_some(),
+        output.cache_outputs_to_build.is_empty(),
+    ) {
+        (true, _) => {
+            output = output.build_or_fetch_cache(tool_configuration).await?;
+            warn_additional_sources(&output);
         }
-        current_output
-    } else {
-        output
-            .fetch_sources(tool_configuration, apply_patch_custom)
-            .await
-            .into_diagnostic()?
-    };
+        (false, false) => {
+            let cache_outputs = output.cache_outputs_to_build.clone();
+            for cache_output in cache_outputs.iter() {
+                output = output
+                    .build_or_fetch_cache_output(cache_output, tool_configuration)
+                    .await?;
+            }
+            warn_additional_sources(&output);
+        }
+        (false, true) => {
+            output = output
+                .fetch_sources(tool_configuration, apply_patch_custom)
+                .await
+                .into_diagnostic()?;
+        }
+    }
 
     let output = output
         .resolve_dependencies(tool_configuration, RunExportsDownload::DownloadMissing)
@@ -174,31 +170,32 @@ pub async fn run_build(
     // we can skip environment installation and script execution entirely. This is a key benefit
     // of the outputs-based cache approach as it allows for significant performance
     // improvements when building multiple outputs that depend on the same intermediate artifacts.
-    let use_fast_path = output.finalized_cache_dependencies.is_some()
-        && output.recipe.build().script().is_default();
-
-    if !use_fast_path {
-        output
-            .install_environments(tool_configuration)
-            .await
-            .into_diagnostic()?;
+    match (
+        output.finalized_cache_dependencies.is_some(),
+        output.recipe.build().script().is_default(),
+    ) {
+        (true, true) => tracing::info!(
+            "Using fast-path optimization: output inherited cache and has no build.script; skipping environment setup and script execution for improved performance."
+        ),
+        _ => {
+            output
+                .install_environments(tool_configuration)
+                .await
+                .into_diagnostic()?;
 
-        match output.run_build_script().await {
-            Ok(_) => {}
-            Err(InterpreterError::Debug(info)) => {
-                tracing::info!("{}", info);
-                return Err(miette::miette!(
-                    "Script not executed because debug mode is enabled"
-                ));
-            }
-            Err(InterpreterError::ExecutionFailed(_)) => {
-                return Err(miette::miette!("Script failed to execute"));
+            match output.run_build_script().await {
+                Ok(_) => {}
+                Err(InterpreterError::Debug(info)) => {
+                    tracing::info!("{}", info);
+                    return Err(miette::miette!(
+                        "Script not executed because debug mode is enabled"
+                    ));
+                }
+                Err(InterpreterError::ExecutionFailed(_)) => {
+                    return Err(miette::miette!("Script failed to execute"));
+                }
             }
         }
-    } else {
-        tracing::info!(
-            "Using fast-path optimization: output inherited cache and has no build.script; skipping environment setup and script execution for improved performance."
-        );
     }
 
     // Package all the new files
diff --git a/src/cache.rs b/src/cache.rs
index b041ad157..c180f5f5c 100644
--- a/src/cache.rs
+++ b/src/cache.rs
@@ -4,7 +4,7 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use content_inspector::ContentType;
+use content_inspector::{ContentType, inspect};
 use fs_err as fs;
 use miette::{Context, IntoDiagnostic};
 use serde::{Deserialize, Serialize};
@@ -31,42 +31,34 @@ use crate::{
 /// Check if a file contains the prefix and determine if it's binary or text
 /// Returns (has_prefix, is_text)
 fn check_file_for_prefix(file_path: &Path, prefix: &Path) -> (bool, bool) {
-    let content = match fs::read(file_path) {
-        Ok(content) => content,
-        Err(_) => return (false, false),
+    let Ok(content) = fs::read(file_path) else {
+        return (false, false);
     };
-    let content_type = content_inspector::inspect(&content);
-    let is_text = content_type.is_text()
-        && matches!(content_type, ContentType::UTF_8 | ContentType::UTF_8_BOM);
-
-    if is_text {
-        match contains_prefix_text(file_path, prefix) {
-            Ok(Some(_)) => (true, true),
-            Ok(None) => (false, true),
-            Err(_) => (false, true),
-        }
-    } else {
-        #[cfg(target_family = "unix")]
-        {
-            match contains_prefix_binary(file_path, prefix) {
-                Ok(has_prefix) => (has_prefix, false),
-                Err(_) => (false, false),
-            }
-        }
-        #[cfg(target_family = "windows")]
-        {
-            if let Ok(contents) = fs::read(file_path) {
-                let prefix_bytes = prefix.to_string_lossy().as_bytes();
-                (
-                    contents
-                        .windows(prefix_bytes.len())
-                        .any(|window| window == prefix_bytes),
-                    false,
-                )
-            } else {
-                (false, false)
-            }
-        }
+
+    let inspected = inspect(&content);
+    let looks_like_text =
+        inspected.is_text() && matches!(inspected, ContentType::UTF_8 | ContentType::UTF_8_BOM);
+
+    if looks_like_text {
+        return contains_prefix_text(file_path, prefix)
+            .map(|found| (found.is_some(), true))
+            .unwrap_or((false, true));
+    }
+
+    #[cfg(target_family = "unix")]
+    {
+        contains_prefix_binary(file_path, prefix)
+            .map(|has| (has, false))
+            .unwrap_or((false, false))
+    }
+
+    #[cfg(target_family = "windows")]
+    {
+        let prefix_bytes = prefix.to_string_lossy();
+        let has_prefix = content
+            .windows(prefix_bytes.len())
+            .any(|window| window == prefix_bytes.as_bytes());
+        (has_prefix, false)
     }
 }
 
@@ -141,30 +133,28 @@ impl Output {
         cache_name: &str,
         cache_reqs: &crate::recipe::parser::CacheRequirements,
     ) -> Result<String, CacheKeyError> {
-        let mut requirement_names: HashSet<_> = cache_reqs
+        let requirement_names: HashSet<_> = cache_reqs
             .build
             .iter()
             .chain(cache_reqs.host.iter())
-            .filter_map(|x| {
-                if let crate::recipe::parser::Dependency::Spec(spec) = x {
-                    if spec.version.is_none() && spec.build.is_none() {
-                        spec.name.as_ref().map(|n| n.as_normalized().to_string())
-                    } else {
-                        None
-                    }
-                } else {
-                    None
+            .filter_map(|dep| match dep {
+                crate::recipe::parser::Dependency::Spec(spec)
+                    if spec.version.is_none() && spec.build.is_none() =>
+                {
+                    spec.name
+                        .as_ref()
+                        .map(|name| name.as_normalized().to_string())
                 }
+                _ => None,
             })
+            .chain(
+                self.recipe
+                    .cache
+                    .iter()
+                    .flat_map(|cache| cache.build.variant.use_keys.iter().cloned()),
+            )
             .collect();
 
-        // Also include explicit variant.use keys from the cache build (if any)
-        if let Some(cache) = &self.recipe.cache {
-            for key in cache.build.variant.use_keys.iter() {
-                requirement_names.insert(key.clone());
-            }
-        }
-
         let mut selected_variant = BTreeMap::new();
         for key in &requirement_names {
             if let Some(value) = self.variant().get(&key.as_str().into()) {
@@ -185,8 +175,6 @@ impl Output {
                 .into(),
         );
 
-        // Include cache name for uniqueness. Do NOT include absolute paths to keep
-        // the cache key stable across different build roots.
         let rebuild_key = (cache_name, cache_reqs, selected_variant);
         let mut hasher = Sha256::new();
         rebuild_key.serialize(&mut serde_json::Serializer::new(&mut hasher))?;
@@ -260,12 +248,6 @@ impl Output {
         let cache_prefix_dir = cache_dir.join("prefix");
         let copied_prefix = CopyDir::new(&cache_prefix_dir, self.prefix())
             .overwrite(true)
-            .on_overwrite(|path| {
-                tracing::warn!(
-                    "File {} restored from cache will be overwritten during output build",
-                    path.display()
-                );
-            })
             .run()
             .into_diagnostic()?;
 
@@ -276,12 +258,6 @@ impl Output {
             &self.build_configuration.directories.work_dir,
         )
         .overwrite(true)
-        .on_overwrite(|path| {
-            tracing::warn!(
-                "File {} restored from cache will be overwritten during output build",
-                path.display()
-            );
-        })
         .run()
         .into_diagnostic()?;
 
@@ -295,14 +271,12 @@ impl Output {
             for rel in &cached_work_files {
                 let target = self.build_configuration.directories.work_dir.join(rel);
                 if target.exists() {
-                    tracing::warn!(
+                    let message = format!(
                         "Source extraction may overwrite restored cache work file: {}",
                         target.display()
                     );
-                    self.record_warning(&format!(
-                        "Source extraction may overwrite restored cache work file: {}",
-                        target.display()
-                    ));
+                    tracing::warn!(message);
+                    self.record_warning(&message);
                 }
             }
         }
@@ -325,12 +299,13 @@ impl Output {
                     &self.build_configuration.directories.work_dir,
                 ] {
                     let path = base.join(rel);
-                    if !path.exists() {
-                        continue;
-                    }
-
-                    if let Err(e) = rewrite_prefix_in_file(&path, &cache.prefix, self.prefix()) {
-                        tracing::warn!("Failed to rewrite restored file {}: {}", path.display(), e);
+                    if path.exists()
+                        && rewrite_prefix_in_file(&path, &cache.prefix, self.prefix()).is_err()
+                    {
+                        tracing::warn!(
+                            "Failed to rewrite restored file {} with new prefix",
+                            path.display()
+                        );
                     }
                 }
             }
@@ -343,18 +318,17 @@ impl Output {
         {
             for rel in cache.files_with_work_dir.iter() {
                 let path = self.build_configuration.directories.work_dir.join(rel);
-                if !path.exists() {
-                    continue;
-                }
-                if let Err(e) = rewrite_prefix_in_file(
-                    &path,
-                    &cache.work_dir,
-                    &self.build_configuration.directories.work_dir,
-                ) {
+                if path.exists()
+                    && rewrite_prefix_in_file(
+                        &path,
+                        &cache.work_dir,
+                        &self.build_configuration.directories.work_dir,
+                    )
+                    .is_err()
+                {
                     tracing::warn!(
-                        "Failed to rewrite restored work_dir file {}: {}",
-                        path.display(),
-                        e
+                        "Failed to rewrite restored work_dir file {} with new work path",
+                        path.display()
                     );
                 }
             }
diff --git a/src/lib.rs b/src/lib.rs
index 9da3bb58d..dd2d4d26a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -212,45 +212,36 @@ pub async fn get_build_output(
 
     // First find all outputs from the recipe
     let named_source = Source::from_path(recipe_path).into_diagnostic()?;
-    let mut outputs = find_outputs_from_src(named_source.clone())?;
+    let outputs = find_outputs_from_src(named_source.clone())?;
     let has_cache_or_inheritance = outputs.iter().any(|output| {
-        if let Some(mapping) = output.as_mapping() {
+        output.as_mapping().is_some_and(|mapping| {
             mapping.contains_key("cache")
-                || (mapping.contains_key("package")
-                    && mapping
-                        .get("package")
-                        .and_then(|p| p.as_mapping())
-                        .and_then(|pm| pm.get("inherit"))
-                        .is_some())
-        } else {
-            false
-        }
+                || mapping
+                    .get("package")
+                    .and_then(|p| p.as_mapping())
+                    .and_then(|pm| pm.get("inherit"))
+                    .is_some()
+        })
     });
 
-    let mut global_cache_outputs = Vec::new();
-    let mut inheritance_relationships = HashMap::new();
-
-    if has_cache_or_inheritance {
+    let (outputs, global_cache_outputs, inheritance_relationships) = if has_cache_or_inheritance {
         let has_toplevel_cache = outputs.iter().any(|output| {
-            if let Ok(recipe) = Recipe::from_output_node(output, selector_config.clone()) {
-                recipe.cache.is_some()
-            } else {
-                false
-            }
+            matches!(
+                Recipe::from_output_node(output, selector_config.clone()),
+                Ok(recipe) if recipe.cache.is_some()
+            )
         });
 
         let jinja = recipe::Jinja::new(selector_config.clone());
-        let (resolved_outputs, cache_outputs, relationships) =
-            recipe::parser::output::resolve_cache_inheritance_with_caches(
-                outputs,
-                has_toplevel_cache,
-                selector_config.experimental,
-                &jinja,
-            )?;
-        outputs = resolved_outputs;
-        global_cache_outputs = cache_outputs;
-        inheritance_relationships = relationships;
-    }
+        recipe::parser::output::resolve_cache_inheritance_with_caches(
+            outputs,
+            has_toplevel_cache,
+            selector_config.experimental,
+            &jinja,
+        )?
+    } else {
+        (outputs, Vec::new(), HashMap::new())
+    };
 
     // Check if there is a `variants.yaml` or `conda_build_config.yaml` file next to
     // the recipe that we should potentially use.
@@ -1102,20 +1093,21 @@ pub async fn build_recipes(
 
         let mut json_value = to_value(&outputs).into_diagnostic()?;
         if let Value::Array(outputs_array) = &mut json_value {
-            for output in outputs_array {
+            outputs_array.iter_mut().for_each(|output| {
                 if let Some(Value::Object(recipe)) = output.get_mut("recipe") {
                     let requirements = recipe
                         .entry("requirements".to_string())
                         .or_insert_with(|| Value::Object(Default::default()));
-                    if let Value::Object(requirements) = requirements {
+
+                    if let Value::Object(requirements_map) = requirements {
                         for key in ["build", "host", "run", "run_constraints"] {
-                            requirements
+                            requirements_map
                                 .entry(key.to_string())
                                 .or_insert_with(|| Value::Array(Vec::new()));
                         }
                     }
                 }
-            }
+            });
         }
 
         println!("{}", to_string_pretty(&json_value).into_diagnostic()?);
diff --git a/src/packaging.rs b/src/packaging.rs
index c161657e3..4212a4c04 100644
--- a/src/packaging.rs
+++ b/src/packaging.rs
@@ -574,20 +574,19 @@ impl Output {
     ) -> Result<(PathBuf, PathsJson), PackagingError> {
         // When cache files are present, the output's build.files should apply to all
         // relevant files, not just "new" ones compared to conda-meta
-        let files_after = if self.has_restored_cache_files() {
-            Files::from_prefix_with_filters(
+        let files_after = match self.has_restored_cache_files() {
+            true => Files::from_prefix_with_filters(
                 &self.build_configuration.directories.host_prefix,
                 self.recipe.build().always_include_files(),
                 self.recipe.build().files(),
                 self.restored_cache_prefix_files.as_ref(),
                 self.restored_cache_work_dir_files.as_ref(),
-            )?
-        } else {
-            Files::from_prefix(
+            )?,
+            false => Files::from_prefix(
                 &self.build_configuration.directories.host_prefix,
                 self.recipe.build().always_include_files(),
                 self.recipe.build().files(),
-            )?
+            )?,
         };
 
         package_conda(self, tool_configuration, &files_after)
diff --git a/src/packaging/metadata.rs b/src/packaging/metadata.rs
index 26ce574f3..6f1b075b4 100644
--- a/src/packaging/metadata.rs
+++ b/src/packaging/metadata.rs
@@ -5,6 +5,7 @@ use std::os::unix::prelude::OsStrExt;
 use std::{
     borrow::Cow,
     collections::HashSet,
+    io::{self, ErrorKind},
     ops::Deref,
     path::{Path, PathBuf},
 };
@@ -129,55 +130,79 @@ pub fn rewrite_prefix_in_file(
     let is_text = content_type.is_text()
         && matches!(content_type, ContentType::UTF_8 | ContentType::UTF_8_BOM);
 
-    match is_text {
-        true => {
-            let old_prefix_str = old_prefix.to_string_lossy();
-            let new_prefix_str = new_prefix.to_string_lossy();
-            let contents = fs::read_to_string(file_path)?;
-            let replaced = contents.replace(&*old_prefix_str, &new_prefix_str);
-            fs::write(file_path, replaced)?;
-            Ok(())
+    if is_text {
+        return rewrite_text_prefix(file_path, content, old_prefix, new_prefix);
+    }
+
+    rewrite_binary_prefix(file_path, old_prefix, new_prefix)
+}
+
+fn rewrite_text_prefix(
+    file_path: &Path,
+    content: Vec<u8>,
+    old_prefix: &Path,
+    new_prefix: &Path,
+) -> Result<(), PackagingError> {
+    let contents = String::from_utf8(content).map_err(|err| {
+        PackagingError::IoError(io::Error::new(ErrorKind::InvalidData, err.utf8_error()))
+    })?;
+
+    let old_prefix_str = old_prefix.to_string_lossy().into_owned();
+
+    if !contents.contains(old_prefix_str.as_str()) {
+        return Ok(());
+    }
+
+    let new_prefix_str = new_prefix.to_string_lossy();
+    let updated = contents.replace(old_prefix_str.as_str(), new_prefix_str.as_ref());
+    fs::write(file_path, updated)?;
+    Ok(())
+}
+
+fn rewrite_binary_prefix(
+    file_path: &Path,
+    old_prefix: &Path,
+    new_prefix: &Path,
+) -> Result<(), PackagingError> {
+    #[cfg(target_family = "unix")]
+    {
+        use std::os::unix::prelude::OsStrExt;
+
+        let old_prefix_bytes = old_prefix.as_os_str().as_bytes();
+        let new_prefix_bytes = new_prefix.as_os_str().as_bytes();
+
+        if old_prefix_bytes.is_empty() {
+            return Ok(());
         }
-        false => {
-            #[cfg(target_family = "unix")]
-            {
-                use std::os::unix::prelude::OsStrExt;
-
-                let old_prefix_bytes = old_prefix.as_os_str().as_bytes();
-                let new_prefix_bytes = new_prefix.as_os_str().as_bytes();
-
-                if new_prefix_bytes.len() > old_prefix_bytes.len() {
-                    return Err(PackagingError::IoError(std::io::Error::new(
-                        std::io::ErrorKind::InvalidInput,
-                        "New prefix is longer than old prefix, cannot replace in binary file",
-                    )));
-                }
 
-                let file = File::options().read(true).write(true).open(file_path)?;
+        if new_prefix_bytes.len() > old_prefix_bytes.len() {
+            return Err(PackagingError::IoError(io::Error::new(
+                ErrorKind::InvalidInput,
+                "New prefix is longer than old prefix, cannot replace in binary file",
+            )));
+        }
 
-                let mut mmap = unsafe { memmap2::MmapOptions::new().map_mut(&file) }?;
-                let mut pos = 0;
-                while pos <= mmap.len().saturating_sub(old_prefix_bytes.len()) {
-                    if &mmap[pos..pos + old_prefix_bytes.len()] == old_prefix_bytes {
-                        mmap[pos..pos + new_prefix_bytes.len()].copy_from_slice(new_prefix_bytes);
-                        let padding_len = old_prefix_bytes.len() - new_prefix_bytes.len();
-                        for i in 0..padding_len {
-                            mmap[pos + new_prefix_bytes.len() + i] = 0;
-                        }
-                    }
-                    pos += 1;
-                }
+        let file = File::options().read(true).write(true).open(file_path)?;
+        let mut mmap = unsafe { memmap2::MmapOptions::new().map_mut(&file) }?;
 
-                Ok(())
-            }
-            #[cfg(target_family = "windows")]
-            {
-                Err(PackagingError::IoError(std::io::Error::new(
-                    std::io::ErrorKind::Unsupported,
-                    "Binary prefix replacement is not supported on Windows",
-                )))
-            }
+        let mut search_start = 0;
+        while let Some(found) = memchr::memmem::find(&mmap[search_start..], old_prefix_bytes) {
+            let pos = search_start + found;
+            mmap[pos..pos + new_prefix_bytes.len()].copy_from_slice(new_prefix_bytes);
+            let padding_range = pos + new_prefix_bytes.len()..pos + old_prefix_bytes.len();
+            mmap[padding_range].fill(0);
+            search_start = pos + 1;
         }
+
+        Ok(())
+    }
+
+    #[cfg(target_family = "windows")]
+    {
+        Err(PackagingError::IoError(io::Error::new(
+            ErrorKind::Unsupported,
+            "Binary prefix replacement is not supported on Windows",
+        )))
     }
 }
 
diff --git a/src/recipe/parser.rs b/src/recipe/parser.rs
index 2e67b35f3..b805779e0 100644
--- a/src/recipe/parser.rs
+++ b/src/recipe/parser.rs
@@ -32,7 +32,7 @@ mod helper;
 pub mod output;
 mod output_parser;
 mod package;
-mod parsing_utils;
+pub(crate) mod parsing_utils;
 mod regex;
 mod requirements;
 mod script;
@@ -478,21 +478,21 @@ impl Recipe {
         all_cache_outputs: &[CacheOutput],
         inheritance_relationships: &HashMap<String, Vec<String>>,
     ) -> Vec<CacheOutput> {
-        let mut result = Vec::new();
-        let mut seen = HashSet::new();
-        let mut visiting = HashSet::new();
+        fn find_cache<'a>(caches: &'a [CacheOutput], name: &str) -> Option<&'a CacheOutput> {
+            caches
+                .iter()
+                .find(|cache| cache.name.as_normalized() == name)
+        }
 
-        // Function to collect all transitive dependencies
-        fn collect_dependencies(
+        fn collect(
             name: &str,
-            all_cache_outputs: &[CacheOutput],
-            inheritance_relationships: &HashMap<String, Vec<String>>,
-            result: &mut Vec<CacheOutput>,
-            seen: &mut HashSet<String>,
+            relationships: &HashMap<String, Vec<String>>,
+            caches: &[CacheOutput],
             visiting: &mut HashSet<String>,
+            seen: &mut HashSet<String>,
+            acc: &mut Vec<CacheOutput>,
         ) {
-            // Detect circular dependencies
-            if visiting.contains(name) {
+            if !visiting.insert(name.to_owned()) {
                 tracing::warn!(
                     "Circular cache dependency detected involving '{}' - this likely indicates a configuration error",
                     name
@@ -500,28 +500,13 @@ impl Recipe {
                 return;
             }
 
-            visiting.insert(name.to_string());
-
-            if let Some(cache_names) = inheritance_relationships.get(name) {
-                for cache_name in cache_names {
-                    // First, recursively collect dependencies of this cache
-                    collect_dependencies(
-                        cache_name,
-                        all_cache_outputs,
-                        inheritance_relationships,
-                        result,
-                        seen,
-                        visiting,
-                    );
-
-                    // Then add the cache itself if we haven't seen it yet
-                    if !seen.contains(cache_name) {
-                        if let Some(cache_output) = all_cache_outputs
-                            .iter()
-                            .find(|c| c.name.as_normalized() == cache_name)
-                        {
-                            result.push(cache_output.clone());
-                            seen.insert(cache_name.to_string());
+            if let Some(children) = relationships.get(name) {
+                for child in children {
+                    collect(child, relationships, caches, visiting, seen, acc);
+
+                    if seen.insert(child.clone()) {
+                        if let Some(cache_output) = find_cache(caches, child) {
+                            acc.push(cache_output.clone());
                         }
                     }
                 }
@@ -530,13 +515,16 @@ impl Recipe {
             visiting.remove(name);
         }
 
-        collect_dependencies(
+        let mut result = Vec::new();
+        let mut seen = HashSet::new();
+        let mut visiting = HashSet::new();
+        collect(
             package_name,
-            all_cache_outputs,
             inheritance_relationships,
-            &mut result,
-            &mut seen,
+            all_cache_outputs,
             &mut visiting,
+            &mut seen,
+            &mut result,
         );
         result
     }
diff --git a/src/recipe/parser/about.rs b/src/recipe/parser/about.rs
index 9dcf9f817..3b94b7e04 100644
--- a/src/recipe/parser/about.rs
+++ b/src/recipe/parser/about.rs
@@ -54,6 +54,14 @@ pub struct About {
 }
 
 impl About {
+    fn merge_if_absent<T: Clone>(target: &mut Option<T>, source: &Option<T>) {
+        if target.is_none() {
+            if let Some(value) = source {
+                *target = Some(value.clone());
+            }
+        }
+    }
+
     /// Returns true if the about has its default configuration.
     pub fn is_default(&self) -> bool {
         self == &Self::default()
@@ -62,22 +70,14 @@ impl About {
     /// Deep merge another About into this one
     /// Values in self take precedence over values in other
     pub fn merge_from(&mut self, other: &About) {
-        macro_rules! merge_field {
-            ($field:ident) => {
-                if self.$field.is_none() && other.$field.is_some() {
-                    self.$field = other.$field.clone();
-                }
-            };
-        }
-
-        merge_field!(homepage);
-        merge_field!(repository);
-        merge_field!(documentation);
-        merge_field!(license);
-        merge_field!(license_family);
-        merge_field!(summary);
-        merge_field!(description);
-        merge_field!(prelink_message);
+        Self::merge_if_absent(&mut self.homepage, &other.homepage);
+        Self::merge_if_absent(&mut self.repository, &other.repository);
+        Self::merge_if_absent(&mut self.documentation, &other.documentation);
+        Self::merge_if_absent(&mut self.license, &other.license);
+        Self::merge_if_absent(&mut self.license_family, &other.license_family);
+        Self::merge_if_absent(&mut self.summary, &other.summary);
+        Self::merge_if_absent(&mut self.description, &other.description);
+        Self::merge_if_absent(&mut self.prelink_message, &other.prelink_message);
 
         if self.license_file.is_empty() && !other.license_file.is_empty() {
             self.license_file = other.license_file.clone();
diff --git a/src/recipe/parser/build.rs b/src/recipe/parser/build.rs
index 0058a8ca2..7d4904f34 100644
--- a/src/recipe/parser/build.rs
+++ b/src/recipe/parser/build.rs
@@ -208,6 +208,16 @@ pub struct PostProcess {
 }
 
 impl Build {
+    fn merge_when<T, P>(target: &mut T, source: &T, should_replace: P)
+    where
+        T: Clone,
+        P: Fn(&T) -> bool,
+    {
+        if should_replace(target) && !should_replace(source) {
+            *target = source.clone();
+        }
+    }
+
     /// Deep merge another Build into this one.
     /// Values in self take precedence over values in other.
     ///
@@ -218,43 +228,42 @@ impl Build {
     /// Excluded fields (preserved from self): number, string, skip, script
     /// These fields are treated as identity fields specific to each output.
     pub fn merge_from(&mut self, other: &Build) {
-        if self.python.is_default() && !other.python.is_default() {
-            self.python = other.python.clone();
-        }
-
-        if self.dynamic_linking.is_default() && !other.dynamic_linking.is_default() {
-            self.dynamic_linking = other.dynamic_linking.clone();
-        }
-
-        if self.prefix_detection.is_default() && !other.prefix_detection.is_default() {
-            self.prefix_detection = other.prefix_detection.clone();
-        }
-
-        if self.variant.is_default() && !other.variant.is_default() {
-            self.variant = other.variant.clone();
-        }
-
-        if self.post_process.is_empty() && !other.post_process.is_empty() {
-            self.post_process = other.post_process.clone();
-        }
-
-        if !self.merge_build_and_host_envs && other.merge_build_and_host_envs {
-            self.merge_build_and_host_envs = other.merge_build_and_host_envs;
-        }
+        Self::merge_when(&mut self.python, &other.python, Python::is_default);
+        Self::merge_when(
+            &mut self.dynamic_linking,
+            &other.dynamic_linking,
+            DynamicLinking::is_default,
+        );
+        Self::merge_when(
+            &mut self.prefix_detection,
+            &other.prefix_detection,
+            PrefixDetection::is_default,
+        );
+        Self::merge_when(
+            &mut self.variant,
+            &other.variant,
+            VariantKeyUsage::is_default,
+        );
+        Self::merge_when(
+            &mut self.post_process,
+            &other.post_process,
+            |v: &Vec<PostProcess>| v.is_empty(),
+        );
 
-        if self.noarch.is_none() && !other.noarch.is_none() {
-            self.noarch = other.noarch;
-        }
+        self.merge_build_and_host_envs |= other.merge_build_and_host_envs;
 
-        if self.files.is_empty() && !other.files.is_empty() {
-            self.files = other.files.clone();
-        }
-        if self.always_include_files.is_empty() && !other.always_include_files.is_empty() {
-            self.always_include_files = other.always_include_files.clone();
-        }
-        if self.always_copy_files.is_empty() && !other.always_copy_files.is_empty() {
-            self.always_copy_files = other.always_copy_files.clone();
-        }
+        Self::merge_when(&mut self.noarch, &other.noarch, NoArchType::is_none);
+        Self::merge_when(&mut self.files, &other.files, GlobVec::is_empty);
+        Self::merge_when(
+            &mut self.always_include_files,
+            &other.always_include_files,
+            GlobVec::is_empty,
+        );
+        Self::merge_when(
+            &mut self.always_copy_files,
+            &other.always_copy_files,
+            GlobVec::is_empty,
+        );
     }
 
     /// Get the merge build host flag.
diff --git a/src/recipe/parser/cache_output.rs b/src/recipe/parser/cache_output.rs
index 87396ca96..c256f131d 100644
--- a/src/recipe/parser/cache_output.rs
+++ b/src/recipe/parser/cache_output.rs
@@ -70,6 +70,24 @@ enum Field {
     About,
 }
 
+fn set_once<T, E: de::Error>(slot: &mut Option<T>, value: T, field: &'static str) -> Result<(), E> {
+    if slot.replace(value).is_some() {
+        Err(de::Error::duplicate_field(field))
+    } else {
+        Ok(())
+    }
+}
+
+fn ensure_cache_build_script<E: de::Error>(build: &CacheBuild) -> Result<(), E> {
+    if build.script.is_none() {
+        Err(E::custom(
+            "cache outputs require an explicit build script (build.script field is required)",
+        ))
+    } else {
+        Ok(())
+    }
+}
+
 // Manual implementation of Deserialize for CacheOutput
 impl<'de> DeserializeTrait<'de> for CacheOutput {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
@@ -100,63 +118,39 @@ impl<'de> DeserializeTrait<'de> for CacheOutput {
                 while let Some(key) = map.next_key()? {
                     match key {
                         Field::Name => {
-                            if name.is_some() {
-                                return Err(de::Error::duplicate_field("name"));
-                            }
-                            name = Some(map.next_value()?);
+                            set_once(&mut name, map.next_value()?, "name")?;
                         }
                         Field::Source => {
-                            if source.is_some() {
-                                return Err(de::Error::duplicate_field("source"));
-                            }
-                            source = Some(map.next_value()?);
+                            set_once(&mut source, map.next_value()?, "source")?;
                         }
                         Field::Build => {
-                            if build.is_some() {
-                                return Err(de::Error::duplicate_field("build"));
-                            }
-                            build = Some(map.next_value()?);
+                            set_once(&mut build, map.next_value()?, "build")?;
                         }
                         Field::Requirements => {
-                            if requirements.is_some() {
-                                return Err(de::Error::duplicate_field("requirements"));
-                            }
-                            requirements = Some(map.next_value()?);
+                            set_once(&mut requirements, map.next_value()?, "requirements")?;
                         }
                         Field::RunExports => {
-                            if run_exports.is_some() {
-                                return Err(de::Error::duplicate_field("run_exports"));
-                            }
-                            run_exports = Some(map.next_value()?);
+                            set_once(&mut run_exports, map.next_value()?, "run_exports")?;
                         }
                         Field::IgnoreRunExports => {
-                            if ignore_run_exports.is_some() {
-                                return Err(de::Error::duplicate_field("ignore_run_exports"));
-                            }
-                            ignore_run_exports = Some(map.next_value()?);
+                            set_once(
+                                &mut ignore_run_exports,
+                                map.next_value()?,
+                                "ignore_run_exports",
+                            )?;
                         }
                         Field::About => {
-                            if about.is_some() {
-                                return Err(de::Error::duplicate_field("about"));
-                            }
-                            about = Some(map.next_value()?);
+                            set_once(&mut about, map.next_value()?, "about")?;
                         }
                     }
                 }
 
                 let name = name.ok_or_else(|| de::Error::missing_field("name"))?;
-                let source = source.unwrap_or_else(Vec::new);
+                let source = source.unwrap_or_default();
                 let build = build.ok_or_else(|| de::Error::missing_field("build"))?;
-                if build.script.is_none() {
-                    return Err(de::Error::custom(
-                        "cache outputs require an explicit build script (build.script field is required)",
-                    ));
-                }
-
-                let requirements = requirements.unwrap_or_else(CacheRequirements::default);
-                let run_exports = run_exports.unwrap_or_else(RunExports::default);
-                let ignore_run_exports = ignore_run_exports;
-                let about = about;
+                ensure_cache_build_script(&build)?;
+                let requirements = requirements.unwrap_or_default();
+                let run_exports = run_exports.unwrap_or_default();
 
                 Ok(CacheOutput {
                     name,
diff --git a/src/recipe/parser/common_output.rs b/src/recipe/parser/common_output.rs
index 453cb51ad..49a280e8d 100644
--- a/src/recipe/parser/common_output.rs
+++ b/src/recipe/parser/common_output.rs
@@ -4,7 +4,7 @@ use crate::{
     _partialerror,
     recipe::{
         ParsingError,
-        custom_yaml::{HasSpan, RenderedNode, TryConvertNode},
+        custom_yaml::{HasSpan, RenderedNode, RenderedScalarNode, TryConvertNode},
         error::{ErrorKind, PartialParsingError},
     },
     source_code::SourceCode,
@@ -30,11 +30,44 @@ pub enum InheritSpec {
     },
 }
 
-fn default_true() -> bool {
+const fn default_true() -> bool {
     true
 }
 
 impl InheritSpec {
+    const EXPECTED_STRING: &'static str = "expected a string";
+    const EXPECTED_BOOLEAN: &'static str = "expected a boolean";
+
+    fn expect_scalar<'a>(
+        node: &'a RenderedNode,
+        help: &'static str,
+    ) -> Result<&'a RenderedScalarNode, Vec<PartialParsingError>> {
+        node.as_scalar().ok_or_else(|| {
+            vec![_partialerror!(
+                *node.span(),
+                ErrorKind::ExpectedScalar,
+                help = help
+            )]
+        })
+    }
+
+    fn parse_string(node: &RenderedNode) -> Result<String, Vec<PartialParsingError>> {
+        Ok(Self::expect_scalar(node, Self::EXPECTED_STRING)?
+            .as_str()
+            .to_string())
+    }
+
+    fn parse_bool(node: &RenderedNode) -> Result<bool, Vec<PartialParsingError>> {
+        let scalar = Self::expect_scalar(node, Self::EXPECTED_BOOLEAN)?;
+        scalar.as_bool().ok_or_else(|| {
+            vec![_partialerror!(
+                *scalar.span(),
+                ErrorKind::ExpectedScalar,
+                help = Self::EXPECTED_BOOLEAN
+            )]
+        })
+    }
+
     /// Get the cache name to inherit from
     pub fn cache_name(&self) -> &str {
         match self {
@@ -75,53 +108,9 @@ impl TryConvertNode<InheritSpec> for RenderedNode {
 
             for (key, value) in mapping.iter() {
                 match key.as_str() {
-                    "from" => {
-                        from = Some(
-                            value
-                                .as_scalar()
-                                .ok_or_else(|| {
-                                    vec![_partialerror!(
-                                        *value.span(),
-                                        ErrorKind::ExpectedScalar,
-                                        help = "expected a string"
-                                    )]
-                                })?
-                                .as_str()
-                                .to_string(),
-                        );
-                    }
-                    "run_exports" => {
-                        let scalar = value.as_scalar().ok_or_else(|| {
-                            vec![_partialerror!(
-                                *value.span(),
-                                ErrorKind::ExpectedScalar,
-                                help = "expected a boolean"
-                            )]
-                        })?;
-                        run_exports = scalar.as_bool().ok_or_else(|| {
-                            vec![_partialerror!(
-                                *value.span(),
-                                ErrorKind::ExpectedScalar,
-                                help = "expected a boolean"
-                            )]
-                        })?;
-                    }
-                    "requirements" => {
-                        let scalar = value.as_scalar().ok_or_else(|| {
-                            vec![_partialerror!(
-                                *value.span(),
-                                ErrorKind::ExpectedScalar,
-                                help = "expected a boolean"
-                            )]
-                        })?;
-                        requirements = scalar.as_bool().ok_or_else(|| {
-                            vec![_partialerror!(
-                                *value.span(),
-                                ErrorKind::ExpectedScalar,
-                                help = "expected a boolean"
-                            )]
-                        })?;
-                    }
+                    "from" => from = Some(InheritSpec::parse_string(value)?),
+                    "run_exports" => run_exports = InheritSpec::parse_bool(value)?,
+                    "requirements" => requirements = InheritSpec::parse_bool(value)?,
                     _ => {
                         return Err(vec![_partialerror!(
                             *key.span(),
diff --git a/src/recipe/parser/output.rs b/src/recipe/parser/output.rs
index 76eeb0ab7..96929be86 100644
--- a/src/recipe/parser/output.rs
+++ b/src/recipe/parser/output.rs
@@ -19,9 +19,13 @@ use crate::{
 
 use rattler_conda_types::PackageName;
 
-use super::common_output::{
-    ALLOWED_KEYS_MULTI_OUTPUTS, DEEP_MERGE_KEYS, extract_recipe_version_marked,
-    merge_mapping_if_not_exists,
+use super::{
+    cache_output::{CacheBuild, CacheOutput, CacheRequirements},
+    common_output::{
+        ALLOWED_KEYS_MULTI_OUTPUTS, DEEP_MERGE_KEYS, extract_recipe_version_marked,
+        merge_mapping_if_not_exists,
+    },
+    requirements::RunExports,
 };
 
 /// Result type for resolve_cache_inheritance_with_caches function
@@ -260,37 +264,32 @@ pub fn find_outputs_from_src<S: SourceCode>(src: S) -> Result<Vec<Node>, Parsing
             }
         }
 
-        let inherit_spec = output_map
+        let inherited_package = output_map
             .get("package")
             .and_then(|pkg_node| pkg_node.as_mapping())
-            .and_then(|pkg_map| pkg_map.get("inherit"));
-
-        match inherit_spec {
-            Some(inherit_node)
-                if inherit_node
-                    .as_scalar()
-                    .is_some_and(|s| s.as_str().is_empty()) => {}
-            Some(_) => {}
-            None => {
-                // When inheriting from top-level, requirements and build.script are ignored (not forbidden)
-                // rather than throwing errors, we just warn about them
-                if let Some(_req_node) = output_map.get("requirements") {
-                    tracing::warn!(
-                        "When inheriting from top-level, the `requirements` field will be ignored. \
-                         The output will inherit all requirements from the top-level recipe."
-                    );
-                }
-                if let Some(build_node) = output_map.get("build") {
-                    if let Some(build_map) = build_node.as_mapping() {
-                        if build_map.contains_key("script") {
-                            tracing::warn!(
-                                "When inheriting from top-level (implicit inheritance), the `build.script` field will be ignored. \
-                                 This is a breaking change from older versions where explicit script definitions in output were used. \
-                                 The output will use the top-level recipe's build script instead."
-                            );
-                        }
-                    }
-                }
+            .and_then(|pkg_map| pkg_map.get("inherit"))
+            .and_then(|inherit_node| inherit_node.as_scalar())
+            .map(|scalar| scalar.as_str().is_empty())
+            .unwrap_or(false);
+
+        if !inherited_package {
+            if output_map.contains_key("requirements") {
+                tracing::warn!(
+                    "When inheriting from top-level, the `requirements` field will be ignored. \
+                     The output will inherit all requirements from the top-level recipe."
+                );
+            }
+
+            if output_map
+                .get("build")
+                .and_then(|build| build.as_mapping())
+                .is_some_and(|build_map| build_map.contains_key("script"))
+            {
+                tracing::warn!(
+                    "When inheriting from top-level (implicit inheritance), the `build.script` field will be ignored. \
+                     This is a breaking change from older versions where explicit script definitions in output were used. \
+                     The output will use the top-level recipe's build script instead."
+                );
             }
         }
 
@@ -319,21 +318,21 @@ pub fn resolve_cache_inheritance(
     let mut cache_names = HashSet::new();
     let mut duplicate_caches = Vec::new();
     let mut cache_name_spans = HashMap::new();
-    let mut cache_inheritance = HashMap::new();
+    let mut cache_inheritance: HashMap<String, Vec<String>> = HashMap::new();
 
-    for output in outputs.iter() {
-        if let Some(cache_output) = parse_cache_output_from_node(output)? {
+    outputs
+        .iter()
+        .filter_map(|output| parse_cache_output_from_node(output).transpose())
+        .try_for_each(|cache_output| {
+            let cache_output = cache_output?;
             let cache_name = cache_output.name.as_normalized().to_string();
             if !cache_names.insert(cache_name.clone()) {
                 duplicate_caches.push(cache_name);
             } else {
-                cache_name_spans.insert(
-                    cache_output.name.as_normalized().to_string(),
-                    cache_output.span,
-                );
+                cache_name_spans.insert(cache_name, cache_output.span);
             }
-        }
-    }
+            Ok::<_, ParsingError<&'static str>>(())
+        })?;
 
     if !duplicate_caches.is_empty() {
         return Err(ParsingError::from_partial(
@@ -381,18 +380,19 @@ pub fn resolve_cache_inheritance(
     }
 
     for output in outputs.iter() {
-        let Some(cache_mapping) = output
+        let Some((cache_mapping, inherit_node)) = output
             .as_mapping()
             .and_then(|mapping| mapping.get("cache"))
             .and_then(|cache_node| cache_node.as_mapping())
+            .and_then(|cache_mapping| {
+                cache_mapping
+                    .get("inherit")
+                    .map(|node| (cache_mapping, node))
+            })
         else {
             continue;
         };
 
-        let Some(inherit_node) = cache_mapping.get("inherit") else {
-            continue;
-        };
-
         let Some(cache_name_to_inherit) = inherit_name_from(inherit_node) else {
             continue;
         };
@@ -405,8 +405,6 @@ pub fn resolve_cache_inheritance(
             continue;
         };
 
-        // Cache outputs can only inherit from other cache outputs, not from package outputs
-        // Check if the cache to inherit from exists in the cache names we collected
         if !cache_names.contains(&cache_name_to_inherit) {
             let available: Vec<_> = cache_names.iter().map(|n| format!("'{}'", n)).collect();
             let help_msg = if available.is_empty() {
@@ -430,10 +428,9 @@ pub fn resolve_cache_inheritance(
             ));
         }
 
-        // Store the inheritance relationship for cycle detection
         cache_inheritance
             .entry(this_cache_name.clone())
-            .or_insert_with(Vec::new)
+            .or_default()
             .push(cache_name_to_inherit.clone());
     }
 
@@ -458,20 +455,58 @@ pub fn resolve_cache_inheritance(
 fn detect_cache_inheritance_cycles(
     inheritance: &HashMap<String, Vec<String>>,
 ) -> Option<Vec<String>> {
-    let mut visited = std::collections::HashMap::new();
-    let mut recursion_stack = std::collections::HashMap::new();
-    let mut parent = std::collections::HashMap::new();
+    let mut visited: HashSet<&str> = HashSet::new();
+    let mut recursion_stack: HashSet<&str> = HashSet::new();
+    let mut parent: HashMap<&str, &str> = HashMap::new();
+
+    fn dfs_visit<'a>(
+        cache: &'a str,
+        inheritance: &'a HashMap<String, Vec<String>>,
+        visited: &mut HashSet<&'a str>,
+        recursion_stack: &mut HashSet<&'a str>,
+        parent: &mut HashMap<&'a str, &'a str>,
+    ) -> Option<Vec<String>> {
+        visited.insert(cache);
+        recursion_stack.insert(cache);
+
+        if let Some(dependencies) = inheritance.get(cache) {
+            for dependency in dependencies {
+                let dep_str = dependency.as_str();
+                if !visited.contains(dep_str) {
+                    parent.insert(dep_str, cache);
+                    if let Some(cycle) =
+                        dfs_visit(dep_str, inheritance, visited, recursion_stack, parent)
+                    {
+                        return Some(cycle);
+                    }
+                } else if recursion_stack.contains(dep_str) {
+                    let mut cycle = vec![dependency.clone()];
+                    let mut current = cache;
+                    while current != dep_str {
+                        cycle.push(current.to_string());
+                        current = parent.get(current).copied().unwrap_or(dep_str);
+                    }
+                    cycle.push(dependency.clone());
+                    cycle.reverse();
+                    return Some(cycle);
+                }
+            }
+        }
+
+        recursion_stack.remove(cache);
+        None
+    }
 
     for cache_name in inheritance.keys() {
-        if !(*visited.get(cache_name).unwrap_or(&false)) {
-            let path = dfs_visit(
-                cache_name,
+        let cache_str = cache_name.as_str();
+        if !visited.contains(cache_str) {
+            if let Some(cycle_path) = dfs_visit(
+                cache_str,
                 inheritance,
                 &mut visited,
                 &mut recursion_stack,
                 &mut parent,
-            );
-            if let Some(cycle_path) = path {
+            ) {
                 return Some(cycle_path);
             }
         }
@@ -479,50 +514,6 @@ fn detect_cache_inheritance_cycles(
     None
 }
 
-/// Depth-first search to find cycles
-fn dfs_visit(
-    cache: &str,
-    inheritance: &HashMap<String, Vec<String>>,
-    visited: &mut std::collections::HashMap<String, bool>,
-    recursion_stack: &mut std::collections::HashMap<String, bool>,
-    parent: &mut std::collections::HashMap<String, String>,
-) -> Option<Vec<String>> {
-    visited.insert(cache.to_string(), true);
-    recursion_stack.insert(cache.to_string(), true);
-
-    if let Some(dependencies) = inheritance.get(cache) {
-        for dependency in dependencies {
-            if !(*visited.get(dependency).unwrap_or(&false)) {
-                parent.insert(dependency.clone(), cache.to_string());
-                if let Some(cycle) =
-                    dfs_visit(dependency, inheritance, visited, recursion_stack, parent)
-                {
-                    return Some(cycle);
-                }
-            } else if *recursion_stack.get(dependency).unwrap_or(&false) {
-                let mut cycle = vec![dependency.clone()];
-                let mut current = cache.to_string();
-
-                while current != *dependency {
-                    cycle.push(current.clone());
-                    if let Some(parent_cache) = parent.get(&current) {
-                        current = parent_cache.clone();
-                    } else {
-                        break;
-                    }
-                }
-                cycle.push(dependency.clone());
-                cycle.reverse();
-
-                return Some(cycle);
-            }
-        }
-    }
-
-    recursion_stack.insert(cache.to_string(), false);
-    None
-}
-
 /// Parse a cache output from a Node using proper TryConvertNode
 fn parse_cache_output_from_node(
     output: &Node,
@@ -531,67 +522,44 @@ fn parse_cache_output_from_node(
     // For now, we'll use a simplified approach since we don't have jinja context here
     // In a full implementation, we would need to render the node first
 
-    if let Some(mapping) = output.as_mapping() {
-        if mapping.contains_key("cache") {
-            if let Some(cache_node) = mapping.get("cache") {
-                if let Some(cache_mapping) = cache_node.as_mapping() {
-                    let name = if let Some(name_node) = cache_mapping.get("name") {
-                        if let Some(name_scalar) = name_node.as_scalar() {
-                            match PackageName::try_from(name_scalar.as_str().to_string()) {
-                                Ok(package_name) => package_name,
-                                Err(err) => {
-                                    return Err(ParsingError::from_partial(
-                                        "",
-                                        _partialerror!(
-                                            *name_node.span(),
-                                            ErrorKind::from(err),
-                                            help = "cache name must be a valid package name"
-                                        ),
-                                    ));
-                                }
-                            }
-                        } else {
-                            return Err(ParsingError::from_partial(
-                                "",
-                                _partialerror!(
-                                    *name_node.span(),
-                                    ErrorKind::ExpectedScalar,
-                                    help = "cache name must be a string"
-                                ),
-                            ));
-                        }
-                    } else {
-                        match PackageName::try_from("default".to_string()) {
-                            Ok(package_name) => package_name,
-                            Err(_) => {
-                                return Err(ParsingError::from_partial(
-                                    "",
-                                    _partialerror!(
-                                        marked_yaml::Span::new_blank(),
-                                        ErrorKind::InvalidField("default".to_string().into()),
-                                        help = "internal error: default cache name is invalid"
-                                    ),
-                                ));
-                            }
-                        }
-                    };
+    let Some(mapping) = output.as_mapping() else {
+        return Ok(None);
+    };
 
-                    // For now, create a basic cache output with defaults
-                    return Ok(Some(crate::recipe::parser::CacheOutput {
-                        name,
-                        source: Vec::new(),
-                        build: crate::recipe::parser::CacheBuild::default(),
-                        requirements: crate::recipe::parser::CacheRequirements::default(),
-                        run_exports: crate::recipe::parser::RunExports::default(),
-                        ignore_run_exports: None,
-                        about: None,
-                        span: *output.span(),
-                    }));
-                }
-            }
-        }
-    }
-    Ok(None)
+    let Some(cache_node) = mapping.get("cache").and_then(|node| node.as_mapping()) else {
+        return Ok(None);
+    };
+
+    let name = cache_node
+        .get("name")
+        .and_then(|name_node| name_node.as_scalar())
+        .map(|scalar| scalar.as_str().to_string())
+        .unwrap_or_else(|| "default".to_string());
+
+    let name = PackageName::try_from(name.clone()).map_err(|err| {
+        ParsingError::from_partial(
+            "",
+            _partialerror!(
+                cache_node
+                    .get("name")
+                    .map(|node| *node.span())
+                    .unwrap_or_else(marked_yaml::Span::new_blank),
+                ErrorKind::from(err),
+                help = "cache name must be a valid package name"
+            ),
+        )
+    })?;
+
+    Ok(Some(CacheOutput {
+        name,
+        source: Vec::new(),
+        build: CacheBuild::default(),
+        requirements: CacheRequirements::default(),
+        run_exports: RunExports::default(),
+        ignore_run_exports: None,
+        about: None,
+        span: *output.span(),
+    }))
 }
 
 /// Parse inheritance relationships from outputs
diff --git a/src/recipe/parser/output_parser.rs b/src/recipe/parser/output_parser.rs
index 55bd7c140..4cead4cb9 100644
--- a/src/recipe/parser/output_parser.rs
+++ b/src/recipe/parser/output_parser.rs
@@ -7,12 +7,35 @@ use crate::{
         error::{ErrorKind, PartialParsingError},
     },
 };
+use marked_yaml::Span;
 use serde::{Deserialize, Serialize};
 
 use super::cache_output::CacheOutput;
 use super::common_output::InheritSpec;
 use super::{About, Build, OutputPackage, Requirements, Source, TestType};
 
+fn duplicate_field_error(field: &str, span: Span) -> PartialParsingError {
+    _partialerror!(
+        span,
+        ErrorKind::InvalidField(field.to_string().into()),
+        help = "field defined multiple times"
+    )
+}
+
+fn set_option_field<T>(
+    slot: &mut Option<T>,
+    value: T,
+    field: &str,
+    span: Span,
+) -> Result<(), Vec<PartialParsingError>> {
+    if slot.is_some() {
+        Err(vec![duplicate_field_error(field, span)])
+    } else {
+        *slot = Some(value);
+        Ok(())
+    }
+}
+
 /// An output that can inherit from a cache
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Output {
@@ -101,12 +124,17 @@ impl TryConvertNode<Output> for RenderedMappingNode {
         let mut about = None;
 
         for (key, value) in self.iter() {
-            match key.as_str() {
+            let field_name = key.as_str();
+            let span = *key.span();
+
+            match field_name {
                 "package" => {
-                    package = Some(value.try_convert("output.package")?);
+                    let parsed = value.try_convert("output.package")?;
+                    set_option_field(&mut package, parsed, field_name, span)?;
                 }
                 "inherit" => {
-                    inherit = Some(value.try_convert("output.inherit")?);
+                    let parsed = value.try_convert("output.inherit")?;
+                    set_option_field(&mut inherit, parsed, field_name, span)?;
                 }
                 "source" => {
                     source = value.try_convert("output.source")?;
@@ -121,12 +149,13 @@ impl TryConvertNode<Output> for RenderedMappingNode {
                     tests = value.try_convert("output.tests")?;
                 }
                 "about" => {
-                    about = Some(value.try_convert("output.about")?);
+                    let parsed = value.try_convert("output.about")?;
+                    set_option_field(&mut about, parsed, field_name, span)?;
                 }
                 _ => {
                     return Err(vec![_partialerror!(
-                        *key.span(),
-                        ErrorKind::InvalidField(key.as_str().to_string().into())
+                        span,
+                        ErrorKind::InvalidField(field_name.to_string().into())
                     )]);
                 }
             }
diff --git a/src/recipe/parser/parsing_utils.rs b/src/recipe/parser/parsing_utils.rs
index 8518c9335..48562a83b 100644
--- a/src/recipe/parser/parsing_utils.rs
+++ b/src/recipe/parser/parsing_utils.rs
@@ -7,7 +7,9 @@
 use crate::{
     _partialerror,
     recipe::{
-        custom_yaml::{HasSpan, RenderedMappingNode, RenderedNode, TryConvertNode},
+        custom_yaml::{
+            HasSpan, RenderedMappingNode, RenderedNode, RenderedScalarNode, TryConvertNode,
+        },
         error::{ErrorKind, PartialParsingError},
     },
 };
@@ -33,21 +35,28 @@ impl<T: StandardTryConvert> TryConvertNode<T> for RenderedNode {
     }
 }
 
+fn expect_scalar<'a>(
+    value: &'a RenderedNode,
+    field_name: &str,
+    expected: &str,
+    context: &str,
+) -> Result<&'a RenderedScalarNode, Vec<PartialParsingError>> {
+    value.as_scalar().ok_or_else(|| {
+        vec![_partialerror!(
+            *value.span(),
+            ErrorKind::ExpectedScalar,
+            help = format!("expected {} for {} in {}", expected, field_name, context)
+        )]
+    })
+}
+
 /// Helper to parse a required string field
 pub fn parse_required_string(
     value: &RenderedNode,
     field_name: &str,
     context: &str,
 ) -> Result<String, Vec<PartialParsingError>> {
-    Ok(value
-        .as_scalar()
-        .ok_or_else(|| {
-            vec![_partialerror!(
-                *value.span(),
-                ErrorKind::ExpectedScalar,
-                help = format!("expected a string for {} in {}", field_name, context)
-            )]
-        })?
+    Ok(expect_scalar(value, field_name, "a string", context)?
         .as_str()
         .to_string())
 }
@@ -58,13 +67,7 @@ pub fn parse_bool(
     field_name: &str,
     context: &str,
 ) -> Result<bool, Vec<PartialParsingError>> {
-    let scalar = value.as_scalar().ok_or_else(|| {
-        vec![_partialerror!(
-            *value.span(),
-            ErrorKind::ExpectedScalar,
-            help = format!("expected a boolean for {} in {}", field_name, context)
-        )]
-    })?;
+    let scalar = expect_scalar(value, field_name, "a boolean", context)?;
 
     scalar.as_bool().ok_or_else(|| {
         vec![_partialerror!(
diff --git a/src/source/copy_dir.rs b/src/source/copy_dir.rs
index 38d1f2701..fbf48c296 100644
--- a/src/source/copy_dir.rs
+++ b/src/source/copy_dir.rs
@@ -217,15 +217,6 @@ impl<'a> CopyDir<'a> {
         self
     }
 
-    #[allow(unused)]
-    pub fn on_overwrite<F>(mut self, callback: F) -> Self
-    where
-        F: Fn(&Path) + Send + Sync + 'static,
-    {
-        self.copy_options.on_overwrite = Some(Box::new(callback));
-        self
-    }
-
     pub fn exclude_git_dirs(mut self, b: bool) -> Self {
         self.exclude_git_dirs = b;
         self
diff --git a/src/variant_render.rs b/src/variant_render.rs
index 8fe1a5db2..67f6815d2 100644
--- a/src/variant_render.rs
+++ b/src/variant_render.rs
@@ -31,25 +31,30 @@ fn inherit_flags_from_output(output: &Node) -> (bool, bool) {
             .or_else(|| m.get("inherit"))
     });
 
-    match inherit_node {
-        Some(node) if node.as_scalar().is_some() => (true, false),
-        Some(node) => {
-            if let Some(mapping) = node.as_mapping() {
-                let run_exports = mapping
-                    .get("run_exports")
-                    .and_then(|n| n.as_scalar()?.as_bool())
-                    .unwrap_or(true);
-                let requirements = mapping
-                    .get("requirements")
-                    .and_then(|n| n.as_scalar()?.as_bool())
-                    .unwrap_or(false);
-                (run_exports, requirements)
-            } else {
-                (true, false)
-            }
-        }
-        _ => (true, false),
+    let Some(node) = inherit_node else {
+        return (true, false);
+    };
+
+    if node.as_scalar().is_some() {
+        return (true, false);
     }
+
+    let Some(mapping) = node.as_mapping() else {
+        return (true, false);
+    };
+
+    let parse_flag = |key: &str, default| {
+        mapping
+            .get(key)
+            .and_then(|node| node.as_scalar())
+            .and_then(|scalar| scalar.as_bool())
+            .unwrap_or(default)
+    };
+
+    let run_exports = parse_flag("run_exports", true);
+    let requirements = parse_flag("requirements", false);
+
+    (run_exports, requirements)
 }
 
 /// Extract normalized names from unversioned dependency specs (specs without version or build constraints)

From 13e64b07ed62fd495657b6b6d63ebc6b8ae03652 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Mon, 20 Oct 2025 00:55:04 +0300
Subject: [PATCH 26/29] windows fix and typo

---
 src/packaging/metadata.rs | 2 ++
 src/types/build_output.rs | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/packaging/metadata.rs b/src/packaging/metadata.rs
index 6f1b075b4..9ceb28e3f 100644
--- a/src/packaging/metadata.rs
+++ b/src/packaging/metadata.rs
@@ -194,11 +194,13 @@ fn rewrite_binary_prefix(
             search_start = pos + 1;
         }
 
+        mmap.flush()?;
         Ok(())
     }
 
     #[cfg(target_family = "windows")]
     {
+        let _ = (file_path, old_prefix, new_prefix);
         Err(PackagingError::IoError(io::Error::new(
             ErrorKind::Unsupported,
             "Binary prefix replacement is not supported on Windows",
diff --git a/src/types/build_output.rs b/src/types/build_output.rs
index a31bc6c59..e4d04bcb1 100644
--- a/src/types/build_output.rs
+++ b/src/types/build_output.rs
@@ -24,7 +24,7 @@ use crate::{
     types::{BuildConfiguration, BuildSummary, PlatformWithVirtualPackages},
 };
 
-/// A output. This is the central element that is passed to the `run_build`
+/// An output. This is the central element that is passed to the `run_build`
 /// function and fully specifies all the options and settings to run the build.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct BuildOutput {

From bf74b7ab5d3be4e0459868eecc068f9244a2f9ea Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Mon, 20 Oct 2025 00:57:36 +0300
Subject: [PATCH 27/29] extra

---
 src/variant_render.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/variant_render.rs b/src/variant_render.rs
index 67f6815d2..8e29f7393 100644
--- a/src/variant_render.rs
+++ b/src/variant_render.rs
@@ -13,7 +13,7 @@ use crate::{
     recipe::{
         Jinja, ParsingError, Recipe,
         custom_yaml::Node,
-        parser::{BuildString, Dependency},
+        parser::{BuildString, CacheOutput, Dependency},
         variable::Variable,
     },
     selectors::SelectorConfig,
@@ -72,7 +72,7 @@ fn collect_unversioned_deps<'a>(
 /// Apply cache inheritance to a parsed recipe from a cache output
 fn apply_cache_inheritance(
     recipe: &mut Recipe,
-    cache: &crate::recipe::parser::CacheOutput,
+    cache: &CacheOutput,
     inherit_run_exports: bool,
     inherit_requirements: bool,
 ) {
@@ -122,7 +122,7 @@ pub(crate) fn stage_0_render<S: SourceCode>(
     source: S,
     selector_config: &SelectorConfig,
     variant_config: &VariantConfig,
-    cache_outputs: &[crate::recipe::parser::CacheOutput],
+    cache_outputs: &[CacheOutput],
     inheritance_relationships: &HashMap<String, Vec<String>>,
 ) -> Result<Vec<Stage0Render<S>>, VariantError<S>> {
     let used_vars = outputs

From 12a1e4a7d1610c85f7b0386ec8fa73581172ccdd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Mon, 20 Oct 2025 01:13:16 +0300
Subject: [PATCH 28/29] extra

---
 src/cache.rs                       | 32 ++++++++++++++----------------
 src/lib.rs                         |  3 ++-
 src/packaging/metadata.rs          |  9 +++++----
 src/recipe/parser/cache_output.rs  |  6 ++++--
 src/recipe/parser/output.rs        | 30 +++++++++++-----------------
 src/recipe/parser/output_parser.rs |  4 ++--
 src/types/build_output.rs          |  8 ++++++--
 7 files changed, 46 insertions(+), 46 deletions(-)

diff --git a/src/cache.rs b/src/cache.rs
index c180f5f5c..4f530ccb4 100644
--- a/src/cache.rs
+++ b/src/cache.rs
@@ -16,7 +16,7 @@ use crate::{
     packaging::{Files, contains_prefix_binary, contains_prefix_text, rewrite_prefix_in_file},
     recipe::{
         Jinja,
-        parser::{Dependency, Requirements, Source},
+        parser::{CacheOutput, CacheRequirements, Dependency, Requirements, RunExports, Source},
     },
     render::resolved_dependencies::{
         FinalizedDependencies, RunExportsDownload, install_environments, resolve_dependencies,
@@ -26,6 +26,7 @@ use crate::{
         fetch_sources,
         patch::apply_patch_custom,
     },
+    tool_configuration::Configuration,
 };
 
 /// Check if a file contains the prefix and determine if it's binary or text
@@ -103,7 +104,7 @@ pub struct Cache {
 
     /// The run exports declared by the cache at build time (rendered form is computed later)
     #[serde(default)]
-    pub run_exports: crate::recipe::parser::RunExports,
+    pub run_exports: RunExports,
 
     /// Files (relative to prefix/work_dir) that contain the old prefix string and
     /// should be rewritten when restoring to a different location.
@@ -131,20 +132,17 @@ impl Output {
     pub fn cache_key_for(
         &self,
         cache_name: &str,
-        cache_reqs: &crate::recipe::parser::CacheRequirements,
+        cache_reqs: &CacheRequirements,
     ) -> Result<String, CacheKeyError> {
         let requirement_names: HashSet<_> = cache_reqs
             .build
             .iter()
             .chain(cache_reqs.host.iter())
             .filter_map(|dep| match dep {
-                crate::recipe::parser::Dependency::Spec(spec)
-                    if spec.version.is_none() && spec.build.is_none() =>
-                {
-                    spec.name
-                        .as_ref()
-                        .map(|name| name.as_normalized().to_string())
-                }
+                Dependency::Spec(spec) if spec.version.is_none() && spec.build.is_none() => spec
+                    .name
+                    .as_ref()
+                    .map(|name| name.as_normalized().to_string()),
                 _ => None,
             })
             .chain(
@@ -349,8 +347,8 @@ impl Output {
     /// Build or fetch a specific cache output
     pub async fn build_or_fetch_cache_output(
         mut self,
-        cache_output: &crate::recipe::parser::CacheOutput,
-        tool_configuration: &crate::tool_configuration::Configuration,
+        cache_output: &CacheOutput,
+        tool_configuration: &Configuration,
     ) -> Result<Self, miette::Error> {
         let cache_name = cache_output.name.as_normalized();
         let cache_key = self
@@ -410,12 +408,12 @@ impl Output {
             .into_diagnostic()?;
 
         // Convert CacheRequirements to Requirements
-        let requirements = crate::recipe::parser::Requirements {
+        let requirements = Requirements {
             build: cache_output.requirements.build.clone(),
             host: cache_output.requirements.host.clone(),
             run: Vec::new(),
             run_constraints: Vec::new(),
-            run_exports: crate::recipe::parser::RunExports::default(),
+            run_exports: RunExports::default(),
             ignore_run_exports: cache_output.ignore_run_exports.clone().unwrap_or_default(),
         };
 
@@ -564,7 +562,7 @@ impl Output {
     /// Note: this modifies the output in place
     pub(crate) async fn build_or_fetch_cache(
         self,
-        tool_configuration: &crate::tool_configuration::Configuration,
+        tool_configuration: &Configuration,
     ) -> Result<Self, miette::Error> {
         if let Some(synthetic_cache) = self.recipe.synthetic_cache_output() {
             // Convert to synthetic cache output
@@ -579,7 +577,7 @@ impl Output {
     #[allow(dead_code)]
     async fn build_or_fetch_cache_legacy(
         mut self,
-        tool_configuration: &crate::tool_configuration::Configuration,
+        tool_configuration: &Configuration,
     ) -> Result<Self, miette::Error> {
         if let Some(cache) = self.recipe.cache.clone() {
             // if we don't have a cache, we need to run the cache build with our current
@@ -741,7 +739,7 @@ impl Output {
                 work_dir_files: work_dir_files.copied_paths().to_vec(),
                 prefix: self.prefix().to_path_buf(),
                 work_dir: self.build_configuration.directories.work_dir.clone(),
-                run_exports: crate::recipe::parser::RunExports::default(),
+                run_exports: RunExports::default(),
                 files_with_prefix,
                 binary_files_with_prefix,
                 files_with_work_dir: Vec::new(),
diff --git a/src/lib.rs b/src/lib.rs
index dd2d4d26a..b62aa904e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -67,6 +67,7 @@ use rattler_conda_types::{
 use rattler_config::config::build::PackageFormatAndCompression;
 use rattler_solve::SolveStrategy;
 use rattler_virtual_packages::VirtualPackageOverrides;
+use recipe::parser::output::resolve_cache_inheritance_with_caches;
 use recipe::parser::{Dependency, Recipe, TestType, find_outputs_from_src};
 use recipe::variable::Variable;
 use render::resolved_dependencies::RunExportsDownload;
@@ -233,7 +234,7 @@ pub async fn get_build_output(
         });
 
         let jinja = recipe::Jinja::new(selector_config.clone());
-        recipe::parser::output::resolve_cache_inheritance_with_caches(
+        resolve_cache_inheritance_with_caches(
             outputs,
             has_toplevel_cache,
             selector_config.experimental,
diff --git a/src/packaging/metadata.rs b/src/packaging/metadata.rs
index 9ceb28e3f..841dba0c4 100644
--- a/src/packaging/metadata.rs
+++ b/src/packaging/metadata.rs
@@ -14,6 +14,7 @@ use content_inspector::ContentType;
 use fs_err as fs;
 use fs_err::File;
 use itertools::Itertools;
+use memchr::memmem;
 use rattler_conda_types::{
     ChannelUrl, NoArchType, Platform,
     package::{
@@ -60,7 +61,7 @@ pub fn contains_prefix_binary(file_path: &Path, prefix: &Path) -> Result<bool, P
         let data = unsafe { memmap2::Mmap::map(&file) }?;
 
         // Check if the content contains the prefix bytes with memchr
-        let contains_prefix = memchr::memmem::find_iter(data.as_ref(), &prefix_bytes)
+        let contains_prefix = memmem::find_iter(data.as_ref(), &prefix_bytes)
             .next()
             .is_some();
 
@@ -83,7 +84,7 @@ pub fn contains_prefix_text(
     // Check if the content contains the prefix with memchr
     let prefix_string = prefix.to_string_lossy().to_string();
     let mut detected_prefix = None;
-    if memchr::memmem::find_iter(mmap.as_ref(), &prefix_string)
+    if memmem::find_iter(mmap.as_ref(), &prefix_string)
         .next()
         .is_some()
     {
@@ -99,7 +100,7 @@ pub fn contains_prefix_text(
         // to something meaningful in unix either way
         let forward_slash: Cow<'_, str> = to_forward_slash_lossy(prefix);
 
-        if memchr::memmem::find_iter(mmap.as_ref(), forward_slash.deref())
+        if memmem::find_iter(mmap.as_ref(), forward_slash.deref())
             .next()
             .is_some()
         {
@@ -186,7 +187,7 @@ fn rewrite_binary_prefix(
         let mut mmap = unsafe { memmap2::MmapOptions::new().map_mut(&file) }?;
 
         let mut search_start = 0;
-        while let Some(found) = memchr::memmem::find(&mmap[search_start..], old_prefix_bytes) {
+        while let Some(found) = memmem::find(&mmap[search_start..], old_prefix_bytes) {
             let pos = search_start + found;
             mmap[pos..pos + new_prefix_bytes.len()].copy_from_slice(new_prefix_bytes);
             let padding_range = pos + new_prefix_bytes.len()..pos + old_prefix_bytes.len();
diff --git a/src/recipe/parser/cache_output.rs b/src/recipe/parser/cache_output.rs
index c256f131d..d6d0eabb7 100644
--- a/src/recipe/parser/cache_output.rs
+++ b/src/recipe/parser/cache_output.rs
@@ -10,7 +10,9 @@
 use crate::{
     _partialerror,
     recipe::{
-        custom_yaml::{HasSpan, RenderedMappingNode, RenderedNode, TryConvertNode},
+        custom_yaml::{
+            HasSpan, RenderedMappingNode, RenderedNode, RenderedScalarNode, TryConvertNode,
+        },
         error::{ErrorKind, PartialParsingError},
         parser::{
             StandardTryConvert, build::VariantKeyUsage, invalid_field_error, missing_field_error,
@@ -377,7 +379,7 @@ fn parse_cache_requirements(
 }
 
 // For compatibility with Vec<CacheOutput> parsing
-impl TryConvertNode<CacheOutput> for crate::recipe::custom_yaml::RenderedScalarNode {
+impl TryConvertNode<CacheOutput> for RenderedScalarNode {
     fn try_convert(&self, _name: &str) -> Result<CacheOutput, Vec<PartialParsingError>> {
         Err(vec![_partialerror!(
             *self.span(),
diff --git a/src/recipe/parser/output.rs b/src/recipe/parser/output.rs
index 96929be86..0a0596763 100644
--- a/src/recipe/parser/output.rs
+++ b/src/recipe/parser/output.rs
@@ -10,7 +10,7 @@ use std::collections::{HashMap, HashSet};
 use crate::{
     _partialerror,
     recipe::{
-        ParsingError, Render,
+        Jinja, ParsingError, Render,
         custom_yaml::{HasSpan, Node, RenderedNode, TryConvertNode, parse_yaml},
         error::{ErrorKind, PartialParsingError},
     },
@@ -29,14 +29,8 @@ use super::{
 };
 
 /// Result type for resolve_cache_inheritance_with_caches function
-type CacheInheritanceResult = Result<
-    (
-        Vec<Node>,
-        Vec<crate::recipe::parser::CacheOutput>,
-        std::collections::HashMap<String, Vec<String>>,
-    ),
-    ParsingError<&'static str>,
->;
+type CacheInheritanceResult =
+    Result<(Vec<Node>, Vec<CacheOutput>, HashMap<String, Vec<String>>), ParsingError<&'static str>>;
 
 // Extract inherit information
 fn inherit_name_from(node: &Node) -> Option<String> {
@@ -517,7 +511,7 @@ fn detect_cache_inheritance_cycles(
 /// Parse a cache output from a Node using proper TryConvertNode
 fn parse_cache_output_from_node(
     output: &Node,
-) -> Result<Option<crate::recipe::parser::CacheOutput>, ParsingError<&'static str>> {
+) -> Result<Option<CacheOutput>, ParsingError<&'static str>> {
     // Convert Node to RenderedNode to use TryConvertNode
     // For now, we'll use a simplified approach since we don't have jinja context here
     // In a full implementation, we would need to render the node first
@@ -565,8 +559,8 @@ fn parse_cache_output_from_node(
 /// Parse inheritance relationships from outputs
 fn parse_inheritance_relationships(
     outputs: &[Node],
-) -> Result<std::collections::HashMap<String, Vec<String>>, ParsingError<&'static str>> {
-    let mut relationships = std::collections::HashMap::new();
+) -> Result<HashMap<String, Vec<String>>, ParsingError<&'static str>> {
+    let mut relationships = HashMap::new();
 
     for output in outputs {
         let Some(mapping) = output.as_mapping() else {
@@ -623,8 +617,8 @@ fn parse_inheritance_relationships(
 /// Parse cache outputs using proper TryConvertNode with jinja context
 fn parse_cache_outputs_with_context(
     outputs: &[Node],
-    jinja: &crate::recipe::Jinja,
-) -> Result<Vec<crate::recipe::parser::CacheOutput>, ParsingError<&'static str>> {
+    jinja: &Jinja,
+) -> Result<Vec<CacheOutput>, ParsingError<&'static str>> {
     use super::output_parser::OutputType;
     let mut cache_outputs = Vec::new();
 
@@ -747,10 +741,10 @@ fn topological_sort(inheritance: &HashMap<String, Vec<String>>) -> Vec<String> {
 
 /// Apply cache-to-cache inheritance to the cache outputs
 fn apply_cache_to_cache_inheritance(
-    cache_outputs: Vec<crate::recipe::parser::CacheOutput>,
+    cache_outputs: Vec<CacheOutput>,
     cache_inheritance_relationships: HashMap<String, Vec<String>>,
-) -> Vec<crate::recipe::parser::CacheOutput> {
-    let mut cache_map: HashMap<String, crate::recipe::parser::CacheOutput> = cache_outputs
+) -> Vec<CacheOutput> {
+    let mut cache_map: HashMap<String, CacheOutput> = cache_outputs
         .into_iter()
         .map(|cache| (cache.name.as_normalized().to_string(), cache))
         .collect();
@@ -816,7 +810,7 @@ pub fn resolve_cache_inheritance_with_caches(
     outputs: Vec<Node>,
     has_toplevel_cache: bool,
     experimental_enabled: bool,
-    jinja: &crate::recipe::Jinja,
+    jinja: &Jinja,
 ) -> CacheInheritanceResult {
     if !experimental_enabled {
         for output in &outputs {
diff --git a/src/recipe/parser/output_parser.rs b/src/recipe/parser/output_parser.rs
index 4cead4cb9..02b0902de 100644
--- a/src/recipe/parser/output_parser.rs
+++ b/src/recipe/parser/output_parser.rs
@@ -12,7 +12,7 @@ use serde::{Deserialize, Serialize};
 
 use super::cache_output::CacheOutput;
 use super::common_output::InheritSpec;
-use super::{About, Build, OutputPackage, Requirements, Source, TestType};
+use super::{About, Build, OutputPackage, Requirements, Source, TestType, build::VariantKeyUsage};
 
 fn duplicate_field_error(field: &str, span: Span) -> PartialParsingError {
     _partialerror!(
@@ -216,7 +216,7 @@ impl Output {
         }
 
         // Deep merge compatible build fields from cache (script is intentionally excluded)
-        let variant_is_default = |v: &super::build::VariantKeyUsage| {
+        let variant_is_default = |v: &VariantKeyUsage| {
             v.use_keys.is_empty() && v.ignore_keys.is_empty() && v.down_prioritize_variant.is_none()
         };
         if variant_is_default(&self.build.variant) && !variant_is_default(&cache.build.variant) {
diff --git a/src/types/build_output.rs b/src/types/build_output.rs
index e4d04bcb1..384d9379a 100644
--- a/src/types/build_output.rs
+++ b/src/types/build_output.rs
@@ -18,7 +18,11 @@ use std::{
 use crate::{
     NormalizedKey,
     console_utils::github_integration_enabled,
-    recipe::{Recipe, parser::Source, variable::Variable},
+    recipe::{
+        Recipe,
+        parser::{CacheOutput, Source},
+        variable::Variable,
+    },
     render::resolved_dependencies::FinalizedDependencies,
     system_tools::SystemTools,
     types::{BuildConfiguration, BuildSummary, PlatformWithVirtualPackages},
@@ -58,7 +62,7 @@ pub struct BuildOutput {
 
     /// Cache outputs that need to be built before this package output
     #[serde(skip_serializing_if = "Vec::is_empty", default)]
-    pub cache_outputs_to_build: Vec<crate::recipe::parser::CacheOutput>,
+    pub cache_outputs_to_build: Vec<CacheOutput>,
 
     /// Summary of the build
     #[serde(skip)]

From e46b099abd2eb87bc1aa5ad3fc1dbeee435c79e2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denizhan=20Dak=C4=B1l=C4=B1r?= <denizhandakilirn@gmail.com>
Date: Mon, 20 Oct 2025 01:29:17 +0300
Subject: [PATCH 29/29] windows fix

---
 src/cache.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/cache.rs b/src/cache.rs
index 4f530ccb4..9bc28460e 100644
--- a/src/cache.rs
+++ b/src/cache.rs
@@ -13,7 +13,7 @@ use sha2::{Digest, Sha256};
 use crate::{
     env_vars,
     metadata::{Output, build_reindexed_channels},
-    packaging::{Files, contains_prefix_binary, contains_prefix_text, rewrite_prefix_in_file},
+    packaging::{Files, contains_prefix_text, rewrite_prefix_in_file},
     recipe::{
         Jinja,
         parser::{CacheOutput, CacheRequirements, Dependency, Requirements, RunExports, Source},
@@ -29,6 +29,9 @@ use crate::{
     tool_configuration::Configuration,
 };
 
+#[cfg(target_family = "unix")]
+use crate::packaging::contains_prefix_binary;
+
 /// Check if a file contains the prefix and determine if it's binary or text
 /// Returns (has_prefix, is_text)
 fn check_file_for_prefix(file_path: &Path, prefix: &Path) -> (bool, bool) {