testplane 9.1.1 → 9.2.0

package/build/src/profiler/analysis/analyzers.js

@@ -0,0 +1,1228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAnalyzers = void 0;
+const aggregator_1 = require("./aggregator");
+const finding_order_1 = require("./finding-order");
+const outliers_1 = require("./outliers");
+const policy_v1_1 = require("./policy-v1");
+const createDefaultAnalyzers = () => [
+    longRunAnalyzer,
+    majorPhaseAnalyzer,
+    testDiscoveryAnalyzer,
+    unattributedAnalyzer,
+    listenerAnalyzer,
+    testFileAnalyzer,
+    slowTestAnalyzer,
+    hookAnalyzer,
+    commandAnalyzer,
+    moduleDependencyAnalyzer,
+    workerCapacityAnalyzer,
+    sessionConcurrencyAnalyzer,
+    resourceSaturationAnalyzer,
+];
+const runAnalyzers = (profile, analyzers = createDefaultAnalyzers()) => {
+    const findings = [];
+    for (const analyzer of analyzers) {
+        if (profile.level < analyzer.minLevel) {
+            continue;
+        }
+        try {
+            findings.push(...analyzer.analyze(profile));
+        }
+        catch (error) {
+            profile.errors.push({
+                stage: `analysis.${analyzer.id}`,
+                message: String(error?.message ?? error).slice(0, 1000),
+            });
+        }
+    }
+    return findings
+        .sort(finding_order_1.compareFindings)
+        .slice(0, 50)
+        .map((finding, index) => ({ ...finding, id: `${finding.analyzer.id}:${index + 1}` }));
+};
+exports.runAnalyzers = runAnalyzers;
+const TEST_DISCOVERY_PHASE = "testplane.phase.test-discovery";
+const NON_ACTIONABLE_PHASES = new Set([
+    "testplane.phase.execution",
+    "testplane.phase.unattributed",
+    TEST_DISCOVERY_PHASE,
+]);
+const longRunAnalyzer = {
+    id: "long-run-v1",
+    minLevel: 1,
+    analyze: profile => {
+        if (profile.operation !== "run" || profile.durationMs <= policy_v1_1.ANALYSIS_POLICY_V1.longRun.thresholdMs) {
+            return [];
+        }
+        const hostCpu95thPercentile = sampledAggregateValue(profile, "host.cpuUtilization", "p95WallMs", {
+            process: "host",
+        });
+        const isHostCpuHigh = hostCpu95thPercentile !== undefined &&
+            hostCpu95thPercentile >= policy_v1_1.ANALYSIS_POLICY_V1.hostCpu.high95thPercentile;
+        const root = profile.timeline.find(operation => operation.kind === "testplane.operation");
+        const hostCpuObservation = hostCpu95thPercentile === undefined
+            ? " Host CPU utilization data was unavailable."
+            : ` Host CPU p95 was ${formatPercent(hostCpu95thPercentile)}, ${isHostCpuHigh ? "at or above" : "below"} the ${formatPercent(policy_v1_1.ANALYSIS_POLICY_V1.hostCpu.high95thPercentile)} high-load threshold.`;
+        const evidence = [
+            {
+                metric: "wall",
+                value: profile.durationMs,
+                unit: "ms",
+                threshold: policy_v1_1.ANALYSIS_POLICY_V1.longRun.thresholdMs,
+                ...(root ? { operationId: root.id } : {}),
+            },
+            {
+                metric: "cpuState",
+                value: isHostCpuHigh ? "high" : hostCpu95thPercentile === undefined ? "unavailable" : "headroom",
+            },
+        ];
+        if (hostCpu95thPercentile !== undefined) {
+            evidence.push({
+                metric: "hostCpuP95",
+                value: hostCpu95thPercentile,
+                unit: "ratio",
+                threshold: policy_v1_1.ANALYSIS_POLICY_V1.hostCpu.high95thPercentile,
+            });
+        }
+        return [
+            simpleFinding({
+                analyzerId: "long-run-v1",
+                category: "run-duration",
+                observation: `The full test run took ${formatMs(profile.durationMs)}, longer than the ${policy_v1_1.ANALYSIS_POLICY_V1.longRun.thresholdMs / 60000}-minute threshold.${hostCpuObservation}`,
+                evidence,
+                action: longRunAction(hostCpu95thPercentile),
+                confidence: "high",
+                operationIds: root ? [root.id] : [],
+            }),
+        ];
+    },
+};
+function longRunAction(hostCpu95thPercentile) {
+    if (hostCpu95thPercentile === undefined) {
+        return "Host CPU data was unavailable or insufficient. Check host CPU and browser-grid capacity first; if both have headroom, increase browser-session parallelism by raising sessionsPerBrowser.";
+    }
+    if (hostCpu95thPercentile >= policy_v1_1.ANALYSIS_POLICY_V1.hostCpu.high95thPercentile) {
+        return "Use @testplane/chunks to split the suite across CI jobs running in parallel on separate available hardware. The plugin selects deterministic chunks but does not orchestrate the jobs; sequential chunks will not reduce total time.";
+    }
+    return "Increase browser-session parallelism where capacity allows by raising sessionsPerBrowser. Compare the next run and stop before browser-grid or host saturation.";
+}
+const majorPhaseAnalyzer = {
+    id: "major-phase-v1",
+    minLevel: 1,
+    analyze: profile => profile.timeline
+        .filter(operation => operation.kind.startsWith("testplane.phase.") && !NON_ACTIONABLE_PHASES.has(operation.kind))
+        .filter(operation => isSignificantPhase(profile, operation))
+        .map(operation => majorPhaseFinding(profile, operation)),
+};
+const testDiscoveryAnalyzer = {
+    id: "test-discovery-v1",
+    minLevel: 1,
+    analyze: profile => profile.timeline
+        .filter(operation => operation.kind === TEST_DISCOVERY_PHASE &&
+        operation.process.type === "master" &&
+        isSignificantPhase(profile, operation))
+        .map(operation => testDiscoveryFinding(profile, operation)),
+};
+function isSignificantPhase(profile, operation) {
+    return (operation.timing.wallMs >= policy_v1_1.ANALYSIS_POLICY_V1.majorPhase.minWallMs &&
+        operation.timing.wallMs / profile.durationMs >= policy_v1_1.ANALYSIS_POLICY_V1.majorPhase.minRunShare);
+}
+const unattributedAnalyzer = {
+    id: "unattributed-v1",
+    minLevel: 1,
+    analyze: profile => profile.timeline
+        .filter(operation => operation.kind === "testplane.phase.unattributed")
+        .filter(operation => operation.attributes.retentionAffected !== true)
+        .filter(operation => {
+        const parent = profile.timeline.find(candidate => candidate.id === operation.parentId);
+        return (operation.timing.wallMs >= policy_v1_1.ANALYSIS_POLICY_V1.unattributed.minWallMs &&
+            operation.timing.wallMs / (parent?.timing.wallMs || profile.durationMs) >=
+                policy_v1_1.ANALYSIS_POLICY_V1.unattributed.minShare);
+    })
+        .map(operation => {
+        const parent = profile.timeline.find(candidate => candidate.id === operation.parentId);
+        const location = parent ? ` inside \`${parent.name}\`` : "";
+        const gap = parent ? largestUnattributedGap(profile, parent) : undefined;
+        const gapObservation = unattributedGapObservation(gap);
+        const gapEvidence = gap
+            ? [
+                {
+                    metric: "largestUnattributedInterval",
+                    value: gap.wallMs,
+                    unit: "ms",
+                    operationId: operation.id,
+                },
+                ...(gap.previous
+                    ? [
+                        {
+                            metric: "previousOperation",
+                            value: gap.previous.name,
+                            operationId: gap.previous.id,
+                        },
+                    ]
+                    : []),
+                ...(gap.next
+                    ? [{ metric: "nextOperation", value: gap.next.name, operationId: gap.next.id }]
+                    : []),
+            ]
+            : [];
+        return {
+            analyzer: { id: "unattributed-v1", version: 1 },
+            category: "coverage",
+            severity: "warning",
+            observation: `${formatMs(operation.timing.wallMs)}${location} could not be attributed to a known child operation.${gapObservation}`,
+            evidence: [
+                {
+                    metric: "unattributedWall",
+                    value: operation.timing.wallMs,
+                    unit: "ms",
+                    operationId: operation.id,
+                },
+                ...(parent ? [{ metric: "parentPhase", value: parent.name }] : []),
+                ...gapEvidence,
+            ],
+            action: unattributedAction(profile, parent, gap),
+            confidence: "medium",
+            operationIds: [
+                operation.id,
+                ...(gap?.previous ? [gap.previous.id] : []),
+                ...(gap?.next ? [gap.next.id] : []),
+            ],
+            confidenceReasons: ["Unattributed time is computed from retained child intervals"],
+        };
+    }),
+};
+function largestUnattributedGap(profile, parent) {
+    const parentStart = parent.startOffsetMs;
+    const parentEnd = parentStart + parent.timing.wallMs;
+    const children = profile.timeline
+        .filter(operation => operation.parentId === parent.id &&
+        operation.kind !== "testplane.phase.unattributed" &&
+        operation.timing.wallMs > 0)
+        .map(operation => ({
+        operation,
+        start: Math.max(parentStart, operation.startOffsetMs),
+        end: Math.min(parentEnd, operation.startOffsetMs + operation.timing.wallMs),
+    }))
+        .filter(interval => interval.end > interval.start)
+        .sort((left, right) => left.start - right.start || right.end - left.end);
+    if (!children.length) {
+        return { wallMs: parent.timing.wallMs };
+    }
+    const gaps = [];
+    let cursor = parentStart;
+    let previous;
+    for (const child of children) {
+        if (child.start > cursor) {
+            gaps.push({ wallMs: child.start - cursor, previous, next: child.operation });
+        }
+        if (child.end > cursor) {
+            cursor = child.end;
+            previous = child.operation;
+        }
+    }
+    if (cursor < parentEnd) {
+        gaps.push({ wallMs: parentEnd - cursor, previous });
+    }
+    return gaps.sort((left, right) => right.wallMs - left.wallMs)[0];
+}
+function unattributedGapObservation(gap) {
+    if (!gap) {
+        return "";
+    }
+    if (gap.previous && gap.next) {
+        return ` The largest unattributed interval was ${formatMs(gap.wallMs)} between ${unattributedBoundary(gap.previous)} and ${unattributedBoundary(gap.next)}.`;
+    }
+    if (gap.previous) {
+        return ` The largest unattributed interval was ${formatMs(gap.wallMs)} after ${unattributedBoundary(gap.previous)}.`;
+    }
+    if (gap.next) {
+        return ` The largest unattributed interval was ${formatMs(gap.wallMs)} before ${unattributedBoundary(gap.next)}.`;
+    }
+    return "";
+}
+function unattributedBoundary(operation) {
+    return `${operationKindLabel(operation.kind)} \`${operation.name}\``;
+}
+const OPERATION_KIND_LABELS = {
+    "browser.command": "browser command",
+    "event.listener": "event listener",
+    "user.callback": "callback",
+    "test.hook": "hook",
+    "test.body": "test body",
+    "test.attempt": "test",
+    "worker.test-attempt": "test",
+    "module.load": "module load",
+    "test.file.load": "test file load",
+    "worker.call": "worker call",
+};
+function operationKindLabel(kind) {
+    return (OPERATION_KIND_LABELS[kind] ??
+        (kind.startsWith("browser.session.")
+            ? "browser session operation"
+            : kind.startsWith("testplane.phase.")
+                ? "phase"
+                : "operation"));
+}
+function unattributedAction(profile, parent, gap) {
+    const location = gap?.previous && gap.next
+        ? `between ${unattributedBoundary(gap.previous)} and ${unattributedBoundary(gap.next)}`
+        : gap?.previous
+            ? `after ${unattributedBoundary(gap.previous)}`
+            : gap?.next
+                ? `before ${unattributedBoundary(gap.next)}`
+                : parent
+                    ? `inside \`${parent.name}\``
+                    : "during this interval";
+    const inspect = `Inspect custom code that can run ${location}, including plugins or listeners, callbacks, module initialization, and synchronous filesystem or CPU work. Disable only suspected extensions one at a time.`;
+    return profile.level < 3
+        ? `Try profiler.level 3 to retain more operations around this interval. ${inspect}`
+        : inspect;
+}
+const listenerAnalyzer = {
+    id: "event-listener-v1",
+    minLevel: 2,
+    analyze: profile => {
+        const aggregates = profile.aggregates.listeners
+            .filter(aggregate => !aggregate.name.startsWith("internal:"))
+            // A listener is only slow if it is slow per call: a low per-call average across many
+            // events is normal, not a bottleneck, even when the cumulative total is large.
+            .filter(aggregate => aggregate.meanWallMs >= policy_v1_1.ANALYSIS_POLICY_V1.eventListener.minMeanWallMs &&
+            (aggregate.maxWallMs >= policy_v1_1.ANALYSIS_POLICY_V1.eventListener.minSingleWallMs ||
+                aggregate.totalWallMs >= policy_v1_1.ANALYSIS_POLICY_V1.eventListener.minTotalWallMs) &&
+            aggregate.totalWallMs / profile.durationMs >= policy_v1_1.ANALYSIS_POLICY_V1.eventListener.minRunShare);
+        const slowestOperations = aggregates.map(aggregate => retainedOperationsForAggregate(profile, aggregate)[0]);
+        const locations = shortestUniqueSourceLocations(slowestOperations.map(operation => operation?.source));
+        return aggregates.map((aggregate, index) => listenerFinding(aggregate, profile, slowestOperations[index], locations[index]));
+    },
+};
+const testFileAnalyzer = {
+    id: "test-file-v1",
+    minLevel: 2,
+    analyze: profile => {
+        // One file loads many times (per worker/session/retry/browser); collapse to the worst
+        // instance per file so a single slow file produces a single finding, not dozens.
+        const operations = dedupeByNameMaxWall(profile.timeline.filter(operation => operation.kind.startsWith("test.file")));
+        const fileLoadWall = operations.reduce((total, operation) => total + operation.timing.wallMs, 0);
+        const candidates = operations.length >= 8
+            ? (0, outliers_1.findRobustOutliers)(operations, operation => operation.timing.wallMs)
+            : operations.map(operation => ({ item: operation, measurement: operation.timing.wallMs }));
+        const retained = candidates
+            .filter(candidate => candidate.measurement >= policy_v1_1.ANALYSIS_POLICY_V1.testFile.minWallMs)
+            .slice(0, Math.max(3, Math.ceil(operations.length * 0.1)));
+        if (retained.reduce((total, candidate) => total + candidate.measurement, 0) / Math.max(1, fileLoadWall) <
+            policy_v1_1.ANALYSIS_POLICY_V1.testFile.minGroupShare) {
+            return [];
+        }
+        return retained.map(({ item: operation }) => operationFinding("test-file-v1", "test-file", operation, profile, testFileAction(profile, operation)));
+    },
+};
+const moduleDependencyAnalyzer = {
+    id: "module-dependency-v1",
+    minLevel: 3,
+    analyze: profile => {
+        const modules = dedupeByNameMaxWall(profile.timeline.filter(operation => operation.kind === "module.load" &&
+            typeof operation.attributes.ownerFile === "string" &&
+            !operation.attributes.cacheHit &&
+            operation.attributes.module !== operation.attributes.ownerFile &&
+            // Testplane's own internals are not user-actionable dependencies.
+            !isFrameworkModule(String(operation.attributes.module ?? operation.name))));
+        const candidates = modules.length >= 8
+            ? (0, outliers_1.findRobustOutliers)(modules, operation => operation.timing.wallMs)
+            : modules.map(operation => ({ item: operation, measurement: operation.timing.wallMs }));
+        return candidates
+            .filter(({ measurement }) => measurement >= 100 && measurement / profile.durationMs >= 0.01)
+            .slice(0, Math.max(3, Math.ceil(modules.length * 0.1)))
+            .map(({ item: operation }) => operationFinding("module-dependency-v1", "module", operation, profile, moduleDependencyAction(operation.attributes.ownerFile)));
+    },
+};
+const workerCapacityAnalyzer = {
+    id: "worker-capacity-v1",
+    minLevel: 1,
+    analyze: profile => {
+        const capacity = assessWorkerCapacity(profile);
+        if (!capacity) {
+            return [];
+        }
+        const pressure = [
+            `runTest calls overlapped for ${formatMs(capacity.concurrentCallOverlapMs)}`,
+            capacity.eventLoopDelay
+                ? `worker event-loop delay was ${formatMs(capacity.eventLoopDelay.medianMs)} at p50 and ${formatMs(capacity.eventLoopDelay.ninetyFifthPercentileMs)} at p95`
+                : undefined,
+        ].filter((value) => Boolean(value));
+        const hostCpuObservation = capacity.hostCpu95thPercentile === undefined
+            ? " Host CPU data was unavailable."
+            : ` Host CPU was ${formatPercent(capacity.hostCpu95thPercentile)} at p95.`;
+        const evidence = [
+            { metric: "currentWorkers", value: capacity.currentWorkers },
+            { metric: "proposedWorkers", value: capacity.proposedWorkers },
+            {
+                metric: "workerEluP50",
+                value: capacity.medianWorkerEventLoopUtilization,
+                unit: "ratio",
+                threshold: policy_v1_1.ANALYSIS_POLICY_V1.workers.minMedianWorkerEventLoopUtilization,
+            },
+            { metric: "activeWorkerCallsPeak", value: capacity.activeCallsPeak },
+            {
+                metric: "concurrentWorkerCallOverlap",
+                value: capacity.concurrentCallOverlapMs,
+                unit: "ms",
+                threshold: policy_v1_1.ANALYSIS_POLICY_V1.workers.minConcurrentCallOverlapMs,
+            },
+        ];
+        if (capacity.hostCpu95thPercentile !== undefined) {
+            evidence.push({
+                metric: "hostCpuP95",
+                value: capacity.hostCpu95thPercentile,
+                unit: "ratio",
+                threshold: policy_v1_1.ANALYSIS_POLICY_V1.workers.maxHostCpu95thPercentile,
+            });
+        }
+        if (capacity.eventLoopDelay) {
+            evidence.push({
+                metric: "eventLoopDelayP50",
+                value: capacity.eventLoopDelay.medianMs,
+                unit: "ms",
+                threshold: policy_v1_1.ANALYSIS_POLICY_V1.workers.minSustainedEventLoopDelayMs,
+            }, {
+                metric: "eventLoopDelayP95",
+                value: capacity.eventLoopDelay.ninetyFifthPercentileMs,
+                unit: "ms",
+            }, { metric: "eventLoopDelaySamples", value: capacity.eventLoopDelay.samples });
+        }
+        return [
+            simpleFinding({
+                analyzerId: "worker-capacity-v1",
+                category: "workers",
+                observation: `Workers were CPU-saturated (${formatPercent(capacity.medianWorkerEventLoopUtilization)} event-loop utilization at p50) while ${pressure.join(" and ")}.${hostCpuObservation}`,
+                evidence,
+                action: workerCapacityAction(capacity),
+                confidence: "medium",
+                operationIds: [],
+                confidenceReasons: ["The suggested gain is a counterfactual estimate"],
+            }),
+        ];
+    },
+};
+function assessWorkerCapacity(profile) {
+    const currentWorkers = metricValue(profile, "config.workers");
+    const availableParallelism = metricValue(profile, "config.availableParallelism");
+    const medianWorkerEventLoopUtilization = sampledAggregateValue(profile, "process.eventLoopUtilization", "p50WallMs", { process: "worker" });
+    if (profile.durationMs < policy_v1_1.ANALYSIS_POLICY_V1.workers.minExecutionMs ||
+        currentWorkers === undefined ||
+        availableParallelism === undefined ||
+        currentWorkers >= availableParallelism ||
+        medianWorkerEventLoopUtilization === undefined ||
+        medianWorkerEventLoopUtilization < policy_v1_1.ANALYSIS_POLICY_V1.workers.minMedianWorkerEventLoopUtilization) {
+        return;
+    }
+    const activeCallsPeak = metricValue(profile, "worker.activeCalls.peak") ?? 0;
+    const concurrentCallOverlapMs = durationAtConcurrency(profile.timeline.filter(operation => operation.kind === "worker.call" && operation.name === "runTest"), 2);
+    const hasDistributableCalls = activeCallsPeak > currentWorkers &&
+        concurrentCallOverlapMs >= policy_v1_1.ANALYSIS_POLICY_V1.workers.minConcurrentCallOverlapMs &&
+        concurrentCallOverlapMs / profile.durationMs >= policy_v1_1.ANALYSIS_POLICY_V1.workers.minConcurrentCallOverlapShare;
+    const eventLoopDelay = sustainedEventLoopDelay(findAggregate(profile, "process.eventLoopDelayP95Ms", { process: "worker" }));
+    const hostCpu95thPercentile = sampledAggregateValue(profile, "host.cpuUtilization", "p95WallMs", {
+        process: "host",
+    });
+    const hasHostHeadroom = hostCpu95thPercentile !== undefined &&
+        hostCpu95thPercentile < policy_v1_1.ANALYSIS_POLICY_V1.workers.maxHostCpu95thPercentile;
+    if (!hasDistributableCalls || (!hasHostHeadroom && !eventLoopDelay)) {
+        return;
+    }
+    const proposedWorkers = Math.min(availableParallelism, activeCallsPeak, Math.ceil(currentWorkers * 1.25));
+    return {
+        currentWorkers,
+        proposedWorkers,
+        activeCallsPeak,
+        concurrentCallOverlapMs,
+        medianWorkerEventLoopUtilization,
+        hostCpu95thPercentile,
+        eventLoopDelay,
+    };
+}
+function sustainedEventLoopDelay(aggregate) {
+    if ((aggregate?.count ?? 0) < policy_v1_1.ANALYSIS_POLICY_V1.resources.minSamples ||
+        aggregate?.p50WallMs === undefined ||
+        aggregate.p50WallMs < policy_v1_1.ANALYSIS_POLICY_V1.workers.minSustainedEventLoopDelayMs ||
+        aggregate.p95WallMs === undefined) {
+        return;
+    }
+    return {
+        medianMs: aggregate.p50WallMs,
+        ninetyFifthPercentileMs: aggregate.p95WallMs,
+        samples: aggregate.count,
+    };
+}
+function workerCapacityAction(capacity) {
+    const action = `Try system.workers: ${capacity.proposedWorkers} (currently ${capacity.currentWorkers}) and compare worker event-loop delay and total run time on the next run.`;
+    return capacity.hostCpu95thPercentile !== undefined &&
+        capacity.hostCpu95thPercentile >= policy_v1_1.ANALYSIS_POLICY_V1.workers.maxHostCpu95thPercentile
+        ? `${action} Host CPU was already high, so revert the increase if it remains saturated; then add CPU capacity or split the run across separate CI hosts with @testplane/chunks.`
+        : action;
+}
+const sessionConcurrencyAnalyzer = {
+    id: "session-concurrency-v1",
+    minLevel: 2,
+    analyze: profile => {
+        const attemptsByBrowser = groupOperations(profile.timeline.filter(operation => operation.kind === "test.attempt" && operation.context.browserId), operation => operation.context.browserId);
+        const browsers = [...attemptsByBrowser]
+            .map(([browserId, attempts]) => ({
+            browserId,
+            attempts,
+            end: Math.max(...attempts.map(operation => operation.startOffsetMs + operation.timing.wallMs)),
+        }))
+            .sort((left, right) => right.end - left.end);
+        if (browsers.length < 2) {
+            return [];
+        }
+        const [browser, nextBrowser] = browsers;
+        if (nextBrowser.end <= 0) {
+            return [];
+        }
+        const hostCpu95thPercentile = sampledAggregateValue(profile, "host.cpuUtilization", "p95WallMs", {
+            process: "host",
+        });
+        const medianWorkerEventLoopUtilization = sampledAggregateValue(profile, "process.eventLoopUtilization", "p50WallMs", { process: "worker" });
+        const medianWorker95thPercentileEventLoopDelayMs = sampledAggregateValue(profile, "process.eventLoopDelayP95Ms", "p50WallMs", { process: "worker" });
+        const globalQueuePeak = maxMetricValue(profile, "browser.pool.queueDepth.peak", { limiter: "global" });
+        const minimumBrowserTailMs = Math.max(policy_v1_1.ANALYSIS_POLICY_V1.sessions.minTailMs, profile.durationMs * policy_v1_1.ANALYSIS_POLICY_V1.sessions.minTailShare);
+        const currentSessionsPerBrowser = metricValue(profile, "config.sessionsPerBrowser", {
+            browserId: browser.browserId,
+        });
+        const browserQueuePeak = metricValue(profile, "browser.pool.queueDepth.peak", {
+            browserId: browser.browserId,
+            limiter: "browser",
+        }) ?? 0;
+        const sessionSampleCount = metricValue(profile, "browser.pool.sessionsLaunched.sampleCount", {
+            browserId: browser.browserId,
+            limiter: "browser",
+        }) ?? 0;
+        const saturatedSessionSampleCount = metricValue(profile, "browser.pool.sessionsLaunched.saturatedSampleCount", {
+            browserId: browser.browserId,
+            limiter: "browser",
+        }) ?? 0;
+        const sessionLimitSaturationShare = sessionSampleCount ? saturatedSessionSampleCount / sessionSampleCount : 0;
+        const browserTailMs = browser.end - nextBrowser.end;
+        if (currentSessionsPerBrowser === undefined ||
+            browser.attempts.length < policy_v1_1.ANALYSIS_POLICY_V1.sessions.minAttempts ||
+            browserQueuePeak <= 0 ||
+            sessionLimitSaturationShare < policy_v1_1.ANALYSIS_POLICY_V1.sessions.minLimitSaturationShare ||
+            hostCpu95thPercentile === undefined ||
+            hostCpu95thPercentile >= policy_v1_1.ANALYSIS_POLICY_V1.workers.maxHostCpu95thPercentile ||
+            (medianWorkerEventLoopUtilization ?? 0) >= policy_v1_1.ANALYSIS_POLICY_V1.workers.minMedianWorkerEventLoopUtilization ||
+            (medianWorker95thPercentileEventLoopDelayMs ?? 0) >=
+                policy_v1_1.ANALYSIS_POLICY_V1.workers.minSustainedEventLoopDelayMs ||
+            (globalQueuePeak ?? 0) !== 0 ||
+            browserTailMs < minimumBrowserTailMs) {
+            return [];
+        }
+        const proposedSessionsPerBrowser = Math.ceil((browser.end / nextBrowser.end) * currentSessionsPerBrowser);
+        return [
+            simpleFinding({
+                analyzerId: "session-concurrency-v1",
+                category: "sessions",
+                observation: `\`${browser.browserId}\` tests took: ${formatMs(browser.end)}; \`${nextBrowser.browserId}\` tests took: ${formatMs(nextBrowser.end)}. \`${browser.browserId}\` finished ${formatMs(browserTailMs)} later.`,
+                evidence: [
+                    { metric: "browser", value: browser.browserId },
+                    { metric: "browserQueuePeak", value: browserQueuePeak },
+                    { metric: "attempts", value: browser.attempts.length },
+                    { metric: "browserEnd", value: browser.end, unit: "ms" },
+                    { metric: "nextBrowser", value: nextBrowser.browserId },
+                    { metric: "nextBrowserEnd", value: nextBrowser.end, unit: "ms" },
+                    {
+                        metric: "browserTail",
+                        value: browserTailMs,
+                        unit: "ms",
+                        threshold: minimumBrowserTailMs,
+                    },
+                    { metric: "currentSessionsPerBrowser", value: currentSessionsPerBrowser },
+                    { metric: "proposedSessionsPerBrowser", value: proposedSessionsPerBrowser },
+                    {
+                        metric: "sessionLimitSaturationShare",
+                        value: sessionLimitSaturationShare,
+                        unit: "ratio",
+                        threshold: policy_v1_1.ANALYSIS_POLICY_V1.sessions.minLimitSaturationShare,
+                    },
+                ],
+                action: `Try sessionsPerBrowser: ${proposedSessionsPerBrowser} for ${browser.browserId} (currently ${currentSessionsPerBrowser}), unless an external grid limit is already saturated.`,
+                confidence: "medium",
+                operationIds: browser.attempts.map(operation => operation.id).slice(0, 20),
+                confidenceReasons: [
+                    "The recommendation predicts the next run and cannot observe external grid capacity",
+                    "The target assumes browser time scales inversely with the number of sessions",
+                ],
+            }),
+        ];
+    },
+};
+const resourceSaturationAnalyzer = {
+    id: "resource-saturation-v1",
+    minLevel: 1,
+    analyze: profile => {
+        const hostCpu95thPercentile = sampledAggregateValue(profile, "host.cpuUtilization", "p95WallMs", {
+            process: "host",
+        });
+        const medianWorkerEventLoopUtilization = sampledAggregateValue(profile, "process.eventLoopUtilization", "p50WallMs", { process: "worker" });
+        const highestMedianEventLoopDelayAggregate = maxAggregate(profile, "process.eventLoopDelayP95Ms", "p50WallMs", policy_v1_1.ANALYSIS_POLICY_V1.resources.minSamples);
+        const eventLoopDelayStats = sustainedEventLoopDelay(highestMedianEventLoopDelayAggregate);
+        const affectedProcess = String(highestMedianEventLoopDelayAggregate?.attributes?.process ?? "Node");
+        const workerCapacity = assessWorkerCapacity(profile);
+        const findings = [];
+        if (hostCpu95thPercentile !== undefined &&
+            hostCpu95thPercentile >= policy_v1_1.ANALYSIS_POLICY_V1.hostCpu.high95thPercentile) {
+            findings.push(simpleFinding({
+                analyzerId: "host-cpu-v1",
+                category: "cpu",
+                observation: `Host CPU utilization reached ${formatPercent(hostCpu95thPercentile)} at p95.${medianWorkerEventLoopUtilization === undefined
+                    ? ""
+                    : ` Worker event-loop utilization was ${formatPercent(medianWorkerEventLoopUtilization)} at p50.`}`,
+                evidence: [
+                    {
+                        metric: "hostCpuP95",
+                        value: hostCpu95thPercentile,
+                        unit: "ratio",
+                        threshold: policy_v1_1.ANALYSIS_POLICY_V1.hostCpu.high95thPercentile,
+                    },
+                    ...(medianWorkerEventLoopUtilization === undefined
+                        ? []
+                        : [
+                            {
+                                metric: "workerEluP50",
+                                value: medianWorkerEventLoopUtilization,
+                                unit: "ratio",
+                                threshold: policy_v1_1.ANALYSIS_POLICY_V1.workers.minMedianWorkerEventLoopUtilization,
+                            },
+                        ]),
+                ],
+                action: hostCpuAction(medianWorkerEventLoopUtilization, workerCapacity),
+                confidence: "medium",
+                operationIds: [],
+                confidenceReasons: ["Host CPU is sampled and may include unrelated processes"],
+            }));
+        }
+        if (eventLoopDelayStats && !(affectedProcess === "worker" && workerCapacity?.eventLoopDelay)) {
+            const processLabel = affectedProcess === "worker" ? "Worker processes" : `${capitalize(affectedProcess)} process`;
+            findings.push(simpleFinding({
+                analyzerId: "event-loop-delay-v1",
+                category: "event-loop",
+                observation: `${processLabel} event-loop delay was ${formatMs(eventLoopDelayStats.medianMs)} at p50 and reached ${formatMs(eventLoopDelayStats.ninetyFifthPercentileMs)} at p95 across ${eventLoopDelayStats.samples} samples. Healthy event-loop delay is below ${formatMs(policy_v1_1.ANALYSIS_POLICY_V1.resources.healthyMedianEventLoopDelayMs)} at p50.`,
+                evidence: [
+                    {
+                        metric: "eventLoopDelayP50",
+                        value: eventLoopDelayStats.medianMs,
+                        unit: "ms",
+                        threshold: policy_v1_1.ANALYSIS_POLICY_V1.workers.minSustainedEventLoopDelayMs,
+                    },
+                    {
+                        metric: "eventLoopDelayP95",
+                        value: eventLoopDelayStats.ninetyFifthPercentileMs,
+                        unit: "ms",
+                    },
+                    { metric: "eventLoopDelaySamples", value: eventLoopDelayStats.samples },
+                    { metric: "process", value: affectedProcess },
+                ],
+                action: eventLoopDelayAction(affectedProcess, processLabel),
+                confidence: "medium",
+                operationIds: [],
+                confidenceReasons: ["Event-loop delay is a process-window metric, not exclusive function CPU"],
+            }));
+        }
+        return findings;
+    },
+};
+function eventLoopDelayAction(process, processLabel) {
+    const healthyMedianDelay = formatMs(policy_v1_1.ANALYSIS_POLICY_V1.resources.healthyMedianEventLoopDelayMs);
+    const reduceDelay = `Reduce p50 below ${healthyMedianDelay} by removing long synchronous sections: replace synchronous filesystem calls with async equivalents, and optimize or move CPU-heavy parsing and calculations off the affected Node event loop.`;
+    if (process === "worker") {
+        return `${reduceDelay} The profile does not prove that more system.workers would help. Start with the concrete slow listener, hook, dependency, test, or command findings printed in this report. If none explains the delay, try profiler.level 3 and inspect worker-side plugins and test files.`;
+    }
+    return `${reduceDelay} Start with the slow phase, listener, and file findings printed for ${processLabel.toLowerCase()}. If none explains the delay, try profiler.level 3 and inspect custom code in that process.`;
+}
+function hostCpuAction(medianWorkerEventLoopUtilization, workerCapacity) {
+    if (medianWorkerEventLoopUtilization === undefined) {
+        return "Host CPU includes Testplane and unrelated processes. Check top/htop and CI or container CPU limits to identify the saturated process before changing system.workers.";
+    }
+    if (medianWorkerEventLoopUtilization >= policy_v1_1.ANALYSIS_POLICY_V1.workers.minMedianWorkerEventLoopUtilization) {
+        if (workerCapacity) {
+            return `Testplane workers were also busy and parallel work exceeded system.workers. Follow the Worker capacity recommendation up to ${workerCapacity.proposedWorkers} workers, then recheck host CPU. If the host stays saturated, reduce CPU-heavy test or plugin work, add CPU capacity, or split the run across separate CI hosts with @testplane/chunks.`;
+        }
+        return "Testplane workers were also busy. Do not add more workers on the same CPU-saturated host. Reduce CPU-heavy test or plugin work, add CPU capacity, or split the run across separate CI hosts with @testplane/chunks.";
+    }
+    return "Testplane workers were not saturated, so the load likely comes from another process or a CI/container CPU limit. Check top/htop and the CPU limit, then free or add capacity before changing system.workers.";
+}
+const slowTestAnalyzer = {
+    id: "slow-test-v1",
+    minLevel: 2,
+    analyze: profile => {
+        const tests = profile.aggregates.tests.filter(aggregate => aggregate.kind === "test.body");
+        if (!tests.length) {
+            return [];
+        }
+        const meanPerCall = tests.reduce((sum, aggregate) => sum + aggregate.meanWallMs, 0) / tests.length;
+        const relativeGate = tests.length >= policy_v1_1.ANALYSIS_POLICY_V1.slowTest.minSampleForRelative
+            ? meanPerCall * policy_v1_1.ANALYSIS_POLICY_V1.slowTest.minMeanMultiple
+            : 0;
+        return tests
+            .filter(aggregate => aggregate.maxWallMs >= policy_v1_1.ANALYSIS_POLICY_V1.slowTest.minWallMs &&
+            aggregate.totalWallMs / profile.durationMs >= policy_v1_1.ANALYSIS_POLICY_V1.slowTest.minExecutionShare &&
+            aggregate.meanWallMs >= relativeGate)
+            .map(aggregate => aggregateFinding("slow-test-v1", "test", aggregate, profile, "Inspect slow commands and awaited operations inside this test body; remove avoidable waits from its critical path."));
+    },
+};
+const hookAnalyzer = {
+    id: "common-hook-v1",
+    minLevel: 2,
+    analyze: profile => {
+        const findings = [];
+        for (const aggregate of profile.aggregates.hooks) {
+            if (aggregate.count < policy_v1_1.ANALYSIS_POLICY_V1.commonHook.minCalls ||
+                aggregate.totalWallMs < policy_v1_1.ANALYSIS_POLICY_V1.commonHook.minTotalWallMs ||
+                aggregate.totalWallMs / profile.durationMs < policy_v1_1.ANALYSIS_POLICY_V1.commonHook.minExecutionShare) {
+                continue;
+            }
+            // Parallel tests inflate cumulative hook work. For moderate hooks, require their
+            // retained intervals to occupy a material part of the run's actual wall time.
+            const observedWallMs = operationUnionWall(profile, aggregate);
+            if (aggregate.meanWallMs < policy_v1_1.ANALYSIS_POLICY_V1.commonHook.minMeanWallMs &&
+                observedWallMs / profile.durationMs < policy_v1_1.ANALYSIS_POLICY_V1.commonHook.minExecutionShare) {
+                continue;
+            }
+            const finding = aggregateFinding("common-hook-v1", "hook", aggregate, profile, "Check whether every test in this suite needs the hook's full setup. Optimize the repeated work, or split the tests into smaller suites with focused hooks so each test runs only the setup it needs.");
+            if (observedWallMs > 0) {
+                finding.evidence.push({
+                    metric: "observedUnionWall",
+                    value: observedWallMs,
+                    unit: "ms",
+                    threshold: profile.durationMs * policy_v1_1.ANALYSIS_POLICY_V1.commonHook.minExecutionShare,
+                });
+            }
+            findings.push(finding);
+        }
+        return findings;
+    },
+};
+const commandAnalyzer = {
+    id: "browser-command-v1",
+    minLevel: 3,
+    analyze: profile => profile.aggregates.commands
+        .filter(aggregate => aggregate.name !== "<root>")
+        .flatMap(aggregate => {
+        if (aggregate.name === "pause") {
+            const matchesPause = aggregate.totalWallMs >= policy_v1_1.ANALYSIS_POLICY_V1.pause.minTotalWallMs &&
+                (aggregate.count >= policy_v1_1.ANALYSIS_POLICY_V1.pause.minCalls ||
+                    aggregate.maxWallMs >= policy_v1_1.ANALYSIS_POLICY_V1.pause.minSingleWallMs) &&
+                aggregate.totalWallMs / profile.durationMs >= policy_v1_1.ANALYSIS_POLICY_V1.pause.minShare;
+            return matchesPause
+                ? [
+                    aggregateFinding("browser-pause-v1", "browser-command", aggregate, profile, "Replace static browser.pause calls with a condition-based wait."),
+                ]
+                : [];
+        }
+        return aggregate.meanWallMs >= policy_v1_1.ANALYSIS_POLICY_V1.command.minMeanWallMs &&
+            aggregate.totalWallMs >= policy_v1_1.ANALYSIS_POLICY_V1.command.minWallMs &&
+            aggregate.totalWallMs / profile.durationMs >= policy_v1_1.ANALYSIS_POLICY_V1.command.minExecutionShare
+            ? [commandFinding(aggregate, profile)]
+            : [];
+    }),
+};
+const aggregateFinding = (analyzerId, category, aggregate, profile, action) => {
+    const retained = retainedOperationsForAggregate(profile, aggregate);
+    return {
+        analyzer: { id: analyzerId, version: 1 },
+        category,
+        severity: "warning",
+        observation: `\`${aggregate.name}\` used ${formatMs(aggregate.totalWallMs)} across ${aggregate.count} call(s).`,
+        evidence: [
+            { metric: "count", value: aggregate.count },
+            { metric: "totalWall", value: aggregate.totalWallMs, unit: "ms" },
+            { metric: "meanWall", value: aggregate.meanWallMs, unit: "ms" },
+            { metric: "maxWall", value: aggregate.maxWallMs, unit: "ms" },
+            { metric: "runShare", value: aggregate.totalWallMs / profile.durationMs, unit: "ratio" },
+            ...retained.slice(0, 1).map(operation => ({
+                metric: "slowestRetainedCall",
+                value: operation.timing.wallMs,
+                unit: "ms",
+                operationId: operation.id,
+            })),
+        ],
+        action,
+        confidence: "medium",
+        operationIds: retained.map(operation => operation.id),
+        entityIds: [aggregate.name],
+        confidenceReasons: ["The total is cumulative work and may overlap other operations"],
+    };
+};
+const operationFinding = (analyzerId, category, operation, profile, action) => ({
+    analyzer: { id: analyzerId, version: 1 },
+    category,
+    severity: "warning",
+    observation: `\`${operation.name}\` took ${formatMs(operation.timing.wallMs)}.`,
+    evidence: [
+        { metric: "wall", value: operation.timing.wallMs, unit: "ms", operationId: operation.id },
+        {
+            metric: "runShare",
+            value: operation.timing.wallMs / profile.durationMs,
+            unit: "ratio",
+            operationId: operation.id,
+        },
+    ],
+    action,
+    confidence: operation.quality.timing === "exact" ? "high" : "medium",
+    operationIds: [operation.id],
+    entityIds: [operation.name],
+});
+const simpleFinding = ({ analyzerId, ...finding }) => ({
+    analyzer: { id: analyzerId, version: 1 },
+    severity: "warning",
+    ...finding,
+});
+function testDiscoveryFinding(profile, phase) {
+    const breakdown = testDiscoveryBreakdown(profile, phase);
+    const evidence = [
+        {
+            metric: "wall",
+            value: phase.timing.wallMs,
+            unit: "ms",
+            threshold: policy_v1_1.ANALYSIS_POLICY_V1.majorPhase.minWallMs,
+            operationId: phase.id,
+        },
+        {
+            metric: "runShare",
+            value: phase.timing.wallMs / profile.durationMs,
+            unit: "ratio",
+            threshold: policy_v1_1.ANALYSIS_POLICY_V1.majorPhase.minRunShare,
+            operationId: phase.id,
+        },
+        { metric: "discoveryGlobWall", value: breakdown.globWallMs, unit: "ms" },
+        { metric: "fileLoadWall", value: breakdown.fileLoadWallMs, unit: "ms" },
+        { metric: "testParseWall", value: breakdown.parseWallMs, unit: "ms" },
+        { metric: "otherDiscoveryWall", value: breakdown.otherWallMs, unit: "ms" },
+    ];
+    if (breakdown.fileCount !== undefined) {
+        evidence.push({ metric: "fileCount", value: breakdown.fileCount });
+    }
+    if (breakdown.averageFileLoadMs !== undefined) {
+        evidence.push({ metric: "averageFileLoad", value: breakdown.averageFileLoadMs, unit: "ms" }, { metric: "fileLoadOutlierThreshold", value: breakdown.averageFileLoadMs * 3, unit: "ms" });
+    }
+    if (breakdown.hasFileLoadOutliers !== undefined) {
+        evidence.push({ metric: "hasFileLoadOutliers", value: breakdown.hasFileLoadOutliers });
+    }
+    for (const outlier of breakdown.outliers) {
+        evidence.push({ metric: "fileLoadOutlier", value: outlier.name, operationId: outlier.id }, { metric: "fileLoadOutlierWall", value: outlier.timing.wallMs, unit: "ms", operationId: outlier.id });
+    }
+    const discoveryOnly = profile.operation === "readTests" || profile.operation === "cli:list-tests";
+    return {
+        analyzer: { id: "test-discovery-v1", version: 1 },
+        category: "test-discovery",
+        severity: "warning",
+        observation: `\`${phase.name}\` took ${formatMs(phase.timing.wallMs)} (${formatPercent(phase.timing.wallMs / profile.durationMs)} of the run).${discoveryOnly ? " This operation does not execute tests." : ""}`,
+        evidence,
+        action: testDiscoveryAction(profile, breakdown),
+        confidence: "high",
+        operationIds: [...new Set([phase.id, ...breakdown.operations.map(operation => operation.id)])].slice(0, 12),
+        entityIds: [phase.name],
+    };
+}
+function testDiscoveryBreakdown(profile, phase) {
+    const children = profile.timeline.filter(operation => operation.parentId === phase.id &&
+        operation.process.type === "master" &&
+        operation.kind !== "testplane.phase.unattributed");
+    const globOperations = children.filter(operation => operation.kind === "sets.resolve-and-glob");
+    const fileLoadOperation = children
+        .filter(operation => operation.kind === "files.load")
+        .sort((left, right) => right.timing.wallMs - left.timing.wallMs)[0];
+    const parseOperations = children.filter(operation => ["files.group-by-browser", "tests.parse", "tests.validate"].includes(operation.kind));
+    const knownOperations = [...globOperations, ...(fileLoadOperation ? [fileLoadOperation] : []), ...parseOperations];
+    const knownWallMs = (0, aggregator_1.operationUnionWithin)(phase, knownOperations);
+    const fileSummary = profile.aggregates.testFiles.find(aggregate => aggregate.kind === "test.file.load.summary" &&
+        (aggregate.attributes?.process === "master" || aggregate.name === "master"));
+    const fileCount = typeof fileLoadOperation?.attributes.files === "number"
+        ? fileLoadOperation.attributes.files
+        : fileSummary?.count;
+    const averageFileLoadMs = fileSummary?.meanWallMs ??
+        (fileLoadOperation && fileCount ? fileLoadOperation.timing.wallMs / fileCount : undefined);
+    const outlierThresholdMs = averageFileLoadMs !== undefined && averageFileLoadMs > 0 ? averageFileLoadMs * 3 : undefined;
+    const retainedFileLoads = fileLoadOperation
+        ? profile.timeline
+            .filter(operation => operation.parentId === fileLoadOperation.id &&
+            operation.kind === "test.file.load" &&
+            operation.process.type === "master")
+            .sort((left, right) => right.timing.wallMs - left.timing.wallMs)
+        : [];
+    const outliers = outlierThresholdMs === undefined
+        ? []
+        : retainedFileLoads.filter(operation => operation.timing.wallMs >= outlierThresholdMs).slice(0, 3);
+    const hasFileLoadOutliers = outlierThresholdMs === undefined
+        ? undefined
+        : fileSummary
+            ? fileSummary.maxWallMs >= outlierThresholdMs
+            : profile.level >= 2
+                ? outliers.length > 0
+                : undefined;
+    return {
+        globWallMs: (0, aggregator_1.operationUnionWithin)(phase, globOperations),
+        fileLoadWallMs: fileLoadOperation?.timing.wallMs ?? 0,
+        parseWallMs: (0, aggregator_1.operationUnionWithin)(phase, parseOperations),
+        otherWallMs: Math.max(0, phase.timing.wallMs - knownWallMs),
+        fileCount,
+        averageFileLoadMs,
+        hasFileLoadOutliers,
+        outliers,
+        operations: [...knownOperations, ...outliers],
+    };
+}
+function testDiscoveryAction(profile, breakdown) {
+    const discoveryOnly = profile.operation === "readTests" || profile.operation === "cli:list-tests";
+    const operationContext = discoveryOnly
+        ? " This operation does not run tests, so reducing discovery directly reduces its total time."
+        : "";
+    const details = breakdown.hasFileLoadOutliers === undefined
+        ? " Run with profiler.level 2 to check individual file-load outliers."
+        : "";
+    const largest = Math.max(breakdown.globWallMs, breakdown.fileLoadWallMs, breakdown.parseWallMs, breakdown.otherWallMs);
+    if (largest === breakdown.globWallMs && largest > 0) {
+        return `File matching/glob is the largest component. Narrow files/sets masks and exclude generated or artifact directories that cannot contain tests.${operationContext}${details}`;
+    }
+    if (largest === breakdown.fileLoadWallMs && largest > 0) {
+        if (breakdown.hasFileLoadOutliers) {
+            return `Inspect the reported file-load outliers and their imports or file-read listeners. Move repeated initialization out of module scope or load heavy dependencies lazily.${operationContext}`;
+        }
+        if (breakdown.hasFileLoadOutliers === false) {
+            const count = breakdown.fileCount === undefined ? "the selected files" : `${breakdown.fileCount} files`;
+            return `No file was at least 3× slower than the average; the cost is distributed across ${count}. Narrow the selected files/sets or move repeated per-file initialization out of module scope.${operationContext}`;
+        }
+        return `Loading the selected files is the largest component.${details}${operationContext}`;
+    }
+    if (largest === breakdown.parseWallMs && largest > 0) {
+        return `Grouping, parsing, or validation is the largest component. Reduce unnecessary browser/file combinations and inspect expensive test declaration or filtering logic.${operationContext}${details}`;
+    }
+    return `The retained components do not fully explain this phase. Set profiler.output and inspect its retained children.${operationContext}${details}`;
+}
+function majorPhaseFinding(profile, operation) {
+    const listeners = slowPhaseListeners(profile, operation);
+    const observation = [
+        `\`${operation.name}\` (${operation.process.type} process) took ${formatMs(operation.timing.wallMs)} (${formatPercent(operation.timing.wallMs / profile.durationMs)} of the run).`,
+        ...(listeners.length
+            ? ["Slow listeners or callbacks inside this phase:", ...listeners.map(phaseListenerObservation)]
+            : []),
+    ].join("\n");
+    const evidence = [
+        {
+            metric: "wall",
+            value: operation.timing.wallMs,
+            unit: "ms",
+            threshold: policy_v1_1.ANALYSIS_POLICY_V1.majorPhase.minWallMs,
+            operationId: operation.id,
+        },
+        {
+            metric: "runShare",
+            value: operation.timing.wallMs / profile.durationMs,
+            unit: "ratio",
+            threshold: policy_v1_1.ANALYSIS_POLICY_V1.majorPhase.minRunShare,
+            operationId: operation.id,
+        },
+    ];
+    for (const listener of listeners) {
+        evidence.push({ metric: "phaseContributor", value: listener.name, operationId: listener.id }, {
+            metric: "phaseContributorWall",
+            value: listener.timing.wallMs,
+            unit: "ms",
+            operationId: listener.id,
+        });
+        const source = formatSource(listener.source);
+        if (source) {
+            evidence.push({ metric: "phaseContributorSource", value: source, operationId: listener.id });
+        }
+        if (listener.timing.activeJsMs !== undefined) {
+            evidence.push({
+                metric: "phaseContributorActiveJs",
+                value: listener.timing.activeJsMs,
+                unit: "ms",
+                operationId: listener.id,
+            });
+        }
+        if (listener.timing.waitingMs !== undefined) {
+            evidence.push({
+                metric: "phaseContributorWaiting",
+                value: listener.timing.waitingMs,
+                unit: "ms",
+                operationId: listener.id,
+            });
+        }
+    }
+    return {
+        analyzer: { id: "major-phase-v1", version: 1 },
+        category: "phase",
+        severity: "warning",
+        observation,
+        evidence,
+        action: majorPhaseAction(profile, operation, listeners),
+        confidence: "high",
+        operationIds: [operation.id, ...listeners.map(listener => listener.id)],
+        entityIds: [operation.name],
+    };
+}
+function slowPhaseListeners(profile, phase) {
+    const operationsById = new Map(profile.timeline.map(operation => [operation.id, operation]));
+    return profile.timeline
+        .filter(operation => (operation.kind === "event.listener" || operation.kind === "user.callback") &&
+        !operation.name.startsWith("internal:"))
+        .filter(operation => hasAncestor(operation, phase.id, operationsById))
+        .filter(operation => operation.timing.wallMs >= policy_v1_1.ANALYSIS_POLICY_V1.majorPhase.minListenerWallMs &&
+        operation.timing.wallMs / phase.timing.wallMs >= policy_v1_1.ANALYSIS_POLICY_V1.majorPhase.minListenerShare)
+        .sort((left, right) => right.timing.wallMs - left.timing.wallMs)
+        .slice(0, policy_v1_1.ANALYSIS_POLICY_V1.majorPhase.maxListeners);
+}
+function hasAncestor(operation, ancestorId, operationsById) {
+    let parentId = operation.parentId;
+    const visited = new Set();
+    while (parentId && !visited.has(parentId)) {
+        if (parentId === ancestorId) {
+            return true;
+        }
+        visited.add(parentId);
+        parentId = operationsById.get(parentId)?.parentId;
+    }
+    return false;
+}
+function phaseListenerObservation(operation) {
+    const source = formatSource(operation.source);
+    const location = source ? ` at \`${source}\`` : "";
+    const type = operation.kind === "user.callback" ? "Callback" : "Listener";
+    const process = ` (${operation.process.type} process)`;
+    const timing = operation.timing.activeJsMs !== undefined && operation.timing.waitingMs !== undefined
+        ? ` It spent ${formatMs(operation.timing.activeJsMs)} in active JS and ${formatMs(operation.timing.waitingMs)} waiting.`
+        : "";
+    return `• ${type} \`${operation.name}\`${process}${location} took ${formatMs(operation.timing.wallMs)}.${timing}`;
+}
+function majorPhaseAction(profile, operation, listeners) {
+    if (!listeners.length) {
+        if (profile.level < 3) {
+            return `Run with profiler.level ${profile.level + 1} to retain more child operations inside \`${operation.name}\`; the current profile does not identify a specific owner.`;
+        }
+        return `Set profiler.output and inspect unattributed time inside \`${operation.name}\`. No retained user-owned child materially explains this phase; if it stays slow without custom plugins, attach the profile to a Testplane issue.`;
+    }
+    return "Open the reported listener or callback sources, or locate their registrations by the displayed names. If active JS dominates, reduce synchronous or CPU-heavy work; if waiting dominates, inspect awaited I/O or timers. Parallelize only independent operations.";
+}
+function listenerFinding(aggregate, profile, slowest, shortLocation) {
+    const finding = aggregateFinding("event-listener-v1", "event-listener", aggregate, profile, listenerAction(profile.level, aggregate.name, slowest, shortLocation));
+    if (!slowest) {
+        return finding;
+    }
+    const source = formatSource(slowest?.source);
+    const location = source ? ` at \`${source}\`` : " (source unavailable)";
+    finding.observation += ` Slowest retained call${location} took ${formatMs(slowest.timing.wallMs)}.`;
+    if (source) {
+        finding.evidence.push({ metric: "source", value: source, operationId: slowest.id });
+    }
+    if (slowest.timing.activeJsMs !== undefined && slowest.timing.waitingMs !== undefined) {
+        finding.evidence.push({
+            metric: "activeJs",
+            value: slowest.timing.activeJsMs,
+            unit: "ms",
+            operationId: slowest.id,
+        }, {
+            metric: "waiting",
+            value: slowest.timing.waitingMs,
+            unit: "ms",
+            operationId: slowest.id,
+        });
+    }
+    return finding;
+}
+function listenerAction(level, name, operation, shortLocation) {
+    const owner = listenerOwner(name, shortLocation);
+    const activeJsMs = operation?.timing.activeJsMs;
+    const waitingMs = operation?.timing.waitingMs;
+    if (activeJsMs === undefined || waitingMs === undefined) {
+        return level < 3
+            ? `${owner}: run with profiler.level 3 to see what happened during this listener call.`
+            : `${owner}: the detailed activity breakdown was not retained; inspect what this listener does during its slow call.`;
+    }
+    if (waitingMs > activeJsMs) {
+        return `${owner}: waiting dominates the slowest retained call; inspect awaited I/O or timers and remove avoidable serial waits.`;
+    }
+    if (activeJsMs > waitingMs) {
+        return `${owner}: active JS dominates the slowest retained call; reduce synchronous CPU-heavy work or move it off the listener's critical path.`;
+    }
+    return `${owner}: active JS and waiting contribute equally; inspect both awaited I/O or timers and synchronous CPU-heavy work.`;
+}
+function listenerOwner(name, shortLocation) {
+    return `\`${name}\` (${shortLocation ?? "source unavailable"})`;
+}
+function shortestUniqueSourceLocations(sources) {
+    const paths = sources.map(source => source?.file?.replaceAll("\\", "/"));
+    const uniquePaths = [...new Set(paths.filter((file) => Boolean(file)))];
+    const suffixCounts = new Map();
+    for (const file of uniquePaths) {
+        const parts = file.split("/").filter(Boolean);
+        for (let depth = 1; depth <= parts.length; depth += 1) {
+            const suffix = parts.slice(-depth).join("/");
+            suffixCounts.set(suffix, (suffixCounts.get(suffix) ?? 0) + 1);
+        }
+    }
+    const suffixes = new Map(uniquePaths.map(file => {
+        const parts = file.split("/").filter(Boolean);
+        const suffix = parts
+            .map((_, index) => parts.slice(-(index + 1)).join("/"))
+            .find(candidate => suffixCounts.get(candidate) === 1);
+        return [file, suffix ?? parts.join("/")];
+    }));
+    return sources.map((source, index) => {
+        const file = paths[index];
+        if (!file) {
+            return;
+        }
+        const line = source?.line;
+        const column = source?.column;
+        return `${suffixes.get(file)}${line === undefined ? "" : `:${line}`}${column === undefined ? "" : `:${column}`}`;
+    });
+}
+function testFileAction(profile, operation) {
+    if (profile.level < 3) {
+        return "Run with profiler.level 3 to identify heavy dependencies. If no slow dependency is reported, inspect synchronous or awaited module-scope initialization in this test file.";
+    }
+    const dependency = profile.timeline
+        .filter(candidate => candidate.kind === "module.load" &&
+        candidate.attributes.ownerFile === operation.name &&
+        candidate.name !== operation.name &&
+        candidate.attributes.cacheHit !== true &&
+        !isFrameworkModule(String(candidate.attributes.module ?? candidate.name)))
+        .sort((left, right) => right.timing.wallMs - left.timing.wallMs)[0];
+    return dependency
+        ? `Inspect \`${dependency.name}\`, the slowest retained uncached dependency of this file. Move heavy initialization out of module scope or load it lazily.`
+        : "No slow dependency was retained for this file. Inspect synchronous or awaited module-scope initialization in the file itself.";
+}
+function moduleDependencyAction(ownerFile) {
+    return `In \`${ownerFile}\`, load this dependency lazily or import a lighter entry point. Reduce its initialization work if you own it. Reuse initialized state through the module cache only within the same worker process.`;
+}
+function commandFinding(aggregate, profile) {
+    const finding = aggregateFinding("browser-command-v1", "browser-command", aggregate, profile, "Inspect the slowest retained calls and their test context. Reduce redundant calls or the work performed by each call; for wait-like commands, prefer a condition-based wait.");
+    const slowest = retainedOperationsForAggregate(profile, aggregate)[0];
+    const context = slowest ? commandContext(profile, slowest) : "";
+    const example = slowest ? ` Slowest retained call took ${formatMs(slowest.timing.wallMs)}${context}.` : "";
+    const source = formatSource(slowest?.source);
+    const registration = source ? ` It was registered at \`${source}\`.` : "";
+    finding.observation = `\`${aggregate.name}\` used ${formatMs(aggregate.totalWallMs)} across ${aggregate.count} call(s) (${formatMs(aggregate.meanWallMs)} average).${example}${registration}`;
+    if (source && slowest) {
+        finding.evidence.push({ metric: "source", value: source, operationId: slowest.id });
+    }
+    return finding;
+}
+function commandContext(profile, operation) {
+    const runnable = findAncestor(profile, operation, candidate => [
+        "test.body",
+        "test.hook",
+        "test.beforeEach.total",
+        "test.afterEach.total",
+        "worker.test-attempt",
+        "test.attempt",
+    ].includes(candidate.kind));
+    const test = runnable ? ` under \`${runnable.name}\`` : "";
+    const browser = operation.context.browserId ? ` on \`${operation.context.browserId}\`` : "";
+    return `${test}${browser}`;
+}
+function findAncestor(profile, operation, matches) {
+    let parentId = operation.parentId;
+    const visited = new Set();
+    while (parentId && !visited.has(parentId)) {
+        visited.add(parentId);
+        const parent = profile.timeline.find(candidate => candidate.id === parentId);
+        if (!parent) {
+            return;
+        }
+        if (matches(parent)) {
+            return parent;
+        }
+        parentId = parent.parentId;
+    }
+    return;
+}
+function retainedOperationsForAggregate(profile, aggregate) {
+    return profile.timeline
+        .filter(operation => operation.kind === aggregate.kind && operation.name === aggregate.name)
+        .sort((left, right) => right.timing.wallMs - left.timing.wallMs)
+        .slice(0, 3);
+}
+function formatSource(source) {
+    const location = source?.file
+        ? `${source.file}${source.line === undefined ? "" : `:${source.line}`}${source.column === undefined ? "" : `:${source.column}`}`
+        : undefined;
+    if (source?.plugin && location) {
+        return `${source.plugin} (${location})`;
+    }
+    return location ?? source?.plugin;
+}
+const dedupeByNameMaxWall = (operations) => {
+    const byName = new Map();
+    for (const operation of operations) {
+        const existing = byName.get(operation.name);
+        if (!existing || operation.timing.wallMs > existing.timing.wallMs) {
+            byName.set(operation.name, operation);
+        }
+    }
+    return [...byName.values()];
+};
+const isFrameworkModule = (modulePath) => modulePath.includes("node_modules/testplane/");
+const groupOperations = (operations, getKey) => {
+    const result = new Map();
+    for (const operation of operations) {
+        const key = getKey(operation);
+        const group = result.get(key);
+        if (group) {
+            group.push(operation);
+        }
+        else {
+            result.set(key, [operation]);
+        }
+    }
+    return result;
+};
+const operationUnionWall = (profile, aggregate) => (0, aggregator_1.unionDuration)(profile.timeline
+    .filter(operation => operation.kind === aggregate.kind && operation.name === aggregate.name)
+    .map(operation => [operation.startOffsetMs, operation.startOffsetMs + operation.timing.wallMs]));
+const durationAtConcurrency = (operations, minimumConcurrency) => {
+    const boundaries = operations
+        .flatMap(operation => [
+        { offset: operation.startOffsetMs, delta: 1 },
+        { offset: operation.startOffsetMs + operation.timing.wallMs, delta: -1 },
+    ])
+        .sort((left, right) => left.offset - right.offset || left.delta - right.delta);
+    let active = 0;
+    let previousOffset = boundaries[0]?.offset ?? 0;
+    let durationMs = 0;
+    for (const boundary of boundaries) {
+        if (active >= minimumConcurrency) {
+            durationMs += Math.max(0, boundary.offset - previousOffset);
+        }
+        active += boundary.delta;
+        previousOffset = boundary.offset;
+    }
+    return durationMs;
+};
+const metricValue = (profile, name, dimensions = {}) => profile.aggregates.metrics.find(metric => metric.name === name &&
+    Object.entries(dimensions).every(([key, value]) => metric.dimensions[key] === value))?.value;
+const sampledAggregateValue = (profile, name, field, attributes = {}) => {
+    const aggregate = findAggregate(profile, name, attributes);
+    return (aggregate?.count ?? 0) >= policy_v1_1.ANALYSIS_POLICY_V1.resources.minSamples ? aggregate?.[field] : undefined;
+};
+const findAggregate = (profile, name, attributes = {}) => profile.aggregates.byKind.find(aggregate => aggregate.kind === "metric.sample" &&
+    aggregate.name === name &&
+    Object.entries(attributes).every(([key, value]) => aggregate.attributes?.[key] === value));
+const maxAggregate = (profile, name, field, minSamples = 0) => profile.aggregates.byKind
+    .filter(aggregate => aggregate.kind === "metric.sample" && aggregate.name === name)
+    .filter(aggregate => aggregate.count >= minSamples && aggregate[field] !== undefined)
+    .sort((left, right) => (right[field] ?? 0) - (left[field] ?? 0))[0];
+const maxMetricValue = (profile, name, dimensions = {}) => {
+    const values = profile.aggregates.metrics
+        .filter(metric => metric.name === name &&
+        Object.entries(dimensions).every(([key, value]) => metric.dimensions[key] === value))
+        .map(metric => metric.value);
+    return values.length ? Math.max(...values) : undefined;
+};
+const formatMs = (milliseconds) => milliseconds >= 1000 ? `${(milliseconds / 1000).toFixed(1)}s` : `${milliseconds.toFixed(0)}ms`;
+const formatPercent = (ratio) => `${Math.round(ratio * 100)}%`;
+const capitalize = (value) => (value ? `${value[0].toUpperCase()}${value.slice(1)}` : value);
+//# sourceMappingURL=analyzers.js.map