context-engine 0.1.6-alpha.1

extern crate alloc;
use alloc::string::String;
use alloc::vec::Vec;
use alloc::collections::BTreeMap;

use super::codec;
use super::fixed_bits;
use super::pool::DynamicPool;
use super::parser::ParsedManifest;

/// A single token in a template value.
#[derive(Debug)]
pub enum TemplateToken {
    /// Literal byte sequence.
    Literal(Vec<u8>),
    /// A path placeholder — intern-index sequence (file segment + field segments).
    Path(Vec<u16>),
}

/// A resolved or unresolved config value produced by `build_config`.
/// State layer is responsible for resolving `Path` and `Template` variants.
#[derive(Debug)]
pub enum ConfigValue {
    /// Static string value (no placeholder resolution needed).
    Str(String),
    /// A single path reference — intern-index sequence to resolve via State.
    Path(Vec<u16>),
    /// A mixed literal+path template — tokens to resolve and concatenate.
    Template(Vec<TemplateToken>),
    /// A map of (yaml_key → db_column) pairs.
    Map(Vec<(String, String)>),
    /// Numeric client id.
    Client(u64),
}

/// Owns all parsed manifest data and provides decode queries.
/// Pure logic — no I/O, no std, no serde_json.
pub struct Manifest {
    pub files: BTreeMap<String, ParsedManifest>,
    pub dynamic: DynamicPool,
    pub keys: Vec<u64>,
    pub values: Vec<[u64; 2]>,
    pub path_map: Vec<Vec<u16>>,
    pub children_map: Vec<Vec<u16>>,
}

impl Manifest {
    pub fn new() -> Self {
        Self {
            files: BTreeMap::new(),
            dynamic: DynamicPool::new(),
            keys: alloc::vec![0],
            values: alloc::vec![[0, 0]],
            path_map: alloc::vec![alloc::vec![]],
            children_map: alloc::vec![alloc::vec![]],
        }
    }

    pub fn is_loaded(&self, file: &str) -> bool {
        self.files.contains_key(file)
    }

    pub fn insert(&mut self, file: String, pm: ParsedManifest) {
        self.files.insert(file, pm);
    }

    /// Returns the direct field-key and meta-key children indices of a record.
    pub fn children_of(&self, record: u64) -> Vec<u16> {
        let child_idx = fixed_bits::get(record, fixed_bits::K_OFFSET_CHILD, fixed_bits::K_MASK_CHILD) as usize;
        if child_idx == 0 {
            return alloc::vec![];
        }
        let has_children = fixed_bits::get(record, fixed_bits::K_OFFSET_HAS_CHILDREN, fixed_bits::K_MASK_HAS_CHILDREN);
        if has_children == 1 {
            self.children_map.get(child_idx)
                .map(|s| s.to_vec())
                .unwrap_or_default()
        } else {
            alloc::vec![child_idx as u16]
        }
    }

    /// Looks up a key record index by dot-separated path within a file.
    pub fn find(&self, file: &str, path: &str) -> Option<u16> {
        let file_idx = self.files.get(file)?.file_key_idx;
        let file_record = self.keys.get(file_idx as usize).copied()?;

        if path.is_empty() {
            return Some(file_idx);
        }

        let segments: Vec<&str> = path.split('.').collect();
        let top_level = self.children_of(file_record);
        self.find_in(&segments, &top_level)
    }

    fn find_in(&self, segments: &[&str], candidates: &[u16]) -> Option<u16> {
        let target = segments[0].as_bytes();
        let rest = &segments[1..];

        for &idx in candidates {
            let record = self.keys.get(idx as usize).copied()?;
            if fixed_bits::get(record, fixed_bits::K_OFFSET_ROOT, fixed_bits::K_MASK_ROOT) != fixed_bits::ROOT_NULL {
                continue;
            }
            let dyn_idx = fixed_bits::get(record, fixed_bits::K_OFFSET_DYNAMIC, fixed_bits::K_MASK_DYNAMIC) as u16;
            if self.dynamic.get(dyn_idx)? != target {
                continue;
            }
            if rest.is_empty() {
                return Some(idx);
            }
            let next = self.children_of(record);
            if next.is_empty() {
                return None;
            }
            return self.find_in(rest, &next);
        }
        None
    }

