experimental-a2 0.0.0 → 0.2.0

package/dist/log-memory.js

@@ -1,8 +1,9 @@
 import { t as A2Error } from "./errors-BJRMd-h6.js";
+import { t as idempotentReplay } from "./idempotent-replay-BMyHrP0L.js";
 import { n as SYSTEM_CLOCK, t as RANDOM_IDS } from "./log-yJbXUf72.js";
 //#region src/log-memory.ts
 /**
-* a2/log-memory — in-memory log backend (the test default).
+* experimental-a2/log-memory — in-memory log backend (the test default).
 *
 * Implements the A2Log interface with zero dependencies. See
 * specs/a2-implementation.md §3 for the contract; the conformance suite
@@ -16,11 +17,15 @@ const toStored = (row) => ({
 	sessionId: row.sessionId,
 	createdAt: new Date(row.createdAt),
 	cause: row.cause ? { ...row.cause } : null,
+	lane: row.lane,
 	processedAt: row.processedAt ? new Date(row.processedAt) : null,
 	processedByAttempt: row.processedByAttempt,
+	returnedEventIds: row.returnedEventIds ? [...row.returnedEventIds] : null,
 	firstClaimedAt: row.firstClaimedAt ? new Date(row.firstClaimedAt) : null,
 	lastClaimedAt: row.lastClaimedAt ? new Date(row.lastClaimedAt) : null,
 	attemptCount: row.attemptCount,
+	claimHolder: row.claimHolder,
+	claimExpiresAt: row.claimExpiresAt ? new Date(row.claimExpiresAt) : null,
 	failureCount: row.failureCount,
 	lastFailedAt: row.lastFailedAt ? new Date(row.lastFailedAt) : null,
 	lastFailedAttempt: row.lastFailedAttempt,
@@ -39,11 +44,9 @@ function memory(options = {}) {
 	const clock = options.clock ?? SYSTEM_CLOCK;
 	const generateId = options.ids ?? RANDOM_IDS;
 	const sessions = /* @__PURE__ */ new Map();
+	const dispatch = /* @__PURE__ */ new Map();
 	/** Global unique index on event ids, like the SQL schema's. */
 	const byEventId = /* @__PURE__ */ new Map();
-	const leases = /* @__PURE__ */ new Map();
-	/** Array offset of the first row not known to be processed. */
-	const pendingHeads = /* @__PURE__ */ new Map();
 	/** Keyed by `${sessionId}\u0000${reducerName}` — a pure cache. */
 	const snapshots = /* @__PURE__ */ new Map();
 	const streamSubscribers = /* @__PURE__ */ new Map();
@@ -60,117 +63,206 @@ function memory(options = {}) {
 		}
 		return rows;
 	};
+	const dispatchOf = (sessionId) => {
+		let state = dispatch.get(sessionId);
+		if (!state) {
+			state = {
+				ready: /* @__PURE__ */ new Map(),
+				lanes: /* @__PURE__ */ new Map()
+			};
+			dispatch.set(sessionId, state);
+		}
+		return state;
+	};
+	const enqueue = (sessionId, row) => {
+		if (row.processedAt !== null) return;
+		const state = dispatchOf(sessionId);
+		if (row.lane === null) {
+			state.ready.set(row.index, row);
+			return;
+		}
+		let queue = state.lanes.get(row.lane);
+		if (!queue) {
+			queue = {
+				rows: [],
+				head: 0
+			};
+			state.lanes.set(row.lane, queue);
+		}
+		queue.rows.push(row);
+		if (queue.rows.length === 1) state.ready.set(row.index, row);
+	};
+	const settle = (sessionId, row) => {
+		const state = dispatchOf(sessionId);
+		state.ready.delete(row.index);
+		if (row.lane === null) return;
+		const queue = state.lanes.get(row.lane);
+		if (queue.rows[queue.head] !== row) return;
+		queue.head += 1;
+		if (queue.head === queue.rows.length) {
+			state.lanes.delete(row.lane);
+			return;
+		}
+		const next = queue.rows[queue.head];
+		if (next.failedAt === null) state.ready.set(next.index, next);
+	};
 	const find = (sessionId, index) => {
-		const row = sessions.get(sessionId)?.find((candidate) => candidate.index === index);
+		const row = sessions.get(sessionId)?.[index - 1];
 		if (!row) throw new TypeError(`no event at index ${index} in session '${sessionId}'`);
 		return row;
 	};
