@pasko70/pibo 1.9.8 → 1.9.9

package/dist/debug/web-streaming-benchmark-analysis.js

@@ -1,605 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { summarizeStreamingSelectedLiveEventSource } from "./web-streaming-report.js";
-const LIVE_PIPELINE_MIN_PRESERVATION_RATIO = 0.95;
-const LIVE_PIPELINE_MIN_FLUSH_RATIO = 0.75;
-const URL_COMPARISON_MAX_SMOOTHNESS_DROP = 15;
-const URL_COMPARISON_MAX_DOM_LAG_DELTA_MS = 150;
-const URL_COMPARISON_MAX_SSE_LAG_DELTA_MS = 100;
-const URL_COMPARISON_MAX_SSE_CHUNK_GAP_DELTA_MS = 100;
-const URL_COMPARISON_MAX_FIRST_TRANSPORT_LATENCY_DELTA_MS = 250;
-const URL_COMPARISON_MAX_FIRST_LIVE_LATENCY_DELTA_MS = 250;
-const URL_COMPARISON_MAX_FIRST_VISIBLE_LATENCY_DELTA_MS = 300;
-const PROVIDER_MIN_TEXT_PRESERVATION_RATIO = 0.95;
-const PROVIDER_MIN_REASONING_PRESERVATION_RATIO = 0.95;
-export function scoreStreamingBenchmark(benchmark) {
-    const debugDelta = benchmark.debug.delta ?? {};
-    const textDeltaCount = numberField(debugDelta, "textDeltaCount");
-    const domGapP50Ms = finiteNumber(benchmark.dom.gapsMs.p50);
-    const domGapP90Ms = finiteNumber(benchmark.dom.gapsMs.p90);
-    const domJumpP90Chars = finiteNumber(benchmark.dom.positiveCharJumps.p90);
-    const firstVisibleMs = finiteNumber(benchmark.dom.firstPositiveUpdateMs);
-    const providerToDomRatio = textDeltaCount > 0 ? Math.min(1, benchmark.dom.positiveUpdateCount / textDeltaCount) : 0;
-    const smoothness = 0.30 * clampScore(100 - (domGapP50Ms ?? 100))
-        + 0.25 * clampScore(((300 - (domGapP90Ms ?? 300)) / 3))
-        + 0.20 * clampScore(((120 - (domJumpP90Chars ?? 120)) / 1.2))
-        + 0.15 * clampScore(providerToDomRatio * 100)
-        + 0.10 * clampScore(100 - ((firstVisibleMs ?? 500) / 5));
-    return {
-        smoothness: round3(smoothness),
-        domGapP50Ms,
-        domGapP90Ms,
-        domJumpP90Chars,
-        textDeltaCount,
-        domPositiveUpdateCount: benchmark.dom.positiveUpdateCount,
-        firstVisibleMs,
-    };
-}
-export function summarizeStreamingCadence(benchmark) {
-    const fixtureScheduleGapP90Ms = finiteNumber(benchmark.fixture?.scheduleGapsMs?.p90);
-    if (fixtureScheduleGapP90Ms === undefined)
-        return undefined;
-    const domGapP90Ms = finiteNumber(benchmark.dom.gapsMs.p90);
-    const sseTextGapP90Ms = finiteNumber(benchmark.sse?.textEventGapsMs.p90);
-    return {
-        fixtureScheduleGapP90Ms,
-        domGapP90Ms,
-        sseTextGapP90Ms,
-        domLagOverScheduleP90Ms: domGapP90Ms === undefined ? undefined : round3(domGapP90Ms - fixtureScheduleGapP90Ms),
-        sseTextLagOverScheduleP90Ms: sseTextGapP90Ms === undefined ? undefined : round3(sseTextGapP90Ms - fixtureScheduleGapP90Ms),
-        domToScheduleP90Ratio: domGapP90Ms === undefined || fixtureScheduleGapP90Ms <= 0 ? undefined : round3(domGapP90Ms / fixtureScheduleGapP90Ms),
-        sseTextToScheduleP90Ratio: sseTextGapP90Ms === undefined || fixtureScheduleGapP90Ms <= 0 ? undefined : round3(sseTextGapP90Ms / fixtureScheduleGapP90Ms),
-    };
-}
-export function summarizeStreamingProviderPreservation(benchmark) {
-    const provider = benchmark.provider;
-    if (!provider?.available)
-        return undefined;
-    const selectedLive = summarizeStreamingSelectedLiveEventSource(benchmark);
-    return {
-        providerTextDeltaCount: provider.textDeltaCount,
-        providerReasoningDeltaCount: provider.reasoningDeltaCount,
-        sseTextEventCount: benchmark.sse?.textEventCount,
-        sseReasoningEventCount: benchmark.sse?.reasoningEventCount,
-        selectedLiveTextEventCountAfterStart: selectedLive?.textEventCountAfterStart,
-        selectedLiveReasoningEventCountAfterStart: selectedLive?.reasoningEventCountAfterStart,
-        domPositiveUpdateCount: benchmark.dom?.positiveUpdateCount,
-        sseTextToProviderRatio: ratioToProvider(benchmark.sse?.textEventCount, provider.textDeltaCount),
-        sseReasoningToProviderRatio: ratioToProvider(benchmark.sse?.reasoningEventCount, provider.reasoningDeltaCount),
-        selectedLiveTextToProviderRatio: ratioToProvider(selectedLive?.textEventCountAfterStart, provider.textDeltaCount),
-        selectedLiveReasoningToProviderRatio: ratioToProvider(selectedLive?.reasoningEventCountAfterStart, provider.reasoningDeltaCount),
-        domPositiveToProviderTextRatio: ratioToProvider(benchmark.dom?.positiveUpdateCount, provider.textDeltaCount),
-    };
-}
-export function summarizeStreamingLivePipeline(benchmark) {
-    const debugDelta = benchmark.debug?.delta ?? {};
-    const debugStateBeforeReset = benchmark.debug?.stateBeforeReset ?? {};
-    const debugAfter = benchmark.debug?.after ?? {};
-    const fixtureTextCount = finiteNumber(benchmark.fixture?.deltaCount);
-    const fixtureReasoningCount = finiteNumber(benchmark.fixture?.reasoningDeltaCount);
-    const provider = benchmark.provider?.available ? benchmark.provider : undefined;
-    const debugTextCount = finiteNumber(debugDelta.textDeltaCount);
-    const debugReasoningCount = finiteNumber(debugDelta.reasoningDeltaCount);
-    const expectedSource = fixtureTextCount !== undefined || fixtureReasoningCount !== undefined ? "fixture" : provider ? "provider" : "debug";
-    const expectedTextDeltaCount = expectedSource === "fixture" ? (fixtureTextCount ?? 0) : expectedSource === "provider" ? provider?.textDeltaCount ?? 0 : debugTextCount ?? 0;
-    const expectedReasoningDeltaCount = expectedSource === "fixture" ? (fixtureReasoningCount ?? 0) : expectedSource === "provider" ? provider?.reasoningDeltaCount ?? 0 : debugReasoningCount ?? 0;
-    const expectedInputEventCount = expectedTextDeltaCount + expectedReasoningDeltaCount;
-    if (expectedInputEventCount <= 0)
-        return undefined;
-    const expectedPipelineEventCount = expectedStreamingPipelineEventCount(benchmark, expectedInputEventCount);
-    const enqueueCount = finiteNumber(debugDelta.enqueueCount);
-    const flushCount = finiteNumber(debugDelta.flushCount);
-    const flushedEventCount = finiteNumber(debugDelta.flushedEventCount);
-    const overlayUpdateCount = finiteNumber(debugDelta.overlayUpdateCount);
-    const overlayEventCount = stateWindowNumber(debugAfter.overlayEventCount, debugStateBeforeReset.overlayEventCount);
-    const currentOutputLength = stateWindowNumber(debugAfter.currentOutputLength, debugStateBeforeReset.currentOutputLength);
-    const expectedTextBytes = finiteNumber(benchmark.fixture?.textBytes);
-    const debugStartedAt = typeof debugAfter.startedAt === "string" ? debugAfter.startedAt : undefined;
-    return {
-        expectedSource,
-        expectedTextDeltaCount,
-        expectedReasoningDeltaCount,
-        expectedInputEventCount,
-        expectedPipelineEventCount,
-        enqueueCount,
-        flushCount,
-        flushedEventCount,
-        overlayUpdateCount,
-        overlayEventCount,
-        currentOutputLength,
-        expectedTextBytes,
-        enqueueToExpectedRatio: ratioToProvider(enqueueCount, expectedPipelineEventCount),
-        flushedEventsToExpectedRatio: ratioToProvider(flushedEventCount, expectedPipelineEventCount),
-        overlayEventsToExpectedRatio: ratioToProvider(overlayEventCount, expectedInputEventCount),
-        currentOutputToExpectedTextBytesRatio: ratioToProvider(currentOutputLength, expectedTextBytes),
-        flushToEnqueueRatio: ratioToProvider(flushCount, enqueueCount),
-        overlayUpdatesToFlushedEventsRatio: ratioToProvider(overlayUpdateCount, flushedEventCount),
-        firstEventMs: elapsedIsoMs(debugStartedAt, debugAfter.firstEventAt),
-        firstTextDeltaMs: elapsedIsoMs(debugStartedAt, debugAfter.firstTextDeltaAt),
-        firstReasoningDeltaMs: elapsedIsoMs(debugStartedAt, debugAfter.firstReasoningDeltaAt),
-        firstEnqueueMs: elapsedIsoMs(debugStartedAt, debugAfter.firstEnqueueAt),
-        firstFlushMs: elapsedIsoMs(debugStartedAt, debugAfter.firstFlushAt),
-        firstOverlayUpdateMs: elapsedIsoMs(debugStartedAt, debugAfter.firstOverlayUpdateAt),
-    };
-}
-export function attachStreamingProviderTelemetryToBenchmark(benchmark, providerTelemetry) {
-    if (!providerTelemetry)
-        return benchmark;
-    const baseRegressions = benchmark.regressions.filter((regression) => !regression.startsWith("provider ") && !regression.startsWith("live pipeline "));
-    const withProvider = { ...benchmark, provider: providerTelemetry };
-    const providerPreservation = summarizeStreamingProviderPreservation(withProvider);
-    const withProviderMetrics = { ...withProvider, providerPreservation, livePipeline: summarizeStreamingLivePipeline(withProvider) };
-    return {
-        ...withProviderMetrics,
-        regressions: [...baseRegressions, ...evaluateStreamingLivePipelineRegressions(withProviderMetrics), ...evaluateStreamingProviderRegressions(withProviderMetrics)],
-    };
-}
-export function attachStreamingProviderTelemetryToBenchmarks(benchmarks, providerTelemetry) {
-    return providerTelemetry ? benchmarks.map((benchmark) => attachStreamingProviderTelemetryToBenchmark(benchmark, providerTelemetry)) : benchmarks;
-}
-function expectedStreamingPipelineEventCount(_benchmark, fallbackInputEventCount) {
-    return fallbackInputEventCount;
-}
-export function evaluateStreamingLivePipelineRegressions(benchmark) {
-    const pipeline = benchmark.livePipeline;
-    if (!pipeline || pipeline.expectedSource === "debug" || pipeline.expectedInputEventCount <= 0 || benchmark.fixture?.simulation === "trace-catchup")
-        return [];
-    const hasLiveCounters = [pipeline.enqueueCount, pipeline.flushCount, pipeline.flushedEventCount, pipeline.overlayUpdateCount, pipeline.overlayEventCount].some((value) => value !== undefined);
-    if (!hasLiveCounters)
-        return [];
-    const regressions = [];
-    pushMinimumRatioRegression(regressions, pipeline.flushedEventsToExpectedRatio, LIVE_PIPELINE_MIN_PRESERVATION_RATIO, "live pipeline flushed events/overlay expected ratio");
-    pushMinimumRatioRegression(regressions, pipeline.overlayEventsToExpectedRatio, LIVE_PIPELINE_MIN_PRESERVATION_RATIO, "live pipeline overlay events/input expected ratio");
-    if (pipeline.expectedTextDeltaCount > 0 && pipeline.expectedTextBytes !== undefined) {
-        pushMinimumRatioRegression(regressions, pipeline.currentOutputToExpectedTextBytesRatio, LIVE_PIPELINE_MIN_PRESERVATION_RATIO, "live pipeline current text/expected bytes ratio");
-    }
-    pushMinimumRatioRegression(regressions, pipeline.flushToEnqueueRatio, LIVE_PIPELINE_MIN_FLUSH_RATIO, "live pipeline flush/enqueue ratio");
-    pushMinimumRatioRegression(regressions, pipeline.overlayUpdatesToFlushedEventsRatio, LIVE_PIPELINE_MIN_FLUSH_RATIO, "live pipeline overlay updates/flushed ratio");
-    return regressions;
-}
-export function evaluateStreamingProviderRegressions(benchmark) {
-    const provider = benchmark.provider;
-    if (!provider?.available)
-        return [];
-    const regressions = [];
-    if ((provider.parseErrorCount ?? 0) > 0)
-        regressions.push(`provider parse errors ${provider.parseErrorCount} > 0`);
-    if ((provider.unknownEventCount ?? 0) > 0)
-        regressions.push(`provider unknown events ${provider.unknownEventCount} > 0`);
-    if (provider.truncated)
-        regressions.push("provider telemetry events were truncated");
-    const preservation = benchmark.providerPreservation;
-    if (provider.textDeltaCount > 0) {
-        if (benchmark.sse?.requested)
-            pushProviderRatioRegression(regressions, preservation?.sseTextToProviderRatio, PROVIDER_MIN_TEXT_PRESERVATION_RATIO, "provider SSE text preservation ratio");
-        if (benchmark.eventSource?.requested)
-            pushProviderRatioRegression(regressions, preservation?.selectedLiveTextToProviderRatio, PROVIDER_MIN_TEXT_PRESERVATION_RATIO, "provider selected-live text preservation ratio");
-    }
-    if (provider.reasoningDeltaCount > 0) {
-        if (benchmark.sse?.requested)
-            pushProviderRatioRegression(regressions, preservation?.sseReasoningToProviderRatio, PROVIDER_MIN_REASONING_PRESERVATION_RATIO, "provider SSE reasoning preservation ratio");
-        if (benchmark.eventSource?.requested)
-            pushProviderRatioRegression(regressions, preservation?.selectedLiveReasoningToProviderRatio, PROVIDER_MIN_REASONING_PRESERVATION_RATIO, "provider selected-live reasoning preservation ratio");
-    }
-    return regressions;
-}
-function pushProviderRatioRegression(regressions, ratio, minimum, label) {
-    pushMinimumRatioRegression(regressions, ratio, minimum, label);
-}
-function pushMinimumRatioRegression(regressions, ratio, minimum, label) {
-    if (ratio === undefined)
-        regressions.push(`${label} unavailable`);
-    else if (ratio < minimum)
-        regressions.push(`${label} ${ratio} < ${minimum}`);
-}
-function ratioToProvider(numerator, denominator) {
-    if (numerator === undefined || denominator === undefined || denominator <= 0)
-        return undefined;
-    return round3(numerator / denominator);
-}
-function commonStreamingNegativeProfile(runs) {
-    const profile = runs[0]?.negativeProfile;
-    return profile && runs.every((run) => run.negativeProfile === profile) ? profile : undefined;
-}
-export function summarizeStreamingBenchmarkGroup(runs, baselineRuns) {
-    const summary = summarizeStreamingBenchmarks(runs);
-    return {
-        kind: "streaming-benchmark-runs",
-        createdAt: new Date().toISOString(),
-        durationMs: runs[0]?.durationMs ?? 0,
-        runs,
-        negativeProfile: commonStreamingNegativeProfile(runs),
-        summary,
-        comparison: baselineRuns?.length ? compareStreamingBenchmarkSummaries(summarizeStreamingBenchmarks(baselineRuns), summary) : undefined,
-        regressions: runs.flatMap((run, index) => run.regressions.map((regression) => `run ${index + 1}: ${regression}`)),
-        warnings: runs.flatMap((run, index) => run.warnings.map((warning) => `run ${index + 1}: ${warning}`)),
-    };
-}
-export function summarizeStreamingBenchmarkUrlComparison(primaryUrl, compareUrl, primary, compare) {
-    const summaryComparison = compareStreamingBenchmarkSummaries(primary.summary, compare.summary);
-    const negativeProfile = primary.negativeProfile && primary.negativeProfile === compare.negativeProfile ? primary.negativeProfile : undefined;
-    return {
-        kind: "streaming-benchmark-url-comparison",
-        createdAt: new Date().toISOString(),
-        durationMs: primary.durationMs,
-        primaryUrl,
-        compareUrl,
-        primary,
-        compare,
-        negativeProfile,
-        comparison: summaryComparison,
-        regressions: [
-            ...primary.regressions.map((regression) => `primary: ${regression}`),
-            ...compare.regressions.map((regression) => `compare: ${regression}`),
-            ...evaluateStreamingBenchmarkUrlComparisonRegressions(summaryComparison).map((regression) => `comparison: ${regression}`),
-        ],
-        warnings: [
-            ...primary.warnings.map((warning) => `primary: ${warning}`),
-            ...compare.warnings.map((warning) => `compare: ${warning}`),
-        ],
-    };
-}
-export function evaluateStreamingBenchmarkUrlComparisonRegressions(comparison) {
-    const regressions = [];
-    if (comparison.smoothnessDelta !== undefined && comparison.smoothnessDelta < -URL_COMPARISON_MAX_SMOOTHNESS_DROP) {
-        regressions.push(`compare smoothness delta ${comparison.smoothnessDelta} below -${URL_COMPARISON_MAX_SMOOTHNESS_DROP}`);
-    }
-    if (comparison.domLagOverFixtureScheduleP90DeltaMs !== undefined && comparison.domLagOverFixtureScheduleP90DeltaMs > URL_COMPARISON_MAX_DOM_LAG_DELTA_MS) {
-        regressions.push(`compare DOM lag over schedule delta ${comparison.domLagOverFixtureScheduleP90DeltaMs}ms exceeds ${URL_COMPARISON_MAX_DOM_LAG_DELTA_MS}ms`);
-    }
-    if (comparison.sseTextLagOverFixtureScheduleP90DeltaMs !== undefined && comparison.sseTextLagOverFixtureScheduleP90DeltaMs > URL_COMPARISON_MAX_SSE_LAG_DELTA_MS) {
-        regressions.push(`compare SSE text lag over schedule delta ${comparison.sseTextLagOverFixtureScheduleP90DeltaMs}ms exceeds ${URL_COMPARISON_MAX_SSE_LAG_DELTA_MS}ms`);
-    }
-    if (comparison.sseChunkGapP90DeltaMs !== undefined && comparison.sseChunkGapP90DeltaMs > URL_COMPARISON_MAX_SSE_CHUNK_GAP_DELTA_MS) {
-        regressions.push(`compare SSE chunk p90 gap delta ${comparison.sseChunkGapP90DeltaMs}ms exceeds ${URL_COMPARISON_MAX_SSE_CHUNK_GAP_DELTA_MS}ms`);
-    }
-    if (comparison.selectedLiveFirstTextEventDeltaMs !== undefined && comparison.selectedLiveFirstTextEventDeltaMs > URL_COMPARISON_MAX_FIRST_TRANSPORT_LATENCY_DELTA_MS) {
-        regressions.push(`compare selected-live first text latency delta ${comparison.selectedLiveFirstTextEventDeltaMs}ms exceeds ${URL_COMPARISON_MAX_FIRST_TRANSPORT_LATENCY_DELTA_MS}ms`);
-    }
-    if (comparison.sseFirstTextEventDeltaMs !== undefined && comparison.sseFirstTextEventDeltaMs > URL_COMPARISON_MAX_FIRST_TRANSPORT_LATENCY_DELTA_MS) {
-        regressions.push(`compare SSE first text latency delta ${comparison.sseFirstTextEventDeltaMs}ms exceeds ${URL_COMPARISON_MAX_FIRST_TRANSPORT_LATENCY_DELTA_MS}ms`);
-    }
-    if (comparison.liveFirstTextDeltaDeltaMs !== undefined && comparison.liveFirstTextDeltaDeltaMs > URL_COMPARISON_MAX_FIRST_LIVE_LATENCY_DELTA_MS) {
-        regressions.push(`compare live first text latency delta ${comparison.liveFirstTextDeltaDeltaMs}ms exceeds ${URL_COMPARISON_MAX_FIRST_LIVE_LATENCY_DELTA_MS}ms`);
-    }
-    if (comparison.liveFirstEnqueueDeltaMs !== undefined && comparison.liveFirstEnqueueDeltaMs > URL_COMPARISON_MAX_FIRST_LIVE_LATENCY_DELTA_MS) {
-        regressions.push(`compare live first enqueue latency delta ${comparison.liveFirstEnqueueDeltaMs}ms exceeds ${URL_COMPARISON_MAX_FIRST_LIVE_LATENCY_DELTA_MS}ms`);
-    }
-    if (comparison.liveFirstFlushDeltaMs !== undefined && comparison.liveFirstFlushDeltaMs > URL_COMPARISON_MAX_FIRST_LIVE_LATENCY_DELTA_MS) {
-        regressions.push(`compare live first flush latency delta ${comparison.liveFirstFlushDeltaMs}ms exceeds ${URL_COMPARISON_MAX_FIRST_LIVE_LATENCY_DELTA_MS}ms`);
-    }
-    if (comparison.liveFirstOverlayUpdateDeltaMs !== undefined && comparison.liveFirstOverlayUpdateDeltaMs > URL_COMPARISON_MAX_FIRST_LIVE_LATENCY_DELTA_MS) {
-        regressions.push(`compare live first overlay latency delta ${comparison.liveFirstOverlayUpdateDeltaMs}ms exceeds ${URL_COMPARISON_MAX_FIRST_LIVE_LATENCY_DELTA_MS}ms`);
-    }
-    if (comparison.firstVisibleDeltaMs !== undefined && comparison.firstVisibleDeltaMs > URL_COMPARISON_MAX_FIRST_VISIBLE_LATENCY_DELTA_MS) {
-        regressions.push(`compare DOM first visible latency delta ${comparison.firstVisibleDeltaMs}ms exceeds ${URL_COMPARISON_MAX_FIRST_VISIBLE_LATENCY_DELTA_MS}ms`);
-    }
-    if (comparison.sseTextEventDelta !== undefined && comparison.sseTextEventDelta < 0)
-        regressions.push(`compare SSE text events delta ${comparison.sseTextEventDelta} below 0`);
-    if (comparison.selectedLiveTextEventDelta !== undefined && comparison.selectedLiveTextEventDelta < 0)
-        regressions.push(`compare selected-live text events delta ${comparison.selectedLiveTextEventDelta} below 0`);
-    if (comparison.selectedLiveReasoningEventDelta !== undefined && comparison.selectedLiveReasoningEventDelta < 0)
-        regressions.push(`compare selected-live reasoning events delta ${comparison.selectedLiveReasoningEventDelta} below 0`);
-    return regressions;
-}
-export function applyExpectedStreamingRegressions(benchmark, expectedPatterns) {
-    const assertion = evaluateStreamingBenchmarkAssertion(benchmark.regressions, expectedPatterns);
-    if (expectedPatterns.length > 0)
-        benchmark.assertion = assertion;
-    return assertion;
-}
-export function evaluateStreamingBenchmarkAssertion(regressions, expectedPatterns) {
-    const expectedRegressionPatterns = expectedPatterns.filter((pattern) => pattern.length > 0);
-    const expectedRegressions = [];
-    const unexpectedRegressions = [];
-    const matchedPatterns = new Set();
-    for (const regression of regressions) {
-        const matches = expectedRegressionPatterns.filter((pattern) => regression.includes(pattern));
-        if (matches.length > 0) {
-            expectedRegressions.push(regression);
-            for (const pattern of matches)
-                matchedPatterns.add(pattern);
-        }
-        else {
-            unexpectedRegressions.push(regression);
-        }
-    }
-    const missingExpectedRegressionPatterns = expectedRegressionPatterns.filter((pattern) => !matchedPatterns.has(pattern));
-    return {
-        expectedRegressionPatterns,
-        expectedRegressions,
-        unexpectedRegressions,
-        missingExpectedRegressionPatterns,
-        passed: unexpectedRegressions.length === 0 && missingExpectedRegressionPatterns.length === 0,
-    };
-}
-export function summarizeStreamingBenchmarks(runs) {
-    return {
-        runs: runs.length,
-        smoothness: numericStats(runs.map((run) => run.score.smoothness)),
-        textDeltaCount: numericStats(runs.map((run) => run.score.textDeltaCount)),
-        reasoningDeltaCount: numericStats(runs.map((run) => numberField(run.debug.delta ?? {}, "reasoningDeltaCount"))),
-        domPositiveUpdateCount: numericStats(runs.map((run) => run.score.domPositiveUpdateCount)),
-        domGapP50Ms: numericStats(runs.map((run) => run.dom.gapsMs.p50)),
-        domGapP90Ms: numericStats(runs.map((run) => run.dom.gapsMs.p90)),
-        domGapMaxMs: numericStats(runs.map((run) => run.dom.gapsMs.max)),
-        domJumpP90Chars: numericStats(runs.map((run) => run.dom.positiveCharJumps.p90)),
-        domJumpMaxChars: numericStats(runs.map((run) => run.dom.positiveCharJumps.max)),
-        firstVisibleMs: numericStats(runs.map((run) => run.dom.firstPositiveUpdateMs)),
-        longTaskMaxMs: numericStats(runs.map((run) => run.longTasks.maxMs)),
-        regressionCount: numericStats(runs.map((run) => run.regressions.length)),
-        debugEnqueueCount: numericStats(runs.map((run) => streamingDebugDeltaNumber(run, "enqueueCount"))),
-        debugFlushCount: numericStats(runs.map((run) => streamingDebugDeltaNumber(run, "flushCount"))),
-        debugFlushedEventCount: numericStats(runs.map((run) => streamingDebugDeltaNumber(run, "flushedEventCount"))),
-        debugOverlayUpdateCount: numericStats(runs.map((run) => streamingDebugDeltaNumber(run, "overlayUpdateCount"))),
-        debugOverlayEventCount: numericStats(runs.map((run) => streamingDebugStateWindowNumber(run, "overlayEventCount"))),
-        debugLiveTraceComputeCount: numericStats(runs.map((run) => streamingDebugDeltaNumber(run, "liveTraceComputeCount"))),
-        debugLiveTraceComputeDurationTotalMs: numericStats(runs.map((run) => streamingDebugDeltaNumber(run, "liveTraceComputeDurationMsTotal"))),
-        debugLiveTraceComputeDurationMaxMs: numericStats(runs.map((run) => streamingDebugAfterNumber(run, "liveTraceComputeDurationMsMax"))),
-        debugMarkdownRenderCount: numericStats(runs.map((run) => streamingDebugDeltaNumber(run, "markdownRenderCount"))),
-        debugMarkdownRenderPlainCount: numericStats(runs.map((run) => streamingDebugDeltaNumber(run, "markdownRenderPlainCount"))),
-        debugMarkdownRenderFullCount: numericStats(runs.map((run) => streamingDebugDeltaNumber(run, "markdownRenderFullCount"))),
-        debugMarkdownRenderCommonMarkCount: numericStats(runs.map((run) => streamingDebugDeltaNumber(run, "markdownRenderCommonMarkCount"))),
-        debugMarkdownRenderGfmCount: numericStats(runs.map((run) => streamingDebugDeltaNumber(run, "markdownRenderGfmCount"))),
-        debugMarkdownRenderGfmFastCount: numericStats(runs.map((run) => streamingDebugDeltaNumber(run, "markdownRenderGfmFastCount"))),
-        debugMarkdownRenderDurationTotalMs: numericStats(runs.map((run) => streamingDebugDeltaNumber(run, "markdownRenderDurationMsTotal"))),
-        debugMarkdownRenderDurationMaxMs: numericStats(runs.map((run) => streamingDebugAfterNumber(run, "markdownRenderDurationMsMax"))),
-        debugMarkdownRenderPlainDurationMaxMs: numericStats(runs.map((run) => streamingDebugAfterNumber(run, "markdownRenderPlainDurationMsMax"))),
-        debugMarkdownRenderFullDurationMaxMs: numericStats(runs.map((run) => streamingDebugAfterNumber(run, "markdownRenderFullDurationMsMax"))),
-        debugMarkdownRenderCommonMarkDurationMaxMs: numericStats(runs.map((run) => streamingDebugAfterNumber(run, "markdownRenderCommonMarkDurationMsMax"))),
-        debugMarkdownRenderGfmDurationMaxMs: numericStats(runs.map((run) => streamingDebugAfterNumber(run, "markdownRenderGfmDurationMsMax"))),
-        debugMarkdownRenderGfmFastDurationMaxMs: numericStats(runs.map((run) => streamingDebugAfterNumber(run, "markdownRenderGfmFastDurationMsMax"))),
-        debugTraceRefreshScheduledCount: numericStats(runs.map((run) => streamingDebugDeltaNumber(run, "traceRefreshScheduledCount"))),
-        debugTraceRefreshCompletedCount: numericStats(runs.map((run) => streamingDebugDeltaNumber(run, "traceRefreshCompletedCount"))),
-        debugTraceRefreshFailedCount: numericStats(runs.map((run) => streamingDebugDeltaNumber(run, "traceRefreshFailedCount"))),
-        debugTraceRefreshDurationMaxMs: numericStats(runs.map((run) => streamingDebugAfterNumber(run, "traceRefreshDurationMsMax"))),
-        debugCurrentOutputLength: numericStats(runs.map((run) => streamingDebugStateWindowNumber(run, "currentOutputLength"))),
-        debugTraceBaseOutputLength: numericStats(runs.map((run) => streamingDebugAfterNumber(run, "traceBaseOutputLength"))),
-        liveExpectedInputEventCount: numericStats(runs.map((run) => streamingLivePipeline(run)?.expectedInputEventCount)),
-        liveExpectedPipelineEventCount: numericStats(runs.map((run) => streamingLivePipeline(run)?.expectedPipelineEventCount)),
-        liveEnqueueToExpectedRatio: numericStats(runs.map((run) => streamingLivePipeline(run)?.enqueueToExpectedRatio)),
-        liveFlushedEventsToExpectedRatio: numericStats(runs.map((run) => streamingLivePipeline(run)?.flushedEventsToExpectedRatio)),
-        liveOverlayEventsToExpectedRatio: numericStats(runs.map((run) => streamingLivePipeline(run)?.overlayEventsToExpectedRatio)),
-        liveCurrentOutputToExpectedTextBytesRatio: numericStats(runs.map((run) => streamingLivePipeline(run)?.currentOutputToExpectedTextBytesRatio)),
-        liveFlushToEnqueueRatio: numericStats(runs.map((run) => streamingLivePipeline(run)?.flushToEnqueueRatio)),
-        liveOverlayUpdatesToFlushedEventsRatio: numericStats(runs.map((run) => streamingLivePipeline(run)?.overlayUpdatesToFlushedEventsRatio)),
-        liveFirstEventMs: numericStats(runs.map((run) => streamingLivePipeline(run)?.firstEventMs)),
-        liveFirstTextDeltaMs: numericStats(runs.map((run) => streamingLivePipeline(run)?.firstTextDeltaMs)),
-        liveFirstReasoningDeltaMs: numericStats(runs.map((run) => streamingLivePipeline(run)?.firstReasoningDeltaMs)),
-        liveFirstEnqueueMs: numericStats(runs.map((run) => streamingLivePipeline(run)?.firstEnqueueMs)),
-        liveFirstFlushMs: numericStats(runs.map((run) => streamingLivePipeline(run)?.firstFlushMs)),
-        liveFirstOverlayUpdateMs: numericStats(runs.map((run) => streamingLivePipeline(run)?.firstOverlayUpdateMs)),
-        traceSampleCount: numericStats(runs.map((run) => run.trace?.sampleCount)),
-        traceLiveVersionCount: numericStats(runs.map((run) => run.trace?.liveVersionCount)),
-        traceFirstLiveVersionMs: numericStats(runs.map((run) => run.trace?.firstLiveVersionMs)),
-        traceMaxAssistantOutputLength: numericStats(runs.map((run) => run.trace?.maxAssistantOutputLength)),
-        traceFinalAssistantOutputLength: numericStats(runs.map((run) => run.trace?.finalAssistantOutputLength)),
-        traceDurableEventDelta: numericStats(runs.map((run) => traceDurableEventDelta(run.trace))),
-        fixtureScheduleGapP90Ms: numericStats(runs.map((run) => run.fixture?.scheduleGapsMs?.p90)),
-        domLagOverFixtureScheduleP90Ms: numericStats(runs.map((run) => run.cadence?.domLagOverScheduleP90Ms)),
-        sseTextLagOverFixtureScheduleP90Ms: numericStats(runs.map((run) => run.cadence?.sseTextLagOverScheduleP90Ms)),
-        domToFixtureScheduleP90Ratio: numericStats(runs.map((run) => run.cadence?.domToScheduleP90Ratio)),
-        sseTextToFixtureScheduleP90Ratio: numericStats(runs.map((run) => run.cadence?.sseTextToScheduleP90Ratio)),
-        eventSourceTextEventCountAfterStart: numericStats(runs.map((run) => run.eventSource?.textEventCountAfterStart)),
-        eventSourceReasoningEventCountAfterStart: numericStats(runs.map((run) => run.eventSource?.reasoningEventCountAfterStart)),
-        eventSourceForcedCloseCountAfterStart: numericStats(runs.map((run) => run.eventSource?.forcedCloseCountAfterStart)),
-        eventSourceReconnectOpenCountAfterStart: numericStats(runs.map((run) => run.eventSource?.openCountAfterStart)),
-        eventSourceTransientIdCountAfterStart: numericStats(runs.map((run) => run.eventSource?.transientIdCountAfterStart)),
-        sseTextEventCount: numericStats(runs.map((run) => run.sse?.textEventCount)),
-        sseReasoningEventCount: numericStats(runs.map((run) => run.sse?.reasoningEventCount)),
-        sseChunkBytesP50: numericStats(runs.map((run) => run.sse?.chunkBytes.p50)),
-        sseChunkGapP90Ms: numericStats(runs.map((run) => run.sse?.chunkGapsMs.p90)),
-        sseTextEventsPerChunkP90: numericStats(runs.map((run) => run.sse?.textEventsPerChunk.p90)),
-        sseTextEventGapP90Ms: numericStats(runs.map((run) => run.sse?.textEventGapsMs.p90)),
-        sseFirstTextEventMs: numericStats(runs.map((run) => run.sse?.firstTextEventMs)),
-        selectedLiveTextEventCountAfterStart: numericStats(runs.map((run) => selectedLiveStream(run)?.textEventCountAfterStart)),
-        selectedLiveReasoningEventCountAfterStart: numericStats(runs.map((run) => selectedLiveStream(run)?.reasoningEventCountAfterStart)),
-        selectedLiveEventCountAfterStart: numericStats(runs.map((run) => selectedLiveStream(run)?.eventCountAfterStart)),
-        selectedLiveForcedCloseCountAfterStart: numericStats(runs.map((run) => selectedLiveStream(run)?.forcedCloseCountAfterStart)),
-        selectedLiveReconnectOpenCountAfterStart: numericStats(runs.map((run) => selectedLiveStream(run)?.openCountAfterStart)),
-        selectedLiveTransientIdCountAfterStart: numericStats(runs.map((run) => selectedLiveStream(run)?.transientIdCountAfterStart)),
-        selectedLiveLiveSinceCount: numericStats(runs.map((run) => selectedLiveStream(run)?.liveSinceValues?.length)),
-        selectedLiveReplayEventCountAfterStart: numericStats(runs.map((run) => selectedLiveStream(run)?.liveReplayEventCountAfterStart)),
-        selectedLiveReplayCursorLagMaxAfterStart: numericStats(runs.map((run) => selectedLiveStream(run)?.liveReplayCursorLagMaxAfterStart)),
-        selectedLiveReplayDuplicateCountAfterStart: numericStats(runs.map((run) => selectedLiveStream(run)?.liveReplayDuplicateCountAfterStart)),
-        selectedLiveReplayMissedCountAfterStart: numericStats(runs.map((run) => selectedLiveStream(run)?.liveReplayMissedCountAfterStart)),
-        selectedLiveFirstTextEventMsAfterStart: numericStats(runs.map((run) => selectedLiveStream(run)?.firstTextEventMsAfterStart)),
-        roomSummaryEventCountAfterStart: numericStats(runs.map((run) => roomSummaryStream(run)?.eventCountAfterStart)),
-        roomSummaryTextEventCountAfterStart: numericStats(runs.map((run) => roomSummaryStream(run)?.textEventCountAfterStart)),
-        roomSummaryReasoningEventCountAfterStart: numericStats(runs.map((run) => roomSummaryStream(run)?.reasoningEventCountAfterStart)),
-        providerTextDeltaCount: numericStats(runs.map((run) => run.provider?.textDeltaCount)),
-        providerReasoningDeltaCount: numericStats(runs.map((run) => run.provider?.reasoningDeltaCount)),
-        providerTextDeltaBytesP50: numericStats(runs.map((run) => run.provider?.textDeltaBytes.p50)),
-        providerTextDeltaGapP90Ms: numericStats(runs.map((run) => run.provider?.textDeltaGapsMs.p90)),
-        providerFirstTextLatencyMs: numericStats(runs.map((run) => run.provider?.firstTextLatencyMs)),
-        providerParseErrorCount: numericStats(runs.map((run) => run.provider?.parseErrorCount)),
-        providerUnknownEventCount: numericStats(runs.map((run) => run.provider?.unknownEventCount)),
-        providerSseTextRatio: numericStats(runs.map((run) => run.providerPreservation?.sseTextToProviderRatio)),
-        providerSseReasoningRatio: numericStats(runs.map((run) => run.providerPreservation?.sseReasoningToProviderRatio)),
-        providerSelectedLiveTextRatio: numericStats(runs.map((run) => run.providerPreservation?.selectedLiveTextToProviderRatio)),
-        providerSelectedLiveReasoningRatio: numericStats(runs.map((run) => run.providerPreservation?.selectedLiveReasoningToProviderRatio)),
-        providerDomPositiveTextRatio: numericStats(runs.map((run) => run.providerPreservation?.domPositiveToProviderTextRatio)),
-    };
-}
-function compareStreamingBenchmarkSummaries(baseline, current) {
-    return {
-        baselineRuns: baseline.runs,
-        currentRuns: current.runs,
-        smoothnessDelta: statDelta(current.smoothness, baseline.smoothness),
-        domGapP90DeltaMs: statDelta(current.domGapP90Ms, baseline.domGapP90Ms),
-        domPositiveUpdateDelta: statDelta(current.domPositiveUpdateCount, baseline.domPositiveUpdateCount),
-        domJumpMaxDeltaChars: statDelta(current.domJumpMaxChars, baseline.domJumpMaxChars),
-        longTaskMaxDeltaMs: statDelta(current.longTaskMaxMs, baseline.longTaskMaxMs),
-        firstVisibleDeltaMs: statDelta(current.firstVisibleMs, baseline.firstVisibleMs),
-        liveFirstTextDeltaDeltaMs: statDelta(current.liveFirstTextDeltaMs, baseline.liveFirstTextDeltaMs),
-        liveFirstEnqueueDeltaMs: statDelta(current.liveFirstEnqueueMs, baseline.liveFirstEnqueueMs),
-        liveFirstFlushDeltaMs: statDelta(current.liveFirstFlushMs, baseline.liveFirstFlushMs),
-        liveFirstOverlayUpdateDeltaMs: statDelta(current.liveFirstOverlayUpdateMs, baseline.liveFirstOverlayUpdateMs),
-        sseFirstTextEventDeltaMs: statDelta(current.sseFirstTextEventMs, baseline.sseFirstTextEventMs),
-        selectedLiveFirstTextEventDeltaMs: statDelta(current.selectedLiveFirstTextEventMsAfterStart, baseline.selectedLiveFirstTextEventMsAfterStart),
-        providerFirstTextLatencyDeltaMs: statDelta(current.providerFirstTextLatencyMs, baseline.providerFirstTextLatencyMs),
-        debugEnqueueCountDelta: statDelta(current.debugEnqueueCount, baseline.debugEnqueueCount),
-        debugFlushCountDelta: statDelta(current.debugFlushCount, baseline.debugFlushCount),
-        debugOverlayUpdateCountDelta: statDelta(current.debugOverlayUpdateCount, baseline.debugOverlayUpdateCount),
-        debugTraceRefreshCompletedCountDelta: statDelta(current.debugTraceRefreshCompletedCount, baseline.debugTraceRefreshCompletedCount),
-        liveEnqueueToExpectedRatioDelta: statDelta(current.liveEnqueueToExpectedRatio, baseline.liveEnqueueToExpectedRatio),
-        liveFlushedEventsToExpectedRatioDelta: statDelta(current.liveFlushedEventsToExpectedRatio, baseline.liveFlushedEventsToExpectedRatio),
-        liveOverlayEventsToExpectedRatioDelta: statDelta(current.liveOverlayEventsToExpectedRatio, baseline.liveOverlayEventsToExpectedRatio),
-        liveFlushToEnqueueRatioDelta: statDelta(current.liveFlushToEnqueueRatio, baseline.liveFlushToEnqueueRatio),
-        liveOverlayUpdatesToFlushedEventsRatioDelta: statDelta(current.liveOverlayUpdatesToFlushedEventsRatio, baseline.liveOverlayUpdatesToFlushedEventsRatio),
-        traceLiveVersionCountDelta: statDelta(current.traceLiveVersionCount, baseline.traceLiveVersionCount),
-        traceMaxAssistantOutputDelta: statDelta(current.traceMaxAssistantOutputLength, baseline.traceMaxAssistantOutputLength),
-        traceDurableEventDeltaDelta: statDelta(current.traceDurableEventDelta, baseline.traceDurableEventDelta),
-        fixtureScheduleGapP90DeltaMs: statDelta(current.fixtureScheduleGapP90Ms, baseline.fixtureScheduleGapP90Ms),
-        domLagOverFixtureScheduleP90DeltaMs: statDelta(current.domLagOverFixtureScheduleP90Ms, baseline.domLagOverFixtureScheduleP90Ms),
-        sseTextLagOverFixtureScheduleP90DeltaMs: statDelta(current.sseTextLagOverFixtureScheduleP90Ms, baseline.sseTextLagOverFixtureScheduleP90Ms),
-        eventSourceTextEventDelta: statDelta(current.eventSourceTextEventCountAfterStart, baseline.eventSourceTextEventCountAfterStart),
-        eventSourceReasoningEventDelta: statDelta(current.eventSourceReasoningEventCountAfterStart, baseline.eventSourceReasoningEventCountAfterStart),
-        sseTextEventDelta: statDelta(current.sseTextEventCount, baseline.sseTextEventCount),
-        sseChunkGapP90DeltaMs: statDelta(current.sseChunkGapP90Ms, baseline.sseChunkGapP90Ms),
-        selectedLiveTextEventDelta: statDelta(current.selectedLiveTextEventCountAfterStart, baseline.selectedLiveTextEventCountAfterStart),
-        selectedLiveReasoningEventDelta: statDelta(current.selectedLiveReasoningEventCountAfterStart, baseline.selectedLiveReasoningEventCountAfterStart),
-        selectedLiveEventDelta: statDelta(current.selectedLiveEventCountAfterStart, baseline.selectedLiveEventCountAfterStart),
-        providerSseTextRatioDelta: statDelta(current.providerSseTextRatio, baseline.providerSseTextRatio),
-        providerSelectedLiveTextRatioDelta: statDelta(current.providerSelectedLiveTextRatio, baseline.providerSelectedLiveTextRatio),
-        providerSseReasoningRatioDelta: statDelta(current.providerSseReasoningRatio, baseline.providerSseReasoningRatio),
-        providerSelectedLiveReasoningRatioDelta: statDelta(current.providerSelectedLiveReasoningRatio, baseline.providerSelectedLiveReasoningRatio),
-        providerDomPositiveTextRatioDelta: statDelta(current.providerDomPositiveTextRatio, baseline.providerDomPositiveTextRatio),
-    };
-}
-function streamingLivePipeline(run) {
-    return run.livePipeline ?? summarizeStreamingLivePipeline(run);
-}
-function streamingDebugDeltaNumber(run, key) {
-    const value = run.debug.delta?.[key];
-    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-function streamingDebugAfterNumber(run, key) {
-    const value = run.debug.after?.[key];
-    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-function streamingDebugStateWindowNumber(run, key) {
-    return stateWindowNumber(run.debug.after?.[key], run.debug.stateBeforeReset?.[key]);
-}
-function selectedLiveStream(run) {
-    return summarizeStreamingSelectedLiveEventSource(run);
-}
-function roomSummaryStream(run) {
-    return run.eventSource?.streams.find((stream) => stream.role === "room-summary");
-}
-function traceDurableEventDelta(trace) {
-    if (!trace || trace.durableEventCountStart === undefined || trace.durableEventCountEnd === undefined)
-        return undefined;
-    return trace.durableEventCountEnd - trace.durableEventCountStart;
-}
-export async function readStreamingBenchmarkArtifact(file) {
-    const parsed = JSON.parse(await readFile(file, "utf8"));
-    const value = parsed.benchmark ?? parsed;
-    if (value?.kind === "streaming-benchmark")
-        return normalizeStreamingBenchmarkRun(value);
-    if (value?.kind === "streaming-benchmark-runs") {
-        const runs = Array.isArray(value.runs) ? value.runs.map((run) => normalizeStreamingBenchmarkRun(run)) : [];
-        return normalizeStreamingBenchmarkGroupArtifact(value, runs);
-    }
-    if (value?.kind === "streaming-benchmark-url-comparison") {
-        const primaryRuns = Array.isArray(value.primary?.runs) ? value.primary.runs.map((run) => normalizeStreamingBenchmarkRun(run)) : [];
-        const compareRuns = Array.isArray(value.compare?.runs) ? value.compare.runs.map((run) => normalizeStreamingBenchmarkRun(run)) : [];
-        const primary = normalizeStreamingBenchmarkGroupArtifact(value.primary, primaryRuns);
-        const compare = normalizeStreamingBenchmarkGroupArtifact(value.compare, compareRuns);
-        return {
-            ...value,
-            primary,
-            compare,
-            comparison: compareStreamingBenchmarkSummaries(primary.summary, compare.summary),
-            regressions: Array.isArray(value.regressions) ? value.regressions : [],
-            warnings: Array.isArray(value.warnings) ? value.warnings : [],
-        };
-    }
-    throw new Error(`File is not a streaming benchmark artifact: ${file}`);
-}
-function normalizeStreamingBenchmarkGroupArtifact(value, runs) {
-    return {
-        ...value,
-        kind: "streaming-benchmark-runs",
-        createdAt: value?.createdAt ?? new Date().toISOString(),
-        durationMs: value?.durationMs ?? runs[0]?.durationMs ?? 0,
-        runs,
-        summary: summarizeStreamingBenchmarks(runs),
-        regressions: Array.isArray(value?.regressions) ? value.regressions : [],
-        warnings: Array.isArray(value?.warnings) ? value.warnings : [],
-    };
-}
-function normalizeStreamingBenchmarkRun(run) {
-    const scored = { ...run, regressions: Array.isArray(run.regressions) ? run.regressions : [], warnings: Array.isArray(run.warnings) ? run.warnings : [], score: run.score ?? scoreStreamingBenchmark(run) };
-    const withProviderPreservation = { ...scored, providerPreservation: run.providerPreservation ?? summarizeStreamingProviderPreservation(scored) };
-    const withLivePipeline = { ...withProviderPreservation, livePipeline: run.livePipeline ?? summarizeStreamingLivePipeline(withProviderPreservation) };
-    return { ...withLivePipeline, cadence: run.cadence ?? summarizeStreamingCadence(withLivePipeline) };
-}
-export function streamingBenchmarkReportTarget(benchmark) {
-    const url = benchmark.kind === "streaming-benchmark-url-comparison"
-        ? benchmark.primaryUrl
-        : benchmark.kind === "streaming-benchmark-runs"
-            ? benchmark.runs[0]?.url ?? ""
-            : benchmark.url;
-    return { id: "artifact", url, title: "streaming benchmark artifact" };
-}
-export async function readStreamingBenchmarkRuns(file) {
-    const value = await readStreamingBenchmarkArtifact(file);
-    const runs = value.kind === "streaming-benchmark-runs"
-        ? value.runs
-        : value.kind === "streaming-benchmark-url-comparison"
-            ? [...value.primary.runs, ...value.compare.runs]
-            : [value];
-    return runs.filter((run) => run.kind === "streaming-benchmark");
-}
-function numericStats(values) {
-    const nums = values.filter((value) => typeof value === "number" && Number.isFinite(value)).slice().sort((a, b) => a - b);
-    if (!nums.length)
-        return { count: 0 };
-    const pick = (q) => nums[Math.min(nums.length - 1, Math.max(0, Math.floor((nums.length - 1) * q)))];
-    const avg = nums.reduce((sum, value) => sum + value, 0) / nums.length;
-    return {
-        count: nums.length,
-        min: round3(nums[0]),
-        p50: round3(pick(0.50)),
-        p90: round3(pick(0.90)),
-        p99: round3(pick(0.99)),
-        max: round3(nums[nums.length - 1]),
-        avg: round3(avg),
-    };
-}
-function statDelta(current, baseline) {
-    if (current.p50 === undefined || baseline.p50 === undefined)
-        return undefined;
-    return round3(current.p50 - baseline.p50);
-}
-function clampScore(value) {
-    return Math.min(100, Math.max(0, value));
-}
-function finiteNumber(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-function numberField(record, key) {
-    const value = record[key];
-    return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
-function stateWindowNumber(afterValue, beforeValue) {
-    const after = finiteNumber(afterValue);
-    if (after === undefined)
-        return undefined;
-    const before = finiteNumber(beforeValue);
-    if (before === undefined || before <= 0 || after < before)
-        return after;
-    return round3(after - before);
-}
-function elapsedIsoMs(startedAt, value) {
-    if (typeof startedAt !== "string" || typeof value !== "string")
-        return undefined;
-    const start = Date.parse(startedAt);
-    const end = Date.parse(value);
-    if (!Number.isFinite(start) || !Number.isFinite(end))
-        return undefined;
-    return round3(end - start);
-}
-function round3(value) {
-    return Math.round(value * 1000) / 1000;
-}