@powerlines/nx 0.10.36 → 0.10.38

package/dist/{chunk-XQ44F4OL.mjs → chunk-OS2GSBDL.mjs}

@@ -1,18 +1,19 @@
-import { loadWorkspaceConfig, CACHE_HASH_LENGTH, PROJECT_ROOT_HASH_LENGTH, getPrefixedProjectRootHash, loadUserConfigFile, writeMetaFile } from './chunk-WGIN2BGP.mjs';
+import { loadWorkspaceConfig, CACHE_HASH_LENGTH, PROJECT_ROOT_HASH_LENGTH, getPrefixedProjectRootHash, loadUserConfigFile, writeMetaFile } from './chunk-OVX2CEXQ.mjs';
 import { __name } from './chunk-O6YSETKJ.mjs';
 import { getLogFn, getLogLevel, writeError } from '@storm-software/config-tools/logger';
 import { withRunExecutor } from '@storm-software/workspace-tools/base/base-executor';
 import { isError } from '@stryke/type-checks/is-error';
-import defu5, { defu } from 'defu';
+import defu6, { defu } from 'defu';
 import { transformAsync } from '@babel/core';
 import { formatLogMessage } from '@storm-software/config-tools/logger/console';
 import { LogLevelLabel } from '@storm-software/config-tools/types';
 import { toArray } from '@stryke/convert/to-array';
 import { copyFiles } from '@stryke/fs/copy-file';
+import { createDirectory } from '@stryke/fs/helpers';
 import { install } from '@stryke/fs/install';
-import { listFiles, listFilesSync } from '@stryke/fs/list-files';
+import { listFilesSync, listFiles } from '@stryke/fs/list-files';
 import { isPackageExists, isPackageListed, doesPackageMatch, getPackageListing } from '@stryke/fs/package-fns';
-import { getResolutionCombinations, resolve, resolveSync, resolvePackage } from '@stryke/fs/resolve';
+import { getResolutionCombinations, resolve as resolve$1, resolveSync, resolvePackage } from '@stryke/fs/resolve';
 import { appendPath } from '@stryke/path/append';
 import { joinPaths as joinPaths$1 } from '@stryke/path/join-paths';
 import { replacePath, replaceExtension } from '@stryke/path/replace';
@@ -26,16 +27,17 @@ import chalk5 from 'chalk';
 import Handlebars from 'handlebars';
 import { declare } from '@babel/helper-plugin-utils';
 import * as t from '@babel/types';
-import ts2, { flattenDiagnosticMessageText } from 'typescript';
+import ts, { flattenDiagnosticMessageText } from 'typescript';
+import { joinPaths } from '@stryke/path/join';
+import { InMemoryFileSystemHost, Project } from 'ts-morph';
 import { getPackageName, hasPackageVersion, getPackageVersion } from '@stryke/string-format/package';
 import { getObjectDiff } from '@donedeal0/superdiff';
 import { readJsonFile, readJsonFileSync } from '@stryke/fs/json';
 import { StormJSON } from '@stryke/json/storm-json';
-import { findFilePath, findFileExtension, relativePath, findFileName, findFileDotExtensionSafe } from '@stryke/path/file-path-fns';
-import { isParentPath } from '@stryke/path/is-parent-path';
+import { hasFileExtension, findFilePath, findFileName, relativePath, findFileDotExtensionSafe } from '@stryke/path/file-path-fns';
 import { titleCase } from '@stryke/string-format/title-case';
-import { existsSync } from '@stryke/fs/exists';
-import { writeFile as writeFile$1 } from '@stryke/fs/write-file';
+import { existsSync, exists } from '@stryke/fs/exists';
+import { writeFileSync, writeFile as writeFile$1 } from '@stryke/fs/write-file';
 import { resolveConfig, format } from 'prettier';
 import { getEnvPaths } from '@stryke/env/get-env-paths';
 import { relativeToWorkspaceRoot } from '@stryke/fs/get-workspace-root';
@@ -44,7 +46,6 @@ import { murmurhash } from '@stryke/hash/murmurhash';
 import { getUnique, getUniqueBy } from '@stryke/helpers/get-unique';
 import { omit } from '@stryke/helpers/omit';
 import { isAbsolutePath, isAbsolute } from '@stryke/path/is-type';
-import { joinPaths } from '@stryke/path/join';
 import { isNull } from '@stryke/type-checks/is-null';
 import { isString } from '@stryke/type-checks/is-string';
 import { uuid } from '@stryke/unique-id/uuid';
@@ -54,20 +55,19 @@ import { isUndefined } from '@stryke/type-checks/is-undefined';
 import { parseTypeDefinition } from '@stryke/convert/parse-type-definition';
 import { isFile } from '@stryke/fs/is-file';
 import * as $ from '@stryke/capnp';
-import { bufferToString } from '@stryke/convert/buffer-to-string';
 import { readFileBuffer, readFileBufferSync, writeFileBuffer } from '@stryke/fs/buffer';
-import { toAbsolutePath, correctPath } from '@stryke/path/correct-path';
+import { correctPath, toAbsolutePath } from '@stryke/path/correct-path';
+import { isParentPath } from '@stryke/path/is-parent-path';
 import { prettyBytes } from '@stryke/string-format/pretty-bytes';
-import { isBuffer } from '@stryke/type-checks/is-buffer';
 import { create } from 'flat-cache';
 import { Blob } from 'node:buffer';
