@statelyai/agent 2.0.0-alpha.30 → 2.0.0-alpha.32

package/dist/ai-sdk.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_event_log = require("./event-log-BZRfBRd7.cjs");
-const require_decision = require("./decision-CIb7ddIv.cjs");
-const require_model_source = require("./model-source-BCKg4qJ1.cjs");
+const require_event_log = require("./event-log-CKWeC7H-.cjs");
+const require_decision = require("./decision-BPdEaxPf.cjs");
+const require_model_source = require("./model-source-BQ97_l1-.cjs");
 let ai = require("ai");
 //#region src/ai-sdk/mappers.ts
 /**
@@ -209,7 +209,7 @@ function toAiSdkOptionTool(options) {
 */
 function fromAiSdkOptionCall(toolCall, options, ids) {
 	if (toolCall.toolName !== OPTION_TOOL_NAME) return unofferedOption(`tool '${toolCall.toolName}'`, ids);
-	const id = require_decision.isRecord(toolCall.input) ? toolCall.input.option : void 0;
+	const id = require_event_log.isRecord(toolCall.input) ? toolCall.input.option : void 0;
 	const option = typeof id === "string" ? options[ids.indexOf(id)] : void 0;
 	return option ? option.event : unofferedOption(`option ${JSON.stringify(id)}`, ids);
 }
