powerlines 0.10.0 → 0.10.2

package/dist/lib/{chunk-2D74QBNW.cjs → chunk-M7WHFUKR.cjs}

@@ -1,14 +1,14 @@
 'use strict';
 
-var chunkTZFBE35T_cjs = require('./chunk-TZFBE35T.cjs');
+var chunkRQICHHZM_cjs = require('./chunk-RQICHHZM.cjs');
 var chunkMFC7UJHT_cjs = require('./chunk-MFC7UJHT.cjs');
-var chunkXFIGAAKN_cjs = require('./chunk-XFIGAAKN.cjs');
+var chunkQ2RUDKWY_cjs = require('./chunk-Q2RUDKWY.cjs');
 var chunkRK2VVGL6_cjs = require('./chunk-RK2VVGL6.cjs');
-var chunkVRNWPH35_cjs = require('./chunk-VRNWPH35.cjs');
+var chunk7EAV6Q7B_cjs = require('./chunk-7EAV6Q7B.cjs');
 var chunkLJZEN4HP_cjs = require('./chunk-LJZEN4HP.cjs');
 var chunkMGEZC2RV_cjs = require('./chunk-MGEZC2RV.cjs');
 var chunk632PWWU7_cjs = require('./chunk-632PWWU7.cjs');
-var chunk65DUUIIF_cjs = require('./chunk-65DUUIIF.cjs');
+var chunkUQJWVRRE_cjs = require('./chunk-UQJWVRRE.cjs');
 var chunkBEKLDCTV_cjs = require('./chunk-BEKLDCTV.cjs');
 var chunkPK6SKIKE_cjs = require('./chunk-PK6SKIKE.cjs');
 var types = require('@storm-software/config-tools/types');
@@ -22,8 +22,6 @@ var helpers = require('@stryke/fs/helpers');
 var install = require('@stryke/fs/install');
 var listFiles = require('@stryke/fs/list-files');
 var packageFns = require('@stryke/fs/package-fns');
-var filePathFns = require('@stryke/path/file-path-fns');
-var isParentPath = require('@stryke/path/is-parent-path');
 var joinPaths = require('@stryke/path/join-paths');
 var replace = require('@stryke/path/replace');
 var isError = require('@stryke/type-checks/is-error');
@@ -44,6 +42,8 @@ var murmurhash = require('@stryke/hash/murmurhash');
 var getUnique = require('@stryke/helpers/get-unique');
 var omit = require('@stryke/helpers/omit');
 var append = require('@stryke/path/append');
+var filePathFns = require('@stryke/path/file-path-fns');
+var isType = require('@stryke/path/is-type');
 var join = require('@stryke/path/join');
 var isNull = require('@stryke/type-checks/is-null');
 var isString = require('@stryke/type-checks/is-string');
@@ -51,9 +51,10 @@ var uuid = require('@stryke/unique-id/uuid');
 var oxcParser = require('oxc-parser');
 var jiti = require('jiti');
 var bufferToString = require('@stryke/convert/buffer-to-string');
-var isType = require('@stryke/path/is-type');
+var isParentPath = require('@stryke/path/is-parent-path');
 var prettyBytes = require('@stryke/string-format/pretty-bytes');
 var isBuffer = require('@stryke/type-checks/is-buffer');
+var isUndefined = require('@stryke/type-checks/is-undefined');
 var memfs = require('memfs');
 var buffer = require('buffer');
 var fs = require('fs');
@@ -161,6 +162,154 @@ function createResolver(options) {
   return baseResolver;
 }
 chunkPK6SKIKE_cjs.__name(createResolver, "createResolver");