    /// Returns meta record indices (_load/_store/_state) for a dot-path node.
    /// Collects from root to node; child overrides parent.
    pub fn get_meta(&self, file: &str, path: &str) -> MetaIndices {
        let file_idx = match self.files.get(file) {
            Some(pm) => pm.file_key_idx,
            None => return MetaIndices::default(),
        };
        let file_record = match self.keys.get(file_idx as usize).copied() {
            Some(r) => r,
            None => return MetaIndices::default(),
        };

        let segments: Vec<&str> = if path.is_empty() { alloc::vec![] } else { path.split('.').collect() };
        let mut meta = MetaIndices::default();
        self.collect_meta(file_record, file_idx, &mut meta);

        let mut candidates = self.children_of(file_record);
        for segment in &segments {
            let mut found_idx = None;
            for &idx in &candidates {
                let record = match self.keys.get(idx as usize).copied() {
                    Some(r) => r,
                    None => continue,
                };
                if fixed_bits::get(record, fixed_bits::K_OFFSET_ROOT, fixed_bits::K_MASK_ROOT) != fixed_bits::ROOT_NULL {
                    continue;
                }
                let dyn_idx = fixed_bits::get(record, fixed_bits::K_OFFSET_DYNAMIC, fixed_bits::K_MASK_DYNAMIC) as u16;
                if self.dynamic.get(dyn_idx) == Some(segment.as_bytes()) {
                    self.collect_meta(record, idx, &mut meta);
                    found_idx = Some(idx);
                    break;
                }
            }
            match found_idx {
                Some(idx) => {
                    let record = self.keys[idx as usize];
                    candidates = self.children_of(record);
                }
                None => return MetaIndices::default(),
            }
        }
        meta
    }

    fn collect_meta(&self, record: u64, node_idx: u16, meta: &mut MetaIndices) {
        for &idx in &self.children_of(record) {
            let child = match self.keys.get(idx as usize).copied() {
                Some(r) => r,
                None => continue,
            };
            let root = fixed_bits::get(child, fixed_bits::K_OFFSET_ROOT, fixed_bits::K_MASK_ROOT);
            match root {
                fixed_bits::ROOT_LOAD  => { meta.load  = Some(idx); meta.load_owner  = node_idx; }
                fixed_bits::ROOT_STORE => { meta.store = Some(idx); meta.store_owner = node_idx; }
                fixed_bits::ROOT_STATE => { meta.state = Some(idx); }
                _ => {}
            }
        }
    }

    /// Returns the client id encoded in a meta record (e.g. _load or _store).
    pub fn get_client(&self, meta_idx: u16) -> u64 {
        let record = match self.keys.get(meta_idx as usize).copied() {
            Some(r) => r,
            None => return fixed_bits::CLIENT_NULL,
        };
        // client is stored directly on the meta record's children
        for &child_idx in &self.children_of(record) {
            let child = match self.keys.get(child_idx as usize).copied() {
                Some(r) => r,
                None => continue,
            };
            let client = fixed_bits::get(child, fixed_bits::K_OFFSET_CLIENT, fixed_bits::K_MASK_CLIENT);
            if client != fixed_bits::CLIENT_NULL {
                return client;
            }
        }
        fixed_bits::CLIENT_NULL
    }

