headlamp 0.1.10 → 0.1.11

package/dist/cli.cjs

@@ -93,7 +93,7 @@ var init_TimeoutError = __esm({
 
 // node_modules/es-toolkit/dist/promise/delay.mjs
 function delay(ms, { signal } = {}) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const abortError = () => {
       reject(new AbortError());
     };
@@ -106,7 +106,7 @@ function delay(ms, { signal } = {}) {
     }
     const timeoutId = setTimeout(() => {
       signal?.removeEventListener("abort", abortHandler);
-      resolve9();
+      resolve10();
     }, ms);
     signal?.addEventListener("abort", abortHandler, { once: true });
   });
@@ -171,11 +171,11 @@ var init_exec = __esm({
       child.stderr?.on("data", (chunk) => {
         stderr += String(chunk);
       });
-      const exec = new Promise((resolve9, reject) => {
+      const exec = new Promise((resolve10, reject) => {
         child.on("error", reject);
         child.on(
           "close",
-          (code) => Number(code) === 0 ? resolve9(stdout) : reject(new Error(stderr || `exit ${code}`))
+          (code) => Number(code) === 0 ? resolve10(stdout) : reject(new Error(stderr || `exit ${code}`))
         );
       });
       try {
@@ -195,7 +195,7 @@ var init_exec = __esm({
         throw caughtError;
       }
     };
-    runExitCode = async (cmd, args, opts = {}) => new Promise((resolve9, reject) => {
+    runExitCode = async (cmd, args, opts = {}) => new Promise((resolve10, reject) => {
       const child = (0, import_node_child_process.spawn)(cmd, [...args], {
         cwd: opts.cwd,
         env: opts.env,
@@ -204,9 +204,9 @@ var init_exec = __esm({
         windowsHide: true
       });
       child.on("error", reject);
-      child.on("close", (code) => resolve9(Number(code)));
+      child.on("close", (code) => resolve10(Number(code)));
     });
-    runWithCapture = async (cmd, args, opts) => new Promise((resolve9, reject) => {
+    runWithCapture = async (cmd, args, opts) => new Promise((resolve10, reject) => {
       const child = (0, import_node_child_process.spawn)(cmd, [...args], {
         cwd: opts.cwd,
         env: opts.env,
@@ -222,7 +222,7 @@ var init_exec = __esm({
         buf += String(chunk);
       });
       child.on("error", reject);
-      child.on("close", (code) => resolve9({ code: Number(code), output: buf }));
+      child.on("close", (code) => resolve10({ code: Number(code), output: buf }));
     });
   }
 });
@@ -272,7 +272,7 @@ var init_args = __esm({
     isSome = (opt) => opt._tag === "some";
     step = (actions, skipNext = false) => [actions, skipNext];
     rule = {
-      when: (predicate, build) => (value, env2) => predicate(value, env2) ? Some(build(value, env2)) : None,
+      when: (predicate, build) => (value, env) => predicate(value, env) ? Some(build(value, env)) : None,
       eq: (flag, build) => rule.when(
         (value) => value === flag,
         () => build()
@@ -282,12 +282,12 @@ var init_args = __esm({
         (value) => build(value)
       ),
       inSet: (select, build) => rule.when(
-        (value, env2) => select(env2).has(value),
+        (value, env) => select(env).has(value),
         (value) => build(value)
       ),
       withLookahead: (lookaheadFlag, build) => rule.when(
-        (value, env2) => value === lookaheadFlag && typeof env2.lookahead === "string" && env2.lookahead.length > 0,
-        (value, env2) => build(value, env2.lookahead)
+        (value, env) => value === lookaheadFlag && typeof env.lookahead === "string" && env.lookahead.length > 0,
+        (value, env) => build(value, env.lookahead)
       )
     };
     STRING_EMPTY = "";
@@ -420,7 +420,7 @@ var init_args = __esm({
         ),
         rule.startsWith("--testPathPattern=", (value) => step([ActionBuilders.jestArg(value)])),
         rule.inSet(
-          (env2) => env2.jestFlags,
+          (env) => env.jestFlags,
           (value) => step([ActionBuilders.jestArg(value)])
         ),
         rule.when(
@@ -516,9 +516,9 @@ var init_args = __esm({
         }
         const tokenValue = token ?? STRING_EMPTY;
         const nextToken = tokens[index + INDEX_STEP];
-        let env2 = { jestFlags: jestOnlyFlags };
+        let env = { jestFlags: jestOnlyFlags };
         if (typeof nextToken === "string" && nextToken.length > 0) {
-          env2 = { jestFlags: jestOnlyFlags, lookahead: nextToken };
+          env = { jestFlags: jestOnlyFlags, lookahead: nextToken };
         }
         const firstMatch = (rs, value, envForRules) => {
           for (const ruleFn of rs) {
@@ -529,7 +529,7 @@ var init_args = __esm({
           }
           return None;
         };
-        const matched = firstMatch(rules, tokenValue, env2);
+        const matched = firstMatch(rules, tokenValue, env);
         const isTestFileToken = (candidate) => /\.(test|spec)\.[tj]sx?$/.test(candidate) || /(^|\/)tests?\//.test(candidate);
         const isPathLike = (candidate) => /[\\/]/.test(candidate) || /\.(m?[tj]sx?)$/i.test(candidate);
         const [matchedActions, shouldSkipNext] = isSome(matched) ? matched.value : (() => {
@@ -1987,19 +1987,19 @@ var require_lib = __commonJS({
   "node_modules/json5/lib/index.js"(exports2, module2) {
     var parse = require_parse();
     var stringify = require_stringify();
-    var JSON52 = {
+    var JSON53 = {
       parse,
       stringify
     };
-    module2.exports = JSON52;
+    module2.exports = JSON53;
   }
 });
 
 // src/lib/program.ts
-var path10 = __toESM(require("node:path"), 1);
+var path11 = __toESM(require("node:path"), 1);
 var os2 = __toESM(require("node:os"), 1);
 var fsSync3 = __toESM(require("node:fs"), 1);
-var fs5 = __toESM(require("node:fs/promises"), 1);
+var fs7 = __toESM(require("node:fs/promises"), 1);
 var LibReport = __toESM(require("istanbul-lib-report"), 1);
 var Reports = __toESM(require("istanbul-reports"), 1);
 var import_istanbul_lib_coverage2 = require("istanbul-lib-coverage");
@@ -3370,7 +3370,7 @@ var printCompactCoverage = async (opts) => {
     );
   }
 };
-var shortenPathPreservingFilename = (relPath, maxWidth, opts) => {
+var shortenPathPreservingFilename = (relPath2, maxWidth, opts) => {
   const ellipsis = opts?.ellipsis ?? "\u2026";
   const START_HEAD = Math.max(0, opts?.keepHead ?? 1);
   const START_TAIL = Math.max(0, opts?.keepTail ?? 1);
@@ -3542,7 +3542,7 @@ var shortenPathPreservingFilename = (relPath, maxWidth, opts) => {
     }
     return null;
   };
-  const normalized = relPath.replace(/\\/g, "/");
+  const normalized = relPath2.replace(/\\/g, "/");
   if (visibleWidth(normalized) <= maxWidth) {
     return normalized;
   }
@@ -3998,11 +3998,343 @@ var printPerFileCompositeTables = async (opts) => {
   }
 };
 
-// src/lib/jest-bridge.ts
-var path9 = __toESM(require("node:path"), 1);
-var fs4 = __toESM(require("node:fs"), 1);
-var util = __toESM(require("node:util"), 1);
-var import_json5 = __toESM(require_lib(), 1);
+// src/lib/jest-reporter-source.ts
+var JEST_BRIDGE_REPORTER_SOURCE = `const fs = require('fs');
+const path = require('path');
+
+const isObject = (v) => typeof v === 'object' && v !== null;
+const sanitizeError = (err) => {
+  if (!isObject(err)) return err;
+  const out = {};
+  const name = err.name || (err.constructor && err.constructor.name) || undefined;
+  if (name) out.name = String(name);
+  if (typeof err.message === 'string') out.message = err.message;
+  if (typeof err.stack === 'string') out.stack = err.stack;
+  if (err.code !== undefined) out.code = err.code;
+  if (err.expected !== undefined) out.expected = err.expected;
+  if (err.received !== undefined) out.received = err.received;
+  if (err.matcherResult && isObject(err.matcherResult)) {
+    const mr = err.matcherResult;
+    let messageText;
+    try {
+      messageText = typeof mr.message === 'function' ? String(mr.message()) : (typeof mr.message === 'string' ? mr.message : undefined);
+    } catch {}
+    out.matcherResult = {
+      matcherName: typeof mr.matcherName === 'string' ? mr.matcherName : undefined,
+      message: messageText,
+      stack: typeof mr.stack === 'string' ? mr.stack : undefined,
+      expected: mr.expected,
+      received: mr.received,
+      actual: mr.actual,
+      pass: typeof mr.pass === 'boolean' ? mr.pass : undefined,
+    };
+  }
+  if (err.cause) {
+    out.cause = sanitizeError(err.cause);
+  }
+  // Copy own enumerable props to preserve custom data
+  try {
+    for (const key of Object.keys(err)) {
+      if (!(key in out)) out[key] = err[key];
+    }
+  } catch {}
+  return out;
+};
+const sanitizeDetail = (d) => {
+  if (typeof d === 'string') return d;
+  if (!isObject(d)) return d;
+  // Common Jest detail shapes
+  const out = {};
+  if (d.message) out.message = d.message;
+  if (d.stack) out.stack = d.stack;
+  if (d.error) out.error = sanitizeError(d.error);
+  if (d.matcherResult) out.matcherResult = sanitizeError({ matcherResult: d.matcherResult }).matcherResult;
+  if (d.expected !== undefined) out.expected = d.expected;
+  if (d.received !== undefined) out.received = d.received;
+  // Copy the rest
+  try {
+    for (const key of Object.keys(d)) {
+      if (!(key in out)) out[key] = d[key];
+    }
+  } catch {}
+  return out;
+};
+
+class BridgeReporter {
+  constructor(globalConfig, options) {
+    this.out = process.env.JEST_BRIDGE_OUT || (options && options.outFile) || path.join(process.cwd(), 'coverage', 'jest-run.json');
+    this.buf = { startTime: Date.now(), testResults: [], aggregated: null };
+  }
+  onRunStart() { this.buf.startTime = Date.now(); }
+  onTestResult(_test, tr) {
+    const mapAssertion = (a) => ({
+      title: a.title,
+      fullName: a.fullName || [...(a.ancestorTitles || []), a.title].join(' '),
+      status: a.status,
+      duration: a.duration || 0,
+      location: a.location || null,
+      failureMessages: (a.failureMessages || []).map(String),
+      failureDetails: (a.failureDetails || []).map(sanitizeDetail),
+    });
+    this.buf.testResults.push({
+      testFilePath: tr.testFilePath,
+      status: tr.numFailingTests ? 'failed' : 'passed',
+      failureMessage: tr.failureMessage || '',
+      failureDetails: (tr.failureDetails || []).map(sanitizeDetail),
+      testExecError: tr.testExecError ? sanitizeError(tr.testExecError) : null,
+      console: tr.console || null,
+      perfStats: tr.perfStats || {},
+      testResults: (tr.testResults || []).map(mapAssertion),
+    });
+  }
+  onRunComplete(_contexts, agg) {
+    this.buf.aggregated = {
+      numTotalTestSuites: agg.numTotalTestSuites,
+      numPassedTestSuites: agg.numPassedTestSuites,
+      numFailedTestSuites: agg.numFailedTestSuites,
+      numTotalTests: agg.numTotalTests,
+      numPassedTests: agg.numPassedTests,
+      numFailedTests: agg.numFailedTests,
+      numPendingTests: agg.numPendingTests,
+      numTodoTests: agg.numTodoTests,
+      startTime: agg.startTime,
+      success: agg.success,
+      runTimeMs: agg.testResults.reduce((t, r) => t + Math.max(0, (r.perfStats?.end || 0) - (r.perfStats?.start || 0)), 0),
+    };
+    fs.mkdirSync(path.dirname(this.out), { recursive: true });
+    fs.writeFileSync(this.out, JSON.stringify(this.buf), 'utf8');
+  }
+}
+module.exports = BridgeReporter;`;
+
+// src/lib/jest-environment-source.ts
+var JEST_BRIDGE_ENV_SOURCE = `
+'use strict';
+
+const NodeEnvironment = require('jest-environment-node').TestEnvironment || require('jest-environment-node');
+
+module.exports = class BridgeEnv extends NodeEnvironment {
+  constructor(config, context) {
+    super(config, context);
+    const { AsyncLocalStorage } = require('node:async_hooks');
+    this._als = new AsyncLocalStorage();
+    this._cleanup = [];
+  }
+
+  _ctx() {
+    try { const s = this._als.getStore(); if (s) return s; } catch {}
+    try {
+      const st = this.global.expect && typeof this.global.expect.getState === 'function' ? this.global.expect.getState() : {};
+      return { testPath: st.testPath, currentTestName: st.currentTestName };
+    } catch { return {}; }
+  }
+
+  async setup() {
+    await super.setup();
+
+    try { Error.stackTraceLimit = Math.max(Error.stackTraceLimit || 10, 50); } catch {}
+
+    const print = (payload) => { try { this.global.console.error('[JEST-BRIDGE-EVENT]', JSON.stringify(payload)); } catch {} };
+    const toErr = (x) => { try { return x instanceof Error ? x : new Error(String(x)); } catch { return new Error('unknown'); } };
+
+    const onRej = (reason) => {
+      const e = toErr(reason);
+      const c = this._ctx();
+      print({ type: 'unhandledRejection', name: e.name, message: e.message, stack: e.stack, code: e.code ?? undefined, ...c });
+    };
+    const onExc = (error) => {
+      const e = toErr(error);
+      const c = this._ctx();
+      print({ type: 'uncaughtException', name: e.name, message: e.message, stack: e.stack, code: e.code ?? undefined, ...c });
+    };
+
+    this.global.process.on('unhandledRejection', onRej);
+    this.global.process.on('uncaughtException', onExc);
+    this._cleanup.push(() => {
+      this.global.process.off('unhandledRejection', onRej);
+      this.global.process.off('uncaughtException', onExc);
+    });
+
+    // Signal environment readiness so we can confirm the custom env loaded
+    try { const c = this._ctx(); print({ type: 'envReady', ...c }); } catch {}
+
+    try {
+      const http = this.global.require ? this.global.require('http') : require('http');
+      const originalEmit = http && http.Server && http.Server.prototype && http.Server.prototype.emit;
+      if (originalEmit) {
+        const MAX = 64 * 1024;
+        const asString = (x) => { try { if (typeof x === 'string') return x; if (Buffer.isBuffer(x)) return x.toString('utf8'); return String(x); } catch { return ''; } };
+
+        const patched = function(eventName, req, res) {
+          try {
+            if (eventName === 'request' && req && res && typeof res.write === 'function' && typeof res.end === 'function') {
+              const startAt = Date.now();
+              const safeHeader = (k) => { try { return req && req.headers ? String((req.headers[k.toLowerCase()] ?? '')) : ''; } catch { return ''; } };
+              const reqIdHeader = safeHeader('x-request-id');
+              const chunks = [];
+              const write = res.write.bind(res);
+              const end = res.end.bind(res);
+              const method = req.method ? String(req.method) : undefined;
+              const url = (req.originalUrl || req.url) ? String(req.originalUrl || req.url) : undefined;
+
+              res.write = function(chunk, enc, cb) {
+                try { const s = asString(chunk); if (s) chunks.push(s); } catch {}
+                return write(chunk, enc, cb);
+              };
+              res.end = function(chunk, enc, cb) {
+                try { const s = asString(chunk); if (s) chunks.push(s); } catch {}
+                try {
+                  const preview = chunks.join('').slice(0, MAX);
+                  const statusCode = typeof res.statusCode === 'number' ? res.statusCode : undefined;
+                  const ct = (typeof res.getHeader === 'function' && res.getHeader('content-type')) || undefined;
+                  const routePath = (req && req.route && req.route.path) || (req && req.baseUrl && req.path ? (req.baseUrl + req.path) : undefined);
+                  const jsonParsed = (() => { try { return JSON.parse(preview); } catch { return undefined; } })();
+                  const requestId = reqIdHeader || (jsonParsed && typeof jsonParsed === 'object' ? (jsonParsed.requestId || jsonParsed.reqId || '') : '');
+                  const ctx = (global.__JEST_BRIDGE_ENV_REF && global.__JEST_BRIDGE_ENV_REF._ctx) ? global.__JEST_BRIDGE_ENV_REF._ctx() : {};
+                  const payload = {
+                    type: 'httpResponse',
+                    timestampMs: Date.now(),
+                    durationMs: Math.max(0, Date.now() - startAt),
+                    method, url, statusCode,
+                    route: routePath ? String(routePath) : undefined,
+                    contentType: ct ? String(ct) : undefined,
+                    headers: (typeof res.getHeaders === 'function') ? res.getHeaders() : undefined,
+                    requestId: requestId ? String(requestId) : undefined,
+                    bodyPreview: preview,
+                    json: jsonParsed,
+                    testPath: ctx.testPath, currentTestName: ctx.currentTestName,
+                  };
+                  try {
+                    if (!global.__JEST_HTTP_EVENTS__) global.__JEST_HTTP_EVENTS__ = [];
+                    const arr = global.__JEST_HTTP_EVENTS__;
+                    arr.push({ timestampMs: payload.timestampMs, durationMs: payload.durationMs, method: payload.method, url: payload.url, route: payload.route, statusCode: payload.statusCode, contentType: payload.contentType, requestId: payload.requestId, json: payload.json, bodyPreview: payload.bodyPreview });
+                    if (arr.length > 25) arr.splice(0, arr.length - 25);
+                  } catch {}
+                  try { console.error('[JEST-BRIDGE-EVENT]', JSON.stringify(payload)); } catch {}
+                } catch {}
+                return end(chunk, enc, cb);
+              };
+              try {
+                res.on('close', function onClose() {
+                  try {
+                    const ended = typeof res.writableEnded === 'boolean' ? res.writableEnded : false;
+                    if (!ended) {
+                      const routePath = (req && req.route && req.route.path) || (req && req.baseUrl && req.path ? (req.baseUrl + req.path) : undefined);
+                      const ctx = (global.__JEST_BRIDGE_ENV_REF && global.__JEST_BRIDGE_ENV_REF._ctx) ? global.__JEST_BRIDGE_ENV_REF._ctx() : {};
+                      const payload = {
+                        type: 'httpAbort',
+                        timestampMs: Date.now(),
+                        durationMs: Math.max(0, Date.now() - startAt),
+                        method, url,
+                        route: routePath ? String(routePath) : undefined,
+                        testPath: ctx.testPath, currentTestName: ctx.currentTestName,
+                      };
+                      try { console.error('[JEST-BRIDGE-EVENT]', JSON.stringify(payload)); } catch {}
+                    }
+                  } catch {}
+                });
+              } catch {}
+            }
+          } catch {}
+          return originalEmit.apply(this, arguments);
+        };
+
+        try { this.global.__JEST_BRIDGE_ENV_REF = this; } catch {}
+        http.Server.prototype.emit = patched;
+
+        this._cleanup.push(() => {
+          try { if (http.Server && http.Server.prototype) http.Server.prototype.emit = originalEmit; } catch {}
+          try { delete this.global.__JEST_BRIDGE_ENV_REF; } catch {}
+        });
+      }
+    } catch {}
+
+    // Wrap test functions to emit rich assertion events on failures
+    try {
+      const g = this.global;
+      const ctxFn = () => {
+        try {
+          const ref = g.__JEST_BRIDGE_ENV_REF;
+          return ref && typeof ref._ctx === 'function' ? ref._ctx() : {};
+        } catch { return {}; }
+      };
+      const emitAssertion = (err) => {
+        try {
+          const e = toErr(err);
+          const mr = e && typeof e === 'object' && e.matcherResult ? e.matcherResult : undefined;
+          const messageText = (() => { try { return mr && typeof mr.message === 'function' ? String(mr.message()) : (e.message || ''); } catch { return e.message || ''; } })();
+          const expectedPreview = (() => { try { return mr && mr.expected !== undefined ? JSON.stringify(mr.expected, null, 2) : undefined; } catch { return undefined; } })();
+          const actualPreview = (() => { try { return mr && mr.received !== undefined ? JSON.stringify(mr.received, null, 2) : undefined; } catch { return undefined; } })();
+          const c = ctxFn();
+          const expectedRaw = (() => { try { return mr?.expected; } catch { return undefined; } })();
+          const receivedRaw = (() => { try { return mr?.received; } catch { return undefined; } })();
+          print({
+            type: 'assertionFailure',
+            timestampMs: Date.now(),
+            matcher: mr && typeof mr.matcherName === 'string' ? mr.matcherName : undefined,
+            expectedPreview,
+            actualPreview,
+            expectedNumber: typeof expectedRaw === 'number' ? expectedRaw : undefined,
+            receivedNumber: typeof receivedRaw === 'number' ? receivedRaw : undefined,
+            message: messageText,
+            stack: e.stack,
+            ...c,
+          });
+        } catch {}
+      };
+      const wrap = (orig) => {
+        if (!orig || typeof orig !== 'function') return orig;
+        const wrapped = function(name, fn, timeout) {
+          if (typeof fn !== 'function') return orig.call(this, name, fn, timeout);
+          const run = function() {
+            try {
+              const res = fn.apply(this, arguments);
+              if (res && typeof res.then === 'function') {
+                return res.catch((err) => { emitAssertion(err); throw err; });
+              }
+              return res;
+            } catch (err) {
+              emitAssertion(err);
+              throw err;
+            }
+          };
+          return orig.call(this, name, run, timeout);
+        };
+        try { wrapped.only = orig.only && typeof orig.only === 'function' ? wrap(orig.only) : orig.only; } catch {}
+        try { wrapped.skip = orig.skip && typeof orig.skip === 'function' ? wrap(orig.skip) : orig.skip; } catch {}
+        return wrapped;
+      };
+      try { g.it = wrap(g.it); } catch {}
+      try { g.test = wrap(g.test); } catch {}
+    } catch {}
+  }
+
+  async handleTestEvent(evt, state) {
+    if (evt.name === 'test_start') {
+      const store = { testPath: state.testPath, currentTestName: evt.test.name };
+      try { this._als.enterWith(store); } catch {}
+    } else if (evt.name === 'test_done') {
+      try { this._als.enterWith({}); } catch {}
+      try {
+        const events = Array.isArray(global.__JEST_HTTP_EVENTS__) ? global.__JEST_HTTP_EVENTS__ : [];
+        if (events.length) {
+          const batch = events.slice(-10);
+          const payload = { type: 'httpResponseBatch', events: batch, testPath: state.testPath, currentTestName: evt.test.name };
+          try { this.global.console.error('[JEST-BRIDGE-EVENT]', JSON.stringify(payload)); } catch {}
+          try { global.__JEST_HTTP_EVENTS__ = []; } catch {}
+        }
+      } catch {}
+    }
+  }
+
+  async teardown() {
+    for (let i = this._cleanup.length - 1; i >= 0; i--) {
+      try { this._cleanup[i](); } catch {}
+    }
+    await super.teardown();
+  }
+};
+`;
 
 // src/lib/stacks.ts
 var isStackLine = (line) => /\s+at\s+/.test(line);
@@ -4065,30 +4397,81 @@ var collapseStacks = (lines) => {
   return out;
 };
 
-// src/lib/jest-bridge.ts
-var extractBridgePath = (raw, cwd) => {
-  const matches = Array.from(
-    raw.matchAll(/Test results written to:\s+([^\n\r]+jest-bridge-[^\s'"]+\.json)/g)
-  );
-  if (!matches.length) {
-    return null;
+// src/lib/fp.ts
+function pipe(initial, ...fns) {
+  return fns.reduce((acc, fn) => fn(acc), initial);
+}
+var some = (value) => ({ tag: "Some", value });
+var none = { tag: "None" };
+var unfoldr = (initial, step2) => {
+  const out = [];
+  for (let state = initial; ; ) {
+    const result = step2(state);
+    if (result.tag === "None") {
+      break;
+    }
+    const [element, next] = result.value;
+    out.push(element);
+    state = next;
   }
-  const jsonPath = matches[matches.length - 1][1].trim().replace(/^["'`]|["'`]$/g, "");
-  return path9.isAbsolute(jsonPath) ? jsonPath : path9.resolve(cwd, jsonPath);
+  return out;
 };
-var drawRule = (label) => {
-  const width = Math.max(
-    40,
-    process.stdout && process.stdout.columns || 80
-  );
-  if (!label) {
-    return ansi.dim("\u2500".repeat(width));
+
+// src/lib/formatter/parse.ts
+var isFailureStart = (lineText) => /^\s*●\s+/.test(lineText);
+var isSuiteLine = (lineText) => /^\s*(PASS|FAIL)\s+/.test(lineText);
+var isSummaryLine = (lineText) => /^\s*(Test Suites:|Tests:|Snapshots:|Time:|Ran all)/.test(lineText);
+var collectFailure = (allLines, startIndex) => {
+  const title = stripAnsiSimple(allLines[startIndex]).replace(/^\s*●\s+/, "").trim();
+  const buf = [allLines[startIndex]];
+  let i = startIndex + 1;
+  for (; i < allLines.length; i += 1) {
+    const simple = stripAnsiSimple(allLines[i]);
+    const nextIsStart = isFailureStart(simple) || isSuiteLine(simple) || isSummaryLine(simple);
+    const prevBlank = stripAnsiSimple(allLines[i - 1] ?? "").trim() === "";
+    if (nextIsStart && prevBlank) {
+      break;
+    }
+    buf.push(allLines[i]);
   }
-  const plain = stripAnsiSimple(label);
-  const pad = Math.max(1, width - plain.length - 1);
-  return `${ansi.dim("\u2500".repeat(pad))} ${label}`;
+  return [{ tag: "FailureBlock", title, lines: buf }, i];
+};
+var parseSuite = (lineText) => {
+  const match = lineText.match(/^\s*(PASS|FAIL)\s+(.+)$/);
+  return { tag: "PassFail", badge: match[1], rel: match[2] };
+};
+var parseChunks = (raw) => {
+  const lines = raw.split(/\r?\n/);
+  return unfoldr({ index: 0 }, (state) => {
+    if (state.index >= lines.length) {
+      return none;
+    }
+    const line = lines[state.index];
+    const simple = stripAnsiSimple(line);
+    if (isFailureStart(simple)) {
+      const [chunk, next] = collectFailure(lines, state.index);
+      return some([chunk, { index: next }]);
+    }
+    if (isSuiteLine(simple)) {
+      return some([parseSuite(simple), { index: state.index + 1 }]);
+    }
+    if (isSummaryLine(simple)) {
+      return some([{ tag: "Summary", line }, { index: state.index + 1 }]);
+    }
+    if (isStackLine(simple)) {
+      return some([{ tag: "Stack", line }, { index: state.index + 1 }]);
+    }
+    return some([{ tag: "Other", line }, { index: state.index + 1 }]);
+  });
 };
-var env = process.env;
+
+// src/lib/formatter/render.ts
+var path9 = __toESM(require("node:path"), 1);
+
+// src/lib/formatter/fns.ts
+var fs4 = __toESM(require("node:fs"), 1);
+var util = __toESM(require("node:util"), 1);
+var import_json5 = __toESM(require_lib(), 1);
 var colorTokens = {
   pass: Colors.Success,
   fail: Colors.Failure,
@@ -4099,31 +4482,17 @@ var colorTokens = {
   failPill: (text) => BackgroundColors.Failure(ansi.white(` ${text} `)),
   runPill: (text) => BackgroundColors.Run(ansi.white(` ${text} `))
 };
-var MAX_CONSOLE_ERRORS_TO_SHOW = 3;
-var isArrayOfPrimitives = (value) => Array.isArray(value) && value.every(
-  (element) => ["string", "number", "boolean"].includes(typeof element) || element === null
-);
-var indentBlock = (text, pad = "      ") => text.split("\n").map((line) => line ? pad + line : pad.trimEnd()).join("\n");
-var normalizeBlock = (raw) => raw.replace(/^\s*Array\s*\[/, "[").replace(/^\s*Object\s*\{/, "{").replace(/,(\s*[\]}])/g, "$1");
-var stringifyPrettierish = (value) => {
-  if (typeof value === "string") {
-    const text = normalizeBlock(value.trim());
-    if (/^[[{]/.test(text)) {
-      try {
-        const parsed = import_json5.default.parse(text);
-        return JSON.stringify(parsed, null, 2);
-      } catch {
-      }
-    }
-    return value;
-  }
-  if (Array.isArray(value) || value && typeof value === "object") {
-    try {
-      return JSON.stringify(value, null, 2);
-    } catch {
-    }
+var drawRule = (label) => {
+  const width = Math.max(
+    40,
+    process.stdout && process.stdout.columns || 80
+  );
+  if (!label) {
+    return ansi.dim("\u2500".repeat(width));
   }
-  return util.inspect(value, { depth: 10, breakLength: Infinity, compact: false, sorted: true });
+  const plain = stripAnsiSimple(label);
+  const pad = Math.max(1, width - plain.length - 1);
+  return `${ansi.dim("\u2500".repeat(pad))} ${label}`;
 };
 var drawFailLine = () => {
   const width = Math.max(
@@ -4133,9 +4502,29 @@ var drawFailLine = () => {
   return colorTokens.fail("\u2500".repeat(width));
 };
 var renderRunLine = (cwd) => `${colorTokens.runPill("RUN")} ${ansi.dim(cwd.replace(/\\/g, "/"))}`;
+var buildFileBadgeLine = (rel, failedCount) => failedCount > 0 ? `${colorTokens.failPill("FAIL")} ${ansi.white(rel)}` : `${colorTokens.passPill("PASS")} ${ansi.white(rel)}`;
+var buildPerFileOverview = (rel, assertions) => {
+  const out = [];
+  out.push(`${ansi.magenta(rel)} ${ansi.dim(`(${assertions.length})`)}`);
+  for (const assertion of assertions) {
+    const name = assertion.fullName;
+    if (assertion.status === "passed") {
+      out.push(`  ${colorTokens.pass("\u2713")} ${ansi.dim(name)}`);
+    } else if (assertion.status === "todo") {
+      out.push(`  ${colorTokens.todo("\u2610")} ${ansi.dim(name)} ${colorTokens.todo("[todo]")}`);
+    } else if (assertion.status === "pending") {
+      out.push(`  ${colorTokens.skip("\u2193")} ${ansi.dim(name)} ${colorTokens.skip("[skipped]")}`);
+    } else {
+      out.push(`  ${colorTokens.fail("\xD7")} ${ansi.white(name)}`);
+    }
+  }
+  out.push("");
+  return out;
+};
+var isObjectRecord = (value) => typeof value === "object" && value !== null;
 var colorStackLine = (line, projectHint) => {
   const plainLine = stripAnsiSimple(line);
-  if (!isStackLine(plainLine)) {
+  if (!/\s+at\s+/.test(plainLine)) {
     return plainLine;
   }
   const match = plainLine.match(/\(?([^\s()]+):(\d+):(\d+)\)?$/);
@@ -4151,298 +4540,144 @@ var colorStackLine = (line, projectHint) => {
     `(${coloredPath}${ansi.dim(":")}${ansi.white(`${lineNumber}:${columnNumber}`)})`
   );
 };
-var renderCodeFrame = (lines, start) => {
-  const out = [];
-  for (let i = start; i < lines.length; i += 1) {
-    const raw = stripAnsiSimple(lines[i]);
-    if (!raw.trim()) {
-      break;
-    }
-    if (/^\s*\^+\s*$/.test(raw)) {
-      out.push(`    ${colorTokens.fail(raw.trimEnd())}`);
-      continue;
-    }
-    const pointerMatch = raw.match(/^\s*>(\s*\d+)\s*\|\s?(.*)$/);
-    if (pointerMatch) {
-      const num = ansi.dim(pointerMatch[1].trim());
-      const code = ansi.yellow(pointerMatch[2] ?? "");
-      out.push(`    ${colorTokens.fail(">")} ${num} ${ansi.dim("|")} ${code}`);
-      continue;
-    }
-    const normalMatch = raw.match(/^\s*(\d+)\s*\|\s?(.*)$/);
-    if (normalMatch) {
-      const num = ansi.dim(normalMatch[1]);
-      const code = ansi.dim(normalMatch[2] ?? "");
-      out.push(`      ${num} ${ansi.dim("|")} ${code}`);
-      continue;
-    }
-    out.push(`    ${raw}`);
+var extractBridgePath = (raw, cwd) => {
+  const re = /Test results written to:\s+([^\n\r]+jest-bridge-[^\s'"]+\.json)/g;
+  const matches = Array.from(raw.matchAll(re));
+  if (matches.length === 0) {
+    return null;
   }
-  return out;
+  const jsonPath = (matches[matches.length - 1][1] ?? "").trim().replace(/^["'`]|["'`]$/g, "");
+  return /^\//.test(jsonPath) ? jsonPath : `${cwd.replace(/\\/g, "/")}/${jsonPath}`;
 };
+var findCodeFrameStart = (lines) => lines.findIndex((line) => /^\s*(>?\s*\d+\s*\|)/.test(stripAnsiSimple(line)));
 var _sourceCache = /* @__PURE__ */ new Map();
 var readSource = (file) => {
-  const normalizedFile = file.replace(/\\/g, "/");
-  const cached = _sourceCache.get(normalizedFile);
-  if (cached) {
-    return cached;
+  const normalized = file.replace(/\\/g, "/");
+  const hit = _sourceCache.get(normalized);
+  if (hit) {
+    return hit;
   }
   try {
-    const txt = fs4.readFileSync(normalizedFile, "utf8");
-    const arr = txt.split(/\r?\n/);
-    _sourceCache.set(normalizedFile, arr);
+    const arr = fs4.readFileSync(normalized, "utf8").split(/\r?\n/);
+    _sourceCache.set(normalized, arr);
     return arr;
   } catch {
     return [];
   }
 };
+var renderInlineCodeFrame = (lines, start) => {
+  const out = [];
+  for (let i = start; i < lines.length; i += 1) {
+    const raw = stripAnsiSimple(lines[i]);
+    if (!raw.trim()) {
+      break;
+    }
+    if (/^\s*\^+\s*$/.test(raw)) {
+      out.push(`    ${Colors.Failure(raw.trimEnd())}`);
+    } else {
+      const ptr = raw.match(/^\s*>(\s*\d+)\s*\|\s?(.*)$/);
+      if (ptr) {
+        const num = ansi.dim(ptr[1].trim());
+        const code = ansi.yellow(ptr[2] ?? "");
+        out.push(`    ${Colors.Failure(">")} ${num} ${ansi.dim("|")} ${code}`);
+      } else {
+        const nor = raw.match(/^\s*(\d+)\s*\|\s?(.*)$/);
+        if (nor) {
+          const num = ansi.dim(nor[1]);
+          const code = ansi.dim(nor[2] ?? "");
+          out.push(`      ${num} ${ansi.dim("|")} ${code}`);
+        } else {
+          out.push(`    ${raw}`);
+        }
+      }
+    }
+  }
+  return out;
+};
 var renderSourceCodeFrame = (file, line, context = 3) => {
   const lines = readSource(file);
-  if (!lines.length || !Number.isFinite(line)) {
+  if (lines.length === 0 || !Number.isFinite(line)) {
     return [];
   }
   const idx = Math.max(1, Math.min(line, lines.length));
   const start = Math.max(1, idx - context);
   const end = Math.min(lines.length, idx + context);
   const out = [];
-  for (let currentLineNumber = start; currentLineNumber <= end; currentLineNumber += 1) {
-    const num = ansi.dim(String(currentLineNumber));
-    const code = currentLineNumber === idx ? ansi.yellow(lines[currentLineNumber - 1] ?? "") : ansi.dim(lines[currentLineNumber - 1] ?? "");
-    if (currentLineNumber === idx) {
-      out.push(`    ${colorTokens.fail(">")} ${num} ${ansi.dim("|")} ${code}`);
+  for (let current = start; current <= end; current += 1) {
+    const num = ansi.dim(String(current));
+    const code = current === idx ? ansi.yellow(lines[current - 1] ?? "") : ansi.dim(lines[current - 1] ?? "");
+    if (current === idx) {
+      out.push(`    ${Colors.Failure(">")} ${num} ${ansi.dim("|")} ${code}`);
     } else {
       out.push(`      ${num} ${ansi.dim("|")} ${code}`);
     }
   }
-  out.push(`    ${colorTokens.fail("^")}`);
+  out.push(`    ${Colors.Failure("^")}`);
   return out;
 };
-var findLastProjectFrameIndex = (lines, projectHint) => {
-  for (let i = lines.length - 1; i >= 0; i -= 1) {
-    const simple = stripAnsiSimple(lines[i]);
-    if (isStackLine(simple) && projectHint.test(simple) && !/node_modules|vitest|jest/.test(simple)) {
-      return i;
-    }
+var stackLocation = (line) => {
+  const match = stripAnsiSimple(line).match(/\(?([^\s()]+):(\d+):\d+\)?$/);
+  if (!match) {
+    return null;
   }
-  return -1;
+  return { file: match[1].replace(/\\/g, "/"), line: Number(match[2]) };
 };
-var renderStackTail = (lines, projectHint, max = 4) => {
-  const onlyStack = lines.filter((candidateLine) => isStackLine(stripAnsiSimple(candidateLine)));
-  if (!onlyStack.length) {
-    return [];
+var deepestProjectLoc = (stackLines, projectHint) => {
+  for (let i = stackLines.length - 1; i >= 0; i -= 1) {
+    const simple = stripAnsiSimple(stackLines[i]);
+    if (isStackLine(simple) && projectHint.test(simple) && !/node_modules|vitest|jest/.test(simple)) {
+      return stackLocation(stackLines[i]);
+    }
   }
-  const tail = onlyStack.slice(-max);
-  return tail.map((frameLine) => `      ${colorStackLine(frameLine, projectHint)}`);
-};
-var firstProjectFrames = (lines, projectHint, max = 2) => {
-  const onlyStack = lines.filter((ln) => isStackLine(stripAnsiSimple(ln)));
-  const projectOnly = onlyStack.filter((ln) => projectHint.test(stripAnsiSimple(ln)));
-  return projectOnly.slice(0, max).map((ln) => `      ${colorStackLine(ln, projectHint)}`);
+  return null;
 };
-var isTerminator = (lineText) => !lineText.trim() || isStackLine(lineText);
-var extractAssertionMessage = (msgLines) => {
-  const lines = msgLines.map((rawLine) => stripAnsiSimple(rawLine));
+var buildCodeFrameSection = (messageLines, ctx, synthLoc) => {
   const out = [];
-  const hintIdx = lines.findIndex(
-    (candidateLine) => /expect\(.+?\)\.(?:to|not\.)/.test(candidateLine) || /\b(?:AssertionError|Error):/.test(candidateLine)
-  );
-  if (hintIdx >= 0) {
-    out.push(lines[hintIdx]);
+  const start = findCodeFrameStart(messageLines);
+  if (start >= 0) {
+    out.push(...renderInlineCodeFrame(messageLines, start), "");
+    return out;
   }
-  const collectBlock = (start) => {
-    out.push(lines[start]);
-    for (let i = start + 1; i < lines.length; i += 1) {
-      const candidate = lines[i];
-      if (isTerminator(candidate)) {
-        break;
-      }
-      out.push(candidate);
-    }
-  };
-  const expectedIdx = lines.findIndex(
-    (candidateLine) => /^\s*Expected:/.test(candidateLine)
-  );
-  const receivedIdx = lines.findIndex(
-    (candidateLine) => /^\s*Received:/.test(candidateLine)
-  );
-  const diffIdx = lines.findIndex(
-    (candidateLine) => /^\s*(?:- Expected|\+ Received|Difference:)/.test(candidateLine)
-  );
-  if (expectedIdx >= 0) {
-    collectBlock(expectedIdx);
-  }
-  if (receivedIdx >= 0) {
-    collectBlock(receivedIdx);
-  }
-  if (diffIdx >= 0) {
-    collectBlock(diffIdx);
-  }
-  if (out.length === 0 && hintIdx >= 0) {
-    for (let i = hintIdx + 1; i < lines.length && out.length < 4; i += 1) {
-      const candidate = lines[i];
-      if (isTerminator(candidate)) {
-        break;
-      }
-      out.push(candidate);
-    }
+  if (ctx.showStacks && synthLoc) {
+    out.push(...renderSourceCodeFrame(synthLoc.file, synthLoc.line), "");
   }
   return out;
 };
-var stackLocation = (line) => {
-  const match = stripAnsiSimple(line).match(/\(?([^\s()]+):(\d+):\d+\)?$/);
-  return match ? { file: match[1].replace(/\\/g, "/"), line: Number(match[2]) } : null;
-};
-var JEST_BRIDGE_REPORTER_SOURCE = `const fs = require('fs');
-const path = require('path');
-
-class BridgeReporter {
-  constructor(globalConfig, options) {
-    this.out = process.env.JEST_BRIDGE_OUT || (options && options.outFile) || path.join(process.cwd(), 'coverage', 'jest-run.json');
-    this.buf = { startTime: Date.now(), testResults: [], aggregated: null };
-  }
-  onRunStart() { this.buf.startTime = Date.now(); }
-  onTestResult(_test, tr) {
-    const mapAssertion = (a) => ({
-      title: a.title,
-      fullName: a.fullName || [...(a.ancestorTitles || []), a.title].join(' '),
-      status: a.status,
-      duration: a.duration || 0,
-      location: a.location || null,
-      failureMessages: (a.failureMessages || []).map(String),
-    });
-    this.buf.testResults.push({
-      testFilePath: tr.testFilePath,
-      status: tr.numFailingTests ? 'failed' : 'passed',
-      failureMessage: tr.failureMessage || '',
-      failureDetails: tr.failureDetails || [],
-      console: tr.console || null,
-      perfStats: tr.perfStats || {},
-      testResults: (tr.testResults || []).map(mapAssertion),
-    });
-  }
-  onRunComplete(_contexts, agg) {
-    this.buf.aggregated = {
-      numTotalTestSuites: agg.numTotalTestSuites,
-      numPassedTestSuites: agg.numPassedTestSuites,
-      numFailedTestSuites: agg.numFailedTestSuites,
-      numTotalTests: agg.numTotalTests,
-      numPassedTests: agg.numPassedTests,
-      numFailedTests: agg.numFailedTests,
-      numPendingTests: agg.numPendingTests,
-      numTodoTests: agg.numTodoTests,
-      startTime: agg.startTime,
-      success: agg.success,
-      runTimeMs: agg.testResults.reduce((t, r) => t + Math.max(0, (r.perfStats?.end || 0) - (r.perfStats?.start || 0)), 0),
-    };
-    fs.mkdirSync(path.dirname(this.out), { recursive: true });
-    fs.writeFileSync(this.out, JSON.stringify(this.buf), 'utf8');
-  }
-}
-module.exports = BridgeReporter;`;
-var asDict = (value) => value && typeof value === "object" ? value : null;
-var get = (objectValue, key) => objectValue ? objectValue[key] : void 0;
-var getStr = (objectValue, key) => {
-  const candidate = get(objectValue, key);
-  return typeof candidate === "string" ? candidate : void 0;
-};
-function linesFromDetails(details) {
-  const stacks = [];
-  const messages = [];
-  if (!details) {
-    return { stacks, messages };
-  }
-  const pushMaybe = (value, bucket) => {
-    if (typeof value === "string" && value.trim()) {
-      bucket.push(...value.split(/\r?\n/));
-    }
-  };
-  for (const detail of details) {
-    if (typeof detail === "string") {
-      if (/\s+at\s.+\(.+:\d+:\d+\)/.test(detail)) {
-        pushMaybe(detail, stacks);
-      } else {
-        pushMaybe(detail, messages);
-      }
-      continue;
-    }
-    const dict = asDict(detail);
-    if (dict) {
-      pushMaybe(getStr(dict, "stack"), stacks);
-      pushMaybe(getStr(dict, "message"), messages);
-      const err = asDict(get(dict, "error"));
-      pushMaybe(getStr(err, "stack"), stacks);
-      pushMaybe(getStr(err, "message"), messages);
-      const matcherResult = asDict(get(dict, "matcherResult"));
-      pushMaybe(getStr(matcherResult, "stack"), stacks);
-      pushMaybe(getStr(matcherResult, "message"), messages);
-      pushMaybe(getStr(matcherResult, "expected"), messages);
-      pushMaybe(getStr(matcherResult, "received"), messages);
-    }
-  }
-  return { stacks, messages };
-}
-function labelForMessage(lines) {
-  const joined = lines.join(" ");
-  const matched = joined.match(/\b(TypeError|ReferenceError|SyntaxError|RangeError|AssertionError)\b/) || joined.match(/\bError\b/);
-  if (matched) {
-    const typeName = matched[1] ?? "Error";
-    return `${typeName}:`;
-  }
-  return /expect\(.+?\)\.(?:to|not\.)/.test(joined) ? "Assertion:" : "Message:";
-}
-function extractExpectedReceived(details, lines) {
-  if (details) {
-    for (const detail of details) {
-      const dict = asDict(detail);
-      const matcherResult = dict && asDict(get(dict, "matcherResult"));
-      if (matcherResult) {
-        const expected = get(matcherResult, "expected");
-        const received = get(matcherResult, "received");
-        if (expected !== void 0 || received !== void 0) {
-          return { expected, received };
-        }
-      }
+var normalizeBlock = (raw) => raw.replace(/^\s*Array\s*\[/, "[").replace(/^\s*Object\s*\{/, "{").replace(/,(\s*[\]}])/g, "$1");
+var stringifyPrettierish = (value) => {
+  if (typeof value === "string") {
+    const text = normalizeBlock(value.trim());
+    try {
+      const parsed = import_json5.default.parse(text);
+      return JSON.stringify(parsed, null, 2);
+    } catch {
+      return value;
     }
   }
-  if (lines && lines.length) {
-    const expectedLines = [];
-    const receivedLines = [];
-    let mode = "none";
-    for (const rawLine of lines) {
-      const simple = stripAnsiSimple(rawLine);
-      if (/^\s*Expected:/.test(simple)) {
-        mode = "exp";
-        expectedLines.push(simple.replace(/^\s*Expected:\s*/, ""));
-        continue;
-      }
-      if (/^\s*Received:/.test(simple)) {
-        mode = "rec";
-        receivedLines.push(simple.replace(/^\s*Received:\s*/, ""));
-        continue;
-      }
-      if (/^\s*[-+]\s/.test(simple)) {
-        continue;
-      }
-      if (!simple.trim()) {
-        mode = "none";
-      } else if (mode === "exp") {
-        expectedLines.push(simple);
-      } else if (mode === "rec") {
-        receivedLines.push(simple);
-      }
-    }
-    if (expectedLines.length || receivedLines.length) {
-      return { expected: expectedLines.join("\n"), received: receivedLines.join("\n") };
-    }
-    const unified = extractFromUnifiedDiff(lines);
-    if (unified.expected !== void 0 || unified.received !== void 0) {
-      return unified;
+  if (Array.isArray(value) || isObjectRecord(value)) {
+    try {
+      return JSON.stringify(value, null, 2);
+    } catch {
+      return util.inspect(value, {
+        depth: 10,
+        breakLength: Infinity,
+        compact: false,
+        sorted: true
+      });
     }
   }
-  return {};
-}
-function extractFromUnifiedDiff(rawLines) {
-  const lines = rawLines.map((lineText) => stripAnsiSimple(lineText));
+  return util.inspect(value, {
+    depth: 10,
+    breakLength: Infinity,
+    compact: false,
+    sorted: true
+  });
+};
+var isArrayOfPrimitives = (value) => Array.isArray(value) && value.every(
+  (element) => ["string", "number", "boolean"].includes(typeof element) || element === null
+);
+var extractFromUnifiedDiff = (rawLines) => {
+  const lines = (rawLines ?? []).map((lineText) => stripAnsiSimple(lineText));
   let startIndex = -1;
   for (let i = 0; i < lines.length; i += 1) {
     const lt = lines[i];
@@ -4489,12 +4724,10 @@ function extractFromUnifiedDiff(rawLines) {
       receivedParts.push(unsigned);
     }
     if (!expDone && expectedParts.length > 0) {
-      const expJoined = expectedParts.join("\n");
-      expDone = canParseJsonish(expJoined);
+      expDone = canParseJsonish(expectedParts.join("\n"));
     }
     if (!recDone && receivedParts.length > 0) {
-      const recJoined = receivedParts.join("\n");
-      recDone = canParseJsonish(recJoined);
+      recDone = canParseJsonish(receivedParts.join("\n"));
     }
     if (opened && expDone && recDone) {
       break;
@@ -4524,32 +4757,108 @@ function extractFromUnifiedDiff(rawLines) {
     result.received = recStr;
   }
   return result;
-}
-function renderPrettyDiff(payload) {
-  const out = [];
-  const { expected, received } = payload;
-  if (expected === void 0 && received === void 0) {
-    return out;
+};
+var extractExpectedReceived = (details, lines) => {
+  if (details) {
+    for (const detail of details) {
+      const dict = isObjectRecord(detail) ? detail : void 0;
+      const matcher = dict && isObjectRecord(dict.matcherResult) ? dict.matcherResult : void 0;
+      if (matcher) {
+        const expectedValue = matcher.expected;
+        const receivedValue = matcher.received;
+        const matcherName = String(
+          matcher.matcherName || ""
+        );
+        if (matcherName === "toHaveBeenCalledTimes" || matcherName === "toBeCalledTimes") {
+          const getCallsCount = (actual) => {
+            if (isObjectRecord(actual) && Array.isArray(actual.calls)) {
+              return actual.calls.length;
+            }
+            if (typeof actual === "number") {
+              return actual;
+            }
+            if (Array.isArray(actual)) {
+              return actual.length;
+            }
+            return void 0;
+          };
+          const expectedNumber = getCallsCount(expectedValue);
+          const actualValue = matcher.actual ?? receivedValue;
+          const receivedNumber = getCallsCount(actualValue);
+          if (expectedNumber !== void 0 || receivedNumber !== void 0) {
+            return { expected: expectedNumber, received: receivedNumber };
+          }
+        }
+        if (expectedValue !== void 0 && receivedValue !== void 0) {
+          return { expected: expectedValue, received: receivedValue };
+        }
+      }
+    }
+  }
+  if (lines && lines.length) {
+    const expectedLines = [];
+    const receivedLines = [];
+    let mode = "none";
+    for (const rawLine of lines) {
+      const simple = stripAnsiSimple(rawLine);
+      if (/^\s*Expected:/.test(simple)) {
+        mode = "exp";
+        expectedLines.push(simple.replace(/^\s*Expected:\s*/, ""));
+        continue;
+      }
+      if (/^\s*Received:/.test(simple)) {
+        mode = "rec";
+        receivedLines.push(simple.replace(/^\s*Received:\s*/, ""));
+        continue;
+      }
+      if (/^\s*[-+]\s/.test(simple)) {
+        continue;
+      }
+      if (!simple.trim()) {
+        mode = "none";
+      } else if (mode === "exp") {
+        expectedLines.push(simple);
+      } else if (mode === "rec") {
+        receivedLines.push(simple);
+      }
+    }
+    if (expectedLines.length || receivedLines.length) {
+      return { expected: expectedLines.join("\n"), received: receivedLines.join("\n") };
+    }
+    const unified = extractFromUnifiedDiff(lines);
+    if (unified.expected !== void 0 || unified.received !== void 0) {
+      return unified;
+    }
   }
-  const expectedString = stringifyPrettierish(expected);
-  const receivedString = stringifyPrettierish(received);
+  return {};
+};
+var buildPrettyDiffSection = (details, messageLines) => {
+  const payload = extractExpectedReceived(details, messageLines);
+  if (payload.expected === void 0 && payload.received === void 0) {
+    return [];
+  }
+  const expectedString = stringifyPrettierish(payload.expected);
+  const receivedString = stringifyPrettierish(payload.received);
+  const out = [];
+  const expectedLenLabel = Array.isArray(payload.expected) ? ansi.dim(` (len ${payload.expected.length})`) : "";
+  out.push(`    ${ansi.bold("Expected")}${expectedLenLabel}`);
   out.push(
-    `    ${ansi.bold("Expected")} ${ansi.dim(
-      expected && Array.isArray(expected) ? `(len ${expected.length})` : ""
-    )}`
+    expectedString.split("\n").map((expectedLine) => `      ${Colors.Success(expectedLine)}`).join("\n")
   );
-  out.push(indentBlock(colorTokens.pass(expectedString)));
+  const receivedLenLabel = Array.isArray(payload.received) ? ansi.dim(` (len ${payload.received.length})`) : "";
+  out.push(`    ${ansi.bold("Received")}${receivedLenLabel}`);
   out.push(
-    `    ${ansi.bold("Received")} ${ansi.dim(
-      received && Array.isArray(received) ? `(len ${received.length})` : ""
-    )}`
+    receivedString.split("\n").map((receivedLine) => `      ${Colors.Failure(receivedLine)}`).join("\n")
   );
-  out.push(indentBlock(colorTokens.fail(receivedString)));
-  if (isArrayOfPrimitives(expected) && isArrayOfPrimitives(received)) {
-    const expectedSet = new Set(expected.map((element) => String(element)));
-    const receivedSet = new Set(received.map((element) => String(element)));
-    const missing = [...expectedSet].filter((element) => !receivedSet.has(element));
-    const unexpected = [...receivedSet].filter((element) => !expectedSet.has(element));
+  if (isArrayOfPrimitives(payload.expected) && isArrayOfPrimitives(payload.received)) {
+    const expectedSet = new Set(
+      payload.expected.map((element) => String(element))
+    );
+    const receivedSet = new Set(
+      payload.received.map((element) => String(element))
+    );
+    const missing = Array.from(expectedSet).filter((element) => !receivedSet.has(element));
+    const unexpected = Array.from(receivedSet).filter((element) => !expectedSet.has(element));
     const parts = [];
     if (missing.length) {
       parts.push(
@@ -4562,67 +4871,85 @@ function renderPrettyDiff(payload) {
       );
     }
     if (parts.length) {
-      out.push(`    ${ansi.dim("Difference:")} ${colorTokens.fail(parts.join(ansi.dim(" | ")))}`);
+      out.push(`    ${ansi.dim("Difference:")} ${Colors.Failure(parts.join(ansi.dim(" | ")))}`);
     }
   }
   out.push("");
   return out;
-}
-function pickPrimaryMessage(candidateMessageLines, details) {
-  const extracted = extractAssertionMessage(candidateMessageLines);
-  if (extracted.length) {
-    return extracted;
-  }
-  const errorLine = details.messages.find(
-    (lineText) => /\b(?:Error|TypeError|ReferenceError|SyntaxError|RangeError|AssertionError)\b/.test(lineText)
+};
+var buildMessageSection = (messageLines, details, _ctx, opts) => {
+  const out = [];
+  const lines = messageLines.map((lineText) => stripAnsiSimple(lineText));
+  const hintIdx = lines.findIndex(
+    (candidate) => /expect\(.+?\)\.(?:to|not\.)/.test(candidate) || /\b(?:AssertionError|Error):/.test(candidate)
   );
-  if (errorLine) {
-    return [errorLine];
-  }
-  const firstNonEmpty = details.messages.find((lineText) => lineText.trim().length);
-  if (firstNonEmpty) {
-    return [firstNonEmpty];
-  }
-  return [];
-}
-function colorUnifiedDiffLine(simple) {
-  if (/^\s*-\s/.test(simple)) {
-    return colorTokens.fail(simple);
+  const acc = [];
+  if (hintIdx >= 0) {
+    acc.push(lines[hintIdx]);
   }
-  if (/^\s*\+\s/.test(simple)) {
-    return colorTokens.pass(simple);
+  const pushBlock = (start) => {
+    acc.push(lines[start]);
+    for (let i = start + 1; i < lines.length; i += 1) {
+      const candidate = lines[i];
+      if (!candidate.trim() || isStackLine(candidate)) {
+        break;
+      }
+      acc.push(candidate);
+    }
+  };
+  const expectedIdx = lines.findIndex((lineText) => /^\s*Expected:/.test(lineText));
+  const receivedIdx = lines.findIndex((lineText) => /^\s*Received:/.test(lineText));
+  const diffIdx = lines.findIndex(
+    (lineText) => /^\s*(?:- Expected|\+ Received|Difference:)/.test(lineText)
+  );
+  if (expectedIdx >= 0) {
+    pushBlock(expectedIdx);
   }
-  return simple;
-}
-var findCodeFrameStart = (lines) => lines.findIndex((line) => /^\s*(>?\s*\d+\s*\|)/.test(stripAnsiSimple(line)));
-var deepestProjectLoc = (stackLines, projectHint) => {
-  const idx = findLastProjectFrameIndex(stackLines, projectHint);
-  return idx >= 0 ? stackLocation(stackLines[idx]) : null;
-};
-var buildCodeFrameSection = (messageLines, ctx, synthLoc) => {
-  const lines = [];
-  const start = findCodeFrameStart(messageLines);
-  if (start >= 0) {
-    lines.push(...renderCodeFrame(messageLines, start), "");
-    return lines;
+  if (receivedIdx >= 0) {
+    pushBlock(receivedIdx);
   }
-  if (ctx.showStacks && synthLoc) {
-    lines.push(...renderSourceCodeFrame(synthLoc.file, synthLoc.line), "");
+  if (diffIdx >= 0) {
+    pushBlock(diffIdx);
   }
-  return lines;
-};
-var buildMessageSection = (messageLines, details, ctx, opts) => {
-  const out = [];
-  const primary = pickPrimaryMessage(messageLines, details);
-  const filtered = opts?.suppressDiff ? primary.filter((raw) => {
+  const filtered = opts?.suppressDiff ? acc.filter((raw) => {
     const simple = stripAnsiSimple(raw);
     return !/^\s*(Expected:|Received:|Difference:)\b/.test(simple) && !/^\s*[-+]\s/.test(simple) && !/^\s*(Array\s*\[|Object\s*\{)/.test(simple);
-  }) : primary;
-  if (filtered.length) {
-    const label = labelForMessage(filtered);
+  }) : acc;
+  const hasOnlyBareError = filtered.length === 0 || filtered.length === 1 && /^\s*(?:Error|AssertionError):?\s*$/.test(filtered[0] ?? "");
+  const fallbackLines = [];
+  if (hasOnlyBareError) {
+    const startFrom = hintIdx >= 0 ? hintIdx + 1 : 0;
+    for (let i = startFrom; i < lines.length; i += 1) {
+      const candidate = lines[i];
+      if (!candidate.trim()) {
+        break;
+      }
+      if (isStackLine(candidate)) {
+        break;
+      }
+      fallbackLines.push(candidate);
+    }
+    if (fallbackLines.length === 0 && details && details.messages && details.messages.length) {
+      fallbackLines.push(
+        ...details.messages.map((messageText) => stripAnsiSimple(messageText)).filter((messageText) => messageText.trim().length > 0).slice(0, 6)
+      );
+    }
+  }
+  if (filtered.length > 0) {
+    const label = (() => {
+      const joined = filtered.join(" ");
+      const matchResult = joined.match(/\b(TypeError|ReferenceError|SyntaxError|RangeError|AssertionError)\b/) || joined.match(/\bError\b/);
+      if (matchResult) {
+        const typeName = matchResult[1] ?? "Error";
+        return `${typeName}:`;
+      }
+      return /expect\(.+?\)\.(?:to|not\.)/.test(joined) ? "Assertion:" : "Message:";
+    })();
     out.push(`    ${ansi.bold(label)}`);
-    for (const lineText of filtered) {
-      out.push(`    ${ansi.yellow(colorUnifiedDiffLine(lineText))}`);
+    const body = hasOnlyBareError ? fallbackLines : filtered;
+    for (const lineText of body) {
+      const colored = /^\s*-\s/.test(lineText) ? Colors.Failure(lineText) : /^\s*\+\s/.test(lineText) ? Colors.Success(lineText) : lineText;
+      out.push(`    ${ansi.yellow(colored)}`);
     }
     if (opts?.stackPreview && opts.stackPreview.length) {
       for (const frame of opts.stackPreview) {
@@ -4633,32 +4960,85 @@ var buildMessageSection = (messageLines, details, ctx, opts) => {
   }
   return out;
 };
-function isConsoleEntry(candidate) {
-  return typeof candidate === "object" && candidate !== null;
-}
-var buildConsoleSection = (maybeConsole) => {
-  const out = [];
-  if (!Array.isArray(maybeConsole)) {
-    return out;
+var linesFromDetails = (details) => {
+  const stacks = [];
+  const messages = [];
+  if (!details) {
+    return { stacks, messages };
   }
-  const entries = maybeConsole.filter(isConsoleEntry);
-  const errorsOnly = entries.filter((entry) => {
-    const val = entry?.type;
-    return String(val ?? "").toLowerCase() === "error";
-  });
-  const scored = errorsOnly.map((entry) => {
-    const raw = entry?.message;
-    const msg = Array.isArray(raw) ? raw.map(String).join(" ") : typeof raw === "string" ? raw : String(raw ?? "");
-    return { msg, score: msg.length };
-  }).filter((item) => item.msg.trim().length > 0).sort((left, right) => right.score - left.score).slice(0, MAX_CONSOLE_ERRORS_TO_SHOW);
-  if (scored.length) {
-    out.push(ansi.dim("    Console errors:"));
-    for (const item of scored) {
-      out.push(`      ${ansi.dim("\u2022")} ${item.msg}`);
+  const pushMaybe = (value, bucket) => {
+    if (typeof value === "string" && value.trim()) {
+      bucket.push(...value.split(/\r?\n/));
+    }
+  };
+  const visitDeep = (value, depth) => {
+    if (depth > 3 || value == null) {
+      return;
+    }
+    if (typeof value === "string") {
+      pushMaybe(value, messages);
+      return;
+    }
+    if (typeof value !== "object") {
+      return;
+    }
+    const obj = value;
+    if (typeof obj.message === "string") {
+      pushMaybe(obj.message, messages);
+    }
+    if (typeof obj.stack === "string") {
+      pushMaybe(obj.stack, stacks);
+    }
+    if (typeof obj.expected === "string") {
+      pushMaybe(obj.expected, messages);
+    }
+    if (typeof obj.received === "string") {
+      pushMaybe(obj.received, messages);
+    }
+    const arrays = ["errors", "causes", "aggregatedErrors"];
+    for (const key of arrays) {
+      const arr = obj[key];
+      if (Array.isArray(arr)) {
+        for (const element of arr) {
+          visitDeep(element, depth + 1);
+        }
+      }
+    }
+    const nestedCandidates = ["error", "cause", "matcherResult"];
+    for (const key of nestedCandidates) {
+      if (obj[key] && typeof obj[key] === "object") {
+        visitDeep(obj[key], depth + 1);
+      }
+    }
+  };
+  for (const detail of details) {
+    if (typeof detail === "string") {
+      if (/\s+at\s.+\(.+:\d+:\d+\)/.test(detail)) {
+        pushMaybe(detail, stacks);
+      } else {
+        pushMaybe(detail, messages);
+      }
+    } else if (isObjectRecord(detail)) {
+      pushMaybe(detail.stack, stacks);
+      pushMaybe(detail.message, messages);
+      const err = isObjectRecord(detail.error) ? detail.error : void 0;
+      if (err) {
+        pushMaybe(err.stack, stacks);
+        pushMaybe(err.message, messages);
+      }
+      const matcher = isObjectRecord(detail.matcherResult) ? detail.matcherResult : void 0;
+      if (matcher) {
+        pushMaybe(matcher.stack, stacks);
+        pushMaybe(matcher.message, messages);
+        pushMaybe(matcher.expected, messages);
+        pushMaybe(matcher.received, messages);
+      }
+      if (messages.length === 0 && stacks.length === 0) {
+        visitDeep(detail, 0);
+      }
     }
-    out.push("");
   }
-  return out;
+  return { stacks, messages };
 };
 var buildStackSection = (mergedForStack, ctx, fallbackLoc) => {
   const out = [];
@@ -4667,13 +5047,18 @@ var buildStackSection = (mergedForStack, ctx, fallbackLoc) => {
     out.push(`      ${ansi.dim("(hidden by TEST_CLI_STACKS=)")}`, "");
     return out;
   }
-  const tail = renderStackTail(mergedForStack, ctx.projectHint, 4);
+  const onlyStack = mergedForStack.filter(
+    (lineText) => isStackLine(stripAnsiSimple(lineText))
+  );
+  const tail = onlyStack.slice(-4);
   if (tail.length) {
-    out.push(...tail);
+    for (const frameLine of tail) {
+      out.push(`      ${colorStackLine(String(frameLine), ctx.projectHint)}`);
+    }
     const loc = deepestProjectLoc(mergedForStack, ctx.projectHint);
     if (loc) {
       const href = preferredEditorHref(loc.file, loc.line, ctx.editorCmd);
-      out.push(`      ${ansi.dim("at")} ${osc8(`${path9.basename(loc.file)}:${loc.line}`, href)}`);
+      out.push(`      ${ansi.dim("at")} ${osc8(`${loc.file.split("/").pop()}:${loc.line}`, href)}`);
     }
     out.push("");
     return out;
@@ -4688,171 +5073,460 @@ var buildStackSection = (mergedForStack, ctx, fallbackLoc) => {
   out.push(`      ${ansi.dim("(no stack provided)")}`, "");
   return out;
 };
-var buildFileBadgeLine = (rel, failedCount) => failedCount > 0 ? `${colorTokens.failPill("FAIL")} ${ansi.white(rel)}` : `${colorTokens.passPill("PASS")} ${ansi.white(rel)}`;
-var buildPerFileOverview = (rel, assertions) => {
+var MAX_CONSOLE_ERRORS_TO_SHOW = 3;
+var isConsoleEntry = (candidate) => typeof candidate === "object" && candidate !== null;
+var buildConsoleSection = (maybeConsole) => {
   const out = [];
-  out.push(`${ansi.magenta(rel)} ${ansi.dim(`(${assertions.length})`)}`);
-  for (const assertion of assertions) {
-    const name = assertion.fullName;
-    if (assertion.status === "passed") {
-      out.push(`  ${colorTokens.pass("\u2713")} ${ansi.dim(name)}`);
-    } else if (assertion.status === "todo") {
-      out.push(`  ${colorTokens.todo("\u2610")} ${ansi.dim(name)} ${colorTokens.todo("[todo]")}`);
-    } else if (assertion.status === "pending") {
-      out.push(`  ${colorTokens.skip("\u2193")} ${ansi.dim(name)} ${colorTokens.skip("[skipped]")}`);
-    } else {
-      out.push(`  ${colorTokens.fail("\xD7")} ${ansi.white(name)}`);
+  if (!Array.isArray(maybeConsole)) {
+    return out;
+  }
+  const entries = maybeConsole.filter(isConsoleEntry);
+  const errorsOnly = entries.filter((entry) => String(entry?.type ?? "").toLowerCase() === "error");
+  const scored = errorsOnly.map((entry) => {
+    const raw = entry?.message;
+    const msg = Array.isArray(raw) ? raw.map(String).join(" ") : typeof raw === "string" ? raw : String(raw ?? "");
+    return { msg, score: msg.length };
+  }).filter((item) => item.msg.trim().length > 0).sort((left, right) => right.score - left.score).slice(0, MAX_CONSOLE_ERRORS_TO_SHOW);
+  if (scored.length) {
+    out.push(ansi.dim("    Console errors:"));
+    for (const item of scored) {
+      out.push(`      ${ansi.dim("\u2022")} ${item.msg}`);
     }
+    out.push("");
   }
-  out.push("");
   return out;
 };
-var formatJestOutputVitest = (raw, opts) => {
-  const showStacks = Boolean(env.TEST_CLI_STACKS);
-  const cwd = (opts?.cwd ?? process.cwd()).replace(/\\/g, "/");
-  const projectHint = new RegExp(
-    `(${cwd.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\$&")})|(/gigworx-node/)`
+var buildFallbackMessageBlock = (messageLines, details) => {
+  const normalize2 = (arr) => arr.map((lineText) => stripAnsiSimple(lineText)).filter((line) => line.trim().length > 0);
+  const normalized = normalize2(messageLines);
+  const informative = normalized.filter((line) => !/^\s*(?:Error|AssertionError):?\s*$/.test(line));
+  if (informative.length > 0) {
+    return [];
+  }
+  const errorIdx = normalized.findIndex(
+    (line) => /(TypeError|ReferenceError|SyntaxError|RangeError|AssertionError|Error):?/.test(line)
   );
-  const onlyFailures = Boolean(opts?.onlyFailures);
-  const lines = raw.split(/\r?\n/);
+  const collected = [];
+  if (errorIdx >= 0) {
+    for (let i = errorIdx; i < normalized.length && collected.length < 8; i += 1) {
+      const ln = normalized[i];
+      if (!ln.trim()) {
+        break;
+      }
+      if (isStackLine(ln)) {
+        break;
+      }
+      collected.push(ln);
+    }
+  }
+  const fromDetails = collected.length > 0 ? [] : normalize2(details.messages).slice(0, 6);
+  const linesToShow = collected.length > 0 ? collected : fromDetails;
+  if (linesToShow.length === 0) {
+    return [];
+  }
   const out = [];
-  const seenFailures = /* @__PURE__ */ new Set();
-  const seenFiles = /* @__PURE__ */ new Set();
-  for (let lineIndex = 0; lineIndex < lines.length; ) {
-    const ln = stripAnsiSimple(lines[lineIndex]);
-    if (/^\s*●\s+/.test(ln)) {
-      const title = ln.replace(/^\s*●\s+/, "").trim();
-      const block = [lines[lineIndex]];
-      let scanIndex = lineIndex + 1;
-      while (scanIndex < lines.length) {
-        const scanLine = stripAnsiSimple(lines[scanIndex]);
-        const nextIsStart = /^\s*●\s+/.test(scanLine) || /^\s*(PASS|FAIL)\s/.test(scanLine) || /^\s*Test Suites:/.test(scanLine);
-        if (nextIsStart && stripAnsiSimple(lines[scanIndex - 1] ?? "").trim() === "") {
-          break;
-        }
-        block.push(lines[scanIndex]);
-        scanIndex += 1;
+  out.push(`    ${ansi.bold("Message:")}`);
+  for (const lineText of linesToShow) {
+    out.push(`    ${ansi.yellow(lineText)}`);
+  }
+  out.push("");
+  return out;
+};
+var buildThrownSection = (details) => {
+  const toLines = (value) => {
+    if (value == null) {
+      return [];
+    }
+    if (typeof value === "string") {
+      return value.split(/\r?\n/);
+    }
+    try {
+      return JSON.stringify(value, null, 2).split(/\r?\n/);
+    } catch {
+      return [String(value)];
+    }
+  };
+  const candidates = [];
+  for (const d of details) {
+    const obj = d && typeof d === "object" ? d : null;
+    if (obj && obj.error && typeof obj.error === "object") {
+      const err = obj.error;
+      if (typeof err.name === "string") {
+        candidates.push(`name: ${err.name}`);
       }
-      const codeFrameStart = block.findIndex(
-        (candidateLine) => /^\s*(>?\s*\d+\s*\|)/.test(stripAnsiSimple(candidateLine))
-      );
-      const location = firstTestLocation(block, projectHint);
-      const rel = location ? location.split(":")[0].replace(/\\/g, "/").replace(`${cwd}/`, "") : "";
-      const key = `${rel}|${title}`;
-      if (seenFailures.has(key)) {
-        lineIndex = scanIndex;
+      if (typeof err.message === "string") {
+        candidates.push(`message: ${err.message}`);
+      }
+      if (typeof err.code === "string" || typeof err.code === "number") {
+        candidates.push(`code: ${String(err.code)}`);
+      }
+      if (typeof err.cause === "string") {
+        candidates.push(`cause: ${err.cause}`);
+      }
+      if (err.cause && typeof err.cause === "object") {
+        candidates.push("cause:");
+        candidates.push(...toLines(err.cause));
+      }
+      const rest = { ...err };
+      delete rest.name;
+      delete rest.message;
+      delete rest.code;
+      delete rest.stack;
+      if (Object.keys(rest).length > 0) {
+        candidates.push("details:");
+        candidates.push(...toLines(rest));
+      }
+    }
+  }
+  if (!candidates.length) {
+    return [];
+  }
+  const out = [];
+  out.push(`    ${ansi.bold("Thrown:")}`);
+  for (const line of candidates.slice(0, 50)) {
+    out.push(`    ${ansi.yellow(line)}`);
+  }
+  out.push("");
+  return out;
+};
+var mkPrettyFns = () => ({
+  drawRule,
+  drawFailLine,
+  renderRunLine,
+  buildPerFileOverview,
+  buildFileBadgeLine,
+  extractBridgePath,
+  buildCodeFrameSection,
+  buildMessageSection,
+  buildPrettyDiffSection,
+  buildStackSection,
+  deepestProjectLoc,
+  findCodeFrameStart,
+  linesFromDetails,
+  buildFallbackMessageBlock,
+  buildThrownSection
+});
+
+// src/lib/formatter/render.ts
+var relPath = (abs, cwd) => abs.replace(/\\/g, "/").replace(`${cwd}/`, "");
+var renderChunks = (chunks, ctx, fns, opts) => {
+  const out = [];
+  const seenFiles = /* @__PURE__ */ new Set();
+  const seenFailures = /* @__PURE__ */ new Set();
+  const onlyFailures = Boolean(opts?.onlyFailures);
+  let currentRelFile = null;
+  const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  for (const ch of chunks) {
+    if (ch.tag === "PassFail") {
+      const rel = relPath(ch.rel, ctx.cwd);
+      if (seenFiles.has(rel)) {
         continue;
       }
-      seenFailures.add(key);
-      out.push(drawFailLine());
-      const header = `${colorTokens.fail("\xD7")} ${ansi.white(rel ? `${rel} > ${title}` : title)}`;
-      out.push(header);
-      const linesBlock = block.map(String);
-      const collapsedForSrc = collapseStacks(linesBlock.slice(0));
-      if (codeFrameStart >= 0) {
-        out.push("");
-        out.push(...renderCodeFrame(linesBlock, codeFrameStart));
-        out.push("");
-      } else if (showStacks) {
-        const deepestIdxForSrc = findLastProjectFrameIndex(collapsedForSrc, projectHint);
-        const locForSrc = deepestIdxForSrc >= 0 ? stackLocation(collapsedForSrc[deepestIdxForSrc]) : null;
-        if (locForSrc) {
-          out.push("");
-          out.push(...renderSourceCodeFrame(locForSrc.file, locForSrc.line));
-          out.push("");
-        }
-      }
-      const payload = extractExpectedReceived(void 0, linesBlock);
-      const hasPretty = payload.expected !== void 0 || payload.received !== void 0;
-      out.push(...renderPrettyDiff(payload));
-      const detailsForMsg = linesFromDetails(void 0);
-      const collapsedForTail = collapseStacks(linesBlock.slice(0));
-      const stackPreview = showStacks ? firstProjectFrames(collapsedForTail, projectHint, 2) : [];
+      seenFiles.add(rel);
+      currentRelFile = rel;
+      if (!(onlyFailures && ch.badge === "PASS")) {
+        out.push(fns.buildFileBadgeLine(rel, ch.badge === "FAIL" ? 1 : 0));
+      }
+      continue;
+    }
+    if (ch.tag === "FailureBlock") {
+      out.push(fns.drawFailLine());
+      const location = firstTestLocation(ch.lines, ctx.projectHint);
+      const rel = location ? relPath(location.split(":")[0] ?? "", ctx.cwd) : "";
+      const headerText = rel ? `${rel} > ${ch.title}` : ch.title;
+      out.push(`${Colors.Failure("\xD7")} ${ansi.white(headerText)}`);
+      const codeStart = fns.findCodeFrameStart(ch.lines);
+      const collapsedForSrc = collapseStacks(ch.lines.slice(0));
+      const deepestLoc = fns.deepestProjectLoc(collapsedForSrc, ctx.projectHint);
+      let effectiveLoc = deepestLoc;
+      if (!effectiveLoc && currentRelFile) {
+        try {
+          const abs = path9.resolve(ctx.cwd, currentRelFile);
+          const source = ctx.readSource(abs);
+          const testName = (() => {
+            const parts = ch.title.split(">");
+            return (parts[parts.length - 1] || ch.title).trim();
+          })();
+          const itRe = new RegExp(
+            String.raw`\b(?:it|test)\s*\(\s*['\"]${escapeRegExp(testName)}['\"]`
+          );
+          let index = source.findIndex((line) => itRe.test(line));
+          if (index < 0) {
+            index = source.findIndex((line) => /\bexpect\s*\(/.test(line));
+          } else {
+            const windowEnd = Math.min(source.length, index + 80);
+            for (let i = index; i < windowEnd; i += 1) {
+              if (/\bexpect\s*\(/.test(source[i])) {
+                index = i;
+                break;
+              }
+            }
+          }
+          if (index >= 0) {
+            effectiveLoc = { file: abs.replace(/\\/g, "/"), line: index + 1 };
+          }
+        } catch {
+        }
+      }
+      if (codeStart >= 0) {
+        out.push("", ...fns.buildCodeFrameSection(ch.lines, ctx, effectiveLoc), "");
+      } else {
+        out.push("", ...fns.buildCodeFrameSection(ch.lines, ctx, effectiveLoc), "");
+      }
+      const pretty = fns.buildPrettyDiffSection(void 0, ch.lines);
+      out.push(...pretty);
+      const hasPretty = pretty.length > 0;
+      const details = fns.linesFromDetails(void 0);
+      const minimal = (() => {
+        const plain = ch.lines.map((ln) => stripAnsiSimple(ln));
+        const hint = plain.findIndex(
+          (lineText) => /expect\(.+?\)\.(?:to|not\.)/.test(lineText) || /\bError:?\b/.test(lineText)
+        );
+        const acc = [];
+        const start = hint >= 0 ? hint : 0;
+        for (let i = start; i < plain.length; i += 1) {
+          const ln = plain[i];
+          if (!ln.trim()) {
+            break;
+          }
+          if (isStackLine(ln)) {
+            break;
+          }
+          acc.push(ln);
+        }
+        return acc;
+      })();
+      const collapsedForTail = collapseStacks(ch.lines.slice(0));
+      const stackPreview = ctx.showStacks ? collapsedForTail.filter((ln) => isStackLine(stripAnsiSimple(ln))).filter((ln) => ctx.projectHint.test(stripAnsiSimple(ln))).slice(0, 2).map((ln) => `      ${colorStackLine(String(ln), ctx.projectHint)}`) : [];
       out.push(
-        ...buildMessageSection(
-          linesBlock,
-          detailsForMsg,
-          { projectHint, editorCmd: opts?.editorCmd, showStacks },
-          { suppressDiff: hasPretty, stackPreview }
-        )
+        ...fns.buildMessageSection(minimal.length ? minimal : ch.lines, details, ctx, {
+          suppressDiff: hasPretty,
+          stackPreview
+        })
       );
-      if (showStacks && stackPreview.length === 0) {
-        const collapsed = collapseStacks(linesBlock.slice(0));
-        out.push(
-          ...buildStackSection(collapsed, {
-            projectHint,
-            editorCmd: opts?.editorCmd,
-            showStacks
-          })
-        );
+      if (minimal.length === 0 && fns.buildFallbackMessageBlock) {
+        out.push(...fns.buildFallbackMessageBlock(ch.lines, { messages: details.messages }));
       }
-      out.push(drawFailLine());
-      out.push("");
-      lineIndex = scanIndex;
-      continue;
-    }
-    const passFail = ln.match(/^\s*(PASS|FAIL)\s+(.+)$/);
-    if (passFail) {
-      const badge = passFail[1];
-      const fileAbs = passFail[2];
-      const rel = fileAbs.replace(/\\/g, "/").replace(`${cwd}/`, "");
-      if (seenFiles.has(rel)) {
-        lineIndex += 1;
-        continue;
+      const consoleInline = (() => {
+        const plain = ch.lines.map((ln) => stripAnsiSimple(ln));
+        const cand = plain.filter((ln) => /\bconsole\.(error|warn)\s*\(/i.test(ln) || /^\s*Error:/.test(ln)).map((ln) => ln.trim()).filter((ln) => ln.length > 0).sort((a, b) => b.length - a.length).slice(0, 3);
+        return cand;
+      })();
+      if (consoleInline.length > 0) {
+        out.push(ansi.dim("    Console errors:"), ...consoleInline.map((ln) => `      ${ln}`), "");
       }
-      seenFiles.add(rel);
-      if (!(onlyFailures && badge === "PASS")) {
-        const pill = badge === "PASS" ? colorTokens.passPill("PASS") : colorTokens.failPill("FAIL");
-        out.push(`${pill} ${ansi.white(rel)}`);
+      if (ctx.showStacks && fns.buildStackSection && stackPreview.length === 0) {
+        const collapsed = collapseStacks(ch.lines.slice(0));
+        out.push(...fns.buildStackSection(collapsed, ctx));
+      }
+      out.push(fns.drawFailLine(), "");
+      if (rel) {
+        seenFailures.add(`${rel}|${ch.title}`);
       }
-      lineIndex += 1;
       continue;
     }
-    if (/^\s*(Test Suites:|Tests:|Snapshots:|Time:|Ran all)/.test(ln)) {
-      out.push(lines[lineIndex]);
-      lineIndex += 1;
+    if (ch.tag === "Summary") {
+      out.push(ch.line);
       continue;
     }
-    if (isStackLine(ln)) {
-      if (showStacks) {
-        const kept = collapseStacks([lines[lineIndex]]);
-        out.push(...kept);
+    if (ch.tag === "Stack") {
+      if (ctx.showStacks) {
+        out.push(ch.line);
       }
-      lineIndex += 1;
       continue;
     }
-    out.push(lines[lineIndex]);
-    lineIndex += 1;
+    if (!onlyFailures) {
+      out.push(ch.line);
+    }
   }
-  const rendered = out.join("\n");
-  const hadParsedTests = seenFiles.size > 0 || seenFailures.size > 0 || out.some((lineText) => /^(?:\s*)(PASS|FAIL)\b/.test(stripAnsiSimple(lineText)));
-  if (!hadParsedTests) {
-    const bridgePath = extractBridgePath(raw, cwd);
-    if (bridgePath && fs4.existsSync(bridgePath)) {
-      try {
-        const json = JSON.parse(fs4.readFileSync(bridgePath, "utf8"));
-        const bridge = coerceJestJsonToBridge(json);
-        const renderedFromJson = renderVitestFromJestJSON(bridge, opts);
-        const prefix = out.join("\n");
-        return prefix ? `${prefix}
-${renderedFromJson}` : renderedFromJson;
-      } catch {
-      }
+  const hadParsed = seenFiles.size > 0 || seenFailures.size > 0 || out.some((lineText) => /^(?:\s*)(PASS|FAIL)\b/.test(stripAnsiSimple(lineText)));
+  return { text: out.join("\n"), hadParsed };
+};
+
+// src/lib/formatter/context.ts
+var fs5 = __toESM(require("node:fs"), 1);
+var makeCtx = (opts, showStacks = false) => {
+  const cwd = (opts?.cwd ?? process.cwd()).replace(/\\/g, "/");
+  const width = Math.max(
+    40,
+    process.stdout && process.stdout.columns || 80
+  );
+  const projectHint = new RegExp(
+    `(${cwd.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\$&")})|(/gigworx-node/)`
+  );
+  const readSource2 = (file) => {
+    try {
+      return fs5.readFileSync(file.replace(/\\/g, "/"), "utf8").split(/\r?\n/);
+    } catch {
+      return [];
     }
+  };
+  return { cwd, width, showStacks, projectHint, editorCmd: opts?.editorCmd, readSource: readSource2 };
+};
+
+// src/lib/formatter/bridge.ts
+var fs6 = __toESM(require("node:fs"), 1);
+var path10 = __toESM(require("node:path"), 1);
+var import_json52 = __toESM(require_lib(), 1);
+var colorTokens2 = {
+  pass: Colors.Success,
+  fail: Colors.Failure,
+  skip: Colors.Skip,
+  todo: Colors.Todo,
+  passPill: (text) => BackgroundColors.Success(ansi.white(` ${text} `)),
+  failPill: (text) => BackgroundColors.Failure(ansi.white(` ${text} `))
+};
+var by = (keySelector) => (left, right) => keySelector(left) - keySelector(right);
+var isObject = (candidateValue) => !!candidateValue && typeof candidateValue === "object";
+var asHttpList = (candidateValue) => Array.isArray(candidateValue) ? candidateValue : [];
+var summarizeUrl = (method, url, route) => {
+  const base = route || url || "";
+  const qs = url && url.includes("?") ? ` ? ${url.split("?")[1]}` : "";
+  return [method || "", base, qs].filter(Boolean).join(" ").trim();
+};
+var stripBridgeEventsFromConsole = (maybeConsole) => {
+  if (!Array.isArray(maybeConsole)) {
+    return maybeConsole;
   }
-  try {
-    const preview = rendered.split("\n").slice(0, 2).join("\n");
-    console.info(`formatJestOutputVitest: produced ${out.length} lines; preview:
-${preview}`);
-  } catch {
+  return maybeConsole.filter((entry) => {
+    try {
+      const raw = Array.isArray(entry.message) ? entry.message.map(String).join(" ") : String(entry.message ?? "");
+      return !raw.includes("[JEST-BRIDGE-EVENT]");
+    } catch {
+      return true;
+    }
+  });
+};
+var extractBridgePath2 = (raw, cwd) => {
+  const matches = Array.from(
+    raw.matchAll(/Test results written to:\s+([^\n\r]+jest-bridge-[^\s'"]+\.json)/g)
+  );
+  if (!matches.length) {
+    return null;
+  }
+  const jsonPath = (matches[matches.length - 1][1] ?? "").trim().replace(/^["'`]|["'`]$/g, "");
+  return path10.isAbsolute(jsonPath) ? jsonPath : path10.resolve(cwd, jsonPath).replace(/\\/g, "/");
+};
+var isTransportError = (msg) => {
+  const lowercaseMessage = (msg ?? "").toLowerCase();
+  return /\bsocket hang up\b|\beconnreset\b|\betimedout\b|\beconnrefused\b|\bwrite epipe\b/.test(
+    lowercaseMessage
+  );
+};
+var envNumber = (name, fallback) => {
+  const parsed = Number(process.env[name]);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+var HEADLAMP_HTTP_WINDOW_MS = () => envNumber("HEADLAMP_HTTP_WINDOW_MS", 3e3);
+var HEADLAMP_HTTP_STRICT_WINDOW_MS = () => envNumber("HEADLAMP_HTTP_STRICT_WINDOW_MS", 600);
+var HEADLAMP_HTTP_MIN_SCORE = () => envNumber("HEADLAMP_HTTP_MIN_SCORE", 1200);
+var HEADLAMP_HTTP_DIFF_LIMIT = () => envNumber("HEADLAMP_HTTP_DIFF_LIMIT", 6);
+var HEADLAMP_HTTP_SHOW_MISS = () => process.env.HEADLAMP_HTTP_MISS === "1";
+var eventsNear = (http, ts, testPath, windowMs = HEADLAMP_HTTP_WINDOW_MS()) => {
+  if (typeof ts !== "number" || !Number.isFinite(ts)) {
+    return [];
+  }
+  return http.filter((e) => {
+    const timeOk = typeof e.timestampMs === "number" && Math.abs(e.timestampMs - ts) <= windowMs;
+    const pathOk = !testPath || e.testPath === testPath;
+    return timeOk && pathOk;
+  });
+};
+var parseMethodPathFromTitle = (title) => {
+  if (!title) {
+    return {};
+  }
+  const matchResult = title.match(/\b(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+([^\s)]+)/i);
+  return matchResult ? { method: matchResult[1]?.toUpperCase(), path: matchResult[2] } : {};
+};
+var isHttpStatusNumber = (statusNumber) => typeof statusNumber === "number" && statusNumber >= 100 && statusNumber <= 599;
+var hasStatusSemantics = (assertionLike) => {
+  if (!assertionLike) {
+    return false;
   }
-  return rendered;
+  if (isHttpStatusNumber(assertionLike.expectedNumber) || isHttpStatusNumber(assertionLike.receivedNumber)) {
+    return true;
+  }
+  const combinedRaw = `${assertionLike.matcher ?? ""} ${assertionLike.message ?? ""}`;
+  const combinedMessage = combinedRaw.toLowerCase();
+  return /\bstatus(code)?\b|\btohaves(tatus|tatuscode)\b/.test(combinedMessage);
+};
+var fileSuggestsHttp = (relPath2) => /(?:^|\/)(routes?|api|controllers?|e2e|integration)(?:\/|\.test\.)/i.test(relPath2);
+var inferHttpNumbersFromText = (lines) => {
+  const text = lines.join("\n");
+  const match = text.match(/Expected:\s*(\d{3})[\s\S]*?Received:\s*(\d{3})/i);
+  if (match) {
+    return { expectedNumber: Number(match[1]), receivedNumber: Number(match[2]) };
+  }
+  return {};
+};
+var titleSuggestsHttp = (title) => {
+  const { method, path: parsedPath } = parseMethodPathFromTitle(title);
+  return Boolean(method || parsedPath && parsedPath.startsWith("/"));
+};
+var isHttpRelevant = (ctx) => {
+  const assertionCtx = ctx.assertion;
+  return ctx.hasTransportSignal || ctx.httpCountInSameTest > 0 || titleSuggestsHttp(ctx.title) || hasStatusSemantics(assertionCtx) || fileSuggestsHttp(ctx.relPath);
+};
+var routeSimilarityScore = (hint, evt) => {
+  if (!hint.path && !hint.method) {
+    return 0;
+  }
+  const methodOk = hint.method && evt.method ? Number(hint.method === evt.method) : 0;
+  const route = evt.route || evt.url || "";
+  if (!route) {
+    return methodOk * 10;
+  }
+  if (hint.path && route === hint.path) {
+    return 500 + methodOk * 50;
+  }
+  if (hint.path && route.endsWith(hint.path)) {
+    return 300 + methodOk * 50;
+  }
+  if (hint.path && route.includes(hint.path)) {
+    return 200 + methodOk * 50;
+  }
+  return methodOk * 10;
 };
-var isBridgeJSONLike = (candidate) => {
-  const candidateValue = candidate;
-  return typeof candidateValue === "object" && candidateValue !== null && "aggregated" in candidateValue;
+var scoreHttpForAssertion = (assertion, titleHint) => (candidateEvent) => {
+  const tsA = assertion.timestampMs;
+  const tsH = candidateEvent.timestampMs;
+  const window = isTransportError(assertion.message) ? HEADLAMP_HTTP_STRICT_WINDOW_MS() : HEADLAMP_HTTP_WINDOW_MS();
+  const timeScore = typeof tsA === "number" && typeof tsH === "number" ? Math.max(0, window - Math.abs(tsA - tsH)) : 0;
+  const statusScore = typeof assertion.receivedNumber === "number" && candidateEvent.statusCode === assertion.receivedNumber ? 1500 : typeof assertion.expectedNumber === "number" && candidateEvent.statusCode === assertion.expectedNumber ? 1200 : (candidateEvent.statusCode ?? 0) >= 400 ? 800 : 0;
+  const routeScore = routeSimilarityScore(titleHint, candidateEvent);
+  const specificity = candidateEvent.route ? 80 : candidateEvent.url ? 40 : 0;
+  return timeScore + statusScore + routeScore + specificity;
+};
+var pickRelevantHttp = (assertion, http, ctx) => {
+  const hint = parseMethodPathFromTitle(ctx.title);
+  const nameMatches = (leftName, rightName) => !!leftName && !!rightName && (leftName === rightName || leftName.includes(rightName) || rightName.includes(leftName));
+  const sameTest = (leftCtx, rightCtx) => !!leftCtx && !!rightCtx && leftCtx.testPath === rightCtx.testPath && nameMatches(leftCtx.currentTestName, rightCtx.currentTestName);
+  const strictPool = http.filter(
+    (httpEvent) => sameTest(assertion, httpEvent) || sameTest(ctx, httpEvent)
+  );
+  const windowMs = isTransportError(assertion.message) ? HEADLAMP_HTTP_STRICT_WINDOW_MS() : HEADLAMP_HTTP_WINDOW_MS();
+  let pool = strictPool;
+  if (!pool.length) {
+    pool = http.filter(
+      (e) => e.testPath === ctx.testPath && typeof assertion.timestampMs === "number" && typeof e.timestampMs === "number" && Math.abs(e.timestampMs - assertion.timestampMs) <= windowMs
+    );
+  }
+  if (!pool.length) {
+    pool = http.filter(
+      (e) => typeof assertion.timestampMs === "number" && typeof e.timestampMs === "number" && Math.abs(e.timestampMs - assertion.timestampMs) <= windowMs
+    );
+  }
+  if (!pool.length) {
+    return void 0;
+  }
+  const scored = pool.map((httpEvent) => ({ h: httpEvent, s: scoreHttpForAssertion(assertion, hint)(httpEvent) })).sort((leftScore, rightScore) => rightScore.s - leftScore.s);
+  const [best] = scored;
+  const threshold = isTransportError(assertion.message) ? Math.max(HEADLAMP_HTTP_MIN_SCORE(), 1400) : HEADLAMP_HTTP_MIN_SCORE();
+  return best && best.s >= threshold ? best.h : void 0;
 };
-function coerceJestJsonToBridge(raw) {
+var isBridgeJSONLike = (candidateValue) => !!candidateValue && typeof candidateValue === "object" && "aggregated" in candidateValue;
+var coerceJestJsonToBridge = (raw) => {
   if (isBridgeJSONLike(raw)) {
     return raw;
   }
@@ -4862,18 +5536,21 @@ function coerceJestJsonToBridge(raw) {
   }
   return {
     startTime: Number(j.startTime ?? Date.now()),
-    testResults: j.testResults.map((testFileResult) => ({
-      testFilePath: testFileResult.testFilePath || testFileResult.name || "",
-      status: testFileResult.status,
-      failureMessage: testFileResult.failureMessage || "",
-      failureDetails: testFileResult.failureDetails ?? [],
-      testResults: (testFileResult.assertionResults || []).map((assertion) => ({
+    testResults: j.testResults.map((tr) => ({
+      testFilePath: tr.testFilePath || tr.name || "",
+      status: tr.status,
+      failureMessage: tr.failureMessage || "",
+      failureDetails: tr.failureDetails ?? [],
+      testExecError: tr.testExecError ?? null,
+      console: tr.console ?? null,
+      testResults: (tr.assertionResults || []).map((assertion) => ({
         title: assertion.title,
         fullName: assertion.fullName || [...assertion.ancestorTitles || [], assertion.title].join(" "),
         status: assertion.status,
         duration: assertion.duration || 0,
         location: assertion.location ?? null,
-        failureMessages: assertion.failureMessages || []
+        failureMessages: assertion.failureMessages || [],
+        failureDetails: assertion.failureDetails || []
       }))
     })),
     aggregated: {
@@ -4889,21 +5566,20 @@ function coerceJestJsonToBridge(raw) {
       success: j.success
     }
   };
-}
-var vitestFooter = (agg, _startedAt, durationMs) => {
+};
+var vitestFooter = (agg, durationMs) => {
   const files = [
-    agg.numFailedTestSuites ? colorTokens.fail(`${agg.numFailedTestSuites} failed`) : "",
-    agg.numPassedTestSuites ? colorTokens.pass(`${agg.numPassedTestSuites} passed`) : "",
-    agg.numPendingTests ? colorTokens.skip(`${agg.numPendingTests} skipped`) : ""
+    agg.numFailedTestSuites ? colorTokens2.fail(`${agg.numFailedTestSuites} failed`) : "",
+    agg.numPassedTestSuites ? colorTokens2.pass(`${agg.numPassedTestSuites} passed`) : "",
+    agg.numPendingTests ? colorTokens2.skip(`${agg.numPendingTests} skipped`) : ""
   ].filter(Boolean).join(ansi.dim(" | "));
   const tests = [
-    agg.numFailedTests ? colorTokens.fail(`${agg.numFailedTests} failed`) : "",
-    agg.numPassedTests ? colorTokens.pass(`${agg.numPassedTests} passed`) : "",
-    agg.numPendingTests ? colorTokens.skip(`${agg.numPendingTests} skipped`) : "",
-    agg.numTodoTests ? colorTokens.todo(`${agg.numTodoTests} todo`) : ""
+    agg.numFailedTests ? colorTokens2.fail(`${agg.numFailedTests} failed`) : "",
+    agg.numPassedTests ? colorTokens2.pass(`${agg.numPassedTests} passed`) : "",
+    agg.numPendingTests ? colorTokens2.skip(`${agg.numPendingTests} skipped`) : "",
+    agg.numTodoTests ? colorTokens2.todo(`${agg.numTodoTests} todo`) : ""
   ].filter(Boolean).join(ansi.dim(" | "));
-  const durMs = typeof durationMs === "number" ? durationMs : typeof agg.runTimeMs === "number" ? agg.runTimeMs : void 0;
-  const time = durMs != null ? `${Math.max(0, Math.round(durMs))}ms` : "";
+  const time = durationMs != null ? `${Math.max(0, Math.round(durationMs))}ms` : typeof agg.runTimeMs === "number" ? `${Math.max(0, Math.round(agg.runTimeMs))}ms` : "";
   const thread = ansi.dim("(in thread 0ms, 0.00%)");
   return [
     `${ansi.bold("Test Files")} ${files} ${ansi.dim(`(${agg.numTotalTestSuites})`)}`,
@@ -4911,20 +5587,14 @@ var vitestFooter = (agg, _startedAt, durationMs) => {
     `${ansi.bold("Time")}      ${time} ${thread}`
   ].join("\n");
 };
-function renderVitestFromJestJSON(data, opts) {
-  const cwd = (opts?.cwd ?? process.cwd()).replace(/\\/g, "/");
-  const projectHint = new RegExp(
-    `(${cwd.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\$&")})|(/gigworx-node/)`
-  );
-  const ctx = { projectHint, editorCmd: opts?.editorCmd, showStacks: true };
-  const onlyFailures = Boolean(opts?.onlyFailures);
+var renderVitestFromJestJSON = (data, ctx, opts) => {
   const out = [];
+  const onlyFailures = Boolean(opts?.onlyFailures);
   if (!onlyFailures) {
-    out.push(renderRunLine(cwd));
-    out.push("");
+    out.push(`${BackgroundColors.Run(ansi.white(" RUN "))} ${ansi.dim(ctx.cwd)}`, "");
   }
   for (const file of data.testResults) {
-    const rel = file.testFilePath.replace(/\\/g, "/").replace(`${cwd}/`, "");
+    const rel = file.testFilePath.replace(/\\/g, "/").replace(`${ctx.cwd}/`, "");
     const failed = file.testResults.filter((assertion) => assertion.status === "failed");
     if (!onlyFailures) {
       out.push(...buildPerFileOverview(rel, file.testResults));
@@ -4932,79 +5602,490 @@ function renderVitestFromJestJSON(data, opts) {
     if (!(onlyFailures && failed.length === 0)) {
       out.push(buildFileBadgeLine(rel, failed.length));
     }
-    if (file.failureMessage && failed.length === 0) {
+    let httpSorted = [];
+    let assertionEvents = [];
+    {
+      const parseBridge = (consoleEntries) => {
+        const http = [];
+        const assertions = [];
+        if (!Array.isArray(consoleEntries)) {
+          return { http, assertions };
+        }
+        for (const entry of consoleEntries) {
+          const rec = entry;
+          const rawMsgVal = rec && typeof rec.message !== "undefined" ? rec.message : "";
+          const raw = Array.isArray(rawMsgVal) ? rawMsgVal.map(String).join(" ") : String(rawMsgVal ?? "");
+          if (!raw.includes("[JEST-BRIDGE-EVENT]")) {
+            continue;
+          }
+          const jsonText = raw.split("[JEST-BRIDGE-EVENT]").pop()?.trim() ?? "";
+          try {
+            const evt = import_json52.default.parse(jsonText);
+            const type = evt?.type;
+            if (type === "httpResponse") {
+              const timestampMs = Number(evt.timestampMs ?? Date.now());
+              http.push({
+                kind: "response",
+                timestampMs,
+                method: evt.method,
+                url: evt.url,
+                route: evt.route,
+                statusCode: evt.statusCode,
+                durationMs: evt.durationMs,
+                contentType: evt.contentType,
+                requestId: evt.requestId,
+                json: evt.json,
+                bodyPreview: evt.bodyPreview,
+                testPath: evt.testPath,
+                currentTestName: evt.currentTestName
+              });
+            } else if (type === "httpAbort") {
+              http.push({
+                kind: "abort",
+                timestampMs: Number(evt.timestampMs ?? Date.now()),
+                method: evt.method,
+                url: evt.url,
+                route: evt.route,
+                durationMs: evt.durationMs,
+                testPath: evt.testPath,
+                currentTestName: evt.currentTestName
+              });
+            } else if (type === "httpResponseBatch") {
+              const list = asHttpList(evt?.events);
+              for (const item of list) {
+                const anyItem = item;
+                http.push({
+                  timestampMs: Number(anyItem.timestampMs ?? Date.now()),
+                  method: anyItem.method,
+                  url: anyItem.url,
+                  route: anyItem.route,
+                  statusCode: anyItem.statusCode,
+                  durationMs: anyItem.durationMs,
+                  contentType: anyItem.contentType,
+                  requestId: anyItem.requestId,
+                  json: anyItem.json,
+                  bodyPreview: anyItem.bodyPreview,
+                  testPath: evt.testPath,
+                  currentTestName: evt.currentTestName
+                });
+              }
+            } else if (type === "assertionFailure") {
+              assertions.push({
+                timestampMs: typeof evt.timestampMs === "number" ? evt.timestampMs : void 0,
+                matcher: evt.matcher,
+                expectedNumber: typeof evt.expectedNumber === "number" ? evt.expectedNumber : void 0,
+                receivedNumber: typeof evt.receivedNumber === "number" ? evt.receivedNumber : void 0,
+                message: typeof evt.message === "string" ? evt.message : void 0,
+                stack: typeof evt.stack === "string" ? evt.stack : void 0,
+                testPath: evt.testPath,
+                currentTestName: evt.currentTestName,
+                expectedPreview: typeof evt.expectedPreview === "string" ? evt.expectedPreview : void 0,
+                actualPreview: typeof evt.actualPreview === "string" ? evt.actualPreview : void 0
+              });
+            }
+          } catch {
+          }
+        }
+        return { http, assertions };
+      };
+      const parsed = parseBridge(file.console);
+      httpSorted = [...parsed.http].sort(by((event) => event.timestampMs));
+      assertionEvents = parsed.assertions;
+    }
+    const inSameCtx = (testPath, testName) => httpSorted.filter(
+      (event) => event.testPath === testPath && event.currentTestName === testName
+    );
+    if (file.failureMessage || file.testExecError) {
       const lines = file.failureMessage.split(/\r?\n/);
-      const details = linesFromDetails(file.failureDetails);
-      const mergedForStack = collapseStacks([...lines, ...details.stacks]);
-      const synthLoc = deepestProjectLoc(mergedForStack, projectHint);
+      const combinedDetails = (() => {
+        const base = linesFromDetails(file.failureDetails);
+        const exec = linesFromDetails(
+          Array.isArray(file.testExecError) ? file.testExecError : [file.testExecError]
+        );
+        return {
+          stacks: [...base.stacks, ...exec.stacks],
+          messages: [...base.messages, ...exec.messages]
+        };
+      })();
+      const mergedForStack = collapseStacks([...lines, ...combinedDetails.stacks]);
+      const synthLoc = deepestProjectLoc(mergedForStack, ctx.projectHint);
       out.push(...buildCodeFrameSection(lines, ctx, synthLoc));
-      const payload = extractExpectedReceived(file.failureDetails, lines);
-      const hasPretty = payload.expected !== void 0 || payload.received !== void 0;
-      out.push(...renderPrettyDiff(payload));
-      const stackPreview = ctx.showStacks ? firstProjectFrames(mergedForStack, projectHint, 2) : [];
+      const payloadPretty = buildPrettyDiffSection(file.failureDetails, lines);
+      out.push(...payloadPretty);
+      const hasPretty = payloadPretty.length > 0;
+      const stackPreview = ctx.showStacks ? mergedForStack.filter((ln) => isStackLine(stripAnsiSimple(ln))).filter((ln) => ctx.projectHint.test(stripAnsiSimple(ln))).slice(0, 2).map((ln) => `      ${colorStackLine(String(ln), ctx.projectHint)}`) : [];
       out.push(
-        ...buildMessageSection(lines, details, ctx, {
+        ...buildMessageSection(lines, combinedDetails, ctx, {
           suppressDiff: hasPretty,
           stackPreview
         })
       );
-      out.push(...buildConsoleSection(file.console ?? null));
+      out.push(...buildConsoleSection(stripBridgeEventsFromConsole(file.console ?? null)));
       if (ctx.showStacks && stackPreview.length === 0) {
-        out.push(...buildStackSection(mergedForStack, ctx));
+        const tail = mergedForStack.filter((ln) => isStackLine(stripAnsiSimple(ln))).slice(-4).map((ln) => `      ${colorStackLine(String(ln), ctx.projectHint)}`);
+        if (tail.length) {
+          out.push(ansi.dim("    Stack:"), ...tail, "");
+        }
       }
     }
-    for (const failedAssertion of failed) {
+    for (const assertion of failed) {
       out.push(drawFailLine());
-      const header = `${rel} > ${failedAssertion.fullName}`;
-      const messagesArray = failedAssertion.failureMessages.length > 0 ? failedAssertion.failureMessages : [""];
-      const details = linesFromDetails(file.failureDetails);
+      const header = `${rel} > ${assertion.fullName}`;
+      const messagesArray = (() => {
+        if (assertion.failureMessages && assertion.failureMessages.length > 0) {
+          return assertion.failureMessages;
+        }
+        if (file.failureMessage && file.failureMessage.trim().length > 0) {
+          return file.failureMessage.split(/\r?\n/);
+        }
+        const linesFromMatcher = linesFromDetails(
+          assertion.failureDetails || file.failureDetails
+        ).messages;
+        if (Array.isArray(linesFromMatcher) && linesFromMatcher.length > 0) {
+          return linesFromMatcher;
+        }
+        return [""];
+      })();
+      const details = linesFromDetails(assertion.failureDetails || file.failureDetails);
+      const matcherMsg = (() => {
+        try {
+          const arr = assertion.failureDetails || file.failureDetails;
+          if (!arr) {
+            return [];
+          }
+          for (const detailEntry of arr) {
+            const obj = detailEntry && typeof detailEntry === "object" ? detailEntry : null;
+            const mr = obj && obj.matcherResult && typeof obj.matcherResult === "object" ? obj.matcherResult : null;
+            if (mr && typeof mr.message === "string" && mr.message.trim()) {
+              const name = typeof mr.matcherName === "string" ? mr.matcherName : "";
+              const matcherHeader = name ? `    ${ansi.bold("Matcher:")} ${ansi.yellow(name)}` : "";
+              const bodyHeader = `    ${ansi.bold("Message:")}`;
+              const body = String(mr.message).split(/\r?\n/).slice(0, 6).map((ln) => `    ${ansi.yellow(ln)}`);
+              return [matcherHeader, bodyHeader, ...body, ""].filter(Boolean);
+            }
+          }
+        } catch {
+        }
+        return [];
+      })();
       const mergedForStack = collapseStacks([...messagesArray, ...details.stacks]);
-      const deepestLoc = deepestProjectLoc(mergedForStack, projectHint);
-      const locLink = deepestLoc && (() => {
-        const href = preferredEditorHref(deepestLoc.file, deepestLoc.line, opts?.editorCmd);
-        const base = `${path9.basename(deepestLoc.file)}:${deepestLoc.line}`;
+      const deepestLoc = deepestProjectLoc(mergedForStack, ctx.projectHint);
+      const locLink = deepestLoc ? (() => {
+        const href = preferredEditorHref(deepestLoc.file, deepestLoc.line, ctx.editorCmd);
+        const base = `${deepestLoc.file.split("/").pop()}:${deepestLoc.line}`;
         return osc8(base, href);
-      })();
+      })() : void 0;
+      const bullet = (text) => `${Colors.Failure("\xD7")} ${ansi.white(text)}`;
       const headerLine = `${ansi.white(header)}${locLink ? `  ${ansi.dim(`(${locLink})`)}` : ""}`;
-      const bullet = (text) => `${colorTokens.fail("\xD7")} ${ansi.white(text)}`;
       out.push(bullet(headerLine));
       const msgLines = messagesArray.join("\n").split("\n");
-      const assertFallback = deepestLoc || failedAssertion.location && {
-        file: file.testFilePath,
-        line: failedAssertion.location.line
-      };
-      out.push("", ...buildCodeFrameSection(msgLines, ctx, assertFallback), "");
-      const payload = extractExpectedReceived(file.failureDetails, msgLines);
-      const hasPretty = payload.expected !== void 0 || payload.received !== void 0;
-      out.push(...renderPrettyDiff(payload));
-      const stackPreview = ctx.showStacks ? firstProjectFrames(mergedForStack, projectHint, 2) : [];
+      const assertFallback = deepestLoc || assertion.location && { file: file.testFilePath, line: assertion.location.line };
+      out.push("", ...buildCodeFrameSection(msgLines, ctx, assertFallback || void 0), "");
+      const pretty = buildPrettyDiffSection(
+        assertion.failureDetails || file.failureDetails,
+        msgLines
+      );
+      out.push(...pretty);
+      const hasPretty = pretty.length > 0;
+      const stackPreview = ctx.showStacks ? mergedForStack.filter((ln) => isStackLine(stripAnsiSimple(ln))).filter((ln) => ctx.projectHint.test(stripAnsiSimple(ln))).slice(0, 2).map((ln) => `      ${colorStackLine(String(ln), ctx.projectHint)}`) : [];
+      if (matcherMsg.length) {
+        out.push(...matcherMsg);
+      }
       out.push(
         ...buildMessageSection(msgLines, details, ctx, { suppressDiff: hasPretty, stackPreview })
       );
-      if (ctx.showStacks && stackPreview.length === 0) {
-        out.push(
-          ...buildStackSection(
-            mergedForStack,
-            ctx,
-            failedAssertion.location ? { file: file.testFilePath, line: failedAssertion.location.line } : null
-          )
+      {
+        const HEADLAMP_HTTP_DIFF_LIMIT_LOCAL = () => HEADLAMP_HTTP_DIFF_LIMIT();
+        const safeParseJSON = (text) => {
+          try {
+            return text ? import_json52.default.parse(text) : void 0;
+          } catch {
+            return void 0;
+          }
+        };
+        const jsonDiff = (expected, actual, limit = HEADLAMP_HTTP_DIFF_LIMIT_LOCAL()) => {
+          const outChanges = [];
+          const queue = [];
+          queue.push({
+            pathSoFar: "$",
+            expectedValue: expected,
+            actualValue: actual
+          });
+          while (queue.length && outChanges.length < limit) {
+            const { pathSoFar, expectedValue, actualValue } = queue.shift();
+            const expectedIsObj = expectedValue && typeof expectedValue === "object";
+            const actualIsObj = actualValue && typeof actualValue === "object";
+            if (!expectedIsObj && !actualIsObj) {
+              if (JSON.stringify(expectedValue) !== JSON.stringify(actualValue)) {
+                outChanges.push({
+                  kind: "changed",
+                  path: pathSoFar,
+                  preview: `${String(expectedValue)} \u2192 ${String(actualValue)}`
+                });
+              }
+            } else if (expectedIsObj && !actualIsObj) {
+              outChanges.push({
+                kind: "changed",
+                path: pathSoFar,
+                preview: "[object] \u2192 primitive"
+              });
+            } else if (!expectedIsObj && actualIsObj) {
+              outChanges.push({
+                kind: "changed",
+                path: pathSoFar,
+                preview: "primitive \u2192 [object]"
+              });
+            } else {
+              const expectedKeys = new Set(Object.keys(expectedValue));
+              const actualKeys = new Set(Object.keys(actualValue));
+              for (const key of expectedKeys) {
+                if (!actualKeys.has(key) && outChanges.length < limit) {
+                  outChanges.push({ kind: "removed", path: `${pathSoFar}.${key}` });
+                }
+              }
+              for (const key of actualKeys) {
+                if (!expectedKeys.has(key) && outChanges.length < limit) {
+                  outChanges.push({ kind: "added", path: `${pathSoFar}.${key}` });
+                }
+              }
+              for (const key of expectedKeys) {
+                if (actualKeys.has(key) && outChanges.length < limit) {
+                  queue.push({
+                    pathSoFar: `${pathSoFar}.${key}`,
+                    expectedValue: expectedValue[key],
+                    actualValue: actualValue[key]
+                  });
+                }
+              }
+            }
+          }
+          return outChanges;
+        };
+        const importantMessages = (json) => {
+          const msgs = [];
+          try {
+            const obj = isObject(json) ? json : {};
+            const pushMaybe = (candidate) => {
+              if (typeof candidate === "string" && candidate.trim()) {
+                msgs.push(candidate);
+              }
+            };
+            pushMaybe(obj.displayMessage);
+            pushMaybe(obj.message);
+            if (Array.isArray(obj.errors)) {
+              for (const element of obj.errors) {
+                pushMaybe(isObject(element) ? element.message : void 0);
+              }
+            }
+            if (Array.isArray(obj.data)) {
+              for (const element of obj.data) {
+                pushMaybe(isObject(element) ? element.message : void 0);
+              }
+            }
+          } catch {
+          }
+          return msgs.slice(0, 2);
+        };
+        const nameMatches = (leftName, rightName) => !!leftName && !!rightName && (leftName === rightName || leftName.includes(rightName) || rightName.includes(leftName));
+        const corresponding = assertionEvents.find(
+          (aevt) => aevt.testPath === file.testFilePath && nameMatches(aevt.currentTestName, assertion.title)
+        ) ?? assertion;
+        const perTestSlice = inSameCtx(file.testFilePath, assertion.title);
+        const nearByTime = eventsNear(
+          httpSorted,
+          corresponding?.timestampMs,
+          file.testFilePath
         );
+        const hasAbort = perTestSlice.some((event) => event.kind === "abort");
+        const hasTransport = isTransportError(corresponding?.message) || hasAbort;
+        const httpLikely = isHttpRelevant({
+          assertion: corresponding,
+          title: assertion.fullName,
+          relPath: rel,
+          httpCountInSameTest: perTestSlice.length || nearByTime.length,
+          hasTransportSignal: hasTransport
+        });
+        if (!httpLikely) {
+        } else {
+          const expPreview = corresponding?.expectedPreview;
+          const actPreview = corresponding?.actualPreview;
+          const parsedExpected = safeParseJSON(expPreview);
+          const parsedActual = safeParseJSON(actPreview);
+          let corr = corresponding;
+          if (!isHttpStatusNumber(corr.expectedNumber) && !isHttpStatusNumber(corr.receivedNumber)) {
+            const inferred = inferHttpNumbersFromText(msgLines);
+            if (isHttpStatusNumber(inferred.expectedNumber) || isHttpStatusNumber(inferred.receivedNumber)) {
+              corr = { ...corr, ...inferred };
+            }
+          }
+          const relevant = pickRelevantHttp(
+            {
+              timestampMs: corr?.timestampMs,
+              expectedNumber: corr?.expectedNumber,
+              receivedNumber: corr?.receivedNumber,
+              matcher: corr?.matcher,
+              message: corr?.message,
+              stack: corr?.stack,
+              testPath: file.testFilePath,
+              currentTestName: assertion.title
+            },
+            httpSorted,
+            {
+              testPath: file.testFilePath,
+              currentTestName: assertion.title,
+              title: assertion.fullName
+            }
+          );
+          if (hasTransport) {
+            const tsBase = corresponding?.timestampMs ?? 0;
+            const abortCandidates = perTestSlice.filter((event) => event.kind === "abort").sort((leftEvent, rightEvent) => {
+              const deltaLeft = Math.abs(tsBase - (leftEvent.timestampMs ?? 0));
+              const deltaRight = Math.abs(tsBase - (rightEvent.timestampMs ?? 0));
+              return deltaLeft - deltaRight;
+            });
+            const [nearestAbort] = abortCandidates;
+            if (nearestAbort) {
+              out.push(
+                "  HTTP:",
+                `
+    ${summarizeUrl(nearestAbort.method, nearestAbort.url, nearestAbort.route)} ${ansi.dim("->")} ${ansi.yellow("connection aborted")}`,
+                (() => {
+                  const ms = nearestAbort.durationMs;
+                  return ms != null ? ` ${ansi.dim(`(${ms}ms)`)} ` : "";
+                })(),
+                "\n"
+              );
+            } else if (relevant) {
+            } else if (HEADLAMP_HTTP_SHOW_MISS()) {
+              out.push(
+                "  HTTP:",
+                `
+    ${ansi.dim("Transport error; no matching HTTP exchange in window.")}`,
+                "\n"
+              );
+            }
+          }
+          if (!hasTransport && relevant) {
+            const parts = [];
+            const where = summarizeUrl(relevant.method, relevant.url, relevant.route);
+            const line1 = [
+              "  HTTP:",
+              `
+    ${where} ${ansi.dim("->")} ${relevant.statusCode ?? "?"}`,
+              (() => {
+                const ms = relevant.durationMs;
+                return typeof ms === "number" ? ` ${ansi.dim(`(${ms}ms)`)} ` : " ";
+              })(),
+              relevant.contentType ? ansi.dim(`(${relevant.contentType})`) : "",
+              relevant.requestId ? ansi.dim(`  reqId=${relevant.requestId}`) : ""
+            ].join("");
+            const expVsAct = (() => {
+              if (typeof corresponding?.expectedNumber === "number" || typeof corresponding?.receivedNumber === "number") {
+                const exp = corresponding?.expectedNumber != null ? String(corresponding.expectedNumber) : "?";
+                const got = corresponding?.receivedNumber != null ? String(corresponding.receivedNumber) : String(relevant.statusCode ?? "?");
+                return `
+      Expected: ${ansi.yellow(exp)}   Received: ${ansi.yellow(got)}`;
+              }
+              return "";
+            })();
+            const whyLines = importantMessages(relevant.json).map((msg) => `
+      Why: ${ansi.white(msg)}`).slice(0, 1).join("");
+            const diffLines = (() => {
+              const rightActual = parsedActual ?? relevant.json;
+              if (!parsedExpected || !rightActual) {
+                return "";
+              }
+              const changes = jsonDiff(parsedExpected, rightActual);
+              if (!changes.length) {
+                return "";
+              }
+              const head = "\n      Diff:";
+              const body = changes.map((change) => {
+                const marker = change.kind === "added" ? "+" : change.kind === "removed" ? "-" : "~";
+                const previewText = change.preview ? `: ${ansi.dim(change.preview)}` : "";
+                return `
+        ${marker} ${change.path}${previewText}`;
+              }).join("");
+              return head + body;
+            })();
+            parts.push(line1, expVsAct, whyLines, diffLines, "\n");
+            out.push(...parts.filter(Boolean));
+          } else if (!hasTransport && !relevant && HEADLAMP_HTTP_SHOW_MISS()) {
+            out.push(
+              "  HTTP:",
+              `
+    ${ansi.dim("No relevant HTTP exchange found. (HEADLAMP_HTTP_MISS=0 to hide)")}`,
+              "\n"
+            );
+          }
+        }
       }
-      out.push(drawFailLine());
-      out.push("");
+      const minimalInfo = msgLines.every((ln) => !ln.trim());
+      if (minimalInfo) {
+        try {
+          out.push(...buildThrownSection(assertion.failureDetails || []));
+        } catch {
+        }
+      }
+      out.push(...buildConsoleSection(stripBridgeEventsFromConsole(file.console ?? null)));
+      if (ctx.showStacks && stackPreview.length === 0) {
+        const tail = mergedForStack.filter((ln) => isStackLine(stripAnsiSimple(ln))).slice(-4).map((ln) => `      ${colorStackLine(String(ln), ctx.projectHint)}`);
+        if (tail.length) {
+          out.push(ansi.dim("    Stack:"), ...tail, "");
+        }
+      }
+      out.push(drawFailLine(), "");
     }
   }
   const failedCount = data.aggregated.numFailedTests;
-  out.push(drawRule(colorTokens.failPill(` Failed Tests ${failedCount} `)));
+  out.push(drawRule(BackgroundColors.Failure(ansi.white(` Failed Tests ${failedCount} `))));
   out.push("");
-  const footer = vitestFooter(
-    data.aggregated,
-    data.aggregated?.startTime ?? data.startTime,
-    data.aggregated?.runTimeMs
-  );
-  return `${out.join("\n")}
-${footer}`;
-}
+  out.push(vitestFooter(data.aggregated));
+  return out.join("\n");
+};
+var tryBridgeFallback = (raw, ctx, opts) => {
+  const bridgeJsonPath = extractBridgePath2(raw, ctx.cwd);
+  if (!bridgeJsonPath || !fs6.existsSync(bridgeJsonPath)) {
+    return null;
+  }
+  try {
+    const json = import_json52.default.parse(fs6.readFileSync(bridgeJsonPath, "utf8"));
+    const bridge = coerceJestJsonToBridge(json);
+    return renderVitestFromJestJSON(bridge, ctx, opts);
+  } catch {
+    return null;
+  }
+};
+
+// src/lib/formatJestOutputVitest.ts
+var formatJestOutputVitest = (raw, opts) => pipe(
+  { raw, opts },
+  (state) => ({
+    ...state,
+    ctx: makeCtx(state.opts, /\bFAIL\b/.test(stripAnsiSimple(state.raw)))
+  }),
+  (state) => ({ ...state, chunks: parseChunks(state.raw) }),
+  (state) => ({
+    ...state,
+    rendered: renderChunks(state.chunks, state.ctx, mkPrettyFns(), {
+      onlyFailures: Boolean(state.opts?.onlyFailures)
+    })
+  }),
+  (state) => {
+    if (state.rendered.hadParsed) {
+      return state.rendered.text;
+    }
+    const fallback = tryBridgeFallback(state.raw, state.ctx, {
+      onlyFailures: Boolean(state.opts?.onlyFailures)
+    });
+    if (!fallback) {
+      return state.rendered.text;
+    }
+    const prefix = state.rendered.text;
+    return prefix ? `${prefix}
+${fallback}` : fallback;
+  }
+);
 
 // src/lib/program.ts
 var jestBin = "./node_modules/.bin/jest";
@@ -5049,7 +6130,7 @@ var mergeLcov = async () => {
     try {
       const entries = fsSync3.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const full = path10.join(dir, entry.name);
+        const full = path11.join(dir, entry.name);
         if (entry.isDirectory()) {
           out.push(...collectLcovs(full));
         } else if (entry.isFile() && entry.name === "lcov.info") {
@@ -5061,8 +6142,8 @@ var mergeLcov = async () => {
     return out;
   };
   try {
-    const jestRoot = path10.join("coverage", "jest");
-    const candidates = [path10.join(jestRoot, "lcov.info"), ...collectLcovs(jestRoot)].map((candidatePath) => path10.resolve(candidatePath)).filter((absolutePath, index, arr) => arr.indexOf(absolutePath) === index);
+    const jestRoot = path11.join("coverage", "jest");
+    const candidates = [path11.join(jestRoot, "lcov.info"), ...collectLcovs(jestRoot)].map((candidatePath) => path11.resolve(candidatePath)).filter((absolutePath, index, arr) => arr.indexOf(absolutePath) === index);
     for (const filePath of candidates) {
       try {
         const content = await readOrEmpty(filePath);
@@ -5102,7 +6183,7 @@ var emitMergedCoverage = async (ui, opts) => {
     try {
       const entries = fsSync3.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const full = path10.join(dir, entry.name);
+        const full = path11.join(dir, entry.name);
         if (entry.isDirectory()) {
           out.push(...listJsons(full));
         } else if (entry.isFile() && entry.name === "coverage-final.json") {
@@ -5113,11 +6194,11 @@ var emitMergedCoverage = async (ui, opts) => {
     }
     return out;
   };
-  const coverageRoot = path10.join("coverage", "jest");
+  const coverageRoot = path11.join("coverage", "jest");
   const jsonCandidates = [
-    path10.join(coverageRoot, "coverage-final.json"),
+    path11.join(coverageRoot, "coverage-final.json"),
     ...listJsons(coverageRoot)
-  ].map((candidatePath) => path10.resolve(candidatePath)).filter((absolutePath, index, arr) => {
+  ].map((candidatePath) => path11.resolve(candidatePath)).filter((absolutePath, index, arr) => {
     const isFirst = arr.indexOf(absolutePath) === index;
     const exists = fsSync3.existsSync(absolutePath);
     return isFirst && exists;
@@ -5179,7 +6260,7 @@ var emitMergedCoverage = async (ui, opts) => {
     executedTests: opts.executedTests ?? []
   });
   const context = LibReport.createContext({
-    dir: path10.resolve("coverage", "merged"),
+    dir: path11.resolve("coverage", "merged"),
     coverageMap: filteredMap,
     defaultSummarizer: "nested"
   });
@@ -5247,8 +6328,8 @@ var emitMergedCoverage = async (ui, opts) => {
   for (const reporter of reporters) {
     reporter.execute(context);
   }
-  const textPath = path10.resolve("coverage", "merged", "coverage.txt");
-  const summaryPath = path10.resolve("coverage", "merged", "coverage-summary.txt");
+  const textPath = path11.resolve("coverage", "merged", "coverage.txt");
+  const summaryPath = path11.resolve("coverage", "merged", "coverage-summary.txt");
   const filesToPrint = [];
   if (fsSync3.existsSync(textPath)) {
     filesToPrint.push(textPath);
@@ -5391,13 +6472,13 @@ var program = async () => {
       const rels2 = Array.from(
         /* @__PURE__ */ new Set([...branchDiff, ...stagedNow, ...unstagedNow, ...untrackedNow])
       );
-      return rels2.map((rel) => path10.resolve(cwd, rel).replace(/\\/g, "/")).filter((abs) => !abs.includes("/node_modules/") && !abs.includes("/coverage/"));
+      return rels2.map((rel) => path11.resolve(cwd, rel).replace(/\\/g, "/")).filter((abs) => !abs.includes("/node_modules/") && !abs.includes("/coverage/"));
     }
     const staged = mode === "staged" || mode === "all" ? await collect("git", ["diff", "--name-only", "--diff-filter=ACMRTUXB", "--cached"]) : [];
     const unstagedTracked = mode === "unstaged" || mode === "all" ? await collect("git", ["diff", "--name-only", "--diff-filter=ACMRTUXB"]) : [];
     const untracked = mode === "unstaged" || mode === "all" ? await collect("git", ["ls-files", "--others", "--exclude-standard"]) : [];
     const rels = Array.from(/* @__PURE__ */ new Set([...staged, ...unstagedTracked, ...untracked]));
-    return rels.map((rel) => path10.resolve(cwd, rel).replace(/\\/g, "/")).filter((abs) => !abs.includes("/node_modules/") && !abs.includes("/coverage/"));
+    return rels.map((rel) => path11.resolve(cwd, rel).replace(/\\/g, "/")).filter((abs) => !abs.includes("/node_modules/") && !abs.includes("/coverage/"));
   };
   const repoRootForChanged = workspaceRoot ?? await findRepoRoot();
   const changedSelectionAbs = changed ? await getChangedFiles(changed, repoRootForChanged) : [];
@@ -5422,18 +6503,18 @@ var program = async () => {
       if (!token) {
         continue;
       }
-      const isAbs = path10.isAbsolute(token);
+      const isAbs = path11.isAbsolute(token);
       const looksLikeRelPath = /[\\/]/.test(token);
       let candidateFromRoot;
       if (token.startsWith("/")) {
-        candidateFromRoot = path10.join(repoRoot, token.slice(1));
+        candidateFromRoot = path11.join(repoRoot, token.slice(1));
       } else if (looksLikeRelPath) {
-        candidateFromRoot = path10.join(repoRoot, token);
+        candidateFromRoot = path11.join(repoRoot, token);
       } else {
         candidateFromRoot = void 0;
       }
       const tryPushIfProd = (absPath) => {
-        const norm = path10.resolve(absPath).replace(/\\/g, "/");
+        const norm = path11.resolve(absPath).replace(/\\/g, "/");
         const isTest = /(^|\/)tests?\//i.test(norm) || /\.(test|spec)\.[tj]sx?$/i.test(norm);
         if (!isTest && fsSync3.existsSync(norm)) {
           results.add(norm);
@@ -5455,7 +6536,7 @@ var program = async () => {
           }),
           timeoutMs: 4e3
         });
-        const matches = out.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((rel) => path10.resolve(repoRoot, rel).replace(/\\/g, "/")).filter(
+        const matches = out.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((rel) => path11.resolve(repoRoot, rel).replace(/\\/g, "/")).filter(
           (abs) => !abs.includes("/node_modules/") && !abs.includes("/coverage/") && !/(^|\/)tests?\//i.test(abs) && !/\.(test|spec)\.[tj]sx?$/i.test(abs)
         );
         matches.forEach((abs) => results.add(abs));
@@ -5476,8 +6557,8 @@ var program = async () => {
   const jestDiscoveryArgs = selectionIncludesProdPaths ? stripPathTokens(jest) : jest;
   const projectConfigs = [];
   try {
-    const baseCfg = path10.resolve("jest.config.js");
-    const tsCfg = path10.resolve("jest.ts.config.js");
+    const baseCfg = path11.resolve("jest.config.js");
+    const tsCfg = path11.resolve("jest.ts.config.js");
     if (fsSync3.existsSync(baseCfg)) {
       projectConfigs.push(baseCfg);
     }
@@ -5494,7 +6575,7 @@ var program = async () => {
     );
     const prodSelections2 = expandedProdSelections;
     for (const cfg of projectConfigs) {
-      const cfgCwd = path10.dirname(cfg);
+      const cfgCwd = path11.dirname(cfg);
       const allTests = await discoverJestResilient([...jestDiscoveryArgs, "--config", cfg], {
         cwd: cfgCwd
       });
@@ -5507,7 +6588,7 @@ var program = async () => {
         });
       } catch (err) {
         if (isDebug()) {
-          console.warn(`direct selection failed for project ${path10.basename(cfg)}: ${String(err)}`);
+          console.warn(`direct selection failed for project ${path11.basename(cfg)}: ${String(err)}`);
         }
       }
       perProjectFiles.set(cfg, directPerProject);
@@ -5519,7 +6600,7 @@ var program = async () => {
       )} | related=${selectionIncludesProdPaths} | cwd=${repoRootForDiscovery}`
     );
     for (const cfg of projectConfigs) {
-      const cfgCwd = path10.dirname(cfg);
+      const cfgCwd = path11.dirname(cfg);
       const files = await discoverJestResilient([...jestDiscoveryArgs, "--config", cfg], {
         cwd: cfgCwd
       });
@@ -5534,13 +6615,13 @@ var program = async () => {
     );
     const candidates = selectionHasPaths && selectionLooksLikeTest ? selectionTestPaths : files;
     const absFiles = candidates.map(
-      (candidatePath) => path10.isAbsolute(candidatePath) ? candidatePath : path10.join(repoRootForDiscovery, candidatePath)
+      (candidatePath) => path11.isAbsolute(candidatePath) ? candidatePath : path11.join(repoRootForDiscovery, candidatePath)
     ).map((absolutePath) => absolutePath.replace(/\\/g, "/"));
     const onlyOwned = await filterCandidatesForProject(
       cfg,
       jestDiscoveryArgs,
       absFiles,
-      path10.dirname(cfg)
+      path11.dirname(cfg)
     );
     perProjectFiltered.set(cfg, onlyOwned);
   }
@@ -5552,7 +6633,7 @@ var program = async () => {
   if (selectionHasPaths && prodSelections.length > 0) {
     console.info(`rg related \u2192 prodSelections=${prodSelections.length} (starting)`);
     const repoRootForRefinement = workspaceRoot ?? await findRepoRoot();
-    const selectionKey = prodSelections.map((absPath) => path10.relative(repoRootForRefinement, absPath).replace(/\\/g, "/")).sort((firstPath, secondPath) => firstPath.localeCompare(secondPath)).join("|");
+    const selectionKey = prodSelections.map((absPath) => path11.relative(repoRootForRefinement, absPath).replace(/\\/g, "/")).sort((firstPath, secondPath) => firstPath.localeCompare(secondPath)).join("|");
     const { cachedRelated: cachedRelated2, findRelatedTestsFast: findRelatedTestsFast2, DEFAULT_TEST_GLOBS: DEFAULT_TEST_GLOBS2 } = await Promise.resolve().then(() => (init_fast_related(), fast_related_exports));
     const { DEFAULT_EXCLUDE: DEFAULT_EXCLUDE2 } = await Promise.resolve().then(() => (init_args(), args_exports));
     const rgMatches = await cachedRelated2({
@@ -5582,7 +6663,7 @@ var program = async () => {
             cfg,
             jestDiscoveryArgs,
             rgCandidates,
-            path10.dirname(cfg)
+            path11.dirname(cfg)
           );
           perProjectFromRg.set(cfg, owned);
         }
@@ -5597,9 +6678,9 @@ var program = async () => {
         } else {
           const repoRootForScan = repoRootForDiscovery;
           const toSeeds = (abs) => {
-            const rel = path10.relative(repoRootForScan, abs).replace(/\\/g, "/");
+            const rel = path11.relative(repoRootForScan, abs).replace(/\\/g, "/");
             const withoutExt = rel.replace(/\.(m?[tj]sx?)$/i, "");
-            const base = path10.basename(withoutExt);
+            const base = path11.basename(withoutExt);
             const segs = withoutExt.split("/");
             const tail2 = segs.slice(-2).join("/");
             return Array.from(new Set([withoutExt, base, tail2].filter(Boolean)));
@@ -5614,8 +6695,8 @@ var program = async () => {
             }
           };
           const resolveLocalImport = (fromFile, spec) => {
-            const baseDir = path10.dirname(fromFile);
-            const cand = path10.resolve(baseDir, spec);
+            const baseDir = path11.dirname(fromFile);
+            const cand = path11.resolve(baseDir, spec);
             const exts = ["", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
             for (const ext of exts) {
               const full = ext ? `${cand}${ext}` : cand;
@@ -5624,7 +6705,7 @@ var program = async () => {
               }
             }
             for (const ext of exts) {
-              const full = path10.join(cand, `index${ext}`);
+              const full = path11.join(cand, `index${ext}`);
               if (fsSync3.existsSync(full)) {
                 return full;
               }
@@ -5678,7 +6759,7 @@ var program = async () => {
                 cfg,
                 jestDiscoveryArgs,
                 keptCandidates,
-                path10.dirname(cfg)
+                path11.dirname(cfg)
               );
               perProjectFromScan.set(cfg, owned);
             }
@@ -5708,7 +6789,7 @@ var program = async () => {
         try {
           const allAcross = [];
           for (const cfg of projectConfigs) {
-            const cfgCwd = path10.dirname(cfg);
+            const cfgCwd = path11.dirname(cfg);
             const listed = await discoverJestResilient([...jestDiscoveryArgs, "--config", cfg], {
               cwd: cfgCwd
             });
@@ -5722,23 +6803,23 @@ var program = async () => {
         }
       }
       const seeds = prodSelections.map(
-        (abs) => path10.relative(repoRoot, abs).replace(/\\/g, "/").replace(/\.(m?[tj]sx?)$/i, "")
+        (abs) => path11.relative(repoRoot, abs).replace(/\\/g, "/").replace(/\.(m?[tj]sx?)$/i, "")
       ).flatMap((rel) => {
-        const base = path10.basename(rel);
+        const base = path11.basename(rel);
         const segments = rel.split("/");
         return Array.from(new Set([rel, base, segments.slice(-2).join("/")].filter(Boolean)));
       });
       const includesSeed = (text) => seeds.some((seed) => text.includes(seed));
       const tryReadFile = async (absPath) => {
         try {
-          return await fs5.readFile(absPath, "utf8");
+          return await fs7.readFile(absPath, "utf8");
         } catch {
           return "";
         }
       };
       const resolveLocalImport = (fromFile, spec) => {
-        const baseDir = path10.dirname(fromFile);
-        const candidate = path10.resolve(baseDir, spec);
+        const baseDir = path11.dirname(fromFile);
+        const candidate = path11.resolve(baseDir, spec);
         const extensions = ["", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"];
         for (const ext of extensions) {
           const fullPath = ext ? `${candidate}${ext}` : candidate;
@@ -5747,7 +6828,7 @@ var program = async () => {
           }
         }
         for (const ext of extensions) {
-          const fullPath = path10.join(candidate, `index${ext}`);
+          const fullPath = path11.join(candidate, `index${ext}`);
           if (fsSync3.existsSync(fullPath)) {
             return fullPath;
           }
@@ -5904,10 +6985,10 @@ var program = async () => {
     };
     const prodSeedsForRun = (() => {
       const changedAbs = (changedSelectionAbs ?? []).map(
-        (absPath) => path10.resolve(absPath).replace(/\\/g, "/")
+        (absPath) => path11.resolve(absPath).replace(/\\/g, "/")
       );
       const selAbs = selectionPathsAugmented.map(
-        (pathToken) => path10.resolve(pathToken).replace(/\\/g, "/")
+        (pathToken) => path11.resolve(pathToken).replace(/\\/g, "/")
       );
       return (changedAbs.length ? changedAbs : selAbs).filter(
         (abs) => /[\\/]/.test(abs) && !/(^|\/)tests?\//i.test(abs) && !/\.(test|spec)\.[tj]sx?$/i.test(abs)
@@ -5922,29 +7003,50 @@ var program = async () => {
       const cfg = projectsToRun[projIndex];
       const files = perProjectFiltered.get(cfg) ?? [];
       if (files.length === 0) {
-        console.info(`Project ${path10.basename(cfg)}: 0 matching tests after filter; skipping.`);
+        console.info(`Project ${path11.basename(cfg)}: 0 matching tests after filter; skipping.`);
         continue;
       }
       files.forEach(
-        (absTestPath) => executedTestFilesSet.add(path10.resolve(absTestPath).replace(/\\/g, "/"))
+        (absTestPath) => executedTestFilesSet.add(path11.resolve(absTestPath).replace(/\\/g, "/"))
       );
-      const outJson = path10.join(
+      const outJson = path11.join(
         os2.tmpdir(),
         `jest-bridge-${Date.now()}-${Math.random().toString(36).slice(2)}.json`
       );
-      const reporterPath = path10.resolve("scripts/jest-vitest-bridge.cjs");
+      const reporterPath = path11.resolve("scripts/jest-vitest-bridge.cjs");
       try {
-        if (!fsSync3.existsSync(reporterPath)) {
-          fsSync3.mkdirSync(path10.dirname(reporterPath), { recursive: true });
+        const needsWrite = (() => {
+          try {
+            const existing = fsSync3.readFileSync(reporterPath, "utf8");
+            return existing !== JEST_BRIDGE_REPORTER_SOURCE;
+          } catch {
+            return true;
+          }
+        })();
+        if (needsWrite) {
+          fsSync3.mkdirSync(path11.dirname(reporterPath), { recursive: true });
           fsSync3.writeFileSync(reporterPath, JEST_BRIDGE_REPORTER_SOURCE, "utf8");
         }
+        const envPath = path11.resolve("scripts/jest-bridge-env.cjs");
+        try {
+          const existingEnv = fsSync3.readFileSync(envPath, "utf8");
+          if (existingEnv !== JEST_BRIDGE_ENV_SOURCE) {
+            fsSync3.writeFileSync(envPath, JEST_BRIDGE_ENV_SOURCE, "utf8");
+          }
+        } catch {
+          try {
+            fsSync3.mkdirSync(path11.dirname(envPath), { recursive: true });
+          } catch {
+          }
+          fsSync3.writeFileSync(envPath, JEST_BRIDGE_ENV_SOURCE, "utf8");
+        }
       } catch (ensureReporterError) {
         console.warn(`Unable to ensure jest bridge reporter: ${String(ensureReporterError)}`);
       }
-      const selectedFilesForCoverage = selectionPathsAugmented.filter((pathToken) => /[\\/]/.test(pathToken)).filter((pathToken) => !looksLikeTestPath(pathToken)).map((pathToken) => path10.relative(repoRootForDiscovery, pathToken).replace(/\\\\/g, "/")).filter((rel) => rel && !/^\.+\//.test(rel)).map((rel) => rel.startsWith("./") ? rel : `./${rel}`);
+      const selectedFilesForCoverage = selectionPathsAugmented.filter((pathToken) => /[\\/]/.test(pathToken)).filter((pathToken) => !looksLikeTestPath(pathToken)).map((pathToken) => path11.relative(repoRootForDiscovery, pathToken).replace(/\\\\/g, "/")).filter((rel) => rel && !/^\.+\//.test(rel)).map((rel) => rel.startsWith("./") ? rel : `./${rel}`);
       const coverageFromArgs = [];
-      for (const relPath of selectedFilesForCoverage) {
-        coverageFromArgs.push("--collectCoverageFrom", relPath);
+      for (const relPath2 of selectedFilesForCoverage) {
+        coverageFromArgs.push("--collectCoverageFrom", relPath2);
       }
       const { code, output } = await runWithCapture(
         babelNodeBin,
@@ -5954,17 +7056,16 @@ var program = async () => {
           jestBin,
           "--config",
           cfg,
+          "--testLocationInResults",
           "--runTestsByPath",
           `--reporters=${reporterPath}`,
-          "--silent",
           "--colors",
-          "--json",
-          "--outputFile",
-          outJson,
+          "--env",
+          path11.resolve("scripts/jest-bridge-env.cjs"),
           ...sanitizedJestRunArgs,
           ...collectCoverage ? [
             "--coverageDirectory",
-            path10.join("coverage", "jest", path10.basename(cfg).replace(/[^a-zA-Z0-9_.-]+/g, "_"))
+            path11.join("coverage", "jest", path11.basename(cfg).replace(/[^a-zA-Z0-9_.-]+/g, "_"))
           ] : [],
           ...coverageFromArgs,
           "--passWithNoTests",
@@ -5997,17 +7098,23 @@ var program = async () => {
             ...bridge,
             testResults: sortTestResultsWithRank(fileRank, bridge.testResults).reverse()
           };
-          pretty = renderVitestFromJestJSON(reordered, {
-            cwd: repoRootForDiscovery,
-            ...editorCmd !== void 0 ? { editorCmd } : {},
-            onlyFailures
-          });
+          pretty = renderVitestFromJestJSON(
+            reordered,
+            makeCtx(
+              { cwd: repoRootForDiscovery, ...editorCmd !== void 0 ? { editorCmd } : {} },
+              /\bFAIL\b/.test(stripAnsiSimple(output))
+            ),
+            { onlyFailures }
+          );
         } catch {
-          pretty = renderVitestFromJestJSON(bridge, {
-            cwd: repoRootForDiscovery,
-            ...editorCmd !== void 0 ? { editorCmd } : {},
-            onlyFailures
-          });
+          pretty = renderVitestFromJestJSON(
+            bridge,
+            makeCtx(
+              { cwd: repoRootForDiscovery, ...editorCmd !== void 0 ? { editorCmd } : {} },
+              /\bFAIL\b/.test(stripAnsiSimple(output))
+            ),
+            { onlyFailures }
+          );
         }
         if (debug) {
           const preview = pretty.split("\n").slice(0, 3).join("\n");
@@ -6021,18 +7128,31 @@ ${preview}${pretty.includes("\n") ? "\n\u2026" : ""}`);
           console.info(String(jsonErr));
           console.info(`fallback: raw output lines=${output.split(/\r?\n/).length}`);
         }
-        const renderOpts = {
+        pretty = formatJestOutputVitest(output, {
           cwd: repoRootForDiscovery,
           ...editorCmd !== void 0 ? { editorCmd } : {},
           onlyFailures
-        };
-        pretty = formatJestOutputVitest(output, renderOpts);
+        });
         if (debug) {
           const preview = pretty.split("\n").slice(0, 3).join("\n");
           console.info(`pretty preview (text):
 ${preview}${pretty.includes("\n") ? "\n\u2026" : ""}`);
         }
       }
+      try {
+        const looksSparse = /\n\s*Error:\s*\n/.test(pretty) && !/(Message:|Thrown:|Events:|Console errors:)/.test(pretty);
+        if (looksSparse) {
+          const rawAlso = formatJestOutputVitest(output, {
+            cwd: repoRootForDiscovery,
+            ...editorCmd !== void 0 ? { editorCmd } : {},
+            onlyFailures
+          });
+          const merged = `${stripFooter(pretty)}
+${stripFooter(rawAlso)}`.trimEnd();
+          pretty = merged;
+        }
+      } catch {
+      }
       pretty = stripFooter(pretty);
       if (pretty.trim().length > 0) {
         process.stdout.write(pretty.endsWith("\n") ? pretty : `${pretty}
@@ -6071,10 +7191,10 @@ ${preview}${pretty.includes("\n") ? "\n\u2026" : ""}`);
     try {
       const prodSeeds = (() => {
         const changedAbs = (changedSelectionAbs ?? []).map(
-          (absPath) => path10.resolve(absPath).replace(/\\/g, "/")
+          (absPath) => path11.resolve(absPath).replace(/\\/g, "/")
         );
         const selAbs = selectionPathsAugmented.map(
-          (pathToken) => path10.resolve(pathToken).replace(/\\/g, "/")
+          (pathToken) => path11.resolve(pathToken).replace(/\\/g, "/")
         );
         return (changedAbs.length ? changedAbs : selAbs).filter(
           (abs) => /[\\/]/.test(abs) && !/(^|\/)tests?\//i.test(abs) && !/\.(test|spec)\.[tj]sx?$/i.test(abs)
@@ -6088,11 +7208,18 @@ ${preview}${pretty.includes("\n") ? "\n\u2026" : ""}`);
       unified.testResults = ordered;
     } catch {
     }
-    const text = renderVitestFromJestJSON(unified, {
-      cwd: repoRootForDiscovery,
-      ...editorCmd !== void 0 ? { editorCmd } : {},
-      onlyFailures
-    });
+    const showStacks = Boolean(unified.aggregated?.numFailedTests > 0);
+    let text = renderVitestFromJestJSON(
+      unified,
+      makeCtx(
+        { cwd: repoRootForDiscovery, ...editorCmd !== void 0 ? { editorCmd } : {} },
+        showStacks
+      ),
+      { onlyFailures }
+    );
+    if (onlyFailures) {
+      text = text.split(/\r?\n/).filter((line) => !/^\s*PASS\b/.test(stripAnsiSimple(line))).join("\n");
+    }
     if (text.trim().length > 0) {
       process.stdout.write(text.endsWith("\n") ? text : `${text}
 `);