@qualflare/playwright 0.1.0 → 0.3.0

package/dist/{resolve-config-CSjXFl7v.d.ts → resolve-config-N04M1Avn.d.ts}

@@ -34,6 +34,14 @@ interface Metadata {
     version: string;
     timestamp: string;
     cliName: string;
+    /** Identifier every shard of ONE run shares. `qualflare-cli collect` groups
+     * the report files in a directory by this and refuses to upload when more
+     * than one distinct run is present, so a file left over from an earlier run
+     * cannot be merged silently into this launch.
+     *
+     * Optional because reports written by earlier releases have none; the CLI
+     * treats those as "unknown run" and never blocks on them. */
+    runId?: string;
 }
 interface Label {
     /** Required, max 128 chars. Allure-style arbitrary label name — epic/feature/story/owner/severity
@@ -103,6 +111,52 @@ interface Attachment {
      * Omit for a case-level (not step-level) attachment. */
     stepIndex?: number;
 }
+/**
+ * One execution of a test, when the framework retried it.
+ *
+ * Sent as `Case.attempts`, persisted per-attempt server-side (see
+ * `case_run_attempts`). This is what lets a report answer "what failed on the
+ * first try?" rather than only "it was retried twice" — `retryCount`/`isFlaky`
+ * are aggregates and cannot.
+ *
+ * Three rules the server relies on:
+ *
+ * 1. **Send every attempt, including the final one**, numbered 1..N. The
+ *    server treats the highest-numbered attempt as the final execution and
+ *    overwrites its `status`/`duration` from the Case itself, so the two can
+ *    never disagree — but it keeps this attempt's own `message`/`trace`, which
+ *    is precisely why the final attempt must be sent rather than inferred.
+ * 2. **Fewer than two attempts persists nothing.** A test that ran once has no
+ *    history worth storing, so omit `attempts` entirely rather than sending a
+ *    single-element array; it is bytes against the 10MB body limit for a row
+ *    the server will discard.
+ * 3. **`attempt` must be >= 1.** Zero-based numbering is silently dropped.
+ */
+interface Attempt {
+    /** 1-based. Must be >= 1; the server drops anything lower. */
+    attempt: number;
+    status: CaseStatus;
+    /** NANOSECONDS — see `NanosecondDuration`. */
+    duration?: NanosecondDuration;
+    /** ISO-8601. When this attempt started. */
+    startedAt?: string;
+    /** The framework's own id for this attempt, passed through untouched.
+     * Max 255 chars server-side. */
+    attemptId?: string;
+    /** Truncated server-side at 8192 runes, never validation-rejected. */
+    message?: string;
+    /** Stack trace. Truncated server-side at 32768 runes. */
+    trace?: string;
+    /** Source snippet. Truncated server-side at 4096 runes. */
+    snippet?: string;
+    /** 1-based source line the failure points at. */
+    line?: number;
+    /** Captured stdout, one entry per line. Server keeps the first 200 lines,
+     * then truncates to 16384 runes. */
+    stdout?: string[];
+    /** Captured stderr, same bounds as `stdout`. */
+    stderr?: string[];
+}
 interface Case {
     /** Required. A stable per-test identifier used for flaky-history matching
      * across separate runs — must stay the same for what a human would call
@@ -118,6 +172,10 @@ interface Case {
     /** NANOSECONDS — see `NanosecondDuration`. */
     duration: NanosecondDuration;
     retryCount?: number;
+    /** Per-attempt execution history, present only when the framework retried
+     * this test (>= 2 entries). Omitted otherwise — a single attempt persists
+     * nothing server-side. See `Attempt`. */
+    attempts?: Attempt[];
     isFlaky?: boolean;
     /** Truncated server-side at 65536 runes, never validation-rejected — send
      * the full error/stack text, don't pre-truncate. */
@@ -218,6 +276,14 @@ interface QualflarePlaywrightOptions {
     ciBuildNumber?: string;
     ciRunUrl?: string;
     ciPrNumber?: number;
+    /** Identifier shared by every shard of one run, written into the report as
+     * `metadata.runId`. `qualflare-cli collect` groups files by it and refuses
+     * to merge a stale report from an earlier run into this launch.
+     *
+     * Auto-detected from CI. Outside CI it falls back to a per-process UUID,
+     * which is correct there: every local run is a distinct run, so a leftover
+     * file is still caught. */
+    runId?: string;
     attachScreenshots?: boolean;
     /** Include Playwright's runner-internal steps — `pw:api` (every
      * `page.click()`, `locator.fill()`, ...) and `fixture` (the implicit
@@ -278,6 +344,7 @@ interface ResolvedReporterConfig {
     ciBuildNumber?: string;
     ciRunUrl?: string;
     ciPrNumber?: number;
+    runId: string;
     attachScreenshots: boolean;
     includeApiSteps: boolean;
     maxAttachmentBytes: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qualflare/playwright",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Native Playwright reporter for the Qualflare test-management platform.",
   "keywords": [
     "qualflare",