@ape-egg/vibe 1.6.0 → 1.7.0

package/CHANGELOG.md

@@ -1,5 +1,66 @@
 # Changelog
 
+## [1.7.0] - 2026-02-19
+
+### Fixed
+
+- **Watch mode stale component cache** - Incremental recompilation no longer uses stale component content
+  - Component cache is cleared before every recompile trigger, ensuring components are always re-read from disk
+  - Component cache and parser element cache are also invalidated immediately when a component file changes
+  - Fixes corrupted output (old event handlers, wrong attributes) that appeared on every watch-mode save after the first
+
+- **Custom element transform — nested hyphenated tags** (`elementsAsIs: false`)
+  - `<accordion-content>` inside `<accordion>` previously produced `<div class="accordion" -content>` due to the `<accordion>` regex partially matching the longer tag name
+  - Fixed by requiring whitespace or end-of-tag immediately after the tag name in the opening tag regex
+  - Tags are now also sorted by descending length so more specific names (e.g. `accordion-content`) are always processed before their prefixes (`accordion`)
+
+- **Custom element transform — existing class preserved** (`elementsAsIs: false`)
+  - `<crow class="i-should-preserve">` previously compiled to `<div class="crow">`, discarding the original class
+  - Existing `class="..."` is now merged: result is `<div class="crow i-should-preserve">`
+
+- **`elementsAsIs` config respected in dependency scanning**
+  - `fetch_components_for_files` and `fetch_all_components` were hardcoded to `elements_as_is: false`, ignoring the project config
+  - Both functions now correctly read `self.config.elements_as_is` and `self.config.reserved_elements`
+
+- **`vibe-dehydrate` protected during manifest stamping**
+  - Content inside `<template vibe-dehydrate>` was incorrectly processed during value stamping
+  - Dehydrated regions are now extracted before processing and restored afterwards
+
+- **Conditional evaluation errors handled gracefully**
+  - A failed `<!-- if ... -->` expression (undefined variable, syntax error) now defaults to `false` instead of crashing
+
+### Changed
+
+- **Lifecycle event API** — `vibe()` now returns an object that supports `.on(event, callback)` before boot completes
+  - `$.on('ready', cb)` — fires once after all components load and initial processing completes
+  - `$.on('afterUpdate', cb)` — fires on every state change
+  - `$.on('afterDomMutation', cb)` — fires after every DOM mutation batch
+  - Listeners registered before boot are queued and replayed once the runtime is ready
+
+- **Component `onComplete` timing** — deferred via `queueMicrotask` to give user code a chance to register listeners before the ready callback fires
+
+- **Iteration performance** — `cloneTreeNode` avoids spread operator; `nameBindings` now correctly carried through cloned iteration trees
+
+---
+
+## [1.6.1] - 2026-02-12
+
+### Fixed
+
+- **Compiler output directory handling** - Fixed duplicate file generation in output
+  - Compiler now properly handles source and output paths without preserving source directory structure
+  - Files from `./src` are now correctly written to root of output directory (e.g., `compiled/index.html`) instead of `compiled/src/index.html`
+  - Canonicalized source path for reliable comparison and path stripping
+  - Updated all processing functions to use canonical source path for relative path calculation
+
+- **Manifest detection improvements** - Better handling of directory URLs and extensionless paths
+  - Directory URLs now normalized: `/compiled/` → `/compiled/index.html`
+  - Extensionless URLs now normalized: `/compiled/mypage` → `/compiled/mypage.html`
+  - Fixes manifest detection when visiting pages without explicit `.html` extension
+  - Enables proper hyperspeed loading for directory index pages
+
+---
+
 ## [1.6.0] - 2026-02-12
 
 ### Added
@@ -522,7 +583,7 @@
 - **Iteration**: `<!-- each items as item, i -->` with efficient diffing
 - **Nested iteration**: `<!-- each category.items as item -->`
 - **Conditionals**: `<!-- if condition -->...<!-- else -->...<!-- /if -->`
-- **Dehydrate**: `<div dehydrate>` to skip reactive processing
+- **Dehydrate**: `<div vibe-dehydrate>` to skip reactive processing
 - **Expression evaluation**: `@[count * 2]`, `@[firstName + ' ' + lastName]`
 
 ### Performance

package/README.md

@@ -1,13 +1,15 @@
 # Vibe
 