    /// Decodes a meta record into a list of (prop_name, ConfigValue) pairs.
    /// The caller (State) is responsible for resolving any `ConfigValue::Placeholder` entries.
    pub fn build_config(&self, meta_idx: u16) -> Option<Vec<(String, ConfigValue)>> {
        let record = self.keys.get(meta_idx as usize).copied()?;
        let child_idx = fixed_bits::get(record, fixed_bits::K_OFFSET_CHILD, fixed_bits::K_MASK_CHILD) as usize;
        if child_idx == 0 {
            return None;
        }
        let children = if fixed_bits::get(record, fixed_bits::K_OFFSET_HAS_CHILDREN, fixed_bits::K_MASK_HAS_CHILDREN) == 1 {
            self.children_map.get(child_idx)?.to_vec()
        } else {
            alloc::vec![child_idx as u16]
        };

        let mut entries: Vec<(String, ConfigValue)> = alloc::vec![];

        for &child_idx in &children {
            let child_record = match self.keys.get(child_idx as usize).copied() {
                Some(r) => r,
                None => continue,
            };
            let prop   = fixed_bits::get(child_record, fixed_bits::K_OFFSET_PROP,   fixed_bits::K_MASK_PROP)   as u8;
            let client = fixed_bits::get(child_record, fixed_bits::K_OFFSET_CLIENT, fixed_bits::K_MASK_CLIENT);
            let is_leaf = fixed_bits::get(child_record, fixed_bits::K_OFFSET_IS_LEAF, fixed_bits::K_MASK_IS_LEAF) == 1;
            let value_idx = if is_leaf {
                fixed_bits::get(child_record, fixed_bits::K_OFFSET_CHILD, fixed_bits::K_MASK_CHILD) as u16
            } else { 0 };

            if client != fixed_bits::CLIENT_NULL {
                entries.push(("client".into(), ConfigValue::Client(client)));
                continue;
            }

            if prop as u64 == fixed_bits::PROP_NULL { continue; }

            if prop as u64 == fixed_bits::PROP_MAP {
                if let Some(pairs) = self.decode_map(child_idx) {
                    entries.push(("map".into(), ConfigValue::Map(pairs)));
                }
            } else if prop as u64 == fixed_bits::PROP_CONNECTION {
                if value_idx != 0 {
                    if let Some(cv) = self.decode_value(value_idx) {
                        entries.push(("connection".into(), cv));
                    }
                }
            } else if value_idx != 0 {
                if let Some(cv) = self.decode_value(value_idx) {
                    if let Some((name_bytes, _)) = codec::PROP_NAMES.iter().find(|(_, v)| *v == prop as u64) {
                        let name = String::from_utf8_lossy(name_bytes).into_owned();
                        entries.push((name, cv));
                    }
                }
            }
        }

        Some(entries)
    }

    /// Decodes a map prop's children into (yaml_key, db_column) pairs.
    pub fn decode_map(&self, map_idx: u16) -> Option<Vec<(String, String)>> {
        let record = self.keys.get(map_idx as usize).copied()?;
        let child_idx = fixed_bits::get(record, fixed_bits::K_OFFSET_CHILD, fixed_bits::K_MASK_CHILD) as usize;
        if child_idx == 0 {
            return Some(alloc::vec![]);
        }
        let children = if fixed_bits::get(record, fixed_bits::K_OFFSET_HAS_CHILDREN, fixed_bits::K_MASK_HAS_CHILDREN) == 1 {
            self.children_map.get(child_idx)?.to_vec()
        } else {
            alloc::vec![child_idx as u16]
        };

        let mut pairs = alloc::vec![];
        for &c in &children {
            let child = self.keys.get(c as usize).copied()?;
            let dyn_idx   = fixed_bits::get(child, fixed_bits::K_OFFSET_DYNAMIC, fixed_bits::K_MASK_DYNAMIC) as u16;
            let value_idx = fixed_bits::get(child, fixed_bits::K_OFFSET_CHILD,   fixed_bits::K_MASK_CHILD) as usize;
            let is_path   = fixed_bits::get(child, fixed_bits::K_OFFSET_IS_PATH, fixed_bits::K_MASK_IS_PATH) == 1;

            let key_str = if is_path {
                let segs = self.path_map.get(dyn_idx as usize)?;
                let parts: Vec<&str> = segs.iter()
                    .filter_map(|&s| self.dynamic.get(s).and_then(|b| core::str::from_utf8(b).ok()))
                    .collect();
                parts.join(".")
            } else {
                let b = self.dynamic.get(dyn_idx)?;
                String::from_utf8_lossy(b).into_owned()
            };

            let val_vo = self.values.get(value_idx).copied()?;
            let col_dyn = fixed_bits::get(val_vo[0], fixed_bits::V_OFFSET_T0_DYNAMIC, fixed_bits::V_MASK_DYNAMIC) as u16;
            let col_b = self.dynamic.get(col_dyn)?;
            let col_str = String::from_utf8_lossy(col_b).into_owned();

            pairs.push((key_str, col_str));
        }
        Some(pairs)
    }