@@ -246,7 +246,7 @@ function maxStepsSetting(request) {
 	return typeof maxSteps === "number" ? { stopWhen: (0, ai.stepCountIs)(maxSteps) } : {};
 }
 function isDecisionModel(model) {
-	return require_decision.isRecord(model) && (typeof model.doDecide === "function" || typeof model.doEvaluate === "function");
+	return require_event_log.isRecord(model) && (typeof model.doDecide === "function" || typeof model.doEvaluate === "function");
 }
 /**
 * Splits a portable `"provider/model-id"` model ref (the convention JSON
@@ -498,16 +498,16 @@ function decisionResult(event, usage = {}, confidence) {
 	};
 }
 function unofferedChoice(error, ids) {
-	if (!ai.InvalidResponseDataError.isInstance(error) || !require_decision.isRecord(error.data)) return void 0;
+	if (!ai.InvalidResponseDataError.isInstance(error) || !require_event_log.isRecord(error.data)) return void 0;
 	const answer = error.data[DECISION_QUESTION_ID];
-	const choice = require_decision.isRecord(answer) ? answer.choice : void 0;
+	const choice = require_event_log.isRecord(answer) ? answer.choice : void 0;
 	return typeof choice === "string" && !ids.includes(choice) ? choice : void 0;
 }
 function toDecisionState(value) {
 	if (typeof value === "string") return value;
 	try {
 		const json = JSON.parse(JSON.stringify(value ?? {}));
-		return require_decision.isRecord(json) ? json : { value: json };
+		return require_event_log.isRecord(json) ? json : { value: json };
 	} catch {
 		return String(value);
 	}

package/dist/ai-sdk.d.cts

@@ -1,5 +1,5 @@
 import { s as AgentTools, u as ChosenEvent } from "./types-Dp5_Ru4R.cjs";
-import { N as AgentDecisionRequest, c as AgentRequestExecutorInfo, f as AgentTextRequest, r as AgentFinishReason, t as AgentCallUsage } from "./text-logic-DmciuVUQ.cjs";
+import { N as AgentDecisionRequest, c as AgentRequestExecutorInfo, f as AgentTextRequest, r as AgentFinishReason, t as AgentCallUsage } from "./text-logic-CYP502VT.cjs";
 import { Experimental_DecisionModel, FinishReason, LanguageModel, LanguageModelUsage, ModelMessage, ToolSet, TypedToolCall, TypedToolResult, generateText } from "ai";
 import { AnyStateMachine } from "xstate";
 //#region src/ai-sdk/mappers.d.ts

package/dist/ai-sdk.d.mts

@@ -1,5 +1,5 @@
 import { s as AgentTools, u as ChosenEvent } from "./types-Dp5_Ru4R.mjs";
-import { N as AgentDecisionRequest, c as AgentRequestExecutorInfo, f as AgentTextRequest, r as AgentFinishReason, t as AgentCallUsage } from "./text-logic-BRYOPWvY.mjs";
+import { N as AgentDecisionRequest, c as AgentRequestExecutorInfo, f as AgentTextRequest, r as AgentFinishReason, t as AgentCallUsage } from "./text-logic-DuK9HIFM.mjs";
 import { AnyStateMachine } from "xstate";
 import { Experimental_DecisionModel, FinishReason, LanguageModel, LanguageModelUsage, ModelMessage, ToolSet, TypedToolCall, TypedToolResult, generateText } from "ai";
 //#region src/ai-sdk/mappers.d.ts

package/dist/ai-sdk.mjs

@@ -1,6 +1,6 @@
-import { R as providerOutputSchema, ct as AgentTruncatedError, j as getAgentOutputMode, tt as isStandardSchema } from "./event-log-DJCMHek_.mjs";
-import { c as renderDecisionAttempts, m as isRecord, o as decisionOptionIds } from "./decision-BHkvuImD.mjs";
-import { t as resolveModelSource } from "./model-source-BaHwJ1wK.mjs";
+import { R as providerOutputSchema, dt as AgentTruncatedError, j as getAgentOutputMode, lt as isRecord, tt as isStandardSchema } from "./event-log-DAqsalT1.mjs";
+import { c as renderDecisionAttempts, o as decisionOptionIds } from "./decision-CV7WiV5C.mjs";
+import { t as resolveModelSource } from "./model-source-BilDEyqk.mjs";
 import { InvalidResponseDataError, NoObjectGeneratedError, Output, experimental_decide, generateText, jsonSchema, stepCountIs, streamText, tool } from "ai";
 //#region src/ai-sdk/mappers.ts
 /**

package/dist/{decision-CIb7ddIv.cjs → decision-BPdEaxPf.cjs}

@@ -1,11 +1,5 @@
-const require_event_log = require("./event-log-BZRfBRd7.cjs");
+const require_event_log = require("./event-log-CKWeC7H-.cjs");
 let xstate = require("xstate");
-//#region src/internal/is-record.ts
-/** True for a plain object-like value (arrays excluded). @internal */
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-//#endregion
 //#region src/events.ts
 /**
 * Thrown by {@link parseAgentEvent} (and {@link eventFromInteraction}) when a
@@ -103,7 +97,7 @@ function isEventPattern(entry) {
 * ```
 */
 function parseAgentEvent(source, payload, options = {}) {
-	if (!isRecord(payload) || typeof payload.type !== "string") throw new AgentInvalidEventPayloadError("(unknown)", "expected an object with a string `type`.");
+	if (!require_event_log.isRecord(payload) || typeof payload.type !== "string") throw new AgentInvalidEventPayloadError("(unknown)", "expected an object with a string `type`.");
 	const event = payload;
 	if (isReservedAgentEvent(event.type)) throw new AgentInvalidEventPayloadError(event.type, "this event type is reserved for the library and cannot be sent from outside.");
 	const machine = typeof source.provide === "function" ? source : source.machine;
@@ -135,14 +129,18 @@ function parseAgentEvent(source, payload, options = {}) {
 * ({@link RESERVED_AGENT_EVENT_PREFIX}) event types are always excluded, before
 * any `allowedEvents` matching — a machine that handles `'@agent.usage'` still
 * never offers it to a model.
+*
+* Pass `actor: "agent"` for the list a model may choose from: it also drops an
+* event the state handles through a transition tagged `meta: { actor: "human" }`.
 */
 function getAcceptedEvents(snapshot, options = {}) {
 	const eventTypes = options.eventTypes;
+	const humanEventTypes = options.actor === "agent" ? getHumanEventTypes(snapshot) : /* @__PURE__ */ new Set();
 	const seen = /* @__PURE__ */ new Set();
 	const usedToolNames = /* @__PURE__ */ new Set();
 	return (0, xstate.getNextTransitions)(snapshot).flatMap((transitionDefinition) => {
 		const eventType = transitionDefinition.eventType;
-		if (!eventType || eventType === "*" || eventType.startsWith("xstate.") || isReservedAgentEvent(eventType) || eventTypes && !eventTypes.some((pattern) => matchesEventPattern(eventType, pattern)) || seen.has(eventType)) return [];
+		if (!eventType || eventType === "*" || eventType.startsWith("xstate.") || isReservedAgentEvent(eventType) || humanEventTypes.has(eventType) || eventTypes && !eventTypes.some((pattern) => matchesEventPattern(eventType, pattern)) || seen.has(eventType)) return [];
 		seen.add(eventType);
 		const toolName = disambiguateEventToolName(sanitizeEventToolName(eventType), eventType, usedToolNames);
 		const inputSchema = (options.events ?? options.schemas?.events)?.[eventType];
@@ -153,6 +151,21 @@ function getAcceptedEvents(snapshot, options = {}) {
 		}];
 	});
 }
+/**
+* The event types a snapshot handles through a transition tagged
+* `meta: { actor: "human" }`: a person sends them, so no model is offered them.
+* @internal
+*/
+function getHumanEventTypes(snapshot) {
+	let types = humanEventTypesBySnapshot.get(snapshot);
+	if (!types) {
+		types = /* @__PURE__ */ new Set();
+		for (const transition of (0, xstate.getNextTransitions)(snapshot)) if (transition.meta?.actor === "human") types.add(transition.eventType);
+		humanEventTypesBySnapshot.set(snapshot, types);
+	}
+	return types;
+}
+const humanEventTypesBySnapshot = /* @__PURE__ */ new WeakMap();
 //#endregion
 //#region src/decision.ts
 function optionsFromPayloads(eventTypes, payloads) {
@@ -172,8 +185,8 @@ function optionsFromPayloads(eventTypes, payloads) {
 */
 function acceptedDecisionOptions(request, can) {
 	if (!request.options) return void 0;
-	const payloads = isRecord(request.input) ? request.input.payloads : void 0;
-	return (isRecord(payloads) ? optionsFromPayloads(request.events.map((event) => event.type), payloads) : request.options).filter((option) => {
+	const payloads = require_event_log.isRecord(request.input) ? request.input.payloads : void 0;
+	return (require_event_log.isRecord(payloads) ? optionsFromPayloads(request.events.map((event) => event.type), payloads) : request.options).filter((option) => {
 		try {
 			return can(option.event);
 		} catch {
@@ -565,22 +578,22 @@ Object.defineProperty(exports, "getAcceptedEvents", {
 		return getAcceptedEvents;
 	}
 });
-Object.defineProperty(exports, "isDecisionLogic", {
+Object.defineProperty(exports, "getHumanEventTypes", {
 	enumerable: true,
 	get: function() {
-		return isDecisionLogic;
+		return getHumanEventTypes;
 	}
 });
-Object.defineProperty(exports, "isEventPattern", {
+Object.defineProperty(exports, "isDecisionLogic", {
 	enumerable: true,
 	get: function() {
-		return isEventPattern;
+		return isDecisionLogic;
 	}
 });
-Object.defineProperty(exports, "isRecord", {
+Object.defineProperty(exports, "isEventPattern", {
 	enumerable: true,
 	get: function() {
-		return isRecord;
+		return isEventPattern;
 	}
 });
 Object.defineProperty(exports, "parseAgentEvent", {

package/dist/{decision-BHkvuImD.mjs → decision-CV7WiV5C.mjs}

@@ -1,11 +1,5 @@
-import { H as getAgentExecutionOptions, T as DECIDE_ACTOR, V as executorBoundLogics, at as userMessage, ot as validateSchemaSync, st as AgentError, u as canonicalEventJson, z as resolveTextLogicValue } from "./event-log-DJCMHek_.mjs";
+import { H as getAgentExecutionOptions, T as DECIDE_ACTOR, V as executorBoundLogics, at as userMessage, lt as isRecord, ot as validateSchemaSync, u as canonicalEventJson, ut as AgentError, z as resolveTextLogicValue } from "./event-log-DAqsalT1.mjs";
 import { createAsyncLogic, getNextTransitions } from "xstate";
-//#region src/internal/is-record.ts
-/** True for a plain object-like value (arrays excluded). @internal */
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-//#endregion
 //#region src/events.ts
 /**
 * Thrown by {@link parseAgentEvent} (and {@link eventFromInteraction}) when a
@@ -135,14 +129,18 @@ function parseAgentEvent(source, payload, options = {}) {
 * ({@link RESERVED_AGENT_EVENT_PREFIX}) event types are always excluded, before
 * any `allowedEvents` matching — a machine that handles `'@agent.usage'` still
 * never offers it to a model.
+*
+* Pass `actor: "agent"` for the list a model may choose from: it also drops an
+* event the state handles through a transition tagged `meta: { actor: "human" }`.
 */
 function getAcceptedEvents(snapshot, options = {}) {
 	const eventTypes = options.eventTypes;
+	const humanEventTypes = options.actor === "agent" ? getHumanEventTypes(snapshot) : /* @__PURE__ */ new Set();
 	const seen = /* @__PURE__ */ new Set();
 	const usedToolNames = /* @__PURE__ */ new Set();
 	return getNextTransitions(snapshot).flatMap((transitionDefinition) => {
 		const eventType = transitionDefinition.eventType;
-		if (!eventType || eventType === "*" || eventType.startsWith("xstate.") || isReservedAgentEvent(eventType) || eventTypes && !eventTypes.some((pattern) => matchesEventPattern(eventType, pattern)) || seen.has(eventType)) return [];
+		if (!eventType || eventType === "*" || eventType.startsWith("xstate.") || isReservedAgentEvent(eventType) || humanEventTypes.has(eventType) || eventTypes && !eventTypes.some((pattern) => matchesEventPattern(eventType, pattern)) || seen.has(eventType)) return [];
 		seen.add(eventType);
 		const toolName = disambiguateEventToolName(sanitizeEventToolName(eventType), eventType, usedToolNames);
 		const inputSchema = (options.events ?? options.schemas?.events)?.[eventType];
@@ -153,6 +151,21 @@ function getAcceptedEvents(snapshot, options = {}) {
 		}];
 	});
 }
+/**
+* The event types a snapshot handles through a transition tagged
+* `meta: { actor: "human" }`: a person sends them, so no model is offered them.
+* @internal
+*/
+function getHumanEventTypes(snapshot) {
+	let types = humanEventTypesBySnapshot.get(snapshot);
+	if (!types) {
+		types = /* @__PURE__ */ new Set();
+		for (const transition of getNextTransitions(snapshot)) if (transition.meta?.actor === "human") types.add(transition.eventType);
+		humanEventTypesBySnapshot.set(snapshot, types);
+	}
+	return types;
+}
+const humanEventTypesBySnapshot = /* @__PURE__ */ new WeakMap();
 //#endregion
 //#region src/decision.ts
 function optionsFromPayloads(eventTypes, payloads) {
@@ -517,4 +530,4 @@ async function resolveDecision(request, executors, options = {}) {
 	throw new AgentDecisionExhaustedError(attempts);
 }
 //#endregion
-export { createDecisionRequest as a, renderDecisionAttempts as c, getAcceptedEvents as d, isEventPattern as f, createDecisionLogic as i, resolveDecision as l, isRecord as m, acceptedDecisionOptions as n, decisionOptionIds as o, parseAgentEvent as p, createDecideActor as r, isDecisionLogic as s, AgentDecisionExhaustedError as t, AgentInvalidEventPayloadError as u };
+export { createDecisionRequest as a, renderDecisionAttempts as c, getAcceptedEvents as d, getHumanEventTypes as f, createDecisionLogic as i, resolveDecision as l, parseAgentEvent as m, acceptedDecisionOptions as n, decisionOptionIds as o, isEventPattern as p, createDecideActor as r, isDecisionLogic as s, AgentDecisionExhaustedError as t, AgentInvalidEventPayloadError as u };

package/dist/{event-log-BZRfBRd7.cjs → event-log-CKWeC7H-.cjs}

@@ -54,6 +54,31 @@ var AgentTruncatedError = class extends AgentError {
 	}
 };
 //#endregion
+//#region src/internal/is-record.ts
+/** True for a plain object-like value (arrays excluded). @internal */
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* True for an object whose prototype is `null` or some realm's
+* `Object.prototype`. Comparing against this realm's `Object.prototype` alone
+* rejects plain objects built in another realm: a jest test file's vm
+* context, or `structuredClone`'s output inside one. @internal
+*/
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || Object.getPrototypeOf(prototype) === null;
+}
+/** True for an `Error` from any realm, where `instanceof Error` sees only this one. @internal */
+function isError(value) {
+	return value instanceof Error || Object.prototype.toString.call(value) === "[object Error]";
+}
+/** JSON text with object keys sorted and `undefined` fields dropped, for comparing JSON-like values. @internal */
+function canonicalJson(value) {
+	return JSON.stringify(value, (_key, item) => isPlainObject(item) ? Object.fromEntries(Object.keys(item).sort().map((key) => [key, item[key]])) : item) ?? "undefined";
+}
+//#endregion
 //#region src/utils.ts
 /** Returns the human-readable text carried by a message, ignoring non-text parts. */
 function getMessageText(message) {
@@ -103,8 +128,7 @@ function findNonSerializableContextPaths(context, limit = 5) {
 			seen.delete(obj);
 			return;
 		}
-		const proto = Object.getPrototypeOf(value);
-		if (proto === Object.prototype || proto === null) {
+		if (isPlainObject(value)) {
 			seen.add(obj);
 			for (const [key, item] of Object.entries(value)) walk(item, `${path}.${key}`);
 			seen.delete(obj);
@@ -456,7 +480,7 @@ function responseMessagesOf(raw) {
 }
 function dropUndefined(value) {
 	if (Array.isArray(value)) return value.map(dropUndefined);
-	if (value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+	if (isPlainObject(value)) {
 		const out = {};
 		for (const [key, entry] of Object.entries(value)) if (entry !== void 0) out[key] = dropUndefined(entry);
 		return out;
@@ -932,8 +956,7 @@ function assertJsonSerializable(value, path = "entry", ancestors = /* @__PURE__
 			assertNoHiddenKeys(value, path, (key) => key === "length" || arrayIndexPattern.test(key));
 			return;
 		}
-		const prototype = Object.getPrototypeOf(value);
-		if (prototype !== Object.prototype && prototype !== null) throw new NonSerializableAgentEventError(path, value.constructor?.name ?? "object");
+		if (!isPlainObject(value)) throw new NonSerializableAgentEventError(path, value.constructor?.name ?? "object");
 		assertNoHiddenKeys(value, path);
 		for (const [key, child] of Object.entries(value)) assertJsonSerializable(child, `${path}.${key}`, ancestors);
 	} finally {
@@ -990,22 +1013,32 @@ function exhaustedAttemptsOf(error) {
 	return Array.isArray(attempts) && isJsonSerializable(attempts) ? attempts : void 0;
 }
 /**
-* Replaces `Error` instances with plain `{ name, message, cause? }` objects so
-* an `xstate.error.actor` payload survives the log's JSON round-trip. A
-* decision-exhausted error also keeps its `code` and `attempts`. Cycles
+* Marks an object {@link normalizeEventErrors} made from an `Error`, so replay
+* restores that object, and only that one, as an `Error`: a thrown plain
+* `{ name, message }` stays a plain object.
+*/
+const NORMALIZED_ERROR_KEY = "@error";
+/**
+* Replaces `Error` instances with plain `{ name, message, code?, cause?,
+* "@error": true }` objects so an `xstate.error.actor` payload survives the
+* log's JSON round-trip. `code` is kept when it is a string or a number; a
+* decision-exhausted error also keeps its `attempts`. Replay turns the
+* object back into an `Error` (see `restoreJournaledEvent`). Cycles
 * are preserved by identity; non-plain objects are left alone (and are then
 * rejected by {@link assertJsonSerializable}).
 */
 function normalizeEventErrors(value, seen = /* @__PURE__ */ new WeakMap()) {
-	if (value instanceof Error) {
+	if (isError(value)) {
 		const normalized = {
 			name: value.name,
-			message: value.message
+			message: value.message,
+			[NORMALIZED_ERROR_KEY]: true
 		};
 		seen.set(value, normalized);
 		if (value.cause !== void 0) normalized.cause = normalizeEventErrors(value.cause, seen);
-		if (value.code === DECISION_EXHAUSTED_CODE) {
-			normalized.code = DECISION_EXHAUSTED_CODE;
+		const code = value.code;
+		if (typeof code === "string" || typeof code === "number" && Number.isFinite(code)) normalized.code = code;
+		if (code === DECISION_EXHAUSTED_CODE) {
 			const attempts = exhaustedAttemptsOf(value);
 			if (attempts !== void 0) normalized.attempts = structuredClone(attempts);
 		}
@@ -1020,8 +1053,7 @@ function normalizeEventErrors(value, seen = /* @__PURE__ */ new WeakMap()) {
 		for (const item of value) result.push(normalizeEventErrors(item, seen));
 		return result;
 	}
-	const prototype = Object.getPrototypeOf(value);
-	if (prototype !== Object.prototype && prototype !== null) return value;
+	if (!isPlainObject(value)) return value;
 	const result = {};
 	seen.set(value, result);
 	for (const [key, item] of Object.entries(value)) result[key] = normalizeEventErrors(item, seen);
@@ -1046,7 +1078,7 @@ function canonicalizeForHash(value, seen = /* @__PURE__ */ new WeakSet(), positi
 	if (typeof value === "symbol") return `[symbol:${String(value)}]`;
 	if (value === null || typeof value !== "object") return value;
 	if (value instanceof Date) return `[Date:${value.toISOString()}]`;
-	if (value instanceof Error) {
+	if (isError(value)) {
 		if (seen.has(value)) return "[circular]";
 		seen.add(value);
 		try {
@@ -1141,7 +1173,7 @@ function createReplayEntry(machine, entries, event, options = {}) {
 		recordedAt: options.recordedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
 		machineId: machineIdOf(machine),
 		machineVersion,
-		event: normalizeDoneActorEvent(normalizeEventErrors(event)),
+		event: normalizeDoneActorEvent(pruneUndefined(normalizeEventErrors(event))),
 		...options.causationId !== void 0 ? { causationId: options.causationId } : {},
 		...options.metadata !== void 0 ? { metadata: options.metadata } : {},
 		...options.attempts !== void 0 && options.attempts.length > 0 ? { attempts: options.attempts } : {}
@@ -1154,15 +1186,23 @@ function createReplayEntry(machine, entries, event, options = {}) {
 	}).persistedSnapshot) };
 	return entry;
 }
-function pruneUndefined(value) {
-	if (Array.isArray(value)) return value.map(pruneUndefined);
+function pruneUndefined(value, ancestors = /* @__PURE__ */ new WeakSet()) {
 	if (value === null || typeof value !== "object") return value;
-	if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return value;
+	if (ancestors.has(value)) return value;
+	if (Array.isArray(value)) {
+		ancestors.add(value);
+		const result = value.map((item) => pruneUndefined(item, ancestors));
+		ancestors.delete(value);
+		return result;
+	}
+	if (!isPlainObject(value)) return value;
+	ancestors.add(value);
 	const result = {};
 	for (const [key, child] of Object.entries(value)) {
 		if (child === void 0) continue;
-		result[key] = pruneUndefined(child);
+		result[key] = pruneUndefined(child, ancestors);
 	}
+	ancestors.delete(value);
 	return result;
 }
 /**
@@ -1199,8 +1239,8 @@ function isSnapshotInitEntry(entry) {
 * Minted once per run and inherited verbatim by every resume of that log, so
 * it names one lineage rather than one process. Entry ids cannot serve this
 * role — the built-in ids are index-derived, so every log's init entry is
-* `evt_00000000`. A fork copies the init entry, so it shares its parent's
-* execution id by construction.
+* `evt_00000000`. A fork ({@link forkEventLog}, `store.fork`) mints its own
+* and records the parent's in `metadata.forkedFrom`.
 *
 * Returns `undefined` for a log with no init entry and for one written without
 * the field — callers must treat the id as optional.
@@ -1248,12 +1288,31 @@ function validateReplayEntries(entries, options = {}) {
 /**
 * The prefix `[0, upToIndex)` of a log, as a new log. `upToIndex` is exclusive
 * and must leave the init entry in place, so the fork is still self-contained.
+*
+* The fork is its own lineage: its init entry gets a fresh
+* `metadata.executionId` and `metadata.forkedFrom: { executionId?, logIndex }`:
+* the cutoff, and the parent's id when it had one. Call keys derive
+* from the execution id, so a fork's calls never collide with its parent's.
+* Every other entry is copied as is.
 */
 function forkEventLog(entries, upToIndex) {
 	if (!Number.isInteger(upToIndex) || upToIndex < 1 || upToIndex > entries.length) throw new AgentEventLogError(`forkEventLog: upToIndex must be an integer in [1, ${entries.length}]; got ${String(upToIndex)}.`);
 	const forked = entries.slice(0, upToIndex);
 	if (!isInitEntry(forked[0])) throw new AgentEventLogError(`forkEventLog: the forked prefix must start with the reserved '${AGENT_INIT_EVENT_TYPE}' entry.`);
-	return forked;
+	const [init, ...rest] = forked;
+	const parentExecutionId = getLogExecutionId(forked);
+	const forkedFrom = {
+		...parentExecutionId !== void 0 ? { executionId: parentExecutionId } : {},
+		logIndex: upToIndex
+	};
+	return [{
+		...init,
+		metadata: {
+			...init.metadata,
+			executionId: crypto.randomUUID(),
+			forkedFrom
+		}
+	}, ...rest];
 }
 const DONE_ACTOR_EVENT_TYPE = "xstate.done.actor";
 const ERROR_ACTOR_EVENT_TYPE = "xstate.error.actor";
@@ -1359,12 +1418,33 @@ function rebindActorSession(event, snapshot, sessions) {
 		sessionId
 	};
 }
-function restoreDoneActorOutput(event) {
-	if (event.type !== DONE_ACTOR_EVENT_TYPE || Object.hasOwn(event, "output")) return event;
-	return {
+/**
+* The event as the machine received it live: a done event's dropped
+* `undefined` output restored, and an error event's normalized error turned
+* back into an `Error`, so `error instanceof Error` holds on replay too.
+*/
+function restoreJournaledEvent(event) {
+	if (event.type === DONE_ACTOR_EVENT_TYPE && !Object.hasOwn(event, "output")) return {
 		...event,
 		output: void 0
 	};
+	if (event.type.startsWith(ERROR_ACTOR_EVENT_TYPE)) {
+		const error = event.error;
+		if (isNormalizedError(error)) return {
+			...event,
+			error: toError(error)
+		};
+	}
+	return event;
+}
+function isNormalizedError(value) {
+	return isPlainObject(value) && value[NORMALIZED_ERROR_KEY] === true && typeof value.name === "string" && typeof value.message === "string";
+}
+function toError(normalized) {
+	const { name, message, cause, [NORMALIZED_ERROR_KEY]: _marker, ...rest } = normalized;
+	const error = new Error(message, cause === void 0 ? void 0 : { cause: isNormalizedError(cause) ? toError(cause) : cause });
+	error.name = name;
+	return Object.assign(error, rest);
 }
 function verifyEntry(entry, persisted, mode) {
 	if (mode === false) return;
@@ -1412,7 +1492,7 @@ function foldLog(machine, entries, options = {}) {
 	verifyEntry(entries[0], persisted, options.verify);
 	const sessions = /* @__PURE__ */ new Map();
 	const apply = (entry) => {
-		const event = restoreDoneActorOutput(rebindActorSession(entry.event, snapshot, sessions));
+		const event = restoreJournaledEvent(rebindActorSession(entry.event, snapshot, sessions));
 		[snapshot] = (0, xstate.transition)(machine, snapshot, event);
 		persisted = machine.getPersistedSnapshot(snapshot);
 		return persisted;
@@ -1610,6 +1690,12 @@ Object.defineProperty(exports, "canonicalEventJson", {
 		return canonicalEventJson;
 	}
 });
+Object.defineProperty(exports, "canonicalJson", {
+	enumerable: true,
+	get: function() {
+		return canonicalJson;
+	}
+});
 Object.defineProperty(exports, "createReplayEntry", {
 	enumerable: true,
 	get: function() {
@@ -1742,6 +1828,18 @@ Object.defineProperty(exports, "initEntry", {
 		return initEntry;
 	}
 });
+Object.defineProperty(exports, "isPlainObject", {
+	enumerable: true,
+	get: function() {
+		return isPlainObject;
+	}
+});
+Object.defineProperty(exports, "isRecord", {
+	enumerable: true,
+	get: function() {
+		return isRecord;
+	}
+});
 Object.defineProperty(exports, "isStandardSchema", {
 	enumerable: true,
 	get: function() {