@piwitests/reporter 0.11.0 → 0.13.0

package/dist/internal/streaming/stream-manager.js

@@ -1,395 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StreamManager = void 0;
-const fs = __importStar(require("node:fs"));
-const errors_js_1 = require("../support/errors.js");
-const http_client_js_1 = require("../transport/http-client.js");
-const logger_js_1 = require("../support/logger.js");
-const limiter_js_1 = require("../support/limiter.js");
-const setup_file_js_1 = require("../support/setup-file.js");
-/**
- * Manages the streaming protocol: queues events (begin / complete), flushes
- * them in batches, schedules retries on failure, and handles per-test-case
- * live file uploads.
- */
-class StreamManager {
-    /** Whether the streaming session is active */
-    get enabled() {
-        return this._enabled;
-    }
-    /** Server-assigned run ID (`null` until the stream opens) */
-    get runId() {
-        return this._runId;
-    }
-    /** Stream authentication token (`null` until the stream opens) */
-    get token() {
-        return this._token;
-    }
-    /** Resolved auth string (API key or session cookie) used in stream requests */
-    get auth() {
-        return this._auth;
-    }
-    /** Promise that resolves when the stream has been fully initialised */
-    get startPromise() {
-        return this._startPromise;
-    }
-    /**
-     * @param httpClient  HTTP client for server communication.
-     * @param streamBuffer On-disk buffer for crash-safe event persistence.
-     * @param recovery    Crash-recovery handler for uploading stale payloads on startup.
-     * @param uploader    Uploader for per-test-case file uploads.
-     * @param fileHandler File-discovery helper for finding traces and attachments.
-     * @param options     Piwi Dashboard reporter options.
-     * @param logger      Prefixed logger.
-     */
-    constructor(httpClient, streamBuffer, recovery, uploader, fileHandler, options, logger = new logger_js_1.Logger()) {
-        this.httpClient = httpClient;
-        this.streamBuffer = streamBuffer;
-        this.recovery = recovery;
-        this.uploader = uploader;
-        this.fileHandler = fileHandler;
-        this.options = options;
-        this.logger = logger;
-        this.pendingEvents = [];
-        this.pendingBeginEvents = [];
-        this.flushTimer = null;
-        this.flushPromises = [];
-        this.liveUploadPromises = [];
-        this.limitLiveUpload = (0, limiter_js_1.createLimiter)(2);
-        this.retryCount = 0;
-        this.retryTimer = null;
-        this.maxRetryDelay = 30000;
-        /**
-         * Idle heartbeat: while the run is open but no events are flowing (e.g. a single
-         * long test, or `beforeAll` setup), a periodic ping keeps the server's activity
-         * timestamp fresh so the stale-run reaper can tell a live run from a crashed one.
-         * The interval must stay well below the server's stale timeout.
-         */
-        this.heartbeatTimer = null;
-        this.heartbeatStopped = false;
-        this.lastActivityAt = 0;
-        this.heartbeatInterval = 15000;
-        /** Tracks cases whose files have already been uploaded live, so `uploadRemaining` can skip them. */
-        this.uploadedCaseFiles = new WeakSet();
-        this._enabled = false;
-        this._runId = null;
-        this._token = null;
-        this._auth = null;
-        this._startPromise = null;
-    }
-    /** Begin the streaming session after `onBegin` fires. Non-blocking — the actual handshake runs asynchronously. */
-    start(startTime, metadata, instanceId, playwrightVersion, reporterVersion, shardInfo, isFullRun, filterDetails) {
-        this._startPromise = this._doStart(startTime, metadata, instanceId, playwrightVersion, reporterVersion, shardInfo, isFullRun, filterDetails);
-    }
-    async _doStart(startTime, metadata, instanceId, playwrightVersion, reporterVersion, shardInfo, isFullRun, filterDetails) {
-        const setupInfo = (0, setup_file_js_1.readSetupInfo)(this.options.projectName);
-        try {
-            this._auth = await this.httpClient.resolveAuth(this.options);
-            await this.recovery.tryUpload(this.httpClient, this._auth);
-            let response;
-            const shardIndex = shardInfo?.current;
-            const shardTotal = shardInfo?.total;
-            if (setupInfo) {
-                try {
-                    response = await this.httpClient.postJSON(`/api/test-runs/${setupInfo.runId}/begin`, {
-                        setupToken: setupInfo.setupToken,
-                        totalTests: 0,
-                        metadata,
-                        playwrightVersion,
-                        reporterVersion,
-                        shardIndex,
-                        shardTotal,
-                        isFullRun,
-                        filterDetails,
-                    }, this._auth);
-                }
-                catch (error) {
-                    // Stale setupInfo — the run was cancelled (e.g. by crash recovery submit).
-                    // Fall back to creating a fresh run instead of silently disabling streaming.
-                    if (!(error instanceof http_client_js_1.HttpError && error.status === 409))
-                        throw error;
-                    this.logger.debug(`Setup info expired, creating fresh run...`);
-                    response = await this.httpClient.postJSON('/api/test-runs/start', {
-                        projectName: this.options.projectName,
-                        projectDescription: this.options.projectDescription,
-                        startTime,
-                        environment: this.options.environment || null,
-                        label: this.options.label || null,
-                        metadata,
-                        instanceId,
-                        playwrightVersion,
-                        reporterVersion,
-                        shardIndex,
-                        shardTotal,
-                        isFullRun,
-                        filterDetails,
-                    }, this._auth);
-                }
-            }
-            else {
-                response = await this.httpClient.postJSON('/api/test-runs/start', {
-                    projectName: this.options.projectName,
-                    projectDescription: this.options.projectDescription,
-                    startTime,
-                    environment: this.options.environment || null,
-                    label: this.options.label || null,
-                    metadata,
-                    instanceId,
-                    playwrightVersion,
-                    reporterVersion,
-                    shardIndex,
-                    shardTotal,
-                    isFullRun,
-                    filterDetails,
-                }, this._auth);
-            }
-            if (response?.runId && response?.streamToken) {
-                this._runId = response.runId;
-                this._token = response.streamToken;
-                this._enabled = true;
-                this.logger.info(`Streaming enabled. Run ID: ${response.runId}`);
-                this.lastActivityAt = Date.now();
-                this.scheduleHeartbeat();
-                if (this.pendingBeginEvents.length > 0) {
-                    this.pendingEvents = [...this.pendingBeginEvents, ...this.pendingEvents];
-                    this.pendingBeginEvents = [];
-                    this.flush();
-                }
-            }
-        }
-        catch (error) {
-            this.logger.debug(`Streaming not available: ${(0, errors_js_1.errorMessage)(error)}. Will use batch mode.`);
-            this._enabled = false;
-        }
-    }
-    // Queues a begin event; held in a pre-start buffer until the stream is open,
-    // then prepended to the main queue so it arrives before the matching complete event.
-    /** Queue a test-case `begin` event. Held in a pre-start buffer if the stream is not yet open, then prepended so it arrives before the matching `complete` event. */
-    queueBeginEvent(event) {
-        if (this._enabled && this._runId) {
-            this.queueEvent(event);
-        }
-        else {
-            this.pendingBeginEvents.push(event);
-        }
-    }
-    /** Queue a test-case event. Triggers an immediate flush when the batch size is reached, otherwise schedules a timer-based flush. */
-    queueEvent(event) {
-        this.pendingEvents.push(event);
-        if (this.pendingEvents.length >= this.options.streamingBatchSize) {
-            this.flush();
-        }
-        else if (!this.flushTimer) {
-            this.flushTimer = setTimeout(() => this.flush(), this.options.streamingBatchDelay);
-        }
-    }
-    /** Flush all pending events to the server. Returns a promise that resolves to `true` on success or `false` on failure (events are re-queued for retry). */
-    flush() {
-        if (this.flushTimer) {
-            clearTimeout(this.flushTimer);
-            this.flushTimer = null;
-        }
-        if (this.pendingEvents.length === 0 || !this._enabled || !this._runId)
-            return null;
-        const events = this.pendingEvents.splice(0);
-        // Never rejects: failed events are re-queued so the retry timer or the
-        // end-of-run drain can resend them (the server deduplicates).
-        const promise = this.httpClient
-            .postJSON(`/api/test-runs/${this._runId}/events`, { streamToken: this._token, testCases: events }, this._auth)
-            .then(() => {
-            this.retryCount = 0;
-            this.lastActivityAt = Date.now();
-            return true;
-        }, () => {
-            this.pendingEvents = events.concat(this.pendingEvents);
-            this.scheduleRetry();
-            return false;
-        });
-        this.flushPromises.push(promise);
-        return promise;
-    }
-    scheduleRetry() {
-        if (this.retryTimer)
-            return;
-        this.retryCount++;
-        const delay = Math.min(1000 * Math.pow(2, this.retryCount - 1), this.maxRetryDelay);
-        this.logger.debug(`Will retry streaming flush in ${delay}ms (attempt ${this.retryCount})`);
-        this.retryTimer = setTimeout(() => {
-            this.retryTimer = null;
-            const buffered = this.streamBuffer.load();
-            if (buffered.length > 0) {
-                this.streamBuffer.clear();
-                this.pendingEvents = buffered.concat(this.pendingEvents);
-            }
-            if (this.pendingEvents.length > 0)
-                this.flush();
-        }, delay);
-    }
-    // Schedule the next idle heartbeat. Self-rescheduling; cleared by stopHeartbeat.
-    scheduleHeartbeat() {
-        if (this.heartbeatStopped || this.heartbeatTimer)
-            return;
-        this.heartbeatTimer = setTimeout(() => {
-            this.heartbeatTimer = null;
-            void this.sendHeartbeat();
-        }, this.heartbeatInterval);
-    }
-    // Ping the server only when the run has actually been idle. Real event traffic
-    // already bumps the server's activity timestamp, so a recent flush (or pending
-    // events about to flush) makes the ping redundant — skip it and reschedule.
-    async sendHeartbeat() {
-        if (this.heartbeatStopped || !this._enabled || !this._runId || !this._token)
-            return;
-        const idleFor = Date.now() - this.lastActivityAt;
-        if (idleFor < this.heartbeatInterval || this.pendingEvents.length > 0) {
-            this.scheduleHeartbeat();
-            return;
-        }
-        try {
-            await this.httpClient.postJSON(`/api/test-runs/${this._runId}/heartbeat`, { streamToken: this._token }, this._auth);
-            this.lastActivityAt = Date.now();
-        }
-        catch (error) {
-            this.logger.debug(`Heartbeat failed: ${(0, errors_js_1.errorMessage)(error)}`);
-        }
-        this.scheduleHeartbeat();
-    }
-    /** Stop the idle heartbeat permanently (called when the run is wrapping up). */
-    stopHeartbeat() {
-        this.heartbeatStopped = true;
-        if (this.heartbeatTimer) {
-            clearTimeout(this.heartbeatTimer);
-            this.heartbeatTimer = null;
-        }
-    }
-    /** Drain all pending and buffered events before the run finishes. Retries up to 10 times with exponential back-off. */
-    async drain() {
-        this.stopHeartbeat();
-        if (!this._enabled) {
-            this.pendingEvents = [];
-            this.flushPromises = [];
-            return;
-        }
-        const MAX_ATTEMPTS = 10;
-        for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
-            if (this._enabled && this.pendingEvents.length > 0)
-                this.flush();
-            if (this.flushPromises.length > 0) {
-                await Promise.allSettled(this.flushPromises);
-                this.flushPromises = [];
-            }
-            if (this.pendingEvents.length === 0) {
-                const buffered = this.streamBuffer.load();
-                if (buffered.length > 0) {
-                    this.pendingEvents = buffered;
-                    this.streamBuffer.clear();
-                    continue;
-                }
-                return;
-            }
-            this.logger.debugError(`${this.pendingEvents.length} events pending, retrying (attempt ${attempt + 1}/${MAX_ATTEMPTS})...`);
-            await new Promise((resolve) => setTimeout(resolve, Math.min(1000 * Math.pow(2, attempt), 10000)));
-        }
-        if (this.pendingEvents.length > 0) {
-            this.streamBuffer.append(this.pendingEvents);
-            this.pendingEvents = [];
-        }
-    }
-    /** Schedule a live upload of trace and attachment files for a test case. Skips cases with no files. Concurrency is limited to 2 simultaneous uploads. */
-    scheduleLiveUpload(tc) {
-        const hasTrace = !!this.options.uploadTraces && this.fileHandler.findTraceFiles(tc).some((p) => fs.existsSync(p));
-        const hasAttachments = this.fileHandler.findAllAttachments(tc).length > 0;
-        if (!hasTrace && !hasAttachments)
-            return;
-        const promise = (async () => {
-            if (this._startPromise)
-                await this._startPromise;
-            if (!this._enabled || !this._runId || !this._token)
-                return;
-            // The complete event must reach the server before it can link files.
-            // queueEvent may have already triggered a batch-size flush that took all
-            // pending events, making our flush() return null.  Wait for any in-flight
-            // flush promises first, then try to flush remaining events.
-            if (this.flushPromises.length > 0) {
-                await Promise.allSettled(this.flushPromises);
-            }
-            const flush = this.flush();
-            if (flush)
-                await flush;
-            // Retry on 404: the events batch carrying this case may still be in flight
-            const delays = [0, 1000, 3000];
-            for (let attempt = 0; attempt < delays.length; attempt++) {
-                if (delays[attempt])
-                    await new Promise((resolve) => setTimeout(resolve, delays[attempt]));
-                try {
-                    await this.limitLiveUpload(() => this.uploader.uploadCaseFiles(this.options.projectName, this._runId, this._token, tc, this.options.uploadTraces, this._auth));
-                    this.uploadedCaseFiles.add(tc);
-                    return;
-                }
-                catch (error) {
-                    const retryable = error instanceof http_client_js_1.HttpError && error.status === 404;
-                    if (!retryable || attempt === delays.length - 1) {
-                        this.logger.debug(`Live file upload failed for "${tc.title}": ${(0, errors_js_1.errorMessage)(error)}`);
-                        return; // The end-of-run pass retries cases that failed here
-                    }
-                }
-            }
-        })();
-        this.liveUploadPromises.push(promise);
-    }
-    /** Wait for all live uploads to settle, then upload files for any test cases that weren't uploaded live */
-    async uploadRemaining(testCases) {
-        if (this.liveUploadPromises.length > 0) {
-            await Promise.allSettled(this.liveUploadPromises);
-            this.liveUploadPromises = [];
-        }
-        if (!this._enabled || !this._runId || !this._token)
-            return;
-        for (const tc of testCases) {
-            if (this.uploadedCaseFiles.has(tc))
-                continue;
-            try {
-                const uploaded = await this.uploader.uploadCaseFiles(this.options.projectName, this._runId, this._token, tc, this.options.uploadTraces, this._auth);
-                if (uploaded)
-                    this.uploadedCaseFiles.add(tc);
-            }
-            catch (error) {
-                this.logger.warn(`Failed to upload files for "${tc.title}": ${(0, errors_js_1.errorMessage)(error)}`);
-            }
-        }
-    }
-}
-exports.StreamManager = StreamManager;

