@powerlines/nx 0.10.47 → 0.10.49

package/dist/{chunk-JLOTTRGF.mjs → chunk-GWF62XV6.mjs}

@@ -3,13 +3,12 @@ import { __name } from './chunk-O6YSETKJ.mjs';
 import { getLogFn, getLogLevel, writeError } from '@storm-software/config-tools/logger';
 import { withRunExecutor } from '@storm-software/workspace-tools/base/base-executor';
 import { isError } from '@stryke/type-checks/is-error';
-import defu6, { defu } from 'defu';
+import defu6, { createDefu, defu } from 'defu';
 import { transformAsync } from '@babel/core';
 import { formatLogMessage } from '@storm-software/config-tools/logger/console';
 import { LogLevelLabel } from '@storm-software/config-tools/types';
 import { toArray } from '@stryke/convert/to-array';
-import { copyFiles } from '@stryke/fs/copy-file';
-import { createDirectory } from '@stryke/fs/helpers';
+import { createDirectorySync, createDirectory } from '@stryke/fs/helpers';
 import { install } from '@stryke/fs/install';
 import { listFilesSync, listFiles } from '@stryke/fs/list-files';
 import { isPackageExists, isPackageListed, doesPackageMatch, getPackageListing } from '@stryke/fs/package-fns';
@@ -29,8 +28,8 @@ import Handlebars from 'handlebars';
 import { declare } from '@babel/helper-plugin-utils';
 import * as t from '@babel/types';
 import ts, { flattenDiagnosticMessageText } from 'typescript';
-import { joinPaths } from '@stryke/path/join';
 import { InMemoryFileSystemHost, Project } from 'ts-morph';
+import { isString } from '@stryke/type-checks/is-string';
 import { getPackageName, hasPackageVersion, getPackageVersion } from '@stryke/string-format/package';
 import { getObjectDiff } from '@donedeal0/superdiff';
 import { readJsonFile, readJsonFileSync } from '@stryke/fs/json';
@@ -46,22 +45,23 @@ import { getUnique, getUniqueBy } from '@stryke/helpers/get-unique';
 import { omit } from '@stryke/helpers/omit';
 import { fetchRequest } from '@stryke/http/fetch';
 import { isAbsolutePath, isAbsolute } from '@stryke/path/is-type';
+import { joinPaths } from '@stryke/path/join';
 import { isNull } from '@stryke/type-checks/is-null';
-import { isString } from '@stryke/type-checks/is-string';
 import { uuid } from '@stryke/unique-id/uuid';
 import { tsconfigPathsToRegExp, match } from 'bundle-require';
 import { create } from 'flat-cache';
 import { parse } from 'oxc-parser';
-import { Response } from 'undici';
+import { Agent, setGlobalDispatcher, interceptors, Response } from 'undici';
 import { createJiti } from 'jiti';
 import { isUndefined } from '@stryke/type-checks/is-undefined';
 import { parseTypeDefinition } from '@stryke/convert/parse-type-definition';
-import { isFile } from '@stryke/fs/is-file';
+import { isDirectory, isFile } from '@stryke/fs/is-file';
 import * as $ from '@stryke/capnp';
 import { readFileBuffer, readFileBufferSync, writeFileBuffer } from '@stryke/fs/buffer';
 import { isParentPath } from '@stryke/path/is-parent-path';
 import { prettyBytes } from '@stryke/string-format/pretty-bytes';
 import { Blob } from 'node:buffer';
+import { fileURLToPath } from 'node:url';
 import { resolveConfig, format } from 'prettier';
 import { getColor } from '@storm-software/config-tools/utilities/colors';
 import { noop } from '@stryke/helpers/noop';
