@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.4

package/dist/builtin/workflows/src/shared/expanded-workflow-graph.ts

@@ -1,434 +0,0 @@
-import type { RunSnapshot, StageSnapshot, StoreSnapshot, ToolNodeSnapshot } from "./store-types.js";
-import { authoritativeWorkflowChildRunId, reciprocalWorkflowRootRunId } from "./workflow-run-ownership.js";
-
-export interface ExpandedWorkflowStageTarget {
-	readonly runId: string;
-	readonly stageId: string;
-	readonly runName: string;
-	readonly depth: number;
-}
-
-export interface ExpandedWorkflowStage extends StageSnapshot {
-	readonly workflowGraphTarget: ExpandedWorkflowStageTarget;
-}
-
-export interface ExpandedWorkflowTool extends ToolNodeSnapshot {
-	readonly runId: string;
-	readonly runName: string;
-	readonly depth: number;
-}
-
-export type ExpandedWorkflowNode =
-	| { readonly kind: "stage"; readonly stage: ExpandedWorkflowStage }
-	| { readonly kind: "tool"; readonly tool: ExpandedWorkflowTool };
-
-export interface ExpandedWorkflowGraph {
-	/** Stage-only inspection/control nodes; excludes tool projections. */
-	readonly stages: readonly ExpandedWorkflowStage[];
-	readonly tools: readonly ExpandedWorkflowTool[];
-	readonly nodes: readonly ExpandedWorkflowNode[];
-	/** All stage-compatible render projections, including non-attachable tool cards. */
-	readonly renderStages: readonly ExpandedWorkflowStage[];
-	/**
-	 * Control targets for stages and tool nodes. Tool entries are abort-only
-	 * control targets: they stay `attachable: false` and never become chat
-	 * targets (see `graph-view-state._stageChatTarget`).
-	 */
-	readonly targets: ReadonlyMap<string, ExpandedWorkflowStageTarget>;
-}
-
-interface ExpandedRunResult {
-	readonly stages: ExpandedWorkflowStage[];
-	readonly tools: ExpandedWorkflowTool[];
-	readonly nodes: ExpandedWorkflowNode[];
-	readonly terminalIds: readonly string[];
-}
-
-type LocalItem =
-	| { readonly kind: "stage"; readonly stage: StageSnapshot; readonly sourceIndex: number }
-	| { readonly kind: "tool"; readonly tool: ToolNodeSnapshot; readonly sourceIndex: number };
-
-function virtualNodeId(runId: string, nodeId: string, isRootRun: boolean): string {
-	return isRootRun ? nodeId : `${runId}:${nodeId}`;
-}
-
-function localItems(run: RunSnapshot): LocalItem[] {
-	const stages = run.stages.map((stage, sourceIndex) => ({ kind: "stage" as const, stage, sourceIndex }));
-	const tools = (run.toolNodes ?? []).map((tool, sourceIndex) => ({ kind: "tool" as const, tool, sourceIndex }));
-	return [...stages, ...tools].sort((left, right) => {
-		const leftOrder = left.kind === "stage" ? left.stage.executionOrder : left.tool.executionOrder;
-		const rightOrder = right.kind === "stage" ? right.stage.executionOrder : right.tool.executionOrder;
-		if (leftOrder !== undefined || rightOrder !== undefined)
-			return (leftOrder ?? Number.MAX_SAFE_INTEGER) - (rightOrder ?? Number.MAX_SAFE_INTEGER);
-		if (left.kind !== right.kind) return left.kind === "stage" ? -1 : 1;
-		return left.sourceIndex - right.sourceIndex;
-	});
-}
-
-function itemId(item: LocalItem): string {
-	return item.kind === "stage" ? item.stage.id : item.tool.id;
-}
-
-function itemParents(item: LocalItem): readonly string[] {
-	return item.kind === "stage" ? item.stage.parentIds : item.tool.parentIds;
-}
-
-function localTerminalIds(items: readonly LocalItem[]): readonly string[] {
-	const parents = new Set(items.flatMap((item) => [...itemParents(item)]));
-	const terminals = items.map(itemId).filter((id) => !parents.has(id));
-	return terminals.length > 0 ? terminals : items.map(itemId);
-}
-
-function isTerminalNonCompletedBoundary(stage: StageSnapshot): boolean {
-	return stage.status === "failed" || stage.status === "skipped";
-}
-
-function childAliasFor(stage: StageSnapshot): string | undefined {
-	if (isTerminalNonCompletedBoundary(stage)) return undefined;
-	if (stage.status === "completed") return stage.workflowChild?.alias ?? stage.workflowChildRun?.alias;
-	return stage.workflowChildRun?.alias;
-}
-
-function projectedToolStatus(tool: ToolNodeSnapshot): StageSnapshot["status"] {
-	if (tool.status === "cached") return "completed";
-	if (tool.status === "cancelled") return "skipped";
-	return tool.status;
-}
-
-export function expandWorkflowGraph(snapshot: StoreSnapshot, rootRunId: string): ExpandedWorkflowGraph {
-	const runById = new Map(snapshot.runs.map((run) => [run.id, run]));
-	const root = runById.get(rootRunId);
-	if (!root) return { stages: [], renderStages: [], tools: [], nodes: [], targets: new Map() };
-	const targets = new Map<string, ExpandedWorkflowStageTarget>();
-	const rootOwnerByRunId = new Map<string, string | undefined>();
-	const rootOwnerFor = (runId: string): string | undefined => {
-		if (rootOwnerByRunId.has(runId)) return rootOwnerByRunId.get(runId);
-		const owner = reciprocalWorkflowRootRunId(runById, runId);
-		rootOwnerByRunId.set(runId, owner);
-		return owner;
-	};
-	const visiting = new Set<string>();
-	const expandedChildren = new Set<string>();
-
-	const expandRun = (run: RunSnapshot, depth: number, incomingParentIds: readonly string[]): ExpandedRunResult => {
-		if (visiting.has(run.id)) return { stages: [], tools: [], nodes: [], terminalIds: [] };
-		visiting.add(run.id);
-		const isRootRun = run.id === rootRunId;
-		const items = localItems(run);
-		const stages: ExpandedWorkflowStage[] = [];
-		const tools: ExpandedWorkflowTool[] = [];
-		const nodes: ExpandedWorkflowNode[] = [];
-		const stageById = new Map(run.stages.map((stage) => [stage.id, stage]));
-		const boundaryExpansions = new Map<string, ExpandedRunResult | null>();
-
-		const validChildRunFor = (stage: StageSnapshot): RunSnapshot | undefined => {
-			const childRunId = authoritativeWorkflowChildRunId(stage);
-			if (childRunId === undefined) return undefined;
-			const childRun = runById.get(childRunId);
-			const runRoot = rootOwnerFor(run.id);
-			if (
-				childRun === undefined ||
-				expandedChildren.has(childRun.id) ||
-				localItems(childRun).length === 0 ||
-				childRun.parentRunId !== run.id ||
-				childRun.parentStageId !== stage.id ||
-				runRoot === undefined ||
-				rootOwnerFor(childRun.id) !== runRoot
-			) {
-				return undefined;
-			}
-			return childRun;
-		};
-
-		const resolvedParentIdsFor = (item: LocalItem): string[] => {
-			const parentIds = itemParents(item);
-			if (parentIds.length === 0) return [...incomingParentIds];
-			return parentIds.flatMap((parentId) => {
-				const parentStage = stageById.get(parentId);
-				const parentExpansion = parentStage === undefined ? undefined : boundaryExpansionFor(parentStage);
-				return parentExpansion?.terminalIds.length
-					? [...parentExpansion.terminalIds]
-					: [virtualNodeId(run.id, parentId, isRootRun)];
-			});
-		};
-
-		const boundaryExpansionFor = (stage: StageSnapshot): ExpandedRunResult | undefined => {
-			const cached = boundaryExpansions.get(stage.id);
-			if (cached !== undefined) return cached ?? undefined;
-			const childRun = validChildRunFor(stage);
-			if (childRun === undefined) return undefined;
-			boundaryExpansions.set(stage.id, null);
-			expandedChildren.add(childRun.id);
-			const stageItem: LocalItem = { kind: "stage", stage, sourceIndex: 0 };
-			const childExpanded = expandRun(childRun, depth + 1, resolvedParentIdsFor(stageItem));
-			if (childExpanded.stages.length === 0 || childExpanded.terminalIds.length === 0) return undefined;
-			boundaryExpansions.set(stage.id, childExpanded);
-			return childExpanded;
-		};
-
-		for (const item of items) {
-			const sourceId = itemId(item);
-			const id = virtualNodeId(run.id, sourceId, isRootRun);
-			const resolvedParentIds = resolvedParentIdsFor(item);
-
-			if (item.kind === "tool") {
-				const tool: ExpandedWorkflowTool = {
-					...item.tool,
-					id,
-					parentIds: Object.freeze(resolvedParentIds),
-					runId: run.id,
-					runName: run.name,
-					depth,
-				};
-				const projectionTarget: ExpandedWorkflowStageTarget = {
-					runId: run.id,
-					stageId: item.tool.id,
-					runName: run.name,
-					depth,
-				};
-				const projection: ExpandedWorkflowStage = {
-					id,
-					name: item.tool.name,
-					status: projectedToolStatus(item.tool),
-					parentIds: Object.freeze(resolvedParentIds),
-					executionOrder: item.tool.executionOrder,
-					nodeKind: "tool",
-					toolStatus: item.tool.status,
-					startedAt: item.tool.startedAt,
-					endedAt: item.tool.endedAt,
-					result: item.tool.resultSummary,
-					error: item.tool.error,
-					toolEvents: [],
-					attachable: false,
-					workflowGraphTarget: projectionTarget,
-				};
-				targets.set(id, projectionTarget);
-				tools.push(tool);
-				stages.push(projection);
-				nodes.push({ kind: "tool", tool });
-				continue;
-			}
-
-			const childExpanded = boundaryExpansionFor(item.stage);
-			if (childExpanded !== undefined) {
-				stages.push(...childExpanded.stages);
-				tools.push(...childExpanded.tools);
-				nodes.push(...childExpanded.nodes);
-				continue;
-			}
-
-			const target: ExpandedWorkflowStageTarget = {
-				runId: run.id,
-				stageId: item.stage.id,
-				runName: run.name,
-				depth,
-			};
-			targets.set(id, target);
-			const stage: ExpandedWorkflowStage = {
-				...item.stage,
-				id,
-				parentIds: Object.freeze(resolvedParentIds),
-				workflowGraphTarget: target,
-			};
-			stages.push(stage);
-			nodes.push({ kind: "stage", stage });
-		}
-
-		const terminalIds = localTerminalIds(items).flatMap((sourceId) => {
-			const stage = stageById.get(sourceId);
-			const replacement = stage === undefined ? undefined : boundaryExpansionFor(stage);
-			return replacement?.terminalIds.length
-				? [...replacement.terminalIds]
-				: [virtualNodeId(run.id, sourceId, isRootRun)];
-		});
-		visiting.delete(run.id);
-		return { stages, tools, nodes, terminalIds };
-	};
-
-	const expanded = expandRun(root, 0, []);
-	return {
-		stages: expanded.stages.filter((stage) => stage.nodeKind !== "tool"),
-		renderStages: expanded.stages,
-		tools: expanded.tools,
-		nodes: expanded.nodes,
-		targets,
-	};
-}
-
-function sameIds(left: readonly string[], right: readonly string[]): boolean {
-	if (left.length !== right.length) return false;
-	for (let index = 0; index < left.length; index++) {
-		if (left[index] !== right[index]) return false;
-	}
-	return true;
-}
-
-interface RefreshRunSources {
-	readonly run: RunSnapshot;
-	readonly stages: ReadonlyMap<string, StageSnapshot>;
-	readonly tools: ReadonlyMap<string, ToolNodeSnapshot>;
-}
-
-function refreshRunSources(snapshot: StoreSnapshot): Map<string, RefreshRunSources> {
-	return new Map(
-		snapshot.runs.map((run) => [
-			run.id,
-			{
-				run,
-				stages: new Map(run.stages.map((stage) => [stage.id, stage])),
-				tools: new Map((run.toolNodes ?? []).map((tool) => [tool.id, tool])),
-			},
-		]),
-	);
-}
-
-export function sameExpandedWorkflowTopology(left: StoreSnapshot, right: StoreSnapshot): boolean {
-	if (left.runs.length !== right.runs.length) return false;
-	for (let runIndex = 0; runIndex < left.runs.length; runIndex++) {
-		const a = left.runs[runIndex]!;
-		const b = right.runs[runIndex]!;
-		if (
-			a.id !== b.id ||
-			a.parentRunId !== b.parentRunId ||
-			a.parentStageId !== b.parentStageId ||
-			a.rootRunId !== b.rootRunId ||
-			a.stages.length !== b.stages.length ||
-			(a.toolNodes?.length ?? 0) !== (b.toolNodes?.length ?? 0)
-		)
-			return false;
-		for (let stageIndex = 0; stageIndex < a.stages.length; stageIndex++) {
-			const x = a.stages[stageIndex]!;
-			const y = b.stages[stageIndex]!;
-			const xChildRunId = authoritativeWorkflowChildRunId(x);
-			const yChildRunId = authoritativeWorkflowChildRunId(y);
-			if (
-				x.id !== y.id ||
-				x.executionOrder !== y.executionOrder ||
-				x.nodeKind !== y.nodeKind ||
-				// The authoritative id becomes undefined at failed/skipped boundaries,
-				// so this comparison also catches a terminal-boundary flip.
-				xChildRunId !== yChildRunId ||
-				!sameIds(x.parentIds, y.parentIds)
-			)
-				return false;
-		}
-		const aTools = a.toolNodes ?? [];
-		const bTools = b.toolNodes ?? [];
-		for (let toolIndex = 0; toolIndex < aTools.length; toolIndex++) {
-			const x = aTools[toolIndex]!;
-			const y = bTools[toolIndex]!;
-			if (x.id !== y.id || x.executionOrder !== y.executionOrder || !sameIds(x.parentIds, y.parentIds)) return false;
-		}
-	}
-	return true;
-}
-
-export function refreshExpandedWorkflowGraph(
-	graph: ExpandedWorkflowGraph,
-	snapshot: StoreSnapshot,
-): ExpandedWorkflowGraph | undefined {
-	const sourcesByRunId = refreshRunSources(snapshot);
-	const refreshedStages = new Map<string, ExpandedWorkflowStage>();
-	const refreshedTools = new Map<string, ExpandedWorkflowTool>();
-	const renderStages: ExpandedWorkflowStage[] = [];
-
-	for (const cached of graph.renderStages) {
-		const target = graph.targets.get(cached.id);
-		const sources = target ? sourcesByRunId.get(target.runId) : undefined;
-		if (!target || !sources) return undefined;
-		if (cached.nodeKind === "tool") {
-			const source = sources.tools.get(target.stageId);
-			if (!source) return undefined;
-			const stage: ExpandedWorkflowStage = {
-				id: cached.id,
-				name: source.name,
-				status: projectedToolStatus(source),
-				parentIds: cached.parentIds,
-				executionOrder: source.executionOrder,
-				nodeKind: "tool",
-				toolStatus: source.status,
-				startedAt: source.startedAt,
-				endedAt: source.endedAt,
-				result: source.resultSummary,
-				error: source.error,
-				toolEvents: [],
-				attachable: false,
-				workflowGraphTarget: target,
-			};
-			renderStages.push(stage);
-			refreshedStages.set(stage.id, stage);
-			continue;
-		}
-		const source = sources.stages.get(target.stageId);
-		if (!source) return undefined;
-		const stage: ExpandedWorkflowStage = {
-			...source,
-			id: cached.id,
-			parentIds: cached.parentIds,
-			workflowGraphTarget: target,
-		};
-		renderStages.push(stage);
-		refreshedStages.set(stage.id, stage);
-	}
-
-	const stages = renderStages.filter((stage) => stage.nodeKind !== "tool");
-	const tools: ExpandedWorkflowTool[] = [];
-
-	for (const cached of graph.tools) {
-		const target = graph.targets.get(cached.id);
-		const sources = target ? sourcesByRunId.get(target.runId) : undefined;
-		const source = target ? sources?.tools.get(target.stageId) : undefined;
-		if (!target || !sources || !source) return undefined;
-		const tool: ExpandedWorkflowTool = {
-			...source,
-			id: cached.id,
-			parentIds: cached.parentIds,
-			runId: sources.run.id,
-			runName: sources.run.name,
-			depth: target.depth,
-		};
-		tools.push(tool);
-		refreshedTools.set(tool.id, tool);
-	}
-
-	const nodes: ExpandedWorkflowNode[] = [];
-	for (const node of graph.nodes) {
-		if (node.kind === "stage") {
-			const stage = refreshedStages.get(node.stage.id);
-			if (!stage) return undefined;
-			nodes.push({ kind: "stage", stage });
-			continue;
-		}
-		const tool = refreshedTools.get(node.tool.id);
-		if (!tool) return undefined;
-		nodes.push({ kind: "tool", tool });
-	}
-	return { stages, tools, nodes, renderStages, targets: graph.targets };
-}
-
-export function expandedStageTarget(
-	graph: ExpandedWorkflowGraph,
-	virtualStageIdValue: string,
-): ExpandedWorkflowStageTarget | undefined {
-	return graph.targets.get(virtualStageIdValue);
-}
-
-/**
- * Exact-match only. A stage id is never truncated to address a stage: at the
- * root that id is a bare UUID, nested it is the `runId:nodeId` composite built
- * by `virtualNodeId`, and a tool node carries `tool:<argsHash>`. Names match
- * whole, so `build` never selects `build-check`.
- */
-export function stageMatchesExpandedIdentifier(stage: ExpandedWorkflowStage, target: string): boolean {
-	const graphTarget = stage.workflowGraphTarget;
-	return (
-		stage.id === target || stage.name === target || graphTarget.stageId === target || graphTarget.runId === target
-	);
-}
-
-export function expandedStageLabel(stage: ExpandedWorkflowStage): string {
-	const target = stage.workflowGraphTarget;
-	if (stage.nodeKind === "tool") return `${stage.name} (tool)`;
-	const depthPrefix = target.depth > 0 ? `${childAliasFor(stage) ?? target.runName}:` : "";
-	return `${depthPrefix}${stage.name} (${target.runId}/${target.stageId})`;
-}

