@avelonjs/conformance 0.1.0

package/src/suites/notifications.ts

@@ -0,0 +1,119 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  Invalid,
+  type NotificationCapabilities,
+  type NotificationChannel,
+  type NotificationDriver,
+  type NotificationMessage,
+} from '@avelonjs/core'
+import { captureFailure, type SuiteContext } from '../harness'
+
+interface SentInspectable {
+  readonly sent: readonly {
+    readonly channel: NotificationChannel
+    readonly message: NotificationMessage
+  }[]
+}
+
+type AssayDriver = NotificationDriver<NotificationCapabilities> & Partial<SentInspectable>
+
+function assay<TDriver extends AssayDriver>(
+  context: SuiteContext<TDriver>,
+  name: string,
+  assertion: (driver: TDriver) => Promise<void> | void,
+): void {
+  test(name, async () => {
+    const driver = await context.create()
+    try {
+      await assertion(driver)
+    } finally {
+      await context.cleanup?.(driver)
+    }
+  })
+}
+
+function hasSentInspection(driver: object): driver is SentInspectable {
+  return 'sent' in driver && Array.isArray(driver.sent)
+}
+
+async function expectInvalid(operation: () => Promise<unknown>): Promise<Invalid> {
+  const error = await captureFailure(operation)
+  expect(error).toBeInstanceOf(Invalid)
+  if (!(error instanceof Invalid)) throw new Error('Expected Invalid after taxonomy assertion.')
+  expect(error.code).toBe('INVALID')
+  return error
+}
+
+const channels: readonly NotificationChannel[] = ['push', 'sms', 'inApp']
+
+/**
+ * Registers the portable notifications contract conformance suite.
+ *
+ * Channels narrow the accepted `send` argument rather than adding methods. The suite therefore
+ * sends through every declared channel and requires undeclared channels to normalize to `Invalid`.
+ *
+ * @param context Fresh isolated notification drivers and optional cleanup.
+ */
+export function notificationsSuite<TDriver extends AssayDriver>(
+  context: SuiteContext<TDriver>,
+): void {
+  describe(`notifications conformance: ${context.name}`, () => {
+    assay(context, 'reports a present and stable resolved notifications instance', (driver) => {
+      const instance = driver.instance
+      expect(instance.length).toBeGreaterThan(0)
+      expect(driver.instance).toBe(instance)
+    })
+
+    assay(
+      context,
+      'honors every declared notification channel in both directions',
+      async (driver) => {
+        for (const channel of channels) {
+          const operation = () =>
+            driver.send(channel, {
+              recipient: `recipient-${channel}`,
+              title: 'Assay notification',
+              body: `Sent through ${channel}`,
+            })
+          if (driver.capabilities.channels.includes(channel)) {
+            const receipt = await operation()
+            expect(receipt.channel).toBe(channel)
+            expect(receipt.id.length).toBeGreaterThan(0)
+          } else {
+            const error = await expectInvalid(operation)
+            expect(error.metadata.fields?.channel).toBeDefined()
+          }
+        }
+      },
+    )
+
+    assay(context, 'preserves notification content and structured data', async (driver) => {
+      const channel = driver.capabilities.channels[0]
+      if (!channel) return
+      const message = {
+        recipient: 'actor-1',
+        title: 'Build complete',
+        body: 'Your deployment is ready.',
+        data: { deploymentId: 'deploy-1', attempts: 2, nested: { region: 'iad1' } },
+      }
+      await driver.send(channel, message)
+      if (hasSentInspection(driver)) {
+        expect(driver.sent).toEqual([{ channel, message }])
+      }
+    })
+
+    assay(
+      context,
+      'returns a distinct stable receipt for each accepted message',
+      async (driver) => {
+        const channel = driver.capabilities.channels[0]
+        if (!channel) return
+        const first = await driver.send(channel, { recipient: 'actor-1', body: 'First' })
+        const second = await driver.send(channel, { recipient: 'actor-1', body: 'Second' })
+        expect(first.id).not.toBe(second.id)
+        expect(first.channel).toBe(channel)
+        expect(second.channel).toBe(channel)
+      },
+    )
+  })
+}

package/src/suites/payments.ts