-A runtime-first reactive library.
+**Version 1.6.0 (Alpha)** — A runtime-first reactive framework with optional compilation.
 
-No virtual DOM. No build step. Just modern JavaScript.
+No virtual DOM. No build step required. Just modern JavaScript. When you need production optimizations, add the optional Rust-based compiler.
 
 ```bash
 npm install @ape-egg/vibe
 ```
 
+**Status:** Functional and ready to use, but expect bugs and breaking changes daily until stable. Use in production at your own risk.
+
 ---
 
 ## Vibe Runtime
@@ -21,9 +23,9 @@ The core reactive runtime. Works directly in the browser without any build tools
   <head>
     <link rel="stylesheet" href="./node_modules/@ape-egg/vibe/vibe.css" />
     <script type="module">
-      import state from './node_modules/@ape-egg/vibe/runtime/index.js';
-      // Attaches to element with attribute "vibe" by default
-      window.$ = state({ name: 'World', count: 0 });
+      import vibe from './node_modules/@ape-egg/vibe/index.js';
+
+      vibe({ name: 'World', count: 0 });
     </script>
   </head>
   <body vibe-fouc>
@@ -121,7 +123,7 @@ Runtime component loading with props and slots:
 Skip reactive processing for an element:
 
 ```html
-<code dehydrate>@[this] displays literally</code>
+<code vibe-dehydrate>@[this] displays literally</code>
 ```
 
 ### Reserved Words & Gotchas
@@ -131,28 +133,35 @@ Vibe uses specific patterns and keywords that have special meaning. Avoid using
 #### Classes & Attributes
 
 - **`vibe-fouc`** — Class or attribute for FOUC (Flash of Unstyled Content) prevention. Automatically removed after hydration completes.
+
   ```html
-  <body vibe-fouc>  <!-- or class="vibe-fouc" -->
+  <body vibe-fouc>
+    <!-- or class="vibe-fouc" -->
+  </body>
   ```
 
 - **`vibe-dehydrate`** — Class or attribute to skip reactive processing. Useful for displaying literal `@[...]` syntax in documentation.
   ```html
-  <code vibe-dehydrate>@[variable]</code>  <!-- or class="vibe-dehydrate" -->
+  <code vibe-dehydrate>@[variable]</code>
+  <!-- or class="vibe-dehydrate" -->
   ```
 
 #### Element Names & Classes
 
 - **`<component>`** — Element name for component system. Used with `src` attribute for runtime component loading, or as a wrapper for inlined components.
+
   ```html
   <component src="/path/to/component.html"></component>
   ```
 
 - **`class="component"`** — Alternative syntax for components using standard HTML elements. Useful for HTML validation or accessibility.
+
   ```html
   <div class="component" src="/path/to/component.html"></div>
   ```
 
 - **`<slot>`** — Element name for component content injection. Gets replaced with content passed between component tags.
+
   ```html
   <!-- In component file -->
   <slot></slot>
@@ -166,6 +175,7 @@ Vibe uses specific patterns and keywords that have special meaning. Avoid using
 #### Comment Syntax
 
 - **`<!-- each -->`** / **`<!-- /each -->`** — Iteration block markers.
+
   ```html
   <!-- each items as item -->
   <!-- /each -->
@@ -188,9 +198,10 @@ Vibe uses specific patterns and keywords that have special meaning. Avoid using
 #### Global Properties
 
 - **`window.$`** — Global reactive state object. All reactive data should be accessed through this.
+
   ```javascript
   window.$ = state({ count: 0 });
-  $.count++;  // Triggers reactive updates
+  $.count++; // Triggers reactive updates
   ```
 
 - **`window.__vibeManifest`** — Internal manifest data. Used by the compiler for optimization. Don't modify.
@@ -206,13 +217,14 @@ Vibe uses specific patterns and keywords that have special meaning. Avoid using
 - **`vibe:ready`** — Custom event fired when Vibe completes initial hydration.
   ```javascript
   document.addEventListener('vibe:ready', () => {
-    console.log('Vibe is ready');
+    console.info('Vibe is ready');
   });
   ```
 
 #### Special Attribute Meanings
 
 - **`src`** on **`<component>`** or **`<div class="component">`** — Triggers runtime component fetching. Components without `src` are treated as inline wrappers.
