@xera-ai/web 0.1.0

package/dist/adapter.d.ts

@@ -0,0 +1,2 @@
+import type { TestAdapter } from '@xera-ai/core/adapter';
+export declare const WebAdapter: TestAdapter;

package/dist/auth-setup/define.d.ts

@@ -0,0 +1,15 @@
+import type { Page } from '@playwright/test';
+export interface AuthRoleCreds {
+    email: string;
+    password: string;
+}
+export interface AuthSetupResult {
+    /** Optional explicit expiry hint, ms since epoch. */
+    expiresAt?: number;
+}
+export type AuthSetupFn = (page: Page, role: string, creds: AuthRoleCreds) => Promise<AuthSetupResult | void>;
+/**
+ * Helper to type-narrow the user's auth setup function. Users import this in
+ * `shared/auth-setup.ts`.
+ */
+export declare function defineAuthSetup(fn: AuthSetupFn): AuthSetupFn;

package/dist/auth-setup/playwright-state.d.ts

@@ -0,0 +1 @@
+export declare function stagePlaywrightState(authDir: string, role: string): string;

package/dist/auth-setup/runner.d.ts

@@ -0,0 +1,11 @@
+import type { Browser } from '@playwright/test';
+import type { AuthRoleCreds } from './define';
+export interface RunAuthSetupInput {
+    role: string;
+    creds: AuthRoleCreds;
+    setupScriptPath: string;
+    authDir: string;
+    browser: Browser;
+    now?: Date;
+}
+export declare function runAuthSetup(input: RunAuthSetupInput): Promise<void>;

package/dist/executor/index.d.ts

@@ -0,0 +1,17 @@
+export interface SpawnResult {
+    exitCode: number;
+}
+export type SpawnFn = (cmd: string, args: string[], env: NodeJS.ProcessEnv) => Promise<SpawnResult>;
+export interface RunPlaywrightInput {
+    specPath: string;
+    configPath: string;
+    outputDir: string;
+    env?: NodeJS.ProcessEnv;
+    spawn?: SpawnFn;
+}
+export interface RunPlaywrightResult {
+    outcome: 'PASS' | 'FAIL';
+    rawReportPath: string;
+    exitCode: number;
+}
+export declare function runPlaywright(input: RunPlaywrightInput): Promise<RunPlaywrightResult>;

package/dist/executor/playwright-args.d.ts

@@ -0,0 +1,6 @@
+export interface PlaywrightArgsInput {
+    specPath: string;
+    outputDir: string;
+    configPath: string;
+}
+export declare function buildPlaywrightArgs(input: PlaywrightArgsInput): string[];

package/dist/generator/gherkin-validate.d.ts

@@ -0,0 +1,8 @@
+export interface GherkinValidateResult {
+    ok: boolean;
+    errors: Array<{
+        line: number;
+        message: string;
+    }>;
+}
+export declare function validateGherkin(content: string): GherkinValidateResult;

package/dist/generator/lint.d.ts

@@ -0,0 +1,8 @@
+import { type SelectorWarning } from './selector-rules';
+export interface LintResult {
+    ok: boolean;
+    warnings: Array<SelectorWarning & {
+        file: string;
+    }>;
+}
+export declare function lintTicket(ticketDir: string): Promise<LintResult>;

package/dist/generator/pom-scan.d.ts

@@ -0,0 +1,5 @@
+export interface SharedPom {
+    className: string;
+    absolutePath: string;
+}
+export declare function scanSharedPoms(repoRoot: string): SharedPom[];

package/dist/generator/promote.d.ts

@@ -0,0 +1,6 @@
+export interface PromoteInput {
+    repoRoot: string;
+    ticket: string;
+    className: string;
+}
+export declare function promotePom(input: PromoteInput): Promise<void>;

package/dist/generator/selector-rules.d.ts

@@ -0,0 +1,9 @@
+export interface SelectorWarning {
+    rule: 'no-auto-classname' | 'prefer-role-over-css' | 'no-xpath';
+    line: number;
+    text: string;
+    message: string;
+}
+export declare function lintSelectors(source: string): {
+    warnings: SelectorWarning[];
+};

