@xera-ai/web 0.1.5 → 0.1.7

package/dist/core/src/jira/types.d.ts

@@ -0,0 +1,28 @@
+export interface JiraTicket {
+    key: string;
+    summary: string;
+    story: string;
+    acceptanceCriteria?: string;
+    attachments: Array<{
+        filename: string;
+        url: string;
+    }>;
+    raw: Record<string, unknown>;
+}
+export interface JiraFieldMap {
+    story: string;
+    acceptanceCriteria?: string;
+}
+export interface JiraClient {
+    readonly backend: 'mcp' | 'rest';
+    fetchTicket(key: string, fields: JiraFieldMap): Promise<JiraTicket>;
+    postComment(key: string, body: string): Promise<{
+        id: string;
+    }>;
+    transitionStatus(key: string, statusName: string): Promise<void>;
+    listFields(sampleKey: string): Promise<Array<{
+        id: string;
+        name: string;
+        hasContent: boolean;
+    }>>;
+}

package/dist/core/src/lock/file-lock.d.ts

@@ -0,0 +1,11 @@
+export interface LockData {
+    pid: number;
+    hostname: string;
+    started_at: string;
+    run_id: string;
+}
+export declare function acquireLock(path: string, runId: string): boolean;
+export declare function releaseLock(path: string): void;
+export declare function readLock(path: string): LockData | null;
+export declare function isLockStale(path: string): boolean;
+export declare function forceUnlock(path: string): void;

package/dist/core/src/logging/ndjson-logger.d.ts

@@ -0,0 +1,10 @@
+export interface LogEntry {
+    ts: string;
+    [key: string]: unknown;
+}
+export declare class NdjsonLogger {
+    private readonly path;
+    constructor(path: string);
+    log(payload: Record<string, unknown>): void;
+    static readAll(path: string): LogEntry[];
+}

package/dist/index.js

@@ -1,6 +1,9 @@
 // @bun
 var __require = import.meta.require;
 
+// src/adapter.ts
+import { join as join3 } from "path";
+
 // src/executor/index.ts
 import { join } from "path";
 
@@ -29,7 +32,10 @@ async function runPlaywright(input) {
     outputDir: input.outputDir
   });
   const spawn = input.spawn ?? defaultSpawn;
