experimental-a2 0.0.0 → 0.2.0

package/dist/log-sqlite.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-sqlite.d.ts
 type SqliteLogOptions = {
   /** Database file path. Defaults to `.a2/dev.db`; `:memory:` works. */

package/dist/log-sqlite.js

@@ -1,12 +1,13 @@
 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";
-import { t as pollingStream } from "./log-polling-RO7kclzR.js";
+import { t as pollingStream } from "./log-polling-6COoN60V.js";
 import { mkdirSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 //#region src/log-sqlite.ts
 /**
-* a2/log-sqlite — sqlite log backend (the dev default, `.a2/dev.db`).
+* experimental-a2/log-sqlite — sqlite log backend (the dev default, `.a2/dev.db`).
 *
 * Built on `node:sqlite` (Node ≥ 22.13) so it ships with zero
 * dependencies. Implements the A2Log interface; the conformance suite
@@ -27,8 +28,11 @@ create table if not exists a2_events (
   event_id     text    not null,
   created_at   integer not null,
   cause        text,
+  lane         text,
+  lane_ready   integer not null default 0,
   processed_at integer,
   processed_by_attempt integer,
+  returned_event_ids text,
   first_claimed_at integer,
   last_claimed_at integer,
   attempt_count integer not null default 0,
@@ -37,18 +41,22 @@ create table if not exists a2_events (
   last_failed_attempt integer,
   last_error   text,
   failed_at    integer,
+  claim_holder text,
+  claim_expires_at integer,
   primary key (session_id, idx)
 ) strict;
 
 create unique index if not exists a2_events_event_id on a2_events (event_id);
 create index if not exists a2_events_unprocessed
   on a2_events (session_id, idx) where processed_at is null;
-
-create table if not exists a2_leases (
-  session_id text    primary key,
-  holder     text    not null,
-  expires_at integer not null
-) strict;
+create index if not exists a2_events_lane_pending
+  on a2_events (session_id, lane, idx) where processed_at is null;
+create index if not exists a2_events_dispatch_ready
+  on a2_events (session_id, idx)
+  where lane_ready = 1 and processed_at is null and failed_at is null;
+create index if not exists a2_events_claim_expiry
+  on a2_events (session_id, claim_expires_at)
+  where lane_ready = 1 and processed_at is null and failed_at is null;
 
 create table if not exists a2_snapshots (
   session_id   text    not null,
@@ -88,9 +96,11 @@ const toCause = (json) => {
 	if (json === null) return null;
 	const value = JSON.parse(json);
 	if (!Number.isInteger(value.index) || Number(value.index) < 1 || !Number.isInteger(value.attempt) || Number(value.attempt) < 1) throw new TypeError("stored event has an invalid cause");
+	if (value.batchSize !== void 0 && (!Number.isInteger(value.batchSize) || Number(value.batchSize) < 1)) throw new TypeError("stored event has an invalid cause");
 	return {
 		index: Number(value.index),
-		attempt: Number(value.attempt)
+		attempt: Number(value.attempt),
+		...value.batchSize === void 0 ? {} : { batchSize: Number(value.batchSize) }
 	};
 };
 const toStored = (row) => ({
@@ -101,8 +111,10 @@ const toStored = (row) => ({
 	sessionId: row.session_id,
 	createdAt: new Date(Number(row.created_at)),
 	cause: toCause(row.cause),
+	lane: row.lane,
 	processedAt: toDate(row.processed_at),
 	processedByAttempt: row.processed_by_attempt === null ? null : Number(row.processed_by_attempt),
+	returnedEventIds: row.returned_event_ids === null ? null : JSON.parse(row.returned_event_ids),
 	firstClaimedAt: toDate(row.first_claimed_at),
 	lastClaimedAt: toDate(row.last_claimed_at),
 	attemptCount: Number(row.attempt_count),
@@ -110,7 +122,9 @@ const toStored = (row) => ({
 	lastFailedAt: toDate(row.last_failed_at),
 	lastFailedAttempt: row.last_failed_attempt === null ? null : Number(row.last_failed_attempt),
 	lastError: row.last_error,
-	failedAt: toDate(row.failed_at)
+	failedAt: toDate(row.failed_at),
+	claimHolder: row.claim_holder,
+	claimExpiresAt: toDate(row.claim_expires_at)
 });
 const toEvent = (row) => ({
 	id: row.event_id,
@@ -120,9 +134,6 @@ const toEvent = (row) => ({
 	sessionId: row.session_id,
 	createdAt: new Date(Number(row.created_at))
 });
-const requireChange = (changes, what) => {
-	if (Number(changes) === 0) throw new TypeError(what);
-};
 function sqlite(options = {}) {
 	const path = options.path ?? ".a2/dev.db";
 	const clock = options.clock ?? SYSTEM_CLOCK;
@@ -138,11 +149,41 @@ function sqlite(options = {}) {
 	db.exec(SCHEMA);
 	const insertEvent = db.prepare(`insert into a2_events
        (session_id, idx, event_type, payload, event_id, created_at,
-        cause)
-     values (?, ?, ?, ?, ?, ?, ?)`);
-	const maxIdx = db.prepare("select coalesce(max(idx), 0) as max from a2_events where session_id = ?");
-	const selectByIds = (count) => db.prepare(`select * from a2_events where event_id in (${Array.from({ length: count }, () => "?").join(", ")})
-       order by idx`);
+        cause, lane, lane_ready, processed_at)
+     select ?, ?, ?, ?, ?, ?, ?, ?,
+            case
+              when ? is null then 1
+              when not exists (
+                select 1 from a2_events
+                 where session_id = ? and lane = ? and processed_at is null
+              ) then 1
+              else 0
+            end,
+            ?`);
+	const promoteLaneHead = db.prepare(`update a2_events set lane_ready = 1
+      where session_id = ?
+        and idx = (
+          select idx from a2_events
+           where session_id = ? and lane = ? and processed_at is null
+           order by idx limit 1
+        )`);
+	const appendStatus = db.prepare(`select coalesce(
+              (select max(idx) from a2_events where session_id = ?),
+              0
+            ) as max,
+            exists(
+              select 1 from a2_events
+              where session_id = ? and processed_at is null
+            ) as has_pending`);
+	const selectByIds = (count) => db.prepare(`select stored.*,
+              exists(
+                select 1 from a2_events pending
+                where pending.session_id = ?
+                  and pending.processed_at is null
+              ) as session_has_pending
+         from a2_events stored
+        where stored.event_id in (${Array.from({ length: count }, () => "?").join(", ")})
+        order by stored.idx`);
 	const tx = (fn) => {
 		db.exec("begin immediate");
 		try {
@@ -158,45 +199,62 @@ function sqlite(options = {}) {
 	};
 	return {
 		async append(sessionId, events) {
-			if (events.length === 0) return [];
+			if (events.length === 0) return wrap(() => {
+				const status = appendStatus.get(sessionId, sessionId);
+				return {
+					events: [],
+					hasPending: Number(status.has_pending) === 1
+				};
+			});
 			return wrap(() => tx(() => {
 				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(...suppliedIds);
+					const existing = selectByIds(suppliedIds.length).all(sessionId, ...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`);
-						if (existing.length === events.length) return existing.map(toStored);
+						if (existing.length === events.length) return {
+							events: idempotentReplay(events, existing.map(toStored)),
+							hasPending: Number(existing[0].session_has_pending) === 1
+						};
 						throw new A2Error("PARTIAL_DUPLICATE_BATCH", `batch mixes ${existing.length} already-appended and ${events.length - existing.length} fresh events`);
 					}
 				}
-				const base = Number(maxIdx.get(sessionId).max);
+				const status = appendStatus.get(sessionId, sessionId);
+				const base = Number(status.max);
 				const now = clock.now().getTime();
-				return 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);
-					return {
-						id,
-						type: e.type,
-						payload: structuredClone(e.payload),
-						index,
-						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
-					};
-				});
+				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);
+						return {
+							id,
+							type: e.type,
+							payload: structuredClone(e.payload),
+							index,
+							sessionId,
+							createdAt: new Date(now),
+							cause: e.cause ? { ...e.cause } : null,
+							lane: e.lane ?? null,
+							processedAt: e.settled ? new Date(now) : null,
+							processedByAttempt: null,
+							returnedEventIds: null,
+							firstClaimedAt: null,
+							lastClaimedAt: null,
+							attemptCount: 0,
+							failureCount: 0,
+							lastFailedAt: null,
+							lastFailedAttempt: null,
+							lastError: null,
+							failedAt: null,
+							claimHolder: null,
+							claimExpiresAt: null
+						};
+					}),
+					hasPending: Number(status.has_pending) === 1 || events.some((event) => event.settled !== true)
+				};
 			}));
 		},
 		async read(sessionId, opts) {
@@ -207,74 +265,116 @@ function sqlite(options = {}) {
 					conditions.push("idx > ?");
 					params.push(opts.afterIndex);
 				}
-				if (opts?.unprocessedOnly) conditions.push("processed_at is null");
 				return db.prepare(`select * from a2_events where ${conditions.join(" and ")} order by idx`).all(...params).map(toStored);
 			});
 		},
-		async claimNext({ sessionId, holder, ttlMs, expiresAtMs, maxIndex }) {
+		async claimAvailable({ sessionId, holder, ttlMs, expiresAtMs, excludeIndexes = [] }) {
 			return wrap(() => tx(() => {
-				const next = db.prepare(`select * from a2_events
-               where session_id = ? and processed_at is null
-               order by idx limit 1`).get(sessionId);
-				if (!next || next.failed_at !== null || maxIndex !== void 0 && Number(next.idx) > maxIndex) return { outcome: "settled" };
 				const now = clock.now().getTime();
-				const current = db.prepare("select holder, expires_at from a2_leases where session_id = ?").get(sessionId);
-				if (current && Number(current.expires_at) > now && current.holder !== holder) return { outcome: "busy" };
-				db.prepare(`insert into a2_leases (session_id, holder, expires_at) values (?, ?, ?)
-             on conflict (session_id) do update set
-               holder = excluded.holder,
-               expires_at = excluded.expires_at`).run(sessionId, holder, expiresAtMs ?? now + ttlMs);
-				const claimed = db.prepare(`update a2_events
-               set attempt_count = attempt_count + 1,
-                   first_claimed_at = coalesce(first_claimed_at, ?),
-                   last_claimed_at = ?
-               where session_id = ? and idx = ? and processed_at is null
-               returning *`).get(now, now, sessionId, next.idx);
-				if (!claimed) throw new TypeError(`no pending event at index ${String(next.idx)} in session '${sessionId}'`);
-				return {
-					outcome: "claimed",
-					event: toStored(claimed)
+				const expiresAt = expiresAtMs ?? now + ttlMs;
+				const exclusion = excludeIndexes.length === 0 ? "" : `and event.idx not in (${excludeIndexes.map(() => "?").join(", ")})`;
+				const eligible = db.prepare(`select event.idx
+                 from a2_events event
+                where event.session_id = ?
+                  and event.processed_at is null
+                  and event.failed_at is null
+                  and event.lane_ready = 1
+                  and (event.claim_expires_at is null or event.claim_expires_at <= ?)
+                  ${exclusion}
+                order by event.idx`).all(sessionId, now, ...excludeIndexes);
+				if (eligible.length > 0) {
+					const update = db.prepare(`update a2_events set
+                 attempt_count = attempt_count + 1,
+                 first_claimed_at = coalesce(first_claimed_at, ?),
+                 last_claimed_at = ?,
+                 claim_holder = ?,
+                 claim_expires_at = ?
+               where session_id = ? and idx = ?
+               returning *`);
+					return {
+						outcome: "claimed",
+						events: eligible.map((row) => {
+							const claimed = update.get(now, now, holder, expiresAt, sessionId, row.idx);
+							return toStored(claimed);
+						})
+					};
+				}
+				const active = db.prepare(`select min(claim_expires_at) as retry_at
+                 from a2_events
+                where session_id = ?
+                  and processed_at is null
+                  and failed_at is null
+                  and lane_ready = 1
+                  and claim_expires_at > ?`).get(sessionId, now);
+				return active.retry_at === null ? { outcome: "settled" } : {
+					outcome: "busy",
+					retryAt: new Date(Number(active.retry_at))
 				};
 			}));
 		},
-		async completeAndClaimNext({ sessionId, holder, completedIndex, attempt, maxIndex }) {
+		async renewClaims({ sessionId, holder, indexes, ttlMs, expiresAtMs }) {
+			if (indexes.length === 0) return [];
 			return wrap(() => tx(() => {
 				const now = clock.now().getTime();
-				if (!db.prepare(`update a2_events
-               set processed_at = ?, processed_by_attempt = ?
-               where session_id = ? and idx = ?
-                 and processed_at is null and attempt_count = ?
-               returning idx`).get(now, attempt, sessionId, completedIndex, attempt)) {
-					if (!db.prepare("select 1 from a2_events where session_id = ? and idx = ?").get(sessionId, completedIndex)) throw new TypeError(`no event at index ${completedIndex} in session '${sessionId}'`);
-					return { outcome: "superseded" };
+				const expiresAt = expiresAtMs ?? now + ttlMs;
+				const placeholders = indexes.map(() => "?").join(", ");
+				return db.prepare(`update a2_events set claim_expires_at = ?
+                where session_id = ?
+                  and idx in (${placeholders})
+                  and processed_at is null
+                  and failed_at is null
+                  and claim_holder = ?
+                  and claim_expires_at > ?
+                returning idx`).all(expiresAt, sessionId, ...indexes, holder, now).map((row) => Number(row.idx)).toSorted((a, b) => a - b);
+			}));
+		},
+		async completeAttempt({ sessionId, index, attempt, events }) {
+			return wrap(() => tx(() => {
+				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);
+				if (new Set(ids).size !== ids.length) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "returned event batch contains the same event id more than once");
+				if (parent.processed_at !== null) {
+					if (Number(parent.processed_by_attempt) !== attempt) return { outcome: "superseded" };
+					const returnedIds = parent.returned_event_ids === null ? null : JSON.parse(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 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");
+					return {
+						outcome: "completed",
+						events: idempotentReplay(events, ordered.map(toStored))
+					};
 				}
-				const next = db.prepare(`select * from a2_events
-               where session_id = ? and processed_at is null
-               order by idx limit 1`).get(sessionId);
-				if (!next || next.failed_at !== null || maxIndex !== void 0 && Number(next.idx) > maxIndex) return { outcome: "settled" };
-				const lease = db.prepare("select holder, expires_at from a2_leases where session_id = ?").get(sessionId);
-				if (!lease || lease.holder !== holder || Number(lease.expires_at) <= now) return { outcome: "busy" };
-				const claimed = db.prepare(`update a2_events
-               set attempt_count = attempt_count + 1,
-                   first_claimed_at = coalesce(first_claimed_at, ?),
-                   last_claimed_at = ?
-               where session_id = ? and idx = ? and processed_at is null
-               returning *`).get(now, now, sessionId, next.idx);
-				if (!claimed) throw new TypeError(`no pending event at index ${String(next.idx)} in session '${sessionId}'`);
+				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);
+				const now = clock.now().getTime();
+				db.prepare(`update a2_events set
+               processed_at = ?,
+               processed_by_attempt = ?,
+               returned_event_ids = ?,
+               lane_ready = 0,
+               claim_holder = null,
+               claim_expires_at = null
+             where session_id = ? and idx = ?`).run(now, attempt, JSON.stringify(ids), sessionId, index);
+				if (parent.lane !== null) promoteLaneHead.run(sessionId, sessionId, parent.lane);
 				return {
-					outcome: "claimed",
-					event: toStored(claimed)
+					outcome: "completed",
+					events: events.map((event, offset) => {
+						const id = event.id;
+						const childIndex = Number(status.max) + offset + 1;
+						const cause = {
+							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);
+						return toStored(db.prepare("select * from a2_events where session_id = ? and idx = ?").get(sessionId, childIndex));
+					})
 				};
 			}));
 		},
-		async markProcessed(sessionId, index) {
-			wrap(() => {
-				const { changes } = db.prepare(`update a2_events
-             set processed_at = coalesce(processed_at, ?)
-             where session_id = ? and idx = ?`).run(clock.now().getTime(), sessionId, index);
-				requireChange(changes, `no event at index ${index} in session '${sessionId}'`);
-			});
-		},
 		async failAttempt({ sessionId, index, attempt, error, maxFailures }) {
 			return wrap(() => tx(() => {
 				const current = db.prepare("select * from a2_events where session_id = ? and idx = ?").get(sessionId, index);
@@ -288,6 +388,14 @@ function sqlite(options = {}) {
 					outcome: "dead_lettered",
 					failureCount
 				};
+				if (current.claim_holder === null && current.last_failed_attempt !== null && Number(current.last_failed_attempt) === attempt) return {
+					outcome: "failed",
+					failureCount
+				};
+				if (current.claim_holder === null) return {
+					outcome: "superseded",
+					failureCount
+				};
 				const now = clock.now().getTime();
 				const nextFailureCount = failureCount + 1;
 				const deadLettered = nextFailureCount >= maxFailures;
@@ -296,7 +404,9 @@ function sqlite(options = {}) {
                last_error = ?,
                last_failed_at = ?,
                last_failed_attempt = ?,
-               failed_at = ?
+               failed_at = ?,
+               claim_holder = null,
+               claim_expires_at = null
              where session_id = ? and idx = ?`).run(nextFailureCount, error, now, attempt, deadLettered ? now : null, sessionId, index);
 				return {
 					outcome: deadLettered ? "dead_lettered" : "failed",
@@ -304,12 +414,6 @@ function sqlite(options = {}) {
 				};
 			}));
 		},
-		async markFailed(sessionId, index) {
-			wrap(() => {
-				const { changes } = db.prepare("update a2_events set failed_at = ? where session_id = ? and idx = ?").run(clock.now().getTime(), sessionId, index);
-				requireChange(changes, `no event at index ${index} in session '${sessionId}'`);
-			});
-		},
 		async readState(sessionId, reducerName) {
 			return wrap(() => {
 				const rows = db.prepare(`with snapshot as materialized (
@@ -322,12 +426,15 @@ function sqlite(options = {}) {
                     snapshot.state as snapshot_state,
                     null as session_id, null as idx, null as event_type,
                     null as payload, null as event_id, null as created_at,
-                    null as cause, null as processed_at,
-                    null as processed_by_attempt, null as first_claimed_at,
+                    null as cause, null as lane, null as lane_ready,
+                    null as processed_at,
+                    null as processed_by_attempt, null as returned_event_ids,
+                    null as first_claimed_at,
                     null as last_claimed_at, null as attempt_count,
                     null as failure_count, null as last_failed_at,
                     null as last_failed_attempt, null as last_error,
-                    null as failed_at
+                    null as failed_at, null as claim_holder,
+                    null as claim_expires_at
              from snapshot
              union all
              select 1 as row_order, 'event' as row_kind,
@@ -423,24 +530,6 @@ function sqlite(options = {}) {
 			});
 			return pollingStream(readAfter, opts?.startAt !== void 0 ? { startAt: opts.startAt } : {});
 		},
-		lease: {
-			async acquire({ sessionId, holder, ttlMs, expiresAtMs }) {
-				return wrap(() => tx(() => {
-					const now = clock.now().getTime();
-					const expiresAt = expiresAtMs ?? now + ttlMs;
-					const current = db.prepare("select * from a2_leases where session_id = ?").get(sessionId);
-					if (current && Number(current.expires_at) > now && current.holder !== holder) return false;
-					db.prepare(`insert into a2_leases (session_id, holder, expires_at) values (?, ?, ?)
-               on conflict (session_id) do update set holder = excluded.holder, expires_at = excluded.expires_at`).run(sessionId, holder, expiresAt);
-					return true;
-				}));
-			},
-			async release({ sessionId, holder }) {
-				wrap(() => {
-					db.prepare("delete from a2_leases where session_id = ? and holder = ?").run(sessionId, holder);
-				});
-			}
-		},
 		close() {
 			db.close();
 		}

package/dist/otel.d.ts

@@ -1,4 +1,4 @@
-import { i as A2Telemetry } from "./telemetry-C78al20p.js";
+import { i as A2Telemetry } from "./telemetry-Cso0qyHQ.js";
 import { Tracer } from "@opentelemetry/api";
 //#region src/otel.d.ts
 type OtelOptions = {

package/dist/otel.js

@@ -1,7 +1,7 @@
 import { SpanStatusCode, trace } from "@opentelemetry/api";
 //#region src/otel.ts
 /**
-* a2/otel — OpenTelemetry adapter for the A2Telemetry interface.
+* experimental-a2/otel — OpenTelemetry adapter for the A2Telemetry interface.
 *
 * Peer-depends on `@opentelemetry/api` (optional). Spans nest through
 * the active context, so with a context manager registered (any real

package/dist/react.d.ts

@@ -1,4 +1,4 @@
-import { i as EventDefs, r as ContractEvent, s as Reducer, t as AppendInput } from "./contract-DL8btVd9.js";
+import { a as EventDefs, c as Reducer, r as ContractEvent, t as AppendInput } from "./contract-C_3dIIEU.js";
 import { A2Client, Connection, PushResult } from "./client.js";
 import { ReactElement, ReactNode } from "react";
 //#region src/react.d.ts

package/dist/react.js

@@ -3,7 +3,7 @@ import { createClient } from "./client.js";
 import { createContext, createElement, useContext, useEffect, useMemo, useSyncExternalStore } from "react";
 //#region src/react.ts
 /**
-* a2/react — React bindings over a2/client.
+* experimental-a2/react — React bindings over experimental-a2/client.
 *
 * `createReact({ client })` is a factory (like createContext): call it
 * once in a `'use client'` module with a shared A2 client and export the

package/dist/recovery-vercel.d.ts

@@ -1,4 +1,4 @@
-import { i as Clock } from "./log-Dg1I8NRr.js";
+import { i as Clock } from "./log-ldf5g8Cx.js";
 import { A2Recovery } from "./server.js";
 //#region src/recovery-vercel.d.ts
 /**
@@ -47,7 +47,7 @@ type VercelQueuesOptions = {
   topic?: string;
   /**
    * Fallback delay when an arm does not supply an absolute due time.
-   * Core A2 arms lease windows explicitly. Default 5.
+   * Core A2 arms claim windows explicitly. Default 5.
    */
   delaySeconds?: number;
   /** Injectable transport (tests). Default: `@vercel/queue`. */

package/dist/recovery-vercel.js

@@ -1,15 +1,15 @@
-import { i as serverInternals, t as DRAIN_TIMINGS } from "./internal-Dm8Ejnud.js";
+import { i as serverInternals, t as DRAIN_TIMINGS } from "./internal-D6wNxTck.js";
 import { t as retryableLazy } from "./retryable-lazy-DZWmHpii.js";
 import { n as SYSTEM_CLOCK } from "./log-yJbXUf72.js";
 //#region src/recovery-vercel.ts
 /**
-* a2/recovery-vercel — queue-backed recovery over Vercel Queues.
+* experimental-a2/recovery-vercel — queue-backed recovery over Vercel Queues.
 *
 * `vercelQueues()` returns an `A2Recovery` (a2-implementation.md §9):
 *
 * - `arm` rounds the requested watchdog time up to a one-second slot.
 *   One message per `(contract, session, dueAt)` coalesces appends,
-*   lease renewals, and racing callbacks. `DuplicateMessageError` is
+*   claim renewals and racing callbacks. `DuplicateMessageError` is
 *   success because that due-time slot is already durable.
 * - `handler(...servers)` is the delivery route: look up the server for
 *   the contract named in the message and drain it. Settled drains ack;
@@ -36,7 +36,7 @@ const MIN_VISIBILITY_SECONDS = 30;
 const unsettledBackoffSeconds = (delaySeconds, deliveryCount) => Math.min(Math.max(delaySeconds * 2 ** Math.max(deliveryCount - 1, 0), MIN_VISIBILITY_SECONDS), 60);
 const vercelQueueTransport = async (delaySeconds) => {
 	const queue = await import("@vercel/queue").catch(() => {
-		throw new Error("a2/recovery-vercel needs the '@vercel/queue' package (optional peer dependency) — install it, or inject a transport");
+		throw new Error("experimental-a2/recovery-vercel needs the '@vercel/queue' package (optional peer dependency) — install it, or inject a transport");
 	});
 	return {
 		send: (topic, message, options) => queue.send(topic, message, options),
@@ -73,10 +73,10 @@ function vercelQueues(options = {}) {
 		}
 	};
 	const successorDueAt = (message) => {
-		const minimumDueAt = clock.now().getTime() + DRAIN_TIMINGS.leaseTtlMs + DRAIN_TIMINGS.recoveryGraceMs;
+		const minimumDueAt = clock.now().getTime() + DRAIN_TIMINGS.claimTtlMs + DRAIN_TIMINGS.recoveryGraceMs;
 		if (message.dueAt === void 0) return minimumDueAt;
-		const beats = Math.max(1, Math.ceil((minimumDueAt - message.dueAt) / DRAIN_TIMINGS.leaseHeartbeatMs));
-		return message.dueAt + beats * DRAIN_TIMINGS.leaseHeartbeatMs;
+		const beats = Math.max(1, Math.ceil((minimumDueAt - message.dueAt) / DRAIN_TIMINGS.claimHeartbeatMs));
+		return message.dueAt + beats * DRAIN_TIMINGS.claimHeartbeatMs;
 	};
 	return {
 		async arm({ contract, sessionId, dueAt }) {
@@ -97,11 +97,10 @@ function vercelQueues(options = {}) {
 					const nextDueAt = successorDueAt(message);
 					const result = internals ? await internals.recoveryDrain(message.sessionId, { recoveryDueAt: nextDueAt }) : {
 						...await server.drain(message.sessionId),
-						outcome: "unknown",
-						processed: 0
+						outcome: "unknown"
 					};
 					if (result.settled) return;
-					if (result.outcome === "busy" || result.outcome === "handed_off") {
+					if (result.outcome === "busy") {
 						if (result.recoveryArm) await result.recoveryArm;
 						else await sendWatchdog({
 							contract: message.contract,