powerlines 0.23.3 → 0.23.5

package/dist/lib/chunk-NDKPSA3I.js

@@ -0,0 +1,1190 @@
+import { writeFile } from './chunk-TANQDHYY.js';
+import { getFileHeader } from './chunk-GANVMM73.js';
+import { handleResolveId } from './chunk-G7S5PIAC.js';
+import { getParsedTypeScriptConfig, getTsconfigFilePath, isIncludeMatchFound } from './chunk-YOENMDZY.js';
+import { PowerlinesAPIContext } from './chunk-SZH2DJOG.js';
+import { callHook } from './chunk-KFJCWNVG.js';
+import { __VFS_PATCH__, __VFS_REVERT__, isPluginConfig, isPlugin, isPluginConfigTuple, isPluginConfigObject, checkDedupe } from './chunk-764HUXP3.js';
+import { writeMetaFile } from './chunk-YH5GOJS3.js';
+import { createLog } from './chunk-ENRLU4UR.js';
+import { getString } from './chunk-M263EZ4F.js';
+import { replacePathTokens } from './chunk-XZFEHPYE.js';
+import { __name } from './chunk-SHUYVCID.js';
+import { LogLevelLabel } from '@storm-software/config-tools/types';
+import { 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 } 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 chalk2 from 'chalk';
+import defu from 'defu';
+import Handlebars from 'handlebars';
+import { declare } from '@babel/helper-plugin-utils';
+import * as t from '@babel/types';
+import ts, { createProgram, createCompilerHost, getPreEmitDiagnostics, getLineAndCharacterOfPosition, flattenDiagnosticMessageText } from 'typescript';
+import { getPackageName, hasPackageVersion, getPackageVersion } from '@stryke/string-format/package';
+import { getObjectDiff } from '@donedeal0/superdiff';
+import { readJsonFile } from '@stryke/fs/json';
+import { loadTsConfig } from '@stryke/fs/tsconfig';
+import { StormJSON } from '@stryke/json/storm-json';
+import { relativePath, findFilePath, findFileName } from '@stryke/path/file-path-fns';
+import { titleCase } from '@stryke/string-format/title-case';
+
+function resolveModulePath(nodePath, state) {
+  if (!t.isStringLiteral(nodePath.node)) {
+    return;
+  }
+  const sourcePath = nodePath.node.value;
+  const resolvedPath = state.context?.fs.resolve(sourcePath);
+  if (resolvedPath) {
+    nodePath.replaceWith(t.stringLiteral(
+      // Remove the file extension if it exists
+      resolvedPath.replace(/\.(?:ts|mts|cts)x?$/, "")
+    ));
+  }
+}
+__name(resolveModulePath, "resolveModulePath");
+var TRANSFORM_FUNCTIONS = [
+  "require",
+  "require.resolve",
+  "System.import",
+  // Jest methods
+  "jest.genMockFromModule",
+  "jest.mock",
+  "jest.unmock",
+  "jest.doMock",
+  // eslint-disable-next-line @cspell/spellchecker
+  "jest.dontMock",
+  "jest.setMock",
+  "jest.requireActual",
+  "jest.requireMock",
+  // Older Jest methods
+  "require.requireActual",
+  "require.requireMock"
+];
+function matchesPattern(state, calleePath, pattern) {
+  const { node } = calleePath;
+  if (t.isMemberExpression(node)) {
+    return calleePath.matchesPattern(pattern);
+  }
+  if (!t.isIdentifier(node) || pattern.includes(".")) {
+    return false;
+  }
+  const name = pattern.split(".")[0];
+  return node.name === name;
+}
+__name(matchesPattern, "matchesPattern");
+var importVisitors = {
+  CallExpression: /* @__PURE__ */ __name((nodePath, state) => {
+    if (state.moduleResolverVisited.has(nodePath)) {
+      return;
+    }
+    const calleePath = nodePath.get("callee");
+    if (calleePath && TRANSFORM_FUNCTIONS.some((pattern) => matchesPattern(state, calleePath, pattern)) || t.isImport(nodePath.node.callee)) {
+      state.moduleResolverVisited.add(nodePath);
+      resolveModulePath(nodePath.get("arguments.0"), state);
+    }
+  }, "CallExpression"),
+  // eslint-disable-next-line ts/naming-convention
+  "ImportDeclaration|ExportDeclaration|ExportAllDeclaration": /* @__PURE__ */ __name((nodePath, state) => {
+    if (!nodePath || !nodePath.get("source") || state.moduleResolverVisited.has(nodePath)) {
+      return;
+    }
+    state.moduleResolverVisited.add(nodePath);
+    resolveModulePath(nodePath.get("source"), state);
+  }, "ImportDeclaration|ExportDeclaration|ExportAllDeclaration")
+};
+var moduleResolverBabelPlugin = /* @__PURE__ */ __name((context) => {
+  return declare(/* @__PURE__ */ __name(function builder(api) {
+    let moduleResolverVisited = /* @__PURE__ */ new Set();
+    return {
+      name: "powerlines:module-resolver",
+      manipulateOptions(opts) {
+        opts.filename ??= "unknown";
+      },
+      pre() {
+        moduleResolverVisited = /* @__PURE__ */ new Set();
+      },
+      visitor: {
+        Program: {
+          enter(programPath, state) {
+            programPath.traverse(importVisitors, {
+              ...state,
+              context,
+              moduleResolverVisited,
+              api
+            });
+          },
+          exit(programPath, state) {
+            programPath.traverse(importVisitors, {
+              ...state,
+              context,
+              moduleResolverVisited,
+              api
+            });
+          }
+        }
+      },
+      post() {
+        moduleResolverVisited.clear();
+      }
+    };
+  }, "builder"));
+}, "moduleResolverBabelPlugin");
+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(context.workspaceConfig.workspaceRoot, context.config.output.dts) : joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot, "storm.d.ts");
+    const dtsRelativePath = joinPaths(relativePath(joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot), findFilePath(dtsFilePath)), findFileName(dtsFilePath));
+    if (!tsconfigJson.include?.some((filePattern) => isIncludeMatchFound(filePattern, [
+      dtsFilePath,
+      dtsRelativePath,
+      "storm.d.ts"
+    ]))) {
+      tsconfigJson.include ??= [];
+      tsconfigJson.include.push(dtsRelativePath.startsWith("./") ? dtsRelativePath.slice(2) : dtsRelativePath);
+    }
+  }
+  if (!tsconfig.options.lib?.some((lib) => [
+    "lib.esnext.d.ts",
+    "lib.es2021.d.ts",
+    "lib.es2022.d.ts",
+    "lib.es2023.d.ts"
+  ].includes(lib.toLowerCase()))) {
+    tsconfigJson.compilerOptions.lib ??= [];
+    tsconfigJson.compilerOptions.lib.push("esnext");
+  }
+  if (tsconfig.options.module !== ts.ModuleKind.ESNext) {
+    tsconfigJson.compilerOptions.module = "ESNext";
+  }
+  if (!tsconfig.options.target || ![
+    ts.ScriptTarget.ESNext,
+    ts.ScriptTarget.ES2024,
+    ts.ScriptTarget.ES2023,
+    ts.ScriptTarget.ES2022,
+    ts.ScriptTarget.ES2021
+  ].includes(tsconfig.options.target)) {
+    tsconfigJson.compilerOptions.target = "ESNext";
+  }
+  if (tsconfig.options.moduleResolution !== ts.ModuleResolutionKind.Bundler) {
+    tsconfigJson.compilerOptions.moduleResolution = "Bundler";
+  }
+  if (tsconfig.options.moduleDetection !== ts.ModuleDetectionKind.Force) {
+    tsconfigJson.compilerOptions.moduleDetection = "force";
+  }
+  if (tsconfig.options.allowSyntheticDefaultImports !== true) {
+    tsconfigJson.compilerOptions.allowSyntheticDefaultImports = true;
+  }
+  if (tsconfig.options.noImplicitOverride !== true) {
+    tsconfigJson.compilerOptions.noImplicitOverride = true;
+  }
+  if (tsconfig.options.noUncheckedIndexedAccess !== true) {
+    tsconfigJson.compilerOptions.noUncheckedIndexedAccess = true;
+  }
+  if (tsconfig.options.skipLibCheck !== true) {
+    tsconfigJson.compilerOptions.skipLibCheck = true;
+  }
+  if (tsconfig.options.resolveJsonModule !== true) {
+    tsconfigJson.compilerOptions.resolveJsonModule = true;
+  }
+  if (tsconfig.options.isolatedModules !== true) {
+    tsconfigJson.compilerOptions.isolatedModules = true;
+  }
+  if (tsconfig.options.verbatimModuleSyntax !== false) {
+    tsconfigJson.compilerOptions.verbatimModuleSyntax = false;
+  }
+  if (tsconfig.options.allowJs !== true) {
+    tsconfigJson.compilerOptions.allowJs = true;
+  }
+  if (tsconfig.options.esModuleInterop !== true) {
+    tsconfigJson.compilerOptions.esModuleInterop = true;
+  }
+  if (tsconfig.options.declaration !== true) {
+    tsconfigJson.compilerOptions.declaration = true;
+  }
+  if (context.environment.consumer === "client") {
+    if (tsconfig.options.jsx !== ts.JsxEmit.ReactJSX) {
+      tsconfigJson.compilerOptions.jsx = "react-jsx";
+    }
+    if (!tsconfig.options.lib?.some((lib) => lib.toLowerCase() !== "dom")) {
+      tsconfigJson.compilerOptions.lib ??= [];
+      tsconfigJson.compilerOptions.lib.push("dom");
+    }
+    if (!tsconfig.options.lib?.some((lib) => lib.toLowerCase() !== "dom.iterable")) {
+      tsconfigJson.compilerOptions.lib ??= [];
+      tsconfigJson.compilerOptions.lib.push("dom.iterable");
+    }
+  } else if (context.config.build.platform === "node") {
+    if (!tsconfig.options.types?.some((type) => type.toLowerCase() === "node" || type.toLowerCase() === "@types/node")) {
+      tsconfigJson.compilerOptions.types ??= [];
+      tsconfigJson.compilerOptions.types.push("node");
+    }
+  }
+  return tsconfigJson;
+}
+__name(resolveTsconfigChanges, "resolveTsconfigChanges");
+async function initializeTsconfig(context) {
+  context.log(LogLevelLabel.TRACE, "Initializing TypeScript configuration (tsconfig.json) for the Powerlines project.");
+  if (!isPackageExists("typescript")) {
+    throw new Error('The TypeScript package is not installed. Please install the package using the command: "npm install typescript --save-dev"');
+  }
+  const tsconfigFilePath = getTsconfigFilePath(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig);
+  context.tsconfig.originalTsconfigJson = await readJsonFile(tsconfigFilePath);
+  context.tsconfig.tsconfigJson = await resolveTsconfigChanges(context);
+  await context.fs.writeFile(tsconfigFilePath, StormJSON.stringify(context.tsconfig.tsconfigJson), {
+    mode: "fs"
+  });
+  context.tsconfig = getParsedTypeScriptConfig(context.workspaceConfig.workspaceRoot, context.config.projectRoot, context.config.tsconfig, context.config.tsconfigRaw, context.tsconfig.originalTsconfigJson);
+}
+__name(initializeTsconfig, "initializeTsconfig");
+async function resolveTsconfig(context) {
+  const updateTsconfigJson = await readJsonFile(context.tsconfig.tsconfigFilePath);
+  if (updateTsconfigJson?.compilerOptions?.types && Array.isArray(updateTsconfigJson.compilerOptions.types) && !updateTsconfigJson.compilerOptions.types.length) {
+    delete updateTsconfigJson.compilerOptions.types;
+  }
+  const result = getObjectDiff(context.tsconfig.originalTsconfigJson, updateTsconfigJson, {
+    ignoreArrayOrder: true,
+    showOnly: {
+      statuses: [
+        "added",
+        "deleted",
+        "updated"
+      ],
+      granularity: "deep"
+    }
+  });
+  const changes = [];
+  const getChanges = /* @__PURE__ */ __name((difference, property) => {
+    if (difference.status === "added" || difference.status === "deleted" || difference.status === "updated") {
+      if (difference.diff) {
+        for (const diff of difference.diff) {
+          getChanges(diff, property ? `${property}.${difference.property}` : difference.property);
+        }
+      } else {
+        changes.push({
+          field: property ? `${property}.${difference.property}` : difference.property,
+          status: difference.status,
+          previous: difference.status === "added" ? "---" : StormJSON.stringify(difference.previousValue),
+          current: difference.status === "deleted" ? "---" : StormJSON.stringify(difference.currentValue)
+        });
+      }
+    }
+  }, "getChanges");
+  for (const diff of result.diff) {
+    getChanges(diff);
+  }
+  if (changes.length > 0) {
+    context.log(LogLevelLabel.WARN, `Updating the following configuration values in "${context.tsconfig.tsconfigFilePath}" file:
+
+    ${changes.map((change, i) => `${chalk2.bold.whiteBright(`${i + 1}. ${titleCase(change.status)} the ${change.field} field: `)}
+    ${chalk2.red(` - Previous: ${change.previous} `)}
+    ${chalk2.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));
+    api.#context.$$internal.api = api;
+    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
+  *
+  * @remarks
+  * This method will prepare the Powerlines API for use, initializing any necessary resources.
+  *
+  * @param inlineConfig - The inline configuration for the prepare command
+  */
+  async prepare(inlineConfig = {
+    command: "prepare"
+  }) {
+    this.context.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.emitBuiltin(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(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, defu({
+          compilerOptions: {
+            strict: false,
+            noEmit: false,
+            declaration: true,
+            declarationMap: false,
+            emitDeclarationOnly: true,
+            skipLibCheck: true
+          },
+          exclude: [
+            "node_modules",
+            "dist"
+          ],
+          include: files
+        }, context.config.tsconfigRaw ?? {}));
+        resolvedTsconfig.options.configFilePath = joinPaths(context.workspaceConfig.workspaceRoot, context.tsconfig.tsconfigFilePath);
+        resolvedTsconfig.options.pathsBasePath = context.workspaceConfig.workspaceRoot;
+        resolvedTsconfig.options.suppressOutputPathCheck = true;
+        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(context.powerlinesPath, "files/common/**/*.hbs"));
+      for (const file of files) {
+        context.log(LogLevelLabel.TRACE, `Adding template file: ${file}`);
+        const template = Handlebars.compile(file);
+        await writeFile(context.log, joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
+      }
+      await this.callNormalHook(context, "new");
+      if (context.config.projectType === "application") {
+        const files2 = await listFiles(joinPaths(context.powerlinesPath, "files/application/**/*.hbs"));
+        for (const file of files2) {
+          context.log(LogLevelLabel.TRACE, `Adding application template file: ${file}`);
+          const template = Handlebars.compile(file);
+          await writeFile(context.log, joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
+        }
+      } else {
+        const files2 = await listFiles(joinPaths(context.powerlinesPath, "files/library/**/*.hbs"));
+        for (const file of files2) {
+          context.log(LogLevelLabel.TRACE, `Adding library template file: ${file}`);
+          const template = Handlebars.compile(file);
+          await writeFile(context.log, joinPaths(context.config.projectRoot, file.replace(".hbs", "")), template(context));
+        }
+      }
+      await this.callPostHook(context, "new");
+    });
+    this.context.log(LogLevelLabel.TRACE, "Powerlines - New command completed");
+  }
+  /**
+  * Clean any previously prepared artifacts
+  *
+  * @remarks
+  * This method will remove the previous Powerlines artifacts from the project.
+  *
+  * @param inlineConfig - The inline configuration for the clean command
+  * @returns A promise that resolves when the clean command has completed
+  */
+  async clean(inlineConfig = {
+    command: "clean"
+  }) {
+    this.context.log(LogLevelLabel.INFO, "\u{1F9F9} Cleaning the previous Powerlines artifacts");
+    await this.prepare(inlineConfig);
+    await this.#executeEnvironments(async (context) => {
+      this.context.log(LogLevelLabel.TRACE, "Cleaning the project's dist and artifacts directories.");
+      await context.fs.rmdir(joinPaths(context.workspaceConfig.workspaceRoot, context.config.output.distPath));
+      await context.fs.rmdir(joinPaths(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(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): ${chalk2.redBright(context.workspaceConfig.workspaceRoot === asset.input ? asset.glob : joinPaths(replacePath(asset.input, context.workspaceConfig.workspaceRoot), asset.glob))} -> ${chalk2.greenBright(joinPaths(replacePath(asset.output, context.workspaceConfig.workspaceRoot), asset.glob))} ${Array.isArray(asset.ignore) && asset.ignore.length > 0 ? ` (ignoring: ${asset.ignore.map((i) => chalk2.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);
+  }
+  /**
+  * Dispose of the Powerlines API instance
+  *
+  * @remarks
+  * This method will finalize the Powerlines API instance, cleaning up any resources used.
+  */
+  async [Symbol.asyncDispose]() {
+    await this.finalize();
+  }
+  /**
+  * 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 ${chalk2.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 ${chalk2.bold.cyanBright(plugin.name)} plugin dependency detected - Skipping initialization.`);
+      return null;
+    }
+    this.context.log(LogLevelLabel.TRACE, `Initializing the ${chalk2.bold.cyanBright(plugin.name)} plugin...`);
+    return plugin;
+  }
+  async #resolvePlugin(pluginPath) {
+    if (pluginPath.startsWith("@") && pluginPath.split("/").filter(Boolean).length > 2) {
+      const splits = pluginPath.split("/").filter(Boolean);
+      pluginPath = `${splits[0]}/${splits[1]}`;
+    }
+    const isInstalled = isPackageExists(pluginPath, {
+      paths: [
+        this.context.workspaceConfig.workspaceRoot,
+        this.context.config.projectRoot
+      ]
+    });
+    if (!isInstalled && this.context.config.skipInstalls !== true) {
+      this.#context.log(LogLevelLabel.WARN, `The plugin package "${pluginPath}" is not installed. It will be installed automatically.`);
+      const result = await install(pluginPath, {
+        cwd: this.context.config.projectRoot
+      });
+      if (isNumber(result.exitCode) && result.exitCode > 0) {
+        this.#context.log(LogLevelLabel.ERROR, result.stderr);
+        throw new Error(`An error occurred while installing the build plugin package "${pluginPath}" `);
+      }
+    }
+    try {
+      const module = await this.context.resolver.plugin.import(this.context.resolver.plugin.esmResolve(joinPaths(pluginPath, "plugin")));
+      const result = module.plugin ?? module.default;
+      if (!result) {
+        throw new Error(`The plugin package "${pluginPath}" does not export a valid module.`);
+      }
+      return result;
+    } catch (error) {
+      try {
+        const module = await this.context.resolver.plugin.import(this.context.resolver.plugin.esmResolve(pluginPath));
+        const result = module.plugin ?? module.default;
+        if (!result) {
+          throw new Error(`The plugin package "${pluginPath}" does not export a valid module.`);
+        }
+        return result;
+      } catch {
+        if (!isInstalled) {
+          throw new Error(`The plugin package "${pluginPath}" is not installed. Please install the package using the command: "npm install ${pluginPath} --save-dev"`);
+        } else {
+          throw new Error(`An error occurred while importing the build plugin package "${pluginPath}":
+${isError(error) ? error.message : String(error)}
+
+Note: Please ensure the plugin package's default export is a class that extends \`Plugin\` with a constructor that excepts a single arguments of type \`PluginOptions\`.`);
+        }
+      }
+    }
+  }
+};
+
+// src/lib/unplugin/factory.ts
+function createUnpluginFactory(variant, decorate) {
+  return (config, meta) => {
+    const log = createLog("unplugin", config);
+    log(LogLevelLabel.DEBUG, "Initializing Unplugin");
+    try {
+      const userConfig = {
+        ...config,
+        variant,
+        unplugin: meta
+      };
+      let api;
+      let resolvePatterns = [];
+      async function buildStart() {
+        log(LogLevelLabel.DEBUG, "Powerlines build plugin starting...");
+        const workspaceRoot = getWorkspaceRoot(process.cwd());
+        api = await PowerlinesAPI.from(workspaceRoot, userConfig);
+        if (api.context.config.build.skipNodeModulesBundle) {
+          resolvePatterns = tsconfigPathsToRegExp(api.context.tsconfig.options.paths ?? []);
+        }
+        log(LogLevelLabel.DEBUG, "Preparing build artifacts for the Powerlines project...");
+        await api.prepare({
+          command: "build"
+        });
+      }
+      __name(buildStart, "buildStart");
+      async function resolveId(id, importer, options = {
+        isEntry: false
+      }) {
+        return handleResolveId(api.context, {
+          id,
+          importer,
+          options
+        }, {
+          skipNodeModulesBundle: api.context.config.build.skipNodeModulesBundle,
+          external: api.context.config.build.external,
+          noExternal: api.context.config.build.noExternal,
+          resolvePatterns
+        });
+      }
+      __name(resolveId, "resolveId");
+      async function load(id) {
+        const environment = await api.context.getEnvironment();
+        if (id) {
+          const resolvedPath = environment.fs.resolve(id);
+          if (resolvedPath) {
+            return environment.fs.readFile(resolvedPath);
+          }
+        }
+        let result2 = await api.callPreHook(environment, "load", id);
+        if (result2) {
+          return result2;
+        }
+        result2 = await api.callNormalHook(environment, "load", id);
+        if (result2) {
+          return result2;
+        }
+        return api.callPostHook(environment, "load", id);
+      }
+      __name(load, "load");
+      async function transform(code, id) {
+        const environment = await api.context.getEnvironment();
+        let transformed = code;
+        let result2 = await api.callPreHook(environment, "transform", getString(transformed), id);
+        if (result2) {
+          transformed = result2;
+        }
+        result2 = await api.callNormalHook(environment, "transform", getString(transformed), id);
+        if (result2) {
+          transformed = result2;
+        }
+        result2 = await api.callPostHook(environment, "transform", getString(transformed), id);
+        if (result2) {
+          transformed = result2;
+        }
+        return transformed;
+      }
+      __name(transform, "transform");
+      async function writeBundle() {
+        log(LogLevelLabel.DEBUG, "Finalizing Powerlines project output...");
+        const environment = await api.context.getEnvironment();
+        await api.callHook(environment, "writeBundle");
+      }
+      __name(writeBundle, "writeBundle");
+      const result = {
+        name: "powerlines",
+        api,
+        resolveId: {
+          filter: {
+            id: {
+              include: [
+                /.*/
+              ]
+            }
+          },
+          handler: resolveId
+        },
+        load: {
+          filter: {
+            id: {
+              include: [
+                /.*/,
+                /^storm:/
+              ]
+            }
+          },
+          handler: load
+        },
+        transform,
+        buildStart,
+        writeBundle
+      };
+      return decorate ? decorate(api, result) : result;
+    } catch (error) {
+      log(LogLevelLabel.FATAL, error?.message);
+      throw error;
+    }
+  };
+}
+__name(createUnpluginFactory, "createUnpluginFactory");
+
+export { createUnpluginFactory };