package/dist/builtin/workflows/src/shared/flat-string.ts

@@ -1,33 +0,0 @@
-/**
- * Truncation that actually releases the untruncated source.
- *
- * V8 does not copy characters for `String.prototype.slice`. For a flat parent of
- * 13 characters or more it allocates a **SlicedString**, which is a length, an
- * offset, and a pointer to the parent. Template interpolation then wraps that in
- * a **ConsString**, which keeps the same pointer. So the obvious way to bound a
- * value for storage:
- *
- * ```ts
- * `${JSON.stringify(value).slice(0, 237)}...`
- * ```
- *
- * produces a 240-character string that reports `length === 240` while holding
- * the entire serialized payload alive. The bound is on what you can read, not on
- * what you retain. An 8 MiB tool result summarized to 240 characters still costs
- * 8 MiB for as long as anything keeps the summary.
- *
- * That is invisible in every ordinary test: the value is correct, its length is
- * correct, and equality holds. It only shows up as heap that never comes back.
- *
- * `split("").join("")` copies the code units into a fresh flat string with no
- * parent pointer. It is code-unit exact, including lone surrogates, because
- * `split("")` splits on UTF-16 code units rather than code points.
- *
- * Use this at any truncation whose result outlives the value it came from —
- * memoized projections, durable checkpoints, catalogs, persisted summaries.
- * A truncation that is consumed and dropped within the same turn does not need
- * it, and paying for a copy there is waste.
- */
-export function flattenTruncatedString(value: string): string {
-	return value.split("").join("");
-}

