tewip-ai 0.4.0

package/dist/engine/similarity.js

@@ -0,0 +1,76 @@
+const STOP_WORDS = new Set(['a', 'an', 'the', 'to', 'of', 'and', 'or', 'for', 'in', 'on', 'with', 'your', 'my', 'data', 'testid', 'test', 'id', 'qa', 'js', 'el', 'div', 'span']);
+const SYNONYMS = {
+    btn: 'button',
+    input: 'textbox',
+    field: 'textbox',
+    image: 'img',
+    icon: 'img',
+    anchor: 'link',
+    lnk: 'link',
+    dropdown: 'combobox',
+    select: 'combobox',
+};
+export const ROLE_WORDS = new Set(['button', 'link', 'textbox', 'checkbox', 'radio', 'combobox', 'heading', 'img', 'listitem', 'tab', 'menuitem', 'option', 'dialog', 'searchbox', 'switch', 'slider']);
+export function tokenize(text) {
+    return text
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((t) => t.length > 1 && !/^\d+$/.test(t) && !STOP_WORDS.has(t))
+        .map((t) => SYNONYMS[t] ?? t);
+}
+/** The human words inside a locator string, without Playwright API names. */
+export function locatorWords(locator) {
+    const role = locator.match(/getByRole\(\s*['"]([a-z]+)['"]/)?.[1];
+    const stripped = locator
+        .replace(/\b(?:locator|getBy[A-Z]\w*|frameLocator|internal:[\w-]+)\b/g, ' ')
+        .replace(/\b(?:name|exact|hasText|hasNotText|has|nth|first|last|filter)\b\s*[:(]?/g, ' ');
+    return { tokens: tokenize(stripped), role };
+}
+function bigrams(word) {
+    const out = new Set();
+    for (let i = 0; i < word.length - 1; i++)
+        out.add(word.slice(i, i + 2));
+    return out;
+}
+/** 1 for equal words, high for prefixes and small typos, 0 for unrelated words. */
+function wordSimilarity(a, b) {
+    if (a === b)
+        return 1;
+    if (Math.min(a.length, b.length) >= 4 && (a.startsWith(b) || b.startsWith(a)))
+        return 0.85;
+    const [x, y] = [bigrams(a), bigrams(b)];
+    const shared = [...x].filter((g) => y.has(g)).length;
+    const dice = x.size + y.size === 0 ? 0 : (2 * shared) / (x.size + y.size);
+    return dice >= 0.7 ? dice : 0;
+}
+/**
+ * Soft Dice overlap of word sets. Role words (button, link, ...) count toward the score
+ * but can't carry it alone: at least one content word must match.
+ */
+export function similarity(target, element) {
+    const content = target.tokens.filter((t) => !ROLE_WORDS.has(t));
+    const wantsRole = target.tokens.some((t) => ROLE_WORDS.has(t));
+    const words = tokenize(`${element.name} ${element.text}`);
+    const candidate = wantsRole ? [...new Set([...words, ...tokenize(element.role)])] : words;
+    if (content.length === 0 || words.length === 0)
+        return 0;
+    const best = (t) => Math.max(0, ...candidate.map((c) => wordSimilarity(t, c)));
+    if (!content.some((t) => best(t) > 0))
+        return 0;
+    const matched = target.tokens.reduce((sum, t) => sum + best(t), 0);
+    const score = Math.min(1, (2 * matched) / (target.tokens.length + candidate.length));
+    return target.role && target.role !== element.role ? score * 0.7 : score;
+}
+/** Snapshot elements most similar to the locator, best first; zero scores dropped. */
+export function rankCandidates(locator, elements) {
+    const target = locatorWords(locator);
+    return elements
+        .map((element) => ({ element, score: similarity(target, element) }))
+        .filter((r) => r.score > 0)
+        .sort((a, b) => b.score - a.score);
+}
+export function describeElement(element) {
+    const label = element.name || element.text;
+    return label ? `${element.role} "${label}"` : element.role;
+}

package/dist/engine/snapshot.js

@@ -0,0 +1,56 @@
+// Reads the page snapshot Playwright stores in error-context.md when a test fails.
+// It is an ARIA snapshot (roles + accessible names), captured at the moment of failure.
+import { existsSync, readFileSync } from 'node:fs';
+import { join, posix } from 'node:path';
+import { PROJECT_ROOT } from '../reporters/store.js';
+/** Absolute path of the record's error-context.md, or null if it no longer exists. */
+export function errorContextPath(record) {
+    const direct = record.attachments.find((a) => a.name === 'error-context')?.path;
+    // Records collected before the reporter kept this attachment: it sits next to the trace.
+    const first = record.attachments[0]?.path;
+    const sibling = first ? posix.join(posix.dirname(first), 'error-context.md') : undefined;
+    for (const rel of [direct, sibling]) {
+        if (rel && existsSync(join(PROJECT_ROOT, rel)))
+            return join(PROJECT_ROOT, rel);
+    }
+    return null;
+}
+export function readPageSnapshot(record) {
+    const file = errorContextPath(record);
+    return file ? extractPageSnapshot(readFileSync(file, 'utf8')) : null;
+}
+/**
+ * The page snapshot yaml of an error-context.md document. Playwright puts it under
+ * "# Page snapshot" for action failures, but for expect() failures it follows the error
+ * details with no heading, so fall back to the first yaml block.
+ */
+export function pageSnapshotYaml(markdown) {
+    return markdown.match(/# Page snapshot\s*```yaml\r?\n([\s\S]*?)```/)?.[1] ?? markdown.match(/```yaml\r?\n([\s\S]*?)```/)?.[1] ?? null;
+}
+export function extractPageSnapshot(markdown) {
+    const yaml = pageSnapshotYaml(markdown);
+    return yaml === null ? null : parseAriaSnapshot(yaml);
+}
+// - role "name" [attr] [ref=e1]: text
+const LINE = /^\s*-\s+([a-z]+)(?:\s+"((?:[^"\\]|\\.)*)")?((?:\s+\[[^\]]*\])*)\s*(?::\s*(.*))?$/;
+export function parseAriaSnapshot(yaml) {
+    const elements = [];
+    for (const line of yaml.split(/\r?\n/)) {
+        const m = LINE.exec(line);
+        if (!m)
+            continue;
+        const [, role, name = '', attrs = '', text = ''] = m;
+        elements.push({ role, name: unquote(`"${name}"`), text: unquote(text.trim()), ref: attrs.match(/\[ref=([^\]]+)\]/)?.[1] });
+    }
+    return elements;
+}
+function unquote(value) {
+    if (value.length < 2 || !value.startsWith('"') || !value.endsWith('"'))
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value.slice(1, -1);
+    }
+}

package/dist/engine/timing-rules.js

@@ -0,0 +1,188 @@
+import { driverClickIntercepted, driverStaleElement } from './driver-errors.js';
+import { errorShape, truncate } from './signature.js';
+export const FLAKY_MIN_RATE = 0.2;
+export const FLAKY_MAX_RATE = 0.8;
+export const TIMING_MIN_RUNS = 3;
+const pct = (rate) => `${Math.round(rate * 100)}%`;
+/**
+ * Any request that failed during the test. Narrowing this to server errors and no-response was
+ * measured and changed nothing on the labelled data, while it would stop a 401 (expired login)
+ * from counting as the environment problem it is, so every failed request still counts.
+ */
+function dependencyFailure(load) {
+    return (load?.() ?? [])[0];
+}
+function declined(source, message, data) {
+    return { category: null, confidence: 0, evidence: [{ source, message, data }] };
+}
+/**
+ * The test failed but another attempt of the same code in the same run passed: Playwright's
+ * own "flaky" signal. A deterministic cause (real bug, drifted locator) would fail every
+ * attempt. Confidence stays below the auto-fix threshold: the rule knows a race happened,
+ * not where. Network signals are handled first by env-network.
+ */
+export const timingRetryPass = {
+    id: 'timing-retry-pass',
+    evaluate({ history }) {
+        const { currentRunAttempts: attempts, currentRunFailures: failures } = history;
+        if (attempts < 2 || failures >= attempts)
+            return null;
+        return {
+            category: 'TIMING',
+            confidence: 0.75,
+            evidence: [{ source: this.id, message: `${failures} of ${attempts} attempts in this run failed and another attempt of the same code passed`, data: { attempts, failures } }],
+        };
+    },
+};
+/** Intermittent failures whose error keeps changing: a race, not a deterministic break. */
+export const timingFlaky = {
+    id: 'timing-flaky',
+    evaluate({ history }) {
+        const { runs, failures, failureRate, distinctErrors } = history;
+        if (failureRate < FLAKY_MIN_RATE || failureRate > FLAKY_MAX_RATE)
+            return null;
+        const rate = `fails ${pct(failureRate)} of the time (${failures}/${runs} runs)`;
+        if (runs < TIMING_MIN_RUNS)
+            return declined(this.id, `${rate}, too few runs to call it flaky (need ${TIMING_MIN_RUNS})`);
+        if (distinctErrors < 2) {
+            return declined(this.id, `${rate} but always with the same error; rules can't tell a race from an intermittent real bug`);
+        }
+        return {
+            category: 'TIMING',
+            confidence: Math.min(0.9, 0.5 + 0.05 * runs),
+            evidence: [{ source: this.id, message: `${rate} with ${distinctErrors} different errors`, data: { runs, failures, failureRate, distinctErrors } }],
+        };
+    },
+};
+/**
+ * Playwright found the element, waited until it was visible, enabled and stable, and then the
+ * click still could not land because another element was on top of it: an overlay, a toast or a
+ * menu that had not gone away yet. That is a race in the page, not a broken feature and not a
+ * renamed element. On every labelled dataset (32 cases across five projects) each failure with
+ * this text is a TIMING failure. Confidence stays below the auto-fix line: the agent knows a
+ * race happened, not which wait to add (rules-7).
+ */
+export const timingIntercepted = {
+    id: 'timing-intercepted',
+    evaluate({ record }) {
+        const match = record.errorMessage.match(/<[^>]+>[^\n]*intercepts pointer events/);
+        if (match) {
+            const what = truncate(match[0].replace(/\s+/g, ' ').trim(), 100);
+            return {
+                category: 'TIMING',
+                confidence: 0.8,
+                evidence: [{ source: this.id, message: `the element was ready but the click could not land: ${what}, so something was still on top of it`, data: { intercepted: what } }],
+            };
+        }
+        // Selenium and Cypress report the same race in their own words. No labelled data from those
+        // tools has measured this yet, so the confidence stays below what the merge gate trusts.
+        const other = driverClickIntercepted(record.errorMessage);
+        if (!other)
+            return null;
+        const what = truncate(other.replace(/\s+/g, ' '), 100);
+        return {
+            category: 'TIMING',
+            confidence: 0.65,
+            evidence: [{ source: this.id, message: `the click could not land because ${what} was on top of the element, so something had not gone away yet`, data: { intercepted: what } }],
+        };
+    },
+};
+/**
+ * Selenium's stale element (and Cypress's "the page updated while this command was executing"):
+ * the test found the element, then the page re-rendered and replaced it before the test used it.
+ * That is a race between the test and the page, fixed by finding the element again, not a broken
+ * feature. Unmeasured on labelled data, so below the merge gate's trust line.
+ */
+export const timingStaleElement = {
+    id: 'timing-stale-element',
+    evaluate({ record }) {
+        const stale = driverStaleElement(record.errorMessage);
+        if (!stale)
+            return null;
+        return {
+            category: 'TIMING',
+            confidence: 0.65,
+            evidence: [{ source: this.id, message: `"${truncate(stale, 80)}": the element was found, then the page replaced it before the test used it`, data: { stale } }],
+        };
+    },
+};
+/**
+ * A known flaky test failing the way it flaked before: in an earlier run it failed with this same
+ * error and then passed on a retry of the same code. This is the memory flaky-test products keep
+ * (a test flagged once stays flagged). On the nine labelled datasets, every later failure of such
+ * a test is TIMING or ENV, never a real bug or a renamed element, across five projects. Declines
+ * when a request failed during the test, since a flaky dependency is ENV (rules-8).
+ */
+export const timingKnownFlaky = {
+    id: 'timing-known-flaky',
+    evaluate({ record, history, loadFailedRequests }) {
+        const shape = errorShape(record.errorMessage);
+        if (!history.earlierFlakeShapes.includes(shape))
+            return null;
+        // A dependency failing during the test is checked first: that is ENV, whatever else holds.
+        const failed = dependencyFailure(loadFailedRequests);
+        if (failed) {
+            return declined(this.id, `this test flaked before with this same error, and ${failed.url} failed during it (${failed.status ?? 'no response'}): a dependency failing now and then is an environment problem, not a race inside the test`);
+        }
+        // A regression can wear an old flake's error. Its signature is different, though: it fails every
+        // retry on this commit while the test passes on other commits, where a flake usually passes one
+        // of its retries. Found by code review: without this, the merge gate could let such a
+        // regression through as "known flaky". Measured, most such failures are still the old flake, so
+        // the category stays TIMING, but at a confidence below what the merge gate trusts: a person
+        // looks before it can merge.
+        const retried = history.sameCommitAttempts >= 2;
+        if (retried && history.sameCommitFailures === history.sameCommitAttempts && history.passesOnOtherCommits > 0) {
+            return {
+                category: 'TIMING',
+                confidence: 0.6,
+                evidence: [
+                    {
+                        source: this.id,
+                        message: `a known flaky test failing its old way, but this time it failed all ${history.sameCommitAttempts} attempts on this commit while passing on other commits, which is also how a regression looks: a person should confirm`,
+                        data: { shape, regressionShaped: true },
+                    },
+                ],
+            };
+        }
+        return {
+            category: 'TIMING',
+            confidence: 0.75,
+            evidence: [{ source: this.id, message: 'a known flaky test: in an earlier run it failed with this same error and then passed on a retry of the same code', data: { shape } }],
+        };
+    },
+};
+/** Flips between passing and failing needed before a test counts as intermittent, not broken. */
+export const INTERMITTENT_MIN_ALTERNATIONS = 3;
+/**
+ * A test that keeps switching between passing and failing across commits. A change that breaks a
+ * test flips it once and it stays broken; a race flips it again and again. The deterministic
+ * rules above (drift on the page, data collisions, server errors) are checked first, so this only
+ * catches what none of them explains. Confidence stays well below the auto-fix threshold: the
+ * rule knows the failure is not deterministic, not where the race is (rules-6, from misreading
+ * cross-branch flakes as real bugs on real CI data).
+ */
+export const timingIntermittent = {
+    id: 'timing-intermittent',
+    evaluate({ history, loadFailedRequests }) {
+        const { alternations, runs, failures } = history;
+        if (alternations < INTERMITTENT_MIN_ALTERNATIONS)
+            return null;
+        // A dependency that fails now and then also makes a test come and go, and that is ENV, not a
+        // race in the test. Seen on held-out data, where an external media API broke this test.
+        const failed = dependencyFailure(loadFailedRequests);
+        if (failed) {
+            return declined(this.id, `this test comes and goes on this branch (${alternations} switches in ${runs} runs) and ${failed.url} failed during it (${failed.status ?? 'no response'}): a dependency failing now and then is an environment problem, not a race inside the test`);
+        }
+        return {
+            category: 'TIMING',
+            confidence: 0.7,
+            evidence: [
+                {
+                    source: 'timing-intermittent',
+                    message: `this test switched between passing and failing ${alternations} times across the last ${runs} runs (${failures} failed): it comes and goes rather than staying broken`,
+                    data: { alternations, runs, failures },
+                },
+            ],
+        };
+    },
+};

package/dist/engine/trace/dom.js

@@ -0,0 +1,92 @@
+// Rebuilds DOM snapshots from a trace and condenses them into a short element list.
+// Trace snapshots are incremental: a node can be [[n, i]], meaning "node i (post-order)
+// of the snapshot n steps back for the same frame". Mirrors Playwright's snapshotRenderer.
+const isElement = (n) => Array.isArray(n) && typeof n[0] === 'string';
+const isReference = (n) => Array.isArray(n) && Array.isArray(n[0]);
+/** Post-order list of the raw (unresolved) nodes of one snapshot, as the references index them. */
+function rawNodes(snapshot, cache) {
+    let nodes = cache.get(snapshot);
+    if (!nodes) {
+        const out = [];
+        const visit = (n) => {
+            if (typeof n === 'string')
+                out.push(n);
+            else if (isElement(n)) {
+                for (const child of n.slice(2))
+                    visit(child);
+                out.push(n);
+            }
+        };
+        visit(snapshot.html);
+        cache.set(snapshot, (nodes = out));
+    }
+    return nodes;
+}
+/** Resolves the last snapshot of the main frame into a plain tree, or null if there is none. */
+export function lastMainFrameDom(snapshots) {
+    const main = snapshots.filter((s) => s.isMainFrame !== false);
+    if (main.length === 0)
+        return null;
+    const frameId = main[main.length - 1].frameId;
+    const frame = snapshots.filter((s) => s.frameId === frameId);
+    const cache = new Map();
+    const resolve = (n, index, depth) => {
+        if (depth > 200)
+            return null;
+        if (typeof n === 'string')
+            return n;
+        if (isReference(n)) {
+            const refIndex = index - n[0][0];
+            const target = frame[refIndex] ? rawNodes(frame[refIndex], cache)[n[0][1]] : undefined;
+            return target === undefined ? null : resolve(target, refIndex, depth + 1);
+        }
+        if (!isElement(n))
+            return null;
+        const [tag, attrs, ...children] = n;
+        const resolved = children.map((c) => resolve(c, index, depth + 1)).filter((c) => c !== null);
+        return { tag: tag.toUpperCase(), attrs: attrs ?? {}, children: resolved };
+    };
+    const root = resolve(frame[frame.length - 1].html, frame.length - 1, 0);
+    return root && typeof root !== 'string' ? { url: frame[frame.length - 1].frameUrl, root } : null;
+}
+const SKIP_TAGS = new Set(['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEMPLATE', 'svg', 'SVG', 'HEAD']);
+const NOTABLE_TAGS = new Set(['BUTTON', 'A', 'INPUT', 'SELECT', 'TEXTAREA', 'LABEL', 'FORM', 'H1', 'H2', 'H3', 'H4', 'DIALOG', 'IMG', 'TABLE']);
+const KEPT_ATTRS = ['id', 'data-testid', 'data-test', 'data-qa', 'name', 'type', 'role', 'aria-label', 'placeholder', 'href', 'disabled', 'hidden', 'aria-hidden', 'aria-busy'];
+function textOf(node) {
+    if (typeof node === 'string')
+        return node;
+    if (SKIP_TAGS.has(node.tag))
+        return '';
+    return node.children.map(textOf).join(' ');
+}
+const clip = (s, max) => (s.length <= max ? s : `${s.slice(0, max - 1)}…`);
+function describe(node) {
+    const attrs = KEPT_ATTRS.filter((a) => node.attrs[a] !== undefined).map((a) => `${a}="${clip(node.attrs[a], 40)}"`);
+    const classes = (node.attrs.class ?? '').split(/\s+/).filter(Boolean).slice(0, 2);
+    if (classes.length > 0)
+        attrs.push(`class="${classes.join(' ')}"`);
+    const text = clip(textOf(node).replace(/\s+/g, ' ').trim(), 60);
+    const tag = node.tag.toLowerCase();
+    return `<${tag}${attrs.length ? ' ' + attrs.join(' ') : ''}>${text}</${tag}>`;
+}
+/**
+ * Elements a selector is likely to target: interactive tags, headings, and anything with an
+ * id, test id, role or aria-label. Capped so the model gets a summary, not the page.
+ */
+export function notableElements(root, max = 60) {
+    const found = [];
+    const visit = (node) => {
+        if (SKIP_TAGS.has(node.tag))
+            return;
+        const a = node.attrs;
+        if (NOTABLE_TAGS.has(node.tag) || a.id || a['data-testid'] || a['data-test'] || a['data-qa'] || a.role || a['aria-label']) {
+            if (node.tag !== 'HTML' && node.tag !== 'BODY')
+                found.push(describe(node));
+        }
+        for (const child of node.children)
+            if (typeof child !== 'string')
+                visit(child);
+    };
+    visit(root);
+    return { elements: found.slice(0, max), omitted: Math.max(0, found.length - max) };
+}

package/dist/engine/trace/trace-summary.js

@@ -0,0 +1,87 @@
+// Condenses a Playwright trace.zip into the facts a triage model needs: the final DOM,
+// failed network requests, console errors and the last test steps. Never raw logs.
+import { stripVTControlCharacters } from 'node:util';
+import { lastMainFrameDom, notableElements } from './dom.js';
+import { readZipEntries } from './zip.js';
+const MAX_STEPS = 12;
+const MAX_ITEMS = 10;
+const clip = (s, max) => (s.length <= max ? s : `${s.slice(0, max - 1)}…`);
+function parseJsonl(buffers) {
+    const events = [];
+    for (const buf of buffers) {
+        for (const line of buf.toString('utf8').split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                events.push(JSON.parse(line));
+            }
+            catch {
+                // A trace cut short by a crash can end with a partial line; skip it.
+            }
+        }
+    }
+    return events;
+}
+/** Keeps origin + path, drops query strings (they can carry tokens) and fragments. */
+function shortUrl(url) {
+    try {
+        const u = new URL(url);
+        return `${u.origin}${u.pathname}`;
+    }
+    catch {
+        return clip(url, 120);
+    }
+}
+function summarizeSteps(testEvents, contextEvents) {
+    const after = new Map(testEvents.filter((e) => e.type === 'after').map((e) => [e.callId, e]));
+    // Protocol-level calls carry the selector / url; they link to test steps through stepId.
+    const params = new Map(contextEvents.filter((e) => e.type === 'before' && e.stepId).map((e) => [e.stepId, e.params ?? {}]));
+    return testEvents
+        .filter((e) => e.type === 'before' && !e.parentId && /^(pw:api|expect)@/.test(e.callId ?? ''))
+        .map((e) => {
+        const end = after.get(e.callId);
+        const p = params.get(e.callId) ?? {};
+        const target = p.selector ?? p.url ?? p.event ?? p.expression ?? '';
+        const ms = end?.endTime !== undefined ? Math.round(end.endTime - e.startTime) : null;
+        const outcome = end?.error ? ` FAILED: ${clip(stripVTControlCharacters(String(end.error.message ?? '')).split('\n')[0], 100)}` : '';
+        return `${e.title}${target ? ` ${clip(String(target), 80)}` : ''}${ms !== null ? ` (${ms}ms)` : ''}${outcome}`;
+    })
+        .slice(-MAX_STEPS);
+}
+export function summarizeTrace(tracePath) {
+    const entries = readZipEntries(tracePath, (name) => /^(\d+-trace\.(trace|network)|test\.trace)$/.test(name));
+    const byKind = (re) => [...entries].filter(([name]) => re.test(name)).map(([, buf]) => buf);
+    const contextEvents = parseJsonl(byKind(/^\d+-trace\.trace$/));
+    const networkEvents = parseJsonl(byKind(/^\d+-trace\.network$/));
+    const testEvents = parseJsonl(byKind(/^test\.trace$/));
+    const snapshots = contextEvents.filter((e) => e.type === 'frame-snapshot').map((e) => e.snapshot);
+    const dom = lastMainFrameDom(snapshots);
+    const notable = dom ? notableElements(dom.root) : { elements: [], omitted: 0 };
+    const resources = networkEvents.filter((e) => e.type === 'resource-snapshot').map((e) => e.snapshot);
+    const failed = resources
+        .filter((r) => !r.response || r.response.status >= 400 || r.response.status <= 0 || r.response._failureText)
+        .slice(0, MAX_ITEMS)
+        .map((r) => ({
+        method: String(r.request?.method ?? 'GET'),
+        url: shortUrl(String(r.request?.url ?? '')),
+        status: r.response && r.response.status > 0 ? Number(r.response.status) : null,
+        ...(r.response?._failureText ? { error: String(r.response._failureText) } : {}),
+    }));
+    const consoleEvents = contextEvents.filter((e) => e.type === 'console');
+    const pageErrors = contextEvents
+        .filter((e) => e.type === 'event' && e.method === 'pageError')
+        .map((e) => clip(String(e.params?.error?.error?.message ?? e.params?.error?.message ?? JSON.stringify(e.params?.error ?? '')), 200))
+        .slice(0, MAX_ITEMS);
+    return {
+        pageUrl: dom ? shortUrl(dom.url) : null,
+        domElements: notable.elements,
+        domElementsOmitted: notable.omitted,
+        network: { requests: resources.length, failed },
+        console: {
+            errors: consoleEvents.filter((e) => e.messageType === 'error').map((e) => clip(String(e.text), 200)).slice(0, MAX_ITEMS),
+            warnings: consoleEvents.filter((e) => e.messageType === 'warning').length,
+        },
+        pageErrors,
+        steps: summarizeSteps(testEvents, contextEvents),
+    };
+}

