@valentinkolb/sync 2.0.4 → 2.1.0

package/index.js

@@ -1,12 +1,16 @@
 // @bun
 var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
@@ -189,6 +193,91 @@ var mutex = (config) => {
 // src/queue.ts
 var {redis: redis3, RedisClient } = globalThis.Bun;
 import { randomUUID } from "crypto";
+
+// src/retry.ts
+var {sleep: sleep2 } = globalThis.Bun;
+var asError = (error) => error instanceof Error ? error : new Error(String(error));
+var createAbortError = () => {
+  const error = new Error("retry aborted");
+  error.name = "AbortError";
+  return error;
+};
+var parseCode = (error) => {
+  if (!error || typeof error !== "object")
+    return "";
+  const code = error.code;
+  return typeof code === "string" ? code.toUpperCase() : "";
+};
+var isRetryableTransportError = (error) => {
+  const code = parseCode(error);
+  if (code === "ECONNRESET" || code === "ETIMEDOUT" || code === "ECONNREFUSED" || code === "ENOTFOUND" || code === "EPIPE" || code === "EHOSTUNREACH" || code === "ECONNABORTED") {
+    return true;
+  }
+  const message = asError(error).message.toLowerCase();
+  return message.includes("econnreset") || message.includes("etimedout") || message.includes("connection") || message.includes("socket") || message.includes("broken pipe") || message.includes("network") || message.includes("loading") || message.includes("tryagain") || message.includes("clusterdown");
+};
+var DEFAULT_RETRY_OPTIONS = {
+  attempts: 8,
+  minDelayMs: 100,
+  maxDelayMs: 2000,
+  factor: 2,
+  jitter: 0.2,
+  retryIf: isRetryableTransportError
+};
+var computeDelayMs = (attempt, opts) => {
+  const base = opts.minDelayMs * opts.factor ** Math.max(0, attempt - 1);
+  const capped = Math.min(opts.maxDelayMs, base);
+  const spread = capped * opts.jitter;
+  const jittered = capped + (Math.random() * 2 - 1) * spread;
+  return Math.max(0, Math.floor(jittered));
+};
+var sleepWithSignal = async (delayMs, signal) => {
+  if (delayMs <= 0)
+    return;
+  if (!signal) {
+    await sleep2(delayMs);
+    return;
+  }
+  if (signal.aborted)
+    throw createAbortError();
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, delayMs);
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+      reject(createAbortError());
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+};
+var retry = async (fn, opts = {}) => {
+  const attempts = Math.max(1, opts.attempts ?? DEFAULT_RETRY_OPTIONS.attempts);
+  const minDelayMs = Math.max(0, opts.minDelayMs ?? DEFAULT_RETRY_OPTIONS.minDelayMs);
+  const maxDelayMs = Math.max(minDelayMs, opts.maxDelayMs ?? DEFAULT_RETRY_OPTIONS.maxDelayMs);
+  const factor = Math.max(1, opts.factor ?? DEFAULT_RETRY_OPTIONS.factor);
+  const jitter = Math.min(1, Math.max(0, opts.jitter ?? DEFAULT_RETRY_OPTIONS.jitter));
+  const retryIf = opts.retryIf ?? DEFAULT_RETRY_OPTIONS.retryIf;
+  for (let attempt = 1;attempt <= attempts; attempt++) {
+    if (opts.signal?.aborted)
+      throw createAbortError();
+    try {
+      return await fn(attempt);
+    } catch (error) {
+      if (attempt >= attempts)
+        throw error;
+      if (!retryIf(error))
+        throw error;
+      const delayMs = computeDelayMs(attempt, { minDelayMs, maxDelayMs, factor, jitter });
+      await sleepWithSignal(delayMs, opts.signal);
+    }
+  }
+  throw new Error("unreachable retry state");
+};
+
+// src/queue.ts
 var DAY_MS = 24 * 60 * 60 * 1000;
 var DEFAULT_PREFIX3 = "sync:queue";
 var DEFAULT_TENANT = "default";
@@ -485,7 +574,7 @@ var TOUCH_SCRIPT = `
   return 1
 `;
 var textEncoder = new TextEncoder;