package/dist/generator/typecheck.d.ts

@@ -0,0 +1,5 @@
+export interface TypecheckResult {
+    ok: boolean;
+    errors: string[];
+}
+export declare function typecheckTicket(ticketDir: string): Promise<TypecheckResult>;

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export * from './adapter';
+export * from './auth-setup/define';
+export * from './auth-setup/runner';
+export * from './auth-setup/playwright-state';
+export * from './executor';
+export * from './executor/playwright-args';
+export * from './trace-normalizer/normalize';
+export * from './trace-normalizer/parse';
+export * from './trace-normalizer/scrub';
+export * from './trace-normalizer/scrub-rules';
+export * from './trace-normalizer/unzip';
+export * from './generator/gherkin-validate';
+export * from './generator/typecheck';
+export * from './generator/lint';
+export * from './generator/selector-rules';
+export * from './generator/pom-scan';
+export * from './generator/promote';

package/dist/index.js

@@ -0,0 +1,494 @@
+// @bun
+var __require = import.meta.require;
+
+// src/executor/index.ts
+import { join } from "path";
+
+// src/executor/playwright-args.ts
+function buildPlaywrightArgs(input) {
+  return [
+    "test",
+    input.specPath,
+    `--config=${input.configPath}`,
+    "--reporter=json",
+    `--output=${input.outputDir}`,
+    "--trace=on"
+  ];
+}
+
+// src/executor/index.ts
+var defaultSpawn = async (cmd, args, env) => {
+  const proc = Bun.spawn([cmd, ...args], { env, stdout: "inherit", stderr: "inherit" });
+  const exitCode = await proc.exited;
+  return { exitCode };
+};
+async function runPlaywright(input) {
+  const args = buildPlaywrightArgs({
+    specPath: input.specPath,
+    configPath: input.configPath,
+    outputDir: input.outputDir
+  });
+  const spawn = input.spawn ?? defaultSpawn;
+  const { exitCode } = await spawn("npx", ["playwright", ...args], { ...process.env, ...input.env });
+  return {
+    outcome: exitCode === 0 ? "PASS" : "FAIL",
+    rawReportPath: join(input.outputDir, "report.json"),
+    exitCode
+  };
+}
+
+// src/trace-normalizer/normalize.ts
+import { readFileSync as readFileSync2, existsSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+
+// src/trace-normalizer/parse.ts
+function* flatSpecs(suites) {
+  for (const s of suites) {
+    for (const sp of s.specs ?? [])
+      yield sp;
+    if (s.suites)
+      yield* flatSpecs(s.suites);
+  }
+}
+function parsePlaywrightReport(report, runId) {
+  const scenarios = [];
+  for (const spec of flatSpecs(report.suites)) {
+    const lastResult = spec.tests[0]?.results[0];
+    const outcome = !lastResult ? "SKIPPED" : lastResult.status === "passed" ? "PASS" : lastResult.status === "skipped" ? "SKIPPED" : "FAIL";
+    const sc = { name: spec.title, outcome };
+    if (outcome === "FAIL" && lastResult) {
+      const screenshot = lastResult.attachments?.find((a) => a.name === "screenshot")?.path;
+      const failure = {};
+      if (lastResult.error?.message !== undefined)
+        failure.errorMessage = lastResult.error.message;
+      if (screenshot !== undefined)
+        failure.screenshotPath = screenshot;
+      sc.failure = failure;
+    }
+    scenarios.push(sc);
+  }
+  return {
+    runId,
+    outcome: report.stats.unexpected === 0 ? "PASS" : "FAIL",
+    scenarios,
+    scrubbed_fields_count: 0
+  };
+}
+
+// src/trace-normalizer/scrub-rules.ts
+var SENSITIVE_HEADERS = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-auth-token",
+  "x-csrf-token",
+  "proxy-authorization"
+];
+var SENSITIVE_BODY_KEYS = [
+  /password/i,
+  /passwd/i,
+  /token/i,
+  /secret/i,
+  /api[-_]?key/i,
+  /access[-_]?key/i,
+  /private[-_]?key/i,
+  /authorization/i,
+  /credit[-_]?card/i,
+  /card[-_]?number/i,
+  /cvv/i
+];
+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 JWT_RE_G = new RegExp(JWT_RE.source, "g");
+var CREDIT_CARD_RE_G = new RegExp(CREDIT_CARD_RE.source, "g");
+var REDACTED = "[REDACTED]";
+function scrubHeaders(headers) {
+  const out = {};
+  for (const [k, v] of Object.entries(headers)) {
+    out[k] = SENSITIVE_HEADERS.includes(k.toLowerCase()) ? REDACTED : v;
+  }
+  return out;
+}
+function scrubBodyJson(body) {
+  if (Array.isArray(body))
+    return body.map(scrubBodyJson);
+  if (body && typeof body === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(body)) {
+      if (SENSITIVE_BODY_KEYS.some((re) => re.test(k))) {
+        out[k] = REDACTED;
+      } else {
+        out[k] = scrubBodyJson(v);
+      }
+    }
+    return out;
+  }
+  if (typeof body === "string")
+    return scrubFreeText(body);
+  return body;
+}
+function scrubFreeText(s) {
+  return s.replace(JWT_RE_G, REDACTED).replace(CREDIT_CARD_RE_G, REDACTED);
+}
+
+// src/trace-normalizer/scrub.ts
+function countScrubbed(before, after) {
+  if (typeof before === "string" && typeof after === "string")
+    return before !== after ? 1 : 0;
+  if (Array.isArray(before) && Array.isArray(after)) {
+    return before.reduce((acc, b, i) => acc + countScrubbed(b, after[i]), 0);
+  }
+  if (before && after && typeof before === "object" && typeof after === "object") {
+    let n = 0;
+    for (const k of Object.keys(before)) {
+      n += countScrubbed(before[k], after[k]);
+    }
+    return n;
+  }
+  return 0;
+}
+function scrub(run) {
+  const out = { ...run, scrubbed_fields_count: 0, scenarios: [] };
+  let totalScrubs = 0;
+  for (const sc of run.scenarios) {
+    const newSc = { ...sc };
+    if (sc.failure) {
+      const f = sc.failure;
+      const newF = { ...f };
+      if (f.errorMessage) {
+        newF.errorMessage = scrubFreeText(f.errorMessage);
+        totalScrubs += countScrubbed(f.errorMessage, newF.errorMessage);
+      }
+      if (f.consoleAtFailure) {
+        newF.consoleAtFailure = f.consoleAtFailure.map(scrubFreeText);
+        totalScrubs += f.consoleAtFailure.reduce((acc, b, i) => acc + countScrubbed(b, newF.consoleAtFailure[i]), 0);
+      }
+      if (f.networkAtFailure) {
+        newF.networkAtFailure = f.networkAtFailure.map((n) => {
+          const reqHeaders = n.requestHeaders ? scrubHeaders(n.requestHeaders) : undefined;
+          const resHeaders = n.responseHeaders ? scrubHeaders(n.responseHeaders) : undefined;
+          const reqBody = n.requestBody !== undefined ? scrubBodyJson(n.requestBody) : undefined;
+          const resBody = n.responseBody !== undefined ? scrubBodyJson(n.responseBody) : undefined;
+          totalScrubs += countScrubbed(n.requestHeaders ?? {}, reqHeaders ?? {});
+          totalScrubs += countScrubbed(n.responseHeaders ?? {}, resHeaders ?? {});
+          totalScrubs += countScrubbed(n.requestBody ?? {}, reqBody ?? {});
+          totalScrubs += countScrubbed(n.responseBody ?? {}, resBody ?? {});
+          const out2 = { method: n.method, url: n.url, status: n.status };
+          if (reqHeaders !== undefined)
+            out2.requestHeaders = reqHeaders;
+          if (resHeaders !== undefined)
+            out2.responseHeaders = resHeaders;
+          if (reqBody !== undefined)
+            out2.requestBody = reqBody;
+          if (resBody !== undefined)
+            out2.responseBody = resBody;
+          return out2;
+        });
+      }
+      newSc.failure = newF;
+    }
+    out.scenarios.push(newSc);
+  }
+  out.scrubbed_fields_count = totalScrubs;
+  return out;
+}
+
+// src/trace-normalizer/unzip.ts
+import { readFileSync } from "fs";
+import { unzipSync } from "fflate";
+function unzipTrace(tracePath) {
+  const buf = readFileSync(tracePath);
+  const entries = unzipSync(buf);
+  const files = {};
+  for (const [name, data] of Object.entries(entries)) {
+    if (name.endsWith("/"))
+      continue;
+    if (name.endsWith(".network") || name.endsWith(".trace") || name.endsWith(".txt") || name.endsWith(".json")) {
+      files[name] = new TextDecoder().decode(data);
+    }
+  }
+  return { files };
+}
+
+// src/trace-normalizer/normalize.ts
+async function normalizeRun(input) {
+  const reportPath = join2(input.runDir, "report.json");
+  const report = JSON.parse(readFileSync2(reportPath, "utf8"));
+  let normalized = parsePlaywrightReport(report, input.runId);
+  const tracePath = join2(input.runDir, "trace.zip");
+  if (existsSync(tracePath)) {
+    const { files } = unzipTrace(tracePath);
+    const networkFile = Object.entries(files).find(([k]) => k.endsWith(".network"))?.[1];
+    const traceFile = Object.entries(files).find(([k]) => k.endsWith(".trace"))?.[1];
+    const network = networkFile ? networkFile.trim().split(`
+`).filter(Boolean).map((l) => JSON.parse(l)).filter((e) => e.type === "request") : [];
+    const consoleEvents = traceFile ? traceFile.trim().split(`
+`).filter(Boolean).map((l) => JSON.parse(l)).filter((e) => e.type === "console") : [];
+    for (const sc of normalized.scenarios) {
+      if (sc.outcome !== "FAIL")
+        continue;
+      sc.failure = sc.failure ?? {};
+      sc.failure.networkAtFailure = network.map((n) => {
+        const entry = { 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;
+        if (n.requestBody !== undefined)
+          entry.requestBody = n.requestBody;
+        if (n.responseBody !== undefined)
+          entry.responseBody = n.responseBody;
+        return entry;
+      });
+      sc.failure.consoleAtFailure = consoleEvents.map((c) => c.text);
+    }
+  }
+  normalized = scrub(normalized);
+  writeFileSync(join2(input.runDir, "normalized.json"), JSON.stringify(normalized, null, 2));
+  return normalized;
+}
+
+// src/adapter.ts
+import { join as join3 } from "path";
+var WebAdapter = {
+  id: "web",
+  async generate(_input) {
+    return { artifacts: [], warnings: [] };
+  },
+  async execute(input) {
+    const runDir = join3(input.ticketDir, "runs", input.runId);
+    const specPath = join3(input.ticketDir, "spec.ts");
+    const configPath = join3(input.ticketDir, "playwright.config.ts");
+    const pwResult = await runPlaywright({ specPath, configPath, outputDir: runDir });
+    const normalized = await normalizeRun({ runId: input.runId, runDir });
+    return {
+      runId: input.runId,
+      outcome: normalized.outcome,
+      scenarios: normalized.scenarios.map((s) => {
+        const out = { name: s.name, outcome: s.outcome };
+        if (s.failure !== undefined)
+          out.failure = s.failure;
+        return out;
+      }),
+      artifactsDir: runDir,
+      rawReportPath: pwResult.rawReportPath,
+      normalizedReportPath: join3(runDir, "normalized.json")
+    };
+  },
+  async doctor() {
+    const checks = [];
+    try {
+      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`." });
+    }
+    return { ok: checks.every((c) => c.ok), checks };
+  }
+};
+// src/auth-setup/define.ts
+function defineAuthSetup(fn) {
+  return fn;
+}
+// src/auth-setup/runner.ts
+import { pathToFileURL } from "url";
+import { writeAuthState } from "@xera-ai/core";
+async function runAuthSetup(input) {
+  const mod = await import(pathToFileURL(input.setupScriptPath).href);
+  const fn = mod.default;
+  if (typeof fn !== "function") {
+    throw new Error(`Auth setup script at ${input.setupScriptPath} must default-export a function (see defineAuthSetup).`);
+  }
+  const context = await input.browser.newContext();
+  try {
+    const page = await context.newPage();
+    const result = await fn(page, input.role, input.creds) ?? {};
+    const storageState = await context.storageState();
+    const now = input.now ?? new Date;
+    const expiresAtMs = result.expiresAt ?? now.getTime() + 28800000;
+    writeAuthState(input.authDir, {
+      role: input.role,
+      strategy: "storageState",
+      created_at: now.toISOString(),
+      expires_at: new Date(expiresAtMs).toISOString(),
+      payload: storageState
+    });
+  } finally {
+    await context.close();
+  }
+}
+// src/auth-setup/playwright-state.ts
+import { writeFileSync as writeFileSync2, mkdirSync } from "fs";
+import { join as join4 } from "path";
+import { readAuthState } from "@xera-ai/core";
+function stagePlaywrightState(authDir, role) {
+  const entry = readAuthState(authDir, role);
+  if (!entry)
+    throw new Error(`No auth state for role "${role}" in ${authDir}`);
+  const cacheDir = join4(authDir, ".cache");
+  mkdirSync(cacheDir, { recursive: true });
+  const stagedPath = join4(cacheDir, `${role}.json`);
+  writeFileSync2(stagedPath, JSON.stringify(entry.payload));
+  return stagedPath;
+}
+// src/generator/gherkin-validate.ts
+import { AstBuilder, GherkinClassicTokenMatcher, Parser } from "@cucumber/gherkin";
+import { IdGenerator } from "@cucumber/messages";
+function validateGherkin(content) {
+  if (!content.trim()) {
+    return { ok: false, errors: [{ line: 0, message: "Empty feature file" }] };
+  }
+  try {
+    const parser = new Parser(new AstBuilder(IdGenerator.uuid()), new GherkinClassicTokenMatcher);
+    parser.parse(content);
+    return { ok: true, errors: [] };
+  } catch (e) {
+    const errors = [];
+    if (e?.errors && Array.isArray(e.errors)) {
+      for (const inner of e.errors) {
+        errors.push({ line: inner?.location?.line ?? 0, message: String(inner?.message ?? inner) });
+      }
+    } else {
+      errors.push({ line: 0, message: String(e?.message ?? e) });
+    }
+    return { ok: false, errors };
+  }
+}
+// src/generator/typecheck.ts
+import { spawnSync } from "child_process";
+async function typecheckTicket(ticketDir) {
+  const proc = spawnSync("npx", ["tsc", "--noEmit", "--project", ticketDir], { encoding: "utf8" });
+  if (proc.status === 0)
+    return { ok: true, errors: [] };
+  const out = (proc.stdout || "") + (proc.stderr || "");
+  const errors = out.split(`
+`).filter((line) => /error TS\d+/.test(line));
+  return { ok: false, errors };
+}
+// src/generator/lint.ts
+import { readFileSync as readFileSync3, existsSync as existsSync2, readdirSync } from "fs";
+import { join as join5 } 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,}/;
+var LOCATOR_CSS_RE = /\.locator\(\s*['"`]([^'"`]+)['"`]/;
+var XPATH_RE = /\.locator\(\s*['"`](xpath=|\/\/)/;
+var ALLOW_CSS_RE = /xera-allow-css:/;
+function lintSelectors(source) {
+  const warnings = [];
+  const lines = source.split(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    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." });
+      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.` });
+      } 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.` });
+      }
+    }
+  }
+  return { warnings };
+}
+
+// src/generator/lint.ts
+function listTsFiles(dir) {
+  if (!existsSync2(dir))
+    return [];
+  const out = [];
+  for (const name of readdirSync(dir, { withFileTypes: true })) {
+    const full = join5(dir, name.name);
+    if (name.isDirectory())
+      out.push(...listTsFiles(full));
+    else if (name.name.endsWith(".ts"))
+      out.push(full);
+  }
+  return out;
+}
+async function lintTicket(ticketDir) {
+  const files = listTsFiles(ticketDir);
+  const warnings = [];
+  for (const f of files) {
+    const src = readFileSync3(f, "utf8");
+    const r = lintSelectors(src);
+    for (const w of r.warnings)
+      warnings.push({ ...w, file: f });
+  }
+  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";
+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))
+    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 src = readFileSync4(path, "utf8");
+    for (const m of src.matchAll(CLASS_RE)) {
+      found.push({ className: m[1], absolutePath: path });
+    }
+  }
+  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";
+async function promotePom(input) {
+  const fromDir = join7(input.repoRoot, ".xera", input.ticket, "page-objects");
+  const toDir = join7(input.repoRoot, "shared", "page-objects");
+  const file = `${input.className}.ts`;
+  const fromPath = join7(fromDir, file);
+  const toPath = join7(toDir, file);
+  if (!existsSync4(fromPath)) {
+    throw new Error(`POM ${file} not found at ${fromPath}`);
+  }
+  if (existsSync4(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 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);
+  }
+}
+export {
+  validateGherkin,
+  unzipTrace,
+  typecheckTicket,
+  stagePlaywrightState,
+  scrubHeaders,
+  scrubFreeText,
+  scrubBodyJson,
+  scrub,
+  scanSharedPoms,
+  runPlaywright,
+  runAuthSetup,
+  promotePom,
+  parsePlaywrightReport,
+  normalizeRun,
+  lintTicket,
+  lintSelectors,
+  defineAuthSetup,
+  buildPlaywrightArgs,
+  WebAdapter,
+  SENSITIVE_HEADERS,
+  SENSITIVE_BODY_KEYS,
+  JWT_RE,
+  CREDIT_CARD_RE
+};

package/dist/trace-normalizer/normalize.d.ts

@@ -0,0 +1,6 @@
+import { type NormalizedRun } from './scrub';
+export interface NormalizeRunInput {
+    runId: string;
+    runDir: string;
+}
+export declare function normalizeRun(input: NormalizeRunInput): Promise<NormalizedRun>;

package/dist/trace-normalizer/parse.d.ts

@@ -0,0 +1,36 @@
+import type { NormalizedRun } 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[];
+}
+export declare function parsePlaywrightReport(report: PWReport, runId: string): NormalizedRun;
+export {};

