@powerlines/nx 0.5.0 → 0.5.1

package/dist/{chunk-UQ4OVGQQ.mjs → chunk-RVNLAQU5.mjs}

@@ -26,7 +26,7 @@ import chalk5 from 'chalk';
 import Handlebars from 'handlebars';
 import { readJsonFile, readJsonFileSync } from '@stryke/fs/json';
 import { appendPath } from '@stryke/path/append';
-import ts3, { createProgram, createCompilerHost, getPreEmitDiagnostics, getLineAndCharacterOfPosition, flattenDiagnosticMessageText } from 'typescript';
+import ts2, { createProgram, createCompilerHost, getPreEmitDiagnostics, getLineAndCharacterOfPosition, flattenDiagnosticMessageText } from 'typescript';
 import { titleCase } from '@stryke/string-format/title-case';
 import { isUndefined } from '@stryke/type-checks/is-undefined';
 import { writeFile as writeFile$1 } from '@stryke/fs/write-file';
@@ -54,20 +54,15 @@ import { Blob } from 'node:buffer';
 import fs from 'node:fs';
 import { Union } from 'unionfs';
 import { isObject } from '@stryke/type-checks/is-object';
-import { isDirectory } from '@stryke/fs/is-file';
-import { readFile, readFileIfExistingSync } from '@stryke/fs/read-file';
-import { parseVersion } from '@stryke/fs/semver-fns';
-import { getParentPath } from '@stryke/path/get-parent-path';
-import path from 'node:path';
-import { hasPackageVersion, getPackageName, getPackageVersion } from '@stryke/string-format/package';
 import { transformAsync } from '@babel/core';
+import { readFileIfExistingSync } from '@stryke/fs/read-file';
 import MagicString from 'magic-string';
 import { declare } from '@babel/helper-plugin-utils';
 import * as t from '@babel/types';
+import { getPackageName, hasPackageVersion, getPackageVersion } from '@stryke/string-format/package';
 import { getObjectDiff } from '@donedeal0/superdiff';
 import { loadTsConfig } from '@stryke/fs/tsconfig';
 import { StormJSON } from '@stryke/json/storm-json';
-import { minimatch } from 'minimatch';
 import { isDevelopmentMode, isTestMode } from '@stryke/env/environment-checks';
 import { createVitePlugin, createEsbuildPlugin, createWebpackPlugin, createRolldownPlugin, createRollupPlugin, createRspackPlugin, createUnloaderPlugin } from 'unplugin';
 import { match, tsconfigPathsToRegExp } from 'bundle-require';
@@ -135,13 +130,13 @@ function isIncludeMatchFound(tsconfigType, types) {
   return findIncludeMatch(tsconfigType, types) !== void 0;
 }
 __name(isIncludeMatchFound, "isIncludeMatchFound");
