experimental-a2 0.0.0 → 0.2.0

package/dist/log-postgres.js

@@ -1,10 +1,11 @@
 import { t as A2Error } from "./errors-BJRMd-h6.js";
 import { t as retryableLazy } from "./retryable-lazy-DZWmHpii.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";
 //#region src/log-postgres.ts
 /**
-* a2/log-postgres — postgres log backend (the production path).
+* experimental-a2/log-postgres — postgres log backend (the production path).
 *
 * Implements the A2Log interface over any client that speaks the tiny
 * `PostgresClient` shape below — a `pg` Pool matches it structurally
@@ -30,8 +31,11 @@ create table if not exists a2_events (
   event_id     text    not null,
   created_at   bigint  not null,
   cause        jsonb,
+  lane         text,
+  lane_ready   boolean not null default false,
   processed_at bigint,
   processed_by_attempt integer,
+  returned_event_ids jsonb,
   first_claimed_at bigint,
   last_claimed_at bigint,
   attempt_count integer not null default 0,
@@ -40,32 +44,22 @@ create table if not exists a2_events (
   last_failed_attempt integer,
   last_error   text,
   failed_at    bigint,
+  claim_holder text,
+  claim_expires_at bigint,
   primary key (session_id, idx)
 );
 
--- CREATE TABLE IF NOT EXISTS leaves an older A2 table untouched. Keep
--- additive lifecycle changes self-healing: an old warm deployment can recreate
--- its embedded schema after an operator drops the tables during a rollout.
-alter table a2_events add column if not exists cause jsonb;
-alter table a2_events add column if not exists processed_by_attempt integer;
-alter table a2_events add column if not exists first_claimed_at bigint;
-alter table a2_events add column if not exists last_claimed_at bigint;
-alter table a2_events
-  add column if not exists attempt_count integer not null default 0;
-alter table a2_events
-  add column if not exists failure_count integer not null default 0;
-alter table a2_events add column if not exists last_failed_at bigint;
-alter table a2_events add column if not exists last_failed_attempt integer;
-
 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 bigint not null
-);
+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 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 and processed_at is null and failed_at is null;
 
 create table if not exists a2_snapshots (
   session_id   text   not null,
@@ -82,9 +76,11 @@ const toCause = (raw) => {
 	if (raw === null || raw === void 0) return null;
 	const value = typeof raw === "string" ? JSON.parse(raw) : raw;
 	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) => ({
@@ -95,8 +91,10 @@ const toStored = (row) => ({
 	sessionId: row["session_id"],
 	createdAt: new Date(asNumber(row["created_at"])),
 	cause: toCause(row["cause"]),
+	lane: row["lane"] ?? null,
 	processedAt: toDate(row["processed_at"]),
 	processedByAttempt: row["processed_by_attempt"] === null || row["processed_by_attempt"] === void 0 ? null : asNumber(row["processed_by_attempt"]),
+	returnedEventIds: row["returned_event_ids"] === null || row["returned_event_ids"] === void 0 ? null : typeof row["returned_event_ids"] === "string" ? JSON.parse(row["returned_event_ids"]) : row["returned_event_ids"],
 	firstClaimedAt: toDate(row["first_claimed_at"]),
 	lastClaimedAt: toDate(row["last_claimed_at"]),
 	attemptCount: asNumber(row["attempt_count"]),
@@ -104,7 +102,9 @@ const toStored = (row) => ({
 	lastFailedAt: toDate(row["last_failed_at"]),
 	lastFailedAttempt: row["last_failed_attempt"] === null || row["last_failed_attempt"] === void 0 ? null : asNumber(row["last_failed_attempt"]),
 	lastError: row["last_error"] ?? null,
-	failedAt: toDate(row["failed_at"])
+	failedAt: toDate(row["failed_at"]),
+	claimHolder: row["claim_holder"] ?? null,
+	claimExpiresAt: toDate(row["claim_expires_at"])
 });
 const toEvent = (row) => ({
 	id: row["event_id"],
@@ -151,7 +151,7 @@ function postgres(options = {}) {
 			let c = options.client;
 			if (!c) {
 				c = new (await (import("pg").catch(() => {
-					throw new A2Error("LOG_NOT_CONFIGURED", "a2/log-postgres with a connectionString needs the 'pg' package (optional peer dependency) — install it, or inject a client");
+					throw new A2Error("LOG_NOT_CONFIGURED", "experimental-a2/log-postgres with a connectionString needs the 'pg' package (optional peer dependency) — install it, or inject a client");
 				}))).default.Pool({ connectionString: options.connectionString });
 				owned = c;
 			}
@@ -196,21 +196,48 @@ function postgres(options = {}) {
 	};
 	return {
 		async append(sessionId, events) {
-			if (events.length === 0) return [];
+			if (events.length === 0) return wrap(async () => {
+				const { rows } = await (await client()).query(`select exists(
+               select 1 from a2_events
+               where session_id = $1 and processed_at is null
+             ) as has_pending`, [sessionId]);
+				return {
+					events: [],
+					hasPending: rows[0]?.["has_pending"] === true
+				};
+			});
 			return wrap(() => withTx(async (query) => {
 				await query("select pg_advisory_xact_lock(hashtext($1))", [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 { rows: existing } = await query("select * from a2_events where event_id = any($1) order by idx", [suppliedIds]);
+					const { rows: existing } = await query(`select stored.*,
+                      exists(
+                        select 1 from a2_events pending
+                        where pending.session_id = $2
+                          and pending.processed_at is null
+                      ) as session_has_pending
+                 from a2_events stored
+                where stored.event_id = any($1)
+                order by stored.idx`, [suppliedIds, sessionId]);
 					if (existing.length > 0) {
 						const foreign = existing.find((row) => row["session_id"] !== sessionId);
 						if (foreign) throw new A2Error("PARTIAL_DUPLICATE_BATCH", `event id '${String(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: existing[0]?.["session_has_pending"] === true
+						};
 						throw new A2Error("PARTIAL_DUPLICATE_BATCH", `batch mixes ${existing.length} already-appended and ${events.length - existing.length} fresh events`);
 					}
 				}
-				const { rows: maxRows } = await query("select coalesce(max(idx), 0) as max from a2_events where session_id = $1", [sessionId]);
+				const { rows: maxRows } = await query(`select coalesce(max(idx), 0) as max,
+                    exists(
+                      select 1 from a2_events pending
+                      where pending.session_id = $1
+                        and pending.processed_at is null
+                    ) as session_has_pending
+               from a2_events
+              where session_id = $1`, [sessionId]);
 				const base = asNumber(maxRows[0]?.["max"]);
 				const now = clock.now().getTime();
 				const inserted = [];
@@ -220,15 +247,24 @@ function postgres(options = {}) {
 					const index = base + 1 + i;
 					await query(`insert into a2_events
                  (session_id, idx, event_type, payload, event_id, created_at,
-                  cause)
-               values ($1, $2, $3, $4::jsonb, $5, $6, $7::jsonb)`, [
+                  cause, lane, lane_ready, processed_at)
+               values (
+                 $1, $2, $3, $4::jsonb, $5, $6, $7::jsonb, $8,
+                 $8::text is null or not exists (
+                   select 1 from a2_events
+                    where session_id = $1 and lane = $8 and processed_at is null
+                 ),
+                 $9
+               )`, [
 						sessionId,
 						index,
 						e.type,
 						jsonb(e.payload),
 						id,
 						now,
-						e.cause ? jsonb(e.cause) : null
+						e.cause ? jsonb(e.cause) : null,
+						e.lane ?? null,
+						e.settled ? now : null
 					]);
 					inserted.push({
 						id,
@@ -238,8 +274,10 @@ function postgres(options = {}) {
 						sessionId,
 						createdAt: new Date(now),
 						cause: e.cause ? { ...e.cause } : null,
-						processedAt: null,
+						lane: e.lane ?? null,
+						processedAt: e.settled ? new Date(now) : null,
 						processedByAttempt: null,
+						returnedEventIds: null,
 						firstClaimedAt: null,
 						lastClaimedAt: null,
 						attemptCount: 0,
@@ -247,10 +285,15 @@ function postgres(options = {}) {
 						lastFailedAt: null,
 						lastFailedAttempt: null,
 						lastError: null,
-						failedAt: null
+						failedAt: null,
+						claimHolder: null,
+						claimExpiresAt: null
 					});
 				}
-				return inserted;
+				return {
+					events: inserted,
+					hasPending: maxRows[0]?.["session_has_pending"] === true || events.some((event) => event.settled !== true)
+				};
 			}));
 		},
 		async read(sessionId, opts) {
@@ -262,146 +305,176 @@ function postgres(options = {}) {
 					params.push(opts.afterIndex);
 					conditions.push(`idx > $${params.length}`);
 				}
-				if (opts?.unprocessedOnly) conditions.push("processed_at is null");
 				const { rows } = await c.query(`select * from a2_events where ${conditions.join(" and ")} order by idx`, params);
 				return rows.map(toStored);
 			});
 		},
-		async claimNext({ sessionId, holder, ttlMs, expiresAtMs, maxIndex }) {
-			return wrap(async () => {
-				const c = await client();
+		async claimAvailable({ sessionId, holder, ttlMs, expiresAtMs, excludeIndexes = [] }) {
+			return wrap(() => withTx(async (query) => {
 				const now = clock.now().getTime();
-				const expiresAt = expiresAtMs ?? now + ttlMs;
-				const { rows } = await c.query(`with head as materialized (
-             select e.* from a2_events e
-             where e.session_id = $1 and e.processed_at is null
-             order by e.idx limit 1 for update of e
-           ), eligible as materialized (
-             select * from head
-             where failed_at is null
-               and ($5::bigint is null or idx <= $5)
-           ), won as (
-             insert into a2_leases (session_id, holder, expires_at)
-             select $1, $2, $3 from eligible
-             on conflict (session_id) do update set
-               holder = excluded.holder,
-               expires_at = excluded.expires_at
-             where a2_leases.expires_at <= $4 or a2_leases.holder = $2
-             returning holder
-           ), claimed as (
-             update a2_events e set
-               attempt_count = e.attempt_count + 1,
-               first_claimed_at = coalesce(e.first_claimed_at, $4),
-               last_claimed_at = $4
-             from eligible, won
-             where e.session_id = $1
-               and e.idx = eligible.idx
-               and e.processed_at is null
-             returning e.*
-           )
-           select case
-             when exists (select 1 from claimed) then 'claimed'
-             when exists (select 1 from eligible) then 'busy'
-             else 'settled'
-           end as outcome, claimed.*
-           from (values (1)) as singleton(n)
-           left join claimed on true`, [
+				const { rows } = await query(`with eligible as materialized (
+               select event.idx
+                 from a2_events event
+                where event.session_id = $1
+                  and event.processed_at is null
+                  and event.failed_at is null
+                  and event.lane_ready
+                  and (event.claim_expires_at is null or event.claim_expires_at <= $2)
+                  and not (event.idx = any($5::bigint[]))
+                for update of event
+             )
+             update a2_events claimed set
+               attempt_count = claimed.attempt_count + 1,
+               first_claimed_at = coalesce(claimed.first_claimed_at, $2),
+               last_claimed_at = $2,
+               claim_holder = $3,
+               claim_expires_at = $4
+             from eligible
+             where claimed.session_id = $1 and claimed.idx = eligible.idx
+             returning claimed.*`, [
 					sessionId,
-					holder,
-					expiresAt,
 					now,
-					maxIndex ?? null
+					holder,
+					expiresAtMs ?? now + ttlMs,
+					[...excludeIndexes]
 				]);
-				const row = rows[0];
-				if (row["outcome"] === "claimed") return {
+				if (rows.length > 0) return {
 					outcome: "claimed",
-					event: toStored(row)
+					events: rows.map(toStored).toSorted((a, b) => a.index - b.index)
 				};
-				return { outcome: row["outcome"] };
-			});
+				const { rows: activeRows } = await query(`select min(claim_expires_at) as retry_at
+               from a2_events
+              where session_id = $1
+                and processed_at is null
+                and failed_at is null
+                and lane_ready
+                and claim_expires_at > $2`, [sessionId, now]);
+				const retryAt = activeRows[0]?.["retry_at"];
+				return retryAt === null || retryAt === void 0 ? { outcome: "settled" } : {
+					outcome: "busy",
+					retryAt: new Date(asNumber(retryAt))
+				};
+			}));
 		},
-		async completeAndClaimNext({ sessionId, holder, completedIndex, attempt, maxIndex }) {
+		async renewClaims({ sessionId, holder, indexes, ttlMs, expiresAtMs }) {
+			if (indexes.length === 0) return [];
 			return wrap(async () => {
 				const c = await client();
 				const now = clock.now().getTime();
-				const { rows } = await c.query(`with current as materialized (
-             select e.* from a2_events e
-             where e.session_id = $1 and e.idx = $3
-             for update of e
-           ), completed as (
-             update a2_events e set
-               processed_at = $5,
-               processed_by_attempt = $4
-             from current
-             where e.session_id = $1
-               and e.idx = $3
-               and current.processed_at is null
-               and current.attempt_count = $4
-             returning e.idx
-           ), head as materialized (
-             select e.* from a2_events e, completed
-             where e.session_id = $1
-               and e.idx > $3
-               and e.processed_at is null
-             order by e.idx limit 1 for update of e
-           ), eligible as materialized (
-             select * from head
-             where failed_at is null
-               and ($6::bigint is null or idx <= $6)
-           ), owned as materialized (
-             select l.session_id from a2_leases l, eligible
-             where l.session_id = $1
-               and l.holder = $2
-               and l.expires_at > $5
-             for update of l
-           ), claimed as (
-             update a2_events e set
-               attempt_count = e.attempt_count + 1,
-               first_claimed_at = coalesce(e.first_claimed_at, $5),
-               last_claimed_at = $5
-             from eligible, owned
-             where e.session_id = $1
-               and e.idx = eligible.idx
-               and e.processed_at is null
-             returning e.*
-           )
-           select case
-             when not exists (select 1 from current) then 'missing'
-             when not exists (select 1 from completed) then 'superseded'
-             when exists (select 1 from claimed) then 'claimed'
-             when not exists (select 1 from eligible) then 'settled'
-             else 'busy'
-           end as outcome, claimed.*
-           from (values (1)) as singleton(n)
-           left join claimed on true`, [
+				const expiresAt = expiresAtMs ?? now + ttlMs;
+				const { rows } = await c.query(`update a2_events set claim_expires_at = $1
+            where session_id = $2
+              and idx = any($3::bigint[])
+              and processed_at is null
+              and failed_at is null
+              and claim_holder = $4
+              and claim_expires_at > $5
+            returning idx`, [
+					expiresAt,
 					sessionId,
+					indexes,
 					holder,
-					completedIndex,
-					attempt,
-					now,
-					maxIndex ?? null
+					now
 				]);
-				const row = rows[0];
-				if (row["outcome"] === "missing") throw new TypeError(`no event at index ${completedIndex} in session '${sessionId}'`);
-				if (row["outcome"] === "claimed") return {
-					outcome: "claimed",
-					event: toStored(row)
-				};
-				return { outcome: row["outcome"] };
+				return rows.map((row) => asNumber(row["idx"])).toSorted((a, b) => a - b);
 			});
 		},
-		async markProcessed(sessionId, index) {
-			await wrap(async () => {
-				const { rows } = await (await client()).query(`update a2_events
-           set processed_at = coalesce(processed_at, $1)
-           where session_id = $2 and idx = $3
-           returning idx`, [
-					clock.now().getTime(),
+		async completeAttempt({ sessionId, index, attempt, events }) {
+			return wrap(() => withTx(async (query) => {
+				const { rows: parentRows } = await query(`select * from a2_events
+              where session_id = $1 and idx = $2
+              for update`, [sessionId, index]);
+				const parent = parentRows[0];
+				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 (asNumber(parent["processed_by_attempt"]) !== attempt) return { outcome: "superseded" };
+					const returnedIds = parent["returned_event_ids"] === null || parent["returned_event_ids"] === void 0 ? null : typeof parent["returned_event_ids"] === "string" ? JSON.parse(parent["returned_event_ids"]) : 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");
+					if (events.length === 0) return {
+						outcome: "completed",
+						events: []
+					};
+					const { rows: existing } = await query(`select * from a2_events
+                where event_id = any($1::text[])`, [ids]);
+					const byId = new Map(existing.map((row) => [row["event_id"], row]));
+					const ordered = ids.map((id) => byId.get(id));
+					if (ordered.some((row) => {
+						const cause = row ? toCause(row["cause"]) : null;
+						return !row || row["session_id"] !== sessionId || cause?.index !== index || 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))
+					};
+				}
+				if (asNumber(parent["attempt_count"]) !== attempt || parent["claim_holder"] === null || parent["claim_holder"] === void 0 || parent["failed_at"] !== null) return { outcome: "superseded" };
+				await query("select pg_advisory_xact_lock(hashtext($1))", [sessionId]);
+				if (ids.length > 0) {
+					const { rows: existing } = await query("select event_id from a2_events where event_id = any($1::text[])", [ids]);
+					if (existing.length > 0) throw new A2Error("PARTIAL_DUPLICATE_BATCH", "returned event batch contains an already-appended event id");
+				}
+				const { rows: maxRows } = await query("select coalesce(max(idx), 0) as max from a2_events where session_id = $1", [sessionId]);
+				const base = asNumber(maxRows[0]?.["max"]);
+				const now = clock.now().getTime();
+				const inserted = [];
+				for (let offset = 0; offset < events.length; offset += 1) {
+					const event = events[offset];
+					const { rows } = await query(`insert into a2_events
+                 (session_id, idx, event_type, payload, event_id, created_at,
+                  cause, lane, lane_ready, processed_at)
+               values (
+                 $1, $2, $3, $4::jsonb, $5, $6, $7::jsonb, $8,
+                 $8::text is null or not exists (
+                   select 1 from a2_events
+                    where session_id = $1 and lane = $8 and processed_at is null
+                 ),
+                 $9
+               )
+               returning *`, [
+						sessionId,
+						base + offset + 1,
+						event.type,
+						jsonb(event.payload),
+						event.id,
+						now,
+						jsonb({
+							index,
+							attempt
+						}),
+						event.lane ?? null,
+						event.settled ? now : null
+					]);
+					inserted.push(toStored(rows[0]));
+				}
+				await query(`update a2_events set
+               processed_at = $1,
+               processed_by_attempt = $2,
+               returned_event_ids = $5::jsonb,
+               lane_ready = false,
+               claim_holder = null,
+               claim_expires_at = null
+             where session_id = $3 and idx = $4`, [
+					now,
+					attempt,
 					sessionId,
-					index
+					index,
+					jsonb(ids)
 				]);
-				if (rows.length === 0) throw new TypeError(`no event at index ${index} in session '${sessionId}'`);
-			});
+				const parentLane = parent["lane"] ?? null;
+				if (parentLane !== null) await query(`update a2_events set lane_ready = true
+                where session_id = $1
+                  and idx = (
+                    select idx from a2_events
+                     where session_id = $1 and lane = $2 and processed_at is null
+                     order by idx limit 1
+                  )`, [sessionId, parentLane]);
+				return {
+					outcome: "completed",
+					events: inserted
+				};
+			}));
 		},
 		async failAttempt({ sessionId, index, attempt, error, maxFailures }) {
 			return wrap(async () => {
@@ -418,13 +491,16 @@ function postgres(options = {}) {
                failed_at = case
                  when e.failure_count + 1 >= $5 then $6
                  else e.failed_at
-               end
+               end,
+               claim_holder = null,
+               claim_expires_at = null
              from current
              where e.session_id = $1
                and e.idx = $2
                and current.processed_at is null
                and current.failed_at is null
                and current.attempt_count = $3
+               and current.claim_holder is not null
              returning e.failure_count, e.failed_at
            )
            select case
@@ -440,6 +516,10 @@ function postgres(options = {}) {
              when exists (
                select 1 from current where failed_at is not null
              ) then 'dead_lettered'
+             when exists (
+               select 1 from current
+                where claim_holder is null and last_failed_attempt = $3
+             ) then 'failed'
              else 'superseded'
            end as outcome,
            coalesce(
@@ -461,16 +541,6 @@ function postgres(options = {}) {
 				};
 			});
 		},
-		async markFailed(sessionId, index) {
-			await wrap(async () => {
-				const { rows } = await (await client()).query("update a2_events set failed_at = $1 where session_id = $2 and idx = $3 returning idx", [
-					clock.now().getTime(),
-					sessionId,
-					index
-				]);
-				if (rows.length === 0) throw new TypeError(`no event at index ${index} in session '${sessionId}'`);
-			});
-		},
 		async readState(sessionId, reducerName) {
 			return wrap(async () => {
 				const { rows } = await (await client()).query(`with snapshot as materialized (
@@ -590,33 +660,6 @@ function postgres(options = {}) {
 			});
 			return pollingStream(readAfter, opts?.startAt !== void 0 ? { startAt: opts.startAt } : {});
 		},
-		lease: {
-			async acquire({ sessionId, holder, ttlMs, expiresAtMs }) {
-				return wrap(async () => {
-					const c = await client();
-					const now = clock.now().getTime();
-					const expiresAt = expiresAtMs ?? now + ttlMs;
-					const { rows } = await c.query(`insert into a2_leases (session_id, holder, expires_at)
-             values ($1, $2, $3)
-             on conflict (session_id) do update set
-               holder = excluded.holder,
-               expires_at = excluded.expires_at
-             where a2_leases.expires_at <= $4 or a2_leases.holder = $2
-             returning holder`, [
-						sessionId,
-						holder,
-						expiresAt,
-						now
-					]);
-					return rows.length === 1;
-				});
-			},
-			async release({ sessionId, holder }) {
-				await wrap(async () => {
-					await (await client()).query("delete from a2_leases where session_id = $1 and holder = $2", [sessionId, holder]);
-				});
-			}
-		},
 		async close() {
 			const current = connection.peek();
 			if (!current) return;

package/dist/log-redis.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-redis.d.ts
 /**
  * The minimal client this backend needs — `ioredis` matches it