    /// Decodes a value record into a ConfigValue.
    /// - Single path token (non-template)  → `Path(Vec<u16>)` (intern-index segments)
    /// - Mixed literal+path (template)     → `Template(Vec<TemplateToken>)`
    /// - Pure literal (no paths)           → `Str(String)`
    pub fn decode_value(&self, value_idx: u16) -> Option<ConfigValue> {
        const TOKEN_OFFSETS: [(u32, u32); 6] = [
            (fixed_bits::V_OFFSET_T0_IS_PATH, fixed_bits::V_OFFSET_T0_DYNAMIC),
            (fixed_bits::V_OFFSET_T1_IS_PATH, fixed_bits::V_OFFSET_T1_DYNAMIC),
            (fixed_bits::V_OFFSET_T2_IS_PATH, fixed_bits::V_OFFSET_T2_DYNAMIC),
            (fixed_bits::V_OFFSET_T3_IS_PATH, fixed_bits::V_OFFSET_T3_DYNAMIC),
            (fixed_bits::V_OFFSET_T4_IS_PATH, fixed_bits::V_OFFSET_T4_DYNAMIC),
            (fixed_bits::V_OFFSET_T5_IS_PATH, fixed_bits::V_OFFSET_T5_DYNAMIC),
        ];

        let vo = self.values.get(value_idx as usize).copied()?;
        let is_template = fixed_bits::get(vo[0], fixed_bits::V_OFFSET_IS_TEMPLATE, fixed_bits::V_MASK_IS_TEMPLATE) == 1;
        let is_path0 = fixed_bits::get(vo[0], fixed_bits::V_OFFSET_T0_IS_PATH, fixed_bits::V_MASK_IS_PATH) == 1;
        let dyn_idx0 = fixed_bits::get(vo[0], fixed_bits::V_OFFSET_T0_DYNAMIC, fixed_bits::V_MASK_DYNAMIC) as u16;

        // single pure path reference (non-template) → Path
        if is_path0 && dyn_idx0 != 0 && !is_template {
            let segs = self.path_map.get(dyn_idx0 as usize)?.clone();
            return Some(ConfigValue::Path(segs));
        }

        // template: collect tokens as TemplateToken list
        if is_template {
            let mut tokens = Vec::new();
            for (i, (off_is_path, off_dynamic)) in TOKEN_OFFSETS.iter().enumerate() {
                let word = if i < 3 { 0 } else { 1 };
                let is_path = fixed_bits::get(vo[word], *off_is_path, fixed_bits::V_MASK_IS_PATH) == 1;
                let dyn_idx = fixed_bits::get(vo[word], *off_dynamic, fixed_bits::V_MASK_DYNAMIC) as u16;
                if dyn_idx == 0 { break; }
                if is_path {
                    let segs = self.path_map.get(dyn_idx as usize)?.clone();
                    tokens.push(TemplateToken::Path(segs));
                } else {
                    let b = self.dynamic.get(dyn_idx)?.to_vec();
                    tokens.push(TemplateToken::Literal(b));
                }
            }
            return Some(ConfigValue::Template(tokens));
        }

        // pure literal
        let b = self.dynamic.get(dyn_idx0)?.to_vec();
        Some(ConfigValue::Str(String::from_utf8_lossy(&b).into_owned()))
    }

