@powerlines/nx 0.10.9 → 0.10.11

package/dist/{chunk-3WPWHDP3.mjs → chunk-WMZ45WVV.mjs}

@@ -1,9 +1,9 @@
-import { __VFS_CACHE__, __VFS_RESOLVER__, __VFS_VIRTUAL__, __VFS_UNIFIED__, __VFS_INIT__, __VFS_REVERT__, loadWorkspaceConfig, CACHE_HASH_LENGTH, PROJECT_ROOT_HASH_LENGTH, getPrefixedProjectRootHash, getChecksum, loadUserConfigFile, writeMetaFile } from './chunk-DVGRVHRD.mjs';
+import { loadWorkspaceConfig, CACHE_HASH_LENGTH, PROJECT_ROOT_HASH_LENGTH, getPrefixedProjectRootHash, getChecksum, loadUserConfigFile, writeMetaFile } from './chunk-FMYWKI25.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 defu3, { defu } from 'defu';
+import defu2, { 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';
@@ -15,7 +15,7 @@ import { install } from '@stryke/fs/install';
 import { listFiles, listFilesSync } from '@stryke/fs/list-files';
 import { isPackageExists, isPackageListed, doesPackageMatch, getPackageListing } from '@stryke/fs/package-fns';
 import { resolvePackage } from '@stryke/fs/resolve';
-import { joinPaths } from '@stryke/path/join-paths';
+import { joinPaths as joinPaths$1 } from '@stryke/path/join-paths';
 import { replacePath, replaceExtension } from '@stryke/path/replace';
 import { isFunction } from '@stryke/type-checks/is-function';
 import { isNumber } from '@stryke/type-checks/is-number';
@@ -36,28 +36,30 @@ import { getUnique, getUniqueBy } from '@stryke/helpers/get-unique';
 import { omit } from '@stryke/helpers/omit';
 import { StormJSON } from '@stryke/json/storm-json';
 import { appendPath } from '@stryke/path/append';
-import { findFilePath, findFileDotExtensionSafe, hasFileExtension, relativePath, findFileName } from '@stryke/path/file-path-fns';
+import { findFileDotExtensionSafe, findFilePath, hasFileExtension, relativePath, findFileName } from '@stryke/path/file-path-fns';
 import { isAbsolutePath, isAbsolute } from '@stryke/path/is-type';
-import { joinPaths as joinPaths$1 } from '@stryke/path/join';
+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';
 import { parseAsync } from 'oxc-parser';
 import { parseTypeDefinition } from '@stryke/convert/parse-type-definition';
 import { isFile } from '@stryke/fs/is-file';
-import { getColor } from '@storm-software/config-tools/utilities/colors';
-import { noop } from '@stryke/helpers/noop';
-import { isUndefined } from '@stryke/type-checks/is-undefined';
-import { createJiti } from 'jiti';
+import * as $ from '@stryke/capnp';
 import { bufferToString } from '@stryke/convert/buffer-to-string';
-import { isParentPath } from '@stryke/path/is-parent-path';
+import { readFileBuffer, readFileBufferSync, writeFileBuffer } from '@stryke/fs/buffer';
 import { prettyBytes } from '@stryke/string-format/pretty-bytes';
 import { isBuffer } from '@stryke/type-checks/is-buffer';
-import { Volume } from 'memfs';
 import { Blob } from 'node:buffer';
 import fs from 'node:fs';
 import { resolveConfig, format } from 'prettier';
+import { getColor } from '@storm-software/config-tools/utilities/colors';
+import { noop } from '@stryke/helpers/noop';
+import { isUndefined } from '@stryke/type-checks/is-undefined';
+import { isParentPath } from '@stryke/path/is-parent-path';
+import { Volume } from 'memfs/lib/node/volume';
 import { Union } from 'unionfs';
+import { createJiti } from 'jiti';
 import { isObject } from '@stryke/type-checks/is-object';
 import ts2, { createProgram, createCompilerHost, getPreEmitDiagnostics, getLineAndCharacterOfPosition, flattenDiagnosticMessageText } from 'typescript';
 import { getPackageName, hasPackageVersion, getPackageVersion } from '@stryke/string-format/package';
@@ -66,12 +68,12 @@ import { loadTsConfig } from '@stryke/fs/tsconfig';
 import { writeFile as writeFile$1 } from '@stryke/fs/write-file';
 import { isDevelopmentMode, isTestMode } from '@stryke/env/environment-checks';
 import { createVitePlugin, createEsbuildPlugin, createWebpackPlugin, createRolldownPlugin, createRollupPlugin, createRspackPlugin, createUnloaderPlugin } from 'unplugin';
+import { camelCase } from '@stryke/string-format/camel-case';
 import { match, tsconfigPathsToRegExp } from 'bundle-require';
 import '@stryke/fs/read-file';
 import 'magic-string';
 import { defineNuxtModule, addVitePlugin, addWebpackPlugin } from '@nuxt/kit';
 import '@nuxt/schema';
-import * as $ from '@stryke/capnp';
 
 function resolveModulePath(nodePath, state) {
   if (!t.isStringLiteral(nodePath.node)) {
@@ -176,7 +178,7 @@ var moduleResolverBabelPlugin = /* @__PURE__ */ __name((context) => {
 }, "moduleResolverBabelPlugin");
 var DEFAULT_ENVIRONMENT = "default";
 function createEnvironment(name, userConfig) {
-  return defu3(userConfig.environments?.[name] ?? {}, {
+  return defu2(userConfig.environments?.[name] ?? {}, {
     name,
     title: userConfig.title || titleCase(userConfig.name),
     ssr: false,
@@ -219,8 +221,17 @@ function createDefaultEnvironment(userConfig) {
   return createEnvironment(DEFAULT_ENVIRONMENT, userConfig);
 }
 __name(createDefaultEnvironment, "createDefaultEnvironment");
+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("{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");
+
+// ../powerlines/src/lib/entry.ts
 function resolveEntryInputFile(context, typeDefinition) {
-  return replacePath(typeDefinition.file, joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot));
+  return replacePath(typeDefinition.file, joinPaths$1(context.workspaceConfig.workspaceRoot, context.config.projectRoot));
 }
 __name(resolveEntryInputFile, "resolveEntryInputFile");
 function resolveEntryInput(context, typeDefinition) {
@@ -231,7 +242,7 @@ function resolveEntryInput(context, typeDefinition) {
 }
 __name(resolveEntryInput, "resolveEntryInput");
 function resolveEntryOutput(context, typeDefinition) {
-  return replaceExtension(replacePath(replacePath(replacePath(replacePath(replacePath(typeDefinition.file, joinPaths(context.workspaceConfig.workspaceRoot, context.config.sourceRoot)), joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot)), context.config.sourceRoot), context.config.projectRoot), replacePath(context.config.sourceRoot, context.config.projectRoot)));
+  return replaceExtension(replacePath(replacePath(replacePath(replacePath(replacePath(typeDefinition.file, joinPaths$1(context.workspaceConfig.workspaceRoot, context.config.sourceRoot)), joinPaths$1(context.workspaceConfig.workspaceRoot, context.config.projectRoot)), context.config.sourceRoot), context.config.projectRoot), replacePath(context.config.sourceRoot, context.config.projectRoot)));
 }
 __name(resolveEntryOutput, "resolveEntryOutput");
 function resolveEntry(context, typeDefinition) {
@@ -244,7 +255,7 @@ function resolveEntry(context, typeDefinition) {
 }
 __name(resolveEntry, "resolveEntry");
 function resolveEntriesSync(context, typeDefinitions) {
-  return typeDefinitions.map((typeDefinition) => {
+  return typeDefinitions.map((entry) => isString(entry) ? replacePathTokens(context, entry) : replacePathTokens(context, entry.file)).map((typeDefinition) => {
     const parsed = parseTypeDefinition(typeDefinition);
     const filePath = appendPath(parsed.file, context.config.projectRoot);
     if (isFile(filePath)) {
@@ -266,6 +277,232 @@ function getUniqueEntries(entries = []) {
   }));
 }
 __name(getUniqueEntries, "getUniqueEntries");
+BigInt("0xa56c61324b9d6e49");
+var FileMetadata_KeyValuePair = class extends $.Struct {
+  static {
+    __name(this, "FileMetadata_KeyValuePair");
+  }
+  static _capnp = {
+    displayName: "KeyValuePair",
+    id: "eabb26cf58b2a14c",
+    size: new $.ObjectSize(0, 2)
+  };
+  get key() {
+    return $.utils.getText(0, this);
+  }
+  set key(value) {
+    $.utils.setText(0, value, this);
+  }
+  get value() {
+    return $.utils.getText(1, this);
+  }
+  set value(value) {
+    $.utils.setText(1, value, this);
+  }
+  toString() {
+    return "FileMetadata_KeyValuePair_" + super.toString();
+  }
+};
+var FileMetadata = class _FileMetadata extends $.Struct {
+  static {
+    __name(this, "FileMetadata");
+  }
+  static KeyValuePair = FileMetadata_KeyValuePair;
+  static _capnp = {
+    displayName: "FileMetadata",
+    id: "8e2cab5d7e28c7b3",
+    size: new $.ObjectSize(0, 4),
+    defaultVariant: "normal"
+  };
+  static _Properties;
+  /**
+  * The variant of the file.
+  *
+  */
+  get id() {
+    return $.utils.getText(0, this);
+  }
+  set id(value) {
+    $.utils.setText(0, value, this);
+  }
+  /**
+  * The output mode of the file.
+  *
+  */
+  get variant() {
+    return $.utils.getText(1, this, _FileMetadata._capnp.defaultVariant);
+  }
+  set variant(value) {
+    $.utils.setText(1, value, this);
+  }
+  /**
+  * Additional metadata associated with the file.
+  *
+  */
+  get mode() {
+    return $.utils.getText(2, this);
+  }
+  set mode(value) {
+    $.utils.setText(2, value, this);
+  }
+  _adoptProperties(value) {
+    $.utils.adopt(value, $.utils.getPointer(3, this));
+  }
+  _disownProperties() {
+    return $.utils.disown(this.properties);
+  }
+  get properties() {
+    return $.utils.getList(3, _FileMetadata._Properties, this);
+  }
+  _hasProperties() {
+    return !$.utils.isNull($.utils.getPointer(3, this));
+  }
+  _initProperties(length) {
+    return $.utils.initList(3, _FileMetadata._Properties, length, this);
+  }
+  set properties(value) {
+    $.utils.copyFrom(value, $.utils.getPointer(3, this));
+  }
+  toString() {
+    return "FileMetadata_" + super.toString();
+  }
+};
+var FileIdentifier = class extends $.Struct {
+  static {
+    __name(this, "FileIdentifier");
+  }
+  static _capnp = {
+    displayName: "FileIdentifier",
+    id: "e12b8732389d7406",
+    size: new $.ObjectSize(0, 2)
+  };
+  /**
+  * An additional identifier for the file.
+  *
+  */
+  get path() {
+    return $.utils.getText(0, this);
+  }
+  set path(value) {
+    $.utils.setText(0, value, this);
+  }
+  get id() {
+    return $.utils.getText(1, this);
+  }
+  set id(value) {
+    $.utils.setText(1, value, this);
+  }
+  toString() {
+    return "FileIdentifier_" + super.toString();
+  }
+};
+var FileData = class extends $.Struct {
+  static {
+    __name(this, "FileData");
+  }
+  static _capnp = {
+    displayName: "FileData",
+    id: "fa6725c8a360f9a2",
+    size: new $.ObjectSize(0, 2)
+  };
+  /**
+  * The contents of the file.
+  *
+  */
+  get path() {
+    return $.utils.getText(0, this);
+  }
+  set path(value) {
+    $.utils.setText(0, value, this);
+  }
+  get content() {
+    return $.utils.getText(1, this);
+  }
+  set content(value) {
+    $.utils.setText(1, value, this);
+  }
+  toString() {
+    return "FileData_" + super.toString();
+  }
+};
+var FileSystemData = class _FileSystemData extends $.Struct {
+  static {
+    __name(this, "FileSystemData");
+  }
+  static _capnp = {
+    displayName: "FileSystemData",
+    id: "aaa72a672ac0732f",
+    size: new $.ObjectSize(0, 3)
+  };
+  static _Ids;
+  static _Metadata;
+  static _Files;
+  _adoptIds(value) {
+    $.utils.adopt(value, $.utils.getPointer(0, this));
+  }
+  _disownIds() {
+    return $.utils.disown(this.ids);
+  }
+  get ids() {
+    return $.utils.getList(0, _FileSystemData._Ids, this);
+  }
+  _hasIds() {
+    return !$.utils.isNull($.utils.getPointer(0, this));
+  }
+  _initIds(length) {
+    return $.utils.initList(0, _FileSystemData._Ids, length, this);
+  }
+  set ids(value) {
+    $.utils.copyFrom(value, $.utils.getPointer(0, this));
+  }
+  _adoptMetadata(value) {
+    $.utils.adopt(value, $.utils.getPointer(1, this));
+  }
+  _disownMetadata() {
+    return $.utils.disown(this.metadata);
+  }
+  get metadata() {
+    return $.utils.getList(1, _FileSystemData._Metadata, this);
+  }
+  _hasMetadata() {
+    return !$.utils.isNull($.utils.getPointer(1, this));
+  }
+  _initMetadata(length) {
+    return $.utils.initList(1, _FileSystemData._Metadata, length, this);
+  }
+  set metadata(value) {
+    $.utils.copyFrom(value, $.utils.getPointer(1, this));
+  }
+  _adoptFiles(value) {
+    $.utils.adopt(value, $.utils.getPointer(2, this));
+  }
+  _disownFiles() {
+    return $.utils.disown(this.files);
+  }
+  get files() {
+    return $.utils.getList(2, _FileSystemData._Files, this);
+  }
+  _hasFiles() {
+    return !$.utils.isNull($.utils.getPointer(2, this));
+  }
+  _initFiles(length) {
+    return $.utils.initList(2, _FileSystemData._Files, length, this);
+  }
+  set files(value) {
+    $.utils.copyFrom(value, $.utils.getPointer(2, this));
+  }
+  toString() {
+    return "FileSystemData_" + super.toString();
+  }
+};
+FileMetadata._Properties = $.CompositeList(FileMetadata_KeyValuePair);
+FileSystemData._Ids = $.CompositeList(FileIdentifier);
+FileSystemData._Metadata = $.CompositeList(FileMetadata);
+FileSystemData._Files = $.CompositeList(FileData);
+
+// ../powerlines/src/types/vfs.ts
+var __VFS_PATCH__ = Symbol("__VFS_PATCH__");
+var __VFS_REVERT__ = Symbol("__VFS_REVERT__");
 var createLog = /* @__PURE__ */ __name((name, options = {}) => {
   const logLevel = options.logLevel === null ? LogLevelLabel.SILENT : options.logLevel || LogLevelLabel.INFO;
   if (logLevel === LogLevelLabel.SILENT) {
@@ -304,96 +541,8 @@ 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");
-
-// ../powerlines/src/types/commands.ts
-var SUPPORTED_COMMANDS = [
-  "new",
-  "clean",
-  "prepare",
-  "lint",
-  "test",
-  "build",
-  "docs",
-  "release",
-  "finalize"
-];
-
-// ../powerlines/src/plugin-utils/helpers.ts
-function isPlugin(value) {
-  return isSetObject(value) && "name" in value && isSetString(value.name) && (isUndefined(value.applyToEnvironment) || "applyToEnvironment" in value && isFunction(value.applyToEnvironment)) && (isUndefined(value.dedupe) || "dedupe" in value && isFunction(value.dedupe)) && (isUndefined(value.dependsOn) || "dependsOn" in value && Array.isArray(value.dependsOn) && value.dependsOn.every(isPluginConfig)) && SUPPORTED_COMMANDS.every((command) => isUndefined(value[command]) || command in value && (isFunction(value[command]) || isSetObject(value[command]) && "handler" in value[command] && isFunction(value[command].handler)));
-}
-__name(isPlugin, "isPlugin");
-function isPluginConfigObject(value) {
-  return isSetObject(value) && "plugin" in value && ((isSetString(value.plugin) || isFunction(value.plugin)) && "options" in value && isSetObject(value.options) || isPlugin(value.plugin));
-}
-__name(isPluginConfigObject, "isPluginConfigObject");
-function isPluginConfigTuple(value) {
-  return Array.isArray(value) && (value.length === 1 || value.length === 2) && ((isSetString(value[0]) || isFunction(value[0])) && value.length > 1 && isSetObject(value[1]) || isPlugin(value[0]));
-}
-__name(isPluginConfigTuple, "isPluginConfigTuple");
-function isPluginConfig(value) {
-  return isSetString(value) || isFunction(value) || isPlugin(value) || isPluginConfigObject(value) || isPluginConfigTuple(value);
-}
-__name(isPluginConfig, "isPluginConfig");
-function isPluginHookFunction(value) {
-  return isFunction(value) || isSetObject(value) && "handler" in value && isFunction(value.handler);
-}
-__name(isPluginHookFunction, "isPluginHookFunction");
-function isPluginHookObject(value) {
-  return isSetObject(value) && "handler" in value && isFunction(value.handler);
-}
-__name(isPluginHookObject, "isPluginHookObject");
-function isPluginHook(value) {
-  return isPluginHookFunction(value) || isPluginHookObject(value);
-}
-__name(isPluginHook, "isPluginHook");
-function getHookHandler(pluginHook) {
-  return isFunction(pluginHook) ? pluginHook : pluginHook.handler;
-}
-__name(getHookHandler, "getHookHandler");
-function isHookExternal(hook) {
-  return hook.startsWith("vite:") || hook.startsWith("esbuild:") || hook.startsWith("rolldown:") || hook.startsWith("rollup:") || hook.startsWith("webpack:") || hook.startsWith("rspack:") || hook.startsWith("farm:");
-}
-__name(isHookExternal, "isHookExternal");
-function checkDedupe(plugin, plugins2) {
-  return plugin.dedupe === false || plugins2.some((p) => p.dedupe !== false && (isFunction(p.dedupe) && p.dedupe(plugin) || p.name === plugin.name));
-}
-__name(checkDedupe, "checkDedupe");
-function addPluginHook(context, plugin, pluginHook, hooksList) {
-  if (!checkDedupe(plugin, hooksList.map((hook) => hook.plugin))) {
-    hooksList.push(isFunction(pluginHook) ? {
-      plugin,
-      handler: getHookHandler(pluginHook).bind(context)
-    } : {
-      plugin,
-      ...pluginHook,
-      handler: getHookHandler(pluginHook).bind(context)
-    });
-  }
-}
-__name(addPluginHook, "addPluginHook");
-function resolveOptions(options) {
-  return defu3(options, {
-    interopDefault: true,
-    fsCache: options.mode !== "development" ? joinPaths(options.cacheDir, "jiti") : false,
-    moduleCache: options.mode !== "development"
-  });
-}
-__name(resolveOptions, "resolveOptions");
-function createPluginResolver(options) {
-  return createJiti(joinPaths(options.workspaceRoot, options.projectRoot), resolveOptions({
-    ...options
-  }));
-}
-__name(createPluginResolver, "createPluginResolver");
-function createResolver(options) {
-  const baseResolver = createJiti(joinPaths(options.workspaceRoot, options.projectRoot), resolveOptions(options));
-  baseResolver.plugin = createPluginResolver(options);
-  return baseResolver;
-}
-__name(createResolver, "createResolver");
-function isBufferEncoding(options) {
-  return isSetString(options) || options === null;
+function isBufferEncoding(options) {
+  return isSetString(options) || options === null;
 }
 __name(isBufferEncoding, "isBufferEncoding");
 function isPowerlinesWriteFileOptions(options) {
@@ -540,160 +689,71 @@ function patchFS(originalFS, vfs) {
   };
 }
 __name(patchFS, "patchFS");
-var VirtualFileSystem = class {
+var UnifiedFS = class _UnifiedFS extends Union {
   static {
-    __name(this, "VirtualFileSystem");
+    __name(this, "UnifiedFS");
   }
   /**
   * The internal map of virtual files.
   */
-  #meta = {};
-  /**
-  * A map of unique identifiers to their virtual file paths.
-  */
-  #ids = {};
-  /**
-  * A map of virtual file paths to their underlying file content.
-  */
-  #cachedFS = /* @__PURE__ */ new Map();
-  /**
-  * A map of virtual file paths to their underlying file content.
-  */
-  #cachedResolver = /* @__PURE__ */ new Map();
-  /**
-  * The internal map of virtual files.
-  */
   #virtualFS = new Volume();
   /**
   * The physical file system.
   */
-  #fs = cloneFS(fs);
-  /**
-  * 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 = new Union();
-  /**
-  * Indicator specifying if the file system module is patched
-  */
-  #isPatched = false;
-  /**
-  * Function to revert require patch
-  */
-  #revert;
+  #physicalFS = cloneFS(fs);
   /**
-  * The context of the virtual file system.
+  * The context of the unified file system.
   */
   #context;
-  /**
-  * The file system's logging function.
-  */
-  #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) {
-    const formattedPath = this.formatPath(path);
-    return this.#virtualFS.existsSync(formattedPath) || this.#fs.existsSync(formattedPath) || this.resolveFS(path).existsSync(formattedPath);
-  }
-  /**
-  * Exposes the internal VFS map for advanced usage.
-  */
-  get [__VFS_CACHE__]() {
-    return this.#cachedFS;
-  }
-  /**
-  * Exposes the internal VFS resolver cache for advanced usage.
-  */
-  get [__VFS_RESOLVER__]() {
-    return this.#cachedResolver;
+  static create(context, data) {
+    let result = new _UnifiedFS(context, data);
+    result = result.use(result.#physicalFS);
+    if (result.#context.config.output.mode !== "fs") {
+      result = result.use(result.#virtualFS);
+    }
+    return result;
   }
   /**
-  * Exposes the internal VFS map for advanced usage.
+  * Gets the virtual file system (VFS).
   */
-  get [__VFS_VIRTUAL__]() {
+  get virtual() {
     return this.#virtualFS;
   }
   /**
-  * Exposes the internal UFS map for advanced usage.
-  */
-  get [__VFS_UNIFIED__]() {
-    return this.#unifiedFS;
-  }
-  /**
-  * A proxy to access the underlying file metadata.
-  */
-  get meta() {
-    return new Proxy(this.#meta, {
-      get: /* @__PURE__ */ __name((target, prop) => {
-        if (target[prop]) {
-          return {
-            id: prop,
-            mode: this.#virtualFS.existsSync(prop) ? "virtual" : this.#fs.existsSync(prop) ? "fs" : this.#context.config.output.mode,
-            details: {},
-            variant: "normal",
-            ...target[prop]
-          };
-        }
-        return void 0;
-      }, "get"),
-      set: /* @__PURE__ */ __name((target, prop, value) => {
-        target[prop] = value;
-        this.#ids[value.id || prop] = prop;
-        return true;
-      }, "set"),
-      deleteProperty: /* @__PURE__ */ __name((target, prop) => {
-        delete this.#ids[target[prop]?.id || prop];
-        delete target[prop];
-        return true;
-      }, "deleteProperty")
-    });
-  }
-  /**
-  * A map of module ids to their file paths.
+  * Gets the physical file system (FS).
   */
-  get ids() {
-    return this.#ids;
+  get physical() {
+    return this.#physicalFS;
   }
   /**
   * Creates a new instance of the VirtualFileSystem.
   *
   * @param context - The context of the virtual file system, typically containing options and logging functions.
-  * @param serialized - A map of files/file contents to populate in cache
+  * @param data - A buffer containing the serialized virtual file system data.
   */
-  constructor(context, serialized = {}) {
+  constructor(context, data) {
+    super();
     this.#context = context;
-    this.#cachedFS = /* @__PURE__ */ new Map();
-    this.#meta = Object.fromEntries(Object.entries(serialized.virtualFilesMeta ?? {}));
-    this.#ids = Object.fromEntries(Object.entries(this.#meta).map(([path, data]) => [
-      data.id || path,
-      path
-    ]));
-    if (!this.#fs.existsSync(this.#context.dataPath)) {
-      this.#fs.mkdirSync(this.#context.dataPath, {
+    if (!this.#physicalFS.existsSync(this.#context.dataPath)) {
+      this.#physicalFS.mkdirSync(this.#context.dataPath, {
         recursive: true
       });
     }
-    if (!this.#fs.existsSync(this.#context.cachePath)) {
-      this.#fs.mkdirSync(this.#context.cachePath, {
+    if (!this.#physicalFS.existsSync(this.#context.cachePath)) {
+      this.#physicalFS.mkdirSync(this.#context.cachePath, {
         recursive: true
       });
     }
-    if (!this.#fs.existsSync(joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.output.outputPath))) {
-      this.#fs.mkdirSync(joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.output.outputPath), {
+    if (!this.#physicalFS.existsSync(joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.output.outputPath))) {
+      this.#physicalFS.mkdirSync(joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.output.outputPath), {
         recursive: true
       });
     }
-    this.#unifiedFS = this.#unifiedFS.use(this.#fs);
     if (this.#context.config.output.mode !== "fs") {
-      if (serialized?.virtualFiles && Object.keys(serialized.virtualFiles).length > 0) {
-        this.#virtualFS = Volume.fromJSON(serialized.virtualFiles);
-      }
+      this.#virtualFS = Volume.fromJSON(data._hasFiles() && data.files.length > 0 ? data.files.values().reduce((ret, file) => {
+        ret[file.path] = file.content;
+        return ret;
+      }, {}) : {});
       if (!this.#virtualFS.existsSync(this.#context.artifactsPath)) {
         this.#virtualFS.mkdirSync(this.#context.artifactsPath, {
           recursive: true
@@ -714,926 +774,1168 @@ var VirtualFileSystem = class {
           recursive: true
         });
       }
-      this.#unifiedFS = this.#unifiedFS.use(this.#virtualFS);
     } else if (this.#context.config.projectType === "application") {
-      if (!this.#fs.existsSync(this.#context.artifactsPath)) {
-        this.#fs.mkdirSync(this.#context.artifactsPath, {
+      if (!this.#physicalFS.existsSync(this.#context.artifactsPath)) {
+        this.#physicalFS.mkdirSync(this.#context.artifactsPath, {
           recursive: true
         });
       }
-      if (!this.#fs.existsSync(this.#context.builtinsPath)) {
-        this.#fs.mkdirSync(this.#context.builtinsPath, {
+      if (!this.#physicalFS.existsSync(this.#context.builtinsPath)) {
+        this.#physicalFS.mkdirSync(this.#context.builtinsPath, {
           recursive: true
         });
       }
-      if (!this.#fs.existsSync(this.#context.entryPath)) {
-        this.#fs.mkdirSync(this.#context.entryPath, {
+      if (!this.#physicalFS.existsSync(this.#context.entryPath)) {
+        this.#physicalFS.mkdirSync(this.#context.entryPath, {
           recursive: true
         });
       }
-      if (!this.#fs.existsSync(this.#context.dtsPath)) {
-        this.#fs.mkdirSync(this.#context.dtsPath, {
+      if (!this.#physicalFS.existsSync(this.#context.dtsPath)) {
+        this.#physicalFS.mkdirSync(this.#context.dtsPath, {
           recursive: true
         });
       }
     }
-    this.#log = extendLog(this.#context.log, "virtual-file-system");
-  }
-  [__VFS_INIT__]() {
-    if (!this.#isPatched && this.#context.config.output.mode !== "fs") {
-      this.#revert = patchFS(fs, this);
-      this.#isPatched = true;
-    }
-  }
-  [__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;
-    }
   }
   /**
-  * Check if a path or id corresponds to a virtual file **(does not actually exists on disk)**.
+  * Select the file system module to use for the operation based on the path or URL.
   *
-  * @param pathOrId - The path or id to check.
-  * @param options - Optional parameters for resolving the path.
-  * @returns Whether the path or id corresponds to a virtual file **(does not actually exists on disk)**.
+  * @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.
   */
-  isVirtual(pathOrId, options = {}) {
-    if (!pathOrId) {
-      return false;
-    }
-    const resolvedPath = this.resolve(pathOrId, {
-      ...options,
-      type: "file"
-    });
-    if (!resolvedPath) {
-      return false;
+  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"
+      };
     }
-    return this.meta[resolvedPath]?.mode === "virtual";
+    return {
+      ...this,
+      mode: this.#context.config.output.mode
+    };
   }
   /**
-  * Check if a path or id corresponds to a file written to the file system **(actually exists on disk)**.
+  * Select the file system module to use for the operation based on the path or URL.
   *
-  * @param pathOrId - The path or id to check.
-  * @param options - Optional parameters for resolving the path.
-  * @returns Whether the path or id corresponds to a file written to the file system **(actually exists on disk)**.
+  * @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.
   */
-  isFs(pathOrId, options = {}) {
-    if (!pathOrId) {
-      return false;
-    }
-    const resolvedPath = this.resolve(pathOrId, {
-      ...options,
-      type: "file"
-    });
-    if (!resolvedPath) {
-      return 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.outputPath))) {
+      return "fs";
     }
-    return this.meta[resolvedPath]?.mode === "fs";
+    return void 0;
   }
   /**
-  * Check if a path exists within one of the directories specified in the tsconfig.json's `path` field.
+  * Serializes the virtual file system (VFS) to a JSON object.
   *
-  * @see https://www.typescriptlang.org/tsconfig#paths
-  *
-  * @param pathOrId - The path or ID to check.
-  * @returns Whether the path or ID corresponds to a virtual file.
+  * @returns A JSON representation of the virtual file system.
   */
-  isTsconfigPath(pathOrId) {
-    return !!this.#context.tsconfig.options.paths && Object.keys(this.#context.tsconfig.options.paths).some((path) => pathOrId.startsWith(path.replaceAll("*", "")));
+  toJSON() {
+    return this.#virtualFS.toJSON();
+  }
+};
+
+// ../powerlines/src/lib/fs/vfs.ts
+var VirtualFileSystem = class _VirtualFileSystem {
+  static {
+    __name(this, "VirtualFileSystem");
   }
   /**
-  * 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.
+  * A map of virtual file IDs to their associated metadata.
   */
-  readdirSync(path, options = "utf8") {
-    return this.resolveFS(path).readdirSync(toFilePath(path), options);
-  }
+  #metadata;
   /**
-  * Removes a file in the virtual file system (VFS).
-  *
-  * @param path - The path to create the directory at.
+  * A map of virtual file IDs to their underlying file paths.
   */
-  unlinkSync(path, options) {
-    const formattedPath = toFilePath(path);
-    if (!this.isFile(formattedPath)) {
-      return;
-    }
-    this.#log(LogLevelLabel.TRACE, `Synchronously removing file: ${formattedPath}`);
-    this.resolveFS(path, options).unlinkSync(formattedPath);
-    this.#cachedFS.delete(formattedPath);
-    this.clearResolverCache(formattedPath);
-  }
+  #ids;
   /**
-  * Removes a file in the virtual file system (VFS).
-  *
-  * @param path - The path to create the directory at.
+  * A map of underlying file paths to their virtual file IDs.
   */
-  async unlink(path, options) {
-    const formattedPath = toFilePath(path);
-    if (!this.isFile(formattedPath)) {
-      return;
-    }
-    this.#log(LogLevelLabel.TRACE, `Removing file: ${formattedPath}`);
-    if (isFunction(this.resolveFS(path, options).promises.unlink)) {
-      await this.resolveFS(path, options).promises.unlink(formattedPath);
-      this.#cachedFS.delete(formattedPath);
-      this.clearResolverCache(formattedPath);
-    } else {
-      this.unlinkSync(formattedPath, options);
-    }
-  }
+  #paths;
   /**
-  * Removes a directory in the virtual file system (VFS).
-  *
-  * @param path - The path to create the directory at.
-  * @param options - Options for creating the directory.
+  * A map of virtual file paths to their underlying file content.
   */
-  rmdirSync(path, options = {}) {
-    const formattedPath = toFilePath(path);
-    if (!this.isDirectory(formattedPath)) {
-      return;
-    }
-    this.#log(LogLevelLabel.TRACE, `Synchronously removing directory: ${formattedPath}`);
-    this.resolveFS(path, options).rmdirSync(formattedPath, defu3(options, {
-      recursive: true
-    }));
-    this.#cachedFS.delete(formattedPath);
-    this.clearResolverCache(formattedPath);
-  }
+  #cachedResolver = /* @__PURE__ */ new Map();
   /**
-  * Removes a directory in the virtual file system (VFS).
+  * The unified volume that combines the virtual file system with the real file system.
   *
-  * @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.
+  * @remarks
+  * This volume allows for seamless access to both virtual and real files.
   */
-  async rmdir(path, options = {}) {
-    const formattedPath = toFilePath(path);
-    if (!this.isDirectory(formattedPath)) {
-      return;
-    }
-    this.#log(LogLevelLabel.TRACE, `Removing directory: ${formattedPath}`);
-    if (isFunction(this.resolveFS(path, options).promises.rm)) {
-      await this.resolveFS(path, options).promises.rm(formattedPath, defu3(options, {
-        force: true,
-        recursive: true
-      }));
-      this.#cachedFS.delete(formattedPath);
-      this.clearResolverCache(formattedPath);
-    } else {
-      this.rmdirSync(formattedPath, defu3(options ?? {}, {
-        force: true,
-        recursive: true
-      }));
-    }
-  }
+  #unifiedFS;
   /**
-  * Removes a file in the virtual file system (VFS).
+  * Indicator specifying if the file system module is patched
+  */
+  #isPatched = false;
+  /**
+  * 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;
+  /**
+  * The file system's logging function.
+  */
+  #log;
+  /**
+  * Checks if a path exists in the virtual file system (VFS).
   *
-  * @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 check.
+  * @returns `true` if the path exists, otherwise `false`.
   */
-  async rm(path, options = {}) {
-    this.#log(LogLevelLabel.TRACE, `Removing: ${toFilePath(path)}`);
-    if (this.isDirectory(path)) {
-      return this.rmdir(path, options);
-    }
-    return this.unlink(path, options);
+  #existsSync(path) {
+    const formattedPath = this.formatPath(path);
+    return this.#unifiedFS.virtual.existsSync(formattedPath) || this.#unifiedFS.physical.existsSync(formattedPath) || this.#unifiedFS.resolveFS(path).existsSync(formattedPath);
   }
   /**
-  * Synchronously removes a file or directory in the virtual file system (VFS).
+  * Builds a regular expression from a string pattern for path matching.
   *
-  * @param path - The path to the file or directory to remove.
-  * @param options - Options for removing the file or directory.
+  * @param strPattern - The string pattern to convert.
+  * @returns A regular expression for matching paths.
   */
-  rmSync(path, options = {}) {
-    this.#log(LogLevelLabel.TRACE, `Removing: ${toFilePath(path)}`);
-    if (this.isDirectory(path)) {
-      return this.rmdirSync(path, options);
-    }
-    return this.unlinkSync(path, options);
+  #buildRegex(strPattern) {
+    const token = "::GLOBSTAR::";
+    return new RegExp(`^${this.formatPath(strPattern).replace(/\*\*/g, token).replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(new RegExp(token, "g"), ".*")}$`);
   }
   /**
-  * Creates a directory in the virtual file system (VFS).
+  * Formats a file id by removing the file extension and prepending the runtime prefix.
   *
-  * @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 id - The file ID to format.
+  * @returns The formatted file ID.
   */
-  mkdirSync(path, options = {}) {
-    const filePath = toFilePath(path);
-    this.clearResolverCache(filePath);
-    return this.resolveFS(filePath, options).mkdirSync(filePath, defu3(options ?? {}, {
-      recursive: true
-    }));
+  #formatId(id) {
+    const formattedId = toFilePath(id);
+    return `${this.#context.config.output.builtinPrefix}:${formattedId.replace(new RegExp(`^${this.#context.config.output.builtinPrefix}:`), "").replace(/^\\0/, "").replace(findFileDotExtensionSafe(formattedId), "")}`;
   }
   /**
-  * Creates a directory in the virtual file system (VFS).
+  * Resolves an id parameter to a corresponding virtual file path 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 id - The id to resolve.
+  * @returns The resolved file id if it exists, otherwise undefined.
   */
-  async mkdir(path, options = {}) {
-    let result;
-    const filePath = toFilePath(path);
-    if (isFunction(this.resolveFS(filePath, options).promises.mkdir)) {
-      result = await this.resolveFS(filePath, options).promises.mkdir(filePath, defu3(options ?? {}, {
-        recursive: true
-      }));
-    } else {
-      result = this.resolveFS(filePath, options).mkdirSync(filePath, defu3(options ?? {}, {
-        recursive: true
-      }));
+  #resolveId(id) {
+    if (this.#ids[this.#formatId(id)]) {
+      return this.#ids[this.#formatId(id)] || false;
     }
-    this.clearResolverCache(filePath);
-    return result;
+    return false;
   }
   /**
-  * Glob files in the virtual file system (VFS) based on the provided pattern(s).
+  * Resolves a path parameter to a corresponding virtual file path in the virtual file system (VFS).
   *
-  * @param patterns - A pattern (or multiple patterns) to use to determine the file paths to return
-  * @returns An array of file paths matching the provided pattern(s)
+  * @param path - The path to resolve.
+  * @param options - Optional parameters for resolving the path.
+  * @returns The resolved file path if it exists, otherwise undefined.
   */
-  async glob(patterns) {
-    const results = [];
-    for (const pattern of toArray(patterns)) {
-      const normalized = this.formatPath(pattern);
-      if (!/[*?[\]{}]/.test(normalized) && !normalized.includes("**")) {
-        const resolved = this.resolve(normalized, {
-          type: "file"
-        });
-        if (resolved && !results.includes(resolved)) {
-          results.push(resolved);
-        }
-        continue;
+  #resolvePath(path, options = {}) {
+    if (isAbsolutePath(path)) {
+      if (this.#existsSync(path)) {
+        return path;
       }
-      const absPattern = isAbsolutePath(normalized) ? normalized : this.formatPath(joinPaths(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.formatPath(joinPaths(dir, entry));
-          let stats;
-          try {
-            stats = this.#unifiedFS.lstatSync(full);
-          } catch {
-            stats = void 0;
-          }
-          if (!stats) continue;
-          if (stats.isDirectory()) {
-            stack.push(full);
-          } else if (stats.isFile()) {
-            if (this.buildRegex(absPattern).test(full)) {
-              const resolved = this.resolve(full, {
-                type: "file"
-              });
-              if (resolved && !results.includes(resolved)) {
-                results.push(resolved);
-              }
-            }
-          }
-        }
+      const result = this.#checkVariants(path);
+      if (result) {
+        return result;
       }
     }
-    return results;
-  }
-  /**
-  * Synchronously glob files in the virtual file system (VFS) based on the provided pattern(s).
-  *
-  * @param patterns - A pattern (or multiple patterns) to use to determine the file paths to return
-  * @returns An array of file paths matching the provided pattern(s)
-  */
-  globSync(patterns) {
-    const results = [];
-    for (const pattern of toArray(patterns)) {
-      const normalized = this.formatPath(pattern);
-      if (!/[*?[\]{}]/.test(normalized) && !normalized.includes("**")) {
-        const resolved = this.resolve(normalized, {
-          type: "file"
-        });
-        if (resolved && !results.includes(resolved)) {
-          results.push(resolved);
-        }
-        continue;
+    for (const parentPath of this.#resolveParentPaths(path, options.paths)) {
+      const request = joinPaths$1(parentPath, path);
+      if (this.#existsSync(request)) {
+        return request;
       }
-      const absPattern = isAbsolutePath(normalized) ? normalized : this.formatPath(joinPaths(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.formatPath(joinPaths(dir, entry));
-          let stats;
-          try {
-            stats = this.#unifiedFS.lstatSync(full);
-          } catch {
-            stats = void 0;
-          }
-          if (!stats) continue;
-          if (stats.isDirectory()) {
-            stack.push(full);
-          } else if (stats.isFile()) {
-            if (this.buildRegex(absPattern).test(full)) {
-              const resolved = this.resolve(full, {
-                type: "file"
-              });
-              if (resolved && !results.includes(resolved)) {
-                results.push(resolved);
-              }
-            }
-          }
-        }
+      const result = this.#checkVariants(request);
+      if (result) {
+        return result;
       }
     }
-    return results;
+    return false;
   }
   /**
-  * Moves a file from one path to another in the virtual file system (VFS).
+  * Resolves parent paths for a given request.
   *
-  * @param srcPath - The source path to move
-  * @param destPath - The destination path to move to
+  * @param request - The request path to resolve parent paths for.
+  * @param parents - An optional array of parent paths to consider.
+  * @returns An array of resolved parent paths.
   */
-  async move(srcPath, destPath) {
-    const content = await this.readFile(srcPath);
-    await this.writeFile(destPath, content);
-    await this.rm(srcPath);
+  #resolveParentPaths(request, parents = []) {
+    let paths = [
+      this.#context.workspaceConfig.workspaceRoot,
+      joinPaths$1(this.#context.workspaceConfig.workspaceRoot, this.#context.config.projectRoot)
+    ];
+    if (this.#context.tsconfig.options.paths) {
+      paths = this.#context.tsconfig.options.paths ? Object.keys(this.#context.tsconfig.options.paths).filter((tsconfigPath) => request.startsWith(tsconfigPath.replaceAll("*", ""))).map((tsconfigPath) => this.#context.tsconfig.options.paths?.[tsconfigPath]).flat().reduce((ret, path) => {
+        if (path && !ret.includes(joinPaths$1(this.#context.workspaceConfig.workspaceRoot, path))) {
+          ret.push(joinPaths$1(this.#context.workspaceConfig.workspaceRoot, path));
+        }
+        return ret;
+      }, paths) : paths;
+    }
+    return paths.reduce((ret, path) => {
+      if (!ret.includes(path)) {
+        ret.push(path);
+      }
+      return ret;
+    }, parents.filter(Boolean).map((p) => this.formatPath(p)));
   }
   /**
-  * Synchronously moves a file from one path to another in the virtual file system (VFS).
+  * Clears the resolver cache for a given path.
   *
-  * @param srcPath - The source path to move
-  * @param destPath - The destination path to move to
+  * @param path - The path to clear the resolver cache for.
   */
-  moveSync(srcPath, destPath) {
-    const content = this.readFileSync(srcPath);
-    this.writeFileSync(destPath, content);
-    this.rmSync(srcPath);
+  #clearResolverCache(path) {
+    this.#cachedResolver.keys().filter((key) => key.startsWith(toFilePath(path))).forEach((key) => this.#cachedResolver.delete(key));
   }
   /**
-  * Copies a file from one path to another in the virtual file system (VFS).
+  * Check if the file exists with different variants (index, extensions).
   *
-  * @param srcPath - The source path to copy
-  * @param destPath - The destination path to copy to
+  * @param request - The request path to check.
+  * @param parentPath - An optional parent path to prepend to the request.
+  * @returns The file path if it exists, otherwise false.
   */
-  async copy(srcPath, destPath) {
-    const content = await this.readFile(srcPath);
-    await this.writeFile(destPath, content);
+  #checkVariants(request, parentPath) {
+    const path = parentPath ? joinPaths$1(parentPath, request) : request;
+    let file = this.#checkExtensions(path);
+    if (file) {
+      return file;
+    }
+    file = this.#checkIndex(path);
+    if (file) {
+      return file;
+    }
+    return false;
   }
   /**
-  * Synchronously copies a file from one path to another in the virtual file system (VFS).
+  * Check if the index file exists in the given request path.
   *
-  * @param srcPath - The source path to copy
-  * @param destPath - The destination path to copy to
-  */
-  copySync(srcPath, destPath) {
-    const content = this.readFileSync(srcPath);
-    this.writeFileSync(destPath, content);
-  }
-  /**
-  * Lists files in a given path.
-  *
-  * @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.
-  */
-  async readdir(pathOrId, options = "utf8") {
-    return this.resolveFS(pathOrId).promises.readdir(toFilePath(pathOrId), options);
-  }
-  /**
-  * Asynchronously reads a file from the virtual file system (VFS).
-  *
-  * @param pathOrId - 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.
+  * @param request - The request path to check.
+  * @returns The index file path if it exists, otherwise false.
   */
-  async readFile(pathOrId, options = "utf8") {
-    if (!pathOrId) {
-      return void 0;
+  #checkIndex(request) {
+    let file = joinPaths$1(request, "index");
+    if (this.#existsSync(file)) {
+      return file;
     }
-    const filePath = this.resolve(toFilePath(pathOrId), {
-      type: "file"
-    });
-    if (filePath) {
-      if (this.#cachedFS.has(filePath)) {
-        return this.#cachedFS.get(filePath);
-      }
-      let result;
-      if (isFunction(this.resolveFS(filePath).promises.readFile)) {
-        result = (await this.resolveFS(filePath).promises.readFile(filePath, options))?.toString("utf8");
-      } else {
-        result = this.resolveFS(filePath).readFileSync(filePath, options);
-      }
-      const content = isBuffer(result) ? bufferToString(result) : result;
-      this.#cachedFS.set(filePath, content);
-      return content;
+    file = this.#checkExtensions(file);
+    if (file) {
+      return file;
     }
-    return void 0;
+    return false;
   }
   /**
-  * Synchronously reads a file from the virtual file system (VFS).
+  * Check if the file exists with different extensions.
   *
-  * @param pathOrId - 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.
+  * @param request - The request path to check.
+  * @returns The file path if it exists with any of the checked extensions, otherwise false.
   */
-  readFileSync(pathOrId, options = "utf8") {
-    if (!pathOrId) {
-      return void 0;
+  #checkExtensions(request) {
+    let file = `${request}.ts`;
+    if (this.#existsSync(file)) {
+      return file;
     }
-    const filePath = this.resolve(toFilePath(pathOrId), {
-      type: "file"
-    });
-    if (filePath) {
-      if (this.#cachedFS.has(filePath)) {
-        return this.#cachedFS.get(filePath);
-      }
-      const result = this.resolveFS(filePath).readFileSync(filePath, options);
-      const content = isBuffer(result) ? bufferToString(result) : result;
-      this.#cachedFS.set(filePath, content);
-      return content;
+    file = `${request}.mts`;
+    if (this.#existsSync(file)) {
+      return file;
     }
-    return void 0;
-  }
-  /**
-  * Writes a file to the virtual file system (VFS).
-  *
-  * @param path - The path to the file.
-  * @param data - The contents of the file.
-  * @param options - Optional parameters for writing the file.
-  * @returns A promise that resolves when the file is written.
-  */
-  async writeFile(path, data = "", options = "utf8") {
-    const formattedPath = this.formatPath(path);
-    if (!this.isDirectory(findFilePath(formattedPath))) {
-      await this.mkdir(findFilePath(formattedPath), isPowerlinesWriteFileOptions(options) ? options : void 0);
+    file = `${request}.cts`;
+    if (this.#existsSync(file)) {
+      return file;
     }
-    let code = isPowerLinesWriteFileData(data) ? data.code : data;
-    if ((!isPowerlinesWriteFileOptions(options) || !options.skipFormat) && isSetString(code)) {
-      const resolvedConfig = await resolveConfig(formattedPath);
-      if (resolvedConfig) {
-        code = await format(code, {
-          absolutePath: formattedPath,
-          ...resolvedConfig
-        });
-      }
+    file = `${request}.tsx`;
+    if (this.#existsSync(file)) {
+      return file;
     }
-    const outputMode = this.resolveOutputMode(formattedPath, isPowerlinesWriteFileOptions(options) ? options : void 0);
-    this.#log(LogLevelLabel.TRACE, `Writing ${formattedPath} file to the ${outputMode === "fs" ? "" : "virtual "}file system (size: ${prettyBytes(new Blob(toArray(code)).size)})`);
-    this.meta[formattedPath] = {
-      path: formattedPath,
-      code,
-      mode: outputMode,
-      variant: "normal",
-      ...isPowerLinesWriteFileData(data) ? data : {}
-    };
-    this.clearResolverCache(formattedPath);
-    const ifs = this.resolveFS(formattedPath, isPowerlinesWriteFileOptions(options) ? options : void 0);
-    if (isFunction(ifs.promises.writeFile)) {
-      return ifs.promises.writeFile(formattedPath, code, isNodeWriteFileOptions(options) ? options : "utf8");
+    file = `${request}.js`;
+    if (this.#existsSync(file)) {
+      return file;
     }
-    return ifs.writeFileSync(formattedPath, code, isNodeWriteFileOptions(options) ? options : "utf8");
+    file = `${request}.mjs`;
+    if (this.#existsSync(file)) {
+      return file;
+    }
+    file = `${request}.cjs`;
+    if (this.#existsSync(file)) {
+      return file;
+    }
+    file = `${request}.jsx`;
+    if (this.#existsSync(file)) {
+      return file;
+    }
+    file = `${request}.json`;
+    if (this.#existsSync(file)) {
+      return file;
+    }
+    file = `${request}.d.ts`;
+    if (this.#existsSync(file)) {
+      return file;
+    }
+    return false;
   }
   /**
-  * Synchronously writes a file to the virtual file system (VFS).
+  * Creates a virtual file system (VFS) that is backed up to a Cap'n Proto message buffer.
   *
-  * @param path - The file to write.
-  * @param data - The contents of the file.
-  * @param options - Optional parameters for writing the file.
+  * @param context - The context of the virtual file system, typically containing options and logging functions.
+  * @returns A promise that resolves to a new virtual file system instance.
   */
-  writeFileSync(path, data = "", options = "utf8") {
-    const formattedPath = this.formatPath(path);
-    if (!this.isDirectory(findFilePath(formattedPath))) {
-      this.mkdirSync(findFilePath(formattedPath), isPowerlinesWriteFileOptions(options) ? options : void 0);
-    }
-    const code = isPowerLinesWriteFileData(data) ? data.code : data;
-    const outputMode = this.resolveOutputMode(formattedPath, isPowerlinesWriteFileOptions(options) ? options : void 0);
-    this.#log(LogLevelLabel.TRACE, `Writing ${formattedPath} file to the ${outputMode === "fs" ? "" : "virtual "}file system (size: ${prettyBytes(new Blob(toArray(code)).size)})`);
-    this.meta[formattedPath] = {
-      path: formattedPath,
-      code,
-      mode: outputMode,
-      variant: "normal",
-      ...isPowerLinesWriteFileData(data) ? data : {}
-    };
-    this.clearResolverCache(formattedPath);
-    const writeStream = this.resolveFS(formattedPath, isPowerlinesWriteFileOptions(options) ? options : void 0).createWriteStream(formattedPath);
-    try {
-      writeStream.write(code);
-    } finally {
-      writeStream.close();
+  static async create(context) {
+    if (!context.config.skipCache && existsSync(joinPaths$1(context.cachePath, "fs.bin"))) {
+      const buffer = await readFileBuffer(joinPaths$1(context.cachePath, "fs.bin"));
+      const message2 = new $.Message(buffer, false);
+      return new _VirtualFileSystem(context, message2.getRoot(FileSystemData));
     }
+    const message = new $.Message();
+    return new _VirtualFileSystem(context, message.initRoot(FileSystemData));
   }
   /**
-  * Synchronously checks if a file exists in the virtual file system (VFS).
+  * Synchronously creates a virtual file system (VFS) that is backed up to a Cap'n Proto message buffer.
   *
-  * @param pathOrId - The path or ID of the file to check.
-  * @returns `true` if the file exists, otherwise `false`.
+  * @param context - The context of the virtual file system, typically containing options and logging functions.
+  * @returns A new virtual file system instance.
   */
-  existsSync(pathOrId) {
-    return this.resolve(pathOrId) !== false;
+  static createSync(context) {
+    if (!context.config.skipCache && existsSync(joinPaths$1(context.cachePath, "fs.bin"))) {
+      const buffer = readFileBufferSync(joinPaths$1(context.cachePath, "fs.bin"));
+      const message2 = new $.Message(buffer, false);
+      return new _VirtualFileSystem(context, message2.getRoot(FileSystemData));
+    }
+    const message = new $.Message();
+    return new _VirtualFileSystem(context, message.initRoot(FileSystemData));
   }
   /**
-  * Retrieves the metadata of a file in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID of the file to retrieve metadata for.
-  * @returns The metadata of the file, or undefined if the file does not exist.
+  * A map of file ids to their metadata.
   */
-  getMetadata(pathOrId) {
-    const resolved = this.resolve(pathOrId);
-    if (resolved && this.meta[resolved]) {
-      return this.meta[resolved];
-    }
-    return void 0;
+  get metadata() {
+    return this.#metadata;
   }
   /**
-  * 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`.
+  * A map of module ids to their file paths.
   */
-  isFile(pathOrId) {
-    const resolved = this.resolve(pathOrId);
-    return !!(resolved && (this.#virtualFS.existsSync(resolved) && this.#virtualFS.lstatSync(resolved).isFile() || this.#fs.existsSync(resolved) && this.#fs.lstatSync(resolved).isFile() || this.resolveFS(resolved).existsSync(resolved) && this.resolveFS(resolved).lstatSync(resolved).isFile()));
+  get ids() {
+    return this.#ids;
   }
   /**
-  * 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`.
+  * A map of virtual file paths to their IDs.
   */
-  isDirectory(pathOrId) {
-    const resolved = this.resolve(pathOrId);
-    return !!(resolved && (this.#virtualFS.existsSync(resolved) && this.#virtualFS.lstatSync(resolved).isDirectory() || this.#fs.existsSync(resolved) && this.#fs.lstatSync(resolved).isDirectory() || this.resolveFS(resolved).existsSync(resolved) && this.resolveFS(resolved).lstatSync(resolved).isDirectory()));
+  get paths() {
+    return this.#paths;
   }
   /**
-  * Retrieves the status of a file in the virtual file system (VFS).
+  * Creates a new instance of the {@link VirtualFileSystem}.
   *
-  * @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.
+  * @param context - The context of the virtual file system, typically containing options and logging functions.
+  * @param data - A buffer containing the serialized virtual file system data.
   */
-  async stat(pathOrId, options) {
-    return this.resolveFS(pathOrId).promises.stat(this.resolve(toFilePath(pathOrId)) || toFilePath(pathOrId), options);
+  constructor(context, data) {
+    this.#context = context;
+    this.#unifiedFS = UnifiedFS.create(context, data);
+    this.#metadata = {};
+    if (data._hasMetadata()) {
+      this.#metadata = data.metadata.values().reduce((ret, data2) => {
+        ret[data2.id] = {
+          id: data2.id,
+          variant: data2.variant,
+          mode: data2.mode,
+          properties: data2._hasProperties() ? data2.properties.values().reduce((ret2, item) => {
+            ret2[item.key] = item.value;
+            return ret2;
+          }, {}) : {}
+        };
+        return ret;
+      }, {});
+    }
+    this.#ids = {};
+    this.#paths = {};
+    if (data._hasIds()) {
+      this.#ids = data.ids.values().reduce((ret, data2) => {
+        ret[data2.id] ??= data2.path;
+        ret[data2.path] ??= data2.path;
+        return ret;
+      }, {});
+      this.#paths = data.ids.values().reduce((ret, data2) => {
+        ret[data2.path] ??= data2.id;
+        return ret;
+      }, {});
+    }
+    this.#log = extendLog(this.#context.log, "file-system");
   }
   /**
-  * Synchronously retrieves the status of a file in the virtual file system (VFS).
+  * Check if a path or id corresponds to a virtual file **(does not actually exists on disk)**.
   *
-  * @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.
+  * @param pathOrId - The path or id to check.
+  * @param options - Optional parameters for resolving the path.
+  * @returns Whether the path or id corresponds to a virtual file **(does not actually exists on disk)**.
   */
-  statSync(pathOrId) {
-    return this.resolveFS(pathOrId).statSync(this.resolve(toFilePath(pathOrId)) || toFilePath(pathOrId));
+  isVirtual(pathOrId, options = {}) {
+    if (!pathOrId) {
+      return false;
+    }
+    const resolvedPath = this.resolve(pathOrId, {
+      ...options,
+      type: "file"
+    });
+    if (!resolvedPath) {
+      return false;
+    }
+    return this.metadata[resolvedPath]?.mode === "virtual";
   }
   /**
-  * Retrieves the status of a symbolic link in the virtual file system (VFS).
+  * 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 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.
+  * @param pathOrId - The path or id to check.
+  * @param options - Optional parameters for resolving the path.
+  * @returns Whether the path or id corresponds to a file written to the file system **(actually exists on disk)**.
   */
-  async lstat(pathOrId, options) {
-    return this.resolveFS(pathOrId).promises.lstat(this.resolve(toFilePath(pathOrId)) || toFilePath(pathOrId), options);
+  isPhysical(pathOrId, options = {}) {
+    if (!pathOrId) {
+      return false;
+    }
+    const resolvedPath = this.resolve(pathOrId, {
+      ...options,
+      type: "file"
+    });
+    if (!resolvedPath) {
+      return false;
+    }
+    return this.metadata[resolvedPath]?.mode === "fs";
   }
   /**
-  * Synchronously retrieves the status of a symbolic link in the virtual file system (VFS).
+  * Lists files in a given path.
   *
-  * @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.
+  * @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.
   */
-  lstatSync(pathOrId, options) {
-    return this.resolveFS(pathOrId).lstatSync(this.resolve(toFilePath(pathOrId)) || toFilePath(pathOrId), options);
+  readdirSync(path, options = "utf8") {
+    return this.#unifiedFS.resolveFS(path).readdirSync(toFilePath(path), options);
   }
   /**
-  * Resolves a path based on TypeScript's `tsconfig.json` paths.
-  *
-  * @see https://www.typescriptlang.org/tsconfig#paths
+  * Removes a file in the virtual file system (VFS).
   *
-  * @param path - The path to check.
-  * @returns The resolved file path if it exists, otherwise undefined.
+  * @param path - The path to create the directory at.
   */
-  resolveTsconfigPath(path) {
-    if (this.#context.tsconfig.options.paths) {
-      for (const tsconfigPathKey of Object.keys(this.#context.tsconfig.options.paths).filter((tsconfigPath) => path.startsWith(tsconfigPath.replaceAll("*", "")))) {
-        const resolvedPath = this.#context.tsconfig.options.paths[tsconfigPathKey]?.find((tsconfigPath) => this.resolvePath(joinPaths(this.#context.workspaceConfig.workspaceRoot, tsconfigPath.replaceAll("*", ""), path.replace(tsconfigPathKey.replaceAll("*", ""), ""))) || this.formatPath(tsconfigPath) === this.formatPath(path));
-        if (resolvedPath) {
-          return this.formatPath(resolvedPath) === this.formatPath(path) ? this.formatPath(resolvedPath) : this.resolvePath(joinPaths(this.#context.workspaceConfig.workspaceRoot, resolvedPath.replaceAll("*", ""), path.replace(tsconfigPathKey.replaceAll("*", ""), "")));
-        }
-      }
+  unlinkSync(path, options) {
+    const formattedPath = toFilePath(path);
+    if (!this.isFile(formattedPath)) {
+      return;
     }
-    return false;
+    this.#log(LogLevelLabel.TRACE, `Synchronously removing file: ${formattedPath}`);
+    this.#unifiedFS.resolveFS(path, options).unlinkSync(formattedPath);
+    if (this.paths[formattedPath] && this.metadata[this.paths[formattedPath]]) {
+      delete this.metadata[this.paths[formattedPath]];
+    }
+    this.#clearResolverCache(formattedPath);
   }
   /**
-  * Resolves a path based on TypeScript's `tsconfig.json` paths.
-  *
-  * @see https://www.typescriptlang.org/tsconfig#paths
+  * Removes a file in the virtual file system (VFS).
   *
-  * @param path - The path to check.
-  * @returns The resolved file path if it exists, otherwise undefined.
+  * @param path - The path to create the directory at.
   */
-  resolveTsconfigPathPackage(path) {
-    if (this.#context.tsconfig.options.paths) {
-      const tsconfigPathKeys = Object.keys(this.#context.tsconfig.options.paths).filter((tsconfigPath) => path.startsWith(tsconfigPath.replaceAll("*", "")));
-      if (tsconfigPathKeys.length > 0 && tsconfigPathKeys[0]) {
-        return tsconfigPathKeys[0].replace(/\/\*$/, "");
+  async unlink(path, options) {
+    const formattedPath = toFilePath(path);
+    if (!this.isFile(formattedPath)) {
+      return;
+    }
+    this.#log(LogLevelLabel.TRACE, `Removing file: ${formattedPath}`);
+    if (isFunction(this.#unifiedFS.resolveFS(path, options).promises.unlink)) {
+      await this.#unifiedFS.resolveFS(path, options).promises.unlink(formattedPath);
+      if (this.paths[formattedPath] && this.metadata[this.paths[formattedPath]]) {
+        delete this.metadata[this.paths[formattedPath]];
       }
+      this.#clearResolverCache(formattedPath);
+    } else {
+      this.unlinkSync(formattedPath, options);
     }
-    return false;
   }
   /**
-  * Resolves a path or ID to its real path in the virtual file system (VFS).
+  * Removes a directory in the virtual file system (VFS).
   *
-  * @param pathOrId - The path or ID to resolve.
-  * @returns The resolved real path if it exists, otherwise undefined.
+  * @param path - The path to create the directory at.
+  * @param options - Options for creating the directory.
   */
-  realpathSync(pathOrId) {
-    const filePath = this.resolve(toFilePath(pathOrId));
-    if (!filePath) {
-      throw new Error(`File not found: ${toFilePath(pathOrId)}`);
+  rmdirSync(path, options = {}) {
+    const formattedPath = toFilePath(path);
+    if (!this.isDirectory(formattedPath)) {
+      return;
     }
-    return filePath;
+    this.#log(LogLevelLabel.TRACE, `Synchronously removing directory: ${formattedPath}`);
+    this.#unifiedFS.resolveFS(path, options).rmdirSync(formattedPath, defu2(options, {
+      recursive: true
+    }));
+    this.#clearResolverCache(formattedPath);
   }
   /**
-  * Resolves a path or ID parameter to a corresponding virtual file path in the virtual file system (VFS).
+  * Removes a directory in the virtual file system (VFS).
   *
-  * @param pathOrId - The path or ID to resolve.
-  * @param options - Optional parameters for resolving the path, such as whether to include the file extension.
-  * @returns The resolved file path if it exists, otherwise undefined.
+  * @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.
   */
-  resolve(pathOrId, options = {}) {
-    const formattedPathOrId = toFilePath(pathOrId);
-    const resolverKey = `${formattedPathOrId}${options.withExtension ? "-ext" : ""}${options.paths ? `-${murmurhash(options.paths)}` : ""}${options.type ? `-${options.type}` : ""}`;
-    if (this.#cachedResolver.has(resolverKey)) {
-      return this.#cachedResolver.get(resolverKey);
-    }
-    let result = this.resolveId(formattedPathOrId);
-    if (!result) {
-      result = this.resolvePath(formattedPathOrId, options);
-    }
-    if (!result) {
-      result = false;
+  async rmdir(path, options = {}) {
+    const formattedPath = toFilePath(path);
+    if (!this.isDirectory(formattedPath)) {
+      return;
     }
-    if (result && options.withExtension === false) {
-      return result.replace(/\.[m|c]?[t|j]sx?$/, "");
+    this.#log(LogLevelLabel.TRACE, `Removing directory: ${formattedPath}`);
+    if (isFunction(this.#unifiedFS.resolveFS(path, options).promises.rm)) {
+      await this.#unifiedFS.resolveFS(path, options).promises.rm(formattedPath, defu2(options, {
+        force: true,
+        recursive: true
+      }));
+      this.#clearResolverCache(formattedPath);
+    } else {
+      this.rmdirSync(formattedPath, defu2(options ?? {}, {
+        force: true,
+        recursive: true
+      }));
     }
-    this.#cachedResolver.set(resolverKey, result);
-    return result;
   }
   /**
-  * Retrieves the partial metadata for all files in the virtual file system (VFS).
+  * Removes a file in the virtual file system (VFS).
   *
-  * @returns A record containing the partial metadata for all files.
+  * @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.
   */
-  getPartialMeta() {
-    return Object.fromEntries(Object.entries(this.#meta).filter(([_, data]) => isSetObject(data)));
-  }
-  buildRegex(strPattern) {
-    const token = "::GLOBSTAR::";
-    return new RegExp(`^${this.formatPath(strPattern).replace(/\*\*/g, token).replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(new RegExp(token, "g"), ".*")}$`);
+  async rm(path, options = {}) {
+    this.#log(LogLevelLabel.TRACE, `Removing: ${toFilePath(path)}`);
+    if (this.isDirectory(path)) {
+      return this.rmdir(path, options);
+    }
+    return this.unlink(path, options);
   }
   /**
-  * Converts a relative path to an absolute path based on the workspace and project root.
+  * Synchronously removes a file or directory in the virtual file system (VFS).
   *
-  * @param path - The relative path to convert.
-  * @returns The absolute path.
+  * @param path - The path to the file or directory to remove.
+  * @param options - Options for removing the file or directory.
   */
-  formatPath(path) {
-    const formattedPath = toFilePath(path);
-    if (isAbsolutePath(formattedPath) || formattedPath.startsWith(this.#context.workspaceConfig.workspaceRoot)) {
-      return formattedPath;
-    } else if (formattedPath.startsWith(this.#context.config.projectRoot)) {
-      return joinPaths(this.#context.workspaceConfig.workspaceRoot, formattedPath);
+  rmSync(path, options = {}) {
+    this.#log(LogLevelLabel.TRACE, `Removing: ${toFilePath(path)}`);
+    if (this.isDirectory(path)) {
+      return this.rmdirSync(path, options);
     }
-    return formattedPath;
+    return this.unlinkSync(path, options);
   }
   /**
-  * Formats a file id by removing the file extension and prepending the runtime prefix.
+  * Creates a directory in the virtual file system (VFS).
   *
-  * @param id - The file ID to format.
-  * @returns The formatted file ID.
+  * @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.
   */
-  formatId(id) {
-    const formattedId = toFilePath(id);
-    return `${this.#context.config.output.builtinPrefix}:${formattedId.replace(new RegExp(`^${this.#context.config.output.builtinPrefix}:`), "").replace(/^\\0/, "").replace(findFileDotExtensionSafe(formattedId), "")}`;
+  mkdirSync(path, options = {}) {
+    const filePath = toFilePath(path);
+    this.#clearResolverCache(filePath);
+    return this.#unifiedFS.resolveFS(filePath, options).mkdirSync(filePath, defu2(options ?? {}, {
+      recursive: true
+    }));
   }
   /**
-  * Resolves an id parameter to a corresponding virtual file path in the virtual file system (VFS).
+  * Creates a directory in the virtual file system (VFS).
   *
-  * @param id - The id to resolve.
-  * @returns The resolved file id if it exists, otherwise undefined.
+  * @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.
   */
-  resolveId(id) {
-    if (this.#ids[this.formatId(id)]) {
-      return this.#ids[this.formatId(id)] || false;
+  async mkdir(path, options = {}) {
+    let result;
+    const filePath = toFilePath(path);
+    if (isFunction(this.#unifiedFS.resolveFS(filePath, options).promises.mkdir)) {
+      result = await this.#unifiedFS.resolveFS(filePath, options).promises.mkdir(filePath, defu2(options ?? {}, {
+        recursive: true
+      }));
+    } else {
+      result = this.#unifiedFS.resolveFS(filePath, options).mkdirSync(filePath, defu2(options ?? {}, {
+        recursive: true
+      }));
     }
-    return false;
+    this.#clearResolverCache(filePath);
+    return result;
   }
   /**
-  * Resolves a path parameter to a corresponding virtual file path in the virtual file system (VFS).
+  * Glob files in the virtual file system (VFS) based on the provided pattern(s).
   *
-  * @param path - The path to resolve.
-  * @param options - Optional parameters for resolving the path.
-  * @returns The resolved file path if it exists, otherwise undefined.
+  * @param patterns - A pattern (or multiple patterns) to use to determine the file paths to return
+  * @returns An array of file paths matching the provided pattern(s)
   */
-  resolvePath(path, options = {}) {
-    if (isAbsolutePath(path)) {
-      if (this.#existsSync(path)) {
-        return path;
-      }
-      const result = this.checkVariants(path);
-      if (result) {
-        return result;
-      }
-    }
-    for (const parentPath of this.resolveParentPaths(path, options.paths)) {
-      const request = joinPaths(parentPath, path);
-      if (this.#existsSync(request)) {
-        return request;
+  async glob(patterns) {
+    const results = [];
+    for (const pattern of toArray(patterns)) {
+      const normalized = this.formatPath(pattern);
+      if (!/[*?[\]{}]/.test(normalized) && !normalized.includes("**")) {
+        const resolved = this.resolve(normalized, {
+          type: "file"
+        });
+        if (resolved && !results.includes(resolved)) {
+          results.push(resolved);
+        }
+        continue;
       }
-      const result = this.checkVariants(request);
-      if (result) {
-        return result;
+      const absPattern = isAbsolutePath(normalized) ? normalized : this.formatPath(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.formatPath(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.resolve(full, {
+                type: "file"
+              });
+              if (resolved && !results.includes(resolved)) {
+                results.push(resolved);
+              }
+            }
+          }
+        }
       }
     }
-    return false;
+    return results;
   }
-  resolveParentPaths(request, parents = []) {
-    let paths = [
-      this.#context.workspaceConfig.workspaceRoot,
-      joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.projectRoot)
-    ];
-    if (this.#context.tsconfig.options.paths) {
-      paths = this.#context.tsconfig.options.paths ? Object.keys(this.#context.tsconfig.options.paths).filter((tsconfigPath) => request.startsWith(tsconfigPath.replaceAll("*", ""))).map((tsconfigPath) => this.#context.tsconfig.options.paths?.[tsconfigPath]).flat().reduce((ret, path) => {
-        if (path && !ret.includes(joinPaths(this.#context.workspaceConfig.workspaceRoot, path))) {
-          ret.push(joinPaths(this.#context.workspaceConfig.workspaceRoot, path));
+  /**
+  * Synchronously glob files in the virtual file system (VFS) based on the provided pattern(s).
+  *
+  * @param patterns - A pattern (or multiple patterns) to use to determine the file paths to return
+  * @returns An array of file paths matching the provided pattern(s)
+  */
+  globSync(patterns) {
+    const results = [];
+    for (const pattern of toArray(patterns)) {
+      const normalized = this.formatPath(pattern);
+      if (!/[*?[\]{}]/.test(normalized) && !normalized.includes("**")) {
+        const resolved = this.resolve(normalized, {
+          type: "file"
+        });
+        if (resolved && !results.includes(resolved)) {
+          results.push(resolved);
         }
-        return ret;
-      }, paths) : paths;
-    }
-    return paths.reduce((ret, path) => {
-      if (!ret.includes(path)) {
-        ret.push(path);
+        continue;
       }
-      return ret;
-    }, parents.filter(Boolean).map((p) => this.formatPath(p)));
+      const absPattern = isAbsolutePath(normalized) ? normalized : this.formatPath(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.formatPath(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.resolve(full, {
+                type: "file"
+              });
+              if (resolved && !results.includes(resolved)) {
+                results.push(resolved);
+              }
+            }
+          }
+        }
+      }
+    }
+    return results;
   }
   /**
-  * Select the file system module to use for the operation based on the path or URL.
+  * Moves a file from one path to another in the virtual file system (VFS).
   *
-  * @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 srcPath - The source path to move
+  * @param destPath - The destination path to move to
   */
-  resolveFS(pathOrUrl, options = {}) {
-    const mode = this.resolveOutputMode(pathOrUrl, options);
-    if (mode === "virtual") {
-      return this.#virtualFS;
-    } else if (mode === "fs") {
-      return this.#fs;
-    }
-    return this.#unifiedFS;
+  async move(srcPath, destPath) {
+    const content = await this.readFile(srcPath);
+    await this.writeFile(destPath, content);
+    await this.rm(srcPath);
   }
   /**
-  * Select the file system module to use for the operation based on the path or URL.
+  * Synchronously moves a file from one path to another in the virtual file system (VFS).
   *
-  * @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 srcPath - The source path to move
+  * @param destPath - The destination path to move to
   */
-  resolveOutputMode(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.outputPath))) {
-      return "fs";
+  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);
+  }
+  /**
+  * Synchronously 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
+  */
+  copySync(srcPath, destPath) {
+    const content = this.readFileSync(srcPath);
+    this.writeFileSync(destPath, content);
+  }
+  /**
+  * Lists files in a given path.
+  *
+  * @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.
+  */
+  async readdir(pathOrId, options = "utf8") {
+    return this.#unifiedFS.resolveFS(pathOrId).promises.readdir(toFilePath(pathOrId), options);
+  }
+  /**
+  * Asynchronously reads a file from the virtual file system (VFS).
+  *
+  * @param pathOrId - 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") {
+    if (!pathOrId) {
+      return void 0;
+    }
+    const filePath = this.resolve(toFilePath(pathOrId), {
+      type: "file"
+    });
+    if (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);
+      }
+      const content = isBuffer(result) ? bufferToString(result) : result;
+      return content;
     }
     return void 0;
   }
   /**
-  * Clears the resolver cache for a given path.
+  * Synchronously reads a file from the virtual file system (VFS).
   *
-  * @param path - The path to clear the resolver cache for.
+  * @param pathOrId - 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.
   */
-  clearResolverCache(path) {
-    this.#cachedResolver.keys().filter((key) => key.startsWith(toFilePath(path))).forEach((key) => this.#cachedResolver.delete(key));
+  readFileSync(pathOrId, options = "utf8") {
+    if (!pathOrId) {
+      return void 0;
+    }
+    const filePath = this.resolve(toFilePath(pathOrId), {
+      type: "file"
+    });
+    if (filePath) {
+      const result = this.#unifiedFS.resolveFS(filePath).readFileSync(filePath, options);
+      const content = isBuffer(result) ? bufferToString(result) : result;
+      return content;
+    }
+    return void 0;
   }
   /**
-  * Check if the file exists with different variants (index, extensions).
+  * Writes a file to the virtual file system (VFS).
   *
-  * @param request - The request path to check.
-  * @param parentPath - An optional parent path to prepend to the request.
-  * @returns The file path if it exists, otherwise false.
+  * @param path - The path to the file.
+  * @param data - The contents of the file.
+  * @param options - Optional parameters for writing the file.
+  * @returns A promise that resolves when the file is written.
   */
-  checkVariants(request, parentPath) {
-    const path = parentPath ? joinPaths(parentPath, request) : request;
-    let file = this.checkExtensions(path);
-    if (file) {
-      return file;
+  async writeFile(path, data = "", options = "utf8") {
+    const formattedPath = this.formatPath(path);
+    if (!this.isDirectory(findFilePath(formattedPath))) {
+      await this.mkdir(findFilePath(formattedPath), isPowerlinesWriteFileOptions(options) ? options : void 0);
     }
-    file = this.checkIndex(path);
-    if (file) {
-      return file;
+    let code = isPowerLinesWriteFileData(data) ? data.code : data;
+    if ((!isPowerlinesWriteFileOptions(options) || !options.skipFormat) && isSetString(code)) {
+      const resolvedConfig = await resolveConfig(formattedPath);
+      if (resolvedConfig) {
+        code = await format(code, {
+          absolutePath: formattedPath,
+          ...resolvedConfig
+        });
+      }
     }
-    return false;
+    const outputMode = this.#unifiedFS.resolveMode(formattedPath, isPowerlinesWriteFileOptions(options) ? options : void 0);
+    this.#log(LogLevelLabel.TRACE, `Writing ${formattedPath} file to the ${outputMode === "fs" ? "" : "virtual "}file system (size: ${prettyBytes(new Blob(toArray(code)).size)})`);
+    this.metadata[formattedPath] = {
+      mode: outputMode,
+      variant: "normal",
+      ...isPowerLinesWriteFileData(data) ? data : {}
+    };
+    this.#clearResolverCache(formattedPath);
+    const ifs = this.#unifiedFS.resolveFS(formattedPath, isPowerlinesWriteFileOptions(options) ? options : void 0);
+    if (isFunction(ifs.promises.writeFile)) {
+      return ifs.promises.writeFile(formattedPath, code, isNodeWriteFileOptions(options) ? options : "utf8");
+    }
+    return ifs.writeFileSync(formattedPath, code, isNodeWriteFileOptions(options) ? options : "utf8");
   }
   /**
-  * Check if the index file exists in the given request path.
+  * Synchronously writes a file to the virtual file system (VFS).
   *
-  * @param request - The request path to check.
-  * @returns The index file path if it exists, otherwise false.
+  * @param path - The file to write.
+  * @param data - The contents of the file.
+  * @param options - Optional parameters for writing the file.
   */
-  checkIndex(request) {
-    let file = joinPaths(request, "index");
-    if (this.#existsSync(file)) {
-      return file;
+  writeFileSync(path, data = "", options = "utf8") {
+    const formattedPath = this.formatPath(path);
+    if (!this.isDirectory(findFilePath(formattedPath))) {
+      this.mkdirSync(findFilePath(formattedPath), isPowerlinesWriteFileOptions(options) ? options : void 0);
     }
-    file = this.checkExtensions(file);
-    if (file) {
-      return file;
+    const code = isPowerLinesWriteFileData(data) ? data.code : data;
+    const outputMode = this.#unifiedFS.resolveMode(formattedPath, isPowerlinesWriteFileOptions(options) ? options : void 0);
+    this.#log(LogLevelLabel.TRACE, `Writing ${formattedPath} file to the ${outputMode === "fs" ? "" : "virtual "}file system (size: ${prettyBytes(new Blob(toArray(code)).size)})`);
+    this.metadata[formattedPath] = {
+      mode: outputMode,
+      variant: "normal",
+      ...isPowerLinesWriteFileData(data) ? data : {}
+    };
+    this.#clearResolverCache(formattedPath);
+    const writeStream = this.#unifiedFS.resolveFS(formattedPath, isPowerlinesWriteFileOptions(options) ? options : void 0).createWriteStream(formattedPath);
+    try {
+      writeStream.write(code);
+    } finally {
+      writeStream.close();
     }
-    return false;
   }
   /**
-  * Check if the file exists with different extensions.
+  * Synchronously checks if a file exists in the virtual file system (VFS).
   *
-  * @param request - The request path to check.
-  * @param vfs - The file system module to use for checking file existence.
-  * @returns The file path if it exists with any of the checked extensions, otherwise false.
+  * @param pathOrId - The path or ID of the file to check.
+  * @returns `true` if the file exists, otherwise `false`.
   */
-  checkExtensions(request) {
-    let file = `${request}.ts`;
-    if (this.#existsSync(file)) {
-      return file;
+  existsSync(pathOrId) {
+    return this.resolve(pathOrId) !== false;
+  }
+  /**
+  * Retrieves the metadata of a file in the virtual file system (VFS).
+  *
+  * @param pathOrId - The path or ID of the file to retrieve metadata for.
+  * @returns The metadata of the file, or undefined if the file does not exist.
+  */
+  getMetadata(pathOrId) {
+    const resolved = this.resolve(pathOrId);
+    if (resolved && this.metadata[resolved]) {
+      return this.metadata[resolved];
     }
-    file = `${request}.mts`;
-    if (this.#existsSync(file)) {
-      return file;
+    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.resolve(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.resolve(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(this.resolve(toFilePath(pathOrId)) || toFilePath(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.resolve(toFilePath(pathOrId)) || toFilePath(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(this.resolve(toFilePath(pathOrId)) || toFilePath(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.resolve(toFilePath(pathOrId)) || toFilePath(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.resolve(toFilePath(pathOrId));
+    if (!filePath) {
+      throw new Error(`File not found: ${toFilePath(pathOrId)}`);
     }
-    file = `${request}.cts`;
-    if (this.#existsSync(file)) {
-      return file;
+    return filePath;
+  }
+  /**
+  * Resolves a path or ID parameter to a corresponding virtual file path in the virtual file system (VFS).
+  *
+  * @param pathOrId - The path or ID to resolve.
+  * @param options - Optional parameters for resolving the path, such as whether to include the file extension.
+  * @returns The resolved file path if it exists, otherwise undefined.
+  */
+  resolve(pathOrId, options = {}) {
+    const formattedPathOrId = toFilePath(pathOrId);
+    const resolverKey = `${formattedPathOrId}${options.withExtension ? "-ext" : ""}${options.paths ? `-${murmurhash(options.paths)}` : ""}${options.type ? `-${options.type}` : ""}`;
+    if (this.#cachedResolver.has(resolverKey)) {
+      return this.#cachedResolver.get(resolverKey);
     }
-    file = `${request}.tsx`;
-    if (this.#existsSync(file)) {
-      return file;
+    let result = this.#resolveId(formattedPathOrId);
+    if (!result) {
+      result = this.#resolvePath(formattedPathOrId, options);
     }
-    file = `${request}.js`;
-    if (this.#existsSync(file)) {
-      return file;
+    if (!result) {
+      result = false;
     }
-    file = `${request}.mjs`;
-    if (this.#existsSync(file)) {
-      return file;
+    if (result && options.withExtension === false) {
+      return result.replace(/\.[m|c]?[t|j]sx?$/, "");
     }
-    file = `${request}.cjs`;
-    if (this.#existsSync(file)) {
-      return file;
+    this.#cachedResolver.set(resolverKey, result);
+    return result;
+  }
+  /**
+  * Converts a relative path to an absolute path based on the workspace and project root.
+  *
+  * @param path - The relative path to convert.
+  * @returns The absolute path.
+  */
+  formatPath(path) {
+    const formattedPath = toFilePath(path);
+    if (isAbsolutePath(formattedPath) || formattedPath.startsWith(this.#context.workspaceConfig.workspaceRoot)) {
+      return formattedPath;
+    } else if (formattedPath.startsWith(this.#context.config.projectRoot)) {
+      return joinPaths$1(this.#context.workspaceConfig.workspaceRoot, formattedPath);
     }
-    file = `${request}.jsx`;
-    if (this.#existsSync(file)) {
-      return file;
+    return formattedPath;
+  }
+  /**
+  * Disposes of the virtual file system (VFS) by saving its state to disk.
+  */
+  async dispose() {
+    if (!this.#isDisposed) {
+      this.#isDisposed = true;
+      this.#log(LogLevelLabel.DEBUG, "Disposing virtual file system...");
+      await this.unlink(joinPaths$1(this.#context.cachePath, "fs.bin"));
+      const message = new $.Message();
+      const data = message.initRoot(FileSystemData);
+      const virtualFS = this.#unifiedFS.toJSON();
+      const files = data._initFiles(Object.keys(virtualFS).length);
+      Object.entries(virtualFS).filter(([_, content]) => content).forEach(([path, content], index) => {
+        const fileData = files.get(index);
+        fileData.path = path;
+        fileData.content = content;
+      });
+      const ids = data._initIds(Object.keys(this.ids).length);
+      Object.entries(this.ids).forEach(([id, path], index) => {
+        const fileId = ids.get(index);
+        fileId.id = id;
+        fileId.path = path;
+      });
+      const metadata = data._initMetadata(Object.keys(this.metadata).length);
+      Object.entries(this.metadata).forEach(([id, value], index) => {
+        const fileMetadata = metadata.get(index);
+        fileMetadata.id = id;
+        fileMetadata.mode = value.mode;
+        fileMetadata.variant = value.variant;
+        if (value.properties) {
+          const props = fileMetadata._initProperties(Object.keys(value.properties).length);
+          Object.entries(value.properties).forEach(([key, val], propIndex) => {
+            const propData = props.get(propIndex);
+            propData.key = key;
+            propData.value = val;
+          });
+        }
+      });
+      await writeFileBuffer(joinPaths$1(this.#context.cachePath, "fs.bin"), message.toArrayBuffer());
     }
-    file = `${request}.json`;
-    if (this.#existsSync(file)) {
-      return file;
+  }
+  /**
+  * 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;
     }
-    file = `${request}.d.ts`;
-    if (this.#existsSync(file)) {
-      return file;
+  }
+  /**
+  * 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;
     }
-    return false;
+  }
+  async [Symbol.asyncDispose]() {
+    return this.dispose();
   }
 };
-function createVfs(context) {
-  const vfs = new VirtualFileSystem(context);
-  return vfs;
+
+// ../powerlines/src/types/commands.ts
+var SUPPORTED_COMMANDS = [
+  "new",
+  "clean",
+  "prepare",
+  "lint",
+  "test",
+  "build",
+  "docs",
+  "deploy",
+  "finalize"
+];
+
+// ../powerlines/src/plugin-utils/helpers.ts
+function isPlugin(value) {
+  return isSetObject(value) && "name" in value && isSetString(value.name) && (isUndefined(value.applyToEnvironment) || "applyToEnvironment" in value && isFunction(value.applyToEnvironment)) && (isUndefined(value.dedupe) || "dedupe" in value && isFunction(value.dedupe)) && (isUndefined(value.dependsOn) || "dependsOn" in value && Array.isArray(value.dependsOn) && value.dependsOn.every(isPluginConfig)) && SUPPORTED_COMMANDS.every((command) => isUndefined(value[command]) || command in value && (isFunction(value[command]) || isSetObject(value[command]) && "handler" in value[command] && isFunction(value[command].handler)));
+}
+__name(isPlugin, "isPlugin");
+function isPluginConfigObject(value) {
+  return isSetObject(value) && "plugin" in value && ((isSetString(value.plugin) || isFunction(value.plugin)) && "options" in value && isSetObject(value.options) || isPlugin(value.plugin));
+}
+__name(isPluginConfigObject, "isPluginConfigObject");
+function isPluginConfigTuple(value) {
+  return Array.isArray(value) && (value.length === 1 || value.length === 2) && ((isSetString(value[0]) || isFunction(value[0])) && value.length > 1 && isSetObject(value[1]) || isPlugin(value[0]));
+}
+__name(isPluginConfigTuple, "isPluginConfigTuple");
+function isPluginConfig(value) {
+  return isSetString(value) || isFunction(value) || isPlugin(value) || isPluginConfigObject(value) || isPluginConfigTuple(value);
+}
+__name(isPluginConfig, "isPluginConfig");
+function isPluginHookFunction(value) {
+  return isFunction(value) || isSetObject(value) && "handler" in value && isFunction(value.handler);
+}
+__name(isPluginHookFunction, "isPluginHookFunction");
+function isPluginHookObject(value) {
+  return isSetObject(value) && "handler" in value && isFunction(value.handler);
+}
+__name(isPluginHookObject, "isPluginHookObject");
+function isPluginHook(value) {
+  return isPluginHookFunction(value) || isPluginHookObject(value);
+}
+__name(isPluginHook, "isPluginHook");
+function getHookHandler(pluginHook) {
+  return isFunction(pluginHook) ? pluginHook : pluginHook.handler;
+}
+__name(getHookHandler, "getHookHandler");
+function isHookExternal(hook) {
+  return hook.startsWith("vite:") || hook.startsWith("esbuild:") || hook.startsWith("rolldown:") || hook.startsWith("rollup:") || hook.startsWith("webpack:") || hook.startsWith("rspack:") || hook.startsWith("farm:");
+}
+__name(isHookExternal, "isHookExternal");
+function checkDedupe(plugin, plugins2) {
+  return plugin.dedupe === false || plugins2.some((p) => p.dedupe !== false && (isFunction(p.dedupe) && p.dedupe(plugin) || p.name === plugin.name));
+}
+__name(checkDedupe, "checkDedupe");
+function addPluginHook(context, plugin, pluginHook, hooksList) {
+  if (!checkDedupe(plugin, hooksList.map((hook) => hook.plugin))) {
+    hooksList.push(isFunction(pluginHook) ? {
+      plugin,
+      handler: getHookHandler(pluginHook).bind(context)
+    } : {
+      plugin,
+      ...pluginHook,
+      handler: getHookHandler(pluginHook).bind(context)
+    });
+  }
+}
+__name(addPluginHook, "addPluginHook");
+function resolveOptions(options) {
+  return defu2(options, {
+    interopDefault: true,
+    fsCache: options.mode !== "development" ? joinPaths$1(options.cacheDir, "jiti") : false,
+    moduleCache: options.mode !== "development"
+  });
+}
+__name(resolveOptions, "resolveOptions");
+function createPluginResolver(options) {
+  return createJiti(joinPaths$1(options.workspaceRoot, options.projectRoot), resolveOptions({
+    ...options
+  }));
+}
+__name(createPluginResolver, "createPluginResolver");
+function createResolver(options) {
+  const baseResolver = createJiti(joinPaths$1(options.workspaceRoot, options.projectRoot), resolveOptions(options));
+  baseResolver.plugin = createPluginResolver(options);
+  return baseResolver;
 }
-__name(createVfs, "createVfs");
+__name(createResolver, "createResolver");
 
 // ../powerlines/src/internal/contexts/context.ts
 var configCache = /* @__PURE__ */ new WeakMap();
@@ -1673,7 +1975,6 @@ var PowerlinesContext = class _PowerlinesContext {
       lint: config.lint,
       transform: config.transform,
       build: config.build,
-      override: config.override,
       framework: config.framework
     };
   }
@@ -1749,7 +2050,7 @@ var PowerlinesContext = class _PowerlinesContext {
   */
   get fs() {
     if (!this.#fs) {
-      this.#fs = createVfs(this);
+      this.#fs = VirtualFileSystem.createSync(this);
     }
     return this.#fs;
   }
@@ -1776,9 +2077,7 @@ var PowerlinesContext = class _PowerlinesContext {
       }),
       configHash: murmurhash(this.config, {
         maxLength: CACHE_HASH_LENGTH
-      }),
-      builtinIdMap: {},
-      virtualFiles: {}
+      })
     };
   }
   /**
@@ -1819,31 +2118,31 @@ var PowerlinesContext = class _PowerlinesContext {
   * Get the path to the artifacts directory for the project
   */
   get artifactsPath() {
-    return joinPaths$1(this.workspaceConfig.workspaceRoot, this.config.projectRoot, this.config.output.artifactsFolder);
+    return joinPaths(this.workspaceConfig.workspaceRoot, this.config.projectRoot, this.config.output.artifactsFolder);
   }
   /**
   * Get the path to the builtin modules used by the project
   */
   get builtinsPath() {
-    return joinPaths$1(this.artifactsPath, "builtins");
+    return joinPaths(this.artifactsPath, "builtins");
   }
   /**
   * Get the path to the entry directory for the project
   */
   get entryPath() {
-    return joinPaths$1(this.artifactsPath, "entry");
+    return joinPaths(this.artifactsPath, "entry");
   }
   /**
   * Get the path to the data directory for the project
   */
   get dataPath() {
-    return joinPaths$1(this.envPaths.data, "projects", getPrefixedProjectRootHash(this.config.name, this.meta.projectRootHash));
+    return joinPaths(this.envPaths.data, "projects", getPrefixedProjectRootHash(this.config.name, this.meta.projectRootHash));
   }
   /**
   * Get the path to the cache directory for the project
   */
   get cachePath() {
-    return joinPaths$1(this.envPaths.cache, "projects", murmurhash({
+    return joinPaths(this.envPaths.cache, "projects", murmurhash({
       checksum: this.#checksum,
       config: this.meta.configHash
     }, {
@@ -1854,7 +2153,7 @@ var PowerlinesContext = class _PowerlinesContext {
   * Get the path to the generated declaration file for the project
   */
   get dtsPath() {
-    return this.config.output.dts ? appendPath(this.config.output.dts, this.workspaceConfig.workspaceRoot) : joinPaths$1(this.workspaceConfig.workspaceRoot, this.config.projectRoot, "storm.d.ts");
+    return this.config.output.dts ? appendPath(this.config.output.dts, this.workspaceConfig.workspaceRoot) : joinPaths(this.workspaceConfig.workspaceRoot, this.config.projectRoot, "storm.d.ts");
   }
   /**
   * Get the project root relative to the workspace root
@@ -1866,13 +2165,13 @@ var PowerlinesContext = class _PowerlinesContext {
   * The builtin module id that exist in the Powerlines virtual file system
   */
   get builtins() {
-    return Object.values(this.fs.meta).filter((meta) => meta && meta.variant === "builtin").map((meta) => meta?.id).filter(Boolean);
+    return Object.values(this.fs.metadata).filter((meta) => meta && meta.variant === "builtin").map((meta) => meta?.id).filter(Boolean);
   }
   /**
-  * Get the project root relative to the workspace root
+  * Get the builtin virtual files that exist in the Powerlines virtual file system
   */
   async getBuiltins() {
-    return Promise.all(Object.entries(this.fs.meta).filter(([, meta]) => meta && meta.variant === "builtin").map(async ([path, meta]) => {
+    return Promise.all(Object.entries(this.fs.metadata).filter(([, meta]) => meta && meta.variant === "builtin").map(async ([path, meta]) => {
       const code = await this.fs.readFile(path);
       return {
         ...meta,
@@ -1892,7 +2191,7 @@ var PowerlinesContext = class _PowerlinesContext {
     return this.fs.writeFile(isAbsolute(path) ? path : appendPath(path, this.entryPath), {
       code,
       variant: "entry"
-    }, defu3(options, {
+    }, defu2(options, {
       mode: this.config.output.mode
     }));
   }
@@ -1905,11 +2204,11 @@ var PowerlinesContext = class _PowerlinesContext {
   * @param options - Optional write file options
   */
   async writeBuiltin(code, id, path, options = {}) {
-    return this.fs.writeFile(path ? isAbsolute(path) ? path : joinPaths$1(this.builtinsPath, path) : appendPath(id, this.builtinsPath), {
+    return this.fs.writeFile(path ? isAbsolute(path) ? path : joinPaths(this.builtinsPath, path) : appendPath(id, this.builtinsPath), {
       id,
       code,
       variant: "builtin"
-    }, defu3(options, {
+    }, defu2(options, {
       mode: this.config.output.mode
     }));
   }
@@ -1931,7 +2230,7 @@ var PowerlinesContext = class _PowerlinesContext {
         options
       });
     }
-    const result = await parseAsync(id, code, defu3(options ?? {}, {
+    const result = await parseAsync(id, code, defu2(options ?? {}, {
       lang: hasFileExtension(id) ? void 0 : "ts",
       astType: hasFileExtension(id) ? void 0 : "ts",
       sourceType: "module",
@@ -1969,7 +2268,7 @@ ${result.errors.map((error) => `  [${error.severity}] ${error.message}${error.co
   }) {
     this.config.inlineConfig = inlineConfig;
     if (inlineConfig.command === "new") {
-      const workspacePackageJsonPath = joinPaths$1(this.workspaceConfig.workspaceRoot, "package.json");
+      const workspacePackageJsonPath = joinPaths(this.workspaceConfig.workspaceRoot, "package.json");
       if (!existsSync(workspacePackageJsonPath)) {
         throw new Error(`The workspace package.json file could not be found at ${workspacePackageJsonPath}`);
       }
@@ -2092,11 +2391,11 @@ ${result.errors.map((error) => `  [${error.severity}] ${error.message}${error.co
       this.resolver = result.resolver;
       this.mergeUserConfig(result.userConfig.config, this.config.userConfig);
     } else {
-      const projectJsonPath = joinPaths$1(cacheKey.projectRoot, "project.json");
+      const projectJsonPath = joinPaths(cacheKey.projectRoot, "project.json");
       if (existsSync(projectJsonPath)) {
         this.projectJson = await readJsonFile(projectJsonPath);
       }
-      const packageJsonPath = joinPaths$1(cacheKey.projectRoot, "package.json");
+      const packageJsonPath = joinPaths(cacheKey.projectRoot, "package.json");
       if (existsSync(packageJsonPath)) {
         this.packageJson = await readJsonFile(packageJsonPath);
       }
@@ -2119,7 +2418,7 @@ ${result.errors.map((error) => `  [${error.severity}] ${error.message}${error.co
       });
     }
     if (isSetObject(config)) {
-      this.resolvedConfig = defu3({
+      this.resolvedConfig = defu2({
         inlineConfig: this.config.inlineConfig,
         userConfig: this.config.userConfig
       }, options.isHighPriority ? this.#getConfigProps(config) : {}, {
@@ -2136,11 +2435,11 @@ ${result.errors.map((error) => `  [${error.severity}] ${error.message}${error.co
         tsconfig: appendPath("tsconfig.json", cacheKey.projectRoot),
         sourceRoot: this.projectJson?.sourceRoot || appendPath("src", cacheKey.projectRoot),
         output: {
-          outputPath: joinPaths$1("dist", cacheKey.projectRoot),
+          outputPath: joinPaths("dist", cacheKey.projectRoot),
           mode: "virtual",
-          dts: joinPaths$1(cacheKey.projectRoot, `${config.framework ?? "powerlines"}.d.ts`),
+          dts: joinPaths(cacheKey.projectRoot, `${config.framework ?? "powerlines"}.d.ts`),
           builtinPrefix: config.framework ?? "powerlines",
-          artifactsFolder: joinPaths$1(cacheKey.projectRoot, `.${config.framework ?? "powerlines"}`),
+          artifactsFolder: joinPaths(cacheKey.projectRoot, `.${config.framework ?? "powerlines"}`),
           assets: [
             {
               glob: "LICENSE"
@@ -2175,9 +2474,9 @@ ${result.errors.map((error) => `  [${error.severity}] ${error.message}${error.co
           eslint: {}
         },
         build: {
-          target: "esnext"
-        },
-        override: {}
+          target: "esnext",
+          override: {}
+        }
       });
     }
     this.config.entry = getUniqueEntries(this.config.entry);
@@ -2197,12 +2496,12 @@ ${result.errors.map((error) => `  [${error.severity}] ${error.message}${error.co
     ] : [
       "esm"
     ])));
-    this.config.output.outputPath ??= joinPaths$1("dist", this.config.projectRoot || ".");
+    this.config.output.outputPath ??= joinPaths("dist", this.config.projectRoot || ".");
     this.config.output.assets = getUnique(this.config.output.assets.map((asset) => {
       return {
         glob: isSetObject(asset) ? asset.glob : asset,
         input: isString(asset) || !asset.input || asset.input === "." || asset.input === "/" || asset.input === "./" ? this.workspaceConfig.workspaceRoot : appendPath(asset.input, this.workspaceConfig.workspaceRoot),
-        output: appendPath(isSetObject(asset) && asset.output ? joinPaths$1(this.config.output.outputPath, replacePath(asset.output, this.config.output.outputPath)) : this.config.output.outputPath, this.workspaceConfig.workspaceRoot),
+        output: appendPath(isSetObject(asset) && asset.output ? joinPaths(this.config.output.outputPath, replacePath(asset.output, this.config.output.outputPath)) : this.config.output.outputPath, this.workspaceConfig.workspaceRoot),
         ignore: isSetObject(asset) && asset.ignore ? toArray(asset.ignore) : void 0
       };
     }));
@@ -2213,9 +2512,10 @@ ${result.errors.map((error) => `  [${error.severity}] ${error.message}${error.co
       ret.push(plugin);
       return ret;
     }, []);
+    this.#fs ??= await VirtualFileSystem.create(this);
   }
   mergeUserConfig(from = {}, into = this.config.userConfig ?? {}) {
-    this.config.userConfig = defu3({
+    this.config.userConfig = defu2({
       entry: Array.isArray(from.entry) && from.entry.length > 0 ? from.entry : Array.isArray(into?.entry) && into.entry.length > 0 ? into.entry : []
     }, omit(from ?? {}, [
       "entry"
@@ -2580,7 +2880,7 @@ async function emitTypes(context, tsconfig, files) {
   const emitResult = program.emit(void 0, (fileName, text, _, __, sourceFiles, _data) => {
     const sourceFile = sourceFiles?.[0];
     if (sourceFile?.fileName && !fileName.endsWith(".map")) {
-      if (context.builtins.some((file) => file === sourceFile.fileName || context.fs.meta[file]?.id && context.fs.meta[file]?.id === sourceFile.fileName)) {
+      if (context.builtins.some((file) => file === sourceFile.fileName || context.fs.metadata[file]?.id && context.fs.metadata[file]?.id === sourceFile.fileName)) {
         builtinModules += `
 declare module "${context.fs.resolve(sourceFile.fileName)}" {
     ${text.trim().replace(/^\s*export\s*declare\s*/gm, "export ").replace(/^\s*declare\s*/gm, "")}
@@ -2669,7 +2969,7 @@ function getTsconfigFilePath(workspaceRoot, projectRoot, tsconfig = "tsconfig.js
     if (!existsSync(tsconfigFilePath)) {
       tsconfigFilePath = appendPath(tsconfig, workspaceRoot);
       if (!existsSync(tsconfigFilePath)) {
-        tsconfigFilePath = appendPath(tsconfig, joinPaths(workspaceRoot, projectRoot));
+        tsconfigFilePath = appendPath(tsconfig, joinPaths$1(workspaceRoot, projectRoot));
         if (!existsSync(tsconfigFilePath)) {
           throw new Error(`Cannot find the \`tsconfig.json\` configuration file at ${tsconfig}, ${appendPath(tsconfig, projectRoot)}, ${appendPath(tsconfig, workspaceRoot)}, or ${tsconfigFilePath}`);
         }
@@ -2727,9 +3027,9 @@ function getParsedTypeScriptConfig(workspaceRoot, projectRoot, tsconfig, tsconfi
   const tsconfigFilePath = getTsconfigFilePath(workspaceRoot, projectRoot, tsconfig);
   const tsconfigJson = readJsonFileSync(tsconfigFilePath);
   if (!tsconfigJson) {
-    throw new Error(`Cannot find the \`tsconfig.json\` configuration file at ${joinPaths(projectRoot, tsconfig ?? "tsconfig.json")}`);
+    throw new Error(`Cannot find the \`tsconfig.json\` configuration file at ${joinPaths$1(projectRoot, tsconfig ?? "tsconfig.json")}`);
   }
-  const parsedCommandLine = ts2.parseJsonConfigFileContent(defu3(tsconfigRaw ?? {}, tsconfigJson), host, appendPath(projectRoot, workspaceRoot));
+  const parsedCommandLine = ts2.parseJsonConfigFileContent(defu2(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")}
@@ -2781,8 +3081,8 @@ async function resolveTsconfigChanges(context) {
     tsconfigJson.compilerOptions.emitDecoratorMetadata = true;
   }
   if (context.config.output.dts) {
-    const dtsFilePath = context.config.output.dts ? context.config.output.dts.startsWith(context.workspaceConfig.workspaceRoot) ? context.config.output.dts : joinPaths(context.workspaceConfig.workspaceRoot, context.config.output.dts) : joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot, "storm.d.ts");
-    const dtsRelativePath = joinPaths(relativePath(joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot), findFilePath(dtsFilePath)), findFileName(dtsFilePath));
+    const dtsFilePath = context.config.output.dts ? context.config.output.dts.startsWith(context.workspaceConfig.workspaceRoot) ? context.config.output.dts : joinPaths$1(context.workspaceConfig.workspaceRoot, context.config.output.dts) : joinPaths$1(context.workspaceConfig.workspaceRoot, context.config.projectRoot, "storm.d.ts");
+    const dtsRelativePath = joinPaths$1(relativePath(joinPaths$1(context.workspaceConfig.workspaceRoot, context.config.projectRoot), findFilePath(dtsFilePath)), findFileName(dtsFilePath));
     if (!tsconfigJson.include?.some((filePattern) => isIncludeMatchFound(filePattern, [
       dtsFilePath,
       dtsRelativePath,
@@ -3021,10 +3321,13 @@ ${context.entry.map((entry) => `- ${entry.input.file || entry.file}${entry.outpu
       await resolveTsconfig(context);
       await installDependencies(context);
       await this.callPostHook(context, "configResolved");
+      if (context.config.build.polyfill) {
+        context.config.build.polyfill = context.config.build.polyfill.map((polyfill) => replacePathTokens(context, polyfill));
+      }
       context.log(LogLevelLabel.TRACE, `Powerlines configuration has been resolved: 
 
 ${formatLogMessage(context.config)}`);
-      context.fs[__VFS_INIT__]();
+      context.fs[__VFS_PATCH__]();
       await writeMetaFile(context);
       context.persistedMeta = context.meta;
       if (!existsSync(context.cachePath)) {
@@ -3081,10 +3384,10 @@ ${formatLogMessage(context.config)}`);
           }
           return ret;
         }, [
-          joinPaths(typescriptPath, "lib", "lib.esnext.full.d.ts")
+          joinPaths$1(typescriptPath, "lib", "lib.esnext.full.d.ts")
         ]);
         context.log(LogLevelLabel.TRACE, "Parsing TypeScript configuration for the Powerlines project.");
-        const resolvedTsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.tsconfig.tsconfigFilePath, defu3({
+        const resolvedTsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.tsconfig.tsconfigFilePath, defu2({
           compilerOptions: {
             strict: false,
             noEmit: false,
@@ -3099,7 +3402,7 @@ ${formatLogMessage(context.config)}`);
           ],
           include: files
         }, context.config.tsconfigRaw ?? {}));
-        resolvedTsconfig.options.configFilePath = joinPaths(context.workspaceConfig.workspaceRoot, context.tsconfig.tsconfigFilePath);
+        resolvedTsconfig.options.configFilePath = joinPaths$1(context.workspaceConfig.workspaceRoot, context.tsconfig.tsconfigFilePath);
         resolvedTsconfig.options.pathsBasePath = context.workspaceConfig.workspaceRoot;
         resolvedTsconfig.options.suppressOutputPathCheck = true;
         let generatedTypes = await emitTypes(context, resolvedTsconfig, files);
@@ -3175,26 +3478,26 @@ ${formatTypes(generatedTypes)}
     await this.#executeEnvironments(async (context) => {
       context.log(LogLevelLabel.TRACE, `Initializing the processing options for the Powerlines project.`);
       await this.callPreHook(context, "new");
-      const files = await listFiles(joinPaths(context.powerlinesPath, "files/common/**/*.hbs"));
+      const files = await listFiles(joinPaths$1(context.powerlinesPath, "files/common/**/*.hbs"));
       for (const file of files) {
         context.log(LogLevelLabel.TRACE, `Adding template file: ${file}`);
         const template = Handlebars.compile(file);
-        await writeFile(context.log, joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
+        await writeFile(context.log, joinPaths$1(context.config.projectRoot, file.replace(".hbs", "")), template(context));
       }
       await this.callNormalHook(context, "new");
       if (context.config.projectType === "application") {
-        const files2 = await listFiles(joinPaths(context.powerlinesPath, "files/application/**/*.hbs"));
+        const files2 = await listFiles(joinPaths$1(context.powerlinesPath, "files/application/**/*.hbs"));
         for (const file of files2) {
           context.log(LogLevelLabel.TRACE, `Adding application template file: ${file}`);
           const template = Handlebars.compile(file);
-          await writeFile(context.log, joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
+          await writeFile(context.log, joinPaths$1(context.config.projectRoot, file.replace(".hbs", "")), template(context));
         }
       } else {
-        const files2 = await listFiles(joinPaths(context.powerlinesPath, "files/library/**/*.hbs"));
+        const files2 = await listFiles(joinPaths$1(context.powerlinesPath, "files/library/**/*.hbs"));
         for (const file of files2) {
           context.log(LogLevelLabel.TRACE, `Adding library template file: ${file}`);
           const template = Handlebars.compile(file);
-          await writeFile(context.log, joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
+          await writeFile(context.log, joinPaths$1(context.config.projectRoot, file.replace(".hbs", "")), template(context));
         }
       }
       await this.callPostHook(context, "new");
@@ -3258,7 +3561,7 @@ ${formatTypes(generatedTypes)}
       await this.callPreHook(context, "build");
       await this.callNormalHook(context, "build");
       await Promise.all(context.config.output.assets.map(async (asset) => {
-        context.log(LogLevelLabel.DEBUG, `Copying asset(s): ${chalk5.redBright(context.workspaceConfig.workspaceRoot === asset.input ? asset.glob : joinPaths(replacePath(asset.input, context.workspaceConfig.workspaceRoot), asset.glob))} -> ${chalk5.greenBright(joinPaths(replacePath(asset.output, context.workspaceConfig.workspaceRoot), asset.glob))} ${Array.isArray(asset.ignore) && asset.ignore.length > 0 ? ` (ignoring: ${asset.ignore.map((i) => chalk5.yellowBright(i)).join(", ")})` : ""}`);
+        context.log(LogLevelLabel.DEBUG, `Copying asset(s): ${chalk5.redBright(context.workspaceConfig.workspaceRoot === asset.input ? asset.glob : joinPaths$1(replacePath(asset.input, context.workspaceConfig.workspaceRoot), asset.glob))} -> ${chalk5.greenBright(joinPaths$1(replacePath(asset.output, context.workspaceConfig.workspaceRoot), asset.glob))} ${Array.isArray(asset.ignore) && asset.ignore.length > 0 ? ` (ignoring: ${asset.ignore.map((i) => chalk5.yellowBright(i)).join(", ")})` : ""}`);
         await copyFiles(asset, asset.output);
       }));
       await this.callPostHook(context, "build");
@@ -3286,22 +3589,22 @@ ${formatTypes(generatedTypes)}
     this.#context.log(LogLevelLabel.TRACE, "Powerlines documentation generation completed");
   }
   /**
-  * Release the project
+  * Deploy the project source code
   *
   * @remarks
-  * This method will prepare and build the Powerlines project, generating the necessary artifacts for release.
+  * This method will prepare and build the Powerlines project, generating the necessary artifacts for the deployment.
   *
-  * @param inlineConfig - The inline configuration for the release command
+  * @param inlineConfig - The inline configuration for the deploy command
   */
-  async release(inlineConfig = {
-    command: "release"
+  async deploy(inlineConfig = {
+    command: "deploy"
   }) {
-    this.context.log(LogLevelLabel.INFO, "\u{1F4E6} Releasing the Powerlines project");
+    this.context.log(LogLevelLabel.INFO, "\u{1F4E6} Deploying the Powerlines project");
     await this.prepare(inlineConfig);
     await this.#executeEnvironments(async (context) => {
-      await this.callHook(context, "release");
+      await this.callHook(context, "deploy");
     });
-    this.context.log(LogLevelLabel.TRACE, "Powerlines release completed");
+    this.context.log(LogLevelLabel.TRACE, "Powerlines deploy completed");
   }
   /**
   * Finalization process
@@ -3316,6 +3619,7 @@ ${formatTypes(generatedTypes)}
     await this.#executeEnvironments(async (context) => {
       await this.callHook(context, "finalize");
       context.fs[__VFS_REVERT__]();
+      await context.fs.dispose();
     });
     this.context.log(LogLevelLabel.TRACE, "Powerlines finalize execution completed");
   }
@@ -3546,7 +3850,7 @@ ${formatTypes(generatedTypes)}
       }
     }
     try {
-      const module = await this.context.resolver.plugin.import(this.context.resolver.plugin.esmResolve(joinPaths(pluginPath, "plugin")));
+      const module = await this.context.resolver.plugin.import(this.context.resolver.plugin.esmResolve(joinPaths$1(pluginPath, "plugin")));
       const result = module.plugin ?? module.default;
       if (!result) {
         throw new Error(`The plugin package "${pluginPath}" does not export a valid module.`);
@@ -3587,22 +3891,88 @@ var DEFAULT_ESBUILD_CONFIG = {
   logLevel: "silent"
 };
 function extractESBuildConfig(context) {
-  return defu3({
+  const inject = context.config.build.override.inject ?? context.config.build.inject;
+  if (inject && Object.keys(inject).length > 0) {
+    context.fs.writeFileSync(joinPaths$1(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.artifactsPath, "inject-shim.js"), Object.entries(inject).map(([key, value]) => {
+      if (value) {
+        if (Array.isArray(value)) {
+          if (camelCase(key) !== key) {
+            if (value.length === 1) {
+              return `
+import ${camelCase(key)} from "${value[0]}";
+export { ${camelCase(key)} as "${key}" }`;
+            } else if (value.length > 1) {
+              return `
+import ${value[1] === "*" ? `* as ${camelCase(key)}` : `{ ${value[1]} as ${camelCase(key)} }`} from "${value[0]}";
+export { ${camelCase(key)} as "${key}" }`;
+            }
+          } else if (value.length === 1) {
+            return `
+import ${key} from "${value[0]}";
+export { ${key} };`;
+          } else if (value.length > 1) {
+            return `
+import ${value[1] === "*" ? `* as ${key}` : `{ ${value[1]} as ${key} }`} from "${value[0]}";
+export { ${key} };`;
+          }
+        } else if (camelCase(key) !== key) {
+          return `
+import ${camelCase(key)} from "${value[0]}";
+export { ${camelCase(key)} as "${key}" }`;
+        } else {
+          return `
+import ${key} from "${value}";
+export { ${key} };`;
+        }
+      }
+      return "";
+    }).join("\n"));
+  }
+  return defu2({
     alias: context.builtins.reduce((ret, id) => {
-      const path = context.fs.ids[id];
-      if (path) {
-        ret[id] = path;
+      if (!ret[id]) {
+        const path = context.fs.ids[id];
+        if (path) {
+          ret[id] = path;
+        }
       }
       return ret;
-    }, {})
-  }, context.config.build.variant === "esbuild" ? context.config.override : {}, {
+    }, context.config.build.alias ? Array.isArray(context.config.build.alias) ? context.config.build.alias.reduce((ret, alias) => {
+      if (!ret[alias.find.toString()]) {
+        ret[alias.find.toString()] = alias.replacement;
+      }
+      return ret;
+    }, {}) : context.config.build.alias : {}),
+    inject: inject && Object.keys(inject).length > 0 ? [
+      joinPaths$1(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.artifactsPath, "inject-shim.js")
+    ] : void 0
+  }, context.config.build.variant === "esbuild" ? omit(context.config.build.override, [
+    "alias",
+    "inject",
+    "external",
+    "noExternal",
+    "skipNodeModulesBundle",
+    "extensions"
+  ]) : {}, {
+    mainFields: context.config.build.mainFields,
+    conditions: context.config.build.conditions,
+    define: context.config.build.define,
+    resolveExtensions: context.config.build.extensions,
+    packages: context.config.build.skipNodeModulesBundle ? "external" : context.config.build.variant === "esbuild" ? context.config.build.packages : void 0,
     format: Array.isArray(context.config.output.format) ? context.config.output.format[0] : context.config.output.format,
     platform: context.config.build.platform,
     treeShaking: Boolean(context.config.build?.treeshake) || context.config.build?.treeShaking,
     outdir: context.config.output.outputPath,
     tsconfig: context.tsconfig.tsconfigFilePath,
     tsconfigRaw: context.tsconfig.tsconfigJson
-  }, context.config.build.variant === "esbuild" ? context.config.build : {}, {
+  }, context.config.build.variant === "esbuild" ? omit(context.config.build, [
+    "alias",
+    "inject",
+    "external",
+    "noExternal",
+    "skipNodeModulesBundle",
+    "extensions"
+  ]) : {}, {
     minify: context.config.mode !== "development",
     metafile: context.config.mode === "development",
     sourcemap: context.config.mode === "development"
@@ -3630,25 +4000,39 @@ var DEFAULT_VITE_CONFIG = {
   clearScreen: true
 };
 function extractViteConfig(context) {
-  return defu3({
+  return defu2({
     resolve: {
       alias: context.builtins.reduce((ret, id) => {
-        const path = context.fs.ids[id];
-        if (path) {
-          ret[id] = path;
+        if (!ret.find((e) => e.find === id)) {
+          const path = context.fs.ids[id];
+          if (path) {
+            ret.push({
+              find: id,
+              replacement: path
+            });
+          }
         }
         return ret;
-      }, {})
-    }
-  }, context.config.build.variant === "vite" ? context.config.override : {}, {
-    external: context.config.build.external,
-    noExternal: context.config.build.noExternal,
-    skipNodeModulesBundle: context.config.build.skipNodeModulesBundle
-  }, {
+      }, context.config.build.alias ? Array.isArray(context.config.build.alias) ? context.config.build.alias : Object.entries(context.config.build.alias).reduce((ret, [id, path]) => {
+        if (!ret.find((e) => e.find === id)) {
+          ret.push({
+            find: id,
+            replacement: path
+          });
+        }
+        return ret;
+      }, []) : []),
+      dedupe: context.config.build.dedupe,
+      mainFields: context.config.build.mainFields,
+      conditions: context.config.build.conditions,
+      extensions: context.config.build.extensions
+    }
+  }, context.config.build.variant === "vite" ? context.config.build.override : {}, {
+    define: context.config.build.define,
     rootDir: context.config.sourceRoot,
     platform: context.config.build.platform,
     mode: context.config.mode === "development" ? "development" : "production",
-    cacheDir: joinPaths(context.cachePath, "vite"),
+    cacheDir: joinPaths$1(context.cachePath, "vite"),
     build: {
       outDir: context.config.output.outputPath,
       tsconfig: context.tsconfig.tsconfigFilePath,
@@ -3656,8 +4040,7 @@ function extractViteConfig(context) {
     },
     esbuild: extractESBuildConfig(context),
     logLevel: context.config.logLevel ?? void 0,
-    envDir: context.config.projectRoot,
-    noExternal: context.builtins
+    envDir: context.config.projectRoot
   }, context.config.build.variant === "vite" ? context.config.build : {}, {
     build: {
       minify: context.config.mode !== "development",
@@ -3700,9 +4083,23 @@ async function handleResolveId(context, args, options = {}) {
         };
       }
     }
-    if (context.fs.isTsconfigPath(args.id)) {
-      const tsconfigPath = context.fs.resolveTsconfigPath(args.id);
-      const tsconfigPathPackage = context.fs.resolveTsconfigPathPackage(args.id);
+    if (!!context.tsconfig.options.paths && Object.keys(context.tsconfig.options.paths).some((path) => args.id.startsWith(path.replaceAll("*", "")))) {
+      let tsconfigPath = false;
+      if (context.tsconfig.options.paths) {
+        for (const tsconfigPathKey of Object.keys(context.tsconfig.options.paths).filter((tsconfigPath2) => args.id.startsWith(tsconfigPath2.replaceAll("*", "")))) {
+          const resolvedPath = context.tsconfig.options.paths[tsconfigPathKey]?.find((tsconfigPath2) => context.fs.resolve(joinPaths(context.workspaceConfig.workspaceRoot, tsconfigPath2.replaceAll("*", ""), args.id.replace(tsconfigPathKey.replaceAll("*", ""), ""))) || context.fs.formatPath(tsconfigPath2) === context.fs.formatPath(args.id));
+          if (resolvedPath) {
+            tsconfigPath = context.fs.formatPath(resolvedPath) === context.fs.formatPath(args.id) ? context.fs.formatPath(resolvedPath) : context.fs.resolve(joinPaths(context.workspaceConfig.workspaceRoot, resolvedPath.replaceAll("*", ""), args.id.replace(tsconfigPathKey.replaceAll("*", ""), "")));
+          }
+        }
+      }
+      let tsconfigPathPackage = false;
+      if (context.tsconfig.options.paths) {
+        const tsconfigPathKeys = Object.keys(context.tsconfig.options.paths).filter((tsconfigPath2) => args.id.startsWith(tsconfigPath2.replaceAll("*", "")));
+        if (tsconfigPathKeys.length > 0 && tsconfigPathKeys[0]) {
+          tsconfigPathPackage = tsconfigPathKeys[0].replace(/\/\*$/, "");
+        }
+      }
       if (tsconfigPath && tsconfigPathPackage) {
         return {
           id: tsconfigPath,
@@ -3735,7 +4132,7 @@ async function handleResolveId(context, args, options = {}) {
           args.importer
         ] : []
       });
-      if (match(args.id, options.noExternal) || resolvedPath && context.fs.meta[resolvedPath]?.variant === "builtin") {
+      if (match(args.id, options.noExternal) || resolvedPath && context.fs.metadata[resolvedPath]?.variant === "builtin") {
         return void 0;
       }
       if (match(args.id, options.external) || args.id.startsWith("node:")) {
@@ -3884,7 +4281,12 @@ var vite = createVitePlugin(createUnpluginFactory("vite", (api, plugin) => {
         api.context.config.mode = isDevelopmentMode(env.mode) ? "development" : isTestMode(env.mode) ? "test" : "production";
         const environment = await api.context.getEnvironment();
         const result = await api.callHook(environment, "config");
-        return defu3(extractViteConfig(api.context), result?.build ?? {}, config);
+        return defu2(
+          extractViteConfig(api.context),
+          // Need to use `any` here to avoid excessive type complexity
+          result?.build ?? {},
+          config
+        );
       },
       async configResolved(_config) {
         const environment = await api.context.getEnvironment();
@@ -3947,228 +4349,6 @@ createRolldownPlugin(createUnpluginFactory("rolldown"));
 createRollupPlugin(createUnpluginFactory("rollup"));
 createRspackPlugin(createUnpluginFactory("rspack"));
 createUnloaderPlugin(createUnpluginFactory("unloader"));
-BigInt("0xa56c61324b9d6e49");
-var FileMetadata_KeyValuePair = class extends $.Struct {
-  static {
-    __name(this, "FileMetadata_KeyValuePair");
-  }
-  static _capnp = {
-    displayName: "KeyValuePair",
-    id: "eabb26cf58b2a14c",
-    size: new $.ObjectSize(0, 2)
-  };
-  get key() {
-    return $.utils.getText(0, this);
-  }
-  set key(value) {
-    $.utils.setText(0, value, this);
-  }
-  get value() {
-    return $.utils.getText(1, this);
-  }
-  set value(value) {
-    $.utils.setText(1, value, this);
-  }
-  toString() {
-    return "FileMetadata_KeyValuePair_" + super.toString();
-  }
-};
-var FileMetadata = class _FileMetadata extends $.Struct {
-  static {
-    __name(this, "FileMetadata");
-  }
-  static KeyValuePair = FileMetadata_KeyValuePair;
-  static _capnp = {
-    displayName: "FileMetadata",
-    id: "8e2cab5d7e28c7b3",
-    size: new $.ObjectSize(0, 4),
-    defaultVariant: "normal"
-  };
-  static _Properties;
-  /**
-  * The variant of the file.
-  *
-  */
-  get id() {
-    return $.utils.getText(0, this);
-  }
-  set id(value) {
-    $.utils.setText(0, value, this);
-  }
-  /**
-  * The output mode of the file.
-  *
-  */
-  get variant() {
-    return $.utils.getText(1, this, _FileMetadata._capnp.defaultVariant);
-  }
-  set variant(value) {
-    $.utils.setText(1, value, this);
-  }
-  /**
-  * Additional metadata associated with the file.
-  *
-  */
-  get mode() {
-    return $.utils.getText(2, this);
-  }
-  set mode(value) {
-    $.utils.setText(2, value, this);
-  }
-  _adoptProperties(value) {
-    $.utils.adopt(value, $.utils.getPointer(3, this));
-  }
-  _disownProperties() {
-    return $.utils.disown(this.properties);
-  }
-  get properties() {
-    return $.utils.getList(3, _FileMetadata._Properties, this);
-  }
-  _hasProperties() {
-    return !$.utils.isNull($.utils.getPointer(3, this));
-  }
-  _initProperties(length) {
-    return $.utils.initList(3, _FileMetadata._Properties, length, this);
-  }
-  set properties(value) {
-    $.utils.copyFrom(value, $.utils.getPointer(3, this));
-  }
-  toString() {
-    return "FileMetadata_" + super.toString();
-  }
-};
-var FileIdentifier = class extends $.Struct {
-  static {
-    __name(this, "FileIdentifier");
-  }
-  static _capnp = {
-    displayName: "FileIdentifier",
-    id: "e12b8732389d7406",
-    size: new $.ObjectSize(0, 2)
-  };
-  /**
-  * An additional identifier for the file.
-  *
-  */
-  get path() {
-    return $.utils.getText(0, this);
-  }
-  set path(value) {
-    $.utils.setText(0, value, this);
-  }
-  get id() {
-    return $.utils.getText(1, this);
-  }
-  set id(value) {
-    $.utils.setText(1, value, this);
-  }
-  toString() {
-    return "FileIdentifier_" + super.toString();
-  }
-};
-var FileData = class extends $.Struct {
-  static {
-    __name(this, "FileData");
-  }
-  static _capnp = {
-    displayName: "FileData",
-    id: "fa6725c8a360f9a2",
-    size: new $.ObjectSize(0, 2)
-  };
-  /**
-  * The contents of the file.
-  *
-  */
-  get path() {
-    return $.utils.getText(0, this);
-  }
-  set path(value) {
-    $.utils.setText(0, value, this);
-  }
-  get content() {
-    return $.utils.getText(1, this);
-  }
-  set content(value) {
-    $.utils.setText(1, value, this);
-  }
-  toString() {
-    return "FileData_" + super.toString();
-  }
-};
-var FileSystemData = class _FileSystemData extends $.Struct {
-  static {
-    __name(this, "FileSystemData");
-  }
-  static _capnp = {
-    displayName: "FileSystemData",
-    id: "aaa72a672ac0732f",
-    size: new $.ObjectSize(0, 3)
-  };
-  static _Ids;
-  static _Metadata;
-  static _Files;
-  _adoptIds(value) {
-    $.utils.adopt(value, $.utils.getPointer(0, this));
-  }
-  _disownIds() {
-    return $.utils.disown(this.ids);
-  }
-  get ids() {
-    return $.utils.getList(0, _FileSystemData._Ids, this);
-  }
-  _hasIds() {
-    return !$.utils.isNull($.utils.getPointer(0, this));
-  }
-  _initIds(length) {
-    return $.utils.initList(0, _FileSystemData._Ids, length, this);
-  }
-  set ids(value) {
-    $.utils.copyFrom(value, $.utils.getPointer(0, this));
-  }
-  _adoptMetadata(value) {
-    $.utils.adopt(value, $.utils.getPointer(1, this));
-  }
-  _disownMetadata() {
-    return $.utils.disown(this.metadata);
-  }
-  get metadata() {
-    return $.utils.getList(1, _FileSystemData._Metadata, this);
-  }
-  _hasMetadata() {
-    return !$.utils.isNull($.utils.getPointer(1, this));
-  }
-  _initMetadata(length) {
-    return $.utils.initList(1, _FileSystemData._Metadata, length, this);
-  }
-  set metadata(value) {
-    $.utils.copyFrom(value, $.utils.getPointer(1, this));
-  }
-  _adoptFiles(value) {
-    $.utils.adopt(value, $.utils.getPointer(2, this));
-  }
-  _disownFiles() {
-    return $.utils.disown(this.files);
-  }
-  get files() {
-    return $.utils.getList(2, _FileSystemData._Files, this);
-  }
-  _hasFiles() {
-    return !$.utils.isNull($.utils.getPointer(2, this));
-  }
-  _initFiles(length) {
-    return $.utils.initList(2, _FileSystemData._Files, length, this);
-  }
-  set files(value) {
-    $.utils.copyFrom(value, $.utils.getPointer(2, this));
-  }
-  toString() {
-    return "FileSystemData_" + super.toString();
-  }
-};
-FileMetadata._Properties = $.CompositeList(FileMetadata_KeyValuePair);
-FileSystemData._Ids = $.CompositeList(FileIdentifier);
-FileSystemData._Metadata = $.CompositeList(FileMetadata);
-FileSystemData._Files = $.CompositeList(FileData);
 
 // ../powerlines/src/index.ts
 var src_default = PowerlinesAPI;
@@ -4183,7 +4363,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, defu3({
+    const api = await src_default.from(workspaceConfig.workspaceRoot, defu2({
       root: projectConfig.root,
       type: projectConfig.projectType,
       sourceRoot: projectConfig.sourceRoot,
@@ -4196,7 +4376,7 @@ function withExecutor(command, executorFn) {
       }
     }, options));
     try {
-      return await Promise.resolve(executorFn(defu3({
+      return await Promise.resolve(executorFn(defu2({
         projectName: context.projectName,
         options,
         workspaceConfig,