@vercel/factory 0.0.17 → 0.0.18

package/dist/store/engine.mjs

@@ -5,12 +5,12 @@ import { budgetSchema } from "../schema/budget.mjs";
 import { parseAgentRouteBinding } from "../schema/agent-route.mjs";
 import { jsonValueSchema, taskWorkSchema } from "../schema/work.mjs";
 import { taskKindSchema, taskOriginSchema, taskQuestionSchema, taskSchema } from "../schema/task.mjs";
+import { RecordExistsError, RecordNotFoundError, TransientStoreError, VersionConflictError } from "./driver.mjs";
 import { InvalidTransitionError, assertTransition, changeInitialState, changeTransitions, legalNextStates, signalOutcomeTransitions, signalTriageTransitions, taskInitialState, taskTransitions } from "../schema/transitions.mjs";
 import { costSchema, receiptSchema } from "../schema/receipt.mjs";
 import { imageAttachmentSchema, imageAttachmentsSchema, imageIdSchema, imageUploadSchema } from "../image-input.mjs";
 import { transcriptSnapshotSchema } from "../schema/transcript.mjs";
 import { routeTaskWork } from "../agent-routes.mjs";
-import { RecordExistsError, RecordNotFoundError, TransientStoreError, VersionConflictError } from "./driver.mjs";
 import { answerEventSchema } from "../schema/answer.mjs";
 import { taskGraphDependenciesSchema } from "../schema/task-graph.mjs";
 import { defineTaskMessageProtocols } from "../schema/task-message.mjs";
@@ -18,17 +18,22 @@ import { createTaskGraphStore } from "./task-graphs.mjs";
 import { createTaskMessageStore } from "./task-messages.mjs";
 import { createTaskWorkStore } from "./task-work.mjs";
 import { createTaskEffectStore } from "./task-effects.mjs";
+import { pageRecords, recordQuerySchema } from "./query.mjs";
+import { changeSchema } from "../schema/change.mjs";
+import { agentSessionIdSchema, agentSessionSchema } from "../schema/session.mjs";
+import { signalSchema } from "../schema/signal.mjs";
+import { communicationEventSchema } from "../schema/communication.mjs";
+import { sessionContinuationRecordSchema, sessionNotificationRecordSchema } from "./session-history.mjs";
+import { factoryIndexKey } from "./indexed-projections.mjs";
+import { recordQueryScope } from "./query-scope.mjs";
 import { defaultTaskWorkflow, defineWorkflows } from "../workflows.mjs";
 import { createWorkNotifier } from "./work-notifications.mjs";
-import { communicationEventSchema } from "../schema/communication.mjs";
-import { agentSessionIdSchema, agentSessionSchema } from "../schema/session.mjs";
 import { externalSessionSchema, storedSessionSchema } from "../schema/stored-session.mjs";
-import { changeSchema } from "../schema/change.mjs";
 import { outboxMessageSchema, outboxQueueSchema } from "../schema/outbox.mjs";
 import { storedTaskSchema } from "../schema/stored-task.mjs";
 import { changeCatalogSchema, externalSessionCatalogSchema, sessionCatalogSchema, taskCatalogSchema, taskRouteSchema } from "../schema/catalog.mjs";
+import { pageTranscriptSnapshot } from "./transcripts.mjs";
 import { questionRouteSchema } from "../schema/question-route.mjs";
-import { signalSchema } from "../schema/signal.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import { z } from "zod";
 import { isDeepStrictEqual } from "node:util";
@@ -177,9 +182,10 @@ const taskReceiptStates = {
 	needs_human: "needs_human",
 	cancelled: "cancelled"
 };
