elit 3.6.6 → 3.6.7

package/dist/test-runtime.js

@@ -66,7 +66,7 @@
         initialize: () => initialize,
         stop: () => stop,
         transform: () => transform,
-        transformSync: () => transformSync2,
+        transformSync: () => transformSync3,
         version: () => version
       });
       module.exports = __toCommonJS(node_exports);
@@ -2202,7 +2202,7 @@ More information: The file containing the code for esbuild's JavaScript API (${_
         }));
         return result;
       };
-      var transformSync2 = (input, options) => {
+      var transformSync3 = (input, options) => {
         if (worker_threads && !isInternalWorkerThread) {
           if (!workerThreadService) workerThreadService = startWorkerThreadService(worker_threads);
           return workerThreadService.transformSync(input, options);
@@ -4649,10 +4649,53 @@ error: ${text}`);
     }
   });
 
-  // src/test-runtime.ts
-  var import_esbuild = __toESM(require_main());
+  // src/test/runtime/state.ts
+  function createRootSuite() {
+    return {
+      name: "root",
+      tests: [],
+      suites: [],
+      skip: false,
+      only: false
+    };
+  }
+  var runtimeState = {
+    currentSuite: createRootSuite(),
+    testResults: [],
+    hasOnly: false,
+    coveredFiles: /* @__PURE__ */ new Set(),
+    describePattern: void 0,
+    testPattern: void 0,
+    currentTestFile: void 0,
+    currentSourceMapConsumer: void 0,
+    wrapperLineOffset: 0,
+    beforeAllHooks: [],
+    afterAllHooks: [],
+    beforeEachHooks: [],
+    afterEachHooks: []
+  };
+  function resetSuiteState() {
+    runtimeState.currentSuite = createRootSuite();
+    runtimeState.hasOnly = false;
+  }
+  function resetHookState() {
+    runtimeState.beforeAllHooks = [];
+    runtimeState.afterAllHooks = [];
+    runtimeState.beforeEachHooks = [];
+    runtimeState.afterEachHooks = [];
+  }
+  function resetSourceMapState() {
+    runtimeState.currentSourceMapConsumer = void 0;
+    runtimeState.wrapperLineOffset = 0;
+  }
+  function getCoveredFiles() {
+    return runtimeState.coveredFiles;
+  }
+  function resetCoveredFiles() {
+    runtimeState.coveredFiles.clear();
+  }
 
-  // src/runtime.ts
+  // src/shares/runtime.ts
   var runtime = (() => {
     if (typeof Deno !== "undefined") return "deno";
     if (typeof Bun !== "undefined") return "bun";
@@ -4662,7 +4705,15 @@ error: ${text}`);
   var isBun = runtime === "bun";
   var isDeno = runtime === "deno";
 
-  // src/fs.ts
+  // src/server/fs/node-modules.ts
+  var fs;
+  var fsPromises;
+  if (isNode || isBun) {
+    fs = __require("fs");
+    fsPromises = __require("fs/promises");
+  }
+
+  // src/server/fs/utils.ts
   function parseOptions(options, defaultValue) {
     return typeof options === "string" ? { encoding: options } : options || defaultValue;
   }
@@ -4672,12 +4723,37 @@ error: ${text}`);
     }
     return Buffer.from(content instanceof ArrayBuffer ? new Uint8Array(content) : content);
   }
-  var fs;
-  var fsPromises;
-  if (isNode || isBun) {
-    fs = __require("fs");
-    fsPromises = __require("fs/promises");
+  function createStatsFromDenoFileInfo(info) {
+    return {
+      isFile: () => info.isFile,
+      isDirectory: () => info.isDirectory,
+      isBlockDevice: () => false,
+      isCharacterDevice: () => false,
+      isSymbolicLink: () => info.isSymlink || false,
+      isFIFO: () => false,
+      isSocket: () => false,
+      dev: info.dev || 0,
+      ino: info.ino || 0,
+      mode: info.mode || 0,
+      nlink: info.nlink || 1,
+      uid: info.uid || 0,
+      gid: info.gid || 0,
+      rdev: 0,
+      size: info.size,
+      blksize: info.blksize || 4096,
+      blocks: info.blocks || Math.ceil(info.size / 512),
+      atimeMs: info.atime?.getTime() || Date.now(),
+      mtimeMs: info.mtime?.getTime() || Date.now(),
+      ctimeMs: info.birthtime?.getTime() || Date.now(),
+      birthtimeMs: info.birthtime?.getTime() || Date.now(),
+      atime: info.atime || /* @__PURE__ */ new Date(),
+      mtime: info.mtime || /* @__PURE__ */ new Date(),
+      ctime: info.birthtime || /* @__PURE__ */ new Date(),
+      birthtime: info.birthtime || /* @__PURE__ */ new Date()
+    };
   }
+
+  // src/server/fs/file-ops.ts
   async function readFile(path, options) {
     const opts = parseOptions(options, {});
     if (isNode || isBun) {
@@ -4715,421 +4791,460 @@ error: ${text}`);
     }
     throw new Error("Unsupported runtime");
   }
-  function createStatsFromDenoFileInfo(info) {
-    return {
-      isFile: () => info.isFile,
-      isDirectory: () => info.isDirectory,
-      isBlockDevice: () => false,
-      isCharacterDevice: () => false,
-      isSymbolicLink: () => info.isSymlink || false,
-      isFIFO: () => false,
-      isSocket: () => false,
-      dev: info.dev || 0,
-      ino: info.ino || 0,
-      mode: info.mode || 0,
-      nlink: info.nlink || 1,
-      uid: info.uid || 0,
-      gid: info.gid || 0,
-      rdev: 0,
-      size: info.size,
-      blksize: info.blksize || 4096,
-      blocks: info.blocks || Math.ceil(info.size / 512),
-      atimeMs: info.atime?.getTime() || Date.now(),
-      mtimeMs: info.mtime?.getTime() || Date.now(),
-      ctimeMs: info.birthtime?.getTime() || Date.now(),
-      birthtimeMs: info.birthtime?.getTime() || Date.now(),
-      atime: info.atime || /* @__PURE__ */ new Date(),
-      mtime: info.mtime || /* @__PURE__ */ new Date(),
-      ctime: info.birthtime || /* @__PURE__ */ new Date(),
-      birthtime: info.birthtime || /* @__PURE__ */ new Date()
-    };
-  }
 
