@adonisjs/assembler 8.0.0-next.9 → 8.0.1

package/build/index.js

@@ -1,376 +1,154 @@
-import {
-  FileBuffer,
-  IndexGenerator
-} from "./chunk-7XU453QB.js";
-import {
-  VirtualFileSystem,
-  copyFiles,
-  debug_default,
-  getPort,
-  loadHooks,
-  memoize,
-  parseConfig,
-  run,
-  runNode,
-  throttle,
-  watch
-} from "./chunk-PORDZS62.js";
-
-// src/hooks.ts
-var hooks = {
-  /**
-   * Hook called during application initialization. This is the first hook
-   * that gets executed when the assembler starts up.
-   *
-   * @param callback - Function to execute when the init event occurs
-   *
-   * @example
-   * ```js
-   * hooks.init((app) => {
-   *   console.log('Application is initializing')
-   *   // Setup global configurations
-   * })
-   * ```
-   */
-  init(callback) {
-    return callback;
-  },
-  /**
-   * Hook called after routes have been committed to the router.
-   * This occurs after all route definitions have been processed.
-   *
-   * @param callback - Function to execute when routes are committed
-   *
-   * @example
-   * ```js
-   * hooks.routesCommitted((router) => {
-   *   console.log('All routes have been committed to the router')
-   *   // Perform route-based setup
-   * })
-   * ```
-   */
-  routesCommitted(callback) {
-    return callback;
-  },
-  /**
-   * Hook called when the assembler starts scanning for route files.
-   * This happens before any route files are actually processed.
-   *
-   * @param callback - Function to execute when route scanning begins
-   *
-   * @example
-   * ```js
-   * hooks.routesScanning(() => {
-   *   console.log('Starting to scan for route files')
-   *   // Setup route scanning configurations
-   * })
-   * ```
-   */
-  routesScanning(callback) {
-    return callback;
-  },
-  /**
-   * Hook called after all route files have been scanned and processed.
-   * This occurs once the route scanning phase is complete.
-   *
-   * @param callback - Function to execute when route scanning is finished
-   *
-   * @example
-   * ```js
-   * hooks.routesScanned((scannedRoutes) => {
-   *   console.log('Route scanning completed')
-   *   // Process scanned route information
-   * })
-   * ```
-   */
-  routesScanned(callback) {
-    return callback;
-  },
-  /**
-   * Hook called when a file is modified during development.
-   * This is triggered by the file watcher when changes are detected.
-   *
-   * @param callback - Function to execute when a file changes
-   *
-   * @example
-   * ```js
-   * hooks.fileChanged((filePath, stats) => {
-   *   console.log(`File changed: ${filePath}`)
-   *   // Handle file change logic
-   * })
-   * ```
-   */
-  fileChanged(callback) {
-    return callback;
-  },
-  /**
-   * Hook called when a new file is added during development.
-   * This is triggered by the file watcher when new files are created.
-   *
-   * @param callback - Function to execute when a file is added
-   *
-   * @example
-   * ```js
-   * hooks.fileAdded((filePath, stats) => {
-   *   console.log(`New file added: ${filePath}`)
-   *   // Handle new file logic
-   * })
-   * ```
-   */
-  fileAdded(callback) {
-    return callback;
-  },
-  /**
-   * Hook called when a file is removed during development.
-   * This is triggered by the file watcher when files are deleted.
-   *
-   * @param callback - Function to execute when a file is removed
-   *
-   * @example
-   * ```js
-   * hooks.fileRemoved((filePath) => {
-   *   console.log(`File removed: ${filePath}`)
-   *   // Handle file removal logic
-   * })
-   * ```
-   */
-  fileRemoved(callback) {
-    return callback;
-  },
-  /**
-   * Hook called when the development server is about to start.
-   * This occurs before the server begins listening for connections.
-   *
-   * @param callback - Function to execute when dev server is starting
-   *
-   * @example
-   * ```js
-   * hooks.devServerStarting((server) => {
-   *   console.log('Development server is starting')
-   *   // Setup server configurations
-   * })
-   * ```
-   */
-  devServerStarting(callback) {
-    return callback;
-  },
-  /**
-   * Hook called after the development server has successfully started.
-   * This occurs once the server is listening and ready to accept requests.
-   *
-   * @param callback - Function to execute when dev server has started
-   *
-   * @example
-   * ```js
-   * hooks.devServerStarted((server) => {
-   *   console.log(`Development server started on port ${server.port}`)
-   *   // Notify external services or open browser
-   * })
-   * ```
-   */
-  devServerStarted(callback) {
-    return callback;
-  },
-  /**
-   * Hook called when the build process is about to start.
-   * This occurs before any build tasks are executed.
-   *
-   * @param callback - Function to execute when build is starting
-   *
-   * @example
-   * ```js
-   * hooks.buildStarting((buildConfig) => {
-   *   console.log('Build process is starting')
-   *   // Setup build configurations or clean directories
-   * })
-   * ```
-   */
-  buildStarting(callback) {
-    return callback;
-  },
-  /**
-   * Hook called after the build process has completed.
-   * This occurs once all build tasks have finished executing.
-   *
-   * @param callback - Function to execute when build is finished
-   *
-   * @example
-   * ```js
-   * hooks.buildFinished((buildResult) => {
-   *   console.log('Build process completed')
-   *   // Deploy artifacts or notify build completion
-   * })
-   * ```
-   */
-  buildFinished(callback) {
-    return callback;
-  },
-  /**
-   * Hook called when the test suite is about to start.
-   * This occurs before any test files are executed.
-   *
-   * @param callback - Function to execute when tests are starting
-   *
-   * @example
-   * ```js
-   * hooks.testsStarting((testConfig) => {
-   *   console.log('Test suite is starting')
-   *   // Setup test database or mock services
-   * })
-   * ```
-   */
-  testsStarting(callback) {
-    return callback;
-  },
-  /**
-   * Hook called after the test suite has completed.
-   * This occurs once all test files have finished executing.
-   *
-   * @param callback - Function to execute when tests are finished
-   *
-   * @example
-   * ```js
-   * hooks.testsFinished((testResults) => {
-   *   console.log('Test suite completed')
-   *   // Generate test reports or cleanup test resources
-   * })
-   * ```
-   */
-  testsFinished(callback) {
-    return callback;
-  }
-};
-
-// src/bundler.ts
+import "./chunk-DF48asd8.js";
+import { a as loadHooks, c as readTsConfig, d as runNode, f as throttle, m as debug_default, n as copyFiles, o as memoize, p as watch, r as getPort, s as parseConfig, t as VirtualFileSystem, u as run } from "./virtual_file_system-dzfXNwEp.js";
+import { n as FileBuffer, t as IndexGenerator } from "./main-INOi9swJ.js";
+import { t as RoutesScanner } from "./main-Cpfvmdw6.js";
+import { t as CodemodException } from "./codemod_exception-BMNJZ0i1.js";
 import dedent from "dedent";
-import fs from "fs/promises";
+import fs, { readFile, unlink } from "node:fs/promises";
 import { cliui } from "@poppinss/cliui";
-import { fileURLToPath } from "url";
+import { fileURLToPath } from "node:url";
 import string from "@poppinss/utils/string";
-import { join, relative } from "path/posix";
+import { join, relative } from "node:path/posix";
 import { detectPackageManager } from "@antfu/install-pkg";
-var SUPPORTED_PACKAGE_MANAGERS = {
-  "npm": {
-    packageManagerFiles: ["package-lock.json"],
-    installCommand: 'npm ci --omit="dev"'
-  },
-  "yarn": {
-    packageManagerFiles: ["yarn.lock"],
-    installCommand: "yarn install --production"
-  },
-  "yarn@berry": {
-    packageManagerFiles: ["yarn.lock", ".yarn/**/*", ".yarnrc.yml"],
-    installCommand: "yarn workspaces focus --production"
-  },
-  "pnpm": {
-    packageManagerFiles: ["pnpm-lock.yaml"],
-    installCommand: "pnpm i --prod"
-  },
-  "bun": {
-    packageManagerFiles: ["bun.lockb"],
-    installCommand: "bun install --production"
-  }
+import getRandomPort from "get-port";
+import picomatch from "picomatch";
+import prettyHrtime from "pretty-hrtime";
+import { RuntimeException } from "@poppinss/utils/exception";
+//#region src/bundler.ts
+/**
+* List of package managers we support in order to
+* copy lockfiles
+*/
+const SUPPORTED_PACKAGE_MANAGERS = {
+	"npm": {
+		packageManagerFiles: ["package-lock.json"],
+		installCommand: "npm ci --omit=\"dev\""
+	},
+	"yarn": {
+		packageManagerFiles: ["yarn.lock"],
+		installCommand: "yarn install --production"
+	},
+	"yarn@berry": {
+		packageManagerFiles: [
+			"yarn.lock",
+			".yarn/**/*",
+			".yarnrc.yml"
+		],
+		installCommand: "yarn workspaces focus --production"
+	},
+	"pnpm": {
+		packageManagerFiles: ["pnpm-lock.yaml"],
+		installCommand: "pnpm i --prod"
+	},
+	"bun": {
+		packageManagerFiles: ["bun.lockb"],
+		installCommand: "bun install --production"
+	}
 };
+/**
+* The bundler class exposes the API to build an AdonisJS project.
+*
+* @example
+* const bundler = new Bundler(new URL('./'), ts, { hooks: [] })
+* const success = await bundler.bundle()
+*/
 var Bundler = class {
-  /**
-   * Reference to the TypeScript module
-   */
-  #ts;
-  /**
-   * Hooks to execute custom actions during the build process
-   */
-  #hooks;
-  /**
-   * Index generator for managing auto-generated index files
-   */
-  #indexGenerator;
-  /**
-   * CLI UI instance for displaying colorful messages and progress information
-   */
-  ui = cliui();
-  /**
-   * The current working directory URL
-   */
-  cwd;
-  /**
-   * The current working project directory path as string
-   */
-  cwdPath;
-  /**
-   * Bundler configuration options including hooks and meta files
-   */
-  options;
-  /**
-   * Create a new bundler instance
-   *
-   * @param cwd - The current working directory URL
-   * @param ts - TypeScript module reference
-   * @param options - Bundler configuration options
-   */
-  constructor(cwd, ts, options) {
-    this.cwd = cwd;
-    this.options = options;
-    this.cwdPath = string.toUnixSlash(fileURLToPath(this.cwd));
-    this.#ts = ts;
-  }
-  /**
-   * Returns the relative unix path for an absolute
-   * file path
-   */
-  #getRelativeName(filePath) {
-    return string.toUnixSlash(relative(this.cwdPath, filePath));
-  }
-  /**
-   * Cleans up the build directory
-   */
-  async #cleanupBuildDirectory(outDir) {
-    await fs.rm(outDir, { recursive: true, force: true, maxRetries: 5 });
-  }
-  /**
-   * Runs tsc command to build the source.
-   */
-  async #runTsc(outDir) {
-    try {
-      await run(this.cwd, {
-        stdio: "inherit",
-        script: "tsc",
-        scriptArgs: ["--outDir", outDir]
-      });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Copy meta files to the output directory
-   */
-  async #copyMetaFiles(outDir, additionalFilesToCopy) {
-    const metaFiles = (this.options.metaFiles || []).map((file) => file.pattern).concat(additionalFilesToCopy);
-    await copyFiles(metaFiles, this.cwdPath, outDir);
-  }
-  /**
-   * Detect the package manager used by the project
-   */
-  async #detectPackageManager() {
-    const pkgManager = await detectPackageManager(this.cwdPath);
-    if (pkgManager === "deno") {
-      return "npm";
-    }
-    if (pkgManager === "pnpm@6") {
-      return "pnpm";
-    }
-    return pkgManager;
-  }
-  /**
-   * Rewrite the ace file since the original one
-   * is importing ts-node which is not installed
-   * in a production environment.
-   */
-  async #createAceFile(outDir) {
-    const aceFileLocation = join(outDir, "ace.js");
-    const aceFileContent = dedent(
-      /* JavaScript */
-      `
+	/**
+	* Reference to the TypeScript module
+	*/
+	#ts;
+	/**
+	* Hooks to execute custom actions during the build process
+	*/
+	#hooks;
+	/**
+	* Index generator for managing auto-generated index files
+	*/
+	#indexGenerator;
+	/**
+	* CLI UI instance for displaying colorful messages and progress information
+	*/
+	ui = cliui();
+	/**
+	* The current working directory URL
+	*/
+	cwd;
+	/**
+	* The current working project directory path as string
+	*/
+	cwdPath;
+	/**
+	* Bundler configuration options including hooks and meta files
+	*/
+	options;
+	/**
+	* Create a new bundler instance
+	*
+	* @param cwd - The current working directory URL
+	* @param ts - TypeScript module reference
+	* @param options - Bundler configuration options
+	*/
+	constructor(cwd, ts, options) {
+		this.cwd = cwd;
+		this.options = options;
+		this.cwdPath = string.toUnixSlash(fileURLToPath(this.cwd));
+		this.#ts = ts;
+	}
+	/**
+	* Returns the relative unix path for an absolute
+	* file path
+	*/
+	#getRelativeName(filePath) {
+		return string.toUnixSlash(relative(this.cwdPath, filePath));
+	}
+	/**
+	* Cleans up the build directory
+	*/
+	async #cleanupBuildDirectory(outDir) {
+		await fs.rm(outDir, {
+			recursive: true,
+			force: true,
+			maxRetries: 5
+		});
+	}
+	/**
+	* Runs tsc command to build the source.
+	*/
+	async #runTsc(outDir) {
+		try {
+			await run(this.cwd, {
+				stdio: "inherit",
+				script: "tsc",
+				scriptArgs: ["--outDir", outDir]
+			});
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Copy meta files to the output directory
+	*/
+	async #copyMetaFiles(outDir, additionalFilesToCopy) {
+		await copyFiles((this.options.metaFiles || []).map((file) => file.pattern).concat(additionalFilesToCopy), this.cwdPath, outDir);
+	}
+	/**
+	* Detect the package manager used by the project
+	*/
+	async #detectPackageManager() {
+		const pkgManager = await detectPackageManager(this.cwdPath);
+		if (pkgManager === "deno") return "npm";
+		if (pkgManager === "pnpm@6") return "pnpm";
+		return pkgManager;
+	}
+	/**
+	* Rewrite the ace file since the original one
+	* is importing ts-node which is not installed
+	* in a production environment.
+	*/
+	async #createAceFile(outDir) {
+		const aceFileLocation = join(outDir, "ace.js");
+		const aceFileContent = dedent(`
       /**
        * This file is auto-generated by the build process.
        * If you had any custom code inside this file, then
@@ -378,1368 +156,1720 @@ var Bundler = class {
        */
 
       await import('./bin/console.js')
-    `
-    );
-    await fs.writeFile(aceFileLocation, aceFileContent);
-    this.ui.logger.info("created ace file", { suffix: this.#getRelativeName(aceFileLocation) });
-  }
-  /**
-   * Bundles the application to be run in production
-   *
-   * @param stopOnError - Whether to stop the build process on TypeScript errors
-   * @param client - Override the detected package manager
-   * @returns Promise that resolves to true if build succeeded, false otherwise
-   *
-   * @example
-   * const success = await bundler.bundle(true, 'npm')
-   */
-  async bundle(stopOnError = true, client) {
-    this.packageManager = client ?? await this.#detectPackageManager() ?? "npm";
-    const config = parseConfig(this.cwd, this.#ts);
-    if (!config) {
-      return false;
-    }
-    this.ui.logger.info("loading hooks...");
-    this.#hooks = await loadHooks(this.options.hooks, ["init", "buildStarting", "buildFinished"]);
-    this.#indexGenerator = new IndexGenerator(this.cwdPath, this.ui.logger);
-    await this.#hooks.runner("init").run(this, this.#indexGenerator);
-    this.#hooks.clear("init");
-    this.ui.logger.info("generating indexes...");
-    await this.#indexGenerator.generate();
-    const outDir = config.options.outDir || fileURLToPath(new URL("build/", this.cwd));
-    this.ui.logger.info("cleaning up output directory", { suffix: this.#getRelativeName(outDir) });
-    await this.#cleanupBuildDirectory(outDir);
-    await this.#hooks.runner("buildStarting").run(this);
-    this.ui.logger.info("compiling typescript source", { suffix: "tsc" });
-    const buildCompleted = await this.#runTsc(outDir);
-    await this.#createAceFile(outDir);
-    if (!buildCompleted && stopOnError) {
-      await this.#cleanupBuildDirectory(outDir);
-      const instructions = this.ui.sticker().fullScreen().drawBorder((borderChar, colors) => colors.red(borderChar));
-      instructions.add(
-        this.ui.colors.red("Cannot complete the build process as there are TypeScript errors.")
-      );
-      instructions.add(
-        this.ui.colors.red(
-          'Use "--ignore-ts-errors" flag to ignore TypeScript errors and continue the build.'
-        )
-      );
-      this.ui.logger.logError(instructions.prepare());
-      return false;
-    }
-    const pkgFiles = [
-      "package.json",
-      ...SUPPORTED_PACKAGE_MANAGERS[this.packageManager].packageManagerFiles
-    ];
-    this.ui.logger.info("copying meta files to the output directory");
-    await this.#copyMetaFiles(outDir, pkgFiles);
-    this.ui.logger.success("build completed");
-    this.ui.logger.log("");
-    const displayMessage = this.ui.instructions().heading("Run the following commands to start the server in production");
-    await this.#hooks.runner("buildFinished").run(this, displayMessage);
-    displayMessage.add(this.ui.colors.cyan(`cd ${this.#getRelativeName(outDir)}`)).add(this.ui.colors.cyan(SUPPORTED_PACKAGE_MANAGERS[this.packageManager].installCommand)).add(this.ui.colors.cyan("node bin/server.js")).render();
-    return true;
-  }
+    `);
+		await fs.writeFile(aceFileLocation, aceFileContent);
+		this.ui.logger.info("created ace file", { suffix: this.#getRelativeName(aceFileLocation) });
+	}
+	/**
+	* Bundles the application to be run in production
+	*
+	* @param stopOnError - Whether to stop the build process on TypeScript errors
+	* @param client - Override the detected package manager
+	* @returns Promise that resolves to true if build succeeded, false otherwise
+	*
+	* @example
+	* const success = await bundler.bundle(true, 'npm')
+	*/
+	async bundle(stopOnError = true, client) {
+		this.packageManager = client ?? await this.#detectPackageManager() ?? "npm";
+		/**
+		* Step 1: Parse config file to get the build output directory
+		*/
+		const config = parseConfig(this.cwd, this.#ts);
+		if (!config) return false;
+		this.ui.logger.info("loading hooks...");
+		this.#hooks = await loadHooks(this.options.hooks, [
+			"init",
+			"buildStarting",
+			"buildFinished"
+		]);
+		this.#indexGenerator = new IndexGenerator(this.cwdPath, this.ui.logger);
+		/**
+		* Step 2: Run init hook and the index generator
+		*/
+		await this.#hooks.runner("init").run(this, this.#hooks, this.#indexGenerator);
+		this.#hooks.clear("init");
+		this.ui.logger.info("generating indexes...");
+		await this.#indexGenerator.generate();
+		/**
+		* Step 3: Cleanup existing build directory (if any)
+		*/
+		const outDir = config.options.outDir || fileURLToPath(new URL("build/", this.cwd));
+		this.ui.logger.info("cleaning up output directory", { suffix: this.#getRelativeName(outDir) });
+		await this.#cleanupBuildDirectory(outDir);
+		/**
+		* Step 4: Execute build starting hook
+		*/
+		await this.#hooks.runner("buildStarting").run(this);
+		/**
+		* Step 5: Build typescript source code
+		*/
+		this.ui.logger.info("compiling typescript source", { suffix: "tsc" });
+		const buildCompleted = await this.#runTsc(outDir);
+		await this.#createAceFile(outDir);
+		/**
+		* Remove incomplete build directory when tsc build
+		* failed and stopOnError is set to true.
+		*/
+		if (!buildCompleted && stopOnError) {
+			await this.#cleanupBuildDirectory(outDir);
+			const instructions = this.ui.sticker().fullScreen().drawBorder((borderChar, colors) => colors.red(borderChar));
+			instructions.add(this.ui.colors.red("Cannot complete the build process as there are TypeScript errors."));
+			instructions.add(this.ui.colors.red("Use \"--ignore-ts-errors\" flag to ignore TypeScript errors and continue the build."));
+			this.ui.logger.logError(instructions.prepare());
+			return false;
+		}
+		/**
+		* Step 6: Copy meta files to the build directory
+		*/
+		const pkgFiles = ["package.json", ...SUPPORTED_PACKAGE_MANAGERS[this.packageManager].packageManagerFiles];
+		this.ui.logger.info("copying meta files to the output directory");
+		await this.#copyMetaFiles(outDir, pkgFiles);
+		this.ui.logger.success("build completed");
+		this.ui.logger.log("");
+		const displayMessage = this.ui.instructions().heading("Run the following commands to start the server in production");
+		/**
+		* Step 7: Execute build completed hook
+		*/
+		await this.#hooks.runner("buildFinished").run(this, displayMessage);
+		/**
+		* Display next steps
+		*/
+		displayMessage.add(this.ui.colors.cyan(`cd ${this.#getRelativeName(outDir)}`)).add(this.ui.colors.cyan(SUPPORTED_PACKAGE_MANAGERS[this.packageManager].installCommand)).add(this.ui.colors.cyan("node bin/server.js")).render();
+		return true;
+	}
 };
