stitchkit 0.116.0 → 0.118.0

package/dist/entrypoints/telegram.js

@@ -5,7 +5,7 @@ import"../index-2kbysk9s.js";
 import"../index-n8z3rvzw.js";
 import {
   attemptExclusiveLock
-} from "../index-z3d6smer.js";
+} from "../index-tdpmfks8.js";
 import {
   TELEGRAM_SEND_FAILURE_REASONS2,
   classifyTelegramSendFailure2
@@ -908,11 +908,8 @@ function telegramOperatorSender(config) {
 }
 // src/telegram/outbound-budget.ts
 import { z as z5 } from "zod";
-var DEFAULT_MESSAGES_PER_SECOND = 24;
-var DEFAULT_RETRY_AFTER_FALLBACK_MS = 1000;
-var TOKEN = z5.string().min(1, "token must not be empty");
-var MESSAGES_PER_SECOND = z5.number().positive().max(1000);
-var RETRY_AFTER_FALLBACK_MS = z5.number().int().nonnegative().max(MAX_TIMER_MS);
+
+// src/telegram/outbound-cost.ts
 var SEND_METHODS = new Set([
   "sendMessage",
   "sendPhoto",
@@ -959,15 +956,69 @@ function sendCost(method, payload) {
   const value = payload[field];
   return Array.isArray(value) ? Math.max(1, value.length) : 1;
 }
-function createBudget(rate, fallback, now, sleepFor) {
-  const interval = 1000 / rate;
+function chatOf(payload) {
+  if (!isRecord(payload))
+    return;
+  const chat = payload.chat_id;
+  return typeof chat === "number" || typeof chat === "string" ? String(chat) : undefined;
+}
+
+// src/telegram/outbound-pauses.ts
+function createOutboundPauses({ tokenPauseChats, tokenPauseWindowMs }, now, onPause) {
+  const chatPauses = new Map;
+  const refusedChats = new Map;
+  let pausedUntil = Number.NEGATIVE_INFINITY;
+  const pauseEnd = (milliseconds) => {
+    if (Number.isNaN(milliseconds) || milliseconds < 0) {
+      throw new RangeError("pause must be a non-negative number of milliseconds");
+    }
+    return now() + (Number.isFinite(milliseconds) ? milliseconds : Number.MAX_SAFE_INTEGER);
+  };
+  const pauseToken = (milliseconds) => {
+    pausedUntil = Math.max(pausedUntil, pauseEnd(milliseconds));
+    onPause();
+  };
+  const forgetExpired = (current) => {
+    for (const [chat, until] of chatPauses)
+      if (until <= current)
+        chatPauses.delete(chat);
+    for (const [chat, at] of refusedChats) {
+      if (current - at > tokenPauseWindowMs)
+        refusedChats.delete(chat);
+    }
+  };
+  return {
+    resumesAt: (chat) => Math.max(pausedUntil, (chat === undefined ? undefined : chatPauses.get(chat)) ?? Number.NEGATIVE_INFINITY),
+    pauseToken,
+    pauseChat(chat, milliseconds) {
+      const until = pauseEnd(milliseconds);
+      const current = now();
+      forgetExpired(current);
+      chatPauses.set(chat, Math.max(chatPauses.get(chat) ?? until, until));
+      refusedChats.set(chat, current);
+      onPause();
+      if (refusedChats.size < tokenPauseChats)
+        return;
+      refusedChats.clear();
+      pauseToken(milliseconds);
+    },
+    pausedForMs: () => Math.max(0, pausedUntil - now()),
+    pausedChats() {
+      forgetExpired(now());
+      return chatPauses.size;
+    }
+  };
+}
+
+// src/telegram/outbound-queue.ts
+function createOutboundQueue(interval, now, sleepFor, pauses) {
   const queue = [];
   let nextGrantAt = now();
-  let pausedUntil = Number.NEGATIVE_INFINITY;
   let granted = 0;
   let messages = 0;
   let draining = false;
-  let wake;
+  let waking;
+  let wakingAt = Number.POSITIVE_INFINITY;
   const wait = async (milliseconds, signal) => {
     const delay = Math.min(MAX_TIMER_MS, Math.max(0, milliseconds));
     if (delay <= 0)
@@ -978,20 +1029,40 @@ function createBudget(rate, fallback, now, sleepFor) {
     else
       await pending;
   };
-  const wakeWaiting = () => {
-    const current = wake;
-    wake = undefined;
+  const wake = () => {
+    const current = waking;
+    waking = undefined;
     current?.abort();
   };
-  const nextWaiter = () => queue.find((waiter) => waiter.lane === "interactive") ?? queue[0];
+  const nextWaiter = (current) => {
+    let bulk;
+    let held;
+    for (const waiter of queue) {
+      if (pauses.resumesAt(waiter.chat) > current) {
+        if (held === undefined || pauses.resumesAt(waiter.chat) < pauses.resumesAt(held.chat)) {
+          held = waiter;
+        }
+      } else if (waiter.lane === "interactive") {
+        return waiter;
+      } else {
+        bulk ??= waiter;
+      }
+    }
+    return bulk ?? held;
+  };
+  const detach = (waiter) => {
+    if (waiter.onAbort)
+      waiter.signal?.removeEventListener("abort", waiter.onAbort);
+    waiter.expiry?.abort();
+  };
   const remove = (waiter) => {
     const index = queue.indexOf(waiter);
     if (index === -1)
       return;
-    const next = nextWaiter() === waiter;
+    const next = nextWaiter(now()) === waiter;
     queue.splice(index, 1);
     if (next)
-      wakeWaiting();
+      wake();
   };
   const drain = async () => {
     if (draining)
@@ -999,38 +1070,38 @@ function createBudget(rate, fallback, now, sleepFor) {
     draining = true;
     try {
       while (queue.length > 0) {
-        const head = nextWaiter();
+        const current = now();
+        const head = nextWaiter(current);
         if (head === undefined)
           break;
         if (head.signal?.aborted) {
           remove(head);
           continue;
         }
-        const current = now();
-        const at = Math.max(current, nextGrantAt, pausedUntil);
+        const at = Math.max(current, nextGrantAt, pauses.resumesAt(head.chat));
         if (at > current) {
           const controller = new AbortController;
-          wake = controller;
+          waking = controller;
+          wakingAt = at;
           try {
             await wait(at - current, controller.signal);
           } catch (error) {
             if (!controller.signal.aborted) {
               for (const waiter of queue.splice(0)) {
-                if (waiter.onAbort)
-                  waiter.signal?.removeEventListener("abort", waiter.onAbort);
+                detach(waiter);
                 waiter.reject(error);
               }
               return;
             }
           } finally {
-            if (wake === controller)
-              wake = undefined;
+            if (waking === controller)
+              waking = undefined;
+            wakingAt = Number.POSITIVE_INFINITY;
           }
           continue;
         }
         queue.splice(queue.indexOf(head), 1);
-        if (head.onAbort)
-          head.signal?.removeEventListener("abort", head.onAbort);
+        detach(head);
         nextGrantAt = at + head.cost * interval;
         granted += 1;
         messages += head.cost;
@@ -1042,67 +1113,115 @@ function createBudget(rate, fallback, now, sleepFor) {
         drain();
     }
   };
-  const acquire = (cost, signal, options) => {
-    if (!Number.isSafeInteger(cost) || cost < 1) {
-      return Promise.reject(new RangeError("cost must be an integer of at least one message"));
-    }
-    if (signal?.aborted)
-      return Promise.reject(signal.reason);
-    return new Promise((resolve, reject) => {
-      const waiter = {
-        cost,
-        lane: options?.lane ?? "interactive",
-        resolve,
-        reject,
-        ...signal && { signal }
-      };
-      if (signal) {
-        const onAbort = () => {
-          remove(waiter);
-          reject(signal.reason);
-        };
-        waiter.onAbort = onAbort;
-        signal.addEventListener("abort", onAbort, { once: true });
-      }
-      queue.push(waiter);
-      drain();
+  const expireAfter = (waiter, maxWaitMs, reject) => {
+    waiter.expiry = new AbortController;
+    wait(maxWaitMs, waiter.expiry.signal).then(() => {
+      if (!queue.includes(waiter))
+        return;
+      remove(waiter);
+      detach(waiter);
+      reject(new TelegramNotDispatchedError2("queue", "the Telegram request waited longer than maxWaitMs for its turn"));
+    }, () => {
+      return;
     });
   };
-  const pauseFor = (milliseconds) => {
-    if (Number.isNaN(milliseconds) || milliseconds < 0) {
-      throw new RangeError("pause must be a non-negative number of milliseconds");
-    }
-    const duration = Number.isFinite(milliseconds) ? milliseconds : Number.MAX_SAFE_INTEGER;
-    pausedUntil = Math.max(pausedUntil, now() + duration);
-    wakeWaiting();
+  return {
+    acquire(cost, signal, options) {
+      if (!Number.isSafeInteger(cost) || cost < 1) {
+        return Promise.reject(new RangeError("cost must be an integer of at least one message"));
+      }
+      if (signal?.aborted)
+        return Promise.reject(signal.reason);
+      const maxWaitMs = options?.maxWaitMs;
+      if (maxWaitMs !== undefined && (!Number.isSafeInteger(maxWaitMs) || maxWaitMs < 1 || maxWaitMs > MAX_TIMER_MS)) {
+        return Promise.reject(new RangeError(`maxWaitMs must be an integer from 1 to ${MAX_TIMER_MS}`));
+      }
+      const chat = options?.chatId === undefined ? undefined : String(options.chatId);
+      return new Promise((resolve, reject) => {
+        const waiter = {
+          cost,
+          lane: options?.lane ?? "interactive",
+          chat,
+          resolve,
+          reject,
+          ...signal && { signal }
+        };
+        if (signal) {
+          const onAbort = () => {
+            remove(waiter);
+            detach(waiter);
+            reject(signal.reason);
+          };
+          waiter.onAbort = onAbort;
+          signal.addEventListener("abort", onAbort, { once: true });
+        }
+        if (maxWaitMs !== undefined)
+          expireAfter(waiter, maxWaitMs, reject);
+        queue.push(waiter);
+        if (Math.max(now(), nextGrantAt, pauses.resumesAt(chat)) < wakingAt)
+          wake();
+        drain();
+      });
+    },
+    wake,
+    wait,
+    counts: () => ({
+      granted,
+      messages,
+      queued: queue.length,
+      queuedBulk: queue.filter((waiter) => waiter.lane === "bulk").length
+    })
   };
-  const pauseAfter = (error) => {
+}
+
+// src/telegram/outbound-budget.ts
+var DEFAULT_MESSAGES_PER_SECOND = 24;
+var DEFAULT_RETRY_AFTER_FALLBACK_MS = 1000;
+var DEFAULT_TOKEN_PAUSE_CHATS = 3;
+var DEFAULT_TOKEN_PAUSE_WINDOW_MS = 5000;
+var TOKEN = z5.string().min(1, "token must not be empty");
+var MESSAGES_PER_SECOND = z5.number().positive().max(1000);
+var RETRY_AFTER_FALLBACK_MS = z5.number().int().nonnegative().max(MAX_TIMER_MS);
+var TOKEN_PAUSE_CHATS = z5.number().int().min(2).max(1000);
+var TOKEN_PAUSE_WINDOW_MS = z5.number().int().positive().max(MAX_TIMER_MS);
+function createBudget(policy, now, sleepFor) {
+  const { rate, fallback } = policy;
+  const pauses = createOutboundPauses(policy, now, () => queue.wake());
+  const queue = createOutboundQueue(1000 / rate, now, sleepFor, pauses);
+  const pauseAfter = (error, options) => {
     const failure = classifyTelegramSendFailure2(error);
     if (failure.reason !== "rate-limited")
       return;
-    pauseFor(failure.retryAfterSeconds === undefined ? fallback : failure.retryAfterSeconds * 1000);
+    const milliseconds = failure.retryAfterSeconds === undefined ? fallback : failure.retryAfterSeconds * 1000;
+    if (options?.chatId === undefined)
+      pauses.pauseToken(milliseconds);
+    else
+      pauses.pauseChat(String(options.chatId), milliseconds);
   };
-  const waitUntilResumed = async (signal) => {
+  const waitUntilResumed = async (signal, options) => {
+    const chat = options?.chatId === undefined ? undefined : String(options.chatId);
     while (true) {
       if (signal?.aborted)
         throw signal.reason;
-      const remaining = pausedUntil - now();
+      const remaining = pauses.resumesAt(chat) - now();
       if (remaining <= 0)
         return;
-      await wait(Math.min(remaining, MAX_TIMER_MS), signal);
+      await queue.wait(Math.min(remaining, MAX_TIMER_MS), signal);
     }
   };
   const run = async (method, payload, signal, send, options) => {
     if (signal?.aborted)
       throw signal.reason;
     const cost = sendCost(method, payload);
+    const chatId = options?.chatId ?? chatOf(payload);
+    const call = chatId === undefined ? {} : { chatId };
     if (cost > 0)
-      await acquire(cost, signal, options);
+      await queue.acquire(cost, signal, { ...options, ...call });
     if (signal?.aborted)
       throw signal.reason;
     const pauseOnRefusal = (refusal) => {
-      if (cost > 0)
-        pauseAfter(refusal);
+      if (cost > 0 && options?.refusal !== "call")
+        pauseAfter(refusal, call);
     };
     let result;
     try {
@@ -1115,22 +1234,19 @@ function createBudget(rate, fallback, now, sleepFor) {
       pauseOnRefusal(result);
     return result;
   };
-  const budget = {
+  return {
     run,
-    acquire,
-    pause: pauseFor,
+    acquire: queue.acquire,
+    pause: pauses.pauseToken,
     pauseAfter,
     waitUntilResumed,
     stats: () => ({
-      granted,
-      messages,
-      queued: queue.length,
-      queuedBulk: queue.filter((waiter) => waiter.lane === "bulk").length,
+      ...queue.counts(),
       messagesPerSecond: rate,
-      pausedForMs: Math.max(0, pausedUntil - now())
+      pausedForMs: pauses.pausedForMs(),
+      pausedChats: pauses.pausedChats()
     })
   };
-  return budget;
 }
 var budgets = new Map;
 function keyOf(token) {
@@ -1140,20 +1256,24 @@ function telegramOutboundBudget(config) {
   const token = TOKEN.parse(config.token);
   const rate = MESSAGES_PER_SECOND.parse(config.messagesPerSecond ?? DEFAULT_MESSAGES_PER_SECOND);
   const fallback = RETRY_AFTER_FALLBACK_MS.parse(config.retryAfterFallbackMs ?? DEFAULT_RETRY_AFTER_FALLBACK_MS);
+  const tokenPauseChats = TOKEN_PAUSE_CHATS.parse(config.tokenPauseChats ?? DEFAULT_TOKEN_PAUSE_CHATS);
+  const tokenPauseWindowMs = TOKEN_PAUSE_WINDOW_MS.parse(config.tokenPauseWindowMs ?? DEFAULT_TOKEN_PAUSE_WINDOW_MS);
   const key = keyOf(token);
   const existing = budgets.get(key);
   if (existing) {
-    const same = existing.rate === rate && existing.fallback === fallback && existing.nowOption === config.now && existing.sleepOption === config.sleep;
+    const same = existing.rate === rate && existing.fallback === fallback && existing.tokenPauseChats === tokenPauseChats && existing.tokenPauseWindowMs === tokenPauseWindowMs && existing.nowOption === config.now && existing.sleepOption === config.sleep;
     if (!same) {
       throw new Error("a Telegram outbound budget already exists for this token with different options");
     }
     return existing.budget;
   }
-  const budget = createBudget(rate, fallback, config.now ?? (() => performance.now()), config.sleep ?? sleep);
+  const budget = createBudget({ rate, fallback, tokenPauseChats, tokenPauseWindowMs }, config.now ?? (() => performance.now()), config.sleep ?? sleep);
   budgets.set(key, {
     budget,
     rate,
     fallback,
+    tokenPauseChats,
+    tokenPauseWindowMs,
     nowOption: config.now,
     sleepOption: config.sleep
   });
@@ -1502,6 +1622,72 @@ function createTelegramUpdateWorkSlots(maxConcurrent) {
     }
   };
 }
+function lineOf(update) {
+  for (const [key, payload] of Object.entries(update)) {
+    if (key === "update_id" || !isRecord(payload))
+      continue;
+    const message = isRecord(payload.message) ? payload.message : undefined;
+    for (const holder of [
+      payload.chat,
+      message?.chat,
+      payload.from,
+      payload.user,
+      payload.voter_chat
+    ]) {
+      if (isRecord(holder) && (typeof holder.id === "number" || typeof holder.id === "string")) {
+        return `chat:${holder.id}`;
+      }
+    }
+  }
+  return `update:${String(update.update_id)}`;
+}
+function createTelegramUpdateLines(run) {
+  const lines = new Map;
+  const scheduled = new Set;
+  return {
+    has: (updateId) => scheduled.has(updateId),
+    schedule(update) {
+      const updateId = Number(update.update_id);
+      if (scheduled.has(updateId))
+        return false;
+      scheduled.add(updateId);
+      const line = lineOf(update);
+      const next = (lines.get(line) ?? Promise.resolve()).then(() => run(update, updateId)).finally(() => {
+        scheduled.delete(updateId);
+        if (lines.get(line) === next)
+          lines.delete(line);
+      });
+      lines.set(line, next);
+      return true;
+    },
+    pending: () => [...lines.values()]
+  };
+}
+async function readTelegramUpdatesDue(store, read) {
+  const { skip, parse, reading, ...query } = read;
+  const rows = [];
+  let afterUpdateId;
+  for (;; ) {
+    const due = await store.due({
+      ...query,
+      ...afterUpdateId !== undefined && { afterUpdateId }
+    });
+    for (const row of due) {
+      if (afterUpdateId !== undefined && row.updateId <= afterUpdateId) {
+        throw new TypeError("[stitchkit] telegram update store: due returned a row at or before afterUpdateId");
+      }
+      if (skip(row.updateId))
+        continue;
+      const update = parse(row.body);
+      if (update)
+        rows.push(update);
+    }
+    afterUpdateId = due.at(-1)?.updateId;
+    if (due.length === 0 || !reading())
+      return rows;
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+}
 function createTelegramUpdateExhaustionScheduler(options) {
   const { config, store, now, slots, parse, reportStoreError } = options;
   const handler = config.handleExhaustion;
@@ -1709,25 +1895,6 @@ function defaultRetry(error, attempt) {
   const backoff = Math.min(5000 * 4 ** (attempt - 1), 15 * 60000);
   return Math.max(backoff, (failure.retryAfterSeconds ?? 0) * 1000);
 }
-function lineOf(update) {
-  for (const [key, payload] of Object.entries(update)) {
-    if (key === "update_id" || !isRecord(payload))
-      continue;
-    const message = isRecord(payload.message) ? payload.message : undefined;
-    for (const holder of [
-      payload.chat,
-      message?.chat,
-      payload.from,
-      payload.user,
-      payload.voter_chat
-    ]) {
-      if (isRecord(holder) && (typeof holder.id === "number" || typeof holder.id === "string")) {
-        return `chat:${holder.id}`;
-      }
-    }
-  }
-  return `update:${String(update.update_id)}`;
-}
 function parsed(body) {
   try {
     const value = JSON.parse(body);
@@ -1748,7 +1915,7 @@ function isTelegramUpdateFencedStore(store) {
 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) {
+function storeCapabilities(config) {
   const { store } = config;
   const exhaustionHandler = config.handleExhaustion;
   const attemptAware = "handleAttempt" in config;
@@ -1760,6 +1927,11 @@ function createTelegramUpdateIntake(config) {
   if (exhaustionHandler && !durable) {
     throw new TypeError("[stitchkit] telegram update intake: handleExhaustion requires a TelegramUpdateDurableStore");
   }
+  return { fenced, durable };
+}
+function createTelegramUpdateIntake(config) {
+  const { store } = config;
+  const { fenced, durable } = storeCapabilities(config);
   const now = config.now ?? Date.now;
   const retry = config.retry ?? defaultRetry;
   const maxAttempts = positive("maxAttempts", config.maxAttempts ?? 5);
@@ -1768,13 +1940,12 @@ function createTelegramUpdateIntake(config) {
   const sweepEveryMs = positive("sweepEveryMs", config.sweepEveryMs ?? 30000);
   const retainMs = config.retainMs ?? 86400000;
   const maxConcurrent = positive("maxConcurrent", config.maxConcurrent ?? 32);
-  const lines = new Map;
-  const scheduled = new Set;
   let started = false;
   let starting;
   let lifecycleGeneration = 0;
   let timer;
   let exhaustionCursor;
+  let arrivals;
   const storeError = (error, step) => {
     try {
       config.onStoreError?.(error, step);
@@ -1804,34 +1975,38 @@ function createTelegramUpdateIntake(config) {
     },
     ownershipLostReason: (identity) => new TelegramUpdateOwnershipLostError(identity)
   });
-  const schedule = (update) => {
-    const updateId = Number(update.update_id);
-    if (!started || scheduled.has(updateId))
-      return false;
-    scheduled.add(updateId);
-    const line = lineOf(update);
-    const next = (lines.get(line) ?? Promise.resolve()).then(async () => {
-      await slots.take();
-      try {
+  const lines = createTelegramUpdateLines(async (update, updateId) => {
+    await slots.take();
+    try {
+      if (started)
         await attempt(update, updateId);
-      } finally {
-        slots.release();
-      }
-    }).finally(() => {
-      scheduled.delete(updateId);
-      if (lines.get(line) === next)
-        lines.delete(line);
-    });
-    lines.set(line, next);
-    return true;
-  };
-  const sweep = async (pendingBefore) => {
+    } catch (error) {
+      storeError(error, "settle");
+    } finally {
+      slots.release();
+    }
+  });
+  const schedule = (update) => started && lines.schedule(update);
+  const sweep = async (pendingBefore, waiting = []) => {
     const at = now();
-    const due = await store.due({ now: at, pendingBefore, limit: SWEEP_BATCH });
+    const generation = lifecycleGeneration;
+    const rows = await readTelegramUpdatesDue(store, {
+      now: at,
+      pendingBefore,
+      limit: SWEEP_BATCH,
+      skip: lines.has,
+      parse: parsed,
+      reading: () => started
+    });
+    if (generation !== lifecycleGeneration)
+      return 0;
+    if (arrivals === waiting)
+      arrivals = undefined;
+    const waited = new Set(waiting);
+    const queue = [...rows, ...waiting].sort((left, right) => Number(left.update_id) - Number(right.update_id));
     let count = 0;
-    for (const row of due) {
-      const update = parsed(row.body);
-      if (update && schedule(update))
+    for (const update of queue) {
+      if (schedule(update) && !waited.has(update))
         count += 1;
     }
     if (durable) {
@@ -1852,6 +2027,11 @@ function createTelegramUpdateIntake(config) {
     await store.prune(at - retainMs);
     return count;
   };
+  const drained = async () => {
+    while (lines.pending().length > 0 || exhaustionScheduler.pending().length > 0) {
+      await Promise.all([...lines.pending(), ...exhaustionScheduler.pending()]);
+    }
+  };
   return {
     async accept(body) {
       const update = parsed(body);
@@ -1861,7 +2041,10 @@ function createTelegramUpdateIntake(config) {
       const added = await store.add({ updateId, body, receivedAt: now() });
       if (!added)
         return "duplicate";
-      schedule(update);
+      if (arrivals)
+        arrivals.push(update);
+      else
+        schedule(update);
       return "accepted";
     },
     start() {
@@ -1871,13 +2054,18 @@ function createTelegramUpdateIntake(config) {
         return Promise.resolve();
       started = true;
       const generation = ++lifecycleGeneration;
+      const waiting = [];
+      arrivals = waiting;
       const operation = (async () => {
         try {
-          await sweep(now());
+          await sweep(now(), waiting);
         } catch (error) {
           if (started && lifecycleGeneration === generation)
             started = false;
           throw error;
+        } finally {
+          if (arrivals === waiting)
+            arrivals = undefined;
         }
         if (!started || lifecycleGeneration !== generation)
           return;
@@ -1898,9 +2086,10 @@ function createTelegramUpdateIntake(config) {
     },
     sweep: () => sweep(now() - pendingGraceMs),
     async idle() {
-      while (lines.size > 0 || exhaustionScheduler.pending().length > 0) {
-        await Promise.all([...lines.values(), ...exhaustionScheduler.pending()]);
-      }
+      await starting?.catch(() => {
+        return;
+      });
+      await drained();
     },
     async close() {
       started = false;
@@ -1916,9 +2105,7 @@ function createTelegramUpdateIntake(config) {
           return;
         });
       }
-      while (lines.size > 0 || exhaustionScheduler.pending().length > 0) {
-        await Promise.all([...lines.values(), ...exhaustionScheduler.pending()]);
-      }
+      await drained();
     }
   };
 }
@@ -2001,7 +2188,7 @@ function memoryTelegramUpdateStore() {
       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 }));
+      return [...records.values()].filter((record) => record.state === "pending" ? record.receivedAt <= query.pendingBefore : isClaimable(record, query.now)).filter((record) => query.afterUpdateId === undefined || record.updateId > query.afterUpdateId).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);
@@ -2134,6 +2321,27 @@ var RULES = {
     if (!same(await store.due({ now: 100, pendingBefore: 0, limit: 10 }), []))
       violated("an update past maxAttempts was not abandoned");
   },
+  "due continues strictly after its cursor": async (store, violated) => {
+    for (const updateId of [1, 2, 3]) {
+      await store.add({ updateId, body: "b", receivedAt: 0 });
+    }
+    await store.claim(2, { ...claim, now: 0, leaseUntil: 10 });
+    await store.settle(2, 1, { state: "failed", at: 1, retryAt: 5, error: "x" });
+    const page = async (afterUpdateId) => (await store.due({
+      now: 5,
+      pendingBefore: 0,
+      limit: 2,
+      ...afterUpdateId !== undefined && { afterUpdateId }
+    })).map(({ updateId }) => updateId);
+    if (!same(await page(), [1, 2]))
+      violated("due did not begin at the first row");
+    if (!same(await page(1), [2, 3]))
+      violated("due lost a retry after its cursor");
+    if (!same(await page(2), [3]))
+      violated("due did not continue after its cursor");
+    if (!same(await page(3), []))
+      violated("due listed a row at or before its cursor");
+  },
   "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: 100 });
@@ -2512,9 +2720,15 @@ function postgresTelegramUpdateStore(config) {
     },
     async due(options) {
       const rows = await run(`SELECT update_id, body FROM ${table}
-         WHERE (state = 'pending' AND received_at <= $2::bigint)
-           OR (state <> 'pending' AND ${CLAIMABLE})
-         ORDER BY update_id LIMIT $3::integer`, [options.now, options.pendingBefore, options.limit]);
+         WHERE ((state = 'pending' AND received_at <= $2::bigint)
+           OR (state <> 'pending' AND ${CLAIMABLE}))
+           AND update_id > $4::bigint
+         ORDER BY update_id LIMIT $3::integer`, [
+        options.now,
+        options.pendingBefore,
+        options.limit,
+        options.afterUpdateId ?? Number.MIN_SAFE_INTEGER
+      ]);
       return rows.flatMap((row) => {
         const updateId = integer(field(row, "update_id"));
         const body = field(row, "body");
@@ -2623,7 +2837,8 @@ function prepareTelegramSqliteUpdateStatements(database, table) {
        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})
+       WHERE ((state = 'pending' AND received_at <= ?2) OR (state <> 'pending' AND ${CLAIMABLE2}))
+         AND update_id > ?4
        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}
@@ -2707,7 +2922,7 @@ function sqliteTelegramUpdateStore(config) {
       settleCurrent(updateId, attempt, settlement);
     },
     async due(query) {
-      return due.all(query.now, query.pendingBefore, query.limit).flatMap((row) => rowOf(row) ?? []);
+      return due.all(query.now, query.pendingBefore, query.limit, query.afterUpdateId ?? Number.MIN_SAFE_INTEGER).flatMap((row) => rowOf(row) ?? []);
     },
     async owns(identity, at) {
       return owns.all(identity.updateId, identity.attempt, at, identity.claimId).length > 0;