@powerlines/nx 0.1.0

package/dist/chunk-OZMYXUES.mjs

@@ -0,0 +1,4276 @@
+import { __VFS_CACHE__, __VFS_RESOLVER__, __VFS_VIRTUAL__, __VFS_UNIFIED__, __VFS_INIT__, __VFS_REVERT__, loadWorkspaceConfig, CACHE_HASH_LENGTH, PROJECT_ROOT_HASH_LENGTH, getPrefixedProjectRootHash, getChecksum, loadUserConfigFile, writeMetaFile } from './chunk-CYWOTYVX.mjs';
+import { __name } from './chunk-O6YSETKJ.mjs';
+import { getLogFn, getLogLevel, 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 defu4, { defu } from 'defu';
+import { formatLogMessage } from '@storm-software/config-tools/logger/console';
+import { LogLevelLabel } from '@storm-software/config-tools/types';
+import { toArray } from '@stryke/convert/to-array';
+import { copyFiles } from '@stryke/fs/copy-file';
+import { existsSync } from '@stryke/fs/exists';
+import { createDirectory, removeDirectory } from '@stryke/fs/helpers';
+import { install } from '@stryke/fs/install';
+import { listFiles, listFilesSync } from '@stryke/fs/list-files';
+import { isPackageExists, isPackageListed, doesPackageMatch, getPackageListing } from '@stryke/fs/package-fns';
+import { findFilePath, findFileExtensionSafe, relativePath, findFileName } from '@stryke/path/file-path-fns';
+import { isParentPath } from '@stryke/path/is-parent-path';
+import { joinPaths } from '@stryke/path/join-paths';
+import { replacePath } from '@stryke/path/replace';
+import { isFunction } from '@stryke/type-checks/is-function';
+import { isNumber } from '@stryke/type-checks/is-number';
+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 chalk5 from 'chalk';
+import Handlebars from 'handlebars';
+import { writeFile as writeFile$1 } from 'node:fs/promises';
+import path, { sep } from 'node:path';
+import { Application, TypeDocReader, PackageJsonReader, TSConfigReader, Converter, ReflectionKind, PageEvent } from 'typedoc';
+import { readJsonFile, readJsonFileSync } from '@stryke/fs/json';
+import { appendPath } from '@stryke/path/append';
+import ts3, { createProgram, createCompilerHost, getPreEmitDiagnostics, getLineAndCharacterOfPosition, flattenDiagnosticMessageText } from 'typescript';
+import { isUndefined } from '@stryke/type-checks/is-undefined';
+import { writeFile } from '@stryke/fs/write-file';
+import { format, resolveConfig } from 'prettier';
+import { resolvePackage } from '@stryke/fs/resolve';
+import { titleCase } from '@stryke/string-format/title-case';
+import { getEnvPaths } from '@stryke/env/get-env-paths';
+import { relativeToWorkspaceRoot, getWorkspaceRoot } from '@stryke/fs/get-workspace-root';
+import { murmurhash } from '@stryke/hash/murmurhash';
+import { getUnique, getUniqueBy } from '@stryke/helpers/get-unique';
+import { omit } from '@stryke/helpers/omit';
+import { joinPaths as joinPaths$1 } from '@stryke/path/join';
+import { isNull } from '@stryke/type-checks/is-null';
+import { isString } from '@stryke/type-checks/is-string';
+import { uuid } from '@stryke/unique-id/uuid';
+import { parseTypeDefinition } from '@stryke/convert/parse-type-definition';
+import { getColor } from '@storm-software/config-tools/utilities/colors';
+import { noop } from '@stryke/helpers/noop';
+import { createJiti } from 'jiti';
+import { bufferToString } from '@stryke/convert/buffer-to-string';
+import { isAbsolutePath } from '@stryke/path/is-type';
+import { prettyBytes } from '@stryke/string-format/pretty-bytes';
+import { isBuffer } from '@stryke/type-checks/is-buffer';
+import { Volume } from 'memfs';
+import { Blob } from 'node:buffer';
+import fs from 'node:fs';
+import { Union } from 'unionfs';
+import { isObject } from '@stryke/type-checks/is-object';
+import { isDirectory } from '@stryke/fs/is-file';
+import { readFile, readFileIfExistingSync } from '@stryke/fs/read-file';
+import { isValidRange, parseVersion } from '@stryke/fs/semver-fns';
+import { getParentPath } from '@stryke/path/get-parent-path';
+import { hasPackageVersion, getPackageName, getPackageVersion } from '@stryke/string-format/package';
+import { transformAsync } from '@babel/core';
+import MagicString from 'magic-string';
+import { declare } from '@babel/helper-plugin-utils';
+import * as t from '@babel/types';
+import { getObjectDiff } from '@donedeal0/superdiff';
+import { loadTsConfig } from '@stryke/fs/tsconfig';
+import { StormJSON } from '@stryke/json/storm-json';
+import { minimatch } from 'minimatch';
+import { isDevelopmentMode, isTestMode } from '@stryke/env/environment-checks';
+import { createVitePlugin, createEsbuildPlugin, createWebpackPlugin, createRolldownPlugin, createRollupPlugin, createRspackPlugin, createUnloaderPlugin } from 'unplugin';
+import { match, tsconfigPathsToRegExp } from 'bundle-require';
+import { defineNuxtModule, addVitePlugin, addWebpackPlugin } from '@nuxt/kit';
+import '@nuxt/schema';
+
+var objectToFrontmatter = /* @__PURE__ */ __name((object = {}) => Object.entries(object).filter(([, value]) => {
+  return value !== void 0 && value !== null && value !== "" && typeof value === "string" || Array.isArray(value) && value.length > 0;
+}).map(([key, value]) => `${key}: ${value}`).join("\n"), "objectToFrontmatter");
+var onRendererPageEnd = /* @__PURE__ */ __name((frontmatterObject) => (event) => {
+  if (!event.contents) {
+    return;
+  } else if (/README\.md$/.test(event.url)) {
+    event.preventDefault();
+    return;
+  }
+  const frontmatter = `---
+title: '${event.model.name}'
+${objectToFrontmatter(frontmatterObject)}
+---
+
+`;
+  event.contents = frontmatter + event.contents;
+}, "onRendererPageEnd");
+var buildNavigationFromProjectReflection = /* @__PURE__ */ __name((baseUrl = "", project) => {
+  const baseUrlWithoutTrailingSlash = baseUrl.replace(/\/$/gm, "");
+  const result = {
+    type: "flat"
+  };
+  const isGroupOfModules = /* @__PURE__ */ __name((group) => group.title === "Modules", "isGroupOfModules");
+  const reflectionToNavItem = /* @__PURE__ */ __name((reflection) => {
+    return {
+      title: reflection.name,
+      url: `${baseUrlWithoutTrailingSlash}/${reflection.url}`.replace(/\.md$/, "")
+    };
+  }, "reflectionToNavItem");
+  const modulesGroupToNavigationGroup = /* @__PURE__ */ __name((module) => ({
+    items: (module.groups ?? []).flatMap((group) => group.children.map(reflectionToNavItem)),
+    name: module.name
+  }), "modulesGroupToNavigationGroup");
+  const navFromReflectionGroups = /* @__PURE__ */ __name((groups, nav = {
+    type: "flat"
+  }) => {
+    groups.forEach((group) => {
+      if (isGroupOfModules(group)) {
+        nav.type = "modular";
+        nav.modules = group.children.map(modulesGroupToNavigationGroup);
+      } else {
+        nav.items = nav?.items?.length ? nav.items : [];
+        nav.items = nav.items.concat(group.children.flatMap(reflectionToNavItem));
+      }
+    });
+    return nav;
+  }, "navFromReflectionGroups");
+  return navFromReflectionGroups(project.groups, result);
+}, "buildNavigationFromProjectReflection");
+var onDeclaration = /* @__PURE__ */ __name((entryPoints = []) => (context, reflection) => {
+  if (reflection.kind === ReflectionKind.Module) {
+    const matchingEntryPoint = entryPoints.find((entryPoint) => entryPoint.path === reflection.sources[0].fullFileName);
+    reflection.name = matchingEntryPoint?.name ?? reflection.name;
+  }
+}, "onDeclaration");
+var typedocConfig = {
+  excludeExternals: true,
+  excludeInternal: true,
+  excludePrivate: true,
+  excludeProtected: true,
+  githubPages: false
+};
+var markdownPluginConfig = {
+  hideBreadcrumbs: true,
+  hideInPageTOC: true,
+  hidePageHeader: true,
+  hidePageTitle: true
+};
+var removeTrailingSlash = /* @__PURE__ */ __name((pathString = "") => pathString.endsWith(sep) ? pathString.slice(0, pathString.length - 1) : pathString, "removeTrailingSlash");
+var initTypedoc = /* @__PURE__ */ __name(async (context, options) => {
+  const { baseUrl = "/docs/", outputPath } = options;
+  const entryPoints = options.entryPoints ?? context.entry.map((entry) => ({
+    name: entry.name || entry.output || findFileName(entry.file, {
+      withExtension: false
+    }),
+    path: joinPaths(context.config.projectRoot, entry.file)
+  }));
+  const app = await Application.bootstrapWithPlugins({
+    ...typedocConfig,
+    ...markdownPluginConfig,
+    gitRevision: context.workspaceConfig.branch || "main",
+    tsconfig: context.tsconfig.tsconfigFilePath,
+    exclude: context.tsconfig.tsconfigJson.exclude?.filter(Boolean),
+    out: outputPath,
+    basePath: baseUrl,
+    entryPoints: entryPoints?.map((e) => e.path),
+    plugin: [
+      "typedoc-plugin-markdown",
+      "powerlines/lib/typedoc/plugin"
+    ],
+    theme: "powerlines",
+    readme: "none",
+    excludePrivate: true,
+    hideGenerator: true
+  }, [
+    new TypeDocReader(),
+    new PackageJsonReader(),
+    new TSConfigReader()
+  ]);
+  app.options.addReader(new TSConfigReader());
+  app.converter.on(Converter.EVENT_CREATE_DECLARATION, onDeclaration(entryPoints));
+  const getReflections = /* @__PURE__ */ __name(async () => app.convert(), "getReflections");
+  const generateDocs = /* @__PURE__ */ __name(async (opts) => {
+    const { outputPath: outputFolder, project, frontmatter } = opts;
+    app.renderer.on(PageEvent.END, onRendererPageEnd(frontmatter));
+    await app.generateDocs(project, outputFolder || outputPath);
+  }, "generateDocs");
+  const generateNavigationJSON = /* @__PURE__ */ __name(async (project, outputFolder = outputPath) => {
+    const navigation = buildNavigationFromProjectReflection(baseUrl, project);
+    await writeFile$1(`${removeTrailingSlash(outputFolder)}/nav.json`, JSON.stringify(navigation));
+  }, "generateNavigationJSON");
+  return {
+    app,
+    generateDocs,
+    generateNavigationJSON,
+    getReflections
+  };
+}, "initTypedoc");
+function getTsconfigFilePath(workspaceRoot, projectRoot, tsconfig = "tsconfig.json") {
+  let tsconfigFilePath = tsconfig;
+  if (!existsSync(tsconfigFilePath)) {
+    tsconfigFilePath = appendPath(tsconfig, projectRoot);
+    if (!existsSync(tsconfigFilePath)) {
+      tsconfigFilePath = appendPath(tsconfig, workspaceRoot);
+      if (!existsSync(tsconfigFilePath)) {
+        tsconfigFilePath = appendPath(tsconfig, joinPaths(workspaceRoot, projectRoot));
+        if (!existsSync(tsconfigFilePath)) {
+          throw new Error(`Cannot find the \`tsconfig.json\` configuration file at ${tsconfig}, ${appendPath(tsconfig, projectRoot)}, ${appendPath(tsconfig, workspaceRoot)}, or ${tsconfigFilePath}`);
+        }
+      }
+    }
+  }
+  return tsconfigFilePath;
+}
+__name(getTsconfigFilePath, "getTsconfigFilePath");
+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 = ts3.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(projectRoot, tsconfig ?? "tsconfig.json")}`);
+  }
+  const parsedCommandLine = ts3.parseJsonConfigFileContent(defu4(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/lib/utilities/file-header.ts
+function getBaseFileHeader() {
+  return `
+// Generated with Powerlines
+// Note: Do not edit this file manually - it will be overwritten automatically
+`;
+}
+__name(getBaseFileHeader, "getBaseFileHeader");
+function getFileHeader(directive = "", prettierIgnore = false) {
+  if (directive && process.env.POWERLINES_LOCAL) {
+    directive = directive.replaceAll("powerlines/runtime-types", "../../dist/packages/types");
+  }
+  return `/* eslint-disable */
+// biome-ignore lint: disable
+${prettierIgnore ? `// prettier-ignore` : ""}${directive ? `
+
+${directive}
+` : "\n"}
+${getBaseFileHeader()}
+
+`;
+}
+__name(getFileHeader, "getFileHeader");
+
+// ../powerlines/src/types/commands.ts
+var SUPPORTED_COMMANDS = [
+  "new",
+  "clean",
+  "prepare",
+  "lint",
+  "test",
+  "build",
+  "docs",
+  "release",
+  "finalize"
+];
+
+// ../powerlines/src/lib/utilities/plugin-helpers.ts
+function isPlugin(value) {
+  return isSetObject(value) && "name" in value && isSetString(value.name) && (isUndefined(value.applyToEnvironment) || "applyToEnvironment" in value && isFunction(value.applyToEnvironment)) && (isUndefined(value.dedupe) || "dedupe" in value && isFunction(value.dedupe)) && (isUndefined(value.dependsOn) || "dependsOn" in value && Array.isArray(value.dependsOn) && value.dependsOn.every(isPluginConfig)) && SUPPORTED_COMMANDS.every((command) => isUndefined(value[command]) || command in value && (isFunction(value[command]) || isSetObject(value[command]) && "handler" in value[command] && isFunction(value[command].handler)));
+}
+__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);
+}
+__name(isPluginConfig, "isPluginConfig");
+function isPluginHookFunction(value) {
+  return isFunction(value) || isSetObject(value) && "handler" in value && isFunction(value.handler);
+}
+__name(isPluginHookFunction, "isPluginHookFunction");
+function isPluginHookObject(value) {
+  return isSetObject(value) && "handler" in value && isFunction(value.handler);
+}
+__name(isPluginHookObject, "isPluginHookObject");
+function isPluginHook(value) {
+  return isPluginHookFunction(value) || isPluginHookObject(value);
+}
+__name(isPluginHook, "isPluginHook");
+function getHookHandler(pluginHook) {
+  return isFunction(pluginHook) ? pluginHook : pluginHook.handler;
+}
+__name(getHookHandler, "getHookHandler");
+function isHookExternal(hook) {
+  return hook.startsWith("vite:") || hook.startsWith("esbuild:") || hook.startsWith("rolldown:") || hook.startsWith("rollup:") || hook.startsWith("webpack:") || hook.startsWith("rspack:") || hook.startsWith("farm:");
+}
+__name(isHookExternal, "isHookExternal");
+function checkDedupe(plugin, plugins2) {
+  return plugins2.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))) {
+    hooksList.push(isFunction(pluginHook) ? {
+      plugin,
+      handler: getHookHandler(pluginHook).bind(context)
+    } : {
+      plugin,
+      ...pluginHook,
+      handler: getHookHandler(pluginHook).bind(context)
+    });
+  }
+}
+__name(addPluginHook, "addPluginHook");
+async function writeFile2(log, filepath, content, skipFormat = false) {
+  try {
+    if (skipFormat) {
+      await writeFile(filepath, content);
+    } else {
+      const config = await resolveConfig(filepath);
+      const formatted = await format(content, {
+        ...config ?? {},
+        filepath
+      });
+      await writeFile(filepath, formatted || "");
+    }
+  } catch (error) {
+    log(LogLevelLabel.ERROR, `Failed to write file ${filepath} to disk 
+${error?.message ? error.message : ""}`);
+  }
+}
+__name(writeFile2, "writeFile");
+var DEFAULT_ENVIRONMENT = "default";
+function createEnvironment(name, userConfig) {
+  return defu4(userConfig.environments?.[name] ?? {}, {
+    name,
+    title: userConfig.title || titleCase(userConfig.name),
+    ssr: false,
+    mainFields: userConfig.build?.platform === "browser" ? [
+      "browser",
+      "module",
+      "jsnext:main",
+      "jsnext"
+    ] : [
+      "module",
+      "jsnext:main",
+      "jsnext"
+    ],
+    extensions: [
+      ".mjs",
+      ".js",
+      ".mts",
+      ".ts",
+      ".jsx",
+      ".tsx",
+      ".json"
+    ],
+    consumer: userConfig.build?.platform === "browser" ? "client" : "server",
+    preview: userConfig.build?.platform === "browser" ? {
+      port: 5173,
+      open: true,
+      strictPort: false,
+      // https: false,
+      host: "localhost",
+      allowedHosts: [
+        "."
+      ],
+      cors: true,
+      headers: {}
+    } : void 0
+  }, userConfig);
+}
+__name(createEnvironment, "createEnvironment");
+function createDefaultEnvironment(userConfig) {
+  return createEnvironment(DEFAULT_ENVIRONMENT, userConfig);
+}
+__name(createDefaultEnvironment, "createDefaultEnvironment");
+function resolveEntryInputFile(context, typeDefinition) {
+  return replacePath(typeDefinition.file, joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot));
+}
+__name(resolveEntryInputFile, "resolveEntryInputFile");
+function resolveEntryInput(context, typeDefinition) {
+  return {
+    file: resolveEntryInputFile(context, typeDefinition),
+    name: typeDefinition.name
+  };
+}
+__name(resolveEntryInput, "resolveEntryInput");
+function resolveEntryOutput(context, typeDefinition) {
+  return joinPaths(replacePath(replacePath(replacePath(replacePath(typeDefinition.file, joinPaths(context.workspaceConfig.workspaceRoot, context.config.sourceRoot)), joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot)), context.config.sourceRoot), context.config.projectRoot)).replace(`.${findFileExtensionSafe(typeDefinition.file)}`, "");
+}
+__name(resolveEntryOutput, "resolveEntryOutput");
+function resolveEntry(context, typeDefinition) {
+  const input = resolveEntryInput(context, typeDefinition);
+  return {
+    ...input,
+    input,
+    output: resolveEntryOutput(context, typeDefinition)
+  };
+}
+__name(resolveEntry, "resolveEntry");
+function resolveEntriesSync(context, typeDefinitions) {
+  return typeDefinitions.map((typeDefinition) => {
+    const parsed = parseTypeDefinition(typeDefinition);
+    return listFilesSync(appendPath(parsed.file, context.config.projectRoot)).map((file) => resolveEntry(context, {
+      file,
+      name: parsed.name
+    }));
+  }).flat().filter(Boolean);
+}
+__name(resolveEntriesSync, "resolveEntriesSync");
+function getUniqueEntries(entries = []) {
+  return getUniqueBy(toArray(entries), (item) => isSetString(item) ? item : murmurhash(item ?? {}, {
+    maxLength: 24
+  }));
+}
+__name(getUniqueEntries, "getUniqueEntries");
+var createLog = /* @__PURE__ */ __name((name, options = {}) => {
+  const logLevel = options.logLevel === null ? LogLevelLabel.SILENT : options.logLevel || LogLevelLabel.INFO;
+  if (logLevel === LogLevelLabel.SILENT) {
+    return noop;
+  }
+  if (options.customLogger) {
+    return options.customLogger;
+  }
+  return (type, ...args) => getLogFn(getLogLevel(type), {
+    ...options,
+    logLevel
+  })(`${chalk5.bold.hex(getColor("brand", options))(`powerlines${name ? `:${name}` : ""}${options.name ? ` ${chalk5.gray("> ")}${options.name}` : ""} ${chalk5.gray("> ")}`)}${args.join(" ")} `.trim());
+}, "createLog");
+var BADGE_COLORS = [
+  "#00A0DD",
+  "#6FCE4E",
+  "#FBBF24",
+  "#F43F5E",
+  "#3B82F6",
+  "#A855F7",
+  "#469592",
+  "#288EDF",
+  "#10B981",
+  "#EF4444",
+  "#F0EC56",
+  "#F472B6",
+  "#22D3EE",
+  "#EAB308",
+  "#84CC16",
+  "#F87171",
+  "#0EA5E9",
+  "#D946EF",
+  "#FACC15",
+  "#34D399"
+];
+var extendLog = /* @__PURE__ */ __name((logFn, name) => {
+  return (type, ...args) => logFn(type, ` ${chalk5.inverse.hex(BADGE_COLORS[name.split("").map((char) => char.charCodeAt(0)).reduce((ret, charCode) => ret + charCode, 0) % BADGE_COLORS.length] || BADGE_COLORS[0])(` ${titleCase(name)} `)}  ${args.join(" ")} `);
+}, "extendLog");
+function resolveOptions(options) {
+  return defu4(options, {
+    interopDefault: true,
+    fsCache: options.mode !== "development" ? joinPaths(options.cacheDir, "jiti") : false,
+    moduleCache: options.mode !== "development"
+  });
+}
+__name(resolveOptions, "resolveOptions");
+function createPluginResolver(options) {
+  return createJiti(joinPaths(options.workspaceRoot, options.projectRoot), resolveOptions({
+    ...options
+  }));
+}
+__name(createPluginResolver, "createPluginResolver");
+function createResolver(options) {
+  const baseResolver = createJiti(joinPaths(options.workspaceRoot, options.projectRoot), resolveOptions(options));
+  baseResolver.plugin = createPluginResolver(options);
+  return baseResolver;
+}
+__name(createResolver, "createResolver");
+var VirtualFileSystem = class {
+  static {
+    __name(this, "VirtualFileSystem");
+  }
+  /**
+  * The internal map of virtual files.
+  */
+  #builtinIdMap = /* @__PURE__ */ new Map();
+  /**
+  * A map of virtual file paths to their underlying file content.
+  */
+  #cachedFS = /* @__PURE__ */ new Map();
+  /**
+  * A map of virtual file paths to their underlying file content.
+  */
+  #cachedResolver = /* @__PURE__ */ new Map();
+  /**
+  * The internal map of virtual files.
+  */
+  #virtualFS = new Volume();
+  /**
+  * The physical file system.
+  */
+  #fs = cloneFS(fs);
+  /**
+  * The unified volume that combines the virtual file system with the real file system.
+  *
+  * @remarks
+  * This volume allows for seamless access to both virtual and real files.
+  */
+  #unifiedFS = new Union();
+  /**
+  * Indicator specifying if the file system module is patched
+  */
+  #isPatched = false;
+  /**
+  * Function to revert require patch
+  */
+  #revert;
+  /**
+  * The context of the virtual file system.
+  */
+  #context;
+  /**
+  * The file system's logging function.
+  */
+  #log;
+  /**
+  * Exposes the internal VFS map for advanced usage.
+  */
+  get [__VFS_CACHE__]() {
+    return this.#cachedFS;
+  }
+  /**
+  * Exposes the internal VFS resolver cache for advanced usage.
+  */
+  get [__VFS_RESOLVER__]() {
+    return this.#cachedResolver;
+  }
+  /**
+  * Exposes the internal VFS map for advanced usage.
+  */
+  get [__VFS_VIRTUAL__]() {
+    return this.#virtualFS;
+  }
+  /**
+  * Exposes the internal UFS map for advanced usage.
+  */
+  get [__VFS_UNIFIED__]() {
+    return this.#unifiedFS;
+  }
+  /**
+  * Creates a new instance of the VirtualFileSystem.
+  *
+  * @param context - The context of the virtual file system, typically containing options and logging functions.
+  * @param serialized - A map of files/file contents to populate in cache
+  */
+  constructor(context, serialized) {
+    this.#context = context;
+    this.#cachedFS = /* @__PURE__ */ new Map();
+    this.#builtinIdMap = new Map(Object.entries(serialized?.builtinIdMap ?? {}));
+    if (!this.#fs.existsSync(this.#context.dataPath)) {
+      this.#fs.mkdirSync(this.#context.dataPath, {
+        recursive: true
+      });
+    }
+    if (!this.#fs.existsSync(this.#context.cachePath)) {
+      this.#fs.mkdirSync(this.#context.cachePath, {
+        recursive: true
+      });
+    }
+    if (!this.#fs.existsSync(joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.output.outputPath))) {
+      this.#fs.mkdirSync(joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.output.outputPath), {
+        recursive: true
+      });
+    }
+    this.#unifiedFS = this.#unifiedFS.use(this.#fs);
+    if (this.#context.config.output.mode !== "fs") {
+      if (serialized?.virtualFiles && Object.keys(serialized.virtualFiles).length > 0) {
+        this.#virtualFS = Volume.fromJSON(serialized.virtualFiles);
+      }
+      if (!this.#virtualFS.existsSync(this.#context.artifactsPath)) {
+        this.#virtualFS.mkdirSync(this.#context.artifactsPath, {
+          recursive: true
+        });
+      }
+      if (!this.#virtualFS.existsSync(this.#context.builtinsPath)) {
+        this.#virtualFS.mkdirSync(this.#context.builtinsPath, {
+          recursive: true
+        });
+      }
+      if (!this.#virtualFS.existsSync(this.#context.entryPath)) {
+        this.#virtualFS.mkdirSync(this.#context.entryPath, {
+          recursive: true
+        });
+      }
+      if (!this.#virtualFS.existsSync(this.#context.dtsPath)) {
+        this.#virtualFS.mkdirSync(this.#context.dtsPath, {
+          recursive: true
+        });
+      }
+      this.#unifiedFS = this.#unifiedFS.use(this.#virtualFS);
+    } else if (this.#context.config.projectType === "application") {
+      if (!this.#fs.existsSync(this.#context.artifactsPath)) {
+        this.#fs.mkdirSync(this.#context.artifactsPath, {
+          recursive: true
+        });
+      }
+      if (!this.#fs.existsSync(this.#context.builtinsPath)) {
+        this.#fs.mkdirSync(this.#context.builtinsPath, {
+          recursive: true
+        });
+      }
+      if (!this.#fs.existsSync(this.#context.entryPath)) {
+        this.#fs.mkdirSync(this.#context.entryPath, {
+          recursive: true
+        });
+      }
+      if (!this.#fs.existsSync(this.#context.dtsPath)) {
+        this.#fs.mkdirSync(this.#context.dtsPath, {
+          recursive: true
+        });
+      }
+    }
+    this.#log = extendLog(this.#context.log, "virtual-file-system");
+  }
+  [__VFS_INIT__]() {
+    if (!this.#isPatched && this.#context.config.output.mode !== "fs") {
+      this.#revert = patchFS(fs, this);
+      this.#isPatched = true;
+    }
+  }
+  [__VFS_REVERT__]() {
+    if (this.#isPatched && this.#context.config.output.mode !== "fs") {
+      if (!this.#revert) {
+        throw new Error("Attempting to revert File System patch prior to calling `__init__` function");
+      }
+      this.#revert?.();
+      this.#isPatched = false;
+    }
+  }
+  /**
+  * Returns a Map of all runtime file IDs and their corresponding paths in the virtual file system.
+  *
+  * @returns A Map where the keys are runtime file IDs (strings) and the values are their corresponding paths (strings).
+  */
+  get builtinIdMap() {
+    return this.#builtinIdMap;
+  }
+  /**
+  * Lists all runtime IDs in the virtual file system.
+  *
+  * @returns An array of formatted runtime IDs.
+  */
+  get runtimeIds() {
+    return Array.from(this.builtinIdMap.keys()).map((id) => this.formatRuntimeId(id));
+  }
+  /**
+  * Checks if a given path or ID corresponds to a runtime file.
+  *
+  * @param pathOrId - The path or ID to check.
+  * @param options - Options for resolving the path, such as paths to check.
+  * @returns `true` if the path or ID corresponds to a runtime file, otherwise `false`.
+  */
+  isBuiltinFile(pathOrId, options) {
+    return !!this.builtinIdMap.values().find((path2) => path2 === this.resolvePath(pathOrId, {
+      ...options,
+      type: "file"
+    }));
+  }
+  /**
+  * Checks if a provided string is a valid runtime ID (does not need to already be created in the file system).
+  *
+  * @param id - The ID to check.
+  * @returns Whether the ID is a valid runtime ID.
+  */
+  isValidBuiltinId(id) {
+    return id.startsWith(`${this.#context.config.builtinPrefix}:`);
+  }
+  /**
+  * Check if a path or ID corresponds to a virtual file.
+  *
+  * @param pathOrId - The path or ID to check.
+  * @param options - Options for resolving the path, such as paths to check.
+  * @returns Whether the path or ID corresponds to a virtual file.
+  */
+  isVirtualFile(pathOrId, options = {}) {
+    if (!pathOrId) {
+      return false;
+    }
+    const resolvedPath = this.resolvePath(pathOrId, {
+      ...options,
+      type: "file"
+    });
+    if (!resolvedPath) {
+      return false;
+    }
+    if (this.builtinIdMap.values().find((path2) => path2 === resolvedPath)) {
+      return true;
+    }
+    return this.#virtualFS.existsSync(resolvedPath);
+  }
+  /**
+  * Check if a path exists within one of the directories specified in the tsconfig.json's `path` field.
+  *
+  * @see https://www.typescriptlang.org/tsconfig#paths
+  *
+  * @param pathOrId - The path or ID to check.
+  * @returns Whether the path or ID corresponds to a virtual file.
+  */
+  isTsconfigPath(pathOrId) {
+    return !!this.#context.tsconfig.options.paths && Object.keys(this.#context.tsconfig.options.paths).some((path2) => pathOrId.startsWith(path2.replaceAll("*", "")));
+  }
+  /**
+  * Checks if a given ID corresponds to a runtime file path.
+  *
+  * @param id - The unique identifier for the runtime file.
+  * @param pathOrId - The path or ID to check.
+  * @returns `true` if the ID corresponds to the path or ID of a runtime file, otherwise `false`.
+  */
+  isMatchingBuiltinId(id, pathOrId) {
+    const resolvedPath = this.resolvePath(pathOrId);
+    const resolvedId = this.resolveId(pathOrId);
+    return !!(this.isBuiltinFile(pathOrId) && (resolvedPath && (resolvedPath === this.builtinIdMap.get(id) || resolvedPath === this.builtinIdMap.get(this.formatRuntimeId(id))) || resolvedId && (resolvedId === this.builtinIdMap.get(id) || resolvedId === this.builtinIdMap.get(this.formatRuntimeId(id)))));
+  }
+  /**
+  * Lists all runtime files in the virtual file system.
+  *
+  * @returns A promise that resolves to an array of runtime files.
+  */
+  async listBuiltinFiles() {
+    const runtimeFiles = [];
+    for (const [id, path2] of this.builtinIdMap.entries()) {
+      const contents = await this.readFile(path2);
+      if (contents) {
+        runtimeFiles.push({
+          id: this.formatRuntimeId(id),
+          path: path2,
+          contents
+        });
+      }
+    }
+    return runtimeFiles;
+  }
+  /**
+  * Lists files in a given path.
+  *
+  * @param path - The path to list files from.
+  * @param options - Options for listing files, such as encoding and recursion.
+  * @returns An array of file names in the specified path.
+  */
+  readdirSync(path2, options = "utf8") {
+    return this.resolveFS(path2).readdirSync(toFilePath(path2), options);
+  }
+  /**
+  * Removes a file in the virtual file system (VFS).
+  *
+  * @param path - The path to create the directory at.
+  */
+  unlinkSync(path2, options) {
+    const formattedPath = toFilePath(path2);
+    if (!this.fileExistsSync(path2)) {
+      return;
+    }
+    this.#log(LogLevelLabel.TRACE, `Synchronously removing file: ${formattedPath}`);
+    this.resolveFS(path2, options).unlinkSync(formattedPath);
+    this.#cachedFS.delete(formattedPath);
+    this.clearResolverCache(formattedPath);
+  }
+  /**
+  * Removes a file in the virtual file system (VFS).
+  *
+  * @param path - The path to create the directory at.
+  */
+  async unlink(path2, options) {
+    const formattedPath = toFilePath(path2);
+    if (!this.fileExistsSync(path2)) {
+      return;
+    }
+    this.#log(LogLevelLabel.TRACE, `Removing file: ${formattedPath}`);
+    if (isFunction(this.resolveFS(path2, options).promises.unlink)) {
+      await this.resolveFS(path2, options).promises.unlink(formattedPath);
+      this.#cachedFS.delete(formattedPath);
+      this.clearResolverCache(formattedPath);
+    } else {
+      this.unlinkSync(formattedPath, options);
+    }
+  }
+  /**
+  * Removes a directory in the virtual file system (VFS).
+  *
+  * @param path - The path to create the directory at.
+  * @param options - Options for creating the directory.
+  */
+  rmdirSync(path2, options = {}) {
+    const formattedPath = toFilePath(path2);
+    if (!this.directoryExistsSync(path2)) {
+      return;
+    }
+    this.#log(LogLevelLabel.TRACE, `Synchronously removing directory: ${formattedPath}`);
+    this.resolveFS(path2, options).rmdirSync(formattedPath, defu4(options, {
+      recursive: true
+    }));
+    this.#cachedFS.delete(formattedPath);
+    this.clearResolverCache(formattedPath);
+  }
+  /**
+  * Removes a directory in the virtual file system (VFS).
+  *
+  * @param path - The path to create the directory at.
+  * @param options - Options for creating the directory.
+  * @returns A promise that resolves to the path of the created directory, or undefined if the directory could not be created.
+  */
+  async rmdir(path2, options = {}) {
+    const formattedPath = toFilePath(path2);
+    if (!this.directoryExistsSync(path2)) {
+      return;
+    }
+    this.#log(LogLevelLabel.TRACE, `Removing directory: ${formattedPath}`);
+    if (isFunction(this.resolveFS(path2, options).promises.rm)) {
+      await this.resolveFS(path2, options).promises.rm(formattedPath, defu4(options, {
+        force: true,
+        recursive: true
+      }));
+      this.#cachedFS.delete(formattedPath);
+      this.clearResolverCache(formattedPath);
+    } else {
+      this.rmdirSync(formattedPath, defu4(options ?? {}, {
+        force: true,
+        recursive: true
+      }));
+    }
+  }
+  /**
+  * Removes a file in the virtual file system (VFS).
+  *
+  * @param path - The path to the file to remove.
+  * @param options - Options for removing the file.
+  * @returns A promise that resolves when the file is removed.
+  */
+  async rm(path2, options = {}) {
+    this.#log(LogLevelLabel.TRACE, `Removing: ${toFilePath(path2)}`);
+    if (this.directoryExistsSync(path2)) {
+      return this.rmdir(path2, options);
+    }
+    return this.unlink(path2, options);
+  }
+  /**
+  * Creates a directory in the virtual file system (VFS).
+  *
+  * @param path - The path to create the directory at.
+  * @param options - Options for creating the directory.
+  * @returns A promise that resolves to the path of the created directory, or undefined if the directory could not be created.
+  */
+  mkdirSync(path2, options = {}) {
+    const filePath = toFilePath(path2);
+    this.clearResolverCache(filePath);
+    return this.resolveFS(filePath, options).mkdirSync(filePath, defu4(options ?? {}, {
+      recursive: true
+    }));
+  }
+  /**
+  * Creates a directory in the virtual file system (VFS).
+  *
+  * @param path - The path to create the directory at.
+  * @param options - Options for creating the directory.
+  * @returns A promise that resolves to the path of the created directory, or undefined if the directory could not be created.
+  */
+  async mkdir(path2, options = {}) {
+    let result;
+    const filePath = toFilePath(path2);
+    if (isFunction(this.resolveFS(filePath, options).promises.mkdir)) {
+      result = await this.resolveFS(filePath, options).promises.mkdir(filePath, defu4(options ?? {}, {
+        recursive: true
+      }));
+    } else {
+      result = this.resolveFS(filePath, options).mkdirSync(filePath, defu4(options ?? {}, {
+        recursive: true
+      }));
+    }
+    this.clearResolverCache(filePath);
+    return result;
+  }
+  /**
+  * Lists files in a given path.
+  *
+  * @param path - The path to list files from.
+  * @param options - Options for listing files, such as encoding and recursion.
+  * @returns An array of file names in the specified path.
+  */
+  async readdir(path2, options = "utf8") {
+    return this.resolveFS(path2).promises.readdir(toFilePath(path2), options);
+  }
+  /**
+  * Asynchronously reads a file from the virtual file system (VFS).
+  *
+  * @param pathOrId - The path or ID of the file to read.
+  * @returns A promise that resolves to the contents of the file as a string, or undefined if the file does not exist.
+  */
+  async readFile(pathOrId, options = "utf8") {
+    if (!pathOrId) {
+      return void 0;
+    }
+    const filePath = this.resolvePath(toFilePath(pathOrId), {
+      type: "file"
+    });
+    if (filePath) {
+      if (this.#cachedFS.has(filePath)) {
+        return this.#cachedFS.get(filePath);
+      }
+      let result;
+      if (isFunction(this.resolveFS(filePath).promises.readFile)) {
+        result = (await this.resolveFS(filePath).promises.readFile(filePath, options))?.toString("utf8");
+      } else {
+        result = this.resolveFS(filePath).readFileSync(filePath, options);
+      }
+      const content = isBuffer(result) ? bufferToString(result) : result;
+      this.#cachedFS.set(filePath, content);
+      return content;
+    }
+    return void 0;
+  }
+  /**
+  * Synchronously reads a file from the virtual file system (VFS).
+  *
+  * @param pathOrId - The path or ID of the file to read.
+  * @returns The contents of the file as a string, or undefined if the file does not exist.
+  */
+  readFileSync(pathOrId, options = "utf8") {
+    if (!pathOrId) {
+      return void 0;
+    }
+    const filePath = this.resolvePath(toFilePath(pathOrId), {
+      type: "file"
+    });
+    if (filePath) {
+      if (this.#cachedFS.has(filePath)) {
+        return this.#cachedFS.get(filePath);
+      }
+      const result = this.resolveFS(filePath).readFileSync(filePath, options);
+      const content = isBuffer(result) ? bufferToString(result) : result;
+      this.#cachedFS.set(filePath, content);
+      return content;
+    }
+    return void 0;
+  }
+  /**
+  * Writes a file to the virtual file system (VFS).
+  *
+  * @param file - The path to the file.
+  * @param data - The contents of the file.
+  * @param options - Optional parameters for writing the file.
+  * @returns A promise that resolves when the file is written.
+  */
+  async writeFile(file, data = "", options = "utf8") {
+    const absolutePath = this.formatAbsoluteFilePath(toFilePath(file));
+    if (!this.directoryExistsSync(findFilePath(absolutePath))) {
+      await this.mkdir(findFilePath(absolutePath), options);
+    }
+    this.#log(LogLevelLabel.TRACE, `Writing ${absolutePath} file to the ${this.resolveOutputMode(absolutePath, options) === "fs" ? "" : "virtual "}file system (size: ${prettyBytes(new Blob(toArray(data)).size)})`);
+    this.#cachedFS.set(absolutePath, data.toString());
+    this.clearResolverCache(absolutePath);
+    const ifs = this.resolveFS(absolutePath, options);
+    if (isFunction(ifs.promises.writeFile)) {
+      return ifs.promises.writeFile(absolutePath, data, omit(options, [
+        "mode"
+      ]));
+    }
+    return ifs.writeFileSync(absolutePath, data, omit(options, [
+      "mode"
+    ]));
+  }
+  /**
+  * Synchronously writes a file to the virtual file system (VFS).
+  *
+  * @param file - The file to write.
+  * @param data - The contents of the file.
+  * @param options - Optional parameters for writing the file.
+  */
+  writeFileSync(file, data = "", options = "utf8") {
+    const absolutePath = this.formatAbsoluteFilePath(toFilePath(file));
+    if (!this.directoryExistsSync(findFilePath(absolutePath))) {
+      this.mkdirSync(findFilePath(absolutePath));
+    }
+    this.#log(LogLevelLabel.TRACE, `Writing ${absolutePath} file to the ${this.resolveOutputMode(absolutePath, options) === "fs" ? "" : "virtual "} (size: ${prettyBytes(new Blob(toArray(data)).size)})`);
+    this.#cachedFS.set(absolutePath, data.toString());
+    this.clearResolverCache(absolutePath);
+    const writeStream = this.resolveFS(absolutePath, omit(options, [
+      "mode"
+    ])).createWriteStream(absolutePath);
+    try {
+      writeStream.write(data);
+    } finally {
+      writeStream.close();
+    }
+  }
+  /**
+  * Writes a runtime file to the virtual file system (VFS).
+  *
+  * @param id - The unique identifier for the runtime file.
+  * @param path - The path to the runtime file.
+  * @param contents - The contents of the runtime file.
+  * @param options - Optional parameters for writing the runtime file.
+  * @returns A promise that resolves when the file is written.
+  */
+  async writeBuiltinFile(id, path2, contents, options = {}) {
+    const formattedId = this.formatRuntimeId(id);
+    const absolutePath = this.formatAbsoluteFilePath(toFilePath(path2));
+    this.builtinIdMap.set(formattedId, absolutePath);
+    let data = contents;
+    if (!options.skipFormat) {
+      data = await format(contents, {
+        absolutePath,
+        ...await resolveConfig(absolutePath)
+      });
+    }
+    const _options = defu4(isSetString(options) ? {} : options ?? {}, {
+      encoding: isSetString(options) ? options : "utf8",
+      mode: "virtual"
+    });
+    this.#log(LogLevelLabel.DEBUG, `Writing runtime file ${absolutePath} (size: ${prettyBytes(new Blob(toArray(data)).size)}) to ${this.resolveOutputMode(absolutePath, _options) === "fs" ? "disk" : "memory"}`);
+    return this.writeFile(absolutePath, data, _options);
+  }
+  /**
+  * Adds an entry file to the virtual file system.
+  *
+  * @param name - The file name or absolute path of the entry module.
+  * @param contents - The contents of the entry file.
+  * @param options - Optional parameters for writing the entry file.
+  */
+  async writeEntryFile(name, contents, options = {}) {
+    const absolutePath = this.formatAbsoluteFilePath(isAbsolutePath(toFilePath(name)) ? toFilePath(name) : toFilePath(joinPaths(this.#context.entryPath, name)));
+    let data = contents;
+    if (!options.skipFormat) {
+      data = await format(contents, {
+        absolutePath,
+        ...await resolveConfig(absolutePath)
+      });
+    }
+    const _options = defu4(isSetString(options) ? {} : options ?? {}, {
+      encoding: isSetString(options) ? options : "utf8",
+      mode: "virtual"
+    });
+    this.#log(LogLevelLabel.DEBUG, `Writing entry file ${absolutePath} (size: ${prettyBytes(new Blob(toArray(data)).size)}) to ${this.resolveOutputMode(absolutePath, _options) === "fs" ? "disk" : "virtual memory"}`);
+    return this.writeFile(absolutePath, data, _options);
+  }
+  /**
+  * Writes a file to disk from the physical file system (on disk).
+  *
+  * @param path - The path to the file to write.
+  * @param contents - The contents of the file to write.
+  * @param options - Optional parameters for writing the file.
+  * @returns A promise that resolves when the file is written.
+  */
+  async writeFileToDisk(path2, contents, options = {}) {
+    const absolutePath = this.formatAbsoluteFilePath(toFilePath(path2));
+    let data = contents;
+    if (!options.skipFormat) {
+      const resolvedConfig = await resolveConfig(absolutePath);
+      if (resolvedConfig) {
+        data = await format(contents, {
+          absolutePath,
+          ...resolvedConfig
+        });
+      }
+    }
+    return this.writeFile(absolutePath, data, defu4({
+      mode: "fs"
+    }, isSetString(options) ? {} : options ?? {}, {
+      encoding: isSetString(options) ? options : "utf8"
+    }));
+  }
+  /**
+  * Synchronously checks if a file exists in the virtual file system (VFS).
+  *
+  * @param pathOrId - The path or ID of the file to check.
+  * @returns `true` if the file exists, otherwise `false`.
+  */
+  existsSync(pathOrId) {
+    return this.pathExistsSync(this.resolvePath(toFilePath(pathOrId)) || toFilePath(pathOrId));
+  }
+  /**
+  * Checks if a file exists in the virtual file system (VFS).
+  *
+  * @remarks
+  * This is a base method used by {@link existsSync} - it does not try to resolve the path prior to checking if it exists or not.
+  *
+  * @param path - The path of the file to check.
+  * @returns `true` if the file exists, otherwise `false`.
+  */
+  fileExistsSync(path2) {
+    const formattedPath = this.formatAbsoluteFilePath(toFilePath(path2));
+    return this.isValidBuiltinId(formattedPath) || this.#virtualFS.existsSync(formattedPath) && this.#virtualFS.lstatSync(formattedPath).isFile() || this.#fs.existsSync(formattedPath) && this.#fs.lstatSync(formattedPath).isFile() || this.resolveFS(path2).existsSync(formattedPath) && this.resolveFS(path2).lstatSync(formattedPath).isFile();
+  }
+  /**
+  * Checks if a directory exists in the virtual file system (VFS).
+  *
+  * @param path - The path of the directory to check.
+  * @returns `true` if the directory exists, otherwise `false`.
+  */
+  directoryExistsSync(path2) {
+    const formattedPath = this.formatAbsoluteFilePath(toFilePath(path2));
+    return this.#virtualFS.existsSync(formattedPath) && this.#virtualFS.lstatSync(formattedPath).isDirectory() || this.#fs.existsSync(formattedPath) && this.#fs.lstatSync(formattedPath).isDirectory() || this.resolveFS(path2).existsSync(formattedPath) && this.resolveFS(path2).lstatSync(formattedPath).isDirectory();
+  }
+  /**
+  * Checks if a path exists in the virtual file system (VFS).
+  *
+  * @param path - The path to check.
+  * @returns `true` if the path exists, otherwise `false`.
+  */
+  pathExistsSync(path2) {
+    const formattedPath = this.formatAbsoluteFilePath(toFilePath(path2));
+    return this.isValidBuiltinId(formattedPath) || this.#virtualFS.existsSync(formattedPath) || this.#fs.existsSync(formattedPath) || this.resolveFS(path2).existsSync(formattedPath);
+  }
+  /**
+  * Retrieves the status of a file in the virtual file system (VFS).
+  *
+  * @param pathOrId - The path or ID of the file to retrieve status for.
+  * @returns A promise that resolves to the file's status information, or false if the file does not exist.
+  */
+  async stat(pathOrId, options) {
+    return this.resolveFS(pathOrId).promises.stat(this.resolvePath(toFilePath(pathOrId)) || toFilePath(pathOrId), options);
+  }
+  /**
+  * Synchronously retrieves the status of a file in the virtual file system (VFS).
+  *
+  * @param pathOrId - The path or ID of the file to retrieve status for.
+  * @returns The file's status information, or false if the file does not exist.
+  */
+  statSync(pathOrId) {
+    return this.resolveFS(pathOrId).statSync(this.resolvePath(toFilePath(pathOrId)) || toFilePath(pathOrId));
+  }
+  /**
+  * Retrieves the status of a symbolic link in the virtual file system (VFS).
+  *
+  * @param pathOrId - The path or ID of the symbolic link to retrieve status for.
+  * @returns A promise that resolves to the symbolic link's status information, or false if the link does not exist.
+  */
+  async lstat(pathOrId, options) {
+    return this.resolveFS(pathOrId).promises.lstat(this.resolvePath(toFilePath(pathOrId)) || toFilePath(pathOrId), options);
+  }
+  /**
+  * Synchronously retrieves the status of a symbolic link in the virtual file system (VFS).
+  *
+  * @param pathOrId - The path or ID of the symbolic link to retrieve status for.
+  * @returns The symbolic link's status information, or false if the link does not exist.
+  */
+  lstatSync(pathOrId, options) {
+    return this.resolveFS(pathOrId).lstatSync(this.resolvePath(toFilePath(pathOrId)) || toFilePath(pathOrId), options);
+  }
+  /**
+  * Resolves a path or ID to a runtime file id in the virtual file system.
+  *
+  * @param pathOrId - The path or id of the file to resolve.
+  * @returns The resolved id of the runtime file if it exists, otherwise false.
+  */
+  resolveId(pathOrId) {
+    if (this.builtinIdMap.has(this.formatRuntimeId(toFilePath(pathOrId)))) {
+      return this.formatRuntimeId(toFilePath(pathOrId));
+    }
+    const filePath = this.resolvePath(toFilePath(pathOrId));
+    if (filePath) {
+      return this.builtinIdMap.keys().find((id) => this.builtinIdMap.get(id) === filePath) || false;
+    }
+    return false;
+  }
+  /**
+  * Resolves a path based on TypeScript's `tsconfig.json` paths.
+  *
+  * @see https://www.typescriptlang.org/tsconfig#paths
+  *
+  * @param path - The path to check.
+  * @returns The resolved file path if it exists, otherwise undefined.
+  */
+  resolveTsconfigPath(path2) {
+    if (this.#context.tsconfig.options.paths) {
+      for (const tsconfigPathKey of Object.keys(this.#context.tsconfig.options.paths).filter((tsconfigPath) => path2.startsWith(tsconfigPath.replaceAll("*", "")))) {
+        const resolvedPath = this.#context.tsconfig.options.paths[tsconfigPathKey]?.find((tsconfigPath) => this.resolvePathName(joinPaths(this.#context.workspaceConfig.workspaceRoot, tsconfigPath.replaceAll("*", ""), path2.replace(tsconfigPathKey.replaceAll("*", ""), ""))) || this.formatAbsoluteFilePath(tsconfigPath) === this.formatAbsoluteFilePath(path2));
+        if (resolvedPath) {
+          return this.formatAbsoluteFilePath(resolvedPath) === this.formatAbsoluteFilePath(path2) ? this.formatAbsoluteFilePath(resolvedPath) : this.resolvePathName(joinPaths(this.#context.workspaceConfig.workspaceRoot, resolvedPath.replaceAll("*", ""), path2.replace(tsconfigPathKey.replaceAll("*", ""), "")));
+        }
+      }
+    }
+    return false;
+  }
+  /**
+  * Resolves a path based on TypeScript's `tsconfig.json` paths.
+  *
+  * @see https://www.typescriptlang.org/tsconfig#paths
+  *
+  * @param path - The path to check.
+  * @returns The resolved file path if it exists, otherwise undefined.
+  */
+  resolveTsconfigPathPackage(path2) {
+    if (this.#context.tsconfig.options.paths) {
+      const tsconfigPathKeys = Object.keys(this.#context.tsconfig.options.paths).filter((tsconfigPath) => path2.startsWith(tsconfigPath.replaceAll("*", "")));
+      if (tsconfigPathKeys.length > 0 && tsconfigPathKeys[0]) {
+        return tsconfigPathKeys[0].replace(/\/\*$/, "");
+      }
+    }
+    return false;
+  }
+  /**
+  * Resolves a path or ID to its real path in the virtual file system (VFS).
+  *
+  * @param pathOrId - The path or ID to resolve.
+  * @returns The resolved real path if it exists, otherwise undefined.
+  */
+  realpathSync(pathOrId) {
+    const filePath = this.resolvePath(toFilePath(pathOrId));
+    if (!filePath) {
+      throw new Error(`File not found: ${toFilePath(pathOrId)}`);
+    }
+    return filePath;
+  }
+  /**
+  * Resolves a path or ID parameter to a corresponding virtual file path in the virtual file system (VFS).
+  *
+  * @param pathOrId - The path or ID to resolve.
+  * @param options - Optional parameters for resolving the path, such as whether to include the file extension.
+  * @returns The resolved file path if it exists, otherwise undefined.
+  */
+  resolvePath(pathOrId, options = {}) {
+    const formattedPath = toFilePath(pathOrId);
+    const resolverKey = `${formattedPath}${options.withExtension ? "-ext" : ""}${options.paths ? `-${murmurhash(options.paths)}` : ""}${options.type ? `-${options.type}` : ""}`;
+    if (this.#cachedResolver.has(resolverKey)) {
+      return this.#cachedResolver.get(resolverKey);
+    } else if (this.#cachedFS.has(formattedPath)) {
+      return formattedPath;
+    }
+    let result = false;
+    if (this.isValidBuiltinId(formattedPath)) {
+      result = this.builtinIdMap.get(this.formatRuntimeId(formattedPath));
+    } else {
+      result = this.resolvePathName(formattedPath, options);
+    }
+    if (!result) {
+      result = false;
+    } else {
+      result = toFilePath(result);
+    }
+    if (result && options.withExtension === false) {
+      return result.replace(/\.[m|c]?[t|j]sx?$/, "");
+    }
+    this.#cachedResolver.set(resolverKey, result);
+    return result;
+  }
+  /**
+  * Formats a file path by removing the runtime prefix and leading null character.
+  *
+  * @param path - The file path to format.
+  * @returns The formatted file path.
+  */
+  formatFilePath(path2) {
+    if (!isSetString(path2)) {
+      throw new Error(`Invalid path provided. Expected a string or a valid file path.`);
+    }
+    return path2.replace(new RegExp(`^${this.#context.config.builtinPrefix}:`), "").replace(/^\\0/, "");
+  }
+  /**
+  * Converts a relative path to an absolute path based on the workspace and project root.
+  *
+  * @param path - The relative path to convert.
+  * @returns The absolute path.
+  */
+  formatAbsoluteFilePath = /* @__PURE__ */ __name((path2) => {
+    const formattedPath = this.formatFilePath(path2);
+    if (isAbsolutePath(formattedPath) || formattedPath.startsWith(this.#context.workspaceConfig.workspaceRoot)) {
+      return formattedPath;
+    } else if (formattedPath.startsWith(this.#context.config.projectRoot)) {
+      return joinPaths(this.#context.workspaceConfig.workspaceRoot, formattedPath);
+    }
+    return formattedPath;
+  }, "formatAbsoluteFilePath");
+  /**
+  * Formats a runtime ID by removing the file extension and prepending the runtime prefix.
+  *
+  * @param id - The runtime ID to format.
+  * @returns The formatted runtime ID.
+  */
+  formatRuntimeId(id) {
+    return `${this.#context.config.builtinPrefix}:${this.formatFilePath(id).replace(/\.[m|c]?[t|j]sx?$/, "")}`;
+  }
+  /**
+  * Resolves a path or ID parameter to a corresponding virtual file path in the virtual file system (VFS).
+  *
+  * @param pathOrId - The path or ID to resolve.
+  * @returns The resolved file path if it exists, otherwise undefined.
+  */
+  resolvePathName(pathOrId, options = {}) {
+    if (pathOrId.startsWith(`${this.#context.config.builtinPrefix}:`)) {
+      return false;
+    }
+    if (isAbsolutePath(pathOrId)) {
+      if (options.type === "file" ? this.fileExistsSync(pathOrId) : this.pathExistsSync(pathOrId)) {
+        return pathOrId;
+      }
+      const result = checkVariants(pathOrId, this);
+      if (result) {
+        return result;
+      }
+    }
+    for (const path2 of this.resolveParentPaths(pathOrId, options.paths)) {
+      const request = joinPaths(path2, pathOrId);
+      if (options.type === "file" ? this.fileExistsSync(pathOrId) : this.pathExistsSync(pathOrId)) {
+        return request;
+      }
+      const result = checkVariants(request, this);
+      if (result) {
+        return result;
+      }
+    }
+    return false;
+  }
+  resolveParentPaths(request, current = []) {
+    let paths = [
+      this.#context.workspaceConfig.workspaceRoot,
+      joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.projectRoot)
+    ];
+    if (this.#context.tsconfig.options.paths) {
+      paths = this.#context.tsconfig.options.paths ? Object.keys(this.#context.tsconfig.options.paths).filter((tsconfigPath) => request.startsWith(tsconfigPath.replaceAll("*", ""))).map((tsconfigPath) => this.#context.tsconfig.options.paths?.[tsconfigPath]).flat().reduce((ret, path2) => {
+        if (path2 && !ret.includes(joinPaths(this.#context.workspaceConfig.workspaceRoot, path2))) {
+          ret.push(joinPaths(this.#context.workspaceConfig.workspaceRoot, path2));
+        }
+        return ret;
+      }, paths) : paths;
+    }
+    return paths.reduce((ret, path2) => {
+      if (!ret.includes(path2)) {
+        ret.push(path2);
+      }
+      return ret;
+    }, current.filter(Boolean).map((p) => this.formatAbsoluteFilePath(toFilePath(p))));
+  }
+  /**
+  * Select the file system module to use for the operation based on the path or URL.
+  *
+  * @param pathOrUrl - The path to perform the file system operation on.
+  * @param options - Options for the operation, such as output mode.
+  * @returns The file system module used for the operation.
+  */
+  resolveFS(pathOrUrl, options = {}) {
+    const mode = this.resolveOutputMode(pathOrUrl, options);
+    if (mode === "virtual") {
+      return this.#virtualFS;
+    } else if (mode === "fs") {
+      return this.#fs;
+    }
+    return this.#unifiedFS;
+  }
+  /**
+  * Select the file system module to use for the operation based on the path or URL.
+  *
+  * @param pathOrUrl - The path to perform the file system operation on.
+  * @param options - Options for the operation, such as output mode.
+  * @returns The file system module used for the operation.
+  */
+  resolveOutputMode(pathOrUrl, options = {}) {
+    if (options.mode === "virtual" && this.#context.config.output.mode !== "fs" && isParentPath(toFilePath(pathOrUrl), this.#context.artifactsPath)) {
+      return "virtual";
+    } else if (options.mode === "fs" || this.#context.config.output.mode === "fs" || isParentPath(toFilePath(pathOrUrl), this.#context.dataPath) || isParentPath(toFilePath(pathOrUrl), this.#context.cachePath) || isParentPath(toFilePath(pathOrUrl), joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.output.outputPath))) {
+      return "fs";
+    }
+    return null;
+  }
+  /**
+  * Clears the resolver cache for a given path.
+  *
+  * @param path - The path to clear the resolver cache for.
+  */
+  clearResolverCache(path2) {
+    this.#cachedResolver.keys().filter((key) => key.startsWith(toFilePath(path2))).forEach((key) => this.#cachedResolver.delete(key));
+  }
+};
+var FILE_PREFIX = "file://";
+function toFilePath(pathOrUrl) {
+  if (!pathOrUrl) {
+    throw new Error("No Path or URL provided to Virtual File System");
+  }
+  let result = pathOrUrl.toString();
+  if (result.startsWith(FILE_PREFIX)) {
+    result = result.slice(FILE_PREFIX.length);
+  }
+  return result;
+}
+__name(toFilePath, "toFilePath");
+var FS_METHODS = [
+  "mkdir",
+  "mkdirSync",
+  "rmdir",
+  "rmdirSync",
+  "unlink",
+  "unlinkSync",
+  "existsSync",
+  "realpathSync",
+  "writeFileSync",
+  "readFileSync",
+  "readdirSync",
+  "createWriteStream",
+  "WriteStream",
+  "createReadStream",
+  "ReadStream"
+];
+var FS_PROMISE_METHODS = [
+  "mkdir",
+  "rm",
+  "rmdir",
+  "unlink",
+  "writeFile",
+  "readFile",
+  "readdir",
+  "stat",
+  "lstat"
+];
+function cloneFS(originalFS) {
+  const clonedFS = {
+    ...originalFS,
+    promises: {
+      ...originalFS.promises ?? {}
+    }
+  };
+  for (const method of FS_METHODS) {
+    if (originalFS[method]) {
+      clonedFS[method] = originalFS[method];
+    }
+  }
+  originalFS.promises ??= {};
+  for (const method of FS_PROMISE_METHODS) {
+    if (originalFS.promises[method]) {
+      clonedFS.promises ??= {};
+      clonedFS.promises[method] = originalFS.promises[method];
+      clonedFS[method] = originalFS.promises[method];
+    }
+  }
+  for (const prop in clonedFS) {
+    if (isFunction(clonedFS[prop])) {
+      clonedFS[prop] = clonedFS[prop].bind(originalFS);
+      if (isFunction(clonedFS.promises[prop])) {
+        clonedFS.promises[prop] = clonedFS.promises[prop].bind(originalFS);
+      }
+    }
+  }
+  for (const prop in clonedFS.promises) {
+    if (isFunction(clonedFS.promises[prop])) {
+      clonedFS.promises[prop] = clonedFS.promises[prop].bind(originalFS);
+    }
+  }
+  return clonedFS;
+}
+__name(cloneFS, "cloneFS");
+function patchFS(originalFS, vfs) {
+  const clonedFS = cloneFS(originalFS);
+  originalFS.mkdirSync = (file, options) => vfs.mkdirSync(toFilePath(file), options);
+  originalFS.mkdir = (file, options, callback) => vfs.mkdir(toFilePath(file), options, callback);
+  originalFS.promises.mkdir = async (file, options) => vfs.mkdir(toFilePath(file), options);
+  originalFS.unlinkSync = (file) => vfs.unlinkSync(toFilePath(file));
+  originalFS.promises.rm = async (file, options) => vfs.rm(toFilePath(file), options);
+  originalFS.promises.unlink = async (file) => vfs.unlink(toFilePath(file));
+  originalFS.existsSync = (file) => vfs.existsSync(toFilePath(file));
+  Object.defineProperty(originalFS, "realpathSync", {
+    value: /* @__PURE__ */ __name((file, options) => vfs.realpathSync(toFilePath(file), options), "value")
+  });
+  originalFS.writeFileSync = (file, data, options) => vfs.writeFileSync(toFilePath(file), data, options);
+  originalFS.promises.writeFile = async (file, data, options) => vfs.writeFile(toFilePath(file), data, options);
+  originalFS.readFileSync = (file, options) => vfs.readFileSync(toFilePath(file), options);
+  originalFS.promises.readFile = (file, options) => vfs.readFile(toFilePath(file), options);
+  originalFS.readdirSync = (file, options) => vfs.readdirSync(toFilePath(file), options);
+  originalFS.promises.readdir = (file, options) => vfs.readdir(toFilePath(file), options);
+  Object.defineProperty(originalFS, "statSync", {
+    value: /* @__PURE__ */ __name((file, options) => vfs.statSync(toFilePath(file), options), "value")
+  });
+  originalFS.stat = (file, options) => vfs.statSync(toFilePath(file), options);
+  originalFS.promises.stat = (file, options) => vfs.stat(toFilePath(file), options);
+  Object.defineProperty(originalFS, "lstatSync", {
+    value: /* @__PURE__ */ __name((file, options) => vfs.lstatSync(toFilePath(file), options), "value")
+  });
+  originalFS.lstat = (file, options) => vfs.lstatSync(toFilePath(file), options);
+  originalFS.promises.lstat = (file, options) => vfs.lstat(toFilePath(file), options);
+  return () => {
+    originalFS.mkdirSync = clonedFS.mkdirSync;
+    originalFS.mkdir = clonedFS.mkdir;
+    originalFS.promises.mkdir = clonedFS.promises.mkdir;
+    originalFS.unlinkSync = clonedFS.unlinkSync;
+    originalFS.promises.rm = clonedFS.promises.rm;
+    originalFS.promises.unlink = clonedFS.promises.unlink;
+    originalFS.existsSync = clonedFS.existsSync;
+    originalFS.realpathSync = clonedFS.realpathSync;
+    originalFS.writeFileSync = clonedFS.writeFileSync;
+    originalFS.promises.writeFile = clonedFS.promises.writeFile;
+    originalFS.readFileSync = clonedFS.readFileSync;
+    originalFS.promises.readFile = clonedFS.promises.readFile;
+    originalFS.readdirSync = clonedFS.readdirSync;
+    originalFS.promises.readdir = clonedFS.promises.readdir;
+    Object.defineProperty(originalFS, "statSync", {
+      value: clonedFS.statSync
+    });
+    originalFS.stat = clonedFS.stat;
+    originalFS.promises.stat = clonedFS.promises.stat;
+    Object.defineProperty(originalFS, "lstatSync", {
+      value: clonedFS.lstatSync
+    });
+    originalFS.lstat = clonedFS.lstat;
+    originalFS.promises.lstat = clonedFS.promises.lstat;
+  };
+}
+__name(patchFS, "patchFS");
+function checkVariants(request, vfs, parentPath) {
+  const path2 = parentPath ? joinPaths(parentPath, request) : request;
+  let file = checkExtensions(path2, vfs);
+  if (file) {
+    return file;
+  }
+  file = checkIndex(path2, vfs);
+  if (file) {
+    return file;
+  }
+  return false;
+}
+__name(checkVariants, "checkVariants");
+function checkIndex(request, vfs) {
+  let file = joinPaths(request, "index");
+  if (vfs.fileExistsSync(file)) {
+    return file;
+  }
+  file = checkExtensions(file, vfs);
+  if (file) {
+    return file;
+  }
+  return false;
+}
+__name(checkIndex, "checkIndex");
+function checkExtensions(request, vfs) {
+  let file = `${request}.ts`;
+  if (vfs.fileExistsSync(file)) {
+    return file;
+  }
+  file = `${request}.mts`;
+  if (vfs.fileExistsSync(file)) {
+    return file;
+  }
+  file = `${request}.cts`;
+  if (vfs.fileExistsSync(file)) {
+    return file;
+  }
+  file = `${request}.tsx`;
+  if (vfs.fileExistsSync(file)) {
+    return file;
+  }
+  file = `${request}.js`;
+  if (vfs.fileExistsSync(file)) {
+    return file;
+  }
+  file = `${request}.mjs`;
+  if (vfs.fileExistsSync(file)) {
+    return file;
+  }
+  file = `${request}.cjs`;
+  if (vfs.fileExistsSync(file)) {
+    return file;
+  }
+  file = `${request}.jsx`;
+  if (vfs.fileExistsSync(file)) {
+    return file;
+  }
+  file = `${request}.json`;
+  if (vfs.fileExistsSync(file)) {
+    return file;
+  }
+  file = `${request}.d.ts`;
+  if (vfs.fileExistsSync(file)) {
+    return file;
+  }
+  return false;
+}
+__name(checkExtensions, "checkExtensions");
+function createVfs(context) {
+  const vfs = new VirtualFileSystem(context);
+  return vfs;
+}
+__name(createVfs, "createVfs");
+
+// ../powerlines/src/internal/contexts/context.ts
+var cache = /* @__PURE__ */ new WeakMap();
+var PowerlinesContext = class _PowerlinesContext {
+  static {
+    __name(this, "PowerlinesContext");
+  }
+  #workspaceConfig;
+  #checksum = null;
+  #buildId = uuid();
+  #releaseId = uuid();
+  #timestamp = Date.now();
+  #envPaths;
+  #fs;
+  #tsconfig;
+  // #entry: ResolvedEntryTypeDefinition[] = [] as ResolvedEntryTypeDefinition[];
+  #getConfigProps(config = {}) {
+    return {
+      variant: config.build?.variant,
+      projectType: config.type,
+      projectRoot: config.root,
+      name: config.name,
+      title: config.title,
+      description: config.description,
+      sourceRoot: config.sourceRoot,
+      configFile: config.configFile,
+      customLogger: config.customLogger,
+      logLevel: config.logLevel,
+      builtinPrefix: config.builtinPrefix,
+      tsconfig: config.tsconfig,
+      tsconfigRaw: config.tsconfigRaw,
+      skipCache: config.skipCache,
+      skipInstalls: config.skipInstalls,
+      entry: config.entry,
+      output: config.output,
+      plugins: config.plugins,
+      mode: config.mode,
+      lint: config.lint,
+      transform: config.transform,
+      build: config.build,
+      override: config.override
+    };
+  }
+  /**
+  * Create a new Storm context from the workspace root and user config.
+  *
+  * @param workspaceRoot - The root directory of the workspace.
+  * @param config - The user configuration options.
+  * @returns A promise that resolves to the new context.
+  */
+  static async from(workspaceRoot, config) {
+    const context = new _PowerlinesContext(await loadWorkspaceConfig(workspaceRoot, config.root));
+    await context.withUserConfig(config);
+    context.corePackagePath = process.env.POWERLINES_LOCAL ? joinPaths$1(context.workspaceConfig.workspaceRoot, "packages/core") : await resolvePackage("powerlines");
+    if (!context.corePackagePath) {
+      throw new Error("Could not resolve powerlines package location.");
+    }
+    return context;
+  }
+  dependencies = {};
+  reflections = {};
+  persistedMeta = void 0;
+  corePackagePath;
+  packageJson;
+  projectJson = void 0;
+  resolver;
+  get entry() {
+    return resolveEntriesSync(this, toArray(this.config.entry));
+  }
+  /**
+  * The TypeScript configuration parsed from the tsconfig file
+  */
+  get tsconfig() {
+    if (!this.#tsconfig) {
+      this.#tsconfig = {
+        tsconfigFilePath: this.config.tsconfig
+      };
+    }
+    return this.#tsconfig;
+  }
+  set tsconfig(value) {
+    this.#tsconfig = value;
+  }
+  get fs() {
+    if (!this.#fs) {
+      this.#fs = createVfs(this);
+    }
+    return this.#fs;
+  }
+  /**
+  * Get the checksum of the project's current state
+  */
+  get checksum() {
+    return this.#checksum;
+  }
+  /**
+  * The meta information about the current build
+  */
+  get meta() {
+    return {
+      buildId: this.#buildId,
+      releaseId: this.#releaseId,
+      checksum: this.#checksum,
+      timestamp: this.#timestamp,
+      projectRootHash: murmurhash({
+        workspaceRoot: this.workspaceConfig?.workspaceRoot,
+        projectRoot: this.config?.projectRoot
+      }, {
+        maxLength: PROJECT_ROOT_HASH_LENGTH
+      }),
+      configHash: murmurhash(this.config, {
+        maxLength: CACHE_HASH_LENGTH
+      }),
+      builtinIdMap: {},
+      virtualFiles: {}
+    };
+  }
+  /**
+  * The resolved configuration options
+  */
+  get config() {
+    return this.resolvedConfig ?? {};
+  }
+  /**
+  * The logger function
+  */
+  get log() {
+    if (!this.logFn) {
+      this.logFn = this.createLog();
+    }
+    return this.logFn;
+  }
+  /**
+  * The workspace configuration
+  */
+  get workspaceConfig() {
+    return this.#workspaceConfig;
+  }
+  get envPaths() {
+    if (!this.#envPaths) {
+      this.#envPaths = getEnvPaths({
+        orgId: "storm-software",
+        appId: "powerlines",
+        workspaceRoot: this.workspaceConfig.workspaceRoot
+      });
+    }
+    return this.#envPaths;
+  }
+  /**
+  * Get the path to the artifacts directory for the project
+  */
+  get artifactsPath() {
+    return joinPaths$1(this.workspaceConfig.workspaceRoot, this.config.projectRoot, ".storm");
+  }
+  /**
+  * Get the path to the builtin modules used by the project
+  */
+  get builtinsPath() {
+    return joinPaths$1(this.artifactsPath, "builtins");
+  }
+  /**
+  * Get the path to the entry directory for the project
+  */
+  get entryPath() {
+    return joinPaths$1(this.artifactsPath, "entry");
+  }
+  /**
+  * Get the path to the data directory for the project
+  */
+  get dataPath() {
+    return joinPaths$1(this.envPaths.data, "projects", getPrefixedProjectRootHash(this.config.name, this.meta.projectRootHash));
+  }
+  /**
+  * Get the path to the cache directory for the project
+  */
+  get cachePath() {
+    return joinPaths$1(this.envPaths.cache, "projects", murmurhash({
+      checksum: this.#checksum,
+      config: this.meta.configHash
+    }, {
+      maxLength: CACHE_HASH_LENGTH
+    }));
+  }
+  /**
+  * Get the path to the generated declaration file for the project
+  */
+  get dtsPath() {
+    return this.config.output.dts ? appendPath(this.config.output.dts, this.workspaceConfig.workspaceRoot) : joinPaths$1(this.workspaceConfig.workspaceRoot, this.config.projectRoot, "storm.d.ts");
+  }
+  /**
+  * Get the project root relative to the workspace root
+  */
+  get relativeToWorkspaceRoot() {
+    return relativeToWorkspaceRoot(this.config.projectRoot);
+  }
+  /**
+  * Update the context using a new user configuration options
+  *
+  * @param userConfig - The new user configuration options.
+  */
+  async withUserConfig(userConfig, options = {
+    isHighPriority: true
+  }) {
+    this.mergeUserConfig(userConfig);
+    await this.init(this.config.userConfig, options);
+  }
+  /**
+  * Update the context using a new inline configuration options
+  *
+  * @param inlineConfig - The new inline configuration options.
+  */
+  async withInlineConfig(inlineConfig, options = {
+    isHighPriority: true
+  }) {
+    this.config.inlineConfig = inlineConfig;
+    if (inlineConfig.command === "new") {
+      const workspacePackageJsonPath = joinPaths$1(this.workspaceConfig.workspaceRoot, "package.json");
+      if (!existsSync(workspacePackageJsonPath)) {
+        throw new Error(`The workspace package.json file could not be found at ${workspacePackageJsonPath}`);
+      }
+      this.packageJson = await readJsonFile(workspacePackageJsonPath);
+      this.workspaceConfig.repository ??= isSetString(this.packageJson?.repository) ? this.packageJson.repository : this.packageJson?.repository?.url;
+    }
+    await this.init(this.config.inlineConfig, options);
+  }
+  /**
+  * Create a new logger instance
+  *
+  * @param name - The name to use for the logger instance
+  * @returns A logger function
+  */
+  createLog(name = null) {
+    return createLog(name, {
+      ...this.config,
+      logLevel: isNull(this.config.logLevel) ? "silent" : this.config.logLevel
+    });
+  }
+  /**
+  * Extend the current logger instance with a new name
+  *
+  * @param name - The name to use for the extended logger instance
+  * @returns A logger function
+  */
+  extendLog(name) {
+    return extendLog(this.log, name);
+  }
+  /**
+  * Creates a new StormContext instance.
+  *
+  * @param workspaceConfig - The workspace configuration.
+  */
+  constructor(workspaceConfig) {
+    this.#workspaceConfig = workspaceConfig;
+    this.#envPaths = getEnvPaths({
+      orgId: "storm-software",
+      appId: "powerlines",
+      workspaceRoot: workspaceConfig.workspaceRoot
+    });
+  }
+  /**
+  * The resolved configuration for this context
+  */
+  resolvedConfig = {};
+  /**
+  * A logger function specific to this context
+  */
+  logFn;
+  /**
+  * Initialize the context with the provided configuration options
+  *
+  * @param config - The partial user configuration to use for initialization.
+  */
+  async init(config = {}, options = {
+    isHighPriority: true
+  }) {
+    const cacheKey = {
+      projectRoot: config.root ?? this.config.projectRoot ?? this.config.userConfig?.root ?? this.config.inlineConfig?.root,
+      mode: (config.mode ?? this.config.mode) || this.workspaceConfig.mode,
+      skipCache: config.skipCache ?? this.config.skipCache ?? false,
+      configFile: config.configFile ?? this.config.configFile,
+      command: this.config.inlineConfig?.command
+    };
+    if (cache.has(cacheKey)) {
+      const result = cache.get(cacheKey);
+      this.projectJson = result.projectJson;
+      this.packageJson = result.packageJson;
+      this.#checksum = result.checksum;
+      this.resolver = result.resolver;
+      this.mergeUserConfig(result.userConfig.config, this.config.userConfig);
+    } else {
+      const projectJsonPath = joinPaths$1(cacheKey.projectRoot, "project.json");
+      if (existsSync(projectJsonPath)) {
+        this.projectJson = await readJsonFile(projectJsonPath);
+      }
+      const packageJsonPath = joinPaths$1(cacheKey.projectRoot, "package.json");
+      if (existsSync(packageJsonPath)) {
+        this.packageJson = await readJsonFile(packageJsonPath);
+      }
+      this.#checksum = await getChecksum(cacheKey.projectRoot);
+      this.resolver = createResolver({
+        workspaceRoot: this.workspaceConfig.workspaceRoot,
+        projectRoot: cacheKey.projectRoot,
+        cacheDir: this.cachePath,
+        mode: cacheKey.mode,
+        skipCache: cacheKey.skipCache
+      });
+      const userConfig = await loadUserConfigFile(cacheKey.projectRoot, this.resolver, cacheKey.command, cacheKey.mode, cacheKey.configFile);
+      this.mergeUserConfig(userConfig.config);
+      cache.set(cacheKey, {
+        projectJson: this.projectJson,
+        packageJson: this.packageJson,
+        checksum: this.#checksum,
+        resolver: this.resolver,
+        userConfig
+      });
+    }
+    if (isSetObject(config)) {
+      this.resolvedConfig = defu4({
+        inlineConfig: this.config.inlineConfig,
+        userConfig: this.config.userConfig
+      }, options.isHighPriority ? this.#getConfigProps(config) : {}, {
+        command: this.config.inlineConfig?.command,
+        ...this.#getConfigProps(this.config.inlineConfig)
+      }, this.#getConfigProps(this.config.userConfig), {
+        mode: this.workspaceConfig?.mode,
+        logLevel: this.workspaceConfig?.logLevel,
+        skipCache: this.workspaceConfig?.skipCache
+      }, {
+        name: this.projectJson?.name || this.packageJson?.name,
+        version: this.packageJson?.version,
+        description: this.packageJson?.description,
+        tsconfig: appendPath("tsconfig.json", cacheKey.projectRoot),
+        sourceRoot: this.projectJson?.sourceRoot || appendPath("src", cacheKey.projectRoot),
+        output: {
+          outputPath: joinPaths$1("dist", cacheKey.projectRoot),
+          mode: "virtual",
+          dts: joinPaths$1(cacheKey.projectRoot, "storm.d.ts"),
+          assets: [
+            {
+              glob: "LICENSE"
+            },
+            {
+              input: cacheKey.projectRoot,
+              glob: "*.md"
+            },
+            {
+              input: cacheKey.projectRoot,
+              glob: "package.json"
+            }
+          ]
+        }
+      }, options.isHighPriority ? {} : this.#getConfigProps(config), {
+        inlineConfig: {},
+        userConfig: {},
+        platform: "neutral",
+        mode: "production",
+        projectType: "application",
+        logLevel: "info",
+        builtinPrefix: "storm",
+        preview: false,
+        environments: {},
+        transform: {
+          babel: {
+            plugins: [],
+            presets: []
+          }
+        },
+        lint: {
+          eslint: {}
+        },
+        build: {
+          target: "esnext"
+        },
+        override: {}
+      });
+    }
+    this.config.entry = getUniqueEntries(this.config.entry);
+    if (this.config.name?.startsWith("@") && this.config.name.split("/").filter(Boolean).length > 1) {
+      this.config.name = this.config.name.split("/").filter(Boolean)[1];
+    }
+    this.config.title ??= titleCase(this.config.name);
+    if (this.config.build.external) {
+      this.config.build.external = getUnique(this.config.build.external);
+    }
+    if (this.config.build.noExternal) {
+      this.config.build.noExternal = getUnique(this.config.build.noExternal);
+    }
+    this.config.output.format = getUnique(toArray(this.config.output?.format ?? (this.config.projectType === "library" ? [
+      "cjs",
+      "esm"
+    ] : [
+      "esm"
+    ])));
+    this.config.output.outputPath ??= joinPaths$1("dist", this.config.projectRoot || ".");
+    this.config.output.assets = getUnique(this.config.output.assets.map((asset) => {
+      return {
+        glob: isSetObject(asset) ? asset.glob : asset,
+        input: isString(asset) || !asset.input || asset.input === "." || asset.input === "/" || asset.input === "./" ? this.workspaceConfig.workspaceRoot : appendPath(asset.input, this.workspaceConfig.workspaceRoot),
+        output: appendPath(isSetObject(asset) && asset.output ? joinPaths$1(this.config.output.outputPath, replacePath(asset.output, this.config.output.outputPath)) : this.config.output.outputPath, this.workspaceConfig.workspaceRoot),
+        ignore: isSetObject(asset) && asset.ignore ? toArray(asset.ignore) : void 0
+      };
+    }));
+    this.config.plugins = (this.config.plugins ?? []).filter(Boolean).reduce((ret, plugin) => {
+      if (isPlugin(plugin) && checkDedupe(plugin, ret.filter((p) => isPlugin(p)))) {
+        return ret;
+      }
+      ret.push(plugin);
+      return ret;
+    }, []);
+  }
+  mergeUserConfig(from = {}, into = this.config.userConfig ?? {}) {
+    this.config.userConfig = defu4({
+      entry: Array.isArray(from.entry) && from.entry.length > 0 ? from.entry : Array.isArray(into?.entry) && into.entry.length > 0 ? into.entry : []
+    }, omit(from ?? {}, [
+      "entry"
+    ]), omit(into ?? {}, [
+      "entry"
+    ]));
+    if (this.config.userConfig.output?.format) {
+      this.config.userConfig.output.format = getUnique(toArray(this.config.userConfig.output?.format));
+    }
+    this.config.userConfig.plugins = (this.config.userConfig.plugins ?? []).filter(Boolean).reduce((ret, plugin) => {
+      if (isPlugin(plugin) && checkDedupe(plugin, ret.filter((p) => isPlugin(p)))) {
+        return ret;
+      }
+      ret.push(plugin);
+      return ret;
+    }, []);
+  }
+};
+
+// ../powerlines/src/types/plugin.ts
+var PLUGIN_NON_HOOK_FIELDS = [
+  "name",
+  "enforce",
+  "dedupe",
+  "dependsOn",
+  "applyToEnvironment"
+];
+async function callHook(context, hook, options, ...args) {
+  const handlers = context.selectHooks(hook, options);
+  if (handlers.length > 0) {
+    context.log(LogLevelLabel.DEBUG, ` \u{1F9E9}  Calling plugin hook: ${chalk5.bold.cyanBright(`${hook}${options?.order ? ` (${options.order})` : ""}`)}`);
+    let results = [];
+    if (options?.sequential === false) {
+      results = await Promise.all(handlers.map(async (handler) => {
+        if (!isFunction(handler)) {
+          throw new Error(`Plugin hook handler for hook "${hook}" is not a function.`);
+        }
+        return Promise.resolve(handler.apply(null, ...args));
+      }));
+    } else {
+      for (const handler of handlers) {
+        if (!isFunction(handler)) {
+          throw new Error(`Plugin hook handler for hook "${hook}" is not a function.`);
+        }
+        results.push(await Promise.resolve(handler.apply(null, ...args)));
+        if (options?.result === "first" && isSet(results[results.length - 1])) {
+          break;
+        }
+      }
+    }
+    const definedResults = results.filter((result) => isSet(result));
+    if (definedResults.length > 0) {
+      let mergedResult = void 0;
+      for (const result of definedResults) {
+        mergedResult = defu(result, mergedResult ?? {});
+      }
+      return mergedResult;
+    }
+  }
+  return void 0;
+}
+__name(callHook, "callHook");
+
+// ../powerlines/src/internal/contexts/plugin-context.ts
+function createPluginContext(plugin, environment) {
+  const normalizeMessage = /* @__PURE__ */ __name((message) => {
+    return isString(message) ? message : message.message;
+  }, "normalizeMessage");
+  const log = environment.extendLog(plugin.name);
+  const callHookFn = /* @__PURE__ */ __name(async (hook, options, ...args) => {
+    return callHook(environment, hook, {
+      sequential: true,
+      ...options
+    }, ...args);
+  }, "callHookFn");
+  return new Proxy({}, {
+    get(_, prop) {
+      if (prop === "$$internal") {
+        return {
+          environment,
+          callHook: callHookFn
+        };
+      }
+      if (prop === "log" || prop === "logger") {
+        return log;
+      }
+      if (prop === "error") {
+        return (message) => {
+          log(LogLevelLabel.ERROR, normalizeMessage(message));
+        };
+      }
+      if (prop === "warn") {
+        return (message) => {
+          log(LogLevelLabel.WARN, normalizeMessage(message));
+        };
+      }
+      return environment[prop];
+    },
+    set(_, prop, value) {
+      if ([
+        "$$internal",
+        "environment",
+        "config",
+        "log",
+        "logger",
+        "error",
+        "warn",
+        "plugins",
+        "hooks",
+        "addPlugin",
+        "selectHooks"
+      ].includes(prop)) {
+        log(LogLevelLabel.WARN, `Cannot set read-only property "${String(prop)}"`);
+        return false;
+      }
+      environment[prop] = value;
+      return true;
+    }
+  });
+}
+__name(createPluginContext, "createPluginContext");
+
+// ../powerlines/src/internal/contexts/environment-context.ts
+var PowerlinesEnvironmentContext = class _PowerlinesEnvironmentContext extends PowerlinesContext {
+  static {
+    __name(this, "PowerlinesEnvironmentContext");
+  }
+  #hooks = {};
+  /**
+  * Create a new Storm context from the workspace root and user config.
+  *
+  * @param workspaceConfig - The root directory of the workspace.
+  * @param config - The user configuration options.
+  * @returns A promise that resolves to the new context.
+  */
+  static async fromConfig(workspaceConfig, config) {
+    const context = new _PowerlinesEnvironmentContext(config, workspaceConfig);
+    await context.init();
+    context.corePackagePath = process.env.POWERLINES_LOCAL ? joinPaths(context.workspaceConfig.workspaceRoot, "packages/core") : await resolvePackage("powerlines");
+    if (!context.corePackagePath) {
+      throw new Error("Could not resolve powerlines package location.");
+    }
+    return context;
+  }
+  environment;
+  plugins = [];
+  /**
+  * The resolved configuration options
+  */
+  get config() {
+    return super.config;
+  }
+  get hooks() {
+    return this.#hooks;
+  }
+  async addPlugin(plugin) {
+    let resolvedPlugin = plugin;
+    if (plugin.applyToEnvironment) {
+      const result = await Promise.resolve(plugin.applyToEnvironment(this.environment));
+      if (!result || isObject(result) && Object.keys(result).length === 0) {
+        return;
+      }
+      resolvedPlugin = isPlugin(result) ? result : plugin;
+    }
+    const context = createPluginContext(resolvedPlugin, this);
+    this.plugins.push({
+      plugin: resolvedPlugin,
+      context
+    });
+    this.#hooks = Object.keys(resolvedPlugin).filter((key) => !PLUGIN_NON_HOOK_FIELDS.includes(key)).reduce((ret, key) => {
+      const hook = key;
+      const pluginHook = resolvedPlugin[hook];
+      if (!isPluginHook(pluginHook)) {
+        return ret;
+      }
+      if (!isHookExternal(hook)) {
+        ret[hook] ??= {};
+        if (resolvedPlugin.enforce) {
+          ret[hook][`${resolvedPlugin.enforce}Enforced`] ??= [];
+          addPluginHook(context, resolvedPlugin, pluginHook, ret[hook][`${resolvedPlugin.enforce}Enforced`]);
+          return ret;
+        }
+        if (isFunction(pluginHook) || !pluginHook.order) {
+          ret[hook].normal ??= [];
+          addPluginHook(context, resolvedPlugin, pluginHook, ret[hook].normal);
+          return ret;
+        }
+        ret[hook][`${pluginHook.order}Ordered`] ??= [];
+        addPluginHook(context, resolvedPlugin, pluginHook, ret[hook][`${pluginHook.order}Ordered`]);
+      } else {
+        ret[hook] ??= [];
+        ret[hook].push({
+          plugin: resolvedPlugin,
+          hook: getHookHandler(pluginHook).bind(context)
+        });
+      }
+      return ret;
+    }, this.hooks);
+  }
+  /**
+  * Retrieves the hook handlers for a specific hook name
+  */
+  selectHooks(hook, options) {
+    const handlers = [];
+    if (this.hooks[hook]) {
+      if (!isHookExternal(hook)) {
+        const hooks = this.hooks[hook];
+        if (options?.order) {
+          if (options?.order === "pre") {
+            handlers.push(...(hooks.preOrdered ?? []).map((h) => h.handler));
+            handlers.push(...(hooks.preEnforced ?? []).map((h) => h.handler));
+          } else if (options?.order === "post") {
+            handlers.push(...(hooks.postOrdered ?? []).map((h) => h.handler));
+            handlers.push(...(hooks.postEnforced ?? []).map((h) => h.handler));
+          } else {
+            handlers.push(...(hooks.normal ?? []).map((h) => h.handler));
+          }
+        } else {
+          handlers.push(...this.selectHooks(hook, {
+            order: "pre"
+          }));
+          handlers.push(...this.selectHooks(hook, {
+            order: "normal"
+          }));
+          handlers.push(...this.selectHooks(hook, {
+            order: "post"
+          }));
+        }
+      } else {
+        handlers.push(...this.hooks[hook].map((h) => h.handler));
+      }
+    }
+    return handlers;
+  }
+  constructor(config, workspaceConfig) {
+    super(workspaceConfig);
+    this.resolvedConfig = config;
+  }
+};
+
+// ../powerlines/src/internal/contexts/api-context.ts
+var PowerlinesAPIContext = class _PowerlinesAPIContext extends PowerlinesContext {
+  static {
+    __name(this, "PowerlinesAPIContext");
+  }
+  #environments = {};
+  #plugins = [];
+  #log;
+  /**
+  * Create a new Storm context from the workspace root and user config.
+  *
+  * @param workspaceRoot - The root directory of the workspace.
+  * @param config - The user configuration options.
+  * @returns A promise that resolves to the new context.
+  */
+  static async from(workspaceRoot, config) {
+    const context = new _PowerlinesAPIContext(await loadWorkspaceConfig(workspaceRoot, config.root));
+    await context.withUserConfig(config);
+    context.corePackagePath = process.env.POWERLINES_LOCAL ? joinPaths(context.workspaceConfig.workspaceRoot, "packages/core") : await resolvePackage("powerlines");
+    if (!context.corePackagePath) {
+      throw new Error("Could not resolve powerlines package location.");
+    }
+    return context;
+  }
+  /**
+  * A record of all environments by name
+  */
+  get environments() {
+    return this.#environments;
+  }
+  get log() {
+    if (!this.#log) {
+      this.#log = this.createLog("engine");
+    }
+    return this.#log;
+  }
+  get plugins() {
+    return this.#plugins;
+  }
+  constructor(workspaceConfig) {
+    super(workspaceConfig);
+  }
+  /**
+  * Initialize the context with the provided configuration options
+  *
+  * @param config - The partial user configuration to use for initialization.
+  */
+  async init(config = {}) {
+    await super.init(config);
+    await Promise.all(toArray(this.config.userConfig.environments && Object.keys(this.config.userConfig.environments).length > 0 ? Object.keys(this.config.userConfig.environments).map((name) => createEnvironment(name, this.config.userConfig)) : createDefaultEnvironment(this.config.userConfig)).map(async (env) => {
+      this.#environments[env.name] = await this.in(env);
+    }));
+  }
+  /**
+  * A function to copy the context and update the fields for a specific environment
+  *
+  * @param environment - The environment configuration to use.
+  * @returns A new context instance with the updated environment.
+  */
+  async in(environment) {
+    let context;
+    if (this.environments[environment.name]) {
+      context = this.environments[environment.name];
+    } else {
+      context = await PowerlinesEnvironmentContext.fromConfig(this.workspaceConfig, this.config);
+    }
+    if (isSetObject(this.config.inlineConfig)) {
+      await context.withInlineConfig(this.config.inlineConfig);
+    }
+    context.environment = environment;
+    context.plugins = [];
+    for (const plugin of this.plugins) {
+      await context.addPlugin(plugin);
+    }
+    return context;
+  }
+  async addPlugin(plugin) {
+    this.plugins.push(plugin);
+    await Promise.all(Object.keys(this.environments).map(async (name) => {
+      await this.environments[name].addPlugin(plugin);
+    }));
+  }
+  async getEnvironment(name) {
+    let environment;
+    if (name) {
+      environment = this.environments[name];
+    }
+    if (Object.keys(this.environments).length === 1) {
+      environment = this.environments[Object.keys(this.environments)[0]];
+      this.log(LogLevelLabel.DEBUG, `Applying the only configured environment: ${chalk5.bold.cyanBright(environment?.environment.name)}`);
+    }
+    if (!environment) {
+      if (name) {
+        throw new Error(`Environment "${name}" not found.`);
+      }
+      environment = await this.in(createDefaultEnvironment(this.config.userConfig));
+      this.log(LogLevelLabel.WARN, `No environment specified, and no default environment found. Using a temporary default environment: ${chalk5.bold.cyanBright(environment?.environment.name)}`);
+    }
+    return environment;
+  }
+  async getEnvironmentSafe(name) {
+    try {
+      return await this.getEnvironment(name);
+    } catch {
+      return void 0;
+    }
+  }
+};
+async function installPackage(context, packageName, dev = false) {
+  const isListed = await isPackageListed(packageName, {
+    cwd: context.config.projectRoot
+  });
+  if (!isListed) {
+    if (context.config.skipInstalls !== true && !process.env.POWERLINES_LOCAL) {
+      context.log(LogLevelLabel.WARN, `The package "${packageName}" is not installed. It will be installed automatically.`);
+      const result = await install(packageName, {
+        cwd: context.config.projectRoot,
+        dev
+      });
+      if (isNumber(result.exitCode) && result.exitCode > 0) {
+        context.log(LogLevelLabel.ERROR, result.stderr);
+        throw new Error(`An error occurred while installing the package "${packageName}"`);
+      }
+    } else {
+      context.log(LogLevelLabel.WARN, `The package "${packageName}" is not installed. Since the "skipInstalls" option is set to true, it will not be installed automatically.`);
+    }
+  } else if (hasPackageVersion(packageName) && !process.env.STORM_STACK_SKIP_VERSION_CHECK) {
+    const isMatching = await doesPackageMatch(getPackageName(packageName), getPackageVersion(packageName), context.config.projectRoot);
+    if (!isMatching) {
+      const packageListing = await getPackageListing(getPackageName(packageName), {
+        cwd: context.config.projectRoot
+      });
+      if (!packageListing?.version.startsWith("catalog:") && !packageListing?.version.startsWith("workspace:")) {
+        context.log(LogLevelLabel.WARN, `The package "${getPackageName(packageName)}" is installed but does not match the expected version ${getPackageVersion(packageName)} (installed version: ${packageListing?.version || "<Unknown>"}). Please ensure this is intentional before proceeding. Note: You can skip this validation with the "STORM_STACK_SKIP_VERSION_CHECK" environment variable.`);
+      }
+    }
+  }
+}
+__name(installPackage, "installPackage");
+async function installPackages(context, packages) {
+  return Promise.all(packages.map(async (pkg) => installPackage(context, pkg.name, pkg.dev)));
+}
+__name(installPackages, "installPackages");
+
+// ../powerlines/src/internal/helpers/eslint.ts
+var MessageSeverity;
+(function(MessageSeverity2) {
+  MessageSeverity2[MessageSeverity2["Warning"] = 1] = "Warning";
+  MessageSeverity2[MessageSeverity2["Error"] = 2] = "Error";
+})(MessageSeverity || (MessageSeverity = {}));
+function pluginCount(messages) {
+  let nextPluginWarningCount = 0;
+  let nextPluginErrorCount = 0;
+  for (let i = 0; i < messages.length; i++) {
+    const { severity, ruleId } = messages[i];
+    if (ruleId?.includes("powerlines")) {
+      if (severity === 1) {
+        nextPluginWarningCount += 1;
+      } else {
+        nextPluginErrorCount += 1;
+      }
+    }
+  }
+  return {
+    nextPluginErrorCount,
+    nextPluginWarningCount
+  };
+}
+__name(pluginCount, "pluginCount");
+function formatMessage(dir, messages, filePath) {
+  let fileName = path.posix.normalize(path.relative(dir, filePath).replace(/\\/g, "/"));
+  if (!fileName.startsWith(".")) {
+    fileName = `./${fileName}`;
+  }
+  let output = `
+${fileName}`;
+  for (let i = 0; i < messages.length; i++) {
+    const { message, severity, line, column, ruleId } = messages[i];
+    output += "\n";
+    if (line && column) {
+      output = `${output + line.toString()}:${column.toString()}  `;
+    }
+    if (severity === 1) {
+      output += `Warning: `;
+    } else {
+      output += `Error: `;
+    }
+    output += message;
+    if (ruleId) {
+      output += `  ${ruleId}`;
+    }
+  }
+  return output;
+}
+__name(formatMessage, "formatMessage");
+async function formatResults(baseDir, results, format3) {
+  let totalPluginErrorCount = 0;
+  let totalPluginWarningCount = 0;
+  const resultsWithMessages = results.filter(({ messages }) => messages?.length);
+  resultsWithMessages.forEach(({ messages }) => {
+    const res = pluginCount(messages);
+    totalPluginErrorCount += res.nextPluginErrorCount;
+    totalPluginWarningCount += res.nextPluginWarningCount;
+  });
+  const output = format3 ? await format3(resultsWithMessages) : resultsWithMessages.map(({ messages, filePath }) => formatMessage(baseDir, messages, filePath)).join("\n");
+  return {
+    output,
+    outputWithMessages: resultsWithMessages.length > 0 ? `${output}
+
+Info  - Need to disable some ESLint rules? Learn more here: https://nextjs.org/docs/app/api-reference/config/eslint#disabling-rules` : "",
+    totalPluginErrorCount,
+    totalPluginWarningCount
+  };
+}
+__name(formatResults, "formatResults");
+async function writeDefaultEslintConfig(log, context, type = "recommended") {
+  const eslintConfigFile = joinPaths(context.workspaceConfig.workspaceRoot, "eslint.config.js");
+  const eslintConfig = `
+import { getConfig } from "eslint-config-powerlines";
+
+Error.stackTraceLimit = Number.POSITIVE_INFINITY;
+
+export default getConfig({
+  repositoryName: "${context.workspaceConfig.name || context.config.name || "powerlines"}",
+  "powerlines": "${type}",
+});
+`;
+  log(LogLevelLabel.INFO, `Writing a default ESLint config file to ${eslintConfigFile}`);
+  return writeFile2(log, eslintConfigFile, eslintConfig);
+}
+__name(writeDefaultEslintConfig, "writeDefaultEslintConfig");
+var VALID_SEVERITY = [
+  "off",
+  "warn",
+  "error"
+];
+function isValidSeverity(severity) {
+  return VALID_SEVERITY.includes(severity);
+}
+__name(isValidSeverity, "isValidSeverity");
+async function writeOutputFile(log, outputFile, outputData) {
+  const filePath = path.resolve(process.cwd(), outputFile);
+  if (isDirectory(filePath)) {
+    log(LogLevelLabel.ERROR, `Cannot write to output file path, it is a directory: ${filePath}`);
+  } else {
+    try {
+      await writeFile2(log, filePath, outputData);
+      log(LogLevelLabel.INFO, `The output file has been created: ${filePath}`);
+    } catch (err) {
+      log(LogLevelLabel.ERROR, `There was a problem writing the output file: ${filePath}`);
+      console.error(err);
+    }
+  }
+}
+__name(writeOutputFile, "writeOutputFile");
+async function hasEslintConfiguration(eslintFile, packageJsonConfig) {
+  const configObject = {
+    exists: false,
+    emptyEslint: false,
+    emptyPkgJsonConfig: false
+  };
+  if (eslintFile) {
+    const content = await readFile(eslintFile).then((txt) => txt.trim().replace(/\n/g, ""), () => null);
+    if (content === "" || content === "{}" || content === "---" || content === "module.exports = {}") {
+      configObject.emptyEslint = true;
+    } else {
+      configObject.exists = true;
+    }
+  } else if (packageJsonConfig?.eslintConfig) {
+    if (Object.keys(packageJsonConfig.eslintConfig).length) {
+      configObject.exists = true;
+    } else {
+      configObject.emptyPkgJsonConfig = true;
+    }
+  }
+  return configObject;
+}
+__name(hasEslintConfiguration, "hasEslintConfiguration");
+var lint = /* @__PURE__ */ __name(async (log, context, eslintConfigPath, { lintDuringBuild = false, eslintOptions = null, reportErrorsOnly = false, maxWarnings = -1, formatter = null, outputFile = null }) => {
+  try {
+    await installPackages(context, [
+      {
+        name: "eslint",
+        dev: true
+      },
+      {
+        name: "eslint-config-powerlines",
+        dev: true
+      }
+    ]);
+    const isInstalled = isPackageExists("eslint", {
+      paths: [
+        context.workspaceConfig.workspaceRoot,
+        context.config.projectRoot
+      ]
+    });
+    if (!isInstalled) {
+      log(LogLevelLabel.ERROR, `ESLint must be installed${lintDuringBuild ? " in order to run during builds:" : ":"} npm install --save-dev eslint`);
+      return null;
+    }
+    const module = await context.resolver.import(context.resolver.esmResolve("eslint"));
+    const useFlatConfig = eslintConfigPath ? findFileName(eslintConfigPath).startsWith("eslint.config.") : false;
+    let ESLint;
+    if ("loadESLint" in module) {
+      ESLint = await module.loadESLint({
+        useFlatConfig
+      });
+    }
+    const eslintVersion = parseVersion(ESLint?.version);
+    if (!eslintVersion || eslintVersion.compare("8.57.0") < 0) {
+      return `Error - Your project has an older version of ESLint installed${eslintVersion ? ` (${eslintVersion.major}.${eslintVersion.minor}.${eslintVersion.patch})` : ""}. Please upgrade to ESLint version 8.57.0 or above`;
+    }
+    const options = {
+      useEslintrc: true,
+      baseConfig: {},
+      errorOnUnmatchedPattern: false,
+      extensions: [
+        ".js",
+        ".jsx",
+        ".ts",
+        ".tsx"
+      ],
+      cache: true,
+      ...eslintOptions
+    };
+    if (eslintVersion?.compare("9.0.0") && useFlatConfig) {
+      for (const option of [
+        "useEslintrc",
+        "extensions",
+        "ignorePath",
+        "reportUnusedDisableDirectives",
+        "resolvePluginsRelativeTo",
+        "rulePaths",
+        "inlineConfig",
+        "maxWarnings"
+      ]) {
+        if (option in options) {
+          delete options[option];
+        }
+      }
+    }
+    let eslint2 = new ESLint(options);
+    let stormStackEslintPluginIsEnabled = false;
+    const stormStackRulesEnabled = /* @__PURE__ */ new Map();
+    for (const configFile of [
+      eslintConfigPath,
+      joinPaths(context.config.projectRoot, "package.json")
+    ]) {
+      if (!configFile) continue;
+      const completeConfig = await eslint2.calculateConfigForFile(configFile);
+      if (!completeConfig) continue;
+      const plugins2 = completeConfig.plugins;
+      const hasStormStackPlugin = (
+        // in ESLint < 9, `plugins` value is string[]
+        Array.isArray(plugins2) ? plugins2.includes("powerlines") : "powerlines" in plugins2
+      );
+      if (hasStormStackPlugin) {
+        stormStackEslintPluginIsEnabled = true;
+        for (const [name, [severity]] of Object.entries(completeConfig.rules)) {
+          if (!name.startsWith("powerlines/")) {
+            continue;
+          }
+          if (typeof severity === "number" && severity >= 0 && severity < VALID_SEVERITY.length) {
+            stormStackRulesEnabled.set(name, VALID_SEVERITY[severity]);
+          } else if (typeof severity === "string" && isValidSeverity(severity)) {
+            stormStackRulesEnabled.set(name, severity);
+          }
+        }
+        break;
+      }
+    }
+    if (stormStackEslintPluginIsEnabled) {
+      eslint2 = new ESLint(options);
+    } else {
+      log(LogLevelLabel.WARN, "The Powerlines plugin was not detected in your ESLint configuration. See https://nextjs.org/docs/app/api-reference/config/eslint#migrating-existing-config");
+    }
+    const lintStart = process.hrtime();
+    let results = await eslint2.lintFiles(context.tsconfig.fileNames.filter((fileName) => !fileName.includes(context.artifactsPath) && !fileName.includes("node_modules")));
+    let selectedFormatter = null;
+    if (options.fix) {
+      await ESLint.outputFixes(results);
+    }
+    if (reportErrorsOnly) {
+      results = ESLint.getErrorResults(results);
+    }
+    if (formatter) {
+      selectedFormatter = await eslint2.loadFormatter(formatter);
+    }
+    const formattedResult = await formatResults(context.config.projectRoot, results, selectedFormatter?.format?.bind(selectedFormatter));
+    const lintEnd = process.hrtime(lintStart);
+    const totalWarnings = results.reduce((sum, file) => sum + file.warningCount, 0);
+    if (outputFile) {
+      await writeOutputFile(log, outputFile, formattedResult.output);
+    }
+    return {
+      output: formattedResult.outputWithMessages,
+      isError: ESLint.getErrorResults(results)?.length > 0 || maxWarnings >= 0 && totalWarnings > maxWarnings,
+      eventInfo: {
+        durationInSeconds: lintEnd[0],
+        eslintVersion: eslintVersion.version,
+        lintedFilesCount: results.length,
+        lintFix: !!options.fix,
+        eslintPluginErrorsCount: formattedResult.totalPluginErrorCount,
+        eslintPluginWarningsCount: formattedResult.totalPluginWarningCount,
+        stormStackRulesEnabled: Object.fromEntries(stormStackRulesEnabled)
+      }
+    };
+  } catch (err) {
+    if (lintDuringBuild) {
+      log(LogLevelLabel.ERROR, `ESLint: ${isError(err) && err.message ? err.message.replace(/\n/g, " ") : String(err)}`);
+      return null;
+    } else {
+      throw err;
+    }
+  }
+}, "lint");
+async function eslint(context, lintDuringBuild = false, opts = {}) {
+  const { eslintOptions = null, reportErrorsOnly = false, maxWarnings = -1, formatter = null, outputFile = null, type = "recommended" } = opts;
+  const eslintFile = getParentPath([
+    // eslint v9
+    "eslint.config.js",
+    "eslint.config.mjs",
+    "eslint.config.cjs",
+    // TS extensions require to install a separate package `jiti`.
+    // https://eslint.org/docs/latest/use/configure/configuration-files#typescript-configuration-files
+    "eslint.config.ts",
+    "eslint.config.mts",
+    "eslint.config.cts",
+    // eslint <= v8
+    ".eslintrc.js",
+    ".eslintrc.cjs",
+    ".eslintrc.yaml",
+    ".eslintrc.yml",
+    ".eslintrc.json",
+    ".eslintrc"
+  ], context.config.projectRoot) ?? null;
+  const config = await hasEslintConfiguration(eslintFile, context.packageJson);
+  if (config.exists) {
+    return lint(context.log, context, eslintFile, {
+      lintDuringBuild,
+      eslintOptions,
+      reportErrorsOnly,
+      maxWarnings,
+      formatter,
+      outputFile
+    });
+  }
+  if (lintDuringBuild) {
+    if (config.emptyPkgJsonConfig || config.emptyEslint) {
+      context.log(LogLevelLabel.WARN, `No ESLint configuration detected. Run "storm lint" to begin setup`);
+    }
+    return null;
+  } else {
+    const isEslintInstalled = isPackageExists("eslint", {
+      paths: [
+        context.workspaceConfig.workspaceRoot,
+        context.config.projectRoot
+      ]
+    });
+    const isEslintPluginInstalled = isPackageExists("eslint-config-powerlines", {
+      paths: [
+        context.workspaceConfig.workspaceRoot,
+        context.config.projectRoot
+      ]
+    });
+    if (!isEslintInstalled || !isEslintPluginInstalled) {
+      await installPackages(context, [
+        {
+          name: "eslint",
+          dev: true
+        },
+        {
+          name: "eslint-config-powerlines",
+          dev: true
+        }
+      ]);
+    }
+    await writeDefaultEslintConfig(context.log, context, type);
+  }
+  context.log(LogLevelLabel.SUCCESS, `ESLint has successfully been configured. Run "storm lint" again to view warnings and errors.`);
+  return null;
+}
+__name(eslint, "eslint");
+function getString(code) {
+  if (!code) {
+    return "";
+  }
+  if (isString(code)) {
+    return code;
+  }
+  if (isSetObject(code) && "code" in code) {
+    return code.code;
+  }
+  return code.toString();
+}
+__name(getString, "getString");
+function getMagicString(code) {
+  if (isString(code)) {
+    return new MagicString(code);
+  }
+  return code;
+}
+__name(getMagicString, "getMagicString");
+function getSourceFile(code, id) {
+  const content = code ?? readFileIfExistingSync(id);
+  return {
+    id,
+    code: getMagicString(content),
+    env: []
+  };
+}
+__name(getSourceFile, "getSourceFile");
+function resolveModulePath(nodePath, state) {
+  if (!t.isStringLiteral(nodePath.node)) {
+    return;
+  }
+  const sourcePath = nodePath.node.value;
+  const resolvedPath = state.context?.fs.resolvePath(sourcePath);
+  if (resolvedPath) {
+    nodePath.replaceWith(t.stringLiteral(
+      // Remove the file extension if it exists
+      resolvedPath.replace(/\.(?:ts|mts|cts)x?$/, "")
+    ));
+  }
+}
+__name(resolveModulePath, "resolveModulePath");
+var TRANSFORM_FUNCTIONS = [
+  "require",
+  "require.resolve",
+  "System.import",
+  // Jest methods
+  "jest.genMockFromModule",
+  "jest.mock",
+  "jest.unmock",
+  "jest.doMock",
+  // eslint-disable-next-line @cspell/spellchecker
+  "jest.dontMock",
+  "jest.setMock",
+  "jest.requireActual",
+  "jest.requireMock",
+  // Older Jest methods
+  "require.requireActual",
+  "require.requireMock"
+];
+function matchesPattern(state, calleePath, pattern) {
+  const { node } = calleePath;
+  if (t.isMemberExpression(node)) {
+    return calleePath.matchesPattern(pattern);
+  }
+  if (!t.isIdentifier(node) || pattern.includes(".")) {
+    return false;
+  }
+  const name = pattern.split(".")[0];
+  return node.name === name;
+}
+__name(matchesPattern, "matchesPattern");
+var importVisitors = {
+  CallExpression: /* @__PURE__ */ __name((nodePath, state) => {
+    if (state.moduleResolverVisited.has(nodePath)) {
+      return;
+    }
+    const calleePath = nodePath.get("callee");
+    if (calleePath && TRANSFORM_FUNCTIONS.some((pattern) => matchesPattern(state, calleePath, pattern)) || t.isImport(nodePath.node.callee)) {
+      state.moduleResolverVisited.add(nodePath);
+      resolveModulePath(nodePath.get("arguments.0"), state);
+    }
+  }, "CallExpression"),
+  // eslint-disable-next-line ts/naming-convention
+  "ImportDeclaration|ExportDeclaration|ExportAllDeclaration": /* @__PURE__ */ __name((nodePath, state) => {
+    if (!nodePath || !nodePath.get("source") || state.moduleResolverVisited.has(nodePath)) {
+      return;
+    }
+    state.moduleResolverVisited.add(nodePath);
+    resolveModulePath(nodePath.get("source"), state);
+  }, "ImportDeclaration|ExportDeclaration|ExportAllDeclaration")
+};
+var moduleResolverBabelPlugin = /* @__PURE__ */ __name((context) => {
+  return declare(/* @__PURE__ */ __name(function builder(api) {
+    let moduleResolverVisited = /* @__PURE__ */ new Set();
+    return {
+      name: "powerlines:module-resolver",
+      manipulateOptions(opts) {
+        opts.filename ??= "unknown";
+      },
+      pre() {
+        moduleResolverVisited = /* @__PURE__ */ new Set();
+      },
+      visitor: {
+        Program: {
+          enter(programPath, state) {
+            programPath.traverse(importVisitors, {
+              ...state,
+              context,
+              moduleResolverVisited,
+              api
+            });
+          },
+          exit(programPath, state) {
+            programPath.traverse(importVisitors, {
+              ...state,
+              context,
+              moduleResolverVisited,
+              api
+            });
+          }
+        }
+      },
+      post() {
+        moduleResolverVisited.clear();
+      }
+    };
+  }, "builder"));
+}, "moduleResolverBabelPlugin");
+
+// ../powerlines/src/internal/helpers/generate-types.ts
+async function generateTypes(context) {
+  context.log(LogLevelLabel.TRACE, `Preparing the TypeScript definitions for the Powerlines project.`);
+  context.log(LogLevelLabel.TRACE, "Transforming built-ins runtime modules files.");
+  const builtinFiles = await Promise.all((await context.fs.listBuiltinFiles()).filter((file) => !context.fs.isMatchingBuiltinId("index", file.id)).map(async (file) => {
+    const result = await transformAsync(file.contents, {
+      highlightCode: true,
+      code: true,
+      ast: false,
+      cloneInputAst: false,
+      comments: true,
+      sourceType: "module",
+      configFile: false,
+      babelrc: false,
+      envName: context.config.mode,
+      caller: {
+        name: "powerlines"
+      },
+      ...context.config.transform.babel,
+      filename: file.path,
+      plugins: [
+        [
+          "@babel/plugin-syntax-typescript"
+        ],
+        [
+          moduleResolverBabelPlugin(context)
+        ]
+      ]
+    });
+    if (!result?.code) {
+      throw new Error(`Powerlines - Generate Types failed to compile ${file.id}`);
+    }
+    context.log(LogLevelLabel.TRACE, `Writing transformed built-in runtime file ${file.id}.`);
+    await context.fs.writeBuiltinFile(file.id, file.path, result.code);
+    return file.path;
+  }));
+  const typescriptPath = await resolvePackage("typescript");
+  if (!typescriptPath) {
+    throw new Error("Could not resolve TypeScript package location. Please ensure TypeScript is installed.");
+  }
+  const files = builtinFiles.reduce((ret, fileName) => {
+    const formatted = replacePath(fileName, context.workspaceConfig.workspaceRoot);
+    if (!ret.includes(formatted)) {
+      ret.push(formatted);
+    }
+    return ret;
+  }, [
+    joinPaths(typescriptPath, "lib", "lib.esnext.full.d.ts")
+  ]);
+  context.log(LogLevelLabel.TRACE, "Parsing TypeScript configuration for the Powerlines project.");
+  const resolvedTsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.tsconfig.tsconfigFilePath, defu4({
+    compilerOptions: {
+      strict: false,
+      noEmit: false,
+      declaration: true,
+      declarationMap: false,
+      emitDeclarationOnly: true,
+      skipLibCheck: true
+    },
+    exclude: [
+      "node_modules",
+      "dist"
+    ],
+    include: files
+  }, context.config.tsconfigRaw ?? {}));
+  resolvedTsconfig.options.configFilePath = joinPaths(context.workspaceConfig.workspaceRoot, context.tsconfig.tsconfigFilePath);
+  resolvedTsconfig.options.pathsBasePath = context.workspaceConfig.workspaceRoot;
+  resolvedTsconfig.options.suppressOutputPathCheck = true;
+  context.log(LogLevelLabel.TRACE, "Creating the TypeScript compiler host");
+  const program = createProgram(files, resolvedTsconfig.options, createCompilerHost(resolvedTsconfig.options));
+  context.log(LogLevelLabel.TRACE, `Running TypeScript compiler on ${builtinFiles.length} built-in runtime files.`);
+  let builtinModules = "";
+  const emitResult = program.emit(void 0, (fileName, text, _, __, sourceFiles, _data) => {
+    const sourceFile2 = sourceFiles?.[0];
+    if (sourceFile2?.fileName && !fileName.endsWith(".map")) {
+      if (context.fs.isBuiltinFile(sourceFile2.fileName)) {
+        builtinModules += `
+declare module "${context.fs.resolveId(sourceFile2.fileName)}" {
+    ${text.trim().replace(/^\s*export\s*declare\s*/gm, "export ").replace(/^\s*declare\s*/gm, "")}
+}
+`;
+      }
+    }
+  }, void 0, true);
+  const diagnostics = getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+  const diagnosticMessages = [];
+  diagnostics.forEach((diagnostic) => {
+    if (diagnostic.file) {
+      const { line, character } = getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+      const message = flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+      diagnosticMessages.push(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+    } else {
+      const message = flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+      diagnosticMessages.push(message);
+    }
+  });
+  const diagnosticMessage = diagnosticMessages.join("\n");
+  if (diagnosticMessage) {
+    throw new Error(`TypeScript compilation failed: 
+
+${diagnosticMessage.length > 5e3 ? `${diagnosticMessage.slice(0, 5e3)}...` : diagnosticMessage}`);
+  }
+  context.log(LogLevelLabel.TRACE, `Generating TypeScript declaration file in ${context.config.output.dts}.`);
+  const sourceFile = getSourceFile(String(context.config.output.dts), `/// <reference types="powerlines/shared" />${context.config.build.platform !== "neutral" ? `
+/// <reference types="powerlines/${context.config.build.platform}" />` : ""}
+
+${getFileHeader(null, false)}
+
+${builtinModules}`.replace(
+    // eslint-disable-next-line regexp/no-super-linear-backtracking
+    /import\s*(?:type\s*)?\{?[\w,\s]*(?:\}\s*)?from\s*(?:'|")@?[a-zA-Z0-9-\\/.]*(?:'|");?/g,
+    ""
+  ).replaceAll("#private;", "").replace(/__Ω/g, ""));
+  await context.fs.writeFileToDisk(sourceFile.id, getString(sourceFile.code));
+}
+__name(generateTypes, "generateTypes");
+async function installDependencies(context) {
+  context.log(LogLevelLabel.TRACE, `Checking and installing missing project dependencies.`);
+  context.dependencies ??= {};
+  context.dependencies["powerlines"] = {
+    type: "dependency"
+  };
+  if (context.config.projectType === "application") {
+    context.dependencies.unstorage = {
+      type: "dependency"
+    };
+  }
+  context.log(LogLevelLabel.TRACE, `The following packages must be installed as dependencies: 
+${Object.keys(context.dependencies).map((key) => ` - ${getPackageName(key)}${hasPackageVersion(key) || isSetObject(context.dependencies[key]) && isSetString(context.dependencies[key].version) ? ` v${isSetObject(context.dependencies[key]) && isSetString(context.dependencies[key].version) ? context.dependencies[key].version : getPackageVersion(key)}` : ""} (${(isString(context.dependencies[key]) ? context.dependencies[key] : context.dependencies[key]?.type) || "dependency"})`).join("\n")}`);
+  for (const [key, value] of Object.entries(context.dependencies)) {
+    const version = isSetObject(value) && isValidRange(value.version) && value.version || getPackageVersion(key);
+    await installPackage(context, version ? `${getPackageName(key)}@${String(version)}` : getPackageName(key), (isSetString(value) ? value : value.type) === "devDependency");
+  }
+}
+__name(installDependencies, "installDependencies");
+async function resolveTsconfigChanges(context) {
+  const tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig, context.config.tsconfigRaw);
+  const tsconfigFilePath = getTsconfigFilePath(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
+  const tsconfigJson = await readJsonFile(tsconfigFilePath);
+  tsconfigJson.compilerOptions ??= {};
+  const extendedTsconfig = await loadTsConfig(tsconfigFilePath);
+  extendedTsconfig.compilerOptions ??= {};
+  if (tsconfigJson.reflection !== true) {
+    tsconfigJson.reflection = true;
+  }
+  if (tsconfig.options.experimentalDecorators !== true) {
+    tsconfigJson.compilerOptions.experimentalDecorators = true;
+  }
+  if (tsconfig.options.emitDecoratorMetadata !== true) {
+    tsconfigJson.compilerOptions.emitDecoratorMetadata = true;
+  }
+  if (context.config.output.dts) {
+    const dtsFilePath = context.config.output.dts ? context.config.output.dts.startsWith(context.workspaceConfig.workspaceRoot) ? context.config.output.dts : joinPaths(context.workspaceConfig.workspaceRoot, context.config.output.dts) : joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot, "storm.d.ts");
+    const dtsRelativePath = joinPaths(relativePath(joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot), findFilePath(dtsFilePath)), findFileName(dtsFilePath));
+    if (!tsconfigJson.include?.some((filePattern) => isIncludeMatchFound(filePattern, [
+      dtsFilePath,
+      dtsRelativePath,
+      "storm.d.ts"
+    ]))) {
+      tsconfigJson.include ??= [];
+      tsconfigJson.include.push(dtsRelativePath.startsWith("./") ? dtsRelativePath.slice(2) : dtsRelativePath);
+    }
+  }
+  if (!tsconfig.options.lib?.some((lib) => [
+    "lib.esnext.d.ts",
+    "lib.es2021.d.ts",
+    "lib.es2022.d.ts",
+    "lib.es2023.d.ts"
+  ].includes(lib.toLowerCase()))) {
+    tsconfigJson.compilerOptions.lib ??= [];
+    tsconfigJson.compilerOptions.lib.push("esnext");
+  }
+  if (tsconfig.options.module !== ts3.ModuleKind.ESNext) {
+    tsconfigJson.compilerOptions.module = "ESNext";
+  }
+  if (!tsconfig.options.target || ![
+    ts3.ScriptTarget.ESNext,
+    ts3.ScriptTarget.ES2024,
+    ts3.ScriptTarget.ES2023,
+    ts3.ScriptTarget.ES2022,
+    ts3.ScriptTarget.ES2021
+  ].includes(tsconfig.options.target)) {
+    tsconfigJson.compilerOptions.target = "ESNext";
+  }
+  if (tsconfig.options.moduleResolution !== ts3.ModuleResolutionKind.Bundler) {
+    tsconfigJson.compilerOptions.moduleResolution = "Bundler";
+  }
+  if (tsconfig.options.moduleDetection !== ts3.ModuleDetectionKind.Force) {
+    tsconfigJson.compilerOptions.moduleDetection = "force";
+  }
+  if (tsconfig.options.allowSyntheticDefaultImports !== true) {
+    tsconfigJson.compilerOptions.allowSyntheticDefaultImports = true;
+  }
+  if (tsconfig.options.noImplicitOverride !== true) {
+    tsconfigJson.compilerOptions.noImplicitOverride = true;
+  }
+  if (tsconfig.options.noUncheckedIndexedAccess !== true) {
+    tsconfigJson.compilerOptions.noUncheckedIndexedAccess = true;
+  }
+  if (tsconfig.options.skipLibCheck !== true) {
+    tsconfigJson.compilerOptions.skipLibCheck = true;
+  }
+  if (tsconfig.options.resolveJsonModule !== true) {
+    tsconfigJson.compilerOptions.resolveJsonModule = true;
+  }
+  if (tsconfig.options.isolatedModules !== true) {
+    tsconfigJson.compilerOptions.isolatedModules = true;
+  }
+  if (tsconfig.options.verbatimModuleSyntax !== false) {
+    tsconfigJson.compilerOptions.verbatimModuleSyntax = false;
+  }
+  if (tsconfig.options.allowJs !== true) {
+    tsconfigJson.compilerOptions.allowJs = true;
+  }
+  if (tsconfig.options.esModuleInterop !== true) {
+    tsconfigJson.compilerOptions.esModuleInterop = true;
+  }
+  if (tsconfig.options.declaration !== true) {
+    tsconfigJson.compilerOptions.declaration = true;
+  }
+  if (context.environment.consumer === "client") {
+    if (tsconfig.options.jsx !== ts3.JsxEmit.ReactJSX) {
+      tsconfigJson.compilerOptions.jsx = "react-jsx";
+    }
+    if (!tsconfig.options.lib?.some((lib) => lib.toLowerCase() !== "dom")) {
+      tsconfigJson.compilerOptions.lib ??= [];
+      tsconfigJson.compilerOptions.lib.push("dom");
+    }
+    if (!tsconfig.options.lib?.some((lib) => lib.toLowerCase() !== "dom.iterable")) {
+      tsconfigJson.compilerOptions.lib ??= [];
+      tsconfigJson.compilerOptions.lib.push("dom.iterable");
+    }
+  } else if (context.config.build.platform === "node") {
+    if (!tsconfig.options.types?.some((type) => type.toLowerCase() === "node" || type.toLowerCase() === "@types/node")) {
+      tsconfigJson.compilerOptions.types ??= [];
+      tsconfigJson.compilerOptions.types.push("node");
+    }
+  }
+  return tsconfigJson;
+}
+__name(resolveTsconfigChanges, "resolveTsconfigChanges");
+async function initializeTsconfig(context) {
+  context.log(LogLevelLabel.TRACE, "Initializing TypeScript configuration (tsconfig.json) for the Powerlines project.");
+  if (!isPackageExists("typescript")) {
+    throw new Error('The TypeScript package is not installed. Please install the package using the command: "npm install typescript --save-dev"');
+  }
+  const tsconfigFilePath = getTsconfigFilePath(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
+  context.tsconfig.originalTsconfigJson = await readJsonFile(tsconfigFilePath);
+  context.tsconfig.tsconfigJson = await resolveTsconfigChanges(context);
+  await context.fs.writeFileToDisk(tsconfigFilePath, StormJSON.stringify(context.tsconfig.tsconfigJson));
+  context.tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig, context.config.tsconfigRaw, context.tsconfig.originalTsconfigJson);
+}
+__name(initializeTsconfig, "initializeTsconfig");
+async function resolveTsconfig(context) {
+  const updateTsconfigJson = await readJsonFile(context.tsconfig.tsconfigFilePath);
+  if (updateTsconfigJson?.compilerOptions?.types && Array.isArray(updateTsconfigJson.compilerOptions.types) && !updateTsconfigJson.compilerOptions.types.length) {
+    delete updateTsconfigJson.compilerOptions.types;
+  }
+  const result = getObjectDiff(context.tsconfig.originalTsconfigJson, updateTsconfigJson, {
+    ignoreArrayOrder: true,
+    showOnly: {
+      statuses: [
+        "added",
+        "deleted",
+        "updated"
+      ],
+      granularity: "deep"
+    }
+  });
+  const changes = [];
+  const getChanges = /* @__PURE__ */ __name((difference, property) => {
+    if (difference.status === "added" || difference.status === "deleted" || difference.status === "updated") {
+      if (difference.diff) {
+        for (const diff of difference.diff) {
+          getChanges(diff, property ? `${property}.${difference.property}` : difference.property);
+        }
+      } else {
+        changes.push({
+          field: property ? `${property}.${difference.property}` : difference.property,
+          status: difference.status,
+          previous: difference.status === "added" ? "---" : StormJSON.stringify(difference.previousValue),
+          current: difference.status === "deleted" ? "---" : StormJSON.stringify(difference.currentValue)
+        });
+      }
+    }
+  }, "getChanges");
+  for (const diff of result.diff) {
+    getChanges(diff);
+  }
+  if (changes.length > 0) {
+    context.log(LogLevelLabel.WARN, `Updating the following configuration values in "${context.tsconfig.tsconfigFilePath}" file:
+
+    ${changes.map((change, i) => `${chalk5.bold.whiteBright(`${i + 1}. ${titleCase(change.status)} the ${change.field} field: `)}
+    ${chalk5.red(` - Previous: ${change.previous} `)}
+    ${chalk5.green(` - Updated: ${change.current} `)}
+  `).join("\n")}
+    `);
+  }
+  await writeFile2(context.log, context.tsconfig.tsconfigFilePath, StormJSON.stringify(updateTsconfigJson));
+  context.tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
+  if (!context.tsconfig) {
+    throw new Error("Failed to parse the TypeScript configuration file.");
+  }
+  context.tsconfig.tsconfigJson.compilerOptions ??= {};
+  context.tsconfig.tsconfigJson.compilerOptions.strict = false;
+}
+__name(resolveTsconfig, "resolveTsconfig");
+function getDefaultCompilerOptions() {
+  return {
+    ...ts3.getDefaultCompilerOptions(),
+    jsx: ts3.JsxEmit.React,
+    strict: true,
+    esModuleInterop: true,
+    module: ts3.ModuleKind.ESNext,
+    suppressOutputPathCheck: true,
+    skipLibCheck: true,
+    skipDefaultLibCheck: true,
+    moduleResolution: ts3.ModuleResolutionKind.Node10
+  };
+}
+__name(getDefaultCompilerOptions, "getDefaultCompilerOptions");
+async function createVirtualProgram(rootNames, context, compilerOptions = {}) {
+  const options = defu4(compilerOptions, getDefaultCompilerOptions());
+  const host = {
+    name: "storm-vfs",
+    root: context.workspaceConfig.workspaceRoot,
+    ...ts3.sys,
+    realpath: /* @__PURE__ */ __name((path2) => {
+      if (context.fs.existsSync(path2)) {
+        return context.fs.resolvePath(path2);
+      }
+      return ts3.sys.realpath?.(path2) ?? path2;
+    }, "realpath"),
+    getCurrentDirectory() {
+      return context.workspaceConfig.workspaceRoot;
+    },
+    getCanonicalFileName(fileName) {
+      return fileName;
+    },
+    getDefaultLibFileName(_options) {
+      return ts3.getDefaultLibFileName(options);
+    },
+    getDefaultLibLocation() {
+      return "/";
+    },
+    getNewLine() {
+      return "\n";
+    },
+    useCaseSensitiveFileNames() {
+      return true;
+    },
+    fileExists(fileName) {
+      return context.fs.existsSync(fileName);
+    },
+    readFile(fileName) {
+      if (context.fs.existsSync(fileName)) {
+        return context.fs.readFileSync(fileName);
+      }
+      return void 0;
+    },
+    readDirectory: /* @__PURE__ */ __name((path2, extensions = [], exclude = [], include = []) => {
+      let results = [];
+      if (context.fs.existsSync(path2)) {
+        results = context.fs.readdirSync(path2, {
+          encoding: "utf8",
+          recursive: true
+        });
+        if (extensions.length > 0) {
+          results = results.filter((file) => extensions.some((ext) => file.endsWith(ext.startsWith(".") ? ext : `.${ext}`)));
+        }
+        if (exclude.length > 0) {
+          results = results.filter((file) => !exclude.some((pattern) => minimatch(file, pattern)));
+        }
+        if (include.length > 0) {
+          results = results.filter((file) => include.some((pattern) => minimatch(file, pattern)));
+        }
+      }
+      return results;
+    }, "readDirectory"),
+    writeFile(fileName, data) {
+      context.fs.writeFileSync(fileName, data);
+    },
+    resolvePath: /* @__PURE__ */ __name((fileName) => {
+      if (context.fs.existsSync(fileName)) {
+        return context.fs.resolvePath(fileName);
+      }
+      return ts3.sys.resolvePath(fileName);
+    }, "resolvePath"),
+    getSourceFile(fileName, languageVersionOrOptions, _, shouldCreateNewSourceFile) {
+      if (context.fs.existsSync(fileName)) {
+        return ts3.createSourceFile(fileName, context.fs.readFileSync(fileName), languageVersionOrOptions ?? compilerOptions.target ?? getDefaultCompilerOptions().target, false);
+      } else if (shouldCreateNewSourceFile) {
+        const sourceFile = ts3.createSourceFile(fileName, "", languageVersionOrOptions ?? compilerOptions.target ?? getDefaultCompilerOptions().target, false);
+        context.fs.writeFileSync(fileName, sourceFile.text);
+        return sourceFile;
+      }
+      return void 0;
+    }
+  };
+  return ts3.createProgram(rootNames, options, host);
+}
+__name(createVirtualProgram, "createVirtualProgram");
+
+// ../powerlines/src/internal/helpers/tsc.ts
+async function typeCheck(context, sources) {
+  if (sources) {
+    await Promise.all(sources.entries().map(async ([path2, content]) => context.fs.writeFile(path2, content)));
+  }
+  const program = await createVirtualProgram(sources ? Array.from(sources.keys()) : [], context, {
+    noEmit: true,
+    lib: [
+      "lib.esnext.d.ts"
+    ],
+    types: []
+  });
+  const emitResult = program.emit();
+  const allDiagnostics = ts3.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+  allDiagnostics.forEach((diagnostic) => {
+    if (diagnostic.file) {
+      const { line, character } = ts3.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+      const message = ts3.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+      context.log(LogLevelLabel.ERROR, `${diagnostic.file.fileName}:${line + 1}:${character + 1} : ${message}`);
+    } else {
+      context.log(LogLevelLabel.ERROR, ts3.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+    }
+  });
+}
+__name(typeCheck, "typeCheck");
+
+// ../powerlines/src/internal/api.ts
+var PowerlinesAPI = class _PowerlinesAPI {
+  static {
+    __name(this, "PowerlinesAPI");
+  }
+  /**
+  * The Powerlines context
+  */
+  #context;
+  /**
+  * The Powerlines context
+  */
+  get context() {
+    return this.#context;
+  }
+  /**
+  * Create a new Powerlines API instance
+  *
+  * @param context - The Powerlines context
+  */
+  constructor(context) {
+    this.#context = context;
+  }
+  /**
+  * Initialize the Powerlines API
+  */
+  static async from(workspaceRoot, config) {
+    const api = new _PowerlinesAPI(await PowerlinesAPIContext.from(workspaceRoot, config));
+    for (const plugin of api.context.config.plugins ?? []) {
+      await api.#addPlugin(plugin);
+    }
+    if (api.context.plugins.length === 0) {
+      api.context.log(LogLevelLabel.WARN, "No Powerlines plugins were specified in the options. Please ensure this is correct, as it is generally not recommended.");
+    }
+    const pluginConfig = await callHook(await api.context.getEnvironment(), "config", {
+      sequential: true,
+      result: "merge"
+    });
+    await api.context.withUserConfig(pluginConfig, {
+      isHighPriority: false
+    });
+    return api;
+  }
+  /**
+  * Prepare the Powerlines API
+  */
+  async prepare(inlineConfig = {
+    command: "prepare"
+  }) {
+    this.context.log(LogLevelLabel.TRACE, " \u{1F3D7}\uFE0F  Preparing the Powerlines project");
+    this.context.log(LogLevelLabel.TRACE, " \u2699\uFE0F  Aggregating configuration options for the Powerlines project");
+    await this.context.withInlineConfig(inlineConfig);
+    await this.#executeEnvironments(async (context) => {
+      context.log(LogLevelLabel.TRACE, `Initializing the processing options for the Powerlines project.`);
+      await this.callPreHook(context, "configResolved");
+      await initializeTsconfig(context);
+      await this.callNormalHook(context, "configResolved");
+      context.log(LogLevelLabel.DEBUG, `The configuration provided ${toArray(context.config.entry).length} entry point(s), Powerlines has found ${context.entry.length} entry files(s) for the ${context.config.title} project${context.entry.length > 0 && context.entry.length < 10 ? `: 
+${context.entry.map((entry) => `- ${entry.input.file || entry.file}${entry.output ? ` -> ${entry.output}` : ""}`).join(" \n")}` : ""}.`);
+      await resolveTsconfig(context);
+      await installDependencies(context);
+      await this.callPostHook(context, "configResolved");
+      context.log(LogLevelLabel.TRACE, `Powerlines configuration has been resolved: 
+
+${formatLogMessage(context.config)}`);
+      context.fs[__VFS_INIT__]();
+      await writeMetaFile(context);
+      context.persistedMeta = context.meta;
+      if (!existsSync(context.cachePath)) {
+        await createDirectory(context.cachePath);
+      }
+      if (!existsSync(context.dataPath)) {
+        await createDirectory(context.dataPath);
+      }
+      await this.callPreHook(context, "prepare");
+      if (context.config.projectType === "application") {
+        context.log(LogLevelLabel.TRACE, "Generating built-in barrel file");
+        await context.fs.writeBuiltinFile("index", joinPaths(context.builtinsPath, "index.ts"), `
+  ${getFileHeader()}
+
+  ${(await context.fs.listBuiltinFiles()).filter((file) => !isParentPath(file.path, joinPaths(context.builtinsPath, "log")) && !isParentPath(file.path, joinPaths(context.builtinsPath, "storage"))).map((file) => `export * from "./${replacePath(file.path, context.builtinsPath).replace(`.${findFileExtensionSafe(file.path)}`, "")}";`).join("\n")}
+  `);
+      }
+      if (context.config.output.dts !== false) {
+        await generateTypes(context);
+      }
+      await this.callNormalHook(context, "prepare");
+      context.tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
+      if (!context.tsconfig) {
+        throw new Error("Failed to parse the TypeScript configuration file.");
+      }
+      await this.callPostHook(context, "prepare");
+      await writeMetaFile(context);
+      context.fs[__VFS_REVERT__]();
+    });
+    this.context.log(LogLevelLabel.INFO, "Powerlines API has been prepared successfully");
+  }
+  /**
+  * Create a new Powerlines project
+  *
+  * @remarks
+  * This method will create a new Powerlines project in the current directory.
+  *
+  * @param inlineConfig - The inline configuration for the new command
+  * @returns A promise that resolves when the project has been created
+  */
+  async new(inlineConfig) {
+    this.context.log(LogLevelLabel.INFO, "\u{1F195} Creating a new Powerlines project");
+    await this.prepare(inlineConfig);
+    await this.#executeEnvironments(async (context) => {
+      context.log(LogLevelLabel.TRACE, `Initializing the processing options for the Powerlines project.`);
+      await this.callPreHook(context, "new");
+      const files = await listFiles(joinPaths(context.corePackagePath, "files/common/**/*.hbs"));
+      for (const file of files) {
+        context.log(LogLevelLabel.TRACE, `Adding template file: ${file}`);
+        const template = Handlebars.compile(file);
+        await writeFile2(context.log, joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
+      }
+      await this.callNormalHook(context, "new");
+      if (context.config.projectType === "application") {
+        const files2 = await listFiles(joinPaths(context.corePackagePath, "files/application/**/*.hbs"));
+        for (const file of files2) {
+          context.log(LogLevelLabel.TRACE, `Adding application template file: ${file}`);
+          const template = Handlebars.compile(file);
+          await writeFile2(context.log, joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
+        }
+      } else {
+        const files2 = await listFiles(joinPaths(context.corePackagePath, "files/library/**/*.hbs"));
+        for (const file of files2) {
+          context.log(LogLevelLabel.TRACE, `Adding library template file: ${file}`);
+          const template = Handlebars.compile(file);
+          await writeFile2(context.log, joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
+        }
+      }
+      await this.callPostHook(context, "new");
+    });
+    this.context.log(LogLevelLabel.TRACE, "Powerlines - New command completed");
+  }
+  /**
+  * Clean any previously prepared artifacts
+  *
+  * @remarks
+  * This method will remove the previous Powerlines artifacts from the project.
+  *
+  * @param inlineConfig - The inline configuration for the clean command
+  * @returns A promise that resolves when the clean command has completed
+  */
+  async clean(inlineConfig = {
+    command: "clean"
+  }) {
+    this.context.log(LogLevelLabel.INFO, "\u{1F9F9} Cleaning the previous Powerlines artifacts");
+    await this.prepare(inlineConfig);
+    await this.#executeEnvironments(async (context) => {
+      await callHook(context, "clean", {
+        sequential: true
+      });
+    });
+    this.context.log(LogLevelLabel.TRACE, "Powerlines - Clean command completed");
+  }
+  /**
+  * Lint the project
+  *
+  * @param inlineConfig - The inline configuration for the lint command
+  * @returns A promise that resolves when the lint command has completed
+  */
+  async lint(inlineConfig = {
+    command: "lint"
+  }) {
+    this.context.log(LogLevelLabel.INFO, "\u{1F4CB} Linting the Powerlines project");
+    await this.prepare(inlineConfig);
+    await this.#executeEnvironments(async (context) => {
+      if (context.config.lint !== false) {
+        await this.callPreHook(context, "lint");
+        await typeCheck(context);
+        await eslint(context, true, context.config.lint.eslint);
+        await this.callNormalHook(context, "lint");
+        await this.callPostHook(context, "lint");
+      }
+    });
+    this.context.log(LogLevelLabel.TRACE, "Powerlines linting completed");
+  }
+  /**
+  * Build the project
+  *
+  * @remarks
+  * This method will build the Powerlines project, generating the necessary artifacts.
+  *
+  * @param inlineConfig - The inline configuration for the build command
+  * @returns A promise that resolves when the build command has completed
+  */
+  async build(inlineConfig = {
+    command: "build"
+  }) {
+    this.context.log(LogLevelLabel.INFO, "\u{1F4E6}  Building the Powerlines project");
+    await this.prepare(inlineConfig);
+    await this.#executeEnvironments(async (context) => {
+      await this.callPreHook(context, "build");
+      await this.callNormalHook(context, "build");
+      await Promise.all(context.config.output.assets.map(async (asset) => {
+        context.log(LogLevelLabel.DEBUG, `Copying asset(s): ${chalk5.redBright(context.workspaceConfig.workspaceRoot === asset.input ? asset.glob : joinPaths(replacePath(asset.input, context.workspaceConfig.workspaceRoot), asset.glob))} -> ${chalk5.greenBright(joinPaths(replacePath(asset.output, context.workspaceConfig.workspaceRoot), asset.glob))} ${Array.isArray(asset.ignore) && asset.ignore.length > 0 ? ` (ignoring: ${asset.ignore.map((i) => chalk5.yellowBright(i)).join(", ")})` : ""}`);
+        await copyFiles(asset, asset.output);
+      }));
+      await this.callPostHook(context, "build");
+    });
+    this.context.log(LogLevelLabel.TRACE, "Powerlines build completed");
+  }
+  /**
+  * Prepare the documentation for the project
+  *
+  * @param inlineConfig - The inline configuration for the docs command
+  * @returns A promise that resolves when the documentation generation has completed
+  */
+  async docs(inlineConfig = {
+    command: "docs"
+  }) {
+    this.context.log(LogLevelLabel.INFO, "Generating documentation for the Powerlines project");
+    await this.prepare(inlineConfig);
+    await this.#executeEnvironments(async (context) => {
+      context.log(LogLevelLabel.TRACE, "Writing API-Reference documentation for the Powerlines project artifacts.");
+      await this.callPreHook(context, "docs");
+      const outputPath = joinPaths(context.config.projectRoot, "docs", "generated", "api-reference");
+      if (existsSync(outputPath)) {
+        await removeDirectory(outputPath);
+      }
+      await createDirectory(outputPath);
+      await this.callNormalHook(context, "docs");
+      const { generateDocs, getReflections } = await initTypedoc(context, {
+        outputPath
+      });
+      const project = await getReflections();
+      if (project) {
+        await generateDocs({
+          project
+        });
+      }
+      await this.callPostHook(context, "docs");
+    });
+    this.#context.log(LogLevelLabel.TRACE, "Powerlines documentation generation completed");
+  }
+  /**
+  * Release the project
+  *
+  * @remarks
+  * This method will prepare and build the Powerlines project, generating the necessary artifacts for release.
+  *
+  * @param inlineConfig - The inline configuration for the release command
+  */
+  async release(inlineConfig = {
+    command: "release"
+  }) {
+    this.context.log(LogLevelLabel.INFO, "\u{1F4E6} Releasing the Powerlines project");
+    await this.prepare(inlineConfig);
+    await this.#executeEnvironments(async (context) => {
+      await this.callHook(context, "release");
+    });
+    this.context.log(LogLevelLabel.TRACE, "Powerlines release completed");
+  }
+  /**
+  * Finalization process
+  *
+  * @remarks
+  * This step includes any final processes or clean up required by Powerlines. It will be run after each Powerlines command.
+  *
+  * @returns A promise that resolves when the finalization process has completed
+  */
+  async finalize() {
+    this.context.log(LogLevelLabel.TRACE, "Powerlines finalize execution started");
+    await this.#executeEnvironments(async (context) => {
+      await this.callHook(context, "finalize");
+      context.fs[__VFS_REVERT__]();
+    });
+    this.context.log(LogLevelLabel.TRACE, "Powerlines finalize execution completed");
+  }
+  /**
+  * Calls a hook in parallel
+  *
+  * @param hook - The hook to call
+  * @param options - Options for calling the hook
+  * @param args - The arguments to pass to the hook
+  * @returns The result of the hook call
+  */
+  async callHookParallel(hook, options, ...args) {
+    return callHook(isSetObject(options?.environment) ? options.environment : await this.#context.getEnvironment(options?.environment), hook, {
+      ...options,
+      sequential: false
+    }, ...args);
+  }
+  /**
+  * Calls a hook in sequence
+  *
+  * @param hook - The hook to call
+  * @param options - Options for calling the hook
+  * @param args - The arguments to pass to the hook
+  * @returns The result of the hook call
+  */
+  async callHookSequential(hook, options, ...args) {
+    return callHook(isSetObject(options?.environment) ? options.environment : await this.#context.getEnvironment(options?.environment), hook, {
+      ...options,
+      sequential: true
+    }, ...args);
+  }
+  /**
+  * Calls the `"pre"` ordered hooks in sequence
+  *
+  * @param environment - The environment to use for the hook call
+  * @param hook - The hook to call
+  * @param args - The arguments to pass to the hook
+  * @returns The result of the hook call
+  */
+  async callPreHook(environment, hook, ...args) {
+    return this.callHookSequential(hook, {
+      order: "pre",
+      environment
+    }, ...args);
+  }
+  /**
+  * Calls the `"post"` ordered hooks in sequence
+  *
+  * @param environment - The environment to use for the hook call
+  * @param hook - The hook to call
+  * @param args - The arguments to pass to the hook
+  * @returns The result of the hook call
+  */
+  async callPostHook(environment, hook, ...args) {
+    return this.callHookSequential(hook, {
+      order: "post",
+      environment
+    }, ...args);
+  }
+  /**
+  * Calls a hook in sequence
+  *
+  * @param environment - The environment to use for the hook call
+  * @param hook - The hook to call
+  * @param args - The arguments to pass to the hook
+  * @returns The result of the hook call
+  */
+  async callNormalHook(environment, hook, ...args) {
+    return this.callHookSequential(hook, {
+      order: "normal",
+      environment
+    }, ...args);
+  }
+  /**
+  * Calls the `"pre"` and `"post"` ordered hooks, as well as the normal hooks in sequence
+  *
+  * @param environment - The environment to use for the hook call
+  * @param hook - The hook to call
+  * @param args - The arguments to pass to the hook
+  * @returns The result of the hook call
+  */
+  async callHook(environment, hook, ...args) {
+    return this.callHookSequential(hook, {
+      environment
+    }, ...args);
+  }
+  async [Symbol.asyncDispose]() {
+    await this.finalize();
+  }
+  /**
+  * Get the configured environments
+  *
+  * @returns The configured environments
+  */
+  async #getEnvironments() {
+    if (!this.context.config.environments || Object.keys(this.context.config.environments).length <= 1) {
+      this.context.log(LogLevelLabel.DEBUG, "No environments are configured for this Powerlines project. Using the default environment.");
+      return [
+        await this.context.getEnvironment()
+      ];
+    }
+    this.context.log(LogLevelLabel.DEBUG, `Found ${Object.keys(this.context.config.environments).length} configured environment(s) for this Powerlines project.`);
+    return (await Promise.all(Object.entries(this.context.config.environments).map(async ([name, config]) => {
+      const environment = await this.context.getEnvironmentSafe(name);
+      if (!environment) {
+        const resolvedEnvironment = await this.callHookParallel("configEnvironment", {
+          environment: name
+        }, name, config);
+        if (resolvedEnvironment) {
+          this.context.environments[name] = await this.context.in(resolvedEnvironment);
+        }
+      }
+      return this.context.environments[name];
+    }))).filter((context) => isSet(context));
+  }
+  /**
+  * Execute a handler function for each environment
+  *
+  * @param handle - The handler function to execute for each environment
+  */
+  async #executeEnvironments(handle) {
+    await Promise.all((await this.#getEnvironments()).map(async (context) => {
+      return Promise.resolve(handle(context));
+    }));
+  }
+  /**
+  * Add a Powerlines plugin used in the build process
+  *
+  * @param config - The import path of the plugin to add
+  */
+  async #addPlugin(config) {
+    if (config) {
+      const plugin = await this.#initPlugin(config);
+      if (!plugin) {
+        return;
+      }
+      if (plugin.dependsOn) {
+        for (const required of plugin.dependsOn) {
+          await this.#addPlugin(required);
+        }
+      }
+      this.context.log(LogLevelLabel.DEBUG, `Successfully initialized the ${chalk5.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) {
+    if (!isPluginConfig(config)) {
+      throw new Error(`Invalid plugin specified in the configuration - ${JSON.stringify(config)}. Please ensure the value is a plugin name, an object with the \`plugin\` and \`props\` properties, or an instance of \`Plugin\`.`);
+    }
+    let plugin;
+    if (isPlugin(config)) {
+      plugin = config;
+    } else if (isFunction(config)) {
+      plugin = await Promise.resolve(config());
+    } else if (isSetString(config)) {
+      const resolved = await this.#resolvePlugin(config);
+      if (isFunction(resolved)) {
+        plugin = await Promise.resolve(resolved());
+      } else {
+        plugin = resolved;
+      }
+    } else if (isPluginConfigTuple(config) || isPluginConfigObject(config)) {
+      let pluginConfig;
+      let pluginOptions;
+      if (isPluginConfigTuple(config)) {
+        pluginConfig = config[0];
+        pluginOptions = config?.length === 2 ? config[1] : void 0;
+      } else {
+        pluginConfig = config.plugin;
+        pluginOptions = config.options;
+      }
+      if (isSetString(pluginConfig)) {
+        const resolved = await this.#resolvePlugin(pluginConfig);
+        if (isFunction(resolved)) {
+          plugin = await Promise.resolve(pluginOptions ? resolved(pluginOptions) : resolved());
+        } else {
+          plugin = resolved;
+        }
+      } else if (isFunction(pluginConfig)) {
+        plugin = await Promise.resolve(pluginConfig(pluginOptions));
+      } else if (isPlugin(pluginConfig)) {
+        plugin = pluginConfig;
+      }
+    }
+    if (!plugin) {
+      throw new Error(`The plugin configuration ${JSON.stringify(config)} is invalid. This configuration must point to a valid Powerlines plugin module.`);
+    }
+    if (!isPlugin(plugin)) {
+      throw new Error(`The plugin option ${JSON.stringify(plugin)} does not export a valid module. This configuration must point to a valid Powerlines plugin module.`);
+    }
+    if (checkDedupe(plugin, this.context.plugins)) {
+      this.context.log(LogLevelLabel.TRACE, `Duplicate ${chalk5.bold.cyanBright(plugin.name)} plugin dependency detected - Skipping initialization.`);
+      return null;
+    }
+    this.context.log(LogLevelLabel.TRACE, `Initializing the ${chalk5.bold.cyanBright(plugin.name)} plugin...`);
+    return plugin;
+  }
+  async #resolvePlugin(pluginPath) {
+    if (pluginPath.startsWith("@") && pluginPath.split("/").filter(Boolean).length > 2) {
+      const splits = pluginPath.split("/").filter(Boolean);
+      pluginPath = `${splits[0]}/${splits[1]}`;
+    }
+    const isInstalled = isPackageExists(pluginPath, {
+      paths: [
+        this.context.workspaceConfig.workspaceRoot,
+        this.context.config.projectRoot
+      ]
+    });
+    if (!isInstalled && this.context.config.skipInstalls !== true) {
+      this.#context.log(LogLevelLabel.WARN, `The plugin package "${pluginPath}" is not installed. It will be installed automatically.`);
+      const result = await install(pluginPath, {
+        cwd: this.context.config.projectRoot
+      });
+      if (isNumber(result.exitCode) && result.exitCode > 0) {
+        this.#context.log(LogLevelLabel.ERROR, result.stderr);
+        throw new Error(`An error occurred while installing the build plugin package "${pluginPath}" `);
+      }
+    }
+    try {
+      const module = await this.context.resolver.plugin.import(this.context.resolver.plugin.esmResolve(joinPaths(pluginPath, "plugin")));
+      const result = module.plugin ?? module.default;
+      if (!result) {
+        throw new Error(`The plugin package "${pluginPath}" does not export a valid module.`);
+      }
+      return result;
+    } catch (error) {
+      try {
+        const module = await this.context.resolver.plugin.import(this.context.resolver.plugin.esmResolve(pluginPath));
+        const result = module.plugin ?? module.default;
+        if (!result) {
+          throw new Error(`The plugin package "${pluginPath}" does not export a valid module.`);
+        }
+        return result;
+      } catch {
+        if (!isInstalled) {
+          throw new Error(`The plugin package "${pluginPath}" is not installed. Please install the package using the command: "npm install ${pluginPath} --save-dev"`);
+        } else {
+          throw new Error(`An error occurred while importing the build plugin package "${pluginPath}":
+${isError(error) ? error.message : String(error)}
+
+Note: Please ensure the plugin package's default export is a class that extends \`Plugin\` with a constructor that excepts a single arguments of type \`PluginOptions\`.`);
+        }
+      }
+    }
+  }
+};
+var DEFAULT_ESBUILD_CONFIG = {
+  target: "esnext",
+  platform: "neutral",
+  format: "esm",
+  write: true,
+  minify: true,
+  sourcemap: false,
+  bundle: true,
+  treeShaking: true,
+  keepNames: true,
+  splitting: true,
+  logLevel: "silent"
+};
+function extractESBuildConfig(context) {
+  return defu4({
+    alias: context.fs.builtinIdMap.keys().reduce((ret, id) => {
+      const path2 = context.fs.builtinIdMap.get(id);
+      if (path2) {
+        ret[id] = path2;
+      }
+      return ret;
+    }, {})
+  }, context.config.build.variant === "esbuild" ? context.config.override : {}, {
+    format: Array.isArray(context.config.output.format) ? context.config.output.format[0] : context.config.output.format,
+    platform: context.config.build.platform,
+    treeShaking: Boolean(context.config.build?.treeshake) || context.config.build?.treeShaking,
+    outdir: context.config.output.outputPath,
+    tsconfig: context.tsconfig.tsconfigFilePath,
+    tsconfigRaw: context.tsconfig.tsconfigJson
+  }, context.config.build.variant === "esbuild" ? context.config.build : {}, {
+    minify: context.config.mode !== "development",
+    metafile: context.config.mode === "development",
+    sourcemap: context.config.mode === "development"
+  }, DEFAULT_ESBUILD_CONFIG);
+}
+__name(extractESBuildConfig, "extractESBuildConfig");
+
+// ../powerlines/src/lib/build/vite.ts
+var DEFAULT_VITE_CONFIG = {
+  resolve: {
+    extensions: [
+      ".mjs",
+      ".js",
+      ".mts",
+      ".ts",
+      ".jsx",
+      ".tsx",
+      ".json"
+    ]
+  },
+  json: {
+    stringify: true
+  },
+  logLevel: "silent",
+  clearScreen: true
+};
+function extractViteConfig(context) {
+  return defu4({
+    resolve: {
+      alias: context.fs.builtinIdMap.keys().reduce((ret, id) => {
+        const path2 = context.fs.builtinIdMap.get(id);
+        if (path2) {
+          ret[id] = path2;
+        }
+        return ret;
+      }, {})
+    }
+  }, context.config.build.variant === "vite" ? context.config.override : {}, {
+    external: context.config.build.external,
+    noExternal: context.config.build.noExternal,
+    skipNodeModulesBundle: context.config.build.skipNodeModulesBundle
+  }, {
+    rootDir: context.config.sourceRoot,
+    platform: context.config.build.platform,
+    mode: context.config.mode === "development" ? "development" : "production",
+    cacheDir: joinPaths(context.cachePath, "vite"),
+    build: {
+      outDir: context.config.output.outputPath,
+      tsconfig: context.tsconfig.tsconfigFilePath,
+      tsconfigRaw: context.tsconfig.tsconfigJson
+    },
+    esbuild: extractESBuildConfig(context),
+    logLevel: context.config.logLevel ?? void 0,
+    envDir: context.config.projectRoot,
+    noExternal: Array.from(context.fs.builtinIdMap.keys())
+  }, context.config.build.variant === "vite" ? context.config.build : {}, {
+    build: {
+      minify: context.config.mode !== "development",
+      metafile: context.config.mode === "development",
+      sourcemap: context.config.mode === "development"
+    }
+  }, DEFAULT_VITE_CONFIG);
+}
+__name(extractViteConfig, "extractViteConfig");
+var NON_NODE_MODULE_REGEX = /^[A-Z]:[/\\]|^\.{0,2}\/|^\.{1,2}$/;
+async function handleResolveId(context, args, options = {}) {
+  if (args.id) {
+    if (context.fs.isVirtualFile(args.id) || args.importer && context.fs.isVirtualFile(args.id, {
+      paths: [
+        args.importer
+      ]
+    })) {
+      const resolvedPath = args.importer ? context.fs.resolvePath(args.id, {
+        paths: [
+          args.importer
+        ]
+      }) : context.fs.resolvePath(args.id);
+      if (resolvedPath) {
+        return {
+          id: resolvedPath,
+          external: context.config.projectType !== "application"
+        };
+      }
+    }
+    if (context.fs.isTsconfigPath(args.id)) {
+      const tsconfigPath = context.fs.resolveTsconfigPath(args.id);
+      const tsconfigPathPackage = context.fs.resolveTsconfigPathPackage(args.id);
+      if (tsconfigPath && tsconfigPathPackage) {
+        return {
+          id: tsconfigPath,
+          external: Boolean(!options.noExternal?.includes(tsconfigPathPackage) && (options.external?.includes(tsconfigPathPackage) ?? context.config.projectType !== "application"))
+        };
+      }
+    }
+    if (options.skipResolve) {
+      return void 0;
+    }
+    if (options.skipNodeModulesBundle) {
+      if (match(args.id, options.resolvePatterns) || match(args.id, options.noExternal) || args.id.startsWith("internal:") || args.id.startsWith("virtual:")) {
+        return void 0;
+      }
+      if (match(args.id, options.external) || args.id.startsWith("node:")) {
+        return {
+          id: args.id,
+          external: true
+        };
+      }
+      if (!NON_NODE_MODULE_REGEX.test(args.id)) {
+        return {
+          id: args.id,
+          external: true
+        };
+      }
+    } else {
+      if (match(args.id, options.noExternal) || context.fs.isBuiltinFile(args.id) || args.importer && context.fs.isBuiltinFile(args.id, {
+        paths: [
+          args.importer
+        ]
+      })) {
+        return void 0;
+      }
+      if (match(args.id, options.external) || args.id.startsWith("node:")) {
+        return {
+          id: args.id,
+          external: true
+        };
+      }
+    }
+  }
+  return void 0;
+}
+__name(handleResolveId, "handleResolveId");
+
+// ../powerlines/src/lib/unplugin/factory.ts
+function createUnpluginFactory(variant, decorate) {
+  return (config, meta) => {
+    const log = createLog("unplugin", config);
+    log(LogLevelLabel.DEBUG, "Initializing Unplugin");
+    try {
+      const userConfig = {
+        ...config,
+        variant,
+        unplugin: meta
+      };
+      let api;
+      let resolvePatterns = [];
+      async function buildStart() {
+        log(LogLevelLabel.DEBUG, "Powerlines build plugin starting...");
+        const workspaceRoot = getWorkspaceRoot(process.cwd());
+        api = await PowerlinesAPI.from(workspaceRoot, userConfig);
+        if (api.context.config.build.skipNodeModulesBundle) {
+          resolvePatterns = tsconfigPathsToRegExp(api.context.tsconfig.options.paths ?? []);
+        }
+        log(LogLevelLabel.DEBUG, "Preparing build artifacts for the Powerlines project...");
+        await api.prepare({
+          command: "build"
+        });
+      }
+      __name(buildStart, "buildStart");
+      async function resolveId(id, importer, options = {
+        isEntry: false
+      }) {
+        return handleResolveId(api.context, {
+          id,
+          importer,
+          options
+        }, {
+          skipNodeModulesBundle: api.context.config.build.skipNodeModulesBundle,
+          external: api.context.config.build.external,
+          noExternal: api.context.config.build.noExternal,
+          resolvePatterns
+        });
+      }
+      __name(resolveId, "resolveId");
+      async function load(id) {
+        const environment = await api.context.getEnvironment();
+        if (id) {
+          const resolvedPath = environment.fs.resolvePath(id, {
+            type: "file"
+          });
+          if (resolvedPath) {
+            return environment.fs.readFile(resolvedPath);
+          }
+        }
+        let result2 = await api.callPreHook(environment, "load", id);
+        if (result2) {
+          return result2;
+        }
+        result2 = await api.callNormalHook(environment, "load", id);
+        if (result2) {
+          return result2;
+        }
+        return api.callPostHook(environment, "load", id);
+      }
+      __name(load, "load");
+      async function transform(code, id) {
+        const environment = await api.context.getEnvironment();
+        let transformed = code;
+        let result2 = await api.callPreHook(environment, "transform", getString(transformed), id);
+        if (result2) {
+          transformed = result2;
+        }
+        result2 = await api.callNormalHook(environment, "transform", getString(transformed), id);
+        if (result2) {
+          transformed = result2;
+        }
+        result2 = await api.callPostHook(environment, "transform", getString(transformed), id);
+        if (result2) {
+          transformed = result2;
+        }
+        return transformed;
+      }
+      __name(transform, "transform");
+      async function writeBundle() {
+        log(LogLevelLabel.DEBUG, "Finalizing Powerlines project output...");
+        const environment = await api.context.getEnvironment();
+        await api.callHook(environment, "writeBundle");
+      }
+      __name(writeBundle, "writeBundle");
+      const result = {
+        name: "powerlines",
+        resolveId: {
+          filter: {
+            id: {
+              include: [
+                /.*/
+              ]
+            }
+          },
+          handler: resolveId
+        },
+        load: {
+          filter: {
+            id: {
+              include: [
+                /.*/,
+                /^storm:/
+              ]
+            }
+          },
+          handler: load
+        },
+        transform,
+        buildStart,
+        writeBundle
+      };
+      return decorate ? decorate(api, result) : result;
+    } catch (error) {
+      log(LogLevelLabel.FATAL, error?.message);
+      throw error;
+    }
+  };
+}
+__name(createUnpluginFactory, "createUnpluginFactory");
+
+// ../powerlines/src/vite.ts
+var vite = createVitePlugin(createUnpluginFactory("vite", (api, plugin) => {
+  return {
+    ...plugin,
+    vite: {
+      sharedDuringBuild: true,
+      async hotUpdate(options) {
+        const environment = await api.context.getEnvironment();
+        return api.callHook(environment, "vite:hotUpdate", options);
+      },
+      async config(config, env) {
+        api.context.config.mode = isDevelopmentMode(env.mode) ? "development" : isTestMode(env.mode) ? "test" : "production";
+        const environment = await api.context.getEnvironment();
+        const result = await api.callHook(environment, "config");
+        return defu4(extractViteConfig(api.context), result?.build ?? {}, config);
+      },
+      async configResolved(_config) {
+        const environment = await api.context.getEnvironment();
+        await api.callHook(environment, "configResolved");
+      },
+      async configureServer(server) {
+        const environment = await api.context.getEnvironment();
+        return api.callHook(environment, "vite:configureServer", server);
+      },
+      async configurePreviewServer(server) {
+        const environment = await api.context.getEnvironment();
+        return api.callHook(environment, "vite:configurePreviewServer", server);
+      },
+      async transformIndexHtml(html, ctx) {
+        const environment = await api.context.getEnvironment();
+        return api.callHook(environment, "vite:transformIndexHtml", html, ctx);
+      },
+      async handleHotUpdate(ctx) {
+        const environment = await api.context.getEnvironment();
+        return api.callHook(environment, "vite:handleHotUpdate", ctx);
+      }
+    }
+  };
+}));
+var vite_default = vite;
+createEsbuildPlugin(createUnpluginFactory("esbuild", (api, plugin) => {
+  return {
+    ...plugin,
+    esbuild: {
+      config: /* @__PURE__ */ __name((options) => {
+        options ??= {};
+        const result = extractESBuildConfig(api.context);
+        for (const key in result) {
+          if (isUndefined(options[key]) && !isUndefined(result[key])) {
+            options[key] = result[key];
+          }
+        }
+      }, "config"),
+      setup: /* @__PURE__ */ __name(async (build) => {
+        const environment = await api.context.getEnvironment();
+        return api.callHook(environment, "esbuild:setup", build);
+      }, "setup")
+    }
+  };
+}));
+var webpack = createWebpackPlugin(createUnpluginFactory("webpack"));
+var webpack_default = webpack;
+defineNuxtModule({
+  meta: {
+    name: "powerlines",
+    configKey: "storm"
+  },
+  defaults: {},
+  setup(options, _nuxt) {
+    addVitePlugin(() => vite_default(options));
+    addWebpackPlugin(() => webpack_default(options));
+  }
+});
+createRolldownPlugin(createUnpluginFactory("rolldown"));
+createRollupPlugin(createUnpluginFactory("rollup"));
+createRspackPlugin(createUnpluginFactory("rspack"));
+createUnloaderPlugin(createUnpluginFactory("unloader"));
+
+// ../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, defu4({
+      root: projectConfig.root,
+      type: projectConfig.projectType,
+      sourceRoot: projectConfig.sourceRoot,
+      tsconfig: options.tsconfig,
+      logLevel: options.logLevel,
+      mode: options.mode,
+      skipCache: options.skipCache,
+      output: {
+        outputPath: options.outputPath ?? projectConfig.targets?.build?.options?.outputPath
+      }
+    }, options));
+    try {
+      return await Promise.resolve(executorFn(defu4({
+        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 };