@mdfriday/foundry 26.3.22 → 26.4.2

package/dist/cli.js

@@ -9174,8 +9174,8 @@ var init_node_manifest_repository = __esm({
       async calculateFileHash(filePath, algorithm = "md5") {
         return new Promise((resolve3, reject) => {
           const hash = import_crypto.default.createHash(algorithm);
-          const fs13 = require("fs");
-          const stream = fs13.createReadStream(filePath);
+          const fs14 = require("fs");
+          const stream = fs14.createReadStream(filePath);
           stream.on("data", (data) => hash.update(data));
           stream.on("end", () => resolve3(hash.digest("hex")));
           stream.on("error", reject);
@@ -11731,8 +11731,8 @@ var init_loader = __esm({
        */
       async fileExists(filename) {
         try {
-          const fs13 = this.sourceDescriptor.fs();
-          const stat4 = await fs13.stat(filename);
+          const fs14 = this.sourceDescriptor.fs();
+          const stat4 = await fs14.stat(filename);
           return !stat4.isDir();
         } catch {
           return false;
@@ -11742,8 +11742,8 @@ var init_loader = __esm({
        * Load configuration from file
        */
       async loadConfigFromFile(filename) {
-        const fs13 = this.sourceDescriptor.fs();
-        const file = await fs13.open(filename);
+        const fs14 = this.sourceDescriptor.fs();
+        const file = await fs14.open(filename);
         try {
           const buffer = new Uint8Array(1024 * 1024);
           const { bytesRead } = await file.read(buffer);
@@ -11762,8 +11762,8 @@ var init_loader = __esm({
 });
 
 // internal/domain/config/factory/sourcedescriptor.ts
-function newSourceDescriptor(fs13, filename) {
-  return new ConfigSourceDescriptor(fs13, filename);
+function newSourceDescriptor(fs14, filename) {
+  return new ConfigSourceDescriptor(fs14, filename);
 }
 var ConfigSourceDescriptor;
 var init_sourcedescriptor = __esm({
@@ -11772,8 +11772,8 @@ var init_sourcedescriptor = __esm({
     ConfigSourceDescriptor = class {
       fileSystem;
       configFilename;
-      constructor(fs13, filename) {
-        this.fileSystem = fs13;
+      constructor(fs14, filename) {
+        this.fileSystem = fs14;
         this.configFilename = filename;
       }
       fs() {
@@ -11787,7 +11787,7 @@ var init_sourcedescriptor = __esm({
 });
 
 // internal/domain/config/factory/config.ts
-async function loadConfigWithParams(fs13, configFilename, workingDir, modulesDir, params = {}) {
+async function loadConfigWithParams(fs14, configFilename, workingDir, modulesDir, params = {}) {
   const cleanWorkingDir = path14.resolve(workingDir);
   const cleanModulesDir = path14.resolve(modulesDir);
   const cleanPublishDir = path14.resolve(DEFAULT_PUBLISH_DIR);
@@ -11797,9 +11797,9 @@ async function loadConfigWithParams(fs13, configFilename, workingDir, modulesDir
     publishDir: cleanPublishDir,
     cacheDir: ""
   };
-  baseDirs.cacheDir = await getCacheDir(fs13, baseDirs.cacheDir);
+  baseDirs.cacheDir = await getCacheDir(fs14, baseDirs.cacheDir);
   const loader = new ConfigLoader(
-    newSourceDescriptor(fs13, configFilename),
+    newSourceDescriptor(fs14, configFilename),
     baseDirs
   );
   try {
@@ -11808,9 +11808,9 @@ async function loadConfigWithParams(fs13, configFilename, workingDir, modulesDir
       provider.set(key2, value);
     }
     const absPublishDir = path14.resolve(provider.get("publishDir") || DEFAULT_PUBLISH_DIR);
-    await fs13.mkdirAll(absPublishDir, 511);
+    await fs14.mkdirAll(absPublishDir, 511);
     return newConfig(
-      fs13,
+      fs14,
       provider,
       newRoot(provider.get(""), provider.getParams("params")),
       newDir(baseDirs.workingDir, baseDirs.modulesDir, absPublishDir),
@@ -11825,14 +11825,14 @@ async function loadConfigWithParams(fs13, configFilename, workingDir, modulesDir
     loader.deleteMergeStrategies();
   }
 }
-async function getCacheDir(fs13, cacheDir) {
+async function getCacheDir(fs14, cacheDir) {
   if (cacheDir !== "") {
     return cacheDir;
   }
   const homeDir = process.env.HOME || process.env.USERPROFILE || "";
   const defaultCacheDir = path14.join(homeDir, ".cache", "mdf");
   try {
-    await fs13.mkdirAll(defaultCacheDir, 493);
+    await fs14.mkdirAll(defaultCacheDir, 493);
     return defaultCacheDir;
   } catch {
     return path14.join("/tmp", "hugo-cache");
@@ -12012,11 +12012,11 @@ var init_mount = __esm({
 });
 
 // internal/domain/module/vo/httpclient.ts
-function newHttpClient(fs13, timeout, headers, customClient) {
+function newHttpClient(fs14, timeout, headers, customClient) {
   if (customClient) {
     return customClient;
   }
-  return new NodeHttpClient2(fs13, timeout, headers);
+  return new NodeHttpClient2(fs14, timeout, headers);
 }
 var path16, http, https, log20, NodeHttpClient2;
 var init_httpclient = __esm({
@@ -12029,8 +12029,8 @@ var init_httpclient = __esm({
     init_log();
     log20 = getDomainLogger("module", { component: "httpclient" });
     NodeHttpClient2 = class {
-      constructor(fs13, timeout = 3e4, headers = {}) {
-        this.fs = fs13;
+      constructor(fs14, timeout = 3e4, headers = {}) {
+        this.fs = fs14;
         this.timeout = timeout;
         this.headers = headers;
       }
@@ -12215,12 +12215,12 @@ var init_httpclient = __esm({
 });
 
 // internal/domain/module/vo/zipextractor.ts
-function newZipExtractor(fs13, environment = "node") {
+function newZipExtractor(fs14, environment = "node") {
   switch (environment) {
     case "node":
-      return new JsZipExtractor(fs13);
+      return new JsZipExtractor(fs14);
     case "browser":
-      return new WebZipExtractor(fs13);
+      return new WebZipExtractor(fs14);
     default:
       throw new Error(`Unsupported environment: ${environment}`);
   }
@@ -12235,8 +12235,8 @@ var init_zipextractor = __esm({
     path17 = __toESM(require("path"));
     log21 = getDomainLogger("module", { component: "zipextractor" });
     JsZipExtractor = class {
-      constructor(fs13) {
-        this.fs = fs13;
+      constructor(fs14) {
+        this.fs = fs14;
       }
       /**
        * Extract ZIP file to target directory
@@ -12339,8 +12339,8 @@ var init_zipextractor = __esm({
       }
     };
     WebZipExtractor = class {
-      constructor(fs13) {
-        this.fs = fs13;
+      constructor(fs14) {
+        this.fs = fs14;
       }
       async extract(zipPath, targetDir) {
         try {
@@ -12363,8 +12363,8 @@ var init_zipextractor = __esm({
 });
 
 // internal/domain/module/vo/cache.ts
-function newModuleCache(fs13, cacheDir) {
-  return new FsModuleCache(fs13, cacheDir);
+function newModuleCache(fs14, cacheDir) {
+  return new FsModuleCache(fs14, cacheDir);
 }
 var path18, log22, FsModuleCache;
 var init_cache = __esm({
@@ -12375,8 +12375,8 @@ var init_cache = __esm({
     path18 = __toESM(require("path"));
     log22 = getDomainLogger("module", { component: "cache" });
     FsModuleCache = class {
-      constructor(fs13, cacheDir = "./module/cache") {
-        this.fs = fs13;
+      constructor(fs14, cacheDir = "./module/cache") {
+        this.fs = fs14;
         this.cacheDir = cacheDir;
       }
       cacheDir;
@@ -12533,15 +12533,15 @@ var init_cache = __esm({
 });
 
 // internal/domain/module/vo/module.ts
-function newModule2(fs13, absoluteDir, modulePath, parent) {
-  return new Module2(fs13, absoluteDir, modulePath, parent || null, false);
+function newModule2(fs14, absoluteDir, modulePath, parent) {
+  return new Module2(fs14, absoluteDir, modulePath, parent || null, false);
 }
 function newProjectModule(info) {
-  const fs13 = info.osFs();
+  const fs14 = info.osFs();
   const absoluteDir = info.projDir();
   const modulePath = "project-root";
   const defaultLanguage3 = info.defaultLanguageKey();
-  const module2 = new Module2(fs13, absoluteDir, modulePath, null, true);
+  const module2 = new Module2(fs14, absoluteDir, modulePath, null, true);
   const projectModule = new ProjectModule(module2);
   projectModule.applyDefaultMounts();
   if (defaultLanguage3) {
@@ -12569,8 +12569,8 @@ var init_module3 = __esm({
     init_mount();
     path19 = __toESM(require("path"));
     Module2 = class _Module {
-      constructor(fs13, absoluteDir, modulePath, parent = null, isProject = false) {
-        this.fs = fs13;
+      constructor(fs14, absoluteDir, modulePath, parent = null, isProject = false) {
+        this.fs = fs14;
         this.absoluteDir = absoluteDir;
         this.modulePath = modulePath;
         this.parentModule = parent;
@@ -13663,11 +13663,11 @@ var init_fileinfo = __esm({
 });
 
 // internal/domain/fs/vo/file.ts
-function newFileWithMeta(file, meta, fs13) {
-  return new File(file, meta, fs13);
+function newFileWithMeta(file, meta, fs14) {
+  return new File(file, meta, fs14);
 }
-function newDirFileWithMeta(file, meta, fs13) {
-  return new File(file, meta, fs13, true);
+function newDirFileWithMeta(file, meta, fs14) {
+  return new File(file, meta, fs14, true);
 }
 var path22, File;
 var init_file = __esm({
@@ -13681,10 +13681,10 @@ var init_file = __esm({
       fileMeta;
       fs;
       _isDir;
-      constructor(file, fileMeta, fs13, isDir = false) {
+      constructor(file, fileMeta, fs14, isDir = false) {
         this.file = file;
         this.fileMeta = fileMeta;
-        this.fs = fs13;
+        this.fs = fs14;
         this._isDir = isDir;
       }
       /**
@@ -13812,8 +13812,8 @@ var init_file = __esm({
 });
 
 // internal/domain/fs/vo/dir.ts
-function newDirFile(file, meta, fs13) {
-  const baseFile = new File(file, meta, fs13, true);
+function newDirFile(file, meta, fs14) {
+  const baseFile = new File(file, meta, fs14, true);
   return new DirFile(baseFile);
 }
 var DirFile;
@@ -13888,8 +13888,8 @@ var init_dir2 = __esm({
 });
 
 // internal/domain/fs/entity/basefs.ts
-function newBaseFs(fs13, roots) {
-  return new BaseFs(fs13, roots);
+function newBaseFs(fs14, roots) {
+  return new BaseFs(fs14, roots);
 }
 var path23, log26, BaseFs;
 var init_basefs = __esm({
@@ -13906,8 +13906,8 @@ var init_basefs = __esm({
       fs;
       // osFs
       roots;
-      constructor(fs13, roots) {
-        this.fs = fs13;
+      constructor(fs14, roots) {
+        this.fs = fs14;
         this.roots = roots;
       }
       /**
@@ -14059,8 +14059,8 @@ var init_basefs = __esm({
 });
 
 // internal/domain/fs/vo/walkway.ts
-function newWalkway(fs13, cb) {
-  return new Walkway(fs13, cb);
+function newWalkway(fs14, cb) {
+  return new Walkway(fs14, cb);
 }
 var path24, log27, Walkway;
 var init_walkway = __esm({
@@ -14078,14 +14078,14 @@ var init_walkway = __esm({
       cb;
       cfg;
       walked = false;
-      constructor(fs13, cb) {
-        if (!fs13) {
+      constructor(fs14, cb) {
+        if (!fs14) {
           throw new Error("fs must be set");
         }
         if (!cb.walkFn) {
           throw new Error("walkFn must be set");
         }
-        this.fs = fs13;
+        this.fs = fs14;
         this.cb = cb;
         this.root = "";
         this.cfg = {};
@@ -14290,9 +14290,9 @@ var init_static_copier = __esm({
       /**
        * Walk filesystem recursively
        */
-      async walkFileSystem(fs13, basePath, callback) {
+      async walkFileSystem(fs14, basePath, callback) {
         try {
-          const file = await fs13.open(basePath);
+          const file = await fs14.open(basePath);
           const fileInfo = await file.stat();
           if (!fileInfo.isDir()) {
             await file.close();
@@ -14305,7 +14305,7 @@ var init_static_copier = __esm({
             const fullPath = this.joinPath(basePath, entry.name());
             if (entry.isDir()) {
               await callback(fullPath, true);
-              await this.walkFileSystem(fs13, fullPath, callback);
+              await this.walkFileSystem(fs14, fullPath, callback);
             } else {
               await callback(fullPath, false);
             }
@@ -14376,25 +14376,25 @@ async function collectFileMetaInfos(paths, fss) {
   const result = /* @__PURE__ */ new Map();
   let found = false;
   for (const path43 of paths) {
-    for (const fs13 of fss) {
+    for (const fs14 of fss) {
       try {
-        const fileMetaInfo = await createFileMetaInfo(path43, fs13);
+        const fileMetaInfo = await createFileMetaInfo(path43, fs14);
         result.set(path43, fileMetaInfo);
         found = true;
         if (found)
           break;
       } catch (error) {
-        log29.error(`Failed to create FileMetaInfo for ${path43} with fs=${fs13}:`, error);
+        log29.error(`Failed to create FileMetaInfo for ${path43} with fs=${fs14}:`, error);
       }
     }
   }
   return result;
 }
-async function createFileMetaInfo(filePath, fs13) {
+async function createFileMetaInfo(filePath, fs14) {
   try {
-    const fi = await fs13.stat(filePath);
+    const fi = await fs14.stat(filePath);
     const meta = newFileMeta(filePath);
-    meta.setOpenFunc(async () => await fs13.open(filePath));
+    meta.setOpenFunc(async () => await fs14.open(filePath));
     return newFileInfoWithMeta(fi, meta);
   } catch (error) {
     throw new Error(`Failed to stat file ${filePath}: ${error.message}`);
@@ -14505,8 +14505,8 @@ var init_fs = __esm({
       async walkLayouts(start, cb, conf) {
         return await this.walk(this.layouts, start, cb, conf);
       }
-      async walkContent(fs13, start, cb, conf) {
-        await this.walk(fs13, start, cb, conf);
+      async walkContent(fs14, start, cb, conf) {
+        await this.walk(fs14, start, cb, conf);
       }
       async walkStatics(start, cb, conf) {
         return await this.walk(this.statics, start, cb, conf);
@@ -14514,8 +14514,8 @@ var init_fs = __esm({
       async walkI18n(start, cb, conf) {
         return await this.walk(this.i18n, start, cb, conf);
       }
-      async walk(fs13, start, cb, conf) {
-        const w = newWalkway(fs13, cb);
+      async walk(fs14, start, cb, conf) {
+        const w = newWalkway(fs14, cb);
         if (start === "") {
           start = "/";
         }
@@ -14634,8 +14634,8 @@ var init_overlayoptions = __esm({
       /**
        * Check if filesystem exists in overlay
        */
-      hasFilesystem(fs13) {
-        return this.fss.includes(fs13);
+      hasFilesystem(fs14) {
+        return this.fss.includes(fs14);
       }
       /**
        * Get all filesystems as readonly array
@@ -14750,8 +14750,8 @@ var init_overlaydir = __esm({
        */
       async loadDirectoryEntries() {
         for (let i = 0; i < this.fss.length; i++) {
-          const fs13 = this.fss[i];
-          await this.readFromFilesystem(fs13, null);
+          const fs14 = this.fss[i];
+          await this.readFromFilesystem(fs14, null);
         }
         for (let i = 0; i < this.dirOpeners.length; i++) {
           const file = await this.dirOpeners[i]();
@@ -14761,12 +14761,12 @@ var init_overlaydir = __esm({
       /**
        * Read directory entries from a specific filesystem or file
        */
-      async readFromFilesystem(fs13, file) {
+      async readFromFilesystem(fs14, file) {
         let f = file;
         try {
-          if (!f && fs13) {
+          if (!f && fs14) {
             const fsPath = this._name === "/" ? "" : this._name;
-            f = await fs13.open(fsPath);
+            f = await fs14.open(fsPath);
           }
           if (!f) {
             return;
@@ -14945,22 +14945,22 @@ var init_overlayfs = __esm({
        * Collect directories from all filesystems
        */
       async collectDirs(name, withFs) {
-        for (const fs13 of this.fss) {
-          await this.collectDirsRecursive(fs13, name, withFs);
+        for (const fs14 of this.fss) {
+          await this.collectDirsRecursive(fs14, name, withFs);
         }
       }
       /**
        * Recursively collect directories from filesystem hierarchy
        */
-      async collectDirsRecursive(fs13, name, withFs) {
+      async collectDirsRecursive(fs14, name, withFs) {
         try {
-          const fi = await fs13.stat(name);
+          const fi = await fs14.stat(name);
           if (fi.isDir()) {
-            withFs(fs13);
+            withFs(fs14);
           }
         } catch (error) {
         }
-        const fsi = fs13;
+        const fsi = fs14;
         if (fsi.filesystem && fsi.numFilesystems) {
           for (let i = 0; i < fsi.numFilesystems(); i++) {
             const subFs = fsi.filesystem(i);
@@ -14975,8 +14975,8 @@ var init_overlayfs = __esm({
        */
       async statInternal(name, lstatIfPossible) {
         for (let i = 0; i < this.fss.length; i++) {
-          const fs13 = this.fss[i];
-          const [fs22, fi, ok3, err] = await this.statRecursive(fs13, name, lstatIfPossible);
+          const fs14 = this.fss[i];
+          const [fs22, fi, ok3, err] = await this.statRecursive(fs14, name, lstatIfPossible);
           if (err === null || !this.isNotExistError(err)) {
             return [fs22, fi, ok3, err];
           }
@@ -14986,16 +14986,16 @@ var init_overlayfs = __esm({
       /**
        * Recursive stat implementation
        */
-      async statRecursive(fs13, name, lstatIfPossible) {
+      async statRecursive(fs14, name, lstatIfPossible) {
         try {
-          const fi = await fs13.stat(name);
-          return [fs13, fi, false, null];
+          const fi = await fs14.stat(name);
+          return [fs14, fi, false, null];
         } catch (error) {
           if (!this.isNotExistError(error)) {
-            return [fs13, null, false, error];
+            return [fs14, null, false, error];
           }
         }
-        const fsi = fs13;
+        const fsi = fs14;
         if (fsi.filesystem && fsi.numFilesystems) {
           for (let i = 0; i < fsi.numFilesystems(); i++) {
             const subFs = fsi.filesystem(i);
@@ -15049,14 +15049,14 @@ var init_overlayfs = __esm({
         if (this.fss.length === 0) {
           throw ErrFileNotFound;
         }
-        const [fs13, fi, , err] = await this.statInternal(name, false);
+        const [fs14, fi, , err] = await this.statInternal(name, false);
         if (err) {
           throw err;
         }
         if (fi.isDir()) {
           const dirFss = [];
-          await this.collectDirs(name, (fs14) => {
-            dirFss.push(fs14);
+          await this.collectDirs(name, (fs15) => {
+            dirFss.push(fs15);
           });
           if (dirFss.length === 0) {
             throw ErrFileNotFound;
@@ -15072,7 +15072,7 @@ var init_overlayfs = __esm({
             // Pass filesystems directly
           );
         }
-        return await fs13.open(name);
+        return await fs14.open(name);
       }
       /**
        * Open file with flags (write operations use first filesystem)
@@ -15434,21 +15434,21 @@ var init_filesystemscollector = __esm({
               absFilename,
               base2
             );
-            const fs13 = rm2.fs(this.sourceProject);
+            const fs14 = rm2.fs(this.sourceProject);
             if (this.isPrompts(mount.target())) {
-              fromToPrompt.push(fs13);
+              fromToPrompt.push(fs14);
             } else if (this.isWorkflows(mount.target())) {
-              fromToWorkflow.push(fs13);
+              fromToWorkflow.push(fs14);
             } else if (this.isContent(mount.target())) {
-              fromToContent.push(fs13);
+              fromToContent.push(fs14);
             } else if (this.isLayouts(mount.target())) {
-              fromToLayouts.push(fs13);
+              fromToLayouts.push(fs14);
             } else if (this.isStatics(mount.target())) {
-              fromToStatics.push(fs13);
+              fromToStatics.push(fs14);
             } else if (this.isAssets(mount.target())) {
-              fromToAssets.push(fs13);
+              fromToAssets.push(fs14);
             } else if (this.isI18n(mount.target())) {
-              fromToI18n.push(fs13);
+              fromToI18n.push(fs14);
             }
           }
           if (fromToWorkflow.length > 0) {
@@ -15458,9 +15458,9 @@ var init_filesystemscollector = __esm({
             this.overlayMountsPrompt = this.overlayMountsPrompt.append(...fromToPrompt);
           }
           if (md.isProjectModule()) {
-            for (const fs13 of fromToContent) {
+            for (const fs14 of fromToContent) {
               let ofs = createReadOnlyOverlayFs([]);
-              ofs = ofs.append(...[fs13]);
+              ofs = ofs.append(...[fs14]);
               this.overlayMountsContent.push(ofs);
             }
           }
@@ -24419,9 +24419,9 @@ var init_pagecollector = __esm({
       fs;
       processedPaths = /* @__PURE__ */ new Set();
       // Track processed paths
-      constructor(pageMap, fs13) {
+      constructor(pageMap, fs14) {
         this.m = pageMap;
-        this.fs = fs13;
+        this.fs = fs14;
       }
       async collect() {
         try {
@@ -24439,9 +24439,9 @@ var init_pagecollector = __esm({
       /**
        * CollectDir - exact replica of Go's collectDir method
        */
-      async collectDir(fs13, path43, root2) {
+      async collectDir(fs14, path43, root2) {
         try {
-          await this.fs.walkContent(fs13, path43, {
+          await this.fs.walkContent(fs14, path43, {
             hookPre: async (dir2, path44, readdir2) => {
               const fullPath = path44;
               if (this.processedPaths.has(fullPath)) {
@@ -24538,8 +24538,8 @@ var init_content2 = __esm({
       pageMap;
       translator;
       pageCollected = false;
-      constructor(fs13, converter, pageMap, translator) {
-        this.fs = fs13;
+      constructor(fs14, converter, pageMap, translator) {
+        this.fs = fs14;
         this.converter = converter;
         this.pageMap = pageMap;
         this.translator = translator;
@@ -27662,8 +27662,8 @@ var init_lookup = __esm({
 });
 
 // internal/domain/template/entity/template.ts
-function newTemplateEngine(executor, lookup, parser, templateNamespace, partialNamespace, shortcodeNamespace, fs13) {
-  return new TemplateEngine(executor, lookup, parser, templateNamespace, partialNamespace, shortcodeNamespace, fs13);
+function newTemplateEngine(executor, lookup, parser, templateNamespace, partialNamespace, shortcodeNamespace, fs14) {
+  return new TemplateEngine(executor, lookup, parser, templateNamespace, partialNamespace, shortcodeNamespace, fs14);
 }
 var log52, TemplateEngine;
 var init_template = __esm({
@@ -27684,14 +27684,14 @@ var init_template = __esm({
       partialNamespace;
       shortcodeNamespace;
       fs;
-      constructor(executor, lookup, parser, templateNamespace, partialNamespace, shortcodeNamespace, fs13) {
+      constructor(executor, lookup, parser, templateNamespace, partialNamespace, shortcodeNamespace, fs14) {
         this.executor = executor;
         this.lookup = lookup;
         this.parser = parser;
         this.templateNamespace = templateNamespace;
         this.partialNamespace = partialNamespace;
         this.shortcodeNamespace = shortcodeNamespace;
-        this.fs = fs13;
+        this.fs = fs14;
       }
       /**
        * Mark template engine as ready
@@ -30371,9 +30371,9 @@ var init_registry = __esm({
 function newTemplateFactory() {
   return new Factory2();
 }
-async function createTemplateEngineWithServices(fs13, services) {
+async function createTemplateEngineWithServices(fs14, services) {
   const factory = newTemplateFactory();
-  return factory.createWithServices(fs13, services);
+  return factory.createWithServices(fs14, services);
 }
 var Factory2, Builder;
 var init_template2 = __esm({
@@ -30391,15 +30391,15 @@ var init_template2 = __esm({
       /**
        * Create template engine with file system (core functions only)
        */
-      async create(fs13) {
-        return this.createWithConfig(fs13, {});
+      async create(fs14) {
+        return this.createWithConfig(fs14, {});
       }
       /**
        * Create template engine with configuration
        */
-      async createWithConfig(fs13, config) {
+      async createWithConfig(fs14, config) {
         try {
-          const builder = new Builder().withFs(fs13).withNamespaces(
+          const builder = new Builder().withFs(fs14).withNamespaces(
             newRegularTemplateNamespace(),
             newPartialTemplateNamespace(),
             newShortcodeTemplateNamespace()
@@ -30423,8 +30423,8 @@ var init_template2 = __esm({
        * Create template engine with services
        * TypeScript equivalent of Go's New(fs, cfs) function
        */
-      async createWithServices(fs13, services) {
-        return this.createWithConfig(fs13, { services });
+      async createWithServices(fs14, services) {
+        return this.createWithConfig(fs14, { services });
       }
     };
     Builder = class {
@@ -30441,8 +30441,8 @@ var init_template2 = __esm({
       /**
        * Set file system
        */
-      withFs(fs13) {
-        this.fs = fs13;
+      withFs(fs14) {
+        this.fs = fs14;
         return this;
       }
       /**
@@ -47738,17 +47738,17 @@ var init_site = __esm({
 });
 
 // internal/domain/site/entity/publisher.ts
-async function openFileForWriting(fs13, filename) {
+async function openFileForWriting(fs14, filename) {
   const cleanFilename = import_path26.default.normalize(filename);
   try {
-    return await fs13.create(cleanFilename);
+    return await fs14.create(cleanFilename);
   } catch (error) {
     if (!isFileNotFoundError(error)) {
       throw error;
     }
     const dir2 = import_path26.default.dirname(cleanFilename);
-    await fs13.mkdirAll(dir2, 511);
-    return await fs13.create(cleanFilename);
+    await fs14.mkdirAll(dir2, 511);
+    return await fs14.create(cleanFilename);
   }
 }
 function isFileNotFoundError(error) {
@@ -47763,8 +47763,8 @@ var init_publisher2 = __esm({
     log64 = getDomainLogger("site", { component: "publisher" });
     Publisher = class {
       fs;
-      constructor(fs13) {
-        this.fs = fs13;
+      constructor(fs14) {
+        this.fs = fs14;
       }
       /**
        * PublishSource publishes content from a source buffer to files
@@ -50283,10 +50283,10 @@ __export(ssg_exports, {
   processSSGWithProgress: () => processSSGWithProgress,
   serveSSG: () => serveSSG
 });
-function setDomainInstances(site, content, fs13, config, modules, resources, template) {
+function setDomainInstances(site, content, fs14, config, modules, resources, template) {
   siteCache = site;
   contentCache = content;
-  fsCache = fs13;
+  fsCache = fs14;
   configCache = config;
   modulesCache = modules;
   resourcesCache = resources;
@@ -50354,8 +50354,8 @@ async function createContentEngine(filesystem, config, modules, markdown) {
     contentFs: () => {
       return filesystem.contentFs();
     },
-    walkContent: (fs13, start, cb, conf) => {
-      return filesystem.walkContent(fs13, start, cb, conf);
+    walkContent: (fs14, start, cb, conf) => {
+      return filesystem.walkContent(fs14, start, cb, conf);
     },
     walkI18n: (start, cb, conf) => {
       return filesystem.walkI18n(start, cb, conf);
@@ -50449,10 +50449,10 @@ function createCustomizedFunctions(config, site, resources) {
     }
   };
 }
-function createResourcesEngine(config, fs13) {
+function createResourcesEngine(config, fs14) {
   const workspace = {
-    assetsFs: () => fs13.assetsFs(),
-    publishFs: () => fs13.publishFs(),
+    assetsFs: () => fs14.assetsFs(),
+    publishFs: () => fs14.publishFs(),
     baseUrl: () => config.getProvider().getString("baseURL") || "http://localhost",
     executeTemplate: async (templateName, rawContent, data) => {
       throw new Error("Template execution not initialized. Please call resources.setTemplateSvc() first.");
@@ -50460,10 +50460,10 @@ function createResourcesEngine(config, fs13) {
   };
   return createResources(workspace);
 }
-async function createTemplateEngineFromFs(fs13, config, site, resources) {
+async function createTemplateEngineFromFs(fs14, config, site, resources) {
   const services = createCustomizedFunctions(config, site, resources);
   const templateFs = {
-    walk: fs13.walkLayouts.bind(fs13)
+    walk: fs14.walkLayouts.bind(fs14)
   };
   return await createTemplateEngineWithServices(templateFs, services);
 }
@@ -50503,7 +50503,7 @@ async function createTemplateAdapter(templateEngine, site) {
     }
   };
 }
-function createSiteForSSG(config, fs13, content) {
+function createSiteForSSG(config, fs14, content) {
   const siteServices = {
     // Config service methods
     configParams: () => config.getProvider().getParams("params"),
@@ -50584,13 +50584,13 @@ function createSiteForSSG(config, fs13, content) {
     generateSitemap: async () => ({ urls: [] }),
     // Publisher methods
     publishFs: () => {
-      return fs13.publishFs();
+      return fs14.publishFs();
     },
     staticFs() {
-      return fs13.staticFs();
+      return fs14.staticFs();
     },
     copyStaticFiles(from, to) {
-      return fs13.copyStatic([from], to);
+      return fs14.copyStatic([from], to);
     },
     workingDir: () => config.getProvider().getString("workingDir") || process.cwd(),
     // ResourceService implementation (placeholder)
@@ -50894,11 +50894,11 @@ var init_ssg = __esm({
     import_path27 = __toESM(require("path"));
     init_resources2();
     log76 = getDomainLogger("ssg", { component: "application" });
-    createDomainInstances = (site, content, fs13, config, modules, resources) => {
+    createDomainInstances = (site, content, fs14, config, modules, resources) => {
       return {
         site,
         content,
-        fs: fs13,
+        fs: fs14,
         config,
         modules,
         resources
@@ -52099,18 +52099,47 @@ init_log();
 // pkg/web/watcher/content-file-watcher.ts
 var chokidar = __toESM(require("chokidar"));
 var path40 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
 init_log();
 var log83 = getDomainLogger("web", { component: "content-file-watcher" });
 var ContentFileWatcher = class {
   constructor(config) {
     this.config = config;
     this.batchDelay = config.batchDelay || 500;
+    if (config.isSingleFileMode !== void 0) {
+      this.isSingleFileMode = config.isSingleFileMode;
+    } else {
+      this.isSingleFileMode = this.detectSingleFileMode(config.contentDirs);
+    }
+    if (this.isSingleFileMode) {
+      log83.info("Single file mode detected", {
+        contentDirs: config.contentDirs
+      });
+    }
   }
   watcher = null;
   eventQueue = [];
   batchTimer = null;
   batchDelay;
   callbacks = [];
+  isSingleFileMode = false;
+  /**
+   * 检测是否所有路径都是单个文件
+   */
+  detectSingleFileMode(paths) {
+    if (paths.length === 0) {
+      return false;
+    }
+    return paths.every((p2) => {
+      try {
+        const stats = fs11.statSync(p2);
+        return stats.isFile();
+      } catch {
+        const ext = path40.extname(p2).toLowerCase();
+        return ext === ".md" || ext === ".markdown";
+      }
+    });
+  }
   async startWatching() {
     if (this.watcher) {
       await this.stopWatching();
@@ -52146,14 +52175,30 @@ var ContentFileWatcher = class {
   }
   queueEvent(filePath, eventType) {
     let fp = filePath;
-    const { projContentDirs, contentDirs } = this.config;
-    for (let i = 0; i < projContentDirs.length; i++) {
-      const projContentDir = projContentDirs[i];
-      for (let j = 0; j < contentDirs.length; j++) {
-        const contentDir = contentDirs[j];
-        if (projContentDir !== contentDir && fp.startsWith(contentDir)) {
-          fp = projContentDir + fp.slice(contentDir.length);
-          break;
+    if (this.isSingleFileMode) {
+      const matchedIndex = this.config.contentDirs.findIndex((contentFile) => {
+        return path40.normalize(filePath) === path40.normalize(contentFile);
+      });
+      if (matchedIndex !== -1) {
+        const projContentDir = this.config.projContentDirs[matchedIndex];
+        fp = path40.join(projContentDir, "index.md");
+        log83.debug("Single file event mapped", {
+          original: filePath,
+          mapped: fp
+        });
+      } else {
+        return;
+      }
+    } else {
+      const { projContentDirs, contentDirs } = this.config;
+      for (let i = 0; i < projContentDirs.length; i++) {
+        const projContentDir = projContentDirs[i];
+        for (let j = 0; j < contentDirs.length; j++) {
+          const contentDir = contentDirs[j];
+          if (projContentDir !== contentDir && fp.startsWith(contentDir)) {
+            fp = projContentDir + fp.slice(contentDir.length);
+            break;
+          }
         }
       }
     }
@@ -52227,7 +52272,7 @@ var ContentFileWatcher = class {
 // pkg/web/server/livereload-server.ts
 var http3 = __toESM(require("http"));
 var path41 = __toESM(require("path"));
-var fs11 = __toESM(require("fs/promises"));
+var fs12 = __toESM(require("fs/promises"));
 var import_ws = require("ws");
 init_log();
 var log84 = getDomainLogger("web", { component: "livereload-server" });
@@ -52379,11 +52424,11 @@ var FoundryLiveReloadServer = class {
     const url = req.url || "/";
     let filePath = this.resolveFilePath(url);
     try {
-      const stats = await fs11.stat(filePath);
+      const stats = await fs12.stat(filePath);
       if (stats.isDirectory()) {
         const indexPath = path41.join(filePath, "index.html");
         try {
-          await fs11.stat(indexPath);
+          await fs12.stat(indexPath);
           filePath = indexPath;
         } catch {
           res.statusCode = 404;
@@ -52391,7 +52436,7 @@ var FoundryLiveReloadServer = class {
           return;
         }
       }
-      let content = await fs11.readFile(filePath);
+      let content = await fs12.readFile(filePath);
       const contentType = this.getContentType(filePath);
       res.setHeader("Content-Type", contentType);
       if (contentType.includes("text/html") && this.config.enableLiveReload) {
@@ -52549,7 +52594,7 @@ var FoundryLiveReloadServer = class {
 // pkg/web/server/electron-livereload-server.ts
 var http4 = __toESM(require("http"));
 var path42 = __toESM(require("path"));
-var fs12 = __toESM(require("fs/promises"));
+var fs13 = __toESM(require("fs/promises"));
 init_log();
 var log85 = getDomainLogger("web", { component: "electron-livereload-server" });
 var ElectronLiveReloadServer = class {
@@ -52596,7 +52641,7 @@ var ElectronLiveReloadServer = class {
         this.httpServer = null;
       }
       try {
-        await fs12.unlink(this.stateFilePath);
+        await fs13.unlink(this.stateFilePath);
       } catch (error) {
       }
       this.running = false;
@@ -52642,7 +52687,7 @@ var ElectronLiveReloadServer = class {
   }
   async writeStateFile(state) {
     try {
-      await fs12.writeFile(this.stateFilePath, JSON.stringify(state), "utf8");
+      await fs13.writeFile(this.stateFilePath, JSON.stringify(state), "utf8");
     } catch (error) {
       log85.error("Failed to write LiveReload state file:", error);
     }
@@ -52679,7 +52724,7 @@ var ElectronLiveReloadServer = class {
     const url = req.url || "/";
     if (url.startsWith("/.foundry-livereload-state.json")) {
       try {
-        const content = await fs12.readFile(this.stateFilePath, "utf8");
+        const content = await fs13.readFile(this.stateFilePath, "utf8");
         res.setHeader("Content-Type", "application/json; charset=utf-8");
         res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
         res.setHeader("Pragma", "no-cache");
@@ -52700,11 +52745,11 @@ var ElectronLiveReloadServer = class {
     }
     let filePath = this.resolveFilePath(url);
     try {
-      const stats = await fs12.stat(filePath);
+      const stats = await fs13.stat(filePath);
       if (stats.isDirectory()) {
         const indexPath = path42.join(filePath, "index.html");
         try {
-          await fs12.stat(indexPath);
+          await fs13.stat(indexPath);
           filePath = indexPath;
         } catch {
           res.statusCode = 404;
@@ -52712,7 +52757,7 @@ var ElectronLiveReloadServer = class {
           return;
         }
       }
-      let content = await fs12.readFile(filePath);
+      let content = await fs13.readFile(filePath);
       const contentType = this.getContentType(filePath);
       res.setHeader("Content-Type", contentType);
       if (contentType.includes("text/html") && this.config.enableLiveReload) {
@@ -55180,7 +55225,7 @@ For more information, visit: https://help.mdfriday.com
    * Show version
    */
   showVersion() {
-    const version = "26.3.22";
+    const version = "26.4.2";
     return {
       success: true,
       message: `MDFriday CLI v${version}`