stitchkit 0.108.4 → 0.109.0

package/dist/entrypoints/telegram.js

@@ -1220,7 +1220,226 @@ function createTelegramBotTransport(options = {}) {
     return exchange(socket, Buffer.concat([Buffer.from(head, "latin1"), body]), { maxResponseBytes, responseTimeoutMs }, signal);
   };
 }
+// src/telegram/update-intake-work.ts
+function createTelegramUpdateWorkSlots(maxConcurrent) {
+  const waiting = [];
+  let running = 0;
+  return {
+    async take() {
+      if (running < maxConcurrent) {
+        running += 1;
+        return;
+      }
+      await new Promise((resolve) => waiting.push(resolve));
+    },
+    release() {
+      const next = waiting.shift();
+      if (next)
+        next();
+      else
+        running -= 1;
+    }
+  };
+}
+function createTelegramUpdateExhaustionScheduler(options) {
+  const { config, store, now, slots, parse, reportStoreError } = options;
+  const handler = config.handleExhaustion;
+  const jobs = new Map;
+  return {
+    schedule(row, active) {
+      if (!active || !store || !handler || jobs.has(row.updateId))
+        return false;
+      const update = parse(row.body);
+      if (!update)
+        return false;
+      const exhaustion = Object.freeze({
+        update: transportResult(update),
+        updateId: row.updateId,
+        attempt: row.attempt,
+        claimId: row.claimId,
+        exhaustedAt: row.exhaustedAt,
+        error: row.error
+      });
+      const job = (async () => {
+        await slots.take();
+        try {
+          try {
+            await handler(exhaustion);
+          } catch (error) {
+            try {
+              config.onExhaustionFailure?.({ exhaustion, error });
+            } catch {}
+            return;
+          }
+          await store.acknowledgeExhaustion(exhaustion, now()).catch((error) => reportStoreError(error, "settle"));
+        } finally {
+          slots.release();
+        }
+      })().finally(() => {
+        if (jobs.get(row.updateId) === job)
+          jobs.delete(row.updateId);
+      });
+      jobs.set(row.updateId, job);
+      return true;
+    },
+    pending: () => [...jobs.values()]
+  };
+}
+function handlerError(error) {
+  return error instanceof Error && error.name === "BotError" && "ctx" in error && "error" in error ? error.error : error;
+}
+function createTelegramUpdateAttemptRunner(options) {
+  const {
+    config,
+    store,
+    fenced,
+    durable,
+    now,
+    retry,
+    maxAttempts,
+    leaseMs,
+    reportStoreError,
+    scheduleExhaustion,
+    ownershipLostReason
+  } = options;
+  return async (update, updateId) => {
+    const taken = now();
+    const claimOptions = {
+      now: taken,
+      leaseUntil: taken + leaseMs,
+      maxAttempts,
+      ...durable && { durableExhaustion: true }
+    };
+    const ownedIdentity = fenced ? await fenced.claimOwned(updateId, claimOptions).catch((error) => reportStoreError(error, "claim")) : undefined;
+    const legacyAttempt = fenced ? undefined : await store.claim(updateId, claimOptions).catch((error) => reportStoreError(error, "claim"));
+    const attempt = ownedIdentity?.attempt ?? legacyAttempt;
+    if (attempt === undefined)
+      return;
+    const identity = Object.freeze(ownedIdentity ?? { updateId, attempt, claimId: "" });
+    const ownership = new AbortController;
+    let active = true;
+    const loseOwnership = () => {
+      if (!ownership.signal.aborted)
+        ownership.abort(ownershipLostReason(identity));
+    };
+    let ownershipDeadline;
+    const armOwnershipDeadline = (leaseUntil) => {
+      if (!active)
+        return;
+      if (ownershipDeadline)
+        clearTimeout(ownershipDeadline);
+      ownershipDeadline = setTimeout(loseOwnership, Math.max(1, leaseUntil - now()));
+      ownershipDeadline.unref?.();
+    };
+    armOwnershipDeadline(taken + leaseMs);
+    let renewalInFlight = false;
+    const renewal = setInterval(() => {
+      if (!active || renewalInFlight)
+        return;
+      renewalInFlight = true;
+      const at = now();
+      const leaseUntil = at + leaseMs;
+      let request;
+      try {
+        request = fenced ? fenced.renewOwned(identity, leaseUntil, at) : store.renew(updateId, attempt, leaseUntil, at);
+      } catch (error) {
+        renewalInFlight = false;
+        if (active)
+          reportStoreError(error, "renew");
+        return;
+      }
+      request.then((held) => {
+        renewalInFlight = false;
+        if (!active)
+          return;
+        if (held)
+          armOwnershipDeadline(leaseUntil);
+        else
+          loseOwnership();
+      }, (error) => {
+        renewalInFlight = false;
+        if (active)
+          reportStoreError(error, "renew");
+      });
+    }, Math.max(1, Math.floor(leaseMs / 4)));
+    renewal.unref?.();
+    const context = Object.freeze({
+      ...identity,
+      fence: identity,
+      ownerLost: ownership.signal
+    });
+    const settleAttempt = (settlement) => fenced ? fenced.settleOwned(identity, settlement) : store.settle(updateId, attempt, settlement).then(() => true);
+    try {
+      try {
+        const typedUpdate = transportResult(update);
+        if ("handleAttempt" in config)
+          await config.handleAttempt(typedUpdate, context);
+        else
+          await config.handle(typedUpdate);
+        const settled = await settleAttempt({ state: "completed", at: now() }).catch((error) => {
+          reportStoreError(error, "settle");
+          return false;
+        });
+        if (settled === false)
+          loseOwnership();
+      } catch (thrown) {
+        const error = handlerError(thrown);
+        const delay = attempt >= maxAttempts ? false : retry(error, attempt);
+        const message = error instanceof Error ? error.message : String(error);
+        let exhaustion;
+        let retrying = delay !== false;
+        if (delay === false && durable) {
+          const at = now();
+          const persisted = await durable.exhaust(identity, { at, error: message }).catch((cause) => {
+            reportStoreError(cause, "settle");
+            return false;
+          });
+          if (persisted) {
+            exhaustion = {
+              ...identity,
+              body: JSON.stringify(update),
+              exhaustedAt: at,
+              error: message
+            };
+          } else {
+            loseOwnership();
+            retrying = true;
+          }
+        } else {
+          const at = now();
+          const settled = await settleAttempt(delay === false ? { state: "abandoned", at, error: message } : { state: "failed", at, retryAt: at + delay, error: message }).catch((cause) => {
+            reportStoreError(cause, "settle");
+            return false;
+          });
+          if (settled === false) {
+            loseOwnership();
+            retrying = true;
+          }
+        }
+        try {
+          config.onFailure?.({ updateId, attempt, error, retrying });
+        } catch {}
+        if (exhaustion)
+          scheduleExhaustion(exhaustion);
+      }
+    } finally {
+      active = false;
+      clearInterval(renewal);
+      if (ownershipDeadline)
+        clearTimeout(ownershipDeadline);
+    }
+  };
+}
+
 // src/telegram/update-intake.ts