    /// Reconstructs a dot-joined key string from intern-index segments.
    /// Returns an error string if any segment index is invalid.
    pub fn segs_to_key(&self, segs: &[u16]) -> Result<String, crate::ports::provided::StateError> {
        let mut parts = Vec::with_capacity(segs.len());
        for &s in segs {
            let b = self.dynamic.get(s)
                .ok_or_else(|| crate::ports::provided::StateError::KeyNotFound(format!("invalid segment index {}", s)))?;
            parts.push(String::from_utf8_lossy(b).into_owned());
        }
        Ok(parts.join("."))
    }

    /// Finds a field-key record by intern-index segment list.
    /// `segs[0]` must be the file name segment, `segs[1..]` are the field path.
    pub fn find_by_segs(&self, segs: &[u16]) -> Option<u16> {
        if segs.is_empty() { return None; }
        let file_name = self.dynamic.get(segs[0])?;
        let file_str = core::str::from_utf8(file_name).ok()?;
        let file_idx = self.files.get(file_str)?.file_key_idx;
        if segs.len() == 1 {
            return Some(file_idx);
        }
        let file_record = self.keys.get(file_idx as usize).copied()?;
        let top_level = self.children_of(file_record);
        self.find_in_by_segs(&segs[1..], &top_level)
    }

    fn find_in_by_segs(&self, segs: &[u16], candidates: &[u16]) -> Option<u16> {
        let target_idx = segs[0];
        let rest = &segs[1..];
        for &idx in candidates {
            let record = self.keys.get(idx as usize).copied()?;
            if fixed_bits::get(record, fixed_bits::K_OFFSET_ROOT, fixed_bits::K_MASK_ROOT) != fixed_bits::ROOT_NULL {
                continue;
            }
            let dyn_idx = fixed_bits::get(record, fixed_bits::K_OFFSET_DYNAMIC, fixed_bits::K_MASK_DYNAMIC) as u16;
            if dyn_idx != target_idx {
                continue;
            }
            if rest.is_empty() {
                return Some(idx);
            }
            let next = self.children_of(record);
            if next.is_empty() {
                return None;
            }
            return self.find_in_by_segs(rest, &next);
        }
        None
    }
}

impl Default for Manifest {
    fn default() -> Self {
        Self::new()
    }
}

/// Indices of meta records for a given node, collected from root to node (child overrides parent).
/// `load_owner` / `store_owner` are the key_idx of the node that directly defines `_load` / `_store`.
#[derive(Debug, Default)]
pub struct MetaIndices {
    pub load:        Option<u16>,
    pub load_owner:  u16,
    pub store:       Option<u16>,
    pub store_owner: u16,
    pub state:       Option<u16>,
}

#[cfg(test)]
mod tests {
    use super::*;
    use super::super::parser::{Value, parse};

    /// Builds a Manifest from a inline DSL mapping.
    /// `entries` is the top-level key→subtree mapping for a single file.
    fn make(filename: &str, entries: Vec<(&str, Value)>) -> Manifest {
        let mut m = Manifest::new();
        let root = Value::Mapping(entries.into_iter().map(|(k, v)| (k.as_bytes().to_vec(), v)).collect());
        let pm = parse(filename, root, &mut m.dynamic, &mut m.keys, &mut m.values, &mut m.path_map, &mut m.children_map).unwrap();
        m.insert(filename.to_string(), pm);
        m
    }

    fn scalar(s: &str) -> Value { Value::Scalar(s.as_bytes().to_vec()) }
    fn mapping(entries: Vec<(&str, Value)>) -> Value {
        Value::Mapping(entries.into_iter().map(|(k, v)| (k.as_bytes().to_vec(), v)).collect())
    }