-import _fs from 'node:fs';
 import { getColor } from '@storm-software/config-tools/utilities/colors';
 import { noop } from '@stryke/helpers/noop';
 import { slash } from '@stryke/path/slash';
-import { Volume } from 'memfs';
-import { Union } from 'unionfs';
-import { InMemoryFileSystemHost, Project } from 'ts-morph';
+import { readFileSync, readFile } from '@stryke/fs/read-file';
+import { unlinkSync } from 'node:fs';
+import { unlink } from 'node:fs/promises';
+import { resolve } from 'node:path';
 import { isObject } from '@stryke/type-checks/is-object';
 
 function resolveModulePath(nodePath, state) {
@@ -171,6 +171,108 @@ var moduleResolverBabelPlugin = /* @__PURE__ */ __name((context) => {
     };
   }, "builder"));
 }, "moduleResolverBabelPlugin");
+var VirtualFileSystemHost = class extends InMemoryFileSystemHost {
+  static {
+    __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(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(LogLevelLabel.TRACE, `Creating ts-morph Project instance with configuration from: ${context.tsconfig.tsconfigFilePath}.`);
+  const project = new Project(defu6(override ?? {}, {
+    skipAddingFilesFromTsConfig: false,
+    tsConfigFilePath: context.tsconfig.tsconfigFilePath,
+    fileSystem: new VirtualFileSystemHost(context),
+    compilerOptions: defu6(context.tsconfig.options ?? {}, {
+      lib: [
+        "lib.esnext.full.d.ts"
+      ]
+    })
+  }));
+  return project;
+}
+__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
@@ -181,8 +283,11 @@ function formatTypes(code) {
 __name(formatTypes, "formatTypes");
 async function emitTypes(context, files) {
   context.log(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 = "";
@@ -379,13 +484,13 @@ function isIncludeMatchFound(tsconfigType, types) {
   return findIncludeMatch(tsconfigType, types) !== void 0;
 }
 __name(isIncludeMatchFound, "isIncludeMatchFound");
-function getParsedTypeScriptConfig(workspaceRoot, projectRoot, tsconfig, tsconfigRaw = {}, originalTsconfigJson, host = ts2.sys) {
+function getParsedTypeScriptConfig(workspaceRoot, projectRoot, tsconfig, tsconfigRaw = {}, originalTsconfigJson, host = ts.sys) {
   const tsconfigFilePath = getTsconfigFilePath(workspaceRoot, projectRoot, tsconfig);
   const tsconfigJson = readJsonFileSync(tsconfigFilePath);
   if (!tsconfigJson) {
     throw new Error(`Cannot find the \`tsconfig.json\` configuration file at ${joinPaths$1(projectRoot, tsconfig ?? "tsconfig.json")}`);
   }
-  const parsedCommandLine = ts2.parseJsonConfigFileContent(defu5(tsconfigRaw ?? {}, tsconfigJson), host, appendPath(projectRoot, workspaceRoot));
+  const parsedCommandLine = ts.parseJsonConfigFileContent(defu6(tsconfigRaw ?? {}, tsconfigJson), host, 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")}
@@ -426,15 +531,10 @@ async function resolveTsconfigChanges(context) {
   const tsconfigJson = await readJsonFile(tsconfigFilePath);
   tsconfigJson.compilerOptions ??= {};
   if (context.config.output.dts !== false) {
-    context.config.output.dts = context.config.output.dts ? isParentPath(context.config.output.dts, context.workspaceConfig.workspaceRoot) ? context.config.output.dts : appendPath(context.config.output.dts, context.workspaceConfig.workspaceRoot) : appendPath(context.config.projectRoot, context.workspaceConfig.workspaceRoot);
-    if (findFileExtension(context.config.output.dts) !== "d.ts" && findFileExtension(context.config.output.dts) !== "d.cts" && findFileExtension(context.config.output.dts) !== "d.mts") {
-      context.config.output.dts = joinPaths$1(context.config.output.dts, "powerlines.d.ts");
-    }
-    const dtsRelativePath = joinPaths$1(relativePath(joinPaths$1(context.workspaceConfig.workspaceRoot, context.config.projectRoot), findFilePath(context.config.output.dts)), findFileName(context.config.output.dts));
+    const dtsRelativePath = joinPaths$1(relativePath(joinPaths$1(context.workspaceConfig.workspaceRoot, context.config.projectRoot), findFilePath(context.dtsPath)), 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);
@@ -449,24 +549,6 @@ async function resolveTsconfigChanges(context) {
     tsconfigJson.compilerOptions.lib ??= [];
     tsconfigJson.compilerOptions.lib.push("esnext");
   }
-  if (tsconfig.options.module !== ts2.ModuleKind.ESNext) {
-    tsconfigJson.compilerOptions.module = "ESNext";
-  }
-  if (!tsconfig.options.target || ![
-    ts2.ScriptTarget.ESNext,
-    ts2.ScriptTarget.ES2024,
-    ts2.ScriptTarget.ES2023,
-    ts2.ScriptTarget.ES2022,
-    ts2.ScriptTarget.ES2021
-  ].includes(tsconfig.options.target)) {
-    tsconfigJson.compilerOptions.target = "ESNext";
-  }
-  if (tsconfig.options.moduleResolution !== ts2.ModuleResolutionKind.Bundler) {
-    tsconfigJson.compilerOptions.moduleResolution = "Bundler";
-  }
-  if (tsconfig.options.moduleDetection !== ts2.ModuleDetectionKind.Force) {
-    tsconfigJson.compilerOptions.moduleDetection = "force";
-  }
   if (tsconfig.options.esModuleInterop !== true) {
     tsconfigJson.compilerOptions.esModuleInterop = true;
   }
@@ -491,9 +573,7 @@ async function initializeTsconfig(context) {
   context.tsconfig.originalTsconfigJson = await readJsonFile(tsconfigFilePath);
   context.tsconfig.tsconfigJson = await resolveTsconfigChanges(context);
   context.log(LogLevelLabel.TRACE, "Writing updated TypeScript configuration (tsconfig.json) file to disk.");
-  await context.fs.writeFile(tsconfigFilePath, StormJSON.stringify(context.tsconfig.tsconfigJson), {
-    mode: "fs"
-  });
+  await writeFile(context.log, tsconfigFilePath, StormJSON.stringify(context.tsconfig.tsconfigJson));
   context.tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig, context.config.tsconfigRaw, context.tsconfig.originalTsconfigJson);
 }
 __name(initializeTsconfig, "initializeTsconfig");
@@ -553,7 +633,7 @@ async function resolveTsconfig(context) {
 __name(resolveTsconfig, "resolveTsconfig");
 var DEFAULT_ENVIRONMENT = "default";
 function createEnvironment(name, userConfig) {
-  return defu5(userConfig.environments?.[name] ?? {}, {
+  return defu6(userConfig.environments?.[name] ?? {}, {
     name,
     title: userConfig.title || titleCase(userConfig.name),
     ssr: false,
@@ -597,8 +677,7 @@ function createDefaultEnvironment(userConfig) {
 }
 __name(createDefaultEnvironment, "createDefaultEnvironment");
 function resolveOptions(options) {
-  return defu5(options, {
-    debug: options.logLevel === "trace",
+  return defu6(options, {
     interopDefault: true,
     fsCache: options.mode !== "development" ? joinPaths$1(options.cacheDir, "jiti") : false,
     moduleCache: options.mode !== "development"
@@ -689,7 +768,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}", replacePath(context.artifactsPath, context.workspaceConfig.workspaceRoot)).replaceAll("{builtinPath}", replacePath(context.builtinsPath, context.workspaceConfig.workspaceRoot)).replaceAll("{entryPath}", 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}", replacePath(context.artifactsPath, context.workspaceConfig.workspaceRoot)).replaceAll("{builtinPath}", replacePath(context.builtinsPath, context.workspaceConfig.workspaceRoot)).replaceAll("{entryPath}", replacePath(context.entryPath, context.workspaceConfig.workspaceRoot));
 }
 __name(replacePathTokens, "replacePathTokens");
 function resolveEntryInputFile(context, typeDefinition) {
@@ -773,7 +852,7 @@ var FileMetadata = class _FileMetadata extends $.Struct {
   static _capnp = {
     displayName: "FileMetadata",
     id: "8e2cab5d7e28c7b3",
-    size: new $.ObjectSize(8, 4),
+    size: new $.ObjectSize(8, 3),
     defaultType: "normal"
   };
   static _Properties;
@@ -788,7 +867,7 @@ var FileMetadata = class _FileMetadata extends $.Struct {
     $.utils.setText(0, value, this);
   }
   /**
-  * The output mode of the file.
+  * The timestamp representing the file's creation date.
   *
   */
   get type() {
@@ -798,16 +877,6 @@ var FileMetadata = class _FileMetadata extends $.Struct {
     $.utils.setText(1, value, this);
   }
   /**
-  * The timestamp representing the file's creation date.
-  *
-  */
-  get mode() {
-    return $.utils.getText(2, this);
-  }
-  set mode(value) {
-    $.utils.setText(2, value, this);
-  }
-  /**
   * Additional metadata associated with the file.
   *
   */
@@ -818,22 +887,22 @@ var FileMetadata = class _FileMetadata extends $.Struct {
     $.utils.setUint32(0, value, this);
   }
   _adoptProperties(value) {
-    $.utils.adopt(value, $.utils.getPointer(3, this));
+    $.utils.adopt(value, $.utils.getPointer(2, this));
   }
   _disownProperties() {
     return $.utils.disown(this.properties);
   }
   get properties() {
-    return $.utils.getList(3, _FileMetadata._Properties, this);
+    return $.utils.getList(2, _FileMetadata._Properties, this);
   }
   _hasProperties() {
-    return !$.utils.isNull($.utils.getPointer(3, this));
+    return !$.utils.isNull($.utils.getPointer(2, this));
   }
   _initProperties(length) {
-    return $.utils.initList(3, _FileMetadata._Properties, length, this);
+    return $.utils.initList(2, _FileMetadata._Properties, length, this);
   }
   set properties(value) {
-    $.utils.copyFrom(value, $.utils.getPointer(3, this));
+    $.utils.copyFrom(value, $.utils.getPointer(2, this));
   }
   toString() {
     return "FileMetadata_" + super.toString();
@@ -868,13 +937,13 @@ var FileId = class extends $.Struct {
     return "FileId_" + super.toString();
   }
 };
-var FileData = class extends $.Struct {
+var FileStorage = class extends $.Struct {
   static {
-    __name(this, "FileData");
+    __name(this, "FileStorage");
   }
   static _capnp = {
-    displayName: "FileData",
-    id: "fa6725c8a360f9a2",
+    displayName: "FileStorage",
+    id: "9dca66ac858c9ebe",
     size: new $.ObjectSize(0, 2)
   };
   /**
@@ -894,7 +963,7 @@ var FileData = class extends $.Struct {
     $.utils.setText(1, value, this);
   }
   toString() {
-    return "FileData_" + super.toString();
+    return "FileStorage_" + super.toString();
   }
 };
 var FileSystem = class _FileSystem extends $.Struct {
@@ -907,7 +976,7 @@ var FileSystem = class _FileSystem extends $.Struct {
     size: new $.ObjectSize(0, 3)
   };
   static _Ids;
-  static _Files;
+  static _Storage;
   static _Metadata;
   _adoptIds(value) {
     $.utils.adopt(value, $.utils.getPointer(0, this));
@@ -927,22 +996,22 @@ var FileSystem = class _FileSystem extends $.Struct {
   set ids(value) {
     $.utils.copyFrom(value, $.utils.getPointer(0, this));
   }
-  _adoptFiles(value) {
+  _adoptStorage(value) {
     $.utils.adopt(value, $.utils.getPointer(1, this));
   }
-  _disownFiles() {
-    return $.utils.disown(this.files);
+  _disownStorage() {
+    return $.utils.disown(this.storage);
   }
-  get files() {
-    return $.utils.getList(1, _FileSystem._Files, this);
+  get storage() {
+    return $.utils.getList(1, _FileSystem._Storage, this);
   }
-  _hasFiles() {
+  _hasStorage() {
     return !$.utils.isNull($.utils.getPointer(1, this));
   }
-  _initFiles(length) {
-    return $.utils.initList(1, _FileSystem._Files, length, this);
+  _initStorage(length) {
+    return $.utils.initList(1, _FileSystem._Storage, length, this);
   }
-  set files(value) {
+  set storage(value) {
     $.utils.copyFrom(value, $.utils.getPointer(1, this));
   }
   _adoptMetadata(value) {
@@ -969,12 +1038,15 @@ var FileSystem = class _FileSystem extends $.Struct {
 };
 FileMetadata._Properties = $.CompositeList(FileMetadata_KeyValuePair);
 FileSystem._Ids = $.CompositeList(FileId);
-FileSystem._Files = $.CompositeList(FileData);
+FileSystem._Storage = $.CompositeList(FileStorage);
 FileSystem._Metadata = $.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__ */ __name((name, options = {}) => {
   const logLevel = options.logLevel === null ? LogLevelLabel.SILENT : options.logLevel || LogLevelLabel.INFO;
   if (logLevel === LogLevelLabel.SILENT) {
@@ -1013,142 +1085,18 @@ var BADGE_COLORS = [
 var extendLog = /* @__PURE__ */ __name((logFn, name) => {
   return (type, ...args) => logFn(type, ` ${chalk5.inverse.hex(BADGE_COLORS[name.split("").map((char) => char.charCodeAt(0)).reduce((ret, charCode) => ret + charCode, 0) % BADGE_COLORS.length] || BADGE_COLORS[0])(` ${titleCase(name)} `)}  ${args.join(" ")} `);
 }, "extendLog");
-function isBufferEncoding(options) {
-  return isSetString(options) || options === null;
-}
-__name(isBufferEncoding, "isBufferEncoding");
-function isPowerlinesWriteFileOptions(options) {
-  return !isBufferEncoding(options) && isSetObject(options) && "mode" in options && (options.mode === "fs" || options.mode === "virtual");
+function isFileError(err) {
+  return isError(err) && "code" in err && err.code;
 }
-__name(isPowerlinesWriteFileOptions, "isPowerlinesWriteFileOptions");
-function isVirtualFileData(obj) {
-  return !!(isSetObject(obj) && "code" in obj && obj.code);
+__name(isFileError, "isFileError");
+function ignoreNotfound(err) {
+  return isFileError(err) && (err.code === "ENOENT" || err.code === "EISDIR" ? null : err);
 }
-__name(isVirtualFileData, "isVirtualFileData");
+__name(ignoreNotfound, "ignoreNotfound");
 function toFilePath(path) {
   return correctPath(slash(path?.toString() || ".").replace(/^file:\/\//, ""));
 }
 __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(clonedFS[prop])) {
-      clonedFS[prop] = clonedFS[prop].bind(originalFS);
-      if (isFunction(clonedFS.promises[prop])) {
-        clonedFS.promises[prop] = clonedFS.promises[prop].bind(originalFS);
-      }
-    }
-  }
-  for (const prop in clonedFS.promises) {
-    if (isFunction(clonedFS.promises[prop])) {
-      clonedFS.promises[prop] = clonedFS.promises[prop].bind(originalFS);
-    }
-  }
-  return clonedFS;
-}
-__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__ */ __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__ */ __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__ */ __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;
-  };
-}
-__name(patchFS, "patchFS");
 function isValidId(id, prefix = "powerlines") {
   return id.replace(/^\\0/, "").startsWith(`${prefix.replace(/:$/, "")}`);
 }
@@ -1158,164 +1106,368 @@ function normalizeId(id, prefix = "powerlines") {
 }
 __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 isAbsolutePath(path) ? path : isValidId(toFilePath(path), prefix) ? normalizeId(toFilePath(path), prefix).replace(new RegExp(`^${prefix.replace(/:$/, "")}:`), builtinsPath) : toFilePath(path);
 }
 __name(normalizePath, "normalizePath");
-var UnifiedFS = class _UnifiedFS extends Union {
+function normalizeKey(key, sep = ":") {
+  if (!key) {
+    return "";
+  }
+  return key.replace(/[:/\\]/g, sep).replace(/^[:/\\]|[:/\\]$/g, "");
+}
+__name(normalizeKey, "normalizeKey");
+function filterKeyByBase(key, base) {
+  if (base) {
+    return key.startsWith(base) && key[key.length - 1] !== "$";
+  }
+  return key[key.length - 1] !== "$";
+}
+__name(filterKeyByBase, "filterKeyByBase");
+var BaseStorageAdapter = class {
   static {
-    __name(this, "UnifiedFS");
+    __name(this, "BaseStorageAdapter");
   }
   /**
-  * The internal map of virtual files.
+  * Indicates whether the storage adapter has been disposed.
   */
-  #virtualFS = new Volume();
+  #isDisposed = false;
   /**
-  * The physical file system.
+  * Configuration options for the storage adapter.
   */
-  #physicalFS = cloneFS(_fs);
+  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 = 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(joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.output.distPath))) {
-      this.#physicalFS.mkdirSync(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 = 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) ? 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) ? 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 appendPath(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 {
+    __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 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(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 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(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 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(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 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 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 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(this.resolve(base), {
+      ignore: this.options.ignore
+    }).catch(ignoreNotfound).then((r) => r || []);
+  }
+};
+var VirtualStorageAdapter = class extends BaseStorageAdapter {
+  static {
+    __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(toFilePath(pathOrUrl), this.#context.artifactsPath)) {
-      return "virtual";
-    } else if (options.mode === "fs" || this.#context.config.output.mode === "fs" || isParentPath(toFilePath(pathOrUrl), this.#context.dataPath) || isParentPath(toFilePath(pathOrUrl), this.#context.cachePath) || isParentPath(toFilePath(pathOrUrl), 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(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();
   }
 };
 
@@ -1337,29 +1489,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;
@@ -1368,15 +1514,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.
@@ -1405,6 +1542,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(path, base)) {
+        return {
+          base,
+          relativeKey: 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(key, base) || includeParent && 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.
@@ -1414,7 +1588,13 @@ var VirtualFileSystem = class _VirtualFileSystem {
     if (!context.config.skipCache && existsSync(joinPaths$1(context.dataPath, "fs.bin"))) {
       const buffer = await readFileBuffer(joinPaths$1(context.dataPath, "fs.bin"));
       const message2 = new $.Message(buffer, 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 $.Message();
     return new _VirtualFileSystem(context, message.initRoot(FileSystem));
@@ -1429,7 +1609,13 @@ var VirtualFileSystem = class _VirtualFileSystem {
     if (!context.config.skipCache && existsSync(joinPaths$1(context.dataPath, "fs.bin"))) {
       const buffer = readFileBufferSync(joinPaths$1(context.dataPath, "fs.bin"));
       const message2 = new $.Message(buffer, 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 $.Message();
     return new _VirtualFileSystem(context, message.initRoot(FileSystem));
@@ -1464,6 +1650,9 @@ var VirtualFileSystem = class _VirtualFileSystem {
       }, "get")
     });
   }
+  /**
+  * Gets the resolver cache.
+  */
   get resolverCache() {
     if (!this.#resolverCache) {
       this.#resolverCache = create({
@@ -1482,16 +1671,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(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;
@@ -1503,12 +1710,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;
       }, {});
@@ -1516,187 +1723,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)**.
+  * Asynchronously checks if a file exists in the virtual file system (VFS).
   *
-  * @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).
-  *
-  * @param path - The path to create the directory at.
-  */
-  unlinkSync(path, options) {
-    if (!this.isFile(this.#normalizePath(path))) {
-      return;
-    }
-    this.#log(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));
-    }
-  }
-  /**
-  * Removes a file 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`.
   */
-  async unlink(path, options) {
-    if (!this.isFile(this.#normalizePath(path))) {
-      return;
-    }
-    this.#log(LogLevelLabel.TRACE, `Removing file: ${this.#normalizePath(path)}`);
-    if (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);
-    }
+  async exists(path) {
+    const { relativeKey, adapter } = this.#getStorage(path);
+    return adapter.exists(relativeKey);
   }
   /**
-  * 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(LogLevelLabel.TRACE, `Synchronously removing directory: ${this.#normalizePath(path)}`);
-    this.#unifiedFS.resolveFS(path, options).rmdirSync(this.#normalizePath(path), defu5(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(LogLevelLabel.TRACE, `Removing directory: ${this.#normalizePath(path)}`);
-    if (isFunction(this.#unifiedFS.resolveFS(path, options).promises.rm)) {
-      await this.#unifiedFS.resolveFS(path, options).promises.rm(this.#normalizePath(path), defu5(options, {
-        force: true,
-        recursive: true
-      }));
-    } else {
-      this.rmdirSync(this.#normalizePath(path), defu5(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(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(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(omit(options, [
-      "mode"
-    ]), {
-      recursive: true
-    }));
+  */
+  async remove(path) {
+    const normalizedPath = this.#normalizePath(path);
+    this.#log(LogLevelLabel.TRACE, `Removing file: ${normalizedPath}`);
+    const { relativeKey, adapter } = this.#getStorage(normalizedPath);
+    if (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(this.#unifiedFS.resolveFS(this.#normalizePath(path), options).promises.mkdir)) {
-      result = await this.#unifiedFS.resolveFS(this.#normalizePath(path), options).promises.mkdir(this.#normalizePath(path), defu5(omit(options, [
-        "mode"
-      ]), {
-        recursive: true
-      }));
+  removeSync(path) {
+    const normalizedPath = this.#normalizePath(path);
+    this.#log(LogLevelLabel.TRACE, `Removing file: ${normalizedPath}`);
+    const { relativeKey, adapter } = this.#getStorage(normalizedPath);
+    if (hasFileExtension(normalizedPath)) {
+      adapter.removeSync(relativeKey);
     } else {
-      result = this.#unifiedFS.resolveFS(this.#normalizePath(path), options).mkdirSync(this.#normalizePath(path), defu5(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).
@@ -1718,38 +1861,14 @@ var VirtualFileSystem = class _VirtualFileSystem {
       const absPattern = isAbsolutePath(normalized) ? normalized : this.#normalizePath(joinPaths$1(this.#context.workspaceConfig.workspaceRoot, normalized));
       const firstGlobIdx = absPattern.search(/[*?[\]{}]/);
       const baseDir = firstGlobIdx === -1 ? findFilePath(absPattern) : absPattern.slice(0, Math.max(0, absPattern.lastIndexOf("/", firstGlobIdx)));
-      const stack = [
-        baseDir && 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$1(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 && 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;
   }
@@ -1773,35 +1892,12 @@ var VirtualFileSystem = class _VirtualFileSystem {
       const absPattern = isAbsolutePath(normalized) ? normalized : this.#normalizePath(joinPaths$1(this.#context.workspaceConfig.workspaceRoot, normalized));
       const firstGlobIdx = absPattern.search(/[*?[\]{}]/);
       const baseDir = firstGlobIdx === -1 ? findFilePath(absPattern) : absPattern.slice(0, Math.max(0, absPattern.lastIndexOf("/", firstGlobIdx)));
-      const stack = [
-        baseDir && 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$1(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 && 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);
           }
         }
       }
@@ -1809,36 +1905,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 (hasFileExtension(srcPath)) {
+      const content = await this.read(srcPath);
+      if (content !== void 0) {
+        await this.write(hasFileExtension(destPath) ? destPath : joinPaths$1(destPath, 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(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).
@@ -1847,51 +1934,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 (hasFileExtension(srcPath)) {
+      const content = this.readSync(srcPath);
+      if (content !== void 0) {
+        this.writeSync(hasFileExtension(destPath) ? destPath : joinPaths$1(destPath, findFileName(srcPath)), content);
+      }
+    } else {
+      this.listSync(srcPath).forEach((file) => {
+        const relativePath2 = file.replace(this.#normalizePath(srcPath), "");
+        const destinationPath = this.#normalizePath(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 (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 (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(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(result) ? 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(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(result) ? 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(LogLevelLabel.TRACE, `Reading ${adapter.name} file: ${filePath}`);
+    return adapter.getSync(relativeKey) ?? void 0;
   }
   /**
   * Writes a file to the virtual file system (VFS).
@@ -1901,41 +2022,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(findFilePath(this.#normalizePath(path)))) {
-      await this.mkdir(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(code)) {
+  async write(path, data = "", options = {}) {
+    let code = data;
+    if (!options.skipFormat) {
       const resolvedConfig = await resolveConfig(this.#normalizePath(path));
       if (resolvedConfig) {
-        code = await format(code, {
+        code = await format(data, {
           absolutePath: this.#normalizePath(path),
           ...resolvedConfig
         });
       }
     }
-    const outputMode = this.#unifiedFS.resolveMode(this.#normalizePath(path), isPowerlinesWriteFileOptions(options) ? options : void 0);
-    this.#log(LogLevelLabel.TRACE, `Writing ${this.#normalizePath(path)} file to the ${outputMode === "fs" ? "" : "virtual "}file system (size: ${prettyBytes(new Blob(toArray(code)).size)})`);
-    this.#metadata[metadata.id] = {
-      mode: outputMode,
+    const { relativeKey, adapter } = this.#getStorage(path);
+    this.#log(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(new Blob(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(ifs.promises.writeFile)) {
-      return ifs.promises.writeFile(this.#normalizePath(path), code, isSetObject(options) ? omit(options, [
-        "mode"
-      ]) : "utf8");
-    }
-    return ifs.writeFileSync(this.#normalizePath(path), code, isSetObject(options) ? 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).
@@ -1944,38 +2052,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(findFilePath(this.#normalizePath(path)))) {
-      this.mkdirSync(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(LogLevelLabel.TRACE, `Writing ${this.#normalizePath(path)} file to the ${outputMode === "fs" ? "" : "virtual "}file system (size: ${prettyBytes(new Blob(toArray(code)).size)})`);
-    this.#metadata[metadata.id] = {
-      mode: outputMode,
+  writeSync(path, data = "", options = {}) {
+    const { relativeKey, adapter } = this.#getStorage(path);
+    this.#log(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(new Blob(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).
@@ -1991,78 +2079,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
@@ -2079,9 +2095,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 (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) {
@@ -2096,12 +2118,14 @@ var VirtualFileSystem = class _VirtualFileSystem {
       for (const combination of getResolutionCombinations(id, {
         paths
       })) {
-        if (this.#existsSync(combination)) {
+        const { relativeKey, adapter } = this.#getStorage(combination);
+        if (await adapter.exists(relativeKey)) {
           result = combination;
+          break;
         }
       }
       try {
-        result = await resolve(id, {
+        result = await resolve$1(id, {
           paths
         });
       } catch {
@@ -2109,7 +2133,9 @@ var VirtualFileSystem = class _VirtualFileSystem {
     }
     if (result) {
       result = toAbsolutePath(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;
   }
@@ -2130,9 +2156,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 (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) {
@@ -2141,14 +2173,16 @@ var VirtualFileSystem = class _VirtualFileSystem {
         paths.push(importer);
       }
       paths.push(this.#context.workspaceConfig.workspaceRoot);
-      paths.push(joinPaths$1(this.#context.workspaceConfig.workspaceRoot, this.#context.config.projectRoot));
-      paths.push(joinPaths$1(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) => appendPath(tsconfigPath, this.#context.workspaceConfig.workspaceRoot)));
+      paths.push(appendPath(this.#context.config.projectRoot, this.#context.workspaceConfig.workspaceRoot));
+      paths.push(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) => appendPath(tsconfigPath, this.#context.workspaceConfig.workspaceRoot)));
       for (const combination of getResolutionCombinations(id, {
         paths
       })) {
-        if (this.#existsSync(combination)) {
+        const { relativeKey, adapter } = this.#getStorage(combination);
+        if (adapter.existsSync(relativeKey)) {
           result = combination;
+          break;
         }
       }
       try {
@@ -2160,7 +2194,9 @@ var VirtualFileSystem = class _VirtualFileSystem {
     }
     if (result) {
       result = toAbsolutePath(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;
   }
@@ -2171,27 +2207,27 @@ var VirtualFileSystem = class _VirtualFileSystem {
     if (!this.#isDisposed) {
       this.#isDisposed = true;
       this.#log(LogLevelLabel.DEBUG, "Disposing virtual file system...");
-      await this.unlink(joinPaths$1(this.#context.dataPath, "fs.bin"));
+      await this.remove(joinPaths$1(this.#context.dataPath, "fs.bin"));
       const message = new $.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) {
@@ -2204,134 +2240,40 @@ var VirtualFileSystem = class _VirtualFileSystem {
         }
       });
       await writeFileBuffer(joinPaths$1(this.#context.dataPath, "fs.bin"), message.toArrayBuffer());
-      this.#resolverCache.save(true);
-      this.#log(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, 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(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 InMemoryFileSystemHost {
-  static {
-    __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(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 Project({
-    compilerOptions: {
-      ...context.tsconfig.options
-    },
-    tsConfigFilePath: context.tsconfig.tsconfigFilePath,
-    fileSystem: new VirtualFileSystemHost(context.fs),
-    ...override
-  });
-  return project;
-}
-__name(createProgram, "createProgram");
 
 // ../powerlines/src/lib/contexts/context.ts
 var configCache = /* @__PURE__ */ new WeakMap();
@@ -2532,7 +2474,7 @@ var PowerlinesContext = class _PowerlinesContext {
   * Get the path to the artifacts directory for the project
   */
   get artifactsPath() {
-    return joinPaths(this.workspaceConfig.workspaceRoot, this.config.projectRoot, this.config.output.artifactsFolder);
+    return joinPaths(this.workspaceConfig.workspaceRoot, this.config.projectRoot, this.config.output.artifactsPath);
   }
   /**
   * Get the path to the builtin modules used by the project
@@ -2672,7 +2614,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;
     }
@@ -2686,7 +2628,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,
@@ -2702,11 +2644,8 @@ var PowerlinesContext = class _PowerlinesContext {
   * @param options - Optional write file options
   */
   async emitEntry(code, path, options = {}) {
-    return this.fs.writeFile(isAbsolute(path) ? path : appendPath(path, this.entryPath), {
-      code,
+    return this.fs.write(isAbsolute(path) ? path : appendPath(path, this.entryPath), code, defu6(options, {
       type: "entry"
-    }, defu5(options, {
-      mode: this.config.output.mode
     }));
   }
   /**
@@ -2718,12 +2657,8 @@ var PowerlinesContext = class _PowerlinesContext {
   * @param options - Optional write file options
   */
   async emitBuiltin(code, id, path, options = {}) {
-    return this.fs.writeFile(path ? isAbsolute(path) ? path : joinPaths(this.builtinsPath, path) : appendPath(id, this.builtinsPath), {
-      id,
-      code,
+    return this.fs.write(path ? isAbsolute(path) ? path : joinPaths(this.builtinsPath, path) : appendPath(id, this.builtinsPath), code, defu6(options, {
       type: "builtin"
-    }, defu5(options, {
-      mode: this.config.output.mode
     }));
   }
   /**
@@ -2917,9 +2852,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(config)) {
-      this.resolvedConfig = defu5({
+      this.resolvedConfig = defu6({
         inlineConfig: this.config.inlineConfig,
         userConfig: this.config.userConfig
       }, options.isHighPriority ? this.#getConfigProps(config) : {}, {
@@ -2934,12 +2869,11 @@ var PowerlinesContext = class _PowerlinesContext {
         version: this.packageJson?.version,
         description: this.packageJson?.description,
         sourceRoot: this.projectJson?.sourceRoot || appendPath("src", cacheKey.projectRoot),
-        output: {
+        output: defu6(config.output ?? {}, {
           outputPath: cacheKey.projectRoot ? joinPaths(this.workspaceConfig?.directories?.build || "dist", cacheKey.projectRoot) : this.workspaceConfig?.directories?.build || "dist",
-          mode: "virtual",
+          artifactsPath: joinPaths(cacheKey.projectRoot, `.${config.framework ?? "powerlines"}`),
           dts: joinPaths(cacheKey.projectRoot, `${config.framework ?? "powerlines"}.d.ts`),
           builtinPrefix: config.framework ?? "powerlines",
-          artifactsFolder: joinPaths(cacheKey.projectRoot, `.${config.framework ?? "powerlines"}`),
           assets: [
             {
               glob: "LICENSE"
@@ -2953,7 +2887,7 @@ var PowerlinesContext = class _PowerlinesContext {
               glob: "package.json"
             }
           ]
-        }
+        })
       }, options.isHighPriority ? {} : this.#getConfigProps(config), {
         inlineConfig: {},
         userConfig: {},
@@ -2998,10 +2932,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 ??= joinPaths("dist", this.config.projectRoot);
-      this.config.output.distPath ??= joinPaths(this.config.projectRoot, "dist");
+      this.config.output.buildPath ??= 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(this.config.output.assets.map((asset) => {
       return {
@@ -3039,7 +2973,7 @@ var PowerlinesContext = class _PowerlinesContext {
     this.#fs ??= await VirtualFileSystem.create(this);
   }
   mergeUserConfig(from = {}, into = this.config.userConfig ?? {}) {
-    this.config.userConfig = defu5({
+    this.config.userConfig = defu6({
       entry: Array.isArray(from.entry) && from.entry.length > 0 ? from.entry : Array.isArray(into?.entry) && into.entry.length > 0 ? into.entry : []
     }, omit(from ?? {}, [
       "entry"
@@ -3344,12 +3278,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) {
@@ -3471,21 +3442,17 @@ ${formatLogMessage(context.config)}`);
       await writeMetaFile(context);
       context.persistedMeta = context.meta;
       if (!context.fs.existsSync(context.cachePath)) {
-        await context.fs.mkdir(context.cachePath, {
-          mode: "fs"
-        });
+        await createDirectory(context.cachePath);
       }
       if (!context.fs.existsSync(context.dataPath)) {
-        await context.fs.mkdir(context.dataPath, {
-          mode: "fs"
-        });
+        await createDirectory(context.dataPath);
       }
       await this.callPreHook(context, "prepare");
       await this.callNormalHook(context, "prepare");
       if (context.config.output.dts !== false) {
         context.log(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(LogLevelLabel.TRACE, "Transforming built-ins runtime modules files.");
         const builtinFilePaths = await Promise.all((await context.getBuiltins()).map(async (file) => {
@@ -3572,7 +3539,7 @@ ${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,
@@ -3580,9 +3547,7 @@ ${formatLogMessage(context.config)}`);
         })}
 
 ${formatTypes(generatedTypes)}
-`, {
-          mode: "fs"
-        });
+`);
       }
       context.tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
       if (!context.tsconfig) {
@@ -3650,8 +3615,8 @@ ${formatTypes(generatedTypes)}
     await this.prepare(inlineConfig);
     await this.#executeEnvironments(async (context) => {
       this.context.log(LogLevelLabel.TRACE, "Cleaning the project's dist and artifacts directories.");
-      await context.fs.rmdir(joinPaths$1(context.workspaceConfig.workspaceRoot, context.config.output.distPath));
-      await context.fs.rmdir(joinPaths$1(context.workspaceConfig.workspaceRoot, context.config.output.artifactsFolder));
+      await context.fs.remove(joinPaths$1(context.workspaceConfig.workspaceRoot, context.config.output.buildPath));
+      await context.fs.remove(joinPaths$1(context.workspaceConfig.workspaceRoot, context.config.output.artifactsPath));
       await callHook(context, "clean", {
         sequential: true
       });
@@ -3693,11 +3658,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 = appendPath(context.config.output.distPath, context.workspaceConfig.workspaceRoot);
+      if (context.config.output.buildPath !== context.config.output.outputPath) {
+        const sourcePath = appendPath(context.config.output.buildPath, context.workspaceConfig.workspaceRoot);
         const destinationPath = joinPaths$1(appendPath(context.config.output.outputPath, context.workspaceConfig.workspaceRoot), "dist");
         if (sourcePath !== destinationPath) {
-          context.log(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(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 copyFiles({
             input: sourcePath,
             glob: "**/*"
@@ -4040,7 +4005,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({
+    const api = await src_default.from(workspaceConfig.workspaceRoot, defu6({
       root: projectConfig.root,
       type: projectConfig.projectType,
       sourceRoot: projectConfig.sourceRoot,
@@ -4053,7 +4018,7 @@ function withExecutor(command, executorFn) {
       }
     }, options));
     try {
-      return await Promise.resolve(executorFn(defu5({
+      return await Promise.resolve(executorFn(defu6({
         projectName: context.projectName,
         options,
         workspaceConfig,