@molecule/api-ai-tools 1.9.14 → 1.9.16

package/dist/trace-artifacts.js

@@ -42,6 +42,13 @@ export const MAX_TRACED_CONSOLE = 4;
 export const MAX_TRACED_ACTIONS = 40;
 /** How much of a 4xx request's sent body (or its response body) the trace read keeps. */
 export const MAX_TRACED_BODY_CHARS = 300;
+/**
+ * How much of a websocket's frames the trace read keeps. Longer than {@link MAX_TRACED_BODY_CHARS}
+ * because a frame read back to its own message still has the message, the module id and the
+ * location to carry — Vite's transform error alone is a sentence longer than the plain body cap,
+ * and the note prints its first 120–200 characters anyway (xr-molecule-flash-m157).
+ */
+const MAX_TRACED_WEBSOCKET_CHARS = 600;
 /** How many tests the note in a run's result names. */
 export const MAX_TRACE_NOTE_TESTS = 5;
 /** How many requests the note names per test. */
@@ -77,6 +84,13 @@ const TRACE_NOTE_FAILURE_CHARS = 120;
  * test's trace holds the whole page load. A request with no response and NO error text was aborted
  * or still in flight when the test ended; it is kept too, but as what it is, not as a failure.
  *
+ * A trace.zip holds ONE trace member per browser context the test used (beside the runner's own
+ * `test.trace`), and the archive's member order is not the test's chronology. Each member is read
+ * as its own context: actions and requests keep their context id, requests and frame snapshots
+ * keep the pageId Playwright records, and the failing assertion's page — the page its own step id
+ * ran on — decides which actions, snapshots and requests become the test's row. What the test's
+ * other browser contexts recorded is reported apart, as `otherContexts` (xr-molecule-flash-m160).
+ *
  * A request answered 4xx by the app's OWN API also keeps what the page SENT and the first of what
  * came back: Playwright stores either inline (`text`) or in a resource entry (`_file`), and both
  * are read. That is where a wrapped body shows: xr-molecule-flash-m111's helper passed
@@ -97,6 +111,7 @@ const MAX_NOTE = ${MAX_TRACE_NOTE_REQUESTS}
 const MAX_CONSOLE = ${MAX_TRACED_CONSOLE}
 const MAX_ACTIONS = ${MAX_TRACED_ACTIONS}
 const MAX_BODY = ${MAX_TRACED_BODY_CHARS}
+const MAX_WS = ${MAX_TRACED_WEBSOCKET_CHARS}
 const MAX_URL = 200
 // A console line that is not an error but still has to reach the note (m148): one a molecule
 // package wrote — it names the package, the \`[molecule/…]\` prefix, or the \`[scope]\` prefix
@@ -199,6 +214,51 @@ function bodyText(buf, entries, value, max) {
   return text.indexOf('\\u0000') === -1 ? text : ''
 }
 
