@qualflare/playwright 0.2.0 → 0.4.0

package/dist/{resolve-config-CQe-oDpg.d.ts → resolve-config-T2ChZzAm.d.ts}

@@ -104,6 +104,10 @@ interface Attachment {
      * Relative to the report file's own directory. Never sent to `/collect`
      * directly; mutually exclusive with `content`/`storageKey`. */
     localVideoPath?: string;
+    /** Filename of a Playwright trace zip copied into `outputDir`, relative to
+     * it. Read by `@qualflare/cli` v0.1.20+, which uploads it only when
+     * `--upload-artifacts=trace` asks; an older CLI ignores the field. */
+    localTracePath?: string;
     /** Byte size of the object at `storageKey`. Ignored when `storageKey` is
      * unset. */
     fileSize?: number;
@@ -111,6 +115,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
@@ -126,6 +176,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. */
@@ -252,6 +306,10 @@ interface QualflarePlaywrightOptions {
     /** Per-video byte cap, checked before the file is written. Default 50MB,
      * matching the server's own hard cap. */
     maxVideoBytes?: number;
+    /** Cap on a single Playwright trace zip copied into `outputDir`. Traces are
+     * larger than videos in some suites, but the server rejects anything past its
+     * own 50MB cap, so the default matches it. */
+    maxTraceBytes?: number;
     debug?: boolean;
     /** `false` fully disables accumulation/upload (a complete no-op) but the
      * reporter still no-ops cleanly rather than throwing. */
@@ -300,6 +358,7 @@ interface ResolvedReporterConfig {
     maxAttachmentBytes: number;
     maxTotalAttachmentBytes: number;
     maxVideoBytes: number;
+    maxTraceBytes: number;
     debug: boolean;
     enabled: boolean;
     outputDir: string;

package/package.json

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