tapimo 0.9.0 → 0.10.1

package/src/internal/Webhooks.test.ts

@@ -1,5 +1,6 @@
 import { Webhooks } from 'tapimo'
 import * as TestApp from '../../test/App.js'
+import * as Metrics from '../Metrics.js'
 import * as Cursor from './Cursor.js'
 
 const apiKeyOwner = { orgId: 'org_1', type: 'api_key' } as const
@@ -327,6 +328,78 @@ describe('listActive', () => {
   })
 })
 
+describe('listActiveWithCursors', () => {
+  test('pairs each subscription with its stored cursor from one read', async () => {
+    const db = TestApp.database()
+    const anchored = await Webhooks.createSubscription(db, createInput())
+    const fresh = await Webhooks.createSubscription(db, createInput({ owner: mppOwner }))
+    await Webhooks.setCursor(db, anchored.id, Cursor.encode([100, 5]))
+
+    const pairs = await Webhooks.listActiveWithCursors(db, 4217, 'token:transfer')
+    const byId = new Map(pairs.map((pair) => [pair.subscription.id, pair.cursor]))
+    expect(Cursor.decode(byId.get(anchored.id)!, ['int', 'int'])).toEqual([100, 5])
+    expect(byId.get(fresh.id)).toBeNull()
+  })
+})
+
+describe('listActiveForChain', () => {
+  test('returns active subscriptions across event types in one read', async () => {
+    const db = TestApp.database()
+    const transfer = await Webhooks.createSubscription(db, createInput())
+    const transaction = await Webhooks.createSubscription(
+      db,
+      createInput({ eventType: 'transaction:included' }),
+    )
+    await Webhooks.createSubscription(
+      db,
+      createInput({ eventType: 'block:created', owner: mppOwner }),
+    )
+    await Webhooks.createSubscription(db, createInput({ chainId: 42431, owner: mppOwner }))
+    await Webhooks.updateSubscription(db, apiKeyOwner, transfer.id, { status: 'paused' })
+
+    const pairs = await Webhooks.listActiveForChain(db, {
+      chainId: 4217,
+      eventTypes: ['transaction:included'],
+    })
+    expect(pairs.map(({ subscription }) => subscription.id)).toEqual([transaction.id])
+  })
+})
+
+describe('maxCursorBlock', () => {
+  test('returns the freshest cursor block across event types', async () => {
+    const db = TestApp.database()
+    const transfer = await Webhooks.createSubscription(db, createInput())
+    const tx = await Webhooks.createSubscription(
+      db,
+      createInput({ eventType: 'transaction:included' }),
+    )
+    await Webhooks.setCursor(db, transfer.id, Cursor.encode([100, 5]))
+    await Webhooks.setCursor(db, tx.id, Cursor.encode([250, 0]))
+
+    expect(await Webhooks.maxCursorBlock(db, 4217)).toBe(250)
+  })
+
+  test('counts creation checkpoints at their recorded head', async () => {
+    const db = TestApp.database()
+    await Webhooks.createSubscription(db, createInput(), { startBlockNumber: 900 })
+
+    expect(await Webhooks.maxCursorBlock(db, 4217)).toBe(900)
+  })
+
+  test('ignores other chains and returns null without cursors', async () => {
+    const db = TestApp.database()
+    expect(await Webhooks.maxCursorBlock(db, 4217)).toBeNull()
+
+    const other = await Webhooks.createSubscription(db, createInput({ chainId: 42431 }))
+    await Webhooks.setCursor(db, other.id, Cursor.encode([999, 0]))
+    // A cursorless subscription on the queried chain still reads as null.
+    await Webhooks.createSubscription(db, createInput())
+
+    expect(await Webhooks.maxCursorBlock(db, 4217)).toBeNull()
+    expect(await Webhooks.maxCursorBlock(db, 42431)).toBe(999)
+  })
+})
+
 describe('cursors', () => {
   test('round-trips a per-subscription cursor', async () => {
     const db = TestApp.database()
@@ -362,6 +435,32 @@ describe('cursors', () => {
   })
 })
 
+describe('compareAndSetCursors', () => {
+  test('atomically advances a batch and reports stale rows', async () => {
+    const db = TestApp.database()
+    const initialized = await Webhooks.createSubscription(db, createInput())
+    const stale = await Webhooks.createSubscription(db, createInput())
+    const uninitialized = await Webhooks.createSubscription(db, createInput())
+    const initial = Cursor.encode([100, 1])
+    const next = Cursor.encode([101, 1])
+    await Webhooks.setCursor(db, initialized.id, initial)
+    await Webhooks.setCursor(db, stale.id, initial)
+
+    const committed = await Webhooks.compareAndSetCursors(db, {
+      cursors: [
+        { cursor: next, expectedCursor: initial, subscriptionId: initialized.id },
+        { cursor: next, expectedCursor: null, subscriptionId: stale.id },
+        { cursor: next, expectedCursor: null, subscriptionId: uninitialized.id },
+      ],
+    })
+
+    expect([...committed].toSorted()).toEqual([initialized.id, uninitialized.id].toSorted())
+    expect(await Webhooks.getCursor(db, initialized.id)).toBe(next)
+    expect(await Webhooks.getCursor(db, stale.id)).toBe(initial)
+    expect(await Webhooks.getCursor(db, uninitialized.id)).toBe(next)
+  })
+})
+
 describe('recordSuccess / recordFailure', () => {
   test('recordSuccess resets failures and stamps lastDeliveryAt', async () => {
     const db = TestApp.database()
@@ -624,6 +723,44 @@ describe('delivery log', () => {
     `)
   })
 
+  test('deliverAndRecord partitions event, enqueue, and queue latency', async () => {
+    const db = TestApp.database()
+    const created = await Webhooks.createSubscription(db, createInput())
+    const histograms = new Map<string, number>()
+    const metrics = Metrics.from({
+      count() {},
+      flush() {},
+      gauge() {},
+      histogram(name, value) {
+        histograms.set(name, value)
+      },
+    })
+    const envelope = {
+      chainId: 4217,
+      createdAt: '1970-01-01T00:00:00.500Z',
+      data: { timestamp: '1970-01-01T00:00:00.000Z' },
+      id: 'evt_null',
+      subscriptionId: created.id,
+      type: 'token:transfer',
+    } satisfies Webhooks.Envelope
+    const fetch = (async () =>
+      new Response(null, { status: 200 })) satisfies typeof globalThis.fetch
+
+    await expect(
+      Webhooks.deliverAndRecord(db, created, envelope, {
+        dequeuedAt: 1_250,
+        fetch,
+        metrics,
+        now: fixedNow,
+        queueAttempt: 2,
+        queuedAt: 1_000,
+      }),
+    ).resolves.toMatchObject({ ok: true })
+    expect(histograms.get('webhook_delivery_envelope_to_queue_ms')).toBe(500)
+    expect(histograms.get('webhook_delivery_event_to_envelope_ms')).toBe(500)
+    expect(histograms.get('webhook_delivery_queue_wait_ms')).toBe(250)
+  })
+
   test('deliverAndRecord appends a failed row with the error and status', async () => {
     const db = TestApp.database()
     const created = await Webhooks.createSubscription(db, createInput())
@@ -667,6 +804,25 @@ describe('delivery log', () => {
     `)
   })
 
+  test('deliverAndRecord records envelope serialization failures', async () => {
+    const db = TestApp.database()
+    const created = await Webhooks.createSubscription(db, createInput())
+    const envelope = {
+      chainId: 4217,
+      createdAt: '2026-01-01T00:00:00.000Z',
+      data: { amount: 1n },
+      id: 'evt_invalid',
+      subscriptionId: created.id,
+      type: 'token:transfer',
+    } satisfies Webhooks.Envelope
+
+    const result = await Webhooks.deliverAndRecord(db, created, envelope, { now: fixedNow })
+
+    expect(result).toEqual({ error: 'delivery failed before request', ok: false })
+    const after = await Webhooks.getSubscription(db, apiKeyOwner, created.id)
+    expect(after?.failureCount).toBe(1)
+  })
+
   test('deliverCurrentAndRecord skips paused and deleted queued subscriptions', async () => {
     const db = TestApp.database()
     const paused = await Webhooks.createSubscription(db, createInput())
@@ -772,6 +928,466 @@ describe('delivery log', () => {
   })
 })
 
+async function stagedObligation(db: ReturnType<typeof TestApp.database>, logIndex = 4) {
+  const subscription = await Webhooks.createSubscription(db, createInput())
+  const envelope = Webhooks.buildEnvelope({
+    blockNumber: 123,
+    createdAt: new Date(),
+    data: { amount: '1' },
+    logIndex,
+    subscription,
+  })
+  const { created, references } = await Webhooks.ensureQueueEvents(db, [{ envelope, subscription }])
+  return { created, envelope, reference: references[0]!, subscription }
+}
+
+describe('ensureQueueEvents', () => {
+  test('keeps oversized envelopes behind compact idempotent Queue references', async () => {
+    const db = TestApp.database()
+    const subscription = await Webhooks.createSubscription(
+      db,
+      createInput({ eventType: 'transaction:included' }),
+    )
+    const input = `0x${'ab'.repeat(70_000)}`
+    const envelope = Webhooks.buildEnvelope({
+      blockNumber: 123,
+      createdAt: fixedNow(),
+      data: { input, meta: { rpc: { input } } },
+      logIndex: 4,
+      subscription,
+    })
+    const dispatchable = { envelope, subscription }
+
+    const { references: [reference] } = await Webhooks.ensureQueueEvents(db, [dispatchable]) // prettier-ignore
+    await Webhooks.ensureQueueEvents(db, [dispatchable])
+
+    expect(
+      new TextEncoder().encode(JSON.stringify({ body: dispatchable })).byteLength,
+    ).toBeGreaterThan(128_000)
+    expect(new TextEncoder().encode(JSON.stringify({ body: reference })).byteLength).toBeLessThan(
+      1_000,
+    )
+    expect((await Webhooks.getQueueEvent(db, reference!))?.envelope).toEqual(envelope)
+  })
+
+  test('delivers a staged oversized envelope from its compact reference', async () => {
+    const db = TestApp.database()
+    const subscription = await Webhooks.createSubscription(
+      db,
+      createInput({ eventType: 'transaction:included' }),
+    )
+    const input = `0x${'ab'.repeat(70_000)}`
+    const envelope = Webhooks.buildEnvelope({
+      blockNumber: 123,
+      data: { input, meta: { rpc: { input } } },
+      logIndex: 4,
+      subscription,
+    })
+    const { references: [reference] } = await Webhooks.ensureQueueEvents(db, [{ envelope, subscription }]) // prettier-ignore
+    const histograms = new Map<string, number>()
+    const metrics = Metrics.from({
+      count() {},
+      flush() {},
+      gauge() {},
+      histogram(name, value) {
+        histograms.set(name, value)
+      },
+    })
+    let deliveredBytes = 0
+    const fetch = (async (_url, init) => {
+      deliveredBytes = new TextEncoder().encode(
+        typeof init?.body === 'string' ? init.body : '',
+      ).byteLength
+      return new Response(null, { status: 200 })
+    }) satisfies typeof globalThis.fetch
+
+    const result = await Webhooks.deliverQueueEventAndRecord(db, reference!, {
+      fetch,
+      metrics,
+      queuedAt: Date.now(),
+    })
+
+    expect(result.status).toBe('delivered')
+    expect(deliveredBytes).toBeGreaterThan(128_000)
+    expect(histograms.has('webhook_delivery_processing_ms')).toBe(true)
+    expect(histograms.has('webhook_delivery_queue_wait_ms')).toBe(true)
+    expect(histograms.has('webhook_delivery_subscription_read_ms')).toBe(true)
+  })
+
+  test('skips a staged event after its subscription expires', async () => {
+    vi.useFakeTimers({ now: fixedNow(), toFake: ['Date'] })
+    try {
+      const db = TestApp.database()
+      const subscription = await Webhooks.createSubscription(
+        db,
+        createInput({ eventType: 'transaction:included', owner: mppOwner, ttl: 60_000 }),
+        { now: fixedNow },
+      )
+      const envelope = Webhooks.buildEnvelope({
+        blockNumber: 123,
+        data: {},
+        logIndex: 4,
+        subscription,
+      })
+      const { references: [reference] } = await Webhooks.ensureQueueEvents(db, [{ envelope, subscription }]) // prettier-ignore
+
+      vi.setSystemTime(new Date('2026-01-01T00:01:00.000Z'))
+
+      await expect(Webhooks.deliverQueueEventAndRecord(db, reference!)).resolves
+        .toMatchInlineSnapshot(`
+        {
+          "status": "skipped",
+        }
+      `)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  test('stages once and keeps the first envelope', async () => {
+    const db = TestApp.database()
+    const { created, envelope, reference, subscription } = await stagedObligation(db)
+    const replacement = { ...envelope, data: { amount: '2' } }
+
+    const second = await Webhooks.ensureQueueEvents(db, [{ envelope: replacement, subscription }])
+
+    expect(created).toBe(1)
+    expect(second.created).toBe(0)
+    expect((await Webhooks.getQueueEvent(db, reference))?.envelope).toEqual(envelope)
+  })
+
+  test('never resurrects a terminal obligation', async () => {
+    const db = TestApp.database()
+    const { envelope, reference, subscription } = await stagedObligation(db)
+    const claim = await Webhooks.claimQueueEvent(db, reference)
+    expect(claim.type).toBe('claimed')
+    if (claim.type !== 'claimed') return
+    expect(
+      await Webhooks.completeQueueEvent(db, reference, {
+        claimedAt: claim.record.attemptingAt!,
+        status: 'succeeded',
+      }),
+    ).toBe(true)
+
+    const again = await Webhooks.ensureQueueEvents(db, [{ envelope, subscription }])
+    expect(again.created).toBe(0)
+    await expect(Webhooks.claimQueueEvent(db, reference)).resolves.toEqual({
+      status: 'succeeded',
+      type: 'terminal',
+    })
+    // Terminal rows read as absent, so no consumer path can redeliver them.
+    expect(await Webhooks.getQueueEvent(db, reference)).toBeNull()
+  })
+
+  test('replaces an expired terminal row so replays stay deliverable', async () => {
+    vi.useFakeTimers({ toFake: ['Date'] })
+    vi.setSystemTime(fixedNow())
+    try {
+      const db = TestApp.database()
+      const { envelope, reference, subscription } = await stagedObligation(db)
+      const claim = await Webhooks.claimQueueEvent(db, reference)
+      expect(claim.type).toBe('claimed')
+      if (claim.type !== 'claimed') return
+      expect(
+        await Webhooks.completeQueueEvent(db, reference, {
+          claimedAt: claim.record.attemptingAt!,
+          status: 'succeeded',
+        }),
+      ).toBe(true)
+
+      // Past the dedupe window an unpruned terminal row must not suppress a
+      // replay.
+      vi.setSystemTime(new Date(fixedNow().getTime() + Webhooks.deliveryRetentionMs + 1_000))
+      const replay = await Webhooks.ensureQueueEvents(db, [{ envelope, subscription }])
+      expect(replay.created).toBe(1)
+      await expect(Webhooks.claimQueueEvent(db, reference)).resolves.toMatchObject({
+        type: 'claimed',
+      })
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+})
+
+describe('claimQueueEvent', () => {
+  beforeEach(() => {
+    vi.useFakeTimers({ toFake: ['Date'] })
+    vi.setSystemTime(fixedNow())
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  test('claims a due obligation once and reclaims after staleness', async () => {
+    const db = TestApp.database()
+    const { reference } = await stagedObligation(db)
+
+    const first = await Webhooks.claimQueueEvent(db, reference)
+    expect(first.type).toBe('claimed')
+    if (first.type !== 'claimed') return
+    expect(first.record.attemptCount).toBe(1)
+
+    await expect(Webhooks.claimQueueEvent(db, reference)).resolves.toEqual({
+      type: 'attempting',
+    })
+
+    vi.setSystemTime(new Date(fixedNow().getTime() + Webhooks.deliveryAttemptStaleMs + 1))
+    const reclaimed = await Webhooks.claimQueueEvent(db, reference)
+    expect(reclaimed.type).toBe('claimed')
+    if (reclaimed.type !== 'claimed') return
+    expect(reclaimed.record.attemptCount).toBe(2)
+  })
+
+  test('classifies missing, scheduled, and terminal obligations', async () => {
+    const db = TestApp.database()
+    const { reference } = await stagedObligation(db)
+
+    await expect(
+      Webhooks.claimQueueEvent(db, { eventId: 'evt_absent', subscriptionId: 'wh_absent' }),
+    ).resolves.toEqual({ type: 'missing' })
+
+    const claim = await Webhooks.claimQueueEvent(db, reference)
+    expect(claim.type).toBe('claimed')
+    if (claim.type !== 'claimed') return
+    expect(
+      await Webhooks.scheduleQueueEventRetry(db, reference, {
+        attemptCount: 1,
+        claimedAt: claim.record.attemptingAt!,
+      }),
+    ).toBe(true)
+    await expect(Webhooks.claimQueueEvent(db, reference)).resolves.toEqual({
+      nextAttemptAt: new Date(fixedNow().getTime() + Webhooks.retryDelayMs(1)).toISOString(),
+      type: 'scheduled',
+    })
+
+    vi.setSystemTime(new Date(fixedNow().getTime() + Webhooks.retryDelayMs(1) + 1))
+    const retried = await Webhooks.claimQueueEvent(db, reference)
+    expect(retried.type).toBe('claimed')
+    if (retried.type !== 'claimed') return
+    expect(
+      await Webhooks.completeQueueEvent(db, reference, {
+        claimedAt: retried.record.attemptingAt!,
+        status: 'failed',
+      }),
+    ).toBe(true)
+    await expect(Webhooks.claimQueueEvent(db, reference)).resolves.toEqual({
+      status: 'failed',
+      type: 'terminal',
+    })
+  })
+
+  test('keeps owed work claimable indefinitely', async () => {
+    const db = TestApp.database()
+    const { reference } = await stagedObligation(db)
+
+    // Pending obligations never expire; only terminal transitions stamp a
+    // dedupe deadline.
+    vi.setSystemTime(new Date(fixedNow().getTime() + Webhooks.deliveryRetentionMs * 3))
+    await expect(Webhooks.claimQueueEvent(db, reference)).resolves.toMatchObject({
+      type: 'claimed',
+    })
+  })
+
+  test('never prunes pending work', async () => {
+    const db = TestApp.database()
+    const { reference } = await stagedObligation(db)
+
+    vi.setSystemTime(new Date(fixedNow().getTime() + Webhooks.deliveryRetentionMs + 1_000))
+    await Webhooks.pruneExpired(db)
+    const claim = await Webhooks.claimQueueEvent(db, reference)
+    expect(claim.type).toBe('claimed')
+    if (claim.type !== 'claimed') return
+    expect(
+      await Webhooks.completeQueueEvent(db, reference, {
+        claimedAt: claim.record.attemptingAt!,
+        status: 'succeeded',
+      }),
+    ).toBe(true)
+  })
+
+  test('fences a stale claimant after a reclaim', async () => {
+    const db = TestApp.database()
+    const { reference } = await stagedObligation(db)
+    const stale = await Webhooks.claimQueueEvent(db, reference)
+    expect(stale.type).toBe('claimed')
+    if (stale.type !== 'claimed') return
+
+    vi.setSystemTime(new Date(fixedNow().getTime() + Webhooks.deliveryAttemptStaleMs + 1))
+    const current = await Webhooks.claimQueueEvent(db, reference)
+    expect(current.type).toBe('claimed')
+    if (current.type !== 'claimed') return
+
+    const staleClaimedAt = stale.record.attemptingAt!
+    expect(
+      await Webhooks.completeQueueEvent(db, reference, {
+        claimedAt: staleClaimedAt,
+        status: 'failed',
+      }),
+    ).toBe(false)
+    expect(
+      await Webhooks.scheduleQueueEventRetry(db, reference, {
+        attemptCount: 1,
+        claimedAt: staleClaimedAt,
+      }),
+    ).toBe(false)
+    expect(
+      await Webhooks.completeQueueEvent(db, reference, {
+        claimedAt: current.record.attemptingAt!,
+        status: 'succeeded',
+      }),
+    ).toBe(true)
+  })
+})
+
+describe('retryDelayMs', () => {
+  test('backs off exponentially and caps hourly', () => {
+    expect([1, 2, 3, 4, 5, 6, 10].map(Webhooks.retryDelayMs)).toMatchInlineSnapshot(`
+      [
+        5000,
+        25000,
+        125000,
+        625000,
+        3125000,
+        3600000,
+        3600000,
+      ]
+    `)
+  })
+})
+
+describe('dueQueueEvents', () => {
+  beforeEach(() => {
+    vi.useFakeTimers({ toFake: ['Date'] })
+    vi.setSystemTime(fixedNow())
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  test('lists due pending work and skips in-flight, scheduled, and terminal rows', async () => {
+    const db = TestApp.database()
+    // Distinct staging times so the due order (next_attempt_at) is deterministic.
+    const due = await stagedObligation(db, 1)
+    vi.setSystemTime(new Date(fixedNow().getTime() + 1))
+    const inFlight = await stagedObligation(db, 2)
+    vi.setSystemTime(new Date(fixedNow().getTime() + 2))
+    const scheduled = await stagedObligation(db, 3)
+    vi.setSystemTime(new Date(fixedNow().getTime() + 3))
+    const terminal = await stagedObligation(db, 4)
+
+    expect((await Webhooks.claimQueueEvent(db, inFlight.reference)).type).toBe('claimed')
+    const scheduledClaim = await Webhooks.claimQueueEvent(db, scheduled.reference)
+    expect(scheduledClaim.type).toBe('claimed')
+    if (scheduledClaim.type !== 'claimed') return
+    expect(
+      await Webhooks.scheduleQueueEventRetry(db, scheduled.reference, {
+        attemptCount: 3,
+        claimedAt: scheduledClaim.record.attemptingAt!,
+      }),
+    ).toBe(true)
+    const terminalClaim = await Webhooks.claimQueueEvent(db, terminal.reference)
+    expect(terminalClaim.type).toBe('claimed')
+    if (terminalClaim.type !== 'claimed') return
+    expect(
+      await Webhooks.completeQueueEvent(db, terminal.reference, {
+        claimedAt: terminalClaim.record.attemptingAt!,
+        status: 'succeeded',
+      }),
+    ).toBe(true)
+
+    await expect(Webhooks.dueQueueEvents(db, 10)).resolves.toEqual([due.reference])
+
+    vi.setSystemTime(new Date(fixedNow().getTime() + Webhooks.deliveryAttemptStaleMs + 10))
+    await expect(Webhooks.dueQueueEvents(db, 10)).resolves.toEqual([
+      due.reference,
+      inFlight.reference,
+    ])
+  })
+})
+
+describe('pendingQueueEvents', () => {
+  beforeEach(() => {
+    vi.useFakeTimers({ toFake: ['Date'] })
+    vi.setSystemTime(fixedNow())
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  test('counts pending obligations and reports the oldest staging time', async () => {
+    const db = TestApp.database()
+    await stagedObligation(db, 1)
+    vi.setSystemTime(new Date(fixedNow().getTime() + 1_000))
+    const done = await stagedObligation(db, 2)
+    const doneClaim = await Webhooks.claimQueueEvent(db, done.reference)
+    expect(doneClaim.type).toBe('claimed')
+    if (doneClaim.type !== 'claimed') return
+    expect(
+      await Webhooks.completeQueueEvent(db, done.reference, {
+        claimedAt: doneClaim.record.attemptingAt!,
+        status: 'succeeded',
+      }),
+    ).toBe(true)
+
+    await expect(Webhooks.pendingQueueEvents(db)).resolves.toEqual({
+      count: 1,
+      dueCount: 1,
+      oldestAt: fixedNow().toISOString(),
+      oldestDueAt: fixedNow().toISOString(),
+    })
+  })
+
+  test('excludes in-flight claims and scheduled retries from due work', async () => {
+    const db = TestApp.database()
+    const inFlight = await stagedObligation(db, 1)
+    const claim = await Webhooks.claimQueueEvent(db, inFlight.reference)
+    expect(claim.type).toBe('claimed')
+
+    await expect(Webhooks.pendingQueueEvents(db)).resolves.toMatchObject({
+      count: 1,
+      dueCount: 0,
+      oldestDueAt: null,
+    })
+  })
+})
+
+describe('deliverClaimedAndRecord', () => {
+  test('delivers a claimed envelope and skips an inactive subscription', async () => {
+    const db = TestApp.database()
+    const { envelope, reference, subscription } = await stagedObligation(db)
+    const claim = await Webhooks.claimQueueEvent(db, reference)
+    expect(claim.type).toBe('claimed')
+    if (claim.type !== 'claimed') return
+
+    let delivered: unknown
+    const fetch = (async (_url, init) => {
+      delivered = JSON.parse(typeof init?.body === 'string' ? init.body : '{}')
+      return new Response(null, { status: 200 })
+    }) satisfies typeof globalThis.fetch
+
+    const delivery = await Webhooks.deliverClaimedAndRecord(
+      db,
+      { envelope: claim.record.envelope, subscriptionId: reference.subscriptionId },
+      { fetch },
+    )
+    expect(delivery.status).toBe('delivered')
+    if (delivery.status !== 'delivered') return
+    expect(delivery.result.ok).toBe(true)
+    expect(delivered).toEqual(envelope)
+
+    await Webhooks.deleteSubscription(db, apiKeyOwner, subscription.id)
+    await expect(
+      Webhooks.deliverClaimedAndRecord(db, {
+        envelope: claim.record.envelope,
+        subscriptionId: reference.subscriptionId,
+      }),
+    ).resolves.toEqual({ status: 'skipped' })
+  })
+})
+
 describe('buildPingEnvelope', () => {
   test('builds a synthetic ping envelope with a deterministic id from the nonce', async () => {
     const db = TestApp.database()