@qartisan/playwright-loupe 0.0.0-stage → 0.0.2

package/dist/core/runErrors.js

@@ -0,0 +1,49 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * Node's ESM resolution error, as Playwright reports it for a spec file that
+ * imports a missing module or package:
+ *   Cannot find module '/abs/tests/missing' imported from /abs/tests/a.spec.ts
+ *   Cannot find package 'nope' imported from /abs/tests/a.spec.ts
+ */
+const ESM_NOT_FOUND = /Cannot find (?:module|package) '([^']+)' imported from (\S+)/;
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Location of an ESM import failure. For ES module spec files, Playwright
+ * reports such load errors at `<anonymous>:1:1`; the importing file is only in
+ * the message. Returns that file with the line of the failing import (found by
+ * its specifier), or null when the message is not such an error or the import
+ * cannot be found in the file. CommonJS spec files already get a precise
+ * location and do not need this.
+ */
+export async function esmImportLocation(message) {
+    const match = ESM_NOT_FOUND.exec(message);
+    if (!match)
+        return null;
+    const [, missing = '', importer = ''] = match;
+    const file = importer.startsWith('file://') ? fileURLToPath(importer) : importer;
+    let source;
+    try {
+        source = await readFile(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    // The message gives a package name, or the resolved path of a relative import without its extension.
+    const name = path.isAbsolute(missing) ? path.basename(missing).replace(/\.[cm]?[jt]sx?$/, '') : missing;
+    // './missing', '../lib/missing.js', 'pkg', 'pkg/sub', '@scope/pkg': the quoted specifier ending with the name.
+    const specifier = new RegExp(`(['"\`])(?:[^'"\`]*/)?${escapeRegExp(name)}(?:\\.[cm]?[jt]sx?|/[^'"\`]*)?\\1`);
+    const lines = source.split(/\r?\n/);
+    const index = lines.findIndex((line) => specifier.test(line));
+    if (index === -1)
+        return null;
+    const line = lines[index];
+    return { file, line: index + 1, column: line.length - line.trimStart().length + 1 };
+}
+/** True when Playwright gave a usable source location (a real file path, not `<anonymous>`). */
+export function isUsableLocation(location) {
+    return location !== undefined && path.isAbsolute(location.file);
+}

package/dist/core/scope.d.ts

@@ -0,0 +1,57 @@
+import type { RunScope } from '../schema/v1.js';
+/**
+ * Best-effort detection of partial runs. What a reporter can see (checked
+ * against Playwright 1.52–1.64):
+ *
+ * - CLI `--grep`, file filters, `--last-failed`, `--only-changed` and
+ *   `--test-list` never reach the resolved config: the only trace is the
+ *   command line (`config.argv` from 1.61, `process.argv` before).
+ * - `--project` is visible as `config.filteredProjects` from 1.64; earlier, the
+ *   command line plus the projects present in the suite are used.
+ * - A `grep` / `grepInvert` in the config file is visible in the config.
+ * - `test.only` is only visible through Playwright's internal `_only` flag.
+ *
+ * Limits are documented in docs/schema/v1.md ("Run scope").
+ */
+/** Reasons, in the order they are reported. */
+export declare const SCOPE_REASONS: readonly ['env', 'file-filter', 'grep', 'project-filter', 'last-failed', 'only-changed', 'test-list', 'only', 'shard', 'list'];
+export type ScopeReason = (typeof SCOPE_REASONS)[number];
+export interface TestCommand {
+    /** Positional arguments: file / line filters. */
+    filters: string[];
+    /** Option names used (long form when given that way), e.g. '--grep', '-g'. */
+    options: Set<string>;
+}
+/** Parses `playwright test` arguments from a full argv; null when the command is not `test`. */
+export declare function parseTestCommand(argv: readonly string[]): TestCommand | null;
+export interface ProjectRef {
+    name: string;
+    dependencies: readonly string[];
+    teardown?: string | undefined;
+}
+export interface ScopeInput {
+    argv: readonly string[];
+    /** `grep` / `grepInvert` set in the config file (not their defaults). */
+    configGrep: boolean;
+    shard: boolean;
+    /** All projects of the config. */
+    projects: readonly ProjectRef[];
+    /** `config.filteredProjects` names when Playwright exposes them (1.64+); empty under merge-reports. */
+    filteredProjects: readonly string[] | undefined;
+    /** Names of the projects that have a suite in this run. */
+    runProjects: readonly string[];
+    /** A `test.only` / `describe.only` is in effect. */
+    only: boolean;
+}
+export declare function detectScopeReasons(input: ScopeInput): ScopeReason[];
+export declare const SCOPE_ENV = "LOUPE_RUN_SCOPE";
+/** Validates the LOUPE_RUN_SCOPE value; null when unset or empty. Throws on anything else than full / partial. */
+export declare function parseScopeOverride(value: string | undefined): RunScope | null;
+/**
+ * Final scope: the override wins. A forced `full` has no reasons; a forced
+ * `partial` reports 'env' followed by whatever was detected.
+ */
+export declare function resolveScope(detected: readonly ScopeReason[], override: RunScope | null): {
+    scope: RunScope;
+    scopeReasons: ScopeReason[];
+};

package/dist/core/scope.js

@@ -0,0 +1,164 @@
+/**
+ * Best-effort detection of partial runs. What a reporter can see (checked
+ * against Playwright 1.52–1.64):
+ *
+ * - CLI `--grep`, file filters, `--last-failed`, `--only-changed` and
+ *   `--test-list` never reach the resolved config: the only trace is the
+ *   command line (`config.argv` from 1.61, `process.argv` before).
+ * - `--project` is visible as `config.filteredProjects` from 1.64; earlier, the
+ *   command line plus the projects present in the suite are used.
+ * - A `grep` / `grepInvert` in the config file is visible in the config.
+ * - `test.only` is only visible through Playwright's internal `_only` flag.
+ *
+ * Limits are documented in docs/schema/v1.md ("Run scope").
+ */
+/** Reasons, in the order they are reported. */
+export const SCOPE_REASONS = [
+    'env',
+    'file-filter',
+    'grep',
+    'project-filter',
+    'last-failed',
+    'only-changed',
+    'test-list',
+    'only',
+    'shard',
+    'list',
+];
+/** `playwright test` options that take a value (the next token, or `--opt=value`). */
+const VALUE_OPTIONS = new Set([
+    '-c', '--config',
+    '-g', '--grep',
+    '--grep-invert',
+    '--project',
+    '-j', '--workers',
+    '--reporter',
+    '--retries',
+    '--timeout',
+    '--global-timeout',
+    '--max-failures',
+    '--output',
+    '--repeat-each',
+    '--shard',
+    '--trace',
+    '--tsconfig',
+    '--update-source-method',
+    '--browser',
+    '--test-list',
+    '--test-list-invert',
+    '--ui-host',
+    '--ui-port',
+]);
+/** Options with an optional value: like commander, they take the next token unless it starts with '-'. */
+const OPTIONAL_VALUE_OPTIONS = new Set(['--only-changed', '-u', '--update-snapshots']);
+/** Parses `playwright test` arguments from a full argv; null when the command is not `test`. */
+export function parseTestCommand(argv) {
+    const args = argv.slice(2);
+    if (args[0] !== 'test')
+        return null;
+    const command = { filters: [], options: new Set() };
+    for (let i = 1; i < args.length; i++) {
+        const arg = args[i] ?? '';
+        if (arg === '--') {
+            command.filters.push(...args.slice(i + 1));
+            break;
+        }
+        if (!arg.startsWith('-') || arg === '-') {
+            command.filters.push(arg);
+            continue;
+        }
+        const equals = arg.indexOf('=');
+        const name = arg.startsWith('--') && equals !== -1 ? arg.slice(0, equals) : arg;
+        // Short options with an attached value, e.g. `-gsmoke`.
+        const short = !arg.startsWith('--') && arg.length > 2 && VALUE_OPTIONS.has(arg.slice(0, 2)) ? arg.slice(0, 2) : null;
+        if (short) {
+            command.options.add(short);
+            continue;
+        }
+        command.options.add(name);
+        if (name !== arg)
+            continue;
+        if (VALUE_OPTIONS.has(name))
+            i++;
+        else if (OPTIONAL_VALUE_OPTIONS.has(name) && args[i + 1] !== undefined && !args[i + 1]?.startsWith('-'))
+            i++;
+    }
+    return command;
+}
+/** Projects that run when `selected` are requested: their dependencies and teardowns included. */
+function withDependencies(selected, projects) {
+    const byName = new Map(projects.map((project) => [project.name, project]));
+    const result = new Set();
+    const pending = [...selected];
+    while (pending.length > 0) {
+        const name = pending.pop();
+        if (result.has(name))
+            continue;
+        result.add(name);
+        const project = byName.get(name);
+        if (!project)
+            continue;
+        pending.push(...project.dependencies);
+        if (project.teardown)
+            pending.push(project.teardown);
+    }
+    return result;
+}
+function hasProjectFilter(input, command) {
+    const all = input.projects.map((project) => project.name);
+    // merge-reports exposes an empty list: a real run always selects at least one project.
+    if (input.filteredProjects && input.filteredProjects.length > 0) {
+        const running = withDependencies(input.filteredProjects, input.projects);
+        return all.some((name) => !running.has(name));
+    }
+    if (!command?.options.has('--project'))
+        return false;
+    const running = new Set(input.runProjects);
+    return all.some((name) => !running.has(name));
+}
+export function detectScopeReasons(input) {
+    const command = parseTestCommand(input.argv);
+    const reasons = new Set();
+    const has = (...names) => names.some((name) => command?.options.has(name));
+    if (command && command.filters.length > 0)
+        reasons.add('file-filter');
+    if (input.configGrep || has('-g', '--grep', '--grep-invert'))
+        reasons.add('grep');
+    if (hasProjectFilter(input, command))
+        reasons.add('project-filter');
+    if (has('--last-failed'))
+        reasons.add('last-failed');
+    if (has('--only-changed'))
+        reasons.add('only-changed');
+    if (has('--test-list', '--test-list-invert'))
+        reasons.add('test-list');
+    if (input.only)
+        reasons.add('only');
+    if (input.shard)
+        reasons.add('shard');
+    // `--list` runs nothing: the report lists tests without results.
+    if (has('--list'))
+        reasons.add('list');
+    return SCOPE_REASONS.filter((reason) => reasons.has(reason));
+}
+export const SCOPE_ENV = 'LOUPE_RUN_SCOPE';
+/** Validates the LOUPE_RUN_SCOPE value; null when unset or empty. Throws on anything else than full / partial. */
+export function parseScopeOverride(value) {
+    const trimmed = value?.trim() ?? '';
+    if (trimmed === '')
+        return null;
+    if (trimmed === 'full' || trimmed === 'partial')
+        return trimmed;
+    throw new Error(`Loupe: invalid ${SCOPE_ENV}=${JSON.stringify(value)}. Expected "full" or "partial".`);
+}
+/**
+ * Final scope: the override wins. A forced `full` has no reasons; a forced
+ * `partial` reports 'env' followed by whatever was detected.
+ */
+export function resolveScope(detected, override) {
+    if (override === 'full')
+        return { scope: 'full', scopeReasons: [] };
+    if (override === 'partial')
+        return { scope: 'partial', scopeReasons: ['env', ...detected] };
+    return { scope: detected.length > 0 ? 'partial' : 'full', scopeReasons: [...detected] };
+}

package/dist/core/signature.d.ts

@@ -0,0 +1,15 @@
+export declare function stripAnsi(text: string): string;
+/** Removes the `(<tags>) ` prefix `merge-reports` adds to run errors. ANSI codes must be stripped first. */
+export declare function stripMergeTagPrefix(text: string): string;
+export interface NormalizeOptions {
+    /** Run errors (`onError`) also lose the `(<tags>) ` prefix added by `merge-reports`. */
+    runError?: boolean;
+}
+/**
+ * Normalizes an error message so the same failure produces the same text
+ * across tests and runs: ANSI codes and the call log are removed, volatile
+ * values are replaced with placeholders and whitespace is collapsed.
+ */
+export declare function normalizeErrorMessage(message: string, options?: NormalizeOptions): string;
+/** First 12 hex chars of sha256 of the normalized message. Independent of the test. */
+export declare function errorSignature(message: string, options?: NormalizeOptions): string;

package/dist/core/signature.js

@@ -0,0 +1,71 @@
+import { createHash } from 'node:crypto';
+// Same pattern as the `ansi-regex` package (CSI and OSC sequences).
+const ANSI_PATTERN = /[\u001B\u009B][[\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\d/#&.:=?%@~_]+)*|[a-zA-Z\d]+(?:;[-a-zA-Z\d/#&.:=?%@~_]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-ntqry=><~]))/g;
+export function stripAnsi(text) {
+    return text.replace(ANSI_PATTERN, '');
+}
+/** Playwright appends the action log after a line starting with "Call log:". */
+const CALL_LOG = /^[ \t]*Call log:/m;
+/**
+ * `merge-reports` prefixes the run errors of a blob whose config has a `tag`
+ * with `(<tags>) `, tags joined by spaces. Config tags always start with `@`.
+ */
+const MERGE_TAG_PREFIX = /^\(@[^()\n]*\) /;
+/** Removes the `(<tags>) ` prefix `merge-reports` adds to run errors. ANSI codes must be stripped first. */
+export function stripMergeTagPrefix(text) {
+    return text.replace(MERGE_TAG_PREFIX, '');
+}
+/**
+ * Ordered replacements. The order matters: URLs before e-mails (a URL may
+ * contain `user@host`) and paths (a URL contains slashes), e-mails and paths
+ * before identifiers, identifiers before durations, hex and numbers (so each
+ * is replaced as a whole), hex before numbers. See "Error signature" in
+ * docs/schema/v1.md.
+ */
+const REPLACEMENTS = [
+    [/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, '<uuid>'],
+    [/\b[a-z][a-z0-9+.-]*:\/\/[^\s'"`<>()[\]{}]*[^\s'"`<>()[\]{}.,;:!?]/gi, '<url>'],
+    // Local part, then a domain with at least one dot and an alphabetic TLD.
+    [/(?<![\w.%+-])[\w.%+-]+@[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)*\.[a-z]{2,}(?![\w-])/gi, '<email>'],
+    // ISO 8601 date with optional time and zone.
+    [/\b\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:[.,]\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?)?(?![\w:])/g, '<date>'],
+    // Time of day.
+    [/\b\d{1,2}:\d{2}:\d{2}(?:[.,]\d+)?\b/g, '<date>'],
+    // Unix timestamps in seconds or milliseconds (2001–2033).
+    [/\b1\d{9}(?:\d{3})?\b/g, '<date>'],
+    // Absolute POSIX paths with at least two segments, and Windows drive paths.
+    [/(?<![\w.~:/\\-])\/(?:[\w.@+~-]+\/)+[\w.@+~-]+\/?/g, '<path>'],
+    [/\b[A-Za-z]:[\\/](?:[^\\/\s'"`:*?<>|]+[\\/])*[^\\/\s'"`:*?<>|]+/g, '<path>'],
+    // nanoid-like: 20+ chars of [A-Za-z0-9_-] with a lowercase letter, an
+    // uppercase letter and a digit. Mixed case keeps kebab-case and snake_case
+    // names out; a digit keeps camelCase words out.
+    [/(?<![\w-])(?=[\w-]*[a-z])(?=[\w-]*[A-Z])(?=[\w-]*\d)[\w-]{20,}(?![\w-])/g, '<id>'],
+    // cuid-like: 20+ lowercase letters and digits, with a digit and a letter
+    // beyond a-f (pure hex strings stay <hex>).
+    [/(?<![0-9A-Za-z])(?=[a-z0-9]*\d)(?=[a-z0-9]*[g-z])[a-z0-9]{20,}(?![0-9A-Za-z])/g, '<id>'],
+    [/\b\d+(?:\.\d+)?\s?(?:ms|milliseconds?|s|secs?|seconds?|m|mins?|minutes?|h|hours?)\b/gi, '<duration>'],
+    // 8+ hex chars with at least one letter (pure digit runs fall through to <n>).
+    [/(?<![0-9A-Za-z])(?=[0-9a-f]*[a-f])[0-9a-f]{8,}(?![0-9A-Za-z])/gi, '<hex>'],
+    [/\d+(?:\.\d+)?/g, '<n>'],
+];
+/**
+ * Normalizes an error message so the same failure produces the same text
+ * across tests and runs: ANSI codes and the call log are removed, volatile
+ * values are replaced with placeholders and whitespace is collapsed.
+ */
+export function normalizeErrorMessage(message, options = {}) {
+    let text = stripAnsi(message);
+    if (options.runError)
+        text = stripMergeTagPrefix(text);
+    const callLog = CALL_LOG.exec(text);
+    if (callLog)
+        text = text.slice(0, callLog.index);
+    for (const [pattern, placeholder] of REPLACEMENTS) {
+        text = text.replace(pattern, placeholder);
+    }
+    return text.replace(/\s+/g, ' ').trim();
+}
+/** First 12 hex chars of sha256 of the normalized message. Independent of the test. */
+export function errorSignature(message, options = {}) {
+    return createHash('sha256').update(normalizeErrorMessage(message, options)).digest('hex').slice(0, 12);
+}

package/dist/core/version.d.ts

@@ -0,0 +1,2 @@
+/** Version of the installed Loupe package, written to `generator.version`. */
+export declare function generatorVersion(): Promise<string>;

package/dist/core/version.js

@@ -0,0 +1,8 @@
+import { readFile } from 'node:fs/promises';
+// Two levels up from both `src/core` and `dist/core`: the package root.
+const PACKAGE_JSON = new URL('../../package.json', import.meta.url);
+/** Version of the installed Loupe package, written to `generator.version`. */
+export async function generatorVersion() {
+    const { version } = JSON.parse(await readFile(PACKAGE_JSON, 'utf8'));
+    return version;
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { LoupeReporter } from './core/reporter.js';
+export default LoupeReporter;
+export { LoupeReporter };
+export { defineConfig } from './config/index.js';
+export type { AnnotationDimensionConfig, CategoriesConfig, CategoryMode, CategoryRuleConfig, CategoryTarget, DimensionConfig, DimensionsConfig, LoupeConfig, LoupeReporterOptions, ScreenshotView, TagDimensionConfig, Theme, } from './config/types.js';
+export type { RendererSettings } from './core/inject.js';
+export type * from './schema/v1.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+import { LoupeReporter } from './core/reporter.js';
+export default LoupeReporter;
+export { LoupeReporter };
+export { defineConfig } from './config/index.js';

package/dist/renderer/index.html

@@ -0,0 +1,16 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Loupe report</title>
+    <script type="module">var e={title:`Loupe report`,theme:`system`,screenshots:{defaultView:`side-by-side`}},t=[`passed`,`failed`,`flaky`,`skipped`];function n(e){return JSON.parse(document.getElementById(e)?.textContent??``)}function r(){try{return{...e,...n(`loupe-settings`)}}catch{return e}}function i(e,t={},n=[]){let r=document.createElement(e);return t.className&&(r.className=t.className),t.text!==void 0&&(r.textContent=t.text),r.append(...n),r}function a(e){return e<1e3?`${e} ms`:`${(e/1e3).toFixed(1)} s`}function o(e,n){let{run:r}=e,o=t.map(e=>i(`li`,{className:`count status-${e}`},[i(`span`,{className:`count-value`,text:String(r.stats[e])}),i(`span`,{className:`count-label`,text:e})])),s=[`${r.stats.total} tests`,a(r.durationMs),`${r.scope} run`,`Playwright ${r.playwrightVersion}`,...r.environment.name?[r.environment.name]:[],...r.git.commit?[r.git.commit.slice(0,8)]:[]];return i(`header`,{className:`summary`},[i(`h1`,{text:n}),i(`p`,{className:`meta`},[i(`span`,{className:`badge status-${r.status}`,text:r.status}),document.createTextNode(` ${s.join(` · `)}`)]),i(`ul`,{className:`counts`},o)])}function s(e){let t={title:``,suites:new Map,tests:[]};for(let n of e){let e=t;for(let t of[n.file,...n.suitePath]){let n=e.suites.get(t);n||(n={title:t,suites:new Map,tests:[]},e.suites.set(t,n)),e=n}e.tests.push(n)}return t}function c(e){return i(`li`,{className:`test`},[i(`span`,{className:`badge status-${e.outcome}`,text:e.outcome}),i(`span`,{className:`title`,text:e.title}),i(`span`,{className:`attempts`,text:e.attempts.length>1?`${e.attempts.length} attempts`:``})])}function l(e,t){return i(`li`,{className:`suite depth-${Math.min(t,3)}`},[i(`span`,{className:t===0?`file`:`suite-title`,text:e.title}),i(`ul`,{className:`tests`},[...[...e.suites.values()].map(e=>l(e,t+1)),...e.tests.map(c)])])}function u(e,t){let n=s(t);return i(`section`,{className:`project`},[i(`h2`,{text:`${e||`(no project)`} (${t.length})`}),i(`ul`,{className:`suites`},[...n.suites.values()].map(e=>l(e,0)))])}function d(e){let t=r(),a;try{a=n(`loupe-data`)}catch{e.append(i(`p`,{className:`error`,text:`Loupe: could not read report data.`}));return}if(a.schemaVersion!==1){e.append(i(`p`,{className:`error`,text:`Loupe: unsupported schema version ${String(a.schemaVersion)}.`}));return}document.title=t.title;let s=new Map(a.projects.map(e=>[e.name,[]]));for(let e of a.tests)s.set(e.project,[...s.get(e.project)??[],e]);e.append(o(a,t.title),...[...s].map(([e,t])=>u(e,t)))}d(document.getElementById(`app`)??document.body);</script>
+    <style>:root{--bg:#fff;--fg:#1f2328;--muted:#656d76;--border:#d0d7de;--surface:#f6f8fa;--passed:#1a7f37;--failed:#cf222e;--flaky:#9a6700;--skipped:#6e7781;--lightningcss-light:initial;--lightningcss-dark: ;color-scheme:light dark}@media (prefers-color-scheme:dark){:root{--lightningcss-light: ;--lightningcss-dark:initial;--bg:#0d1117;--fg:#e6edf3;--muted:#8d96a0;--border:#30363d;--surface:#161b22;--passed:#3fb950;--failed:#f85149;--flaky:#d29922;--skipped:#8d96a0}}*{box-sizing:border-box}body{background:var(--bg);color:var(--fg);margin:0;font:14px/1.5 system-ui,-apple-system,Segoe UI,sans-serif}main{max-width:960px;margin:0 auto;padding:24px 16px}h1{margin:0 0 4px;font-size:22px}h2{margin:0 0 8px;font-size:16px}.meta{color:var(--muted);margin:0 0 16px}.counts{flex-wrap:wrap;gap:8px;margin:0 0 24px;padding:0;list-style:none;display:flex}.count{border:1px solid var(--border);background:var(--surface);border-radius:6px;flex-direction:column;min-width:96px;padding:8px 12px;display:flex}.count-value{font-size:20px;font-weight:600}.count-label{color:var(--muted);text-transform:capitalize}.project{margin-bottom:24px}.suites{border:1px solid var(--border);border-radius:6px;margin:0;padding:0;list-style:none}.suites>.suite{border-top:1px solid var(--border);padding:6px 12px}.suites>.suite:first-child{border-top:0}.tests{margin:0;padding:0 0 0 16px;list-style:none}.suite .file{color:var(--muted);overflow-wrap:anywhere;font-size:12px}.suite .suite-title{font-weight:600}.test{grid-template-columns:72px 1fr auto;align-items:baseline;gap:4px 12px;padding:2px 0;display:grid}.test .attempts{color:var(--muted);font-size:12px}.badge{text-transform:uppercase;font-size:12px;font-weight:600}.status-passed{color:var(--passed)}.status-failed,.status-timedout,.status-interrupted{color:var(--failed)}.status-flaky{color:var(--flaky)}.status-skipped{color:var(--skipped)}.error{color:var(--failed)}
+/*$vite$:1*/</style>
+  </head>
+  <body>
+    <main id="app"></main>
+    <script id="loupe-settings" type="application/json">__LOUPE_SETTINGS__</script>
+    <script id="loupe-data" type="application/json">__LOUPE_DATA__</script>
+  </body>
+</html>

package/dist/schema/v1.d.ts

@@ -0,0 +1,226 @@
+/**
+ * Loupe JSON report — schema v1. This file is the source of truth for the
+ * public contract; `docs/schema/report-v1.schema.json` mirrors it and
+ * `docs/schema/v1.md` documents every field and rule.
+ *
+ * Any change to the shape below requires a new `schemaVersion` (see the
+ * versioning policy in `docs/schema/v1.md`). Before the first npm
+ * publication, v1 was amended in place (`Run.errors`,
+ * `DimensionDefinition.values`); after it, shape changes need a new version.
+ *
+ * Enumerations are declared as runtime constants so the JSON Schema test can
+ * check that both sides list the same values. Kept free of Node imports so the
+ * renderer can import it too.
+ */
+export declare const SCHEMA_VERSION = 1;
+export declare const RUN_STATUSES: readonly ['passed', 'failed', 'timedout', 'interrupted'];
+export type RunStatus = (typeof RUN_STATUSES)[number];
+export declare const RUN_SCOPES: readonly ['full', 'partial'];
+export type RunScope = (typeof RUN_SCOPES)[number];
+export declare const OUTCOMES: readonly ['passed', 'failed', 'flaky', 'skipped'];
+export type Outcome = (typeof OUTCOMES)[number];
+export declare const ATTEMPT_STATUSES: readonly ['passed', 'failed', 'timedOut', 'skipped', 'interrupted'];
+export type AttemptStatus = (typeof ATTEMPT_STATUSES)[number];
+export declare const ATTACHMENT_KINDS: readonly ['screenshot', 'video', 'trace', 'text', 'other'];
+export type AttachmentKind = (typeof ATTACHMENT_KINDS)[number];
+export declare const COMPARISON_ROLES: readonly ['expected', 'actual', 'diff'];
+export type ComparisonRole = (typeof COMPARISON_ROLES)[number];
+export declare const DIMENSION_SOURCES: readonly ['tag', 'annotation'];
+export type DimensionSource = (typeof DIMENSION_SOURCES)[number];
+export interface LoupeReport {
+    schemaVersion: 1;
+    generator: {
+        name: 'playwright-loupe';
+        version: string;
+    };
+    run: Run;
+    projects: Project[];
+    tests: TestCase[];
+    /** Category definitions actually used in this report. */
+    categories: CategoryDefinition[];
+    /** Dimension definitions actually used in this report. */
+    dimensions: DimensionDefinition[];
+}
+export interface Run {
+    /** Random UUID generated at onBegin. */
+    id: string;
+    /** ISO 8601. */
+    startedAt: string;
+    durationMs: number;
+    status: RunStatus;
+    scope: RunScope;
+    /** Why the run was considered partial, e.g. ['grep', 'file-filter']. Empty when full. */
+    scopeReasons: string[];
+    playwrightVersion: string;
+    workers: number;
+    shard: {
+        current: number;
+        total: number;
+    } | null;
+    environment: {
+        /** From LOUPE_ENV, null otherwise. */
+        name: string | null;
+        ci: boolean;
+        /** 'github-actions', 'gitlab', ... when detectable. */
+        ciProvider: string | null;
+        /** Platform and architecture, e.g. 'linux-x64'. */
+        os: string;
+        nodeVersion: string;
+    };
+    git: {
+        commit: string | null;
+        branch: string | null;
+        remote: string | null;
+    };
+    /** Phase 2 slot: always null in v1. */
+    excluded: {
+        reason: string;
+    } | null;
+    /** Phase 2 slot: always [] in v1. */
+    notes: Note[];
+    stats: Stats;
+    /** Errors not attached to a test: load errors, global setup/teardown failures, worker teardown errors. */
+    errors: RunError[];
+}
+export interface RunError {
+    /** ANSI codes stripped. */
+    message: string;
+    stack: string | null;
+    location: SourceLocation | null;
+    snippet: string | null;
+    /** Same normalization as test errors. */
+    signature: string;
+    /** Same rules as test errors. */
+    category: string | null;
+    /** Project concerned when Playwright makes it knowable, null otherwise. */
+    project: string | null;
+}
+export interface Note {
+    createdAt: string;
+    author: string | null;
+    text: string;
+    /** Test id when the note targets a test result; null for a run-level note. */
+    testId: string | null;
+}
+export interface Stats {
+    total: number;
+    passed: number;
+    failed: number;
+    flaky: number;
+    skipped: number;
+}
+export interface Project {
+    name: string;
+    /** Relative to the Playwright root dir, POSIX separators ('.' when equal). */
+    testDir: string;
+    retries: number;
+    timeoutMs: number;
+    stats: Stats;
+}
+export interface SourceLocation {
+    /** Relative to the Playwright root dir, POSIX separators. */
+    file: string;
+    line: number;
+    column: number;
+}
+export interface TestCase {
+    /** Stable id: first 16 hex chars of sha256(project + '\0' + file + '\0' + [...suitePath, title].join('\0')). */
+    id: string;
+    /**
+     * 0 unless the run used `--repeat-each`, which yields several tests with the
+     * same `id`. The pair (id, repeatEachIndex) is unique within a report.
+     */
+    repeatEachIndex: number;
+    project: string;
+    /** Relative to the Playwright root dir, POSIX separators. */
+    file: string;
+    line: number;
+    column: number;
+    /** describe() titles only — no project, no file, no test title. */
+    suitePath: string[];
+    title: string;
+    /** As declared, with the leading '@'. */
+    tags: string[];
+    annotations: Annotation[];
+    /** Final outcome; a test.fail() that fails as expected is 'passed'. */
+    outcome: Outcome;
+    expectedStatus: AttemptStatus;
+    /** Sum of all attempts. */
+    durationMs: number;
+    /** Computed: dimension name → values. */
+    dimensions: Record<string, string[]>;
+    /** From the last failing attempt; null when the test never failed. */
+    category: string | null;
+    errorSignature: string | null;
+    attempts: Attempt[];
+}
+export interface Annotation {
+    type: string;
+    description: string | null;
+}
+export interface Attempt {
+    /** 0 for the first run, 1 for the first retry, ... */
+    index: number;
+    status: AttemptStatus;
+    startedAt: string;
+    durationMs: number;
+    workerIndex: number;
+    errors: LoupeError[];
+    steps: Step[];
+    attachments: Attachment[];
+    annotations: Annotation[];
+    /** Truncated to a fixed size, with a flag when truncated. */
+    stdout: Output;
+    stderr: Output;
+}
+export interface Output {
+    text: string;
+    truncated: boolean;
+}
+export interface LoupeError {
+    /** ANSI codes stripped. */
+    message: string;
+    stack: string | null;
+    location: SourceLocation | null;
+    snippet: string | null;
+    signature: string;
+    category: string | null;
+}
+export interface Step {
+    title: string;
+    /** Playwright step subtitle (e.g. the target locator of a `pw:api` step); null when absent. */
+    subtitle: string | null;
+    /** Playwright step category: 'test.step', 'expect', 'pw:api', 'hook', 'fixture', ... */
+    category: string;
+    durationMs: number;
+    error: LoupeError | null;
+    location: SourceLocation | null;
+    steps: Step[];
+}
+export interface Attachment {
+    name: string;
+    contentType: string;
+    kind: AttachmentKind;
+    /** Relative to the report folder; null when the body is inlined or the file is missing. */
+    path: string | null;
+    /** Inline only for small text bodies. */
+    body: string | null;
+    /** Set for toHaveScreenshot / toMatchSnapshot images. */
+    comparison: {
+        group: string;
+        role: ComparisonRole;
+    } | null;
+}
+export interface CategoryDefinition {
+    name: string;
+    color: string;
+    builtIn: boolean;
+}
+export interface DimensionDefinition {
+    name: string;
+    source: DimensionSource;
+    /** Tag prefix (without '@' and ':') or annotation type. */
+    key: string;
+    /** Expected values declared in the config; null when not declared. */
+    values: string[] | null;
+}

package/dist/schema/v1.js

@@ -0,0 +1,22 @@
+/**
+ * Loupe JSON report — schema v1. This file is the source of truth for the
+ * public contract; `docs/schema/report-v1.schema.json` mirrors it and
+ * `docs/schema/v1.md` documents every field and rule.
+ *
+ * Any change to the shape below requires a new `schemaVersion` (see the
+ * versioning policy in `docs/schema/v1.md`). Before the first npm
+ * publication, v1 was amended in place (`Run.errors`,
+ * `DimensionDefinition.values`); after it, shape changes need a new version.
+ *
+ * Enumerations are declared as runtime constants so the JSON Schema test can
+ * check that both sides list the same values. Kept free of Node imports so the
+ * renderer can import it too.
+ */
+export const SCHEMA_VERSION = 1;
+export const RUN_STATUSES = ['passed', 'failed', 'timedout', 'interrupted'];
+export const RUN_SCOPES = ['full', 'partial'];
+export const OUTCOMES = ['passed', 'failed', 'flaky', 'skipped'];
+export const ATTEMPT_STATUSES = ['passed', 'failed', 'timedOut', 'skipped', 'interrupted'];
+export const ATTACHMENT_KINDS = ['screenshot', 'video', 'trace', 'text', 'other'];
+export const COMPARISON_ROLES = ['expected', 'actual', 'diff'];
+export const DIMENSION_SOURCES = ['tag', 'annotation'];