@adonisjs/assembler 7.8.1 → 8.0.0-next.0

package/build/index.js

@@ -1,124 +1,57 @@
+import {
+  debug_default
+} from "./chunk-RR4HCA4M.js";
+
 // src/bundler.ts
-import slash from "slash";
 import dedent from "dedent";
-import fs from "node:fs/promises";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { join as join2, relative as relative2 } from "node:path";
+import fs from "fs/promises";
 import { cliui } from "@poppinss/cliui";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { join as join2, relative as relative2 } from "path";
+import string from "@poppinss/utils/string";
 import { detectPackageManager } from "@antfu/install-pkg";
 
-// src/hooks.ts
-import { RuntimeException } from "@poppinss/utils";
-import Hooks from "@poppinss/hooks";
-var AssemblerHooks = class {
-  #config;
-  #hooks = new Hooks();
-  constructor(config) {
-    this.#config = config;
-  }
-  /**
-   * Resolve the hook by importing the file and returning the default export
-   */
-  async #resolveHookNode(node) {
-    const exports = await node();
-    if (!exports.default) {
-      throw new RuntimeException("Assembler hook must be defined using the default export");
-    }
-    return exports.default;
-  }
-  /**
-   * Resolve hooks needed for dev-time and register them to the Hooks instance
-   */
-  async registerDevServerHooks() {
-    await Promise.all([
-      ...(this.#config?.onDevServerStarted || []).map(
-        async (node) => this.#hooks.add("onDevServerStarted", await this.#resolveHookNode(node))
-      ),
-      ...(this.#config?.onSourceFileChanged || []).map(
-        async (node) => this.#hooks.add("onSourceFileChanged", await this.#resolveHookNode(node))
-      )
-    ]);
-  }
-  /**
-   * Resolve hooks needed for build-time and register them to the Hooks instance
-   */
-  async registerBuildHooks() {
-    await Promise.all([
-      ...(this.#config?.onBuildStarting || []).map(
-        async (node) => this.#hooks.add("onBuildStarting", await this.#resolveHookNode(node))
-      ),
-      ...(this.#config?.onBuildCompleted || []).map(
-        async (node) => this.#hooks.add("onBuildCompleted", await this.#resolveHookNode(node))
-      )
-    ]);
-  }
-  /**
-   * When the dev server is started
-   */
-  async onDevServerStarted(...args) {
-    await this.#hooks.runner("onDevServerStarted").run(...args);
-  }
-  /**
-   * When a source file changes
-   */
-  async onSourceFileChanged(...args) {
-    await this.#hooks.runner("onSourceFileChanged").run(...args);
-  }
-  /**
-   * When the build process is starting
-   */
-  async onBuildStarting(...args) {
-    await this.#hooks.runner("onBuildStarting").run(...args);
-  }
-  /**
-   * When the build process is completed
-   */
-  async onBuildCompleted(...args) {
-    await this.#hooks.runner("onBuildCompleted").run(...args);
-  }
-};
-
-// src/helpers.ts
+// src/utils.ts
+import Cache from "tmp-cache";
 import { isJunk } from "junk";
 import fastGlob from "fast-glob";
+import Hooks from "@poppinss/hooks";
+import { existsSync } from "fs";
 import getRandomPort from "get-port";
-import { existsSync } from "node:fs";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath } from "url";
 import { execaNode, execa } from "execa";
-import { copyFile, mkdir } from "node:fs/promises";
+import { importDefault } from "@poppinss/utils";
+import { copyFile, mkdir } from "fs/promises";
 import { EnvLoader, EnvParser } from "@adonisjs/env";