    fn cache_manifest() -> Manifest {
        make("cache", vec![
            ("user", mapping(vec![
                ("_store", mapping(vec![
                    ("client", scalar("KVS")),
                    ("key", scalar("user:${session.sso_user_id}")),
                ])),
                ("_load", mapping(vec![
                    ("client", scalar("Db")),
                    ("connection", scalar("${connection.tenant}")),
                    ("table", scalar("users")),
                    ("map", mapping(vec![
                        ("id", scalar("id")),
                        ("org_id", scalar("sso_org_id")),
                    ])),
                ])),
                ("id", mapping(vec![
                    ("_state", mapping(vec![("type", scalar("integer"))])),
                ])),
                ("tenant_id", mapping(vec![
                    ("_state", mapping(vec![("type", scalar("integer"))])),
                    ("_load", mapping(vec![
                        ("client", scalar("State")),
                        ("key", scalar("${org_id}")),
                    ])),
                ])),
            ])),
        ])
    }

    // --- find ---

    #[test]
    fn test_find_file_not_loaded_returns_none() {
        let m = Manifest::new();
        assert!(m.find("cache", "user").is_none());
    }

    #[test]
    fn test_find_top_level() {
        let m = cache_manifest();
        assert!(m.find("cache", "user").is_some());
    }

    #[test]
    fn test_find_nested() {
        let m = cache_manifest();
        assert!(m.find("cache", "user.id").is_some());
    }

    #[test]
    fn test_find_unknown_returns_none() {
        let m = cache_manifest();
        assert!(m.find("cache", "nonexistent").is_none());
    }

    #[test]
    fn test_find_unknown_nested_returns_none() {
        let m = cache_manifest();
        assert!(m.find("cache", "user.nonexistent").is_none());
    }

    #[test]
    fn test_find_unique_indices_across_files() {
        let mut m = cache_manifest();
        let root2 = Value::Mapping(vec![
            (b"common".to_vec(), Value::Mapping(vec![
                (b"_store".to_vec(), Value::Mapping(vec![
                    (b"client".to_vec(), Value::Scalar(b"InMemory".to_vec())),
                ])),
            ])),
        ]);
        let pm2 = parse("connection", root2, &mut m.dynamic, &mut m.keys, &mut m.values, &mut m.path_map, &mut m.children_map).unwrap();
        m.insert("connection".to_string(), pm2);

        let cache_idx = m.find("cache", "user").unwrap();
        let conn_idx  = m.find("connection", "common").unwrap();
        assert_ne!(cache_idx, conn_idx);
    }

    // --- get_meta ---

    #[test]
    fn test_get_meta_has_load_and_store() {
        let m = cache_manifest();
        let meta = m.get_meta("cache", "user");
        assert!(meta.load.is_some());
        assert!(meta.store.is_some());
    }

    #[test]
    fn test_get_meta_leaf_has_state() {
        let m = cache_manifest();
        let meta = m.get_meta("cache", "user.id");
        assert!(meta.state.is_some());
    }

    #[test]
    fn test_get_meta_child_inherits_parent_store() {
        let m = cache_manifest();
        let parent = m.get_meta("cache", "user");
        let child  = m.get_meta("cache", "user.id");
        assert!(child.store.is_some());
        assert_eq!(child.store, parent.store);
    }

    #[test]
    fn test_get_meta_child_overrides_parent_load() {
        let m = cache_manifest();
        let parent = m.get_meta("cache", "user");
        let child  = m.get_meta("cache", "user.tenant_id");
        assert!(child.load.is_some());
        assert_ne!(child.load, parent.load);
    }

    #[test]
    fn test_get_meta_unknown_path_returns_default() {
        let m = cache_manifest();
        let meta = m.get_meta("cache", "nonexistent");
        assert!(meta.load.is_none());
        assert!(meta.store.is_none());
        assert!(meta.state.is_none());
    }