+function isBufferEncoding(options) {
+  return isSetString.isSetString(options) || options === null;
+}
+chunkPK6SKIKE_cjs.__name(isBufferEncoding, "isBufferEncoding");
+function isPowerlinesWriteFileOptions(options) {
+  return !isBufferEncoding(options) && isSetObject.isSetObject(options) && ("skipFormat" in options || "mode" in options && (options.mode === "fs" || options.mode === "virtual"));
+}
+chunkPK6SKIKE_cjs.__name(isPowerlinesWriteFileOptions, "isPowerlinesWriteFileOptions");
+function isNodeWriteFileOptions(options) {
+  return !isUndefined.isUndefined(options) && (isBufferEncoding(options) || !isPowerlinesWriteFileOptions(options));
+}
+chunkPK6SKIKE_cjs.__name(isNodeWriteFileOptions, "isNodeWriteFileOptions");
+function isPowerLinesWriteFileData(data) {
+  return !!(isSetObject.isSetObject(data) && "code" in data && data.code);
+}
+chunkPK6SKIKE_cjs.__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;
+}
+chunkPK6SKIKE_cjs.__name(toFilePath, "toFilePath");
+var FS_METHODS = [
+  "mkdir",
+  "mkdirSync",
+  "rmdir",
+  "rmdirSync",
+  "unlink",
+  "unlinkSync",
+  "existsSync",
+  "realpathSync",
+  "writeFileSync",
+  "readFileSync",
+  "readdirSync",
+  "createWriteStream",
+  "WriteStream",
+  "createReadStream",
+  "ReadStream"
+];
+var FS_PROMISE_METHODS = [
+  "mkdir",
+  "rm",
+  "rmdir",
+  "unlink",
+  "writeFile",
+  "readFile",
+  "readdir",
+  "stat",
+  "lstat"
+];
+function cloneFS(originalFS) {
+  const clonedFS = {
+    ...originalFS,
+    promises: {
+      ...originalFS.promises ?? {}
+    }
+  };
+  for (const method of FS_METHODS) {
+    if (originalFS[method]) {
+      clonedFS[method] = originalFS[method];
+    }
+  }
+  originalFS.promises ??= {};
+  for (const method of FS_PROMISE_METHODS) {
+    if (originalFS.promises[method]) {
+      clonedFS.promises ??= {};
+      clonedFS.promises[method] = originalFS.promises[method];
+      clonedFS[method] = originalFS.promises[method];
+    }
+  }
+  for (const prop in clonedFS) {
+    if (isFunction.isFunction(clonedFS[prop])) {
+      clonedFS[prop] = clonedFS[prop].bind(originalFS);
+      if (isFunction.isFunction(clonedFS.promises[prop])) {
+        clonedFS.promises[prop] = clonedFS.promises[prop].bind(originalFS);
+      }
+    }
+  }
+  for (const prop in clonedFS.promises) {
+    if (isFunction.isFunction(clonedFS.promises[prop])) {
+      clonedFS.promises[prop] = clonedFS.promises[prop].bind(originalFS);
+    }
+  }
+  return clonedFS;
+}
+chunkPK6SKIKE_cjs.__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__ */ chunkPK6SKIKE_cjs.__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__ */ chunkPK6SKIKE_cjs.__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__ */ chunkPK6SKIKE_cjs.__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;
+  };
+}
+chunkPK6SKIKE_cjs.__name(patchFS, "patchFS");
 var VirtualFileSystem = class {
   static {
     chunkPK6SKIKE_cjs.__name(this, "VirtualFileSystem");
@@ -168,7 +317,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.
   */
@@ -209,39 +362,88 @@ 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 [chunkXFIGAAKN_cjs.__VFS_CACHE__]() {
+  get [chunkQ2RUDKWY_cjs.__VFS_CACHE__]() {
     return this.#cachedFS;
   }
   /**
   * Exposes the internal VFS resolver cache for advanced usage.
   */
-  get [chunkXFIGAAKN_cjs.__VFS_RESOLVER__]() {
+  get [chunkQ2RUDKWY_cjs.__VFS_RESOLVER__]() {
     return this.#cachedResolver;
   }
   /**
   * Exposes the internal VFS map for advanced usage.
   */
-  get [chunkXFIGAAKN_cjs.__VFS_VIRTUAL__]() {
+  get [chunkQ2RUDKWY_cjs.__VFS_VIRTUAL__]() {
     return this.#virtualFS;
   }
   /**
   * Exposes the internal UFS map for advanced usage.
   */
-  get [chunkXFIGAAKN_cjs.__VFS_UNIFIED__]() {
+  get [chunkQ2RUDKWY_cjs.__VFS_UNIFIED__]() {
     return this.#unifiedFS;
   }
   /**
+  * A proxy to access the underlying file metadata.
+  */
+  get meta() {
+    return new Proxy(this.#meta, {
+      get: /* @__PURE__ */ chunkPK6SKIKE_cjs.__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__ */ chunkPK6SKIKE_cjs.__name((target, prop, value) => {
+        target[prop] = value;
+        this.#ids[value.id || prop] = prop;
+        return true;
+      }, "set"),
+      deleteProperty: /* @__PURE__ */ chunkPK6SKIKE_cjs.__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
@@ -307,13 +509,13 @@ var VirtualFileSystem = class {
     }
     this.#log = chunk632PWWU7_cjs.extendLog(this.#context.log, "virtual-file-system");
   }
-  [chunkXFIGAAKN_cjs.__VFS_INIT__]() {
+  [chunkQ2RUDKWY_cjs.__VFS_INIT__]() {
     if (!this.#isPatched && this.#context.config.output.mode !== "fs") {
       this.#revert = patchFS(fs__default.default, this);
       this.#isPatched = true;
     }
   }
-  [chunkXFIGAAKN_cjs.__VFS_REVERT__]() {
+  [chunkQ2RUDKWY_cjs.__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");
@@ -323,65 +525,44 @@ var VirtualFileSystem = class {
     }
   }
   /**
-  * Returns a Map of all runtime file IDs and their corresponding paths in the virtual file system.
-  *
-  * @returns A Map where the keys are runtime file IDs (strings) and the values are their corresponding paths (strings).
-  */
-  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.
+  * Check if a path or id corresponds to a virtual file **(does not actually exists on disk)**.
   *
-  * @param pathOrId - The path or ID to check.
-  * @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`.
+  * @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)**.
   */
-  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"
-    }));
+    });
+    if (!resolvedPath) {
+      return false;
+    }
+    return this.meta[resolvedPath]?.mode === "virtual";
   }
   /**
-  * Checks if a provided string is a valid runtime ID (does not need to already be created in the file system).
+  * Check if a path or id corresponds to a file written to the file system **(actually exists on disk)**.
   *
-  * @param id - The ID to check.
-  * @returns Whether the ID is a valid runtime ID.
+  * @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)**.
   */
-  isValidBuiltinId(id) {
-    return id.startsWith(`${this.#context.config.output.builtinPrefix}:`);
-  }
-  /**
-  * Check if a path or ID corresponds to a virtual file.
-  *
-  * @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.
-  */
-  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.
@@ -395,37 +576,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.
@@ -442,7 +592,7 @@ var VirtualFileSystem = class {
   */
   unlinkSync(path, options) {
     const formattedPath = toFilePath(path);
-    if (!this.fileExistsSync(path)) {
+    if (!this.isFile(formattedPath)) {
       return;
     }
     this.#log(types.LogLevelLabel.TRACE, `Synchronously removing file: ${formattedPath}`);
@@ -457,7 +607,7 @@ var VirtualFileSystem = class {
   */
   async unlink(path, options) {
     const formattedPath = toFilePath(path);
-    if (!this.fileExistsSync(path)) {
+    if (!this.isFile(formattedPath)) {
       return;
     }
     this.#log(types.LogLevelLabel.TRACE, `Removing file: ${formattedPath}`);
@@ -477,7 +627,7 @@ var VirtualFileSystem = class {
   */
   rmdirSync(path, options = {}) {
     const formattedPath = toFilePath(path);
-    if (!this.directoryExistsSync(path)) {
+    if (!this.isDirectory(formattedPath)) {
       return;
     }
     this.#log(types.LogLevelLabel.TRACE, `Synchronously removing directory: ${formattedPath}`);
@@ -496,7 +646,7 @@ var VirtualFileSystem = class {
   */
   async rmdir(path, options = {}) {
     const formattedPath = toFilePath(path);
-    if (!this.directoryExistsSync(path)) {
+    if (!this.isDirectory(formattedPath)) {
       return;
     }
     this.#log(types.LogLevelLabel.TRACE, `Removing directory: ${formattedPath}`);
@@ -523,7 +673,7 @@ var VirtualFileSystem = class {
   */
   async rm(path, options = {}) {
     this.#log(types.LogLevelLabel.TRACE, `Removing: ${toFilePath(path)}`);
-    if (this.directoryExistsSync(path)) {
+    if (this.isDirectory(path)) {
       return this.rmdir(path, options);
     }
     return this.unlink(path, options);
@@ -567,12 +717,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).
@@ -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) {
@@ -613,7 +763,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) {
@@ -630,137 +780,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(filePathFns.findFilePath(absolutePath))) {
-      await this.mkdir(filePathFns.findFilePath(absolutePath), options);
+  async writeFile(path, data = "", options = "utf8") {
+    const formattedPath = this.formatPath(path);
+    if (!this.isDirectory(filePathFns.findFilePath(formattedPath))) {
+      await this.mkdir(filePathFns.findFilePath(formattedPath), isPowerlinesWriteFileOptions(options) ? options : void 0);
     }
-    this.#log(types.LogLevelLabel.TRACE, `Writing ${absolutePath} file to the ${this.resolveOutputMode(absolutePath, options) === "fs" ? "" : "virtual "}file system (size: ${prettyBytes.prettyBytes(new buffer.Blob(toArray.toArray(data)).size)})`);
-    this.#cachedFS.set(absolutePath, data.toString());
-    this.clearResolverCache(absolutePath);
-    const ifs = this.resolveFS(absolutePath, options);
+    let code = isPowerLinesWriteFileData(data) ? data.code : data;
+    if ((!isPowerlinesWriteFileOptions(options) || !options.skipFormat) && isSetString.isSetString(code)) {
+      const resolvedConfig = await prettier.resolveConfig(formattedPath);
+      if (resolvedConfig) {
+        code = await prettier.format(code, {
+          absolutePath: formattedPath,
+          ...resolvedConfig
+        });
+      }
+    }
+    const outputMode = this.resolveOutputMode(formattedPath, isPowerlinesWriteFileOptions(options) ? options : void 0);
+    this.#log(types.LogLevelLabel.TRACE, `Writing ${formattedPath} file to the ${outputMode === "fs" ? "" : "virtual "}file system (size: ${prettyBytes.prettyBytes(new buffer.Blob(toArray.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.isFunction(ifs.promises.writeFile)) {
-      return ifs.promises.writeFile(absolutePath, data, omit.omit(options, [
-        "mode"
-      ]));
+      return ifs.promises.writeFile(formattedPath, code, isNodeWriteFileOptions(options) ? options : "utf8");
     }
-    return ifs.writeFileSync(absolutePath, data, omit.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(filePathFns.findFilePath(absolutePath))) {
-      this.mkdirSync(filePathFns.findFilePath(absolutePath));
-    }
-    this.#log(types.LogLevelLabel.TRACE, `Writing ${absolutePath} file to the ${this.resolveOutputMode(absolutePath, options) === "fs" ? "" : "virtual "} (size: ${prettyBytes.prettyBytes(new buffer.Blob(toArray.toArray(data)).size)})`);
-    this.#cachedFS.set(absolutePath, data.toString());
-    this.clearResolverCache(absolutePath);
-    const writeStream = this.resolveFS(absolutePath, omit.omit(options, [
-      "mode"
-    ])).createWriteStream(absolutePath);
+  writeFileSync(path, data = "", options = "utf8") {
+    const formattedPath = this.formatPath(path);
+    if (!this.isDirectory(filePathFns.findFilePath(formattedPath))) {
+      this.mkdirSync(filePathFns.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(types.LogLevelLabel.TRACE, `Writing ${formattedPath} file to the ${outputMode === "fs" ? "" : "virtual "}file system (size: ${prettyBytes.prettyBytes(new buffer.Blob(toArray.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 prettier.format(contents, {
-        absolutePath,
-        ...await prettier.resolveConfig(absolutePath)
-      });
-    }
-    const _options = defu3__default.default(isSetString.isSetString(options) ? {} : options ?? {}, {
-      encoding: isSetString.isSetString(options) ? options : "utf8",
-      mode: "virtual"
-    });
-    this.#log(types.LogLevelLabel.DEBUG, `Writing runtime file ${absolutePath} (size: ${prettyBytes.prettyBytes(new buffer.Blob(toArray.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(isType.isAbsolutePath(toFilePath(name)) ? toFilePath(name) : toFilePath(joinPaths.joinPaths(this.#context.entryPath, name)));
-    let data = contents;
-    if (!options.skipFormat) {
-      data = await prettier.format(contents, {
-        absolutePath,
-        ...await prettier.resolveConfig(absolutePath)
-      });
-    }
-    const _options = defu3__default.default(isSetString.isSetString(options) ? {} : options ?? {}, {
-      encoding: isSetString.isSetString(options) ? options : "utf8",
-      mode: "virtual"
-    });
-    this.#log(types.LogLevelLabel.DEBUG, `Writing entry file ${absolutePath} (size: ${prettyBytes.prettyBytes(new buffer.Blob(toArray.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 prettier.resolveConfig(absolutePath);
-      if (resolvedConfig) {
-        data = await prettier.format(contents, {
-          absolutePath,
-          ...resolvedConfig
-        });
-      }
-    }
-    return this.writeFile(absolutePath, data, defu3__default.default({
-      mode: "fs"
-    }, isSetString.isSetString(options) ? {} : options ?? {}, {
-      encoding: isSetString.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).
@@ -768,32 +861,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).
@@ -802,7 +885,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).
@@ -811,7 +894,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).
@@ -820,7 +903,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).
@@ -829,23 +912,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.
@@ -858,9 +925,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.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.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.joinPaths(this.#context.workspaceConfig.workspaceRoot, resolvedPath.replaceAll("*", ""), path.replace(tsconfigPathKey.replaceAll("*", ""), "")));
+          return this.formatPath(resolvedPath) === this.formatPath(path) ? this.formatPath(resolvedPath) : this.resolvePath(joinPaths.joinPaths(this.#context.workspaceConfig.workspaceRoot, resolvedPath.replaceAll("*", ""), path.replace(tsconfigPathKey.replaceAll("*", ""), "")));
         }
       }
     }
@@ -890,7 +957,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)}`);
     }
@@ -903,24 +970,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.murmurhash(options.paths)}` : ""}${options.type ? `-${options.type}` : ""}`;
+  resolve(pathOrId, options = {}) {
+    const formattedPathOrId = toFilePath(pathOrId);
+    const resolverKey = `${formattedPathOrId}${options.withExtension ? "-ext" : ""}${options.paths ? `-${murmurhash.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?$/, "");
@@ -929,16 +990,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.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.isSetObject(data)));
   }
   /**
   * Converts a relative path to an absolute path based on the workspace and project root.
@@ -946,56 +1003,67 @@ var VirtualFileSystem = class {
   * @param path - The relative path to convert.
   * @returns The absolute path.
   */
-  formatAbsoluteFilePath = /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((path) => {
-    const formattedPath = this.formatFilePath(path);
+  formatPath(path) {
+    const formattedPath = toFilePath(path);
     if (isType.isAbsolutePath(formattedPath) || formattedPath.startsWith(this.#context.workspaceConfig.workspaceRoot)) {
       return formattedPath;
     } else if (formattedPath.startsWith(this.#context.config.projectRoot)) {
       return joinPaths.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(filePathFns.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 (isType.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 (isType.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.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.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.joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.projectRoot)
@@ -1013,7 +1081,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.
@@ -1044,7 +1112,7 @@ var VirtualFileSystem = class {
     } else if (options.mode === "fs" || this.#context.config.output.mode === "fs" || isParentPath.isParentPath(toFilePath(pathOrUrl), this.#context.dataPath) || isParentPath.isParentPath(toFilePath(pathOrUrl), this.#context.cachePath) || isParentPath.isParentPath(toFilePath(pathOrUrl), joinPaths.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.
@@ -1054,208 +1122,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;
-}
-chunkPK6SKIKE_cjs.__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.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.joinPaths(request, "index");
+    if (this.#existsSync(file)) {
+      return file;
     }
-  }
-  for (const prop in clonedFS) {
-    if (isFunction.isFunction(clonedFS[prop])) {
-      clonedFS[prop] = clonedFS[prop].bind(originalFS);
-      if (isFunction.isFunction(clonedFS.promises[prop])) {
-        clonedFS.promises[prop] = clonedFS.promises[prop].bind(originalFS);
-      }
+    file = this.checkExtensions(file);
+    if (file) {
+      return file;
     }
+    return false;
   }
-  for (const prop in clonedFS.promises) {
-    if (isFunction.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;
-}
-chunkPK6SKIKE_cjs.__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__ */ chunkPK6SKIKE_cjs.__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__ */ chunkPK6SKIKE_cjs.__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__ */ chunkPK6SKIKE_cjs.__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;
-  };
-}
-chunkPK6SKIKE_cjs.__name(patchFS, "patchFS");
-function checkVariants(request, vfs, parentPath) {
-  const path = parentPath ? joinPaths.joinPaths(parentPath, request) : request;
-  let file = checkExtensions(path, vfs);
-  if (file) {
-    return file;
-  }
-  file = checkIndex(path, vfs);
-  if (file) {
-    return file;
-  }
-  return false;
-}
-chunkPK6SKIKE_cjs.__name(checkVariants, "checkVariants");
-function checkIndex(request, vfs) {
-  let file = joinPaths.joinPaths(request, "index");
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  file = checkExtensions(file, vfs);
-  if (file) {
-    return file;
-  }
-  return false;
-}
-chunkPK6SKIKE_cjs.__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;
-}
-chunkPK6SKIKE_cjs.__name(checkExtensions, "checkExtensions");
+};
 function createVfs(context) {
   const vfs = new VirtualFileSystem(context);
   return vfs;
@@ -1400,10 +1353,10 @@ var PowerlinesContext = class _PowerlinesContext {
         workspaceRoot: this.workspaceConfig?.workspaceRoot,
         projectRoot: this.config?.projectRoot
       }, {
-        maxLength: chunkXFIGAAKN_cjs.PROJECT_ROOT_HASH_LENGTH
+        maxLength: chunkQ2RUDKWY_cjs.PROJECT_ROOT_HASH_LENGTH
       }),
       configHash: murmurhash.murmurhash(this.config, {
-        maxLength: chunkXFIGAAKN_cjs.CACHE_HASH_LENGTH
+        maxLength: chunkQ2RUDKWY_cjs.CACHE_HASH_LENGTH
       }),
       builtinIdMap: {},
       virtualFiles: {}
@@ -1465,7 +1418,7 @@ var PowerlinesContext = class _PowerlinesContext {
   * Get the path to the data directory for the project
   */
   get dataPath() {
-    return join.joinPaths(this.envPaths.data, "projects", chunkXFIGAAKN_cjs.getPrefixedProjectRootHash(this.config.name, this.meta.projectRootHash));
+    return join.joinPaths(this.envPaths.data, "projects", chunkQ2RUDKWY_cjs.getPrefixedProjectRootHash(this.config.name, this.meta.projectRootHash));
   }
   /**
   * Get the path to the cache directory for the project
@@ -1475,7 +1428,7 @@ var PowerlinesContext = class _PowerlinesContext {
       checksum: this.#checksum,
       config: this.meta.configHash
     }, {
-      maxLength: chunkXFIGAAKN_cjs.CACHE_HASH_LENGTH
+      maxLength: chunkQ2RUDKWY_cjs.CACHE_HASH_LENGTH
     }));
   }
   /**
@@ -1491,6 +1444,57 @@ var PowerlinesContext = class _PowerlinesContext {
     return getWorkspaceRoot.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(isType.isAbsolute(path) ? path : append.appendPath(path, this.entryPath), {
+      code,
+      variant: "entry"
+    }, defu3__default.default(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 ? isType.isAbsolute(path) ? path : join.joinPaths(this.builtinsPath, path) : append.appendPath(id, this.builtinsPath), {
+      id,
+      code,
+      variant: "builtin"
+    }, defu3__default.default(options, {
+      mode: this.config.output.mode
+    }));
+  }
+  /**
   * Parses the source code and returns a {@link ParseResult} object.
   *
   * @param code - The source code to parse.
@@ -1628,7 +1632,7 @@ ${result.errors.map((error) => `  [${error.severity}] ${error.message}${error.co
       if (exists.existsSync(packageJsonPath)) {
         this.packageJson = await json.readJsonFile(packageJsonPath);
       }
-      this.#checksum = await chunkXFIGAAKN_cjs.getChecksum(cacheKey.projectRoot);
+      this.#checksum = await chunkQ2RUDKWY_cjs.getChecksum(cacheKey.projectRoot);
       this.resolver = createResolver({
         workspaceRoot: this.workspaceConfig.workspaceRoot,
         projectRoot: cacheKey.projectRoot,
@@ -2097,7 +2101,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__namespace.stringLiteral(
       // Remove the file extension if it exists
@@ -2198,8 +2202,9 @@ var moduleResolverBabelPlugin = /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((contex
 async function generateTypes(context) {
   context.log(types.LogLevelLabel.TRACE, `Preparing the TypeScript definitions for the Powerlines project.`);
   context.log(types.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 core.transformAsync(file.contents, {
+  const builtinFiles = await context.getBuiltins();
+  const builtinFilePaths = await Promise.all(builtinFiles.map(async (file) => {
+    const result = await core.transformAsync(file.code.toString(), {
       highlightCode: true,
       code: true,
       ast: false,
@@ -2227,14 +2232,14 @@ async function generateTypes(context) {
       throw new Error(`Powerlines - Generate Types failed to compile ${file.id}`);
     }
     context.log(types.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 resolve.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 = replace.replacePath(fileName, context.workspaceConfig.workspaceRoot);
     if (!ret.includes(formatted)) {
       ret.push(formatted);
@@ -2269,9 +2274,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, "")}
 }
 `;
@@ -2297,7 +2302,7 @@ declare module "${context.fs.resolveId(sourceFile2.fileName)}" {
 ${diagnosticMessage.length > 5e3 ? `${diagnosticMessage.slice(0, 5e3)}...` : diagnosticMessage}`);
   }
   context.log(types.LogLevelLabel.TRACE, `Generating TypeScript declaration file in ${context.config.output.dts}.`);
-  const sourceFile = chunk65DUUIIF_cjs.getSourceFile(String(context.config.output.dts), `/// <reference types="powerlines/shared" />${context.config.build.platform !== "neutral" ? `
+  const sourceFile = chunkUQJWVRRE_cjs.getSourceFile(String(context.config.output.dts), `/// <reference types="powerlines/shared" />${context.config.build.platform !== "neutral" ? `
 /// <reference types="powerlines/${context.config.build.platform}" />` : ""}
 
 ${chunkMFC7UJHT_cjs.getFileHeader(context, {
@@ -2310,7 +2315,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, chunk65DUUIIF_cjs.getString(sourceFile.code));
+  await context.fs.writeFile(sourceFile.id, chunkUQJWVRRE_cjs.getString(sourceFile.code), {
+    mode: "fs"
+  });
 }
 chunkPK6SKIKE_cjs.__name(generateTypes, "generateTypes");
 async function installPackage(context, packageName, dev = false) {
@@ -2474,7 +2481,9 @@ async function initializeTsconfig(context) {
   const tsconfigFilePath = chunkLJZEN4HP_cjs.getTsconfigFilePath(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
   context.tsconfig.originalTsconfigJson = await json.readJsonFile(tsconfigFilePath);
   context.tsconfig.tsconfigJson = await resolveTsconfigChanges(context);
-  await context.fs.writeFileToDisk(tsconfigFilePath, stormJson.StormJSON.stringify(context.tsconfig.tsconfigJson));
+  await context.fs.writeFile(tsconfigFilePath, stormJson.StormJSON.stringify(context.tsconfig.tsconfigJson), {
+    mode: "fs"
+  });
   context.tsconfig = chunkLJZEN4HP_cjs.getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig, context.config.tsconfigRaw, context.tsconfig.originalTsconfigJson);
 }
 chunkPK6SKIKE_cjs.__name(initializeTsconfig, "initializeTsconfig");
@@ -2523,7 +2532,7 @@ async function resolveTsconfig(context) {
   `).join("\n")}
     `);
   }
-  await chunkTZFBE35T_cjs.writeFile(context.log, context.tsconfig.tsconfigFilePath, stormJson.StormJSON.stringify(updateTsconfigJson));
+  await chunkRQICHHZM_cjs.writeFile(context.log, context.tsconfig.tsconfigFilePath, stormJson.StormJSON.stringify(updateTsconfigJson));
   context.tsconfig = chunkLJZEN4HP_cjs.getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
   if (!context.tsconfig) {
     throw new Error("Failed to parse the TypeScript configuration file.");
@@ -2598,8 +2607,8 @@ ${context.entry.map((entry) => `- ${entry.input.file || entry.file}${entry.outpu
       context.log(types.LogLevelLabel.TRACE, `Powerlines configuration has been resolved: 
 
 ${console.formatLogMessage(context.config)}`);
-      context.fs[chunkXFIGAAKN_cjs.__VFS_INIT__]();
-      await chunkXFIGAAKN_cjs.writeMetaFile(context);
+      context.fs[chunkQ2RUDKWY_cjs.__VFS_INIT__]();
+      await chunkQ2RUDKWY_cjs.writeMetaFile(context);
       context.persistedMeta = context.meta;
       if (!exists.existsSync(context.cachePath)) {
         await helpers.createDirectory(context.cachePath);
@@ -2610,11 +2619,6 @@ ${console.formatLogMessage(context.config)}`);
       await this.callPreHook(context, "prepare");
       if (context.config.projectType === "application") {
         context.log(types.LogLevelLabel.TRACE, "Generating built-in barrel file");
-        await context.fs.writeBuiltinFile("index", joinPaths.joinPaths(context.builtinsPath, "index.ts"), `
-  ${chunkMFC7UJHT_cjs.getFileHeader(context)}
-
-  ${(await context.fs.listBuiltinFiles()).filter((file) => !isParentPath.isParentPath(file.path, joinPaths.joinPaths(context.builtinsPath, "log")) && !isParentPath.isParentPath(file.path, joinPaths.joinPaths(context.builtinsPath, "storage"))).map((file) => `export * from "./${replace.replacePath(file.path, context.builtinsPath).replace(`.${filePathFns.findFileExtensionSafe(file.path)}`, "")}";`).join("\n")}
-  `);
       }
       if (context.config.output.dts !== false) {
         await generateTypes(context);
@@ -2625,8 +2629,8 @@ ${console.formatLogMessage(context.config)}`);
         throw new Error("Failed to parse the TypeScript configuration file.");
       }
       await this.callPostHook(context, "prepare");
-      await chunkXFIGAAKN_cjs.writeMetaFile(context);
-      context.fs[chunkXFIGAAKN_cjs.__VFS_REVERT__]();
+      await chunkQ2RUDKWY_cjs.writeMetaFile(context);
+      context.fs[chunkQ2RUDKWY_cjs.__VFS_REVERT__]();
     });
     this.context.log(types.LogLevelLabel.INFO, "Powerlines API has been prepared successfully");
   }
@@ -2649,7 +2653,7 @@ ${console.formatLogMessage(context.config)}`);
       for (const file of files) {
         context.log(types.LogLevelLabel.TRACE, `Adding template file: ${file}`);
         const template = Handlebars__default.default.compile(file);
-        await chunkTZFBE35T_cjs.writeFile(context.log, joinPaths.joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
+        await chunkRQICHHZM_cjs.writeFile(context.log, joinPaths.joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
       }
       await this.callNormalHook(context, "new");
       if (context.config.projectType === "application") {
@@ -2657,14 +2661,14 @@ ${console.formatLogMessage(context.config)}`);
         for (const file of files2) {
           context.log(types.LogLevelLabel.TRACE, `Adding application template file: ${file}`);
           const template = Handlebars__default.default.compile(file);
-          await chunkTZFBE35T_cjs.writeFile(context.log, joinPaths.joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
+          await chunkRQICHHZM_cjs.writeFile(context.log, joinPaths.joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
         }
       } else {
         const files2 = await listFiles.listFiles(joinPaths.joinPaths(context.powerlinesPath, "files/library/**/*.hbs"));
         for (const file of files2) {
           context.log(types.LogLevelLabel.TRACE, `Adding library template file: ${file}`);
           const template = Handlebars__default.default.compile(file);
-          await chunkTZFBE35T_cjs.writeFile(context.log, joinPaths.joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
+          await chunkRQICHHZM_cjs.writeFile(context.log, joinPaths.joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
         }
       }
       await this.callPostHook(context, "new");
@@ -2785,7 +2789,7 @@ ${console.formatLogMessage(context.config)}`);
     this.context.log(types.LogLevelLabel.TRACE, "Powerlines finalize execution started");
     await this.#executeEnvironments(async (context) => {
       await this.callHook(context, "finalize");
-      context.fs[chunkXFIGAAKN_cjs.__VFS_REVERT__]();
+      context.fs[chunkQ2RUDKWY_cjs.__VFS_REVERT__]();
     });
     this.context.log(types.LogLevelLabel.TRACE, "Powerlines finalize execution completed");
   }
@@ -3073,7 +3077,7 @@ function createUnpluginFactory(variant, decorate) {
       async function resolveId(id, importer, options = {
         isEntry: false
       }) {
-        return chunkVRNWPH35_cjs.handleResolveId(api.context, {
+        return chunk7EAV6Q7B_cjs.handleResolveId(api.context, {
           id,
           importer,
           options
@@ -3088,9 +3092,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);
           }
@@ -3109,15 +3111,15 @@ function createUnpluginFactory(variant, decorate) {
       async function transform(code, id) {
         const environment = await api.context.getEnvironment();
         let transformed = code;
-        let result2 = await api.callPreHook(environment, "transform", chunk65DUUIIF_cjs.getString(transformed), id);
+        let result2 = await api.callPreHook(environment, "transform", chunkUQJWVRRE_cjs.getString(transformed), id);
         if (result2) {
           transformed = result2;
         }
-        result2 = await api.callNormalHook(environment, "transform", chunk65DUUIIF_cjs.getString(transformed), id);
+        result2 = await api.callNormalHook(environment, "transform", chunkUQJWVRRE_cjs.getString(transformed), id);
         if (result2) {
           transformed = result2;
         }
-        result2 = await api.callPostHook(environment, "transform", chunk65DUUIIF_cjs.getString(transformed), id);
+        result2 = await api.callPostHook(environment, "transform", chunkUQJWVRRE_cjs.getString(transformed), id);
         if (result2) {
           transformed = result2;
         }
@@ -3167,5 +3169,5 @@ function createUnpluginFactory(variant, decorate) {
 chunkPK6SKIKE_cjs.__name(createUnpluginFactory, "createUnpluginFactory");
 
 exports.createUnpluginFactory = createUnpluginFactory;
-//# sourceMappingURL=chunk-2D74QBNW.cjs.map
-//# sourceMappingURL=chunk-2D74QBNW.cjs.map
+//# sourceMappingURL=chunk-M7WHFUKR.cjs.map
+//# sourceMappingURL=chunk-M7WHFUKR.cjs.map