switchroom 0.19.26 → 0.19.27

package/telegram-plugin/tests/feed-edit-rate-ceiling.test.ts

@@ -0,0 +1,462 @@
+/**
+ * Regression suite for the 2026-07-27 activity-feed flood ban.
+ *
+ * What happened: agent `overlord`'s live activity/worker feed edited its card
+ * at a sustained 4-17 `editMessageText`/min on ONE DM chat for hours (326
+ * edits against 6 real replies in the final 20 minutes). Telegram answered
+ * with a **15908-second** per-chat flood ban, which severed every outbound
+ * reply — a cosmetic progress indicator took out the agent's entire ability
+ * to communicate.
+ *
+ * The edit-flood fuse was already installed. It did not bind ONCE, because
+ * its ceilings (20 edits/60s per message, 30 edits/60s per chat) sat ABOVE
+ * the rate that earned the ban, and because it was class-blind: it could not
+ * tell a repaint from a reply, so it could not hold repaints to a low rate
+ * without also throttling answers.
+ *
+ * Every test here asserts an OUTCOME at the transformer seam — how many calls
+ * actually reached the API — under a scenario drawn from the incident. Each
+ * one fails if the cosmetic ceiling, the reply reservation, the class
+ * propagation, or the escalating 429 backoff is removed.
+ */
+import { describe, it, expect } from 'vitest'
+import {
+  createEditFloodFuse,
+  editFloodFuseConfigFromEnv,
+  EDIT_FLOOD_FUSE_DEFAULTS,
+} from '../edit-flood-fuse.js'
+import { withOutboundClass, currentOutboundClass } from '../outbound-class.js'
+import { createSendGate, type Clock } from '../send-gate.js'
+
+const CHAT = '1001'
+const CARD = 4242
+
+class FakeClock implements Clock {
+  private cur = 0
+  private seq = 0
+  private timers: { at: number; id: number; resolve: () => void }[] = []
+
+  now(): number { return this.cur }
+
+  sleep(ms: number): Promise<void> {
+    return new Promise<void>((resolve) => {
+      this.timers.push({ at: this.cur + ms, id: this.seq++, resolve })
+    })
+  }
+
+  async advance(ms: number): Promise<void> {
+    const target = this.cur + ms
+    for (;;) {
+      await flush()
+      const due = this.timers.filter((t) => t.at <= target).sort((a, b) => a.at - b.at || a.id - b.id)
+      if (due.length === 0) break
+      const t = due[0]!
+      this.timers = this.timers.filter((x) => x !== t)
+      this.cur = t.at
+      t.resolve()
+      await flush()
+    }
+    this.cur = target
+    await flush()
+  }
+}
+
+function flush(): Promise<void> {
+  return new Promise((r) => setImmediate(r))
+}
+
+describe('feed flood ban — a cosmetic edit stream is held below the banned rate', () => {
+  it('replays the incident cadence: ~17 feed edits/min offered for 10 min admit ≤ the cosmetic ceiling', async () => {
+    const clock = new FakeClock()
+    const landed: number[] = []
+    const fuse = createEditFloodFuse({ clock })
+
+    // The incident's peak 10-minute bucket: 174 editMessageText calls against
+    // one card in one chat. Offered at a steady ~3.4s spacing, exactly as the
+    // feed heartbeat + worker ticks produced them.
+    const OFFERED = 174
+    const SPAN_MS = 600_000
+    const inflight: Promise<unknown>[] = []
+    for (let i = 0; i < OFFERED; i++) {
+      inflight.push(
+        withOutboundClass('cosmetic', () => fuse.apply(
+          'editMessageText',
+          { chat_id: CHAT, message_id: CARD, text: `frame ${i}` },
+          async () => { landed.push(i); return true },
+        )),
+      )
+      await clock.advance(Math.floor(SPAN_MS / OFFERED))
+    }
+    await clock.advance(EDIT_FLOOD_FUSE_DEFAULTS.maxDeferMs + 1_000)
+    await Promise.all(inflight)
+
+    const perMinuteAdmitted = landed.length / (SPAN_MS / 60_000)
+    // The ceiling that must hold. 4/min per card is the cosmetic per-message
+    // default; a little slack covers window-boundary effects.
+    expect(perMinuteAdmitted).toBeLessThanOrEqual(
+      EDIT_FLOOD_FUSE_DEFAULTS.cosmeticPerMessageMaxPerWindow + 1)
+    // …and it must be a REDUCTION, not a no-op: the offered rate is the rate
+    // that earned the ban.
+    expect(landed.length).toBeLessThan(OFFERED / 3)
+    // The card is still live — throttled, never silenced.
+    expect(landed.length).toBeGreaterThan(0)
+
+    // The pre-fix ceilings would not have bound at all. This is the assertion
+    // that makes the whole suite non-vacuous: 174/10min = 17.4/min, which is
+    // under BOTH old ceilings, which is precisely why the ban happened.
+    const offeredPerMin = OFFERED / (SPAN_MS / 60_000)
+    expect(offeredPerMin).toBeLessThan(EDIT_FLOOD_FUSE_DEFAULTS.perMessageMaxPerWindow)
+    expect(offeredPerMin).toBeLessThan(EDIT_FLOOD_FUSE_DEFAULTS.perChatEditMaxPerWindow)
+  })
+
+  it('coalesces rather than loses state: the LAST frame offered is the last frame painted', async () => {
+    const clock = new FakeClock()
+    const landed: string[] = []
+    const fuse = createEditFloodFuse({ clock })
+
+    const inflight: Promise<unknown>[] = []
+    for (let i = 1; i <= 60; i++) {
+      inflight.push(
+        withOutboundClass('cosmetic', () => fuse.apply(
+          'editMessageText', { chat_id: CHAT, message_id: CARD, text: `v${i}` },
+          async () => { landed.push(`v${i}`); return true },
+        )),
+      )
+      await clock.advance(1_000)
+    }
+    await clock.advance(120_000)
+    await Promise.all(inflight)
+
+    // Backpressure, not dropping-on-the-floor: the operator sees CURRENT state
+    // at every permitted edit, just less often. If the newest frame could be
+    // shed the card would go stale, which is the failure mode a plain rate
+    // limiter would introduce.
+    expect(landed[landed.length - 1]).toBe('v60')
+  })
+
+  it('N concurrent worker cards in one chat share the cosmetic allowance', async () => {
+    const clock = new FakeClock()
+    const landed: string[] = []
+    const fuse = createEditFloodFuse({ clock })
+
+    // 6 background workers, each with its own card, each individually inside
+    // the per-message ceiling. Only a per-CHAT cosmetic ceiling stops their sum.
+    const inflight: Promise<unknown>[] = []
+    // 9 rounds ⇒ every offer lands inside ONE 60s window, so the snapshot below
+    // measures the ceiling and not a window-boundary refill.
+    for (let round = 0; round < 9; round++) {
+      for (let w = 0; w < 6; w++) {
+        inflight.push(
+          withOutboundClass('cosmetic', () => fuse.apply(
+            'editMessageText', { chat_id: CHAT, message_id: 500 + w, text: `w${w} r${round}` },
+            async () => { landed.push(`w${w} r${round}`); return true },
+          )),
+        )
+      }
+      await clock.advance(6_000) // the gateway's FEED_HEARTBEAT_TICK_MS
+    }
+    const inWindow = landed.length
+    await clock.advance(EDIT_FLOOD_FUSE_DEFAULTS.maxDeferMs + 1_000)
+    await Promise.all(inflight)
+
+    // 54 offers across one 60s window; the chat's cosmetic allowance binds.
+    expect(inWindow).toBeLessThanOrEqual(
+      EDIT_FLOOD_FUSE_DEFAULTS.cosmeticPerChatMaxPerWindow
+      + EDIT_FLOOD_FUSE_DEFAULTS.lateReleaseMaxPerWindow + 1)
+  })
+})
+
+describe('feed flood ban — a real reply is never starved by feed edits', () => {
+  it('delivers a reply while the cosmetic budget is fully exhausted', async () => {
+    const clock = new FakeClock()
+    const replies: string[] = []
+    const fuse = createEditFloodFuse({ clock })
+
+    // Saturate: 200 cosmetic edits offered as fast as the feed can produce
+    // them, spread across several cards so every cosmetic tier is pinned.
+    const noise: Promise<unknown>[] = []
+    for (let i = 0; i < 200; i++) {
+      noise.push(
+        withOutboundClass('cosmetic', () => fuse.apply(
+          'editMessageText', { chat_id: CHAT, message_id: 700 + (i % 5), text: `n${i}` },
+          async () => true,
+        )),
+      )
+    }
+    await clock.advance(500)
+
+    // The operator's actual answer, issued mid-flood.
+    const reply = withOutboundClass('critical', () => fuse.apply(
+      'sendMessage', { chat_id: CHAT, text: 'the answer' },
+      async () => { replies.push('the answer'); return { message_id: 1 } },
+    ))
+    // It must land, and land PROMPTLY — inside the reserve, not after the
+    // cosmetic window slides. This is the property the incident violated: the
+    // feed consumed the chat's budget and the reply could not go out at all.
+    await clock.advance(2_000)
+    await reply
+    expect(replies).toEqual(['the answer'])
+
+    await clock.advance(300_000)
+    await Promise.all(noise)
+    // Not one reply was dropped by the fuse.
+    expect(fuse.stats().dropped).toBeGreaterThan(0) // cosmetic edits were shed…
+    expect(replies).toHaveLength(1)                 // …the answer was not.
+  })
+
+  it('does not throttle a non-cosmetic edit with the cosmetic ceiling', async () => {
+    const clock = new FakeClock()
+    const landed: number[] = []
+    const fuse = createEditFloodFuse({ clock })
+
+    // An approval card being re-rendered by operator taps: `useful`, low
+    // volume, but above the 4/min cosmetic ceiling. Throttling it would be a
+    // regression — the fix must separate classes, not just lower one number.
+    const inflight: Promise<unknown>[] = []
+    for (let i = 0; i < 10; i++) {
+      inflight.push(
+        withOutboundClass('useful', () => fuse.apply(
+          'editMessageText', { chat_id: CHAT, message_id: 900, text: `tap ${i}` },
+          async () => { landed.push(i); return true },
+        )),
+      )
+      await clock.advance(2_000)
+    }
+    await clock.advance(60_000)
+    await Promise.all(inflight)
+
+    expect(landed).toHaveLength(10)
+    expect(landed[landed.length - 1]).toBe(9)
+  })
+
+  it('treats an UNTAGGED edit as cosmetic — a new unkeyed call site is limited by default', async () => {
+    const clock = new FakeClock()
+    const landed: number[] = []
+    const fuse = createEditFloodFuse({ clock })
+
+    // No `withOutboundClass` wrapper at all: the shape of a future call site
+    // that never heard of the send gate. That is exactly how both the
+    // 2026-07-25 and 2026-07-27 floods started.
+    const inflight: Promise<unknown>[] = []
+    for (let i = 0; i < 60; i++) {
+      inflight.push(fuse.apply(
+        'editMessageText', { chat_id: CHAT, message_id: 950, text: `u${i}` },
+        async () => { landed.push(i); return true },
+      ))
+      await clock.advance(1_000)
+    }
+    const inWindow = landed.length
+    await clock.advance(EDIT_FLOOD_FUSE_DEFAULTS.maxDeferMs + 1_000)
+    await Promise.all(inflight)
+
+    expect(inWindow).toBeLessThanOrEqual(
+      EDIT_FLOOD_FUSE_DEFAULTS.cosmeticPerMessageMaxPerWindow + 1)
+  })
+
+  it('treats an UNTAGGED send as critical — never dropped', async () => {
+    const clock = new FakeClock()
+    const landed: number[] = []
+    const fuse = createEditFloodFuse({ clock })
+    const inflight: Promise<unknown>[] = []
+    for (let i = 0; i < 40; i++) {
+      inflight.push(fuse.apply('sendMessage', { chat_id: CHAT, text: `s${i}` },
+        async () => { landed.push(i); return { message_id: i } }))
+    }
+    await clock.advance(600_000)
+    await Promise.all(inflight)
+    expect(landed).toHaveLength(40)
+  })
+})
+
+describe('feed flood ban — a 429 reduces the subsequent feed edit rate', () => {
+  it('escalates: each 429 compounds the tightening rather than re-applying one step', async () => {
+    const clock = new FakeClock()
+    const fuse = createEditFloodFuse({ clock })
+    const base = EDIT_FLOOD_FUSE_DEFAULTS.cosmeticPerChatMaxPerWindow
+
+    expect(fuse.stats().tightenLevel).toBe(0)
+    expect(fuse.stats().cosmeticPerChatCeiling).toBe(base)
+
+    const flood = (): unknown => Object.assign(
+      new Error('Too Many Requests: retry after 3'),
+      { error_code: 429, parameters: { retry_after: 3 } },
+    )
+    const takeOne429 = async (): Promise<void> => {
+      await expect(fuse.apply('sendMessage', { chat_id: CHAT, text: 'x' },
+        async () => { throw flood() })).rejects.toThrow(/Too Many Requests/)
+    }
+
+    await takeOne429()
+    const after1 = fuse.stats().cosmeticPerChatCeiling
+    await clock.advance(1_000)
+    await takeOne429()
+    const after2 = fuse.stats().cosmeticPerChatCeiling
+
+    // Pre-fix a second 429 changed nothing: the tightening was a single flat
+    // 0.5× re-armed for another 10 minutes, so a stream taking repeated small
+    // 429s held the SAME rate and walked into the long ban.
+    expect(after1).toBeLessThan(base)
+    expect(after2).toBeLessThan(after1)
+    expect(fuse.stats().tightenLevel).toBe(2)
+  })
+
+  it('a 429 actually reduces how many feed edits get through afterwards', async () => {
+    const clock = new FakeClock()
+    const fuse = createEditFloodFuse({ clock })
+
+    const offerBurst = async (tag: string): Promise<number> => {
+      const landed: number[] = []
+      const inflight: Promise<unknown>[] = []
+      for (let i = 0; i < 40; i++) {
+        inflight.push(
+          withOutboundClass('cosmetic', () => fuse.apply(
+            'editMessageText', { chat_id: CHAT, message_id: 1234, text: `${tag}${i}` },
+            async () => { landed.push(i); return true },
+          )),
+        )
+        await clock.advance(500)
+      }
+      const n = landed.length
+      await clock.advance(EDIT_FLOOD_FUSE_DEFAULTS.maxDeferMs + 1_000)
+      await Promise.all(inflight)
+      return n
+    }
+
+    const before = await offerBurst('a')
+    // Let every window fully drain so the comparison isolates the tightening.
+    await clock.advance(120_000)
+
+    await expect(fuse.apply('sendMessage', { chat_id: CHAT, text: 'x' }, async () => {
+      throw Object.assign(new Error('Too Many Requests: retry after 3'),
+        { error_code: 429, parameters: { retry_after: 3 } })
+    })).rejects.toThrow(/Too Many Requests/)
+    await clock.advance(120_000)
+
+    const after = await offerBurst('b')
+
+    expect(before).toBeGreaterThan(0)
+    expect(after).toBeLessThan(before)
+  })
+
+  it('decays one level at a time rather than restoring full rate in one step', async () => {
+    const clock = new FakeClock()
+    const fuse = createEditFloodFuse({ clock, tightenMs: 60_000 })
+    const base = EDIT_FLOOD_FUSE_DEFAULTS.cosmeticPerMessageMaxPerWindow
+
+    for (let i = 0; i < 3; i++) {
+      await expect(fuse.apply('sendMessage', { chat_id: CHAT, text: 'x' }, async () => {
+        throw Object.assign(new Error('Too Many Requests: retry after 3'),
+          { error_code: 429, parameters: { retry_after: 3 } })
+      })).rejects.toThrow(/Too Many Requests/)
+    }
+    expect(fuse.stats().tightenLevel).toBe(3)
+
+    // #3856: the hold is now `max(tightenMs, retry_after * 1000 + tightenMs)`,
+    // so a stated `retry_after: 3` holds for 63s — the fuse must not begin
+    // decaying while Telegram's own stated cooldown is still running. The
+    // one-level-at-a-time decay this test guards is unchanged; only the FIRST
+    // hold is longer, by the stated 3s.
+    await clock.advance(63_001)
+    expect(fuse.stats().tightenLevel).toBe(2)
+    await clock.advance(60_001)
+    expect(fuse.stats().tightenLevel).toBe(1)
+    await clock.advance(60_001)
+    expect(fuse.stats().tightenLevel).toBe(0)
+    expect(fuse.stats().cosmeticPerMessageCeiling).toBe(base)
+  })
+})
+
+describe('feed flood ban — the send gate publishes the class the fuse depends on', () => {
+  it('a cosmetic gated EDIT is visible as cosmetic at the transformer seam', async () => {
+    const gate = createSendGate({ enabled: true })
+    let seen: string | undefined
+    await gate.gate(
+      async () => { seen = currentOutboundClass(); return true },
+      { chat_id: CHAT, messageId: CARD, editPayload: 'body', priorityClass: 'cosmetic' },
+    )
+    // Without this propagation the fuse's class awareness is decorative: every
+    // edit would fall back to the untagged default and the classes would never
+    // actually separate.
+    expect(seen).toBe('cosmetic')
+  })
+
+  it('a critical gated SEND is visible as critical at the transformer seam', async () => {
+    const gate = createSendGate({ enabled: true })
+    let seen: string | undefined
+    await gate.gate(
+      async () => { seen = currentOutboundClass(); return true },
+      { chat_id: CHAT, priorityClass: 'critical' },
+    )
+    expect(seen).toBe('critical')
+  })
+
+  it('an untagged gated send reports the gate\'s own UNTAGGED_SEND_CLASS', async () => {
+    const gate = createSendGate({ enabled: true })
+    let seen: string | undefined
+    await gate.gate(async () => { seen = currentOutboundClass(); return true }, { chat_id: CHAT })
+    expect(seen).toBe('critical')
+  })
+})
+
+describe('feed flood ban — the ceilings are operator-configurable', () => {
+  it('reads every ceiling from env, and keeps defaults when unset', () => {
+    // Pre-fix the ONLY knob was SWITCHROOM_EDIT_FUSE=0, which turns the whole
+    // failsafe off — an operator being flooded had no way to tighten it.
+    const cfg = editFloodFuseConfigFromEnv({
+      SWITCHROOM_FEED_EDIT_MAX_PER_MSG_PER_MIN: '2',
+      SWITCHROOM_FEED_EDIT_MAX_PER_CHAT_PER_MIN: '3',
+      SWITCHROOM_CHAT_TOTAL_MAX_PER_MIN: '15',
+      SWITCHROOM_CHAT_REPLY_RESERVE: '9',
+    })
+    expect(cfg).toMatchObject({
+      enabled: true,
+      cosmeticPerMessageMaxPerWindow: 2,
+      cosmeticPerChatMaxPerWindow: 3,
+      perChatTotalMaxPerWindow: 15,
+      perChatReplyReserve: 9,
+    })
+
+    const bare = editFloodFuseConfigFromEnv({})
+    expect(bare.cosmeticPerMessageMaxPerWindow).toBeUndefined()
+    expect(bare.enabled).toBe(true)
+    expect(editFloodFuseConfigFromEnv({ SWITCHROOM_EDIT_FUSE: '0' }).enabled).toBe(false)
+    // Garbage must not silently become 0 (which would deadlock every card).
+    expect(editFloodFuseConfigFromEnv({ SWITCHROOM_FEED_EDIT_MAX_PER_MSG_PER_MIN: 'lots' })
+      .cosmeticPerMessageMaxPerWindow).toBeUndefined()
+  })
+
+  it('an env-tightened ceiling actually binds', async () => {
+    const clock = new FakeClock()
+    const fuse = createEditFloodFuse({
+      clock, ...editFloodFuseConfigFromEnv({ SWITCHROOM_FEED_EDIT_MAX_PER_MSG_PER_MIN: '1' }),
+    })
+    const landed: number[] = []
+    const inflight: Promise<unknown>[] = []
+    for (let i = 0; i < 30; i++) {
+      inflight.push(
+        withOutboundClass('cosmetic', () => fuse.apply(
+          'editMessageText', { chat_id: CHAT, message_id: 4321, text: `e${i}` },
+          async () => { landed.push(i); return true },
+        )),
+      )
+      await clock.advance(1_000)
+    }
+    const inWindow = landed.length
+    await clock.advance(EDIT_FLOOD_FUSE_DEFAULTS.maxDeferMs + 1_000)
+    await Promise.all(inflight)
+    expect(inWindow).toBeLessThanOrEqual(2)
+  })
+
+  it('a reserve larger than the total budget cannot deadlock cosmetic traffic', async () => {
+    const clock = new FakeClock()
+    const fuse = createEditFloodFuse({
+      clock, perChatTotalMaxPerWindow: 5, perChatReplyReserve: 99,
+    })
+    const landed: number[] = []
+    await withOutboundClass('cosmetic', () => fuse.apply(
+      'editMessageText', { chat_id: CHAT, message_id: 8888, text: 'x' },
+      async () => { landed.push(1); return true },
+    ))
+    expect(landed).toHaveLength(1)
+  })
+})

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)
+}