+// A websocket's content is a JSONL stream of frames (\`{type, time, opcode, data}\`), and the data
+// is the page's own message. The envelope is ~35 characters on every frame, so cutting the raw
+// stream lands inside it and never reaches the text that names a cause: xr-molecule-flash-m157's
+// Vite HMR error frame was \`{"type":"receive","time":…,"opcode":1,"data":"{\\"type\\":\\"error\\",
+// \\"err\\":{\\"message\\":\\"Cannot import non-asset file /styles.css which is inside /public …\` and
+// every note stopped at \`{"type":"error","err":{"message":"Cannot…\`. Read the frames and print
+// what they carry — a Vite error's message, id and loc, or the JSON a frame sends — so the cut
+// lands in the message itself.
+function websocketText(raw) {
+  const errors = []
+  const others = []
+  for (const line of String(raw).split('\\n')) {
+    if (!line.trim()) continue
+    let frame
+    try { frame = JSON.parse(line) } catch (e) { continue }
+    if (!frame || typeof frame.data !== 'string') continue
+    let data = frame.data
+    try { data = JSON.parse(frame.data) } catch (e) { /* a text frame: print the data as it is */ }
+    const err = data && typeof data === 'object' && data.type === 'error' ? data.err : null
+    if (err && typeof err.message === 'string') {
+      let text = 'vite error: ' + err.message
+      if (err.id !== undefined && err.id !== null && err.id !== '')
+        text += ' (id: ' + String(err.id) + ')'
+      const loc = err.loc
+      if (loc && typeof loc === 'object') {
+        const file = typeof loc.file === 'string' && loc.file ? loc.file : String(err.id || '')
+        text += ' (loc: ' + file +
+          (typeof loc.line === 'number' ? ':' + loc.line + ':' + (typeof loc.column === 'number' ? loc.column : 0) : '') +
+          ')'
+      } else if (typeof loc === 'string' && loc) text += ' (loc: ' + loc + ')'
+      errors.push(text)
+    } else if (typeof data === 'string') others.push(data)
+    else others.push(JSON.stringify(data))
+  }
+  return errors.concat(others).join(' ')
+}
+
+// What a request got back, as the note reads it: a websocket's frames are read as the messages
+// they carry (m157), every other request's body as stored.
+function gotText(buf, entries, r) {
+  if (r.type !== 'websocket') return bodyText(buf, entries, r.content, MAX_BODY)
+  const raw = bodyText(buf, entries, r.content, 8000)
+  return (websocketText(raw) || raw).slice(0, MAX_WS)
+}
+
 let origin = ''
 function pathOf(url) {
   try {
@@ -223,26 +283,69 @@ const found = []
 walk(ROOT, 5, found)
 found.sort(function (a, b) { return b.mtime - a.mtime })
 
+// A trace.zip holds ONE trace member per browser context the test used (1-trace.trace,
+// 3-trace.trace, …) beside the test runner's own test.trace. The archive ORDER of those members
+// is not the test's chronology: xr-molecule-flash-m160's helper context was written after the
+// primary page's, so the concatenation's last user action was the helper's editor click and the
+// last frame snapshot was /editor, while the assertion had failed on the primary page at
+// /profile/:username. Each member is read as its own context, and everything below attributes a
+// request, an action and a frame snapshot to the page and context that recorded it.
+function traceContextOf(name) {
+  if (name === 'test.trace') return 'test'
+  if (name === 'trace.trace') return '0'
+  const m = /^(.+)-trace\\.trace$/.exec(name)
+  return m === null ? null : m[1]
+}
+function networkContextOf(name) {
+  if (name === 'trace.network') return '0'
+  const m = /^(.+)-trace\\.network$/.exec(name)
+  return m === null ? null : m[1]
+}
+
 for (const one of found.slice(0, MAX_TRACES)) {
   let buf
   try { buf = fs.readFileSync(one.file) } catch (e) { continue }
   let entries
   try { entries = zipEntries(buf) } catch (e) { continue }
-  const network = []
-  const trace = []
+  const runner = []
+  const contexts = []
+  const contextById = {}
+  function contextFor(id) {
+    let ctx = contextById[id]
+    if (!ctx) {
+      ctx = { id: id, trace: [], network: [], requests: [], actions: [], frames: [] }
+      contextById[id] = ctx
+      contexts.push(ctx)
+    }
+    return ctx
+  }
   for (const entry of entries) {
-    if (/\\.network$/.test(entry.name)) network.push.apply(network, ndjson(zipData(buf, entry)))
-    else if (/\\.trace$/.test(entry.name)) trace.push.apply(trace, ndjson(zipData(buf, entry)))
+    const traceContext = traceContextOf(entry.name)
+    if (traceContext === 'test') {
+      runner.push.apply(runner, ndjson(zipData(buf, entry)))
+      continue
+    }
+    if (traceContext !== null) {
+      const ctx = contextFor(traceContext)
+      ctx.trace.push.apply(ctx.trace, ndjson(zipData(buf, entry)))
+      continue
+    }
+    const networkContext = networkContextOf(entry.name)
+    if (networkContext !== null) {
+      const ctx = contextFor(networkContext)
+      ctx.network.push.apply(ctx.network, ndjson(zipData(buf, entry)))
+    }
   }
-  const requests = []
-  for (const line of network) {
-    if (!line || line.type !== 'resource-snapshot') continue
-    const snapshot = line.snapshot || {}
-    const request = snapshot.request || {}
-    if (!request.url || !request.method) continue
-    const response = snapshot.response || {}
-    const type = String(snapshot._resourceType || '')
-    if (!origin) origin = type === 'document' ? originOf(String(request.url)) : ''
+  const requestsAll = []
+  for (const ctx of contexts) {
+    for (const line of ctx.network) {
+      if (!line || line.type !== 'resource-snapshot') continue
+      const snapshot = line.snapshot || {}
+      const request = snapshot.request || {}
+      if (!request.url || !request.method) continue
+      const response = snapshot.response || {}
+      const type = String(snapshot._resourceType || '')
+      if (!origin) origin = type === 'document' ? originOf(String(request.url)) : ''
     // What the request carried for CREDENTIALS — never the secret itself. A 401 on the app's own
     // API cannot be read without this: m148's favorite POST answered 401 with no Authorization
     // header at all, so the client never attached the token, and the note sent the run to the
@@ -259,51 +362,213 @@ for (const one of found.slice(0, MAX_TRACES)) {
     const authSpace = authValue.search(/\\s/)
     const authWord = authSpace > 0 ? authValue.slice(0, authSpace) : ''
     const authScheme = /^[A-Za-z][A-Za-z0-9._~+/-]{0,23}$/.test(authWord) ? authWord : undefined
-    const sentCookie = headerList.some(function (h) {
-      return h && typeof h.name === 'string' && /^cookie$/i.test(h.name)
-    })
-    requests.push({
-      method: String(request.method).toUpperCase(),
-      path: String(request.url).slice(0, MAX_URL),
-      status: Number(response.status) || 0,
-      failure: typeof response._failureText === 'string' ? response._failureText : undefined,
-      type: type,
-      sentAuthorization: authHeader !== undefined,
-      authorization: authScheme,
-      sentCookie: sentCookie,
-      // The HAR entry carries the monotonic clock the trace's action entries use, so a request
-      // can be attributed to the action that caused it (see \`lastAction\` below).
-      startedAt: typeof snapshot._monotonicTime === 'number' ? snapshot._monotonicTime : undefined,
-      postData: request.postData,
-      content: response.content,
-    })
+      const sentCookie = headerList.some(function (h) {
+        return h && typeof h.name === 'string' && /^cookie$/i.test(h.name)
+      })
+      const parsed = {
+        method: String(request.method).toUpperCase(),
+        path: String(request.url).slice(0, MAX_URL),
+        status: Number(response.status) || 0,
+        failure: typeof response._failureText === 'string' ? response._failureText : undefined,
+        type: type,
+        sentAuthorization: authHeader !== undefined,
+        authorization: authScheme,
+        sentCookie: sentCookie,
+        // The HAR entry carries the monotonic clock the trace's action entries use, so a request
+        // can be attributed to the action that caused it (see \`lastAction\` below).
+        startedAt: typeof snapshot._monotonicTime === 'number' ? snapshot._monotonicTime : undefined,
+        // The context member and the page ref the HAR entry records: a request made by the test's
+        // helper context is not the failing page's, however late the archive wrote it (m160).
+        context: ctx.id,
+        pageId: typeof snapshot.pageref === 'string' ? snapshot.pageref : undefined,
+        postData: request.postData,
+        content: response.content,
+      }
+      ctx.requests.push(parsed)
+      requestsAll.push(parsed)
+    }
   }
   if (!origin) {
-    const first = requests.find(function (r) { return r.type === 'document' }) || requests[0]
+    const first = requestsAll.find(function (r) { return r.type === 'document' }) || requestsAll[0]
     origin = first ? originOf(first.path) : ''
   }
-  for (const r of requests) r.path = pathOf(r.path).slice(0, MAX_URL)
+  for (const r of requestsAll) r.path = pathOf(r.path).slice(0, MAX_URL)
   // The page's own actions, timed. before/after pair on the call id, and only the LIBRARY
   // traces carry a class and a method (Frame.goto, Locator.fill); the test runner's own
-  // trace times its hooks and fixtures with class Test, which is not a page action. Read BEFORE
-  // the request buckets: whether the navigation itself finished decides whether a subresource
-  // with no response is evidence (see \`navigationOpen\` below).
-  const ended = {}
-  for (const entry of trace) {
-    if (entry && entry.type === 'after' && typeof entry.callId === 'string' && typeof entry.endTime === 'number')
-      ended[entry.callId] = entry.endTime
+  // trace times its hooks and fixtures with class Test, which is not a page action. Each action
+  // keeps the context it came from and the page/frame its frame snapshot names, so the failing
+  // assertion's own page can be selected below (m160).
+  const actionsAll = []
+  const framesAll = []
+  for (const ctx of contexts) {
+    const ended = {}
+    for (const entry of ctx.trace) {
+      if (entry && entry.type === 'after' && typeof entry.callId === 'string' && typeof entry.endTime === 'number')
+        ended[entry.callId] = entry.endTime
+    }
+    const pageByCall = {}
+    for (const entry of ctx.trace) {
+      if (!entry || entry.type !== 'frame-snapshot') continue
+      const snap = entry.snapshot || {}
+      if (typeof snap.callId === 'string' && typeof snap.pageId === 'string' && pageByCall[snap.callId] === undefined)
+        pageByCall[snap.callId] = snap.pageId
+      if (snap.isMainFrame === false) continue
+      if (typeof snap.frameUrl !== 'string' || typeof snap.timestamp !== 'number') continue
+      ctx.frames.push({
+        url: pathOf(snap.frameUrl).slice(0, MAX_URL),
+        at: snap.timestamp,
+        context: ctx.id,
+        pageId: typeof snap.pageId === 'string' ? snap.pageId : undefined,
+        frameId: typeof snap.frameId === 'string' ? snap.frameId : undefined,
+      })
+    }
+    for (const entry of ctx.trace) {
+      if (!entry || entry.type !== 'before') continue
+      if (typeof entry.class !== 'string' || typeof entry.method !== 'string') continue
+      if (entry.class === 'Test' || typeof entry.startTime !== 'number') continue
+      const action = {
+        api: entry.class + '.' + entry.method,
+        start: entry.startTime,
+        end: typeof ended[entry.callId] === 'number' ? ended[entry.callId] : null,
+        context: ctx.id,
+        pageId: typeof entry.callId === 'string' ? pageByCall[entry.callId] : undefined,
+        frameId: undefined,
+        stepId: typeof entry.stepId === 'string' ? entry.stepId : undefined,
+      }
+      if (action.pageId !== undefined) {
+        for (const frame of ctx.frames) {
+          if (frame.pageId !== action.pageId) continue
+          action.frameId = frame.frameId
+          break
+        }
+      }
+      ctx.actions.push(action)
+    }
+    // Monotonic time, not archive order: two contexts interleave in the zip, and one context's
+    // own actions still have to be read in the order the page performed them.
+    ctx.actions.sort(function (a, b) { return a.start - b.start })
+    ctx.frames.sort(function (a, b) { return a.at - b.at })
+    for (const action of ctx.actions) actionsAll.push(action)
+    for (const frame of ctx.frames) framesAll.push(frame)
   }
-  const actions = []
-  for (const entry of trace) {
-    if (!entry || entry.type !== 'before') continue
-    if (typeof entry.class !== 'string' || typeof entry.method !== 'string') continue
-    if (entry.class === 'Test' || typeof entry.startTime !== 'number') continue
-    actions.push({
-      api: entry.class + '.' + entry.method,
-      start: entry.startTime,
-      end: typeof ended[entry.callId] === 'number' ? ended[entry.callId] : null,
-    })
+  // The step the runner itself reports as failed, and the location it names. The runner writes
+  // the error on the failed step's \`after\` entry; taking the LAST step with a spec stack instead
+  // named the afterEach's \`context.close()\` (m160's social.spec.ts:13) rather than the strict-mode
+  // assertion at :90. The first error is the test's own failure — an afterEach that also fails
+  // runs after it.
+  let failedStepId = null
+  let failedStep = null
+  let failedEnd = null
+  let failureSpec = null
+  let failureLine = 0
+  let lastSpec = null
+  let lastSpecLine = 0
+  for (const entry of runner) {
+    if (!entry) continue
+    if (entry.type === 'after' && entry.error && typeof entry.callId === 'string' && failedStepId === null) {
+      failedStepId = entry.callId
+      failedEnd = typeof entry.endTime === 'number' ? entry.endTime : null
+    }
+  }
+  // The fallback location — the last step that names a spec — is read from every member, runner
+  // and library alike: a trace written without a test.trace (a synthetic fixture, an older
+  // Playwright) still names its spec on the library entries, and dropping that would leave the
+  // row placeless.
+  for (const traceEntries of [runner].concat(contexts.map(function (ctx) { return ctx.trace }))) {
+    for (const entry of traceEntries) {
+      if (!entry || entry.type !== 'before' || !Array.isArray(entry.stack)) continue
+      for (const frame of entry.stack) {
+        if (typeof frame.file !== 'string' || !/\\.(?:spec|test)\\.[cm]?[jt]sx?$/.test(frame.file)) continue
+        lastSpec = specPathOf(frame.file)
+        lastSpecLine = Number(frame.line) || 0
+        break
+      }
+    }
   }
+  if (failedStepId !== null) {
+    for (const entry of runner) {
+      if (!entry || entry.type !== 'before' || entry.callId !== failedStepId) continue
+      failedStep = entry
+      if (!Array.isArray(entry.stack)) break
+      for (const frame of entry.stack) {
+        if (typeof frame.file !== 'string' || !/\\.(?:spec|test)\\.[cm]?[jt]sx?$/.test(frame.file)) continue
+        failureSpec = specPathOf(frame.file)
+        failureLine = Number(frame.line) || 0
+        break
+      }
+      break
+    }
+  }
+  const spec = failureSpec !== null ? failureSpec : lastSpec
+  const line = failureSpec !== null ? failureLine : lastSpecLine
+  // The page the failing step ran on. The library trace records the runner's step id on every
+  // action it performed for that step, and each action's frame snapshot carries its pageId — so
+  // the failing assertion's page is the step's own page, never the last page any context left
+  // behind (m160: the helper context's /editor won because its member came later in the zip).
+  let failedPageIds = []
+  if (failedStepId !== null) {
+    for (const action of actionsAll) {
+      if (action.stepId !== failedStepId || action.pageId === undefined) continue
+      if (failedPageIds.indexOf(action.pageId) === -1) failedPageIds.push(action.pageId)
+    }
+    // A step with no library action of its own (a plain \`page.waitForTimeout\`, a runner-only
+    // step) falls back to the actions that ran inside its own interval.
+    if (failedPageIds.length === 0 && failedStep !== null && typeof failedStep.startTime === 'number') {
+      for (const action of actionsAll) {
+        if (action.pageId === undefined) continue
+        if (action.start < failedStep.startTime - 1) continue
+        if (failedEnd !== null && action.start > failedEnd + 1) continue
+        if (failedPageIds.indexOf(action.pageId) === -1) failedPageIds.push(action.pageId)
+      }
+    }
+  }
+  let failedPage = failedPageIds.length === 1 ? failedPageIds[0] : null
+  // A member with no action, request or frame is not a context the test used: Playwright writes
+  // a trace entry for a context it opened and closed without a page, and counting that as a
+  // second context would make every ordinary trace unattributable.
+  const usedContexts = contexts.filter(function (ctx) {
+    return ctx.actions.length > 0 || ctx.requests.length > 0 || ctx.frames.length > 0
+  })
+  // One context, one page: nothing to attribute, and no second context to merge.
+  if (failedPage === null && usedContexts.length === 1) {
+    const pages = []
+    for (const frame of framesAll) {
+      if (frame.pageId !== undefined && pages.indexOf(frame.pageId) === -1) pages.push(frame.pageId)
+    }
+    if (pages.length === 1) failedPage = pages[0]
+  }
+  let failedContext = null
+  if (failedPage !== null) {
+    for (const frame of framesAll) {
+      if (frame.pageId !== failedPage) continue
+      failedContext = frame.context
+      break
+    }
+    if (failedContext === null) {
+      for (const action of actionsAll) {
+        if (action.pageId !== failedPage) continue
+        failedContext = action.context
+        break
+      }
+    }
+    if (failedContext === null) {
+      for (const r of requestsAll) {
+        if (r.pageId !== failedPage) continue
+        failedContext = r.context
+        break
+      }
+    }
+  }
+  // Two used contexts and no identified page: the note makes no causal claim rather than
+  // merging them (m160's rule). With one used context everything in it belongs to the test's page.
+  const unattributed = failedPage === null && usedContexts.length > 1
+  const actions = failedPage === null ? actionsAll : actionsAll.filter(function (a) { return a.pageId === failedPage })
+  const frames = failedPage === null ? (usedContexts.length === 1 ? framesAll : []) : framesAll.filter(function (f) { return f.pageId === failedPage })
+  let requests = failedPage === null ? requestsAll : requestsAll.filter(function (r) { return r.pageId === failedPage })
+  // A trace whose HAR entries carry no page ref: the failing context's own requests are still
+  // its page's, because a context in a test with one page has nowhere else to send them.
+  if (failedPage !== null && requests.length === 0 && failedContext !== null)
+    requests = requestsAll.filter(function (r) { return r.context === failedContext })
   // A \`page.goto\` that has no end time: the page never finished loading. When that is the
   // failure, a document subresource with no response is the reason — the navigation waits for
   // its stylesheets and scripts — and it is evidence, not the aborted noise a finished
@@ -393,7 +658,9 @@ for (const one of found.slice(0, MAX_TRACES)) {
   // then rendering signed-out) leads instead of the Home page's own fetch.
   const USER_ACTION = /\\.(?:click|dblclick|tap|fill|press|pressSequentially|selectOption|check|uncheck|setInputFiles|goto|type)$/
   const userActions = actions.filter(function (a) { return USER_ACTION.test(a.api) })
-  const lastAction = userActions.length > 0 ? userActions[userActions.length - 1] : null
+  // With two contexts and no identified page there is no causal claim to make: the last action
+  // of the concatenation could belong to the helper's page (m160).
+  const lastAction = unattributed || userActions.length === 0 ? null : userActions[userActions.length - 1]
   // A request the action caused started after it (a millisecond of clock slack) and before the
   // assertion — which is everything later in the trace. A request that started before it is the
   // page's own load, not the action's; the page shell's files are never the step's, except a
@@ -431,7 +698,7 @@ for (const one of found.slice(0, MAX_TRACES)) {
   for (const i of actionIndexes) {
     const r = requests[i]
     const sent = bodyText(buf, entries, r.postData, MAX_BODY)
-    const got = bodyText(buf, entries, r.content, MAX_BODY)
+    const got = gotText(buf, entries, r)
     if (sent) r.sent = sent
     if (got) r.got = got
   }
@@ -439,7 +706,7 @@ for (const one of found.slice(0, MAX_TRACES)) {
     if (r.status < 400 || r.status >= 500) continue
     if (/^https?:/i.test(r.path)) continue
     const sent = bodyText(buf, entries, r.postData, MAX_BODY)
-    const got = bodyText(buf, entries, r.content, MAX_BODY)
+    const got = gotText(buf, entries, r)
     if (sent) r.sent = sent
     if (got) r.got = got
   }
@@ -458,19 +725,13 @@ for (const one of found.slice(0, MAX_TRACES)) {
       ...(r.sentAuthorization ? { sentAuthorization: true } : {}),
       ...(r.authorization ? { authorization: r.authorization } : {}),
       ...(r.sentCookie ? { sentCookie: true } : {}),
+      ...(r.context ? { context: r.context } : {}),
+      ...(r.pageId ? { pageId: r.pageId } : {}),
     }
   }
-  // The main frame's URL, timed: what the page showed when the action ran, and where it ended up.
-  // The trace records these around every action, which is how the note can say what the page did
-  // after the request — a client-side redirect never appears in the network log as a document.
-  const frames = []
-  for (const entry of trace) {
-    if (!entry || entry.type !== 'frame-snapshot') continue
-    const snap = entry.snapshot || {}
-    if (snap.isMainFrame === false) continue
-    if (typeof snap.frameUrl !== 'string' || typeof snap.timestamp !== 'number') continue
-    frames.push({ url: pathOf(snap.frameUrl).slice(0, MAX_URL), at: snap.timestamp })
-  }
+  // The failing page's own frame snapshots, timed: what the page showed when the action ran, and
+  // where it ended up. They are the snapshots of the assertion's page only — another context's
+  // editor page is not where this page went (m160) — and they are ordered by the trace's clock.
   let last = null
   if (lastAction !== null) {
     let pageBefore
@@ -494,8 +755,9 @@ for (const one of found.slice(0, MAX_TRACES)) {
   }
   // The fallback lead stays for traces with no action clock. With an action, only a request it
   // caused is the lead; an action that sent none leaves the page's own load to the row's
-  // "also answered" bucket, not to a lead that would hide it.
-  if (lead === null && lastAction === null) {
+  // "also answered" bucket, not to a lead that would hide it. With two contexts and no identified
+  // page there is no causal lead at all (m160).
+  if (!unattributed && lead === null && lastAction === null) {
     let leadIndex = -1
     for (let i = requests.length - 1; i >= 0; i--) {
       const r = requests[i]
@@ -509,7 +771,7 @@ for (const one of found.slice(0, MAX_TRACES)) {
     if (leadIndex !== -1) {
       const r = requests[leadIndex]
       const sent = bodyText(buf, entries, r.postData, MAX_BODY)
-      const got = bodyText(buf, entries, r.content, MAX_BODY)
+      const got = gotText(buf, entries, r)
       lead = wire(r)
       if (sent) lead.sent = sent
       if (got) lead.got = got
@@ -555,24 +817,49 @@ for (const one of found.slice(0, MAX_TRACES)) {
   const consoleErrors = []
   const consoleSignals = []
   const consoleWarnings = []
-  let spec = null
-  let line = 0
-  for (const entry of trace) {
-    if (!entry) continue
-    if (entry.type === 'console' && typeof entry.text === 'string') {
-      if (entry.messageType === 'error') consoleErrors.push(entry.text)
-      else if (consoleSignal(entry.text)) consoleSignals.push(entry.text)
-      else if (entry.messageType === 'warning' || entry.messageType === 'warn')
-        consoleWarnings.push(entry.text)
-    } else if (entry.type === 'event' && entry.method === 'pageError') {
-      const message = messageOf(entry.params)
-      if (message) consoleErrors.push(message)
-    } else if (entry.type === 'before' && Array.isArray(entry.stack) && entry.stack.length) {
-      const frame = entry.stack[0] || {}
-      if (typeof frame.file === 'string' && /\\.(?:spec|test)\\.[cm]?[jt]sx?$/.test(frame.file)) {
-        spec = specPathOf(frame.file)
-        line = Number(frame.line) || 0
+  // The console lines of the page the assertion ran on; with no identified page, of every context.
+  const consoleTraces =
+    failedContext === null
+      ? contexts.map(function (ctx) { return ctx.trace })
+      : contexts.filter(function (ctx) { return ctx.id === failedContext }).map(function (ctx) { return ctx.trace })
+  for (const traceEntries of consoleTraces) {
+    for (const entry of traceEntries) {
+      if (!entry) continue
+      if (entry.type === 'console' && typeof entry.text === 'string') {
+        if (entry.messageType === 'error') consoleErrors.push(entry.text)
+        else if (consoleSignal(entry.text)) consoleSignals.push(entry.text)
+        else if (entry.messageType === 'warning' || entry.messageType === 'warn')
+          consoleWarnings.push(entry.text)
+      } else if (entry.type === 'event' && entry.method === 'pageError') {
+        const message = messageOf(entry.params)
+        if (message) consoleErrors.push(message)
+      }
+    }
+  }
+  // Evidence from the OTHER browser contexts the test opened — kept apart from the failing page's
+  // requests and labelled as set-up work, never as the failing action's effect (m160).
+  const otherContexts = []
+  if (failedContext !== null) {
+    for (const ctx of usedContexts) {
+      if (ctx.id === failedContext) continue
+      const picked = []
+      for (const r of ctx.requests) {
+        if (shellRequest(r)) continue
+        const sent = bodyText(buf, entries, r.postData, MAX_BODY)
+        const got = gotText(buf, entries, r)
+        if (sent) r.sent = sent
+        if (got) r.got = got
+        picked.push(r)
       }
+      if (picked.length === 0 && ctx.actions.length === 0) continue
+      // Failures first, then by the trace's clock: a 401 from the helper context is worth naming
+      // even when its later answered calls would fill the bound.
+      picked.sort(function (a, b) {
+        const left = failedRequest(a) ? 0 : 1
+        const right = failedRequest(b) ? 0 : 1
+        return left === right ? (a.startedAt || 0) - (b.startedAt || 0) : left - right
+      })
+      otherContexts.push({ context: ctx.id, requests: picked.slice(0, MAX_NOTE).map(wire) })
     }
   }
   // Chromium reports every failed request as a console error too; where the page logged something
@@ -596,6 +883,8 @@ for (const one of found.slice(0, MAX_TRACES)) {
     requests: chosen.slice(0, MAX_REQUESTS),
     console: keptConsole.slice(0, MAX_CONSOLE).map(function (text) { return text.slice(0, 300) }),
     actions: actions.slice(-MAX_ACTIONS),
+    ...(unattributed ? { unattributed: true } : {}),
+    ...(otherContexts.length > 0 ? { otherContexts: otherContexts } : {}),
   }) + '\\n')
 }
 `;
@@ -624,6 +913,8 @@ function parseTraceRequest(value) {
             ? { authorization: r.authorization }
             : {}),
         ...(r.sentCookie === true ? { sentCookie: true } : {}),
+        ...(typeof r.context === 'string' && r.context ? { context: r.context } : {}),
+        ...(typeof r.pageId === 'string' && r.pageId ? { pageId: r.pageId } : {}),
     };
 }
 /**
@@ -671,6 +962,17 @@ export function parseTraceArtifacts(stdout) {
             const actions = Array.isArray(raw.actions) ? raw.actions : [];
             const lead = parseTraceRequest(raw.lead);
             const lastAction = parseLastAction(raw.lastAction);
+            const otherContexts = Array.isArray(raw.otherContexts)
+                ? raw.otherContexts
+                    .filter((c) => typeof c === 'object' && c !== null)
+                    .filter((c) => typeof c.context === 'string')
+                    .map((c) => ({
+                    context: String(c.context),
+                    requests: (Array.isArray(c.requests) ? c.requests : [])
+                        .map(parseTraceRequest)
+                        .filter((request) => request !== null),
+                }))
+                : [];
             out.push({
                 spec: typeof raw.spec === 'string' ? raw.spec : null,
                 line: typeof raw.line === 'number' ? raw.line : 0,
@@ -687,7 +989,12 @@ export function parseTraceArtifacts(stdout) {
                     api: String(a.api),
                     start: Number(a.start),
                     end: a.end === null || a.end === undefined ? null : Number(a.end),
+                    ...(typeof a.context === 'string' ? { context: a.context } : {}),
+                    ...(typeof a.pageId === 'string' ? { pageId: a.pageId } : {}),
+                    ...(typeof a.frameId === 'string' ? { frameId: a.frameId } : {}),
                 })),
+                ...(otherContexts.length === 0 ? {} : { otherContexts }),
+                ...(raw.unattributed === true ? { unattributed: true } : {}),
             });
         }
         catch (_error) {
@@ -1009,6 +1316,36 @@ function runFailureOf(item, failures) {
     }
     return undefined;
 }
+/**
+ * Where the row names this failing test.
+ *
+ * The trace names the line of the step it recorded — the failing assertion when the runner wrote
+ * its error on that step, and the suite's `afterEach` (`context.close()`) when it did not. The
+ * runner's own summary names the test's DECLARATION line, and that is the location the result
+ * quotes and the line a re-run command takes, so it wins whenever the run reported one for this
+ * file: matched by the trace's own line inside the test body ({@link runFailureOf}), and otherwise
+ * by the file alone when that file has exactly ONE reported failure — an `afterEach` line sits
+ * BEFORE the declaration, so the line window cannot match it (xr-molecule-flash-m163's row said
+ * `navigation.spec.ts:12`, the suite's `afterEach`, for the test declared at `:200`).
+ *
+ * @param item - One traced failure.
+ * @param failures - The runner's report, one entry per failing test.
+ * @returns The `file:line` the row names.
+ */
+function failureWhereOf(item, failures) {
+    const spec = item.spec;
+    if (spec === null)
+        return whereOf(item);
+    let reported = runFailureOf(item, failures);
+    if (reported === undefined) {
+        const sameFile = failures.filter((failure) => sameLocationFile(spec, failure.spec));
+        if (sameFile.length === 1)
+            reported = sameFile[0];
+    }
+    if (reported === undefined)
+        return whereOf(item);
+    return reported.line > 0 ? `${reported.spec}:${reported.line}` : reported.spec;
+}
 /**
  * Whether a pending request's interval covers a navigation's wait: it started while the
  * navigation was loading (at or after the wait began) and it has no recorded response, so it was
@@ -1420,6 +1757,14 @@ function missingApiPrefixSentence(request) {
  * (answered 201, the page still rendering signed-out) never appeared. With no action clock, the
  * row falls back to {@link TraceArtifact.lead}: the page's last answered fetch/xhr.
  *
+ * The action, the URL and the requests are the FAILING ASSERTION'S PAGE's ({@link
+ * TraceArtifact.lastAction}), never the archive's last context: a test that creates its data in a
+ * second browser context writes that context's click and `/editor` snapshot into the same zip, and
+ * reading the concatenation made them the failing page (xr-molecule-flash-m160). The other
+ * contexts' requests are named separately as set-up work. When the trace holds more than one used
+ * context and the assertion's page cannot be identified, the note lists the requests and makes NO
+ * causal claim — no "the test's last action", no "the page stayed at …" — instead of merging them.
+ *
  * WHICH rows it spends is evidence, not artifact order (xr-molecule-flash-m112 +53:46): a row
  * needs a recorded response, a real failure or a console line ({@link traceRowEvidence}), rows are
  * deduplicated by the test's location, and they are ordered real failure → repeated from an
@@ -1474,6 +1819,7 @@ function missingApiPrefixSentence(request) {
  *   error.
  */
 export function failureTraceNote(items, target, earlierFailures = [], apiPrefixes = [], report = {}) {
+    const failures = report.failures ?? [];
     const candidates = items.filter((item) => traceRowEvidence(item, report));
     if (candidates.length === 0)
         return null;
@@ -1486,7 +1832,7 @@ export function failureTraceNote(items, target, earlierFailures = [], apiPrefixe
     const seen = new Set();
     for (const { item, index } of ranked) {
         // A trace that names no spec cannot be placed; it is never collapsed onto another one.
-        const where = item.spec === null ? `#${index}` : whereOf(item);
+        const where = item.spec === null ? `#${index}` : failureWhereOf(item, failures);
         if (seen.has(where))
             continue;
         seen.add(where);
@@ -1540,6 +1886,9 @@ export function failureTraceNote(items, target, earlierFailures = [], apiPrefixe
     ];
     const anyStalled = stalls.some((stall) => stall !== null);
     const rows = [];
+    // Rows whose failing action sent nothing and left the page on a new route: the page is still
+    // showing the previous route's data. Counted so the note can say it once for the whole run.
+    let staleRouteRows = 0;
     for (const [index, item] of traced.entries()) {
         // The test's LAST action before the failing assertion leads the row (m148): the requests it
         // caused and what came back explain a page that never showed the signed-in state, while the
@@ -1577,7 +1926,26 @@ export function failureTraceNote(items, target, earlierFailures = [], apiPrefixe
         const parts = [];
         if (step !== undefined && !stalledNav) {
             const head = `the test's last action was ${step.api} at ${actionClock(item, step.start)}`;
-            if (stepRequests.length === 0) {
+            const pageBefore = step.pageBefore;
+            const pageAfter = step.pageAfter;
+            // The action asked the API for nothing and the page ended up on another route: the page is
+            // still showing the data it fetched for the route before, which is why the new route's list
+            // is wrong (xr-molecule-flash-m163 +10:00 — the note printed "it sent no request" beside
+            // "the page then navigated to …", then pointed at a response body that never existed, and
+            // the run spent six minutes on markup and CSS).
+            const staleRoute = stepRequests.length === 0 &&
+                pageBefore !== undefined &&
+                pageAfter !== undefined &&
+                pageBefore !== pageAfter;
+            if (staleRoute) {
+                staleRouteRows += 1;
+                parts.push(`${head}, and it sent no request — the page moved from ${pageBefore} to ${pageAfter}. ` +
+                    `The page changed route but fetched nothing new, so it is still showing the previous ` +
+                    `route's data: check how the page reads the route (a param the route does not define ` +
+                    `is always undefined; a missing effect dependency on the route means the fetch never ` +
+                    `re-runs), not the markup or the CSS`);
+            }
+            else if (stepRequests.length === 0) {
                 parts.push(`${head}, and it sent no request`);
             }
             else {
@@ -1589,10 +1957,10 @@ export function failureTraceNote(items, target, earlierFailures = [], apiPrefixe
             }
             // What the page did next: a navigation shows in the main frame's URL even when the app moved
             // client-side and the network log recorded no document request.
-            if (step.pageAfter !== undefined) {
-                parts.push(step.pageBefore !== undefined && step.pageBefore !== step.pageAfter
-                    ? `the page then navigated to ${step.pageAfter}`
-                    : `the page stayed at ${step.pageAfter}`);
+            if (!staleRoute && pageAfter !== undefined) {
+                parts.push(pageBefore !== undefined && pageBefore !== pageAfter
+                    ? `the page then navigated to ${pageAfter}`
+                    : `the page stayed at ${pageAfter}`);
             }
             // A 4xx on the logout endpoint with the page unmoved is not a backend failure: the auth
             // client swallows the call and clears the session, and the URL can only move if the page
@@ -1649,14 +2017,29 @@ export function failureTraceNote(items, target, earlierFailures = [], apiPrefixe
                 .slice(0, 2)
                 .map((text) => text.replace(/\s+/g, ' ').trim().slice(0, 160))
                 .join(' | ')}`);
-        rows.push(`  ${index + 1}. ${whereOf(item)} — ${parts.join(' — ')}`);
+        // A request from another browser context the test opened is not the failing action's effect:
+        // it is set-up work on a different page, and it is named as such rather than merged into the
+        // row (xr-molecule-flash-m160: the helper context's POST /api/articles was printed as the
+        // click's effect while the assertion had failed on the profile page).
+        const others = (item.otherContexts ?? []).filter((context) => context.requests.length > 0);
+        for (const [otherIndex, context] of others.slice(0, 2).entries()) {
+            const label = otherIndex === 0
+                ? 'a second browser context, opened by the test for set-up and not the page the assertion ran on'
+                : 'another browser context the test opened';
+            parts.push(`${label}: ${context.requests.slice(0, 2).map(requestLine).join('; ')}`);
+        }
+        rows.push(`  ${index + 1}. ${failureWhereOf(item, failures)} — ${parts.join(' — ')}`);
     }
     // Distinct locations the note did not name: the repeats collapse, so the count is what is left
     // to look at, not how many zips Playwright wrote.
-    const distinct = new Set(candidates.map((item, index) => (item.spec === null ? `#${index}` : whereOf(item))));
+    const distinct = new Set(candidates.map((item, index) => item.spec === null ? `#${index}` : failureWhereOf(item, failures)));
     const more = distinct.size > traced.length
         ? `\n  … and ${distinct.size - traced.length} more traced failures`
         : '';
+    // Every row came from a trace with more than one browser context and no page to tie the
+    // assertion to: the note may list the requests, and may not say what action sent them or where
+    // "the page" went (m160).
+    const allUnattributed = traced.every((item) => item.unattributed === true);
     // A run whose pages never loaded has one cause, and it is not in the app: every traced failure is
     // a `page.goto` that timed out on a document the browser could not load. The transport error is
     // the first line the executor needs — m118 (+37:09) read 14 goto timeouts as app failures while
@@ -1699,12 +2082,33 @@ export function failureTraceNote(items, target, earlierFailures = [], apiPrefixe
                     `and if the stall repeats measure that exact fetch ` +
                     `(\`curl -o /dev/null -w '%{time_starttransfer} %{time_total}' <url>\`) before ` +
                     `treating it as the app's.\n\n`);
+    // Every row is a route change that fetched nothing: the cause and the next read are the same
+    // for the whole run, and the generic "read the response body" paragraph would point at a
+    // response that never existed (xr-molecule-flash-m163 +10:00).
+    const everyStaleRoute = staleRouteRows > 0 &&
+        staleRouteRows === traced.length &&
+        !anyFailed &&
+        !anyStalled &&
+        !allUnattributed &&
+        transport === null;
+    const staleRouteLead = everyStaleRoute
+        ? `Every failure this run traced is the same shape: the failing action asked the API for ` +
+            `nothing and the page changed route, so the page is still showing the data it fetched for ` +
+            `the route before. Read how each page derives its query from the route — a param the route ` +
+            `does not define is always undefined, and a missing effect dependency on the route means ` +
+            `the fetch never re-runs — before touching the markup or the CSS.\n\n`
+        : '';
     return (transportLead +
         stalledLead +
+        staleRouteLead +
         `The platform read the failing tests' own Playwright traces from the run against ${target} ` +
-        `(what each page sent and got — first what the test's last action sent and where the page went ` +
-        `next, then the requests that failed, the ones that got no response, and its last answered ` +
-        `ones):\n` +
+        (allUnattributed
+            ? `(what each page sent and got — the requests their contexts recorded, with no claim about ` +
+                `which action caused them, then the ones that failed, the ones that got no response, and ` +
+                `the last answered ones):\n`
+            : `(what each page sent and got — first what the test's last action sent and where the page ` +
+                `went next, then the requests that failed, the ones that got no response, and its last ` +
+                `answered ones):\n`) +
         `${rows.join('\n')}${more}\n` +
         (anyFailed
             ? everyFailureLacksPrefix
@@ -1734,13 +2138,24 @@ export function failureTraceNote(items, target, earlierFailures = [], apiPrefixe
                         'not finish loading because its own subresource never answered. Do not read this as a ' +
                         'page-state bug: re-run these tests against the same URL first, and change the app only ' +
                         'if the same navigation times out again with no stalled asset in the trace.'
-                : 'No listed request failed — none got a 4xx/5xx or a network error — so the cause is in the ' +
-                    "page, not the API. Start with what the test's last action sent (the first line of each " +
-                    'row) and what the page did next: a request that answered (2xx included) while the page ' +
-                    'still did not show the state the assertion waited on is the fact to read — its status ' +
-                    'and response body, not the selector. If the request is not the one the test meant — an ' +
-                    'unfollow sent where the test clicked follow — the state the action read was stale ' +
-                    'before it.') +
+                : allUnattributed
+                    ? 'No listed request failed — none got a 4xx/5xx or a network error. The trace held more ' +
+                        'than one browser context and nothing ties a page to the failing assertion, so no ' +
+                        'action or URL is attributed here: read the requests above together with the runner’s ' +
+                        'own failure text to tell which page the test asserted on, and read that page’s state, ' +
+                        'not the selector.'
+                    : everyStaleRoute
+                        ? 'No listed request failed — none got a 4xx/5xx or a network error — and the failing ' +
+                            'action sent no request at all, so there is no response to read. The page changed ' +
+                            'route and fetched nothing, which is why it still shows the previous route’s data: ' +
+                            'fix how the page reads the route, not the selector.'
+                        : 'No listed request failed — none got a 4xx/5xx or a network error — so the cause is in the ' +
+                            "page, not the API. Start with what the test's last action sent (the first line of each " +
+                            'row) and what the page did next: a request that answered (2xx included) while the page ' +
+                            'still did not show the state the assertion waited on is the fact to read — its status ' +
+                            'and response body, not the selector. If the request is not the one the test meant — an ' +
+                            'unfollow sent where the test clicked follow — the state the action read was stale ' +
+                            'before it.') +
         prefixAdvice +
         (wrapped
             ? ' The API received a body wrapped in `data`: app-http’s `post(url, data, config)` / ' +