fix(backup): restore file and symlink source paths via unified root policy

Regression from 0b10124: the unified inode walker unconditionally called
`read_dir` on the source root, so a regular-file `source_paths` entry
surfaced as `Not a directory (os error 20)`. Concentrate the file-vs-
directory-vs-symlink decision in a new `ResolvedSource` + `RootEmission`
policy resolved once up front, and drive the walker, materializer, and
parent-reuse inversion from that single policy. The walker now re-stats
the root at init, so `EmitRoot` entries carry real filesystem metadata
instead of the previous synthetic `0o755/0/0/0` placeholder.

Author: m3nu

crates/vykar-core/src/commands/backup/mod.rs

@@ -4,6 +4,7 @@ mod commit;
 mod concurrency;
 pub(crate) mod pipeline;
 mod sequential;
+mod source;
 mod walk;
 
 pub(crate) use chunk_process::WorkerChunk;
@@ -20,7 +21,7 @@ use std::sync::Arc;
 
 use crate::limits;
 use crate::platform::fs;
-use crate::repo::file_cache::{FileCache, ParentReuseBuilder, ParentReuseIndex};
+use crate::repo::file_cache::{FileCache, ParentReuseBuilder, ParentReuseIndex, ParentReuseRoot};
 use crate::repo::format::{pack_object_with_context, ObjectType};
 use crate::repo::lock;
 use crate::repo::manifest::SnapshotEntry;
@@ -52,33 +53,6 @@ pub(crate) fn normalize_rel_path(path: String) -> String {
     }
 }
 
