@powerlines/nx 0.10.36 → 0.10.38

package/dist/{chunk-LNSZHZQF.js → chunk-F7EY5OCV.js}

@@ -1,16 +1,17 @@
 'use strict';
 
-var chunk2PYUYDPD_js = require('./chunk-2PYUYDPD.js');
+var chunkDQI2I5KK_js = require('./chunk-DQI2I5KK.js');
 var chunkSHUYVCID_js = require('./chunk-SHUYVCID.js');
 var logger = require('@storm-software/config-tools/logger');
 var baseExecutor = require('@storm-software/workspace-tools/base/base-executor');
 var isError = require('@stryke/type-checks/is-error');
-var defu5 = require('defu');
+var defu6 = require('defu');
 var core = require('@babel/core');
 var console = require('@storm-software/config-tools/logger/console');
 var types = require('@storm-software/config-tools/types');
 var toArray = require('@stryke/convert/to-array');
 var copyFile = require('@stryke/fs/copy-file');
+var helpers = require('@stryke/fs/helpers');
 var install = require('@stryke/fs/install');
 var listFiles = require('@stryke/fs/list-files');
 var packageFns = require('@stryke/fs/package-fns');
@@ -28,13 +29,14 @@ var chalk5 = require('chalk');
 var Handlebars = require('handlebars');
 var helperPluginUtils = require('@babel/helper-plugin-utils');
 var t = require('@babel/types');
-var ts2 = require('typescript');
+var ts = require('typescript');
+var join = require('@stryke/path/join');
+var tsMorph = require('ts-morph');
 var _package = require('@stryke/string-format/package');
 var superdiff = require('@donedeal0/superdiff');
 var json = require('@stryke/fs/json');
 var stormJson = require('@stryke/json/storm-json');
 var filePathFns = require('@stryke/path/file-path-fns');
-var isParentPath = require('@stryke/path/is-parent-path');
 var titleCase = require('@stryke/string-format/title-case');
 var exists = require('@stryke/fs/exists');
 var writeFile$1 = require('@stryke/fs/write-file');
@@ -46,7 +48,6 @@ var murmurhash = require('@stryke/hash/murmurhash');
 var getUnique = require('@stryke/helpers/get-unique');
 var omit = require('@stryke/helpers/omit');
 var isType = require('@stryke/path/is-type');
-var join = require('@stryke/path/join');
 var isNull = require('@stryke/type-checks/is-null');
 var isString = require('@stryke/type-checks/is-string');
 var uuid = require('@stryke/unique-id/uuid');
@@ -56,20 +57,19 @@ var isUndefined = require('@stryke/type-checks/is-undefined');
 var parseTypeDefinition = require('@stryke/convert/parse-type-definition');
 var isFile = require('@stryke/fs/is-file');
 var $ = require('@stryke/capnp');
-var bufferToString = require('@stryke/convert/buffer-to-string');
 var buffer = require('@stryke/fs/buffer');
 var correctPath = require('@stryke/path/correct-path');
+var isParentPath = require('@stryke/path/is-parent-path');
 var prettyBytes = require('@stryke/string-format/pretty-bytes');
-var isBuffer = require('@stryke/type-checks/is-buffer');
 var flatCache = require('flat-cache');
 var buffer$1 = require('buffer');
-var _fs = require('fs');
 var colors = require('@storm-software/config-tools/utilities/colors');
 var noop = require('@stryke/helpers/noop');
 var slash = require('@stryke/path/slash');
-var memfs = require('memfs');
-var unionfs = require('unionfs');
-var tsMorph = require('ts-morph');
+var readFile = require('@stryke/fs/read-file');
+var fs = require('fs');
+var promises = require('fs/promises');
+var path = require('path');
 var isObject = require('@stryke/type-checks/is-object');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -92,13 +92,12 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var defu5__default = /*#__PURE__*/_interopDefault(defu5);
+var defu6__default = /*#__PURE__*/_interopDefault(defu6);
 var chalk5__default = /*#__PURE__*/_interopDefault(chalk5);
 var Handlebars__default = /*#__PURE__*/_interopDefault(Handlebars);
 var t__namespace = /*#__PURE__*/_interopNamespace(t);
-var ts2__default = /*#__PURE__*/_interopDefault(ts2);
+var ts__default = /*#__PURE__*/_interopDefault(ts);
 var $__namespace = /*#__PURE__*/_interopNamespace($);
-var _fs__default = /*#__PURE__*/_interopDefault(_fs);
 
 function resolveModulePath(nodePath, state) {
   if (!t__namespace.isStringLiteral(nodePath.node)) {
@@ -201,6 +200,108 @@ var moduleResolverBabelPlugin = /* @__PURE__ */ chunkSHUYVCID_js.__name((context
     };
   }, "builder"));
 }, "moduleResolverBabelPlugin");
