elit 3.6.5 → 3.6.7

package/dist/test-runtime.mjs

@@ -6,10 +6,53 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// src/test-runtime.ts
-import { transformSync } from "esbuild";
+// 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";
@@ -19,7 +62,15 @@ var isNode = runtime === "node";
 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;
 }
@@ -29,12 +80,37 @@ function decodeContent(content, encoding) {
   }
   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) {
@@ -72,421 +148,460 @@ function statSync(path) {
   }
   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 "/";
-}
-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)
-  };
+// src/test/runtime/assertion-context.ts
+function getAssertionMethod(stack) {
+  const assertionMatch = stack.match(/at _?Expect\.(\w+)/);
+  return assertionMatch ? assertionMatch[1] : void 0;
 }
-function isAbsolutePosix(path) {
-  return path.length > 0 && path[0] === "/";
+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 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;
-      }
+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;
   }
-  return false;
 }
-var isWindows = (() => {
-  if (isNode) {
-    return process.platform === "win32";
-  } else if (isDeno) {
-    return Deno.build.os === "windows";
+function resolveMappedLine(lineNumber, sourceLines, assertionMethod) {
+  const targetPattern = getTargetPattern(assertionMethod);
+  if (lineNumber <= 0 || lineNumber > sourceLines.length) {
+    return lineNumber;
+  }
+  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 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;
+  return lineNumber;
+}
+function resolveAssertionContext(stack) {
+  if (!stack) {
+    return {};
+  }
+  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;
+  }
+  get not() {
+    if (!this._not) {
+      this._not = new _Expect(this.actual, !this.isNot, false);
     }
+    return this._not;
   }
-  if (!isAbsolute) {
-    const cwd = getCwd();
-    resolved = cwd + (resolved.length > 0 ? separator + resolved : "");
+  get resolves() {
+    if (!this._resolves) {
+      this._resolves = new _Expect(this.actual, this.isNot, true);
+    }
+    return this._resolves;
   }
-  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 rejects() {
+    if (!this._rejects) {
+      this._rejects = new _Expect(this.actual, this.isNot, true);
     }
+    return this._rejects;
   }
-  const upCount = fromParts.length - commonLength;
-  const result = [];
-  for (let i = 0; i < upCount; i++) {
-    result.push("..");
+  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);
+    }
   }
-  for (let i = commonLength; i < toParts.length; i++) {
-    result.push(toParts[i]);
+  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 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 "";
-  }
-  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 = "\\";
-    }
-  } else {
-    if (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);
     }
   }
-  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
-import { SourceMapConsumer } from "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";
+  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}`);
+    }
   }
-};
-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"
+  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]));
       }
-    }
-  };
-}
-function resolveExistingTestModulePath(basePath) {
-  const nodePath = __require("path");
-  if (existsSync(basePath) && statSync(basePath).isFile()) {
-    return basePath;
+      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);
   }
-  for (const extension of TEST_MODULE_EXTENSIONS) {
-    const candidatePath = `${basePath}${extension}`;
-    if (existsSync(candidatePath) && statSync(candidatePath).isFile()) {
-      return candidatePath;
+  toBeTruthy() {
+    this.assertCondition(!!this.actual, "Expected value to be truthy", false, void 0, new Error().stack);
+  }
+  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 = 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;
+  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);
+  }
+};
+function expect(actual) {
+  return new Expect(actual);
 }
-async function transpileFile(filePath) {
-  const source = await readFile(filePath, "utf-8");
-  const result = 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);
-  }
-  return { code: result.code, sourceMap };
+
+// 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 = {
@@ -496,12 +611,12 @@ function createTestFunction(defaultTimeout = 5e3) {
       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,
@@ -509,9 +624,9 @@ function createTestFunction(defaultTimeout = 5e3) {
       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 = {
@@ -521,15 +636,15 @@ function createTestFunction(defaultTimeout = 5e3) {
       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: [],
@@ -539,12 +654,12 @@ function createDescribeFunction() {
       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: [],
@@ -554,13 +669,13 @@ function createDescribeFunction() {
       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: [],
@@ -570,594 +685,476 @@ function createDescribeFunction() {
       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
+import { transformSync } from "esbuild";
+
+// 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";
+  }
+  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;
   }
-  get rejects() {
-    if (!this._rejects) {
-      this._rejects = new _Expect(this.actual, this.isNot, 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 = 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 = 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
+import { transformSync as transformSync2 } from "esbuild";
+import { SourceMapConsumer } from "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 = 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 SourceMapConsumer(sourceMap);
-      } else {
-        currentSourceMapConsumer = void 0;
-      }
-      wrapperLineOffset = 0;
+      const result = transformSync2(source, createTestTransformOptions(file, "cjs", "inline"));
+      const sourceMap = extractInlineSourceMap(result.code);
+      runtimeState.currentSourceMapConsumer = sourceMap ? await new 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;
   }
@@ -1166,47 +1163,46 @@ async function executeSuite(suite, timeout, bail, parentMatched = false) {
       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();
@@ -1217,27 +1213,27 @@ async function executeSuite(suite, timeout, bail, parentMatched = false) {
           (_, 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
       });
@@ -1245,53 +1241,14 @@ async function executeSuite(suite, timeout, bail, parentMatched = false) {
         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();
-}
 export {
   clearGlobals,
   getCoveredFiles,