-
-// src/dev_server.ts
-import { cliui as cliui2 } from "@poppinss/cliui";
-import prettyHrtime from "pretty-hrtime";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import string3 from "@poppinss/utils/string";
-import { join as join2, relative as relative3 } from "path/posix";
-import { RuntimeException } from "@poppinss/utils/exception";
-
-// src/file_system.ts
-import picomatch from "picomatch";
-import { relative as relative2 } from "path/posix";
-import string2 from "@poppinss/utils/string";
-var DEFAULT_INCLUDES = ["**/*"];
-var ALWAYS_EXCLUDE = [".git/**", "coverage/**", ".github/**", ".adonisjs/**"];
-var DEFAULT_EXCLUDES = ["node_modules/**", "bower_components/**", "jspm_packages/**"];
+//#endregion
+//#region src/file_system.ts
+const DEFAULT_INCLUDES = ["**/*"];
+const ALWAYS_EXCLUDE = [
+	".git/**",
+	"coverage/**",
+	".github/**",
+	".adonisjs/**",
+	"tmp/**",
+	"storage/**",
+	"build/**"
+];
+const DEFAULT_EXCLUDES = [
+	"node_modules/**",
+	"bower_components/**",
+	"jspm_packages/**"
+];
+/**
+* Exposes an intutive API to run actions when different kind of files
+* are changed. The FileSystem is built around the vocabulary used by
+* AdonisJS. Which includes:
+*
+* - Source files: TypeScript, JavaScript, JSON, JSX, TSX files that are included
+*   inside the "tsconfig.json" file are considered as source files.
+* - Meta files: Files registered under the "metaFiles" array of "adonisrc.ts" file
+*   are called meta files.
+* - Meta restart files: Meta files with "restart: true" enabled are called meta restart
+*   files.
+*
+* Using FileSystem you can register actions to be executed when a file changes in
+* one of the above categories.
+*
+* @example
+* const fs = new FileSystem(cwd, tsConfig, rcFile)
+* const file = fs.inspect('./app/controllers/users_controller.ts')
+*/
 var FileSystem = class {
-  /**
-   * The current working project directory
-   */
-  #cwd;
-  /**
-   * Referenced to the parsed ts config file. We use it to read the includes,
-   * excludes and pre-scanned files.
-   */
-  #tsConfig;
-  /**
-   * Set of pre-scanned typeScript files provided by tsconfig
-   */
-  #scannedTypeScriptFiles = /* @__PURE__ */ new Set();
-  /**
-   * Picomatch matcher function to know if a file path is
-   * part of includes
-   */
-  #isIncluded;
-  /**
-   * Picomatch matcher function to know if a file path is
-   * part of excludes
-   */
-  #isExcluded;
-  /**
-   * Picomatch matcher function to know if a file path is a
-   * meta file with reloadServer option enabled
-   */
-  #isMetaFileWithReloadsEnabled;
-  /**
-   * Picomatch matcher function to know if a file path is a
-   * meta file with reloadServer option disabled
-   */
-  #isMetaFileWithReloadsDisabled;
-  /**
-   * Picomatch matcher function to know if a file path is a
-   * test file or not
-   */
-  #isTestFile;
-  /**
-   * References to includes and excludes glob patterns
-   */
-  #includes;
-  #excludes;
-  /**
-   * Includes glob patterns extracted from "tsconfig.json" file.
-   * Defaults to: ["**\/*"]
-   */
-  get includes() {
-    return this.#includes;
-  }
-  /**
-   * Excludes glob patterns extracted from "tsconfig.json" file.
-   *
-   * Defaults to: [
-   *   'node_modules/**',
-   *   'bower_components/**',
-   *   'jspm_packages/**,
-   * ]
-   *
-   * Following patterns are always ignored
-   *
-   * '.git/**', 'coverage/**', '.github/**'
-   */
-  get excludes() {
-    return this.#excludes;
-  }
-  /**
-   * Inspect a file path to determine its type and properties within the project.
-   *
-   * This method analyzes a file to categorize it as a script file, test file, or meta file,
-   * and determines whether changes to the file should trigger server restarts. Results
-   * are memoized for performance optimization.
-   *
-   * @param absolutePath - The absolute Unix path to the file
-   * @param relativePath - The relative Unix path from the project root
-   * @returns File inspection result or null if the file should be ignored
-   *
-   * @example
-   * const file = fileSystem.inspect('/project/app/models/user.ts', 'app/models/user.ts')
-   * if (file) {
-   *   console.log(file.fileType) // 'script'
-   *   console.log(file.reloadServer) // true
-   * }
-   */
-  inspect = memoize((absolutePath, relativePath) => {
-    relativePath = relativePath ?? relative2(this.#cwd, absolutePath);
-    if (this.#isScriptFile(relativePath) && (this.#scannedTypeScriptFiles.has(absolutePath) || this.#isPartOfBackendProject(relativePath))) {
-      debug_default('backend project file "%s"', relativePath);
-      const isTestFile = this.#isTestFile(relativePath);
-      return {
-        fileType: isTestFile ? "test" : "script",
-        reloadServer: !isTestFile,
-        unixRelativePath: relativePath,
-        unixAbsolutePath: absolutePath
-      };
-    }
-    if (this.#isMetaFileWithReloadsEnabled(relativePath)) {
-      debug_default('meta file "%s"', relativePath);
-      return {
-        fileType: "meta",
-        reloadServer: true,
-        unixRelativePath: relativePath,
-        unixAbsolutePath: absolutePath
-      };
-    }
-    if (this.#isMetaFileWithReloadsDisabled(relativePath)) {
-      debug_default('meta file "%s"', relativePath);
-      return {
-        fileType: "meta",
-        reloadServer: false,
-        unixRelativePath: relativePath,
-        unixAbsolutePath: absolutePath
-      };
-    }
-    debug_default('ignored file "%s"', relativePath);
-    return null;
-  });
-  /**
-   * Determines if a directory should be watched by the file watcher.
-   *
-   * This method checks if a directory should be monitored for file changes
-   * based on the TypeScript configuration includes/excludes patterns.
-   * Results are memoized for performance. Chokidar sends absolute Unix paths.
-   *
-   * Note: Use shouldWatchFile for files and this method for directories only.
-   *
-   * @param absolutePath - The absolute Unix path to the directory
-   * @returns True if the directory should be watched
-   *
-   * @example
-   * const shouldWatch = fileSystem.shouldWatchDirectory('/project/app/controllers')
-   * console.log(shouldWatch) // true
-   */
-  shouldWatchDirectory = memoize((absolutePath) => {
-    if (absolutePath === this.#cwd) {
-      debug_default("watching project root");
-      return true;
-    }
-    const relativePath = relative2(this.#cwd, absolutePath);
-    if (this.#isExcluded(relativePath)) {
-      debug_default('watching "%s"', absolutePath);
-      return false;
-    }
-    return true;
-  });
-  /**
-   * Create a new FileSystem instance
-   *
-   * @param cwd - The current working directory URL or string path
-   * @param tsConfig - Parsed TypeScript configuration
-   * @param rcFile - AdonisJS RC file configuration
-   */
-  constructor(cwd, tsConfig, rcFile) {
-    this.#cwd = cwd;
-    this.#tsConfig = tsConfig;
-    const files = tsConfig.fileNames;
-    const metaFiles = rcFile.metaFiles ?? [];
-    const testSuites = rcFile.suites ?? [];
-    const outDir = tsConfig.raw.compilerOptions?.outDir;
-    for (const file of files) {
-      this.#scannedTypeScriptFiles.add(string2.toUnixSlash(file));
-    }
-    this.#includes = tsConfig.raw.include || DEFAULT_INCLUDES;
-    this.#excludes = ALWAYS_EXCLUDE.concat(
-      tsConfig.raw.exclude || (outDir ? DEFAULT_EXCLUDES.concat(outDir) : DEFAULT_EXCLUDES)
-    );
-    const metaFilesWithReloads = [];
-    const metaFilesWithoutReloads = [];
-    for (const file of metaFiles) {
-      if (file.reloadServer) {
-        metaFilesWithReloads.push(file.pattern);
-      } else {
-        metaFilesWithoutReloads.push(file.pattern);
-      }
-    }
-    const testFilePatterns = testSuites.flatMap((suite) => suite.files);
-    const picomatcchOptions = { cwd: this.#cwd };
-    this.#isMetaFileWithReloadsEnabled = picomatch(metaFilesWithReloads, picomatcchOptions);
-    this.#isMetaFileWithReloadsDisabled = picomatch(metaFilesWithoutReloads, picomatcchOptions);
-    this.#isTestFile = picomatch(testFilePatterns, picomatcchOptions);
-    this.#isIncluded = picomatch(this.#includes, picomatcchOptions);
-    this.#isExcluded = picomatch(this.#excludes, picomatcchOptions);
-    debug_default("initiating file system %O", {
-      includes: this.#includes,
-      excludes: this.#excludes,
-      outDir,
-      files,
-      metaFiles,
-      testSuites
-    });
-  }
-  /**
-   * Determines if a file path represents a script file based on TypeScript configuration.
-   *
-   * Script files are those that can be processed by the TypeScript compiler:
-   * - Files ending with ".ts" or ".tsx" (excluding ".d.ts" declaration files)
-   * - Files ending with ".js" when "allowJs" option is enabled in tsconfig
-   * - Files ending with ".json" when "resolveJsonModule" option is enabled in tsconfig
-   *
-   * @param relativePath - The relative file path to check
-   * @returns True if the file is a script file
-   */
-  #isScriptFile(relativePath) {
-    if ((relativePath.endsWith(".ts") || relativePath.endsWith(".tsx")) && !relativePath.endsWith(".d.ts")) {
-      return true;
-    }
-    if (this.#tsConfig.options.allowJs && relativePath.endsWith(".js")) {
-      return true;
-    }
-    if (this.#tsConfig.options.resolveJsonModule && relativePath.endsWith(".json")) {
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Checks if a file path is part of the backend TypeScript project.
-   *
-   * Uses TypeScript configuration "includes", "excludes", and "files" paths
-   * to determine if a file should be considered part of the project compilation.
-   *
-   * @param relativePath - The relative file path to check
-   * @returns True if the file is part of the backend project
-   */
-  #isPartOfBackendProject(relativePath) {
-    if (this.#isExcluded(relativePath)) {
-      debug_default('excluded by tsconfig "%s"', relativePath);
-      return false;
-    }
-    if (this.#isIncluded(relativePath)) {
-      debug_default('included by tsconfig "%s"', relativePath);
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Returns true if the file should be watched. Chokidar sends
-   * absolute unix paths to the ignored callback.
-   *
-   * You must use "shouldWatchDirectory" method for directories and call
-   * this method for files only.
-   *
-   * @param absolutePath - The absolute path to the file
-   * @returns True if the file should be watched
-   */
-  shouldWatchFile(absolutePath) {
-    return this.inspect(absolutePath) !== null;
-  }
+	/**
+	* The current working project directory
+	*/
+	#cwd;
+	/**
+	* Referenced to the parsed ts config file. We use it to read the includes,
+	* excludes and pre-scanned files.
+	*/
+	#tsConfig;
+	/**
+	* Set of pre-scanned typeScript files provided by tsconfig
+	*/
+	#scannedTypeScriptFiles = /* @__PURE__ */ new Set();
+	/**
+	* Picomatch matcher function to know if a file path is
+	* part of includes
+	*/
+	#isIncluded;
+	/**
+	* Picomatch matcher function to know if a file path is
+	* part of excludes
+	*/
+	#isExcluded;
+	/**
+	* Picomatch matcher function to know if a file path is a
+	* meta file with reloadServer option enabled
+	*/
+	#isMetaFileWithReloadsEnabled;
+	/**
+	* Picomatch matcher function to know if a file path is a
+	* meta file with reloadServer option disabled
+	*/
+	#isMetaFileWithReloadsDisabled;
+	/**
+	* Picomatch matcher function to know if a file path is a
+	* test file or not
+	*/
+	#isTestFile;
+	/**
+	* References to includes and excludes glob patterns
+	*/
+	#includes;
+	#excludes;
+	/**
+	* Includes glob patterns extracted from "tsconfig.json" file.
+	* Defaults to: ["**\/*"]
+	*/
+	get includes() {
+		return this.#includes;
+	}
+	/**
+	* Excludes glob patterns extracted from "tsconfig.json" file.
+	*
+	* Defaults to: [
+	*   'node_modules/**',
+	*   'bower_components/**',
+	*   'jspm_packages/**,
+	* ]
+	*
+	* Following patterns are always ignored
+	*
+	* '.git/**', 'coverage/**', '.github/**', '.adonisjs/**', 'tmp/**', 'storage/**', 'build/**'
+	*/
+	get excludes() {
+		return this.#excludes;
+	}
+	/**
+	* Inspect a file path to determine its type and properties within the project.
+	*
+	* This method analyzes a file to categorize it as a script file, test file, or meta file,
+	* and determines whether changes to the file should trigger server restarts. Results
+	* are memoized for performance optimization.
+	*
+	* @param absolutePath - The absolute Unix path to the file
+	* @param relativePath - The relative Unix path from the project root
+	* @returns File inspection result or null if the file should be ignored
+	*
+	* @example
+	* const file = fileSystem.inspect('/project/app/models/user.ts', 'app/models/user.ts')
+	* if (file) {
+	*   console.log(file.fileType) // 'script'
+	*   console.log(file.reloadServer) // true
+	* }
+	*/
+	inspect = memoize((absolutePath, relativePath) => {
+		relativePath = relativePath ?? relative(this.#cwd, absolutePath);
+		/**
+		* If a file is a script file and part of the backend project, then we consider
+		* the file.
+		*
+		* Non script files are not checked inside the backend project, since there are
+		* anyways cannot be processed by TypeScript.
+		*/
+		if (this.#isScriptFile(relativePath) && (this.#scannedTypeScriptFiles.has(absolutePath) || this.#isPartOfBackendProject(relativePath))) {
+			debug_default("backend project file \"%s\"", relativePath);
+			const isTestFile = this.#isTestFile(relativePath);
+			return {
+				fileType: isTestFile ? "test" : "script",
+				reloadServer: !isTestFile,
+				unixRelativePath: relativePath,
+				unixAbsolutePath: absolutePath
+			};
+		}
+		/**
+		* Check for meta files with reload flag enabled
+		*/
+		if (this.#isMetaFileWithReloadsEnabled(relativePath)) {
+			debug_default("meta file \"%s\"", relativePath);
+			return {
+				fileType: "meta",
+				reloadServer: true,
+				unixRelativePath: relativePath,
+				unixAbsolutePath: absolutePath
+			};
+		}
+		/**
+		* Check for meta files with reload flag disabled
+		*/
+		if (this.#isMetaFileWithReloadsDisabled(relativePath)) {
+			debug_default("meta file \"%s\"", relativePath);
+			return {
+				fileType: "meta",
+				reloadServer: false,
+				unixRelativePath: relativePath,
+				unixAbsolutePath: absolutePath
+			};
+		}
+		debug_default("ignored file \"%s\"", relativePath);
+		return null;
+	});
+	/**
+	* Determines if a directory should be watched by the file watcher.
+	*
+	* This method checks if a directory should be monitored for file changes
+	* based on the TypeScript configuration includes/excludes patterns.
+	* Results are memoized for performance. Chokidar sends absolute Unix paths.
+	*
+	* Note: Use shouldWatchFile for files and this method for directories only.
+	*
+	* @param absolutePath - The absolute Unix path to the directory
+	* @returns True if the directory should be watched
+	*
+	* @example
+	* const shouldWatch = fileSystem.shouldWatchDirectory('/project/app/controllers')
+	* console.log(shouldWatch) // true
+	*/
+	shouldWatchDirectory = memoize((absolutePath) => {
+		/**
+		* Always watch the project root
+		*/
+		if (absolutePath === this.#cwd) {
+			debug_default("watching project root");
+			return true;
+		}
+		/**
+		* Ignore directories excluded by tsconfig.json file. If tsconfig excludes
+		* directories include by metaFiles, then its a mis-configuration and we
+		* should update excludes to be more specific.
+		*
+		* Overriding excludes via metaFiles patterns is close to impossible because
+		* of how undeterministic glob patterns are.
+		*/
+		const relativePath = relative(this.#cwd, absolutePath);
+		if (this.#isExcluded(relativePath)) {
+			debug_default("watching \"%s\"", absolutePath);
+			return false;
+		}
+		return true;
+	});
+	/**
+	* Create a new FileSystem instance
+	*
+	* @param cwd - The current working directory URL or string path
+	* @param tsConfig - Parsed TypeScript configuration
+	* @param rcFile - AdonisJS RC file configuration
+	*/
+	constructor(cwd, tsConfig, rcFile) {
+		this.#cwd = cwd;
+		this.#tsConfig = tsConfig;
+		const files = tsConfig.config.files ?? [];
+		const metaFiles = rcFile.metaFiles ?? [];
+		const testSuites = rcFile.suites ?? [];
+		const outDir = tsConfig.config.compilerOptions?.outDir;
+		/**
+		* Register files we know ahead of time
+		*/
+		for (const file of files) this.#scannedTypeScriptFiles.add(string.toUnixSlash(file));
+		/**
+		* Compute includes and excludes
+		*/
+		this.#includes = tsConfig.config.include || DEFAULT_INCLUDES;
+		this.#excludes = ALWAYS_EXCLUDE.concat(tsConfig.config.exclude || (outDir ? DEFAULT_EXCLUDES.concat(outDir) : DEFAULT_EXCLUDES));
+		/**
+		* Pre-compute meta file patterns to avoid repeated array operations
+		*/
+		const metaFilesWithReloads = [];
+		const metaFilesWithoutReloads = [];
+		for (const file of metaFiles) if (file.reloadServer) metaFilesWithReloads.push(file.pattern);
+		else metaFilesWithoutReloads.push(file.pattern);
+		const testFilePatterns = testSuites.flatMap((suite) => suite.files);
+		const picomatcchOptions = { cwd: this.#cwd };
+		/**
+		* Initiate picomatch matchers we will need to identify metafiles
+		*/
+		this.#isMetaFileWithReloadsEnabled = picomatch(metaFilesWithReloads, picomatcchOptions);
+		this.#isMetaFileWithReloadsDisabled = picomatch(metaFilesWithoutReloads, picomatcchOptions);
+		this.#isTestFile = picomatch(testFilePatterns, picomatcchOptions);
+		this.#isIncluded = picomatch(this.#includes, picomatcchOptions);
+		this.#isExcluded = picomatch(this.#excludes, picomatcchOptions);
+		debug_default("initiating file system %O", {
+			includes: this.#includes,
+			excludes: this.#excludes,
+			outDir,
+			files,
+			metaFiles,
+			testSuites
+		});
+	}
+	/**
+	* Determines if a file path represents a script file based on TypeScript configuration.
+	*
+	* Script files are those that can be processed by the TypeScript compiler:
+	* - Files ending with ".ts" or ".tsx" (excluding ".d.ts" declaration files)
+	* - Files ending with ".js" when "allowJs" option is enabled in tsconfig
+	* - Files ending with ".json" when "resolveJsonModule" option is enabled in tsconfig
+	*
+	* @param relativePath - The relative file path to check
+	* @returns True if the file is a script file
+	*/
+	#isScriptFile(relativePath) {
+		if ((relativePath.endsWith(".ts") || relativePath.endsWith(".tsx")) && !relativePath.endsWith(".d.ts")) return true;
+		if (this.#tsConfig.config.compilerOptions?.allowJs && relativePath.endsWith(".js")) return true;
+		if (this.#tsConfig.config.compilerOptions?.resolveJsonModule && relativePath.endsWith(".json")) return true;
+		return false;
+	}
+	/**
+	* Checks if a file path is part of the backend TypeScript project.
+	*
+	* Uses TypeScript configuration "includes", "excludes", and "files" paths
+	* to determine if a file should be considered part of the project compilation.
+	*
+	* @param relativePath - The relative file path to check
+	* @returns True if the file is part of the backend project
+	*/
+	#isPartOfBackendProject(relativePath) {
+		/**
+		* Script and non-script files can be excluded using tsconfig
+		*/
+		if (this.#isExcluded(relativePath)) {
+			debug_default("excluded by tsconfig \"%s\"", relativePath);
+			return false;
+		}
+		/**
+		* Return true when included
+		*/
+		if (this.#isIncluded(relativePath)) {
+			debug_default("included by tsconfig \"%s\"", relativePath);
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Returns true if the file should be watched. Chokidar sends
+	* absolute unix paths to the ignored callback.
+	*
+	* You must use "shouldWatchDirectory" method for directories and call
+	* this method for files only.
+	*
+	* @param absolutePath - The absolute path to the file
+	* @returns True if the file should be watched
+	*/
+	shouldWatchFile(absolutePath) {
+		return this.inspect(absolutePath) !== null;
+	}
 };
-
-// src/shortcuts_manager.ts
+//#endregion
+//#region src/shortcuts_manager.ts
+/**
+* Manages keyboard shortcuts for development server interaction.
+*
+* The ShortcutsManager provides a convenient way to handle keyboard inputs
+* during development, allowing users to restart servers, clear console,
+* open browsers, and perform other common development tasks through simple
+* key presses.
+*
+* @example
+* const shortcuts = new ShortcutsManager({
+*   logger: ui.logger,
+*   callbacks: {
+*     onRestart: () => server.restart(),
+*     onClear: () => console.clear(),
+*     onQuit: () => process.exit()
+*   }
+* })
+* shortcuts.setup()
+*/
 var ShortcutsManager = class {
-  /**
-   * Logger instance for displaying messages
-   */
-  #logger;
-  /**
-   * Callback functions for different keyboard shortcuts
-   */
-  #callbacks;
-  /**
-   * The server URL used for opening browser
-   */
-  #serverUrl;
-  /**
-   * Key press event handler function
-   */
-  #keyPressHandler;
-  /**
-   * Available keyboard shortcuts with their handlers
-   */
-  #shortcuts = [
-    {
-      key: "r",
-      description: "restart server",
-      handler: () => {
-        this.#logger.log("");
-        this.#logger.info("Manual restart triggered...");
-        this.#callbacks.onRestart();
-      }
-    },
-    {
-      key: "c",
-      description: "clear console",
-      handler: () => {
-        this.#callbacks.onClear();
-        this.#logger.info("Console cleared");
-      }
-    },
-    {
-      key: "o",
-      description: "open in browser",
-      handler: () => this.#handleOpenBrowser()
-    },
-    {
-      key: "h",
-      description: "show this help",
-      handler: () => this.showHelp()
-    }
-  ];
-  /**
-   * Create a new ShortcutsManager instance
-   *
-   * @param options - Configuration options for the shortcuts manager
-   */
-  constructor(options) {
-    this.#logger = options.logger;
-    this.#callbacks = options.callbacks;
-  }
-  /**
-   * Set server url for opening in browser
-   *
-   * This URL will be used when the user presses 'o' to open the
-   * development server in their default browser.
-   *
-   * @param url - The server URL to open when 'o' key is pressed
-   */
-  setServerUrl(url) {
-    this.#serverUrl = url;
-  }
-  /**
-   * Initialize keyboard shortcuts by setting up raw mode on stdin
-   *
-   * This method enables raw mode on stdin to capture individual keypresses
-   * and sets up the event listener for handling keyboard input. Only works
-   * in TTY environments.
-   */
-  setup() {
-    if (!process.stdin.isTTY) {
-      return;
-    }
-    process.stdin.setRawMode(true);
-    this.#keyPressHandler = (data) => this.#handleKeyPress(data.toString());
-    process.stdin.on("data", this.#keyPressHandler);
-  }
-  /**
-   * Handle key press events and execute corresponding shortcuts
-   *
-   * Processes individual key presses and matches them against registered
-   * shortcuts. Also handles special key combinations like Ctrl+C and Ctrl+D.
-   *
-   * @param key - The pressed key as a string
-   */
-  #handleKeyPress(key) {
-    if (key === "" || key === "") {
-      return this.#callbacks.onQuit();
-    }
-    const shortcut = this.#shortcuts.find((s) => s.key === key);
-    if (shortcut) {
-      shortcut.handler();
-    }
-  }
-  /**
-   * Handle opening browser with the configured server URL
-   *
-   * Uses the 'open' package to launch the default browser and navigate
-   * to the development server URL.
-   */
-  async #handleOpenBrowser() {
-    this.#logger.log("");
-    this.#logger.info(`Opening ${this.#serverUrl}...`);
-    const { default: open } = await import("open");
-    open(this.#serverUrl);
-  }
-  /**
-   * Show available keyboard shortcuts in the console
-   *
-   * Displays a formatted list of all available keyboard shortcuts
-   * and their descriptions to help users understand what actions
-   * are available.
-   */
-  showHelp() {
-    this.#logger.log("");
-    this.#logger.log("Available shortcuts:");
-    this.#shortcuts.forEach(({ key, description }) => this.#logger.log(`\xB7 ${key}: ${description}`));
-  }
-  /**
-   * Cleanup keyboard shortcuts and restore terminal state
-   *
-   * Disables raw mode on stdin, removes event listeners, and restores
-   * the terminal to its normal state. Should be called when shutting down
-   * the development server.
-   */
-  cleanup() {
-    if (!process.stdin.isTTY) {
-      return;
-    }
-    process.stdin.setRawMode(false);
-    process.stdin.pause();
-    process.stdin.unref();
-    process.stdin.removeListener("data", this.#keyPressHandler);
-    this.#keyPressHandler = void 0;
-  }
+	/**
+	* Logger instance for displaying messages
+	*/
+	#logger;
+	/**
+	* Callback functions for different keyboard shortcuts
+	*/
+	#callbacks;
+	/**
+	* The server URL used for opening browser
+	*/
+	#serverUrl;
+	/**
+	* Key press event handler function
+	*/
+	#keyPressHandler;
+	/**
+	* Available keyboard shortcuts with their handlers
+	*/
+	#shortcuts = [
+		{
+			key: "r",
+			description: "restart server",
+			handler: () => {
+				this.#logger.log("");
+				this.#logger.info("Manual restart triggered...");
+				this.#callbacks.onRestart();
+			}
+		},
+		{
+			key: "c",
+			description: "clear console",
+			handler: () => {
+				this.#callbacks.onClear();
+				this.#logger.info("Console cleared");
+			}
+		},
+		{
+			key: "o",
+			description: "open in browser",
+			handler: () => this.#handleOpenBrowser()
+		},
+		{
+			key: "h",
+			description: "show this help",
+			handler: () => this.showHelp()
+		}
+	];
+	/**
+	* Create a new ShortcutsManager instance
+	*
+	* @param options - Configuration options for the shortcuts manager
+	*/
+	constructor(options) {
+		this.#logger = options.logger;
+		this.#callbacks = options.callbacks;
+	}
+	/**
+	* Set server url for opening in browser
+	*
+	* This URL will be used when the user presses 'o' to open the
+	* development server in their default browser.
+	*
+	* @param url - The server URL to open when 'o' key is pressed
+	*/
+	setServerUrl(url) {
+		this.#serverUrl = url;
+	}
+	/**
+	* Initialize keyboard shortcuts by setting up raw mode on stdin
+	*
+	* This method enables raw mode on stdin to capture individual keypresses
+	* and sets up the event listener for handling keyboard input. Only works
+	* in TTY environments.
+	*/
+	setup() {
+		if (!process.stdin.isTTY) return;
+		process.stdin.setRawMode(true);
+		this.#keyPressHandler = (data) => this.#handleKeyPress(data.toString());
+		process.stdin.on("data", this.#keyPressHandler);
+	}
+	/**
+	* Handle key press events and execute corresponding shortcuts
+	*
+	* Processes individual key presses and matches them against registered
+	* shortcuts. Also handles special key combinations like Ctrl+C and Ctrl+D.
+	*
+	* @param key - The pressed key as a string
+	*/
+	#handleKeyPress(key) {
+		if (key === "" || key === "") return this.#callbacks.onQuit();
+		const shortcut = this.#shortcuts.find((s) => s.key === key);
+		if (shortcut) shortcut.handler();
+	}
+	/**
+	* Handle opening browser with the configured server URL
+	*
+	* Uses the 'open' package to launch the default browser and navigate
+	* to the development server URL.
+	*/
+	async #handleOpenBrowser() {
+		this.#logger.log("");
+		this.#logger.info(`Opening ${this.#serverUrl}...`);
+		const { default: open } = await import("open");
+		open(this.#serverUrl);
+	}
+	/**
+	* Show available keyboard shortcuts in the console
+	*
+	* Displays a formatted list of all available keyboard shortcuts
+	* and their descriptions to help users understand what actions
+	* are available.
+	*/
+	showHelp() {
+		this.#logger.log("");
+		this.#logger.log("Available shortcuts:");
+		this.#shortcuts.forEach(({ key, description }) => this.#logger.log(`· ${key}: ${description}`));
+	}
+	/**
+	* Cleanup keyboard shortcuts and restore terminal state
+	*
+	* Disables raw mode on stdin, removes event listeners, and restores
+	* the terminal to its normal state. Should be called when shutting down
+	* the development server.
+	*/
+	cleanup() {
+		if (!process.stdin.isTTY) return;
+		process.stdin.setRawMode(false);
+		process.stdin.pause();
+		process.stdin.unref();
+		process.stdin.removeListener("data", this.#keyPressHandler);
+		this.#keyPressHandler = void 0;
+	}
 };
-
-// src/dev_server.ts
-var DevServer = class _DevServer {
-  /**
-   * Pre-allocated info object for hot-hook change events to avoid repeated object creation
-   */
-  static #HOT_HOOK_CHANGE_INFO = {
-    source: "hot-hook",
-    fullReload: false,
-    hotReloaded: false
-  };
-  /**
-   * Pre-allocated info object for hot-hook full reload events
-   */
-  static #HOT_HOOK_FULL_RELOAD_INFO = {
-    source: "hot-hook",
-    fullReload: true,
-    hotReloaded: false
-  };
-  /**
-   * Pre-allocated info object for hot-hook invalidation events
-   */
-  static #HOT_HOOK_INVALIDATED_INFO = {
-    source: "hot-hook",
-    fullReload: false,
-    hotReloaded: true
-  };
-  /**
-   * Pre-allocated info object for file watcher events
-   */
-  static #WATCHER_INFO = {
-    source: "watcher",
-    fullReload: true,
-    hotReloaded: false
-  };
-  /**
-   * External listeners that are invoked when child process
-   * gets an error or closes
-   */
-  #onError;
-  #onClose;
-  /**
-   * The stickyPort is set by the start and the startAndWatch methods
-   * and we will continue to use that port during restart
-   */
-  #stickyPort;
-  /**
-   * The mode is set by the start and the startAndWatch methods
-   */
-  #mode = "static";
-  /**
-   * Reference to chokidar watcher
-   */
-  #watcher;
-  /**
-   * Reference to the child process
-   */
-  #httpServer;
-  /**
-   * Keyboard shortcuts manager instance
-   */
-  #shortcutsManager;
-  /**
-   * Filesystem is used to decide which files to watch or entertain when
-   * using hot-hook
-   */
-  #fileSystem;
-  /**
-   * Index generator for managing auto-generated index files
-   */
-  #indexGenerator;
-  /**
-   * Hooks to execute custom actions during the dev server lifecycle
-   */
-  #hooks;
-  /**
-   * CLI UI instance for displaying colorful messages and progress information
-   */
-  ui = cliui2();
-  /**
-   * Restarts the HTTP server and throttle concurrent calls to
-   * ensure we do not end up with a long loop of restarts
-   */
-  #restartHTTPServer = throttle(async () => {
-    if (this.#httpServer) {
-      this.#httpServer.removeAllListeners();
-      this.#httpServer.kill("SIGKILL");
-    }
-    await this.#startHTTPServer(this.#stickyPort);
-  }, "restartHTTPServer");
-  /**
-   * Sets up keyboard shortcuts for development server interactions
-   *
-   * Initializes the shortcuts manager with callbacks for restarting the server,
-   * clearing the screen, and quitting the application.
-   */
-  #setupKeyboardShortcuts() {
-    this.#shortcutsManager = new ShortcutsManager({
-      logger: this.ui.logger,
-      callbacks: {
-        onRestart: () => this.#restartHTTPServer(),
-        onClear: () => this.#clearScreen(),
-        onQuit: () => this.close()
-      }
-    });
-    this.#shortcutsManager.setup();
-  }
-  /**
-   * Cleanup keyboard shortcuts and restore terminal state
-   *
-   * Removes keyboard shortcuts event listeners and restores the terminal
-   * to its normal state when shutting down the development server.
-   */
-  #cleanupKeyboardShortcuts() {
-    this.#shortcutsManager?.cleanup();
-  }
-  /**
-   * The mode in which the DevServer is running.
-   */
-  get mode() {
-    return this.#mode;
-  }
-  /**
-   * Script file to start the development server
-   */
-  scriptFile = "bin/server.ts";
-  /**
-   * The current working directory URL
-   */
-  cwd;
-  /**
-   * File path computed from the cwd
-   */
-  cwdPath;
-  /**
-   * Development server configuration options including hooks and environment variables
-   */
-  options;
-  /**
-   * Create a new DevServer instance
-   *
-   * @param cwd - The current working directory URL
-   * @param options - Development server configuration options
-   */
-  constructor(cwd, options) {
-    this.cwd = cwd;
-    this.options = options;
-    this.cwdPath = string3.toUnixSlash(fileURLToPath2(this.cwd));
-  }
-  /**
-   * Type guard to check if child process message is from AdonisJS HTTP server
-   *
-   * Validates that a message from the child process contains the expected
-   * structure indicating the AdonisJS server is ready and listening.
-   *
-   * @param message - Unknown message from child process
-   * @returns True if message is an AdonisJS ready message
-   */
-  #isAdonisJSReadyMessage(message) {
-    return message !== null && typeof message === "object" && "isAdonisJS" in message && "environment" in message && message.environment === "web";
-  }
-  /**
-   * Displays server information and executes hooks after server startup
-   *
-   * Shows server URL, mode, startup duration, and help instructions.
-   * Also executes the devServerStarted hooks to allow custom post-startup logic.
-   *
-   * @param message - Server ready message containing port, host, and optional duration
-   */
-  async #postServerReady(message) {
-    const host = message.host === "0.0.0.0" ? "127.0.0.1" : message.host;
-    const info = { host, port: message.port };
-    const serverUrl = `http://${host}:${message.port}`;
-    this.#shortcutsManager?.setServerUrl(serverUrl);
-    const displayMessage = this.ui.sticker().add(`Server address: ${this.ui.colors.cyan(serverUrl)}`).add(`Mode: ${this.ui.colors.cyan(this.mode)}`);
-    if (message.duration) {
-      displayMessage.add(`Ready in: ${this.ui.colors.cyan(prettyHrtime(message.duration))}`);
-    }
-    displayMessage.add(`Press ${this.ui.colors.dim("h")} to show help`);
-    try {
-      await this.#hooks.runner("devServerStarted").run(this, info, displayMessage);
-    } catch (error) {
-      this.ui.logger.error('One of the "devServerStarted" hooks failed');
-      this.ui.logger.fatal(error);
-    }
-    displayMessage.render();
-  }
-  /**
-   * Type guard to check if child process message is from hot-hook
-   *
-   * Validates that a message from the child process is a hot-hook notification
-   * about file changes, invalidations, or full reloads.
-   *
-   * @param message - Unknown message from child process
-   * @returns True if message is a hot-hook message
-   */
-  #isHotHookMessage(message) {
-    return message !== null && typeof message === "object" && "type" in message && typeof message.type === "string" && message.type.startsWith("hot-hook:");
-  }
-  /**
-   * Conditionally clears the terminal screen based on configuration
-   *
-   * Clears the terminal screen if the clearScreen option is enabled,
-   * providing a clean view for development output.
-   */
-  #clearScreen() {
-    if (this.options.clearScreen) {
-      process.stdout.write("\x1Bc");
-    }
-  }
-  /**
-   * Handles file change events and triggers appropriate server actions
-   *
-   * Processes file change notifications and determines whether to restart
-   * the server, hot reload, or ignore the change based on file type and mode.
-   *
-   * @param relativePath - Relative path to the changed file
-   * @param absolutePath - Absolute path to the changed file
-   * @param action - Type of file change (add, update, delete)
-   * @param info - Optional information about the change source and reload behavior
-   */
-  #handleFileChange(relativePath, absolutePath, action, info) {
-    if ((action === "add" || action === "delete") && this.mode === "hmr") {
-      debug_default("ignoring add and delete actions in HMR mode %s", relativePath);
-      return;
-    }
-    if (info && info.source === "hot-hook" && info.hotReloaded) {
-      debug_default("hot reloading %s, info %O", relativePath, info);
-      this.ui.logger.log(`${this.ui.colors.green("invalidated")} ${relativePath}`);
-      return;
-    }
-    if (info && !info.fullReload) {
-      debug_default("ignoring full reload", relativePath, info);
-      return;
-    }
-    const file = this.#fileSystem.inspect(absolutePath, relativePath);
-    if (!file) {
-      return;
-    }
-    if (file.reloadServer) {
-      this.#clearScreen();
-      this.ui.logger.log(`${this.ui.colors.green(action)} ${relativePath}`);
-      this.#restartHTTPServer();
-      return;
-    }
-    this.ui.logger.log(`${this.ui.colors.green(action)} ${relativePath}`);
-  }
-  /**
-   * Regenerates index files when a file is added or removed
-   *
-   * Updates the index generator to reflect file system changes by adding
-   * or removing files from the generated index files.
-   *
-   * @param filePath - Absolute path to the file that changed
-   * @param action - Whether the file was added or deleted
-   */
-  #regenerateIndex(filePath, action) {
-    if (action === "add") {
-      return this.#indexGenerator.addFile(filePath);
-    }
-    return this.#indexGenerator.removeFile(filePath);
-  }
-  /**
-   * Registers hooks for file system events and server restart triggers
-   *
-   * Sets up event handlers that respond to file additions, changes, and removals
-   * by regenerating indexes and handling server restarts as needed.
-   */
-  #registerServerRestartHooks() {
-    this.#hooks.add("fileAdded", (relativePath, absolutePath) => {
-      this.#regenerateIndex(absolutePath, "add");
-      this.#handleFileChange(relativePath, absolutePath, "add");
-    });
-    this.#hooks.add(
-      "fileChanged",
-      (relativePath, absolutePath, info) => this.#handleFileChange(relativePath, absolutePath, "update", info)
-    );
-    this.#hooks.add("fileRemoved", (relativePath, absolutePath) => {
-      this.#regenerateIndex(absolutePath, "delete");
-      this.#handleFileChange(relativePath, absolutePath, "delete");
-    });
-  }
-  /**
-   * Initiate the state for DevServer and executes the init hooks
-   */
-  async #init(ts, mode) {
-    const tsConfig = parseConfig(this.cwd, ts);
-    if (!tsConfig) {
-      this.#onError?.(new RuntimeException("Unable to parse tsconfig file"));
-      return false;
-    }
-    this.#mode = mode;
-    this.#clearScreen();
-    this.ui.logger.info(`starting server in ${this.#mode} mode...`);
-    this.#indexGenerator = new IndexGenerator(this.cwdPath, this.ui.logger);
-    this.#stickyPort = String(await getPort(this.cwd));
-    this.#fileSystem = new FileSystem(this.cwdPath, tsConfig, this.options);
-    this.ui.logger.info("loading hooks...");
-    this.#hooks = await loadHooks(this.options.hooks, [
-      "init",
-      "routesCommitted",
-      "routesScanning",
-      "routesScanned",
-      "devServerStarting",
-      "devServerStarted",
-      "fileAdded",
-      "fileChanged",
-      "fileRemoved"
-    ]);
-    this.#registerServerRestartHooks();
-    this.#setupKeyboardShortcuts();
-    await this.#hooks.runner("init").run(this, this.#indexGenerator);
-    this.#hooks.clear("init");
-    this.ui.logger.info("generating indexes...");
-    await this.#indexGenerator.generate();
-    return true;
-  }
-  /**
-   * Starts the HTTP server as a child process
-   *
-   * Creates a new Node.js child process to run the server script with the
-   * specified port and configuration. Sets up message handlers for server
-   * ready notifications and hot-hook events.
-   *
-   * @param port - Port number for the server to listen on
-   */
-  async #startHTTPServer(port) {
-    await this.#hooks.runner("devServerStarting").run(this);
-    debug_default('starting http server using "%s" file, options %O', this.scriptFile, this.options);
-    return new Promise(async (resolve) => {
-      this.#httpServer = runNode(this.cwd, {
-        script: this.scriptFile,
-        env: { PORT: port, ...this.options.env },
-        nodeArgs: this.options.nodeArgs,
-        reject: true,
-        scriptArgs: this.options.scriptArgs
-      });
-      this.#httpServer.on("message", async (message) => {
-        if (this.#isAdonisJSReadyMessage(message)) {
-          debug_default("received http server ready message %O", message);
-          await this.#postServerReady(message);
-          resolve();
-        } else if (this.#mode === "hmr" && this.#isHotHookMessage(message)) {
-          debug_default("received hot-hook message %O", message);
-          const absolutePath = message.path ? string3.toUnixSlash(message.path) : "";
-          const relativePath = relative3(this.cwdPath, absolutePath);
-          if (message.type === "hot-hook:file-changed") {
-            const { action } = message;
-            if (action === "add") {
-              this.#hooks.runner("fileAdded").run(relativePath, absolutePath, this);
-            } else if (action === "change") {
-              this.#hooks.runner("fileChanged").run(relativePath, absolutePath, _DevServer.#HOT_HOOK_CHANGE_INFO, this);
-            } else if (action === "unlink") {
-              this.#hooks.runner("fileRemoved").run(relativePath, absolutePath, this);
-            }
-          } else if (message.type === "hot-hook:full-reload") {
-            this.#hooks.runner("fileChanged").run(relativePath, absolutePath, _DevServer.#HOT_HOOK_FULL_RELOAD_INFO, this);
-          } else if (message.type === "hot-hook:invalidated") {
-            this.#hooks.runner("fileChanged").run(relativePath, absolutePath, _DevServer.#HOT_HOOK_INVALIDATED_INFO, this);
-          }
-        }
-      });
-      this.#httpServer.then((result) => {
-        if (!this.#watcher) {
-          this.#onClose?.(result.exitCode);
-        } else {
-          this.ui.logger.info("Underlying HTTP server closed. Still watching for changes");
-        }
-      }).catch((error) => {
-        if (!this.#watcher) {
-          this.#onError?.(error);
-        } else {
-          this.ui.logger.info("Underlying HTTP server died. Still watching for changes");
-        }
-      }).finally(() => {
-        resolve();
-      });
-    });
-  }
-  /**
-   * Add listener to get notified when dev server is closed
-   *
-   * @param callback - Function to call when dev server closes
-   * @returns This DevServer instance for method chaining
-   */
-  onClose(callback) {
-    this.#onClose = callback;
-    return this;
-  }
-  /**
-   * Add listener to get notified when dev server encounters an error
-   *
-   * @param callback - Function to call when dev server encounters an error
-   * @returns This DevServer instance for method chaining
-   */
-  onError(callback) {
-    this.#onError = callback;
-    return this;
-  }
-  /**
-   * Close watchers and the running child process
-   */
-  async close() {
-    this.#cleanupKeyboardShortcuts();
-    await this.#watcher?.close();
-    if (this.#httpServer) {
-      this.#httpServer.removeAllListeners();
-      this.#httpServer.kill("SIGKILL");
-    }
-  }
-  /**
-   * Start the development server in static or HMR mode
-   *
-   * @param ts - TypeScript module reference
-   */
-  async start(ts) {
-    const initiated = await this.#init(ts, this.options.hmr ? "hmr" : "static");
-    if (!initiated) {
-      return;
-    }
-    if (this.#mode === "hmr") {
-      this.options.nodeArgs.push("--import=hot-hook/register");
-      this.options.env = {
-        ...this.options.env,
-        HOT_HOOK_INCLUDE: this.#fileSystem.includes.join(","),
-        HOT_HOOK_IGNORE: this.#fileSystem.excludes.join(","),
-        HOT_HOOK_RESTART: (this.options.metaFiles ?? []).filter(({ reloadServer }) => !!reloadServer).map(({ pattern }) => pattern).join(",")
-      };
-    }
-    this.ui.logger.info("starting HTTP server...");
-    await this.#startHTTPServer(this.#stickyPort);
-  }
-  /**
-   * Start the development server in watch mode and restart on file changes
-   *
-   * @param ts - TypeScript module reference
-   * @param options - Watch options including polling mode
-   */
-  async startAndWatch(ts, options) {
-    const initiated = await this.#init(ts, "watch");
-    if (!initiated) {
-      return;
-    }
-    this.ui.logger.info("starting HTTP server...");
-    await this.#startHTTPServer(this.#stickyPort);
-    this.#watcher = watch({
-      usePolling: options?.poll ?? false,
-      cwd: this.cwdPath,
-      ignoreInitial: true,
-      ignored: (file, stats) => {
-        if (!stats) {
-          return false;
-        }
-        if (stats.isFile()) {
-          return !this.#fileSystem.shouldWatchFile(file);
-        }
-        return !this.#fileSystem.shouldWatchDirectory(file);
-      }
-    });
-    this.#watcher.on("ready", () => {
-      this.ui.logger.info("watching file system for changes...");
-    });
-    this.#watcher.on("error", (error) => {
-      this.ui.logger.warning("file system watcher failure");
-      this.ui.logger.fatal(error);
-      this.#onError?.(error);
-      this.#watcher?.close();
-    });
-    this.#watcher.on("add", (filePath) => {
-      const relativePath = string3.toUnixSlash(filePath);
-      const absolutePath = join2(this.cwdPath, relativePath);
-      this.#hooks.runner("fileAdded").run(relativePath, absolutePath, this);
-    });
-    this.#watcher.on("change", (filePath) => {
-      const relativePath = string3.toUnixSlash(filePath);
-      const absolutePath = join2(this.cwdPath, relativePath);
-      this.#hooks.runner("fileChanged").run(relativePath, absolutePath, _DevServer.#WATCHER_INFO, this);
-    });
-    this.#watcher.on("unlink", (filePath) => {
-      const relativePath = string3.toUnixSlash(filePath);
-      const absolutePath = join2(this.cwdPath, relativePath);
-      this.#hooks.runner("fileRemoved").run(relativePath, absolutePath, this);
-    });
-  }
+//#endregion
+//#region src/dev_server.ts
+/**
+* Exposes the API to start the development server in HMR, watch or static mode
+*
+* In HMR mode, the DevServer will exec the "bin/server.ts" file and let hot-hook
+* manage the changes using hot module reloading.
+*
+* In watch mode, the DevServer will start an internal watcher and restarts the server
+* after every file change. The files must be part of the TypeScript project (via tsconfig.json),
+* or registered as metaFiles.
+*
+* In static mode, the server runs without file watching or hot reloading.
+*
+* @example
+* const devServer = new DevServer(cwd, { hmr: true, hooks: [] })
+* await devServer.start(ts)
+*/
+var DevServer = class DevServer {
+	/**
+	* Pre-allocated info object for hot-hook full reload events
+	*/
+	static #HOT_HOOK_FULL_RELOAD_INFO = {
+		source: "hot-hook",
+		fullReload: true,
+		hotReloaded: false
+	};
+	/**
+	* Pre-allocated info object for hot-hook invalidation events
+	*/
+	static #HOT_HOOK_INVALIDATED_INFO = {
+		source: "hot-hook",
+		fullReload: false,
+		hotReloaded: true
+	};
+	/**
+	* Pre-allocated info object for file watcher events
+	*/
+	static #WATCHER_INFO = {
+		source: "watcher",
+		fullReload: true,
+		hotReloaded: false
+	};
+	/**
+	* External listeners that are invoked when child process
+	* gets an error or closes
+	*/
+	#onError;
+	#onClose;
+	/**
+	* The stickyPort is set by the start and the startAndWatch methods
+	* and we will continue to use that port during restart
+	*/
+	#stickyPort;
+	/**
+	* The stickyHmrPort is set by the start and the startAndWatch methods
+	* and we will continue to use that port during restart
+	*/
+	#stickyHmrPort;
+	/**
+	* The mode is set by the start and the startAndWatch methods
+	*/
+	#mode = "static";
+	/**
+	* Reference to chokidar watcher
+	*/
+	#watcher;
+	/**
+	* Reference to the child process
+	*/
+	#httpServer;
+	/**
+	* Flag to track if the HTTP server child process is alive
+	*/
+	#isHttpServerAlive = false;
+	/**
+	* Keyboard shortcuts manager instance
+	*/
+	#shortcutsManager;
+	/**
+	* Filesystem is used to decide which files to watch or entertain when
+	* using hot-hook
+	*/
+	#fileSystem;
+	/**
+	* Index generator for managing auto-generated index files
+	*/
+	#indexGenerator;
+	/**
+	* Routes scanner to scan routes and infer route request and
+	* response data
+	*/
+	#routesScanner;
+	/**
+	* Hooks to execute custom actions during the dev server lifecycle
+	*/
+	#hooks;
+	/**
+	* CLI UI instance for displaying colorful messages and progress information
+	*/
+	ui = cliui();
+	/**
+	* Restarts the HTTP server and throttle concurrent calls to
+	* ensure we do not end up with a long loop of restarts
+	*/
+	#restartHTTPServer = throttle(async () => {
+		if (this.#httpServer) {
+			this.#httpServer.removeAllListeners();
+			this.#httpServer.kill("SIGKILL");
+		}
+		await this.#startHTTPServer(this.#stickyPort, this.#stickyHmrPort);
+	}, "restartHTTPServer");
+	/**
+	* Sets up keyboard shortcuts for development server interactions
+	*
+	* Initializes the shortcuts manager with callbacks for restarting the server,
+	* clearing the screen, and quitting the application.
+	*/
+	#setupKeyboardShortcuts() {
+		this.#shortcutsManager = new ShortcutsManager({
+			logger: this.ui.logger,
+			callbacks: {
+				onRestart: () => this.#restartHTTPServer(),
+				onClear: () => this.#clearScreen(),
+				onQuit: () => this.close()
+			}
+		});
+		this.#shortcutsManager.setup();
+	}
+	/**
+	* Cleanup keyboard shortcuts and restore terminal state
+	*
+	* Removes keyboard shortcuts event listeners and restores the terminal
+	* to its normal state when shutting down the development server.
+	*/
+	#cleanupKeyboardShortcuts() {
+		this.#shortcutsManager?.cleanup();
+	}
+	/**
+	* The mode in which the DevServer is running
+	*
+	* Returns the current operating mode of the development server:
+	* - 'hmr': Hot Module Reloading enabled
+	* - 'watch': File system watching with full restarts
+	* - 'static': No file watching or hot reloading
+	*/
+	get mode() {
+		return this.#mode;
+	}
+	/**
+	* Script file to start the development server
+	*/
+	scriptFile = "bin/server.ts";
+	/**
+	* The current working directory URL
+	*/
+	cwd;
+	/**
+	* File path computed from the cwd
+	*/
+	cwdPath;
+	/**
+	* Development server configuration options including hooks and environment variables
+	*/
+	options;
+	/**
+	* Create a new DevServer instance
+	*
+	* @param cwd - The current working directory URL
+	* @param options - Development server configuration options
+	*/
+	constructor(cwd, options) {
+		this.cwd = cwd;
+		this.options = options;
+		this.cwdPath = string.toUnixSlash(fileURLToPath(this.cwd));
+	}
+	/**
+	* Type guard to check if child process message is from AdonisJS HTTP server
+	*
+	* Validates that a message from the child process contains the expected
+	* structure indicating the AdonisJS server is ready and listening.
+	*
+	* @param message - Unknown message from child process
+	* @returns True if message is an AdonisJS ready message
+	*/
+	#isAdonisJSReadyMessage(message) {
+		return message !== null && typeof message === "object" && "isAdonisJS" in message && "environment" in message && message.environment === "web";
+	}
+	/**
+	* Type guard to check if child process message contains routes information
+	*
+	* Validates that a message from the child process contains the expected
+	* structure with routes file location from the AdonisJS server.
+	*
+	* @param message - Unknown message from child process
+	* @returns True if message contains routes file location
+	*/
+	#isAdonisJSRoutesMessage(message) {
+		return message !== null && typeof message === "object" && "routesFileLocation" in message;
+	}
+	/**
+	* Displays server information and executes hooks after server startup
+	*
+	* Shows server URL, mode, startup duration, and help instructions.
+	* Also executes the devServerStarted hooks to allow custom post-startup logic.
+	*
+	* @param message - Server ready message containing port, host, and optional duration
+	*/
+	async #postServerReady(message) {
+		const host = message.host === "0.0.0.0" ? "127.0.0.1" : message.host;
+		const info = {
+			host,
+			port: message.port
+		};
+		const serverUrl = `http://${host}:${message.port}`;
+		this.#shortcutsManager?.setServerUrl(serverUrl);
+		const displayMessage = this.ui.sticker().add(`Server address: ${this.ui.colors.cyan(serverUrl)}`).add(`Mode: ${this.ui.colors.cyan(this.mode)}`);
+		if (message.duration) displayMessage.add(`Ready in: ${this.ui.colors.cyan(prettyHrtime(message.duration))}`);
+		displayMessage.add(`Press ${this.ui.colors.dim("h")} to show help`);
+		/**
+		* Run hooks before displaying the "displayMessage". It will allow hooks to add
+		* custom lines to the display message.
+		*/
+		try {
+			await this.#hooks.runner("devServerStarted").run(this, info, displayMessage);
+		} catch (error) {
+			this.ui.logger.error("One of the \"devServerStarted\" hooks failed");
+			this.ui.logger.fatal(error);
+		}
+		displayMessage.render();
+	}
+	/**
+	* Type guard to check if child process message is from hot-hook
+	*
+	* Validates that a message from the child process is a hot-hook notification
+	* about file changes, invalidations, or full reloads.
+	*
+	* @param message - Unknown message from child process
+	* @returns True if message is a hot-hook message
+	*/
+	#isHotHookMessage(message) {
+		return message !== null && typeof message === "object" && "type" in message && typeof message.type === "string" && message.type.startsWith("hot-hook:");
+	}
+	/**
+	* Conditionally clears the terminal screen based on configuration
+	*
+	* Clears the terminal screen if the clearScreen option is enabled,
+	* providing a clean view for development output.
+	*/
+	#clearScreen() {
+		if (this.options.clearScreen) process.stdout.write("\x1Bc");
+	}
+	/**
+	* Creates our file system watcher
+	*/
+	#createWatcher(options) {
+		const watcher = watch({
+			usePolling: options?.poll ?? false,
+			cwd: this.cwdPath,
+			ignoreInitial: true,
+			ignored: (file, stats) => {
+				if (!stats) return false;
+				if (file.includes("inertia") && !file.includes("node_modules")) return false;
+				if (stats.isFile()) return !this.#fileSystem.shouldWatchFile(file);
+				return !this.#fileSystem.shouldWatchDirectory(file);
+			}
+		});
+		watcher.on("error", (error) => {
+			this.ui.logger.warning("file system watcher failure");
+			this.ui.logger.fatal(error);
+			this.#onError?.(error);
+			this.#watcher?.close();
+		});
+		watcher.on("ready", () => {
+			this.ui.logger.info("watching file system for changes...");
+		});
+		return watcher;
+	}
+	/**
+	* Handles file change events in HMR mode by forwarding to hot-hook
+	* or restarting the server if dead.
+	*/
+	#handleHmrWatcherEvent(options) {
+		const relativePath = string.toUnixSlash(options.filePath);
+		const absolutePath = join(this.cwdPath, relativePath);
+		if (this.#isHttpServerAlive === false) {
+			this.#clearScreen();
+			this.ui.logger.log(`${this.ui.colors.green(options.displayLabel)} ${relativePath}`);
+			this.#restartHTTPServer();
+			return;
+		}
+		/**
+		* For add/unlink, we call the hooks directly since hot-hook ignores files
+		* not in its dependency tree. This ensures index files are regenerated
+		* for new/removed files.
+		*/
+		if (options.action === "add") this.#hooks.runner("fileAdded").run(relativePath, absolutePath, this);
+		else if (options.action === "unlink") this.#hooks.runner("fileRemoved").run(relativePath, absolutePath, this);
+		/**
+		* Forward all events to hot-hook so it can:
+		* - Update its dependency tree (for unlink)
+		* - Handle HMR for change events on imported files
+		* - Then we wait for hot-hook to notify us back via IPC message
+		*/
+		this.#httpServer?.send({
+			type: "hot-hook:file-changed",
+			path: absolutePath,
+			action: options.action
+		});
+	}
+	/**
+	* Handles file change events and triggers appropriate server actions
+	*
+	* Processes file change notifications and determines whether to restart
+	* the server, hot reload, or ignore the change based on file type and mode.
+	*
+	* @param relativePath - Relative path to the changed file
+	* @param absolutePath - Absolute path to the changed file
+	* @param action - Type of file change (add, update, delete)
+	* @param info - Optional information about the change source and reload behavior
+	*/
+	#handleFileChange(relativePath, absolutePath, action, info) {
+		/**
+		* Ignore add and delete events in HMR mode and let hot-hook find the
+		* file via import first.
+		*
+		* Remember, hot-hook does not send the action as "add" or "delete" if this
+		* file is being imported.
+		*/
+		if ((action === "add" || action === "delete") && this.mode === "hmr") {
+			debug_default("ignoring add and delete actions in HMR mode %s", relativePath);
+			return;
+		}
+		/**
+		* Notify about the invalidated file
+		*/
+		if (info && info.source === "hot-hook" && info.hotReloaded) {
+			debug_default("hot reloading %s, info %O", relativePath, info);
+			this.ui.logger.log(`${this.ui.colors.green("invalidated")} ${relativePath}`);
+			return;
+		}
+		/**
+		* Do not do anything when fullReload is not enabled.
+		*/
+		if (info && !info.fullReload) {
+			debug_default("ignoring full reload", relativePath, info);
+			return;
+		}
+		const file = this.#fileSystem.inspect(absolutePath, relativePath);
+		if (!file) return;
+		if (file.reloadServer) {
+			this.#clearScreen();
+			this.ui.logger.log(`${this.ui.colors.green(action)} ${relativePath}`);
+			this.#restartHTTPServer();
+			return;
+		}
+		this.ui.logger.log(`${this.ui.colors.green(action)} ${relativePath}`);
+	}
+	/**
+	* Regenerates index files when a file is added or removed
+	*
+	* Updates the index generator to reflect file system changes by adding
+	* or removing files from the generated index files.
+	*
+	* @param filePath - Absolute path to the file that changed
+	* @param action - Whether the file was added or deleted
+	*/
+	#regenerateIndex(filePath, action) {
+		if (action === "add") return this.#indexGenerator.addFile(filePath);
+		return this.#indexGenerator.removeFile(filePath);
+	}
+	/**
+	* Re-scans routes when a file is modified during hot reloading
+	*
+	* Invalidates the routes cache for the given file and triggers route
+	* scanning hooks if the invalidation was successful.
+	*
+	* @param filePath - Absolute path to the file that was modified
+	*
+	* @example
+	* await devServer.#reScanRoutes('/path/to/routes.ts')
+	*/
+	async #reScanRoutes(filePath) {
+		if (!this.#routesScanner) return;
+		try {
+			if (await this.#routesScanner.invalidate(filePath)) await this.#hooks.runner("routesScanned").run(this, this.#routesScanner);
+		} catch (error) {
+			this.ui.logger.error("Unable to rescan routes because of the following error");
+			this.ui.logger.fatal(error);
+		}
+	}
+	/**
+	* Processes routes received from the AdonisJS server
+	*
+	* Executes routesCommitted hooks and optionally scans routes if scanning
+	* hooks are registered. Creates a routes scanner instance if needed and
+	* processes routes for each domain.
+	*
+	* @param routesList - Routes organized by domain
+	*
+	* @example
+	* await devServer.#processRoutes({
+	*   'example.com': [
+	*     { pattern: '/', handler: 'HomeController.index' }
+	*   ]
+	* })
+	*/
+	#processRoutes = throttle(async (routesFileLocation) => {
+		try {
+			const scanRoutes = this.#hooks.has("routesScanning") || this.#hooks.has("routesScanned");
+			const shareRoutes = this.#hooks.has("routesCommitted");
+			/**
+			* Remove the routes file and return early when there are no
+			* hooks listening for routes related events
+			*/
+			if (!scanRoutes && !shareRoutes) {
+				unlink(routesFileLocation).catch(() => {});
+				return;
+			}
+			/**
+			* Read routes JSON, parse it and remove the file
+			*/
+			const routesJSON = await readFile(routesFileLocation, "utf-8");
+			const routesList = JSON.parse(routesJSON);
+			unlink(routesFileLocation).catch(() => {});
+			/**
+			* Notify about the existence of routes
+			*/
+			if (shareRoutes) await this.#hooks.runner("routesCommitted").run(this, routesList);
+			/**
+			* Scan routes and notify scanning and scanned hooks
+			*/
+			if (scanRoutes) {
+				this.#routesScanner = new RoutesScanner(this.cwdPath, []);
+				await this.#hooks.runner("routesScanning").run(this, this.#routesScanner);
+				for (const domain of Object.keys(routesList)) await this.#routesScanner.scan(routesList[domain]);
+				await this.#hooks.runner("routesScanned").run(this, this.#routesScanner);
+			}
+		} catch (error) {
+			this.ui.logger.error("Unable to process and scan routes because of the following error");
+			this.ui.logger.fatal(error);
+		}
+	}, "processRoutes");
+	/**
+	* Registers hooks for file system events and server restart triggers
+	*
+	* Sets up event handlers that respond to file additions, changes, and removals
+	* by regenerating indexes and handling server restarts as needed.
+	*/
+	#registerServerRestartHooks() {
+		this.#hooks.add("fileAdded", (relativePath, absolutePath) => {
+			this.#regenerateIndex(absolutePath, "add");
+			this.#handleFileChange(relativePath, absolutePath, "add");
+		});
+		this.#hooks.add("fileChanged", (relativePath, absolutePath, info) => {
+			/**
+			* Rescan routes when the file is hot-reloaded or when the file is
+			* not part of the imports tree, but meant to be hot-reloaded
+			*/
+			if (info.hotReloaded || !info.hotReloaded && !info.fullReload) this.#reScanRoutes(absolutePath);
+			this.#handleFileChange(relativePath, absolutePath, "update", info);
+		});
+		this.#hooks.add("fileRemoved", (relativePath, absolutePath) => {
+			this.#regenerateIndex(absolutePath, "delete");
+			this.#handleFileChange(relativePath, absolutePath, "delete");
+		});
+	}
+	/**
+	* Initializes the development server state and executes init hooks
+	*
+	* Parses TypeScript configuration, sets up file system, loads hooks,
+	* initializes the index generator, and prepares the server for the
+	* specified mode (HMR, watch, or static).
+	*
+	* @param ts - TypeScript module reference
+	* @param mode - Server mode (hmr, watch, or static)
+	* @returns True if initialization succeeds, false if tsconfig parsing fails
+	*
+	* @example
+	* const success = await devServer.#init(ts, 'hmr')
+	* if (!success) {
+	*   console.error('Failed to initialize dev server')
+	* }
+	*/
+	async #init(mode) {
+		const tsConfig = readTsConfig(this.cwdPath);
+		if (!tsConfig) {
+			this.#onError?.(new RuntimeException("Unable to parse tsconfig file"));
+			return false;
+		}
+		this.#mode = mode;
+		this.#clearScreen();
+		this.ui.logger.info(`starting server in ${this.#mode} mode...`);
+		this.#indexGenerator = new IndexGenerator(this.cwdPath, this.ui.logger);
+		this.#stickyPort = String(await getPort(this.cwd));
+		this.#stickyHmrPort = String(await getRandomPort({ port: 24678 }));
+		this.#fileSystem = new FileSystem(this.cwdPath, tsConfig, this.options);
+		this.ui.logger.info("loading hooks...");
+		this.#hooks = await loadHooks(this.options.hooks, [
+			"init",
+			"routesCommitted",
+			"routesScanning",
+			"routesScanned",
+			"devServerStarting",
+			"devServerStarted",
+			"fileAdded",
+			"fileChanged",
+			"fileRemoved"
+		]);
+		this.#registerServerRestartHooks();
+		this.#setupKeyboardShortcuts();
+		/**
+		* Run init hooks and clear them as they won't be executed
+		* ever again
+		*/
+		await this.#hooks.runner("init").run(this, this.#hooks, this.#indexGenerator);
+		this.#hooks.clear("init");
+		this.ui.logger.info("generating indexes...");
+		await this.#indexGenerator.generate();
+		return true;
+	}
+	/**
+	* Starts the HTTP server as a child process
+	*
+	* Creates a new Node.js child process to run the server script with the
+	* specified port and configuration. Sets up message handlers for server
+	* ready notifications, routes sharing, and hot-hook events. Executes
+	* devServerStarting hooks before spawning the process.
+	*
+	* @param port - Port number for the server to listen on
+	*
+	* @example
+	* await devServer.#startHTTPServer('3333')
+	*/
+	async #startHTTPServer(port, hmrPort) {
+		/**
+		* Execute the registered before creating the child process. This will allow
+		* hooks to modify the options before they are used.
+		*/
+		await this.#hooks.runner("devServerStarting").run(this);
+		debug_default("starting http server using \"%s\" file, options %O", this.scriptFile, this.options);
+		return new Promise((resolve) => {
+			/**
+			* Creating child process
+			*/
+			this.#httpServer = runNode(this.cwd, {
+				script: this.scriptFile,
+				env: {
+					PORT: port,
+					VITE_HMR_PORT: hmrPort,
+					DEV_MODE: "true",
+					...this.options.env
+				},
+				nodeArgs: this.options.nodeArgs,
+				reject: true,
+				scriptArgs: this.options.scriptArgs
+			});
+			this.#isHttpServerAlive = true;
+			this.#httpServer.on("message", async (message) => {
+				if (this.#isAdonisJSReadyMessage(message)) {
+					debug_default("received http server ready message %O", message);
+					await this.#postServerReady(message);
+					resolve();
+				} else if (this.#isAdonisJSRoutesMessage(message)) {
+					debug_default("received routes location from the server %O", message);
+					await this.#processRoutes(message.routesFileLocation);
+				} else if (this.#mode === "hmr" && this.#isHotHookMessage(message)) {
+					debug_default("received hot-hook message %O", message);
+					if (message.type === "hot-hook:full-reload") {
+						const absolutePath = message.path ? string.toUnixSlash(message.path) : "";
+						const relativePath = relative(this.cwdPath, absolutePath);
+						this.#hooks.runner("fileChanged").run(relativePath, absolutePath, DevServer.#HOT_HOOK_FULL_RELOAD_INFO, this);
+					} else if (message.type === "hot-hook:invalidated") {
+						const absolutePath = message.paths[0] ? string.toUnixSlash(message.paths[0]) : "";
+						const relativePath = relative(this.cwdPath, absolutePath);
+						this.#hooks.runner("fileChanged").run(relativePath, absolutePath, DevServer.#HOT_HOOK_INVALIDATED_INFO, this);
+					}
+				}
+			});
+			this.#httpServer.then((result) => {
+				this.#isHttpServerAlive = false;
+				if (!this.#watcher) this.#onClose?.(result.exitCode);
+				else this.ui.logger.info("Underlying HTTP server closed. Still watching for changes");
+			}).catch((error) => {
+				this.#isHttpServerAlive = false;
+				if (!this.#watcher) this.#onError?.(error);
+				else this.ui.logger.info("Underlying HTTP server died. Still watching for changes");
+			}).finally(() => {
+				resolve();
+			});
+		});
+	}
+	/**
+	* Adds listener to get notified when dev server is closed
+	*
+	* Registers a callback function that will be invoked when the development
+	* server's child process exits. The callback receives the exit code.
+	*
+	* @param callback - Function to call when dev server closes
+	* @returns This DevServer instance for method chaining
+	*
+	* @example
+	* devServer.onClose((exitCode) => {
+	*   console.log(`Server closed with exit code: ${exitCode}`)
+	* })
+	*/
+	onClose(callback) {
+		this.#onClose = callback;
+		return this;
+	}
+	/**
+	* Adds listener to get notified when dev server encounters an error
+	*
+	* Registers a callback function that will be invoked when the development
+	* server's child process encounters an error or fails to start.
+	*
+	* @param callback - Function to call when dev server encounters an error
+	* @returns This DevServer instance for method chaining
+	*
+	* @example
+	* devServer.onError((error) => {
+	*   console.error('Dev server error:', error.message)
+	* })
+	*/
+	onError(callback) {
+		this.#onError = callback;
+		return this;
+	}
+	/**
+	* Closes watchers and terminates the running child process
+	*
+	* Cleans up keyboard shortcuts, stops file system watchers, and kills
+	* the HTTP server child process. This should be called when shutting down
+	* the development server.
+	*
+	* @example
+	* await devServer.close()
+	*/
+	async close() {
+		this.#cleanupKeyboardShortcuts();
+		await this.#watcher?.close();
+		if (this.#httpServer) {
+			this.#httpServer.removeAllListeners();
+			this.#httpServer.kill("SIGKILL");
+		}
+	}
+	/**
+	* Starts the development server in static or HMR mode
+	*
+	* Initializes the server and starts the HTTP server. The mode is determined
+	* by the `hmr` option in DevServerOptions. In HMR mode, hot-hook is configured
+	* to enable hot module reloading.
+	*
+	* @param ts - TypeScript module reference
+	*
+	* @example
+	* const devServer = new DevServer(cwd, { hmr: true, hooks: [] })
+	* await devServer.start(ts)
+	*/
+	async start() {
+		if (!await this.#init(this.options.hmr ? "hmr" : "static")) return;
+		if (this.#mode === "hmr") {
+			this.options.nodeArgs.push("--import=hot-hook/register");
+			this.options.env = {
+				...this.options.env,
+				HOT_HOOK_WATCH: "false"
+			};
+		}
+		this.ui.logger.info("starting HTTP server...");
+		await this.#startHTTPServer(this.#stickyPort, this.#stickyHmrPort);
+		if (this.#mode !== "hmr") return;
+		this.#watcher = this.#createWatcher();
+		this.#watcher.on("add", (filePath) => {
+			this.#handleHmrWatcherEvent({
+				filePath,
+				action: "add",
+				displayLabel: "add"
+			});
+		});
+		this.#watcher.on("change", (filePath) => {
+			this.#handleHmrWatcherEvent({
+				filePath,
+				action: "change",
+				displayLabel: "update"
+			});
+		});
+		this.#watcher.on("unlink", (filePath) => {
+			this.#handleHmrWatcherEvent({
+				filePath,
+				action: "unlink",
+				displayLabel: "delete"
+			});
+		});
+	}
+	/**
+	* Starts the development server in watch mode and restarts on file changes
+	*
+	* Initializes the server, starts the HTTP server, and sets up a file system
+	* watcher that monitors for changes. When files are added, modified, or deleted,
+	* the server automatically restarts. The watcher respects TypeScript project
+	* configuration and metaFiles settings.
+	*
+	* @param ts - TypeScript module reference
+	* @param options - Watch options including polling mode
+	*
+	* @example
+	* const devServer = new DevServer(cwd, { hooks: [] })
+	* await devServer.startAndWatch(ts, { poll: false })
+	*/
+	async startAndWatch(options) {
+		if (!await this.#init("watch")) return;
+		this.ui.logger.info("starting HTTP server...");
+		await this.#startHTTPServer(this.#stickyPort, this.#stickyHmrPort);
+		this.#watcher = this.#createWatcher({ poll: options?.poll });
+		this.#watcher.on("add", (filePath) => {
+			const relativePath = string.toUnixSlash(filePath);
+			const absolutePath = join(this.cwdPath, relativePath);
+			this.#hooks.runner("fileAdded").run(relativePath, absolutePath, this);
+		});
+		this.#watcher.on("change", (filePath) => {
+			const relativePath = string.toUnixSlash(filePath);
+			const absolutePath = join(this.cwdPath, relativePath);
+			this.#hooks.runner("fileChanged").run(relativePath, absolutePath, DevServer.#WATCHER_INFO, this);
+		});
+		this.#watcher.on("unlink", (filePath) => {
+			const relativePath = string.toUnixSlash(filePath);
+			const absolutePath = join(this.cwdPath, relativePath);
+			this.#hooks.runner("fileRemoved").run(relativePath, absolutePath, this);
+		});
+	}
 };
