@mdfriday/foundry 26.4.10 → 26.4.12

package/dist/cli.js

@@ -4357,12 +4357,11 @@ var init_workspace2 = __esm({
 });
 
 // internal/application/workspace.ts
-var import_path, log6, WorkspaceAppService;
+var log6, WorkspaceAppService;
 var init_workspace3 = __esm({
   "internal/application/workspace.ts"() {
     "use strict";
     init_log();
-    import_path = __toESM(require("path"));
     log6 = getDomainLogger("workspace-app", { component: "application" });
     WorkspaceAppService = class {
       workspaceFactory;
@@ -4375,17 +4374,17 @@ var init_workspace3 = __esm({
       /**
        * Load workspace from path
        */
-      async loadWorkspace(path40) {
-        if (path40) {
-          return this.workspaceFactory.load(path40);
+      async loadWorkspace(path39) {
+        if (path39) {
+          return this.workspaceFactory.load(path39);
         }
         return this.workspaceFactory.loadOrFind();
       }
       /**
        * Create new workspace
        */
-      async createWorkspace(path40, options) {
-        return this.workspaceFactory.create(path40, options);
+      async createWorkspace(path39, options) {
+        return this.workspaceFactory.create(path39, options);
       }
       /**
        * Save workspace
@@ -4449,7 +4448,7 @@ var init_workspace3 = __esm({
             if (!fsRepo) {
               project = void 0;
             } else {
-              const inputPath = import_path.default.resolve(projectNameOrPath);
+              const inputPath = fsRepo.resolvePathSync(projectNameOrPath);
               for (const p2 of projects) {
                 const projectPath = p2.getPath();
                 if (inputPath.startsWith(projectPath) || projectPath === inputPath) {
@@ -5031,12 +5030,12 @@ var init_identity2 = __esm({
 });
 
 // internal/infrastructure/persistence/node-workspace-repository.ts
-var import_fs, import_path2, MDFRIDAY_DIR, WORKSPACE_FILE, PROJECTS_FILE, PROJECT_FILE, CONFIG_FILE, NodeWorkspaceRepository, NodeProjectRepository;
+var import_fs, import_path, 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_fs = require("fs");
-    import_path2 = __toESM(require("path"));
+    import_path = __toESM(require("path"));
     MDFRIDAY_DIR = ".mdfriday";
     WORKSPACE_FILE = "workspace.json";
     PROJECTS_FILE = "projects.json";
@@ -5045,7 +5044,7 @@ var init_node_workspace_repository = __esm({
     NodeWorkspaceRepository = class {
       async isWorkspace(workspacePath) {
         try {
-          const metadataPath = import_path2.default.join(workspacePath, MDFRIDAY_DIR, WORKSPACE_FILE);
+          const metadataPath = import_path.default.join(workspacePath, MDFRIDAY_DIR, WORKSPACE_FILE);
           await import_fs.promises.access(metadataPath);
           return true;
         } catch {
@@ -5053,28 +5052,28 @@ var init_node_workspace_repository = __esm({
         }
       }
       async initWorkspaceStructure(workspacePath, modulesDir, projectsDir) {
-        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);
+        const mdfridayDir = import_path.default.join(workspacePath, MDFRIDAY_DIR);
+        const modulesDirPath = import_path.default.join(workspacePath, modulesDir);
+        const projectsDirPath = import_path.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_path2.default.join(workspacePath, MDFRIDAY_DIR, WORKSPACE_FILE);
+        const metadataPath = import_path.default.join(workspacePath, MDFRIDAY_DIR, WORKSPACE_FILE);
         await import_fs.promises.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
       }
       async loadWorkspaceMetadata(workspacePath) {
-        const metadataPath = import_path2.default.join(workspacePath, MDFRIDAY_DIR, WORKSPACE_FILE);
+        const metadataPath = import_path.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_path2.default.join(workspacePath, MDFRIDAY_DIR, PROJECTS_FILE);
+        const registryPath = import_path.default.join(workspacePath, MDFRIDAY_DIR, PROJECTS_FILE);
         await import_fs.promises.writeFile(registryPath, JSON.stringify(registry, null, 2));
       }
       async loadProjectRegistry(workspacePath) {
-        const registryPath = import_path2.default.join(workspacePath, MDFRIDAY_DIR, PROJECTS_FILE);
+        const registryPath = import_path.default.join(workspacePath, MDFRIDAY_DIR, PROJECTS_FILE);
         const content = await import_fs.promises.readFile(registryPath, "utf-8");
         return JSON.parse(content);
       }
@@ -5082,7 +5081,7 @@ var init_node_workspace_repository = __esm({
     NodeProjectRepository = class {
       async isProject(projectPath) {
         try {
-          const metadataPath = import_path2.default.join(projectPath, MDFRIDAY_DIR, PROJECT_FILE);
+          const metadataPath = import_path.default.join(projectPath, MDFRIDAY_DIR, PROJECT_FILE);
           await import_fs.promises.access(metadataPath);
           return true;
         } catch {
@@ -5090,26 +5089,26 @@ var init_node_workspace_repository = __esm({
         }
       }
       async initProjectStructure(projectPath, contentDir, staticDir, publishDir) {
-        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);
+        const mdfridayDir = import_path.default.join(projectPath, MDFRIDAY_DIR);
+        const contentDirPath = import_path.default.join(projectPath, contentDir);
+        const staticDirPath = import_path.default.join(projectPath, staticDir);
+        const publishDirPath = import_path.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_path2.default.join(projectPath, MDFRIDAY_DIR, PROJECT_FILE);
+        const metadataPath = import_path.default.join(projectPath, MDFRIDAY_DIR, PROJECT_FILE);
         await import_fs.promises.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
       }
       async loadProjectMetadata(projectPath) {
-        const metadataPath = import_path2.default.join(projectPath, MDFRIDAY_DIR, PROJECT_FILE);
+        const metadataPath = import_path.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_path2.default.join(projectPath, CONFIG_FILE);
+        const configPath = import_path.default.join(projectPath, CONFIG_FILE);
         await import_fs.promises.writeFile(configPath, JSON.stringify(config, null, 2));
       }
       async createSampleContent(contentPath, content) {
@@ -5126,20 +5125,20 @@ var init_node_workspace_repository = __esm({
 });
 
 // internal/infrastructure/persistence/node-snapshot-repository.ts
-var import_fs2, import_path3, NodeSnapshotRepository;
+var import_fs2, import_path2, NodeSnapshotRepository;
 var init_node_snapshot_repository = __esm({
   "internal/infrastructure/persistence/node-snapshot-repository.ts"() {
     "use strict";
     import_fs2 = require("fs");
-    import_path3 = __toESM(require("path"));
+    import_path2 = __toESM(require("path"));
     NodeSnapshotRepository = class {
       /**
        * Create a snapshot by copying output directory to snapshot storage
        */
       async createSnapshot(projectPath, snapshotId, outputDir) {
-        const snapshotDir = import_path3.default.join(projectPath, ".mdfriday", "snapshots");
+        const snapshotDir = import_path2.default.join(projectPath, ".mdfriday", "snapshots");
         await import_fs2.promises.mkdir(snapshotDir, { recursive: true });
-        const storageDir = import_path3.default.join(snapshotDir, snapshotId);
+        const storageDir = import_path2.default.join(snapshotDir, snapshotId);
         await import_fs2.promises.mkdir(storageDir, { recursive: true });
         await this.copyDirectory(outputDir, storageDir);
         const size = await this.getDirectorySize(storageDir);
@@ -5149,12 +5148,12 @@ var init_node_snapshot_repository = __esm({
           name: snapshotId,
           // Will be updated by service if custom name provided
           timestamp: Date.now(),
-          outputDir: import_path3.default.relative(projectPath, outputDir),
-          storageDir: import_path3.default.relative(projectPath, storageDir),
+          outputDir: import_path2.default.relative(projectPath, outputDir),
+          storageDir: import_path2.default.relative(projectPath, storageDir),
           size,
           fileCount
         };
-        const metadataPath = import_path3.default.join(snapshotDir, `${snapshotId}.json`);
+        const metadataPath = import_path2.default.join(snapshotDir, `${snapshotId}.json`);
         await import_fs2.promises.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
         return metadata;
       }
@@ -5162,7 +5161,7 @@ var init_node_snapshot_repository = __esm({
        * List all snapshots for a project
        */
       async listSnapshots(projectPath) {
-        const snapshotDir = import_path3.default.join(projectPath, ".mdfriday", "snapshots");
+        const snapshotDir = import_path2.default.join(projectPath, ".mdfriday", "snapshots");
         try {
           await import_fs2.promises.access(snapshotDir);
         } catch {
@@ -5173,7 +5172,7 @@ var init_node_snapshot_repository = __esm({
         const snapshots = [];
         for (const file of jsonFiles) {
           try {
-            const content = await import_fs2.promises.readFile(import_path3.default.join(snapshotDir, file), "utf-8");
+            const content = await import_fs2.promises.readFile(import_path2.default.join(snapshotDir, file), "utf-8");
             snapshots.push(JSON.parse(content));
           } catch {
           }
@@ -5184,8 +5183,8 @@ var init_node_snapshot_repository = __esm({
        * Get snapshot metadata
        */
       async getSnapshot(projectPath, snapshotId) {
-        const snapshotDir = import_path3.default.join(projectPath, ".mdfriday", "snapshots");
-        const metadataPath = import_path3.default.join(snapshotDir, `${snapshotId}.json`);
+        const snapshotDir = import_path2.default.join(projectPath, ".mdfriday", "snapshots");
+        const metadataPath = import_path2.default.join(snapshotDir, `${snapshotId}.json`);
         try {
           const content = await import_fs2.promises.readFile(metadataPath, "utf-8");
           const metadata = JSON.parse(content);
@@ -5205,7 +5204,7 @@ var init_node_snapshot_repository = __esm({
        */
       async restoreSnapshot(projectPath, snapshotId, outputDir) {
         const metadata = await this.getSnapshot(projectPath, snapshotId);
-        const storageDir = import_path3.default.join(projectPath, metadata.storageDir);
+        const storageDir = import_path2.default.join(projectPath, metadata.storageDir);
         try {
           await import_fs2.promises.access(storageDir);
         } catch {
@@ -5221,13 +5220,13 @@ var init_node_snapshot_repository = __esm({
        * Delete a snapshot
        */
       async deleteSnapshot(projectPath, snapshotId) {
-        const snapshotDir = import_path3.default.join(projectPath, ".mdfriday", "snapshots");
-        const metadataPath = import_path3.default.join(snapshotDir, `${snapshotId}.json`);
+        const snapshotDir = import_path2.default.join(projectPath, ".mdfriday", "snapshots");
+        const metadataPath = import_path2.default.join(snapshotDir, `${snapshotId}.json`);
         try {
           const content = await import_fs2.promises.readFile(metadataPath, "utf-8");
           const metadata = JSON.parse(content);
           if (metadata.storageDir) {
-            const storageDir = import_path3.default.join(projectPath, metadata.storageDir);
+            const storageDir = import_path2.default.join(projectPath, metadata.storageDir);
             try {
               await import_fs2.promises.rm(storageDir, { recursive: true, force: true });
             } catch {
@@ -5249,8 +5248,8 @@ var init_node_snapshot_repository = __esm({
         const entries = await import_fs2.promises.readdir(src, { withFileTypes: true });
         await Promise.all(
           entries.map(async (entry) => {
-            const srcPath = import_path3.default.join(src, entry.name);
-            const destPath = import_path3.default.join(dest, entry.name);
+            const srcPath = import_path2.default.join(src, entry.name);
+            const destPath = import_path2.default.join(dest, entry.name);
             if (entry.isDirectory()) {
               await this.copyDirectory(srcPath, destPath);
             } else {
@@ -5266,7 +5265,7 @@ var init_node_snapshot_repository = __esm({
         let size = 0;
         const entries = await import_fs2.promises.readdir(dir2, { withFileTypes: true });
         for (const entry of entries) {
-          const entryPath = import_path3.default.join(dir2, entry.name);
+          const entryPath = import_path2.default.join(dir2, entry.name);
           if (entry.isDirectory()) {
             size += await this.getDirectorySize(entryPath);
           } else {
@@ -5283,7 +5282,7 @@ var init_node_snapshot_repository = __esm({
         let count = 0;
         const entries = await import_fs2.promises.readdir(dir2, { withFileTypes: true });
         for (const entry of entries) {
-          const entryPath = import_path3.default.join(dir2, entry.name);
+          const entryPath = import_path2.default.join(dir2, entry.name);
           if (entry.isDirectory()) {
             count += await this.countFiles(entryPath);
           } else {
@@ -5301,12 +5300,12 @@ function mapLanguageCode(code) {
   const normalized = code.toLowerCase().trim();
   return LANGUAGE_CODE_MAP[normalized] || normalized;
 }
-var import_fs3, import_path4, log8, LANGUAGE_CODE_MAP, NodeFileSystemRepository;
+var import_fs3, import_path3, log8, LANGUAGE_CODE_MAP, NodeFileSystemRepository;
 var init_node_file_system = __esm({
   "internal/infrastructure/persistence/node-file-system.ts"() {
     "use strict";
     import_fs3 = require("fs");
-    import_path4 = __toESM(require("path"));
+    import_path3 = __toESM(require("path"));
     init_log();
     log8 = getDomainLogger("node-fs", { component: "infrastructure" });
     LANGUAGE_CODE_MAP = {
@@ -5355,7 +5354,7 @@ var init_node_file_system = __esm({
         try {
           const entries = await import_fs3.promises.readdir(dirPath, { withFileTypes: true });
           return entries.map((entry) => ({
-            path: import_path4.default.join(dirPath, entry.name),
+            path: import_path3.default.join(dirPath, entry.name),
             name: entry.name,
             isDirectory: entry.isDirectory(),
             isFile: entry.isFile()
@@ -5406,7 +5405,7 @@ var init_node_file_system = __esm({
             if (a.weight !== b.weight) {
               return a.weight - b.weight;
             }
-            return import_path4.default.basename(a.path).localeCompare(import_path4.default.basename(b.path));
+            return import_path3.default.basename(a.path).localeCompare(import_path3.default.basename(b.path));
           });
           const isStructured = contentFolders.length > 0;
           log8.debug(`Scanned folder structure: ${dirPath}`, {
@@ -5550,7 +5549,7 @@ var init_node_file_system = __esm({
       }
       async copyFile(source, target) {
         try {
-          const targetDir = import_path4.default.dirname(target);
+          const targetDir = import_path3.default.dirname(target);
           if (!await this.exists(targetDir)) {
             await import_fs3.promises.mkdir(targetDir, { recursive: true });
           }
@@ -5571,7 +5570,7 @@ var init_node_file_system = __esm({
       }
       async writeFile(filePath, content, encoding = "utf-8") {
         try {
-          const dir2 = import_path4.default.dirname(filePath);
+          const dir2 = import_path3.default.dirname(filePath);
           if (!await this.exists(dir2)) {
             await import_fs3.promises.mkdir(dir2, { recursive: true });
           }
@@ -5599,34 +5598,34 @@ var init_node_file_system = __esm({
         }
       }
       async resolvePath(filePath) {
-        return import_path4.default.resolve(filePath);
+        return import_path3.default.resolve(filePath);
       }
       basename(filePath) {
-        return import_path4.default.basename(filePath);
+        return import_path3.default.basename(filePath);
       }
       dirname(filePath) {
-        return import_path4.default.dirname(filePath);
+        return import_path3.default.dirname(filePath);
       }
       join(...paths) {
-        return import_path4.default.join(...paths);
+        return import_path3.default.join(...paths);
       }
       // ============================================================================
       // Path Operations (Sync)
       // ============================================================================
       resolvePathSync(...paths) {
-        return import_path4.default.resolve(...paths);
+        return import_path3.default.resolve(...paths);
       }
       relative(from, to) {
-        return import_path4.default.relative(from, to);
+        return import_path3.default.relative(from, to);
       }
       parsePath(filePath) {
-        return import_path4.default.parse(filePath);
+        return import_path3.default.parse(filePath);
       }
       normalize(filePath) {
-        return import_path4.default.normalize(filePath);
+        return import_path3.default.normalize(filePath);
       }
       isAbsolute(filePath) {
-        return import_path4.default.isAbsolute(filePath);
+        return import_path3.default.isAbsolute(filePath);
       }
     };
   }
@@ -5840,10 +5839,10 @@ var init_publish_manifest = __esm({
        */
       getChangedFiles(newManifest) {
         const changedFiles = [];
-        for (const [path40, newEntry] of newManifest.files.entries()) {
-          const oldEntry = this.files.get(path40);
+        for (const [path39, newEntry] of newManifest.files.entries()) {
+          const oldEntry = this.files.get(path39);
           if (!oldEntry || oldEntry.hash !== newEntry.hash) {
-            changedFiles.push(path40);
+            changedFiles.push(path39);
           }
         }
         return changedFiles;
@@ -5854,9 +5853,9 @@ var init_publish_manifest = __esm({
        */
       getDeletedFiles(newManifest) {
         const deletedFiles = [];
-        for (const path40 of this.files.keys()) {
-          if (!newManifest.files.has(path40)) {
-            deletedFiles.push(path40);
+        for (const path39 of this.files.keys()) {
+          if (!newManifest.files.has(path39)) {
+            deletedFiles.push(path39);
           }
         }
         return deletedFiles;
@@ -5866,8 +5865,8 @@ var init_publish_manifest = __esm({
        */
       toJSON() {
         const filesObj = {};
-        for (const [path40, entry] of this.files.entries()) {
-          filesObj[path40] = entry;
+        for (const [path39, entry] of this.files.entries()) {
+          filesObj[path39] = entry;
         }
         return {
           projectId: this.projectId,
@@ -7459,8 +7458,8 @@ var require_Client = __commonJS({
       /**
        * Set the working directory.
        */
-      async cd(path40) {
-        const validPath = await this.protectWhitespace(path40);
+      async cd(path39) {
+        const validPath = await this.protectWhitespace(path39);
         return this.send("CWD " + validPath);
       }
       /**
@@ -7473,8 +7472,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(path40) {
-        const validPath = await this.protectWhitespace(path40);
+      async lastMod(path39) {
+        const validPath = await this.protectWhitespace(path39);
         const res = await this.send(`MDTM ${validPath}`);
         const date = res.message.slice(4);
         return (0, parseListMLSD_1.parseMLSxDate)(date);
@@ -7482,8 +7481,8 @@ var require_Client = __commonJS({
       /**
        * Get the size of a file.
        */
-      async size(path40) {
-        const validPath = await this.protectWhitespace(path40);
+      async size(path39) {
+        const validPath = await this.protectWhitespace(path39);
         const command = `SIZE ${validPath}`;
         const res = await this.send(command);
         const size = parseInt(res.message.slice(4), 10);
@@ -7510,8 +7509,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(path40, ignoreErrorCodes = false) {
-        const validPath = await this.protectWhitespace(path40);
+      async remove(path39, ignoreErrorCodes = false) {
+        const validPath = await this.protectWhitespace(path39);
         if (ignoreErrorCodes) {
           return this.sendIgnoringError(`DELE ${validPath}`);
         }
@@ -7665,8 +7664,8 @@ var require_Client = __commonJS({
        *
        * @param [path]  Path to remote file or directory.
        */
-      async list(path40 = "") {
-        const validPath = await this.protectWhitespace(path40);
+      async list(path39 = "") {
+        const validPath = await this.protectWhitespace(path39);
         let lastError;
         for (const candidate of this.availableListCommands) {
           const command = validPath === "" ? candidate : `${candidate} ${validPath}`;
@@ -7836,21 +7835,21 @@ var require_Client = __commonJS({
       /**
        * Remove an empty directory, will fail if not empty.
        */
-      async removeEmptyDir(path40) {
-        const validPath = await this.protectWhitespace(path40);
+      async removeEmptyDir(path39) {
+        const validPath = await this.protectWhitespace(path39);
         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(path40) {
-        if (!path40.startsWith(" ")) {
-          return path40;
+      async protectWhitespace(path39) {
+        if (!path39.startsWith(" ")) {
+          return path39;
         }
         const pwd = await this.pwd();
         const absolutePathPrefix = pwd.endsWith("/") ? pwd : pwd + "/";
-        return absolutePathPrefix + path40;
+        return absolutePathPrefix + path39;
       }
       async _exitAtCurrentDirectory(func) {
         const userDir = await this.pwd();
@@ -7927,11 +7926,11 @@ var require_Client = __commonJS({
       }
     };
     exports2.Client = Client2;
-    async function ensureLocalDirectory(path40) {
+    async function ensureLocalDirectory(path39) {
       try {
-        await fsStat(path40);
+        await fsStat(path39);
       } catch (_a2) {
-        await fsMkDir(path40, { recursive: true });
+        await fsMkDir(path39, { recursive: true });
       }
     }
     async function ignoreError(func) {
@@ -7994,13 +7993,13 @@ var require_dist = __commonJS({
 });
 
 // internal/domain/publish/value-object/ftp-publisher.ts
-var ftp, import_path5, import_fs4, log10, FtpPublisher;
+var ftp, import_path4, 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_path5 = __toESM(require("path"));
+    import_path4 = __toESM(require("path"));
     import_fs4 = require("fs");
     log10 = getDomainLogger("ftp-publisher", { component: "domain" });
     FtpPublisher = class {
@@ -8048,10 +8047,10 @@ var init_ftp_publisher = __esm({
           });
           const createdDirs = /* @__PURE__ */ new Set();
           for (const relativePath of changedFiles) {
-            const localPath = import_path5.default.join(sourceDir, relativePath);
+            const localPath = import_path4.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_path5.default.dirname(remoteFilePath).replace(/\\/g, "/");
+              const remoteDir = import_path4.default.dirname(remoteFilePath).replace(/\\/g, "/");
               if (remoteDir && remoteDir !== "." && remoteDir !== "/") {
                 if (!createdDirs.has(remoteDir)) {
                   try {
@@ -8282,12 +8281,12 @@ var init_ftp_publisher = __esm({
 });
 
 // internal/domain/publish/value-object/netlify-publisher.ts
-var import_path6, import_fs5, log11, NetlifyPublisher;
+var import_path5, import_fs5, log11, NetlifyPublisher;
 var init_netlify_publisher = __esm({
   "internal/domain/publish/value-object/netlify-publisher.ts"() {
     "use strict";
     init_log();
-    import_path6 = __toESM(require("path"));
+    import_path5 = __toESM(require("path"));
     import_fs5 = require("fs");
     log11 = getDomainLogger("netlify-publisher", { component: "domain" });
     NetlifyPublisher = class {
@@ -8549,7 +8548,7 @@ var init_netlify_publisher = __esm({
             log11.warn(`File not found in manifest: ${filePath}`);
             continue;
           }
-          const localFilePath = import_path6.default.join(sourceDir, filePath);
+          const localFilePath = import_path5.default.join(sourceDir, filePath);
           try {
             const fileContent = await import_fs5.promises.readFile(localFilePath);
             await this.uploadFileWithRetry(deployId, filePath, fileContent, fileEntry.hash);
@@ -8693,12 +8692,12 @@ var mdfriday_publisher_exports = {};
 __export(mdfriday_publisher_exports, {
   MDFridayPublisher: () => MDFridayPublisher
 });
-var import_path7, import_fs6, log12, MDFridayPublisher;
+var import_path6, import_fs6, log12, MDFridayPublisher;
 var init_mdfriday_publisher = __esm({
   "internal/domain/publish/value-object/mdfriday-publisher.ts"() {
     "use strict";
     init_log();
-    import_path7 = __toESM(require("path"));
+    import_path6 = __toESM(require("path"));
     import_fs6 = require("fs");
     log12 = getDomainLogger("mdfriday-publisher", { component: "domain" });
     MDFridayPublisher = class {
@@ -8916,7 +8915,7 @@ 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_path7.default.join(sourceDir, relativePath);
+          const filePath = import_path6.default.join(sourceDir, relativePath);
           try {
             const fileContent = await import_fs6.promises.readFile(filePath);
             zip.file(relativePath, new Uint8Array(fileContent));
@@ -8940,7 +8939,7 @@ var init_mdfriday_publisher = __esm({
         const addDirectoryToZip = async (dirPath, zipFolder) => {
           const items = await import_fs6.promises.readdir(dirPath, { withFileTypes: true });
           for (const item of items) {
-            const itemPath = import_path7.default.join(dirPath, item.name);
+            const itemPath = import_path6.default.join(dirPath, item.name);
             if (item.isDirectory()) {
               const subFolder = zipFolder.folder(item.name);
               if (subFolder) {
@@ -9039,10 +9038,10 @@ var init_mdfriday_publisher = __esm({
       /**
        * Build multipart form data for upload
        */
-      buildFormData(zipContent, projectName, path40, deploymentType) {
+      buildFormData(zipContent, projectName, path39, deploymentType) {
         return {
           type: deploymentType,
-          path: path40,
+          path: path39,
           id: "-1",
           // NEW_ID
           name: projectName,
@@ -9198,13 +9197,13 @@ var init_publish = __esm({
 });
 
 // internal/infrastructure/persistence/node-manifest-repository.ts
-var import_path8, import_fs7, import_crypto, log14, NodeManifestRepository;
+var import_path7, 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_path8 = __toESM(require("path"));
+    import_path7 = __toESM(require("path"));
     import_fs7 = require("fs");
     import_crypto = __toESM(require("crypto"));
     log14 = getDomainLogger("node-manifest-repo", { component: "infrastructure" });
@@ -9231,7 +9230,7 @@ var init_node_manifest_repository = __esm({
        * Save manifest to file
        */
       async saveManifest(projectPath, manifest, suffix) {
-        const manifestDir = import_path8.default.join(projectPath, ".mdfriday");
+        const manifestDir = import_path7.default.join(projectPath, ".mdfriday");
         await import_fs7.promises.mkdir(manifestDir, { recursive: true });
         const manifestPath = this.getManifestPath(
           projectPath,
@@ -9290,7 +9289,7 @@ var init_node_manifest_repository = __esm({
        */
       getManifestPath(projectPath, publishMethod, suffix) {
         const filename = suffix ? `manifest-${publishMethod}-${suffix}.json` : `manifest-${publishMethod}.json`;
-        return import_path8.default.join(projectPath, ".mdfriday", filename);
+        return import_path7.default.join(projectPath, ".mdfriday", filename);
       }
       /**
        * Recursively scan directory and collect file info
@@ -9298,8 +9297,8 @@ var init_node_manifest_repository = __esm({
       async scanDirectory(currentPath, relativePath, files, hashAlgorithm = "md5") {
         const items = await import_fs7.promises.readdir(currentPath, { withFileTypes: true });
         for (const item of items) {
-          const itemPath = import_path8.default.join(currentPath, item.name);
-          const itemRelativePath = relativePath ? import_path8.default.join(relativePath, item.name) : item.name;
+          const itemPath = import_path7.default.join(currentPath, item.name);
+          const itemRelativePath = relativePath ? import_path7.default.join(relativePath, item.name) : item.name;
           if (item.isDirectory()) {
             await this.scanDirectory(itemPath, itemRelativePath, files, hashAlgorithm);
           } else if (item.isFile()) {
@@ -10281,8 +10280,8 @@ var init_module2 = __esm({
       /**
        * Find import by path
        */
-      findImport(path40) {
-        return this.moduleConfig.imports.find((imp) => imp.path === path40);
+      findImport(path39) {
+        return this.moduleConfig.imports.find((imp) => imp.path === path39);
       }
       /**
        * Find mount by source
@@ -11531,11 +11530,11 @@ var init_markdown2 = __esm({
 function newDir(workingDir, themesDir, publishDir) {
   return new Dir(workingDir, themesDir, publishDir);
 }
-var import_path9, DEFAULT_PUBLISH_DIR, Dir;
+var import_path8, DEFAULT_PUBLISH_DIR, Dir;
 var init_dir = __esm({
   "internal/domain/config/entity/dir.ts"() {
     "use strict";
-    import_path9 = __toESM(require("path"));
+    import_path8 = __toESM(require("path"));
     DEFAULT_PUBLISH_DIR = "public";
     Dir = class {
       workingDir;
@@ -11547,16 +11546,16 @@ var init_dir = __esm({
         this.publishDir = publishDir;
       }
       getWorkingDir() {
-        return import_path9.default.resolve(this.workingDir);
+        return import_path8.default.resolve(this.workingDir);
       }
       getThemesDir() {
-        return import_path9.default.resolve(this.themesDir);
+        return import_path8.default.resolve(this.themesDir);
       }
       getThemesCacheDir() {
-        return import_path9.default.resolve(this.themesDir, ".cache");
+        return import_path8.default.resolve(this.themesDir, ".cache");
       }
       getPublishDir() {
-        return import_path9.default.resolve(this.publishDir);
+        return import_path8.default.resolve(this.publishDir);
       }
     };
   }
@@ -11746,12 +11745,12 @@ var init_provider = __esm({
 });
 
 // internal/domain/config/factory/loader.ts
-var path10, NO_CONFIG_FILE_ERR_INFO, ConfigLoader;
+var path9, NO_CONFIG_FILE_ERR_INFO, ConfigLoader;
 var init_loader = __esm({
   "internal/domain/config/factory/loader.ts"() {
     "use strict";
     init_provider();
-    path10 = __toESM(require("path"));
+    path9 = __toESM(require("path"));
     NO_CONFIG_FILE_ERR_INFO = "Unable to locate config file or config directory.";
     ConfigLoader = class {
       cfg;
@@ -11790,13 +11789,13 @@ var init_loader = __esm({
       async loadProvider(configName) {
         const baseDir = this.baseDirs.workingDir;
         let baseFilename;
-        if (path10.isAbsolute(configName)) {
+        if (path9.isAbsolute(configName)) {
           baseFilename = configName;
         } else {
-          baseFilename = path10.join(baseDir, configName);
+          baseFilename = path9.join(baseDir, configName);
         }
         let filename = "";
-        if (path10.extname(configName) !== "") {
+        if (path9.extname(configName) !== "") {
           const exists = await this.fileExists(baseFilename);
           if (exists) {
             filename = baseFilename;
@@ -11935,9 +11934,9 @@ var init_sourcedescriptor = __esm({
 
 // internal/domain/config/factory/config.ts
 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 cleanWorkingDir = path10.resolve(workingDir);
+  const cleanModulesDir = path10.resolve(modulesDir);
+  const cleanPublishDir = path10.resolve(DEFAULT_PUBLISH_DIR);
   const baseDirs = {
     workingDir: cleanWorkingDir,
     modulesDir: cleanModulesDir,
@@ -11954,7 +11953,7 @@ async function loadConfigWithParams(fs13, configFilename, workingDir, modulesDir
     for (const [key2, value] of Object.entries(params)) {
       provider.set(key2, value);
     }
-    const absPublishDir = path11.resolve(provider.get("publishDir") || DEFAULT_PUBLISH_DIR);
+    const absPublishDir = path10.resolve(provider.get("publishDir") || DEFAULT_PUBLISH_DIR);
     await fs13.mkdirAll(absPublishDir, 511);
     return newConfig(
       fs13,
@@ -11977,15 +11976,15 @@ async function getCacheDir(fs13, cacheDir) {
     return cacheDir;
   }
   const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-  const defaultCacheDir = path11.join(homeDir, ".cache", "mdf");
+  const defaultCacheDir = path10.join(homeDir, ".cache", "mdf");
   try {
     await fs13.mkdirAll(defaultCacheDir, 493);
     return defaultCacheDir;
   } catch {
-    return path11.join("/tmp", "hugo-cache");
+    return path10.join("/tmp", "hugo-cache");
   }
 }
-var path11;
+var path10;
 var init_config2 = __esm({
   "internal/domain/config/factory/config.ts"() {
     "use strict";
@@ -12000,7 +11999,7 @@ var init_config2 = __esm({
     init_markdown2();
     init_loader();
     init_sourcedescriptor();
-    path11 = __toESM(require("path"));
+    path10 = __toESM(require("path"));
   }
 });
 
@@ -12072,11 +12071,11 @@ function createDefaultMounts(componentFolders) {
     (folder) => new Mount(folder, folder)
   );
 }
-var path12, Mount;
+var path11, Mount;
 var init_mount = __esm({
   "internal/domain/module/vo/mount.ts"() {
     "use strict";
-    path12 = __toESM(require("path"));
+    path11 = __toESM(require("path"));
     Mount = class _Mount {
       constructor(sourcePath, targetPath, language2 = "") {
         this.sourcePath = sourcePath;
@@ -12111,16 +12110,16 @@ var init_mount = __esm({
        * Get component name from target path
        */
       component() {
-        const parts = this.targetPath.split(path12.sep);
+        const parts = this.targetPath.split(path11.sep);
         return parts[0] || "";
       }
       /**
        * Get component and name from target path
        */
       componentAndName() {
-        const parts = this.targetPath.split(path12.sep);
+        const parts = this.targetPath.split(path11.sep);
         const component = parts[0] || "";
-        const name = parts.slice(1).join(path12.sep);
+        const name = parts.slice(1).join(path11.sep);
         return { component, name };
       }
       /**
@@ -12165,12 +12164,12 @@ function newHttpClient(fs13, timeout, headers, customClient) {
   }
   return new NodeHttpClient2(fs13, timeout, headers);
 }
-var path13, http, https, log20, NodeHttpClient2;
+var path12, http, https, log20, NodeHttpClient2;
 var init_httpclient = __esm({
   "internal/domain/module/vo/httpclient.ts"() {
     "use strict";
     init_type5();
-    path13 = __toESM(require("path"));
+    path12 = __toESM(require("path"));
     http = __toESM(require("http"));
     https = __toESM(require("https"));
     init_log();
@@ -12221,7 +12220,7 @@ var init_httpclient = __esm({
               let lastProgressTime = Date.now();
               let lastLoggedPercentage = -1;
               try {
-                const targetDir = path13.dirname(targetPath);
+                const targetDir = path12.dirname(targetPath);
                 await this.fs.mkdirAll(targetDir, 493);
                 const file = await this.fs.create(targetPath);
                 const chunks = [];
@@ -12372,14 +12371,14 @@ function newZipExtractor(fs13, environment = "node") {
       throw new Error(`Unsupported environment: ${environment}`);
   }
 }
-var import_jszip, path14, log21, JsZipExtractor, WebZipExtractor;
+var import_jszip, path13, log21, JsZipExtractor, WebZipExtractor;
 var init_zipextractor = __esm({
   "internal/domain/module/vo/zipextractor.ts"() {
     "use strict";
     init_type5();
     init_log();
     import_jszip = __toESM(require("jszip"));
-    path14 = __toESM(require("path"));
+    path13 = __toESM(require("path"));
     log21 = getDomainLogger("module", { component: "zipextractor" });
     JsZipExtractor = class {
       constructor(fs13) {
@@ -12453,11 +12452,11 @@ var init_zipextractor = __esm({
        * Extract a single ZIP entry (file or directory)
        */
       async extractSingleEntry(relativePath, zipEntry, targetDir) {
-        const fullPath = path14.join(targetDir, relativePath);
+        const fullPath = path13.join(targetDir, relativePath);
         if (zipEntry.dir) {
           await this.fs.mkdirAll(fullPath, 493);
         } else {
-          const dir2 = path14.dirname(fullPath);
+          const dir2 = path13.dirname(fullPath);
           if (dir2 !== targetDir) {
             await this.fs.mkdirAll(dir2, 493);
           }
@@ -12513,13 +12512,13 @@ var init_zipextractor = __esm({
 function newModuleCache(fs13, cacheDir) {
   return new FsModuleCache(fs13, cacheDir);
 }
-var path15, log22, FsModuleCache;
+var path14, log22, FsModuleCache;
 var init_cache = __esm({
   "internal/domain/module/vo/cache.ts"() {
     "use strict";
     init_type5();
     init_log();
-    path15 = __toESM(require("path"));
+    path14 = __toESM(require("path"));
     log22 = getDomainLogger("module", { component: "cache" });
     FsModuleCache = class {
       constructor(fs13, cacheDir = "./module/cache") {
@@ -12615,7 +12614,7 @@ var init_cache = __esm({
        */
       getCacheFilePath(modulePath) {
         const safeFileName = modulePath.replace(/[/\\:*?"<>|]/g, "_").replace(/^_+|_+$/g, "") + ".json";
-        return path15.join(this.cacheDir, safeFileName);
+        return path14.join(this.cacheDir, safeFileName);
       }
       /**
        * Get cache directory
@@ -12632,7 +12631,7 @@ var init_cache = __esm({
           let totalSize = 0;
           for (const file of files) {
             try {
-              const filePath = path15.join(this.cacheDir, file);
+              const filePath = path14.join(this.cacheDir, file);
               const fileInfo = await this.fs.stat(filePath);
               totalSize += fileInfo.size();
             } catch (error) {
@@ -12656,7 +12655,7 @@ var init_cache = __esm({
         try {
           const files = await this.listCacheFiles();
           return files.map(
-            (file) => path15.basename(file, ".json").replace(/_/g, "/")
+            (file) => path14.basename(file, ".json").replace(/_/g, "/")
           );
         } catch (error) {
           return [];
@@ -12708,13 +12707,13 @@ function newProjectModule(info) {
   }
   return projectModule;
 }
-var path16, Module2, ProjectModule;
+var path15, Module2, ProjectModule;
 var init_module3 = __esm({
   "internal/domain/module/vo/module.ts"() {
     "use strict";
     init_type5();
     init_mount();
-    path16 = __toESM(require("path"));
+    path15 = __toESM(require("path"));
     Module2 = class _Module {
       constructor(fs13, absoluteDir, modulePath, parent = null, isProject = false) {
         this.fs = fs13;
@@ -12778,7 +12777,7 @@ var init_module3 = __esm({
           let mounts = moduleImport.mounts || [];
           if (mounts.length === 0) {
             for (const componentFolder of ComponentFolders) {
-              const sourceDir = path16.join(this.absoluteDir, componentFolder);
+              const sourceDir = path15.join(this.absoluteDir, componentFolder);
               try {
                 const stat4 = await this.fs.stat(sourceDir);
                 if (stat4.isDir()) {
@@ -12929,11 +12928,11 @@ var init_module3 = __esm({
 function newLang(modules) {
   return new Lang(modules);
 }
-var import_path10, Lang;
+var import_path9, Lang;
 var init_lang2 = __esm({
   "internal/domain/module/entity/lang.ts"() {
     "use strict";
-    import_path10 = __toESM(require("path"));
+    import_path9 = __toESM(require("path"));
     Lang = class {
       sourceLangMap;
       constructor(modules) {
@@ -12949,7 +12948,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_path10.default.basename(source));
+        const lang2 = this.sourceLangMap.get(import_path9.default.basename(source));
         if (lang2 !== void 0) {
           return [lang2, true];
         }
@@ -13052,7 +13051,7 @@ var init_themes = __esm({
 function newModules(info, httpClient, zipExtractor, moduleCache) {
   return new Modules(info, httpClient, zipExtractor, moduleCache);
 }
-var import_smol_toml, path18, log23, Modules;
+var import_smol_toml, path17, log23, Modules;
 var init_module4 = __esm({
   "internal/domain/module/entity/module.ts"() {
     "use strict";
@@ -13062,7 +13061,7 @@ var init_module4 = __esm({
     init_themes();
     init_log();
     import_smol_toml = require("smol-toml");
-    path18 = __toESM(require("path"));
+    path17 = __toESM(require("path"));
     log23 = getDomainLogger("module", { component: "modules" });
     Modules = class {
       constructor(info, httpClient, zipExtractor, moduleCache) {
@@ -13217,7 +13216,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 = path18.join(moduleDir, "module.zip");
+          const zipPath = path17.join(moduleDir, "module.zip");
           const metadata = {
             path: moduleImport.path,
             version: moduleImport.version || "latest",
@@ -13323,7 +13322,7 @@ var init_module4 = __esm({
        */
       getModuleDir(modulePath) {
         const safeName = modulePath.replace(/[/\\:*?"<>|]/g, "_").replace(/^_+|_+$/g, "");
-        return path18.join(this.info.moduleDir(), safeName);
+        return path17.join(this.info.moduleDir(), safeName);
       }
       /**
        * Get download URL for module path
@@ -13424,7 +13423,7 @@ var init_module4 = __esm({
        */
       async parseThemeToml(module2) {
         try {
-          const themeTomlPath = path18.join(module2.dir(), "theme.toml");
+          const themeTomlPath = path17.join(module2.dir(), "theme.toml");
           try {
             const stat4 = await this.info.osFs().stat(themeTomlPath);
             if (stat4.isDir()) {
@@ -13816,13 +13815,13 @@ function newFileWithMeta(file, meta, fs13) {
 function newDirFileWithMeta(file, meta, fs13) {
   return new File(file, meta, fs13, true);
 }
-var path19, File;
+var path18, File;
 var init_file = __esm({
   "internal/domain/fs/vo/file.ts"() {
     "use strict";
     init_filemeta();
     init_fileinfo();
-    path19 = __toESM(require("path"));
+    path18 = __toESM(require("path"));
     File = class {
       file;
       fileMeta;
@@ -13916,7 +13915,7 @@ var init_file = __esm({
         return await this.file.writeAt(buffer, offset);
       }
       name() {
-        return path19.basename(this.fileMeta.fileName());
+        return path18.basename(this.fileMeta.fileName());
       }
       async readdir(count) {
         if (this.file === null) {
@@ -14038,7 +14037,7 @@ var init_dir2 = __esm({
 function newBaseFs(fs13, roots) {
   return new BaseFs(fs13, roots);
 }
-var path20, log26, BaseFs;
+var path19, log26, BaseFs;
 var init_basefs = __esm({
   "internal/domain/fs/entity/basefs.ts"() {
     "use strict";
@@ -14046,7 +14045,7 @@ var init_basefs = __esm({
     init_fileinfo();
     init_file();
     init_dir2();
-    path20 = __toESM(require("path"));
+    path19 = __toESM(require("path"));
     init_log();
     log26 = getDomainLogger("fs", { component: "basefs" });
     BaseFs = class {
@@ -14069,17 +14068,17 @@ var init_basefs = __esm({
         if (name === "") {
           return root2;
         }
-        if (path20.isAbsolute(name)) {
+        if (path19.isAbsolute(name)) {
           if (name.startsWith(root2)) {
             return name;
           }
-          return path20.join(root2, name.substring(1));
+          return path19.join(root2, name.substring(1));
         }
-        return path20.join(root2, name);
+        return path19.join(root2, name);
       }
       isSameRootedPath(name) {
         const root2 = this.roots[0];
-        return name.startsWith(path20.join(root2, path20.sep)) || name === root2;
+        return name.startsWith(path19.join(root2, path19.sep)) || name === root2;
       }
       /**
        * Stat returns file info with opener function
@@ -14165,8 +14164,8 @@ var init_basefs = __esm({
         const absPath = this.toAbsolutePath(name);
         return await this.fs.mkdir(absPath, perm);
       }
-      async mkdirAll(path40, perm) {
-        const absPath = this.toAbsolutePath(path40);
+      async mkdirAll(path39, perm) {
+        const absPath = this.toAbsolutePath(path39);
         return await this.fs.mkdirAll(absPath, perm);
       }
       async openFile(name, flag, perm) {
@@ -14177,8 +14176,8 @@ var init_basefs = __esm({
         const absPath = this.toAbsolutePath(name);
         return await this.fs.remove(absPath);
       }
-      async removeAll(path40) {
-        const absPath = this.toAbsolutePath(path40);
+      async removeAll(path39) {
+        const absPath = this.toAbsolutePath(path39);
         return await this.fs.removeAll(absPath);
       }
       async rename(oldname, newname) {
@@ -14209,11 +14208,11 @@ var init_basefs = __esm({
 function newWalkway(fs13, cb) {
   return new Walkway(fs13, cb);
 }
-var path21, log27, Walkway;
+var path20, log27, Walkway;
 var init_walkway = __esm({
   "internal/domain/fs/vo/walkway.ts"() {
     "use strict";
-    path21 = __toESM(require("path"));
+    path20 = __toESM(require("path"));
     init_type6();
     init_fileinfo();
     init_filemeta();
@@ -14340,7 +14339,7 @@ var init_walkway = __esm({
           }
         }
         for (const entry of dirEntries) {
-          const nextPath = path21.join(filePath, entry.name());
+          const nextPath = path20.join(filePath, entry.name());
           try {
             await this.walkRecursive(nextPath, entry);
           } catch (err) {
@@ -14422,9 +14421,9 @@ var init_static_copier = __esm({
       async walkSourceFiles(sourceFs, targetDir) {
         let fileCount = 0;
         try {
-          await this.walkFileSystem(sourceFs, "/", async (path40, isDir) => {
+          await this.walkFileSystem(sourceFs, "/", async (path39, isDir) => {
             if (!isDir) {
-              await this.copyFile(sourceFs, path40, this.toFs, targetDir);
+              await this.copyFile(sourceFs, path39, this.toFs, targetDir);
               fileCount++;
             }
           });
@@ -14508,8 +14507,8 @@ var init_static_copier = __esm({
       /**
        * Get directory name from path
        */
-      dirname(path40) {
-        const parts = path40.split("/").filter((part) => part.length > 0);
+      dirname(path39) {
+        const parts = path39.split("/").filter((part) => part.length > 0);
         if (parts.length <= 1)
           return "/";
         return "/" + parts.slice(0, -1).join("/");
@@ -14522,16 +14521,16 @@ var init_static_copier = __esm({
 async function collectFileMetaInfos(paths, fss) {
   const result = /* @__PURE__ */ new Map();
   let found = false;
-  for (const path40 of paths) {
+  for (const path39 of paths) {
     for (const fs13 of fss) {
       try {
-        const fileMetaInfo = await createFileMetaInfo(path40, fs13);
-        result.set(path40, fileMetaInfo);
+        const fileMetaInfo = await createFileMetaInfo(path39, fs13);
+        result.set(path39, fileMetaInfo);
         found = true;
         if (found)
           break;
       } catch (error) {
-        log29.error(`Failed to create FileMetaInfo for ${path40} with fs=${fs13}:`, error);
+        log29.error(`Failed to create FileMetaInfo for ${path39} with fs=${fs13}:`, error);
       }
     }
   }
@@ -14640,8 +14639,8 @@ var init_fs = __esm({
       /**
        * Create new base path filesystem
        */
-      newBasePathFs(source, path40) {
-        return newBaseFs(source, [path40]);
+      newBasePathFs(source, path39) {
+        return newBaseFs(source, [path39]);
       }
       async walkPrompts(start, cb, conf) {
         return await this.walk(this.prompts, start, cb, conf);
@@ -15183,11 +15182,11 @@ var init_overlayfs = __esm({
       /**
        * Create directory tree (write operation)
        */
-      async mkdirAll(path40, perm) {
+      async mkdirAll(path39, perm) {
         if (!this.firstWritable) {
           throw new OverlayFsError("filesystem is read-only", "READ_ONLY");
         }
-        return await this.writeFs().mkdirAll(path40, perm);
+        return await this.writeFs().mkdirAll(path39, perm);
       }
       /**
        * Open file for reading (searches all filesystems)
@@ -15246,11 +15245,11 @@ var init_overlayfs = __esm({
       /**
        * Remove directory tree (write operation)
        */
-      async removeAll(path40) {
+      async removeAll(path39) {
         if (!this.firstWritable) {
           throw new OverlayFsError("filesystem is read-only", "READ_ONLY");
         }
-        return await this.writeFs().removeAll(path40);
+        return await this.writeFs().removeAll(path39);
       }
       /**
        * Rename file (write operation)
@@ -15507,13 +15506,13 @@ var init_overlayfs_factory = __esm({
 function newFilesystemsCollector(sourceProject) {
   return new FilesystemsCollector(sourceProject);
 }
-var path22, log31, RootMapping, FilesystemsCollector;
+var path21, log31, RootMapping, FilesystemsCollector;
 var init_filesystemscollector = __esm({
   "internal/domain/fs/vo/filesystemscollector.ts"() {
     "use strict";
     init_overlayfs_factory();
     init_basefs();
-    path22 = __toESM(require("path"));
+    path21 = __toESM(require("path"));
     init_log();
     log31 = getDomainLogger("fs", { component: "filesystemscollector" });
     RootMapping = class {
@@ -15568,7 +15567,7 @@ var init_filesystemscollector = __esm({
           const fromToAssets = [];
           const fromToI18n = [];
           const absPathify = (inputPath) => {
-            if (path22.isAbsolute(inputPath)) {
+            if (path21.isAbsolute(inputPath)) {
               return ["", inputPath];
             }
             return [md.dir(), this.absPathify(md.dir(), inputPath)];
@@ -15647,7 +15646,7 @@ var init_filesystemscollector = __esm({
         return target === "i18n" || target.startsWith("i18n/") || target.startsWith("/i18n/");
       }
       absPathify(baseDir, relativePath) {
-        return path22.resolve(baseDir, relativePath);
+        return path21.resolve(baseDir, relativePath);
       }
     };
   }
@@ -15657,12 +15656,12 @@ var init_filesystemscollector = __esm({
 function newOsFs() {
   return new OsFs();
 }
-var fs8, path23, log32, OsFileInfo, OsFile, OsFs;
+var fs8, path22, log32, OsFileInfo, OsFile, OsFs;
 var init_osfs = __esm({
   "internal/domain/fs/vo/osfs.ts"() {
     "use strict";
     fs8 = __toESM(require("fs/promises"));
-    path23 = __toESM(require("path"));
+    path22 = __toESM(require("path"));
     init_log();
     log32 = getDomainLogger("fs", { component: "osfs" });
     OsFileInfo = class {
@@ -15785,7 +15784,7 @@ var init_osfs = __esm({
         const limit = count > 0 ? Math.min(count, entries.length) : entries.length;
         for (let i = 0; i < limit; i++) {
           const entry = entries[i];
-          const entryPath = path23.join(this.filePath, entry.name);
+          const entryPath = path22.join(this.filePath, entry.name);
           const stats = await fs8.stat(entryPath);
           result.push(new OsFileInfo(stats, entry.name));
         }
@@ -15801,7 +15800,7 @@ var init_osfs = __esm({
         if (this.closed)
           throw new Error("File is closed");
         const stats = await fs8.stat(this.filePath);
-        return new OsFileInfo(stats, path23.basename(this.filePath));
+        return new OsFileInfo(stats, path22.basename(this.filePath));
       }
       async sync() {
         if (this.closed)
@@ -15878,7 +15877,7 @@ var init_osfs = __esm({
       }
       async stat(name) {
         const stats = await fs8.stat(name);
-        return new OsFileInfo(stats, path23.basename(name));
+        return new OsFileInfo(stats, path22.basename(name));
       }
       name() {
         return "OsFs";
@@ -19250,8 +19249,8 @@ function wikilinkInlineRule(state, silent) {
 function renderWikilinkLink(tokens, idx) {
   const token = tokens[idx];
   const meta = token.meta;
-  const [path40, _anchor] = splitAnchor(meta.url);
-  const slug2 = slugifyFilePath(path40);
+  const [path39, _anchor] = splitAnchor(meta.url);
+  const slug2 = slugifyFilePath(path39);
   const displayText = meta.alias ?? meta.filepath;
   const escapedText = escapeHtml(displayText);
   return `<a class="internal" data-slug="${slug2}" data-wikilink="${escapeHtml(meta.url)}">${escapedText}</a>`;
@@ -20217,8 +20216,8 @@ var init_type10 = __esm({
       COMPONENT_FOLDER_ASSETS: "assets",
       COMPONENT_FOLDER_I18N: "i18n",
       // Path normalization utility
-      normalizePath: (path40) => {
-        let p2 = path40.replace(/\\/g, "/");
+      normalizePath: (path39) => {
+        let p2 = path39.replace(/\\/g, "/");
         if (p2.startsWith("//")) {
           p2 = p2.substring(1);
         }
@@ -20468,8 +20467,8 @@ var init_path2 = __esm({
         if (this.components.component) {
           return this.components.component;
         }
-        const path40 = this.components.normalized;
-        const parts = path40.split("/").filter((p2) => p2.length > 0);
+        const path39 = this.components.normalized;
+        const parts = path39.split("/").filter((p2) => p2.length > 0);
         if (parts.length === 0) {
           return "content";
         }
@@ -20797,10 +20796,10 @@ var init_path2 = __esm({
       /**
        * Create a path from string components
        */
-      static fromString(component, path40) {
+      static fromString(component, path39) {
         const components = new PathComponentsImpl(
-          path40,
-          path40,
+          path39,
+          path39,
           { containerLow: -1, containerHigh: -1, sectionHigh: -1, identifierLanguage: -1 },
           [],
           0 /* File */,
@@ -20811,8 +20810,8 @@ var init_path2 = __esm({
       /**
        * Check if a path has a specific extension
        */
-      static hasExtension(path40, extension) {
-        const pathExt = path40.ext();
+      static hasExtension(path39, extension) {
+        const pathExt = path39.ext();
         const targetExt = extension.startsWith(".") ? extension : "." + extension;
         return pathExt.toLowerCase() === targetExt.toLowerCase();
       }
@@ -20870,20 +20869,20 @@ var init_pathparser = __esm({
       /**
        * Parse a path with component information
        */
-      parse(component, path40) {
-        let normalizedPath = path40;
+      parse(component, path39) {
+        let normalizedPath = path39;
         if (!normalizedPath || normalizedPath === "") {
           normalizedPath = "/";
         }
         const normalized = this.normalizer.normalize(normalizedPath);
-        const pathComponents = this.createPathComponents(component, normalized, path40);
+        const pathComponents = this.createPathComponents(component, normalized, path39);
         return new Path(pathComponents);
       }
       /**
        * Parse and return only the identity
        */
-      parseIdentity(component, path40) {
-        const parsed = this.parse(component, path40);
+      parseIdentity(component, path39) {
+        const parsed = this.parse(component, path39);
         return {
           identifierBase: () => parsed.base()
         };
@@ -20891,8 +20890,8 @@ var init_pathparser = __esm({
       /**
        * Parse and return base and base name without identifier
        */
-      parseBaseAndBaseNameNoIdentifier(component, path40) {
-        const parsed = this.parse(component, path40);
+      parseBaseAndBaseNameNoIdentifier(component, path39) {
+        const parsed = this.parse(component, path39);
         return [parsed.base(), parsed.baseNameNoIdentifier()];
       }
       /**
@@ -21021,8 +21020,8 @@ var init_pathparser = __esm({
         this.toLowerCase = toLowerCase;
         this.replaceSpaces = replaceSpaces;
       }
-      normalize(path40) {
-        let result = path40;
+      normalize(path39) {
+        let result = path39;
         result = result.replace(/\\/g, "/");
         if (this.toLowerCase) {
           result = result.toLowerCase();
@@ -21038,8 +21037,8 @@ var init_pathparser = __esm({
         this.toLowerCase = toLowerCase;
         this.replaceSpaces = replaceSpaces;
       }
-      normalize(path40) {
-        let result = path40;
+      normalize(path39) {
+        let result = path39;
         result = result.replace(/\\/g, "/");
         if (this.toLowerCase) {
           result = result.toLowerCase();
@@ -21059,12 +21058,12 @@ var init_pathparser = __esm({
         const htmlExts = PATH_CONSTANTS.HTML_EXTENSIONS;
         return htmlExts.includes(ext.toLowerCase());
       }
-      hasExt(path40) {
-        for (let i = path40.length - 1; i >= 0; i--) {
-          if (path40[i] === ".") {
+      hasExt(path39) {
+        for (let i = path39.length - 1; i >= 0; i--) {
+          if (path39[i] === ".") {
             return true;
           }
-          if (path40[i] === "/") {
+          if (path39[i] === "/") {
             return false;
           }
         }
@@ -21075,10 +21074,10 @@ var init_pathparser = __esm({
       /**
        * Parse a path string into basic components
        */
-      static parseBasic(path40) {
-        const lastSlash = path40.lastIndexOf("/");
-        const dir2 = lastSlash >= 0 ? path40.substring(0, lastSlash) : "";
-        const name = lastSlash >= 0 ? path40.substring(lastSlash + 1) : path40;
+      static parseBasic(path39) {
+        const lastSlash = path39.lastIndexOf("/");
+        const dir2 = lastSlash >= 0 ? path39.substring(0, lastSlash) : "";
+        const name = lastSlash >= 0 ? path39.substring(lastSlash + 1) : path39;
         const lastDot = name.lastIndexOf(".");
         const ext = lastDot >= 0 ? name.substring(lastDot) : "";
         const nameWithoutExt = lastDot >= 0 ? name.substring(0, lastDot) : name;
@@ -21093,43 +21092,43 @@ var init_pathparser = __esm({
       /**
        * Normalize a path string using basic rules
        */
-      static normalizeBasic(path40) {
+      static normalizeBasic(path39) {
         const normalizer = new BasicPathNormalizer();
-        return normalizer.normalize(path40);
+        return normalizer.normalize(path39);
       }
       /**
        * Check if a path represents a bundle
        */
-      static isBundle(path40) {
-        const basic = _PathParserUtils.parseBasic(path40);
+      static isBundle(path39) {
+        const basic = _PathParserUtils.parseBasic(path39);
         const indexNames = PATH_CONSTANTS.INDEX_NAMES;
         return indexNames.includes(basic.nameWithoutExt);
       }
       /**
        * Extract section from path
        */
-      static extractSection(path40) {
-        const normalized = path40.startsWith("/") ? path40.substring(1) : path40;
+      static extractSection(path39) {
+        const normalized = path39.startsWith("/") ? path39.substring(1) : path39;
         const firstSlash = normalized.indexOf("/");
         return firstSlash >= 0 ? normalized.substring(0, firstSlash) : normalized;
       }
       /**
        * Remove extension from path
        */
-      static removeExtension(path40) {
-        const lastDot = path40.lastIndexOf(".");
-        const lastSlash = path40.lastIndexOf("/");
+      static removeExtension(path39) {
+        const lastDot = path39.lastIndexOf(".");
+        const lastSlash = path39.lastIndexOf("/");
         if (lastDot > lastSlash) {
-          return path40.substring(0, lastDot);
+          return path39.substring(0, lastDot);
         }
-        return path40;
+        return path39;
       }
       /**
        * Check if path has extension
        */
-      static hasExtension(path40) {
+      static hasExtension(path39) {
         const checker = new DefaultFileExtensionChecker();
-        return checker.hasExt(path40);
+        return checker.hasExt(path39);
       }
     };
   }
@@ -21160,11 +21159,11 @@ var init_pathfactory = __esm({
       /**
        * Create a Path from component and path string
        */
-      create(component, path40, config) {
+      create(component, path39, config) {
         if (this.pool) {
           const pooledPath = this.pool.get();
         }
-        return this.processor.parse(component, path40);
+        return this.processor.parse(component, path39);
       }
       /**
        * Create a Path from PathComponents
@@ -21176,12 +21175,12 @@ var init_pathfactory = __esm({
        * Create multiple paths from an array of path strings
        */
       createMany(component, paths, config) {
-        return paths.map((path40) => this.create(component, path40, config));
+        return paths.map((path39) => this.create(component, path39, config));
       }
       /**
        * Create a path with custom configuration
        */
-      createWithConfig(component, path40, normalizeConfig) {
+      createWithConfig(component, path39, normalizeConfig) {
         const config = {};
         if (normalizeConfig?.toLowerCase !== void 0) {
           config.normalize = normalizeConfig.toLowerCase;
@@ -21192,7 +21191,7 @@ var init_pathfactory = __esm({
         if (normalizeConfig?.customNormalizer !== void 0) {
           config.normalizer = normalizeConfig.customNormalizer;
         }
-        return this.create(component, path40, config);
+        return this.create(component, path39, config);
       }
     };
     DefaultPathFactory = class extends PathFactoryImpl {
@@ -21216,9 +21215,9 @@ var init_pathfactory = __esm({
         const components = PathComponentsFactory.createEmpty();
         return new Path(components);
       }
-      put(path40) {
+      put(path39) {
         if (this.pool.length < this.maxSize) {
-          this.pool.push(path40);
+          this.pool.push(path39);
         }
       }
       /**
@@ -21252,8 +21251,8 @@ var init_pathfactory = __esm({
       /**
        * Set the path
        */
-      withPath(path40) {
-        this.path = path40;
+      withPath(path39) {
+        this.path = path39;
         return this;
       }
       /**
@@ -21301,38 +21300,38 @@ var init_pathfactory = __esm({
       /**
        * Create a content path
        */
-      static createContentPath(path40) {
-        return _PathFactoryUtils.defaultFactory.create("content", path40);
+      static createContentPath(path39) {
+        return _PathFactoryUtils.defaultFactory.create("content", path39);
       }
       /**
        * Create a static resource path
        */
-      static createStaticPath(path40) {
-        return _PathFactoryUtils.defaultFactory.create("static", path40);
+      static createStaticPath(path39) {
+        return _PathFactoryUtils.defaultFactory.create("static", path39);
       }
       /**
        * Create a layout path
        */
-      static createLayoutPath(path40) {
-        return _PathFactoryUtils.defaultFactory.create("layouts", path40);
+      static createLayoutPath(path39) {
+        return _PathFactoryUtils.defaultFactory.create("layouts", path39);
       }
       /**
        * Create an archetype path
        */
-      static createArchetypePath(path40) {
-        return _PathFactoryUtils.defaultFactory.create("archetypes", path40);
+      static createArchetypePath(path39) {
+        return _PathFactoryUtils.defaultFactory.create("archetypes", path39);
       }
       /**
        * Create a data path
        */
-      static createDataPath(path40) {
-        return _PathFactoryUtils.defaultFactory.create("data", path40);
+      static createDataPath(path39) {
+        return _PathFactoryUtils.defaultFactory.create("data", path39);
       }
       /**
        * Create a theme path
        */
-      static createThemePath(path40) {
-        return _PathFactoryUtils.defaultFactory.create("themes", path40);
+      static createThemePath(path39) {
+        return _PathFactoryUtils.defaultFactory.create("themes", path39);
       }
       /**
        * Create paths from a configuration object
@@ -21346,7 +21345,7 @@ var init_pathfactory = __esm({
           factoryConfig.replaceSpaces = config.replaceSpaces;
         }
         const factory = new PathFactoryImpl(factoryConfig);
-        return config.paths.map((path40) => factory.create(config.component, path40));
+        return config.paths.map((path39) => factory.create(config.component, path39));
       }
       /**
        * Get a path builder instance
@@ -21357,9 +21356,9 @@ var init_pathfactory = __esm({
       /**
        * Create a path with pooling
        */
-      static createWithPool(component, path40, pool2) {
+      static createWithPool(component, path39, pool2) {
         const factory = new PathFactoryImpl(void 0, pool2);
-        return factory.create(component, path40);
+        return factory.create(component, path39);
       }
     };
   }
@@ -21465,12 +21464,12 @@ var init_translator = __esm({
       async setupTranslateFuncs(fsService) {
         try {
           await fsService.walkI18n("", {
-            walkFn: async (path40, info) => {
-              if (!path40.endsWith(".yaml") && !path40.endsWith(".yml")) {
+            walkFn: async (path39, info) => {
+              if (!path39.endsWith(".yaml") && !path39.endsWith(".yml")) {
                 return;
               }
               try {
-                const normalizedPath = PATH_CONSTANTS.normalizePath(path40);
+                const normalizedPath = PATH_CONSTANTS.normalizePath(path39);
                 const filename = normalizedPath.split("/").pop() || "";
                 const langKey = filename.replace(/\.(yaml|yml)$/, "").toLowerCase();
                 const content = await this.readI18nFile(info);
@@ -21490,7 +21489,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 ${path40}:`, error);
+                log38.error(`\u274C Failed to load i18n file ${path39}:`, error);
               }
             }
           }, {});
@@ -21696,13 +21695,13 @@ function isContentExt(ext) {
 function newFileInfo2(fi) {
   return FileInfo7.newFileInfo(fi);
 }
-var crypto2, path24, log41, contentFileExtensions, contentFileExtensionsSet, FileInfo7;
+var crypto2, path23, log41, contentFileExtensions, contentFileExtensionsSet, FileInfo7;
 var init_fileinfo2 = __esm({
   "internal/domain/content/vo/fileinfo.ts"() {
     "use strict";
     init_paths();
     crypto2 = __toESM(require("crypto"));
-    path24 = __toESM(require("path"));
+    path23 = __toESM(require("path"));
     init_log();
     log41 = getDomainLogger("content", { component: "FileInfo" });
     contentFileExtensions = [
@@ -21740,7 +21739,7 @@ var init_fileinfo2 = __esm({
       relPath() {
         const dir2 = this.pathInfo.dir();
         const dirWithoutLeadingSlash = dir2.startsWith("/") ? dir2.substring(1) : dir2;
-        return path24.join(dirWithoutLeadingSlash, this.pathInfo.name());
+        return path23.join(dirWithoutLeadingSlash, this.pathInfo.name());
       }
       section() {
         return this.pathInfo.section();
@@ -21837,7 +21836,7 @@ var init_fileinfo2 = __esm({
         if (s2 === "") {
           return s2;
         }
-        return path24.normalize(s2.substring(1) + "/");
+        return path23.normalize(s2.substring(1) + "/");
       }
       determineBundleType() {
         const isContent = isContentExt(this.pathInfo.ext());
@@ -22117,7 +22116,7 @@ function getParam(p2, key2, stringToLower) {
       return v;
   }
 }
-var import_path17, FrontMatterParserImpl;
+var import_path16, FrontMatterParserImpl;
 var init_frontmatter = __esm({
   "internal/domain/content/vo/frontmatter.ts"() {
     "use strict";
@@ -22125,7 +22124,7 @@ var init_frontmatter = __esm({
     init_cast2();
     init_string2();
     init_types3();
-    import_path17 = __toESM(require("path"));
+    import_path16 = __toESM(require("path"));
     FrontMatterParserImpl = class {
       params;
       langSvc;
@@ -22312,7 +22311,7 @@ var init_frontmatter = __esm({
           organization.website = Cast.toString(orgValue.website);
         }
         if (orgValue.logo !== void 0 && orgValue.logo !== null) {
-          organization.logo = import_path17.default.join(baseURL, Cast.toString(orgValue.logo));
+          organization.logo = import_path16.default.join(baseURL, Cast.toString(orgValue.logo));
         }
         const contact = this.parseContact(orgValue.contact);
         if (contact) {
@@ -22430,7 +22429,7 @@ var init_frontmatter = __esm({
           author.website = Cast.toString(authorValue.website);
         }
         if (authorValue.avatar !== void 0 && authorValue.avatar !== null) {
-          author.avatar = import_path17.default.join(baseURL, Cast.toString(authorValue.avatar));
+          author.avatar = import_path16.default.join(baseURL, Cast.toString(authorValue.avatar));
         }
         const contact = this.parseContact(authorValue.contact);
         if (contact) {
@@ -22486,8 +22485,8 @@ var init_frontmatter = __esm({
        * Convert path to slash preserving leading slash
        * Equivalent to Go's paths.ToSlashPreserveLeading
        */
-      toSlashPreserveLeading(path40) {
-        return path40.replace(/\\/g, "/");
+      toSlashPreserveLeading(path39) {
+        return path39.replace(/\\/g, "/");
       }
     };
   }
@@ -22912,9 +22911,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(path40, fn) {
+      async walkPath(path39, fn) {
         let n = this.root;
-        let search2 = path40;
+        let search2 = path39;
         while (true) {
           if (n.leaf !== null && await fn(n.leaf.key, n.leaf.val)) {
             return;
@@ -24049,8 +24048,8 @@ var init_pagesource = __esm({
        * 3. Handle index files (index → parent folder)
        * 4. Handle _index files (Hugo-style section index)
        */
-      pathToSlug(path40) {
-        let slug2 = path40.replace(/^\//, "");
+      pathToSlug(path39) {
+        let slug2 = path39.replace(/^\//, "");
         slug2 = slug2.replace(/\.md$/, "");
         if (slug2.endsWith("/index")) {
           slug2 = slug2.replace(/\/index$/, "");
@@ -24097,17 +24096,17 @@ var init_pagesource = __esm({
 });
 
 // internal/domain/content/entity/pagemap.ts
-function addTrailingSlash(path40) {
-  if (!path40.endsWith("/")) {
-    path40 += "/";
+function addTrailingSlash(path39) {
+  if (!path39.endsWith("/")) {
+    path39 += "/";
   }
-  return path40;
+  return path39;
 }
-function addLeadingSlash(path40) {
-  if (!path40.startsWith("/")) {
-    path40 = "/" + path40;
+function addLeadingSlash(path39) {
+  if (!path39.startsWith("/")) {
+    path39 = "/" + path39;
   }
-  return path40;
+  return path39;
 }
 var log43, ambiguousContentNode, ContentTreeReverseIndexMap, ContentTreeReverseIndex, pagePredicates, PageMapQueryPagesBelowPathImpl, PageMapQueryPagesInSectionImpl, PageMap;
 var init_pagemap = __esm({
@@ -24160,8 +24159,8 @@ var init_pagemap = __esm({
       path;
       keyPart;
       include;
-      constructor(path40, keyPart, include = pagePredicates.shouldListLocal) {
-        this.path = path40;
+      constructor(path39, keyPart, include = pagePredicates.shouldListLocal) {
+        this.path = path39;
         this.keyPart = keyPart;
         this.include = include;
       }
@@ -24173,8 +24172,8 @@ var init_pagemap = __esm({
       recursive;
       includeSelf;
       index;
-      constructor(path40, keyPart, recursive, includeSelf, index2, include) {
-        super(path40, keyPart, include);
+      constructor(path39, keyPart, recursive, includeSelf, index2, include) {
+        super(path39, keyPart, include);
         this.recursive = recursive;
         this.includeSelf = includeSelf;
         this.index = index2;
@@ -24542,12 +24541,12 @@ var init_pagemap = __esm({
       /**
        * Helper method to get directory from path
        */
-      pathDir(path40) {
-        const lastSlash = path40.lastIndexOf("/");
+      pathDir(path39) {
+        const lastSlash = path39.lastIndexOf("/");
         if (lastSlash === -1) {
           return "";
         }
-        return path40.substring(0, lastSlash);
+        return path39.substring(0, lastSlash);
       }
     };
   }
@@ -24586,11 +24585,11 @@ var init_pagecollector = __esm({
       /**
        * CollectDir - exact replica of Go's collectDir method
        */
-      async collectDir(fs13, path40, root2) {
+      async collectDir(fs13, path39, root2) {
         try {
-          await this.fs.walkContent(fs13, path40, {
-            hookPre: async (dir2, path41, readdir2) => {
-              const fullPath = path41;
+          await this.fs.walkContent(fs13, path39, {
+            hookPre: async (dir2, path40, readdir2) => {
+              const fullPath = path40;
               if (this.processedPaths.has(fullPath)) {
                 log44.warn("Path already processed!", {
                   path: fullPath,
@@ -24621,7 +24620,7 @@ var init_pagecollector = __esm({
           });
         } catch (error) {
           log44.error(`Failed to collect directory: ${error}`, {
-            path: path40,
+            path: path39,
             rootName: root2.name(),
             rootIsDir: root2.isDir(),
             stack: error.stack || "No stack trace available"
@@ -24631,7 +24630,7 @@ var init_pagecollector = __esm({
       }
       async handleBundleLeaf(dir2, bundle, inPath, readdir2) {
         const bundlePath = bundle.paths();
-        const walk = async (path40, info) => {
+        const walk = async (path39, info) => {
           if (info.isDir()) {
             return;
           }
@@ -24883,10 +24882,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, path40) {
+      getPageFromPath(langIndex, path39) {
         try {
           const pathProcessor = PathDomain.createProcessor();
-          const ps = pathProcessor.parse(PATH_CONSTANTS.COMPONENT_FOLDER_CONTENT, path40);
+          const ps = pathProcessor.parse(PATH_CONSTANTS.COMPONENT_FOLDER_CONTENT, path39);
           const tree = this.pageMap.treePages.shape(0, langIndex);
           let node = tree.get(ps.base());
           if (node) {
@@ -24897,7 +24896,7 @@ var init_content2 = __esm({
           }
           return null;
         } catch (error) {
-          log45.error(`\u274C Content.getPageFromPath error for path "${path40}":`, error);
+          log45.error(`\u274C Content.getPageFromPath error for path "${path39}":`, error);
           return null;
         }
       }
@@ -25704,15 +25703,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, path40) {
-  if (!root2 || path40.startsWith(root2)) {
-    return path40;
+function addContextRoot(root2, path39) {
+  if (!root2 || path39.startsWith(root2)) {
+    return path39;
   }
-  return joinPaths(root2, path40);
+  return joinPaths(root2, path39);
 }
-function makePermalink(baseURL, path40) {
+function makePermalink(baseURL, path39) {
   const base2 = baseURL.replace(/\/$/, "");
-  const cleanPath = path40.replace(/^\//, "");
+  const cleanPath = path39.replace(/^\//, "");
   const fullURL = `${base2}/${cleanPath}`;
   try {
     return new URL(fullURL);
@@ -25741,7 +25740,7 @@ var init_paths2 = __esm({
 });
 
 // internal/domain/content/entity/page.ts
-var import_path18, log48, PageImpl, TaxonomyPageImpl, TermPageImpl;
+var import_path17, log48, PageImpl, TaxonomyPageImpl, TermPageImpl;
 var init_page = __esm({
   "internal/domain/content/entity/page.ts"() {
     "use strict";
@@ -25753,7 +25752,7 @@ var init_page = __esm({
     init_paths2();
     init_doctree();
     init_sort();
-    import_path18 = __toESM(require("path"));
+    import_path17 = __toESM(require("path"));
     init_log();
     log48 = getDomainLogger("content", { component: "page" });
     PageImpl = class {
@@ -25831,8 +25830,8 @@ var init_page = __esm({
        * 3. Handle index files (index → parent folder)
        * 4. Handle _index files (Hugo-style section index)
        */
-      pathToSlug(path40) {
-        let slug2 = path40.replace(/^\//, "");
+      pathToSlug(path39) {
+        let slug2 = path39.replace(/^\//, "");
         slug2 = slug2.replace(/\.md$/, "");
         if (slug2.endsWith("/index")) {
           slug2 = slug2.replace(/\/index$/, "");
@@ -25859,7 +25858,7 @@ var init_page = __esm({
         if (/^(https?:)?\/\//.test(src)) {
           return src;
         }
-        src = import_path18.default.normalize(src);
+        src = import_path17.default.normalize(src);
         src = src.replace(/\\/g, "/");
         if (src.startsWith("/")) {
           src = src.slice(1);
@@ -26579,12 +26578,12 @@ var init_type11 = __esm({
 function newBaseOf() {
   return new BaseOf();
 }
-var path27, BaseOf;
+var path26, BaseOf;
 var init_baseof = __esm({
   "internal/domain/template/vo/baseof.ts"() {
     "use strict";
     init_type11();
-    path27 = __toESM(require("path"));
+    path26 = __toESM(require("path"));
     BaseOf = class {
       baseof = /* @__PURE__ */ new Map();
       needsBaseof = /* @__PURE__ */ new Map();
@@ -26624,7 +26623,7 @@ var init_baseof = __esm({
        * Check if path is a base template path
        */
       isBaseTemplatePath(filePath) {
-        return path27.basename(filePath).includes(BASE_FILE_BASE);
+        return path26.basename(filePath).includes(BASE_FILE_BASE);
       }
       /**
        * Check if template needs base template
@@ -28379,8 +28378,8 @@ var init_registry = __esm({
             }
           },
           // PathEscape escapes special characters in a URL path
-          PathEscape: (path40) => {
-            return encodeURIComponent(path40).replace(/%2F/g, "/").replace(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+          PathEscape: (path39) => {
+            return encodeURIComponent(path39).replace(/%2F/g, "/").replace(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
           },
           // QueryEscape escapes special characters in a URL query
           QueryEscape: (query) => {
@@ -29536,11 +29535,11 @@ var init_registry = __esm({
               }
             }
           }
-          const getNestedValue = (obj, path40) => {
-            if (!path40 || path40 === "value") {
+          const getNestedValue = (obj, path39) => {
+            if (!path39 || path39 === "value") {
               return obj;
             }
-            const keys = path40.split(".");
+            const keys = path39.split(".");
             let current = obj;
             for (const key2 of keys) {
               if (current === null || current === void 0) {
@@ -30105,23 +30104,23 @@ var init_registry = __esm({
       registerPathFunctions(funcMap) {
         funcMap.set("path", () => ({
           // Base returns the last element of path
-          Base: (path40) => {
-            if (!path40)
+          Base: (path39) => {
+            if (!path39)
               return ".";
-            path40 = path40.replace(/\\/g, "/");
-            path40 = path40.replace(/\/+$/, "");
-            if (!path40)
+            path39 = path39.replace(/\\/g, "/");
+            path39 = path39.replace(/\/+$/, "");
+            if (!path39)
               return "/";
-            const parts = path40.split("/");
+            const parts = path39.split("/");
             return parts[parts.length - 1] || "/";
           },
           // Clean returns the shortest path name equivalent to path
-          Clean: (path40) => {
-            if (!path40)
+          Clean: (path39) => {
+            if (!path39)
               return ".";
-            path40 = path40.replace(/\\/g, "/");
-            const isAbs = path40.startsWith("/");
-            const parts = path40.split("/").filter((p2) => p2 && p2 !== ".");
+            path39 = path39.replace(/\\/g, "/");
+            const isAbs = path39.startsWith("/");
+            const parts = path39.split("/").filter((p2) => p2 && p2 !== ".");
             const stack = [];
             for (const part of parts) {
               if (part === "..") {
@@ -30134,56 +30133,56 @@ var init_registry = __esm({
                 stack.push(part);
               }
             }
-            path40 = stack.join("/");
+            path39 = stack.join("/");
             if (isAbs)
-              path40 = "/" + path40;
-            return path40 || (isAbs ? "/" : ".");
+              path39 = "/" + path39;
+            return path39 || (isAbs ? "/" : ".");
           },
           // Dir returns all but the last element of path
-          Dir: (path40) => {
-            if (!path40)
+          Dir: (path39) => {
+            if (!path39)
               return ".";
-            path40 = path40.replace(/\/+$/, "");
-            if (!path40)
+            path39 = path39.replace(/\/+$/, "");
+            if (!path39)
               return "/";
-            const parts = path40.split("/");
+            const parts = path39.split("/");
             parts.pop();
             return parts.join("/") || ".";
           },
           // Ext returns the file name extension
-          Ext: (path40) => {
-            const base2 = path40.split("/").pop() || "";
+          Ext: (path39) => {
+            const base2 = path39.split("/").pop() || "";
             const dot = base2.lastIndexOf(".");
             if (dot === -1 || dot === 0)
               return "";
             return base2.substring(dot);
           },
           // IsAbs reports whether the path is absolute
-          IsAbs: (path40) => {
-            return path40.startsWith("/");
+          IsAbs: (path39) => {
+            return path39.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 path40 = parts.join("/");
+            let path39 = parts.join("/");
             if (elements[0] && elements[0].startsWith("/")) {
-              path40 = "/" + path40;
+              path39 = "/" + path39;
             }
-            return path40 || ".";
+            return path39 || ".";
           },
           // Split splits path immediately following the final slash
-          Split: (path40) => {
-            if (!path40)
+          Split: (path39) => {
+            if (!path39)
               return [".", ""];
-            const lastSlash = path40.lastIndexOf("/");
+            const lastSlash = path39.lastIndexOf("/");
             if (lastSlash === -1) {
-              return ["", path40];
+              return ["", path39];
             }
             return [
-              path40.substring(0, lastSlash),
-              path40.substring(lastSlash + 1)
+              path39.substring(0, lastSlash),
+              path39.substring(lastSlash + 1)
             ];
           }
         }));
@@ -30469,11 +30468,11 @@ var init_registry = __esm({
        * Get nested value from object using dot notation path
        * Following golang's path resolution logic
        */
-      getNestedValue(obj, path40) {
-        if (!obj || !path40) {
+      getNestedValue(obj, path39) {
+        if (!obj || !path39) {
           return void 0;
         }
-        const cleanPath = path40.replace(/^\\.+/, "");
+        const cleanPath = path39.replace(/^\\.+/, "");
         const parts = cleanPath.split(".");
         let current = obj;
         for (let i = 0; i < parts.length; i++) {
@@ -31008,14 +31007,14 @@ var init_pagebuilder = __esm({
        * Parse kind - exact replica of Go's parseKind method
        */
       async parseKind() {
-        const path40 = this.source.file.paths();
+        const path39 = this.source.file.paths();
         let kind = "";
         if (this.fm) {
           kind = this.fm.kind || "";
         }
         if (kind === "") {
           kind = getKindMain("page");
-          const base2 = path40.baseNoLeadingSlash();
+          const base2 = path39.baseNoLeadingSlash();
           switch (base2) {
             case PAGE_HOME_BASE:
             case "":
@@ -31030,9 +31029,9 @@ var init_pagebuilder = __esm({
             default:
               if (this.source.file.isBranchBundle()) {
                 kind = getKindMain("section");
-                const v = this.taxonomy.getTaxonomy(path40.path());
+                const v = this.taxonomy.getTaxonomy(path39.path());
                 if (!this.taxonomy.isZero(v)) {
-                  if (this.taxonomy.isTaxonomyPath(path40.path())) {
+                  if (this.taxonomy.isTaxonomyPath(path39.path())) {
                     kind = getKindMain("taxonomy");
                   } else {
                     kind = getKindMain("term");
@@ -31319,7 +31318,7 @@ function cleanTreeKey2(...elem) {
   if (elem.length > 0) {
     s2 = elem[0];
     if (elem.length > 1) {
-      s2 = path28.join(...elem);
+      s2 = path27.join(...elem);
     }
   }
   s2 = s2.replace(/^[\.\/ \s]+|[\.\/ \s]+$/g, "");
@@ -31332,14 +31331,14 @@ function cleanTreeKey2(...elem) {
   }
   return s2;
 }
-var path28, filepath, Taxonomy2;
+var path27, filepath, Taxonomy2;
 var init_taxonomy3 = __esm({
   "internal/domain/content/entity/taxonomy.ts"() {
     "use strict";
     init_pagetrees();
     init_fileinfo2();
     init_pagesource();
-    path28 = __toESM(require("path"));
+    path27 = __toESM(require("path"));
     filepath = __toESM(require("path"));
     Taxonomy2 = class {
       views;
@@ -31370,7 +31369,7 @@ var init_taxonomy3 = __esm({
         if (!ta) {
           return false;
         }
-        return p2 === path28.join(this.pluralTreeKey(ta.plural()), "_index.md");
+        return p2 === path27.join(this.pluralTreeKey(ta.plural()), "_index.md");
       }
       /**
        * PluralTreeKey - exact replica of Go's PluralTreeKey method
@@ -31675,11 +31674,11 @@ var init_pager = __esm({
 });
 
 // internal/domain/site/entity/page.ts
-var import_path19, log57, Page2;
+var import_path18, log57, Page2;
 var init_page2 = __esm({
   "internal/domain/site/entity/page.ts"() {
     "use strict";
-    import_path19 = __toESM(require("path"));
+    import_path18 = __toESM(require("path"));
     init_log();
     init_pager();
     log57 = getDomainLogger("site", { component: "page" });
@@ -31799,14 +31798,14 @@ var init_page2 = __esm({
         } else {
           prefix = this.site.getLanguage().getCurrentLanguage();
         }
-        targetFilenames.push(import_path19.default.join(prefix, this.getPageOutput().targetFilePath()));
+        targetFilenames.push(import_path18.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_path19.default.join(prefix, currentPager.url(), this.getPageOutput().targetFileBase())];
+            const paginationTargets = [import_path18.default.join(prefix, currentPager.url(), this.getPageOutput().targetFileBase())];
             await this.renderAndWritePage(tmpl, paginationTargets);
             currentPager = currentPager.next();
           }
@@ -31839,7 +31838,7 @@ var init_page2 = __esm({
             prefix = this.site.getLanguage().getCurrentLanguage();
           }
           let resourcePath = pageSource.path();
-          targetFilenames.push(import_path19.default.join(prefix, resourcePath));
+          targetFilenames.push(import_path18.default.join(prefix, resourcePath));
           let stream = null;
           try {
             const opener = () => pageSource.pageFile().open();
@@ -32494,11 +32493,11 @@ var init_baseurl = __esm({
       /**
        * Returns the appropriate root URL based on the path.
        */
-      getRoot(path40) {
+      getRoot(path39) {
         if (this.isRelative) {
           return this.basePath;
         }
-        if (path40.startsWith("/")) {
+        if (path39.startsWith("/")) {
           return this.withoutPath;
         }
         return this.withPath;
@@ -33892,8 +33891,8 @@ function assertNonEmpty(part, name) {
     throw new Error("`" + name + "` cannot be empty");
   }
 }
-function assertPath(path40, name) {
-  if (!path40) {
+function assertPath(path39, name) {
+  if (!path39) {
     throw new Error("Setting `" + name + "` requires `path` to be set too");
   }
 }
@@ -34078,13 +34077,13 @@ var init_lib4 = __esm({
        * @returns {undefined}
        *   Nothing.
        */
-      set path(path40) {
-        if (isUrl(path40)) {
-          path40 = (0, import_node_url.fileURLToPath)(path40);
+      set path(path39) {
+        if (isUrl(path39)) {
+          path39 = (0, import_node_url.fileURLToPath)(path39);
         }
-        assertNonEmpty(path40, "path");
-        if (this.path !== path40) {
-          this.history.push(path40);
+        assertNonEmpty(path39, "path");
+        if (this.path !== path39) {
+          this.history.push(path39);
         }
       }
       /**
@@ -46845,7 +46844,7 @@ var init_is_absolute_url = __esm({
 function createHtmlLinkProcessor(graph, options) {
   return new HtmlLinkProcessor(graph, options);
 }
-var import_path21, log61, defaultOptions, HtmlLinkProcessor;
+var import_path20, log61, defaultOptions, HtmlLinkProcessor;
 var init_html_link_processor = __esm({
   "internal/domain/site/service/html-link-processor.ts"() {
     "use strict";
@@ -46854,7 +46853,7 @@ var init_html_link_processor = __esm({
     init_rehype_stringify();
     init_unist_util_visit();
     init_is_absolute_url();
-    import_path21 = __toESM(require("path"));
+    import_path20 = __toESM(require("path"));
     init_path3();
     init_log();
     log61 = getDomainLogger("site", { component: "HtmlLinkProcessor" });
@@ -46992,7 +46991,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_path21.default.basename(node.children[0].value);
+                node.children[0].value = import_path20.default.basename(node.children[0].value);
               }
             }
             if (["img", "video", "audio", "iframe"].includes(node.tagName) && node.properties && typeof node.properties.src === "string") {
@@ -47886,14 +47885,14 @@ var init_site = __esm({
 
 // internal/domain/site/entity/publisher.ts
 async function openFileForWriting(fs13, filename) {
-  const cleanFilename = import_path23.default.normalize(filename);
+  const cleanFilename = import_path22.default.normalize(filename);
   try {
     return await fs13.create(cleanFilename);
   } catch (error) {
     if (!isFileNotFoundError(error)) {
       throw error;
     }
-    const dir2 = import_path23.default.dirname(cleanFilename);
+    const dir2 = import_path22.default.dirname(cleanFilename);
     await fs13.mkdirAll(dir2, 511);
     return await fs13.create(cleanFilename);
   }
@@ -47901,11 +47900,11 @@ async function openFileForWriting(fs13, filename) {
 function isFileNotFoundError(error) {
   return error && (error.code === "ENOENT" || error.code === "FILE_NOT_FOUND" || error.message?.includes("not found") || error.message?.includes("no such file"));
 }
-var import_path23, log64, Publisher, MultiWriter;
+var import_path22, log64, Publisher, MultiWriter;
 var init_publisher2 = __esm({
   "internal/domain/site/entity/publisher.ts"() {
     "use strict";
-    import_path23 = __toESM(require("path"));
+    import_path22 = __toESM(require("path"));
     init_log();
     log64 = getDomainLogger("site", { component: "publisher" });
     Publisher = class {
@@ -48766,8 +48765,8 @@ var init_menu_builder = __esm({
       /**
        * Fallback URL generation from path (used when site page conversion fails)
        */
-      fallbackUrlFromPath(path40) {
-        let url = path40.replace(/\.md$/, "");
+      fallbackUrlFromPath(path39) {
+        let url = path39.replace(/\.md$/, "");
         if (!url.startsWith("/")) {
           url = "/" + url;
         }
@@ -49690,11 +49689,11 @@ var init_template4 = __esm({
 });
 
 // internal/domain/resources/entity/publisher.ts
-var path32, import_stream2, log73, Publisher2, FileWritable;
+var path31, import_stream2, log73, Publisher2, FileWritable;
 var init_publisher3 = __esm({
   "internal/domain/resources/entity/publisher.ts"() {
     "use strict";
-    path32 = __toESM(require("path"));
+    path31 = __toESM(require("path"));
     init_log();
     import_stream2 = require("stream");
     log73 = getDomainLogger("resources", { component: "publisher" });
@@ -49729,7 +49728,7 @@ var init_publisher3 = __esm({
           return new FileWritable(file);
         } catch (error) {
           if (error.code === "ENOENT" || error.message.includes("ENOENT")) {
-            const dir2 = path32.dirname(cleanFilename);
+            const dir2 = path31.dirname(cleanFilename);
             await this.pubFs.mkdirAll(dir2, 511);
             const file = await this.pubFs.create(cleanFilename);
             const originalClose = file.close.bind(file);
@@ -49763,14 +49762,14 @@ var init_publisher3 = __esm({
        * TypeScript equivalent of OpenFileForWriting function from Go
        */
       async openFileForWriting(filename) {
-        const cleanFilename = path32.normalize(filename);
+        const cleanFilename = path31.normalize(filename);
         try {
           return await this.pubFs.create(cleanFilename);
         } catch (error) {
           if (!this.isFileNotFoundError(error)) {
             throw error;
           }
-          const dir2 = path32.dirname(cleanFilename);
+          const dir2 = path31.dirname(cleanFilename);
           await this.pubFs.mkdirAll(dir2, 511);
           return await this.pubFs.create(cleanFilename);
         }
@@ -49898,7 +49897,7 @@ var init_http2 = __esm({
 });
 
 // internal/domain/resources/entity/resources.ts
-var path33, import_crypto4, log75, Resources;
+var path32, import_crypto4, log75, Resources;
 var init_resources = __esm({
   "internal/domain/resources/entity/resources.ts"() {
     "use strict";
@@ -49910,7 +49909,7 @@ var init_resources = __esm({
     init_publisher3();
     init_http2();
     init_type9();
-    path33 = __toESM(require("path"));
+    path32 = __toESM(require("path"));
     import_crypto4 = require("crypto");
     init_log();
     log75 = getDomainLogger("resources", { component: "resources" });
@@ -49945,7 +49944,7 @@ var init_resources = __esm({
        * Supports caching for performance optimization
        */
       async getResource(pathname) {
-        const cleanPath = path33.posix.normalize(pathname);
+        const cleanPath = path32.posix.normalize(pathname);
         const cacheKey = `${cleanPath}__get`;
         if (this.cache.has(cacheKey)) {
           return this.cache.get(cacheKey) || null;
@@ -49974,7 +49973,7 @@ var init_resources = __esm({
        * GetResourceWithOpener - Alternative way to get resource with custom opener
        */
       async getResourceWithOpener(pathname, opener) {
-        const cleanPath = path33.posix.normalize(pathname);
+        const cleanPath = path32.posix.normalize(pathname);
         const cacheKey = `${cleanPath}__get_with_opener`;
         if (this.cache.has(cacheKey)) {
           return this.cache.get(cacheKey) || null;
@@ -50112,7 +50111,7 @@ var init_resources = __esm({
        */
       async buildResource(pathname, opener) {
         try {
-          const ext = path33.extname(pathname);
+          const ext = path32.extname(pathname);
           const mediaType = this.getMediaTypeFromExtension(ext);
           const resourcePaths = ResourcePaths.newResourcePaths(pathname, this.workspace);
           const resource = new ResourceImpl(
@@ -50214,11 +50213,11 @@ var init_resources = __esm({
 });
 
 // internal/domain/resources/valueobject/resourcepaths.ts
-var path34, ResourcePaths;
+var path33, ResourcePaths;
 var init_resourcepaths = __esm({
   "internal/domain/resources/valueobject/resourcepaths.ts"() {
     "use strict";
-    path34 = __toESM(require("path"));
+    path33 = __toESM(require("path"));
     ResourcePaths = class _ResourcePaths {
       // This is the directory component for the target file or link.
       dir;
@@ -50241,7 +50240,7 @@ var init_resourcepaths = __esm({
       }
       static newResourcePaths(targetPath, svc) {
         const normalizedPath = targetPath.replace(/\\/g, "/");
-        const parsedPath = path34.posix.parse(normalizedPath);
+        const parsedPath = path33.posix.parse(normalizedPath);
         let dir2 = parsedPath.dir;
         if (dir2 === "/") {
           dir2 = "";
@@ -50298,7 +50297,7 @@ var init_resourcepaths = __esm({
       }
       fromTargetPath(targetPath) {
         const normalizedPath = targetPath.replace(/\\/g, "/");
-        const parsedPath = path34.posix.parse(normalizedPath);
+        const parsedPath = path33.posix.parse(normalizedPath);
         let dir2 = parsedPath.dir;
         if (dir2 === "/") {
           dir2 = "";
@@ -50444,7 +50443,7 @@ function getDomainInstances() {
 }
 async function loadConfiguration(projDir, modulesDir) {
   const osFs = newOsFs();
-  const configFilePath = import_path24.default.join(projDir, "config.json");
+  const configFilePath = import_path23.default.join(projDir, "config.json");
   return await loadConfigWithParams(osFs, configFilePath, projDir, modulesDir);
 }
 async function createModule(config) {
@@ -50690,11 +50689,11 @@ function createSiteForSSG(config, fs13, content) {
     searchPage: async (pages, page) => {
       return [];
     },
-    getPageFromPath: async (langIndex, path40) => {
+    getPageFromPath: async (langIndex, path39) => {
       try {
-        const page = content.getPageFromPath(langIndex, path40);
+        const page = content.getPageFromPath(langIndex, path39);
         if (!page) {
-          log76.error(`\u26A0\uFE0F  Application.getPageFromPath: content domain returned null for path: "${path40}"`);
+          log76.error(`\u26A0\uFE0F  Application.getPageFromPath: content domain returned null for path: "${path39}"`);
         }
         return page;
       } catch (error) {
@@ -50702,11 +50701,11 @@ function createSiteForSSG(config, fs13, content) {
         return null;
       }
     },
-    getPageFromPathSync: (langIndex, path40) => {
+    getPageFromPathSync: (langIndex, path39) => {
       try {
-        const page = content.getPageFromPath(langIndex, path40);
+        const page = content.getPageFromPath(langIndex, path39);
         if (!page) {
-          log76.warn(`\u26A0\uFE0F  Application.getPageFromPathSync: content domain returned null for path: ${path40}`);
+          log76.warn(`\u26A0\uFE0F  Application.getPageFromPathSync: content domain returned null for path: ${path39}`);
         }
         return page;
       } catch (error) {
@@ -50741,14 +50740,14 @@ function createSiteForSSG(config, fs13, content) {
     },
     workingDir: () => config.getProvider().getString("workingDir") || process.cwd(),
     // ResourceService implementation (placeholder)
-    getResource: async (path40) => {
+    getResource: async (path39) => {
       return null;
     },
-    getResourceWithOpener: async (path40, opener) => {
+    getResourceWithOpener: async (path39, opener) => {
       return {
-        name: () => path40,
+        name: () => path39,
         readSeekCloser: opener,
-        targetPath: () => path40
+        targetPath: () => path39
       };
     },
     // URLService implementation
@@ -51027,7 +51026,7 @@ async function collectAllPageTasks(projDir, modulesDir, markdown, onProgress, ht
     throw new Error(`Failed to generate static site: ${message}`);
   }
 }
-var import_path24, log76, configCache, modulesCache, fsCache, contentCache, resourcesCache, templateEngineCache, siteCache, createDomainInstances, tasks;
+var import_path23, log76, configCache, modulesCache, fsCache, contentCache, resourcesCache, templateEngineCache, siteCache, createDomainInstances, tasks;
 var init_ssg = __esm({
   "internal/application/ssg.ts"() {
     "use strict";
@@ -51038,7 +51037,7 @@ var init_ssg = __esm({
     init_template3();
     init_site2();
     init_log();
-    import_path24 = __toESM(require("path"));
+    import_path23 = __toESM(require("path"));
     init_resources2();
     log76 = getDomainLogger("ssg", { component: "application" });
     createDomainInstances = (site, content, fs13, config, modules, resources) => {
@@ -51774,8 +51773,8 @@ var WorkerPoolManager = class {
    * 初始化 Node.js Worker 池
    */
   async initializeNodePool() {
-    const path40 = require("path");
-    const workerPath = path40.join(__dirname, "worker", "worker-node.js");
+    const path39 = require("path");
+    const workerPath = path39.join(__dirname, "worker", "worker-node.js");
     log79.debug(`Initializing Node.js worker pool with path: ${workerPath}`);
     this.pool = workerpool.pool(workerPath, {
       minWorkers: this.workerCount,
@@ -52102,7 +52101,7 @@ async function processSSGParallel(projDir, modulesDir, markdown, onProgress, htt
 
 // internal/interfaces/cli/commands/build.ts
 init_log();
-var import_path25 = __toESM(require("path"));
+var import_path24 = __toESM(require("path"));
 var import_fs14 = require("fs");
 var log82 = getDomainLogger("build-command", { component: "cli" });
 var BuildCommand = class {
@@ -52129,7 +52128,7 @@ var BuildCommand = class {
       await project.loadConfig();
       const projectRoot = project.getPath();
       const modulesDir = options.modulesDir || workspace.getModulesDir();
-      const outputDir = options.destination ? import_path25.default.resolve(projectRoot, options.destination) : await project.getPublishDir();
+      const outputDir = options.destination ? import_path24.default.resolve(projectRoot, options.destination) : await project.getPublishDir();
       if (options.clean) {
         await this.cleanOutputDir(outputDir);
         log82.info(`Cleaned output directory: ${outputDir}`);
@@ -52138,7 +52137,7 @@ var BuildCommand = class {
       let contentDirs = await project.getContentDirs();
       if (options.contentDirs && options.contentDirs.length > 0) {
         const extraDirs = options.contentDirs.map(
-          (dir2) => import_path25.default.resolve(projectRoot, dir2)
+          (dir2) => import_path24.default.resolve(projectRoot, dir2)
         );
         contentDirs = [...contentDirs, ...extraDirs];
         log82.info(`Added extra content directories: ${options.contentDirs.join(", ")}`);
@@ -52228,7 +52227,7 @@ var BuildCommand = class {
       const entries = await import_fs14.promises.readdir(outputDir);
       await Promise.all(
         entries.map(
-          (entry) => import_fs14.promises.rm(import_path25.default.join(outputDir, entry), { recursive: true, force: true })
+          (entry) => import_fs14.promises.rm(import_path24.default.join(outputDir, entry), { recursive: true, force: true })
         )
       );
     } catch (error) {
@@ -52245,7 +52244,7 @@ init_log();
 
 // pkg/web/watcher/content-file-watcher.ts
 var chokidar = __toESM(require("chokidar"));
-var path37 = __toESM(require("path"));
+var path36 = __toESM(require("path"));
 var fs10 = __toESM(require("fs"));
 init_log();
 var log83 = getDomainLogger("web", { component: "content-file-watcher" });
@@ -52282,7 +52281,7 @@ var ContentFileWatcher = class {
         const stats = fs10.statSync(p2);
         return stats.isFile();
       } catch {
-        const ext = path37.extname(p2).toLowerCase();
+        const ext = path36.extname(p2).toLowerCase();
         return ext === ".md" || ext === ".markdown";
       }
     });
@@ -52324,11 +52323,11 @@ var ContentFileWatcher = class {
     let fp = filePath;
     if (this.isSingleFileMode) {
       const matchedIndex = this.config.contentDirs.findIndex((contentFile) => {
-        return path37.normalize(filePath) === path37.normalize(contentFile);
+        return path36.normalize(filePath) === path36.normalize(contentFile);
       });
       if (matchedIndex !== -1) {
         const projContentDir = this.config.projContentDirs[matchedIndex];
-        fp = path37.join(projContentDir, "index.md");
+        fp = path36.join(projContentDir, "index.md");
         log83.debug("Single file event mapped", {
           original: filePath,
           mapped: fp
@@ -52349,7 +52348,7 @@ var ContentFileWatcher = class {
         }
       }
     }
-    const normalizedPath = path37.normalize(fp);
+    const normalizedPath = path36.normalize(fp);
     if (!this.isRelevantFile(normalizedPath)) {
       return;
     }
@@ -52367,11 +52366,11 @@ var ContentFileWatcher = class {
     return this.isMarkdownFile(filePath) || this.isImageFile(filePath);
   }
   isMarkdownFile(filePath) {
-    const ext = path37.extname(filePath).toLowerCase();
+    const ext = path36.extname(filePath).toLowerCase();
     return ext === ".md" || ext === ".markdown";
   }
   isImageFile(filePath) {
-    const ext = path37.extname(filePath).toLowerCase();
+    const ext = path36.extname(filePath).toLowerCase();
     return [".jpg", ".jpeg", ".png", ".gif", ".svg", ".webp", ".bmp"].includes(ext);
   }
   scheduleBatch() {
@@ -52418,7 +52417,7 @@ var ContentFileWatcher = class {
 
 // pkg/web/server/livereload-server.ts
 var http3 = __toESM(require("http"));
-var path38 = __toESM(require("path"));
+var path37 = __toESM(require("path"));
 var fs11 = __toESM(require("fs/promises"));
 var import_ws = require("ws");
 init_log();
@@ -52489,7 +52488,7 @@ var FoundryLiveReloadServer = class {
     };
     if (changedFiles && changedFiles.length === 1) {
       const file = changedFiles[0];
-      const ext = path38.extname(file).toLowerCase();
+      const ext = path37.extname(file).toLowerCase();
       if (ext === ".css") {
         reloadEvent.path = file;
         reloadEvent.liveCSS = true;
@@ -52573,7 +52572,7 @@ var FoundryLiveReloadServer = class {
     try {
       const stats = await fs11.stat(filePath);
       if (stats.isDirectory()) {
-        const indexPath = path38.join(filePath, "index.html");
+        const indexPath = path37.join(filePath, "index.html");
         try {
           await fs11.stat(indexPath);
           filePath = indexPath;
@@ -52619,9 +52618,9 @@ var FoundryLiveReloadServer = class {
       log84.warn("Failed to decode URL:", cleanUrl, error);
       decodedUrl = cleanUrl;
     }
-    const normalizedPath = path38.normalize(decodedUrl).replace(/^(\.\.[\/\\])+/, "");
+    const normalizedPath = path37.normalize(decodedUrl).replace(/^(\.\.[\/\\])+/, "");
     const relativePath = normalizedPath.startsWith("/") ? normalizedPath.slice(1) : normalizedPath;
-    const resolvedPath = path38.join(this.config.publicDir, relativePath);
+    const resolvedPath = path37.join(this.config.publicDir, relativePath);
     if (process.platform === "win32" && resolvedPath.length > 260) {
       log84.warn("Path too long for Windows filesystem:", resolvedPath);
     }
@@ -52634,7 +52633,7 @@ var FoundryLiveReloadServer = class {
     return resolvedPath;
   }
   getContentType(filePath) {
-    const ext = path38.extname(filePath).toLowerCase();
+    const ext = path37.extname(filePath).toLowerCase();
     const mimeTypes = {
       ".html": "text/html; charset=utf-8",
       ".css": "text/css; charset=utf-8",
@@ -52728,19 +52727,19 @@ var FoundryLiveReloadServer = class {
   shouldLiveReloadCSS(changedFiles) {
     if (!changedFiles)
       return false;
-    return changedFiles.some((file) => path38.extname(file).toLowerCase() === ".css");
+    return changedFiles.some((file) => path37.extname(file).toLowerCase() === ".css");
   }
   shouldLiveReloadImages(changedFiles) {
     if (!changedFiles)
       return false;
     const imageExts = [".jpg", ".jpeg", ".png", ".gif", ".svg", ".webp"];
-    return changedFiles.some((file) => imageExts.includes(path38.extname(file).toLowerCase()));
+    return changedFiles.some((file) => imageExts.includes(path37.extname(file).toLowerCase()));
   }
 };
 
 // pkg/web/server/electron-livereload-server.ts
 var http4 = __toESM(require("http"));
-var path39 = __toESM(require("path"));
+var path38 = __toESM(require("path"));
 var fs12 = __toESM(require("fs/promises"));
 init_log();
 var log85 = getDomainLogger("web", { component: "electron-livereload-server" });
@@ -52757,7 +52756,7 @@ var ElectronLiveReloadServer = class {
       enableLiveReload: config.enableLiveReload !== false,
       publicDir: config.publicDir
     };
-    this.stateFilePath = path39.join(this.config.publicDir, ".foundry-livereload-state.json");
+    this.stateFilePath = path38.join(this.config.publicDir, ".foundry-livereload-state.json");
   }
   async start() {
     if (this.running) {
@@ -52810,7 +52809,7 @@ var ElectronLiveReloadServer = class {
     };
     if (changedFiles && changedFiles.length === 1) {
       const file = changedFiles[0];
-      const ext = path39.extname(file).toLowerCase();
+      const ext = path38.extname(file).toLowerCase();
       if (ext === ".css" || [".jpg", ".jpeg", ".png", ".gif", ".svg", ".webp"].includes(ext)) {
         state.path = file;
       }
@@ -52894,7 +52893,7 @@ var ElectronLiveReloadServer = class {
     try {
       const stats = await fs12.stat(filePath);
       if (stats.isDirectory()) {
-        const indexPath = path39.join(filePath, "index.html");
+        const indexPath = path38.join(filePath, "index.html");
         try {
           await fs12.stat(indexPath);
           filePath = indexPath;
@@ -52940,13 +52939,13 @@ var ElectronLiveReloadServer = class {
       log85.warn("Failed to decode URL:", cleanUrl, error);
       decodedUrl = cleanUrl;
     }
-    const normalizedPath = path39.normalize(decodedUrl).replace(/^(\.\.[\/\\])+/, "");
+    const normalizedPath = path38.normalize(decodedUrl).replace(/^(\.\.[\/\\])+/, "");
     const relativePath = normalizedPath.startsWith("/") ? normalizedPath.slice(1) : normalizedPath;
-    const resolvedPath = path39.join(this.config.publicDir, relativePath);
+    const resolvedPath = path38.join(this.config.publicDir, relativePath);
     return resolvedPath;
   }
   getContentType(filePath) {
-    const ext = path39.extname(filePath).toLowerCase();
+    const ext = path38.extname(filePath).toLowerCase();
     const mimeTypes = {
       ".html": "text/html; charset=utf-8",
       ".css": "text/css; charset=utf-8",
@@ -53066,13 +53065,13 @@ var ElectronLiveReloadServer = class {
   shouldLiveReloadCSS(changedFiles) {
     if (!changedFiles)
       return false;
-    return changedFiles.some((file) => path39.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(path39.extname(file).toLowerCase()));
+    return changedFiles.some((file) => imageExts.includes(path38.extname(file).toLowerCase()));
   }
 };
 
@@ -55372,7 +55371,7 @@ For more information, visit: https://help.mdfriday.com
    * Show version
    */
   showVersion() {
-    const version = "26.4.10";
+    const version = "26.4.12";
     return {
       success: true,
       message: `MDFriday CLI v${version}`