-	const pendingHead = (sessionId) => {
-		const rows = sessions.get(sessionId) ?? [];
-		let offset = pendingHeads.get(sessionId) ?? 0;
-		while (offset < rows.length && rows[offset]?.processedAt !== null) offset += 1;
-		pendingHeads.set(sessionId, offset);
-		return rows[offset];
-	};
-	const claim = (row, now) => {
+	const appendResult = (sessionId, events) => ({
+		events,
+		hasPending: (sessions.get(sessionId) ?? []).some((row) => row.processedAt === null)
+	});
+	const claim = (row, holder, now, expiresAt) => {
 		row.attemptCount += 1;
 		row.firstClaimedAt ??= new Date(now);
 		row.lastClaimedAt = new Date(now);
+		row.claimHolder = holder;
+		row.claimExpiresAt = new Date(expiresAt);
 		return toStored(row);
 	};
+	const checkBatchIds = (sessionId, events) => {
+		const supplied = events.filter((candidate) => candidate.id !== void 0);
+		if (new Set(supplied.map((candidate) => candidate.id)).size !== supplied.length) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "batch contains the same event id more than once");
+		const existing = supplied.map((candidate) => byEventId.get(candidate.id)).filter((row) => row !== void 0);
+		const foreign = existing.find((row) => row.sessionId !== sessionId);
+		if (foreign) throw new A2Error("PARTIAL_DUPLICATE_BATCH", `event id '${foreign.id}' already exists in another session`);
+		return existing;
+	};
+	const insert = (sessionId, events, now, cause) => {
+		const rows = rowsOf(sessionId);
+		const base = rows.length === 0 ? 0 : rows[rows.length - 1].index;
+		const inserted = events.map((candidate, offset) => ({
+			id: candidate.id ?? generateId(),
+			type: candidate.type,
+			payload: structuredClone(candidate.payload),
+			index: base + 1 + offset,
+			sessionId,
+			createdAt: new Date(now),
+			cause: cause ? { ...cause } : candidate.cause ? { ...candidate.cause } : null,
+			lane: candidate.lane ?? null,
+			processedAt: candidate.settled ? new Date(now) : null,
+			processedByAttempt: null,
+			returnedEventIds: null,
+			firstClaimedAt: null,
+			lastClaimedAt: null,
+			attemptCount: 0,
+			claimHolder: null,
+			claimExpiresAt: null,
+			failureCount: 0,
+			lastFailedAt: null,
+			lastFailedAttempt: null,
+			lastError: null,
+			failedAt: null
+		}));
+		for (const row of inserted) if (byEventId.has(row.id)) throw new A2Error("PARTIAL_DUPLICATE_BATCH", `event id '${row.id}' already exists`);
+		for (const row of inserted) {
+			rows.push(row);
+			byEventId.set(row.id, row);
+			enqueue(sessionId, row);
+		}
+		return inserted;
+	};
 	return {
 		async append(sessionId, events) {
-			if (events.length === 0) return [];
-			const supplied = events.filter((e) => e.id !== void 0);
-			if (new Set(supplied.map((e) => e.id)).size !== supplied.length) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "batch contains the same event id more than once");
-			const existing = supplied.map((e) => byEventId.get(e.id)).filter((row) => row !== void 0);
+			if (events.length === 0) return appendResult(sessionId, []);
+			const existing = checkBatchIds(sessionId, events);
 			if (existing.length > 0) {
-				const foreign = existing.find((row) => row.sessionId !== sessionId);
-				if (foreign) throw new A2Error("PARTIAL_DUPLICATE_BATCH", `event id '${foreign.id}' already exists in another session`);
-				if (existing.length === events.length) return existing.toSorted((a, b) => a.index - b.index).map(toStored);
+				if (existing.length === events.length) return appendResult(sessionId, idempotentReplay(events, existing.map(toStored)));
 				throw new A2Error("PARTIAL_DUPLICATE_BATCH", `batch mixes ${existing.length} already-appended and ${events.length - existing.length} fresh events`);
 			}
-			const rows = rowsOf(sessionId);
 			const now = clock.now();
-			const base = rows.length === 0 ? 0 : rows[rows.length - 1].index;
-			const inserted = events.map((e, i) => {
-				return {
-					id: e.id ?? generateId(),
-					type: e.type,
-					payload: structuredClone(e.payload),
-					index: base + 1 + i,
-					sessionId,
-					createdAt: new Date(now),
-					cause: e.cause ? { ...e.cause } : null,
-					processedAt: null,
-					processedByAttempt: null,
-					firstClaimedAt: null,
-					lastClaimedAt: null,
-					attemptCount: 0,
-					failureCount: 0,
-					lastFailedAt: null,
-					lastFailedAttempt: null,
-					lastError: null,
-					failedAt: null
-				};
-			});
-			for (const row of inserted) if (byEventId.has(row.id)) throw new A2Error("PARTIAL_DUPLICATE_BATCH", `event id '${row.id}' already exists`);
-			for (const row of inserted) {
-				rows.push(row);
-				byEventId.set(row.id, row);
-			}
+			const inserted = insert(sessionId, events, now);
 			notifyStreams(sessionId, inserted);
-			return inserted.map(toStored);
+			return appendResult(sessionId, inserted.map(toStored));
 		},
 		async read(sessionId, opts) {
 			return (sessions.get(sessionId) ?? []).filter((row) => {
 				if (opts?.afterIndex !== void 0 && row.index <= opts.afterIndex) return false;
-				if (opts?.unprocessedOnly && row.processedAt !== null) return false;
 				return true;
 			}).map(toStored);
 		},
