@mdfriday/foundry 26.4.7 → 26.4.9

package/dist/cli.js

@@ -624,11 +624,10 @@ var init_log = __esm({
 });
 
 // internal/domain/workspace/entity/workspace.ts
-var import_path, log, Workspace;
+var log, Workspace;
 var init_workspace = __esm({
   "internal/domain/workspace/entity/workspace.ts"() {
     "use strict";
-    import_path = __toESM(require("path"));
     init_log();
     log = getDomainLogger("workspace", { component: "domain" });
     Workspace = class {
@@ -637,12 +636,16 @@ var init_workspace = __esm({
       projects;
       authentication;
       fileSystemRepo;
+      // 必需
       constructor(rootPath, metadata, projects, authentication, fileSystemRepo) {
         this.rootPath = rootPath;
         this.metadata = metadata;
         this.projects = projects;
         this.authentication = authentication;
         this.fileSystemRepo = fileSystemRepo;
+        if (!this.fileSystemRepo) {
+          throw new Error("FileSystemRepository is required for Workspace");
+        }
       }
       // ============================================================================
       // Basic Getters
@@ -675,13 +678,13 @@ var init_workspace = __esm({
        * Get modules directory path
        */
       getModulesDir() {
-        return import_path.default.resolve(this.rootPath, this.metadata.paths.modules);
+        return this.fileSystemRepo.join(this.rootPath, this.metadata.paths.modules);
       }
       /**
        * Get projects directory path
        */
       getProjectsDir() {
-        return import_path.default.resolve(this.rootPath, this.metadata.paths.projects);
+        return this.fileSystemRepo.join(this.rootPath, this.metadata.paths.projects);
       }
       // ============================================================================
       // Metadata Management
@@ -777,7 +780,7 @@ var init_workspace = __esm({
         for (const project of this.projects.values()) {
           const metadata = project.getMetadata();
           const projectPath = project.getPath();
-          const relativePath = import_path.default.relative(this.getProjectsDir(), projectPath);
+          const relativePath = this.fileSystemRepo.relative(this.getProjectsDir(), projectPath);
           projectEntries.push({
             id: metadata.id,
             name: metadata.name,
@@ -815,15 +818,12 @@ var init_workspace = __esm({
        * Get workspace configuration file path
        */
       getConfigPath() {
-        return import_path.default.join(this.rootPath, ".mdfriday", "config.json");
+        return this.fileSystemRepo.join(this.rootPath, ".mdfriday", "config.json");
       }
       /**
        * Get configuration value by key (supports nested keys with dot notation)
        */
       async getConfig(key2) {
-        if (!this.fileSystemRepo) {
-          throw new Error("FileSystemRepository is required for config operations");
-        }
         const configPath = this.getConfigPath();
         try {
           const content = await this.fileSystemRepo.readFile(configPath, "utf-8");
@@ -840,9 +840,6 @@ var init_workspace = __esm({
        * Get all workspace configuration
        */
       async getAllConfig() {
-        if (!this.fileSystemRepo) {
-          throw new Error("FileSystemRepository is required for config operations");
-        }
         const configPath = this.getConfigPath();
         try {
           const content = await this.fileSystemRepo.readFile(configPath, "utf-8");
@@ -858,11 +855,8 @@ var init_workspace = __esm({
        * Set configuration value (supports nested keys with dot notation)
        */
       async setConfig(key2, value) {
-        if (!this.fileSystemRepo) {
-          throw new Error("FileSystemRepository is required for config operations");
-        }
         const configPath = this.getConfigPath();
-        const configDir = import_path.default.dirname(configPath);
+        const configDir = this.fileSystemRepo.dirname(configPath);
         await this.fileSystemRepo.createDirectory(configDir, true);
         let config = {};
         try {
@@ -881,9 +875,6 @@ var init_workspace = __esm({
        * Unset configuration value (supports nested keys with dot notation)
        */
       async unsetConfig(key2) {
-        if (!this.fileSystemRepo) {
-          throw new Error("FileSystemRepository is required for config operations");
-        }
         const configPath = this.getConfigPath();
         try {
           const content = await this.fileSystemRepo.readFile(configPath, "utf-8");
@@ -966,21 +957,25 @@ var init_workspace = __esm({
 });
 
 // internal/domain/workspace/entity/project.ts
-var import_path2, import_fs, log2, Project;
+var log2, Project;
 var init_project = __esm({
   "internal/domain/workspace/entity/project.ts"() {
     "use strict";
     init_log();
-    import_path2 = __toESM(require("path"));
-    import_fs = require("fs");
     log2 = getDomainLogger("project", { component: "domain" });
     Project = class {
       metadata;
       projectPath;
       config = null;
-      constructor(projectPath, metadata) {
+      fileSystemRepo;
+      // 必需
+      constructor(projectPath, metadata, fileSystemRepo) {
         this.projectPath = projectPath;
         this.metadata = metadata;
+        this.fileSystemRepo = fileSystemRepo;
+        if (!this.fileSystemRepo) {
+          throw new Error("FileSystemRepository is required for Project");
+        }
       }
       /**
        * Get project path
@@ -1052,8 +1047,8 @@ var init_project = __esm({
           return this.config;
         }
         try {
-          const configPath = import_path2.default.join(this.projectPath, "config.json");
-          const content = await import_fs.promises.readFile(configPath, "utf-8");
+          const configPath = this.fileSystemRepo.join(this.projectPath, "config.json");
+          const content = await this.fileSystemRepo.readFile(configPath, "utf-8");
           this.config = JSON.parse(content);
           return this.config;
         } catch (error) {
@@ -1080,11 +1075,11 @@ var init_project = __esm({
         const config = await this.loadConfig();
         const contentDirs = [];
         const mainContentDir = config.contentDir || "content";
-        contentDirs.push(import_path2.default.resolve(this.projectPath, mainContentDir));
+        contentDirs.push(this.fileSystemRepo.join(this.projectPath, mainContentDir));
         if (config.languages) {
           for (const [lang2, langConfig] of Object.entries(config.languages)) {
             if (langConfig.contentDir && langConfig.contentDir !== mainContentDir) {
-              contentDirs.push(import_path2.default.resolve(this.projectPath, langConfig.contentDir));
+              contentDirs.push(this.fileSystemRepo.join(this.projectPath, langConfig.contentDir));
             }
           }
         }
@@ -1097,14 +1092,14 @@ var init_project = __esm({
       async getPublishDir() {
         const config = await this.loadConfig();
         const publishDir = config.publishDir || "public";
-        return import_path2.default.resolve(this.projectPath, publishDir);
+        return this.fileSystemRepo.join(this.projectPath, publishDir);
       }
       /**
        * Get static directory
        * Returns absolute path
        */
       getStaticDir() {
-        return import_path2.default.resolve(this.projectPath, "static");
+        return this.fileSystemRepo.join(this.projectPath, "static");
       }
       /**
        * Get default content language
@@ -1130,7 +1125,7 @@ var init_project = __esm({
        * Get project configuration file path
        */
       getConfigPath() {
-        return import_path2.default.join(this.projectPath, "config.json");
+        return this.fileSystemRepo.join(this.projectPath, "config.json");
       }
       /**
        * Get configuration value by key (supports nested keys with dot notation)
@@ -1185,7 +1180,7 @@ var init_project = __esm({
           throw new Error("Configuration not loaded. Call loadConfig() first.");
         }
         const configPath = this.getConfigPath();
-        await import_fs.promises.writeFile(configPath, JSON.stringify(this.config, null, 2), "utf-8");
+        await this.fileSystemRepo.writeFile(configPath, JSON.stringify(this.config, null, 2), "utf-8");
         log2.debug(`Project config saved: ${configPath}`, { projectName: this.metadata.name });
       }
       // Helper methods for nested key access
@@ -1254,7 +1249,7 @@ var init_project = __esm({
        * Get snapshots directory path
        */
       getSnapshotsDir() {
-        return import_path2.default.join(this.projectPath, ".mdfriday", "snapshots");
+        return this.fileSystemRepo.join(this.projectPath, ".mdfriday", "snapshots");
       }
       // ============================================================================
       // Source Folder Links Management
@@ -1371,8 +1366,8 @@ var init_project = __esm({
       async setBaseURL(baseURL) {
         const config = await this.loadConfig();
         config.baseURL = baseURL;
-        const configPath = import_path2.default.join(this.projectPath, "config.json");
-        await import_fs.promises.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+        const configPath = this.fileSystemRepo.join(this.projectPath, "config.json");
+        await this.fileSystemRepo.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
         this.config = config;
       }
       /**
@@ -3404,7 +3399,7 @@ function generateProjectId(name) {
   const slug2 = name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
   return `${slug2}-${Date.now().toString(36)}`;
 }
-var import_path3, log5, defaultLanguage, WorkspaceFactory;
+var log5, defaultLanguage, WorkspaceFactory;
 var init_workspace_factory = __esm({
   "internal/domain/workspace/factory/workspace-factory.ts"() {
     "use strict";
@@ -3414,7 +3409,6 @@ var init_workspace_factory = __esm({
     init_workspace_metadata();
     init_project_metadata();
     init_folder_structure();
-    import_path3 = __toESM(require("path"));
     init_log();
     log5 = getDomainLogger("workspace-factory", { component: "domain" });
     defaultLanguage = "en";
@@ -3423,11 +3417,15 @@ var init_workspace_factory = __esm({
       projectRepo;
       snapshotRepo;
       fileSystemRepo;
+      // 不再可选
       constructor(options) {
         this.workspaceRepo = options.workspaceRepo;
         this.projectRepo = options.projectRepo;
         this.snapshotRepo = options.snapshotRepo;
-        this.fileSystemRepo = options.fileSystemRepo || null;
+        this.fileSystemRepo = options.fileSystemRepo;
+        if (!this.fileSystemRepo) {
+          throw new Error("FileSystemRepository is required");
+        }
       }
       // ============================================================================
       // Load Workspace (Aggregate Root)
@@ -3437,7 +3435,7 @@ var init_workspace_factory = __esm({
        * Returns fully constructed Workspace aggregate root with all Project entities
        */
       async load(rootPath) {
-        const absolutePath = import_path3.default.resolve(rootPath);
+        const absolutePath = this.fileSystemRepo.resolvePathSync(rootPath);
         log5.info("Loading workspace", { path: absolutePath });
         const metadataData = await this.workspaceRepo.loadWorkspaceMetadata(absolutePath);
         const metadata = WorkspaceMetadata.create(metadataData);
@@ -3447,7 +3445,7 @@ var init_workspace_factory = __esm({
           try {
             const projectMetadataData = await this.projectRepo.loadProjectMetadata(entry.absolutePath);
             const projectMetadata = ProjectMetadata.create(projectMetadataData);
-            const project = new Project(entry.absolutePath, projectMetadata);
+            const project = new Project(entry.absolutePath, projectMetadata, this.fileSystemRepo);
             projects.set(entry.id, project);
             log5.debug("Project loaded", { projectId: entry.id, name: entry.name });
           } catch (error) {
@@ -3465,7 +3463,7 @@ var init_workspace_factory = __esm({
           metadata,
           projects,
           authentication,
-          this.fileSystemRepo || void 0
+          this.fileSystemRepo
         );
         log5.info("Workspace loaded", {
           workspaceId: workspace.getId(),
@@ -3478,10 +3476,7 @@ 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 authPath = this.fileSystemRepo.join(workspacePath, ".mdfriday", "auth-token.json");
         try {
           await this.fileSystemRepo.access(authPath);
           return true;
@@ -3496,7 +3491,7 @@ var init_workspace_factory = __esm({
        * Create a new workspace
        */
       async create(rootPath, options = {}) {
-        const absolutePath = import_path3.default.resolve(rootPath);
+        const absolutePath = this.fileSystemRepo.resolvePathSync(rootPath);
         log5.info("Creating workspace", { path: absolutePath });
         if (await this.workspaceRepo.isWorkspace(absolutePath)) {
           throw new Error(`Workspace already exists at ${absolutePath}`);
@@ -3508,7 +3503,7 @@ var init_workspace_factory = __esm({
         const metadata = WorkspaceMetadata.create({
           version: "1.0",
           id: generateWorkspaceId(),
-          name: options.name || import_path3.default.basename(absolutePath),
+          name: options.name || this.fileSystemRepo.basename(absolutePath),
           createdAt: now,
           updatedAt: now,
           paths: {
@@ -3526,24 +3521,22 @@ var init_workspace_factory = __esm({
         };
         await this.workspaceRepo.saveWorkspaceMetadata(absolutePath, metadata.toJSON());
         await this.workspaceRepo.saveProjectRegistry(absolutePath, emptyRegistry);
-        if (this.fileSystemRepo) {
-          const mdfridayDir = import_path3.default.join(absolutePath, ".mdfriday");
-          const configPath = import_path3.default.join(mdfridayDir, "config.json");
-          await this.fileSystemRepo.writeFile(configPath, "{}", "utf-8");
-          const userDataPath = import_path3.default.join(mdfridayDir, "user-data.json");
-          await this.fileSystemRepo.writeFile(userDataPath, "{}", "utf-8");
-          log5.debug("Initialized configuration files", {
-            configPath,
-            userDataPath
-          });
-        }
+        const mdfridayDir = this.fileSystemRepo.join(absolutePath, ".mdfriday");
+        const configPath = this.fileSystemRepo.join(mdfridayDir, "config.json");
+        await this.fileSystemRepo.writeFile(configPath, "{}", "utf-8");
+        const userDataPath = this.fileSystemRepo.join(mdfridayDir, "user-data.json");
+        await this.fileSystemRepo.writeFile(userDataPath, "{}", "utf-8");
+        log5.debug("Initialized configuration files", {
+          configPath,
+          userDataPath
+        });
         const authentication = new Authentication(absolutePath, false);
         const workspace = new Workspace(
           absolutePath,
           metadata,
           /* @__PURE__ */ new Map(),
           authentication,
-          this.fileSystemRepo || void 0
+          this.fileSystemRepo
         );
         log5.info("Workspace created", {
           workspaceId: workspace.getId(),
@@ -3587,13 +3580,14 @@ var init_workspace_factory = __esm({
        * Find workspace root by searching up the directory tree
        */
       async findWorkspaceRoot(startPath) {
-        let currentPath = import_path3.default.resolve(startPath);
-        const root2 = import_path3.default.parse(currentPath).root;
+        let currentPath = this.fileSystemRepo.resolvePathSync(startPath);
+        const pathInfo = this.fileSystemRepo.parsePath(currentPath);
+        const root2 = pathInfo.root;
         while (currentPath !== root2) {
           if (await this.workspaceRepo.isWorkspace(currentPath)) {
             return currentPath;
           }
-          currentPath = import_path3.default.dirname(currentPath);
+          currentPath = this.fileSystemRepo.dirname(currentPath);
         }
         return null;
       }
@@ -3601,7 +3595,7 @@ var init_workspace_factory = __esm({
        * Check if a path is a workspace
        */
       async isWorkspace(workspacePath) {
-        const absolutePath = import_path3.default.resolve(workspacePath);
+        const absolutePath = this.fileSystemRepo.resolvePathSync(workspacePath);
         return this.workspaceRepo.isWorkspace(absolutePath);
       }
       /**
@@ -3623,7 +3617,7 @@ var init_workspace_factory = __esm({
        */
       async createProject(workspace, name, options = {}) {
         const projectId = generateProjectId(name);
-        const projectPath = import_path3.default.join(workspace.getProjectsDir(), name);
+        const projectPath = this.fileSystemRepo.join(workspace.getProjectsDir(), name);
         log5.info("Creating project", { projectId, name, path: projectPath });
         if (workspace.findProject(name)) {
           throw new Error(`Project ${name} already exists`);
@@ -3659,9 +3653,9 @@ var init_workspace_factory = __esm({
         };
         await this.projectRepo.saveProjectMetadata(projectPath, projectMetadata.toJSON());
         await this.projectRepo.saveProjectConfig(projectPath, config);
-        const sampleContentPath = import_path3.default.join(projectPath, contentDir, "index.md");
+        const sampleContentPath = this.fileSystemRepo.join(projectPath, contentDir, "index.md");
         await this.projectRepo.createSampleContent(sampleContentPath, this.createSampleContent());
-        const project = new Project(projectPath, projectMetadata);
+        const project = new Project(projectPath, projectMetadata, this.fileSystemRepo);
         workspace.addProject(project);
         await this.save(workspace);
         log5.info("Project created", { projectId, name });
@@ -3699,7 +3693,7 @@ var init_workspace_factory = __esm({
           throw new Error("FileSystemRepository is required to create project from folder");
         }
         const projectId = generateProjectId(name);
-        const projectPath = import_path3.default.join(workspace.getProjectsDir(), name);
+        const projectPath = this.fileSystemRepo.join(workspace.getProjectsDir(), name);
         log5.info("Creating project from folder", {
           projectId,
           name,
@@ -3738,7 +3732,7 @@ var init_workspace_factory = __esm({
         const contentLinks = [];
         const contentLinksMetadata = [];
         for (const contentFolder of finalFolderStructure.getContentFolders()) {
-          const targetDir = contentFolder.weight === 0 ? import_path3.default.join(projectPath, "content") : import_path3.default.join(projectPath, `content.${contentFolder.languageCode}`);
+          const targetDir = contentFolder.weight === 0 ? this.fileSystemRepo.join(projectPath, "content") : this.fileSystemRepo.join(projectPath, `content.${contentFolder.languageCode}`);
           contentLinks.push({
             source: contentFolder.path,
             target: targetDir
@@ -3754,7 +3748,7 @@ var init_workspace_factory = __esm({
           const staticFolder = finalFolderStructure.getStaticFolder();
           contentLinks.push({
             source: staticFolder.path,
-            target: import_path3.default.join(projectPath, "static")
+            target: this.fileSystemRepo.join(projectPath, "static")
           });
           staticLinkMetadata = { sourcePath: staticFolder.path };
         }
@@ -3799,7 +3793,7 @@ var init_workspace_factory = __esm({
         }
         await this.projectRepo.saveProjectMetadata(projectPath, projectMetadata.toJSON());
         await this.projectRepo.saveProjectConfig(projectPath, config);
-        const project = new Project(projectPath, projectMetadata);
+        const project = new Project(projectPath, projectMetadata, this.fileSystemRepo);
         workspace.addProject(project);
         await this.save(workspace);
         log5.info("Project created from folder", {
@@ -3821,7 +3815,7 @@ var init_workspace_factory = __esm({
           throw new Error("FileSystemRepository is required to create project from file");
         }
         const projectId = generateProjectId(name);
-        const projectPath = import_path3.default.join(workspace.getProjectsDir(), name);
+        const projectPath = this.fileSystemRepo.join(workspace.getProjectsDir(), name);
         log5.info("Creating project from file", {
           projectId,
           name,
@@ -3845,8 +3839,8 @@ var init_workspace_factory = __esm({
           "static",
           "public"
         );
-        const contentDir = import_path3.default.join(projectPath, "content");
-        const targetFilePath = import_path3.default.join(contentDir, "index.md");
+        const contentDir = this.fileSystemRepo.join(projectPath, "content");
+        const targetFilePath = this.fileSystemRepo.join(contentDir, "index.md");
         let useSymlink = false;
         let fileLink = null;
         try {
@@ -3899,7 +3893,7 @@ var init_workspace_factory = __esm({
         };
         await this.projectRepo.saveProjectMetadata(projectPath, projectMetadata.toJSON());
         await this.projectRepo.saveProjectConfig(projectPath, config);
-        const project = new Project(projectPath, projectMetadata);
+        const project = new Project(projectPath, projectMetadata, this.fileSystemRepo);
         workspace.addProject(project);
         await this.save(workspace);
         log5.info("Project created from file", {
@@ -3917,14 +3911,14 @@ var init_workspace_factory = __esm({
        * Load a single project by path
        */
       async loadProject(projectPath) {
-        const absolutePath = import_path3.default.resolve(projectPath);
+        const absolutePath = this.fileSystemRepo.resolvePathSync(projectPath);
         if (!await this.projectRepo.isProject(absolutePath)) {
           throw new Error(`No project found at ${absolutePath}`);
         }
         const metadataData = await this.projectRepo.loadProjectMetadata(absolutePath);
         const { ProjectMetadata: ProjectMetadataVO } = await Promise.resolve().then(() => (init_project_metadata(), project_metadata_exports));
         const metadata = ProjectMetadataVO.create(metadataData);
-        return new Project(absolutePath, metadata);
+        return new Project(absolutePath, metadata, this.fileSystemRepo);
       }
       /**
        * Save a single project
@@ -3942,13 +3936,13 @@ var init_workspace_factory = __esm({
        * Find project root from current directory
        */
       async findProjectRoot(startPath) {
-        let currentPath = import_path3.default.resolve(startPath);
-        const root2 = import_path3.default.parse(currentPath).root;
+        let currentPath = this.fileSystemRepo.resolvePathSync(startPath);
+        const root2 = this.fileSystemRepo.parsePath(currentPath).root;
         while (currentPath !== root2) {
           if (await this.projectRepo.isProject(currentPath)) {
             return currentPath;
           }
-          currentPath = import_path3.default.dirname(currentPath);
+          currentPath = this.fileSystemRepo.dirname(currentPath);
         }
         return null;
       }
@@ -3974,7 +3968,7 @@ var init_workspace_factory = __esm({
             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 metadataPath = this.fileSystemRepo.join(project.getPath(), ".mdfriday", "snapshots", `${metadata.id}.json`);
           await this.fileSystemRepo.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
         }
         log5.info("Snapshot created", { snapshotId, size: metadata.size, fileCount: metadata.fileCount });
@@ -4027,8 +4021,8 @@ var init_workspace_factory = __esm({
         return {
           // 新方法：合并存储
           async saveUserData(data) {
-            const userDataPath = import_path3.default.join(workspacePath, ".mdfriday", "user-data.json");
-            await fsRepo.createDirectory(import_path3.default.dirname(userDataPath), true);
+            const userDataPath = fsRepo.join(workspacePath, ".mdfriday", "user-data.json");
+            await fsRepo.createDirectory(fsRepo.dirname(userDataPath), true);
             const jsonData = {};
             if (data.serverConfig) {
               jsonData.serverConfig = data.serverConfig.toJSON();
@@ -4049,7 +4043,7 @@ var init_workspace_factory = __esm({
             await fsRepo.writeFile(userDataPath, JSON.stringify(jsonData, null, 2));
           },
           async loadUserData() {
-            const userDataPath = import_path3.default.join(workspacePath, ".mdfriday", "user-data.json");
+            const userDataPath = fsRepo.join(workspacePath, ".mdfriday", "user-data.json");
             try {
               const content = await fsRepo.readFile(userDataPath, "utf-8");
               const data = JSON.parse(content);
@@ -4084,7 +4078,7 @@ var init_workspace_factory = __esm({
             }
           },
           async clearUserData() {
-            const userDataPath = import_path3.default.join(workspacePath, ".mdfriday", "user-data.json");
+            const userDataPath = fsRepo.join(workspacePath, ".mdfriday", "user-data.json");
             try {
               await fsRepo.unlink(userDataPath);
             } catch {
@@ -4093,8 +4087,8 @@ var init_workspace_factory = __esm({
           },
           // 保留旧方法以向后兼容
           async saveToken(token) {
-            const authPath = import_path3.default.join(workspacePath, ".mdfriday", "auth-token.json");
-            await fsRepo.createDirectory(import_path3.default.dirname(authPath), true);
+            const authPath = fsRepo.join(workspacePath, ".mdfriday", "auth-token.json");
+            await fsRepo.createDirectory(fsRepo.dirname(authPath), true);
             await fsRepo.writeFile(authPath, JSON.stringify(token.toJSON(), null, 2));
             authentication.markAuthExists();
           },
@@ -4103,7 +4097,7 @@ var init_workspace_factory = __esm({
             if (userData?.token) {
               return userData.token;
             }
-            const authPath = import_path3.default.join(workspacePath, ".mdfriday", "auth-token.json");
+            const authPath = fsRepo.join(workspacePath, ".mdfriday", "auth-token.json");
             try {
               const content = await fsRepo.readFile(authPath, "utf-8");
               const data = JSON.parse(content);
@@ -4114,7 +4108,7 @@ var init_workspace_factory = __esm({
             }
           },
           async clearToken() {
-            const authPath = import_path3.default.join(workspacePath, ".mdfriday", "auth-token.json");
+            const authPath = fsRepo.join(workspacePath, ".mdfriday", "auth-token.json");
             try {
               await fsRepo.unlink(authPath);
             } catch {
@@ -4122,8 +4116,8 @@ var init_workspace_factory = __esm({
             authentication.markAuthDeleted();
           },
           async saveServerConfig(config) {
-            const configPath = import_path3.default.join(workspacePath, ".mdfriday", "auth-config.json");
-            await fsRepo.createDirectory(import_path3.default.dirname(configPath), true);
+            const configPath = fsRepo.join(workspacePath, ".mdfriday", "auth-config.json");
+            await fsRepo.createDirectory(fsRepo.dirname(configPath), true);
             await fsRepo.writeFile(configPath, JSON.stringify(config.toJSON(), null, 2));
           },
           async loadServerConfig() {
@@ -4131,7 +4125,7 @@ var init_workspace_factory = __esm({
             if (userData?.serverConfig) {
               return userData.serverConfig;
             }
-            const configPath = import_path3.default.join(workspacePath, ".mdfriday", "auth-config.json");
+            const configPath = fsRepo.join(workspacePath, ".mdfriday", "auth-config.json");
             try {
               const content = await fsRepo.readFile(configPath, "utf-8");
               const data = JSON.parse(content);
@@ -4161,7 +4155,7 @@ var init_workspace_factory = __esm({
         const baseURL = await project.getBaseURL();
         const pathInfo = project.parseBaseURLPath(baseURL);
         const projectRoot = project.getPath();
-        const publicDir = import_path3.default.join(projectRoot, "public");
+        const publicDir = this.fileSystemRepo.join(projectRoot, "public");
         if (pathInfo.isRoot) {
           log5.debug("baseURL is root, no structure needed");
           return {
@@ -4176,13 +4170,13 @@ var init_workspace_factory = __esm({
         });
         let currentDir = publicDir;
         for (const dirName of pathInfo.parentParts) {
-          currentDir = import_path3.default.join(currentDir, dirName);
+          currentDir = this.fileSystemRepo.join(currentDir, dirName);
           if (!await this.fileSystemRepo.exists(currentDir)) {
             await this.fileSystemRepo.createDirectory(currentDir, false);
             log5.debug(`Created parent directory: ${dirName}`);
           }
         }
-        const symlinkPath = import_path3.default.join(currentDir, pathInfo.finalDirName);
+        const symlinkPath = this.fileSystemRepo.join(currentDir, pathInfo.finalDirName);
         if (await this.fileSystemRepo.exists(symlinkPath)) {
           await this.fileSystemRepo.remove(symlinkPath, true);
           log5.debug(`Removed existing symlink: ${symlinkPath}`);
@@ -4230,12 +4224,12 @@ var init_workspace_factory = __esm({
           return;
         }
         const projectRoot = project.getPath();
-        const publicDir = import_path3.default.join(projectRoot, "public");
+        const publicDir = this.fileSystemRepo.join(projectRoot, "public");
         log5.info("Cleaning baseURL structure in public/", {
           pathParts: structureInfo.pathParts
         });
         for (let i = structureInfo.pathParts.length; i > 0; i--) {
-          const targetPath = import_path3.default.join(
+          const targetPath = this.fileSystemRepo.join(
             publicDir,
             ...structureInfo.pathParts.slice(0, i)
           );
@@ -4244,7 +4238,7 @@ var init_workspace_factory = __esm({
             log5.debug(`Removed: ${structureInfo.pathParts.slice(0, i).join("/")}`);
           }
           if (i > 1) {
-            const parentPath = import_path3.default.join(
+            const parentPath = this.fileSystemRepo.join(
               publicDir,
               ...structureInfo.pathParts.slice(0, i - 1)
             );
@@ -4286,7 +4280,7 @@ var init_workspace_factory = __esm({
           };
         }
         return {
-          serverRoot: import_path3.default.join(project.getPath(), "public"),
+          serverRoot: this.fileSystemRepo.join(project.getPath(), "public"),
           baseURL: currentBaseURL,
           recreated: false
         };
@@ -4363,12 +4357,12 @@ var init_workspace2 = __esm({
 });
 
 // internal/application/workspace.ts
-var import_path4, log6, WorkspaceAppService;
+var import_path, log6, WorkspaceAppService;
 var init_workspace3 = __esm({
   "internal/application/workspace.ts"() {
     "use strict";
     init_log();
-    import_path4 = __toESM(require("path"));
+    import_path = __toESM(require("path"));
     log6 = getDomainLogger("workspace-app", { component: "application" });
     WorkspaceAppService = class {
       workspaceFactory;
@@ -4381,17 +4375,17 @@ var init_workspace3 = __esm({
       /**
        * Load workspace from path
        */
-      async loadWorkspace(path43) {
-        if (path43) {
-          return this.workspaceFactory.load(path43);
+      async loadWorkspace(path40) {
+        if (path40) {
+          return this.workspaceFactory.load(path40);
         }
         return this.workspaceFactory.loadOrFind();
       }
       /**
        * Create new workspace
        */
-      async createWorkspace(path43, options) {
-        return this.workspaceFactory.create(path43, options);
+      async createWorkspace(path40, options) {
+        return this.workspaceFactory.create(path40, options);
       }
       /**
        * Save workspace
@@ -4455,7 +4449,7 @@ var init_workspace3 = __esm({
             if (!fsRepo) {
               project = void 0;
             } else {
-              const inputPath = import_path4.default.resolve(projectNameOrPath);
+              const inputPath = import_path.default.resolve(projectNameOrPath);
               for (const p2 of projects) {
                 const projectPath = p2.getPath();
                 if (inputPath.startsWith(projectPath) || projectPath === inputPath) {
@@ -5037,12 +5031,12 @@ var init_identity2 = __esm({
 });
 
 // internal/infrastructure/persistence/node-workspace-repository.ts
-var import_fs2, import_path5, MDFRIDAY_DIR, WORKSPACE_FILE, PROJECTS_FILE, PROJECT_FILE, CONFIG_FILE, NodeWorkspaceRepository, NodeProjectRepository;
+var import_fs, import_path2, 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_path5 = __toESM(require("path"));
+    import_fs = require("fs");
+    import_path2 = __toESM(require("path"));
     MDFRIDAY_DIR = ".mdfriday";
     WORKSPACE_FILE = "workspace.json";
     PROJECTS_FILE = "projects.json";
@@ -5051,102 +5045,102 @@ var init_node_workspace_repository = __esm({
     NodeWorkspaceRepository = class {
       async isWorkspace(workspacePath) {
         try {
-          const metadataPath = import_path5.default.join(workspacePath, MDFRIDAY_DIR, WORKSPACE_FILE);
-          await import_fs2.promises.access(metadataPath);
+          const metadataPath = import_path2.default.join(workspacePath, MDFRIDAY_DIR, WORKSPACE_FILE);
+          await import_fs.promises.access(metadataPath);
           return true;
         } catch {
           return false;
         }
       }
       async initWorkspaceStructure(workspacePath, modulesDir, 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 });
+        const mdfridayDir = import_path2.default.join(workspacePath, MDFRIDAY_DIR);
+        const modulesDirPath = import_path2.default.join(workspacePath, modulesDir);
+        const projectsDirPath = import_path2.default.join(workspacePath, projectsDir);
+        await import_fs.promises.mkdir(mdfridayDir, { recursive: true });
+        await import_fs.promises.mkdir(modulesDirPath, { recursive: true });
+        await import_fs.promises.mkdir(projectsDirPath, { recursive: true });
       }
       async saveWorkspaceMetadata(workspacePath, metadata) {
-        const metadataPath = import_path5.default.join(workspacePath, MDFRIDAY_DIR, WORKSPACE_FILE);
-        await import_fs2.promises.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+        const metadataPath = import_path2.default.join(workspacePath, MDFRIDAY_DIR, WORKSPACE_FILE);
+        await import_fs.promises.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
       }
       async loadWorkspaceMetadata(workspacePath) {
-        const metadataPath = import_path5.default.join(workspacePath, MDFRIDAY_DIR, WORKSPACE_FILE);
-        const content = await import_fs2.promises.readFile(metadataPath, "utf-8");
+        const metadataPath = import_path2.default.join(workspacePath, MDFRIDAY_DIR, WORKSPACE_FILE);
+        const content = await import_fs.promises.readFile(metadataPath, "utf-8");
         return JSON.parse(content);
       }
       async saveProjectRegistry(workspacePath, registry) {
-        const registryPath = import_path5.default.join(workspacePath, MDFRIDAY_DIR, PROJECTS_FILE);
-        await import_fs2.promises.writeFile(registryPath, JSON.stringify(registry, null, 2));
+        const registryPath = import_path2.default.join(workspacePath, MDFRIDAY_DIR, PROJECTS_FILE);
+        await import_fs.promises.writeFile(registryPath, JSON.stringify(registry, null, 2));
       }
       async loadProjectRegistry(workspacePath) {
-        const registryPath = import_path5.default.join(workspacePath, MDFRIDAY_DIR, PROJECTS_FILE);
-        const content = await import_fs2.promises.readFile(registryPath, "utf-8");
+        const registryPath = import_path2.default.join(workspacePath, MDFRIDAY_DIR, PROJECTS_FILE);
+        const content = await import_fs.promises.readFile(registryPath, "utf-8");
         return JSON.parse(content);
       }
     };
     NodeProjectRepository = class {
       async isProject(projectPath) {
         try {
-          const metadataPath = import_path5.default.join(projectPath, MDFRIDAY_DIR, PROJECT_FILE);
-          await import_fs2.promises.access(metadataPath);
+          const metadataPath = import_path2.default.join(projectPath, MDFRIDAY_DIR, PROJECT_FILE);
+          await import_fs.promises.access(metadataPath);
           return true;
         } catch {
           return false;
         }
       }
       async initProjectStructure(projectPath, contentDir, staticDir, 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 });
+        const mdfridayDir = import_path2.default.join(projectPath, MDFRIDAY_DIR);
+        const contentDirPath = import_path2.default.join(projectPath, contentDir);
+        const staticDirPath = import_path2.default.join(projectPath, staticDir);
+        const publishDirPath = import_path2.default.join(projectPath, publishDir);
+        await import_fs.promises.mkdir(mdfridayDir, { recursive: true });
+        await import_fs.promises.mkdir(contentDirPath, { recursive: true });
+        await import_fs.promises.mkdir(staticDirPath, { recursive: true });
+        await import_fs.promises.mkdir(publishDirPath, { recursive: true });
       }
       async saveProjectMetadata(projectPath, metadata) {
-        const metadataPath = import_path5.default.join(projectPath, MDFRIDAY_DIR, PROJECT_FILE);
-        await import_fs2.promises.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+        const metadataPath = import_path2.default.join(projectPath, MDFRIDAY_DIR, PROJECT_FILE);
+        await import_fs.promises.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
       }
       async loadProjectMetadata(projectPath) {
-        const metadataPath = import_path5.default.join(projectPath, MDFRIDAY_DIR, PROJECT_FILE);
-        const content = await import_fs2.promises.readFile(metadataPath, "utf-8");
+        const metadataPath = import_path2.default.join(projectPath, MDFRIDAY_DIR, PROJECT_FILE);
+        const content = await import_fs.promises.readFile(metadataPath, "utf-8");
         return JSON.parse(content);
       }
       async saveProjectConfig(projectPath, config) {
-        const configPath = import_path5.default.join(projectPath, CONFIG_FILE);
-        await import_fs2.promises.writeFile(configPath, JSON.stringify(config, null, 2));
+        const configPath = import_path2.default.join(projectPath, CONFIG_FILE);
+        await import_fs.promises.writeFile(configPath, JSON.stringify(config, null, 2));
       }
       async createSampleContent(contentPath, content) {
-        await import_fs2.promises.writeFile(contentPath, content);
+        await import_fs.promises.writeFile(contentPath, content);
       }
       async deleteProjectFiles(projectPath) {
-        await import_fs2.promises.rm(projectPath, { recursive: true, force: true });
+        await import_fs.promises.rm(projectPath, { recursive: true, force: true });
       }
       async deleteProjectDirectory(projectPath) {
-        await import_fs2.promises.rm(projectPath, { recursive: true, force: true });
+        await import_fs.promises.rm(projectPath, { recursive: true, force: true });
       }
     };
   }
 });
 
 // internal/infrastructure/persistence/node-snapshot-repository.ts
-var import_fs3, import_path6, NodeSnapshotRepository;
+var import_fs2, import_path3, NodeSnapshotRepository;
 var init_node_snapshot_repository = __esm({
   "internal/infrastructure/persistence/node-snapshot-repository.ts"() {
     "use strict";
-    import_fs3 = require("fs");
-    import_path6 = __toESM(require("path"));
+    import_fs2 = require("fs");
+    import_path3 = __toESM(require("path"));
     NodeSnapshotRepository = class {
       /**
        * Create a snapshot by copying output directory to snapshot storage
        */
       async createSnapshot(projectPath, snapshotId, outputDir) {
-        const snapshotDir = import_path6.default.join(projectPath, ".mdfriday", "snapshots");
-        await import_fs3.promises.mkdir(snapshotDir, { recursive: true });
-        const storageDir = import_path6.default.join(snapshotDir, snapshotId);
-        await import_fs3.promises.mkdir(storageDir, { recursive: true });
+        const snapshotDir = import_path3.default.join(projectPath, ".mdfriday", "snapshots");
+        await import_fs2.promises.mkdir(snapshotDir, { recursive: true });
+        const storageDir = import_path3.default.join(snapshotDir, snapshotId);
+        await import_fs2.promises.mkdir(storageDir, { recursive: true });
         await this.copyDirectory(outputDir, storageDir);
         const size = await this.getDirectorySize(storageDir);
         const fileCount = await this.countFiles(storageDir);
@@ -5155,31 +5149,31 @@ var init_node_snapshot_repository = __esm({
           name: snapshotId,
           // Will be updated by service if custom name provided
           timestamp: Date.now(),
-          outputDir: import_path6.default.relative(projectPath, outputDir),
-          storageDir: import_path6.default.relative(projectPath, storageDir),
+          outputDir: import_path3.default.relative(projectPath, outputDir),
+          storageDir: import_path3.default.relative(projectPath, storageDir),
           size,
           fileCount
         };
-        const metadataPath = import_path6.default.join(snapshotDir, `${snapshotId}.json`);
-        await import_fs3.promises.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+        const metadataPath = import_path3.default.join(snapshotDir, `${snapshotId}.json`);
+        await import_fs2.promises.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
         return metadata;
       }
       /**
        * List all snapshots for a project
        */
       async listSnapshots(projectPath) {
-        const snapshotDir = import_path6.default.join(projectPath, ".mdfriday", "snapshots");
+        const snapshotDir = import_path3.default.join(projectPath, ".mdfriday", "snapshots");
         try {
-          await import_fs3.promises.access(snapshotDir);
+          await import_fs2.promises.access(snapshotDir);
         } catch {
           return [];
         }
-        const entries = await import_fs3.promises.readdir(snapshotDir);
+        const entries = await import_fs2.promises.readdir(snapshotDir);
         const jsonFiles = entries.filter((f) => f.endsWith(".json"));
         const snapshots = [];
         for (const file of jsonFiles) {
           try {
-            const content = await import_fs3.promises.readFile(import_path6.default.join(snapshotDir, file), "utf-8");
+            const content = await import_fs2.promises.readFile(import_path3.default.join(snapshotDir, file), "utf-8");
             snapshots.push(JSON.parse(content));
           } catch {
           }
@@ -5190,10 +5184,10 @@ var init_node_snapshot_repository = __esm({
        * Get snapshot metadata
        */
       async getSnapshot(projectPath, snapshotId) {
-        const snapshotDir = import_path6.default.join(projectPath, ".mdfriday", "snapshots");
-        const metadataPath = import_path6.default.join(snapshotDir, `${snapshotId}.json`);
+        const snapshotDir = import_path3.default.join(projectPath, ".mdfriday", "snapshots");
+        const metadataPath = import_path3.default.join(snapshotDir, `${snapshotId}.json`);
         try {
-          const content = await import_fs3.promises.readFile(metadataPath, "utf-8");
+          const content = await import_fs2.promises.readFile(metadataPath, "utf-8");
           const metadata = JSON.parse(content);
           if (!metadata.storageDir) {
             throw new Error("This is a legacy metadata-only snapshot and cannot be restored");
@@ -5211,14 +5205,14 @@ var init_node_snapshot_repository = __esm({
        */
       async restoreSnapshot(projectPath, snapshotId, outputDir) {
         const metadata = await this.getSnapshot(projectPath, snapshotId);
-        const storageDir = import_path6.default.join(projectPath, metadata.storageDir);
+        const storageDir = import_path3.default.join(projectPath, metadata.storageDir);
         try {
-          await import_fs3.promises.access(storageDir);
+          await import_fs2.promises.access(storageDir);
         } catch {
           throw new Error(`Snapshot storage not found: ${snapshotId}`);
         }
         try {
-          await import_fs3.promises.rm(outputDir, { recursive: true, force: true });
+          await import_fs2.promises.rm(outputDir, { recursive: true, force: true });
         } catch {
         }
         await this.copyDirectory(storageDir, outputDir);
@@ -5227,19 +5221,19 @@ var init_node_snapshot_repository = __esm({
        * Delete a snapshot
        */
       async deleteSnapshot(projectPath, snapshotId) {
-        const snapshotDir = import_path6.default.join(projectPath, ".mdfriday", "snapshots");
-        const metadataPath = import_path6.default.join(snapshotDir, `${snapshotId}.json`);
+        const snapshotDir = import_path3.default.join(projectPath, ".mdfriday", "snapshots");
+        const metadataPath = import_path3.default.join(snapshotDir, `${snapshotId}.json`);
         try {
-          const content = await import_fs3.promises.readFile(metadataPath, "utf-8");
+          const content = await import_fs2.promises.readFile(metadataPath, "utf-8");
           const metadata = JSON.parse(content);
           if (metadata.storageDir) {
-            const storageDir = import_path6.default.join(projectPath, metadata.storageDir);
+            const storageDir = import_path3.default.join(projectPath, metadata.storageDir);
             try {
-              await import_fs3.promises.rm(storageDir, { recursive: true, force: true });
+              await import_fs2.promises.rm(storageDir, { recursive: true, force: true });
             } catch {
             }
           }
-          await import_fs3.promises.rm(metadataPath, { force: true });
+          await import_fs2.promises.rm(metadataPath, { force: true });
         } catch (error) {
           if (error.code === "ENOENT") {
             throw new Error(`Snapshot not found: ${snapshotId}`);
@@ -5251,16 +5245,16 @@ var init_node_snapshot_repository = __esm({
        * Copy directory recursively
        */
       async copyDirectory(src, dest) {
-        await import_fs3.promises.mkdir(dest, { recursive: true });
-        const entries = await import_fs3.promises.readdir(src, { withFileTypes: true });
+        await import_fs2.promises.mkdir(dest, { recursive: true });
+        const entries = await import_fs2.promises.readdir(src, { withFileTypes: true });
         await Promise.all(
           entries.map(async (entry) => {
-            const srcPath = import_path6.default.join(src, entry.name);
-            const destPath = import_path6.default.join(dest, entry.name);
+            const srcPath = import_path3.default.join(src, entry.name);
+            const destPath = import_path3.default.join(dest, entry.name);
             if (entry.isDirectory()) {
               await this.copyDirectory(srcPath, destPath);
             } else {
-              await import_fs3.promises.copyFile(srcPath, destPath);
+              await import_fs2.promises.copyFile(srcPath, destPath);
             }
           })
         );
@@ -5270,13 +5264,13 @@ var init_node_snapshot_repository = __esm({
        */
       async getDirectorySize(dir2) {
         let size = 0;
-        const entries = await import_fs3.promises.readdir(dir2, { withFileTypes: true });
+        const entries = await import_fs2.promises.readdir(dir2, { withFileTypes: true });
         for (const entry of entries) {
-          const entryPath = import_path6.default.join(dir2, entry.name);
+          const entryPath = import_path3.default.join(dir2, entry.name);
           if (entry.isDirectory()) {
             size += await this.getDirectorySize(entryPath);
           } else {
-            const stats = await import_fs3.promises.stat(entryPath);
+            const stats = await import_fs2.promises.stat(entryPath);
             size += stats.size;
           }
         }
@@ -5287,9 +5281,9 @@ var init_node_snapshot_repository = __esm({
        */
       async countFiles(dir2) {
         let count = 0;
-        const entries = await import_fs3.promises.readdir(dir2, { withFileTypes: true });
+        const entries = await import_fs2.promises.readdir(dir2, { withFileTypes: true });
         for (const entry of entries) {
-          const entryPath = import_path6.default.join(dir2, entry.name);
+          const entryPath = import_path3.default.join(dir2, entry.name);
           if (entry.isDirectory()) {
             count += await this.countFiles(entryPath);
           } else {
@@ -5307,12 +5301,12 @@ function mapLanguageCode(code) {
   const normalized = code.toLowerCase().trim();
   return LANGUAGE_CODE_MAP[normalized] || normalized;
 }
-var import_fs4, import_path7, log8, LANGUAGE_CODE_MAP, NodeFileSystemRepository;
+var import_fs3, import_path4, 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_path7 = __toESM(require("path"));
+    import_fs3 = require("fs");
+    import_path4 = __toESM(require("path"));
     init_log();
     log8 = getDomainLogger("node-fs", { component: "infrastructure" });
     LANGUAGE_CODE_MAP = {
@@ -5335,7 +5329,7 @@ var init_node_file_system = __esm({
     NodeFileSystemRepository = class {
       async exists(filePath) {
         try {
-          await import_fs4.promises.access(filePath);
+          await import_fs3.promises.access(filePath);
           return true;
         } catch {
           return false;
@@ -5343,7 +5337,7 @@ var init_node_file_system = __esm({
       }
       async isDirectory(filePath) {
         try {
-          const stats = await import_fs4.promises.stat(filePath);
+          const stats = await import_fs3.promises.stat(filePath);
           return stats.isDirectory();
         } catch {
           return false;
@@ -5351,7 +5345,7 @@ var init_node_file_system = __esm({
       }
       async isFile(filePath) {
         try {
-          const stats = await import_fs4.promises.stat(filePath);
+          const stats = await import_fs3.promises.stat(filePath);
           return stats.isFile();
         } catch {
           return false;
@@ -5359,9 +5353,9 @@ var init_node_file_system = __esm({
       }
       async readDirectory(dirPath) {
         try {
-          const entries = await import_fs4.promises.readdir(dirPath, { withFileTypes: true });
+          const entries = await import_fs3.promises.readdir(dirPath, { withFileTypes: true });
           return entries.map((entry) => ({
-            path: import_path7.default.join(dirPath, entry.name),
+            path: import_path4.default.join(dirPath, entry.name),
             name: entry.name,
             isDirectory: entry.isDirectory(),
             isFile: entry.isFile()
@@ -5412,7 +5406,7 @@ var init_node_file_system = __esm({
             if (a.weight !== b.weight) {
               return a.weight - b.weight;
             }
-            return import_path7.default.basename(a.path).localeCompare(import_path7.default.basename(b.path));
+            return import_path4.default.basename(a.path).localeCompare(import_path4.default.basename(b.path));
           });
           const isStructured = contentFolders.length > 0;
           log8.debug(`Scanned folder structure: ${dirPath}`, {
@@ -5453,20 +5447,20 @@ var init_node_file_system = __esm({
           }
           const targetDir = this.dirname(target);
           await this.createDirectory(targetDir, true);
-          const stats = await import_fs4.promises.stat(source);
+          const stats = await import_fs3.promises.stat(source);
           const isFile = stats.isFile();
           const isWindows = process.platform === "win32";
           if (isFile) {
             if (isWindows) {
-              await import_fs4.promises.symlink(source, target, "file");
+              await import_fs3.promises.symlink(source, target, "file");
             } else {
-              await import_fs4.promises.symlink(source, target);
+              await import_fs3.promises.symlink(source, target);
             }
           } else {
             if (isWindows) {
-              await import_fs4.promises.symlink(source, target, "junction");
+              await import_fs3.promises.symlink(source, target, "junction");
             } else {
-              await import_fs4.promises.symlink(source, target, "dir");
+              await import_fs3.promises.symlink(source, target, "dir");
             }
           }
           log8.debug(`Created symlink: ${target} -> ${source}`);
@@ -5492,7 +5486,7 @@ var init_node_file_system = __esm({
       async removeSymlink(filePath) {
         try {
           if (await this.isSymlink(filePath)) {
-            await import_fs4.promises.unlink(filePath);
+            await import_fs3.promises.unlink(filePath);
             log8.debug(`Removed symlink: ${filePath}`);
           }
         } catch (error) {
@@ -5502,7 +5496,7 @@ var init_node_file_system = __esm({
       }
       async isSymlink(filePath) {
         try {
-          const stats = await import_fs4.promises.lstat(filePath);
+          const stats = await import_fs3.promises.lstat(filePath);
           return stats.isSymbolicLink();
         } catch {
           return false;
@@ -5510,7 +5504,7 @@ var init_node_file_system = __esm({
       }
       async readSymlink(filePath) {
         try {
-          return await import_fs4.promises.readlink(filePath);
+          return await import_fs3.promises.readlink(filePath);
         } catch (error) {
           log8.error(`Failed to read symlink: ${filePath}`, error);
           throw error;
@@ -5518,7 +5512,7 @@ var init_node_file_system = __esm({
       }
       async createDirectory(dirPath, recursive = false) {
         try {
-          await import_fs4.promises.mkdir(dirPath, { recursive });
+          await import_fs3.promises.mkdir(dirPath, { recursive });
           log8.debug(`Created directory: ${dirPath}`);
         } catch (error) {
           log8.error(`Failed to create directory: ${dirPath}`, error);
@@ -5527,11 +5521,11 @@ var init_node_file_system = __esm({
       }
       async remove(filePath, recursive = false) {
         try {
-          const stats = await import_fs4.promises.lstat(filePath);
+          const stats = await import_fs3.promises.lstat(filePath);
           if (stats.isDirectory()) {
-            await import_fs4.promises.rm(filePath, { recursive, force: true });
+            await import_fs3.promises.rm(filePath, { recursive, force: true });
           } else {
-            await import_fs4.promises.unlink(filePath);
+            await import_fs3.promises.unlink(filePath);
           }
           log8.debug(`Removed: ${filePath}`);
         } catch (error) {
@@ -5541,7 +5535,7 @@ var init_node_file_system = __esm({
       }
       async stat(filePath) {
         try {
-          const stats = await import_fs4.promises.stat(filePath);
+          const stats = await import_fs3.promises.stat(filePath);
           return {
             isFile: () => stats.isFile(),
             isDirectory: () => stats.isDirectory(),
@@ -5556,11 +5550,11 @@ var init_node_file_system = __esm({
       }
       async copyFile(source, target) {
         try {
-          const targetDir = import_path7.default.dirname(target);
+          const targetDir = import_path4.default.dirname(target);
           if (!await this.exists(targetDir)) {
-            await import_fs4.promises.mkdir(targetDir, { recursive: true });
+            await import_fs3.promises.mkdir(targetDir, { recursive: true });
           }
-          await import_fs4.promises.copyFile(source, target);
+          await import_fs3.promises.copyFile(source, target);
           log8.debug(`Copied file: ${source} -> ${target}`);
         } catch (error) {
           log8.error(`Failed to copy file: ${source} -> ${target}`, error);
@@ -5569,7 +5563,7 @@ var init_node_file_system = __esm({
       }
       async readFile(filePath, encoding = "utf-8") {
         try {
-          return await import_fs4.promises.readFile(filePath, encoding);
+          return await import_fs3.promises.readFile(filePath, encoding);
         } catch (error) {
           log8.error(`Failed to read file: ${filePath}`, error);
           throw error;
@@ -5577,11 +5571,11 @@ var init_node_file_system = __esm({
       }
       async writeFile(filePath, content, encoding = "utf-8") {
         try {
-          const dir2 = import_path7.default.dirname(filePath);
+          const dir2 = import_path4.default.dirname(filePath);
           if (!await this.exists(dir2)) {
-            await import_fs4.promises.mkdir(dir2, { recursive: true });
+            await import_fs3.promises.mkdir(dir2, { recursive: true });
           }
-          await import_fs4.promises.writeFile(filePath, content, encoding);
+          await import_fs3.promises.writeFile(filePath, content, encoding);
           log8.debug(`Wrote file: ${filePath}`);
         } catch (error) {
           log8.error(`Failed to write file: ${filePath}`, error);
@@ -5590,7 +5584,7 @@ var init_node_file_system = __esm({
       }
       async unlink(filePath) {
         try {
-          await import_fs4.promises.unlink(filePath);
+          await import_fs3.promises.unlink(filePath);
           log8.debug(`Deleted file: ${filePath}`);
         } catch (error) {
           log8.error(`Failed to delete file: ${filePath}`, error);
@@ -5599,22 +5593,40 @@ var init_node_file_system = __esm({
       }
       async access(filePath) {
         try {
-          await import_fs4.promises.access(filePath);
+          await import_fs3.promises.access(filePath);
         } catch (error) {
           throw new Error(`Cannot access path: ${filePath}`);
         }
       }
       async resolvePath(filePath) {
-        return import_path7.default.resolve(filePath);
+        return import_path4.default.resolve(filePath);
       }
       basename(filePath) {
-        return import_path7.default.basename(filePath);
+        return import_path4.default.basename(filePath);
       }
       dirname(filePath) {
-        return import_path7.default.dirname(filePath);
+        return import_path4.default.dirname(filePath);
       }
       join(...paths) {
-        return import_path7.default.join(...paths);
+        return import_path4.default.join(...paths);
+      }
+      // ============================================================================
+      // Path Operations (Sync)
+      // ============================================================================
+      resolvePathSync(...paths) {
+        return import_path4.default.resolve(...paths);
+      }
+      relative(from, to) {
+        return import_path4.default.relative(from, to);
+      }
+      parsePath(filePath) {
+        return import_path4.default.parse(filePath);
+      }
+      normalize(filePath) {
+        return import_path4.default.normalize(filePath);
+      }
+      isAbsolute(filePath) {
+        return import_path4.default.isAbsolute(filePath);
       }
     };
   }
@@ -5828,10 +5840,10 @@ var init_publish_manifest = __esm({
        */
       getChangedFiles(newManifest) {
         const changedFiles = [];
-        for (const [path43, newEntry] of newManifest.files.entries()) {
-          const oldEntry = this.files.get(path43);
+        for (const [path40, newEntry] of newManifest.files.entries()) {
+          const oldEntry = this.files.get(path40);
           if (!oldEntry || oldEntry.hash !== newEntry.hash) {
-            changedFiles.push(path43);
+            changedFiles.push(path40);
           }
         }
         return changedFiles;
@@ -5842,9 +5854,9 @@ var init_publish_manifest = __esm({
        */
       getDeletedFiles(newManifest) {
         const deletedFiles = [];
-        for (const path43 of this.files.keys()) {
-          if (!newManifest.files.has(path43)) {
-            deletedFiles.push(path43);
+        for (const path40 of this.files.keys()) {
+          if (!newManifest.files.has(path40)) {
+            deletedFiles.push(path40);
           }
         }
         return deletedFiles;
@@ -5854,8 +5866,8 @@ var init_publish_manifest = __esm({
        */
       toJSON() {
         const filesObj = {};
-        for (const [path43, entry] of this.files.entries()) {
-          filesObj[path43] = entry;
+        for (const [path40, entry] of this.files.entries()) {
+          filesObj[path40] = entry;
         }
         return {
           projectId: this.projectId,
@@ -7447,8 +7459,8 @@ var require_Client = __commonJS({
       /**
        * Set the working directory.
        */
-      async cd(path43) {
-        const validPath = await this.protectWhitespace(path43);
+      async cd(path40) {
+        const validPath = await this.protectWhitespace(path40);
         return this.send("CWD " + validPath);
       }
       /**
@@ -7461,8 +7473,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(path43) {
-        const validPath = await this.protectWhitespace(path43);
+      async lastMod(path40) {
+        const validPath = await this.protectWhitespace(path40);
         const res = await this.send(`MDTM ${validPath}`);
         const date = res.message.slice(4);
         return (0, parseListMLSD_1.parseMLSxDate)(date);
@@ -7470,8 +7482,8 @@ var require_Client = __commonJS({
       /**
        * Get the size of a file.
        */
-      async size(path43) {
-        const validPath = await this.protectWhitespace(path43);
+      async size(path40) {
+        const validPath = await this.protectWhitespace(path40);
         const command = `SIZE ${validPath}`;
         const res = await this.send(command);
         const size = parseInt(res.message.slice(4), 10);
@@ -7498,8 +7510,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(path43, ignoreErrorCodes = false) {
-        const validPath = await this.protectWhitespace(path43);
+      async remove(path40, ignoreErrorCodes = false) {
+        const validPath = await this.protectWhitespace(path40);
         if (ignoreErrorCodes) {
           return this.sendIgnoringError(`DELE ${validPath}`);
         }
@@ -7653,8 +7665,8 @@ var require_Client = __commonJS({
        *
        * @param [path]  Path to remote file or directory.
        */
-      async list(path43 = "") {
-        const validPath = await this.protectWhitespace(path43);
+      async list(path40 = "") {
+        const validPath = await this.protectWhitespace(path40);
         let lastError;
         for (const candidate of this.availableListCommands) {
           const command = validPath === "" ? candidate : `${candidate} ${validPath}`;
@@ -7824,21 +7836,21 @@ var require_Client = __commonJS({
       /**
        * Remove an empty directory, will fail if not empty.
        */
-      async removeEmptyDir(path43) {
-        const validPath = await this.protectWhitespace(path43);
+      async removeEmptyDir(path40) {
+        const validPath = await this.protectWhitespace(path40);
         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(path43) {
-        if (!path43.startsWith(" ")) {
-          return path43;
+      async protectWhitespace(path40) {
+        if (!path40.startsWith(" ")) {
+          return path40;
         }
         const pwd = await this.pwd();
         const absolutePathPrefix = pwd.endsWith("/") ? pwd : pwd + "/";
-        return absolutePathPrefix + path43;
+        return absolutePathPrefix + path40;
       }
       async _exitAtCurrentDirectory(func) {
         const userDir = await this.pwd();
@@ -7915,11 +7927,11 @@ var require_Client = __commonJS({
       }
     };
     exports2.Client = Client2;
-    async function ensureLocalDirectory(path43) {
+    async function ensureLocalDirectory(path40) {
       try {
-        await fsStat(path43);
+        await fsStat(path40);
       } catch (_a2) {
-        await fsMkDir(path43, { recursive: true });
+        await fsMkDir(path40, { recursive: true });
       }
     }
     async function ignoreError(func) {
@@ -7982,14 +7994,14 @@ var require_dist = __commonJS({
 });
 
 // internal/domain/publish/value-object/ftp-publisher.ts
-var ftp, import_path8, import_fs5, log10, FtpPublisher;
+var ftp, import_path5, import_fs4, log10, FtpPublisher;
 var init_ftp_publisher = __esm({
   "internal/domain/publish/value-object/ftp-publisher.ts"() {
     "use strict";
     init_log();
     ftp = __toESM(require_dist());
-    import_path8 = __toESM(require("path"));
-    import_fs5 = require("fs");
+    import_path5 = __toESM(require("path"));
+    import_fs4 = require("fs");
     log10 = getDomainLogger("ftp-publisher", { component: "domain" });
     FtpPublisher = class {
       constructor(config, manifestRepo, projectId, projectPath) {
@@ -8036,10 +8048,10 @@ var init_ftp_publisher = __esm({
           });
           const createdDirs = /* @__PURE__ */ new Set();
           for (const relativePath of changedFiles) {
-            const localPath = import_path8.default.join(sourceDir, relativePath);
+            const localPath = import_path5.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_path8.default.dirname(remoteFilePath).replace(/\\/g, "/");
+              const remoteDir = import_path5.default.dirname(remoteFilePath).replace(/\\/g, "/");
               if (remoteDir && remoteDir !== "." && remoteDir !== "/") {
                 if (!createdDirs.has(remoteDir)) {
                   try {
@@ -8052,7 +8064,7 @@ var init_ftp_publisher = __esm({
                 }
               }
               await this.uploadFileWithRetry(client, localPath, remoteFilePath, relativePath, 2);
-              const stats = await import_fs5.promises.stat(localPath);
+              const stats = await import_fs4.promises.stat(localPath);
               bytesTransferred += stats.size;
               filesUploaded++;
               completedFiles++;
@@ -8270,13 +8282,13 @@ var init_ftp_publisher = __esm({
 });
 
 // internal/domain/publish/value-object/netlify-publisher.ts
-var import_path9, import_fs6, log11, NetlifyPublisher;
+var import_path6, import_fs5, log11, NetlifyPublisher;
 var init_netlify_publisher = __esm({
   "internal/domain/publish/value-object/netlify-publisher.ts"() {
     "use strict";
     init_log();
-    import_path9 = __toESM(require("path"));
-    import_fs6 = require("fs");
+    import_path6 = __toESM(require("path"));
+    import_fs5 = require("fs");
     log11 = getDomainLogger("netlify-publisher", { component: "domain" });
     NetlifyPublisher = class {
       constructor(config, manifestRepo, httpClient, projectId, projectPath) {
@@ -8537,9 +8549,9 @@ var init_netlify_publisher = __esm({
             log11.warn(`File not found in manifest: ${filePath}`);
             continue;
           }
-          const localFilePath = import_path9.default.join(sourceDir, filePath);
+          const localFilePath = import_path6.default.join(sourceDir, filePath);
           try {
-            const fileContent = await import_fs6.promises.readFile(localFilePath);
+            const fileContent = await import_fs5.promises.readFile(localFilePath);
             await this.uploadFileWithRetry(deployId, filePath, fileContent, fileEntry.hash);
             filesUploaded++;
             bytesTransferred += fileEntry.size;
@@ -8681,13 +8693,13 @@ var mdfriday_publisher_exports = {};
 __export(mdfriday_publisher_exports, {
   MDFridayPublisher: () => MDFridayPublisher
 });
-var import_path10, import_fs7, log12, MDFridayPublisher;
+var import_path7, import_fs6, log12, MDFridayPublisher;
 var init_mdfriday_publisher = __esm({
   "internal/domain/publish/value-object/mdfriday-publisher.ts"() {
     "use strict";
     init_log();
-    import_path10 = __toESM(require("path"));
-    import_fs7 = require("fs");
+    import_path7 = __toESM(require("path"));
+    import_fs6 = require("fs");
     log12 = getDomainLogger("mdfriday-publisher", { component: "domain" });
     MDFridayPublisher = class {
       constructor(config, manifestRepo, httpClient, projectId, projectPath) {
@@ -8904,9 +8916,9 @@ var init_mdfriday_publisher = __esm({
         const zip = new JSZip2();
         log12.debug(`Creating incremental ZIP with ${filesToInclude.length} files`);
         for (const relativePath of filesToInclude) {
-          const filePath = import_path10.default.join(sourceDir, relativePath);
+          const filePath = import_path7.default.join(sourceDir, relativePath);
           try {
-            const fileContent = await import_fs7.promises.readFile(filePath);
+            const fileContent = await import_fs6.promises.readFile(filePath);
             zip.file(relativePath, new Uint8Array(fileContent));
           } catch (error) {
             log12.error(`Failed to add file to ZIP: ${relativePath}`, error);
@@ -8926,16 +8938,16 @@ var init_mdfriday_publisher = __esm({
         const JSZip2 = require("jszip");
         const zip = new JSZip2();
         const addDirectoryToZip = async (dirPath, zipFolder) => {
-          const items = await import_fs7.promises.readdir(dirPath, { withFileTypes: true });
+          const items = await import_fs6.promises.readdir(dirPath, { withFileTypes: true });
           for (const item of items) {
-            const itemPath = import_path10.default.join(dirPath, item.name);
+            const itemPath = import_path7.default.join(dirPath, item.name);
             if (item.isDirectory()) {
               const subFolder = zipFolder.folder(item.name);
               if (subFolder) {
                 await addDirectoryToZip(itemPath, subFolder);
               }
             } else if (item.isFile()) {
-              const fileContent = await import_fs7.promises.readFile(itemPath);
+              const fileContent = await import_fs6.promises.readFile(itemPath);
               zipFolder.file(item.name, new Uint8Array(fileContent));
             }
           }
@@ -9027,10 +9039,10 @@ var init_mdfriday_publisher = __esm({
       /**
        * Build multipart form data for upload
        */
-      buildFormData(zipContent, projectName, path43, deploymentType) {
+      buildFormData(zipContent, projectName, path40, deploymentType) {
         return {
           type: deploymentType,
-          path: path43,
+          path: path40,
           id: "-1",
           // NEW_ID
           name: projectName,
@@ -9186,14 +9198,14 @@ var init_publish = __esm({
 });
 
 // internal/infrastructure/persistence/node-manifest-repository.ts
-var import_path11, import_fs8, import_crypto, log14, NodeManifestRepository;
+var import_path8, import_fs7, import_crypto, log14, NodeManifestRepository;
 var init_node_manifest_repository = __esm({
   "internal/infrastructure/persistence/node-manifest-repository.ts"() {
     "use strict";
     init_publish();
     init_log();
-    import_path11 = __toESM(require("path"));
-    import_fs8 = require("fs");
+    import_path8 = __toESM(require("path"));
+    import_fs7 = require("fs");
     import_crypto = __toESM(require("crypto"));
     log14 = getDomainLogger("node-manifest-repo", { component: "infrastructure" });
     NodeManifestRepository = class {
@@ -9203,7 +9215,7 @@ var init_node_manifest_repository = __esm({
       async loadManifest(projectPath, publishMethod, suffix) {
         const manifestPath = this.getManifestPath(projectPath, publishMethod, suffix);
         try {
-          const content = await import_fs8.promises.readFile(manifestPath, "utf-8");
+          const content = await import_fs7.promises.readFile(manifestPath, "utf-8");
           const json = JSON.parse(content);
           return PublishManifest.fromJSON(json);
         } catch (error) {
@@ -9219,14 +9231,14 @@ var init_node_manifest_repository = __esm({
        * Save manifest to file
        */
       async saveManifest(projectPath, manifest, suffix) {
-        const manifestDir = import_path11.default.join(projectPath, ".mdfriday");
-        await import_fs8.promises.mkdir(manifestDir, { recursive: true });
+        const manifestDir = import_path8.default.join(projectPath, ".mdfriday");
+        await import_fs7.promises.mkdir(manifestDir, { recursive: true });
         const manifestPath = this.getManifestPath(
           projectPath,
           manifest.getPublishMethod(),
           suffix
         );
-        await import_fs8.promises.writeFile(
+        await import_fs7.promises.writeFile(
           manifestPath,
           JSON.stringify(manifest.toJSON(), null, 2),
           "utf-8"
@@ -9255,7 +9267,7 @@ var init_node_manifest_repository = __esm({
       async deleteManifest(projectPath, publishMethod, suffix) {
         const manifestPath = this.getManifestPath(projectPath, publishMethod, suffix);
         try {
-          await import_fs8.promises.unlink(manifestPath);
+          await import_fs7.promises.unlink(manifestPath);
           log14.debug(`Manifest deleted: ${manifestPath}`);
           return true;
         } catch (error) {
@@ -9278,20 +9290,20 @@ var init_node_manifest_repository = __esm({
        */
       getManifestPath(projectPath, publishMethod, suffix) {
         const filename = suffix ? `manifest-${publishMethod}-${suffix}.json` : `manifest-${publishMethod}.json`;
-        return import_path11.default.join(projectPath, ".mdfriday", filename);
+        return import_path8.default.join(projectPath, ".mdfriday", filename);
       }
       /**
        * Recursively scan directory and collect file info
        */
       async scanDirectory(currentPath, relativePath, files, hashAlgorithm = "md5") {
-        const items = await import_fs8.promises.readdir(currentPath, { withFileTypes: true });
+        const items = await import_fs7.promises.readdir(currentPath, { withFileTypes: true });
         for (const item of items) {
-          const itemPath = import_path11.default.join(currentPath, item.name);
-          const itemRelativePath = relativePath ? import_path11.default.join(relativePath, item.name) : item.name;
+          const itemPath = import_path8.default.join(currentPath, item.name);
+          const itemRelativePath = relativePath ? import_path8.default.join(relativePath, item.name) : item.name;
           if (item.isDirectory()) {
             await this.scanDirectory(itemPath, itemRelativePath, files, hashAlgorithm);
           } else if (item.isFile()) {
-            const stats = await import_fs8.promises.stat(itemPath);
+            const stats = await import_fs7.promises.stat(itemPath);
             const hash = await this.calculateFileHash(itemPath, hashAlgorithm);
             const normalizedPath = itemRelativePath.replace(/\\/g, "/");
             files.set(normalizedPath, {
@@ -9309,8 +9321,8 @@ var init_node_manifest_repository = __esm({
       async calculateFileHash(filePath, algorithm = "md5") {
         return new Promise((resolve3, reject) => {
           const hash = import_crypto.default.createHash(algorithm);
-          const fs14 = require("fs");
-          const stream = fs14.createReadStream(filePath);
+          const fs13 = require("fs");
+          const stream = fs13.createReadStream(filePath);
           stream.on("data", (data) => hash.update(data));
           stream.on("end", () => resolve3(hash.digest("hex")));
           stream.on("error", reject);
@@ -10269,8 +10281,8 @@ var init_module2 = __esm({
       /**
        * Find import by path
        */
-      findImport(path43) {
-        return this.moduleConfig.imports.find((imp) => imp.path === path43);
+      findImport(path40) {
+        return this.moduleConfig.imports.find((imp) => imp.path === path40);
       }
       /**
        * Find mount by source
@@ -11519,11 +11531,11 @@ var init_markdown2 = __esm({
 function newDir(workingDir, themesDir, publishDir) {
   return new Dir(workingDir, themesDir, publishDir);
 }
-var import_path12, DEFAULT_PUBLISH_DIR, Dir;
+var import_path9, DEFAULT_PUBLISH_DIR, Dir;
 var init_dir = __esm({
   "internal/domain/config/entity/dir.ts"() {
     "use strict";
-    import_path12 = __toESM(require("path"));
+    import_path9 = __toESM(require("path"));
     DEFAULT_PUBLISH_DIR = "public";
     Dir = class {
       workingDir;
@@ -11535,16 +11547,16 @@ var init_dir = __esm({
         this.publishDir = publishDir;
       }
       getWorkingDir() {
-        return import_path12.default.resolve(this.workingDir);
+        return import_path9.default.resolve(this.workingDir);
       }
       getThemesDir() {
-        return import_path12.default.resolve(this.themesDir);
+        return import_path9.default.resolve(this.themesDir);
       }
       getThemesCacheDir() {
-        return import_path12.default.resolve(this.themesDir, ".cache");
+        return import_path9.default.resolve(this.themesDir, ".cache");
       }
       getPublishDir() {
-        return import_path12.default.resolve(this.publishDir);
+        return import_path9.default.resolve(this.publishDir);
       }
     };
   }
@@ -11734,12 +11746,12 @@ var init_provider = __esm({
 });
 
 // internal/domain/config/factory/loader.ts
-var path13, NO_CONFIG_FILE_ERR_INFO, ConfigLoader;
+var path10, NO_CONFIG_FILE_ERR_INFO, ConfigLoader;
 var init_loader = __esm({
   "internal/domain/config/factory/loader.ts"() {
     "use strict";
     init_provider();
-    path13 = __toESM(require("path"));
+    path10 = __toESM(require("path"));
     NO_CONFIG_FILE_ERR_INFO = "Unable to locate config file or config directory.";
     ConfigLoader = class {
       cfg;
@@ -11778,13 +11790,13 @@ var init_loader = __esm({
       async loadProvider(configName) {
         const baseDir = this.baseDirs.workingDir;
         let baseFilename;
-        if (path13.isAbsolute(configName)) {
+        if (path10.isAbsolute(configName)) {
           baseFilename = configName;
         } else {
-          baseFilename = path13.join(baseDir, configName);
+          baseFilename = path10.join(baseDir, configName);
         }
         let filename = "";
-        if (path13.extname(configName) !== "") {
+        if (path10.extname(configName) !== "") {
           const exists = await this.fileExists(baseFilename);
           if (exists) {
             filename = baseFilename;
@@ -11866,8 +11878,8 @@ var init_loader = __esm({
        */
       async fileExists(filename) {
         try {
-          const fs14 = this.sourceDescriptor.fs();
-          const stat4 = await fs14.stat(filename);
+          const fs13 = this.sourceDescriptor.fs();
+          const stat4 = await fs13.stat(filename);
           return !stat4.isDir();
         } catch {
           return false;
@@ -11877,8 +11889,8 @@ var init_loader = __esm({
        * Load configuration from file
        */
       async loadConfigFromFile(filename) {
-        const fs14 = this.sourceDescriptor.fs();
-        const file = await fs14.open(filename);
+        const fs13 = this.sourceDescriptor.fs();
+        const file = await fs13.open(filename);
         try {
           const buffer = new Uint8Array(1024 * 1024);
           const { bytesRead } = await file.read(buffer);
@@ -11897,8 +11909,8 @@ var init_loader = __esm({
 });
 
 // internal/domain/config/factory/sourcedescriptor.ts
-function newSourceDescriptor(fs14, filename) {
-  return new ConfigSourceDescriptor(fs14, filename);
+function newSourceDescriptor(fs13, filename) {
+  return new ConfigSourceDescriptor(fs13, filename);
 }
 var ConfigSourceDescriptor;
 var init_sourcedescriptor = __esm({
@@ -11907,8 +11919,8 @@ var init_sourcedescriptor = __esm({
     ConfigSourceDescriptor = class {
       fileSystem;
       configFilename;
-      constructor(fs14, filename) {
-        this.fileSystem = fs14;
+      constructor(fs13, filename) {
+        this.fileSystem = fs13;
         this.configFilename = filename;
       }
       fs() {
@@ -11922,19 +11934,19 @@ var init_sourcedescriptor = __esm({
 });
 
 // internal/domain/config/factory/config.ts
-async function loadConfigWithParams(fs14, configFilename, workingDir, modulesDir, params = {}) {
-  const cleanWorkingDir = path14.resolve(workingDir);
-  const cleanModulesDir = path14.resolve(modulesDir);
-  const cleanPublishDir = path14.resolve(DEFAULT_PUBLISH_DIR);
+async function loadConfigWithParams(fs13, configFilename, workingDir, modulesDir, params = {}) {
+  const cleanWorkingDir = path11.resolve(workingDir);
+  const cleanModulesDir = path11.resolve(modulesDir);
+  const cleanPublishDir = path11.resolve(DEFAULT_PUBLISH_DIR);
   const baseDirs = {
     workingDir: cleanWorkingDir,
     modulesDir: cleanModulesDir,
     publishDir: cleanPublishDir,
     cacheDir: ""
   };
-  baseDirs.cacheDir = await getCacheDir(fs14, baseDirs.cacheDir);
+  baseDirs.cacheDir = await getCacheDir(fs13, baseDirs.cacheDir);
   const loader = new ConfigLoader(
-    newSourceDescriptor(fs14, configFilename),
+    newSourceDescriptor(fs13, configFilename),
     baseDirs
   );
   try {
@@ -11942,10 +11954,10 @@ async function loadConfigWithParams(fs14, configFilename, workingDir, modulesDir
     for (const [key2, value] of Object.entries(params)) {
       provider.set(key2, value);
     }
-    const absPublishDir = path14.resolve(provider.get("publishDir") || DEFAULT_PUBLISH_DIR);
-    await fs14.mkdirAll(absPublishDir, 511);
+    const absPublishDir = path11.resolve(provider.get("publishDir") || DEFAULT_PUBLISH_DIR);
+    await fs13.mkdirAll(absPublishDir, 511);
     return newConfig(
-      fs14,
+      fs13,
       provider,
       newRoot(provider.get(""), provider.getParams("params")),
       newDir(baseDirs.workingDir, baseDirs.modulesDir, absPublishDir),
@@ -11960,20 +11972,20 @@ async function loadConfigWithParams(fs14, configFilename, workingDir, modulesDir
     loader.deleteMergeStrategies();
   }
 }
-async function getCacheDir(fs14, cacheDir) {
+async function getCacheDir(fs13, cacheDir) {
   if (cacheDir !== "") {
     return cacheDir;
   }
   const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-  const defaultCacheDir = path14.join(homeDir, ".cache", "mdf");
+  const defaultCacheDir = path11.join(homeDir, ".cache", "mdf");
   try {
-    await fs14.mkdirAll(defaultCacheDir, 493);
+    await fs13.mkdirAll(defaultCacheDir, 493);
     return defaultCacheDir;
   } catch {
-    return path14.join("/tmp", "hugo-cache");
+    return path11.join("/tmp", "hugo-cache");
   }
 }
-var path14;
+var path11;
 var init_config2 = __esm({
   "internal/domain/config/factory/config.ts"() {
     "use strict";
@@ -11988,7 +12000,7 @@ var init_config2 = __esm({
     init_markdown2();
     init_loader();
     init_sourcedescriptor();
-    path14 = __toESM(require("path"));
+    path11 = __toESM(require("path"));
   }
 });
 
@@ -12060,11 +12072,11 @@ function createDefaultMounts(componentFolders) {
     (folder) => new Mount(folder, folder)
   );
 }
-var path15, Mount;
+var path12, Mount;
 var init_mount = __esm({
   "internal/domain/module/vo/mount.ts"() {
     "use strict";
-    path15 = __toESM(require("path"));
+    path12 = __toESM(require("path"));
     Mount = class _Mount {
       constructor(sourcePath, targetPath, language2 = "") {
         this.sourcePath = sourcePath;
@@ -12099,16 +12111,16 @@ var init_mount = __esm({
        * Get component name from target path
        */
       component() {
-        const parts = this.targetPath.split(path15.sep);
+        const parts = this.targetPath.split(path12.sep);
         return parts[0] || "";
       }
       /**
        * Get component and name from target path
        */
       componentAndName() {
-        const parts = this.targetPath.split(path15.sep);
+        const parts = this.targetPath.split(path12.sep);
         const component = parts[0] || "";
-        const name = parts.slice(1).join(path15.sep);
+        const name = parts.slice(1).join(path12.sep);
         return { component, name };
       }
       /**
@@ -12147,25 +12159,25 @@ var init_mount = __esm({
 });
 
 // internal/domain/module/vo/httpclient.ts
-function newHttpClient(fs14, timeout, headers, customClient) {
+function newHttpClient(fs13, timeout, headers, customClient) {
   if (customClient) {
     return customClient;
   }
-  return new NodeHttpClient2(fs14, timeout, headers);
+  return new NodeHttpClient2(fs13, timeout, headers);
 }
-var path16, http, https, log20, NodeHttpClient2;
+var path13, http, https, log20, NodeHttpClient2;
 var init_httpclient = __esm({
   "internal/domain/module/vo/httpclient.ts"() {
     "use strict";
     init_type5();
-    path16 = __toESM(require("path"));
+    path13 = __toESM(require("path"));
     http = __toESM(require("http"));
     https = __toESM(require("https"));
     init_log();
     log20 = getDomainLogger("module", { component: "httpclient" });
     NodeHttpClient2 = class {
-      constructor(fs14, timeout = 3e4, headers = {}) {
-        this.fs = fs14;
+      constructor(fs13, timeout = 3e4, headers = {}) {
+        this.fs = fs13;
         this.timeout = timeout;
         this.headers = headers;
       }
@@ -12209,7 +12221,7 @@ var init_httpclient = __esm({
               let lastProgressTime = Date.now();
               let lastLoggedPercentage = -1;
               try {
-                const targetDir = path16.dirname(targetPath);
+                const targetDir = path13.dirname(targetPath);
                 await this.fs.mkdirAll(targetDir, 493);
                 const file = await this.fs.create(targetPath);
                 const chunks = [];
@@ -12350,28 +12362,28 @@ var init_httpclient = __esm({
 });
 
 // internal/domain/module/vo/zipextractor.ts
-function newZipExtractor(fs14, environment = "node") {
+function newZipExtractor(fs13, environment = "node") {
   switch (environment) {
     case "node":
-      return new JsZipExtractor(fs14);
+      return new JsZipExtractor(fs13);
     case "browser":
-      return new WebZipExtractor(fs14);
+      return new WebZipExtractor(fs13);
     default:
       throw new Error(`Unsupported environment: ${environment}`);
   }
 }
-var import_jszip, path17, log21, JsZipExtractor, WebZipExtractor;
+var import_jszip, path14, log21, JsZipExtractor, WebZipExtractor;
 var init_zipextractor = __esm({
   "internal/domain/module/vo/zipextractor.ts"() {
     "use strict";
     init_type5();
     init_log();
     import_jszip = __toESM(require("jszip"));
-    path17 = __toESM(require("path"));
+    path14 = __toESM(require("path"));
     log21 = getDomainLogger("module", { component: "zipextractor" });
     JsZipExtractor = class {
-      constructor(fs14) {
-        this.fs = fs14;
+      constructor(fs13) {
+        this.fs = fs13;
       }
       /**
        * Extract ZIP file to target directory
@@ -12441,11 +12453,11 @@ var init_zipextractor = __esm({
        * Extract a single ZIP entry (file or directory)
        */
       async extractSingleEntry(relativePath, zipEntry, targetDir) {
-        const fullPath = path17.join(targetDir, relativePath);
+        const fullPath = path14.join(targetDir, relativePath);
         if (zipEntry.dir) {
           await this.fs.mkdirAll(fullPath, 493);
         } else {
-          const dir2 = path17.dirname(fullPath);
+          const dir2 = path14.dirname(fullPath);
           if (dir2 !== targetDir) {
             await this.fs.mkdirAll(dir2, 493);
           }
@@ -12474,8 +12486,8 @@ var init_zipextractor = __esm({
       }
     };
     WebZipExtractor = class {
-      constructor(fs14) {
-        this.fs = fs14;
+      constructor(fs13) {
+        this.fs = fs13;
       }
       async extract(zipPath, targetDir) {
         try {
@@ -12498,20 +12510,20 @@ var init_zipextractor = __esm({
 });
 
 // internal/domain/module/vo/cache.ts
-function newModuleCache(fs14, cacheDir) {
-  return new FsModuleCache(fs14, cacheDir);
+function newModuleCache(fs13, cacheDir) {
+  return new FsModuleCache(fs13, cacheDir);
 }
-var path18, log22, FsModuleCache;
+var path15, log22, FsModuleCache;
 var init_cache = __esm({
   "internal/domain/module/vo/cache.ts"() {
     "use strict";
     init_type5();
     init_log();
-    path18 = __toESM(require("path"));
+    path15 = __toESM(require("path"));
     log22 = getDomainLogger("module", { component: "cache" });
     FsModuleCache = class {
-      constructor(fs14, cacheDir = "./module/cache") {
-        this.fs = fs14;
+      constructor(fs13, cacheDir = "./module/cache") {
+        this.fs = fs13;
         this.cacheDir = cacheDir;
       }
       cacheDir;
@@ -12603,7 +12615,7 @@ var init_cache = __esm({
        */
       getCacheFilePath(modulePath) {
         const safeFileName = modulePath.replace(/[/\\:*?"<>|]/g, "_").replace(/^_+|_+$/g, "") + ".json";
-        return path18.join(this.cacheDir, safeFileName);
+        return path15.join(this.cacheDir, safeFileName);
       }
       /**
        * Get cache directory
@@ -12620,7 +12632,7 @@ var init_cache = __esm({
           let totalSize = 0;
           for (const file of files) {
             try {
-              const filePath = path18.join(this.cacheDir, file);
+              const filePath = path15.join(this.cacheDir, file);
               const fileInfo = await this.fs.stat(filePath);
               totalSize += fileInfo.size();
             } catch (error) {
@@ -12644,7 +12656,7 @@ var init_cache = __esm({
         try {
           const files = await this.listCacheFiles();
           return files.map(
-            (file) => path18.basename(file, ".json").replace(/_/g, "/")
+            (file) => path15.basename(file, ".json").replace(/_/g, "/")
           );
         } catch (error) {
           return [];
@@ -12668,15 +12680,15 @@ var init_cache = __esm({
 });
 
 // internal/domain/module/vo/module.ts
-function newModule2(fs14, absoluteDir, modulePath, parent) {
-  return new Module2(fs14, absoluteDir, modulePath, parent || null, false);
+function newModule2(fs13, absoluteDir, modulePath, parent) {
+  return new Module2(fs13, absoluteDir, modulePath, parent || null, false);
 }
 function newProjectModule(info) {
-  const fs14 = info.osFs();
+  const fs13 = info.osFs();
   const absoluteDir = info.projDir();
   const modulePath = "project-root";
   const defaultLanguage3 = info.defaultLanguageKey();
-  const module2 = new Module2(fs14, absoluteDir, modulePath, null, true);
+  const module2 = new Module2(fs13, absoluteDir, modulePath, null, true);
   const projectModule = new ProjectModule(module2);
   projectModule.applyDefaultMounts();
   if (defaultLanguage3) {
@@ -12696,16 +12708,16 @@ function newProjectModule(info) {
   }
   return projectModule;
 }
-var path19, Module2, ProjectModule;
+var path16, Module2, ProjectModule;
 var init_module3 = __esm({
   "internal/domain/module/vo/module.ts"() {
     "use strict";
     init_type5();
     init_mount();
-    path19 = __toESM(require("path"));
+    path16 = __toESM(require("path"));
     Module2 = class _Module {
-      constructor(fs14, absoluteDir, modulePath, parent = null, isProject = false) {
-        this.fs = fs14;
+      constructor(fs13, absoluteDir, modulePath, parent = null, isProject = false) {
+        this.fs = fs13;
         this.absoluteDir = absoluteDir;
         this.modulePath = modulePath;
         this.parentModule = parent;
@@ -12766,7 +12778,7 @@ var init_module3 = __esm({
           let mounts = moduleImport.mounts || [];
           if (mounts.length === 0) {
             for (const componentFolder of ComponentFolders) {
-              const sourceDir = path19.join(this.absoluteDir, componentFolder);
+              const sourceDir = path16.join(this.absoluteDir, componentFolder);
               try {
                 const stat4 = await this.fs.stat(sourceDir);
                 if (stat4.isDir()) {
@@ -12917,11 +12929,11 @@ var init_module3 = __esm({
 function newLang(modules) {
   return new Lang(modules);
 }
-var import_path13, Lang;
+var import_path10, Lang;
 var init_lang2 = __esm({
   "internal/domain/module/entity/lang.ts"() {
     "use strict";
-    import_path13 = __toESM(require("path"));
+    import_path10 = __toESM(require("path"));
     Lang = class {
       sourceLangMap;
       constructor(modules) {
@@ -12937,7 +12949,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_path13.default.basename(source));
+        const lang2 = this.sourceLangMap.get(import_path10.default.basename(source));
         if (lang2 !== void 0) {
           return [lang2, true];
         }
@@ -13040,7 +13052,7 @@ var init_themes = __esm({
 function newModules(info, httpClient, zipExtractor, moduleCache) {
   return new Modules(info, httpClient, zipExtractor, moduleCache);
 }
-var import_smol_toml, path21, log23, Modules;
+var import_smol_toml, path18, log23, Modules;
 var init_module4 = __esm({
   "internal/domain/module/entity/module.ts"() {
     "use strict";
@@ -13050,7 +13062,7 @@ var init_module4 = __esm({
     init_themes();
     init_log();
     import_smol_toml = require("smol-toml");
-    path21 = __toESM(require("path"));
+    path18 = __toESM(require("path"));
     log23 = getDomainLogger("module", { component: "modules" });
     Modules = class {
       constructor(info, httpClient, zipExtractor, moduleCache) {
@@ -13205,7 +13217,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 = path21.join(moduleDir, "module.zip");
+          const zipPath = path18.join(moduleDir, "module.zip");
           const metadata = {
             path: moduleImport.path,
             version: moduleImport.version || "latest",
@@ -13311,7 +13323,7 @@ var init_module4 = __esm({
        */
       getModuleDir(modulePath) {
         const safeName = modulePath.replace(/[/\\:*?"<>|]/g, "_").replace(/^_+|_+$/g, "");
-        return path21.join(this.info.moduleDir(), safeName);
+        return path18.join(this.info.moduleDir(), safeName);
       }
       /**
        * Get download URL for module path
@@ -13412,7 +13424,7 @@ var init_module4 = __esm({
        */
       async parseThemeToml(module2) {
         try {
-          const themeTomlPath = path21.join(module2.dir(), "theme.toml");
+          const themeTomlPath = path18.join(module2.dir(), "theme.toml");
           try {
             const stat4 = await this.info.osFs().stat(themeTomlPath);
             if (stat4.isDir()) {
@@ -13798,28 +13810,28 @@ var init_fileinfo = __esm({
 });
 
 // internal/domain/fs/vo/file.ts
-function newFileWithMeta(file, meta, fs14) {
-  return new File(file, meta, fs14);
+function newFileWithMeta(file, meta, fs13) {
+  return new File(file, meta, fs13);
 }
-function newDirFileWithMeta(file, meta, fs14) {
-  return new File(file, meta, fs14, true);
+function newDirFileWithMeta(file, meta, fs13) {
+  return new File(file, meta, fs13, true);
 }
-var path22, File;
+var path19, File;
 var init_file = __esm({
   "internal/domain/fs/vo/file.ts"() {
     "use strict";
     init_filemeta();
     init_fileinfo();
-    path22 = __toESM(require("path"));
+    path19 = __toESM(require("path"));
     File = class {
       file;
       fileMeta;
       fs;
       _isDir;
-      constructor(file, fileMeta, fs14, isDir = false) {
+      constructor(file, fileMeta, fs13, isDir = false) {
         this.file = file;
         this.fileMeta = fileMeta;
-        this.fs = fs14;
+        this.fs = fs13;
         this._isDir = isDir;
       }
       /**
@@ -13904,7 +13916,7 @@ var init_file = __esm({
         return await this.file.writeAt(buffer, offset);
       }
       name() {
-        return path22.basename(this.fileMeta.fileName());
+        return path19.basename(this.fileMeta.fileName());
       }
       async readdir(count) {
         if (this.file === null) {
@@ -13947,8 +13959,8 @@ var init_file = __esm({
 });
 
 // internal/domain/fs/vo/dir.ts
-function newDirFile(file, meta, fs14) {
-  const baseFile = new File(file, meta, fs14, true);
+function newDirFile(file, meta, fs13) {
+  const baseFile = new File(file, meta, fs13, true);
   return new DirFile(baseFile);
 }
 var DirFile;
@@ -14023,10 +14035,10 @@ var init_dir2 = __esm({
 });
 
 // internal/domain/fs/entity/basefs.ts
-function newBaseFs(fs14, roots) {
-  return new BaseFs(fs14, roots);
+function newBaseFs(fs13, roots) {
+  return new BaseFs(fs13, roots);
 }
-var path23, log26, BaseFs;
+var path20, log26, BaseFs;
 var init_basefs = __esm({
   "internal/domain/fs/entity/basefs.ts"() {
     "use strict";
@@ -14034,15 +14046,15 @@ var init_basefs = __esm({
     init_fileinfo();
     init_file();
     init_dir2();
-    path23 = __toESM(require("path"));
+    path20 = __toESM(require("path"));
     init_log();
     log26 = getDomainLogger("fs", { component: "basefs" });
     BaseFs = class {
       fs;
       // osFs
       roots;
-      constructor(fs14, roots) {
-        this.fs = fs14;
+      constructor(fs13, roots) {
+        this.fs = fs13;
         this.roots = roots;
       }
       /**
@@ -14057,17 +14069,17 @@ var init_basefs = __esm({
         if (name === "") {
           return root2;
         }
-        if (path23.isAbsolute(name)) {
+        if (path20.isAbsolute(name)) {
           if (name.startsWith(root2)) {
             return name;
           }
-          return path23.join(root2, name.substring(1));
+          return path20.join(root2, name.substring(1));
         }
-        return path23.join(root2, name);
+        return path20.join(root2, name);
       }
       isSameRootedPath(name) {
         const root2 = this.roots[0];
-        return name.startsWith(path23.join(root2, path23.sep)) || name === root2;
+        return name.startsWith(path20.join(root2, path20.sep)) || name === root2;
       }
       /**
        * Stat returns file info with opener function
@@ -14153,8 +14165,8 @@ var init_basefs = __esm({
         const absPath = this.toAbsolutePath(name);
         return await this.fs.mkdir(absPath, perm);
       }
-      async mkdirAll(path43, perm) {
-        const absPath = this.toAbsolutePath(path43);
+      async mkdirAll(path40, perm) {
+        const absPath = this.toAbsolutePath(path40);
         return await this.fs.mkdirAll(absPath, perm);
       }
       async openFile(name, flag, perm) {
@@ -14165,8 +14177,8 @@ var init_basefs = __esm({
         const absPath = this.toAbsolutePath(name);
         return await this.fs.remove(absPath);
       }
-      async removeAll(path43) {
-        const absPath = this.toAbsolutePath(path43);
+      async removeAll(path40) {
+        const absPath = this.toAbsolutePath(path40);
         return await this.fs.removeAll(absPath);
       }
       async rename(oldname, newname) {
@@ -14194,14 +14206,14 @@ var init_basefs = __esm({
 });
 
 // internal/domain/fs/vo/walkway.ts
-function newWalkway(fs14, cb) {
-  return new Walkway(fs14, cb);
+function newWalkway(fs13, cb) {
+  return new Walkway(fs13, cb);
 }
-var path24, log27, Walkway;
+var path21, log27, Walkway;
 var init_walkway = __esm({
   "internal/domain/fs/vo/walkway.ts"() {
     "use strict";
-    path24 = __toESM(require("path"));
+    path21 = __toESM(require("path"));
     init_type6();
     init_fileinfo();
     init_filemeta();
@@ -14213,14 +14225,14 @@ var init_walkway = __esm({
       cb;
       cfg;
       walked = false;
-      constructor(fs14, cb) {
-        if (!fs14) {
+      constructor(fs13, cb) {
+        if (!fs13) {
           throw new Error("fs must be set");
         }
         if (!cb.walkFn) {
           throw new Error("walkFn must be set");
         }
-        this.fs = fs14;
+        this.fs = fs13;
         this.cb = cb;
         this.root = "";
         this.cfg = {};
@@ -14328,7 +14340,7 @@ var init_walkway = __esm({
           }
         }
         for (const entry of dirEntries) {
-          const nextPath = path24.join(filePath, entry.name());
+          const nextPath = path21.join(filePath, entry.name());
           try {
             await this.walkRecursive(nextPath, entry);
           } catch (err) {
@@ -14410,9 +14422,9 @@ var init_static_copier = __esm({
       async walkSourceFiles(sourceFs, targetDir) {
         let fileCount = 0;
         try {
-          await this.walkFileSystem(sourceFs, "/", async (path43, isDir) => {
+          await this.walkFileSystem(sourceFs, "/", async (path40, isDir) => {
             if (!isDir) {
-              await this.copyFile(sourceFs, path43, this.toFs, targetDir);
+              await this.copyFile(sourceFs, path40, this.toFs, targetDir);
               fileCount++;
             }
           });
@@ -14425,9 +14437,9 @@ var init_static_copier = __esm({
       /**
        * Walk filesystem recursively
        */
-      async walkFileSystem(fs14, basePath, callback) {
+      async walkFileSystem(fs13, basePath, callback) {
         try {
-          const file = await fs14.open(basePath);
+          const file = await fs13.open(basePath);
           const fileInfo = await file.stat();
           if (!fileInfo.isDir()) {
             await file.close();
@@ -14440,7 +14452,7 @@ var init_static_copier = __esm({
             const fullPath = this.joinPath(basePath, entry.name());
             if (entry.isDir()) {
               await callback(fullPath, true);
-              await this.walkFileSystem(fs14, fullPath, callback);
+              await this.walkFileSystem(fs13, fullPath, callback);
             } else {
               await callback(fullPath, false);
             }
@@ -14496,8 +14508,8 @@ var init_static_copier = __esm({
       /**
        * Get directory name from path
        */
-      dirname(path43) {
-        const parts = path43.split("/").filter((part) => part.length > 0);
+      dirname(path40) {
+        const parts = path40.split("/").filter((part) => part.length > 0);
         if (parts.length <= 1)
           return "/";
         return "/" + parts.slice(0, -1).join("/");
@@ -14510,26 +14522,26 @@ var init_static_copier = __esm({
 async function collectFileMetaInfos(paths, fss) {
   const result = /* @__PURE__ */ new Map();
   let found = false;
-  for (const path43 of paths) {
-    for (const fs14 of fss) {
+  for (const path40 of paths) {
+    for (const fs13 of fss) {
       try {
-        const fileMetaInfo = await createFileMetaInfo(path43, fs14);
-        result.set(path43, fileMetaInfo);
+        const fileMetaInfo = await createFileMetaInfo(path40, fs13);
+        result.set(path40, fileMetaInfo);
         found = true;
         if (found)
           break;
       } catch (error) {
-        log29.error(`Failed to create FileMetaInfo for ${path43} with fs=${fs14}:`, error);
+        log29.error(`Failed to create FileMetaInfo for ${path40} with fs=${fs13}:`, error);
       }
     }
   }
   return result;
 }
-async function createFileMetaInfo(filePath, fs14) {
+async function createFileMetaInfo(filePath, fs13) {
   try {
-    const fi = await fs14.stat(filePath);
+    const fi = await fs13.stat(filePath);
     const meta = newFileMeta(filePath);
-    meta.setOpenFunc(async () => await fs14.open(filePath));
+    meta.setOpenFunc(async () => await fs13.open(filePath));
     return newFileInfoWithMeta(fi, meta);
   } catch (error) {
     throw new Error(`Failed to stat file ${filePath}: ${error.message}`);
@@ -14628,8 +14640,8 @@ var init_fs = __esm({
       /**
        * Create new base path filesystem
        */
-      newBasePathFs(source, path43) {
-        return newBaseFs(source, [path43]);
+      newBasePathFs(source, path40) {
+        return newBaseFs(source, [path40]);
       }
       async walkPrompts(start, cb, conf) {
         return await this.walk(this.prompts, start, cb, conf);
@@ -14640,8 +14652,8 @@ var init_fs = __esm({
       async walkLayouts(start, cb, conf) {
         return await this.walk(this.layouts, start, cb, conf);
       }
-      async walkContent(fs14, start, cb, conf) {
-        await this.walk(fs14, start, cb, conf);
+      async walkContent(fs13, start, cb, conf) {
+        await this.walk(fs13, start, cb, conf);
       }
       async walkStatics(start, cb, conf) {
         return await this.walk(this.statics, start, cb, conf);
@@ -14649,8 +14661,8 @@ var init_fs = __esm({
       async walkI18n(start, cb, conf) {
         return await this.walk(this.i18n, start, cb, conf);
       }
-      async walk(fs14, start, cb, conf) {
-        const w = newWalkway(fs14, cb);
+      async walk(fs13, start, cb, conf) {
+        const w = newWalkway(fs13, cb);
         if (start === "") {
           start = "/";
         }
@@ -14769,8 +14781,8 @@ var init_overlayoptions = __esm({
       /**
        * Check if filesystem exists in overlay
        */
-      hasFilesystem(fs14) {
-        return this.fss.includes(fs14);
+      hasFilesystem(fs13) {
+        return this.fss.includes(fs13);
       }
       /**
        * Get all filesystems as readonly array
@@ -14885,8 +14897,8 @@ var init_overlaydir = __esm({
        */
       async loadDirectoryEntries() {
         for (let i = 0; i < this.fss.length; i++) {
-          const fs14 = this.fss[i];
-          await this.readFromFilesystem(fs14, null);
+          const fs13 = this.fss[i];
+          await this.readFromFilesystem(fs13, null);
         }
         for (let i = 0; i < this.dirOpeners.length; i++) {
           const file = await this.dirOpeners[i]();
@@ -14896,12 +14908,12 @@ var init_overlaydir = __esm({
       /**
        * Read directory entries from a specific filesystem or file
        */
-      async readFromFilesystem(fs14, file) {
+      async readFromFilesystem(fs13, file) {
         let f = file;
         try {
-          if (!f && fs14) {
+          if (!f && fs13) {
             const fsPath = this._name === "/" ? "" : this._name;
-            f = await fs14.open(fsPath);
+            f = await fs13.open(fsPath);
           }
           if (!f) {
             return;
@@ -15080,22 +15092,22 @@ var init_overlayfs = __esm({
        * Collect directories from all filesystems
        */
       async collectDirs(name, withFs) {
-        for (const fs14 of this.fss) {
-          await this.collectDirsRecursive(fs14, name, withFs);
+        for (const fs13 of this.fss) {
+          await this.collectDirsRecursive(fs13, name, withFs);
         }
       }
       /**
        * Recursively collect directories from filesystem hierarchy
        */
-      async collectDirsRecursive(fs14, name, withFs) {
+      async collectDirsRecursive(fs13, name, withFs) {
         try {
-          const fi = await fs14.stat(name);
+          const fi = await fs13.stat(name);
           if (fi.isDir()) {
-            withFs(fs14);
+            withFs(fs13);
           }
         } catch (error) {
         }
-        const fsi = fs14;
+        const fsi = fs13;
         if (fsi.filesystem && fsi.numFilesystems) {
           for (let i = 0; i < fsi.numFilesystems(); i++) {
             const subFs = fsi.filesystem(i);
@@ -15110,8 +15122,8 @@ var init_overlayfs = __esm({
        */
       async statInternal(name, lstatIfPossible) {
         for (let i = 0; i < this.fss.length; i++) {
-          const fs14 = this.fss[i];
-          const [fs22, fi, ok3, err] = await this.statRecursive(fs14, name, lstatIfPossible);
+          const fs13 = this.fss[i];
+          const [fs22, fi, ok3, err] = await this.statRecursive(fs13, name, lstatIfPossible);
           if (err === null || !this.isNotExistError(err)) {
             return [fs22, fi, ok3, err];
           }
@@ -15121,16 +15133,16 @@ var init_overlayfs = __esm({
       /**
        * Recursive stat implementation
        */
-      async statRecursive(fs14, name, lstatIfPossible) {
+      async statRecursive(fs13, name, lstatIfPossible) {
         try {
-          const fi = await fs14.stat(name);
-          return [fs14, fi, false, null];
+          const fi = await fs13.stat(name);
+          return [fs13, fi, false, null];
         } catch (error) {
           if (!this.isNotExistError(error)) {
-            return [fs14, null, false, error];
+            return [fs13, null, false, error];
           }
         }
-        const fsi = fs14;
+        const fsi = fs13;
         if (fsi.filesystem && fsi.numFilesystems) {
           for (let i = 0; i < fsi.numFilesystems(); i++) {
             const subFs = fsi.filesystem(i);
@@ -15171,11 +15183,11 @@ var init_overlayfs = __esm({
       /**
        * Create directory tree (write operation)
        */
-      async mkdirAll(path43, perm) {
+      async mkdirAll(path40, perm) {
         if (!this.firstWritable) {
           throw new OverlayFsError("filesystem is read-only", "READ_ONLY");
         }
-        return await this.writeFs().mkdirAll(path43, perm);
+        return await this.writeFs().mkdirAll(path40, perm);
       }
       /**
        * Open file for reading (searches all filesystems)
@@ -15184,14 +15196,14 @@ var init_overlayfs = __esm({
         if (this.fss.length === 0) {
           throw ErrFileNotFound;
         }
-        const [fs14, fi, , err] = await this.statInternal(name, false);
+        const [fs13, fi, , err] = await this.statInternal(name, false);
         if (err) {
           throw err;
         }
         if (fi.isDir()) {
           const dirFss = [];
-          await this.collectDirs(name, (fs15) => {
-            dirFss.push(fs15);
+          await this.collectDirs(name, (fs14) => {
+            dirFss.push(fs14);
           });
           if (dirFss.length === 0) {
             throw ErrFileNotFound;
@@ -15207,7 +15219,7 @@ var init_overlayfs = __esm({
             // Pass filesystems directly
           );
         }
-        return await fs14.open(name);
+        return await fs13.open(name);
       }
       /**
        * Open file with flags (write operations use first filesystem)
@@ -15234,11 +15246,11 @@ var init_overlayfs = __esm({
       /**
        * Remove directory tree (write operation)
        */
-      async removeAll(path43) {
+      async removeAll(path40) {
         if (!this.firstWritable) {
           throw new OverlayFsError("filesystem is read-only", "READ_ONLY");
         }
-        return await this.writeFs().removeAll(path43);
+        return await this.writeFs().removeAll(path40);
       }
       /**
        * Rename file (write operation)
@@ -15495,13 +15507,13 @@ var init_overlayfs_factory = __esm({
 function newFilesystemsCollector(sourceProject) {
   return new FilesystemsCollector(sourceProject);
 }
-var path25, log31, RootMapping, FilesystemsCollector;
+var path22, log31, RootMapping, FilesystemsCollector;
 var init_filesystemscollector = __esm({
   "internal/domain/fs/vo/filesystemscollector.ts"() {
     "use strict";
     init_overlayfs_factory();
     init_basefs();
-    path25 = __toESM(require("path"));
+    path22 = __toESM(require("path"));
     init_log();
     log31 = getDomainLogger("fs", { component: "filesystemscollector" });
     RootMapping = class {
@@ -15556,7 +15568,7 @@ var init_filesystemscollector = __esm({
           const fromToAssets = [];
           const fromToI18n = [];
           const absPathify = (inputPath) => {
-            if (path25.isAbsolute(inputPath)) {
+            if (path22.isAbsolute(inputPath)) {
               return ["", inputPath];
             }
             return [md.dir(), this.absPathify(md.dir(), inputPath)];
@@ -15569,21 +15581,21 @@ var init_filesystemscollector = __esm({
               absFilename,
               base2
             );
-            const fs14 = rm2.fs(this.sourceProject);
+            const fs13 = rm2.fs(this.sourceProject);
             if (this.isPrompts(mount.target())) {
-              fromToPrompt.push(fs14);
+              fromToPrompt.push(fs13);
             } else if (this.isWorkflows(mount.target())) {
-              fromToWorkflow.push(fs14);
+              fromToWorkflow.push(fs13);
             } else if (this.isContent(mount.target())) {
-              fromToContent.push(fs14);
+              fromToContent.push(fs13);
             } else if (this.isLayouts(mount.target())) {
-              fromToLayouts.push(fs14);
+              fromToLayouts.push(fs13);
             } else if (this.isStatics(mount.target())) {
-              fromToStatics.push(fs14);
+              fromToStatics.push(fs13);
             } else if (this.isAssets(mount.target())) {
-              fromToAssets.push(fs14);
+              fromToAssets.push(fs13);
             } else if (this.isI18n(mount.target())) {
-              fromToI18n.push(fs14);
+              fromToI18n.push(fs13);
             }
           }
           if (fromToWorkflow.length > 0) {
@@ -15593,9 +15605,9 @@ var init_filesystemscollector = __esm({
             this.overlayMountsPrompt = this.overlayMountsPrompt.append(...fromToPrompt);
           }
           if (md.isProjectModule()) {
-            for (const fs14 of fromToContent) {
+            for (const fs13 of fromToContent) {
               let ofs = createReadOnlyOverlayFs([]);
-              ofs = ofs.append(...[fs14]);
+              ofs = ofs.append(...[fs13]);
               this.overlayMountsContent.push(ofs);
             }
           }
@@ -15635,7 +15647,7 @@ var init_filesystemscollector = __esm({
         return target === "i18n" || target.startsWith("i18n/") || target.startsWith("/i18n/");
       }
       absPathify(baseDir, relativePath) {
-        return path25.resolve(baseDir, relativePath);
+        return path22.resolve(baseDir, relativePath);
       }
     };
   }
@@ -15645,12 +15657,12 @@ var init_filesystemscollector = __esm({
 function newOsFs() {
   return new OsFs();
 }
-var fs9, path26, log32, OsFileInfo, OsFile, OsFs;
+var fs8, path23, log32, OsFileInfo, OsFile, OsFs;
 var init_osfs = __esm({
   "internal/domain/fs/vo/osfs.ts"() {
     "use strict";
-    fs9 = __toESM(require("fs/promises"));
-    path26 = __toESM(require("path"));
+    fs8 = __toESM(require("fs/promises"));
+    path23 = __toESM(require("path"));
     init_log();
     log32 = getDomainLogger("fs", { component: "osfs" });
     OsFileInfo = class {
@@ -15687,7 +15699,7 @@ var init_osfs = __esm({
       position = 0;
       async ensureOpen() {
         if (!this.handle && !this.closed) {
-          this.handle = await fs9.open(this.filePath, this.flags);
+          this.handle = await fs8.open(this.filePath, this.flags);
         }
       }
       async close() {
@@ -15768,13 +15780,13 @@ var init_osfs = __esm({
       async readdir(count) {
         if (this.closed)
           throw new Error("File is closed");
-        const entries = await fs9.readdir(this.filePath, { withFileTypes: true });
+        const entries = await fs8.readdir(this.filePath, { withFileTypes: true });
         const result = [];
         const limit = count > 0 ? Math.min(count, entries.length) : entries.length;
         for (let i = 0; i < limit; i++) {
           const entry = entries[i];
-          const entryPath = path26.join(this.filePath, entry.name);
-          const stats = await fs9.stat(entryPath);
+          const entryPath = path23.join(this.filePath, entry.name);
+          const stats = await fs8.stat(entryPath);
           result.push(new OsFileInfo(stats, entry.name));
         }
         return result;
@@ -15782,14 +15794,14 @@ var init_osfs = __esm({
       async readdirnames(n) {
         if (this.closed)
           throw new Error("File is closed");
-        const entries = await fs9.readdir(this.filePath);
+        const entries = await fs8.readdir(this.filePath);
         return n > 0 ? entries.slice(0, n) : entries;
       }
       async stat() {
         if (this.closed)
           throw new Error("File is closed");
-        const stats = await fs9.stat(this.filePath);
-        return new OsFileInfo(stats, path26.basename(this.filePath));
+        const stats = await fs8.stat(this.filePath);
+        return new OsFileInfo(stats, path23.basename(this.filePath));
       }
       async sync() {
         if (this.closed)
@@ -15818,18 +15830,18 @@ var init_osfs = __esm({
     };
     OsFs = class {
       async create(name) {
-        await fs9.writeFile(name, "");
+        await fs8.writeFile(name, "");
         return new OsFile(name, "w+");
       }
       async mkdir(name, perm) {
-        await fs9.mkdir(name, { mode: perm });
+        await fs8.mkdir(name, { mode: perm });
       }
       async mkdirAll(dirPath, perm) {
-        await fs9.mkdir(dirPath, { mode: perm, recursive: true });
+        await fs8.mkdir(dirPath, { mode: perm, recursive: true });
       }
       async open(name) {
-        await fs9.access(name);
-        const stats = await fs9.stat(name);
+        await fs8.access(name);
+        const stats = await fs8.stat(name);
         if (stats.isDirectory()) {
           return new OsFile(name, "r");
         } else {
@@ -15851,34 +15863,34 @@ var init_osfs = __esm({
         return new OsFile(name, flags);
       }
       async remove(name) {
-        const stats = await fs9.stat(name);
+        const stats = await fs8.stat(name);
         if (stats.isDirectory()) {
-          await fs9.rmdir(name);
+          await fs8.rmdir(name);
         } else {
-          await fs9.unlink(name);
+          await fs8.unlink(name);
         }
       }
       async removeAll(dirPath) {
-        await fs9.rm(dirPath, { recursive: true, force: true });
+        await fs8.rm(dirPath, { recursive: true, force: true });
       }
       async rename(oldname, newname) {
-        await fs9.rename(oldname, newname);
+        await fs8.rename(oldname, newname);
       }
       async stat(name) {
-        const stats = await fs9.stat(name);
-        return new OsFileInfo(stats, path26.basename(name));
+        const stats = await fs8.stat(name);
+        return new OsFileInfo(stats, path23.basename(name));
       }
       name() {
         return "OsFs";
       }
       async chmod(name, mode) {
-        await fs9.chmod(name, mode);
+        await fs8.chmod(name, mode);
       }
       async chown(name, uid, gid) {
-        await fs9.chown(name, uid, gid);
+        await fs8.chown(name, uid, gid);
       }
       async chtimes(name, atime, mtime) {
-        await fs9.utimes(name, atime, mtime);
+        await fs8.utimes(name, atime, mtime);
       }
     };
   }
@@ -19238,8 +19250,8 @@ function wikilinkInlineRule(state, silent) {
 function renderWikilinkLink(tokens, idx) {
   const token = tokens[idx];
   const meta = token.meta;
-  const [path43, _anchor] = splitAnchor(meta.url);
-  const slug2 = slugifyFilePath(path43);
+  const [path40, _anchor] = splitAnchor(meta.url);
+  const slug2 = slugifyFilePath(path40);
   const displayText = meta.alias ?? meta.filepath;
   const escapedText = escapeHtml(displayText);
   return `<a class="internal" data-slug="${slug2}" data-wikilink="${escapeHtml(meta.url)}">${escapedText}</a>`;
@@ -20205,8 +20217,8 @@ var init_type10 = __esm({
       COMPONENT_FOLDER_ASSETS: "assets",
       COMPONENT_FOLDER_I18N: "i18n",
       // Path normalization utility
-      normalizePath: (path43) => {
-        let p2 = path43.replace(/\\/g, "/");
+      normalizePath: (path40) => {
+        let p2 = path40.replace(/\\/g, "/");
         if (p2.startsWith("//")) {
           p2 = p2.substring(1);
         }
@@ -20456,8 +20468,8 @@ var init_path2 = __esm({
         if (this.components.component) {
           return this.components.component;
         }
-        const path43 = this.components.normalized;
-        const parts = path43.split("/").filter((p2) => p2.length > 0);
+        const path40 = this.components.normalized;
+        const parts = path40.split("/").filter((p2) => p2.length > 0);
         if (parts.length === 0) {
           return "content";
         }
@@ -20785,10 +20797,10 @@ var init_path2 = __esm({
       /**
        * Create a path from string components
        */
-      static fromString(component, path43) {
+      static fromString(component, path40) {
         const components = new PathComponentsImpl(
-          path43,
-          path43,
+          path40,
+          path40,
           { containerLow: -1, containerHigh: -1, sectionHigh: -1, identifierLanguage: -1 },
           [],
           0 /* File */,
@@ -20799,8 +20811,8 @@ var init_path2 = __esm({
       /**
        * Check if a path has a specific extension
        */
-      static hasExtension(path43, extension) {
-        const pathExt = path43.ext();
+      static hasExtension(path40, extension) {
+        const pathExt = path40.ext();
         const targetExt = extension.startsWith(".") ? extension : "." + extension;
         return pathExt.toLowerCase() === targetExt.toLowerCase();
       }
@@ -20858,20 +20870,20 @@ var init_pathparser = __esm({
       /**
        * Parse a path with component information
        */
-      parse(component, path43) {
-        let normalizedPath = path43;
+      parse(component, path40) {
+        let normalizedPath = path40;
         if (!normalizedPath || normalizedPath === "") {
           normalizedPath = "/";
         }
         const normalized = this.normalizer.normalize(normalizedPath);
-        const pathComponents = this.createPathComponents(component, normalized, path43);
+        const pathComponents = this.createPathComponents(component, normalized, path40);
         return new Path(pathComponents);
       }
       /**
        * Parse and return only the identity
        */
-      parseIdentity(component, path43) {
-        const parsed = this.parse(component, path43);
+      parseIdentity(component, path40) {
+        const parsed = this.parse(component, path40);
         return {
           identifierBase: () => parsed.base()
         };
@@ -20879,8 +20891,8 @@ var init_pathparser = __esm({
       /**
        * Parse and return base and base name without identifier
        */
-      parseBaseAndBaseNameNoIdentifier(component, path43) {
-        const parsed = this.parse(component, path43);
+      parseBaseAndBaseNameNoIdentifier(component, path40) {
+        const parsed = this.parse(component, path40);
         return [parsed.base(), parsed.baseNameNoIdentifier()];
       }
       /**
@@ -21009,8 +21021,8 @@ var init_pathparser = __esm({
         this.toLowerCase = toLowerCase;
         this.replaceSpaces = replaceSpaces;
       }
-      normalize(path43) {
-        let result = path43;
+      normalize(path40) {
+        let result = path40;
         result = result.replace(/\\/g, "/");
         if (this.toLowerCase) {
           result = result.toLowerCase();
@@ -21026,8 +21038,8 @@ var init_pathparser = __esm({
         this.toLowerCase = toLowerCase;
         this.replaceSpaces = replaceSpaces;
       }
-      normalize(path43) {
-        let result = path43;
+      normalize(path40) {
+        let result = path40;
         result = result.replace(/\\/g, "/");
         if (this.toLowerCase) {
           result = result.toLowerCase();
@@ -21047,12 +21059,12 @@ var init_pathparser = __esm({
         const htmlExts = PATH_CONSTANTS.HTML_EXTENSIONS;
         return htmlExts.includes(ext.toLowerCase());
       }
-      hasExt(path43) {
-        for (let i = path43.length - 1; i >= 0; i--) {
-          if (path43[i] === ".") {
+      hasExt(path40) {
+        for (let i = path40.length - 1; i >= 0; i--) {
+          if (path40[i] === ".") {
             return true;
           }
-          if (path43[i] === "/") {
+          if (path40[i] === "/") {
             return false;
           }
         }
@@ -21063,10 +21075,10 @@ var init_pathparser = __esm({
       /**
        * Parse a path string into basic components
        */
-      static parseBasic(path43) {
-        const lastSlash = path43.lastIndexOf("/");
-        const dir2 = lastSlash >= 0 ? path43.substring(0, lastSlash) : "";
-        const name = lastSlash >= 0 ? path43.substring(lastSlash + 1) : path43;
+      static parseBasic(path40) {
+        const lastSlash = path40.lastIndexOf("/");
+        const dir2 = lastSlash >= 0 ? path40.substring(0, lastSlash) : "";
+        const name = lastSlash >= 0 ? path40.substring(lastSlash + 1) : path40;
         const lastDot = name.lastIndexOf(".");
         const ext = lastDot >= 0 ? name.substring(lastDot) : "";
         const nameWithoutExt = lastDot >= 0 ? name.substring(0, lastDot) : name;
@@ -21081,43 +21093,43 @@ var init_pathparser = __esm({
       /**
        * Normalize a path string using basic rules
        */
-      static normalizeBasic(path43) {
+      static normalizeBasic(path40) {
         const normalizer = new BasicPathNormalizer();
-        return normalizer.normalize(path43);
+        return normalizer.normalize(path40);
       }
       /**
        * Check if a path represents a bundle
        */
-      static isBundle(path43) {
-        const basic = _PathParserUtils.parseBasic(path43);
+      static isBundle(path40) {
+        const basic = _PathParserUtils.parseBasic(path40);
         const indexNames = PATH_CONSTANTS.INDEX_NAMES;
         return indexNames.includes(basic.nameWithoutExt);
       }
       /**
        * Extract section from path
        */
-      static extractSection(path43) {
-        const normalized = path43.startsWith("/") ? path43.substring(1) : path43;
+      static extractSection(path40) {
+        const normalized = path40.startsWith("/") ? path40.substring(1) : path40;
         const firstSlash = normalized.indexOf("/");
         return firstSlash >= 0 ? normalized.substring(0, firstSlash) : normalized;
       }
       /**
        * Remove extension from path
        */
-      static removeExtension(path43) {
-        const lastDot = path43.lastIndexOf(".");
-        const lastSlash = path43.lastIndexOf("/");
+      static removeExtension(path40) {
+        const lastDot = path40.lastIndexOf(".");
+        const lastSlash = path40.lastIndexOf("/");
         if (lastDot > lastSlash) {
-          return path43.substring(0, lastDot);
+          return path40.substring(0, lastDot);
         }
-        return path43;
+        return path40;
       }
       /**
        * Check if path has extension
        */
-      static hasExtension(path43) {
+      static hasExtension(path40) {
         const checker = new DefaultFileExtensionChecker();
-        return checker.hasExt(path43);
+        return checker.hasExt(path40);
       }
     };
   }
@@ -21148,11 +21160,11 @@ var init_pathfactory = __esm({
       /**
        * Create a Path from component and path string
        */
-      create(component, path43, config) {
+      create(component, path40, config) {
         if (this.pool) {
           const pooledPath = this.pool.get();
         }
-        return this.processor.parse(component, path43);
+        return this.processor.parse(component, path40);
       }
       /**
        * Create a Path from PathComponents
@@ -21164,12 +21176,12 @@ var init_pathfactory = __esm({
        * Create multiple paths from an array of path strings
        */
       createMany(component, paths, config) {
-        return paths.map((path43) => this.create(component, path43, config));
+        return paths.map((path40) => this.create(component, path40, config));
       }
       /**
        * Create a path with custom configuration
        */
-      createWithConfig(component, path43, normalizeConfig) {
+      createWithConfig(component, path40, normalizeConfig) {
         const config = {};
         if (normalizeConfig?.toLowerCase !== void 0) {
           config.normalize = normalizeConfig.toLowerCase;
@@ -21180,7 +21192,7 @@ var init_pathfactory = __esm({
         if (normalizeConfig?.customNormalizer !== void 0) {
           config.normalizer = normalizeConfig.customNormalizer;
         }
-        return this.create(component, path43, config);
+        return this.create(component, path40, config);
       }
     };
     DefaultPathFactory = class extends PathFactoryImpl {
@@ -21204,9 +21216,9 @@ var init_pathfactory = __esm({
         const components = PathComponentsFactory.createEmpty();
         return new Path(components);
       }
-      put(path43) {
+      put(path40) {
         if (this.pool.length < this.maxSize) {
-          this.pool.push(path43);
+          this.pool.push(path40);
         }
       }
       /**
@@ -21240,8 +21252,8 @@ var init_pathfactory = __esm({
       /**
        * Set the path
        */
-      withPath(path43) {
-        this.path = path43;
+      withPath(path40) {
+        this.path = path40;
         return this;
       }
       /**
@@ -21289,38 +21301,38 @@ var init_pathfactory = __esm({
       /**
        * Create a content path
        */
-      static createContentPath(path43) {
-        return _PathFactoryUtils.defaultFactory.create("content", path43);
+      static createContentPath(path40) {
+        return _PathFactoryUtils.defaultFactory.create("content", path40);
       }
       /**
        * Create a static resource path
        */
-      static createStaticPath(path43) {
-        return _PathFactoryUtils.defaultFactory.create("static", path43);
+      static createStaticPath(path40) {
+        return _PathFactoryUtils.defaultFactory.create("static", path40);
       }
       /**
        * Create a layout path
        */
-      static createLayoutPath(path43) {
-        return _PathFactoryUtils.defaultFactory.create("layouts", path43);
+      static createLayoutPath(path40) {
+        return _PathFactoryUtils.defaultFactory.create("layouts", path40);
       }
       /**
        * Create an archetype path
        */
-      static createArchetypePath(path43) {
-        return _PathFactoryUtils.defaultFactory.create("archetypes", path43);
+      static createArchetypePath(path40) {
+        return _PathFactoryUtils.defaultFactory.create("archetypes", path40);
       }
       /**
        * Create a data path
        */
-      static createDataPath(path43) {
-        return _PathFactoryUtils.defaultFactory.create("data", path43);
+      static createDataPath(path40) {
+        return _PathFactoryUtils.defaultFactory.create("data", path40);
       }
       /**
        * Create a theme path
        */
-      static createThemePath(path43) {
-        return _PathFactoryUtils.defaultFactory.create("themes", path43);
+      static createThemePath(path40) {
+        return _PathFactoryUtils.defaultFactory.create("themes", path40);
       }
       /**
        * Create paths from a configuration object
@@ -21334,7 +21346,7 @@ var init_pathfactory = __esm({
           factoryConfig.replaceSpaces = config.replaceSpaces;
         }
         const factory = new PathFactoryImpl(factoryConfig);
-        return config.paths.map((path43) => factory.create(config.component, path43));
+        return config.paths.map((path40) => factory.create(config.component, path40));
       }
       /**
        * Get a path builder instance
@@ -21345,9 +21357,9 @@ var init_pathfactory = __esm({
       /**
        * Create a path with pooling
        */
-      static createWithPool(component, path43, pool2) {
+      static createWithPool(component, path40, pool2) {
         const factory = new PathFactoryImpl(void 0, pool2);
-        return factory.create(component, path43);
+        return factory.create(component, path40);
       }
     };
   }
@@ -21453,12 +21465,12 @@ var init_translator = __esm({
       async setupTranslateFuncs(fsService) {
         try {
           await fsService.walkI18n("", {
-            walkFn: async (path43, info) => {
-              if (!path43.endsWith(".yaml") && !path43.endsWith(".yml")) {
+            walkFn: async (path40, info) => {
+              if (!path40.endsWith(".yaml") && !path40.endsWith(".yml")) {
                 return;
               }
               try {
-                const normalizedPath = PATH_CONSTANTS.normalizePath(path43);
+                const normalizedPath = PATH_CONSTANTS.normalizePath(path40);
                 const filename = normalizedPath.split("/").pop() || "";
                 const langKey = filename.replace(/\.(yaml|yml)$/, "").toLowerCase();
                 const content = await this.readI18nFile(info);
@@ -21478,7 +21490,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 ${path43}:`, error);
+                log38.error(`\u274C Failed to load i18n file ${path40}:`, error);
               }
             }
           }, {});
@@ -21684,13 +21696,13 @@ function isContentExt(ext) {
 function newFileInfo2(fi) {
   return FileInfo7.newFileInfo(fi);
 }
-var crypto2, path27, log41, contentFileExtensions, contentFileExtensionsSet, FileInfo7;
+var crypto2, path24, log41, contentFileExtensions, contentFileExtensionsSet, FileInfo7;
 var init_fileinfo2 = __esm({
   "internal/domain/content/vo/fileinfo.ts"() {
     "use strict";
     init_paths();
     crypto2 = __toESM(require("crypto"));
-    path27 = __toESM(require("path"));
+    path24 = __toESM(require("path"));
     init_log();
     log41 = getDomainLogger("content", { component: "FileInfo" });
     contentFileExtensions = [
@@ -21728,7 +21740,7 @@ var init_fileinfo2 = __esm({
       relPath() {
         const dir2 = this.pathInfo.dir();
         const dirWithoutLeadingSlash = dir2.startsWith("/") ? dir2.substring(1) : dir2;
-        return path27.join(dirWithoutLeadingSlash, this.pathInfo.name());
+        return path24.join(dirWithoutLeadingSlash, this.pathInfo.name());
       }
       section() {
         return this.pathInfo.section();
@@ -21825,7 +21837,7 @@ var init_fileinfo2 = __esm({
         if (s2 === "") {
           return s2;
         }
-        return path27.normalize(s2.substring(1) + "/");
+        return path24.normalize(s2.substring(1) + "/");
       }
       determineBundleType() {
         const isContent = isContentExt(this.pathInfo.ext());
@@ -22105,7 +22117,7 @@ function getParam(p2, key2, stringToLower) {
       return v;
   }
 }
-var import_path20, FrontMatterParserImpl;
+var import_path17, FrontMatterParserImpl;
 var init_frontmatter = __esm({
   "internal/domain/content/vo/frontmatter.ts"() {
     "use strict";
@@ -22113,7 +22125,7 @@ var init_frontmatter = __esm({
     init_cast2();
     init_string2();
     init_types3();
-    import_path20 = __toESM(require("path"));
+    import_path17 = __toESM(require("path"));
     FrontMatterParserImpl = class {
       params;
       langSvc;
@@ -22300,7 +22312,7 @@ var init_frontmatter = __esm({
           organization.website = Cast.toString(orgValue.website);
         }
         if (orgValue.logo !== void 0 && orgValue.logo !== null) {
-          organization.logo = import_path20.default.join(baseURL, Cast.toString(orgValue.logo));
+          organization.logo = import_path17.default.join(baseURL, Cast.toString(orgValue.logo));
         }
         const contact = this.parseContact(orgValue.contact);
         if (contact) {
@@ -22418,7 +22430,7 @@ var init_frontmatter = __esm({
           author.website = Cast.toString(authorValue.website);
         }
         if (authorValue.avatar !== void 0 && authorValue.avatar !== null) {
-          author.avatar = import_path20.default.join(baseURL, Cast.toString(authorValue.avatar));
+          author.avatar = import_path17.default.join(baseURL, Cast.toString(authorValue.avatar));
         }
         const contact = this.parseContact(authorValue.contact);
         if (contact) {
@@ -22474,8 +22486,8 @@ var init_frontmatter = __esm({
        * Convert path to slash preserving leading slash
        * Equivalent to Go's paths.ToSlashPreserveLeading
        */
-      toSlashPreserveLeading(path43) {
-        return path43.replace(/\\/g, "/");
+      toSlashPreserveLeading(path40) {
+        return path40.replace(/\\/g, "/");
       }
     };
   }
@@ -22900,9 +22912,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(path43, fn) {
+      async walkPath(path40, fn) {
         let n = this.root;
-        let search2 = path43;
+        let search2 = path40;
         while (true) {
           if (n.leaf !== null && await fn(n.leaf.key, n.leaf.val)) {
             return;
@@ -24037,8 +24049,8 @@ var init_pagesource = __esm({
        * 3. Handle index files (index → parent folder)
        * 4. Handle _index files (Hugo-style section index)
        */
-      pathToSlug(path43) {
-        let slug2 = path43.replace(/^\//, "");
+      pathToSlug(path40) {
+        let slug2 = path40.replace(/^\//, "");
         slug2 = slug2.replace(/\.md$/, "");
         if (slug2.endsWith("/index")) {
           slug2 = slug2.replace(/\/index$/, "");
@@ -24085,17 +24097,17 @@ var init_pagesource = __esm({
 });
 
 // internal/domain/content/entity/pagemap.ts
-function addTrailingSlash(path43) {
-  if (!path43.endsWith("/")) {
-    path43 += "/";
+function addTrailingSlash(path40) {
+  if (!path40.endsWith("/")) {
+    path40 += "/";
   }
-  return path43;
+  return path40;
 }
-function addLeadingSlash(path43) {
-  if (!path43.startsWith("/")) {
-    path43 = "/" + path43;
+function addLeadingSlash(path40) {
+  if (!path40.startsWith("/")) {
+    path40 = "/" + path40;
   }
-  return path43;
+  return path40;
 }
 var log43, ambiguousContentNode, ContentTreeReverseIndexMap, ContentTreeReverseIndex, pagePredicates, PageMapQueryPagesBelowPathImpl, PageMapQueryPagesInSectionImpl, PageMap;
 var init_pagemap = __esm({
@@ -24148,8 +24160,8 @@ var init_pagemap = __esm({
       path;
       keyPart;
       include;
-      constructor(path43, keyPart, include = pagePredicates.shouldListLocal) {
-        this.path = path43;
+      constructor(path40, keyPart, include = pagePredicates.shouldListLocal) {
+        this.path = path40;
         this.keyPart = keyPart;
         this.include = include;
       }
@@ -24161,8 +24173,8 @@ var init_pagemap = __esm({
       recursive;
       includeSelf;
       index;
-      constructor(path43, keyPart, recursive, includeSelf, index2, include) {
-        super(path43, keyPart, include);
+      constructor(path40, keyPart, recursive, includeSelf, index2, include) {
+        super(path40, keyPart, include);
         this.recursive = recursive;
         this.includeSelf = includeSelf;
         this.index = index2;
@@ -24530,12 +24542,12 @@ var init_pagemap = __esm({
       /**
        * Helper method to get directory from path
        */
-      pathDir(path43) {
-        const lastSlash = path43.lastIndexOf("/");
+      pathDir(path40) {
+        const lastSlash = path40.lastIndexOf("/");
         if (lastSlash === -1) {
           return "";
         }
-        return path43.substring(0, lastSlash);
+        return path40.substring(0, lastSlash);
       }
     };
   }
@@ -24554,9 +24566,9 @@ var init_pagecollector = __esm({
       fs;
       processedPaths = /* @__PURE__ */ new Set();
       // Track processed paths
-      constructor(pageMap, fs14) {
+      constructor(pageMap, fs13) {
         this.m = pageMap;
-        this.fs = fs14;
+        this.fs = fs13;
       }
       async collect() {
         try {
@@ -24574,11 +24586,11 @@ var init_pagecollector = __esm({
       /**
        * CollectDir - exact replica of Go's collectDir method
        */
-      async collectDir(fs14, path43, root2) {
+      async collectDir(fs13, path40, root2) {
         try {
-          await this.fs.walkContent(fs14, path43, {
-            hookPre: async (dir2, path44, readdir2) => {
-              const fullPath = path44;
+          await this.fs.walkContent(fs13, path40, {
+            hookPre: async (dir2, path41, readdir2) => {
+              const fullPath = path41;
               if (this.processedPaths.has(fullPath)) {
                 log44.warn("Path already processed!", {
                   path: fullPath,
@@ -24609,7 +24621,7 @@ var init_pagecollector = __esm({
           });
         } catch (error) {
           log44.error(`Failed to collect directory: ${error}`, {
-            path: path43,
+            path: path40,
             rootName: root2.name(),
             rootIsDir: root2.isDir(),
             stack: error.stack || "No stack trace available"
@@ -24619,7 +24631,7 @@ var init_pagecollector = __esm({
       }
       async handleBundleLeaf(dir2, bundle, inPath, readdir2) {
         const bundlePath = bundle.paths();
-        const walk = async (path43, info) => {
+        const walk = async (path40, info) => {
           if (info.isDir()) {
             return;
           }
@@ -24673,8 +24685,8 @@ var init_content2 = __esm({
       pageMap;
       translator;
       pageCollected = false;
-      constructor(fs14, converter, pageMap, translator) {
-        this.fs = fs14;
+      constructor(fs13, converter, pageMap, translator) {
+        this.fs = fs13;
         this.converter = converter;
         this.pageMap = pageMap;
         this.translator = translator;
@@ -24871,10 +24883,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, path43) {
+      getPageFromPath(langIndex, path40) {
         try {
           const pathProcessor = PathDomain.createProcessor();
-          const ps = pathProcessor.parse(PATH_CONSTANTS.COMPONENT_FOLDER_CONTENT, path43);
+          const ps = pathProcessor.parse(PATH_CONSTANTS.COMPONENT_FOLDER_CONTENT, path40);
           const tree = this.pageMap.treePages.shape(0, langIndex);
           let node = tree.get(ps.base());
           if (node) {
@@ -24885,7 +24897,7 @@ var init_content2 = __esm({
           }
           return null;
         } catch (error) {
-          log45.error(`\u274C Content.getPageFromPath error for path "${path43}":`, error);
+          log45.error(`\u274C Content.getPageFromPath error for path "${path40}":`, error);
           return null;
         }
       }
@@ -25692,15 +25704,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, path43) {
-  if (!root2 || path43.startsWith(root2)) {
-    return path43;
+function addContextRoot(root2, path40) {
+  if (!root2 || path40.startsWith(root2)) {
+    return path40;
   }
-  return joinPaths(root2, path43);
+  return joinPaths(root2, path40);
 }
-function makePermalink(baseURL, path43) {
+function makePermalink(baseURL, path40) {
   const base2 = baseURL.replace(/\/$/, "");
-  const cleanPath = path43.replace(/^\//, "");
+  const cleanPath = path40.replace(/^\//, "");
   const fullURL = `${base2}/${cleanPath}`;
   try {
     return new URL(fullURL);
@@ -25729,7 +25741,7 @@ var init_paths2 = __esm({
 });
 
 // internal/domain/content/entity/page.ts
-var import_path21, log48, PageImpl, TaxonomyPageImpl, TermPageImpl;
+var import_path18, log48, PageImpl, TaxonomyPageImpl, TermPageImpl;
 var init_page = __esm({
   "internal/domain/content/entity/page.ts"() {
     "use strict";
@@ -25741,7 +25753,7 @@ var init_page = __esm({
     init_paths2();
     init_doctree();
     init_sort();
-    import_path21 = __toESM(require("path"));
+    import_path18 = __toESM(require("path"));
     init_log();
     log48 = getDomainLogger("content", { component: "page" });
     PageImpl = class {
@@ -25819,8 +25831,8 @@ var init_page = __esm({
        * 3. Handle index files (index → parent folder)
        * 4. Handle _index files (Hugo-style section index)
        */
-      pathToSlug(path43) {
-        let slug2 = path43.replace(/^\//, "");
+      pathToSlug(path40) {
+        let slug2 = path40.replace(/^\//, "");
         slug2 = slug2.replace(/\.md$/, "");
         if (slug2.endsWith("/index")) {
           slug2 = slug2.replace(/\/index$/, "");
@@ -25847,7 +25859,7 @@ var init_page = __esm({
         if (/^(https?:)?\/\//.test(src)) {
           return src;
         }
-        src = import_path21.default.normalize(src);
+        src = import_path18.default.normalize(src);
         src = src.replace(/\\/g, "/");
         if (src.startsWith("/")) {
           src = src.slice(1);
@@ -26567,12 +26579,12 @@ var init_type11 = __esm({
 function newBaseOf() {
   return new BaseOf();
 }
-var path30, BaseOf;
+var path27, BaseOf;
 var init_baseof = __esm({
   "internal/domain/template/vo/baseof.ts"() {
     "use strict";
     init_type11();
-    path30 = __toESM(require("path"));
+    path27 = __toESM(require("path"));
     BaseOf = class {
       baseof = /* @__PURE__ */ new Map();
       needsBaseof = /* @__PURE__ */ new Map();
@@ -26612,7 +26624,7 @@ var init_baseof = __esm({
        * Check if path is a base template path
        */
       isBaseTemplatePath(filePath) {
-        return path30.basename(filePath).includes(BASE_FILE_BASE);
+        return path27.basename(filePath).includes(BASE_FILE_BASE);
       }
       /**
        * Check if template needs base template
@@ -27797,8 +27809,8 @@ var init_lookup = __esm({
 });
 
 // internal/domain/template/entity/template.ts
-function newTemplateEngine(executor, lookup, parser, templateNamespace, partialNamespace, shortcodeNamespace, fs14) {
-  return new TemplateEngine(executor, lookup, parser, templateNamespace, partialNamespace, shortcodeNamespace, fs14);
+function newTemplateEngine(executor, lookup, parser, templateNamespace, partialNamespace, shortcodeNamespace, fs13) {
+  return new TemplateEngine(executor, lookup, parser, templateNamespace, partialNamespace, shortcodeNamespace, fs13);
 }
 var log52, TemplateEngine;
 var init_template = __esm({
@@ -27819,14 +27831,14 @@ var init_template = __esm({
       partialNamespace;
       shortcodeNamespace;
       fs;
-      constructor(executor, lookup, parser, templateNamespace, partialNamespace, shortcodeNamespace, fs14) {
+      constructor(executor, lookup, parser, templateNamespace, partialNamespace, shortcodeNamespace, fs13) {
         this.executor = executor;
         this.lookup = lookup;
         this.parser = parser;
         this.templateNamespace = templateNamespace;
         this.partialNamespace = partialNamespace;
         this.shortcodeNamespace = shortcodeNamespace;
-        this.fs = fs14;
+        this.fs = fs13;
       }
       /**
        * Mark template engine as ready
@@ -28367,8 +28379,8 @@ var init_registry = __esm({
             }
           },
           // PathEscape escapes special characters in a URL path
-          PathEscape: (path43) => {
-            return encodeURIComponent(path43).replace(/%2F/g, "/").replace(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+          PathEscape: (path40) => {
+            return encodeURIComponent(path40).replace(/%2F/g, "/").replace(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
           },
           // QueryEscape escapes special characters in a URL query
           QueryEscape: (query) => {
@@ -29524,11 +29536,11 @@ var init_registry = __esm({
               }
             }
           }
-          const getNestedValue = (obj, path43) => {
-            if (!path43 || path43 === "value") {
+          const getNestedValue = (obj, path40) => {
+            if (!path40 || path40 === "value") {
               return obj;
             }
-            const keys = path43.split(".");
+            const keys = path40.split(".");
             let current = obj;
             for (const key2 of keys) {
               if (current === null || current === void 0) {
@@ -30093,23 +30105,23 @@ var init_registry = __esm({
       registerPathFunctions(funcMap) {
         funcMap.set("path", () => ({
           // Base returns the last element of path
-          Base: (path43) => {
-            if (!path43)
+          Base: (path40) => {
+            if (!path40)
               return ".";
-            path43 = path43.replace(/\\/g, "/");
-            path43 = path43.replace(/\/+$/, "");
-            if (!path43)
+            path40 = path40.replace(/\\/g, "/");
+            path40 = path40.replace(/\/+$/, "");
+            if (!path40)
               return "/";
-            const parts = path43.split("/");
+            const parts = path40.split("/");
             return parts[parts.length - 1] || "/";
           },
           // Clean returns the shortest path name equivalent to path
-          Clean: (path43) => {
-            if (!path43)
+          Clean: (path40) => {
+            if (!path40)
               return ".";
-            path43 = path43.replace(/\\/g, "/");
-            const isAbs = path43.startsWith("/");
-            const parts = path43.split("/").filter((p2) => p2 && p2 !== ".");
+            path40 = path40.replace(/\\/g, "/");
+            const isAbs = path40.startsWith("/");
+            const parts = path40.split("/").filter((p2) => p2 && p2 !== ".");
             const stack = [];
             for (const part of parts) {
               if (part === "..") {
@@ -30122,56 +30134,56 @@ var init_registry = __esm({
                 stack.push(part);
               }
             }
-            path43 = stack.join("/");
+            path40 = stack.join("/");
             if (isAbs)
-              path43 = "/" + path43;
-            return path43 || (isAbs ? "/" : ".");
+              path40 = "/" + path40;
+            return path40 || (isAbs ? "/" : ".");
           },
           // Dir returns all but the last element of path
-          Dir: (path43) => {
-            if (!path43)
+          Dir: (path40) => {
+            if (!path40)
               return ".";
-            path43 = path43.replace(/\/+$/, "");
-            if (!path43)
+            path40 = path40.replace(/\/+$/, "");
+            if (!path40)
               return "/";
-            const parts = path43.split("/");
+            const parts = path40.split("/");
             parts.pop();
             return parts.join("/") || ".";
           },
           // Ext returns the file name extension
-          Ext: (path43) => {
-            const base2 = path43.split("/").pop() || "";
+          Ext: (path40) => {
+            const base2 = path40.split("/").pop() || "";
             const dot = base2.lastIndexOf(".");
             if (dot === -1 || dot === 0)
               return "";
             return base2.substring(dot);
           },
           // IsAbs reports whether the path is absolute
-          IsAbs: (path43) => {
-            return path43.startsWith("/");
+          IsAbs: (path40) => {
+            return path40.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 path43 = parts.join("/");
+            let path40 = parts.join("/");
             if (elements[0] && elements[0].startsWith("/")) {
-              path43 = "/" + path43;
+              path40 = "/" + path40;
             }
-            return path43 || ".";
+            return path40 || ".";
           },
           // Split splits path immediately following the final slash
-          Split: (path43) => {
-            if (!path43)
+          Split: (path40) => {
+            if (!path40)
               return [".", ""];
-            const lastSlash = path43.lastIndexOf("/");
+            const lastSlash = path40.lastIndexOf("/");
             if (lastSlash === -1) {
-              return ["", path43];
+              return ["", path40];
             }
             return [
-              path43.substring(0, lastSlash),
-              path43.substring(lastSlash + 1)
+              path40.substring(0, lastSlash),
+              path40.substring(lastSlash + 1)
             ];
           }
         }));
@@ -30457,11 +30469,11 @@ var init_registry = __esm({
        * Get nested value from object using dot notation path
        * Following golang's path resolution logic
        */
-      getNestedValue(obj, path43) {
-        if (!obj || !path43) {
+      getNestedValue(obj, path40) {
+        if (!obj || !path40) {
           return void 0;
         }
-        const cleanPath = path43.replace(/^\\.+/, "");
+        const cleanPath = path40.replace(/^\\.+/, "");
         const parts = cleanPath.split(".");
         let current = obj;
         for (let i = 0; i < parts.length; i++) {
@@ -30506,9 +30518,9 @@ var init_registry = __esm({
 function newTemplateFactory() {
   return new Factory2();
 }
-async function createTemplateEngineWithServices(fs14, services) {
+async function createTemplateEngineWithServices(fs13, services) {
   const factory = newTemplateFactory();
-  return factory.createWithServices(fs14, services);
+  return factory.createWithServices(fs13, services);
 }
 var Factory2, Builder;
 var init_template2 = __esm({
@@ -30526,15 +30538,15 @@ var init_template2 = __esm({
       /**
        * Create template engine with file system (core functions only)
        */
-      async create(fs14) {
-        return this.createWithConfig(fs14, {});
+      async create(fs13) {
+        return this.createWithConfig(fs13, {});
       }
       /**
        * Create template engine with configuration
        */
-      async createWithConfig(fs14, config) {
+      async createWithConfig(fs13, config) {
         try {
-          const builder = new Builder().withFs(fs14).withNamespaces(
+          const builder = new Builder().withFs(fs13).withNamespaces(
             newRegularTemplateNamespace(),
             newPartialTemplateNamespace(),
             newShortcodeTemplateNamespace()
@@ -30558,8 +30570,8 @@ var init_template2 = __esm({
        * Create template engine with services
        * TypeScript equivalent of Go's New(fs, cfs) function
        */
-      async createWithServices(fs14, services) {
-        return this.createWithConfig(fs14, { services });
+      async createWithServices(fs13, services) {
+        return this.createWithConfig(fs13, { services });
       }
     };
     Builder = class {
@@ -30576,8 +30588,8 @@ var init_template2 = __esm({
       /**
        * Set file system
        */
-      withFs(fs14) {
-        this.fs = fs14;
+      withFs(fs13) {
+        this.fs = fs13;
         return this;
       }
       /**
@@ -30996,14 +31008,14 @@ var init_pagebuilder = __esm({
        * Parse kind - exact replica of Go's parseKind method
        */
       async parseKind() {
-        const path43 = this.source.file.paths();
+        const path40 = this.source.file.paths();
         let kind = "";
         if (this.fm) {
           kind = this.fm.kind || "";
         }
         if (kind === "") {
           kind = getKindMain("page");
-          const base2 = path43.baseNoLeadingSlash();
+          const base2 = path40.baseNoLeadingSlash();
           switch (base2) {
             case PAGE_HOME_BASE:
             case "":
@@ -31018,9 +31030,9 @@ var init_pagebuilder = __esm({
             default:
               if (this.source.file.isBranchBundle()) {
                 kind = getKindMain("section");
-                const v = this.taxonomy.getTaxonomy(path43.path());
+                const v = this.taxonomy.getTaxonomy(path40.path());
                 if (!this.taxonomy.isZero(v)) {
-                  if (this.taxonomy.isTaxonomyPath(path43.path())) {
+                  if (this.taxonomy.isTaxonomyPath(path40.path())) {
                     kind = getKindMain("taxonomy");
                   } else {
                     kind = getKindMain("term");
@@ -31307,7 +31319,7 @@ function cleanTreeKey2(...elem) {
   if (elem.length > 0) {
     s2 = elem[0];
     if (elem.length > 1) {
-      s2 = path31.join(...elem);
+      s2 = path28.join(...elem);
     }
   }
   s2 = s2.replace(/^[\.\/ \s]+|[\.\/ \s]+$/g, "");
@@ -31320,14 +31332,14 @@ function cleanTreeKey2(...elem) {
   }
   return s2;
 }
-var path31, filepath, Taxonomy2;
+var path28, filepath, Taxonomy2;
 var init_taxonomy3 = __esm({
   "internal/domain/content/entity/taxonomy.ts"() {
     "use strict";
     init_pagetrees();
     init_fileinfo2();
     init_pagesource();
-    path31 = __toESM(require("path"));
+    path28 = __toESM(require("path"));
     filepath = __toESM(require("path"));
     Taxonomy2 = class {
       views;
@@ -31358,7 +31370,7 @@ var init_taxonomy3 = __esm({
         if (!ta) {
           return false;
         }
-        return p2 === path31.join(this.pluralTreeKey(ta.plural()), "_index.md");
+        return p2 === path28.join(this.pluralTreeKey(ta.plural()), "_index.md");
       }
       /**
        * PluralTreeKey - exact replica of Go's PluralTreeKey method
@@ -31663,11 +31675,11 @@ var init_pager = __esm({
 });
 
 // internal/domain/site/entity/page.ts
-var import_path22, log57, Page2;
+var import_path19, log57, Page2;
 var init_page2 = __esm({
   "internal/domain/site/entity/page.ts"() {
     "use strict";
-    import_path22 = __toESM(require("path"));
+    import_path19 = __toESM(require("path"));
     init_log();
     init_pager();
     log57 = getDomainLogger("site", { component: "page" });
@@ -31787,14 +31799,14 @@ var init_page2 = __esm({
         } else {
           prefix = this.site.getLanguage().getCurrentLanguage();
         }
-        targetFilenames.push(import_path22.default.join(prefix, this.getPageOutput().targetFilePath()));
+        targetFilenames.push(import_path19.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_path22.default.join(prefix, currentPager.url(), this.getPageOutput().targetFileBase())];
+            const paginationTargets = [import_path19.default.join(prefix, currentPager.url(), this.getPageOutput().targetFileBase())];
             await this.renderAndWritePage(tmpl, paginationTargets);
             currentPager = currentPager.next();
           }
@@ -31827,7 +31839,7 @@ var init_page2 = __esm({
             prefix = this.site.getLanguage().getCurrentLanguage();
           }
           let resourcePath = pageSource.path();
-          targetFilenames.push(import_path22.default.join(prefix, resourcePath));
+          targetFilenames.push(import_path19.default.join(prefix, resourcePath));
           let stream = null;
           try {
             const opener = () => pageSource.pageFile().open();
@@ -32482,11 +32494,11 @@ var init_baseurl = __esm({
       /**
        * Returns the appropriate root URL based on the path.
        */
-      getRoot(path43) {
+      getRoot(path40) {
         if (this.isRelative) {
           return this.basePath;
         }
-        if (path43.startsWith("/")) {
+        if (path40.startsWith("/")) {
           return this.withoutPath;
         }
         return this.withPath;
@@ -33880,8 +33892,8 @@ function assertNonEmpty(part, name) {
     throw new Error("`" + name + "` cannot be empty");
   }
 }
-function assertPath(path43, name) {
-  if (!path43) {
+function assertPath(path40, name) {
+  if (!path40) {
     throw new Error("Setting `" + name + "` requires `path` to be set too");
   }
 }
@@ -34066,13 +34078,13 @@ var init_lib4 = __esm({
        * @returns {undefined}
        *   Nothing.
        */
-      set path(path43) {
-        if (isUrl(path43)) {
-          path43 = (0, import_node_url.fileURLToPath)(path43);
+      set path(path40) {
+        if (isUrl(path40)) {
+          path40 = (0, import_node_url.fileURLToPath)(path40);
         }
-        assertNonEmpty(path43, "path");
-        if (this.path !== path43) {
-          this.history.push(path43);
+        assertNonEmpty(path40, "path");
+        if (this.path !== path40) {
+          this.history.push(path40);
         }
       }
       /**
@@ -46833,7 +46845,7 @@ var init_is_absolute_url = __esm({
 function createHtmlLinkProcessor(graph, options) {
   return new HtmlLinkProcessor(graph, options);
 }
-var import_path24, log61, defaultOptions, HtmlLinkProcessor;
+var import_path21, log61, defaultOptions, HtmlLinkProcessor;
 var init_html_link_processor = __esm({
   "internal/domain/site/service/html-link-processor.ts"() {
     "use strict";
@@ -46842,7 +46854,7 @@ var init_html_link_processor = __esm({
     init_rehype_stringify();
     init_unist_util_visit();
     init_is_absolute_url();
-    import_path24 = __toESM(require("path"));
+    import_path21 = __toESM(require("path"));
     init_path3();
     init_log();
     log61 = getDomainLogger("site", { component: "HtmlLinkProcessor" });
@@ -46980,7 +46992,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_path24.default.basename(node.children[0].value);
+                node.children[0].value = import_path21.default.basename(node.children[0].value);
               }
             }
             if (["img", "video", "audio", "iframe"].includes(node.tagName) && node.properties && typeof node.properties.src === "string") {
@@ -47873,33 +47885,33 @@ var init_site = __esm({
 });
 
 // internal/domain/site/entity/publisher.ts
-async function openFileForWriting(fs14, filename) {
-  const cleanFilename = import_path26.default.normalize(filename);
+async function openFileForWriting(fs13, filename) {
+  const cleanFilename = import_path23.default.normalize(filename);
   try {
-    return await fs14.create(cleanFilename);
+    return await fs13.create(cleanFilename);
   } catch (error) {
     if (!isFileNotFoundError(error)) {
       throw error;
     }
-    const dir2 = import_path26.default.dirname(cleanFilename);
-    await fs14.mkdirAll(dir2, 511);
-    return await fs14.create(cleanFilename);
+    const dir2 = import_path23.default.dirname(cleanFilename);
+    await fs13.mkdirAll(dir2, 511);
+    return await fs13.create(cleanFilename);
   }
 }
 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_path26, log64, Publisher, MultiWriter;
+var import_path23, log64, Publisher, MultiWriter;
 var init_publisher2 = __esm({
   "internal/domain/site/entity/publisher.ts"() {
     "use strict";
-    import_path26 = __toESM(require("path"));
+    import_path23 = __toESM(require("path"));
     init_log();
     log64 = getDomainLogger("site", { component: "publisher" });
     Publisher = class {
       fs;
-      constructor(fs14) {
-        this.fs = fs14;
+      constructor(fs13) {
+        this.fs = fs13;
       }
       /**
        * PublishSource publishes content from a source buffer to files
@@ -48754,8 +48766,8 @@ var init_menu_builder = __esm({
       /**
        * Fallback URL generation from path (used when site page conversion fails)
        */
-      fallbackUrlFromPath(path43) {
-        let url = path43.replace(/\.md$/, "");
+      fallbackUrlFromPath(path40) {
+        let url = path40.replace(/\.md$/, "");
         if (!url.startsWith("/")) {
           url = "/" + url;
         }
@@ -49678,11 +49690,11 @@ var init_template4 = __esm({
 });
 
 // internal/domain/resources/entity/publisher.ts
-var path35, import_stream2, log73, Publisher2, FileWritable;
+var path32, import_stream2, log73, Publisher2, FileWritable;
 var init_publisher3 = __esm({
   "internal/domain/resources/entity/publisher.ts"() {
     "use strict";
-    path35 = __toESM(require("path"));
+    path32 = __toESM(require("path"));
     init_log();
     import_stream2 = require("stream");
     log73 = getDomainLogger("resources", { component: "publisher" });
@@ -49717,7 +49729,7 @@ var init_publisher3 = __esm({
           return new FileWritable(file);
         } catch (error) {
           if (error.code === "ENOENT" || error.message.includes("ENOENT")) {
-            const dir2 = path35.dirname(cleanFilename);
+            const dir2 = path32.dirname(cleanFilename);
             await this.pubFs.mkdirAll(dir2, 511);
             const file = await this.pubFs.create(cleanFilename);
             const originalClose = file.close.bind(file);
@@ -49751,14 +49763,14 @@ var init_publisher3 = __esm({
        * TypeScript equivalent of OpenFileForWriting function from Go
        */
       async openFileForWriting(filename) {
-        const cleanFilename = path35.normalize(filename);
+        const cleanFilename = path32.normalize(filename);
         try {
           return await this.pubFs.create(cleanFilename);
         } catch (error) {
           if (!this.isFileNotFoundError(error)) {
             throw error;
           }
-          const dir2 = path35.dirname(cleanFilename);
+          const dir2 = path32.dirname(cleanFilename);
           await this.pubFs.mkdirAll(dir2, 511);
           return await this.pubFs.create(cleanFilename);
         }
@@ -49886,7 +49898,7 @@ var init_http2 = __esm({
 });
 
 // internal/domain/resources/entity/resources.ts
-var path36, import_crypto4, log75, Resources;
+var path33, import_crypto4, log75, Resources;
 var init_resources = __esm({
   "internal/domain/resources/entity/resources.ts"() {
     "use strict";
@@ -49898,7 +49910,7 @@ var init_resources = __esm({
     init_publisher3();
     init_http2();
     init_type9();
-    path36 = __toESM(require("path"));
+    path33 = __toESM(require("path"));
     import_crypto4 = require("crypto");
     init_log();
     log75 = getDomainLogger("resources", { component: "resources" });
@@ -49933,7 +49945,7 @@ var init_resources = __esm({
        * Supports caching for performance optimization
        */
       async getResource(pathname) {
-        const cleanPath = path36.posix.normalize(pathname);
+        const cleanPath = path33.posix.normalize(pathname);
         const cacheKey = `${cleanPath}__get`;
         if (this.cache.has(cacheKey)) {
           return this.cache.get(cacheKey) || null;
@@ -49962,7 +49974,7 @@ var init_resources = __esm({
        * GetResourceWithOpener - Alternative way to get resource with custom opener
        */
       async getResourceWithOpener(pathname, opener) {
-        const cleanPath = path36.posix.normalize(pathname);
+        const cleanPath = path33.posix.normalize(pathname);
         const cacheKey = `${cleanPath}__get_with_opener`;
         if (this.cache.has(cacheKey)) {
           return this.cache.get(cacheKey) || null;
@@ -50100,7 +50112,7 @@ var init_resources = __esm({
        */
       async buildResource(pathname, opener) {
         try {
-          const ext = path36.extname(pathname);
+          const ext = path33.extname(pathname);
           const mediaType = this.getMediaTypeFromExtension(ext);
           const resourcePaths = ResourcePaths.newResourcePaths(pathname, this.workspace);
           const resource = new ResourceImpl(
@@ -50202,11 +50214,11 @@ var init_resources = __esm({
 });
 
 // internal/domain/resources/valueobject/resourcepaths.ts
-var path37, ResourcePaths;
+var path34, ResourcePaths;
 var init_resourcepaths = __esm({
   "internal/domain/resources/valueobject/resourcepaths.ts"() {
     "use strict";
-    path37 = __toESM(require("path"));
+    path34 = __toESM(require("path"));
     ResourcePaths = class _ResourcePaths {
       // This is the directory component for the target file or link.
       dir;
@@ -50229,7 +50241,7 @@ var init_resourcepaths = __esm({
       }
       static newResourcePaths(targetPath, svc) {
         const normalizedPath = targetPath.replace(/\\/g, "/");
-        const parsedPath = path37.posix.parse(normalizedPath);
+        const parsedPath = path34.posix.parse(normalizedPath);
         let dir2 = parsedPath.dir;
         if (dir2 === "/") {
           dir2 = "";
@@ -50286,7 +50298,7 @@ var init_resourcepaths = __esm({
       }
       fromTargetPath(targetPath) {
         const normalizedPath = targetPath.replace(/\\/g, "/");
-        const parsedPath = path37.posix.parse(normalizedPath);
+        const parsedPath = path34.posix.parse(normalizedPath);
         let dir2 = parsedPath.dir;
         if (dir2 === "/") {
           dir2 = "";
@@ -50418,10 +50430,10 @@ __export(ssg_exports, {
   processSSGWithProgress: () => processSSGWithProgress,
   serveSSG: () => serveSSG
 });
-function setDomainInstances(site, content, fs14, config, modules, resources, template) {
+function setDomainInstances(site, content, fs13, config, modules, resources, template) {
   siteCache = site;
   contentCache = content;
-  fsCache = fs14;
+  fsCache = fs13;
   configCache = config;
   modulesCache = modules;
   resourcesCache = resources;
@@ -50432,7 +50444,7 @@ function getDomainInstances() {
 }
 async function loadConfiguration(projDir, modulesDir) {
   const osFs = newOsFs();
-  const configFilePath = import_path27.default.join(projDir, "config.json");
+  const configFilePath = import_path24.default.join(projDir, "config.json");
   return await loadConfigWithParams(osFs, configFilePath, projDir, modulesDir);
 }
 async function createModule(config) {
@@ -50489,8 +50501,8 @@ async function createContentEngine(filesystem, config, modules, markdown) {
     contentFs: () => {
       return filesystem.contentFs();
     },
-    walkContent: (fs14, start, cb, conf) => {
-      return filesystem.walkContent(fs14, start, cb, conf);
+    walkContent: (fs13, start, cb, conf) => {
+      return filesystem.walkContent(fs13, start, cb, conf);
     },
     walkI18n: (start, cb, conf) => {
       return filesystem.walkI18n(start, cb, conf);
@@ -50584,10 +50596,10 @@ function createCustomizedFunctions(config, site, resources) {
     }
   };
 }
-function createResourcesEngine(config, fs14) {
+function createResourcesEngine(config, fs13) {
   const workspace = {
-    assetsFs: () => fs14.assetsFs(),
-    publishFs: () => fs14.publishFs(),
+    assetsFs: () => fs13.assetsFs(),
+    publishFs: () => fs13.publishFs(),
     baseUrl: () => config.getProvider().getString("baseURL") || "http://localhost",
     executeTemplate: async (templateName, rawContent, data) => {
       throw new Error("Template execution not initialized. Please call resources.setTemplateSvc() first.");
@@ -50595,10 +50607,10 @@ function createResourcesEngine(config, fs14) {
   };
   return createResources(workspace);
 }
-async function createTemplateEngineFromFs(fs14, config, site, resources) {
+async function createTemplateEngineFromFs(fs13, config, site, resources) {
   const services = createCustomizedFunctions(config, site, resources);
   const templateFs = {
-    walk: fs14.walkLayouts.bind(fs14)
+    walk: fs13.walkLayouts.bind(fs13)
   };
   return await createTemplateEngineWithServices(templateFs, services);
 }
@@ -50638,7 +50650,7 @@ async function createTemplateAdapter(templateEngine, site) {
     }
   };
 }
-function createSiteForSSG(config, fs14, content) {
+function createSiteForSSG(config, fs13, content) {
   const siteServices = {
     // Config service methods
     configParams: () => config.getProvider().getParams("params"),
@@ -50678,11 +50690,11 @@ function createSiteForSSG(config, fs14, content) {
     searchPage: async (pages, page) => {
       return [];
     },
-    getPageFromPath: async (langIndex, path43) => {
+    getPageFromPath: async (langIndex, path40) => {
       try {
-        const page = content.getPageFromPath(langIndex, path43);
+        const page = content.getPageFromPath(langIndex, path40);
         if (!page) {
-          log76.error(`\u26A0\uFE0F  Application.getPageFromPath: content domain returned null for path: "${path43}"`);
+          log76.error(`\u26A0\uFE0F  Application.getPageFromPath: content domain returned null for path: "${path40}"`);
         }
         return page;
       } catch (error) {
@@ -50690,11 +50702,11 @@ function createSiteForSSG(config, fs14, content) {
         return null;
       }
     },
-    getPageFromPathSync: (langIndex, path43) => {
+    getPageFromPathSync: (langIndex, path40) => {
       try {
-        const page = content.getPageFromPath(langIndex, path43);
+        const page = content.getPageFromPath(langIndex, path40);
         if (!page) {
-          log76.warn(`\u26A0\uFE0F  Application.getPageFromPathSync: content domain returned null for path: ${path43}`);
+          log76.warn(`\u26A0\uFE0F  Application.getPageFromPathSync: content domain returned null for path: ${path40}`);
         }
         return page;
       } catch (error) {
@@ -50719,24 +50731,24 @@ function createSiteForSSG(config, fs14, content) {
     generateSitemap: async () => ({ urls: [] }),
     // Publisher methods
     publishFs: () => {
-      return fs14.publishFs();
+      return fs13.publishFs();
     },
     staticFs() {
-      return fs14.staticFs();
+      return fs13.staticFs();
     },
     copyStaticFiles(from, to) {
-      return fs14.copyStatic([from], to);
+      return fs13.copyStatic([from], to);
     },
     workingDir: () => config.getProvider().getString("workingDir") || process.cwd(),
     // ResourceService implementation (placeholder)
-    getResource: async (path43) => {
+    getResource: async (path40) => {
       return null;
     },
-    getResourceWithOpener: async (path43, opener) => {
+    getResourceWithOpener: async (path40, opener) => {
       return {
-        name: () => path43,
+        name: () => path40,
         readSeekCloser: opener,
-        targetPath: () => path43
+        targetPath: () => path40
       };
     },
     // URLService implementation
@@ -51015,7 +51027,7 @@ async function collectAllPageTasks(projDir, modulesDir, markdown, onProgress, ht
     throw new Error(`Failed to generate static site: ${message}`);
   }
 }
-var import_path27, log76, configCache, modulesCache, fsCache, contentCache, resourcesCache, templateEngineCache, siteCache, createDomainInstances, tasks;
+var import_path24, log76, configCache, modulesCache, fsCache, contentCache, resourcesCache, templateEngineCache, siteCache, createDomainInstances, tasks;
 var init_ssg = __esm({
   "internal/application/ssg.ts"() {
     "use strict";
@@ -51026,14 +51038,14 @@ var init_ssg = __esm({
     init_template3();
     init_site2();
     init_log();
-    import_path27 = __toESM(require("path"));
+    import_path24 = __toESM(require("path"));
     init_resources2();
     log76 = getDomainLogger("ssg", { component: "application" });
-    createDomainInstances = (site, content, fs14, config, modules, resources) => {
+    createDomainInstances = (site, content, fs13, config, modules, resources) => {
       return {
         site,
         content,
-        fs: fs14,
+        fs: fs13,
         config,
         modules,
         resources
@@ -51762,8 +51774,8 @@ var WorkerPoolManager = class {
    * 初始化 Node.js Worker 池
    */
   async initializeNodePool() {
-    const path43 = require("path");
-    const workerPath = path43.join(__dirname, "worker", "worker-node.js");
+    const path40 = require("path");
+    const workerPath = path40.join(__dirname, "worker", "worker-node.js");
     log79.debug(`Initializing Node.js worker pool with path: ${workerPath}`);
     this.pool = workerpool.pool(workerPath, {
       minWorkers: this.workerCount,
@@ -52090,8 +52102,8 @@ async function processSSGParallel(projDir, modulesDir, markdown, onProgress, htt
 
 // internal/interfaces/cli/commands/build.ts
 init_log();
-var import_path28 = __toESM(require("path"));
-var import_fs15 = require("fs");
+var import_path25 = __toESM(require("path"));
+var import_fs14 = require("fs");
 var log82 = getDomainLogger("build-command", { component: "cli" });
 var BuildCommand = class {
   constructor(workspaceAppService) {
@@ -52117,7 +52129,7 @@ var BuildCommand = class {
       await project.loadConfig();
       const projectRoot = project.getPath();
       const modulesDir = options.modulesDir || workspace.getModulesDir();
-      const outputDir = options.destination ? import_path28.default.resolve(projectRoot, options.destination) : await project.getPublishDir();
+      const outputDir = options.destination ? import_path25.default.resolve(projectRoot, options.destination) : await project.getPublishDir();
       if (options.clean) {
         await this.cleanOutputDir(outputDir);
         log82.info(`Cleaned output directory: ${outputDir}`);
@@ -52126,7 +52138,7 @@ var BuildCommand = class {
       let contentDirs = await project.getContentDirs();
       if (options.contentDirs && options.contentDirs.length > 0) {
         const extraDirs = options.contentDirs.map(
-          (dir2) => import_path28.default.resolve(projectRoot, dir2)
+          (dir2) => import_path25.default.resolve(projectRoot, dir2)
         );
         contentDirs = [...contentDirs, ...extraDirs];
         log82.info(`Added extra content directories: ${options.contentDirs.join(", ")}`);
@@ -52212,11 +52224,11 @@ var BuildCommand = class {
    */
   async cleanOutputDir(outputDir) {
     try {
-      await import_fs15.promises.access(outputDir);
-      const entries = await import_fs15.promises.readdir(outputDir);
+      await import_fs14.promises.access(outputDir);
+      const entries = await import_fs14.promises.readdir(outputDir);
       await Promise.all(
         entries.map(
-          (entry) => import_fs15.promises.rm(import_path28.default.join(outputDir, entry), { recursive: true, force: true })
+          (entry) => import_fs14.promises.rm(import_path25.default.join(outputDir, entry), { recursive: true, force: true })
         )
       );
     } catch (error) {
@@ -52233,8 +52245,8 @@ init_log();
 
 // pkg/web/watcher/content-file-watcher.ts
 var chokidar = __toESM(require("chokidar"));
-var path40 = __toESM(require("path"));
-var fs11 = __toESM(require("fs"));
+var path37 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
 init_log();
 var log83 = getDomainLogger("web", { component: "content-file-watcher" });
 var ContentFileWatcher = class {
@@ -52267,10 +52279,10 @@ var ContentFileWatcher = class {
     }
     return paths.every((p2) => {
       try {
-        const stats = fs11.statSync(p2);
+        const stats = fs10.statSync(p2);
         return stats.isFile();
       } catch {
-        const ext = path40.extname(p2).toLowerCase();
+        const ext = path37.extname(p2).toLowerCase();
         return ext === ".md" || ext === ".markdown";
       }
     });
@@ -52312,11 +52324,11 @@ var ContentFileWatcher = class {
     let fp = filePath;
     if (this.isSingleFileMode) {
       const matchedIndex = this.config.contentDirs.findIndex((contentFile) => {
-        return path40.normalize(filePath) === path40.normalize(contentFile);
+        return path37.normalize(filePath) === path37.normalize(contentFile);
       });
       if (matchedIndex !== -1) {
         const projContentDir = this.config.projContentDirs[matchedIndex];
-        fp = path40.join(projContentDir, "index.md");
+        fp = path37.join(projContentDir, "index.md");
         log83.debug("Single file event mapped", {
           original: filePath,
           mapped: fp
@@ -52337,7 +52349,7 @@ var ContentFileWatcher = class {
         }
       }
     }
-    const normalizedPath = path40.normalize(fp);
+    const normalizedPath = path37.normalize(fp);
     if (!this.isRelevantFile(normalizedPath)) {
       return;
     }
@@ -52355,11 +52367,11 @@ var ContentFileWatcher = class {
     return this.isMarkdownFile(filePath) || this.isImageFile(filePath);
   }
   isMarkdownFile(filePath) {
-    const ext = path40.extname(filePath).toLowerCase();
+    const ext = path37.extname(filePath).toLowerCase();
     return ext === ".md" || ext === ".markdown";
   }
   isImageFile(filePath) {
-    const ext = path40.extname(filePath).toLowerCase();
+    const ext = path37.extname(filePath).toLowerCase();
     return [".jpg", ".jpeg", ".png", ".gif", ".svg", ".webp", ".bmp"].includes(ext);
   }
   scheduleBatch() {
@@ -52406,8 +52418,8 @@ var ContentFileWatcher = class {
 
 // pkg/web/server/livereload-server.ts
 var http3 = __toESM(require("http"));
-var path41 = __toESM(require("path"));
-var fs12 = __toESM(require("fs/promises"));
+var path38 = __toESM(require("path"));
+var fs11 = __toESM(require("fs/promises"));
 var import_ws = require("ws");
 init_log();
 var log84 = getDomainLogger("web", { component: "livereload-server" });
@@ -52477,7 +52489,7 @@ var FoundryLiveReloadServer = class {
     };
     if (changedFiles && changedFiles.length === 1) {
       const file = changedFiles[0];
-      const ext = path41.extname(file).toLowerCase();
+      const ext = path38.extname(file).toLowerCase();
       if (ext === ".css") {
         reloadEvent.path = file;
         reloadEvent.liveCSS = true;
@@ -52559,11 +52571,11 @@ var FoundryLiveReloadServer = class {
     const url = req.url || "/";
     let filePath = this.resolveFilePath(url);
     try {
-      const stats = await fs12.stat(filePath);
+      const stats = await fs11.stat(filePath);
       if (stats.isDirectory()) {
-        const indexPath = path41.join(filePath, "index.html");
+        const indexPath = path38.join(filePath, "index.html");
         try {
-          await fs12.stat(indexPath);
+          await fs11.stat(indexPath);
           filePath = indexPath;
         } catch {
           res.statusCode = 404;
@@ -52571,7 +52583,7 @@ var FoundryLiveReloadServer = class {
           return;
         }
       }
-      let content = await fs12.readFile(filePath);
+      let content = await fs11.readFile(filePath);
       const contentType = this.getContentType(filePath);
       res.setHeader("Content-Type", contentType);
       if (contentType.includes("text/html") && this.config.enableLiveReload) {
@@ -52607,9 +52619,9 @@ var FoundryLiveReloadServer = class {
       log84.warn("Failed to decode URL:", cleanUrl, error);
       decodedUrl = cleanUrl;
     }
-    const normalizedPath = path41.normalize(decodedUrl).replace(/^(\.\.[\/\\])+/, "");
+    const normalizedPath = path38.normalize(decodedUrl).replace(/^(\.\.[\/\\])+/, "");
     const relativePath = normalizedPath.startsWith("/") ? normalizedPath.slice(1) : normalizedPath;
-    const resolvedPath = path41.join(this.config.publicDir, relativePath);
+    const resolvedPath = path38.join(this.config.publicDir, relativePath);
     if (process.platform === "win32" && resolvedPath.length > 260) {
       log84.warn("Path too long for Windows filesystem:", resolvedPath);
     }
@@ -52622,7 +52634,7 @@ var FoundryLiveReloadServer = class {
     return resolvedPath;
   }
   getContentType(filePath) {
-    const ext = path41.extname(filePath).toLowerCase();
+    const ext = path38.extname(filePath).toLowerCase();
     const mimeTypes = {
       ".html": "text/html; charset=utf-8",
       ".css": "text/css; charset=utf-8",
@@ -52716,20 +52728,20 @@ var FoundryLiveReloadServer = class {
   shouldLiveReloadCSS(changedFiles) {
     if (!changedFiles)
       return false;
-    return changedFiles.some((file) => path41.extname(file).toLowerCase() === ".css");
+    return changedFiles.some((file) => path38.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(path38.extname(file).toLowerCase()));
   }
 };
 
 // pkg/web/server/electron-livereload-server.ts
 var http4 = __toESM(require("http"));
-var path42 = __toESM(require("path"));
-var fs13 = __toESM(require("fs/promises"));
+var path39 = __toESM(require("path"));
+var fs12 = __toESM(require("fs/promises"));
 init_log();
 var log85 = getDomainLogger("web", { component: "electron-livereload-server" });
 var ElectronLiveReloadServer = class {
@@ -52745,7 +52757,7 @@ var ElectronLiveReloadServer = class {
       enableLiveReload: config.enableLiveReload !== false,
       publicDir: config.publicDir
     };
-    this.stateFilePath = path42.join(this.config.publicDir, ".foundry-livereload-state.json");
+    this.stateFilePath = path39.join(this.config.publicDir, ".foundry-livereload-state.json");
   }
   async start() {
     if (this.running) {
@@ -52776,7 +52788,7 @@ var ElectronLiveReloadServer = class {
         this.httpServer = null;
       }
       try {
-        await fs13.unlink(this.stateFilePath);
+        await fs12.unlink(this.stateFilePath);
       } catch (error) {
       }
       this.running = false;
@@ -52798,7 +52810,7 @@ var ElectronLiveReloadServer = class {
     };
     if (changedFiles && changedFiles.length === 1) {
       const file = changedFiles[0];
-      const ext = path42.extname(file).toLowerCase();
+      const ext = path39.extname(file).toLowerCase();
       if (ext === ".css" || [".jpg", ".jpeg", ".png", ".gif", ".svg", ".webp"].includes(ext)) {
         state.path = file;
       }
@@ -52822,7 +52834,7 @@ var ElectronLiveReloadServer = class {
   }
   async writeStateFile(state) {
     try {
-      await fs13.writeFile(this.stateFilePath, JSON.stringify(state), "utf8");
+      await fs12.writeFile(this.stateFilePath, JSON.stringify(state), "utf8");
     } catch (error) {
       log85.error("Failed to write LiveReload state file:", error);
     }
@@ -52859,7 +52871,7 @@ var ElectronLiveReloadServer = class {
     const url = req.url || "/";
     if (url.startsWith("/.foundry-livereload-state.json")) {
       try {
-        const content = await fs13.readFile(this.stateFilePath, "utf8");
+        const content = await fs12.readFile(this.stateFilePath, "utf8");
         res.setHeader("Content-Type", "application/json; charset=utf-8");
         res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
         res.setHeader("Pragma", "no-cache");
@@ -52880,11 +52892,11 @@ var ElectronLiveReloadServer = class {
     }
     let filePath = this.resolveFilePath(url);
     try {
-      const stats = await fs13.stat(filePath);
+      const stats = await fs12.stat(filePath);
       if (stats.isDirectory()) {
-        const indexPath = path42.join(filePath, "index.html");
+        const indexPath = path39.join(filePath, "index.html");
         try {
-          await fs13.stat(indexPath);
+          await fs12.stat(indexPath);
           filePath = indexPath;
         } catch {
           res.statusCode = 404;
@@ -52892,7 +52904,7 @@ var ElectronLiveReloadServer = class {
           return;
         }
       }
-      let content = await fs13.readFile(filePath);
+      let content = await fs12.readFile(filePath);
       const contentType = this.getContentType(filePath);
       res.setHeader("Content-Type", contentType);
       if (contentType.includes("text/html") && this.config.enableLiveReload) {
@@ -52928,13 +52940,13 @@ var ElectronLiveReloadServer = class {
       log85.warn("Failed to decode URL:", cleanUrl, error);
       decodedUrl = cleanUrl;
     }
-    const normalizedPath = path42.normalize(decodedUrl).replace(/^(\.\.[\/\\])+/, "");
+    const normalizedPath = path39.normalize(decodedUrl).replace(/^(\.\.[\/\\])+/, "");
     const relativePath = normalizedPath.startsWith("/") ? normalizedPath.slice(1) : normalizedPath;
-    const resolvedPath = path42.join(this.config.publicDir, relativePath);
+    const resolvedPath = path39.join(this.config.publicDir, relativePath);
     return resolvedPath;
   }
   getContentType(filePath) {
-    const ext = path42.extname(filePath).toLowerCase();
+    const ext = path39.extname(filePath).toLowerCase();
     const mimeTypes = {
       ".html": "text/html; charset=utf-8",
       ".css": "text/css; charset=utf-8",
@@ -53054,13 +53066,13 @@ var ElectronLiveReloadServer = class {
   shouldLiveReloadCSS(changedFiles) {
     if (!changedFiles)
       return false;
-    return changedFiles.some((file) => path42.extname(file).toLowerCase() === ".css");
+    return changedFiles.some((file) => path39.extname(file).toLowerCase() === ".css");
   }
   shouldLiveReloadImages(changedFiles) {
     if (!changedFiles)
       return false;
     const imageExts = [".jpg", ".jpeg", ".png", ".gif", ".svg", ".webp"];
-    return changedFiles.some((file) => imageExts.includes(path42.extname(file).toLowerCase()));
+    return changedFiles.some((file) => imageExts.includes(path39.extname(file).toLowerCase()));
   }
 };
 
@@ -55360,7 +55372,7 @@ For more information, visit: https://help.mdfriday.com
    * Show version
    */
   showVersion() {
-    const version = "26.4.7";
+    const version = "26.4.9";
     return {
       success: true,
       message: `MDFriday CLI v${version}`