+
   ```html
   <!-- Both work the same way -->
   <component src="/components/card.html"></component>
@@ -246,7 +258,7 @@ No need for immutable update patterns or spread operators. Just mutate and Vibe
 
 ## Vibe Compiler
 
-Optional build step for production optimization. The compiler processes HTML files, inlines components, and handles assets while preserving directory structure.
+Optional build step for production optimization. The compiler provides component inlining, iteration optimization, watch mode, and hydration manifests while preserving directory structure.
 
 ### Installation
 
@@ -264,18 +276,27 @@ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
 # Initialize config in package.json
 bunx vibe compile --init
 
-# Compile
+# Basic compilation
 bunx vibe compile
+# or shorthand
+bunx vibe c
+
+# Watch mode (incremental compilation)
+bunx vibe compile --watch
+
+# Production build
+bunx vibe compile --minify --source-maps
 
 # With options
 bunx vibe compile --verbose             # Step-by-step logging
 bunx vibe compile --minify              # Minify output
-bunx vibe compile --accessibility       # Transform custom tags to divs
+bunx vibe compile --elements-as-is      # Keep custom elements as-is
 bunx vibe compile --validate            # Validate HTML syntax
-bunx vibe compile --create-manifest     # Generate hydration manifest
 bunx vibe compile --source-maps         # Generate source maps
 bunx vibe compile --node-modules-as-is  # Copy node_modules as-is
-bunx vibe compile --watch               # Watch mode (future)
+bunx vibe compile --components-as-is    # Skip component inlining
+bunx vibe compile --runtime-as-is       # Skip manifest generation
+bunx vibe compile --iterations-as-is    # Skip iteration optimization
 ```
 
 Or via npm scripts:
@@ -283,13 +304,14 @@ Or via npm scripts:
 ```json
 {
   "scripts": {
-    "vibe:compile": "vibe compile",
-    "vibe:compile:init": "vibe compile --init"
+    "compile": "vibe compile",
+    "compile:watch": "vibe compile --watch",
+    "compile:prod": "vibe compile --minify --source-maps"
   }
 }
 ```
 
-Then run with `bun vibe:compile` or `npm run vibe:compile`.
+Then run with `npm run compile` or `bun compile`.
 
 ### Configuration
 
@@ -304,13 +326,26 @@ Add to your `package.json`:
     "pages": "pages",
     "assets": "assets",
     "minify": false,
-    "accessibility": false,
-    "excludeTags": [],
-    "nodeModulesAsIs": false
+    "elementsAsIs": false,
+    "reservedElements": [],
+    "sourceMaps": false,
+    "validate": false,
+    "nodeModulesAsIs": false,
+    "componentsAsIs": false,
+    "runtimeAsIs": false,
+    "iterationsAsIs": false
   }
 }
 ```
 
+**Key Options:**
+
+- `elementsAsIs: false` — Transform custom elements to divs (default)
+- `reservedElements: []` — Additional element names to reserve (appends to built-in HTML5 elements + "component")
+- `componentsAsIs: false` — Inline components (default) or keep separate for runtime
+- `iterationsAsIs: false` — Optimize iterations (default) or use runtime rendering
+- `runtimeAsIs: false` — Generate manifest (default) or skip for runtime-only
+
 **Defaults** (when no config):
 
 - `source`: `./`
@@ -351,6 +386,67 @@ Auto-detects based on lockfiles: `bun.lockb`, `pnpm-lock.yaml`, `yarn.lock`, `pa
 **Opt-out:**
 Set `nodeModulesAsIs: true` in config or use `--node-modules-as-is` flag to copy node_modules as-is.
 