@@ -187,13 +187,16 @@ var VirtualFileSystemHost = class extends InMemoryFileSystemHost {
     this.#context.fs.removeSync(path);
   }
   readDirSync(dirPath) {
+    if (!this.#context.fs.isDirectorySync(dirPath)) {
+      return [];
+    }
     return this.#context.fs.listSync(dirPath).reduce((ret, entry) => {
-      const fullPath = this.#context.fs.resolveSync(joinPaths(dirPath, entry));
+      const fullPath = this.#context.fs.resolveSync(entry);
       if (fullPath) {
         ret.push({
           name: entry,
-          isDirectory: this.#context.fs.existsSync(fullPath),
-          isFile: this.#context.fs.existsSync(fullPath),
+          isDirectory: this.#context.fs.isDirectorySync(fullPath),
+          isFile: this.#context.fs.isFileSync(fullPath),
           isSymlink: false
         });
       }
@@ -201,14 +204,14 @@ var VirtualFileSystemHost = class extends InMemoryFileSystemHost {
     }, []);
   }
   async readFile(filePath) {
-    if (!this.#context.fs.existsSync(filePath)) {
-      throw new Error(`File not found: '${filePath}'. Please check the path and try again.`);
+    if (!this.#context.fs.isFileSync(filePath)) {
+      return "";
     }
     return await this.#context.fs.read(filePath);
   }
   readFileSync(filePath) {
-    if (!this.#context.fs.existsSync(filePath)) {
-      throw new Error(`File not found: '${filePath}'. Please check the path and try again.`);
+    if (!this.#context.fs.isFileSync(filePath)) {
+      return "";
     }
     return this.#context.fs.readSync(filePath);
   }
@@ -218,9 +221,11 @@ var VirtualFileSystemHost = class extends InMemoryFileSystemHost {
   writeFileSync(filePath, fileText) {
     this.#context.fs.writeSync(filePath, fileText);
   }
-  async mkdir(_dirPath) {
+  async mkdir(dirPath) {
+    await this.#context.fs.mkdir(dirPath);
   }
-  mkdirSync(_dirPath) {
+  mkdirSync(dirPath) {
+    this.#context.fs.mkdirSync(dirPath);
   }
   async move(srcPath, destPath) {
     await this.#context.fs.move(srcPath, destPath);
@@ -235,16 +240,16 @@ var VirtualFileSystemHost = class extends InMemoryFileSystemHost {
     this.#context.fs.copySync(srcPath, destPath);
   }
   async fileExists(filePath) {
-    return this.#context.fs.exists(filePath);
+    return this.#context.fs.isFile(filePath);
   }
   fileExistsSync(filePath) {
-    return this.#context.fs.existsSync(filePath);
+    return this.#context.fs.isFileSync(filePath);
   }
   async directoryExists(dirPath) {
-    return this.#context.fs.exists(dirPath);
+    return this.#context.fs.isDirectory(dirPath);
   }
   directoryExistsSync(dirPath) {
-    return this.#context.fs.existsSync(dirPath);
+    return this.#context.fs.isDirectorySync(dirPath);
   }
   realpathSync(path) {
     return this.#context.fs.resolveSync(path) || path;
@@ -323,6 +328,14 @@ ${diagnosticMessage.length > 5e3 ? `${diagnosticMessage.slice(0, 5e3)}...` : dia
   return formatTypes(builtinModules);
 }
 __name(emitTypes, "emitTypes");
+var mergeResults = createDefu((obj, key, value) => {
+  if (isString(obj[key]) && isString(value)) {
+    obj[key] = `${obj[key] || ""}
+${value || ""}`.trim();
+    return true;
+  }
+  return false;
+});
 async function callHook(context, hook, options, ...args) {
   const handlers = context.selectHooks(hook, options);
   if (handlers.length > 0) {
@@ -330,22 +343,28 @@ async function callHook(context, hook, options, ...args) {
     let results = [];
     if (options?.sequential === false) {
       results = await Promise.all(handlers.map(async (handler) => {
-        if (!isFunction(handler)) {
+        if (!isFunction(handler.handle)) {
           throw new Error(`Plugin hook handler for hook "${hook}" is not a function.`);
         }
-        return Promise.resolve(handler.apply(null, [
-          ...args
-        ]));
+        return Promise.resolve(
+          // eslint-disable-next-line ts/no-unsafe-call
+          handler.handle.apply(handler.context, [
+            ...args
+          ])
+        );
       }));
     } else {
       for (const handler of handlers) {
-        if (!isFunction(handler)) {
+        if (!isFunction(handler.handle)) {
           throw new Error(`Plugin hook handler for hook "${hook}" is not a function.`);
         }
         if (options?.result === "first" || options?.asNextParam === false) {
-          results.push(await Promise.resolve(handler.apply(null, [
-            ...args
-          ])));
+          results.push(await Promise.resolve(
+            // eslint-disable-next-line ts/no-unsafe-call
+            handler.handle.apply(handler.context, [
+              ...args
+            ])
+          ));
           if (options?.result === "first" && isSet(results[results.length - 1])) {
             break;
           }
@@ -357,8 +376,8 @@ async function callHook(context, hook, options, ...args) {
             sequenceArgs[0] = isFunction(options.asNextParam) ? await Promise.resolve(options.asNextParam(results[0])) : results[0];
           }
           const result = await Promise.resolve(
-            // eslint-disable-next-line ts/no-unsafe-call, no-useless-call
-            handler.apply(null, [
+            // eslint-disable-next-line ts/no-unsafe-call
+            handler.handle.apply(handler.context, [
               ...sequenceArgs
             ])
           );
@@ -367,9 +386,14 @@ async function callHook(context, hook, options, ...args) {
               results = [
                 result
               ];
-            } else {
+            } else if (isString(result)) {
+              results = [
+                `${isString(results[0]) ? results[0] || "" : ""}
+${result || ""}`.trim()
+              ];
+            } else if (isObject(result)) {
               results = [
-                defu(result, results[0] ?? {})
+                mergeResults(result, results[0] ?? {})
               ];
             }
           }
@@ -1127,20 +1151,17 @@ function normalizePath(path, builtinsPath, prefix = "powerlines") {
   return isAbsolutePath(path) ? path : isValidId(toFilePath(path), prefix) ? normalizeId(toFilePath(path), prefix).replace(new RegExp(`^${prefix.replace(/:$/, "")}:`), builtinsPath) : toFilePath(path);
 }
 __name(normalizePath, "normalizePath");
-function normalizeKey(key, sep = ":") {
-  if (!key) {
-    return "";
-  }
-  return key.replace(/[:/\\]/g, sep).replace(/^[:/\\]|[:/\\]$/g, "");
-}
-__name(normalizeKey, "normalizeKey");
-function filterKeyByBase(key, base) {
-  if (base) {
-    return key.startsWith(base) && key[key.length - 1] !== "$";
-  }
-  return key[key.length - 1] !== "$";
+function normalizeGlobPatterns(workspaceRoot, patterns) {
+  return getUnique(toArray(patterns).map((pattern) => {
+    if (isSetObject(pattern) && (isSetString(pattern.input) || isSetString(pattern.glob))) {
+      return joinPaths(pattern.input || workspaceRoot, pattern.glob || "**/*");
+    } else if (!isSetString(pattern)) {
+      return void 0;
+    }
+    return pattern;
+  }).filter(isSetString));
 }
-__name(filterKeyByBase, "filterKeyByBase");
+__name(normalizeGlobPatterns, "normalizeGlobPatterns");
 var BaseStorageAdapter = class {
   static {
     __name(this, "BaseStorageAdapter");
@@ -1195,6 +1216,21 @@ var BaseStorageAdapter = class {
     }
   }
   /**
+  * Synchronously creates a directory at the specified path.
+  *
+  * @param _ - The path of the directory to create.
+  */
+  mkdirSync(_) {
+  }
+  /**
+  * Creates a directory at the specified path.
+  *
+  * @param dirPath - The path of the directory to create.
+  */
+  async mkdir(dirPath) {
+    return Promise.resolve(this.mkdirSync(dirPath));
+  }
+  /**
   * Asynchronously removes a key from the storage.
   *
   * @param key - The key to remove.
@@ -1243,6 +1279,42 @@ var BaseStorageAdapter = class {
     return this.listSync(base);
   }
   /**
+  * Synchronously checks if the given key is a directory.
+  *
+  * @param _ - The key to check.
+  * @returns `true` if the key is a directory, otherwise `false`.
+  */
+  isDirectorySync(_) {
+    return false;
+  }
+  /**
+  * Checks if the given key is a directory.
+  *
+  * @param key - The key to check.
+  * @returns A promise that resolves to `true` if the key is a directory, otherwise `false`.
+  */
+  async isDirectory(key) {
+    return Promise.resolve(this.isDirectorySync(key));
+  }
+  /**
+  * Synchronously checks if the given key is a file.
+  *
+  * @param key - The key to check.
+  * @returns `true` if the key is a file, otherwise `false`.
+  */
+  isFileSync(key) {
+    return this.existsSync(key) && !this.isDirectorySync(key);
+  }
+  /**
+  * Checks if the given key is a file.
+  *
+  * @param key - The key to check.
+  * @returns A promise that resolves to `true` if the key is a file, otherwise `false`.
+  */
+  async isFile(key) {
+    return Promise.resolve(this.isFileSync(key));
+  }
+  /**
   * Disposes of the storage adapter, releasing any held resources.
   *
   * @returns A promise that resolves when the disposal is complete.
@@ -1383,6 +1455,22 @@ var FileSystemStorageAdapter = class extends BaseStorageAdapter {
     }
   }
   /**
+  * Synchronously creates a directory at the specified path.
+  *
+  * @param dirPath - The path of the directory to create.
+  */
+  mkdirSync(dirPath) {
+    createDirectorySync(this.resolve(dirPath));
+  }
+  /**
+  * Creates a directory at the specified path.
+  *
+  * @param dirPath - The path of the directory to create.
+  */
+  async mkdir(dirPath) {
+    await createDirectory(this.resolve(dirPath));
+  }
+  /**
   * Lists all keys under a given base path synchronously.
   *
   * @param base - The base path to list keys from.
@@ -1408,6 +1496,24 @@ var FileSystemStorageAdapter = class extends BaseStorageAdapter {
       ignore: this.options.ignore
     }).catch(ignoreNotfound).then((r) => r || []);
   }
+  /**
+  * Synchronously checks if the given key is a directory.
+  *
+  * @param key - The key to check.
+  * @returns `true` if the key is a directory, otherwise `false`.
+  */
+  isDirectorySync(key) {
+    return isDirectory(this.resolve(key));
+  }
+  /**
+  * Synchronously checks if the given key is a file.
+  *
+  * @param key - The key to check.
+  * @returns `true` if the key is a file, otherwise `false`.
+  */
+  isFileSync(key) {
+    return !isFile(this.resolve(key));
+  }
 };
 var VirtualStorageAdapter = class extends BaseStorageAdapter {
   static {
@@ -1778,26 +1884,65 @@ var VirtualFileSystem = class _VirtualFileSystem {
     return this.#getStorage(resolved)?.adapter?.name === "virtual";
   }
   /**
+  * Checks if a path is a directory in the virtual file system (VFS).
+  *
+  * @param path - The path to check.
+  * @returns `true` if the path is a directory, otherwise `false`.
+  */
+  isDirectorySync(path) {
+    const resolved = this.resolveSync(path);
+    if (!resolved) {
+      return false;
+    }
+    return !!(this.existsSync(resolved) && this.#getStorage(resolved)?.adapter?.isDirectorySync(resolved));
+  }
+  /**
+  * Checks if a path is a directory in the virtual file system (VFS).
+  *
+  * @param path - The path to check.
+  * @returns `true` if the path is a directory, otherwise `false`.
+  */
+  async isDirectory(path) {
+    const resolved = await this.resolve(path);
+    if (!resolved) {
+      return false;
+    }
+    return !!(await this.exists(resolved) && await this.#getStorage(resolved)?.adapter?.isDirectory(resolved));
+  }
+  /**
+  * Checks if a path is a file in the virtual file system (VFS).
+  *
+  * @param path - The path to check.
+  * @returns `true` if the path is a file, otherwise `false`.
+  */
+  isFileSync(path) {
+    const resolved = this.resolveSync(path);
+    if (!resolved) {
+      return false;
+    }
+    return this.#getStorage(resolved)?.adapter?.isFileSync(resolved) ?? false;
+  }
+  /**
+  * Checks if a path is a file in the virtual file system (VFS).
+  *
+  * @param path - The path to check.
+  * @returns `true` if the path is a file, otherwise `false`.
+  */
+  async isFile(path) {
+    const resolved = await this.resolve(path);
+    if (!resolved) {
+      return false;
+    }
+    return await this.#getStorage(resolved)?.adapter?.isFile(resolved) ?? false;
+  }
+  /**
   * Lists files in a given path.
   *
   * @param path - The path to list files from.
   * @returns An array of file names in the specified path.
   */
   listSync(path) {
-    let maskedMounts = [];
-    const allKeys = [];
-    for (const storage of this.#getStorages(path, true)) {
-      for (const key of storage.adapter.listSync(storage.relativeBase)) {
-        if (!maskedMounts.some((p) => `${storage.base}${normalizeKey(key)}`.startsWith(p))) {
-          allKeys.push(`${storage.base}${normalizeKey(key)}`);
-        }
-      }
-      maskedMounts = [
-        storage.base,
-        ...maskedMounts.filter((p) => !p.startsWith(storage.base))
-      ];
-    }
-    return allKeys.filter((key) => filterKeyByBase(key, path));
+    return getUnique(this.#getStorages(path, true).map((storage) => storage.adapter.listSync(storage.relativeBase ? storage.base ? appendPath(storage.relativeBase, storage.base) : storage.relativeBase : storage.base)).flat());
   }
   /**
   * Lists files in a given path.
@@ -1806,20 +1951,7 @@ var VirtualFileSystem = class _VirtualFileSystem {
   * @returns An array of file names in the specified path.
   */
   async list(path) {
-    let maskedMounts = [];
-    const allKeys = [];
-    for (const storage of this.#getStorages(path, true)) {
-      for (const key of await storage.adapter.list(storage.relativeBase)) {
-        if (!maskedMounts.some((p) => `${storage.base}${normalizeKey(key)}`.startsWith(p))) {
-          allKeys.push(`${storage.base}${normalizeKey(key)}`);
-        }
-      }
-      maskedMounts = [
-        storage.base,
-        ...maskedMounts.filter((p) => !p.startsWith(storage.base))
-      ];
-    }
-    return allKeys.filter((key) => filterKeyByBase(key, path));
+    return getUnique((await Promise.all(this.#getStorages(path, true).map(async (storage) => storage.adapter.list(storage.relativeBase ? storage.base ? appendPath(storage.relativeBase, storage.base) : storage.relativeBase : storage.base)))).flat());
   }
   /**
   * Removes a file in the virtual file system (VFS).
@@ -1871,12 +2003,16 @@ var VirtualFileSystem = class _VirtualFileSystem {
   */
   async glob(patterns) {
     const results = [];
-    for (const pattern of toArray(patterns)) {
+    for (const pattern of normalizeGlobPatterns(this.#context.workspaceConfig.workspaceRoot, patterns)) {
       const normalized = this.#normalizePath(pattern);
       if (!/[*?[\]{}]/.test(normalized) && !normalized.includes("**")) {
-        const resolved = this.resolveSync(normalized);
-        if (resolved && !results.includes(resolved)) {
-          results.push(resolved);
+        if (this.isDirectorySync(normalized)) {
+          results.push(...await this.list(normalized));
+        } else {
+          const resolved = await this.resolve(normalized);
+          if (resolved && !results.includes(resolved)) {
+            results.push(resolved);
+          }
         }
         continue;
       }
@@ -1902,12 +2038,16 @@ var VirtualFileSystem = class _VirtualFileSystem {
   */
   globSync(patterns) {
     const results = [];
-    for (const pattern of toArray(patterns)) {
+    for (const pattern of normalizeGlobPatterns(this.#context.workspaceConfig.workspaceRoot, patterns)) {
       const normalized = this.#normalizePath(pattern);
       if (!/[*?[\]{}]/.test(normalized) && !normalized.includes("**")) {
-        const resolved = this.resolveSync(normalized);
-        if (resolved && !results.includes(resolved)) {
-          results.push(resolved);
+        if (this.isDirectorySync(normalized)) {
+          results.push(...this.listSync(normalized));
+        } else {
+          const resolved = this.resolveSync(normalized);
+          if (resolved && !results.includes(resolved)) {
+            results.push(resolved);
+          }
         }
         continue;
       }
@@ -1933,20 +2073,27 @@ var VirtualFileSystem = class _VirtualFileSystem {
   * @param destPath - The destination path to copy to
   */
   async copy(srcPath, destPath) {
-    if (hasFileExtension(srcPath)) {
-      const content = await this.read(srcPath);
+    const src = srcPath instanceof URL ? fileURLToPath(srcPath) : srcPath;
+    const dest = destPath instanceof URL ? fileURLToPath(destPath) : destPath;
+    if (!isSetString(src) && (!isSetObject(src) || !isSetString(src.input)) || !isSetString(dest)) {
+      return;
+    }
+    const sourceStr = isString(src) ? src : src.input ? src.input : this.#context.workspaceConfig.workspaceRoot;
+    const source = await this.resolve(sourceStr);
+    if (!source) {
+      return;
+    }
+    if (this.isDirectorySync(source) || isSetString(src) && src.includes("*") || isSetObject(src) && isSetString(src.glob)) {
+      await Promise.all((await this.glob(src)).map(async (file) => {
+        return this.copy(file, appendPath(replacePath(file, sourceStr), dest));
+      }));
+    } else {
+      const content = await this.read(source);
       if (content !== void 0) {
-        await this.write(hasFileExtension(destPath) ? destPath : joinPaths$1(destPath, findFileName(srcPath)), content);
+        await this.write(this.#normalizePath(dest), content, {
+          skipFormat: true
+        });
       }
-    } else {
-      await Promise.all((await this.list(srcPath)).map(async (file) => {
-        const relativePath2 = file.replace(this.#normalizePath(srcPath), "");
-        const destinationPath = this.#normalizePath(appendPath(destPath, relativePath2));
-        const content = await this.read(file);
-        if (content !== void 0) {
-          await this.write(destinationPath, content);
-        }
-      }));
     }
   }
   /**
@@ -1956,20 +2103,27 @@ var VirtualFileSystem = class _VirtualFileSystem {
   * @param destPath - The destination path to copy to
   */
   copySync(srcPath, destPath) {
-    if (hasFileExtension(srcPath)) {
-      const content = this.readSync(srcPath);
+    const src = srcPath instanceof URL ? fileURLToPath(srcPath) : srcPath;
+    const dest = destPath instanceof URL ? fileURLToPath(destPath) : destPath;
+    if (!isSetString(src) && (!isSetObject(src) || !isSetString(src.input)) || !isSetString(dest)) {
+      return;
+    }
+    const sourceStr = isString(src) ? src : src.input ? src.input : this.#context.workspaceConfig.workspaceRoot;
+    const source = this.resolveSync(sourceStr);
+    if (!source) {
+      return;
+    }
+    if (this.isDirectorySync(source) || isSetString(src) && src.includes("*") || isSetObject(src) && isSetString(src.glob)) {
+      this.globSync(src).map((file) => {
+        return this.copySync(file, appendPath(findFilePath(replacePath(file, sourceStr)), dest));
+      });
+    } else {
+      const content = this.readSync(source);
       if (content !== void 0) {
-        this.writeSync(hasFileExtension(destPath) ? destPath : joinPaths$1(destPath, findFileName(srcPath)), content);
+        this.writeSync(this.#normalizePath(hasFileExtension(dest) ? dest : appendPath(findFileName(source), dest)), content, {
+          skipFormat: true
+        });
       }
-    } else {
-      this.listSync(srcPath).forEach((file) => {
-        const relativePath2 = file.replace(this.#normalizePath(srcPath), "");
-        const destinationPath = this.#normalizePath(appendPath(destPath, relativePath2));
-        const content = this.readSync(file);
-        if (content !== void 0) {
-          this.writeSync(destinationPath, content);
-        }
-      });
     }
   }
   /**
@@ -2088,6 +2242,22 @@ var VirtualFileSystem = class _VirtualFileSystem {
     return adapter.setSync(relativeKey, data);
   }
   /**
+  * Synchronously creates a directory at the specified path.
+  *
+  * @param dirPath - The path of the directory to create.
+  */
+  mkdirSync(dirPath) {
+    return this.#getStorage(dirPath)?.adapter?.mkdirSync(dirPath);
+  }
+  /**
+  * Creates a directory at the specified path.
+  *
+  * @param path - The path of the directory to create.
+  */
+  async mkdir(path) {
+    return this.#getStorage(path)?.adapter?.mkdir(path);
+  }
+  /**
   * Retrieves the metadata of a file in the virtual file system (VFS).
   *
   * @param pathOrId - The path or ID of the file to retrieve metadata for.
@@ -2312,16 +2482,29 @@ var VirtualFileSystem = class _VirtualFileSystem {
 
 // ../powerlines/src/lib/contexts/context.ts
 var configCache = /* @__PURE__ */ new WeakMap();
+var agent = new Agent({
+  keepAliveTimeout: 1e4
+});
+setGlobalDispatcher(agent.compose(interceptors.retry({
+  maxRetries: 3,
+  minTimeout: 1e3,
+  maxTimeout: 1e4,
+  timeoutFactor: 2,
+  retryAfter: true
+})));
 var PowerlinesContext = class _PowerlinesContext {
   static {
     __name(this, "PowerlinesContext");
   }
   /**
-  * Internal reference to the API instance
+  * Internal references storage
+  *
+  * @danger
+  * This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
   *
   * @internal
   */
-  #api;
+  #internal = {};
   #workspaceConfig;
   #checksum = null;
   #buildId = uuid();
@@ -2411,12 +2594,24 @@ var PowerlinesContext = class _PowerlinesContext {
   /**
   * Internal context fields and methods
   *
+  * @danger
+  * This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
+  *
   * @internal
   */
   get $$internal() {
-    return {
-      api: this.#api
-    };
+    return this.#internal;
+  }
+  /**
+  * Internal context fields and methods
+  *
+  * @danger
+  * This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
+  *
+  * @internal
+  */
+  set $$internal(value) {
+    this.#internal = value;
   }
   /**
   * The resolved entry type definitions for the project
@@ -2643,19 +2838,27 @@ var PowerlinesContext = class _PowerlinesContext {
         });
       }
     }
-    const result = await fetchRequest(input, options);
+    const response = await fetchRequest(input, {
+      timeout: 12e3,
+      ...options
+    });
+    const result = {
+      body: await response.text(),
+      status: response.status,
+      statusText: response.statusText,
+      headers: Object.fromEntries(response.headers.entries())
+    };
     if (!this.config.skipCache && !options.skipCache) {
       try {
-        this.requestCache.set(cacheKey, {
-          body: await result.text(),
-          status: result.status,
-          statusText: result.statusText,
-          headers: Object.fromEntries(result.headers.entries())
-        });
+        this.requestCache.set(cacheKey, result);
       } catch {
       }
     }
-    return result;
+    return new Response(result.body, {
+      status: result.status,
+      statusText: result.statusText,
+      headers: result.headers
+    });
   }
   /**
   * Parse code using [Oxc-Parser](https://github.com/oxc/oxc) into an (ESTree-compatible)[https://github.com/estree/estree] AST object.
@@ -3349,36 +3552,90 @@ var PowerlinesEnvironmentContext = class _PowerlinesEnvironmentContext extends P
   * Retrieves the hook handlers for a specific hook name
   */
   selectHooks(hook, options) {
-    const handlers = [];
+    const result = [];
     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));
+            result.push(...(hooks.preOrdered ?? []).map((h) => {
+              const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
+              if (!plugin) {
+                throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
+              }
+              return {
+                handle: h.handler,
+                context: plugin.context
+              };
+            }));
+            result.push(...(hooks.preEnforced ?? []).map((h) => {
+              const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
+              if (!plugin) {
+                throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
+              }
+              return {
+                handle: h.handler,
+                context: plugin.context
+              };
+            }));
           } else if (options?.order === "post") {
-            handlers.push(...(hooks.postOrdered ?? []).map((h) => h.handler));
-            handlers.push(...(hooks.postEnforced ?? []).map((h) => h.handler));
+            result.push(...(hooks.postOrdered ?? []).map((h) => {
+              const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
+              if (!plugin) {
+                throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
+              }
+              return {
+                handle: h.handler,
+                context: plugin.context
+              };
+            }));
+            result.push(...(hooks.postEnforced ?? []).map((h) => {
+              const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
+              if (!plugin) {
+                throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
+              }
+              return {
+                handle: h.handler,
+                context: plugin.context
+              };
+            }));
           } else {
-            handlers.push(...(hooks.normal ?? []).map((h) => h.handler));
+            result.push(...(hooks.normal ?? []).map((h) => {
+              const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
+              if (!plugin) {
+                throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
+              }
+              return {
+                handle: h.handler,
+                context: plugin.context
+              };
+            }));
           }
         } else {
-          handlers.push(...this.selectHooks(hook, {
+          result.push(...this.selectHooks(hook, {
             order: "pre"
           }));
-          handlers.push(...this.selectHooks(hook, {
+          result.push(...this.selectHooks(hook, {
             order: "normal"
           }));
-          handlers.push(...this.selectHooks(hook, {
+          result.push(...this.selectHooks(hook, {
             order: "post"
           }));
         }
       } else {
-        handlers.push(...this.hooks[hook].map((h) => h.handler));
+        result.push(...this.hooks[hook].map((h) => {
+          const plugin = this.plugins.find((p) => p.plugin.name === h.plugin.name);
+          if (!plugin) {
+            throw new Error(`Could not find plugin context for plugin "${h.plugin.name}".`);
+          }
+          return {
+            handle: h.handler,
+            context: plugin.context
+          };
+        }));
       }
     }
-    return handlers;
+    return result;
   }
   constructor(config, workspaceConfig) {
     super(workspaceConfig);
@@ -3411,6 +3668,31 @@ var PowerlinesAPIContext = class _PowerlinesAPIContext extends PowerlinesContext
     return context;
   }
   /**
+  * Internal context fields and methods
+  *
+  * @danger
+  * This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
+  *
+  * @internal
+  */
+  get $$internal() {
+    return super.$$internal;
+  }
+  /**
+  * Internal context fields and methods
+  *
+  * @danger
+  * This field is for internal use only and should not be accessed or modified directly. It is unstable and can be changed at anytime.
+  *
+  * @internal
+  */
+  set $$internal(value) {
+    super.$$internal = value;
+    for (const environment of Object.values(this.environments)) {
+      environment.$$internal = super.$$internal;
+    }
+  }
+  /**
   * A record of all environments by name
   */
   get environments() {
@@ -3584,7 +3866,9 @@ var PowerlinesAPI = class _PowerlinesAPI {
   */
   static async from(workspaceRoot, config) {
     const api = new _PowerlinesAPI(await PowerlinesAPIContext.from(workspaceRoot, config));
-    api.#context.$$internal.api = api;
+    api.#context.$$internal = {
+      api
+    };
     for (const plugin of api.context.config.plugins ?? []) {
       await api.#addPlugin(plugin);
     }
@@ -3709,7 +3993,7 @@ ${formatLogMessage(context.config)}`);
         context.log(LogLevelLabel.TRACE, `Generating TypeScript declaration file ${context.dtsPath}.`);
         const directives = [];
         const asNextParam = /* @__PURE__ */ __name((previousResult) => isObject(previousResult) ? previousResult.code : previousResult, "asNextParam");
-        let result = await this.callHook("generateTypes", {
+        let result = await this.callHook("types", {
           environment: context,
           sequential: true,
           order: "pre",
@@ -3726,7 +4010,7 @@ ${formatLogMessage(context.config)}`);
             generatedTypes = result;
           }
         }
-        result = await this.callHook("generateTypes", {
+        result = await this.callHook("types", {
           environment: context,
           sequential: true,
           order: "normal",
@@ -3743,7 +4027,7 @@ ${formatLogMessage(context.config)}`);
             generatedTypes = result;
           }
         }
-        result = await this.callHook("generateTypes", {
+        result = await this.callHook("types", {
           environment: context,
           sequential: true,
           order: "post",
@@ -3916,15 +4200,12 @@ ${formatTypes(generatedTypes)}
         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.buildPath}) to the workspace's output directory (${context.config.output.outputPath}).`);
-          await copyFiles({
-            input: sourcePath,
-            glob: "**/*"
-          }, destinationPath);
+          await context.fs.copy(sourcePath, destinationPath);
         }
       }
       await Promise.all(context.config.output.assets.map(async (asset) => {
         context.log(LogLevelLabel.DEBUG, `Copying asset(s): ${chalk5.redBright(context.workspaceConfig.workspaceRoot === asset.input ? asset.glob : joinPaths$1(replacePath(asset.input, context.workspaceConfig.workspaceRoot), asset.glob))} -> ${chalk5.greenBright(joinPaths$1(replacePath(asset.output, context.workspaceConfig.workspaceRoot), asset.glob))} ${Array.isArray(asset.ignore) && asset.ignore.length > 0 ? ` (ignoring: ${asset.ignore.map((i) => chalk5.yellowBright(i)).join(", ")})` : ""}`);
-        await copyFiles(asset, asset.output);
+        await context.fs.copy(asset, asset.output);
       }));
       await this.callHook("build", {
         environment: context,