humanish 0.128.0 → 0.130.0

package/dist/routes/computer-use/fanout-bundle.js

@@ -4,7 +4,7 @@ import { actorEnding } from "../../actors/stop-cause.js";
 import { cuaGoalSource } from "../../actors/goal-source.js";
 import { redactText } from "../../evidence/redaction.js";
 import { REVIEW_SCHEMA, bundleArtifacts, bundleHead, } from "../../run/bundle.js";
-import { aggregateTaskFunnels, formatParticipantOutcomes, formatRunTaskFunnel, gapsListClause, withCuaReviewProvenance, } from "../../run/outcomes.js";
+import { aggregateTaskFunnels, formatParticipantOutcomes, formatRunTaskFunnel, gapsListClause, skippedSentence, withCuaReviewProvenance, } from "../../run/outcomes.js";
 import { providerResourcesForOutcome, publicSafeAppUrlLabel } from "./bundle-parts.js";
 import { subjectName } from "../../run/subject-name.js";
 import { participantFeedbackCandidates } from "./participant-feedback.js";
@@ -63,12 +63,9 @@ function fanoutSummary(args, facts) {
     // A run where every participant was skipped has no one to describe in this sentence.
     if (tookPart > 0)
         sentences.push(`${plural(tookPart, "participant")} took part, ${tookPart === 1 ? "in its own copy" : "each in their own copy"} of the app: ${outcomes}${gaps}.`);
-    // The gaps are pointed at once: here only when the sentence before did not.
-    const why = gaps === "" ? "; the gaps say why" : "";
-    if (facts.skipped === 1)
-        sentences.push(`1 participant was skipped before its session started${why}.`);
-    if (facts.skipped > 1)
-        sentences.push(`${facts.skipped} participants were skipped before their sessions started${why}.`);
+    const skipped = skippedSentence(facts.skipped, gaps === "");
+    if (skipped !== "")
+        sentences.push(skipped);
     return `${host}${rerun}${sentences.join(" ")}${tasks}`;
 }
 /**

package/dist/routes/shared-world/bundle-records.js

@@ -67,7 +67,12 @@ function sharedWorldSimulation(ctx, spec, index, view) {
         mode: "browser-sim",
         progress: inProgress ? 35 : 100,
         currentStep: view.reason,
-        summary: participantSummary(name, { name: "the shared app" }, { trace: session?.trace, sessionError: outcome?.sessionError, inProgress }),
+        summary: participantSummary(name, { name: "the shared app" }, {
+            trace: session?.trace,
+            skippedReason: outcome?.skippedReason,
+            sessionError: outcome?.sessionError,
+            inProgress,
+        }),
         startedAt: args.run.createdAt,
         updatedAt: args.run.createdAt,
         ...(args.plan.arrivals.declared

package/dist/routes/shared-world/bundle.d.ts

@@ -7,6 +7,14 @@ export declare function maxSimultaneousWindows(windows: Array<{
     startedAt: number;
     endedAt: number;
 }>): number;
+/**
+ * The windows of the participants that used the app, for overlap and the live-at-once count. A
+ * participant the run skipped before its session started never used it, though its window sits
+ * inside another participant's session. run.json's laneWindows keep that window: verify expects
+ * one per declared participant, and reads overlap from them only on a pass, which a run with a
+ * skipped participant cannot reach.
+ */
+export declare function usedAppWindows(results: readonly ActorRunResult[]): ActorRunResult[];
 /**
  * The judgment for a shared-world bundle's inputs: how each participant ended, plus what the run
  * observed about its world: overlap, a state change under overlap on the provisioned plane, and

package/dist/routes/shared-world/bundle.js

@@ -16,7 +16,7 @@ import { hostOriginDigest } from "./provenance.js";
 import { participantEvent, participantIds } from "../../run/participant-records.js";
 import { sharedWorldParticipantRecords } from "./bundle-records.js";
 import { CONCURRENT_ATTRIBUTION_LIMITS, EXTERNAL_PUBLIC_ATTRIBUTION_LIMITS, } from "./types.js";
-import { gapsListClause } from "../../run/outcomes.js";
+import { gapsListClause, skippedSentence } from "../../run/outcomes.js";
 import { plural } from "../../run/text.js";
 import { describeArrivals } from "../../study/arrivals.js";
 /** Max windows live at the same instant (sweep over start/end points). The simultaneity
@@ -38,6 +38,16 @@ export function maxSimultaneousWindows(windows) {
     }
     return max;
 }
+/**
+ * The windows of the participants that used the app, for overlap and the live-at-once count. A
+ * participant the run skipped before its session started never used it, though its window sits
+ * inside another participant's session. run.json's laneWindows keep that window: verify expects
+ * one per declared participant, and reads overlap from them only on a pass, which a run with a
+ * skipped participant cannot reach.
+ */
+export function usedAppWindows(results) {
+    return results.filter((result) => result.outcome.skippedReason === undefined);
+}
 /**
  * The judgment for a shared-world bundle's inputs: how each participant ended, plus what the run
  * observed about its world: overlap, a state change under overlap on the provisioned plane, and
@@ -52,11 +62,7 @@ export function judgeSharedWorldRun(args) {
         expected: args.actorSpecs.length,
         participants: args.actorResults.map((result) => participantFactsOf(result.outcome)),
         world: {
-            // The same windows and state series the bundle writes, read by verify's pass gate too.
-            ...concurrencyFacts(args.actorSpecs.map((_spec, index) => ({
-                startedAt: args.actorResults[index]?.startedAt ?? 0,
-                endedAt: args.actorResults[index]?.endedAt ?? 0,
-            })), external ? undefined : args.stateSnapshots),
+            ...concurrencyFacts(usedAppWindows(args.actorResults), external ? undefined : args.stateSnapshots),
             ...(external ? { lobbyConvergence: args.lobbyConvergenceDigest !== undefined } : {}),
         },
     });
@@ -68,8 +74,10 @@ export function actorRunPassed(result) {
  * The run's summary in plain sentences: who took part, how many reached the goal, and what the
  * world showed. A participant reached the goal when its session passed the judge's checks and
  * ended at the goal, so a productive `budget_reached` session does not count even when the lobby
- * converged. Each participant's ending stays in `sharedWorld.outcomes`, and the plane, topology
- * and attribution limits stay in the bundle's events and `sharedWorld` block.
+ * converged. A participant the run skipped, such as a follower stopped at the handoff, never used
+ * the app, so it is counted in a sentence of its own. Each participant's ending stays in
+ * `sharedWorld.outcomes`, and the plane, topology and attribution limits stay in the bundle's
+ * events and `sharedWorld` block.
  */
 function sharedWorldSummary(args, facts) {
     const count = args.actorSpecs.length;
@@ -79,16 +87,20 @@ function sharedWorldSummary(args, facts) {
         const served = facts.external ? ", as it is deployed" : ", served from a sandbox";
         return `Dry run: ${people} would use ${app} at the same time${served}. No sandboxes were launched and $0 was spent.`;
     }
+    // The live summary is written once, before any participant starts, so it names the plan.
     if (facts.inProgress) {
-        return `${people} ${count === 1 ? "is" : "are"} using ${app} at the same time. The run is still going, so nothing here is final.`;
+        return `${people} ${count === 1 ? "is planned, in" : "are planned, all in"} ${app}. The run is still going, so nothing here is final.`;
     }
     const passed = facts.outcomes.filter((outcome) => outcome.ok);
     const reached = passed.filter((outcome) => outcome.completionReason === "goal_satisfied").length;
-    const together = facts.overlaps ? " at the same time" : ", but never at the same time";
+    const skipped = args.actorResults.filter((result) => result.outcome.skippedReason !== undefined).length;
+    const tookPart = count - skipped;
+    const together = tookPart === 1 ? "" : facts.overlaps ? " at the same time" : ", but never at the same time";
     // A participant who did not pass has a gap line; one who passed but stopped short has none.
+    const gaps = gapsListClause(tookPart - passed.length, tookPart);
     const rest = [
         passed.length > reached ? `; ${passed.length - reached} ended without reaching it` : "",
-        gapsListClause(count - passed.length, count),
+        gaps,
     ].join("");
     const world = facts.external
         ? args.lobbyConvergenceDigest
@@ -97,7 +109,15 @@ function sharedWorldSummary(args, facts) {
         : facts.deltas === 0
             ? "The app's shared state did not change during the run."
             : `The app's shared state changed ${plural(facts.deltas, "time")} during the run.`;
-    return `${people} used ${app}${together}. ${reached} of ${count} reached the goal${rest}. ${world}`;
+    return [
+        tookPart > 0
+            ? `${plural(tookPart, "participant")} used ${app}${together}. ${reached} of ${tookPart} reached the goal${rest}.`
+            : "",
+        skippedSentence(skipped, gaps === ""),
+        world,
+    ]
+        .filter((sentence) => sentence !== "")
+        .join(" ");
 }
 /** The run's first two events: its creation and the shared plane's provenance. */
 function planeEvents(args, external) {
@@ -261,7 +281,7 @@ function concurrencyReview(args, external, inProgress, evidence, events, nextEve
     // The count that matters is how many participants were live at once, which can be fewer than exist:
     // a 6-participant run capped at 3 must never read as 6-wide concurrency.
     const capForReport = plan.concurrency;
-    const maxLive = maxSimultaneousWindows(windows);
+    const maxLive = maxSimultaneousWindows(usedAppWindows(args.actorResults));
     events.push({
         id: nextEventId("concurrency"),
         at: createdAt,

package/dist/routes/shared-world/participant-specs.d.ts

@@ -12,7 +12,8 @@ export declare function resolveActorEntryUrl(baseUrl: string, entry: string | un
  *  follower joins through the real UI (a direct /lobby/CODE visit does not auto-join a non-member). */
 export declare function withLobbyCodeMission(spec: DesktopParticipantRun, code: string): DesktopParticipantRun;
 /** A follower blocked by an expired deadline or an ended host. It never opened a browser;
- * keep the actual reason rather than turning every upstream failure into a timeout. */
+ * keep the actual reason rather than turning every upstream failure into a timeout. The skip
+ * reason is a sentence in the form the computer-use skips use, since run lines and gaps print it. */
 export declare function makeBlockedFollowerOutcome(spec: DesktopParticipantRun, reason: string, timedOut: boolean): ParticipantRunOutcome;
 /**
  * A live run publishes an in-progress bundle before its participants start, whether or not an

package/dist/routes/shared-world/participant-specs.js

@@ -63,7 +63,8 @@ export function withLobbyCodeMission(spec, code) {
     };
 }
 /** A follower blocked by an expired deadline or an ended host. It never opened a browser;
- * keep the actual reason rather than turning every upstream failure into a timeout. */
+ * keep the actual reason rather than turning every upstream failure into a timeout. The skip
+ * reason is a sentence in the form the computer-use skips use, since run lines and gaps print it. */
 export function makeBlockedFollowerOutcome(spec, reason, timedOut) {
     return {
         spec,
@@ -77,7 +78,9 @@ export function makeBlockedFollowerOutcome(spec, reason, timedOut) {
         noEngagement: true,
         selfReportedBlocker: false,
         harnessError: false,
-        skippedReason: timedOut ? "handoff-timeout" : "host-ended-before-handoff",
+        skippedReason: timedOut
+            ? "skipped: the host did not reach a lobby within the handoff deadline; no desktop was created"
+            : "skipped: the host ended before it reached a lobby; no desktop was created",
     };
 }
 /**

package/dist/routes/shared-world/result.js

@@ -8,7 +8,7 @@ import { validatePreparedRunArtifactPaths } from "../../run/paths.js";
 import { participantExecutionFailures, participantFactsOf, } from "../computer-use/participant-facts.js";
 import { participantCapWarning } from "../computer-use/participant-model.js";
 import { resolveSubjectState } from "../computer-use/subject-projection.js";
-import { actorRunPassed, buildConcurrentSharedWorldBundle, judgeSharedWorldRun, maxSimultaneousWindows, } from "./bundle.js";
+import { actorRunPassed, buildConcurrentSharedWorldBundle, judgeSharedWorldRun, maxSimultaneousWindows, usedAppWindows, } from "./bundle.js";
 import { planeStateOf } from "./plan.js";
 import { buildSubjectProvenance, hostOriginDigest } from "./provenance.js";
 import {} from "./types.js";
@@ -47,9 +47,16 @@ function concurrentParticipantResults(actorSpecs, actorResults, dryRun) {
         }
         const session = result.outcome.session;
         const thisOk = participantOk(result);
+        const { skippedReason } = result.outcome;
+        // The same judged record run.json writes, so the run line and the bundle name one status.
+        const record = judgeParticipantRecords([participantFactsOf(result.outcome)], {
+            sessionLabel: "Participant",
+            missingSessionMessage: "Actor did not produce a terminal session.",
+        }).participants[0];
         return {
             ...base,
-            status: session ? session.status : "failed",
+            status: record.status,
+            ...(skippedReason === undefined ? {} : { skippedReason }),
             ok: thisOk,
             window: { startedAt: result.startedAt, endedAt: result.endedAt },
             ...(session
@@ -70,10 +77,7 @@ function concurrentParticipantResults(actorSpecs, actorResults, dryRun) {
                 : {
                     error: {
                         code: "HUMANISH_SHARED_WORLD_FAILED",
-                        message: judgeParticipantRecords([participantFactsOf(result.outcome)], {
-                            sessionLabel: "Participant",
-                            missingSessionMessage: "Actor did not produce a terminal session.",
-                        }).participants[0].notPassedMessage,
+                        message: record.notPassedMessage,
                     },
                 }),
         };
@@ -306,7 +310,9 @@ export async function finishConcurrentRun(ctx, live, results, plane) {
             ? {}
             : { subjectSandbox: { sandboxId: subjectSandboxId, killed: subjectKilled } }),
         ...(dryRun ? {} : { overlapProven }),
-        ...(dryRun ? {} : { maxSimultaneousLanes: maxSimultaneousWindows(actorResults) }),
+        ...(dryRun
+            ? {}
+            : { maxSimultaneousLanes: maxSimultaneousWindows(usedAppWindows(actorResults)) }),
         subject,
         roles: participantResults,
         observer,

package/dist/routes/shared-world/types.d.ts

@@ -94,6 +94,8 @@ export interface ConcurrentSharedWorldParticipantResult {
         sandboxIdDigest?: string;
         killed: boolean;
     };
+    /** Set when the run skipped the participant before its session started (status `blocked`). */
+    skippedReason?: string;
     error?: {
         code: ConcurrentSharedWorldStudyErrorCode;
         message: string;

package/dist/run/bundle-shape.d.ts

@@ -1,6 +1,6 @@
-import { type ReviewSummary, type RunAdapterScore, type RunBundle, type RunOutcome } from "./bundle.js";
+import { type ReviewSummary, type RunAdapterScore, type StoredRunBundle, type RunOutcome } from "./bundle.js";
 import { type StoredCleanupResult, type RunPointer } from "./results.js";
-export declare function isRunBundle(value: unknown): value is RunBundle;
+export declare function isRunBundle(value: unknown): value is StoredRunBundle;
 /** run.json's `outcome`: a finished run's ok and execution outcome, or the signal that stopped it. */
 export declare function isRunOutcome(value: unknown): value is RunOutcome;
 export declare function isCleanupResult(value: unknown): value is StoredCleanupResult;

package/dist/run/bundle.d.ts

@@ -4,7 +4,7 @@ import type { ExecutionOutcome } from "./judge.js";
 import type { SharedWorldEvidence } from "./shared-world-evidence.js";
 import { type RunStudyProvenance } from "./study-provenance.js";
 import type { RunInterruptSignal } from "./status.js";
-import type { RunSimulationStatus, RunStream, RunStreamKind } from "./streams.js";
+import type { RunSimulationStatus, RunStream, RunStreamKind, StoredRunStream } from "./streams.js";
 /**
  * The run bundle version this release writes: each stream's trace, and each running participant's
  * items so far, are files run.json indexes, and each participant's per-request lists are only in
@@ -388,6 +388,13 @@ export interface RunBundle {
      */
     cost?: RunCostSummary;
 }
+/**
+ * run.json as a reader parses it, in any version: each stream a StoredRunStream, without the
+ * per-request lists that from v4 only its trace file holds. loadStreamTraces gives the RunBundle.
+ */
+export type StoredRunBundle = Omit<RunBundle, "streams"> & {
+    streams: StoredRunStream[];
+};
 /**
  * How a run ended. `finished`: Run.finish published the final bundle with the route result's `ok`
  * and its execution outcome (`judgeExecution` in src/run/judge.ts). `interrupted`: the CLI's signal

package/dist/run/detail.js

@@ -119,7 +119,10 @@ function costOf(trace, rowsLoaded) {
  * items run.json or a file supplied for it.
  */
 async function displayedStreams(runPaths, streams, bundle) {
-    const loaded = await loadStreamTraces(runPaths, { ...bundle, streams });
+    const loaded = await loadStreamTraces(runPaths, {
+        ...bundle,
+        streams,
+    });
     return displayedTraces(loaded).streams;
 }
 /**

package/dist/run/outcomes.d.ts

@@ -53,6 +53,13 @@ interface SummarySession {
 export declare function participantSummary(name: string, app: SummaryApp, session: SummarySession): string;
 /** "; the gaps list the other 2", or "all 3" when nobody passed. Empty when the gaps list nobody. */
 export declare function gapsListClause(listed: number, total: number): string;
+/**
+ * The sentence that counts the participants a run skipped before their sessions started, or ""
+ * when it skipped none. A skipped participant never used the app, so a summary counts it here and
+ * leaves it out of the sentence about those that took part. `pointAtGaps` is false when that
+ * sentence already points at the gaps.
+ */
+export declare function skippedSentence(skipped: number, pointAtGaps: boolean): string;
 /** One line a stakeholder can read, with the denominator attached to every number. */
 export declare function formatParticipantOutcomes(outcomes: ParticipantOutcomes, terminalCauses?: readonly ParticipantOutcomeDetail[]): string;
 /** Presentation details tolerate optional legacy actor payloads without changing their tallies. */

package/dist/run/outcomes.js

@@ -206,6 +206,20 @@ export function gapsListClause(listed, total) {
         return `; the gaps list the other ${listed}`;
     return total === 1 ? "; the gaps say why" : `; the gaps list all ${total}`;
 }
+/**
+ * The sentence that counts the participants a run skipped before their sessions started, or ""
+ * when it skipped none. A skipped participant never used the app, so a summary counts it here and
+ * leaves it out of the sentence about those that took part. `pointAtGaps` is false when that
+ * sentence already points at the gaps.
+ */
+export function skippedSentence(skipped, pointAtGaps) {
+    const why = pointAtGaps ? "; the gaps say why" : "";
+    if (skipped === 1)
+        return `1 participant was skipped before its session started${why}.`;
+    if (skipped > 1)
+        return `${skipped} participants were skipped before their sessions started${why}.`;
+    return "";
+}
 /** One line a stakeholder can read, with the denominator attached to every number. */
 export function formatParticipantOutcomes(outcomes, terminalCauses = []) {
     if (outcomes.total === 0)

package/dist/run/participant-records.d.ts

@@ -21,7 +21,7 @@ export declare function participantEvent(ids: ParticipantIds, event: Omit<RunEve
 /** The ids a provider resource saves for the participant whose sandbox it is. */
 export declare function participantResourceIds(ids: ParticipantIds, participantId: string): Required<Pick<RunProviderResource, "simId" | "streamId" | "laneId">>;
 /** The record id a saved stream belongs to. */
-export declare function recordIdOf(stream: RunStream): string;
+export declare function recordIdOf(stream: Pick<RunStream, "simId">): string;
 /** The record id a saved event names, when it names one. */
 export declare function eventRecordIdOf(event: RunEvent): string | undefined;
 /** The participant id an adapter recorded on a saved stream (a fan-out `lane-NN` id), when it has one. */

package/dist/run/stream-shape.d.ts

@@ -1,5 +1,5 @@
-import { type RunSimulationStatus, type RunStream, type RunStreamKind, type StreamTraceIndex } from "./streams.js";
-export declare function isRunStream(value: unknown): value is RunStream;
+import { type RunSimulationStatus, type RunStream, type RunStreamKind, type StoredRunStream, type StreamTraceIndex } from "./streams.js";
+export declare function isRunStream(value: unknown): value is StoredRunStream;
 export declare function isRunStreamArtifact(value: unknown): value is RunStream["artifacts"][number];
 /**
  * The trace file names the run writer produces: actor.json for one participant,

package/dist/run/stream-trace.d.ts

@@ -1,14 +1,23 @@
-import { type RunBundle } from "./bundle.js";
+import { type RunBundle, type StoredRunBundle } from "./bundle.js";
 import { type PreparedOutputRoot } from "./contained-output.js";
 import { type LiveItemsCursor } from "./live-items.js";
-import type { LiveItemsIndex, RunStream } from "./streams.js";
-/** A trace that does not match its index, or cannot be read. The message names the stream. */
+import type { LiveItemsIndex, RunStream, StoredRunStream, WithoutRequestLists } from "./streams.js";
+/**
+ * A trace that does not match its index, or cannot be read. The message names the stream, and ends
+ * with `advice`: by default, restore the run folder from a copy.
+ */
 export declare class StreamTraceRefusedError extends Error {
     readonly streamId: string;
-    constructor(streamId: string, detail: string);
+    constructor(streamId: string, detail: string, advice?: string);
+}
+/**
+ * A trace or live file whose index records more than the loader reads of one file. The loader reads
+ * no file past the limit, so a copy of the file is refused too.
+ */
+export declare class StreamTraceTooLargeError extends StreamTraceRefusedError {
 }
 /** `trace` without the per-request lists; every other field as it is. */
-export declare function withoutRequestLists<T extends object>(trace: T): T;
+export declare function withoutRequestLists<T extends object>(trace: T): WithoutRequestLists<T>;
 /**
  * The run.json the run writes, and the trace files it writes first. Each stream with a finished
  * actor keeps that actor without `items` and the per-request lists, its artifacts other than
@@ -18,7 +27,7 @@ export declare function withoutRequestLists<T extends object>(trace: T): T;
  * run.json held beside it. A running participant's live actor is written by liveSummary.
  */
 export declare function splitStreamTraces(bundle: RunBundle): {
-    bundle: RunBundle;
+    bundle: StoredRunBundle;
     files: {
         path: string;
         bytes: Buffer;
@@ -39,13 +48,22 @@ export type TraceFileReader = (relativePath: string, maxBytes: number, length?:
 }>;
 /**
  * A live file the loader joined into stream `streamId`: the index it read the items by, and the
- * cursor it read past when the stream holds only the items after one.
+ * cursor it read past when the stream holds only the items after one. A read with `stopped` has
+ * an index that records more than the loader reads of one file, so it read nothing and joined no
+ * items past `after`, which it always has; `stopped` is the warning a reader that shows the run
+ * gives.
  */
-export interface LiveItemsRead {
+export type LiveItemsRead = {
     streamId: string;
     index: LiveItemsIndex;
     after?: LiveItemsCursor;
-}
+    stopped?: undefined;
+} | {
+    streamId: string;
+    index: LiveItemsIndex;
+    after: LiveItemsCursor;
+    stopped: string;
+};
 /** For a live file's index, the prefix of that file the caller holds already, if any. */
 type LiveAfter = (index: LiveItemsIndex) => LiveItemsCursor | undefined;
 /**
@@ -53,10 +71,11 @@ type LiveAfter = (index: LiveItemsIndex) => LiveItemsCursor | undefined;
  * stream without an index is returned as it is (a v1 stream, or one with no actor). An indexed
  * stream's file must have a trace file name (isStreamTracePath); it is read under `maxBytes` and
  * checked against the index's byte count, sha256, item count and screenshot count, and any
- * difference throws StreamTraceRefusedError. The rules that need the whole bundle (an unindexed v2
+ * difference throws StreamTraceRefusedError. An index that records more than `maxBytes` throws
+ * before the file is read. The rules that need the whole bundle (an unindexed v2
  * actor, two participants indexing one file) are loadStreamTraces'.
  */
-export declare function loadStreamTrace(runPaths: PreparedOutputRoot, stream: RunStream, maxBytes?: number): Promise<RunStream>;
+export declare function loadStreamTrace(runPaths: PreparedOutputRoot, stream: StoredRunStream, maxBytes?: number): Promise<RunStream>;
 /**
  * Whether a run.json of `schema` holds the per-request lists (REQUEST_LISTS) the writer kept in
  * it: v1 to v3, and a schema WRITER_RULES does not name, which is read as v1. From v4 they are
@@ -80,14 +99,16 @@ interface LoadedTraces {
  * `liveAfter` names, for a live file's index, the prefix the caller holds already (the Observer
  * feed's cursor). The loader then reads and joins only the items past it, checked by liveItemsAfter
  * without the indexed sha256, and `live` records the cursor; a cursor past the index or off the
- * file's lines gets the whole prefix, checked as always.
+ * file's lines gets the whole prefix, checked as always. A live file whose index records more than
+ * `maxBytes` is not read: for a cursor that fits the index the stream gets no items past it and
+ * `live` records `stopped`, and without one the stream is refused.
  *
  * A live file that cannot be read may have been removed by the writer after `bundle` was read: it
  * removes a superseded generation once run.json names the next one, and every live file once the
  * run finished. The loader then reads run.json again, once, through the same reader, and loads
  * that bundle instead when it is a run bundle of the same run.
  */
-export declare function loadStreamTraces(source: PreparedOutputRoot | TraceFileReader, bundle: RunBundle, options?: {
+export declare function loadStreamTraces(source: PreparedOutputRoot | TraceFileReader, bundle: StoredRunBundle, options?: {
     maxBytes?: number;
     onTrace?: (path: string, bytes: Buffer) => void;
     liveAfter?: LiveAfter;
@@ -97,12 +118,22 @@ export declare function loadStreamTraces(source: PreparedOutputRoot | TraceFileR
  * summary, shows none of the items or per-request lists run.json or a file supplied for it (its
  * actor's items and lists, its in-progress items, its screenshot entries), and carries
  * `traceUnavailable` with the reason; a warn event on its timeline says the same. A reader that
- * shows the run then never prices or checks rows the loader refused.
+ * shows the run then never prices or checks rows the loader refused. A live file the loader
+ * stopped reading (LiveItemsRead's `stopped`) gives its stream a `live-items.not-read` warn event.
  */
 export declare function displayedTraces(loaded: {
     bundle: RunBundle;
     refused: readonly StreamTraceRefusedError[];
+    live?: readonly LiveItemsRead[];
 }): RunBundle;
+/**
+ * What `reduce` returns for each stream of the bundle, loaded as loadRunTraces loads it, in stream
+ * order; the first refusal throws. Streams are loaded one at a time and nothing of a stream's files
+ * is kept past its `reduce` call, so a caller that keeps part of each trace holds one trace at a
+ * time where loadRunTraces holds them all. Unlike loadStreamTraces it does not read run.json again
+ * when a live file cannot be read, so it suits a run whose participants have finished.
+ */
+export declare function reduceRunTraces<T>(runPaths: PreparedOutputRoot, bundle: StoredRunBundle, reduce: (stream: RunStream, index: number) => T): Promise<T[]>;
 /** The bundle with every stream loaded; the first refusal throws. */
-export declare function loadRunTraces(source: PreparedOutputRoot | TraceFileReader, bundle: RunBundle, maxBytes?: number): Promise<RunBundle>;
+export declare function loadRunTraces(source: PreparedOutputRoot | TraceFileReader, bundle: StoredRunBundle, maxBytes?: number): Promise<RunBundle>;
 export {};