@tangle-network/agent-runtime 0.165.0 → 0.166.0

package/dist/graph.js

@@ -1,1819 +1,2 @@
-import { m as ValidationError } from "./errors-CDZ8XsVj.js";
-import { d as replaySpawnTree, i as InMemorySpawnJournal, l as materializeTreeView, o as closesCursorSlot, r as InMemoryResultBlobStore, u as pendingWaits, x as contentAddress } from "./spawn-journal-Tgvp5VS5.js";
-import { t as addSpend } from "./util-D6ZEuBMi.js";
-import { N as createBudgetPool, U as createExecutorRegistry, a as uncertainSpawnBudgets, i as sumMeasuredSpendFromEvents, l as runFinalizer, o as bestDelivered, p as createScope, r as maxSeqOf, s as collectDelivered } from "./supervisor-DpIKMlPJ.js";
-import { i as workerFromBackend, s as supervisorAgent } from "./supervise-Da20R0PO.js";
-import { t as GraphEdgeCapError } from "./graph-DGri_zJm.js";
-//#region src/runtime/graph/condition.ts
-/**
-* The ONE predicate tree: every guard in a graph — an edge `guard`, a filter projection's
-* predicate — is this shape, evaluated by this evaluator, so `contains`, ordering and equality can
-* never mean two different things on two surfaces (adopted from ADC's `workflow-conditions`,
-* agent-runtime#968). A declarative tree keeps an untrusted predicate incapable of code execution;
-* the size and depth bounds keep a predicate authored once from burning CPU on every settle.
-*
-* No zod: the kernel's grain is a hand-written validator that throws `ValidationError` by name.
-*/
-/** The leaf comparison operators; `exists`/`truthy` are unary, the rest compare against `value`. */
-const CONDITION_OPS = [
-	"eq",
-	"neq",
-	"gt",
-	"gte",
-	"lt",
-	"lte",
-	"in",
-	"contains",
-	"exists",
-	"truthy"
-];
-/** Operators that compare against `value`; `exists`/`truthy` are unary and must omit it. */
-const OPS_NEEDING_VALUE = new Set(CONDITION_OPS.filter((op) => op !== "exists" && op !== "truthy"));
-const MAX_PATH_LENGTH = 256;
-const MAX_PATH_SEGMENTS = 16;
-const PATH_SEGMENT = /^[A-Za-z_$][A-Za-z0-9_$-]*$/u;
-/** Parse `a.b[0].c` into steps; refuse anything outside the bounded grammar. */
-function parseConditionPath(path, context) {
-	if (typeof path !== "string" || path.length === 0 || path.length > MAX_PATH_LENGTH) throw new ValidationError(`${context}: path must be a non-empty string of at most ${MAX_PATH_LENGTH} chars`);
-	const steps = [];
-	for (const part of path.split(".")) {
-		const open = part.indexOf("[");
-		const head = open === -1 ? part : part.slice(0, open);
-		if (head.length > 0) {
-			if (!PATH_SEGMENT.test(head)) throw new ValidationError(`${context}: path segment ${JSON.stringify(head)} is not addressable`);
-			steps.push(head);
-		} else if (open !== 0 || steps.length === 0) throw new ValidationError(`${context}: path ${JSON.stringify(path)} has an empty segment`);
-		let rest = open === -1 ? "" : part.slice(open);
-		while (rest.length > 0) {
-			const match = /^\[(\d{1,6})\]/u.exec(rest);
-			if (!match) throw new ValidationError(`${context}: path index in ${JSON.stringify(part)} must be [N]`);
-			steps.push(Number(match[1]));
-			rest = rest.slice(match[0].length);
-		}
-		if (steps.length > MAX_PATH_SEGMENTS) throw new ValidationError(`${context}: path exceeds ${MAX_PATH_SEGMENTS} segments`);
-	}
-	if (steps.length === 0) throw new ValidationError(`${context}: path resolves no segment`);
-	return steps;
-}
-/** Walk a parsed path; any miss resolves `undefined`, never a throw — absence is an answer. */
-function resolveConditionPath(context, steps) {
-	let current = context;
-	for (const step of steps) {
-		if (current === null || current === void 0) return void 0;
-		if (typeof step === "number") {
-			if (!Array.isArray(current)) return void 0;
-			current = current[step];
-		} else {
-			if (typeof current !== "object" || Array.isArray(current)) return void 0;
-			current = current[step];
-		}
-	}
-	return current;
-}
-function isLeaf(condition) {
-	return typeof condition.path === "string";
-}
-/** Validate shape, bounds, and per-leaf path/operator rules; returns the input for chaining. */
-function validateCondition(raw, context) {
-	let nodes = 0;
-	const walk = (value, depth) => {
-		nodes += 1;
-		if (nodes > 40) throw new ValidationError(`${context}: condition exceeds 40 nodes`);
-		if (depth > 6) throw new ValidationError(`${context}: condition exceeds depth 6`);
-		if (typeof value !== "object" || value === null || Array.isArray(value)) throw new ValidationError(`${context}: a condition must be an object`);
-		const record = value;
-		const combinators = [
-			"all",
-			"any",
-			"not"
-		].filter((key) => record[key] !== void 0);
-		if (combinators.length > 1) throw new ValidationError(`${context}: a condition carries ONE of all/any/not, got ${combinators.join("+")}`);
-		if (record.all !== void 0 || record.any !== void 0) {
-			const key = record.all !== void 0 ? "all" : "any";
-			const branch = record[key];
-			if (!Array.isArray(branch) || branch.length === 0) throw new ValidationError(`${context}: ${key} must be a non-empty array`);
-			for (const child of branch) walk(child, depth + 1);
-			return value;
-		}
-		if (record.not !== void 0) {
-			walk(record.not, depth + 1);
-			return value;
-		}
-		const op = record.op;
-		if (typeof record.path !== "string" || typeof op !== "string") throw new ValidationError(`${context}: a leaf needs { path, op }`);
-		if (!CONDITION_OPS.includes(op)) throw new ValidationError(`${context}: unknown op ${JSON.stringify(op)}; known: ${CONDITION_OPS.join(", ")}`);
-		parseConditionPath(record.path, context);
-		const needsValue = OPS_NEEDING_VALUE.has(op);
-		if (needsValue && !("value" in record)) throw new ValidationError(`${context}: op ${JSON.stringify(op)} requires a value`);
-		if (!needsValue && "value" in record) throw new ValidationError(`${context}: op ${JSON.stringify(op)} is unary — remove value`);
-		if (op === "in" && !Array.isArray(record.value)) throw new ValidationError(`${context}: op "in" takes an array value`);
-		return value;
-	};
-	return walk(raw, 1);
-}
-function canonicalEquals(a, b) {
-	if (Object.is(a, b)) return true;
-	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
-	try {
-		return JSON.stringify(a) === JSON.stringify(b);
-	} catch {
-		return false;
-	}
-}
-function ordering(op, left, right) {
-	if (typeof left === "number" && typeof right === "number") {
-		if (Number.isNaN(left) || Number.isNaN(right)) return false;
-		if (op === "gt") return left > right;
-		if (op === "gte") return left >= right;
-		if (op === "lt") return left < right;
-		return left <= right;
-	}
-	if (typeof left === "string" && typeof right === "string") {
-		if (op === "gt") return left > right;
-		if (op === "gte") return left >= right;
-		if (op === "lt") return left < right;
-		return left <= right;
-	}
-	return false;
-}
-/** Walk a validated condition over a context to a boolean. Never throws on data shape. */
-function evaluateCondition(condition, context) {
-	if (isLeaf(condition)) {
-		const resolved = resolveConditionPath(context, parseConditionPath(condition.path, "evaluate"));
-		switch (condition.op) {
-			case "exists": return resolved !== void 0 && resolved !== null;
-			case "truthy": return Boolean(resolved);
-			case "eq": return canonicalEquals(resolved, condition.value);
-			case "neq": return !canonicalEquals(resolved, condition.value);
-			case "in": return Array.isArray(condition.value) ? condition.value.some((candidate) => canonicalEquals(resolved, candidate)) : false;
-			case "contains":
-				if (Array.isArray(resolved)) return resolved.some((element) => canonicalEquals(element, condition.value));
-				return typeof resolved === "string" && typeof condition.value === "string" ? resolved.includes(condition.value) : false;
-			default: return ordering(condition.op, resolved, condition.value);
-		}
-	}
-	if ("all" in condition) return condition.all.every((child) => evaluateCondition(child, context));
-	if ("any" in condition) return condition.any.some((child) => evaluateCondition(child, context));
-	return !evaluateCondition(condition.not, context);
-}
-//#endregion
-//#region src/runtime/graph/projection.ts
-/**
-* The ONE pure projection a `data` edge may carry (agent-runtime#971): the bounded,
-* schema-preserving subset of ADC's collection helpers. Anything richer is a `script` NODE, so it
-* is journaled (`inputRef` → `outRef`), typed, and visible. Exactly one operator per projection.
-*/
-const PROJECTION_KEYS = [
-	"path",
-	"pick",
-	"map",
-	"filter",
-	"first",
-	"last",
-	"count"
-];
-/** Validate a projection: exactly one known operator, its argument well-formed. */
-function validateProjection(raw, context) {
-	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) throw new ValidationError(`${context}: a projection must be an object`);
-	const record = raw;
-	const keys = PROJECTION_KEYS.filter((key) => record[key] !== void 0);
-	const unknown = Object.keys(record).filter((key) => !PROJECTION_KEYS.includes(key));
-	if (unknown.length > 0) throw new ValidationError(`${context}: unknown projection key(s) ${unknown.join(", ")}; known: ${PROJECTION_KEYS.join(", ")}`);
-	if (keys.length !== 1) throw new ValidationError(`${context}: a projection carries exactly ONE of ${PROJECTION_KEYS.join("/")}`);
-	const key = keys[0];
-	if (key === "path" || key === "map") parseConditionPath(record[key], context);
-	if (key === "pick") {
-		const fields = record.pick;
-		if (!Array.isArray(fields) || fields.length === 0 || fields.some((f) => typeof f !== "string")) throw new ValidationError(`${context}: pick must be a non-empty array of field names`);
-	}
-	if (key === "filter") validateCondition(record.filter, context);
-	if ((key === "first" || key === "last" || key === "count") && record[key] !== true) throw new ValidationError(`${context}: ${key} must be literally true`);
-	return raw;
-}
-/**
-* Apply a validated projection to an admitted payload. Collection operators over a non-array
-* refuse by name — a shape the author did not expect is a graph defect, not an empty result.
-*/
-function applyProjection(value, projection, context) {
-	if ("path" in projection) return resolveConditionPath(value, parseConditionPath(projection.path, context));
-	if ("pick" in projection) {
-		if (typeof value !== "object" || value === null || Array.isArray(value)) throw new ValidationError(`${context}: pick needs an object payload`);
-		const record = value;
-		const out = {};
-		for (const field of projection.pick) if (field in record) out[field] = record[field];
-		return out;
-	}
-	const collection = value;
-	if (!Array.isArray(collection)) throw new ValidationError(`${context}: this projection needs an array payload`);
-	if ("map" in projection) {
-		const steps = parseConditionPath(projection.map, context);
-		return collection.map((element) => resolveConditionPath(element, steps));
-	}
-	if ("filter" in projection) return collection.filter((element) => evaluateCondition(projection.filter, element));
-	if ("first" in projection) return collection[0];
-	if ("last" in projection) return collection[collection.length - 1];
-	return collection.length;
-}
-//#endregion
-//#region src/runtime/graph/registry.ts
-/**
-* `Registry<T>` — the ONE name→thing shape for the graph engine.
-*
-* The kernel grew fourteen of these (agent-runtime#978) that differ in three properties:
-* whether names can be listed, what a miss does, and whether the table is global. This one
-* fixes all three — enumerable, a miss is refused BY NAME listing what is registered, and every
-* registry is per-instance — and it is lifted from `AgentEnvironmentProviderRegistry`, the
-* richest and best-tested of the fourteen, not invented.
-*
-* Entries are addressed by a versioned handle, `<id>/v<n>`, the same way the prompt registry
-* addresses directives. A graph names a kind by handle; a host registers exact versions; a
-* missing version is refused, never served by a newer one.
-*/
-/** `<id>/v<n>` — the only spelling a handle has on the wire, in a journal, or in an error. */
-function formatRegistryHandle(handle) {
-	return `${handle.id}/v${handle.version}`;
-}
-/** Parse the wire spelling back. Refuses anything that is not exactly `<id>/v<n>`. */
-function parseRegistryHandle(text, context) {
-	const match = /^([A-Za-z0-9][A-Za-z0-9._-]*)\/v(\d+)$/u.exec(text);
-	if (!match) throw new ValidationError(`${context}: ${JSON.stringify(text)} is not a registry handle; expected "<id>/v<n>"`);
-	const version = Number(match[2]);
-	if (!Number.isSafeInteger(version) || version < 1) throw new ValidationError(`${context}: handle version must be a positive integer`);
-	return {
-		id: match[1],
-		version
-	};
-}
-/**
-* Create a registry. Per-instance by construction: two engines in one process may hold
-* different kind sets, a test is hermetic, and a run can print its own table. There is
-* deliberately no module-level singleton — `builtinShapes` was the one mutable global in the
-* kernel and it had zero tests.
-*/
-function createRegistry(label, seed = []) {
-	const table = /* @__PURE__ */ new Map();
-	const registry = {
-		register(entry, options = {}) {
-			if (typeof entry.id !== "string" || entry.id.length === 0) throw new ValidationError(`${label}: an entry must carry a non-empty id`);
-			if (!Number.isSafeInteger(entry.version) || entry.version < 1) throw new ValidationError(`${label}: ${JSON.stringify(entry.id)} must carry a positive integer version`);
-			const key = formatRegistryHandle(entry);
-			if (!options.replace && table.has(key)) throw new ValidationError(`${label}: ${JSON.stringify(key)} is already registered`);
-			table.set(key, entry);
-		},
-		has(handle) {
-			return table.has(formatRegistryHandle(handle));
-		},
-		get(handle) {
-			return table.get(formatRegistryHandle(handle));
-		},
-		require(handle, context = label) {
-			const key = formatRegistryHandle(handle);
-			const entry = table.get(key);
-			if (entry === void 0) {
-				const known = registry.names();
-				const suffix = known.length > 0 ? `; registered: ${known.join(", ")}` : "; nothing is registered";
-				throw new ValidationError(`${context}: ${JSON.stringify(key)} is not registered${suffix}`);
-			}
-			return entry;
-		},
-		names() {
-			return Array.from(table.keys()).sort();
-		},
-		entries() {
-			return registry.names().map((key) => table.get(key));
-		}
-	};
-	for (const entry of seed) registry.register(entry);
-	return registry;
-}
-//#endregion
-//#region src/runtime/graph/definition.ts
-/** Which gating-edge outcomes release a node (adopted from ADC, agent-runtime#968). */
-const JOIN_RULES = [
-	"all",
-	"any",
-	"any_failed",
-	"all_done"
-];
-/** ADC-compatible visit backstop: nothing may be ENTERED more than this many times. */
-const DEFAULT_MAX_NODE_VISITS = 25;
-/** The hard ceiling an author's `maxVisits`/`maxNodeVisits` override may reach. */
-const MAX_MAX_NODE_VISITS = 100;
-/** Structural validation only — everything a registry is not needed for. */
-function validateEngineGraphSpec(spec, context = "compileGraph") {
-	if (!Array.isArray(spec.nodes) || spec.nodes.length === 0) throw new ValidationError(`${context}: a graph needs at least one node`);
-	const ids = /* @__PURE__ */ new Set();
-	for (const node of spec.nodes) {
-		if (typeof node.id !== "string" || node.id.length === 0) throw new ValidationError(`${context}: every node needs a non-empty id`);
-		if (ids.has(node.id)) throw new ValidationError(`${context}: duplicate node id ${JSON.stringify(node.id)}`);
-		ids.add(node.id);
-		parseRegistryHandle(node.kind, `${context}: node ${node.id} kind`);
-		if (node.join !== void 0 && !JOIN_RULES.includes(node.join)) throw new ValidationError(`${context}: node ${node.id} join ${JSON.stringify(node.join)}; known: ${JOIN_RULES.join(", ")}`);
-		if (node.maxVisits !== void 0) {
-			if (!Number.isSafeInteger(node.maxVisits) || node.maxVisits < 1 || node.maxVisits > 100) throw new ValidationError(`${context}: node ${node.id} maxVisits must be an integer in [1, 100]`);
-		}
-	}
-	if (!Array.isArray(spec.edges)) throw new ValidationError(`${context}: edges must be an array`);
-	for (const [index, edge] of spec.edges.entries()) {
-		const who = `${context}: edge[${index}]`;
-		if (edge.kind !== "delegates" && edge.kind !== "analyzes" && edge.kind !== "data") throw new ValidationError(`${who}: kind must be delegates | analyzes | data`);
-		for (const end of ["from", "to"]) {
-			const ref = edge[end];
-			if (typeof ref !== "object" || ref === null || typeof ref.node !== "string" || !ids.has(ref.node)) throw new ValidationError(`${who}: ${end}.node must name a node in this graph`);
-		}
-		if (edge.guard !== void 0) validateCondition(edge.guard, `${who} guard`);
-		if (edge.projection !== void 0) {
-			if (edge.kind !== "data") throw new ValidationError(`${who}: only a data edge carries a projection`);
-			validateProjection(edge.projection, `${who} projection`);
-		}
-		if (edge.maxTraversals !== void 0) {
-			if (!Number.isSafeInteger(edge.maxTraversals) || edge.maxTraversals < 1) throw new ValidationError(`${who}: maxTraversals must be a positive integer`);
-		}
-		if (edge.kind === "data" && edge.directive !== void 0) throw new ValidationError(`${who}: a data edge carries a port binding, never a directive`);
-	}
-	if (spec.root !== void 0 && !ids.has(spec.root)) throw new ValidationError(`${context}: root ${JSON.stringify(spec.root)} names no node`);
-	if (spec.maxNodeVisits !== void 0) {
-		if (!Number.isSafeInteger(spec.maxNodeVisits) || spec.maxNodeVisits < 1 || spec.maxNodeVisits > 100) throw new ValidationError(`${context}: maxNodeVisits must be an integer in [1, 100]`);
-	}
-}
-//#endregion
-//#region src/runtime/graph/compile.ts
-/**
-* Compile an authored graph against an engine's kind registry into the schedulable form. Every
-* refusal here happens before any spend: an unknown kind, a port that does not exist, a `data`
-* binding whose schemas cannot fit, a `delegates`/`data` edge into an oracle, a terminal with no
-* completion check (agent-runtime#971, #973).
-*/
-/** A node's ports: its kind's declared outputs plus the two implicit ones every node has. */
-const IMPLICIT_OUTPUT_PORTS = ["out", "trace"];
-/** A node's ports: node-level declarations merged OVER its kind's (the node wins on a name). */
-function nodePorts(kind, node) {
-	const merge = (declared, own) => {
-		if (own === void 0 || own.length === 0) return declared;
-		const names = new Set(own.map((port) => port.name));
-		return [...own, ...declared.filter((port) => !names.has(port.name))];
-	};
-	return {
-		inputs: merge(kind.inputs, node.ports?.inputs),
-		outputs: merge(kind.outputs, node.ports?.outputs)
-	};
-}
-function outputPort(ports, port) {
-	if (IMPLICIT_OUTPUT_PORTS.includes(port)) return {
-		name: port,
-		schema: {}
-	};
-	return ports.outputs.find((candidate) => candidate.name === port);
-}
-function inputPort(ports, port) {
-	return ports.inputs.find((candidate) => candidate.name === port);
-}
-/**
-* Bounded structural acceptance: does a value of `source`'s shape fit `target`? Schemas with no
-* `type` accept anything; object targets require their `required` properties to be present and
-* accepted when the source declares properties. Depth-bounded — this is a compile-time tripwire,
-* not a full JSON Schema validator.
-*/
-function schemaAccepts(source, target, depth = 0) {
-	if (depth > 6) return true;
-	const sourceType = source.type;
-	const targetType = target.type;
-	if (targetType === void 0 || sourceType === void 0) return true;
-	const targets = Array.isArray(targetType) ? targetType : [targetType];
-	const sources = Array.isArray(sourceType) ? sourceType : [sourceType];
-	if (sources.filter((candidate) => targets.includes(candidate === "integer" ? "number" : candidate) || targets.includes(candidate)).length === 0) return false;
-	if (targets.includes("object") && sources.includes("object")) {
-		const required = Array.isArray(target.required) ? target.required : [];
-		const sourceProps = source.properties;
-		const targetProps = target.properties;
-		if (sourceProps !== void 0) for (const name of required) {
-			const sourceProp = sourceProps[name];
-			if (sourceProp === void 0) return false;
-			const targetProp = targetProps?.[name];
-			if (targetProp !== void 0 && !schemaAccepts(sourceProp, targetProp, depth + 1)) return false;
-		}
-	}
-	if (targets.includes("array") && sources.includes("array")) {
-		const sourceItems = source.items;
-		const targetItems = target.items;
-		if (sourceItems !== void 0 && targetItems !== void 0) return schemaAccepts(sourceItems, targetItems, depth + 1);
-	}
-	return true;
-}
-/**
-* Lower an authored graph against an engine's kind registry into the schedulable form, refusing
-* every structural defect before any spend.
-*/
-function compileGraph(engine, spec, context = "compileGraph") {
-	validateEngineGraphSpec(spec, context);
-	const kinds = /* @__PURE__ */ new Map();
-	const configs = /* @__PURE__ */ new Map();
-	for (const node of spec.nodes) {
-		const handle = parseRegistryHandle(node.kind, `${context}: node ${node.id}`);
-		const kind = engine.kinds.require(handle, `${context}: node ${node.id}`);
-		kinds.set(node.id, kind);
-		configs.set(node.id, kind.validateConfig(node.config ?? {}, `${context}: node ${node.id}`));
-		if (node.flags?.pure && kind.id !== "script") throw new ValidationError(`${context}: node ${node.id} sets pure, which only a script node may claim`);
-	}
-	const compiledEdges = [];
-	const inbound = /* @__PURE__ */ new Map();
-	const outbound = /* @__PURE__ */ new Map();
-	for (const [index, edge] of spec.edges.entries()) {
-		const who = `${context}: edge[${index}] ${edge.from.node}->${edge.to.node}`;
-		const fromKind = kinds.get(edge.from.node);
-		const toKind = kinds.get(edge.to.node);
-		if (!fromKind || !toKind) throw new ValidationError(`${who}: unresolved endpoint`);
-		const toNode = spec.nodes.find((node) => node.id === edge.to.node);
-		if (edge.kind !== "analyzes" && toNode?.flags?.oracle) throw new ValidationError(`${who}: a ${edge.kind} edge may not target oracle node ${edge.to.node}; use analyzes`);
-		const fromPort = edge.from.port ?? (edge.kind === "analyzes" ? "trace" : "out");
-		if (edge.kind === "analyzes" && fromPort !== "trace") throw new ValidationError(`${who}: an analyzes edge reads the trace port, got ${fromPort}`);
-		const fromPorts = nodePorts(fromKind, spec.nodes.find((node) => node.id === edge.from.node));
-		const toPorts = nodePorts(toKind, toNode);
-		const sourcePort = outputPort(fromPorts, fromPort);
-		if (!sourcePort) {
-			const known = [...IMPLICIT_OUTPUT_PORTS, ...fromPorts.outputs.map((port) => port.name)];
-			throw new ValidationError(`${who}: ${formatRegistryHandle(fromKind)} has no output port ${JSON.stringify(fromPort)}; known: ${known.join(", ")}`);
-		}
-		let toPort = edge.to.port ?? "";
-		if (edge.kind === "data") {
-			if (toPort === "") if (toPorts.inputs.length === 1) toPort = toPorts.inputs[0]?.name ?? "";
-			else throw new ValidationError(`${who}: a data edge needs to.port; ${formatRegistryHandle(toKind)} declares ${toPorts.inputs.length} inputs`);
-			const targetPort = inputPort(toPorts, toPort);
-			if (!targetPort) throw new ValidationError(`${who}: ${formatRegistryHandle(toKind)} has no input port ${JSON.stringify(toPort)}; known: ${toPorts.inputs.map((port) => port.name).join(", ") || "(none)"}`);
-			if (edge.projection === void 0 && !schemaAccepts(sourcePort.schema, targetPort.schema)) throw new ValidationError(`${who}: output ${fromPort} (${JSON.stringify(sourcePort.schema.type ?? "any")}) cannot fit input ${toPort} (${JSON.stringify(targetPort.schema.type ?? "any")})`);
-		}
-		const compiled = {
-			id: edge.id ?? `${edge.from.node}->${edge.to.node}#${index}`,
-			spec: edge,
-			fromPort,
-			toPort: toPort === "" ? "out" : toPort
-		};
-		compiledEdges.push(compiled);
-		outbound.set(edge.from.node, [...outbound.get(edge.from.node) ?? [], compiled]);
-		inbound.set(edge.to.node, [...inbound.get(edge.to.node) ?? [], compiled]);
-	}
-	const dupes = /* @__PURE__ */ new Set();
-	for (const edge of compiledEdges) {
-		if (dupes.has(edge.id)) throw new ValidationError(`${context}: duplicate edge id ${edge.id}`);
-		dupes.add(edge.id);
-	}
-	const entries = spec.nodes.filter((node) => (inbound.get(node.id) ?? []).length === 0);
-	if (entries.length === 0) throw new ValidationError(`${context}: no entry node — every node has an inbound edge`);
-	const root = spec.root ?? (entries.length === 1 ? entries[0]?.id ?? "" : (() => {
-		throw new ValidationError(`${context}: ${entries.length} entry nodes (${entries.map((node) => node.id).join(", ")}) — name spec.root`);
-	})());
-	const nodes = /* @__PURE__ */ new Map();
-	const terminals = [];
-	for (const node of spec.nodes) {
-		const kind = kinds.get(node.id);
-		if (!kind) throw new ValidationError(`${context}: unresolved node ${node.id}`);
-		const terminal = node.terminal ?? (outbound.get(node.id) ?? []).length === 0;
-		const deliverable = node.deliverable ?? (node.id === root ? spec.deliverable : void 0);
-		if (terminal) terminals.push(node.id);
-		nodes.set(node.id, {
-			id: node.id,
-			kind,
-			config: configs.get(node.id),
-			join: node.join ?? "all",
-			maxVisits: node.maxVisits ?? spec.maxNodeVisits ?? 25,
-			oracle: node.flags?.oracle ?? false,
-			pure: node.flags?.pure ?? false,
-			terminal,
-			...deliverable === void 0 ? {} : { deliverable },
-			inbound: inbound.get(node.id) ?? [],
-			outbound: outbound.get(node.id) ?? [],
-			spec: node
-		});
-	}
-	if (terminals.filter((id) => nodes.get(id)?.deliverable === void 0).length === terminals.length) throw new ValidationError(`${context}: no terminal declares a completion check (terminals: ${terminals.join(", ")}); give a node a deliverable or set spec.deliverable`);
-	return {
-		nodes,
-		edges: compiledEdges,
-		entries: entries.map((node) => node.id),
-		terminals,
-		root,
-		maxNodeVisits: spec.maxNodeVisits ?? 25
-	};
-}
-//#endregion
-//#region src/runtime/graph/kind.ts
-/** Validate a kind declaration at registration — so a malformed kind is refused by name once,
-*  not at the first node that uses it. */
-function validateNodeKind(kind, context = "registerNodeKind") {
-	const who = `${context}: kind ${JSON.stringify(`${kind.id}/v${kind.version}`)}`;
-	if (typeof kind.id !== "string" || kind.id.length === 0) throw new ValidationError(`${context}: a kind must carry a non-empty id`);
-	if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/u.test(kind.id)) throw new ValidationError(`${who}: id may contain only letters, digits, ".", "_" and "-"`);
-	if (!Number.isSafeInteger(kind.version) || kind.version < 1) throw new ValidationError(`${who}: version must be a positive integer`);
-	if (typeof kind.description !== "string" || kind.description.trim().length === 0) throw new ValidationError(`${who}: description is required`);
-	if (typeof kind.validateConfig !== "function") throw new ValidationError(`${who}: validateConfig must be a function`);
-	if (!isRecord(kind.configSchema)) throw new ValidationError(`${who}: configSchema must be a JSON Schema object`);
-	for (const [field, ports] of [["inputs", kind.inputs], ["outputs", kind.outputs]]) {
-		if (!Array.isArray(ports)) throw new ValidationError(`${who}: ${field} must be an array`);
-		const seen = /* @__PURE__ */ new Set();
-		for (const port of ports) {
-			if (!port || typeof port.name !== "string" || port.name.length === 0) throw new ValidationError(`${who}: every ${field} port needs a non-empty name`);
-			if (field === "outputs" && (port.name === "out" || port.name === "trace")) throw new ValidationError(`${who}: output port ${JSON.stringify(port.name)} is implicit on every node and cannot be declared`);
-			if (seen.has(port.name)) throw new ValidationError(`${who}: duplicate ${field} port ${JSON.stringify(port.name)}`);
-			seen.add(port.name);
-			if (!isRecord(port.schema)) throw new ValidationError(`${who}: ${field} port ${JSON.stringify(port.name)} needs a JSON Schema`);
-		}
-	}
-	if (!Array.isArray(kind.effects) || kind.effects.some((e) => typeof e !== "string" || e.length === 0)) throw new ValidationError(`${who}: effects must be an array of non-empty names`);
-	if (new Set(kind.effects).size !== kind.effects.length) throw new ValidationError(`${who}: effects must not repeat a name`);
-	if (kind.onCrash !== "restart" && kind.onCrash !== "resume") throw new ValidationError(`${who}: onCrash must be "restart" or "resume"`);
-	if (kind.budget !== "metered" && kind.budget !== "exempt") throw new ValidationError(`${who}: budget must be "metered" or "exempt"`);
-	if (typeof kind.run !== "function") throw new ValidationError(`${who}: run must be a function`);
-	return kind;
-}
-/** The handle a graph writes to name this kind. */
-function kindHandle(kind) {
-	return {
-		id: kind.id,
-		version: kind.version
-	};
-}
-/**
-* Narrow a host's effect table to exactly what one kind declared. Anything the kind did not
-* declare is absent — `undefined` on read — so a kind cannot reach past its declaration, and the
-* engine can list a graph's required effects before spending a token.
-*/
-function narrowEffects(declared, provided, context) {
-	const out = {};
-	const missing = [];
-	for (const name of declared) {
-		if (!(name in provided)) {
-			missing.push(name);
-			continue;
-		}
-		out[name] = provided[name];
-	}
-	if (missing.length > 0) throw new ValidationError(`${context}: host provides no effect for ${missing.map((m) => JSON.stringify(m)).join(", ")}; provided: ${Object.keys(provided).sort().join(", ") || "none"}`);
-	return Object.freeze(out);
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-//#endregion
-//#region src/runtime/graph/engine.ts
-/**
-* `createGraphEngine` — one engine instance: its kind registry (core kinds pre-registered, host
-* kinds added by the caller), its effect table, and nothing global.
-*
-* The scheduler (#980), journal fold (#981) and the `runGraph` preset (#982) attach here; this
-* file is the part that must exist first so a host can register kinds and a compiler can ask
-* "which effects does this graph need" before a token is spent.
-*/
-/**
-* Build one engine: a kind registry seeded with the core kinds plus the host's, and the host's
-* effect values. Every kind is validated by name at construction, so a malformed host kind fails
-* here, never at its first node.
-*/
-function createGraphEngine(options) {
-	const kinds = createRegistry("graph kinds");
-	for (const kind of options.coreKinds) kinds.register(validateNodeKind(kind, "createGraphEngine"));
-	for (const kind of options.kinds ?? []) kinds.register(validateNodeKind(kind, "createGraphEngine"));
-	const effects = Object.freeze({ ...options.effects ?? {} });
-	if (Object.keys(effects).some((name) => name.length === 0)) throw new ValidationError("createGraphEngine: an effect name must be non-empty");
-	const engine = {
-		kinds,
-		effects,
-		requiredEffects() {
-			const names = /* @__PURE__ */ new Set();
-			for (const kind of kinds.entries()) for (const name of kind.effects) names.add(name);
-			return Array.from(names).sort();
-		},
-		missingEffects() {
-			return engine.requiredEffects().filter((name) => !(name in effects));
-		}
-	};
-	return engine;
-}
-//#endregion
-//#region src/runtime/graph/fold.ts
-/**
-* The fold (agent-runtime#974): scheduler state is a pure function of the journal, reconstructed
-* by replaying events through the SAME reducer the live scheduler feeds — fold, never checkpoint.
-* Kernel events (`spawned`, `settled`, `waiting`, `woken`) carry what the kernel owns; the engine's
-* events (`node-inputs-resolved`, `edge-verdict`, `join-state`) carry what the scheduler decided,
-* each journaled BEFORE its effect was visible. `edge` stays observability and is skipped here
-* exactly as the kernel's own replay skips it.
-*
-* Events are consumed in APPEND order (the journal file's line order), not by `seq`: kernel and
-* engine events carry independent ordinal counters, and append order is the one total order both
-* share.
-*/
-/** The reducer's zero: every node unvisited, every edge pending, nothing suspended. */
-function emptyFoldState(compiled) {
-	const nodes = /* @__PURE__ */ new Map();
-	for (const id of compiled.nodes.keys()) nodes.set(id, {
-		visits: 0,
-		blocked: false,
-		settles: []
-	});
-	const edges = /* @__PURE__ */ new Map();
-	for (const edge of compiled.edges) edges.set(edge.id, {
-		state: "pending",
-		consumedOnce: false,
-		traversals: 0,
-		judgedSourceSettles: 0,
-		capped: false
-	});
-	return {
-		nodes,
-		edges,
-		instances: /* @__PURE__ */ new Map(),
-		spawnedIds: /* @__PURE__ */ new Map(),
-		suspensions: /* @__PURE__ */ new Map(),
-		exhaustedEdges: /* @__PURE__ */ new Set()
-	};
-}
-function instanceOf(state, label) {
-	return state.instances.get(label);
-}
-/**
-* Apply ONE journal event. The live scheduler calls this right after each append; the restart path
-* calls it over the loaded journal. Unknown kernel events are ignored — the engine folds only what
-* it understands, exactly as the kernel's replay skips the engine's events.
-*/
-function applyGraphFoldEvent(state, ev, compiled) {
-	switch (ev.kind) {
-		case "node-inputs-resolved": {
-			const visit = Number(ev.instance.split("#").at(-1));
-			if (!Number.isSafeInteger(visit)) throw new ValidationError(`graph fold: instance ${ev.instance} carries no visit ordinal`);
-			state.instances.set(ev.instance, {
-				node: ev.node,
-				instance: ev.instance,
-				visit,
-				inputRef: ev.inputRef,
-				status: "released"
-			});
-			const node = state.nodes.get(ev.node);
-			if (node) node.visits = Math.max(node.visits, visit);
-			return;
-		}
-		case "spawned": {
-			const instance = instanceOf(state, ev.label);
-			if (instance) {
-				instance.status = "live";
-				state.spawnedIds.set(ev.id, ev.label);
-			}
-			return;
-		}
-		case "settled": {
-			const label = state.spawnedIds.get(ev.id);
-			const instance = label === void 0 ? void 0 : instanceOf(state, label);
-			if (!instance) return;
-			instance.status = ev.status;
-			const settle = {
-				node: instance.node,
-				visit: instance.visit,
-				status: ev.status,
-				...ev.outRef !== void 0 ? { outRef: ev.outRef } : {},
-				...ev.reason !== void 0 ? { reason: ev.reason } : {}
-			};
-			if (ev.trace?.status === "available") settle.traceRef = ev.trace.traceRef;
-			instance.settle = settle;
-			state.nodes.get(instance.node)?.settles.push(settle);
-			const node = compiled.nodes.get(instance.node);
-			for (const edge of node?.outbound ?? []) {
-				const folded = state.edges.get(edge.id);
-				if (folded?.consumedOnce && folded.state === "pending") {
-					folded.consumedOnce = false;
-					folded.judgedSourceSettles += 1;
-				}
-			}
-			return;
-		}
-		case "edge-verdict": {
-			const folded = state.edges.get(ev.edge);
-			if (!folded) return;
-			if (ev.capped) {
-				folded.capped = true;
-				state.exhaustedEdges.add(ev.edge);
-				const target = compiled.edges.find((edge) => edge.id === ev.edge)?.spec.to.node;
-				const compiledTarget = target === void 0 ? void 0 : compiled.nodes.get(target);
-				if (compiledTarget && (compiledTarget.join === "all" || compiledTarget.join === "all_done")) {
-					const node = state.nodes.get(target);
-					if (node) node.blocked = true;
-				}
-				return;
-			}
-			folded.judgedSourceSettles += 1;
-			if (!ev.fired) {
-				folded.state = ev.sourceStatus === "done" ? "dead" : "failed";
-				folded.payloadRef = void 0;
-				return;
-			}
-			folded.state = "satisfied";
-			folded.payloadRef = ev.inputRef;
-			return;
-		}
-		case "join-state": {
-			for (const edgeId of ev.satisfiedBy) {
-				const folded = state.edges.get(edgeId);
-				if (!folded) continue;
-				folded.traversals += 1;
-				folded.state = "pending";
-				folded.payloadRef = void 0;
-			}
-			const target = compiled.nodes.get(ev.node);
-			for (const edge of target?.inbound ?? []) {
-				const folded = state.edges.get(edge.id);
-				if (!folded) continue;
-				if (ev.consumedPending.includes(edge.id)) folded.consumedOnce = true;
-				else if (folded.state !== "pending" && !ev.satisfiedBy.includes(edge.id)) {
-					folded.state = "pending";
-					folded.payloadRef = void 0;
-				}
-			}
-			return;
-		}
-		case "waiting": {
-			if (ev.spec.kind !== "token") return;
-			const instance = instanceOf(state, ev.label);
-			if (instance) {
-				instance.status = "suspended";
-				if (instance.settle !== void 0) {
-					const settles = state.nodes.get(instance.node)?.settles;
-					if (settles && settles.at(-1) === instance.settle) settles.pop();
-					instance.settle = void 0;
-				}
-			}
-			state.suspensions.set(ev.spec.token, {
-				token: ev.spec.token,
-				node: instance?.node ?? ev.label.split("#")[0] ?? ev.label,
-				instance: ev.label,
-				onExpire: ev.spec.onExpire,
-				...ev.spec.expiresAtMs !== void 0 ? { expiresAtMs: ev.spec.expiresAtMs } : {},
-				...ev.spec.defaultRef !== void 0 ? { defaultRef: ev.spec.defaultRef } : {},
-				status: "pending"
-			});
-			return;
-		}
-		case "woken": {
-			const token = ev.id.startsWith("graphwait:") ? ev.id.slice(10) : void 0;
-			const suspension = token === void 0 ? void 0 : state.suspensions.get(token);
-			if (!suspension) return;
-			const instance = instanceOf(state, suspension.instance);
-			if (ev.by === "expired") {
-				suspension.status = "expired";
-				if (instance) {
-					instance.status = "down";
-					const settle = {
-						node: suspension.node,
-						visit: instance.visit,
-						status: "down",
-						reason: "suspension expired"
-					};
-					instance.settle = settle;
-					state.nodes.get(suspension.node)?.settles.push(settle);
-				}
-				return;
-			}
-			suspension.status = "woken";
-			if (instance) {
-				instance.status = "done";
-				const settle = {
-					node: suspension.node,
-					visit: instance.visit,
-					status: "done",
-					...ev.outRef !== void 0 ? { outRef: ev.outRef } : {}
-				};
-				instance.settle = settle;
-				state.nodes.get(suspension.node)?.settles.push(settle);
-			}
-			return;
-		}
-		default: return;
-	}
-}
-/** Fold a loaded journal (append order) into scheduler state. */
-function foldGraphJournal(events, compiled) {
-	const state = emptyFoldState(compiled);
-	for (const ev of events) applyGraphFoldEvent(state, ev, compiled);
-	return state;
-}
-//#endregion
-//#region src/runtime/graph/kinds.ts
-/**
-* One profile, one run: the kernel's leaf, exactly as `supervise()` derives it from `backend`.
-* The model cannot decide this — it is what gets run.
-*/
-function agentKind(defaults) {
-	return {
-		id: "agent",
-		version: 1,
-		description: "One AgentProfile run as a leaf on a backend; the kernel derives the executor.",
-		validateConfig: (raw, context) => {
-			const config = asRecord(raw, `${context}: agent config`);
-			return {
-				...config.backend !== void 0 ? { backend: config.backend } : {},
-				...config.deliverable !== void 0 ? { deliverable: config.deliverable } : {}
-			};
-		},
-		configSchema: {
-			type: "object",
-			properties: {
-				backend: { type: "object" },
-				deliverable: { type: "object" }
-			},
-			additionalProperties: false
-		},
-		inputs: [],
-		outputs: [],
-		effects: [],
-		onCrash: "restart",
-		budget: "metered",
-		run: ({ config, profile, spawn }) => {
-			const backend = config.backend ?? defaults.backend;
-			if (!backend) throw new ValidationError(`agent kind: node ${JSON.stringify(profile.name)} has no backend — set config.backend or the engine default`);
-			return workerFromBackend(backend, config.deliverable ?? defaults.deliverable)(profile, spawn);
-		}
-	};
-}
-/**
-* The thing that DECIDES: a nested `supervisorAgent` with the coordination verbs. Its children
-* are its own tree — the graph sees one node in, one `Settled` out. A `subgraph` constrains what
-* it may spawn; without one it is free-form under `profileSecurity` and `allowedModels`.
-*/
-function supervisorKind(deps) {
-	return {
-		id: "supervisor",
-		version: 1,
-		description: "A nested supervisor: spawns, observes, steers and awaits its own children with the coordination verbs.",
-		validateConfig: (raw, context) => {
-			const config = asRecord(raw, `${context}: supervisor config`);
-			return {
-				perWorker: asRecord(config.perWorker, `${context}: supervisor config.perWorker`),
-				...config.maxLiveWorkers !== void 0 ? { maxLiveWorkers: Number(config.maxLiveWorkers) } : {}
-			};
-		},
-		configSchema: {
-			type: "object",
-			properties: {
-				perWorker: { type: "object" },
-				maxLiveWorkers: { type: "integer" }
-			},
-			required: ["perWorker"],
-			additionalProperties: false
-		},
-		inputs: [],
-		outputs: [],
-		effects: [],
-		onCrash: "restart",
-		budget: "metered",
-		run: ({ config, profile }) => supervisorAgent(profile, {
-			blobs: deps.blobs,
-			makeWorkerAgent: deps.makeWorkerAgent,
-			perWorker: config.perWorker,
-			...config.maxLiveWorkers !== void 0 ? { maxLiveWorkers: config.maxLiveWorkers } : {},
-			...deps.router ? { router: deps.router } : {},
-			...deps.driveHarness ? { driveHarness: deps.driveHarness } : {}
-		})
-	};
-}
-/** The script kind's handle; it also names the kind in every script node's identity. */
-const SCRIPT = {
-	id: "script",
-	version: 1
-};
-/**
-* Caller code as a node. The one kind with no kernel primitive behind it: the kernel has no
-* "data→data with no execution" concept (agent-runtime#970 fact-finding), so this is new. It is
-* still a leaf `Agent` carrying an `Executor`, so the journal, the gate and the pool treat it like
-* any other node.
-*/
-function scriptKind() {
-	return {
-		...SCRIPT,
-		description: "Run caller code over the resolved inputs; pure scripts are exempt and restorable.",
-		validateConfig: (raw, context) => {
-			const config = asRecord(raw, `${context}: script config`);
-			if (typeof config.body !== "function") throw new ValidationError(`${context}: script config.body must be a function`);
-			if (config.pure !== void 0 && typeof config.pure !== "boolean") throw new ValidationError(`${context}: script config.pure must be a boolean`);
-			if (config.pure === true && config.spent !== void 0) throw new ValidationError(`${context}: a pure script is budget-exempt and cannot report spent`);
-			return {
-				body: config.body,
-				...config.pure !== void 0 ? { pure: config.pure } : {},
-				...config.spent !== void 0 ? { spent: config.spent } : {}
-			};
-		},
-		configSchema: {
-			type: "object",
-			properties: {
-				pure: { type: "boolean" },
-				spent: { type: "object" }
-			},
-			additionalProperties: true
-		},
-		inputs: [],
-		outputs: [],
-		effects: [],
-		onCrash: "restart",
-		budget: "metered",
-		run: ({ config, profile, inputs }) => scriptAgent(profile, config, inputs, SCRIPT)
-	};
-}
-function scriptAgent(profile, config, inputs, kind) {
-	let artifact;
-	const spec = {
-		profile,
-		harness: null,
-		executor: {
-			runtime: "inline",
-			...config.pure ? { budgetExempt: true } : {},
-			async execute(_task, signal) {
-				const startedAt = Date.now();
-				const out = await config.body(inputs, signal);
-				const ms = Date.now() - startedAt;
-				const spent = config.pure ? {
-					iterations: 0,
-					tokens: {
-						input: 0,
-						output: 0
-					},
-					usd: 0,
-					ms
-				} : config.spent ?? {
-					iterations: 1,
-					tokens: {
-						input: 0,
-						output: 0,
-						tokensKnown: false
-					},
-					tokensKnown: false,
-					usd: 0,
-					usdKnown: false,
-					ms
-				};
-				artifact = {
-					outRef: contentAddress(out),
-					out,
-					spent
-				};
-				return artifact;
-			},
-			teardown: () => Promise.resolve({ destroyed: true }),
-			resultArtifact() {
-				if (!artifact) throw new ValidationError("script: resultArtifact() read before execute()");
-				return artifact;
-			}
-		},
-		execution: { correlation: { nodeKind: formatRegistryHandle(kind) } }
-	};
-	return {
-		name: profile.name ?? "script",
-		act: () => Promise.reject(new ValidationError("script: act() is not the execution path")),
-		executorSpec: spec
-	};
-}
-/**
-* A node carrying its own graph: the constraint on what a supervisor may spawn at depth>1. Its
-* executor is a nested engine run; that needs the scheduler (#980), so until then this kind is
-* registered and REFUSES at run time by name rather than being absent — a graph that names it
-* compiles, and the refusal says exactly what is missing.
-*/
-function subgraphKind() {
-	return {
-		id: "subgraph",
-		version: 1,
-		description: "A node that runs its own graph; constrains a supervisor at depth>1.",
-		validateConfig: (raw, context) => {
-			const config = asRecord(raw, `${context}: subgraph config`);
-			if (config.graph === void 0) throw new ValidationError(`${context}: subgraph config.graph is required`);
-			return { graph: config.graph };
-		},
-		configSchema: {
-			type: "object",
-			properties: { graph: { type: "object" } },
-			required: ["graph"]
-		},
-		inputs: [],
-		outputs: [],
-		effects: [],
-		onCrash: "restart",
-		budget: "metered",
-		run: ({ profile }) => {
-			throw new ValidationError(`subgraph kind: node ${JSON.stringify(profile.name)} cannot run yet — the scheduler that executes a nested graph lands in agent-runtime#980`);
-		}
-	};
-}
-function asRecord(value, context) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new ValidationError(`${context} must be an object`);
-	return value;
-}
-//#endregion
-//#region src/runtime/graph/scheduler.ts
-/**
-* The engine scheduler (agent-runtime#980, durable per #974/#976): run a compiled graph by hosting
-* every node instance on one kernel `Scope` — the pool, the journal, the blob store and
-* cancellation are the kernel's, never re-implemented. The scheduler owns only what a graph adds:
-* joins over guarded edges, traversal and visit caps, directive/payload delivery, suspensions,
-* terminals and the finalizer reduce.
-*
-* DURABILITY MODEL — fold, never checkpoint. Every scheduling decision is journaled BEFORE its
-* effect is visible (blob-then-journal where a ref is minted), then applied to in-memory state
-* through the SAME pure reducer (`applyGraphFoldEvent`) a restart replays the journal through.
-* Kill the process at any journal boundary and a restart with the same journal re-enters the exact
-* state: settled nodes restore from `outRef` and are never re-executed; a released-but-unspawned
-* instance re-enters from its pinned `inputRef`; an in-flight instance is in-doubt and re-enters
-* per its kind's `onCrash`.
-*
-* Engine `woken` ordinals live in a reserved high band (`ENGINE_WOKEN_SEQ_BASE`+) so they can
-* never collide with the kernel scope's cursor counter, which the kernel owns and advances
-* concurrently.
-*/
-/** Engine-appended `woken` ordinals start here — far above any kernel cursor counter. */
-const ENGINE_WOKEN_SEQ_BASE = 1e7;
-const SUSPEND_MARK = "__graphSuspension";
-/** What a kind's executor returns to park its node on a host wake (agent-runtime#976). */
-function suspended(options = {}) {
-	const onExpire = options.onExpire ?? "wait";
-	if (onExpire !== "wait" && options.expiresInMs === void 0) throw new ValidationError(`suspended: onExpire '${onExpire}' requires expiresInMs`);
-	if (onExpire === "wait" && options.expiresInMs !== void 0) throw new ValidationError("suspended: onExpire 'wait' never expires — remove expiresInMs");
-	if (onExpire === "default" && options.default === void 0) throw new ValidationError("suspended: onExpire 'default' requires a default payload");
-	return {
-		[SUSPEND_MARK]: true,
-		onExpire,
-		...options.expiresInMs !== void 0 ? { expiresInMs: options.expiresInMs } : {},
-		...options.default !== void 0 ? { default: options.default } : {}
-	};
-}
-function isSuspensionRequest(value) {
-	return typeof value === "object" && value !== null && value[SUSPEND_MARK] === true;
-}
-/** Admission for every value crossing an edge (#971): JSON round-trip, `undefined` stripped, a
-*  non-representable value becomes a RECORD of that fact — a degraded record beats a vanished
-*  edge. */
-function admitPayload(value) {
-	if (value === void 0) return void 0;
-	try {
-		const text = JSON.stringify(value);
-		if (text === void 0) return { nonCanonical: `payload of type ${typeof value}` };
-		return JSON.parse(text);
-	} catch (error) {
-		return { nonCanonical: error instanceof Error ? error.message : String(error) };
-	}
-}
-/** Run a graph to its result: `createGraphRun` awaited — the one-call form for a run that needs
-*  no live host wakes. */
-async function runEngineGraph(engine, spec, task, options) {
-	return createGraphRun(engine, spec, task, options).done;
-}
-/**
-* Start (or resume) a graph run and return its handle: await `done` for the result; deliver host
-* wakes through `resume`/`expire` while it runs (#976).
-*/
-function createGraphRun(engine, spec, task, options) {
-	const compiled = "nodes" in spec && spec.nodes instanceof Map ? spec : compileGraph(engine, spec);
-	const wakes = [];
-	let notifyWake;
-	const handleState = { finished: false };
-	const done = runGraphLoop(engine, compiled, task, options, wakes, () => notifyWake?.(), (fn) => {
-		notifyWake = fn;
-	}).finally(() => {
-		handleState.finished = true;
-	});
-	const queue = (token, payload, expire) => {
-		if (handleState.finished) return Promise.reject(new ValidationError(`graph resume: run completed; start a new run over the same journal to wake '${token}'`));
-		return new Promise((settle, fail) => {
-			wakes.push({
-				token,
-				payload,
-				expire,
-				settle,
-				fail
-			});
-			notifyWake?.();
-		});
-	};
-	return {
-		done,
-		resume: (token, payload) => queue(token, payload, false),
-		expire: (token) => queue(token, void 0, true)
-	};
-}
-async function runGraphLoop(engine, compiled, task, options, wakes, _notify, onWakeSignal) {
-	const context = "runEngineGraph";
-	for (const node of compiled.nodes.values()) {
-		const missing = node.kind.effects.filter((name) => !(name in engine.effects));
-		if (missing.length > 0) throw new ValidationError(`${context}: node ${node.id} needs effect(s) ${missing.join(", ")} the host did not provide`);
-		if (node.spec.budget === void 0 && options.perNode === void 0) throw new ValidationError(`${context}: node ${node.id} declares no budget and options.perNode is absent — the engine invents no split`);
-	}
-	for (const edge of compiled.edges) if (edge.spec.directive !== void 0 && options.prompts === void 0) throw new ValidationError(`${context}: edge ${edge.id} carries a directive but options.prompts is absent`);
-	const now = options.now ?? Date.now;
-	const journal = options.journal ?? new InMemorySpawnJournal();
-	const blobs = options.blobs ?? new InMemoryResultBlobStore();
-	const runId = options.runId ?? `graph:${contentAddress({ task }).slice(0, 18)}`;
-	const prior = await journal.loadTree(runId);
-	if (prior !== void 0 && options.resume !== true) throw new ValidationError(`${context}: runId '${runId}' already exists; pass resume: true to continue it or use a new runId`);
-	const resuming = options.resume === true && prior !== void 0 && prior.length > 0;
-	let runEpochMs = now();
-	let rootBudget = options.budget;
-	if (prior === void 0) await journal.beginTree(runId, new Date(runEpochMs).toISOString());
-	if (!resuming) await journal.appendEvent(runId, {
-		kind: "spawned",
-		id: runId,
-		label: "graph-root",
-		budget: options.budget,
-		runtime: "inline",
-		seq: 0,
-		at: new Date(runEpochMs).toISOString()
-	});
-	if (resuming) {
-		const root = prior.find((ev) => ev.kind === "spawned" && ev.id === runId);
-		if (root?.kind === "spawned") {
-			runEpochMs = Date.parse(root.at);
-			rootBudget = root.budget;
-		}
-	}
-	const elapsed = () => now() - runEpochMs;
-	const pool = resuming ? createBudgetPool(rootBudget, elapsed, {
-		committed: (() => {
-			const measured = sumMeasuredSpendFromEvents(prior);
-			return addSpend(measured.childWork, measured.driverInference);
-		})(),
-		uncertainReservations: uncertainSpawnBudgets(prior),
-		...rootBudget.deadlineMs !== void 0 ? { absoluteDeadlineMs: runEpochMs + rootBudget.deadlineMs } : {}
-	}) : createBudgetPool(rootBudget, elapsed);
-	const abort = new AbortController();
-	const onOuterAbort = () => abort.abort(options.signal?.reason);
-	options.signal?.addEventListener("abort", onOuterAbort, { once: true });
-	if (options.signal?.aborted) abort.abort(options.signal.reason);
-	const scope = createScope({
-		parentId: runId,
-		root: runId,
-		pool,
-		journal,
-		blobs,
-		executors: createExecutorRegistry(),
-		seams: {},
-		depth: 0,
-		signal: abort.signal,
-		now,
-		...resuming ? { resumeFrom: {
-			settled: await replaySpawnTree(journal, blobs, runId),
-			view: materializeTreeView(prior),
-			maxSpawnOrdinal: maxSeqOf(prior, (ev) => ev.kind === "spawned"),
-			maxCursorSeq: maxSeqOf(prior, closesCursorSlot),
-			maxWaitOrdinal: maxSeqOf(prior, (ev) => ev.kind === "waiting"),
-			waits: pendingWaits(prior),
-			keys: /* @__PURE__ */ new Map(),
-			priorSpend: sumMeasuredSpendFromEvents(prior)
-		} } : {}
-	});
-	try {
-		return await runToResult();
-	} finally {
-		options.signal?.removeEventListener("abort", onOuterAbort);
-		abort.abort("run complete");
-	}
-	async function runToResult() {
-		const state = emptyFoldState(compiled);
-		if (resuming) for (const ev of prior) applyGraphFoldEvent(state, ev, compiled);
-		let engineSeq = resuming ? maxEngineSeq(prior) + 1 : 0;
-		let engineWokenSeq = ENGINE_WOKEN_SEQ_BASE + (resuming ? prior.filter((ev) => ev.kind === "woken" && ev.seq >= 1e7).length : 0);
-		const appendAndApply = async (ev) => {
-			await journal.appendEvent(runId, ev);
-			applyGraphFoldEvent(state, ev, compiled);
-		};
-		const ledger = [];
-		const liveHandles = /* @__PURE__ */ new Map();
-		const waitingForBudget = [];
-		const outCache = /* @__PURE__ */ new Map();
-		let ledgerSeq = resuming ? prior.filter((ev) => ev.kind === "edge").length : 0;
-		let liveCount = 0;
-		let failure;
-		const recordLedger = async (edge, traversal, outcome, reason) => {
-			const spec = edge.spec;
-			const entry = {
-				edge: edge.id,
-				kind: spec.kind,
-				from: spec.from.node,
-				to: spec.to.node,
-				traversal,
-				outcome,
-				...spec.directive !== void 0 ? { directive: `${spec.directive.surface}/v${spec.directive.version}` } : {},
-				...spec.kind === "data" ? { port: edge.toPort } : {},
-				...reason !== void 0 ? { reason } : {}
-			};
-			ledger.push(entry);
-			await journal.appendEvent(runId, {
-				kind: "edge",
-				id: `graph:${spec.to.node}`,
-				edge: {
-					kind: spec.kind,
-					from: spec.from.node,
-					to: spec.to.node,
-					...entry.directive !== void 0 ? { directive: entry.directive } : {},
-					...entry.port !== void 0 ? { port: entry.port } : {}
-				},
-				traversal,
-				outcome: outcome === "delivered" ? "delivered" : outcome,
-				bytes: 0,
-				...reason !== void 0 ? { reason } : {},
-				seq: ledgerSeq++,
-				at: new Date(now()).toISOString()
-			});
-		};
-		/** Spawn one released instance from its journaled envelope — the ONE entry path, used for a
-		*  fresh release, a budget-parked retry, and a restart re-entry alike. */
-		const spawnInstance = async (instanceLabel) => {
-			if (failure) return;
-			const instance = state.instances.get(instanceLabel);
-			const node = instance === void 0 ? void 0 : compiled.nodes.get(instance.node);
-			if (!instance || !node || instance.inputRef === void 0) throw new ValidationError(`${context}: instance ${instanceLabel} has no journaled envelope`);
-			const envelope = await blobs.get(instance.inputRef);
-			if (envelope === void 0) throw new ValidationError(`${context}: envelope ${instance.inputRef} is not in the blob store`);
-			const effects = narrowEffects(node.kind.effects, engine.effects, `${context}: node ${node.id}`);
-			const agent = node.kind.run({
-				config: node.config,
-				profile: {
-					name: node.id,
-					...node.spec.profile ?? {}
-				},
-				inputs: envelope.inputs,
-				effects
-			});
-			const budget = node.spec.budget ?? options.perNode;
-			const spawned = scope.spawn(agent, envelope.task, {
-				label: instanceLabel,
-				budget
-			});
-			if (spawned.ok) {
-				liveCount += 1;
-				liveHandles.set(spawned.handle.id, instanceLabel);
-				applyGraphFoldEvent(state, {
-					kind: "spawned",
-					id: spawned.handle.id,
-					label: instanceLabel,
-					budget,
-					runtime: "inline",
-					seq: 0,
-					at: ""
-				}, compiled);
-				return;
-			}
-			if (spawned.reason === "budget-exhausted" || spawned.reason === "max-live-workers") {
-				waitingForBudget.push(instanceLabel);
-				return;
-			}
-			failure = {
-				reason: "driver-failed",
-				error: {
-					name: "SpawnRefused",
-					message: `node ${node.id}: ${spawned.reason}`
-				}
-			};
-			abort.abort(`spawn refused: ${node.id}`);
-		};
-		/** Release a node: journal the wave (join-state + envelope) then spawn. */
-		const release = async (nodeId, satisfiedBy, consumedPending) => {
-			const node = compiled.nodes.get(nodeId);
-			const folded = state.nodes.get(nodeId);
-			if (!node || !folded) return;
-			const visit = folded.visits + 1;
-			if (visit > node.maxVisits) {
-				failure = {
-					reason: "cycle-budget-exceeded",
-					error: {
-						name: "GraphCycleBudget",
-						message: `node ${nodeId} entered ${visit} times; maxVisits ${node.maxVisits}`
-					}
-				};
-				abort.abort(`cycle-budget-exceeded: ${nodeId}`);
-				return;
-			}
-			const instanceLabel = `${nodeId}#${visit}`;
-			const inputs = {};
-			const directives = [];
-			const traces = [];
-			for (const edge of satisfiedBy) {
-				const foldedEdge = state.edges.get(edge.id);
-				const spec = edge.spec;
-				if (spec.kind === "data" && foldedEdge?.state === "satisfied") {
-					let payload = foldedEdge.payloadRef === void 0 ? void 0 : outCache.get(foldedEdge.payloadRef);
-					if (payload === void 0 && foldedEdge.payloadRef !== void 0) payload = admitPayload(await blobs.get(foldedEdge.payloadRef));
-					let outcome = "delivered";
-					let reason;
-					if (spec.projection !== void 0) try {
-						payload = admitPayload(applyProjection(payload, spec.projection, `edge ${edge.id}`));
-					} catch (error) {
-						outcome = "empty";
-						reason = error instanceof Error ? error.message : String(error);
-						payload = void 0;
-					}
-					if (payload === void 0 && outcome === "delivered") outcome = "empty";
-					await recordLedger(edge, (foldedEdge?.traversals ?? 0) + 1, outcome, reason);
-					if (payload !== void 0) inputs[edge.toPort] = payload;
-				} else {
-					if (spec.directive !== void 0 && options.prompts !== void 0) directives.push(options.prompts.resolve(spec.directive).text);
-					if (spec.kind === "analyzes" && foldedEdge?.state === "satisfied") traces.push(`trace of ${spec.from.node}: ${foldedEdge.payloadRef ?? "(no traceRef)"}`);
-					await recordLedger(edge, (foldedEdge?.traversals ?? 0) + 1, "delivered");
-				}
-			}
-			const nodeTask = [
-				nodeId === compiled.root ? task : "",
-				...directives,
-				...traces
-			].filter((part) => part.length > 0).join("\n\n");
-			const envelope = {
-				task: nodeTask.length > 0 ? nodeTask : task,
-				inputs
-			};
-			const inputRef = contentAddress(envelope);
-			await blobs.put(inputRef, envelope);
-			const at = new Date(now()).toISOString();
-			await appendAndApply({
-				kind: "node-inputs-resolved",
-				id: instanceLabel,
-				node: nodeId,
-				instance: instanceLabel,
-				inputRef,
-				seq: engineSeq++,
-				at
-			});
-			await appendAndApply({
-				kind: "join-state",
-				id: instanceLabel,
-				node: nodeId,
-				rule: node.join,
-				satisfiedBy: satisfiedBy.map((edge) => edge.id),
-				consumedPending,
-				instance: instanceLabel,
-				seq: engineSeq++,
-				at
-			});
-			await spawnInstance(instanceLabel);
-		};
-		/** Join evaluation per ADC's rules over the folded edge states. */
-		const tryRelease = async (nodeId) => {
-			const node = compiled.nodes.get(nodeId);
-			const folded = state.nodes.get(nodeId);
-			if (!node || !folded || folded.blocked || failure) return;
-			const gating = node.inbound;
-			if (gating.length === 0) return;
-			const states = gating.map((edge) => ({
-				edge,
-				folded: state.edges.get(edge.id)
-			}));
-			const settled = states.filter((entry) => entry.folded && entry.folded.state !== "pending");
-			const satisfied = states.filter((entry) => entry.folded?.state === "satisfied");
-			const failed = states.filter((entry) => entry.folded?.state === "failed");
-			const allSettled = settled.length === gating.length;
-			let releaseNow = false;
-			switch (node.join) {
-				case "all":
-					releaseNow = satisfied.length === gating.length && !states.some((entry) => entry.folded?.state === "dead" || entry.folded?.state === "failed");
-					break;
-				case "any":
-					releaseNow = satisfied.length > 0;
-					if (!releaseNow && allSettled) folded.blocked = true;
-					break;
-				case "any_failed":
-					releaseNow = failed.length > 0;
-					if (!releaseNow && allSettled) folded.blocked = true;
-					break;
-				case "all_done":
-					releaseNow = allSettled;
-					break;
-			}
-			if (!releaseNow) return;
-			const consuming = node.join === "any" ? [satisfied[0]] : node.join === "any_failed" ? [failed[0]] : settled;
-			for (const entry of consuming) {
-				const cap = entry.edge.spec.maxTraversals;
-				if (cap !== void 0 && (entry.folded?.traversals ?? 0) >= cap) {
-					recordLedger(entry.edge, (entry.folded?.traversals ?? 0) + 1, "unpropagated", `traversal-cap-exhausted (max ${cap})`);
-					await appendAndApply({
-						kind: "edge-verdict",
-						id: `graph:${nodeId}`,
-						edge: entry.edge.id,
-						fired: false,
-						sourceStatus: "done",
-						capped: true,
-						seq: engineSeq++,
-						at: new Date(now()).toISOString()
-					});
-					return;
-				}
-			}
-			const consumedPending = states.filter((entry) => entry.folded?.state === "pending" && hasLiveInstance(state, liveHandles, entry.edge.spec.from.node)).map((entry) => entry.edge.id);
-			await release(nodeId, consuming.map((entry) => entry.edge), consumedPending);
-		};
-		/** Judge every outbound edge of a settle: journal the verdict, apply, then try the joins. */
-		const propagate = async (instanceLabel, settle) => {
-			const node = compiled.nodes.get(settle.node);
-			if (!node) return;
-			const succeeded = settle.status === "done" && settle.valid !== false;
-			const sourceSettles = state.nodes.get(settle.node)?.settles.length ?? 0;
-			for (const edge of node.outbound) {
-				const folded = state.edges.get(edge.id);
-				if (!folded) continue;
-				if (folded.judgedSourceSettles >= sourceSettles) continue;
-				let fired = false;
-				let inputRef;
-				if (succeeded) {
-					const guardContext = {
-						node: settle.node,
-						out: settle.out,
-						visits: state.nodes.get(settle.node)?.visits ?? 0,
-						valid: settle.valid ?? true
-					};
-					fired = edge.spec.guard === void 0 || evaluateCondition(edge.spec.guard, guardContext);
-					if (fired) inputRef = edge.spec.kind === "analyzes" ? settle.traceRef ?? void 0 : settle.outRef;
-				}
-				await appendAndApply({
-					kind: "edge-verdict",
-					id: instanceLabel,
-					edge: edge.id,
-					fired,
-					sourceStatus: settle.status === "down" ? "down" : succeeded ? "done" : "invalid",
-					...inputRef !== void 0 ? { inputRef } : {},
-					seq: engineSeq++,
-					at: new Date(now()).toISOString()
-				});
-			}
-			for (const edge of node.outbound) await tryRelease(edge.spec.to.node);
-		};
-		const mintToken = (instanceLabel) => contentAddress({
-			runId,
-			instance: instanceLabel,
-			kind: "graph-suspension"
-		});
-		const journalSuspension = async (instanceLabel, request) => {
-			const token = mintToken(instanceLabel);
-			let defaultRef;
-			if (request.default !== void 0) {
-				const admitted = admitPayload(request.default);
-				defaultRef = contentAddress(admitted);
-				await blobs.put(defaultRef, admitted);
-			}
-			await appendAndApply({
-				kind: "waiting",
-				id: `graphwait:${token}`,
-				label: instanceLabel,
-				spec: {
-					kind: "token",
-					token,
-					onExpire: request.onExpire,
-					...request.expiresInMs !== void 0 ? { expiresAtMs: now() + request.expiresInMs } : {},
-					...defaultRef !== void 0 ? { defaultRef } : {}
-				},
-				armedAt: now(),
-				seq: engineSeq++,
-				at: new Date(now()).toISOString()
-			});
-		};
-		const wake = async (suspension, by, outRef) => {
-			await appendAndApply({
-				kind: "woken",
-				id: `graphwait:${suspension.token}`,
-				by,
-				...outRef !== void 0 ? { outRef } : {},
-				seq: engineWokenSeq++,
-				at: new Date(now()).toISOString()
-			});
-			const settle = state.instances.get(suspension.instance)?.settle;
-			if (settle !== void 0) {
-				const enriched = {
-					...settle,
-					...settle.outRef !== void 0 ? { out: admitPayload(await blobs.get(settle.outRef)) } : {}
-				};
-				if (enriched.outRef !== void 0 && enriched.out !== void 0) outCache.set(enriched.outRef, enriched.out);
-				await propagate(suspension.instance, enriched);
-			}
-		};
-		/** Expiries are engine-clocked: judged on every loop turn and before parking (#976). */
-		const sweepExpiries = async () => {
-			for (const suspension of [...state.suspensions.values()]) {
-				if (suspension.status !== "pending") continue;
-				if (suspension.expiresAtMs === void 0 || now() < suspension.expiresAtMs) continue;
-				if (suspension.onExpire === "fail") await wake(suspension, "expired");
-				else if (suspension.onExpire === "default") await wake(suspension, "fired", suspension.defaultRef);
-			}
-		};
-		const processWakes = async () => {
-			while (wakes.length > 0) {
-				const request = wakes.shift();
-				if (!request) break;
-				try {
-					const suspension = state.suspensions.get(request.token);
-					if (!suspension) throw new ValidationError(`graph resume: unknown token '${request.token}'`);
-					if (suspension.status !== "pending") throw new ValidationError(`graph resume: token '${request.token}' already woken`);
-					if (request.expire) if (suspension.onExpire === "fail") await wake(suspension, "expired");
-					else if (suspension.onExpire === "default") await wake(suspension, "fired", suspension.defaultRef);
-					else await wake(suspension, "expired");
-					else {
-						const admitted = admitPayload(request.payload);
-						const outRef = contentAddress(admitted);
-						await blobs.put(outRef, admitted);
-						outCache.set(outRef, admitted);
-						await wake(suspension, "fired", outRef);
-					}
-					request.settle();
-				} catch (error) {
-					request.fail(error);
-				}
-			}
-		};
-		const handleSettle = async (settled) => {
-			const instanceLabel = liveHandles.get(settled.handle.id);
-			if (instanceLabel === void 0) return;
-			liveHandles.delete(settled.handle.id);
-			liveCount -= 1;
-			const instance = state.instances.get(instanceLabel);
-			const node = instance === void 0 ? void 0 : compiled.nodes.get(instance.node);
-			if (!instance || !node) return;
-			if (settled.kind === "done" && isSuspensionRequest(settled.out)) {
-				await journalSuspension(instanceLabel, settled.out);
-				return;
-			}
-			applyGraphFoldEvent(state, {
-				kind: "settled",
-				id: settled.handle.id,
-				status: settled.kind === "done" ? "done" : "down",
-				...settled.kind === "done" ? { outRef: settled.outRef } : {},
-				...settled.kind === "down" ? { reason: settled.reason } : {},
-				...settled.kind === "done" && settled.trace?.status === "available" ? { trace: settled.trace } : {},
-				spent: {
-					iterations: 0,
-					tokens: {
-						input: 0,
-						output: 0
-					},
-					usd: 0,
-					ms: 0
-				},
-				seq: 0,
-				at: ""
-			}, compiled);
-			const folded = state.instances.get(instanceLabel)?.settle;
-			if (!folded) return;
-			let enriched = folded;
-			if (settled.kind === "done") {
-				const admitted = admitPayload(settled.out);
-				if (settled.outRef !== void 0) outCache.set(settled.outRef, admitted);
-				let valid;
-				if (node.deliverable !== void 0) try {
-					valid = await node.deliverable.check(admitted);
-				} catch {
-					valid = false;
-				}
-				enriched = {
-					...folded,
-					out: admitted,
-					...valid !== void 0 ? { valid } : {}
-				};
-				state.instances.get(instanceLabel).settle = enriched;
-				const settles = state.nodes.get(instance.node)?.settles;
-				if (settles) settles[settles.length - 1] = enriched;
-			}
-			if (instance.node === compiled.root && enriched.status === "done" && enriched.valid === true) {
-				abort.abort("root delivered");
-				return;
-			}
-			await propagate(instanceLabel, enriched);
-		};
-		const enterEntryNode = async (nodeId) => {
-			const folded = state.nodes.get(nodeId);
-			if (!folded) return;
-			const visit = folded.visits + 1;
-			const node = compiled.nodes.get(nodeId);
-			if (!node) return;
-			if (visit > node.maxVisits) return;
-			const instanceLabel = `${nodeId}#${visit}`;
-			const envelope = {
-				task,
-				inputs: {}
-			};
-			const inputRef = contentAddress(envelope);
-			await blobs.put(inputRef, envelope);
-			await appendAndApply({
-				kind: "node-inputs-resolved",
-				id: instanceLabel,
-				node: nodeId,
-				instance: instanceLabel,
-				inputRef,
-				seq: engineSeq++,
-				at: new Date(now()).toISOString()
-			});
-			await spawnInstance(instanceLabel);
-		};
-		if (!resuming) for (const id of compiled.entries) await enterEntryNode(id);
-		else {
-			for (const instance of [...state.instances.values()]) if (instance.status === "released") await spawnInstance(instance.instance);
-			else if (instance.status === "live") {
-				const node = compiled.nodes.get(instance.node);
-				const folded = state.nodes.get(instance.node);
-				if (!node || !folded) continue;
-				const visit = folded.visits + 1;
-				if (visit > node.maxVisits) {
-					failure = {
-						reason: "cycle-budget-exceeded",
-						error: {
-							name: "GraphCycleBudget",
-							message: `node ${instance.node} entered ${visit} times; maxVisits ${node.maxVisits}`
-						}
-					};
-					break;
-				}
-				const restartLabel = `${instance.node}#${visit}`;
-				instance.status = "down";
-				const at = new Date(now()).toISOString();
-				await journal.appendEvent(runId, {
-					kind: "node-inputs-resolved",
-					id: restartLabel,
-					node: instance.node,
-					instance: restartLabel,
-					inputRef: instance.inputRef,
-					seq: engineSeq++,
-					at
-				});
-				applyGraphFoldEvent(state, {
-					kind: "node-inputs-resolved",
-					id: restartLabel,
-					node: instance.node,
-					instance: restartLabel,
-					inputRef: instance.inputRef,
-					seq: 0,
-					at
-				}, compiled);
-				await spawnInstance(restartLabel);
-			}
-			for (const [nodeId, foldedNode] of state.nodes) {
-				const latest = foldedNode.settles.at(-1);
-				if (latest === void 0) continue;
-				const instanceLabel = `${nodeId}#${latest.visit}`;
-				let enriched = latest;
-				if (latest.status === "done" && latest.outRef !== void 0) {
-					const out = admitPayload(await blobs.get(latest.outRef));
-					if (isSuspensionRequest(out)) {
-						foldedNode.settles.pop();
-						const instance = state.instances.get(instanceLabel);
-						if (instance) instance.settle = void 0;
-						await journalSuspension(instanceLabel, out);
-						continue;
-					}
-					outCache.set(latest.outRef, out);
-					const nodeSpec = compiled.nodes.get(nodeId);
-					let valid;
-					if (nodeSpec?.deliverable !== void 0) try {
-						valid = await nodeSpec.deliverable.check(out);
-					} catch {
-						valid = false;
-					}
-					enriched = {
-						...latest,
-						out,
-						...valid !== void 0 ? { valid } : {}
-					};
-				}
-				await propagate(instanceLabel, enriched);
-			}
-			for (const id of compiled.entries) if ((state.nodes.get(id)?.visits ?? 0) === 0) await enterEntryNode(id);
-			for (const id of compiled.nodes.keys()) await tryRelease(id);
-		}
-		const allTerminalsSettled = () => compiled.terminals.every((id) => (state.nodes.get(id)?.settles.length ?? 0) > 0);
-		let wakeSignal = Promise.resolve();
-		let armWake = () => {};
-		const rearmWakeSignal = () => {
-			wakeSignal = new Promise((fire) => {
-				armWake = fire;
-			});
-			onWakeSignal(() => armWake());
-		};
-		rearmWakeSignal();
-		let inFlightNext;
-		while (!failure) {
-			await sweepExpiries();
-			if (wakes.length > 0) {
-				await processWakes();
-				continue;
-			}
-			if (allTerminalsSettled()) break;
-			if (liveCount === 0) {
-				const pendingSuspensions = [...state.suspensions.values()].filter((suspension) => suspension.status === "pending");
-				if (pendingSuspensions.length > 0) {
-					const nearest = Math.min(...pendingSuspensions.map((suspension) => suspension.expiresAtMs ?? Number.POSITIVE_INFINITY));
-					if (Number.isFinite(nearest) && now() >= nearest) continue;
-					if (options.waitForWakes) {
-						rearmWakeSignal();
-						await wakeSignal;
-						continue;
-					}
-					const defaulting = pendingSuspensions.filter((suspension) => suspension.onExpire === "default");
-					if (defaulting.length > 0) {
-						for (const suspension of defaulting) await wake(suspension, "fired", suspension.defaultRef);
-						continue;
-					}
-					break;
-				}
-				break;
-			}
-			inFlightNext ??= scope.next();
-			const raced = await Promise.race([inFlightNext.then((settle) => ({ settle })), wakeSignal.then(() => "wake")]);
-			if (raced === "wake") {
-				rearmWakeSignal();
-				continue;
-			}
-			inFlightNext = void 0;
-			if (raced.settle === null) break;
-			await handleSettle(raced.settle);
-			for (const parked of waitingForBudget.splice(0)) await spawnInstance(parked);
-		}
-		abort.abort("graph loop complete");
-		while (await (inFlightNext ?? scope.next()) !== null) inFlightNext = void 0;
-		const rehydrate = async (settle) => {
-			if (settle.out !== void 0 || settle.outRef === void 0) return settle;
-			const out = outCache.get(settle.outRef) ?? admitPayload(await blobs.get(settle.outRef));
-			const node = compiled.nodes.get(settle.node);
-			let valid = settle.valid;
-			if (valid === void 0 && node?.deliverable !== void 0 && settle.status === "done") try {
-				valid = await node.deliverable.check(out);
-			} catch {
-				valid = false;
-			}
-			return {
-				...settle,
-				out,
-				...valid !== void 0 ? { valid } : {}
-			};
-		};
-		const settles = await Promise.all([...compiled.nodes.keys()].flatMap((id) => state.nodes.get(id)?.settles ?? []).map(rehydrate));
-		const terminals = settles.filter((settle) => compiled.nodes.get(settle.node)?.terminal);
-		const finish = (result) => {
-			if (result.kind === "no-winner" && state.exhaustedEdges.size > 0) throw new GraphEdgeCapError(Object.freeze([...state.exhaustedEdges]), Object.freeze([...ledger]), result);
-			return result;
-		};
-		if (failure) return finish({
-			kind: "no-winner",
-			reason: failure.reason,
-			...failure.error ? { error: failure.error } : {},
-			terminals,
-			settles,
-			ledger,
-			unreachable: []
-		});
-		const pendingTokens = [...state.suspensions.values()].filter((suspension) => suspension.status === "pending").map((suspension) => suspension.token);
-		if (pendingTokens.length > 0 && !allTerminalsSettled()) return {
-			kind: "suspended",
-			tokens: pendingTokens,
-			terminals,
-			settles,
-			ledger
-		};
-		if (options.signal?.aborted) return finish({
-			kind: "no-winner",
-			reason: "aborted",
-			terminals,
-			settles,
-			ledger,
-			unreachable: []
-		});
-		const out = terminals.some((settle) => settle.status === "done" && settle.valid !== false) ? await runFinalizer(options.finalizer === void 0 || options.finalizer === "bestDelivered" ? bestDelivered : options.finalizer === "collectDelivered" ? collectDelivered : options.finalizer, {
-			settled: terminals.map((settle) => ({
-				id: settle.node,
-				status: settle.status,
-				valid: settle.status === "done" && settle.valid !== false,
-				...settle.outRef !== void 0 ? { outRef: settle.outRef } : {}
-			})),
-			blobs,
-			tree: scope.view,
-			budget: scope.budget
-		}) : void 0;
-		if (out !== void 0) return {
-			kind: "winner",
-			out,
-			terminals,
-			settles,
-			ledger
-		};
-		const unreachable = [...compiled.nodes.keys()].filter((id) => (state.nodes.get(id)?.settles.length ?? 0) === 0);
-		return finish({
-			kind: "no-winner",
-			reason: compiled.terminals.some((id) => unreachable.includes(id)) ? unreachable.length === compiled.nodes.size ? "budget-exhausted" : "unreachable-terminal" : "all-children-down",
-			terminals,
-			settles,
-			ledger,
-			unreachable
-		});
-	}
-}
-function hasLiveInstance(state, liveHandles, node) {
-	for (const label of liveHandles.values()) if (state.instances.get(label)?.node === node) return true;
-	return false;
-}
-function maxEngineSeq(events) {
-	let max = -1;
-	for (const ev of events) {
-		if (ev.kind === "node-inputs-resolved" || ev.kind === "edge-verdict" || ev.kind === "join-state") {
-			if (ev.seq > max) max = ev.seq;
-		}
-		if (ev.kind === "waiting" && ev.spec.kind === "token" && ev.seq > max) max = ev.seq;
-	}
-	return max;
-}
-//#endregion
-export { CONDITION_OPS, DEFAULT_MAX_NODE_VISITS, ENGINE_WOKEN_SEQ_BASE, JOIN_RULES, MAX_MAX_NODE_VISITS, admitPayload, agentKind, applyGraphFoldEvent, applyProjection, compileGraph, createGraphEngine, createGraphRun, createRegistry, emptyFoldState, evaluateCondition, foldGraphJournal, formatRegistryHandle, kindHandle, narrowEffects, parseRegistryHandle, runEngineGraph, schemaAccepts, scriptKind, subgraphKind, supervisorKind, suspended, validateCondition, validateNodeKind, validateProjection };
-
-//# sourceMappingURL=graph.js.map
+import { A as supervisorKind, B as MAX_MAX_NODE_VISITS, C as applyGraphFoldEvent, D as agentKind, E as admitPayload, F as compileGraph, G as validateProjection, H as formatRegistryHandle, I as isEngineFired, J as validateCondition, K as CONDITION_OPS, L as schemaAccepts, M as kindHandle, N as narrowEffects, O as scriptKind, P as validateNodeKind, R as DEFAULT_MAX_NODE_VISITS, S as decideJoin, T as foldGraphJournal, U as parseRegistryHandle, V as createRegistry, W as applyProjection, _ as ENGINE_WOKEN_SEQ_BASE, a as RUN_GRAPH_KIND, b as materializeSettles, c as runGraphKind, d as runEngineGraph, f as isSuspensionRequest, g as tokenFromSuspensionNodeId, h as suspensionNodeId, j as createGraphEngine, k as subgraphKind, l as runGraphThroughEngine, m as suspended, o as graphFromRunGraph, p as mintSuspensionToken, q as evaluateCondition, s as runGraphEngine, u as createGraphRun, v as openGraphRun, w as emptyFoldState, x as createEdgeLedger, y as assembleGraphResult, z as JOIN_RULES } from "./graph-E0U0c2YP.js";
+export { CONDITION_OPS, DEFAULT_MAX_NODE_VISITS, ENGINE_WOKEN_SEQ_BASE, JOIN_RULES, MAX_MAX_NODE_VISITS, RUN_GRAPH_KIND, admitPayload, agentKind, applyGraphFoldEvent, applyProjection, assembleGraphResult, compileGraph, createEdgeLedger, createGraphEngine, createGraphRun, createRegistry, decideJoin, emptyFoldState, evaluateCondition, foldGraphJournal, formatRegistryHandle, graphFromRunGraph, isEngineFired, isSuspensionRequest, kindHandle, materializeSettles, mintSuspensionToken, narrowEffects, openGraphRun, parseRegistryHandle, runEngineGraph, runGraphEngine, runGraphKind, runGraphThroughEngine, schemaAccepts, scriptKind, subgraphKind, supervisorKind, suspended, suspensionNodeId, tokenFromSuspensionNodeId, validateCondition, validateNodeKind, validateProjection };