-		async claimNext({ sessionId, holder, ttlMs, expiresAtMs, maxIndex }) {
-			const next = pendingHead(sessionId);
-			if (!next || next.failedAt || maxIndex !== void 0 && next.index > maxIndex) return { outcome: "settled" };
+		async claimAvailable({ sessionId, holder, ttlMs, expiresAtMs, excludeIndexes }) {
 			const claimedAt = clock.now();
 			const now = claimedAt.getTime();
-			const current = leases.get(sessionId);
-			if (current && current.expiresAt > now && current.holder !== holder) return { outcome: "busy" };
-			leases.set(sessionId, {
-				holder,
-				expiresAt: expiresAtMs ?? now + ttlMs
-			});
+			const expiresAt = new Date(expiresAtMs ?? now + ttlMs);
+			const excluded = new Set(excludeIndexes ?? []);
+			const eligible = [];
+			let retryAt = null;
+			for (const row of dispatchOf(sessionId).ready.values()) {
+				if (row.failedAt !== null || excluded.has(row.index)) continue;
+				if (row.claimExpiresAt && row.claimExpiresAt.getTime() > now) {
+					if (!retryAt || row.claimExpiresAt < retryAt) retryAt = new Date(row.claimExpiresAt);
+					continue;
+				}
+				eligible.push(row);
+			}
+			if (eligible.length === 0) return retryAt ? {
+				outcome: "busy",
+				retryAt
+			} : { outcome: "settled" };
+			eligible.sort((a, b) => a.index - b.index);
 			return {
 				outcome: "claimed",
-				event: claim(next, claimedAt)
+				events: eligible.map((row) => claim(row, holder, claimedAt, expiresAt))
 			};
 		},
-		async completeAndClaimNext({ sessionId, holder, completedIndex, attempt, maxIndex }) {
-			const claimedAt = clock.now();
-			const completed = find(sessionId, completedIndex);
-			if (completed.processedAt || completed.attemptCount !== attempt) return { outcome: "superseded" };
-			completed.processedAt = new Date(claimedAt);
-			completed.processedByAttempt = attempt;
-			const next = pendingHead(sessionId);
-			if (!next || next.failedAt || maxIndex !== void 0 && next.index > maxIndex) return { outcome: "settled" };
-			const now = claimedAt.getTime();
-			const current = leases.get(sessionId);
-			if (!current || current.holder !== holder || current.expiresAt <= now) return { outcome: "busy" };
+		async renewClaims({ sessionId, holder, indexes, ttlMs, expiresAtMs }) {
+			const now = clock.now();
+			const expiresAt = new Date(expiresAtMs ?? now.getTime() + ttlMs);
+			const requested = new Set(indexes);
+			const renewed = [];
+			for (const row of sessions.get(sessionId) ?? []) if (requested.has(row.index) && row.processedAt === null && row.failedAt === null && row.claimHolder === holder && row.claimExpiresAt !== null && row.claimExpiresAt > now) {
+				row.claimExpiresAt = new Date(expiresAt);
+				renewed.push(row.index);
+			}
+			return renewed;
+		},
+		async completeAttempt({ sessionId, index, attempt, events }) {
+			const parent = find(sessionId, index);
+			const cause = {
+				index,
+				attempt
+			};
+			if (parent.processedAt !== null) {
+				if (parent.processedByAttempt !== attempt) return { outcome: "superseded" };
+				const requestedIds = events.map((event) => event.id);
+				if (parent.returnedEventIds === null || parent.returnedEventIds.length !== requestedIds.length || parent.returnedEventIds.some((id, offset) => id !== requestedIds[offset])) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "completed attempt does not match the returned event batch");
+				const existing = checkBatchIds(sessionId, events);
+				if (existing.length !== events.length || existing.some((row) => row.cause?.index !== index || row.cause.attempt !== attempt)) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "completed attempt does not match the returned event batch");
+				return {
+					outcome: "completed",
+					events: idempotentReplay(events, existing.map(toStored))
+				};
+			}
+			if (parent.attemptCount !== attempt || parent.failedAt !== null || parent.claimHolder === null) return { outcome: "superseded" };
+			if (checkBatchIds(sessionId, events).length > 0) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "returned event batch contains already-appended ids");
+			const now = clock.now();
+			const inserted = insert(sessionId, events, now, cause);
+			parent.processedAt = new Date(now);
+			parent.processedByAttempt = attempt;
+			parent.returnedEventIds = events.map((event) => event.id);
+			parent.claimHolder = null;
+			parent.claimExpiresAt = null;
+			settle(sessionId, parent);
+			notifyStreams(sessionId, inserted);
 			return {
-				outcome: "claimed",
-				event: claim(next, claimedAt)
+				outcome: "completed",
+				events: inserted.map(toStored)
 			};
 		},