    #[test]
    fn test_get_meta_file_not_loaded_returns_default() {
        let m = Manifest::new();
        let meta = m.get_meta("cache", "user");
        assert!(meta.load.is_none());
    }

    // --- get_client ---

    #[test]
    fn test_get_client_kvs() {
        let m = cache_manifest();
        let meta = m.get_meta("cache", "user");
        let client = m.get_client(meta.store.unwrap());
        assert_eq!(client, super::super::fixed_bits::CLIENT_KVS);
    }

    #[test]
    fn test_get_client_db() {
        let m = cache_manifest();
        let meta = m.get_meta("cache", "user");
        let client = m.get_client(meta.load.unwrap());
        assert_eq!(client, super::super::fixed_bits::CLIENT_DB);
    }

    #[test]
    fn test_get_client_state() {
        let m = cache_manifest();
        let meta = m.get_meta("cache", "user.tenant_id");
        let client = m.get_client(meta.load.unwrap());
        assert_eq!(client, super::super::fixed_bits::CLIENT_STATE);
    }

    // --- build_config ---

    #[test]
    fn test_build_config_contains_client() {
        let m = cache_manifest();
        let meta = m.get_meta("cache", "user");
        let entries = m.build_config(meta.store.unwrap()).unwrap();
        assert!(entries.iter().any(|(k, _)| k == "client"));
    }

    #[test]
    fn test_build_config_connection_is_path() {
        let m = cache_manifest();
        let meta = m.get_meta("cache", "user");
        let entries = m.build_config(meta.load.unwrap()).unwrap();
        let conn = entries.iter().find(|(k, _)| k == "connection");
        assert!(matches!(conn, Some((_, ConfigValue::Path(_)))));
    }

    #[test]
    fn test_build_config_map_is_map_variant() {
        let m = cache_manifest();
        let meta = m.get_meta("cache", "user");
        let entries = m.build_config(meta.load.unwrap()).unwrap();
        let map = entries.iter().find(|(k, _)| k == "map");
        assert!(matches!(map, Some((_, ConfigValue::Map(_)))));
        if let Some((_, ConfigValue::Map(pairs))) = map {
            assert!(!pairs.is_empty());
        }
    }

    #[test]
    fn test_build_config_key_with_template_is_template() {
        let m = cache_manifest();
        let meta = m.get_meta("cache", "user");
        let entries = m.build_config(meta.store.unwrap()).unwrap();
        let key = entries.iter().find(|(k, _)| k == "key");
        assert!(matches!(key, Some((_, ConfigValue::Template(_)))));
    }

    // --- decode_value ---

    #[test]
    fn test_decode_value_single_path() {
        // connection: ${connection.tenant} → Path with segments ["connection", "tenant"]
        let m = cache_manifest();
        let meta = m.get_meta("cache", "user");
        let entries = m.build_config(meta.load.unwrap()).unwrap();
        let conn = entries.iter().find(|(k, _)| k == "connection");
        if let Some((_, ConfigValue::Path(segs))) = conn {
            let key = m.segs_to_key(segs).unwrap();
            assert_eq!(key, "connection.tenant");
        } else {
            panic!("expected Path");
        }
    }

    #[test]
    fn test_decode_value_template_is_template_variant() {
        // key: "user:${session.sso_user_id}" → Template with Literal + Path tokens
        let m = cache_manifest();
        let meta = m.get_meta("cache", "user");
        let entries = m.build_config(meta.store.unwrap()).unwrap();
        let key = entries.iter().find(|(k, _)| k == "key");
        if let Some((_, ConfigValue::Template(tokens))) = key {
            assert!(tokens.iter().any(|t| matches!(t, TemplateToken::Literal(_))));
            assert!(tokens.iter().any(|t| matches!(t, TemplateToken::Path(_))));
        } else {
            panic!("expected Template");
        }
    }
}