-  // src/path.ts
-  function getSeparator(isWin) {
-    return isWin ? "\\" : "/";
-  }
-  function getCwd() {
-    if (isNode || isBun) {
-      return process.cwd();
-    } else if (isDeno) {
-      return Deno.cwd();
-    }
-    return "/";
+  // src/test/runtime/assertion-context.ts
+  function getAssertionMethod(stack) {
+    const assertionMatch = stack.match(/at _?Expect\.(\w+)/);
+    return assertionMatch ? assertionMatch[1] : void 0;
   }
-  function findLastSeparator(path) {
-    return Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
-  }
-  function createPathOps(isWin) {
-    return {
-      sep: getSeparator(isWin),
-      delimiter: isWin ? ";" : ":",
-      normalize: (path) => normalizePath(path, isWin),
-      join: (...paths) => joinPaths(paths, isWin),
-      resolve: (...paths) => resolvePaths(paths, isWin),
-      isAbsolute: (path) => isWin ? isAbsoluteWin(path) : isAbsolutePosix(path),
-      relative: (from, to) => relativePath(from, to, isWin),
-      dirname: (path) => getDirname(path, isWin),
-      basename: (path, ext) => getBasename(path, ext, isWin),
-      extname: (path) => getExtname(path),
-      parse: (path) => parsePath(path, isWin),
-      format: (pathObject) => formatPath(pathObject, isWin)
-    };
+  function getTargetPattern(assertionMethod) {
+    if (assertionMethod === "toEqual") return ".toEqual(";
+    if (assertionMethod === "toStrictEqual") return ".toStrictEqual(";
+    if (assertionMethod === "toMatch") return ".toMatch(";
+    if (assertionMethod === "toContain") return ".toContain(";
+    if (assertionMethod === "toHaveLength") return ".toHaveLength(";
+    if (assertionMethod === "toBeDefined") return ".toBeDefined(";
+    if (assertionMethod === "toBeNull") return ".toBeNull(";
+    if (assertionMethod === "toBeUndefined") return ".toBeUndefined(";
+    if (assertionMethod === "toBeTruthy") return ".toBeTruthy(";
+    if (assertionMethod === "toBeFalsy") return ".toBeFalsy(";
+    if (assertionMethod === "toThrow") return ".toThrow(";
+    if (assertionMethod === "toBeGreaterThan") return ".toBeGreaterThan(";
+    if (assertionMethod === "toBeGreaterThanOrEqual") return ".toBeGreaterThanOrEqual(";
+    if (assertionMethod === "toBeLessThan") return ".toBeLessThan(";
+    if (assertionMethod === "toBeLessThanOrEqual") return ".toBeLessThanOrEqual(";
+    return ".toBe(";
   }
-  function isAbsolutePosix(path) {
-    return path.length > 0 && path[0] === "/";
+  function readSourceLines(filePath) {
+    try {
+      let sourceCode = readFileSync(filePath, "utf-8");
+      if (Buffer.isBuffer(sourceCode)) {
+        sourceCode = sourceCode.toString("utf-8");
+      }
+      return sourceCode.split("\n");
+    } catch {
+      return void 0;
+    }
   }
-  function isAbsoluteWin(path) {
-    const len = path.length;
-    if (len === 0) return false;
-    const code = path.charCodeAt(0);
-    if (code === 47 || code === 92) {
-      return true;
+  function resolveMappedLine(lineNumber, sourceLines, assertionMethod) {
+    const targetPattern = getTargetPattern(assertionMethod);
+    if (lineNumber <= 0 || lineNumber > sourceLines.length) {
+      return lineNumber;
     }
-    if (code >= 65 && code <= 90 || code >= 97 && code <= 122) {
-      if (len > 2 && path.charCodeAt(1) === 58) {
-        const code2 = path.charCodeAt(2);
-        if (code2 === 47 || code2 === 92) {
-          return true;
-        }
+    if (sourceLines[lineNumber - 1].includes(targetPattern)) {
+      return lineNumber;
+    }
+    for (let index = 1; index <= 3; index++) {
+      const searchLine = lineNumber - index;
+      if (searchLine > 0 && searchLine <= sourceLines.length && sourceLines[searchLine - 1].includes(targetPattern)) {
+        return searchLine;
       }
     }
-    return false;
+    return lineNumber;
   }
-  var isWindows = (() => {
-    if (isNode) {
-      return process.platform === "win32";
-    } else if (isDeno) {
-      return Deno.build.os === "windows";
+  function resolveAssertionContext(stack) {
+    if (!stack) {
+      return {};
     }
-    return typeof process !== "undefined" && process.platform === "win32";
-  })();
-  var posix = createPathOps(false);
-  var win32 = createPathOps(true);
-  function normalizePath(path, isWin) {
-    if (path.length === 0) return ".";
-    const separator = getSeparator(isWin);
-    const isAbsolute = isWin ? isAbsoluteWin(path) : isAbsolutePosix(path);
-    const trailingSeparator = path[path.length - 1] === separator || isWin && path[path.length - 1] === "/";
-    let normalized = path.replace(isWin ? /[\/\\]+/g : /\/+/g, separator);
-    const parts = normalized.split(separator);
-    const result = [];
-    for (let i = 0; i < parts.length; i++) {
-      const part = parts[i];
-      if (part === "" || part === ".") {
-        if (i === 0 && isAbsolute) result.push("");
-        continue;
+    const assertionMethod = getAssertionMethod(stack);
+    const stackFrames = [];
+    for (const line of stack.split("\n")) {
+      const match = line.match(/<anonymous>:([0-9]+):([0-9]+)/);
+      if (match) {
+        stackFrames.push({
+          line: parseInt(match[1], 10),
+          column: parseInt(match[2], 10)
+        });
       }
-      if (part === "..") {
-        if (result.length > 0 && result[result.length - 1] !== "..") {
-          if (!(result.length === 1 && result[0] === "")) {
-            result.pop();
+    }
+    const targetFrame = stackFrames.length > 1 ? stackFrames[1] : stackFrames[0];
+    let lineNumber;
+    if (targetFrame && runtimeState.currentSourceMapConsumer) {
+      try {
+        const transpiledLine = targetFrame.line - runtimeState.wrapperLineOffset;
+        const originalPosition = runtimeState.currentSourceMapConsumer.originalPositionFor({
+          line: transpiledLine,
+          column: targetFrame.column
+        });
+        if (originalPosition.line !== null) {
+          lineNumber = originalPosition.line;
+        } else {
+          const posWithoutColumn = runtimeState.currentSourceMapConsumer.originalPositionFor({
+            line: transpiledLine,
+            column: 0
+          });
+          if (posWithoutColumn.line !== null) {
+            lineNumber = posWithoutColumn.line;
+          } else {
+            const lineMappings = [];
+            runtimeState.currentSourceMapConsumer.eachMapping((mapping) => {
+              if (mapping.originalLine !== null) {
+                lineMappings.push({
+                  line: mapping.originalLine,
+                  distance: Math.abs(mapping.generatedLine - transpiledLine)
+                });
+              }
+            });
+            if (lineMappings.length > 0) {
+              lineMappings.sort((left, right) => left.distance - right.distance);
+              lineNumber = lineMappings[0].line;
+            }
           }
-        } else if (!isAbsolute) {
-          result.push("..");
         }
-      } else {
-        result.push(part);
+      } catch {
       }
     }
-    let final = result.join(separator);
-    if (final.length === 0) {
-      return isAbsolute ? separator : ".";
+    if (!runtimeState.currentTestFile || !lineNumber) {
+      return { lineNumber };
     }
-    if (trailingSeparator && final[final.length - 1] !== separator) {
-      final += separator;
+    const sourceLines = readSourceLines(runtimeState.currentTestFile);
+    if (!sourceLines) {
+      return { lineNumber };
     }
-    return final;
+    lineNumber = resolveMappedLine(lineNumber, sourceLines, assertionMethod);
+    const codeLine = lineNumber > 0 && lineNumber <= sourceLines.length ? sourceLines[lineNumber - 1] : void 0;
+    return {
+      lineNumber,
+      codeSnippet: codeLine ? codeLine.trim() : void 0
+    };
   }
-  function joinPaths(paths, isWin) {
-    if (paths.length === 0) return ".";
-    const separator = getSeparator(isWin);
-    let joined = "";
-    for (let i = 0; i < paths.length; i++) {
-      const path = paths[i];
-      if (path && path.length > 0) {
-        if (joined.length === 0) {
-          joined = path;
-        } else {
-          joined += separator + path;
-        }
-      }
+
+  // src/test/runtime/expect.ts
+  var AssertionError = class extends Error {
+    constructor(message, filePath, lineNumber, columnNumber, codeSnippet) {
+      super(message);
+      this.filePath = filePath;
+      this.lineNumber = lineNumber;
+      this.columnNumber = columnNumber;
+      this.codeSnippet = codeSnippet;
+      this.name = "AssertionError";
     }
-    if (joined.length === 0) return ".";
-    return normalizePath(joined, isWin);
-  }
-  function resolvePaths(paths, isWin) {
-    const separator = getSeparator(isWin);
-    let resolved = "";
-    let isAbsolute = false;
-    for (let i = paths.length - 1; i >= 0 && !isAbsolute; i--) {
-      const path = paths[i];
-      if (path && path.length > 0) {
-        resolved = path + (resolved.length > 0 ? separator + resolved : "");
-        isAbsolute = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
-      }
+  };
+  var Expect = class _Expect {
+    constructor(actual, isNot = false, isAsync = false) {
+      this.actual = actual;
+      this.isNot = isNot;
+      this.isAsync = isAsync;
+      this._not = null;
+      this._resolves = null;
+      this._rejects = null;
     }
-    if (!isAbsolute) {
-      const cwd = getCwd();
-      resolved = cwd + (resolved.length > 0 ? separator + resolved : "");
+    get not() {
+      if (!this._not) {
+        this._not = new _Expect(this.actual, !this.isNot, false);
+      }
+      return this._not;
     }
-    return normalizePath(resolved, isWin);
-  }
-  function relativePath(from, to, isWin) {
-    from = resolvePaths([from], isWin);
-    to = resolvePaths([to], isWin);
-    if (from === to) return "";
-    const separator = getSeparator(isWin);
-    const fromParts = from.split(separator).filter((p) => p.length > 0);
-    const toParts = to.split(separator).filter((p) => p.length > 0);
-    let commonLength = 0;
-    const minLength = Math.min(fromParts.length, toParts.length);
-    for (let i = 0; i < minLength; i++) {
-      if (fromParts[i] === toParts[i]) {
-        commonLength++;
-      } else {
-        break;
+    get resolves() {
+      if (!this._resolves) {
+        this._resolves = new _Expect(this.actual, this.isNot, true);
       }
+      return this._resolves;
     }
-    const upCount = fromParts.length - commonLength;
-    const result = [];
-    for (let i = 0; i < upCount; i++) {
-      result.push("..");
+    get rejects() {
+      if (!this._rejects) {
+        this._rejects = new _Expect(this.actual, this.isNot, true);
+      }
+      return this._rejects;
     }
-    for (let i = commonLength; i < toParts.length; i++) {
-      result.push(toParts[i]);
+    assertCondition(condition, message, showExpectedReceived = true, expectedDisplay, callerStack) {
+      if (this.isNot) {
+        condition = !condition;
+      }
+      if (!condition) {
+        let errorMessage = message;
+        if (showExpectedReceived) {
+          const expectedValue = expectedDisplay ?? this.stringify(this.expected ?? "truthy");
+          errorMessage += `
+  Expected: ${expectedValue}
+  Received: ${this.stringify(this.actual)}`;
+        }
+        const stack = callerStack || new Error().stack;
+        const { lineNumber, codeSnippet } = resolveAssertionContext(stack);
+        throw new AssertionError(errorMessage, runtimeState.currentTestFile, lineNumber, void 0, codeSnippet);
+      }
     }
-    return result.join(separator) || ".";
-  }
-  function getDirname(path, isWin) {
-    if (path.length === 0) return ".";
-    const separator = getSeparator(isWin);
-    const normalized = normalizePath(path, isWin);
-    const lastSepIndex = normalized.lastIndexOf(separator);
-    if (lastSepIndex === -1) return ".";
-    if (lastSepIndex === 0) return separator;
-    return normalized.slice(0, lastSepIndex);
-  }
-  function getBasename(path, ext, isWin) {
-    if (path.length === 0) return "";
-    const lastSepIndex = isWin ? findLastSeparator(path) : path.lastIndexOf("/");
-    let base = lastSepIndex === -1 ? path : path.slice(lastSepIndex + 1);
-    if (ext && base.endsWith(ext)) {
-      base = base.slice(0, base.length - ext.length);
-    }
-    return base;
-  }
-  function getExtname(path) {
-    const lastDotIndex = path.lastIndexOf(".");
-    const lastSepIndex = findLastSeparator(path);
-    if (lastDotIndex === -1 || lastDotIndex < lastSepIndex || lastDotIndex === path.length - 1) {
-      return "";
+    stringify(value) {
+      if (value === void 0) return "undefined";
+      if (value === null) return "null";
+      if (typeof value === "string") return `"${value}"`;
+      if (typeof value === "number" || typeof value === "boolean") return String(value);
+      if (typeof value === "function") return "Function";
+      if (Array.isArray(value)) return `[${value.map((item) => this.stringify(item)).join(", ")}]`;
+      if (typeof value === "object") {
+        const keys = Object.keys(value);
+        if (keys.length === 0) return "{}";
+        return `{ ${keys.slice(0, 3).map((key) => `${key}: ${this.stringify(value[key])}`).join(", ")}${keys.length > 3 ? "..." : ""} }`;
+      }
+      return String(value);
     }
-    return path.slice(lastDotIndex);
-  }
-  function parsePath(path, isWin) {
-    let root = "";
-    if (isWin) {
-      if (path.length >= 2 && path[1] === ":") {
-        root = path.slice(0, 2);
-        if (path.length > 2 && (path[2] === "\\" || path[2] === "/")) {
-          root += "\\";
+    async handleAsyncAssertion(value, assertion) {
+      try {
+        const resolvedValue = await this.actual;
+        if (this.isNot) {
+          throw new Error("Promise resolved when it should have rejected");
         }
-      } else if (path[0] === "\\" || path[0] === "/") {
-        root = "\\";
+        assertion(resolvedValue);
+        return Promise.resolve(resolvedValue);
+      } catch (error) {
+        if (this.isNot) {
+          return Promise.resolve(void 0);
+        }
+        if (typeof value === "string") {
+          this.assertCondition(
+            error.message?.includes(value),
+            `Expected error message to include "${value}"`
+          );
+        } else if (value instanceof RegExp) {
+          this.assertCondition(
+            value.test(error.message),
+            `Expected error message to match ${value}`
+          );
+        }
+        return Promise.resolve(void 0);
       }
-    } else {
-      if (path[0] === "/") {
-        root = "/";
+    }
+    toBe(value) {
+      const stack = new Error().stack;
+      if (this.isAsync) {
+        return this.handleAsyncAssertion(value, (actual) => {
+          this.expected = value;
+          this.assertCondition(actual === value, "Expected values to be strictly equal (using ===)", false, void 0, stack);
+          if (typeof actual !== typeof value) {
+            throw new Error(`Types don't match: expected ${typeof value} but got ${typeof actual}`);
+          }
+        });
+      }
+      this.expected = value;
+      this.assertCondition(this.actual === value, "Expected values to be strictly equal (using ===)", true, void 0, stack);
+      if (typeof this.actual !== typeof value) {
+        throw new Error(`Types don't match: expected ${typeof value} but got ${typeof this.actual}`);
       }
     }
-    const dir = getDirname(path, isWin);
-    const base = getBasename(path, void 0, isWin);
-    const ext = getExtname(path);
-    const name = ext ? base.slice(0, base.length - ext.length) : base;
-    return { root, dir, base, ext, name };
-  }
-  function formatPath(pathObject, isWin) {
-    const separator = getSeparator(isWin);
-    const dir = pathObject.dir || pathObject.root || "";
-    const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
-    if (!dir) return base;
-    if (dir === pathObject.root) return dir + base;
-    return dir + separator + base;
-  }
-  function dirname(path) {
-    return getDirname(path, isWindows);
-  }
-
-  // src/test-runtime.ts
-  var import_source_map = __toESM(require_source_map());
-  function escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  }
-  var AssertionError = class extends Error {
-    constructor(message, filePath, lineNumber, columnNumber, codeSnippet) {
-      super(message);
-      this.filePath = filePath;
-      this.lineNumber = lineNumber;
-      this.columnNumber = columnNumber;
-      this.codeSnippet = codeSnippet;
-      this.name = "AssertionError";
+    toEqual(value) {
+      const stack = new Error().stack;
+      this.expected = value;
+      const isEqual = (left, right) => {
+        if (left === right) return true;
+        if (left == null || right == null) return left === right;
+        if (typeof left !== typeof right) return false;
+        if (typeof left !== "object") return left === right;
+        if (Array.isArray(left) !== Array.isArray(right)) return false;
+        if (Array.isArray(left)) {
+          if (left.length !== right.length) return false;
+          return left.every((item, index) => isEqual(item, right[index]));
+        }
+        const keysLeft = Object.keys(left);
+        const keysRight = Object.keys(right);
+        if (keysLeft.length !== keysRight.length) return false;
+        return keysLeft.every((key) => isEqual(left[key], right[key]));
+      };
+      this.assertCondition(isEqual(this.actual, value), "Expected values to be deeply equal", false, void 0, stack);
     }
-  };
-  var currentSuite = {
-    name: "root",
-    tests: [],
-    suites: [],
-    skip: false,
-    only: false
-  };
-  var testResults = [];
-  var hasOnly = false;
-  var coveredFiles = /* @__PURE__ */ new Set();
-  var describePattern = void 0;
-  var testPattern = void 0;
-  var currentTestFile = void 0;
-  var currentSourceMapConsumer = void 0;
-  var wrapperLineOffset = 0;
-  var TEST_MODULE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs", ".json"];
-  function resolveTestLoader(filePath) {
-    return /\.(?:ts|tsx|mts|cts)$/i.test(filePath) ? "ts" : "js";
-  }
-  function createTestTransformOptions(filePath, format, sourcemap) {
-    return {
-      loader: resolveTestLoader(filePath),
-      format,
-      sourcemap,
-      sourcefile: filePath,
-      target: "es2020",
-      tsconfigRaw: {
-        compilerOptions: {
-          jsx: "react",
-          jsxFactory: "h",
-          jsxFragmentFactory: "Fragment"
-        }
-      }
-    };
-  }
-  function resolveExistingTestModulePath(basePath) {
-    const nodePath = __require("path");
-    if (existsSync(basePath) && statSync(basePath).isFile()) {
-      return basePath;
+    toBeTruthy() {
+      this.assertCondition(!!this.actual, "Expected value to be truthy", false, void 0, new Error().stack);
     }
-    for (const extension of TEST_MODULE_EXTENSIONS) {
-      const candidatePath = `${basePath}${extension}`;
-      if (existsSync(candidatePath) && statSync(candidatePath).isFile()) {
-        return candidatePath;
+    toBeFalsy() {
+      this.assertCondition(!this.actual, "Expected value to be falsy", false, void 0, new Error().stack);
+    }
+    toBeNull() {
+      this.assertCondition(this.actual === null, "Expected value to be null", false, void 0, new Error().stack);
+    }
+    toBeUndefined() {
+      this.assertCondition(this.actual === void 0, "Expected value to be undefined", false, void 0, new Error().stack);
+    }
+    toBeDefined() {
+      this.assertCondition(this.actual !== void 0, "Expected value to be defined", false, void 0, new Error().stack);
+    }
+    toBeGreaterThan(value) {
+      const stack = new Error().stack;
+      this.expected = value;
+      this.assertCondition(typeof this.actual === "number" && this.actual > value, `Expected ${this.stringify(this.actual)} to be greater than ${value}`, true, String(value), stack);
+    }
+    toBeGreaterThanOrEqual(value) {
+      const stack = new Error().stack;
+      this.expected = value;
+      this.assertCondition(typeof this.actual === "number" && this.actual >= value, `Expected ${this.stringify(this.actual)} to be greater than or equal to ${value}`, true, `${value}`, stack);
+    }
+    toBeLessThan(value) {
+      const stack = new Error().stack;
+      this.expected = value;
+      this.assertCondition(typeof this.actual === "number" && this.actual < value, `Expected ${this.stringify(this.actual)} to be less than ${value}`, true, String(value), stack);
+    }
+    toBeLessThanOrEqual(value) {
+      const stack = new Error().stack;
+      this.expected = value;
+      this.assertCondition(typeof this.actual === "number" && this.actual <= value, `Expected ${this.stringify(this.actual)} to be less than or equal to ${value}`, true, `${value}`, stack);
+    }
+    toContain(value) {
+      const stack = new Error().stack;
+      this.expected = value;
+      if (typeof this.actual === "string") {
+        this.assertCondition(this.actual.includes(value), `Expected "${this.actual}" to contain "${value}"`, false, void 0, stack);
+      } else if (Array.isArray(this.actual)) {
+        this.assertCondition(this.actual.some((item) => this.deepEqual(item, value)), `Expected array to contain ${this.stringify(value)}`, false, void 0, stack);
+      } else {
+        throw new Error(`toContain expects string or array, got ${typeof this.actual}`);
       }
     }
-    if (existsSync(basePath) && statSync(basePath).isDirectory()) {
-      const packageJsonPath = nodePath.join(basePath, "package.json");
-      if (existsSync(packageJsonPath) && statSync(packageJsonPath).isFile()) {
-        try {
-          const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-          for (const candidateEntry of [packageJson.main, packageJson.module]) {
-            if (typeof candidateEntry !== "string" || candidateEntry.trim().length === 0) {
-              continue;
-            }
-            try {
-              return resolveExistingTestModulePath(nodePath.resolve(basePath, candidateEntry));
-            } catch {
-              continue;
-            }
-          }
-        } catch {
+    toHaveLength(length) {
+      const stack = new Error().stack;
+      this.expected = length;
+      const actualLength = this.actual?.length;
+      this.assertCondition(actualLength === length, `Expected length to be ${length}, but got ${actualLength}`, false, void 0, stack);
+    }
+    toThrow(error) {
+      if (this.isAsync) {
+        return this.handleAsyncAssertion(error, () => {
+        });
+      }
+      let threw = false;
+      let thrownError = null;
+      try {
+        if (typeof this.actual === "function") {
+          this.actual();
         }
+      } catch (caughtError) {
+        threw = true;
+        thrownError = caughtError;
       }
-      for (const extension of TEST_MODULE_EXTENSIONS) {
-        const candidatePath = nodePath.join(basePath, `index${extension}`);
-        if (existsSync(candidatePath) && statSync(candidatePath).isFile()) {
-          return candidatePath;
+      this.assertCondition(threw, "Expected function to throw an error");
+      if (error) {
+        if (typeof error === "string") {
+          this.assertCondition(thrownError.message.includes(error), `Expected error message to include "${error}"`);
+        } else if (error instanceof RegExp) {
+          this.assertCondition(error.test(thrownError.message), `Expected error message to match ${error}`);
         }
       }
     }
-    return basePath;
-  }
-  function resolveTestModulePath(fromFilePath, specifier) {
-    if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
-      return specifier;
-    }
-    const nodePath = __require("path");
-    const basePath = specifier.startsWith(".") ? nodePath.resolve(dirname(fromFilePath), specifier) : specifier;
-    return resolveExistingTestModulePath(basePath);
-  }
-  function shouldTranspileTestModule(filePath) {
-    return /\.(?:ts|tsx|mts|cts|js|jsx|mjs|cjs)$/i.test(filePath);
-  }
-  function createTestModuleRequire(fromFilePath, moduleCache) {
-    return (specifier) => {
-      if (specifier.startsWith("elit/") || specifier === "elit") {
-        return __require(specifier);
-      }
-      const resolvedPath = resolveTestModulePath(fromFilePath, specifier);
-      if (resolvedPath === specifier) {
-        return __require(specifier);
+    toMatch(pattern) {
+      this.expected = pattern;
+      const text = String(this.actual);
+      if (pattern instanceof RegExp) {
+        this.assertCondition(pattern.test(text), `Expected "${text}" to match ${pattern}`);
+      } else {
+        this.assertCondition(text.includes(pattern), `Expected "${text}" to contain "${pattern}"`);
       }
-      if (!existsSync(resolvedPath) || !statSync(resolvedPath).isFile()) {
-        return __require(resolvedPath);
+    }
+    toBeInstanceOf(classType) {
+      this.expected = classType;
+      this.assertCondition(this.actual instanceof classType, `Expected value to be instance of ${classType.name}`);
+    }
+    toHaveProperty(path, value) {
+      const keys = Array.isArray(path) ? path : path.split(".");
+      let object = this.actual;
+      for (const key of keys) {
+        if (object == null || !Object.hasOwnProperty.call(object, key)) {
+          throw new Error(`Expected object to have property "${path}"`);
+        }
+        object = object[key];
       }
-      if (!shouldTranspileTestModule(resolvedPath)) {
-        return __require(resolvedPath);
+      if (value !== void 0) {
+        this.assertCondition(this.deepEqual(object, value), `Expected property "${path}" to equal ${this.stringify(value)}`);
       }
-      return loadTranspiledTestModule(resolvedPath, moduleCache);
-    };
-  }
-  function loadTranspiledTestModule(modulePath, moduleCache) {
-    const cached = moduleCache.get(modulePath);
-    if (cached) {
-      return cached.exports;
     }
-    const source = readFileSync(modulePath, "utf-8");
-    let transpiled;
-    try {
-      transpiled = (0, import_esbuild.transformSync)(source, createTestTransformOptions(modulePath, "cjs", false));
-    } catch (error) {
-      throw new Error(`Failed to transpile test dependency ${modulePath}: ${error instanceof Error ? error.message : String(error)}`);
+    toBeCalled() {
+      this.assertCondition(this.actual._isMock && this.actual._calls.length > 0, "Expected mock function to have been called");
     }
-    const moduleRecord = { exports: {} };
-    const moduleObj = { exports: moduleRecord.exports };
-    moduleCache.set(modulePath, moduleRecord);
-    try {
-      const fn = new Function("module", "exports", "require", "__filename", "__dirname", transpiled.code);
-      const requireFn = createTestModuleRequire(modulePath, moduleCache);
-      fn(moduleObj, moduleObj.exports, requireFn, modulePath, dirname(modulePath));
-    } catch (error) {
-      throw new Error(`Failed to execute test dependency ${modulePath}: ${error instanceof Error ? error.message : String(error)}`);
+    toBeCalledTimes(times) {
+      this.assertCondition(this.actual._isMock && this.actual._calls.length === times, `Expected mock to be called ${times} times, but was called ${this.actual._calls?.length || 0} times`);
     }
-    moduleRecord.exports = moduleObj.exports;
-    if (!modulePath.includes(".test.") && !modulePath.includes(".spec.")) {
-      coveredFiles.add(modulePath);
+    toBeCalledWith(...args) {
+      this.assertCondition(this.actual._isMock && this.actual._calls.some((call) => this.deepEqual(call, args)), `Expected mock to be called with ${this.stringify(args)}`);
     }
-    return moduleRecord.exports;
-  }
-  async function transpileFile(filePath) {
-    const source = await readFile(filePath, "utf-8");
-    const result = (0, import_esbuild.transformSync)(source, createTestTransformOptions(filePath, "esm", "inline"));
-    let sourceMap;
-    const sourceMapMatch = result.code.match(/\/\/# sourceMappingURL=data:application\/json;base64,(.+)/);
-    if (sourceMapMatch) {
-      const base64 = sourceMapMatch[1];
-      const json = Buffer.from(base64, "base64").toString("utf-8");
-      sourceMap = JSON.parse(json);
+    lastReturnedWith(value) {
+      const lastResult = this.actual._results?.[this.actual._results.length - 1];
+      this.assertCondition(lastResult && this.deepEqual(lastResult.value, value), `Expected last call to return ${this.stringify(value)}`);
+    }
+    deepEqual(left, right) {
+      return JSON.stringify(left) === JSON.stringify(right);
     }
-    return { code: result.code, sourceMap };
+  };
+  function expect(actual) {
+    return new Expect(actual);
+  }
+
+  // src/test/runtime/hooks.ts
+  var beforeAll = (fn) => runtimeState.beforeAllHooks.push(fn);
+  var afterAll = (fn) => runtimeState.afterAllHooks.push(fn);
+  var beforeEach = (fn) => runtimeState.beforeEachHooks.push(fn);
+  var afterEach = (fn) => runtimeState.afterEachHooks.push(fn);
+
+  // src/test/runtime/mocks.ts
+  function createMockFunction() {
+    const mock = function(...args) {
+      mock._calls.push(args);
+      try {
+        const result = mock._implementation ? mock._implementation(...args) : void 0;
+        mock._results.push({ type: "return", value: result });
+        return result;
+      } catch (error) {
+        mock._results.push({ type: "throw", value: error });
+        throw error;
+      }
+    };
+    mock._isMock = true;
+    mock._calls = [];
+    mock._results = [];
+    mock._implementation = null;
+    mock.mockImplementation = function(fn) {
+      mock._implementation = fn;
+      return mock;
+    };
+    mock.mockReturnValue = function(value) {
+      mock._implementation = (() => value);
+      return mock;
+    };
+    mock.mockResolvedValue = function(value) {
+      mock._implementation = (() => Promise.resolve(value));
+      return mock;
+    };
+    mock.mockRejectedValue = function(value) {
+      mock._implementation = (() => Promise.reject(value));
+      return mock;
+    };
+    mock.restore = function() {
+      mock._calls = [];
+      mock._results = [];
+      mock._implementation = null;
+    };
+    mock.clear = function() {
+      mock._calls = [];
+      mock._results = [];
+    };
+    return mock;
   }
+  var vi = {
+    fn: () => createMockFunction(),
+    spyOn: (obj, method) => {
+      const original = obj[method];
+      const mock = createMockFunction();
+      mock.mockImplementation(original);
+      obj[method] = mock;
+      mock.restore = () => {
+        obj[method] = original;
+      };
+      return mock;
+    },
+    clearAllMocks: () => {
+    },
+    restoreAllMocks: () => {
+    }
+  };
+
+  // src/test/runtime/test-api.ts
   function createTestFunction(defaultTimeout = 5e3) {
     const testFn = function(name, fn, timeout) {
       const test = {
         name,
         fn,
-        skip: currentSuite.skip,
+        skip: runtimeState.currentSuite.skip,
         only: false,
         todo: false,
         timeout: timeout ?? defaultTimeout,
-        suite: currentSuite
+        suite: runtimeState.currentSuite
       };
-      currentSuite.tests.push(test);
+      runtimeState.currentSuite.tests.push(test);
     };
     testFn.skip = (name, fn, timeout) => {
       const test = {
@@ -5139,12 +5254,12 @@ error: ${text}`);
         only: false,
         todo: false,
         timeout: timeout ?? defaultTimeout,
-        suite: currentSuite
+        suite: runtimeState.currentSuite
       };
-      currentSuite.tests.push(test);
+      runtimeState.currentSuite.tests.push(test);
     };
     testFn.only = (name, fn, timeout) => {
-      hasOnly = true;
+      runtimeState.hasOnly = true;
       const test = {
         name,
         fn,
@@ -5152,9 +5267,9 @@ error: ${text}`);
         only: true,
         todo: false,
         timeout: timeout ?? defaultTimeout,
-        suite: currentSuite
+        suite: runtimeState.currentSuite
       };
-      currentSuite.tests.push(test);
+      runtimeState.currentSuite.tests.push(test);
     };
     testFn.todo = (name, fn, timeout) => {
       const test = {
@@ -5164,15 +5279,15 @@ error: ${text}`);
         only: false,
         todo: true,
         timeout: timeout ?? defaultTimeout,
-        suite: currentSuite
+        suite: runtimeState.currentSuite
       };
-      currentSuite.tests.push(test);
+      runtimeState.currentSuite.tests.push(test);
     };
     return testFn;
   }
   function createDescribeFunction() {
     const describeFn = function(name, fn) {
-      const parent = currentSuite;
+      const parent = runtimeState.currentSuite;
       const suite = {
         name,
         tests: [],
@@ -5182,12 +5297,12 @@ error: ${text}`);
         only: parent.only
       };
       parent.suites.push(suite);
-      currentSuite = suite;
+      runtimeState.currentSuite = suite;
       fn();
-      currentSuite = parent;
+      runtimeState.currentSuite = parent;
     };
     describeFn.skip = (name, fn) => {
-      const parent = currentSuite;
+      const parent = runtimeState.currentSuite;
       const suite = {
         name,
         tests: [],
@@ -5197,13 +5312,13 @@ error: ${text}`);
         only: false
       };
       parent.suites.push(suite);
-      currentSuite = suite;
+      runtimeState.currentSuite = suite;
       fn();
-      currentSuite = parent;
+      runtimeState.currentSuite = parent;
     };
     describeFn.only = (name, fn) => {
-      hasOnly = true;
-      const parent = currentSuite;
+      runtimeState.hasOnly = true;
+      const parent = runtimeState.currentSuite;
       const suite = {
         name,
         tests: [],
@@ -5213,594 +5328,476 @@ error: ${text}`);
         only: true
       };
       parent.suites.push(suite);
-      currentSuite = suite;
+      runtimeState.currentSuite = suite;
       fn();
-      currentSuite = parent;
+      runtimeState.currentSuite = parent;
     };
     return describeFn;
   }
-  var Expect = class _Expect {
-    constructor(actual, isNot = false, isAsync = false) {
-      this.actual = actual;
-      this.isNot = isNot;
-      this.isAsync = isAsync;
-      this._not = null;
-      this._resolves = null;
-      this._rejects = null;
+
+  // src/test/runtime/globals.ts
+  var globals = {
+    describe: createDescribeFunction(),
+    it: createTestFunction(5e3),
+    test: createTestFunction(5e3),
+    expect,
+    beforeAll,
+    afterAll,
+    beforeEach,
+    afterEach,
+    vi
+  };
+  function setupGlobals() {
+    global.describe = globals.describe;
+    global.it = globals.it;
+    global.test = globals.test;
+    global.expect = globals.expect;
+    global.beforeAll = globals.beforeAll;
+    global.afterAll = globals.afterAll;
+    global.beforeEach = globals.beforeEach;
+    global.afterEach = globals.afterEach;
+    global.vi = globals.vi;
+  }
+  function clearGlobals() {
+    delete global.describe;
+    delete global.it;
+    delete global.test;
+    delete global.expect;
+    delete global.beforeAll;
+    delete global.afterAll;
+    delete global.beforeEach;
+    delete global.afterEach;
+    delete global.vi;
+  }
+
+  // src/test/runtime/transpile.ts
+  var import_esbuild = __toESM(require_main());
+
+  // src/server/path/platform.ts
+  function getSeparator(isWin) {
+    return isWin ? "\\" : "/";
+  }
+  function getCwd() {
+    if (isNode || isBun) {
+      return process.cwd();
     }
-    get not() {
-      if (!this._not) {
-        this._not = new _Expect(this.actual, !this.isNot, false);
-      }
-      return this._not;
+    if (isDeno) {
+      return Deno.cwd();
     }
-    get resolves() {
-      if (!this._resolves) {
-        this._resolves = new _Expect(this.actual, this.isNot, true);
-      }
-      return this._resolves;
+    return "/";
+  }
+  var isWindows = (() => {
+    if (isNode) {
+      return process.platform === "win32";
     }
-    get rejects() {
-      if (!this._rejects) {
-        this._rejects = new _Expect(this.actual, this.isNot, true);
+    if (isDeno) {
+      return Deno.build.os === "windows";
+    }
+    return typeof process !== "undefined" && process.platform === "win32";
+  })();
+
+  // src/server/path/operations.ts
+  function findLastSeparator(path) {
+    return Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+  }
+  function isAbsolutePosix(path) {
+    return path.length > 0 && path[0] === "/";
+  }
+  function isAbsoluteWin(path) {
+    const len = path.length;
+    if (len === 0) return false;
+    const code = path.charCodeAt(0);
+    if (code === 47 || code === 92) {
+      return true;
+    }
+    if (code >= 65 && code <= 90 || code >= 97 && code <= 122) {
+      if (len > 2 && path.charCodeAt(1) === 58) {
+        const code2 = path.charCodeAt(2);
+        if (code2 === 47 || code2 === 92) {
+          return true;
+        }
       }
-      return this._rejects;
     }
-    assertCondition(condition, message, showExpectedReceived = true, expectedDisplay, callerStack) {
-      if (this.isNot) {
-        condition = !condition;
+    return false;
+  }
+  function normalizePath(path, isWin) {
+    if (path.length === 0) return ".";
+    const separator = getSeparator(isWin);
+    const isAbsolute = isWin ? isAbsoluteWin(path) : isAbsolutePosix(path);
+    const trailingSeparator = path[path.length - 1] === separator || isWin && path[path.length - 1] === "/";
+    const normalized = path.replace(isWin ? /[\/\\]+/g : /\/+/g, separator);
+    const parts = normalized.split(separator);
+    const result = [];
+    for (let index = 0; index < parts.length; index++) {
+      const part = parts[index];
+      if (part === "" || part === ".") {
+        if (index === 0 && isAbsolute) result.push("");
+        continue;
       }
-      if (!condition) {
-        let errorMsg = message;
-        if (showExpectedReceived) {
-          const expectedValue = expectedDisplay ?? this.stringify(this.expected ?? "truthy");
-          errorMsg += `
-  Expected: ${expectedValue}
-  Received: ${this.stringify(this.actual)}`;
-        }
-        const stack = callerStack || new Error().stack;
-        let lineNumber = void 0;
-        let codeSnippet = void 0;
-        let assertionMethod = void 0;
-        if (stack) {
-          const assertionMatch = stack.match(/at _Expect\.(\w+)/);
-          if (assertionMatch) {
-            assertionMethod = assertionMatch[1];
-          }
-        }
-        if (stack) {
-          const lines = stack.split("\n");
-          const stackFrames = [];
-          for (const line of lines) {
-            const match = line.match(/<anonymous>:([0-9]+):([0-9]+)/);
-            if (match) {
-              stackFrames.push({
-                line: parseInt(match[1], 10),
-                column: parseInt(match[2], 10)
-              });
-            }
-          }
-          const targetFrame = stackFrames.length > 1 ? stackFrames[1] : stackFrames[0];
-          if (targetFrame && currentSourceMapConsumer) {
-            try {
-              const transpiledLine = targetFrame.line - wrapperLineOffset;
-              const originalPosition = currentSourceMapConsumer.originalPositionFor({
-                line: transpiledLine,
-                column: targetFrame.column
-              });
-              if (originalPosition.line !== null) {
-                lineNumber = originalPosition.line;
-                if (currentTestFile) {
-                  try {
-                    let sourceCode = readFileSync(currentTestFile, "utf-8");
-                    if (Buffer.isBuffer(sourceCode)) {
-                      sourceCode = sourceCode.toString("utf-8");
-                    }
-                    const sourceLines = sourceCode.split("\n");
-                    let targetPattern = ".toBe(";
-                    if (assertionMethod === "toEqual") targetPattern = ".toEqual(";
-                    else if (assertionMethod === "toStrictEqual") targetPattern = ".toStrictEqual(";
-                    else if (assertionMethod === "toMatch") targetPattern = ".toMatch(";
-                    else if (assertionMethod === "toContain") targetPattern = ".toContain(";
-                    else if (assertionMethod === "toHaveLength") targetPattern = ".toHaveLength(";
-                    else if (assertionMethod === "toBeDefined") targetPattern = ".toBeDefined(";
-                    else if (assertionMethod === "toBeNull") targetPattern = ".toBeNull(";
-                    else if (assertionMethod === "toBeUndefined") targetPattern = ".toBeUndefined(";
-                    else if (assertionMethod === "toBeTruthy") targetPattern = ".toBeTruthy(";
-                    else if (assertionMethod === "toBeFalsy") targetPattern = ".toBeFalsy(";
-                    else if (assertionMethod === "toThrow") targetPattern = ".toThrow(";
-                    else if (assertionMethod === "toBeGreaterThan") targetPattern = ".toBeGreaterThan(";
-                    else if (assertionMethod === "toBeGreaterThanOrEqual") targetPattern = ".toBeGreaterThanOrEqual(";
-                    else if (assertionMethod === "toBeLessThan") targetPattern = ".toBeLessThan(";
-                    else if (assertionMethod === "toBeLessThanOrEqual") targetPattern = ".toBeLessThanOrEqual(";
-                    if (lineNumber > 0 && lineNumber <= sourceLines.length) {
-                      const mappedLine = sourceLines[lineNumber - 1];
-                      const hasMatchingAssertion = mappedLine.includes(targetPattern);
-                      if (!hasMatchingAssertion) {
-                        for (let i = 1; i <= 3; i++) {
-                          const searchLine = lineNumber - i;
-                          if (searchLine > 0 && searchLine <= sourceLines.length) {
-                            const testLine = sourceLines[searchLine - 1];
-                            if (testLine.includes(targetPattern)) {
-                              lineNumber = searchLine;
-                              break;
-                            }
-                          }
-                        }
-                      }
-                    }
-                  } catch (e) {
-                  }
-                }
-              } else {
-                const posWithoutColumn = currentSourceMapConsumer.originalPositionFor({
-                  line: transpiledLine,
-                  column: 0
-                });
-                if (posWithoutColumn.line !== null) {
-                  lineNumber = posWithoutColumn.line;
-                } else {
-                  const lineMappings = [];
-                  currentSourceMapConsumer.eachMapping((mapping) => {
-                    if (mapping.originalLine !== null) {
-                      const distance = Math.abs(mapping.generatedLine - transpiledLine);
-                      lineMappings.push({
-                        line: mapping.originalLine,
-                        distance
-                      });
-                    }
-                  });
-                  if (lineMappings.length > 0) {
-                    lineMappings.sort((a, b) => a.distance - b.distance);
-                    lineNumber = lineMappings[0].line;
-                  }
-                }
-              }
-            } catch (e) {
-            }
-          }
-          if (currentTestFile && lineNumber) {
-            try {
-              let sourceCode = readFileSync(currentTestFile, "utf-8");
-              if (Buffer.isBuffer(sourceCode)) {
-                sourceCode = sourceCode.toString("utf-8");
-              }
-              const sourceLines = sourceCode.split("\n");
-              if (lineNumber > 0 && lineNumber <= sourceLines.length) {
-                const codeLine = sourceLines[lineNumber - 1];
-                if (codeLine) {
-                  codeSnippet = codeLine.trim();
-                }
-              }
-            } catch (e) {
-            }
+      if (part === "..") {
+        if (result.length > 0 && result[result.length - 1] !== "..") {
+          if (!(result.length === 1 && result[0] === "")) {
+            result.pop();
           }
+        } else if (!isAbsolute) {
+          result.push("..");
         }
-        throw new AssertionError(errorMsg, currentTestFile, lineNumber, void 0, codeSnippet);
+      } else {
+        result.push(part);
       }
     }
-    stringify(value) {
-      if (value === void 0) return "undefined";
-      if (value === null) return "null";
-      if (typeof value === "string") return `"${value}"`;
-      if (typeof value === "number" || typeof value === "boolean") return String(value);
-      if (typeof value === "function") return "Function";
-      if (Array.isArray(value)) return `[${value.map((v) => this.stringify(v)).join(", ")}]`;
-      if (typeof value === "object") {
-        const keys = Object.keys(value);
-        if (keys.length === 0) return "{}";
-        return `{ ${keys.slice(0, 3).map((k) => `${k}: ${this.stringify(value[k])}`).join(", ")}${keys.length > 3 ? "..." : ""} }`;
-      }
-      return String(value);
+    let finalPath = result.join(separator);
+    if (finalPath.length === 0) {
+      return isAbsolute ? separator : ".";
     }
-    async handleAsyncAssertion(value, assertion) {
-      try {
-        const resolvedValue = await this.actual;
-        if (this.isNot) {
-          throw new Error(`Promise resolved when it should have rejected`);
-        }
-        assertion(resolvedValue);
-        return Promise.resolve(resolvedValue);
-      } catch (error) {
-        if (this.isNot) {
-          return Promise.resolve(void 0);
-        }
-        if (typeof value === "string") {
-          this.assertCondition(
-            error.message?.includes(value),
-            `Expected error message to include "${value}"`
-          );
-        } else if (value instanceof RegExp) {
-          this.assertCondition(
-            value.test(error.message),
-            `Expected error message to match ${value}`
-          );
+    if (trailingSeparator && finalPath[finalPath.length - 1] !== separator) {
+      finalPath += separator;
+    }
+    return finalPath;
+  }
+  function joinPaths(paths, isWin) {
+    if (paths.length === 0) return ".";
+    const separator = getSeparator(isWin);
+    let joined = "";
+    for (let index = 0; index < paths.length; index++) {
+      const path = paths[index];
+      if (path && path.length > 0) {
+        if (joined.length === 0) {
+          joined = path;
+        } else {
+          joined += separator + path;
         }
-        return Promise.resolve(void 0);
       }
     }
-    toBe(value) {
-      const stack = new Error().stack;
-      if (this.isAsync) {
-        return this.handleAsyncAssertion(value, (actual) => {
-          this.expected = value;
-          this.assertCondition(actual === value, `Expected values to be strictly equal (using ===)`, false, void 0, stack);
-          if (typeof actual !== typeof value) {
-            throw new Error(`Types don't match: expected ${typeof value} but got ${typeof actual}`);
-          }
-        });
-      }
-      this.expected = value;
-      this.assertCondition(this.actual === value, `Expected values to be strictly equal (using ===)`, true, void 0, stack);
-      if (typeof this.actual !== typeof value) {
-        throw new Error(`Types don't match: expected ${typeof value} but got ${typeof this.actual}`);
+    if (joined.length === 0) return ".";
+    return normalizePath(joined, isWin);
+  }
+  function resolvePaths(paths, isWin) {
+    const separator = getSeparator(isWin);
+    let resolved = "";
+    let absolute = false;
+    for (let index = paths.length - 1; index >= 0 && !absolute; index--) {
+      const path = paths[index];
+      if (path && path.length > 0) {
+        resolved = path + (resolved.length > 0 ? separator + resolved : "");
+        absolute = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
       }
     }
-    toEqual(value) {
-      const stack = new Error().stack;
-      this.expected = value;
-      const isEqual = (a, b) => {
-        if (a === b) return true;
-        if (a == null || b == null) return a === b;
-        if (typeof a !== typeof b) return false;
-        if (typeof a !== "object") return a === b;
-        if (Array.isArray(a) !== Array.isArray(b)) return false;
-        if (Array.isArray(a)) {
-          if (a.length !== b.length) return false;
-          return a.every((item, i) => isEqual(item, b[i]));
-        }
-        const keysA = Object.keys(a);
-        const keysB = Object.keys(b);
-        if (keysA.length !== keysB.length) return false;
-        return keysA.every((key) => isEqual(a[key], b[key]));
-      };
-      this.assertCondition(isEqual(this.actual, value), "Expected values to be deeply equal", false, void 0, stack);
-    }
-    toBeTruthy() {
-      const stack = new Error().stack;
-      this.assertCondition(!!this.actual, `Expected value to be truthy`, false, void 0, stack);
-    }
-    toBeFalsy() {
-      const stack = new Error().stack;
-      this.assertCondition(!this.actual, `Expected value to be falsy`, false, void 0, stack);
-    }
-    toBeNull() {
-      const stack = new Error().stack;
-      this.assertCondition(this.actual === null, `Expected value to be null`, false, void 0, stack);
+    if (!absolute) {
+      const cwd = getCwd();
+      resolved = cwd + (resolved.length > 0 ? separator + resolved : "");
     }
-    toBeUndefined() {
-      const stack = new Error().stack;
-      this.assertCondition(this.actual === void 0, `Expected value to be undefined`, false, void 0, stack);
+    return normalizePath(resolved, isWin);
+  }
+  function relativePath(from, to, isWin) {
+    const resolvedFrom = resolvePaths([from], isWin);
+    const resolvedTo = resolvePaths([to], isWin);
+    if (resolvedFrom === resolvedTo) return "";
+    const separator = getSeparator(isWin);
+    const fromParts = resolvedFrom.split(separator).filter((part) => part.length > 0);
+    const toParts = resolvedTo.split(separator).filter((part) => part.length > 0);
+    const minLength = Math.min(fromParts.length, toParts.length);
+    let commonLength = 0;
+    for (let index = 0; index < minLength; index++) {
+      if (fromParts[index] === toParts[index]) {
+        commonLength++;
+      } else {
+        break;
+      }
     }
-    toBeDefined() {
-      const stack = new Error().stack;
-      this.assertCondition(this.actual !== void 0, `Expected value to be defined`, false, void 0, stack);
+    const result = [];
+    const upCount = fromParts.length - commonLength;
+    for (let index = 0; index < upCount; index++) {
+      result.push("..");
     }
-    toBeGreaterThan(value) {
-      const stack = new Error().stack;
-      this.expected = value;
-      this.assertCondition(
-        typeof this.actual === "number" && this.actual > value,
-        `Expected ${this.stringify(this.actual)} to be greater than ${value}`,
-        true,
-        String(value),
-        stack
-      );
+    for (let index = commonLength; index < toParts.length; index++) {
+      result.push(toParts[index]);
     }
-    toBeGreaterThanOrEqual(value) {
-      const stack = new Error().stack;
-      this.expected = value;
-      this.assertCondition(
-        typeof this.actual === "number" && this.actual >= value,
-        `Expected ${this.stringify(this.actual)} to be greater than or equal to ${value}`,
-        true,
-        `${value}`,
-        stack
-      );
+    return result.join(separator) || ".";
+  }
+  function getDirname(path, isWin) {
+    if (path.length === 0) return ".";
+    const separator = getSeparator(isWin);
+    const normalized = normalizePath(path, isWin);
+    const lastSeparatorIndex = normalized.lastIndexOf(separator);
+    if (lastSeparatorIndex === -1) return ".";
+    if (lastSeparatorIndex === 0) return separator;
+    return normalized.slice(0, lastSeparatorIndex);
+  }
+  function getBasename(path, ext, isWin) {
+    if (path.length === 0) return "";
+    const lastSeparatorIndex = isWin ? findLastSeparator(path) : path.lastIndexOf("/");
+    let base = lastSeparatorIndex === -1 ? path : path.slice(lastSeparatorIndex + 1);
+    if (ext && base.endsWith(ext)) {
+      base = base.slice(0, base.length - ext.length);
     }
-    toBeLessThan(value) {
-      const stack = new Error().stack;
-      this.expected = value;
-      this.assertCondition(
-        typeof this.actual === "number" && this.actual < value,
-        `Expected ${this.stringify(this.actual)} to be less than ${value}`,
-        true,
-        String(value),
-        stack
-      );
+    return base;
+  }
+  function getExtname(path) {
+    const lastDotIndex = path.lastIndexOf(".");
+    const lastSeparatorIndex = findLastSeparator(path);
+    if (lastDotIndex === -1 || lastDotIndex < lastSeparatorIndex || lastDotIndex === path.length - 1) {
+      return "";
     }
-    toBeLessThanOrEqual(value) {
-      const stack = new Error().stack;
-      this.expected = value;
-      this.assertCondition(
-        typeof this.actual === "number" && this.actual <= value,
-        `Expected ${this.stringify(this.actual)} to be less than or equal to ${value}`,
-        true,
-        `${value}`,
-        stack
-      );
+    return path.slice(lastDotIndex);
+  }
+  function parsePath(path, isWin) {
+    let root = "";
+    if (isWin) {
+      if (path.length >= 2 && path[1] === ":") {
+        root = path.slice(0, 2);
+        if (path.length > 2 && (path[2] === "\\" || path[2] === "/")) {
+          root += "\\";
+        }
+      } else if (path[0] === "\\" || path[0] === "/") {
+        root = "\\";
+      }
+    } else if (path[0] === "/") {
+      root = "/";
     }
-    toContain(value) {
-      const stack = new Error().stack;
-      this.expected = value;
-      if (typeof this.actual === "string") {
-        this.assertCondition(
-          this.actual.includes(value),
-          `Expected "${this.actual}" to contain "${value}"`,
-          false,
-          void 0,
-          stack
-        );
-      } else if (Array.isArray(this.actual)) {
-        this.assertCondition(
-          this.actual.some((item) => this.deepEqual(item, value)),
-          `Expected array to contain ${this.stringify(value)}`,
-          false,
-          void 0,
-          stack
-        );
-      } else {
-        throw new Error(`toContain expects string or array, got ${typeof this.actual}`);
+    const dir = getDirname(path, isWin);
+    const base = getBasename(path, void 0, isWin);
+    const ext = getExtname(path);
+    const name = ext ? base.slice(0, base.length - ext.length) : base;
+    return { root, dir, base, ext, name };
+  }
+  function formatPath(pathObject, isWin) {
+    const separator = getSeparator(isWin);
+    const dir = pathObject.dir || pathObject.root || "";
+    const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+    if (!dir) return base;
+    if (dir === pathObject.root) return dir + base;
+    return dir + separator + base;
+  }
+  function createPathOps(isWin) {
+    return {
+      sep: getSeparator(isWin),
+      delimiter: isWin ? ";" : ":",
+      normalize: (path) => normalizePath(path, isWin),
+      join: (...paths) => joinPaths(paths, isWin),
+      resolve: (...paths) => resolvePaths(paths, isWin),
+      isAbsolute: (path) => isWin ? isAbsoluteWin(path) : isAbsolutePosix(path),
+      relative: (from, to) => relativePath(from, to, isWin),
+      dirname: (path) => getDirname(path, isWin),
+      basename: (path, ext) => getBasename(path, ext, isWin),
+      extname: (path) => getExtname(path),
+      parse: (path) => parsePath(path, isWin),
+      format: (pathObject) => formatPath(pathObject, isWin)
+    };
+  }
+
+  // src/server/path/index.ts
+  var posix = createPathOps(false);
+  var win32 = createPathOps(true);
+  function dirname(path) {
+    return getDirname(path, isWindows);
+  }
+
+  // src/test/runtime/transpile.ts
+  var TEST_MODULE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs", ".json"];
+  function resolveTestLoader(filePath) {
+    return /\.(?:ts|tsx|mts|cts)$/i.test(filePath) ? "ts" : "js";
+  }
+  function createTestTransformOptions(filePath, format, sourcemap) {
+    return {
+      loader: resolveTestLoader(filePath),
+      format,
+      sourcemap,
+      sourcefile: filePath,
+      target: "es2020",
+      tsconfigRaw: {
+        compilerOptions: {
+          jsx: "react",
+          jsxFactory: "h",
+          jsxFragmentFactory: "Fragment"
+        }
       }
+    };
+  }
+  function extractInlineSourceMap(code) {
+    const sourceMapMatch = code.match(/\/\/# sourceMappingURL=data:application\/json;base64,(.+)/);
+    if (!sourceMapMatch) {
+      return void 0;
     }
-    toHaveLength(length) {
-      const stack = new Error().stack;
-      this.expected = length;
-      const actualLength = this.actual?.length;
-      this.assertCondition(
-        actualLength === length,
-        `Expected length to be ${length}, but got ${actualLength}`,
-        false,
-        void 0,
-        stack
-      );
+    const json = Buffer.from(sourceMapMatch[1], "base64").toString("utf-8");
+    return JSON.parse(json);
+  }
+  function resolveExistingTestModulePath(basePath) {
+    const nodePath = __require("path");
+    if (existsSync(basePath) && statSync(basePath).isFile()) {
+      return basePath;
     }
-    toThrow(error) {
-      if (this.isAsync) {
-        return this.handleAsyncAssertion(error, () => {
-        });
+    for (const extension of TEST_MODULE_EXTENSIONS) {
+      const candidatePath = `${basePath}${extension}`;
+      if (existsSync(candidatePath) && statSync(candidatePath).isFile()) {
+        return candidatePath;
       }
-      let threw = false;
-      let thrownError = null;
-      try {
-        if (typeof this.actual === "function") {
-          this.actual();
+    }
+    if (existsSync(basePath) && statSync(basePath).isDirectory()) {
+      const packageJsonPath = nodePath.join(basePath, "package.json");
+      if (existsSync(packageJsonPath) && statSync(packageJsonPath).isFile()) {
+        try {
+          const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+          for (const candidateEntry of [packageJson.main, packageJson.module]) {
+            if (typeof candidateEntry !== "string" || candidateEntry.trim().length === 0) {
+              continue;
+            }
+            try {
+              return resolveExistingTestModulePath(nodePath.resolve(basePath, candidateEntry));
+            } catch {
+              continue;
+            }
+          }
+        } catch {
         }
-      } catch (e) {
-        threw = true;
-        thrownError = e;
       }
-      this.assertCondition(threw, `Expected function to throw an error`);
-      if (error) {
-        if (typeof error === "string") {
-          this.assertCondition(
-            thrownError.message.includes(error),
-            `Expected error message to include "${error}"`
-          );
-        } else if (error instanceof RegExp) {
-          this.assertCondition(
-            error.test(thrownError.message),
-            `Expected error message to match ${error}`
-          );
+      for (const extension of TEST_MODULE_EXTENSIONS) {
+        const candidatePath = nodePath.join(basePath, `index${extension}`);
+        if (existsSync(candidatePath) && statSync(candidatePath).isFile()) {
+          return candidatePath;
         }
       }
     }
-    toMatch(pattern) {
-      this.expected = pattern;
-      const str = String(this.actual);
-      if (pattern instanceof RegExp) {
-        this.assertCondition(
-          pattern.test(str),
-          `Expected "${str}" to match ${pattern}`
-        );
-      } else {
-        this.assertCondition(
-          str.includes(pattern),
-          `Expected "${str}" to contain "${pattern}"`
-        );
-      }
-    }
-    toBeInstanceOf(classType) {
-      this.expected = classType;
-      this.assertCondition(
-        this.actual instanceof classType,
-        `Expected value to be instance of ${classType.name}`
-      );
+    return basePath;
+  }
+  function resolveTestModulePath(fromFilePath, specifier) {
+    if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
+      return specifier;
     }
-    toHaveProperty(path, value) {
-      const keys = Array.isArray(path) ? path : path.split(".");
-      let obj = this.actual;
-      for (const key of keys) {
-        if (obj == null || !Object.hasOwnProperty.call(obj, key)) {
-          throw new Error(`Expected object to have property "${path}"`);
-        }
-        obj = obj[key];
+    const nodePath = __require("path");
+    const basePath = specifier.startsWith(".") ? nodePath.resolve(dirname(fromFilePath), specifier) : specifier;
+    return resolveExistingTestModulePath(basePath);
+  }
+  function shouldTranspileTestModule(filePath) {
+    return /\.(?:ts|tsx|mts|cts|js|jsx|mjs|cjs)$/i.test(filePath);
+  }
+  function createTestModuleRequire(fromFilePath, moduleCache) {
+    return (specifier) => {
+      if (specifier.startsWith("elit/") || specifier === "elit") {
+        return __require(specifier);
       }
-      if (value !== void 0) {
-        this.assertCondition(
-          this.deepEqual(obj, value),
-          `Expected property "${path}" to equal ${this.stringify(value)}`
-        );
+      const resolvedPath = resolveTestModulePath(fromFilePath, specifier);
+      if (resolvedPath === specifier) {
+        return __require(specifier);
       }
+      if (!existsSync(resolvedPath) || !statSync(resolvedPath).isFile()) {
+        return __require(resolvedPath);
+      }
+      if (!shouldTranspileTestModule(resolvedPath)) {
+        return __require(resolvedPath);
+      }
+      return loadTranspiledTestModule(resolvedPath, moduleCache);
+    };
+  }
+  function loadTranspiledTestModule(modulePath, moduleCache) {
+    const cached = moduleCache.get(modulePath);
+    if (cached) {
+      return cached.exports;
     }
-    // Mock function matchers
-    toBeCalled() {
-      this.assertCondition(
-        this.actual._isMock && this.actual._calls.length > 0,
-        `Expected mock function to have been called`
-      );
-    }
-    toBeCalledTimes(times) {
-      this.assertCondition(
-        this.actual._isMock && this.actual._calls.length === times,
-        `Expected mock to be called ${times} times, but was called ${this.actual._calls?.length || 0} times`
-      );
-    }
-    toBeCalledWith(...args) {
-      this.assertCondition(this.actual._isMock && this.actual._calls.some((call) => this.deepEqual(call, args)), `Expected mock to be called with ${this.stringify(args)}`);
+    const source = readFileSync(modulePath, "utf-8");
+    let transpiled;
+    try {
+      transpiled = (0, import_esbuild.transformSync)(source, createTestTransformOptions(modulePath, "cjs", false));
+    } catch (error) {
+      throw new Error(`Failed to transpile test dependency ${modulePath}: ${error instanceof Error ? error.message : String(error)}`);
     }
-    lastReturnedWith(value) {
-      const lastResult = this.actual._results?.[this.actual._results.length - 1];
-      this.assertCondition(
-        lastResult && this.deepEqual(lastResult.value, value),
-        `Expected last call to return ${this.stringify(value)}`
-      );
+    const moduleRecord = { exports: {} };
+    const moduleObject = { exports: moduleRecord.exports };
+    moduleCache.set(modulePath, moduleRecord);
+    try {
+      const fn = new Function("module", "exports", "require", "__filename", "__dirname", transpiled.code);
+      const requireFn = createTestModuleRequire(modulePath, moduleCache);
+      fn(moduleObject, moduleObject.exports, requireFn, modulePath, dirname(modulePath));
+    } catch (error) {
+      throw new Error(`Failed to execute test dependency ${modulePath}: ${error instanceof Error ? error.message : String(error)}`);
     }
-    deepEqual(a, b) {
-      return JSON.stringify(a) === JSON.stringify(b);
+    moduleRecord.exports = moduleObject.exports;
+    if (!modulePath.includes(".test.") && !modulePath.includes(".spec.")) {
+      runtimeState.coveredFiles.add(modulePath);
     }
-  };
-  function expect(actual) {
-    return new Expect(actual);
+    return moduleRecord.exports;
   }
-  function createMockFunction() {
-    const mock = function(...args) {
-      mock._calls.push(args);
-      try {
-        const result = mock._implementation ? mock._implementation(...args) : void 0;
-        mock._results.push({ type: "return", value: result });
-        return result;
-      } catch (error) {
-        mock._results.push({ type: "throw", value: error });
-        throw error;
-      }
-    };
-    mock._isMock = true;
-    mock._calls = [];
-    mock._results = [];
-    mock._implementation = null;
-    mock.mockImplementation = function(fn) {
-      mock._implementation = fn;
-      return mock;
-    };
-    mock.mockReturnValue = function(value) {
-      mock._implementation = (() => value);
-      return mock;
-    };
-    mock.mockResolvedValue = function(value) {
-      mock._implementation = (() => Promise.resolve(value));
-      return mock;
-    };
-    mock.mockRejectedValue = function(value) {
-      mock._implementation = (() => Promise.reject(value));
-      return mock;
-    };
-    mock.restore = function() {
-      mock._calls = [];
-      mock._results = [];
-      mock._implementation = null;
-    };
-    mock.clear = function() {
-      mock._calls = [];
-      mock._results = [];
+  async function transpileFile(filePath) {
+    const source = await readFile(filePath, "utf-8");
+    const result = (0, import_esbuild.transformSync)(source, createTestTransformOptions(filePath, "esm", "inline"));
+    return {
+      code: result.code,
+      sourceMap: extractInlineSourceMap(result.code)
     };
-    return mock;
   }
-  var vi = {
-    fn: () => createMockFunction(),
-    spyOn: (obj, method) => {
-      const original = obj[method];
-      const mock = createMockFunction();
-      mock.mockImplementation(original);
-      obj[method] = mock;
-      mock.restore = () => {
-        obj[method] = original;
-      };
-      return mock;
-    },
-    clearAllMocks: () => {
-    },
-    restoreAllMocks: () => {
+
+  // src/test/runtime/runner.ts
+  var import_esbuild2 = __toESM(require_main());
+  var import_source_map = __toESM(require_source_map());
+  function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  function destroyCurrentSourceMapConsumer() {
+    if (runtimeState.currentSourceMapConsumer) {
+      runtimeState.currentSourceMapConsumer.destroy();
+      runtimeState.currentSourceMapConsumer = void 0;
     }
-  };
-  var beforeAllHooks = [];
-  var afterAllHooks = [];
-  var beforeEachHooks = [];
-  var afterEachHooks = [];
-  var beforeAll = (fn) => beforeAllHooks.push(fn);
-  var afterAll = (fn) => afterAllHooks.push(fn);
-  var beforeEach = (fn) => beforeEachHooks.push(fn);
-  var afterEach = (fn) => afterEachHooks.push(fn);
+  }
+  function suiteOrDescendantMatches(suite) {
+    if (!runtimeState.describePattern) {
+      return true;
+    }
+    const regex = new RegExp(escapeRegex(runtimeState.describePattern), "i");
+    if (regex.test(suite.name)) {
+      return true;
+    }
+    for (const child of suite.suites) {
+      if (suiteOrDescendantMatches(child)) {
+        return true;
+      }
+    }
+    return false;
+  }
   async function runTests(options) {
-    const { files, timeout = 5e3, bail = false, describePattern: descPattern, testPattern: tPattern } = options;
-    describePattern = descPattern;
-    testPattern = tPattern;
-    testResults.length = 0;
-    hasOnly = false;
+    const { files, timeout = 5e3, bail = false, describePattern, testPattern } = options;
+    runtimeState.describePattern = describePattern;
+    runtimeState.testPattern = testPattern;
+    runtimeState.testResults.length = 0;
     for (const file of files) {
-      currentTestFile = file;
+      resetSuiteState();
+      resetHookState();
+      resetSourceMapState();
+      runtimeState.currentTestFile = file;
       try {
         const source = await readFile(file, "utf-8");
         const testFileDir = dirname(file);
-        const result = (0, import_esbuild.transformSync)(source, createTestTransformOptions(file, "cjs", "inline"));
-        let code = result.code;
-        const sourceMapMatch = code.match(/\/\/# sourceMappingURL=data:application\/json;base64,(.+)/);
-        if (sourceMapMatch) {
-          const base64 = sourceMapMatch[1];
-          const json = Buffer.from(base64, "base64").toString("utf-8");
-          const sourceMap = JSON.parse(json);
-          currentSourceMapConsumer = await new import_source_map.SourceMapConsumer(sourceMap);
-        } else {
-          currentSourceMapConsumer = void 0;
-        }
-        wrapperLineOffset = 0;
+        const result = (0, import_esbuild2.transformSync)(source, createTestTransformOptions(file, "cjs", "inline"));
+        const sourceMap = extractInlineSourceMap(result.code);
+        runtimeState.currentSourceMapConsumer = sourceMap ? await new import_source_map.SourceMapConsumer(sourceMap) : void 0;
+        runtimeState.wrapperLineOffset = 0;
         setupGlobals();
         const moduleCache = /* @__PURE__ */ new Map();
         const moduleRecord = { exports: {} };
-        const moduleObj = { exports: moduleRecord.exports };
+        const moduleObject = { exports: moduleRecord.exports };
         moduleCache.set(file, moduleRecord);
-        const fn = new Function("module", "exports", "require", "__filename", "__dirname", code);
+        const fn = new Function("module", "exports", "require", "__filename", "__dirname", result.code);
         const requireFn = createTestModuleRequire(file, moduleCache);
-        await fn(moduleObj, moduleObj.exports, requireFn, file, testFileDir);
-        await executeSuite(currentSuite, timeout, bail);
-        if (currentSourceMapConsumer) {
-          currentSourceMapConsumer.destroy();
-          currentSourceMapConsumer = void 0;
-        }
-        currentSuite = {
-          name: "root",
-          tests: [],
-          suites: [],
-          skip: false,
-          only: false
-        };
-        hasOnly = false;
-        beforeAllHooks = [];
-        afterAllHooks = [];
-        beforeEachHooks = [];
-        afterEachHooks = [];
+        await fn(moduleObject, moduleObject.exports, requireFn, file, testFileDir);
+        await executeSuite(runtimeState.currentSuite, timeout, bail);
       } catch (error) {
-        if (currentSourceMapConsumer) {
-          currentSourceMapConsumer.destroy();
-          currentSourceMapConsumer = void 0;
-        }
         console.error(`Error loading test file ${file}:`, error);
+      } finally {
+        destroyCurrentSourceMapConsumer();
       }
     }
-    const passed = testResults.filter((r) => r.status === "pass").length;
-    const failed = testResults.filter((r) => r.status === "fail").length;
-    const skipped = testResults.filter((r) => r.status === "skip").length;
-    const todo = testResults.filter((r) => r.status === "todo").length;
-    return { passed, failed, skipped, todo, results: testResults };
+    const passed = runtimeState.testResults.filter((result) => result.status === "pass").length;
+    const failed = runtimeState.testResults.filter((result) => result.status === "fail").length;
+    const skipped = runtimeState.testResults.filter((result) => result.status === "skip").length;
+    const todo = runtimeState.testResults.filter((result) => result.status === "todo").length;
+    return { passed, failed, skipped, todo, results: runtimeState.testResults };
   }
   async function executeSuite(suite, timeout, bail, parentMatched = false) {
     let directMatch = false;
-    if (describePattern) {
-      const escapedPattern = escapeRegex(describePattern);
-      const regex = new RegExp(escapedPattern, "i");
+    if (runtimeState.describePattern) {
+      const regex = new RegExp(escapeRegex(runtimeState.describePattern), "i");
       directMatch = regex.test(suite.name);
     }
-    function suiteOrDescendantMatches(s) {
-      if (!describePattern) return true;
-      const escapedPattern = escapeRegex(describePattern);
-      const regex = new RegExp(escapedPattern, "i");
-      if (regex.test(s.name)) return true;
-      for (const child of s.suites) {
-        if (suiteOrDescendantMatches(child)) return true;
-      }
-      return false;
-    }
-    const shouldRunSuite = !describePattern || directMatch || parentMatched || suiteOrDescendantMatches(suite);
+    const shouldRunSuite = !runtimeState.describePattern || directMatch || parentMatched || suiteOrDescendantMatches(suite);
     if (!shouldRunSuite) {
       return;
     }
@@ -5809,47 +5806,46 @@ error: ${text}`);
         await executeSuite(childSuite, timeout, bail, parentMatched || directMatch);
       }
     }
-    const shouldRunTests = !describePattern || directMatch || parentMatched || suite.name === "";
+    const shouldRunTests = !runtimeState.describePattern || directMatch || parentMatched || suite.name === "";
     if (!shouldRunTests) {
       return;
     }
-    for (const hook of beforeAllHooks) {
+    for (const hook of runtimeState.beforeAllHooks) {
       await hook();
     }
     for (const test of suite.tests) {
-      if (hasOnly && !test.only && !suite.only) {
+      if (runtimeState.hasOnly && !test.only && !suite.only) {
         continue;
       }
       let testMatches = true;
-      if (testPattern) {
-        const escapedPattern = escapeRegex(testPattern);
-        const regex = new RegExp(escapedPattern, "i");
+      if (runtimeState.testPattern) {
+        const regex = new RegExp(escapeRegex(runtimeState.testPattern), "i");
         testMatches = regex.test(test.name);
       }
       if (!testMatches) {
         continue;
       }
       if (test.skip || suite.skip) {
-        testResults.push({
+        runtimeState.testResults.push({
           name: test.name,
           status: "skip",
           duration: 0,
           suite: suite.name,
-          file: currentTestFile
+          file: runtimeState.currentTestFile
         });
         continue;
       }
       if (test.todo) {
-        testResults.push({
+        runtimeState.testResults.push({
           name: test.name,
           status: "todo",
           duration: 0,
           suite: suite.name,
-          file: currentTestFile
+          file: runtimeState.currentTestFile
         });
         continue;
       }
-      for (const hook of beforeEachHooks) {
+      for (const hook of runtimeState.beforeEachHooks) {
         await hook();
       }
       const startTime = Date.now();
@@ -5860,27 +5856,27 @@ error: ${text}`);
             (_, reject) => setTimeout(() => reject(new Error(`Test timed out after ${test.timeout}ms`)), test.timeout)
           )
         ]);
-        testResults.push({
+        runtimeState.testResults.push({
           name: test.name,
           status: "pass",
           duration: Date.now() - startTime,
           suite: suite.name,
-          file: currentTestFile
+          file: runtimeState.currentTestFile
         });
       } catch (error) {
-        let lineNumber = void 0;
-        let codeSnippet = void 0;
+        let lineNumber;
+        let codeSnippet;
         if (error instanceof AssertionError) {
           lineNumber = error.lineNumber;
           codeSnippet = error.codeSnippet;
         }
-        testResults.push({
+        runtimeState.testResults.push({
           name: test.name,
           status: "fail",
           duration: Date.now() - startTime,
           error,
           suite: suite.name,
-          file: currentTestFile,
+          file: runtimeState.currentTestFile,
           lineNumber,
           codeSnippet
         });
@@ -5888,51 +5884,12 @@ error: ${text}`);
           throw error;
         }
       }
-      for (const hook of afterEachHooks) {
+      for (const hook of runtimeState.afterEachHooks) {
         await hook();
       }
     }
-    for (const hook of afterAllHooks) {
+    for (const hook of runtimeState.afterAllHooks) {
       await hook();
     }
   }
-  var globals = {
-    describe: createDescribeFunction(),
-    it: createTestFunction(5e3),
-    test: createTestFunction(5e3),
-    expect,
-    beforeAll,
-    afterAll,
-    beforeEach,
-    afterEach,
-    vi
-  };
-  function setupGlobals() {
-    global.describe = globals.describe;
-    global.it = globals.it;
-    global.test = globals.test;
-    global.expect = globals.expect;
-    global.beforeAll = globals.beforeAll;
-    global.afterAll = globals.afterAll;
-    global.beforeEach = globals.beforeEach;
-    global.afterEach = globals.afterEach;
-    global.vi = globals.vi;
-  }
-  function clearGlobals() {
-    delete global.describe;
-    delete global.it;
-    delete global.test;
-    delete global.expect;
-    delete global.beforeAll;
-    delete global.afterAll;
-    delete global.beforeEach;
-    delete global.afterEach;
-    delete global.vi;
-  }
-  function getCoveredFiles() {
-    return coveredFiles;
-  }
-  function resetCoveredFiles() {
-    coveredFiles.clear();
-  }
 })();