@milaboratories/pl-flight-recorder 0.2.0

package/dist/analyze.js

@@ -0,0 +1,525 @@
+import { SESSION_END_RECORD } from "./events.js";
+import { listSessions, readSession, sessionIdFromFile, sessionStartFromId } from "./recorder.js";
+import { readCrashMarkers } from "./supervisor.js";
+import { inputRowsMax, joinShapes, structuralFindings } from "./rules.js";
+import path from "node:path";
+//#region src/analyze.ts
+/**
+* Turns a flight log into an attributed cause.
+*
+* Three independent lines of evidence are combined: which operation was still
+* running when the process died (an unmatched begin record), where memory
+* actually went (resident growth across each completed operation, and which
+* region grew — JS heap, off-heap buffers, or native), and what the join tree
+* looked like before any data was touched. Any one alone is suggestive;
+* together they name a specific call in a specific block.
+*/
+const THRESHOLDS = {
+	/** Fraction of the heap ceiling above which the heap counts as exhausted. */
+	heapPressure: .85,
+	nativeGrowthBytes: 512 * 1024 * 1024,
+	amplification: 10,
+	unboundedRows: 1e6,
+	returnedBytes: 256 * 1024 * 1024,
+	inlineEntries: 1e6,
+	stallMs: 2e3,
+	/** Backward tolerance when matching a marker by time, for parent/worker clock drift. */
+	clockToleranceMs: 1e3,
+	/** How many open sessions are considered as rivals for an unattributed marker. */
+	maxRivalSessions: 8,
+	/** A machine-memory claim needs the process to actually be large. */
+	machineRssShare: .25
+};
+/** Analyzes the newest crashed session in a directory, else the newest session. */
+function analyzeLatest(dir, options = {}) {
+	const { preferCrashed = true } = options;
+	const sessions = listSessions(dir);
+	if (sessions.length === 0) return void 0;
+	return analyzeSession(((preferCrashed ? sessions.find((s) => s.crashed) : void 0) ?? sessions[0]).file, dir);
+}
+/** Analyzes one flight log, merging the sibling sampler series when present. */
+function analyzeSession(file, dir = path.dirname(file)) {
+	const { records, truncatedTail } = readSession(file);
+	const header = records.find((r) => r.type === "session") ?? {};
+	const sessionId = sessionIdFromFile(file);
+	const samples = readSamples(path.join(dir, `mem-${sessionId}.ndjson`));
+	const ended = records.find((r) => r.type === SESSION_END_RECORD);
+	const attribution = ended ? {
+		marker: void 0,
+		ambiguous: false
+	} : findCrashMarker(dir, sessionId, records);
+	const crashMarker = attribution.marker;
+	const memory = analyzeMemory(records, samples, header.env);
+	const operations = pairOperations(records);
+	const inFlight = operations.filter((op) => !op.end);
+	const findings = [
+		...classifyCrashMarker(crashMarker),
+		...ambiguousMarkerFinding(attribution.ambiguous),
+		...classifyMemory(memory, header.env, crashMarker),
+		...collectStructural(records),
+		...collectEmpirical(records, operations, definitionBySeq(records)),
+		...stallFindings(memory)
+	].sort(bySeverity);
+	return {
+		file,
+		sessionId,
+		crashed: !ended,
+		truncatedTail,
+		endedReason: ended?.reason,
+		crashMarker,
+		env: header.env,
+		role: header.role,
+		meta: header.meta,
+		recordCount: records.length,
+		rotations: records.filter((r) => r.type === "session" && r.continuation === true).length,
+		memory,
+		attribution: operations.filter((op) => typeof op.rssDelta === "number").sort((lhs, rhs) => (rhs.rssDelta ?? 0) - (lhs.rssDelta ?? 0)).slice(0, 12),
+		inFlight,
+		inFlightAtDeath: inFlight.at(-1),
+		renders: summarizeRenders(records),
+		findings,
+		verdict: buildVerdict({
+			crashed: !ended,
+			memory,
+			inFlight,
+			findings,
+			crashMarker,
+			blockOf: enclosingRenders(records)
+		}),
+		timeline: records.slice(-40).map(compactRecord)
+	};
+}
+/** Thousands separators, or `unknown` when the count was never observed. */
+function formatCount(value) {
+	return typeof value === "number" ? value.toLocaleString("en-US") : "unknown";
+}
+/** Binary byte units, or `unknown`. */
+function formatBytes(value) {
+	if (typeof value !== "number") return "unknown";
+	const units = [
+		"B",
+		"KiB",
+		"MiB",
+		"GiB",
+		"TiB"
+	];
+	let index = 0;
+	let scaled = Math.abs(value);
+	while (scaled >= 1024 && index < units.length - 1) {
+		scaled /= 1024;
+		index++;
+	}
+	const digits = scaled < 10 && index > 0 ? 1 : 0;
+	return `${value < 0 ? "-" : ""}${scaled.toFixed(digits)} ${units[index]}`;
+}
+const CLOCK_TOLERANCE_MS = THRESHOLDS.clockToleranceMs;
+const MAX_RIVAL_SESSIONS = THRESHOLDS.maxRivalSessions;
+const SEVERITY_ORDER = {
+	critical: 0,
+	high: 1,
+	medium: 2,
+	low: 3
+};
+const REGION_RULES = [
+	"js-heap-exhaustion-confirmed",
+	"js-heap-exhaustion",
+	"off-heap-buffer-growth",
+	"native-allocation-growth",
+	"machine-memory-exhausted"
+];
+const CAUSE_RULES = [
+	"cross-join",
+	"axis-domain-mismatch",
+	"join-amplification",
+	"unbounded-getData",
+	"huge-inline-column"
+];
+/**
+* The marker for a session is the one whose assigned id names it.
+*
+* Failing that, a marker with no id is attributed by time: a session that died
+* stopped writing, so the marker lands at or just after its last record, while a
+* session that survived kept writing past it. That test only separates them when
+* the other sessions actually did keep writing. When two sessions both look
+* dead, no attribution is made at all — an unattributed marker is reported as
+* such, which is honest, where naming the wrong session is not.
+*/
+function findCrashMarker(dir, sessionId, records) {
+	const markers = readCrashMarkers(dir);
+	const assigned = markers.find((marker) => isAssigned(marker) && marker.sessionId === sessionId);
+	if (assigned) return {
+		marker: assigned,
+		ambiguous: false
+	};
+	const thisStart = sessionStartFromId(sessionId);
+	const lastWall = records.at(-1)?.wall ?? 0;
+	const others = openSessionEnds(dir).filter((session) => session.sessionId !== sessionId);
+	for (const marker of markers) {
+		if (isAssigned(marker)) continue;
+		if (marker.wall < Math.max(thisStart, lastWall - CLOCK_TOLERANCE_MS)) continue;
+		if (others.filter((session) => marker.wall >= Math.max(session.start, session.lastWall - CLOCK_TOLERANCE_MS)).length > 0) return {
+			marker: void 0,
+			ambiguous: true
+		};
+		return {
+			marker,
+			ambiguous: false
+		};
+	}
+	return {
+		marker: void 0,
+		ambiguous: false
+	};
+}
+/**
+* An older recorder put a guess in `sessionId` and labelled it. Such an id is
+* not identity, so it is read back as an unattributed marker.
+*/
+function isAssigned(marker) {
+	return marker.sessionId !== void 0 && marker.sessionIdSource !== "guessed";
+}
+/** Last recorded wall clock of every session that has no terminating record. */
+function openSessionEnds(dir) {
+	return listSessions(dir).filter((session) => session.crashed).slice(0, MAX_RIVAL_SESSIONS).map((session) => {
+		const id = sessionIdFromFile(session.file);
+		let lastWall = 0;
+		try {
+			lastWall = readSession(session.file).records.at(-1)?.wall ?? 0;
+		} catch {}
+		return {
+			sessionId: id,
+			start: sessionStartFromId(id),
+			lastWall
+		};
+	});
+}
+function readSamples(file) {
+	try {
+		return readSession(file).records;
+	} catch {
+		return [];
+	}
+}
+function analyzeMemory(records, samples, env) {
+	const selfSeries = records.filter((record) => record.mem).map((record) => ({
+		wall: record.wall,
+		...record.mem
+	}));
+	const rssSeries = samples.length ? samples.map((s) => ({
+		wall: s.wall,
+		rss: s.rss,
+		freeMemory: s.freeMemory
+	})) : selfSeries.map((s) => ({
+		wall: s.wall,
+		rss: s.rss
+	}));
+	const last = selfSeries.at(-1);
+	const lastSample = samples.at(-1);
+	const heapLimit = last?.heapLimit ?? env?.heapLimit;
+	return {
+		samplerPresent: samples.length > 0,
+		sampleCount: rssSeries.length,
+		rssSeries,
+		peakRss: Math.max(0, ...rssSeries.map((s) => s.rss ?? 0)),
+		rssAtDeath: lastSample?.rss ?? last?.rss,
+		rssGrowth: rssSeries.length ? (rssSeries.at(-1)?.rss ?? 0) - (rssSeries[0].rss ?? 0) : 0,
+		heapUsedAtDeath: last?.heapUsed,
+		heapLimit,
+		heapPressure: last?.heapUsed && heapLimit ? Math.round(last.heapUsed / heapLimit * 100) / 100 : void 0,
+		heapGrowth: growth(selfSeries, "heapUsed"),
+		externalGrowth: growth(selfSeries, "external"),
+		arrayBuffersGrowth: growth(selfSeries, "arrayBuffers"),
+		worstStallMs: Math.max(0, ...records.filter((record) => record.type === "mem-self").map((record) => record.stallMs ?? 0)),
+		freeMemoryAtDeath: lastSample?.freeMemory,
+		totalMemory: lastSample?.totalMemory ?? env?.totalMemory
+	};
+}
+function growth(series, key) {
+	const values = series.map((entry) => entry[key]).filter((value) => typeof value === "number");
+	return values.length ? values[values.length - 1] - values[0] : void 0;
+}
+function pairOperations(records) {
+	const begins = /* @__PURE__ */ new Map();
+	const beginMemory = /* @__PURE__ */ new Map();
+	const operations = [];
+	for (const record of records) {
+		if (record.type.endsWith("-begin")) {
+			if (begins.has(record.seq)) continue;
+			const summary = {
+				op: record.type.replace(/-begin$/, ""),
+				seq: record.seq,
+				wall: record.wall,
+				info: compactRecord(record)
+			};
+			begins.set(record.seq, summary);
+			if (record.mem) beginMemory.set(record.seq, record.mem);
+			operations.push(summary);
+			continue;
+		}
+		if (!record.type.endsWith("-end") && !record.type.endsWith("-error")) continue;
+		const summary = record.begin === void 0 ? void 0 : begins.get(record.begin);
+		if (!summary) continue;
+		summary.end = compactRecord(record);
+		summary.ms = record.ms;
+		summary.failed = record.type.endsWith("-error");
+		const beginMem = beginMemory.get(summary.seq);
+		if (beginMem && record.mem) {
+			summary.rssDelta = record.mem.rss - beginMem.rss;
+			summary.heapDelta = record.mem.heapUsed - beginMem.heapUsed;
+		}
+	}
+	return operations;
+}
+function collectStructural(records) {
+	const enclosing = enclosingRenders(records);
+	const out = [];
+	for (const record of records) for (const finding of structuralFindings(recordedDef(record))) out.push({
+		rule: finding.rule,
+		severity: finding.severity,
+		detail: finding.detail,
+		path: finding.path,
+		join: finding.join,
+		source: record.type,
+		seq: record.seq,
+		block: record.blockId ?? enclosing.get(record.seq)
+	});
+	return out;
+}
+/**
+* Maps each record's sequence number to the block whose render was open at that
+* point. Driver calls carry no block identity of their own — the driver does not
+* know which model asked — so the enclosing render span supplies it.
+*/
+function enclosingRenders(records) {
+	const out = /* @__PURE__ */ new Map();
+	const open = [];
+	for (const record of records) {
+		if (record.type === "render-begin") {
+			if (!open.some((entry) => entry.seq === record.seq)) open.push({
+				seq: record.seq,
+				blockId: record.blockId
+			});
+		} else if (record.type === "render-end" || record.type === "render-error") {
+			const index = open.findIndex((entry) => entry.seq === record.begin);
+			if (index >= 0) open.splice(index, 1);
+		}
+		const innermost = open.at(-1);
+		if (innermost?.blockId) out.set(record.seq, innermost.blockId);
+	}
+	return out;
+}
+function collectEmpirical(records, operations, definitions) {
+	const out = [];
+	const beginBySeq = new Map(records.map((record) => [record.seq, record]));
+	for (const record of records) {
+		if (record.type === "getShape-end") {
+			const joinSeq = (record.begin === void 0 ? void 0 : beginBySeq.get(record.begin))?.joinSeq;
+			const declared = joinSeq === void 0 ? void 0 : inputRowsMax(definitions.get(joinSeq));
+			const rows = record.rows;
+			const amplification = typeof rows === "number" && typeof declared === "number" && declared > 0 ? Math.round(rows / declared * 100) / 100 : void 0;
+			if ((amplification ?? 0) >= THRESHOLDS.amplification) out.push({
+				rule: "join-amplification",
+				severity: "critical",
+				seq: record.seq,
+				detail: `join produced ${formatCount(rows)} rows from at most ${formatCount(declared)} declared input rows (x${amplification})`
+			});
+		}
+		const tableRows = record.tableRows ?? 0;
+		if (record.type === "getData-begin" && record.unbounded && tableRows > THRESHOLDS.unboundedRows) out.push({
+			rule: "unbounded-getData",
+			severity: "critical",
+			seq: record.seq,
+			detail: `getData with no row range on a ${formatCount(tableRows)}-row table pulls the whole table into the JS heap`
+		});
+		const returnedBytes = record.returnedBytes ?? 0;
+		if (record.type === "getData-end" && returnedBytes >= THRESHOLDS.returnedBytes) out.push({
+			rule: "large-getData-result",
+			severity: "high",
+			seq: record.seq,
+			detail: `${formatBytes(returnedBytes)} of column data returned into JS in one call`
+		});
+		if (record.type.startsWith("createP")) for (const inline of inlineColumns(recordedDef(record))) {
+			if ((inline.entries ?? 0) < THRESHOLDS.inlineEntries) continue;
+			out.push({
+				rule: "huge-inline-column",
+				severity: "high",
+				seq: record.seq,
+				detail: `model passed an inline column of ${formatCount(inline.entries)} entries (~${formatBytes(inline.approxBytes)}) through the sandbox`
+			});
+		}
+	}
+	for (const op of operations) {
+		if ((op.rssDelta ?? 0) < THRESHOLDS.nativeGrowthBytes) continue;
+		out.push({
+			rule: "operation-memory-spike",
+			severity: "high",
+			seq: op.seq,
+			detail: `${op.op} grew RSS by ${formatBytes(op.rssDelta)} (heap ${formatBytes(op.heapDelta ?? 0)})`
+		});
+	}
+	return out;
+}
+function classifyCrashMarker(marker) {
+	if (!marker) return [];
+	const explanation = {
+		"js-heap-out-of-memory": "the supervisor received ERR_WORKER_OUT_OF_MEMORY: the middle-layer thread exceeded its V8 heap limit",
+		"abort-or-fatal-allocation-failure": "the process aborted on a fatal allocation failure (V8 fatal out-of-memory, or a failed native allocation)",
+		"killed-by-os": "the OS killed the process (SIGKILL), which is what an out-of-memory kill looks like"
+	};
+	const firstLine = marker.message ? marker.message.split("\n")[0] : "";
+	return [{
+		rule: marker.reason === "js-heap-out-of-memory" ? "js-heap-exhaustion-confirmed" : `crash-${marker.reason}`,
+		severity: "critical",
+		source: "supervisor",
+		detail: `${explanation[marker.reason] ?? marker.reason}${firstLine ? ` — ${firstLine}` : ""}`
+	}];
+}
+function ambiguousMarkerFinding(ambiguous) {
+	if (!ambiguous) return [];
+	return [{
+		rule: "unattributed-crash-marker",
+		severity: "medium",
+		detail: "a crash marker sits in this session's time window, but another session in the same directory also stopped writing around then, so it is not attributed to either — spawn the worker with an assigned session id to remove the ambiguity"
+	}];
+}
+function classifyMemory(memory, env, crashMarker) {
+	const out = [];
+	const rssShare = memory.totalMemory ? (memory.rssAtDeath ?? 0) / memory.totalMemory : 0;
+	if (memory.freeMemoryAtDeath !== void 0 && memory.totalMemory && memory.freeMemoryAtDeath < memory.totalMemory * .03 && rssShare > THRESHOLDS.machineRssShare) out.push({
+		rule: "machine-memory-exhausted",
+		severity: "critical",
+		detail: `process held ${formatBytes(memory.rssAtDeath)} (${Math.round(rssShare * 100)}%) of ${formatBytes(memory.totalMemory)} with ${formatBytes(memory.freeMemoryAtDeath)} free — the OS, not V8, ended the process`
+	});
+	if (!crashMarker && memory.heapPressure !== void 0 && memory.heapPressure < THRESHOLDS.heapPressure && memory.worstStallMs >= THRESHOLDS.stallMs) out.push({
+		rule: "heap-reading-stale",
+		severity: "medium",
+		detail: `last JS heap reading is ${formatBytes(memory.heapUsedAtDeath)} but the thread was blocked for ${Math.round(memory.worstStallMs)}ms before the log ends, so the heap was never sampled near the crash`
+	});
+	if ((memory.heapPressure ?? 0) >= THRESHOLDS.heapPressure) {
+		const flag = env?.maxOldSpaceSize ? ` (--max-old-space-size=${env.maxOldSpaceSize})` : "";
+		out.push({
+			rule: "js-heap-exhaustion",
+			severity: "critical",
+			detail: `JS heap at ${Math.round((memory.heapPressure ?? 0) * 100)}% of its ${formatBytes(memory.heapLimit)} limit${flag}`
+		});
+	}
+	const offHeap = (memory.externalGrowth ?? 0) + (memory.arrayBuffersGrowth ?? 0);
+	const heapGrowth = memory.heapGrowth ?? 0;
+	if (memory.rssGrowth >= THRESHOLDS.nativeGrowthBytes && heapGrowth < memory.rssGrowth / 4) {
+		const offHeapDominant = offHeap >= THRESHOLDS.nativeGrowthBytes;
+		out.push({
+			rule: offHeapDominant ? "off-heap-buffer-growth" : "native-allocation-growth",
+			severity: "critical",
+			detail: offHeapDominant ? `RSS grew ${formatBytes(memory.rssGrowth)} while the JS heap grew ${formatBytes(heapGrowth)}; off-heap ArrayBuffer/external allocation grew ${formatBytes(offHeap)} — the growth is buffers handed out by the pframes engine, not JavaScript objects. Raising --max-old-space-size will not help.` : `RSS grew ${formatBytes(memory.rssGrowth)} while the JS heap grew only ${formatBytes(heapGrowth)} — the allocation is native (pframes engine / Arrow buffers), not JavaScript. Raising --max-old-space-size will not help.`
+		});
+	}
+	return out;
+}
+function stallFindings(memory) {
+	if (memory.worstStallMs < THRESHOLDS.stallMs) return [];
+	return [{
+		rule: "event-loop-stall",
+		severity: "medium",
+		detail: `the recorded thread was blocked for ${Math.round(memory.worstStallMs)}ms — synchronous work (model evaluation, or a blocking native call)`
+	}];
+}
+function summarizeRenders(records) {
+	const open = /* @__PURE__ */ new Map();
+	const out = [];
+	for (const record of records) {
+		if (record.type === "render-begin") {
+			if (open.has(record.seq)) continue;
+			const summary = {
+				seq: record.seq,
+				blockId: record.blockId,
+				block: record.block,
+				key: record.key
+			};
+			open.set(record.seq, summary);
+			out.push(summary);
+			continue;
+		}
+		if (record.type !== "render-end" && record.type !== "render-error") continue;
+		const summary = record.begin === void 0 ? void 0 : open.get(record.begin);
+		if (!summary) continue;
+		summary.end = true;
+		summary.ms = record.ms;
+		summary.stats = record.stats;
+		summary.failed = record.type === "render-error";
+	}
+	return out;
+}
+function buildVerdict(input) {
+	const { crashed, memory, inFlight, findings, crashMarker, blockOf } = input;
+	const gun = inFlight.at(-1);
+	const region = findings.find((finding) => REGION_RULES.includes(finding.rule));
+	const cause = findings.find((finding) => CAUSE_RULES.includes(finding.rule));
+	const blockId = gun?.info?.blockId ?? (gun === void 0 ? void 0 : blockOf.get(gun.seq)) ?? findings.find((finding) => finding.block)?.block;
+	return {
+		outcome: crashed ? `session ended without shutdown${crashMarker ? ` — supervisor reported ${crashMarker.reason}` : " (no supervisor marker)"}` : "clean shutdown",
+		peakRss: memory.peakRss,
+		where: gun ? `${gun.op} started at seq ${gun.seq} and never returned${blockId ? ` (block ${blockId})` : ""}` : "no operation was in flight",
+		memoryRegion: region?.rule,
+		likelyCause: cause?.rule ?? findings[0]?.rule,
+		summary: [
+			crashed ? "Process died without running shutdown." : "Session closed normally.",
+			gun ? `Last unfinished operation: ${gun.op} (seq ${gun.seq}).` : void 0,
+			region?.detail,
+			cause ? `Probable cause: ${cause.rule} — ${cause.detail}` : void 0
+		].filter(Boolean).join(" ")
+	};
+}
+function inlineColumns(def, acc = []) {
+	if (!def || typeof def !== "object") return acc;
+	const node = def;
+	const data = node.data;
+	if (data?.kind === "inline") acc.push(data);
+	for (const value of Object.values(node)) if (Array.isArray(value)) for (const child of value) inlineColumns(child, acc);
+	else if (value && typeof value === "object") inlineColumns(value, acc);
+	return acc;
+}
+function compactRecord(record) {
+	const { mem, def, ...rest } = record;
+	const out = { ...rest };
+	if (mem) out.rss = mem.rss;
+	if (def) out.defSummary = summarizeDef(def);
+	return out;
+}
+function summarizeDef(digest) {
+	const typed = digest;
+	const def = recordedDefFrom(digest);
+	const outermost = joinShapes(def)[0];
+	return {
+		kind: typed?.kind,
+		bytes: typed?.redaction?.bytes,
+		join: outermost?.join,
+		children: outermost?.childCount,
+		sharedAxes: outermost?.sharedAxes.length,
+		inputRowsMax: outermost?.inputRowsMax ?? inputRowsMax(def),
+		rowsUpperBound: outermost?.rowsUpperBound
+	};
+}
+/** The redacted definition inside a record, if it carries one. */
+function recordedDef(record) {
+	return recordedDefFrom(record.def);
+}
+function recordedDefFrom(digest) {
+	if (!digest || typeof digest !== "object") return void 0;
+	return digest.def;
+}
+/** Definition of each creation call, keyed by the sequence number of its record. */
+function definitionBySeq(records) {
+	const out = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		const def = recordedDef(record);
+		if (def !== void 0) out.set(record.seq, def);
+	}
+	return out;
+}
+function bySeverity(lhs, rhs) {
+	return (SEVERITY_ORDER[lhs.severity] ?? 9) - (SEVERITY_ORDER[rhs.severity] ?? 9);
+}
+//#endregion
+export { THRESHOLDS, analyzeLatest, analyzeSession, formatBytes, formatCount };
+
+//# sourceMappingURL=analyze.js.map