package/dist/builtin/workflows/src/shared/graph-store-snapshot.ts

@@ -1,188 +0,0 @@
-import { flattenTruncatedString } from "./flat-string.js";
-import type {
-	PendingPrompt,
-	RunSnapshot,
-	StageInputRequest,
-	StageSnapshot,
-	StoreSnapshot,
-	ToolEvent,
-	ToolNodeSnapshot,
-	WorkflowChildReplaySnapshot,
-	WorkflowNotice,
-} from "./store-types.js";
-import { boundedToolPayload, boundedToolPayloadRecord, boundedToolText } from "./tool-payload-bounds.js";
-import type { WorkflowOutputValues, WorkflowSerializableValue } from "./types.js";
-
-export const COMPACT_RESULT_FIELD_LIMIT = 1024;
-const COMPACT_EXIT_OUTPUT_LIMIT = COMPACT_RESULT_FIELD_LIMIT * 4;
-
-function compactResultField(value: WorkflowSerializableValue | undefined): string | undefined {
-	if (typeof value !== "string") return undefined;
-	if (value.length <= COMPACT_RESULT_FIELD_LIMIT) return value;
-	// Flattened, not just sliced: `graphSnapshot()` memoizes this projection, so a
-	// SlicedString here would keep the whole run result alive inside the store.
-	return flattenTruncatedString(value.slice(0, COMPACT_RESULT_FIELD_LIMIT));
-}
-
-function compactRunResult(
-	result: WorkflowOutputValues | undefined,
-	preserveExitedOutputs = false,
-): WorkflowOutputValues | undefined {
-	if (result === undefined) return undefined;
-	const status = compactResultField(result.status);
-	const summary = compactResultField(result.summary);
-	const remainingWork = compactResultField(result.remaining_work);
-	const resultText = compactResultField(result.result);
-	const compact: WorkflowOutputValues = {
-		...(status !== undefined ? { status } : {}),
-		...(summary !== undefined ? { summary } : {}),
-		...(remainingWork !== undefined ? { remaining_work: remainingWork } : {}),
-		...(resultText !== undefined ? { result: resultText } : {}),
-	};
-	if (!preserveExitedOutputs) return Object.keys(compact).length === 0 ? undefined : compact;
-	return compactExitedOutputs(result, compact);
-}
-
-function compactExitedOutputs(
-	result: WorkflowOutputValues,
-	compact: WorkflowOutputValues,
-): WorkflowOutputValues | undefined {
-	try {
-		const serialized = JSON.stringify(result);
-		if (serialized !== undefined && serialized.length <= COMPACT_EXIT_OUTPUT_LIMIT) {
-			const parsed: unknown = JSON.parse(serialized);
-			if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
-				return compactExitedObject(parsed as Record<string, WorkflowSerializableValue>);
-			}
-		}
-	} catch {
-		// Fall through to the bounded legacy fields below.
-	}
-	return Object.keys(compact).length === 0 ? undefined : compact;
-}
-
-function compactExitedObject(result: Record<string, WorkflowSerializableValue>): WorkflowOutputValues | undefined {
-	const compacted = { ...result };
-	for (const key of ["status", "summary", "remaining_work", "result"]) {
-		const value = compacted[key];
-		if (typeof value === "string") compacted[key] = compactResultField(value) ?? "";
-	}
-	return Object.keys(compacted).length === 0 ? undefined : compacted;
-}
-
-// Both cloners are called only from a `!== undefined` guard at their call sites,
-// so they take and return a concrete value; an internal undefined branch here
-// would be unreachable and would only weaken the type for every caller.
-function clonePrompt(prompt: PendingPrompt): PendingPrompt {
-	return {
-		...prompt,
-		...(prompt.choices !== undefined ? { choices: [...prompt.choices] } : {}),
-	};
-}
-
-function cloneInputRequest(request: StageInputRequest): StageInputRequest {
-	return {
-		...request,
-		questions: request.questions.map((question) => ({
-			...question,
-			options: question.options.map((option) => ({ ...option })),
-		})),
-	};
-}
-
-function compactToolEvents(events: readonly ToolEvent[]): ToolEvent[] {
-	const event = events.at(-1);
-	return event === undefined ? [] : [{ name: event.name }];
-}
-
-function compactWorkflowChild(child: WorkflowChildReplaySnapshot): WorkflowChildReplaySnapshot {
-	return {
-		...child,
-		outputs: {},
-		outputCount: child.outputCount ?? Object.keys(child.outputs).length,
-	};
-}
-
-function compactStage(stage: StageSnapshot): StageSnapshot {
-	const {
-		toolEvents,
-		workflowChild,
-		workflowChildRun,
-		pendingPrompt,
-		promptFootprint,
-		inputRequest,
-		notices,
-		mcpScope: _mcpScope,
-		attemptedModels: _attemptedModels,
-		modelAttempts: _modelAttempts,
-		// Agent-stage results can be unbounded and graph cards do not render
-		// them. Tool cards render a constant body, so `resultSummary` is kept
-		// for status surfaces while the bounded full payload below backs the
-		// read-only detail view.
-		result: _result,
-		...metadata
-	} = stage;
-	return {
-		...metadata,
-		parentIds: [...stage.parentIds],
-		toolEvents: compactToolEvents(toolEvents),
-		...(workflowChild !== undefined ? { workflowChild: compactWorkflowChild(workflowChild) } : {}),
-		...(workflowChildRun !== undefined ? { workflowChildRun: { ...workflowChildRun } } : {}),
-		...(pendingPrompt !== undefined ? { pendingPrompt: clonePrompt(pendingPrompt) } : {}),
-		...(promptFootprint !== undefined ? { promptFootprint: clonePrompt(promptFootprint) } : {}),
-		...(inputRequest !== undefined ? { inputRequest: cloneInputRequest(inputRequest) } : {}),
-		...(notices !== undefined ? { notices: notices.map((notice) => ({ ...notice })) } : {}),
-	};
-}
-
-function compactToolNode(node: ToolNodeSnapshot): ToolNodeSnapshot {
-	return {
-		...node,
-		parentIds: [...node.parentIds],
-		// Author payloads may be cyclic, may throw on property access, and may be
-		// arbitrarily large. `boundedToolPayload` contains all three so building a
-		// snapshot cannot throw and one version cannot retain a whole payload.
-		...(node.args !== undefined ? { args: boundedToolPayloadRecord(node.args) } : {}),
-		...(node.result !== undefined ? { result: boundedToolPayload(node.result) } : {}),
-		...(node.source !== undefined ? { source: boundedToolText(node.source) } : {}),
-	};
-}
-
-function compactRun(run: RunSnapshot): RunSnapshot {
-	const { inputs: _inputs, result: sourceResult, stages, toolNodes, pendingPrompt, ...metadata } = run;
-	const result = compactRunResult(sourceResult, run.exited === true && run.status === "failed");
-	return {
-		...metadata,
-		inputs: {},
-		stages: stages.map(compactStage),
-		...(toolNodes !== undefined ? { toolNodes: toolNodes.map(compactToolNode) } : {}),
-		...(pendingPrompt !== undefined ? { pendingPrompt: clonePrompt(pendingPrompt) } : {}),
-		...(result !== undefined ? { result } : {}),
-	};
-}
-
-export function createGraphStoreSnapshot(
-	runs: readonly RunSnapshot[],
-	notices: readonly WorkflowNotice[],
-	version: number,
-): StoreSnapshot {
-	const snapshot: StoreSnapshot = {
-		runs: runs.map(compactRun),
-		notices: notices.map((notice) => ({ ...notice })),
-		version,
-	};
-	deepFreezeGraphValue(snapshot);
-	return snapshot;
-}
-
-function deepFreezeGraphValue(value: unknown): void {
-	if (value === null || typeof value !== "object" || Object.isFrozen(value)) return;
-	Object.freeze(value);
-	if (Array.isArray(value)) {
-		for (const item of value) deepFreezeGraphValue(item);
-		return;
-	}
-	for (const key of Object.keys(value as Record<string, unknown>)) {
-		deepFreezeGraphValue((value as Record<string, unknown>)[key]);
-	}
-}