switchroom 0.19.26 → 0.19.28

package/telegram-plugin/tests/finalize-callback-flood-policy.test.ts

@@ -0,0 +1,298 @@
+/**
+ * Outcome tests for #3891 — `finalizeCallback` must transit the ONE retry /
+ * flood policy, and a failed card repaint must not leave a live-looking
+ * keyboard.
+ *
+ * These are deliberately NOT unit tests of a helper. Each one drives the real
+ * `createRetryApiCall` + the real `makeFloodWaitRecorder` against a real temp
+ * state dir and asserts the observable artefact an operator or `switchroom
+ * doctor` would later read:
+ *
+ *   - `429-ledger.json` gains an episode for a 429 earned by a BUTTON TAP.
+ *   - `flood-wait.json` gains the window.
+ *   - after a repaint that fails post-retry, the card's keyboard is gone
+ *     (or, if it cannot be removed, the operator is told in-channel).
+ *
+ * Pre-fix (both legs calling `ctx.*` raw) every one of these fails: the
+ * ledger file is never created, and the keyboard survives untouched.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, rmSync, existsSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { GrammyError } from 'grammy'
+import {
+  finalizeCallback,
+  DEAD_CARD_NOTICE,
+  type FinalizeCallbackContext,
+  type FinalizeApiCall,
+} from '../inline-keyboard-callbacks.js'
+import { createRetryApiCall } from '../retry-api-call.js'
+import { makeFloodWaitRecorder, makeFloodWaitProbe } from '../flood-circuit-breaker.js'
+import {
+  readFlood429Ledger,
+  flood429LedgerPathFromFloodState,
+} from '../flood-429-ledger.js'
+
+/** Synthetic chat id — never a real operator chat (see check-no-pii-secrets). */
+const CHAT_ID = -1009900112233
+const MSG_ID = 4242
+
+let stateDir: string
+let floodStatePath: string
+
+beforeEach(() => {
+  stateDir = mkdtempSync(join(tmpdir(), 'sr-3891-'))
+  floodStatePath = join(stateDir, 'flood-wait.json')
+})
+afterEach(() => {
+  rmSync(stateDir, { recursive: true, force: true })
+})
+
+/** A Telegram 429 exactly as grammy surfaces it. */
+function flood429(retryAfter: number, method: string): GrammyError {
+  return new GrammyError(
+    `Call to '${method}' failed!`,
+    { ok: false, error_code: 429, description: 'Too Many Requests: retry after ' + retryAfter, parameters: { retry_after: retryAfter } },
+    method,
+    {},
+  )
+}
+
+/** A non-429, non-benign edit failure — the shape seen in the clerk incident. */
+function hardEditFailure(method = 'editMessageText'): GrammyError {
+  return new GrammyError(
+    `Call to '${method}' failed!`,
+    { ok: false, error_code: 400, description: "Bad Request: can't parse entities" },
+    method,
+    {},
+  )
+}
+
+/**
+ * The production wiring, verbatim in shape: `createRetryApiCall` with BOTH
+ * breaker hooks, writing to a temp state dir. No sleeping (fake sleep) so the
+ * flood-wait retry path runs at test speed.
+ */
+function realPolicy(): FinalizeApiCall {
+  const record = makeFloodWaitRecorder(floodStatePath)
+  const probe = makeFloodWaitProbe(floodStatePath)
+  return createRetryApiCall({
+    log: () => {},
+    sleep: async () => {},
+    onFloodWait: (retryAfterSec) => record(retryAfterSec),
+    floodWaitRemainingMs: probe,
+  })
+}
+
+interface Capture {
+  acks: number
+  edits: number
+  markupEdits: Array<Record<string, unknown>>
+  replies: string[]
+}
+
+function mkCtx(cap: Capture, behaviour: {
+  ack?: () => void
+  edit?: () => void
+  markup?: () => void
+  reply?: () => void
+} = {}): FinalizeCallbackContext {
+  return {
+    answerCallbackQuery: async () => { cap.acks++; behaviour.ack?.(); return true },
+    editMessageText: async () => { cap.edits++; behaviour.edit?.(); return { message_id: MSG_ID } },
+    editMessageReplyMarkup: async (opts) => {
+      cap.markupEdits.push(opts ?? {})
+      behaviour.markup?.()
+      return true
+    },
+    reply: async (text) => { cap.replies.push(text); behaviour.reply?.(); return { message_id: MSG_ID + 1 } },
+    callbackQuery: { message: { message_id: MSG_ID, chat: { id: CHAT_ID } } },
+  }
+}
+
+const mkCap = (): Capture => ({ acks: 0, edits: 0, markupEdits: [], replies: [] })
+
+describe('#3891 — tap-path 429s reach the flood ledger', () => {
+  it('records a 429 earned by answerCallbackQuery to the 429 ledger AND the window file', async () => {
+    const cap = mkCap()
+    let ackAttempts = 0
+    const ctx = mkCtx(cap, {
+      ack: () => { ackAttempts++; if (ackAttempts === 1) throw flood429(7, 'answerCallbackQuery') },
+    })
+
+    await finalizeCallback(ctx, {
+      ackText: 'Approved',
+      newText: 'resolved',
+      apiCall: realPolicy(),
+      log: () => {},
+    })
+    // The ack leg is fire-and-forget; let its retry chain settle.
+    await new Promise((r) => setTimeout(r, 0))
+
+    const ledgerPath = flood429LedgerPathFromFloodState(floodStatePath)
+    expect(existsSync(ledgerPath)).toBe(true)
+    const episodes = readFlood429Ledger(ledgerPath)
+    expect(episodes).toHaveLength(1)
+    expect(episodes[0]?.peakRetryAfterSec).toBe(7)
+    expect(episodes[0]?.count).toBe(1)
+    // The window file the send gate / doctor / watchdog all read.
+    expect(existsSync(floodStatePath)).toBe(true)
+    // And the tap still succeeded on retry — the policy is not a silencer.
+    expect(ackAttempts).toBe(2)
+  })
+
+  it('records a 429 earned by the card repaint, and the repaint still lands on retry', async () => {
+    const cap = mkCap()
+    let editAttempts = 0
+    const ctx = mkCtx(cap, {
+      edit: () => { editAttempts++; if (editAttempts === 1) throw flood429(11, 'editMessageText') },
+    })
+
+    await finalizeCallback(ctx, {
+      ackText: 'Approved',
+      newText: 'resolved',
+      apiCall: realPolicy(),
+      log: () => {},
+    })
+
+    const episodes = readFlood429Ledger(flood429LedgerPathFromFloodState(floodStatePath))
+    expect(episodes).toHaveLength(1)
+    expect(episodes[0]?.peakRetryAfterSec).toBe(11)
+    expect(editAttempts).toBe(2)
+    // Repaint landed on the retry, so no ladder rung was needed.
+    expect(cap.markupEdits).toHaveLength(0)
+    expect(cap.replies).toHaveLength(0)
+  })
+
+  it('scopes the flood window to the tapped chat, not `global`', async () => {
+    const seen: Array<{ chat_id?: string; verb?: string; priorityClass?: string }> = []
+    const apiCall: FinalizeApiCall = async (fn, opts) => {
+      seen.push({ chat_id: opts?.chat_id, verb: opts?.verb, priorityClass: opts?.priorityClass })
+      return fn()
+    }
+    const cap = mkCap()
+    await finalizeCallback(mkCtx(cap), { ackText: 'ok', newText: 'x', apiCall, log: () => {} })
+    await new Promise((r) => setTimeout(r, 0))
+
+    expect(seen).toHaveLength(2)
+    for (const s of seen) {
+      expect(s.chat_id).toBe(String(CHAT_ID))
+      // `critical` is the one class the send gate never sheds. A finalize
+      // repaint is the operator's ONLY confirmation their tap resolved a
+      // human-in-the-loop decision; shedding it is the incident itself.
+      expect(s.priorityClass).toBe('critical')
+    }
+    expect(seen.map((s) => s.verb)).toEqual(['answerCallbackQuery', 'editMessageText'])
+  })
+
+  it('survives a callbackQuery with no chat (degrades to an unscoped window, never throws)', async () => {
+    const seen: Array<string | undefined> = []
+    const apiCall: FinalizeApiCall = async (fn, opts) => { seen.push(opts?.chat_id); return fn() }
+    const cap = mkCap()
+    const ctx = { ...mkCtx(cap), callbackQuery: undefined }
+    await expect(
+      finalizeCallback(ctx, { ackText: 'ok', newText: 'x', apiCall, log: () => {} }),
+    ).resolves.toBeUndefined()
+    expect(seen.every((s) => s === undefined)).toBe(true)
+  })
+})
+
+describe('#3891 — a failed repaint never leaves a live-looking card', () => {
+  it('strips the keyboard when the body repaint fails post-retry', async () => {
+    const cap = mkCap()
+    const logs: string[] = []
+    const ctx = mkCtx(cap, { edit: () => { throw hardEditFailure() } })
+
+    await finalizeCallback(ctx, {
+      ackText: 'Approved',
+      newText: '**bad _markdown',
+      apiCall: realPolicy(),
+      log: (l) => logs.push(l),
+    })
+
+    // THE outcome: the card is no longer tappable.
+    expect(cap.markupEdits).toHaveLength(1)
+    expect(cap.markupEdits[0]?.reply_markup).toEqual({ inline_keyboard: [] })
+    // Not silent, either.
+    expect(logs.some((l) => l.includes('editMessageText failed'))).toBe(true)
+    expect(logs.some((l) => l.includes('no longer tappable'))).toBe(true)
+    // No need to shout in-channel — rung 2 fixed it.
+    expect(cap.replies).toHaveLength(0)
+  })
+
+  it('tells the operator in-channel when the keyboard cannot be stripped either', async () => {
+    const cap = mkCap()
+    const logs: string[] = []
+    const ctx = mkCtx(cap, {
+      edit: () => { throw hardEditFailure() },
+      markup: () => { throw hardEditFailure('editMessageReplyMarkup') },
+    })
+
+    await finalizeCallback(ctx, {
+      ackText: 'Approved',
+      newText: 'resolved',
+      apiCall: realPolicy(),
+      log: (l) => logs.push(l),
+    })
+
+    expect(cap.replies).toEqual([DEAD_CARD_NOTICE])
+    // The notice must name the buttons as stale — that is the whole point.
+    expect(DEAD_CARD_NOTICE).toContain('STALE')
+  })
+
+  it('a repaint failure does NOT block the model wake-up (invariant 3 holds)', async () => {
+    const cap = mkCap()
+    let synthFired = false
+    const ctx = mkCtx(cap, {
+      edit: () => { throw hardEditFailure() },
+      markup: () => { throw hardEditFailure('editMessageReplyMarkup') },
+      reply: () => { throw hardEditFailure('sendMessage') },
+    })
+
+    await finalizeCallback(ctx, {
+      ackText: 'Approved',
+      newText: 'resolved',
+      apiCall: realPolicy(),
+      synthInbound: () => { synthFired = true },
+      log: () => {},
+    })
+
+    expect(synthFired).toBe(true)
+  })
+
+  it('does NOT run the ladder when the repaint succeeds', async () => {
+    const cap = mkCap()
+    await finalizeCallback(mkCtx(cap), {
+      ackText: 'Approved',
+      newText: 'resolved',
+      apiCall: realPolicy(),
+      log: () => {},
+    })
+    expect(cap.edits).toBe(1)
+    expect(cap.markupEdits).toHaveLength(0)
+    expect(cap.replies).toHaveLength(0)
+  })
+
+  it('treats the two BENIGN edit failures as done — the retry policy swallows them, no ladder', async () => {
+    // MESSAGE_TO_EDIT_NOT_FOUND: the operator deleted the card. There is no
+    // keyboard left to disarm, so shouting about a stale card would be noise.
+    const cap = mkCap()
+    const ctx = mkCtx(cap, {
+      edit: () => {
+        throw new GrammyError(
+          "Call to 'editMessageText' failed!",
+          { ok: false, error_code: 400, description: 'Bad Request: message to edit not found' },
+          'editMessageText',
+          {},
+        )
+      },
+    })
+    await finalizeCallback(ctx, {
+      ackText: 'Approved', newText: 'resolved', apiCall: realPolicy(), log: () => {},
+    })
+    expect(cap.markupEdits).toHaveLength(0)
+    expect(cap.replies).toHaveLength(0)
+  })
+})