-function needsLifecycleCommunication(task, state, phase) {
+function needsLifecycleCommunication(task, state, phase, parent, includeChild) {
 	if (state === "needs_human") return task.question !== void 0;
-	if (task.parentTaskId !== void 0) return false;
+	const isConversationDelegation = task.parentTaskId !== void 0 && parent?.work.route?.id === "conversation";
+	if (task.parentTaskId !== void 0 && !isConversationDelegation && !includeChild?.(task, state)) return false;
 	if (state === "dispatched") return phase === "retry";
 	if (state === "failed" || state === "cancelled") return true;
 	if (state !== "succeeded") return false;
@@ -274,6 +280,9 @@ async function nextTransientRetry(error, attempt, startedAt) {
 * ```
 */
 function createStores(options) {
+	return createStoreEngine(options);
+}
+function createStoreEngine(options, indexed) {
 	const { driver } = options;
 	const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
 	const workflows = options.workflows ?? defineWorkflows([defaultTaskWorkflow]);
@@ -301,8 +310,41 @@ function createStores(options) {
 		if (record === null) throw new RecordNotFoundError(collection, id);
 		return record;
 	}
+	async function listPage(collections, schema, input, catalog) {
+		const query = recordQuerySchema.parse(input);
+		if (indexed) {
+			const page = await indexed.queryRecords({
+				sources: collections.map((collection) => ({
+					collection,
+					index: factoryIndexKey(recordQueryScope(collection, query))
+				})),
+				...query
+			});
+			return {
+				items: page.entries.map((entry) => {
+					if (entry.collection === "sessions") storedSessionSchema.parse(entry.record.value);
+					if (entry.collection === "externalSessions") externalSessionSchema.parse(entry.record.value);
+					return schema.parse(entry.record.value);
+				}),
+				nextCursor: page.nextCursor
+			};
+		}
+		const values = catalog ? await catalog() : (await Promise.all(collections.map((collection) => listAll(collection, schema)))).flat();
+		return pageRecords(collections.join(":"), values, query, (value) => {
+			const key = z.object({
+				id: z.string().optional(),
+				receiptId: z.string().optional()
+			}).parse(value);
+			return z.string().min(1).parse(key.id ?? key.receiptId);
+		});
+	}
 	async function listAll(collection, schema) {
-		return (await driver.list(collection)).map((entry) => schema.parse(entry.record.value));
+		if (indexed) throw new Error("Indexed stores require bounded queries instead of collection lists");
+		return (await driver.list(collection)).map((entry) => {
+			if (collection === "sessions") storedSessionSchema.parse(entry.record.value);
+			if (collection === "externalSessions") externalSessionSchema.parse(entry.record.value);
+			return schema.parse(entry.record.value);
+		});
 	}
 	async function forEachConcurrent(values, limit, operation) {
 		let next = 0;
@@ -313,12 +355,10 @@ function createStores(options) {
 	const catalogShards = "0123456789abcdef".split("");
 	const shardFor = (id) => createHash("sha256").update(id).digest("hex")[0];
 	function sessionSummary(session) {
-		return agentSessionSchema.parse({
-			...session,
-			continuations: session.continuations?.map(({ context: _context, ...continuation }) => continuation)
-		});
+		return agentSessionSchema.parse(session);
 	}
 	async function projectCatalogEntry(collection, prefix, schema, value, sourceVersion) {
+		if (indexed) return;
 		const id = `${prefix}-${shardFor(value.id)}`;
 		for (;;) {
 			const existing = await driver.get(collection, id);
@@ -360,6 +400,7 @@ function createStores(options) {
 	const projectSessionCatalog = (value, sourceVersion) => projectCatalogEntry("sessionCatalogs", "sessions", sessionCatalogSchema, sessionSummary(value), sourceVersion);
 	const projectExternalSessionCatalog = (value, sourceVersion) => projectCatalogEntry("externalSessionCatalogs", "external-sessions", externalSessionCatalogSchema, sessionSummary(value), sourceVersion);
 	async function markCatalogRepair(collection, prefix, schema, sourceId, sourceVersion) {
+		if (indexed) return;
 		const id = `${prefix}-${shardFor(sourceId)}`;
 		for (;;) {
 			const existing = await driver.get(collection, id);
@@ -400,6 +441,7 @@ function createStores(options) {
 	const markSessionCatalogRepair = (id, sourceVersion) => markCatalogRepair("sessionCatalogs", "sessions", sessionCatalogSchema, id, sourceVersion);
 	const markExternalSessionCatalogRepair = (id, sourceVersion) => markCatalogRepair("externalSessionCatalogs", "external-sessions", externalSessionCatalogSchema, id, sourceVersion);
 	async function projectTaskRoute(value, sourceVersion) {
+		if (indexed) return;
 		if (value.replyTo.channel !== "api") return;
 		const id = derivedId("task-route", JSON.stringify([value.replyTo.channel, value.replyTo.address]));
 		for (;;) {
@@ -438,6 +480,7 @@ function createStores(options) {
 		}
 	}
 	async function markTaskRouteRepair(value, sourceVersion) {
+		if (indexed) return;
 		if (value.replyTo.channel !== "api") return;
 		const id = derivedId("task-route", JSON.stringify([value.replyTo.channel, value.replyTo.address]));
 		for (;;) {
@@ -488,6 +531,7 @@ function createStores(options) {
 		}
 	}
 	async function catalogValues(source, collection, prefix, sourceSchema, catalogSchema, project, fallbackValue = (value) => value) {
+		if (indexed) throw new Error("Indexed stores require bounded queries instead of catalogs");
 		let catalogs = await Promise.all(catalogShards.map((shard) => driver.get(collection, `${prefix}-${shard}`)));
 		if (catalogs.some((catalog) => catalog === null)) {
 			const entries = await driver.list(source);
@@ -650,7 +694,8 @@ function createStores(options) {
 					reason: reason ?? `rejected by ${by}`,
 					attempt: task.attempt
 				});
-				if (needsLifecycleCommunication(next, "cancelled", "approval")) next = taskSchema.parse({
+				const rejectionParent = next.parentTaskId ? await stores.tasks.get(next.parentTaskId) : null;
+				if (needsLifecycleCommunication(next, "cancelled", "approval", rejectionParent, options.includeChildTaskCommunication)) next = taskSchema.parse({
 					...next,
 					pendingCommunicationReceiptIds: [.../* @__PURE__ */ new Set([...next.pendingCommunicationReceiptIds ?? [], cancelled.receiptId])]
 				});
@@ -698,6 +743,41 @@ function createStores(options) {
 			}
 		}
 	}
+	async function commitLatestContinuation(session) {
+		if (!session.latestContinuationId) return null;
+		for (;;) {
+			const record = await mustRead("sessionContinuations", session.latestContinuationId, sessionContinuationRecordSchema);
+			if (record.value.sessionId !== session.id) throw new SessionConflictError("Continuation belongs to another session");
+			if (record.value.committed) return record.value;
+			try {
+				const next = {
+					...record.value,
+					committed: true
+				};
+				await driver.update({
+					collection: "sessionContinuations",
+					id: record.value.id,
+					value: next,
+					expectedVersion: record.version
+				});
+				return next;
+			} catch (error) {
+				if (!(error instanceof VersionConflictError)) throw error;
+			}
+		}
+	}
+	function withinSession(id, query, committed) {
+		const parsed = recordQuerySchema.parse(query);
+		const alternatives = parsed.match === void 0 ? [{}] : Array.isArray(parsed.match) ? parsed.match : [parsed.match];
+		return {
+			...parsed,
+			match: alternatives.map((match) => ({
+				...match,
+				sessionId: id,
+				...committed === void 0 ? {} : { committed }
+			}))
+		};
+	}
 	const stores = {
 		driverName: driver.name,
 		workflowRecords: {
@@ -752,6 +832,21 @@ function createStores(options) {
 			}
 		}),
 		transcripts: {
+			async head(execution) {
+				const snapshot = await stores.transcripts.get(execution);
+				return snapshot === null ? null : {
+					...snapshot,
+					blocks: [],
+					blockCount: snapshot.blocks.length
+				};
+			},
+			async page(execution, input) {
+				const snapshot = await stores.transcripts.get(execution);
+				return snapshot === null ? null : pageTranscriptSnapshot(execution, snapshot, input);
+			},
+			async block(execution, blockId) {
+				return (await stores.transcripts.get(execution))?.blocks.find((block) => block.id === blockId) ?? null;
+			},
 			async get(execution) {
 				const record = await read("transcripts", derivedId("transcript", JSON.stringify([execution.provider, execution.sessionId])), storedTranscriptSchema);
 				if (record === null) return null;
@@ -874,8 +969,8 @@ function createStores(options) {
 					const record = await mustRead("sessions", id, storedSessionSchema);
 					await projectSafely(() => projectSessionCatalog(record.value, record.version));
 					const existing = record.value;
-					const { createdAt: _at, execution: _execution, taskId: _task, notifications: _notifications, continuations: _continuations, ...intent } = existing;
-					const { createdAt: _newAt, notifications: _newNotifications, ...nextIntent } = candidate;
+					const { createdAt: _at, execution: _execution, taskId: _task, latestNotificationId: _notification, latestContinuationId: _continuation, ...intent } = existing;
+					const { createdAt: _newAt, ...nextIntent } = candidate;
 					if (!sameStoredValue(intent, nextIntent)) throw new SessionConflictError("Session operationId was reused with different input");
 					return existing;
 				}
@@ -955,24 +1050,66 @@ function createStores(options) {
 					return existing.value;
 				}
 			},
+			async getContinuation(id, taskId) {
+				const record = (await listPage(["sessionContinuations"], sessionContinuationRecordSchema, {
+					limit: 1,
+					match: {
+						sessionId: id,
+						taskId
+					}
+				})).items[0];
+				if (!record) return null;
+				if (record.committed) return record.continuation;
+				return (await stores.sessions.get(id))?.latestContinuationId === record.id ? record.continuation : null;
+			},
+			async getContinuationByOperation(id, operationId) {
+				const key = derivedId("scont", JSON.stringify([id, operationId]));
+				const record = await read("sessionContinuations", key, sessionContinuationRecordSchema);
+				if (!record) return null;
+				if (record.value.sessionId !== id) throw new SessionConflictError("Continuation belongs to another session");
+				if (record.value.committed) return record.value.continuation;
+				return (await stores.sessions.get(id))?.latestContinuationId === key ? record.value.continuation : null;
+			},
+			async listContinuations(id, query) {
+				await commitLatestContinuation((await mustRead("sessions", id, storedSessionSchema)).value);
+				const page = await listPage(["sessionContinuations"], sessionContinuationRecordSchema, withinSession(id, query, true));
+				return {
+					items: page.items.map((record) => record.continuation),
+					nextCursor: page.nextCursor
+				};
+			},
+			async listNotifications(id, query) {
+				const page = await listPage(["sessionNotifications"], sessionNotificationRecordSchema, withinSession(id, query));
+				return {
+					items: page.items.map((record) => record.event),
+					nextCursor: page.nextCursor
+				};
+			},
 			async cacheContinuationContext(id, input) {
 				const { taskId, context, attachments } = input;
+				const session = await mustRead("sessions", id, storedSessionSchema);
+				const continuation = await stores.sessions.getContinuation(id, taskId);
+				if (!continuation) throw new SessionConflictError("Task is not a conversation continuation");
+				await stores.images.validate(session.value.owner, attachments ?? []);
+				const key = derivedId("scont", JSON.stringify([id, continuation.operationId]));
 				for (;;) {
-					const record = await mustRead("sessions", id, storedSessionSchema);
-					const continuation = record.value.continuations?.find((item) => item.taskId === taskId);
-					if (!continuation) throw new SessionConflictError("Task is not a conversation continuation");
-					if (continuation.context !== void 0) return continuation.context;
-					await stores.images.validate(record.value.owner, attachments ?? []);
-					const next = storedSessionSchema.parse({
+					const record = await mustRead("sessionContinuations", key, sessionContinuationRecordSchema);
+					if (record.value.continuation.context !== void 0) return record.value.continuation.context;
+					const next = sessionContinuationRecordSchema.parse({
 						...record.value,
-						continuations: record.value.continuations?.map((item) => item.taskId === taskId ? {
-							...item,
+						continuation: {
+							...record.value.continuation,
 							context,
 							...attachments?.length ? { contextAttachments: attachments } : {}
-						} : item)
+						}
 					});
 					try {
-						await updateSession(next, record.version);
+						await driver.update({
+							collection: "sessionContinuations",
+							id: key,
+							value: next,
+							expectedVersion: record.version
+						});
 						return context;
 					} catch (error) {
 						if (!(error instanceof VersionConflictError)) throw error;
@@ -981,16 +1118,19 @@ function createStores(options) {
 			},
 			async continue(id, input) {
 				if (input.operationId.trim().length === 0 || input.operationId.length > 200) throw new SessionConflictError("operationId must contain 1–200 characters");
+				const continuationId = derivedId("scont", JSON.stringify([id, input.operationId]));
 				const dedupeKey = `session:${id}:follow-up:${input.operationId}`;
 				for (;;) {
 					const record = await mustRead("sessions", id, storedSessionSchema);
 					const session = record.value;
+					const latestRecord = await commitLatestContinuation(session);
 					await stores.images.validate(session.owner, input.attachments ?? []);
 					if (session.repositoryId === void 0 || session.taskId === void 0) throw new SessionConflictError("Follow-up work requires a repository-bound task conversation");
 					const parent = (await mustRead("tasks", input.parentTaskId, storedTaskSchema)).value;
 					if (parent.id !== session.taskId && !(parent.replyTo.channel === "api" && parent.replyTo.address === id)) throw new SessionConflictError("Follow-up parent is outside this conversation");
 					if (parent.repositoryIds.length !== 1 || parent.repositoryIds[0] !== session.repositoryId) throw new SessionConflictError("Follow-up repository differs from its conversation");
-					const previous = session.continuations?.find((item) => item.operationId === input.operationId);
+					const previousRecord = await read("sessionContinuations", continuationId, sessionContinuationRecordSchema);
+					const previous = previousRecord?.value.continuation;
 					if (previous !== void 0 && !sameStoredValue({
 						operationId: input.operationId,
 						parentTaskId: input.parentTaskId,
@@ -1014,14 +1154,14 @@ function createStores(options) {
 						createdAt: now()
 					};
 					let next = session;
-					if (previous === void 0) {
+					if (!previousRecord?.value.committed) {
 						if (![
 							"succeeded",
 							"failed",
 							"cancelled",
 							"verifying"
 						].includes(parent.state)) throw new SessionConflictError("Wait for this task or answer its pending question before starting a follow-up");
-						const latest = session.continuations?.at(-1);
+						const latest = latestRecord?.continuation;
 						if (latest !== void 0 && latest.taskId !== parent.id) {
 							let ancestor = parent;
 							const visited = /* @__PURE__ */ new Set();
@@ -1039,12 +1179,27 @@ function createStores(options) {
 						}
 						next = storedSessionSchema.parse({
 							...session,
-							continuations: [...session.continuations ?? [], continuation]
+							latestContinuationId: continuationId
 						});
+						if (previousRecord && previousRecord.value.previousId !== session.latestContinuationId) throw new SessionConflictError("Conversation changed before this follow-up was admitted; refresh and use a new operationId");
 						try {
+							if (!previousRecord) await driver.insert({
+								collection: "sessionContinuations",
+								id: continuationId,
+								value: sessionContinuationRecordSchema.parse({
+									id: continuationId,
+									sessionId: id,
+									taskId: continuation.taskId,
+									previousId: session.latestContinuationId,
+									committed: false,
+									createdAt: continuation.createdAt,
+									continuation
+								})
+							});
 							await updateSession(next, record.version);
+							await commitLatestContinuation(next);
 						} catch (error) {
-							if (error instanceof VersionConflictError) continue;
+							if (error instanceof VersionConflictError || error instanceof RecordExistsError) continue;
 							throw error;
 						}
 					}
@@ -1099,11 +1254,8 @@ function createStores(options) {
 				if (records.length > 1) throw new SessionConflictError("Session ID exists in multiple collections");
 				return records[0]?.value ?? null;
 			},
-			async list() {
-				return (await Promise.all([listAll("sessions", storedSessionSchema), listAll("externalSessions", externalSessionSchema)])).flat();
-			},
-			async summaries() {
-				return (await Promise.all([catalogValues("sessions", "sessionCatalogs", "sessions", storedSessionSchema, sessionCatalogSchema, projectSessionCatalog, sessionSummary), catalogValues("externalSessions", "externalSessionCatalogs", "external-sessions", externalSessionSchema, externalSessionCatalogSchema, projectExternalSessionCatalog, sessionSummary)])).flat();
+			list(query) {
+				return listPage(["sessions", "externalSessions"], agentSessionSchema, query);
 			},
 			async bind(id, reference) {
 				const external = await read("externalSessions", id, externalSessionSchema);
@@ -1139,16 +1291,36 @@ function createStores(options) {
 			async notify(input) {
 				const event = communicationEventSchema.parse(input);
 				if (event.replyTo.channel !== "api") throw new SessionConflictError("Expected an API notification");
-				for (;;) {
-					const record = await mustRead("sessions", event.replyTo.address, storedSessionSchema);
-					const existing = record.value.notifications.find((item) => item.eventId === event.eventId);
-					if (existing !== void 0) {
-						if (!sameStoredValue(existing, event)) throw new SessionConflictError("Notification eventId was reused");
-						return;
+				const id = agentSessionIdSchema.parse(event.replyTo.address);
+				await mustRead("sessions", id, storedSessionSchema);
+				const key = derivedId("snotice", JSON.stringify([id, event.eventId]));
+				let notification = await read("sessionNotifications", key, sessionNotificationRecordSchema);
+				if (!notification) {
+					try {
+						await driver.insert({
+							collection: "sessionNotifications",
+							id: key,
+							value: sessionNotificationRecordSchema.parse({
+								id: key,
+								sessionId: id,
+								createdAt: now(),
+								event
+							})
+						});
+					} catch (error) {
+						if (!(error instanceof RecordExistsError)) throw error;
 					}
+					notification = await mustRead("sessionNotifications", key, sessionNotificationRecordSchema);
+				}
+				if (!sameStoredValue(notification.value.event, event)) throw new SessionConflictError("Notification eventId was reused");
+				for (;;) {
+					const record = await mustRead("sessions", id, storedSessionSchema);
+					if (record.value.latestNotificationId === key) return;
+					const latest = record.value.latestNotificationId ? await mustRead("sessionNotifications", record.value.latestNotificationId, sessionNotificationRecordSchema) : null;
+					if (latest && (latest.value.createdAt > notification.value.createdAt || latest.value.createdAt === notification.value.createdAt && latest.value.id > key)) return;
 					const next = storedSessionSchema.parse({
 						...record.value,
-						notifications: [...record.value.notifications, event]
+						latestNotificationId: key
 					});
 					try {
 						await updateSession(next, record.version);
@@ -1204,8 +1376,8 @@ function createStores(options) {
 				const record = await read("repositories", id, repositorySchema);
 				return record === null ? null : record.value;
 			},
-			list() {
-				return listAll("repositories", repositorySchema);
+			list(query) {
+				return listPage(["repositories"], repositorySchema, query);
 			}
 		},
 		signals: {
@@ -1324,8 +1496,8 @@ function createStores(options) {
 				});
 				return next;
 			},
-			list() {
-				return listAll("signals", signalSchema);
+			list(query) {
+				return listPage(["signals"], signalSchema, query);
 			}
 		},
 		tasks: {
@@ -1743,7 +1915,8 @@ function createStores(options) {
 						...next,
 						failureReceiptId: receipt.receiptId
 					});
-					if (needsLifecycleCommunication(next, receiptState, transitionOptions.phase)) next = taskSchema.parse({
+					const transitionParent = next.parentTaskId ? await stores.tasks.get(next.parentTaskId) : null;
+					if (needsLifecycleCommunication(next, receiptState, transitionOptions.phase, transitionParent, options.includeChildTaskCommunication)) next = taskSchema.parse({
 						...next,
 						pendingCommunicationReceiptIds: [...next.pendingCommunicationReceiptIds ?? [], receipt.receiptId]
 					});
@@ -1828,60 +2001,10 @@ function createStores(options) {
 				}
 				return question;
 			},
-			async forReplyTo(replyTo) {
-				const id = derivedId("task-route", JSON.stringify([replyTo.channel, replyTo.address]));
-				let route = await read("taskRoutes", id, taskRouteSchema);
-				let discovered = [];
-				if (route === null) {
-					discovered = (await stores.tasks.list()).filter((task) => task.replyTo.channel === replyTo.channel && task.replyTo.address === replyTo.address);
-					for (const task of discovered) {
-						const record = await mustRead("tasks", task.id, storedTaskSchema);
-						await projectSafely(() => projectTaskRoute(record.value, record.version));
-					}
-					if (discovered.length === 0) {
-						const empty = taskRouteSchema.parse({
-							schemaVersion: 1,
-							id,
-							replyTo,
-							entries: [],
-							updatedAt: now()
-						});
-						await projectSafely(async () => {
-							try {
-								await driver.insert({
-									collection: "taskRoutes",
-									id,
-									value: empty
-								});
-							} catch (error) {
-								if (!(error instanceof RecordExistsError)) throw error;
-							}
-						});
-					}
-					route = await read("taskRoutes", id, taskRouteSchema);
-				}
-				if (route === null) return discovered;
-				const values = new Map(route.value.entries.map((entry) => [entry.value.id, entry.value]));
-				await forEachConcurrent(route.value.repairs, 16, async (repair) => {
-					const repairTaskId = taskIdSchema.parse(repair.id);
-					const record = await driver.get("tasks", repairTaskId);
-					if (record === null) {
-						values.delete(repairTaskId);
-						return;
-					}
-					const canonical = storedTaskSchema.parse(record.value);
-					if (canonical.replyTo.channel === replyTo.channel && canonical.replyTo.address === replyTo.address) values.set(canonical.id, canonical);
-					else values.delete(canonical.id);
-					await projectSafely(() => projectTaskRoute(canonical, record.version));
-				});
-				const tasks = [...values.values()];
-				for (const task of tasks) validateTaskWork(task);
-				return tasks;
-			},
-			async list() {
-				const tasks = await catalogValues("tasks", "taskCatalogs", "tasks", storedTaskSchema, taskCatalogSchema, projectTaskCatalog);
-				for (const task of tasks) validateTaskWork(task);
-				return tasks;
+			async list(query) {
+				const page = await listPage(["tasks"], storedTaskSchema, query, () => catalogValues("tasks", "taskCatalogs", "tasks", storedTaskSchema, taskCatalogSchema, projectTaskCatalog));
+				for (const task of page.items) validateTaskWork(task);
+				return page;
 			}
 		},
 		changes: {
@@ -1994,8 +2117,8 @@ function createStores(options) {
 				await updateChange(next, existing.version);
 				return next;
 			},
-			list() {
-				return catalogValues("changes", "changeCatalogs", "changes", changeSchema, changeCatalogSchema, projectChangeCatalog);
+			list(query) {
+				return listPage(["changes"], changeSchema, query, () => catalogValues("changes", "changeCatalogs", "changes", changeSchema, changeCatalogSchema, projectChangeCatalog));
 			}
 		},
 		receipts: {
@@ -2010,8 +2133,8 @@ function createStores(options) {
 				const record = await read("receipts", id, receiptSchema);
 				return record === null ? null : record.value;
 			},
-			list() {
-				return listAll("receipts", receiptSchema);
+			list(query) {
+				return listPage(["receipts"], receiptSchema, query);
 			}
 		},
 		budgets: {
@@ -2304,6 +2427,6 @@ function createStores(options) {
 	return stores;
 }
 //#endregion
-export { AnswerEventConflictError, ApprovalError, ChangeAssociationError, ImageInputError, OutboxEventConflictError, SessionConflictError, SettlementError, TaskAttemptConflictError, createStores };
+export { AnswerEventConflictError, ApprovalError, ChangeAssociationError, ImageInputError, OutboxEventConflictError, SessionConflictError, SettlementError, TaskAttemptConflictError, createStoreEngine, createStores };
 
 //# sourceMappingURL=engine.mjs.map