npm - @mdfriday/foundry - Versions diffs - 26.3.4 → 26.3.5 - Mend

@mdfriday/foundry 26.3.4 → 26.3.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/dist/cli.js +560 -500
package/dist/index.js +1 -1
package/dist/internal/domain/workspace/entity/workspace.d.ts +3 -1
package/dist/internal/domain/workspace/repository/file-system.d.ts +4 -0
package/dist/internal/infrastructure/persistence/node-file-system.d.ts +4 -0
package/package.json +1 -1

package/dist/cli.js CHANGED Viewed

@@ -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;
@@ -3088,7 +3098,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 +3116,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 +3169,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 +3596,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 +3646,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 +3668,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 +3702,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 +3711,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 +3721,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 +3732,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 +3749,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 +3808,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 +3826,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 +3896,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 +3925,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 +4423,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 +4437,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 +4445,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 +4474,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 +4482,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 +4518,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 +4541,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 +4554,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 +4565,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 +4576,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 +4597,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 +4613,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 +4641,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 +4658,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 +4675,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 +4693,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 +4747,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 +4798,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 +4942,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 +4953,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 +5214,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 +5228,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 +5240,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 +6833,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 +6847,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 +6856,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 +6884,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 +7039,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 +7210,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 +7301,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 +7368,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 +7422,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 +7656,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 +7923,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 +8067,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 +8225,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 +8474,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 +8507,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 +8556,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 +8564,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 +9495,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 +10745,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 +10761,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 +10960,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 +11004,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 +11149,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 +11168,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 +11191,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 +11214,7 @@ var init_config2 = __esm({
     init_markdown2();
     init_loader();
     init_sourcedescriptor();
-    path13 = __toESM(require("path"));
+    path14 = __toESM(require("path"));
   }
 });
@@ -11226,11 +11286,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 +11325,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 +11379,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 +11435,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 +11586,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 +11667,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 +11727,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 +11829,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 +11846,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 +11870,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 +11922,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 +11992,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 +12143,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 +12163,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 +12266,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 +12276,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 +12431,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 +12537,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 +12638,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 +13030,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 +13130,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 +13252,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 +13260,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 +13283,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 +13379,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 +13391,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 +13423,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 +13554,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 +13636,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 +13722,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 +13736,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 +13854,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 +14397,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 +14460,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 +14721,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 +14782,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 +14861,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 +14871,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 +14999,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 +15015,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 +15092,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 +18464,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 +19431,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 +19682,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 +20011,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 +20025,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 +20084,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 +20105,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 +20235,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 +20252,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 +20273,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 +20289,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 +20307,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 +20374,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 +20390,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 +20406,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 +20430,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 +20466,8 @@ var init_pathfactory = __esm({
       /**
        * Set the path
        */
-      withPath(path42) {
-        this.path = path42;
+      withPath(path43) {
+        this.path = path43;
         return this;
       }
       /**
@@ -20455,38 +20515,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 +20560,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 +20571,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 +20679,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 +20704,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 +20910,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 +20954,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 +21051,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 +21331,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 +21339,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 +21526,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 +21644,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 +21700,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 +22126,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 +23263,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 +23311,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 +23374,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 +23387,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 +23756,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 +23800,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 +23835,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 +23845,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 +24097,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 +24111,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 +24918,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 +24955,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 +24967,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 +25045,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 +25073,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 +25793,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 +25838,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 +27593,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 +28750,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 +29319,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 +29348,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 +29683,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 +30222,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 +30244,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 +30533,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 +30546,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 +30584,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 +30889,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 +31013,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 +31053,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 +31708,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 +33106,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 +33292,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 +46059,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 +46068,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 +46206,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 +47100,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 +47115,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 +47980,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 +48904,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 +48943,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 +48977,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 +49112,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 +49124,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 +49159,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 +49188,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 +49326,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 +49428,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 +49455,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 +49512,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 +49658,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 +49904,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 +49916,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 +49955,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 +50241,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 +50252,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 +50984,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 +51312,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 +51339,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 +51348,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 +51429,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 +51446,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 +51505,7 @@ var ContentFileWatcher = class {
         }
       }
     }
-    const normalizedPath = path39.normalize(fp);
+    const normalizedPath = path40.normalize(fp);
     if (!this.isRelevantFile(normalizedPath)) {
       return;
     }
@@ -51463,11 +51523,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 +51574,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 +51645,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 +51729,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 +51775,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 +51790,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 +51884,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 +51913,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 +51966,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 +52050,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 +52096,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 +52222,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()));
   }
 };
@@ -54472,7 +54532,7 @@ For more information, visit: https://help.mdfriday.com
    * Show version
    */
   showVersion() {
-    const version = "26.3.4";
+    const version = "26.3.5";
     return {
       success: true,
       message: `MDFriday CLI v${version}`