@@ -0,0 +1,200 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  Invalid,
+  NotFound,
+  Unauthenticated,
+  type CheckoutPaymentSurface,
+  type PaymentCapabilities,
+  type PaymentDriver,
+  type SubscriptionPaymentSurface,
+  type WebhookPaymentSurface,
+} from '@avelonjs/core'
+import { assertCapabilitySurface, captureFailure, type SuiteContext } from '../harness'
+
+type AssayDriver = PaymentDriver<PaymentCapabilities> &
+  Partial<SubscriptionPaymentSurface & CheckoutPaymentSurface & WebhookPaymentSurface>
+
+function assay<TDriver extends AssayDriver>(
+  context: SuiteContext<TDriver>,
+  name: string,
+  assertion: (driver: TDriver) => Promise<void> | void,
+): void {
+  test(name, async () => {
+    const driver = await context.create()
+    try {
+      await assertion(driver)
+    } finally {
+      await context.cleanup?.(driver)
+    }
+  })
+}
+
+function hasSubscriptions(driver: AssayDriver): driver is AssayDriver & SubscriptionPaymentSurface {
+  return driver.capabilities.subscriptions && typeof driver.subscribe === 'function'
+}
+
+function hasCheckout(driver: AssayDriver): driver is AssayDriver & CheckoutPaymentSurface {
+  return driver.capabilities.checkout && typeof driver.checkout === 'function'
+}
+
+function hasWebhooks(driver: AssayDriver): driver is AssayDriver & WebhookPaymentSurface {
+  return driver.capabilities.webhooks && typeof driver.webhook === 'function'
+}
+
+async function expectError<TError>(
+  constructor: abstract new (...arguments_: never[]) => TError,
+  operation: () => Promise<unknown>,
+): Promise<TError> {
+  const error = await captureFailure(operation)
+  expect(error).toBeInstanceOf(constructor)
+  if (!(error instanceof constructor)) throw new Error('Expected normalized payment error.')
+  return error
+}
+
+/**
+ * Registers the portable payments contract conformance suite.
+ *
+ * The webhook verifier is configured with the assay signature `assay-signature`. A bad signature is
+ * `Unauthenticated`, because the sender was not established; malformed verified bytes are `Invalid`.
+ * The stable webhook event ID enables application idempotency, but the contract exposes no event
+ * processing operation or idempotency key, so the suite does not invent an idempotency assertion.
+ *
+ * @param context Fresh isolated payment drivers and optional cleanup.
+ */
+export function paymentsSuite<TDriver extends AssayDriver>(context: SuiteContext<TDriver>): void {
+  describe(`payments conformance: ${context.name}`, () => {
+    assay(context, 'reports a present and stable resolved payments instance', (driver) => {
+      const instance = driver.instance
+      expect(instance.length).toBeGreaterThan(0)
+      expect(driver.instance).toBe(instance)
+    })
+
+    assay(context, 'enforces every payments capability surface in both directions', (driver) => {
+      const surfaces: readonly [string, boolean, readonly string[]][] = [
+        [
+          'subscriptions',
+          driver.capabilities.subscriptions,
+          ['subscribe', 'subscription', 'cancelSubscription'],
+        ],
+        ['checkout', driver.capabilities.checkout, ['checkout']],
+        ['webhooks', driver.capabilities.webhooks, ['webhook']],
+      ]
+      for (const [capability, declared, methods] of surfaces) {
+        assertCapabilitySurface(driver, capability, declared, methods)
+        assertCapabilitySurface(
+          { capabilities: { [capability]: false } },
+          capability,
+          false,
+          methods,
+        )
+        expect(() =>
+          assertCapabilitySurface(
+            { capabilities: { [capability]: false }, [methods[0] ?? 'missing']: () => undefined },
+            capability,
+            false,
+            methods,
+          ),
+        ).toThrow()
+        expect(() =>
+          assertCapabilitySurface(
+            { capabilities: { [capability]: true } },
+            capability,
+            true,
+            methods,
+          ),
+        ).toThrow()
+      }
+    })
+
+    assay(context, 'creates and retrieves customers with metadata intact', async (driver) => {
+      const created = await driver.createCustomer({
+        email: 'actor@example.test',
+        metadata: { actorId: 'actor-1', plan: 'pro' },
+      })
+      expect(created.id.length).toBeGreaterThan(0)
+      expect(await driver.customer(created.id)).toEqual(created)
+      expect(created.metadata).toEqual({ actorId: 'actor-1', plan: 'pro' })
+    })
+
+    assay(context, 'normalizes a missing customer to NotFound', async (driver) => {
+      const error = await expectError(NotFound, () => driver.customer('missing-customer'))
+      expect(error.code).toBe('NOT_FOUND')
+      expect(error.metadata).toEqual({
+        resource: 'payment-customer',
+        identifier: 'missing-customer',
+      })
+    })
+
+    assay(
+      context,
+      'creates, retrieves, and cancels subscriptions when declared',
+      async (driver) => {
+        if (!hasSubscriptions(driver)) return
+        const customer = await driver.createCustomer({})
+        const created = await driver.subscribe(customer.id, 'price-pro')
+        expect(created).toMatchObject({
+          customerId: customer.id,
+          priceId: 'price-pro',
+          status: 'active',
+        })
+        expect(created.currentPeriodEndsAt).toBeInstanceOf(Date)
+        expect(await driver.subscription(created.id)).toEqual(created)
+        expect(await driver.cancelSubscription(created.id)).toMatchObject({
+          id: created.id,
+          status: 'canceled',
+        })
+        expect((await driver.subscription(created.id)).status).toBe('canceled')
+      },
+    )
+
+    assay(context, 'creates a hosted checkout session when declared', async (driver) => {
+      if (!hasCheckout(driver)) return
+      const customer = await driver.createCustomer({})
+      const checkout = await driver.checkout({
+        customerId: customer.id,
+        priceId: 'price-team',
+        successUrl: 'https://app.example.test/billing/success',
+        cancelUrl: 'https://app.example.test/billing/cancel',
+      })
+      expect(checkout.id.length).toBeGreaterThan(0)
+      expect(new URL(checkout.url).protocol).toBe('https:')
+      expect(checkout.expiresAt).toBeInstanceOf(Date)
+    })
+
+    assay(context, 'verifies and normalizes signed webhook bytes when declared', async (driver) => {
+      if (!hasWebhooks(driver)) return
+      const occurredAt = '2026-08-03T12:00:00.000Z'
+      const payload = new TextEncoder().encode(
+        JSON.stringify({
+          id: 'event-1',
+          type: 'subscription.updated',
+          data: { subscriptionId: 'subscription-1', status: 'active' },
+          occurredAt,
+        }),
+      )
+      expect(await driver.webhook(payload, 'assay-signature')).toEqual({
+        id: 'event-1',
+        type: 'subscription.updated',
+        data: { subscriptionId: 'subscription-1', status: 'active' },
+        occurredAt: new Date(occurredAt),
+      })
+    })
+
+    assay(context, 'rejects an unverified webhook signature as Unauthenticated', async (driver) => {
+      if (!hasWebhooks(driver)) return
+      const payload = new TextEncoder().encode('{}')
+      const error = await expectError(Unauthenticated, () => driver.webhook(payload, 'forged'))
+      expect(error.code).toBe('UNAUTHENTICATED')
+      expect(error.metadata.guard).toBe('payment-webhook')
+    })
+
+    assay(context, 'rejects malformed verified webhook bytes as Invalid', async (driver) => {
+      if (!hasWebhooks(driver)) return
+      const error = await expectError(Invalid, () =>
+        driver.webhook(new TextEncoder().encode('not-json'), 'assay-signature'),
+      )
+      expect(error.code).toBe('INVALID')
+      expect(error.cause).toBeDefined()
+    })
+  })
+}