package/dist/trace-normalizer/scrub-rules.d.ts

@@ -0,0 +1,7 @@
+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 function scrubHeaders(headers: Record<string, string>): Record<string, string>;
+export declare function scrubBodyJson(body: unknown): unknown;
+export declare function scrubFreeText(s: string): string;

package/dist/trace-normalizer/scrub.d.ts

@@ -0,0 +1,28 @@
+export interface NormalizedNetworkEntry {
+    method: string;
+    url: string;
+    status: number;
+    requestHeaders?: Record<string, string>;
+    requestBody?: unknown;
+    responseHeaders?: Record<string, string>;
+    responseBody?: unknown;
+}
+export interface NormalizedScenario {
+    name: string;
+    outcome: 'PASS' | 'FAIL' | 'SKIPPED';
+    failure?: {
+        step?: string;
+        errorMessage?: string;
+        domSnapshotAtFailure?: string;
+        networkAtFailure?: NormalizedNetworkEntry[];
+        consoleAtFailure?: string[];
+        screenshotPath?: string;
+    };
+}
+export interface NormalizedRun {
+    runId: string;
+    outcome: 'PASS' | 'FAIL';
+    scenarios: NormalizedScenario[];
+    scrubbed_fields_count: number;
+}
+export declare function scrub(run: NormalizedRun): NormalizedRun;

package/dist/trace-normalizer/unzip.d.ts

@@ -0,0 +1,5 @@
+export interface TraceEntries {
+    /** Filename → text contents */
+    files: Record<string, string>;
+}
+export declare function unzipTrace(tracePath: string): TraceEntries;

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@xera-ai/web",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun --external @playwright/test --external @xera-ai/core --external @cucumber/gherkin --external @cucumber/messages --external fflate",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@cucumber/gherkin": "30.0.4",
+    "@cucumber/messages": "27.0.2",
+    "@playwright/test": "1.48.0",
+    "@xera-ai/core": "workspace:*",
+    "fflate": "0.8.2"
+  }
+}