package/telegram-plugin/tests/finalize-callback.test.ts

@@ -16,6 +16,8 @@ import { finalizeCallback, type FinalizeCallbackContext } from '../inline-keyboa
 interface Capture {
   acks: Array<{ text?: string; show_alert?: boolean }>
   edits: Array<{ text: string | { markdown: string }; opts: Record<string, unknown> }>
+  markupEdits: Array<Record<string, unknown>>
+  replies: string[]
   ackThrows?: Error
   editThrows?: Error
 }
@@ -32,13 +34,30 @@ function mkCtx(cap: Capture): FinalizeCallbackContext {
       if (cap.editThrows) throw cap.editThrows
       return { message_id: 1 }
     },
+    editMessageReplyMarkup: async (opts) => {
+      cap.markupEdits.push(opts ?? {})
+      return true
+    },
+    reply: async (text) => {
+      cap.replies.push(text)
+      return { message_id: 2 }
+    },
   }
 }
 
+/**
+ * Passthrough stand-in for the gateway's `robustApiCall` (#3891). The helper
+ * now REQUIRES the retry/flood seam; these three-invariant cases are about the
+ * invariants, not the policy, so they hand in a transparent one. The policy's
+ * own outcomes are pinned in `finalize-callback-flood-policy.test.ts`.
+ */
+const passthrough = <T>(fn: () => Promise<T>): Promise<T> => fn()
+
 describe('finalizeCallback — three-invariant contract', () => {
   it('invariant 1: acks the callback with the supplied toast text', async () => {
-    const cap: Capture = { acks: [], edits: [] }
+    const cap: Capture = { acks: [], edits: [], markupEdits: [], replies: [] }
     await finalizeCallback(mkCtx(cap), {
+      apiCall: passthrough,
       ackText: 'Approved',
       newText: 'Original prompt\n\n✓ Approved by @op',
     })
@@ -48,8 +67,9 @@ describe('finalizeCallback — three-invariant contract', () => {
   })
 
   it('invariant 1: alert=true renders as full modal (show_alert: true)', async () => {
-    const cap: Capture = { acks: [], edits: [] }
+    const cap: Capture = { acks: [], edits: [], markupEdits: [], replies: [] }
     await finalizeCallback(mkCtx(cap), {
+      apiCall: passthrough,
       ackText: 'Vault grant revoked',
       alert: true,
       newText: '...',
@@ -58,8 +78,9 @@ describe('finalizeCallback — three-invariant contract', () => {
   })
 
   it('invariant 2: strips reply_markup AND rich-edits the body in one atomic call', async () => {
-    const cap: Capture = { acks: [], edits: [] }
+    const cap: Capture = { acks: [], edits: [], markupEdits: [], replies: [] }
     await finalizeCallback(mkCtx(cap), {
+      apiCall: passthrough,
       ackText: 'Approved',
       newText: '**✓ Approved**\n\nGrant minted at 22:38 UTC',
     })
@@ -75,8 +96,8 @@ describe('finalizeCallback — three-invariant contract', () => {
   })
 
   it('invariant 2: literalText edits a plain string (no rich wrapper, no parse_mode)', async () => {
-    const cap: Capture = { acks: [], edits: [] }
-    await finalizeCallback(mkCtx(cap), { ackText: 'ok', newText: 'plain', literalText: true })
+    const cap: Capture = { acks: [], edits: [], markupEdits: [], replies: [] }
+    await finalizeCallback(mkCtx(cap), { ackText: 'ok', newText: 'plain', literalText: true, apiCall: passthrough })
     expect(cap.edits[0]?.text).toBe('plain')
     expect(cap.edits[0]?.opts.parse_mode).toBeUndefined()
   })
@@ -91,8 +112,11 @@ describe('finalizeCallback — three-invariant contract', () => {
         order.push('edit-end')
         return { message_id: 1 }
       },
+      editMessageReplyMarkup: async () => { order.push('markup'); return true },
+      reply: async () => { order.push('reply'); return { message_id: 2 } },
     }
     await finalizeCallback(ctx, {
+      apiCall: passthrough,
       ackText: 'ok',
       newText: '...',
       synthInbound: () => { order.push('synth') },
@@ -108,8 +132,9 @@ describe('finalizeCallback — three-invariant contract', () => {
 
   it('invariant 3: async synthInbound is awaited', async () => {
     let synthResolved = false
-    const cap: Capture = { acks: [], edits: [] }
+    const cap: Capture = { acks: [], edits: [], markupEdits: [], replies: [] }
     await finalizeCallback(mkCtx(cap), {
+      apiCall: passthrough,
       ackText: 'ok',
       newText: '...',
       synthInbound: async () => {
@@ -122,9 +147,10 @@ describe('finalizeCallback — three-invariant contract', () => {
 
   it('invariant 3: synthInbound errors are caught + logged, never propagated', async () => {
     const logs: string[] = []
-    const cap: Capture = { acks: [], edits: [] }
+    const cap: Capture = { acks: [], edits: [], markupEdits: [], replies: [] }
     await expect(
       finalizeCallback(mkCtx(cap), {
+        apiCall: passthrough,
         ackText: 'ok',
         newText: '...',
         synthInbound: () => { throw new Error('inject_inbound IPC closed') },
@@ -143,9 +169,12 @@ describe('finalizeCallback — three-invariant contract', () => {
     const cap: Capture = {
       acks: [],
       edits: [],
+      markupEdits: [],
+      replies: [],
       editThrows: new Error('Bad Request: message to edit not found'),
     }
     await finalizeCallback(mkCtx(cap), {
+      apiCall: passthrough,
       ackText: 'Approved',
       newText: '...',
       synthInbound: () => { synthFired = true },
@@ -163,9 +192,12 @@ describe('finalizeCallback — three-invariant contract', () => {
     const cap: Capture = {
       acks: [],
       edits: [],
+      markupEdits: [],
+      replies: [],
       ackThrows: new Error('query is too old'),
     }
     await finalizeCallback(mkCtx(cap), {
+      apiCall: passthrough,
       ackText: 'Approved',
       newText: 'edited body',
       synthInbound: () => { synthFired = true },
@@ -181,8 +213,9 @@ describe('finalizeCallback — three-invariant contract', () => {
   })
 
   it('synthInbound is optional — surfaces with no model in the loop just ack + edit', async () => {
-    const cap: Capture = { acks: [], edits: [] }
+    const cap: Capture = { acks: [], edits: [], markupEdits: [], replies: [] }
     await finalizeCallback(mkCtx(cap), {
+      apiCall: passthrough,
       ackText: 'Dismissed',
       newText: '✗ Dismissed',
     })

package/telegram-plugin/tests/fixtures/real-429-stream.ts

@@ -0,0 +1,220 @@
+/**
+ * The real 2026-07 Telegram 429 stream, verbatim.
+ *
+ * Every `telegram gateway: 429 …` line one production agent's gateway emitted
+ * between 2026-07-12 and 2026-07-27, extracted from `gateway-supervisor.log`
+ * (plus its rotated `.gz`) as
+ * `[<iso>] … (flood ban of <n>s | rate limited, waiting <n>s)`.
+ * 170 observations; nothing sampled, synthesised, or reordered. Timestamps and
+ * `retry_after` values only — no ids, no chat content.
+ *
+ * This is the fixture the flood-pressure classifier is proved against, because
+ * the shape is the whole problem:
+ *
+ *   - 72 of the 170 are short rate nudges, the largest being 5s. They are
+ *     invisible to the operator: `retryApiCall` sleeps them and the send lands.
+ *   - The smallest `retry_after` belonging to a real ban is 282s. There is no
+ *     observed traffic between 5s and 282s, so the benign band is wide.
+ *   - 87 of the remaining observations are ONE ban (2026-07-27T20:19:56Z,
+ *     `retry_after=15908`) re-observed every ~5s as it counted down. Any signal
+ *     built on event COUNT explodes here, during the outage it should have
+ *     predicted.
+ *
+ * The four real bans:
+ *   2026-07-12T05:06:46Z  retry_after=21397  (5.9h)
+ *   2026-07-13T03:17:47Z  retry_after=27951  (7.8h)
+ *   2026-07-25T23:43:07Z  retry_after=3713   (62min)
+ *   2026-07-27T20:19:56Z  retry_after=15908  (4.4h)  ← the incident
+ *
+ * Generated once from the live logs; do not edit by hand.
+ */
+
+/** One observed 429: ISO timestamp + Telegram's `parameters.retry_after`. */
+export interface RawFlood429 {
+  iso: string
+  ts: number
+  retryAfterSec: number
+}
+
+const RAW: ReadonlyArray<{ iso: string; retryAfterSec: number }> = [
+  { iso: "2026-07-12T00:43:42.969Z", retryAfterSec: 3 },
+  { iso: "2026-07-12T00:43:52.754Z", retryAfterSec: 3 },
+  { iso: "2026-07-12T05:06:46.641Z", retryAfterSec: 21397 },
+  { iso: "2026-07-12T23:39:24.579Z", retryAfterSec: 436 },
+  { iso: "2026-07-13T00:37:18.647Z", retryAfterSec: 563 },
+  { iso: "2026-07-13T00:37:19.162Z", retryAfterSec: 563 },
+  { iso: "2026-07-13T01:42:00.795Z", retryAfterSec: 283 },
+  { iso: "2026-07-13T01:42:01.269Z", retryAfterSec: 282 },
+  { iso: "2026-07-13T01:42:01.741Z", retryAfterSec: 282 },
+  { iso: "2026-07-13T02:39:43.308Z", retryAfterSec: 425 },
+  { iso: "2026-07-13T03:17:47.764Z", retryAfterSec: 27951 },
+  { iso: "2026-07-14T01:00:55.498Z", retryAfterSec: 3 },
+  { iso: "2026-07-14T01:01:05.283Z", retryAfterSec: 3 },
+  { iso: "2026-07-14T01:42:51.141Z", retryAfterSec: 3 },
+  { iso: "2026-07-14T01:43:00.941Z", retryAfterSec: 3 },
+  { iso: "2026-07-14T10:17:08.494Z", retryAfterSec: 3 },
+  { iso: "2026-07-14T10:17:18.394Z", retryAfterSec: 3 },
+  { iso: "2026-07-15T06:47:31.287Z", retryAfterSec: 3 },
+  { iso: "2026-07-15T11:28:14.054Z", retryAfterSec: 3 },
+  { iso: "2026-07-15T11:28:23.913Z", retryAfterSec: 3 },
+  { iso: "2026-07-16T01:48:28.656Z", retryAfterSec: 3 },
+  { iso: "2026-07-16T01:48:38.477Z", retryAfterSec: 3 },
+  { iso: "2026-07-16T02:37:16.659Z", retryAfterSec: 3 },
+  { iso: "2026-07-16T02:37:26.496Z", retryAfterSec: 3 },
+  { iso: "2026-07-16T07:39:14.389Z", retryAfterSec: 3 },
+  { iso: "2026-07-16T07:39:24.206Z", retryAfterSec: 3 },
+  { iso: "2026-07-16T19:29:32.965Z", retryAfterSec: 3 },
+  { iso: "2026-07-16T19:29:42.817Z", retryAfterSec: 3 },
+  { iso: "2026-07-16T21:32:57.539Z", retryAfterSec: 5 },
+  { iso: "2026-07-17T00:04:44.818Z", retryAfterSec: 3 },
+  { iso: "2026-07-17T00:04:54.594Z", retryAfterSec: 3 },
+  { iso: "2026-07-17T02:45:40.820Z", retryAfterSec: 3 },
+  { iso: "2026-07-17T02:45:50.608Z", retryAfterSec: 3 },
+  { iso: "2026-07-17T06:10:38.674Z", retryAfterSec: 3 },
+  { iso: "2026-07-17T06:10:48.510Z", retryAfterSec: 3 },
+  { iso: "2026-07-17T07:55:18.855Z", retryAfterSec: 3 },
+  { iso: "2026-07-17T07:55:28.640Z", retryAfterSec: 3 },
+  { iso: "2026-07-17T09:21:15.798Z", retryAfterSec: 3 },
+  { iso: "2026-07-18T22:35:20.897Z", retryAfterSec: 3 },
+  { iso: "2026-07-19T01:25:52.829Z", retryAfterSec: 3 },
+  { iso: "2026-07-19T01:26:02.649Z", retryAfterSec: 3 },
+  { iso: "2026-07-19T03:29:55.399Z", retryAfterSec: 3 },
+  { iso: "2026-07-19T03:30:05.203Z", retryAfterSec: 3 },
+  { iso: "2026-07-19T06:05:47.796Z", retryAfterSec: 3 },
+  { iso: "2026-07-19T06:05:57.632Z", retryAfterSec: 3 },
+  { iso: "2026-07-19T10:21:12.347Z", retryAfterSec: 3 },
+  { iso: "2026-07-19T10:21:22.178Z", retryAfterSec: 3 },
+  { iso: "2026-07-19T10:21:50.826Z", retryAfterSec: 3 },
+  { iso: "2026-07-19T10:22:00.651Z", retryAfterSec: 3 },
+  { iso: "2026-07-19T10:22:10.486Z", retryAfterSec: 3 },
+  { iso: "2026-07-19T10:47:10.609Z", retryAfterSec: 3 },
+  { iso: "2026-07-19T10:47:20.439Z", retryAfterSec: 3 },
+  { iso: "2026-07-19T10:47:30.277Z", retryAfterSec: 3 },
+  { iso: "2026-07-20T01:40:22.311Z", retryAfterSec: 3 },
+  { iso: "2026-07-20T01:40:32.183Z", retryAfterSec: 3 },
+  { iso: "2026-07-20T02:26:37.436Z", retryAfterSec: 3 },
+  { iso: "2026-07-20T02:26:47.514Z", retryAfterSec: 3 },
+  { iso: "2026-07-21T11:14:47.910Z", retryAfterSec: 3 },
+  { iso: "2026-07-21T11:14:57.729Z", retryAfterSec: 3 },
+  { iso: "2026-07-21T22:59:02.412Z", retryAfterSec: 3 },
+  { iso: "2026-07-21T22:59:12.189Z", retryAfterSec: 3 },
+  { iso: "2026-07-23T19:58:39.060Z", retryAfterSec: 3 },
+  { iso: "2026-07-24T08:22:21.126Z", retryAfterSec: 3 },
+  { iso: "2026-07-24T09:00:54.528Z", retryAfterSec: 3 },
+  { iso: "2026-07-24T09:01:04.413Z", retryAfterSec: 3 },
+  { iso: "2026-07-24T21:47:04.852Z", retryAfterSec: 3 },
+  { iso: "2026-07-24T21:49:20.213Z", retryAfterSec: 3 },
+  { iso: "2026-07-24T21:49:30.004Z", retryAfterSec: 3 },
+  { iso: "2026-07-24T21:49:39.786Z", retryAfterSec: 3 },
+  { iso: "2026-07-25T05:24:04.941Z", retryAfterSec: 3 },
+  { iso: "2026-07-25T22:50:39.203Z", retryAfterSec: 3 },
+  { iso: "2026-07-25T22:50:48.981Z", retryAfterSec: 3 },
+  { iso: "2026-07-25T23:43:07.861Z", retryAfterSec: 3713 },
+  { iso: "2026-07-26T14:07:07.428Z", retryAfterSec: 3 },
+  { iso: "2026-07-26T14:07:20.567Z", retryAfterSec: 3 },
+  { iso: "2026-07-26T14:07:30.355Z", retryAfterSec: 3 },
+  { iso: "2026-07-26T22:43:03.042Z", retryAfterSec: 3 },
+  { iso: "2026-07-27T05:50:52.944Z", retryAfterSec: 3 },
+  { iso: "2026-07-27T10:04:58.523Z", retryAfterSec: 3 },
+  { iso: "2026-07-27T10:05:12.142Z", retryAfterSec: 3 },
+  { iso: "2026-07-27T10:05:21.953Z", retryAfterSec: 3 },
+  { iso: "2026-07-27T16:22:32.052Z", retryAfterSec: 3 },
+  { iso: "2026-07-27T20:19:56.704Z", retryAfterSec: 15908 },
+  { iso: "2026-07-27T20:53:27.532Z", retryAfterSec: 13897 },
+  { iso: "2026-07-27T20:53:31.923Z", retryAfterSec: 13893 },
+  { iso: "2026-07-27T20:53:36.919Z", retryAfterSec: 13888 },
+  { iso: "2026-07-27T20:53:41.904Z", retryAfterSec: 13883 },
+  { iso: "2026-07-27T20:53:46.908Z", retryAfterSec: 13878 },
+  { iso: "2026-07-27T20:53:51.904Z", retryAfterSec: 13873 },
+  { iso: "2026-07-27T20:53:56.914Z", retryAfterSec: 13868 },
+  { iso: "2026-07-27T20:54:01.911Z", retryAfterSec: 13863 },
+  { iso: "2026-07-27T20:54:06.907Z", retryAfterSec: 13858 },
+  { iso: "2026-07-27T20:54:11.932Z", retryAfterSec: 13853 },
+  { iso: "2026-07-27T20:54:16.925Z", retryAfterSec: 13848 },
+  { iso: "2026-07-27T20:54:21.929Z", retryAfterSec: 13843 },
+  { iso: "2026-07-27T20:54:26.932Z", retryAfterSec: 13838 },
+  { iso: "2026-07-27T20:54:31.929Z", retryAfterSec: 13833 },
+  { iso: "2026-07-27T20:54:36.940Z", retryAfterSec: 13828 },
+  { iso: "2026-07-27T20:54:41.914Z", retryAfterSec: 13823 },
+  { iso: "2026-07-27T20:54:46.919Z", retryAfterSec: 13818 },
+  { iso: "2026-07-27T20:54:51.949Z", retryAfterSec: 13813 },
+  { iso: "2026-07-27T20:54:56.911Z", retryAfterSec: 13808 },
+  { iso: "2026-07-27T20:55:01.932Z", retryAfterSec: 13803 },
+  { iso: "2026-07-27T20:55:06.918Z", retryAfterSec: 13798 },
+  { iso: "2026-07-27T20:55:11.949Z", retryAfterSec: 13793 },
+  { iso: "2026-07-27T20:55:17.011Z", retryAfterSec: 13788 },
+  { iso: "2026-07-27T20:55:21.997Z", retryAfterSec: 13783 },
+  { iso: "2026-07-27T20:55:26.949Z", retryAfterSec: 13778 },
+  { iso: "2026-07-27T20:55:31.941Z", retryAfterSec: 13773 },
+  { iso: "2026-07-27T20:55:36.943Z", retryAfterSec: 13768 },
+  { iso: "2026-07-27T20:55:41.924Z", retryAfterSec: 13763 },
+  { iso: "2026-07-27T20:55:46.927Z", retryAfterSec: 13758 },
+  { iso: "2026-07-27T20:55:51.928Z", retryAfterSec: 13753 },
+  { iso: "2026-07-27T20:55:56.922Z", retryAfterSec: 13748 },
+  { iso: "2026-07-27T20:56:01.937Z", retryAfterSec: 13743 },
+  { iso: "2026-07-27T20:56:06.922Z", retryAfterSec: 13738 },
+  { iso: "2026-07-27T20:56:11.950Z", retryAfterSec: 13733 },
+  { iso: "2026-07-27T20:56:16.950Z", retryAfterSec: 13728 },
+  { iso: "2026-07-27T20:56:21.954Z", retryAfterSec: 13723 },
+  { iso: "2026-07-27T20:56:26.955Z", retryAfterSec: 13718 },
+  { iso: "2026-07-27T20:56:31.952Z", retryAfterSec: 13713 },
+  { iso: "2026-07-27T20:56:36.954Z", retryAfterSec: 13708 },
+  { iso: "2026-07-27T20:56:41.952Z", retryAfterSec: 13703 },
+  { iso: "2026-07-27T20:56:46.938Z", retryAfterSec: 13698 },
+  { iso: "2026-07-27T20:56:51.937Z", retryAfterSec: 13693 },
+  { iso: "2026-07-27T20:56:56.942Z", retryAfterSec: 13688 },
+  { iso: "2026-07-27T20:57:01.984Z", retryAfterSec: 13683 },
+  { iso: "2026-07-27T20:57:06.955Z", retryAfterSec: 13678 },
+  { iso: "2026-07-27T20:57:11.959Z", retryAfterSec: 13673 },
+  { iso: "2026-07-27T20:57:16.976Z", retryAfterSec: 13668 },
+  { iso: "2026-07-27T20:57:21.964Z", retryAfterSec: 13663 },
+  { iso: "2026-07-27T20:57:26.962Z", retryAfterSec: 13658 },
+  { iso: "2026-07-27T20:57:31.968Z", retryAfterSec: 13653 },
+  { iso: "2026-07-27T20:57:36.960Z", retryAfterSec: 13648 },
+  { iso: "2026-07-27T20:57:41.981Z", retryAfterSec: 13643 },
+  { iso: "2026-07-27T20:57:46.972Z", retryAfterSec: 13638 },
+  { iso: "2026-07-27T20:57:51.976Z", retryAfterSec: 13633 },
+  { iso: "2026-07-27T20:57:56.966Z", retryAfterSec: 13628 },
+  { iso: "2026-07-27T20:58:01.971Z", retryAfterSec: 13623 },
+  { iso: "2026-07-27T20:58:07.023Z", retryAfterSec: 13618 },
+  { iso: "2026-07-27T20:58:12.081Z", retryAfterSec: 13613 },
+  { iso: "2026-07-27T20:58:16.975Z", retryAfterSec: 13608 },
+  { iso: "2026-07-27T20:58:21.974Z", retryAfterSec: 13603 },
+  { iso: "2026-07-27T20:58:26.994Z", retryAfterSec: 13598 },
+  { iso: "2026-07-27T20:58:31.979Z", retryAfterSec: 13593 },
+  { iso: "2026-07-27T20:58:36.977Z", retryAfterSec: 13588 },
+  { iso: "2026-07-27T20:58:41.983Z", retryAfterSec: 13583 },
+  { iso: "2026-07-27T20:58:46.966Z", retryAfterSec: 13578 },
+  { iso: "2026-07-27T20:58:51.982Z", retryAfterSec: 13573 },
+  { iso: "2026-07-27T20:58:56.984Z", retryAfterSec: 13568 },
+  { iso: "2026-07-27T20:59:01.983Z", retryAfterSec: 13563 },
+  { iso: "2026-07-27T20:59:06.982Z", retryAfterSec: 13558 },
+  { iso: "2026-07-27T20:59:11.987Z", retryAfterSec: 13553 },
+  { iso: "2026-07-27T20:59:16.995Z", retryAfterSec: 13548 },
+  { iso: "2026-07-27T20:59:21.982Z", retryAfterSec: 13543 },
+  { iso: "2026-07-27T20:59:26.987Z", retryAfterSec: 13538 },
+  { iso: "2026-07-27T20:59:31.991Z", retryAfterSec: 13533 },
+  { iso: "2026-07-27T20:59:36.994Z", retryAfterSec: 13528 },
+  { iso: "2026-07-27T20:59:41.993Z", retryAfterSec: 13523 },
+  { iso: "2026-07-27T20:59:47.005Z", retryAfterSec: 13518 },
+  { iso: "2026-07-27T20:59:51.997Z", retryAfterSec: 13513 },
+  { iso: "2026-07-27T20:59:56.996Z", retryAfterSec: 13508 },
+  { iso: "2026-07-27T21:00:02.004Z", retryAfterSec: 13503 },
+  { iso: "2026-07-27T21:00:07.009Z", retryAfterSec: 13498 },
+  { iso: "2026-07-27T21:00:11.996Z", retryAfterSec: 13493 },
+  { iso: "2026-07-27T21:00:17.016Z", retryAfterSec: 13488 },
+  { iso: "2026-07-27T21:00:22.002Z", retryAfterSec: 13483 },
+  { iso: "2026-07-27T21:00:27.001Z", retryAfterSec: 13478 },
+  { iso: "2026-07-27T21:00:32.002Z", retryAfterSec: 13473 },
+  { iso: "2026-07-27T21:00:36.999Z", retryAfterSec: 13468 },
+]
+
+export const REAL_429_STREAM: ReadonlyArray<RawFlood429> = RAW.map((e) => ({
+  ...e,
+  ts: Date.parse(e.iso),
+}))
+
+/** Convenience: `Date.parse` of an ISO instant, for assertion timestamps. */
+export function at(iso: string): number {
+  return Date.parse(iso)
+}