@epikodelabs/testify 1.0.16

package/bin/testify

@@ -0,0 +1,4640 @@
+#!/usr/bin/env node
+import { createRequire as ___createRequire } from "module";
+const require2 = ___createRequire(import.meta.url);
+const ___fileURLToPath = require2("url").fileURLToPath;
+const ___path = require2("path");
+const __filename = ___fileURLToPath(import.meta.url);
+const __dirname = ___path.dirname(__filename);
+import { fileURLToPath, parse, pathToFileURL } from "url";
+import * as fs from "fs";
+import * as path from "path";
+import path__default, { extname } from "path";
+import util from "util";
+import { glob } from "glob";
+import { EventEmitter } from "events";
+import * as fs$1 from "fs/promises";
+import http, { createServer } from "http";
+import libCoverage from "istanbul-lib-coverage";
+import libReport from "istanbul-lib-report";
+import libSourceMaps from "istanbul-lib-source-maps";
+import libIstanbulApi from "istanbul-api";
+import { minimatch } from "minimatch";
+import { createInstrumenter } from "istanbul-lib-instrument";
+import { WebSocketServer, WebSocket } from "ws";
+import { watch } from "chokidar";
+import picomatch from "picomatch";
+const norm = (p) => p.replace(/\\/g, "/");
+const capitalize = (p) => {
+  if (!p) return "";
+  return p.charAt(0).toUpperCase() + p.slice(1);
+};
+class JSONCleaner {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      removeComments: options.removeComments !== false,
+      removeTrailingCommas: options.removeTrailingCommas !== false,
+      normalizeWhitespace: options.normalizeWhitespace === true,
+      allowSingleQuotes: options.allowSingleQuotes === true,
+      preserveNewlines: options.preserveNewlines !== false,
+      strict: options.strict === true
+    };
+  }
+  /**
+   * Clean JSON string by removing comments and fixing common issues
+   */
+  clean(jsonString) {
+    if (typeof jsonString !== "string") {
+      throw new Error("Input must be a string");
+    }
+    let result = jsonString;
+    if (this.options.removeComments) {
+      result = this.stripComments(result);
+    }
+    if (this.options.removeTrailingCommas) {
+      result = this.removeTrailingCommas(result);
+    }
+    if (this.options.allowSingleQuotes) {
+      result = this.normalizeSingleQuotes(result);
+    }
+    if (this.options.normalizeWhitespace) {
+      result = this.normalizeWhitespace(result);
+    }
+    if (this.options.strict) {
+      try {
+        JSON.parse(result);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid JSON after cleaning: ${message}`);
+      }
+    }
+    return result;
+  }
+  /**
+   * Strip single-line and multi-line comments
+   * More robust than simple regex - handles edge cases
+   */
+  stripComments(str) {
+    let result = "";
+    let i = 0;
+    const state = {
+      inString: false,
+      stringChar: null,
+      escapeNext: false
+    };
+    while (i < str.length) {
+      const char = str[i];
+      const nextChar = str[i + 1];
+      if (state.escapeNext) {
+        result += char;
+        state.escapeNext = false;
+        i++;
+        continue;
+      }
+      if (char === "\\" && state.inString) {
+        result += char;
+        state.escapeNext = true;
+        i++;
+        continue;
+      }
+      if ((char === '"' || char === "'") && !state.escapeNext) {
+        if (!state.inString) {
+          state.inString = true;
+          state.stringChar = char;
+          result += char;
+        } else if (char === state.stringChar) {
+          state.inString = false;
+          state.stringChar = null;
+          result += char;
+        } else {
+          result += char;
+        }
+        i++;
+        continue;
+      }
+      if (!state.inString) {
+        if (char === "/" && nextChar === "/") {
+          i += 2;
+          while (i < str.length && str[i] !== "\n" && str[i] !== "\r") {
+            i++;
+          }
+          if (i < str.length && this.options.preserveNewlines) {
+            result += str[i];
+          }
+          i++;
+          continue;
+        }
+        if (char === "/" && nextChar === "*") {
+          i += 2;
+          let foundEnd = false;
+          let newlineCount = 0;
+          while (i < str.length - 1) {
+            if (str[i] === "\n") newlineCount++;
+            if (str[i] === "*" && str[i + 1] === "/") {
+              i += 2;
+              foundEnd = true;
+              break;
+            }
+            i++;
+          }
+          if (!foundEnd) {
+            throw new Error("Unclosed multi-line comment");
+          }
+          if (this.options.preserveNewlines && newlineCount > 0) {
+            result += "\n".repeat(Math.min(newlineCount, 2));
+          }
+          continue;
+        }
+      }
+      result += char;
+      i++;
+    }
+    if (state.inString) {
+      throw new Error("Unclosed string in JSON");
+    }
+    return result;
+  }
+  /**
+   * Remove trailing commas before closing brackets/braces
+   */
+  removeTrailingCommas(str) {
+    let result = "";
+    let i = 0;
+    const state = {
+      inString: false,
+      stringChar: null,
+      escapeNext: false
+    };
+    while (i < str.length) {
+      const char = str[i];
+      if (state.escapeNext) {
+        result += char;
+        state.escapeNext = false;
+        i++;
+        continue;
+      }
+      if (char === "\\" && state.inString) {
+        result += char;
+        state.escapeNext = true;
+        i++;
+        continue;
+      }
+      if ((char === '"' || char === "'") && !state.escapeNext) {
+        if (!state.inString) {
+          state.inString = true;
+          state.stringChar = char;
+        } else if (char === state.stringChar) {
+          state.inString = false;
+          state.stringChar = null;
+        }
+        result += char;
+        i++;
+        continue;
+      }
+      if (!state.inString && char === ",") {
+        let j = i + 1;
+        while (j < str.length && /\s/.test(str[j])) {
+          j++;
+        }
+        if (j < str.length && (str[j] === "]" || str[j] === "}")) {
+          i++;
+          continue;
+        }
+      }
+      result += char;
+      i++;
+    }
+    return result;
+  }
+  /**
+   * Convert single quotes to double quotes (outside of strings)
+   */
+  normalizeSingleQuotes(str) {
+    let result = "";
+    let i = 0;
+    const state = {
+      inString: false,
+      stringChar: null,
+      escapeNext: false
+    };
+    while (i < str.length) {
+      const char = str[i];
+      if (state.escapeNext) {
+        result += char;
+        state.escapeNext = false;
+        i++;
+        continue;
+      }
+      if (char === "\\" && state.inString) {
+        result += char;
+        state.escapeNext = true;
+        i++;
+        continue;
+      }
+      if ((char === '"' || char === "'") && !state.escapeNext) {
+        if (!state.inString) {
+          state.inString = true;
+          state.stringChar = char;
+          result += '"';
+        } else if (char === state.stringChar) {
+          state.inString = false;
+          state.stringChar = null;
+          result += '"';
+        } else {
+          if (char === '"') {
+            result += '\\"';
+          } else {
+            result += char;
+          }
+        }
+        i++;
+        continue;
+      }
+      result += char;
+      i++;
+    }
+    return result;
+  }
+  /**
+   * Normalize whitespace
+   */
+  normalizeWhitespace(str) {
+    return str.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).join("\n");
+  }
+  /**
+   * Parse JSON string with automatic cleaning
+   */
+  parse(jsonString) {
+    const cleaned = this.clean(jsonString);
+    return JSON.parse(cleaned);
+  }
+  /**
+   * Read and clean JSON file
+   */
+  readFile(filePath, encoding = "utf8") {
+    const content = fs.readFileSync(filePath, encoding);
+    return this.clean(content);
+  }
+  /**
+   * Read, clean, and parse JSON file
+   */
+  parseFile(filePath, encoding = "utf8") {
+    const cleaned = this.readFile(filePath, encoding);
+    return JSON.parse(cleaned);
+  }
+  /**
+   * Clean and write JSON file
+   */
+  writeFile(filePath, jsonString, encoding = "utf8") {
+    const cleaned = this.clean(jsonString);
+    fs.writeFileSync(filePath, cleaned, encoding);
+  }
+  /**
+   * Clean and prettify JSON file
+   */
+  prettifyFile(inputPath, outputPath = null, indent = 2) {
+    const parsed = this.parseFile(inputPath);
+    const prettified = JSON.stringify(parsed, null, indent);
+    const targetPath = outputPath || inputPath;
+    fs.writeFileSync(targetPath, prettified, "utf8");
+  }
+}
+const MAX_WIDTH = 63;
+class ConsoleReporter {
+  print;
+  showColors;
+  specCount;
+  executableSpecCount;
+  failureCount;
+  failedSpecs;
+  pendingSpecs;
+  ansi;
+  startTime;
+  config = null;
+  envInfo;
+  rootSuite;
+  currentSuite;
+  suiteStack;
+  currentSpec;
+  suiteById = /* @__PURE__ */ new Map();
+  specById = /* @__PURE__ */ new Map();
+  lineWidth = MAX_WIDTH;
+  interruptHandlersRegistered = false;
+  interrupted = false;
+  orderedSuites = null;
+  orderedSpecs = null;
+  constructor() {
+    this.print = (...args) => logger.printRaw(util.format(...args));
+    this.showColors = this.detectColorSupport();
+    this.config = null;
+    this.specCount = 0;
+    this.executableSpecCount = 0;
+    this.failureCount = 0;
+    this.failedSpecs = [];
+    this.pendingSpecs = [];
+    this.startTime = 0;
+    this.envInfo = null;
+    this.rootSuite = this.createRootSuite();
+    this.currentSuite = null;
+    this.suiteStack = [this.rootSuite];
+    this.currentSpec = null;
+    this.ansi = {
+      green: "\x1B[32m",
+      brightGreen: "\x1B[92m",
+      red: "\x1B[31m",
+      brightRed: "\x1B[91m",
+      yellow: "\x1B[33m",
+      brightYellow: "\x1B[93m",
+      blue: "\x1B[34m",
+      brightBlue: "\x1B[94m",
+      cyan: "\x1B[36m",
+      brightCyan: "\x1B[96m",
+      magenta: "\x1B[35m",
+      gray: "\x1B[90m",
+      white: "\x1B[97m",
+      bold: "\x1B[1m",
+      dim: "\x1B[2m",
+      none: "\x1B[0m"
+    };
+  }
+  getFailureCount() {
+    return this.failureCount;
+  }
+  // Detect if terminal supports colors
+  detectColorSupport() {
+    if (process.env.NO_COLOR) return false;
+    if (process.env.FORCE_COLOR) return true;
+    return process.stdout.isTTY ?? false;
+  }
+  createRootSuite() {
+    return {
+      id: "suite0",
+      description: "Jasmine__TopLevel__Suite",
+      fullName: "",
+      specs: [],
+      children: [],
+      status: "skipped"
+    };
+  }
+  buildSuiteTree(config) {
+    this.rootSuite = this.createRootSuite();
+    this.suiteById.clear();
+    this.specById.clear();
+    this.suiteStack = [this.rootSuite];
+    this.currentSuite = null;
+    this.currentSpec = null;
+    this.suiteById.set(this.rootSuite.id, this.rootSuite);
+    const orderedSuites = this.orderedSuites;
+    if (orderedSuites) {
+      orderedSuites.forEach((suiteConfig) => {
+        const suite = {
+          id: suiteConfig.id,
+          description: this.normalizeDescription(suiteConfig.description ?? suiteConfig.id),
+          fullName: suiteConfig.fullName ?? suiteConfig.id,
+          specs: [],
+          children: [],
+          parent: void 0,
+          status: "skipped"
+          // default until executed
+        };
+        this.suiteById.set(suite.id, suite);
+      });
+    }
+    const orderedSpecs = this.orderedSpecs;
+    if (orderedSpecs) {
+      orderedSpecs.forEach((specConfig) => {
+        const spec = {
+          id: specConfig.id,
+          description: specConfig.description ?? specConfig.id,
+          fullName: specConfig.fullName ?? specConfig.id,
+          status: "skipped"
+        };
+        this.specById.set(spec.id, spec);
+        const parentSuiteId = specConfig.suiteId ?? this.findSuiteIdForSpec(specConfig);
+        const parentSuite = this.suiteById.get(parentSuiteId);
+        if (parentSuite && parentSuite.id !== this.rootSuite.id) {
+          parentSuite.specs.push(spec);
+        } else {
+          this.rootSuite.specs.push(spec);
+        }
+      });
+    }
+    if (orderedSuites) {
+      orderedSuites.forEach((suiteConfig) => {
+        const suite = this.suiteById.get(suiteConfig.id);
+        if (!suite) return;
+        const parentSuiteId = suiteConfig.parentSuiteId ?? this.findParentSuiteId(suiteConfig);
+        const parentSuite = this.suiteById.get(parentSuiteId) ?? this.rootSuite;
+        if (parentSuite.id !== suite.id) {
+          suite.parent = parentSuite;
+          if (!parentSuite.children.includes(suite)) {
+            parentSuite.children.push(suite);
+          }
+        }
+      });
+    }
+    const totalSuites = this.orderedSuites?.length;
+    const totalSpecs = this.orderedSpecs?.length;
+    logger.println(`🧩 Suite tree built (${totalSuites} suites, ${totalSpecs} specs).`);
+  }
+  countSpecs(suite) {
+    let total = suite.specs.length;
+    for (const child of suite.children) {
+      total += this.countSpecs(child);
+    }
+    return total;
+  }
+  normalizeDescription(desc) {
+    if (typeof desc === "string") return desc;
+    if (desc?.en) return desc.en;
+    return JSON.stringify(desc);
+  }
+  findSuiteIdForSpec(specConfig) {
+    if (specConfig.suiteId) return specConfig.suiteId;
+    if (specConfig.fullName) {
+      for (const [id, suite] of this.suiteById) {
+        if (id !== this.rootSuite.id && specConfig.fullName.startsWith(suite.fullName)) {
+          return id;
+        }
+      }
+    }
+    return this.rootSuite.id;
+  }
+  findParentSuiteId(suiteConfig) {
+    if (suiteConfig.parentSuiteId) return suiteConfig.parentSuiteId;
+    if (suiteConfig.fullName) {
+      const parts = suiteConfig.fullName.split(" ");
+      if (parts.length > 1) {
+        const parentFullName = parts.slice(0, -1).join(" ");
+        for (const [id, suite] of this.suiteById) {
+          if (suite.fullName === parentFullName) {
+            return id;
+          }
+        }
+      }
+    }
+    return this.rootSuite.id;
+  }
+  userAgent(message, suites, specs) {
+    this.envInfo = this.gatherEnvironmentInfo();
+    this.orderedSuites = suites ?? null;
+    this.orderedSpecs = specs ?? null;
+    if (message) {
+      const userAgent = { ...message };
+      delete userAgent?.timestamp;
+      delete userAgent?.type;
+      this.envInfo = {
+        ...this.envInfo,
+        userAgent
+      };
+    }
+  }
+  jasmineStarted(config) {
+    this.startTime = Date.now();
+    this.specCount = 0;
+    this.executableSpecCount = 0;
+    this.failureCount = 0;
+    this.config = config;
+    this.failedSpecs = [];
+    this.pendingSpecs = [];
+    this.rootSuite = this.createRootSuite();
+    this.suiteStack = [this.rootSuite];
+    this.currentSuite = null;
+    this.currentSpec = null;
+    this.interrupted = false;
+    this.buildSuiteTree(config);
+    this.setupInterruptHandler();
+    this.print("\n");
+    this.printBox("Test Runner Started", "cyan");
+    this.printEnvironmentInfo();
+    this.printTestConfiguration(config);
+  }
+  suiteStarted(config) {
+    if (this.interrupted) return;
+    let suite = this.suiteById.get(config.id);
+    const parentSuite = this.suiteStack[this.suiteStack.length - 1];
+    if (!suite) {
+      suite = {
+        id: config.id,
+        description: config.description,
+        fullName: config.fullName,
+        specs: [],
+        children: [],
+        parent: parentSuite,
+        status: "running"
+      };
+      this.suiteById.set(suite.id, suite);
+    } else {
+      suite.status = "running";
+      suite.parent = parentSuite;
+    }
+    if (parentSuite && !parentSuite.children.includes(suite)) {
+      parentSuite.children.push(suite);
+    }
+    this.suiteStack.push(suite);
+    this.currentSuite = suite;
+    if (config.description) {
+      this.clearCurrentLine();
+      this.printSuiteLine(suite, false);
+    }
+  }
+  specStarted(config) {
+    if (this.interrupted) return;
+    const spec = this.specById.get(config.id) ?? {
+      id: config.id,
+      description: config.description,
+      fullName: config.fullName,
+      status: "running"
+    };
+    spec.status = "running";
+    this.specById.set(spec.id, spec);
+    this.currentSpec = spec;
+    if (this.currentSuite) {
+      if (!this.currentSuite.specs.includes(spec)) {
+        this.currentSuite.specs.push(spec);
+      }
+    } else {
+      this.rootSuite.specs.push(spec);
+    }
+    this.updateStatusLine();
+  }
+  specDone(result) {
+    if (this.interrupted) return;
+    this.specCount++;
+    const spec = this.specById.get(result.id);
+    if (spec) {
+      spec.status = result.status;
+      spec.duration = result.duration;
+      spec.failedExpectations = result.failedExpectations;
+      spec.pendingReason = result.pendingReason;
+    }
+    switch (result.status) {
+      case "passed":
+        this.executableSpecCount++;
+        break;
+      case "failed":
+        this.failureCount++;
+        this.failedSpecs.push(result);
+        this.executableSpecCount++;
+        break;
+      case "pending":
+        this.pendingSpecs.push(result);
+        this.executableSpecCount++;
+        break;
+    }
+    this.currentSpec = null;
+    if (this.currentSuite) {
+      this.clearCurrentLine();
+      this.printSuiteLine(this.currentSuite, false);
+      this.updateStatusLine();
+    }
+  }
+  suiteDone(result) {
+    if (this.interrupted) return;
+    const suite = this.suiteStack[this.suiteStack.length - 1];
+    if (!suite) return;
+    suite.status = this.determineSuiteStatusFromInternal(suite);
+    this.clearCurrentLine();
+    this.printSuiteLine(suite, true);
+    this.print("\n");
+    this.suiteStack.pop();
+    this.currentSuite = this.suiteStack[this.suiteStack.length - 1] ?? null;
+  }
+  jasmineDone(result) {
+    const totalTimeMs = typeof result?.totalTime === "number" ? result.totalTime : Date.now() - this.startTime;
+    const totalTime = totalTimeMs / 1e3;
+    this.clearCurrentLine();
+    if (this.failedSpecs.length > 0) {
+      this.printFailures();
+    }
+    if (this.pendingSpecs.length > 0) {
+      this.printPendingSpecs();
+    }
+    this.printSummary(totalTime);
+    this.print("\n");
+    this.printFinalStatus(result?.overallStatus);
+    this.print("\n\n");
+  }
+  /** Mark all specs and suites that were never executed as skipped */
+  markUnexecutedAsSkipped() {
+    if (this.currentSpec) {
+      if (!this.currentSpec.status || this.currentSpec.status === "running") {
+        this.currentSpec.status = "incomplete";
+      }
+    }
+    if (this.currentSuite && this.currentSuite.id !== this.rootSuite.id) {
+      if (!this.currentSuite.status || this.currentSuite.status === "running") {
+        this.currentSuite.status = "incomplete";
+      }
+    }
+    for (const [id, spec] of this.specById) {
+      if (this.currentSpec && id === this.currentSpec.id) continue;
+      if (!spec.status || spec.status === "running") {
+        spec.status = "skipped";
+      }
+    }
+    for (const [id, suite] of this.suiteById) {
+      if (id === this.rootSuite.id) continue;
+      if (this.currentSuite && id === this.currentSuite.id) continue;
+      if (!suite.status || suite.status === "running") {
+        suite.status = "skipped";
+      }
+    }
+  }
+  testsAborted(message) {
+    this.print("\r\x1B[1A");
+    this.clearCurrentLine();
+    this.clearCurrentLine();
+    this.print("\n");
+    this.markUnexecutedAsSkipped();
+    const totalTime = (Date.now() - this.startTime) / 1e3;
+    if (this.failedSpecs.length > 0) {
+      this.printFailures();
+    }
+    this.printTestTree();
+    this.print("\n");
+    this.printSummary(totalTime);
+    this.print("\n");
+    this.printBox("✕ TESTS INTERRUPTED", "yellow");
+    this.print("\n");
+    process.exit(1);
+  }
+  /** Determine suite status based on its specs and children */
+  determineSuiteStatusFromInternal(suite) {
+    if (suite.specs.length > 0) {
+      const hasFailed = suite.specs.some((s) => s.status === "failed");
+      if (hasFailed) return "failed";
+      const hasPending = suite.specs.some((s) => s.status === "pending");
+      if (hasPending) return "pending";
+      const hasRunning = suite.specs.some((s) => s.status === "running");
+      if (hasRunning) return "incomplete";
+      const hasSkipped = suite.specs.every((s) => s.status === "skipped");
+      if (hasSkipped) return "skipped";
+      return "passed";
+    }
+    if (suite.children.length > 0) {
+      let childStatuses = suite.children.map((child) => this.determineSuiteStatusFromInternal(child));
+      if (childStatuses.includes("failed")) return "failed";
+      if (childStatuses.includes("pending")) return "pending";
+      if (childStatuses.includes("incomplete")) return "incomplete";
+      if (childStatuses.every((s) => s === "skipped")) return "skipped";
+      return "passed";
+    }
+    return "skipped";
+  }
+  setupInterruptHandler() {
+    if (this.interruptHandlersRegistered) return;
+    process.once("SIGINT", this.testsAborted.bind(this));
+    process.once("SIGTERM", this.testsAborted.bind(this));
+    this.interruptHandlersRegistered = true;
+  }
+  updateStatusLine() {
+    if (!this.currentSuite || !this.currentSpec) return;
+    const suiteName = this.currentSuite.description;
+    const passed = this.executableSpecCount - this.failureCount - this.pendingSpecs.length;
+    const statusText = `
+  ${this.colored("dim", "→")} ${suiteName} ${this.colored("gray", `[${passed}/${this.executableSpecCount} passed]`)}`;
+    this.clearCurrentLine();
+    this.print(statusText);
+    this.print("\r\x1B[1A");
+  }
+  clearCurrentLine() {
+    this.print("\x1B[2K\r");
+  }
+  printSuiteLine(suite, isFinal) {
+    const suiteName = suite.description;
+    let displayDots = this.getSpecDots(suite);
+    const prefix = "  ";
+    const availableWidth = this.lineWidth - prefix.length;
+    let displayName = suiteName;
+    const suiteNameLength = displayName.replace(/\.\.\.$/, "").length + (displayName.includes("...") ? 3 : 0);
+    const dotsLength = this.countVisualDots(displayDots);
+    let padding = " ".repeat(Math.max(0, availableWidth - suiteNameLength - dotsLength));
+    this.print(prefix + this.colored("brightBlue", displayName) + padding + displayDots);
+    if (!isFinal) {
+      this.print("\r");
+    }
+  }
+  getSpecDots(suite) {
+    return suite.specs.map((spec) => this.getSpecSymbol(spec)).join("");
+  }
+  getSpecSymbol(spec) {
+    switch (spec.status) {
+      case "passed":
+        return this.colored("brightGreen", "●");
+      case "failed":
+        return this.colored("brightRed", "⨯");
+      case "pending":
+        return this.colored("brightYellow", "○");
+      default:
+        return "";
+    }
+  }
+  compressDots(suite, sideCount) {
+    const dots = suite.specs.map((spec) => this.getSpecSymbol(spec));
+    if (dots.length <= sideCount * 2) {
+      return dots.join("");
+    }
+    const start = dots.slice(0, sideCount).join("");
+    const end = dots.slice(-sideCount).join("");
+    const ellipsis = this.colored("gray", "...");
+    return start + ellipsis + end;
+  }
+  countVisualDots(dotsString) {
+    return dotsString.replace(/\x1b\[[0-9;]*m/g, "").length;
+  }
+  separator() {
+    return "  " + "─".repeat(this.lineWidth - 2);
+  }
+  printFailures() {
+    this.print("\n");
+    this.printSectionHeader("FAILURES", "red");
+    this.print(this.colored("red", this.separator() + "\n"));
+    if (!this.failedSpecs.length) return;
+    this.failedSpecs.forEach((spec, idx) => {
+      const header = wrapLine(`${idx + 1}) ${spec.fullName}`, this.lineWidth, 1);
+      header.forEach((line) => (this.print(this.colored("white", line)), this.print("\n")));
+      if (spec.failedExpectations?.length > 0) {
+        spec.failedExpectations.forEach((expectation, exIndex) => {
+          const messageLines = wrapLine(`✕ ${logger.reformat(expectation.message, { width: this.lineWidth, align: "left" }).map((l) => l.trim()).join(" ")}`, this.lineWidth, 1);
+          messageLines.forEach((line) => (this.print(this.colored("brightRed", line)), this.print("\n")));
+          if (expectation.stack) {
+            const stackLines = wrapLine(logger.reformat(expectation.stack, { width: 80, align: "left" }).map((l) => l.trim()).join(" "), this.lineWidth, 2);
+            stackLines.forEach((line) => (this.print(this.colored("gray", line)), this.print("\n")));
+          }
+          if (exIndex < spec.failedExpectations.length - 1) this.print("\n");
+        });
+      }
+      this.print("\n");
+    });
+  }
+  printPendingSpecs() {
+    this.print("\n");
+    this.printSectionHeader("PENDING", "yellow");
+    this.print(this.colored("yellow", this.separator() + "\n"));
+    this.pendingSpecs.forEach((spec, idx) => {
+      const header = wrapLine(`${this.colored("brightYellow", "○")} ${this.colored("white", spec.fullName)}`, this.lineWidth, 1, "word");
+      header.forEach((line) => (this.print(line), this.print("\n")));
+    });
+  }
+  computeOverallStatus(jasmineOverallStatus) {
+    if (this.failureCount > 0) return "failed";
+    const hasIncompleteSpec = [...this.specById.values()].some(
+      (spec) => spec.status === "incomplete" || spec.status === "running"
+    );
+    const hasIncompleteSuite = [...this.suiteById.values()].some(
+      (suite) => suite.status === "incomplete" || suite.status === "running"
+    );
+    if (hasIncompleteSpec || hasIncompleteSuite || jasmineOverallStatus === "incomplete") {
+      return "incomplete";
+    }
+    return "passed";
+  }
+  printFinalStatus(jasmineOverallStatus) {
+    const overallStatus = this.computeOverallStatus(jasmineOverallStatus);
+    if (overallStatus === "passed") {
+      const msg = this.pendingSpecs.length === 0 ? "✓ ALL TESTS PASSED" : `✓ ALL TESTS PASSED (${this.pendingSpecs.length} pending)`;
+      this.printBox(msg, "green");
+    } else if (overallStatus === "failed") {
+      this.printBox(`✕ ${this.failureCount} TEST${this.failureCount === 1 ? "" : "S"} FAILED`, "red");
+    } else if (overallStatus === "incomplete") {
+      this.printBox("⚠ TESTS INCOMPLETE", "yellow");
+    } else {
+      this.printBox(`⚠ UNKNOWN STATUS: ${overallStatus}`, "red");
+    }
+  }
+  printTestTree() {
+    this.print(this.colored("bold", "  Demanding Attention\n"));
+    this.print(this.colored("gray", this.separator() + "\n"));
+    for (const [id, suite] of this.suiteById) {
+      this.calculateSuiteStatuses(suite);
+    }
+    let hasProblems = false;
+    for (const [id, suite] of this.suiteById) {
+      if (suite.id === this.rootSuite.id) continue;
+      if (!suite.parent || suite.parent.id === this.rootSuite.id) {
+        if (this.printProblemSuite(suite, 1)) {
+          hasProblems = true;
+        }
+      }
+    }
+    if (!hasProblems) {
+      this.print("  " + this.colored("brightGreen", "✓") + " " + this.colored("dim", "All suites completed successfully\n"));
+    }
+  }
+  calculateSuiteStatuses(suite) {
+    const childStatuses = suite.children.map((child) => this.calculateSuiteStatuses(child));
+    for (const spec of suite.specs) {
+      if (!spec.status) {
+        spec.status = "skipped";
+      } else if (spec.status === "running") {
+        spec.status = "incomplete";
+      }
+    }
+    const specs = suite.specs;
+    const failedCount = specs.filter((s) => s.status === "failed").length;
+    const pendingCount = specs.filter((s) => s.status === "pending").length;
+    const incompleteCount = specs.filter((s) => s.status === "incomplete").length;
+    const skippedCount = specs.filter((s) => s.status === "skipped").length;
+    const hasFailedChildren = childStatuses.includes("failed");
+    const hasPendingChildren = childStatuses.includes("pending");
+    const hasIncompleteChildren = childStatuses.includes("incomplete");
+    if (failedCount > 0 || hasFailedChildren) {
+      suite.status = "failed";
+    } else if (incompleteCount > 0 || hasIncompleteChildren) {
+      suite.status = "incomplete";
+    } else if (pendingCount > 0 || hasPendingChildren) {
+      suite.status = "pending";
+    } else if (skippedCount > 0) {
+      suite.status = "skipped";
+    } else {
+      suite.status = "passed";
+    }
+    return suite.status;
+  }
+  /** Print only suites/specs that need attention */
+  printProblemSuite(suite, indentLevel = 0) {
+    if (suite.id === this.rootSuite.id) return false;
+    const indent = "  ".repeat(indentLevel);
+    let hasProblems = false;
+    let childHasProblems = false;
+    for (const child of suite.children) {
+      if (this.printProblemSuite(child, indentLevel + 1)) {
+        childHasProblems = true;
+        hasProblems = true;
+      }
+    }
+    const isProblemSuite = ["failed", "pending", "incomplete", "skipped"].includes(suite.status);
+    if (isProblemSuite || childHasProblems) {
+      hasProblems = true;
+      if (isProblemSuite) {
+        const { symbol, color } = this.getSuiteSymbol(suite.status);
+        const specs = suite.specs;
+        const specCount = specs.length;
+        const failed = specs.filter((s) => s.status === "failed").length;
+        const pending = specs.filter((s) => s.status === "pending").length;
+        const incomplete = specs.filter((s) => s.status === "incomplete").length;
+        const skipped = specs.filter((s) => s.status === "skipped").length;
+        const passed = specs.filter((s) => s.status === "passed").length;
+        const statusParts = [];
+        switch (suite.status) {
+          case "failed":
+            if (failed > 0) statusParts.push(`${failed} failed`);
+            if (passed > 0) statusParts.push(`${passed} passed`);
+            if (pending > 0) statusParts.push(`${pending} pending`);
+            if (incomplete > 0) statusParts.push(`${incomplete} incomplete`);
+            if (skipped > 0) statusParts.push(`${skipped} skipped`);
+            break;
+          case "incomplete":
+            if (incomplete > 0) statusParts.push(`${incomplete} incomplete`);
+            if (passed > 0) statusParts.push(`${passed} passed`);
+            if (failed > 0) statusParts.push(`${failed} failed`);
+            if (pending > 0) statusParts.push(`${pending} pending`);
+            break;
+          case "pending":
+            if (pending > 0) statusParts.push(`${pending} pending`);
+            if (passed > 0) statusParts.push(`${passed} passed`);
+            if (failed > 0) statusParts.push(`${failed} failed`);
+            break;
+          case "skipped":
+            statusParts.push(`${specCount} skipped`);
+            break;
+          case "passed":
+            statusParts.push(`${specCount} passed`);
+            break;
+        }
+        if (suite.children.length > 0) {
+          statusParts.push(`${suite.children.length} child suite${suite.children.length !== 1 ? "s" : ""}`);
+        }
+        const details = statusParts.length ? this.colored("gray", ` (${statusParts.join(", ")})`) : "";
+        const desc = suite.status === "incomplete" ? this.colored("yellow", suite.description) : suite.description;
+        this.print(`${indent}${this.colored(color, symbol)} ${desc}${details}
+`);
+      } else if (childHasProblems) {
+        const hasNonSkippedChildProblems = suite.children.some(
+          (c) => ["failed", "pending", "incomplete"].includes(c.status)
+        );
+        if (hasNonSkippedChildProblems) {
+          this.print(`${indent}${this.colored("brightBlue", "↳")} ${this.colored("dim", suite.description)}
+`);
+        }
+      }
+    }
+    return hasProblems;
+  }
+  getSuiteSymbol(status) {
+    switch (status) {
+      case "failed":
+        return { symbol: "✕", color: "brightRed" };
+      case "pending":
+        return { symbol: "○", color: "brightYellow" };
+      case "skipped":
+        return { symbol: "⤼", color: "gray" };
+      case "incomplete":
+        return { symbol: "◷", color: "cyan" };
+      case "passed":
+        return { symbol: "✓", color: "brightGreen" };
+      default:
+        return { symbol: "?", color: "white" };
+    }
+  }
+  printBox(text, color) {
+    const width = text.length + 4;
+    const topBottom = "═".repeat(width);
+    logger.printlnRaw(`${this.colored(color, `  ╔${topBottom}╗`)}`);
+    logger.printlnRaw(`${this.colored(color, `  ║  `)}${this.colored(["bold", color], text + `  ║`)}`);
+    logger.printlnRaw(`${this.colored(color, `  ╚${topBottom}╝`)}`);
+  }
+  printSectionHeader(text, color) {
+    this.print(this.colored("bold", this.colored(color, `  ${text}
+`)));
+  }
+  printDivider() {
+    this.print(this.colored("gray", this.separator() + "\n"));
+  }
+  printSummary(totalTime) {
+    let passed = 0;
+    let failed = 0;
+    let pending = 0;
+    let skipped = 0;
+    let incomplete = 0;
+    let notRun = 0;
+    for (const [id, spec] of this.specById) {
+      switch (spec.status) {
+        case "passed":
+          passed++;
+          break;
+        case "failed":
+          failed++;
+          break;
+        case "pending":
+          pending++;
+          break;
+        case "skipped":
+          skipped++;
+          break;
+        case "incomplete":
+          incomplete++;
+          break;
+        default:
+          notRun++;
+          break;
+      }
+    }
+    const totalSpecs = this.specById.size;
+    const duration = `${totalTime.toFixed(3)}s`;
+    const lineWidth = this.lineWidth;
+    const rightInfo = `total: ${totalSpecs}  time: ${duration}`;
+    const title = "  Test Summary";
+    const spacing = Math.max(1, lineWidth - title.length - rightInfo.length);
+    const headerLine = this.colored("bold", title) + " ".repeat(spacing) + this.colored("gray", rightInfo);
+    this.print("\n");
+    this.print(headerLine + "\n");
+    this.print(this.colored("gray", this.separator() + "\n"));
+    const parts = [];
+    if (passed > 0)
+      parts.push(this.colored("brightGreen", `✓ Passed: ${passed}`));
+    if (failed > 0)
+      parts.push(this.colored("brightRed", `✕ Failed: ${failed}`));
+    if (pending > 0)
+      parts.push(this.colored("brightYellow", `○ Pending: ${pending}`));
+    if (incomplete > 0)
+      parts.push(this.colored("cyan", `◷ Incomplete: ${incomplete}`));
+    if (skipped > 0)
+      parts.push(this.colored("gray", `⤼ Skipped: ${skipped}`));
+    if (notRun > 0)
+      parts.push(this.colored("gray", `⊘ Not Run: ${notRun}`));
+    if (parts.length > 0)
+      this.print("  " + parts.join(this.colored("gray", "  |  ")) + "\n");
+    else
+      this.print(this.colored("gray", "  (no specs executed)\n"));
+  }
+  colored(style, text) {
+    const styles = Array.isArray(style) ? style : [style];
+    const seq = styles.map((s) => this.ansi[s] ?? "").join("");
+    return `${seq}${text}${this.ansi.none}`;
+  }
+  gatherEnvironmentInfo() {
+    const memUsage = process.memoryUsage();
+    const memTotal = Math.round(memUsage.heapTotal / 1024 / 1024);
+    const uptime = Math.round(process.uptime());
+    return {
+      node: process.version,
+      platform: `${process.platform} ${process.arch}`,
+      arch: process.arch,
+      cwd: process.cwd(),
+      memory: `${memTotal} MB`,
+      pid: process.pid,
+      uptime: `${uptime}s`
+    };
+  }
+  printEnvironmentInfo() {
+    if (!this.envInfo) this.envInfo = this.gatherEnvironmentInfo();
+    this.print("\n");
+    this.print(this.colored("bold", "  Environment\n"));
+    this.print(this.colored("gray", this.separator() + "\n"));
+    this.print(this.colored("cyan", "  Node.js:   ") + this.colored("white", `${this.envInfo.node}
+`));
+    this.print(this.colored("cyan", "  Platform:  ") + this.colored("white", `${this.envInfo.platform}
+`));
+    this.print(this.colored("cyan", "  Arch:      ") + this.colored("white", `${this.envInfo.arch}
+`));
+    this.print(this.colored("cyan", "  PID:       ") + this.colored("white", `${this.envInfo.pid}
+`));
+    this.print(this.colored("cyan", "  Uptime:    ") + this.colored("white", `${this.envInfo.uptime}
+`));
+    this.print(this.colored("cyan", "  Memory:    ") + this.colored("white", `${this.envInfo.memory} heap
+`));
+    if (this.envInfo.userAgent) {
+      this.printUserAgentInfo(this.envInfo.userAgent);
+    }
+    this.print("\n");
+    const cwdShort = this.truncateString(this.envInfo.cwd, 45, true);
+    this.print(this.colored("cyan", "  Directory:  ") + this.colored("gray", `${cwdShort}
+`));
+  }
+  detectBrowser(userAgent) {
+    let name = "Unknown";
+    let version = "";
+    const ua = userAgent.toLowerCase();
+    if (/firefox\/(\d+\.\d+)/.test(ua)) {
+      name = "Firefox";
+      version = ua.match(/firefox\/(\d+\.\d+)/)[1];
+    } else if (/edg\/(\d+\.\d+)/.test(ua)) {
+      name = "Edge";
+      version = ua.match(/edg\/(\d+\.\d+)/)[1];
+    } else if (/chrome\/(\d+\.\d+)/.test(ua)) {
+      name = "Chrome";
+      version = ua.match(/chrome\/(\d+\.\d+)/)[1];
+    } else if (/safari\/(\d+\.\d+)/.test(ua) && /version\/(\d+\.\d+)/.test(ua)) {
+      name = "Safari";
+      version = ua.match(/version\/(\d+\.\d+)/)[1];
+    } else if (/opr\/(\d+\.\d+)/.test(ua)) {
+      name = "Opera";
+      version = ua.match(/opr\/(\d+\.\d+)/)[1];
+    }
+    return { name, version };
+  }
+  printUserAgentInfo(userAgent) {
+    const { name: browserName, version: browserVersion } = this.detectBrowser(userAgent.userAgent);
+    this.print("\n");
+    this.print(this.colored("bold", "  Browser/Navigator\n"));
+    this.print(this.colored("gray", this.separator() + "\n"));
+    const shortUA = this.truncateString(userAgent.userAgent, 45);
+    this.print(this.colored("cyan", "  User Agent: ") + this.colored("white", `${shortUA}
+`));
+    this.print(this.colored("cyan", "  Browser:    ") + this.colored("white", `${browserName} ${browserVersion}
+`));
+    if (userAgent.platform) {
+      this.print(this.colored("cyan", "  Platform:   ") + this.colored("white", `${userAgent.platform}
+`));
+    }
+    if (userAgent.vendor) {
+      this.print(this.colored("cyan", "  Vendor:     ") + this.colored("white", `${userAgent.vendor}
+`));
+    }
+    if (userAgent.language) {
+      this.print(this.colored("cyan", "  Language:   ") + this.colored("white", `${userAgent.language}
+`));
+    }
+    if (userAgent.languages?.length > 0) {
+      const langs = userAgent.languages.join(", ");
+      const shortLangs = this.truncateString(langs, 40);
+      this.print(this.colored("cyan", "  Languages:  ") + this.colored("white", `${shortLangs}
+`));
+    }
+  }
+  truncateString(str, maxLength, fromStart = false) {
+    if (str.length <= maxLength) return str;
+    if (fromStart) {
+      return "..." + str.slice(-(maxLength - 3));
+    }
+    return str.substring(0, maxLength - 3) + "...";
+  }
+  printTestConfiguration(config) {
+    if (!config || Object.keys(config).length === 0) return;
+    const lineWidth = this.lineWidth;
+    const orderPart = config.order?.random !== void 0 ? config.order.random ? "random" : "sequential" : null;
+    const seedPart = config.order?.seed !== void 0 ? `seed: ${config.order.seed}` : null;
+    const rightInfo = [orderPart, seedPart].filter(Boolean).join("  ");
+    const title = "  Test Configuration";
+    const spacing = Math.max(1, lineWidth - title.length - rightInfo.length);
+    const headerLine = this.colored("bold", title) + " ".repeat(spacing) + this.colored("gray", rightInfo);
+    this.print("\n");
+    this.print(headerLine + "\n");
+    this.print(this.colored("gray", this.separator() + "\n"));
+    const parts = [];
+    if (config.stopOnSpecFailure !== void 0)
+      parts.push(
+        this.colored("magenta", "Fail Fast:") + " " + this.colored("white", config.stopOnSpecFailure ? "✓ enabled" : "✗ disabled")
+      );
+    if (config.stopSpecOnExpectationFailure !== void 0)
+      parts.push(
+        this.colored("magenta", "Stop Spec:") + " " + this.colored("white", config.stopSpecOnExpectationFailure ? "✓ enabled" : "✗ disabled")
+      );
+    if (config.failSpecWithNoExpectations !== void 0)
+      parts.push(
+        this.colored("magenta", "No Expect:") + " " + this.colored("white", config.failSpecWithNoExpectations ? "✓ fail" : "✗ pass")
+      );
+    if (parts.length > 0) {
+      this.print("  " + parts.join(this.colored("gray", "  |  ")) + "\n");
+    }
+  }
+}
+const ANSI_FULL_REGEX = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1B\\))/g;
+function wrapLine(text, width, indentation = 0, mode = "char") {
+  text = text.replace(/\r?\n/g, " ").replace(/[\uFEFF\xA0\t]/g, " ").replace(/\s{2,}/g, " ").trim();
+  const indent = " ".repeat(indentation);
+  const indentWidth = indent.length;
+  if (width <= indentWidth) width = indentWidth + 1;
+  const availableWidth = width - indentWidth;
+  return mode === "char" ? wrapByChar(text, availableWidth, indent) : wrapByWord(text, availableWidth, indent);
+}
+function wrapByChar(text, available, indent) {
+  const lines = [];
+  let buf = "";
+  let vis = 0;
+  const tokens = text.split(ANSI_FULL_REGEX);
+  for (const token of tokens) {
+    if (ANSI_FULL_REGEX.test(token)) {
+      buf += token;
+      continue;
+    }
+    for (const ch of [...token]) {
+      if (vis >= available) {
+        lines.push(indent + buf);
+        buf = "";
+        vis = 0;
+      }
+      buf += ch;
+      vis++;
+    }
+  }
+  if (buf) lines.push(indent + buf);
+  return lines;
+}
+function wrapByWord(text, available, indent) {
+  const lines = [];
+  let buf = "";
+  let vis = 0;
+  let word = "";
+  let wordVis = 0;
+  const flushWord = () => {
+    if (!word) return;
+    if (wordVis > available) {
+      for (const ch of [...word]) {
+        if (vis >= available) {
+          lines.push(indent + buf.trimEnd());
+          buf = "";
+          vis = 0;
+        }
+        buf += ch;
+        vis++;
+      }
+    } else {
+      if (vis + wordVis > available && vis > 0) {
+        lines.push(indent + buf.trimEnd());
+        buf = "";
+        vis = 0;
+      }
+      buf += word;
+      vis += wordVis;
+    }
+    word = "";
+    wordVis = 0;
+  };
+  for (const ch of [...text]) {
+    if (/\s/.test(ch)) {
+      flushWord();
+      if (vis < available && vis > 0) {
+        buf += " ";
+        vis++;
+      }
+    } else {
+      word += ch;
+      wordVis++;
+    }
+  }
+  flushWord();
+  if (buf) lines.push(indent + buf.trimEnd());
+  return lines;
+}
+const colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  brightRed: "\x1B[91m",
+  brightGreen: "\x1B[92m"
+};
+class Logger {
+  previousLines = [];
+  showPrompt = true;
+  prompt;
+  errorPrompt;
+  constructor(options = {}) {
+    this.prompt = `${colors.bold}${options.promptColor ?? colors.brightGreen}> ${colors.reset}`;
+    this.errorPrompt = `${options.errorPromptColor ?? colors.brightRed}> ${colors.reset}`;
+  }
+  // ─── Utilities ───────────────────────────────────────────
+  visibleWidth(str) {
+    return [...str.replace(ANSI_FULL_REGEX, "")].length;
+  }
+  clearLine() {
+    process.stdout.write("\r\x1B[K");
+  }
+  writeLine(line, color = "") {
+    this.clearLine();
+    process.stdout.write(color + line + colors.reset);
+    if (this.visibleWidth(line) >= MAX_WIDTH) {
+      process.stdout.write("\n");
+    }
+  }
+  addLine(text, opts = {}) {
+    this.previousLines.push({
+      text,
+      isRaw: opts.isRaw,
+      hasPrompt: opts.hasPrompt ?? this.showPrompt
+    });
+    if (this.previousLines.length > 200) {
+      this.previousLines.splice(0, 100);
+    }
+  }
+  // ─── REFORMAT (RESTORED) ─────────────────────────────────
+  reformat(text, opts) {
+    const { width, align = "left", padChar = " " } = opts;
+    const normalized = text.replace(/\r?\n/g, " ").replace(/[\uFEFF\xA0\t]/g, " ").replace(/\s{2,}/g, " ").trim();
+    const lines = [];
+    let buf = "";
+    let vis = 0;
+    const tokens = normalized.split(
+      /(\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1B\\)))/g
+    );
+    for (const token of tokens) {
+      if (ANSI_FULL_REGEX.test(token)) {
+        buf += token;
+        continue;
+      }
+      for (const ch of [...token]) {
+        if (vis >= width) {
+          lines.push(this.applyPadding(buf, vis, width, align, padChar));
+          buf = "";
+          vis = 0;
+        }
+        buf += ch;
+        vis++;
+      }
+    }
+    if (buf) {
+      lines.push(this.applyPadding(buf, vis, width, align, padChar));
+    }
+    return lines;
+  }
+  applyPadding(text, visible, width, align, padChar) {
+    const pad = Math.max(0, width - visible);
+    switch (align) {
+      case "right":
+        return padChar.repeat(pad) + text;
+      case "center": {
+        const left = Math.floor(pad / 2);
+        const right = pad - left;
+        return padChar.repeat(left) + text + padChar.repeat(right);
+      }
+      default:
+        return text + padChar.repeat(pad);
+    }
+  }
+  // ─── Printing ────────────────────────────────────────────
+  print(msg) {
+    const lines = wrapLine(
+      this.showPrompt ? this.prompt + msg : msg,
+      MAX_WIDTH,
+      0,
+      "word"
+    );
+    for (let i = 0; i < lines.length; i++) {
+      this.writeLine(lines[i]);
+      if (i < lines.length - 1) process.stdout.write("\n");
+      this.addLine(lines[i]);
+    }
+    this.showPrompt = false;
+    return true;
+  }
+  println(msg = "") {
+    if (msg) this.print(msg);
+    process.stdout.write("\n");
+    this.addLine("");
+    this.showPrompt = true;
+    return true;
+  }
+  printRaw(line) {
+    process.stdout.write(line);
+    this.addLine(line, { isRaw: true });
+    return true;
+  }
+  printlnRaw(line = "") {
+    this.printRaw(line);
+    process.stdout.write("\n");
+    this.addLine("", { isRaw: true });
+    return true;
+  }
+  error(msg) {
+    const lines = wrapLine(
+      this.showPrompt ? this.errorPrompt + msg : msg,
+      MAX_WIDTH,
+      0,
+      "word"
+    );
+    for (let i = 0; i < lines.length; i++) {
+      this.writeLine(lines[i], colors.brightRed);
+      if (i < lines.length - 1) process.stdout.write("\n");
+      this.addLine(lines[i]);
+    }
+    process.stdout.write("\n");
+    this.showPrompt = true;
+    return true;
+  }
+  // ─── History ─────────────────────────────────────────────
+  clearHistory() {
+    this.previousLines = [];
+  }
+  getHistory() {
+    return [...this.previousLines];
+  }
+}
+const logger = new Logger();
+class ConfigManager {
+  static ensureConfigExists(configPath) {
+    const jsonPath = norm(configPath || path.resolve(process.cwd(), "testify.json"));
+    const cleaner = new JSONCleaner();
+    if (fs.existsSync(jsonPath)) {
+      try {
+        return cleaner.parse(fs.readFileSync(jsonPath, "utf-8"));
+      } catch (error) {
+        logger.error(`❌ Failed to parse existing testify.json ${error}`);
+        return {};
+      }
+    }
+    const defaultConfig = this.createDefaultConfig();
+    try {
+      fs.writeFileSync(jsonPath, JSON.stringify(defaultConfig, null, 2));
+      logger.println(`🆕 Created default test runner config at ${jsonPath}`);
+    } catch (error) {
+      logger.error(`❌ Failed to create default testify.json ${error}`);
+    }
+    return defaultConfig;
+  }
+  static createDefaultConfig() {
+    const configDir = norm(process.cwd());
+    const rel = (p) => {
+      const r = path.relative(configDir, p);
+      return r === "" ? "." : norm(r);
+    };
+    const srcAbsolute = path.join(configDir, "src");
+    const testAbsolute = path.join(configDir, "tests");
+    const outAbsolute = path.join(configDir, "dist/.vite-jasmine-build/");
+    return {
+      srcDirs: [rel(srcAbsolute)],
+      // ["./src"]
+      testDirs: [rel(testAbsolute)],
+      // ["./tests"]
+      exclude: ["**/node_modules/**"],
+      preserveOutputs: false,
+      outDir: rel(outAbsolute),
+      // "./dist/.vite-jasmine-build"
+      browser: "chrome",
+      headless: false,
+      coverage: false,
+      port: 8888,
+      viteBuildOptions: {
+        target: "es2022",
+        sourcemap: true,
+        minify: false,
+        preserveModules: false,
+        preserveModulesRoot: rel(configDir)
+        // "./"
+      },
+      jasmineConfig: {
+        env: { stopSpecOnExpectationFailure: false, random: true, seed: 0, timeout: 12e4 }
+      },
+      htmlOptions: {
+        title: "Jasmine Tests Runner"
+      },
+      suppressConsoleLogs: false
+    };
+  }
+  static initViteJasmineConfig(configPath) {
+    const jsonPath = norm(configPath || path.resolve(process.cwd(), "testify.json"));
+    if (fs.existsSync(jsonPath)) {
+      logger.println(`⚠️  Config already exists at ${jsonPath}`);
+      return;
+    }
+    const defaultConfig = this.createDefaultConfig();
+    fs.writeFileSync(jsonPath, JSON.stringify(defaultConfig, null, 2));
+    logger.println(`✅ Generated default Vite Jasmine config at ${jsonPath}`);
+  }
+  static loadViteJasmineBrowserConfig(configPath) {
+    return this.ensureConfigExists(configPath);
+  }
+}
+class BrowserManager {
+  constructor(config) {
+    this.config = config;
+  }
+  playwright = null;
+  currentBrowser = null;
+  currentPage = null;
+  getPlaywright() {
+    if (!this.playwright) {
+      this.playwright = require2("playwright");
+    }
+    return this.playwright;
+  }
+  async checkBrowser(browserName) {
+    try {
+      const playwright = this.getPlaywright();
+      let browser = null;
+      switch (browserName.toLowerCase()) {
+        case "chromium":
+        case "chrome":
+          browser = playwright.chromium;
+          break;
+        case "firefox":
+          browser = playwright.firefox;
+          break;
+        case "webkit":
+        case "safari":
+          browser = playwright.webkit;
+          break;
+        default:
+          logger.println(`⚠️  Unknown browser "${browserName}", falling back to Node.js mode`);
+          return null;
+      }
+      return browser;
+    } catch (err) {
+      if (err.code === "MODULE_NOT_FOUND") {
+        logger.println(`ℹ️ Playwright not installed. Browser "${browserName}" not available.`);
+        logger.println(`💡 Tip: Install Playwright to enable browser testing:
+   npm install playwright`);
+      } else {
+        logger.error(`❌ Browser execution failed for "${browserName}": ${err.message}`);
+      }
+      return null;
+    }
+  }
+  async runHeadlessBrowserTests(browserType, port) {
+    const browser = await browserType.launch({
+      headless: true,
+      args: ["--no-sandbox", "--disable-setuid-sandbox"]
+    });
+    const page = await browser.newPage();
+    page.setDefaultTimeout(0);
+    let interrupted = false;
+    const interruptError = new Error("Interrupted");
+    let interruptReject = null;
+    const interruptPromise = new Promise((_, reject) => {
+      interruptReject = reject;
+    });
+    const abortRun = () => {
+      interrupted = true;
+      if (interruptReject) interruptReject(interruptError);
+      if (!page.isClosed()) {
+        void page.close().catch(() => {
+        });
+      }
+      void browser.close().catch(() => {
+      });
+    };
+    const sigintHandler = () => abortRun();
+    const sigtermHandler = () => abortRun();
+    process.once("SIGINT", sigintHandler);
+    process.once("SIGTERM", sigtermHandler);
+    page.on("console", (msg) => {
+      const text = msg.text();
+      const type = msg.type();
+      if (text.match(/error|failed/i)) {
+        if (type === "error") logger.error(`BROWSER ERROR: ${text}`);
+        else if (type === "warn") logger.println(`BROWSER WARN: ${text}`);
+      }
+    });
+    page.on("pageerror", (error) => logger.error(`❌ Page error: ${error.message}`));
+    page.on("requestfailed", (request) => logger.error(`❌ Request failed: ${request.url()}, ${request.failure()?.errorText}`));
+    logger.println("🌐 Navigating to test page...");
+    await page.goto(`http://localhost:${port}/index.html`, { waitUntil: "networkidle0", timeout: 12e4 });
+    try {
+      await Promise.race([
+        page.waitForFunction(() => window.jasmineFinished === true, {
+          timeout: this.config.jasmineConfig?.env?.timeout ?? 12e4
+        }),
+        interruptPromise
+      ]);
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      await browser.close();
+      return true;
+    } catch (error) {
+      if (interrupted || error === interruptError) {
+        logger.printRaw("\n\n");
+        logger.println("🛑 Tests aborted by user (Ctrl+C)");
+        await browser.close();
+        return false;
+      }
+      logger.error(`❌ Test execution failed: ${error}`);
+      await browser.close();
+      throw error;
+    } finally {
+      process.removeListener("SIGINT", sigintHandler);
+      process.removeListener("SIGTERM", sigtermHandler);
+    }
+  }
+  async openBrowser(port, onBrowserClose, options) {
+    let browserName = this.config.browser || "chrome";
+    const url = `http://localhost:${port}/index.html`;
+    try {
+      const playwright = this.getPlaywright();
+      let browserType;
+      switch (browserName.toLowerCase()) {
+        case "chrome":
+        case "chromium":
+          browserType = playwright.chromium;
+          break;
+        case "firefox":
+          browserType = playwright.firefox;
+          break;
+        case "webkit":
+        case "safari":
+          browserType = playwright.webkit;
+          break;
+        default:
+          logger.println(`⚠️  Unknown browser "${browserName}", using Chrome instead`);
+          browserType = playwright.chromium;
+          browserName = "chrome";
+      }
+      if (!browserType) {
+        logger.println(`❌ Browser "${browserName}" is not installed.`);
+        logger.println(`💡 Tip: Install it by running: npx playwright install ${browserName.toLowerCase()}`);
+        return;
+      }
+      logger.println(`🌐 Opening ${browserName} browser...`);
+      const browser = await browserType.launch({
+        headless: this.config.headless,
+        args: ["--no-sandbox", "--disable-setuid-sandbox"]
+      });
+      const page = await browser.newPage();
+      this.currentBrowser = browser;
+      this.currentPage = page;
+      await page.goto(url);
+      const exitOnClose = options?.exitOnClose !== false;
+      page.on("close", async () => {
+        if (onBrowserClose) {
+          await onBrowserClose();
+        }
+        this.clearBrowserState();
+        if (exitOnClose) {
+          process.exit(0);
+        }
+      });
+    } catch (error) {
+      if (error.code === "MODULE_NOT_FOUND") {
+        logger.println(`ℹ️ Playwright not installed. Please open browser manually: ${url}`);
+        logger.println(`💡 Tip: Install Playwright to enable automatic browser opening:
+   npm install playwright`);
+      } else {
+        logger.error(`❌ Failed to open browser: ${error.message}`);
+        logger.println(`💡 Please open browser manually: ${url}`);
+      }
+    }
+  }
+  clearBrowserState() {
+    this.currentPage = null;
+    this.currentBrowser = null;
+  }
+  async closeBrowser() {
+    if (!this.currentBrowser && !this.currentPage) {
+      return;
+    }
+    try {
+      if (this.currentBrowser) {
+        await this.currentBrowser.close();
+      } else if (this.currentPage && !this.currentPage.isClosed()) {
+        await this.currentPage.close();
+      }
+    } catch (error) {
+      logger.error(`❌ Failed to close browser: ${error?.message ?? error}`);
+    } finally {
+      this.clearBrowserState();
+    }
+  }
+}
+class FileDiscoveryService {
+  constructor(config) {
+    this.config = config;
+  }
+  getSrcDirConfigs() {
+    const srcDirs = Array.isArray(this.config.srcDirs) ? this.config.srcDirs : [this.config.srcDirs];
+    if (srcDirs.filter(Boolean).length === 0) return ["./src"];
+    return srcDirs.filter(Boolean);
+  }
+  getTestDirConfigs() {
+    const testDirs = Array.isArray(this.config.testDirs) ? this.config.testDirs : [this.config.testDirs];
+    if (testDirs.filter(Boolean).length === 0) return ["./tests"];
+    return testDirs.filter(Boolean);
+  }
+  async scanDir(dir, pattern, exclude = []) {
+    const cleanPattern = pattern.startsWith("/") || pattern.startsWith("**") ? pattern : `/${pattern}`;
+    const basePath = norm(path.join(dir, cleanPattern)).replace(/^\//, "");
+    try {
+      let files = await glob(basePath, { absolute: true, ignore: exclude });
+      return files.map((s) => norm(s));
+    } catch (error) {
+      logger.error(`❌ Error discovering files: ${error}`);
+      throw new Error("Failed to discover source and test files");
+    }
+  }
+  async filterExistingFiles(paths) {
+    const existingFiles = [];
+    await Promise.all(
+      paths.map(async (filePath) => {
+        const normalizedPath = norm(filePath);
+        try {
+          await fs$1.access(normalizedPath);
+          existingFiles.push(normalizedPath);
+        } catch {
+        }
+      })
+    );
+    return existingFiles;
+  }
+  async discoverSources() {
+    try {
+      const defaultSrcExclude = ["**/node_modules/**", "**/*.spec.*"];
+      const defaultTestExclude = ["**/node_modules/**"];
+      const sharedExclude = this.config.exclude ?? [];
+      const srcDirs = this.getSrcDirConfigs();
+      const testDirs = this.getTestDirConfigs();
+      const srcFiles = [];
+      for (const inc of srcDirs) {
+        const exclude = [...defaultSrcExclude, ...sharedExclude];
+        const files = await this.scanDir(norm(inc), "/**/*.{ts,js,mjs}", exclude);
+        srcFiles.push(...files);
+      }
+      const specFiles = [];
+      for (const inc of testDirs) {
+        const exclude = [...defaultTestExclude, ...sharedExclude];
+        const files = await this.scanDir(norm(inc), "/**/*.spec.{ts,js,mjs}", exclude);
+        specFiles.push(...files);
+      }
+      return { srcFiles: [...new Set(srcFiles)], specFiles: [...new Set(specFiles)] };
+    } catch (error) {
+      logger.error(`❌ Error discovering files: ${error}`);
+      throw new Error("Failed to discover source and test files");
+    }
+  }
+  getOutputName(filePath) {
+    const srcDirs = this.getSrcDirConfigs();
+    const testDirs = this.getTestDirConfigs();
+    const normalizedPath = norm(path.resolve(filePath));
+    const resolveDirs = (dirs) => dirs.map((dir) => norm(path.resolve(dir)));
+    const normalizedSrcDirs = resolveDirs(srcDirs);
+    const normalizedTestDirs = resolveDirs(testDirs);
+    if (!normalizedSrcDirs.length) {
+      normalizedSrcDirs.push(norm(path.resolve("./src")));
+    }
+    if (!normalizedTestDirs.length) {
+      normalizedTestDirs.push(norm(path.resolve("./tests")));
+    }
+    const matchDir = (dirs) => {
+      for (const candidate of dirs) {
+        if (normalizedPath === candidate || normalizedPath.startsWith(`${candidate}/`)) {
+          return candidate;
+        }
+      }
+      return null;
+    };
+    const baseTest = matchDir(normalizedTestDirs);
+    const baseSrc = matchDir(normalizedSrcDirs) ?? normalizedSrcDirs[0];
+    const base = baseTest ?? baseSrc;
+    const relativePath = path.relative(base, normalizedPath);
+    const relativeNormalized = norm(relativePath);
+    const relativeWithoutExt = relativeNormalized.replace(/\.(ts|js|mjs)$/, "");
+    const sanitizeSegment = (segment) => {
+      if (segment === "..") return "up";
+      if (segment === ".") return "dot";
+      return segment;
+    };
+    const segments = relativeWithoutExt.split("/").filter(Boolean);
+    const sanitized = segments.length > 0 ? segments.map(sanitizeSegment).join("_") : sanitizeSegment(path.basename(relativeWithoutExt) || "index");
+    return `${sanitized}.js`;
+  }
+}
+class HtmlGenerator {
+  constructor(fileDiscovery, config) {
+    this.fileDiscovery = fileDiscovery;
+    this.config = config;
+  }
+  async generateHtmlFile() {
+    const htmlDir = this.config.outDir;
+    if (!fs.existsSync(htmlDir)) {
+      fs.mkdirSync(htmlDir, { recursive: true });
+    }
+    const builtFiles = fs.readdirSync(htmlDir).filter((f) => f.endsWith(".js")).sort();
+    if (builtFiles.length === 0) {
+      logger.println("⚠️  No JS files found for HTML generation.");
+      return;
+    }
+    const sourceFiles = builtFiles.filter((f) => !f.endsWith(".spec.js"));
+    const specFiles = builtFiles.filter((f) => f.endsWith(".spec.js"));
+    const imports = [...sourceFiles, ...specFiles].map((f) => `import "./${f}";`).join("\n        ");
+    const faviconTag = this.getFaviconTag();
+    const htmlContent = this.generateHtmlTemplate(imports, faviconTag);
+    const htmlPath = norm(path.join(htmlDir, "index.html"));
+    fs.writeFileSync(htmlPath, htmlContent);
+    logger.println(`📄 Generated test page: ${norm(path.relative(this.config.outDir, htmlPath))}`);
+  }
+  async generateHtmlFileWithHmr() {
+    const htmlDir = this.config.outDir;
+    if (!fs.existsSync(htmlDir)) {
+      fs.mkdirSync(htmlDir, { recursive: true });
+    }
+    const faviconTag = this.getFaviconTag();
+    const htmlContent = this.generateHtmlTemplateWithHmr(faviconTag);
+    const htmlPath = norm(path.join(htmlDir, "index.html"));
+    fs.writeFileSync(htmlPath, htmlContent);
+    console.log("📄 Generated HMR-enabled test page:", norm(path.relative(this.config.outDir, htmlPath)));
+  }
+  getFaviconTag() {
+    const __filename2 = norm(fileURLToPath(import.meta.url));
+    const __dirname2 = norm(path.dirname(__filename2));
+    const faviconPath = path.resolve(__dirname2, "../assets/favicon.ico");
+    if (fs.existsSync(faviconPath)) {
+      const faviconData = fs.readFileSync(faviconPath);
+      const faviconBase64 = faviconData.toString("base64");
+      return `<link rel="icon" type="image/x-icon" href="data:image/x-icon;base64,${faviconBase64}">`;
+    } else {
+      logger.println(`⚠️  Favicon not found at ${faviconPath}, using default <link>`);
+      return `<link rel="icon" href="favicon.ico" type="image/x-icon" />`;
+    }
+  }
+  generateHtmlTemplate(imports, faviconTag) {
+    return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  ${faviconTag}
+  <title>${this.config.htmlOptions?.title || "Jasmine Tests Runner"}</title>
+  <link rel="stylesheet" href="/node_modules/jasmine-core/lib/jasmine-core/jasmine.css">
+  <script src="/node_modules/jasmine-core/lib/jasmine-core/jasmine.js"><\/script>
+  <script src="/node_modules/jasmine-core/lib/jasmine-core/jasmine-html.js"><\/script>
+  <script src="/node_modules/jasmine-core/lib/jasmine-core/boot0.js"><\/script>
+  <script src="/node_modules/jasmine-core/lib/jasmine-core/boot1.js"><\/script>
+  <script type="module">
+    ${this.getWebSocketEventForwarderScript()}
+    
+    const forwarder = new WebSocketEventForwarder();
+    forwarder.connect();
+    jasmine.getEnv().addReporter(forwarder);
+    
+    ${imports}
+  <\/script>
+</head>
+<body>
+  <div class="jasmine_html-reporter"></div>
+</body>
+</html>`;
+  }
+  generateHtmlTemplateWithHmr(faviconTag) {
+    return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  ${faviconTag}
+  <title>${this.config.htmlOptions?.title || "Jasmine Tests Runner (HMR)"}</title>
+  <link rel="stylesheet" href="/node_modules/jasmine-core/lib/jasmine-core/jasmine.css">
+  <script src="/node_modules/jasmine-core/lib/jasmine-core/jasmine.js"><\/script>
+  <script src="/node_modules/jasmine-core/lib/jasmine-core/jasmine-html.js"><\/script>
+
+  <script>
+${this.getJasminePatchScript()}
+
+${this.getWebSocketEventForwarderScript()}
+
+${this.getHmrClientScript()}
+
+// Initialize everything after Jasmine is loaded
+(function initAfterJasmine() {
+  if (!window.jasmineRequire) {
+    return setTimeout(initAfterJasmine, 10);
+  }
+
+  const script = document.createElement('script');
+  script.src = '/node_modules/jasmine-core/lib/jasmine-core/boot0.js';
+  
+  script.onload = () => {
+    // Add the WebSocket forwarder as a reporter
+    const forwarder = new WebSocketEventForwarder();
+    forwarder.connect();
+    jasmine.getEnv().addReporter(forwarder);
+    
+    ${this.getRuntimeHelpersScript()}
+  };
+  
+  script.onerror = (err) => {
+    console.error('Failed to load boot0.js:', err);
+  };
+  
+  document.head.appendChild(script);
+})();
+  <\/script>
+</head>
+<body>
+  <div class="jasmine_html-reporter"></div>
+</body>
+</html>`;
+  }
+  getJasminePatchScript() {
+    return `
+// Patch Jasmine before boot to add metadata backlinks
+(function patchJasmineBeforeBoot() {
+  if (!window.jasmineRequire) {
+    return setTimeout(patchJasmineBeforeBoot, 10);
+  }
+
+  const j$ = jasmineRequire.core(jasmineRequire);
+  const OriginalSuiteFactory = jasmineRequire.Suite || j$.Suite || null;
+  const OriginalEnvFactory = jasmineRequire.Env || j$.Env || null;
+  const root = window.jasmineRequire || jasmineRequire;
+
+  // Helper to attach metadata backref
+  function attachMetadataBackref(suite) {
+    if (!suite || !suite.metadata) return;
+    try {
+      if (!suite.metadata.__suite) {
+        Object.defineProperty(suite.metadata, '__suite', {
+          value: suite,
+          enumerable: false,
+          configurable: true,
+          writable: false
+        });
+      }
+    } catch (e) {
+      // Ignore errors
+    }
+  }
+
+  // Recursively attach backlinks
+  function attachMetadataBackrefsRecursive(suite) {
+    try {
+      attachMetadataBackref(suite);
+      if (Array.isArray(suite.children)) {
+        suite.children.forEach(attachMetadataBackrefsRecursive);
+      }
+    } catch (e) {
+      // Ignore errors
+    }
+  }
+
+  // Patch Suite factory
+  if (OriginalSuiteFactory) {
+    root.Suite = function(j$local) {
+      const OriginalSuite = OriginalSuiteFactory(j$local);
+      
+      return class PatchedSuite extends OriginalSuite {
+        constructor(attrs) {
+          super(attrs);
+          attachMetadataBackref(this);
+        }
+      };
+    };
+  }
+
+  // Patch Env factory
+  if (OriginalEnvFactory) {
+    root.Env = function(j$local) {
+      const OriginalEnv = OriginalEnvFactory(j$local);
+      
+      return class PatchedEnv extends OriginalEnv {
+        constructor(attrs) {
+          super(attrs);
+          try {
+            if (this.topSuite) {
+              window.__jasmine_real_topSuite = this.topSuite;
+              attachMetadataBackrefsRecursive(this.topSuite);
+            }
+          } catch (e) {
+            // Ignore errors
+          }
+        }
+      };
+    };
+  }
+
+  // Define loadSpecs function in global scope
+  window.loadSpecs = async function(srcFiles, specFiles) {
+    // Wait for HMRClient
+    let attempts = 0;
+    while (!window.HMRClient && attempts < 100) {
+      await new Promise(resolve => setTimeout(resolve, 50));
+      attempts++;
+    }
+    
+    if (!window.HMRClient) {
+      console.error('❌ HMRClient not available after waiting');
+      return;
+    }
+    
+    console.log('📦 Loading spec files dynamically...');
+    
+    try {
+      // Load source files first
+      for (const file of srcFiles) {
+        await import('/' + file);
+      }
+      
+      // Then load spec files with file path tracking
+      for (const file of specFiles) {
+        const module = await import('/' + file);
+        
+        if (window.HMRClient?.attachFilePathToSuites) {
+          await window.HMRClient.attachFilePathToSuites(file, module);
+        }
+      }
+      
+      console.log('✅ All specs loaded and tagged with file paths');
+    } catch (err) {
+      console.error('❌ Failed to load specs:', err);
+    }
+  };
+})();
+`;
+  }
+  getWebSocketEventForwarderScript() {
+    const seed = this.config.jasmineConfig?.env?.seed ?? 0;
+    const random = this.config.jasmineConfig?.env?.random ?? false;
+    return `
+function WebSocketEventForwarder() {
+  this.ws = null;
+  this.connected = false;
+  this.messageQueue = [];
+
+  const self = this;
+
+  this.connect = function () {
+    const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+    const wsUrl = protocol + '//' + window.location.host;
+
+    self.ws = new WebSocket(wsUrl);
+
+    self.ws.onopen = () => {
+      self.connected = true;
+      console.log('WebSocket connected to', wsUrl);
+
+      self.send({
+        type: 'userAgent',
+        data: {
+          userAgent: navigator.userAgent,
+          appName: navigator.appName,
+          appVersion: navigator.appVersion,
+          platform: navigator.platform,
+          vendor: navigator.vendor,
+          language: navigator.language,
+          languages: navigator.languages,
+          orderedSuites: self.getOrderedSuites(${seed}, ${random}).map(suite => ({
+            id: suite.id,
+            description: suite.description,
+            fullName: suite.getFullName ? suite.getFullName() : suite.description
+          })),
+          orderedSpecs: self.getOrderedSpecs(${seed}, ${random}).map(spec => ({
+            id: spec.id,
+            description: spec.description,
+            fullName: spec.getFullName ? spec.getFullName() : spec.description
+          }))
+        },
+        timestamp: Date.now()
+      });
+
+      while (self.messageQueue.length > 0) {
+        const msg = self.messageQueue.shift();
+        self.send(msg);
+      }
+    };
+
+    self.ws.onclose = () => {
+      self.connected = false;
+      console.log('WebSocket disconnected');
+      setTimeout(() => self.connect(), 1000);
+    };
+
+    self.ws.onerror = (err) => {
+      self.connected = false;
+      console.error('WebSocket error:', err);
+    };
+
+    self.ws.onmessage = async (event) => {
+      try {
+        const message = JSON.parse(event.data);
+        if (window.HMRClient && (message.type === 'hmr:connected' || message.type === 'hmr:update')) {
+          await window.HMRClient.handleMessage(message);
+        }
+      } catch (err) {
+        console.error('Failed to handle WebSocket message:', err);
+      }
+    };
+  };
+
+  this.send = function (msg) {
+    if (self.connected && self.ws && self.ws.readyState === WebSocket.OPEN) {
+      try {
+        self.ws.send(JSON.stringify(msg));
+      } catch (err) {
+        console.error('Failed to send WebSocket message:', err);
+      }
+    } else {
+      self.messageQueue.push(msg);
+    }
+  };
+
+  this.getAllSpecs = function () {
+    const allSpecs = [];
+    function collect(suite) {
+      suite.children.forEach((child) => {
+        if (child.children && child.children.length > 0) {
+          collect(child);
+        } else {
+          allSpecs.push(child);
+        }
+      });
+    }
+    
+    const env = jasmine?.getEnv?.();
+    if (env) collect(env.topSuite());
+    return allSpecs;
+  };
+
+  this.getAllSuites = function () {
+    const allSuites = [];
+    function collect(suite) {
+      allSuites.push(suite);
+      suite.children.forEach((child) => {
+        if (child.children && child.children.length > 0) {
+          collect(child);
+        }
+      });
+    }
+    
+    const env = jasmine?.getEnv?.();
+    if (env) collect(env.topSuite());
+    return allSuites;
+  };
+
+  this.getOrderedSpecs = function (seed, random) {
+    const allSpecs = self.getAllSpecs();
+    if (!random) return allSpecs;
+
+    const OrderCtor = jasmine.Order;
+    if (typeof OrderCtor === 'function') {
+      try {
+        const order = new OrderCtor({ random, seed });
+        if (typeof order.sort === 'function') {
+          return order.sort(allSpecs);
+        }
+      } catch (err) {
+        console.error('Failed to create jasmine.Order:', err);
+      }
+    }
+    return allSpecs;
+  };
+
+  this.getOrderedSuites = function (seed, random) {
+    const allSuites = self.getAllSuites();
+    if (!random) return allSuites;
+
+    const OrderCtor = jasmine.Order;
+    if (typeof OrderCtor === 'function') {
+      try {
+        const order = new OrderCtor({ random, seed });
+        if (typeof order.sort === 'function') {
+          return order.sort(allSuites);
+        }
+      } catch (err) {
+        console.error('Failed to create jasmine.Order for suites:', err);
+      }
+    }
+    return allSuites;
+  };
+
+  // Jasmine reporter hooks
+  this.jasmineStarted = function (config) {
+    let orderedSpecs = [];
+    let orderedSuites = [];
+
+    if (config.order) {
+      const random = !!config.order.random;
+      const seed = config.order.seed;
+      orderedSpecs = self.getOrderedSpecs(seed, random);
+      orderedSuites = self.getOrderedSuites(seed, random);
+    }
+
+    self.send({
+      type: 'jasmineStarted',
+      data: config,
+      timestamp: Date.now()
+    });
+  };
+
+  this.suiteStarted = function (suite) {
+    self.send({
+      type: 'suiteStarted',
+      id: suite.id,
+      description: suite.description,
+      fullName: suite.fullName,
+      timestamp: Date.now()
+    });
+  };
+
+  this.specStarted = function (spec) {
+    self.send({
+      type: 'specStarted',
+      id: spec.id,
+      description: spec.description,
+      fullName: spec.fullName,
+      timestamp: Date.now()
+    });
+  };
+
+  this.specDone = function (result) {
+    self.send({
+      type: 'specDone',
+      ...result,
+      timestamp: Date.now()
+    });
+  };
+
+  this.suiteDone = function (suite) {
+    self.send({
+      type: 'suiteDone',
+      id: suite.id,
+      description: suite.description,
+      fullName: suite.fullName,
+      timestamp: Date.now()
+    });
+  };
+
+  this.jasmineDone = function (result) {
+    const coverage = globalThis.__coverage__;
+    self.send({
+      type: 'jasmineDone',
+      ...result,
+      coverage: coverage ? JSON.stringify(coverage) : null,
+      timestamp: Date.now()
+    });
+
+    window.jasmineFinished = true;
+
+    if (!window.HMRClient) {
+      setTimeout(() => {
+        if (self.ws) self.ws.close();
+      }, 1000);
+    }
+  };
+}
+`;
+  }
+  getHmrClientScript() {
+    return `
+// HMR Client Runtime
+window.HMRClient = (function() {
+  const moduleRegistry = new Map();
+  
+  function getEnv() {
+    return window.jasmine?.getEnv?.();
+  }
+
+  function setFilePath(obj, filePath) {
+    if (!obj) return;
+    try {
+      Object.defineProperty(obj, '_filePath', {
+        value: filePath,
+        enumerable: false,
+        configurable: true,
+        writable: true
+      });
+    } catch (e) {
+      obj._filePath = filePath;
+    }
+  }
+
+  async function attachFilePathToSuites(filePath, moduleExports) {
+    const env = getEnv();
+    if (!env) return;
+    
+    const topSuite = env.topSuite().__suite || env.topSuite();
+    if (!topSuite) return;
+
+    function tagSuites(suite) {
+      if (!suite) return;
+
+      if (!suite._filePath) {
+        setFilePath(suite, filePath);
+      }
+
+      if (suite.metadata && !suite.metadata.__suite) {
+        try {
+          Object.defineProperty(suite.metadata, '__suite', {
+            value: suite,
+            enumerable: false,
+            configurable: true,
+            writable: false
+          });
+        } catch (e) {
+          // Ignore
+        }
+      }
+
+      const children = suite.children || [];
+      for (const ch of children) {
+        tagSuites(ch);
+      }
+    }
+
+    tagSuites(topSuite);
+  }
+
+  function detachFilePathSuites(filePath) {
+    const env = getEnv();
+    if (!env) return;
+    
+    const topSuite = env.topSuite().__suite || env.topSuite();
+    if (!topSuite) return;
+
+    function cleanSuite(suite) {
+      if (!suite || !Array.isArray(suite.children)) return;
+
+      const keep = [];
+
+      for (const childWrapper of suite.children) {
+        if (!childWrapper) continue;
+
+        const child = childWrapper;
+
+        if (child._filePath === filePath) {
+          continue;
+        }
+
+        if (child.children && Array.isArray(child.children)) {
+          cleanSuite(child);
+        }
+
+        keep.push(childWrapper);
+      }
+
+      if (suite.removeChildren && suite.addChild) {
+        suite.removeChildren();
+        keep.forEach(item => suite.addChild(item));
+      } else {
+        suite.children = keep;
+      }
+
+      if (Array.isArray(suite.specs)) {
+        suite.specs = suite.specs.filter(spec => spec._filePath !== filePath);
+      }
+    }
+
+    cleanSuite(topSuite);
+    console.log(\`🧹 Detached all suites/specs with _filePath: \${filePath}\`);
+  }
+
+  async function hotUpdateSpec(filePath, moduleExports) {
+    detachFilePathSuites(filePath);
+    await attachFilePathToSuites(filePath, moduleExports);
+    console.log('✅ Hot updated Jasmine suites from:', filePath);
+  }
+
+  async function handleMessage(message) {
+    if (message.type === 'hmr:connected') {
+      console.log('🔥 HMR enabled on server');
+      if (window.loadSpecs) {
+        await window.loadSpecs(message.srcFiles, message.specFiles);
+      }
+      return;
+    }
+
+    if (message.type === 'hmr:update') {
+      const update = message.data;
+      if (!update) return;
+
+      if (update.type === 'full-reload') {
+        console.log('🔄 Full reload required');
+        location.reload();
+        return;
+      }
+
+      console.log('🔥 Hot updating:', update.path);
+
+      try {
+        let newModule = null;
+        if (update.content) {
+          newModule = await import('/' + update.path + \`?t=\${Date.now()}\`);
+          moduleRegistry.set(update.path, newModule);
+        }
+
+        await hotUpdateSpec(update.path, newModule);
+        console.log('✅ HMR update applied:', update.path);
+      } catch (err) {
+        console.error('❌ HMR update failed:', err);
+        location.reload();
+      }
+    }
+  }
+
+  return {
+    handleMessage,
+    attachFilePathToSuites,
+    detachFilePathSuites,
+    clearCache: (filePath) => {
+      if (filePath) moduleRegistry.delete(filePath);
+      else moduleRegistry.clear();
+    }
+  };
+})();
+`;
+  }
+  getRuntimeHelpersScript() {
+    const stopOnSpecFailure = this.config.jasmineConfig?.env?.stopSpecOnExpectationFailure ?? false;
+    const initialSeed = this.config.jasmineConfig?.env?.seed ?? 0;
+    const initialRandom = this.config.jasmineConfig?.env?.random ?? false;
+    return `
+(function(globalThis) {
+  async function waitForJasmine(maxAttempts = 50, interval = 100) {
+    return new Promise((resolve, reject) => {
+      let attempts = 0;
+      
+      function check() {
+        if (globalThis.jasmine?.getEnv) {
+          resolve(globalThis.jasmine.getEnv());
+        } else if (attempts >= maxAttempts) {
+          reject(new Error('Jasmine environment not found after waiting'));
+        } else {
+          attempts++;
+          setTimeout(check, interval);
+        }
+      }
+      
+      check();
+    });
+  }
+
+  async function init() {
+    let env;
+    try {
+      env = await waitForJasmine();
+      console.log('✅ Jasmine environment found');
+    } catch (error) {
+      console.error('⚠️  Jasmine environment not found:', error.message);
+      return;
+    }
+
+    let random = ${initialRandom};
+    let seed = ${initialSeed};
+
+    env.configure({
+      random,
+      stopOnSpecFailure: ${stopOnSpecFailure},
+      seed,
+      autoCleanClosures: false
+    });
+
+    function isSpec(child) {
+      return child && typeof child.id === 'string' && !child.children;
+    }
+
+    function isSuite(child) {
+      return child && Array.isArray(child.children);
+    }
+
+    function getAllSpecs() {
+      const specs = [];
+      const traverse = suite => {
+        (suite.children || []).forEach(child => {
+          if (isSpec(child)) specs.push(child);
+          if (isSuite(child)) traverse(child);
+        });
+      };
+      traverse(env.topSuite());
+      return specs;
+    }
+
+    function getAllSuites() {
+      const suites = [];
+      const traverse = suite => {
+        suites.push(suite);
+        (suite.children || []).forEach(child => {
+          if (isSuite(child)) traverse(child);
+        });
+      };
+      traverse(env.topSuite());
+      return suites;
+    }
+
+    function getOrderedSpecs(seed, random) {
+      const all = getAllSpecs();
+      if (!random) return all;
+
+      try {
+        const order = new globalThis.jasmine.Order({ random, seed });
+        return order.sort?.(all) ?? all;
+      } catch {
+        return all;
+      }
+    }
+
+    function getOrderedSuites(seed, random) {
+      const all = getAllSuites();
+      if (!random) return all;
+
+      try {
+        const order = new globalThis.jasmine.Order({ random, seed });
+        return order.sort?.(all) ?? all;
+      } catch {
+        return all;
+      }
+    }
+
+    globalThis.jasmine = {
+      ...globalThis.jasmine,
+      getAllSpecs,
+      getAllSuites,
+      getOrderedSpecs,
+      getOrderedSuites
+    };
+
+    let originalSpecFilter = null;
+    let isExecuting = false;
+
+    const inBrowserReporter = {
+      results: [],
+      currentSpecIdSet: null,
+
+      jasmineStarted: function () {
+        this.results = [];
+      },
+
+      specStarted: function (config) {
+        if (this.currentSpecIdSet?.has(config.id)) {
+          console.log(\`▶️ Running [\${config.id}]: \${config.description}\`);
+        }
+      },
+
+      specDone: function (result) {
+        if (this.currentSpecIdSet?.has(result.id)) {
+          this.results.push(result);
+          const status = result.status.toUpperCase();
+          console.log(\`[\${status}] \${result.description}\`);
+          
+          result.failedExpectations?.forEach(f => 
+            console.error('❌', f.message, f.stack ? '\\n' + f.stack : '')
+          );
+        }
+      },
+
+      jasmineDone: () => {
+        if (originalSpecFilter !== null) {
+          env.configure({ specFilter: originalSpecFilter });
+        }
+        isExecuting = false;
+      }
+    };
+
+    env.addReporter(inBrowserReporter);
+
+    function resetEnvironment() {
+      const resetNode = (node) => {
+        if (node.result) {
+          node.result = {
+            status: 'pending',
+            failedExpectations: [],
+            passedExpectations: []
+          };
+        }
+        node.children?.forEach(resetNode);
+      };
+      
+      resetNode(env.topSuite());
+    }
+
+    async function executeSpecsByIds(specIds) {
+      if (isExecuting) {
+        console.warn('⚠️  Execution already in progress. Please wait...');
+        return [];
+      }
+
+      return new Promise((resolve) => {
+        isExecuting = true;
+        inBrowserReporter.results = [];
+        const specIdSet = new Set(specIds);
+        inBrowserReporter.currentSpecIdSet = specIdSet;
+        
+        if (originalSpecFilter === null) {
+          originalSpecFilter = env.specFilter;
+        }
+
+        resetEnvironment();
+
+        env.configure({
+          random,
+          seed,
+          specFilter: (spec) => specIdSet.has(spec.id),
+          autoCleanClosures: false
+        });
+
+        const originalDone = inBrowserReporter.jasmineDone;
+        inBrowserReporter.jasmineDone = () => {
+          originalDone.call(inBrowserReporter);
+          resolve(inBrowserReporter.results);
+          inBrowserReporter.jasmineDone = originalDone;
+        };
+
+        env.execute();
+      });
+    }
+
+    async function runTests(filters) {
+      const allSpecs = getAllSpecs();
+      const filterArr = Array.isArray(filters) ? filters : [filters];
+      const matching = filterArr.length
+        ? allSpecs.filter(s => filterArr.some(f => 
+            f instanceof RegExp ? f.test(s.description) : s.id === f || s.description === f
+          ))
+        : allSpecs;
+
+      if (!matching.length) {
+        console.warn('No matching specs found for:', filters);
+        return [];
+      }
+
+      console.log(\`🎯 Executing \${matching.length} spec(s)\`);
+      return await executeSpecsByIds(matching.map(s => s.id).sort());
+    }
+
+    async function runTest(filter) {
+      if (Array.isArray(filter)) {
+        throw new Error('runTest() only accepts a single spec or RegExp, not an array.');
+      }
+      return runTests(filter);
+    }
+
+    async function runSuite(name) {
+      const suites = getAllSuites();
+      const matching = suites.filter(s => 
+        name instanceof RegExp ? name.test(s.description) : s.description.includes(name)
+      );
+      
+      if (!matching.length) {
+        console.warn('No matching suites found for:', name);
+        return [];
+      }
+
+      const allSpecs = matching.flatMap(suite => {
+        const specs = [];
+        const traverse = s => {
+          (s.children || []).forEach(child => {
+            if (isSpec(child)) specs.push(child);
+            if (isSuite(child)) traverse(child);
+          });
+        };
+        traverse(suite);
+        return specs;
+      });
+
+      console.log(\`🎯 Executing \${allSpecs.length} spec(s) from suite\`);
+      return await executeSpecsByIds(allSpecs.map(s => s.id).sort());
+    }
+
+    function listTests() {
+      const specs = getOrderedSpecs(seed, random);
+      console.table(specs.map(s => ({
+        id: s.id,
+        name: s.description
+      })));
+    }
+
+    function setSeed(nextSeed) {
+      const parsed = Number(nextSeed);
+      if (!Number.isFinite(parsed)) {
+        console.warn('Invalid seed (expected a number).');
+        return seed;
+      }
+      random = true;
+      seed = parsed;
+      env.configure({ random, seed });
+      console.log('✅ Seed updated to:', seed, '| Random enabled:', random);
+      return seed;
+    }
+
+    function resetSeed() {
+      random = false;
+      seed = ${initialSeed};
+      env.configure({ random, seed });
+      console.log('✅ Seed reset to:', seed, '| Random reset to:', random);
+      return seed;
+    }
+
+    globalThis.runner = {
+      runTests,
+      runTest,
+      runSuite,
+      listTests,
+      setSeed,
+      resetSeed,
+      reload: () => location.reload(),
+    };
+
+    console.log('%c✅ Jasmine runner ready!', 'color: green; font-weight: bold;');
+    console.log('Usage:');
+    console.log('  await runner.runTest("spec-name") or await runner.runTest(/pattern/)');
+    console.log('  await runner.runTests(["spec1", "spec2"])');
+    console.log('  await runner.runSuite("Suite Name")');
+    console.log('  runner.setSeed(12345) - Enable random order with seed');
+    console.log('  runner.resetSeed() - Back to sequential order');
+    console.log('  runner.listTests() - Show all tests');
+  }
+
+  init().catch(error => {
+    console.error('Failed to initialize runner:', error);
+  });
+})(window);
+`;
+  }
+}
+class HttpServerManager {
+  constructor(config) {
+    this.config = config;
+  }
+  server = null;
+  async startServer() {
+    const port = this.config.port;
+    const outDir = this.config.outDir;
+    const __filename2 = norm(fileURLToPath(import.meta.url));
+    const __dirname2 = norm(path.dirname(__filename2));
+    const vendorDir = norm(path.join(__dirname2, "../node_modules"));
+    this.server = createServer((req, res) => {
+      let { pathname } = parse(req.url === "/" ? "/index.html" : req.url, true);
+      const filePath = decodeURIComponent(pathname);
+      res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
+      res.setHeader("Pragma", "no-cache");
+      res.setHeader("Expires", "0");
+      if (req.method === "OPTIONS") {
+        res.writeHead(200, {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Methods": "GET, OPTIONS",
+          "Access-Control-Allow-Headers": "Content-Type"
+        });
+        res.end();
+        return;
+      }
+      let resolvedPath;
+      if (filePath.startsWith("/node_modules/")) {
+        const relativePath = filePath.replace(/^\/node_modules\//, "");
+        resolvedPath = norm(path.join(vendorDir, relativePath));
+      } else {
+        resolvedPath = norm(path.join(outDir, filePath));
+      }
+      resolvedPath = norm(path.normalize(resolvedPath));
+      if (fs.existsSync(resolvedPath) && fs.statSync(resolvedPath).isFile()) {
+        const ext = extname(resolvedPath);
+        res.writeHead(200, {
+          "Content-Type": this.getContentType(ext),
+          "Access-Control-Allow-Origin": "*"
+        });
+        res.end(fs.readFileSync(resolvedPath));
+      } else {
+        res.writeHead(404);
+        res.end("Not found");
+      }
+    });
+    return new Promise((resolve, reject) => {
+      this.server.listen(port, () => {
+        logger.println(`🚀 Test server running at http://localhost:${port}`);
+        resolve(this.server);
+      });
+      this.server.on("error", (error) => {
+        logger.error(`❌ Server error: ${error}`);
+        reject(error);
+      });
+    });
+  }
+  getContentType(ext) {
+    const types = {
+      ".html": "text/html",
+      ".js": "application/javascript",
+      ".css": "text/css",
+      ".json": "application/json",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".gif": "image/gif",
+      ".svg": "image/svg+xml",
+      ".ico": "image/x-icon"
+    };
+    return types[ext] || "application/octet-stream";
+  }
+  async waitForServerReady(url, timeout = 5e3) {
+    const start = Date.now();
+    const { hostname, port } = new URL(url);
+    while (Date.now() - start < timeout) {
+      try {
+        await new Promise((resolve, reject) => {
+          const req = http.request({
+            hostname,
+            port,
+            path: "/",
+            method: "HEAD",
+            timeout: 1e3
+          }, (res) => {
+            res.resume();
+            resolve();
+          });
+          req.on("error", reject);
+          req.on("timeout", () => {
+            req.destroy();
+            reject(new Error("Timeout"));
+          });
+          req.end();
+        });
+        return;
+      } catch {
+        await new Promise((r) => setTimeout(r, 100));
+      }
+    }
+    throw new Error(`Server not ready at ${url} after ${timeout}ms`);
+  }
+  async cleanup() {
+    if (this.server) {
+      await new Promise((resolve, reject) => {
+        this.server.close((err) => err ? reject(err) : resolve());
+      });
+      this.server = null;
+    }
+  }
+}
+class CoverageReportGenerator {
+  reportDir;
+  constructor(reportDir = norm(path__default.join(process.cwd(), "coverage"))) {
+    this.reportDir = reportDir;
+  }
+  saveCoverageToFile(coverage) {
+    try {
+      const fs2 = require2("fs");
+      const path2 = require2("path");
+      const outDir = path2.resolve(process.cwd(), ".nyc_output");
+      const outFile = path2.join(outDir, "out.json");
+      if (!fs2.existsSync(outDir)) fs2.mkdirSync(outDir, { recursive: true });
+      fs2.writeFileSync(outFile, JSON.stringify(coverage, null, 2), "utf8");
+      logger.println(`📄 Raw coverage saved to ${outFile}`);
+    } catch (err) {
+      logger.error(`❌ Failed to write coverage file: ${err}`);
+    }
+  }
+  async generate(coverage) {
+    const coverageMap = libCoverage.createCoverageMap(coverage);
+    const remapper = libSourceMaps.createSourceMapStore();
+    const remappedCoverage = await remapper.transformCoverage(coverageMap);
+    const filteredCoverage = libCoverage.createCoverageMap();
+    const filePaths = remappedCoverage.files();
+    for (const filePath of filePaths) {
+      if (!/\.spec\.(ts|tsx|js|jsx|mts|cts|mjs)$/i.test(filePath)) {
+        filteredCoverage.addFileCoverage(remappedCoverage.fileCoverageFor(filePath));
+      }
+    }
+    libReport.createContext({
+      dir: this.reportDir,
+      coverageMap: filteredCoverage
+    });
+    const reporter = libIstanbulApi.createReporter();
+    reporter.dir = this.reportDir;
+    reporter.addAll(["html", "lcov", "text"]);
+    reporter.write(filteredCoverage, true);
+    logger.println(`✅ Coverage reports generated successfully`);
+  }
+}
+class NodeTestRunner {
+  reporter;
+  options;
+  isRunning = false;
+  runnerModule = null;
+  config;
+  constructor(config, options = {}) {
+    this.config = config;
+    this.options = options;
+    this.reporter = options.reporter ?? new ConsoleReporter();
+  }
+  /**
+   * Generate in-process test runner entry file that:
+   * - Bootstraps Jasmine
+   * - Imports compiled spec bundles
+   * - Exposes a stable API: runTests, getOrderedSpecs/Suites, getTestCounts
+   */
+  generateTestRunner() {
+    const outDir = this.config.outDir;
+    if (!fs.existsSync(outDir)) {
+      fs.mkdirSync(outDir, { recursive: true });
+    }
+    const builtFiles = fs.readdirSync(outDir).filter((f) => f.endsWith(".js") && f !== "test-runner.js").sort();
+    if (builtFiles.length === 0) {
+      logger.println("⚠️  No JS files found for test runner generation.");
+      return;
+    }
+    const imports = builtFiles.map((f) => `    await import('./${f}');`).join("\n");
+    const runnerContent = this.generateRunnerTemplate(imports);
+    const testRunnerPath = norm(path.join(outDir, "test-runner.js"));
+    fs.writeFileSync(testRunnerPath, runnerContent);
+    logger.println(
+      `🤖 Generated in-process test runner: ${norm(path.relative(outDir, testRunnerPath))}`
+    );
+  }
+  /**
+   * Template for the generated ESM runner file.
+   * NOTE: This is emitted as JS, so keep syntax JS-friendly.
+   */
+  generateRunnerTemplate(imports) {
+    return `// Auto-generated in-process Jasmine test runner
+import { fileURLToPath, pathToFileURL } from 'url';
+import { dirname, join } from 'path';
+
+// __dirname / __filename for ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const __cwd = process.cwd();
+
+// Jasmine internals
+let jasmineInstance = null;
+let jasmineEnv = null;
+
+// ---------------------------
+// Introspection helpers
+// ---------------------------
+export function getAllSpecs() {
+  const specs = [];
+  const traverse = (suite) => {
+    suite.children?.forEach((child) => {
+      if (child && typeof child.id === 'string' && !child.children) specs.push(child);
+      if (child?.children) traverse(child);
+    });
+  };
+  traverse(jasmineEnv.topSuite());
+  return specs;
+}
+
+export function getAllSuites() {
+  const suites = [];
+  const traverse = (suite) => {
+    suites.push(suite);
+    suite.children?.forEach((child) => {
+      if (child?.children) traverse(child);
+    });
+  };
+  traverse(jasmineEnv.topSuite());
+  return suites;
+}
+
+export function getOrderedSpecs(seed, random) {
+  const all = getAllSpecs();
+  if (!random) return all;
+
+  const OrderCtor = jasmineInstance.Order;
+  try {
+    const order = new OrderCtor({ random, seed });
+    return typeof order.sort === "function" ? order.sort(all) : all;
+  } catch {
+    return all;
+  }
+}
+
+export function getOrderedSuites(seed, random) {
+  const all = getAllSuites();
+  if (!random) return all;
+
+  const OrderCtor = jasmineInstance.Order;
+  try {
+    const order = new OrderCtor({ random, seed });
+    return typeof order.sort === "function" ? order.sort(all) : all;
+  } catch {
+    return all;
+  }
+}
+
+// ---------------------------
+// Main runTests entrypoint
+// ---------------------------
+export async function runTests(reporter) {
+  const envValue = process.env.TS_TEST_RUNNER_SUPPRESS_CONSOLE_LOGS;
+  const shouldSilenceConsole =
+    envValue === '1' || envValue?.toLowerCase() === 'true';
+
+  if (shouldSilenceConsole) {
+    const silentMethods = ['log', 'info', 'debug', 'trace', 'warn', 'table'];
+    for (const method of silentMethods) {
+      if (typeof console[method] === 'function') {
+        console[method] = () => {};
+      }
+    }
+  }
+
+  return new Promise((resolve) => {
+    // Global error handlers
+    process.on('unhandledRejection', (error) => {
+      console.error(\`❌ Unhandled Rejection: \${error}\`);
+      process.exit(1);
+    });
+
+    process.on('uncaughtException', (error) => {
+      console.error(\`❌ Uncaught Exception: \${error}\`);
+      process.exit(1);
+    });
+
+    (async function () {
+      try {
+        // Load jasmine-core from testify's own node_modules
+        const jasmineCorePath = join(
+          __cwd,
+          './node_modules/@epikodelabs/testify/node_modules/jasmine-core/lib/jasmine-core/jasmine.js',
+        );
+
+        const jasmineCore = await import(pathToFileURL(jasmineCorePath).href);
+        const jasmineRequire = jasmineCore.default;
+
+        jasmineInstance = jasmineRequire.core(jasmineRequire);
+        jasmineEnv = jasmineInstance.getEnv();
+
+        const utils = {
+          getAllSpecs,
+          getAllSuites,
+          getOrderedSpecs,
+          getOrderedSuites
+        };
+        
+        // Expose jasmine globals (describe, it, beforeEach, etc.)
+        Object.assign(globalThis, jasmineRequire.interface(jasmineInstance, jasmineEnv));
+        globalThis.jasmine = { ...globalThis.jasmine, ...jasmineInstance, ...utils };
+
+        // Clean shutdown
+        function onExit(signal) {
+          console.log(\`\\n⚙️  Caught \${signal}. Cleaning up...\`);
+          process.exit(0);
+        }
+        process.on('SIGINT', onExit);
+        process.on('SIGTERM', onExit);
+
+        jasmineEnv.clearReporters();
+        jasmineEnv.addReporter(reporter);
+
+${imports}
+        
+        // Configure env from template (inlined from ViteJasmineConfig)
+        const random = ${this.config.jasmineConfig?.env?.random ?? false};
+        const stopOnSpecFailure = ${this.config.jasmineConfig?.env?.stopSpecOnExpectationFailure ?? false};
+        const seed = ${this.config.jasmineConfig?.env?.seed} ?? 0;
+
+        jasmineEnv.configure({
+          random,
+          stopOnSpecFailure,
+          seed
+        });
+
+        // Get ordered specs and suites based on configuration
+        const orderedSpecs = getOrderedSpecs(seed, random).map(spec => ({
+          id: spec.id,
+          description: spec.description,
+          fullName: spec.getFullName ? spec.getFullName() : spec.description
+        }));
+
+        const orderedSuites = getOrderedSuites(seed, random).map(suite => ({
+          id: suite.id,
+          description: suite.description,
+          fullName: suite.getFullName ? suite.getFullName() : suite.description
+        }));
+
+        // Execute tests - this will populate spec results
+        await new Promise((resolve) => setTimeout(() => resolve(), 300));
+        reporter.userAgent(undefined, orderedSuites, orderedSpecs);
+        await jasmineEnv.execute();
+
+        const failures = reporter.failureCount || 0;
+        resolve(failures);
+      } catch (error) {
+        console.error(\`❌ Error during test execution: \${error}\`);
+        console.error(error.stack);
+        resolve(1);
+      }
+    })();
+  });
+}
+
+// ---------------------------
+// CLI entry (backward compat)
+// ---------------------------
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  (async () => {
+    try {
+      const consoleReporterPath = join(__dirname, '../lib/console-reporter.js');
+      const consoleReporterModule = await import(pathToFileURL(consoleReporterPath).href);
+      const ConsoleReporter = consoleReporterModule.ConsoleReporter;
+
+      const failures = await runTests(new ConsoleReporter());
+      process.exit(failures === 0 ? 0 : 1);
+    } catch (error) {
+      console.error(\`❌ Failed to run tests: \${error}\`);
+      process.exit(1);
+    }
+  })();
+}
+`;
+  }
+  /**
+   * Start the test runner in the current (host) process.
+   */
+  async start() {
+    if (this.isRunning) {
+      this.reporter.testsAborted?.("Test process already running");
+      return Promise.reject("Test process already running");
+    }
+    this.isRunning = true;
+    if (this.options.env) {
+      for (const [key, value] of Object.entries(this.options.env)) {
+        if (value == null) delete process.env[key];
+        else process.env[key] = value;
+      }
+    }
+    process.env.NODE_ENV = "test";
+    const shouldSilenceConsole = !!this.options.suppressConsoleLogs;
+    const previousSuppressConsole = process.env.TS_TEST_RUNNER_SUPPRESS_CONSOLE_LOGS;
+    if (shouldSilenceConsole) {
+      process.env.TS_TEST_RUNNER_SUPPRESS_CONSOLE_LOGS = "1";
+    }
+    try {
+      const childFile = path.resolve(
+        this.options.cwd || process.cwd(),
+        this.options.file || path.join(this.config.outDir, "test-runner.js")
+      );
+      logger.println(`🚀 Starting test runner in current process...`);
+      const fileUrl = pathToFileURL(childFile).href;
+      this.runnerModule = await import(fileUrl);
+      if (typeof this.runnerModule.runTests === "function") {
+        const failures = await this.runnerModule.runTests(this.reporter);
+        const coverage = globalThis.__coverage__;
+        if (coverage) {
+          const cov = new CoverageReportGenerator();
+          await cov.generate(coverage);
+        }
+        return failures === 0 ? 0 : 1;
+      } else {
+        logger.error("⚠️  Test runner does not export runTests function");
+        return 1;
+      }
+    } catch (error) {
+      this.reporter.jasmineFailed?.(`Test execution error: ${error.message}`);
+      throw error;
+    } finally {
+      if (shouldSilenceConsole) {
+        if (previousSuppressConsole === void 0) {
+          delete process.env.TS_TEST_RUNNER_SUPPRESS_CONSOLE_LOGS;
+        } else {
+          process.env.TS_TEST_RUNNER_SUPPRESS_CONSOLE_LOGS = previousSuppressConsole;
+        }
+      }
+      this.isRunning = false;
+    }
+  }
+  async stop() {
+    this.isRunning = false;
+  }
+  async restart() {
+    await this.stop();
+    setTimeout(() => this.start(), 300);
+  }
+}
+class ViteConfigBuilder {
+  constructor(config) {
+    this.config = config;
+  }
+  inputMap = {};
+  static DEFAULT_EXCLUDED_DIRS = /* @__PURE__ */ new Set([
+    "node_modules",
+    "dist",
+    "build",
+    ".git",
+    ".vite",
+    ".cache",
+    ".turbo"
+  ]);
+  /* -------------------------------------------------- */
+  /* Helpers                                            */
+  /* -------------------------------------------------- */
+  preserveRoot() {
+    return this.config.viteBuildOptions?.preserveModulesRoot ?? ".";
+  }
+  normalizeDirs(value, fallback) {
+    if (!value) return [fallback];
+    return Array.isArray(value) ? value : [value];
+  }
+  srcDirs() {
+    return this.normalizeDirs(this.config.srcDirs, "./src");
+  }
+  testDirs() {
+    return this.normalizeDirs(this.config.testDirs, "./tests");
+  }
+  shouldSkipDirectory(dirPath) {
+    const name = path.basename(dirPath);
+    if (ViteConfigBuilder.DEFAULT_EXCLUDED_DIRS.has(name)) {
+      return true;
+    }
+    if (this.config.exclude?.some(
+      (p) => minimatch(dirPath, p, { dot: true })
+    )) {
+      return true;
+    }
+    return false;
+  }
+  isValidSourceFile(file, isTest) {
+    const ext = path.extname(file).toLowerCase();
+    if (![".ts", ".js", ".mjs"].includes(ext)) return false;
+    if (file.endsWith(".d.ts")) return false;
+    const isTestFile = /\.spec\.|\.test\./.test(file);
+    return isTest ? isTestFile : !isTestFile;
+  }
+  /* -------------------------------------------------- */
+  /* Synchronous discovery                              */
+  /* -------------------------------------------------- */
+  discoverFilesSync() {
+    const all = [];
+    for (const dir of this.srcDirs()) {
+      if (fs.existsSync(dir)) all.push(...this.walk(dir, false));
+    }
+    for (const dir of this.testDirs()) {
+      if (fs.existsSync(dir)) all.push(...this.walk(dir, true));
+    }
+    return [...new Set(all)];
+  }
+  walk(dir, isTest) {
+    const out = [];
+    for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) {
+        if (this.shouldSkipDirectory(full)) continue;
+        out.push(...this.walk(full, isTest));
+        continue;
+      }
+      if (e.isFile() && this.isValidSourceFile(full, isTest)) {
+        out.push(full);
+      }
+    }
+    return out;
+  }
+  /* -------------------------------------------------- */
+  /* Input map (flattened, collision-safe)              */
+  /* -------------------------------------------------- */
+  buildInputMap(files) {
+    const map = {};
+    for (const file of files) {
+      if (this.isTypeOnlyModule(file)) {
+        continue;
+      }
+      const rel = path.relative(this.preserveRoot(), file).replace(/\.(ts|js|mjs)$/, "");
+      const flatName = Buffer.from(rel).toString("hex");
+      map[flatName] = norm(file);
+    }
+    return map;
+  }
+  isTypeOnlyModule(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (![".ts", ".mts", ".cts"].includes(ext)) return false;
+    if (filePath.endsWith(".d.ts")) return true;
+    let content = "";
+    try {
+      content = fs.readFileSync(filePath, "utf8");
+    } catch {
+      return false;
+    }
+    const stripCommentsAndStrings = (input) => {
+      let out = input.replace(/\/\*[\s\S]*?\*\//g, "");
+      out = out.replace(/\/\/.*$/gm, "");
+      out = out.replace(/(['"`])(?:\\.|(?!\1)[^\\])*\1/g, "");
+      return out;
+    };
+    const code = stripCommentsAndStrings(content);
+    if (/\bexport\s+\*\s+from\b/.test(code)) return false;
+    if (/\bexport\s+default\b/.test(code)) return false;
+    if (/\bexport\s+(const|let|var|function|class|enum)\b/.test(code)) return false;
+    if (/\bimport\s+(?!type\b)/.test(code)) return false;
+    if (/\b(const|let|var|function|class|enum)\b/.test(code)) return false;
+    for (const match of code.matchAll(/export\s*(?:type\s*)?\{([^}]*)\}/g)) {
+      const specList = match[1].split(",").map((s) => s.trim()).filter(Boolean);
+      for (const spec of specList) {
+        const cleaned = spec.replace(/^type\s+/, "").trim();
+        if (cleaned.length > 0 && !spec.startsWith("type ")) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  /* -------------------------------------------------- */
+  /* Vendor chunk logic                                 */
+  /* -------------------------------------------------- */
+  vendorChunk(id) {
+    if (id.includes("node_modules")) return "vendor";
+    return;
+  }
+  /* -------------------------------------------------- */
+  /* Base config factory                                */
+  /* -------------------------------------------------- */
+  baseConfig(input, incremental, viteCache) {
+    const onwarn = (warning, warn) => {
+      if (warning.code === "EMPTY_BUNDLE") return;
+      if (warning.code === "CIRCULAR_DEPENDENCY") return;
+      warn(warning);
+    };
+    return {
+      root: process.cwd(),
+      configFile: incremental ? false : void 0,
+      build: {
+        outDir: this.config.outDir,
+        emptyOutDir: !incremental,
+        sourcemap: true,
+        target: "es2022",
+        minify: false,
+        rollupOptions: {
+          input,
+          cache: viteCache,
+          preserveEntrySignatures: incremental ? "allow-extension" : "strict",
+          // 🔥 Suppress empty bundle warnings
+          onwarn,
+          output: {
+            format: "es",
+            // 🔥 flattened local outputs
+            entryFileNames: "[name].js",
+            // 🔥 single vendor bundle
+            chunkFileNames: "vendor.js",
+            manualChunks: (id) => this.vendorChunk(id)
+          }
+        }
+      },
+      resolve: { alias: this.createPathAliases() },
+      esbuild: {
+        target: "es2022",
+        keepNames: false,
+        treeShaking: true
+        // Enable tree shaking for type imports
+      },
+      define: { "process.env.NODE_ENV": '"test"' },
+      logLevel: "warn"
+    };
+  }
+  /* -------------------------------------------------- */
+  /* FULL BUILD                                         */
+  /* -------------------------------------------------- */
+  createViteConfig(entryFiles) {
+    const files = entryFiles && entryFiles.length > 0 ? entryFiles : this.discoverFilesSync();
+    this.inputMap = this.buildInputMap(files);
+    if (!Object.keys(this.inputMap).length) {
+      logger.error("❌ No files found to build");
+    }
+    return this.mergeUserConfig(this.baseConfig(this.inputMap, false));
+  }
+  /* -------------------------------------------------- */
+  /* INCREMENTAL BUILD                                  */
+  /* -------------------------------------------------- */
+  createViteConfigForFiles(sourceFiles, testFilesOrCache, viteCache) {
+    const testFiles = Array.isArray(testFilesOrCache) ? testFilesOrCache : [];
+    const cache = Array.isArray(testFilesOrCache) ? viteCache : testFilesOrCache;
+    const changedFiles = [...sourceFiles, ...testFiles];
+    const updates = this.buildInputMap(changedFiles);
+    this.inputMap = { ...this.inputMap, ...updates };
+    for (const [k, v] of Object.entries(this.inputMap)) {
+      if (!fs.existsSync(v)) delete this.inputMap[k];
+    }
+    logger.println(
+      `📦 Incremental build: ${Object.keys(this.inputMap).length} files`
+    );
+    return this.mergeUserConfig(
+      this.baseConfig(this.inputMap, true, cache)
+    );
+  }
+  removeFromInputMap(filePath) {
+    const normalized = norm(filePath);
+    for (const [key, value] of Object.entries(this.inputMap)) {
+      if (value === normalized || !fs.existsSync(value)) {
+        delete this.inputMap[key];
+      }
+    }
+  }
+  removeMultipleFromInputMap(filePaths) {
+    const normalizedSet = new Set(filePaths.map(norm));
+    for (const [key, value] of Object.entries(this.inputMap)) {
+      if (normalizedSet.has(value) || !fs.existsSync(value)) {
+        delete this.inputMap[key];
+      }
+    }
+  }
+  /* -------------------------------------------------- */
+  /* Safe user config merge                             */
+  /* -------------------------------------------------- */
+  mergeUserConfig(base) {
+    const user = this.config.viteConfig;
+    if (!user) return base;
+    return {
+      ...base,
+      ...user,
+      build: {
+        ...base.build,
+        ...user.build,
+        rollupOptions: {
+          ...base.build?.rollupOptions,
+          ...user.build?.rollupOptions
+        }
+      }
+    };
+  }
+  /* -------------------------------------------------- */
+  /* tsconfig aliases                                   */
+  /* -------------------------------------------------- */
+  createPathAliases() {
+    const aliases = {};
+    const cleaner = new JSONCleaner();
+    try {
+      const tsconfigPath = this.config.tsconfig ?? "tsconfig.json";
+      if (!fs.existsSync(tsconfigPath)) return aliases;
+      const tsconfig = cleaner.parse(fs.readFileSync(tsconfigPath, "utf8"));
+      const baseUrl = tsconfig.compilerOptions?.baseUrl ?? ".";
+      const paths = tsconfig.compilerOptions?.paths ?? {};
+      for (const [alias, values] of Object.entries(paths)) {
+        if (!Array.isArray(values) || !values.length) continue;
+        aliases[alias.replace(/\/\*$/, "")] = norm(
+          path.resolve(baseUrl, values[0].replace(/\/\*$/, ""))
+        );
+      }
+    } catch (err) {
+      logger.error(`⚠️ tsconfig parse failed: ${err}`);
+    }
+    return aliases;
+  }
+}
+class IstanbulInstrumenter {
+  config;
+  instrumenter;
+  constructor(config) {
+    this.config = config;
+    this.instrumenter = createInstrumenter({
+      coverageVariable: "__coverage__",
+      produceSourceMap: true
+      // generate instrumented map
+    });
+  }
+  async instrument({ filename, source, sourceMap }) {
+    if (!this.config.coverage) return { code: source };
+    if (/\.spec(\.map)?\.js$/i.test(filename)) return { code: source };
+    if (!filename.endsWith(".js")) return { code: source };
+    const instrumentedCode = this.instrumenter.instrumentSync(source, filename, sourceMap);
+    let generatedSourceMap = void 0;
+    if (this.config.coverage && instrumentedCode) ;
+    return {
+      code: instrumentedCode,
+      sourceMap: generatedSourceMap
+    };
+  }
+  /**
+   * Convenience method: read file and instrument it, automatically using existing source map if available
+   */
+  async instrumentFile(filePath) {
+    const source = fs.readFileSync(filePath, "utf-8");
+    const mapFile = filePath + ".map";
+    let sourceMap;
+    if (fs.existsSync(mapFile)) {
+      sourceMap = JSON.parse(fs.readFileSync(mapFile, "utf-8"));
+    }
+    return this.instrument({ filename: filePath, source, sourceMap });
+  }
+}
+class WebSocketManager extends EventEmitter {
+  constructor(fileDiscovery, config, server, reporter) {
+    super();
+    this.fileDiscovery = fileDiscovery;
+    this.config = config;
+    this.server = server;
+    this.reporter = reporter;
+    this.createWebSocketServer();
+  }
+  wss = null;
+  wsClients = [];
+  hmrManager = null;
+  hmrEnabled = false;
+  createWebSocketServer() {
+    this.wss = new WebSocketServer({ server: this.server });
+    this.wss.on("connection", async (ws) => {
+      logger.println("🔌 WebSocket client connected");
+      this.wsClients.push(ws);
+      if (this.hmrEnabled) {
+        const files = await this.fileDiscovery.scanDir(this.config.outDir, "/**/*.js");
+        this.sendToClient(ws, {
+          type: "hmr:connected",
+          specFiles: files.filter((file) => file.endsWith(".spec.js")).map((file) => path__default.basename(file)).sort(),
+          srcFiles: files.filter((file) => !file.endsWith(".spec.js") && file.endsWith(".js")).map((file) => path__default.basename(file)).sort(),
+          enabled: true
+        });
+      }
+      const cleaner = new JSONCleaner();
+      ws.on("message", (data) => {
+        try {
+          const message = cleaner.parse(data.toString());
+          this.handleWebSocketMessage(message);
+        } catch (error) {
+          logger.error(`❌ Failed to parse WebSocket message: ${error}`);
+        }
+      });
+      ws.on("close", () => {
+        this.wsClients = this.wsClients.filter((client) => client !== ws);
+      });
+      ws.on("error", (error) => {
+        logger.error(`❌ WebSocket error: ${error}`);
+        this.wsClients = this.wsClients.filter((client) => client !== ws);
+      });
+    });
+  }
+  handleWebSocketMessage(message) {
+    try {
+      switch (message.type) {
+        case "userAgent":
+          this.reporter?.userAgent?.(message.data, message.data.orderedSuites, message.data.orderedSpecs);
+          break;
+        case "jasmineStarted":
+          this.reporter?.jasmineStarted(message);
+          break;
+        case "suiteStarted":
+          this.reporter?.suiteStarted(message);
+          break;
+        case "specStarted":
+          this.reporter?.specStarted(message);
+          break;
+        case "specDone":
+          this.reporter?.specDone(message);
+          break;
+        case "suiteDone":
+          this.reporter?.suiteDone(message);
+          break;
+        case "jasmineDone":
+          this.reporter?.jasmineDone(message);
+          const coverage = message.coverage ? new JSONCleaner().parse(message.coverage) : null;
+          const success = message.overallStatus === "passed" && message.failedSpecsCount === 0;
+          this.emit("testsCompleted", { success, coverage });
+          break;
+        case "hmr:ready":
+          logger.println("🔥 Client HMR runtime ready");
+          break;
+        case "hmr:error":
+          logger.error(`❌ HMR error on client: ${message.error}`);
+          break;
+        default:
+          logger.println(`⚠️  Unknown WebSocket message type: ${message.type}`);
+      }
+    } catch (error) {
+      logger.error(`❌ Error handling WebSocket message: ${error}`);
+    }
+  }
+  // New method to enable HMR
+  enableHmr(hmrManager) {
+    this.hmrManager = hmrManager;
+    this.hmrEnabled = true;
+    this.hmrManager.on("hmr:update", (update) => {
+      this.broadcast({
+        type: "hmr:update",
+        data: update
+      });
+    });
+    logger.println("🔥 HMR enabled on WebSocket server");
+  }
+  broadcast(message) {
+    const data = JSON.stringify(message);
+    this.wsClients.forEach((client) => {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(data);
+      }
+    });
+  }
+  sendToClient(client, message) {
+    if (client.readyState === WebSocket.OPEN) {
+      client.send(JSON.stringify(message));
+    }
+  }
+  async cleanup() {
+    if (this.hmrManager) {
+      await this.hmrManager.stop();
+      this.hmrManager = null;
+    }
+    if (this.wsClients.length > 0) {
+      for (const client of this.wsClients) {
+        try {
+          if (client.readyState === WebSocket.OPEN) client.close();
+        } catch (err) {
+          logger.error(`❌ Error closing WebSocket client: ${err}`);
+        }
+      }
+      this.wsClients = [];
+    }
+    if (this.wss) {
+      await new Promise((resolve) => this.wss.close(() => resolve()));
+      this.wss = null;
+    }
+  }
+}
+let viteBuild$1 = null;
+async function getViteBuild() {
+  if (!viteBuild$1) {
+    const vite = await import("vite");
+    viteBuild$1 = vite.build;
+  }
+  return viteBuild$1;
+}
+class HmrManager extends EventEmitter {
+  constructor(fileDiscovery, config, viteConfigBuilder, viteCache = null, options) {
+    super();
+    this.fileDiscovery = fileDiscovery;
+    this.config = config;
+    this.viteConfigBuilder = viteConfigBuilder;
+    this.viteCache = viteCache;
+    const srcDir = Array.isArray(config.srcDirs) && config.srcDirs.length > 0 ? config.srcDirs[0] : "./src";
+    const testDir = Array.isArray(config.testDirs) && config.testDirs.length > 0 ? config.testDirs[0] : "./tests";
+    this.primarySrcDir = norm(srcDir);
+    this.primaryTestDir = norm(testDir);
+    this.pathAliases = this.viteConfigBuilder.createPathAliases();
+    if (options?.fileFilter) this.fileFilter = { ...this.fileFilter, ...options.fileFilter };
+    if (options?.rebuildMode) this.rebuildMode = options.rebuildMode;
+    if (options?.sourceChangeStrategy) this.sourceChangeStrategy = options.sourceChangeStrategy;
+    if (options?.criticalSourcePatterns) {
+      this.criticalSourcePatterns = [...this.criticalSourcePatterns, ...options.criticalSourcePatterns];
+    }
+  }
+  watcher = null;
+  isRebuilding = false;
+  rebuildQueue = /* @__PURE__ */ new Set();
+  directChanges = /* @__PURE__ */ new Set();
+  allFiles = [];
+  // ✅ FIX: Add atomic operation queue
+  operationQueue = Promise.resolve();
+  rebuildPromise = null;
+  fileFilter = {
+    include: [],
+    exclude: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/coverage/**"],
+    extensions: [".ts", ".js", ".mjs"]
+  };
+  dependencyGraph = /* @__PURE__ */ new Map();
+  reverseDependencyGraph = /* @__PURE__ */ new Map();
+  pathAliases = {};
+  rebuildMode = "selective";
+  sourceChangeStrategy = "smart";
+  criticalSourcePatterns = [
+    "**/config/**",
+    "**/setup/**",
+    "**/*.config.*",
+    "**/bootstrap.*",
+    "**/main.*",
+    "**/index.*"
+    // root-level index files
+  ];
+  primarySrcDir;
+  primaryTestDir;
+  setFileFilter(filter) {
+    this.fileFilter = { ...this.fileFilter, ...filter };
+    logger.println(`✅ File filter updated: ${this.fileFilter}`);
+  }
+  setRebuildMode(mode) {
+    this.rebuildMode = mode;
+    logger.println(`✅ Rebuild mode set to: ${mode}`);
+  }
+  setSourceChangeStrategy(strategy) {
+    this.sourceChangeStrategy = strategy;
+    logger.println(`✅ Source change strategy set to: ${strategy}`);
+  }
+  matchesFilter(filePath) {
+    const normalizedPath = filePath;
+    if (this.fileFilter.extensions?.length) {
+      const ext = path.extname(normalizedPath);
+      if (!this.fileFilter.extensions.includes(ext)) return false;
+    }
+    if (this.fileFilter.exclude?.length) {
+      if (picomatch.isMatch(normalizedPath, this.fileFilter.exclude)) return false;
+    }
+    if (this.fileFilter.include?.length) {
+      if (!picomatch.isMatch(normalizedPath, this.fileFilter.include)) return false;
+    }
+    return true;
+  }
+  /**
+   * Determines if a file is a test file
+   */
+  isTestFile(filePath) {
+    const normalized = norm(filePath);
+    return normalized.startsWith(this.primaryTestDir);
+  }
+  /**
+   * Determines if a file is a source file
+   */
+  isSourceFile(filePath) {
+    const normalized = norm(filePath);
+    return normalized.startsWith(this.primarySrcDir);
+  }
+  /**
+   * Checks if a source file is critical and requires full reload
+   */
+  isCriticalSourceFile(filePath) {
+    if (!this.isSourceFile(filePath)) return false;
+    const normalized = norm(filePath);
+    return this.criticalSourcePatterns.some(
+      (pattern) => picomatch.isMatch(normalized, pattern)
+    );
+  }
+  /**
+   * Determines the appropriate update strategy based on what changed
+   */
+  determineUpdateStrategy(changedFiles, changeType) {
+    const hasSourceChanges = changedFiles.some((f) => this.isSourceFile(f));
+    const hasTestChanges = changedFiles.some((f) => this.isTestFile(f));
+    const hasCriticalChanges = changedFiles.some((f) => this.isCriticalSourceFile(f));
+    if (!hasSourceChanges && hasTestChanges) {
+      return {
+        type: "test-update",
+        reason: "Test files changed - incremental update"
+      };
+    }
+    if (changeType === "unlink" || changeType === "unlinkDir") {
+      if (hasCriticalChanges) {
+        return {
+          type: "full-reload",
+          reason: "Critical source file/directory removed"
+        };
+      }
+      return {
+        type: "update",
+        reason: "Source file/directory removed - updating dependents"
+      };
+    }
+    if (changeType === "add" || changeType === "addDir") {
+      return {
+        type: "update",
+        reason: "Source file/directory added - building new modules"
+      };
+    }
+    if (hasSourceChanges) {
+      if (this.sourceChangeStrategy === "always-reload") {
+        return {
+          type: "full-reload",
+          reason: "Source changed - always-reload strategy"
+        };
+      }
+      if (this.sourceChangeStrategy === "never-reload") {
+        return {
+          type: "update",
+          reason: "Source changed - never-reload strategy"
+        };
+      }
+      if (hasCriticalChanges) {
+        return {
+          type: "full-reload",
+          reason: "Critical source file changed"
+        };
+      }
+      return {
+        type: "update",
+        reason: "Source changed - incremental update"
+      };
+    }
+    return {
+      type: "update",
+      reason: "General update"
+    };
+  }
+  /**
+   * Rebuilds the dependency graph entry for the given files
+   */
+  async buildDependencyGraph(files) {
+    const existingFiles = files.filter(fs.existsSync);
+    for (const file of existingFiles) {
+      const normalizedFile = norm(file);
+      const oldDeps = this.dependencyGraph.get(normalizedFile);
+      if (oldDeps) {
+        for (const oldDep of oldDeps) {
+          this.reverseDependencyGraph.get(oldDep)?.delete(normalizedFile);
+        }
+      }
+      const newDeps = await this.extractDependencies(file);
+      this.dependencyGraph.set(normalizedFile, newDeps);
+      for (const newDep of newDeps) {
+        if (!this.reverseDependencyGraph.has(newDep)) {
+          this.reverseDependencyGraph.set(newDep, /* @__PURE__ */ new Set());
+        }
+        this.reverseDependencyGraph.get(newDep).add(normalizedFile);
+      }
+    }
+  }
+  async extractDependencies(filePath) {
+    if (!fs.existsSync(filePath)) {
+      return /* @__PURE__ */ new Set();
+    }
+    const deps = /* @__PURE__ */ new Set();
+    try {
+      const content = fs.readFileSync(filePath, "utf-8");
+      const importRegex = /(?:import|export).*?from\s+['"]([^'"]+)['"]/g;
+      const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+      let match;
+      while ((match = importRegex.exec(content)) !== null) {
+        const resolved = this.resolveImport(filePath, match[1]);
+        if (resolved) deps.add(norm(resolved));
+      }
+      while ((match = requireRegex.exec(content)) !== null) {
+        const resolved = this.resolveImport(filePath, match[1]);
+        if (resolved) deps.add(norm(resolved));
+      }
+    } catch (error) {
+      logger.println(`⚠️  Could not extract dependencies from ${filePath}: ${error.message}`);
+    }
+    return deps;
+  }
+  resolveImport(fromFile, importPath) {
+    if (!fs.existsSync(fromFile)) {
+      return null;
+    }
+    if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
+      const aliasResolved = this.resolvePathAlias(importPath);
+      return aliasResolved || null;
+    }
+    const dir = path.dirname(fromFile);
+    let resolved = path.resolve(dir, importPath);
+    const extensions = [...this.fileFilter.extensions, ""];
+    if (fs.existsSync(resolved) && fs.statSync(resolved).isFile()) return resolved;
+    for (const ext of extensions) {
+      const withExt = resolved + ext;
+      if (fs.existsSync(withExt) && fs.statSync(withExt).isFile()) return withExt;
+      const indexFile = path.join(resolved, `index${ext}`);
+      if (fs.existsSync(indexFile) && fs.statSync(indexFile).isFile()) return indexFile;
+    }
+    return null;
+  }
+  resolvePathAlias(importPath) {
+    const extensions = [...this.fileFilter.extensions, ""];
+    for (const [alias, aliasPath] of Object.entries(this.pathAliases)) {
+      if (importPath === alias || importPath.startsWith(alias.replace(/\/\*$/, "") + "/")) {
+        const relativePart = importPath.slice(alias.replace(/\/\*$/, "").length);
+        const resolvedBase = norm(path.join(aliasPath.replace(/\/\*$/, ""), relativePart));
+        for (const ext of extensions) {
+          const withExt = resolvedBase + ext;
+          if (fs.existsSync(withExt) && fs.statSync(withExt).isFile()) return withExt;
+          const indexFile = path.join(resolvedBase, `index${ext}`);
+          if (fs.existsSync(indexFile) && fs.statSync(indexFile).isFile()) return indexFile;
+        }
+      }
+    }
+    return null;
+  }
+  getFilesToRebuild(changedFile) {
+    const filesToRebuild = /* @__PURE__ */ new Set();
+    if (this.rebuildMode === "all") {
+      this.allFiles.filter(fs.existsSync).forEach((f) => filesToRebuild.add(f));
+      return filesToRebuild;
+    }
+    const queue = [norm(changedFile)];
+    const visited = /* @__PURE__ */ new Set();
+    while (queue.length) {
+      const current = queue.shift();
+      if (visited.has(current)) continue;
+      visited.add(current);
+      if (fs.existsSync(current)) {
+        filesToRebuild.add(current);
+      }
+      const dependents = this.reverseDependencyGraph.get(current);
+      if (dependents) {
+        dependents.forEach((d) => {
+          if (fs.existsSync(d)) {
+            queue.push(d);
+          }
+        });
+      }
+    }
+    return filesToRebuild;
+  }
+  /**
+   * Gets all test files affected by a source change
+   */
+  getAffectedTests(sourceFile) {
+    const allDependents = this.getFilesToRebuild(sourceFile);
+    return Array.from(allDependents).filter((f) => this.isTestFile(f) && fs.existsSync(f));
+  }
+  async start() {
+    const watchDirs = [...this.config.srcDirs || [], ...this.config.testDirs || []].filter(Boolean);
+    const watchTargets = watchDirs.length > 0 ? watchDirs : [this.primarySrcDir, this.primaryTestDir];
+    this.initializeTrackedFiles(watchTargets);
+    this.watcher = watch(watchTargets, {
+      ignored: /(^|[\/\\])\../,
+      persistent: true,
+      ignoreInitial: true
+    });
+    this.watcher.on("change", (filePath) => {
+      filePath = norm(filePath);
+      if (this.matchesFilter(filePath)) this.queueRebuild(filePath, "change");
+    });
+    this.watcher.on("add", (filePath) => {
+      filePath = norm(filePath);
+      if (this.matchesFilter(filePath)) this.handleFileAdd(filePath);
+    });
+    this.watcher.on("unlink", (filePath) => {
+      filePath = norm(filePath);
+      if (this.matchesFilter(filePath)) this.handleFileRemove(filePath);
+    });
+    this.watcher.on("addDir", (dirPath) => this.handleDirectoryAdd(norm(dirPath)));
+    this.watcher.on("unlinkDir", (dirPath) => this.handleDirectoryRemove(norm(dirPath)));
+    this.watcher.on("ready", async () => {
+      logger.println(`✅ HMR watching ${this.allFiles.length} files (mode: ${this.rebuildMode}, strategy: ${this.sourceChangeStrategy})`);
+      this.emit("hmr:ready");
+    });
+  }
+  initializeTrackedFiles(watchTargets) {
+    const defaultExtensions = this.fileFilter.extensions.join(",");
+    for (const target of watchTargets) {
+      const normalizedTarget = norm(target);
+      if (!fs.existsSync(normalizedTarget)) continue;
+      const pattern = norm(path.join(normalizedTarget, `**/*{${defaultExtensions}}`));
+      const files = glob.sync(pattern, { absolute: true, ignore: ["**/node_modules/**"] }).filter((f) => this.matchesFilter(norm(f)));
+      for (const file of files) {
+        const normalized = norm(file);
+        if (!this.allFiles.includes(normalized)) {
+          this.allFiles.push(normalized);
+        }
+      }
+    }
+  }
+  async handleFileAdd(filePath) {
+    this.operationQueue = this.operationQueue.then(async () => {
+      filePath = norm(filePath);
+      if (!this.allFiles.includes(filePath)) {
+        this.allFiles.push(filePath);
+        const fileType = this.isTestFile(filePath) ? "test" : this.isSourceFile(filePath) ? "source" : "unknown";
+        const output = norm(this.isTestFile(filePath) ? path.relative(this.primaryTestDir, filePath) : path.relative(this.primarySrcDir, filePath));
+        logger.println(`➕ ${capitalize(fileType)} file added: ${output}`);
+        this.queueRebuild(filePath, "add");
+      }
+    }).catch((error) => {
+      logger.error(`❌ Error in handleFileAdd: ${error}`);
+    });
+    await this.operationQueue;
+  }
+  async handleFileRemove(filePath) {
+    this.operationQueue = this.operationQueue.then(async () => {
+      filePath = norm(filePath);
+      this.viteConfigBuilder.removeFromInputMap(filePath);
+      this.rebuildQueue.delete(filePath);
+      this.directChanges.delete(filePath);
+      const affectedFiles = /* @__PURE__ */ new Set();
+      const dependents = this.reverseDependencyGraph.get(filePath);
+      dependents?.forEach((d) => {
+        if (fs.existsSync(d)) {
+          affectedFiles.add(d);
+        }
+      });
+      this.allFiles = this.allFiles.filter((f) => f !== filePath);
+      this.dependencyGraph.delete(filePath);
+      this.reverseDependencyGraph.delete(filePath);
+      for (const deps of this.dependencyGraph.values()) deps.delete(filePath);
+      for (const dep of this.reverseDependencyGraph.values()) dep.delete(filePath);
+      const fileType = this.isTestFile(filePath) ? "test" : this.isSourceFile(filePath) ? "source" : "unknown";
+      let output = norm(this.isTestFile(filePath) ? path.relative(this.primaryTestDir, filePath) : path.relative(this.primarySrcDir, filePath));
+      logger.println(`➖ ${capitalize(fileType)} file removed: ${output}`);
+      const strategy = this.determineUpdateStrategy([filePath], "unlink");
+      output = norm(path.join(this.config.outDir, this.fileDiscovery.getOutputName(filePath)));
+      if (fs.existsSync(output)) fs.rmSync(output);
+      const map = output.replace(/\.js$/, ".js.map");
+      if (fs.existsSync(map)) fs.rmSync(map);
+      this.emit("hmr:update", {
+        type: strategy.type,
+        path: this.fileDiscovery.getOutputName(filePath),
+        timestamp: Date.now(),
+        affectedTests: this.isSourceFile(filePath) ? Array.from(affectedFiles).filter((f) => this.isTestFile(f)) : void 0,
+        reason: strategy.reason
+      });
+      if (this.rebuildMode === "selective" && affectedFiles.size > 0) {
+        affectedFiles.forEach((f) => this.queueRebuild(f, "change"));
+      }
+    }).catch((error) => {
+      logger.error(`❌ Error in handleFileRemove: ${error}`);
+    });
+    await this.operationQueue;
+  }
+  async handleDirectoryAdd(dirPath) {
+    this.operationQueue = this.operationQueue.then(async () => {
+      dirPath = norm(dirPath);
+      const dirType = dirPath.startsWith(this.primaryTestDir) ? "test" : "source";
+      const output = norm(dirPath.startsWith(this.primaryTestDir) ? path.relative(this.primaryTestDir, dirPath) : path.relative(this.primarySrcDir, dirPath));
+      logger.println(`📁 ${capitalize(dirType)} directory added: ${output}`);
+      const defaultExtensions = this.fileFilter.extensions.join(",");
+      const pattern = norm(path.join(dirPath, `**/*{${defaultExtensions}}`));
+      const newFiles = glob.sync(pattern, { absolute: true, ignore: ["**/node_modules/**"] }).filter((f) => this.matchesFilter(norm(f)));
+      const filesToProcess = [];
+      for (const file of newFiles) {
+        const normalized = norm(file);
+        if (!this.allFiles.includes(normalized)) {
+          this.allFiles.push(normalized);
+          filesToProcess.push(normalized);
+        }
+      }
+      if (filesToProcess.length) {
+        logger.println(`📦 Found ${filesToProcess.length} ${dirType} files in new directory`);
+        const strategy = this.determineUpdateStrategy(filesToProcess, "addDir");
+        this.emit("hmr:update", {
+          type: strategy.type,
+          path: output,
+          timestamp: Date.now(),
+          reason: strategy.reason
+        });
+        filesToProcess.forEach((f) => this.queueRebuild(f, "add"));
+      }
+    }).catch((error) => {
+      logger.error(`❌ Error in handleDirectoryAdd: ${error}`);
+    });
+    await this.operationQueue;
+  }
+  async handleDirectoryRemove(dirPath) {
+    this.operationQueue = this.operationQueue.then(async () => {
+      dirPath = norm(dirPath);
+      const dirType = dirPath.startsWith(this.primaryTestDir) ? "test" : "source";
+      const output = norm(dirPath.startsWith(this.primaryTestDir) ? path.relative(this.primaryTestDir, dirPath) : path.relative(this.primarySrcDir, dirPath));
+      logger.println(`📁 ${capitalize(dirType)} directory removed: ${output}`);
+      const removedFiles = this.allFiles.filter((f) => f.startsWith(dirPath + path.sep) || f === dirPath);
+      const affectedFiles = /* @__PURE__ */ new Set();
+      for (const file of removedFiles) {
+        this.rebuildQueue.delete(file);
+        this.directChanges.delete(file);
+        const dependents = this.reverseDependencyGraph.get(file);
+        dependents?.forEach((d) => {
+          if (fs.existsSync(d)) {
+            affectedFiles.add(d);
+          }
+        });
+        this.dependencyGraph.delete(file);
+        this.reverseDependencyGraph.delete(file);
+        for (const deps of this.dependencyGraph.values()) deps.delete(file);
+        for (const dep of this.reverseDependencyGraph.values()) dep.delete(file);
+      }
+      this.allFiles = this.allFiles.filter((f) => !removedFiles.includes(f));
+      const strategy = this.determineUpdateStrategy(removedFiles, "unlinkDir");
+      this.viteConfigBuilder.removeMultipleFromInputMap(removedFiles);
+      this.emit("hmr:update", {
+        type: strategy.type,
+        path: output,
+        timestamp: Date.now(),
+        affectedTests: Array.from(affectedFiles).filter((f) => this.isTestFile(f)),
+        reason: strategy.reason
+      });
+      if (this.rebuildMode === "selective" && affectedFiles.size > 0) {
+        affectedFiles.forEach((f) => this.queueRebuild(f, "change"));
+      }
+    }).catch((error) => {
+      logger.error(`❌ Error in handleDirectoryRemove: ${error}`);
+    });
+    await this.operationQueue;
+  }
+  async queueRebuild(filePath, changeType = "change") {
+    const normalized = norm(filePath);
+    if (changeType !== "unlink" && !fs.existsSync(normalized)) {
+      logger.println(`⚠️  Skipping rebuild for non-existent file: ${normalized}`);
+      return;
+    }
+    this.directChanges.add(normalized);
+    this.rebuildQueue.add(normalized);
+    if (this.rebuildPromise) {
+      await this.rebuildPromise;
+    }
+    if (!this.isRebuilding) {
+      this.isRebuilding = true;
+      this.rebuildPromise = this.rebuildAll().catch((error) => {
+        logger.error(`❌ Rebuild failed: ${error}`);
+        this.emit(`hmr:error ${error}`);
+      }).finally(() => {
+        this.isRebuilding = false;
+        this.rebuildPromise = null;
+      });
+    }
+    await this.rebuildPromise;
+  }
+  async rebuildAll() {
+    try {
+      while (this.rebuildQueue.size > 0) {
+        const startTime = Date.now();
+        const changedFiles = Array.from(this.rebuildQueue).filter((file) => {
+          if (!fs.existsSync(file)) {
+            logger.println(`⚠️  Skipping deleted file from rebuild queue: ${file}`);
+            return false;
+          }
+          return true;
+        });
+        this.rebuildQueue.clear();
+        const directChangedFiles = Array.from(this.directChanges).filter((file) => {
+          if (!fs.existsSync(file)) {
+            logger.println(`⚠️  Skipping deleted file from direct changes: ${file}`);
+            return false;
+          }
+          return true;
+        });
+        this.directChanges.clear();
+        if (changedFiles.length === 0) {
+          logger.println("⚠️  All queued files were deleted, skipping rebuild");
+          continue;
+        }
+        const filesToRebuild = /* @__PURE__ */ new Set();
+        for (const file of changedFiles) {
+          const deps = this.getFilesToRebuild(file);
+          deps.forEach((f) => {
+            if (fs.existsSync(f)) {
+              filesToRebuild.add(f);
+            }
+          });
+        }
+        const rebuiltFiles = Array.from(filesToRebuild);
+        if (rebuiltFiles.length === 0) {
+          logger.println("⚠️  No valid files to rebuild after filtering");
+          continue;
+        }
+        const validSourceFiles = rebuiltFiles.filter((f) => this.isSourceFile(f) && fs.existsSync(f));
+        const validTestFiles = rebuiltFiles.filter((f) => this.isTestFile(f) && fs.existsSync(f));
+        logger.println(
+          `📦 Changed: ${directChangedFiles.length} files → Rebuilding: ${rebuiltFiles.length} files (${validSourceFiles.length} source, ${validTestFiles.length} test)`
+        );
+        if (validSourceFiles.length === 0 && validTestFiles.length === 0) {
+          logger.println("⚠️  No valid source or test files to build after filtering");
+          continue;
+        }
+        await this.buildDependencyGraph(rebuiltFiles);
+        const viteConfig = this.viteConfigBuilder.createViteConfigForFiles(
+          [...validSourceFiles, ...validTestFiles],
+          this.viteCache
+        );
+        const build = await getViteBuild();
+        const startBuildTime = Date.now();
+        try {
+          const result = await build(viteConfig);
+          this.viteCache = result;
+        } catch (buildError) {
+          logger.error(`❌ Vite build failed: ${buildError}`);
+          if (buildError.code === "UNRESOLVED_ENTRY") {
+            logger.println("🔄 Retrying build with filtered entry points...");
+            const finalSourceFiles = validSourceFiles.filter(fs.existsSync);
+            const finalTestFiles = validTestFiles.filter(fs.existsSync);
+            if (finalSourceFiles.length === 0 && finalTestFiles.length === 0) {
+              logger.println("⚠️  All entry points were deleted, skipping build");
+              continue;
+            }
+            const retryConfig = this.viteConfigBuilder.createViteConfigForFiles(
+              [...finalSourceFiles, ...finalTestFiles],
+              this.viteCache
+            );
+            const result = await build(retryConfig);
+            this.viteCache = result;
+          } else {
+            throw buildError;
+          }
+        }
+        for (const file of rebuiltFiles) {
+          const relative = this.fileDiscovery.getOutputName(file);
+          const outputPath = path.join(this.config.outDir, relative);
+          if (fs.existsSync(outputPath)) {
+            const content = fs.readFileSync(outputPath, "utf-8");
+            const strategy = this.determineUpdateStrategy(directChangedFiles, "change");
+            const affectedTests = directChangedFiles.filter((f) => this.isSourceFile(f)).flatMap((f) => this.getAffectedTests(f));
+            this.emit("hmr:update", {
+              type: strategy.type,
+              path: relative,
+              timestamp: Date.now(),
+              content,
+              affectedTests: affectedTests.length > 0 ? affectedTests : void 0,
+              reason: strategy.reason
+            });
+          }
+        }
+        logger.println(`📦 Vite rebuild completed in ${Date.now() - startBuildTime}ms`);
+        const duration = Date.now() - startTime;
+        const sourceChanges = directChangedFiles.filter((f) => this.isSourceFile(f));
+        const testChanges = directChangedFiles.filter((f) => this.isTestFile(f));
+        const updateType = sourceChanges.length > 0 ? "source-change" : testChanges.length > 0 ? "test-only" : "full";
+        this.emit("hmr:rebuild", {
+          changedFiles: directChangedFiles,
+          rebuiltFiles,
+          duration,
+          timestamp: Date.now(),
+          updateType
+        });
+        logger.println(`✅ Rebuild complete (${updateType}): ${rebuiltFiles.length} files in ${duration}ms`);
+      }
+    } catch (error) {
+      logger.error(`❌ Rebuild failed: ${error}`);
+      this.emit(`hmr:error ${error}`);
+      throw error;
+    }
+  }
+  getDependencyInfo(filePath) {
+    const normalized = norm(filePath);
+    return {
+      dependencies: Array.from(this.dependencyGraph.get(normalized) || []),
+      dependents: Array.from(this.reverseDependencyGraph.get(normalized) || []),
+      isTest: this.isTestFile(normalized),
+      isSource: this.isSourceFile(normalized),
+      isCritical: this.isCriticalSourceFile(normalized),
+      affectedTests: this.isSourceFile(normalized) ? this.getAffectedTests(normalized) : []
+    };
+  }
+  getStats() {
+    const sourceFiles = this.allFiles.filter((f) => this.isSourceFile(f));
+    const testFiles = this.allFiles.filter((f) => this.isTestFile(f));
+    const criticalFiles = sourceFiles.filter((f) => this.isCriticalSourceFile(f));
+    return {
+      totalFiles: this.allFiles.length,
+      sourceFiles: sourceFiles.length,
+      testFiles: testFiles.length,
+      criticalSourceFiles: criticalFiles.length,
+      trackedDependencies: this.dependencyGraph.size,
+      rebuildMode: this.rebuildMode,
+      sourceChangeStrategy: this.sourceChangeStrategy,
+      fileFilter: this.fileFilter,
+      pathAliases: this.pathAliases,
+      criticalPatterns: this.criticalSourcePatterns
+    };
+  }
+  async stop() {
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+      this.dependencyGraph.clear();
+      this.reverseDependencyGraph.clear();
+      logger.println("✅ HMR watcher stopped");
+    }
+  }
+}
+const { build: viteBuild } = await import("vite");
+class ViteJasmineRunner extends EventEmitter {
+  viteCache = null;
+  config;
+  fileDiscovery;
+  viteConfigBuilder;
+  htmlGenerator;
+  browserManager;
+  httpServerManager;
+  nodeTestRunner;
+  webSocketManager = null;
+  consoleReporter;
+  instrumenter;
+  hmrManager = null;
+  completePromise = new Promise((resolve, reject) => {
+    this.completePromiseResolve = resolve;
+  });
+  completePromiseResolve = null;
+  primarySrcDir;
+  primaryTestDir;
+  shouldPreserve() {
+    return !!this.config.preserveOutputs;
+  }
+  constructor(config) {
+    super();
+    const cwd = norm(process.cwd());
+    const normalizedSrcDirs = (Array.isArray(config.srcDirs) ? config.srcDirs : [config.srcDirs ?? "./src"]).filter(Boolean).map(norm);
+    const normalizedTestDirs = (Array.isArray(config.testDirs) ? config.testDirs : [config.testDirs ?? "./tests"]).filter(Boolean).map(norm);
+    this.primarySrcDir = normalizedSrcDirs[0] ?? cwd;
+    this.primaryTestDir = normalizedTestDirs[0] ?? cwd;
+    this.config = {
+      ...config,
+      browser: config.browser ?? "node",
+      port: config.port ?? 8888,
+      headless: config.headless ?? true,
+      watch: config.watch ?? false,
+      srcDirs: normalizedSrcDirs,
+      testDirs: normalizedTestDirs,
+      outDir: norm(config.outDir) ?? norm(path.join(cwd, "dist/.vite-jasmine-build/"))
+    };
+    this.fileDiscovery = new FileDiscoveryService(this.config);
+    this.viteConfigBuilder = new ViteConfigBuilder(this.config);
+    this.htmlGenerator = new HtmlGenerator(this.fileDiscovery, this.config);
+    this.browserManager = new BrowserManager(this.config);
+    this.httpServerManager = new HttpServerManager(this.config);
+    this.instrumenter = new IstanbulInstrumenter(this.config);
+    this.consoleReporter = new ConsoleReporter();
+    this.nodeTestRunner = new NodeTestRunner(this.config, {
+      reporter: this.consoleReporter,
+      cwd: this.config.outDir,
+      file: "test-runner.js",
+      coverage: this.config.coverage,
+      suppressConsoleLogs: this.config.suppressConsoleLogs
+    });
+  }
+  async preprocess() {
+    try {
+      const { srcFiles, specFiles } = await this.fileDiscovery.discoverSources();
+      if (specFiles.length === 0) {
+        throw new Error("No test files found");
+      }
+      const entryFiles = [...srcFiles, ...specFiles];
+      const viteConfig = this.viteConfigBuilder.createViteConfig(entryFiles);
+      const input = {};
+      const entryKeyFromOutput = (file) => this.fileDiscovery.getOutputName(file).replace(/\.js$/, "");
+      for (const file of entryFiles) {
+        input[entryKeyFromOutput(file)] = file;
+      }
+      if (!fs.existsSync(this.config.outDir)) {
+        fs.mkdirSync(this.config.outDir, { recursive: true });
+      }
+      viteConfig.build.rollupOptions.input = input;
+      logger.println(`📦 Building ${Object.keys(input).length} files...`);
+      this.viteCache = await viteBuild(viteConfig);
+      const jsFiles = glob.sync(path.join(this.config.outDir, "**/*.js").replace(/\\/g, "/")).filter((f) => !/\.spec\.js$/i.test(f));
+      for (const jsFile of jsFiles) {
+        const result = await this.instrumenter.instrumentFile(jsFile);
+        const outFile = path.join(this.config.outDir, path.relative(this.config.outDir, jsFile));
+        fs.mkdirSync(path.dirname(outFile), { recursive: true });
+        fs.writeFileSync(outFile, result.code, "utf-8");
+        if (result.sourceMap) {
+          const mapFile = outFile + ".map";
+          fs.writeFileSync(mapFile, JSON.stringify(result.sourceMap, null, 2), "utf-8");
+        }
+      }
+      const htmlPath = path.join(this.config.outDir, "index.html");
+      const preserveHtml = this.shouldPreserve() && fs.existsSync(htmlPath);
+      if (!(this.config.headless && this.config.browser === "node") && !preserveHtml) {
+        if (this.config.watch) {
+          await this.htmlGenerator.generateHtmlFileWithHmr();
+        } else {
+          await this.htmlGenerator.generateHtmlFile();
+        }
+      } else if (preserveHtml) {
+        logger.println("ℹ️  Preserving existing index.html (no regeneration).");
+      }
+      const runnerPath = path.join(this.config.outDir, "test-runner.js");
+      const preserveRunner = this.shouldPreserve() && fs.existsSync(runnerPath);
+      if (this.config.headless && this.config.browser === "node" && !preserveRunner) {
+        this.nodeTestRunner.generateTestRunner();
+      } else if (this.config.headless && this.config.browser === "node" && preserveRunner) {
+        logger.println("ℹ️  Preserving existing test-runner.js (no regeneration).");
+      }
+    } catch (error) {
+      logger.error(`❌ Preprocessing failed: ${error}`);
+      throw error;
+    }
+  }
+  async cleanup() {
+    if (this.hmrManager) {
+      await this.hmrManager.stop();
+      this.hmrManager = null;
+    }
+    if (this.webSocketManager) {
+      await this.webSocketManager.cleanup();
+      this.webSocketManager = null;
+    }
+    await this.httpServerManager.cleanup();
+  }
+  async start() {
+    if (this.config.watch) {
+      return this.watch();
+    }
+    logger.println(
+      `🚀 Starting Jasmine Test ${this.config.headless ? "Runner (Headless)" : "Server"}...`
+    );
+    try {
+      await this.preprocess();
+    } catch (error) {
+      logger.error(`❌ Build failed: ${error}`);
+      process.exit(1);
+    }
+    if (this.config.headless && this.config.browser !== "node") {
+      await this.runHeadlessBrowserMode();
+    } else if (this.config.headless && this.config.browser === "node") {
+      await this.runHeadlessNodeMode();
+    } else if (!this.config.headless && this.config.browser === "node") {
+      logger.error(`❌ Invalid configuration: Node.js runner cannot run in headed mode.`);
+      process.exit(1);
+    } else {
+      await this.runHeadedBrowserMode();
+    }
+  }
+  async watch() {
+    if (this.config.headless || this.config.browser === "node") {
+      logger.error("❌ --watch mode is only supported in headed browser environments.");
+      process.exit(1);
+    }
+    this.config.watch = true;
+    logger.println("👀 Starting Jasmine Tests Runner in Watch Mode...");
+    await this.preprocess();
+    await this.runWatchMode();
+  }
+  async runWatchMode() {
+    logger.println("🔥 Starting HMR file watcher...");
+    const server = await this.httpServerManager.startServer();
+    this.webSocketManager = new WebSocketManager(this.fileDiscovery, this.config, server, this.consoleReporter);
+    this.hmrManager = new HmrManager(this.fileDiscovery, this.config, this.viteConfigBuilder, this.viteCache);
+    this.webSocketManager.enableHmr(this.hmrManager);
+    await this.hmrManager.start();
+    logger.println("📡 WebSocket server ready");
+    logger.println("👌 Press Ctrl+C to stop the server");
+    let shuttingDown = false;
+    const onBrowserClose = async () => {
+      if (shuttingDown) return;
+      logger.println("🔄 Browser window closed");
+      await this.cleanup();
+      process.exit(0);
+    };
+    await this.browserManager.openBrowser(this.config.port, onBrowserClose, { exitOnClose: false });
+    process.once("SIGINT", async () => {
+      if (shuttingDown) return;
+      shuttingDown = true;
+      logger.println("🛑 Stopping HMR server...");
+      await this.browserManager.closeBrowser();
+      logger.println("🔄 Browser window closed");
+      await this.cleanup();
+      process.exit(0);
+    });
+    process.once("SIGTERM", async () => {
+      if (shuttingDown) return;
+      shuttingDown = true;
+      logger.println("🛑 Received SIGTERM, stopping HMR server...");
+      await this.browserManager.closeBrowser();
+      logger.println("🔄 Browser window closed");
+      await this.cleanup();
+      process.exit(0);
+    });
+  }
+  async runHeadlessBrowserMode() {
+    const server = await this.httpServerManager.startServer();
+    await this.httpServerManager.waitForServerReady(`http://localhost:${this.config.port}/index.html`, 1e4);
+    this.webSocketManager = new WebSocketManager(this.fileDiscovery, this.config, server, this.consoleReporter);
+    let testSuccess = false;
+    this.webSocketManager.on("testsCompleted", ({ success, coverage }) => {
+      testSuccess = success;
+      if (this.config.coverage) {
+        const cov = new CoverageReportGenerator();
+        cov.generate(coverage);
+      }
+    });
+    const browserType = await this.browserManager.checkBrowser(this.config.browser);
+    if (!browserType) {
+      logger.println("⚠️  Headless browser not available. Falling back to Node.js runner.");
+      this.nodeTestRunner.generateTestRunner();
+      const exitCode = await this.nodeTestRunner.start();
+      await this.cleanup();
+      process.exit(exitCode);
+    }
+    try {
+      await this.browserManager.runHeadlessBrowserTests(browserType, this.config.port);
+      await this.cleanup();
+      process.exit(testSuccess ? 0 : 1);
+    } catch (error) {
+      logger.error(`❌ Browser test execution failed. Need to install playwright?`);
+      await this.cleanup();
+      process.exit(1);
+    }
+  }
+  async runHeadlessNodeMode() {
+    const exitCode = await this.nodeTestRunner.start();
+    if (this.config.coverage) {
+      const coverage = globalThis.__coverage__;
+      const cov = new CoverageReportGenerator();
+      cov.generate(coverage);
+    }
+    process.exit(exitCode);
+  }
+  async runHeadedBrowserMode() {
+    const server = await this.httpServerManager.startServer();
+    let testsCompleted = false;
+    let testSuccess = false;
+    this.webSocketManager = new WebSocketManager(this.fileDiscovery, this.config, server, this.consoleReporter);
+    logger.println("📡 WebSocket server ready for real-time test reporting");
+    logger.println("👌 Press Ctrl+C to stop the server");
+    const finishHeadedRun = async (coverage) => {
+      if (this.config.coverage) {
+        const cov = new CoverageReportGenerator();
+        await cov.generate(coverage);
+      }
+      await this.browserManager.closeBrowser();
+    };
+    this.webSocketManager.on("testsCompleted", ({ success, coverage }) => {
+      if (testsCompleted) {
+        return;
+      }
+      testsCompleted = true;
+      testSuccess = success;
+      finishHeadedRun(coverage).catch((error) => {
+        logger.error(`❌ Failed to finish headed browser run: ${error}`);
+        process.exit(1);
+      });
+    });
+    const onBrowserClose = async () => {
+      const promise = new Promise((resolve) => {
+        if (!testsCompleted) {
+          setImmediate(() => {
+            logger.clearLine();
+            logger.printRaw("\n");
+            logger.clearLine();
+            this.consoleReporter.testsAborted();
+            logger.clearLine();
+            logger.printRaw("\n");
+            logger.println("🔄 Browser window closed prematurely");
+            resolve();
+          });
+        } else {
+          resolve();
+        }
+      });
+      await promise;
+      await this.cleanup();
+      process.exit(testsCompleted ? testSuccess ? 0 : 1 : 1);
+    };
+    await this.browserManager.openBrowser(this.config.port, onBrowserClose);
+    process.once("SIGINT", async () => {
+      if (!testsCompleted) {
+        setImmediate(() => {
+          logger.clearLine();
+          logger.printRaw("\n");
+          logger.clearLine();
+          this.consoleReporter.testsAborted();
+          logger.clearLine();
+          logger.printRaw("\n");
+          logger.printlnRaw("🛑 Tests aborted by user (Ctrl+C)");
+        });
+      }
+      await this.browserManager.closeBrowser();
+      await this.cleanup();
+      process.exit(testsCompleted ? testSuccess ? 0 : 1 : 1);
+    });
+  }
+}
+function createViteJasmineRunner(config) {
+  return new ViteJasmineRunner(config);
+}
+class CLIHandler {
+  static async run() {
+    const args = process.argv.slice(2);
+    const helpRequested = args.includes("--help") || args.includes("-h");
+    if (helpRequested) {
+      this.printHelp();
+      return;
+    }
+    const initOnly = args.includes("init");
+    const watch2 = args.includes("--watch");
+    const headless = args.includes("--headless");
+    const coverage = args.includes("--coverage");
+    const browserIndex = args.findIndex((a) => a === "--browser");
+    const seedIndex = args.findIndex((a) => a === "--seed");
+    const silentLogs = args.includes("--silent") || args.includes("--quiet");
+    const hasBrowserArg = browserIndex !== -1;
+    let browserName = "chrome";
+    let seedValue;
+    if (seedIndex !== -1) {
+      const raw = args[seedIndex + 1];
+      const parsed = raw !== void 0 ? Number(raw) : NaN;
+      if (!Number.isFinite(parsed)) {
+        logger.error("¢?? Invalid --seed value (expected a number).");
+        process.exit(1);
+      }
+      seedValue = parsed;
+    }
+    if (hasBrowserArg && browserIndex + 1 < args.length) {
+      browserName = args[browserIndex + 1];
+    }
+    const preserveOutputsFlag = args.includes("--preserve");
+    const preserveOutputsArg = preserveOutputsFlag ? true : void 0;
+    if (initOnly) {
+      ConfigManager.initViteJasmineConfig();
+      return;
+    }
+    if (watch2) {
+      const invalidFlags = [];
+      if (headless) invalidFlags.push("--headless");
+      if (coverage) invalidFlags.push("--coverage");
+      if (invalidFlags.length > 0) {
+        logger.error(`❌ The --watch flag cannot be used with: ${invalidFlags.join(", ")}`);
+        process.exit(1);
+      }
+    }
+    try {
+      const normalizeDirConfig = (dirConfig, fallback) => {
+        if (!dirConfig) return [fallback];
+        if (Array.isArray(dirConfig)) {
+          return dirConfig.length > 0 ? dirConfig : [fallback];
+        }
+        return [dirConfig];
+      };
+      let config = ConfigManager.loadViteJasmineBrowserConfig("testify.json");
+      config = {
+        ...config,
+        headless: headless ? true : config.headless || false,
+        coverage: coverage ? true : config.coverage || false,
+        browser: hasBrowserArg ? browserName : config.browser || "chrome",
+        watch: watch2 ? true : config.watch || false,
+        suppressConsoleLogs: silentLogs ? true : config.suppressConsoleLogs,
+        srcDirs: normalizeDirConfig(config.srcDirs, "./src"),
+        testDirs: normalizeDirConfig(config.testDirs, "./tests"),
+        preserveOutputs: preserveOutputsArg ?? !!config.preserveOutputs
+      };
+      if (seedValue !== void 0) {
+        const env = config.jasmineConfig?.env ?? {};
+        config.jasmineConfig = {
+          ...config.jasmineConfig,
+          env: {
+            ...env,
+            seed: seedValue
+          }
+        };
+      }
+      if (config.preserveOutputs) {
+        logger.println(`🛑 Preserve outputs enabled (skip regenerating index.html and test-runner.js when present).`);
+      }
+      const runner = createViteJasmineRunner(config);
+      if (watch2) {
+        await runner.watch();
+      } else {
+        await runner.start();
+      }
+    } catch (error) {
+      logger.error(`❌ Failed to start test runner: ${error}`);
+      process.exit(1);
+    }
+  }
+  static printHelp() {
+    logger.println("testify — run your Jasmine tests across browsers, headless, or Node.js.");
+    logger.println("");
+    logger.println("Usage:");
+    logger.println("  npx testify [options]");
+    logger.println("  npx testify init               # scaffold testify.json");
+    logger.println("");
+    logger.println("Options:");
+    logger.println("  --headless           Run tests in the default Playwright browser without UI");
+    logger.println("  --browser <name>     Target browser (chrome|chromium|firefox|webkit)");
+    logger.println("  --watch              Launch browser mode + HMR for rapid feedback (cannot be headless)");
+    logger.println("  --coverage           Generate Istanbul coverage reports after the run");
+    logger.println("  --seed <number>      Seed used for randomization order");
+    logger.println("  --silent / --quiet    Suppress console logs when running in Node.js mode");
+    logger.println("  --preserve           Skip regenerating index.html and test-runner.js when outputs exist");
+    logger.println("  --help, -h           Show this help message");
+    logger.println("");
+    logger.println("Configuration:");
+    logger.println("  testify.json keeps your src/test dirs, browser, port, coverage, and HTML options.");
+    logger.println("  Use --preserve after the first run if you need to debug manually generated assets.");
+    logger.println("");
+    logger.println("Tip:");
+    logger.println("  npx testify --headless --browser node   # fastest Node.js test execution");
+    logger.println("  npx testify --headless                  # run headless Chrome for browser APIs");
+    logger.println("");
+    logger.println("Playwright Browsers:");
+    logger.println("  npx playwright install                         # install all supported browsers");
+    logger.println("  npx playwright install chromium                # install only Chromium");
+  }
+}
+class CompoundReporter {
+  reporters;
+  constructor(reporters = []) {
+    this.reporters = reporters;
+  }
+  addReporter(reporter) {
+    this.reporters.push(reporter);
+  }
+  userAgent(agentInfo, suites, specs) {
+    this.reporters.forEach((r) => r?.userAgent?.(agentInfo, suites, specs));
+  }
+  jasmineStarted(suiteInfo) {
+    this.reporters.forEach((r) => r.jasmineStarted?.(suiteInfo));
+  }
+  suiteStarted(result) {
+    this.reporters.forEach((r) => r.suiteStarted?.(result));
+  }
+  specStarted(result) {
+    this.reporters.forEach((r) => r.specStarted?.(result));
+  }
+  specDone(result) {
+    this.reporters.forEach((r) => r.specDone?.(result));
+  }
+  suiteDone(result) {
+    this.reporters.forEach((r) => r.suiteDone?.(result));
+  }
+  jasmineDone(result) {
+    this.reporters.forEach((r) => r.jasmineDone?.(result));
+  }
+  testsAborted(message) {
+    this.reporters.forEach((r) => r?.testsAborted?.(message));
+  }
+}
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  CLIHandler.run();
+}
+export {
+  BrowserManager,
+  CLIHandler,
+  CompoundReporter,
+  ConfigManager,
+  ConsoleReporter,
+  FileDiscoveryService,
+  HmrManager,
+  HtmlGenerator,
+  HttpServerManager,
+  IstanbulInstrumenter,
+  Logger,
+  NodeTestRunner,
+  ViteConfigBuilder,
+  ViteJasmineRunner,
+  WebSocketManager,
+  norm
+};