-/// Build the multi-path prefix basename and synthetic directory item.
-/// Used when backing up multiple source paths to namespace each source.
-fn build_multi_path_prefix(source_path: &str, source: &std::path::Path) -> (String, Item) {
-    use crate::snapshot::item::ItemType;
-    let base = source
-        .file_name()
-        .map(|n| n.to_string_lossy().to_string())
-        .unwrap_or_else(|| source_path.to_string());
-    let dir_item = Item {
-        path: base.clone(),
-        entry_type: ItemType::Directory,
-        mode: 0o755,
-        uid: 0,
-        gid: 0,
-        user: None,
-        group: None,
-        mtime: 0,
-        atime: None,
-        ctime: None,
-        size: 0,
-        chunks: Vec::new(),
-        link_target: None,
-        xattrs: None,
-    };
-    (base, dir_item)
-}
-
 /// Resolve a cache hit by checking the file cache, falling back to the parent reuse index.
 fn resolve_cache_hit(
     file_cache: &FileCache,
@@ -276,31 +250,11 @@ pub fn run_with_progress(
 
     let multi_path = source_paths.len() > 1;
 
-    // Build walk-root pairs: (original_basename, canonicalized_walk_root).
-    // The walker uses the original basename for snapshot item prefixes, but
-    // canonicalizes the root for abs_path construction (at least on Linux).
-    // The parent reuse builder needs both to reconstruct matching abs_paths.
-    let walk_roots: Vec<(String, String)> = source_paths
-        .iter()
-        .map(|sp| {
-            let p = std::path::Path::new(sp);
-            let basename = p
-                .file_name()
-                .map(|n| n.to_string_lossy().to_string())
-                .unwrap_or_else(|| sp.clone());
-            let walk_root = std::fs::canonicalize(p)
-                .unwrap_or_else(|_| {
-                    if p.is_absolute() {
-                        p.to_path_buf()
-                    } else {
-                        std::env::current_dir().unwrap_or_default().join(p)
-                    }
-                })
-                .to_string_lossy()
-                .to_string();
-            (basename, walk_root)
-        })
-        .collect();
+    // Resolve every configured source up-front: stat, canonicalize, derive
+    // basename + emission policy, and reject duplicate basenames. This runs
+    // BEFORE opening the repo so any source-validation failure short-circuits
+    // with no session registered.
+    let resolved_sources = source::ResolvedSource::resolve_all(source_paths, multi_path)?;
 
     let _nice_guard = match limits::NiceGuard::apply(config.limits.nice) {
         Ok(guard) => guard,
@@ -420,8 +374,10 @@ pub fn run_with_progress(
         }
 
         // Set up read cache + write cache sections for filesystem sources.
-        let canonical_roots: Vec<String> =
-            walk_roots.iter().map(|(_, root)| root.clone()).collect();
+        let canonical_roots: Vec<String> = resolved_sources
+            .iter()
+            .map(|s| s.abs_source_str.clone())
+            .collect();
         let mut parent_reuse_index: Option<ParentReuseIndex> = None;
         if !source_paths.is_empty() {
             let section_valid = repo
@@ -449,7 +405,11 @@ pub fn run_with_progress(
                     .max_by_key(|s| s.time);
                 if let Some(parent_entry) = latest {
                     let parent_name = parent_entry.name.clone();
-                    let mut builder = ParentReuseBuilder::new(walk_roots.clone(), multi_path);
+                    let parent_roots: Vec<ParentReuseRoot> = resolved_sources
+                        .iter()
+                        .map(|s| s.parent_reuse_root())
+                        .collect();
+                    let mut builder = ParentReuseBuilder::new(parent_roots);
                     let stream_result =
                         super::list::for_each_snapshot_item(&mut repo, &parent_name, |item| {
                             builder.push(item);
@@ -536,8 +496,7 @@ pub fn run_with_progress(
                 .min(pipeline_buffer_bytes) as u64;
 
             let pipeline_ctx = pipeline::PipelineCtx {
-                source_paths,
-                multi_path,
+                sources: &resolved_sources,
                 exclude_patterns,
                 exclude_if_present,
                 one_file_system,
@@ -574,13 +533,12 @@ pub fn run_with_progress(
             repo.restore_file_cache(file_cache_snapshot);
             pipeline_result?;
         } else {
-            for source_path in source_paths {
+            for source in &resolved_sources {
                 check_interrupted(shutdown)?;
 
                 sequential::process_source_path(
                     &mut repo,
-                    source_path,
-                    multi_path,
+                    source,
                     exclude_patterns,
                     exclude_if_present,
                     one_file_system,

crates/vykar-core/src/commands/backup/pipeline.rs

@@ -23,6 +23,7 @@ use vykar_types::error::{Result, VykarError};
 use super::chunk_process::classify_chunk;
 use super::commit::process_worker_chunks;
 use super::concurrency::{BudgetGuard, ByteBudget};
+use super::source::ResolvedSource;
 use super::walk::{build_walk_iter, reserve_budget, WalkEntry};
 use super::BackupProgressEvent;
 
@@ -654,8 +655,7 @@ enum PipelineResult {
 /// 20+ individual arguments.
 #[derive(Clone, Copy)]
 pub(crate) struct PipelineCtx<'a> {
-    pub source_paths: &'a [String],
-    pub multi_path: bool,
+    pub sources: &'a [ResolvedSource],
     pub exclude_patterns: &'a [String],
     pub exclude_if_present: &'a [String],
     pub one_file_system: bool,
@@ -699,8 +699,7 @@ pub(crate) fn run_parallel_pipeline(
     progress: &mut Option<&mut dyn FnMut(BackupProgressEvent)>,
 ) -> Result<()> {
     let PipelineCtx {
-        source_paths,
-        multi_path,
+        sources,
         exclude_patterns,
         exclude_if_present,
         one_file_system,
@@ -753,8 +752,7 @@ pub(crate) fn run_parallel_pipeline(
         let walk_result_tx = result_tx.clone();
         s.spawn(move || {
             let walk_iter = build_walk_iter(
-                source_paths,
-                multi_path,
+                sources,
                 exclude_patterns,
                 exclude_if_present,
                 one_file_system,

crates/vykar-core/src/commands/backup/sequential.rs

@@ -22,6 +22,7 @@ use vykar_types::error::{Result, VykarError};
 
 use super::chunk_process::{classify_chunk, WorkerChunk};
 use super::commit::process_worker_chunks;
+use super::source::ResolvedSource;
 use super::walk::{is_soft_io_error, materialize_item, InodeSortedWalk, Materialized, WalkEvent};
 use super::{append_item_to_stream, emit_progress, emit_stats_progress};
 use super::{BackupProgressEvent, FileStatus};
@@ -410,8 +411,7 @@ pub(super) fn process_regular_file_item(
 #[allow(clippy::too_many_arguments)]
 pub(super) fn process_source_path(
     repo: &mut Repository,
-    source_path: &str,
-    multi_path: bool,
+    source: &ResolvedSource,
     exclude_patterns: &[String],
     exclude_if_present: &[String],
     one_file_system: bool,
@@ -436,28 +436,10 @@ pub(super) fn process_source_path(
     emit_progress(
         progress,
         BackupProgressEvent::SourceStarted {
-            source_path: source_path.to_string(),
+            source_path: source.configured.clone(),
         },
     );
 
-    let source = Path::new(source_path);
-
-    // For multi-path mode, derive basename prefix.
-    let prefix = if multi_path {
-        let (base, dir_item) = super::build_multi_path_prefix(source_path, source);
-        append_item_to_stream(
-            repo,
-            item_stream,
-            item_ptrs,
-            &dir_item,
-            items_config,
-            compression,
-        )?;
-        Some(base)
-    } else {
-        None
-    };
-
     let chunk_id_key = *repo.crypto.chunk_id_key();
     let min_chunk_size = repo.config.chunker_params.min_size as u64;
     let mut cross_batch = CrossFileBatch::new();
@@ -469,7 +451,6 @@ pub(super) fn process_source_path(
         one_file_system,
         git_ignore,
     )?;
-    let abs_source = inode_walk.abs_source().to_owned();
 
     for event_result in inode_walk {
         check_interrupted(shutdown)?;
@@ -484,7 +465,7 @@ pub(super) fn process_source_path(
         };
 
         let (mut item, entry_path, metadata_summary) =
-            match materialize_item(walked, &abs_source, &prefix, xattrs_enabled) {
+            match materialize_item(walked, xattrs_enabled) {
                 Ok(Materialized::Entry {
                     item,
                     abs_path,
@@ -688,7 +669,7 @@ pub(super) fn process_source_path(
     emit_progress(
         progress,
         BackupProgressEvent::SourceFinished {
-            source_path: source_path.to_string(),
+            source_path: source.configured.clone(),
         },
     );