ccqa 1.43.0 → 1.44.0

package/dist/bin/ccqa.mjs

@@ -4,7 +4,7 @@ import { t as EVIDENCE_DIR_ENV } from "../evidence-constants-C425F7ZG.mjs";
 import { a as formatAgentBrowserUnavailableMessage, i as assertAgentBrowserAvailable, n as spawnAB, o as pathWithAgentBrowserShim, r as AgentBrowserUnavailableError, s as resolveAgentBrowserBin$1, t as sleepSync } from "../spawn-ab-Bm34WBui.mjs";
 import { createRequire } from "node:module";
 import { Command } from "commander";
-import { accessSync, appendFileSync, createWriteStream, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { accessSync, appendFileSync, createReadStream, createWriteStream, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { createCipheriv, createDecipheriv, createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { access, appendFile, chmod, cp, mkdir, mkdtemp, open, readFile, readdir, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
@@ -11986,6 +11986,14 @@ async function resolveCoverageRoots(changed, cwd) {
 */
 const MAX_REPORT_RUNS = 20;
 /**
+* How many reads one source keeps in flight. The two sources run together, so
+* the hub sees twice this. All at once is what it cannot take: it serves one
+* process, a resolve walks the whole event stream, and a report carries its
+* screenshots inline — forty of those together is what took it down, rather
+* than any single one of them.
+*/
+const HUB_READ_CONCURRENCY = 4;
+/**
 * Read every spec's most recent measured reach from the hub. Never throws: a
 * source that cannot be read warns, and `degraded` flips when the failure
 * leaves absence ambiguous (the ledger itself, or the legacy sources while
@@ -12053,8 +12061,14 @@ async function collectStreamEdges(input, merge) {
 	const { hub, project } = input;
 	const latest = await hub.getCoverage(project);
 	ingestResolved(latest.resolved, merge);
-	const older = latest.runIds.filter((runId) => runId !== latest.resolved?.runId);
-	return (await Promise.allSettled(older.map(async (runId) => ingestResolved((await hub.getCoverage(project, { runId })).resolved, merge)))).filter((r) => r.status === "rejected").length;
+	return (await runPool(latest.runIds.filter((runId) => runId !== latest.resolved?.runId), HUB_READ_CONCURRENCY, async (runId) => {
+		try {
+			ingestResolved((await hub.getCoverage(project, { runId })).resolved, merge);
+			return true;
+		} catch {
+			return false;
+		}
+	})).filter((ok) => !ok).length;
 }
 function ingestResolved(resolved, merge) {
 	if (!resolved) return;
@@ -12086,7 +12100,7 @@ const ReportCoverageRowsSchema = z.object({ results: z.array(z.object({
 */
 async function collectReportEdges(input, merge) {
 	const { hub, project } = input;
-	const eligible = (await hub.listRuns({
+	return (await runPool((await hub.listRuns({
 		project,
 		kind: "run",
 		limit: MAX_REPORT_RUNS
@@ -12098,18 +12112,22 @@ async function collectReportEdges(input, merge) {
 			id: run.id,
 			measuredAt
 		}];
-	});
-	return (await Promise.allSettled(eligible.map(async ({ id, measuredAt }) => {
-		const parsed = ReportCoverageRowsSchema.safeParse(await hub.getReport(id));
-		if (!parsed.success) return;
-		for (const row of parsed.data.results) {
-			if (!row.coverage || row.coverage.files.length === 0) continue;
-			merge(`${row.feature}/${row.spec}`, {
-				files: row.coverage.files,
-				measuredAt
-			});
+	}), HUB_READ_CONCURRENCY, async ({ id, measuredAt }) => {
+		try {
+			const parsed = ReportCoverageRowsSchema.safeParse(await hub.getReport(id));
+			if (!parsed.success) return true;
+			for (const row of parsed.data.results) {
+				if (!row.coverage || row.coverage.files.length === 0) continue;
+				merge(`${row.feature}/${row.spec}`, {
+					files: row.coverage.files,
+					measuredAt
+				});
+			}
+			return true;
+		} catch {
+			return false;
 		}
-	}))).filter((r) => r.status === "rejected").length;
+	})).filter((ok) => !ok).length;
 }
 //#endregion
 //#region src/select/inventory.ts
@@ -12224,6 +12242,27 @@ function foldTouchIndex(current, entry, selection) {
 	}
 	return out;
 }
+//#endregion
+//#region src/coverage/resolve-stream.ts
+/**
+* One run's answer out of a project's stored event stream (ADR-0022).
+*
+* The stream interleaves many runs and two producers; this is the single
+* shared interpretation over it — the same gate, join and loss accounting the
+* run-local sink applies, executed at read time by whichever host asks (the
+* hub's API, or the CLI). Everything here is a pure fold over the stamps the
+* events carry: no clock is ever read, so the same stream resolves to the
+* same answer on any host, at any time.
+*/
+/**
+* How far past a run's last marker an application push still counts as its
+* audience (ms). The run-local sink keeps listening while a spec settles, so
+* the work a spec's last action triggered still lands; a stored stream has no
+* listener to wait, so the resolve re-creates that patience as a fixed bound.
+* Pushes past it were heard by nobody bound to this run — most likely they
+* belong to whatever run came next.
+*/
+const GRACE_MS = 3e4;
 z.object({
 	runId: z.string(),
 	hubRunId: z.string().optional(),
@@ -12261,88 +12300,109 @@ function formatResolvedSpec(spec) {
 	return `${spec.specId}: ${spec.files.length} file(s)${actors ? ` (${actors})` : ""}`;
 }
 /**
-* Interprets `runId`'s view of the stream.
+* `runId`'s view of the stream, built one event at a time.
 *
-* Two passes, because the resolver needs its context up front: the first
+* Two passes, because the resolver needs its context up front. The first
 * collects what the run's own markers establish — which ids it issued, which
 * identity tags were its to hand out, its universe, and when its first and
-* last marker arrived. The second replays the stream through the shared
-* resolver: this run's window markers as they came, and every application
-* push — as-is when its stamp falls inside the span the run's sink would
-* have been listening (first marker to last marker plus `GRACE_MS`),
-* stripped of its spec and actor attribution when it does not. A push
-* outside the span was another run's audience, so its attribution is not
-* this run's to claim — but the collector never re-sends what an earlier
-* run acked, so on an always-on hub the boot set and each process's health
-* figures arrived long before this run began, and only survive here.
-*/
-function resolveStream(events, runId) {
-	const issued = /* @__PURE__ */ new Set();
-	const specOrder = [];
-	const tagToKey = /* @__PURE__ */ new Map();
-	const browserFiles = /* @__PURE__ */ new Map();
-	let universe;
-	let hubRunId;
-	let firstMarkerAt;
-	let lastMarkerAt = 0;
-	for (const event of events) {
-		const body = event.body;
-		if (!("kind" in body) || body.runId !== runId) continue;
-		if (firstMarkerAt === void 0) firstMarkerAt = event.at;
-		lastMarkerAt = event.at;
-		switch (body.kind) {
-			case "spec-open":
-				if (!issued.has(body.specId)) {
-					issued.add(body.specId);
-					specOrder.push(body.specId);
+* last marker arrived; markers are a small part of a stream, so a caller can
+* hold them. The second replays the stream through the shared resolver: this
+* run's window markers as they came, and every application push — as-is when
+* its stamp falls inside the span the run's sink would have been listening
+* (first marker to last marker plus `GRACE_MS`), stripped of its spec and
+* actor attribution when it does not. A push outside the span was another
+* run's audience, so its attribution is not this run's to claim — but the
+* collector never re-sends what an earlier run acked, so on an always-on hub
+* the boot set and each process's health figures arrived long before this run
+* began, and only survive here.
+*
+* The constructor takes the markers and `accept` takes one event at a time, so
+* the second pass can be fed from a stream: it keeps nothing per push, which
+* is what lets a resolve outlive the point where the stream stops fitting in
+* memory.
+*/
+var StreamResolution = class {
+	runId;
+	resolver;
+	/** The ids this run opened, in that order — a `Set` iterates by insertion. */
+	specIds;
+	browserFiles = /* @__PURE__ */ new Map();
+	/**
+	* The stamps in which the run's sink would have been listening. Undefined
+	* when the markers held no event of this run — then no push is ever inside.
+	*/
+	span;
+	universe;
+	hubRunId;
+	asOf = 0;
+	lastSeq = 0;
+	pushesDuringRun = 0;
+	/** `markers` needs to hold every marker event of the stream; pushes are ignored here. */
+	constructor(markers, runId) {
+		this.runId = runId;
+		const specIds = /* @__PURE__ */ new Set();
+		const tagToKey = /* @__PURE__ */ new Map();
+		let firstAt;
+		let lastAt = 0;
+		for (const event of markers) {
+			const body = event.body;
+			if (!("kind" in body) || body.runId !== runId) continue;
+			if (firstAt === void 0) firstAt = event.at;
+			lastAt = event.at;
+			switch (body.kind) {
+				case "spec-open":
+					specIds.add(body.specId);
+					break;
+				case "window-open":
+					tagToKey.set(body.tag, body.key);
+					break;
+				case "universe":
+					this.universe = {
+						include: body.include,
+						files: body.files
+					};
+					break;
+				case "run-link":
+					this.hubRunId = body.hubRunId;
+					break;
+				case "browser": {
+					const files = this.browserFiles.get(body.specId) ?? /* @__PURE__ */ new Set();
+					for (const file of body.files) files.add(file);
+					this.browserFiles.set(body.specId, files);
+					break;
 				}
-				break;
-			case "window-open":
-				tagToKey.set(body.tag, body.key);
-				break;
-			case "universe":
-				universe = {
-					include: body.include,
-					files: body.files
-				};
-				break;
-			case "run-link":
-				hubRunId = body.hubRunId;
-				break;
-			case "browser": {
-				const files = browserFiles.get(body.specId) ?? /* @__PURE__ */ new Set();
-				for (const file of body.files) files.add(file);
-				browserFiles.set(body.specId, files);
-				break;
 			}
 		}
+		this.specIds = specIds;
+		this.span = firstAt === void 0 ? void 0 : {
+			from: firstAt,
+			until: lastAt + GRACE_MS
+		};
+		this.resolver = new CoverageResolver(specIds, tagToKey);
 	}
-	const resolver = new CoverageResolver(issued, tagToKey);
-	let asOf = 0;
-	let lastSeq = 0;
-	let pushesDuringRun = 0;
-	for (const event of events) {
-		if (event.seq > lastSeq) lastSeq = event.seq;
+	/** One event of the second pass. Every event of the stream, in stamp order. */
+	accept(event) {
+		if (event.seq > this.lastSeq) this.lastSeq = event.seq;
 		const body = event.body;
 		if ("kind" in body) {
-			if (body.runId !== runId) continue;
-			asOf = event.at;
-			if (body.kind === "window-open") resolver.apply({
+			if (body.runId !== this.runId) return;
+			this.asOf = event.at;
+			if (body.kind === "window-open") this.resolver.apply({
 				kind: "window-open",
 				at: event.at,
 				tag: body.tag,
 				key: body.key,
 				specId: body.specId
 			});
-			else if (body.kind === "window-close") resolver.apply({
+			else if (body.kind === "window-close") this.resolver.apply({
 				kind: "window-close",
 				at: event.at,
 				tag: body.tag
 			});
-			continue;
+			return;
 		}
-		if (firstMarkerAt === void 0 || event.at < firstMarkerAt || event.at > lastMarkerAt + 3e4) {
-			resolver.apply({
+		if (this.span === void 0 || event.at < this.span.from || event.at > this.span.until) {
+			this.resolver.apply({
 				kind: "push",
 				at: event.at,
 				push: {
@@ -12351,49 +12411,52 @@ function resolveStream(events, runId) {
 					actors: []
 				}
 			});
-			continue;
+			return;
 		}
-		asOf = event.at;
-		pushesDuringRun++;
-		resolver.apply({
+		this.asOf = event.at;
+		this.pushesDuringRun++;
+		this.resolver.apply({
 			kind: "push",
 			at: event.at,
 			push: body
 		});
 	}
-	const specs = specOrder.map((specId) => {
-		const actorEvents = {};
-		for (const [key, count] of resolver.actorEventsFor(specId)) actorEvents[key] = count;
+	/** The answer as of every event accepted so far. */
+	finish() {
+		const specs = [...this.specIds].map((specId) => {
+			const actorEvents = {};
+			for (const [key, count] of this.resolver.actorEventsFor(specId)) actorEvents[key] = count;
+			return {
+				specId,
+				files: [...new Set([...this.resolver.filesFor(specId) ?? [], ...this.browserFiles.get(specId) ?? []])].sort(),
+				actorEvents
+			};
+		});
+		const outsideWindowEvents = {};
+		for (const [key, count] of this.resolver.outsideWindowEvents()) outsideWindowEvents[key] = count;
 		return {
-			specId,
-			files: [...new Set([...resolver.filesFor(specId) ?? [], ...browserFiles.get(specId) ?? []])].sort(),
-			actorEvents
+			runId: this.runId,
+			...this.hubRunId !== void 0 ? { hubRunId: this.hubRunId } : {},
+			asOf: this.asOf,
+			lastSeq: this.lastSeq,
+			...this.universe !== void 0 ? { universe: this.universe } : {},
+			specs,
+			boot: [...this.resolver.boot()].sort(),
+			health: {
+				heardFromApplication: this.resolver.heardFromApplication(),
+				pushesDuringRun: this.pushesDuringRun,
+				attributedSpecs: this.resolver.attributedSpecs(),
+				rejectedPushes: this.resolver.rejectedPushes(),
+				uninstrumentedFiles: this.resolver.uninstrumentedFiles(),
+				uninstrumentedProcesses: this.resolver.uninstrumentedProcesses(),
+				droppedPushes: this.resolver.droppedPushes(),
+				unmappedActorEvents: this.resolver.unmappedActorEvents(),
+				outsideWindowEvents,
+				specsMeasured: specs.length
+			}
 		};
-	});
-	const outsideWindowEvents = {};
-	for (const [key, count] of resolver.outsideWindowEvents()) outsideWindowEvents[key] = count;
-	return {
-		runId,
-		...hubRunId !== void 0 ? { hubRunId } : {},
-		asOf,
-		lastSeq,
-		...universe !== void 0 ? { universe } : {},
-		specs,
-		boot: [...resolver.boot()].sort(),
-		health: {
-			heardFromApplication: resolver.heardFromApplication(),
-			pushesDuringRun,
-			attributedSpecs: resolver.attributedSpecs(),
-			rejectedPushes: resolver.rejectedPushes(),
-			uninstrumentedFiles: resolver.uninstrumentedFiles(),
-			uninstrumentedProcesses: resolver.uninstrumentedProcesses(),
-			droppedPushes: resolver.droppedPushes(),
-			unmappedActorEvents: resolver.unmappedActorEvents(),
-			outsideWindowEvents,
-			specsMeasured: specs.length
-		}
-	};
-}
+	}
+};
 /**
 * Every run that opened a spec in this stream, most recently heard-from
 * first — recency by the arrival position of each run's latest spec-open,
@@ -23432,7 +23495,9 @@ function createAppendCoverageEventHandler(config) {
 }
 /**
 * GET /api/v1/coverage/events?project=&sinceSeq= — the stream after `sinceSeq`
-* (exclusive, so a consumer passes back the `lastSeq` it saw), decrypted.
+* (exclusive), decrypted, at most `MAX_EVENTS_PER_READ` of them. A consumer
+* passes back the `seq` of the last event it received; `lastSeq` is the
+* stream's head, which `truncated` says the body stopped short of.
 * Hub bearer token only (the server's central check): what the append-only
 * credential wrote, it must not be able to read back.
 */
@@ -23441,33 +23506,51 @@ function createGetCoverageEventsHandler(config) {
 		const key = requireKey(config);
 		const project = requireProjectParam(ctx);
 		const sinceSeq = requireSinceSeqParam(ctx.url);
-		sendJson(ctx.res, 200, await readStream(config, key, project, sinceSeq));
+		const events = [];
+		let truncated = false;
+		const { lastSeq, skipped } = await scanStream(config, key, project, sinceSeq, (event) => {
+			if (events.length < MAX_EVENTS_PER_READ) events.push(event);
+			else truncated = true;
+		});
+		sendJson(ctx.res, 200, {
+			events,
+			lastSeq,
+			skipped,
+			truncated
+		});
 	};
 }
-/** The stored stream after `sinceSeq` (exclusive), decrypted and parsed. */
-async function readStream(config, key, project, sinceSeq) {
-	const { entries, lastSeq, skipped } = await config.store.read(project, sinceSeq);
-	const events = [];
+/**
+* Hand each event after `sinceSeq` (exclusive) to `visit`, decrypted and
+* parsed. Nothing is retained here: what a caller keeps is its own choice,
+* which is what lets a whole-stream read stay bounded.
+*/
+async function scanStream(config, key, project, sinceSeq, visit) {
 	let unreadable = 0;
-	for (const entry of entries) try {
-		const plain = decrypt(decodeEncryptedBlob(entry.payload), key);
-		const body = InboxBodySchema.parse(JSON.parse(new TextDecoder().decode(plain)));
-		events.push({
-			seq: entry.seq,
-			at: entry.at,
-			body
-		});
-	} catch {
-		unreadable += 1;
-	}
+	const { lastSeq, skipped } = await config.store.scan(project, sinceSeq, (entry) => {
+		let event;
+		try {
+			const plain = decrypt(decodeEncryptedBlob(entry.payload), key);
+			event = {
+				seq: entry.seq,
+				at: entry.at,
+				body: InboxBodySchema.parse(JSON.parse(new TextDecoder().decode(plain)))
+			};
+		} catch {
+			unreadable += 1;
+			return;
+		}
+		visit(event);
+	});
 	return {
-		events,
 		lastSeq,
 		skipped: skipped + unreadable
 	};
 }
 /** Newest runs the resolve read offers; past twenty the answer is history nobody pages through. */
 const RUN_IDS_LIMIT = 20;
+/** How many events one `GET /events` body carries; past it the answer is `truncated`. */
+const MAX_EVENTS_PER_READ = 5e3;
 /** Resolved answers kept per handler; one page polls one key, so a handful covers the readers. */
 const RESOLVE_CACHE_LIMIT = 8;
 /**
@@ -23524,14 +23607,27 @@ function createResolveCoverageHandler(config) {
 			sendJson(ctx.res, 200, hit);
 			return;
 		}
-		const { events, lastSeq } = await readStream(config, key, project, 0);
-		const runIds = listRunIds(events).slice(0, RUN_IDS_LIMIT);
+		const markers = [];
+		let seen = 0;
+		const first = await scanStream(config, key, project, 0, (event) => {
+			seen += 1;
+			if ("kind" in event.body) markers.push(event);
+		});
+		const runIds = listRunIds(markers).slice(0, RUN_IDS_LIMIT);
 		const runId = runKey !== "" ? runKey : runIds[0];
+		let resolved = null;
+		if (runId !== void 0 && seen > 0) {
+			const resolution = new StreamResolution(markers, runId);
+			await scanStream(config, key, project, 0, (event) => {
+				if (event.seq <= first.lastSeq) resolution.accept(event);
+			});
+			resolved = resolution.finish();
+		}
 		const answer = {
-			resolved: runId === void 0 || events.length === 0 ? null : resolveStream(events, runId),
+			resolved,
 			runIds
 		};
-		memo.put(project, runKey, lastSeq, answer);
+		memo.put(project, runKey, first.lastSeq, answer);
 		sendJson(ctx.res, 200, answer);
 	};
 }
@@ -31168,7 +31264,7 @@ function createFileCoverageEventStore(root, caps) {
 			oldestAt: null,
 			endsWithNewline: raw === "" || raw.endsWith("\n")
 		};
-		for (const rawLine of nonEmptyLines(raw)) {
+		for (const rawLine of raw.split("\n")) {
 			const line = parseLine(rawLine);
 			if (line === null) continue;
 			if (line.seq >= state.nextSeq) state.nextSeq = line.seq + 1;
@@ -31224,19 +31320,17 @@ function createFileCoverageEventStore(root, caps) {
 				return stamp;
 			});
 		},
-		async read(project, sinceSeq) {
+		async scan(project, sinceSeq, visit) {
 			assertSafeName(project, "project");
 			const path = coverageEventsPath(root, project);
 			const now = Date.now();
 			await serialize(path, async () => {
 				await pruneIfDue(project, path, await loadState(project, path), now);
 			});
-			const raw = await readRaw(path);
 			const cutoff = now - retentionMs;
-			const entries = [];
 			let lastSeq = 0;
 			let skipped = 0;
-			for (const rawLine of nonEmptyLines(raw)) {
+			for await (const rawLine of streamLines(path)) {
 				const line = parseLine(rawLine);
 				if (line === null) {
 					skipped += 1;
@@ -31245,15 +31339,13 @@ function createFileCoverageEventStore(root, caps) {
 				if (line.seq > lastSeq) lastSeq = line.seq;
 				if (line.seq <= sinceSeq) continue;
 				if (line.at < cutoff) continue;
-				entries.push({
+				visit({
 					seq: line.seq,
 					at: line.at,
 					payload: new Uint8Array(Buffer.from(line.payload, "base64"))
 				});
 			}
-			entries.sort((a, b) => a.seq - b.seq);
 			return {
-				entries,
 				lastSeq,
 				skipped
 			};
@@ -31284,13 +31376,31 @@ async function readRaw(path) {
 		throw err;
 	}
 }
-function nonEmptyLines(raw) {
-	return raw.split("\n").filter((l) => l !== "");
+/**
+* The stream's non-empty lines, one at a time. Streamed rather than read as one
+* string because a project's stream is capped in the hundreds of megabytes, far
+* past what a reader can hold. Order is the file's, which is append order,
+* which is seq order — the prune rewrites a suffix and never reorders.
+*/
+async function* streamLines(path) {
+	const input = createReadStream(path, { encoding: "utf8" });
+	const lines = createInterface$1({
+		input,
+		crlfDelay: Infinity
+	});
+	try {
+		for await (const line of lines) if (line !== "") yield line;
+	} catch (err) {
+		if (!(err instanceof Error && "code" in err && err.code === "ENOENT")) throw err;
+	} finally {
+		lines.close();
+		input.destroy();
+	}
 }
 /** Every parseable line of the log; partial or corrupt lines are silently omitted (the read side counts them). */
 async function readLines(path) {
 	const lines = [];
-	for (const rawLine of nonEmptyLines(await readRaw(path))) {
+	for await (const rawLine of streamLines(path)) {
 		const line = parseLine(rawLine);
 		if (line !== null) lines.push(line);
 	}

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccqa",
-  "version": "1.43.0",
+  "version": "1.44.0",
   "type": "module",
   "description": "Browser test recorder powered by Claude Code and agent-browser",
   "repository": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccqa",
-  "version": "1.43.0",
+  "version": "1.44.0",
   "type": "module",
   "description": "Browser test recorder powered by Claude Code and agent-browser",
   "repository": {