-  const { exitCode } = await spawn("npx", ["playwright", ...args], { ...process.env, ...input.env });
+  const { exitCode } = await spawn("npx", ["playwright", ...args], {
+    ...process.env,
+    ...input.env
+  });
   return {
     outcome: exitCode === 0 ? "PASS" : "FAIL",
     rawReportPath: join(input.outputDir, "report.json"),
@@ -38,7 +44,7 @@ async function runPlaywright(input) {
 }
 
 // src/trace-normalizer/normalize.ts
-import { readFileSync as readFileSync2, existsSync, writeFileSync } from "fs";
+import { existsSync, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { join as join2 } from "path";
 
 // src/trace-normalizer/parse.ts
@@ -100,8 +106,12 @@ var SENSITIVE_BODY_KEYS = [
 ];
 var JWT_RE = /\beyJ[A-Za-z0-9_-]{7,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{5,}\b/;
 var CREDIT_CARD_RE = /\b(?:\d{4}[-\s]?){3}\d{4}\b/;
+var EMAIL_RE = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/;
+var PHONE_RE = /(?:\+?\d[\d\s().-]{6,}\d)/;
 var JWT_RE_G = new RegExp(JWT_RE.source, "g");
 var CREDIT_CARD_RE_G = new RegExp(CREDIT_CARD_RE.source, "g");
+var EMAIL_RE_G = new RegExp(EMAIL_RE.source, "g");
+var PHONE_RE_G = new RegExp(PHONE_RE.source, "g");
 var REDACTED = "[REDACTED]";
 function scrubHeaders(headers) {
   const out = {};
@@ -129,7 +139,7 @@ function scrubBodyJson(body) {
   return body;
 }
 function scrubFreeText(s) {
-  return s.replace(JWT_RE_G, REDACTED).replace(CREDIT_CARD_RE_G, REDACTED);
+  return s.replace(JWT_RE_G, REDACTED).replace(CREDIT_CARD_RE_G, REDACTED).replace(EMAIL_RE_G, REDACTED).replace(PHONE_RE_G, REDACTED);
 }
 
 // src/trace-normalizer/scrub.ts
@@ -250,7 +260,6 @@ async function normalizeRun(input) {
 }
 
 // src/adapter.ts
-import { join as join3 } from "path";
 var WebAdapter = {
   id: "web",
   async generate(_input) {
@@ -282,7 +291,11 @@ var WebAdapter = {
       await import("@playwright/test");
       checks.push({ name: "@playwright/test installed", ok: true });
     } catch {
-      checks.push({ name: "@playwright/test installed", ok: false, message: "Run `bun add -D @playwright/test`." });
+      checks.push({
+        name: "@playwright/test installed",
+        ok: false,
+        message: "Run `bun add -D @playwright/test`."
+      });
     }
     return { ok: checks.every((c) => c.ok), checks };
   }
@@ -319,7 +332,7 @@ async function runAuthSetup(input) {
   }
 }
 // src/auth-setup/playwright-state.ts
-import { writeFileSync as writeFileSync2, mkdirSync } from "fs";
+import { mkdirSync, writeFileSync as writeFileSync2 } from "fs";
 import { join as join4 } from "path";
 import { readAuthState } from "@xera-ai/core";
 function stagePlaywrightState(authDir, role) {
@@ -357,18 +370,45 @@ function validateGherkin(content) {
 }
 // src/generator/typecheck.ts
 import { spawnSync } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { dirname, join as join5 } from "path";
+function findNearestTsconfig(start) {
+  let dir = start;
+  while (true) {
+    const candidate = join5(dir, "tsconfig.json");
+    if (existsSync2(candidate))
+      return candidate;
+    const parent = dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
 async function typecheckTicket(ticketDir) {
-  const proc = spawnSync("npx", ["tsc", "--noEmit", "--project", ticketDir], { encoding: "utf8" });
+  const tsconfig = findNearestTsconfig(ticketDir);
+  if (!tsconfig) {
+    return {
+      ok: false,
+      errors: [
+        `No tsconfig.json found walking up from ${ticketDir}. Run \`xera init\` to scaffold one at the project root.`
+      ]
+    };
+  }
+  const proc = spawnSync("npx", ["tsc", "--noEmit", "-p", tsconfig], { encoding: "utf8" });
   if (proc.status === 0)
     return { ok: true, errors: [] };
-  const out = (proc.stdout || "") + (proc.stderr || "");
-  const errors = out.split(`
+  const out = `${proc.stdout ?? ""}${proc.stderr ?? ""}`;
+  const allErrors = out.split(`
 `).filter((line) => /error TS\d+/.test(line));
-  return { ok: false, errors };
+  const ticketErrors = allErrors.filter((line) => line.includes(ticketDir));
+  return {
+    ok: false,
+    errors: ticketErrors.length > 0 ? ticketErrors : allErrors
+  };
 }
 // src/generator/lint.ts
-import { readFileSync as readFileSync3, existsSync as existsSync2, readdirSync } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync } from "fs";
+import { join as join6 } from "path";
 
 // src/generator/selector-rules.ts
 var AUTO_CLASS_RE = /\.(?:Mui|css|ant|chakra|MuiButton)[A-Za-z]*-[A-Za-z0-9_]*-[A-Za-z0-9_]{3,}/;
@@ -383,16 +423,31 @@ function lintSelectors(source) {
     const text = lines[i];
     const prev = lines[i - 1] ?? "";
     if (XPATH_RE.test(text)) {
-      warnings.push({ rule: "no-xpath", line: i + 1, text, message: "XPath selectors are forbidden in v0.1." });
+      warnings.push({
+        rule: "no-xpath",
+        line: i + 1,
+        text,
+        message: "XPath selectors are forbidden in v0.1."
+      });
       continue;
     }
     const cssMatch = LOCATOR_CSS_RE.exec(text);
     if (cssMatch) {
       const sel = cssMatch[1];
       if (AUTO_CLASS_RE.test(sel)) {
-        warnings.push({ rule: "no-auto-classname", line: i + 1, text, message: `Auto-generated class name "${sel}" \u2014 refactor to role/label/test-id.` });
+        warnings.push({
+          rule: "no-auto-classname",
+          line: i + 1,
+          text,
+          message: `Auto-generated class name "${sel}" \u2014 refactor to role/label/test-id.`
+        });
       } else if (!ALLOW_CSS_RE.test(prev)) {
-        warnings.push({ rule: "prefer-role-over-css", line: i + 1, text, message: `Prefer getByRole/getByLabel over CSS "${sel}". If unavoidable, add "// xera-allow-css: <reason>" on the previous line.` });
+        warnings.push({
+          rule: "prefer-role-over-css",
+          line: i + 1,
+          text,
+          message: `Prefer getByRole/getByLabel over CSS "${sel}". If unavoidable, add "// xera-allow-css: <reason>" on the previous line.`
+        });
       }
     }
   }
@@ -401,11 +456,11 @@ function lintSelectors(source) {
 
 // src/generator/lint.ts
 function listTsFiles(dir) {
-  if (!existsSync2(dir))
+  if (!existsSync3(dir))
     return [];
   const out = [];
   for (const name of readdirSync(dir, { withFileTypes: true })) {
-    const full = join5(dir, name.name);
+    const full = join6(dir, name.name);
     if (name.isDirectory())
       out.push(...listTsFiles(full));
     else if (name.name.endsWith(".ts"))
@@ -425,18 +480,18 @@ async function lintTicket(ticketDir) {
   return { ok: warnings.length === 0, warnings };
 }
 // src/generator/pom-scan.ts
-import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync4 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync2 } from "fs";
+import { join as join7 } from "path";
 var CLASS_RE = /export\s+class\s+([A-Z][A-Za-z0-9_]*)/g;
 function scanSharedPoms(repoRoot) {
-  const dir = join6(repoRoot, "shared", "page-objects");
-  if (!existsSync3(dir))
+  const dir = join7(repoRoot, "shared", "page-objects");
+  if (!existsSync4(dir))
     return [];
   const found = [];
   for (const entry of readdirSync2(dir, { withFileTypes: true })) {
     if (!entry.isFile() || !entry.name.endsWith(".ts"))
       continue;
-    const path = join6(dir, entry.name);
+    const path = join7(dir, entry.name);
     const src = readFileSync4(path, "utf8");
     for (const m of src.matchAll(CLASS_RE)) {
       found.push({ className: m[1], absolutePath: path });
@@ -445,23 +500,23 @@ function scanSharedPoms(repoRoot) {
   return found;
 }
 // src/generator/promote.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3, renameSync } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync5, renameSync, writeFileSync as writeFileSync3 } from "fs";
+import { join as join8 } from "path";
 async function promotePom(input) {
-  const fromDir = join7(input.repoRoot, ".xera", input.ticket, "page-objects");
-  const toDir = join7(input.repoRoot, "shared", "page-objects");
+  const fromDir = join8(input.repoRoot, ".xera", input.ticket, "page-objects");
+  const toDir = join8(input.repoRoot, "shared", "page-objects");
   const file = `${input.className}.ts`;
-  const fromPath = join7(fromDir, file);
-  const toPath = join7(toDir, file);
-  if (!existsSync4(fromPath)) {
+  const fromPath = join8(fromDir, file);
+  const toPath = join8(toDir, file);
+  if (!existsSync5(fromPath)) {
     throw new Error(`POM ${file} not found at ${fromPath}`);
   }
-  if (existsSync4(toPath)) {
+  if (existsSync5(toPath)) {
     throw new Error(`POM ${file} already exists at ${toPath}. Reconcile manually before promoting.`);
   }
   renameSync(fromPath, toPath);
-  const specPath = join7(input.repoRoot, ".xera", input.ticket, "spec.ts");
-  if (existsSync4(specPath)) {
+  const specPath = join8(input.repoRoot, ".xera", input.ticket, "spec.ts");
+  if (existsSync5(specPath)) {
     const src = readFileSync5(specPath, "utf8");
     const updated = src.replace(new RegExp(`from\\s+['"]\\./page-objects/${input.className}['"]`, "g"), `from '../../shared/page-objects/${input.className}'`);
     writeFileSync3(specPath, updated);
@@ -489,6 +544,10 @@ export {
   WebAdapter,
   SENSITIVE_HEADERS,
   SENSITIVE_BODY_KEYS,
+  PHONE_RE_G,
+  PHONE_RE,
   JWT_RE,
+  EMAIL_RE_G,
+  EMAIL_RE,
   CREDIT_CARD_RE
 };

package/dist/web/src/generator/typecheck.d.ts

@@ -0,0 +1,10 @@
+export interface TypecheckResult {
+    ok: boolean;
+    errors: string[];
+}
+/**
+ * Type-check the ticket's TypeScript files using the project's root tsconfig.
+ * Errors are filtered to those whose path contains the ticket directory, so the
+ * skill sees only the locally relevant ones.
+ */
+export declare function typecheckTicket(ticketDir: string): Promise<TypecheckResult>;

package/dist/{trace-normalizer → web/src/trace-normalizer}/scrub-rules.d.ts

@@ -2,6 +2,10 @@ export declare const SENSITIVE_HEADERS: readonly string[];
 export declare const SENSITIVE_BODY_KEYS: readonly RegExp[];
 export declare const JWT_RE: RegExp;
 export declare const CREDIT_CARD_RE: RegExp;
+export declare const EMAIL_RE: RegExp;
+export declare const PHONE_RE: RegExp;
+export declare const EMAIL_RE_G: RegExp;
+export declare const PHONE_RE_G: RegExp;
 export declare function scrubHeaders(headers: Record<string, string>): Record<string, string>;
 export declare function scrubBodyJson(body: unknown): unknown;
 export declare function scrubFreeText(s: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xera-ai/web",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/adapter.ts

@@ -1,7 +1,14 @@
+import { join } from 'node:path';
+import type {
+  DoctorReport,
+  ExecuteInput,
+  GenerateInput,
+  GenerateResult,
+  RunResult,
+  TestAdapter,
+} from '@xera-ai/core/adapter';
 import { runPlaywright } from './executor';
 import { normalizeRun } from './trace-normalizer/normalize';
-import type { TestAdapter, GenerateInput, GenerateResult, ExecuteInput, RunResult, DoctorReport } from '@xera-ai/core/adapter';
-import { join } from 'node:path';
 
 export const WebAdapter: TestAdapter = {
   id: 'web',
@@ -22,7 +29,7 @@ export const WebAdapter: TestAdapter = {
     return {
       runId: input.runId,
       outcome: normalized.outcome,
-      scenarios: normalized.scenarios.map(s => {
+      scenarios: normalized.scenarios.map((s) => {
         const out: RunResult['scenarios'][number] = { name: s.name, outcome: s.outcome };
         if (s.failure !== undefined) out.failure = s.failure;
         return out;
@@ -39,8 +46,12 @@ export const WebAdapter: TestAdapter = {
       await import('@playwright/test');
       checks.push({ name: '@playwright/test installed', ok: true });
     } catch {
-      checks.push({ name: '@playwright/test installed', ok: false, message: 'Run `bun add -D @playwright/test`.' });
+      checks.push({
+        name: '@playwright/test installed',
+        ok: false,
+        message: 'Run `bun add -D @playwright/test`.',
+      });
     }
-    return { ok: checks.every(c => c.ok), checks };
+    return { ok: checks.every((c) => c.ok), checks };
   },
 };

package/src/auth-setup/playwright-state.ts

@@ -1,4 +1,4 @@
-import { writeFileSync, mkdirSync } from 'node:fs';
+import { mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { readAuthState } from '@xera-ai/core';
 

package/src/auth-setup/runner.ts

@@ -1,5 +1,5 @@
-import type { Browser } from '@playwright/test';
 import { pathToFileURL } from 'node:url';
+import type { Browser } from '@playwright/test';
 import { writeAuthState } from '@xera-ai/core';
 import type { AuthRoleCreds } from './define';
 

package/src/executor/index.ts

@@ -33,7 +33,10 @@ export async function runPlaywright(input: RunPlaywrightInput): Promise<RunPlayw
     outputDir: input.outputDir,
   });
   const spawn = input.spawn ?? defaultSpawn;
-  const { exitCode } = await spawn('npx', ['playwright', ...args], { ...process.env, ...input.env });
+  const { exitCode } = await spawn('npx', ['playwright', ...args], {
+    ...process.env,
+    ...input.env,
+  });
   return {
     outcome: exitCode === 0 ? 'PASS' : 'FAIL',
     rawReportPath: join(input.outputDir, 'report.json'),

package/src/generator/lint.ts

@@ -1,6 +1,6 @@
-import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
-import { lintSelectors, type SelectorWarning } from './selector-rules';
+import { type SelectorWarning, lintSelectors } from './selector-rules';
 
 export interface LintResult {
   ok: boolean;

package/src/generator/pom-scan.ts

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 
 const CLASS_RE = /export\s+class\s+([A-Z][A-Za-z0-9_]*)/g;

package/src/generator/promote.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
+import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 
 export interface PromoteInput {
@@ -18,7 +18,9 @@ export async function promotePom(input: PromoteInput): Promise<void> {
     throw new Error(`POM ${file} not found at ${fromPath}`);
   }
   if (existsSync(toPath)) {
-    throw new Error(`POM ${file} already exists at ${toPath}. Reconcile manually before promoting.`);
+    throw new Error(
+      `POM ${file} already exists at ${toPath}. Reconcile manually before promoting.`,
+    );
   }
 
   renameSync(fromPath, toPath);

package/src/generator/selector-rules.ts

@@ -17,16 +17,31 @@ export function lintSelectors(source: string): { warnings: SelectorWarning[] } {
     const text = lines[i]!;
     const prev = lines[i - 1] ?? '';
     if (XPATH_RE.test(text)) {
-      warnings.push({ rule: 'no-xpath', line: i + 1, text, message: 'XPath selectors are forbidden in v0.1.' });
+      warnings.push({
+        rule: 'no-xpath',
+        line: i + 1,
+        text,
+        message: 'XPath selectors are forbidden in v0.1.',
+      });
       continue;
     }
     const cssMatch = LOCATOR_CSS_RE.exec(text);
     if (cssMatch) {
       const sel = cssMatch[1]!;
       if (AUTO_CLASS_RE.test(sel)) {
-        warnings.push({ rule: 'no-auto-classname', line: i + 1, text, message: `Auto-generated class name "${sel}" — refactor to role/label/test-id.` });
+        warnings.push({
+          rule: 'no-auto-classname',
+          line: i + 1,
+          text,
+          message: `Auto-generated class name "${sel}" — refactor to role/label/test-id.`,
+        });
       } else if (!ALLOW_CSS_RE.test(prev)) {
-        warnings.push({ rule: 'prefer-role-over-css', line: i + 1, text, message: `Prefer getByRole/getByLabel over CSS "${sel}". If unavoidable, add "// xera-allow-css: <reason>" on the previous line.` });
+        warnings.push({
+          rule: 'prefer-role-over-css',
+          line: i + 1,
+          text,
+          message: `Prefer getByRole/getByLabel over CSS "${sel}". If unavoidable, add "// xera-allow-css: <reason>" on the previous line.`,
+        });
       }
     }
   }

package/src/generator/typecheck.ts

@@ -1,14 +1,54 @@
 import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 
 export interface TypecheckResult {
   ok: boolean;
   errors: string[];
 }
 
+/**
+ * Walks up from `start` looking for the first `tsconfig.json`. Returns null if
+ * none is found before reaching the filesystem root.
+ */
+function findNearestTsconfig(start: string): string | null {
+  let dir = start;
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    const candidate = join(dir, 'tsconfig.json');
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+/**
+ * Type-check the ticket's TypeScript files using the project's root tsconfig.
+ * Errors are filtered to those whose path contains the ticket directory, so the
+ * skill sees only the locally relevant ones.
+ */
 export async function typecheckTicket(ticketDir: string): Promise<TypecheckResult> {
-  const proc = spawnSync('npx', ['tsc', '--noEmit', '--project', ticketDir], { encoding: 'utf8' });
+  const tsconfig = findNearestTsconfig(ticketDir);
+  if (!tsconfig) {
+    return {
+      ok: false,
+      errors: [
+        `No tsconfig.json found walking up from ${ticketDir}. Run \`xera init\` to scaffold one at the project root.`,
+      ],
+    };
+  }
+
+  const proc = spawnSync('npx', ['tsc', '--noEmit', '-p', tsconfig], { encoding: 'utf8' });
   if (proc.status === 0) return { ok: true, errors: [] };
-  const out = (proc.stdout || '') + (proc.stderr || '');
-  const errors = out.split('\n').filter(line => /error TS\d+/.test(line));
-  return { ok: false, errors };
+
+  const out = `${proc.stdout ?? ''}${proc.stderr ?? ''}`;
+  const allErrors = out.split('\n').filter((line) => /error TS\d+/.test(line));
+  // Keep errors that originate inside the ticket dir; if none match, fall back
+  // to all errors so callers don't see "ok" for a broken root.
+  const ticketErrors = allErrors.filter((line) => line.includes(ticketDir));
+  return {
+    ok: false,
+    errors: ticketErrors.length > 0 ? ticketErrors : allErrors,
+  };
 }

package/src/trace-normalizer/normalize.ts

@@ -1,7 +1,7 @@
-import { readFileSync, existsSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { parsePlaywrightReport } from './parse';
-import { scrub, type NormalizedNetworkEntry, type NormalizedRun } from './scrub';
+import { type NormalizedNetworkEntry, type NormalizedRun, scrub } from './scrub';
 import { unzipTrace } from './unzip';
 
 export interface NormalizeRunInput {
@@ -20,7 +20,10 @@ interface TraceNetworkEntry {
   responseBody?: unknown;
 }
 
-interface TraceConsoleEntry { type: 'console'; text: string; }
+interface TraceConsoleEntry {
+  type: 'console';
+  text: string;
+}
 
 export async function normalizeRun(input: NormalizeRunInput): Promise<NormalizedRun> {
   const reportPath = join(input.runDir, 'report.json');
@@ -34,17 +37,27 @@ export async function normalizeRun(input: NormalizeRunInput): Promise<Normalized
     const networkFile = Object.entries(files).find(([k]) => k.endsWith('.network'))?.[1];
     const traceFile = Object.entries(files).find(([k]) => k.endsWith('.trace'))?.[1];
     const network: TraceNetworkEntry[] = networkFile
-      ? networkFile.trim().split('\n').filter(Boolean).map(l => JSON.parse(l)).filter((e: any) => e.type === 'request')
+      ? networkFile
+          .trim()
+          .split('\n')
+          .filter(Boolean)
+          .map((l) => JSON.parse(l))
+          .filter((e: any) => e.type === 'request')
       : [];
     const consoleEvents: TraceConsoleEntry[] = traceFile
-      ? traceFile.trim().split('\n').filter(Boolean).map(l => JSON.parse(l)).filter((e: any) => e.type === 'console')
+      ? traceFile
+          .trim()
+          .split('\n')
+          .filter(Boolean)
+          .map((l) => JSON.parse(l))
+          .filter((e: any) => e.type === 'console')
       : [];
 
     // Attach to each failing scenario (all entries — v0.1 doesn't yet correlate by step time)
     for (const sc of normalized.scenarios) {
       if (sc.outcome !== 'FAIL') continue;
       sc.failure = sc.failure ?? {};
-      sc.failure.networkAtFailure = network.map(n => {
+      sc.failure.networkAtFailure = network.map((n) => {
         const entry: NormalizedNetworkEntry = { method: n.method, url: n.url, status: n.status };
         if (n.requestHeaders !== undefined) entry.requestHeaders = n.requestHeaders;
         if (n.responseHeaders !== undefined) entry.responseHeaders = n.responseHeaders;
@@ -52,7 +65,7 @@ export async function normalizeRun(input: NormalizeRunInput): Promise<Normalized
         if (n.responseBody !== undefined) entry.responseBody = n.responseBody;
         return entry;
       });
-      sc.failure.consoleAtFailure = consoleEvents.map(c => c.text);
+      sc.failure.consoleAtFailure = consoleEvents.map((c) => c.text);
     }
   }
 

package/src/trace-normalizer/parse.ts

@@ -1,11 +1,33 @@
 import type { NormalizedRun, NormalizedScenario } from './scrub';
 
-interface PWAttachment { name: string; path?: string; contentType?: string; }
-interface PWResult { status: string; duration: number; error?: { message?: string; stack?: string }; attachments?: PWAttachment[]; }
-interface PWTest { results: PWResult[]; }
-interface PWSpec { title: string; ok: boolean; tests: PWTest[]; }
-interface PWSuite { title: string; specs?: PWSpec[]; suites?: PWSuite[]; }
-interface PWReport { stats: { unexpected: number }; suites: PWSuite[]; }
+interface PWAttachment {
+  name: string;
+  path?: string;
+  contentType?: string;
+}
+interface PWResult {
+  status: string;
+  duration: number;
+  error?: { message?: string; stack?: string };
+  attachments?: PWAttachment[];
+}
+interface PWTest {
+  results: PWResult[];
+}
+interface PWSpec {
+  title: string;
+  ok: boolean;
+  tests: PWTest[];
+}
+interface PWSuite {
+  title: string;
+  specs?: PWSpec[];
+  suites?: PWSuite[];
+}
+interface PWReport {
+  stats: { unexpected: number };
+  suites: PWSuite[];
+}
 
 function* flatSpecs(suites: PWSuite[]): Generator<PWSpec> {
   for (const s of suites) {
@@ -18,13 +40,16 @@ export function parsePlaywrightReport(report: PWReport, runId: string): Normaliz
   const scenarios: NormalizedScenario[] = [];
   for (const spec of flatSpecs(report.suites)) {
     const lastResult = spec.tests[0]?.results[0];
-    const outcome: 'PASS' | 'FAIL' | 'SKIPPED' =
-      !lastResult ? 'SKIPPED' :
-      lastResult.status === 'passed' ? 'PASS' :
-      lastResult.status === 'skipped' ? 'SKIPPED' : 'FAIL';
+    const outcome: 'PASS' | 'FAIL' | 'SKIPPED' = !lastResult
+      ? 'SKIPPED'
+      : lastResult.status === 'passed'
+        ? 'PASS'
+        : lastResult.status === 'skipped'
+          ? 'SKIPPED'
+          : 'FAIL';
     const sc: NormalizedScenario = { name: spec.title, outcome };
     if (outcome === 'FAIL' && lastResult) {
-      const screenshot = lastResult.attachments?.find(a => a.name === 'screenshot')?.path;
+      const screenshot = lastResult.attachments?.find((a) => a.name === 'screenshot')?.path;
       const failure: NormalizedScenario['failure'] = {};
       if (lastResult.error?.message !== undefined) failure!.errorMessage = lastResult.error.message;
       if (screenshot !== undefined) failure!.screenshotPath = screenshot;