powerlines 0.14.0 → 0.14.4

package/dist/lib/chunk-6BRTJXZ2.js

@@ -1,3333 +0,0 @@
-import { writeFile } from './chunk-HQ6TGY34.js';
-import { getFileHeader } from './chunk-7R23HVGQ.js';
-import { __VFS_CACHE__, __VFS_RESOLVER__, __VFS_VIRTUAL__, __VFS_UNIFIED__, __VFS_INIT__, __VFS_REVERT__, CACHE_HASH_LENGTH, PROJECT_ROOT_HASH_LENGTH, getPrefixedProjectRootHash, getChecksum, writeMetaFile } from './chunk-KOCDKJDJ.js';
-import { isPlugin, checkDedupe, isPluginHook, isHookExternal, addPluginHook, getHookHandler, isPluginConfig, isPluginConfigTuple, isPluginConfigObject } from './chunk-UGRFAVAJ.js';
-import { handleResolveId } from './chunk-YBIWVB66.js';
-import { getParsedTypeScriptConfig, getTsconfigFilePath, isIncludeMatchFound } from './chunk-OO4BIM7N.js';
-import { loadWorkspaceConfig, loadUserConfigFile } from './chunk-56LQSSQ3.js';
-import { extendLog, createLog } from './chunk-35EO5Y7R.js';
-import { getSourceFile, getString } from './chunk-PXSRMP4E.js';
-import { resolveEntriesSync, getUniqueEntries } from './chunk-STAKGAWR.js';
-import { __name } from './chunk-7QVYU63E.js';
-import { LogLevelLabel } from '@storm-software/config-tools/types';
-import { relativeToWorkspaceRoot, getWorkspaceRoot } from '@stryke/fs/get-workspace-root';
-import { tsconfigPathsToRegExp } from 'bundle-require';
-import { formatLogMessage } from '@storm-software/config-tools/logger/console';
-import { toArray } from '@stryke/convert/to-array';
-import { copyFiles } from '@stryke/fs/copy-file';
-import { existsSync } from '@stryke/fs/exists';
-import { createDirectory } from '@stryke/fs/helpers';
-import { install } from '@stryke/fs/install';
-import { listFiles } from '@stryke/fs/list-files';
-import { isPackageExists, isPackageListed, doesPackageMatch, getPackageListing } from '@stryke/fs/package-fns';
-import { joinPaths } from '@stryke/path/join-paths';
-import { replacePath } from '@stryke/path/replace';
-import { isError } from '@stryke/type-checks/is-error';
-import { isFunction } from '@stryke/type-checks/is-function';
-import { isNumber } from '@stryke/type-checks/is-number';
-import { isPromiseLike } from '@stryke/type-checks/is-promise';
-import { isSet } from '@stryke/type-checks/is-set';
-import { isSetObject } from '@stryke/type-checks/is-set-object';
-import { isSetString } from '@stryke/type-checks/is-set-string';
-import chalk4 from 'chalk';
-import Handlebars from 'handlebars';
-import { resolvePackage } from '@stryke/fs/resolve';
-import { titleCase } from '@stryke/string-format/title-case';
-import defu3, { defu } from 'defu';
-import { getEnvPaths } from '@stryke/env/get-env-paths';
-import { readJsonFile } from '@stryke/fs/json';
-import { murmurhash } from '@stryke/hash/murmurhash';
-import { getUnique } from '@stryke/helpers/get-unique';
-import { omit } from '@stryke/helpers/omit';
-import { appendPath } from '@stryke/path/append';
-import { findFilePath, findFileDotExtensionSafe, hasFileExtension, relativePath, findFileName } from '@stryke/path/file-path-fns';
-import { isAbsolutePath, isAbsolute } from '@stryke/path/is-type';
-import { joinPaths as joinPaths$1 } from '@stryke/path/join';
-import { isNull } from '@stryke/type-checks/is-null';
-import { isString } from '@stryke/type-checks/is-string';
-import { uuid } from '@stryke/unique-id/uuid';
-import { parseAsync } from 'oxc-parser';
-import { createJiti } from 'jiti';
-import { bufferToString } from '@stryke/convert/buffer-to-string';
-import { isParentPath } from '@stryke/path/is-parent-path';
-import { prettyBytes } from '@stryke/string-format/pretty-bytes';
-import { isBuffer } from '@stryke/type-checks/is-buffer';
-import { isUndefined } from '@stryke/type-checks/is-undefined';
-import { Volume } from 'memfs';
-import { Blob } from 'node:buffer';
-import fs from 'node:fs';
-import { resolveConfig, format } from 'prettier';
-import { Union } from 'unionfs';
-import { isObject } from '@stryke/type-checks/is-object';
-import { transformAsync } from '@babel/core';
-import ts, { createProgram, createCompilerHost, getPreEmitDiagnostics, getLineAndCharacterOfPosition, flattenDiagnosticMessageText } from 'typescript';
-import { declare } from '@babel/helper-plugin-utils';
-import * as t from '@babel/types';
-import { getPackageName, hasPackageVersion, getPackageVersion } from '@stryke/string-format/package';
-import { getObjectDiff } from '@donedeal0/superdiff';
-import { loadTsConfig } from '@stryke/fs/tsconfig';
-import { StormJSON } from '@stryke/json/storm-json';
-
-var DEFAULT_ENVIRONMENT = "default";
-function createEnvironment(name, userConfig) {
-  return defu3(userConfig.environments?.[name] ?? {}, {
-    name,
-    title: userConfig.title || titleCase(userConfig.name),
-    ssr: false,
-    mainFields: userConfig.build?.platform === "browser" ? [
-      "browser",
-      "module",
-      "jsnext:main",
-      "jsnext"
-    ] : [
-      "module",
-      "jsnext:main",
-      "jsnext"
-    ],
-    extensions: [
-      ".mjs",
-      ".js",
-      ".mts",
-      ".ts",
-      ".jsx",
-      ".tsx",
-      ".json"
-    ],
-    consumer: userConfig.build?.platform === "browser" ? "client" : "server",
-    preview: userConfig.build?.platform === "browser" ? {
-      port: 5173,
-      open: true,
-      strictPort: false,
-      // https: false,
-      host: "localhost",
-      allowedHosts: [
-        "."
-      ],
-      cors: true,
-      headers: {}
-    } : void 0
-  }, userConfig);
-}
-__name(createEnvironment, "createEnvironment");
-function createDefaultEnvironment(userConfig) {
-  return createEnvironment(DEFAULT_ENVIRONMENT, userConfig);
-}
-__name(createDefaultEnvironment, "createDefaultEnvironment");
-function resolveOptions(options) {
-  return defu3(options, {
-    interopDefault: true,
-    fsCache: options.mode !== "development" ? joinPaths(options.cacheDir, "jiti") : false,
-    moduleCache: options.mode !== "development"
-  });
-}
-__name(resolveOptions, "resolveOptions");
-function createPluginResolver(options) {
-  return createJiti(joinPaths(options.workspaceRoot, options.projectRoot), resolveOptions({
-    ...options
-  }));
-}
-__name(createPluginResolver, "createPluginResolver");
-function createResolver(options) {
-  const baseResolver = createJiti(joinPaths(options.workspaceRoot, options.projectRoot), resolveOptions(options));
-  baseResolver.plugin = createPluginResolver(options);
-  return baseResolver;
-}
-__name(createResolver, "createResolver");
-function isBufferEncoding(options) {
-  return isSetString(options) || options === null;
-}
-__name(isBufferEncoding, "isBufferEncoding");
-function isPowerlinesWriteFileOptions(options) {
-  return !isBufferEncoding(options) && isSetObject(options) && ("skipFormat" in options || "mode" in options && (options.mode === "fs" || options.mode === "virtual"));
-}
-__name(isPowerlinesWriteFileOptions, "isPowerlinesWriteFileOptions");
-function isNodeWriteFileOptions(options) {
-  return !isUndefined(options) && (isBufferEncoding(options) || !isPowerlinesWriteFileOptions(options));
-}
-__name(isNodeWriteFileOptions, "isNodeWriteFileOptions");
-function isPowerLinesWriteFileData(data) {
-  return !!(isSetObject(data) && "code" in data && data.code);
-}
-__name(isPowerLinesWriteFileData, "isPowerLinesWriteFileData");
-var FILE_PREFIX = "file://";
-function toFilePath(pathOrUrl) {
-  if (!pathOrUrl) {
-    throw new Error("No Path or URL provided to Virtual File System");
-  }
-  let result = pathOrUrl.toString();
-  if (result.startsWith(FILE_PREFIX)) {
-    result = result.slice(FILE_PREFIX.length);
-  }
-  return result;
-}
-__name(toFilePath, "toFilePath");
-var FS_METHODS = [
-  "mkdir",
-  "mkdirSync",
-  "rmdir",
-  "rmdirSync",
-  "unlink",
-  "unlinkSync",
-  "existsSync",
-  "realpathSync",
-  "writeFileSync",
-  "readFileSync",
-  "readdirSync",
-  "createWriteStream",
-  "WriteStream",
-  "createReadStream",
-  "ReadStream"
-];
-var FS_PROMISE_METHODS = [
-  "mkdir",
-  "rm",
-  "rmdir",
-  "unlink",
-  "writeFile",
-  "readFile",
-  "readdir",
-  "stat",
-  "lstat"
-];
-function cloneFS(originalFS) {
-  const clonedFS = {
-    ...originalFS,
-    promises: {
-      ...originalFS.promises ?? {}
-    }
-  };
-  for (const method of FS_METHODS) {
-    if (originalFS[method]) {
-      clonedFS[method] = originalFS[method];
-    }
-  }
-  originalFS.promises ??= {};
-  for (const method of FS_PROMISE_METHODS) {
-    if (originalFS.promises[method]) {
-      clonedFS.promises ??= {};
-      clonedFS.promises[method] = originalFS.promises[method];
-      clonedFS[method] = originalFS.promises[method];
-    }
-  }
-  for (const prop in clonedFS) {
-    if (isFunction(clonedFS[prop])) {
-      clonedFS[prop] = clonedFS[prop].bind(originalFS);
-      if (isFunction(clonedFS.promises[prop])) {
-        clonedFS.promises[prop] = clonedFS.promises[prop].bind(originalFS);
-      }
-    }
-  }
-  for (const prop in clonedFS.promises) {
-    if (isFunction(clonedFS.promises[prop])) {
-      clonedFS.promises[prop] = clonedFS.promises[prop].bind(originalFS);
-    }
-  }
-  return clonedFS;
-}
-__name(cloneFS, "cloneFS");
-function patchFS(originalFS, vfs) {
-  const clonedFS = cloneFS(originalFS);
-  originalFS.mkdirSync = (file, options) => vfs.mkdirSync(toFilePath(file), options);
-  originalFS.mkdir = (file, options, callback) => vfs.mkdir(toFilePath(file), options, callback);
-  originalFS.promises.mkdir = async (file, options) => vfs.mkdir(toFilePath(file), options);
-  originalFS.unlinkSync = (file) => vfs.unlinkSync(toFilePath(file));
-  originalFS.promises.rm = async (file, options) => vfs.rm(toFilePath(file), options);
-  originalFS.promises.unlink = async (file) => vfs.unlink(toFilePath(file));
-  originalFS.existsSync = (file) => vfs.existsSync(toFilePath(file));
-  Object.defineProperty(originalFS, "realpathSync", {
-    value: /* @__PURE__ */ __name((file, options) => vfs.realpathSync(toFilePath(file), options), "value")
-  });
-  originalFS.writeFileSync = (file, data, options) => vfs.writeFileSync(toFilePath(file), data, options);
-  originalFS.promises.writeFile = async (file, data, options) => vfs.writeFile(toFilePath(file), data, options);
-  originalFS.readFileSync = (file, options) => vfs.readFileSync(toFilePath(file), options);
-  originalFS.promises.readFile = (file, options) => vfs.readFile(toFilePath(file), options);
-  originalFS.readdirSync = (file, options) => vfs.readdirSync(toFilePath(file), options);
-  originalFS.promises.readdir = (file, options) => vfs.readdir(toFilePath(file), options);
-  Object.defineProperty(originalFS, "statSync", {
-    value: /* @__PURE__ */ __name((file, options) => vfs.statSync(toFilePath(file), options), "value")
-  });
-  originalFS.stat = (file, options) => vfs.statSync(toFilePath(file), options);
-  originalFS.promises.stat = (file, options) => vfs.stat(toFilePath(file), options);
-  Object.defineProperty(originalFS, "lstatSync", {
-    value: /* @__PURE__ */ __name((file, options) => vfs.lstatSync(toFilePath(file), options), "value")
-  });
-  originalFS.lstat = (file, options) => vfs.lstatSync(toFilePath(file), options);
-  originalFS.promises.lstat = (file, options) => vfs.lstat(toFilePath(file), options);
-  return () => {
-    originalFS.mkdirSync = clonedFS.mkdirSync;
-    originalFS.mkdir = clonedFS.mkdir;
-    originalFS.promises.mkdir = clonedFS.promises.mkdir;
-    originalFS.unlinkSync = clonedFS.unlinkSync;
-    originalFS.promises.rm = clonedFS.promises.rm;
-    originalFS.promises.unlink = clonedFS.promises.unlink;
-    originalFS.existsSync = clonedFS.existsSync;
-    originalFS.realpathSync = clonedFS.realpathSync;
-    originalFS.writeFileSync = clonedFS.writeFileSync;
-    originalFS.promises.writeFile = clonedFS.promises.writeFile;
-    originalFS.readFileSync = clonedFS.readFileSync;
-    originalFS.promises.readFile = clonedFS.promises.readFile;
-    originalFS.readdirSync = clonedFS.readdirSync;
-    originalFS.promises.readdir = clonedFS.promises.readdir;
-    Object.defineProperty(originalFS, "statSync", {
-      value: clonedFS.statSync
-    });
-    originalFS.stat = clonedFS.stat;
-    originalFS.promises.stat = clonedFS.promises.stat;
-    Object.defineProperty(originalFS, "lstatSync", {
-      value: clonedFS.lstatSync
-    });
-    originalFS.lstat = clonedFS.lstat;
-    originalFS.promises.lstat = clonedFS.promises.lstat;
-  };
-}
-__name(patchFS, "patchFS");
-var VirtualFileSystem = class {
-  static {
-    __name(this, "VirtualFileSystem");
-  }
-  /**
-  * The internal map of virtual files.
-  */
-  #meta = {};
-  /**
-  * A map of unique identifiers to their virtual file paths.
-  */
-  #ids = {};
-  /**
-  * A map of virtual file paths to their underlying file content.
-  */
-  #cachedFS = /* @__PURE__ */ new Map();
-  /**
-  * A map of virtual file paths to their underlying file content.
-  */
-  #cachedResolver = /* @__PURE__ */ new Map();
-  /**
-  * The internal map of virtual files.
-  */
-  #virtualFS = new Volume();
-  /**
-  * The physical file system.
-  */
-  #fs = cloneFS(fs);
-  /**
-  * The unified volume that combines the virtual file system with the real file system.
-  *
-  * @remarks
-  * This volume allows for seamless access to both virtual and real files.
-  */
-  #unifiedFS = new Union();
-  /**
-  * Indicator specifying if the file system module is patched
-  */
-  #isPatched = false;
-  /**
-  * Function to revert require patch
-  */
-  #revert;
-  /**
-  * The context of the virtual file system.
-  */
-  #context;
-  /**
-  * The file system's logging function.
-  */
-  #log;
-  /**
-  * Checks if a path exists in the virtual file system (VFS).
-  *
-  * @param path - The path to check.
-  * @returns `true` if the path exists, otherwise `false`.
-  */
-  #existsSync(path) {
-    const formattedPath = this.formatPath(path);
-    return this.#virtualFS.existsSync(formattedPath) || this.#fs.existsSync(formattedPath) || this.resolveFS(path).existsSync(formattedPath);
-  }
-  /**
-  * Exposes the internal VFS map for advanced usage.
-  */
-  get [__VFS_CACHE__]() {
-    return this.#cachedFS;
-  }
-  /**
-  * Exposes the internal VFS resolver cache for advanced usage.
-  */
-  get [__VFS_RESOLVER__]() {
-    return this.#cachedResolver;
-  }
-  /**
-  * Exposes the internal VFS map for advanced usage.
-  */
-  get [__VFS_VIRTUAL__]() {
-    return this.#virtualFS;
-  }
-  /**
-  * Exposes the internal UFS map for advanced usage.
-  */
-  get [__VFS_UNIFIED__]() {
-    return this.#unifiedFS;
-  }
-  /**
-  * A proxy to access the underlying file metadata.
-  */
-  get meta() {
-    return new Proxy(this.#meta, {
-      get: /* @__PURE__ */ __name((target, prop) => {
-        if (target[prop]) {
-          return {
-            id: prop,
-            mode: this.#virtualFS.existsSync(prop) ? "virtual" : this.#fs.existsSync(prop) ? "fs" : this.#context.config.output.mode,
-            details: {},
-            variant: "normal",
-            ...target[prop]
-          };
-        }
-        return void 0;
-      }, "get"),
-      set: /* @__PURE__ */ __name((target, prop, value) => {
-        target[prop] = value;
-        this.#ids[value.id || prop] = prop;
-        return true;
-      }, "set"),
-      deleteProperty: /* @__PURE__ */ __name((target, prop) => {
-        delete this.#ids[target[prop]?.id || prop];
-        delete target[prop];
-        return true;
-      }, "deleteProperty")
-    });
-  }
-  /**
-  * A map of module ids to their file paths.
-  */
-  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 = {}) {
-    this.#context = context;
-    this.#cachedFS = /* @__PURE__ */ new Map();
-    this.#meta = Object.fromEntries(Object.entries(serialized.virtualFilesMeta ?? {}));
-    this.#ids = Object.fromEntries(Object.entries(this.#meta).map(([path, data]) => [
-      data.id || path,
-      path
-    ]));
-    if (!this.#fs.existsSync(this.#context.dataPath)) {
-      this.#fs.mkdirSync(this.#context.dataPath, {
-        recursive: true
-      });
-    }
-    if (!this.#fs.existsSync(this.#context.cachePath)) {
-      this.#fs.mkdirSync(this.#context.cachePath, {
-        recursive: true
-      });
-    }
-    if (!this.#fs.existsSync(joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.output.outputPath))) {
-      this.#fs.mkdirSync(joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.output.outputPath), {
-        recursive: true
-      });
-    }
-    this.#unifiedFS = this.#unifiedFS.use(this.#fs);
-    if (this.#context.config.output.mode !== "fs") {
-      if (serialized?.virtualFiles && Object.keys(serialized.virtualFiles).length > 0) {
-        this.#virtualFS = Volume.fromJSON(serialized.virtualFiles);
-      }
-      if (!this.#virtualFS.existsSync(this.#context.artifactsPath)) {
-        this.#virtualFS.mkdirSync(this.#context.artifactsPath, {
-          recursive: true
-        });
-      }
-      if (!this.#virtualFS.existsSync(this.#context.builtinsPath)) {
-        this.#virtualFS.mkdirSync(this.#context.builtinsPath, {
-          recursive: true
-        });
-      }
-      if (!this.#virtualFS.existsSync(this.#context.entryPath)) {
-        this.#virtualFS.mkdirSync(this.#context.entryPath, {
-          recursive: true
-        });
-      }
-      if (!this.#virtualFS.existsSync(this.#context.dtsPath)) {
-        this.#virtualFS.mkdirSync(this.#context.dtsPath, {
-          recursive: true
-        });
-      }
-      this.#unifiedFS = this.#unifiedFS.use(this.#virtualFS);
-    } else if (this.#context.config.projectType === "application") {
-      if (!this.#fs.existsSync(this.#context.artifactsPath)) {
-        this.#fs.mkdirSync(this.#context.artifactsPath, {
-          recursive: true
-        });
-      }
-      if (!this.#fs.existsSync(this.#context.builtinsPath)) {
-        this.#fs.mkdirSync(this.#context.builtinsPath, {
-          recursive: true
-        });
-      }
-      if (!this.#fs.existsSync(this.#context.entryPath)) {
-        this.#fs.mkdirSync(this.#context.entryPath, {
-          recursive: true
-        });
-      }
-      if (!this.#fs.existsSync(this.#context.dtsPath)) {
-        this.#fs.mkdirSync(this.#context.dtsPath, {
-          recursive: true
-        });
-      }
-    }
-    this.#log = extendLog(this.#context.log, "virtual-file-system");
-  }
-  [__VFS_INIT__]() {
-    if (!this.#isPatched && this.#context.config.output.mode !== "fs") {
-      this.#revert = patchFS(fs, this);
-      this.#isPatched = true;
-    }
-  }
-  [__VFS_REVERT__]() {
-    if (this.#isPatched && this.#context.config.output.mode !== "fs") {
-      if (!this.#revert) {
-        throw new Error("Attempting to revert File System patch prior to calling `__init__` function");
-      }
-      this.#revert?.();
-      this.#isPatched = false;
-    }
-  }
-  /**
-  * Check if a path or id corresponds to a virtual file **(does not actually exists on disk)**.
-  *
-  * @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)**.
-  */
-  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";
-  }
-  /**
-  * Check if a path or id corresponds to a file written to the file system **(actually exists on disk)**.
-  *
-  * @param pathOrId - The path or id to check.
-  * @param options - 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)**.
-  */
-  isFs(pathOrId, options = {}) {
-    if (!pathOrId) {
-      return false;
-    }
-    const resolvedPath = this.resolve(pathOrId, {
-      ...options,
-      type: "file"
-    });
-    if (!resolvedPath) {
-      return false;
-    }
-    return this.meta[resolvedPath]?.mode === "fs";
-  }
-  /**
-  * Check if a path exists within one of the directories specified in the tsconfig.json's `path` field.
-  *
-  * @see https://www.typescriptlang.org/tsconfig#paths
-  *
-  * @param pathOrId - The path or ID to check.
-  * @returns Whether the path or ID corresponds to a virtual file.
-  */
-  isTsconfigPath(pathOrId) {
-    return !!this.#context.tsconfig.options.paths && Object.keys(this.#context.tsconfig.options.paths).some((path) => pathOrId.startsWith(path.replaceAll("*", "")));
-  }
-  /**
-  * Lists files in a given path.
-  *
-  * @param path - The path to list files from.
-  * @param options - Options for listing files, such as encoding and recursion.
-  * @returns An array of file names in the specified path.
-  */
-  readdirSync(path, options = "utf8") {
-    return this.resolveFS(path).readdirSync(toFilePath(path), options);
-  }
-  /**
-  * Removes a file in the virtual file system (VFS).
-  *
-  * @param path - The path to create the directory at.
-  */
-  unlinkSync(path, options) {
-    const formattedPath = toFilePath(path);
-    if (!this.isFile(formattedPath)) {
-      return;
-    }
-    this.#log(LogLevelLabel.TRACE, `Synchronously removing file: ${formattedPath}`);
-    this.resolveFS(path, options).unlinkSync(formattedPath);
-    this.#cachedFS.delete(formattedPath);
-    this.clearResolverCache(formattedPath);
-  }
-  /**
-  * Removes a file in the virtual file system (VFS).
-  *
-  * @param path - The path to create the directory at.
-  */
-  async unlink(path, options) {
-    const formattedPath = toFilePath(path);
-    if (!this.isFile(formattedPath)) {
-      return;
-    }
-    this.#log(LogLevelLabel.TRACE, `Removing file: ${formattedPath}`);
-    if (isFunction(this.resolveFS(path, options).promises.unlink)) {
-      await this.resolveFS(path, options).promises.unlink(formattedPath);
-      this.#cachedFS.delete(formattedPath);
-      this.clearResolverCache(formattedPath);
-    } else {
-      this.unlinkSync(formattedPath, options);
-    }
-  }
-  /**
-  * Removes a directory in the virtual file system (VFS).
-  *
-  * @param path - The path to create the directory at.
-  * @param options - Options for creating the directory.
-  */
-  rmdirSync(path, options = {}) {
-    const formattedPath = toFilePath(path);
-    if (!this.isDirectory(formattedPath)) {
-      return;
-    }
-    this.#log(LogLevelLabel.TRACE, `Synchronously removing directory: ${formattedPath}`);
-    this.resolveFS(path, options).rmdirSync(formattedPath, defu3(options, {
-      recursive: true
-    }));
-    this.#cachedFS.delete(formattedPath);
-    this.clearResolverCache(formattedPath);
-  }
-  /**
-  * Removes a directory in the virtual file system (VFS).
-  *
-  * @param path - The path to create the directory at.
-  * @param options - Options for creating the directory.
-  * @returns A promise that resolves to the path of the created directory, or undefined if the directory could not be created.
-  */
-  async rmdir(path, options = {}) {
-    const formattedPath = toFilePath(path);
-    if (!this.isDirectory(formattedPath)) {
-      return;
-    }
-    this.#log(LogLevelLabel.TRACE, `Removing directory: ${formattedPath}`);
-    if (isFunction(this.resolveFS(path, options).promises.rm)) {
-      await this.resolveFS(path, options).promises.rm(formattedPath, defu3(options, {
-        force: true,
-        recursive: true
-      }));
-      this.#cachedFS.delete(formattedPath);
-      this.clearResolverCache(formattedPath);
-    } else {
-      this.rmdirSync(formattedPath, defu3(options ?? {}, {
-        force: true,
-        recursive: true
-      }));
-    }
-  }
-  /**
-  * Removes a file in the virtual file system (VFS).
-  *
-  * @param path - The path to the file to remove.
-  * @param options - Options for removing the file.
-  * @returns A promise that resolves when the file is removed.
-  */
-  async rm(path, options = {}) {
-    this.#log(LogLevelLabel.TRACE, `Removing: ${toFilePath(path)}`);
-    if (this.isDirectory(path)) {
-      return this.rmdir(path, options);
-    }
-    return this.unlink(path, options);
-  }
-  /**
-  * Synchronously removes a file or directory in the virtual file system (VFS).
-  *
-  * @param path - The path to the file or directory to remove.
-  * @param options - Options for removing the file or directory.
-  */
-  rmSync(path, options = {}) {
-    this.#log(LogLevelLabel.TRACE, `Removing: ${toFilePath(path)}`);
-    if (this.isDirectory(path)) {
-      return this.rmdirSync(path, options);
-    }
-    return this.unlinkSync(path, options);
-  }
-  /**
-  * Creates a directory in the virtual file system (VFS).
-  *
-  * @param path - The path to create the directory at.
-  * @param options - Options for creating the directory.
-  * @returns A promise that resolves to the path of the created directory, or undefined if the directory could not be created.
-  */
-  mkdirSync(path, options = {}) {
-    const filePath = toFilePath(path);
-    this.clearResolverCache(filePath);
-    return this.resolveFS(filePath, options).mkdirSync(filePath, defu3(options ?? {}, {
-      recursive: true
-    }));
-  }
-  /**
-  * Creates a directory in the virtual file system (VFS).
-  *
-  * @param path - The path to create the directory at.
-  * @param options - Options for creating the directory.
-  * @returns A promise that resolves to the path of the created directory, or undefined if the directory could not be created.
-  */
-  async mkdir(path, options = {}) {
-    let result;
-    const filePath = toFilePath(path);
-    if (isFunction(this.resolveFS(filePath, options).promises.mkdir)) {
-      result = await this.resolveFS(filePath, options).promises.mkdir(filePath, defu3(options ?? {}, {
-        recursive: true
-      }));
-    } else {
-      result = this.resolveFS(filePath, options).mkdirSync(filePath, defu3(options ?? {}, {
-        recursive: true
-      }));
-    }
-    this.clearResolverCache(filePath);
-    return result;
-  }
-  /**
-  * 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.formatPath(pattern);
-      if (!/[*?[\]{}]/.test(normalized) && !normalized.includes("**")) {
-        const resolved = this.resolve(normalized, {
-          type: "file"
-        });
-        if (resolved && !results.includes(resolved)) {
-          results.push(resolved);
-        }
-        continue;
-      }
-      const absPattern = isAbsolutePath(normalized) ? normalized : this.formatPath(joinPaths(this.#context.workspaceConfig.workspaceRoot, normalized));
-      const firstGlobIdx = absPattern.search(/[*?[\]{}]/);
-      const baseDir = firstGlobIdx === -1 ? findFilePath(absPattern) : absPattern.slice(0, Math.max(0, absPattern.lastIndexOf("/", firstGlobIdx)));
-      const stack = [
-        baseDir && isAbsolutePath(baseDir) ? baseDir : this.#context.workspaceConfig.workspaceRoot
-      ];
-      while (stack.length) {
-        const dir = stack.pop();
-        let entries = [];
-        try {
-          entries = await this.readdir(dir);
-        } catch {
-          continue;
-        }
-        for (const entry of entries) {
-          const full = this.formatPath(joinPaths(dir, entry));
-          let stats;
-          try {
-            stats = this.#unifiedFS.lstatSync(full);
-          } catch {
-            stats = void 0;
-          }
-          if (!stats) continue;
-          if (stats.isDirectory()) {
-            stack.push(full);
-          } else if (stats.isFile()) {
-            if (this.buildRegex(absPattern).test(full)) {
-              const resolved = this.resolve(full, {
-                type: "file"
-              });
-              if (resolved && !results.includes(resolved)) {
-                results.push(resolved);
-              }
-            }
-          }
-        }
-      }
-    }
-    return results;
-  }
-  /**
-  * Synchronously glob files in the virtual file system (VFS) based on the provided pattern(s).
-  *
-  * @param patterns - A pattern (or multiple patterns) to use to determine the file paths to return
-  * @returns An array of file paths matching the provided pattern(s)
-  */
-  globSync(patterns) {
-    const results = [];
-    for (const pattern of toArray(patterns)) {
-      const normalized = this.formatPath(pattern);
-      if (!/[*?[\]{}]/.test(normalized) && !normalized.includes("**")) {
-        const resolved = this.resolve(normalized, {
-          type: "file"
-        });
-        if (resolved && !results.includes(resolved)) {
-          results.push(resolved);
-        }
-        continue;
-      }
-      const absPattern = isAbsolutePath(normalized) ? normalized : this.formatPath(joinPaths(this.#context.workspaceConfig.workspaceRoot, normalized));
-      const firstGlobIdx = absPattern.search(/[*?[\]{}]/);
-      const baseDir = firstGlobIdx === -1 ? findFilePath(absPattern) : absPattern.slice(0, Math.max(0, absPattern.lastIndexOf("/", firstGlobIdx)));
-      const stack = [
-        baseDir && isAbsolutePath(baseDir) ? baseDir : this.#context.workspaceConfig.workspaceRoot
-      ];
-      while (stack.length) {
-        const dir = stack.pop();
-        let entries = [];
-        try {
-          entries = this.readdirSync(dir);
-        } catch {
-          continue;
-        }
-        for (const entry of entries) {
-          const full = this.formatPath(joinPaths(dir, entry));
-          let stats;
-          try {
-            stats = this.#unifiedFS.lstatSync(full);
-          } catch {
-            stats = void 0;
-          }
-          if (!stats) continue;
-          if (stats.isDirectory()) {
-            stack.push(full);
-          } else if (stats.isFile()) {
-            if (this.buildRegex(absPattern).test(full)) {
-              const resolved = this.resolve(full, {
-                type: "file"
-              });
-              if (resolved && !results.includes(resolved)) {
-                results.push(resolved);
-              }
-            }
-          }
-        }
-      }
-    }
-    return results;
-  }
-  /**
-  * Moves a file from one path to another in the virtual file system (VFS).
-  *
-  * @param srcPath - The source path to move
-  * @param destPath - The destination path to move to
-  */
-  async move(srcPath, destPath) {
-    const content = await this.readFile(srcPath);
-    await this.writeFile(destPath, content);
-    await this.rm(srcPath);
-  }
-  /**
-  * Synchronously moves a file from one path to another in the virtual file system (VFS).
-  *
-  * @param srcPath - The source path to move
-  * @param destPath - The destination path to move to
-  */
-  moveSync(srcPath, destPath) {
-    const content = this.readFileSync(srcPath);
-    this.writeFileSync(destPath, content);
-    this.rmSync(srcPath);
-  }
-  /**
-  * Copies a file from one path to another in the virtual file system (VFS).
-  *
-  * @param srcPath - The source path to copy
-  * @param destPath - The destination path to copy to
-  */
-  async copy(srcPath, destPath) {
-    const content = await this.readFile(srcPath);
-    await this.writeFile(destPath, content);
-  }
-  /**
-  * Synchronously copies a file from one path to another in the virtual file system (VFS).
-  *
-  * @param srcPath - The source path to copy
-  * @param destPath - The destination path to copy to
-  */
-  copySync(srcPath, destPath) {
-    const content = this.readFileSync(srcPath);
-    this.writeFileSync(destPath, content);
-  }
-  /**
-  * Lists files in a given path.
-  *
-  * @param pathOrId - The path to list files from.
-  * @param options - Options for listing files, such as encoding and recursion.
-  * @returns An array of file names in the specified path.
-  */
-  async readdir(pathOrId, options = "utf8") {
-    return this.resolveFS(pathOrId).promises.readdir(toFilePath(pathOrId), options);
-  }
-  /**
-  * Asynchronously reads a file from the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID of the file to read.
-  * @returns A promise that resolves to the contents of the file as a string, or undefined if the file does not exist.
-  */
-  async readFile(pathOrId, options = "utf8") {
-    if (!pathOrId) {
-      return void 0;
-    }
-    const filePath = this.resolve(toFilePath(pathOrId), {
-      type: "file"
-    });
-    if (filePath) {
-      if (this.#cachedFS.has(filePath)) {
-        return this.#cachedFS.get(filePath);
-      }
-      let result;
-      if (isFunction(this.resolveFS(filePath).promises.readFile)) {
-        result = (await this.resolveFS(filePath).promises.readFile(filePath, options))?.toString("utf8");
-      } else {
-        result = this.resolveFS(filePath).readFileSync(filePath, options);
-      }
-      const content = isBuffer(result) ? bufferToString(result) : result;
-      this.#cachedFS.set(filePath, content);
-      return content;
-    }
-    return void 0;
-  }
-  /**
-  * Synchronously reads a file from the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID of the file to read.
-  * @returns The contents of the file as a string, or undefined if the file does not exist.
-  */
-  readFileSync(pathOrId, options = "utf8") {
-    if (!pathOrId) {
-      return void 0;
-    }
-    const filePath = this.resolve(toFilePath(pathOrId), {
-      type: "file"
-    });
-    if (filePath) {
-      if (this.#cachedFS.has(filePath)) {
-        return this.#cachedFS.get(filePath);
-      }
-      const result = this.resolveFS(filePath).readFileSync(filePath, options);
-      const content = isBuffer(result) ? bufferToString(result) : result;
-      this.#cachedFS.set(filePath, content);
-      return content;
-    }
-    return void 0;
-  }
-  /**
-  * Writes a file to the virtual file system (VFS).
-  *
-  * @param path - The path to the file.
-  * @param data - The contents of the file.
-  * @param options - Optional parameters for writing the file.
-  * @returns A promise that resolves when the file is written.
-  */
-  async writeFile(path, data = "", options = "utf8") {
-    const formattedPath = this.formatPath(path);
-    if (!this.isDirectory(findFilePath(formattedPath))) {
-      await this.mkdir(findFilePath(formattedPath), isPowerlinesWriteFileOptions(options) ? options : void 0);
-    }
-    let code = isPowerLinesWriteFileData(data) ? data.code : data;
-    if ((!isPowerlinesWriteFileOptions(options) || !options.skipFormat) && isSetString(code)) {
-      const resolvedConfig = await resolveConfig(formattedPath);
-      if (resolvedConfig) {
-        code = await format(code, {
-          absolutePath: formattedPath,
-          ...resolvedConfig
-        });
-      }
-    }
-    const outputMode = this.resolveOutputMode(formattedPath, isPowerlinesWriteFileOptions(options) ? options : void 0);
-    this.#log(LogLevelLabel.TRACE, `Writing ${formattedPath} file to the ${outputMode === "fs" ? "" : "virtual "}file system (size: ${prettyBytes(new Blob(toArray(code)).size)})`);
-    this.meta[formattedPath] = {
-      path: formattedPath,
-      code,
-      mode: outputMode,
-      variant: "normal",
-      ...isPowerLinesWriteFileData(data) ? data : {}
-    };
-    this.clearResolverCache(formattedPath);
-    const ifs = this.resolveFS(formattedPath, isPowerlinesWriteFileOptions(options) ? options : void 0);
-    if (isFunction(ifs.promises.writeFile)) {
-      return ifs.promises.writeFile(formattedPath, code, isNodeWriteFileOptions(options) ? options : "utf8");
-    }
-    return ifs.writeFileSync(formattedPath, code, isNodeWriteFileOptions(options) ? options : "utf8");
-  }
-  /**
-  * 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.
-  */
-  writeFileSync(path, data = "", options = "utf8") {
-    const formattedPath = this.formatPath(path);
-    if (!this.isDirectory(findFilePath(formattedPath))) {
-      this.mkdirSync(findFilePath(formattedPath), isPowerlinesWriteFileOptions(options) ? options : void 0);
-    }
-    const code = isPowerLinesWriteFileData(data) ? data.code : data;
-    const outputMode = this.resolveOutputMode(formattedPath, isPowerlinesWriteFileOptions(options) ? options : void 0);
-    this.#log(LogLevelLabel.TRACE, `Writing ${formattedPath} file to the ${outputMode === "fs" ? "" : "virtual "}file system (size: ${prettyBytes(new Blob(toArray(code)).size)})`);
-    this.meta[formattedPath] = {
-      path: formattedPath,
-      code,
-      mode: outputMode,
-      variant: "normal",
-      ...isPowerLinesWriteFileData(data) ? data : {}
-    };
-    this.clearResolverCache(formattedPath);
-    const writeStream = this.resolveFS(formattedPath, isPowerlinesWriteFileOptions(options) ? options : void 0).createWriteStream(formattedPath);
-    try {
-      writeStream.write(code);
-    } finally {
-      writeStream.close();
-    }
-  }
-  /**
-  * 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.resolve(pathOrId) !== false;
-  }
-  /**
-  * Retrieves the metadata of a file in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID of the file to retrieve metadata for.
-  * @returns The metadata of the file, or undefined if the file does not exist.
-  */
-  getMetadata(pathOrId) {
-    const resolved = this.resolve(pathOrId);
-    if (resolved && this.meta[resolved]) {
-      return this.meta[resolved];
-    }
-    return void 0;
-  }
-  /**
-  * Checks if a file exists in the virtual file system (VFS).
-  *
-  * @remarks
-  * This is a base method used by {@link existsSync} - it does not try to resolve the path prior to checking if it exists or not.
-  *
-  * @param pathOrId - The path of the file to check.
-  * @returns `true` if the file exists, otherwise `false`.
-  */
-  isFile(pathOrId) {
-    const resolved = this.resolve(pathOrId);
-    return !!(resolved && (this.#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 pathOrId - The path of the directory to check.
-  * @returns `true` if the directory exists, otherwise `false`.
-  */
-  isDirectory(pathOrId) {
-    const resolved = this.resolve(pathOrId);
-    return !!(resolved && (this.#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).
-  *
-  * @param pathOrId - The path or ID of the file to retrieve status for.
-  * @returns A promise that resolves to the file's status information, or false if the file does not exist.
-  */
-  async stat(pathOrId, options) {
-    return this.resolveFS(pathOrId).promises.stat(this.resolve(toFilePath(pathOrId)) || toFilePath(pathOrId), options);
-  }
-  /**
-  * Synchronously retrieves the status of a file in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID of the file to retrieve status for.
-  * @returns The file's status information, or false if the file does not exist.
-  */
-  statSync(pathOrId) {
-    return this.resolveFS(pathOrId).statSync(this.resolve(toFilePath(pathOrId)) || toFilePath(pathOrId));
-  }
-  /**
-  * Retrieves the status of a symbolic link in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID of the symbolic link to retrieve status for.
-  * @returns A promise that resolves to the symbolic link's status information, or false if the link does not exist.
-  */
-  async lstat(pathOrId, options) {
-    return this.resolveFS(pathOrId).promises.lstat(this.resolve(toFilePath(pathOrId)) || toFilePath(pathOrId), options);
-  }
-  /**
-  * Synchronously retrieves the status of a symbolic link in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID of the symbolic link to retrieve status for.
-  * @returns The symbolic link's status information, or false if the link does not exist.
-  */
-  lstatSync(pathOrId, options) {
-    return this.resolveFS(pathOrId).lstatSync(this.resolve(toFilePath(pathOrId)) || toFilePath(pathOrId), options);
-  }
-  /**
-  * Resolves a path based on TypeScript's `tsconfig.json` paths.
-  *
-  * @see https://www.typescriptlang.org/tsconfig#paths
-  *
-  * @param path - The path to check.
-  * @returns The resolved file path if it exists, otherwise undefined.
-  */
-  resolveTsconfigPath(path) {
-    if (this.#context.tsconfig.options.paths) {
-      for (const tsconfigPathKey of Object.keys(this.#context.tsconfig.options.paths).filter((tsconfigPath) => path.startsWith(tsconfigPath.replaceAll("*", "")))) {
-        const resolvedPath = this.#context.tsconfig.options.paths[tsconfigPathKey]?.find((tsconfigPath) => this.resolvePath(joinPaths(this.#context.workspaceConfig.workspaceRoot, tsconfigPath.replaceAll("*", ""), path.replace(tsconfigPathKey.replaceAll("*", ""), ""))) || this.formatPath(tsconfigPath) === this.formatPath(path));
-        if (resolvedPath) {
-          return this.formatPath(resolvedPath) === this.formatPath(path) ? this.formatPath(resolvedPath) : this.resolvePath(joinPaths(this.#context.workspaceConfig.workspaceRoot, resolvedPath.replaceAll("*", ""), path.replace(tsconfigPathKey.replaceAll("*", ""), "")));
-        }
-      }
-    }
-    return false;
-  }
-  /**
-  * Resolves a path based on TypeScript's `tsconfig.json` paths.
-  *
-  * @see https://www.typescriptlang.org/tsconfig#paths
-  *
-  * @param path - The path to check.
-  * @returns The resolved file path if it exists, otherwise undefined.
-  */
-  resolveTsconfigPathPackage(path) {
-    if (this.#context.tsconfig.options.paths) {
-      const tsconfigPathKeys = Object.keys(this.#context.tsconfig.options.paths).filter((tsconfigPath) => path.startsWith(tsconfigPath.replaceAll("*", "")));
-      if (tsconfigPathKeys.length > 0 && tsconfigPathKeys[0]) {
-        return tsconfigPathKeys[0].replace(/\/\*$/, "");
-      }
-    }
-    return false;
-  }
-  /**
-  * Resolves a path or ID to its real path in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID to resolve.
-  * @returns The resolved real path if it exists, otherwise undefined.
-  */
-  realpathSync(pathOrId) {
-    const filePath = this.resolve(toFilePath(pathOrId));
-    if (!filePath) {
-      throw new Error(`File not found: ${toFilePath(pathOrId)}`);
-    }
-    return filePath;
-  }
-  /**
-  * Resolves a path or ID parameter to a corresponding virtual file path in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID to resolve.
-  * @param options - Optional parameters for resolving the path, such as whether to include the file extension.
-  * @returns The resolved file path if it exists, otherwise undefined.
-  */
-  resolve(pathOrId, options = {}) {
-    const formattedPathOrId = toFilePath(pathOrId);
-    const resolverKey = `${formattedPathOrId}${options.withExtension ? "-ext" : ""}${options.paths ? `-${murmurhash(options.paths)}` : ""}${options.type ? `-${options.type}` : ""}`;
-    if (this.#cachedResolver.has(resolverKey)) {
-      return this.#cachedResolver.get(resolverKey);
-    }
-    let result = this.resolveId(formattedPathOrId);
-    if (!result) {
-      result = this.resolvePath(formattedPathOrId, options);
-    }
-    if (!result) {
-      result = false;
-    }
-    if (result && options.withExtension === false) {
-      return result.replace(/\.[m|c]?[t|j]sx?$/, "");
-    }
-    this.#cachedResolver.set(resolverKey, result);
-    return result;
-  }
-  /**
-  * Retrieves the partial metadata for all files in the virtual file system (VFS).
-  *
-  * @returns A record containing the partial metadata for all files.
-  */
-  getPartialMeta() {
-    return Object.fromEntries(Object.entries(this.#meta).filter(([_, data]) => isSetObject(data)));
-  }
-  buildRegex(strPattern) {
-    const token = "::GLOBSTAR::";
-    return new RegExp(`^${this.formatPath(strPattern).replace(/\*\*/g, token).replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(new RegExp(token, "g"), ".*")}$`);
-  }
-  /**
-  * Converts a relative path to an absolute path based on the workspace and project root.
-  *
-  * @param path - The relative path to convert.
-  * @returns The absolute path.
-  */
-  formatPath(path) {
-    const formattedPath = toFilePath(path);
-    if (isAbsolutePath(formattedPath) || formattedPath.startsWith(this.#context.workspaceConfig.workspaceRoot)) {
-      return formattedPath;
-    } else if (formattedPath.startsWith(this.#context.config.projectRoot)) {
-      return joinPaths(this.#context.workspaceConfig.workspaceRoot, formattedPath);
-    }
-    return formattedPath;
-  }
-  /**
-  * Formats a file id by removing the file extension and prepending the runtime prefix.
-  *
-  * @param id - The file ID to format.
-  * @returns The formatted file ID.
-  */
-  formatId(id) {
-    const formattedId = toFilePath(id);
-    return `${this.#context.config.output.builtinPrefix}:${formattedId.replace(new RegExp(`^${this.#context.config.output.builtinPrefix}:`), "").replace(/^\\0/, "").replace(findFileDotExtensionSafe(formattedId), "")}`;
-  }
-  /**
-  * Resolves an id parameter to a corresponding virtual file path in the virtual file system (VFS).
-  *
-  * @param id - The id to resolve.
-  * @returns The resolved file id if it exists, otherwise undefined.
-  */
-  resolveId(id) {
-    if (this.#ids[this.formatId(id)]) {
-      return this.#ids[this.formatId(id)] || false;
-    }
-    return false;
-  }
-  /**
-  * Resolves a path parameter to a corresponding virtual file path in the virtual file system (VFS).
-  *
-  * @param path - The path to resolve.
-  * @param options - Optional parameters for resolving the path.
-  * @returns The resolved file path if it exists, otherwise undefined.
-  */
-  resolvePath(path, options = {}) {
-    if (isAbsolutePath(path)) {
-      if (this.#existsSync(path)) {
-        return path;
-      }
-      const result = this.checkVariants(path);
-      if (result) {
-        return result;
-      }
-    }
-    for (const parentPath of this.resolveParentPaths(path, options.paths)) {
-      const request = joinPaths(parentPath, path);
-      if (this.#existsSync(request)) {
-        return request;
-      }
-      const result = this.checkVariants(request);
-      if (result) {
-        return result;
-      }
-    }
-    return false;
-  }
-  resolveParentPaths(request, parents = []) {
-    let paths = [
-      this.#context.workspaceConfig.workspaceRoot,
-      joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.projectRoot)
-    ];
-    if (this.#context.tsconfig.options.paths) {
-      paths = this.#context.tsconfig.options.paths ? Object.keys(this.#context.tsconfig.options.paths).filter((tsconfigPath) => request.startsWith(tsconfigPath.replaceAll("*", ""))).map((tsconfigPath) => this.#context.tsconfig.options.paths?.[tsconfigPath]).flat().reduce((ret, path) => {
-        if (path && !ret.includes(joinPaths(this.#context.workspaceConfig.workspaceRoot, path))) {
-          ret.push(joinPaths(this.#context.workspaceConfig.workspaceRoot, path));
-        }
-        return ret;
-      }, paths) : paths;
-    }
-    return paths.reduce((ret, path) => {
-      if (!ret.includes(path)) {
-        ret.push(path);
-      }
-      return ret;
-    }, parents.filter(Boolean).map((p) => this.formatPath(p)));
-  }
-  /**
-  * Select the file system module to use for the operation based on the path or URL.
-  *
-  * @param pathOrUrl - The path to perform the file system operation on.
-  * @param options - Options for the operation, such as output mode.
-  * @returns The file system module used for the operation.
-  */
-  resolveFS(pathOrUrl, options = {}) {
-    const mode = this.resolveOutputMode(pathOrUrl, options);
-    if (mode === "virtual") {
-      return this.#virtualFS;
-    } else if (mode === "fs") {
-      return this.#fs;
-    }
-    return this.#unifiedFS;
-  }
-  /**
-  * Select the file system module to use for the operation based on the path or URL.
-  *
-  * @param pathOrUrl - The path to perform the file system operation on.
-  * @param options - Options for the operation, such as output mode.
-  * @returns The file system module used for the operation.
-  */
-  resolveOutputMode(pathOrUrl, options = {}) {
-    if (options.mode === "virtual" && this.#context.config.output.mode !== "fs" && isParentPath(toFilePath(pathOrUrl), this.#context.artifactsPath)) {
-      return "virtual";
-    } else if (options.mode === "fs" || this.#context.config.output.mode === "fs" || isParentPath(toFilePath(pathOrUrl), this.#context.dataPath) || isParentPath(toFilePath(pathOrUrl), this.#context.cachePath) || isParentPath(toFilePath(pathOrUrl), joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.output.outputPath))) {
-      return "fs";
-    }
-    return void 0;
-  }
-  /**
-  * Clears the resolver cache for a given path.
-  *
-  * @param path - The path to clear the resolver cache for.
-  */
-  clearResolverCache(path) {
-    this.#cachedResolver.keys().filter((key) => key.startsWith(toFilePath(path))).forEach((key) => this.#cachedResolver.delete(key));
-  }
-  /**
-  * Check if the file exists with different variants (index, extensions).
-  *
-  * @param request - The request path to check.
-  * @param parentPath - An optional parent path to prepend to the request.
-  * @returns The file path if it exists, otherwise false.
-  */
-  checkVariants(request, parentPath) {
-    const path = parentPath ? joinPaths(parentPath, request) : request;
-    let file = this.checkExtensions(path);
-    if (file) {
-      return file;
-    }
-    file = this.checkIndex(path);
-    if (file) {
-      return file;
-    }
-    return false;
-  }
-  /**
-  * Check if the index file exists in the given request path.
-  *
-  * @param request - The request path to check.
-  * @returns The index file path if it exists, otherwise false.
-  */
-  checkIndex(request) {
-    let file = joinPaths(request, "index");
-    if (this.#existsSync(file)) {
-      return file;
-    }
-    file = this.checkExtensions(file);
-    if (file) {
-      return file;
-    }
-    return false;
-  }
-  /**
-  * 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;
-  }
-};
-function createVfs(context) {
-  const vfs = new VirtualFileSystem(context);
-  return vfs;
-}
-__name(createVfs, "createVfs");
-
-// src/internal/contexts/context.ts
-var configCache = /* @__PURE__ */ new WeakMap();
-var parseCache = /* @__PURE__ */ new WeakMap();
-var PowerlinesContext = class _PowerlinesContext {
-  static {
-    __name(this, "PowerlinesContext");
-  }
-  #workspaceConfig;
-  #checksum = null;
-  #buildId = uuid();
-  #releaseId = uuid();
-  #timestamp = Date.now();
-  #envPaths;
-  #fs;
-  #tsconfig;
-  #getConfigProps(config = {}) {
-    return {
-      variant: config.build?.variant,
-      projectType: config.type,
-      projectRoot: config.root,
-      name: config.name,
-      title: config.title,
-      description: config.description,
-      sourceRoot: config.sourceRoot,
-      configFile: config.configFile,
-      customLogger: config.customLogger,
-      logLevel: config.logLevel,
-      tsconfig: config.tsconfig,
-      tsconfigRaw: config.tsconfigRaw,
-      skipCache: config.skipCache,
-      skipInstalls: config.skipInstalls,
-      entry: config.entry,
-      output: config.output,
-      plugins: config.plugins,
-      mode: config.mode,
-      lint: config.lint,
-      transform: config.transform,
-      build: config.build,
-      override: config.override,
-      framework: config.framework
-    };
-  }
-  /**
-  * Create a new Storm context from the workspace root and user config.
-  *
-  * @param workspaceRoot - The root directory of the workspace.
-  * @param config - The user configuration options.
-  * @returns A promise that resolves to the new context.
-  */
-  static async from(workspaceRoot, config) {
-    const context = new _PowerlinesContext(await loadWorkspaceConfig(workspaceRoot, config.root));
-    await context.withUserConfig(config);
-    context.powerlinesPath = await resolvePackage("powerlines");
-    if (!context.powerlinesPath) {
-      throw new Error("Could not resolve `powerlines` package location.");
-    }
-    return context;
-  }
-  /**
-  * An object containing the dependencies that should be installed for the project
-  */
-  dependencies = {};
-  /**
-  * An object containing the development dependencies that should be installed for the project
-  */
-  devDependencies = {};
-  /**
-  * The persisted meta information about the current build
-  */
-  persistedMeta = void 0;
-  /**
-  * The path to the Powerlines package
-  */
-  powerlinesPath;
-  /**
-  * The parsed `package.json` file for the project
-  */
-  packageJson;
-  /**
-  * The parsed `project.json` file for the project
-  */
-  projectJson = void 0;
-  /**
-  * The module resolver for the project
-  */
-  resolver;
-  /**
-  * The resolved entry type definitions for the project
-  */
-  get entry() {
-    return resolveEntriesSync(this, toArray(this.config.entry));
-  }
-  /**
-  * The TypeScript configuration parsed from the tsconfig file
-  */
-  get tsconfig() {
-    if (!this.#tsconfig) {
-      this.#tsconfig = {
-        tsconfigFilePath: this.config.tsconfig
-      };
-    }
-    return this.#tsconfig;
-  }
-  /**
-  * Sets the TypeScript configuration parsed from the tsconfig file
-  */
-  set tsconfig(value) {
-    this.#tsconfig = value;
-  }
-  /**
-  * The virtual file system interface for the project
-  */
-  get fs() {
-    if (!this.#fs) {
-      this.#fs = createVfs(this);
-    }
-    return this.#fs;
-  }
-  /**
-  * Get the checksum of the project's current state
-  */
-  get checksum() {
-    return this.#checksum;
-  }
-  /**
-  * The meta information about the current build
-  */
-  get meta() {
-    return {
-      buildId: this.#buildId,
-      releaseId: this.#releaseId,
-      checksum: this.#checksum,
-      timestamp: this.#timestamp,
-      projectRootHash: murmurhash({
-        workspaceRoot: this.workspaceConfig?.workspaceRoot,
-        projectRoot: this.config?.projectRoot
-      }, {
-        maxLength: PROJECT_ROOT_HASH_LENGTH
-      }),
-      configHash: murmurhash(this.config, {
-        maxLength: CACHE_HASH_LENGTH
-      }),
-      builtinIdMap: {},
-      virtualFiles: {}
-    };
-  }
-  /**
-  * The resolved configuration options
-  */
-  get config() {
-    return this.resolvedConfig ?? {};
-  }
-  /**
-  * The logger function
-  */
-  get log() {
-    if (!this.logFn) {
-      this.logFn = this.createLog();
-    }
-    return this.logFn;
-  }
-  /**
-  * The workspace configuration
-  */
-  get workspaceConfig() {
-    return this.#workspaceConfig;
-  }
-  /**
-  * The environment paths for the project
-  */
-  get envPaths() {
-    if (!this.#envPaths) {
-      this.#envPaths = getEnvPaths({
-        orgId: "storm-software",
-        appId: "powerlines",
-        workspaceRoot: this.workspaceConfig.workspaceRoot
-      });
-    }
-    return this.#envPaths;
-  }
-  /**
-  * Get the path to the artifacts directory for the project
-  */
-  get artifactsPath() {
-    return joinPaths$1(this.workspaceConfig.workspaceRoot, this.config.projectRoot, this.config.output.artifactsFolder);
-  }
-  /**
-  * Get the path to the builtin modules used by the project
-  */
-  get builtinsPath() {
-    return joinPaths$1(this.artifactsPath, "builtins");
-  }
-  /**
-  * Get the path to the entry directory for the project
-  */
-  get entryPath() {
-    return joinPaths$1(this.artifactsPath, "entry");
-  }
-  /**
-  * Get the path to the data directory for the project
-  */
-  get dataPath() {
-    return joinPaths$1(this.envPaths.data, "projects", getPrefixedProjectRootHash(this.config.name, this.meta.projectRootHash));
-  }
-  /**
-  * Get the path to the cache directory for the project
-  */
-  get cachePath() {
-    return joinPaths$1(this.envPaths.cache, "projects", murmurhash({
-      checksum: this.#checksum,
-      config: this.meta.configHash
-    }, {
-      maxLength: CACHE_HASH_LENGTH
-    }));
-  }
-  /**
-  * Get the path to the generated declaration file for the project
-  */
-  get dtsPath() {
-    return this.config.output.dts ? appendPath(this.config.output.dts, this.workspaceConfig.workspaceRoot) : joinPaths$1(this.workspaceConfig.workspaceRoot, this.config.projectRoot, "storm.d.ts");
-  }
-  /**
-  * Get the project root relative to the workspace root
-  */
-  get relativeToWorkspaceRoot() {
-    return relativeToWorkspaceRoot(this.config.projectRoot);
-  }
-  /**
-  * The builtin module id that exist in the Powerlines virtual file system
-  */
-  get builtins() {
-    return Object.values(this.fs.meta).filter((meta) => meta && meta.variant === "builtin").map((meta) => meta?.id).filter(Boolean);
-  }
-  /**
-  * Get the project root relative to the workspace root
-  */
-  async getBuiltins() {
-    return Promise.all(Object.entries(this.fs.meta).filter(([, meta]) => meta && meta.variant === "builtin").map(async ([path, meta]) => {
-      const code = await this.fs.readFile(path);
-      return {
-        ...meta,
-        path,
-        code
-      };
-    }));
-  }
-  /**
-  * Resolves a entry virtual file and writes it to the VFS if it does not already exist
-  *
-  * @param code - The source code of the entry file
-  * @param path - A path to write the entry file to
-  * @param options - Optional write file options
-  */
-  async writeEntry(code, path, options = {}) {
-    return this.fs.writeFile(isAbsolute(path) ? path : appendPath(path, this.entryPath), {
-      code,
-      variant: "entry"
-    }, defu3(options, {
-      mode: this.config.output.mode
-    }));
-  }
-  /**
-  * Resolves a builtin virtual file and writes it to the VFS if it does not already exist
-  *
-  * @param code - The source code of the builtin file
-  * @param id - The unique identifier of the builtin file
-  * @param path - An optional path to write the builtin file to
-  * @param options - Optional write file options
-  */
-  async writeBuiltin(code, id, path, options = {}) {
-    return this.fs.writeFile(path ? isAbsolute(path) ? path : joinPaths$1(this.builtinsPath, path) : appendPath(id, this.builtinsPath), {
-      id,
-      code,
-      variant: "builtin"
-    }, defu3(options, {
-      mode: this.config.output.mode
-    }));
-  }
-  /**
-  * Parses the source code and returns a {@link ParseResult} object.
-  *
-  * @param code - The source code to parse.
-  * @param id - The unique identifier for the source file.
-  * @param options - Optional parser options.
-  * @returns The parsed {@link ParseResult} object.
-  */
-  async parse(code, id, options = {}) {
-    if (parseCache.has({
-      code,
-      options
-    })) {
-      return parseCache.get({
-        code,
-        options
-      });
-    }
-    const result = await parseAsync(id, code, defu3(options ?? {}, {
-      lang: hasFileExtension(id) ? void 0 : "ts",
-      astType: hasFileExtension(id) ? void 0 : "ts",
-      sourceType: "module",
-      showSemanticErrors: false
-    }));
-    if (result.errors && result.errors.length > 0) {
-      throw new Error(`Powerlines parsing errors in file: ${id}
-${result.errors.map((error) => `  [${error.severity}] ${error.message}${error.codeframe ? ` (${error.codeframe})` : ""}${error.helpMessage ? `
-    Help: ${error.helpMessage}` : ""}`).join("\n")}`);
-    }
-    parseCache.set({
-      code,
-      options
-    }, result);
-    return result;
-  }
-  /**
-  * Update the context using a new user configuration options
-  *
-  * @param userConfig - The new user configuration options.
-  */
-  async withUserConfig(userConfig, options = {
-    isHighPriority: true
-  }) {
-    this.mergeUserConfig(userConfig);
-    await this.init(this.config.userConfig, options);
-  }
-  /**
-  * Update the context using a new inline configuration options
-  *
-  * @param inlineConfig - The new inline configuration options.
-  */
-  async withInlineConfig(inlineConfig, options = {
-    isHighPriority: true
-  }) {
-    this.config.inlineConfig = inlineConfig;
-    if (inlineConfig.command === "new") {
-      const workspacePackageJsonPath = joinPaths$1(this.workspaceConfig.workspaceRoot, "package.json");
-      if (!existsSync(workspacePackageJsonPath)) {
-        throw new Error(`The workspace package.json file could not be found at ${workspacePackageJsonPath}`);
-      }
-      this.packageJson = await readJsonFile(workspacePackageJsonPath);
-      this.workspaceConfig.repository ??= isSetString(this.packageJson?.repository) ? this.packageJson.repository : this.packageJson?.repository?.url;
-    }
-    await this.init(this.config.inlineConfig, options);
-  }
-  /**
-  * Create a new logger instance
-  *
-  * @param name - The name to use for the logger instance
-  * @returns A logger function
-  */
-  createLog(name = null) {
-    return createLog(name, {
-      ...this.config,
-      logLevel: isNull(this.config.logLevel) ? "silent" : this.config.logLevel
-    });
-  }
-  /**
-  * Extend the current logger instance with a new name
-  *
-  * @param name - The name to use for the extended logger instance
-  * @returns A logger function
-  */
-  extendLog(name) {
-    return extendLog(this.log, name);
-  }
-  /**
-  * Creates a new StormContext instance.
-  *
-  * @param workspaceConfig - The workspace configuration.
-  */
-  constructor(workspaceConfig) {
-    this.#workspaceConfig = workspaceConfig;
-    this.#envPaths = getEnvPaths({
-      orgId: "storm-software",
-      appId: "powerlines",
-      workspaceRoot: workspaceConfig.workspaceRoot
-    });
-  }
-  /**
-  * The resolved configuration for this context
-  */
-  resolvedConfig = {};
-  /**
-  * A logger function specific to this context
-  */
-  logFn;
-  /**
-  * Initialize the context with the provided configuration options
-  *
-  * @param config - The partial user configuration to use for initialization.
-  */
-  async init(config = {}, options = {
-    isHighPriority: true
-  }) {
-    const cacheKey = {
-      projectRoot: config.root ?? this.config.projectRoot ?? this.config.userConfig?.root ?? this.config.inlineConfig?.root,
-      mode: (config.mode ?? this.config.mode) || this.workspaceConfig.mode,
-      skipCache: config.skipCache ?? this.config.skipCache ?? false,
-      configFile: config.configFile ?? this.config.configFile,
-      command: this.config.inlineConfig?.command
-    };
-    if (configCache.has(cacheKey)) {
-      const result = configCache.get(cacheKey);
-      this.projectJson = result.projectJson;
-      this.packageJson = result.packageJson;
-      this.#checksum = result.checksum;
-      this.resolver = result.resolver;
-      this.mergeUserConfig(result.userConfig.config, this.config.userConfig);
-    } else {
-      const projectJsonPath = joinPaths$1(cacheKey.projectRoot, "project.json");
-      if (existsSync(projectJsonPath)) {
-        this.projectJson = await readJsonFile(projectJsonPath);
-      }
-      const packageJsonPath = joinPaths$1(cacheKey.projectRoot, "package.json");
-      if (existsSync(packageJsonPath)) {
-        this.packageJson = await readJsonFile(packageJsonPath);
-      }
-      this.#checksum = await getChecksum(cacheKey.projectRoot);
-      this.resolver = createResolver({
-        workspaceRoot: this.workspaceConfig.workspaceRoot,
-        projectRoot: cacheKey.projectRoot,
-        cacheDir: this.cachePath,
-        mode: cacheKey.mode,
-        skipCache: cacheKey.skipCache
-      });
-      const userConfig = await loadUserConfigFile(cacheKey.projectRoot, this.resolver, cacheKey.command, cacheKey.mode, cacheKey.configFile);
-      this.mergeUserConfig(userConfig.config);
-      configCache.set(cacheKey, {
-        projectJson: this.projectJson,
-        packageJson: this.packageJson,
-        checksum: this.#checksum,
-        resolver: this.resolver,
-        userConfig
-      });
-    }
-    if (isSetObject(config)) {
-      this.resolvedConfig = defu3({
-        inlineConfig: this.config.inlineConfig,
-        userConfig: this.config.userConfig
-      }, options.isHighPriority ? this.#getConfigProps(config) : {}, {
-        command: this.config.inlineConfig?.command,
-        ...this.#getConfigProps(this.config.inlineConfig)
-      }, this.#getConfigProps(this.config.userConfig), {
-        mode: this.workspaceConfig?.mode,
-        logLevel: this.workspaceConfig?.logLevel,
-        skipCache: this.workspaceConfig?.skipCache
-      }, {
-        name: this.projectJson?.name || this.packageJson?.name,
-        version: this.packageJson?.version,
-        description: this.packageJson?.description,
-        tsconfig: appendPath("tsconfig.json", cacheKey.projectRoot),
-        sourceRoot: this.projectJson?.sourceRoot || appendPath("src", cacheKey.projectRoot),
-        output: {
-          outputPath: joinPaths$1("dist", cacheKey.projectRoot),
-          mode: "virtual",
-          dts: joinPaths$1(cacheKey.projectRoot, `${config.framework ?? "powerlines"}.d.ts`),
-          builtinPrefix: config.framework ?? "powerlines",
-          artifactsFolder: joinPaths$1(cacheKey.projectRoot, `.${config.framework ?? "powerlines"}`),
-          assets: [
-            {
-              glob: "LICENSE"
-            },
-            {
-              input: cacheKey.projectRoot,
-              glob: "*.md"
-            },
-            {
-              input: cacheKey.projectRoot,
-              glob: "package.json"
-            }
-          ]
-        }
-      }, options.isHighPriority ? {} : this.#getConfigProps(config), {
-        inlineConfig: {},
-        userConfig: {},
-        framework: "powerlines",
-        platform: "neutral",
-        mode: "production",
-        projectType: "application",
-        logLevel: "info",
-        preview: false,
-        environments: {},
-        transform: {
-          babel: {
-            plugins: [],
-            presets: []
-          }
-        },
-        lint: {
-          eslint: {}
-        },
-        build: {
-          target: "esnext"
-        },
-        override: {}
-      });
-    }
-    this.config.entry = getUniqueEntries(this.config.entry);
-    if (this.config.name?.startsWith("@") && this.config.name.split("/").filter(Boolean).length > 1) {
-      this.config.name = this.config.name.split("/").filter(Boolean)[1];
-    }
-    this.config.title ??= titleCase(this.config.name);
-    if (this.config.build.external) {
-      this.config.build.external = getUnique(this.config.build.external);
-    }
-    if (this.config.build.noExternal) {
-      this.config.build.noExternal = getUnique(this.config.build.noExternal);
-    }
-    this.config.output.format = getUnique(toArray(this.config.output?.format ?? (this.config.projectType === "library" ? [
-      "cjs",
-      "esm"
-    ] : [
-      "esm"
-    ])));
-    this.config.output.outputPath ??= joinPaths$1("dist", this.config.projectRoot || ".");
-    this.config.output.assets = getUnique(this.config.output.assets.map((asset) => {
-      return {
-        glob: isSetObject(asset) ? asset.glob : asset,
-        input: isString(asset) || !asset.input || asset.input === "." || asset.input === "/" || asset.input === "./" ? this.workspaceConfig.workspaceRoot : appendPath(asset.input, this.workspaceConfig.workspaceRoot),
-        output: appendPath(isSetObject(asset) && asset.output ? joinPaths$1(this.config.output.outputPath, replacePath(asset.output, this.config.output.outputPath)) : this.config.output.outputPath, this.workspaceConfig.workspaceRoot),
-        ignore: isSetObject(asset) && asset.ignore ? toArray(asset.ignore) : void 0
-      };
-    }));
-    this.config.plugins = (this.config.plugins ?? []).filter(Boolean).reduce((ret, plugin) => {
-      if (isPlugin(plugin) && checkDedupe(plugin, ret.filter((p) => isPlugin(p)))) {
-        return ret;
-      }
-      ret.push(plugin);
-      return ret;
-    }, []);
-  }
-  mergeUserConfig(from = {}, into = this.config.userConfig ?? {}) {
-    this.config.userConfig = defu3({
-      entry: Array.isArray(from.entry) && from.entry.length > 0 ? from.entry : Array.isArray(into?.entry) && into.entry.length > 0 ? into.entry : []
-    }, omit(from ?? {}, [
-      "entry"
-    ]), omit(into ?? {}, [
-      "entry"
-    ]));
-    if (this.config.userConfig.output?.format) {
-      this.config.userConfig.output.format = getUnique(toArray(this.config.userConfig.output?.format));
-    }
-    this.config.userConfig.plugins = (this.config.userConfig.plugins ?? []).filter(Boolean).reduce((ret, plugin) => {
-      if (isPlugin(plugin) && checkDedupe(plugin, ret.filter((p) => isPlugin(p)))) {
-        return ret;
-      }
-      ret.push(plugin);
-      return ret;
-    }, []);
-  }
-};
-
-// src/types/plugin.ts
-var PLUGIN_NON_HOOK_FIELDS = [
-  "name",
-  "enforce",
-  "dedupe",
-  "dependsOn",
-  "applyToEnvironment"
-];
-async function callHook(context, hook, options, ...args) {
-  const handlers = context.selectHooks(hook, options);
-  if (handlers.length > 0) {
-    context.log(LogLevelLabel.DEBUG, ` \u{1F9E9}  Calling plugin hook: ${chalk4.bold.cyanBright(`${hook}${options?.order ? ` (${options.order})` : ""}`)}`);
-    let results = [];
-    if (options?.sequential === false) {
-      results = await Promise.all(handlers.map(async (handler) => {
-        if (!isFunction(handler)) {
-          throw new Error(`Plugin hook handler for hook "${hook}" is not a function.`);
-        }
-        return Promise.resolve(handler.apply(null, ...args));
-      }));
-    } else {
-      for (const handler of handlers) {
-        if (!isFunction(handler)) {
-          throw new Error(`Plugin hook handler for hook "${hook}" is not a function.`);
-        }
-        results.push(await Promise.resolve(handler.apply(null, ...args)));
-        if (options?.result === "first" && isSet(results[results.length - 1])) {
-          break;
-        }
-      }
-    }
-    const definedResults = results.filter((result) => isSet(result));
-    if (definedResults.length > 0) {
-      let mergedResult = void 0;
-      for (const result of definedResults) {
-        mergedResult = defu(result, mergedResult ?? {});
-      }
-      return mergedResult;
-    }
-  }
-  return void 0;
-}
-__name(callHook, "callHook");
-
-// src/internal/contexts/plugin-context.ts
-function createPluginContext(plugin, environment) {
-  const normalizeMessage = /* @__PURE__ */ __name((message) => {
-    return isString(message) ? message : message.message;
-  }, "normalizeMessage");
-  const log = environment.extendLog(plugin.name);
-  const callHookFn = /* @__PURE__ */ __name(async (hook, options, ...args) => {
-    return callHook(environment, hook, {
-      sequential: true,
-      ...options
-    }, ...args);
-  }, "callHookFn");
-  return new Proxy({}, {
-    get(_, prop) {
-      if (prop === "$$internal") {
-        return {
-          environment,
-          callHook: callHookFn
-        };
-      }
-      if (prop === "log" || prop === "logger") {
-        return log;
-      }
-      if (prop === "error") {
-        return (message) => {
-          log(LogLevelLabel.ERROR, normalizeMessage(message));
-        };
-      }
-      if (prop === "warn") {
-        return (message) => {
-          log(LogLevelLabel.WARN, normalizeMessage(message));
-        };
-      }
-      return environment[prop];
-    },
-    set(_, prop, value) {
-      if ([
-        "$$internal",
-        "environment",
-        "config",
-        "log",
-        "logger",
-        "error",
-        "warn",
-        "plugins",
-        "hooks",
-        "addPlugin",
-        "selectHooks"
-      ].includes(prop)) {
-        log(LogLevelLabel.WARN, `Cannot set read-only property "${String(prop)}"`);
-        return false;
-      }
-      environment[prop] = value;
-      return true;
-    }
-  });
-}
-__name(createPluginContext, "createPluginContext");
-
-// src/internal/contexts/environment-context.ts
-var PowerlinesEnvironmentContext = class _PowerlinesEnvironmentContext extends PowerlinesContext {
-  static {
-    __name(this, "PowerlinesEnvironmentContext");
-  }
-  #hooks = {};
-  /**
-  * Create a new Storm context from the workspace root and user config.
-  *
-  * @param workspaceConfig - The root directory of the workspace.
-  * @param config - The user configuration options.
-  * @returns A promise that resolves to the new context.
-  */
-  static async fromConfig(workspaceConfig, config) {
-    const context = new _PowerlinesEnvironmentContext(config, workspaceConfig);
-    await context.init();
-    context.powerlinesPath = await resolvePackage("powerlines");
-    if (!context.powerlinesPath) {
-      throw new Error("Could not resolve `powerlines` package location.");
-    }
-    return context;
-  }
-  environment;
-  plugins = [];
-  /**
-  * The resolved configuration options
-  */
-  get config() {
-    return super.config;
-  }
-  get hooks() {
-    return this.#hooks;
-  }
-  async addPlugin(plugin) {
-    let resolvedPlugin = plugin;
-    if (plugin.applyToEnvironment) {
-      const result = await Promise.resolve(plugin.applyToEnvironment(this.environment));
-      if (!result || isObject(result) && Object.keys(result).length === 0) {
-        return;
-      }
-      resolvedPlugin = isPlugin(result) ? result : plugin;
-    }
-    const context = createPluginContext(resolvedPlugin, this);
-    this.plugins.push({
-      plugin: resolvedPlugin,
-      context
-    });
-    this.#hooks = Object.keys(resolvedPlugin).filter((key) => !PLUGIN_NON_HOOK_FIELDS.includes(key)).reduce((ret, key) => {
-      const hook = key;
-      const pluginHook = resolvedPlugin[hook];
-      if (!isPluginHook(pluginHook)) {
-        return ret;
-      }
-      if (!isHookExternal(hook)) {
-        ret[hook] ??= {};
-        if (resolvedPlugin.enforce) {
-          ret[hook][`${resolvedPlugin.enforce}Enforced`] ??= [];
-          addPluginHook(context, resolvedPlugin, pluginHook, ret[hook][`${resolvedPlugin.enforce}Enforced`]);
-          return ret;
-        }
-        if (isFunction(pluginHook) || !pluginHook.order) {
-          ret[hook].normal ??= [];
-          addPluginHook(context, resolvedPlugin, pluginHook, ret[hook].normal);
-          return ret;
-        }
-        ret[hook][`${pluginHook.order}Ordered`] ??= [];
-        addPluginHook(context, resolvedPlugin, pluginHook, ret[hook][`${pluginHook.order}Ordered`]);
-      } else {
-        ret[hook] ??= [];
-        ret[hook].push({
-          plugin: resolvedPlugin,
-          hook: getHookHandler(pluginHook).bind(context)
-        });
-      }
-      return ret;
-    }, this.hooks);
-  }
-  /**
-  * Retrieves the hook handlers for a specific hook name
-  */
-  selectHooks(hook, options) {
-    const handlers = [];
-    if (this.hooks[hook]) {
-      if (!isHookExternal(hook)) {
-        const hooks = this.hooks[hook];
-        if (options?.order) {
-          if (options?.order === "pre") {
-            handlers.push(...(hooks.preOrdered ?? []).map((h) => h.handler));
-            handlers.push(...(hooks.preEnforced ?? []).map((h) => h.handler));
-          } else if (options?.order === "post") {
-            handlers.push(...(hooks.postOrdered ?? []).map((h) => h.handler));
-            handlers.push(...(hooks.postEnforced ?? []).map((h) => h.handler));
-          } else {
-            handlers.push(...(hooks.normal ?? []).map((h) => h.handler));
-          }
-        } else {
-          handlers.push(...this.selectHooks(hook, {
-            order: "pre"
-          }));
-          handlers.push(...this.selectHooks(hook, {
-            order: "normal"
-          }));
-          handlers.push(...this.selectHooks(hook, {
-            order: "post"
-          }));
-        }
-      } else {
-        handlers.push(...this.hooks[hook].map((h) => h.handler));
-      }
-    }
-    return handlers;
-  }
-  constructor(config, workspaceConfig) {
-    super(workspaceConfig);
-    this.resolvedConfig = config;
-  }
-};
-
-// src/internal/contexts/api-context.ts
-var PowerlinesAPIContext = class _PowerlinesAPIContext extends PowerlinesContext {
-  static {
-    __name(this, "PowerlinesAPIContext");
-  }
-  #environments = {};
-  #plugins = [];
-  #log;
-  /**
-  * Create a new Storm context from the workspace root and user config.
-  *
-  * @param workspaceRoot - The root directory of the workspace.
-  * @param config - The user configuration options.
-  * @returns A promise that resolves to the new context.
-  */
-  static async from(workspaceRoot, config) {
-    const context = new _PowerlinesAPIContext(await loadWorkspaceConfig(workspaceRoot, config.root));
-    await context.withUserConfig(config);
-    context.powerlinesPath = await resolvePackage("powerlines");
-    if (!context.powerlinesPath) {
-      throw new Error("Could not resolve `powerlines` package location.");
-    }
-    return context;
-  }
-  /**
-  * A record of all environments by name
-  */
-  get environments() {
-    return this.#environments;
-  }
-  get log() {
-    if (!this.#log) {
-      this.#log = this.createLog("engine");
-    }
-    return this.#log;
-  }
-  get plugins() {
-    return this.#plugins;
-  }
-  constructor(workspaceConfig) {
-    super(workspaceConfig);
-  }
-  /**
-  * Initialize the context with the provided configuration options
-  *
-  * @param config - The partial user configuration to use for initialization.
-  */
-  async init(config = {}) {
-    await super.init(config);
-    await Promise.all(toArray(this.config.userConfig.environments && Object.keys(this.config.userConfig.environments).length > 0 ? Object.keys(this.config.userConfig.environments).map((name) => createEnvironment(name, this.config.userConfig)) : createDefaultEnvironment(this.config.userConfig)).map(async (env) => {
-      this.#environments[env.name] = await this.in(env);
-    }));
-  }
-  /**
-  * A function to copy the context and update the fields for a specific environment
-  *
-  * @param environment - The environment configuration to use.
-  * @returns A new context instance with the updated environment.
-  */
-  async in(environment) {
-    let context;
-    if (this.environments[environment.name]) {
-      context = this.environments[environment.name];
-    } else {
-      context = await PowerlinesEnvironmentContext.fromConfig(this.workspaceConfig, this.config);
-    }
-    if (isSetObject(this.config.inlineConfig)) {
-      await context.withInlineConfig(this.config.inlineConfig);
-    }
-    context.environment = environment;
-    context.plugins = [];
-    for (const plugin of this.plugins) {
-      await context.addPlugin(plugin);
-    }
-    return context;
-  }
-  async addPlugin(plugin) {
-    this.plugins.push(plugin);
-    await Promise.all(Object.keys(this.environments).map(async (name) => {
-      await this.environments[name].addPlugin(plugin);
-    }));
-  }
-  async getEnvironment(name) {
-    let environment;
-    if (name) {
-      environment = this.environments[name];
-    }
-    if (Object.keys(this.environments).length === 1) {
-      environment = this.environments[Object.keys(this.environments)[0]];
-      this.log(LogLevelLabel.DEBUG, `Applying the only configured environment: ${chalk4.bold.cyanBright(environment?.environment.name)}`);
-    }
-    if (!environment) {
-      if (name) {
-        throw new Error(`Environment "${name}" not found.`);
-      }
-      environment = await this.in(createDefaultEnvironment(this.config.userConfig));
-      this.log(LogLevelLabel.WARN, `No environment specified, and no default environment found. Using a temporary default environment: ${chalk4.bold.cyanBright(environment?.environment.name)}`);
-    }
-    return environment;
-  }
-  async getEnvironmentSafe(name) {
-    try {
-      return await this.getEnvironment(name);
-    } catch {
-      return void 0;
-    }
-  }
-};
-function resolveModulePath(nodePath, state) {
-  if (!t.isStringLiteral(nodePath.node)) {
-    return;
-  }
-  const sourcePath = nodePath.node.value;
-  const resolvedPath = state.context?.fs.resolve(sourcePath);
-  if (resolvedPath) {
-    nodePath.replaceWith(t.stringLiteral(
-      // Remove the file extension if it exists
-      resolvedPath.replace(/\.(?:ts|mts|cts)x?$/, "")
-    ));
-  }
-}
-__name(resolveModulePath, "resolveModulePath");
-var TRANSFORM_FUNCTIONS = [
-  "require",
-  "require.resolve",
-  "System.import",
-  // Jest methods
-  "jest.genMockFromModule",
-  "jest.mock",
-  "jest.unmock",
-  "jest.doMock",
-  // eslint-disable-next-line @cspell/spellchecker
-  "jest.dontMock",
-  "jest.setMock",
-  "jest.requireActual",
-  "jest.requireMock",
-  // Older Jest methods
-  "require.requireActual",
-  "require.requireMock"
-];
-function matchesPattern(state, calleePath, pattern) {
-  const { node } = calleePath;
-  if (t.isMemberExpression(node)) {
-    return calleePath.matchesPattern(pattern);
-  }
-  if (!t.isIdentifier(node) || pattern.includes(".")) {
-    return false;
-  }
-  const name = pattern.split(".")[0];
-  return node.name === name;
-}
-__name(matchesPattern, "matchesPattern");
-var importVisitors = {
-  CallExpression: /* @__PURE__ */ __name((nodePath, state) => {
-    if (state.moduleResolverVisited.has(nodePath)) {
-      return;
-    }
-    const calleePath = nodePath.get("callee");
-    if (calleePath && TRANSFORM_FUNCTIONS.some((pattern) => matchesPattern(state, calleePath, pattern)) || t.isImport(nodePath.node.callee)) {
-      state.moduleResolverVisited.add(nodePath);
-      resolveModulePath(nodePath.get("arguments.0"), state);
-    }
-  }, "CallExpression"),
-  // eslint-disable-next-line ts/naming-convention
-  "ImportDeclaration|ExportDeclaration|ExportAllDeclaration": /* @__PURE__ */ __name((nodePath, state) => {
-    if (!nodePath || !nodePath.get("source") || state.moduleResolverVisited.has(nodePath)) {
-      return;
-    }
-    state.moduleResolverVisited.add(nodePath);
-    resolveModulePath(nodePath.get("source"), state);
-  }, "ImportDeclaration|ExportDeclaration|ExportAllDeclaration")
-};
-var moduleResolverBabelPlugin = /* @__PURE__ */ __name((context) => {
-  return declare(/* @__PURE__ */ __name(function builder(api) {
-    let moduleResolverVisited = /* @__PURE__ */ new Set();
-    return {
-      name: "powerlines:module-resolver",
-      manipulateOptions(opts) {
-        opts.filename ??= "unknown";
-      },
-      pre() {
-        moduleResolverVisited = /* @__PURE__ */ new Set();
-      },
-      visitor: {
-        Program: {
-          enter(programPath, state) {
-            programPath.traverse(importVisitors, {
-              ...state,
-              context,
-              moduleResolverVisited,
-              api
-            });
-          },
-          exit(programPath, state) {
-            programPath.traverse(importVisitors, {
-              ...state,
-              context,
-              moduleResolverVisited,
-              api
-            });
-          }
-        }
-      },
-      post() {
-        moduleResolverVisited.clear();
-      }
-    };
-  }, "builder"));
-}, "moduleResolverBabelPlugin");
-
-// src/internal/helpers/generate-types.ts
-async function generateTypes(context) {
-  context.log(LogLevelLabel.TRACE, `Preparing the TypeScript definitions for the Powerlines project.`);
-  context.log(LogLevelLabel.TRACE, "Transforming built-ins runtime modules files.");
-  const builtinFiles = await context.getBuiltins();
-  const builtinFilePaths = await Promise.all(builtinFiles.map(async (file) => {
-    const result = await transformAsync(file.code.toString(), {
-      highlightCode: true,
-      code: true,
-      ast: false,
-      cloneInputAst: false,
-      comments: true,
-      sourceType: "module",
-      configFile: false,
-      babelrc: false,
-      envName: context.config.mode,
-      caller: {
-        name: "powerlines"
-      },
-      ...context.config.transform.babel,
-      filename: file.path,
-      plugins: [
-        [
-          "@babel/plugin-syntax-typescript"
-        ],
-        [
-          moduleResolverBabelPlugin(context)
-        ]
-      ]
-    });
-    if (!result?.code) {
-      throw new Error(`Powerlines - Generate Types failed to compile ${file.id}`);
-    }
-    context.log(LogLevelLabel.TRACE, `Writing transformed built-in runtime file ${file.id}.`);
-    await context.writeBuiltin(result.code, file.id, file.path);
-    return file.path;
-  }));
-  const typescriptPath = await resolvePackage("typescript");
-  if (!typescriptPath) {
-    throw new Error("Could not resolve TypeScript package location. Please ensure TypeScript is installed.");
-  }
-  const files = builtinFilePaths.reduce((ret, fileName) => {
-    const formatted = replacePath(fileName, context.workspaceConfig.workspaceRoot);
-    if (!ret.includes(formatted)) {
-      ret.push(formatted);
-    }
-    return ret;
-  }, [
-    joinPaths(typescriptPath, "lib", "lib.esnext.full.d.ts")
-  ]);
-  context.log(LogLevelLabel.TRACE, "Parsing TypeScript configuration for the Powerlines project.");
-  const resolvedTsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.tsconfig.tsconfigFilePath, defu3({
-    compilerOptions: {
-      strict: false,
-      noEmit: false,
-      declaration: true,
-      declarationMap: false,
-      emitDeclarationOnly: true,
-      skipLibCheck: true
-    },
-    exclude: [
-      "node_modules",
-      "dist"
-    ],
-    include: files
-  }, context.config.tsconfigRaw ?? {}));
-  resolvedTsconfig.options.configFilePath = joinPaths(context.workspaceConfig.workspaceRoot, context.tsconfig.tsconfigFilePath);
-  resolvedTsconfig.options.pathsBasePath = context.workspaceConfig.workspaceRoot;
-  resolvedTsconfig.options.suppressOutputPathCheck = true;
-  context.log(LogLevelLabel.TRACE, "Creating the TypeScript compiler host");
-  const program = createProgram(files, resolvedTsconfig.options, createCompilerHost(resolvedTsconfig.options));
-  context.log(LogLevelLabel.TRACE, `Running TypeScript compiler on ${builtinFiles.length} built-in runtime files.`);
-  let builtinModules = "";
-  const emitResult = program.emit(void 0, (fileName, text, _, __, sourceFiles, _data) => {
-    const sourceFile2 = sourceFiles?.[0];
-    if (sourceFile2?.fileName && !fileName.endsWith(".map")) {
-      if (builtinFiles.some((file) => file.id === sourceFile2.fileName || file.path === sourceFile2.fileName)) {
-        builtinModules += `
-declare module "${context.fs.resolve(sourceFile2.fileName)}" {
-    ${text.trim().replace(/^\s*export\s*declare\s*/gm, "export ").replace(/^\s*declare\s*/gm, "")}
-}
-`;
-      }
-    }
-  }, void 0, true);
-  const diagnostics = getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
-  const diagnosticMessages = [];
-  diagnostics.forEach((diagnostic) => {
-    if (diagnostic.file) {
-      const { line, character } = getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
-      const message = flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-      diagnosticMessages.push(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
-    } else {
-      const message = flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-      diagnosticMessages.push(message);
-    }
-  });
-  const diagnosticMessage = diagnosticMessages.join("\n");
-  if (diagnosticMessage) {
-    throw new Error(`TypeScript compilation failed: 
-
-${diagnosticMessage.length > 5e3 ? `${diagnosticMessage.slice(0, 5e3)}...` : diagnosticMessage}`);
-  }
-  context.log(LogLevelLabel.TRACE, `Generating TypeScript declaration file in ${context.config.output.dts}.`);
-  const sourceFile = getSourceFile(String(context.config.output.dts), `/// <reference types="powerlines/shared" />${context.config.build.platform !== "neutral" ? `
-/// <reference types="powerlines/${context.config.build.platform}" />` : ""}
-
-${getFileHeader(context, {
-    directive: null,
-    prettierIgnore: false
-  })}
-
-${builtinModules}`.replace(
-    // eslint-disable-next-line regexp/no-super-linear-backtracking
-    /import\s*(?:type\s*)?\{?[\w,\s]*(?:\}\s*)?from\s*(?:'|")@?[a-zA-Z0-9-\\/.]*(?:'|");?/g,
-    ""
-  ).replaceAll("#private;", "").replace(/__Ω/g, ""));
-  await context.fs.writeFile(sourceFile.id, getString(sourceFile.code), {
-    mode: "fs"
-  });
-}
-__name(generateTypes, "generateTypes");
-async function installPackage(context, packageName, dev = false) {
-  if (!await isPackageListed(getPackageName(packageName), {
-    cwd: context.config.projectRoot
-  })) {
-    if (context.config.skipInstalls !== true && !process.env.POWERLINES_LOCAL) {
-      context.log(LogLevelLabel.WARN, `The package "${packageName}" is not installed. It will be installed automatically.`);
-      const result = await install(packageName, {
-        cwd: context.config.projectRoot,
-        dev
-      });
-      if (isNumber(result.exitCode) && result.exitCode > 0) {
-        context.log(LogLevelLabel.ERROR, result.stderr);
-        throw new Error(`An error occurred while installing the package "${packageName}"`);
-      }
-    } else {
-      context.log(LogLevelLabel.WARN, `The package "${packageName}" is not installed. Since the "skipInstalls" option is set to true, it will not be installed automatically.`);
-    }
-  } else if (hasPackageVersion(packageName) && !process.env.POWERLINES_SKIP_VERSION_CHECK) {
-    const isMatching = await doesPackageMatch(getPackageName(packageName), getPackageVersion(packageName), context.config.projectRoot);
-    if (!isMatching) {
-      const packageListing = await getPackageListing(getPackageName(packageName), {
-        cwd: context.config.projectRoot
-      });
-      if (!packageListing?.version.startsWith("catalog:") && !packageListing?.version.startsWith("workspace:")) {
-        context.log(LogLevelLabel.WARN, `The package "${getPackageName(packageName)}" is installed but does not match the expected version ${getPackageVersion(packageName)} (installed version: ${packageListing?.version || "<Unknown>"}). Please ensure this is intentional before proceeding. Note: You can skip this validation with the "STORM_STACK_SKIP_VERSION_CHECK" environment variable.`);
-      }
-    }
-  }
-}
-__name(installPackage, "installPackage");
-
-// src/internal/helpers/install-dependencies.ts
-async function installDependencies(context) {
-  context.log(LogLevelLabel.TRACE, `Checking and installing missing project dependencies.`);
-  context.dependencies ??= {};
-  context.log(LogLevelLabel.TRACE, `The following packages are required: 
-Dependencies: 
-${Object.entries(context.dependencies).map(([name, version]) => `- ${name}@${String(version)}`).join(" \n")}
-
-DevDependencies: 
-${Object.entries(context.devDependencies).map(([name, version]) => `- ${name}@${String(version)}`).join(" \n")}`);
-  await Promise.all([
-    Promise.all(Object.entries(context.dependencies).map(async ([name, version]) => installPackage(context, `${getPackageName(name)}@${String(version)}`, false))),
-    Promise.all(Object.entries(context.devDependencies).map(async ([name, version]) => installPackage(context, `${getPackageName(name)}@${String(version)}`, true)))
-  ]);
-}
-__name(installDependencies, "installDependencies");
-async function resolveTsconfigChanges(context) {
-  const tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig, context.config.tsconfigRaw);
-  const tsconfigFilePath = getTsconfigFilePath(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
-  const tsconfigJson = await readJsonFile(tsconfigFilePath);
-  tsconfigJson.compilerOptions ??= {};
-  const extendedTsconfig = await loadTsConfig(tsconfigFilePath);
-  extendedTsconfig.compilerOptions ??= {};
-  if (tsconfigJson.reflection !== true) {
-    tsconfigJson.reflection = true;
-  }
-  if (tsconfig.options.experimentalDecorators !== true) {
-    tsconfigJson.compilerOptions.experimentalDecorators = true;
-  }
-  if (tsconfig.options.emitDecoratorMetadata !== true) {
-    tsconfigJson.compilerOptions.emitDecoratorMetadata = true;
-  }
-  if (context.config.output.dts) {
-    const dtsFilePath = context.config.output.dts ? context.config.output.dts.startsWith(context.workspaceConfig.workspaceRoot) ? context.config.output.dts : joinPaths(context.workspaceConfig.workspaceRoot, context.config.output.dts) : joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot, "storm.d.ts");
-    const dtsRelativePath = joinPaths(relativePath(joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot), findFilePath(dtsFilePath)), findFileName(dtsFilePath));
-    if (!tsconfigJson.include?.some((filePattern) => isIncludeMatchFound(filePattern, [
-      dtsFilePath,
-      dtsRelativePath,
-      "storm.d.ts"
-    ]))) {
-      tsconfigJson.include ??= [];
-      tsconfigJson.include.push(dtsRelativePath.startsWith("./") ? dtsRelativePath.slice(2) : dtsRelativePath);
-    }
-  }
-  if (!tsconfig.options.lib?.some((lib) => [
-    "lib.esnext.d.ts",
-    "lib.es2021.d.ts",
-    "lib.es2022.d.ts",
-    "lib.es2023.d.ts"
-  ].includes(lib.toLowerCase()))) {
-    tsconfigJson.compilerOptions.lib ??= [];
-    tsconfigJson.compilerOptions.lib.push("esnext");
-  }
-  if (tsconfig.options.module !== ts.ModuleKind.ESNext) {
-    tsconfigJson.compilerOptions.module = "ESNext";
-  }
-  if (!tsconfig.options.target || ![
-    ts.ScriptTarget.ESNext,
-    ts.ScriptTarget.ES2024,
-    ts.ScriptTarget.ES2023,
-    ts.ScriptTarget.ES2022,
-    ts.ScriptTarget.ES2021
-  ].includes(tsconfig.options.target)) {
-    tsconfigJson.compilerOptions.target = "ESNext";
-  }
-  if (tsconfig.options.moduleResolution !== ts.ModuleResolutionKind.Bundler) {
-    tsconfigJson.compilerOptions.moduleResolution = "Bundler";
-  }
-  if (tsconfig.options.moduleDetection !== ts.ModuleDetectionKind.Force) {
-    tsconfigJson.compilerOptions.moduleDetection = "force";
-  }
-  if (tsconfig.options.allowSyntheticDefaultImports !== true) {
-    tsconfigJson.compilerOptions.allowSyntheticDefaultImports = true;
-  }
-  if (tsconfig.options.noImplicitOverride !== true) {
-    tsconfigJson.compilerOptions.noImplicitOverride = true;
-  }
-  if (tsconfig.options.noUncheckedIndexedAccess !== true) {
-    tsconfigJson.compilerOptions.noUncheckedIndexedAccess = true;
-  }
-  if (tsconfig.options.skipLibCheck !== true) {
-    tsconfigJson.compilerOptions.skipLibCheck = true;
-  }
-  if (tsconfig.options.resolveJsonModule !== true) {
-    tsconfigJson.compilerOptions.resolveJsonModule = true;
-  }
-  if (tsconfig.options.isolatedModules !== true) {
-    tsconfigJson.compilerOptions.isolatedModules = true;
-  }
-  if (tsconfig.options.verbatimModuleSyntax !== false) {
-    tsconfigJson.compilerOptions.verbatimModuleSyntax = false;
-  }
-  if (tsconfig.options.allowJs !== true) {
-    tsconfigJson.compilerOptions.allowJs = true;
-  }
-  if (tsconfig.options.esModuleInterop !== true) {
-    tsconfigJson.compilerOptions.esModuleInterop = true;
-  }
-  if (tsconfig.options.declaration !== true) {
-    tsconfigJson.compilerOptions.declaration = true;
-  }
-  if (context.environment.consumer === "client") {
-    if (tsconfig.options.jsx !== ts.JsxEmit.ReactJSX) {
-      tsconfigJson.compilerOptions.jsx = "react-jsx";
-    }
-    if (!tsconfig.options.lib?.some((lib) => lib.toLowerCase() !== "dom")) {
-      tsconfigJson.compilerOptions.lib ??= [];
-      tsconfigJson.compilerOptions.lib.push("dom");
-    }
-    if (!tsconfig.options.lib?.some((lib) => lib.toLowerCase() !== "dom.iterable")) {
-      tsconfigJson.compilerOptions.lib ??= [];
-      tsconfigJson.compilerOptions.lib.push("dom.iterable");
-    }
-  } else if (context.config.build.platform === "node") {
-    if (!tsconfig.options.types?.some((type) => type.toLowerCase() === "node" || type.toLowerCase() === "@types/node")) {
-      tsconfigJson.compilerOptions.types ??= [];
-      tsconfigJson.compilerOptions.types.push("node");
-    }
-  }
-  return tsconfigJson;
-}
-__name(resolveTsconfigChanges, "resolveTsconfigChanges");
-async function initializeTsconfig(context) {
-  context.log(LogLevelLabel.TRACE, "Initializing TypeScript configuration (tsconfig.json) for the Powerlines project.");
-  if (!isPackageExists("typescript")) {
-    throw new Error('The TypeScript package is not installed. Please install the package using the command: "npm install typescript --save-dev"');
-  }
-  const tsconfigFilePath = getTsconfigFilePath(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
-  context.tsconfig.originalTsconfigJson = await readJsonFile(tsconfigFilePath);
-  context.tsconfig.tsconfigJson = await resolveTsconfigChanges(context);
-  await context.fs.writeFile(tsconfigFilePath, StormJSON.stringify(context.tsconfig.tsconfigJson), {
-    mode: "fs"
-  });
-  context.tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig, context.config.tsconfigRaw, context.tsconfig.originalTsconfigJson);
-}
-__name(initializeTsconfig, "initializeTsconfig");
-async function resolveTsconfig(context) {
-  const updateTsconfigJson = await readJsonFile(context.tsconfig.tsconfigFilePath);
-  if (updateTsconfigJson?.compilerOptions?.types && Array.isArray(updateTsconfigJson.compilerOptions.types) && !updateTsconfigJson.compilerOptions.types.length) {
-    delete updateTsconfigJson.compilerOptions.types;
-  }
-  const result = getObjectDiff(context.tsconfig.originalTsconfigJson, updateTsconfigJson, {
-    ignoreArrayOrder: true,
-    showOnly: {
-      statuses: [
-        "added",
-        "deleted",
-        "updated"
-      ],
-      granularity: "deep"
-    }
-  });
-  const changes = [];
-  const getChanges = /* @__PURE__ */ __name((difference, property) => {
-    if (difference.status === "added" || difference.status === "deleted" || difference.status === "updated") {
-      if (difference.diff) {
-        for (const diff of difference.diff) {
-          getChanges(diff, property ? `${property}.${difference.property}` : difference.property);
-        }
-      } else {
-        changes.push({
-          field: property ? `${property}.${difference.property}` : difference.property,
-          status: difference.status,
-          previous: difference.status === "added" ? "---" : StormJSON.stringify(difference.previousValue),
-          current: difference.status === "deleted" ? "---" : StormJSON.stringify(difference.currentValue)
-        });
-      }
-    }
-  }, "getChanges");
-  for (const diff of result.diff) {
-    getChanges(diff);
-  }
-  if (changes.length > 0) {
-    context.log(LogLevelLabel.WARN, `Updating the following configuration values in "${context.tsconfig.tsconfigFilePath}" file:
-
-    ${changes.map((change, i) => `${chalk4.bold.whiteBright(`${i + 1}. ${titleCase(change.status)} the ${change.field} field: `)}
-    ${chalk4.red(` - Previous: ${change.previous} `)}
-    ${chalk4.green(` - Updated: ${change.current} `)}
-  `).join("\n")}
-    `);
-  }
-  await writeFile(context.log, context.tsconfig.tsconfigFilePath, StormJSON.stringify(updateTsconfigJson));
-  context.tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
-  if (!context.tsconfig) {
-    throw new Error("Failed to parse the TypeScript configuration file.");
-  }
-  context.tsconfig.tsconfigJson.compilerOptions ??= {};
-  context.tsconfig.tsconfigJson.compilerOptions.strict = false;
-}
-__name(resolveTsconfig, "resolveTsconfig");
-
-// src/internal/api.ts
-var PowerlinesAPI = class _PowerlinesAPI {
-  static {
-    __name(this, "PowerlinesAPI");
-  }
-  /**
-  * The Powerlines context
-  */
-  #context;
-  /**
-  * The Powerlines context
-  */
-  get context() {
-    return this.#context;
-  }
-  /**
-  * Create a new Powerlines API instance
-  *
-  * @param context - The Powerlines context
-  */
-  constructor(context) {
-    this.#context = context;
-  }
-  /**
-  * Initialize the Powerlines API
-  */
-  static async from(workspaceRoot, config) {
-    const api = new _PowerlinesAPI(await PowerlinesAPIContext.from(workspaceRoot, config));
-    for (const plugin of api.context.config.plugins ?? []) {
-      await api.#addPlugin(plugin);
-    }
-    if (api.context.plugins.length === 0) {
-      api.context.log(LogLevelLabel.WARN, "No Powerlines plugins were specified in the options. Please ensure this is correct, as it is generally not recommended.");
-    }
-    const pluginConfig = await callHook(await api.context.getEnvironment(), "config", {
-      sequential: true,
-      result: "merge"
-    });
-    await api.context.withUserConfig(pluginConfig, {
-      isHighPriority: false
-    });
-    return api;
-  }
-  /**
-  * Prepare the Powerlines API
-  */
-  async prepare(inlineConfig = {
-    command: "prepare"
-  }) {
-    this.context.log(LogLevelLabel.TRACE, " \u{1F3D7}\uFE0F  Preparing the Powerlines project");
-    this.context.log(LogLevelLabel.TRACE, " \u2699\uFE0F  Aggregating configuration options for the Powerlines project");
-    await this.context.withInlineConfig(inlineConfig);
-    await this.#executeEnvironments(async (context) => {
-      context.log(LogLevelLabel.TRACE, `Initializing the processing options for the Powerlines project.`);
-      await this.callPreHook(context, "configResolved");
-      await initializeTsconfig(context);
-      await this.callNormalHook(context, "configResolved");
-      context.log(LogLevelLabel.DEBUG, `The configuration provided ${toArray(context.config.entry).length} entry point(s), Powerlines has found ${context.entry.length} entry files(s) for the ${context.config.title} project${context.entry.length > 0 && context.entry.length < 10 ? `: 
-${context.entry.map((entry) => `- ${entry.input.file || entry.file}${entry.output ? ` -> ${entry.output}` : ""}`).join(" \n")}` : ""}.`);
-      await resolveTsconfig(context);
-      await installDependencies(context);
-      await this.callPostHook(context, "configResolved");
-      context.log(LogLevelLabel.TRACE, `Powerlines configuration has been resolved: 
-
-${formatLogMessage(context.config)}`);
-      context.fs[__VFS_INIT__]();
-      await writeMetaFile(context);
-      context.persistedMeta = context.meta;
-      if (!existsSync(context.cachePath)) {
-        await createDirectory(context.cachePath);
-      }
-      if (!existsSync(context.dataPath)) {
-        await createDirectory(context.dataPath);
-      }
-      await this.callPreHook(context, "prepare");
-      if (context.config.projectType === "application") {
-        context.log(LogLevelLabel.TRACE, "Generating built-in barrel file");
-      }
-      if (context.config.output.dts !== false) {
-        await generateTypes(context);
-      }
-      await this.callNormalHook(context, "prepare");
-      context.tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
-      if (!context.tsconfig) {
-        throw new Error("Failed to parse the TypeScript configuration file.");
-      }
-      await this.callPostHook(context, "prepare");
-      await writeMetaFile(context);
-      context.fs[__VFS_REVERT__]();
-    });
-    this.context.log(LogLevelLabel.INFO, "Powerlines API has been prepared successfully");
-  }
-  /**
-  * Create a new Powerlines project
-  *
-  * @remarks
-  * This method will create a new Powerlines project in the current directory.
-  *
-  * @param inlineConfig - The inline configuration for the new command
-  * @returns A promise that resolves when the project has been created
-  */
-  async new(inlineConfig) {
-    this.context.log(LogLevelLabel.INFO, "\u{1F195} Creating a new Powerlines project");
-    await this.prepare(inlineConfig);
-    await this.#executeEnvironments(async (context) => {
-      context.log(LogLevelLabel.TRACE, `Initializing the processing options for the Powerlines project.`);
-      await this.callPreHook(context, "new");
-      const files = await listFiles(joinPaths(context.powerlinesPath, "files/common/**/*.hbs"));
-      for (const file of files) {
-        context.log(LogLevelLabel.TRACE, `Adding template file: ${file}`);
-        const template = Handlebars.compile(file);
-        await writeFile(context.log, joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
-      }
-      await this.callNormalHook(context, "new");
-      if (context.config.projectType === "application") {
-        const files2 = await listFiles(joinPaths(context.powerlinesPath, "files/application/**/*.hbs"));
-        for (const file of files2) {
-          context.log(LogLevelLabel.TRACE, `Adding application template file: ${file}`);
-          const template = Handlebars.compile(file);
-          await writeFile(context.log, joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
-        }
-      } else {
-        const files2 = await listFiles(joinPaths(context.powerlinesPath, "files/library/**/*.hbs"));
-        for (const file of files2) {
-          context.log(LogLevelLabel.TRACE, `Adding library template file: ${file}`);
-          const template = Handlebars.compile(file);
-          await writeFile(context.log, joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
-        }
-      }
-      await this.callPostHook(context, "new");
-    });
-    this.context.log(LogLevelLabel.TRACE, "Powerlines - New command completed");
-  }
-  /**
-  * Clean any previously prepared artifacts
-  *
-  * @remarks
-  * This method will remove the previous Powerlines artifacts from the project.
-  *
-  * @param inlineConfig - The inline configuration for the clean command
-  * @returns A promise that resolves when the clean command has completed
-  */
-  async clean(inlineConfig = {
-    command: "clean"
-  }) {
-    this.context.log(LogLevelLabel.INFO, "\u{1F9F9} Cleaning the previous Powerlines artifacts");
-    await this.prepare(inlineConfig);
-    await this.#executeEnvironments(async (context) => {
-      await callHook(context, "clean", {
-        sequential: true
-      });
-    });
-    this.context.log(LogLevelLabel.TRACE, "Powerlines - Clean command completed");
-  }
-  /**
-  * Lint the project
-  *
-  * @param inlineConfig - The inline configuration for the lint command
-  * @returns A promise that resolves when the lint command has completed
-  */
-  async lint(inlineConfig = {
-    command: "lint"
-  }) {
-    this.context.log(LogLevelLabel.INFO, "\u{1F4CB} Linting the Powerlines project");
-    await this.prepare(inlineConfig);
-    await this.#executeEnvironments(async (context) => {
-      if (context.config.lint !== false) {
-        await this.callHook(context, "lint");
-      }
-    });
-    this.context.log(LogLevelLabel.TRACE, "Powerlines linting completed");
-  }
-  /**
-  * Build the project
-  *
-  * @remarks
-  * This method will build the Powerlines project, generating the necessary artifacts.
-  *
-  * @param inlineConfig - The inline configuration for the build command
-  * @returns A promise that resolves when the build command has completed
-  */
-  async build(inlineConfig = {
-    command: "build"
-  }) {
-    this.context.log(LogLevelLabel.INFO, "\u{1F4E6}  Building the Powerlines project");
-    await this.prepare(inlineConfig);
-    await this.#executeEnvironments(async (context) => {
-      await this.callPreHook(context, "build");
-      await this.callNormalHook(context, "build");
-      await Promise.all(context.config.output.assets.map(async (asset) => {
-        context.log(LogLevelLabel.DEBUG, `Copying asset(s): ${chalk4.redBright(context.workspaceConfig.workspaceRoot === asset.input ? asset.glob : joinPaths(replacePath(asset.input, context.workspaceConfig.workspaceRoot), asset.glob))} -> ${chalk4.greenBright(joinPaths(replacePath(asset.output, context.workspaceConfig.workspaceRoot), asset.glob))} ${Array.isArray(asset.ignore) && asset.ignore.length > 0 ? ` (ignoring: ${asset.ignore.map((i) => chalk4.yellowBright(i)).join(", ")})` : ""}`);
-        await copyFiles(asset, asset.output);
-      }));
-      await this.callPostHook(context, "build");
-    });
-    this.context.log(LogLevelLabel.TRACE, "Powerlines build completed");
-  }
-  /**
-  * Prepare the documentation for the project
-  *
-  * @param inlineConfig - The inline configuration for the docs command
-  * @returns A promise that resolves when the documentation generation has completed
-  */
-  async docs(inlineConfig = {
-    command: "docs"
-  }) {
-    this.context.log(LogLevelLabel.INFO, "\u{1F4D3} Generating documentation for the Powerlines project");
-    await this.prepare(inlineConfig);
-    await this.#executeEnvironments(async (context) => {
-      context.log(LogLevelLabel.TRACE, "Writing documentation for the Powerlines project artifacts.");
-      await this.prepare(inlineConfig);
-      await this.#executeEnvironments(async (context2) => {
-        await this.callHook(context2, "docs");
-      });
-    });
-    this.#context.log(LogLevelLabel.TRACE, "Powerlines documentation generation completed");
-  }
-  /**
-  * Release the project
-  *
-  * @remarks
-  * This method will prepare and build the Powerlines project, generating the necessary artifacts for release.
-  *
-  * @param inlineConfig - The inline configuration for the release command
-  */
-  async release(inlineConfig = {
-    command: "release"
-  }) {
-    this.context.log(LogLevelLabel.INFO, "\u{1F4E6} Releasing the Powerlines project");
-    await this.prepare(inlineConfig);
-    await this.#executeEnvironments(async (context) => {
-      await this.callHook(context, "release");
-    });
-    this.context.log(LogLevelLabel.TRACE, "Powerlines release completed");
-  }
-  /**
-  * Finalization process
-  *
-  * @remarks
-  * This step includes any final processes or clean up required by Powerlines. It will be run after each Powerlines command.
-  *
-  * @returns A promise that resolves when the finalization process has completed
-  */
-  async finalize() {
-    this.context.log(LogLevelLabel.TRACE, "Powerlines finalize execution started");
-    await this.#executeEnvironments(async (context) => {
-      await this.callHook(context, "finalize");
-      context.fs[__VFS_REVERT__]();
-    });
-    this.context.log(LogLevelLabel.TRACE, "Powerlines finalize execution completed");
-  }
-  /**
-  * Calls a hook in parallel
-  *
-  * @param hook - The hook to call
-  * @param options - Options for calling the hook
-  * @param args - The arguments to pass to the hook
-  * @returns The result of the hook call
-  */
-  async callHookParallel(hook, options, ...args) {
-    return callHook(isSetObject(options?.environment) ? options.environment : await this.#context.getEnvironment(options?.environment), hook, {
-      ...options,
-      sequential: false
-    }, ...args);
-  }
-  /**
-  * Calls a hook in sequence
-  *
-  * @param hook - The hook to call
-  * @param options - Options for calling the hook
-  * @param args - The arguments to pass to the hook
-  * @returns The result of the hook call
-  */
-  async callHookSequential(hook, options, ...args) {
-    return callHook(isSetObject(options?.environment) ? options.environment : await this.#context.getEnvironment(options?.environment), hook, {
-      ...options,
-      sequential: true
-    }, ...args);
-  }
-  /**
-  * Calls the `"pre"` ordered hooks in sequence
-  *
-  * @param environment - The environment to use for the hook call
-  * @param hook - The hook to call
-  * @param args - The arguments to pass to the hook
-  * @returns The result of the hook call
-  */
-  async callPreHook(environment, hook, ...args) {
-    return this.callHookSequential(hook, {
-      order: "pre",
-      environment
-    }, ...args);
-  }
-  /**
-  * Calls the `"post"` ordered hooks in sequence
-  *
-  * @param environment - The environment to use for the hook call
-  * @param hook - The hook to call
-  * @param args - The arguments to pass to the hook
-  * @returns The result of the hook call
-  */
-  async callPostHook(environment, hook, ...args) {
-    return this.callHookSequential(hook, {
-      order: "post",
-      environment
-    }, ...args);
-  }
-  /**
-  * Calls a hook in sequence
-  *
-  * @param environment - The environment to use for the hook call
-  * @param hook - The hook to call
-  * @param args - The arguments to pass to the hook
-  * @returns The result of the hook call
-  */
-  async callNormalHook(environment, hook, ...args) {
-    return this.callHookSequential(hook, {
-      order: "normal",
-      environment
-    }, ...args);
-  }
-  /**
-  * Calls the `"pre"` and `"post"` ordered hooks, as well as the normal hooks in sequence
-  *
-  * @param environment - The environment to use for the hook call
-  * @param hook - The hook to call
-  * @param args - The arguments to pass to the hook
-  * @returns The result of the hook call
-  */
-  async callHook(environment, hook, ...args) {
-    return this.callHookSequential(hook, {
-      environment
-    }, ...args);
-  }
-  async [Symbol.asyncDispose]() {
-    await this.finalize();
-  }
-  /**
-  * Get the configured environments
-  *
-  * @returns The configured environments
-  */
-  async #getEnvironments() {
-    if (!this.context.config.environments || Object.keys(this.context.config.environments).length <= 1) {
-      this.context.log(LogLevelLabel.DEBUG, "No environments are configured for this Powerlines project. Using the default environment.");
-      return [
-        await this.context.getEnvironment()
-      ];
-    }
-    this.context.log(LogLevelLabel.DEBUG, `Found ${Object.keys(this.context.config.environments).length} configured environment(s) for this Powerlines project.`);
-    return (await Promise.all(Object.entries(this.context.config.environments).map(async ([name, config]) => {
-      const environment = await this.context.getEnvironmentSafe(name);
-      if (!environment) {
-        const resolvedEnvironment = await this.callHookParallel("configEnvironment", {
-          environment: name
-        }, name, config);
-        if (resolvedEnvironment) {
-          this.context.environments[name] = await this.context.in(resolvedEnvironment);
-        }
-      }
-      return this.context.environments[name];
-    }))).filter((context) => isSet(context));
-  }
-  /**
-  * Execute a handler function for each environment
-  *
-  * @param handle - The handler function to execute for each environment
-  */
-  async #executeEnvironments(handle) {
-    await Promise.all((await this.#getEnvironments()).map(async (context) => {
-      return Promise.resolve(handle(context));
-    }));
-  }
-  /**
-  * Add a Powerlines plugin used in the build process
-  *
-  * @param config - The import path of the plugin to add
-  */
-  async #addPlugin(config) {
-    if (config) {
-      const plugin = await this.#initPlugin(config);
-      if (!plugin) {
-        return;
-      }
-      if (plugin.dependsOn) {
-        for (const required of plugin.dependsOn) {
-          await this.#addPlugin(required);
-        }
-      }
-      this.context.log(LogLevelLabel.DEBUG, `Successfully initialized the ${chalk4.bold.cyanBright(plugin.name)} plugin`);
-      await this.context.addPlugin(plugin);
-    }
-  }
-  /**
-  * Initialize a Powerlines plugin
-  *
-  * @param config - The configuration for the plugin
-  * @returns The initialized plugin instance, or null if the plugin was a duplicate
-  * @throws Will throw an error if the plugin cannot be found or is invalid
-  */
-  async #initPlugin(config) {
-    let awaited = config;
-    if (isPromiseLike(config)) {
-      awaited = await Promise.resolve(config);
-    }
-    if (!isPluginConfig(awaited)) {
-      throw new Error(`Invalid plugin specified in the configuration - ${JSON.stringify(awaited)}. Please ensure the value is a plugin name, an object with the \`plugin\` and \`props\` properties, or an instance of \`Plugin\`.`);
-    }
-    let plugin;
-    if (isPlugin(awaited)) {
-      plugin = awaited;
-    } else if (isFunction(awaited)) {
-      plugin = await Promise.resolve(awaited());
-    } else if (isSetString(awaited)) {
-      const resolved = await this.#resolvePlugin(awaited);
-      if (isFunction(resolved)) {
-        plugin = await Promise.resolve(resolved());
-      } else {
-        plugin = resolved;
-      }
-    } else if (isPluginConfigTuple(awaited) || isPluginConfigObject(awaited)) {
-      let pluginConfig;
-      let pluginOptions;
-      if (isPluginConfigTuple(awaited)) {
-        pluginConfig = awaited[0];
-        pluginOptions = awaited?.length === 2 ? awaited[1] : void 0;
-      } else {
-        pluginConfig = awaited.plugin;
-        pluginOptions = awaited.options;
-      }
-      if (isSetString(pluginConfig)) {
-        const resolved = await this.#resolvePlugin(pluginConfig);
-        if (isFunction(resolved)) {
-          plugin = await Promise.resolve(pluginOptions ? resolved(pluginOptions) : resolved());
-        } else {
-          plugin = resolved;
-        }
-      } else if (isFunction(pluginConfig)) {
-        plugin = await Promise.resolve(pluginConfig(pluginOptions));
-      } else if (isPlugin(pluginConfig)) {
-        plugin = pluginConfig;
-      }
-    }
-    if (!plugin) {
-      throw new Error(`The plugin configuration ${JSON.stringify(awaited)} is invalid. This configuration must point to a valid Powerlines plugin module.`);
-    }
-    if (!isPlugin(plugin)) {
-      throw new Error(`The plugin option ${JSON.stringify(plugin)} does not export a valid module. This configuration must point to a valid Powerlines plugin module.`);
-    }
-    if (checkDedupe(plugin, this.context.plugins)) {
-      this.context.log(LogLevelLabel.TRACE, `Duplicate ${chalk4.bold.cyanBright(plugin.name)} plugin dependency detected - Skipping initialization.`);
-      return null;
-    }
-    this.context.log(LogLevelLabel.TRACE, `Initializing the ${chalk4.bold.cyanBright(plugin.name)} plugin...`);
-    return plugin;
-  }
-  async #resolvePlugin(pluginPath) {
-    if (pluginPath.startsWith("@") && pluginPath.split("/").filter(Boolean).length > 2) {
-      const splits = pluginPath.split("/").filter(Boolean);
-      pluginPath = `${splits[0]}/${splits[1]}`;
-    }
-    const isInstalled = isPackageExists(pluginPath, {
-      paths: [
-        this.context.workspaceConfig.workspaceRoot,
-        this.context.config.projectRoot
-      ]
-    });
-    if (!isInstalled && this.context.config.skipInstalls !== true) {
-      this.#context.log(LogLevelLabel.WARN, `The plugin package "${pluginPath}" is not installed. It will be installed automatically.`);
-      const result = await install(pluginPath, {
-        cwd: this.context.config.projectRoot
-      });
-      if (isNumber(result.exitCode) && result.exitCode > 0) {
-        this.#context.log(LogLevelLabel.ERROR, result.stderr);
-        throw new Error(`An error occurred while installing the build plugin package "${pluginPath}" `);
-      }
-    }
-    try {
-      const module = await this.context.resolver.plugin.import(this.context.resolver.plugin.esmResolve(joinPaths(pluginPath, "plugin")));
-      const result = module.plugin ?? module.default;
-      if (!result) {
-        throw new Error(`The plugin package "${pluginPath}" does not export a valid module.`);
-      }
-      return result;
-    } catch (error) {
-      try {
-        const module = await this.context.resolver.plugin.import(this.context.resolver.plugin.esmResolve(pluginPath));
-        const result = module.plugin ?? module.default;
-        if (!result) {
-          throw new Error(`The plugin package "${pluginPath}" does not export a valid module.`);
-        }
-        return result;
-      } catch {
-        if (!isInstalled) {
-          throw new Error(`The plugin package "${pluginPath}" is not installed. Please install the package using the command: "npm install ${pluginPath} --save-dev"`);
-        } else {
-          throw new Error(`An error occurred while importing the build plugin package "${pluginPath}":
-${isError(error) ? error.message : String(error)}
-
-Note: Please ensure the plugin package's default export is a class that extends \`Plugin\` with a constructor that excepts a single arguments of type \`PluginOptions\`.`);
-        }
-      }
-    }
-  }
-};
-
-// src/lib/unplugin/factory.ts
-function createUnpluginFactory(variant, decorate) {
-  return (config, meta) => {
-    const log = createLog("unplugin", config);
-    log(LogLevelLabel.DEBUG, "Initializing Unplugin");
-    try {
-      const userConfig = {
-        ...config,
-        variant,
-        unplugin: meta
-      };
-      let api;
-      let resolvePatterns = [];
-      async function buildStart() {
-        log(LogLevelLabel.DEBUG, "Powerlines build plugin starting...");
-        const workspaceRoot = getWorkspaceRoot(process.cwd());
-        api = await PowerlinesAPI.from(workspaceRoot, userConfig);
-        if (api.context.config.build.skipNodeModulesBundle) {
-          resolvePatterns = tsconfigPathsToRegExp(api.context.tsconfig.options.paths ?? []);
-        }
-        log(LogLevelLabel.DEBUG, "Preparing build artifacts for the Powerlines project...");
-        await api.prepare({
-          command: "build"
-        });
-      }
-      __name(buildStart, "buildStart");
-      async function resolveId(id, importer, options = {
-        isEntry: false
-      }) {
-        return handleResolveId(api.context, {
-          id,
-          importer,
-          options
-        }, {
-          skipNodeModulesBundle: api.context.config.build.skipNodeModulesBundle,
-          external: api.context.config.build.external,
-          noExternal: api.context.config.build.noExternal,
-          resolvePatterns
-        });
-      }
-      __name(resolveId, "resolveId");
-      async function load(id) {
-        const environment = await api.context.getEnvironment();
-        if (id) {
-          const resolvedPath = environment.fs.resolve(id);
-          if (resolvedPath) {
-            return environment.fs.readFile(resolvedPath);
-          }
-        }
-        let result2 = await api.callPreHook(environment, "load", id);
-        if (result2) {
-          return result2;
-        }
-        result2 = await api.callNormalHook(environment, "load", id);
-        if (result2) {
-          return result2;
-        }
-        return api.callPostHook(environment, "load", id);
-      }
-      __name(load, "load");
-      async function transform(code, id) {
-        const environment = await api.context.getEnvironment();
-        let transformed = code;
-        let result2 = await api.callPreHook(environment, "transform", getString(transformed), id);
-        if (result2) {
-          transformed = result2;
-        }
-        result2 = await api.callNormalHook(environment, "transform", getString(transformed), id);
-        if (result2) {
-          transformed = result2;
-        }
-        result2 = await api.callPostHook(environment, "transform", getString(transformed), id);
-        if (result2) {
-          transformed = result2;
-        }
-        return transformed;
-      }
-      __name(transform, "transform");
-      async function writeBundle() {
-        log(LogLevelLabel.DEBUG, "Finalizing Powerlines project output...");
-        const environment = await api.context.getEnvironment();
-        await api.callHook(environment, "writeBundle");
-      }
-      __name(writeBundle, "writeBundle");
-      const result = {
-        name: "powerlines",
-        resolveId: {
-          filter: {
-            id: {
-              include: [
-                /.*/
-              ]
-            }
-          },
-          handler: resolveId
-        },
-        load: {
-          filter: {
-            id: {
-              include: [
-                /.*/,
-                /^storm:/
-              ]
-            }
-          },
-          handler: load
-        },
-        transform,
-        buildStart,
-        writeBundle
-      };
-      return decorate ? decorate(api, result) : result;
-    } catch (error) {
-      log(LogLevelLabel.FATAL, error?.message);
-      throw error;
-    }
-  };
-}
-__name(createUnpluginFactory, "createUnpluginFactory");
-
-export { createUnpluginFactory };
-//# sourceMappingURL=chunk-6BRTJXZ2.js.map
-//# sourceMappingURL=chunk-6BRTJXZ2.js.map