+### Watch Mode
+
+Watch mode enables incremental compilation with intelligent dependency tracking:
+
+```bash
+bunx vibe compile --watch
+```
+
+Features:
+
+- **Incremental builds** — Only recompiles changed files (~100ms)
+- **Dependency tracking** — Changes to components trigger recompilation of pages using them
+- **Debounced** — 300ms debounce prevents excessive compilation during rapid changes
+- **Delta output** — First compile shows full output, subsequent compiles show only changes
+
+### Component System
+
+Components are automatically inlined during compilation with full support for props and slots:
+
+```html
+<!-- Source: components/card.html -->
+<div class="card">
+  <h2>@[title]</h2>
+  <p>@[description]</p>
+  <slot></slot>
+</div>
+
+<!-- Usage in page -->
+<component src="/components/card.html" title="My Card" description="Card description">
+  <p>Slot content</p>
+</component>
+
+<!-- Compiled output -->
+<component>
+  <div class="card">
+    <h2>My Card</h2>
+    <p>Card description</p>
+    <p>Slot content</p>
+  </div>
+</component>
+```
+
+**Custom element syntax:** Components can also use custom element syntax (e.g., `<card>` → auto-converts to `<component src="/components/card.html">`).
+
+**Opt-out:** Set `componentsAsIs: true` to keep components as separate files for runtime loading.
+
+### Iteration Optimization
+
+The compiler generates optimized batch functions for `<!-- each -->` loops, providing 2-3x faster rendering:
+
+```html
+<!-- Source -->
+<!-- each items as item, index -->
+<li>@[index]: @[item]</li>
+<!-- /each -->
+
+<!-- Compiled to optimized batch function -->
+```
+
+**Opt-out:** Set `iterationsAsIs: true` to use runtime rendering for all iterations.
+
 ### Output Structure
 
 Mirrors source structure:
@@ -368,9 +464,9 @@ src/                     compiled/
         └── vibe/               └── vibe/
 ```
 
-### Accessibility Mode
+### Element Transformation
 
-`--accessibility` transforms custom HTML elements to divs with classes:
+By default (`elementsAsIs: false`), custom HTML elements are transformed to divs with classes for better HTML validity:
 
 ```html
 <!-- input -->
