experimental-a2 0.7.0 → 0.8.0

package/dist/{server-286j79Mt.js → server-B2XNevQA.js}

@@ -1123,21 +1123,45 @@ function createServer(options) {
 			throw asStoreUnavailable(err);
 		}
 	};
-	const readCachedState = async (store, sessionId, reducerName) => {
+	const readCachedState = async (store, sessionId, reducerName, throughIndex, snapshotThroughIndex) => {
 		try {
-			return await store.readState(nsId(sessionId), reducerName);
+			return await store.readState(nsId(sessionId), reducerName, throughIndex === void 0 && snapshotThroughIndex === void 0 ? void 0 : {
+				...throughIndex === void 0 ? {} : { throughIndex },
+				...snapshotThroughIndex === void 0 ? {} : { snapshotThroughIndex }
+			});
 		} catch {
 			try {
 				return {
+					headIndex: null,
 					snapshot: null,
-					events: await store.read(nsId(sessionId))
+					events: await store.read(nsId(sessionId), throughIndex === void 0 ? void 0 : { throughIndex })
 				};
 			} catch (err) {
 				throw asStoreUnavailable(err);
 			}
 		}
 	};
-	const foldStateRead = async (store, sessionId, reducer, stateRead, span) => {
+	const planStateReads = (batch) => {
+		const bySession = /* @__PURE__ */ new Map();
+		for (const entry of batch) {
+			const entries = bySession.get(entry.sessionId);
+			if (entries) entries.push(entry);
+			else bySession.set(entry.sessionId, [entry]);
+		}
+		const plans = [];
+		for (const [sessionId, entries] of bySession) {
+			const boundaries = entries.flatMap((entry) => entry.throughIndex === void 0 ? [] : [entry.throughIndex]);
+			const plan = {
+				sessionId,
+				entries
+			};
+			if (boundaries.length === entries.length) plan.throughIndex = Math.max(...boundaries);
+			if (boundaries.length > 0) plan.snapshotThroughIndex = Math.min(...boundaries);
+			plans.push(plan);
+		}
+		return plans;
+	};
+	const foldStatePlan = async (store, reducer, plan, stateRead) => {
 		let state = cloneInitial(reducer.initialState);
 		let index = 0;
 		let snapshotOutcome = "miss";
@@ -1158,84 +1182,120 @@ function createServer(options) {
 				snapshotOutcome = "hit";
 			}
 		}
-		span.setAttribute("a2.state.snapshot", snapshotOutcome);
 		if (snapshotOutcome === "rejected") try {
-			rows = await store.read(nsId(sessionId));
+			rows = await store.read(nsId(plan.sessionId), plan.throughIndex === void 0 ? void 0 : { throughIndex: plan.throughIndex });
 		} catch (err) {
 			throw asStoreUnavailable(err);
 		}
-		for (const row of rows) {
-			state = reducer.fold(state, toPublic(row));
-			index = row.index;
+		const ordered = plan.entries.toSorted((a, b) => (a.throughIndex ?? Number.POSITIVE_INFINITY) - (b.throughIndex ?? Number.POSITIVE_INFINITY));
+		const writes = /* @__PURE__ */ new Map();
+		let rowPosition = 0;
+		for (const entry of ordered) {
+			const target = entry.throughIndex ?? Number.POSITIVE_INFINITY;
+			while (rowPosition < rows.length && rows[rowPosition].index <= target) {
+				const row = rows[rowPosition];
+				state = reducer.fold(state, toPublic(row));
+				index = row.index;
+				rowPosition += 1;
+			}
+			const resultState = cloneInitial(state);
+			const folded = rowPosition;
+			entry.span.setAttribute("a2.state.snapshot", snapshotOutcome);
+			entry.span.setAttribute("a2.state.folded", folded);
+			entry.span.setAttribute("a2.state.index", index);
+			if (index > 0 && (folded > 0 || entry.pinEventIndex !== void 0)) {
+				const advancesHead = stateRead.headIndex === null || index > stateRead.headIndex;
+				const repairsHead = snapshotOutcome === "rejected" && index === stateRead.headIndex;
+				if (!advancesHead && !repairsHead && entry.pinEventIndex === void 0) {
+					entry.resolve({
+						state: resultState,
+						index
+					});
+					continue;
+				}
+				let write = writes.get(index);
+				if (!write) {
+					write = {
+						state: cloneInitial(resultState),
+						pinEventIndexes: /* @__PURE__ */ new Set()
+					};
+					writes.set(index, write);
+				}
+				if (entry.pinEventIndex !== void 0) write.pinEventIndexes.add(entry.pinEventIndex);
+			}
+			entry.resolve({
+				state: resultState,
+				index
+			});
+		}
+		if (writes.size > 0) {
+			const snapshots = [];
+			for (const [snapshotIndex, write] of writes) {
+				const snapshot = {
+					index: snapshotIndex,
+					state: write.state
+				};
+				if (write.pinEventIndexes.size > 0) snapshot.pinEventIndexes = [...write.pinEventIndexes];
+				snapshots.push(snapshot);
+			}
+			const persistence = Promise.resolve().then(() => store.putSnapshots(nsId(plan.sessionId), reducer.name, snapshots)).catch(() => {});
+			track(persistence);
+			platformWaitUntil(persistence);
 		}
-		span.setAttribute("a2.state.folded", rows.length);
-		span.setAttribute("a2.state.index", index);
-		return {
-			state,
-			index,
-			folded: rows.length
-		};
 	};
 	const pendingStateReads = /* @__PURE__ */ new Map();
-	const flushStateReads = async (store, reducerName, batch) => {
+	const flushStateReads = async (store, reducer, batch) => {
+		const plans = planStateReads(batch);
 		let reads;
 		try {
-			reads = store.readStates ? await store.readStates(batch.map((entry) => nsId(entry.sessionId)), reducerName) : null;
+			reads = store.readStates ? await store.readStates(plans.map((plan) => ({
+				sessionId: nsId(plan.sessionId),
+				...plan.throughIndex === void 0 ? {} : { throughIndex: plan.throughIndex },
+				...plan.snapshotThroughIndex === void 0 ? {} : { snapshotThroughIndex: plan.snapshotThroughIndex }
+			})), reducer.name) : await Promise.all(plans.map((plan) => readCachedState(store, plan.sessionId, reducer.name, plan.throughIndex, plan.snapshotThroughIndex)));
 		} catch {
 			reads = null;
 		}
-		if (!reads || reads.length !== batch.length) {
-			for (const entry of batch) entry.resolve(readCachedState(store, entry.sessionId, reducerName));
+		if (!reads || reads.length !== plans.length) try {
+			reads = await Promise.all(plans.map((plan) => readCachedState(store, plan.sessionId, reducer.name, plan.throughIndex, plan.snapshotThroughIndex)));
+		} catch (err) {
+			for (const entry of batch) entry.reject(err);
 			return;
 		}
-		const seen = /* @__PURE__ */ new Set();
-		for (const [position, entry] of batch.entries()) {
-			const shared = seen.has(entry.sessionId);
-			seen.add(entry.sessionId);
-			try {
-				const read = reads[position];
-				entry.resolve(shared ? structuredClone(read) : read);
-			} catch {
-				entry.resolve(readCachedState(store, entry.sessionId, reducerName));
-			}
+		for (const [position, plan] of plans.entries()) try {
+			await foldStatePlan(store, reducer, plan, reads[position]);
+		} catch (err) {
+			for (const entry of plan.entries) entry.reject(err);
 		}
 	};
-	const enqueueStateRead = (store, sessionId, reducerName) => new Promise((resolve) => {
+	const enqueueStateRead = (store, sessionId, reducer, throughIndex, pinEventIndex, span) => new Promise((resolve, reject) => {
+		const reducerName = reducer.name;
 		let batch = pendingStateReads.get(reducerName);
 		if (!batch) {
 			const opened = [];
 			pendingStateReads.set(reducerName, opened);
 			queueMicrotask(() => {
 				pendingStateReads.delete(reducerName);
-				flushStateReads(store, reducerName, opened);
+				flushStateReads(store, reducer, opened);
 			});
 			batch = opened;
 		}
 		batch.push({
 			sessionId,
-			resolve
+			...throughIndex === void 0 ? {} : { throughIndex },
+			...pinEventIndex === void 0 ? {} : { pinEventIndex },
+			span,
+			resolve,
+			reject
 		});
 	});
-	const readState = async (sessionId, reducer) => {
+	const readState = async (sessionId, reducer, throughIndex, pinEventIndex) => {
 		const store = await resolveStore();
 		return telemetry.span("a2.state", {
 			"a2.contract": name,
 			"a2.session_id": sessionId,
 			"a2.state.reducer": reducer.name
-		}, async (span) => {
-			const stateRead = store.readStates ? await enqueueStateRead(store, sessionId, reducer.name) : await readCachedState(store, sessionId, reducer.name);
-			const { state, index, folded } = await foldStateRead(store, sessionId, reducer, stateRead, span);
-			if (folded > 0) {
-				const snapshotState = cloneInitial(state);
-				const write = Promise.resolve().then(() => store.putSnapshot(nsId(sessionId), reducer.name, index, snapshotState)).catch(() => {});
-				track(write);
-				platformWaitUntil(write);
-			}
-			return {
-				state,
-				index
-			};
-		});
+		}, (span) => enqueueStateRead(store, sessionId, reducer, throughIndex, pinEventIndex, span));
 	};
 	const makeSchedule = (sessionId, trigger) => {
 		const triggerEventId = trigger?.id ?? null;
@@ -1246,11 +1306,14 @@ function createServer(options) {
 			if (events.length === 0) throw new TypeError("schedule requires at least one event");
 			const dueAt = scheduleDueAt(timing, triggerCreatedAt ?? Date.now());
 			const payloads = events.map((event) => cloneScheduledPayload(event.payload));
-			const snapshottedEvents = events.map((event, index) => ({
+			const snapshottedEvents = events.map((event, index) => event.id === void 0 ? {
+				type: event.type,
+				payload: payloads[index]
+			} : {
 				type: event.type,
 				payload: payloads[index],
-				...event.id === void 0 ? {} : { id: event.id }
-			}));
+				id: event.id
+			});
 			const validated = validateEvents(sessionId, structuredClone(snapshottedEvents), false);
 			const scheduleId = await deterministicScheduleId(name, sessionId, triggerEventId, scheduleName);
 			const scheduledEvents = await Promise.all(validated.map(async (event, item) => ({
@@ -1512,7 +1575,11 @@ function createServer(options) {
 		append,
 		schedule: makeSchedule(id, trigger),
 		history: async (bounds) => (await readHistory(id, bounds)).map(toPublic),
-		state: (reducer) => readState(id, reducer),
+		state: (reducer, stateOptions) => {
+			const through = stateOptions?.through ?? trigger?.index;
+			if (through !== void 0 && through !== "latest") assertStateIndex(through);
+			return readState(id, reducer, through === "latest" ? void 0 : through, trigger && through !== "latest" ? trigger.index : void 0);
+		},
 		stream: (opts) => {
 			const startAfter = opts?.startAfter ?? 0;
 			assertStreamIndex(startAfter);
@@ -1998,6 +2065,9 @@ function assertHistoryIndex(name, value) {
 function assertStreamIndex(value) {
 	if (!Number.isSafeInteger(value) || value < 0) throw new TypeError("stream.startAfter must be a non-negative safe integer");
 }
+function assertStateIndex(value) {
+	if (!Number.isSafeInteger(value) || value < 0) throw new TypeError("state.through must be a non-negative safe integer");
+}
 function assertAppendName(name) {
 	if (typeof name !== "string" || name.length === 0) throw new TypeError("handler append name must be a non-empty string");
 }
@@ -2089,4 +2159,4 @@ function cloneInitial(initial) {
 //#endregion
 export { platformVercelOidcToken as i, deliverSchedulerAppend as n, setServerFetchHooks as r, createServer as t };
 
-//# sourceMappingURL=server-286j79Mt.js.map
+//# sourceMappingURL=server-B2XNevQA.js.map