-function getParsedTypeScriptConfig(workspaceRoot, projectRoot, tsconfig, tsconfigRaw = {}, originalTsconfigJson, host = ts3.sys) {
+function getParsedTypeScriptConfig(workspaceRoot, projectRoot, tsconfig, tsconfigRaw = {}, originalTsconfigJson, host = ts2.sys) {
   const tsconfigFilePath = getTsconfigFilePath(workspaceRoot, projectRoot, tsconfig);
   const tsconfigJson = readJsonFileSync(tsconfigFilePath);
   if (!tsconfigJson) {
     throw new Error(`Cannot find the \`tsconfig.json\` configuration file at ${joinPaths(projectRoot, tsconfig ?? "tsconfig.json")}`);
   }
-  const parsedCommandLine = ts3.parseJsonConfigFileContent(defu4(tsconfigRaw ?? {}, tsconfigJson), host, appendPath(projectRoot, workspaceRoot));
+  const parsedCommandLine = ts2.parseJsonConfigFileContent(defu4(tsconfigRaw ?? {}, tsconfigJson), host, appendPath(projectRoot, workspaceRoot));
   if (parsedCommandLine.errors.length > 0) {
     const errorMessage = `Cannot parse the TypeScript compiler options. Please investigate the following issues:
 ${parsedCommandLine.errors.map((error) => `- ${(error.category !== void 0 && error.code ? `[${error.category}-${error.code}]: ` : "") + error.messageText.toString()}`).join("\n")}
@@ -590,7 +585,7 @@ var VirtualFileSystem = class {
   * @returns `true` if the path or ID corresponds to a runtime file, otherwise `false`.
   */
   isBuiltinFile(pathOrId, options) {
-    return !!this.builtinIdMap.values().find((path2) => path2 === this.resolvePath(pathOrId, {
+    return !!this.builtinIdMap.values().find((path) => path === this.resolvePath(pathOrId, {
       ...options,
       type: "file"
     }));
@@ -622,7 +617,7 @@ var VirtualFileSystem = class {
     if (!resolvedPath) {
       return false;
     }
-    if (this.builtinIdMap.values().find((path2) => path2 === resolvedPath)) {
+    if (this.builtinIdMap.values().find((path) => path === resolvedPath)) {
       return true;
     }
     return this.#virtualFS.existsSync(resolvedPath);
@@ -636,7 +631,7 @@ var VirtualFileSystem = class {
   * @returns Whether the path or ID corresponds to a virtual file.
   */
   isTsconfigPath(pathOrId) {
-    return !!this.#context.tsconfig.options.paths && Object.keys(this.#context.tsconfig.options.paths).some((path2) => pathOrId.startsWith(path2.replaceAll("*", "")));
+    return !!this.#context.tsconfig.options.paths && Object.keys(this.#context.tsconfig.options.paths).some((path) => pathOrId.startsWith(path.replaceAll("*", "")));
   }
   /**
   * Checks if a given ID corresponds to a runtime file path.
@@ -657,12 +652,12 @@ var VirtualFileSystem = class {
   */
   async listBuiltinFiles() {
     const runtimeFiles = [];
-    for (const [id, path2] of this.builtinIdMap.entries()) {
-      const contents = await this.readFile(path2);
+    for (const [id, path] of this.builtinIdMap.entries()) {
+      const contents = await this.readFile(path);
       if (contents) {
         runtimeFiles.push({
           id: this.formatRuntimeId(id),
-          path: path2,
+          path,
           contents
         });
       }
@@ -676,21 +671,21 @@ var VirtualFileSystem = class {
   * @param options - Options for listing files, such as encoding and recursion.
   * @returns An array of file names in the specified path.
   */
-  readdirSync(path2, options = "utf8") {
-    return this.resolveFS(path2).readdirSync(toFilePath(path2), options);
+  readdirSync(path, options = "utf8") {
+    return this.resolveFS(path).readdirSync(toFilePath(path), options);
   }
   /**
   * Removes a file in the virtual file system (VFS).
   *
   * @param path - The path to create the directory at.
   */
-  unlinkSync(path2, options) {
-    const formattedPath = toFilePath(path2);
-    if (!this.fileExistsSync(path2)) {
+  unlinkSync(path, options) {
+    const formattedPath = toFilePath(path);
+    if (!this.fileExistsSync(path)) {
       return;
     }
     this.#log(LogLevelLabel.TRACE, `Synchronously removing file: ${formattedPath}`);
-    this.resolveFS(path2, options).unlinkSync(formattedPath);
+    this.resolveFS(path, options).unlinkSync(formattedPath);
     this.#cachedFS.delete(formattedPath);
     this.clearResolverCache(formattedPath);
   }
@@ -699,14 +694,14 @@ var VirtualFileSystem = class {
   *
   * @param path - The path to create the directory at.
   */
-  async unlink(path2, options) {
-    const formattedPath = toFilePath(path2);
-    if (!this.fileExistsSync(path2)) {
+  async unlink(path, options) {
+    const formattedPath = toFilePath(path);
+    if (!this.fileExistsSync(path)) {
       return;
     }
     this.#log(LogLevelLabel.TRACE, `Removing file: ${formattedPath}`);
-    if (isFunction(this.resolveFS(path2, options).promises.unlink)) {
-      await this.resolveFS(path2, options).promises.unlink(formattedPath);
+    if (isFunction(this.resolveFS(path, options).promises.unlink)) {
+      await this.resolveFS(path, options).promises.unlink(formattedPath);
       this.#cachedFS.delete(formattedPath);
       this.clearResolverCache(formattedPath);
     } else {
@@ -719,13 +714,13 @@ var VirtualFileSystem = class {
   * @param path - The path to create the directory at.
   * @param options - Options for creating the directory.
   */
-  rmdirSync(path2, options = {}) {
-    const formattedPath = toFilePath(path2);
-    if (!this.directoryExistsSync(path2)) {
+  rmdirSync(path, options = {}) {
+    const formattedPath = toFilePath(path);
+    if (!this.directoryExistsSync(path)) {
       return;
     }
     this.#log(LogLevelLabel.TRACE, `Synchronously removing directory: ${formattedPath}`);
-    this.resolveFS(path2, options).rmdirSync(formattedPath, defu4(options, {
+    this.resolveFS(path, options).rmdirSync(formattedPath, defu4(options, {
       recursive: true
     }));
     this.#cachedFS.delete(formattedPath);
@@ -738,14 +733,14 @@ var VirtualFileSystem = class {
   * @param options - Options for creating the directory.
   * @returns A promise that resolves to the path of the created directory, or undefined if the directory could not be created.
   */
-  async rmdir(path2, options = {}) {
-    const formattedPath = toFilePath(path2);
-    if (!this.directoryExistsSync(path2)) {
+  async rmdir(path, options = {}) {
+    const formattedPath = toFilePath(path);
+    if (!this.directoryExistsSync(path)) {
       return;
     }
     this.#log(LogLevelLabel.TRACE, `Removing directory: ${formattedPath}`);
-    if (isFunction(this.resolveFS(path2, options).promises.rm)) {
-      await this.resolveFS(path2, options).promises.rm(formattedPath, defu4(options, {
+    if (isFunction(this.resolveFS(path, options).promises.rm)) {
+      await this.resolveFS(path, options).promises.rm(formattedPath, defu4(options, {
         force: true,
         recursive: true
       }));
@@ -765,12 +760,12 @@ var VirtualFileSystem = class {
   * @param options - Options for removing the file.
   * @returns A promise that resolves when the file is removed.
   */
-  async rm(path2, options = {}) {
-    this.#log(LogLevelLabel.TRACE, `Removing: ${toFilePath(path2)}`);
-    if (this.directoryExistsSync(path2)) {
-      return this.rmdir(path2, options);
+  async rm(path, options = {}) {
+    this.#log(LogLevelLabel.TRACE, `Removing: ${toFilePath(path)}`);
+    if (this.directoryExistsSync(path)) {
+      return this.rmdir(path, options);
     }
-    return this.unlink(path2, options);
+    return this.unlink(path, options);
   }
   /**
   * Creates a directory in the virtual file system (VFS).
@@ -779,8 +774,8 @@ var VirtualFileSystem = class {
   * @param options - Options for creating the directory.
   * @returns A promise that resolves to the path of the created directory, or undefined if the directory could not be created.
   */
-  mkdirSync(path2, options = {}) {
-    const filePath = toFilePath(path2);
+  mkdirSync(path, options = {}) {
+    const filePath = toFilePath(path);
     this.clearResolverCache(filePath);
     return this.resolveFS(filePath, options).mkdirSync(filePath, defu4(options ?? {}, {
       recursive: true
@@ -793,9 +788,9 @@ var VirtualFileSystem = class {
   * @param options - Options for creating the directory.
   * @returns A promise that resolves to the path of the created directory, or undefined if the directory could not be created.
   */
-  async mkdir(path2, options = {}) {
+  async mkdir(path, options = {}) {
     let result;
-    const filePath = toFilePath(path2);
+    const filePath = toFilePath(path);
     if (isFunction(this.resolveFS(filePath, options).promises.mkdir)) {
       result = await this.resolveFS(filePath, options).promises.mkdir(filePath, defu4(options ?? {}, {
         recursive: true
@@ -815,8 +810,8 @@ var VirtualFileSystem = class {
   * @param options - Options for listing files, such as encoding and recursion.
   * @returns An array of file names in the specified path.
   */
-  async readdir(path2, options = "utf8") {
-    return this.resolveFS(path2).promises.readdir(toFilePath(path2), options);
+  async readdir(path, options = "utf8") {
+    return this.resolveFS(path).promises.readdir(toFilePath(path), options);
   }
   /**
   * Asynchronously reads a file from the virtual file system (VFS).
@@ -930,9 +925,9 @@ var VirtualFileSystem = class {
   * @param options - Optional parameters for writing the runtime file.
   * @returns A promise that resolves when the file is written.
   */
-  async writeBuiltinFile(id, path2, contents, options = {}) {
+  async writeBuiltinFile(id, path, contents, options = {}) {
     const formattedId = this.formatRuntimeId(id);
-    const absolutePath = this.formatAbsoluteFilePath(toFilePath(path2));
+    const absolutePath = this.formatAbsoluteFilePath(toFilePath(path));
     this.builtinIdMap.set(formattedId, absolutePath);
     let data = contents;
     if (!options.skipFormat) {
@@ -979,8 +974,8 @@ var VirtualFileSystem = class {
   * @param options - Optional parameters for writing the file.
   * @returns A promise that resolves when the file is written.
   */
-  async writeFileToDisk(path2, contents, options = {}) {
-    const absolutePath = this.formatAbsoluteFilePath(toFilePath(path2));
+  async writeFileToDisk(path, contents, options = {}) {
+    const absolutePath = this.formatAbsoluteFilePath(toFilePath(path));
     let data = contents;
     if (!options.skipFormat) {
       const resolvedConfig = await resolveConfig(absolutePath);
@@ -1015,9 +1010,9 @@ var VirtualFileSystem = class {
   * @param path - The path of the file to check.
   * @returns `true` if the file exists, otherwise `false`.
   */
-  fileExistsSync(path2) {
-    const formattedPath = this.formatAbsoluteFilePath(toFilePath(path2));
-    return this.isValidBuiltinId(formattedPath) || this.#virtualFS.existsSync(formattedPath) && this.#virtualFS.lstatSync(formattedPath).isFile() || this.#fs.existsSync(formattedPath) && this.#fs.lstatSync(formattedPath).isFile() || this.resolveFS(path2).existsSync(formattedPath) && this.resolveFS(path2).lstatSync(formattedPath).isFile();
+  fileExistsSync(path) {
+    const formattedPath = this.formatAbsoluteFilePath(toFilePath(path));
+    return this.isValidBuiltinId(formattedPath) || this.#virtualFS.existsSync(formattedPath) && this.#virtualFS.lstatSync(formattedPath).isFile() || this.#fs.existsSync(formattedPath) && this.#fs.lstatSync(formattedPath).isFile() || this.resolveFS(path).existsSync(formattedPath) && this.resolveFS(path).lstatSync(formattedPath).isFile();
   }
   /**
   * Checks if a directory exists in the virtual file system (VFS).
@@ -1025,9 +1020,9 @@ var VirtualFileSystem = class {
   * @param path - The path of the directory to check.
   * @returns `true` if the directory exists, otherwise `false`.
   */
-  directoryExistsSync(path2) {
-    const formattedPath = this.formatAbsoluteFilePath(toFilePath(path2));
-    return this.#virtualFS.existsSync(formattedPath) && this.#virtualFS.lstatSync(formattedPath).isDirectory() || this.#fs.existsSync(formattedPath) && this.#fs.lstatSync(formattedPath).isDirectory() || this.resolveFS(path2).existsSync(formattedPath) && this.resolveFS(path2).lstatSync(formattedPath).isDirectory();
+  directoryExistsSync(path) {
+    const formattedPath = this.formatAbsoluteFilePath(toFilePath(path));
+    return this.#virtualFS.existsSync(formattedPath) && this.#virtualFS.lstatSync(formattedPath).isDirectory() || this.#fs.existsSync(formattedPath) && this.#fs.lstatSync(formattedPath).isDirectory() || this.resolveFS(path).existsSync(formattedPath) && this.resolveFS(path).lstatSync(formattedPath).isDirectory();
   }
   /**
   * Checks if a path exists in the virtual file system (VFS).
@@ -1035,9 +1030,9 @@ var VirtualFileSystem = class {
   * @param path - The path to check.
   * @returns `true` if the path exists, otherwise `false`.
   */
-  pathExistsSync(path2) {
-    const formattedPath = this.formatAbsoluteFilePath(toFilePath(path2));
-    return this.isValidBuiltinId(formattedPath) || this.#virtualFS.existsSync(formattedPath) || this.#fs.existsSync(formattedPath) || this.resolveFS(path2).existsSync(formattedPath);
+  pathExistsSync(path) {
+    const formattedPath = this.formatAbsoluteFilePath(toFilePath(path));
+    return this.isValidBuiltinId(formattedPath) || this.#virtualFS.existsSync(formattedPath) || this.#fs.existsSync(formattedPath) || this.resolveFS(path).existsSync(formattedPath);
   }
   /**
   * Retrieves the status of a file in the virtual file system (VFS).
@@ -1099,12 +1094,12 @@ var VirtualFileSystem = class {
   * @param path - The path to check.
   * @returns The resolved file path if it exists, otherwise undefined.
   */
-  resolveTsconfigPath(path2) {
+  resolveTsconfigPath(path) {
     if (this.#context.tsconfig.options.paths) {
-      for (const tsconfigPathKey of Object.keys(this.#context.tsconfig.options.paths).filter((tsconfigPath) => path2.startsWith(tsconfigPath.replaceAll("*", "")))) {
-        const resolvedPath = this.#context.tsconfig.options.paths[tsconfigPathKey]?.find((tsconfigPath) => this.resolvePathName(joinPaths(this.#context.workspaceConfig.workspaceRoot, tsconfigPath.replaceAll("*", ""), path2.replace(tsconfigPathKey.replaceAll("*", ""), ""))) || this.formatAbsoluteFilePath(tsconfigPath) === this.formatAbsoluteFilePath(path2));
+      for (const tsconfigPathKey of Object.keys(this.#context.tsconfig.options.paths).filter((tsconfigPath) => path.startsWith(tsconfigPath.replaceAll("*", "")))) {
+        const resolvedPath = this.#context.tsconfig.options.paths[tsconfigPathKey]?.find((tsconfigPath) => this.resolvePathName(joinPaths(this.#context.workspaceConfig.workspaceRoot, tsconfigPath.replaceAll("*", ""), path.replace(tsconfigPathKey.replaceAll("*", ""), ""))) || this.formatAbsoluteFilePath(tsconfigPath) === this.formatAbsoluteFilePath(path));
         if (resolvedPath) {
-          return this.formatAbsoluteFilePath(resolvedPath) === this.formatAbsoluteFilePath(path2) ? this.formatAbsoluteFilePath(resolvedPath) : this.resolvePathName(joinPaths(this.#context.workspaceConfig.workspaceRoot, resolvedPath.replaceAll("*", ""), path2.replace(tsconfigPathKey.replaceAll("*", ""), "")));
+          return this.formatAbsoluteFilePath(resolvedPath) === this.formatAbsoluteFilePath(path) ? this.formatAbsoluteFilePath(resolvedPath) : this.resolvePathName(joinPaths(this.#context.workspaceConfig.workspaceRoot, resolvedPath.replaceAll("*", ""), path.replace(tsconfigPathKey.replaceAll("*", ""), "")));
         }
       }
     }
@@ -1118,9 +1113,9 @@ var VirtualFileSystem = class {
   * @param path - The path to check.
   * @returns The resolved file path if it exists, otherwise undefined.
   */
-  resolveTsconfigPathPackage(path2) {
+  resolveTsconfigPathPackage(path) {
     if (this.#context.tsconfig.options.paths) {
-      const tsconfigPathKeys = Object.keys(this.#context.tsconfig.options.paths).filter((tsconfigPath) => path2.startsWith(tsconfigPath.replaceAll("*", "")));
+      const tsconfigPathKeys = Object.keys(this.#context.tsconfig.options.paths).filter((tsconfigPath) => path.startsWith(tsconfigPath.replaceAll("*", "")));
       if (tsconfigPathKeys.length > 0 && tsconfigPathKeys[0]) {
         return tsconfigPathKeys[0].replace(/\/\*$/, "");
       }
@@ -1178,11 +1173,11 @@ var VirtualFileSystem = class {
   * @param path - The file path to format.
   * @returns The formatted file path.
   */
-  formatFilePath(path2) {
-    if (!isSetString(path2)) {
+  formatFilePath(path) {
+    if (!isSetString(path)) {
       throw new Error(`Invalid path provided. Expected a string or a valid file path.`);
     }
-    return path2.replace(new RegExp(`^${this.#context.config.output.builtinPrefix}:`), "").replace(/^\\0/, "");
+    return path.replace(new RegExp(`^${this.#context.config.output.builtinPrefix}:`), "").replace(/^\\0/, "");
   }
   /**
   * Converts a relative path to an absolute path based on the workspace and project root.
@@ -1190,8 +1185,8 @@ var VirtualFileSystem = class {
   * @param path - The relative path to convert.
   * @returns The absolute path.
   */
-  formatAbsoluteFilePath = /* @__PURE__ */ __name((path2) => {
-    const formattedPath = this.formatFilePath(path2);
+  formatAbsoluteFilePath = /* @__PURE__ */ __name((path) => {
+    const formattedPath = this.formatFilePath(path);
     if (isAbsolutePath(formattedPath) || formattedPath.startsWith(this.#context.workspaceConfig.workspaceRoot)) {
       return formattedPath;
     } else if (formattedPath.startsWith(this.#context.config.projectRoot)) {
@@ -1227,8 +1222,8 @@ var VirtualFileSystem = class {
         return result;
       }
     }
-    for (const path2 of this.resolveParentPaths(pathOrId, options.paths)) {
-      const request = joinPaths(path2, pathOrId);
+    for (const path of this.resolveParentPaths(pathOrId, options.paths)) {
+      const request = joinPaths(path, pathOrId);
       if (options.type === "file" ? this.fileExistsSync(pathOrId) : this.pathExistsSync(pathOrId)) {
         return request;
       }
@@ -1245,16 +1240,16 @@ var VirtualFileSystem = class {
       joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.projectRoot)
     ];
     if (this.#context.tsconfig.options.paths) {
-      paths = this.#context.tsconfig.options.paths ? Object.keys(this.#context.tsconfig.options.paths).filter((tsconfigPath) => request.startsWith(tsconfigPath.replaceAll("*", ""))).map((tsconfigPath) => this.#context.tsconfig.options.paths?.[tsconfigPath]).flat().reduce((ret, path2) => {
-        if (path2 && !ret.includes(joinPaths(this.#context.workspaceConfig.workspaceRoot, path2))) {
-          ret.push(joinPaths(this.#context.workspaceConfig.workspaceRoot, path2));
+      paths = this.#context.tsconfig.options.paths ? Object.keys(this.#context.tsconfig.options.paths).filter((tsconfigPath) => request.startsWith(tsconfigPath.replaceAll("*", ""))).map((tsconfigPath) => this.#context.tsconfig.options.paths?.[tsconfigPath]).flat().reduce((ret, path) => {
+        if (path && !ret.includes(joinPaths(this.#context.workspaceConfig.workspaceRoot, path))) {
+          ret.push(joinPaths(this.#context.workspaceConfig.workspaceRoot, path));
         }
         return ret;
       }, paths) : paths;
     }
-    return paths.reduce((ret, path2) => {
-      if (!ret.includes(path2)) {
-        ret.push(path2);
+    return paths.reduce((ret, path) => {
+      if (!ret.includes(path)) {
+        ret.push(path);
       }
       return ret;
     }, current.filter(Boolean).map((p) => this.formatAbsoluteFilePath(toFilePath(p))));
@@ -1295,8 +1290,8 @@ var VirtualFileSystem = class {
   *
   * @param path - The path to clear the resolver cache for.
   */
-  clearResolverCache(path2) {
-    this.#cachedResolver.keys().filter((key) => key.startsWith(toFilePath(path2))).forEach((key) => this.#cachedResolver.delete(key));
+  clearResolverCache(path) {
+    this.#cachedResolver.keys().filter((key) => key.startsWith(toFilePath(path))).forEach((key) => this.#cachedResolver.delete(key));
   }
 };
 var FILE_PREFIX = "file://";
@@ -1432,12 +1427,12 @@ function patchFS(originalFS, vfs) {
 }
 __name(patchFS, "patchFS");
 function checkVariants(request, vfs, parentPath) {
-  const path2 = parentPath ? joinPaths(parentPath, request) : request;
-  let file = checkExtensions(path2, vfs);
+  const path = parentPath ? joinPaths(parentPath, request) : request;
+  let file = checkExtensions(path, vfs);
   if (file) {
     return file;
   }
-  file = checkIndex(path2, vfs);
+  file = checkIndex(path, vfs);
   if (file) {
     return file;
   }
@@ -2274,381 +2269,6 @@ var PowerlinesAPIContext = class _PowerlinesAPIContext extends PowerlinesContext
     }
   }
 };
-async function installPackage(context, packageName, dev = false) {
-  const isListed = await isPackageListed(packageName, {
-    cwd: context.config.projectRoot
-  });
-  if (!isListed) {
-    if (context.config.skipInstalls !== true && !process.env.POWERLINES_LOCAL) {
-      context.log(LogLevelLabel.WARN, `The package "${packageName}" is not installed. It will be installed automatically.`);
-      const result = await install(packageName, {
-        cwd: context.config.projectRoot,
-        dev
-      });
-      if (isNumber(result.exitCode) && result.exitCode > 0) {
-        context.log(LogLevelLabel.ERROR, result.stderr);
-        throw new Error(`An error occurred while installing the package "${packageName}"`);
-      }
-    } else {
-      context.log(LogLevelLabel.WARN, `The package "${packageName}" is not installed. Since the "skipInstalls" option is set to true, it will not be installed automatically.`);
-    }
-  } else if (hasPackageVersion(packageName) && !process.env.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");
-async function installPackages(context, packages) {
-  return Promise.all(packages.map(async (pkg) => installPackage(context, pkg.name, pkg.dev)));
-}
-__name(installPackages, "installPackages");
-
-// ../powerlines/src/internal/helpers/eslint.ts
-var MessageSeverity;
-(function(MessageSeverity2) {
-  MessageSeverity2[MessageSeverity2["Warning"] = 1] = "Warning";
-  MessageSeverity2[MessageSeverity2["Error"] = 2] = "Error";
-})(MessageSeverity || (MessageSeverity = {}));
-function pluginCount(messages) {
-  let nextPluginWarningCount = 0;
-  let nextPluginErrorCount = 0;
-  for (let i = 0; i < messages.length; i++) {
-    const { severity, ruleId } = messages[i];
-    if (ruleId?.includes("powerlines")) {
-      if (severity === 1) {
-        nextPluginWarningCount += 1;
-      } else {
-        nextPluginErrorCount += 1;
-      }
-    }
-  }
-  return {
-    nextPluginErrorCount,
-    nextPluginWarningCount
-  };
-}
-__name(pluginCount, "pluginCount");
-function formatMessage(dir, messages, filePath) {
-  let fileName = path.posix.normalize(path.relative(dir, filePath).replace(/\\/g, "/"));
-  if (!fileName.startsWith(".")) {
-    fileName = `./${fileName}`;
-  }
-  let output = `
-${fileName}`;
-  for (let i = 0; i < messages.length; i++) {
-    const { message, severity, line, column, ruleId } = messages[i];
-    output += "\n";
-    if (line && column) {
-      output = `${output + line.toString()}:${column.toString()}  `;
-    }
-    if (severity === 1) {
-      output += `Warning: `;
-    } else {
-      output += `Error: `;
-    }
-    output += message;
-    if (ruleId) {
-      output += `  ${ruleId}`;
-    }
-  }
-  return output;
-}
-__name(formatMessage, "formatMessage");
-async function formatResults(baseDir, results, format3) {
-  let totalPluginErrorCount = 0;
-  let totalPluginWarningCount = 0;
-  const resultsWithMessages = results.filter(({ messages }) => messages?.length);
-  resultsWithMessages.forEach(({ messages }) => {
-    const res = pluginCount(messages);
-    totalPluginErrorCount += res.nextPluginErrorCount;
-    totalPluginWarningCount += res.nextPluginWarningCount;
-  });
-  const output = format3 ? await format3(resultsWithMessages) : resultsWithMessages.map(({ messages, filePath }) => formatMessage(baseDir, messages, filePath)).join("\n");
-  return {
-    output,
-    outputWithMessages: resultsWithMessages.length > 0 ? `${output}
-
-Info  - Need to disable some ESLint rules? Learn more here: https://nextjs.org/docs/app/api-reference/config/eslint#disabling-rules` : "",
-    totalPluginErrorCount,
-    totalPluginWarningCount
-  };
-}
-__name(formatResults, "formatResults");
-async function writeDefaultEslintConfig(log, context, type = "recommended") {
-  const eslintConfigFile = joinPaths(context.workspaceConfig.workspaceRoot, "eslint.config.js");
-  const eslintConfig = `
-import { getConfig } from "eslint-config-powerlines";
-
-Error.stackTraceLimit = Number.POSITIVE_INFINITY;
-
-export default getConfig({
-  repositoryName: "${context.workspaceConfig.name || context.config.name || "powerlines"}",
-  "powerlines": "${type}",
-});
-`;
-  log(LogLevelLabel.INFO, `Writing a default ESLint config file to ${eslintConfigFile}`);
-  return writeFile(log, eslintConfigFile, eslintConfig);
-}
-__name(writeDefaultEslintConfig, "writeDefaultEslintConfig");
-var VALID_SEVERITY = [
-  "off",
-  "warn",
-  "error"
-];
-function isValidSeverity(severity) {
-  return VALID_SEVERITY.includes(severity);
-}
-__name(isValidSeverity, "isValidSeverity");
-async function writeOutputFile(log, outputFile, outputData) {
-  const filePath = path.resolve(process.cwd(), outputFile);
-  if (isDirectory(filePath)) {
-    log(LogLevelLabel.ERROR, `Cannot write to output file path, it is a directory: ${filePath}`);
-  } else {
-    try {
-      await writeFile(log, filePath, outputData);
-      log(LogLevelLabel.INFO, `The output file has been created: ${filePath}`);
-    } catch (err) {
-      log(LogLevelLabel.ERROR, `There was a problem writing the output file: ${filePath}`);
-      console.error(err);
-    }
-  }
-}
-__name(writeOutputFile, "writeOutputFile");
-async function hasEslintConfiguration(eslintFile, packageJsonConfig) {
-  const configObject = {
-    exists: false,
-    emptyEslint: false,
-    emptyPkgJsonConfig: false
-  };
-  if (eslintFile) {
-    const content = await readFile(eslintFile).then((txt) => txt.trim().replace(/\n/g, ""), () => null);
-    if (content === "" || content === "{}" || content === "---" || content === "module.exports = {}") {
-      configObject.emptyEslint = true;
-    } else {
-      configObject.exists = true;
-    }
-  } else if (packageJsonConfig?.eslintConfig) {
-    if (Object.keys(packageJsonConfig.eslintConfig).length) {
-      configObject.exists = true;
-    } else {
-      configObject.emptyPkgJsonConfig = true;
-    }
-  }
-  return configObject;
-}
-__name(hasEslintConfiguration, "hasEslintConfiguration");
-var lint = /* @__PURE__ */ __name(async (log, context, eslintConfigPath, { lintDuringBuild = false, eslintOptions = null, reportErrorsOnly = false, maxWarnings = -1, formatter = null, outputFile = null }) => {
-  try {
-    await installPackages(context, [
-      {
-        name: "eslint",
-        dev: true
-      },
-      {
-        name: "eslint-config-powerlines",
-        dev: true
-      }
-    ]);
-    const isInstalled = isPackageExists("eslint", {
-      paths: [
-        context.workspaceConfig.workspaceRoot,
-        context.config.projectRoot
-      ]
-    });
-    if (!isInstalled) {
-      log(LogLevelLabel.ERROR, `ESLint must be installed${lintDuringBuild ? " in order to run during builds:" : ":"} npm install --save-dev eslint`);
-      return null;
-    }
-    const module = await context.resolver.import(context.resolver.esmResolve("eslint"));
-    const useFlatConfig = eslintConfigPath ? findFileName(eslintConfigPath).startsWith("eslint.config.") : false;
-    let ESLint;
-    if ("loadESLint" in module) {
-      ESLint = await module.loadESLint({
-        useFlatConfig
-      });
-    }
-    const eslintVersion = parseVersion(ESLint?.version);
-    if (!eslintVersion || eslintVersion.compare("8.57.0") < 0) {
-      return `Error - Your project has an older version of ESLint installed${eslintVersion ? ` (${eslintVersion.major}.${eslintVersion.minor}.${eslintVersion.patch})` : ""}. Please upgrade to ESLint version 8.57.0 or above`;
-    }
-    const options = {
-      useEslintrc: true,
-      baseConfig: {},
-      errorOnUnmatchedPattern: false,
-      extensions: [
-        ".js",
-        ".jsx",
-        ".ts",
-        ".tsx"
-      ],
-      cache: true,
-      ...eslintOptions
-    };
-    if (eslintVersion?.compare("9.0.0") && useFlatConfig) {
-      for (const option of [
-        "useEslintrc",
-        "extensions",
-        "ignorePath",
-        "reportUnusedDisableDirectives",
-        "resolvePluginsRelativeTo",
-        "rulePaths",
-        "inlineConfig",
-        "maxWarnings"
-      ]) {
-        if (option in options) {
-          delete options[option];
-        }
-      }
-    }
-    let eslint2 = new ESLint(options);
-    let stormStackEslintPluginIsEnabled = false;
-    const stormStackRulesEnabled = /* @__PURE__ */ new Map();
-    for (const configFile of [
-      eslintConfigPath,
-      joinPaths(context.config.projectRoot, "package.json")
-    ]) {
-      if (!configFile) continue;
-      const completeConfig = await eslint2.calculateConfigForFile(configFile);
-      if (!completeConfig) continue;
-      const plugins2 = completeConfig.plugins;
-      const hasStormStackPlugin = (
-        // in ESLint < 9, `plugins` value is string[]
-        Array.isArray(plugins2) ? plugins2.includes("powerlines") : "powerlines" in plugins2
-      );
-      if (hasStormStackPlugin) {
-        stormStackEslintPluginIsEnabled = true;
-        for (const [name, [severity]] of Object.entries(completeConfig.rules)) {
-          if (!name.startsWith("powerlines/")) {
-            continue;
-          }
-          if (typeof severity === "number" && severity >= 0 && severity < VALID_SEVERITY.length) {
-            stormStackRulesEnabled.set(name, VALID_SEVERITY[severity]);
-          } else if (typeof severity === "string" && isValidSeverity(severity)) {
-            stormStackRulesEnabled.set(name, severity);
-          }
-        }
-        break;
-      }
-    }
-    if (stormStackEslintPluginIsEnabled) {
-      eslint2 = new ESLint(options);
-    } else {
-      log(LogLevelLabel.WARN, "The Powerlines plugin was not detected in your ESLint configuration. See https://nextjs.org/docs/app/api-reference/config/eslint#migrating-existing-config");
-    }
-    const lintStart = process.hrtime();
-    let results = await eslint2.lintFiles(context.tsconfig.fileNames.filter((fileName) => !fileName.includes(context.artifactsPath) && !fileName.includes("node_modules")));
-    let selectedFormatter = null;
-    if (options.fix) {
-      await ESLint.outputFixes(results);
-    }
-    if (reportErrorsOnly) {
-      results = ESLint.getErrorResults(results);
-    }
-    if (formatter) {
-      selectedFormatter = await eslint2.loadFormatter(formatter);
-    }
-    const formattedResult = await formatResults(context.config.projectRoot, results, selectedFormatter?.format?.bind(selectedFormatter));
-    const lintEnd = process.hrtime(lintStart);
-    const totalWarnings = results.reduce((sum, file) => sum + file.warningCount, 0);
-    if (outputFile) {
-      await writeOutputFile(log, outputFile, formattedResult.output);
-    }
-    return {
-      output: formattedResult.outputWithMessages,
-      isError: ESLint.getErrorResults(results)?.length > 0 || maxWarnings >= 0 && totalWarnings > maxWarnings,
-      eventInfo: {
-        durationInSeconds: lintEnd[0],
-        eslintVersion: eslintVersion.version,
-        lintedFilesCount: results.length,
-        lintFix: !!options.fix,
-        eslintPluginErrorsCount: formattedResult.totalPluginErrorCount,
-        eslintPluginWarningsCount: formattedResult.totalPluginWarningCount,
-        stormStackRulesEnabled: Object.fromEntries(stormStackRulesEnabled)
-      }
-    };
-  } catch (err) {
-    if (lintDuringBuild) {
-      log(LogLevelLabel.ERROR, `ESLint: ${isError(err) && err.message ? err.message.replace(/\n/g, " ") : String(err)}`);
-      return null;
-    } else {
-      throw err;
-    }
-  }
-}, "lint");
-async function eslint(context, lintDuringBuild = false, opts = {}) {
-  const { eslintOptions = null, reportErrorsOnly = false, maxWarnings = -1, formatter = null, outputFile = null, type = "recommended" } = opts;
-  const eslintFile = getParentPath([
-    // eslint v9
-    "eslint.config.js",
-    "eslint.config.mjs",
-    "eslint.config.cjs",
-    // TS extensions require to install a separate package `jiti`.
-    // https://eslint.org/docs/latest/use/configure/configuration-files#typescript-configuration-files
-    "eslint.config.ts",
-    "eslint.config.mts",
-    "eslint.config.cts",
-    // eslint <= v8
-    ".eslintrc.js",
-    ".eslintrc.cjs",
-    ".eslintrc.yaml",
-    ".eslintrc.yml",
-    ".eslintrc.json",
-    ".eslintrc"
-  ], context.config.projectRoot) ?? null;
-  const config = await hasEslintConfiguration(eslintFile, context.packageJson);
-  if (config.exists) {
-    return lint(context.log, context, eslintFile, {
-      lintDuringBuild,
-      eslintOptions,
-      reportErrorsOnly,
-      maxWarnings,
-      formatter,
-      outputFile
-    });
-  }
-  if (lintDuringBuild) {
-    if (config.emptyPkgJsonConfig || config.emptyEslint) {
-      context.log(LogLevelLabel.WARN, `No ESLint configuration detected. Run "storm lint" to begin setup`);
-    }
-    return null;
-  } else {
-    const isEslintInstalled = isPackageExists("eslint", {
-      paths: [
-        context.workspaceConfig.workspaceRoot,
-        context.config.projectRoot
-      ]
-    });
-    const isEslintPluginInstalled = isPackageExists("eslint-config-powerlines", {
-      paths: [
-        context.workspaceConfig.workspaceRoot,
-        context.config.projectRoot
-      ]
-    });
-    if (!isEslintInstalled || !isEslintPluginInstalled) {
-      await installPackages(context, [
-        {
-          name: "eslint",
-          dev: true
-        },
-        {
-          name: "eslint-config-powerlines",
-          dev: true
-        }
-      ]);
-    }
-    await writeDefaultEslintConfig(context.log, context, type);
-  }
-  context.log(LogLevelLabel.SUCCESS, `ESLint has successfully been configured. Run "storm lint" again to view warnings and errors.`);
-  return null;
-}
-__name(eslint, "eslint");
 function getString(code) {
   if (!code) {
     return "";
@@ -2899,13 +2519,47 @@ ${builtinModules}`.replace(
   await context.fs.writeFileToDisk(sourceFile.id, getString(sourceFile.code));
 }
 __name(generateTypes, "generateTypes");
+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");
+
+// ../powerlines/src/internal/helpers/install-dependencies.ts
 async function installDependencies(context) {
   context.log(LogLevelLabel.TRACE, `Checking and installing missing project dependencies.`);
   context.dependencies ??= {};
-  context.dependencies.powerlines = "latest";
-  if (context.config.projectType === "application") {
-    context.dependencies.unstorage = "latest";
-  }
+  context.log(LogLevelLabel.TRACE, `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)))
@@ -2949,22 +2603,22 @@ async function resolveTsconfigChanges(context) {
     tsconfigJson.compilerOptions.lib ??= [];
     tsconfigJson.compilerOptions.lib.push("esnext");
   }
-  if (tsconfig.options.module !== ts3.ModuleKind.ESNext) {
+  if (tsconfig.options.module !== ts2.ModuleKind.ESNext) {
     tsconfigJson.compilerOptions.module = "ESNext";
   }
   if (!tsconfig.options.target || ![
-    ts3.ScriptTarget.ESNext,
-    ts3.ScriptTarget.ES2024,
-    ts3.ScriptTarget.ES2023,
-    ts3.ScriptTarget.ES2022,
-    ts3.ScriptTarget.ES2021
+    ts2.ScriptTarget.ESNext,
+    ts2.ScriptTarget.ES2024,
+    ts2.ScriptTarget.ES2023,
+    ts2.ScriptTarget.ES2022,
+    ts2.ScriptTarget.ES2021
   ].includes(tsconfig.options.target)) {
     tsconfigJson.compilerOptions.target = "ESNext";
   }
-  if (tsconfig.options.moduleResolution !== ts3.ModuleResolutionKind.Bundler) {
+  if (tsconfig.options.moduleResolution !== ts2.ModuleResolutionKind.Bundler) {
     tsconfigJson.compilerOptions.moduleResolution = "Bundler";
   }
-  if (tsconfig.options.moduleDetection !== ts3.ModuleDetectionKind.Force) {
+  if (tsconfig.options.moduleDetection !== ts2.ModuleDetectionKind.Force) {
     tsconfigJson.compilerOptions.moduleDetection = "force";
   }
   if (tsconfig.options.allowSyntheticDefaultImports !== true) {
@@ -2998,7 +2652,7 @@ async function resolveTsconfigChanges(context) {
     tsconfigJson.compilerOptions.declaration = true;
   }
   if (context.environment.consumer === "client") {
-    if (tsconfig.options.jsx !== ts3.JsxEmit.ReactJSX) {
+    if (tsconfig.options.jsx !== ts2.JsxEmit.ReactJSX) {
       tsconfigJson.compilerOptions.jsx = "react-jsx";
     }
     if (!tsconfig.options.lib?.some((lib) => lib.toLowerCase() !== "dom")) {
@@ -3084,127 +2738,6 @@ async function resolveTsconfig(context) {
   context.tsconfig.tsconfigJson.compilerOptions.strict = false;
 }
 __name(resolveTsconfig, "resolveTsconfig");
-function getDefaultCompilerOptions() {
-  return {
-    ...ts3.getDefaultCompilerOptions(),
-    jsx: ts3.JsxEmit.React,
-    strict: true,
-    esModuleInterop: true,
-    module: ts3.ModuleKind.ESNext,
-    suppressOutputPathCheck: true,
-    skipLibCheck: true,
-    skipDefaultLibCheck: true,
-    moduleResolution: ts3.ModuleResolutionKind.Node10
-  };
-}
-__name(getDefaultCompilerOptions, "getDefaultCompilerOptions");
-async function createVirtualProgram(rootNames, context, compilerOptions = {}) {
-  const options = defu4(compilerOptions, getDefaultCompilerOptions());
-  const host = {
-    name: "storm-vfs",
-    root: context.workspaceConfig.workspaceRoot,
-    ...ts3.sys,
-    realpath: /* @__PURE__ */ __name((path2) => {
-      if (context.fs.existsSync(path2)) {
-        return context.fs.resolvePath(path2);
-      }
-      return ts3.sys.realpath?.(path2) ?? path2;
-    }, "realpath"),
-    getCurrentDirectory() {
-      return context.workspaceConfig.workspaceRoot;
-    },
-    getCanonicalFileName(fileName) {
-      return fileName;
-    },
-    getDefaultLibFileName(_options) {
-      return ts3.getDefaultLibFileName(options);
-    },
-    getDefaultLibLocation() {
-      return "/";
-    },
-    getNewLine() {
-      return "\n";
-    },
-    useCaseSensitiveFileNames() {
-      return true;
-    },
-    fileExists(fileName) {
-      return context.fs.existsSync(fileName);
-    },
-    readFile(fileName) {
-      if (context.fs.existsSync(fileName)) {
-        return context.fs.readFileSync(fileName);
-      }
-      return void 0;
-    },
-    readDirectory: /* @__PURE__ */ __name((path2, extensions = [], exclude = [], include = []) => {
-      let results = [];
-      if (context.fs.existsSync(path2)) {
-        results = context.fs.readdirSync(path2, {
-          encoding: "utf8",
-          recursive: true
-        });
-        if (extensions.length > 0) {
-          results = results.filter((file) => extensions.some((ext) => file.endsWith(ext.startsWith(".") ? ext : `.${ext}`)));
-        }
-        if (exclude.length > 0) {
-          results = results.filter((file) => !exclude.some((pattern) => minimatch(file, pattern)));
-        }
-        if (include.length > 0) {
-          results = results.filter((file) => include.some((pattern) => minimatch(file, pattern)));
-        }
-      }
-      return results;
-    }, "readDirectory"),
-    writeFile(fileName, data) {
-      context.fs.writeFileSync(fileName, data);
-    },
-    resolvePath: /* @__PURE__ */ __name((fileName) => {
-      if (context.fs.existsSync(fileName)) {
-        return context.fs.resolvePath(fileName);
-      }
-      return ts3.sys.resolvePath(fileName);
-    }, "resolvePath"),
-    getSourceFile(fileName, languageVersionOrOptions, _, shouldCreateNewSourceFile) {
-      if (context.fs.existsSync(fileName)) {
-        return ts3.createSourceFile(fileName, context.fs.readFileSync(fileName), languageVersionOrOptions ?? compilerOptions.target ?? getDefaultCompilerOptions().target, false);
-      } else if (shouldCreateNewSourceFile) {
-        const sourceFile = ts3.createSourceFile(fileName, "", languageVersionOrOptions ?? compilerOptions.target ?? getDefaultCompilerOptions().target, false);
-        context.fs.writeFileSync(fileName, sourceFile.text);
-        return sourceFile;
-      }
-      return void 0;
-    }
-  };
-  return ts3.createProgram(rootNames, options, host);
-}
-__name(createVirtualProgram, "createVirtualProgram");
-
-// ../powerlines/src/internal/helpers/tsc.ts
-async function typeCheck(context, sources) {
-  if (sources) {
-    await Promise.all(sources.entries().map(async ([path2, content]) => context.fs.writeFile(path2, content)));
-  }
-  const program = await createVirtualProgram(sources ? Array.from(sources.keys()) : [], context, {
-    noEmit: true,
-    lib: [
-      "lib.esnext.d.ts"
-    ],
-    types: []
-  });
-  const emitResult = program.emit();
-  const allDiagnostics = ts3.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
-  allDiagnostics.forEach((diagnostic) => {
-    if (diagnostic.file) {
-      const { line, character } = ts3.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
-      const message = ts3.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-      context.log(LogLevelLabel.ERROR, `${diagnostic.file.fileName}:${line + 1}:${character + 1} : ${message}`);
-    } else {
-      context.log(LogLevelLabel.ERROR, ts3.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
-    }
-  });
-}
-__name(typeCheck, "typeCheck");
 
 // ../powerlines/src/internal/api.ts
 var PowerlinesAPI = class _PowerlinesAPI {
@@ -3378,11 +2911,7 @@ ${formatLogMessage(context.config)}`);
     await this.prepare(inlineConfig);
     await this.#executeEnvironments(async (context) => {
       if (context.config.lint !== false) {
-        await this.callPreHook(context, "lint");
-        await typeCheck(context);
-        await eslint(context, true, context.config.lint.eslint);
-        await this.callNormalHook(context, "lint");
-        await this.callPostHook(context, "lint");
+        await this.callHook(context, "lint");
       }
     });
     this.context.log(LogLevelLabel.TRACE, "Powerlines linting completed");
@@ -3732,9 +3261,9 @@ var DEFAULT_ESBUILD_CONFIG = {
 function extractESBuildConfig(context) {
   return defu4({
     alias: context.fs.builtinIdMap.keys().reduce((ret, id) => {
-      const path2 = context.fs.builtinIdMap.get(id);
-      if (path2) {
-        ret[id] = path2;
+      const path = context.fs.builtinIdMap.get(id);
+      if (path) {
+        ret[id] = path;
       }
       return ret;
     }, {})
@@ -3776,9 +3305,9 @@ function extractViteConfig(context) {
   return defu4({
     resolve: {
       alias: context.fs.builtinIdMap.keys().reduce((ret, id) => {
-        const path2 = context.fs.builtinIdMap.get(id);
-        if (path2) {
-          ret[id] = path2;
+        const path = context.fs.builtinIdMap.get(id);
+        if (path) {
+          ret[id] = path;
         }
         return ret;
       }, {})