@glubean/runner 0.7.0 → 0.8.1

package/dist/load/reducer.js

@@ -0,0 +1,718 @@
+import { LoadHistogram } from "./histogram.js";
+import { LoadTimeline } from "./timeline.js";
+import { LoadSampleCollector } from "./samples.js";
+const SEP = "\u0000";
+const ZERO_PCT = { p50: 0, p90: 0, p95: 0, p99: 0, max: 0 };
+// Fixed latency ladder (ms) for the distribution histograms. Fixed (not data-derived) so two
+// runs' distributions line up bucket-for-bucket; a final overflow bucket carries the tail.
+const LATENCY_LADDER = [10, 25, 50, 75, 100, 150, 200, 300, 500, 750, 1000, 2000, 5000];
+function rate(failed, total) {
+    return total > 0 ? failed / total : 0;
+}
+export class LoadReducerImpl {
+    runnerId = "";
+    config;
+    requestedConcurrency = 0;
+    endReason;
+    crash;
+    firstTs;
+    lastTs = 0;
+    // transactions (iterations)
+    iterStarted = 0;
+    iterCompleted = 0;
+    iterSucceeded = 0;
+    iterFailed = 0;
+    iterLatency = new LoadHistogram();
+    // primary-phase boundary (M5): present only when a scenario calls
+    // `ctx.report.primaryComplete()`. `primaryLatency` aggregates `primaryDurationMs`
+    // (iteration start → boundary); `iterHadPrimary` tracks in-flight iterations that
+    // reached the boundary so a later failure is classified before/after it.
+    primaryBoundaries = 0;
+    failedBeforePrimary = 0;
+    endedWithoutBoundary = 0;
+    primaryLatency = new LoadHistogram();
+    iterHadPrimary = new Set();
+    // continuation / producer-release (M6): present once any release is attempted.
+    releasedProducerSlots = 0;
+    rejectedReleaseSignals = 0;
+    duplicateReleaseSignals = 0;
+    maxContinuationBacklog = 0;
+    continuationBackpressure = new LoadHistogram();
+    // Released iterations still in their continuation phase (released, not yet ended):
+    // the LIVE in-flight count for snapshot() and an interrupted finalize().
+    liveContinuations = new Set();
+    // Iterations that reached their boundary requesting release but aren't yet granted
+    // / rejected — i.e. parked on a full backlog. They've left the primary phase but
+    // aren't continuations yet, so they're the LIVE `blockedOnBacklog` count.
+    pendingRelease = new Set();
+    // Per in-flight iteration: each step's START phase (recorded at step:start), so a
+    // step's step:end + requests aggregate under the phase it started in even after a
+    // mid-step boundary flips the live phase. Cleared at iteration:end (bounded).
+    iterStepPhase = new Map();
+    scenarios = new Map();
+    steps = new Map();
+    endpoints = new Map();
+    matrix = new Map();
+    recentFailures = [];
+    // Over-time series (RPS / error-rate / latency / concurrency vs time), bucketed by the
+    // event ts offset from the run start.
+    timeline = new LoadTimeline();
+    // Bounded failure-trace / slow-transaction samples (the "show me one" view).
+    samples;
+    /** @param reportCaps `report` sample caps (0 disables a sample type entirely). */
+    constructor(reportCaps = {}) {
+        this.samples = new LoadSampleCollector(reportCaps);
+    }
+    apply(event) {
+        if (this.firstTs === undefined)
+            this.firstTs = event.ts;
+        if (event.ts > this.lastTs)
+            this.lastTs = event.ts;
+        if (event.runnerId)
+            this.runnerId = event.runnerId;
+        switch (event.type) {
+            case "load:start":
+                this.config = event.config;
+                this.requestedConcurrency = event.config.concurrency;
+                // Seed an aggregate for every configured traffic-mix entry, so a low-weight entry
+                // that never gets selected still appears in the artifact (configured, 0 iterations)
+                // rather than absent. A single-scenario run has no `scenarios` and seeds on its
+                // first iteration:start, as before.
+                for (const s of event.config.scenarios ?? []) {
+                    this.scenarioAgg(s.scenarioId, s.scenarioRefId);
+                }
+                break;
+            case "load:end":
+                this.endReason = event.reason;
+                if (event.crash)
+                    this.crash = event.crash;
+                break;
+            case "iteration:start":
+                this.iterStarted += 1;
+                // Concurrency-over-time: sample the live in-flight (post-increment local peak); the
+                // window also carries the count forward at finalize.
+                this.timeline.recordIterationStart(this.offsetOf(event.ts), this.iterStarted - this.iterCompleted);
+                if (event.iterationId) {
+                    this.samples.beginIteration(event.iterationId, {
+                        scenarioId: event.scenarioId ?? "",
+                        ...(event.scenarioRefId !== undefined ? { scenarioRefId: event.scenarioRefId } : {}),
+                        producerSlotId: event.producerSlotId ?? "",
+                        ...(event.feederKeys !== undefined ? { feederKeys: event.feederKeys } : {}),
+                    });
+                }
+                // Seed the scenario aggregate (no completed-count change) so a run that
+                // aborts/crashes before this scenario's first iteration:end still keeps
+                // scenario-level attribution in the finalized artifact.
+                this.scenarioAgg(event.scenarioId, event.scenarioRefId);
+                break;
+            case "iteration:end": {
+                this.iterCompleted += 1;
+                if (event.ok)
+                    this.iterSucceeded += 1;
+                else
+                    this.iterFailed += 1;
+                this.iterLatency.record(event.durationMs);
+                this.timeline.recordIterationEnd(this.offsetOf(event.ts)); // iteration throughput over time
+                // Boundary accounting (M5): did this iteration reach its primary boundary?
+                // A failure WITHOUT a boundary failed before primary completion.
+                const hadBoundary = event.iterationId ? this.iterHadPrimary.delete(event.iterationId) : false;
+                if (!hadBoundary) {
+                    this.endedWithoutBoundary += 1;
+                    // A no-boundary iteration has no continuation phase — its whole run IS its
+                    // primary phase. On success it COMPLETED primary (record its full duration
+                    // as primary latency); on failure it failed before any boundary.
+                    if (!event.ok)
+                        this.failedBeforePrimary += 1;
+                    else
+                        this.primaryLatency.record(event.durationMs);
+                }
+                if (event.iterationId) {
+                    this.samples.endIteration(event.iterationId, {
+                        ok: event.ok,
+                        durationMs: event.durationMs,
+                        ...(event.errorKind !== undefined ? { errorKind: event.errorKind } : {}),
+                    });
+                    this.iterStepPhase.delete(event.iterationId); // bounded cleanup
+                    this.liveContinuations.delete(event.iterationId); // continuation finished
+                    this.pendingRelease.delete(event.iterationId); // a fail-iteration tail ended
+                }
+                const sc = this.scenarioAgg(event.scenarioId, event.scenarioRefId);
+                if (sc) {
+                    sc.iterations += 1;
+                    if (event.ok)
+                        sc.successful += 1;
+                    else
+                        sc.failed += 1;
+                    sc.latency.record(event.durationMs);
+                }
+                if (!event.ok) {
+                    this.pushFailure({
+                        scenarioId: event.scenarioId,
+                        scenarioRefId: event.scenarioRefId,
+                        iterationId: event.iterationId ?? "",
+                        errorKind: event.errorKind,
+                        atMs: this.firstTs !== undefined ? event.ts - this.firstTs : 0,
+                    });
+                }
+                break;
+            }
+            case "step:start": {
+                const stepId = event.stepId ?? event.stepName;
+                // step:start carries the step's START phase — record it so this step's later
+                // events (step:end, requests) all resolve to it, even after a mid-step flip.
+                const phase = this.phaseOf(event);
+                this.rememberStepPhase(event.iterationId, stepId, phase);
+                const step = this.getStep(event.scenarioId, event.scenarioRefId, stepId, phase, event.stepName);
+                // groupId is only on step:start — capture it now (step:end omits it).
+                if (event.groupId !== undefined)
+                    step.groupId = event.groupId;
+                break;
+            }
+            case "step:end": {
+                const stepId = event.stepId ?? event.stepName;
+                const step = this.getStep(event.scenarioId, event.scenarioRefId, stepId, this.stepStartPhase(event.iterationId, stepId, this.phaseOf(event)), event.stepName);
+                step.stepName = event.stepName; // correct any placeholder set by an earlier request:observed
+                // A skipped leaf emits no step:start, so capture its group here too.
+                if (event.groupId !== undefined && step.groupId === undefined)
+                    step.groupId = event.groupId;
+                step.invocationCount += 1;
+                if (event.skipped) {
+                    // A skipped step (fail-fast / skipRemainingSteps) is neither a latency
+                    // sample nor a failure of its own — only an explicit skip.
+                    step.skippedCount += 1;
+                }
+                else {
+                    step.latency.record(event.durationMs);
+                    if (!event.ok)
+                        step.errorCount += 1;
+                }
+                step.assertionFailureCount += event.assertionFailures ?? 0;
+                if (event.iterationId) {
+                    this.samples.recordStep(event.iterationId, {
+                        stepId,
+                        stepName: event.stepName,
+                        durationMs: event.durationMs,
+                        ok: event.ok,
+                        skipped: event.skipped ?? false,
+                    });
+                }
+                break;
+            }
+            case "request:observed": {
+                // RPS / error-rate / latency over time, with a live-in-flight sample (a request-busy
+                // window — e.g. a poll — still shows concurrency).
+                this.timeline.recordRequest(this.offsetOf(event.ts), event.durationMs, event.ok, this.iterStarted - this.iterCompleted);
+                if (event.iterationId) {
+                    this.samples.recordRequest(event.iterationId, {
+                        tsOffsetMs: this.offsetOf(event.ts),
+                        ...(event.stepId !== undefined ? { stepId: event.stepId } : {}),
+                        phase: this.phaseOf(event),
+                        method: event.method,
+                        routeKey: event.routeKey,
+                        ...(event.status !== undefined ? { status: event.status } : {}),
+                        ok: event.ok,
+                        durationMs: event.durationMs,
+                        ...(event.errorKind !== undefined ? { errorKind: event.errorKind } : {}),
+                    });
+                }
+                const ep = this.endpointAgg(event);
+                ep.requestCount += 1;
+                if (!event.ok)
+                    ep.errorCount += 1;
+                ep.latency.record(event.durationMs);
+                const statusKey = event.status === undefined ? "error" : String(event.status);
+                ep.statusCounts[statusKey] = (ep.statusCounts[statusKey] ?? 0) + 1;
+                const cell = this.matrixAgg(event);
+                cell.requestCount += 1;
+                if (!event.ok)
+                    cell.errorCount += 1;
+                cell.latency.record(event.durationMs);
+                // Attribute the request to its STEP's requestCount under the step's START
+                // phase (not the request's live phase), so a post-boundary same-step request
+                // lands in the step's single row — endpoint/matrix above already used the
+                // live phase. (request:observed often arrives before step:end, so the step
+                // agg is created lazily here under the same start phase as step:start.)
+                if (event.stepId) {
+                    const step = this.getStep(event.scenarioId, event.scenarioRefId, event.stepId, this.stepStartPhase(event.iterationId, event.stepId, this.phaseOf(event)), event.stepId);
+                    step.requestCount += 1;
+                }
+                break;
+            }
+            case "assertion:observed": {
+                // Only failed assertions matter to a failure trace (they don't feed an aggregate —
+                // step:end already carries the per-step failed-assertion count).
+                if (!event.passed && event.iterationId) {
+                    this.samples.recordAssertionFailure(event.iterationId, {
+                        tsOffsetMs: this.offsetOf(event.ts),
+                        ...(event.stepId !== undefined ? { stepId: event.stepId } : {}),
+                        phase: this.phaseOf(event),
+                        ...(event.message !== undefined ? { message: event.message } : {}),
+                        // Presence (not value) checks so a deliberately-`undefined` operand survives.
+                        ...("actual" in event ? { actual: event.actual, hasActual: true } : {}),
+                        ...("expected" in event ? { expected: event.expected, hasExpected: true } : {}),
+                    });
+                }
+                break;
+            }
+            case "producer:primaryCompleted": {
+                // The first primaryComplete boundary of an iteration (M5): record the
+                // primary-phase duration and mark the iteration as having reached it.
+                this.primaryBoundaries += 1;
+                this.primaryLatency.record(event.primaryDurationMs);
+                if (event.iterationId) {
+                    this.iterHadPrimary.add(event.iterationId);
+                    // A release request leaves the primary phase but isn't a continuation until
+                    // granted — until then it's parked on the backlog (blockedOnBacklog).
+                    if (event.releaseRequested)
+                        this.pendingRelease.add(event.iterationId);
+                }
+                break;
+            }
+            case "producer:released": {
+                // A producer slot was freed at the boundary (M6): track release count, the
+                // back-pressure wait, the peak backlog, and the now-live continuation (its
+                // iteration is in continuation phase until its iteration:end).
+                this.releasedProducerSlots += 1;
+                this.continuationBackpressure.record(event.backpressureMs);
+                if (event.continuationBacklog > this.maxContinuationBacklog) {
+                    this.maxContinuationBacklog = event.continuationBacklog;
+                }
+                if (event.iterationId) {
+                    this.pendingRelease.delete(event.iterationId); // granted → now a continuation
+                    this.liveContinuations.add(event.iterationId);
+                }
+                break;
+            }
+            case "producer:releaseRejected": {
+                // A release that wasn't granted: a duplicate signal, or rejected (backlog full
+                // under fail-iteration, a parked release whose drain bound expired, or one
+                // cancelled by the run deadline).
+                if (event.reason === "duplicateRelease") {
+                    this.duplicateReleaseSignals += 1;
+                }
+                else {
+                    this.rejectedReleaseSignals += 1;
+                    // A deadline-rejected release still STALLED the producer (it parked on the
+                    // full backlog until the deadline) — count that wait as back-pressure, and
+                    // it's no longer parked. (A duplicate's original release already cleared.)
+                    if (event.waitMs > 0)
+                        this.continuationBackpressure.record(event.waitMs);
+                    if (event.iterationId)
+                        this.pendingRelease.delete(event.iterationId);
+                }
+                break;
+            }
+            // assertion:observed / log:sampled / checkpoints are handled by the sink
+            // (failure traces) or don't affect these aggregates.
+            default:
+                break;
+        }
+    }
+    /** Ms from the run start (the first event's ts) — the timeline's window axis. */
+    offsetOf(ts) {
+        return this.firstTs !== undefined ? Math.max(0, ts - this.firstTs) : 0;
+    }
+    snapshot(now) {
+        const at = now ?? this.lastTs;
+        const elapsedMs = this.firstTs !== undefined ? Math.max(0, at - this.firstTs) : 0;
+        const elapsedSec = elapsedMs / 1000;
+        return {
+            elapsedMs,
+            requestedConcurrency: this.requestedConcurrency,
+            primaryInFlight: this.primaryInFlightCount(),
+            continuationInFlight: this.liveContinuations.size,
+            blockedOnBacklog: this.pendingRelease.size,
+            primaryStarted: this.iterStarted,
+            // With a phase split, "primary completed" = boundaries + no-boundary successes;
+            // in the pure closed model (no primaryComplete) it coincides with completed
+            // iterations.
+            primaryCompleted: this.primaryBoundaries > 0 ? this.primaryCompletedCount() : this.iterCompleted,
+            endToEndCompleted: this.iterCompleted,
+            failedIterations: this.iterFailed,
+            throughputPerSec: elapsedSec > 0 ? this.iterCompleted / elapsedSec : 0,
+            transactionLatency: this.iterCompleted > 0 ? this.iterLatency.percentiles() : ZERO_PCT,
+            topSlowEndpoints: this.topSlowEndpoints(3, elapsedSec),
+            recentFailures: this.recentFailures.slice(-5),
+        };
+    }
+    finalize() {
+        const startedAtMs = this.firstTs ?? 0;
+        const durationMs = Math.max(0, this.lastTs - startedAtMs);
+        const elapsedSec = durationMs / 1000;
+        const endpoints = this.endpointSummaries(elapsedSec);
+        const anyHeuristicEndpoint = endpoints.some((e) => e.routeKeyHeuristic);
+        return {
+            schemaVersion: "glubean.load.v1",
+            runnerId: this.runnerId,
+            runMode: "load",
+            startedAt: new Date(startedAtMs).toISOString(),
+            durationMs,
+            source: { kind: "glubean-local", engine: "local" },
+            config: this.config ?? { concurrency: this.requestedConcurrency },
+            runtime: {
+                engine: "local",
+                processModel: "single-process-async-producer-slot",
+                // A configured think-time makes this a paced closed run, not back-to-back.
+                executionModel: this.config?.pacing?.thinkTimeMs !== undefined ? "closed-paced" : "closed-back-to-back",
+                // Producer release ("producer-released") wins; else a primaryComplete
+                // boundary is a MEASURED closed run (phase split); else plain closed.
+                slotModel: this.releasedProducerSlots > 0
+                    ? "producer-released"
+                    : this.primaryBoundaries > 0
+                        ? "end-to-end-measured"
+                        : "end-to-end",
+                requestedConcurrency: this.requestedConcurrency,
+                // Same reducer state as snapshot(): an interrupted run (abort/crash with
+                // started-but-not-ended iterations) shows its in-flight count, not 0.
+                primaryInFlight: this.primaryInFlightCount(),
+                // Released iterations still in their continuation phase at finalize (an
+                // interrupted run; a clean run drains to 0). The orchestrator may raise this
+                // for drain-timeout aborts whose tails it abandoned.
+                continuationInFlight: this.liveContinuations.size,
+                // Producers still parked on a full backlog at finalize (an interrupted run;
+                // a clean run has none).
+                blockedOnBacklog: this.pendingRelease.size,
+                feederGuarantee: "single-node",
+                sampleGranularity: "event",
+                attribution: this.attribution(anyHeuristicEndpoint),
+                percentileSource: "glubean-reducer",
+                ...(this.crash ? { crash: this.crash } : {}),
+            },
+            summary: {
+                // M4 evaluates thresholds and refines pass; here pass = "didn't crash".
+                pass: this.endReason !== "crash" && this.crash === undefined,
+                totalIterations: this.iterCompleted,
+                successfulIterations: this.iterSucceeded,
+                failedIterations: this.iterFailed,
+                errorRate: rate(this.iterFailed, this.iterCompleted),
+                throughputPerSec: elapsedSec > 0 ? this.iterCompleted / elapsedSec : 0,
+                latency: this.iterCompleted > 0 ? this.iterLatency.percentiles() : ZERO_PCT,
+                ...(this.iterCompleted > 0 ? { latencyDistribution: this.iterLatency.distribution(LATENCY_LADDER) } : {}),
+                // Phase split (M5): present only once an iteration reached a primaryComplete
+                // boundary. The top-level compat fields above stay end-to-end; `primary` /
+                // `endToEnd` expose the split (primary = up to the boundary).
+                ...(this.primaryBoundaries > 0
+                    ? { primary: this.primaryPhaseSummary(elapsedSec), endToEnd: this.endToEndPhaseSummary(elapsedSec) }
+                    : {}),
+                // Continuation (M6): present once producer release is attempted.
+                ...(this.releaseUsed() ? { continuation: this.continuationSummary() } : {}),
+                thresholds: [],
+            },
+            scenarios: this.scenarioSummaries(),
+            steps: this.stepSummaries(),
+            endpoints,
+            matrix: this.matrixSummaries(),
+            timeline: this.timeline.finalize(durationMs),
+            samples: this.samples.finalize(),
+        };
+    }
+    // ── aggregate accessors ────────────────────────────────────────────────
+    phaseOf(event) {
+        return event.phase ?? "primary";
+    }
+    /** Record the phase a step started in for this iteration (from step:start). */
+    rememberStepPhase(iterationId, stepId, phase) {
+        if (!iterationId)
+            return;
+        let m = this.iterStepPhase.get(iterationId);
+        if (!m) {
+            m = new Map();
+            this.iterStepPhase.set(iterationId, m);
+        }
+        m.set(stepId, phase);
+    }
+    /** The phase a step started in this iteration (falls back to `live` for a SKIPPED
+     *  leaf, which emits no step:start, or an untracked iteration). */
+    stepStartPhase(iterationId, stepId, live) {
+        if (!iterationId)
+            return live;
+        return this.iterStepPhase.get(iterationId)?.get(stepId) ?? live;
+    }
+    scenarioKey(scenarioId, scenarioRefId) {
+        return `${scenarioId}${SEP}${scenarioRefId ?? ""}`;
+    }
+    scenarioAgg(scenarioId, scenarioRefId) {
+        if (!scenarioId)
+            return undefined;
+        const key = this.scenarioKey(scenarioId, scenarioRefId);
+        let agg = this.scenarios.get(key);
+        if (!agg) {
+            agg = {
+                scenarioId,
+                ...(scenarioRefId !== undefined ? { scenarioRefId } : {}),
+                iterations: 0,
+                successful: 0,
+                failed: 0,
+                latency: new LoadHistogram(),
+            };
+            this.scenarios.set(key, agg);
+        }
+        return agg;
+    }
+    // Steps are keyed by (stepId, the phase the invocation STARTED in). A step that
+    // spans the boundary stays ONE row — every event of that invocation resolves to
+    // its captured start phase (`iterStepPhase`), so a post-boundary same-step request
+    // can't fork a phantom row — while the SAME stepId starting in different phases
+    // across iterations (a conditional boundary) correctly splits into two rows.
+    // Endpoints / matrix still split by the request's LIVE phase, so post-boundary
+    // requests show as continuation.
+    stepKey(scenarioId, scenarioRefId, stepId, phase) {
+        return `${scenarioId ?? ""}${SEP}${scenarioRefId ?? ""}${SEP}${stepId}${SEP}${phase}`;
+    }
+    getStep(scenarioId, scenarioRefId, stepId, phase, stepName) {
+        const key = this.stepKey(scenarioId, scenarioRefId, stepId, phase);
+        let agg = this.steps.get(key);
+        if (!agg) {
+            agg = {
+                scenarioId: scenarioId ?? "",
+                ...(scenarioRefId !== undefined ? { scenarioRefId } : {}),
+                stepId,
+                stepName,
+                phase, // the phase of the step's FIRST event (its start)
+                invocationCount: 0,
+                skippedCount: 0,
+                assertionFailureCount: 0,
+                errorCount: 0,
+                requestCount: 0,
+                latency: new LoadHistogram(),
+            };
+            this.steps.set(key, agg);
+        }
+        return agg;
+    }
+    endpointAgg(event) {
+        const phase = this.phaseOf(event); // normalize omitted phase to "primary" (matches steps)
+        const key = `${event.routeKey}${SEP}${phase}`;
+        let agg = this.endpoints.get(key);
+        if (!agg) {
+            agg = {
+                routeKey: event.routeKey,
+                phase,
+                routeKeySource: event.routeKeySource,
+                routeKeyHeuristic: event.routeKeyHeuristic,
+                method: event.method,
+                requestCount: 0,
+                errorCount: 0,
+                statusCounts: {},
+                latency: new LoadHistogram(),
+            };
+            this.endpoints.set(key, agg);
+        }
+        // If any request for this routeKey is heuristic, the aggregate is heuristic.
+        if (event.routeKeyHeuristic && !agg.routeKeyHeuristic) {
+            agg.routeKeyHeuristic = true;
+            agg.routeKeySource = event.routeKeySource;
+        }
+        return agg;
+    }
+    matrixAgg(event) {
+        const phase = this.phaseOf(event); // normalize omitted phase to "primary" (matches steps)
+        const key = `${event.scenarioId ?? ""}${SEP}${event.scenarioRefId ?? ""}${SEP}${event.stepId ?? ""}${SEP}${event.routeKey}${SEP}${phase}`;
+        let agg = this.matrix.get(key);
+        if (!agg) {
+            agg = {
+                scenarioId: event.scenarioId ?? "",
+                ...(event.scenarioRefId !== undefined ? { scenarioRefId: event.scenarioRefId } : {}),
+                ...(event.stepId !== undefined ? { stepId: event.stepId } : {}),
+                phase,
+                routeKey: event.routeKey,
+                routeKeySource: event.routeKeySource,
+                routeKeyHeuristic: event.routeKeyHeuristic,
+                requestCount: 0,
+                errorCount: 0,
+                latency: new LoadHistogram(),
+            };
+            this.matrix.set(key, agg);
+        }
+        if (event.routeKeyHeuristic && !agg.routeKeyHeuristic) {
+            agg.routeKeyHeuristic = true;
+            agg.routeKeySource = event.routeKeySource;
+        }
+        return agg;
+    }
+    pushFailure(f) {
+        this.recentFailures.push(f);
+        if (this.recentFailures.length > 100)
+            this.recentFailures.shift();
+    }
+    // ── summary builders ───────────────────────────────────────────────────
+    /** Iterations still in their primary phase: started, not yet at a boundary, and
+     *  not ended before reaching one. Without any boundary this is the ordinary
+     *  end-to-end in-flight count (started − completed). */
+    primaryInFlightCount() {
+        return Math.max(0, this.iterStarted - this.primaryBoundaries - this.endedWithoutBoundary);
+    }
+    /** Iterations that COMPLETED their primary phase: those that hit the boundary,
+     *  plus no-boundary successes (whose primary phase is the whole iteration). Keeps
+     *  `started = completed + failedBeforeRelease + inFlightAtEnd` consistent. */
+    primaryCompletedCount() {
+        return this.primaryBoundaries + (this.endedWithoutBoundary - this.failedBeforePrimary);
+    }
+    /** Primary-phase aggregate (producer side) — present only with a boundary. */
+    primaryPhaseSummary(elapsedSec) {
+        const completed = this.primaryCompletedCount();
+        return {
+            started: this.iterStarted,
+            completed,
+            failedBeforeRelease: this.failedBeforePrimary,
+            throughputPerSec: elapsedSec > 0 ? completed / elapsedSec : 0,
+            latency: this.primaryLatency.count > 0 ? this.primaryLatency.percentiles() : ZERO_PCT,
+        };
+    }
+    /** End-to-end aggregate (full logical iteration) — the structured form of the
+     *  top-level compat fields, surfaced alongside `primary` when the split exists. */
+    endToEndPhaseSummary(elapsedSec) {
+        return {
+            started: this.iterStarted,
+            completed: this.iterCompleted,
+            successful: this.iterSucceeded,
+            failed: this.iterFailed,
+            inFlightAtEnd: Math.max(0, this.iterStarted - this.iterCompleted),
+            errorRate: rate(this.iterFailed, this.iterCompleted),
+            throughputPerSec: elapsedSec > 0 ? this.iterCompleted / elapsedSec : 0,
+            latency: this.iterCompleted > 0 ? this.iterLatency.percentiles() : ZERO_PCT,
+        };
+    }
+    /** Whether producer release was attempted at all (release granted, rejected, a
+     *  duplicate, or still parked on the backlog at finalize) — gates the continuation
+     *  summary's presence so an interrupted run with a parked release still reports it. */
+    releaseUsed() {
+        return (this.releasedProducerSlots > 0 ||
+            this.rejectedReleaseSignals > 0 ||
+            this.duplicateReleaseSignals > 0 ||
+            this.pendingRelease.size > 0);
+    }
+    /** Continuation (bounded-open) subsystem summary (M6). A finalized run has drained
+     *  its continuations, so live counts (backlog / active / blockedOnBacklog) are 0;
+     *  the cumulative release / back-pressure / coverage figures are what matter. */
+    continuationSummary() {
+        const hasBackpressure = this.continuationBackpressure.count > 0;
+        const waits = hasBackpressure ? this.continuationBackpressure.percentiles() : undefined;
+        const live = this.liveContinuations.size; // in-flight at finalize (0 for a clean run)
+        return {
+            backlog: live,
+            maxBacklog: this.maxContinuationBacklog,
+            // Every in-flight continuation is concurrently scheduled in this single-process
+            // model, so peak concurrency coincides with peak backlog.
+            maxConcurrent: this.maxContinuationBacklog,
+            active: live,
+            ...(waits ? { queueWaitMs: waits, backpressureMs: waits } : {}),
+            releasedProducerSlots: this.releasedProducerSlots,
+            // Coverage: how many iterations reached a boundary, and of those how many
+            // actually released — a low value flags branch/error paths that skipped it.
+            primaryBoundaryCoverage: this.iterStarted > 0 ? this.primaryBoundaries / this.iterStarted : 0,
+            releaseCoverage: this.primaryBoundaries > 0 ? this.releasedProducerSlots / this.primaryBoundaries : 0,
+            duplicateReleaseSignals: this.duplicateReleaseSignals,
+            rejectedReleaseSignals: this.rejectedReleaseSignals,
+            abortedByDrainTimeout: 0, // drain-timeout abort lands in M6-d
+        };
+    }
+    attribution(anyHeuristicEndpoint) {
+        const canonical = "canonical";
+        return {
+            scenario: canonical,
+            step: canonical,
+            endpoint: anyHeuristicEndpoint ? "heuristic" : canonical,
+            phase: canonical,
+            iteration: canonical,
+            failureTrace: canonical,
+        };
+    }
+    stepSummary(agg) {
+        return {
+            scenarioId: agg.scenarioId,
+            // Carry the mix entry id so two entries referencing the SAME scenario aren't
+            // indistinguishable in the flat `artifact.steps` (matches the scenario summaries
+            // + matrix, which already carry it). Omitted for a single scenario.
+            ...(agg.scenarioRefId !== undefined ? { scenarioRefId: agg.scenarioRefId } : {}),
+            stepId: agg.stepId,
+            stepName: agg.stepName,
+            ...(agg.groupId !== undefined ? { groupId: agg.groupId } : {}),
+            phase: agg.phase,
+            invocationCount: agg.invocationCount,
+            skippedCount: agg.skippedCount,
+            assertionFailureCount: agg.assertionFailureCount,
+            errorCount: agg.errorCount,
+            // Error rate is over EXECUTED invocations — skipped steps aren't failures.
+            errorRate: rate(agg.errorCount, agg.invocationCount - agg.skippedCount),
+            latency: agg.latency.count > 0 ? agg.latency.percentiles() : ZERO_PCT,
+            requestCount: agg.requestCount,
+        };
+    }
+    stepSummaries() {
+        return [...this.steps.values()].map((s) => this.stepSummary(s));
+    }
+    scenarioSummaries() {
+        const stepsByScenario = new Map();
+        for (const s of this.steps.values()) {
+            const k = this.scenarioKey(s.scenarioId, s.scenarioRefId);
+            const list = stepsByScenario.get(k) ?? [];
+            list.push(this.stepSummary(s));
+            stepsByScenario.set(k, list);
+        }
+        return [...this.scenarios.values()].map((sc) => ({
+            scenarioId: sc.scenarioId,
+            ...(sc.scenarioRefId !== undefined ? { scenarioRefId: sc.scenarioRefId } : {}),
+            iterations: sc.iterations,
+            successfulIterations: sc.successful,
+            failedIterations: sc.failed,
+            errorRate: rate(sc.failed, sc.iterations),
+            latency: sc.latency.count > 0 ? sc.latency.percentiles() : ZERO_PCT,
+            steps: stepsByScenario.get(this.scenarioKey(sc.scenarioId, sc.scenarioRefId)) ?? [],
+        }));
+    }
+    endpointSummaries(elapsedSec) {
+        return [...this.endpoints.values()].map((e) => ({
+            routeKey: e.routeKey,
+            ...(e.phase !== undefined ? { phase: e.phase } : {}),
+            routeKeySource: e.routeKeySource,
+            routeKeyHeuristic: e.routeKeyHeuristic,
+            ...(e.method !== undefined ? { method: e.method } : {}),
+            requestCount: e.requestCount,
+            errorCount: e.errorCount,
+            errorRate: rate(e.errorCount, e.requestCount),
+            statusCounts: e.statusCounts,
+            latency: e.latency.count > 0 ? e.latency.percentiles() : ZERO_PCT,
+            ...(e.latency.count > 0 ? { latencyDistribution: e.latency.distribution(LATENCY_LADDER) } : {}),
+            throughputPerSec: elapsedSec > 0 ? e.requestCount / elapsedSec : 0,
+        }));
+    }
+    matrixSummaries() {
+        // Resolve a matrix cell's stepName by stepId regardless of phase: the cell's
+        // phase is the request's LIVE phase, but the step agg is keyed by its start
+        // phase, so a post-boundary request's cell would otherwise miss its step row.
+        const stepNameById = new Map();
+        for (const s of this.steps.values()) {
+            stepNameById.set(`${this.scenarioKey(s.scenarioId, s.scenarioRefId)}${SEP}${s.stepId}`, s.stepName);
+        }
+        return [...this.matrix.values()].map((m) => {
+            const stepName = m.stepId !== undefined
+                ? stepNameById.get(`${this.scenarioKey(m.scenarioId, m.scenarioRefId)}${SEP}${m.stepId}`)
+                : undefined;
+            return {
+                scenarioId: m.scenarioId,
+                ...(m.scenarioRefId !== undefined ? { scenarioRefId: m.scenarioRefId } : {}),
+                ...(m.stepId !== undefined ? { stepId: m.stepId } : {}),
+                ...(stepName !== undefined ? { stepName } : {}),
+                ...(m.phase !== undefined ? { phase: m.phase } : {}),
+                routeKey: m.routeKey,
+                routeKeySource: m.routeKeySource,
+                routeKeyHeuristic: m.routeKeyHeuristic,
+                requestCount: m.requestCount,
+                errorRate: rate(m.errorCount, m.requestCount),
+                latency: m.latency.count > 0 ? m.latency.percentiles() : ZERO_PCT,
+            };
+        });
+    }
+    topSlowEndpoints(n, elapsedSec) {
+        return this.endpointSummaries(elapsedSec)
+            .sort((a, b) => b.latency.p95 - a.latency.p95)
+            .slice(0, n);
+    }
+}
+/** Create a fresh streaming load reducer. `reportCaps` bounds the failure-trace /
+ *  slow-transaction samples (from the plan's `report` config; 0 disables a type). */
+export function createLoadReducer(reportCaps) {
+    return new LoadReducerImpl(reportCaps);
+}
+//# sourceMappingURL=reducer.js.map