-		async markProcessed(sessionId, index) {
-			const row = find(sessionId, index);
-			row.processedAt ??= clock.now();
-		},
 		async failAttempt({ sessionId, index, attempt, error, maxFailures }) {
 			const row = find(sessionId, index);
-			if (row.processedAt || row.attemptCount !== attempt) return {
+			if (row.processedAt || row.attemptCount !== attempt || row.claimHolder === null && row.lastFailedAttempt !== attempt) return {
 				outcome: "superseded",
 				failureCount: row.failureCount
 			};
+			if (row.lastFailedAttempt === attempt && row.claimHolder === null) return {
+				outcome: row.failedAt ? "dead_lettered" : "failed",
+				failureCount: row.failureCount
+			};
 			if (row.failedAt) return {
 				outcome: "dead_lettered",
 				failureCount: row.failureCount
@@ -180,8 +272,11 @@ function memory(options = {}) {
 			const failedAt = clock.now();
 			row.lastFailedAt = new Date(failedAt);
 			row.lastFailedAttempt = attempt;
+			row.claimHolder = null;
+			row.claimExpiresAt = null;
 			if (row.failureCount >= maxFailures) {
 				row.failedAt = new Date(failedAt);
+				dispatchOf(sessionId).ready.delete(row.index);
 				return {
 					outcome: "dead_lettered",
 					failureCount: row.failureCount
@@ -192,9 +287,6 @@ function memory(options = {}) {
 				failureCount: row.failureCount
 			};
 		},
-		async markFailed(sessionId, index) {
-			find(sessionId, index).failedAt = clock.now();
-		},
 		async readState(sessionId, reducerName) {
 			const snap = snapshots.get(`${sessionId}\u0000${reducerName}`);
 			const snapshot = snap ? {
@@ -323,21 +415,6 @@ function memory(options = {}) {
 					}
 				};
 			} };
-		},
-		lease: {
-			async acquire({ sessionId, holder, ttlMs, expiresAtMs }) {
-				const now = clock.now().getTime();
-				const current = leases.get(sessionId);
-				if (current && current.expiresAt > now && current.holder !== holder) return false;
-				leases.set(sessionId, {
-					holder,
-					expiresAt: expiresAtMs ?? now + ttlMs
-				});
-				return true;
-			},
-			async release({ sessionId, holder }) {
-				if (leases.get(sessionId)?.holder === holder) leases.delete(sessionId);
-			}
 		}
 	};
 }

package/dist/{log-polling-RO7kclzR.js → log-polling-6COoN60V.js}

@@ -1,4 +1,4 @@
-import { n as POLL_TIMINGS } from "./internal-Dm8Ejnud.js";
+import { n as POLL_TIMINGS } from "./internal-D6wNxTck.js";
 //#region src/log-polling.ts
 /**
 * The shared polling stream — how poll-based backends (sqlite,

package/dist/log-postgres.d.ts

@@ -1,4 +1,4 @@
-import { c as IdSource, i as Clock, t as A2Log } from "./log-Dg1I8NRr.js";
+import { c as IdSource, i as Clock, t as A2Log } from "./log-ldf5g8Cx.js";
 //#region src/log-postgres.d.ts
 /** The result shape this backend reads: just rows. */
 type PostgresQueryResult = {