powerlines 0.23.2 → 0.23.4

package/dist/lib/{chunk-UWHGJ4JS.js → chunk-BLNW3ZQA.js}

@@ -1,220 +1,135 @@
-import { writeFile } from './chunk-TANQDHYY.js';
-import { getFileHeader } from './chunk-GANVMM73.js';
-import { CACHE_HASH_LENGTH, PROJECT_ROOT_HASH_LENGTH, getPrefixedProjectRootHash, getChecksum, writeMetaFile } from './chunk-YH5GOJS3.js';
-import { handleResolveId } from './chunk-L4NEN725.js';
-import { getParsedTypeScriptConfig, getTsconfigFilePath, isIncludeMatchFound } from './chunk-YOENMDZY.js';
+import { CACHE_HASH_LENGTH, PROJECT_ROOT_HASH_LENGTH, getPrefixedProjectRootHash, getChecksum } from './chunk-YH5GOJS3.js';
 import { loadWorkspaceConfig, loadUserConfigFile } from './chunk-ZPIKFR7Z.js';
 import { extendLog, createLog } from './chunk-ENRLU4UR.js';
-import { getString } from './chunk-M263EZ4F.js';
-import { resolveEntriesSync, getUniqueEntries, replacePathTokens } from './chunk-XZFEHPYE.js';
+import { resolveEntriesSync, getUniqueEntries } from './chunk-XZFEHPYE.js';
 import { __name } from './chunk-SHUYVCID.js';
 import { LogLevelLabel } from '@storm-software/config-tools/types';
-import { relativeToWorkspaceRoot, getWorkspaceRoot } from '@stryke/fs/get-workspace-root';
-import { tsconfigPathsToRegExp } from 'bundle-require';
-import { transformAsync } from '@babel/core';
-import { formatLogMessage } from '@storm-software/config-tools/logger/console';
 import { toArray } from '@stryke/convert/to-array';
-import { copyFiles } from '@stryke/fs/copy-file';
-import { existsSync } from '@stryke/fs/exists';
-import { createDirectory } from '@stryke/fs/helpers';
-import { install } from '@stryke/fs/install';
-import { listFiles } from '@stryke/fs/list-files';
-import { isPackageExists, isPackageListed, doesPackageMatch, getPackageListing } from '@stryke/fs/package-fns';
-import { resolvePackage } from '@stryke/fs/resolve';
-import { appendPath } from '@stryke/path/append';
-import { joinPaths as joinPaths$1 } from '@stryke/path/join-paths';
-import { replacePath } from '@stryke/path/replace';
-import { isError } from '@stryke/type-checks/is-error';
-import { isFunction } from '@stryke/type-checks/is-function';
-import { isNumber } from '@stryke/type-checks/is-number';
-import { isPromiseLike } from '@stryke/type-checks/is-promise';
-import { isSet } from '@stryke/type-checks/is-set';
-import { isSetObject } from '@stryke/type-checks/is-set-object';
-import { isSetString } from '@stryke/type-checks/is-set-string';
-import chalk4 from 'chalk';
-import defu2, { defu } from 'defu';
-import Handlebars from 'handlebars';
-import { declare } from '@babel/helper-plugin-utils';
-import * as t from '@babel/types';
-import { titleCase } from '@stryke/string-format/title-case';
 import { getEnvPaths } from '@stryke/env/get-env-paths';
+import { existsSync } from '@stryke/fs/exists';
+import { relativeToWorkspaceRoot } from '@stryke/fs/get-workspace-root';
 import { readJsonFile } from '@stryke/fs/json';
+import { resolvePackage } from '@stryke/fs/resolve';
 import { murmurhash } from '@stryke/hash/murmurhash';
 import { getUnique } from '@stryke/helpers/get-unique';
 import { omit } from '@stryke/helpers/omit';
 import { StormJSON } from '@stryke/json/storm-json';
-import { findFileDotExtensionSafe, findFilePath, hasFileExtension, relativePath, findFileName } from '@stryke/path/file-path-fns';
+import { appendPath } from '@stryke/path/append';
 import { isAbsolutePath, isAbsolute } from '@stryke/path/is-type';
 import { joinPaths } from '@stryke/path/join';
+import { replacePath } from '@stryke/path/replace';
+import { titleCase } from '@stryke/string-format/title-case';
 import { isNull } from '@stryke/type-checks/is-null';
+import { isSetObject } from '@stryke/type-checks/is-set-object';
+import { isSetString } from '@stryke/type-checks/is-set-string';
 import { isString } from '@stryke/type-checks/is-string';
 import { uuid } from '@stryke/unique-id/uuid';
-import { parseAsync } from 'oxc-parser';
+import defu2 from 'defu';
+import { joinPaths as joinPaths$1 } from '@stryke/path/join-paths';
+import { createJiti } from 'jiti';
+import { isFunction } from '@stryke/type-checks/is-function';
+import { isUndefined } from '@stryke/type-checks/is-undefined';
 import * as $ from '@stryke/capnp';
 import { bufferToString } from '@stryke/convert/buffer-to-string';
 import { readFileBuffer, readFileBufferSync, writeFileBuffer } from '@stryke/fs/buffer';
+import { findFileDotExtensionSafe, findFilePath } from '@stryke/path/file-path-fns';
 import { prettyBytes } from '@stryke/string-format/pretty-bytes';
 import { isBuffer } from '@stryke/type-checks/is-buffer';
 import { Blob } from 'node:buffer';
-import fs from 'node:fs';
+import _fs from 'node:fs';
 import { resolveConfig, format } from 'prettier';
-import { isUndefined } from '@stryke/type-checks/is-undefined';
 import { isParentPath } from '@stryke/path/is-parent-path';
 import { Volume } from 'memfs/lib/node/volume';
 import { Union } from 'unionfs';
-import { createJiti } from 'jiti';
-import { isObject } from '@stryke/type-checks/is-object';
-import ts, { createProgram, createCompilerHost, getPreEmitDiagnostics, getLineAndCharacterOfPosition, flattenDiagnosticMessageText } from 'typescript';
-import { getPackageName, hasPackageVersion, getPackageVersion } from '@stryke/string-format/package';
-import { getObjectDiff } from '@donedeal0/superdiff';
-import { loadTsConfig } from '@stryke/fs/tsconfig';
 
