experimental-a2 0.16.1 → 0.17.0

package/dist/store-sqlite.js

@@ -1,6 +1,6 @@
-import { t as A2Error } from "./errors-DCk6ch5n.js";
-import { n as pollingStream } from "./store-polling-CmxUbV93.js";
-import { t as idempotentReplay } from "./idempotent-replay-DVOlyYbx.js";
+import { i as A2Error, r as sessionClearedError, s as supersededAttemptError, t as CLEAR_EVENT_TYPE } from "./session-clear-DGI4jTQ5.js";
+import { n as pollingStream } from "./store-polling-4_y8lETm.js";
+import { t as idempotentReplay } from "./idempotent-replay-JdgMQRRm.js";
 import { n as SYSTEM_CLOCK, t as RANDOM_IDS } from "./store-N8PXxDAS.js";
 import { t as decodeReturnedEventIds } from "./store-codec-DTG0Ftek.js";
 import { mkdirSync } from "node:fs";
@@ -88,6 +88,11 @@ create table if not exists a2_snapshot_pins (
 create index if not exists a2_snapshot_pins_checkpoint
   on a2_snapshot_pins (session_id, reducer_name, up_to_index);
 
+create table if not exists a2_clears (
+  session_id  text    not null primary key,
+  clear_index integer not null
+) strict;
+
 create table if not exists a2_presence (
   ns          text    not null,
   participant text    not null,
@@ -166,6 +171,7 @@ const toEvent = (row) => ({
 	sessionId: row.session_id,
 	createdAt: new Date(Number(row.created_at))
 });
+const RECLAIM_BATCH = 256;
 function sqlite(options = {}) {
 	const path = options.path ?? ".a2/dev.db";
 	const clock = options.clock ?? SYSTEM_CLOCK;
@@ -188,6 +194,7 @@ function sqlite(options = {}) {
               when not exists (
                 select 1 from a2_events
                  where session_id = ? and lane = ? and processed_at is null
+                   and idx > ?
               ) then 1
               else 0
             end,
@@ -197,6 +204,7 @@ function sqlite(options = {}) {
         and idx = (
           select idx from a2_events
            where session_id = ? and lane = ? and processed_at is null
+             and idx > ?
            order by idx limit 1
         )`);
 	const appendStatus = db.prepare(`select coalesce(
@@ -205,7 +213,7 @@ function sqlite(options = {}) {
             ) as max,
             exists(
               select 1 from a2_events
-              where session_id = ? and processed_at is null
+              where session_id = ? and processed_at is null and idx > ?
             ) as has_pending`);
 	const upsertPresence = db.prepare(`insert into a2_presence (ns, participant, field, value, seen, at, expires_at)
      values (?, ?, ?, ?, ?, ?, ?)
@@ -227,10 +235,34 @@ function sqlite(options = {}) {
                 select 1 from a2_events pending
                 where pending.session_id = ?
                   and pending.processed_at is null
+                  and pending.idx > ?
               ) as session_has_pending
          from a2_events stored
         where stored.event_id in (${Array.from({ length: count }, () => "?").join(", ")})
         order by stored.idx`);
+	const selectClearIndex = db.prepare("select clear_index from a2_clears where session_id = ?");
+	const clearIndexOf = (sessionId) => Number(selectClearIndex.get(sessionId)?.clear_index ?? 0);
+	const deleteEventById = db.prepare("delete from a2_events where session_id = ? and event_id = ?");
+	/**
+	* The rows owning `ids`. This session's rows below its clear marker do
+	* not own their ids: they are deleted here so the ids can be reused.
+	*/
+	const liveOwnersOf = (sessionId, clearIndex, ids) => {
+		if (ids.length === 0) return [];
+		return selectByIds(ids.length).all(sessionId, clearIndex, ...ids).filter((row) => {
+			if (row.session_id !== sessionId || Number(row.idx) >= clearIndex) return true;
+			deleteEventById.run(sessionId, row.event_id);
+			return false;
+		});
+	};
+	const selectCauseParent = db.prepare("select attempt_count, failed_at from a2_events where session_id = ? and idx = ?");
+	/** The attempt-currency fence shared by handler appends and clears. */
+	const assertCurrentCause = ({ sessionId, cause, clearIndex }) => {
+		if (cause.index <= clearIndex) throw supersededAttemptError(sessionId, cause);
+		const parent = selectCauseParent.get(sessionId, cause.index);
+		if (!parent) throw new TypeError(`no event at index ${cause.index} in session '${sessionId}'`);
+		if (Number(parent.attempt_count) !== cause.attempt || parent.failed_at !== null) throw supersededAttemptError(sessionId, cause);
+	};
 	const tx = (fn) => {
 		db.exec("begin immediate");
 		try {
@@ -245,19 +277,20 @@ function sqlite(options = {}) {
 		}
 	};
 	return {
-		async append(sessionId, events) {
+		async append(sessionId, events, appendOptions) {
 			if (events.length === 0) return wrap(() => {
-				const status = appendStatus.get(sessionId, sessionId);
+				const status = appendStatus.get(sessionId, sessionId, clearIndexOf(sessionId));
 				return {
 					events: [],
 					hasPending: Number(status.has_pending) === 1
 				};
 			});
 			return wrap(() => tx(() => {
+				const clearIndex = clearIndexOf(sessionId);
 				const suppliedIds = events.filter((e) => e.id !== void 0).map((e) => e.id);
 				if (new Set(suppliedIds).size !== suppliedIds.length) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "batch contains the same event id more than once");
 				if (suppliedIds.length > 0) {
-					const existing = selectByIds(suppliedIds.length).all(sessionId, ...suppliedIds);
+					const existing = liveOwnersOf(sessionId, clearIndex, suppliedIds);
 					if (existing.length > 0) {
 						const foreign = existing.find((row) => row.session_id !== sessionId);
 						if (foreign) throw new A2Error("PARTIAL_DUPLICATE_BATCH", `event id '${foreign.event_id}' already exists in another session`);
@@ -268,20 +301,21 @@ function sqlite(options = {}) {
 						throw new A2Error("PARTIAL_DUPLICATE_BATCH", `batch mixes ${existing.length} already-appended and ${events.length - existing.length} fresh events`);
 					}
 				}
-				for (const e of events) {
-					if (!e.cause) continue;
-					const parent = db.prepare("select attempt_count, failed_at from a2_events where session_id = ? and idx = ?").get(sessionId, e.cause.index);
-					if (!parent) throw new TypeError(`no event at index ${e.cause.index} in session '${sessionId}'`);
-					if (Number(parent.attempt_count) !== e.cause.attempt || parent.failed_at !== null) throw new A2Error("SUPERSEDED_ATTEMPT", `attempt ${e.cause.attempt} no longer owns event ${e.cause.index} in session '${sessionId}'`);
-				}
-				const status = appendStatus.get(sessionId, sessionId);
+				const originIndex = appendOptions?.originIndex;
+				if (originIndex !== void 0 && originIndex <= clearIndex) throw sessionClearedError(`scheduled work from event ${originIndex} was cleared in session '${sessionId}'`);
+				for (const e of events) if (e.cause) assertCurrentCause({
+					sessionId,
+					cause: e.cause,
+					clearIndex
+				});
+				const status = appendStatus.get(sessionId, sessionId, clearIndex);
 				const base = Number(status.max);
 				const now = clock.now().getTime();
 				return {
 					events: events.map((e, i) => {
 						const id = e.id ?? generateId();
 						const index = base + 1 + i;
-						insertEvent.run(sessionId, index, e.type, JSON.stringify(e.payload) ?? "null", id, now, e.cause ? JSON.stringify(e.cause) : null, e.lane ?? null, e.lane ?? null, sessionId, e.lane ?? null, e.settled ? now : null);
+						insertEvent.run(sessionId, index, e.type, JSON.stringify(e.payload) ?? "null", id, now, e.cause ? JSON.stringify(e.cause) : null, e.lane ?? null, e.lane ?? null, sessionId, e.lane ?? null, clearIndex, e.settled ? now : null);
 						return {
 							id,
 							type: e.type,
@@ -312,8 +346,8 @@ function sqlite(options = {}) {
 		},
 		async read(sessionId, opts) {
 			return wrap(() => {
-				const conditions = ["session_id = ?"];
-				const params = [sessionId];
+				const conditions = ["session_id = ?", "idx >= coalesce((select clear_index from a2_clears where session_id = ?), 0)"];
+				const params = [sessionId, sessionId];
 				if (opts?.afterIndex !== void 0) {
 					conditions.push("idx > ?");
 					params.push(opts.afterIndex);
@@ -329,6 +363,7 @@ function sqlite(options = {}) {
 			return wrap(() => tx(() => {
 				const now = clock.now().getTime();
 				const expiresAt = expiresAtMs ?? now + ttlMs;
+				const clearIndex = clearIndexOf(sessionId);
 				const exclusion = excludeIndexes.length === 0 ? "" : `and event.idx not in (${excludeIndexes.map(() => "?").join(", ")})`;
 				const eligible = db.prepare(`select event.idx
                  from a2_events event
@@ -336,9 +371,10 @@ function sqlite(options = {}) {
                   and event.processed_at is null
                   and event.failed_at is null
                   and event.lane_ready = 1
+                  and event.idx > ?
                   and (event.claim_expires_at is null or event.claim_expires_at <= ?)
                   ${exclusion}
-                order by event.idx`).all(sessionId, now, ...excludeIndexes);
+                order by event.idx`).all(sessionId, clearIndex, now, ...excludeIndexes);
 				if (eligible.length > 0) {
 					const update = db.prepare(`update a2_events set
                  attempt_count = attempt_count + 1,
@@ -352,7 +388,9 @@ function sqlite(options = {}) {
 						outcome: "claimed",
 						events: eligible.map((row) => {
 							const claimed = update.get(now, now, holder, expiresAt, sessionId, row.idx);
-							return toStored(claimed);
+							const stored = toStored(claimed);
+							if (clearIndex > 0) stored.clearIndex = clearIndex;
+							return stored;
 						})
 					};
 				}
@@ -362,7 +400,8 @@ function sqlite(options = {}) {
                   and processed_at is null
                   and failed_at is null
                   and lane_ready = 1
-                  and claim_expires_at > ?`).get(sessionId, now);
+                  and idx > ?
+                  and claim_expires_at > ?`).get(sessionId, clearIndex, now);
 				return active.retry_at === null ? { outcome: "settled" } : {
 					outcome: "busy",
 					retryAt: new Date(Number(active.retry_at))
@@ -388,7 +427,12 @@ function sqlite(options = {}) {
                 and failed_at is null
                 and claim_holder = ?
                 and claim_expires_at > ?`);
+				const clearIndex = clearIndexOf(sessionId);
 				for (const claim of claims) {
+					if (claim.index <= clearIndex) {
+						superseded.push(claim.index);
+						continue;
+					}
 					const row = currentAttempt.get(sessionId, claim.index);
 					if (!row) continue;
 					if (Number(row.attempt_count) > claim.attempt) {
@@ -406,6 +450,8 @@ function sqlite(options = {}) {
 		},
 		async completeAttempt({ sessionId, index, attempt, events }) {
 			return wrap(() => tx(() => {
+				const clearIndex = clearIndexOf(sessionId);
+				if (index <= clearIndex) return { outcome: "superseded" };
 				const parent = db.prepare("select * from a2_events where session_id = ? and idx = ?").get(sessionId, index);
 				if (!parent) throw new TypeError(`no event at index ${index} in session '${sessionId}'`);
 				const ids = events.map((event) => event.id);
@@ -414,7 +460,7 @@ function sqlite(options = {}) {
 					if (Number(parent.processed_by_attempt) !== attempt) return { outcome: "superseded" };
 					const returnedIds = parent.returned_event_ids === null ? null : decodeReturnedEventIds(parent.returned_event_ids);
 					if (returnedIds === null || returnedIds.length !== ids.length || returnedIds.some((id, offset) => id !== ids[offset])) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "completed attempt does not match the returned event batch");
-					const existing = ids.length === 0 ? [] : selectByIds(ids.length).all(sessionId, ...ids);
+					const existing = ids.length === 0 ? [] : selectByIds(ids.length).all(sessionId, clearIndex, ...ids);
 					const byId = new Map(existing.map((row) => [row.event_id, row]));
 					const ordered = ids.map((id) => byId.get(id));
 					if (ordered.some((row) => !row || row.session_id !== sessionId || row.cause === null || toCause(row.cause)?.index !== index || toCause(row.cause)?.attempt !== attempt)) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "returned event retry does not match the committed batch");
@@ -424,8 +470,8 @@ function sqlite(options = {}) {
 					};
 				}
 				if (Number(parent.attempt_count) !== attempt || parent.claim_holder === null || parent.failed_at !== null) return { outcome: "superseded" };
-				if (ids.length > 0 && selectByIds(ids.length).all(sessionId, ...ids).length > 0) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "returned event batch contains an already-appended event id");
-				const status = appendStatus.get(sessionId, sessionId);
+				if (liveOwnersOf(sessionId, clearIndex, ids).length > 0) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "returned event batch contains an already-appended event id");
+				const status = appendStatus.get(sessionId, sessionId, clearIndex);
 				const now = clock.now().getTime();
 				db.prepare(`update a2_events set
                processed_at = ?,
@@ -444,7 +490,7 @@ function sqlite(options = {}) {
                      and pin.reducer_name = a2_snapshot_history.reducer_name
                      and pin.up_to_index = a2_snapshot_history.up_to_index
                 )`).run(sessionId);
-				if (parent.lane !== null) promoteLaneHead.run(sessionId, sessionId, parent.lane);
+				if (parent.lane !== null) promoteLaneHead.run(sessionId, sessionId, parent.lane, clearIndex);
 				return {
 					outcome: "completed",
 					events: events.map((event, offset) => {
@@ -454,7 +500,7 @@ function sqlite(options = {}) {
 							index,
 							attempt
 						};
-						insertEvent.run(sessionId, childIndex, event.type, JSON.stringify(event.payload) ?? "null", id, now, JSON.stringify(cause), event.lane ?? null, event.lane ?? null, sessionId, event.lane ?? null, event.settled ? now : null);
+						insertEvent.run(sessionId, childIndex, event.type, JSON.stringify(event.payload) ?? "null", id, now, JSON.stringify(cause), event.lane ?? null, event.lane ?? null, sessionId, event.lane ?? null, clearIndex, event.settled ? now : null);
 						return toStored(db.prepare("select * from a2_events where session_id = ? and idx = ?").get(sessionId, childIndex));
 					})
 				};
@@ -462,6 +508,10 @@ function sqlite(options = {}) {
 		},
 		async failAttempt({ sessionId, index, attempt, error, maxFailures }) {
 			return wrap(() => tx(() => {
+				if (index <= clearIndexOf(sessionId)) return {
+					outcome: "superseded",
+					failureCount: 0
+				};
 				const current = db.prepare("select * from a2_events where session_id = ? and idx = ?").get(sessionId, index);
 				if (!current) throw new TypeError(`no event at index ${index} in session '${sessionId}'`);
 				const failureCount = Number(current.failure_count);
@@ -514,10 +564,15 @@ function sqlite(options = {}) {
 			return wrap(() => {
 				const throughIndex = stateOptions?.throughIndex ?? null;
 				const snapshotThroughIndex = stateOptions?.snapshotThroughIndex ?? throughIndex;
-				const rows = db.prepare(`with head as materialized (
+				const rows = db.prepare(`with boundary as materialized (
+             select coalesce(
+               (select clear_index from a2_clears where session_id = ?), 0
+             ) as clear_index
+           ), head as materialized (
              select up_to_index, state, updated_at
                from a2_snapshots
               where session_id = ? and reducer_name = ?
+                and up_to_index >= (select clear_index from boundary)
            ), snapshot as materialized (
              select up_to_index, state from (
                select up_to_index, state from head
@@ -526,10 +581,12 @@ function sqlite(options = {}) {
                select up_to_index, state
                  from a2_snapshot_history
                 where session_id = ? and reducer_name = ?
+                  and up_to_index >= (select clear_index from boundary)
                   and (? is null or up_to_index <= ?)
              ) order by up_to_index desc limit 1
              )
              select 0 as row_order, 'snapshot' as row_kind,
+                    (select clear_index from boundary) as clear_index,
                     (select up_to_index from head) as head_index,
                     (select up_to_index from snapshot) as snapshot_index,
                     (select state from snapshot) as snapshot_state,
@@ -546,16 +603,22 @@ function sqlite(options = {}) {
                     null as claim_expires_at
              union all
              select 1 as row_order, 'event' as row_kind,
+                    null as clear_index,
                     (select up_to_index from head) as head_index,
                     null as snapshot_index, null as snapshot_state,
                     event.*
              from a2_events as event
              where event.session_id = ?
-               and event.idx > coalesce((select up_to_index from snapshot), 0)
+               and event.idx > max(
+                 coalesce((select up_to_index from snapshot), 0),
+                 (select clear_index from boundary) - 1
+               )
                and (? is null or event.idx <= ?)
-             order by row_order, idx`).all(sessionId, reducerName, snapshotThroughIndex, snapshotThroughIndex, sessionId, reducerName, snapshotThroughIndex, snapshotThroughIndex, sessionId, throughIndex, throughIndex);
+             order by row_order, idx`).all(sessionId, sessionId, reducerName, snapshotThroughIndex, snapshotThroughIndex, sessionId, reducerName, snapshotThroughIndex, snapshotThroughIndex, sessionId, throughIndex, throughIndex);
 				const snapshot = rows.find((row) => row.row_kind === "snapshot");
+				const clearIndex = Number(snapshot?.clear_index ?? 0);
 				return {
+					...clearIndex > 0 ? { clearIndex } : {},
 					headIndex: snapshot?.head_index === null || snapshot?.head_index === void 0 ? null : Number(snapshot.head_index),
 					snapshot: snapshot?.snapshot_index !== null && snapshot?.snapshot_index !== void 0 ? {
 						index: Number(snapshot.snapshot_index),
@@ -570,7 +633,7 @@ function sqlite(options = {}) {
 				const selectHead = db.prepare(`select up_to_index, state, updated_at from a2_snapshots
               where session_id = ? and reducer_name = ?`);
 				const unfinished = db.prepare(`select 1 from a2_events
-              where session_id = ? and idx = ?
+              where session_id = ? and idx = ? and idx > ?
                 and processed_at is null and failed_at is null`);
 				const insertPin = db.prepare(`insert or ignore into a2_snapshot_pins
                (session_id, event_index, reducer_name, up_to_index)
@@ -593,12 +656,14 @@ function sqlite(options = {}) {
              where excluded.up_to_index >= a2_snapshots.up_to_index`);
 				const deleteHistory = db.prepare(`delete from a2_snapshot_history
               where session_id = ? and reducer_name = ? and up_to_index = ?`);
+				const clearIndex = clearIndexOf(sessionId);
 				for (const write of writes.toSorted((a, b) => a.index - b.index)) {
-					for (const eventIndex of write.pinEventIndexes ?? []) if (unfinished.get(sessionId, eventIndex)) insertPin.run(sessionId, eventIndex, reducerName, write.index);
+					if (write.index < clearIndex) continue;
+					for (const eventIndex of write.pinEventIndexes ?? []) if (unfinished.get(sessionId, eventIndex, clearIndex)) insertPin.run(sessionId, eventIndex, reducerName, write.index);
 					const head = selectHead.get(sessionId, reducerName);
 					const now = clock.now().getTime();
 					if (!head || write.index >= Number(head.up_to_index)) {
-						if (head && write.index > Number(head.up_to_index) && hasPin.get(sessionId, reducerName, Number(head.up_to_index))) putHistory.run(sessionId, reducerName, Number(head.up_to_index), head.state, Number(head.updated_at));
+						if (head && write.index > Number(head.up_to_index) && Number(head.up_to_index) >= clearIndex && hasPin.get(sessionId, reducerName, Number(head.up_to_index))) putHistory.run(sessionId, reducerName, Number(head.up_to_index), head.state, Number(head.updated_at));
 						putHead.run(sessionId, reducerName, write.index, JSON.stringify(write.state) ?? "null", now);
 						deleteHistory.run(sessionId, reducerName, write.index);
 					} else if (write.index < Number(head.up_to_index) && hasPin.get(sessionId, reducerName, write.index)) putHistory.run(sessionId, reducerName, write.index, JSON.stringify(write.state) ?? "null", now);
@@ -633,10 +698,79 @@ function sqlite(options = {}) {
 		},
 		stream(sessionId, opts) {
 			const readAfter = (afterIndex) => wrap(() => {
-				return db.prepare("select * from a2_events where session_id = ? and idx > ? order by idx").all(sessionId, afterIndex).map(toStored);
+				return db.prepare(`select * from a2_events
+                where session_id = ? and idx > ?
+                  and idx >= coalesce((select clear_index from a2_clears where session_id = ?), 0)
+                order by idx`).all(sessionId, afterIndex, sessionId).map(toStored);
 			});
 			return pollingStream(readAfter, opts?.startAfter !== void 0 ? { startAfter: opts.startAfter } : {});
 		},
+		async clear({ sessionId, ifLastIndex, cause }) {
+			return wrap(() => tx(() => {
+				const clearIndex = clearIndexOf(sessionId);
+				if (cause) assertCurrentCause({
+					sessionId,
+					cause,
+					clearIndex
+				});
+				const head = Number(appendStatus.get(sessionId, sessionId, clearIndex).max);
+				if (ifLastIndex !== void 0 && clearIndex === ifLastIndex + 1) return {
+					cleared: true,
+					index: head,
+					clearIndex
+				};
+				if (ifLastIndex !== void 0 && ifLastIndex !== head) return {
+					cleared: false,
+					index: head,
+					clearIndex
+				};
+				if (head === 0 || clearIndex === head) return {
+					cleared: true,
+					index: head,
+					clearIndex
+				};
+				const marker = head + 1;
+				const now = clock.now().getTime();
+				insertEvent.run(sessionId, marker, CLEAR_EVENT_TYPE, "null", generateId(), now, null, null, null, sessionId, null, clearIndex, now);
+				db.prepare(`insert into a2_clears (session_id, clear_index) values (?, ?)
+             on conflict (session_id) do update set clear_index = excluded.clear_index`).run(sessionId, marker);
+				return {
+					cleared: true,
+					index: marker,
+					clearIndex: marker
+				};
+			}));
+		},
+		async reclaim(sessionId) {
+			return wrap(() => tx(() => {
+				const clearIndex = clearIndexOf(sessionId);
+				if (clearIndex === 0) return {
+					deleted: 0,
+					done: true
+				};
+				const last = db.prepare(`select max(idx) as last from (
+                 select idx from a2_events
+                  where session_id = ? and idx < ?
+                  order by idx limit ?
+               )`).get(sessionId, clearIndex, RECLAIM_BATCH);
+				let deleted = 0;
+				if (last.last !== null) {
+					const through = Number(last.last);
+					deleted = Number(db.prepare("delete from a2_events where session_id = ? and idx <= ?").run(sessionId, through).changes);
+					db.prepare("delete from a2_snapshot_pins where session_id = ? and event_index <= ?").run(sessionId, through);
+				}
+				const done = db.prepare("select 1 from a2_events where session_id = ? and idx < ? limit 1").get(sessionId, clearIndex) === void 0;
+				if (done) for (const table of [
+					"a2_snapshot_pins",
+					"a2_snapshot_history",
+					"a2_snapshots"
+				]) db.prepare(`delete from ${table} where session_id = ? and up_to_index < ?`).run(sessionId, clearIndex);
+				return {
+					deleted,
+					done
+				};
+			}));
+		},
 		close() {
 			db.close();
 		}