package/dist/analyze.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.js","names":[],"sources":["../src/analyze.ts"],"sourcesContent":["import path from \"node:path\";\nimport type {\n  CrashMarker,\n  FlightRecord,\n  MemorySnapshot,\n  SamplerRecord,\n  SessionEnvironment,\n} from \"./events\";\nimport { SAMPLER_FILE_PREFIX, SESSION_END_RECORD, SESSION_RECORD } from \"./events\";\nimport { listSessions, readSession, sessionIdFromFile, sessionStartFromId } from \"./recorder\";\nimport { readCrashMarkers } from \"./supervisor\";\nimport { inputRowsMax, joinShapes, structuralFindings, type FindingSeverity } from \"./rules\";\n\n/**\n * Turns a flight log into an attributed cause.\n *\n * Three independent lines of evidence are combined: which operation was still\n * running when the process died (an unmatched begin record), where memory\n * actually went (resident growth across each completed operation, and which\n * region grew — JS heap, off-heap buffers, or native), and what the join tree\n * looked like before any data was touched. Any one alone is suggestive;\n * together they name a specific call in a specific block.\n */\n\nexport const THRESHOLDS = {\n  /** Fraction of the heap ceiling above which the heap counts as exhausted. */\n  heapPressure: 0.85,\n  nativeGrowthBytes: 512 * 1024 * 1024,\n  amplification: 10,\n  unboundedRows: 1_000_000,\n  returnedBytes: 256 * 1024 * 1024,\n  inlineEntries: 1_000_000,\n  stallMs: 2000,\n  /** Backward tolerance when matching a marker by time, for parent/worker clock drift. */\n  clockToleranceMs: 1000,\n  /** How many open sessions are considered as rivals for an unattributed marker. */\n  maxRivalSessions: 8,\n  /** A machine-memory claim needs the process to actually be large. */\n  machineRssShare: 0.25,\n} as const;\n\nexport type Finding = {\n  rule: string;\n  severity: FindingSeverity;\n  detail: string;\n  seq?: number;\n  path?: string;\n  join?: string;\n  source?: string;\n  block?: string;\n};\n\nexport type MemoryAnalysis = {\n  samplerPresent: boolean;\n  sampleCount: number;\n  rssSeries: { wall: number; rss?: number; freeMemory?: number }[];\n  peakRss: number;\n  rssAtDeath?: number;\n  rssGrowth: number;\n  heapUsedAtDeath?: number;\n  heapLimit?: number;\n  heapPressure?: number;\n  heapGrowth?: number;\n  externalGrowth?: number;\n  arrayBuffersGrowth?: number;\n  worstStallMs: number;\n  freeMemoryAtDeath?: number;\n  totalMemory?: number;\n};\n\nexport type OperationSummary = {\n  op: string;\n  seq: number;\n  wall: number;\n  info: Record<string, unknown>;\n  end?: Record<string, unknown>;\n  ms?: number;\n  failed?: boolean;\n  rssDelta?: number;\n  heapDelta?: number;\n};\n\nexport type RenderSummary = {\n  seq: number;\n  blockId?: string;\n  block?: string;\n  key?: string;\n  end?: boolean;\n  failed?: boolean;\n  ms?: number;\n  stats?: { serOutBytes?: number; serInBytes?: number; [key: string]: unknown };\n};\n\nexport type Verdict = {\n  outcome: string;\n  peakRss: number;\n  where: string;\n  memoryRegion?: string;\n  likelyCause?: string;\n  summary: string;\n};\n\nexport type SessionAnalysis = {\n  file: string;\n  sessionId: string;\n  crashed: boolean;\n  truncatedTail: boolean;\n  endedReason?: string;\n  crashMarker?: CrashMarker;\n  env?: SessionEnvironment;\n  role?: string;\n  meta?: Record<string, unknown>;\n  recordCount: number;\n  /**\n   * How many times the log rotated. Each rotation re-emits the session header,\n   * so environment and metadata survive, but operations older than the retained\n   * segments do not — which is why the count is reported rather than implied.\n   */\n  rotations: number;\n  memory: MemoryAnalysis;\n  /** Completed operations ranked by resident growth. */\n  attribution: OperationSummary[];\n  inFlight: OperationSummary[];\n  /** The innermost operation that started and never returned. */\n  inFlightAtDeath?: OperationSummary;\n  renders: RenderSummary[];\n  findings: Finding[];\n  verdict: Verdict;\n  timeline: Record<string, unknown>[];\n};\n\n/** Analyzes the newest crashed session in a directory, else the newest session. */\nexport function analyzeLatest(\n  dir: string,\n  options: { preferCrashed?: boolean } = {},\n): SessionAnalysis | undefined {\n  const { preferCrashed = true } = options;\n  const sessions = listSessions(dir);\n  if (sessions.length === 0) return undefined;\n  const target = (preferCrashed ? sessions.find((s) => s.crashed) : undefined) ?? sessions[0];\n  return analyzeSession(target.file, dir);\n}\n\n/** Analyzes one flight log, merging the sibling sampler series when present. */\nexport function analyzeSession(file: string, dir: string = path.dirname(file)): SessionAnalysis {\n  const { records, truncatedTail } = readSession(file);\n  const header = (records.find((r) => r.type === SESSION_RECORD) ?? {}) as FlightRecord & {\n    env?: SessionEnvironment;\n    role?: string;\n    meta?: Record<string, unknown>;\n  };\n  const sessionId = sessionIdFromFile(file);\n  const samples = readSamples(path.join(dir, `${SAMPLER_FILE_PREFIX}-${sessionId}.ndjson`));\n\n  const ended = records.find((r) => r.type === SESSION_END_RECORD);\n  const attribution = ended\n    ? { marker: undefined, ambiguous: false }\n    : findCrashMarker(dir, sessionId, records);\n  const crashMarker = attribution.marker;\n\n  const memory = analyzeMemory(records, samples, header.env);\n  const operations = pairOperations(records);\n  const inFlight = operations.filter((op) => !op.end);\n\n  const findings = [\n    ...classifyCrashMarker(crashMarker),\n    ...ambiguousMarkerFinding(attribution.ambiguous),\n    ...classifyMemory(memory, header.env, crashMarker),\n    ...collectStructural(records),\n    ...collectEmpirical(records, operations, definitionBySeq(records)),\n    ...stallFindings(memory),\n  ].sort(bySeverity);\n\n  return {\n    file,\n    sessionId,\n    crashed: !ended,\n    truncatedTail,\n    endedReason: ended?.reason as string | undefined,\n    crashMarker,\n    env: header.env,\n    role: header.role,\n    meta: header.meta,\n    recordCount: records.length,\n    rotations: records.filter((r) => r.type === SESSION_RECORD && r.continuation === true).length,\n    memory,\n    attribution: operations\n      .filter((op) => typeof op.rssDelta === \"number\")\n      .sort((lhs, rhs) => (rhs.rssDelta ?? 0) - (lhs.rssDelta ?? 0))\n      .slice(0, 12),\n    inFlight,\n    inFlightAtDeath: inFlight.at(-1),\n    renders: summarizeRenders(records),\n    findings,\n    verdict: buildVerdict({\n      crashed: !ended,\n      memory,\n      inFlight,\n      findings,\n      crashMarker,\n      blockOf: enclosingRenders(records),\n    }),\n    timeline: records.slice(-40).map(compactRecord),\n  };\n}\n\n/** Thousands separators, or `unknown` when the count was never observed. */\nexport function formatCount(value: number | undefined): string {\n  return typeof value === \"number\" ? value.toLocaleString(\"en-US\") : \"unknown\";\n}\n\n/** Binary byte units, or `unknown`. */\nexport function formatBytes(value: number | undefined): string {\n  if (typeof value !== \"number\") return \"unknown\";\n  const units = [\"B\", \"KiB\", \"MiB\", \"GiB\", \"TiB\"];\n  let index = 0;\n  let scaled = Math.abs(value);\n  while (scaled >= 1024 && index < units.length - 1) {\n    scaled /= 1024;\n    index++;\n  }\n  const digits = scaled < 10 && index > 0 ? 1 : 0;\n  return `${value < 0 ? \"-\" : \"\"}${scaled.toFixed(digits)} ${units[index]}`;\n}\n\n// Internals\n\nconst CLOCK_TOLERANCE_MS = THRESHOLDS.clockToleranceMs;\nconst MAX_RIVAL_SESSIONS = THRESHOLDS.maxRivalSessions;\n\nconst SEVERITY_ORDER: Record<FindingSeverity, number> = {\n  critical: 0,\n  high: 1,\n  medium: 2,\n  low: 3,\n};\n\nconst REGION_RULES = [\n  \"js-heap-exhaustion-confirmed\",\n  \"js-heap-exhaustion\",\n  \"off-heap-buffer-growth\",\n  \"native-allocation-growth\",\n  \"machine-memory-exhausted\",\n];\n\nconst CAUSE_RULES = [\n  \"cross-join\",\n  \"axis-domain-mismatch\",\n  \"join-amplification\",\n  \"unbounded-getData\",\n  \"huge-inline-column\",\n];\n\n/**\n * The marker for a session is the one whose assigned id names it.\n *\n * Failing that, a marker with no id is attributed by time: a session that died\n * stopped writing, so the marker lands at or just after its last record, while a\n * session that survived kept writing past it. That test only separates them when\n * the other sessions actually did keep writing. When two sessions both look\n * dead, no attribution is made at all — an unattributed marker is reported as\n * such, which is honest, where naming the wrong session is not.\n */\nfunction findCrashMarker(\n  dir: string,\n  sessionId: string,\n  records: FlightRecord[],\n): { marker?: CrashMarker; ambiguous: boolean } {\n  const markers = readCrashMarkers(dir);\n  const assigned = markers.find((marker) => isAssigned(marker) && marker.sessionId === sessionId);\n  if (assigned) return { marker: assigned, ambiguous: false };\n\n  const thisStart = sessionStartFromId(sessionId);\n  const lastWall = records.at(-1)?.wall ?? 0;\n  const others = openSessionEnds(dir).filter((session) => session.sessionId !== sessionId);\n\n  for (const marker of markers) {\n    if (isAssigned(marker)) continue;\n    // A marker cannot predate the session it belongs to; the backward tolerance\n    // only absorbs clock drift between the parent and the worker.\n    if (marker.wall < Math.max(thisStart, lastWall - CLOCK_TOLERANCE_MS)) continue;\n    const rivals = others.filter(\n      (session) => marker.wall >= Math.max(session.start, session.lastWall - CLOCK_TOLERANCE_MS),\n    );\n    if (rivals.length > 0) return { marker: undefined, ambiguous: true };\n    return { marker, ambiguous: false };\n  }\n  return { marker: undefined, ambiguous: false };\n}\n\n/**\n * An older recorder put a guess in `sessionId` and labelled it. Such an id is\n * not identity, so it is read back as an unattributed marker.\n */\nfunction isAssigned(marker: CrashMarker): boolean {\n  return marker.sessionId !== undefined && marker.sessionIdSource !== \"guessed\";\n}\n\n/** Last recorded wall clock of every session that has no terminating record. */\nfunction openSessionEnds(dir: string): { sessionId: string; start: number; lastWall: number }[] {\n  return listSessions(dir)\n    .filter((session) => session.crashed)\n    .slice(0, MAX_RIVAL_SESSIONS)\n    .map((session) => {\n      const id = sessionIdFromFile(session.file);\n      let lastWall = 0;\n      try {\n        lastWall = readSession(session.file).records.at(-1)?.wall ?? 0;\n      } catch {\n        // A session whose log cannot be read cannot rival anything.\n      }\n      return { sessionId: id, start: sessionStartFromId(id), lastWall };\n    });\n}\n\nfunction readSamples(file: string): SamplerRecord[] {\n  try {\n    return readSession(file).records as unknown as SamplerRecord[];\n  } catch {\n    return [];\n  }\n}\n\nfunction analyzeMemory(\n  records: FlightRecord[],\n  samples: SamplerRecord[],\n  env: SessionEnvironment | undefined,\n): MemoryAnalysis {\n  const selfSeries = records\n    .filter((record) => record.mem)\n    .map((record) => ({ wall: record.wall, ...record.mem! }));\n  const rssSeries = samples.length\n    ? samples.map((s) => ({ wall: s.wall, rss: s.rss, freeMemory: s.freeMemory }))\n    : selfSeries.map((s) => ({ wall: s.wall, rss: s.rss }));\n\n  const last = selfSeries.at(-1);\n  const lastSample = samples.at(-1);\n  const heapLimit = last?.heapLimit ?? env?.heapLimit;\n\n  return {\n    samplerPresent: samples.length > 0,\n    sampleCount: rssSeries.length,\n    rssSeries,\n    peakRss: Math.max(0, ...rssSeries.map((s) => s.rss ?? 0)),\n    rssAtDeath: lastSample?.rss ?? last?.rss,\n    rssGrowth: rssSeries.length ? (rssSeries.at(-1)?.rss ?? 0) - (rssSeries[0].rss ?? 0) : 0,\n    heapUsedAtDeath: last?.heapUsed,\n    heapLimit,\n    heapPressure:\n      last?.heapUsed && heapLimit ? Math.round((last.heapUsed / heapLimit) * 100) / 100 : undefined,\n    heapGrowth: growth(selfSeries, \"heapUsed\"),\n    externalGrowth: growth(selfSeries, \"external\"),\n    arrayBuffersGrowth: growth(selfSeries, \"arrayBuffers\"),\n    worstStallMs: Math.max(\n      0,\n      ...records\n        .filter((record) => record.type === \"mem-self\")\n        .map((record) => (record.stallMs as number | undefined) ?? 0),\n    ),\n    freeMemoryAtDeath: lastSample?.freeMemory,\n    totalMemory: lastSample?.totalMemory ?? env?.totalMemory,\n  };\n}\n\nfunction growth(series: Record<string, number | undefined>[], key: string): number | undefined {\n  const values = series\n    .map((entry) => entry[key])\n    .filter((value): value is number => typeof value === \"number\");\n  return values.length ? values[values.length - 1] - values[0] : undefined;\n}\n\n// Pairs each begin record with its end or error by sequence number. Unmatched\n// begins are what was running when the log stopped.\nfunction pairOperations(records: FlightRecord[]): OperationSummary[] {\n  const begins = new Map<number, OperationSummary>();\n  const beginMemory = new Map<number, MemorySnapshot>();\n  const operations: OperationSummary[] = [];\n  for (const record of records) {\n    if (record.type.endsWith(\"-begin\")) {\n      // A begin rewritten into a rotated segment repeats its sequence number;\n      // the operation is already known and must not be counted twice.\n      if (begins.has(record.seq)) continue;\n      const summary: OperationSummary = {\n        op: record.type.replace(/-begin$/, \"\"),\n        seq: record.seq,\n        wall: record.wall,\n        info: compactRecord(record),\n      };\n      begins.set(record.seq, summary);\n      if (record.mem) beginMemory.set(record.seq, record.mem);\n      operations.push(summary);\n      continue;\n    }\n    if (!record.type.endsWith(\"-end\") && !record.type.endsWith(\"-error\")) continue;\n    const summary = record.begin === undefined ? undefined : begins.get(record.begin);\n    if (!summary) continue;\n    summary.end = compactRecord(record);\n    summary.ms = record.ms as number | undefined;\n    summary.failed = record.type.endsWith(\"-error\");\n    const beginMem = beginMemory.get(summary.seq);\n    if (beginMem && record.mem) {\n      summary.rssDelta = record.mem.rss - beginMem.rss;\n      summary.heapDelta = record.mem.heapUsed - beginMem.heapUsed;\n    }\n  }\n  return operations;\n}\n\nfunction collectStructural(records: FlightRecord[]): Finding[] {\n  const enclosing = enclosingRenders(records);\n  const out: Finding[] = [];\n  for (const record of records) {\n    // Rules run here rather than at record time, so they can be revised against\n    // logs that already exist and cost nothing on the hot path.\n    for (const finding of structuralFindings(recordedDef(record))) {\n      out.push({\n        rule: finding.rule,\n        severity: finding.severity,\n        detail: finding.detail,\n        path: finding.path,\n        join: finding.join,\n        source: record.type,\n        seq: record.seq,\n        block: (record.blockId as string | undefined) ?? enclosing.get(record.seq),\n      });\n    }\n  }\n  return out;\n}\n\n/**\n * Maps each record's sequence number to the block whose render was open at that\n * point. Driver calls carry no block identity of their own — the driver does not\n * know which model asked — so the enclosing render span supplies it.\n */\nfunction enclosingRenders(records: FlightRecord[]): Map<number, string> {\n  const out = new Map<number, string>();\n  const open: { seq: number; blockId?: string }[] = [];\n  for (const record of records) {\n    if (record.type === \"render-begin\") {\n      // A render open across a rotation is written twice with one sequence\n      // number: once in the segment that was overwritten, once carried into the\n      // new one. Pushing both would leave a copy open after the render returned,\n      // and every later driver call would be blamed on a block that had finished.\n      if (!open.some((entry) => entry.seq === record.seq)) {\n        open.push({ seq: record.seq, blockId: record.blockId as string | undefined });\n      }\n    } else if (record.type === \"render-end\" || record.type === \"render-error\") {\n      const index = open.findIndex((entry) => entry.seq === record.begin);\n      if (index >= 0) open.splice(index, 1);\n    }\n    const innermost = open.at(-1);\n    if (innermost?.blockId) out.set(record.seq, innermost.blockId);\n  }\n  return out;\n}\n\nfunction collectEmpirical(\n  records: FlightRecord[],\n  operations: OperationSummary[],\n  definitions: Map<number, unknown>,\n): Finding[] {\n  const out: Finding[] = [];\n  const beginBySeq = new Map(records.map((record) => [record.seq, record]));\n  for (const record of records) {\n    if (record.type === \"getShape-end\") {\n      // The observed row count is compared against what the definition of the\n      // table declared as input, which is looked up here rather than carried on\n      // the record.\n      const begin = record.begin === undefined ? undefined : beginBySeq.get(record.begin);\n      const joinSeq = begin?.joinSeq as number | undefined;\n      const declared = joinSeq === undefined ? undefined : inputRowsMax(definitions.get(joinSeq));\n      const rows = record.rows as number | undefined;\n      const amplification =\n        typeof rows === \"number\" && typeof declared === \"number\" && declared > 0\n          ? Math.round((rows / declared) * 100) / 100\n          : undefined;\n      if ((amplification ?? 0) >= THRESHOLDS.amplification) {\n        out.push({\n          rule: \"join-amplification\",\n          severity: \"critical\",\n          seq: record.seq,\n          detail: `join produced ${formatCount(rows)} rows from at most ${formatCount(\n            declared,\n          )} declared input rows (x${amplification})`,\n        });\n      }\n    }\n    const tableRows = (record.tableRows as number | undefined) ?? 0;\n    if (\n      record.type === \"getData-begin\" &&\n      record.unbounded &&\n      tableRows > THRESHOLDS.unboundedRows\n    ) {\n      out.push({\n        rule: \"unbounded-getData\",\n        severity: \"critical\",\n        seq: record.seq,\n        detail: `getData with no row range on a ${formatCount(tableRows)}-row table pulls the whole table into the JS heap`,\n      });\n    }\n    const returnedBytes = (record.returnedBytes as number | undefined) ?? 0;\n    if (record.type === \"getData-end\" && returnedBytes >= THRESHOLDS.returnedBytes) {\n      out.push({\n        rule: \"large-getData-result\",\n        severity: \"high\",\n        seq: record.seq,\n        detail: `${formatBytes(returnedBytes)} of column data returned into JS in one call`,\n      });\n    }\n    if (record.type.startsWith(\"createP\")) {\n      for (const inline of inlineColumns(recordedDef(record))) {\n        if ((inline.entries ?? 0) < THRESHOLDS.inlineEntries) continue;\n        out.push({\n          rule: \"huge-inline-column\",\n          severity: \"high\",\n          seq: record.seq,\n          detail: `model passed an inline column of ${formatCount(inline.entries)} entries (~${formatBytes(\n            inline.approxBytes,\n          )}) through the sandbox`,\n        });\n      }\n    }\n  }\n  for (const op of operations) {\n    if ((op.rssDelta ?? 0) < THRESHOLDS.nativeGrowthBytes) continue;\n    out.push({\n      rule: \"operation-memory-spike\",\n      severity: \"high\",\n      seq: op.seq,\n      detail: `${op.op} grew RSS by ${formatBytes(op.rssDelta)} (heap ${formatBytes(op.heapDelta ?? 0)})`,\n    });\n  }\n  return out;\n}\n\nfunction classifyCrashMarker(marker: CrashMarker | undefined): Finding[] {\n  if (!marker) return [];\n  const explanation: Record<string, string> = {\n    \"js-heap-out-of-memory\":\n      \"the supervisor received ERR_WORKER_OUT_OF_MEMORY: the middle-layer thread exceeded its V8 heap limit\",\n    \"abort-or-fatal-allocation-failure\":\n      \"the process aborted on a fatal allocation failure (V8 fatal out-of-memory, or a failed native allocation)\",\n    \"killed-by-os\":\n      \"the OS killed the process (SIGKILL), which is what an out-of-memory kill looks like\",\n  };\n  const firstLine = marker.message ? marker.message.split(\"\\n\")[0] : \"\";\n  return [\n    {\n      rule:\n        marker.reason === \"js-heap-out-of-memory\"\n          ? \"js-heap-exhaustion-confirmed\"\n          : `crash-${marker.reason}`,\n      severity: \"critical\",\n      source: \"supervisor\",\n      detail: `${explanation[marker.reason] ?? marker.reason}${firstLine ? ` — ${firstLine}` : \"\"}`,\n    },\n  ];\n}\n\nfunction ambiguousMarkerFinding(ambiguous: boolean): Finding[] {\n  if (!ambiguous) return [];\n  return [\n    {\n      rule: \"unattributed-crash-marker\",\n      severity: \"medium\",\n      detail:\n        \"a crash marker sits in this session's time window, but another session in the same directory also stopped writing around then, so it is not attributed to either — spawn the worker with an assigned session id to remove the ambiguity\",\n    },\n  ];\n}\n\nfunction classifyMemory(\n  memory: MemoryAnalysis,\n  env: SessionEnvironment | undefined,\n  crashMarker: CrashMarker | undefined,\n): Finding[] {\n  const out: Finding[] = [];\n\n  // On macOS `os.freemem()` sits near zero at all times because the kernel keeps\n  // free pages in the file cache, so a low reading alone means nothing: the\n  // process itself has to be large before the OS can plausibly have killed it.\n  const rssShare = memory.totalMemory ? (memory.rssAtDeath ?? 0) / memory.totalMemory : 0;\n  if (\n    memory.freeMemoryAtDeath !== undefined &&\n    memory.totalMemory &&\n    memory.freeMemoryAtDeath < memory.totalMemory * 0.03 &&\n    rssShare > THRESHOLDS.machineRssShare\n  ) {\n    out.push({\n      rule: \"machine-memory-exhausted\",\n      severity: \"critical\",\n      detail: `process held ${formatBytes(memory.rssAtDeath)} (${Math.round(rssShare * 100)}%) of ${formatBytes(\n        memory.totalMemory,\n      )} with ${formatBytes(memory.freeMemoryAtDeath)} free — the OS, not V8, ended the process`,\n    });\n  }\n\n  // The last in-thread heap reading predates a synchronous blow-up, so a low\n  // reading is not evidence of a healthy heap. Say so rather than conclude.\n  if (\n    !crashMarker &&\n    memory.heapPressure !== undefined &&\n    memory.heapPressure < THRESHOLDS.heapPressure &&\n    memory.worstStallMs >= THRESHOLDS.stallMs\n  ) {\n    out.push({\n      rule: \"heap-reading-stale\",\n      severity: \"medium\",\n      detail: `last JS heap reading is ${formatBytes(memory.heapUsedAtDeath)} but the thread was blocked for ${Math.round(\n        memory.worstStallMs,\n      )}ms before the log ends, so the heap was never sampled near the crash`,\n    });\n  }\n\n  if ((memory.heapPressure ?? 0) >= THRESHOLDS.heapPressure) {\n    const flag = env?.maxOldSpaceSize ? ` (--max-old-space-size=${env.maxOldSpaceSize})` : \"\";\n    out.push({\n      rule: \"js-heap-exhaustion\",\n      severity: \"critical\",\n      detail: `JS heap at ${Math.round((memory.heapPressure ?? 0) * 100)}% of its ${formatBytes(\n        memory.heapLimit,\n      )} limit${flag}`,\n    });\n  }\n\n  const offHeap = (memory.externalGrowth ?? 0) + (memory.arrayBuffersGrowth ?? 0);\n  const heapGrowth = memory.heapGrowth ?? 0;\n  if (memory.rssGrowth >= THRESHOLDS.nativeGrowthBytes && heapGrowth < memory.rssGrowth / 4) {\n    const offHeapDominant = offHeap >= THRESHOLDS.nativeGrowthBytes;\n    out.push({\n      rule: offHeapDominant ? \"off-heap-buffer-growth\" : \"native-allocation-growth\",\n      severity: \"critical\",\n      detail: offHeapDominant\n        ? `RSS grew ${formatBytes(memory.rssGrowth)} while the JS heap grew ${formatBytes(\n            heapGrowth,\n          )}; off-heap ArrayBuffer/external allocation grew ${formatBytes(offHeap)} — the growth is buffers handed out by the pframes engine, not JavaScript objects. Raising --max-old-space-size will not help.`\n        : `RSS grew ${formatBytes(memory.rssGrowth)} while the JS heap grew only ${formatBytes(\n            heapGrowth,\n          )} — the allocation is native (pframes engine / Arrow buffers), not JavaScript. Raising --max-old-space-size will not help.`,\n    });\n  }\n  return out;\n}\n\nfunction stallFindings(memory: MemoryAnalysis): Finding[] {\n  if (memory.worstStallMs < THRESHOLDS.stallMs) return [];\n  return [\n    {\n      rule: \"event-loop-stall\",\n      severity: \"medium\",\n      detail: `the recorded thread was blocked for ${Math.round(\n        memory.worstStallMs,\n      )}ms — synchronous work (model evaluation, or a blocking native call)`,\n    },\n  ];\n}\n\nfunction summarizeRenders(records: FlightRecord[]): RenderSummary[] {\n  const open = new Map<number, RenderSummary>();\n  const out: RenderSummary[] = [];\n  for (const record of records) {\n    if (record.type === \"render-begin\") {\n      // A render open across a rotation is written twice under one sequence\n      // number; the carried copy must not become a second, never-finished render.\n      if (open.has(record.seq)) continue;\n      const summary: RenderSummary = {\n        seq: record.seq,\n        blockId: record.blockId as string | undefined,\n        block: record.block as string | undefined,\n        key: record.key as string | undefined,\n      };\n      open.set(record.seq, summary);\n      out.push(summary);\n      continue;\n    }\n    if (record.type !== \"render-end\" && record.type !== \"render-error\") continue;\n    const summary = record.begin === undefined ? undefined : open.get(record.begin);\n    if (!summary) continue;\n    summary.end = true;\n    summary.ms = record.ms as number | undefined;\n    summary.stats = record.stats as RenderSummary[\"stats\"];\n    summary.failed = record.type === \"render-error\";\n  }\n  return out;\n}\n\nfunction buildVerdict(input: {\n  crashed: boolean;\n  memory: MemoryAnalysis;\n  inFlight: OperationSummary[];\n  findings: Finding[];\n  crashMarker?: CrashMarker;\n  /** Block whose render was open at each sequence number. */\n  blockOf: Map<number, string>;\n}): Verdict {\n  const { crashed, memory, inFlight, findings, crashMarker, blockOf } = input;\n  const gun = inFlight.at(-1);\n  const region = findings.find((finding) => REGION_RULES.includes(finding.rule));\n  const cause = findings.find((finding) => CAUSE_RULES.includes(finding.rule));\n\n  // A driver call carries no block identity of its own, so it is taken from the\n  // render that was open around it rather than from whichever finding happens\n  // to have one.\n  const blockId =\n    (gun?.info?.blockId as string | undefined) ??\n    (gun === undefined ? undefined : blockOf.get(gun.seq)) ??\n    findings.find((finding) => finding.block)?.block;\n  return {\n    outcome: crashed\n      ? `session ended without shutdown${\n          crashMarker ? ` — supervisor reported ${crashMarker.reason}` : \" (no supervisor marker)\"\n        }`\n      : \"clean shutdown\",\n    peakRss: memory.peakRss,\n    where: gun\n      ? `${gun.op} started at seq ${gun.seq} and never returned${blockId ? ` (block ${blockId})` : \"\"}`\n      : \"no operation was in flight\",\n    memoryRegion: region?.rule,\n    likelyCause: cause?.rule ?? findings[0]?.rule,\n    summary: [\n      crashed ? \"Process died without running shutdown.\" : \"Session closed normally.\",\n      gun ? `Last unfinished operation: ${gun.op} (seq ${gun.seq}).` : undefined,\n      region?.detail,\n      cause ? `Probable cause: ${cause.rule} — ${cause.detail}` : undefined,\n    ]\n      .filter(Boolean)\n      .join(\" \"),\n  };\n}\n\nfunction inlineColumns(\n  def: unknown,\n  acc: { entries?: number; approxBytes?: number }[] = [],\n): { entries?: number; approxBytes?: number }[] {\n  if (!def || typeof def !== \"object\") return acc;\n  const node = def as Record<string, unknown>;\n  const data = node.data as { kind?: string; entries?: number; approxBytes?: number } | undefined;\n  if (data?.kind === \"inline\") acc.push(data);\n  for (const value of Object.values(node)) {\n    if (Array.isArray(value)) {\n      for (const child of value) inlineColumns(child, acc);\n    } else if (value && typeof value === \"object\") {\n      inlineColumns(value, acc);\n    }\n  }\n  return acc;\n}\n\nfunction compactRecord(record: FlightRecord): Record<string, unknown> {\n  const { mem, def, ...rest } = record;\n  const out: Record<string, unknown> = { ...rest };\n  if (mem) out.rss = mem.rss;\n  if (def) out.defSummary = summarizeDef(def);\n  return out;\n}\n\nfunction summarizeDef(digest: unknown): Record<string, unknown> {\n  const typed = digest as { kind?: string; redaction?: { bytes?: number } } | undefined;\n  const def = recordedDefFrom(digest);\n  const outermost = joinShapes(def)[0];\n  return {\n    kind: typed?.kind,\n    bytes: typed?.redaction?.bytes,\n    join: outermost?.join,\n    children: outermost?.childCount,\n    sharedAxes: outermost?.sharedAxes.length,\n    inputRowsMax: outermost?.inputRowsMax ?? inputRowsMax(def),\n    rowsUpperBound: outermost?.rowsUpperBound,\n  };\n}\n\n/** The redacted definition inside a record, if it carries one. */\nfunction recordedDef(record: FlightRecord): unknown {\n  return recordedDefFrom(record.def);\n}\n\nfunction recordedDefFrom(digest: unknown): unknown {\n  if (!digest || typeof digest !== \"object\") return undefined;\n  return (digest as { def?: unknown }).def;\n}\n\n/** Definition of each creation call, keyed by the sequence number of its record. */\nfunction definitionBySeq(records: FlightRecord[]): Map<number, unknown> {\n  const out = new Map<number, unknown>();\n  for (const record of records) {\n    const def = recordedDef(record);\n    if (def !== undefined) out.set(record.seq, def);\n  }\n  return out;\n}\n\nfunction bySeverity(lhs: Finding, rhs: Finding): number {\n  return (SEVERITY_ORDER[lhs.severity] ?? 9) - (SEVERITY_ORDER[rhs.severity] ?? 9);\n}\n"],"mappings":"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"}

package/dist/data_summary.d.ts

@@ -0,0 +1,28 @@
+//#region src/data_summary.d.ts
+/**
+ * Counts and sizes for a column payload, never the payload.
+ *
+ * This is the one place that has to know the shape of `DataInfo`, because the
+ * numbers that predict a join's cost — rows per partition and their byte sizes —
+ * live at type-specific positions inside it. Everything else about a definition
+ * is recorded structurally.
+ *
+ * Chunk statistics are optional: the producing workflow fills them in, so row
+ * counts are reported when present and left unknown otherwise rather than
+ * guessed.
+ */
+export type DataSummary = {
+  kind: string;
+  /** Entries for inline or JSON payloads. */
+  entries?: number;
+  approxBytes?: number;
+  keyLength?: number;
+  partitionKeyLength?: number;
+  parts?: number;
+  partsWithStats?: number;
+  rows?: number;
+  bytes?: number;
+};
+export declare function summarizeData(data: unknown): DataSummary;
+//#endregion
+//# sourceMappingURL=data_summary.d.ts.map

package/dist/data_summary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data_summary.d.ts","names":[],"sources":["../src/data_summary.ts"],"mappings":";;;;;;;;;;;;;YAaY;EACV;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;wBAGc,cAAc,gBAAgB"}