-import { ConfigParser, Watcher } from "@poppinss/chokidar-ts";
-import { basename, dirname, isAbsolute, join, relative } from "node:path";
-
-// src/debug.ts
-import { debuglog } from "node:util";
-var debug_default = debuglog("adonisjs:assembler");
-
-// src/helpers.ts
-var DEFAULT_NODE_ARGS = [
-  // Use ts-node/esm loader. The project must install it
-  process.versions.tsNodeMaintained ? "--import=ts-node-maintained/register/esm" : "--loader=ts-node/esm",
-  // Enable source maps, since TSNode source maps are broken
-  "--enable-source-maps"
-];
-if (process.allowedNodeEnvironmentFlags.has("--disable-warning")) {
-  DEFAULT_NODE_ARGS.push("--disable-warning=ExperimentalWarning");
-} else {
-  DEFAULT_NODE_ARGS.push("--no-warnings");
-}
+import chokidar from "chokidar";
+import { basename, dirname, isAbsolute, join, relative } from "path";
+var DEFAULT_NODE_ARGS = ["--import=@poppinss/ts-exec", "--enable-source-maps"];
 function parseConfig(cwd, ts) {
-  const { config, error } = new ConfigParser(cwd, "tsconfig.json", ts).parse();
-  if (error) {
+  const cwdPath = typeof cwd === "string" ? cwd : fileURLToPath(cwd);
+  const configFile = join(cwdPath, "tsconfig.json");
+  debug_default('parsing config file "%s"', configFile);
+  let hardException = null;
+  const parsedConfig = ts.getParsedCommandLineOfConfigFile(
+    configFile,
+    {},
+    {
+      ...ts.sys,
+      useCaseSensitiveFileNames: true,
+      getCurrentDirectory: () => cwdPath,
+      onUnRecoverableConfigFileDiagnostic: (error) => hardException = error
+    }
+  );
+  if (hardException) {
     const compilerHost = ts.createCompilerHost({});
-    console.log(ts.formatDiagnosticsWithColorAndContext([error], compilerHost));
+    console.log(ts.formatDiagnosticsWithColorAndContext([hardException], compilerHost));
     return;
   }
-  if (config.errors.length) {
+  if (parsedConfig.errors.length) {
     const compilerHost = ts.createCompilerHost({});
-    console.log(ts.formatDiagnosticsWithColorAndContext(config.errors, compilerHost));
+    console.log(ts.formatDiagnosticsWithColorAndContext(parsedConfig.errors, compilerHost));
     return;
   }
-  return config;
+  return parsedConfig;
 }
 function runNode(cwd, options) {
   const childProcess = execaNode(options.script, options.scriptArgs, {
@@ -152,20 +85,8 @@ function run(cwd, options) {
   });
   return childProcess;
 }
-function watch(cwd, ts, options) {
-  const config = parseConfig(cwd, ts);
-  if (!config) {
-    return;
-  }
-  const watcher = new Watcher(typeof cwd === "string" ? cwd : fileURLToPath(cwd), config);
-  const chokidar = watcher.watch(["."], { usePolling: options.poll });
-  return { watcher, chokidar };
-}
-function isDotEnvFile(filePath) {
-  if (filePath === ".env") {
-    return true;
-  }
-  return filePath.includes(".env.");
+function watch(options) {
+  return chokidar.watch(["."], options);
 }
 async function getPort(cwd) {
   if (process.env.PORT) {
@@ -207,9 +128,57 @@ async function copyFiles(files, cwd, outDir) {
   });
   return await Promise.all(copyPromises);
 }
+function memoize(fn, maxKeys) {
+  const cache = new Cache({ max: maxKeys });
+  return (input) => {
+    if (cache.has(input)) {
+      return cache.get(input);
+    }
+    return fn(input);
+  };
+}
+async function loadHooks(rcFileHooks, names) {
+  const groups = names.map((name) => {
+    return {
+      group: name,
+      hooks: rcFileHooks?.[name] ?? []
+    };
+  });
+  const hooks = new Hooks();
+  for (const { group, hooks: collection } of groups) {
+    for (const item of collection) {
+      hooks.add(group, await importDefault(item));
+    }
+  }
+  return hooks;
+}
+function throttle(fn, name) {
+  name = name || "throttled";
+  let isBusy = false;
+  let hasQueuedCalls = false;
+  let lastCallArgs;
+  async function throttled(...args) {
+    if (isBusy) {
+      debug_default('ignoring "%s" invocation as current execution is in progress', name);
+      hasQueuedCalls = true;
+      lastCallArgs = args;
+      return;
+    }
+    isBusy = true;
+    debug_default('executing "%s" function', name);
+    await fn(...args);
+    isBusy = false;
+    if (hasQueuedCalls) {
+      hasQueuedCalls = false;
+      debug_default('resuming and running latest "%s" invocation', name);
+      await throttled(...lastCallArgs);
+    }
+  }
+  return throttled;
+}
 
 // src/bundler.ts
-var SUPPORT_PACKAGE_MANAGERS = {
+var SUPPORTED_PACKAGE_MANAGERS = {
   "npm": {
     packageManagerFiles: ["package-lock.json"],
     installCommand: 'npm ci --omit="dev"'
@@ -231,33 +200,26 @@ var SUPPORT_PACKAGE_MANAGERS = {
     installCommand: "bun install --production"
   }
 };
-var ui = cliui();
 var Bundler = class {
-  #cwd;
+  constructor(cwd, ts, options) {
+    this.cwd = cwd;
+    this.options = options;
+    this.#cwdPath = fileURLToPath2(this.cwd);
+    this.#ts = ts;
+  }
   #cwdPath;
   #ts;
-  #logger = ui.logger;
-  #hooks;
-  #options;
   /**
-   * Getting reference to colors library from logger
+   * Hooks to execute custom actions during the build process
    */
-  get #colors() {
-    return this.#logger.getColors();
-  }
-  constructor(cwd, ts, options) {
-    this.#cwd = cwd;
-    this.#cwdPath = fileURLToPath2(this.#cwd);
-    this.#ts = ts;
-    this.#options = options;
-    this.#hooks = new AssemblerHooks(options.hooks);
-  }
+  #hooks;
+  ui = cliui();
   /**
    * Returns the relative unix path for an absolute
    * file path
    */
   #getRelativeName(filePath) {
-    return slash(relative2(this.#cwdPath, filePath));
+    return string.toUnixSlash(relative2(this.#cwdPath, filePath));
   }
   /**
    * Cleans up the build directory
@@ -265,32 +227,12 @@ var Bundler = class {
   async #cleanupBuildDirectory(outDir) {
     await fs.rm(outDir, { recursive: true, force: true, maxRetries: 5 });
   }
-  /**
-   * Runs assets bundler command to build assets
-   */
-  async #buildAssets() {
-    const assetsBundler = this.#options.assets;
-    if (!assetsBundler?.enabled) {
-      return true;
-    }
-    try {
-      this.#logger.info("compiling frontend assets", { suffix: assetsBundler.cmd });
-      await run(this.#cwd, {
-        stdio: "inherit",
-        script: assetsBundler.cmd,
-        scriptArgs: assetsBundler.args
-      });
-      return true;
-    } catch {
-      return false;
-    }
-  }
   /**
    * Runs tsc command to build the source.
    */
   async #runTsc(outDir) {
     try {
-      await run(this.#cwd, {
+      await run(this.cwd, {
         stdio: "inherit",
         script: "tsc",
         scriptArgs: ["--outDir", outDir]
@@ -304,26 +246,21 @@ var Bundler = class {
    * Copy meta files to the output directory
    */
   async #copyMetaFiles(outDir, additionalFilesToCopy) {
-    const metaFiles = (this.#options.metaFiles || []).map((file) => file.pattern).concat(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
-   * and return the lockfile name and install command
-   * related to it.
    */
-  async #getPackageManager(client) {
-    let pkgManager = client;
-    if (!pkgManager) {
-      pkgManager = await detectPackageManager(this.#cwdPath);
+  async #detectPackageManager() {
+    const pkgManager = await detectPackageManager(this.#cwdPath);
+    if (pkgManager === "deno") {
+      return "npm";
     }
-    if (!pkgManager) {
-      pkgManager = "npm";
+    if (pkgManager === "pnpm@6") {
+      return "pnpm";
     }
-    if (!Object.keys(SUPPORT_PACKAGE_MANAGERS).includes(pkgManager)) {
-      return null;
-    }
-    return SUPPORT_PACKAGE_MANAGERS[pkgManager];
+    return pkgManager;
   }
   /**
    * Rewrite the ace file since the original one
@@ -345,257 +282,346 @@ var Bundler = class {
     `
     );
     await fs.writeFile(aceFileLocation, aceFileContent);
-    this.#logger.info("rewrited ace file", { suffix: this.#getRelativeName(aceFileLocation) });
-  }
-  /**
-   * Set a custom CLI UI logger
-   */
-  setLogger(logger) {
-    this.#logger = logger;
-    return this;
+    this.ui.logger.info("created ace file", { suffix: this.#getRelativeName(aceFileLocation) });
   }
   /**
    * Bundles the application to be run in production
    */
   async bundle(stopOnError = true, client) {
-    await this.#hooks.registerBuildHooks();
-    const config = parseConfig(this.#cwd, this.#ts);
+    this.#hooks = await loadHooks(this.options.hooks, ["buildStarting", "buildFinished"]);
+    this.packageManager = client ?? await this.#detectPackageManager() ?? "npm";
+    const config = parseConfig(this.cwd, this.#ts);
     if (!config) {
       return false;
     }
-    const outDir = config.options.outDir || fileURLToPath2(new URL("build/", this.#cwd));
-    this.#logger.info("cleaning up output directory", { suffix: this.#getRelativeName(outDir) });
+    const outDir = config.options.outDir || fileURLToPath2(new URL("build/", this.cwd));
+    this.ui.logger.info("cleaning up output directory", { suffix: this.#getRelativeName(outDir) });
     await this.#cleanupBuildDirectory(outDir);
-    if (!await this.#buildAssets()) {
-      return false;
-    }
-    await this.#hooks.onBuildStarting({ colors: ui.colors, logger: this.#logger });
-    this.#logger.info("compiling typescript source", { suffix: "tsc" });
+    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 = ui.sticker().fullScreen().drawBorder((borderChar, colors) => colors.red(borderChar));
+      const instructions = this.ui.sticker().fullScreen().drawBorder((borderChar, colors) => colors.red(borderChar));
       instructions.add(
-        this.#colors.red("Cannot complete the build process as there are TypeScript errors.")
+        this.ui.colors.red("Cannot complete the build process as there are TypeScript errors.")
       );
       instructions.add(
-        this.#colors.red(
+        this.ui.colors.red(
           'Use "--ignore-ts-errors" flag to ignore TypeScript errors and continue the build.'
         )
       );
-      this.#logger.logError(instructions.prepare());
+      this.ui.logger.logError(instructions.prepare());
       return false;
     }
-    const pkgManager = await this.#getPackageManager(client);
-    const pkgFiles = pkgManager ? ["package.json", ...pkgManager.packageManagerFiles] : ["package.json"];
-    this.#logger.info("copying meta files to the output 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.#logger.success("build completed");
-    this.#logger.log("");
-    await this.#hooks.onBuildCompleted({ colors: ui.colors, logger: this.#logger });
-    ui.instructions().useRenderer(this.#logger.getRenderer()).heading("Run the following commands to start the server in production").add(this.#colors.cyan(`cd ${this.#getRelativeName(outDir)}`)).add(
-      this.#colors.cyan(
-        pkgManager ? pkgManager.installCommand : "Install production dependencies"
-      )
-    ).add(this.#colors.cyan("node bin/server.js")).render();
+    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;
   }
 };
 
 // src/dev_server.ts
-import picomatch from "picomatch";
-import { relative as relative3 } from "node:path";
+import { cliui as cliui2 } from "@poppinss/cliui";
 import prettyHrtime from "pretty-hrtime";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { cliui as cliui3 } from "@poppinss/cliui";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import string3 from "@poppinss/utils/string";
 
-// src/assets_dev_server.ts
-import { cliui as cliui2 } from "@poppinss/cliui";
-var ui2 = cliui2();
-var AssetsDevServer = class {
+// src/file_system.ts
+import picomatch from "picomatch";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { join as join3, relative as relative3 } from "path";
+import string2 from "@poppinss/utils/string";
+var DEFAULT_INCLUDES = ["**/*"];
+var ALWAYS_EXCLUDE = [".git/**", "coverage/**", ".github/**"];
+var DEFAULT_EXCLUDES = ["node_modules/**", "bower_components/**", "jspm_packages/**"];
+var FileSystem = class {
+  /**
+   * The current working project directory
+   */
   #cwd;
-  #logger = ui2.logger;
-  #options;
-  #devServer;
   /**
-   * Getting reference to colors library from logger
+   * Referenced to the parsed ts config file. We use it to read the includes,
+   * excludes and pre-scanned files.
    */
-  get #colors() {
-    return this.#logger.getColors();
-  }
-  constructor(cwd, options) {
-    this.#cwd = cwd;
-    this.#options = options;
-  }
+  #tsConfig;
   /**
-   * Logs messages from vite dev server stdout and stderr
+   * Set of pre-scanned typeScript files provided by tsconfig
    */
-  #logViteDevServerMessage(data) {
-    const dataString = data.toString();
-    const lines = dataString.split("\n");
-    if (dataString.includes("Local") && dataString.includes("Network")) {
-      const sticker = ui2.sticker().useColors(this.#colors).useRenderer(this.#logger.getRenderer());
-      lines.forEach((line) => {
-        if (line.trim()) {
-          sticker.add(line);
-        }
-      });
-      sticker.render();
-      return;
-    }
-    if (dataString.includes("ready in")) {
-      console.log("");
-      console.log(dataString.trim());
-      return;
-    }
-    lines.forEach((line) => {
-      if (line.trim()) {
-        console.log(line);
-      }
-    });
-  }
+  #scannedTypeScriptFiles = /* @__PURE__ */ new Set();
   /**
-   * Logs messages from assets dev server stdout and stderr
+   * Picomatch matcher function to know if a file path is
+   * part of includes
    */
-  #logAssetsDevServerMessage(data) {
-    const dataString = data.toString();
-    const lines = dataString.split("\n");
-    lines.forEach((line) => {
-      if (line.trim()) {
-        console.log(line);
-      }
-    });
-  }
+  #isIncluded;
   /**
-   * Set a custom CLI UI logger
+   * Picomatch matcher function to know if a file path is
+   * part of excludes
    */
-  setLogger(logger) {
-    this.#logger = logger;
-    return this;
+  #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
+   */
+  #includes;
+  #excludes;
+  /**
+   * Includes glob patterns extracted from "tsconfig.json" file.
+   * Defaults to: ["**\/*"]
+   */
+  get includes() {
+    return this.#includes;
   }
   /**
-   * Starts the assets bundler server. The assets bundler server process is
-   * considered as the secondary process and therefore we do not perform
-   * any cleanup if it dies.
+   * 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 relative path to find its source in the project
+   */
+  inspect = memoize((filePath) => {
+    const relativePath = filePath;
+    const absolutePath = string2.toUnixSlash(join3(this.#cwd, relativePath));
+    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;
+  });
+  /**
+   * Returns true if the directory should be watched. Chokidar sends
+   * absolute unix paths to the ignored callback.
+   *
+   * You must use "shouldWatchFile" method for files and call this method
+   * for directories only.
    */
-  start() {
-    if (!this.#options?.enabled) {
-      return;
+  shouldWatchDirectory = memoize((absolutePath) => {
+    if (absolutePath === this.#cwd) {
+      debug_default("watching project root");
+      return true;
     }
-    this.#logger.info(`starting "${this.#options.driver}" dev server...`);
-    this.#devServer = run(this.#cwd, {
-      script: this.#options.cmd,
-      /**
-       * We do not inherit the stdio for vite and encore, because in
-       * inherit mode they own the stdin and interrupts the
-       * `Ctrl + C` command.
-       */
-      stdio: "pipe",
-      scriptArgs: this.#options.args
-    });
-    this.#devServer.stdout?.on("data", (data) => {
-      if (this.#options.driver === "vite") {
-        this.#logViteDevServerMessage(data);
-      } else {
-        this.#logAssetsDevServerMessage(data);
+    const relativePath = string2.toUnixSlash(relative3(this.#cwd, absolutePath));
+    if (this.#isExcluded(relativePath)) {
+      debug_default('watching "%s"', absolutePath);
+      return false;
+    }
+    return true;
+  });
+  constructor(cwd, tsConfig, rcFile) {
+    this.#cwd = string2.toUnixSlash(typeof cwd === "string" ? cwd : fileURLToPath3(cwd));
+    this.#tsConfig = tsConfig;
+    const files = tsConfig.fileNames;
+    const metaFiles = rcFile.metaFiles ?? [];
+    const testSuites = rcFile.suites ?? [];
+    const outDir = tsConfig.raw.compilerOptions?.outDir;
+    files.forEach((file) => 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)
+    );
+    this.#isMetaFileWithReloadsEnabled = picomatch(
+      metaFiles.filter((file) => !!file.reloadServer).map((file) => file.pattern),
+      {
+        cwd: this.#cwd
       }
-    });
-    this.#devServer.stderr?.on("data", (data) => {
-      if (this.#options.driver === "vite") {
-        this.#logViteDevServerMessage(data);
-      } else {
-        this.#logAssetsDevServerMessage(data);
+    );
+    this.#isMetaFileWithReloadsDisabled = picomatch(
+      metaFiles.filter((file) => !file.reloadServer).map((file) => file.pattern),
+      {
+        cwd: this.#cwd
       }
+    );
+    this.#isTestFile = picomatch(
+      testSuites.flatMap((suite) => suite.files),
+      {
+        cwd: this.#cwd
+      }
+    );
+    this.#isIncluded = picomatch(this.#includes, {
+      cwd: this.#cwd
     });
-    this.#devServer.then((result) => {
-      this.#logger.warning(
-        `"${this.#options.driver}" dev server closed with status code "${result.exitCode}"`
-      );
-    }).catch((error) => {
-      this.#logger.warning(`unable to connect to "${this.#options.driver}" dev server`);
-      this.#logger.fatal(error);
+    this.#isExcluded = picomatch(this.#excludes, {
+      cwd: this.#cwd
+    });
+    debug_default("initiating file system %O", {
+      includes: this.#includes,
+      excludes: this.#includes,
+      outDir,
+      files,
+      metaFiles,
+      testSuites
     });
   }
   /**
-   * Stop the dev server
+   * Returns a boolean telling if a file path is a script file or not.
+   *
+   * - Files ending with ".ts", ".tsx" are considered are script files.
+   * - Files ending with ".js" with "allowJs" option enabled are considered are script files.
+   * - Files ending with ".json" with "resolveJsonModule" option enabled are considered are script files.
    */
-  stop() {
-    if (this.#devServer) {
-      this.#devServer.removeAllListeners();
-      this.#devServer.kill("SIGKILL");
-      this.#devServer = void 0;
+  #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;
+  }
+  /**
+   * Check if the file path is part of the backend TypeScript project. We use
+   * tsconfig "includes", "excludes", and "files" paths to test if the file
+   * should be considered or not.
+   */
+  #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.
+   */
+  shouldWatchFile(absolutePath) {
+    return this.inspect(relative3(this.#cwd, absolutePath)) !== null;
   }
 };
 
 // src/dev_server.ts
-var ui3 = cliui3();
 var DevServer = class {
-  #cwd;
-  #logger = ui3.logger;
-  #options;
-  /**
-   * Flag to know if the dev server is running in watch
-   * mode
-   */
-  #isWatching = false;
+  constructor(cwd, options) {
+    this.cwd = cwd;
+    this.options = options;
+  }
   /**
-   * Script file to start the development server
+   * External listeners that are invoked when child process
+   * gets an error or closes
    */
-  #scriptFile = "bin/server.js";
+  #onError;
+  #onClose;
   /**
-   * Picomatch matcher function to know if a file path is a
-   * meta file with reloadServer option enabled
+   * The stickyPort is set by the start and the startAndWatch methods
+   * and we will continue to use that port during restart
    */
-  #isMetaFileWithReloadsEnabled;
+  #stickyPort;
   /**
-   * Picomatch matcher function to know if a file path is a
-   * meta file with reloadServer option disabled
+   * The mode is set by the start and the startAndWatch methods
    */
-  #isMetaFileWithReloadsDisabled;
+  #mode = "static";
   /**
-   * External listeners that are invoked when child process
-   * gets an error or closes
+   * Reference to chokidar watcher
    */
-  #onError;
-  #onClose;
+  #watcher;
   /**
    * Reference to the child process
    */
   #httpServer;
   /**
-   * Reference to the watcher
+   * Filesystem is used to decide which files to watch or entertain when
+   * using hot-hook
    */
-  #watcher;
-  /**
-   * Reference to the assets server
-   */
-  #assetsServer;
+  #fileSystem;
   /**
    * Hooks to execute custom actions during the dev server lifecycle
    */
   #hooks;
   /**
-   * Getting reference to colors library from logger
+   * Restarts the HTTP server and throttle concurrent calls to
+   * ensure we do not end up with a long loop of restarts
    */
-  get #colors() {
-    return this.#logger.getColors();
-  }
-  constructor(cwd, options) {
-    this.#cwd = cwd;
-    this.#options = options;
-    this.#hooks = new AssemblerHooks(options.hooks);
-    if (this.#options.hmr) {
-      this.#options.nodeArgs = this.#options.nodeArgs.concat(["--import=hot-hook/register"]);
+  #restartHTTPServer = throttle(async () => {
+    if (this.#httpServer) {
+      this.#httpServer.removeAllListeners();
+      this.#httpServer.kill("SIGKILL");
     }
-    this.#isMetaFileWithReloadsEnabled = picomatch(
-      (this.#options.metaFiles || []).filter(({ reloadServer }) => reloadServer === true).map(({ pattern }) => pattern)
-    );
-    this.#isMetaFileWithReloadsDisabled = picomatch(
-      (this.#options.metaFiles || []).filter(({ reloadServer }) => reloadServer !== true).map(({ pattern }) => pattern)
-    );
+    await this.#startHTTPServer(this.#stickyPort);
+  }, "restartHTTPServer");
+  /**
+   * CLI UI to log colorful messages
+   */
+  ui = cliui2();
+  /**
+   * The mode in which the DevServer is running.
+   */
+  get mode() {
+    return this.#mode;
   }
+  /**
+   * Script file to start the development server
+   */
+  scriptFile = "bin/server.ts";
   /**
    * Inspect if child process message is from AdonisJS HTTP server
    */
@@ -603,7 +629,25 @@ var DevServer = class {
     return message !== null && typeof message === "object" && "isAdonisJS" in message && "environment" in message && message.environment === "web";
   }
   /**
-   * Inspect if child process message is coming from Hot Hook
+   * Displays the server info and executes the hooks after the server has been
+   * started.
+   */
+  async #postServerReady(message) {
+    const host = message.host === "0.0.0.0" ? "127.0.0.1" : message.host;
+    const displayMessage = this.ui.sticker().add(`Server address: ${this.ui.colors.cyan(`http://${host}:${message.port}`)}`).add(`Mode: ${this.ui.colors.cyan(this.mode)}`);
+    if (message.duration) {
+      displayMessage.add(`Ready in: ${this.ui.colors.cyan(prettyHrtime(message.duration))}`);
+    }
+    try {
+      await this.#hooks.runner("devServerStarted").run(this, displayMessage);
+    } catch (error) {
+      this.ui.logger.error('One of the "devServerStarted" hooks failed');
+      this.ui.logger.fatal(error);
+    }
+    displayMessage.render();
+  }
+  /**
+   * Inspect if child process message is coming from hot-hook
    */
   #isHotHookMessage(message) {
     return message !== null && typeof message === "object" && "type" in message && typeof message.type === "string" && message.type.startsWith("hot-hook:");
@@ -612,120 +656,96 @@ var DevServer = class {
    * Conditionally clear the terminal screen
    */
   #clearScreen() {
-    if (this.#options.clearScreen) {
+    if (this.options.clearScreen) {
       process.stdout.write("\x1Bc");
     }
   }
   /**
-   * Starts the HTTP server
-   */
-  #startHTTPServer(port, mode) {
-    const hooksArgs = { colors: this.#colors, logger: this.#logger };
-    this.#httpServer = runNode(this.#cwd, {
-      script: this.#scriptFile,
-      env: { PORT: port, ...this.#options.env },
-      nodeArgs: this.#options.nodeArgs,
-      scriptArgs: this.#options.scriptArgs
-    });
-    this.#httpServer.on("message", async (message) => {
-      if (this.#isHotHookMessage(message)) {
-        const path = relative3(fileURLToPath3(this.#cwd), message.path || message.paths?.[0]);
-        this.#hooks.onSourceFileChanged(hooksArgs, path);
-        if (message.type === "hot-hook:full-reload") {
-          this.#clearScreen();
-          this.#logger.log(`${this.#colors.green("full-reload")} ${path}`);
-          this.#restartHTTPServer(port);
-          this.#hooks.onDevServerStarted(hooksArgs);
-        } else if (message.type === "hot-hook:invalidated") {
-          this.#logger.log(`${this.#colors.green("invalidated")} ${path}`);
-        }
-      }
-      if (this.#isAdonisJSReadyMessage(message)) {
-        const host = message.host === "0.0.0.0" ? "127.0.0.1" : message.host;
-        const displayMessage = ui3.sticker().useColors(this.#colors).useRenderer(this.#logger.getRenderer()).add(`Server address: ${this.#colors.cyan(`http://${host}:${message.port}`)}`);
-        const watchMode = this.#options.hmr ? "HMR" : this.#isWatching ? "Legacy" : "None";
-        displayMessage.add(`Watch Mode: ${this.#colors.cyan(watchMode)}`);
-        if (message.duration) {
-          displayMessage.add(`Ready in: ${this.#colors.cyan(prettyHrtime(message.duration))}`);
-        }
-        displayMessage.render();
-        await this.#hooks.onDevServerStarted({ colors: ui3.colors, logger: this.#logger });
-      }
-    });
-    this.#httpServer.then((result) => {
-      if (mode === "nonblocking") {
-        this.#onClose?.(result.exitCode);
-        this.#watcher?.close();
-        this.#assetsServer?.stop();
-      } else {
-        this.#logger.info("Underlying HTTP server closed. Still watching for changes");
-      }
-    }).catch((error) => {
-      if (mode === "nonblocking") {
-        this.#onError?.(error);
-        this.#watcher?.close();
-        this.#assetsServer?.stop();
-      } else {
-        this.#logger.info("Underlying HTTP server died. Still watching for changes");
-      }
-    });
-  }
-  /**
-   * Starts the assets server
-   */
-  #startAssetsServer() {
-    this.#assetsServer = new AssetsDevServer(this.#cwd, this.#options.assets);
-    this.#assetsServer.setLogger(this.#logger);
-    this.#assetsServer.start();
-  }
-  /**
-   * Restarts the HTTP server in the watch mode. Do not call this
-   * method when not in watch mode
-   */
-  #restartHTTPServer(port) {
-    if (this.#httpServer) {
-      this.#httpServer.removeAllListeners();
-      this.#httpServer.kill("SIGKILL");
-    }
-    this.#startHTTPServer(port, "blocking");
-  }
-  /**
-   * Handles a non TypeScript file change
+   * Handles file change event
    */
-  #handleFileChange(action, port, relativePath) {
-    if (isDotEnvFile(relativePath)) {
-      this.#clearScreen();
-      this.#logger.log(`${this.#colors.green(action)} ${relativePath}`);
-      this.#restartHTTPServer(port);
+  #handleFileChange(filePath, action, hotReplaced) {
+    const file = this.#fileSystem.inspect(filePath);
+    if (!file) {
       return;
     }
-    if (this.#isMetaFileWithReloadsEnabled(relativePath)) {
-      this.#clearScreen();
-      this.#logger.log(`${this.#colors.green(action)} ${relativePath}`);
-      this.#restartHTTPServer(port);
+    if (hotReplaced) {
+      this.ui.logger.log(`${this.ui.colors.green("invalidated")} ${filePath}`);
       return;
     }
-    if (this.#isMetaFileWithReloadsDisabled(relativePath)) {
+    if (file.reloadServer) {
       this.#clearScreen();
-      this.#logger.log(`${this.#colors.green(action)} ${relativePath}`);
+      this.ui.logger.log(`${this.ui.colors.green(action)} ${filePath}`);
+      this.#restartHTTPServer();
+      return;
     }
+    this.ui.logger.log(`${this.ui.colors.green(action)} ${filePath}`);
   }
   /**
-   * Handles TypeScript source file change
+   * Registers inline hooks for the file changes and restarts the
+   * HTTP server when a file gets changed.
    */
-  async #handleSourceFileChange(action, port, relativePath) {
-    await this.#hooks.onSourceFileChanged({ colors: ui3.colors, logger: this.#logger }, relativePath);
-    this.#clearScreen();
-    this.#logger.log(`${this.#colors.green(action)} ${relativePath}`);
-    this.#restartHTTPServer(port);
+  #registerServerRestartHooks() {
+    this.#hooks.add("fileAdded", (filePath) => this.#handleFileChange(filePath, "add"));
+    this.#hooks.add(
+      "fileChanged",
+      (filePath, hotReplaced) => this.#handleFileChange(filePath, "update", hotReplaced)
+    );
+    this.#hooks.add("fileRemoved", (filePath) => this.#handleFileChange(filePath, "delete"));
   }
   /**
-   * Set a custom CLI UI logger
+   * Starts the HTTP server
    */
-  setLogger(logger) {
-    this.#logger = logger;
-    this.#assetsServer?.setLogger(logger);
-    return this;
+  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)) {
+          await this.#postServerReady(message);
+          resolve();
+        } else if (this.#mode === "hmr" && this.#isHotHookMessage(message)) {
+          if (message.type === "hot-hook:file-changed") {
+            switch (message.action) {
+              case "add":
+                this.#hooks.runner("fileAdded").run(string3.toUnixSlash(message.path), this);
+                break;
+              case "change":
+                this.#hooks.runner("fileChanged").run(string3.toUnixSlash(message.path), false, this);
+                break;
+              case "unlink":
+                this.#hooks.runner("fileRemoved").run(string3.toUnixSlash(message.path), this);
+            }
+          } else if (message.type === "hot-hook:full-reload") {
+            this.#hooks.runner("fileChanged").run(string3.toUnixSlash(message.path), false, this);
+          } else if (message.type === "hot-hook:invalidated") {
+            this.#hooks.runner("fileChanged").run(string3.toUnixSlash(message.path), true, 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(() => {
+        console.log("ere>>");
+        resolve();
+      });
+    });
   }
   /**
    * Add listener to get notified when dev server is
@@ -744,11 +764,10 @@ var DevServer = class {
     return this;
   }
   /**
-   * Close watchers and running child processes
+   * Close watchers and the running child process
    */
   async close() {
     await this.#watcher?.close();
-    this.#assetsServer?.stop();
     if (this.#httpServer) {
       this.#httpServer.removeAllListeners();
       this.#httpServer.kill("SIGKILL");
@@ -757,173 +776,175 @@ var DevServer = class {
   /**
    * Start the development server
    */
-  async start() {
-    await this.#hooks.registerDevServerHooks();
+  async start(ts) {
+    const tsConfig = parseConfig(this.cwd, ts);
+    if (!tsConfig) {
+      return;
+    }
+    this.#stickyPort = String(await getPort(this.cwd));
+    this.#fileSystem = new FileSystem(this.cwd, tsConfig, this.options);
+    this.#hooks = await loadHooks(this.options.hooks, [
+      "devServerStarting",
+      "devServerStarted",
+      "fileAdded",
+      "fileChanged",
+      "fileRemoved"
+    ]);
+    this.#registerServerRestartHooks();
+    if (this.options.hmr) {
+      this.#mode = "hmr";
+      this.options.nodeArgs = this.options.nodeArgs.concat("--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 ?? []).map(({ pattern }) => pattern).join(",")
+      };
+    }
     this.#clearScreen();
-    this.#logger.info("starting HTTP server...");
-    this.#startHTTPServer(String(await getPort(this.#cwd)), "nonblocking");
-    this.#startAssetsServer();
+    this.ui.logger.info("starting HTTP server...");
+    await this.#startHTTPServer(this.#stickyPort);
   }
   /**
    * Start the development server in watch mode
    */
   async startAndWatch(ts, options) {
-    await this.#hooks.registerDevServerHooks();
-    const port = String(await getPort(this.#cwd));
-    this.#isWatching = true;
-    this.#clearScreen();
-    this.#logger.info("starting HTTP server...");
-    this.#startHTTPServer(port, "blocking");
-    this.#startAssetsServer();
-    const output = watch(this.#cwd, ts, options || {});
-    if (!output) {
-      this.#onClose?.(1);
+    const tsConfig = parseConfig(this.cwd, ts);
+    if (!tsConfig) {
       return;
     }
-    this.#watcher = output.chokidar;
-    output.watcher.on("watcher:ready", () => {
-      this.#logger.info("watching file system for changes...");
+    this.#mode = "watch";
+    this.#stickyPort = String(await getPort(this.cwd));
+    this.#fileSystem = new FileSystem(this.cwd, tsConfig, this.options);
+    this.#hooks = await loadHooks(this.options.hooks, [
+      "devServerStarting",
+      "devServerStarted",
+      "fileAdded",
+      "fileChanged",
+      "fileRemoved"
+    ]);
+    this.#registerServerRestartHooks();
+    this.#clearScreen();
+    this.ui.logger.info("starting HTTP server...");
+    await this.#startHTTPServer(this.#stickyPort);
+    this.#watcher = watch({
+      usePolling: options?.poll ?? false,
+      cwd: fileURLToPath4(this.cwd),
+      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...");
     });
-    output.chokidar.on("error", (error) => {
-      this.#logger.warning("file system watcher failure");
-      this.#logger.fatal(error);
+    this.#watcher.on("error", (error) => {
+      this.ui.logger.warning("file system watcher failure");
+      this.ui.logger.fatal(error);
       this.#onError?.(error);
-      output.chokidar.close();
+      this.#watcher?.close();
     });
-    output.watcher.on(
-      "source:add",
-      ({ relativePath }) => this.#handleSourceFileChange("add", port, relativePath)
-    );
-    output.watcher.on(
-      "source:change",
-      ({ relativePath }) => this.#handleSourceFileChange("update", port, relativePath)
-    );
-    output.watcher.on(
-      "source:unlink",
-      ({ relativePath }) => this.#handleSourceFileChange("delete", port, relativePath)
-    );
-    output.watcher.on(
+    this.#watcher.on(
       "add",
-      ({ relativePath }) => this.#handleFileChange("add", port, relativePath)
+      (filePath) => this.#hooks.runner("fileAdded").run(string3.toUnixSlash(filePath), this)
     );
-    output.watcher.on(
+    this.#watcher.on(
       "change",
-      ({ relativePath }) => this.#handleFileChange("update", port, relativePath)
+      (filePath) => this.#hooks.runner("fileChanged").run(string3.toUnixSlash(filePath), false, this)
     );
-    output.watcher.on(
+    this.#watcher.on(
       "unlink",
-      ({ relativePath }) => this.#handleFileChange("delete", port, relativePath)
+      (filePath) => this.#hooks.runner("fileRemoved").run(string3.toUnixSlash(filePath), this)
     );
   }
 };
 
 // src/test_runner.ts
-import picomatch2 from "picomatch";
-import { cliui as cliui4 } from "@poppinss/cliui";
-var ui4 = cliui4();
+import { cliui as cliui3 } from "@poppinss/cliui";
+import { fileURLToPath as fileURLToPath5 } from "url";
+import string4 from "@poppinss/utils/string";
 var TestRunner = class {
-  #cwd;
-  #logger = ui4.logger;
-  #options;
-  /**
-   * The script file to run as a child process
-   */
-  #scriptFile = "bin/test.js";
-  /**
-   * Pico matcher function to check if the filepath is
-   * part of the `metaFiles` glob patterns
-   */
-  #isMetaFile;
+  constructor(cwd, options) {
+    this.cwd = cwd;
+    this.options = options;
+  }
   /**
-   * Pico matcher function to check if the filepath is
-   * part of a test file.
+   * External listeners that are invoked when child process
+   * gets an error or closes
    */
-  #isTestFile;
+  #onError;
+  #onClose;
   /**
-   * Arguments to pass to the "bin/test.js" file.
+   * The stickyPort is set by the startAndWatch method and we will
+   * continue to use this port during re-runs
    */
-  #scriptArgs;
+  #stickyPort;
   /**
-   * Set of initial filters applied when running the test
-   * command. In watch mode, we will append an additional
-   * filter to run tests only for the file that has been
-   * changed.
+   * Reference to chokidar watcher
    */
-  #initialFiltersArgs;
+  #watcher;
   /**
-   * In watch mode, after a file is changed, we wait for the current
-   * set of tests to finish before triggering a re-run. Therefore,
-   * we use this flag to know if we are already busy in running
-   * tests and ignore file-changes.
+   * Reference to the test script child process
    */
-  #isBusy = false;
+  #testsProcess;
   /**
-   * External listeners that are invoked when child process
-   * gets an error or closes
+   * Filesystem is used to decide which files to watch or entertain in watch
+   * mode
    */
-  #onError;
-  #onClose;
+  #fileSystem;
   /**
-   * Reference to the test script child process
+   * Hooks to execute custom actions during the tests runner lifecycle
    */
-  #testScript;
+  #hooks;
   /**
-   * Reference to the watcher
+   * Re-runs the test child process and throttle concurrent calls to
+   * ensure we do not end up with a long loop of restarts
    */
-  #watcher;
+  #reRunTests = throttle(async (filters) => {
+    if (this.#testsProcess) {
+      this.#testsProcess.removeAllListeners();
+      this.#testsProcess.kill("SIGKILL");
+    }
+    await this.#runTests(this.#stickyPort, filters);
+  }, "reRunTests");
   /**
-   * Reference to the assets server
+   * CLI UI to log colorful messages
    */
-  #assetsServer;
+  ui = cliui3();
   /**
-   * Getting reference to colors library from logger
+   * The script file to run as a child process
    */
-  get #colors() {
-    return this.#logger.getColors();
-  }
-  constructor(cwd, options) {
-    this.#cwd = cwd;
-    this.#options = options;
-    this.#isMetaFile = picomatch2((this.#options.metaFiles || []).map(({ pattern }) => pattern));
-    this.#isTestFile = picomatch2(
-      this.#options.suites.filter((suite) => {
-        if (this.#options.filters.suites) {
-          return this.#options.filters.suites.includes(suite.name);
-        }
-        return true;
-      }).map((suite) => suite.files).flat(1)
-    );
-    this.#scriptArgs = this.#convertOptionsToArgs().concat(this.#options.scriptArgs);
-    this.#initialFiltersArgs = this.#convertFiltersToArgs(this.#options.filters);
-  }
+  scriptFile = "bin/test.ts";
   /**
    * Convert test runner options to the CLI args
    */
   #convertOptionsToArgs() {
     const args = [];
-    if (this.#options.reporters) {
+    if (this.options.reporters) {
       args.push("--reporters");
-      args.push(this.#options.reporters.join(","));
+      args.push(this.options.reporters.join(","));
     }
-    if (this.#options.timeout !== void 0) {
+    if (this.options.timeout !== void 0) {
       args.push("--timeout");
-      args.push(String(this.#options.timeout));
+      args.push(String(this.options.timeout));
     }
-    if (this.#options.failed) {
+    if (this.options.failed) {
       args.push("--failed");
     }
-    if (this.#options.retries !== void 0) {
+    if (this.options.retries !== void 0) {
       args.push("--retries");
-      args.push(String(this.#options.retries));
+      args.push(String(this.options.retries));
     }
     return args;
   }
   /**
    * Converts all known filters to CLI args.
-   *
-   * The following code snippet may seem like repetitive code. But, it
-   * is done intentionally to have visibility around how each filter
-   * is converted to an arg.
    */
   #convertFiltersToArgs(filters) {
     const args = [];
@@ -952,93 +973,74 @@ var TestRunner = class {
    * Conditionally clear the terminal screen
    */
   #clearScreen() {
-    if (this.#options.clearScreen) {
+    if (this.options.clearScreen) {
       process.stdout.write("\x1Bc");
     }
   }
   /**
    * Runs tests
    */
-  #runTests(port, mode, filters) {
-    this.#isBusy = true;
-    const scriptArgs = filters ? this.#convertFiltersToArgs(filters).concat(this.#scriptArgs) : this.#initialFiltersArgs.concat(this.#scriptArgs);
-    this.#testScript = runNode(this.#cwd, {
-      script: this.#scriptFile,
-      env: { PORT: port, ...this.#options.env },
-      nodeArgs: this.#options.nodeArgs,
-      scriptArgs
-    });
-    this.#testScript.then((result) => {
-      if (mode === "nonblocking") {
-        this.#onClose?.(result.exitCode);
-        this.close();
-      }
-    }).catch((error) => {
-      if (mode === "nonblocking") {
-        this.#onError?.(error);
-        this.close();
-      }
-    }).finally(() => {
-      this.#isBusy = false;
+  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 scriptArgs = this.#convertOptionsToArgs().concat(this.options.scriptArgs).concat(
+        this.#convertFiltersToArgs({
+          ...this.options.filters,
+          ...filters
+        })
+      );
+      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());
     });
   }
   /**
-   * Re-run tests with additional inline filters. Should be
-   * executed in watch mode only.
-   */
-  #rerunTests(port, filters) {
-    if (this.#testScript) {
-      this.#testScript.removeAllListeners();
-      this.#testScript.kill("SIGKILL");
-    }
-    this.#runTests(port, "blocking", filters);
-  }
-  /**
-   * Starts the assets server
-   */
-  #startAssetsServer() {
-    this.#assetsServer = new AssetsDevServer(this.#cwd, this.#options.assets);
-    this.#assetsServer.setLogger(this.#logger);
-    this.#assetsServer.start();
-  }
-  /**
-   * Handles a non TypeScript file change
-   */
-  #handleFileChange(action, port, relativePath) {
-    if (this.#isBusy) {
-      return;
-    }
-    if (isDotEnvFile(relativePath) || this.#isMetaFile(relativePath)) {
-      this.#clearScreen();
-      this.#logger.log(`${this.#colors.green(action)} ${relativePath}`);
-      this.#rerunTests(port);
-    }
-  }
-  /**
-   * Handles TypeScript source file change
+   * Handles file change event
    */
-  #handleSourceFileChange(action, port, relativePath) {
-    if (this.#isBusy) {
+  #handleFileChange(filePath, action) {
+    const file = this.#fileSystem.inspect(filePath);
+    if (!file) {
       return;
     }
     this.#clearScreen();
-    this.#logger.log(`${this.#colors.green(action)} ${relativePath}`);
-    if (this.#isTestFile(relativePath)) {
-      this.#rerunTests(port, {
-        ...this.#options.filters,
-        files: [relativePath]
-      });
-      return;
+    this.ui.logger.log(`${this.ui.colors.green(action)} ${filePath}`);
+    if (file.fileType === "test") {
+      this.#reRunTests({ files: [filePath] });
+    } else {
+      this.#reRunTests();
     }
-    this.#rerunTests(port);
   }
   /**
-   * Set a custom CLI UI logger
+   * Registers inline hooks for the file changes and restarts the
+   * HTTP server when a file gets changed.
    */
-  setLogger(logger) {
-    this.#logger = logger;
-    this.#assetsServer?.setLogger(logger);
-    return this;
+  #registerServerRestartHooks() {
+    this.#hooks.add("fileAdded", (filePath) => this.#handleFileChange(filePath, "add"));
+    this.#hooks.add("fileChanged", (filePath) => this.#handleFileChange(filePath, "update"));
+    this.#hooks.add("fileRemoved", (filePath) => this.#handleFileChange(filePath, "delete"));
   }
   /**
    * Add listener to get notified when dev server is
@@ -1061,69 +1063,90 @@ var TestRunner = class {
    */
   async close() {
     await this.#watcher?.close();
-    this.#assetsServer?.stop();
-    if (this.#testScript) {
-      this.#testScript.removeAllListeners();
-      this.#testScript.kill("SIGKILL");
+    if (this.#testsProcess) {
+      this.#testsProcess.removeAllListeners();
+      this.#testsProcess.kill("SIGKILL");
     }
   }
   /**
    * Runs tests
    */
   async run() {
-    const port = String(await getPort(this.#cwd));
+    this.#stickyPort = String(await getPort(this.cwd));
+    this.#hooks = await loadHooks(this.options.hooks, [
+      "testsStarting",
+      "testsFinished",
+      "fileAdded",
+      "fileChanged",
+      "fileRemoved"
+    ]);
     this.#clearScreen();
-    this.#startAssetsServer();
-    this.#logger.info("booting application to run tests...");
-    this.#runTests(port, "nonblocking");
+    this.ui.logger.info("booting application to run tests...");
+    await this.#runTests(this.#stickyPort);
   }
   /**
    * Run tests in watch mode
    */
   async runAndWatch(ts, options) {
-    const port = String(await getPort(this.#cwd));
-    this.#clearScreen();
-    this.#startAssetsServer();
-    this.#logger.info("booting application to run tests...");
-    this.#runTests(port, "blocking");
-    const output = watch(this.#cwd, ts, options || {});
-    if (!output) {
-      this.#onClose?.(1);
+    const tsConfig = parseConfig(this.cwd, ts);
+    if (!tsConfig) {
       return;
     }
-    this.#watcher = output.chokidar;
-    output.watcher.on("watcher:ready", () => {
-      this.#logger.info("watching file system for changes...");
+    this.#stickyPort = String(await getPort(this.cwd));
+    this.#fileSystem = new FileSystem(this.cwd, tsConfig, {
+      ...this.options,
+      suites: this.options.suites?.filter((suite) => {
+        if (this.options.filters.suites) {
+          return this.options.filters.suites.includes(suite.name);
+        }
+        return true;
+      })
     });
-    output.chokidar.on("error", (error) => {
-      this.#logger.warning("file system watcher failure");
-      this.#logger.fatal(error);
+    this.#hooks = await loadHooks(this.options.hooks, [
+      "testsStarting",
+      "testsFinished",
+      "fileAdded",
+      "fileChanged",
+      "fileRemoved"
+    ]);
+    this.#registerServerRestartHooks();
+    this.#clearScreen();
+    this.ui.logger.info("booting application to run tests...");
+    await this.#runTests(this.#stickyPort);
+    this.#watcher = watch({
+      usePolling: options?.poll ?? false,
+      cwd: fileURLToPath5(this.cwd),
+      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);
-      output.chokidar.close();
+      this.#watcher?.close();
     });
-    output.watcher.on(
-      "source:add",
-      ({ relativePath }) => this.#handleSourceFileChange("add", port, relativePath)
-    );
-    output.watcher.on(
-      "source:change",
-      ({ relativePath }) => this.#handleSourceFileChange("update", port, relativePath)
-    );
-    output.watcher.on(
-      "source:unlink",
-      ({ relativePath }) => this.#handleSourceFileChange("delete", port, relativePath)
-    );
-    output.watcher.on(
+    this.#watcher.on(
       "add",
-      ({ relativePath }) => this.#handleFileChange("add", port, relativePath)
+      (filePath) => this.#hooks.runner("fileAdded").run(string4.toUnixSlash(filePath), this)
     );
-    output.watcher.on(
+    this.#watcher.on(
       "change",
-      ({ relativePath }) => this.#handleFileChange("update", port, relativePath)
+      (filePath) => this.#hooks.runner("fileChanged").run(string4.toUnixSlash(filePath), false, this)
     );
-    output.watcher.on(
+    this.#watcher.on(
       "unlink",
-      ({ relativePath }) => this.#handleFileChange("delete", port, relativePath)
+      (filePath) => this.#hooks.runner("fileRemoved").run(string4.toUnixSlash(filePath), this)
     );
   }
 };
@@ -1132,4 +1155,3 @@ export {
   DevServer,
   TestRunner
 };
-//# sourceMappingURL=index.js.map