package/dist/internal/submit/run-submitter.d.ts

@@ -1,67 +0,0 @@
-import type { FullResult } from '@playwright/test/reporter';
-import type { PiwiDashboardOptions, ShardInfo } from '../../public/options.js';
-import type { HttpClient } from '../transport/http-client.js';
-import type { Uploader } from './uploader.js';
-import type { CrashRecovery } from '../streaming/crash-recovery.js';
-import type { StreamManager } from '../streaming/stream-manager.js';
-import { Logger } from '../support/logger.js';
-import type { CollectedTestCase, SetupStep, FilterDetails } from '../../types.js';
-/**
- * Snapshot of everything the reporter has collected by `onEnd`, handed off to
- * the `RunSubmitter` so the reporter itself stays a thin collect-and-hand-off
- * shell.
- */
-export interface CollectedRun {
-    options: PiwiDashboardOptions;
-    testCases: CollectedTestCase[];
-    startTime: string | null;
-    playwrightVersion: string | null;
-    reporterVersion: string | null;
-    totalTests: number;
-    passedTests: number;
-    failedTests: number;
-    skippedTests: number;
-    timedOutTests: number;
-    didNotRunTests: number;
-    metadata: Record<string, any>;
-    instanceId: string;
-    shardInfo: ShardInfo | null;
-    setupSteps: SetupStep[];
-    isFullRun: boolean;
-    filterDetails: FilterDetails | null;
-}
-/**
- * Owns the three-tier submit/fallback ladder:
- *
- *   1. finalize the streaming run (`/finish`) when streaming is active,
- *   2. fall back to multipart upload (`/upload`) when there are reports or
- *      traces to attach,
- *   3. fall back to plain JSON (`/submit`) as the last resort, persisting a
- *      recovery payload on total failure.
- *
- * The order and logging are identical to the pre-extraction reporter — this is
- * a move, not a redesign.
- */
-export declare class RunSubmitter {
-    private readonly httpClient;
-    private readonly uploader;
-    private readonly recovery;
-    private readonly streamManager;
-    private readonly logger;
-    /**
-     * @param httpClient    HTTP client for auth resolution and the finish call.
-     * @param uploader      Upload strategies (multipart + JSON).
-     * @param recovery      Crash-recovery persistence.
-     * @param streamManager Streaming session (may be `null` when streaming is disabled).
-     * @param logger        Prefixed logger.
-     */
-    constructor(httpClient: HttpClient, uploader: Uploader, recovery: CrashRecovery, streamManager: StreamManager | null, logger?: Logger);
-    /** Run the fallback ladder for a completed test run. */
-    submit(run: CollectedRun, result: FullResult): Promise<void>;
-    private hasReports;
-    private reportOptions;
-    private buildRunPayload;
-    private tryFinishStreaming;
-    private tryUploadWithFiles;
-    private tryUploadJSON;
-}