-function resolveModulePath(nodePath, state) {
-  if (!t.isStringLiteral(nodePath.node)) {
-    return;
-  }
-  const sourcePath = nodePath.node.value;
-  const resolvedPath = state.context?.fs.resolve(sourcePath);
-  if (resolvedPath) {
-    nodePath.replaceWith(t.stringLiteral(
-      // Remove the file extension if it exists
-      resolvedPath.replace(/\.(?:ts|mts|cts)x?$/, "")
-    ));
-  }
+function resolveOptions(options) {
+  return defu2(options, {
+    interopDefault: true,
+    fsCache: options.mode !== "development" ? joinPaths$1(options.cacheDir, "jiti") : false,
+    moduleCache: options.mode !== "development"
+  });
+}
+__name(resolveOptions, "resolveOptions");
+function createPluginResolver(options) {
+  return createJiti(joinPaths$1(options.workspaceRoot, options.projectRoot), resolveOptions({
+    ...options
+  }));
+}
+__name(createPluginResolver, "createPluginResolver");
+function createResolver(options) {
+  const baseResolver = createJiti(joinPaths$1(options.workspaceRoot, options.projectRoot), resolveOptions(options));
+  baseResolver.plugin = createPluginResolver(options);
+  return baseResolver;
 }
-__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"
+__name(createResolver, "createResolver");
+
+// src/types/commands.ts
+var SUPPORTED_COMMANDS = [
+  "new",
+  "clean",
+  "prepare",
+  "lint",
+  "test",
+  "build",
+  "docs",
+  "deploy",
+  "finalize"
 ];
-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;
+
+// src/plugin-utils/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(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");
-var DEFAULT_ENVIRONMENT = "default";
-function createEnvironment(name, userConfig) {
-  return defu2(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(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(createEnvironment, "createEnvironment");
-function createDefaultEnvironment(userConfig) {
-  return createEnvironment(DEFAULT_ENVIRONMENT, userConfig);
+__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, plugins) {
+  return plugin.dedupe === false || plugins.some((p) => p.dedupe !== false && (isFunction(p.dedupe) && p.dedupe(plugin) || p.name === plugin.name));
+}
+__name(checkDedupe, "checkDedupe");
+function addPluginHook(context, plugin, pluginHook, hooksList) {
+  if (!checkDedupe(plugin, hooksList.map((hook) => hook.plugin))) {
+    hooksList.push(isFunction(pluginHook) ? {
+      plugin,
+      handler: getHookHandler(pluginHook).bind(context)
+    } : {
+      plugin,
+      ...pluginHook,
+      handler: getHookHandler(pluginHook).bind(context)
+    });
+  }
 }
-__name(createDefaultEnvironment, "createDefaultEnvironment");
+__name(addPluginHook, "addPluginHook");
 BigInt("0xa56c61324b9d6e49");
 var FileMetadata_KeyValuePair = class extends $.Struct {
   static {
@@ -249,12 +164,12 @@ var FileMetadata = class _FileMetadata extends $.Struct {
   static _capnp = {
     displayName: "FileMetadata",
     id: "8e2cab5d7e28c7b3",
-    size: new $.ObjectSize(0, 4),
-    defaultVariant: "normal"
+    size: new $.ObjectSize(8, 4),
+    defaultType: "normal"
   };
   static _Properties;
   /**
-  * The variant of the file.
+  * The type of the file.
   *
   */
   get id() {
@@ -267,14 +182,14 @@ var FileMetadata = class _FileMetadata extends $.Struct {
   * The output mode of the file.
   *
   */
-  get variant() {
-    return $.utils.getText(1, this, _FileMetadata._capnp.defaultVariant);
+  get type() {
+    return $.utils.getText(1, this, _FileMetadata._capnp.defaultType);
   }
-  set variant(value) {
+  set type(value) {
     $.utils.setText(1, value, this);
   }
   /**
-  * Additional metadata associated with the file.
+  * The timestamp representing the file's creation date.
   *
   */
   get mode() {
@@ -283,6 +198,16 @@ var FileMetadata = class _FileMetadata extends $.Struct {
   set mode(value) {
     $.utils.setText(2, value, this);
   }
+  /**
+  * Additional metadata associated with the file.
+  *
+  */
+  get timestamp() {
+    return $.utils.getUint32(0, this);
+  }
+  set timestamp(value) {
+    $.utils.setUint32(0, value, this);
+  }
   _adoptProperties(value) {
     $.utils.adopt(value, $.utils.getPointer(3, this));
   }
@@ -305,33 +230,214 @@ var FileMetadata = class _FileMetadata extends $.Struct {
     return "FileMetadata_" + super.toString();
   }
 };
-var FileIdentifier = class extends $.Struct {
+var ChunkData = class extends $.Struct {
   static {
-    __name(this, "FileIdentifier");
+    __name(this, "ChunkData");
   }
   static _capnp = {
-    displayName: "FileIdentifier",
-    id: "e12b8732389d7406",
-    size: new $.ObjectSize(0, 2)
+    displayName: "ChunkData",
+    id: "84076f13b057f83a",
+    size: new $.ObjectSize(8, 4)
   };
   /**
-  * An additional identifier for the file.
+  * An additional name for the file.
   *
   */
-  get path() {
+  get id() {
     return $.utils.getText(0, this);
   }
-  set path(value) {
+  set id(value) {
+    $.utils.setText(0, value, this);
+  }
+  /**
+  * Files that are implicitly loaded after one of the specified files.
+  *
+  */
+  get name() {
+    return $.utils.getText(1, this);
+  }
+  set name(value) {
+    $.utils.setText(1, value, this);
+  }
+  _adoptImplicitlyLoadedAfterOneOf(value) {
+    $.utils.adopt(value, $.utils.getPointer(2, this));
+  }
+  _disownImplicitlyLoadedAfterOneOf() {
+    return $.utils.disown(this.implicitlyLoadedAfterOneOf);
+  }
+  /**
+  * The importer of the file.
+  *
+  */
+  get implicitlyLoadedAfterOneOf() {
+    return $.utils.getList(2, $.TextList, this);
+  }
+  _hasImplicitlyLoadedAfterOneOf() {
+    return !$.utils.isNull($.utils.getPointer(2, this));
+  }
+  _initImplicitlyLoadedAfterOneOf(length) {
+    return $.utils.initList(2, $.TextList, length, this);
+  }
+  set implicitlyLoadedAfterOneOf(value) {
+    $.utils.copyFrom(value, $.utils.getPointer(2, this));
+  }
+  /**
+  * The signature preservation mode for the file.
+  *
+  */
+  get importer() {
+    return $.utils.getText(3, this);
+  }
+  set importer(value) {
+    $.utils.setText(3, value, this);
+  }
+  get preserveSignature() {
+    return $.utils.getUint16(0, this);
+  }
+  set preserveSignature(value) {
+    $.utils.setUint16(0, value, this);
+  }
+  toString() {
+    return "ChunkData_" + super.toString();
+  }
+};
+var PrebuiltData = class extends $.Struct {
+  static {
+    __name(this, "PrebuiltData");
+  }
+  static _capnp = {
+    displayName: "PrebuiltData",
+    id: "c5b1a6ca696328ee",
+    size: new $.ObjectSize(0, 4)
+  };
+  /**
+  * An additional name for the file.
+  *
+  */
+  get id() {
+    return $.utils.getText(0, this);
+  }
+  set id(value) {
     $.utils.setText(0, value, this);
   }
+  /**
+  * The file exports.
+  *
+  */
+  get name() {
+    return $.utils.getText(1, this);
+  }
+  set name(value) {
+    $.utils.setText(1, value, this);
+  }
+  _adoptExports(value) {
+    $.utils.adopt(value, $.utils.getPointer(2, this));
+  }
+  _disownExports() {
+    return $.utils.disown(this.exports);
+  }
+  /**
+  * The source map for the file.
+  *
+  */
+  get exports() {
+    return $.utils.getList(2, $.TextList, this);
+  }
+  _hasExports() {
+    return !$.utils.isNull($.utils.getPointer(2, this));
+  }
+  _initExports(length) {
+    return $.utils.initList(2, $.TextList, length, this);
+  }
+  set exports(value) {
+    $.utils.copyFrom(value, $.utils.getPointer(2, this));
+  }
+  get map() {
+    return $.utils.getText(3, this);
+  }
+  set map(value) {
+    $.utils.setText(3, value, this);
+  }
+  toString() {
+    return "PrebuiltData_" + super.toString();
+  }
+};
+var AssetData = class extends $.Struct {
+  static {
+    __name(this, "AssetData");
+  }
+  static _capnp = {
+    displayName: "AssetData",
+    id: "da660c6c1fa4c830",
+    size: new $.ObjectSize(8, 3)
+  };
+  /**
+  * An additional name for the file.
+  *
+  */
   get id() {
+    return $.utils.getText(0, this);
+  }
+  set id(value) {
+    $.utils.setText(0, value, this);
+  }
+  /**
+  * Indicates whether the file needs a code reference.
+  *
+  */
+  get name() {
     return $.utils.getText(1, this);
   }
+  set name(value) {
+    $.utils.setText(1, value, this);
+  }
+  /**
+  * The original file name before any transformations.
+  *
+  */
+  get needsCodeReference() {
+    return $.utils.getBit(0, this);
+  }
+  set needsCodeReference(value) {
+    $.utils.setBit(0, value, this);
+  }
+  get originalFileName() {
+    return $.utils.getText(2, this);
+  }
+  set originalFileName(value) {
+    $.utils.setText(2, value, this);
+  }
+  toString() {
+    return "AssetData_" + super.toString();
+  }
+};
+var FileId = class extends $.Struct {
+  static {
+    __name(this, "FileId");
+  }
+  static _capnp = {
+    displayName: "FileId",
+    id: "990d6a471072f997",
+    size: new $.ObjectSize(0, 2)
+  };
+  /**
+  * A virtual (or actual) path to the file in the file system.
+  *
+  */
+  get id() {
+    return $.utils.getText(0, this);
+  }
   set id(value) {
+    $.utils.setText(0, value, this);
+  }
+  get path() {
+    return $.utils.getText(1, this);
+  }
+  set path(value) {
     $.utils.setText(1, value, this);
   }
   toString() {
-    return "FileIdentifier_" + super.toString();
+    return "FileId_" + super.toString();
   }
 };
 var FileData = class extends $.Struct {
@@ -344,7 +450,7 @@ var FileData = class extends $.Struct {
     size: new $.ObjectSize(0, 2)
   };
   /**
-  * The contents of the file.
+  * A virtual (or actual) path to the file in the file system.
   *
   */
   get path() {
@@ -353,28 +459,31 @@ var FileData = class extends $.Struct {
   set path(value) {
     $.utils.setText(0, value, this);
   }
-  get content() {
+  get code() {
     return $.utils.getText(1, this);
   }
-  set content(value) {
+  set code(value) {
     $.utils.setText(1, value, this);
   }
   toString() {
     return "FileData_" + super.toString();
   }
 };
-var FileSystemData = class _FileSystemData extends $.Struct {
+var FileSystem = class _FileSystem extends $.Struct {
   static {
-    __name(this, "FileSystemData");
+    __name(this, "FileSystem");
   }
   static _capnp = {
-    displayName: "FileSystemData",
-    id: "aaa72a672ac0732f",
-    size: new $.ObjectSize(0, 3)
+    displayName: "FileSystem",
+    id: "ae0c23d43e56abcf",
+    size: new $.ObjectSize(0, 6)
   };
   static _Ids;
-  static _Metadata;
   static _Files;
+  static _Metadata;
+  static _Assets;
+  static _Chunks;
+  static _Prebuilt;
   _adoptIds(value) {
     $.utils.adopt(value, $.utils.getPointer(0, this));
   }
@@ -382,63 +491,120 @@ var FileSystemData = class _FileSystemData extends $.Struct {
     return $.utils.disown(this.ids);
   }
   get ids() {
-    return $.utils.getList(0, _FileSystemData._Ids, this);
+    return $.utils.getList(0, _FileSystem._Ids, this);
   }
   _hasIds() {
     return !$.utils.isNull($.utils.getPointer(0, this));
   }
   _initIds(length) {
-    return $.utils.initList(0, _FileSystemData._Ids, length, this);
+    return $.utils.initList(0, _FileSystem._Ids, length, this);
   }
   set ids(value) {
     $.utils.copyFrom(value, $.utils.getPointer(0, this));
   }
-  _adoptMetadata(value) {
+  _adoptFiles(value) {
     $.utils.adopt(value, $.utils.getPointer(1, this));
   }
-  _disownMetadata() {
-    return $.utils.disown(this.metadata);
+  _disownFiles() {
+    return $.utils.disown(this.files);
   }
-  get metadata() {
-    return $.utils.getList(1, _FileSystemData._Metadata, this);
+  get files() {
+    return $.utils.getList(1, _FileSystem._Files, this);
   }
-  _hasMetadata() {
+  _hasFiles() {
     return !$.utils.isNull($.utils.getPointer(1, this));
   }
-  _initMetadata(length) {
-    return $.utils.initList(1, _FileSystemData._Metadata, length, this);
+  _initFiles(length) {
+    return $.utils.initList(1, _FileSystem._Files, length, this);
   }
-  set metadata(value) {
+  set files(value) {
     $.utils.copyFrom(value, $.utils.getPointer(1, this));
   }
-  _adoptFiles(value) {
+  _adoptMetadata(value) {
     $.utils.adopt(value, $.utils.getPointer(2, this));
   }
-  _disownFiles() {
-    return $.utils.disown(this.files);
+  _disownMetadata() {
+    return $.utils.disown(this.metadata);
   }
-  get files() {
-    return $.utils.getList(2, _FileSystemData._Files, this);
+  get metadata() {
+    return $.utils.getList(2, _FileSystem._Metadata, this);
   }
-  _hasFiles() {
+  _hasMetadata() {
     return !$.utils.isNull($.utils.getPointer(2, this));
   }
-  _initFiles(length) {
-    return $.utils.initList(2, _FileSystemData._Files, length, this);
+  _initMetadata(length) {
+    return $.utils.initList(2, _FileSystem._Metadata, length, this);
   }
-  set files(value) {
+  set metadata(value) {
     $.utils.copyFrom(value, $.utils.getPointer(2, this));
   }
+  _adoptAssets(value) {
+    $.utils.adopt(value, $.utils.getPointer(3, this));
+  }
+  _disownAssets() {
+    return $.utils.disown(this.assets);
+  }
+  get assets() {
+    return $.utils.getList(3, _FileSystem._Assets, this);
+  }
+  _hasAssets() {
+    return !$.utils.isNull($.utils.getPointer(3, this));
+  }
+  _initAssets(length) {
+    return $.utils.initList(3, _FileSystem._Assets, length, this);
+  }
+  set assets(value) {
+    $.utils.copyFrom(value, $.utils.getPointer(3, this));
+  }
+  _adoptChunks(value) {
+    $.utils.adopt(value, $.utils.getPointer(4, this));
+  }
+  _disownChunks() {
+    return $.utils.disown(this.chunks);
+  }
+  get chunks() {
+    return $.utils.getList(4, _FileSystem._Chunks, this);
+  }
+  _hasChunks() {
+    return !$.utils.isNull($.utils.getPointer(4, this));
+  }
+  _initChunks(length) {
+    return $.utils.initList(4, _FileSystem._Chunks, length, this);
+  }
+  set chunks(value) {
+    $.utils.copyFrom(value, $.utils.getPointer(4, this));
+  }
+  _adoptPrebuilt(value) {
+    $.utils.adopt(value, $.utils.getPointer(5, this));
+  }
+  _disownPrebuilt() {
+    return $.utils.disown(this.prebuilt);
+  }
+  get prebuilt() {
+    return $.utils.getList(5, _FileSystem._Prebuilt, this);
+  }
+  _hasPrebuilt() {
+    return !$.utils.isNull($.utils.getPointer(5, this));
+  }
+  _initPrebuilt(length) {
+    return $.utils.initList(5, _FileSystem._Prebuilt, length, this);
+  }
+  set prebuilt(value) {
+    $.utils.copyFrom(value, $.utils.getPointer(5, this));
+  }
   toString() {
-    return "FileSystemData_" + super.toString();
+    return "FileSystem_" + super.toString();
   }
 };
 FileMetadata._Properties = $.CompositeList(FileMetadata_KeyValuePair);
-FileSystemData._Ids = $.CompositeList(FileIdentifier);
-FileSystemData._Metadata = $.CompositeList(FileMetadata);
-FileSystemData._Files = $.CompositeList(FileData);
+FileSystem._Ids = $.CompositeList(FileId);
+FileSystem._Files = $.CompositeList(FileData);
+FileSystem._Metadata = $.CompositeList(FileMetadata);
+FileSystem._Assets = $.CompositeList(AssetData);
+FileSystem._Chunks = $.CompositeList(ChunkData);
+FileSystem._Prebuilt = $.CompositeList(PrebuiltData);
 
-// src/types/vfs.ts
+// src/types/fs.ts
 var __VFS_PATCH__ = "__VFS_PATCH__";
 var __VFS_REVERT__ = "__VFS_REVERT__";
 function isBufferEncoding(options) {
@@ -453,10 +619,10 @@ function isNodeWriteFileOptions(options) {
   return !isUndefined(options) && (isBufferEncoding(options) || !isPowerlinesWriteFileOptions(options));
 }
 __name(isNodeWriteFileOptions, "isNodeWriteFileOptions");
-function isPowerLinesWriteFileData(data) {
-  return !!(isSetObject(data) && "code" in data && data.code);
+function isVirtualFileData(obj) {
+  return !!(isSetObject(obj) && "code" in obj && obj.code);
 }
-__name(isPowerLinesWriteFileData, "isPowerLinesWriteFileData");
+__name(isVirtualFileData, "isVirtualFileData");
 var FILE_PREFIX = "file://";
 function toFilePath(pathOrUrl) {
   if (!pathOrUrl) {
@@ -600,13 +766,13 @@ var UnifiedFS = class _UnifiedFS extends Union {
   /**
   * The physical file system.
   */
-  #physicalFS = cloneFS(fs);
+  #physicalFS = cloneFS(_fs);
   /**
   * The context of the unified file system.
   */
   #context;
-  static create(context, data) {
-    let result = new _UnifiedFS(context, data);
+  static create(context, fs2) {
+    let result = new _UnifiedFS(context, fs2);
     result = result.use(result.#physicalFS);
     if (result.#context.config.output.mode !== "fs") {
       result = result.use(result.#virtualFS);
@@ -629,9 +795,9 @@ var UnifiedFS = class _UnifiedFS extends Union {
   * Creates a new instance of the VirtualFileSystem.
   *
   * @param context - The context of the virtual file system, typically containing options and logging functions.
-  * @param data - A buffer containing the serialized virtual file system data.
+  * @param fs - A buffer containing the serialized virtual file system data.
   */
-  constructor(context, data) {
+  constructor(context, fs2) {
     super();
     this.#context = context;
     if (!this.#physicalFS.existsSync(this.#context.dataPath)) {
@@ -650,8 +816,8 @@ var UnifiedFS = class _UnifiedFS extends Union {
       });
     }
     if (this.#context.config.output.mode !== "fs") {
-      this.#virtualFS = Volume.fromJSON(data._hasFiles() && data.files.length > 0 ? data.files.values().reduce((ret, file) => {
-        ret[file.path] = file.content;
+      this.#virtualFS = Volume.fromJSON(fs2._hasFiles() && fs2.files.length > 0 ? fs2.files.values().reduce((ret, file) => {
+        ret[file.path] = file.code;
         return ret;
       }, {}) : {});
       if (!this.#virtualFS.existsSync(this.#context.artifactsPath)) {
@@ -996,10 +1162,10 @@ var VirtualFileSystem = class _VirtualFileSystem {
     if (!context.config.skipCache && existsSync(joinPaths$1(context.cachePath, "fs.bin"))) {
       const buffer = await readFileBuffer(joinPaths$1(context.cachePath, "fs.bin"));
       const message2 = new $.Message(buffer, false);
-      return new _VirtualFileSystem(context, message2.getRoot(FileSystemData));
+      return new _VirtualFileSystem(context, message2.getRoot(FileSystem));
     }
     const message = new $.Message();
-    return new _VirtualFileSystem(context, message.initRoot(FileSystemData));
+    return new _VirtualFileSystem(context, message.initRoot(FileSystem));
   }
   /**
   * Synchronously creates a virtual file system (VFS) that is backed up to a Cap'n Proto message buffer.
@@ -1011,10 +1177,10 @@ var VirtualFileSystem = class _VirtualFileSystem {
     if (!context.config.skipCache && existsSync(joinPaths$1(context.cachePath, "fs.bin"))) {
       const buffer = readFileBufferSync(joinPaths$1(context.cachePath, "fs.bin"));
       const message2 = new $.Message(buffer, false);
-      return new _VirtualFileSystem(context, message2.getRoot(FileSystemData));
+      return new _VirtualFileSystem(context, message2.getRoot(FileSystem));
     }
     const message = new $.Message();
-    return new _VirtualFileSystem(context, message.initRoot(FileSystemData));
+    return new _VirtualFileSystem(context, message.initRoot(FileSystem));
   }
   /**
   * A map of file ids to their metadata.
@@ -1038,19 +1204,20 @@ var VirtualFileSystem = class _VirtualFileSystem {
   * Creates a new instance of the {@link VirtualFileSystem}.
   *
   * @param context - The context of the virtual file system, typically containing options and logging functions.
-  * @param data - A buffer containing the serialized virtual file system data.
+  * @param fs - A buffer containing the serialized virtual file system data.
   */
-  constructor(context, data) {
+  constructor(context, fs2) {
     this.#context = context;
-    this.#unifiedFS = UnifiedFS.create(context, data);
+    this.#unifiedFS = UnifiedFS.create(context, fs2);
     this.#metadata = {};
-    if (data._hasMetadata()) {
-      this.#metadata = data.metadata.values().reduce((ret, data2) => {
-        ret[data2.id] = {
-          id: data2.id,
-          variant: data2.variant,
-          mode: data2.mode,
-          properties: data2._hasProperties() ? data2.properties.values().reduce((ret2, item) => {
+    if (fs2._hasMetadata()) {
+      this.#metadata = fs2.metadata.values().reduce((ret, metadata) => {
+        ret[metadata.id] = {
+          id: metadata.id,
+          type: metadata.type,
+          mode: metadata.mode,
+          timestamp: metadata.timestamp || Date.now(),
+          properties: metadata._hasProperties() ? metadata.properties.values().reduce((ret2, item) => {
             ret2[item.key] = item.value;
             return ret2;
           }, {}) : {}
@@ -1060,14 +1227,13 @@ var VirtualFileSystem = class _VirtualFileSystem {
     }
     this.#ids = {};
     this.#paths = {};
-    if (data._hasIds()) {
-      this.#ids = data.ids.values().reduce((ret, data2) => {
-        ret[data2.id] ??= data2.path;
-        ret[data2.path] ??= data2.path;
+    if (fs2._hasIds()) {
+      this.#ids = fs2.ids.values().reduce((ret, identifier) => {
+        ret[identifier.path] ??= identifier.id;
         return ret;
       }, {});
-      this.#paths = data.ids.values().reduce((ret, data2) => {
-        ret[data2.path] ??= data2.id;
+      this.#paths = fs2.ids.values().reduce((ret, identifier) => {
+        ret[identifier.id] ??= identifier.path;
         return ret;
       }, {});
     }
@@ -1086,7 +1252,7 @@ var VirtualFileSystem = class _VirtualFileSystem {
     }
     const resolvedPath = this.resolve(pathOrId, {
       ...options,
-      type: "file"
+      pathType: "file"
     });
     if (!resolvedPath) {
       return false;
@@ -1106,7 +1272,7 @@ var VirtualFileSystem = class _VirtualFileSystem {
     }
     const resolvedPath = this.resolve(pathOrId, {
       ...options,
-      type: "file"
+      pathType: "file"
     });
     if (!resolvedPath) {
       return false;
@@ -1279,7 +1445,7 @@ var VirtualFileSystem = class _VirtualFileSystem {
       const normalized = this.formatPath(pattern);
       if (!/[*?[\]{}]/.test(normalized) && !normalized.includes("**")) {
         const resolved = this.resolve(normalized, {
-          type: "file"
+          pathType: "file"
         });
         if (resolved && !results.includes(resolved)) {
           results.push(resolved);
@@ -1314,7 +1480,7 @@ var VirtualFileSystem = class _VirtualFileSystem {
           } else if (stats.isFile()) {
             if (this.#buildRegex(absPattern).test(full)) {
               const resolved = this.resolve(full, {
-                type: "file"
+                pathType: "file"
               });
               if (resolved && !results.includes(resolved)) {
                 results.push(resolved);
@@ -1338,7 +1504,7 @@ var VirtualFileSystem = class _VirtualFileSystem {
       const normalized = this.formatPath(pattern);
       if (!/[*?[\]{}]/.test(normalized) && !normalized.includes("**")) {
         const resolved = this.resolve(normalized, {
-          type: "file"
+          pathType: "file"
         });
         if (resolved && !results.includes(resolved)) {
           results.push(resolved);
@@ -1373,7 +1539,7 @@ var VirtualFileSystem = class _VirtualFileSystem {
           } else if (stats.isFile()) {
             if (this.#buildRegex(absPattern).test(full)) {
               const resolved = this.resolve(full, {
-                type: "file"
+                pathType: "file"
               });
               if (resolved && !results.includes(resolved)) {
                 results.push(resolved);
@@ -1448,7 +1614,7 @@ var VirtualFileSystem = class _VirtualFileSystem {
       return void 0;
     }
     const filePath = this.resolve(toFilePath(pathOrId), {
-      type: "file"
+      pathType: "file"
     });
     if (filePath) {
       let result;
@@ -1473,7 +1639,7 @@ var VirtualFileSystem = class _VirtualFileSystem {
       return void 0;
     }
     const filePath = this.resolve(toFilePath(pathOrId), {
-      type: "file"
+      pathType: "file"
     });
     if (filePath) {
       const result = this.#unifiedFS.resolveFS(filePath).readFileSync(filePath, options);
@@ -1495,7 +1661,7 @@ var VirtualFileSystem = class _VirtualFileSystem {
     if (!this.isDirectory(findFilePath(formattedPath))) {
       await this.mkdir(findFilePath(formattedPath), isPowerlinesWriteFileOptions(options) ? options : void 0);
     }
-    let code = isPowerLinesWriteFileData(data) ? data.code : data;
+    let code = isVirtualFileData(data) ? data.code : data;
     if ((!isPowerlinesWriteFileOptions(options) || !options.skipFormat) && isSetString(code)) {
       const resolvedConfig = await resolveConfig(formattedPath);
       if (resolvedConfig) {
@@ -1510,7 +1676,8 @@ var VirtualFileSystem = class _VirtualFileSystem {
     this.metadata[formattedPath] = {
       mode: outputMode,
       variant: "normal",
-      ...isPowerLinesWriteFileData(data) ? data : {}
+      timestamp: Date.now(),
+      ...isVirtualFileData(data) ? data : {}
     };
     this.#clearResolverCache(formattedPath);
     const ifs = this.#unifiedFS.resolveFS(formattedPath, isPowerlinesWriteFileOptions(options) ? options : void 0);
@@ -1531,13 +1698,14 @@ var VirtualFileSystem = class _VirtualFileSystem {
     if (!this.isDirectory(findFilePath(formattedPath))) {
       this.mkdirSync(findFilePath(formattedPath), isPowerlinesWriteFileOptions(options) ? options : void 0);
     }
-    const code = isPowerLinesWriteFileData(data) ? data.code : data;
+    const code = isVirtualFileData(data) ? data.code : data;
     const outputMode = this.#unifiedFS.resolveMode(formattedPath, isPowerlinesWriteFileOptions(options) ? options : void 0);
     this.#log(LogLevelLabel.TRACE, `Writing ${formattedPath} file to the ${outputMode === "fs" ? "" : "virtual "}file system (size: ${prettyBytes(new Blob(toArray(code)).size)})`);
     this.metadata[formattedPath] = {
       mode: outputMode,
       variant: "normal",
-      ...isPowerLinesWriteFileData(data) ? data : {}
+      timestamp: Date.now(),
+      ...isVirtualFileData(data) ? data : {}
     };
     this.#clearResolverCache(formattedPath);
     const writeStream = this.#unifiedFS.resolveFS(formattedPath, isPowerlinesWriteFileOptions(options) ? options : void 0).createWriteStream(formattedPath);
@@ -1650,7 +1818,7 @@ var VirtualFileSystem = class _VirtualFileSystem {
   */
   resolve(pathOrId, options = {}) {
     const formattedPathOrId = toFilePath(pathOrId);
-    const resolverKey = `${formattedPathOrId}${options.withExtension ? "-ext" : ""}${options.paths ? `-${murmurhash(options.paths)}` : ""}${options.type ? `-${options.type}` : ""}`;
+    const resolverKey = `${formattedPathOrId}${options.withExtension ? "-ext" : ""}${options.paths ? `-${murmurhash(options.paths)}` : ""}${options.pathType ? `-${options.pathType}` : ""}`;
     if (this.#cachedResolver.has(resolverKey)) {
       return this.#cachedResolver.get(resolverKey);
     }
@@ -1691,26 +1859,28 @@ var VirtualFileSystem = class _VirtualFileSystem {
       this.#log(LogLevelLabel.DEBUG, "Disposing virtual file system...");
       await this.unlink(joinPaths$1(this.#context.cachePath, "fs.bin"));
       const message = new $.Message();
-      const data = message.initRoot(FileSystemData);
+      const fs2 = message.initRoot(FileSystem);
       const virtualFS = this.#unifiedFS.toJSON();
-      const files = data._initFiles(Object.keys(virtualFS).length);
-      Object.entries(virtualFS).filter(([_, content]) => content).forEach(([path, content], index) => {
-        const fileData = files.get(index);
-        fileData.path = path;
-        fileData.content = content;
+      const virtualFiles = Object.entries(virtualFS).filter(([_, code]) => code);
+      const files = fs2._initFiles(virtualFiles.length);
+      virtualFiles.forEach(([path, code], index) => {
+        const fd = files.get(index);
+        fd.path = path;
+        fd.code = code;
       });
-      const ids = data._initIds(Object.keys(this.ids).length);
+      const ids = fs2._initIds(Object.keys(this.ids).length);
       Object.entries(this.ids).forEach(([id, path], index) => {
         const fileId = ids.get(index);
         fileId.id = id;
         fileId.path = path;
       });
-      const metadata = data._initMetadata(Object.keys(this.metadata).length);
+      const metadata = fs2._initMetadata(Object.keys(this.metadata).length);
       Object.entries(this.metadata).forEach(([id, value], index) => {
         const fileMetadata = metadata.get(index);
         fileMetadata.id = id;
         fileMetadata.mode = value.mode;
-        fileMetadata.variant = value.variant;
+        fileMetadata.type = value.type;
+        fileMetadata.timestamp = value.timestamp ?? BigInt(Date.now());
         if (value.properties) {
           const props = fileMetadata._initProperties(Object.keys(value.properties).length);
           Object.entries(value.properties).forEach(([key, val], propIndex) => {
@@ -1728,7 +1898,7 @@ var VirtualFileSystem = class _VirtualFileSystem {
   */
   [__VFS_PATCH__]() {
     if (!this.#isPatched && this.#context.config.output.mode !== "fs") {
-      this.#revert = patchFS(fs, this);
+      this.#revert = patchFS(_fs, this);
       this.#isPatched = true;
     }
   }
@@ -1749,101 +1919,18 @@ var VirtualFileSystem = class _VirtualFileSystem {
   }
 };
 
-// src/types/commands.ts
-var SUPPORTED_COMMANDS = [
-  "new",
-  "clean",
-  "prepare",
-  "lint",
-  "test",
-  "build",
-  "docs",
-  "deploy",
-  "finalize"
-];
-
-// src/plugin-utils/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, plugins) {
-  return plugin.dedupe === false || plugins.some((p) => p.dedupe !== false && (isFunction(p.dedupe) && p.dedupe(plugin) || p.name === plugin.name));
-}
-__name(checkDedupe, "checkDedupe");
-function addPluginHook(context, plugin, pluginHook, hooksList) {
-  if (!checkDedupe(plugin, hooksList.map((hook) => hook.plugin))) {
-    hooksList.push(isFunction(pluginHook) ? {
-      plugin,
-      handler: getHookHandler(pluginHook).bind(context)
-    } : {
-      plugin,
-      ...pluginHook,
-      handler: getHookHandler(pluginHook).bind(context)
-    });
-  }
-}
-__name(addPluginHook, "addPluginHook");
-function resolveOptions(options) {
-  return defu2(options, {
-    interopDefault: true,
-    fsCache: options.mode !== "development" ? joinPaths$1(options.cacheDir, "jiti") : false,
-    moduleCache: options.mode !== "development"
-  });
-}
-__name(resolveOptions, "resolveOptions");
-function createPluginResolver(options) {
-  return createJiti(joinPaths$1(options.workspaceRoot, options.projectRoot), resolveOptions({
-    ...options
-  }));
-}
-__name(createPluginResolver, "createPluginResolver");
-function createResolver(options) {
-  const baseResolver = createJiti(joinPaths$1(options.workspaceRoot, options.projectRoot), resolveOptions(options));
-  baseResolver.plugin = createPluginResolver(options);
-  return baseResolver;
-}
-__name(createResolver, "createResolver");
-
-// src/internal/contexts/context.ts
+// src/lib/contexts/context.ts
 var configCache = /* @__PURE__ */ new WeakMap();
-var parseCache = /* @__PURE__ */ new WeakMap();
 var PowerlinesContext = class _PowerlinesContext {
   static {
     __name(this, "PowerlinesContext");
   }
+  /**
+  * Internal reference to the API instance
+  *
+  * @internal
+  */
+  #api;
   #workspaceConfig;
   #checksum = null;
   #buildId = uuid();
@@ -1923,6 +2010,16 @@ var PowerlinesContext = class _PowerlinesContext {
   */
   resolver;
   /**
+  * Internal context fields and methods
+  *
+  * @internal
+  */
+  get $$internal() {
+    return {
+      api: this.#api
+    };
+  }
+  /**
   * The resolved entry type definitions for the project
   */
   get entry() {
@@ -2065,13 +2162,13 @@ var PowerlinesContext = class _PowerlinesContext {
   * The builtin module id that exist in the Powerlines virtual file system
   */
   get builtins() {
-    return Object.values(this.fs.metadata).filter((meta) => meta && meta.variant === "builtin").map((meta) => meta?.id).filter(Boolean);
+    return Object.values(this.fs.metadata).filter((meta) => meta && meta.type === "builtin").map((meta) => meta?.id).filter(Boolean);
   }
   /**
   * Get the builtin virtual files that exist in the Powerlines virtual file system
   */
   async getBuiltins() {
-    return Promise.all(Object.entries(this.fs.metadata).filter(([, meta]) => meta && meta.variant === "builtin").map(async ([path, meta]) => {
+    return Promise.all(Object.entries(this.fs.metadata).filter(([, meta]) => meta && meta.type === "builtin").map(async ([path, meta]) => {
       const code = await this.fs.readFile(path);
       return {
         ...meta,
@@ -2087,10 +2184,10 @@ var PowerlinesContext = class _PowerlinesContext {
   * @param path - A path to write the entry file to
   * @param options - Optional write file options
   */
-  async writeEntry(code, path, options = {}) {
+  async emitEntry(code, path, options = {}) {
     return this.fs.writeFile(isAbsolute(path) ? path : appendPath(path, this.entryPath), {
       code,
-      variant: "entry"
+      type: "entry"
     }, defu2(options, {
       mode: this.config.output.mode
     }));
@@ -2103,51 +2200,16 @@ var PowerlinesContext = class _PowerlinesContext {
   * @param path - An optional path to write the builtin file to
   * @param options - Optional write file options
   */
-  async writeBuiltin(code, id, path, options = {}) {
+  async emitBuiltin(code, id, path, options = {}) {
     return this.fs.writeFile(path ? isAbsolute(path) ? path : joinPaths(this.builtinsPath, path) : appendPath(id, this.builtinsPath), {
       id,
       code,
-      variant: "builtin"
+      type: "builtin"
     }, defu2(options, {
       mode: this.config.output.mode
     }));
   }
   /**
-  * Parses the source code and returns a {@link ParseResult} object.
-  *
-  * @param code - The source code to parse.
-  * @param id - The unique identifier for the source file.
-  * @param options - Optional parser options.
-  * @returns The parsed {@link ParseResult} object.
-  */
-  async parse(code, id, options = {}) {
-    if (parseCache.has({
-      code,
-      options
-    })) {
-      return parseCache.get({
-        code,
-        options
-      });
-    }
-    const result = await parseAsync(id, code, defu2(options ?? {}, {
-      lang: hasFileExtension(id) ? void 0 : "ts",
-      astType: hasFileExtension(id) ? void 0 : "ts",
-      sourceType: "module",
-      showSemanticErrors: false
-    }));
-    if (result.errors && result.errors.length > 0) {
-      throw new Error(`Powerlines parsing errors in file: ${id}
-${result.errors.map((error) => `  [${error.severity}] ${error.message}${error.codeframe ? ` (${error.codeframe})` : ""}${error.helpMessage ? `
-    Help: ${error.helpMessage}` : ""}`).join("\n")}`);
-    }
-    parseCache.set({
-      code,
-      options
-    }, result);
-    return result;
-  }
-  /**
   * Update the context using a new user configuration options
   *
   * @param userConfig - The new user configuration options.
@@ -2335,7 +2397,7 @@ ${result.errors.map((error) => `  [${error.severity}] ${error.message}${error.co
         tsconfig: appendPath("tsconfig.json", cacheKey.projectRoot),
         sourceRoot: this.projectJson?.sourceRoot || appendPath("src", cacheKey.projectRoot),
         output: {
-          outputPath: joinPaths("dist", cacheKey.projectRoot),
+          outputPath: cacheKey.projectRoot ? joinPaths(this.workspaceConfig?.directories?.build || "dist", cacheKey.projectRoot) : this.workspaceConfig?.directories?.build || "dist",
           mode: "virtual",
           dts: joinPaths(cacheKey.projectRoot, `${config.framework ?? "powerlines"}.d.ts`),
           builtinPrefix: config.framework ?? "powerlines",
@@ -2441,1359 +2503,4 @@ ${result.errors.map((error) => `  [${error.severity}] ${error.message}${error.co
   }
 };
 
-// src/types/plugin.ts
-var PLUGIN_NON_HOOK_FIELDS = [
-  "name",
-  "enforce",
-  "dedupe",
-  "dependsOn",
-  "applyToEnvironment"
-];
-async function callHook(context, hook, options, ...args) {
-  const handlers = context.selectHooks(hook, options);
-  if (handlers.length > 0) {
-    context.log(LogLevelLabel.DEBUG, ` \u{1F9E9}  Calling plugin hook: ${chalk4.bold.cyanBright(`${hook}${options?.order ? ` (${options.order})` : ""}`)}`);
-    let results = [];
-    if (options?.sequential === false) {
-      results = await Promise.all(handlers.map(async (handler) => {
-        if (!isFunction(handler)) {
-          throw new Error(`Plugin hook handler for hook "${hook}" is not a function.`);
-        }
-        return Promise.resolve(handler.apply(null, ...args));
-      }));
-    } else {
-      for (const handler of handlers) {
-        if (!isFunction(handler)) {
-          throw new Error(`Plugin hook handler for hook "${hook}" is not a function.`);
-        }
-        results.push(await Promise.resolve(handler.apply(null, ...args)));
-        if (options?.result === "first" && isSet(results[results.length - 1])) {
-          break;
-        }
-      }
-    }
-    const definedResults = results.filter((result) => isSet(result));
-    if (definedResults.length > 0) {
-      let mergedResult = void 0;
-      for (const result of definedResults) {
-        mergedResult = defu(result, mergedResult ?? {});
-      }
-      return mergedResult;
-    }
-  }
-  return void 0;
-}
-__name(callHook, "callHook");
-
-// src/internal/contexts/plugin-context.ts
-function createPluginContext(plugin, environment) {
-  const normalizeMessage = /* @__PURE__ */ __name((message) => {
-    return isString(message) ? message : message.message;
-  }, "normalizeMessage");
-  const log = environment.extendLog(plugin.name);
-  const callHookFn = /* @__PURE__ */ __name(async (hook, options, ...args) => {
-    return callHook(environment, hook, {
-      sequential: true,
-      ...options
-    }, ...args);
-  }, "callHookFn");
-  return new Proxy({}, {
-    get(_, prop) {
-      if (prop === "$$internal") {
-        return {
-          environment,
-          callHook: callHookFn
-        };
-      }
-      if (prop === "log" || prop === "logger") {
-        return log;
-      }
-      if (prop === "error") {
-        return (message) => {
-          log(LogLevelLabel.ERROR, normalizeMessage(message));
-        };
-      }
-      if (prop === "warn") {
-        return (message) => {
-          log(LogLevelLabel.WARN, normalizeMessage(message));
-        };
-      }
-      return environment[prop];
-    },
-    set(_, prop, value) {
-      if ([
-        "$$internal",
-        "environment",
-        "config",
-        "log",
-        "logger",
-        "error",
-        "warn",
-        "plugins",
-        "hooks",
-        "addPlugin",
-        "selectHooks"
-      ].includes(prop)) {
-        log(LogLevelLabel.WARN, `Cannot set read-only property "${String(prop)}"`);
-        return false;
-      }
-      environment[prop] = value;
-      return true;
-    }
-  });
-}
-__name(createPluginContext, "createPluginContext");
-
-// src/internal/contexts/environment-context.ts
-var PowerlinesEnvironmentContext = class _PowerlinesEnvironmentContext extends PowerlinesContext {
-  static {
-    __name(this, "PowerlinesEnvironmentContext");
-  }
-  #hooks = {};
-  /**
-  * Create a new Storm context from the workspace root and user config.
-  *
-  * @param workspaceConfig - The root directory of the workspace.
-  * @param config - The user configuration options.
-  * @returns A promise that resolves to the new context.
-  */
-  static async fromConfig(workspaceConfig, config) {
-    const context = new _PowerlinesEnvironmentContext(config, workspaceConfig);
-    await context.init();
-    context.powerlinesPath = await resolvePackage("powerlines");
-    if (!context.powerlinesPath) {
-      throw new Error("Could not resolve `powerlines` package location.");
-    }
-    return context;
-  }
-  environment;
-  plugins = [];
-  /**
-  * The resolved configuration options
-  */
-  get config() {
-    return super.config;
-  }
-  get hooks() {
-    return this.#hooks;
-  }
-  async addPlugin(plugin) {
-    let resolvedPlugin = plugin;
-    if (plugin.applyToEnvironment) {
-      const result = await Promise.resolve(plugin.applyToEnvironment(this.environment));
-      if (!result || isObject(result) && Object.keys(result).length === 0) {
-        return;
-      }
-      resolvedPlugin = isPlugin(result) ? result : plugin;
-    }
-    const context = createPluginContext(resolvedPlugin, this);
-    this.plugins.push({
-      plugin: resolvedPlugin,
-      context
-    });
-    this.#hooks = Object.keys(resolvedPlugin).filter((key) => !PLUGIN_NON_HOOK_FIELDS.includes(key)).reduce((ret, key) => {
-      const hook = key;
-      const pluginHook = resolvedPlugin[hook];
-      if (!isPluginHook(pluginHook)) {
-        return ret;
-      }
-      if (!isHookExternal(hook)) {
-        ret[hook] ??= {};
-        if (resolvedPlugin.enforce) {
-          ret[hook][`${resolvedPlugin.enforce}Enforced`] ??= [];
-          addPluginHook(context, resolvedPlugin, pluginHook, ret[hook][`${resolvedPlugin.enforce}Enforced`]);
-          return ret;
-        }
-        if (isFunction(pluginHook) || !pluginHook.order) {
-          ret[hook].normal ??= [];
-          addPluginHook(context, resolvedPlugin, pluginHook, ret[hook].normal);
-          return ret;
-        }
-        ret[hook][`${pluginHook.order}Ordered`] ??= [];
-        addPluginHook(context, resolvedPlugin, pluginHook, ret[hook][`${pluginHook.order}Ordered`]);
-      } else {
-        ret[hook] ??= [];
-        ret[hook].push({
-          plugin: resolvedPlugin,
-          hook: getHookHandler(pluginHook).bind(context)
-        });
-      }
-      return ret;
-    }, this.hooks);
-  }
-  /**
-  * Retrieves the hook handlers for a specific hook name
-  */
-  selectHooks(hook, options) {
-    const handlers = [];
-    if (this.hooks[hook]) {
-      if (!isHookExternal(hook)) {
-        const hooks = this.hooks[hook];
-        if (options?.order) {
-          if (options?.order === "pre") {
-            handlers.push(...(hooks.preOrdered ?? []).map((h) => h.handler));
-            handlers.push(...(hooks.preEnforced ?? []).map((h) => h.handler));
-          } else if (options?.order === "post") {
-            handlers.push(...(hooks.postOrdered ?? []).map((h) => h.handler));
-            handlers.push(...(hooks.postEnforced ?? []).map((h) => h.handler));
-          } else {
-            handlers.push(...(hooks.normal ?? []).map((h) => h.handler));
-          }
-        } else {
-          handlers.push(...this.selectHooks(hook, {
-            order: "pre"
-          }));
-          handlers.push(...this.selectHooks(hook, {
-            order: "normal"
-          }));
-          handlers.push(...this.selectHooks(hook, {
-            order: "post"
-          }));
-        }
-      } else {
-        handlers.push(...this.hooks[hook].map((h) => h.handler));
-      }
-    }
-    return handlers;
-  }
-  constructor(config, workspaceConfig) {
-    super(workspaceConfig);
-    this.resolvedConfig = config;
-  }
-};
-
-// src/internal/contexts/api-context.ts
-var PowerlinesAPIContext = class _PowerlinesAPIContext extends PowerlinesContext {
-  static {
-    __name(this, "PowerlinesAPIContext");
-  }
-  #environments = {};
-  #plugins = [];
-  #log;
-  /**
-  * Create a new Storm context from the workspace root and user config.
-  *
-  * @param workspaceRoot - The root directory of the workspace.
-  * @param config - The user configuration options.
-  * @returns A promise that resolves to the new context.
-  */
-  static async from(workspaceRoot, config) {
-    const context = new _PowerlinesAPIContext(await loadWorkspaceConfig(workspaceRoot, config.root));
-    await context.withUserConfig(config);
-    context.powerlinesPath = await resolvePackage("powerlines");
-    if (!context.powerlinesPath) {
-      throw new Error("Could not resolve `powerlines` package location.");
-    }
-    return context;
-  }
-  /**
-  * A record of all environments by name
-  */
-  get environments() {
-    return this.#environments;
-  }
-  get log() {
-    if (!this.#log) {
-      this.#log = this.createLog("engine");
-    }
-    return this.#log;
-  }
-  get plugins() {
-    return this.#plugins;
-  }
-  constructor(workspaceConfig) {
-    super(workspaceConfig);
-  }
-  /**
-  * Initialize the context with the provided configuration options
-  *
-  * @param config - The partial user configuration to use for initialization.
-  */
-  async init(config = {}) {
-    await super.init(config);
-    await Promise.all(toArray(this.config.userConfig.environments && Object.keys(this.config.userConfig.environments).length > 0 ? Object.keys(this.config.userConfig.environments).map((name) => createEnvironment(name, this.config.userConfig)) : createDefaultEnvironment(this.config.userConfig)).map(async (env) => {
-      this.#environments[env.name] = await this.in(env);
-    }));
-  }
-  /**
-  * A function to copy the context and update the fields for a specific environment
-  *
-  * @param environment - The environment configuration to use.
-  * @returns A new context instance with the updated environment.
-  */
-  async in(environment) {
-    let context;
-    if (this.environments[environment.name]) {
-      context = this.environments[environment.name];
-    } else {
-      context = await PowerlinesEnvironmentContext.fromConfig(this.workspaceConfig, this.config);
-    }
-    if (isSetObject(this.config.inlineConfig)) {
-      await context.withInlineConfig(this.config.inlineConfig);
-    }
-    context.environment = environment;
-    context.plugins = [];
-    for (const plugin of this.plugins) {
-      await context.addPlugin(plugin);
-    }
-    return context;
-  }
-  async addPlugin(plugin) {
-    this.plugins.push(plugin);
-    await Promise.all(Object.keys(this.environments).map(async (name) => {
-      await this.environments[name].addPlugin(plugin);
-    }));
-  }
-  async getEnvironment(name) {
-    let environment;
-    if (name) {
-      environment = this.environments[name];
-    }
-    if (Object.keys(this.environments).length === 1) {
-      environment = this.environments[Object.keys(this.environments)[0]];
-      this.log(LogLevelLabel.DEBUG, `Applying the only configured environment: ${chalk4.bold.cyanBright(environment?.environment.name)}`);
-    }
-    if (!environment) {
-      if (name) {
-        throw new Error(`Environment "${name}" not found.`);
-      }
-      environment = await this.in(createDefaultEnvironment(this.config.userConfig));
-      this.log(LogLevelLabel.WARN, `No environment specified, and no default environment found. Using a temporary default environment: ${chalk4.bold.cyanBright(environment?.environment.name)}`);
-    }
-    return environment;
-  }
-  async getEnvironmentSafe(name) {
-    try {
-      return await this.getEnvironment(name);
-    } catch {
-      return void 0;
-    }
-  }
-};
-function formatTypes(code) {
-  return code.replace(
-    // eslint-disable-next-line regexp/no-super-linear-backtracking
-    /import\s*(?:type\s*)?\{?[\w,\s]*(?:\}\s*)?from\s*(?:'|")@?[a-zA-Z0-9-\\/.]*(?:'|");?/g,
-    ""
-  ).replaceAll("#private;", "").replace(/__Ω/g, "");
-}
-__name(formatTypes, "formatTypes");
-async function emitTypes(context, tsconfig, files) {
-  context.log(LogLevelLabel.TRACE, "Creating the TypeScript compiler host");
-  const program = createProgram(files, tsconfig.options, createCompilerHost(tsconfig.options));
-  context.log(LogLevelLabel.TRACE, `Running the TypeScript compiler for ${context.builtins.length} built-in runtime files.`);
-  let builtinModules = "";
-  const emitResult = program.emit(void 0, (fileName, text, _, __, sourceFiles, _data) => {
-    const sourceFile = sourceFiles?.[0];
-    if (sourceFile?.fileName && !fileName.endsWith(".map")) {
-      if (context.builtins.some((file) => file === sourceFile.fileName || context.fs.metadata[file]?.id && context.fs.metadata[file]?.id === sourceFile.fileName)) {
-        builtinModules += `
-declare module "${context.fs.resolve(sourceFile.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}`);
-  }
-  return formatTypes(builtinModules);
-}
-__name(emitTypes, "emitTypes");
-async function installPackage(context, packageName, dev = false) {
-  if (!await isPackageListed(getPackageName(packageName), {
-    cwd: context.config.projectRoot
-  })) {
-    if (context.config.skipInstalls !== true && !process.env.POWERLINES_LOCAL) {
-      context.log(LogLevelLabel.WARN, `The package "${packageName}" is not installed. It will be installed automatically.`);
-      const result = await install(packageName, {
-        cwd: context.config.projectRoot,
-        dev
-      });
-      if (isNumber(result.exitCode) && result.exitCode > 0) {
-        context.log(LogLevelLabel.ERROR, result.stderr);
-        throw new Error(`An error occurred while installing the package "${packageName}"`);
-      }
-    } else {
-      context.log(LogLevelLabel.WARN, `The package "${packageName}" is not installed. Since the "skipInstalls" option is set to true, it will not be installed automatically.`);
-    }
-  } else if (hasPackageVersion(packageName) && !process.env.POWERLINES_SKIP_VERSION_CHECK) {
-    const isMatching = await doesPackageMatch(getPackageName(packageName), getPackageVersion(packageName), context.config.projectRoot);
-    if (!isMatching) {
-      const packageListing = await getPackageListing(getPackageName(packageName), {
-        cwd: context.config.projectRoot
-      });
-      if (!packageListing?.version.startsWith("catalog:") && !packageListing?.version.startsWith("workspace:")) {
-        context.log(LogLevelLabel.WARN, `The package "${getPackageName(packageName)}" is installed but does not match the expected version ${getPackageVersion(packageName)} (installed version: ${packageListing?.version || "<Unknown>"}). Please ensure this is intentional before proceeding. Note: You can skip this validation with the "STORM_STACK_SKIP_VERSION_CHECK" environment variable.`);
-      }
-    }
-  }
-}
-__name(installPackage, "installPackage");
-
-// src/internal/helpers/install-dependencies.ts
-async function installDependencies(context) {
-  context.log(LogLevelLabel.TRACE, `Checking and installing missing project dependencies.`);
-  context.dependencies ??= {};
-  context.devDependencies ??= {};
-  if (Object.keys(context.dependencies).length === 0 && Object.keys(context.devDependencies).length === 0) {
-    context.log(LogLevelLabel.TRACE, `No dependencies or devDependencies to install. Skipping installation step.`);
-    return;
-  }
-  context.log(LogLevelLabel.DEBUG, `The following packages are required: 
-Dependencies: 
-${Object.entries(context.dependencies).map(([name, version]) => `- ${name}@${String(version)}`).join(" \n")}
-
-DevDependencies: 
-${Object.entries(context.devDependencies).map(([name, version]) => `- ${name}@${String(version)}`).join(" \n")}`);
-  await Promise.all([
-    Promise.all(Object.entries(context.dependencies).map(async ([name, version]) => installPackage(context, `${getPackageName(name)}@${String(version)}`, false))),
-    Promise.all(Object.entries(context.devDependencies).map(async ([name, version]) => installPackage(context, `${getPackageName(name)}@${String(version)}`, true)))
-  ]);
-}
-__name(installDependencies, "installDependencies");
-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$1(context.workspaceConfig.workspaceRoot, context.config.output.dts) : joinPaths$1(context.workspaceConfig.workspaceRoot, context.config.projectRoot, "storm.d.ts");
-    const dtsRelativePath = joinPaths$1(relativePath(joinPaths$1(context.workspaceConfig.workspaceRoot, context.config.projectRoot), findFilePath(dtsFilePath)), findFileName(dtsFilePath));
-    if (!tsconfigJson.include?.some((filePattern) => isIncludeMatchFound(filePattern, [
-      dtsFilePath,
-      dtsRelativePath,
-      "storm.d.ts"
-    ]))) {
-      tsconfigJson.include ??= [];
-      tsconfigJson.include.push(dtsRelativePath.startsWith("./") ? dtsRelativePath.slice(2) : dtsRelativePath);
-    }
-  }
-  if (!tsconfig.options.lib?.some((lib) => [
-    "lib.esnext.d.ts",
-    "lib.es2021.d.ts",
-    "lib.es2022.d.ts",
-    "lib.es2023.d.ts"
-  ].includes(lib.toLowerCase()))) {
-    tsconfigJson.compilerOptions.lib ??= [];
-    tsconfigJson.compilerOptions.lib.push("esnext");
-  }
-  if (tsconfig.options.module !== ts.ModuleKind.ESNext) {
-    tsconfigJson.compilerOptions.module = "ESNext";
-  }
-  if (!tsconfig.options.target || ![
-    ts.ScriptTarget.ESNext,
-    ts.ScriptTarget.ES2024,
-    ts.ScriptTarget.ES2023,
-    ts.ScriptTarget.ES2022,
-    ts.ScriptTarget.ES2021
-  ].includes(tsconfig.options.target)) {
-    tsconfigJson.compilerOptions.target = "ESNext";
-  }
-  if (tsconfig.options.moduleResolution !== ts.ModuleResolutionKind.Bundler) {
-    tsconfigJson.compilerOptions.moduleResolution = "Bundler";
-  }
-  if (tsconfig.options.moduleDetection !== ts.ModuleDetectionKind.Force) {
-    tsconfigJson.compilerOptions.moduleDetection = "force";
-  }
-  if (tsconfig.options.allowSyntheticDefaultImports !== true) {
-    tsconfigJson.compilerOptions.allowSyntheticDefaultImports = true;
-  }
-  if (tsconfig.options.noImplicitOverride !== true) {
-    tsconfigJson.compilerOptions.noImplicitOverride = true;
-  }
-  if (tsconfig.options.noUncheckedIndexedAccess !== true) {
-    tsconfigJson.compilerOptions.noUncheckedIndexedAccess = true;
-  }
-  if (tsconfig.options.skipLibCheck !== true) {
-    tsconfigJson.compilerOptions.skipLibCheck = true;
-  }
-  if (tsconfig.options.resolveJsonModule !== true) {
-    tsconfigJson.compilerOptions.resolveJsonModule = true;
-  }
-  if (tsconfig.options.isolatedModules !== true) {
-    tsconfigJson.compilerOptions.isolatedModules = true;
-  }
-  if (tsconfig.options.verbatimModuleSyntax !== false) {
-    tsconfigJson.compilerOptions.verbatimModuleSyntax = false;
-  }
-  if (tsconfig.options.allowJs !== true) {
-    tsconfigJson.compilerOptions.allowJs = true;
-  }
-  if (tsconfig.options.esModuleInterop !== true) {
-    tsconfigJson.compilerOptions.esModuleInterop = true;
-  }
-  if (tsconfig.options.declaration !== true) {
-    tsconfigJson.compilerOptions.declaration = true;
-  }
-  if (context.environment.consumer === "client") {
-    if (tsconfig.options.jsx !== ts.JsxEmit.ReactJSX) {
-      tsconfigJson.compilerOptions.jsx = "react-jsx";
-    }
-    if (!tsconfig.options.lib?.some((lib) => lib.toLowerCase() !== "dom")) {
-      tsconfigJson.compilerOptions.lib ??= [];
-      tsconfigJson.compilerOptions.lib.push("dom");
-    }
-    if (!tsconfig.options.lib?.some((lib) => lib.toLowerCase() !== "dom.iterable")) {
-      tsconfigJson.compilerOptions.lib ??= [];
-      tsconfigJson.compilerOptions.lib.push("dom.iterable");
-    }
-  } else if (context.config.build.platform === "node") {
-    if (!tsconfig.options.types?.some((type) => type.toLowerCase() === "node" || type.toLowerCase() === "@types/node")) {
-      tsconfigJson.compilerOptions.types ??= [];
-      tsconfigJson.compilerOptions.types.push("node");
-    }
-  }
-  return tsconfigJson;
-}
-__name(resolveTsconfigChanges, "resolveTsconfigChanges");
-async function initializeTsconfig(context) {
-  context.log(LogLevelLabel.TRACE, "Initializing TypeScript configuration (tsconfig.json) for the Powerlines project.");
-  if (!isPackageExists("typescript")) {
-    throw new Error('The TypeScript package is not installed. Please install the package using the command: "npm install typescript --save-dev"');
-  }
-  const tsconfigFilePath = getTsconfigFilePath(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
-  context.tsconfig.originalTsconfigJson = await readJsonFile(tsconfigFilePath);
-  context.tsconfig.tsconfigJson = await resolveTsconfigChanges(context);
-  await context.fs.writeFile(tsconfigFilePath, StormJSON.stringify(context.tsconfig.tsconfigJson), {
-    mode: "fs"
-  });
-  context.tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig, context.config.tsconfigRaw, context.tsconfig.originalTsconfigJson);
-}
-__name(initializeTsconfig, "initializeTsconfig");
-async function resolveTsconfig(context) {
-  const updateTsconfigJson = await readJsonFile(context.tsconfig.tsconfigFilePath);
-  if (updateTsconfigJson?.compilerOptions?.types && Array.isArray(updateTsconfigJson.compilerOptions.types) && !updateTsconfigJson.compilerOptions.types.length) {
-    delete updateTsconfigJson.compilerOptions.types;
-  }
-  const result = getObjectDiff(context.tsconfig.originalTsconfigJson, updateTsconfigJson, {
-    ignoreArrayOrder: true,
-    showOnly: {
-      statuses: [
-        "added",
-        "deleted",
-        "updated"
-      ],
-      granularity: "deep"
-    }
-  });
-  const changes = [];
-  const getChanges = /* @__PURE__ */ __name((difference, property) => {
-    if (difference.status === "added" || difference.status === "deleted" || difference.status === "updated") {
-      if (difference.diff) {
-        for (const diff of difference.diff) {
-          getChanges(diff, property ? `${property}.${difference.property}` : difference.property);
-        }
-      } else {
-        changes.push({
-          field: property ? `${property}.${difference.property}` : difference.property,
-          status: difference.status,
-          previous: difference.status === "added" ? "---" : StormJSON.stringify(difference.previousValue),
-          current: difference.status === "deleted" ? "---" : StormJSON.stringify(difference.currentValue)
-        });
-      }
-    }
-  }, "getChanges");
-  for (const diff of result.diff) {
-    getChanges(diff);
-  }
-  if (changes.length > 0) {
-    context.log(LogLevelLabel.WARN, `Updating the following configuration values in "${context.tsconfig.tsconfigFilePath}" file:
-
-    ${changes.map((change, i) => `${chalk4.bold.whiteBright(`${i + 1}. ${titleCase(change.status)} the ${change.field} field: `)}
-    ${chalk4.red(` - Previous: ${change.previous} `)}
-    ${chalk4.green(` - Updated: ${change.current} `)}
-  `).join("\n")}
-    `);
-  }
-  await writeFile(context.log, context.tsconfig.tsconfigFilePath, StormJSON.stringify(updateTsconfigJson));
-  context.tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
-  if (!context.tsconfig) {
-    throw new Error("Failed to parse the TypeScript configuration file.");
-  }
-  context.tsconfig.tsconfigJson.compilerOptions ??= {};
-  context.tsconfig.tsconfigJson.compilerOptions.strict = false;
-}
-__name(resolveTsconfig, "resolveTsconfig");
-
-// src/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");
-      if (context.config.build.polyfill) {
-        context.config.build.polyfill = context.config.build.polyfill.map((polyfill) => replacePathTokens(context, polyfill));
-      }
-      context.log(LogLevelLabel.TRACE, `Powerlines configuration has been resolved: 
-
-${formatLogMessage(context.config)}`);
-      context.fs[__VFS_PATCH__]();
-      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");
-      await this.callNormalHook(context, "prepare");
-      if (context.config.output.dts !== false) {
-        context.log(LogLevelLabel.TRACE, `Preparing the TypeScript definitions for the Powerlines project.`);
-        context.log(LogLevelLabel.TRACE, "Transforming built-ins runtime modules files.");
-        const builtinFilePaths = await Promise.all((await context.getBuiltins()).map(async (file) => {
-          const result2 = await transformAsync(file.code.toString(), {
-            highlightCode: true,
-            code: true,
-            ast: false,
-            cloneInputAst: false,
-            comments: true,
-            sourceType: "module",
-            configFile: false,
-            babelrc: false,
-            envName: context.config.mode,
-            caller: {
-              name: "powerlines"
-            },
-            ...context.config.transform.babel,
-            filename: file.path,
-            plugins: [
-              [
-                "@babel/plugin-syntax-typescript"
-              ],
-              [
-                moduleResolverBabelPlugin(context)
-              ]
-            ]
-          });
-          if (!result2?.code) {
-            throw new Error(`Powerlines - Generate Types failed to compile ${file.id}`);
-          }
-          context.log(LogLevelLabel.TRACE, `Writing transformed built-in runtime file ${file.id}.`);
-          await context.writeBuiltin(result2.code, file.id, file.path);
-          return file.path;
-        }));
-        const typescriptPath = await resolvePackage("typescript");
-        if (!typescriptPath) {
-          throw new Error("Could not resolve TypeScript package location. Please ensure TypeScript is installed.");
-        }
-        const files = builtinFilePaths.reduce((ret, fileName) => {
-          const formatted = replacePath(fileName, context.workspaceConfig.workspaceRoot);
-          if (!ret.includes(formatted)) {
-            ret.push(formatted);
-          }
-          return ret;
-        }, [
-          joinPaths$1(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, defu2({
-          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$1(context.workspaceConfig.workspaceRoot, context.tsconfig.tsconfigFilePath);
-        resolvedTsconfig.options.pathsBasePath = context.workspaceConfig.workspaceRoot;
-        resolvedTsconfig.options.suppressOutputPathCheck = true;
-        let generatedTypes = await emitTypes(context, resolvedTsconfig, files);
-        context.log(LogLevelLabel.TRACE, `Generating TypeScript declaration file in ${context.config.output.dts}.`);
-        const directives = [];
-        let result = await this.callPreHook(context, "generateTypes", generatedTypes);
-        if (result) {
-          if (isSetObject(result)) {
-            generatedTypes = result.code;
-            if (Array.isArray(result.directives) && result.directives.length > 0) {
-              directives.push(...result.directives);
-            }
-          } else if (isSetString(result)) {
-            generatedTypes = result;
-          }
-        }
-        result = await this.callNormalHook(context, "generateTypes", generatedTypes);
-        if (result) {
-          if (isSetObject(result)) {
-            generatedTypes = result.code;
-            if (Array.isArray(result.directives) && result.directives.length > 0) {
-              directives.push(...result.directives);
-            }
-          } else if (isSetString(result)) {
-            generatedTypes = result;
-          }
-        }
-        result = await this.callPostHook(context, "generateTypes", generatedTypes);
-        if (result) {
-          if (isSetObject(result)) {
-            generatedTypes = result.code;
-            if (Array.isArray(result.directives) && result.directives.length > 0) {
-              directives.push(...result.directives);
-            }
-          } else if (isSetString(result)) {
-            generatedTypes = result;
-          }
-        }
-        await context.fs.writeFile(context.config.output.dts, `${directives ? `${directives.map((directive) => `/// <reference types="${directive}" />`).join("\n")}
-
-` : ""}${getFileHeader(context, {
-          directive: null,
-          prettierIgnore: false
-        })}
-
-${formatTypes(generatedTypes)}
-`, {
-          mode: "fs"
-        });
-      }
-      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$1(context.powerlinesPath, "files/common/**/*.hbs"));
-      for (const file of files) {
-        context.log(LogLevelLabel.TRACE, `Adding template file: ${file}`);
-        const template = Handlebars.compile(file);
-        await writeFile(context.log, joinPaths$1(context.config.projectRoot, file.replace(".hbs", "")), template(context));
-      }
-      await this.callNormalHook(context, "new");
-      if (context.config.projectType === "application") {
-        const files2 = await listFiles(joinPaths$1(context.powerlinesPath, "files/application/**/*.hbs"));
-        for (const file of files2) {
-          context.log(LogLevelLabel.TRACE, `Adding application template file: ${file}`);
-          const template = Handlebars.compile(file);
-          await writeFile(context.log, joinPaths$1(context.config.projectRoot, file.replace(".hbs", "")), template(context));
-        }
-      } else {
-        const files2 = await listFiles(joinPaths$1(context.powerlinesPath, "files/library/**/*.hbs"));
-        for (const file of files2) {
-          context.log(LogLevelLabel.TRACE, `Adding library template file: ${file}`);
-          const template = Handlebars.compile(file);
-          await writeFile(context.log, joinPaths$1(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) => {
-      this.context.log(LogLevelLabel.TRACE, "Cleaning the project's dist and artifacts directories.");
-      await context.fs.rmdir(joinPaths$1(context.workspaceConfig.workspaceRoot, context.config.output.distPath));
-      await context.fs.rmdir(joinPaths$1(context.workspaceConfig.workspaceRoot, context.config.output.artifactsFolder));
-      await callHook(context, "clean", {
-        sequential: true
-      });
-    });
-    this.context.log(LogLevelLabel.TRACE, "Powerlines - Clean command completed");
-  }
-  /**
-  * Lint the project
-  *
-  * @param inlineConfig - The inline configuration for the lint command
-  * @returns A promise that resolves when the lint command has completed
-  */
-  async lint(inlineConfig = {
-    command: "lint"
-  }) {
-    this.context.log(LogLevelLabel.INFO, "\u{1F4CB} Linting the Powerlines project");
-    await this.prepare(inlineConfig);
-    await this.#executeEnvironments(async (context) => {
-      if (context.config.lint !== false) {
-        await this.callHook(context, "lint");
-      }
-    });
-    this.context.log(LogLevelLabel.TRACE, "Powerlines linting completed");
-  }
-  /**
-  * Build the project
-  *
-  * @remarks
-  * This method will build the Powerlines project, generating the necessary artifacts.
-  *
-  * @param inlineConfig - The inline configuration for the build command
-  * @returns A promise that resolves when the build command has completed
-  */
-  async build(inlineConfig = {
-    command: "build"
-  }) {
-    this.context.log(LogLevelLabel.INFO, "\u{1F4E6}  Building the Powerlines project");
-    await this.prepare(inlineConfig);
-    await this.#executeEnvironments(async (context) => {
-      await this.callPreHook(context, "build");
-      await this.callNormalHook(context, "build");
-      if (context.config.output.distPath !== context.config.output.outputPath) {
-        const sourcePath = appendPath(context.config.output.distPath, context.workspaceConfig.workspaceRoot);
-        const destinationPath = joinPaths$1(appendPath(context.config.output.outputPath, context.workspaceConfig.workspaceRoot), "dist");
-        if (sourcePath !== destinationPath) {
-          context.log(LogLevelLabel.INFO, `Copying build output files from project's build directory (${context.config.output.distPath}) to the workspace's output directory (${context.config.output.outputPath}).`);
-          await copyFiles({
-            input: sourcePath,
-            glob: "**/*"
-          }, destinationPath);
-        }
-      }
-      await Promise.all(context.config.output.assets.map(async (asset) => {
-        context.log(LogLevelLabel.DEBUG, `Copying asset(s): ${chalk4.redBright(context.workspaceConfig.workspaceRoot === asset.input ? asset.glob : joinPaths$1(replacePath(asset.input, context.workspaceConfig.workspaceRoot), asset.glob))} -> ${chalk4.greenBright(joinPaths$1(replacePath(asset.output, context.workspaceConfig.workspaceRoot), asset.glob))} ${Array.isArray(asset.ignore) && asset.ignore.length > 0 ? ` (ignoring: ${asset.ignore.map((i) => chalk4.yellowBright(i)).join(", ")})` : ""}`);
-        await copyFiles(asset, asset.output);
-      }));
-      await this.callPostHook(context, "build");
-    });
-    this.context.log(LogLevelLabel.TRACE, "Powerlines build completed");
-  }
-  /**
-  * Prepare the documentation for the project
-  *
-  * @param inlineConfig - The inline configuration for the docs command
-  * @returns A promise that resolves when the documentation generation has completed
-  */
-  async docs(inlineConfig = {
-    command: "docs"
-  }) {
-    this.context.log(LogLevelLabel.INFO, "\u{1F4D3} Generating documentation for the Powerlines project");
-    await this.prepare(inlineConfig);
-    await this.#executeEnvironments(async (context) => {
-      context.log(LogLevelLabel.TRACE, "Writing documentation for the Powerlines project artifacts.");
-      await this.prepare(inlineConfig);
-      await this.#executeEnvironments(async (context2) => {
-        await this.callHook(context2, "docs");
-      });
-    });
-    this.#context.log(LogLevelLabel.TRACE, "Powerlines documentation generation completed");
-  }
-  /**
-  * Deploy the project source code
-  *
-  * @remarks
-  * This method will prepare and build the Powerlines project, generating the necessary artifacts for the deployment.
-  *
-  * @param inlineConfig - The inline configuration for the deploy command
-  */
-  async deploy(inlineConfig = {
-    command: "deploy"
-  }) {
-    this.context.log(LogLevelLabel.INFO, "\u{1F4E6} Deploying the Powerlines project");
-    await this.prepare(inlineConfig);
-    await this.#executeEnvironments(async (context) => {
-      await this.callHook(context, "deploy");
-    });
-    this.context.log(LogLevelLabel.TRACE, "Powerlines deploy 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__]();
-      await context.fs.dispose();
-    });
-    this.context.log(LogLevelLabel.TRACE, "Powerlines finalize execution completed");
-  }
-  /**
-  * Calls a hook in parallel
-  *
-  * @param hook - The hook to call
-  * @param options - Options for calling the hook
-  * @param args - The arguments to pass to the hook
-  * @returns The result of the hook call
-  */
-  async callHookParallel(hook, options, ...args) {
-    return callHook(isSetObject(options?.environment) ? options.environment : await this.#context.getEnvironment(options?.environment), hook, {
-      ...options,
-      sequential: false
-    }, ...args);
-  }
-  /**
-  * Calls a hook in sequence
-  *
-  * @param hook - The hook to call
-  * @param options - Options for calling the hook
-  * @param args - The arguments to pass to the hook
-  * @returns The result of the hook call
-  */
-  async callHookSequential(hook, options, ...args) {
-    return callHook(isSetObject(options?.environment) ? options.environment : await this.#context.getEnvironment(options?.environment), hook, {
-      ...options,
-      sequential: true
-    }, ...args);
-  }
-  /**
-  * Calls the `"pre"` ordered hooks in sequence
-  *
-  * @param environment - The environment to use for the hook call
-  * @param hook - The hook to call
-  * @param args - The arguments to pass to the hook
-  * @returns The result of the hook call
-  */
-  async callPreHook(environment, hook, ...args) {
-    return this.callHookSequential(hook, {
-      order: "pre",
-      environment
-    }, ...args);
-  }
-  /**
-  * Calls the `"post"` ordered hooks in sequence
-  *
-  * @param environment - The environment to use for the hook call
-  * @param hook - The hook to call
-  * @param args - The arguments to pass to the hook
-  * @returns The result of the hook call
-  */
-  async callPostHook(environment, hook, ...args) {
-    return this.callHookSequential(hook, {
-      order: "post",
-      environment
-    }, ...args);
-  }
-  /**
-  * Calls a hook in sequence
-  *
-  * @param environment - The environment to use for the hook call
-  * @param hook - The hook to call
-  * @param args - The arguments to pass to the hook
-  * @returns The result of the hook call
-  */
-  async callNormalHook(environment, hook, ...args) {
-    return this.callHookSequential(hook, {
-      order: "normal",
-      environment
-    }, ...args);
-  }
-  /**
-  * Calls the `"pre"` and `"post"` ordered hooks, as well as the normal hooks in sequence
-  *
-  * @param environment - The environment to use for the hook call
-  * @param hook - The hook to call
-  * @param args - The arguments to pass to the hook
-  * @returns The result of the hook call
-  */
-  async callHook(environment, hook, ...args) {
-    return this.callHookSequential(hook, {
-      environment
-    }, ...args);
-  }
-  async [Symbol.asyncDispose]() {
-    await this.finalize();
-  }
-  /**
-  * Get the configured environments
-  *
-  * @returns The configured environments
-  */
-  async #getEnvironments() {
-    if (!this.context.config.environments || Object.keys(this.context.config.environments).length <= 1) {
-      this.context.log(LogLevelLabel.DEBUG, "No environments are configured for this Powerlines project. Using the default environment.");
-      return [
-        await this.context.getEnvironment()
-      ];
-    }
-    this.context.log(LogLevelLabel.DEBUG, `Found ${Object.keys(this.context.config.environments).length} configured environment(s) for this Powerlines project.`);
-    return (await Promise.all(Object.entries(this.context.config.environments).map(async ([name, config]) => {
-      const environment = await this.context.getEnvironmentSafe(name);
-      if (!environment) {
-        const resolvedEnvironment = await this.callHookParallel("configEnvironment", {
-          environment: name
-        }, name, config);
-        if (resolvedEnvironment) {
-          this.context.environments[name] = await this.context.in(resolvedEnvironment);
-        }
-      }
-      return this.context.environments[name];
-    }))).filter((context) => isSet(context));
-  }
-  /**
-  * Execute a handler function for each environment
-  *
-  * @param handle - The handler function to execute for each environment
-  */
-  async #executeEnvironments(handle) {
-    await Promise.all((await this.#getEnvironments()).map(async (context) => {
-      return Promise.resolve(handle(context));
-    }));
-  }
-  /**
-  * Add a Powerlines plugin used in the build process
-  *
-  * @param config - The import path of the plugin to add
-  */
-  async #addPlugin(config) {
-    if (config) {
-      const plugin = await this.#initPlugin(config);
-      if (!plugin) {
-        return;
-      }
-      if (plugin.dependsOn) {
-        for (const required of plugin.dependsOn) {
-          await this.#addPlugin(required);
-        }
-      }
-      this.context.log(LogLevelLabel.DEBUG, `Successfully initialized the ${chalk4.bold.cyanBright(plugin.name)} plugin`);
-      await this.context.addPlugin(plugin);
-    }
-  }
-  /**
-  * Initialize a Powerlines plugin
-  *
-  * @param config - The configuration for the plugin
-  * @returns The initialized plugin instance, or null if the plugin was a duplicate
-  * @throws Will throw an error if the plugin cannot be found or is invalid
-  */
-  async #initPlugin(config) {
-    let awaited = config;
-    if (isPromiseLike(config)) {
-      awaited = await Promise.resolve(config);
-    }
-    if (!isPluginConfig(awaited)) {
-      throw new Error(`Invalid plugin specified in the configuration - ${JSON.stringify(awaited)}. Please ensure the value is a plugin name, an object with the \`plugin\` and \`props\` properties, or an instance of \`Plugin\`.`);
-    }
-    let plugin;
-    if (isPlugin(awaited)) {
-      plugin = awaited;
-    } else if (isFunction(awaited)) {
-      plugin = await Promise.resolve(awaited());
-    } else if (isSetString(awaited)) {
-      const resolved = await this.#resolvePlugin(awaited);
-      if (isFunction(resolved)) {
-        plugin = await Promise.resolve(resolved());
-      } else {
-        plugin = resolved;
-      }
-    } else if (isPluginConfigTuple(awaited) || isPluginConfigObject(awaited)) {
-      let pluginConfig;
-      let pluginOptions;
-      if (isPluginConfigTuple(awaited)) {
-        pluginConfig = awaited[0];
-        pluginOptions = awaited?.length === 2 ? awaited[1] : void 0;
-      } else {
-        pluginConfig = awaited.plugin;
-        pluginOptions = awaited.options;
-      }
-      if (isSetString(pluginConfig)) {
-        const resolved = await this.#resolvePlugin(pluginConfig);
-        if (isFunction(resolved)) {
-          plugin = await Promise.resolve(pluginOptions ? resolved(pluginOptions) : resolved());
-        } else {
-          plugin = resolved;
-        }
-      } else if (isFunction(pluginConfig)) {
-        plugin = await Promise.resolve(pluginConfig(pluginOptions));
-      } else if (isPlugin(pluginConfig)) {
-        plugin = pluginConfig;
-      }
-    }
-    if (!plugin) {
-      throw new Error(`The plugin configuration ${JSON.stringify(awaited)} is invalid. This configuration must point to a valid Powerlines plugin module.`);
-    }
-    if (!isPlugin(plugin)) {
-      throw new Error(`The plugin option ${JSON.stringify(plugin)} does not export a valid module. This configuration must point to a valid Powerlines plugin module.`);
-    }
-    if (checkDedupe(plugin, this.context.plugins)) {
-      this.context.log(LogLevelLabel.TRACE, `Duplicate ${chalk4.bold.cyanBright(plugin.name)} plugin dependency detected - Skipping initialization.`);
-      return null;
-    }
-    this.context.log(LogLevelLabel.TRACE, `Initializing the ${chalk4.bold.cyanBright(plugin.name)} plugin...`);
-    return plugin;
-  }
-  async #resolvePlugin(pluginPath) {
-    if (pluginPath.startsWith("@") && pluginPath.split("/").filter(Boolean).length > 2) {
-      const splits = pluginPath.split("/").filter(Boolean);
-      pluginPath = `${splits[0]}/${splits[1]}`;
-    }
-    const isInstalled = isPackageExists(pluginPath, {
-      paths: [
-        this.context.workspaceConfig.workspaceRoot,
-        this.context.config.projectRoot
-      ]
-    });
-    if (!isInstalled && this.context.config.skipInstalls !== true) {
-      this.#context.log(LogLevelLabel.WARN, `The plugin package "${pluginPath}" is not installed. It will be installed automatically.`);
-      const result = await install(pluginPath, {
-        cwd: this.context.config.projectRoot
-      });
-      if (isNumber(result.exitCode) && result.exitCode > 0) {
-        this.#context.log(LogLevelLabel.ERROR, result.stderr);
-        throw new Error(`An error occurred while installing the build plugin package "${pluginPath}" `);
-      }
-    }
-    try {
-      const module = await this.context.resolver.plugin.import(this.context.resolver.plugin.esmResolve(joinPaths$1(pluginPath, "plugin")));
-      const result = module.plugin ?? module.default;
-      if (!result) {
-        throw new Error(`The plugin package "${pluginPath}" does not export a valid module.`);
-      }
-      return result;
-    } catch (error) {
-      try {
-        const module = await this.context.resolver.plugin.import(this.context.resolver.plugin.esmResolve(pluginPath));
-        const result = module.plugin ?? module.default;
-        if (!result) {
-          throw new Error(`The plugin package "${pluginPath}" does not export a valid module.`);
-        }
-        return result;
-      } catch {
-        if (!isInstalled) {
-          throw new Error(`The plugin package "${pluginPath}" is not installed. Please install the package using the command: "npm install ${pluginPath} --save-dev"`);
-        } else {
-          throw new Error(`An error occurred while importing the build plugin package "${pluginPath}":
-${isError(error) ? error.message : String(error)}
-
-Note: Please ensure the plugin package's default export is a class that extends \`Plugin\` with a constructor that excepts a single arguments of type \`PluginOptions\`.`);
-        }
-      }
-    }
-  }
-};
-
-// src/lib/unplugin/factory.ts
-function createUnpluginFactory(variant, decorate) {
-  return (config, meta) => {
-    const log = createLog("unplugin", config);
-    log(LogLevelLabel.DEBUG, "Initializing Unplugin");
-    try {
-      const userConfig = {
-        ...config,
-        variant,
-        unplugin: meta
-      };
-      let api;
-      let resolvePatterns = [];
-      async function buildStart() {
-        log(LogLevelLabel.DEBUG, "Powerlines build plugin starting...");
-        const workspaceRoot = getWorkspaceRoot(process.cwd());
-        api = await PowerlinesAPI.from(workspaceRoot, userConfig);
-        if (api.context.config.build.skipNodeModulesBundle) {
-          resolvePatterns = tsconfigPathsToRegExp(api.context.tsconfig.options.paths ?? []);
-        }
-        log(LogLevelLabel.DEBUG, "Preparing build artifacts for the Powerlines project...");
-        await api.prepare({
-          command: "build"
-        });
-      }
-      __name(buildStart, "buildStart");
-      async function resolveId(id, importer, options = {
-        isEntry: false
-      }) {
-        return handleResolveId(api.context, {
-          id,
-          importer,
-          options
-        }, {
-          skipNodeModulesBundle: api.context.config.build.skipNodeModulesBundle,
-          external: api.context.config.build.external,
-          noExternal: api.context.config.build.noExternal,
-          resolvePatterns
-        });
-      }
-      __name(resolveId, "resolveId");
-      async function load(id) {
-        const environment = await api.context.getEnvironment();
-        if (id) {
-          const resolvedPath = environment.fs.resolve(id);
-          if (resolvedPath) {
-            return environment.fs.readFile(resolvedPath);
-          }
-        }
-        let result2 = await api.callPreHook(environment, "load", id);
-        if (result2) {
-          return result2;
-        }
-        result2 = await api.callNormalHook(environment, "load", id);
-        if (result2) {
-          return result2;
-        }
-        return api.callPostHook(environment, "load", id);
-      }
-      __name(load, "load");
-      async function transform(code, id) {
-        const environment = await api.context.getEnvironment();
-        let transformed = code;
-        let result2 = await api.callPreHook(environment, "transform", getString(transformed), id);
-        if (result2) {
-          transformed = result2;
-        }
-        result2 = await api.callNormalHook(environment, "transform", getString(transformed), id);
-        if (result2) {
-          transformed = result2;
-        }
-        result2 = await api.callPostHook(environment, "transform", getString(transformed), id);
-        if (result2) {
-          transformed = result2;
-        }
-        return transformed;
-      }
-      __name(transform, "transform");
-      async function writeBundle() {
-        log(LogLevelLabel.DEBUG, "Finalizing Powerlines project output...");
-        const environment = await api.context.getEnvironment();
-        await api.callHook(environment, "writeBundle");
-      }
-      __name(writeBundle, "writeBundle");
-      const result = {
-        name: "powerlines",
-        resolveId: {
-          filter: {
-            id: {
-              include: [
-                /.*/
-              ]
-            }
-          },
-          handler: resolveId
-        },
-        load: {
-          filter: {
-            id: {
-              include: [
-                /.*/,
-                /^storm:/
-              ]
-            }
-          },
-          handler: load
-        },
-        transform,
-        buildStart,
-        writeBundle
-      };
-      return decorate ? decorate(api, result) : result;
-    } catch (error) {
-      log(LogLevelLabel.FATAL, error?.message);
-      throw error;
-    }
-  };
-}
-__name(createUnpluginFactory, "createUnpluginFactory");
-
-export { VirtualFileSystem, createUnpluginFactory };
+export { PowerlinesContext, VirtualFileSystem, __VFS_PATCH__, __VFS_REVERT__, addPluginHook, checkDedupe, getHookHandler, isHookExternal, isPlugin, isPluginConfig, isPluginConfigObject, isPluginConfigTuple, isPluginHook };