@ewhauser/world-celld 0.2.0 → 0.3.0

package/dist/testing.js

@@ -1,5 +1,5 @@
 import { a as cleanupTombstone, c as globalRunIndexKey, d as workflowRunIndexKey, f as compact, h as parse, i as TOMBSTONE_KEY, l as hookMarkerKey, m as rpcStringify, n as HOOK_MARKER_PREFIX, o as correlationIndexKey, p as rpcParse, r as INDEX_MARKER_PREFIX, s as expiredRead, t as CLEANUP_RECORD_KEY, u as indexMarkerKey } from "./retention-bLY1vcOu.js";
-import { EventSchema, HookSchema, SPEC_VERSION_CURRENT, StepSchema, WorkflowRunSchema, isLegacySpecVersion, isTerminalStepStatus, isTerminalWorkflowRunStatus, requiresNewerWorld } from "@workflow/world";
+import { EventSchema, HookSchema, SPEC_VERSION_CURRENT, StepSchema, WaitSchema, WorkflowRunSchema, applyAttributeChanges, eventIdToSlot, getMaxEventsPerRun, isChildEntityCreationEvent, isTerminalStepStatus, isTerminalWorkflowRunStatus, slotToEventId, validateAttributeChanges } from "@workflow/world";
 import http from "node:http";
 //#region src/testing/fake-cell.ts
 function applyListOptions(keys, options) {
@@ -1224,6 +1224,7 @@ const RUN_KEY = "run";
 const EVENT_KEY_PREFIX = "event:";
 const STEP_KEY_PREFIX = "step:";
 const HOOK_KEY_PREFIX = "hook:";
+const WAIT_KEY_PREFIX = "wait:";
 const STEP_CREATED_KEY_PREFIX = "stepcreated:";
 const HOOK_CREATED_KEY_PREFIX = "hookcreated:";
 /**
@@ -1233,6 +1234,10 @@ const HOOK_CREATED_KEY_PREFIX = "hookcreated:";
 * rejected as a duplicate instead of resurrecting the hook.
 */
 const HOOK_EVENT_MARKER_PREFIX = "hookevent:";
+/** Workflow-authored attr_set correlation claims. */
+const ATTRIBUTE_EVENT_MARKER_PREFIX = "attrevent:";
+/** Durable lazy-hook resume claims, scoped by the containing run DO. */
+const HOOK_RESUME_CLAIM_PREFIX = "hookresume:";
 function failure(code, message, extra) {
 	return {
 		ok: false,
@@ -1335,9 +1340,15 @@ async function releaseAllHooks(store) {
 	}
 	return released;
 }
+/** Delete all persisted waits once their owning run becomes terminal. */
+async function releaseAllWaits(store) {
+	const waits = await store.list({ prefix: WAIT_KEY_PREFIX });
+	for (const key of waits.keys()) await store.delete(key);
+}
 async function applyEvent(store, ctx) {
 	const { runId, data, now } = ctx;
 	const specVersion = data.specVersion ?? SPEC_VERSION_CURRENT;
+	if (specVersion !== SPEC_VERSION_CURRENT) return failure("RUN_NOT_SUPPORTED", `Run "${runId}" uses unsupported specVersion ${specVersion}; this world requires ${SPEC_VERSION_CURRENT}`, { runSpecVersion: specVersion });
 	/** Build and validate the stored event BEFORE anything is persisted. */
 	const buildEvent = (record) => {
 		const withMeta = {
@@ -1345,9 +1356,16 @@ async function applyEvent(store, ctx) {
 			runId,
 			eventId: ctx.nextEventId(),
 			createdAt: now,
+			occurredAt: ctx.params?.occurredAt,
+			resumeId: ctx.params?.resumeId,
 			specVersion
 		};
+		if (record.eventType !== "hook_received") delete withMeta.resumeId;
 		if (record.eventType === "run_started") delete withMeta.eventData;
+		if (record.eventType === "step_started" && withMeta.eventData !== null && typeof withMeta.eventData === "object") {
+			const { input: _input, ...eventData } = withMeta.eventData;
+			withMeta.eventData = eventData;
+		}
 		return EventSchema.parse(compact(withMeta));
 	};
 	const putEvent = async (event) => {
@@ -1358,14 +1376,21 @@ async function applyEvent(store, ctx) {
 	if (!skipRunValidation) currentRun = await store.get(RUN_KEY);
 	let bootstrapped;
 	if (data.eventType === "run_started" && !currentRun && data.eventData) {
-		const { deploymentId, workflowName, input, executionContext } = data.eventData;
+		const { deploymentId, workflowName, input, executionContext, attributes, allowReservedAttributes, encryptionPublicKey } = data.eventData;
 		if (deploymentId && workflowName && input !== void 0) {
+			const attributeChanges = Object.entries(attributes ?? {}).map(([key, value]) => ({
+				key,
+				value
+			}));
+			validateAttributeChanges(attributeChanges, { allowReservedAttributes });
 			const createdRun = WorkflowRunSchema.parse(compact({
 				runId,
 				deploymentId,
 				workflowName,
 				specVersion,
 				executionContext,
+				attributes,
+				encryptionPublicKey,
 				input,
 				status: "pending",
 				output: void 0,
@@ -1381,7 +1406,10 @@ async function applyEvent(store, ctx) {
 					deploymentId,
 					workflowName,
 					input,
-					executionContext
+					executionContext,
+					attributes,
+					allowReservedAttributes,
+					encryptionPublicKey
 				}
 			});
 			await store.put(RUN_KEY, createdRun);
@@ -1393,10 +1421,7 @@ async function applyEvent(store, ctx) {
 			};
 		}
 	}
-	if (currentRun) {
-		if (requiresNewerWorld(currentRun.specVersion)) return failure("RUN_NOT_SUPPORTED", `Run "${runId}" requires a newer world (run specVersion ${currentRun.specVersion}, world ${SPEC_VERSION_CURRENT})`, { runSpecVersion: currentRun.specVersion });
-		if (isLegacySpecVersion(currentRun.specVersion)) return failure("LEGACY_RUN_NOT_SUPPORTED", `Run "${runId}" was created with a legacy spec version (${currentRun.specVersion ?? "undefined"}) not supported by this world`);
-	}
+	if (currentRun && currentRun.specVersion !== SPEC_VERSION_CURRENT) return failure("RUN_NOT_SUPPORTED", `Run "${runId}" uses unsupported specVersion ${currentRun.specVersion}; this world requires ${SPEC_VERSION_CURRENT}`, { runSpecVersion: currentRun.specVersion });
 	if (currentRun && isTerminalWorkflowRunStatus(currentRun.status)) {
 		if (data.eventType === "run_cancelled" && currentRun.status === "cancelled") {
 			const event = buildEvent({ ...data });
@@ -1410,14 +1435,32 @@ async function applyEvent(store, ctx) {
 		}
 		if (data.eventType === "run_started") return failure("RUN_EXPIRED", `Workflow run "${runId}" is already in terminal state "${currentRun.status}"`);
 		if (data.eventType === "run_completed" || data.eventType === "run_failed" || data.eventType === "run_cancelled") return failure("ENTITY_CONFLICT", `Cannot transition run from terminal state "${currentRun.status}"`);
-		if (data.eventType === "step_created" || data.eventType === "hook_created" || data.eventType === "wait_created") return failure("ENTITY_CONFLICT", `Cannot create new entities on run in terminal state "${currentRun.status}"`);
+		if (isChildEntityCreationEvent(data)) return failure("ENTITY_CONFLICT", `Cannot create new entities on run in terminal state "${currentRun.status}"`);
+		if (data.eventType === "attr_set") return failure("ENTITY_CONFLICT", `Cannot set attributes on run in terminal state "${currentRun.status}"`);
 	}
 	let validatedStep;
 	if (data.eventType === "step_started" || data.eventType === "step_completed" || data.eventType === "step_failed" || data.eventType === "step_retrying") {
+		const lazyStepStart = data.eventType === "step_started" && isChildEntityCreationEvent(data);
 		validatedStep = await store.get(`${STEP_KEY_PREFIX}${data.correlationId}`);
-		if (!validatedStep) return failure("STEP_NOT_FOUND", `Step "${data.correlationId}" not found`);
-		if (isTerminalStepStatus(validatedStep.status)) return failure("ENTITY_CONFLICT", `Cannot modify step in terminal state "${validatedStep.status}"`);
-		if (currentRun && isTerminalWorkflowRunStatus(currentRun.status) && validatedStep.status !== "running") return failure("RUN_EXPIRED", `Cannot modify non-running step on run in terminal state "${currentRun.status}"`);
+		if (!validatedStep) {
+			if (!lazyStepStart) return failure("STEP_NOT_FOUND", `Step "${data.correlationId}" not found`);
+		} else if (lazyStepStart) return failure("ENTITY_CONFLICT", `Step "${data.correlationId}" already exists`);
+		if (validatedStep && isTerminalStepStatus(validatedStep.status)) return failure("ENTITY_CONFLICT", `Cannot modify step in terminal state "${validatedStep.status}"`);
+		if (currentRun && isTerminalWorkflowRunStatus(currentRun.status) && validatedStep && validatedStep.status !== "running") return failure("RUN_EXPIRED", `Cannot modify non-running step on run in terminal state "${currentRun.status}"`);
+	}
+	if (data.eventType === "hook_received" && ctx.params?.resumeId) {
+		const claim = await store.get(`${HOOK_RESUME_CLAIM_PREFIX}${ctx.params.resumeId}`);
+		if (claim) {
+			if (claim.hookId !== data.correlationId) return failure("ENTITY_CONFLICT", `hook_received resumeId "${ctx.params.resumeId}" already recorded for a different hook`);
+			if (claim.payloadDigest && ctx.params.resumePayloadDigest && claim.payloadDigest !== ctx.params.resumePayloadDigest) return failure("ENTITY_CONFLICT", `hook_received resumeId "${ctx.params.resumeId}" already recorded with a different payload`);
+			const committed = await store.get(`${EVENT_KEY_PREFIX}${claim.eventId}`);
+			if (committed?.eventType === "hook_received" && committed.correlationId === claim.hookId && committed.resumeId === ctx.params.resumeId) return {
+				ok: true,
+				event: committed,
+				releasedHooks: []
+			};
+			if (committed) return failure("ENTITY_CONFLICT", `hook_received resumeId "${ctx.params.resumeId}" points to a different event`);
+		}
 	}
 	if ((data.eventType === "hook_disposed" || data.eventType === "hook_received") && data.correlationId) {
 		if (!await store.get(`hook:${data.correlationId}`)) return failure("HOOK_NOT_FOUND", `Hook "${data.correlationId}" not found`);
@@ -1431,12 +1474,19 @@ async function applyEvent(store, ctx) {
 				run: existing,
 				releasedHooks: []
 			};
+			const attributeChanges = Object.entries(data.eventData.attributes ?? {}).map(([key, value]) => ({
+				key,
+				value
+			}));
+			validateAttributeChanges(attributeChanges, { allowReservedAttributes: data.eventData.allowReservedAttributes });
 			const run = WorkflowRunSchema.parse(compact({
 				runId,
 				deploymentId: data.eventData.deploymentId,
 				workflowName: data.eventData.workflowName,
 				specVersion,
 				executionContext: data.eventData.executionContext,
+				attributes: data.eventData.attributes,
+				encryptionPublicKey: data.eventData.encryptionPublicKey,
 				input: data.eventData.input,
 				status: "pending",
 				output: void 0,
@@ -1462,11 +1512,25 @@ async function applyEvent(store, ctx) {
 		}
 		case "run_started": {
 			if (!currentRun) return failure("RUN_NOT_FOUND", `Workflow run "${runId}" not found`);
-			if (currentRun.status === "running") return {
-				ok: true,
-				run: currentRun,
-				releasedHooks: []
-			};
+			if (currentRun.status === "running") {
+				const result = {
+					ok: true,
+					run: currentRun,
+					releasedHooks: [],
+					maxEvents: getMaxEventsPerRun()
+				};
+				if (ctx.params?.skipPreload) return result;
+				const allEvents = await listByPrefix(store, EVENT_KEY_PREFIX, {
+					limit: getMaxEventsPerRun(),
+					sortOrder: "asc"
+				}, (event) => event.eventId);
+				return {
+					...result,
+					events: allEvents.data,
+					cursor: allEvents.cursor,
+					hasMore: allEvents.hasMore
+				};
+			}
 			const run = WorkflowRunSchema.parse(compact({
 				...currentRun,
 				status: "running",
@@ -1479,17 +1543,24 @@ async function applyEvent(store, ctx) {
 			const event = buildEvent({ ...data });
 			await store.put(RUN_KEY, run);
 			await putEvent(event);
-			const allEvents = await listByPrefix(store, EVENT_KEY_PREFIX, {
-				limit: 1e3,
-				sortOrder: "asc"
-			}, (e) => e.eventId);
-			return {
+			const result = {
 				ok: true,
 				event,
 				run,
 				releasedHooks: [],
 				runCreated: bootstrapped,
-				events: allEvents.data
+				maxEvents: getMaxEventsPerRun()
+			};
+			if (ctx.params?.skipPreload) return result;
+			const allEvents = await listByPrefix(store, EVENT_KEY_PREFIX, {
+				limit: getMaxEventsPerRun(),
+				sortOrder: "asc"
+			}, (e) => e.eventId);
+			return {
+				...result,
+				events: allEvents.data,
+				cursor: allEvents.cursor,
+				hasMore: allEvents.hasMore
 			};
 		}
 		case "run_completed": {
@@ -1505,11 +1576,13 @@ async function applyEvent(store, ctx) {
 			const event = buildEvent({ ...data });
 			await store.put(RUN_KEY, run);
 			await putEvent(event);
+			const releasedHooks = await releaseAllHooks(store);
+			await releaseAllWaits(store);
 			return {
 				ok: true,
 				event,
 				run,
-				releasedHooks: await releaseAllHooks(store)
+				releasedHooks
 			};
 		}
 		case "run_failed": {
@@ -1525,11 +1598,13 @@ async function applyEvent(store, ctx) {
 			const event = buildEvent({ ...data });
 			await store.put(RUN_KEY, run);
 			await putEvent(event);
+			const releasedHooks = await releaseAllHooks(store);
+			await releaseAllWaits(store);
 			return {
 				ok: true,
 				event,
 				run,
-				releasedHooks: await releaseAllHooks(store)
+				releasedHooks
 			};
 		}
 		case "run_cancelled": {
@@ -1545,11 +1620,37 @@ async function applyEvent(store, ctx) {
 			const event = buildEvent({ ...data });
 			await store.put(RUN_KEY, run);
 			await putEvent(event);
+			const releasedHooks = await releaseAllHooks(store);
+			await releaseAllWaits(store);
+			return {
+				ok: true,
+				event,
+				run,
+				releasedHooks
+			};
+		}
+		case "attr_set": {
+			if (!currentRun) return failure("RUN_NOT_FOUND", `Workflow run "${runId}" not found`);
+			validateAttributeChanges(data.eventData.changes, {
+				existingKeys: Object.keys(currentRun.attributes),
+				allowReservedAttributes: data.eventData.allowReservedAttributes
+			});
+			const markerKey = data.correlationId && data.eventData.writer.type === "workflow" ? `${ATTRIBUTE_EVENT_MARKER_PREFIX}${data.correlationId}` : void 0;
+			if (markerKey && await store.get(markerKey) !== void 0) return failure("ENTITY_CONFLICT", `Attribute event "${data.correlationId}" already exists`);
+			const run = WorkflowRunSchema.parse(compact({
+				...currentRun,
+				attributes: applyAttributeChanges(currentRun.attributes, data.eventData.changes),
+				updatedAt: now
+			}));
+			const event = buildEvent({ ...data });
+			await store.put(RUN_KEY, run);
+			if (markerKey) await store.put(markerKey, event.eventId);
+			await putEvent(event);
 			return {
 				ok: true,
 				event,
 				run,
-				releasedHooks: await releaseAllHooks(store)
+				releasedHooks: []
 			};
 		}
 		case "step_created": {
@@ -1583,7 +1684,34 @@ async function applyEvent(store, ctx) {
 			};
 		}
 		case "step_started": {
-			const step = validatedStep;
+			let step = validatedStep;
+			let stepCreated = false;
+			if (!step && data.eventData?.input !== void 0 && data.eventData.stepName) {
+				step = StepSchema.parse(compact({
+					runId,
+					stepId: data.correlationId,
+					stepName: data.eventData.stepName,
+					status: "pending",
+					input: data.eventData.input,
+					attempt: 0,
+					createdAt: now,
+					updatedAt: now,
+					specVersion
+				}));
+				const createdEvent = buildEvent({
+					eventType: "step_created",
+					correlationId: data.correlationId,
+					eventData: {
+						stepName: data.eventData.stepName,
+						workflowName: data.eventData.workflowName,
+						input: data.eventData.input
+					}
+				});
+				await store.put(`${STEP_KEY_PREFIX}${data.correlationId}`, step);
+				await store.put(creationIndexKey(STEP_CREATED_KEY_PREFIX, step.createdAt, step.stepId), step.stepId);
+				await putEvent(createdEvent);
+				stepCreated = true;
+			}
 			if (!step) return failure("STEP_NOT_FOUND", `Step "${data.correlationId}" not found`);
 			if (step.retryAfter && step.retryAfter.getTime() > now.getTime()) return failure("TOO_EARLY", `Cannot start step "${data.correlationId}": retryAfter timestamp has not been reached yet`, { retryAfterSeconds: Math.ceil((step.retryAfter.getTime() - now.getTime()) / 1e3) });
 			const updated = StepSchema.parse(compact({
@@ -1601,7 +1729,8 @@ async function applyEvent(store, ctx) {
 				ok: true,
 				event,
 				step: updated,
-				releasedHooks: []
+				releasedHooks: [],
+				...stepCreated ? { stepCreated: true } : {}
 			};
 		}
 		case "step_completed": {
@@ -1630,7 +1759,7 @@ async function applyEvent(store, ctx) {
 			const updated = StepSchema.parse(compact({
 				...step,
 				status: "failed",
-				error: toStructuredError(data.eventData.error, { stack: data.eventData.stack }),
+				error: toStructuredError(data.eventData.error),
 				completedAt: now,
 				updatedAt: now
 			}));
@@ -1650,7 +1779,7 @@ async function applyEvent(store, ctx) {
 			const updated = StepSchema.parse(compact({
 				...step,
 				status: "pending",
-				error: toStructuredError(data.eventData.error, { stack: data.eventData.stack }),
+				error: toStructuredError(data.eventData.error),
 				retryAfter: data.eventData.retryAfter ? new Date(data.eventData.retryAfter) : void 0,
 				updatedAt: now
 			}));
@@ -1706,7 +1835,9 @@ async function applyEvent(store, ctx) {
 				environment: "",
 				createdAt: now,
 				specVersion,
-				isWebhook: data.eventData.isWebhook ?? false
+				isWebhook: data.eventData.isWebhook ?? false,
+				isSystem: data.eventData.isSystem,
+				tokenRetentionUntil: data.eventData.tokenRetentionUntil
 			}));
 			const event = buildEvent({ ...data });
 			await store.put(hookKey, hook);
@@ -1738,9 +1869,58 @@ async function applyEvent(store, ctx) {
 				}]
 			};
 		}
+		case "wait_created": {
+			const waitKey = `${WAIT_KEY_PREFIX}${data.correlationId}`;
+			if (await store.get(waitKey) !== void 0) return failure("ENTITY_CONFLICT", `Wait "${data.correlationId}" already exists`);
+			const wait = WaitSchema.parse({
+				waitId: `${runId}-${data.correlationId}`,
+				runId,
+				status: "waiting",
+				resumeAt: data.eventData.resumeAt,
+				createdAt: now,
+				updatedAt: now,
+				specVersion
+			});
+			const event = buildEvent({ ...data });
+			await store.put(waitKey, wait);
+			await putEvent(event);
+			return {
+				ok: true,
+				event,
+				wait,
+				releasedHooks: []
+			};
+		}
+		case "wait_completed": {
+			const waitKey = `${WAIT_KEY_PREFIX}${data.correlationId}`;
+			const existing = await store.get(waitKey);
+			if (!existing) return failure("WAIT_NOT_FOUND", `Wait "${data.correlationId}" not found`);
+			if (existing.status === "completed") return failure("ENTITY_CONFLICT", `Wait "${data.correlationId}" already completed`);
+			const event = buildEvent({ ...data });
+			const wait = WaitSchema.parse({
+				...existing,
+				status: "completed",
+				resumeAt: data.eventData?.resumeAt ?? existing.resumeAt,
+				completedAt: now,
+				updatedAt: now
+			});
+			await store.put(waitKey, wait);
+			await putEvent(event);
+			return {
+				ok: true,
+				event,
+				wait,
+				releasedHooks: []
+			};
+		}
 		default: {
 			const event = buildEvent({ ...data });
 			await putEvent(event);
+			if (data.eventType === "hook_received" && ctx.params?.resumeId) await store.put(`${HOOK_RESUME_CLAIM_PREFIX}${ctx.params.resumeId}`, {
+				hookId: data.correlationId,
+				eventId: event.eventId,
+				...ctx.params.resumePayloadDigest ? { payloadDigest: ctx.params.resumePayloadDigest } : {}
+			});
 			return {
 				ok: true,
 				event,
@@ -1749,71 +1929,54 @@ async function applyEvent(store, ctx) {
 		}
 	}
 }
+/**
+* Complete Workflow 5's event-page response after an atomic apply. A celld
+* run is a single serialized writer, so the committed sequence is dense; a
+* stale eventCount therefore needs only the slots between the requested
+* position and the event this call committed.
+*/
+async function finalizeEventPage(store, outcome, params) {
+	if (!outcome.ok) return outcome;
+	const result = outcome.run && outcome.maxEvents === void 0 ? {
+		...outcome,
+		maxEvents: getMaxEventsPerRun()
+	} : outcome;
+	if (!result.event) return result;
+	if (typeof params?.sinceCursor === "string") {
+		const page = await listByPrefix(store, EVENT_KEY_PREFIX, {
+			limit: 100,
+			cursor: params.sinceCursor,
+			sortOrder: "asc"
+		}, (event) => event.eventId);
+		return {
+			...result,
+			events: page.data,
+			cursor: page.cursor,
+			hasMore: page.hasMore
+		};
+	}
+	if (params?.eventCount === void 0) return result;
+	const committedSlot = eventIdToSlot(result.event.eventId);
+	if (committedSlot === null || committedSlot <= params.eventCount + 1) return result;
+	const skippedCount = committedSlot - params.eventCount - 1;
+	const events = (await listByPrefix(store, EVENT_KEY_PREFIX, {
+		limit: skippedCount,
+		cursor: params.eventCount > 0 ? slotToEventId(params.eventCount) : void 0,
+		sortOrder: "asc"
+	}, (event) => event.eventId)).data.filter((event) => event.eventId < result.event.eventId);
+	return {
+		...result,
+		events,
+		cursor: null,
+		hasMore: events.length < skippedCount
+	};
+}
 //#endregion
 //#region src/worker/durable-objects/WorkflowRunDO.ts
 const PAYLOAD_DELETE_BATCH = 256;
 const STREAM_DELETE_CONCURRENCY = 16;
 const CLEANUP_RETRY_MAX_MS = 36e5;
 /**
-* Current schema version for DO storage.
-* Increment when making breaking changes to the storage layout.
-* Migrations run lazily on first request after deploy.
-*
-* v2: one storage key per event ('event:<eventId>'), step ('step:<stepId>')
-* and hook ('hook:<hookId>') instead of single aggregate values. This package
-* is pre-production, so the migration simply drops the legacy aggregates.
-*/
-const CURRENT_SCHEMA_VERSION = 3;
-/**
-* Idempotent migration functions keyed by target version. The schema version
-* is written only after the migration completes, so eviction safely retries
-* an interrupted migration.
-*/
-const MIGRATIONS = {
-	2: async (storage) => {
-		await storage.transaction(async (txn) => {
-			await txn.delete("events");
-			await txn.delete("steps");
-			await txn.delete("hooks");
-		});
-	},
-	3: async (storage) => {
-		await backfillCreationIndex(storage, STEP_KEY_PREFIX, STEP_CREATED_KEY_PREFIX, (step) => step.stepId);
-		await backfillCreationIndex(storage, HOOK_KEY_PREFIX, HOOK_CREATED_KEY_PREFIX, (hook) => hook.hookId);
-	}
-};
-async function backfillCreationIndex(storage, entityPrefix, indexPrefix, getId) {
-	let startAfter;
-	while (true) {
-		const entities = await storage.list({
-			prefix: entityPrefix,
-			startAfter,
-			limit: 100
-		});
-		if (entities.size === 0) return;
-		for (const [key, entity] of entities) {
-			const id = getId(entity);
-			await storage.put(`${indexPrefix}${entity.createdAt.toISOString()}:${id}`, id);
-			startAfter = key;
-		}
-		if (entities.size < 100) return;
-	}
-}
-/**
-* Ensure the DO storage schema is up to date.
-* Runs any pending migrations sequentially inside transactions,
-* persisting the version after each successful migration.
-* Safe to call on every request -- it's a no-op when already current.
-*/
-async function ensureSchemaUpToDate(storage) {
-	const stored = await storage.get("schema_version") ?? 1;
-	for (let v = stored + 1; v <= CURRENT_SCHEMA_VERSION; v++) {
-		const migration = MIGRATIONS[v];
-		if (migration) await migration(storage);
-		await storage.put("schema_version", v);
-	}
-}
-/**
 * Adapt DO storage (or a transaction) to the {@link EventStore} interface
 * shared with the test mocks. No casts: the methods line up structurally,
 * this just pins the subset we rely on.
@@ -1837,15 +2000,10 @@ function storeFrom(storage) {
 * queue-message dedup claims (see claimInflight/releaseInflight).
 */
 var WorkflowRunDO = class extends DurableObject {
-	schemaReady = null;
 	now() {
 		const clock = this.env?.clock;
 		return typeof clock === "function" ? clock() : Date.now();
 	}
-	ensureSchema() {
-		if (!this.schemaReady) this.schemaReady = ensureSchemaUpToDate(this.ctx.storage);
-		return this.schemaReady;
-	}
 	async expiredTombstone(storage, now = this.now()) {
 		const tombstone = await storage.get(TOMBSTONE_KEY);
 		if (tombstone) return tombstone;
@@ -1854,7 +2012,6 @@ var WorkflowRunDO = class extends DurableObject {
 		return cleanupTombstone(cleanup, cleanup.tombstonedAt ?? cleanup.dueAt);
 	}
 	async read(reader) {
-		await this.ensureSchema();
 		const tombstone = await this.expiredTombstone(this.ctx.storage);
 		if (tombstone) return expiredRead(tombstone);
 		return {
@@ -1864,7 +2021,6 @@ var WorkflowRunDO = class extends DurableObject {
 	}
 	/** Apply an event and capture all retention metadata in the same transaction. */
 	async applyEvent(request) {
-		await this.ensureSchema();
 		return await this.ctx.storage.transaction(async (txn) => {
 			const now = new Date(this.now());
 			const tombstone = await this.expiredTombstone(txn, now.getTime());
@@ -1876,7 +2032,7 @@ var WorkflowRunDO = class extends DurableObject {
 			let eventSequence = await txn.get("event_sequence") ?? 0;
 			const outcome = await applyEvent(storeFrom(txn), {
 				...request,
-				nextEventId: () => `wevt_z${String(++eventSequence).padStart(20, "0")}`,
+				nextEventId: () => slotToEventId(++eventSequence),
 				now
 			});
 			if (!outcome.ok) return outcome;
@@ -1921,7 +2077,7 @@ var WorkflowRunDO = class extends DurableObject {
 				await txn.setAlarm(dueAt);
 				outcome.run = run;
 			}
-			return outcome;
+			return finalizeEventPage(storeFrom(txn), outcome, request.params);
 		});
 	}
 	async getRun() {
@@ -1955,12 +2111,10 @@ var WorkflowRunDO = class extends DurableObject {
 		}));
 	}
 	async getCleanupStatus() {
-		await this.ensureSchema();
 		return await this.ctx.storage.get("retention:cleanup") ?? null;
 	}
 	/** Explicitly schedule an existing terminal run, used for opt-in backfills. */
 	async scheduleCleanup(request) {
-		await this.ensureSchema();
 		if (request.retentionMs <= 0) return this.getCleanupStatus();
 		return await this.ctx.storage.transaction(async (txn) => {
 			const existing = await txn.get(CLEANUP_RECORD_KEY);
@@ -1996,7 +2150,6 @@ var WorkflowRunDO = class extends DurableObject {
 		});
 	}
 	async cleanupNow(request) {
-		await this.ensureSchema();
 		if (!await this.ctx.storage.get("retention:cleanup")) await this.scheduleCleanup({
 			...request,
 			retentionMs: Math.max(1, request.retentionMs)
@@ -2024,7 +2177,6 @@ var WorkflowRunDO = class extends DurableObject {
 		return this.getCleanupStatus();
 	}
 	async rearmCleanup() {
-		await this.ensureSchema();
 		const cleanup = await this.ctx.storage.get(CLEANUP_RECORD_KEY);
 		if (!cleanup) return null;
 		if (cleanup.phase === "tombstoned") await this.ctx.storage.deleteAlarm();
@@ -2032,7 +2184,6 @@ var WorkflowRunDO = class extends DurableObject {
 		return cleanup;
 	}
 	async alarm() {
-		await this.ensureSchema();
 		try {
 			await this.executeCleanup();
 		} catch (error) {
@@ -2135,7 +2286,7 @@ var WorkflowRunDO = class extends DurableObject {
 			const cleanup = await txn.get(CLEANUP_RECORD_KEY);
 			if (!cleanup || cleanup.phase !== "payload") return true;
 			const entries = await txn.list({ limit: 259 });
-			const keys = Array.from(entries.keys()).filter((key) => key !== "retention:cleanup" && key !== "retention:tombstone" && key !== "schema_version").slice(0, PAYLOAD_DELETE_BATCH);
+			const keys = Array.from(entries.keys()).filter((key) => key !== "retention:cleanup" && key !== "retention:tombstone").slice(0, PAYLOAD_DELETE_BATCH);
 			const now = new Date(this.now());
 			await txn.put(TOMBSTONE_KEY, cleanupTombstone(cleanup, now));
 			for (const key of keys) await txn.delete(key);
@@ -2175,7 +2326,6 @@ var WorkflowRunDO = class extends DurableObject {
 		});
 	}
 	async claimInflight(params) {
-		await this.ensureSchema();
 		return await this.ctx.storage.transaction(async (txn) => {
 			const existing = await txn.get("claim");
 			const now = this.now();
@@ -2188,7 +2338,6 @@ var WorkflowRunDO = class extends DurableObject {
 		});
 	}
 	async releaseInflight() {
-		await this.ensureSchema();
 		await this.ctx.storage.delete("claim");
 	}
 };