+var VirtualFileSystemHost = class extends tsMorph.InMemoryFileSystemHost {
+  static {
+    chunkSHUYVCID_js.__name(this, "VirtualFileSystemHost");
+  }
+  #context;
+  constructor(context) {
+    super();
+    this.#context = context;
+  }
+  deleteSync(path) {
+    this.#context.fs.removeSync(path);
+  }
+  readDirSync(dirPath) {
+    return this.#context.fs.listSync(dirPath).reduce((ret, entry) => {
+      const fullPath = this.#context.fs.resolveSync(join.joinPaths(dirPath, entry));
+      if (fullPath) {
+        ret.push({
+          name: entry,
+          isDirectory: this.#context.fs.existsSync(fullPath),
+          isFile: this.#context.fs.existsSync(fullPath),
+          isSymlink: false
+        });
+      }
+      return ret;
+    }, []);
+  }
+  async readFile(filePath) {
+    if (!this.#context.fs.existsSync(filePath)) {
+      throw new Error(`File not found: '${filePath}'. Please check the path and try again.`);
+    }
+    return await this.#context.fs.read(filePath);
+  }
+  readFileSync(filePath) {
+    if (!this.#context.fs.existsSync(filePath)) {
+      throw new Error(`File not found: '${filePath}'. Please check the path and try again.`);
+    }
+    return this.#context.fs.readSync(filePath);
+  }
+  async writeFile(filePath, fileText) {
+    return this.#context.fs.write(filePath, fileText);
+  }
+  writeFileSync(filePath, fileText) {
+    this.#context.fs.writeSync(filePath, fileText);
+  }
+  async mkdir(_dirPath) {
+  }
+  mkdirSync(_dirPath) {
+  }
+  async move(srcPath, destPath) {
+    await this.#context.fs.move(srcPath, destPath);
+  }
+  moveSync(srcPath, destPath) {
+    this.#context.fs.moveSync(srcPath, destPath);
+  }
+  async copy(srcPath, destPath) {
+    await this.#context.fs.copy(srcPath, destPath);
+  }
+  copySync(srcPath, destPath) {
+    this.#context.fs.copySync(srcPath, destPath);
+  }
+  async fileExists(filePath) {
+    return this.#context.fs.exists(filePath);
+  }
+  fileExistsSync(filePath) {
+    return this.#context.fs.existsSync(filePath);
+  }
+  async directoryExists(dirPath) {
+    return this.#context.fs.exists(dirPath);
+  }
+  directoryExistsSync(dirPath) {
+    return this.#context.fs.existsSync(dirPath);
+  }
+  realpathSync(path) {
+    return this.#context.fs.resolveSync(path) || path;
+  }
+  getCurrentDirectory() {
+    return this.#context.workspaceConfig.workspaceRoot;
+  }
+  async glob(patterns) {
+    return this.#context.fs.glob(patterns);
+  }
+  globSync(patterns) {
+    return this.#context.fs.globSync(patterns);
+  }
+};
+function createProgram(context, override) {
+  context.log(types.LogLevelLabel.TRACE, `Creating ts-morph Project instance with configuration from: ${context.tsconfig.tsconfigFilePath}.`);
+  const project = new tsMorph.Project(defu6__default.default(override ?? {}, {
+    skipAddingFilesFromTsConfig: false,
+    tsConfigFilePath: context.tsconfig.tsconfigFilePath,
+    fileSystem: new VirtualFileSystemHost(context),
+    compilerOptions: defu6__default.default(context.tsconfig.options ?? {}, {
+      lib: [
+        "lib.esnext.full.d.ts"
+      ]
+    })
+  }));
+  return project;
+}
+chunkSHUYVCID_js.__name(createProgram, "createProgram");
+
+// ../powerlines/src/internal/helpers/generate-types.ts
 function formatTypes(code) {
   return code.replace(
     // eslint-disable-next-line regexp/no-super-linear-backtracking
@@ -211,8 +312,11 @@ function formatTypes(code) {
 chunkSHUYVCID_js.__name(formatTypes, "formatTypes");
 async function emitTypes(context, files) {
   context.log(types.LogLevelLabel.TRACE, `Running the TypeScript compiler for ${files.length} generated runtime files.`);
-  context.program.addSourceFilesAtPaths(files);
-  const result = context.program.emitToMemory({
+  const program = createProgram(context, {
+    skipAddingFilesFromTsConfig: true
+  });
+  program.addSourceFilesAtPaths(files);
+  const result = program.emitToMemory({
     emitOnlyDtsFiles: true
   });
   let builtinModules = "";
@@ -231,9 +335,9 @@ async function emitTypes(context, files) {
   const diagnosticMessages = [];
   result.getDiagnostics().forEach((diagnostic) => {
     if (diagnostic.getSourceFile()?.getBaseName()) {
-      diagnosticMessages.push(`${diagnostic.getSourceFile()?.getBaseName()} (${(diagnostic.getLineNumber() ?? 0) + 1}): ${ts2.flattenDiagnosticMessageText(diagnostic.getMessageText().toString(), "\n")}`);
+      diagnosticMessages.push(`${diagnostic.getSourceFile()?.getBaseName()} (${(diagnostic.getLineNumber() ?? 0) + 1}): ${ts.flattenDiagnosticMessageText(diagnostic.getMessageText().toString(), "\n")}`);
     } else {
-      diagnosticMessages.push(ts2.flattenDiagnosticMessageText(diagnostic.getMessageText().toString(), "\n"));
+      diagnosticMessages.push(ts.flattenDiagnosticMessageText(diagnostic.getMessageText().toString(), "\n"));
     }
   });
   const diagnosticMessage = diagnosticMessages.join("\n");
@@ -272,7 +376,7 @@ async function callHook(context, hook, options, ...args) {
     if (definedResults.length > 0) {
       let mergedResult = void 0;
       for (const result of definedResults) {
-        mergedResult = defu5.defu(result, mergedResult ?? {});
+        mergedResult = defu6.defu(result, mergedResult ?? {});
       }
       return mergedResult;
     }
@@ -409,13 +513,13 @@ function isIncludeMatchFound(tsconfigType, types) {
   return findIncludeMatch(tsconfigType, types) !== void 0;
 }
 chunkSHUYVCID_js.__name(isIncludeMatchFound, "isIncludeMatchFound");
-function getParsedTypeScriptConfig(workspaceRoot, projectRoot, tsconfig, tsconfigRaw = {}, originalTsconfigJson, host = ts2__default.default.sys) {
+function getParsedTypeScriptConfig(workspaceRoot, projectRoot, tsconfig, tsconfigRaw = {}, originalTsconfigJson, host = ts__default.default.sys) {
   const tsconfigFilePath = getTsconfigFilePath(workspaceRoot, projectRoot, tsconfig);
   const tsconfigJson = json.readJsonFileSync(tsconfigFilePath);
   if (!tsconfigJson) {
     throw new Error(`Cannot find the \`tsconfig.json\` configuration file at ${joinPaths.joinPaths(projectRoot, tsconfig ?? "tsconfig.json")}`);
   }
-  const parsedCommandLine = ts2__default.default.parseJsonConfigFileContent(defu5__default.default(tsconfigRaw ?? {}, tsconfigJson), host, append.appendPath(projectRoot, workspaceRoot));
+  const parsedCommandLine = ts__default.default.parseJsonConfigFileContent(defu6__default.default(tsconfigRaw ?? {}, tsconfigJson), host, append.appendPath(projectRoot, workspaceRoot));
   if (parsedCommandLine.errors.length > 0) {
     const errorMessage = `Cannot parse the TypeScript compiler options. Please investigate the following issues:
 ${parsedCommandLine.errors.map((error) => `- ${(error.category !== void 0 && error.code ? `[${error.category}-${error.code}]: ` : "") + error.messageText.toString()}`).join("\n")}
@@ -456,15 +560,10 @@ async function resolveTsconfigChanges(context) {
   const tsconfigJson = await json.readJsonFile(tsconfigFilePath);
   tsconfigJson.compilerOptions ??= {};
   if (context.config.output.dts !== false) {
-    context.config.output.dts = context.config.output.dts ? isParentPath.isParentPath(context.config.output.dts, context.workspaceConfig.workspaceRoot) ? context.config.output.dts : append.appendPath(context.config.output.dts, context.workspaceConfig.workspaceRoot) : append.appendPath(context.config.projectRoot, context.workspaceConfig.workspaceRoot);
-    if (filePathFns.findFileExtension(context.config.output.dts) !== "d.ts" && filePathFns.findFileExtension(context.config.output.dts) !== "d.cts" && filePathFns.findFileExtension(context.config.output.dts) !== "d.mts") {
-      context.config.output.dts = joinPaths.joinPaths(context.config.output.dts, "powerlines.d.ts");
-    }
-    const dtsRelativePath = joinPaths.joinPaths(filePathFns.relativePath(joinPaths.joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot), filePathFns.findFilePath(context.config.output.dts)), filePathFns.findFileName(context.config.output.dts));
+    const dtsRelativePath = joinPaths.joinPaths(filePathFns.relativePath(joinPaths.joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot), filePathFns.findFilePath(context.dtsPath)), filePathFns.findFileName(context.dtsPath));
     if (!tsconfigJson.include?.some((filePattern) => isIncludeMatchFound(filePattern, [
-      String(context.config.output.dts),
-      dtsRelativePath,
-      "storm.d.ts"
+      context.dtsPath,
+      dtsRelativePath
     ]))) {
       tsconfigJson.include ??= [];
       tsconfigJson.include.push(dtsRelativePath.startsWith("./") ? dtsRelativePath.slice(2) : dtsRelativePath);
@@ -479,24 +578,6 @@ async function resolveTsconfigChanges(context) {
     tsconfigJson.compilerOptions.lib ??= [];
     tsconfigJson.compilerOptions.lib.push("esnext");
   }
-  if (tsconfig.options.module !== ts2__default.default.ModuleKind.ESNext) {
-    tsconfigJson.compilerOptions.module = "ESNext";
-  }
-  if (!tsconfig.options.target || ![
-    ts2__default.default.ScriptTarget.ESNext,
-    ts2__default.default.ScriptTarget.ES2024,
-    ts2__default.default.ScriptTarget.ES2023,
-    ts2__default.default.ScriptTarget.ES2022,
-    ts2__default.default.ScriptTarget.ES2021
-  ].includes(tsconfig.options.target)) {
-    tsconfigJson.compilerOptions.target = "ESNext";
-  }
-  if (tsconfig.options.moduleResolution !== ts2__default.default.ModuleResolutionKind.Bundler) {
-    tsconfigJson.compilerOptions.moduleResolution = "Bundler";
-  }
-  if (tsconfig.options.moduleDetection !== ts2__default.default.ModuleDetectionKind.Force) {
-    tsconfigJson.compilerOptions.moduleDetection = "force";
-  }
   if (tsconfig.options.esModuleInterop !== true) {
     tsconfigJson.compilerOptions.esModuleInterop = true;
   }
@@ -521,9 +602,7 @@ async function initializeTsconfig(context) {
   context.tsconfig.originalTsconfigJson = await json.readJsonFile(tsconfigFilePath);
   context.tsconfig.tsconfigJson = await resolveTsconfigChanges(context);
   context.log(types.LogLevelLabel.TRACE, "Writing updated TypeScript configuration (tsconfig.json) file to disk.");
-  await context.fs.writeFile(tsconfigFilePath, stormJson.StormJSON.stringify(context.tsconfig.tsconfigJson), {
-    mode: "fs"
-  });
+  await writeFile(context.log, tsconfigFilePath, stormJson.StormJSON.stringify(context.tsconfig.tsconfigJson));
   context.tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig, context.config.tsconfigRaw, context.tsconfig.originalTsconfigJson);
 }
 chunkSHUYVCID_js.__name(initializeTsconfig, "initializeTsconfig");
@@ -583,7 +662,7 @@ async function resolveTsconfig(context) {
 chunkSHUYVCID_js.__name(resolveTsconfig, "resolveTsconfig");
 var DEFAULT_ENVIRONMENT = "default";
 function createEnvironment(name, userConfig) {
-  return defu5__default.default(userConfig.environments?.[name] ?? {}, {
+  return defu6__default.default(userConfig.environments?.[name] ?? {}, {
     name,
     title: userConfig.title || titleCase.titleCase(userConfig.name),
     ssr: false,
@@ -627,8 +706,7 @@ function createDefaultEnvironment(userConfig) {
 }
 chunkSHUYVCID_js.__name(createDefaultEnvironment, "createDefaultEnvironment");
 function resolveOptions(options) {
-  return defu5__default.default(options, {
-    debug: options.logLevel === "trace",
+  return defu6__default.default(options, {
     interopDefault: true,
     fsCache: options.mode !== "development" ? joinPaths.joinPaths(options.cacheDir, "jiti") : false,
     moduleCache: options.mode !== "development"
@@ -719,7 +797,7 @@ function replacePathTokens(context, path) {
   if (!path) {
     return path;
   }
-  return path.replaceAll("{workspaceRoot}", context.workspaceConfig.workspaceRoot).replaceAll("{root}", context.config.projectRoot).replaceAll("{projectRoot}", context.config.projectRoot).replaceAll("{powerlinesPath}", context.powerlinesPath).replaceAll("{cachePath}", context.cachePath).replaceAll("{dataPath}", context.dataPath).replaceAll("{logPath}", context.envPaths.log).replaceAll("{tempPath}", context.envPaths.temp).replaceAll("{configPath}", context.envPaths.config).replaceAll("{outputPath}", context.config.output.outputPath).replaceAll("{distPath}", context.config.output.distPath).replaceAll("{artifactsPath}", replace.replacePath(context.artifactsPath, context.workspaceConfig.workspaceRoot)).replaceAll("{builtinPath}", replace.replacePath(context.builtinsPath, context.workspaceConfig.workspaceRoot)).replaceAll("{entryPath}", replace.replacePath(context.entryPath, context.workspaceConfig.workspaceRoot));
+  return path.replaceAll("{workspaceRoot}", context.workspaceConfig.workspaceRoot).replaceAll("{root}", context.config.projectRoot).replaceAll("{projectRoot}", context.config.projectRoot).replaceAll("{powerlinesPath}", context.powerlinesPath).replaceAll("{cachePath}", context.cachePath).replaceAll("{dataPath}", context.dataPath).replaceAll("{logPath}", context.envPaths.log).replaceAll("{tempPath}", context.envPaths.temp).replaceAll("{configPath}", context.envPaths.config).replaceAll("{outputPath}", context.config.output.outputPath).replaceAll("{buildPath}", context.config.output.buildPath).replaceAll("{artifactsPath}", replace.replacePath(context.artifactsPath, context.workspaceConfig.workspaceRoot)).replaceAll("{builtinPath}", replace.replacePath(context.builtinsPath, context.workspaceConfig.workspaceRoot)).replaceAll("{entryPath}", replace.replacePath(context.entryPath, context.workspaceConfig.workspaceRoot));
 }
 chunkSHUYVCID_js.__name(replacePathTokens, "replacePathTokens");
 function resolveEntryInputFile(context, typeDefinition) {
@@ -803,7 +881,7 @@ var FileMetadata = class _FileMetadata extends $__namespace.Struct {
   static _capnp = {
     displayName: "FileMetadata",
     id: "8e2cab5d7e28c7b3",
-    size: new $__namespace.ObjectSize(8, 4),
+    size: new $__namespace.ObjectSize(8, 3),
     defaultType: "normal"
   };
   static _Properties;
@@ -818,7 +896,7 @@ var FileMetadata = class _FileMetadata extends $__namespace.Struct {
     $__namespace.utils.setText(0, value, this);
   }
   /**
-  * The output mode of the file.
+  * The timestamp representing the file's creation date.
   *
   */
   get type() {
@@ -828,16 +906,6 @@ var FileMetadata = class _FileMetadata extends $__namespace.Struct {
     $__namespace.utils.setText(1, value, this);
   }
   /**
-  * The timestamp representing the file's creation date.
-  *
-  */
-  get mode() {
-    return $__namespace.utils.getText(2, this);
-  }
-  set mode(value) {
-    $__namespace.utils.setText(2, value, this);
-  }
-  /**
   * Additional metadata associated with the file.
   *
   */
@@ -848,22 +916,22 @@ var FileMetadata = class _FileMetadata extends $__namespace.Struct {
     $__namespace.utils.setUint32(0, value, this);
   }
   _adoptProperties(value) {
-    $__namespace.utils.adopt(value, $__namespace.utils.getPointer(3, this));
+    $__namespace.utils.adopt(value, $__namespace.utils.getPointer(2, this));
   }
   _disownProperties() {
     return $__namespace.utils.disown(this.properties);
   }
   get properties() {
-    return $__namespace.utils.getList(3, _FileMetadata._Properties, this);
+    return $__namespace.utils.getList(2, _FileMetadata._Properties, this);
   }
   _hasProperties() {
-    return !$__namespace.utils.isNull($__namespace.utils.getPointer(3, this));
+    return !$__namespace.utils.isNull($__namespace.utils.getPointer(2, this));
   }
   _initProperties(length) {
-    return $__namespace.utils.initList(3, _FileMetadata._Properties, length, this);
+    return $__namespace.utils.initList(2, _FileMetadata._Properties, length, this);
   }
   set properties(value) {
-    $__namespace.utils.copyFrom(value, $__namespace.utils.getPointer(3, this));
+    $__namespace.utils.copyFrom(value, $__namespace.utils.getPointer(2, this));
   }
   toString() {
     return "FileMetadata_" + super.toString();
@@ -898,13 +966,13 @@ var FileId = class extends $__namespace.Struct {
     return "FileId_" + super.toString();
   }
 };
-var FileData = class extends $__namespace.Struct {
+var FileStorage = class extends $__namespace.Struct {
   static {
-    chunkSHUYVCID_js.__name(this, "FileData");
+    chunkSHUYVCID_js.__name(this, "FileStorage");
   }
   static _capnp = {
-    displayName: "FileData",
-    id: "fa6725c8a360f9a2",
+    displayName: "FileStorage",
+    id: "9dca66ac858c9ebe",
     size: new $__namespace.ObjectSize(0, 2)
   };
   /**
@@ -924,7 +992,7 @@ var FileData = class extends $__namespace.Struct {
     $__namespace.utils.setText(1, value, this);
   }
   toString() {
-    return "FileData_" + super.toString();
+    return "FileStorage_" + super.toString();
   }
 };
 var FileSystem = class _FileSystem extends $__namespace.Struct {
@@ -937,7 +1005,7 @@ var FileSystem = class _FileSystem extends $__namespace.Struct {
     size: new $__namespace.ObjectSize(0, 3)
   };
   static _Ids;
-  static _Files;
+  static _Storage;
   static _Metadata;
   _adoptIds(value) {
     $__namespace.utils.adopt(value, $__namespace.utils.getPointer(0, this));
@@ -957,22 +1025,22 @@ var FileSystem = class _FileSystem extends $__namespace.Struct {
   set ids(value) {
     $__namespace.utils.copyFrom(value, $__namespace.utils.getPointer(0, this));
   }
-  _adoptFiles(value) {
+  _adoptStorage(value) {
     $__namespace.utils.adopt(value, $__namespace.utils.getPointer(1, this));
   }
-  _disownFiles() {
-    return $__namespace.utils.disown(this.files);
+  _disownStorage() {
+    return $__namespace.utils.disown(this.storage);
   }
-  get files() {
-    return $__namespace.utils.getList(1, _FileSystem._Files, this);
+  get storage() {
+    return $__namespace.utils.getList(1, _FileSystem._Storage, this);
   }
-  _hasFiles() {
+  _hasStorage() {
     return !$__namespace.utils.isNull($__namespace.utils.getPointer(1, this));
   }
-  _initFiles(length) {
-    return $__namespace.utils.initList(1, _FileSystem._Files, length, this);
+  _initStorage(length) {
+    return $__namespace.utils.initList(1, _FileSystem._Storage, length, this);
   }
-  set files(value) {
+  set storage(value) {
     $__namespace.utils.copyFrom(value, $__namespace.utils.getPointer(1, this));
   }
   _adoptMetadata(value) {
@@ -999,12 +1067,15 @@ var FileSystem = class _FileSystem extends $__namespace.Struct {
 };
 FileMetadata._Properties = $__namespace.CompositeList(FileMetadata_KeyValuePair);
 FileSystem._Ids = $__namespace.CompositeList(FileId);
-FileSystem._Files = $__namespace.CompositeList(FileData);
+FileSystem._Storage = $__namespace.CompositeList(FileStorage);
 FileSystem._Metadata = $__namespace.CompositeList(FileMetadata);
 
 // ../powerlines/src/types/fs.ts
-var __VFS_PATCH__ = "__VFS_PATCH__";
-var __VFS_REVERT__ = "__VFS_REVERT__";
+var StoragePreset = /* @__PURE__ */ (function(StoragePreset2) {
+  StoragePreset2["VIRTUAL"] = "virtual";
+  StoragePreset2["FS"] = "fs";
+  return StoragePreset2;
+})({});
 var createLog = /* @__PURE__ */ chunkSHUYVCID_js.__name((name, options = {}) => {
   const logLevel = options.logLevel === null ? types.LogLevelLabel.SILENT : options.logLevel || types.LogLevelLabel.INFO;
   if (logLevel === types.LogLevelLabel.SILENT) {
@@ -1043,142 +1114,18 @@ var BADGE_COLORS = [
 var extendLog = /* @__PURE__ */ chunkSHUYVCID_js.__name((logFn, name) => {
   return (type, ...args) => logFn(type, ` ${chalk5__default.default.inverse.hex(BADGE_COLORS[name.split("").map((char) => char.charCodeAt(0)).reduce((ret, charCode) => ret + charCode, 0) % BADGE_COLORS.length] || BADGE_COLORS[0])(` ${titleCase.titleCase(name)} `)}  ${args.join(" ")} `);
 }, "extendLog");
-function isBufferEncoding(options) {
-  return isSetString.isSetString(options) || options === null;
-}
-chunkSHUYVCID_js.__name(isBufferEncoding, "isBufferEncoding");
-function isPowerlinesWriteFileOptions(options) {
-  return !isBufferEncoding(options) && isSetObject.isSetObject(options) && "mode" in options && (options.mode === "fs" || options.mode === "virtual");
+function isFileError(err) {
+  return isError.isError(err) && "code" in err && err.code;
 }
-chunkSHUYVCID_js.__name(isPowerlinesWriteFileOptions, "isPowerlinesWriteFileOptions");
-function isVirtualFileData(obj) {
-  return !!(isSetObject.isSetObject(obj) && "code" in obj && obj.code);
+chunkSHUYVCID_js.__name(isFileError, "isFileError");
+function ignoreNotfound(err) {
+  return isFileError(err) && (err.code === "ENOENT" || err.code === "EISDIR" ? null : err);
 }
-chunkSHUYVCID_js.__name(isVirtualFileData, "isVirtualFileData");
+chunkSHUYVCID_js.__name(ignoreNotfound, "ignoreNotfound");
 function toFilePath(path) {
   return correctPath.correctPath(slash.slash(path?.toString() || ".").replace(/^file:\/\//, ""));
 }
 chunkSHUYVCID_js.__name(toFilePath, "toFilePath");
-var FS_METHODS = [
-  "mkdir",
-  "mkdirSync",
-  "rmdir",
-  "rmdirSync",
-  "unlink",
-  "unlinkSync",
-  "existsSync",
-  "realpathSync",
-  "writeFileSync",
-  "readFileSync",
-  "readdirSync",
-  "createWriteStream",
-  "WriteStream",
-  "createReadStream",
-  "ReadStream"
-];
-var FS_PROMISE_METHODS = [
-  "mkdir",
-  "rm",
-  "rmdir",
-  "unlink",
-  "writeFile",
-  "readFile",
-  "readdir",
-  "stat",
-  "lstat"
-];
-function cloneFS(originalFS) {
-  const clonedFS = {
-    ...originalFS,
-    promises: {
-      ...originalFS.promises ?? {}
-    }
-  };
-  for (const method of FS_METHODS) {
-    if (originalFS[method]) {
-      clonedFS[method] = originalFS[method];
-    }
-  }
-  originalFS.promises ??= {};
-  for (const method of FS_PROMISE_METHODS) {
-    if (originalFS.promises[method]) {
-      clonedFS.promises ??= {};
-      clonedFS.promises[method] = originalFS.promises[method];
-      clonedFS[method] = originalFS.promises[method];
-    }
-  }
-  for (const prop in clonedFS) {
-    if (isFunction.isFunction(clonedFS[prop])) {
-      clonedFS[prop] = clonedFS[prop].bind(originalFS);
-      if (isFunction.isFunction(clonedFS.promises[prop])) {
-        clonedFS.promises[prop] = clonedFS.promises[prop].bind(originalFS);
-      }
-    }
-  }
-  for (const prop in clonedFS.promises) {
-    if (isFunction.isFunction(clonedFS.promises[prop])) {
-      clonedFS.promises[prop] = clonedFS.promises[prop].bind(originalFS);
-    }
-  }
-  return clonedFS;
-}
-chunkSHUYVCID_js.__name(cloneFS, "cloneFS");
-function patchFS(originalFS, vfs) {
-  const clonedFS = cloneFS(originalFS);
-  originalFS.mkdirSync = (file, options) => vfs.mkdirSync(toFilePath(file), options);
-  originalFS.mkdir = (file, options, callback) => vfs.mkdir(toFilePath(file), options, callback);
-  originalFS.promises.mkdir = async (file, options) => vfs.mkdir(toFilePath(file), options);
-  originalFS.unlinkSync = (file) => vfs.unlinkSync(toFilePath(file));
-  originalFS.promises.rm = async (file, options) => vfs.rm(toFilePath(file), options);
-  originalFS.promises.unlink = async (file) => vfs.unlink(toFilePath(file));
-  originalFS.existsSync = (file) => vfs.existsSync(toFilePath(file));
-  Object.defineProperty(originalFS, "realpathSync", {
-    value: /* @__PURE__ */ chunkSHUYVCID_js.__name((file, options) => vfs.realpathSync(toFilePath(file), options), "value")
-  });
-  originalFS.writeFileSync = (file, data, options) => vfs.writeFileSync(toFilePath(file), data, options);
-  originalFS.promises.writeFile = async (file, data, options) => vfs.writeFile(toFilePath(file), data, options);
-  originalFS.readFileSync = (file, options) => vfs.readFileSync(toFilePath(file), options);
-  originalFS.promises.readFile = (file, options) => vfs.readFile(toFilePath(file), options);
-  originalFS.readdirSync = (file, options) => vfs.readdirSync(toFilePath(file), options);
-  originalFS.promises.readdir = (file, options) => vfs.readdir(toFilePath(file), options);
-  Object.defineProperty(originalFS, "statSync", {
-    value: /* @__PURE__ */ chunkSHUYVCID_js.__name((file, options) => vfs.statSync(toFilePath(file), options), "value")
-  });
-  originalFS.stat = (file, options) => vfs.statSync(toFilePath(file), options);
-  originalFS.promises.stat = (file, options) => vfs.stat(toFilePath(file), options);
-  Object.defineProperty(originalFS, "lstatSync", {
-    value: /* @__PURE__ */ chunkSHUYVCID_js.__name((file, options) => vfs.lstatSync(toFilePath(file), options), "value")
-  });
-  originalFS.lstat = (file, options) => vfs.lstatSync(toFilePath(file), options);
-  originalFS.promises.lstat = (file, options) => vfs.lstat(toFilePath(file), options);
-  return () => {
-    originalFS.mkdirSync = clonedFS.mkdirSync;
-    originalFS.mkdir = clonedFS.mkdir;
-    originalFS.promises.mkdir = clonedFS.promises.mkdir;
-    originalFS.unlinkSync = clonedFS.unlinkSync;
-    originalFS.promises.rm = clonedFS.promises.rm;
-    originalFS.promises.unlink = clonedFS.promises.unlink;
-    originalFS.existsSync = clonedFS.existsSync;
-    originalFS.realpathSync = clonedFS.realpathSync;
-    originalFS.writeFileSync = clonedFS.writeFileSync;
-    originalFS.promises.writeFile = clonedFS.promises.writeFile;
-    originalFS.readFileSync = clonedFS.readFileSync;
-    originalFS.promises.readFile = clonedFS.promises.readFile;
-    originalFS.readdirSync = clonedFS.readdirSync;
-    originalFS.promises.readdir = clonedFS.promises.readdir;
-    Object.defineProperty(originalFS, "statSync", {
-      value: clonedFS.statSync
-    });
-    originalFS.stat = clonedFS.stat;
-    originalFS.promises.stat = clonedFS.promises.stat;
-    Object.defineProperty(originalFS, "lstatSync", {
-      value: clonedFS.lstatSync
-    });
-    originalFS.lstat = clonedFS.lstat;
-    originalFS.promises.lstat = clonedFS.promises.lstat;
-  };
-}
-chunkSHUYVCID_js.__name(patchFS, "patchFS");
 function isValidId(id, prefix = "powerlines") {
   return id.replace(/^\\0/, "").startsWith(`${prefix.replace(/:$/, "")}`);
 }
@@ -1188,164 +1135,368 @@ function normalizeId(id, prefix = "powerlines") {
 }
 chunkSHUYVCID_js.__name(normalizeId, "normalizeId");
 function normalizePath(path, builtinsPath, prefix = "powerlines") {
-  return isValidId(toFilePath(path), prefix) ? normalizeId(toFilePath(path), prefix).replace(new RegExp(`^${prefix.replace(/:$/, "")}:`), builtinsPath) : toFilePath(path);
+  return isType.isAbsolutePath(path) ? path : isValidId(toFilePath(path), prefix) ? normalizeId(toFilePath(path), prefix).replace(new RegExp(`^${prefix.replace(/:$/, "")}:`), builtinsPath) : toFilePath(path);
 }
 chunkSHUYVCID_js.__name(normalizePath, "normalizePath");
-var UnifiedFS = class _UnifiedFS extends unionfs.Union {
+function normalizeKey(key, sep = ":") {
+  if (!key) {
+    return "";
+  }
+  return key.replace(/[:/\\]/g, sep).replace(/^[:/\\]|[:/\\]$/g, "");
+}
+chunkSHUYVCID_js.__name(normalizeKey, "normalizeKey");
+function filterKeyByBase(key, base) {
+  if (base) {
+    return key.startsWith(base) && key[key.length - 1] !== "$";
+  }
+  return key[key.length - 1] !== "$";
+}
+chunkSHUYVCID_js.__name(filterKeyByBase, "filterKeyByBase");
+var BaseStorageAdapter = class {
   static {
-    chunkSHUYVCID_js.__name(this, "UnifiedFS");
+    chunkSHUYVCID_js.__name(this, "BaseStorageAdapter");
   }
   /**
-  * The internal map of virtual files.
+  * Indicates whether the storage adapter has been disposed.
   */
-  #virtualFS = new memfs.Volume();
+  #isDisposed = false;
   /**
-  * The physical file system.
+  * Configuration options for the storage adapter.
   */
-  #physicalFS = cloneFS(_fs__default.default);
+  options;
   /**
-  * The context of the unified file system.
+  * Constructor for the BaseStorageAdapter.
+  *
+  * @param options - Configuration options for the storage adapter.
   */
-  #context;
-  static create(context, fs2) {
-    let result = new _UnifiedFS(context, fs2);
-    result = result.use(result.#physicalFS);
-    if (result.#context.config.output.mode !== "fs") {
-      result = result.use(result.#virtualFS);
-    }
-    return result;
+  constructor(options = {
+    base: "/"
+  }) {
+    this.options = options;
+    this.options.base = path.resolve(options.base);
+    this.options.isReadOnly = !!options.isReadOnly;
   }
   /**
-  * Gets the virtual file system (VFS).
+  * Asynchronously checks if a key exists in the storage.
+  *
+  * @param key - The key to check for existence.
+  * @returns A promise that resolves to `true` if the key exists, otherwise `false`.
   */
-  get virtual() {
-    return this.#virtualFS;
+  async exists(key) {
+    return this.existsSync(key);
   }
   /**
-  * Gets the physical file system (FS).
+  * Asynchronously retrieves the value associated with a given key.
+  *
+  * @param key - The key whose value is to be retrieved.
+  * @returns A promise that resolves to the value associated with the key, or `null` if the key does not exist.
   */
-  get physical() {
-    return this.#physicalFS;
+  async get(key) {
+    return this.getSync(key);
   }
   /**
-  * Creates a new instance of the VirtualFileSystem.
+  * Asynchronously sets the value for a given key.
   *
-  * @param context - The context of the virtual file system, typically containing options and logging functions.
-  * @param fs - A buffer containing the serialized virtual file system data.
+  * @param key - The key to set the value for.
+  * @param value - The value to set.
   */
-  constructor(context, fs2) {
-    super();
-    this.#context = context;
-    if (!this.#physicalFS.existsSync(this.#context.dataPath)) {
-      this.#physicalFS.mkdirSync(this.#context.dataPath, {
-        recursive: true
-      });
+  async set(key, value) {
+    if (!this.options.isReadOnly) {
+      this.setSync(key, value);
     }
-    if (!this.#physicalFS.existsSync(this.#context.cachePath)) {
-      this.#physicalFS.mkdirSync(this.#context.cachePath, {
-        recursive: true
-      });
-    }
-    if (!this.#physicalFS.existsSync(join.joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.output.distPath))) {
-      this.#physicalFS.mkdirSync(join.joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.output.distPath), {
-        recursive: true
-      });
+  }
+  /**
+  * Asynchronously removes a key from the storage.
+  *
+  * @param key - The key to remove.
+  */
+  async remove(key) {
+    if (!this.options.isReadOnly) {
+      this.removeSync(key);
     }
-    if (this.#context.config.output.mode !== "fs") {
-      this.#virtualFS = memfs.Volume.fromJSON(fs2._hasFiles() && fs2.files.length > 0 ? fs2.files.values().reduce((ret, file) => {
-        ret[file.path] = file.code;
-        return ret;
-      }, {}) : {});
-      if (!this.#virtualFS.existsSync(this.#context.artifactsPath)) {
-        this.#virtualFS.mkdirSync(this.#context.artifactsPath, {
-          recursive: true
-        });
-      }
-      if (!this.#virtualFS.existsSync(this.#context.builtinsPath)) {
-        this.#virtualFS.mkdirSync(this.#context.builtinsPath, {
-          recursive: true
-        });
-      }
-      if (!this.#virtualFS.existsSync(this.#context.entryPath)) {
-        this.#virtualFS.mkdirSync(this.#context.entryPath, {
-          recursive: true
-        });
-      }
-      if (!this.#virtualFS.existsSync(this.#context.dtsPath)) {
-        this.#virtualFS.mkdirSync(this.#context.dtsPath, {
-          recursive: true
-        });
-      }
-    } else if (this.#context.config.projectType === "application") {
-      if (!this.#physicalFS.existsSync(this.#context.artifactsPath)) {
-        this.#physicalFS.mkdirSync(this.#context.artifactsPath, {
-          recursive: true
-        });
-      }
-      if (!this.#physicalFS.existsSync(this.#context.builtinsPath)) {
-        this.#physicalFS.mkdirSync(this.#context.builtinsPath, {
-          recursive: true
-        });
+  }
+  /**
+  * Synchronously removes all entries from the storage that match the provided base path.
+  *
+  * @param base - The base path to clear keys from.
+  */
+  clearSync(base) {
+    if (!this.options.isReadOnly) {
+      const keys = this.listSync(base || this.options.base);
+      if (!keys.length) {
+        return;
       }
-      if (!this.#physicalFS.existsSync(this.#context.entryPath)) {
-        this.#physicalFS.mkdirSync(this.#context.entryPath, {
-          recursive: true
-        });
+      keys.map((key) => this.removeSync(base && !key.startsWith(base) ? join.joinPaths(base, key) : key));
+    }
+  }
+  /**
+  * Asynchronously removes all entries from the storage that match the provided base path.
+  *
+  * @param base - The base path to clear keys from.
+  * @returns A promise that resolves when the operation is complete.
+  */
+  async clear(base) {
+    if (!this.options.isReadOnly) {
+      const keys = await this.list(base || this.options.base);
+      if (!keys.length) {
+        return;
       }
-      if (!this.#physicalFS.existsSync(this.#context.dtsPath)) {
-        this.#physicalFS.mkdirSync(this.#context.dtsPath, {
-          recursive: true
-        });
+      await Promise.all(keys.map(async (key) => this.remove(base && !key.startsWith(base) ? join.joinPaths(base, key) : key)));
+    }
+  }
+  /**
+  * Asynchronously lists all keys under a given base path.
+  *
+  * @param base - The base path to list keys from.
+  * @returns A promise that resolves to an array of keys under the specified base path.
+  */
+  async list(base) {
+    return this.listSync(base);
+  }
+  /**
+  * Disposes of the storage adapter, releasing any held resources.
+  *
+  * @returns A promise that resolves when the disposal is complete.
+  */
+  dispose() {
+    return Promise.resolve();
+  }
+  /**
+  * Async dispose method to clean up resources.
+  *
+  * @returns A promise that resolves when disposal is complete.
+  */
+  async [Symbol.asyncDispose]() {
+    return this._dispose();
+  }
+  /**
+  * Resolves a given key to its full path within the storage adapter.
+  *
+  * @param key - The key to resolve.
+  * @returns The resolved full path for the key.
+  */
+  resolve(key = this.options.base) {
+    if (/\.\.:|\.\.$/.test(key)) {
+      throw new Error(`[${this.name}]: Invalid key: ${JSON.stringify(key)} provided to storage adapter.`);
+    }
+    return append.appendPath(correctPath.correctPath(key).replace(/:/g, "/"), this.options.base);
+  }
+  /**
+  * Disposes of the storage adapter, releasing any held resources.
+  *
+  * @returns A promise that resolves when the disposal is complete.
+  */
+  async _dispose() {
+    if (!this.#isDisposed) {
+      await Promise.resolve(this.dispose());
+      this.#isDisposed = true;
+    }
+  }
+};
+
+// ../powerlines/src/lib/fs/storage/file-system.ts
+var FileSystemStorageAdapter = class extends BaseStorageAdapter {
+  static {
+    chunkSHUYVCID_js.__name(this, "FileSystemStorageAdapter");
+  }
+  /**
+  * A name identifying the storage adapter type.
+  */
+  name = "file-system";
+  /**
+  * Constructor for the FileSystemStorageAdapter.
+  *
+  * @param options - Configuration options for the storage adapter.
+  */
+  constructor(options) {
+    super(options);
+  }
+  /**
+  * Synchronously checks if a key exists in the storage.
+  *
+  * @param key - The key to check for existence.
+  * @returns Returns `true` if the key exists, otherwise `false`.
+  */
+  existsSync(key) {
+    return exists.existsSync(this.resolve(key));
+  }
+  /**
+  * Asynchronously checks if a key exists in the storage.
+  *
+  * @param key - The key to check for existence.
+  * @returns A promise that resolves to `true` if the key exists, otherwise `false`.
+  */
+  async exists(key) {
+    return exists.exists(this.resolve(key));
+  }
+  /**
+  * Synchronously retrieves the value associated with a given key.
+  *
+  * @param key - The key whose value is to be retrieved.
+  * @returns The value associated with the key, or `null` if the key does not exist.
+  */
+  getSync(key) {
+    return readFile.readFileSync(this.resolve(key));
+  }
+  /**
+  * Asynchronously retrieves the value associated with a given key.
+  *
+  * @param key - The key whose value is to be retrieved.
+  * @returns A promise that resolves to the value associated with the key, or `null` if the key does not exist.
+  */
+  async get(key) {
+    return readFile.readFile(this.resolve(key));
+  }
+  /**
+  * Synchronously sets the value for a given key.
+  *
+  * @param key - The key to set the value for.
+  * @param value - The value to set.
+  */
+  setSync(key, value) {
+    if (!this.options.isReadOnly) {
+      return writeFile$1.writeFileSync(this.resolve(key), value);
+    }
+  }
+  /**
+  * Asynchronously sets the value for a given key.
+  *
+  * @param key - The key to set the value for.
+  * @param value - The value to set.
+  */
+  async set(key, value) {
+    if (!this.options.isReadOnly) {
+      return writeFile$1.writeFile(this.resolve(key), value);
+    }
+  }
+  /**
+  * Synchronously removes a key from the storage.
+  *
+  * @param key - The key to remove.
+  */
+  removeSync(key) {
+    if (!this.options.isReadOnly) {
+      try {
+        return fs.unlinkSync(this.resolve(key));
+      } catch (err) {
+        return ignoreNotfound(err);
       }
     }
   }
   /**
-  * Select the file system module to use for the operation based on the path or URL.
+  * Asynchronously removes a key from the storage.
   *
-  * @param pathOrUrl - The path to perform the file system operation on.
-  * @param options - Options for the operation, such as output mode.
-  * @returns The file system module used for the operation.
+  * @param key - The key to remove.
   */
-  resolveFS(pathOrUrl, options = {}) {
-    const mode = this.resolveMode(pathOrUrl, options);
-    if (mode === "virtual") {
-      return {
-        ...this.#virtualFS,
-        mode: "virtual"
-      };
-    } else if (mode === "fs") {
-      return {
-        ...this.#physicalFS,
-        mode: "fs"
-      };
+  async remove(key) {
+    if (!this.options.isReadOnly) {
+      return promises.unlink(this.resolve(key)).catch(ignoreNotfound);
     }
-    return {
-      ...this,
-      mode: this.#context.config.output.mode
-    };
   }
   /**
-  * Select the file system module to use for the operation based on the path or URL.
+  * Lists all keys under a given base path synchronously.
+  *
+  * @param base - The base path to list keys from.
+  * @returns An array of keys under the specified base path.
+  */
+  listSync(base) {
+    try {
+      return listFiles.listFilesSync(this.resolve(base), {
+        ignore: this.options.ignore
+      });
+    } catch (err) {
+      return ignoreNotfound(err) ?? [];
+    }
+  }
+  /**
+  * Asynchronously lists all keys under a given base path.
+  *
+  * @param base - The base path to list keys from.
+  * @returns A promise that resolves to an array of keys under the specified base path.
+  */
+  async list(base) {
+    return listFiles.listFiles(this.resolve(base), {
+      ignore: this.options.ignore
+    }).catch(ignoreNotfound).then((r) => r || []);
+  }
+};
+var VirtualStorageAdapter = class extends BaseStorageAdapter {
+  static {
+    chunkSHUYVCID_js.__name(this, "VirtualStorageAdapter");
+  }
+  /**
+  * A name identifying the storage adapter type.
+  */
+  name = "virtual";
+  /**
+  * In-memory data storage.
+  */
+  data = /* @__PURE__ */ new Map();
+  /**
+  * Constructor for the VirtualStorageAdapter.
+  *
+  * @param options - Configuration options for the storage adapter.
+  */
+  constructor(options) {
+    super(options);
+  }
+  /**
+  * Synchronously checks if a key exists in the storage.
   *
-  * @param pathOrUrl - The path to perform the file system operation on.
-  * @param options - Options for the operation, such as output mode.
-  * @returns The file system module used for the operation.
+  * @param key - The key to check for existence.
+  * @returns Returns `true` if the key exists, otherwise `false`.
   */
-  resolveMode(pathOrUrl, options = {}) {
-    if (options.mode === "virtual" && this.#context.config.output.mode !== "fs" && isParentPath.isParentPath(toFilePath(pathOrUrl), this.#context.artifactsPath)) {
-      return "virtual";
-    } else if (options.mode === "fs" || this.#context.config.output.mode === "fs" || isParentPath.isParentPath(toFilePath(pathOrUrl), this.#context.dataPath) || isParentPath.isParentPath(toFilePath(pathOrUrl), this.#context.cachePath) || isParentPath.isParentPath(toFilePath(pathOrUrl), join.joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.output.distPath))) {
-      return "fs";
+  existsSync(key) {
+    return this.data.has(this.resolve(key));
+  }
+  /**
+  * Synchronously retrieves the value associated with a given key.
+  *
+  * @param key - The key whose value is to be retrieved.
+  * @returns The value associated with the key, or `null` if the key does not exist.
+  */
+  getSync(key) {
+    return this.data.get(this.resolve(key)) ?? null;
+  }
+  /**
+  * Synchronously sets the value for a given key.
+  *
+  * @param key - The key to set the value for.
+  * @param value - The value to set.
+  */
+  setSync(key, value) {
+    if (!this.options.isReadOnly) {
+      this.data.set(this.resolve(key), value);
     }
-    return void 0;
   }
   /**
-  * Serializes the virtual file system (VFS) to a JSON object.
+  * Synchronously removes a key from the storage.
   *
-  * @returns A JSON representation of the virtual file system.
+  * @param key - The key to remove.
   */
-  toJSON() {
-    return this.#virtualFS.toJSON();
+  removeSync(key) {
+    if (!this.options.isReadOnly) {
+      this.data.delete(this.resolve(key));
+    }
+  }
+  /**
+  * Lists all keys under a given base path synchronously.
+  *
+  * @param base - The base path to list keys from.
+  * @returns An array of keys under the specified base path.
+  */
+  listSync(base) {
+    return [
+      ...this.data.keys().filter((key) => !base ? true : isParentPath.isParentPath(key, this.resolve(base)))
+    ];
+  }
+  /**
+  * Disposes of the storage adapter, releasing any held resources.
+  *
+  * @returns A promise that resolves when the disposal is complete.
+  */
+  async dispose() {
+    return this.clear();
   }
 };
 
@@ -1367,29 +1518,23 @@ var VirtualFileSystem = class _VirtualFileSystem {
   */
   #paths;
   /**
-  * A cache for module resolution results.
-  */
-  #resolverCache;
-  /**
   * The unified volume that combines the virtual file system with the real file system.
   *
   * @remarks
   * This volume allows for seamless access to both virtual and real files.
   */
-  #unifiedFS;
+  #storage = {
+    "": new FileSystemStorageAdapter()
+  };
   /**
-  * Indicator specifying if the file system module is patched
+  * A cache for module resolution results.
   */
-  #isPatched = false;
+  #resolverCache;
   /**
   * Indicator specifying if the virtual file system (VFS) is disposed
   */
   #isDisposed = false;
   /**
-  * Function to revert require patch
-  */
-  #revert;
-  /**
   * The context of the virtual file system.
   */
   #context;
@@ -1398,15 +1543,6 @@ var VirtualFileSystem = class _VirtualFileSystem {
   */
   #log;
   /**
-  * Checks if a path exists in the virtual file system (VFS).
-  *
-  * @param path - The path to check.
-  * @returns `true` if the path exists, otherwise `false`.
-  */
-  #existsSync(path) {
-    return this.#unifiedFS.virtual.existsSync(this.#normalizePath(path)) || this.#unifiedFS.physical.existsSync(this.#normalizePath(path)) || this.#unifiedFS.resolveFS(path).existsSync(this.#normalizePath(path));
-  }
-  /**
   * Normalizes a given module id by resolving it against the built-ins path.
   *
   * @param id - The module id to normalize.
@@ -1435,6 +1571,43 @@ var VirtualFileSystem = class _VirtualFileSystem {
     return new RegExp(`^${this.#normalizePath(path).replace(/\*\*/g, token).replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(new RegExp(token, "g"), ".*")}$`);
   }
   /**
+  * Gets the storage adapter and relative key for a given key.
+  *
+  * @param key - The key to get the storage adapter for.
+  * @returns The storage adapter and relative key for the given key.
+  */
+  #getStorage(key) {
+    const path = this.resolveSync(this.#normalizePath(key)) || key;
+    for (const base of Object.keys(this.#storage).filter(Boolean).sort().reverse()) {
+      if (isParentPath.isParentPath(path, base)) {
+        return {
+          base,
+          relativeKey: replace.replacePath(path, base),
+          adapter: this.#storage[base]
+        };
+      }
+    }
+    return {
+      base: "",
+      relativeKey: path,
+      adapter: this.#storage[""]
+    };
+  }
+  /**
+  * Gets all storage adapters that match a given base key.
+  *
+  * @param base - The base key to match storage adapters against.
+  * @param includeParent - Whether to include parent storage adapters.
+  * @returns An array of storage adapters that match the given base key.
+  */
+  #getStorages(base = "", includeParent = false) {
+    return Object.keys(this.#storage).sort().reverse().filter((key) => isParentPath.isParentPath(key, base) || includeParent && isParentPath.isParentPath(base, key)).map((key) => ({
+      relativeBase: base.length > key.length ? base.slice(key.length) : void 0,
+      base: key,
+      adapter: this.#storage[key]
+    }));
+  }
+  /**
   * Creates a virtual file system (VFS) that is backed up to a Cap'n Proto message buffer.
   *
   * @param context - The context of the virtual file system, typically containing options and logging functions.
@@ -1444,7 +1617,13 @@ var VirtualFileSystem = class _VirtualFileSystem {
     if (!context.config.skipCache && exists.existsSync(joinPaths.joinPaths(context.dataPath, "fs.bin"))) {
       const buffer$1 = await buffer.readFileBuffer(joinPaths.joinPaths(context.dataPath, "fs.bin"));
       const message2 = new $__namespace.Message(buffer$1, false);
-      return new _VirtualFileSystem(context, message2.getRoot(FileSystem));
+      const fs = message2.getRoot(FileSystem);
+      const result = new _VirtualFileSystem(context, fs);
+      if (fs._hasStorage() && fs.storage.length > 0) {
+        await Promise.all(fs.storage.values().map(async (file) => {
+          await result.write(file.path, file.code);
+        }));
+      }
     }
     const message = new $__namespace.Message();
     return new _VirtualFileSystem(context, message.initRoot(FileSystem));
@@ -1459,7 +1638,13 @@ var VirtualFileSystem = class _VirtualFileSystem {
     if (!context.config.skipCache && exists.existsSync(joinPaths.joinPaths(context.dataPath, "fs.bin"))) {
       const buffer$1 = buffer.readFileBufferSync(joinPaths.joinPaths(context.dataPath, "fs.bin"));
       const message2 = new $__namespace.Message(buffer$1, false);
-      return new _VirtualFileSystem(context, message2.getRoot(FileSystem));
+      const fs = message2.getRoot(FileSystem);
+      const result = new _VirtualFileSystem(context, fs);
+      if (fs._hasStorage() && fs.storage.length > 0) {
+        fs.storage.values().map((file) => {
+          result.writeSync(file.path, file.code);
+        });
+      }
     }
     const message = new $__namespace.Message();
     return new _VirtualFileSystem(context, message.initRoot(FileSystem));
@@ -1494,6 +1679,9 @@ var VirtualFileSystem = class _VirtualFileSystem {
       }, "get")
     });
   }
+  /**
+  * Gets the resolver cache.
+  */
   get resolverCache() {
     if (!this.#resolverCache) {
       this.#resolverCache = flatCache.create({
@@ -1512,16 +1700,34 @@ var VirtualFileSystem = class _VirtualFileSystem {
   * @param context - The context of the virtual file system, typically containing options and logging functions.
   * @param fs - A buffer containing the serialized virtual file system data.
   */
-  constructor(context, fs2) {
+  constructor(context, fs) {
     this.#context = context;
-    this.#unifiedFS = UnifiedFS.create(context, fs2);
+    if (isSetObject.isSetObject(this.#context.config.output.storage)) {
+      this.#storage = {
+        ...this.#storage,
+        ...this.#context.config.output.storage
+      };
+    }
+    this.#storage.virtual ??= new VirtualStorageAdapter({
+      base: "/_virtual"
+    });
+    if (this.#context.config.output.storage !== StoragePreset.FS) {
+      this.#storage[this.#context.artifactsPath] ??= new VirtualStorageAdapter({
+        base: this.#context.artifactsPath
+      });
+      this.#storage[this.#context.builtinsPath] ??= new VirtualStorageAdapter({
+        base: this.#context.builtinsPath
+      });
+      this.#storage[this.#context.entryPath] ??= new VirtualStorageAdapter({
+        base: this.#context.entryPath
+      });
+    }
     this.#metadata = {};
-    if (fs2._hasMetadata()) {
-      this.#metadata = fs2.metadata.values().reduce((ret, metadata) => {
+    if (fs._hasMetadata()) {
+      this.#metadata = fs.metadata.values().reduce((ret, metadata) => {
         ret[metadata.id] = {
           id: metadata.id,
           type: metadata.type,
-          mode: metadata.mode,
           timestamp: metadata.timestamp || Date.now(),
           properties: metadata._hasProperties() ? metadata.properties.values().reduce((ret2, item) => {
             ret2[item.key] = item.value;
@@ -1533,12 +1739,12 @@ var VirtualFileSystem = class _VirtualFileSystem {
     }
     this.#ids = {};
     this.#paths = {};
-    if (fs2._hasIds()) {
-      this.#ids = fs2.ids.values().reduce((ret, identifier) => {
+    if (fs._hasIds()) {
+      this.#ids = fs.ids.values().reduce((ret, identifier) => {
         ret[identifier.path] ??= identifier.id;
         return ret;
       }, {});
-      this.#paths = fs2.ids.values().reduce((ret, identifier) => {
+      this.#paths = fs.ids.values().reduce((ret, identifier) => {
         ret[identifier.id] ??= identifier.path;
         return ret;
       }, {});
@@ -1546,187 +1752,123 @@ var VirtualFileSystem = class _VirtualFileSystem {
     this.#log = extendLog(this.#context.log, "file-system");
   }
   /**
-  * Check if a path or id corresponds to a virtual file **(does not actually exists on disk)**.
-  *
-  * @param pathOrId - The path or id to check.
-  * @returns Whether the path or id corresponds to a virtual file **(does not actually exists on disk)**.
-  */
-  isVirtual(pathOrId, importer, options = {}) {
-    if (!pathOrId) {
-      return false;
-    }
-    const resolvedPath = this.resolveSync(pathOrId, importer, options);
-    if (!resolvedPath) {
-      return false;
-    }
-    return this.metadata[resolvedPath]?.mode === "virtual";
-  }
-  /**
-  * Check if a path or id corresponds to a file written to the file system **(actually exists on disk)**.
-  *
-  * @param pathOrId - The path or id to check.
-  * @returns Whether the path or id corresponds to a file written to the file system **(actually exists on disk)**.
-  */
-  isPhysical(pathOrId, importer, options = {}) {
-    if (!pathOrId) {
-      return false;
-    }
-    const resolvedPath = this.resolveSync(pathOrId, importer, options);
-    if (!resolvedPath) {
-      return false;
-    }
-    return this.metadata[resolvedPath]?.mode === "fs";
-  }
-  /**
-  * Lists files in a given path.
-  *
-  * @param path - The path to list files from.
-  * @param options - Options for listing files, such as encoding and recursion.
-  * @returns An array of file names in the specified path.
-  */
-  readdirSync(path, options = "utf8") {
-    return this.#unifiedFS.resolveFS(path).readdirSync(toFilePath(path), options);
-  }
-  /**
-  * Removes a file in the virtual file system (VFS).
+  * Asynchronously checks if a file exists in the virtual file system (VFS).
   *
-  * @param path - The path to create the directory at.
+  * @param path - The path to the file.
+  * @returns A promise that resolves to `true` if the file exists, otherwise `false`.
   */
-  unlinkSync(path, options) {
-    if (!this.isFile(this.#normalizePath(path))) {
-      return;
-    }
-    this.#log(types.LogLevelLabel.TRACE, `Synchronously removing file: ${this.#normalizePath(path)}`);
-    this.#unifiedFS.resolveFS(path, options).unlinkSync(this.#normalizePath(path));
-    if (this.#ids[this.#normalizePath(path)] && this.#metadata[this.#ids[this.#normalizePath(path)]]) {
-      delete this.#metadata[this.#ids[this.#normalizePath(path)]];
-      delete this.#ids[this.#normalizePath(path)];
-      delete this.#paths[this.#normalizeId(path)];
-      this.#resolverCache.delete(this.#normalizePath(path));
-    }
+  async exists(path) {
+    const { relativeKey, adapter } = this.#getStorage(path);
+    return adapter.exists(relativeKey);
   }
   /**
-  * Removes a file in the virtual file system (VFS).
-  *
-  * @param path - The path to create the directory at.
-  */
-  async unlink(path, options) {
-    if (!this.isFile(this.#normalizePath(path))) {
-      return;
-    }
-    this.#log(types.LogLevelLabel.TRACE, `Removing file: ${this.#normalizePath(path)}`);
-    if (isFunction.isFunction(this.#unifiedFS.resolveFS(path, options).promises.unlink)) {
-      await this.#unifiedFS.resolveFS(path, options).promises.unlink(this.#normalizePath(path));
-      if (this.#ids[this.#normalizePath(path)] && this.#metadata[this.#ids[this.#normalizePath(path)]]) {
-        delete this.#metadata[this.#ids[this.#normalizePath(path)]];
-      }
-    } else {
-      this.unlinkSync(this.#normalizePath(path), options);
-    }
-  }
-  /**
-  * Removes a directory in the virtual file system (VFS).
+  * Synchronously checks if a file exists in the virtual file system (VFS).
   *
-  * @param path - The path to create the directory at.
-  * @param options - Options for creating the directory.
+  * @param path - The path to the file.
+  * @returns `true` if the file exists, otherwise `false`.
   */
-  rmdirSync(path, options = {}) {
-    if (!this.isDirectory(this.#normalizePath(path))) {
-      return;
-    }
-    this.#log(types.LogLevelLabel.TRACE, `Synchronously removing directory: ${this.#normalizePath(path)}`);
-    this.#unifiedFS.resolveFS(path, options).rmdirSync(this.#normalizePath(path), defu5__default.default(options, {
-      recursive: true
-    }));
+  existsSync(path) {
+    const { relativeKey, adapter } = this.#getStorage(path);
+    return adapter.existsSync(relativeKey);
   }
   /**
-  * Removes a directory in the virtual file system (VFS).
+  * Checks if a file is virtual in the virtual file system (VFS).
   *
-  * @param path - The path to create the directory at.
-  * @param options - Options for creating the directory.
-  * @returns A promise that resolves to the path of the created directory, or undefined if the directory could not be created.
+  * @param path - The path to the file.
+  * @returns `true` if the file is virtual, otherwise `false`.
   */
-  async rmdir(path, options = {}) {
-    if (!this.isDirectory(this.#normalizePath(path))) {
-      return;
-    }
-    this.#log(types.LogLevelLabel.TRACE, `Removing directory: ${this.#normalizePath(path)}`);
-    if (isFunction.isFunction(this.#unifiedFS.resolveFS(path, options).promises.rm)) {
-      await this.#unifiedFS.resolveFS(path, options).promises.rm(this.#normalizePath(path), defu5__default.default(options, {
-        force: true,
-        recursive: true
-      }));
-    } else {
-      this.rmdirSync(this.#normalizePath(path), defu5__default.default(options ?? {}, {
-        force: true,
-        recursive: true
-      }));
+  isVirtual(path) {
+    const resolved = this.resolveSync(path);
+    if (!resolved) {
+      return false;
     }
+    return this.#getStorage(resolved)?.adapter?.name === "virtual";
   }
   /**
-  * Removes a file in the virtual file system (VFS).
+  * Lists files in a given path.
   *
-  * @param path - The path to the file to remove.
-  * @param options - Options for removing the file.
-  * @returns A promise that resolves when the file is removed.
+  * @param path - The path to list files from.
+  * @returns An array of file names in the specified path.
   */
-  async rm(path, options = {}) {
-    this.#log(types.LogLevelLabel.TRACE, `Removing: ${this.#normalizePath(path)}`);
-    if (this.isDirectory(this.#normalizePath(path))) {
-      return this.rmdir(this.#normalizePath(path), options);
+  listSync(path) {
+    let maskedMounts = [];
+    const allKeys = [];
+    for (const storage of this.#getStorages(path, true)) {
+      for (const key of storage.adapter.listSync(storage.relativeBase)) {
+        if (!maskedMounts.some((p) => `${storage.base}${normalizeKey(key)}`.startsWith(p))) {
+          allKeys.push(`${storage.base}${normalizeKey(key)}`);
+        }
+      }
+      maskedMounts = [
+        storage.base,
+        ...maskedMounts.filter((p) => !p.startsWith(storage.base))
+      ];
     }
-    return this.unlink(this.#normalizePath(path), options);
+    return allKeys.filter((key) => filterKeyByBase(key, path));
   }
   /**
-  * Synchronously removes a file or directory in the virtual file system (VFS).
+  * Lists files in a given path.
   *
-  * @param path - The path to the file or directory to remove.
-  * @param options - Options for removing the file or directory.
+  * @param path - The path to list files from.
+  * @returns An array of file names in the specified path.
   */
-  rmSync(path, options = {}) {
-    this.#log(types.LogLevelLabel.TRACE, `Removing: ${this.#normalizePath(path)}`);
-    if (this.isDirectory(this.#normalizePath(path))) {
-      return this.rmdirSync(this.#normalizePath(path), options);
+  async list(path) {
+    let maskedMounts = [];
+    const allKeys = [];
+    for (const storage of this.#getStorages(path, true)) {
+      for (const key of await storage.adapter.list(storage.relativeBase)) {
+        if (!maskedMounts.some((p) => `${storage.base}${normalizeKey(key)}`.startsWith(p))) {
+          allKeys.push(`${storage.base}${normalizeKey(key)}`);
+        }
+      }
+      maskedMounts = [
+        storage.base,
+        ...maskedMounts.filter((p) => !p.startsWith(storage.base))
+      ];
     }
-    return this.unlinkSync(this.#normalizePath(path), options);
+    return allKeys.filter((key) => filterKeyByBase(key, path));
   }
   /**
-  * Creates a directory in the virtual file system (VFS).
+  * Removes a file in the virtual file system (VFS).
   *
   * @param path - The path to create the directory at.
-  * @param options - Options for creating the directory.
-  * @returns A promise that resolves to the path of the created directory, or undefined if the directory could not be created.
-  */
-  mkdirSync(path, options = {}) {
-    return this.#unifiedFS.resolveFS(this.#normalizePath(path), options).mkdirSync(this.#normalizePath(path), defu5__default.default(omit.omit(options, [
-      "mode"
-    ]), {
-      recursive: true
-    }));
+  */
+  async remove(path) {
+    const normalizedPath = this.#normalizePath(path);
+    this.#log(types.LogLevelLabel.TRACE, `Removing file: ${normalizedPath}`);
+    const { relativeKey, adapter } = this.#getStorage(normalizedPath);
+    if (filePathFns.hasFileExtension(normalizedPath)) {
+      await adapter.remove(relativeKey);
+    } else {
+      await adapter.clear(relativeKey);
+    }
+    const id = this.#ids[normalizedPath];
+    if (id && this.#metadata[id]) {
+      delete this.#metadata[id];
+      delete this.#ids[normalizedPath];
+      delete this.#paths[id];
+    }
   }
   /**
-  * Creates a directory in the virtual file system (VFS).
+  * Removes a file in the virtual file system (VFS).
   *
   * @param path - The path to create the directory at.
-  * @param options - Options for creating the directory.
-  * @returns A promise that resolves to the path of the created directory, or undefined if the directory could not be created.
   */
-  async mkdir(path, options = {}) {
-    let result;
-    if (isFunction.isFunction(this.#unifiedFS.resolveFS(this.#normalizePath(path), options).promises.mkdir)) {
-      result = await this.#unifiedFS.resolveFS(this.#normalizePath(path), options).promises.mkdir(this.#normalizePath(path), defu5__default.default(omit.omit(options, [
-        "mode"
-      ]), {
-        recursive: true
-      }));
+  removeSync(path) {
+    const normalizedPath = this.#normalizePath(path);
+    this.#log(types.LogLevelLabel.TRACE, `Removing file: ${normalizedPath}`);
+    const { relativeKey, adapter } = this.#getStorage(normalizedPath);
+    if (filePathFns.hasFileExtension(normalizedPath)) {
+      adapter.removeSync(relativeKey);
     } else {
-      result = this.#unifiedFS.resolveFS(this.#normalizePath(path), options).mkdirSync(this.#normalizePath(path), defu5__default.default(omit.omit(options, [
-        "mode"
-      ]), {
-        recursive: true
-      }));
+      adapter.clearSync(relativeKey);
+    }
+    const id = this.#ids[normalizedPath];
+    if (id && this.#metadata[id]) {
+      delete this.#metadata[id];
+      delete this.#ids[normalizedPath];
+      delete this.#paths[id];
     }
-    return result;
   }
   /**
   * Glob files in the virtual file system (VFS) based on the provided pattern(s).
@@ -1748,38 +1890,14 @@ var VirtualFileSystem = class _VirtualFileSystem {
       const absPattern = isType.isAbsolutePath(normalized) ? normalized : this.#normalizePath(joinPaths.joinPaths(this.#context.workspaceConfig.workspaceRoot, normalized));
       const firstGlobIdx = absPattern.search(/[*?[\]{}]/);
       const baseDir = firstGlobIdx === -1 ? filePathFns.findFilePath(absPattern) : absPattern.slice(0, Math.max(0, absPattern.lastIndexOf("/", firstGlobIdx)));
-      const stack = [
-        baseDir && isType.isAbsolutePath(baseDir) ? baseDir : this.#context.workspaceConfig.workspaceRoot
-      ];
-      while (stack.length) {
-        const dir = stack.pop();
-        let entries = [];
-        try {
-          entries = await this.readdir(dir);
-        } catch {
-          continue;
-        }
-        for (const entry of entries) {
-          const full = this.#normalizePath(joinPaths.joinPaths(dir, entry));
-          let stats;
-          try {
-            stats = this.#unifiedFS.lstatSync(full);
-          } catch {
-            stats = void 0;
-          }
-          if (!stats) continue;
-          if (stats.isDirectory()) {
-            stack.push(full);
-          } else if (stats.isFile()) {
-            if (this.#buildRegex(absPattern).test(full)) {
-              const resolved = this.resolveSync(full);
-              if (resolved && !results.includes(resolved)) {
-                results.push(resolved);
-              }
-            }
+      await Promise.all((await this.list(baseDir && isType.isAbsolutePath(baseDir) ? baseDir : this.#context.workspaceConfig.workspaceRoot)).map(async (file) => {
+        if (this.#buildRegex(absPattern).test(file)) {
+          const resolved = this.resolveSync(file);
+          if (resolved && !results.includes(resolved)) {
+            results.push(resolved);
           }
         }
-      }
+      }));
     }
     return results;
   }
@@ -1803,35 +1921,12 @@ var VirtualFileSystem = class _VirtualFileSystem {
       const absPattern = isType.isAbsolutePath(normalized) ? normalized : this.#normalizePath(joinPaths.joinPaths(this.#context.workspaceConfig.workspaceRoot, normalized));
       const firstGlobIdx = absPattern.search(/[*?[\]{}]/);
       const baseDir = firstGlobIdx === -1 ? filePathFns.findFilePath(absPattern) : absPattern.slice(0, Math.max(0, absPattern.lastIndexOf("/", firstGlobIdx)));
-      const stack = [
-        baseDir && isType.isAbsolutePath(baseDir) ? baseDir : this.#context.workspaceConfig.workspaceRoot
-      ];
-      while (stack.length) {
-        const dir = stack.pop();
-        let entries = [];
-        try {
-          entries = this.readdirSync(dir);
-        } catch {
-          continue;
-        }
-        for (const entry of entries) {
-          const full = this.#normalizePath(joinPaths.joinPaths(dir, entry));
-          let stats;
-          try {
-            stats = this.#unifiedFS.lstatSync(full);
-          } catch {
-            stats = void 0;
-          }
-          if (!stats) continue;
-          if (stats.isDirectory()) {
-            stack.push(full);
-          } else if (stats.isFile()) {
-            if (this.#buildRegex(absPattern).test(full)) {
-              const resolved = this.resolveSync(full);
-              if (resolved && !results.includes(resolved)) {
-                results.push(resolved);
-              }
-            }
+      const files = this.listSync(baseDir && isType.isAbsolutePath(baseDir) ? baseDir : this.#context.workspaceConfig.workspaceRoot);
+      for (const file of files) {
+        if (this.#buildRegex(absPattern).test(file)) {
+          const resolved = this.resolveSync(file);
+          if (resolved && !results.includes(resolved)) {
+            results.push(resolved);
           }
         }
       }
@@ -1839,36 +1934,27 @@ var VirtualFileSystem = class _VirtualFileSystem {
     return results;
   }
   /**
-  * Moves a file from one path to another in the virtual file system (VFS).
-  *
-  * @param srcPath - The source path to move
-  * @param destPath - The destination path to move to
-  */
-  async move(srcPath, destPath) {
-    const content = await this.readFile(srcPath);
-    await this.writeFile(destPath, content);
-    await this.rm(srcPath);
-  }
-  /**
-  * Synchronously moves a file from one path to another in the virtual file system (VFS).
-  *
-  * @param srcPath - The source path to move
-  * @param destPath - The destination path to move to
-  */
-  moveSync(srcPath, destPath) {
-    const content = this.readFileSync(srcPath);
-    this.writeFileSync(destPath, content);
-    this.rmSync(srcPath);
-  }
-  /**
   * Copies a file from one path to another in the virtual file system (VFS).
   *
   * @param srcPath - The source path to copy
   * @param destPath - The destination path to copy to
   */
   async copy(srcPath, destPath) {
-    const content = await this.readFile(srcPath);
-    await this.writeFile(destPath, content);
+    if (filePathFns.hasFileExtension(srcPath)) {
+      const content = await this.read(srcPath);
+      if (content !== void 0) {
+        await this.write(filePathFns.hasFileExtension(destPath) ? destPath : joinPaths.joinPaths(destPath, filePathFns.findFileName(srcPath)), content);
+      }
+    } else {
+      await Promise.all((await this.list(srcPath)).map(async (file) => {
+        const relativePath2 = file.replace(this.#normalizePath(srcPath), "");
+        const destinationPath = this.#normalizePath(append.appendPath(destPath, relativePath2));
+        const content = await this.read(file);
+        if (content !== void 0) {
+          await this.write(destinationPath, content);
+        }
+      }));
+    }
   }
   /**
   * Synchronously copies a file from one path to another in the virtual file system (VFS).
@@ -1877,51 +1963,85 @@ var VirtualFileSystem = class _VirtualFileSystem {
   * @param destPath - The destination path to copy to
   */
   copySync(srcPath, destPath) {
-    const content = this.readFileSync(srcPath);
-    this.writeFileSync(destPath, content);
+    if (filePathFns.hasFileExtension(srcPath)) {
+      const content = this.readSync(srcPath);
+      if (content !== void 0) {
+        this.writeSync(filePathFns.hasFileExtension(destPath) ? destPath : joinPaths.joinPaths(destPath, filePathFns.findFileName(srcPath)), content);
+      }
+    } else {
+      this.listSync(srcPath).forEach((file) => {
+        const relativePath2 = file.replace(this.#normalizePath(srcPath), "");
+        const destinationPath = this.#normalizePath(append.appendPath(destPath, relativePath2));
+        const content = this.readSync(file);
+        if (content !== void 0) {
+          this.writeSync(destinationPath, content);
+        }
+      });
+    }
   }
   /**
-  * Lists files in a given path.
+  * Moves a file (or files) from one path to another in the virtual file system (VFS).
   *
-  * @param pathOrId - The path to list files from.
-  * @param options - Options for listing files, such as encoding and recursion.
-  * @returns An array of file names in the specified path.
+  * @param srcPath - The source path to move
+  * @param destPath - The destination path to move to
+  */
+  async move(srcPath, destPath) {
+    if (filePathFns.hasFileExtension(srcPath)) {
+      await this.copy(srcPath, destPath);
+      await this.remove(srcPath);
+    } else {
+      await Promise.all((await this.list(srcPath)).map(async (file) => {
+        await this.copy(file, destPath);
+        await this.remove(file);
+      }));
+    }
+  }
+  /**
+  * Synchronously moves a file (or files) from one path to another in the virtual file system (VFS).
+  *
+  * @param srcPath - The source path to move
+  * @param destPath - The destination path to move to
   */
-  async readdir(pathOrId, options = "utf8") {
-    return this.#unifiedFS.resolveFS(pathOrId).promises.readdir(toFilePath(pathOrId), options);
+  moveSync(srcPath, destPath) {
+    if (filePathFns.hasFileExtension(srcPath)) {
+      this.copySync(srcPath, destPath);
+      this.removeSync(srcPath);
+    } else {
+      this.listSync(srcPath).forEach((file) => {
+        this.copySync(file, destPath);
+        this.removeSync(file);
+      });
+    }
   }
   /**
   * Asynchronously reads a file from the virtual file system (VFS).
   *
-  * @param pathOrId - The path or ID of the file to read.
+  * @param path - The path or ID of the file to read.
   * @returns A promise that resolves to the contents of the file as a string, or undefined if the file does not exist.
   */
-  async readFile(pathOrId, options = "utf8") {
-    const filePath = await this.resolve(pathOrId);
-    if (filePath && this.isFile(filePath)) {
-      let result;
-      if (isFunction.isFunction(this.#unifiedFS.resolveFS(filePath).promises.readFile)) {
-        result = (await this.#unifiedFS.resolveFS(filePath).promises.readFile(filePath, options))?.toString("utf8");
-      } else {
-        result = this.#unifiedFS.resolveFS(filePath).readFileSync(filePath, options);
-      }
-      return isBuffer.isBuffer(result) ? bufferToString.bufferToString(result) : result;
+  async read(path) {
+    const filePath = await this.resolve(path);
+    if (!filePath) {
+      return void 0;
     }
-    return void 0;
+    const { relativeKey, adapter } = this.#getStorage(filePath);
+    this.#log(types.LogLevelLabel.TRACE, `Reading ${adapter.name} file: ${filePath}`);
+    return await adapter.get(relativeKey) ?? void 0;
   }
   /**
   * Synchronously reads a file from the virtual file system (VFS).
   *
-  * @param pathOrId - The path or ID of the file to read.
+  * @param path - The path or ID of the file to read.
   * @returns The contents of the file as a string, or undefined if the file does not exist.
   */
-  readFileSync(pathOrId, options = "utf8") {
-    const filePath = this.resolveSync(pathOrId);
-    if (filePath && this.isFile(filePath)) {
-      const result = this.#unifiedFS.resolveFS(filePath).readFileSync(filePath, options);
-      return isBuffer.isBuffer(result) ? bufferToString.bufferToString(result) : result;
+  readSync(path) {
+    const filePath = this.resolveSync(path);
+    if (!filePath) {
+      return void 0;
     }
-    return void 0;
+    const { relativeKey, adapter } = this.#getStorage(filePath);
+    this.#log(types.LogLevelLabel.TRACE, `Reading ${adapter.name} file: ${filePath}`);
+    return adapter.getSync(relativeKey) ?? void 0;
   }
   /**
   * Writes a file to the virtual file system (VFS).
@@ -1931,41 +2051,28 @@ var VirtualFileSystem = class _VirtualFileSystem {
   * @param options - Optional parameters for writing the file.
   * @returns A promise that resolves when the file is written.
   */
-  async writeFile(path, data = "", options = "utf8") {
-    if (!this.isDirectory(filePathFns.findFilePath(this.#normalizePath(path)))) {
-      await this.mkdir(filePathFns.findFilePath(this.#normalizePath(path)), isPowerlinesWriteFileOptions(options) ? options : void 0);
-    }
-    const metadata = isVirtualFileData(data) ? data : {};
-    metadata.id = this.#normalizeId(path);
-    let code = isVirtualFileData(data) ? metadata.code : data;
-    if ((!isPowerlinesWriteFileOptions(options) || !options.skipFormat) && isSetString.isSetString(code)) {
+  async write(path, data = "", options = {}) {
+    let code = data;
+    if (!options.skipFormat) {
       const resolvedConfig = await prettier.resolveConfig(this.#normalizePath(path));
       if (resolvedConfig) {
-        code = await prettier.format(code, {
+        code = await prettier.format(data, {
           absolutePath: this.#normalizePath(path),
           ...resolvedConfig
         });
       }
     }
-    const outputMode = this.#unifiedFS.resolveMode(this.#normalizePath(path), isPowerlinesWriteFileOptions(options) ? options : void 0);
-    this.#log(types.LogLevelLabel.TRACE, `Writing ${this.#normalizePath(path)} file to the ${outputMode === "fs" ? "" : "virtual "}file system (size: ${prettyBytes.prettyBytes(new buffer$1.Blob(toArray.toArray(code)).size)})`);
-    this.#metadata[metadata.id] = {
-      mode: outputMode,
+    const { relativeKey, adapter } = this.#getStorage(path);
+    this.#log(types.LogLevelLabel.TRACE, `Writing ${this.#normalizePath(path)} to ${adapter.name === "virtual" ? "the virtual file system" : adapter.name === "file-system" ? "the local file system" : adapter.name} (size: ${prettyBytes.prettyBytes(new buffer$1.Blob(toArray.toArray(code)).size)})`);
+    const id = options?.meta?.id || this.#normalizeId(path);
+    this.#metadata[id] = {
       variant: "normal",
       timestamp: Date.now(),
-      ...metadata
+      ...options.meta ?? {}
     };
-    this.#paths[metadata.id] = this.#normalizePath(path);
-    this.#ids[this.#normalizePath(path)] = metadata.id;
-    const ifs = this.#unifiedFS.resolveFS(this.#normalizePath(path), isPowerlinesWriteFileOptions(options) ? options : void 0);
-    if (isFunction.isFunction(ifs.promises.writeFile)) {
-      return ifs.promises.writeFile(this.#normalizePath(path), code, isSetObject.isSetObject(options) ? omit.omit(options, [
-        "mode"
-      ]) : "utf8");
-    }
-    return ifs.writeFileSync(this.#normalizePath(path), code, isSetObject.isSetObject(options) ? omit.omit(options, [
-      "mode"
-    ]) : "utf8");
+    this.#paths[id] = this.#normalizePath(path);
+    this.#ids[this.#normalizePath(path)] = id;
+    return adapter.set(relativeKey, code);
   }
   /**
   * Synchronously writes a file to the virtual file system (VFS).
@@ -1974,38 +2081,18 @@ var VirtualFileSystem = class _VirtualFileSystem {
   * @param data - The contents of the file.
   * @param options - Optional parameters for writing the file.
   */
-  writeFileSync(path, data = "", options = "utf8") {
-    if (!this.isDirectory(filePathFns.findFilePath(this.#normalizePath(path)))) {
-      this.mkdirSync(filePathFns.findFilePath(this.#normalizePath(path)), isPowerlinesWriteFileOptions(options) ? options : void 0);
-    }
-    const metadata = isVirtualFileData(data) ? data : {};
-    metadata.id = this.#normalizeId(path);
-    const code = isVirtualFileData(data) ? metadata.code : data;
-    const outputMode = this.#unifiedFS.resolveMode(this.#normalizePath(path), isPowerlinesWriteFileOptions(options) ? options : void 0);
-    this.#log(types.LogLevelLabel.TRACE, `Writing ${this.#normalizePath(path)} file to the ${outputMode === "fs" ? "" : "virtual "}file system (size: ${prettyBytes.prettyBytes(new buffer$1.Blob(toArray.toArray(code)).size)})`);
-    this.#metadata[metadata.id] = {
-      mode: outputMode,
+  writeSync(path, data = "", options = {}) {
+    const { relativeKey, adapter } = this.#getStorage(path);
+    this.#log(types.LogLevelLabel.TRACE, `Writing ${this.#normalizePath(path)} file to ${adapter.name === "virtual" ? "the virtual file system" : adapter.name === "file-system" ? "the local file system" : adapter.name} (size: ${prettyBytes.prettyBytes(new buffer$1.Blob(toArray.toArray(data)).size)})`);
+    const id = options?.meta?.id || this.#normalizeId(path);
+    this.#metadata[id] = {
       variant: "normal",
       timestamp: Date.now(),
-      ...metadata
+      ...options.meta ?? {}
     };
-    this.#paths[metadata.id] = this.#normalizePath(path);
-    this.#ids[this.#normalizePath(path)] = metadata.id;
-    const writeStream = this.#unifiedFS.resolveFS(this.#normalizePath(path), isPowerlinesWriteFileOptions(options) ? options : void 0).createWriteStream(this.#normalizePath(path));
-    try {
-      writeStream.write(code);
-    } finally {
-      writeStream.close();
-    }
-  }
-  /**
-  * Synchronously checks if a file exists in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID of the file to check.
-  * @returns `true` if the file exists, otherwise `false`.
-  */
-  existsSync(pathOrId) {
-    return !!this.resolveSync(pathOrId);
+    this.#paths[id] = this.#normalizePath(path);
+    this.#ids[this.#normalizePath(path)] = id;
+    return adapter.setSync(relativeKey, data);
   }
   /**
   * Retrieves the metadata of a file in the virtual file system (VFS).
@@ -2021,78 +2108,6 @@ var VirtualFileSystem = class _VirtualFileSystem {
     return void 0;
   }
   /**
-  * Checks if a file exists in the virtual file system (VFS).
-  *
-  * @remarks
-  * This is a base method used by {@link existsSync} - it does not try to resolve the path prior to checking if it exists or not.
-  *
-  * @param pathOrId - The path of the file to check.
-  * @returns `true` if the file exists, otherwise `false`.
-  */
-  isFile(pathOrId) {
-    const resolved = this.resolveSync(pathOrId);
-    return !!(resolved && (this.#unifiedFS.virtual.existsSync(resolved) && this.#unifiedFS.virtual.lstatSync(resolved).isFile() || this.#unifiedFS.physical.existsSync(resolved) && this.#unifiedFS.physical.lstatSync(resolved).isFile() || this.#unifiedFS.resolveFS(resolved).existsSync(resolved) && this.#unifiedFS.resolveFS(resolved).lstatSync(resolved).isFile()));
-  }
-  /**
-  * Checks if a directory exists in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path of the directory to check.
-  * @returns `true` if the directory exists, otherwise `false`.
-  */
-  isDirectory(pathOrId) {
-    const resolved = this.resolveSync(pathOrId);
-    return !!(resolved && (this.#unifiedFS.virtual.existsSync(resolved) && this.#unifiedFS.virtual.lstatSync(resolved).isDirectory() || this.#unifiedFS.physical.existsSync(resolved) && this.#unifiedFS.physical.lstatSync(resolved).isDirectory() || this.#unifiedFS.resolveFS(resolved).existsSync(resolved) && this.#unifiedFS.resolveFS(resolved).lstatSync(resolved).isDirectory()));
-  }
-  /**
-  * Retrieves the status of a file in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID of the file to retrieve status for.
-  * @returns A promise that resolves to the file's status information, or false if the file does not exist.
-  */
-  async stat(pathOrId, options) {
-    return this.#unifiedFS.resolveFS(pathOrId).promises.stat(await this.resolve(pathOrId) || pathOrId, options);
-  }
-  /**
-  * Synchronously retrieves the status of a file in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID of the file to retrieve status for.
-  * @returns The file's status information, or false if the file does not exist.
-  */
-  statSync(pathOrId) {
-    return this.#unifiedFS.resolveFS(pathOrId).statSync(this.resolveSync(pathOrId) || pathOrId);
-  }
-  /**
-  * Retrieves the status of a symbolic link in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID of the symbolic link to retrieve status for.
-  * @returns A promise that resolves to the symbolic link's status information, or false if the link does not exist.
-  */
-  async lstat(pathOrId, options) {
-    return this.#unifiedFS.resolveFS(pathOrId).promises.lstat(await this.resolve(pathOrId) || pathOrId, options);
-  }
-  /**
-  * Synchronously retrieves the status of a symbolic link in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID of the symbolic link to retrieve status for.
-  * @returns The symbolic link's status information, or false if the link does not exist.
-  */
-  lstatSync(pathOrId, options) {
-    return this.#unifiedFS.resolveFS(pathOrId).lstatSync(this.resolveSync(pathOrId) || pathOrId, options);
-  }
-  /**
-  * Resolves a path or ID to its real path in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID to resolve.
-  * @returns The resolved real path if it exists, otherwise undefined.
-  */
-  realpathSync(pathOrId) {
-    const filePath = this.resolveSync(pathOrId);
-    if (!filePath) {
-      throw new Error(`File not found: ${pathOrId}`);
-    }
-    return filePath;
-  }
-  /**
   * A helper function to resolve modules in the virtual file system (VFS).
   *
   * @remarks
@@ -2109,9 +2124,15 @@ var VirtualFileSystem = class _VirtualFileSystem {
   * @returns A promise that resolves to the resolved module path.
   */
   async resolve(id, importer, options = {}) {
-    let result = this.resolverCache.get(this.#normalizeId(id));
-    if (result) {
-      return result;
+    if (isType.isAbsolutePath(id)) {
+      return id;
+    }
+    let result;
+    if (!this.#context.config.skipCache) {
+      result = this.resolverCache.get(this.#normalizeId(id));
+      if (result) {
+        return result;
+      }
     }
     result = this.paths[this.#normalizeId(id)];
     if (!result) {
@@ -2126,8 +2147,10 @@ var VirtualFileSystem = class _VirtualFileSystem {
       for (const combination of resolve.getResolutionCombinations(id, {
         paths
       })) {
-        if (this.#existsSync(combination)) {
+        const { relativeKey, adapter } = this.#getStorage(combination);
+        if (await adapter.exists(relativeKey)) {
           result = combination;
+          break;
         }
       }
       try {
@@ -2139,7 +2162,9 @@ var VirtualFileSystem = class _VirtualFileSystem {
     }
     if (result) {
       result = correctPath.toAbsolutePath(append.appendPath(result, this.#context.config.projectRoot), this.#context.workspaceConfig.workspaceRoot);
-      this.resolverCache.set(this.#normalizeId(id), result);
+      if (!this.#context.config.skipCache) {
+        this.resolverCache.set(this.#normalizeId(id), result);
+      }
     }
     return result;
   }
@@ -2160,9 +2185,15 @@ var VirtualFileSystem = class _VirtualFileSystem {
   * @returns The resolved module path.
   */
   resolveSync(id, importer, options = {}) {
-    let result = this.resolverCache.get(this.#normalizeId(id));
-    if (result) {
-      return result;
+    if (isType.isAbsolutePath(id)) {
+      return id;
+    }
+    let result;
+    if (!this.#context.config.skipCache) {
+      result = this.resolverCache.get(this.#normalizeId(id));
+      if (result) {
+        return result;
+      }
     }
     result = this.paths[this.#normalizeId(id)];
     if (!result) {
@@ -2171,14 +2202,16 @@ var VirtualFileSystem = class _VirtualFileSystem {
         paths.push(importer);
       }
       paths.push(this.#context.workspaceConfig.workspaceRoot);
-      paths.push(joinPaths.joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.projectRoot));
-      paths.push(joinPaths.joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.sourceRoot));
-      paths.push(...Object.keys(this.#context.tsconfig?.options?.paths ?? {}).filter((tsconfigPath) => id.startsWith(tsconfigPath.replace(/\*$/, ""))).map((tsconfigPath) => this.#context.tsconfig?.options?.paths?.[tsconfigPath]).flat().filter(Boolean).map((tsconfigPath) => append.appendPath(tsconfigPath, this.#context.workspaceConfig.workspaceRoot)));
+      paths.push(append.appendPath(this.#context.config.projectRoot, this.#context.workspaceConfig.workspaceRoot));
+      paths.push(append.appendPath(this.#context.config.sourceRoot, this.#context.workspaceConfig.workspaceRoot));
+      paths.push(...Object.keys(this.#context.tsconfig.options.paths ?? {}).filter((tsconfigPath) => id.startsWith(tsconfigPath.replace(/\*$/, ""))).map((tsconfigPath) => this.#context.tsconfig.options.paths?.[tsconfigPath]).flat().filter(Boolean).map((tsconfigPath) => append.appendPath(tsconfigPath, this.#context.workspaceConfig.workspaceRoot)));
       for (const combination of resolve.getResolutionCombinations(id, {
         paths
       })) {
-        if (this.#existsSync(combination)) {
+        const { relativeKey, adapter } = this.#getStorage(combination);
+        if (adapter.existsSync(relativeKey)) {
           result = combination;
+          break;
         }
       }
       try {
@@ -2190,7 +2223,9 @@ var VirtualFileSystem = class _VirtualFileSystem {
     }
     if (result) {
       result = correctPath.toAbsolutePath(append.appendPath(result, this.#context.config.projectRoot), this.#context.workspaceConfig.workspaceRoot);
-      this.resolverCache.set(this.#normalizeId(id), result);
+      if (!this.#context.config.skipCache) {
+        this.resolverCache.set(this.#normalizeId(id), result);
+      }
     }
     return result;
   }
@@ -2201,27 +2236,27 @@ var VirtualFileSystem = class _VirtualFileSystem {
     if (!this.#isDisposed) {
       this.#isDisposed = true;
       this.#log(types.LogLevelLabel.DEBUG, "Disposing virtual file system...");
-      await this.unlink(joinPaths.joinPaths(this.#context.dataPath, "fs.bin"));
+      await this.remove(joinPaths.joinPaths(this.#context.dataPath, "fs.bin"));
       const message = new $__namespace.Message();
-      const fs2 = message.initRoot(FileSystem);
-      const virtualFiles = Object.entries(this.#unifiedFS.toJSON()).filter(([, code]) => code);
-      const files = fs2._initFiles(virtualFiles.length);
-      virtualFiles.filter(([, code]) => code).forEach(([path, code], index) => {
-        const fd = files.get(index);
+      const fs = message.initRoot(FileSystem);
+      const paths = await this.list();
+      const storage = fs._initStorage(paths.length);
+      await Promise.all(paths.map(async (path, index) => {
+        const code = await this.read(path);
+        const fd = storage.get(index);
         fd.path = path;
         fd.code = code || "";
-      });
-      const ids = fs2._initIds(Object.keys(this.ids).length);
+      }));
+      const ids = fs._initIds(Object.keys(this.ids).length);
       Object.entries(this.ids).filter(([, path]) => path).forEach(([id, path], index) => {
         const fileId = ids.get(index);
         fileId.id = id;
         fileId.path = path;
       });
-      const metadata = fs2._initMetadata(Object.keys(this.metadata).length);
+      const metadata = fs._initMetadata(Object.keys(this.metadata).length);
       Object.entries(this.metadata).filter(([, value]) => value).forEach(([id, value], index) => {
         const fileMetadata = metadata.get(index);
         fileMetadata.id = id;
-        fileMetadata.mode = value.mode;
         fileMetadata.type = value.type;
         fileMetadata.timestamp = value.timestamp ?? BigInt(Date.now());
         if (value.properties) {
@@ -2234,134 +2269,40 @@ var VirtualFileSystem = class _VirtualFileSystem {
         }
       });
       await buffer.writeFileBuffer(joinPaths.joinPaths(this.#context.dataPath, "fs.bin"), message.toArrayBuffer());
-      this.#resolverCache.save(true);
-      this.#log(types.LogLevelLabel.DEBUG, "Virtual file system disposed.");
-    }
-  }
-  /**
-  * Initializes the virtual file system (VFS) by patching the file system module if necessary.
-  */
-  [__VFS_PATCH__]() {
-    if (!this.#isPatched && this.#context.config.output.mode !== "fs") {
-      this.#revert = patchFS(_fs__default.default, this);
-      this.#isPatched = true;
-    }
-  }
-  /**
-  * Reverts the file system module to its original state if it was previously patched.
-  */
-  [__VFS_REVERT__]() {
-    if (this.#isPatched && this.#context.config.output.mode !== "fs") {
-      if (!this.#revert) {
-        throw new Error("Attempting to revert File System patch prior to calling `__init__` function");
-      }
-      this.#revert?.();
-      this.#isPatched = false;
-    }
-  }
+      if (!this.#context.config.skipCache) {
+        this.#resolverCache.save(true);
+      }
+      await Promise.all(this.#getStorages().map(async (storage2) => storage2.adapter.dispose()));
+      this.#log(types.LogLevelLabel.TRACE, "Virtual file system has been disposed.");
+    }
+  }
+  // /**
+  //  * Initializes the virtual file system (VFS) by patching the file system module if necessary.
+  //  */
+  // public [__VFS_PATCH__]() {
+  //   if (!this.#isPatched && this.#context.config.output.mode !== "fs") {
+  //     this.#revert = patchFS(fs, this);
+  //     this.#isPatched = true;
+  //   }
+  // }
+  // /**
+  //  * Reverts the file system module to its original state if it was previously patched.
+  //  */
+  // public [__VFS_REVERT__]() {
+  //   if (this.#isPatched && this.#context.config.output.mode !== "fs") {
+  //     if (!this.#revert) {
+  //       throw new Error(
+  //         "Attempting to revert File System patch prior to calling `__init__` function"
+  //       );
+  //     }
+  //     this.#revert?.();
+  //     this.#isPatched = false;
+  //   }
+  // }
   async [Symbol.asyncDispose]() {
     return this.dispose();
   }
 };
-var VirtualFileSystemHost = class VirtualFileSystemHost2 extends tsMorph.InMemoryFileSystemHost {
-  static {
-    chunkSHUYVCID_js.__name(this, "VirtualFileSystemHost");
-  }
-  #fs;
-  constructor(fs2) {
-    super();
-    this.#fs = fs2;
-  }
-  deleteSync(path) {
-    this.#fs.rmSync(path);
-  }
-  readDirSync(dirPath) {
-    return this.#fs.readdirSync(dirPath).reduce((ret, entry) => {
-      const fullPath = this.#fs.resolveSync(join.joinPaths(dirPath, entry));
-      if (fullPath) {
-        ret.push({
-          name: entry,
-          isDirectory: this.#fs.isDirectory(fullPath),
-          isFile: this.#fs.isFile(fullPath),
-          isSymlink: false
-        });
-      }
-      return ret;
-    }, []);
-  }
-  async readFile(filePath) {
-    if (!this.#fs.existsSync(filePath)) {
-      throw new Error(`File not found: '${filePath}'. Please check the path and try again.`);
-    }
-    return await this.#fs.readFile(filePath);
-  }
-  readFileSync(filePath) {
-    if (!this.#fs.existsSync(filePath)) {
-      throw new Error(`File not found: '${filePath}'. Please check the path and try again.`);
-    }
-    return this.#fs.readFileSync(filePath);
-  }
-  async writeFile(filePath, fileText) {
-    return this.#fs.writeFile(filePath, fileText);
-  }
-  writeFileSync(filePath, fileText) {
-    this.#fs.writeFileSync(filePath, fileText);
-  }
-  async mkdir(dirPath) {
-    await this.#fs.mkdir(dirPath);
-  }
-  mkdirSync(dirPath) {
-    this.#fs.mkdirSync(dirPath);
-  }
-  async move(srcPath, destPath) {
-    await this.#fs.move(srcPath, destPath);
-  }
-  moveSync(srcPath, destPath) {
-    this.#fs.moveSync(srcPath, destPath);
-  }
-  async copy(srcPath, destPath) {
-    await this.#fs.copy(srcPath, destPath);
-  }
-  copySync(srcPath, destPath) {
-    this.#fs.copySync(srcPath, destPath);
-  }
-  async fileExists(filePath) {
-    return this.#fs.isFile(filePath);
-  }
-  fileExistsSync(filePath) {
-    return this.#fs.isFile(filePath);
-  }
-  async directoryExists(dirPath) {
-    return this.#fs.isDirectory(dirPath);
-  }
-  directoryExistsSync(dirPath) {
-    return this.#fs.isDirectory(dirPath);
-  }
-  realpathSync(path) {
-    return this.#fs.resolveSync(path) || path;
-  }
-  getCurrentDirectory() {
-    return "/";
-  }
-  async glob(patterns) {
-    return this.#fs.glob(patterns);
-  }
-  globSync(patterns) {
-    return this.#fs.globSync(patterns);
-  }
-};
-function createProgram(context, override) {
-  const project = new tsMorph.Project({
-    compilerOptions: {
-      ...context.tsconfig.options
-    },
-    tsConfigFilePath: context.tsconfig.tsconfigFilePath,
-    fileSystem: new VirtualFileSystemHost(context.fs),
-    ...override
-  });
-  return project;
-}
-chunkSHUYVCID_js.__name(createProgram, "createProgram");
 
 // ../powerlines/src/lib/contexts/context.ts
 var configCache = /* @__PURE__ */ new WeakMap();
@@ -2419,7 +2360,7 @@ var PowerlinesContext = class _PowerlinesContext {
   * @returns A promise that resolves to the new context.
   */
   static async from(workspaceRoot, config) {
-    const context = new _PowerlinesContext(await chunk2PYUYDPD_js.loadWorkspaceConfig(workspaceRoot, config.root));
+    const context = new _PowerlinesContext(await chunkDQI2I5KK_js.loadWorkspaceConfig(workspaceRoot, config.root));
     await context.withUserConfig(config);
     context.powerlinesPath = await resolve.resolvePackage("powerlines");
     if (!context.powerlinesPath) {
@@ -2517,10 +2458,10 @@ var PowerlinesContext = class _PowerlinesContext {
         workspaceRoot: this.workspaceConfig?.workspaceRoot,
         projectRoot: this.config?.projectRoot
       }, {
-        maxLength: chunk2PYUYDPD_js.PROJECT_ROOT_HASH_LENGTH
+        maxLength: chunkDQI2I5KK_js.PROJECT_ROOT_HASH_LENGTH
       }),
       configHash: murmurhash.murmurhash(this.config, {
-        maxLength: chunk2PYUYDPD_js.CACHE_HASH_LENGTH
+        maxLength: chunkDQI2I5KK_js.CACHE_HASH_LENGTH
       })
     };
   }
@@ -2562,7 +2503,7 @@ var PowerlinesContext = class _PowerlinesContext {
   * Get the path to the artifacts directory for the project
   */
   get artifactsPath() {
-    return join.joinPaths(this.workspaceConfig.workspaceRoot, this.config.projectRoot, this.config.output.artifactsFolder);
+    return join.joinPaths(this.workspaceConfig.workspaceRoot, this.config.projectRoot, this.config.output.artifactsPath);
   }
   /**
   * Get the path to the builtin modules used by the project
@@ -2580,7 +2521,7 @@ var PowerlinesContext = class _PowerlinesContext {
   * Get the path to the data directory for the project
   */
   get dataPath() {
-    return join.joinPaths(this.envPaths.data, "projects", chunk2PYUYDPD_js.getPrefixedProjectRootHash(this.config.name, this.meta.projectRootHash));
+    return join.joinPaths(this.envPaths.data, "projects", chunkDQI2I5KK_js.getPrefixedProjectRootHash(this.config.name, this.meta.projectRootHash));
   }
   /**
   * Get the path to the cache directory for the project
@@ -2590,7 +2531,7 @@ var PowerlinesContext = class _PowerlinesContext {
       checksum: this.#checksum,
       config: this.meta.configHash
     }, {
-      maxLength: chunk2PYUYDPD_js.CACHE_HASH_LENGTH
+      maxLength: chunkDQI2I5KK_js.CACHE_HASH_LENGTH
     }));
   }
   /**
@@ -2702,7 +2643,7 @@ var PowerlinesContext = class _PowerlinesContext {
     if (!resolvedId) {
       return void 0;
     }
-    const code = await this.fs.readFile(resolvedId);
+    const code = await this.fs.read(resolvedId);
     if (!code) {
       return void 0;
     }
@@ -2716,7 +2657,7 @@ var PowerlinesContext = class _PowerlinesContext {
   */
   async getBuiltins() {
     return Promise.all(Object.entries(this.fs.metadata).filter(([, meta]) => meta && meta.type === "builtin").map(async ([path, meta]) => {
-      const code = await this.fs.readFile(path);
+      const code = await this.fs.read(path);
       return {
         ...meta,
         path,
@@ -2732,11 +2673,8 @@ var PowerlinesContext = class _PowerlinesContext {
   * @param options - Optional write file options
   */
   async emitEntry(code, path, options = {}) {
-    return this.fs.writeFile(isType.isAbsolute(path) ? path : append.appendPath(path, this.entryPath), {
-      code,
+    return this.fs.write(isType.isAbsolute(path) ? path : append.appendPath(path, this.entryPath), code, defu6__default.default(options, {
       type: "entry"
-    }, defu5__default.default(options, {
-      mode: this.config.output.mode
     }));
   }
   /**
@@ -2748,12 +2686,8 @@ var PowerlinesContext = class _PowerlinesContext {
   * @param options - Optional write file options
   */
   async emitBuiltin(code, id, path, options = {}) {
-    return this.fs.writeFile(path ? isType.isAbsolute(path) ? path : join.joinPaths(this.builtinsPath, path) : append.appendPath(id, this.builtinsPath), {
-      id,
-      code,
+    return this.fs.write(path ? isType.isAbsolute(path) ? path : join.joinPaths(this.builtinsPath, path) : append.appendPath(id, this.builtinsPath), code, defu6__default.default(options, {
       type: "builtin"
-    }, defu5__default.default(options, {
-      mode: this.config.output.mode
     }));
   }
   /**
@@ -2937,7 +2871,7 @@ var PowerlinesContext = class _PowerlinesContext {
         logLevel: config.logLevel || this.config?.logLevel || this.workspaceConfig.logLevel || "info",
         skipCache: cacheKey.skipCache
       });
-      const userConfig = await chunk2PYUYDPD_js.loadUserConfigFile(cacheKey.projectRoot, this.workspaceConfig.workspaceRoot, this.resolver, cacheKey.command, cacheKey.mode, cacheKey.configFile, cacheKey.framework);
+      const userConfig = await chunkDQI2I5KK_js.loadUserConfigFile(cacheKey.projectRoot, this.workspaceConfig.workspaceRoot, this.resolver, cacheKey.command, cacheKey.mode, cacheKey.configFile, cacheKey.framework);
       this.mergeUserConfig(userConfig.config);
       configCache.set(cacheKey, {
         projectJson: this.projectJson,
@@ -2947,9 +2881,9 @@ var PowerlinesContext = class _PowerlinesContext {
         userConfig
       });
     }
-    this.config.tsconfig ??= getTsconfigFilePath(this.workspaceConfig.workspaceRoot, cacheKey.projectRoot, config.tsconfig);
+    config.tsconfig ??= getTsconfigFilePath(this.workspaceConfig.workspaceRoot, cacheKey.projectRoot, config.tsconfig);
     if (isSetObject.isSetObject(config)) {
-      this.resolvedConfig = defu5__default.default({
+      this.resolvedConfig = defu6__default.default({
         inlineConfig: this.config.inlineConfig,
         userConfig: this.config.userConfig
       }, options.isHighPriority ? this.#getConfigProps(config) : {}, {
@@ -2964,12 +2898,11 @@ var PowerlinesContext = class _PowerlinesContext {
         version: this.packageJson?.version,
         description: this.packageJson?.description,
         sourceRoot: this.projectJson?.sourceRoot || append.appendPath("src", cacheKey.projectRoot),
-        output: {
+        output: defu6__default.default(config.output ?? {}, {
           outputPath: cacheKey.projectRoot ? join.joinPaths(this.workspaceConfig?.directories?.build || "dist", cacheKey.projectRoot) : this.workspaceConfig?.directories?.build || "dist",
-          mode: "virtual",
+          artifactsPath: join.joinPaths(cacheKey.projectRoot, `.${config.framework ?? "powerlines"}`),
           dts: join.joinPaths(cacheKey.projectRoot, `${config.framework ?? "powerlines"}.d.ts`),
           builtinPrefix: config.framework ?? "powerlines",
-          artifactsFolder: join.joinPaths(cacheKey.projectRoot, `.${config.framework ?? "powerlines"}`),
           assets: [
             {
               glob: "LICENSE"
@@ -2983,7 +2916,7 @@ var PowerlinesContext = class _PowerlinesContext {
               glob: "package.json"
             }
           ]
-        }
+        })
       }, options.isHighPriority ? {} : this.#getConfigProps(config), {
         inlineConfig: {},
         userConfig: {},
@@ -3028,10 +2961,10 @@ var PowerlinesContext = class _PowerlinesContext {
     ])));
     if (this.config.projectRoot && this.config.projectRoot !== "." && this.config.projectRoot !== "./" && this.config.projectRoot !== this.workspaceConfig.workspaceRoot) {
       this.config.output.outputPath ??= join.joinPaths("dist", this.config.projectRoot);
-      this.config.output.distPath ??= join.joinPaths(this.config.projectRoot, "dist");
+      this.config.output.buildPath ??= join.joinPaths(this.config.projectRoot, "dist");
     } else {
       this.config.output.outputPath ??= "dist";
-      this.config.output.distPath ??= "dist";
+      this.config.output.buildPath ??= "dist";
     }
     this.config.output.assets = getUnique.getUnique(this.config.output.assets.map((asset) => {
       return {
@@ -3069,7 +3002,7 @@ var PowerlinesContext = class _PowerlinesContext {
     this.#fs ??= await VirtualFileSystem.create(this);
   }
   mergeUserConfig(from = {}, into = this.config.userConfig ?? {}) {
-    this.config.userConfig = defu5__default.default({
+    this.config.userConfig = defu6__default.default({
       entry: Array.isArray(from.entry) && from.entry.length > 0 ? from.entry : Array.isArray(into?.entry) && into.entry.length > 0 ? into.entry : []
     }, omit.omit(from ?? {}, [
       "entry"
@@ -3314,7 +3247,7 @@ var PowerlinesAPIContext = class _PowerlinesAPIContext extends PowerlinesContext
   * @returns A promise that resolves to the new context.
   */
   static async from(workspaceRoot, config) {
-    const context = new _PowerlinesAPIContext(await chunk2PYUYDPD_js.loadWorkspaceConfig(workspaceRoot, config.root));
+    const context = new _PowerlinesAPIContext(await chunkDQI2I5KK_js.loadWorkspaceConfig(workspaceRoot, config.root));
     await context.withUserConfig(config);
     context.powerlinesPath = await resolve.resolvePackage("powerlines");
     if (!context.powerlinesPath) {
@@ -3374,12 +3307,49 @@ var PowerlinesAPIContext = class _PowerlinesAPIContext extends PowerlinesContext
     }
     return context;
   }
+  /**
+  * Update the context using a new user configuration options
+  *
+  * @param userConfig - The new user configuration options.
+  */
+  async withUserConfig(userConfig, options = {
+    isHighPriority: true
+  }) {
+    await super.withUserConfig(userConfig, options);
+    await Promise.all(Object.keys(this.#environments).map(async (name) => {
+      await this.#environments[name].withUserConfig(userConfig, options);
+    }));
+  }
+  /**
+  * Update the context using a new inline configuration options
+  *
+  * @param inlineConfig - The new inline configuration options.
+  */
+  async withInlineConfig(inlineConfig, options = {
+    isHighPriority: true
+  }) {
+    await super.withInlineConfig(inlineConfig, options);
+    await Promise.all(Object.keys(this.#environments).map(async (name) => {
+      await this.#environments[name].withInlineConfig(inlineConfig, options);
+    }));
+  }
+  /**
+  * Add a plugin to the API context and all environments
+  *
+  * @param plugin - The plugin to add.
+  */
   async addPlugin(plugin) {
     this.plugins.push(plugin);
     await Promise.all(Object.keys(this.environments).map(async (name) => {
       await this.environments[name].addPlugin(plugin);
     }));
   }
+  /**
+  * Get an environment by name, or the default environment if no name is provided
+  *
+  * @param name - The name of the environment to retrieve.
+  * @returns The requested environment context.
+  */
   async getEnvironment(name) {
     let environment;
     if (name) {
@@ -3498,24 +3468,20 @@ ${context.entry.map((entry) => `- ${entry.input.file || entry.file}${entry.outpu
       context.log(types.LogLevelLabel.TRACE, `Powerlines configuration has been resolved: 
 
 ${console.formatLogMessage(context.config)}`);
-      await chunk2PYUYDPD_js.writeMetaFile(context);
+      await chunkDQI2I5KK_js.writeMetaFile(context);
       context.persistedMeta = context.meta;
       if (!context.fs.existsSync(context.cachePath)) {
-        await context.fs.mkdir(context.cachePath, {
-          mode: "fs"
-        });
+        await helpers.createDirectory(context.cachePath);
       }
       if (!context.fs.existsSync(context.dataPath)) {
-        await context.fs.mkdir(context.dataPath, {
-          mode: "fs"
-        });
+        await helpers.createDirectory(context.dataPath);
       }
       await this.callPreHook(context, "prepare");
       await this.callNormalHook(context, "prepare");
       if (context.config.output.dts !== false) {
         context.log(types.LogLevelLabel.TRACE, `Preparing the TypeScript definitions for the Powerlines project.`);
         if (context.fs.existsSync(context.dtsPath)) {
-          await context.fs.unlink(context.dtsPath);
+          await context.fs.remove(context.dtsPath);
         }
         context.log(types.LogLevelLabel.TRACE, "Transforming built-ins runtime modules files.");
         const builtinFilePaths = await Promise.all((await context.getBuiltins()).map(async (file) => {
@@ -3602,7 +3568,7 @@ ${console.formatLogMessage(context.config)}`);
             generatedTypes = result;
           }
         }
-        await context.fs.writeFile(context.dtsPath, `${directives ? `${directives.map((directive) => `/// <reference types="${directive}" />`).join("\n")}
+        await context.fs.write(context.dtsPath, `${directives ? `${directives.map((directive) => `/// <reference types="${directive}" />`).join("\n")}
 
 ` : ""}${getFileHeader(context, {
           directive: null,
@@ -3610,16 +3576,14 @@ ${console.formatLogMessage(context.config)}`);
         })}
 
 ${formatTypes(generatedTypes)}
-`, {
-          mode: "fs"
-        });
+`);
       }
       context.tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
       if (!context.tsconfig) {
         throw new Error("Failed to parse the TypeScript configuration file.");
       }
       await this.callPostHook(context, "prepare");
-      await chunk2PYUYDPD_js.writeMetaFile(context);
+      await chunkDQI2I5KK_js.writeMetaFile(context);
     });
     this.context.log(types.LogLevelLabel.INFO, "Powerlines API has been prepared successfully");
   }
@@ -3680,8 +3644,8 @@ ${formatTypes(generatedTypes)}
     await this.prepare(inlineConfig);
     await this.#executeEnvironments(async (context) => {
       this.context.log(types.LogLevelLabel.TRACE, "Cleaning the project's dist and artifacts directories.");
-      await context.fs.rmdir(joinPaths.joinPaths(context.workspaceConfig.workspaceRoot, context.config.output.distPath));
-      await context.fs.rmdir(joinPaths.joinPaths(context.workspaceConfig.workspaceRoot, context.config.output.artifactsFolder));
+      await context.fs.remove(joinPaths.joinPaths(context.workspaceConfig.workspaceRoot, context.config.output.buildPath));
+      await context.fs.remove(joinPaths.joinPaths(context.workspaceConfig.workspaceRoot, context.config.output.artifactsPath));
       await callHook(context, "clean", {
         sequential: true
       });
@@ -3723,11 +3687,11 @@ ${formatTypes(generatedTypes)}
     await this.#executeEnvironments(async (context) => {
       await this.callPreHook(context, "build");
       await this.callNormalHook(context, "build");
-      if (context.config.output.distPath !== context.config.output.outputPath) {
-        const sourcePath = append.appendPath(context.config.output.distPath, context.workspaceConfig.workspaceRoot);
+      if (context.config.output.buildPath !== context.config.output.outputPath) {
+        const sourcePath = append.appendPath(context.config.output.buildPath, context.workspaceConfig.workspaceRoot);
         const destinationPath = joinPaths.joinPaths(append.appendPath(context.config.output.outputPath, context.workspaceConfig.workspaceRoot), "dist");
         if (sourcePath !== destinationPath) {
-          context.log(types.LogLevelLabel.INFO, `Copying build output files from project's build directory (${context.config.output.distPath}) to the workspace's output directory (${context.config.output.outputPath}).`);
+          context.log(types.LogLevelLabel.INFO, `Copying build output files from project's build directory (${context.config.output.buildPath}) to the workspace's output directory (${context.config.output.outputPath}).`);
           await copyFile.copyFiles({
             input: sourcePath,
             glob: "**/*"
@@ -4070,7 +4034,7 @@ function withExecutor(command, executorFn) {
       throw new Error("The executor requires `projectsConfigurations` on the context object.");
     }
     const projectConfig = context.projectsConfigurations.projects[context.projectName];
-    const api = await src_default.from(workspaceConfig.workspaceRoot, defu5__default.default({
+    const api = await src_default.from(workspaceConfig.workspaceRoot, defu6__default.default({
       root: projectConfig.root,
       type: projectConfig.projectType,
       sourceRoot: projectConfig.sourceRoot,
@@ -4083,7 +4047,7 @@ function withExecutor(command, executorFn) {
       }
     }, options));
     try {
-      return await Promise.resolve(executorFn(defu5__default.default({
+      return await Promise.resolve(executorFn(defu6__default.default({
         projectName: context.projectName,
         options,
         workspaceConfig,