package/dist/engine/trace/zip.js

@@ -0,0 +1,53 @@
+// Minimal zip reader for Playwright trace.zip files (stored or deflated entries, no zip64,
+// no encryption). Only the entries the caller asks for are decompressed.
+import { readFileSync } from 'node:fs';
+import { inflateRawSync } from 'node:zlib';
+const EOCD_SIGNATURE = 0x06054b50;
+const CENTRAL_SIGNATURE = 0x02014b50;
+const LOCAL_SIGNATURE = 0x04034b50;
+export function readZipEntries(file, wanted) {
+    return readZipBuffer(readFileSync(file), wanted, file);
+}
+/** Same as readZipEntries for a zip already in memory (e.g. a zip nested in another zip). */
+export function readZipBuffer(buf, wanted, file = 'zip') {
+    let eocd = -1;
+    for (let i = buf.length - 22; i >= Math.max(0, buf.length - 22 - 0xffff); i--) {
+        if (buf.readUInt32LE(i) === EOCD_SIGNATURE) {
+            eocd = i;
+            break;
+        }
+    }
+    if (eocd < 0)
+        throw new Error(`${file} is not a zip file`);
+    const count = buf.readUInt16LE(eocd + 10);
+    let offset = buf.readUInt32LE(eocd + 16);
+    const entries = new Map();
+    for (let i = 0; i < count; i++) {
+        if (buf.readUInt32LE(offset) !== CENTRAL_SIGNATURE)
+            throw new Error(`${file}: corrupt central directory`);
+        const method = buf.readUInt16LE(offset + 10);
+        const compressedSize = buf.readUInt32LE(offset + 20);
+        const nameLength = buf.readUInt16LE(offset + 28);
+        const extraLength = buf.readUInt16LE(offset + 30);
+        const commentLength = buf.readUInt16LE(offset + 32);
+        const localOffset = buf.readUInt32LE(offset + 42);
+        const name = buf.toString('utf8', offset + 46, offset + 46 + nameLength);
+        offset += 46 + nameLength + extraLength + commentLength;
+        if (!wanted(name))
+            continue;
+        if (compressedSize === 0xffffffff || localOffset === 0xffffffff)
+            throw new Error(`${file}: zip64 entries are not supported`);
+        if (buf.readUInt32LE(localOffset) !== LOCAL_SIGNATURE)
+            throw new Error(`${file}: corrupt local header for ${name}`);
+        // The local header's extra field can differ in length from the central one.
+        const dataStart = localOffset + 30 + buf.readUInt16LE(localOffset + 26) + buf.readUInt16LE(localOffset + 28);
+        const data = buf.subarray(dataStart, dataStart + compressedSize);
+        if (method === 0)
+            entries.set(name, data);
+        else if (method === 8)
+            entries.set(name, inflateRawSync(data));
+        else
+            throw new Error(`${file}: unsupported compression method ${method} for ${name}`);
+    }
+    return entries;
+}

package/dist/eval/harvest/gh.js

@@ -0,0 +1,21 @@
+// Thin wrapper around the GitHub CLI for read-only calls against public repositories.
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+const WINDOWS_GH = 'C:\\Program Files\\GitHub CLI\\gh.exe';
+const GH = process.env.GH_PATH || (existsSync(WINDOWS_GH) ? WINDOWS_GH : 'gh');
+/** Runs `gh <args>` and resolves with stdout; async so several calls can run at once. */
+export function ghRaw(args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(GH, args);
+        const out = [];
+        const err = [];
+        child.stdout.on('data', (d) => out.push(d));
+        child.stderr.on('data', (d) => err.push(d));
+        child.on('error', reject);
+        child.on('close', (code) => code === 0 ? resolve(Buffer.concat(out)) : reject(new Error(`gh ${args.slice(0, 2).join(' ')} failed: ${Buffer.concat(err).toString('utf8').trim().slice(0, 300)}`)));
+    });
+}
+export async function ghApi(path) {
+    return JSON.parse((await ghRaw(['api', path])).toString('utf8'));
+}
+export const downloadArtifact = (repo, artifactId) => ghRaw(['api', `repos/${repo}/actions/artifacts/${artifactId}/zip`]);