@mdfriday/foundry 26.3.4 → 26.3.6

package/dist/cli.js

@@ -631,11 +631,13 @@ var init_workspace = __esm({
       metadata;
       projects;
       authentication;
-      constructor(rootPath, metadata, projects, authentication) {
+      fileSystemRepo;
+      constructor(rootPath, metadata, projects, authentication, fileSystemRepo) {
         this.rootPath = rootPath;
         this.metadata = metadata;
         this.projects = projects;
         this.authentication = authentication;
+        this.fileSystemRepo = fileSystemRepo;
       }
       // ============================================================================
       // Basic Getters
@@ -814,14 +816,16 @@ var init_workspace = __esm({
        * Get configuration value by key (supports nested keys with dot notation)
        */
       async getConfig(key2) {
-        const fs13 = await import("fs/promises");
+        if (!this.fileSystemRepo) {
+          throw new Error("FileSystemRepository is required for config operations");
+        }
         const configPath = this.getConfigPath();
         try {
-          const content = await fs13.readFile(configPath, "utf-8");
+          const content = await this.fileSystemRepo.readFile(configPath, "utf-8");
           const config = JSON.parse(content);
           return this.getNestedValue(config, key2);
         } catch (error) {
-          if (error.code === "ENOENT") {
+          if (error.message?.includes("Cannot access path")) {
             return void 0;
           }
           throw error;
@@ -831,13 +835,15 @@ var init_workspace = __esm({
        * Get all workspace configuration
        */
       async getAllConfig() {
-        const fs13 = await import("fs/promises");
+        if (!this.fileSystemRepo) {
+          throw new Error("FileSystemRepository is required for config operations");
+        }
         const configPath = this.getConfigPath();
         try {
-          const content = await fs13.readFile(configPath, "utf-8");
+          const content = await this.fileSystemRepo.readFile(configPath, "utf-8");
           return JSON.parse(content);
         } catch (error) {
-          if (error.code === "ENOENT") {
+          if (error.message?.includes("Cannot access path")) {
             return {};
           }
           throw error;
@@ -847,40 +853,44 @@ var init_workspace = __esm({
        * Set configuration value (supports nested keys with dot notation)
        */
       async setConfig(key2, value) {
-        const fs13 = await import("fs/promises");
+        if (!this.fileSystemRepo) {
+          throw new Error("FileSystemRepository is required for config operations");
+        }
         const configPath = this.getConfigPath();
         const configDir = import_path.default.dirname(configPath);
-        await fs13.mkdir(configDir, { recursive: true });
+        await this.fileSystemRepo.createDirectory(configDir, true);
         let config = {};
         try {
-          const content = await fs13.readFile(configPath, "utf-8");
+          const content = await this.fileSystemRepo.readFile(configPath, "utf-8");
           config = JSON.parse(content);
         } catch (error) {
-          if (error.code !== "ENOENT") {
+          if (!error.message?.includes("Cannot access path")) {
             throw error;
           }
         }
         this.setNestedValue(config, key2, value);
-        await fs13.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+        await this.fileSystemRepo.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
         log.debug(`Workspace config updated: ${key2}`, { workspaceId: this.getId() });
       }
       /**
        * Unset configuration value (supports nested keys with dot notation)
        */
       async unsetConfig(key2) {
-        const fs13 = await import("fs/promises");
+        if (!this.fileSystemRepo) {
+          throw new Error("FileSystemRepository is required for config operations");
+        }
         const configPath = this.getConfigPath();
         try {
-          const content = await fs13.readFile(configPath, "utf-8");
+          const content = await this.fileSystemRepo.readFile(configPath, "utf-8");
           const config = JSON.parse(content);
           const deleted = this.deleteNestedValue(config, key2);
           if (deleted) {
-            await fs13.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+            await this.fileSystemRepo.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
             log.debug(`Workspace config deleted: ${key2}`, { workspaceId: this.getId() });
           }
           return deleted;
         } catch (error) {
-          if (error.code === "ENOENT") {
+          if (error.message?.includes("Cannot access path")) {
             return false;
           }
           throw error;
@@ -1309,6 +1319,24 @@ var init_project = __esm({
       isLinkedProject() {
         return this.hasSourceLinks();
       }
+      /**
+       * 获取所有链接的源路径（包括 fileLink 和 contentLinks）
+       * Returns absolute paths to original source files/folders
+       */
+      getLinkDirs() {
+        const linkDirs = [];
+        const fileLink = this.getFileLink();
+        if (fileLink) {
+          linkDirs.push(fileLink.sourcePath);
+        }
+        const contentLinks = this.getContentLinks();
+        for (const link of contentLinks) {
+          if (!linkDirs.includes(link.sourcePath)) {
+            linkDirs.push(link.sourcePath);
+          }
+        }
+        return linkDirs;
+      }
     };
   }
 });
@@ -3088,7 +3116,13 @@ var init_workspace_factory = __esm({
         }
         const hasAuthFile = await this.checkAuthFile(absolutePath);
         const authentication = new Authentication(absolutePath, hasAuthFile);
-        const workspace = new Workspace(absolutePath, metadata, projects, authentication);
+        const workspace = new Workspace(
+          absolutePath,
+          metadata,
+          projects,
+          authentication,
+          this.fileSystemRepo || void 0
+        );
         log5.info("Workspace loaded", {
           workspaceId: workspace.getId(),
           name: workspace.getName(),
@@ -3100,10 +3134,12 @@ var init_workspace_factory = __esm({
        * Check if auth file exists
        */
       async checkAuthFile(workspacePath) {
+        if (!this.fileSystemRepo) {
+          return false;
+        }
         const authPath = import_path3.default.join(workspacePath, ".mdfriday", "auth-token.json");
-        const fs13 = await import("fs/promises");
         try {
-          await fs13.access(authPath);
+          await this.fileSystemRepo.access(authPath);
           return true;
         } catch {
           return false;
@@ -3151,7 +3187,8 @@ var init_workspace_factory = __esm({
           absolutePath,
           metadata,
           /* @__PURE__ */ new Map(),
-          authentication
+          authentication,
+          this.fileSystemRepo || void 0
         );
         log5.info("Workspace created", {
           workspaceId: workspace.getId(),
@@ -3577,10 +3614,12 @@ var init_workspace_factory = __esm({
           outputDir
         );
         if (snapshotName && snapshotName !== metadata.id) {
+          if (!this.fileSystemRepo) {
+            throw new Error("FileSystemRepository is required to update snapshot metadata");
+          }
           metadata.name = snapshotName;
           const metadataPath = import_path3.default.join(project.getPath(), ".mdfriday", "snapshots", `${metadata.id}.json`);
-          const fs13 = await import("fs/promises");
-          await fs13.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+          await this.fileSystemRepo.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
         }
         log5.info("Snapshot created", { snapshotId, size: metadata.size, fileCount: metadata.fileCount });
         return metadata;
@@ -3625,12 +3664,15 @@ var init_workspace_factory = __esm({
       createIdentityStorage(workspace) {
         const workspacePath = workspace.getPath();
         const authentication = workspace.getAuthentication();
+        const fsRepo = this.fileSystemRepo;
+        if (!fsRepo) {
+          throw new Error("FileSystemRepository is required for identity storage");
+        }
         return {
           // 新方法：合并存储
           async saveUserData(data) {
             const userDataPath = import_path3.default.join(workspacePath, ".mdfriday", "user-data.json");
-            const fs13 = await import("fs/promises");
-            await fs13.mkdir(import_path3.default.dirname(userDataPath), { recursive: true });
+            await fsRepo.createDirectory(import_path3.default.dirname(userDataPath), true);
             const jsonData = {
               serverConfig: data.serverConfig.toJSON()
             };
@@ -3644,13 +3686,12 @@ var init_workspace_factory = __esm({
             if (data.email) {
               jsonData.email = data.email;
             }
-            await fs13.writeFile(userDataPath, JSON.stringify(jsonData, null, 2));
+            await fsRepo.writeFile(userDataPath, JSON.stringify(jsonData, null, 2));
           },
           async loadUserData() {
             const userDataPath = import_path3.default.join(workspacePath, ".mdfriday", "user-data.json");
-            const fs13 = await import("fs/promises");
             try {
-              const content = await fs13.readFile(userDataPath, "utf-8");
+              const content = await fsRepo.readFile(userDataPath, "utf-8");
               const data = JSON.parse(content);
               const { Token: Token3, ServerConfig: ServerConfig2, License: License2 } = await Promise.resolve().then(() => (init_identity(), identity_exports));
               const result = {};
@@ -3679,9 +3720,8 @@ var init_workspace_factory = __esm({
           },
           async clearUserData() {
             const userDataPath = import_path3.default.join(workspacePath, ".mdfriday", "user-data.json");
-            const fs13 = await import("fs/promises");
             try {
-              await fs13.unlink(userDataPath);
+              await fsRepo.unlink(userDataPath);
             } catch {
             }
             authentication.markAuthDeleted();
@@ -3689,9 +3729,8 @@ var init_workspace_factory = __esm({
           // 保留旧方法以向后兼容
           async saveToken(token) {
             const authPath = import_path3.default.join(workspacePath, ".mdfriday", "auth-token.json");
-            const fs13 = await import("fs/promises");
-            await fs13.mkdir(import_path3.default.dirname(authPath), { recursive: true });
-            await fs13.writeFile(authPath, JSON.stringify(token.toJSON(), null, 2));
+            await fsRepo.createDirectory(import_path3.default.dirname(authPath), true);
+            await fsRepo.writeFile(authPath, JSON.stringify(token.toJSON(), null, 2));
             authentication.markAuthExists();
           },
           async loadToken() {
@@ -3700,9 +3739,8 @@ var init_workspace_factory = __esm({
               return userData.token;
             }
             const authPath = import_path3.default.join(workspacePath, ".mdfriday", "auth-token.json");
-            const fs13 = await import("fs/promises");
             try {
-              const content = await fs13.readFile(authPath, "utf-8");
+              const content = await fsRepo.readFile(authPath, "utf-8");
               const data = JSON.parse(content);
               const { Token: Token3 } = await Promise.resolve().then(() => (init_identity(), identity_exports));
               return Token3.create(data.token, data.expiresAt);
@@ -3712,18 +3750,16 @@ var init_workspace_factory = __esm({
           },
           async clearToken() {
             const authPath = import_path3.default.join(workspacePath, ".mdfriday", "auth-token.json");
-            const fs13 = await import("fs/promises");
             try {
-              await fs13.unlink(authPath);
+              await fsRepo.unlink(authPath);
             } catch {
             }
             authentication.markAuthDeleted();
           },
           async saveServerConfig(config) {
             const configPath = import_path3.default.join(workspacePath, ".mdfriday", "auth-config.json");
-            const fs13 = await import("fs/promises");
-            await fs13.mkdir(import_path3.default.dirname(configPath), { recursive: true });
-            await fs13.writeFile(configPath, JSON.stringify(config.toJSON(), null, 2));
+            await fsRepo.createDirectory(import_path3.default.dirname(configPath), true);
+            await fsRepo.writeFile(configPath, JSON.stringify(config.toJSON(), null, 2));
           },
           async loadServerConfig() {
             const userData = await this.loadUserData();
@@ -3731,9 +3767,8 @@ var init_workspace_factory = __esm({
               return userData.serverConfig;
             }
             const configPath = import_path3.default.join(workspacePath, ".mdfriday", "auth-config.json");
-            const fs13 = await import("fs/promises");
             try {
-              const content = await fs13.readFile(configPath, "utf-8");
+              const content = await fsRepo.readFile(configPath, "utf-8");
               const data = JSON.parse(content);
               const { ServerConfig: ServerConfig2 } = await Promise.resolve().then(() => (init_identity(), identity_exports));
               return ServerConfig2.create(data.apiUrl, data.websiteUrl);
@@ -3791,11 +3826,12 @@ var init_workspace2 = __esm({
 });
 
 // internal/application/workspace.ts
-var log6, WorkspaceAppService;
+var import_path4, log6, WorkspaceAppService;
 var init_workspace3 = __esm({
   "internal/application/workspace.ts"() {
     "use strict";
     init_log();
+    import_path4 = __toESM(require("path"));
     log6 = getDomainLogger("workspace-app", { component: "application" });
     WorkspaceAppService = class {
       workspaceFactory;
@@ -3808,17 +3844,17 @@ var init_workspace3 = __esm({
       /**
        * Load workspace from path
        */
-      async loadWorkspace(path42) {
-        if (path42) {
-          return this.workspaceFactory.load(path42);
+      async loadWorkspace(path43) {
+        if (path43) {
+          return this.workspaceFactory.load(path43);
         }
         return this.workspaceFactory.loadOrFind();
       }
       /**
        * Create new workspace
        */
-      async createWorkspace(path42, options) {
-        return this.workspaceFactory.create(path42, options);
+      async createWorkspace(path43, options) {
+        return this.workspaceFactory.create(path43, options);
       }
       /**
        * Save workspace
@@ -3878,23 +3914,26 @@ var init_workspace3 = __esm({
           project = workspace.findProject(projectNameOrPath);
           if (!project) {
             const projects = workspace.getProjects();
-            const fs13 = await import("fs/promises");
-            const path42 = await import("path");
-            const inputPath = path42.resolve(projectNameOrPath);
-            for (const p2 of projects) {
-              const projectPath = p2.getPath();
-              if (inputPath.startsWith(projectPath) || projectPath === inputPath) {
-                project = p2;
-                break;
-              }
-              try {
-                const realInputPath = await fs13.realpath(inputPath);
-                const realProjectPath = await fs13.realpath(projectPath);
-                if (realInputPath.startsWith(realProjectPath) || realProjectPath === realInputPath) {
+            const fsRepo = this.workspaceFactory["fileSystemRepo"];
+            if (!fsRepo) {
+              project = void 0;
+            } else {
+              const inputPath = import_path4.default.resolve(projectNameOrPath);
+              for (const p2 of projects) {
+                const projectPath = p2.getPath();
+                if (inputPath.startsWith(projectPath) || projectPath === inputPath) {
                   project = p2;
                   break;
                 }
-              } catch (error) {
+                try {
+                  const realInputPath = await fsRepo.resolvePath(inputPath);
+                  const realProjectPath = await fsRepo.resolvePath(projectPath);
+                  if (realInputPath.startsWith(realProjectPath) || realProjectPath === realInputPath) {
+                    project = p2;
+                    break;
+                  }
+                } catch (error) {
+                }
               }
             }
             if (!project) {
@@ -3904,21 +3943,23 @@ var init_workspace3 = __esm({
         } else {
           const cwd = process.cwd();
           const projects = workspace.getProjects();
-          const fs13 = await import("fs/promises");
-          for (const p2 of projects) {
-            const projectPath = p2.getPath();
-            if (cwd.startsWith(projectPath)) {
-              project = p2;
-              break;
-            }
-            try {
-              const realCwd = await fs13.realpath(cwd);
-              const realProjectPath = await fs13.realpath(projectPath);
-              if (realCwd.startsWith(realProjectPath)) {
+          const fsRepo = this.workspaceFactory["fileSystemRepo"];
+          if (fsRepo) {
+            for (const p2 of projects) {
+              const projectPath = p2.getPath();
+              if (cwd.startsWith(projectPath)) {
                 project = p2;
                 break;
               }
-            } catch (error) {
+              try {
+                const realCwd = await fsRepo.resolvePath(cwd);
+                const realProjectPath = await fsRepo.resolvePath(projectPath);
+                if (realCwd.startsWith(realProjectPath)) {
+                  project = p2;
+                  break;
+                }
+              } catch (error) {
+              }
             }
           }
           if (!project && projects.length === 1) {
@@ -4400,12 +4441,12 @@ var init_identity2 = __esm({
 });
 
 // internal/infrastructure/persistence/node-workspace-repository.ts
-var import_fs2, import_path4, MDFRIDAY_DIR, WORKSPACE_FILE, PROJECTS_FILE, PROJECT_FILE, CONFIG_FILE, NodeWorkspaceRepository, NodeProjectRepository;
+var import_fs2, import_path5, MDFRIDAY_DIR, WORKSPACE_FILE, PROJECTS_FILE, PROJECT_FILE, CONFIG_FILE, NodeWorkspaceRepository, NodeProjectRepository;
 var init_node_workspace_repository = __esm({
   "internal/infrastructure/persistence/node-workspace-repository.ts"() {
     "use strict";
     import_fs2 = require("fs");
-    import_path4 = __toESM(require("path"));
+    import_path5 = __toESM(require("path"));
     MDFRIDAY_DIR = ".mdfriday";
     WORKSPACE_FILE = "workspace.json";
     PROJECTS_FILE = "projects.json";
@@ -4414,7 +4455,7 @@ var init_node_workspace_repository = __esm({
     NodeWorkspaceRepository = class {
       async isWorkspace(workspacePath) {
         try {
-          const metadataPath = import_path4.default.join(workspacePath, MDFRIDAY_DIR, WORKSPACE_FILE);
+          const metadataPath = import_path5.default.join(workspacePath, MDFRIDAY_DIR, WORKSPACE_FILE);
           await import_fs2.promises.access(metadataPath);
           return true;
         } catch {
@@ -4422,28 +4463,28 @@ var init_node_workspace_repository = __esm({
         }
       }
       async initWorkspaceStructure(workspacePath, modulesDir, projectsDir) {
-        const mdfridayDir = import_path4.default.join(workspacePath, MDFRIDAY_DIR);
-        const modulesDirPath = import_path4.default.join(workspacePath, modulesDir);
-        const projectsDirPath = import_path4.default.join(workspacePath, projectsDir);
+        const mdfridayDir = import_path5.default.join(workspacePath, MDFRIDAY_DIR);
+        const modulesDirPath = import_path5.default.join(workspacePath, modulesDir);
+        const projectsDirPath = import_path5.default.join(workspacePath, projectsDir);
         await import_fs2.promises.mkdir(mdfridayDir, { recursive: true });
         await import_fs2.promises.mkdir(modulesDirPath, { recursive: true });
         await import_fs2.promises.mkdir(projectsDirPath, { recursive: true });
       }
       async saveWorkspaceMetadata(workspacePath, metadata) {
-        const metadataPath = import_path4.default.join(workspacePath, MDFRIDAY_DIR, WORKSPACE_FILE);
+        const metadataPath = import_path5.default.join(workspacePath, MDFRIDAY_DIR, WORKSPACE_FILE);
         await import_fs2.promises.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
       }
       async loadWorkspaceMetadata(workspacePath) {
-        const metadataPath = import_path4.default.join(workspacePath, MDFRIDAY_DIR, WORKSPACE_FILE);
+        const metadataPath = import_path5.default.join(workspacePath, MDFRIDAY_DIR, WORKSPACE_FILE);
         const content = await import_fs2.promises.readFile(metadataPath, "utf-8");
         return JSON.parse(content);
       }
       async saveProjectRegistry(workspacePath, registry) {
-        const registryPath = import_path4.default.join(workspacePath, MDFRIDAY_DIR, PROJECTS_FILE);
+        const registryPath = import_path5.default.join(workspacePath, MDFRIDAY_DIR, PROJECTS_FILE);
         await import_fs2.promises.writeFile(registryPath, JSON.stringify(registry, null, 2));
       }
       async loadProjectRegistry(workspacePath) {
-        const registryPath = import_path4.default.join(workspacePath, MDFRIDAY_DIR, PROJECTS_FILE);
+        const registryPath = import_path5.default.join(workspacePath, MDFRIDAY_DIR, PROJECTS_FILE);
         const content = await import_fs2.promises.readFile(registryPath, "utf-8");
         return JSON.parse(content);
       }
@@ -4451,7 +4492,7 @@ var init_node_workspace_repository = __esm({
     NodeProjectRepository = class {
       async isProject(projectPath) {
         try {
-          const metadataPath = import_path4.default.join(projectPath, MDFRIDAY_DIR, PROJECT_FILE);
+          const metadataPath = import_path5.default.join(projectPath, MDFRIDAY_DIR, PROJECT_FILE);
           await import_fs2.promises.access(metadataPath);
           return true;
         } catch {
@@ -4459,26 +4500,26 @@ var init_node_workspace_repository = __esm({
         }
       }
       async initProjectStructure(projectPath, contentDir, staticDir, publishDir) {
-        const mdfridayDir = import_path4.default.join(projectPath, MDFRIDAY_DIR);
-        const contentDirPath = import_path4.default.join(projectPath, contentDir);
-        const staticDirPath = import_path4.default.join(projectPath, staticDir);
-        const publishDirPath = import_path4.default.join(projectPath, publishDir);
+        const mdfridayDir = import_path5.default.join(projectPath, MDFRIDAY_DIR);
+        const contentDirPath = import_path5.default.join(projectPath, contentDir);
+        const staticDirPath = import_path5.default.join(projectPath, staticDir);
+        const publishDirPath = import_path5.default.join(projectPath, publishDir);
         await import_fs2.promises.mkdir(mdfridayDir, { recursive: true });
         await import_fs2.promises.mkdir(contentDirPath, { recursive: true });
         await import_fs2.promises.mkdir(staticDirPath, { recursive: true });
         await import_fs2.promises.mkdir(publishDirPath, { recursive: true });
       }
       async saveProjectMetadata(projectPath, metadata) {
-        const metadataPath = import_path4.default.join(projectPath, MDFRIDAY_DIR, PROJECT_FILE);
+        const metadataPath = import_path5.default.join(projectPath, MDFRIDAY_DIR, PROJECT_FILE);
         await import_fs2.promises.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
       }
       async loadProjectMetadata(projectPath) {
-        const metadataPath = import_path4.default.join(projectPath, MDFRIDAY_DIR, PROJECT_FILE);
+        const metadataPath = import_path5.default.join(projectPath, MDFRIDAY_DIR, PROJECT_FILE);
         const content = await import_fs2.promises.readFile(metadataPath, "utf-8");
         return JSON.parse(content);
       }
       async saveProjectConfig(projectPath, config) {
-        const configPath = import_path4.default.join(projectPath, CONFIG_FILE);
+        const configPath = import_path5.default.join(projectPath, CONFIG_FILE);
         await import_fs2.promises.writeFile(configPath, JSON.stringify(config, null, 2));
       }
       async createSampleContent(contentPath, content) {
@@ -4495,20 +4536,20 @@ var init_node_workspace_repository = __esm({
 });
 
 // internal/infrastructure/persistence/node-snapshot-repository.ts
-var import_fs3, import_path5, NodeSnapshotRepository;
+var import_fs3, import_path6, NodeSnapshotRepository;
 var init_node_snapshot_repository = __esm({
   "internal/infrastructure/persistence/node-snapshot-repository.ts"() {
     "use strict";
     import_fs3 = require("fs");
-    import_path5 = __toESM(require("path"));
+    import_path6 = __toESM(require("path"));
     NodeSnapshotRepository = class {
       /**
        * Create a snapshot by copying output directory to snapshot storage
        */
       async createSnapshot(projectPath, snapshotId, outputDir) {
-        const snapshotDir = import_path5.default.join(projectPath, ".mdfriday", "snapshots");
+        const snapshotDir = import_path6.default.join(projectPath, ".mdfriday", "snapshots");
         await import_fs3.promises.mkdir(snapshotDir, { recursive: true });
-        const storageDir = import_path5.default.join(snapshotDir, snapshotId);
+        const storageDir = import_path6.default.join(snapshotDir, snapshotId);
         await import_fs3.promises.mkdir(storageDir, { recursive: true });
         await this.copyDirectory(outputDir, storageDir);
         const size = await this.getDirectorySize(storageDir);
@@ -4518,12 +4559,12 @@ var init_node_snapshot_repository = __esm({
           name: snapshotId,
           // Will be updated by service if custom name provided
           timestamp: Date.now(),
-          outputDir: import_path5.default.relative(projectPath, outputDir),
-          storageDir: import_path5.default.relative(projectPath, storageDir),
+          outputDir: import_path6.default.relative(projectPath, outputDir),
+          storageDir: import_path6.default.relative(projectPath, storageDir),
           size,
           fileCount
         };
-        const metadataPath = import_path5.default.join(snapshotDir, `${snapshotId}.json`);
+        const metadataPath = import_path6.default.join(snapshotDir, `${snapshotId}.json`);
         await import_fs3.promises.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
         return metadata;
       }
@@ -4531,7 +4572,7 @@ var init_node_snapshot_repository = __esm({
        * List all snapshots for a project
        */
       async listSnapshots(projectPath) {
-        const snapshotDir = import_path5.default.join(projectPath, ".mdfriday", "snapshots");
+        const snapshotDir = import_path6.default.join(projectPath, ".mdfriday", "snapshots");
         try {
           await import_fs3.promises.access(snapshotDir);
         } catch {
@@ -4542,7 +4583,7 @@ var init_node_snapshot_repository = __esm({
         const snapshots = [];
         for (const file of jsonFiles) {
           try {
-            const content = await import_fs3.promises.readFile(import_path5.default.join(snapshotDir, file), "utf-8");
+            const content = await import_fs3.promises.readFile(import_path6.default.join(snapshotDir, file), "utf-8");
             snapshots.push(JSON.parse(content));
           } catch {
           }
@@ -4553,8 +4594,8 @@ var init_node_snapshot_repository = __esm({
        * Get snapshot metadata
        */
       async getSnapshot(projectPath, snapshotId) {
-        const snapshotDir = import_path5.default.join(projectPath, ".mdfriday", "snapshots");
-        const metadataPath = import_path5.default.join(snapshotDir, `${snapshotId}.json`);
+        const snapshotDir = import_path6.default.join(projectPath, ".mdfriday", "snapshots");
+        const metadataPath = import_path6.default.join(snapshotDir, `${snapshotId}.json`);
         try {
           const content = await import_fs3.promises.readFile(metadataPath, "utf-8");
           const metadata = JSON.parse(content);
@@ -4574,7 +4615,7 @@ var init_node_snapshot_repository = __esm({
        */
       async restoreSnapshot(projectPath, snapshotId, outputDir) {
         const metadata = await this.getSnapshot(projectPath, snapshotId);
-        const storageDir = import_path5.default.join(projectPath, metadata.storageDir);
+        const storageDir = import_path6.default.join(projectPath, metadata.storageDir);
         try {
           await import_fs3.promises.access(storageDir);
         } catch {
@@ -4590,13 +4631,13 @@ var init_node_snapshot_repository = __esm({
        * Delete a snapshot
        */
       async deleteSnapshot(projectPath, snapshotId) {
-        const snapshotDir = import_path5.default.join(projectPath, ".mdfriday", "snapshots");
-        const metadataPath = import_path5.default.join(snapshotDir, `${snapshotId}.json`);
+        const snapshotDir = import_path6.default.join(projectPath, ".mdfriday", "snapshots");
+        const metadataPath = import_path6.default.join(snapshotDir, `${snapshotId}.json`);
         try {
           const content = await import_fs3.promises.readFile(metadataPath, "utf-8");
           const metadata = JSON.parse(content);
           if (metadata.storageDir) {
-            const storageDir = import_path5.default.join(projectPath, metadata.storageDir);
+            const storageDir = import_path6.default.join(projectPath, metadata.storageDir);
             try {
               await import_fs3.promises.rm(storageDir, { recursive: true, force: true });
             } catch {
@@ -4618,8 +4659,8 @@ var init_node_snapshot_repository = __esm({
         const entries = await import_fs3.promises.readdir(src, { withFileTypes: true });
         await Promise.all(
           entries.map(async (entry) => {
-            const srcPath = import_path5.default.join(src, entry.name);
-            const destPath = import_path5.default.join(dest, entry.name);
+            const srcPath = import_path6.default.join(src, entry.name);
+            const destPath = import_path6.default.join(dest, entry.name);
             if (entry.isDirectory()) {
               await this.copyDirectory(srcPath, destPath);
             } else {
@@ -4635,7 +4676,7 @@ var init_node_snapshot_repository = __esm({
         let size = 0;
         const entries = await import_fs3.promises.readdir(dir2, { withFileTypes: true });
         for (const entry of entries) {
-          const entryPath = import_path5.default.join(dir2, entry.name);
+          const entryPath = import_path6.default.join(dir2, entry.name);
           if (entry.isDirectory()) {
             size += await this.getDirectorySize(entryPath);
           } else {
@@ -4652,7 +4693,7 @@ var init_node_snapshot_repository = __esm({
         let count = 0;
         const entries = await import_fs3.promises.readdir(dir2, { withFileTypes: true });
         for (const entry of entries) {
-          const entryPath = import_path5.default.join(dir2, entry.name);
+          const entryPath = import_path6.default.join(dir2, entry.name);
           if (entry.isDirectory()) {
             count += await this.countFiles(entryPath);
           } else {
@@ -4670,12 +4711,12 @@ function mapLanguageCode(code) {
   const normalized = code.toLowerCase().trim();
   return LANGUAGE_CODE_MAP[normalized] || normalized;
 }
-var import_fs4, import_path6, log8, LANGUAGE_CODE_MAP, NodeFileSystemRepository;
+var import_fs4, import_path7, log8, LANGUAGE_CODE_MAP, NodeFileSystemRepository;
 var init_node_file_system = __esm({
   "internal/infrastructure/persistence/node-file-system.ts"() {
     "use strict";
     import_fs4 = require("fs");
-    import_path6 = __toESM(require("path"));
+    import_path7 = __toESM(require("path"));
     init_log();
     log8 = getDomainLogger("node-fs", { component: "infrastructure" });
     LANGUAGE_CODE_MAP = {
@@ -4724,7 +4765,7 @@ var init_node_file_system = __esm({
         try {
           const entries = await import_fs4.promises.readdir(dirPath, { withFileTypes: true });
           return entries.map((entry) => ({
-            path: import_path6.default.join(dirPath, entry.name),
+            path: import_path7.default.join(dirPath, entry.name),
             name: entry.name,
             isDirectory: entry.isDirectory(),
             isFile: entry.isFile()
@@ -4775,7 +4816,7 @@ var init_node_file_system = __esm({
             if (a.weight !== b.weight) {
               return a.weight - b.weight;
             }
-            return import_path6.default.basename(a.path).localeCompare(import_path6.default.basename(b.path));
+            return import_path7.default.basename(a.path).localeCompare(import_path7.default.basename(b.path));
           });
           const isStructured = contentFolders.length > 0;
           log8.debug(`Scanned folder structure: ${dirPath}`, {
@@ -4919,7 +4960,7 @@ var init_node_file_system = __esm({
       }
       async copyFile(source, target) {
         try {
-          const targetDir = import_path6.default.dirname(target);
+          const targetDir = import_path7.default.dirname(target);
           if (!await this.exists(targetDir)) {
             await import_fs4.promises.mkdir(targetDir, { recursive: true });
           }
@@ -4930,17 +4971,54 @@ var init_node_file_system = __esm({
           throw error;
         }
       }
+      async readFile(filePath, encoding = "utf-8") {
+        try {
+          return await import_fs4.promises.readFile(filePath, encoding);
+        } catch (error) {
+          log8.error(`Failed to read file: ${filePath}`, error);
+          throw error;
+        }
+      }
+      async writeFile(filePath, content, encoding = "utf-8") {
+        try {
+          const dir2 = import_path7.default.dirname(filePath);
+          if (!await this.exists(dir2)) {
+            await import_fs4.promises.mkdir(dir2, { recursive: true });
+          }
+          await import_fs4.promises.writeFile(filePath, content, encoding);
+          log8.debug(`Wrote file: ${filePath}`);
+        } catch (error) {
+          log8.error(`Failed to write file: ${filePath}`, error);
+          throw error;
+        }
+      }
+      async unlink(filePath) {
+        try {
+          await import_fs4.promises.unlink(filePath);
+          log8.debug(`Deleted file: ${filePath}`);
+        } catch (error) {
+          log8.error(`Failed to delete file: ${filePath}`, error);
+          throw error;
+        }
+      }
+      async access(filePath) {
+        try {
+          await import_fs4.promises.access(filePath);
+        } catch (error) {
+          throw new Error(`Cannot access path: ${filePath}`);
+        }
+      }
       async resolvePath(filePath) {
-        return import_path6.default.resolve(filePath);
+        return import_path7.default.resolve(filePath);
       }
       basename(filePath) {
-        return import_path6.default.basename(filePath);
+        return import_path7.default.basename(filePath);
       }
       dirname(filePath) {
-        return import_path6.default.dirname(filePath);
+        return import_path7.default.dirname(filePath);
       }
       join(...paths) {
-        return import_path6.default.join(...paths);
+        return import_path7.default.join(...paths);
       }
     };
   }
@@ -5154,10 +5232,10 @@ var init_publish_manifest = __esm({
        */
       getChangedFiles(newManifest) {
         const changedFiles = [];
-        for (const [path42, newEntry] of newManifest.files.entries()) {
-          const oldEntry = this.files.get(path42);
+        for (const [path43, newEntry] of newManifest.files.entries()) {
+          const oldEntry = this.files.get(path43);
           if (!oldEntry || oldEntry.hash !== newEntry.hash) {
-            changedFiles.push(path42);
+            changedFiles.push(path43);
           }
         }
         return changedFiles;
@@ -5168,9 +5246,9 @@ var init_publish_manifest = __esm({
        */
       getDeletedFiles(newManifest) {
         const deletedFiles = [];
-        for (const path42 of this.files.keys()) {
-          if (!newManifest.files.has(path42)) {
-            deletedFiles.push(path42);
+        for (const path43 of this.files.keys()) {
+          if (!newManifest.files.has(path43)) {
+            deletedFiles.push(path43);
           }
         }
         return deletedFiles;
@@ -5180,8 +5258,8 @@ var init_publish_manifest = __esm({
        */
       toJSON() {
         const filesObj = {};
-        for (const [path42, entry] of this.files.entries()) {
-          filesObj[path42] = entry;
+        for (const [path43, entry] of this.files.entries()) {
+          filesObj[path43] = entry;
         }
         return {
           projectId: this.projectId,
@@ -6773,8 +6851,8 @@ var require_Client = __commonJS({
       /**
        * Set the working directory.
        */
-      async cd(path42) {
-        const validPath = await this.protectWhitespace(path42);
+      async cd(path43) {
+        const validPath = await this.protectWhitespace(path43);
         return this.send("CWD " + validPath);
       }
       /**
@@ -6787,8 +6865,8 @@ var require_Client = __commonJS({
        * Get the last modified time of a file. This is not supported by every FTP server, in which case
        * calling this method will throw an exception.
        */
-      async lastMod(path42) {
-        const validPath = await this.protectWhitespace(path42);
+      async lastMod(path43) {
+        const validPath = await this.protectWhitespace(path43);
         const res = await this.send(`MDTM ${validPath}`);
         const date = res.message.slice(4);
         return (0, parseListMLSD_1.parseMLSxDate)(date);
@@ -6796,8 +6874,8 @@ var require_Client = __commonJS({
       /**
        * Get the size of a file.
        */
-      async size(path42) {
-        const validPath = await this.protectWhitespace(path42);
+      async size(path43) {
+        const validPath = await this.protectWhitespace(path43);
         const command = `SIZE ${validPath}`;
         const res = await this.send(command);
         const size = parseInt(res.message.slice(4), 10);
@@ -6824,8 +6902,8 @@ var require_Client = __commonJS({
        * You can ignore FTP error return codes which won't throw an exception if e.g.
        * the file doesn't exist.
        */
-      async remove(path42, ignoreErrorCodes = false) {
-        const validPath = await this.protectWhitespace(path42);
+      async remove(path43, ignoreErrorCodes = false) {
+        const validPath = await this.protectWhitespace(path43);
         if (ignoreErrorCodes) {
           return this.sendIgnoringError(`DELE ${validPath}`);
         }
@@ -6979,8 +7057,8 @@ var require_Client = __commonJS({
        *
        * @param [path]  Path to remote file or directory.
        */
-      async list(path42 = "") {
-        const validPath = await this.protectWhitespace(path42);
+      async list(path43 = "") {
+        const validPath = await this.protectWhitespace(path43);
         let lastError;
         for (const candidate of this.availableListCommands) {
           const command = validPath === "" ? candidate : `${candidate} ${validPath}`;
@@ -7150,21 +7228,21 @@ var require_Client = __commonJS({
       /**
        * Remove an empty directory, will fail if not empty.
        */
-      async removeEmptyDir(path42) {
-        const validPath = await this.protectWhitespace(path42);
+      async removeEmptyDir(path43) {
+        const validPath = await this.protectWhitespace(path43);
         return this.send(`RMD ${validPath}`);
       }
       /**
        * FTP servers can't handle filenames that have leading whitespace. This method transforms
        * a given path to fix that issue for most cases.
        */
-      async protectWhitespace(path42) {
-        if (!path42.startsWith(" ")) {
-          return path42;
+      async protectWhitespace(path43) {
+        if (!path43.startsWith(" ")) {
+          return path43;
         }
         const pwd = await this.pwd();
         const absolutePathPrefix = pwd.endsWith("/") ? pwd : pwd + "/";
-        return absolutePathPrefix + path42;
+        return absolutePathPrefix + path43;
       }
       async _exitAtCurrentDirectory(func) {
         const userDir = await this.pwd();
@@ -7241,11 +7319,11 @@ var require_Client = __commonJS({
       }
     };
     exports2.Client = Client2;
-    async function ensureLocalDirectory(path42) {
+    async function ensureLocalDirectory(path43) {
       try {
-        await fsStat(path42);
+        await fsStat(path43);
       } catch (_a2) {
-        await fsMkDir(path42, { recursive: true });
+        await fsMkDir(path43, { recursive: true });
       }
     }
     async function ignoreError(func) {
@@ -7308,13 +7386,13 @@ var require_dist = __commonJS({
 });
 
 // internal/domain/publish/value-object/ftp-publisher.ts
-var ftp, import_path7, import_fs5, log10, FtpPublisher;
+var ftp, import_path8, import_fs5, log10, FtpPublisher;
 var init_ftp_publisher = __esm({
   "internal/domain/publish/value-object/ftp-publisher.ts"() {
     "use strict";
     init_log();
     ftp = __toESM(require_dist());
-    import_path7 = __toESM(require("path"));
+    import_path8 = __toESM(require("path"));
     import_fs5 = require("fs");
     log10 = getDomainLogger("ftp-publisher", { component: "domain" });
     FtpPublisher = class {
@@ -7362,10 +7440,10 @@ var init_ftp_publisher = __esm({
           });
           const createdDirs = /* @__PURE__ */ new Set();
           for (const relativePath of changedFiles) {
-            const localPath = import_path7.default.join(sourceDir, relativePath);
+            const localPath = import_path8.default.join(sourceDir, relativePath);
             const remoteFilePath = this.config.remotePath && this.config.remotePath !== "/" ? `${this.config.remotePath}/${relativePath}`.replace(/\\/g, "/") : relativePath.replace(/\\/g, "/");
             try {
-              const remoteDir = import_path7.default.dirname(remoteFilePath).replace(/\\/g, "/");
+              const remoteDir = import_path8.default.dirname(remoteFilePath).replace(/\\/g, "/");
               if (remoteDir && remoteDir !== "." && remoteDir !== "/") {
                 if (!createdDirs.has(remoteDir)) {
                   try {
@@ -7596,12 +7674,12 @@ var init_ftp_publisher = __esm({
 });
 
 // internal/domain/publish/value-object/netlify-publisher.ts
-var import_path8, import_fs6, log11, NetlifyPublisher;
+var import_path9, import_fs6, log11, NetlifyPublisher;
 var init_netlify_publisher = __esm({
   "internal/domain/publish/value-object/netlify-publisher.ts"() {
     "use strict";
     init_log();
-    import_path8 = __toESM(require("path"));
+    import_path9 = __toESM(require("path"));
     import_fs6 = require("fs");
     log11 = getDomainLogger("netlify-publisher", { component: "domain" });
     NetlifyPublisher = class {
@@ -7863,7 +7941,7 @@ var init_netlify_publisher = __esm({
             log11.warn(`File not found in manifest: ${filePath}`);
             continue;
           }
-          const localFilePath = import_path8.default.join(sourceDir, filePath);
+          const localFilePath = import_path9.default.join(sourceDir, filePath);
           try {
             const fileContent = await import_fs6.promises.readFile(localFilePath);
             await this.uploadFileWithRetry(deployId, filePath, fileContent, fileEntry.hash);
@@ -8007,12 +8085,12 @@ var mdfriday_publisher_exports = {};
 __export(mdfriday_publisher_exports, {
   MDFridayPublisher: () => MDFridayPublisher
 });
-var import_path9, import_fs7, log12, MDFridayPublisher;
+var import_path10, import_fs7, log12, MDFridayPublisher;
 var init_mdfriday_publisher = __esm({
   "internal/domain/publish/value-object/mdfriday-publisher.ts"() {
     "use strict";
     init_log();
-    import_path9 = __toESM(require("path"));
+    import_path10 = __toESM(require("path"));
     import_fs7 = require("fs");
     log12 = getDomainLogger("mdfriday-publisher", { component: "domain" });
     MDFridayPublisher = class {
@@ -8165,7 +8243,7 @@ var init_mdfriday_publisher = __esm({
         const addDirectoryToZip = async (dirPath, zipFolder) => {
           const items = await import_fs7.promises.readdir(dirPath, { withFileTypes: true });
           for (const item of items) {
-            const itemPath = import_path9.default.join(dirPath, item.name);
+            const itemPath = import_path10.default.join(dirPath, item.name);
             if (item.isDirectory()) {
               const subFolder = zipFolder.folder(item.name);
               if (subFolder) {
@@ -8414,13 +8492,13 @@ var init_publish = __esm({
 });
 
 // internal/infrastructure/persistence/node-manifest-repository.ts
-var import_path10, import_fs8, import_crypto, log14, NodeManifestRepository;
+var import_path11, import_fs8, import_crypto, log14, NodeManifestRepository;
 var init_node_manifest_repository = __esm({
   "internal/infrastructure/persistence/node-manifest-repository.ts"() {
     "use strict";
     init_publish();
     init_log();
-    import_path10 = __toESM(require("path"));
+    import_path11 = __toESM(require("path"));
     import_fs8 = require("fs");
     import_crypto = __toESM(require("crypto"));
     log14 = getDomainLogger("node-manifest-repo", { component: "infrastructure" });
@@ -8447,7 +8525,7 @@ var init_node_manifest_repository = __esm({
        * Save manifest to file
        */
       async saveManifest(projectPath, manifest) {
-        const manifestDir = import_path10.default.join(projectPath, ".mdfriday");
+        const manifestDir = import_path11.default.join(projectPath, ".mdfriday");
         await import_fs8.promises.mkdir(manifestDir, { recursive: true });
         const manifestPath = this.getManifestPath(projectPath, manifest.getPublishMethod());
         await import_fs8.promises.writeFile(
@@ -8496,7 +8574,7 @@ var init_node_manifest_repository = __esm({
        * Get manifest file path
        */
       getManifestPath(projectPath, publishMethod) {
-        return import_path10.default.join(projectPath, ".mdfriday", `manifest-${publishMethod}.json`);
+        return import_path11.default.join(projectPath, ".mdfriday", `manifest-${publishMethod}.json`);
       }
       /**
        * Recursively scan directory and collect file info
@@ -8504,8 +8582,8 @@ var init_node_manifest_repository = __esm({
       async scanDirectory(currentPath, relativePath, files, hashAlgorithm = "md5") {
         const items = await import_fs8.promises.readdir(currentPath, { withFileTypes: true });
         for (const item of items) {
-          const itemPath = import_path10.default.join(currentPath, item.name);
-          const itemRelativePath = relativePath ? import_path10.default.join(relativePath, item.name) : item.name;
+          const itemPath = import_path11.default.join(currentPath, item.name);
+          const itemRelativePath = relativePath ? import_path11.default.join(relativePath, item.name) : item.name;
           if (item.isDirectory()) {
             await this.scanDirectory(itemPath, itemRelativePath, files, hashAlgorithm);
           } else if (item.isFile()) {
@@ -9435,8 +9513,8 @@ var init_module2 = __esm({
       /**
        * Find import by path
        */
-      findImport(path42) {
-        return this.moduleConfig.imports.find((imp) => imp.path === path42);
+      findImport(path43) {
+        return this.moduleConfig.imports.find((imp) => imp.path === path43);
       }
       /**
        * Find mount by source
@@ -10685,11 +10763,11 @@ var init_markdown2 = __esm({
 function newDir(workingDir, themesDir, publishDir) {
   return new Dir(workingDir, themesDir, publishDir);
 }
-var import_path11, DEFAULT_PUBLISH_DIR, Dir;
+var import_path12, DEFAULT_PUBLISH_DIR, Dir;
 var init_dir = __esm({
   "internal/domain/config/entity/dir.ts"() {
     "use strict";
-    import_path11 = __toESM(require("path"));
+    import_path12 = __toESM(require("path"));
     DEFAULT_PUBLISH_DIR = "public";
     Dir = class {
       workingDir;
@@ -10701,16 +10779,16 @@ var init_dir = __esm({
         this.publishDir = publishDir;
       }
       getWorkingDir() {
-        return import_path11.default.resolve(this.workingDir);
+        return import_path12.default.resolve(this.workingDir);
       }
       getThemesDir() {
-        return import_path11.default.resolve(this.themesDir);
+        return import_path12.default.resolve(this.themesDir);
       }
       getThemesCacheDir() {
-        return import_path11.default.resolve(this.themesDir, ".cache");
+        return import_path12.default.resolve(this.themesDir, ".cache");
       }
       getPublishDir() {
-        return import_path11.default.resolve(this.publishDir);
+        return import_path12.default.resolve(this.publishDir);
       }
     };
   }
@@ -10900,12 +10978,12 @@ var init_provider = __esm({
 });
 
 // internal/domain/config/factory/loader.ts
-var path12, NO_CONFIG_FILE_ERR_INFO, ConfigLoader;
+var path13, NO_CONFIG_FILE_ERR_INFO, ConfigLoader;
 var init_loader = __esm({
   "internal/domain/config/factory/loader.ts"() {
     "use strict";
     init_provider();
-    path12 = __toESM(require("path"));
+    path13 = __toESM(require("path"));
     NO_CONFIG_FILE_ERR_INFO = "Unable to locate config file or config directory.";
     ConfigLoader = class {
       cfg;
@@ -10944,13 +11022,13 @@ var init_loader = __esm({
       async loadProvider(configName) {
         const baseDir = this.baseDirs.workingDir;
         let baseFilename;
-        if (path12.isAbsolute(configName)) {
+        if (path13.isAbsolute(configName)) {
           baseFilename = configName;
         } else {
-          baseFilename = path12.join(baseDir, configName);
+          baseFilename = path13.join(baseDir, configName);
         }
         let filename = "";
-        if (path12.extname(configName) !== "") {
+        if (path13.extname(configName) !== "") {
           const exists = await this.fileExists(baseFilename);
           if (exists) {
             filename = baseFilename;
@@ -11089,9 +11167,9 @@ var init_sourcedescriptor = __esm({
 
 // internal/domain/config/factory/config.ts
 async function loadConfigWithParams(fs13, configFilename, workingDir, modulesDir, params = {}) {
-  const cleanWorkingDir = path13.resolve(workingDir);
-  const cleanModulesDir = path13.resolve(modulesDir);
-  const cleanPublishDir = path13.resolve(DEFAULT_PUBLISH_DIR);
+  const cleanWorkingDir = path14.resolve(workingDir);
+  const cleanModulesDir = path14.resolve(modulesDir);
+  const cleanPublishDir = path14.resolve(DEFAULT_PUBLISH_DIR);
   const baseDirs = {
     workingDir: cleanWorkingDir,
     modulesDir: cleanModulesDir,
@@ -11108,7 +11186,7 @@ async function loadConfigWithParams(fs13, configFilename, workingDir, modulesDir
     for (const [key2, value] of Object.entries(params)) {
       provider.set(key2, value);
     }
-    const absPublishDir = path13.resolve(provider.get("publishDir") || DEFAULT_PUBLISH_DIR);
+    const absPublishDir = path14.resolve(provider.get("publishDir") || DEFAULT_PUBLISH_DIR);
     await fs13.mkdirAll(absPublishDir, 511);
     return newConfig(
       fs13,
@@ -11131,15 +11209,15 @@ async function getCacheDir(fs13, cacheDir) {
     return cacheDir;
   }
   const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-  const defaultCacheDir = path13.join(homeDir, ".cache", "mdf");
+  const defaultCacheDir = path14.join(homeDir, ".cache", "mdf");
   try {
     await fs13.mkdirAll(defaultCacheDir, 493);
     return defaultCacheDir;
   } catch {
-    return path13.join("/tmp", "hugo-cache");
+    return path14.join("/tmp", "hugo-cache");
   }
 }
-var path13;
+var path14;
 var init_config2 = __esm({
   "internal/domain/config/factory/config.ts"() {
     "use strict";
@@ -11154,7 +11232,7 @@ var init_config2 = __esm({
     init_markdown2();
     init_loader();
     init_sourcedescriptor();
-    path13 = __toESM(require("path"));
+    path14 = __toESM(require("path"));
   }
 });
 
@@ -11226,11 +11304,11 @@ function createDefaultMounts(componentFolders) {
     (folder) => new Mount(folder, folder)
   );
 }
-var path14, Mount;
+var path15, Mount;
 var init_mount = __esm({
   "internal/domain/module/vo/mount.ts"() {
     "use strict";
-    path14 = __toESM(require("path"));
+    path15 = __toESM(require("path"));
     Mount = class _Mount {
       constructor(sourcePath, targetPath, language2 = "") {
         this.sourcePath = sourcePath;
@@ -11265,16 +11343,16 @@ var init_mount = __esm({
        * Get component name from target path
        */
       component() {
-        const parts = this.targetPath.split(path14.sep);
+        const parts = this.targetPath.split(path15.sep);
         return parts[0] || "";
       }
       /**
        * Get component and name from target path
        */
       componentAndName() {
-        const parts = this.targetPath.split(path14.sep);
+        const parts = this.targetPath.split(path15.sep);
         const component = parts[0] || "";
-        const name = parts.slice(1).join(path14.sep);
+        const name = parts.slice(1).join(path15.sep);
         return { component, name };
       }
       /**
@@ -11319,12 +11397,12 @@ function newHttpClient(fs13, timeout, headers, customClient) {
   }
   return new NodeHttpClient2(fs13, timeout, headers);
 }
-var path15, http, https, log20, NodeHttpClient2;
+var path16, http, https, log20, NodeHttpClient2;
 var init_httpclient = __esm({
   "internal/domain/module/vo/httpclient.ts"() {
     "use strict";
     init_type5();
-    path15 = __toESM(require("path"));
+    path16 = __toESM(require("path"));
     http = __toESM(require("http"));
     https = __toESM(require("https"));
     init_log();
@@ -11375,7 +11453,7 @@ var init_httpclient = __esm({
               let lastProgressTime = Date.now();
               let lastLoggedPercentage = -1;
               try {
-                const targetDir = path15.dirname(targetPath);
+                const targetDir = path16.dirname(targetPath);
                 await this.fs.mkdirAll(targetDir, 493);
                 const file = await this.fs.create(targetPath);
                 const chunks = [];
@@ -11526,14 +11604,14 @@ function newZipExtractor(fs13, environment = "node") {
       throw new Error(`Unsupported environment: ${environment}`);
   }
 }
-var import_jszip, path16, log21, JsZipExtractor, WebZipExtractor;
+var import_jszip, path17, log21, JsZipExtractor, WebZipExtractor;
 var init_zipextractor = __esm({
   "internal/domain/module/vo/zipextractor.ts"() {
     "use strict";
     init_type5();
     init_log();
     import_jszip = __toESM(require("jszip"));
-    path16 = __toESM(require("path"));
+    path17 = __toESM(require("path"));
     log21 = getDomainLogger("module", { component: "zipextractor" });
     JsZipExtractor = class {
       constructor(fs13) {
@@ -11607,11 +11685,11 @@ var init_zipextractor = __esm({
        * Extract a single ZIP entry (file or directory)
        */
       async extractSingleEntry(relativePath, zipEntry, targetDir) {
-        const fullPath = path16.join(targetDir, relativePath);
+        const fullPath = path17.join(targetDir, relativePath);
         if (zipEntry.dir) {
           await this.fs.mkdirAll(fullPath, 493);
         } else {
-          const dir2 = path16.dirname(fullPath);
+          const dir2 = path17.dirname(fullPath);
           if (dir2 !== targetDir) {
             await this.fs.mkdirAll(dir2, 493);
           }
@@ -11667,13 +11745,13 @@ var init_zipextractor = __esm({
 function newModuleCache(fs13, cacheDir) {
   return new FsModuleCache(fs13, cacheDir);
 }
-var path17, log22, FsModuleCache;
+var path18, log22, FsModuleCache;
 var init_cache = __esm({
   "internal/domain/module/vo/cache.ts"() {
     "use strict";
     init_type5();
     init_log();
-    path17 = __toESM(require("path"));
+    path18 = __toESM(require("path"));
     log22 = getDomainLogger("module", { component: "cache" });
     FsModuleCache = class {
       constructor(fs13, cacheDir = "./module/cache") {
@@ -11769,7 +11847,7 @@ var init_cache = __esm({
        */
       getCacheFilePath(modulePath) {
         const safeFileName = modulePath.replace(/[/\\:*?"<>|]/g, "_").replace(/^_+|_+$/g, "") + ".json";
-        return path17.join(this.cacheDir, safeFileName);
+        return path18.join(this.cacheDir, safeFileName);
       }
       /**
        * Get cache directory
@@ -11786,7 +11864,7 @@ var init_cache = __esm({
           let totalSize = 0;
           for (const file of files) {
             try {
-              const filePath = path17.join(this.cacheDir, file);
+              const filePath = path18.join(this.cacheDir, file);
               const fileInfo = await this.fs.stat(filePath);
               totalSize += fileInfo.size();
             } catch (error) {
@@ -11810,7 +11888,7 @@ var init_cache = __esm({
         try {
           const files = await this.listCacheFiles();
           return files.map(
-            (file) => path17.basename(file, ".json").replace(/_/g, "/")
+            (file) => path18.basename(file, ".json").replace(/_/g, "/")
           );
         } catch (error) {
           return [];
@@ -11862,13 +11940,13 @@ function newProjectModule(info) {
   }
   return projectModule;
 }
-var path18, Module2, ProjectModule;
+var path19, Module2, ProjectModule;
 var init_module3 = __esm({
   "internal/domain/module/vo/module.ts"() {
     "use strict";
     init_type5();
     init_mount();
-    path18 = __toESM(require("path"));
+    path19 = __toESM(require("path"));
     Module2 = class _Module {
       constructor(fs13, absoluteDir, modulePath, parent = null, isProject = false) {
         this.fs = fs13;
@@ -11932,7 +12010,7 @@ var init_module3 = __esm({
           let mounts = moduleImport.mounts || [];
           if (mounts.length === 0) {
             for (const componentFolder of ComponentFolders) {
-              const sourceDir = path18.join(this.absoluteDir, componentFolder);
+              const sourceDir = path19.join(this.absoluteDir, componentFolder);
               try {
                 const stat4 = await this.fs.stat(sourceDir);
                 if (stat4.isDir()) {
@@ -12083,11 +12161,11 @@ var init_module3 = __esm({
 function newLang(modules) {
   return new Lang(modules);
 }
-var import_path12, Lang;
+var import_path13, Lang;
 var init_lang2 = __esm({
   "internal/domain/module/entity/lang.ts"() {
     "use strict";
-    import_path12 = __toESM(require("path"));
+    import_path13 = __toESM(require("path"));
     Lang = class {
       sourceLangMap;
       constructor(modules) {
@@ -12103,7 +12181,7 @@ var init_lang2 = __esm({
        * Returns a tuple of [language, exists] to match Go's return pattern
        */
       getSourceLang(source) {
-        const lang2 = this.sourceLangMap.get(import_path12.default.basename(source));
+        const lang2 = this.sourceLangMap.get(import_path13.default.basename(source));
         if (lang2 !== void 0) {
           return [lang2, true];
         }
@@ -12206,7 +12284,7 @@ var init_themes = __esm({
 function newModules(info, httpClient, zipExtractor, moduleCache) {
   return new Modules(info, httpClient, zipExtractor, moduleCache);
 }
-var import_smol_toml, path20, log23, Modules;
+var import_smol_toml, path21, log23, Modules;
 var init_module4 = __esm({
   "internal/domain/module/entity/module.ts"() {
     "use strict";
@@ -12216,7 +12294,7 @@ var init_module4 = __esm({
     init_themes();
     init_log();
     import_smol_toml = require("smol-toml");
-    path20 = __toESM(require("path"));
+    path21 = __toESM(require("path"));
     log23 = getDomainLogger("module", { component: "modules" });
     Modules = class {
       constructor(info, httpClient, zipExtractor, moduleCache) {
@@ -12371,7 +12449,7 @@ var init_module4 = __esm({
             log23.info(`Cache version mismatch for ${moduleImport.path}: cached=${cachedMetadata.version}, requested=${effectiveVersion || "latest"}`);
           }
           const moduleDir = this.getModuleDir(moduleImport.path);
-          const zipPath = path20.join(moduleDir, "module.zip");
+          const zipPath = path21.join(moduleDir, "module.zip");
           const metadata = {
             path: moduleImport.path,
             version: moduleImport.version || "latest",
@@ -12477,7 +12555,7 @@ var init_module4 = __esm({
        */
       getModuleDir(modulePath) {
         const safeName = modulePath.replace(/[/\\:*?"<>|]/g, "_").replace(/^_+|_+$/g, "");
-        return path20.join(this.info.moduleDir(), safeName);
+        return path21.join(this.info.moduleDir(), safeName);
       }
       /**
        * Get download URL for module path
@@ -12578,7 +12656,7 @@ var init_module4 = __esm({
        */
       async parseThemeToml(module2) {
         try {
-          const themeTomlPath = path20.join(module2.dir(), "theme.toml");
+          const themeTomlPath = path21.join(module2.dir(), "theme.toml");
           try {
             const stat4 = await this.info.osFs().stat(themeTomlPath);
             if (stat4.isDir()) {
@@ -12970,13 +13048,13 @@ function newFileWithMeta(file, meta, fs13) {
 function newDirFileWithMeta(file, meta, fs13) {
   return new File(file, meta, fs13, true);
 }
-var path21, File;
+var path22, File;
 var init_file = __esm({
   "internal/domain/fs/vo/file.ts"() {
     "use strict";
     init_filemeta();
     init_fileinfo();
-    path21 = __toESM(require("path"));
+    path22 = __toESM(require("path"));
     File = class {
       file;
       fileMeta;
@@ -13070,7 +13148,7 @@ var init_file = __esm({
         return await this.file.writeAt(buffer, offset);
       }
       name() {
-        return path21.basename(this.fileMeta.fileName());
+        return path22.basename(this.fileMeta.fileName());
       }
       async readdir(count) {
         if (this.file === null) {
@@ -13192,7 +13270,7 @@ var init_dir2 = __esm({
 function newBaseFs(fs13, roots) {
   return new BaseFs(fs13, roots);
 }
-var path22, log26, BaseFs;
+var path23, log26, BaseFs;
 var init_basefs = __esm({
   "internal/domain/fs/entity/basefs.ts"() {
     "use strict";
@@ -13200,7 +13278,7 @@ var init_basefs = __esm({
     init_fileinfo();
     init_file();
     init_dir2();
-    path22 = __toESM(require("path"));
+    path23 = __toESM(require("path"));
     init_log();
     log26 = getDomainLogger("fs", { component: "basefs" });
     BaseFs = class {
@@ -13223,17 +13301,17 @@ var init_basefs = __esm({
         if (name === "") {
           return root2;
         }
-        if (path22.isAbsolute(name)) {
+        if (path23.isAbsolute(name)) {
           if (name.startsWith(root2)) {
             return name;
           }
-          return path22.join(root2, name.substring(1));
+          return path23.join(root2, name.substring(1));
         }
-        return path22.join(root2, name);
+        return path23.join(root2, name);
       }
       isSameRootedPath(name) {
         const root2 = this.roots[0];
-        return name.startsWith(path22.join(root2, path22.sep)) || name === root2;
+        return name.startsWith(path23.join(root2, path23.sep)) || name === root2;
       }
       /**
        * Stat returns file info with opener function
@@ -13319,8 +13397,8 @@ var init_basefs = __esm({
         const absPath = this.toAbsolutePath(name);
         return await this.fs.mkdir(absPath, perm);
       }
-      async mkdirAll(path42, perm) {
-        const absPath = this.toAbsolutePath(path42);
+      async mkdirAll(path43, perm) {
+        const absPath = this.toAbsolutePath(path43);
         return await this.fs.mkdirAll(absPath, perm);
       }
       async openFile(name, flag, perm) {
@@ -13331,8 +13409,8 @@ var init_basefs = __esm({
         const absPath = this.toAbsolutePath(name);
         return await this.fs.remove(absPath);
       }
-      async removeAll(path42) {
-        const absPath = this.toAbsolutePath(path42);
+      async removeAll(path43) {
+        const absPath = this.toAbsolutePath(path43);
         return await this.fs.removeAll(absPath);
       }
       async rename(oldname, newname) {
@@ -13363,11 +13441,11 @@ var init_basefs = __esm({
 function newWalkway(fs13, cb) {
   return new Walkway(fs13, cb);
 }
-var path23, log27, Walkway;
+var path24, log27, Walkway;
 var init_walkway = __esm({
   "internal/domain/fs/vo/walkway.ts"() {
     "use strict";
-    path23 = __toESM(require("path"));
+    path24 = __toESM(require("path"));
     init_type6();
     init_fileinfo();
     init_filemeta();
@@ -13494,7 +13572,7 @@ var init_walkway = __esm({
           }
         }
         for (const entry of dirEntries) {
-          const nextPath = path23.join(filePath, entry.name());
+          const nextPath = path24.join(filePath, entry.name());
           try {
             await this.walkRecursive(nextPath, entry);
           } catch (err) {
@@ -13576,9 +13654,9 @@ var init_static_copier = __esm({
       async walkSourceFiles(sourceFs, targetDir) {
         let fileCount = 0;
         try {
-          await this.walkFileSystem(sourceFs, "/", async (path42, isDir) => {
+          await this.walkFileSystem(sourceFs, "/", async (path43, isDir) => {
             if (!isDir) {
-              await this.copyFile(sourceFs, path42, this.toFs, targetDir);
+              await this.copyFile(sourceFs, path43, this.toFs, targetDir);
               fileCount++;
             }
           });
@@ -13662,8 +13740,8 @@ var init_static_copier = __esm({
       /**
        * Get directory name from path
        */
-      dirname(path42) {
-        const parts = path42.split("/").filter((part) => part.length > 0);
+      dirname(path43) {
+        const parts = path43.split("/").filter((part) => part.length > 0);
         if (parts.length <= 1)
           return "/";
         return "/" + parts.slice(0, -1).join("/");
@@ -13676,16 +13754,16 @@ var init_static_copier = __esm({
 async function collectFileMetaInfos(paths, fss) {
   const result = /* @__PURE__ */ new Map();
   let found = false;
-  for (const path42 of paths) {
+  for (const path43 of paths) {
     for (const fs13 of fss) {
       try {
-        const fileMetaInfo = await createFileMetaInfo(path42, fs13);
-        result.set(path42, fileMetaInfo);
+        const fileMetaInfo = await createFileMetaInfo(path43, fs13);
+        result.set(path43, fileMetaInfo);
         found = true;
         if (found)
           break;
       } catch (error) {
-        log29.error(`Failed to create FileMetaInfo for ${path42} with fs=${fs13}:`, error);
+        log29.error(`Failed to create FileMetaInfo for ${path43} with fs=${fs13}:`, error);
       }
     }
   }
@@ -13794,8 +13872,8 @@ var init_fs = __esm({
       /**
        * Create new base path filesystem
        */
-      newBasePathFs(source, path42) {
-        return newBaseFs(source, [path42]);
+      newBasePathFs(source, path43) {
+        return newBaseFs(source, [path43]);
       }
       async walkPrompts(start, cb, conf) {
         return await this.walk(this.prompts, start, cb, conf);
@@ -14337,11 +14415,11 @@ var init_overlayfs = __esm({
       /**
        * Create directory tree (write operation)
        */
-      async mkdirAll(path42, perm) {
+      async mkdirAll(path43, perm) {
         if (!this.firstWritable) {
           throw new OverlayFsError("filesystem is read-only", "READ_ONLY");
         }
-        return await this.writeFs().mkdirAll(path42, perm);
+        return await this.writeFs().mkdirAll(path43, perm);
       }
       /**
        * Open file for reading (searches all filesystems)
@@ -14400,11 +14478,11 @@ var init_overlayfs = __esm({
       /**
        * Remove directory tree (write operation)
        */
-      async removeAll(path42) {
+      async removeAll(path43) {
         if (!this.firstWritable) {
           throw new OverlayFsError("filesystem is read-only", "READ_ONLY");
         }
-        return await this.writeFs().removeAll(path42);
+        return await this.writeFs().removeAll(path43);
       }
       /**
        * Rename file (write operation)
@@ -14661,13 +14739,13 @@ var init_overlayfs_factory = __esm({
 function newFilesystemsCollector(sourceProject) {
   return new FilesystemsCollector(sourceProject);
 }
-var path24, log31, RootMapping, FilesystemsCollector;
+var path25, log31, RootMapping, FilesystemsCollector;
 var init_filesystemscollector = __esm({
   "internal/domain/fs/vo/filesystemscollector.ts"() {
     "use strict";
     init_overlayfs_factory();
     init_basefs();
-    path24 = __toESM(require("path"));
+    path25 = __toESM(require("path"));
     init_log();
     log31 = getDomainLogger("fs", { component: "filesystemscollector" });
     RootMapping = class {
@@ -14722,7 +14800,7 @@ var init_filesystemscollector = __esm({
           const fromToAssets = [];
           const fromToI18n = [];
           const absPathify = (inputPath) => {
-            if (path24.isAbsolute(inputPath)) {
+            if (path25.isAbsolute(inputPath)) {
               return ["", inputPath];
             }
             return [md.dir(), this.absPathify(md.dir(), inputPath)];
@@ -14801,7 +14879,7 @@ var init_filesystemscollector = __esm({
         return target === "i18n" || target.startsWith("i18n/") || target.startsWith("/i18n/");
       }
       absPathify(baseDir, relativePath) {
-        return path24.resolve(baseDir, relativePath);
+        return path25.resolve(baseDir, relativePath);
       }
     };
   }
@@ -14811,12 +14889,12 @@ var init_filesystemscollector = __esm({
 function newOsFs() {
   return new OsFs();
 }
-var fs9, path25, log32, OsFileInfo, OsFile, OsFs;
+var fs9, path26, log32, OsFileInfo, OsFile, OsFs;
 var init_osfs = __esm({
   "internal/domain/fs/vo/osfs.ts"() {
     "use strict";
     fs9 = __toESM(require("fs/promises"));
-    path25 = __toESM(require("path"));
+    path26 = __toESM(require("path"));
     init_log();
     log32 = getDomainLogger("fs", { component: "osfs" });
     OsFileInfo = class {
@@ -14939,7 +15017,7 @@ var init_osfs = __esm({
         const limit = count > 0 ? Math.min(count, entries.length) : entries.length;
         for (let i = 0; i < limit; i++) {
           const entry = entries[i];
-          const entryPath = path25.join(this.filePath, entry.name);
+          const entryPath = path26.join(this.filePath, entry.name);
           const stats = await fs9.stat(entryPath);
           result.push(new OsFileInfo(stats, entry.name));
         }
@@ -14955,7 +15033,7 @@ var init_osfs = __esm({
         if (this.closed)
           throw new Error("File is closed");
         const stats = await fs9.stat(this.filePath);
-        return new OsFileInfo(stats, path25.basename(this.filePath));
+        return new OsFileInfo(stats, path26.basename(this.filePath));
       }
       async sync() {
         if (this.closed)
@@ -15032,7 +15110,7 @@ var init_osfs = __esm({
       }
       async stat(name) {
         const stats = await fs9.stat(name);
-        return new OsFileInfo(stats, path25.basename(name));
+        return new OsFileInfo(stats, path26.basename(name));
       }
       name() {
         return "OsFs";
@@ -18404,8 +18482,8 @@ function wikilinkInlineRule(state, silent) {
 function renderWikilinkLink(tokens, idx) {
   const token = tokens[idx];
   const meta = token.meta;
-  const [path42, _anchor] = splitAnchor(meta.url);
-  const slug2 = slugifyFilePath(path42);
+  const [path43, _anchor] = splitAnchor(meta.url);
+  const slug2 = slugifyFilePath(path43);
   const displayText = meta.alias ?? meta.filepath;
   const escapedText = escapeHtml(displayText);
   return `<a class="internal" data-slug="${slug2}" data-wikilink="${escapeHtml(meta.url)}">${escapedText}</a>`;
@@ -19371,8 +19449,8 @@ var init_type10 = __esm({
       COMPONENT_FOLDER_ASSETS: "assets",
       COMPONENT_FOLDER_I18N: "i18n",
       // Path normalization utility
-      normalizePath: (path42) => {
-        let p2 = path42.replace(/\\/g, "/");
+      normalizePath: (path43) => {
+        let p2 = path43.replace(/\\/g, "/");
         if (p2.startsWith("//")) {
           p2 = p2.substring(1);
         }
@@ -19622,8 +19700,8 @@ var init_path2 = __esm({
         if (this.components.component) {
           return this.components.component;
         }
-        const path42 = this.components.normalized;
-        const parts = path42.split("/").filter((p2) => p2.length > 0);
+        const path43 = this.components.normalized;
+        const parts = path43.split("/").filter((p2) => p2.length > 0);
         if (parts.length === 0) {
           return "content";
         }
@@ -19951,10 +20029,10 @@ var init_path2 = __esm({
       /**
        * Create a path from string components
        */
-      static fromString(component, path42) {
+      static fromString(component, path43) {
         const components = new PathComponentsImpl(
-          path42,
-          path42,
+          path43,
+          path43,
           { containerLow: -1, containerHigh: -1, sectionHigh: -1, identifierLanguage: -1 },
           [],
           0 /* File */,
@@ -19965,8 +20043,8 @@ var init_path2 = __esm({
       /**
        * Check if a path has a specific extension
        */
-      static hasExtension(path42, extension) {
-        const pathExt = path42.ext();
+      static hasExtension(path43, extension) {
+        const pathExt = path43.ext();
         const targetExt = extension.startsWith(".") ? extension : "." + extension;
         return pathExt.toLowerCase() === targetExt.toLowerCase();
       }
@@ -20024,20 +20102,20 @@ var init_pathparser = __esm({
       /**
        * Parse a path with component information
        */
-      parse(component, path42) {
-        let normalizedPath = path42;
+      parse(component, path43) {
+        let normalizedPath = path43;
         if (!normalizedPath || normalizedPath === "") {
           normalizedPath = "/";
         }
         const normalized = this.normalizer.normalize(normalizedPath);
-        const pathComponents = this.createPathComponents(component, normalized, path42);
+        const pathComponents = this.createPathComponents(component, normalized, path43);
         return new Path(pathComponents);
       }
       /**
        * Parse and return only the identity
        */
-      parseIdentity(component, path42) {
-        const parsed = this.parse(component, path42);
+      parseIdentity(component, path43) {
+        const parsed = this.parse(component, path43);
         return {
           identifierBase: () => parsed.base()
         };
@@ -20045,8 +20123,8 @@ var init_pathparser = __esm({
       /**
        * Parse and return base and base name without identifier
        */
-      parseBaseAndBaseNameNoIdentifier(component, path42) {
-        const parsed = this.parse(component, path42);
+      parseBaseAndBaseNameNoIdentifier(component, path43) {
+        const parsed = this.parse(component, path43);
         return [parsed.base(), parsed.baseNameNoIdentifier()];
       }
       /**
@@ -20175,8 +20253,8 @@ var init_pathparser = __esm({
         this.toLowerCase = toLowerCase;
         this.replaceSpaces = replaceSpaces;
       }
-      normalize(path42) {
-        let result = path42;
+      normalize(path43) {
+        let result = path43;
         result = result.replace(/\\/g, "/");
         if (this.toLowerCase) {
           result = result.toLowerCase();
@@ -20192,8 +20270,8 @@ var init_pathparser = __esm({
         this.toLowerCase = toLowerCase;
         this.replaceSpaces = replaceSpaces;
       }
-      normalize(path42) {
-        let result = path42;
+      normalize(path43) {
+        let result = path43;
         result = result.replace(/\\/g, "/");
         if (this.toLowerCase) {
           result = result.toLowerCase();
@@ -20213,12 +20291,12 @@ var init_pathparser = __esm({
         const htmlExts = PATH_CONSTANTS.HTML_EXTENSIONS;
         return htmlExts.includes(ext.toLowerCase());
       }
-      hasExt(path42) {
-        for (let i = path42.length - 1; i >= 0; i--) {
-          if (path42[i] === ".") {
+      hasExt(path43) {
+        for (let i = path43.length - 1; i >= 0; i--) {
+          if (path43[i] === ".") {
             return true;
           }
-          if (path42[i] === "/") {
+          if (path43[i] === "/") {
             return false;
           }
         }
@@ -20229,10 +20307,10 @@ var init_pathparser = __esm({
       /**
        * Parse a path string into basic components
        */
-      static parseBasic(path42) {
-        const lastSlash = path42.lastIndexOf("/");
-        const dir2 = lastSlash >= 0 ? path42.substring(0, lastSlash) : "";
-        const name = lastSlash >= 0 ? path42.substring(lastSlash + 1) : path42;
+      static parseBasic(path43) {
+        const lastSlash = path43.lastIndexOf("/");
+        const dir2 = lastSlash >= 0 ? path43.substring(0, lastSlash) : "";
+        const name = lastSlash >= 0 ? path43.substring(lastSlash + 1) : path43;
         const lastDot = name.lastIndexOf(".");
         const ext = lastDot >= 0 ? name.substring(lastDot) : "";
         const nameWithoutExt = lastDot >= 0 ? name.substring(0, lastDot) : name;
@@ -20247,43 +20325,43 @@ var init_pathparser = __esm({
       /**
        * Normalize a path string using basic rules
        */
-      static normalizeBasic(path42) {
+      static normalizeBasic(path43) {
         const normalizer = new BasicPathNormalizer();
-        return normalizer.normalize(path42);
+        return normalizer.normalize(path43);
       }
       /**
        * Check if a path represents a bundle
        */
-      static isBundle(path42) {
-        const basic = _PathParserUtils.parseBasic(path42);
+      static isBundle(path43) {
+        const basic = _PathParserUtils.parseBasic(path43);
         const indexNames = PATH_CONSTANTS.INDEX_NAMES;
         return indexNames.includes(basic.nameWithoutExt);
       }
       /**
        * Extract section from path
        */
-      static extractSection(path42) {
-        const normalized = path42.startsWith("/") ? path42.substring(1) : path42;
+      static extractSection(path43) {
+        const normalized = path43.startsWith("/") ? path43.substring(1) : path43;
         const firstSlash = normalized.indexOf("/");
         return firstSlash >= 0 ? normalized.substring(0, firstSlash) : normalized;
       }
       /**
        * Remove extension from path
        */
-      static removeExtension(path42) {
-        const lastDot = path42.lastIndexOf(".");
-        const lastSlash = path42.lastIndexOf("/");
+      static removeExtension(path43) {
+        const lastDot = path43.lastIndexOf(".");
+        const lastSlash = path43.lastIndexOf("/");
         if (lastDot > lastSlash) {
-          return path42.substring(0, lastDot);
+          return path43.substring(0, lastDot);
         }
-        return path42;
+        return path43;
       }
       /**
        * Check if path has extension
        */
-      static hasExtension(path42) {
+      static hasExtension(path43) {
         const checker = new DefaultFileExtensionChecker();
-        return checker.hasExt(path42);
+        return checker.hasExt(path43);
       }
     };
   }
@@ -20314,11 +20392,11 @@ var init_pathfactory = __esm({
       /**
        * Create a Path from component and path string
        */
-      create(component, path42, config) {
+      create(component, path43, config) {
         if (this.pool) {
           const pooledPath = this.pool.get();
         }
-        return this.processor.parse(component, path42);
+        return this.processor.parse(component, path43);
       }
       /**
        * Create a Path from PathComponents
@@ -20330,12 +20408,12 @@ var init_pathfactory = __esm({
        * Create multiple paths from an array of path strings
        */
       createMany(component, paths, config) {
-        return paths.map((path42) => this.create(component, path42, config));
+        return paths.map((path43) => this.create(component, path43, config));
       }
       /**
        * Create a path with custom configuration
        */
-      createWithConfig(component, path42, normalizeConfig) {
+      createWithConfig(component, path43, normalizeConfig) {
         const config = {};
         if (normalizeConfig?.toLowerCase !== void 0) {
           config.normalize = normalizeConfig.toLowerCase;
@@ -20346,7 +20424,7 @@ var init_pathfactory = __esm({
         if (normalizeConfig?.customNormalizer !== void 0) {
           config.normalizer = normalizeConfig.customNormalizer;
         }
-        return this.create(component, path42, config);
+        return this.create(component, path43, config);
       }
     };
     DefaultPathFactory = class extends PathFactoryImpl {
@@ -20370,9 +20448,9 @@ var init_pathfactory = __esm({
         const components = PathComponentsFactory.createEmpty();
         return new Path(components);
       }
-      put(path42) {
+      put(path43) {
         if (this.pool.length < this.maxSize) {
-          this.pool.push(path42);
+          this.pool.push(path43);
         }
       }
       /**
@@ -20406,8 +20484,8 @@ var init_pathfactory = __esm({
       /**
        * Set the path
        */
-      withPath(path42) {
-        this.path = path42;
+      withPath(path43) {
+        this.path = path43;
         return this;
       }
       /**
@@ -20455,38 +20533,38 @@ var init_pathfactory = __esm({
       /**
        * Create a content path
        */
-      static createContentPath(path42) {
-        return _PathFactoryUtils.defaultFactory.create("content", path42);
+      static createContentPath(path43) {
+        return _PathFactoryUtils.defaultFactory.create("content", path43);
       }
       /**
        * Create a static resource path
        */
-      static createStaticPath(path42) {
-        return _PathFactoryUtils.defaultFactory.create("static", path42);
+      static createStaticPath(path43) {
+        return _PathFactoryUtils.defaultFactory.create("static", path43);
       }
       /**
        * Create a layout path
        */
-      static createLayoutPath(path42) {
-        return _PathFactoryUtils.defaultFactory.create("layouts", path42);
+      static createLayoutPath(path43) {
+        return _PathFactoryUtils.defaultFactory.create("layouts", path43);
       }
       /**
        * Create an archetype path
        */
-      static createArchetypePath(path42) {
-        return _PathFactoryUtils.defaultFactory.create("archetypes", path42);
+      static createArchetypePath(path43) {
+        return _PathFactoryUtils.defaultFactory.create("archetypes", path43);
       }
       /**
        * Create a data path
        */
-      static createDataPath(path42) {
-        return _PathFactoryUtils.defaultFactory.create("data", path42);
+      static createDataPath(path43) {
+        return _PathFactoryUtils.defaultFactory.create("data", path43);
       }
       /**
        * Create a theme path
        */
-      static createThemePath(path42) {
-        return _PathFactoryUtils.defaultFactory.create("themes", path42);
+      static createThemePath(path43) {
+        return _PathFactoryUtils.defaultFactory.create("themes", path43);
       }
       /**
        * Create paths from a configuration object
@@ -20500,7 +20578,7 @@ var init_pathfactory = __esm({
           factoryConfig.replaceSpaces = config.replaceSpaces;
         }
         const factory = new PathFactoryImpl(factoryConfig);
-        return config.paths.map((path42) => factory.create(config.component, path42));
+        return config.paths.map((path43) => factory.create(config.component, path43));
       }
       /**
        * Get a path builder instance
@@ -20511,9 +20589,9 @@ var init_pathfactory = __esm({
       /**
        * Create a path with pooling
        */
-      static createWithPool(component, path42, pool2) {
+      static createWithPool(component, path43, pool2) {
         const factory = new PathFactoryImpl(void 0, pool2);
-        return factory.create(component, path42);
+        return factory.create(component, path43);
       }
     };
   }
@@ -20619,12 +20697,12 @@ var init_translator = __esm({
       async setupTranslateFuncs(fsService) {
         try {
           await fsService.walkI18n("", {
-            walkFn: async (path42, info) => {
-              if (!path42.endsWith(".yaml") && !path42.endsWith(".yml")) {
+            walkFn: async (path43, info) => {
+              if (!path43.endsWith(".yaml") && !path43.endsWith(".yml")) {
                 return;
               }
               try {
-                const normalizedPath = PATH_CONSTANTS.normalizePath(path42);
+                const normalizedPath = PATH_CONSTANTS.normalizePath(path43);
                 const filename = normalizedPath.split("/").pop() || "";
                 const langKey = filename.replace(/\.(yaml|yml)$/, "").toLowerCase();
                 const content = await this.readI18nFile(info);
@@ -20644,7 +20722,7 @@ var init_translator = __esm({
                 this.translateFuncs.set(langKey, translateFunc);
                 log38.info(`\u2705 Loaded i18n translations for language: ${langKey} (${translations.length} items)`);
               } catch (error) {
-                log38.error(`\u274C Failed to load i18n file ${path42}:`, error);
+                log38.error(`\u274C Failed to load i18n file ${path43}:`, error);
               }
             }
           }, {});
@@ -20850,13 +20928,13 @@ function isContentExt(ext) {
 function newFileInfo2(fi) {
   return FileInfo7.newFileInfo(fi);
 }
-var crypto2, path26, log41, contentFileExtensions, contentFileExtensionsSet, FileInfo7;
+var crypto2, path27, log41, contentFileExtensions, contentFileExtensionsSet, FileInfo7;
 var init_fileinfo2 = __esm({
   "internal/domain/content/vo/fileinfo.ts"() {
     "use strict";
     init_paths();
     crypto2 = __toESM(require("crypto"));
-    path26 = __toESM(require("path"));
+    path27 = __toESM(require("path"));
     init_log();
     log41 = getDomainLogger("content", { component: "FileInfo" });
     contentFileExtensions = [
@@ -20894,7 +20972,7 @@ var init_fileinfo2 = __esm({
       relPath() {
         const dir2 = this.pathInfo.dir();
         const dirWithoutLeadingSlash = dir2.startsWith("/") ? dir2.substring(1) : dir2;
-        return path26.join(dirWithoutLeadingSlash, this.pathInfo.name());
+        return path27.join(dirWithoutLeadingSlash, this.pathInfo.name());
       }
       section() {
         return this.pathInfo.section();
@@ -20991,7 +21069,7 @@ var init_fileinfo2 = __esm({
         if (s2 === "") {
           return s2;
         }
-        return path26.normalize(s2.substring(1) + "/");
+        return path27.normalize(s2.substring(1) + "/");
       }
       determineBundleType() {
         const isContent = isContentExt(this.pathInfo.ext());
@@ -21271,7 +21349,7 @@ function getParam(p2, key2, stringToLower) {
       return v;
   }
 }
-var import_path19, FrontMatterParserImpl;
+var import_path20, FrontMatterParserImpl;
 var init_frontmatter = __esm({
   "internal/domain/content/vo/frontmatter.ts"() {
     "use strict";
@@ -21279,7 +21357,7 @@ var init_frontmatter = __esm({
     init_cast2();
     init_string2();
     init_types3();
-    import_path19 = __toESM(require("path"));
+    import_path20 = __toESM(require("path"));
     FrontMatterParserImpl = class {
       params;
       langSvc;
@@ -21466,7 +21544,7 @@ var init_frontmatter = __esm({
           organization.website = Cast.toString(orgValue.website);
         }
         if (orgValue.logo !== void 0 && orgValue.logo !== null) {
-          organization.logo = import_path19.default.join(baseURL, Cast.toString(orgValue.logo));
+          organization.logo = import_path20.default.join(baseURL, Cast.toString(orgValue.logo));
         }
         const contact = this.parseContact(orgValue.contact);
         if (contact) {
@@ -21584,7 +21662,7 @@ var init_frontmatter = __esm({
           author.website = Cast.toString(authorValue.website);
         }
         if (authorValue.avatar !== void 0 && authorValue.avatar !== null) {
-          author.avatar = import_path19.default.join(baseURL, Cast.toString(authorValue.avatar));
+          author.avatar = import_path20.default.join(baseURL, Cast.toString(authorValue.avatar));
         }
         const contact = this.parseContact(authorValue.contact);
         if (contact) {
@@ -21640,8 +21718,8 @@ var init_frontmatter = __esm({
        * Convert path to slash preserving leading slash
        * Equivalent to Go's paths.ToSlashPreserveLeading
        */
-      toSlashPreserveLeading(path42) {
-        return path42.replace(/\\/g, "/");
+      toSlashPreserveLeading(path43) {
+        return path43.replace(/\\/g, "/");
       }
     };
   }
@@ -22066,9 +22144,9 @@ var init_radix = __esm({
       // from the root down to a given leaf. Where WalkPrefix walks
       // all the entries *under* the given prefix, this walks the
       // entries *above* the given prefix.
-      async walkPath(path42, fn) {
+      async walkPath(path43, fn) {
         let n = this.root;
-        let search2 = path42;
+        let search2 = path43;
         while (true) {
           if (n.leaf !== null && await fn(n.leaf.key, n.leaf.val)) {
             return;
@@ -23203,8 +23281,8 @@ var init_pagesource = __esm({
        * 3. Handle index files (index → parent folder)
        * 4. Handle _index files (Hugo-style section index)
        */
-      pathToSlug(path42) {
-        let slug2 = path42.replace(/^\//, "");
+      pathToSlug(path43) {
+        let slug2 = path43.replace(/^\//, "");
         slug2 = slug2.replace(/\.md$/, "");
         if (slug2.endsWith("/index")) {
           slug2 = slug2.replace(/\/index$/, "");
@@ -23251,17 +23329,17 @@ var init_pagesource = __esm({
 });
 
 // internal/domain/content/entity/pagemap.ts
-function addTrailingSlash(path42) {
-  if (!path42.endsWith("/")) {
-    path42 += "/";
+function addTrailingSlash(path43) {
+  if (!path43.endsWith("/")) {
+    path43 += "/";
   }
-  return path42;
+  return path43;
 }
-function addLeadingSlash(path42) {
-  if (!path42.startsWith("/")) {
-    path42 = "/" + path42;
+function addLeadingSlash(path43) {
+  if (!path43.startsWith("/")) {
+    path43 = "/" + path43;
   }
-  return path42;
+  return path43;
 }
 var log43, ambiguousContentNode, ContentTreeReverseIndexMap, ContentTreeReverseIndex, pagePredicates, PageMapQueryPagesBelowPathImpl, PageMapQueryPagesInSectionImpl, PageMap;
 var init_pagemap = __esm({
@@ -23314,8 +23392,8 @@ var init_pagemap = __esm({
       path;
       keyPart;
       include;
-      constructor(path42, keyPart, include = pagePredicates.shouldListLocal) {
-        this.path = path42;
+      constructor(path43, keyPart, include = pagePredicates.shouldListLocal) {
+        this.path = path43;
         this.keyPart = keyPart;
         this.include = include;
       }
@@ -23327,8 +23405,8 @@ var init_pagemap = __esm({
       recursive;
       includeSelf;
       index;
-      constructor(path42, keyPart, recursive, includeSelf, index2, include) {
-        super(path42, keyPart, include);
+      constructor(path43, keyPart, recursive, includeSelf, index2, include) {
+        super(path43, keyPart, include);
         this.recursive = recursive;
         this.includeSelf = includeSelf;
         this.index = index2;
@@ -23696,12 +23774,12 @@ var init_pagemap = __esm({
       /**
        * Helper method to get directory from path
        */
-      pathDir(path42) {
-        const lastSlash = path42.lastIndexOf("/");
+      pathDir(path43) {
+        const lastSlash = path43.lastIndexOf("/");
         if (lastSlash === -1) {
           return "";
         }
-        return path42.substring(0, lastSlash);
+        return path43.substring(0, lastSlash);
       }
     };
   }
@@ -23740,11 +23818,11 @@ var init_pagecollector = __esm({
       /**
        * CollectDir - exact replica of Go's collectDir method
        */
-      async collectDir(fs13, path42, root2) {
+      async collectDir(fs13, path43, root2) {
         try {
-          await this.fs.walkContent(fs13, path42, {
-            hookPre: async (dir2, path43, readdir2) => {
-              const fullPath = path43;
+          await this.fs.walkContent(fs13, path43, {
+            hookPre: async (dir2, path44, readdir2) => {
+              const fullPath = path44;
               if (this.processedPaths.has(fullPath)) {
                 log44.warn("Path already processed!", {
                   path: fullPath,
@@ -23775,7 +23853,7 @@ var init_pagecollector = __esm({
           });
         } catch (error) {
           log44.error(`Failed to collect directory: ${error}`, {
-            path: path42,
+            path: path43,
             rootName: root2.name(),
             rootIsDir: root2.isDir(),
             stack: error.stack || "No stack trace available"
@@ -23785,7 +23863,7 @@ var init_pagecollector = __esm({
       }
       async handleBundleLeaf(dir2, bundle, inPath, readdir2) {
         const bundlePath = bundle.paths();
-        const walk = async (path42, info) => {
+        const walk = async (path43, info) => {
           if (info.isDir()) {
             return;
           }
@@ -24037,10 +24115,10 @@ var init_content2 = __esm({
        * GetPageFromPath - TypeScript equivalent of Go's PageFinder.GetPageFromPath
        * This is the core content domain business logic for finding pages by path
        */
-      getPageFromPath(langIndex, path42) {
+      getPageFromPath(langIndex, path43) {
         try {
           const pathProcessor = PathDomain.createProcessor();
-          const ps = pathProcessor.parse(PATH_CONSTANTS.COMPONENT_FOLDER_CONTENT, path42);
+          const ps = pathProcessor.parse(PATH_CONSTANTS.COMPONENT_FOLDER_CONTENT, path43);
           const tree = this.pageMap.treePages.shape(0, langIndex);
           let node = tree.get(ps.base());
           if (node) {
@@ -24051,7 +24129,7 @@ var init_content2 = __esm({
           }
           return null;
         } catch (error) {
-          log45.error(`\u274C Content.getPageFromPath error for path "${path42}":`, error);
+          log45.error(`\u274C Content.getPageFromPath error for path "${path43}":`, error);
           return null;
         }
       }
@@ -24858,15 +24936,15 @@ var init_scratch = __esm({
 function sanitize(input) {
   return input.replace(/[\s\t\n\r]+/g, "-").replace(/[^\w\-_]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
-function addContextRoot(root2, path42) {
-  if (!root2 || path42.startsWith(root2)) {
-    return path42;
+function addContextRoot(root2, path43) {
+  if (!root2 || path43.startsWith(root2)) {
+    return path43;
   }
-  return joinPaths(root2, path42);
+  return joinPaths(root2, path43);
 }
-function makePermalink(baseURL, path42) {
+function makePermalink(baseURL, path43) {
   const base2 = baseURL.replace(/\/$/, "");
-  const cleanPath = path42.replace(/^\//, "");
+  const cleanPath = path43.replace(/^\//, "");
   const fullURL = `${base2}/${cleanPath}`;
   try {
     return new URL(fullURL);
@@ -24895,7 +24973,7 @@ var init_paths2 = __esm({
 });
 
 // internal/domain/content/entity/page.ts
-var import_path20, log48, PageImpl, TaxonomyPageImpl, TermPageImpl;
+var import_path21, log48, PageImpl, TaxonomyPageImpl, TermPageImpl;
 var init_page = __esm({
   "internal/domain/content/entity/page.ts"() {
     "use strict";
@@ -24907,7 +24985,7 @@ var init_page = __esm({
     init_paths2();
     init_doctree();
     init_sort();
-    import_path20 = __toESM(require("path"));
+    import_path21 = __toESM(require("path"));
     init_log();
     log48 = getDomainLogger("content", { component: "page" });
     PageImpl = class {
@@ -24985,8 +25063,8 @@ var init_page = __esm({
        * 3. Handle index files (index → parent folder)
        * 4. Handle _index files (Hugo-style section index)
        */
-      pathToSlug(path42) {
-        let slug2 = path42.replace(/^\//, "");
+      pathToSlug(path43) {
+        let slug2 = path43.replace(/^\//, "");
         slug2 = slug2.replace(/\.md$/, "");
         if (slug2.endsWith("/index")) {
           slug2 = slug2.replace(/\/index$/, "");
@@ -25013,7 +25091,7 @@ var init_page = __esm({
         if (/^(https?:)?\/\//.test(src)) {
           return src;
         }
-        src = import_path20.default.normalize(src);
+        src = import_path21.default.normalize(src);
         src = src.replace(/\\/g, "/");
         if (src.startsWith("/")) {
           src = src.slice(1);
@@ -25733,12 +25811,12 @@ var init_type11 = __esm({
 function newBaseOf() {
   return new BaseOf();
 }
-var path29, BaseOf;
+var path30, BaseOf;
 var init_baseof = __esm({
   "internal/domain/template/vo/baseof.ts"() {
     "use strict";
     init_type11();
-    path29 = __toESM(require("path"));
+    path30 = __toESM(require("path"));
     BaseOf = class {
       baseof = /* @__PURE__ */ new Map();
       needsBaseof = /* @__PURE__ */ new Map();
@@ -25778,7 +25856,7 @@ var init_baseof = __esm({
        * Check if path is a base template path
        */
       isBaseTemplatePath(filePath) {
-        return path29.basename(filePath).includes(BASE_FILE_BASE);
+        return path30.basename(filePath).includes(BASE_FILE_BASE);
       }
       /**
        * Check if template needs base template
@@ -27533,8 +27611,8 @@ var init_registry = __esm({
             }
           },
           // PathEscape escapes special characters in a URL path
-          PathEscape: (path42) => {
-            return encodeURIComponent(path42).replace(/%2F/g, "/").replace(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+          PathEscape: (path43) => {
+            return encodeURIComponent(path43).replace(/%2F/g, "/").replace(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
           },
           // QueryEscape escapes special characters in a URL query
           QueryEscape: (query) => {
@@ -28690,11 +28768,11 @@ var init_registry = __esm({
               }
             }
           }
-          const getNestedValue = (obj, path42) => {
-            if (!path42 || path42 === "value") {
+          const getNestedValue = (obj, path43) => {
+            if (!path43 || path43 === "value") {
               return obj;
             }
-            const keys = path42.split(".");
+            const keys = path43.split(".");
             let current = obj;
             for (const key2 of keys) {
               if (current === null || current === void 0) {
@@ -29259,23 +29337,23 @@ var init_registry = __esm({
       registerPathFunctions(funcMap) {
         funcMap.set("path", () => ({
           // Base returns the last element of path
-          Base: (path42) => {
-            if (!path42)
+          Base: (path43) => {
+            if (!path43)
               return ".";
-            path42 = path42.replace(/\\/g, "/");
-            path42 = path42.replace(/\/+$/, "");
-            if (!path42)
+            path43 = path43.replace(/\\/g, "/");
+            path43 = path43.replace(/\/+$/, "");
+            if (!path43)
               return "/";
-            const parts = path42.split("/");
+            const parts = path43.split("/");
             return parts[parts.length - 1] || "/";
           },
           // Clean returns the shortest path name equivalent to path
-          Clean: (path42) => {
-            if (!path42)
+          Clean: (path43) => {
+            if (!path43)
               return ".";
-            path42 = path42.replace(/\\/g, "/");
-            const isAbs = path42.startsWith("/");
-            const parts = path42.split("/").filter((p2) => p2 && p2 !== ".");
+            path43 = path43.replace(/\\/g, "/");
+            const isAbs = path43.startsWith("/");
+            const parts = path43.split("/").filter((p2) => p2 && p2 !== ".");
             const stack = [];
             for (const part of parts) {
               if (part === "..") {
@@ -29288,56 +29366,56 @@ var init_registry = __esm({
                 stack.push(part);
               }
             }
-            path42 = stack.join("/");
+            path43 = stack.join("/");
             if (isAbs)
-              path42 = "/" + path42;
-            return path42 || (isAbs ? "/" : ".");
+              path43 = "/" + path43;
+            return path43 || (isAbs ? "/" : ".");
           },
           // Dir returns all but the last element of path
-          Dir: (path42) => {
-            if (!path42)
+          Dir: (path43) => {
+            if (!path43)
               return ".";
-            path42 = path42.replace(/\/+$/, "");
-            if (!path42)
+            path43 = path43.replace(/\/+$/, "");
+            if (!path43)
               return "/";
-            const parts = path42.split("/");
+            const parts = path43.split("/");
             parts.pop();
             return parts.join("/") || ".";
           },
           // Ext returns the file name extension
-          Ext: (path42) => {
-            const base2 = path42.split("/").pop() || "";
+          Ext: (path43) => {
+            const base2 = path43.split("/").pop() || "";
             const dot = base2.lastIndexOf(".");
             if (dot === -1 || dot === 0)
               return "";
             return base2.substring(dot);
           },
           // IsAbs reports whether the path is absolute
-          IsAbs: (path42) => {
-            return path42.startsWith("/");
+          IsAbs: (path43) => {
+            return path43.startsWith("/");
           },
           // Join joins any number of path elements into a single path
           Join: (...elements) => {
             if (elements.length === 0)
               return ".";
             const parts = elements.filter((e) => e).map((e) => e.replace(/^\/+|\/+$/g, ""));
-            let path42 = parts.join("/");
+            let path43 = parts.join("/");
             if (elements[0] && elements[0].startsWith("/")) {
-              path42 = "/" + path42;
+              path43 = "/" + path43;
             }
-            return path42 || ".";
+            return path43 || ".";
           },
           // Split splits path immediately following the final slash
-          Split: (path42) => {
-            if (!path42)
+          Split: (path43) => {
+            if (!path43)
               return [".", ""];
-            const lastSlash = path42.lastIndexOf("/");
+            const lastSlash = path43.lastIndexOf("/");
             if (lastSlash === -1) {
-              return ["", path42];
+              return ["", path43];
             }
             return [
-              path42.substring(0, lastSlash),
-              path42.substring(lastSlash + 1)
+              path43.substring(0, lastSlash),
+              path43.substring(lastSlash + 1)
             ];
           }
         }));
@@ -29623,11 +29701,11 @@ var init_registry = __esm({
        * Get nested value from object using dot notation path
        * Following golang's path resolution logic
        */
-      getNestedValue(obj, path42) {
-        if (!obj || !path42) {
+      getNestedValue(obj, path43) {
+        if (!obj || !path43) {
           return void 0;
         }
-        const cleanPath = path42.replace(/^\\.+/, "");
+        const cleanPath = path43.replace(/^\\.+/, "");
         const parts = cleanPath.split(".");
         let current = obj;
         for (let i = 0; i < parts.length; i++) {
@@ -30162,14 +30240,14 @@ var init_pagebuilder = __esm({
        * Parse kind - exact replica of Go's parseKind method
        */
       async parseKind() {
-        const path42 = this.source.file.paths();
+        const path43 = this.source.file.paths();
         let kind = "";
         if (this.fm) {
           kind = this.fm.kind || "";
         }
         if (kind === "") {
           kind = getKindMain("page");
-          const base2 = path42.baseNoLeadingSlash();
+          const base2 = path43.baseNoLeadingSlash();
           switch (base2) {
             case PAGE_HOME_BASE:
             case "":
@@ -30184,9 +30262,9 @@ var init_pagebuilder = __esm({
             default:
               if (this.source.file.isBranchBundle()) {
                 kind = getKindMain("section");
-                const v = this.taxonomy.getTaxonomy(path42.path());
+                const v = this.taxonomy.getTaxonomy(path43.path());
                 if (!this.taxonomy.isZero(v)) {
-                  if (this.taxonomy.isTaxonomyPath(path42.path())) {
+                  if (this.taxonomy.isTaxonomyPath(path43.path())) {
                     kind = getKindMain("taxonomy");
                   } else {
                     kind = getKindMain("term");
@@ -30473,7 +30551,7 @@ function cleanTreeKey2(...elem) {
   if (elem.length > 0) {
     s2 = elem[0];
     if (elem.length > 1) {
-      s2 = path30.join(...elem);
+      s2 = path31.join(...elem);
     }
   }
   s2 = s2.replace(/^[\.\/ \s]+|[\.\/ \s]+$/g, "");
@@ -30486,14 +30564,14 @@ function cleanTreeKey2(...elem) {
   }
   return s2;
 }
-var path30, filepath, Taxonomy2;
+var path31, filepath, Taxonomy2;
 var init_taxonomy3 = __esm({
   "internal/domain/content/entity/taxonomy.ts"() {
     "use strict";
     init_pagetrees();
     init_fileinfo2();
     init_pagesource();
-    path30 = __toESM(require("path"));
+    path31 = __toESM(require("path"));
     filepath = __toESM(require("path"));
     Taxonomy2 = class {
       views;
@@ -30524,7 +30602,7 @@ var init_taxonomy3 = __esm({
         if (!ta) {
           return false;
         }
-        return p2 === path30.join(this.pluralTreeKey(ta.plural()), "_index.md");
+        return p2 === path31.join(this.pluralTreeKey(ta.plural()), "_index.md");
       }
       /**
        * PluralTreeKey - exact replica of Go's PluralTreeKey method
@@ -30829,11 +30907,11 @@ var init_pager = __esm({
 });
 
 // internal/domain/site/entity/page.ts
-var import_path21, log57, Page2;
+var import_path22, log57, Page2;
 var init_page2 = __esm({
   "internal/domain/site/entity/page.ts"() {
     "use strict";
-    import_path21 = __toESM(require("path"));
+    import_path22 = __toESM(require("path"));
     init_log();
     init_pager();
     log57 = getDomainLogger("site", { component: "page" });
@@ -30953,14 +31031,14 @@ var init_page2 = __esm({
         } else {
           prefix = this.site.getLanguage().getCurrentLanguage();
         }
-        targetFilenames.push(import_path21.default.join(prefix, this.getPageOutput().targetFilePath()));
+        targetFilenames.push(import_path22.default.join(prefix, this.getPageOutput().targetFilePath()));
         await this.renderAndWritePage(tmpl, targetFilenames);
         const current = await this.current();
         if (current) {
           let currentPager = current.next();
           while (currentPager) {
             this.setCurrent(currentPager);
-            const paginationTargets = [import_path21.default.join(prefix, currentPager.url(), this.getPageOutput().targetFileBase())];
+            const paginationTargets = [import_path22.default.join(prefix, currentPager.url(), this.getPageOutput().targetFileBase())];
             await this.renderAndWritePage(tmpl, paginationTargets);
             currentPager = currentPager.next();
           }
@@ -30993,7 +31071,7 @@ var init_page2 = __esm({
             prefix = this.site.getLanguage().getCurrentLanguage();
           }
           let resourcePath = pageSource.path();
-          targetFilenames.push(import_path21.default.join(prefix, resourcePath));
+          targetFilenames.push(import_path22.default.join(prefix, resourcePath));
           let stream = null;
           try {
             const opener = () => pageSource.pageFile().open();
@@ -31648,11 +31726,11 @@ var init_baseurl = __esm({
       /**
        * Returns the appropriate root URL based on the path.
        */
-      getRoot(path42) {
+      getRoot(path43) {
         if (this.isRelative) {
           return this.basePath;
         }
-        if (path42.startsWith("/")) {
+        if (path43.startsWith("/")) {
           return this.withoutPath;
         }
         return this.withPath;
@@ -33046,8 +33124,8 @@ function assertNonEmpty(part, name) {
     throw new Error("`" + name + "` cannot be empty");
   }
 }
-function assertPath(path42, name) {
-  if (!path42) {
+function assertPath(path43, name) {
+  if (!path43) {
     throw new Error("Setting `" + name + "` requires `path` to be set too");
   }
 }
@@ -33232,13 +33310,13 @@ var init_lib4 = __esm({
        * @returns {undefined}
        *   Nothing.
        */
-      set path(path42) {
-        if (isUrl(path42)) {
-          path42 = (0, import_node_url.fileURLToPath)(path42);
+      set path(path43) {
+        if (isUrl(path43)) {
+          path43 = (0, import_node_url.fileURLToPath)(path43);
         }
-        assertNonEmpty(path42, "path");
-        if (this.path !== path42) {
-          this.history.push(path42);
+        assertNonEmpty(path43, "path");
+        if (this.path !== path43) {
+          this.history.push(path43);
         }
       }
       /**
@@ -45999,7 +46077,7 @@ var init_is_absolute_url = __esm({
 function createHtmlLinkProcessor(graph, options) {
   return new HtmlLinkProcessor(graph, options);
 }
-var import_path23, log61, defaultOptions, HtmlLinkProcessor;
+var import_path24, log61, defaultOptions, HtmlLinkProcessor;
 var init_html_link_processor = __esm({
   "internal/domain/site/service/html-link-processor.ts"() {
     "use strict";
@@ -46008,7 +46086,7 @@ var init_html_link_processor = __esm({
     init_rehype_stringify();
     init_unist_util_visit();
     init_is_absolute_url();
-    import_path23 = __toESM(require("path"));
+    import_path24 = __toESM(require("path"));
     init_path3();
     init_log();
     log61 = getDomainLogger("site", { component: "HtmlLinkProcessor" });
@@ -46146,7 +46224,7 @@ var init_html_link_processor = __esm({
                 node.properties["data-slug"] = full;
               }
               if (opts.prettyLinks && isInternal && node.children.length === 1 && node.children[0].type === "text" && !node.children[0].value.startsWith("#")) {
-                node.children[0].value = import_path23.default.basename(node.children[0].value);
+                node.children[0].value = import_path24.default.basename(node.children[0].value);
               }
             }
             if (["img", "video", "audio", "iframe"].includes(node.tagName) && node.properties && typeof node.properties.src === "string") {
@@ -47040,14 +47118,14 @@ var init_site = __esm({
 
 // internal/domain/site/entity/publisher.ts
 async function openFileForWriting(fs13, filename) {
-  const cleanFilename = import_path25.default.normalize(filename);
+  const cleanFilename = import_path26.default.normalize(filename);
   try {
     return await fs13.create(cleanFilename);
   } catch (error) {
     if (!isFileNotFoundError(error)) {
       throw error;
     }
-    const dir2 = import_path25.default.dirname(cleanFilename);
+    const dir2 = import_path26.default.dirname(cleanFilename);
     await fs13.mkdirAll(dir2, 511);
     return await fs13.create(cleanFilename);
   }
@@ -47055,11 +47133,11 @@ async function openFileForWriting(fs13, filename) {
 function isFileNotFoundError(error) {
   return error && (error.code === "ENOENT" || error.code === "FILE_NOT_FOUND" || error.message?.includes("not found") || error.message?.includes("no such file"));
 }
-var import_path25, log64, Publisher, MultiWriter;
+var import_path26, log64, Publisher, MultiWriter;
 var init_publisher2 = __esm({
   "internal/domain/site/entity/publisher.ts"() {
     "use strict";
-    import_path25 = __toESM(require("path"));
+    import_path26 = __toESM(require("path"));
     init_log();
     log64 = getDomainLogger("site", { component: "publisher" });
     Publisher = class {
@@ -47920,8 +47998,8 @@ var init_menu_builder = __esm({
       /**
        * Fallback URL generation from path (used when site page conversion fails)
        */
-      fallbackUrlFromPath(path42) {
-        let url = path42.replace(/\.md$/, "");
+      fallbackUrlFromPath(path43) {
+        let url = path43.replace(/\.md$/, "");
         if (!url.startsWith("/")) {
           url = "/" + url;
         }
@@ -48844,11 +48922,11 @@ var init_template4 = __esm({
 });
 
 // internal/domain/resources/entity/publisher.ts
-var path34, import_stream2, log73, Publisher2, FileWritable;
+var path35, import_stream2, log73, Publisher2, FileWritable;
 var init_publisher3 = __esm({
   "internal/domain/resources/entity/publisher.ts"() {
     "use strict";
-    path34 = __toESM(require("path"));
+    path35 = __toESM(require("path"));
     init_log();
     import_stream2 = require("stream");
     log73 = getDomainLogger("resources", { component: "publisher" });
@@ -48883,7 +48961,7 @@ var init_publisher3 = __esm({
           return new FileWritable(file);
         } catch (error) {
           if (error.code === "ENOENT" || error.message.includes("ENOENT")) {
-            const dir2 = path34.dirname(cleanFilename);
+            const dir2 = path35.dirname(cleanFilename);
             await this.pubFs.mkdirAll(dir2, 511);
             const file = await this.pubFs.create(cleanFilename);
             const originalClose = file.close.bind(file);
@@ -48917,14 +48995,14 @@ var init_publisher3 = __esm({
        * TypeScript equivalent of OpenFileForWriting function from Go
        */
       async openFileForWriting(filename) {
-        const cleanFilename = path34.normalize(filename);
+        const cleanFilename = path35.normalize(filename);
         try {
           return await this.pubFs.create(cleanFilename);
         } catch (error) {
           if (!this.isFileNotFoundError(error)) {
             throw error;
           }
-          const dir2 = path34.dirname(cleanFilename);
+          const dir2 = path35.dirname(cleanFilename);
           await this.pubFs.mkdirAll(dir2, 511);
           return await this.pubFs.create(cleanFilename);
         }
@@ -49052,7 +49130,7 @@ var init_http2 = __esm({
 });
 
 // internal/domain/resources/entity/resources.ts
-var path35, import_crypto4, log75, Resources;
+var path36, import_crypto4, log75, Resources;
 var init_resources = __esm({
   "internal/domain/resources/entity/resources.ts"() {
     "use strict";
@@ -49064,7 +49142,7 @@ var init_resources = __esm({
     init_publisher3();
     init_http2();
     init_type9();
-    path35 = __toESM(require("path"));
+    path36 = __toESM(require("path"));
     import_crypto4 = require("crypto");
     init_log();
     log75 = getDomainLogger("resources", { component: "resources" });
@@ -49099,7 +49177,7 @@ var init_resources = __esm({
        * Supports caching for performance optimization
        */
       async getResource(pathname) {
-        const cleanPath = path35.posix.normalize(pathname);
+        const cleanPath = path36.posix.normalize(pathname);
         const cacheKey = `${cleanPath}__get`;
         if (this.cache.has(cacheKey)) {
           return this.cache.get(cacheKey) || null;
@@ -49128,7 +49206,7 @@ var init_resources = __esm({
        * GetResourceWithOpener - Alternative way to get resource with custom opener
        */
       async getResourceWithOpener(pathname, opener) {
-        const cleanPath = path35.posix.normalize(pathname);
+        const cleanPath = path36.posix.normalize(pathname);
         const cacheKey = `${cleanPath}__get_with_opener`;
         if (this.cache.has(cacheKey)) {
           return this.cache.get(cacheKey) || null;
@@ -49266,7 +49344,7 @@ var init_resources = __esm({
        */
       async buildResource(pathname, opener) {
         try {
-          const ext = path35.extname(pathname);
+          const ext = path36.extname(pathname);
           const mediaType = this.getMediaTypeFromExtension(ext);
           const resourcePaths = ResourcePaths.newResourcePaths(pathname, this.workspace);
           const resource = new ResourceImpl(
@@ -49368,11 +49446,11 @@ var init_resources = __esm({
 });
 
 // internal/domain/resources/valueobject/resourcepaths.ts
-var path36, ResourcePaths;
+var path37, ResourcePaths;
 var init_resourcepaths = __esm({
   "internal/domain/resources/valueobject/resourcepaths.ts"() {
     "use strict";
-    path36 = __toESM(require("path"));
+    path37 = __toESM(require("path"));
     ResourcePaths = class _ResourcePaths {
       // This is the directory component for the target file or link.
       dir;
@@ -49395,7 +49473,7 @@ var init_resourcepaths = __esm({
       }
       static newResourcePaths(targetPath, svc) {
         const normalizedPath = targetPath.replace(/\\/g, "/");
-        const parsedPath = path36.posix.parse(normalizedPath);
+        const parsedPath = path37.posix.parse(normalizedPath);
         let dir2 = parsedPath.dir;
         if (dir2 === "/") {
           dir2 = "";
@@ -49452,7 +49530,7 @@ var init_resourcepaths = __esm({
       }
       fromTargetPath(targetPath) {
         const normalizedPath = targetPath.replace(/\\/g, "/");
-        const parsedPath = path36.posix.parse(normalizedPath);
+        const parsedPath = path37.posix.parse(normalizedPath);
         let dir2 = parsedPath.dir;
         if (dir2 === "/") {
           dir2 = "";
@@ -49598,7 +49676,7 @@ function getDomainInstances() {
 }
 async function loadConfiguration(projDir, modulesDir) {
   const osFs = newOsFs();
-  const configFilePath = import_path26.default.join(projDir, "config.json");
+  const configFilePath = import_path27.default.join(projDir, "config.json");
   return await loadConfigWithParams(osFs, configFilePath, projDir, modulesDir);
 }
 async function createModule(config) {
@@ -49844,11 +49922,11 @@ function createSiteForSSG(config, fs13, content) {
     searchPage: async (pages, page) => {
       return [];
     },
-    getPageFromPath: async (langIndex, path42) => {
+    getPageFromPath: async (langIndex, path43) => {
       try {
-        const page = content.getPageFromPath(langIndex, path42);
+        const page = content.getPageFromPath(langIndex, path43);
         if (!page) {
-          log76.error(`\u26A0\uFE0F  Application.getPageFromPath: content domain returned null for path: "${path42}"`);
+          log76.error(`\u26A0\uFE0F  Application.getPageFromPath: content domain returned null for path: "${path43}"`);
         }
         return page;
       } catch (error) {
@@ -49856,11 +49934,11 @@ function createSiteForSSG(config, fs13, content) {
         return null;
       }
     },
-    getPageFromPathSync: (langIndex, path42) => {
+    getPageFromPathSync: (langIndex, path43) => {
       try {
-        const page = content.getPageFromPath(langIndex, path42);
+        const page = content.getPageFromPath(langIndex, path43);
         if (!page) {
-          log76.warn(`\u26A0\uFE0F  Application.getPageFromPathSync: content domain returned null for path: ${path42}`);
+          log76.warn(`\u26A0\uFE0F  Application.getPageFromPathSync: content domain returned null for path: ${path43}`);
         }
         return page;
       } catch (error) {
@@ -49895,14 +49973,14 @@ function createSiteForSSG(config, fs13, content) {
     },
     workingDir: () => config.getProvider().getString("workingDir") || process.cwd(),
     // ResourceService implementation (placeholder)
-    getResource: async (path42) => {
+    getResource: async (path43) => {
       return null;
     },
-    getResourceWithOpener: async (path42, opener) => {
+    getResourceWithOpener: async (path43, opener) => {
       return {
-        name: () => path42,
+        name: () => path43,
         readSeekCloser: opener,
-        targetPath: () => path42
+        targetPath: () => path43
       };
     },
     // URLService implementation
@@ -50181,7 +50259,7 @@ async function collectAllPageTasks(projDir, modulesDir, markdown, onProgress, ht
     throw new Error(`Failed to generate static site: ${message}`);
   }
 }
-var import_path26, log76, configCache, modulesCache, fsCache, contentCache, resourcesCache, templateEngineCache, siteCache, createDomainInstances, tasks;
+var import_path27, log76, configCache, modulesCache, fsCache, contentCache, resourcesCache, templateEngineCache, siteCache, createDomainInstances, tasks;
 var init_ssg = __esm({
   "internal/application/ssg.ts"() {
     "use strict";
@@ -50192,7 +50270,7 @@ var init_ssg = __esm({
     init_template3();
     init_site2();
     init_log();
-    import_path26 = __toESM(require("path"));
+    import_path27 = __toESM(require("path"));
     init_resources2();
     log76 = getDomainLogger("ssg", { component: "application" });
     createDomainInstances = (site, content, fs13, config, modules, resources) => {
@@ -50924,8 +51002,8 @@ var WorkerPoolManager = class {
    * 初始化 Node.js Worker 池
    */
   async initializeNodePool() {
-    const path42 = require("path");
-    const workerPath = path42.join(__dirname, "worker", "worker-node.js");
+    const path43 = require("path");
+    const workerPath = path43.join(__dirname, "worker", "worker-node.js");
     log79.debug(`Initializing Node.js worker pool with path: ${workerPath}`);
     this.pool = workerpool.pool(workerPath, {
       minWorkers: this.workerCount,
@@ -51252,7 +51330,7 @@ async function processSSGParallel(projDir, modulesDir, markdown, onProgress, htt
 
 // internal/interfaces/cli/commands/build.ts
 init_log();
-var import_path27 = __toESM(require("path"));
+var import_path28 = __toESM(require("path"));
 var import_fs15 = require("fs");
 var log82 = getDomainLogger("build-command", { component: "cli" });
 var BuildCommand = class {
@@ -51279,7 +51357,7 @@ var BuildCommand = class {
       await project.loadConfig();
       const projectRoot = project.getPath();
       const modulesDir = options.modulesDir || workspace.getModulesDir();
-      const outputDir = options.destination ? import_path27.default.resolve(projectRoot, options.destination) : await project.getPublishDir();
+      const outputDir = options.destination ? import_path28.default.resolve(projectRoot, options.destination) : await project.getPublishDir();
       if (options.clean) {
         await this.cleanOutputDir(outputDir);
         log82.info(`Cleaned output directory: ${outputDir}`);
@@ -51288,7 +51366,7 @@ var BuildCommand = class {
       let contentDirs = await project.getContentDirs();
       if (options.contentDirs && options.contentDirs.length > 0) {
         const extraDirs = options.contentDirs.map(
-          (dir2) => import_path27.default.resolve(projectRoot, dir2)
+          (dir2) => import_path28.default.resolve(projectRoot, dir2)
         );
         contentDirs = [...contentDirs, ...extraDirs];
         log82.info(`Added extra content directories: ${options.contentDirs.join(", ")}`);
@@ -51369,7 +51447,7 @@ var BuildCommand = class {
       const entries = await import_fs15.promises.readdir(outputDir);
       await Promise.all(
         entries.map(
-          (entry) => import_fs15.promises.rm(import_path27.default.join(outputDir, entry), { recursive: true, force: true })
+          (entry) => import_fs15.promises.rm(import_path28.default.join(outputDir, entry), { recursive: true, force: true })
         )
       );
     } catch (error) {
@@ -51386,7 +51464,7 @@ init_log();
 
 // pkg/web/watcher/content-file-watcher.ts
 var chokidar = __toESM(require("chokidar"));
-var path39 = __toESM(require("path"));
+var path40 = __toESM(require("path"));
 init_log();
 var log83 = getDomainLogger("web", { component: "content-file-watcher" });
 var ContentFileWatcher = class {
@@ -51445,7 +51523,7 @@ var ContentFileWatcher = class {
         }
       }
     }
-    const normalizedPath = path39.normalize(fp);
+    const normalizedPath = path40.normalize(fp);
     if (!this.isRelevantFile(normalizedPath)) {
       return;
     }
@@ -51463,11 +51541,11 @@ var ContentFileWatcher = class {
     return this.isMarkdownFile(filePath) || this.isImageFile(filePath);
   }
   isMarkdownFile(filePath) {
-    const ext = path39.extname(filePath).toLowerCase();
+    const ext = path40.extname(filePath).toLowerCase();
     return ext === ".md" || ext === ".markdown";
   }
   isImageFile(filePath) {
-    const ext = path39.extname(filePath).toLowerCase();
+    const ext = path40.extname(filePath).toLowerCase();
     return [".jpg", ".jpeg", ".png", ".gif", ".svg", ".webp", ".bmp"].includes(ext);
   }
   scheduleBatch() {
@@ -51514,7 +51592,7 @@ var ContentFileWatcher = class {
 
 // pkg/web/server/livereload-server.ts
 var http3 = __toESM(require("http"));
-var path40 = __toESM(require("path"));
+var path41 = __toESM(require("path"));
 var fs11 = __toESM(require("fs/promises"));
 var import_ws = require("ws");
 init_log();
@@ -51585,7 +51663,7 @@ var FoundryLiveReloadServer = class {
     };
     if (changedFiles && changedFiles.length === 1) {
       const file = changedFiles[0];
-      const ext = path40.extname(file).toLowerCase();
+      const ext = path41.extname(file).toLowerCase();
       if (ext === ".css") {
         reloadEvent.path = file;
         reloadEvent.liveCSS = true;
@@ -51669,7 +51747,7 @@ var FoundryLiveReloadServer = class {
     try {
       const stats = await fs11.stat(filePath);
       if (stats.isDirectory()) {
-        const indexPath = path40.join(filePath, "index.html");
+        const indexPath = path41.join(filePath, "index.html");
         try {
           await fs11.stat(indexPath);
           filePath = indexPath;
@@ -51715,9 +51793,9 @@ var FoundryLiveReloadServer = class {
       log84.warn("Failed to decode URL:", cleanUrl, error);
       decodedUrl = cleanUrl;
     }
-    const normalizedPath = path40.normalize(decodedUrl).replace(/^(\.\.[\/\\])+/, "");
+    const normalizedPath = path41.normalize(decodedUrl).replace(/^(\.\.[\/\\])+/, "");
     const relativePath = normalizedPath.startsWith("/") ? normalizedPath.slice(1) : normalizedPath;
-    const resolvedPath = path40.join(this.config.publicDir, relativePath);
+    const resolvedPath = path41.join(this.config.publicDir, relativePath);
     if (process.platform === "win32" && resolvedPath.length > 260) {
       log84.warn("Path too long for Windows filesystem:", resolvedPath);
     }
@@ -51730,7 +51808,7 @@ var FoundryLiveReloadServer = class {
     return resolvedPath;
   }
   getContentType(filePath) {
-    const ext = path40.extname(filePath).toLowerCase();
+    const ext = path41.extname(filePath).toLowerCase();
     const mimeTypes = {
       ".html": "text/html; charset=utf-8",
       ".css": "text/css; charset=utf-8",
@@ -51824,19 +51902,19 @@ var FoundryLiveReloadServer = class {
   shouldLiveReloadCSS(changedFiles) {
     if (!changedFiles)
       return false;
-    return changedFiles.some((file) => path40.extname(file).toLowerCase() === ".css");
+    return changedFiles.some((file) => path41.extname(file).toLowerCase() === ".css");
   }
   shouldLiveReloadImages(changedFiles) {
     if (!changedFiles)
       return false;
     const imageExts = [".jpg", ".jpeg", ".png", ".gif", ".svg", ".webp"];
-    return changedFiles.some((file) => imageExts.includes(path40.extname(file).toLowerCase()));
+    return changedFiles.some((file) => imageExts.includes(path41.extname(file).toLowerCase()));
   }
 };
 
 // pkg/web/server/electron-livereload-server.ts
 var http4 = __toESM(require("http"));
-var path41 = __toESM(require("path"));
+var path42 = __toESM(require("path"));
 var fs12 = __toESM(require("fs/promises"));
 init_log();
 var log85 = getDomainLogger("web", { component: "electron-livereload-server" });
@@ -51853,7 +51931,7 @@ var ElectronLiveReloadServer = class {
       enableLiveReload: config.enableLiveReload !== false,
       publicDir: config.publicDir
     };
-    this.stateFilePath = path41.join(this.config.publicDir, ".foundry-livereload-state.json");
+    this.stateFilePath = path42.join(this.config.publicDir, ".foundry-livereload-state.json");
   }
   async start() {
     if (this.running) {
@@ -51906,7 +51984,7 @@ var ElectronLiveReloadServer = class {
     };
     if (changedFiles && changedFiles.length === 1) {
       const file = changedFiles[0];
-      const ext = path41.extname(file).toLowerCase();
+      const ext = path42.extname(file).toLowerCase();
       if (ext === ".css" || [".jpg", ".jpeg", ".png", ".gif", ".svg", ".webp"].includes(ext)) {
         state.path = file;
       }
@@ -51990,7 +52068,7 @@ var ElectronLiveReloadServer = class {
     try {
       const stats = await fs12.stat(filePath);
       if (stats.isDirectory()) {
-        const indexPath = path41.join(filePath, "index.html");
+        const indexPath = path42.join(filePath, "index.html");
         try {
           await fs12.stat(indexPath);
           filePath = indexPath;
@@ -52036,13 +52114,13 @@ var ElectronLiveReloadServer = class {
       log85.warn("Failed to decode URL:", cleanUrl, error);
       decodedUrl = cleanUrl;
     }
-    const normalizedPath = path41.normalize(decodedUrl).replace(/^(\.\.[\/\\])+/, "");
+    const normalizedPath = path42.normalize(decodedUrl).replace(/^(\.\.[\/\\])+/, "");
     const relativePath = normalizedPath.startsWith("/") ? normalizedPath.slice(1) : normalizedPath;
-    const resolvedPath = path41.join(this.config.publicDir, relativePath);
+    const resolvedPath = path42.join(this.config.publicDir, relativePath);
     return resolvedPath;
   }
   getContentType(filePath) {
-    const ext = path41.extname(filePath).toLowerCase();
+    const ext = path42.extname(filePath).toLowerCase();
     const mimeTypes = {
       ".html": "text/html; charset=utf-8",
       ".css": "text/css; charset=utf-8",
@@ -52162,13 +52240,13 @@ var ElectronLiveReloadServer = class {
   shouldLiveReloadCSS(changedFiles) {
     if (!changedFiles)
       return false;
-    return changedFiles.some((file) => path41.extname(file).toLowerCase() === ".css");
+    return changedFiles.some((file) => path42.extname(file).toLowerCase() === ".css");
   }
   shouldLiveReloadImages(changedFiles) {
     if (!changedFiles)
       return false;
     const imageExts = [".jpg", ".jpeg", ".png", ".gif", ".svg", ".webp"];
-    return changedFiles.some((file) => imageExts.includes(path41.extname(file).toLowerCase()));
+    return changedFiles.some((file) => imageExts.includes(path42.extname(file).toLowerCase()));
   }
 };
 
@@ -52493,7 +52571,8 @@ var ServeCommand = class {
       const host = options.host || "localhost";
       const livereloadPort = options.livereloadPort || 35729;
       const enableLivereload = options.livereload !== false;
-      const contentDirs = await project.getContentDirs();
+      const projContentDirs = await project.getContentDirs();
+      const contentDirs = project.getLinkDirs();
       const modulesDir = workspace.getModulesDir();
       const publicDir = await project.getPublishDir();
       const projectRoot = project.getPath();
@@ -52501,7 +52580,7 @@ var ServeCommand = class {
         projDir: projectRoot,
         modulesDir,
         contentDirs,
-        projContentDirs: contentDirs,
+        projContentDirs,
         publicDir,
         enableWatching: true,
         batchDelay: 300,
@@ -54472,7 +54551,7 @@ For more information, visit: https://help.mdfriday.com
    * Show version
    */
   showVersion() {
-    const version = "26.3.4";
+    const version = "26.3.6";
     return {
       success: true,
       message: `MDFriday CLI v${version}`