package/src/suites/queue.ts

@@ -0,0 +1,238 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  type DeadLetterQueueSurface,
+  type DelayedQueueSurface,
+  type QueueCapabilities,
+  type QueueDriver,
+  type QueueReceipt,
+  type RetryQueueSurface,
+} from '@avelonjs/core'
+import { assertCapabilitySurface, type SuiteContext } from '../harness'
+
+type AssayDriver = QueueDriver<QueueCapabilities> &
+  Partial<DelayedQueueSurface & RetryQueueSurface & DeadLetterQueueSurface>
+
+function assay<TDriver extends AssayDriver>(
+  context: SuiteContext<TDriver>,
+  name: string,
+  assertion: (driver: TDriver) => Promise<void> | void,
+): void {
+  test(name, async () => {
+    const driver = await context.create()
+    try {
+      await assertion(driver)
+    } finally {
+      await context.cleanup?.(driver)
+    }
+  })
+}
+
+function hasDelay(driver: AssayDriver): driver is AssayDriver & DelayedQueueSurface {
+  return driver.capabilities.delayed && typeof driver.enqueueAt === 'function'
+}
+
+function hasRetries(driver: AssayDriver): driver is AssayDriver & RetryQueueSurface {
+  return driver.capabilities.retries && typeof driver.retry === 'function'
+}
+
+function hasDeadLetter(driver: AssayDriver): driver is AssayDriver & DeadLetterQueueSurface {
+  return driver.capabilities.deadLetter && typeof driver.failed === 'function'
+}
+
+/**
+ * Registers the portable queue contract conformance suite.
+ *
+ * Dead-letter-capable contexts configure a three-attempt limit. The limit belongs to driver
+ * construction rather than `QueueJob`, so the fixture setup owns that value. Replaying a terminal
+ * failure starts a fresh attempt budget.
+ *
+ * @param context Fresh isolated queue drivers and optional cleanup.
+ */
+export function queueSuite<TDriver extends AssayDriver>(context: SuiteContext<TDriver>): void {
+  const delayMs = context.queueDelayMs ?? (context.live ? 2_000 : 80)
+  const settleMs = context.queueSettleMs ?? (context.live ? 3_000 : 120)
+
+  describe(`queue conformance: ${context.name}`, () => {
+    assay(context, 'reports a present and stable resolved queue instance', (driver) => {
+      const instance = driver.instance
+      expect(instance.length).toBeGreaterThan(0)
+      expect(driver.instance).toBe(instance)
+    })
+
+    assay(context, 'enforces every queue capability surface in both directions', (driver) => {
+      const surfaces: readonly [string, boolean, readonly string[]][] = [
+        ['delayed', driver.capabilities.delayed, ['enqueueAt']],
+        ['retries', driver.capabilities.retries, ['retry']],
+        ['deadLetter', driver.capabilities.deadLetter, ['failed', 'replay', 'forget']],
+      ]
+      for (const [capability, declared, methods] of surfaces) {
+        assertCapabilitySurface(driver, capability, declared, methods)
+        const unavailable = { capabilities: { [capability]: false } }
+        assertCapabilitySurface(unavailable, capability, false, methods)
+        expect(() =>
+          assertCapabilitySurface(
+            { ...unavailable, [methods[0] ?? 'missing']: () => undefined },
+            capability,
+            false,
+            methods,
+          ),
+        ).toThrow()
+        expect(() =>
+          assertCapabilitySurface(
+            { capabilities: { [capability]: true } },
+            capability,
+            true,
+            methods,
+          ),
+        ).toThrow()
+      }
+    })
+
+    assay(context, 'enqueues and removes a job when its handler resolves', async (driver) => {
+      const id = await driver.enqueue({ name: 'GenerateReport', payload: { reportId: 'report-1' } })
+      const receipts: QueueReceipt[] = []
+      expect(
+        await driver.drain(async (receipt) => {
+          receipts.push(receipt)
+        }),
+      ).toBe(1)
+      expect(receipts).toEqual([
+        {
+          id,
+          job: { name: 'GenerateReport', payload: { reportId: 'report-1' } },
+          attempt: 1,
+        },
+      ])
+      expect(await driver.drain(async () => undefined)).toBe(0)
+    })
+
+    assay(context, 'honors destination queues and drain limits', async (driver) => {
+      await driver.enqueue({ name: 'DefaultJob', payload: {} })
+      await driver.enqueue({ name: 'FirstMail', payload: {}, queue: 'mail' })
+      await driver.enqueue({ name: 'SecondMail', payload: {}, queue: 'mail' })
+      const names: string[] = []
+
+      expect(
+        await driver.drain(
+          async (receipt) => {
+            names.push(receipt.job.name)
+          },
+          { queue: 'mail', limit: 1 },
+        ),
+      ).toBe(1)
+      expect(names).toEqual(['FirstMail'])
+      expect(await driver.drain(async () => undefined)).toBe(2)
+    })
+
+    assay(context, 'redelivers thrown jobs only when retries are declared', async (driver) => {
+      await driver.enqueue({ name: 'FragileJob', payload: {} })
+      let firstAttempt = 0
+      expect(
+        await driver.drain(async (receipt) => {
+          firstAttempt = receipt.attempt
+          throw new Error('temporary failure')
+        }),
+      ).toBe(1)
+      expect(firstAttempt).toBe(1)
+
+      if (driver.capabilities.retries) {
+        let secondAttempt = 0
+        expect(
+          await driver.drain(async (receipt) => {
+            secondAttempt = receipt.attempt
+          }),
+        ).toBe(1)
+        expect(secondAttempt).toBe(2)
+      } else {
+        // No retry means at-most-once after a handler throw. Infinite redelivery would secretly
+        // implement the capability and can make every future drain permanently fail.
+        expect(await driver.drain(async () => undefined)).toBe(0)
+      }
+    })
+
+    assay(context, 'releases a failed job through the retry surface', async (driver) => {
+      if (!hasRetries(driver)) return
+      const id = await driver.enqueue({ name: 'RetryJob', payload: {} })
+      await driver.drain(async () => {
+        throw new Error('retry me')
+      })
+      await driver.retry(id)
+
+      let attempt = 0
+      expect(
+        await driver.drain(async (receipt) => {
+          attempt = receipt.attempt
+        }),
+      ).toBe(1)
+      expect(attempt).toBe(2)
+    })
+
+    assay(
+      context,
+      'dead-letters after exhausting tries and supports replay and forget',
+      async (driver) => {
+        if (!hasDeadLetter(driver)) return
+        const id = await driver.enqueue({
+          name: 'TerminalJob',
+          payload: { accountId: 'account-1' },
+          queue: 'critical',
+        })
+
+        for (let attempt = 1; attempt <= 3; attempt += 1) {
+          expect(
+            await driver.drain(
+              async () => {
+                throw new Error('terminal failure')
+              },
+              { queue: 'critical' },
+            ),
+          ).toBe(1)
+          expect((await driver.failed('critical')).length).toBe(attempt === 3 ? 1 : 0)
+        }
+
+        const failures = await driver.failed('critical')
+        expect(failures).toHaveLength(1)
+        expect(failures[0]).toMatchObject({
+          id,
+          job: {
+            name: 'TerminalJob',
+            payload: { accountId: 'account-1' },
+            queue: 'critical',
+          },
+          attempt: 3,
+          error: 'terminal failure',
+        })
+        expect(failures[0]?.failedAt).toBeInstanceOf(Date)
+
+        await driver.replay(id)
+        expect(await driver.failed('critical')).toHaveLength(0)
+        let replayAttempt = 0
+        await driver.drain(async (receipt) => {
+          replayAttempt = receipt.attempt
+        })
+        expect(replayAttempt).toBe(1)
+
+        const forgottenId = await driver.enqueue({ name: 'ForgottenJob', payload: {} })
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+          await driver.drain(async () => {
+            throw new Error('forget me')
+          })
+        }
+        expect(await driver.failed()).toHaveLength(1)
+        await driver.forget(forgottenId)
+        expect(await driver.failed()).toHaveLength(0)
+      },
+    )
+
+    assay(context, 'keeps delayed jobs invisible until their delivery time', async (driver) => {
+      if (!hasDelay(driver)) return
+      await driver.enqueueAt(
+        { name: 'ScheduledJob', payload: { batch: 4 } },
+        new Date(Date.now() + delayMs),
+      )
+      expect(await driver.drain(async () => undefined)).toBe(0)
+      await new Promise((resolve) => setTimeout(resolve, settleMs))
+      expect(await driver.drain(async () => undefined)).toBe(1)
+    })
+  })
+}

