powerlines 0.9.0 → 0.10.1

package/dist/lib/{chunk-6IEUZ5DZ.js → chunk-PIFE7MUZ.js}

@@ -1,12 +1,12 @@
-import { writeFile } from './chunk-DKE25WTL.js';
+import { writeFile } from './chunk-HQ6TGY34.js';
 import { getFileHeader } from './chunk-7R23HVGQ.js';
-import { __VFS_CACHE__, __VFS_RESOLVER__, __VFS_VIRTUAL__, __VFS_UNIFIED__, __VFS_INIT__, __VFS_REVERT__, CACHE_HASH_LENGTH, PROJECT_ROOT_HASH_LENGTH, getPrefixedProjectRootHash, getChecksum, writeMetaFile } from './chunk-GWAVDFOE.js';
+import { __VFS_CACHE__, __VFS_RESOLVER__, __VFS_VIRTUAL__, __VFS_UNIFIED__, __VFS_INIT__, __VFS_REVERT__, CACHE_HASH_LENGTH, PROJECT_ROOT_HASH_LENGTH, getPrefixedProjectRootHash, getChecksum, writeMetaFile } from './chunk-M7U5RMK7.js';
 import { isPlugin, checkDedupe, isPluginHook, isHookExternal, addPluginHook, getHookHandler, isPluginConfig, isPluginConfigTuple, isPluginConfigObject } from './chunk-UGRFAVAJ.js';
-import { handleResolveId } from './chunk-PJKWY74P.js';
+import { handleResolveId } from './chunk-YBIWVB66.js';
 import { getParsedTypeScriptConfig, getTsconfigFilePath, isIncludeMatchFound } from './chunk-OO4BIM7N.js';
 import { loadWorkspaceConfig, loadUserConfigFile } from './chunk-56LQSSQ3.js';
 import { extendLog, createLog } from './chunk-35EO5Y7R.js';
-import { getSourceFile, getString } from './chunk-2ZYHO243.js';
+import { getSourceFile, getString } from './chunk-PXSRMP4E.js';
 import { resolveEntriesSync, getUniqueEntries } from './chunk-STAKGAWR.js';
 import { __name } from './chunk-7QVYU63E.js';
 import { LogLevelLabel } from '@storm-software/config-tools/types';
@@ -20,8 +20,6 @@ import { createDirectory } from '@stryke/fs/helpers';
 import { install } from '@stryke/fs/install';
 import { listFiles } from '@stryke/fs/list-files';
 import { isPackageExists, isPackageListed, doesPackageMatch, getPackageListing } from '@stryke/fs/package-fns';
-import { findFilePath, hasFileExtension, findFileExtensionSafe, relativePath, findFileName } from '@stryke/path/file-path-fns';
-import { isParentPath } from '@stryke/path/is-parent-path';
 import { joinPaths } from '@stryke/path/join-paths';
 import { replacePath } from '@stryke/path/replace';
 import { isError } from '@stryke/type-checks/is-error';
@@ -42,6 +40,8 @@ import { murmurhash } from '@stryke/hash/murmurhash';
 import { getUnique } from '@stryke/helpers/get-unique';
 import { omit } from '@stryke/helpers/omit';
 import { appendPath } from '@stryke/path/append';
