Method list_vault_entries

atomic-core/src/pristine/txn/read.rs:844–894

(
        &self,
        prefix: &str,
        entry_type_filter: Option<VaultEntryType>,
    )

    }

    fn list_vault_entries(
        &self,
        prefix: &str,
        entry_type_filter: Option<VaultEntryType>,
    ) -> PristineResult<Vec<VaultEntryMeta>> {
        let table = match self.txn.open_table(VAULT_ENTRIES) {
            Ok(table) => table,
            Err(redb::TableError::TableDoesNotExist(_)) => return Ok(Vec::new()),
            Err(e) => return Err(PristineError::from(e)),
        };

        let mut results = Vec::new();

        let iter = if prefix.is_empty() {
            table.iter()?
        } else {
            table.range(prefix..)?
        };

        for item in iter {
            let (key, value) = item?;
            let key_str = key.value();

            // Stop iterating once we pass the prefix range
            if !prefix.is_empty() && !key_str.starts_with(prefix) {
                break;
            }

            let entry: VaultEntry =
                postcard::from_bytes(value.value()).map_err(|e| PristineError::Serialization {
                    message: format!("failed to deserialize VaultEntry at '{}': {}", key_str, e),
                })?;

            // Apply type filter
            if let Some(ref filter) = entry_type_filter {
                if entry.entry_type != *filter {
                    continue;
                }
            }

            results.push(VaultEntryMeta {
                path: key_str.to_string(),
                entry_type: entry.entry_type,
                content_hash: entry.content_hash,
                content_size: entry.content_bytes.len(),
                updated_at: entry.updated_at,
            });
        }

        Ok(results)
    }

    fn get_vault_manifest(&self) -> PristineResult<VaultManifest> {
        let table = match self.txn.open_table(VAULT_MANIFEST) {