package/dist/internal/submit/run-submitter.js

@@ -1,190 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunSubmitter = void 0;
-const errors_js_1 = require("../support/errors.js");
-const http_client_js_1 = require("../transport/http-client.js");
-const logger_js_1 = require("../support/logger.js");
-const step_analyzer_js_1 = require("../collect/step-analyzer.js");
-const serializer_js_1 = require("./serializer.js");
-/**
- * Owns the three-tier submit/fallback ladder:
- *
- *   1. finalize the streaming run (`/finish`) when streaming is active,
- *   2. fall back to multipart upload (`/upload`) when there are reports or
- *      traces to attach,
- *   3. fall back to plain JSON (`/submit`) as the last resort, persisting a
- *      recovery payload on total failure.
- *
- * The order and logging are identical to the pre-extraction reporter — this is
- * a move, not a redesign.
- */
-class RunSubmitter {
-    /**
-     * @param httpClient    HTTP client for auth resolution and the finish call.
-     * @param uploader      Upload strategies (multipart + JSON).
-     * @param recovery      Crash-recovery persistence.
-     * @param streamManager Streaming session (may be `null` when streaming is disabled).
-     * @param logger        Prefixed logger.
-     */
-    constructor(httpClient, uploader, recovery, streamManager, logger = new logger_js_1.Logger()) {
-        this.httpClient = httpClient;
-        this.uploader = uploader;
-        this.recovery = recovery;
-        this.streamManager = streamManager;
-        this.logger = logger;
-    }
-    /** Run the fallback ladder for a completed test run. */
-    async submit(run, result) {
-        const endTime = new Date().toISOString();
-        const duration = new Date(endTime).getTime() - new Date(run.startTime).getTime();
-        const overallStatus = (0, serializer_js_1.resolveOverallStatus)(result, {
-            failedTests: run.failedTests,
-            timedOutTests: run.timedOutTests,
-            totalTests: run.totalTests,
-        });
-        this.logger.info(`Test run completed. Status: ${overallStatus} (Playwright result.status: ${result?.status || 'undefined'})`);
-        this.logger.info(`Total: ${run.totalTests}, Passed: ${run.passedTests}, Failed: ${run.failedTests}, Skipped: ${run.skippedTests}, TimedOut: ${run.timedOutTests}, DidNotRun: ${run.didNotRunTests}`);
-        if (run.options.collectPerformanceMetrics) {
-            run.metadata.performance = (0, step_analyzer_js_1.computePerformanceSummary)(run.testCases);
-        }
-        const sm = this.streamManager;
-        if (sm?.startPromise)
-            await sm.startPromise;
-        await sm?.drain();
-        let auth;
-        try {
-            auth = sm?.auth ?? (await this.httpClient.resolveAuth(run.options));
-        }
-        catch (error) {
-            this.logger.error(`Authentication failed: ${(0, errors_js_1.errorMessage)(error)}`);
-            throw error;
-        }
-        if (sm?.enabled && sm?.runId != null) {
-            if (await this.tryFinishStreaming(run, overallStatus, duration, auth))
-                return;
-        }
-        if (this.hasReports(run) || run.options.uploadTraces) {
-            if (await this.tryUploadWithFiles(run, overallStatus, duration, auth))
-                return;
-        }
-        await this.tryUploadJSON(run, overallStatus, duration, auth);
-    }
-    hasReports(run) {
-        return !!run.options.uploadReport || (run.options.reports?.length ?? 0) > 0;
-    }
-    reportOptions(run) {
-        return {
-            uploadTraces: run.options.uploadTraces,
-            uploadReport: run.options.uploadReport,
-            reports: run.options.reports,
-        };
-    }
-    buildRunPayload(run, status, duration) {
-        return {
-            projectName: run.options.projectName,
-            projectDescription: run.options.projectDescription,
-            status,
-            startTime: run.startTime,
-            duration,
-            totalTests: run.totalTests,
-            passedTests: run.passedTests,
-            failedTests: run.failedTests,
-            timedOutTests: run.timedOutTests,
-            skippedTests: run.skippedTests,
-            didNotRunTests: run.didNotRunTests,
-            environment: run.options.environment,
-            label: run.options.label || null,
-            metadata: run.metadata,
-            instanceId: run.instanceId,
-            playwrightVersion: run.playwrightVersion ?? undefined,
-            reporterVersion: run.reporterVersion ?? undefined,
-            testCases: run.testCases,
-            shardIndex: run.shardInfo?.current,
-            shardTotal: run.shardInfo?.total,
-            isFullRun: run.isFullRun,
-            filterDetails: run.filterDetails,
-        };
-    }
-    async tryFinishStreaming(run, overallStatus, duration, auth) {
-        const sm = this.streamManager;
-        try {
-            const flakyTests = run.testCases.filter((tc) => tc.status === 'passed' && (tc.retries || 0) > 0).length;
-            const durations = run.testCases.filter((tc) => tc.duration != null).map((tc) => tc.duration);
-            await sm.uploadRemaining(run.testCases);
-            const finishBody = {
-                streamToken: sm.token,
-                status: overallStatus,
-                duration,
-                totalTests: run.totalTests,
-                passedTests: run.passedTests,
-                failedTests: run.failedTests,
-                timedOutTests: run.timedOutTests,
-                skippedTests: run.skippedTests,
-                didNotRunTests: run.didNotRunTests,
-                flakyTests,
-                durations,
-                label: run.options.label || null,
-                metadata: run.metadata,
-                hasPendingUploads: this.hasReports(run),
-                playwrightVersion: run.playwrightVersion ?? undefined,
-                reporterVersion: run.reporterVersion ?? undefined,
-                setupSteps: run.setupSteps.length > 0 ? run.setupSteps : undefined,
-                isFullRun: run.isFullRun,
-                filterDetails: run.filterDetails ?? null,
-            };
-            if (run.shardInfo) {
-                finishBody.shardIndex = run.shardInfo.current;
-                finishBody.shardTotal = run.shardInfo.total;
-            }
-            await this.httpClient.postJSON(`/api/test-runs/${sm.runId}/finish`, finishBody, auth);
-            this.logger.info(`Successfully finalized streaming run #${sm.runId}`);
-            this.recovery.clear();
-            if (this.hasReports(run)) {
-                try {
-                    await this.uploader.uploadReportsForStreamingRun(run.options.projectName, sm.runId, this.reportOptions(run), run.startTime, auth);
-                }
-                catch (error) {
-                    this.logger.warn(`Failed to upload reports for streaming run: ${(0, errors_js_1.errorMessage)(error)}`);
-                }
-            }
-            return true;
-        }
-        catch (error) {
-            this.logger.warn(`Failed to finalize streaming run: ${(0, errors_js_1.errorMessage)(error)}`);
-            this.logger.info('Falling back to batch upload...');
-            return false;
-        }
-    }
-    async tryUploadWithFiles(run, overallStatus, duration, auth) {
-        try {
-            await this.uploader.uploadWithFiles(this.buildRunPayload(run, overallStatus, duration), this.reportOptions(run), auth);
-            this.recovery.clear();
-            return true;
-        }
-        catch (error) {
-            if (error instanceof http_client_js_1.HttpError && error.status === 401 && !auth)
-                throw error;
-            this.logger.warn(`Failed to upload with files: ${(0, errors_js_1.errorMessage)(error)}`);
-            this.logger.info('Falling back to JSON upload...');
-            return false;
-        }
-    }
-    async tryUploadJSON(run, overallStatus, duration, auth) {
-        const payload = this.buildRunPayload(run, overallStatus, duration);
-        try {
-            await this.uploader.uploadJSON(payload, auth);
-            this.recovery.clear();
-        }
-        catch (error) {
-            // If the server returned 401 and no auth was configured, this is a
-            // configuration error — throw so the caller knows it's fatal.
-            if (error instanceof http_client_js_1.HttpError && error.status === 401 && !auth)
-                throw error;
-            this.logger.error(`All upload methods failed: ${(0, errors_js_1.errorMessage)(error)}`);
-            // Save the wire-serialized form so the recovery file matches the
-            // original submit payload (no raw attachments / internal fields).
-            this.recovery.save((0, serializer_js_1.serializeRun)(payload, { includeTestCases: true }));
-        }
-    }
-}
-exports.RunSubmitter = RunSubmitter;