-var asError = (error) => error instanceof Error ? error : new Error(String(error));
+var asError2 = (error) => error instanceof Error ? error : new Error(String(error));
 var safeClose = (client) => {
   if (!client.connected)
     return;
@@ -576,7 +665,7 @@ var queue = (config) => {
         } catch (error) {
           if (cfg.signal.aborted)
             return null;
-          throw asError(error);
+          throw asError2(error);
         } finally {
           cfg.signal.removeEventListener("abort", onAbort);
           safeClose(client);
@@ -588,7 +677,7 @@ var queue = (config) => {
         return typeof popped === "string" ? popped : null;
       } catch (error) {
         resetBlockingClient();
-        throw asError(error);
+        throw asError2(error);
       }
     };
     const recv = async (recvCfg = {}) => {
@@ -607,7 +696,7 @@ var queue = (config) => {
           messageId = await popMessageId(keys, { wait, timeoutMs, signal: recvCfg.signal });
         } catch (error) {
           if (!wait)
-            throw asError(error);
+            throw asError2(error);
           continue;
         }
         if (!messageId)
@@ -683,7 +772,11 @@ var queue = (config) => {
       const wait = streamCfg.wait ?? true;
       try {
         while (!streamCfg.signal?.aborted) {
-          const message = await recv(streamCfg);
+          const message = wait ? await retry(async () => await recv(streamCfg), {
+            attempts: Number.POSITIVE_INFINITY,
+            signal: streamCfg.signal,
+            retryIf: isRetryableTransportError
+          }) : await recv(streamCfg);
           if (message) {
             yield message;
             continue;
@@ -827,7 +920,7 @@ var PUB_SCRIPT = `
 `;
 var ENSURED_GROUPS_MAX = 1e4;
 var textEncoder2 = new TextEncoder;
-var asError2 = (error) => error instanceof Error ? error : new Error(String(error));
+var asError3 = (error) => error instanceof Error ? error : new Error(String(error));
 var safeClose2 = (client) => {
   if (!client.connected)
     return;
@@ -855,7 +948,7 @@ var blockingReadWithTemporaryClient = async (command, args, signal) => {
   } catch (error) {
     if (signal?.aborted)
       return null;
-    throw asError2(error);
+    throw asError3(error);
   } finally {
     if (signal)
       signal.removeEventListener("abort", onAbort);
@@ -878,7 +971,7 @@ var topic = (config) => {
     try {
       await redis4.send("XGROUP", ["CREATE", key, group, "0", "MKSTREAM"]);
     } catch (error) {
-      const message = asError2(error).message;
+      const message = asError3(error).message;
       if (!message.includes("BUSYGROUP"))
         throw error;
     }
@@ -953,7 +1046,7 @@ var topic = (config) => {
         if (signal?.aborted)
           return null;
         resetBlockingClient();
-        throw asError2(error);
+        throw asError3(error);
       } finally {
         if (signal)
           signal.removeEventListener("abort", onAbort);
@@ -1009,7 +1102,11 @@ var topic = (config) => {
       const wait = streamCfg.wait ?? true;
       try {
         while (!streamCfg.signal?.aborted) {
-          const message = await recv(streamCfg);
+          const message = wait ? await retry(async () => await recv(streamCfg), {
+            attempts: Number.POSITIVE_INFINITY,
+            signal: streamCfg.signal,
+            retryIf: isRetryableTransportError
+          }) : await recv(streamCfg);
           if (message) {
             yield message;
             continue;
@@ -1049,15 +1146,19 @@ var topic = (config) => {
     let cursor = liveCfg.after ?? "$";
     try {
       while (!liveCfg.signal?.aborted) {
-        const result = liveCfg.signal ? await blockingReadWithTemporaryClient("XREAD", ["COUNT", "1", "BLOCK", timeoutMs.toString(), "STREAMS", key, cursor], liveCfg.signal) : await (async () => {
+        const result = await retry(async () => liveCfg.signal ? await blockingReadWithTemporaryClient("XREAD", ["COUNT", "1", "BLOCK", timeoutMs.toString(), "STREAMS", key, cursor], liveCfg.signal) : await (async () => {
           try {
             const client = await ensureBlockingClient();
             return await client.send("XREAD", ["COUNT", "1", "BLOCK", timeoutMs.toString(), "STREAMS", key, cursor]);
           } catch (error) {
             resetBlockingClient();
-            throw asError2(error);
+            throw asError3(error);
           }
-        })();
+        })(), {
+          attempts: Number.POSITIVE_INFINITY,
+          signal: liveCfg.signal,
+          retryIf: isRetryableTransportError
+        });
         const entry = parseFirstStreamEntry(result);
         if (!entry)
           continue;
@@ -1088,7 +1189,7 @@ var topic = (config) => {
   };
 };
 // src/job.ts
-var {redis: redis5 } = globalThis.Bun;
+var {redis: redis5, sleep: sleep3 } = globalThis.Bun;
 
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -14672,6 +14773,43 @@ var DEFAULT_LEASE_MS2 = 30000;
 var DEFAULT_WORKER_RECV_TIMEOUT_MS = 1000;
 var DEFAULT_MAX_ATTEMPTS = 1;
 var DEFAULT_STATE_RETENTION_MS = 7 * DAY_MS3;
+var FINALIZE_STATE_SCRIPT = `
+  local key = KEYS[1]
+  local payload = ARGV[1]
+  local ttlMs = tonumber(ARGV[2])
+
+  local raw = redis.call("GET", key)
+  if not raw then return 0 end
+
+  local ok, state = pcall(cjson.decode, raw)
+  if not ok then return 0 end
+
+  local status = tostring(state.status or "")
+  if status == "cancelled" then return -1 end
+  if status == "completed" or status == "failed" or status == "timed_out" then return 0 end
+
+  redis.call("SET", key, payload, "PX", tostring(ttlMs))
+  return 1
+`;
+var CANCEL_STATE_SCRIPT = `
+  local key = KEYS[1]
+  local payload = ARGV[1]
+  local ttlMs = tonumber(ARGV[2])
+
+  local raw = redis.call("GET", key)
+  if not raw then return 0 end
+
+  local ok, state = pcall(cjson.decode, raw)
+  if not ok then return 0 end
+
+  local status = tostring(state.status or "")
+  if status == "completed" or status == "failed" or status == "timed_out" or status == "cancelled" then
+    return 0
+  end
+
+  redis.call("SET", key, payload, "PX", tostring(ttlMs))
+  return 1
+`;
 var activeWorkers = new Map;
 var workPayloadSchema = exports_external.object({
   id: exports_external.string(),
@@ -14731,150 +14869,211 @@ var job = (definition) => {
   const writeState = async (state, ttlMs = DEFAULT_STATE_RETENTION_MS) => {
     await redis5.send("SET", [stateKey(state.id), JSON.stringify(state), "PX", ttlMs.toString()]);
   };
+  const writeStateIfAbsent = async (state, ttlMs = DEFAULT_STATE_RETENTION_MS) => {
+    const result = await redis5.send("SET", [stateKey(state.id), JSON.stringify(state), "PX", ttlMs.toString(), "NX"]);
+    return result === "OK";
+  };
+  const writeFinalState = async (state, ttlMs = DEFAULT_STATE_RETENTION_MS) => {
+    const result = Number(await redis5.send("EVAL", [
+      FINALIZE_STATE_SCRIPT,
+      "1",
+      stateKey(state.id),
+      JSON.stringify(state),
+      String(ttlMs)
+    ]));
+    if (result === 1)
+      return "ok";
+    if (result === -1)
+      return "cancelled";
+    return "missing";
+  };
+  const writeCancelledState = async (state, ttlMs = DEFAULT_STATE_RETENTION_MS) => {
+    const result = Number(await redis5.send("EVAL", [
+      CANCEL_STATE_SCRIPT,
+      "1",
+      stateKey(state.id),
+      JSON.stringify(state),
+      String(ttlMs)
+    ]));
+    return result === 1;
+  };
   const startWorker = () => {
     if (activeWorkers.has(workerId))
       return;
     const workerAc = new AbortController;
     activeWorkers.set(workerId, workerAc);
     (async () => {
-      while (!workerAc.signal.aborted) {
-        const message = await workQueue.recv({
-          wait: true,
-          timeoutMs: DEFAULT_WORKER_RECV_TIMEOUT_MS,
-          leaseMs: DEFAULT_LEASE_MS2
-        });
-        if (!message)
-          continue;
-        const payload = message.data;
-        const state = await readState(payload.id);
-        if (!state) {
-          await message.ack();
-          continue;
-        }
-        if (state.status === "cancelled") {
-          await message.ack();
-          continue;
-        }
-        if (isTerminalStatus(state.status)) {
-          await message.ack();
-          continue;
-        }
-        const attempt = message.attempt;
-        const runId = message.deliveryId;
-        const startedAt = now();
-        await writeState({
-          ...state,
-          status: "running",
-          attempts: attempt,
-          updatedAt: startedAt
-        });
-        await emitEvent(payload.id, {
-          type: "started",
-          id: payload.id,
-          runId,
-          attempt,
-          ts: startedAt
-        });
-        await message.touch({ leaseMs: payload.leaseMs });
-        const jobAc = new AbortController;
-        const ctx = {
-          signal: jobAc.signal,
-          step: async (cfg) => {
-            return await Promise.resolve(cfg.run());
-          },
-          heartbeat: async (cfg) => {
-            await message.touch({ leaseMs: cfg?.leaseMs ?? payload.leaseMs });
-            await emitEvent(payload.id, {
-              type: "heartbeat",
-              id: payload.id,
-              runId,
-              ts: now()
-            });
-          }
-        };
-        try {
-          const inputParsed = definition.schema.safeParse(payload.input);
-          if (!inputParsed.success) {
-            throw inputParsed.error;
-          }
-          const processPromise = Promise.resolve(definition.process({ ctx, input: inputParsed.data }));
-          const result = await withTimeout(processPromise, payload.leaseMs);
-          const latest = await readState(payload.id);
-          if (latest?.status === "cancelled") {
-            jobAc.abort();
-            await message.ack();
-            continue;
-          }
-          const acked = await message.ack();
-          if (!acked)
-            continue;
-          const finishedAt = now();
-          await writeState({
-            id: payload.id,
-            status: "completed",
-            attempts: attempt,
-            updatedAt: finishedAt,
-            finishedAt,
-            result
-          });
-          await emitEvent(payload.id, {
-            type: "completed",
-            id: payload.id,
-            ts: finishedAt
-          });
-        } catch (error48) {
-          jobAc.abort();
-          const err = error48 instanceof Error ? error48 : new Error(String(error48));
-          const timedOut = err.name === "JobTimeoutError";
-          const canRetry = attempt < payload.maxAttempts;
-          if (canRetry) {
-            const delayMs = computeRetryDelay(payload.backoff, attempt);
-            const nextAt = now() + delayMs;
-            const nacked = await message.nack({
-              delayMs,
-              reason: timedOut ? "timed_out" : "error",
-              error: err.message
+      try {
+        while (!workerAc.signal.aborted) {
+          try {
+            const message = await retry(async () => await workQueue.recv({
+              wait: true,
+              timeoutMs: DEFAULT_WORKER_RECV_TIMEOUT_MS,
+              leaseMs: DEFAULT_LEASE_MS2
+            }), {
+              attempts: Number.POSITIVE_INFINITY,
+              signal: workerAc.signal,
+              retryIf: isRetryableTransportError
             });
-            if (!nacked)
+            if (!message)
               continue;
+            const payload = message.data;
+            let state = await readState(payload.id);
+            if (!state) {
+              await writeStateIfAbsent({
+                id: payload.id,
+                status: "submitted",
+                attempts: 0,
+                updatedAt: now()
+              });
+              state = await readState(payload.id);
+              if (!state) {
+                await message.nack({ delayMs: 250, reason: "state_missing_recover_failed" });
+                continue;
+              }
+            }
+            if (state.status === "cancelled") {
+              await message.ack();
+              continue;
+            }
+            if (isTerminalStatus(state.status)) {
+              await message.ack();
+              continue;
+            }
+            const attempt = message.attempt;
+            const runId = message.deliveryId;
+            const startedAt = now();
             await writeState({
-              id: payload.id,
-              status: "submitted",
+              ...state,
+              status: "running",
               attempts: attempt,
-              updatedAt: now()
+              updatedAt: startedAt
             });
             await emitEvent(payload.id, {
-              type: "retry",
+              type: "started",
               id: payload.id,
               runId,
-              nextAt,
-              reason: err.message,
-              ts: now()
+              attempt,
+              ts: startedAt
             });
-            continue;
-          }
-          const acked = await message.ack();
-          if (!acked)
-            continue;
-          const finishedAt = now();
-          const status = timedOut ? "timed_out" : "failed";
-          await writeState({
-            id: payload.id,
-            status,
-            attempts: attempt,
-            updatedAt: finishedAt,
-            finishedAt,
-            error: {
-              message: err.message,
-              code: timedOut ? "TIMEOUT" : undefined
+            await message.touch({ leaseMs: payload.leaseMs });
+            const jobAc = new AbortController;
+            const ctx = {
+              signal: jobAc.signal,
+              step: async (cfg) => {
+                return await Promise.resolve(cfg.run());
+              },
+              heartbeat: async (cfg) => {
+                await message.touch({ leaseMs: cfg?.leaseMs ?? payload.leaseMs });
+                await emitEvent(payload.id, {
+                  type: "heartbeat",
+                  id: payload.id,
+                  runId,
+                  ts: now()
+                });
+              }
+            };
+            try {
+              const inputParsed = definition.schema.safeParse(payload.input);
+              if (!inputParsed.success) {
+                throw inputParsed.error;
+              }
+              const processPromise = Promise.resolve(definition.process({ ctx, input: inputParsed.data }));
+              const result = await withTimeout(processPromise, payload.leaseMs);
+              const latest = await readState(payload.id);
+              if (latest?.status === "cancelled") {
+                jobAc.abort();
+                await message.ack();
+                continue;
+              }
+              const acked = await message.ack();
+              if (!acked)
+                continue;
+              const finishedAt = now();
+              const writeResult = await writeFinalState({
+                id: payload.id,
+                status: "completed",
+                attempts: attempt,
+                updatedAt: finishedAt,
+                finishedAt,
+                result
+              });
+              if (writeResult !== "ok")
+                continue;
+              await emitEvent(payload.id, {
+                type: "completed",
+                id: payload.id,
+                ts: finishedAt
+              });
+            } catch (error48) {
+              jobAc.abort();
+              const err = error48 instanceof Error ? error48 : new Error(String(error48));
+              const timedOut = err.name === "JobTimeoutError";
+              const canRetry = attempt < payload.maxAttempts;
+              if (canRetry) {
+                const delayMs = computeRetryDelay(payload.backoff, attempt);
+                const nextAt = now() + delayMs;
+                const nacked = await message.nack({
+                  delayMs,
+                  reason: timedOut ? "timed_out" : "error",
+                  error: err.message
+                });
+                if (!nacked)
+                  continue;
+                const latestState = await readState(payload.id);
+                if (latestState?.status === "cancelled")
+                  continue;
+                await writeState({
+                  id: payload.id,
+                  status: "submitted",
+                  attempts: attempt,
+                  updatedAt: now()
+                });
+                await emitEvent(payload.id, {
+                  type: "retry",
+                  id: payload.id,
+                  runId,
+                  nextAt,
+                  reason: err.message,
+                  ts: now()
+                });
+                continue;
+              }
+              const acked = await message.ack();
+              if (!acked)
+                continue;
+              const finishedAt = now();
+              const status = timedOut ? "timed_out" : "failed";
+              const writeResult = await writeFinalState({
+                id: payload.id,
+                status,
+                attempts: attempt,
+                updatedAt: finishedAt,
+                finishedAt,
+                error: {
+                  message: err.message,
+                  code: timedOut ? "TIMEOUT" : undefined
+                }
+              });
+              if (writeResult !== "ok")
+                continue;
+              await emitEvent(payload.id, {
+                type: "failed",
+                id: payload.id,
+                reason: err.message,
+                ts: finishedAt
+              });
             }
-          });
-          await emitEvent(payload.id, {
-            type: "failed",
-            id: payload.id,
-            reason: err.message,
-            ts: finishedAt
-          });
+          } catch {
+            if (workerAc.signal.aborted)
+              break;
+            await sleep3(25);
+          }
+        }
+      } finally {
+        const current = activeWorkers.get(workerId);
+        if (current === workerAc) {
+          activeWorkers.delete(workerId);
         }
       }
     })();
@@ -14902,7 +15101,9 @@ var job = (definition) => {
     const leaseMs = Math.max(1, cfg.leaseMs ?? definition.defaults?.leaseMs ?? DEFAULT_LEASE_MS2);
     const backoff = cfg.backoff ?? definition.defaults?.backoff;
     const delayMs = cfg.at !== undefined ? Math.max(0, cfg.at - now()) : Math.max(0, cfg.delayMs ?? 0);
+    const keyTtlMs = Math.max(1000, cfg.keyTtlMs ?? DEFAULT_STATE_RETENTION_MS);
     let jobId;
+    let isNewSubmission = true;
     if (cfg.key) {
       const idemKey = `${keys.idempotencyPrefix}:${cfg.key}`;
       const result = await redis5.send("EVAL", [
@@ -14910,16 +15111,21 @@ var job = (definition) => {
         "2",
         idemKey,
         keys.seq,
-        String(DEFAULT_STATE_RETENTION_MS)
+        String(keyTtlMs)
       ]);
       const arr = result;
       jobId = String(arr[0]);
-      if (Number(arr[1]) === 0)
-        return jobId;
+      isNewSubmission = Number(arr[1]) === 1;
     } else {
       const nextId = await redis5.incr(keys.seq);
       jobId = String(nextId);
     }
+    const submittedState = {
+      id: jobId,
+      status: "submitted",
+      attempts: 0,
+      updatedAt: now()
+    };
     const payload = {
       id: jobId,
       input: parsed.data,
@@ -14928,25 +15134,44 @@ var job = (definition) => {
       leaseMs,
       meta: cfg.meta
     };
-    await writeState({
-      id: jobId,
-      status: "submitted",
-      attempts: 0,
-      updatedAt: now()
-    });
-    await workQueue.send({
-      data: payload,
-      delayMs,
-      idempotencyKey: cfg.key,
-      idempotencyTtlMs: DEFAULT_STATE_RETENTION_MS,
-      meta: cfg.meta
-    });
-    await emitEvent(jobId, {
-      type: "submitted",
-      id: jobId,
-      ts: now()
-    });
-    return jobId;
+    if (!isNewSubmission) {
+      const existingState = await readState(jobId);
+      if (existingState)
+        return jobId;
+      await workQueue.send({
+        data: payload,
+        delayMs,
+        idempotencyKey: cfg.key,
+        idempotencyTtlMs: keyTtlMs,
+        meta: cfg.meta
+      });
+      const wrote = await writeStateIfAbsent(submittedState);
+      if (wrote) {
+        await emitEvent(jobId, {
+          type: "submitted",
+          id: jobId,
+          ts: now()
+        });
+      }
+      return jobId;
+    } else {
+      await workQueue.send({
+        data: payload,
+        delayMs,
+        idempotencyKey: cfg.key,
+        idempotencyTtlMs: keyTtlMs,
+        meta: cfg.meta
+      });
+      const wrote = await writeStateIfAbsent(submittedState);
+      if (wrote) {
+        await emitEvent(jobId, {
+          type: "submitted",
+          id: jobId,
+          ts: now()
+        });
+      }
+      return jobId;
+    }
   };
   const join = async (cfg) => {
     const state = await readState(cfg.id);
@@ -15014,7 +15239,7 @@ var job = (definition) => {
     if (isTerminalStatus(existing.status))
       return;
     const finishedAt = now();
-    await writeState({
+    const wrote = await writeCancelledState({
       id: cfg.id,
       status: "cancelled",
       attempts: existing.attempts,
@@ -15025,6 +15250,8 @@ var job = (definition) => {
         code: "CANCELLED"
       } : undefined
     });
+    if (!wrote)
+      return;
     await emitEvent(cfg.id, {
       type: "cancelled",
       id: cfg.id,
@@ -15049,18 +15276,1658 @@ var job = (definition) => {
   return {
     id: definition.id,
     submit,
+    validateInput: (input) => {
+      const parsed = definition.schema.safeParse(input);
+      if (!parsed.success)
+        throw parsed.error;
+    },
     join,
     cancel,
     events,
     stop
   };
 };
+// src/scheduler.ts
+var {redis: redis6, sleep: sleep4 } = globalThis.Bun;
+
+// src/internal/cron.ts
+var MAX_LOOKAHEAD_MINUTES = 5 * 366 * 24 * 60;
+var WEEKDAY_TO_NUM = {
+  Sun: 0,
+  Mon: 1,
+  Tue: 2,
+  Wed: 3,
+  Thu: 4,
+  Fri: 5,
+  Sat: 6
+};
+var zonedFormatterCache = new Map;
+var parsedCronCache = new Map;
+var getZonedFormatter = (tz) => {
+  const cached2 = zonedFormatterCache.get(tz);
+  if (cached2)
+    return cached2;
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone: tz,
+    hour12: false,
+    hourCycle: "h23",
+    minute: "2-digit",
+    hour: "2-digit",
+    day: "2-digit",
+    month: "2-digit",
+    year: "numeric",
+    weekday: "short"
+  });
+  zonedFormatterCache.set(tz, formatter);
+  return formatter;
+};
+var asInt = (value, fieldName) => {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed)) {
+    throw new Error(`invalid ${fieldName} value: ${value}`);
+  }
+  return parsed;
+};
+var normalizeDow = (value) => {
+  if (value === 7)
+    return 0;
+  return value;
+};
+var parseSegment = (segment, min, max, fieldName) => {
+  const [base, stepRaw] = segment.split("/");
+  const step = stepRaw === undefined ? 1 : asInt(stepRaw, `${fieldName} step`);
+  if (step <= 0)
+    throw new Error(`invalid ${fieldName} step: ${segment}`);
+  const resolvedBase = base ?? "*";
+  let start = min;
+  let end = max;
+  if (resolvedBase !== "*") {
+    if (resolvedBase.includes("-")) {
+      const [a, b] = resolvedBase.split("-");
+      if (a === undefined || b === undefined)
+        throw new Error(`invalid ${fieldName} range: ${segment}`);
+      start = asInt(a, fieldName);
+      end = asInt(b, fieldName);
+    } else {
+      start = asInt(resolvedBase, fieldName);
+      end = start;
+    }
+  }
+  if (fieldName === "day-of-week") {
+    const rawStart = start;
+    const rawEnd = end;
+    start = normalizeDow(start);
+    end = normalizeDow(end);
+    if (rawStart !== rawEnd && start > end) {
+      const wrappedValues = [];
+      for (let v = start;v <= max; v += step)
+        wrappedValues.push(v);
+      for (let v = min;v <= end; v += step)
+        wrappedValues.push(v);
+      return wrappedValues;
+    }
+  }
+  if (start < min || start > max || end < min || end > max || start > end) {
+    throw new Error(`out-of-range ${fieldName}: ${segment}`);
+  }
+  const values = [];
+  for (let v = start;v <= end; v += step)
+    values.push(v);
+  return values;
+};
+var parseField = (raw, min, max, fieldName) => {
+  if (raw === "*")
+    return { any: true, values: new Set };
+  const values = new Set;
+  for (const segment of raw.split(",")) {
+    const trimmed = segment.trim();
+    if (!trimmed)
+      throw new Error(`invalid ${fieldName} field: "${raw}"`);
+    for (const v of parseSegment(trimmed, min, max, fieldName)) {
+      values.add(fieldName === "day-of-week" ? normalizeDow(v) : v);
+    }
+  }
+  if (values.size === 0)
+    throw new Error(`invalid ${fieldName} field: "${raw}"`);
+  return { any: false, values };
+};
+var parseCron = (raw) => {
+  const cached2 = parsedCronCache.get(raw);
+  if (cached2)
+    return cached2;
+  const parts = raw.trim().split(/\s+/);
+  if (parts.length !== 5) {
+    throw new Error(`cron must have 5 fields (minute hour day-of-month month day-of-week), got: "${raw}"`);
+  }
+  const [minuteRaw, hourRaw, dayOfMonthRaw, monthRaw, dayOfWeekRaw] = parts;
+  const spec = {
+    minute: parseField(minuteRaw, 0, 59, "minute"),
+    hour: parseField(hourRaw, 0, 23, "hour"),
+    dayOfMonth: parseField(dayOfMonthRaw, 1, 31, "day-of-month"),
+    month: parseField(monthRaw, 1, 12, "month"),
+    dayOfWeek: parseField(dayOfWeekRaw, 0, 7, "day-of-week")
+  };
+  parsedCronCache.set(raw, spec);
+  if (parsedCronCache.size > 1000) {
+    const firstKey = parsedCronCache.keys().next().value;
+    if (firstKey)
+      parsedCronCache.delete(firstKey);
+  }
+  return spec;
+};
+var floorToMinute = (timestampMs) => {
+  return Math.floor(timestampMs / 60000) * 60000;
+};
+var toZonedParts = (timestampMs, tz) => {
+  const parts = getZonedFormatter(tz).formatToParts(new Date(timestampMs));
+  let minute = -1;
+  let hour = -1;
+  let dayOfMonth = -1;
+  let month = -1;
+  let dayOfWeek = -1;
+  for (const part of parts) {
+    if (part.type === "minute")
+      minute = Number(part.value);
+    else if (part.type === "hour")
+      hour = Number(part.value);
+    else if (part.type === "day")
+      dayOfMonth = Number(part.value);
+    else if (part.type === "month")
+      month = Number(part.value);
+    else if (part.type === "weekday")
+      dayOfWeek = WEEKDAY_TO_NUM[part.value] ?? -1;
+  }
+  if (minute < 0 || hour < 0 || dayOfMonth < 0 || month < 0 || dayOfWeek < 0) {
+    throw new Error(`failed to resolve zoned time parts for timezone "${tz}"`);
+  }
+  return { minute, hour, dayOfMonth, month, dayOfWeek };
+};
+var matchesField = (field, value) => field.any || field.values.has(value);
+var matchesDay = (spec, dayOfMonth, dayOfWeek) => {
+  const domAny = spec.dayOfMonth.any;
+  const dowAny = spec.dayOfWeek.any;
+  const domMatches = domAny || spec.dayOfMonth.values.has(dayOfMonth);
+  const dowMatches = dowAny || spec.dayOfWeek.values.has(dayOfWeek);
+  if (domAny && dowAny)
+    return true;
+  if (domAny)
+    return dowMatches;
+  if (dowAny)
+    return domMatches;
+  return domMatches || dowMatches;
+};
+var matchesCron = (spec, timestampMs, tz) => {
+  const p = toZonedParts(timestampMs, tz);
+  return matchesField(spec.minute, p.minute) && matchesField(spec.hour, p.hour) && matchesField(spec.month, p.month) && matchesDay(spec, p.dayOfMonth, p.dayOfWeek);
+};
+var nextCronTimestamp = (cron, tz, afterTimestampMs) => {
+  const spec = parseCron(cron);
+  let candidate = floorToMinute(afterTimestampMs) + 60000;
+  for (let i = 0;i < MAX_LOOKAHEAD_MINUTES; i++) {
+    if (matchesCron(spec, candidate, tz))
+      return candidate;
+    candidate += 60000;
+  }
+  throw new Error(`unable to find next cron execution within lookahead window for "${cron}" (${tz})`);
+};
+var assertValidTimeZone = (tz) => {
+  getZonedFormatter(tz);
+};
+
+// src/scheduler.ts
+var DEFAULT_PREFIX6 = "sync:scheduler";
+var DAY_MS4 = 24 * 60 * 60 * 1000;
+var DEFAULT_LEASE_MS3 = 5000;
+var DEFAULT_HEARTBEAT_MS = 500;
+var DEFAULT_TICK_MS = 500;
+var DEFAULT_BATCH_SIZE = 200;
+var DEFAULT_MAX_SUBMITS_PER_TICK = 500;
+var DEFAULT_SUBMIT_RETRIES = 3;
+var DEFAULT_SUBMIT_BACKOFF_BASE_MS = 100;
+var DEFAULT_SUBMIT_BACKOFF_MAX_MS = 2000;
+var DEFAULT_SCHEDULED_JOB_KEY_TTL_MS = 90 * DAY_MS4;
+var DEFAULT_DISPATCH_DLQ_MAX_ENTRIES = 5000;
+var DEFAULT_MISFIRE = "skip";
+var DEFAULT_MAX_CATCH_UP_RUNS = 100;
+var DEFAULT_MAX_CONSECUTIVE_DISPATCH_FAILURES = 5;
+var DEFAULT_STRICT_HANDLERS = true;
+var UPSERT_SCRIPT = `
+  local raw = redis.call("GET", KEYS[1])
+  local incomingRaw = ARGV[1]
+  local firstRunAt = tonumber(ARGV[2])
+  local scheduleId = ARGV[3]
+  local now = tonumber(ARGV[4])
+
+  local created = 1
+  local incoming = cjson.decode(incomingRaw)
+
+  if raw then
+    created = 0
+    local ok, existing = pcall(cjson.decode, raw)
+    if ok then
+      incoming.createdAt = tonumber(existing.createdAt) or incoming.createdAt
+
+      local shouldResetNext = tostring(existing.cron) ~= tostring(incoming.cron)
+        or tostring(existing.tz) ~= tostring(incoming.tz)
+
+      if shouldResetNext then
+        incoming.nextRunAt = firstRunAt
+        incoming.consecutiveDispatchFailures = 0
+        incoming.lastFailedSlotTs = nil
+        incoming.lastDispatchError = nil
+      else
+        incoming.nextRunAt = tonumber(existing.nextRunAt) or firstRunAt
+        incoming.consecutiveDispatchFailures = tonumber(existing.consecutiveDispatchFailures) or 0
+        incoming.lastFailedSlotTs = tonumber(existing.lastFailedSlotTs) or nil
+        incoming.lastDispatchError = existing.lastDispatchError
+      end
+    else
+      incoming.nextRunAt = firstRunAt
+      incoming.consecutiveDispatchFailures = 0
+      incoming.lastFailedSlotTs = nil
+      incoming.lastDispatchError = nil
+    end
+  else
+    incoming.nextRunAt = firstRunAt
+    incoming.consecutiveDispatchFailures = 0
+    incoming.lastFailedSlotTs = nil
+    incoming.lastDispatchError = nil
+  end
+
+  incoming.updatedAt = now
+
+  redis.call("SET", KEYS[1], cjson.encode(incoming))
+  redis.call("ZADD", KEYS[2], tostring(incoming.nextRunAt), scheduleId)
+  redis.call("SADD", KEYS[3], scheduleId)
+
+  if created == 1 then
+    return 1
+  end
+  return 2
+`;
+var UNREGISTER_SCRIPT = `
+  redis.call("DEL", KEYS[1])
+  redis.call("ZREM", KEYS[2], ARGV[1])
+  redis.call("SREM", KEYS[3], ARGV[1])
+  return 1
+`;
+var CLEANUP_BROKEN_SCRIPT = `
+  redis.call("DEL", KEYS[1])
+  redis.call("ZREM", KEYS[2], ARGV[1])
+  redis.call("SREM", KEYS[3], ARGV[1])
+  return 1
+`;
+var RESCHEDULE_CAS_SCRIPT = `
+  local epochKey = KEYS[4]
+  local raw = redis.call("GET", KEYS[1])
+  local scheduleId = ARGV[1]
+  local expectedEpoch = tonumber(ARGV[2])
+  local expectedNext = ARGV[3]
+  local nextRunAt = tonumber(ARGV[4])
+  local now = tonumber(ARGV[5])
+
+  local currentEpoch = tonumber(redis.call("GET", epochKey) or "0")
+  if currentEpoch ~= expectedEpoch then
+    return -2
+  end
+
+  if not raw then
+    redis.call("ZREM", KEYS[2], scheduleId)
+    redis.call("SREM", KEYS[3], scheduleId)
+    return 0
+  end
+
+  local ok, schedule = pcall(cjson.decode, raw)
+  if not ok then
+    redis.call("DEL", KEYS[1])
+    redis.call("ZREM", KEYS[2], scheduleId)
+    redis.call("SREM", KEYS[3], scheduleId)
+    return 0
+  end
+
+  if tonumber(schedule.nextRunAt) ~= tonumber(expectedNext) then
+    return -1
+  end
+
+  schedule.nextRunAt = nextRunAt
+  schedule.updatedAt = now
+
+  redis.call("SET", KEYS[1], cjson.encode(schedule))
+  redis.call("ZADD", KEYS[2], tostring(nextRunAt), scheduleId)
+  redis.call("SADD", KEYS[3], scheduleId)
+
+  return 1
+`;
+var PUSH_DISPATCH_DLQ_SCRIPT = `
+  redis.call("LPUSH", KEYS[1], ARGV[1])
+  redis.call("LTRIM", KEYS[1], "0", ARGV[2])
+  return 1
+`;
+var RECORD_FAILURE_CAS_SCRIPT = `
+  local epochKey = KEYS[4]
+  local raw = redis.call("GET", KEYS[1])
+  local scheduleId = ARGV[1]
+  local expectedEpoch = tonumber(ARGV[2])
+  local expectedNext = tonumber(ARGV[3])
+  local failedSlotTs = tonumber(ARGV[4])
+  local nextRunAt = tonumber(ARGV[5])
+  local failures = tonumber(ARGV[6])
+  local shouldAdvance = tonumber(ARGV[7])
+  local errorMessage = ARGV[8]
+  local now = tonumber(ARGV[9])
+
+  local currentEpoch = tonumber(redis.call("GET", epochKey) or "0")
+  if currentEpoch ~= expectedEpoch then
+    return -2
+  end
+
+  if not raw then
+    redis.call("ZREM", KEYS[2], scheduleId)
+    redis.call("SREM", KEYS[3], scheduleId)
+    return 0
+  end
+
+  local ok, schedule = pcall(cjson.decode, raw)
+  if not ok then
+    redis.call("DEL", KEYS[1])
+    redis.call("ZREM", KEYS[2], scheduleId)
+    redis.call("SREM", KEYS[3], scheduleId)
+    return 0
+  end
+
+  if tonumber(schedule.nextRunAt) ~= expectedNext then
+    return -1
+  end
+
+  schedule.consecutiveDispatchFailures = failures
+  schedule.lastFailedSlotTs = failedSlotTs
+  schedule.lastDispatchError = errorMessage
+  schedule.updatedAt = now
+
+  if shouldAdvance == 1 then
+    schedule.nextRunAt = nextRunAt
+    schedule.consecutiveDispatchFailures = 0
+  end
+
+  redis.call("SET", KEYS[1], cjson.encode(schedule))
+  redis.call("ZADD", KEYS[2], tostring(schedule.nextRunAt), scheduleId)
+  redis.call("SADD", KEYS[3], scheduleId)
+  return 1
+`;
+var asError4 = (error48) => error48 instanceof Error ? error48 : new Error(String(error48));
+var safeMetric = (onMetric, metric) => {
+  if (!onMetric)
+    return;
+  try {
+    onMetric(metric);
+  } catch {}
+};
+var parseSchedule = (raw) => {
+  if (!raw)
+    return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+var asInfo = (schedule) => ({
+  id: schedule.id,
+  cron: schedule.cron,
+  tz: schedule.tz,
+  misfire: schedule.misfire,
+  maxCatchUpRuns: schedule.maxCatchUpRuns,
+  jobId: schedule.jobId,
+  nextRunAt: schedule.nextRunAt,
+  createdAt: schedule.createdAt,
+  updatedAt: schedule.updatedAt
+});
+var computeDispatchPlan = (schedule, nowMs) => {
+  if (schedule.nextRunAt > nowMs)
+    return null;
+  if (schedule.misfire === "skip") {
+    return {
+      slots: [],
+      nextRunAt: nextCronTimestamp(schedule.cron, schedule.tz, nowMs)
+    };
+  }
+  if (schedule.misfire === "catch_up_one") {
+    return {
+      slots: [schedule.nextRunAt],
+      nextRunAt: nextCronTimestamp(schedule.cron, schedule.tz, nowMs)
+    };
+  }
+  const slots = [];
+  let cursor = schedule.nextRunAt;
+  const maxRuns = Math.max(1, schedule.maxCatchUpRuns);
+  while (cursor <= nowMs && slots.length < maxRuns) {
+    slots.push(cursor);
+    cursor = nextCronTimestamp(schedule.cron, schedule.tz, cursor);
+  }
+  return {
+    slots,
+    nextRunAt: cursor
+  };
+};
+var scheduler = (config2) => {
+  const prefix = config2.prefix ?? DEFAULT_PREFIX6;
+  const leaseMs = Math.max(500, config2.leader?.leaseMs ?? DEFAULT_LEASE_MS3);
+  const heartbeatMs = Math.max(100, config2.leader?.heartbeatMs ?? DEFAULT_HEARTBEAT_MS);
+  const tickMs = Math.max(50, config2.dispatch?.tickMs ?? DEFAULT_TICK_MS);
+  const batchSize = Math.max(1, config2.dispatch?.batchSize ?? DEFAULT_BATCH_SIZE);
+  const maxSubmitsPerTick = Math.max(1, config2.dispatch?.maxSubmitsPerTick ?? DEFAULT_MAX_SUBMITS_PER_TICK);
+  const submitRetries = Math.max(0, config2.dispatch?.submitRetries ?? DEFAULT_SUBMIT_RETRIES);
+  const submitBackoffBaseMs = Math.max(10, config2.dispatch?.submitBackoffBaseMs ?? DEFAULT_SUBMIT_BACKOFF_BASE_MS);
+  const submitBackoffMaxMs = Math.max(submitBackoffBaseMs, config2.dispatch?.submitBackoffMaxMs ?? DEFAULT_SUBMIT_BACKOFF_MAX_MS);
+  const scheduledJobKeyTtlMs = Math.max(60000, config2.dispatch?.scheduledJobKeyTtlMs ?? DEFAULT_SCHEDULED_JOB_KEY_TTL_MS);
+  const dlqMaxEntries = Math.max(1, config2.dispatch?.dlqMaxEntries ?? DEFAULT_DISPATCH_DLQ_MAX_ENTRIES);
+  const maxConsecutiveDispatchFailures = Math.max(1, config2.dispatch?.maxConsecutiveDispatchFailures ?? DEFAULT_MAX_CONSECUTIVE_DISPATCH_FAILURES);
+  const strictHandlers = config2.strictHandlers ?? DEFAULT_STRICT_HANDLERS;
+  const scheduleKey = (scheduleId) => `${prefix}:${config2.id}:schedule:${scheduleId}`;
+  const dueKey = `${prefix}:${config2.id}:due`;
+  const indexKey = `${prefix}:${config2.id}:index`;
+  const dispatchDlqKey = `${prefix}:${config2.id}:dispatch:dlq`;
+  const leaderEpochKey = `${prefix}:${config2.id}:leader:epoch`;
+  const leaderMutex = mutex({
+    id: `${config2.id}:leader`,
+    prefix: `${prefix}:leader`,
+    defaultTtl: leaseMs,
+    retryCount: 0
+  });
+  const jobsById = new Map;
+  const scheduleToJobId = new Map;
+  const metricsState = {
+    isLeader: false,
+    leaderEpoch: 0,
+    leaderChanges: 0,
+    dispatchSubmitted: 0,
+    dispatchFailed: 0,
+    dispatchRetried: 0,
+    dispatchSkipped: 0,
+    dispatchDlq: 0,
+    tickErrors: 0,
+    lastTickAt: null
+  };
+  let running = false;
+  let loopPromise = null;
+  let currentLeaderLock = null;
+  let currentLeaderEpoch = null;
+  let lastHeartbeatAt = 0;
+  const setLeader = (next, reason) => {
+    if (metricsState.isLeader === next)
+      return;
+    metricsState.isLeader = next;
+    metricsState.leaderChanges += 1;
+    if (next) {
+      safeMetric(config2.onMetric, { type: "leader_acquired", ts: Date.now() });
+      return;
+    }
+    metricsState.leaderEpoch = currentLeaderEpoch ?? metricsState.leaderEpoch;
+    safeMetric(config2.onMetric, { type: "leader_lost", ts: Date.now(), reason: reason ?? "stop" });
+  };
+  const tryAcquireLeadership = async () => {
+    if (currentLeaderLock)
+      return;
+    const acquired = await leaderMutex.acquire("active", leaseMs);
+    if (!acquired)
+      return;
+    currentLeaderLock = acquired;
+    currentLeaderEpoch = Number(await redis6.incr(leaderEpochKey));
+    metricsState.leaderEpoch = currentLeaderEpoch;
+    lastHeartbeatAt = Date.now();
+    setLeader(true);
+  };
+  const maintainLeadership = async () => {
+    if (!currentLeaderLock)
+      return;
+    const nowMs = Date.now();
+    if (nowMs - lastHeartbeatAt < heartbeatMs)
+      return;
+    const ok = await leaderMutex.extend(currentLeaderLock, leaseMs);
+    lastHeartbeatAt = nowMs;
+    if (ok) {
+      if (currentLeaderEpoch !== null) {
+        const latestEpoch = Number(await redis6.get(leaderEpochKey) ?? "0");
+        if (latestEpoch === currentLeaderEpoch)
+          return;
+      } else {
+        return;
+      }
+    }
+    currentLeaderLock = null;
+    currentLeaderEpoch = null;
+    setLeader(false, "extend_failed");
+  };
+  const relinquishLeadership = async () => {
+    if (!currentLeaderLock)
+      return;
+    try {
+      await leaderMutex.release(currentLeaderLock);
+    } catch {}
+    currentLeaderLock = null;
+    currentLeaderEpoch = null;
+    setLeader(false, "extend_failed");
+  };
+  const ensureLeadership = async (cfg) => {
+    if (!currentLeaderLock || currentLeaderEpoch === null)
+      return false;
+    const nowMs = Date.now();
+    const shouldRefresh = (cfg?.forceRefresh ?? false) || nowMs - lastHeartbeatAt >= heartbeatMs;
+    if (!shouldRefresh)
+      return metricsState.isLeader;
+    const ok = await leaderMutex.extend(currentLeaderLock, leaseMs);
+    lastHeartbeatAt = nowMs;
+    if (ok) {
+      const latestEpoch = Number(await redis6.get(leaderEpochKey) ?? "0");
+      if (latestEpoch === currentLeaderEpoch)
+        return true;
+    }
+    currentLeaderLock = null;
+    currentLeaderEpoch = null;
+    setLeader(false, "extend_failed");
+    return false;
+  };
+  const cleanupBrokenSchedule = async (scheduleId) => {
+    await redis6.send("EVAL", [
+      CLEANUP_BROKEN_SCRIPT,
+      "3",
+      scheduleKey(scheduleId),
+      dueKey,
+      indexKey,
+      scheduleId
+    ]);
+    scheduleToJobId.delete(scheduleId);
+  };
+  const rescheduleCas = async (schedule, nextRunAt, nowMs) => {
+    if (currentLeaderEpoch === null)
+      return "stale";
+    const result = await redis6.send("EVAL", [
+      RESCHEDULE_CAS_SCRIPT,
+      "4",
+      scheduleKey(schedule.id),
+      dueKey,
+      indexKey,
+      leaderEpochKey,
+      schedule.id,
+      String(currentLeaderEpoch),
+      String(schedule.nextRunAt),
+      String(nextRunAt),
+      String(nowMs)
+    ]);
+    const code = Number(result);
+    if (code === 1)
+      return "ok";
+    if (code === 0)
+      return "missing";
+    return "stale";
+  };
+  const pushDispatchDlq = async (cfg) => {
+    const payload = JSON.stringify({
+      ...cfg,
+      ts: Date.now(),
+      schedulerId: config2.id,
+      leaderEpoch: currentLeaderEpoch
+    });
+    await redis6.send("EVAL", [
+      PUSH_DISPATCH_DLQ_SCRIPT,
+      "1",
+      dispatchDlqKey,
+      payload,
+      String(dlqMaxEntries - 1)
+    ]);
+    metricsState.dispatchDlq += 1;
+    safeMetric(config2.onMetric, {
+      type: "dispatch_dlq",
+      ts: Date.now(),
+      scheduleId: cfg.scheduleId,
+      slotTs: cfg.slotTs,
+      message: cfg.message
+    });
+  };
+  const submitWithRetry = async (cfg) => {
+    await retry(async () => {
+      if (!await ensureLeadership({ forceRefresh: true })) {
+        throw new Error("leadership lost during dispatch");
+      }
+      return await cfg.jobHandle.submit({
+        input: cfg.schedule.input,
+        key: `${cfg.schedule.id}:${cfg.slotTs}`,
+        keyTtlMs: scheduledJobKeyTtlMs,
+        at: cfg.slotTs,
+        meta: {
+          ...cfg.schedule.meta ?? {},
+          scheduleId: cfg.schedule.id,
+          scheduleSlotTs: cfg.slotTs,
+          schedulerId: config2.id
+        }
+      });
+    }, {
+      attempts: submitRetries + 1,
+      minDelayMs: submitBackoffBaseMs,
+      maxDelayMs: submitBackoffMaxMs,
+      factor: 2,
+      jitter: 0.25,
+      retryIf: (error48) => {
+        const err = asError4(error48);
+        if (err.name === "ZodError")
+          return false;
+        if (err.message === "leadership lost during dispatch")
+          return false;
+        metricsState.dispatchRetried += 1;
+        return true;
+      }
+    });
+  };
+  const recordDispatchFailure = async (cfg) => {
+    if (currentLeaderEpoch === null)
+      return "stale";
+    const sameSlot = cfg.schedule.lastFailedSlotTs === cfg.failedSlotTs;
+    const failures = sameSlot ? cfg.schedule.consecutiveDispatchFailures + 1 : 1;
+    const shouldAdvance = cfg.deterministic || failures >= maxConsecutiveDispatchFailures;
+    const nextRunAt = shouldAdvance ? nextCronTimestamp(cfg.schedule.cron, cfg.schedule.tz, cfg.failedSlotTs) : cfg.schedule.nextRunAt;
+    const result = Number(await redis6.send("EVAL", [
+      RECORD_FAILURE_CAS_SCRIPT,
+      "4",
+      scheduleKey(cfg.schedule.id),
+      dueKey,
+      indexKey,
+      leaderEpochKey,
+      cfg.schedule.id,
+      String(currentLeaderEpoch),
+      String(cfg.schedule.nextRunAt),
+      String(cfg.failedSlotTs),
+      String(nextRunAt),
+      String(failures),
+      shouldAdvance ? "1" : "0",
+      cfg.message,
+      String(Date.now())
+    ]));
+    if (result === 1 && shouldAdvance) {
+      safeMetric(config2.onMetric, {
+        type: "dispatch_advanced_after_failures",
+        ts: Date.now(),
+        scheduleId: cfg.schedule.id,
+        slotTs: cfg.failedSlotTs,
+        failures
+      });
+    }
+    if (result === 1)
+      return "ok";
+    if (result === 0)
+      return "missing";
+    return "stale";
+  };
+  const dispatchDue = async () => {
+    const nowMs = Date.now();
+    const dueIds = await redis6.send("ZRANGEBYSCORE", [dueKey, "-inf", String(nowMs), "LIMIT", "0", String(batchSize)]);
+    if (!Array.isArray(dueIds) || dueIds.length === 0)
+      return;
+    let submitsRemaining = maxSubmitsPerTick;
+    for (const idRaw of dueIds) {
+      if (!await ensureLeadership())
+        break;
+      const scheduleId = String(idRaw);
+      const raw = await redis6.get(scheduleKey(scheduleId));
+      const schedule = parseSchedule(raw);
+      if (!schedule) {
+        await cleanupBrokenSchedule(scheduleId);
+        continue;
+      }
+      if (schedule.nextRunAt > nowMs) {
+        continue;
+      }
+      const plan = computeDispatchPlan(schedule, nowMs);
+      if (!plan)
+        continue;
+      const jobHandle = jobsById.get(schedule.jobId);
+      if (!jobHandle && plan.slots.length > 0) {
+        metricsState.dispatchSkipped += 1;
+        safeMetric(config2.onMetric, { type: "dispatch_skipped", ts: nowMs, scheduleId: schedule.id, reason: "missing_handler" });
+        if (strictHandlers) {
+          await relinquishLeadership();
+          break;
+        }
+        continue;
+      }
+      let submitFailed = false;
+      let submittedAny = false;
+      let lastSubmittedSlotTs = null;
+      for (const slotTs of plan.slots) {
+        if (submitsRemaining <= 0)
+          break;
+        if (!await ensureLeadership()) {
+          submitFailed = true;
+          break;
+        }
+        try {
+          await submitWithRetry({
+            jobHandle,
+            schedule,
+            slotTs
+          });
+          metricsState.dispatchSubmitted += 1;
+          submitsRemaining -= 1;
+          submittedAny = true;
+          lastSubmittedSlotTs = slotTs;
+          safeMetric(config2.onMetric, {
+            type: "dispatch_submitted",
+            ts: Date.now(),
+            scheduleId: schedule.id,
+            slotTs,
+            jobId: schedule.jobId
+          });
+        } catch (error48) {
+          submitFailed = true;
+          metricsState.dispatchFailed += 1;
+          const err = asError4(error48);
+          await pushDispatchDlq({
+            scheduleId: schedule.id,
+            slotTs,
+            message: err.message
+          });
+          await recordDispatchFailure({
+            schedule,
+            failedSlotTs: slotTs,
+            message: err.message,
+            deterministic: err.name === "ZodError"
+          });
+          safeMetric(config2.onMetric, {
+            type: "dispatch_failed",
+            ts: Date.now(),
+            scheduleId: schedule.id,
+            message: err.message
+          });
+          break;
+        }
+      }
+      if (submitFailed)
+        continue;
+      if (submitsRemaining <= 0) {
+        if (submittedAny && lastSubmittedSlotTs !== null) {
+          if (!await ensureLeadership({ forceRefresh: true }))
+            break;
+          const partialNextRunAt = nextCronTimestamp(schedule.cron, schedule.tz, lastSubmittedSlotTs);
+          const partialCas = await rescheduleCas(schedule, partialNextRunAt, Date.now());
+          if (partialCas !== "ok") {
+            metricsState.dispatchSkipped += 1;
+            safeMetric(config2.onMetric, {
+              type: "dispatch_skipped",
+              ts: Date.now(),
+              scheduleId: schedule.id,
+              reason: "cas_stale"
+            });
+          }
+          scheduleToJobId.set(schedule.id, schedule.jobId);
+        }
+        break;
+      }
+      if (!await ensureLeadership({ forceRefresh: true }))
+        break;
+      const cas = await rescheduleCas(schedule, plan.nextRunAt, Date.now());
+      if (cas !== "ok") {
+        metricsState.dispatchSkipped += 1;
+        safeMetric(config2.onMetric, {
+          type: "dispatch_skipped",
+          ts: Date.now(),
+          scheduleId: schedule.id,
+          reason: "cas_stale"
+        });
+      }
+      scheduleToJobId.set(schedule.id, schedule.jobId);
+    }
+  };
+  const loop = async () => {
+    while (running) {
+      try {
+        await tryAcquireLeadership();
+        await maintainLeadership();
+        if (currentLeaderLock) {
+          await dispatchDue();
+        }
+        metricsState.lastTickAt = Date.now();
+      } catch (error48) {
+        metricsState.tickErrors += 1;
+        safeMetric(config2.onMetric, {
+          type: "tick_error",
+          ts: Date.now(),
+          message: asError4(error48).message
+        });
+      }
+      await sleep4(tickMs);
+    }
+  };
+  const register = async (cfg) => {
+    const tz = cfg.tz ?? "UTC";
+    assertValidTimeZone(tz);
+    cfg.job.validateInput?.(cfg.input);
+    const nowMs = Date.now();
+    const misfire = cfg.misfire ?? DEFAULT_MISFIRE;
+    const maxCatchUpRuns = Math.max(1, cfg.maxCatchUpRuns ?? DEFAULT_MAX_CATCH_UP_RUNS);
+    const firstRunAt = nextCronTimestamp(cfg.cron, tz, nowMs);
+    const previous = parseSchedule(await redis6.get(scheduleKey(cfg.id)));
+    const stored = {
+      id: cfg.id,
+      cron: cfg.cron,
+      tz,
+      misfire,
+      maxCatchUpRuns,
+      jobId: cfg.job.id,
+      input: cfg.input,
+      meta: cfg.meta,
+      createdAt: nowMs,
+      updatedAt: nowMs,
+      nextRunAt: firstRunAt,
+      consecutiveDispatchFailures: 0
+    };
+    const upsertResult = Number(await redis6.send("EVAL", [
+      UPSERT_SCRIPT,
+      "3",
+      scheduleKey(cfg.id),
+      dueKey,
+      indexKey,
+      JSON.stringify(stored),
+      String(firstRunAt),
+      cfg.id,
+      String(nowMs)
+    ]));
+    const created = upsertResult === 1;
+    const updated = upsertResult === 2;
+    jobsById.set(cfg.job.id, cfg.job);
+    scheduleToJobId.set(cfg.id, cfg.job.id);
+    if (previous && previous.jobId !== cfg.job.id) {
+      let stillUsed = false;
+      for (const [sid, jid] of scheduleToJobId.entries()) {
+        if (sid !== cfg.id && jid === previous.jobId) {
+          stillUsed = true;
+          break;
+        }
+      }
+      if (!stillUsed)
+        jobsById.delete(previous.jobId);
+    }
+    safeMetric(config2.onMetric, {
+      type: "schedule_registered",
+      ts: Date.now(),
+      scheduleId: cfg.id,
+      created
+    });
+    if (updated && !created) {
+      safeMetric(config2.onMetric, {
+        type: "schedule_updated",
+        ts: Date.now(),
+        scheduleId: cfg.id
+      });
+    }
+    return { created, updated };
+  };
+  const unregister = async (cfg) => {
+    const jobId = scheduleToJobId.get(cfg.id);
+    await redis6.send("EVAL", [
+      UNREGISTER_SCRIPT,
+      "3",
+      scheduleKey(cfg.id),
+      dueKey,
+      indexKey,
+      cfg.id
+    ]);
+    safeMetric(config2.onMetric, {
+      type: "schedule_unregistered",
+      ts: Date.now(),
+      scheduleId: cfg.id
+    });
+    scheduleToJobId.delete(cfg.id);
+    if (jobId) {
+      let stillUsed = false;
+      for (const mappedJobId of scheduleToJobId.values()) {
+        if (mappedJobId === jobId) {
+          stillUsed = true;
+          break;
+        }
+      }
+      if (!stillUsed)
+        jobsById.delete(jobId);
+    }
+  };
+  const get = async (cfg) => {
+    const raw = await redis6.get(scheduleKey(cfg.id));
+    const parsed = parseSchedule(raw);
+    if (!parsed)
+      return null;
+    return asInfo(parsed);
+  };
+  const list = async () => {
+    const idsRaw = await redis6.send("SMEMBERS", [indexKey]);
+    if (!Array.isArray(idsRaw) || idsRaw.length === 0)
+      return [];
+    const ids = idsRaw.map((v) => String(v));
+    const values = await redis6.send("MGET", ids.map((id) => scheduleKey(id)));
+    if (!Array.isArray(values))
+      return [];
+    const out = [];
+    for (const raw of values) {
+      const parsed = parseSchedule(typeof raw === "string" ? raw : null);
+      if (!parsed)
+        continue;
+      out.push(asInfo(parsed));
+    }
+    out.sort((a, b) => a.id.localeCompare(b.id));
+    return out;
+  };
+  const start = () => {
+    if (running)
+      return;
+    running = true;
+    loopPromise = loop();
+  };
+  const stop = async () => {
+    if (!running)
+      return;
+    running = false;
+    await loopPromise;
+    loopPromise = null;
+    if (currentLeaderLock) {
+      try {
+        await leaderMutex.release(currentLeaderLock);
+      } catch {}
+      currentLeaderLock = null;
+      currentLeaderEpoch = null;
+    }
+    setLeader(false, "stop");
+  };
+  const metrics = () => ({ ...metricsState });
+  return {
+    id: config2.id,
+    start,
+    stop,
+    register,
+    unregister,
+    get,
+    list,
+    metrics
+  };
+};
+// src/ephemeral.ts
+var {redis: redis7, RedisClient: RedisClient3 } = globalThis.Bun;
+var DEFAULT_PREFIX7 = "sync:e";
+var DEFAULT_TENANT3 = "default";
+var DEFAULT_MAX_ENTRIES = 1e4;
+var DEFAULT_MAX_PAYLOAD_BYTES = 4 * 1024;
+var DEFAULT_EVENT_RETENTION_MS = 5 * 60 * 1000;
+var DEFAULT_EVENT_MAXLEN = 50000;
+var DEFAULT_TIMEOUT_MS2 = 30000;
+var DEFAULT_RECONCILE_BATCH_SIZE = 200;
+var DEFAULT_RECONCILE_INTERVAL_MS = 250;
+var MAX_RECONCILE_TENANTS = 1000;
+var MAX_KEY_BYTES = 512;
+var textEncoder3 = new TextEncoder;
+var UPSERT_SCRIPT2 = `
+  local now = tonumber(ARGV[1])
+  local ttlMs = tonumber(ARGV[2])
+  local dataRaw = ARGV[3]
+  local logicalKey = ARGV[4]
+  local maxEntries = tonumber(ARGV[5])
+  local trimMinId = ARGV[6]
+  local maxEventLen = tonumber(ARGV[7])
+
+  local ttlKey = KEYS[4] .. string.len(logicalKey) .. ":" .. logicalKey
+
+  local exists = redis.call("HEXISTS", KEYS[2], logicalKey)
+  if exists == 0 then
+    local count = tonumber(redis.call("HLEN", KEYS[2]))
+    if count >= maxEntries then
+      return "__ERR_CAPACITY__"
+    end
+  end
+
+  local decodeOk, data = pcall(cjson.decode, dataRaw)
+  if not decodeOk then
+    return "__ERR_PAYLOAD__"
+  end
+
+  local version = tostring(redis.call("INCR", KEYS[1]))
+  local updatedAt = now
+  local expiresAt = now + ttlMs
+
+  local entry = {
+    key = logicalKey,
+    data = data,
+    version = version,
+    updatedAt = updatedAt,
+    expiresAt = expiresAt,
+  }
+
+  local encoded = cjson.encode(entry)
+  redis.call("HSET", KEYS[2], logicalKey, encoded)
+  redis.call("ZADD", KEYS[3], tostring(expiresAt), logicalKey)
+  redis.call("SET", ttlKey, "1", "PX", tostring(ttlMs))
+
+  redis.call(
+    "XADD",
+    KEYS[5],
+    "*",
+    "type",
+    "upsert",
+    "key",
+    logicalKey,
+    "version",
+    version,
+    "updatedAt",
+    tostring(updatedAt),
+    "expiresAt",
+    tostring(expiresAt),
+    "payload",
+    dataRaw
+  )
+
+  if trimMinId ~= "" then
+    redis.call("XTRIM", KEYS[5], "MINID", "~", trimMinId)
+  end
+  if maxEventLen > 0 then
+    redis.call("XTRIM", KEYS[5], "MAXLEN", "~", tostring(maxEventLen))
+  end
+
+  return encoded
+`;
+var TOUCH_SCRIPT2 = `
+  local now = tonumber(ARGV[1])
+  local ttlMs = tonumber(ARGV[2])
+  local logicalKey = ARGV[3]
+  local trimMinId = ARGV[4]
+  local maxEventLen = tonumber(ARGV[5])
+
+  local ttlKey = KEYS[4] .. string.len(logicalKey) .. ":" .. logicalKey
+
+  local existingRaw = redis.call("HGET", KEYS[2], logicalKey)
+  if not existingRaw then
+    return nil
+  end
+
+  local decodeOk, existing = pcall(cjson.decode, existingRaw)
+  if not decodeOk then
+    redis.call("HDEL", KEYS[2], logicalKey)
+    redis.call("ZREM", KEYS[3], logicalKey)
+    redis.call("DEL", ttlKey)
+    return nil
+  end
+
+  local version = tostring(redis.call("INCR", KEYS[1]))
+  local expiresAt = now + ttlMs
+
+  existing.version = version
+  existing.updatedAt = now
+  existing.expiresAt = expiresAt
+
+  redis.call("HSET", KEYS[2], logicalKey, cjson.encode(existing))
+  redis.call("ZADD", KEYS[3], tostring(expiresAt), logicalKey)
+  redis.call("SET", ttlKey, "1", "PX", tostring(ttlMs))
+
+  redis.call(
+    "XADD",
+    KEYS[5],
+    "*",
+    "type",
+    "touch",
+    "key",
+    logicalKey,
+    "version",
+    version,
+    "expiresAt",
+    tostring(expiresAt)
+  )
+
+  if trimMinId ~= "" then
+    redis.call("XTRIM", KEYS[5], "MINID", "~", trimMinId)
+  end
+  if maxEventLen > 0 then
+    redis.call("XTRIM", KEYS[5], "MAXLEN", "~", tostring(maxEventLen))
+  end
+
+  return cjson.encode({ version = version, expiresAt = expiresAt })
+`;
+var REMOVE_SCRIPT = `
+  local now = tonumber(ARGV[1])
+  local logicalKey = ARGV[2]
+  local reason = ARGV[3]
+  local trimMinId = ARGV[4]
+  local maxEventLen = tonumber(ARGV[5])
+
+  local ttlKey = KEYS[4] .. string.len(logicalKey) .. ":" .. logicalKey
+
+  local existingRaw = redis.call("HGET", KEYS[2], logicalKey)
+  if not existingRaw then
+    return 0
+  end
+
+  redis.call("HDEL", KEYS[2], logicalKey)
+  redis.call("ZREM", KEYS[3], logicalKey)
+  redis.call("DEL", ttlKey)
+
+  local version = tostring(redis.call("INCR", KEYS[1]))
+  if reason ~= "" then
+    redis.call(
+      "XADD",
+      KEYS[5],
+      "*",
+      "type",
+      "delete",
+      "key",
+      logicalKey,
+      "version",
+      version,
+      "reason",
+      reason,
+      "deletedAt",
+      tostring(now)
+    )
+  else
+    redis.call(
+      "XADD",
+      KEYS[5],
+      "*",
+      "type",
+      "delete",
+      "key",
+      logicalKey,
+      "version",
+      version,
+      "deletedAt",
+      tostring(now)
+    )
+  end
+
+  if trimMinId ~= "" then
+    redis.call("XTRIM", KEYS[5], "MINID", "~", trimMinId)
+  end
+  if maxEventLen > 0 then
+    redis.call("XTRIM", KEYS[5], "MAXLEN", "~", tostring(maxEventLen))
+  end
+
+  return 1
+`;
+var RECONCILE_SCRIPT = `
+  local now = tonumber(ARGV[1])
+  local batch = tonumber(ARGV[2])
+  local trimMinId = ARGV[3]
+  local maxEventLen = tonumber(ARGV[4])
+
+  local due = redis.call("ZRANGEBYSCORE", KEYS[3], "-inf", tostring(now), "LIMIT", "0", tostring(batch))
+  local expired = 0
+
+  for _, logicalKey in ipairs(due) do
+    local ttlKey = KEYS[4] .. string.len(logicalKey) .. ":" .. logicalKey
+    local ttlExists = redis.call("EXISTS", ttlKey)
+    if ttlExists == 0 then
+      redis.call("ZREM", KEYS[3], logicalKey)
+
+      local existingRaw = redis.call("HGET", KEYS[2], logicalKey)
+      if existingRaw then
+        redis.call("HDEL", KEYS[2], logicalKey)
+        local version = tostring(redis.call("INCR", KEYS[1]))
+        redis.call(
+          "XADD",
+          KEYS[5],
+          "*",
+          "type",
+          "expire",
+          "key",
+          logicalKey,
+          "version",
+          version,
+          "expiredAt",
+          tostring(now)
+        )
+        expired = expired + 1
+      end
+    end
+  end
+
+  if expired > 0 and trimMinId ~= "" then
+    redis.call("XTRIM", KEYS[5], "MINID", "~", trimMinId)
+  end
+  if expired > 0 and maxEventLen > 0 then
+    redis.call("XTRIM", KEYS[5], "MAXLEN", "~", tostring(maxEventLen))
+  end
+
+  return expired
+`;
+var asError5 = (error48) => error48 instanceof Error ? error48 : new Error(String(error48));
+var safeClose3 = (client) => {
+  if (!client.connected)
+    return;
+  try {
+    client.close();
+  } catch {}
+};
+var evalScript3 = async (script, keys, args) => {
+  return await redis7.send("EVAL", [script, keys.length.toString(), ...keys, ...args.map((v) => String(v))]);
+};
+var blockingReadWithTemporaryClient2 = async (args, signal) => {
+  if (signal?.aborted)
+    return null;
+  const client = new RedisClient3;
+  const onAbort = () => {
+    safeClose3(client);
+  };
+  if (signal)
+    signal.addEventListener("abort", onAbort, { once: true });
+  try {
+    if (!client.connected)
+      await client.connect();
+    return await client.send("XREAD", args);
+  } catch (error48) {
+    if (signal?.aborted)
+      return null;
+    throw asError5(error48);
+  } finally {
+    if (signal)
+      signal.removeEventListener("abort", onAbort);
+    safeClose3(client);
+  }
+};
+var parseFirstRangeEntry = (raw) => {
+  if (!Array.isArray(raw) || raw.length === 0)
+    return null;
+  const first = raw[0];
+  if (!Array.isArray(first) || first.length < 2)
+    return null;
+  const id = first[0];
+  if (typeof id !== "string")
+    return null;
+  return {
+    id,
+    fields: fieldArrayToObject(first[1])
+  };
+};
+
+class EphemeralCapacityError extends Error {
+  constructor(message = "ephemeral store capacity reached") {
+    super(message);
+    this.name = "EphemeralCapacityError";
+  }
+}
+
+class EphemeralPayloadTooLargeError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EphemeralPayloadTooLargeError";
+  }
+}
+var parseOptionalNumber = (value) => {
+  if (typeof value === "number")
+    return Number.isFinite(value) ? value : null;
+  if (typeof value === "string") {
+    const num = Number(value);
+    return Number.isFinite(num) ? num : null;
+  }
+  return null;
+};
+var encodeSegment = (value) => encodeURIComponent(value);
+var assertIdentifier = (value, label) => {
+  if (value.length === 0)
+    throw new Error(`${label} must be non-empty`);
+  if (value.length > 256)
+    throw new Error(`${label} too long (max 256 chars)`);
+};
+var assertLogicalKey = (value) => {
+  if (value.length === 0)
+    throw new Error("key must be non-empty");
+  const bytes = textEncoder3.encode(value).byteLength;
+  if (bytes > MAX_KEY_BYTES)
+    throw new Error(`key exceeds max length (${MAX_KEY_BYTES} bytes)`);
+};
+var ephemeral = (config2) => {
+  if (!Number.isFinite(config2.ttlMs) || config2.ttlMs <= 0) {
+    throw new Error("ttlMs must be > 0");
+  }
+  assertIdentifier(config2.id, "config.id");
+  const defaultTenant = config2.tenantId ?? DEFAULT_TENANT3;
+  assertIdentifier(defaultTenant, "tenantId");
+  const maxEntries = config2.limits?.maxEntries ?? DEFAULT_MAX_ENTRIES;
+  const maxPayloadBytes = config2.limits?.maxPayloadBytes ?? DEFAULT_MAX_PAYLOAD_BYTES;
+  const eventRetentionMs = config2.limits?.eventRetentionMs ?? DEFAULT_EVENT_RETENTION_MS;
+  const eventMaxLen = config2.limits?.eventMaxLen ?? DEFAULT_EVENT_MAXLEN;
+  const resolveTenant = (tenantId) => {
+    const resolved = tenantId ?? defaultTenant;
+    assertIdentifier(resolved, "tenantId");
+    return resolved;
+  };
+  const keysForTenant = (tenantId) => {
+    const base = `${DEFAULT_PREFIX7}:${encodeSegment(tenantId)}:${encodeSegment(config2.id)}`;
+    return {
+      seq: `${base}:seq`,
+      state: `${base}:state`,
+      expirations: `${base}:exp`,
+      ttlPrefix: `${base}:ttl:`,
+      events: `${base}:events`
+    };
+  };
+  const trimMinId = () => `${Date.now() - eventRetentionMs}-0`;
+  const parseStoredEntry = (raw) => {
+    try {
+      const parsed = JSON.parse(raw);
+      const validated = config2.schema.safeParse(parsed.data);
+      if (!validated.success)
+        return null;
+      return {
+        key: parsed.key,
+        value: validated.data,
+        version: String(parsed.version),
+        updatedAt: Number(parsed.updatedAt),
+        expiresAt: Number(parsed.expiresAt)
+      };
+    } catch {
+      return null;
+    }
+  };
+  const parseUpsertEvent = (entry) => {
+    const rawPayload = entry.fields.payload;
+    if (!rawPayload)
+      return null;
+    try {
+      const payload = JSON.parse(rawPayload);
+      const parsed = config2.schema.safeParse(payload);
+      if (!parsed.success)
+        return null;
+      const updatedAt = parseOptionalNumber(entry.fields.updatedAt);
+      const expiresAt = parseOptionalNumber(entry.fields.expiresAt);
+      if (updatedAt === null || expiresAt === null)
+        return null;
+      return {
+        type: "upsert",
+        cursor: entry.id,
+        entry: {
+          key: entry.fields.key ?? "",
+          value: parsed.data,
+          version: entry.fields.version ?? "",
+          updatedAt,
+          expiresAt
+        }
+      };
+    } catch {
+      return null;
+    }
+  };
+  const parseEvent = (entry) => {
+    const type = entry.fields.type;
+    if (type === "upsert")
+      return parseUpsertEvent(entry);
+    if (type === "touch") {
+      const expiresAt = parseOptionalNumber(entry.fields.expiresAt);
+      if (expiresAt === null)
+        return null;
+      return {
+        type,
+        cursor: entry.id,
+        key: entry.fields.key ?? "",
+        version: entry.fields.version ?? "",
+        expiresAt
+      };
+    }
+    if (type === "delete") {
+      const deletedAt = parseOptionalNumber(entry.fields.deletedAt);
+      if (deletedAt === null)
+        return null;
+      return {
+        type,
+        cursor: entry.id,
+        key: entry.fields.key ?? "",
+        version: entry.fields.version ?? "",
+        deletedAt,
+        reason: entry.fields.reason
+      };
+    }
+    if (type === "expire") {
+      const expiredAt = parseOptionalNumber(entry.fields.expiredAt);
+      if (expiredAt === null)
+        return null;
+      return {
+        type,
+        cursor: entry.id,
+        key: entry.fields.key ?? "",
+        version: entry.fields.version ?? "",
+        expiredAt
+      };
+    }
+    return null;
+  };
+  const lastReconcileByTenant = new Map;
+  const runReconcile = async (keys, now2) => {
+    const raw = await evalScript3(RECONCILE_SCRIPT, [keys.seq, keys.state, keys.expirations, keys.ttlPrefix, keys.events], [now2, DEFAULT_RECONCILE_BATCH_SIZE, trimMinId(), eventMaxLen]);
+    return Number(raw ?? 0);
+  };
+  const maybeRunReconcile = async (tenantId, keys, force = false) => {
+    const now2 = Date.now();
+    if (!force) {
+      const last = lastReconcileByTenant.get(tenantId) ?? 0;
+      if (now2 - last < DEFAULT_RECONCILE_INTERVAL_MS)
+        return;
+    }
+    if (!lastReconcileByTenant.has(tenantId) && lastReconcileByTenant.size >= MAX_RECONCILE_TENANTS) {
+      const first = lastReconcileByTenant.keys().next().value;
+      if (first)
+        lastReconcileByTenant.delete(first);
+    }
+    lastReconcileByTenant.set(tenantId, now2);
+    await runReconcile(keys, now2);
+  };
+  const runFullReconcile = async (keys) => {
+    let loops = 0;
+    while (loops < 50) {
+      const count = await runReconcile(keys, Date.now());
+      if (count < DEFAULT_RECONCILE_BATCH_SIZE)
+        break;
+      loops += 1;
+      await Bun.sleep(1);
+    }
+  };
+  const latestCursor = async (eventsKey) => {
+    const raw = await redis7.send("XREVRANGE", [eventsKey, "+", "-", "COUNT", "1"]);
+    const parsed = parseFirstRangeEntry(raw);
+    return parsed?.id ?? "0-0";
+  };
+  const firstAtOrAfterCursor = async (eventsKey, cursor) => {
+    const raw = await redis7.send("XRANGE", [eventsKey, cursor, "+", "COUNT", "1"]);
+    return parseFirstRangeEntry(raw)?.id ?? null;
+  };
+  const upsert = async (cfg) => {
+    assertLogicalKey(cfg.key);
+    const tenantId = resolveTenant(cfg.tenantId);
+    const keys = keysForTenant(tenantId);
+    await maybeRunReconcile(tenantId, keys);
+    const ttlMs = cfg.ttlMs ?? config2.ttlMs;
+    if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+      throw new Error("ttlMs must be > 0");
+    }
+    const parsed = config2.schema.safeParse(cfg.value);
+    if (!parsed.success)
+      throw parsed.error;
+    const payloadRaw = JSON.stringify(parsed.data);
+    const payloadBytes = textEncoder3.encode(payloadRaw).byteLength;
+    if (payloadBytes > maxPayloadBytes) {
+      throw new EphemeralPayloadTooLargeError(`payload exceeds limit (${maxPayloadBytes} bytes)`);
+    }
+    const raw = await evalScript3(UPSERT_SCRIPT2, [keys.seq, keys.state, keys.expirations, keys.ttlPrefix, keys.events], [Date.now(), ttlMs, payloadRaw, cfg.key, maxEntries, trimMinId(), eventMaxLen]);
+    if (raw === "__ERR_CAPACITY__") {
+      throw new EphemeralCapacityError(`maxEntries (${maxEntries}) reached`);
+    }
+    if (raw === "__ERR_PAYLOAD__") {
+      throw new Error("invalid payload encoding");
+    }
+    const storedRaw = typeof raw === "string" ? raw : String(raw ?? "");
+    const entry = parseStoredEntry(storedRaw);
+    if (!entry)
+      throw new Error("failed to parse stored entry");
+    return entry;
+  };
+  const touch = async (cfg) => {
+    assertLogicalKey(cfg.key);
+    const tenantId = resolveTenant(cfg.tenantId);
+    const keys = keysForTenant(tenantId);
+    await maybeRunReconcile(tenantId, keys);
+    const ttlMs = cfg.ttlMs ?? config2.ttlMs;
+    if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+      throw new Error("ttlMs must be > 0");
+    }
+    const raw = await evalScript3(TOUCH_SCRIPT2, [keys.seq, keys.state, keys.expirations, keys.ttlPrefix, keys.events], [Date.now(), ttlMs, cfg.key, trimMinId(), eventMaxLen]);
+    if (!raw)
+      return { ok: false };
+    try {
+      const parsed = JSON.parse(typeof raw === "string" ? raw : String(raw));
+      return { ok: true, version: String(parsed.version), expiresAt: Number(parsed.expiresAt) };
+    } catch {
+      return { ok: false };
+    }
+  };
+  const remove = async (cfg) => {
+    assertLogicalKey(cfg.key);
+    const tenantId = resolveTenant(cfg.tenantId);
+    const keys = keysForTenant(tenantId);
+    await maybeRunReconcile(tenantId, keys);
+    const raw = await evalScript3(REMOVE_SCRIPT, [keys.seq, keys.state, keys.expirations, keys.ttlPrefix, keys.events], [Date.now(), cfg.key, cfg.reason ?? "", trimMinId(), eventMaxLen]);
+    return Number(raw) > 0;
+  };
+  const snapshot = async (cfg = {}) => {
+    const tenantId = resolveTenant(cfg.tenantId);
+    const keys = keysForTenant(tenantId);
+    await runFullReconcile(keys);
+    const rawEntries = await redis7.hvals(keys.state);
+    const entries = [];
+    for (const raw of rawEntries) {
+      const parsed = parseStoredEntry(String(raw));
+      if (!parsed)
+        continue;
+      entries.push(parsed);
+    }
+    entries.sort((a, b) => a.key.localeCompare(b.key));
+    return {
+      entries,
+      cursor: await latestCursor(keys.events)
+    };
+  };
+  const reader = (readerCfg = {}) => {
+    const tenantId = resolveTenant(readerCfg.tenantId);
+    const keys = keysForTenant(tenantId);
+    let cursor = readerCfg.after ?? "$";
+    let overflowPending = null;
+    let replayChecked = false;
+    let anchored = false;
+    let blockingClient = null;
+    const resetBlockingClient = () => {
+      if (!blockingClient)
+        return;
+      safeClose3(blockingClient);
+      blockingClient = null;
+    };
+    const ensureBlockingClient = async () => {
+      if (blockingClient?.connected)
+        return blockingClient;
+      resetBlockingClient();
+      blockingClient = new RedisClient3;
+      await blockingClient.connect();
+      return blockingClient;
+    };
+    const checkReplayGap = async () => {
+      if (replayChecked)
+        return;
+      replayChecked = true;
+      const after = readerCfg.after;
+      if (!after || after === "$")
+        return;
+      const firstAtOrAfter = await firstAtOrAfterCursor(keys.events, after);
+      if (!firstAtOrAfter)
+        return;
+      if (after === "0-0" || firstAtOrAfter !== after) {
+        const liveCursor = await latestCursor(keys.events);
+        overflowPending = {
+          type: "overflow",
+          cursor: liveCursor,
+          after,
+          firstAvailable: firstAtOrAfter
+        };
+        cursor = liveCursor;
+      }
+    };
+    const anchorLiveCursor = async () => {
+      if (anchored)
+        return;
+      anchored = true;
+      if (cursor !== "$")
+        return;
+      cursor = await latestCursor(keys.events);
+    };
+    const recv = async (cfg = {}) => {
+      await anchorLiveCursor();
+      await maybeRunReconcile(tenantId, keys);
+      await checkReplayGap();
+      if (overflowPending) {
+        const event = overflowPending;
+        overflowPending = null;
+        return event;
+      }
+      const wait = cfg.wait ?? true;
+      const timeoutMs = cfg.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+      const args = wait ? ["COUNT", "1", "BLOCK", timeoutMs.toString(), "STREAMS", keys.events, cursor] : ["COUNT", "1", "STREAMS", keys.events, cursor];
+      const result = cfg.signal ? await blockingReadWithTemporaryClient2(args, cfg.signal) : wait ? await (async () => {
+        const client = await ensureBlockingClient();
+        try {
+          return await client.send("XREAD", args);
+        } catch (error48) {
+          resetBlockingClient();
+          throw asError5(error48);
+        }
+      })() : await redis7.send("XREAD", args);
+      const entry = parseFirstStreamEntry(result);
+      if (!entry)
+        return null;
+      cursor = entry.id;
+      const parsed = parseEvent(entry);
+      if (!parsed)
+        return null;
+      return parsed;
+    };
+    const stream = async function* (cfg = {}) {
+      const wait = cfg.wait ?? true;
+      try {
+        while (!cfg.signal?.aborted) {
+          const event = wait ? await retry(async () => await recv(cfg), {
+            attempts: Number.POSITIVE_INFINITY,
+            signal: cfg.signal,
+            retryIf: isRetryableTransportError
+          }) : await recv(cfg);
+          if (event) {
+            yield event;
+            continue;
+          }
+          if (!wait)
+            break;
+        }
+      } finally {
+        resetBlockingClient();
+      }
+    };
+    return { recv, stream };
+  };
+  return {
+    upsert,
+    touch,
+    remove,
+    snapshot,
+    reader
+  };
+};
 export {
   topic,
+  scheduler,
+  retry,
   ratelimit,
   queue,
   mutex,
   job,
+  isRetryableTransportError,
+  ephemeral,
   RateLimitError,
-  LockError
+  LockError,
+  EphemeralPayloadTooLargeError,
+  EphemeralCapacityError,
+  DEFAULT_RETRY_OPTIONS
 };