package/src/suites/ratelimit.ts

@@ -0,0 +1,134 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  Invalid,
+  type RateLimitAlgorithm,
+  type RateLimitCapabilities,
+  type RateLimitDriver,
+  type RateLimitPolicy,
+} from '@avelonjs/core'
+import { captureFailure, type SuiteContext } from '../harness'
+
+type AssayDriver = RateLimitDriver<RateLimitCapabilities>
+
+function assay<TDriver extends AssayDriver>(
+  context: SuiteContext<TDriver>,
+  name: string,
+  assertion: (driver: TDriver) => Promise<void> | void,
+): void {
+  test(name, async () => {
+    const driver = await context.create()
+    try {
+      await assertion(driver)
+    } finally {
+      await context.cleanup?.(driver)
+    }
+  })
+}
+
+async function expectInvalid(operation: () => Promise<unknown>): Promise<Invalid> {
+  const error = await captureFailure(operation)
+  expect(error).toBeInstanceOf(Invalid)
+  if (!(error instanceof Invalid)) throw new Error('Expected Invalid after taxonomy assertion.')
+  expect(error.code).toBe('INVALID')
+  return error
+}
+
+const algorithms: readonly RateLimitAlgorithm[] = ['tokenBucket', 'slidingWindow']
+
+function policy(algorithm: RateLimitAlgorithm, limit = 2): RateLimitPolicy {
+  return { algorithm, limit, intervalSeconds: 0.05 }
+}
+
+/**
+ * Registers the portable rate-limit contract conformance suite.
+ *
+ * Algorithms narrow the accepted policy argument rather than adding methods, so both directions
+ * are tested behaviorally. The first `limit` units are accepted and the next is denied; after one
+ * full interval, capacity is available again. Denial is represented by `RateLimitDecision`, not a
+ * `RateLimited` exception, so only malformed policies normalize to `Invalid`.
+ *
+ * @param context Fresh isolated rate-limit drivers and optional cleanup.
+ */
+export function ratelimitSuite<TDriver extends AssayDriver>(context: SuiteContext<TDriver>): void {
+  describe(`ratelimit conformance: ${context.name}`, () => {
+    assay(context, 'reports a present and stable resolved ratelimit instance', (driver) => {
+      const instance = driver.instance
+      expect(instance.length).toBeGreaterThan(0)
+      expect(driver.instance).toBe(instance)
+    })
+
+    assay(
+      context,
+      'honors every declared rate-limit algorithm in both directions',
+      async (driver) => {
+        for (const algorithm of algorithms) {
+          if (driver.capabilities.algorithms.includes(algorithm)) {
+            const decision = await driver.consume(`declared-${algorithm}`, policy(algorithm))
+            expect(decision.allowed).toBe(true)
+            expect(decision.remaining).toBe(1)
+          } else {
+            const error = await expectInvalid(() =>
+              driver.consume(`undeclared-${algorithm}`, policy(algorithm)),
+            )
+            expect(error.metadata.fields?.algorithm).toBeDefined()
+          }
+        }
+      },
+    )
+
+    assay(context, 'blocks at the configured limit boundary', async (driver) => {
+      for (const algorithm of driver.capabilities.algorithms) {
+        const configured = policy(algorithm)
+        const first = await driver.consume(`boundary-${algorithm}`, configured)
+        const second = await driver.consume(`boundary-${algorithm}`, configured)
+        const blocked = await driver.consume(`boundary-${algorithm}`, configured)
+        expect(first).toMatchObject({ allowed: true, remaining: 1 })
+        expect(second).toMatchObject({ allowed: true, remaining: 0 })
+        expect(blocked).toMatchObject({ allowed: false, remaining: 0 })
+        expect(blocked.retryAfterMs).toBeGreaterThan(0)
+      }
+    })
+
+    assay(context, 'restores capacity after the configured interval', async (driver) => {
+      for (const algorithm of driver.capabilities.algorithms) {
+        const configured = policy(algorithm, 1)
+        expect((await driver.consume(`window-${algorithm}`, configured)).allowed).toBe(true)
+        expect((await driver.consume(`window-${algorithm}`, configured)).allowed).toBe(false)
+        await new Promise((resolve) => setTimeout(resolve, 80))
+        const restored = await driver.consume(`window-${algorithm}`, configured)
+        expect(restored.allowed).toBe(true)
+        expect(restored.remaining).toBe(0)
+      }
+    })
+
+    assay(context, 'keeps separate keys on separate budgets', async (driver) => {
+      for (const algorithm of driver.capabilities.algorithms) {
+        const configured = policy(algorithm, 1)
+        const first = await driver.consume(`first-${algorithm}`, configured)
+        const second = await driver.consume(`second-${algorithm}`, configured)
+        expect(first).toMatchObject({ allowed: true, remaining: 0 })
+        expect(second).toMatchObject({ allowed: true, remaining: 0 })
+      }
+    })
+
+    assay(context, 'clears accumulated state for one key', async (driver) => {
+      for (const algorithm of driver.capabilities.algorithms) {
+        const key = `reset-${algorithm}`
+        const configured = policy(algorithm, 1)
+        await driver.consume(key, configured)
+        expect((await driver.consume(key, configured)).allowed).toBe(false)
+        await driver.reset(key)
+        expect((await driver.consume(key, configured)).allowed).toBe(true)
+      }
+    })
+
+    assay(context, 'normalizes malformed policies to Invalid', async (driver) => {
+      const algorithm = driver.capabilities.algorithms[0]
+      if (!algorithm) return
+      const error = await expectInvalid(() =>
+        driver.consume('invalid-policy', { algorithm, limit: 0, intervalSeconds: 1 }),
+      )
+      expect(Object.keys(error.metadata.fields ?? {})).toContain('limit')
+    })
+  })
+}