@@ -380,7 +476,23 @@ src/                     compiled/
 <div class="counter-header">Count</div>
 ```
 
-Exclude specific tags (e.g., web components) via `excludeTags` config.
+Set `elementsAsIs: true` or use `--elements-as-is` flag to keep custom elements unchanged.
+
+**Note:** The `<component>` element is a framework element and is never transformed.
+
+### Reserved Element Names
+
+The compiler validates component filenames against reserved element names (all HTML5 elements + "component" + your custom list). This prevents confusing bugs where components share names with HTML elements.
+
+```json
+{
+  "vibe-compiler": {
+    "reservedElements": ["my-custom-element", "another-reserved-name"]
+  }
+}
+```
+
+**Case-sensitive validation:** `nav.html` conflicts with `<nav>` and will error, but `Nav.html` is allowed.
 
 ### Building Native Binaries
 

package/boot.js

@@ -2,6 +2,7 @@
 // Used by both index.js (global state) and component.js (component state)
 
 import main from './runtime/index.js';
+import { getPendingListeners } from './index.js';
 
 let bootQueued = false;
 let booted = false;
@@ -39,6 +40,16 @@ export const boot = () => {
   // Boot with merged state
   window.$ = main(mergedState, config, targetSelector);
 
+  // Apply pending listeners from vibe instance
+  const pendingListeners = getPendingListeners();
+  if (pendingListeners) {
+    Object.keys(pendingListeners).forEach(event => {
+      pendingListeners[event].forEach(callback => {
+        window.$.on(event, callback);
+      });
+    });
+  }
+
   return window.$;
 };
 

package/compiler/src/Cargo.lock

@@ -2061,7 +2061,7 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
 name = "vibe-compiler"
-version = "0.1.0"
+version = "1.7.0"
 dependencies = [
  "clap",
  "colored",

package/compiler/src/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vibe-compiler"
-version = "0.1.0"
+version = "1.7.0"
 edition = "2021"
 description = "Vibe framework compiler - compiles Vibe source files into optimized output"
 authors = ["Kim Korte"]

package/compiler/src/compiler/compile.rs

@@ -40,9 +40,8 @@ const MIRROR_EXTENSIONS: &[&str] = &[
 
 // Files and directories to skip when walking source (supports glob patterns)
 // Note: Output directory is checked dynamically (not hardcoded here)
+// Note: Dotfiles are handled by starts_with('.') check in should_skip_path()
 pub const SKIP_FILES: &[&str] = &[
-    ".git",
-    ".claude",
     "target",            // Rust build artifacts
     "tests",             // Test files
     "test-results",
@@ -56,6 +55,11 @@ pub const SKIP_FILES: &[&str] = &[
 
 /// Check if a path should be skipped based on SKIP_FILES patterns
 pub fn should_skip_path(path: &Path, name: &str) -> bool {
+    // Check if name starts with dot (dotfiles/directories)
+    if name.starts_with('.') {
+        return true;
+    }
+
     // Check exact name match (for directories and simple filenames)
     if SKIP_FILES.contains(&name) {
         return true;
@@ -433,6 +437,11 @@ impl Compiler {
         }
     }
 
+    /// Clear all cached component content (forces re-fetch on next compile)
+    pub fn clear_component_cache(&mut self) {
+        self.component_cache.clear();
+    }
+
     pub fn compile(&mut self) -> Result<CompileStats, CompileError> {
         let mut stats = CompileStats {
             files_compiled: 0,
@@ -492,6 +501,19 @@ impl Compiler {
             }
         }
 
+        // Clean output directory if not in no-clean mode
+        if !self.config.no_clean && self.config.output.exists() {
+            if self.verbose {
+                println!("  Cleaning output directory: {}", self.config.output.display());
+            }
+            fs::remove_dir_all(&self.config.output).map_err(|e| {
+                CompileError::WriteError {
+                    path: self.config.output.display().to_string(),
+                    source: e,
+                }
+            })?;
+        }
+
         // Create output directory
         if !self.config.output.exists() {
             fs::create_dir_all(&self.config.output).map_err(|_| {
@@ -502,18 +524,20 @@ impl Compiler {
             }
         }
 
-        // Canonicalize output path once for reliable comparison
+        // Canonicalize both output and source paths for reliable comparison
         let canonical_output = self.config.output.canonicalize()
             .unwrap_or_else(|_| self.config.output.clone());
+        let canonical_source = self.config.source.canonicalize()
+            .unwrap_or_else(|_| self.config.source.clone());
 
         // Track compile and copy times separately
         let compile_start = Instant::now();
 
         // Process all HTML files in source (excluding components directory)
-        self.process_directory_html_only(&self.config.source.clone(), &parser, "", &canonical_output, &mut stats)?;
+        self.process_directory_html_only(&canonical_source, &parser, "", &canonical_output, &canonical_source, &mut stats)?;
 
         // Process source directory for assets (CSS, JS, images, etc.)
-        self.process_directory_assets_only(&self.config.source.clone(), "", &canonical_output, &mut stats)?;
+        self.process_directory_assets_only(&canonical_source, "", &canonical_output, &canonical_source, &mut stats)?;
 
         let process_time = compile_start.elapsed();
 
@@ -798,10 +822,9 @@ impl Compiler {
         // Stamp values (pre-render) AFTER building manifest
         // When components_as_is is true, skip stamping inside component elements (runtime will handle them)
         let stamper = ValueStamper::new(&state, components_as_is)?;
-        let mut pre_rendered = stamper.stamp_html(html.to_string())?;
+        let pre_rendered = stamper.stamp_html(html.to_string())?;
 
-        // Remove FOUC prevention since HTML is pre-rendered
-        pre_rendered = remove_fouc_prevention(pre_rendered);
+        // Note: FOUC removal happens in compile_html_file(), not here
 
         // Write pre-rendered HTML
         fs::write(html_path, pre_rendered)
@@ -906,6 +929,7 @@ impl Compiler {
         parser: &HtmlParser,
         relative_path: &str,
         canonical_output: &Path,
+        canonical_source: &Path,
         stats: &mut CompileStats,
     ) -> Result<(), CompileError> {
         let entries = fs::read_dir(dir).map_err(|e| CompileError::ReadError {
@@ -941,7 +965,7 @@ impl Compiler {
                     format!("{}/{}", relative_path, file_name)
                 };
 
-                self.process_directory_html_only(&path, parser, &new_relative, canonical_output, stats)?;
+                self.process_directory_html_only(&path, parser, &new_relative, canonical_output, canonical_source, stats)?;
             } else if path.extension().and_then(|e| e.to_str()) == Some("html") {
                 let (internal, external, component_srcs) = self.compile_html_file(&path, parser, relative_path)?;
                 stats.files_compiled += 1;
@@ -962,7 +986,7 @@ impl Compiler {
                 };
 
                 if let Some(ref mut logger) = self.logger {
-                    logger.log(&path, FileOperation::Compiled, &self.config.source);
+                    logger.log(&path, FileOperation::Compiled, canonical_source);
 
                     // Log each component occurrence (for counting)
                     if let Some(all_srcs) = all_srcs {
@@ -990,6 +1014,7 @@ impl Compiler {
         dir: &Path,
         relative_path: &str,
         canonical_output: &Path,
+        canonical_source: &Path,
         stats: &mut CompileStats,
     ) -> Result<(), CompileError> {
         let entries = fs::read_dir(dir).map_err(|e| CompileError::ReadError {
@@ -1027,7 +1052,7 @@ impl Compiler {
                         } else {
                             format!("{}/{}", relative_path, file_name)
                         };
-                        self.copy_directory(&path, &new_relative, stats)?;
+                        self.copy_directory(&path, &new_relative, canonical_source, stats)?;
                     }
                     // Skip further processing (don't recurse into components)
                     continue;
@@ -1040,7 +1065,7 @@ impl Compiler {
                     format!("{}/{}", relative_path, file_name)
                 };
 
-                self.process_directory_assets_only(&path, &new_relative, canonical_output, stats)?;
+                self.process_directory_assets_only(&path, &new_relative, canonical_output, canonical_source, stats)?;
             } else if let Some(ext) = path.extension().and_then(|e| e.to_str()) {
                 // Skip files matching skip patterns
                 if should_skip_path(&path, file_name) {
@@ -1052,7 +1077,7 @@ impl Compiler {
                     self.copy_file(&path, relative_path)?;
                     stats.files_copied += 1;
                     if let Some(ref mut logger) = self.logger {
-                        logger.log(&path, FileOperation::Copied, &self.config.source);
+                        logger.log(&path, FileOperation::Copied, canonical_source);
                     }
                 }
             }
@@ -1095,12 +1120,17 @@ impl Compiler {
         );
 
         // Minify if requested
-        let output = if self.config.minify {
+        let mut output = if self.config.minify {
             minify_html(&processed)
         } else {
             processed
         };
 
+        // Remove FOUC prevention unless fouc_as_is is enabled
+        if !self.config.fouc_as_is {
+            output = remove_fouc_prevention(output);
+        }
+
         // Write to output
         let output_path = self.get_output_path(path, relative_path)?;
         fs::write(&output_path, output).map_err(|e| CompileError::WriteError {
@@ -1208,8 +1238,8 @@ impl Compiler {
             // Transform custom tags to <component> tags
             let transformed = parser.process_html(
                 &content,
-                false, // elements_as_is
-                &[], // reserved_elements
+                self.config.elements_as_is,
+                &self.config.reserved_elements,
                 true, // components_as_is (don't inline, just transform)
                 &self.config.components,
             );
@@ -1245,8 +1275,8 @@ impl Compiler {
             // Transform custom tags to <component> tags
             let transformed = parser.process_html(
                 &content,
-                false, // elements_as_is
-                &[], // reserved_elements
+                self.config.elements_as_is,
+                &self.config.reserved_elements,
                 true, // components_as_is (don't inline, just transform)
                 &self.config.components,
             );
@@ -1459,8 +1489,8 @@ impl Compiler {
             let file_name = entry.file_name();
             let file_name_str = file_name.to_string_lossy();
 
-            // Skip hidden files and specific directories/patterns
-            if file_name_str.starts_with('.') || should_skip_path(&path, &file_name_str) {
+            // Skip specific directories/patterns (includes dotfiles via SKIP_FILES)
+            if should_skip_path(&path, &file_name_str) {
                 continue;
             }
 
@@ -1523,6 +1553,7 @@ impl Compiler {
         &mut self,
         dir: &Path,
         relative_path: &str,
+        canonical_source: &Path,
         stats: &mut CompileStats,
     ) -> Result<(), CompileError> {
         let entries = fs::read_dir(dir).map_err(|e| CompileError::ReadError {
@@ -1541,12 +1572,12 @@ impl Compiler {
 
             if path.is_dir() {
                 let new_relative = format!("{}/{}", relative_path, file_name);
-                self.copy_directory(&path, &new_relative, stats)?;
+                self.copy_directory(&path, &new_relative, canonical_source, stats)?;
             } else {
                 self.copy_file(&path, relative_path)?;
                 stats.files_copied += 1;
                 if let Some(ref mut logger) = self.logger {
-                    logger.log(&path, FileOperation::Copied, &self.config.source);
+                    logger.log(&path, FileOperation::Copied, canonical_source);
                 }
             }
         }