+class TelegramUpdateOwnershipLostError extends Error {
+  identity;
+  constructor(identity) {
+    super(`[stitchkit] telegram update ${identity.updateId} attempt ${identity.attempt} lost ownership`);
+    this.identity = identity;
+    this.name = "TelegramUpdateOwnershipLostError";
+  }
+}
 var SWEEP_BATCH = 100;
 function defaultRetry(error, attempt) {
   const failure = classifyTelegramSendFailure2(error);
@@ -1256,17 +1475,30 @@ function parsed(body) {
     return;
   }
 }
-function handlerError(error) {
-  return error instanceof Error && error.name === "BotError" && "ctx" in error && "error" in error ? error.error : error;
-}
 function positive(name, value) {
   if (!Number.isSafeInteger(value) || value < 1) {
     throw new RangeError(`[stitchkit] telegram update intake: ${name} is a positive integer`);
   }
   return value;
 }
+function isTelegramUpdateFencedStore(store) {
+  return "claimOwned" in store && typeof store.claimOwned === "function" && "renewOwned" in store && typeof store.renewOwned === "function" && "owns" in store && typeof store.owns === "function" && "settleOwned" in store && typeof store.settleOwned === "function";
+}
+function isTelegramUpdateDurableStore(store) {
+  return isTelegramUpdateFencedStore(store) && "exhaust" in store && typeof store.exhaust === "function" && "dueExhaustions" in store && typeof store.dueExhaustions === "function" && "acknowledgeExhaustion" in store && typeof store.acknowledgeExhaustion === "function";
+}
 function createTelegramUpdateIntake(config) {
   const { store } = config;
+  const exhaustionHandler = config.handleExhaustion;
+  const attemptAware = "handleAttempt" in config;
+  const fenced = attemptAware || exhaustionHandler !== undefined ? isTelegramUpdateFencedStore(store) ? store : undefined : undefined;
+  const durable = exhaustionHandler ? isTelegramUpdateDurableStore(store) ? store : undefined : undefined;
+  if (attemptAware && !fenced) {
+    throw new TypeError("[stitchkit] telegram update intake: handleAttempt requires a TelegramUpdateFencedStore");
+  }
+  if (exhaustionHandler && !durable) {
+    throw new TypeError("[stitchkit] telegram update intake: handleExhaustion requires a TelegramUpdateDurableStore");
+  }
   const now = config.now ?? Date.now;
   const retry = config.retry ?? defaultRetry;
   const maxAttempts = positive("maxAttempts", config.maxAttempts ?? 5);
@@ -1277,66 +1509,52 @@ function createTelegramUpdateIntake(config) {
   const maxConcurrent = positive("maxConcurrent", config.maxConcurrent ?? 32);
   const lines = new Map;
   const scheduled = new Set;
-  const waiting = [];
-  let running = 0;
   let started = false;
+  let starting;
+  let lifecycleGeneration = 0;
   let timer;
+  let exhaustionCursor;
   const storeError = (error, step) => {
     try {
       config.onStoreError?.(error, step);
     } catch {}
   };
-  const slot = async () => {
-    if (running < maxConcurrent) {
-      running += 1;
-      return;
-    }
-    await new Promise((resolve) => waiting.push(resolve));
-  };
-  const release = () => {
-    const next = waiting.shift();
-    if (next)
-      next();
-    else
-      running -= 1;
-  };
-  const attempt = async (update, updateId) => {
-    const taken = now();
-    const number = await store.claim(updateId, { now: taken, leaseUntil: taken + leaseMs, maxAttempts }).catch((error) => storeError(error, "claim"));
-    if (number === undefined)
-      return;
-    const renewal = setInterval(() => {
-      store.renew(updateId, number, now() + leaseMs).catch((error) => storeError(error, "renew"));
-    }, Math.max(1, Math.floor(leaseMs / 4)));
-    let settlement;
-    try {
-      await config.handle(transportResult(update));
-      settlement = { state: "completed", at: now() };
-    } catch (thrown) {
-      const error = handlerError(thrown);
-      const delay = number >= maxAttempts ? false : retry(error, number);
-      const message = error instanceof Error ? error.message : String(error);
-      settlement = delay === false ? { state: "abandoned", at: now(), error: message } : { state: "failed", at: now(), retryAt: now() + delay, error: message };
-      try {
-        config.onFailure?.({ updateId, attempt: number, error, retrying: delay !== false });
-      } catch {}
-    } finally {
-      clearInterval(renewal);
-    }
-    await store.settle(updateId, number, settlement).catch((error) => storeError(error, "settle"));
-  };
+  const slots = createTelegramUpdateWorkSlots(maxConcurrent);
+  const exhaustionScheduler = createTelegramUpdateExhaustionScheduler({
+    config,
+    store: durable,
+    now,
+    slots,
+    parse: parsed,
+    reportStoreError: storeError
+  });
+  const attempt = createTelegramUpdateAttemptRunner({
+    config,
+    store,
+    fenced,
+    durable,
+    now,
+    retry,
+    maxAttempts,
+    leaseMs,
+    reportStoreError: storeError,
+    scheduleExhaustion: (row) => {
+      exhaustionScheduler.schedule(row, started);
+    },
+    ownershipLostReason: (identity) => new TelegramUpdateOwnershipLostError(identity)
+  });
   const schedule = (update) => {
     const updateId = Number(update.update_id);
     if (!started || scheduled.has(updateId))
-      return;
+      return false;
     scheduled.add(updateId);
     const line = lineOf(update);
     const next = (lines.get(line) ?? Promise.resolve()).then(async () => {
-      await slot();
+      await slots.take();
       try {
         await attempt(update, updateId);
       } finally {
-        release();
+        slots.release();
       }
     }).finally(() => {
       scheduled.delete(updateId);
@@ -1344,6 +1562,7 @@ function createTelegramUpdateIntake(config) {
         lines.delete(line);
     });
     lines.set(line, next);
+    return true;
   };
   const sweep = async (pendingBefore) => {
     const at = now();
@@ -1351,9 +1570,22 @@ function createTelegramUpdateIntake(config) {
     let count = 0;
     for (const row of due) {
       const update = parsed(row.body);
-      if (update && !scheduled.has(row.updateId)) {
-        schedule(update);
+      if (update && schedule(update))
         count += 1;
+    }
+    if (durable) {
+      let exhaustions = await durable.dueExhaustions({
+        limit: SWEEP_BATCH,
+        ...exhaustionCursor !== undefined && { afterUpdateId: exhaustionCursor }
+      });
+      if (exhaustions.length === 0 && exhaustionCursor !== undefined) {
+        exhaustionCursor = undefined;
+        exhaustions = await durable.dueExhaustions({ limit: SWEEP_BATCH });
+      }
+      exhaustionCursor = exhaustions.at(-1)?.updateId;
+      for (const exhaustion of exhaustions) {
+        if (exhaustionScheduler.schedule(exhaustion, started))
+          count += 1;
       }
     }
     await store.prune(at - retainMs);
@@ -1371,32 +1603,66 @@ function createTelegramUpdateIntake(config) {
       schedule(update);
       return "accepted";
     },
-    async start() {
+    start() {
+      if (starting)
+        return starting;
       if (started)
-        return;
+        return Promise.resolve();
       started = true;
-      await sweep(now());
-      timer = setInterval(() => {
-        sweep(now() - pendingGraceMs).catch((error) => storeError(error, "sweep"));
-      }, sweepEveryMs);
-      timer.unref?.();
+      const generation = ++lifecycleGeneration;
+      const operation = (async () => {
+        try {
+          await sweep(now());
+        } catch (error) {
+          if (started && lifecycleGeneration === generation)
+            started = false;
+          throw error;
+        }
+        if (!started || lifecycleGeneration !== generation)
+          return;
+        timer = setInterval(() => {
+          if (!started || lifecycleGeneration !== generation)
+            return;
+          sweep(now() - pendingGraceMs).catch((error) => storeError(error, "sweep"));
+        }, sweepEveryMs);
+        timer.unref?.();
+      })();
+      starting = operation;
+      const clearStarting = () => {
+        if (starting === operation)
+          starting = undefined;
+      };
+      operation.then(clearStarting, clearStarting);
+      return operation;
     },
     sweep: () => sweep(now() - pendingGraceMs),
     async idle() {
-      while (lines.size > 0)
-        await Promise.all(lines.values());
+      while (lines.size > 0 || exhaustionScheduler.pending().length > 0) {
+        await Promise.all([...lines.values(), ...exhaustionScheduler.pending()]);
+      }
     },
     async close() {
       started = false;
+      lifecycleGeneration += 1;
       if (timer)
         clearInterval(timer);
       timer = undefined;
-      while (lines.size > 0)
-        await Promise.all(lines.values());
+      const pendingStart = starting;
+      if (pendingStart) {
+        await pendingStart.then(() => {
+          return;
+        }, () => {
+          return;
+        });
+      }
+      while (lines.size > 0 || exhaustionScheduler.pending().length > 0) {
+        await Promise.all([...lines.values(), ...exhaustionScheduler.pending()]);
+      }
     }
   };
 }
 // src/telegram/update-store.ts
+import { randomUUID } from "node:crypto";
 function isClaimable(record, now) {
   if (record.state === "pending")
     return true;
@@ -1406,9 +1672,41 @@ function isClaimable(record, now) {
 }
 function memoryTelegramUpdateStore() {
   const records = new Map;
-  const holding = (updateId, attempt) => {
+  const holding = (updateId, attempt, claimId) => {
+    const record = records.get(updateId);
+    return record?.state === "processing" && record.attempts === attempt && (claimId === undefined || record.claimId === claimId) ? record : undefined;
+  };
+  const settleCurrent = (updateId, attempt, settlement, claimId) => {
+    const record = holding(updateId, attempt, claimId);
+    if (!record || record.dueAt < settlement.at)
+      return false;
+    record.state = settlement.state;
+    record.error = settlement.state === "completed" ? undefined : settlement.error;
+    if (settlement.state === "failed")
+      record.dueAt = settlement.retryAt;
+    else
+      record.settledAt = settlement.at;
+    return true;
+  };
+  const claimOwned = (updateId, options) => {
     const record = records.get(updateId);
-    return record?.state === "processing" && record.attempts === attempt ? record : undefined;
+    if (!record || !isClaimable(record, options.now))
+      return;
+    if (record.attempts >= options.maxAttempts) {
+      Object.assign(record, {
+        state: "abandoned",
+        dueAt: options.now,
+        settledAt: options.durableExhaustion ? undefined : options.now,
+        error: "attempts spent",
+        claimId: record.claimId ?? randomUUID()
+      });
+      return;
+    }
+    record.state = "processing";
+    record.attempts += 1;
+    record.dueAt = options.leaseUntil;
+    record.claimId = randomUUID();
+    return { updateId, attempt: record.attempts, claimId: record.claimId };
   };
   return {
     async add(update) {
@@ -1420,47 +1718,76 @@ function memoryTelegramUpdateStore() {
         attempts: 0,
         dueAt: update.receivedAt,
         settledAt: undefined,
-        error: undefined
+        error: undefined,
+        claimId: undefined
       });
       return true;
     },
     async claim(updateId, options) {
-      const record = records.get(updateId);
-      if (!record || !isClaimable(record, options.now))
-        return;
-      if (record.attempts >= options.maxAttempts) {
-        Object.assign(record, {
-          state: "abandoned",
-          settledAt: options.now,
-          error: "attempts spent"
-        });
-        return;
-      }
-      record.state = "processing";
-      record.attempts += 1;
-      record.dueAt = options.leaseUntil;
-      return record.attempts;
+      return claimOwned(updateId, options)?.attempt;
+    },
+    async claimOwned(updateId, options) {
+      return claimOwned(updateId, options);
     },
-    async renew(updateId, attempt, leaseUntil) {
+    async renew(updateId, attempt, leaseUntil, at) {
       const record = holding(updateId, attempt);
-      if (record)
-        record.dueAt = leaseUntil;
-      return record !== undefined;
+      if (!record || at !== undefined && record.dueAt < at)
+        return false;
+      record.dueAt = Math.max(record.dueAt, leaseUntil);
+      return true;
     },
     async settle(updateId, attempt, settlement) {
-      const record = holding(updateId, attempt);
-      if (!record)
-        return;
-      record.state = settlement.state;
-      record.error = settlement.state === "completed" ? undefined : settlement.error;
-      if (settlement.state === "failed")
-        record.dueAt = settlement.retryAt;
-      else
-        record.settledAt = settlement.at;
+      settleCurrent(updateId, attempt, settlement);
     },
     async due(query) {
       return [...records.values()].filter((record) => record.state === "pending" ? record.receivedAt <= query.pendingBefore : isClaimable(record, query.now)).sort((left, right) => left.updateId - right.updateId).slice(0, query.limit).map(({ updateId, body }) => ({ updateId, body }));
     },
+    async owns(identity, at) {
+      const record = holding(identity.updateId, identity.attempt, identity.claimId);
+      return record !== undefined && record.dueAt >= at;
+    },
+    async renewOwned(identity, leaseUntil, at) {
+      const record = holding(identity.updateId, identity.attempt, identity.claimId);
+      if (!record || at !== undefined && record.dueAt < at)
+        return false;
+      record.dueAt = Math.max(record.dueAt, leaseUntil);
+      return true;
+    },
+    async settleOwned(identity, settlement) {
+      return settleCurrent(identity.updateId, identity.attempt, settlement, identity.claimId);
+    },
+    async exhaust(identity, exhaustion) {
+      const record = holding(identity.updateId, identity.attempt, identity.claimId);
+      if (!record || record.dueAt < exhaustion.at)
+        return false;
+      Object.assign(record, {
+        state: "abandoned",
+        dueAt: exhaustion.at,
+        settledAt: undefined,
+        error: exhaustion.error
+      });
+      return true;
+    },
+    async dueExhaustions(query) {
+      return [...records.values()].filter((record) => record.state === "abandoned" && record.settledAt === undefined && (query.afterUpdateId === undefined || record.updateId > query.afterUpdateId)).sort((left, right) => left.updateId - right.updateId).slice(0, query.limit).flatMap(({ updateId, body, attempts, dueAt, error, claimId }) => claimId ? [
+        {
+          updateId,
+          body,
+          attempt: attempts,
+          claimId,
+          exhaustedAt: dueAt,
+          error: error ?? "attempts spent"
+        }
+      ] : []);
+    },
+    async acknowledgeExhaustion(identity, at) {
+      const record = records.get(identity.updateId);
+      if (record?.state !== "abandoned" || record.attempts !== identity.attempt || record.claimId !== identity.claimId || record.settledAt !== undefined) {
+        return false;
+      }
+      record.settledAt = at;
+      return true;
+    },
     async prune(before) {
       let pruned = 0;
       for (const [updateId, record] of records) {
@@ -1478,6 +1805,12 @@ function same(actual, expected) {
   return JSON.stringify(actual) === JSON.stringify(expected);
 }
 var claim = { maxAttempts: 2 };
+function fenced(store) {
+  return "claimOwned" in store && typeof store.claimOwned === "function" && "renewOwned" in store && typeof store.renewOwned === "function" && "owns" in store && typeof store.owns === "function" && "settleOwned" in store && typeof store.settleOwned === "function";
+}
+function durable(store) {
+  return fenced(store) && "exhaust" in store && typeof store.exhaust === "function" && "dueExhaustions" in store && typeof store.dueExhaustions === "function" && "acknowledgeExhaustion" in store && typeof store.acknowledgeExhaustion === "function";
+}
 var RULES = {
   "one record per update_id": async (store, violated) => {
     if (!await store.add({ updateId: 7, body: "b", receivedAt: 0 }))
@@ -1502,7 +1835,13 @@ var RULES = {
   },
   "only the attempt holding the update renews or settles it": async (store, violated) => {
     await store.add({ updateId: 1, body: "b", receivedAt: 0 });
-    await store.claim(1, { ...claim, now: 0, leaseUntil: 10 });
+    const owned = fenced(store) ? store : undefined;
+    const firstIdentity = owned ? await owned.claimOwned(1, { ...claim, now: 0, leaseUntil: 10 }) : undefined;
+    if (!owned)
+      await store.claim(1, { ...claim, now: 0, leaseUntil: 10 });
+    if (firstIdentity && owned && await owned.settleOwned(firstIdentity, { state: "completed", at: 11 })) {
+      violated("an attempt whose lease expired settled the update");
+    }
     await store.claim(1, { ...claim, now: 11, leaseUntil: 50 });
     if (await store.renew(1, 1, 500))
       violated("an attempt that lost its lease renewed it");
@@ -1536,7 +1875,7 @@ var RULES = {
   },
   "settled updates are forgotten after they are pruned": async (store, violated) => {
     await store.add({ updateId: 3, body: "b", receivedAt: 0 });
-    await store.claim(3, { ...claim, now: 0, leaseUntil: 10 });
+    await store.claim(3, { ...claim, now: 0, leaseUntil: 100 });
     await store.settle(3, 1, { state: "abandoned", at: 36, error: "x" });
     await store.add({ updateId: 4, body: "b", receivedAt: 0 });
     if (await store.prune(36) !== 0)
@@ -1553,6 +1892,199 @@ var RULES = {
     const taken = await Promise.all(Array.from({ length: 8 }, () => store.claim(9, { maxAttempts: 5, now: 1, leaseUntil: 100 })));
     if (taken.filter((attempt) => attempt !== undefined).length !== 1)
       violated(`${taken.filter((attempt) => attempt !== undefined).length} of 8 concurrent claims took one update`);
+  },
+  "of concurrent fenced claims exactly one takes the update": async (store, violated) => {
+    if (!fenced(store))
+      return;
+    await store.add({ updateId: 19, body: "b", receivedAt: 0 });
+    const taken = await Promise.all(Array.from({ length: 8 }, () => store.claimOwned(19, { maxAttempts: 5, now: 1, leaseUntil: 100 })));
+    if (taken.filter((identity) => identity !== undefined).length !== 1) {
+      violated(`${taken.filter((identity) => identity !== undefined).length} of 8 concurrent fenced claims took one update`);
+    }
+  },
+  "renewal never shortens a live lease": async (store, violated) => {
+    await store.add({ updateId: 18, body: "b", receivedAt: 0 });
+    const identity = fenced(store) ? await store.claimOwned(18, { ...claim, now: 0, leaseUntil: 10 }) : undefined;
+    if (!identity)
+      await store.claim(18, { ...claim, now: 0, leaseUntil: 10 });
+    if (!await store.renew(18, 1, 30, 1)) {
+      violated("the live attempt could not extend its lease");
+      return;
+    }
+    if (!await store.renew(18, 1, 20, 2)) {
+      violated("an older live renewal was not accepted");
+      return;
+    }
+    if ((await store.due({ now: 21, pendingBefore: 0, limit: 10 })).length !== 0) {
+      violated("an older renewal shortened the current lease");
+    }
+    if (identity && fenced(store)) {
+      if (!await store.renewOwned(identity, 40, 3)) {
+        violated("the fenced attempt could not extend its lease");
+        return;
+      }
+      if (!await store.renewOwned(identity, 35, 4)) {
+        violated("an older fenced renewal was not accepted");
+        return;
+      }
+      if (!await store.owns(identity, 39)) {
+        violated("an older fenced renewal shortened the current lease");
+      }
+    }
+  },
+  "an attempt fence expires and never adopts a later claim": async (store, violated) => {
+    if (!fenced(store))
+      return;
+    await store.add({ updateId: 10, body: "b", receivedAt: 0 });
+    const first = await store.claimOwned(10, { ...claim, now: 0, leaseUntil: 10 });
+    if (!first) {
+      violated("the first fenced claim was not taken");
+      return;
+    }
+    if (!await store.owns(first, 10))
+      violated("the current attempt did not own its lease at the bound");
+    const wrongFirst = { ...first, claimId: `${first.claimId}-wrong` };
+    if (await store.owns(wrongFirst, 10))
+      violated("a different claim token owned the current attempt");
+    if (await store.renewOwned(wrongFirst, 10, 0))
+      violated("a different claim token renewed the current attempt");
+    if (await store.owns(first, 11))
+      violated("an expired attempt still owned its lease");
+    if (await store.renewOwned(first, 50, 11))
+      violated("an expired attempt resurrected its lease");
+    const second = await store.claimOwned(10, { ...claim, now: 11, leaseUntil: 30 });
+    if (!second) {
+      violated("the later fenced claim was not taken");
+      return;
+    }
+    if (await store.owns(first, 12))
+      violated("the old attempt adopted the later claim");
+    if (!await store.owns(second, 12))
+      violated("the later attempt did not own its claim");
+    if (!await store.settleOwned(second, { state: "completed", at: 12 }))
+      violated("the later attempt could not settle its claim");
+    if (await store.prune(13) !== 1) {
+      violated("the settled fenced attempt could not be pruned");
+      return;
+    }
+    await store.add({ updateId: 10, body: "new b", receivedAt: 13 });
+    const recycled = await store.claimOwned(10, { ...claim, now: 13, leaseUntil: 30 });
+    if (!recycled) {
+      violated("the recycled update_id could not be claimed");
+      return;
+    }
+    if (recycled.attempt !== first.attempt)
+      violated("the recycled update_id did not restart its attempt number");
+    const wrongRecycled = { ...recycled, claimId: `${recycled.claimId}-wrong` };
+    if (await store.renewOwned(wrongRecycled, 40, 14))
+      violated("a different claim token renewed a recycled update_id");
+    if (await store.settleOwned(wrongRecycled, { state: "completed", at: 14 }))
+      violated("a different claim token settled a recycled update_id");
+    if (await store.owns(first, 14))
+      violated("a pruned claim identity adopted a recycled update_id");
+    if (await store.renewOwned(first, 40, 14))
+      violated("a pruned claim identity renewed a recycled update_id");
+    if (await store.settleOwned(first, { state: "completed", at: 14 }))
+      violated("a pruned claim identity settled a recycled update_id");
+  },
+  "durable exhaustion survives owner loss until its exact acknowledgement": async (store, violated) => {
+    if (!durable(store))
+      return;
+    await store.add({ updateId: 11, body: "crash", receivedAt: 0 });
+    const first = await store.claimOwned(11, {
+      now: 0,
+      leaseUntil: 10,
+      maxAttempts: 1,
+      durableExhaustion: true
+    });
+    if (!first) {
+      violated("the durable claim was not taken");
+      return;
+    }
+    if (await store.claimOwned(11, {
+      now: 11,
+      leaseUntil: 20,
+      maxAttempts: 1,
+      durableExhaustion: true
+    }) !== undefined) {
+      violated("an attempts-spent update was claimed again");
+    }
+    const [exhaustion] = await store.dueExhaustions({ limit: 10 });
+    if (exhaustion?.updateId !== 11 || exhaustion.attempt !== 1 || exhaustion.body !== "crash") {
+      violated("the attempts-spent abandonment was not recoverable with its identity and body");
+      return;
+    }
+    if (await store.prune(1000) !== 0)
+      violated("prune removed an unacknowledged exhaustion");
+    if (await store.acknowledgeExhaustion({ ...exhaustion, claimId: `${exhaustion.claimId}-wrong` }, 20)) {
+      violated("a different claim token acknowledged the exhaustion");
+    }
+    if (await store.acknowledgeExhaustion({ ...exhaustion, attempt: 2 }, 20))
+      violated("a different attempt acknowledged the exhaustion");
+    if (!await store.acknowledgeExhaustion(exhaustion, 20))
+      violated("the exact attempt could not acknowledge the exhaustion");
+    if ((await store.dueExhaustions({ limit: 10 })).length !== 0)
+      violated("an acknowledged exhaustion remained due");
+    if (await store.prune(21) !== 1)
+      violated("an acknowledged exhaustion could not be pruned");
+    await store.add({ updateId: 12, body: "terminal", receivedAt: 0 });
+    const terminal = await store.claimOwned(12, { now: 0, leaseUntil: 10, maxAttempts: 2 });
+    if (!terminal) {
+      violated("the terminal claim was not taken");
+      return;
+    }
+    if (await store.exhaust({ ...terminal, claimId: `${terminal.claimId}-wrong` }, { at: 1, error: "wrong terminal refusal" })) {
+      violated("a different claim token persisted terminal exhaustion");
+    }
+    if (!await store.exhaust(terminal, { at: 1, error: "terminal refusal" })) {
+      violated("the holding attempt could not persist its terminal exhaustion");
+    }
+    if ((await store.dueExhaustions({ limit: 10 }))[0]?.error !== "terminal refusal")
+      violated("the terminal exhaustion did not preserve its reason");
+    await store.add({ updateId: 13, body: "expired", receivedAt: 0 });
+    const expired = await store.claimOwned(13, { now: 0, leaseUntil: 10, maxAttempts: 2 });
+    if (!expired) {
+      violated("the expiring claim was not taken");
+      return;
+    }
+    if (await store.exhaust(expired, { at: 11, error: "late terminal refusal" })) {
+      violated("an expired attempt persisted a terminal exhaustion");
+    }
+    if ((await store.claimOwned(13, { now: 11, leaseUntil: 20, maxAttempts: 2 }))?.attempt !== 2)
+      violated("an expired terminal attempt prevented a later claim");
+    await store.add({ updateId: 14, body: "next terminal", receivedAt: 0 });
+    const next = await store.claimOwned(14, { now: 0, leaseUntil: 10, maxAttempts: 2 });
+    if (!next) {
+      violated("the next terminal claim was not taken");
+      return;
+    }
+    await store.exhaust(next, { at: 1, error: "next terminal refusal" });
+    if (!same((await store.dueExhaustions({ limit: 10, afterUpdateId: 12 })).map(({ updateId }) => updateId), [14])) {
+      violated("exhaustion pagination did not continue after its update_id cursor");
+    }
+    await store.add({ updateId: 15, body: "base durable", receivedAt: 0 });
+    if (await store.claim(15, {
+      now: 0,
+      leaseUntil: 10,
+      maxAttempts: 1,
+      durableExhaustion: true
+    }) !== 1) {
+      violated("the base durable claim was not taken");
+      return;
+    }
+    await store.claim(15, {
+      now: 11,
+      leaseUntil: 20,
+      maxAttempts: 1,
+      durableExhaustion: true
+    });
+    const baseExhaustion = (await store.dueExhaustions({ limit: 20 })).find(({ updateId }) => updateId === 15);
+    if (!baseExhaustion) {
+      violated("a base durable claim became an invisible exhaustion");
+      return;
+    }
+    if (!await store.acknowledgeExhaustion(baseExhaustion, 20))
+      violated("a base durable exhaustion could not be acknowledged");
   }
 };
 async function checkTelegramUpdateStore(make) {
@@ -1567,6 +2099,7 @@ async function checkTelegramUpdateStore(make) {
   return violations;
 }
 // src/telegram/update-store-postgres.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
 var TABLE_NAME = /^[A-Za-z_][A-Za-z0-9_]{0,62}$/;
 function checkedTable(table) {
   if (!TABLE_NAME.test(table)) {
@@ -1584,8 +2117,10 @@ function postgresTelegramUpdateStoreSchema(table = "telegram_updates") {
   due_at BIGINT NOT NULL,
   received_at BIGINT NOT NULL,
   settled_at BIGINT,
-  error TEXT
+  error TEXT,
+  claim_id TEXT
 );
+ALTER TABLE ${name} ADD COLUMN IF NOT EXISTS claim_id TEXT;
 CREATE INDEX IF NOT EXISTS ${name}_due ON ${name} (state, due_at);`;
 }
 var CLAIMABLE = `(state = 'pending' OR (state = 'failed' AND due_at <= $1::bigint)
@@ -1601,7 +2136,7 @@ function integer(value) {
 function field(row, name) {
   return typeof row === "object" && row !== null && name in row ? Reflect.get(row, name) : undefined;
 }
-function postgresTelegramUpdateStore(config) {
+function createPostgresTelegramUpdateContext(config) {
   const table = checkedTable(config.table ?? "telegram_updates");
   const { query } = config;
   let ready;
@@ -1617,6 +2152,54 @@ function postgresTelegramUpdateStore(config) {
     }
     return query(text, parameters);
   };
+  const settleOwned = async (updateId, attempt, settlement, claimId) => {
+    const rows = await run(`UPDATE ${table} SET state = $1::text, due_at = COALESCE($2::bigint, due_at),
+         settled_at = $3::bigint, error = $4::text
+       WHERE update_id = $5::bigint AND attempts = $6::integer AND state = 'processing'
+         AND due_at >= $7::bigint
+         AND claim_id = $8::text
+       RETURNING update_id`, [
+      settlement.state,
+      settlement.state === "failed" ? settlement.retryAt : null,
+      settlement.state === "failed" ? null : settlement.at,
+      settlement.state === "completed" ? null : settlement.error,
+      updateId,
+      attempt,
+      settlement.at,
+      claimId
+    ]);
+    return rows.length > 0;
+  };
+  const takeAttempt = async (updateId, options) => {
+    const claimId = randomUUID2();
+    const [row] = await run(`UPDATE ${table} SET state = 'processing', attempts = attempts + 1,
+         due_at = $2::bigint, error = NULL, claim_id = $5::text
+       WHERE update_id = $3::bigint AND attempts < $4::integer AND ${CLAIMABLE}
+       RETURNING attempts, claim_id`, [options.now, options.leaseUntil, updateId, options.maxAttempts, claimId]);
+    const attempt = integer(field(row, "attempts"));
+    const persistedClaimId = field(row, "claim_id");
+    if (attempt !== undefined && typeof persistedClaimId === "string") {
+      return { updateId, attempt, claimId: persistedClaimId };
+    }
+    await run(`UPDATE ${table} SET state = 'abandoned', due_at = $1::bigint,
+         settled_at = CASE WHEN $4::integer = 1 THEN NULL ELSE $1::bigint END,
+         error = 'attempts spent', claim_id = COALESCE(claim_id, $5::text)
+       WHERE update_id = $2::bigint AND attempts >= $3::integer AND ${CLAIMABLE}
+       RETURNING update_id`, [options.now, updateId, options.maxAttempts, options.durableExhaustion ? 1 : 0, claimId]);
+    return;
+  };
+  const renewCurrent = async (updateId, attempt, leaseUntil, at, claimId) => {
+    const rows = await run(`UPDATE ${table} SET due_at = GREATEST(due_at, $1::bigint)
+       WHERE update_id = $2::bigint AND attempts = $3::integer AND state = 'processing'
+         AND ($4::bigint IS NULL OR due_at >= $4::bigint)
+         AND claim_id = $5::text
+       RETURNING update_id`, [leaseUntil, updateId, attempt, at ?? null, claimId]);
+    return rows.length > 0;
+  };
+  return { table, run, settleOwned, takeAttempt, renewCurrent };
+}
+function postgresTelegramUpdateStore(config) {
+  const { table, run, settleOwned, takeAttempt, renewCurrent } = createPostgresTelegramUpdateContext(config);
   return {
     async add(update) {
       const rows = await run(`INSERT INTO ${table} (update_id, body, state, attempts, due_at, received_at)
@@ -1625,35 +2208,45 @@ function postgresTelegramUpdateStore(config) {
       return rows.length > 0;
     },
     async claim(updateId, options) {
+      if (options.durableExhaustion)
+        return (await takeAttempt(updateId, options))?.attempt;
       const [row] = await run(`UPDATE ${table} SET state = 'processing', attempts = attempts + 1,
            due_at = $2::bigint, error = NULL
          WHERE update_id = $3::bigint AND attempts < $4::integer AND ${CLAIMABLE}
          RETURNING attempts`, [options.now, options.leaseUntil, updateId, options.maxAttempts]);
-      const attempts = integer(field(row, "attempts"));
-      if (attempts !== undefined)
-        return attempts;
-      await run(`UPDATE ${table} SET state = 'abandoned', settled_at = $1::bigint, error = 'attempts spent'
+      const attempt = integer(field(row, "attempts"));
+      if (attempt !== undefined)
+        return attempt;
+      await run(`UPDATE ${table} SET state = 'abandoned', due_at = $1::bigint,
+           settled_at = CASE WHEN $4::integer = 1 THEN NULL ELSE $1::bigint END,
+           error = 'attempts spent'
          WHERE update_id = $2::bigint AND attempts >= $3::integer AND ${CLAIMABLE}
-         RETURNING update_id`, [options.now, updateId, options.maxAttempts]);
+         RETURNING update_id`, [options.now, updateId, options.maxAttempts, options.durableExhaustion ? 1 : 0]);
       return;
     },
-    async renew(updateId, attempt, leaseUntil) {
-      const rows = await run(`UPDATE ${table} SET due_at = $1::bigint
+    async claimOwned(updateId, options) {
+      return takeAttempt(updateId, options);
+    },
+    async renew(updateId, attempt, leaseUntil, at) {
+      const rows = await run(`UPDATE ${table} SET due_at = GREATEST(due_at, $1::bigint)
          WHERE update_id = $2::bigint AND attempts = $3::integer AND state = 'processing'
-         RETURNING update_id`, [leaseUntil, updateId, attempt]);
+           AND ($4::bigint IS NULL OR due_at >= $4::bigint)
+         RETURNING update_id`, [leaseUntil, updateId, attempt, at ?? null]);
       return rows.length > 0;
     },
     async settle(updateId, attempt, settlement) {
       await run(`UPDATE ${table} SET state = $1::text, due_at = COALESCE($2::bigint, due_at),
            settled_at = $3::bigint, error = $4::text
          WHERE update_id = $5::bigint AND attempts = $6::integer AND state = 'processing'
+           AND due_at >= $7::bigint
          RETURNING update_id`, [
         settlement.state,
         settlement.state === "failed" ? settlement.retryAt : null,
         settlement.state === "failed" ? null : settlement.at,
         settlement.state === "completed" ? null : settlement.error,
         updateId,
-        attempt
+        attempt,
+        settlement.at
       ]);
     },
     async due(options) {
@@ -1667,6 +2260,56 @@ function postgresTelegramUpdateStore(config) {
         return updateId !== undefined && typeof body === "string" ? [{ updateId, body }] : [];
       });
     },
+    async owns(identity, at) {
+      const rows = await run(`SELECT update_id FROM ${table}
+         WHERE update_id = $1::bigint AND attempts = $2::integer
+           AND state = 'processing' AND due_at >= $3::bigint
+           AND claim_id = $4::text
+         FOR UPDATE`, [identity.updateId, identity.attempt, at, identity.claimId]);
+      return rows.length > 0;
+    },
+    async renewOwned(identity, leaseUntil, at) {
+      return renewCurrent(identity.updateId, identity.attempt, leaseUntil, at, identity.claimId);
+    },
+    async settleOwned(identity, settlement) {
+      return settleOwned(identity.updateId, identity.attempt, settlement, identity.claimId);
+    },
+    async exhaust(identity, exhaustion) {
+      const rows = await run(`UPDATE ${table} SET state = 'abandoned', due_at = $1::bigint,
+           settled_at = NULL, error = $2::text
+         WHERE update_id = $3::bigint AND attempts = $4::integer AND state = 'processing'
+           AND due_at >= $1::bigint AND claim_id = $5::text
+         RETURNING update_id`, [
+        exhaustion.at,
+        exhaustion.error,
+        identity.updateId,
+        identity.attempt,
+        identity.claimId
+      ]);
+      return rows.length > 0;
+    },
+    async dueExhaustions(options) {
+      const rows = await run(`SELECT update_id, body, attempts, due_at, error, claim_id FROM ${table}
+         WHERE state = 'abandoned' AND settled_at IS NULL
+           AND ($2::bigint IS NULL OR update_id > $2::bigint)
+         ORDER BY update_id LIMIT $1::integer`, [options.limit, options.afterUpdateId ?? null]);
+      return rows.flatMap((row) => {
+        const updateId = integer(field(row, "update_id"));
+        const body = field(row, "body");
+        const attempt = integer(field(row, "attempts"));
+        const exhaustedAt = integer(field(row, "due_at"));
+        const error = field(row, "error");
+        const claimId = field(row, "claim_id");
+        return updateId !== undefined && typeof body === "string" && attempt !== undefined && typeof claimId === "string" && exhaustedAt !== undefined && typeof error === "string" ? [{ updateId, body, attempt, claimId, exhaustedAt, error }] : [];
+      });
+    },
+    async acknowledgeExhaustion(identity, at) {
+      const rows = await run(`UPDATE ${table} SET settled_at = $1::bigint
+         WHERE update_id = $2::bigint AND attempts = $3::integer
+           AND state = 'abandoned' AND settled_at IS NULL AND claim_id = $4::text
+         RETURNING update_id`, [at, identity.updateId, identity.attempt, identity.claimId]);
+      return rows.length > 0;
+    },
     async prune(before) {
       const rows = await run(`DELETE FROM ${table} WHERE state IN ('completed', 'abandoned') AND settled_at < $1::bigint
          RETURNING update_id`, [before]);
@@ -1675,9 +2318,68 @@ function postgresTelegramUpdateStore(config) {
   };
 }
 // src/telegram/update-store-sqlite.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
 var TABLE_NAME2 = /^[A-Za-z_][A-Za-z0-9_]{0,62}$/;
 var CLAIMABLE2 = `(state = 'pending' OR (state = 'failed' AND due_at <= ?1)
   OR (state = 'processing' AND due_at < ?1))`;
+function prepareTelegramSqliteUpdateStatements(database, table) {
+  database.exec(`CREATE TABLE IF NOT EXISTS ${table} (
+    update_id INTEGER PRIMARY KEY,
+    body TEXT NOT NULL,
+    state TEXT NOT NULL,
+    attempts INTEGER NOT NULL,
+    due_at INTEGER NOT NULL,
+    received_at INTEGER NOT NULL,
+    settled_at INTEGER,
+    error TEXT,
+    claim_id TEXT
+  );
+  CREATE INDEX IF NOT EXISTS ${table}_due ON ${table} (state, due_at);`);
+  const hasClaimId = () => database.prepare(`PRAGMA table_info(${table})`).all().some((row) => typeof row === "object" && row !== null && ("name" in row) && row.name === "claim_id");
+  if (!hasClaimId()) {
+    try {
+      database.exec(`ALTER TABLE ${table} ADD COLUMN claim_id TEXT`);
+    } catch (error) {
+      if (!hasClaimId())
+        throw error;
+    }
+  }
+  return {
+    insert: database.prepare(`INSERT OR IGNORE INTO ${table} (update_id, body, state, attempts, due_at, received_at)
+       VALUES (?1, ?2, 'pending', 0, ?3, ?3)`),
+    take: database.prepare(`UPDATE ${table} SET state = 'processing', attempts = attempts + 1, due_at = ?2,
+         error = NULL, claim_id = ?5
+       WHERE update_id = ?3 AND attempts < ?4 AND ${CLAIMABLE2}
+       RETURNING attempts, claim_id`),
+    spend: database.prepare(`UPDATE ${table} SET state = 'abandoned', due_at = ?1,
+         settled_at = CASE WHEN ?4 = 1 THEN NULL ELSE ?1 END, error = 'attempts spent',
+         claim_id = COALESCE(claim_id, ?5)
+       WHERE update_id = ?2 AND attempts >= ?3 AND ${CLAIMABLE2}`),
+    renew: database.prepare(`UPDATE ${table} SET due_at = MAX(due_at, ?1)
+       WHERE update_id = ?2 AND attempts = ?3 AND state = 'processing'
+         AND (?4 IS NULL OR due_at >= ?4) AND (?5 IS NULL OR claim_id = ?5)`),
+    settle: database.prepare(`UPDATE ${table} SET state = ?1, due_at = COALESCE(?2, due_at), settled_at = ?3, error = ?4
+       WHERE update_id = ?5 AND attempts = ?6 AND state = 'processing' AND due_at >= ?7
+         AND (?8 IS NULL OR claim_id = ?8)`),
+    due: database.prepare(`SELECT update_id, body FROM ${table}
+       WHERE (state = 'pending' AND received_at <= ?2) OR (state <> 'pending' AND ${CLAIMABLE2})
+       ORDER BY update_id LIMIT ?3`),
+    prune: database.prepare(`DELETE FROM ${table} WHERE state IN ('completed', 'abandoned') AND settled_at < ?1`),
+    owns: database.prepare(`SELECT update_id FROM ${table}
+       WHERE update_id = ?1 AND attempts = ?2 AND state = 'processing' AND due_at >= ?3
+         AND claim_id = ?4`),
+    exhaust: database.prepare(`UPDATE ${table} SET state = 'abandoned', due_at = ?1, settled_at = NULL, error = ?2
+       WHERE update_id = ?3 AND attempts = ?4 AND state = 'processing' AND due_at >= ?1
+         AND claim_id = ?5`),
+    dueExhaustions: database.prepare(`SELECT update_id, body, attempts, due_at, error, claim_id FROM ${table}
+       WHERE state = 'abandoned' AND settled_at IS NULL
+         AND (?2 IS NULL OR update_id > ?2)
+       ORDER BY update_id LIMIT ?1`),
+    acknowledgeExhaustion: database.prepare(`UPDATE ${table} SET settled_at = ?1
+       WHERE update_id = ?2 AND attempts = ?3 AND state = 'abandoned' AND settled_at IS NULL
+         AND claim_id = ?4`)
+  };
+}
 function rowOf(row) {
   if (typeof row !== "object" || row === null)
     return;
@@ -1685,57 +2387,85 @@ function rowOf(row) {
   const body = "body" in row ? row.body : undefined;
   return typeof updateId === "number" && typeof body === "string" ? { updateId, body } : undefined;
 }
+function exhaustionOf(row) {
+  if (typeof row !== "object" || row === null)
+    return;
+  const updateId = "update_id" in row ? row.update_id : undefined;
+  const body = "body" in row ? row.body : undefined;
+  const attempt = "attempts" in row ? row.attempts : undefined;
+  const exhaustedAt = "due_at" in row ? row.due_at : undefined;
+  const error = "error" in row ? row.error : undefined;
+  const claimId = "claim_id" in row ? row.claim_id : undefined;
+  return typeof updateId === "number" && typeof body === "string" && typeof attempt === "number" && typeof claimId === "string" && typeof exhaustedAt === "number" && typeof error === "string" ? { updateId, body, attempt, claimId, exhaustedAt, error } : undefined;
+}
 function sqliteTelegramUpdateStore(config) {
   const table = config.table ?? "telegram_updates";
   if (!TABLE_NAME2.test(table)) {
     throw new TypeError("[stitchkit] telegram update store: a table name is [A-Za-z_][A-Za-z0-9_]*");
   }
   const database = config.database;
-  database.exec(`CREATE TABLE IF NOT EXISTS ${table} (
-    update_id INTEGER PRIMARY KEY,
-    body TEXT NOT NULL,
-    state TEXT NOT NULL,
-    attempts INTEGER NOT NULL,
-    due_at INTEGER NOT NULL,
-    received_at INTEGER NOT NULL,
-    settled_at INTEGER,
-    error TEXT
-  );
-  CREATE INDEX IF NOT EXISTS ${table}_due ON ${table} (state, due_at);`);
-  const insert = database.prepare(`INSERT OR IGNORE INTO ${table} (update_id, body, state, attempts, due_at, received_at)
-     VALUES (?1, ?2, 'pending', 0, ?3, ?3)`);
-  const take = database.prepare(`UPDATE ${table} SET state = 'processing', attempts = attempts + 1, due_at = ?2, error = NULL
-     WHERE update_id = ?3 AND attempts < ?4 AND ${CLAIMABLE2} RETURNING attempts`);
-  const spend = database.prepare(`UPDATE ${table} SET state = 'abandoned', settled_at = ?1, error = 'attempts spent'
-     WHERE update_id = ?2 AND attempts >= ?3 AND ${CLAIMABLE2}`);
-  const renew = database.prepare(`UPDATE ${table} SET due_at = ?1 WHERE update_id = ?2 AND attempts = ?3 AND state = 'processing'`);
-  const settle = database.prepare(`UPDATE ${table} SET state = ?1, due_at = COALESCE(?2, due_at), settled_at = ?3, error = ?4
-     WHERE update_id = ?5 AND attempts = ?6 AND state = 'processing'`);
-  const due = database.prepare(`SELECT update_id, body FROM ${table}
-     WHERE (state = 'pending' AND received_at <= ?2) OR (state <> 'pending' AND ${CLAIMABLE2})
-     ORDER BY update_id LIMIT ?3`);
-  const prune = database.prepare(`DELETE FROM ${table} WHERE state IN ('completed', 'abandoned') AND settled_at < ?1`);
+  const {
+    insert,
+    take,
+    spend,
+    renew,
+    settle,
+    due,
+    prune,
+    owns,
+    exhaust,
+    dueExhaustions,
+    acknowledgeExhaustion
+  } = prepareTelegramSqliteUpdateStatements(database, table);
+  const settleCurrent = (updateId, attempt, settlement, claimId) => Number(settle.run(settlement.state, settlement.state === "failed" ? settlement.retryAt : null, settlement.state === "failed" ? null : settlement.at, settlement.state === "completed" ? null : settlement.error, updateId, attempt, settlement.at, claimId ?? null).changes) > 0;
+  const takeAttempt = (updateId, options) => {
+    const claimId = randomUUID3();
+    const [row] = take.all(options.now, options.leaseUntil, updateId, options.maxAttempts, claimId);
+    const attempt = typeof row === "object" && row !== null && "attempts" in row ? row.attempts : undefined;
+    const persistedClaimId = typeof row === "object" && row !== null && "claim_id" in row ? row.claim_id : undefined;
+    if (typeof attempt === "number" && typeof persistedClaimId === "string") {
+      return { updateId, attempt, claimId: persistedClaimId };
+    }
+    spend.run(options.now, updateId, options.maxAttempts, options.durableExhaustion ? 1 : 0, claimId);
+    return;
+  };
   return {
     async add(update) {
       return Number(insert.run(update.updateId, update.body, update.receivedAt).changes) > 0;
     },
     async claim(updateId, options) {
-      const [row] = take.all(options.now, options.leaseUntil, updateId, options.maxAttempts);
-      const attempts = typeof row === "object" && row !== null && "attempts" in row ? row.attempts : undefined;
-      if (typeof attempts === "number")
-        return attempts;
-      spend.run(options.now, updateId, options.maxAttempts);
-      return;
+      return takeAttempt(updateId, options)?.attempt;
+    },
+    async claimOwned(updateId, options) {
+      return takeAttempt(updateId, options);
     },
-    async renew(updateId, attempt, leaseUntil) {
-      return Number(renew.run(leaseUntil, updateId, attempt).changes) > 0;
+    async renew(updateId, attempt, leaseUntil, at) {
+      return Number(renew.run(leaseUntil, updateId, attempt, at ?? null, null).changes) > 0;
     },
     async settle(updateId, attempt, settlement) {
-      settle.run(settlement.state, settlement.state === "failed" ? settlement.retryAt : null, settlement.state === "failed" ? null : settlement.at, settlement.state === "completed" ? null : settlement.error, updateId, attempt);
+      settleCurrent(updateId, attempt, settlement);
     },
     async due(query) {
       return due.all(query.now, query.pendingBefore, query.limit).flatMap((row) => rowOf(row) ?? []);
     },
+    async owns(identity, at) {
+      return owns.all(identity.updateId, identity.attempt, at, identity.claimId).length > 0;
+    },
+    async renewOwned(identity, leaseUntil, at) {
+      return Number(renew.run(leaseUntil, identity.updateId, identity.attempt, at ?? null, identity.claimId).changes) > 0;
+    },
+    async settleOwned(identity, settlement) {
+      return settleCurrent(identity.updateId, identity.attempt, settlement, identity.claimId);
+    },
+    async exhaust(identity, exhaustion) {
+      return Number(exhaust.run(exhaustion.at, exhaustion.error, identity.updateId, identity.attempt, identity.claimId).changes) > 0;
+    },
+    async dueExhaustions(query) {
+      return dueExhaustions.all(query.limit, query.afterUpdateId ?? null).flatMap((row) => exhaustionOf(row) ?? []);
+    },
+    async acknowledgeExhaustion(identity, at) {
+      return Number(acknowledgeExhaustion.run(at, identity.updateId, identity.attempt, identity.claimId).changes) > 0;
+    },
     async prune(before) {
       return Number(prune.run(before).changes);
     }
@@ -1857,6 +2587,7 @@ export {
   TelegramBroadcastFailureSchema,
   TelegramLocalFileError,
   TelegramNotDispatchedError2 as TelegramNotDispatchedError,
+  TelegramUpdateOwnershipLostError,
   TelegramWebhookClaimError,
   callTelegramBotApi,
   checkTelegramUpdateStore,