powerlines 0.24.8 → 0.25.0

package/dist/lib/chunk-OBA5U4Y2.js

@@ -0,0 +1,1059 @@
+import { FileSystemStorageAdapter } from './chunk-L56XA427.js';
+import { VirtualStorageAdapter } from './chunk-ONETLSPO.js';
+import { normalizeId, normalizePath, normalizeKey, filterKeyByBase } from './chunk-KFDNKOXM.js';
+import { extendLog } from './chunk-ENRLU4UR.js';
+import { __name } from './chunk-SHUYVCID.js';
+import { LogLevelLabel } from '@storm-software/config-tools/types';
+import * as $ from '@stryke/capnp';
+import { toArray } from '@stryke/convert/to-array';
+import { readFileBuffer, readFileBufferSync, writeFileBuffer } from '@stryke/fs/buffer';
+import { existsSync } from '@stryke/fs/exists';
+import { getResolutionCombinations, resolve, resolveSync } from '@stryke/fs/resolve';
+import { appendPath } from '@stryke/path/append';
+import { toAbsolutePath } from '@stryke/path/correct-path';
+import { hasFileExtension, findFilePath, findFileName } from '@stryke/path/file-path-fns';
+import { isParentPath } from '@stryke/path/is-parent-path';
+import { isAbsolutePath } from '@stryke/path/is-type';
+import { joinPaths } from '@stryke/path/join-paths';
+import { replacePath } from '@stryke/path/replace';
+import { prettyBytes } from '@stryke/string-format/pretty-bytes';
+import { isSetObject } from '@stryke/type-checks/is-set-object';
+import { create } from 'flat-cache';
+import { Blob } from 'node:buffer';
+import { resolveConfig, format } from 'prettier';
+
+BigInt("0xa56c61324b9d6e49");
+var FileMetadata_KeyValuePair = class extends $.Struct {
+  static {
+    __name(this, "FileMetadata_KeyValuePair");
+  }
+  static _capnp = {
+    displayName: "KeyValuePair",
+    id: "eabb26cf58b2a14c",
+    size: new $.ObjectSize(0, 2)
+  };
+  get key() {
+    return $.utils.getText(0, this);
+  }
+  set key(value) {
+    $.utils.setText(0, value, this);
+  }
+  get value() {
+    return $.utils.getText(1, this);
+  }
+  set value(value) {
+    $.utils.setText(1, value, this);
+  }
+  toString() {
+    return "FileMetadata_KeyValuePair_" + super.toString();
+  }
+};
+var FileMetadata = class _FileMetadata extends $.Struct {
+  static {
+    __name(this, "FileMetadata");
+  }
+  static KeyValuePair = FileMetadata_KeyValuePair;
+  static _capnp = {
+    displayName: "FileMetadata",
+    id: "8e2cab5d7e28c7b3",
+    size: new $.ObjectSize(8, 3),
+    defaultType: "normal"
+  };
+  static _Properties;
+  /**
+  * The type of the file.
+  *
+  */
+  get id() {
+    return $.utils.getText(0, this);
+  }
+  set id(value) {
+    $.utils.setText(0, value, this);
+  }
+  /**
+  * The timestamp representing the file's creation date.
+  *
+  */
+  get type() {
+    return $.utils.getText(1, this, _FileMetadata._capnp.defaultType);
+  }
+  set type(value) {
+    $.utils.setText(1, value, this);
+  }
+  /**
+  * Additional metadata associated with the file.
+  *
+  */
+  get timestamp() {
+    return $.utils.getUint32(0, this);
+  }
+  set timestamp(value) {
+    $.utils.setUint32(0, value, this);
+  }
+  _adoptProperties(value) {
+    $.utils.adopt(value, $.utils.getPointer(2, this));
+  }
+  _disownProperties() {
+    return $.utils.disown(this.properties);
+  }
+  get properties() {
+    return $.utils.getList(2, _FileMetadata._Properties, this);
+  }
+  _hasProperties() {
+    return !$.utils.isNull($.utils.getPointer(2, this));
+  }
+  _initProperties(length) {
+    return $.utils.initList(2, _FileMetadata._Properties, length, this);
+  }
+  set properties(value) {
+    $.utils.copyFrom(value, $.utils.getPointer(2, this));
+  }
+  toString() {
+    return "FileMetadata_" + super.toString();
+  }
+};
+var FileId = class extends $.Struct {
+  static {
+    __name(this, "FileId");
+  }
+  static _capnp = {
+    displayName: "FileId",
+    id: "990d6a471072f997",
+    size: new $.ObjectSize(0, 2)
+  };
+  /**
+  * A virtual (or actual) path to the file in the file system.
+  *
+  */
+  get id() {
+    return $.utils.getText(0, this);
+  }
+  set id(value) {
+    $.utils.setText(0, value, this);
+  }
+  get path() {
+    return $.utils.getText(1, this);
+  }
+  set path(value) {
+    $.utils.setText(1, value, this);
+  }
+  toString() {
+    return "FileId_" + super.toString();
+  }
+};
+var FileStorage = class extends $.Struct {
+  static {
+    __name(this, "FileStorage");
+  }
+  static _capnp = {
+    displayName: "FileStorage",
+    id: "9dca66ac858c9ebe",
+    size: new $.ObjectSize(0, 2)
+  };
+  /**
+  * A virtual (or actual) path to the file in the file system.
+  *
+  */
+  get path() {
+    return $.utils.getText(0, this);
+  }
+  set path(value) {
+    $.utils.setText(0, value, this);
+  }
+  get code() {
+    return $.utils.getText(1, this);
+  }
+  set code(value) {
+    $.utils.setText(1, value, this);
+  }
+  toString() {
+    return "FileStorage_" + super.toString();
+  }
+};
+var FileSystem = class _FileSystem extends $.Struct {
+  static {
+    __name(this, "FileSystem");
+  }
+  static _capnp = {
+    displayName: "FileSystem",
+    id: "ae0c23d43e56abcf",
+    size: new $.ObjectSize(0, 3)
+  };
+  static _Ids;
+  static _Storage;
+  static _Metadata;
+  _adoptIds(value) {
+    $.utils.adopt(value, $.utils.getPointer(0, this));
+  }
+  _disownIds() {
+    return $.utils.disown(this.ids);
+  }
+  get ids() {
+    return $.utils.getList(0, _FileSystem._Ids, this);
+  }
+  _hasIds() {
+    return !$.utils.isNull($.utils.getPointer(0, this));
+  }
+  _initIds(length) {
+    return $.utils.initList(0, _FileSystem._Ids, length, this);
+  }
+  set ids(value) {
+    $.utils.copyFrom(value, $.utils.getPointer(0, this));
+  }
+  _adoptStorage(value) {
+    $.utils.adopt(value, $.utils.getPointer(1, this));
+  }
+  _disownStorage() {
+    return $.utils.disown(this.storage);
+  }
+  get storage() {
+    return $.utils.getList(1, _FileSystem._Storage, this);
+  }
+  _hasStorage() {
+    return !$.utils.isNull($.utils.getPointer(1, this));
+  }
+  _initStorage(length) {
+    return $.utils.initList(1, _FileSystem._Storage, length, this);
+  }
+  set storage(value) {
+    $.utils.copyFrom(value, $.utils.getPointer(1, this));
+  }
+  _adoptMetadata(value) {
+    $.utils.adopt(value, $.utils.getPointer(2, this));
+  }
+  _disownMetadata() {
+    return $.utils.disown(this.metadata);
+  }
+  get metadata() {
+    return $.utils.getList(2, _FileSystem._Metadata, this);
+  }
+  _hasMetadata() {
+    return !$.utils.isNull($.utils.getPointer(2, this));
+  }
+  _initMetadata(length) {
+    return $.utils.initList(2, _FileSystem._Metadata, length, this);
+  }
+  set metadata(value) {
+    $.utils.copyFrom(value, $.utils.getPointer(2, this));
+  }
+  toString() {
+    return "FileSystem_" + super.toString();
+  }
+};
+FileMetadata._Properties = $.CompositeList(FileMetadata_KeyValuePair);
+FileSystem._Ids = $.CompositeList(FileId);
+FileSystem._Storage = $.CompositeList(FileStorage);
+FileSystem._Metadata = $.CompositeList(FileMetadata);
+
+// src/types/fs.ts
+var StoragePreset = /* @__PURE__ */ (function(StoragePreset2) {
+  StoragePreset2["VIRTUAL"] = "virtual";
+  StoragePreset2["FS"] = "fs";
+  return StoragePreset2;
+})({});
+
+// src/lib/fs/vfs.ts
+var VirtualFileSystem = class _VirtualFileSystem {
+  static {
+    __name(this, "VirtualFileSystem");
+  }
+  /**
+  * A map of virtual file IDs to their associated metadata.
+  */
+  #metadata;
+  /**
+  * A map of virtual file IDs to their underlying file paths.
+  */
+  #ids;
+  /**
+  * A map of underlying file paths to their virtual file IDs.
+  */
+  #paths;
+  /**
+  * The unified volume that combines the virtual file system with the real file system.
+  *
+  * @remarks
+  * This volume allows for seamless access to both virtual and real files.
+  */
+  #storage = {
+    "": new FileSystemStorageAdapter()
+  };
+  /**
+  * A cache for module resolution results.
+  */
+  #resolverCache;
+  /**
+  * Indicator specifying if the virtual file system (VFS) is disposed
+  */
+  #isDisposed = false;
+  /**
+  * The context of the virtual file system.
+  */
+  #context;
+  /**
+  * The file system's logging function.
+  */
+  #log;
+  /**
+  * Normalizes a given module id by resolving it against the built-ins path.
+  *
+  * @param id - The module id to normalize.
+  * @returns The normalized module id.
+  */
+  #normalizeId(id) {
+    return normalizeId(id, this.#context.config.output.builtinPrefix);
+  }
+  /**
+  * Normalizes a given path by resolving it against the project root, workspace root, and built-ins path.
+  *
+  * @param path - The path to normalize.
+  * @returns The normalized path.
+  */
+  #normalizePath(path) {
+    return normalizePath(path, this.#context.builtinsPath, this.#context.config.output.builtinPrefix);
+  }
+  /**
+  * Builds a regular expression from a string pattern for path matching.
+  *
+  * @param path - The string pattern to convert.
+  * @returns A regular expression for matching paths.
+  */
+  #buildRegex(path) {
+    const token = "::GLOBSTAR::";
+    return new RegExp(`^${this.#normalizePath(path).replace(/\*\*/g, token).replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(new RegExp(token, "g"), ".*")}$`);
+  }
+  /**
+  * Gets the storage adapter and relative key for a given key.
+  *
+  * @param key - The key to get the storage adapter for.
+  * @returns The storage adapter and relative key for the given key.
+  */
+  #getStorage(key) {
+    const path = this.resolveSync(this.#normalizePath(key)) || key;
+    for (const base of Object.keys(this.#storage).filter(Boolean).sort().reverse()) {
+      if (isParentPath(path, base)) {
+        return {
+          base,
+          relativeKey: replacePath(path, base),
+          adapter: this.#storage[base]
+        };
+      }
+    }
+    return {
+      base: "",
+      relativeKey: path,
+      adapter: this.#storage[""]
+    };
+  }
+  /**
+  * Gets all storage adapters that match a given base key.
+  *
+  * @param base - The base key to match storage adapters against.
+  * @param includeParent - Whether to include parent storage adapters.
+  * @returns An array of storage adapters that match the given base key.
+  */
+  #getStorages(base = "", includeParent = false) {
+    return Object.keys(this.#storage).sort().reverse().filter((key) => isParentPath(key, base) || includeParent && isParentPath(base, key)).map((key) => ({
+      relativeBase: base.length > key.length ? base.slice(key.length) : void 0,
+      base: key,
+      adapter: this.#storage[key]
+    }));
+  }
+  /**
+  * Creates a virtual file system (VFS) that is backed up to a Cap'n Proto message buffer.
+  *
+  * @param context - The context of the virtual file system, typically containing options and logging functions.
+  * @returns A promise that resolves to a new virtual file system instance.
+  */
+  static async create(context) {
+    if (!context.config.skipCache && existsSync(joinPaths(context.dataPath, "fs.bin"))) {
+      const buffer = await readFileBuffer(joinPaths(context.dataPath, "fs.bin"));
+      const message2 = new $.Message(buffer, false);
+      const fs = message2.getRoot(FileSystem);
+      const result = new _VirtualFileSystem(context, fs);
+      if (fs._hasStorage() && fs.storage.length > 0) {
+        await Promise.all(fs.storage.values().map(async (file) => {
+          await result.write(file.path, file.code);
+        }));
+      }
+    }
+    const message = new $.Message();
+    return new _VirtualFileSystem(context, message.initRoot(FileSystem));
+  }
+  /**
+  * Synchronously creates a virtual file system (VFS) that is backed up to a Cap'n Proto message buffer.
+  *
+  * @param context - The context of the virtual file system, typically containing options and logging functions.
+  * @returns A new virtual file system instance.
+  */
+  static createSync(context) {
+    if (!context.config.skipCache && existsSync(joinPaths(context.dataPath, "fs.bin"))) {
+      const buffer = readFileBufferSync(joinPaths(context.dataPath, "fs.bin"));
+      const message2 = new $.Message(buffer, false);
+      const fs = message2.getRoot(FileSystem);
+      const result = new _VirtualFileSystem(context, fs);
+      if (fs._hasStorage() && fs.storage.length > 0) {
+        fs.storage.values().map((file) => {
+          result.writeSync(file.path, file.code);
+        });
+      }
+    }
+    const message = new $.Message();
+    return new _VirtualFileSystem(context, message.initRoot(FileSystem));
+  }
+  /**
+  * A map of file ids to their metadata.
+  */
+  get metadata() {
+    return new Proxy(this.#metadata, {
+      get: /* @__PURE__ */ __name((target, prop) => {
+        return target[this.#normalizeId(prop)];
+      }, "get")
+    });
+  }
+  /**
+  * A map of file paths to their module ids.
+  */
+  get ids() {
+    return new Proxy(this.#paths, {
+      get: /* @__PURE__ */ __name((target, prop) => {
+        return target[this.#normalizePath(prop)];
+      }, "get")
+    });
+  }
+  /**
+  * A map of module ids to their file paths.
+  */
+  get paths() {
+    return new Proxy(this.#paths, {
+      get: /* @__PURE__ */ __name((target, prop) => {
+        return target[this.#normalizeId(prop)];
+      }, "get")
+    });
+  }
+  /**
+  * Gets the resolver cache.
+  */
+  get resolverCache() {
+    if (!this.#resolverCache) {
+      this.#resolverCache = create({
+        cacheId: "module-resolution",
+        cacheDir: this.#context.cachePath,
+        ttl: 60 * 60 * 1e3,
+        lruSize: 5e3,
+        persistInterval: 100
+      });
+    }
+    return this.#resolverCache;
+  }
+  /**
+  * Creates a new instance of the {@link VirtualFileSystem}.
+  *
+  * @param context - The context of the virtual file system, typically containing options and logging functions.
+  * @param fs - A buffer containing the serialized virtual file system data.
+  */
+  constructor(context, fs) {
+    this.#context = context;
+    if (isSetObject(this.#context.config.output.storage)) {
+      this.#storage = {
+        ...this.#storage,
+        ...this.#context.config.output.storage
+      };
+    }
+    this.#storage.virtual ??= new VirtualStorageAdapter({
+      base: "/_virtual"
+    });
+    if (this.#context.config.output.storage !== StoragePreset.FS) {
+      this.#storage[this.#context.artifactsPath] ??= new VirtualStorageAdapter({
+        base: this.#context.artifactsPath
+      });
+      this.#storage[this.#context.builtinsPath] ??= new VirtualStorageAdapter({
+        base: this.#context.builtinsPath
+      });
+      this.#storage[this.#context.entryPath] ??= new VirtualStorageAdapter({
+        base: this.#context.entryPath
+      });
+    }
+    this.#metadata = {};
+    if (fs._hasMetadata()) {
+      this.#metadata = fs.metadata.values().reduce((ret, metadata) => {
+        ret[metadata.id] = {
+          id: metadata.id,
+          type: metadata.type,
+          timestamp: metadata.timestamp || Date.now(),
+          properties: metadata._hasProperties() ? metadata.properties.values().reduce((ret2, item) => {
+            ret2[item.key] = item.value;
+            return ret2;
+          }, {}) : {}
+        };
+        return ret;
+      }, {});
+    }
+    this.#ids = {};
+    this.#paths = {};
+    if (fs._hasIds()) {
+      this.#ids = fs.ids.values().reduce((ret, identifier) => {
+        ret[identifier.path] ??= identifier.id;
+        return ret;
+      }, {});
+      this.#paths = fs.ids.values().reduce((ret, identifier) => {
+        ret[identifier.id] ??= identifier.path;
+        return ret;
+      }, {});
+    }
+    this.#log = extendLog(this.#context.log, "file-system");
+  }
+  /**
+  * Asynchronously checks if a file exists in the virtual file system (VFS).
+  *
+  * @param path - The path to the file.
+  * @returns A promise that resolves to `true` if the file exists, otherwise `false`.
+  */
+  async exists(path) {
+    const { relativeKey, adapter } = this.#getStorage(path);
+    return adapter.exists(relativeKey);
+  }
+  /**
+  * Synchronously checks if a file exists in the virtual file system (VFS).
+  *
+  * @param path - The path to the file.
+  * @returns `true` if the file exists, otherwise `false`.
+  */
+  existsSync(path) {
+    const { relativeKey, adapter } = this.#getStorage(path);
+    return adapter.existsSync(relativeKey);
+  }
+  /**
+  * Checks if a file is virtual in the virtual file system (VFS).
+  *
+  * @param path - The path to the file.
+  * @returns `true` if the file is virtual, otherwise `false`.
+  */
+  isVirtual(path) {
+    const resolved = this.resolveSync(path);
+    if (!resolved) {
+      return false;
+    }
+    return this.#getStorage(resolved)?.adapter?.name === "virtual";
+  }
+  /**
+  * Lists files in a given path.
+  *
+  * @param path - The path to list files from.
+  * @returns An array of file names in the specified path.
+  */
+  listSync(path) {
+    let maskedMounts = [];
+    const allKeys = [];
+    for (const storage of this.#getStorages(path, true)) {
+      for (const key of storage.adapter.listSync(storage.relativeBase)) {
+        if (!maskedMounts.some((p) => `${storage.base}${normalizeKey(key)}`.startsWith(p))) {
+          allKeys.push(`${storage.base}${normalizeKey(key)}`);
+        }
+      }
+      maskedMounts = [
+        storage.base,
+        ...maskedMounts.filter((p) => !p.startsWith(storage.base))
+      ];
+    }
+    return allKeys.filter((key) => filterKeyByBase(key, path));
+  }
+  /**
+  * Lists files in a given path.
+  *
+  * @param path - The path to list files from.
+  * @returns An array of file names in the specified path.
+  */
+  async list(path) {
+    let maskedMounts = [];
+    const allKeys = [];
+    for (const storage of this.#getStorages(path, true)) {
+      for (const key of await storage.adapter.list(storage.relativeBase)) {
+        if (!maskedMounts.some((p) => `${storage.base}${normalizeKey(key)}`.startsWith(p))) {
+          allKeys.push(`${storage.base}${normalizeKey(key)}`);
+        }
+      }
+      maskedMounts = [
+        storage.base,
+        ...maskedMounts.filter((p) => !p.startsWith(storage.base))
+      ];
+    }
+    return allKeys.filter((key) => filterKeyByBase(key, path));
+  }
+  /**
+  * Removes a file in the virtual file system (VFS).
+  *
+  * @param path - The path to create the directory at.
+  */
+  async remove(path) {
+    const normalizedPath = this.#normalizePath(path);
+    this.#log(LogLevelLabel.TRACE, `Removing file: ${normalizedPath}`);
+    const { relativeKey, adapter } = this.#getStorage(normalizedPath);
+    if (hasFileExtension(normalizedPath)) {
+      await adapter.remove(relativeKey);
+    } else {
+      await adapter.clear(relativeKey);
+    }
+    const id = this.#ids[normalizedPath];
+    if (id && this.#metadata[id]) {
+      delete this.#metadata[id];
+      delete this.#ids[normalizedPath];
+      delete this.#paths[id];
+    }
+  }
+  /**
+  * Removes a file in the virtual file system (VFS).
+  *
+  * @param path - The path to create the directory at.
+  */
+  removeSync(path) {
+    const normalizedPath = this.#normalizePath(path);
+    this.#log(LogLevelLabel.TRACE, `Removing file: ${normalizedPath}`);
+    const { relativeKey, adapter } = this.#getStorage(normalizedPath);
+    if (hasFileExtension(normalizedPath)) {
+      adapter.removeSync(relativeKey);
+    } else {
+      adapter.clearSync(relativeKey);
+    }
+    const id = this.#ids[normalizedPath];
+    if (id && this.#metadata[id]) {
+      delete this.#metadata[id];
+      delete this.#ids[normalizedPath];
+      delete this.#paths[id];
+    }
+  }
+  /**
+  * Glob files in the virtual file system (VFS) based on the provided pattern(s).
+  *
+  * @param patterns - A pattern (or multiple patterns) to use to determine the file paths to return
+  * @returns An array of file paths matching the provided pattern(s)
+  */
+  async glob(patterns) {
+    const results = [];
+    for (const pattern of toArray(patterns)) {
+      const normalized = this.#normalizePath(pattern);
+      if (!/[*?[\]{}]/.test(normalized) && !normalized.includes("**")) {
+        const resolved = this.resolveSync(normalized);
+        if (resolved && !results.includes(resolved)) {
+          results.push(resolved);
+        }
+        continue;
+      }
+      const absPattern = isAbsolutePath(normalized) ? normalized : this.#normalizePath(joinPaths(this.#context.workspaceConfig.workspaceRoot, normalized));
+      const firstGlobIdx = absPattern.search(/[*?[\]{}]/);
+      const baseDir = firstGlobIdx === -1 ? findFilePath(absPattern) : absPattern.slice(0, Math.max(0, absPattern.lastIndexOf("/", firstGlobIdx)));
+      await Promise.all((await this.list(baseDir && isAbsolutePath(baseDir) ? baseDir : this.#context.workspaceConfig.workspaceRoot)).map(async (file) => {
+        if (this.#buildRegex(absPattern).test(file)) {
+          const resolved = this.resolveSync(file);
+          if (resolved && !results.includes(resolved)) {
+            results.push(resolved);
+          }
+        }
+      }));
+    }
+    return results;
+  }
+  /**
+  * Synchronously glob files in the virtual file system (VFS) based on the provided pattern(s).
+  *
+  * @param patterns - A pattern (or multiple patterns) to use to determine the file paths to return
+  * @returns An array of file paths matching the provided pattern(s)
+  */
+  globSync(patterns) {
+    const results = [];
+    for (const pattern of toArray(patterns)) {
+      const normalized = this.#normalizePath(pattern);
+      if (!/[*?[\]{}]/.test(normalized) && !normalized.includes("**")) {
+        const resolved = this.resolveSync(normalized);
+        if (resolved && !results.includes(resolved)) {
+          results.push(resolved);
+        }
+        continue;
+      }
+      const absPattern = isAbsolutePath(normalized) ? normalized : this.#normalizePath(joinPaths(this.#context.workspaceConfig.workspaceRoot, normalized));
+      const firstGlobIdx = absPattern.search(/[*?[\]{}]/);
+      const baseDir = firstGlobIdx === -1 ? findFilePath(absPattern) : absPattern.slice(0, Math.max(0, absPattern.lastIndexOf("/", firstGlobIdx)));
+      const files = this.listSync(baseDir && isAbsolutePath(baseDir) ? baseDir : this.#context.workspaceConfig.workspaceRoot);
+      for (const file of files) {
+        if (this.#buildRegex(absPattern).test(file)) {
+          const resolved = this.resolveSync(file);
+          if (resolved && !results.includes(resolved)) {
+            results.push(resolved);
+          }
+        }
+      }
+    }
+    return results;
+  }
+  /**
+  * Copies a file from one path to another in the virtual file system (VFS).
+  *
+  * @param srcPath - The source path to copy
+  * @param destPath - The destination path to copy to
+  */
+  async copy(srcPath, destPath) {
+    if (hasFileExtension(srcPath)) {
+      const content = await this.read(srcPath);
+      if (content !== void 0) {
+        await this.write(hasFileExtension(destPath) ? destPath : joinPaths(destPath, findFileName(srcPath)), content);
+      }
+    } else {
+      await Promise.all((await this.list(srcPath)).map(async (file) => {
+        const relativePath = file.replace(this.#normalizePath(srcPath), "");
+        const destinationPath = this.#normalizePath(appendPath(destPath, relativePath));
+        const content = await this.read(file);
+        if (content !== void 0) {
+          await this.write(destinationPath, content);
+        }
+      }));
+    }
+  }
+  /**
+  * Synchronously copies a file from one path to another in the virtual file system (VFS).
+  *
+  * @param srcPath - The source path to copy
+  * @param destPath - The destination path to copy to
+  */
+  copySync(srcPath, destPath) {
+    if (hasFileExtension(srcPath)) {
+      const content = this.readSync(srcPath);
+      if (content !== void 0) {
+        this.writeSync(hasFileExtension(destPath) ? destPath : joinPaths(destPath, findFileName(srcPath)), content);
+      }
+    } else {
+      this.listSync(srcPath).forEach((file) => {
+        const relativePath = file.replace(this.#normalizePath(srcPath), "");
+        const destinationPath = this.#normalizePath(appendPath(destPath, relativePath));
+        const content = this.readSync(file);
+        if (content !== void 0) {
+          this.writeSync(destinationPath, content);
+        }
+      });
+    }
+  }
+  /**
+  * Moves a file (or files) from one path to another in the virtual file system (VFS).
+  *
+  * @param srcPath - The source path to move
+  * @param destPath - The destination path to move to
+  */
+  async move(srcPath, destPath) {
+    if (hasFileExtension(srcPath)) {
+      await this.copy(srcPath, destPath);
+      await this.remove(srcPath);
+    } else {
+      await Promise.all((await this.list(srcPath)).map(async (file) => {
+        await this.copy(file, destPath);
+        await this.remove(file);
+      }));
+    }
+  }
+  /**
+  * Synchronously moves a file (or files) from one path to another in the virtual file system (VFS).
+  *
+  * @param srcPath - The source path to move
+  * @param destPath - The destination path to move to
+  */
+  moveSync(srcPath, destPath) {
+    if (hasFileExtension(srcPath)) {
+      this.copySync(srcPath, destPath);
+      this.removeSync(srcPath);
+    } else {
+      this.listSync(srcPath).forEach((file) => {
+        this.copySync(file, destPath);
+        this.removeSync(file);
+      });
+    }
+  }
+  /**
+  * Asynchronously reads a file from the virtual file system (VFS).
+  *
+  * @param path - The path or ID of the file to read.
+  * @returns A promise that resolves to the contents of the file as a string, or undefined if the file does not exist.
+  */
+  async read(path) {
+    const filePath = await this.resolve(path);
+    if (!filePath) {
+      return void 0;
+    }
+    const { relativeKey, adapter } = this.#getStorage(filePath);
+    this.#log(LogLevelLabel.TRACE, `Reading ${adapter.name} file: ${filePath}`);
+    return await adapter.get(relativeKey) ?? void 0;
+  }
+  /**
+  * Synchronously reads a file from the virtual file system (VFS).
+  *
+  * @param path - The path or ID of the file to read.
+  * @returns The contents of the file as a string, or undefined if the file does not exist.
+  */
+  readSync(path) {
+    const filePath = this.resolveSync(path);
+    if (!filePath) {
+      return void 0;
+    }
+    const { relativeKey, adapter } = this.#getStorage(filePath);
+    this.#log(LogLevelLabel.TRACE, `Reading ${adapter.name} file: ${filePath}`);
+    return adapter.getSync(relativeKey) ?? void 0;
+  }
+  /**
+  * Writes a file to the virtual file system (VFS).
+  *
+  * @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 write(path, data = "", options = {}) {
+    let code = data;
+    if (!options.skipFormat) {
+      const resolvedConfig = await resolveConfig(this.#normalizePath(path));
+      if (resolvedConfig) {
+        code = await format(data, {
+          absolutePath: this.#normalizePath(path),
+          ...resolvedConfig
+        });
+      }
+    }
+    const { relativeKey, adapter } = this.#getStorage(path);
+    this.#log(LogLevelLabel.TRACE, `Writing ${this.#normalizePath(path)} to ${adapter.name === "virtual" ? "the virtual file system" : adapter.name === "file-system" ? "the local file system" : adapter.name} (size: ${prettyBytes(new Blob(toArray(code)).size)})`);
+    const id = options?.meta?.id || this.#normalizeId(path);
+    this.#metadata[id] = {
+      variant: "normal",
+      timestamp: Date.now(),
+      ...options.meta ?? {}
+    };
+    this.#paths[id] = this.#normalizePath(path);
+    this.#ids[this.#normalizePath(path)] = id;
+    return adapter.set(relativeKey, code);
+  }
+  /**
+  * Synchronously writes a file to the virtual file system (VFS).
+  *
+  * @param path - The file to write.
+  * @param data - The contents of the file.
+  * @param options - Optional parameters for writing the file.
+  */
+  writeSync(path, data = "", options = {}) {
+    const { relativeKey, adapter } = this.#getStorage(path);
+    this.#log(LogLevelLabel.TRACE, `Writing ${this.#normalizePath(path)} file to ${adapter.name === "virtual" ? "the virtual file system" : adapter.name === "file-system" ? "the local file system" : adapter.name} (size: ${prettyBytes(new Blob(toArray(data)).size)})`);
+    const id = options?.meta?.id || this.#normalizeId(path);
+    this.#metadata[id] = {
+      variant: "normal",
+      timestamp: Date.now(),
+      ...options.meta ?? {}
+    };
+    this.#paths[id] = this.#normalizePath(path);
+    this.#ids[this.#normalizePath(path)] = id;
+    return adapter.setSync(relativeKey, data);
+  }
+  /**
+  * Retrieves the metadata of a file in the virtual file system (VFS).
+  *
+  * @param pathOrId - The path or ID of the file to retrieve metadata for.
+  * @returns The metadata of the file, or undefined if the file does not exist.
+  */
+  getMetadata(pathOrId) {
+    const resolved = this.resolveSync(pathOrId);
+    if (resolved && this.metadata[resolved]) {
+      return this.metadata[resolved];
+    }
+    return void 0;
+  }
+  /**
+  * A helper function to resolve modules in the virtual file system (VFS).
+  *
+  * @remarks
+  * This function can be used to resolve modules relative to the project root directory.
+  *
+  * @example
+  * ```ts
+  * const resolved = await context.resolvePath("some-module", "/path/to/importer");
+  * ```
+  *
+  * @param id - The module to resolve.
+  * @param importer - An optional path to the importer module.
+  * @param options - Additional resolution options.
+  * @returns A promise that resolves to the resolved module path.
+  */
+  async resolve(id, importer, options = {}) {
+    if (isAbsolutePath(id)) {
+      return id;
+    }
+    let result;
+    if (!this.#context.config.skipCache) {
+      result = this.resolverCache.get(this.#normalizeId(id));
+      if (result) {
+        return result;
+      }
+    }
+    result = this.paths[this.#normalizeId(id)];
+    if (!result) {
+      const paths = options.paths ?? [];
+      if (importer && !paths.includes(importer)) {
+        paths.push(importer);
+      }
+      paths.push(this.#context.workspaceConfig.workspaceRoot);
+      paths.push(appendPath(this.#context.config.projectRoot, this.#context.workspaceConfig.workspaceRoot));
+      paths.push(appendPath(this.#context.config.sourceRoot, this.#context.workspaceConfig.workspaceRoot));
+      paths.push(...Object.keys(this.#context.tsconfig.options.paths ?? {}).filter((tsconfigPath) => id.startsWith(tsconfigPath.replace(/\*$/, ""))).map((tsconfigPath) => this.#context.tsconfig.options.paths?.[tsconfigPath]).flat().filter(Boolean).map((tsconfigPath) => appendPath(tsconfigPath, this.#context.workspaceConfig.workspaceRoot)));
+      for (const combination of getResolutionCombinations(id, {
+        paths
+      })) {
+        const { relativeKey, adapter } = this.#getStorage(combination);
+        if (await adapter.exists(relativeKey)) {
+          result = combination;
+          break;
+        }
+      }
+      try {
+        result = await resolve(id, {
+          paths
+        });
+      } catch {
+      }
+    }
+    if (result) {
+      result = toAbsolutePath(appendPath(result, this.#context.config.projectRoot), this.#context.workspaceConfig.workspaceRoot);
+      if (!this.#context.config.skipCache) {
+        this.resolverCache.set(this.#normalizeId(id), result);
+      }
+    }
+    return result;
+  }
+  /**
+  * A synchronous helper function to resolve modules using the Jiti resolver
+  *
+  * @remarks
+  * This function can be used to resolve modules relative to the project root directory.
+  *
+  * @example
+  * ```ts
+  * const resolvedPath = context.resolveSync("some-module", "/path/to/importer");
+  * ```
+  *
+  * @param id - The module to resolve.
+  * @param importer - An optional path to the importer module.
+  * @param options - Additional resolution options.
+  * @returns The resolved module path.
+  */
+  resolveSync(id, importer, options = {}) {
+    if (isAbsolutePath(id)) {
+      return id;
+    }
+    let result;
+    if (!this.#context.config.skipCache) {
+      result = this.resolverCache.get(this.#normalizeId(id));
+      if (result) {
+        return result;
+      }
+    }
+    result = this.paths[this.#normalizeId(id)];
+    if (!result) {
+      const paths = options.paths ?? [];
+      if (importer && !paths.includes(importer)) {
+        paths.push(importer);
+      }
+      paths.push(this.#context.workspaceConfig.workspaceRoot);
+      paths.push(appendPath(this.#context.config.projectRoot, this.#context.workspaceConfig.workspaceRoot));
+      paths.push(appendPath(this.#context.config.sourceRoot, this.#context.workspaceConfig.workspaceRoot));
+      paths.push(...Object.keys(this.#context.tsconfig.options.paths ?? {}).filter((tsconfigPath) => id.startsWith(tsconfigPath.replace(/\*$/, ""))).map((tsconfigPath) => this.#context.tsconfig.options.paths?.[tsconfigPath]).flat().filter(Boolean).map((tsconfigPath) => appendPath(tsconfigPath, this.#context.workspaceConfig.workspaceRoot)));
+      for (const combination of getResolutionCombinations(id, {
+        paths
+      })) {
+        const { relativeKey, adapter } = this.#getStorage(combination);
+        if (adapter.existsSync(relativeKey)) {
+          result = combination;
+          break;
+        }
+      }
+      try {
+        result = resolveSync(id, {
+          paths
+        });
+      } catch {
+      }
+    }
+    if (result) {
+      result = toAbsolutePath(appendPath(result, this.#context.config.projectRoot), this.#context.workspaceConfig.workspaceRoot);
+      if (!this.#context.config.skipCache) {
+        this.resolverCache.set(this.#normalizeId(id), result);
+      }
+    }
+    return result;
+  }
+  /**
+  * Disposes of the virtual file system (VFS) by saving its state to disk.
+  */
+  async dispose() {
+    if (!this.#isDisposed) {
+      this.#isDisposed = true;
+      this.#log(LogLevelLabel.DEBUG, "Disposing virtual file system...");
+      await this.remove(joinPaths(this.#context.dataPath, "fs.bin"));
+      const message = new $.Message();
+      const fs = message.initRoot(FileSystem);
+      const paths = await this.list();
+      const storage = fs._initStorage(paths.length);
+      await Promise.all(paths.map(async (path, index) => {
+        const code = await this.read(path);
+        const fd = storage.get(index);
+        fd.path = path;
+        fd.code = code || "";
+      }));
+      const ids = fs._initIds(Object.keys(this.ids).length);
+      Object.entries(this.ids).filter(([, path]) => path).forEach(([id, path], index) => {
+        const fileId = ids.get(index);
+        fileId.id = id;
+        fileId.path = path;
+      });
+      const metadata = fs._initMetadata(Object.keys(this.metadata).length);
+      Object.entries(this.metadata).filter(([, value]) => value).forEach(([id, value], index) => {
+        const fileMetadata = metadata.get(index);
+        fileMetadata.id = id;
+        fileMetadata.type = value.type;
+        fileMetadata.timestamp = value.timestamp ?? BigInt(Date.now());
+        if (value.properties) {
+          const props = fileMetadata._initProperties(Object.keys(value.properties).length);
+          Object.entries(value.properties).forEach(([key, val], index2) => {
+            const prop = props.get(index2);
+            prop.key = key;
+            prop.value = val;
+          });
+        }
+      });
+      await writeFileBuffer(joinPaths(this.#context.dataPath, "fs.bin"), message.toArrayBuffer());
+      if (!this.#context.config.skipCache) {
+        this.#resolverCache.save(true);
+      }
+      await Promise.all(this.#getStorages().map(async (storage2) => storage2.adapter.dispose()));
+      this.#log(LogLevelLabel.TRACE, "Virtual file system has been disposed.");
+    }
+  }
+  // /**
+  //  * Initializes the virtual file system (VFS) by patching the file system module if necessary.
+  //  */
+  // public [__VFS_PATCH__]() {
+  //   if (!this.#isPatched && this.#context.config.output.mode !== "fs") {
+  //     this.#revert = patchFS(fs, this);
+  //     this.#isPatched = true;
+  //   }
+  // }
+  // /**
+  //  * Reverts the file system module to its original state if it was previously patched.
+  //  */
+  // public [__VFS_REVERT__]() {
+  //   if (this.#isPatched && this.#context.config.output.mode !== "fs") {
+  //     if (!this.#revert) {
+  //       throw new Error(
+  //         "Attempting to revert File System patch prior to calling `__init__` function"
+  //       );
+  //     }
+  //     this.#revert?.();
+  //     this.#isPatched = false;
+  //   }
+  // }
+  async [Symbol.asyncDispose]() {
+    return this.dispose();
+  }
+};
+
+export { VirtualFileSystem };