@powerlines/nx 0.11.221 → 0.11.223

package/dist/chunk-RBIHD4JS.mjs

@@ -1,4900 +0,0 @@
-import { replacePathTokens, extendLog, format, loadWorkspaceConfig, resolveEntriesSync, CACHE_HASH_LENGTH, ROOT_HASH_LENGTH, createLog, loadUserConfigFile, getUniqueInputs, GLOBAL_ENVIRONMENT, getFileHeader, formatFolder, DEFAULT_ENVIRONMENT } from './chunk-W75JGXP2.mjs';
-import { __name } from './chunk-O6YSETKJ.mjs';
-import { writeError } from '@storm-software/config-tools/logger';
-import { withRunExecutor } from '@storm-software/workspace-tools/base/base-executor';
-import { isError } from '@stryke/type-checks/is-error';
-import defu7, { createDefu, defu } from 'defu';
-import { relativeToWorkspaceRoot } from '@stryke/fs/get-workspace-root';
-import { formatLogMessage } from '@storm-software/config-tools/logger/console';
-import { toArray } from '@stryke/convert/to-array';
-import { createDirectorySync, createDirectory } from '@stryke/fs/helpers';
-import { install } from '@stryke/fs/install';
-import { listFilesSync, listFiles } from '@stryke/fs/list-files';
-import { isPackageExists, isPackageListed, doesPackageMatch, getPackageListing } from '@stryke/fs/package-fns';
-import { getResolutionCombinations, resolve as resolve$1, resolveSync, resolvePackage } from '@stryke/fs/resolve';
-import { omit } from '@stryke/helpers/omit';
-import { appendPath } from '@stryke/path/append';
-import { joinPaths as joinPaths$1 } from '@stryke/path/join-paths';
-import { replacePath, replaceExtension } from '@stryke/path/replace';
-import { isFunction } from '@stryke/type-checks/is-function';
-import { isNumber } from '@stryke/type-checks/is-number';
-import { isObject } from '@stryke/type-checks/is-object';
-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 { isString } from '@stryke/type-checks/is-string';
-import chalk4 from 'chalk';
-import Handlebars from 'handlebars';
-import { hasFileExtension, findFilePath, findFileName, findFileExtensionSafe, findFileDotExtensionSafe, relativePath } from '@stryke/path/file-path-fns';
-import { isParentPath } from '@stryke/path/is-parent-path';
-import { prettyBytes } from '@stryke/string-format/pretty-bytes';
-import { InMemoryFileSystemHost, Project, DiagnosticCategory } from 'ts-morph';
-import { getUnique, getUniqueBy } from '@stryke/helpers/get-unique';
-import { isRegExp } from '@stryke/type-checks/is-regexp';
-import { isUndefined } from '@stryke/type-checks/is-undefined';
-import { joinPaths } from '@stryke/path/join';
-import { unlinkSync } from 'node:fs';
-import { getPackageName, hasPackageVersion, getPackageVersion } from '@stryke/string-format/package';
-import { existsSync, exists } from '@stryke/fs/exists';
-import { readJsonFile, readJsonFileSync } from '@stryke/fs/json';
-import '@stryke/fs/remove-file';
-import { kebabCase } from '@stryke/string-format/kebab-case';
-import { getObjectDiff } from '@donedeal0/superdiff';
-import { StormJSON } from '@stryke/json/storm-json';
-import { titleCase } from '@stryke/string-format/title-case';
-import ts from 'typescript';
-import { LogLevelLabel } from '@storm-software/config-tools/types';
-import { getEnvPaths } from '@stryke/env/get-env-paths';
-import { hashDirectory } from '@stryke/hash/hash-files';
-import { murmurhash } from '@stryke/hash/murmurhash';
-import { fetchRequest } from '@stryke/http/fetch';
-import { isNull } from '@stryke/type-checks/is-null';
-import { uuid } from '@stryke/unique-id/uuid';
-import { tsconfigPathsToRegExp, match } from 'bundle-require';
-import { resolveCompatibilityDates } from 'compatx';
-import { create } from 'flat-cache';
-import { parse } from 'oxc-parser';
-import { Agent, setGlobalDispatcher, interceptors, Response } from 'undici';
-import { createJiti } from 'jiti';
-import * as $ from '@stryke/capnp';
-import { readFileBuffer, readFileBufferSync, writeFileBuffer } from '@stryke/fs/buffer';
-import { correctPath, stripStars } from '@stryke/path/correct-path';
-import { globToRegex } from '@stryke/path/glob-to-regex';
-import { isAbsolutePath } from '@stryke/path/is-type';
-import { slash } from '@stryke/path/slash';
-import { Blob as Blob$1 } from 'node:buffer';
-import { fileURLToPath } from 'node:url';
-import { isDirectory, isFile } from '@stryke/fs/is-file';
-import { readFileSync, readFile } from '@stryke/fs/read-file';
-import { writeFileSync, writeFile } from '@stryke/fs/write-file';
-import { unlink } from 'node:fs/promises';
-import { resolve } from 'node:path';
-import 'unplugin';
-
-// ../powerlines/package.json
-var package_default = {
-  version: "0.39.1"};
-var VirtualFileSystemHost = class extends InMemoryFileSystemHost {
-  static {
-    __name(this, "VirtualFileSystemHost");
-  }
-  #context;
-  constructor(context) {
-    super();
-    this.#context = context;
-  }
-  deleteSync(path) {
-    this.#context.fs.removeSync(path);
-  }
-  readDirSync(dirPath) {
-    if (!this.#context.fs.isDirectorySync(dirPath)) {
-      return [];
-    }
-    return this.#context.fs.listSync(dirPath).reduce((ret, entry) => {
-      const fullPath = this.#context.fs.resolveSync(entry);
-      if (fullPath) {
-        ret.push({
-          name: entry,
-          isDirectory: this.#context.fs.isDirectorySync(fullPath),
-          isFile: this.#context.fs.isFileSync(fullPath),
-          isSymlink: false
-        });
-      }
-      return ret;
-    }, []);
-  }
-  async readFile(filePath) {
-    if (!this.#context.fs.isFileSync(filePath)) {
-      return "";
-    }
-    return await this.#context.fs.read(filePath);
-  }
-  readFileSync(filePath) {
-    if (!this.#context.fs.isFileSync(filePath)) {
-      return "";
-    }
-    return this.#context.fs.readSync(filePath);
-  }
-  async writeFile(filePath, fileText) {
-    return this.#context.fs.write(filePath, fileText);
-  }
-  writeFileSync(filePath, fileText) {
-    this.#context.fs.writeSync(filePath, fileText);
-  }
-  async mkdir(dirPath) {
-    await this.#context.fs.mkdir(dirPath);
-  }
-  mkdirSync(dirPath) {
-    this.#context.fs.mkdirSync(dirPath);
-  }
-  async move(srcPath, destPath) {
-    await this.#context.fs.move(srcPath, destPath);
-  }
-  moveSync(srcPath, destPath) {
-    this.#context.fs.moveSync(srcPath, destPath);
-  }
-  async copy(srcPath, destPath) {
-    await this.#context.fs.copy(srcPath, destPath);
-  }
-  copySync(srcPath, destPath) {
-    this.#context.fs.copySync(srcPath, destPath);
-  }
-  async fileExists(filePath) {
-    return this.#context.fs.isFile(filePath);
-  }
-  fileExistsSync(filePath) {
-    return this.#context.fs.isFileSync(filePath);
-  }
-  async directoryExists(dirPath) {
-    return this.#context.fs.isDirectory(dirPath);
-  }
-  directoryExistsSync(dirPath) {
-    return this.#context.fs.isDirectorySync(dirPath);
-  }
-  realpathSync(path) {
-    return this.#context.fs.resolveSync(path) || path;
-  }
-  getCurrentDirectory() {
-    return this.#context.workspaceConfig.workspaceRoot;
-  }
-  async glob(patterns) {
-    return this.#context.fs.glob(patterns);
-  }
-  globSync(patterns) {
-    return this.#context.fs.globSync(patterns);
-  }
-};
-function createProgram(context, override) {
-  context.debug(`Creating ts-morph Project instance with configuration from: ${context.tsconfig.tsconfigFilePath}.`);
-  const project = new Project(defu7(override ?? {}, {
-    skipAddingFilesFromTsConfig: false,
-    tsConfigFilePath: context.tsconfig.tsconfigFilePath,
-    fileSystem: new VirtualFileSystemHost(context),
-    compilerOptions: defu7(context.tsconfig.options ?? {}, {
-      lib: [
-        "lib.esnext.full.d.ts"
-      ]
-    })
-  }));
-  return project;
-}
-__name(createProgram, "createProgram");
-
-// ../powerlines/src/_internal/helpers/generate-types.ts
-var getModuleCommentBlockRegex = /* @__PURE__ */ __name((moduleId) => new RegExp(`\\/\\*\\*(?s:.)*?@module\\s+${moduleId}(?s:.)*?\\*\\/\\s+`), "getModuleCommentBlockRegex");
-function formatTypes(code) {
-  return code.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, "");
-}
-__name(formatTypes, "formatTypes");
-async function emitBuiltinTypes(context, files) {
-  if (files.length === 0) {
-    context.debug("No files provided for TypeScript types generation. Typescript compilation for built-in modules will be skipped.");
-    return "";
-  }
-  context.debug(`Running the TypeScript compiler for ${files.length} generated built-in module files.`);
-  const program = createProgram(context, {
-    skipAddingFilesFromTsConfig: true,
-    compilerOptions: {
-      declaration: true,
-      declarationMap: false,
-      emitDeclarationOnly: true,
-      sourceMap: false,
-      outDir: replacePath(context.builtinsPath, context.workspaceConfig.workspaceRoot),
-      composite: false,
-      incremental: false,
-      tsBuildInfoFile: void 0
-    }
-  });
-  program.addSourceFilesAtPaths(files);
-  const result = program.emitToMemory({
-    emitOnlyDtsFiles: true
-  });
-  const diagnostics = result.getDiagnostics();
-  if (diagnostics && diagnostics.length > 0) {
-    if (diagnostics.some((d) => d.getCategory() === DiagnosticCategory.Error)) {
-      throw new Error(`The Typescript emit process failed while generating built-in types: 
- ${diagnostics.filter((d) => d.getCategory() === DiagnosticCategory.Error).map((d) => `-${d.getSourceFile() ? `${d.getSourceFile()?.getFilePath()}:` : ""} ${String(d.getMessageText())} (at ${d.getStart()}:${d.getLength()})`).join("\n")}`);
-    } else if (diagnostics.some((d) => d.getCategory() === DiagnosticCategory.Warning)) {
-      context.warn(`The Typescript emit process completed with warnings while generating built-in types: 
- ${diagnostics.filter((d) => d.getCategory() === DiagnosticCategory.Warning).map((d) => `-${d.getSourceFile() ? `${d.getSourceFile()?.getFilePath()}:` : ""} ${String(d.getMessageText())} (at ${d.getStart()}:${d.getLength()})`).join("\n")}`);
-    } else {
-      context.debug(`The Typescript emit process completed with diagnostic messages while generating built-in types: 
- ${diagnostics.map((d) => `-${d.getSourceFile() ? `${d.getSourceFile()?.getFilePath()}:` : ""} ${String(d.getMessageText())} (at ${d.getStart()}:${d.getLength()})`).join("\n")}`);
-    }
-  }
-  const emittedFiles = result.getFiles();
-  context.debug(`The TypeScript compiler emitted ${emittedFiles.length} files for built-in types.`);
-  let builtinModules = "";
-  for (const emittedFile of emittedFiles) {
-    context.trace(`Processing emitted type declaration file: ${emittedFile.filePath}`);
-    const filePath = appendPath(emittedFile.filePath, context.workspaceConfig.workspaceRoot);
-    if (!filePath.endsWith(".map") && findFileName(filePath) !== "tsconfig.tsbuildinfo" && isParentPath(filePath, context.builtinsPath)) {
-      const moduleId = `${context.config.framework}:${replaceExtension(replacePath(filePath, context.builtinsPath), "", {
-        fullExtension: true
-      })}`;
-      const moduleComment = emittedFile.text.match(getModuleCommentBlockRegex(moduleId))?.find((comment) => isSetString(comment?.trim()));
-      builtinModules += `${moduleComment ? `
-${moduleComment.trim()}` : ""}
-declare module "${moduleId}" {
-    ${emittedFile.text.replace(moduleComment ?? "", "").trim().replace(/^\s*export\s*declare\s*/gm, "export ").replace(/^\s*declare\s*/gm, "")}
-}
-`;
-    }
-  }
-  builtinModules = formatTypes(builtinModules);
-  context.debug(`A TypeScript declaration file (size: ${prettyBytes(new Blob(toArray(builtinModules)).size)}) emitted for the built-in modules types.`);
-  return builtinModules;
-}
-__name(emitBuiltinTypes, "emitBuiltinTypes");
-
-// ../core/src/types/commands.ts
-var SUPPORTED_COMMANDS = [
-  "new",
-  "clean",
-  "prepare",
-  "lint",
-  "test",
-  "build",
-  "docs",
-  "deploy",
-  "finalize"
-];
-
-// ../core/src/types/unplugin.ts
-var UNPLUGIN_BUILDER_VARIANTS = [
-  "rollup",
-  "webpack",
-  "rspack",
-  "vite",
-  "esbuild",
-  "farm",
-  "unloader",
-  "rolldown",
-  "bun"
-];
-var BUILDER_VARIANTS = [
-  ...UNPLUGIN_BUILDER_VARIANTS,
-  "tsup",
-  "tsdown",
-  "unbuild"
-];
-
-// ../core/src/types/plugin.ts
-var PLUGIN_NON_HOOK_FIELDS = [
-  "name",
-  "api",
-  "enforce",
-  "dedupe",
-  "applyToEnvironment"
-];
-var PLUGIN_HOOKS_FIELDS = [
-  ...SUPPORTED_COMMANDS,
-  "config",
-  "configEnvironment",
-  "configResolved",
-  "types",
-  "buildStart",
-  "buildEnd",
-  "transform",
-  "load",
-  "resolveId",
-  "writeBundle"
-];
-
-// ../core/src/plugin-utils/helpers.ts
-function isPlugin(value) {
-  return isSetObject(value) && "name" in value && isSetString(value.name) && (isUndefined(value.api) || "api" in value && isSetObject(value.api)) && (isUndefined(value.applyToEnvironment) || "applyToEnvironment" in value && isFunction(value.applyToEnvironment)) && (isUndefined(value.dedupe) || "dedupe" in value && isFunction(value.dedupe)) && PLUGIN_HOOKS_FIELDS.every((hook) => isUndefined(value[hook]) || hook in value && (isPluginHookFunction(value[hook]) || hook === "config" && isSetObject(value[hook]))) && BUILDER_VARIANTS.every((variant) => isUndefined(value[variant]) || variant in value && isSetObject(value[variant]));
-}
-__name(isPlugin, "isPlugin");
-function isPluginConfigObject(value) {
-  return isSetObject(value) && "plugin" in value && ((isSetString(value.plugin) || isFunction(value.plugin)) && "options" in value && isSetObject(value.options) || isPlugin(value.plugin));
-}
-__name(isPluginConfigObject, "isPluginConfigObject");
-function isPluginConfigTuple(value) {
-  return Array.isArray(value) && (value.length === 1 || value.length === 2) && ((isSetString(value[0]) || isFunction(value[0])) && value.length > 1 && isSetObject(value[1]) || isPlugin(value[0]));
-}
-__name(isPluginConfigTuple, "isPluginConfigTuple");
-function isPluginConfig(value) {
-  return isSetString(value) || isFunction(value) || isPlugin(value) || isPluginConfigObject(value) || isPluginConfigTuple(value) || Array.isArray(value) && value.every((item) => isPluginConfig(item));
-}
-__name(isPluginConfig, "isPluginConfig");
-function isPluginHookObject(value) {
-  return isSetObject(value) && "handler" in value && isFunction(value.handler);
-}
-__name(isPluginHookObject, "isPluginHookObject");
-function isPluginHookFunction(value) {
-  return isFunction(value) || isPluginHookObject(value);
-}
-__name(isPluginHookFunction, "isPluginHookFunction");
-function isPluginHook(value) {
-  return isPluginHookFunction(value) || isPluginHookObject(value);
-}
-__name(isPluginHook, "isPluginHook");
-function getHookHandler(pluginHook) {
-  return isFunction(pluginHook) ? pluginHook : pluginHook.handler;
-}
-__name(getHookHandler, "getHookHandler");
-function isUnpluginHookKey(keys) {
-  return UNPLUGIN_BUILDER_VARIANTS.some((variant) => keys.startsWith(`${variant}:`));
-}
-__name(isUnpluginHookKey, "isUnpluginHookKey");
-function isPluginHookField(keys) {
-  return !isUnpluginHookKey(keys) && PLUGIN_HOOKS_FIELDS.includes(keys);
-}
-__name(isPluginHookField, "isPluginHookField");
-function isUnpluginHookField(field) {
-  return !isPluginHookField(field) && UNPLUGIN_BUILDER_VARIANTS.includes(field);
-}
-__name(isUnpluginHookField, "isUnpluginHookField");
-function checkDedupe(plugin, plugins) {
-  return plugin.dedupe === false || plugins.some((p) => p.dedupe !== false && (isFunction(p.dedupe) && p.dedupe(plugin) || p.name === plugin.name));
-}
-__name(checkDedupe, "checkDedupe");
-function addPluginHook(context, plugin, pluginHook, hooksList) {
-  if (!checkDedupe(plugin, hooksList.map((hook) => hook.plugin).filter(Boolean))) {
-    const handler = /* @__PURE__ */ __name((...args) => getHookHandler(pluginHook).apply(context, args), "handler");
-    if (!handler) {
-      return;
-    }
-    hooksList.push({
-      plugin,
-      handler
-    });
-  }
-}
-__name(addPluginHook, "addPluginHook");
-function findInvalidPluginConfig(config) {
-  if (isPluginConfig(config)) {
-    return null;
-  }
-  if (Array.isArray(config)) {
-    const invalidItems = [];
-    config.forEach((item) => {
-      const invalid = findInvalidPluginConfig(item);
-      if (invalid) {
-        invalidItems.push(...invalid.map((i) => JSON.stringify(i, null, 2)));
-      }
-    });
-    return invalidItems.length > 0 ? invalidItems : null;
-  }
-  return [
-    JSON.stringify(config, null, 2)
-  ];
-}
-__name(findInvalidPluginConfig, "findInvalidPluginConfig");
-
-// ../core/src/plugin-utils/merge.ts
-createDefu((obj, key, value) => {
-  if (isPluginHook(obj[key]) && isPluginHook(value)) {
-    obj[key] = {
-      ...obj[key],
-      ...value,
-      handler: /* @__PURE__ */ __name(async (...params) => {
-        const [resultA, resultB] = await Promise.all([
-          // eslint-disable-next-line ts/no-unsafe-call
-          getHookHandler(obj[key])(...params),
-          // eslint-disable-next-line ts/no-unsafe-call
-          getHookHandler(value)(...params)
-        ]);
-        return resultB && resultA ? defu7(resultA, resultB) : resultA || resultB;
-      }, "handler")
-    };
-    return true;
-  }
-  return false;
-});
-var mergeConfig = createDefu((obj, key, value) => {
-  if (isString(obj[key]) && isString(value)) {
-    if (isSetString(value)) {
-      obj[key] = value;
-    }
-    return true;
-  }
-  return false;
-});
-
-// ../powerlines/src/_internal/helpers/hooks.ts
-var mergeResultObjects = createDefu((obj, key, value) => {
-  if (isString(obj[key]) && isString(value)) {
-    obj[key] = `${obj[key] || ""}
-${value || ""}`.trim();
-    return true;
-  }
-  return false;
-});
-function mergeResults(currentResult, previousResults) {
-  if (isString(currentResult)) {
-    previousResults = [
-      `${isString(previousResults[0]) ? previousResults[0] || "" : ""}
-${currentResult || ""}`.trim()
-    ];
-  } else if (isObject(currentResult)) {
-    previousResults = [
-      mergeResultObjects(currentResult, previousResults[0] ?? {})
-    ];
-  }
-  return previousResults;
-}
-__name(mergeResults, "mergeResults");
-function mergeConfigs(currentResult, previousResults) {
-  if (isString(currentResult)) {
-    previousResults = [
-      `${isString(previousResults[0]) ? previousResults[0] || "" : ""}
-${currentResult || ""}`.trim()
-    ];
-  } else if (isObject(currentResult)) {
-    previousResults = [
-      mergeConfig(currentResult, previousResults[0] ?? {})
-    ];
-  }
-  return previousResults;
-}
-__name(mergeConfigs, "mergeConfigs");
-async function callHook(context, key, options, ...args) {
-  const hooks = context.selectHooks(key, options);
-  if (hooks.length > 0) {
-    context.debug(` \u{1F9E9}  Calling plugin hook: ${chalk4.bold.cyanBright(`${key}${options?.order ? ` (${options.order})` : ""}`)}`);
-    const invokeHook = /* @__PURE__ */ __name(async (hook, hookArgs) => {
-      return Reflect.apply(hook.handler, hook.context, hookArgs);
-    }, "invokeHook");
-    let results = [];
-    if (options?.sequential === false) {
-      results = await Promise.all(hooks.map(async (hook) => {
-        if (!isFunction(hook.handler)) {
-          throw new Error(`Plugin hook handler for hook "${key}" is not a function.`);
-        }
-        return invokeHook(hook, [
-          ...args
-        ]);
-      }));
-    } else {
-      for (const hook of hooks) {
-        if (!isFunction(hook.handler)) {
-          throw new Error(`Plugin hook handler for hook "${key}" is not a function.`);
-        }
-        if (options?.result === "first" || options?.asNextParam === false) {
-          results.push(await Promise.resolve(invokeHook(hook, [
-            ...args
-          ])));
-          if (options?.result === "first" && isSet(results[results.length - 1])) {
-            break;
-          }
-        } else {
-          const sequenceArgs = [
-            ...args
-          ];
-          if (results.length > 0 && sequenceArgs.length > 0) {
-            sequenceArgs[0] = isFunction(options.asNextParam) ? await Promise.resolve(options.asNextParam(results[0])) : results[0];
-          }
-          const result = await Promise.resolve(invokeHook(hook, [
-            ...sequenceArgs
-          ]));
-          if (result) {
-            if (options.result === "last") {
-              results = [
-                result
-              ];
-            } else if (options.result === "merge" && options.merge) {
-              results = options.merge(result, results);
-            } else {
-              results = mergeResults(result, results);
-            }
-          }
-        }
-      }
-    }
-    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");
-async function installPackage(context, packageName, dev = false) {
-  if (!await isPackageListed(getPackageName(packageName), {
-    cwd: context.config.root
-  })) {
-    if (context.config.autoInstall) {
-      context.warn(`The package "${packageName}" is not installed. It will be installed automatically.`);
-      const result = await install(packageName, {
-        cwd: context.config.root,
-        dev
-      });
-      if (isNumber(result.exitCode) && result.exitCode > 0) {
-        context.error(result.stderr);
-        throw new Error(`An error occurred while installing the package "${packageName}"`);
-      }
-    } else {
-      context.warn(`The package "${packageName}" is not installed. Since the "autoInstall" option is set to false, 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.root);
-    if (!isMatching) {
-      const packageListing = await getPackageListing(getPackageName(packageName), {
-        cwd: context.config.root
-      });
-      if (!packageListing?.version.startsWith("catalog:") && !packageListing?.version.startsWith("workspace:")) {
-        context.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");
-
-// ../powerlines/src/_internal/helpers/install-dependencies.ts
-async function installDependencies(context) {
-  context.debug(`Checking and installing missing project dependencies.`);
-  context.dependencies ??= {};
-  context.devDependencies ??= {};
-  if (Object.keys(context.dependencies).length === 0 && Object.keys(context.devDependencies).length === 0) {
-    context.debug(`No dependencies or devDependencies to install. Skipping installation step.`);
-    return;
-  }
-  context.debug(`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");
-function getPrefixedRootHash(name, rootHash) {
-  const combined = `${kebabCase(name)}_${rootHash}`;
-  return combined.length > ROOT_HASH_LENGTH ? combined.slice(0, ROOT_HASH_LENGTH) : combined;
-}
-__name(getPrefixedRootHash, "getPrefixedRootHash");
-async function writeMetaFile(context) {
-  const metaFilePath = joinPaths$1(context.dataPath, "meta.json");
-  context.debug(`Writing runtime metadata to ${metaFilePath}`);
-  await context.fs.write(metaFilePath, JSON.stringify(context.meta, null, 2));
-}
-__name(writeMetaFile, "writeMetaFile");
-function getTsconfigFilePath(workspaceRoot, projectRoot, tsconfig) {
-  let tsconfigFilePath;
-  if (tsconfig) {
-    tsconfigFilePath = tryTsconfigFilePath(workspaceRoot, projectRoot, tsconfig);
-  } else {
-    tsconfigFilePath = tryTsconfigFilePath(workspaceRoot, projectRoot, "tsconfig.app.json");
-    if (!tsconfigFilePath) {
-      tsconfigFilePath = tryTsconfigFilePath(workspaceRoot, projectRoot, "tsconfig.lib.json");
-      if (!tsconfigFilePath) {
-        tsconfigFilePath = tryTsconfigFilePath(workspaceRoot, projectRoot, "tsconfig.json");
-      }
-    }
-  }
-  if (!tsconfigFilePath) {
-    throw new Error(`Cannot find the \`tsconfig.json\` configuration file for the project at ${projectRoot}.`);
-  }
-  return tsconfigFilePath;
-}
-__name(getTsconfigFilePath, "getTsconfigFilePath");
-function tryTsconfigFilePath(workspaceRoot, projectRoot, tsconfig) {
-  let tsconfigFilePath = tsconfig;
-  if (!existsSync(tsconfigFilePath)) {
-    tsconfigFilePath = appendPath(tsconfig, projectRoot);
-    if (!existsSync(tsconfigFilePath)) {
-      tsconfigFilePath = appendPath(tsconfig, appendPath(projectRoot, workspaceRoot));
-      if (!existsSync(tsconfigFilePath)) {
-        return void 0;
-      }
-    }
-  }
-  return tsconfigFilePath;
-}
-__name(tryTsconfigFilePath, "tryTsconfigFilePath");
-function findMatch(tsconfigType, types, extensions = [
-  ".ts",
-  ".tsx",
-  ".d.ts"
-]) {
-  return types.find((type) => tsconfigType?.toString().toLowerCase() === type?.toString().toLowerCase() || tsconfigType?.toString().toLowerCase() === `./${type?.toString().toLowerCase()}` || `./${tsconfigType?.toString().toLowerCase()}` === type?.toString().toLowerCase() || extensions.some((ext) => `${tsconfigType?.toString().toLowerCase()}${ext}` === type?.toString().toLowerCase() || `${tsconfigType?.toString().toLowerCase()}${ext}` === `./${type?.toString().toLowerCase()}` || `${type?.toString().toLowerCase()}${ext}` === `./${tsconfigType?.toString().toLowerCase()}` || tsconfigType?.toString().toLowerCase() === `${type?.toString().toLowerCase()}${ext}` || tsconfigType?.toString().toLowerCase() === `./${type?.toString().toLowerCase()}${ext}` || type?.toString().toLowerCase() === `./${tsconfigType?.toString().toLowerCase()}${ext}`));
-}
-__name(findMatch, "findMatch");
-function findIncludeMatch(tsconfigType, types) {
-  return findMatch(tsconfigType, types, [
-    ".ts",
-    ".tsx",
-    ".d.ts",
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-    ".mts",
-    ".cts",
-    "/*.ts",
-    "/*.tsx",
-    "/*.d.ts",
-    "/*.js",
-    "/*.jsx",
-    "/*.mjs",
-    "/*.cjs",
-    "/*.mts",
-    "/*.cts",
-    "/**/*.ts",
-    "/**/*.tsx",
-    "/**/*.d.ts",
-    "/**/*.js",
-    "/**/*.jsx",
-    "/**/*.mjs",
-    "/**/*.cjs",
-    "/**/*.mts",
-    "/**/*.cts"
-  ]);
-}
-__name(findIncludeMatch, "findIncludeMatch");
-function isIncludeMatchFound(tsconfigType, types) {
-  return findIncludeMatch(tsconfigType, types) !== void 0;
-}
-__name(isIncludeMatchFound, "isIncludeMatchFound");
-function getParsedTypeScriptConfig(workspaceRoot, projectRoot, tsconfig, tsconfigRaw = {}, originalTsconfigJson, host = ts.sys) {
-  const tsconfigFilePath = getTsconfigFilePath(workspaceRoot, projectRoot, tsconfig);
-  const tsconfigJson = readJsonFileSync(tsconfigFilePath);
-  if (!tsconfigJson) {
-    throw new Error(`Cannot find the \`tsconfig.json\` configuration file at ${joinPaths$1(projectRoot, tsconfig ?? "tsconfig.json")}`);
-  }
-  const parsedCommandLine = ts.parseJsonConfigFileContent(defu7(tsconfigRaw ?? {}, tsconfigJson), host, appendPath(projectRoot, workspaceRoot));
-  if (parsedCommandLine.errors.length > 0) {
-    const errorMessage = `Cannot parse the TypeScript compiler options. Please investigate the following issues:
-${parsedCommandLine.errors.map((error) => `- ${(error.category !== void 0 && error.code ? `[${error.category}-${error.code}]: ` : "") + error.messageText.toString()}`).join("\n")}
-      `;
-    throw new Error(errorMessage);
-  }
-  return {
-    ...parsedCommandLine,
-    originalTsconfigJson: originalTsconfigJson ?? tsconfigJson,
-    tsconfigJson,
-    tsconfigFilePath
-  };
-}
-__name(getParsedTypeScriptConfig, "getParsedTypeScriptConfig");
-
-// ../powerlines/src/_internal/helpers/resolve-tsconfig.ts
-function getTsconfigDtsPath(context) {
-  const dtsRelativePath = joinPaths$1(relativePath(joinPaths$1(context.workspaceConfig.workspaceRoot, context.config.root), findFilePath(context.dtsPath)), findFileName(context.dtsPath));
-  return dtsRelativePath;
-}
-__name(getTsconfigDtsPath, "getTsconfigDtsPath");
-async function resolveTsconfigChanges(context) {
-  const tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.root, context.config.tsconfig, context.config.tsconfigRaw);
-  const tsconfigFilePath = getTsconfigFilePath(context.workspaceConfig.workspaceRoot, context.config.root, context.config.tsconfig);
-  const tsconfigJson = await readJsonFile(tsconfigFilePath);
-  tsconfigJson.compilerOptions ??= {};
-  if (context.config.output.dts !== false) {
-    const dtsRelativePath = getTsconfigDtsPath(context);
-    if (!tsconfigJson.include?.some((filePattern) => isIncludeMatchFound(filePattern, [
-      context.dtsPath,
-      dtsRelativePath
-    ]))) {
-      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.esModuleInterop !== true) {
-    tsconfigJson.compilerOptions.esModuleInterop = true;
-  }
-  if (tsconfig.options.isolatedModules !== true) {
-    tsconfigJson.compilerOptions.isolatedModules = true;
-  }
-  if (context.config.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.debug("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.root, context.config.tsconfig);
-  context.tsconfig.originalTsconfigJson = await readJsonFile(tsconfigFilePath);
-  context.tsconfig.tsconfigJson = await resolveTsconfigChanges(context);
-  context.debug("Writing updated TypeScript configuration (tsconfig.json) file to disk.");
-  await context.fs.write(tsconfigFilePath, StormJSON.stringify(context.tsconfig.tsconfigJson));
-  context.tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.root, 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.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 context.fs.write(context.tsconfig.tsconfigFilePath, StormJSON.stringify(updateTsconfigJson));
-  context.tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.root, context.config.tsconfig);
-  if (!context.tsconfig) {
-    throw new Error("Failed to parse the TypeScript configuration file.");
-  }
-}
-__name(resolveTsconfig, "resolveTsconfig");
-function createEnvironment(name, userConfig) {
-  return defu7(userConfig.environments?.[name] ?? {}, {
-    name,
-    title: userConfig.title || titleCase(userConfig.name),
-    ssr: false,
-    mainFields: userConfig?.platform === "browser" ? [
-      "browser",
-      "module",
-      "jsnext:main",
-      "jsnext"
-    ] : [
-      "module",
-      "jsnext:main",
-      "jsnext"
-    ],
-    extensions: [
-      ".mjs",
-      ".js",
-      ".mts",
-      ".ts",
-      ".jsx",
-      ".tsx",
-      ".json"
-    ],
-    consumer: userConfig?.platform === "browser" ? "client" : "server",
-    preview: userConfig?.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 defu7(options, {
-    interopDefault: true,
-    fsCache: options.mode !== "development" ? joinPaths$1(options.cacheDir, "jiti") : false,
-    moduleCache: options.mode !== "development"
-  });
-}
-__name(resolveOptions, "resolveOptions");
-function createResolver(options) {
-  const baseResolver = createJiti(joinPaths$1(options.workspaceRoot, options.root), resolveOptions(options));
-  baseResolver.plugin = createJiti(joinPaths$1(options.workspaceRoot, options.root), resolveOptions(options));
-  return baseResolver;
-}
-__name(createResolver, "createResolver");
-BigInt("0xa56c61324b9d6e49");
-var FileMetadata_KeyValuePair = class extends $.Struct {
-  static {
-    __name(this, "FileMetadata_KeyValuePair");
-  }
-  static _capnp = {
-    displayName: "KeyValuePair",
-    id: "eabb26cf58b2a14c",
-    size: new $.ObjectSize(0, 2)
-  };
-  get key() {
-    return $.utils.getText(0, this);
-  }
-  set key(value) {
-    $.utils.setText(0, value, this);
-  }
-  get value() {
-    return $.utils.getText(1, this);
-  }
-  set value(value) {
-    $.utils.setText(1, value, this);
-  }
-  toString() {
-    return "FileMetadata_KeyValuePair_" + super.toString();
-  }
-};
-var FileMetadata = class _FileMetadata extends $.Struct {
-  static {
-    __name(this, "FileMetadata");
-  }
-  static KeyValuePair = FileMetadata_KeyValuePair;
-  static _capnp = {
-    displayName: "FileMetadata",
-    id: "8e2cab5d7e28c7b3",
-    size: new $.ObjectSize(8, 3),
-    defaultType: "normal"
-  };
-  static _Properties;
-  /**
-  * The type of the file.
-  *
-  */
-  get id() {
-    return $.utils.getText(0, this);
-  }
-  set id(value) {
-    $.utils.setText(0, value, this);
-  }
-  /**
-  * The timestamp representing the file's creation date.
-  *
-  */
-  get type() {
-    return $.utils.getText(1, this, _FileMetadata._capnp.defaultType);
-  }
-  set type(value) {
-    $.utils.setText(1, value, this);
-  }
-  /**
-  * Additional metadata associated with the file.
-  *
-  */
-  get timestamp() {
-    return $.utils.getUint32(0, this);
-  }
-  set timestamp(value) {
-    $.utils.setUint32(0, value, this);
-  }
-  _adoptProperties(value) {
-    $.utils.adopt(value, $.utils.getPointer(2, this));
-  }
-  _disownProperties() {
-    return $.utils.disown(this.properties);
-  }
-  get properties() {
-    return $.utils.getList(2, _FileMetadata._Properties, this);
-  }
-  _hasProperties() {
-    return !$.utils.isNull($.utils.getPointer(2, this));
-  }
-  _initProperties(length) {
-    return $.utils.initList(2, _FileMetadata._Properties, length, this);
-  }
-  set properties(value) {
-    $.utils.copyFrom(value, $.utils.getPointer(2, this));
-  }
-  toString() {
-    return "FileMetadata_" + super.toString();
-  }
-};
-var FileId = class extends $.Struct {
-  static {
-    __name(this, "FileId");
-  }
-  static _capnp = {
-    displayName: "FileId",
-    id: "990d6a471072f997",
-    size: new $.ObjectSize(0, 2)
-  };
-  /**
-  * A virtual (or actual) path to the file in the file system.
-  *
-  */
-  get id() {
-    return $.utils.getText(0, this);
-  }
-  set id(value) {
-    $.utils.setText(0, value, this);
-  }
-  get path() {
-    return $.utils.getText(1, this);
-  }
-  set path(value) {
-    $.utils.setText(1, value, this);
-  }
-  toString() {
-    return "FileId_" + super.toString();
-  }
-};
-var FileStorage = class extends $.Struct {
-  static {
-    __name(this, "FileStorage");
-  }
-  static _capnp = {
-    displayName: "FileStorage",
-    id: "9dca66ac858c9ebe",
-    size: new $.ObjectSize(0, 2)
-  };
-  /**
-  * A virtual (or actual) path to the file in the file system.
-  *
-  */
-  get path() {
-    return $.utils.getText(0, this);
-  }
-  set path(value) {
-    $.utils.setText(0, value, this);
-  }
-  get code() {
-    return $.utils.getText(1, this);
-  }
-  set code(value) {
-    $.utils.setText(1, value, this);
-  }
-  toString() {
-    return "FileStorage_" + super.toString();
-  }
-};
-var FileSystem = class _FileSystem extends $.Struct {
-  static {
-    __name(this, "FileSystem");
-  }
-  static _capnp = {
-    displayName: "FileSystem",
-    id: "ae0c23d43e56abcf",
-    size: new $.ObjectSize(0, 3)
-  };
-  static _Ids;
-  static _Storage;
-  static _Metadata;
-  _adoptIds(value) {
-    $.utils.adopt(value, $.utils.getPointer(0, this));
-  }
-  _disownIds() {
-    return $.utils.disown(this.ids);
-  }
-  get ids() {
-    return $.utils.getList(0, _FileSystem._Ids, this);
-  }
-  _hasIds() {
-    return !$.utils.isNull($.utils.getPointer(0, this));
-  }
-  _initIds(length) {
-    return $.utils.initList(0, _FileSystem._Ids, length, this);
-  }
-  set ids(value) {
-    $.utils.copyFrom(value, $.utils.getPointer(0, this));
-  }
-  _adoptStorage(value) {
-    $.utils.adopt(value, $.utils.getPointer(1, this));
-  }
-  _disownStorage() {
-    return $.utils.disown(this.storage);
-  }
-  get storage() {
-    return $.utils.getList(1, _FileSystem._Storage, this);
-  }
-  _hasStorage() {
-    return !$.utils.isNull($.utils.getPointer(1, this));
-  }
-  _initStorage(length) {
-    return $.utils.initList(1, _FileSystem._Storage, length, this);
-  }
-  set storage(value) {
-    $.utils.copyFrom(value, $.utils.getPointer(1, this));
-  }
-  _adoptMetadata(value) {
-    $.utils.adopt(value, $.utils.getPointer(2, this));
-  }
-  _disownMetadata() {
-    return $.utils.disown(this.metadata);
-  }
-  get metadata() {
-    return $.utils.getList(2, _FileSystem._Metadata, this);
-  }
-  _hasMetadata() {
-    return !$.utils.isNull($.utils.getPointer(2, this));
-  }
-  _initMetadata(length) {
-    return $.utils.initList(2, _FileSystem._Metadata, length, this);
-  }
-  set metadata(value) {
-    $.utils.copyFrom(value, $.utils.getPointer(2, this));
-  }
-  toString() {
-    return "FileSystem_" + super.toString();
-  }
-};
-FileMetadata._Properties = $.CompositeList(FileMetadata_KeyValuePair);
-FileSystem._Ids = $.CompositeList(FileId);
-FileSystem._Storage = $.CompositeList(FileStorage);
-FileSystem._Metadata = $.CompositeList(FileMetadata);
-var BaseStorageAdapter = class {
-  static {
-    __name(this, "BaseStorageAdapter");
-  }
-  /**
-  * Indicates whether the storage adapter has been disposed.
-  */
-  #isDisposed = false;
-  /**
-  * Configuration options for the storage adapter.
-  */
-  options;
-  /**
-  * The storage preset for the adapter.
-  *
-  * @remarks
-  * This can be used as an alternate way to identify the type of storage being used.
-  */
-  preset = null;
-  /**
-  * Constructor for the BaseStorageAdapter.
-  *
-  * @param options - Configuration options for the storage adapter.
-  */
-  constructor(options = {
-    base: "/"
-  }) {
-    this.options = options;
-    this.options.base = resolve(options.base);
-    this.options.isReadOnly = !!options.isReadOnly;
-  }
-  /**
-  * Asynchronously checks if a key exists in the storage.
-  *
-  * @param key - The key to check for existence.
-  * @returns A promise that resolves to `true` if the key exists, otherwise `false`.
-  */
-  async exists(key) {
-    return this.existsSync(key);
-  }
-  /**
-  * Asynchronously retrieves the value associated with a given key.
-  *
-  * @param key - The key whose value is to be retrieved.
-  * @returns A promise that resolves to the value associated with the key, or `null` if the key does not exist.
-  */
-  async get(key) {
-    return this.getSync(key);
-  }
-  /**
-  * Asynchronously sets the value for a given key.
-  *
-  * @param key - The key to set the value for.
-  * @param value - The value to set.
-  */
-  async set(key, value) {
-    if (!this.options.isReadOnly) {
-      this.setSync(key, value);
-    }
-  }
-  /**
-  * Synchronously creates a directory at the specified path.
-  *
-  * @param _ - The path of the directory to create.
-  */
-  mkdirSync(_) {
-  }
-  /**
-  * Creates a directory at the specified path.
-  *
-  * @param dirPath - The path of the directory to create.
-  */
-  async mkdir(dirPath) {
-    return Promise.resolve(this.mkdirSync(dirPath));
-  }
-  /**
-  * Asynchronously removes a key from the storage.
-  *
-  * @param key - The key to remove.
-  */
-  async remove(key) {
-    if (!this.options.isReadOnly) {
-      this.removeSync(key);
-    }
-  }
-  /**
-  * Synchronously removes all entries from the storage that match the provided base path.
-  *
-  * @param base - The base path to clear keys from.
-  */
-  clearSync(base) {
-    if (!this.options.isReadOnly) {
-      const keys = this.listSync(base || this.options.base);
-      if (!keys.length) {
-        return;
-      }
-      keys.map((key) => this.removeSync(base && !key.startsWith(base) ? joinPaths(base, key) : key));
-    }
-  }
-  /**
-  * Asynchronously removes all entries from the storage that match the provided base path.
-  *
-  * @param base - The base path to clear keys from.
-  * @returns A promise that resolves when the operation is complete.
-  */
-  async clear(base) {
-    if (!this.options.isReadOnly) {
-      const keys = await this.list(base || this.options.base);
-      if (!keys.length) {
-        return;
-      }
-      await Promise.all(keys.map(async (key) => this.remove(base && !key.startsWith(base) ? joinPaths(base, key) : key)));
-    }
-  }
-  /**
-  * Asynchronously lists all keys under a given base path.
-  *
-  * @param base - The base path to list keys from.
-  * @returns A promise that resolves to an array of keys under the specified base path.
-  */
-  async list(base) {
-    return this.listSync(base);
-  }
-  /**
-  * Synchronously checks if the given key is a directory.
-  *
-  * @param _ - The key to check.
-  * @returns `true` if the key is a directory, otherwise `false`.
-  */
-  isDirectorySync(_) {
-    return false;
-  }
-  /**
-  * Checks if the given key is a directory.
-  *
-  * @param key - The key to check.
-  * @returns A promise that resolves to `true` if the key is a directory, otherwise `false`.
-  */
-  async isDirectory(key) {
-    return Promise.resolve(this.isDirectorySync(key));
-  }
-  /**
-  * Synchronously checks if the given key is a file.
-  *
-  * @param key - The key to check.
-  * @returns `true` if the key is a file, otherwise `false`.
-  */
-  isFileSync(key) {
-    return this.existsSync(key) && !this.isDirectorySync(key);
-  }
-  /**
-  * Checks if the given key is a file.
-  *
-  * @param key - The key to check.
-  * @returns A promise that resolves to `true` if the key is a file, otherwise `false`.
-  */
-  async isFile(key) {
-    return Promise.resolve(this.isFileSync(key));
-  }
-  /**
-  * Disposes of the storage adapter, releasing any held resources.
-  *
-  * @returns A promise that resolves when the disposal is complete.
-  */
-  dispose() {
-    return Promise.resolve();
-  }
-  /**
-  * Async dispose method to clean up resources.
-  *
-  * @returns A promise that resolves when disposal is complete.
-  */
-  async [Symbol.asyncDispose]() {
-    return this._dispose();
-  }
-  /**
-  * Resolves a given key to its full path within the storage adapter.
-  *
-  * @param key - The key to resolve.
-  * @returns The resolved full path for the key.
-  */
-  resolve(key) {
-    if (!key) {
-      return this.options.base;
-    }
-    if (/\.\.:|\.\.$/.test(key)) {
-      throw new Error(`[${this.name}]: Invalid key: ${JSON.stringify(key)} provided to storage adapter.`);
-    }
-    return appendPath(correctPath(key).replace(/:/g, "/"), this.options.base);
-  }
-  /**
-  * Disposes of the storage adapter, releasing any held resources.
-  *
-  * @returns A promise that resolves when the disposal is complete.
-  */
-  async _dispose() {
-    if (!this.#isDisposed) {
-      await Promise.resolve(this.dispose());
-      this.#isDisposed = true;
-    }
-  }
-};
-function isFileError(err) {
-  return isError(err) && "code" in err && err.code;
-}
-__name(isFileError, "isFileError");
-function ignoreNotfound(err) {
-  return isFileError(err) && (err.code === "ENOENT" || err.code === "EISDIR" ? null : err);
-}
-__name(ignoreNotfound, "ignoreNotfound");
-
-// ../powerlines/src/storage/file-system.ts
-var FileSystemStorageAdapter = class extends BaseStorageAdapter {
-  static {
-    __name(this, "FileSystemStorageAdapter");
-  }
-  /**
-  * A name identifying the storage adapter type.
-  */
-  name = "file-system";
-  /**
-  * The storage preset for the adapter.
-  *
-  * @remarks
-  * This can be used as an alternate way to identify the type of storage being used.
-  */
-  preset = "fs";
-  /**
-  * Constructor for the FileSystemStorageAdapter.
-  *
-  * @param options - Configuration options for the storage adapter.
-  */
-  constructor(options) {
-    super(options);
-  }
-  /**
-  * Synchronously checks if a key exists in the storage.
-  *
-  * @param key - The key to check for existence.
-  * @returns Returns `true` if the key exists, otherwise `false`.
-  */
-  existsSync(key) {
-    return existsSync(this.resolve(key));
-  }
-  /**
-  * Asynchronously checks if a key exists in the storage.
-  *
-  * @param key - The key to check for existence.
-  * @returns A promise that resolves to `true` if the key exists, otherwise `false`.
-  */
-  async exists(key) {
-    return exists(this.resolve(key));
-  }
-  /**
-  * Synchronously retrieves the value associated with a given key.
-  *
-  * @param key - The key whose value is to be retrieved.
-  * @returns The value associated with the key, or `null` if the key does not exist.
-  */
-  getSync(key) {
-    return readFileSync(this.resolve(key));
-  }
-  /**
-  * Asynchronously retrieves the value associated with a given key.
-  *
-  * @param key - The key whose value is to be retrieved.
-  * @returns A promise that resolves to the value associated with the key, or `null` if the key does not exist.
-  */
-  async get(key) {
-    return readFile(this.resolve(key));
-  }
-  /**
-  * Synchronously sets the value for a given key.
-  *
-  * @param key - The key to set the value for.
-  * @param value - The value to set.
-  */
-  setSync(key, value) {
-    if (!this.options.isReadOnly) {
-      return writeFileSync(this.resolve(key), value);
-    }
-  }
-  /**
-  * Asynchronously sets the value for a given key.
-  *
-  * @param key - The key to set the value for.
-  * @param value - The value to set.
-  */
-  async set(key, value) {
-    if (!this.options.isReadOnly) {
-      return writeFile(this.resolve(key), value);
-    }
-  }
-  /**
-  * Synchronously removes a key from the storage.
-  *
-  * @param key - The key to remove.
-  */
-  removeSync(key) {
-    if (!this.options.isReadOnly) {
-      try {
-        return unlinkSync(this.resolve(key));
-      } catch (err) {
-        return ignoreNotfound(err);
-      }
-    }
-  }
-  /**
-  * Asynchronously removes a key from the storage.
-  *
-  * @param key - The key to remove.
-  */
-  async remove(key) {
-    if (!this.options.isReadOnly) {
-      return unlink(this.resolve(key)).catch(ignoreNotfound);
-    }
-  }
-  /**
-  * Synchronously creates a directory at the specified path.
-  *
-  * @param dirPath - The path of the directory to create.
-  */
-  mkdirSync(dirPath) {
-    createDirectorySync(this.resolve(dirPath));
-  }
-  /**
-  * Creates a directory at the specified path.
-  *
-  * @param dirPath - The path of the directory to create.
-  */
-  async mkdir(dirPath) {
-    await createDirectory(this.resolve(dirPath));
-  }
-  /**
-  * Lists all keys under a given base path synchronously.
-  *
-  * @param base - The base path to list keys from.
-  * @returns An array of keys under the specified base path.
-  */
-  listSync(base) {
-    try {
-      return listFilesSync(this.resolve(base), {
-        ignore: this.options.ignore
-      });
-    } catch (err) {
-      return ignoreNotfound(err) ?? [];
-    }
-  }
-  /**
-  * Asynchronously lists all keys under a given base path.
-  *
-  * @param base - The base path to list keys from.
-  * @returns A promise that resolves to an array of keys under the specified base path.
-  */
-  async list(base) {
-    return listFiles(this.resolve(base), {
-      ignore: this.options.ignore
-    }).catch(ignoreNotfound).then((r) => r || []);
-  }
-  /**
-  * Synchronously checks if the given key is a directory.
-  *
-  * @param key - The key to check.
-  * @returns `true` if the key is a directory, otherwise `false`.
-  */
-  isDirectorySync(key) {
-    return isDirectory(this.resolve(key));
-  }
-  /**
-  * Synchronously checks if the given key is a file.
-  *
-  * @param key - The key to check.
-  * @returns `true` if the key is a file, otherwise `false`.
-  */
-  isFileSync(key) {
-    return isFile(this.resolve(key));
-  }
-};
-var VirtualStorageAdapter = class extends BaseStorageAdapter {
-  static {
-    __name(this, "VirtualStorageAdapter");
-  }
-  /**
-  * A name identifying the storage adapter type.
-  */
-  name = "virtual";
-  /**
-  * The storage preset for the adapter.
-  *
-  * @remarks
-  * This can be used as an alternate way to identify the type of storage being used.
-  */
-  preset = "virtual";
-  /**
-  * In-memory data storage.
-  */
-  data = /* @__PURE__ */ new Map();
-  /**
-  * Constructor for the VirtualStorageAdapter.
-  *
-  * @param options - Configuration options for the storage adapter.
-  */
-  constructor(options) {
-    super(options);
-  }
-  /**
-  * Synchronously checks if a key exists in the storage.
-  *
-  * @param key - The key to check for existence.
-  * @returns Returns `true` if the key exists, otherwise `false`.
-  */
-  existsSync(key) {
-    return this.data.has(this.resolve(key));
-  }
-  /**
-  * Synchronously retrieves the value associated with a given key.
-  *
-  * @param key - The key whose value is to be retrieved.
-  * @returns The value associated with the key, or `null` if the key does not exist.
-  */
-  getSync(key) {
-    return this.data.get(this.resolve(key)) ?? null;
-  }
-  /**
-  * Synchronously sets the value for a given key.
-  *
-  * @param key - The key to set the value for.
-  * @param value - The value to set.
-  */
-  setSync(key, value) {
-    if (!this.options.isReadOnly) {
-      this.data.set(this.resolve(key), value);
-    }
-  }
-  /**
-  * Synchronously removes a key from the storage.
-  *
-  * @param key - The key to remove.
-  */
-  removeSync(key) {
-    if (!this.options.isReadOnly) {
-      this.data.delete(this.resolve(key));
-    }
-  }
-  /**
-  * Lists all keys under a given base path synchronously.
-  *
-  * @param base - The base path to list keys from.
-  * @returns An array of keys under the specified base path.
-  */
-  listSync(base) {
-    return [
-      ...this.data.keys().filter((key) => !base ? true : isParentPath(key, this.resolve(base)))
-    ];
-  }
-  /**
-  * Disposes of the storage adapter, releasing any held resources.
-  *
-  * @returns A promise that resolves when the disposal is complete.
-  */
-  async dispose() {
-    return this.clear();
-  }
-};
-
-// ../powerlines/src/_internal/vfs.ts
-function toFilePath(path) {
-  return correctPath(slash(path?.toString() || ".").replace(/^file:\/\//, ""));
-}
-__name(toFilePath, "toFilePath");
-function isValidId(id, prefix = "powerlines") {
-  return id.replace(/^\\0/, "").startsWith(`${prefix.replace(/:$/, "")}`);
-}
-__name(isValidId, "isValidId");
-function normalizeId(id, prefix = "powerlines") {
-  return replaceExtension(toFilePath(id)).replace(/^\\0/, "").replace(/^powerlines:/, "").replace(new RegExp(`^${prefix.replace(/:$/, "")}:`), "");
-}
-__name(normalizeId, "normalizeId");
-function normalizePath(path, builtinsPath, prefix = "powerlines") {
-  return isAbsolutePath(path) ? path : isValidId(toFilePath(path), prefix) ? normalizeId(toFilePath(path), prefix).replace(new RegExp(`^${prefix.replace(/:$/, "")}:`), builtinsPath) : toFilePath(path);
-}
-__name(normalizePath, "normalizePath");
-function normalizeGlobPatterns(workspaceRoot, patterns) {
-  return getUnique(toArray(patterns).map((pattern) => {
-    if (isSetObject(pattern) && (isSetString(pattern.input) || isSetString(pattern.glob))) {
-      return joinPaths(pattern.input || workspaceRoot, pattern.glob || "**/*");
-    } else if (!isSetString(pattern)) {
-      return void 0;
-    }
-    return pattern;
-  }).filter(isSetString));
-}
-__name(normalizeGlobPatterns, "normalizeGlobPatterns");
-var VirtualFileSystem = class _VirtualFileSystem {
-  static {
-    __name(this, "VirtualFileSystem");
-  }
-  /**
-  * A map of virtual file IDs to their associated metadata.
-  */
-  #metadata;
-  /**
-  * A map of underlying file paths to their virtual file IDs.
-  */
-  #ids;
-  /**
-  * A map of virtual file IDs to their underlying file paths.
-  */
-  #paths;
-  /**
-  * The unified volume that combines the virtual file system with the real file system.
-  *
-  * @remarks
-  * This volume allows for seamless access to both virtual and real files.
-  */
-  #storage = {
-    "": new FileSystemStorageAdapter()
-  };
-  /**
-  * A cache for module resolution results.
-  */
-  #resolverCache;
-  /**
-  * Indicator specifying if the virtual file system (VFS) is disposed
-  */
-  #isDisposed = false;
-  /**
-  * The context of the virtual file system.
-  */
-  #context;
-  /**
-  * The file system's logging function.
-  */
-  #log;
-  /**
-  * Normalizes a given module id by resolving it against the built-ins path.
-  *
-  * @param id - The module id to normalize.
-  * @returns The normalized module id.
-  */
-  #normalizeId(id) {
-    let normalized = id;
-    if (isParentPath(normalized, this.#context.builtinsPath)) {
-      normalized = replacePath(normalized, this.#context.builtinsPath);
-    }
-    return normalizeId(normalized, this.#context.config.framework);
-  }
-  /**
-  * Normalizes a given path by resolving it against the project root, workspace root, and built-ins path.
-  *
-  * @param path - The path to normalize.
-  * @returns The normalized path.
-  */
-  #normalizePath(path) {
-    return normalizePath(path.includes("{") || path.includes("}") ? replacePathTokens(this.#context, path) : path, this.#context.builtinsPath, this.#context.config.framework);
-  }
-  /**
-  * Gets the storage adapter and relative key for a given key.
-  *
-  * @remarks
-  * The `key` can be either a path or a storage adapter name.
-  *
-  * @param key - The key to get the storage adapter for.
-  * @returns The storage adapter and relative key for the given key.
-  */
-  #getStorage(key, preset) {
-    const path = this.resolveSync(this.#normalizePath(key)) || key;
-    for (const base of Object.keys(this.#storage).filter(Boolean).sort().reverse()) {
-      if ((path === base || isParentPath(path, base)) && (!preset || this.#storage[base]?.preset?.toLowerCase() === preset.toLowerCase())) {
-        return {
-          base,
-          relativeKey: replacePath(path, base),
-          adapter: this.#storage[base]
-        };
-      }
-    }
-    if (!preset || this.#storage[""]?.preset?.toLowerCase() === preset.toLowerCase()) {
-      return {
-        base: "",
-        relativeKey: path,
-        adapter: this.#storage[""]
-      };
-    }
-    this.#storage[path] = preset === "virtual" ? new VirtualStorageAdapter({
-      base: path
-    }) : new FileSystemStorageAdapter({
-      base: path
-    });
-    return {
-      base: path,
-      relativeKey: "",
-      adapter: this.#storage[path]
-    };
-  }
-  /**
-  * Gets all storage adapters that match a given base key.
-  *
-  * @param base - The base key to match storage adapters against.
-  * @param includeParent - Whether to include parent storage adapters.
-  * @returns An array of storage adapters that match the given base key.
-  */
-  #getStorages(base = "", includeParent = false) {
-    const baseKey = this.resolveSync(base) || base;
-    return Object.keys(this.#storage).sort().reverse().filter((key) => isParentPath(key, baseKey) || includeParent && isParentPath(baseKey, key) || baseKey.includes("*") && (isParentPath(stripStars(baseKey), key) || globToRegex(replaceExtension(baseKey)).test(key))).map((key) => ({
-      relativeBase: baseKey.length > key.length ? baseKey.slice(key.length) : void 0,
-      base: key,
-      adapter: this.#storage[key]
-    }));
-  }
-  /**
-  * Creates a virtual file system (VFS) that is backed up to a Cap'n Proto message buffer.
-  *
-  * @param context - The context of the virtual file system, typically containing options and logging functions.
-  * @returns A promise that resolves to a new virtual file system instance.
-  */
-  static async create(context) {
-    context.debug("Starting virtual file system (VFS) initialization processes...");
-    let result;
-    if (!context.config.skipCache && existsSync(joinPaths(context.dataPath, "fs.bin"))) {
-      const buffer = await readFileBuffer(joinPaths(context.dataPath, "fs.bin"));
-      const message = new $.Message(buffer, false);
-      const fs = message.getRoot(FileSystem);
-      result = new _VirtualFileSystem(context, fs);
-      if (fs._hasStorage() && fs.storage.length > 0) {
-        await Promise.all(fs.storage.values().map(async (file) => {
-          if (file.path && file.code) {
-            let id;
-            if (fs._hasIds()) {
-              id = fs.ids.find((fileId) => fileId.path === file.path);
-            }
-            let metadata;
-            if (fs._hasMetadata()) {
-              metadata = fs.metadata.find((meta) => meta.id === result.#normalizeId(id?.id ?? file.path));
-            }
-            await result.write(file.path, file.code, {
-              meta: {
-                id: result.#normalizeId(id?.id ?? metadata?.id ?? file.path),
-                type: metadata?.type || "normal",
-                properties: metadata?._hasProperties() ? metadata?.properties.values().reduce((ret, kvp) => {
-                  ret[kvp.key] = kvp.value;
-                  return ret;
-                }, {}) : void 0,
-                timestamp: metadata?.timestamp
-              }
-            });
-          }
-        }));
-      }
-    } else {
-      const message = new $.Message();
-      result = new _VirtualFileSystem(context, message.initRoot(FileSystem));
-    }
-    result.#log(LogLevelLabel.DEBUG, "Successfully completed virtual file system (VFS) initialization.");
-    return result;
-  }
-  /**
-  * Synchronously creates a virtual file system (VFS) that is backed up to a Cap'n Proto message buffer.
-  *
-  * @param context - The context of the virtual file system, typically containing options and logging functions.
-  * @returns A new virtual file system instance.
-  */
-  static createSync(context) {
-    context.debug("Starting virtual file system (VFS) initialization processes...");
-    let result;
-    if (!context.config.skipCache && existsSync(joinPaths(context.dataPath, "fs.bin"))) {
-      const buffer = readFileBufferSync(joinPaths(context.dataPath, "fs.bin"));
-      const message = new $.Message(buffer, false);
-      const fs = message.getRoot(FileSystem);
-      result = new _VirtualFileSystem(context, fs);
-      if (fs._hasStorage() && fs.storage.length > 0) {
-        fs.storage.values().forEach((file) => {
-          if (file.path && file.code) {
-            let id;
-            if (fs._hasIds()) {
-              id = fs.ids.find((fileId) => fileId.path === file.path);
-            }
-            let metadata;
-            if (fs._hasMetadata()) {
-              metadata = fs.metadata.find((meta) => meta.id === result.#normalizeId(id?.id ?? file.path));
-            }
-            result.writeSync(file.path, file.code, {
-              meta: {
-                id: result.#normalizeId(id?.id ?? metadata?.id ?? file.path),
-                type: metadata?.type,
-                properties: metadata?._hasProperties() ? metadata?.properties.values().reduce((ret, kvp) => {
-                  ret[kvp.key] = kvp.value;
-                  return ret;
-                }, {}) : void 0,
-                timestamp: metadata?.timestamp
-              }
-            });
-          }
-        });
-      }
-    } else {
-      const message = new $.Message();
-      result = new _VirtualFileSystem(context, message.initRoot(FileSystem));
-    }
-    result.#log(LogLevelLabel.DEBUG, "Successfully completed virtual file system (VFS) initialization.");
-    return result;
-  }
-  /**
-  * A map of file ids to their metadata.
-  */
-  get metadata() {
-    return new Proxy(this.#metadata, {
-      get: /* @__PURE__ */ __name((target, prop) => {
-        return target[this.#normalizeId(prop)];
-      }, "get"),
-      set: /* @__PURE__ */ __name((target, prop, value) => {
-        target[this.#normalizeId(prop)] = value;
-        return true;
-      }, "set"),
-      deleteProperty: /* @__PURE__ */ __name((target, prop) => {
-        delete target[this.#normalizeId(prop)];
-        return true;
-      }, "deleteProperty"),
-      has: /* @__PURE__ */ __name((target, prop) => {
-        return this.#normalizeId(prop) in target;
-      }, "has"),
-      ownKeys: /* @__PURE__ */ __name((target) => {
-        return getUnique(Reflect.ownKeys(target).map((key) => this.#normalizeId(key)));
-      }, "ownKeys")
-    });
-  }
-  /**
-  * A map of file paths to their module ids.
-  */
-  get ids() {
-    return new Proxy(this.#ids, {
-      get: /* @__PURE__ */ __name((target, prop) => {
-        return target[this.#normalizePath(prop)];
-      }, "get"),
-      set: /* @__PURE__ */ __name((target, prop, value) => {
-        target[this.#normalizePath(prop)] = value;
-        return true;
-      }, "set"),
-      deleteProperty: /* @__PURE__ */ __name((target, prop) => {
-        delete target[this.#normalizePath(prop)];
-        return true;
-      }, "deleteProperty"),
-      has: /* @__PURE__ */ __name((target, prop) => {
-        return this.#normalizePath(prop) in target;
-      }, "has"),
-      ownKeys: /* @__PURE__ */ __name((target) => {
-        return getUnique(Reflect.ownKeys(target).map((key) => this.#normalizePath(key)));
-      }, "ownKeys")
-    });
-  }
-  /**
-  * A map of module ids to their file paths.
-  */
-  get paths() {
-    return new Proxy(this.#paths, {
-      get: /* @__PURE__ */ __name((target, prop) => {
-        return target[this.#normalizeId(prop)];
-      }, "get"),
-      set: /* @__PURE__ */ __name((target, prop, value) => {
-        target[this.#normalizeId(prop)] = value;
-        return true;
-      }, "set"),
-      deleteProperty: /* @__PURE__ */ __name((target, prop) => {
-        delete target[this.#normalizeId(prop)];
-        return true;
-      }, "deleteProperty"),
-      has: /* @__PURE__ */ __name((target, prop) => {
-        return this.#normalizeId(prop) in target;
-      }, "has"),
-      ownKeys: /* @__PURE__ */ __name((target) => {
-        return getUnique(Reflect.ownKeys(target).map((key) => this.#normalizeId(key)));
-      }, "ownKeys")
-    });
-  }
-  /**
-  * Gets the resolver cache.
-  */
-  get resolverCache() {
-    if (!this.#resolverCache) {
-      this.#resolverCache = create({
-        cacheId: "module-resolution",
-        cacheDir: this.#context.cachePath,
-        ttl: 60 * 60 * 1e3,
-        lruSize: 5e3,
-        persistInterval: 100
-      });
-    }
-    return this.#resolverCache;
-  }
-  /**
-  * Creates a new instance of the {@link VirtualFileSystem}.
-  *
-  * @param context - The context of the virtual file system, typically containing options and logging functions.
-  * @param fs - A buffer containing the serialized virtual file system data.
-  */
-  constructor(context, fs) {
-    this.#context = context;
-    if (isSetObject(this.#context.config.output.storage)) {
-      this.#storage = {
-        ...this.#storage,
-        ...this.#context.config.output.storage
-      };
-    }
-    this.#storage.virtual ??= new VirtualStorageAdapter({
-      base: "/_virtual"
-    });
-    if (this.#context.config.output.storage !== "fs") {
-      this.#storage[this.#context.artifactsPath] ??= new VirtualStorageAdapter({
-        base: this.#context.artifactsPath
-      });
-      this.#storage[this.#context.builtinsPath] ??= new VirtualStorageAdapter({
-        base: this.#context.builtinsPath
-      });
-      this.#storage[this.#context.entryPath] ??= new VirtualStorageAdapter({
-        base: this.#context.entryPath
-      });
-    }
-    this.#metadata = {};
-    if (fs._hasMetadata()) {
-      this.#metadata = fs.metadata.values().reduce((ret, metadata) => {
-        ret[metadata.id] = {
-          id: metadata.id,
-          type: metadata.type,
-          timestamp: metadata.timestamp ?? Date.now(),
-          properties: metadata._hasProperties() ? metadata.properties.values().reduce((ret2, item) => {
-            ret2[item.key] = item.value;
-            return ret2;
-          }, {}) : {}
-        };
-        return ret;
-      }, {});
-    }
-    this.#ids = {};
-    this.#paths = {};
-    if (fs._hasIds()) {
-      this.#ids = fs.ids.values().reduce((ret, identifier) => {
-        ret[identifier.path] ??= identifier.id;
-        return ret;
-      }, {});
-      this.#paths = fs.ids.values().reduce((ret, identifier) => {
-        ret[identifier.id] ??= identifier.path;
-        return ret;
-      }, {});
-    }
-    this.#log = extendLog(this.#context.log, "file-system");
-  }
-  /**
-  * Asynchronously checks if a file exists in the virtual file system (VFS).
-  *
-  * @param path - The path to the file.
-  * @returns A promise that resolves to `true` if the file exists, otherwise `false`.
-  */
-  async exists(path) {
-    const { relativeKey, adapter } = this.#getStorage(path);
-    return adapter.exists(relativeKey);
-  }
-  /**
-  * Synchronously checks if a file exists in the virtual file system (VFS).
-  *
-  * @param path - The path to the file.
-  * @returns `true` if the file exists, otherwise `false`.
-  */
-  existsSync(path) {
-    const { relativeKey, adapter } = this.#getStorage(path);
-    return adapter.existsSync(relativeKey);
-  }
-  /**
-  * Checks if a file is virtual in the virtual file system (VFS).
-  *
-  * @param path - The path to the file.
-  * @returns `true` if the file is virtual, otherwise `false`.
-  */
-  isVirtual(path) {
-    const resolved = this.resolveSync(path);
-    if (!resolved) {
-      return false;
-    }
-    return this.#getStorage(resolved)?.adapter?.preset === "virtual";
-  }
-  /**
-  * Checks if a path is a directory in the virtual file system (VFS).
-  *
-  * @param path - The path to check.
-  * @returns `true` if the path is a directory, otherwise `false`.
-  */
-  isDirectorySync(path) {
-    const resolved = this.resolveSync(path);
-    if (!resolved) {
-      return false;
-    }
-    return !!(this.existsSync(resolved) && this.#getStorage(resolved)?.adapter?.isDirectorySync(resolved));
-  }
-  /**
-  * Checks if a path is a directory in the virtual file system (VFS).
-  *
-  * @param path - The path to check.
-  * @returns `true` if the path is a directory, otherwise `false`.
-  */
-  async isDirectory(path) {
-    const resolved = await this.resolve(path);
-    if (!resolved) {
-      return false;
-    }
-    return !!(await this.exists(resolved) && await this.#getStorage(resolved)?.adapter?.isDirectory(resolved));
-  }
-  /**
-  * Checks if a path is a file in the virtual file system (VFS).
-  *
-  * @param path - The path to check.
-  * @returns `true` if the path is a file, otherwise `false`.
-  */
-  isFileSync(path) {
-    const resolved = this.resolveSync(path);
-    if (!resolved) {
-      return false;
-    }
-    return this.#getStorage(resolved)?.adapter?.isFileSync(resolved) ?? false;
-  }
-  /**
-  * Checks if a path is a file in the virtual file system (VFS).
-  *
-  * @param path - The path to check.
-  * @returns `true` if the path is a file, otherwise `false`.
-  */
-  async isFile(path) {
-    const resolved = await this.resolve(path);
-    if (!resolved) {
-      return false;
-    }
-    return await this.#getStorage(resolved)?.adapter?.isFile(resolved) ?? false;
-  }
-  /**
-  * Lists files in a given path.
-  *
-  * @param path - The path to list files from.
-  * @returns An array of file names in the specified path.
-  */
-  listSync(path) {
-    let resolvedPath = path;
-    if (resolvedPath.includes("*")) {
-      this.#log(LogLevelLabel.WARN, `Invoking "listSync" with a glob pattern is not supported. It is likely you meant to use "globSync". Path: ${path}`);
-      resolvedPath = stripStars(resolvedPath);
-    }
-    return getUnique(this.#getStorages(resolvedPath, true).map((storage) => storage.adapter.listSync(storage.relativeBase ? storage.base ? appendPath(storage.relativeBase, storage.base) : storage.relativeBase : storage.base)).flat().filter(Boolean));
-  }
-  /**
-  * Lists files in a given path.
-  *
-  * @param path - The path to list files from.
-  * @returns An array of file names in the specified path.
-  */
-  async list(path) {
-    let resolvedPath = path;
-    if (resolvedPath.includes("*")) {
-      this.#log(LogLevelLabel.WARN, `Invoking "list" with a glob pattern is not supported. It is likely you meant to use "glob". Path: ${path}`);
-      resolvedPath = stripStars(resolvedPath);
-    }
-    return getUnique((await Promise.all(this.#getStorages(resolvedPath, true).map(async (storage) => storage.adapter.list(storage.relativeBase ? storage.base ? appendPath(storage.relativeBase, storage.base) : storage.relativeBase : storage.base)))).flat().filter(Boolean));
-  }
-  /**
-  * Removes a file in the virtual file system (VFS).
-  *
-  * @param path - The path to create the directory at.
-  */
-  async remove(path) {
-    const normalizedPath = this.#normalizePath(path);
-    this.#log(LogLevelLabel.TRACE, `Removing file: ${normalizedPath}`);
-    const { relativeKey, adapter } = this.#getStorage(normalizedPath);
-    if (hasFileExtension(normalizedPath)) {
-      await adapter.remove(relativeKey);
-    } else {
-      await adapter.clear(relativeKey);
-    }
-    const id = this.#ids[normalizedPath];
-    if (id && this.#metadata[id]) {
-      delete this.#metadata[id];
-      delete this.#ids[normalizedPath];
-      delete this.#paths[id];
-    }
-  }
-  /**
-  * Removes a file in the virtual file system (VFS).
-  *
-  * @param path - The path to create the directory at.
-  */
-  removeSync(path) {
-    const normalizedPath = this.#normalizePath(path);
-    this.#log(LogLevelLabel.TRACE, `Removing file: ${normalizedPath}`);
-    const { relativeKey, adapter } = this.#getStorage(normalizedPath);
-    if (hasFileExtension(normalizedPath)) {
-      adapter.removeSync(relativeKey);
-    } else {
-      adapter.clearSync(relativeKey);
-    }
-    const id = this.#ids[normalizedPath];
-    if (id && this.#metadata[id]) {
-      delete this.#metadata[id];
-      delete this.#ids[normalizedPath];
-      delete this.#paths[id];
-    }
-  }
-  /**
-  * Glob files in the virtual file system (VFS) based on the provided pattern(s).
-  *
-  * @param patterns - A pattern (or multiple patterns) to use to determine the file paths to return
-  * @returns An array of file paths matching the provided pattern(s)
-  */
-  async glob(patterns) {
-    const results = [];
-    for (const pattern of normalizeGlobPatterns(this.#context.workspaceConfig.workspaceRoot, patterns)) {
-      const normalized = this.#normalizePath(pattern);
-      if (!/[*?[\]{}]/.test(normalized) && !normalized.includes("*")) {
-        if (this.isDirectorySync(normalized)) {
-          results.push(...await this.list(normalized));
-        } else {
-          const resolved = await this.resolve(normalized);
-          if (resolved && !results.includes(resolved)) {
-            results.push(resolved);
-          }
-        }
-      } else {
-        const absPattern = isAbsolutePath(normalized) ? normalized : this.#normalizePath(appendPath(normalized, this.#context.workspaceConfig.workspaceRoot));
-        await Promise.all((await this.list(stripStars(absPattern))).map(async (file) => {
-          if (globToRegex(absPattern).test(file)) {
-            const resolved = await this.resolve(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 normalizeGlobPatterns(this.#context.workspaceConfig.workspaceRoot, patterns)) {
-      const normalized = this.#normalizePath(pattern);
-      if (!/[*?[\]{}]/.test(normalized) && !normalized.includes("*")) {
-        if (this.isDirectorySync(normalized)) {
-          results.push(...this.listSync(normalized));
-        } else {
-          const resolved = this.resolveSync(normalized);
-          if (resolved && !results.includes(resolved)) {
-            results.push(resolved);
-          }
-        }
-      } else {
-        const absPattern = isAbsolutePath(normalized) ? normalized : this.#normalizePath(appendPath(normalized, this.#context.workspaceConfig.workspaceRoot));
-        const files = this.listSync(stripStars(absPattern));
-        for (const file of files) {
-          const regex = globToRegex(absPattern);
-          if (regex.test(file)) {
-            const resolved = this.resolveSync(file);
-            if (resolved && !results.includes(resolved)) {
-              results.push(resolved);
-            }
-          }
-        }
-      }
-    }
-    return results;
-  }
-  /**
-  * Copies a file from one path to another in the virtual file system (VFS).
-  *
-  * @param srcPath - The source path to copy
-  * @param destPath - The destination path to copy to
-  */
-  async copy(srcPath, destPath) {
-    const src = srcPath instanceof URL ? fileURLToPath(srcPath) : srcPath;
-    const dest = destPath instanceof URL ? fileURLToPath(destPath) : destPath;
-    if (!isSetString(src) && (!isSetObject(src) || !isSetString(src.input)) || !isSetString(dest)) {
-      return;
-    }
-    const sourceStr = isString(src) ? src : src.input ? src.input : this.#context.workspaceConfig.workspaceRoot;
-    const source = await this.resolve(sourceStr);
-    if (!source) {
-      return;
-    }
-    if (this.isDirectorySync(source) || isSetString(src) && src.includes("*") || isSetObject(src) && isSetString(src.glob)) {
-      await Promise.all((await this.glob(src)).map(async (file) => {
-        return this.copy(file, appendPath(replacePath(file, sourceStr), dest));
-      }));
-    } else {
-      const content = await this.read(source);
-      if (content !== void 0) {
-        await this.write(this.#normalizePath(dest), content, {
-          skipFormat: true
-        });
-      }
-    }
-  }
-  /**
-  * 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 src = srcPath instanceof URL ? fileURLToPath(srcPath) : srcPath;
-    const dest = destPath instanceof URL ? fileURLToPath(destPath) : destPath;
-    if (!isSetString(src) && (!isSetObject(src) || !isSetString(src.input)) || !isSetString(dest)) {
-      return;
-    }
-    const sourceStr = isString(src) ? src : src.input ? src.input : this.#context.workspaceConfig.workspaceRoot;
-    const source = this.resolveSync(sourceStr);
-    if (!source) {
-      return;
-    }
-    if (this.isDirectorySync(source) || isSetString(src) && src.includes("*") || isSetObject(src) && isSetString(src.glob)) {
-      this.globSync(src).map((file) => {
-        return this.copySync(file, appendPath(findFilePath(replacePath(file, sourceStr)), dest));
-      });
-    } else {
-      const content = this.readSync(source);
-      if (content !== void 0) {
-        this.writeSync(this.#normalizePath(hasFileExtension(dest) ? dest : appendPath(findFileName(source), dest)), content, {
-          skipFormat: true
-        });
-      }
-    }
-  }
-  /**
-  * Moves a file (or files) from one path to another in the virtual file system (VFS).
-  *
-  * @param srcPath - The source path to move
-  * @param destPath - The destination path to move to
-  */
-  async move(srcPath, destPath) {
-    if (hasFileExtension(srcPath)) {
-      await this.copy(srcPath, destPath);
-      await this.remove(srcPath);
-    } else {
-      await Promise.all((await this.list(srcPath)).map(async (file) => {
-        await this.copy(file, destPath);
-        await this.remove(file);
-      }));
-    }
-  }
-  /**
-  * Synchronously moves a file (or files) from one path to another in the virtual file system (VFS).
-  *
-  * @param srcPath - The source path to move
-  * @param destPath - The destination path to move to
-  */
-  moveSync(srcPath, destPath) {
-    if (hasFileExtension(srcPath)) {
-      this.copySync(srcPath, destPath);
-      this.removeSync(srcPath);
-    } else {
-      this.listSync(srcPath).forEach((file) => {
-        this.copySync(file, destPath);
-        this.removeSync(file);
-      });
-    }
-  }
-  /**
-  * Asynchronously reads a file from the virtual file system (VFS).
-  *
-  * @param path - The path or ID of the file to read.
-  * @returns A promise that resolves to the contents of the file as a string, or undefined if the file does not exist.
-  */
-  async read(path) {
-    const filePath = await this.resolve(path);
-    if (!filePath || !this.existsSync(filePath)) {
-      return void 0;
-    }
-    const { adapter } = this.#getStorage(filePath);
-    this.#log(LogLevelLabel.TRACE, `Reading ${adapter.name} file: ${filePath}`);
-    return await adapter.get(filePath) ?? void 0;
-  }
-  /**
-  * Synchronously reads a file from the virtual file system (VFS).
-  *
-  * @param path - The path or ID of the file to read.
-  * @returns The contents of the file as a string, or undefined if the file does not exist.
-  */
-  readSync(path) {
-    const filePath = this.resolveSync(path);
-    if (!filePath || !this.existsSync(filePath)) {
-      return void 0;
-    }
-    const { adapter } = this.#getStorage(filePath);
-    this.#log(LogLevelLabel.TRACE, `Reading ${adapter.name} file: ${filePath}`);
-    return adapter.getSync(filePath) ?? void 0;
-  }
-  /**
-  * Writes a file to the virtual file system (VFS).
-  *
-  * @param path - The path to the file.
-  * @param data - The contents of the file.
-  * @param options - Optional parameters for writing the file.
-  * @returns A promise that resolves when the file is written.
-  */
-  async write(path, data = "", options = {}) {
-    const meta = options.meta ?? {};
-    const resolvedPath = await this.resolve(this.#normalizePath(path)) || path;
-    const { relativeKey, adapter } = this.#getStorage(resolvedPath, options.storage);
-    this.#log(LogLevelLabel.TRACE, `Writing ${resolvedPath} to ${adapter.name === "virtual" ? "the virtual file system" : adapter.name === "file-system" ? "the local file system" : adapter.name} (size: ${prettyBytes(new Blob$1(toArray(data)).size)})`);
-    let code = data;
-    try {
-      if (!options.skipFormat) {
-        code = await format(this.#context, resolvedPath, data);
-      }
-    } catch (err) {
-      if ([
-        "js",
-        "ts",
-        "cjs",
-        "cts",
-        "mjs",
-        "mts",
-        "tsx",
-        "jsx",
-        "json",
-        "json5",
-        "jsonc",
-        "md",
-        "mdx"
-      ].includes(findFileExtensionSafe(resolvedPath, {
-        fullExtension: true
-      }))) {
-        this.#log(LogLevelLabel.WARN, `Failed to format file ${resolvedPath} before writing: ${err.message}`);
-      }
-      code = data;
-    }
-    this.#log(LogLevelLabel.TRACE, `Writing ${resolvedPath} to ${adapter.name === "virtual" ? "the virtual file system" : adapter.name === "file-system" ? "the local file system" : adapter.name} (size: ${prettyBytes(new Blob$1(toArray(code)).size)})`);
-    const id = this.#normalizeId(meta.id || resolvedPath);
-    this.metadata[id] = {
-      type: "normal",
-      timestamp: Date.now(),
-      ...this.metadata[id] ?? {},
-      ...meta
-    };
-    this.paths[id] = resolvedPath;
-    this.ids[resolvedPath] = id;
-    return adapter.set(relativeKey, code);
-  }
-  /**
-  * Synchronously writes a file to the virtual file system (VFS).
-  *
-  * @param path - The file to write.
-  * @param data - The contents of the file.
-  * @param options - Optional parameters for writing the file.
-  */
-  writeSync(path, data = "", options = {}) {
-    const meta = options.meta ?? {};
-    const resolvedPath = this.resolveSync(this.#normalizePath(path)) || path;
-    const { relativeKey, adapter } = this.#getStorage(resolvedPath, options.storage);
-    this.#log(LogLevelLabel.TRACE, `Writing ${resolvedPath} file to ${adapter.name === "virtual" ? "the virtual file system" : adapter.name === "file-system" ? "the local file system" : adapter.name} (size: ${prettyBytes(new Blob$1(toArray(data)).size)})`);
-    const id = this.#normalizeId(meta.id || resolvedPath);
-    this.metadata[id] = {
-      type: "normal",
-      timestamp: Date.now(),
-      ...this.metadata[id] ?? {},
-      ...meta
-    };
-    this.paths[id] = resolvedPath;
-    this.ids[resolvedPath] = id;
-    return adapter.setSync(relativeKey, data);
-  }
-  /**
-  * Synchronously creates a directory at the specified path.
-  *
-  * @param dirPath - The path of the directory to create.
-  */
-  mkdirSync(dirPath) {
-    return this.#getStorage(dirPath)?.adapter?.mkdirSync(dirPath);
-  }
-  /**
-  * Creates a directory at the specified path.
-  *
-  * @param path - The path of the directory to create.
-  */
-  async mkdir(path) {
-    return this.#getStorage(path)?.adapter?.mkdir(path);
-  }
-  /**
-  * Retrieves the metadata of a file in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID of the file to retrieve metadata for.
-  * @returns The metadata of the file, or undefined if the file does not exist.
-  */
-  getMetadata(pathOrId) {
-    const resolved = this.resolveSync(pathOrId);
-    if (resolved && this.metadata[resolved]) {
-      return this.metadata[resolved];
-    }
-    return void 0;
-  }
-  /**
-  * Resolves a given module ID using the configured aliases.
-  *
-  * @remarks
-  * This function can be used to map module IDs to different paths based on the alias configuration.
-  *
-  * @param id - The module ID to resolve.
-  * @returns The resolved module ID - after applying any configured aliases (this will be the same as the input ID if no aliases match).
-  */
-  resolveAlias(id) {
-    let path = id;
-    if (this.#context.config.resolve.alias) {
-      if (Array.isArray(this.#context.config.resolve.alias) && this.#context.config.resolve.alias.length > 0) {
-        const found = this.#context.config.resolve.alias.filter((alias) => isSetString(alias.find) && (alias.find === path || path.startsWith(`${alias.find}/`)) || isRegExp(alias.find) && alias.find.test(path));
-        if (found.length > 0) {
-          const alias = found.reduce((ret, current) => {
-            const retLength = isSetString(ret.find) ? ret.find.length : isRegExp(ret.find) ? ret.find.source.length : 0;
-            const currentLength = isSetString(current.find) ? current.find.length : isRegExp(current.find) ? current.find.source.length : 0;
-            return retLength > currentLength ? ret : current;
-          });
-          if (isSetString(alias.find)) {
-            path = path.replace(new RegExp(`^${alias.find}`), alias.replacement);
-          } else if (isRegExp(alias.find)) {
-            path = path.replace(alias.find, alias.replacement);
-          }
-        }
-      } else if (isSetObject(this.#context.config.resolve.alias)) {
-        const found = Object.keys(this.#context.config.resolve.alias).filter((key) => key === path || path.startsWith(`${key}/`));
-        if (found.length > 0) {
-          const alias = found.reduce((ret, current) => {
-            return ret.length > current.length ? ret : current;
-          });
-          path = path.replace(new RegExp(`^${alias}`), this.#context.config.resolve.alias[alias]);
-        }
-      }
-    }
-    return path;
-  }
-  /**
-  * A helper function to resolve modules in the virtual file system (VFS).
-  *
-  * @remarks
-  * This function can be used to resolve modules relative to the project root directory.
-  *
-  * @example
-  * ```ts
-  * const resolved = await context.resolvePath("some-module", "/path/to/importer");
-  * ```
-  *
-  * @param id - The module to resolve.
-  * @param importer - An optional path to the importer module.
-  * @param options - Additional resolution options.
-  * @returns A promise that resolves to the resolved module path.
-  */
-  async resolve(id, importer, options = {}) {
-    let path = id;
-    if (path.includes("{") || path.includes("}")) {
-      path = replacePathTokens(this.#context, path);
-    }
-    if (options.skipAlias !== true) {
-      path = this.resolveAlias(path);
-    }
-    if (isAbsolutePath(path)) {
-      return path;
-    }
-    const resolverCacheKey = murmurhash({
-      path: this.#normalizeId(path),
-      importer,
-      options
-    });
-    let result;
-    if (!this.#context.config.skipCache) {
-      result = this.resolverCache.get(resolverCacheKey);
-      if (result) {
-        return result;
-      }
-    }
-    result = this.paths[this.#normalizeId(path)];
-    if (!result) {
-      const paths = options.paths ?? [];
-      if (importer && !paths.includes(importer)) {
-        paths.push(importer);
-      }
-      paths.push(this.#context.workspaceConfig.workspaceRoot);
-      paths.push(appendPath(this.#context.config.root, this.#context.workspaceConfig.workspaceRoot));
-      paths.push(appendPath(joinPaths(this.#context.config.root, "src"), this.#context.workspaceConfig.workspaceRoot));
-      paths.push(...Object.keys(this.#context.tsconfig?.options?.paths ?? {}).filter((tsconfigPath) => path.startsWith(tsconfigPath.replace(/\*$/, ""))).map((tsconfigPath) => this.#context.tsconfig?.options?.paths?.[tsconfigPath]).flat().filter(Boolean).map((tsconfigPath) => appendPath(tsconfigPath, this.#context.workspaceConfig.workspaceRoot)));
-      for (const combination of getResolutionCombinations(path, {
-        paths
-      })) {
-        const { relativeKey, adapter } = this.#getStorage(combination);
-        if (await adapter.exists(relativeKey)) {
-          result = combination;
-          break;
-        }
-      }
-      if (!result) {
-        try {
-          result = await resolve$1(path, {
-            ...options,
-            paths
-          });
-        } catch {
-        }
-      }
-    }
-    if (result && !this.#context.config.skipCache) {
-      this.resolverCache.set(resolverCacheKey, result);
-    }
-    return result;
-  }
-  /**
-  * A synchronous helper function to resolve modules using the Jiti resolver
-  *
-  * @remarks
-  * This function can be used to resolve modules relative to the project root directory.
-  *
-  * @example
-  * ```ts
-  * const resolvedPath = context.resolveSync("some-module", "/path/to/importer");
-  * ```
-  *
-  * @param id - The module to resolve.
-  * @param importer - An optional path to the importer module.
-  * @param options - Additional resolution options.
-  * @returns The resolved module path.
-  */
-  resolveSync(id, importer, options = {}) {
-    let path = id;
-    if (path.includes("{") || path.includes("}")) {
-      path = replacePathTokens(this.#context, path);
-    }
-    if (options.skipAlias !== true) {
-      path = this.resolveAlias(path);
-    }
-    if (isAbsolutePath(path)) {
-      return path;
-    }
-    let result;
-    if (!this.#context.config.skipCache) {
-      result = this.resolverCache.get(this.#normalizeId(path));
-      if (result) {
-        return result;
-      }
-    }
-    result = this.paths[this.#normalizeId(path)];
-    if (!result) {
-      const paths = options.paths ?? [];
-      if (importer && !paths.includes(importer)) {
-        paths.push(importer);
-      }
-      paths.push(this.#context.workspaceConfig.workspaceRoot);
-      paths.push(appendPath(this.#context.config.root, this.#context.workspaceConfig.workspaceRoot));
-      paths.push(appendPath(joinPaths(this.#context.config.root, "src"), this.#context.workspaceConfig.workspaceRoot));
-      paths.push(...Object.keys(this.#context.tsconfig?.options?.paths ?? {}).filter((tsconfigPath) => path.startsWith(tsconfigPath.replace(/\*$/, ""))).map((tsconfigPath) => this.#context.tsconfig?.options?.paths?.[tsconfigPath]).flat().filter(Boolean).map((tsconfigPath) => appendPath(tsconfigPath, this.#context.workspaceConfig.workspaceRoot)));
-      for (const combination of getResolutionCombinations(path, {
-        paths
-      })) {
-        const { relativeKey, adapter } = this.#getStorage(combination);
-        if (adapter.existsSync(relativeKey)) {
-          result = combination;
-          break;
-        }
-      }
-      if (!result) {
-        try {
-          result = resolveSync(path, {
-            ...options,
-            paths
-          });
-        } catch {
-        }
-      }
-    }
-    if (result && !this.#context.config.skipCache) {
-      this.resolverCache.set(this.#normalizeId(path), result);
-    }
-    return result;
-  }
-  /**
-  * Disposes of the virtual file system (VFS) by saving its state to disk.
-  */
-  async dispose() {
-    if (!this.#isDisposed) {
-      this.#isDisposed = true;
-      this.#log(LogLevelLabel.DEBUG, "Disposing virtual file system...");
-      await this.remove(joinPaths(this.#context.dataPath, "fs.bin"));
-      const message = new $.Message();
-      const fs = message.initRoot(FileSystem);
-      const storage = fs._initStorage(Object.keys(this.#paths).length);
-      await Promise.all(Object.values(this.#paths).map(async (path, index) => {
-        const code = await this.read(path);
-        const fd = storage.get(index);
-        fd.path = path;
-        fd.code = code || "";
-      }));
-      const ids = fs._initIds(Object.keys(this.#ids).length);
-      Object.entries(this.#ids).filter(([, id]) => id).forEach(([path, id], index) => {
-        const fileId = ids.get(index);
-        fileId.id = id;
-        fileId.path = path;
-      });
-      const metadata = fs._initMetadata(Object.keys(this.#metadata).length);
-      Object.entries(this.#metadata).filter(([, value]) => value).forEach(([id, value], index) => {
-        const fileMetadata = metadata.get(index);
-        fileMetadata.id = id;
-        fileMetadata.type = value.type;
-        fileMetadata.timestamp = value.timestamp ?? Date.now();
-        if (value.properties) {
-          const props = fileMetadata._initProperties(Object.keys(value.properties).length);
-          Object.entries(value.properties).filter(([, val]) => isSetString(val)).forEach(([key, val], index2) => {
-            const prop = props.get(index2);
-            prop.key = key;
-            prop.value = val;
-          });
-        }
-      });
-      await writeFileBuffer(joinPaths(this.#context.dataPath, "fs.bin"), message.toArrayBuffer());
-      if (!this.#context.config.skipCache) {
-        this.#resolverCache.save(true);
-      }
-      await Promise.all(this.#getStorages().map(async (storage2) => storage2.adapter.dispose()));
-      this.#log(LogLevelLabel.TRACE, "Virtual file system has been disposed.");
-    }
-  }
-  // /**
-  //  * Initializes the virtual file system (VFS) by patching the file system module if necessary.
-  //  */
-  // public [__VFS_PATCH__]() {
-  //   if (!this.#isPatched && this.#context.config.output.mode !== "fs") {
-  //     this.#revert = patchFS(fs, this);
-  //     this.#isPatched = true;
-  //   }
-  // }
-  // /**
-  //  * Reverts the file system module to its original state if it was previously patched.
-  //  */
-  // public [__VFS_REVERT__]() {
-  //   if (this.#isPatched && this.#context.config.output.mode !== "fs") {
-  //     if (!this.#revert) {
-  //       throw new Error(
-  //         "Attempting to revert File System patch prior to calling `__init__` function"
-  //       );
-  //     }
-  //     this.#revert?.();
-  //     this.#isPatched = false;
-  //   }
-  // }
-  async [Symbol.asyncDispose]() {
-    return this.dispose();
-  }
-};
-
-// ../powerlines/src/context/context.ts
-var configCache = /* @__PURE__ */ new WeakMap();
-var envPathCache = /* @__PURE__ */ new WeakMap();
-var agent = new Agent({
-  keepAliveTimeout: 1e4
-});
-setGlobalDispatcher(agent.compose(interceptors.retry({
-  maxRetries: 3,
-  minTimeout: 1e3,
-  maxTimeout: 1e4,
-  timeoutFactor: 2,
-  retryAfter: true
-})));
-var PowerlinesContext = class _PowerlinesContext {
-  static {
-    __name(this, "PowerlinesContext");
-  }
-  /**
-  * Internal references storage
-  *
-  * @danger
-  * This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
-  *
-  * @internal
-  */
-  #internal = {};
-  #workspaceConfig;
-  #checksum = null;
-  #buildId = uuid();
-  #releaseId = uuid();
-  #timestamp = Date.now();
-  #fs;
-  #tsconfig;
-  #parserCache;
-  #requestCache;
-  #getConfigProps(config = {}) {
-    return mergeConfig({
-      root: config.root,
-      name: config.name,
-      title: config.title,
-      organization: config.organization,
-      compatibilityDate: resolveCompatibilityDates(config.compatibilityDate, "latest"),
-      description: config.description,
-      configFile: config.configFile,
-      projectType: config.projectType,
-      customLogger: config.customLogger,
-      logLevel: config.logLevel,
-      tsconfig: config.tsconfig,
-      tsconfigRaw: config.tsconfigRaw,
-      skipCache: config.skipCache,
-      autoInstall: config.autoInstall,
-      input: config.input,
-      output: config.output,
-      plugins: config.plugins,
-      mode: config.mode,
-      resolve: config.resolve,
-      framework: config.framework,
-      ...config
-    }, {
-      output: config.framework ? {
-        artifactsPath: `.${config.framework ?? "powerlines"}`,
-        dts: joinPaths(config.root ?? this.config.root, `${config.framework ?? "powerlines"}.d.ts`)
-      } : {}
-    });
-  }
-  /**
-  * 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);
-    const powerlinesPath = await resolvePackage("powerlines");
-    if (!powerlinesPath) {
-      throw new Error("Could not resolve `powerlines` package location.");
-    }
-    context.powerlinesPath = powerlinesPath;
-    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 configuration options
-  */
-  resolvePatterns = [];
-  /**
-  * Internal context fields and methods
-  *
-  * @danger
-  * This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
-  *
-  * @internal
-  */
-  get $$internal() {
-    return this.#internal;
-  }
-  /**
-  * Internal context fields and methods
-  *
-  * @danger
-  * This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
-  *
-  * @internal
-  */
-  set $$internal(value) {
-    this.#internal = value;
-  }
-  /**
-  * The resolved entry type definitions for the project
-  */
-  get entry() {
-    const entry = this.resolvedEntry;
-    return resolveEntriesSync(this, entry && entry.length > 0 ? entry : Array.isArray(this.config.input) || isSetObject(this.config.input) && !isRegExp(this.config.input) ? this.config.input : toArray(this.config.input));
-  }
-  /**
-  * 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;
-    this.resolvePatterns = tsconfigPathsToRegExp(value?.options?.paths ?? {});
-  }
-  /**
-  * The virtual file system interface for the project
-  */
-  get fs() {
-    if (!this.#fs) {
-      this.#fs = VirtualFileSystem.createSync(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,
-      rootHash: murmurhash({
-        workspaceRoot: this.workspaceConfig?.workspaceRoot,
-        root: this.config?.root
-      }, {
-        maxLength: ROOT_HASH_LENGTH
-      }),
-      configHash: murmurhash(this.config, {
-        maxLength: CACHE_HASH_LENGTH
-      })
-    };
-  }
-  /**
-  * 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 (envPathCache.has({
-      workspaceRoot: this.workspaceConfig.workspaceRoot,
-      framework: this.config?.framework || "powerlines"
-    })) {
-      return envPathCache.get({
-        workspaceRoot: this.workspaceConfig.workspaceRoot,
-        framework: this.config?.framework || "powerlines"
-      });
-    }
-    const envPaths = getEnvPaths({
-      orgId: "storm-software",
-      appId: this.config?.framework || "powerlines",
-      workspaceRoot: this.workspaceConfig.workspaceRoot
-    });
-    envPathCache.set({
-      workspaceRoot: this.workspaceConfig.workspaceRoot,
-      framework: this.config?.framework || "powerlines"
-    }, envPaths);
-    return envPaths;
-  }
-  /**
-  * Get the path to the artifacts directory for the project
-  */
-  get artifactsPath() {
-    return joinPaths(this.workspaceConfig.workspaceRoot, this.config.root, this.config.output.artifactsPath);
-  }
-  /**
-  * Get the path to the builtin modules used by the project
-  */
-  get builtinsPath() {
-    return joinPaths(this.artifactsPath, "builtins");
-  }
-  /**
-  * Get the path to the entry directory for the project
-  */
-  get entryPath() {
-    return joinPaths(this.artifactsPath, "entry");
-  }
-  /**
-  * Get the path to the data directory for the project
-  */
-  get dataPath() {
-    return joinPaths(this.envPaths.data, "projects", getPrefixedRootHash(this.config.name, this.meta.rootHash));
-  }
-  /**
-  * Get the path to the cache directory for the project
-  */
-  get cachePath() {
-    return joinPaths(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(this.workspaceConfig.workspaceRoot, this.config.root, "powerlines.d.ts");
-  }
-  /**
-  * Get the project root relative to the workspace root
-  */
-  get relativeToWorkspaceRoot() {
-    return relativeToWorkspaceRoot(this.config.root);
-  }
-  /**
-  * The builtin module id that exist in the Powerlines virtual file system
-  */
-  get builtins() {
-    return Object.values(this.fs.metadata).filter((meta) => meta && meta.type === "builtin").map((meta) => meta?.id).filter(Boolean);
-  }
-  /**
-  * The alias mappings for the project used during module resolution
-  *
-  * @remarks
-  * This includes both the built-in module aliases as well as any custom aliases defined in the build configuration.
-  */
-  get alias() {
-    return this.builtins.reduce((ret, id) => {
-      const moduleId = `${this.config?.framework || "powerlines"}:${id.replace(/^.*?:/, "")}`;
-      if (!ret[moduleId]) {
-        const path = this.fs.paths[id];
-        if (path) {
-          ret[moduleId] = path;
-        }
-      }
-      return ret;
-    }, this.config.resolve.alias ? Array.isArray(this.config.resolve.alias) ? this.config.resolve.alias.reduce((ret, alias) => {
-      if (!ret[alias.find.toString()]) {
-        ret[alias.find.toString()] = alias.replacement;
-      }
-      return ret;
-    }, {}) : this.config.resolve.alias : {});
-  }
-  /**
-  * Gets the parser cache.
-  */
-  get parserCache() {
-    if (!this.#parserCache) {
-      this.#parserCache = create({
-        cacheId: "parser",
-        cacheDir: this.cachePath,
-        ttl: 2 * 60 * 60 * 1e3,
-        lruSize: 5e3,
-        persistInterval: 250
-      });
-    }
-    return this.#parserCache;
-  }
-  /**
-  * Gets the request cache.
-  */
-  get requestCache() {
-    if (!this.#requestCache) {
-      this.#requestCache = create({
-        cacheId: "http",
-        cacheDir: this.cachePath,
-        ttl: 6 * 60 * 60 * 1e3,
-        lruSize: 5e3,
-        persistInterval: 250
-      });
-    }
-    return this.#requestCache;
-  }
-  /**
-  * The entry points that exist in the Powerlines virtual file system
-  */
-  get resolvedEntry() {
-    return Object.entries(this.fs.metadata).filter(([, meta]) => meta && meta.type === "entry").map(([path, meta]) => {
-      const typeDefinition = {
-        file: path
-      };
-      if (meta.properties) {
-        if (isSetString(meta.properties.file)) {
-          typeDefinition.file = meta.properties.file;
-        }
-        if (isSetString(meta.properties.name)) {
-          typeDefinition.name = meta.properties.name;
-        }
-        if (isSetString(meta.properties["input.file"]) || isSetString(meta.properties["input.name"])) {
-          typeDefinition.input ??= {};
-          if (isSetString(meta.properties["input.file"])) {
-            typeDefinition.input.file = meta.properties["input.file"];
-          }
-          if (isSetString(meta.properties["input.name"])) {
-            typeDefinition.input.name = meta.properties["input.name"];
-          }
-        }
-        if (isSetString(meta.properties.output)) {
-          typeDefinition.output = meta.properties.output;
-        }
-      }
-      return typeDefinition;
-    }).filter(Boolean);
-  }
-  /**
-  * A function to perform HTTP fetch requests
-  *
-  * @remarks
-  * This function uses a caching layer to avoid duplicate requests during the Powerlines process.
-  *
-  * @example
-  * ```ts
-  * const response = await context.fetch("https://api.example.com/data");
-  * const data = await response.json();
-  * ```
-  *
-  * @see https://github.com/nodejs/undici
-  *
-  * @param input - The URL to fetch.
-  * @param options - The fetch request options.
-  * @returns A promise that resolves to a response returned by the fetch.
-  */
-  async fetch(input, options = {}) {
-    const cacheKey = murmurhash({
-      input: input.toString(),
-      options: JSON.stringify(options)
-    });
-    if (!this.config.skipCache && !options.skipCache) {
-      const cached = this.requestCache.get(cacheKey);
-      if (cached) {
-        return new Response(cached.body, {
-          status: cached.status,
-          statusText: cached.statusText,
-          headers: cached.headers
-        });
-      }
-    }
-    const response = await fetchRequest(input, {
-      timeout: 12e3,
-      ...options
-    });
-    const result = {
-      body: await response.text(),
-      status: response.status,
-      statusText: response.statusText,
-      headers: Object.fromEntries(response.headers.entries())
-    };
-    if (!this.config.skipCache && !options.skipCache) {
-      try {
-        this.requestCache.set(cacheKey, result);
-      } catch {
-      }
-    }
-    return new Response(result.body, {
-      status: result.status,
-      statusText: result.statusText,
-      headers: result.headers
-    });
-  }
-  /**
-  * Parse code using [Oxc-Parser](https://github.com/oxc/oxc) into an (ESTree-compatible)[https://github.com/estree/estree] AST object.
-  *
-  * @remarks
-  * This function can be used to parse TypeScript code into an AST for further analysis or transformation.
-  *
-  * @example
-  * ```ts
-  * const ast = context.parse("const x: number = 42;");
-  * ```
-  *
-  * @see https://rollupjs.org/plugin-development/#this-parse
-  * @see https://github.com/oxc/oxc
-  *
-  * @param code - The source code to parse.
-  * @param options - The options to pass to the parser.
-  * @returns An (ESTree-compatible)[https://github.com/estree/estree] AST object.
-  */
-  async parse(code, options = {}) {
-    const cacheKey = murmurhash({
-      code,
-      options
-    });
-    let result;
-    if (!this.config.skipCache) {
-      result = this.parserCache.get(cacheKey);
-      if (result) {
-        return result;
-      }
-    }
-    result = await parse(`source.${options.lang || "ts"}`, code, {
-      ...options,
-      sourceType: "module",
-      showSemanticErrors: this.config.mode === "development"
-    });
-    if (!this.config.skipCache) {
-      this.parserCache.set(cacheKey, result);
-    }
-    return result;
-  }
-  /**
-  * A helper function to resolve modules in the Virtual File System
-  *
-  * @remarks
-  * This function can be used to resolve modules relative to the project root directory.
-  *
-  * @example
-  * ```ts
-  * const resolved = await context.resolve("some-module", "/path/to/importer");
-  * ```
-  *
-  * @param id - The module to resolve.
-  * @param importer - An optional path to the importer module.
-  * @param options - Additional resolution options.
-  * @returns A promise that resolves to the resolved module path.
-  */
-  async resolve(id, importer, options = {}) {
-    let moduleId = id;
-    if (this.config.resolve.alias) {
-      if (Array.isArray(this.config.resolve.alias)) {
-        const alias = this.config.resolve.alias.find((a) => match(moduleId, [
-          a.find
-        ]));
-        if (alias) {
-          moduleId = alias.replacement;
-        }
-      } else if (isSetObject(this.config.resolve.alias) && this.config.resolve.alias[id]) {
-        moduleId = this.config.resolve.alias[id];
-      }
-    }
-    if (this.fs.isVirtual(moduleId)) {
-      const result = await this.fs.resolve(moduleId, importer, {
-        conditions: this.config.resolve.conditions,
-        extensions: this.config.resolve.extensions,
-        ...options
-      });
-      if (!result) {
-        return void 0;
-      }
-      return {
-        id: `\0${result}`,
-        external: this.config.projectType !== "application"
-      };
-    }
-    if (this.config.resolve.skipNodeModulesBundle) {
-      if (match(moduleId, this.resolvePatterns) || match(moduleId, this.config.resolve.noExternal)) {
-        return void 0;
-      }
-      if (match(moduleId, this.config.resolve.external) || moduleId.startsWith("node:")) {
-        return {
-          id: moduleId,
-          external: true
-        };
-      }
-      if (!/^[A-Z]:[/\\]|^\.{0,2}\/|^\.{1,2}$/.test(moduleId)) {
-        return {
-          id: moduleId,
-          external: true
-        };
-      }
-    } else {
-      if (match(moduleId, this.config.resolve.noExternal)) {
-        return void 0;
-      }
-      if (match(moduleId, this.config.resolve.external) || moduleId.startsWith("node:")) {
-        return {
-          id: moduleId,
-          external: true
-        };
-      }
-    }
-    return void 0;
-  }
-  /**
-  * A helper function to load modules from the Virtual File System
-  *
-  * @remarks
-  * This function can be used to load modules relative to the project root directory.
-  *
-  * @example
-  * ```ts
-  * const module = await context.load("some-module", "/path/to/importer");
-  * ```
-  *
-  * @param id - The module to load.
-  * @returns A promise that resolves to the loaded module.
-  */
-  async load(id) {
-    const resolvedId = await this.fs.resolve(id);
-    if (!resolvedId) {
-      return void 0;
-    }
-    const code = await this.fs.read(resolvedId);
-    if (!code) {
-      return void 0;
-    }
-    return {
-      code,
-      map: null
-    };
-  }
-  /**
-  * Get the builtin virtual files that exist in the Powerlines virtual file system
-  */
-  async getBuiltins() {
-    return Promise.all(Object.entries(this.fs.metadata).filter(([, meta]) => meta && meta.type === "builtin").map(async ([id, meta]) => {
-      const code = await this.fs.read(id);
-      const path = this.fs.paths[id];
-      return {
-        ...meta,
-        path,
-        code
-      };
-    }));
-  }
-  /**
-  * Resolves a file and writes it to the VFS if it does not already exist
-  *
-  * @param code - The source code of the file
-  * @param path - The path to write the file to
-  * @param options - Additional options for writing the file
-  */
-  async emit(code, path, options = {}) {
-    const filePath = options.extension ? findFileExtensionSafe(path) ? options.extension.startsWith(".") ? path.replace(findFileDotExtensionSafe(path), options.extension) : path.replace(findFileExtensionSafe(path), options.extension) : options.extension.startsWith(".") ? `${path}${options.extension}` : `${path}.${options.extension}` : findFileExtensionSafe(path) ? path : `${path}.ts`;
-    if (isFunction(this.emitFile) && options.emitWithBundler) {
-      return this.emitFile({
-        needsCodeReference: options.needsCodeReference,
-        originalFileName: options.originalFileName,
-        fileName: filePath,
-        source: code,
-        type: "asset"
-      });
-    }
-    return this.fs.write(filePath, code, options);
-  }
-  /**
-  * Synchronously resolves a file and writes it to the VFS if it does not already exist
-  *
-  * @param code - The source code of the file
-  * @param path - The path to write the file to
-  * @param options - Additional options for writing the file
-  */
-  emitSync(code, path, options = {}) {
-    const filePath = options.extension ? findFileExtensionSafe(path) ? options.extension.startsWith(".") ? path.replace(findFileDotExtensionSafe(path), options.extension) : path.replace(findFileExtensionSafe(path), options.extension) : options.extension.startsWith(".") ? `${path}${options.extension}` : `${path}.${options.extension}` : findFileExtensionSafe(path) ? path : `${path}.ts`;
-    if (isFunction(this.emitFile) && options.emitWithBundler) {
-      return this.emitFile({
-        needsCodeReference: options.needsCodeReference,
-        originalFileName: options.originalFileName,
-        fileName: filePath,
-        source: code,
-        type: "asset"
-      });
-    }
-    return this.fs.writeSync(filePath, code, options);
-  }
-  /**
-  * 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 emitEntry(code, path, options = {}) {
-    return this.emit(code, appendPath(path, this.entryPath), defu7({
-      meta: {
-        type: "entry",
-        properties: {
-          file: appendPath(path, this.entryPath),
-          name: options?.name,
-          output: options?.output,
-          "input.file": options?.input?.file,
-          "input.name": options?.input?.name
-        }
-      }
-    }, omit(options, [
-      "name"
-    ])));
-  }
-  /**
-  * Synchronously 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
-  */
-  emitEntrySync(code, path, options = {}) {
-    return this.emitSync(code, appendPath(path, this.entryPath), defu7({
-      meta: {
-        type: "entry",
-        properties: {
-          file: appendPath(path, this.entryPath),
-          name: options?.name,
-          output: options?.output,
-          "input.file": options?.input?.file,
-          "input.name": options?.input?.name
-        }
-      }
-    }, omit(options, [
-      "name"
-    ])));
-  }
-  /**
-  * 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 options - Optional write file options
-  */
-  async emitBuiltin(code, id, options = {}) {
-    if (!this.builtinsPath) {
-      throw new Error(`The builtins path is not set. Cannot emit builtin file with id "${id}".`);
-    }
-    if (!isSetString(id)) {
-      throw new Error(`The builtin id must be a non-empty string. Received: ${String(id)}`);
-    }
-    return this.emit(code, appendPath(id, this.builtinsPath), defu7(options, {
-      meta: {
-        type: "builtin",
-        id
-      }
-    }));
-  }
-  /**
-  * Synchronously 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 options - Optional write file options
-  */
-  emitBuiltinSync(code, id, options = {}) {
-    if (!this.builtinsPath) {
-      throw new Error(`The builtins path is not set. Cannot emit builtin file with id "${id}".`);
-    }
-    if (!isSetString(id)) {
-      throw new Error(`The builtin id must be a non-empty string. Received: ${String(id)}`);
-    }
-    return this.emitSync(code, appendPath(id, this.builtinsPath), defu7(options, {
-      meta: {
-        type: "builtin",
-        id
-      }
-    }));
-  }
-  /**
-  * 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(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);
-  }
-  /**
-  * A logging function for fatal messages
-  *
-  * @param message - The message to log.
-  */
-  fatal(message) {
-    this.log(LogLevelLabel.FATAL, isString(message) ? message : StormJSON.stringify(message));
-  }
-  /**
-  * A logging function for error messages
-  *
-  * @param message - The message to log.
-  */
-  error(message) {
-    this.log(LogLevelLabel.ERROR, isString(message) ? message : StormJSON.stringify(message));
-  }
-  /**
-  * A logging function for warning messages
-  *
-  * @param message - The message to log.
-  */
-  warn(message) {
-    this.log(LogLevelLabel.WARN, isString(message) ? message : StormJSON.stringify(message));
-  }
-  /**
-  * A logging function for informational messages
-  *
-  * @param message - The message to log.
-  */
-  info(message) {
-    this.log(LogLevelLabel.INFO, isString(message) ? message : StormJSON.stringify(message));
-  }
-  /**
-  * A logging function for debug messages
-  *
-  * @param message - The message to log.
-  */
-  debug(message) {
-    this.log(LogLevelLabel.DEBUG, isString(message) ? message : StormJSON.stringify(message));
-  }
-  /**
-  * A logging function for trace messages
-  *
-  * @param message - The message to log.
-  */
-  trace(message) {
-    this.log(LogLevelLabel.TRACE, isString(message) ? message : StormJSON.stringify(message));
-  }
-  /**
-  * 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);
-  }
-  /**
-  * Generates a checksum representing the current context state
-  *
-  * @param root - The root directory of the project to generate the checksum for
-  * @returns A promise that resolves to a string representing the checksum
-  */
-  async generateChecksum(root = this.config.root) {
-    this.#checksum = await hashDirectory(root, {
-      ignore: [
-        "node_modules",
-        ".git",
-        ".nx",
-        ".cache",
-        "tmp",
-        "dist"
-      ]
-    });
-    return this.#checksum;
-  }
-  /**
-  * Creates a new StormContext instance.
-  *
-  * @param workspaceConfig - The workspace configuration.
-  */
-  constructor(workspaceConfig) {
-    this.#workspaceConfig = workspaceConfig;
-    envPathCache.set({
-      workspaceRoot: workspaceConfig.workspaceRoot,
-      framework: "powerlines"
-    }, getEnvPaths({
-      orgId: (isSetObject(workspaceConfig.organization) ? workspaceConfig.organization.name : workspaceConfig.organization) || "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 = {
-      root: config.root ?? this.config.root ?? 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,
-      framework: config.framework ?? this.config.framework ?? "powerlines",
-      command: this.config.inlineConfig?.command,
-      alias: this.config.resolve?.alias ?? config.resolve?.alias
-    };
-    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(cacheKey.root, "project.json");
-      if (existsSync(projectJsonPath)) {
-        this.projectJson = await readJsonFile(projectJsonPath);
-      }
-      const packageJsonPath = joinPaths(cacheKey.root, "package.json");
-      if (existsSync(packageJsonPath)) {
-        this.packageJson = await readJsonFile(packageJsonPath);
-      }
-      this.#checksum = await this.generateChecksum(cacheKey.root);
-      this.resolver = createResolver({
-        workspaceRoot: this.workspaceConfig.workspaceRoot,
-        root: cacheKey.root,
-        cacheDir: this.cachePath,
-        mode: cacheKey.mode,
-        logLevel: config.logLevel || this.config.logLevel || this.workspaceConfig.logLevel || "info",
-        skipCache: cacheKey.skipCache,
-        alias: this.config.resolve?.alias ? Array.isArray(this.config.resolve.alias) ? this.config.resolve.alias.reduce((ret, alias) => {
-          ret[alias.find.toString()] = alias.replacement;
-          return ret;
-        }, {}) : this.config.resolve.alias : {}
-      });
-      const userConfig = await loadUserConfigFile(cacheKey.root, this.workspaceConfig.workspaceRoot, this.resolver, cacheKey.command, cacheKey.mode, cacheKey.configFile, cacheKey.framework);
-      this.mergeUserConfig(userConfig.config);
-      configCache.set(cacheKey, {
-        projectJson: this.projectJson,
-        packageJson: this.packageJson,
-        checksum: this.#checksum,
-        resolver: this.resolver,
-        userConfig
-      });
-    }
-    config.tsconfig ??= getTsconfigFilePath(this.workspaceConfig.workspaceRoot, cacheKey.root, config.tsconfig);
-    if (isSetObject(config)) {
-      this.resolvedConfig = mergeConfig({
-        inlineConfig: this.config.inlineConfig,
-        userConfig: this.config.userConfig
-      }, options.isHighPriority ? this.#getConfigProps(config) : {}, {
-        ...this.#getConfigProps(this.config.inlineConfig),
-        command: this.config.inlineConfig?.command
-      }, 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,
-        output: mergeConfig(config.output ?? {}, {
-          outputPath: cacheKey.root ? joinPaths(this.workspaceConfig?.directories?.build || "dist", cacheKey.root) : this.workspaceConfig?.directories?.build || "dist",
-          artifactsPath: `.${config.framework ?? "powerlines"}`,
-          dts: joinPaths(cacheKey.root, `${config.framework ?? "powerlines"}.d.ts`),
-          assets: [
-            {
-              glob: "LICENSE"
-            },
-            {
-              input: cacheKey.root,
-              glob: "*.md"
-            },
-            {
-              input: cacheKey.root,
-              glob: "package.json"
-            }
-          ]
-        })
-      }, options.isHighPriority ? {} : this.#getConfigProps(config), {
-        inlineConfig: {},
-        userConfig: {},
-        framework: "powerlines",
-        mode: "production",
-        projectType: "application",
-        platform: "neutral",
-        logLevel: "info",
-        preview: false,
-        environments: {},
-        resolve: {}
-      });
-    }
-    this.config.input = getUniqueInputs(this.config.input);
-    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);
-    this.config.organization ??= (isSetObject(this.workspaceConfig.organization) ? this.workspaceConfig.organization.name : this.workspaceConfig.organization) || (isSetObject(this.packageJson?.author) ? this.packageJson?.author?.name : this.packageJson?.author) || this.config.name;
-    if (this.config.userConfig.resolve?.external) {
-      this.config.userConfig.resolve.external = getUnique(this.config.userConfig.resolve.external);
-    }
-    if (this.config.userConfig.resolve?.noExternal) {
-      this.config.userConfig.resolve.noExternal = getUnique(this.config.userConfig.resolve.noExternal);
-    }
-    if (this.config.resolve.external) {
-      this.config.resolve.external = getUnique(this.config.resolve.external);
-    }
-    if (this.config.resolve.noExternal) {
-      this.config.resolve.noExternal = getUnique(this.config.resolve.noExternal);
-    }
-    this.config.output.format = getUnique(toArray(this.config.output?.format ?? (this.config.projectType === "library" ? [
-      "cjs",
-      "esm"
-    ] : [
-      "esm"
-    ])));
-    if (this.config.root && this.config.root !== "." && this.config.root !== "./" && this.config.root !== this.workspaceConfig.workspaceRoot) {
-      this.config.output.outputPath ??= joinPaths("dist", this.config.root);
-      this.config.output.buildPath ??= joinPaths(this.config.root, "dist");
-    } else {
-      this.config.output.outputPath ??= "dist";
-      this.config.output.buildPath ??= "dist";
-    }
-    this.config.output.assets = getUniqueBy(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 : isParentPath(asset.input, this.workspaceConfig.workspaceRoot) || asset.input === this.workspaceConfig.workspaceRoot ? asset.input : appendPath(asset.input, this.workspaceConfig.workspaceRoot),
-        output: isSetObject(asset) && asset.output ? isParentPath(asset.output, this.workspaceConfig.workspaceRoot) ? asset.output : appendPath(joinPaths(this.config.output.outputPath, replacePath(replacePath(asset.output, replacePath(this.config.output.outputPath, this.workspaceConfig.workspaceRoot)), this.config.output.outputPath)), this.workspaceConfig.workspaceRoot) : appendPath(this.config.output.outputPath, this.workspaceConfig.workspaceRoot),
-        ignore: isSetObject(asset) && asset.ignore ? toArray(asset.ignore) : void 0
-      };
-    }), (a) => `${a.input}-${a.glob}-${a.output}`);
-    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;
-    }, []);
-    if (this.config.tsconfig) {
-      this.config.tsconfig = replacePathTokens(this, this.config.tsconfig);
-    }
-    if (this.config.output.dts) {
-      if (isSetString(this.config.output.dts)) {
-        this.config.output.dts = replacePathTokens(this, this.config.output.dts);
-      } else {
-        this.config.output.dts = joinPaths(this.config.root, `${this.config.framework ?? "powerlines"}.d.ts`);
-      }
-    }
-    if (this.config.output.assets) {
-      this.config.output.assets = this.config.output.assets.map((asset) => ({
-        ...asset,
-        glob: replacePathTokens(this, asset.glob),
-        ignore: asset.ignore ? asset.ignore.map((ignore) => replacePathTokens(this, ignore)) : void 0,
-        input: replacePathTokens(this, asset.input),
-        output: replacePathTokens(this, asset.output)
-      }));
-    }
-    this.#fs ??= await VirtualFileSystem.create(this);
-  }
-  mergeUserConfig(from = {}, into = this.config.userConfig ?? {}) {
-    this.config.userConfig = mergeConfig({
-      input: isSetObject(from.input) && !isRegExp(from.input) && !Array.isArray(from.input) && from.input.file ? from.input.file : isSetObject(into?.input) && !isRegExp(into.input) && !Array.isArray(into.input) && into.input.file ? into.input.file : Array.isArray(from.input) && from.input.length > 0 ? from.input : Array.isArray(into?.input) && into.input.length > 0 ? into.input : []
-    }, omit(from ?? {}, [
-      "input"
-    ]), omit(into ?? {}, [
-      "input"
-    ]));
-    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;
-    }, []);
-  }
-};
-function isUnpluginBuilderVariant(str) {
-  return isSetString(str) && UNPLUGIN_BUILDER_VARIANTS.includes(str);
-}
-__name(isUnpluginBuilderVariant, "isUnpluginBuilderVariant");
-function createPluginContext(plugin, environment) {
-  const normalizeMessage = /* @__PURE__ */ __name((message) => {
-    return isString(message) ? message : message.message;
-  }, "normalizeMessage");
-  const log = environment.extendLog(plugin.name.replaceAll(":", " - "));
-  const callHookFn = /* @__PURE__ */ __name(async (hook, options, ...args) => {
-    return environment.$$internal.api.callHook(hook, {
-      sequential: true,
-      result: "merge",
-      ...options,
-      environment
-    }, ...args);
-  }, "callHookFn");
-  const meta = {};
-  return new Proxy({}, {
-    get(_, prop) {
-      if (prop === "$$internal") {
-        return {
-          ...environment.$$internal,
-          environment,
-          callHook: callHookFn,
-          meta
-        };
-      }
-      if (prop === "log" || prop === "logger") {
-        return log;
-      }
-      if (prop === "fatal") {
-        return (message) => {
-          log(LogLevelLabel.FATAL, normalizeMessage(message));
-        };
-      }
-      if (prop === "error") {
-        return (message) => {
-          log(LogLevelLabel.ERROR, normalizeMessage(message));
-        };
-      }
-      if (prop === "warn") {
-        return (message) => {
-          log(LogLevelLabel.WARN, normalizeMessage(message));
-        };
-      }
-      if (prop === "info") {
-        return (message) => {
-          log(LogLevelLabel.INFO, normalizeMessage(message));
-        };
-      }
-      if (prop === "debug") {
-        return (message) => {
-          log(LogLevelLabel.DEBUG, normalizeMessage(message));
-        };
-      }
-      if (prop === "trace") {
-        return (message) => {
-          log(LogLevelLabel.TRACE, 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");
-
-// ../powerlines/src/context/environment-context.ts
-var PowerlinesEnvironmentContext = class _PowerlinesEnvironmentContext extends PowerlinesContext {
-  static {
-    __name(this, "PowerlinesEnvironmentContext");
-  }
-  /**
-  * The hooks registered by plugins in this environment
-  */
-  #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();
-    const powerlinesPath = await resolvePackage("powerlines");
-    if (!powerlinesPath) {
-      throw new Error("Could not resolve `powerlines` package location.");
-    }
-    context.powerlinesPath = powerlinesPath;
-    return context;
-  }
-  /**
-  * The resolved environment configuration
-  */
-  environment;
-  /**
-  * The list of plugins applied to this environment
-  */
-  plugins = [];
-  /**
-  * The resolved configuration options
-  */
-  get config() {
-    return super.config;
-  }
-  get hooks() {
-    return this.#hooks;
-  }
-  async addPlugin(plugin) {
-    let resolvedPlugin = plugin;
-    if (isFunction(plugin.applyToEnvironment)) {
-      const result = await Promise.resolve(plugin.applyToEnvironment(this.environment));
-      if (!result || isObject(result) && Object.keys(result).length === 0) {
-        return;
-      }
-      if (isPluginConfig(result)) {
-        return this.$$internal.addPlugin(result);
-      }
-      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;
-      if (isPluginHookField(hook)) {
-        const pluginHook = resolvedPlugin[hook];
-        if (!isPluginHook(pluginHook)) {
-          return ret;
-        }
-        ret[hook] ??= {
-          preEnforced: [],
-          preOrdered: [],
-          normal: [],
-          postEnforced: [],
-          postOrdered: []
-        };
-        if (resolvedPlugin.enforce) {
-          const hookListOrder2 = `${resolvedPlugin.enforce}Enforced`;
-          ret[hook][hookListOrder2] ??= [];
-          const bucket = ret[hook][hookListOrder2];
-          addPluginHook(context, resolvedPlugin, pluginHook, bucket);
-          return ret;
-        }
-        if (isFunction(pluginHook) || !pluginHook.order) {
-          ret[hook].normal ??= [];
-          const bucket = ret[hook].normal;
-          addPluginHook(context, resolvedPlugin, pluginHook, bucket);
-          return ret;
-        }
-        const hookListOrder = `${pluginHook.order}Ordered`;
-        ret[hook][hookListOrder] ??= [];
-        addPluginHook(context, resolvedPlugin, pluginHook, ret[hook][hookListOrder]);
-        return ret;
-      } else if (isUnpluginHookField(hook)) {
-        const unpluginPlugin = resolvedPlugin[hook];
-        if (!isSetObject(unpluginPlugin)) {
-          return ret;
-        }
-        for (const field of Object.keys(unpluginPlugin)) {
-          const variantField = field;
-          const pluginHook = unpluginPlugin[variantField];
-          if (!isPluginHook(pluginHook)) {
-            continue;
-          }
-          ret[hook] ??= {};
-          ret[hook][variantField] ??= {
-            preEnforced: [],
-            preOrdered: [],
-            normal: [],
-            postEnforced: [],
-            postOrdered: []
-          };
-          if (resolvedPlugin.enforce) {
-            addPluginHook(context, resolvedPlugin, pluginHook, ret[hook][variantField][`${resolvedPlugin.enforce}Enforced`]);
-            return ret;
-          }
-          if (isFunction(pluginHook) || !pluginHook.order) {
-            addPluginHook(context, resolvedPlugin, pluginHook, ret[hook][variantField].normal);
-            return ret;
-          }
-          addPluginHook(context, resolvedPlugin, pluginHook, ret[hook][variantField][`${pluginHook.order}Ordered`]);
-        }
-      } else {
-        this.warn(`Unknown plugin hook field: ${String(hook)}`);
-      }
-      return ret;
-    }, this.hooks);
-  }
-  /**
-  * Retrieves the hook handlers for a specific hook name
-  */
-  selectHooks(key, options) {
-    const result = [];
-    if (isUnpluginHookKey(key)) {
-      const variant = String(key).split(":")[0];
-      if (isUnpluginBuilderVariant(variant)) {
-        const hooks = this.hooks[variant];
-        if (hooks) {
-          const field = String(key).split(":")[1];
-          if (field && hooks[field]) {
-            const fieldHooks = hooks[field];
-            if (options?.order) {
-              const mapHooksToResult = /* @__PURE__ */ __name((hooksList) => hooksList.map((hook) => {
-                const plugin = this.plugins.find((p) => p.plugin.name === hook.plugin.name);
-                if (!plugin) {
-                  throw new Error(`Could not find plugin context for plugin "${hook.plugin.name}".`);
-                }
-                return {
-                  handler: hook.handler,
-                  plugin: hook.plugin,
-                  context: plugin.context
-                };
-              }), "mapHooksToResult");
-              if (options?.order === "pre") {
-                result.push(...mapHooksToResult(fieldHooks.preOrdered ?? []));
-                result.push(...mapHooksToResult(fieldHooks.preEnforced ?? []));
-              } else if (options?.order === "post") {
-                result.push(...mapHooksToResult(fieldHooks.postOrdered ?? []));
-                result.push(...mapHooksToResult(fieldHooks.postEnforced ?? []));
-              } else {
-                result.push(...mapHooksToResult(fieldHooks.normal ?? []));
-              }
-            } else {
-              result.push(...this.selectHooks(key, {
-                order: "pre"
-              }));
-              result.push(...this.selectHooks(key, {
-                order: "normal"
-              }));
-              result.push(...this.selectHooks(key, {
-                order: "post"
-              }));
-            }
-          }
-        }
-      }
-    } else if (isPluginHookField(key)) {
-      if (this.hooks[key]) {
-        const fieldHooks = this.hooks[key];
-        if (options?.order) {
-          const mapHooksToResult = /* @__PURE__ */ __name((hooksList) => hooksList.map((hook) => {
-            const plugin = this.plugins.find((p) => p.plugin.name === hook.plugin.name);
-            if (!plugin) {
-              throw new Error(`Could not find plugin context for plugin "${hook.plugin.name}".`);
-            }
-            return {
-              handler: hook.handler,
-              plugin: hook.plugin,
-              context: plugin.context
-            };
-          }), "mapHooksToResult");
-          if (options?.order === "pre") {
-            result.push(...mapHooksToResult(fieldHooks.preOrdered ?? []));
-            result.push(...mapHooksToResult(fieldHooks.preEnforced ?? []));
-          } else if (options?.order === "post") {
-            result.push(...mapHooksToResult(fieldHooks.postOrdered ?? []));
-            result.push(...mapHooksToResult(fieldHooks.postEnforced ?? []));
-          } else {
-            result.push(...mapHooksToResult(fieldHooks.normal ?? []));
-          }
-        } else {
-          result.push(...this.selectHooks(key, {
-            order: "pre"
-          }));
-          result.push(...this.selectHooks(key, {
-            order: "normal"
-          }));
-          result.push(...this.selectHooks(key, {
-            order: "post"
-          }));
-        }
-      }
-    } else {
-      throw new Error(`Unknown plugin hook key: ${String(key)}`);
-    }
-    return result;
-  }
-  constructor(config, workspaceConfig) {
-    super(workspaceConfig);
-    this.resolvedConfig = config;
-  }
-};
-
-// ../powerlines/src/context/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);
-    const powerlinesPath = await resolvePackage("powerlines");
-    if (!powerlinesPath) {
-      throw new Error("Could not resolve `powerlines` package location.");
-    }
-    context.powerlinesPath = powerlinesPath;
-    return context;
-  }
-  /**
-  * Internal context fields and methods
-  *
-  * @danger
-  * This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
-  *
-  * @internal
-  */
-  get $$internal() {
-    return super.$$internal;
-  }
-  /**
-  * Internal context fields and methods
-  *
-  * @danger
-  * This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
-  *
-  * @internal
-  */
-  set $$internal(value) {
-    super.$$internal = value;
-    for (const environment of Object.values(this.environments)) {
-      environment.$$internal = super.$$internal;
-    }
-  }
-  /**
-  * A record of all environments by name
-  */
-  get environments() {
-    return this.#environments;
-  }
-  get log() {
-    if (!this.#log) {
-      this.#log = this.createLog();
-    }
-    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;
-  }
-  /**
-  * Update the context using a new user configuration options
-  *
-  * @param userConfig - The new user configuration options.
-  */
-  async withUserConfig(userConfig, options = {
-    isHighPriority: true
-  }) {
-    await super.withUserConfig(userConfig, options);
-    await Promise.all(Object.keys(this.#environments).map(async (name) => {
-      await this.#environments[name].withUserConfig(userConfig, options);
-    }));
-  }
-  /**
-  * Update the context using a new inline configuration options
-  *
-  * @param inlineConfig - The new inline configuration options.
-  */
-  async withInlineConfig(inlineConfig, options = {
-    isHighPriority: true
-  }) {
-    await super.withInlineConfig(inlineConfig, options);
-    await Promise.all(Object.keys(this.#environments).map(async (name) => {
-      await this.#environments[name].withInlineConfig(inlineConfig, options);
-    }));
-  }
-  /**
-  * Add a plugin to the API context and all environments
-  *
-  * @param plugin - The plugin to add.
-  */
-  async addPlugin(plugin) {
-    this.plugins.push(plugin);
-    await Promise.all(Object.keys(this.environments).map(async (name) => {
-      await this.environments[name].addPlugin(plugin);
-    }));
-  }
-  /**
-  * Get an environment by name, or the default environment if no name is provided
-  *
-  * @param name - The name of the environment to retrieve.
-  * @returns The requested environment context.
-  */
-  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.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.warn(`No environment specified, and no default environment found. Using a temporary default environment: ${chalk4.bold.cyanBright(environment?.environment.name)}`);
-    }
-    return environment;
-  }
-  /**
-  * A safe version of `getEnvironment` that returns `undefined` if the environment is not found
-  *
-  * @param name - The name of the environment to retrieve.
-  * @returns The requested environment context or `undefined` if not found.
-  */
-  async getEnvironmentSafe(name) {
-    try {
-      return await this.getEnvironment(name);
-    } catch {
-      return void 0;
-    }
-  }
-  /**
-  * A function to merge all configured environments into a single context.
-  *
-  * @remarks
-  * If only one environment is configured, that environment will be returned directly.
-  *
-  * @returns A promise that resolves to a merged/global environment context.
-  */
-  async toEnvironment() {
-    let environment;
-    if (Object.keys(this.environments).length > 1) {
-      environment = await this.in(createEnvironment(GLOBAL_ENVIRONMENT, this.config.userConfig));
-      this.debug(`Combined all ${Object.keys(this.environments).length} environments into a single global context.`);
-    } else {
-      environment = await this.getEnvironment();
-    }
-    return environment;
-  }
-};
-
-// ../powerlines/src/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 a Powerlines API instance
-  *
-  * @param workspaceRoot - The directory of the underlying workspace the Powerlines project exists in
-  * @param config - An object containing the configuration required to run Powerlines tasks.
-  * @returns A new instance of the Powerlines API
-  */
-  static async from(workspaceRoot, config) {
-    const api = new _PowerlinesAPI(await PowerlinesAPIContext.from(workspaceRoot, config));
-    api.#context.$$internal = {
-      api,
-      addPlugin: api.#addPlugin.bind(api)
-    };
-    api.context.info(`\u{1F50C} The Powerlines Engine v${package_default.version} has started`);
-    for (const plugin of api.context.config.plugins ?? []) {
-      await api.#addPlugin(plugin);
-    }
-    if (api.context.plugins.length === 0) {
-      api.context.warn("No Powerlines plugins were specified in the options. Please ensure this is correct, as it is generally not recommended.");
-    }
-    const pluginConfig = await api.callHook("config", {
-      environment: await api.context.getEnvironment(),
-      sequential: true,
-      result: "merge",
-      merge: mergeConfigs
-    });
-    await api.context.withUserConfig(pluginConfig, {
-      isHighPriority: false
-    });
-    return api;
-  }
-  /**
-  * Prepare the Powerlines API
-  *
-  * @remarks
-  * This method will prepare the Powerlines API for use, initializing any necessary resources.
-  *
-  * @param inlineConfig - The inline configuration for the prepare command
-  */
-  async prepare(inlineConfig = {
-    command: "prepare"
-  }) {
-    this.context.info(" \u{1F3D7}\uFE0F  Preparing the Powerlines project");
-    this.context.debug(" Aggregating configuration options for the Powerlines project");
-    await this.context.withInlineConfig(inlineConfig);
-    await this.#executeEnvironments(async (context) => {
-      context.debug(`Initializing the processing options for the Powerlines project.`);
-      await this.callHook("configResolved", {
-        environment: context,
-        order: "pre"
-      });
-      await initializeTsconfig(context);
-      await this.callHook("configResolved", {
-        environment: context,
-        order: "normal"
-      });
-      if (context.entry.length > 0) {
-        context.debug(`The configuration provided ${isObject(context.config.input) ? Object.keys(context.config.input).length : toArray(context.config.input).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.file}${entry.output ? ` -> ${entry.output}` : ""}`).join(" \n")}` : ""}`);
-      } else {
-        context.warn(`No entry files were found for the ${context.config.title} project. Please ensure this is correct. Powerlines plugins generally require at least one entry point to function properly.`);
-      }
-      await resolveTsconfig(context);
-      await installDependencies(context);
-      await this.callHook("configResolved", {
-        environment: context,
-        order: "post"
-      });
-      context.trace(`Powerlines configuration has been resolved: 
-
-${formatLogMessage({
-        ...context.config,
-        userConfig: isSetObject(context.config.userConfig) ? omit(context.config.userConfig, [
-          "plugins"
-        ]) : void 0,
-        inlineConfig: isSetObject(context.config.inlineConfig) ? omit(context.config.inlineConfig, [
-          "plugins"
-        ]) : void 0,
-        plugins: context.plugins.map((plugin) => plugin.plugin.name)
-      })}`);
-      if (!context.fs.existsSync(context.cachePath)) {
-        await createDirectory(context.cachePath);
-      }
-      if (!context.fs.existsSync(context.dataPath)) {
-        await createDirectory(context.dataPath);
-      }
-      await this.callHook("prepare", {
-        environment: context,
-        order: "pre"
-      });
-      await this.callHook("prepare", {
-        environment: context,
-        order: "normal"
-      });
-      if (context.config.output.dts !== false) {
-        context.debug(`Preparing the TypeScript definitions for the Powerlines project.`);
-        if (context.fs.existsSync(context.dtsPath)) {
-          await context.fs.remove(context.dtsPath);
-        }
-        const typescriptPath = await resolvePackage("typescript");
-        if (!typescriptPath) {
-          throw new Error("Could not resolve TypeScript package location. Please ensure TypeScript is installed.");
-        }
-        context.debug("Running TypeScript compiler for built-in runtime module files.");
-        let types = await emitBuiltinTypes(context, (await context.getBuiltins()).reduce((ret, builtin) => {
-          const formatted = replacePath(builtin.path, context.workspaceConfig.workspaceRoot);
-          if (!ret.includes(formatted)) {
-            ret.push(formatted);
-          }
-          return ret;
-        }, []));
-        context.debug(`Generating TypeScript declaration file ${context.dtsPath}.`);
-        const directives = [];
-        const asNextParam = /* @__PURE__ */ __name((previousResult) => isObject(previousResult) ? previousResult.code : previousResult, "asNextParam");
-        let result = await this.callHook("types", {
-          environment: context,
-          sequential: true,
-          order: "pre",
-          result: "merge",
-          asNextParam
-        }, types);
-        if (result) {
-          if (isSetObject(result)) {
-            types = result.code;
-            if (Array.isArray(result.directives) && result.directives.length > 0) {
-              directives.push(...result.directives);
-            }
-          } else if (isSetString(result)) {
-            types = result;
-          }
-        }
-        result = await this.callHook("types", {
-          environment: context,
-          sequential: true,
-          order: "normal",
-          result: "merge",
-          asNextParam
-        }, types);
-        if (result) {
-          if (isSetObject(result)) {
-            types = result.code;
-            if (Array.isArray(result.directives) && result.directives.length > 0) {
-              directives.push(...result.directives);
-            }
-          } else if (isSetString(result)) {
-            types = result;
-          }
-        }
-        result = await this.callHook("types", {
-          environment: context,
-          sequential: true,
-          order: "post",
-          result: "merge",
-          asNextParam
-        }, types);
-        if (result) {
-          if (isSetObject(result)) {
-            types = result.code;
-            if (Array.isArray(result.directives) && result.directives.length > 0) {
-              directives.push(...result.directives);
-            }
-          } else if (isSetString(result)) {
-            types = result;
-          }
-        }
-        if (isSetString(types?.trim()) || directives.length > 0) {
-          await context.fs.write(context.dtsPath, `${directives.length > 0 ? `${directives.map((directive) => `/// <reference types="${directive}" />`).join("\n")}
-
-` : ""}${getFileHeader(context, {
-            directive: null,
-            prettierIgnore: false
-          })}
-
-${formatTypes(types)}
-`);
-        } else {
-          const dtsRelativePath = getTsconfigDtsPath(context);
-          if (context.tsconfig.tsconfigJson.include && isIncludeMatchFound(dtsRelativePath, context.tsconfig.tsconfigJson.include)) {
-            const normalizedDtsRelativePath = dtsRelativePath.startsWith("./") ? dtsRelativePath.slice(2) : dtsRelativePath;
-            context.tsconfig.tsconfigJson.include = context.tsconfig.tsconfigJson.include.filter((includeValue) => includeValue?.toString() !== normalizedDtsRelativePath);
-            await context.fs.write(context.tsconfig.tsconfigFilePath, JSON.stringify(context.tsconfig.tsconfigJson, null, 2));
-          }
-        }
-      }
-      context.tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.root, context.config.tsconfig);
-      if (!context.tsconfig) {
-        throw new Error("Failed to parse the TypeScript configuration file.");
-      }
-      this.context.debug("Formatting files generated during the prepare step.");
-      await Promise.all([
-        formatFolder(context, context.builtinsPath),
-        formatFolder(context, context.entryPath)
-      ]);
-      await this.callHook("prepare", {
-        environment: context,
-        order: "post"
-      });
-      await writeMetaFile(context);
-      context.persistedMeta = context.meta;
-    });
-    this.context.debug("\u2714 Powerlines preparation has completed 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.info("\u{1F195} Creating a new Powerlines project");
-    await this.prepare(inlineConfig);
-    await this.#executeEnvironments(async (context) => {
-      context.debug("Initializing the processing options for the Powerlines project.");
-      await this.callHook("new", {
-        environment: context,
-        order: "pre"
-      });
-      const files = await listFiles(joinPaths$1(context.powerlinesPath, "files/common/**/*.hbs"));
-      for (const file of files) {
-        context.trace(`Adding template file to project: ${file}`);
-        const template = Handlebars.compile(file);
-        await context.fs.write(joinPaths$1(context.config.root, file.replace(".hbs", "")), template(context));
-      }
-      await this.callHook("new", {
-        environment: context,
-        order: "normal"
-      });
-      if (context.config.projectType === "application") {
-        const files2 = await listFiles(joinPaths$1(context.powerlinesPath, "files/application/**/*.hbs"));
-        for (const file of files2) {
-          context.trace(`Adding application template file: ${file}`);
-          const template = Handlebars.compile(file);
-          await context.fs.write(joinPaths$1(context.config.root, file.replace(".hbs", "")), template(context));
-        }
-      } else {
-        const files2 = await listFiles(joinPaths$1(context.powerlinesPath, "files/library/**/*.hbs"));
-        for (const file of files2) {
-          context.trace(`Adding library template file: ${file}`);
-          const template = Handlebars.compile(file);
-          await context.fs.write(joinPaths$1(context.config.root, file.replace(".hbs", "")), template(context));
-        }
-      }
-      await this.callHook("new", {
-        environment: context,
-        order: "post"
-      });
-    });
-    this.context.debug("\u2714 Powerlines new command completed successfully");
-  }
-  /**
-  * 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.info("\u{1F9F9} Cleaning the previous Powerlines artifacts");
-    await this.prepare(inlineConfig);
-    await this.#executeEnvironments(async (context) => {
-      context.debug("Cleaning the project's dist and artifacts directories.");
-      await context.fs.remove(joinPaths$1(context.workspaceConfig.workspaceRoot, context.config.output.buildPath));
-      await context.fs.remove(joinPaths$1(context.workspaceConfig.workspaceRoot, context.config.root, context.config.output.artifactsPath));
-      await this.callHook("clean", {
-        environment: context,
-        sequential: false
-      });
-    });
-    this.context.debug("\u2714 Powerlines cleaning completed successfully");
-  }
-  /**
-  * 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.info("\u{1F4CB} Linting the Powerlines project");
-    await this.prepare(inlineConfig);
-    await this.#executeEnvironments(async (context) => {
-      await this.callHook("lint", {
-        environment: context,
-        sequential: false
-      });
-    });
-    this.context.debug("\u2714 Powerlines linting completed successfully");
-  }
-  /**
-  * 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.info("\u{1F4E6}  Building the Powerlines project");
-    await this.context.generateChecksum();
-    if (this.context.meta.checksum !== this.context.persistedMeta?.checksum || this.context.config.skipCache) {
-      this.context.info("The project has been modified since the last time `prepare` was ran. Re-preparing the project.");
-      await this.prepare(inlineConfig);
-    }
-    if (this.context.config.singleBuild) {
-      await this.#handleBuild(await this.#context.toEnvironment());
-    } else {
-      await this.#executeEnvironments(async (context) => {
-        await this.#handleBuild(context);
-      });
-    }
-    this.context.debug("\u2714 Powerlines build completed successfully");
-  }
-  /**
-  * 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.info("\u{1F4D3} Generating documentation for the Powerlines project");
-    await this.prepare(inlineConfig);
-    await this.#executeEnvironments(async (context) => {
-      context.debug("Writing documentation for the Powerlines project artifacts.");
-      await this.prepare(inlineConfig);
-      await this.#executeEnvironments(async (context2) => {
-        await this.callHook("docs", {
-          environment: context2
-        });
-      });
-    });
-    this.context.debug("\u2714 Powerlines documentation generation completed successfully");
-  }
-  /**
-  * Deploy the project source code
-  *
-  * @remarks
-  * This method will prepare and build the Powerlines project, generating the necessary artifacts for the deployment.
-  *
-  * @param inlineConfig - The inline configuration for the deploy command
-  */
-  async deploy(inlineConfig = {
-    command: "deploy"
-  }) {
-    this.context.info("\u{1F680} Deploying the Powerlines project");
-    await this.prepare(inlineConfig);
-    await this.#executeEnvironments(async (context) => {
-      await this.callHook("deploy", {
-        environment: context
-      });
-    });
-    this.context.debug("\u2714 Powerlines deploy completed successfully");
-  }
-  /**
-  * 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.info("\u{1F3C1} Powerlines finalization processes started");
-    await this.#executeEnvironments(async (context) => {
-      await this.callHook("finalize", {
-        environment: context
-      });
-      await context.fs.dispose();
-    });
-    this.context.debug("\u2714 Powerlines finalization completed successfully");
-  }
-  /**
-  * Invokes the configured plugin hooks
-  *
-  * @remarks
-  * By default, it will call the `"pre"`, `"normal"`, and `"post"` ordered hooks in sequence
-  *
-  * @param hook - The hook to call
-  * @param options - The options to provide to the hook
-  * @param args - The arguments to pass to the hook
-  * @returns The result of the hook call
-  */
-  async callHook(hook, options, ...args) {
-    return callHook(isSetObject(options?.environment) ? options.environment : await this.#context.getEnvironment(options?.environment), hook, {
-      sequential: true,
-      ...options
-    }, ...args);
-  }
-  /**
-  * Dispose of the Powerlines API instance
-  *
-  * @remarks
-  * This method will finalize the Powerlines API instance, cleaning up any resources used.
-  */
-  async [Symbol.asyncDispose]() {
-    await this.finalize();
-  }
-  async #handleBuild(context) {
-    await this.callHook("build", {
-      environment: context,
-      order: "pre"
-    });
-    context.debug("Formatting the generated entry files before the build process starts.");
-    await formatFolder(context, context.entryPath);
-    await this.callHook("build", {
-      environment: context,
-      order: "normal"
-    });
-    if (context.config.output.buildPath !== context.config.output.outputPath) {
-      const sourcePath = appendPath(context.config.output.buildPath, context.workspaceConfig.workspaceRoot);
-      const destinationPath = joinPaths$1(appendPath(context.config.output.outputPath, context.workspaceConfig.workspaceRoot), "dist");
-      if (context.fs.existsSync(sourcePath) && sourcePath !== destinationPath) {
-        context.debug(`Copying build output files from project's build directory (${context.config.output.buildPath}) to the workspace's output directory (${context.config.output.outputPath}).`);
-        await context.fs.copy(sourcePath, destinationPath);
-      }
-    }
-    await Promise.all(context.config.output.assets.map(async (asset) => {
-      context.trace(`Copying asset(s): ${chalk4.redBright(context.workspaceConfig.workspaceRoot === asset.input ? asset.glob : joinPaths$1(replacePath(asset.input, context.workspaceConfig.workspaceRoot), asset.glob))} -> ${chalk4.greenBright(joinPaths$1(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 context.fs.copy(asset, asset.output);
-    }));
-    await this.callHook("build", {
-      environment: context,
-      order: "post"
-    });
-  }
-  /**
-  * 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.debug("No environments are configured for this Powerlines project. Using the default environment.");
-      return [
-        await this.context.getEnvironment()
-      ];
-    }
-    this.context.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.callHook("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 result = await this.#initPlugin(config);
-      if (!result) {
-        return;
-      }
-      for (const plugin of result) {
-        this.context.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)) {
-      const invalid = findInvalidPluginConfig(awaited);
-      throw new Error(`Invalid ${invalid && invalid.length > 1 ? "plugins" : "plugin"} specified in the configuration - ${invalid && invalid.length > 0 ? JSON.stringify(awaited) : invalid?.join("\n\n")} 
-
-Please ensure the value is one of the following: 
- - an instance of \`Plugin\` 
- - a plugin name 
- - an object with the \`plugin\` and \`options\` properties 
- - a tuple array with the plugin and options 
- - a factory function that returns a plugin or array of plugins 
- - an array of plugins or plugin configurations`);
-    }
-    let plugins;
-    if (isPlugin(awaited)) {
-      plugins = [
-        awaited
-      ];
-    } else if (isFunction(awaited)) {
-      plugins = toArray(await Promise.resolve(awaited()));
-    } else if (isString(awaited)) {
-      const resolved = await this.#resolvePlugin(awaited);
-      if (isFunction(resolved)) {
-        plugins = toArray(await Promise.resolve(resolved()));
-      } else {
-        plugins = toArray(resolved);
-      }
-    } else if (Array.isArray(awaited) && awaited.every(isPlugin)) {
-      plugins = awaited;
-    } else if (Array.isArray(awaited) && awaited.every(isPluginConfig)) {
-      plugins = [];
-      for (const pluginConfig of awaited) {
-        const initialized = await this.#initPlugin(pluginConfig);
-        if (initialized) {
-          plugins.push(...initialized);
-        }
-      }
-    } 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)) {
-          plugins = toArray(await Promise.resolve(pluginOptions ? resolved(pluginOptions) : resolved()));
-        } else {
-          plugins = toArray(resolved);
-        }
-      } else if (isFunction(pluginConfig)) {
-        plugins = toArray(await Promise.resolve(pluginConfig(pluginOptions)));
-      } else if (Array.isArray(pluginConfig) && pluginConfig.every(isPlugin)) {
-        plugins = pluginConfig;
-      } else if (isPlugin(pluginConfig)) {
-        plugins = toArray(pluginConfig);
-      }
-    }
-    if (!plugins) {
-      throw new Error(`The plugin configuration ${JSON.stringify(awaited)} is invalid. This configuration must point to a valid Powerlines plugin module.`);
-    }
-    if (plugins.length > 0 && !plugins.every(isPlugin)) {
-      throw new Error(`The plugin option ${JSON.stringify(plugins)} does not export a valid module. This configuration must point to a valid Powerlines plugin module.`);
-    }
-    const result = [];
-    for (const plugin of plugins) {
-      if (checkDedupe(plugin, this.context.plugins)) {
-        this.context.trace(`Duplicate ${chalk4.bold.cyanBright(plugin.name)} plugin dependency detected - Skipping initialization.`);
-      } else {
-        result.push(plugin);
-        this.context.trace(`Initializing the ${chalk4.bold.cyanBright(plugin.name)} plugin...`);
-      }
-    }
-    return result;
-  }
-  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.root
-      ]
-    });
-    if (!isInstalled && this.context.config.autoInstall) {
-      this.#context.warn(`The plugin package "${pluginPath}" is not installed. It will be installed automatically.`);
-      const result = await install(pluginPath, {
-        cwd: this.context.config.root
-      });
-      if (isNumber(result.exitCode) && result.exitCode > 0) {
-        this.#context.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$1(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\`.`);
-        }
-      }
-    }
-  }
-};
-
-// ../powerlines/src/index.ts
-var src_default = PowerlinesAPI;
-
-// src/base/base-executor.ts
-function withExecutor(command, executorFn) {
-  return withRunExecutor(`Powerlines ${command} command executor`, async (options, context, workspaceConfig) => {
-    if (!context.projectName) {
-      throw new Error("The executor requires `projectName` on the context object.");
-    }
-    if (!context.projectName || !context.projectsConfigurations?.projects || !context.projectsConfigurations.projects[context.projectName] || !context.projectsConfigurations.projects[context.projectName]?.root) {
-      throw new Error("The executor requires `projectsConfigurations` on the context object.");
-    }
-    const projectConfig = context.projectsConfigurations.projects[context.projectName];
-    const api = await src_default.from(workspaceConfig.workspaceRoot, defu7({
-      input: options.input,
-      output: {
-        outputPath: options.outputPath ?? projectConfig.targets?.build?.options?.outputPath,
-        format: options.format,
-        sourceMap: options.sourceMap
-      },
-      resolve: {
-        external: options.external,
-        noExternal: options.noExternal,
-        skipNodeModulesBundle: options.skipNodeModulesBundle
-      },
-      root: projectConfig.root,
-      projectType: projectConfig.projectType,
-      sourceRoot: projectConfig.sourceRoot,
-      tsconfig: options.tsconfig,
-      platform: options.platform,
-      define: options.define,
-      logLevel: options.logLevel,
-      mode: options.mode
-    }, options));
-    try {
-      return await Promise.resolve(executorFn(defu7({
-        projectName: context.projectName,
-        options,
-        workspaceConfig,
-        inlineConfig: {
-          command,
-          configFile: options.configFile
-        },
-        command
-      }, context), api));
-    } catch (error) {
-      writeError(`An error occurred while executing the Powerlines ${command} command executor: ${isError(error) ? `${error.message}
-
-${error.stack}` : "Unknown error"}`);
-      return {
-        success: false
-      };
-    } finally {
-      await api.finalize();
-    }
-  }, {
-    skipReadingConfig: false,
-    hooks: {
-      applyDefaultOptions: /* @__PURE__ */ __name((options) => {
-        if (options.mode !== "development" && options.mode !== "test") {
-          options.mode = "production";
-        }
-        options.outputPath ??= "dist/{projectRoot}";
-        options.configFile ??= "{projectRoot}/powerlines.config.ts";
-        return options;
-      }, "applyDefaultOptions")
-    }
-  });
-}
-__name(withExecutor, "withExecutor");
-
-export { withExecutor };