+import { findFilePath, findFileExtensionSafe, 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 { isNull } from '@stryke/type-checks/is-null';
 import { isString } from '@stryke/type-checks/is-string';
@@ -49,13 +49,14 @@ import { uuid } from '@stryke/unique-id/uuid';
 import { parseAsync } from 'oxc-parser';
 import { createJiti } from 'jiti';
 import { bufferToString } from '@stryke/convert/buffer-to-string';
-import { isAbsolutePath } from '@stryke/path/is-type';
+import { isParentPath } from '@stryke/path/is-parent-path';
 import { prettyBytes } from '@stryke/string-format/pretty-bytes';
 import { isBuffer } from '@stryke/type-checks/is-buffer';
+import { isUndefined } from '@stryke/type-checks/is-undefined';
 import { Volume } from 'memfs';
 import { Blob } from 'node:buffer';
 import fs from 'node:fs';
-import { format, resolveConfig } from 'prettier';
+import { resolveConfig, format } from 'prettier';
 import { Union } from 'unionfs';
 import { isObject } from '@stryke/type-checks/is-object';
 import { transformAsync } from '@babel/core';
@@ -132,6 +133,154 @@ function createResolver(options) {
   return baseResolver;
 }
 __name(createResolver, "createResolver");
+function isBufferEncoding(options) {
+  return isSetString(options) || options === null;
+}
+__name(isBufferEncoding, "isBufferEncoding");
+function isPowerlinesWriteFileOptions(options) {
+  return !isBufferEncoding(options) && isSetObject(options) && ("skipFormat" in options || "mode" in options && (options.mode === "fs" || options.mode === "virtual"));
+}
+__name(isPowerlinesWriteFileOptions, "isPowerlinesWriteFileOptions");
+function isNodeWriteFileOptions(options) {
+  return !isUndefined(options) && (isBufferEncoding(options) || !isPowerlinesWriteFileOptions(options));
+}
+__name(isNodeWriteFileOptions, "isNodeWriteFileOptions");
+function isPowerLinesWriteFileData(data) {
+  return !!(isSetObject(data) && "code" in data && data.code);
+}
+__name(isPowerLinesWriteFileData, "isPowerLinesWriteFileData");
+var FILE_PREFIX = "file://";
+function toFilePath(pathOrUrl) {
+  if (!pathOrUrl) {
+    throw new Error("No Path or URL provided to Virtual File System");
+  }
+  let result = pathOrUrl.toString();
+  if (result.startsWith(FILE_PREFIX)) {
+    result = result.slice(FILE_PREFIX.length);
+  }
+  return result;
+}
+__name(toFilePath, "toFilePath");
+var FS_METHODS = [
+  "mkdir",
+  "mkdirSync",
+  "rmdir",
+  "rmdirSync",
+  "unlink",
+  "unlinkSync",
+  "existsSync",
+  "realpathSync",
+  "writeFileSync",
+  "readFileSync",
+  "readdirSync",
+  "createWriteStream",
+  "WriteStream",
+  "createReadStream",
+  "ReadStream"
+];
+var FS_PROMISE_METHODS = [
+  "mkdir",
+  "rm",
+  "rmdir",
+  "unlink",
+  "writeFile",
+  "readFile",
+  "readdir",
+  "stat",
+  "lstat"
+];
+function cloneFS(originalFS) {
+  const clonedFS = {
+    ...originalFS,
+    promises: {
+      ...originalFS.promises ?? {}
+    }
+  };
+  for (const method of FS_METHODS) {
+    if (originalFS[method]) {
+      clonedFS[method] = originalFS[method];
+    }
+  }
+  originalFS.promises ??= {};
+  for (const method of FS_PROMISE_METHODS) {
+    if (originalFS.promises[method]) {
+      clonedFS.promises ??= {};
+      clonedFS.promises[method] = originalFS.promises[method];
+      clonedFS[method] = originalFS.promises[method];
+    }
+  }
+  for (const prop in clonedFS) {
+    if (isFunction(clonedFS[prop])) {
+      clonedFS[prop] = clonedFS[prop].bind(originalFS);
+      if (isFunction(clonedFS.promises[prop])) {
+        clonedFS.promises[prop] = clonedFS.promises[prop].bind(originalFS);
+      }
+    }
+  }
+  for (const prop in clonedFS.promises) {
+    if (isFunction(clonedFS.promises[prop])) {
+      clonedFS.promises[prop] = clonedFS.promises[prop].bind(originalFS);
+    }
+  }
+  return clonedFS;
+}
+__name(cloneFS, "cloneFS");
+function patchFS(originalFS, vfs) {
+  const clonedFS = cloneFS(originalFS);
+  originalFS.mkdirSync = (file, options) => vfs.mkdirSync(toFilePath(file), options);
+  originalFS.mkdir = (file, options, callback) => vfs.mkdir(toFilePath(file), options, callback);
+  originalFS.promises.mkdir = async (file, options) => vfs.mkdir(toFilePath(file), options);
+  originalFS.unlinkSync = (file) => vfs.unlinkSync(toFilePath(file));
+  originalFS.promises.rm = async (file, options) => vfs.rm(toFilePath(file), options);
+  originalFS.promises.unlink = async (file) => vfs.unlink(toFilePath(file));
+  originalFS.existsSync = (file) => vfs.existsSync(toFilePath(file));
+  Object.defineProperty(originalFS, "realpathSync", {
+    value: /* @__PURE__ */ __name((file, options) => vfs.realpathSync(toFilePath(file), options), "value")
+  });
+  originalFS.writeFileSync = (file, data, options) => vfs.writeFileSync(toFilePath(file), data, options);
+  originalFS.promises.writeFile = async (file, data, options) => vfs.writeFile(toFilePath(file), data, options);
+  originalFS.readFileSync = (file, options) => vfs.readFileSync(toFilePath(file), options);
+  originalFS.promises.readFile = (file, options) => vfs.readFile(toFilePath(file), options);
+  originalFS.readdirSync = (file, options) => vfs.readdirSync(toFilePath(file), options);
+  originalFS.promises.readdir = (file, options) => vfs.readdir(toFilePath(file), options);
+  Object.defineProperty(originalFS, "statSync", {
+    value: /* @__PURE__ */ __name((file, options) => vfs.statSync(toFilePath(file), options), "value")
+  });
+  originalFS.stat = (file, options) => vfs.statSync(toFilePath(file), options);
+  originalFS.promises.stat = (file, options) => vfs.stat(toFilePath(file), options);
+  Object.defineProperty(originalFS, "lstatSync", {
+    value: /* @__PURE__ */ __name((file, options) => vfs.lstatSync(toFilePath(file), options), "value")
+  });
+  originalFS.lstat = (file, options) => vfs.lstatSync(toFilePath(file), options);
+  originalFS.promises.lstat = (file, options) => vfs.lstat(toFilePath(file), options);
+  return () => {
+    originalFS.mkdirSync = clonedFS.mkdirSync;
+    originalFS.mkdir = clonedFS.mkdir;
+    originalFS.promises.mkdir = clonedFS.promises.mkdir;
+    originalFS.unlinkSync = clonedFS.unlinkSync;
+    originalFS.promises.rm = clonedFS.promises.rm;
+    originalFS.promises.unlink = clonedFS.promises.unlink;
+    originalFS.existsSync = clonedFS.existsSync;
+    originalFS.realpathSync = clonedFS.realpathSync;
+    originalFS.writeFileSync = clonedFS.writeFileSync;
+    originalFS.promises.writeFile = clonedFS.promises.writeFile;
+    originalFS.readFileSync = clonedFS.readFileSync;
+    originalFS.promises.readFile = clonedFS.promises.readFile;
+    originalFS.readdirSync = clonedFS.readdirSync;
+    originalFS.promises.readdir = clonedFS.promises.readdir;
+    Object.defineProperty(originalFS, "statSync", {
+      value: clonedFS.statSync
+    });
+    originalFS.stat = clonedFS.stat;
+    originalFS.promises.stat = clonedFS.promises.stat;
+    Object.defineProperty(originalFS, "lstatSync", {
+      value: clonedFS.lstatSync
+    });
+    originalFS.lstat = clonedFS.lstat;
+    originalFS.promises.lstat = clonedFS.promises.lstat;
+  };
+}
+__name(patchFS, "patchFS");
 var VirtualFileSystem = class {
   static {
     __name(this, "VirtualFileSystem");
@@ -139,7 +288,11 @@ var VirtualFileSystem = class {
   /**
   * The internal map of virtual files.
   */
-  #builtinIdMap = /* @__PURE__ */ new Map();
+  #meta = {};
+  /**
+  * A map of unique identifiers to their virtual file paths.
+  */
+  #ids = {};
   /**
   * A map of virtual file paths to their underlying file content.
   */
@@ -180,6 +333,16 @@ var VirtualFileSystem = class {
   */
   #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__]() {
@@ -204,15 +367,54 @@ var VirtualFileSystem = class {
     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.
+  */
+  get ids() {
+    return this.#ids;
+  }
+  /**
   * 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
   */
-  constructor(context, serialized) {
+  constructor(context, serialized = {}) {
     this.#context = context;
     this.#cachedFS = /* @__PURE__ */ new Map();
-    this.#builtinIdMap = new Map(Object.entries(serialized?.builtinIdMap ?? {}));
+    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, {
         recursive: true
@@ -294,65 +496,44 @@ var VirtualFileSystem = class {
     }
   }
   /**
-  * Returns a Map of all runtime file IDs and their corresponding paths in the virtual file system.
+  * Check if a path or id corresponds to a virtual file **(does not actually exists on disk)**.
   *
-  * @returns A Map where the keys are runtime file IDs (strings) and the values are their corresponding paths (strings).
+  * @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)**.
   */
-  get builtinIdMap() {
-    return this.#builtinIdMap;
-  }
-  /**
-  * Lists all runtime IDs in the virtual file system.
-  *
-  * @returns An array of formatted runtime IDs.
-  */
-  get runtimeIds() {
-    return Array.from(this.builtinIdMap.keys()).map((id) => this.formatRuntimeId(id));
-  }
-  /**
-  * Checks if a given path or ID corresponds to a runtime file.
-  *
-  * @param pathOrId - The path or ID to check.
-  * @param options - Options for resolving the path, such as paths to check.
-  * @returns `true` if the path or ID corresponds to a runtime file, otherwise `false`.
-  */
-  isBuiltinFile(pathOrId, options) {
-    return !!this.builtinIdMap.values().find((path) => path === this.resolvePath(pathOrId, {
+  isVirtual(pathOrId, options = {}) {
+    if (!pathOrId) {
+      return false;
+    }
+    const resolvedPath = this.resolve(pathOrId, {
       ...options,
       type: "file"
-    }));
-  }
-  /**
-  * Checks if a provided string is a valid runtime ID (does not need to already be created in the file system).
-  *
-  * @param id - The ID to check.
-  * @returns Whether the ID is a valid runtime ID.
-  */
-  isValidBuiltinId(id) {
-    return id.startsWith(`${this.#context.config.output.builtinPrefix}:`);
+    });
+    if (!resolvedPath) {
+      return false;
+    }
+    return this.meta[resolvedPath]?.mode === "virtual";
   }
   /**
-  * Check if a path or ID corresponds to a virtual file.
+  * Check if a path or id corresponds to a file written to the file system **(actually exists on disk)**.
   *
-  * @param pathOrId - The path or ID to check.
-  * @param options - Options for resolving the path, such as paths to check.
-  * @returns Whether the path or ID corresponds to a virtual file.
+  * @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)**.
   */
-  isVirtualFile(pathOrId, options = {}) {
+  isFs(pathOrId, options = {}) {
     if (!pathOrId) {
       return false;
     }
-    const resolvedPath = this.resolvePath(pathOrId, {
+    const resolvedPath = this.resolve(pathOrId, {
       ...options,
       type: "file"
     });
     if (!resolvedPath) {
       return false;
     }
-    if (this.builtinIdMap.values().find((path) => path === resolvedPath)) {
-      return true;
-    }
-    return this.#virtualFS.existsSync(resolvedPath);
+    return this.meta[resolvedPath]?.mode === "fs";
   }
   /**
   * Check if a path exists within one of the directories specified in the tsconfig.json's `path` field.
@@ -366,37 +547,6 @@ var VirtualFileSystem = class {
     return !!this.#context.tsconfig.options.paths && Object.keys(this.#context.tsconfig.options.paths).some((path) => pathOrId.startsWith(path.replaceAll("*", "")));
   }
   /**
-  * Checks if a given ID corresponds to a runtime file path.
-  *
-  * @param id - The unique identifier for the runtime file.
-  * @param pathOrId - The path or ID to check.
-  * @returns `true` if the ID corresponds to the path or ID of a runtime file, otherwise `false`.
-  */
-  isMatchingBuiltinId(id, pathOrId) {
-    const resolvedPath = this.resolvePath(pathOrId);
-    const resolvedId = this.resolveId(pathOrId);
-    return !!(this.isBuiltinFile(pathOrId) && (resolvedPath && (resolvedPath === this.builtinIdMap.get(id) || resolvedPath === this.builtinIdMap.get(this.formatRuntimeId(id))) || resolvedId && (resolvedId === this.builtinIdMap.get(id) || resolvedId === this.builtinIdMap.get(this.formatRuntimeId(id)))));
-  }
-  /**
-  * Lists all runtime files in the virtual file system.
-  *
-  * @returns A promise that resolves to an array of runtime files.
-  */
-  async listBuiltinFiles() {
-    const runtimeFiles = [];
-    for (const [id, path] of this.builtinIdMap.entries()) {
-      const contents = await this.readFile(path);
-      if (contents) {
-        runtimeFiles.push({
-          id: this.formatRuntimeId(id),
-          path,
-          contents
-        });
-      }
-    }
-    return runtimeFiles;
-  }
-  /**
   * Lists files in a given path.
   *
   * @param path - The path to list files from.
@@ -413,7 +563,7 @@ var VirtualFileSystem = class {
   */
   unlinkSync(path, options) {
     const formattedPath = toFilePath(path);
-    if (!this.fileExistsSync(path)) {
+    if (!this.isFile(formattedPath)) {
       return;
     }
     this.#log(LogLevelLabel.TRACE, `Synchronously removing file: ${formattedPath}`);
@@ -428,7 +578,7 @@ var VirtualFileSystem = class {
   */
   async unlink(path, options) {
     const formattedPath = toFilePath(path);
-    if (!this.fileExistsSync(path)) {
+    if (!this.isFile(formattedPath)) {
       return;
     }
     this.#log(LogLevelLabel.TRACE, `Removing file: ${formattedPath}`);
@@ -448,7 +598,7 @@ var VirtualFileSystem = class {
   */
   rmdirSync(path, options = {}) {
     const formattedPath = toFilePath(path);
-    if (!this.directoryExistsSync(path)) {
+    if (!this.isDirectory(formattedPath)) {
       return;
     }
     this.#log(LogLevelLabel.TRACE, `Synchronously removing directory: ${formattedPath}`);
@@ -467,7 +617,7 @@ var VirtualFileSystem = class {
   */
   async rmdir(path, options = {}) {
     const formattedPath = toFilePath(path);
-    if (!this.directoryExistsSync(path)) {
+    if (!this.isDirectory(formattedPath)) {
       return;
     }
     this.#log(LogLevelLabel.TRACE, `Removing directory: ${formattedPath}`);
@@ -494,7 +644,7 @@ var VirtualFileSystem = class {
   */
   async rm(path, options = {}) {
     this.#log(LogLevelLabel.TRACE, `Removing: ${toFilePath(path)}`);
-    if (this.directoryExistsSync(path)) {
+    if (this.isDirectory(path)) {
       return this.rmdir(path, options);
     }
     return this.unlink(path, options);
@@ -538,12 +688,12 @@ var VirtualFileSystem = class {
   /**
   * Lists files in a given path.
   *
-  * @param path - The path to list files from.
+  * @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(path, options = "utf8") {
-    return this.resolveFS(path).promises.readdir(toFilePath(path), options);
+  async readdir(pathOrId, options = "utf8") {
+    return this.resolveFS(pathOrId).promises.readdir(toFilePath(pathOrId), options);
   }
   /**
   * Asynchronously reads a file from the virtual file system (VFS).
@@ -555,7 +705,7 @@ var VirtualFileSystem = class {
     if (!pathOrId) {
       return void 0;
     }
-    const filePath = this.resolvePath(toFilePath(pathOrId), {
+    const filePath = this.resolve(toFilePath(pathOrId), {
       type: "file"
     });
     if (filePath) {
@@ -584,7 +734,7 @@ var VirtualFileSystem = class {
     if (!pathOrId) {
       return void 0;
     }
-    const filePath = this.resolvePath(toFilePath(pathOrId), {
+    const filePath = this.resolve(toFilePath(pathOrId), {
       type: "file"
     });
     if (filePath) {
@@ -601,137 +751,80 @@ var VirtualFileSystem = class {
   /**
   * Writes a file to the virtual file system (VFS).
   *
-  * @param file - The path to the file.
+  * @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(file, data = "", options = "utf8") {
-    const absolutePath = this.formatAbsoluteFilePath(toFilePath(file));
-    if (!this.directoryExistsSync(findFilePath(absolutePath))) {
-      await this.mkdir(findFilePath(absolutePath), options);
+  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);
+    }
+    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
+        });
+      }
     }
-    this.#log(LogLevelLabel.TRACE, `Writing ${absolutePath} file to the ${this.resolveOutputMode(absolutePath, options) === "fs" ? "" : "virtual "}file system (size: ${prettyBytes(new Blob(toArray(data)).size)})`);
-    this.#cachedFS.set(absolutePath, data.toString());
-    this.clearResolverCache(absolutePath);
-    const ifs = this.resolveFS(absolutePath, options);
+    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(absolutePath, data, omit(options, [
-        "mode"
-      ]));
+      return ifs.promises.writeFile(formattedPath, code, isNodeWriteFileOptions(options) ? options : "utf8");
     }
-    return ifs.writeFileSync(absolutePath, data, omit(options, [
-      "mode"
-    ]));
+    return ifs.writeFileSync(formattedPath, code, isNodeWriteFileOptions(options) ? options : "utf8");
   }
   /**
   * Synchronously writes a file to the virtual file system (VFS).
   *
-  * @param file - The file to write.
+  * @param path - The file to write.
   * @param data - The contents of the file.
   * @param options - Optional parameters for writing the file.
   */
-  writeFileSync(file, data = "", options = "utf8") {
-    const absolutePath = this.formatAbsoluteFilePath(toFilePath(file));
-    if (!this.directoryExistsSync(findFilePath(absolutePath))) {
-      this.mkdirSync(findFilePath(absolutePath));
-    }
-    this.#log(LogLevelLabel.TRACE, `Writing ${absolutePath} file to the ${this.resolveOutputMode(absolutePath, options) === "fs" ? "" : "virtual "} (size: ${prettyBytes(new Blob(toArray(data)).size)})`);
-    this.#cachedFS.set(absolutePath, data.toString());
-    this.clearResolverCache(absolutePath);
-    const writeStream = this.resolveFS(absolutePath, omit(options, [
-      "mode"
-    ])).createWriteStream(absolutePath);
+  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(data);
+      writeStream.write(code);
     } finally {
       writeStream.close();
     }
   }
   /**
-  * Writes a runtime file to the virtual file system (VFS).
-  *
-  * @param id - The unique identifier for the runtime file.
-  * @param path - The path to the runtime file.
-  * @param contents - The contents of the runtime file.
-  * @param options - Optional parameters for writing the runtime file.
-  * @returns A promise that resolves when the file is written.
-  */
-  async writeBuiltinFile(id, path, contents, options = {}) {
-    const formattedId = this.formatRuntimeId(id);
-    const absolutePath = this.formatAbsoluteFilePath(toFilePath(path));
-    this.builtinIdMap.set(formattedId, absolutePath);
-    let data = contents;
-    if (!options.skipFormat) {
-      data = await format(contents, {
-        absolutePath,
-        ...await resolveConfig(absolutePath)
-      });
-    }
-    const _options = defu3(isSetString(options) ? {} : options ?? {}, {
-      encoding: isSetString(options) ? options : "utf8",
-      mode: "virtual"
-    });
-    this.#log(LogLevelLabel.DEBUG, `Writing runtime file ${absolutePath} (size: ${prettyBytes(new Blob(toArray(data)).size)}) to ${this.resolveOutputMode(absolutePath, _options) === "fs" ? "disk" : "memory"}`);
-    return this.writeFile(absolutePath, data, _options);
-  }
-  /**
-  * Adds an entry file to the virtual file system.
-  *
-  * @param name - The file name or absolute path of the entry module.
-  * @param contents - The contents of the entry file.
-  * @param options - Optional parameters for writing the entry file.
-  */
-  async writeEntryFile(name, contents, options = {}) {
-    const absolutePath = this.formatAbsoluteFilePath(isAbsolutePath(toFilePath(name)) ? toFilePath(name) : toFilePath(joinPaths(this.#context.entryPath, name)));
-    let data = contents;
-    if (!options.skipFormat) {
-      data = await format(contents, {
-        absolutePath,
-        ...await resolveConfig(absolutePath)
-      });
-    }
-    const _options = defu3(isSetString(options) ? {} : options ?? {}, {
-      encoding: isSetString(options) ? options : "utf8",
-      mode: "virtual"
-    });
-    this.#log(LogLevelLabel.DEBUG, `Writing entry file ${absolutePath} (size: ${prettyBytes(new Blob(toArray(data)).size)}) to ${this.resolveOutputMode(absolutePath, _options) === "fs" ? "disk" : "virtual memory"}`);
-    return this.writeFile(absolutePath, data, _options);
-  }
-  /**
-  * Writes a file to disk from the physical file system (on disk).
-  *
-  * @param path - The path to the file to write.
-  * @param contents - The contents of the file to write.
-  * @param options - Optional parameters for writing the file.
-  * @returns A promise that resolves when the file is written.
-  */
-  async writeFileToDisk(path, contents, options = {}) {
-    const absolutePath = this.formatAbsoluteFilePath(toFilePath(path));
-    let data = contents;
-    if (!options.skipFormat) {
-      const resolvedConfig = await resolveConfig(absolutePath);
-      if (resolvedConfig) {
-        data = await format(contents, {
-          absolutePath,
-          ...resolvedConfig
-        });
-      }
-    }
-    return this.writeFile(absolutePath, data, defu3({
-      mode: "fs"
-    }, isSetString(options) ? {} : options ?? {}, {
-      encoding: isSetString(options) ? options : "utf8"
-    }));
-  }
-  /**
   * Synchronously checks if a file exists in the virtual file system (VFS).
   *
   * @param pathOrId - The path or ID of the file to check.
   * @returns `true` if the file exists, otherwise `false`.
   */
   existsSync(pathOrId) {
-    return this.pathExistsSync(this.resolvePath(toFilePath(pathOrId)) || toFilePath(pathOrId));
+    return this.resolve(pathOrId) !== false;
   }
   /**
   * Checks if a file exists in the virtual file system (VFS).
@@ -739,32 +832,22 @@ var VirtualFileSystem = class {
   * @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 path - The path of the file to check.
+  * @param pathOrId - The path of the file to check.
   * @returns `true` if the file exists, otherwise `false`.
   */
-  fileExistsSync(path) {
-    const formattedPath = this.formatAbsoluteFilePath(toFilePath(path));
-    return this.isValidBuiltinId(formattedPath) || this.#virtualFS.existsSync(formattedPath) && this.#virtualFS.lstatSync(formattedPath).isFile() || this.#fs.existsSync(formattedPath) && this.#fs.lstatSync(formattedPath).isFile() || this.resolveFS(path).existsSync(formattedPath) && this.resolveFS(path).lstatSync(formattedPath).isFile();
+  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()));
   }
   /**
   * Checks if a directory exists in the virtual file system (VFS).
   *
-  * @param path - The path of the directory to check.
+  * @param pathOrId - The path of the directory to check.
   * @returns `true` if the directory exists, otherwise `false`.
   */
-  directoryExistsSync(path) {
-    const formattedPath = this.formatAbsoluteFilePath(toFilePath(path));
-    return this.#virtualFS.existsSync(formattedPath) && this.#virtualFS.lstatSync(formattedPath).isDirectory() || this.#fs.existsSync(formattedPath) && this.#fs.lstatSync(formattedPath).isDirectory() || this.resolveFS(path).existsSync(formattedPath) && this.resolveFS(path).lstatSync(formattedPath).isDirectory();
-  }
-  /**
-  * 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`.
-  */
-  pathExistsSync(path) {
-    const formattedPath = this.formatAbsoluteFilePath(toFilePath(path));
-    return this.isValidBuiltinId(formattedPath) || this.#virtualFS.existsSync(formattedPath) || this.#fs.existsSync(formattedPath) || this.resolveFS(path).existsSync(formattedPath);
+  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()));
   }
   /**
   * Retrieves the status of a file in the virtual file system (VFS).
@@ -773,7 +856,7 @@ var VirtualFileSystem = class {
   * @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.resolveFS(pathOrId).promises.stat(this.resolvePath(toFilePath(pathOrId)) || toFilePath(pathOrId), options);
+    return this.resolveFS(pathOrId).promises.stat(this.resolve(toFilePath(pathOrId)) || toFilePath(pathOrId), options);
   }
   /**
   * Synchronously retrieves the status of a file in the virtual file system (VFS).
@@ -782,7 +865,7 @@ var VirtualFileSystem = class {
   * @returns The file's status information, or false if the file does not exist.
   */
   statSync(pathOrId) {
-    return this.resolveFS(pathOrId).statSync(this.resolvePath(toFilePath(pathOrId)) || toFilePath(pathOrId));
+    return this.resolveFS(pathOrId).statSync(this.resolve(toFilePath(pathOrId)) || toFilePath(pathOrId));
   }
   /**
   * Retrieves the status of a symbolic link in the virtual file system (VFS).
@@ -791,7 +874,7 @@ var VirtualFileSystem = class {
   * @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.resolveFS(pathOrId).promises.lstat(this.resolvePath(toFilePath(pathOrId)) || toFilePath(pathOrId), options);
+    return this.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).
@@ -800,23 +883,7 @@ var VirtualFileSystem = class {
   * @returns The symbolic link's status information, or false if the link does not exist.
   */
   lstatSync(pathOrId, options) {
-    return this.resolveFS(pathOrId).lstatSync(this.resolvePath(toFilePath(pathOrId)) || toFilePath(pathOrId), options);
-  }
-  /**
-  * Resolves a path or ID to a runtime file id in the virtual file system.
-  *
-  * @param pathOrId - The path or id of the file to resolve.
-  * @returns The resolved id of the runtime file if it exists, otherwise false.
-  */
-  resolveId(pathOrId) {
-    if (this.builtinIdMap.has(this.formatRuntimeId(toFilePath(pathOrId)))) {
-      return this.formatRuntimeId(toFilePath(pathOrId));
-    }
-    const filePath = this.resolvePath(toFilePath(pathOrId));
-    if (filePath) {
-      return this.builtinIdMap.keys().find((id) => this.builtinIdMap.get(id) === filePath) || false;
-    }
-    return false;
+    return this.resolveFS(pathOrId).lstatSync(this.resolve(toFilePath(pathOrId)) || toFilePath(pathOrId), options);
   }
   /**
   * Resolves a path based on TypeScript's `tsconfig.json` paths.
@@ -829,9 +896,9 @@ var VirtualFileSystem = class {
   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.resolvePathName(joinPaths(this.#context.workspaceConfig.workspaceRoot, tsconfigPath.replaceAll("*", ""), path.replace(tsconfigPathKey.replaceAll("*", ""), ""))) || this.formatAbsoluteFilePath(tsconfigPath) === this.formatAbsoluteFilePath(path));
+        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.formatAbsoluteFilePath(resolvedPath) === this.formatAbsoluteFilePath(path) ? this.formatAbsoluteFilePath(resolvedPath) : this.resolvePathName(joinPaths(this.#context.workspaceConfig.workspaceRoot, resolvedPath.replaceAll("*", ""), path.replace(tsconfigPathKey.replaceAll("*", ""), "")));
+          return this.formatPath(resolvedPath) === this.formatPath(path) ? this.formatPath(resolvedPath) : this.resolvePath(joinPaths(this.#context.workspaceConfig.workspaceRoot, resolvedPath.replaceAll("*", ""), path.replace(tsconfigPathKey.replaceAll("*", ""), "")));
         }
       }
     }
@@ -861,7 +928,7 @@ var VirtualFileSystem = class {
   * @returns The resolved real path if it exists, otherwise undefined.
   */
   realpathSync(pathOrId) {
-    const filePath = this.resolvePath(toFilePath(pathOrId));
+    const filePath = this.resolve(toFilePath(pathOrId));
     if (!filePath) {
       throw new Error(`File not found: ${toFilePath(pathOrId)}`);
     }
@@ -874,24 +941,18 @@ var VirtualFileSystem = class {
   * @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.
   */
-  resolvePath(pathOrId, options = {}) {
-    const formattedPath = toFilePath(pathOrId);
-    const resolverKey = `${formattedPath}${options.withExtension ? "-ext" : ""}${options.paths ? `-${murmurhash(options.paths)}` : ""}${options.type ? `-${options.type}` : ""}`;
+  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);
-    } else if (this.#cachedFS.has(formattedPath)) {
-      return formattedPath;
     }
-    let result = false;
-    if (this.isValidBuiltinId(formattedPath)) {
-      result = this.builtinIdMap.get(this.formatRuntimeId(formattedPath));
-    } else {
-      result = this.resolvePathName(formattedPath, options);
+    let result = this.resolveId(formattedPathOrId);
+    if (!result) {
+      result = this.resolvePath(formattedPathOrId, options);
     }
     if (!result) {
       result = false;
-    } else {
-      result = toFilePath(result);
     }
     if (result && options.withExtension === false) {
       return result.replace(/\.[m|c]?[t|j]sx?$/, "");
@@ -900,16 +961,12 @@ var VirtualFileSystem = class {
     return result;
   }
   /**
-  * Formats a file path by removing the runtime prefix and leading null character.
+  * Retrieves the partial metadata for all files in the virtual file system (VFS).
   *
-  * @param path - The file path to format.
-  * @returns The formatted file path.
+  * @returns A record containing the partial metadata for all files.
   */
-  formatFilePath(path) {
-    if (!isSetString(path)) {
-      throw new Error(`Invalid path provided. Expected a string or a valid file path.`);
-    }
-    return path.replace(new RegExp(`^${this.#context.config.output.builtinPrefix}:`), "").replace(/^\\0/, "");
+  getPartialMeta() {
+    return Object.fromEntries(Object.entries(this.#meta).filter(([_, data]) => isSetObject(data)));
   }
   /**
   * Converts a relative path to an absolute path based on the workspace and project root.
@@ -917,56 +974,67 @@ var VirtualFileSystem = class {
   * @param path - The relative path to convert.
   * @returns The absolute path.
   */
-  formatAbsoluteFilePath = /* @__PURE__ */ __name((path) => {
-    const formattedPath = this.formatFilePath(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(this.#context.workspaceConfig.workspaceRoot, formattedPath);
     }
     return formattedPath;
-  }, "formatAbsoluteFilePath");
+  }
   /**
-  * Formats a runtime ID by removing the file extension and prepending the runtime prefix.
+  * Formats a file id by removing the file extension and prepending the runtime prefix.
   *
-  * @param id - The runtime ID to format.
-  * @returns The formatted runtime ID.
+  * @param id - The file ID to format.
+  * @returns The formatted file ID.
   */
-  formatRuntimeId(id) {
-    return `${this.#context.config.output.builtinPrefix}:${this.formatFilePath(id).replace(/\.[m|c]?[t|j]sx?$/, "")}`;
+  formatId(id) {
+    const formattedId = toFilePath(id);
+    return `${this.#context.config.output.builtinPrefix}:${formattedId.replace(new RegExp(`^${this.#context.config.output.builtinPrefix}:`), "").replace(/^\\0/, "").replace(findFileExtensionSafe(formattedId), "")}`;
   }
   /**
-  * Resolves a path or ID parameter to a corresponding virtual file path in the virtual file system (VFS).
+  * Resolves an id parameter to a corresponding virtual file path in the virtual file system (VFS).
   *
-  * @param pathOrId - The path or ID to resolve.
-  * @returns The resolved file path if it exists, otherwise undefined.
+  * @param id - The id to resolve.
+  * @returns The resolved file id if it exists, otherwise undefined.
   */
-  resolvePathName(pathOrId, options = {}) {
-    if (pathOrId.startsWith(`${this.#context.config.output.builtinPrefix}:`)) {
-      return false;
+  resolveId(id) {
+    if (this.#ids[this.formatId(id)]) {
+      return this.#ids[this.formatId(id)] || false;
     }
-    if (isAbsolutePath(pathOrId)) {
-      if (options.type === "file" ? this.fileExistsSync(pathOrId) : this.pathExistsSync(pathOrId)) {
-        return pathOrId;
+    return false;
+  }
+  /**
+  * Resolves a path parameter to a corresponding virtual file path in the virtual file system (VFS).
+  *
+  * @param path - The path to resolve.
+  * @param options - Optional parameters for resolving the path.
+  * @returns The resolved file path if it exists, otherwise undefined.
+  */
+  resolvePath(path, options = {}) {
+    if (isAbsolutePath(path)) {
+      if (this.#existsSync(path)) {
+        return path;
       }
-      const result = checkVariants(pathOrId, this);
+      const result = this.checkVariants(path);
       if (result) {
         return result;
       }
     }
-    for (const path of this.resolveParentPaths(pathOrId, options.paths)) {
-      const request = joinPaths(path, pathOrId);
-      if (options.type === "file" ? this.fileExistsSync(pathOrId) : this.pathExistsSync(pathOrId)) {
+    for (const parentPath of this.resolveParentPaths(path, options.paths)) {
+      const request = joinPaths(parentPath, path);
+      if (this.#existsSync(request)) {
         return request;
       }
-      const result = checkVariants(request, this);
+      const result = this.checkVariants(request);
       if (result) {
         return result;
       }
     }
     return false;
   }
-  resolveParentPaths(request, current = []) {
+  resolveParentPaths(request, parents = []) {
     let paths = [
       this.#context.workspaceConfig.workspaceRoot,
       joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.projectRoot)
@@ -984,7 +1052,7 @@ var VirtualFileSystem = class {
         ret.push(path);
       }
       return ret;
-    }, current.filter(Boolean).map((p) => this.formatAbsoluteFilePath(toFilePath(p))));
+    }, parents.filter(Boolean).map((p) => this.formatPath(p)));
   }
   /**
   * Select the file system module to use for the operation based on the path or URL.
@@ -1015,7 +1083,7 @@ var VirtualFileSystem = class {
     } 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 null;
+    return void 0;
   }
   /**
   * Clears the resolver cache for a given path.
@@ -1025,208 +1093,93 @@ var VirtualFileSystem = class {
   clearResolverCache(path) {
     this.#cachedResolver.keys().filter((key) => key.startsWith(toFilePath(path))).forEach((key) => this.#cachedResolver.delete(key));
   }
-};
-var FILE_PREFIX = "file://";
-function toFilePath(pathOrUrl) {
-  if (!pathOrUrl) {
-    throw new Error("No Path or URL provided to Virtual File System");
-  }
-  let result = pathOrUrl.toString();
-  if (result.startsWith(FILE_PREFIX)) {
-    result = result.slice(FILE_PREFIX.length);
-  }
-  return result;
-}
-__name(toFilePath, "toFilePath");
-var FS_METHODS = [
-  "mkdir",
-  "mkdirSync",
-  "rmdir",
-  "rmdirSync",
-  "unlink",
-  "unlinkSync",
-  "existsSync",
-  "realpathSync",
-  "writeFileSync",
-  "readFileSync",
-  "readdirSync",
-  "createWriteStream",
-  "WriteStream",
-  "createReadStream",
-  "ReadStream"
-];
-var FS_PROMISE_METHODS = [
-  "mkdir",
-  "rm",
-  "rmdir",
-  "unlink",
-  "writeFile",
-  "readFile",
-  "readdir",
-  "stat",
-  "lstat"
-];
-function cloneFS(originalFS) {
-  const clonedFS = {
-    ...originalFS,
-    promises: {
-      ...originalFS.promises ?? {}
+  /**
+  * Check if the file exists with different variants (index, extensions).
+  *
+  * @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.
+  */
+  checkVariants(request, parentPath) {
+    const path = parentPath ? joinPaths(parentPath, request) : request;
+    let file = this.checkExtensions(path);
+    if (file) {
+      return file;
     }
-  };
-  for (const method of FS_METHODS) {
-    if (originalFS[method]) {
-      clonedFS[method] = originalFS[method];
+    file = this.checkIndex(path);
+    if (file) {
+      return file;
     }
+    return false;
   }
-  originalFS.promises ??= {};
-  for (const method of FS_PROMISE_METHODS) {
-    if (originalFS.promises[method]) {
-      clonedFS.promises ??= {};
-      clonedFS.promises[method] = originalFS.promises[method];
-      clonedFS[method] = originalFS.promises[method];
+  /**
+  * Check if the index file exists in the given request path.
+  *
+  * @param request - The request path to check.
+  * @returns The index file path if it exists, otherwise false.
+  */
+  checkIndex(request) {
+    let file = joinPaths(request, "index");
+    if (this.#existsSync(file)) {
+      return file;
     }
-  }
-  for (const prop in clonedFS) {
-    if (isFunction(clonedFS[prop])) {
-      clonedFS[prop] = clonedFS[prop].bind(originalFS);
-      if (isFunction(clonedFS.promises[prop])) {
-        clonedFS.promises[prop] = clonedFS.promises[prop].bind(originalFS);
-      }
+    file = this.checkExtensions(file);
+    if (file) {
+      return file;
     }
+    return false;
   }
-  for (const prop in clonedFS.promises) {
-    if (isFunction(clonedFS.promises[prop])) {
-      clonedFS.promises[prop] = clonedFS.promises[prop].bind(originalFS);
+  /**
+  * Check if the file exists with different extensions.
+  *
+  * @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.
+  */
+  checkExtensions(request) {
+    let file = `${request}.ts`;
+    if (this.#existsSync(file)) {
+      return file;
     }
+    file = `${request}.mts`;
+    if (this.#existsSync(file)) {
+      return file;
+    }
+    file = `${request}.cts`;
+    if (this.#existsSync(file)) {
+      return file;
+    }
+    file = `${request}.tsx`;
+    if (this.#existsSync(file)) {
+      return file;
+    }
+    file = `${request}.js`;
+    if (this.#existsSync(file)) {
+      return file;
+    }
+    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;
   }
-  return clonedFS;
-}
-__name(cloneFS, "cloneFS");
-function patchFS(originalFS, vfs) {
-  const clonedFS = cloneFS(originalFS);
-  originalFS.mkdirSync = (file, options) => vfs.mkdirSync(toFilePath(file), options);
-  originalFS.mkdir = (file, options, callback) => vfs.mkdir(toFilePath(file), options, callback);
-  originalFS.promises.mkdir = async (file, options) => vfs.mkdir(toFilePath(file), options);
-  originalFS.unlinkSync = (file) => vfs.unlinkSync(toFilePath(file));
-  originalFS.promises.rm = async (file, options) => vfs.rm(toFilePath(file), options);
-  originalFS.promises.unlink = async (file) => vfs.unlink(toFilePath(file));
-  originalFS.existsSync = (file) => vfs.existsSync(toFilePath(file));
-  Object.defineProperty(originalFS, "realpathSync", {
-    value: /* @__PURE__ */ __name((file, options) => vfs.realpathSync(toFilePath(file), options), "value")
-  });
-  originalFS.writeFileSync = (file, data, options) => vfs.writeFileSync(toFilePath(file), data, options);
-  originalFS.promises.writeFile = async (file, data, options) => vfs.writeFile(toFilePath(file), data, options);
-  originalFS.readFileSync = (file, options) => vfs.readFileSync(toFilePath(file), options);
-  originalFS.promises.readFile = (file, options) => vfs.readFile(toFilePath(file), options);
-  originalFS.readdirSync = (file, options) => vfs.readdirSync(toFilePath(file), options);
-  originalFS.promises.readdir = (file, options) => vfs.readdir(toFilePath(file), options);
-  Object.defineProperty(originalFS, "statSync", {
-    value: /* @__PURE__ */ __name((file, options) => vfs.statSync(toFilePath(file), options), "value")
-  });
-  originalFS.stat = (file, options) => vfs.statSync(toFilePath(file), options);
-  originalFS.promises.stat = (file, options) => vfs.stat(toFilePath(file), options);
-  Object.defineProperty(originalFS, "lstatSync", {
-    value: /* @__PURE__ */ __name((file, options) => vfs.lstatSync(toFilePath(file), options), "value")
-  });
-  originalFS.lstat = (file, options) => vfs.lstatSync(toFilePath(file), options);
-  originalFS.promises.lstat = (file, options) => vfs.lstat(toFilePath(file), options);
-  return () => {
-    originalFS.mkdirSync = clonedFS.mkdirSync;
-    originalFS.mkdir = clonedFS.mkdir;
-    originalFS.promises.mkdir = clonedFS.promises.mkdir;
-    originalFS.unlinkSync = clonedFS.unlinkSync;
-    originalFS.promises.rm = clonedFS.promises.rm;
-    originalFS.promises.unlink = clonedFS.promises.unlink;
-    originalFS.existsSync = clonedFS.existsSync;
-    originalFS.realpathSync = clonedFS.realpathSync;
-    originalFS.writeFileSync = clonedFS.writeFileSync;
-    originalFS.promises.writeFile = clonedFS.promises.writeFile;
-    originalFS.readFileSync = clonedFS.readFileSync;
-    originalFS.promises.readFile = clonedFS.promises.readFile;
-    originalFS.readdirSync = clonedFS.readdirSync;
-    originalFS.promises.readdir = clonedFS.promises.readdir;
-    Object.defineProperty(originalFS, "statSync", {
-      value: clonedFS.statSync
-    });
-    originalFS.stat = clonedFS.stat;
-    originalFS.promises.stat = clonedFS.promises.stat;
-    Object.defineProperty(originalFS, "lstatSync", {
-      value: clonedFS.lstatSync
-    });
-    originalFS.lstat = clonedFS.lstat;
-    originalFS.promises.lstat = clonedFS.promises.lstat;
-  };
-}
-__name(patchFS, "patchFS");
-function checkVariants(request, vfs, parentPath) {
-  const path = parentPath ? joinPaths(parentPath, request) : request;
-  let file = checkExtensions(path, vfs);
-  if (file) {
-    return file;
-  }
-  file = checkIndex(path, vfs);
-  if (file) {
-    return file;
-  }
-  return false;
-}
-__name(checkVariants, "checkVariants");
-function checkIndex(request, vfs) {
-  let file = joinPaths(request, "index");
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  file = checkExtensions(file, vfs);
-  if (file) {
-    return file;
-  }
-  return false;
-}
-__name(checkIndex, "checkIndex");
-function checkExtensions(request, vfs) {
-  let file = `${request}.ts`;
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  file = `${request}.mts`;
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  file = `${request}.cts`;
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  file = `${request}.tsx`;
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  file = `${request}.js`;
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  file = `${request}.mjs`;
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  file = `${request}.cjs`;
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  file = `${request}.jsx`;
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  file = `${request}.json`;
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  file = `${request}.d.ts`;
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  return false;
-}
-__name(checkExtensions, "checkExtensions");
+};
 function createVfs(context) {
   const vfs = new VirtualFileSystem(context);
   return vfs;
@@ -1234,7 +1187,8 @@ function createVfs(context) {
 __name(createVfs, "createVfs");
 
 // src/internal/contexts/context.ts
-var cache = /* @__PURE__ */ new WeakMap();
+var configCache = /* @__PURE__ */ new WeakMap();
+var parseCache = /* @__PURE__ */ new WeakMap();
 var PowerlinesContext = class _PowerlinesContext {
   static {
     __name(this, "PowerlinesContext");
@@ -1461,6 +1415,57 @@ var PowerlinesContext = class _PowerlinesContext {
     return relativeToWorkspaceRoot(this.config.projectRoot);
   }
   /**
+  * 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);
+  }
+  /**
+  * Get the project root relative to the workspace root
+  */
+  async getBuiltins() {
+    return Promise.all(Object.entries(this.fs.meta).filter(([, meta]) => meta && meta.variant === "builtin").map(async ([path, meta]) => {
+      const code = await this.fs.readFile(path);
+      return {
+        ...meta,
+        path,
+        code
+      };
+    }));
+  }
+  /**
+  * Resolves a entry virtual file and writes it to the VFS if it does not already exist
+  *
+  * @param code - The source code of the entry file
+  * @param path - A path to write the entry file to
+  * @param options - Optional write file options
+  */
+  async writeEntry(code, path, options = {}) {
+    return this.fs.writeFile(isAbsolute(path) ? path : appendPath(path, this.entryPath), {
+      code,
+      variant: "entry"
+    }, defu3(options, {
+      mode: this.config.output.mode
+    }));
+  }
+  /**
+  * Resolves a builtin virtual file and writes it to the VFS if it does not already exist
+  *
+  * @param code - The source code of the builtin file
+  * @param id - The unique identifier of the builtin file
+  * @param path - An optional path to write the builtin file to
+  * @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), {
+      id,
+      code,
+      variant: "builtin"
+    }, defu3(options, {
+      mode: this.config.output.mode
+    }));
+  }
+  /**
   * Parses the source code and returns a {@link ParseResult} object.
   *
   * @param code - The source code to parse.
@@ -1469,12 +1474,31 @@ var PowerlinesContext = class _PowerlinesContext {
   * @returns The parsed {@link ParseResult} object.
   */
   async parse(code, id, options = {}) {
-    return parseAsync(id, code, defu3(options ?? {}, {
+    if (parseCache.has({
+      code,
+      options
+    })) {
+      return parseCache.get({
+        code,
+        options
+      });
+    }
+    const result = await parseAsync(id, code, defu3(options ?? {}, {
       lang: hasFileExtension(id) ? void 0 : "ts",
       astType: hasFileExtension(id) ? void 0 : "ts",
       sourceType: "module",
       showSemanticErrors: false
     }));
+    if (result.errors && result.errors.length > 0) {
+      throw new Error(`Powerlines parsing errors in file: ${id}
+${result.errors.map((error) => `  [${error.severity}] ${error.message}${error.codeframe ? ` (${error.codeframe})` : ""}${error.helpMessage ? `
+    Help: ${error.helpMessage}` : ""}`).join("\n")}`);
+    }
+    parseCache.set({
+      code,
+      options
+    }, result);
+    return result;
   }
   /**
   * Update the context using a new user configuration options
@@ -1563,8 +1587,8 @@ var PowerlinesContext = class _PowerlinesContext {
       configFile: config.configFile ?? this.config.configFile,
       command: this.config.inlineConfig?.command
     };
-    if (cache.has(cacheKey)) {
-      const result = cache.get(cacheKey);
+    if (configCache.has(cacheKey)) {
+      const result = configCache.get(cacheKey);
       this.projectJson = result.projectJson;
       this.packageJson = result.packageJson;
       this.#checksum = result.checksum;
@@ -1589,7 +1613,7 @@ var PowerlinesContext = class _PowerlinesContext {
       });
       const userConfig = await loadUserConfigFile(cacheKey.projectRoot, this.resolver, cacheKey.command, cacheKey.mode, cacheKey.configFile);
       this.mergeUserConfig(userConfig.config);
-      cache.set(cacheKey, {
+      configCache.set(cacheKey, {
         projectJson: this.projectJson,
         packageJson: this.packageJson,
         checksum: this.#checksum,
@@ -2048,7 +2072,7 @@ function resolveModulePath(nodePath, state) {
     return;
   }
   const sourcePath = nodePath.node.value;
-  const resolvedPath = state.context?.fs.resolvePath(sourcePath);
+  const resolvedPath = state.context?.fs.resolve(sourcePath);
   if (resolvedPath) {
     nodePath.replaceWith(t.stringLiteral(
       // Remove the file extension if it exists
@@ -2149,8 +2173,9 @@ var moduleResolverBabelPlugin = /* @__PURE__ */ __name((context) => {
 async function generateTypes(context) {
   context.log(LogLevelLabel.TRACE, `Preparing the TypeScript definitions for the Powerlines project.`);
   context.log(LogLevelLabel.TRACE, "Transforming built-ins runtime modules files.");
-  const builtinFiles = await Promise.all((await context.fs.listBuiltinFiles()).filter((file) => !context.fs.isMatchingBuiltinId("index", file.id)).map(async (file) => {
-    const result = await transformAsync(file.contents, {
+  const builtinFiles = await context.getBuiltins();
+  const builtinFilePaths = await Promise.all(builtinFiles.map(async (file) => {
+    const result = await transformAsync(file.code.toString(), {
       highlightCode: true,
       code: true,
       ast: false,
@@ -2178,14 +2203,14 @@ async function generateTypes(context) {
       throw new Error(`Powerlines - Generate Types failed to compile ${file.id}`);
     }
     context.log(LogLevelLabel.TRACE, `Writing transformed built-in runtime file ${file.id}.`);
-    await context.fs.writeBuiltinFile(file.id, file.path, result.code);
+    await context.writeBuiltin(result.code, file.id, file.path);
     return file.path;
   }));
   const typescriptPath = await resolvePackage("typescript");
   if (!typescriptPath) {
     throw new Error("Could not resolve TypeScript package location. Please ensure TypeScript is installed.");
   }
-  const files = builtinFiles.reduce((ret, fileName) => {
+  const files = builtinFilePaths.reduce((ret, fileName) => {
     const formatted = replacePath(fileName, context.workspaceConfig.workspaceRoot);
     if (!ret.includes(formatted)) {
       ret.push(formatted);
@@ -2220,9 +2245,9 @@ async function generateTypes(context) {
   const emitResult = program.emit(void 0, (fileName, text, _, __, sourceFiles, _data) => {
     const sourceFile2 = sourceFiles?.[0];
     if (sourceFile2?.fileName && !fileName.endsWith(".map")) {
-      if (context.fs.isBuiltinFile(sourceFile2.fileName)) {
+      if (builtinFiles.some((file) => file.id === sourceFile2.fileName || file.path === sourceFile2.fileName)) {
         builtinModules += `
-declare module "${context.fs.resolveId(sourceFile2.fileName)}" {
+declare module "${context.fs.resolve(sourceFile2.fileName)}" {
     ${text.trim().replace(/^\s*export\s*declare\s*/gm, "export ").replace(/^\s*declare\s*/gm, "")}
 }
 `;
@@ -2261,7 +2286,9 @@ ${builtinModules}`.replace(
     /import\s*(?:type\s*)?\{?[\w,\s]*(?:\}\s*)?from\s*(?:'|")@?[a-zA-Z0-9-\\/.]*(?:'|");?/g,
     ""
   ).replaceAll("#private;", "").replace(/__Ω/g, ""));
-  await context.fs.writeFileToDisk(sourceFile.id, getString(sourceFile.code));
+  await context.fs.writeFile(sourceFile.id, getString(sourceFile.code), {
+    mode: "fs"
+  });
 }
 __name(generateTypes, "generateTypes");
 async function installPackage(context, packageName, dev = false) {
@@ -2425,7 +2452,9 @@ async function initializeTsconfig(context) {
   const tsconfigFilePath = getTsconfigFilePath(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
   context.tsconfig.originalTsconfigJson = await readJsonFile(tsconfigFilePath);
   context.tsconfig.tsconfigJson = await resolveTsconfigChanges(context);
-  await context.fs.writeFileToDisk(tsconfigFilePath, StormJSON.stringify(context.tsconfig.tsconfigJson));
+  await context.fs.writeFile(tsconfigFilePath, StormJSON.stringify(context.tsconfig.tsconfigJson), {
+    mode: "fs"
+  });
   context.tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig, context.config.tsconfigRaw, context.tsconfig.originalTsconfigJson);
 }
 __name(initializeTsconfig, "initializeTsconfig");
@@ -2561,11 +2590,6 @@ ${formatLogMessage(context.config)}`);
       await this.callPreHook(context, "prepare");
       if (context.config.projectType === "application") {
         context.log(LogLevelLabel.TRACE, "Generating built-in barrel file");
-        await context.fs.writeBuiltinFile("index", joinPaths(context.builtinsPath, "index.ts"), `
-  ${getFileHeader(context)}
-
-  ${(await context.fs.listBuiltinFiles()).filter((file) => !isParentPath(file.path, joinPaths(context.builtinsPath, "log")) && !isParentPath(file.path, joinPaths(context.builtinsPath, "storage"))).map((file) => `export * from "./${replacePath(file.path, context.builtinsPath).replace(`.${findFileExtensionSafe(file.path)}`, "")}";`).join("\n")}
-  `);
       }
       if (context.config.output.dts !== false) {
         await generateTypes(context);
@@ -3039,9 +3063,7 @@ function createUnpluginFactory(variant, decorate) {
       async function load(id) {
         const environment = await api.context.getEnvironment();
         if (id) {
-          const resolvedPath = environment.fs.resolvePath(id, {
-            type: "file"
-          });
+          const resolvedPath = environment.fs.resolve(id);
           if (resolvedPath) {
             return environment.fs.readFile(resolvedPath);
           }
@@ -3118,5 +3140,5 @@ function createUnpluginFactory(variant, decorate) {
 __name(createUnpluginFactory, "createUnpluginFactory");
 
 export { createUnpluginFactory };
-//# sourceMappingURL=chunk-6IEUZ5DZ.js.map
-//# sourceMappingURL=chunk-6IEUZ5DZ.js.map
+//# sourceMappingURL=chunk-PIFE7MUZ.js.map
+//# sourceMappingURL=chunk-PIFE7MUZ.js.map