-
-// src/test_runner.ts
-import { join as join3 } from "path/posix";
-import { cliui as cliui3 } from "@poppinss/cliui";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import string4 from "@poppinss/utils/string";
-import { RuntimeException as RuntimeException2 } from "@poppinss/utils/exception";
+//#endregion
+//#region src/test_runner.ts
+/**
+* Exposes the API to run Japa tests and optionally watch for file
+* changes to re-run the tests.
+*
+* The TestRunner provides intelligent test execution with watch mode capabilities.
+* When files change, it can selectively run specific tests or the entire suite
+* based on what changed.
+*
+* The watch mode functions as follows:
+*  - If the changed file is a test file, then only tests for that file
+*    will be re-run.
+*  - Otherwise, all tests will re-run with respect to the initial
+*    filters applied when running the `node ace test` command.
+*
+* @example
+* const testRunner = new TestRunner(cwd, { suites: [], hooks: [] })
+* await testRunner.run()
+*
+* @example
+* // Run tests in watch mode
+* const testRunner = new TestRunner(cwd, { suites: [], hooks: [] })
+* await testRunner.runAndWatch(ts, { poll: false })
+*/
 var TestRunner = class {
-  /**
-   * External listeners that are invoked when child process
-   * gets an error or closes
-   */
-  #onError;
-  #onClose;
-  /**
-   * The stickyPort is set by the startAndWatch method and we will
-   * continue to use this port during re-runs
-   */
-  #stickyPort;
-  /**
-   * Reference to chokidar watcher
-   */
-  #watcher;
-  /**
-   * Reference to the test script child process
-   */
-  #testsProcess;
-  /**
-   * Filesystem is used to decide which files to watch or entertain in watch
-   * mode
-   */
-  #fileSystem;
-  /**
-   * Hooks to execute custom actions during the tests runner lifecycle
-   */
-  #hooks;
-  /**
-   * Index generator for managing auto-generated index files
-   */
-  #indexGenerator;
-  /**
-   * CLI UI instance for displaying colorful messages and progress information
-   */
-  ui = cliui3();
-  /**
-   * Re-runs the test child process and throttle concurrent calls to
-   * ensure we do not end up with a long loop of restarts
-   */
-  #reRunTests = throttle(async (filters) => {
-    if (this.#testsProcess) {
-      this.#testsProcess.removeAllListeners();
-      this.#testsProcess.kill("SIGKILL");
-    }
-    await this.#runTests(this.#stickyPort, filters);
-  }, "reRunTests");
-  /**
-   * The script file to run as a child process
-   */
-  scriptFile = "bin/test.ts";
-  /**
-   * The current working directory URL
-   */
-  cwd;
-  /**
-   * The current working directory path as a string
-   */
-  cwdPath;
-  /**
-   * Test runner configuration options including filters, reporters, and hooks
-   */
-  options;
-  /**
-   * Create a new TestRunner instance
-   *
-   * @param cwd - The current working directory URL
-   * @param options - Test runner configuration options
-   */
-  constructor(cwd, options) {
-    this.cwd = cwd;
-    this.options = options;
-    this.cwdPath = string4.toUnixSlash(fileURLToPath3(this.cwd));
-  }
-  /**
-   * Convert test runner options to the CLI args
-   *
-   * Transforms the test runner configuration options into command-line
-   * arguments that can be passed to the test script.
-   *
-   * @returns Array of command-line arguments
-   */
-  #convertOptionsToArgs() {
-    const args = [];
-    if (this.options.reporters) {
-      args.push("--reporters");
-      args.push(this.options.reporters.join(","));
-    }
-    if (this.options.timeout !== void 0) {
-      args.push("--timeout");
-      args.push(String(this.options.timeout));
-    }
-    if (this.options.failed) {
-      args.push("--failed");
-    }
-    if (this.options.retries !== void 0) {
-      args.push("--retries");
-      args.push(String(this.options.retries));
-    }
-    return args;
-  }
-  /**
-   * Converts all known filters to CLI args
-   *
-   * Transforms test filters (suites, files, groups, tags, tests) into
-   * command-line arguments for the test script.
-   *
-   * @param filters - The test filters to convert
-   * @returns Array of command-line arguments representing the filters
-   */
-  #convertFiltersToArgs(filters) {
-    const args = [];
-    if (filters.suites) {
-      args.push(...filters.suites);
-    }
-    if (filters.files) {
-      args.push("--files");
-      args.push(filters.files.join(","));
-    }
-    if (filters.groups) {
-      args.push("--groups");
-      args.push(filters.groups.join(","));
-    }
-    if (filters.tags) {
-      args.push("--tags");
-      args.push(filters.tags.join(","));
-    }
-    if (filters.tests) {
-      args.push("--tests");
-      args.push(filters.tests.join(","));
-    }
-    return args;
-  }
-  /**
-   * Conditionally clear the terminal screen
-   *
-   * Clears the terminal screen if the clearScreen option is enabled
-   * in the test runner configuration.
-   */
-  #clearScreen() {
-    if (this.options.clearScreen) {
-      process.stdout.write("\x1Bc");
-    }
-  }
-  /**
-   * Runs tests as a child process
-   *
-   * Creates a Node.js child process to execute the test script with
-   * appropriate command-line arguments and environment variables.
-   * Handles process lifecycle and hook execution.
-   *
-   * @param port - The port number to set in the environment
-   * @param filters - Optional test filters to apply for this run
-   */
-  async #runTests(port, filters) {
-    await this.#hooks.runner("testsStarting").run(this);
-    debug_default('running tests using "%s" file, options %O', this.scriptFile, this.options);
-    return new Promise(async (resolve) => {
-      const mergedFilters = { ...this.options.filters, ...filters };
-      const scriptArgs = [
-        ...this.#convertOptionsToArgs(),
-        ...this.options.scriptArgs,
-        ...this.#convertFiltersToArgs(mergedFilters)
-      ];
-      this.#testsProcess = runNode(this.cwd, {
-        script: this.scriptFile,
-        reject: true,
-        env: { PORT: port, ...this.options.env },
-        nodeArgs: this.options.nodeArgs,
-        scriptArgs
-      });
-      this.#testsProcess.then((result) => {
-        this.#hooks.runner("testsFinished").run(this).catch((error) => {
-          this.ui.logger.error('One of the "testsFinished" hooks failed');
-          this.ui.logger.fatal(error);
-        }).finally(() => {
-          if (!this.#watcher) {
-            this.#onClose?.(result.exitCode);
-            this.close();
-          }
-        });
-      }).catch((error) => {
-        if (!this.#watcher) {
-          this.#onError?.(error);
-          this.close();
-        } else {
-          this.ui.logger.info("Underlying HTTP server died. Still watching for changes");
-        }
-      }).finally(() => resolve());
-    });
-  }
-  /**
-   * Handles file change event during watch mode
-   *
-   * Determines whether to run specific tests or all tests based on
-   * the type of file that changed. Test files trigger selective runs,
-   * while other files trigger full test suite runs.
-   *
-   * @param filePath - The path of the changed file
-   * @param action - The type of change (add, update, delete)
-   */
-  #handleFileChange(relativePath, absolutePath, action) {
-    const file = this.#fileSystem.inspect(absolutePath, relativePath);
-    if (!file) {
-      return;
-    }
-    this.#clearScreen();
-    this.ui.logger.log(`${this.ui.colors.green(action)} ${relativePath}`);
-    if (file.fileType === "test") {
-      this.#reRunTests({ files: [relativePath] });
-    } else {
-      this.#reRunTests();
-    }
-  }
-  /**
-   * Re-generates the index when a file is changed, but only in HMR
-   * mode
-   */
-  #regenerateIndex(filePath, action) {
-    if (action === "add") {
-      return this.#indexGenerator.addFile(filePath);
-    }
-    return this.#indexGenerator.removeFile(filePath);
-  }
-  /**
-   * Registers inline hooks for file changes and test re-runs
-   *
-   * Sets up event handlers that respond to file system changes by
-   * triggering appropriate test runs based on the changed files.
-   */
-  #registerServerRestartHooks() {
-    this.#hooks.add("fileAdded", (relativePath, absolutePath) => {
-      this.#regenerateIndex(absolutePath, "add");
-      this.#handleFileChange(relativePath, absolutePath, "add");
-    });
-    this.#hooks.add("fileChanged", (relativePath, absolutePath) => {
-      this.#regenerateIndex(absolutePath, "add");
-      this.#handleFileChange(relativePath, absolutePath, "update");
-    });
-    this.#hooks.add("fileRemoved", (relativePath, absolutePath) => {
-      this.#regenerateIndex(absolutePath, "delete");
-      this.#handleFileChange(relativePath, absolutePath, "delete");
-    });
-  }
-  /**
-   * Add listener to get notified when test runner is closed
-   *
-   * @param callback - Function to call when test runner closes
-   * @returns This TestRunner instance for method chaining
-   */
-  onClose(callback) {
-    this.#onClose = callback;
-    return this;
-  }
-  /**
-   * Add listener to get notified when test runner encounters an error
-   *
-   * @param callback - Function to call when test runner encounters an error
-   * @returns This TestRunner instance for method chaining
-   */
-  onError(callback) {
-    this.#onError = callback;
-    return this;
-  }
-  /**
-   * Close watchers and running child processes
-   *
-   * Cleans up file system watchers and terminates any running test
-   * processes to ensure graceful shutdown.
-   */
-  async close() {
-    await this.#watcher?.close();
-    if (this.#testsProcess) {
-      this.#testsProcess.removeAllListeners();
-      this.#testsProcess.kill("SIGKILL");
-    }
-  }
-  /**
-   * Runs tests once without watching for file changes
-   *
-   * Executes the test suite a single time and exits. This is the
-   * equivalent of running tests in CI/CD environments.
-   */
-  async run() {
-    this.#stickyPort = String(await getPort(this.cwd));
-    this.#indexGenerator = new IndexGenerator(this.cwdPath, this.ui.logger);
-    this.#clearScreen();
-    this.ui.logger.info("loading hooks...");
-    this.#hooks = await loadHooks(this.options.hooks, ["init", "testsStarting", "testsFinished"]);
-    await this.#hooks.runner("init").run(this, this.#indexGenerator);
-    this.#hooks.clear("init");
-    this.ui.logger.info("generating indexes...");
-    await this.#indexGenerator.generate();
-    this.ui.logger.info("booting application to run tests...");
-    await this.#runTests(this.#stickyPort);
-  }
-  /**
-   * Run tests in watch mode and re-run them when files change
-   *
-   * Starts the test runner in watch mode, monitoring the file system
-   * for changes and automatically re-running tests when relevant files
-   * are modified. Uses intelligent filtering to run only affected tests
-   * when possible.
-   *
-   * @param ts - TypeScript module reference for parsing configuration
-   * @param options - Watch options including polling mode for file system monitoring
-   */
-  async runAndWatch(ts, options) {
-    const tsConfig = parseConfig(this.cwd, ts);
-    if (!tsConfig) {
-      this.#onError?.(new RuntimeException2("Unable to parse tsconfig file"));
-      return;
-    }
-    this.#stickyPort = String(await getPort(this.cwd));
-    this.#indexGenerator = new IndexGenerator(this.cwdPath, this.ui.logger);
-    this.#fileSystem = new FileSystem(this.cwdPath, tsConfig, {
-      ...this.options,
-      suites: this.options.suites?.filter((suite) => {
-        if (this.options.filters.suites) {
-          return this.options.filters.suites.includes(suite.name);
-        }
-        return true;
-      })
-    });
-    this.#clearScreen();
-    this.ui.logger.info("loading hooks...");
-    this.#hooks = await loadHooks(this.options.hooks, [
-      "init",
-      "testsStarting",
-      "testsFinished",
-      "fileAdded",
-      "fileChanged",
-      "fileRemoved"
-    ]);
-    this.#registerServerRestartHooks();
-    await this.#hooks.runner("init").run(this, this.#indexGenerator);
-    this.#hooks.clear("init");
-    this.ui.logger.info("generating indexes...");
-    await this.#indexGenerator.generate();
-    this.ui.logger.info("booting application to run tests...");
-    await this.#runTests(this.#stickyPort);
-    this.#watcher = watch({
-      usePolling: options?.poll ?? false,
-      cwd: this.cwdPath,
-      ignoreInitial: true,
-      ignored: (file, stats) => {
-        if (!stats) {
-          return false;
-        }
-        if (stats.isFile()) {
-          return !this.#fileSystem.shouldWatchFile(file);
-        }
-        return !this.#fileSystem.shouldWatchDirectory(file);
-      }
-    });
-    this.#watcher.on("ready", () => {
-      this.ui.logger.info("watching file system for changes...");
-    });
-    this.#watcher.on("error", (error) => {
-      this.ui.logger.warning("file system watcher failure");
-      this.ui.logger.fatal(error);
-      this.#onError?.(error);
-      this.#watcher?.close();
-    });
-    this.#watcher.on("add", (filePath) => {
-      const relativePath = string4.toUnixSlash(filePath);
-      const absolutePath = join3(this.cwdPath, filePath);
-      this.#hooks.runner("fileAdded").run(relativePath, absolutePath, this);
-    });
-    this.#watcher.on("change", (filePath) => {
-      const relativePath = string4.toUnixSlash(filePath);
-      const absolutePath = join3(this.cwdPath, filePath);
-      this.#hooks.runner("fileChanged").run(
-        relativePath,
-        absolutePath,
-        {
-          source: "watcher",
-          fullReload: true,
-          hotReloaded: false
-        },
-        this
-      );
-    });
-    this.#watcher.on("unlink", (filePath) => {
-      const relativePath = string4.toUnixSlash(filePath);
-      const absolutePath = join3(this.cwdPath, filePath);
-      this.#hooks.runner("fileRemoved").run(relativePath, absolutePath, this);
-    });
-  }
-};
-export {
-  Bundler,
-  DevServer,
-  FileBuffer,
-  SUPPORTED_PACKAGE_MANAGERS,
-  TestRunner,
-  VirtualFileSystem,
-  hooks
+	/**
+	* External listeners that are invoked when child process
+	* gets an error or closes
+	*/
+	#onError;
+	#onClose;
+	/**
+	* The stickyPort is set by the startAndWatch method and we will
+	* continue to use this port during re-runs
+	*/
+	#stickyPort;
+	/**
+	* The stickyHmrPort is set by the start and the startAndWatch methods
+	* and we will continue to use that port during restart
+	*/
+	#stickyHmrPort;
+	/**
+	* Reference to chokidar watcher
+	*/
+	#watcher;
+	/**
+	* Reference to the test script child process
+	*/
+	#testsProcess;
+	/**
+	* Filesystem is used to decide which files to watch or entertain in watch
+	* mode
+	*/
+	#fileSystem;
+	/**
+	* Hooks to execute custom actions during the tests runner lifecycle
+	*/
+	#hooks;
+	/**
+	* Index generator for managing auto-generated index files
+	*/
+	#indexGenerator;
+	/**
+	* CLI UI instance for displaying colorful messages and progress information
+	*/
+	ui = cliui();
+	/**
+	* Re-runs the test child process and throttle concurrent calls to
+	* ensure we do not end up with a long loop of restarts
+	*/
+	#reRunTests = throttle(async (filters) => {
+		if (this.#testsProcess) {
+			this.#testsProcess.removeAllListeners();
+			this.#testsProcess.kill("SIGKILL");
+		}
+		await this.#runTests(this.#stickyPort, this.#stickyHmrPort, filters);
+	}, "reRunTests");
+	/**
+	* The script file to run as a child process
+	*/
+	scriptFile = "bin/test.ts";
+	/**
+	* The current working directory URL
+	*/
+	cwd;
+	/**
+	* The current working directory path as a string
+	*/
+	cwdPath;
+	/**
+	* Test runner configuration options including filters, reporters, and hooks
+	*/
+	options;
+	/**
+	* Create a new TestRunner instance
+	*
+	* @param cwd - The current working directory URL
+	* @param options - Test runner configuration options
+	*/
+	constructor(cwd, options) {
+		this.cwd = cwd;
+		this.options = options;
+		this.cwdPath = string.toUnixSlash(fileURLToPath(this.cwd));
+	}
+	/**
+	* Convert test runner options to the CLI args
+	*
+	* Transforms the test runner configuration options into command-line
+	* arguments that can be passed to the test script.
+	*
+	* @returns Array of command-line arguments
+	*/
+	#convertOptionsToArgs() {
+		const args = [];
+		if (this.options.reporters) {
+			args.push("--reporters");
+			args.push(this.options.reporters.join(","));
+		}
+		if (this.options.timeout !== void 0) {
+			args.push("--timeout");
+			args.push(String(this.options.timeout));
+		}
+		if (this.options.failed) args.push("--failed");
+		if (this.options.retries !== void 0) {
+			args.push("--retries");
+			args.push(String(this.options.retries));
+		}
+		return args;
+	}
+	/**
+	* Converts all known filters to CLI args
+	*
+	* Transforms test filters (suites, files, groups, tags, tests) into
+	* command-line arguments for the test script.
+	*
+	* @param filters - The test filters to convert
+	* @returns Array of command-line arguments representing the filters
+	*/
+	#convertFiltersToArgs(filters) {
+		const args = [];
+		if (filters.suites) args.push(...filters.suites);
+		if (filters.files) {
+			args.push("--files");
+			args.push(filters.files.join(","));
+		}
+		if (filters.groups) {
+			args.push("--groups");
+			args.push(filters.groups.join(","));
+		}
+		if (filters.tags) {
+			args.push("--tags");
+			args.push(filters.tags.join(","));
+		}
+		if (filters.tests) {
+			args.push("--tests");
+			args.push(filters.tests.join(","));
+		}
+		return args;
+	}
+	/**
+	* Conditionally clear the terminal screen
+	*
+	* Clears the terminal screen if the clearScreen option is enabled
+	* in the test runner configuration.
+	*/
+	#clearScreen() {
+		if (this.options.clearScreen) process.stdout.write("\x1Bc");
+	}
+	/**
+	* Runs tests as a child process
+	*
+	* Creates a Node.js child process to execute the test script with
+	* appropriate command-line arguments and environment variables.
+	* Handles process lifecycle and hook execution.
+	*
+	* @param port - The port number to set in the environment
+	* @param filters - Optional test filters to apply for this run
+	*/
+	async #runTests(port, hmrPort, filters) {
+		/**
+		* Execute the registered before creating the child process. This will allow
+		* hooks to modify the options before they are used.
+		*/
+		await this.#hooks.runner("testsStarting").run(this);
+		debug_default("running tests using \"%s\" file, options %O", this.scriptFile, this.options);
+		return new Promise(async (resolve) => {
+			/**
+			* If inline filters are defined, then we ignore the
+			* initial filters
+			*/
+			const mergedFilters = {
+				...this.options.filters,
+				...filters
+			};
+			const scriptArgs = [
+				...this.#convertOptionsToArgs(),
+				...this.options.scriptArgs,
+				...this.#convertFiltersToArgs(mergedFilters)
+			];
+			this.#testsProcess = runNode(this.cwd, {
+				script: this.scriptFile,
+				reject: true,
+				env: {
+					PORT: port,
+					VITE_HMR_PORT: hmrPort,
+					...this.options.env
+				},
+				nodeArgs: this.options.nodeArgs,
+				scriptArgs
+			});
+			this.#testsProcess.then((result) => {
+				this.#hooks.runner("testsFinished").run(this).catch((error) => {
+					this.ui.logger.error("One of the \"testsFinished\" hooks failed");
+					this.ui.logger.fatal(error);
+				}).finally(() => {
+					if (!this.#watcher) {
+						this.#onClose?.(result.exitCode);
+						this.close();
+					}
+				});
+			}).catch((error) => {
+				if (!this.#watcher) {
+					this.#onError?.(error);
+					this.close();
+				} else this.ui.logger.info("Underlying HTTP server died. Still watching for changes");
+			}).finally(() => resolve());
+		});
+	}
+	/**
+	* Handles file change event during watch mode
+	*
+	* Determines whether to run specific tests or all tests based on
+	* the type of file that changed. Test files trigger selective runs,
+	* while other files trigger full test suite runs.
+	*
+	* @param filePath - The path of the changed file
+	* @param action - The type of change (add, update, delete)
+	*/
+	#handleFileChange(relativePath, absolutePath, action) {
+		const file = this.#fileSystem.inspect(absolutePath, relativePath);
+		if (!file) return;
+		this.#clearScreen();
+		this.ui.logger.log(`${this.ui.colors.green(action)} ${relativePath}`);
+		if (file.fileType === "test") this.#reRunTests({ files: [relativePath] });
+		else this.#reRunTests();
+	}
+	/**
+	* Re-generates the index when a file is changed, but only in HMR
+	* mode
+	*/
+	#regenerateIndex(filePath, action) {
+		if (action === "add") return this.#indexGenerator.addFile(filePath);
+		return this.#indexGenerator.removeFile(filePath);
+	}
+	/**
+	* Registers inline hooks for file changes and test re-runs
+	*
+	* Sets up event handlers that respond to file system changes by
+	* triggering appropriate test runs based on the changed files.
+	*/
+	#registerServerRestartHooks() {
+		this.#hooks.add("fileAdded", (relativePath, absolutePath) => {
+			this.#regenerateIndex(absolutePath, "add");
+			this.#handleFileChange(relativePath, absolutePath, "add");
+		});
+		this.#hooks.add("fileChanged", (relativePath, absolutePath) => {
+			this.#regenerateIndex(absolutePath, "add");
+			this.#handleFileChange(relativePath, absolutePath, "update");
+		});
+		this.#hooks.add("fileRemoved", (relativePath, absolutePath) => {
+			this.#regenerateIndex(absolutePath, "delete");
+			this.#handleFileChange(relativePath, absolutePath, "delete");
+		});
+	}
+	/**
+	* Add listener to get notified when test runner is closed
+	*
+	* @param callback - Function to call when test runner closes
+	* @returns This TestRunner instance for method chaining
+	*/
+	onClose(callback) {
+		this.#onClose = callback;
+		return this;
+	}
+	/**
+	* Add listener to get notified when test runner encounters an error
+	*
+	* @param callback - Function to call when test runner encounters an error
+	* @returns This TestRunner instance for method chaining
+	*/
+	onError(callback) {
+		this.#onError = callback;
+		return this;
+	}
+	/**
+	* Close watchers and running child processes
+	*
+	* Cleans up file system watchers and terminates any running test
+	* processes to ensure graceful shutdown.
+	*/
+	async close() {
+		await this.#watcher?.close();
+		if (this.#testsProcess) {
+			this.#testsProcess.removeAllListeners();
+			this.#testsProcess.kill("SIGKILL");
+		}
+	}
+	/**
+	* Runs tests once without watching for file changes
+	*
+	* Executes the test suite a single time and exits. This is the
+	* equivalent of running tests in CI/CD environments.
+	*/
+	async run() {
+		this.#stickyPort = String(await getPort(this.cwd));
+		this.#stickyHmrPort = String(await getRandomPort({ port: 24678 }));
+		this.#indexGenerator = new IndexGenerator(this.cwdPath, this.ui.logger);
+		this.#clearScreen();
+		this.ui.logger.info("loading hooks...");
+		this.#hooks = await loadHooks(this.options.hooks, [
+			"init",
+			"testsStarting",
+			"testsFinished"
+		]);
+		/**
+		* Run init hooks and clear them as they won't be executed
+		* ever again
+		*/
+		await this.#hooks.runner("init").run(this, this.#hooks, this.#indexGenerator);
+		this.#hooks.clear("init");
+		this.ui.logger.info("generating indexes...");
+		await this.#indexGenerator.generate();
+		this.ui.logger.info("booting application to run tests...");
+		await this.#runTests(this.#stickyPort, this.#stickyHmrPort);
+	}
+	/**
+	* Run tests in watch mode and re-run them when files change
+	*
+	* Starts the test runner in watch mode, monitoring the file system
+	* for changes and automatically re-running tests when relevant files
+	* are modified. Uses intelligent filtering to run only affected tests
+	* when possible.
+	*
+	* @param ts - TypeScript module reference for parsing configuration
+	* @param options - Watch options including polling mode for file system monitoring
+	*/
+	async runAndWatch(options) {
+		const tsConfig = readTsConfig(this.cwdPath);
+		if (!tsConfig) {
+			this.#onError?.(new RuntimeException("Unable to parse tsconfig file"));
+			return;
+		}
+		this.#stickyPort = String(await getPort(this.cwd));
+		this.#stickyHmrPort = String(getRandomPort({ port: 24678 }));
+		this.#indexGenerator = new IndexGenerator(this.cwdPath, this.ui.logger);
+		this.#fileSystem = new FileSystem(this.cwdPath, tsConfig, {
+			...this.options,
+			suites: this.options.suites?.filter((suite) => {
+				if (this.options.filters.suites) return this.options.filters.suites.includes(suite.name);
+				return true;
+			})
+		});
+		this.#clearScreen();
+		this.ui.logger.info("loading hooks...");
+		this.#hooks = await loadHooks(this.options.hooks, [
+			"init",
+			"testsStarting",
+			"testsFinished",
+			"fileAdded",
+			"fileChanged",
+			"fileRemoved"
+		]);
+		this.#registerServerRestartHooks();
+		/**
+		* Run init hooks and clear them as they won't be executed
+		* ever again
+		*/
+		await this.#hooks.runner("init").run(this, this.#hooks, this.#indexGenerator);
+		this.#hooks.clear("init");
+		this.ui.logger.info("generating indexes...");
+		await this.#indexGenerator.generate();
+		this.ui.logger.info("booting application to run tests...");
+		await this.#runTests(this.#stickyPort, this.#stickyHmrPort);
+		/**
+		* Create watcher
+		*/
+		this.#watcher = watch({
+			usePolling: options?.poll ?? false,
+			cwd: this.cwdPath,
+			ignoreInitial: true,
+			ignored: (file, stats) => {
+				if (!stats) return false;
+				if (stats.isFile()) return !this.#fileSystem.shouldWatchFile(file);
+				return !this.#fileSystem.shouldWatchDirectory(file);
+			}
+		});
+		/**
+		* Notify the watcher is ready
+		*/
+		this.#watcher.on("ready", () => {
+			this.ui.logger.info("watching file system for changes...");
+		});
+		/**
+		* Cleanup when watcher dies
+		*/
+		this.#watcher.on("error", (error) => {
+			this.ui.logger.warning("file system watcher failure");
+			this.ui.logger.fatal(error);
+			this.#onError?.(error);
+			this.#watcher?.close();
+		});
+		this.#watcher.on("add", (filePath) => {
+			const relativePath = string.toUnixSlash(filePath);
+			const absolutePath = join(this.cwdPath, filePath);
+			this.#hooks.runner("fileAdded").run(relativePath, absolutePath, this);
+		});
+		this.#watcher.on("change", (filePath) => {
+			const relativePath = string.toUnixSlash(filePath);
+			const absolutePath = join(this.cwdPath, filePath);
+			this.#hooks.runner("fileChanged").run(relativePath, absolutePath, {
+				source: "watcher",
+				fullReload: true,
+				hotReloaded: false
+			}, this);
+		});
+		this.#watcher.on("unlink", (filePath) => {
+			const relativePath = string.toUnixSlash(filePath);
+			const absolutePath = join(this.cwdPath, filePath);
+			this.#hooks.runner("fileRemoved").run(relativePath, absolutePath, this);
+		});
+	}
 };
+//#endregion
+export { Bundler, CodemodException, DevServer, FileBuffer, SUPPORTED_PACKAGE_MANAGERS, TestRunner, VirtualFileSystem };