@7h3/protocol 0.4.0 → 0.5.1

package/src/queueBinding.ts

@@ -1,102 +0,0 @@
-import {
-  type ProtocolEnvelope,
-  createEnvelope,
-  signEnvelopeEd25519,
-  verifyEnvelopeEd25519,
-} from './protocol'
-
-export interface QueueSignOptions {
-  privateKey: string
-  sender: string
-  recipient?: string
-  ttlMs?: number
-  keyId?: string
-}
-
-export interface QueueVerifyOptions {
-  publicKey: string
-}
-
-export type SignedEnvelope = ProtocolEnvelope
-
-export interface QueueMessage<T> {
-  envelope: SignedEnvelope
-  payload: T
-}
-
-/**
- * Signs a payload for queue transit (Kafka/SQS/Pub-Sub/RabbitMQ).
- * Returns a JSON string: {"envelope": SignedEnvelope, "payload": T}
- * Default TTL is 1 hour (3 600 000 ms).
- */
-export async function signQueueMessage<T>(
-  payload: T,
-  opts: QueueSignOptions,
-): Promise<string> {
-  const ttlMs = opts.ttlMs ?? 3_600_000
-  const content = typeof payload === 'string' ? payload : JSON.stringify(payload)
-
-  const envelope = createEnvelope({
-    sender: opts.sender,
-    recipient: opts.recipient,
-    intent: 'TASK',
-    content,
-    ttlMs,
-  })
-
-  const signed = await signEnvelopeEd25519(envelope, opts.privateKey, opts.keyId)
-
-  const message: QueueMessage<T> = { envelope: signed, payload }
-  return JSON.stringify(message)
-}
-
-/**
- * Parses a queue message JSON string and verifies the envelope signature.
- * Throws if the message is malformed or the signature is invalid.
- */
-export async function verifyQueueMessage<T>(
-  message: string,
-  opts: QueueVerifyOptions,
-): Promise<{ payload: T; envelope: ProtocolEnvelope }> {
-  let parsed: QueueMessage<T>
-  try {
-    parsed = JSON.parse(message) as QueueMessage<T>
-  } catch {
-    throw new Error('Queue message is not valid JSON')
-  }
-
-  if (!parsed.envelope || typeof parsed.envelope !== 'object') {
-    throw new Error('Queue message missing envelope')
-  }
-
-  const valid = await verifyEnvelopeEd25519(parsed.envelope, opts.publicKey)
-  if (!valid) {
-    throw new Error('Queue message signature verification failed')
-  }
-
-  return { payload: parsed.payload, envelope: parsed.envelope }
-}
-
-/**
- * Verifies a batch of queue message strings.
- * Never throws — returns per-message success/failure objects.
- */
-export async function verifyQueueBatch<T>(
-  messages: string[],
-  opts: QueueVerifyOptions,
-): Promise<Array<{ ok: true; payload: T; envelope: ProtocolEnvelope } | { ok: false; raw: string; error: string }>> {
-  return Promise.all(
-    messages.map(async (raw) => {
-      try {
-        const { payload, envelope } = await verifyQueueMessage<T>(raw, opts)
-        return { ok: true as const, payload, envelope }
-      } catch (err) {
-        return {
-          ok: false as const,
-          raw,
-          error: err instanceof Error ? err.message : String(err),
-        }
-      }
-    }),
-  )
-}

package/src/rateLimiter.test.ts

@@ -1,96 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest'
-import { SlidingWindowRateLimiter } from './rateLimiter'
-
-describe('SlidingWindowRateLimiter', () => {
-  let limiter: SlidingWindowRateLimiter
-
-  beforeEach(() => {
-    limiter = new SlidingWindowRateLimiter()
-  })
-
-  it('check() allows when under limit', () => {
-    const result = limiter.check('alice', { requests: 5, windowMs: 1000 })
-    expect(result.allowed).toBe(true)
-    expect(result.remaining).toBe(4) // 4 left after this one would be consumed
-  })
-
-  it('check() does not record a timestamp', () => {
-    const policy = { requests: 1, windowMs: 1000 }
-    limiter.check('alice', policy)
-    limiter.check('alice', policy)
-    // Still allowed — check doesn't consume
-    const result = limiter.check('alice', policy)
-    expect(result.allowed).toBe(true)
-  })
-
-  it('consume() records and blocks at limit', () => {
-    const policy = { requests: 2, windowMs: 10_000 }
-    const r1 = limiter.consume('alice', policy)
-    expect(r1.allowed).toBe(true)
-    expect(r1.remaining).toBe(1)
-
-    const r2 = limiter.consume('alice', policy)
-    expect(r2.allowed).toBe(true)
-    expect(r2.remaining).toBe(0)
-
-    const r3 = limiter.consume('alice', policy)
-    expect(r3.allowed).toBe(false)
-    expect(r3.remaining).toBe(0)
-  })
-
-  it('consume() sliding window expires old timestamps', () => {
-    const policy = { requests: 2, windowMs: 1000 }
-    const baseMs = 10_000
-
-    // Fill the window at t=0
-    limiter.consume('alice', policy, baseMs)
-    limiter.consume('alice', policy, baseMs)
-
-    // Blocked at t=500 (still inside window)
-    const blocked = limiter.consume('alice', policy, baseMs + 500)
-    expect(blocked.allowed).toBe(false)
-
-    // Allowed at t=1001 (first entry has expired)
-    const allowed = limiter.consume('alice', policy, baseMs + 1001)
-    expect(allowed.allowed).toBe(true)
-  })
-
-  it('reset() clears a specific key', () => {
-    const policy = { requests: 1, windowMs: 10_000 }
-    limiter.consume('alice', policy)
-    const blocked = limiter.consume('alice', policy)
-    expect(blocked.allowed).toBe(false)
-
-    limiter.reset('alice')
-    const allowed = limiter.consume('alice', policy)
-    expect(allowed.allowed).toBe(true)
-  })
-
-  it('clear() clears all keys', () => {
-    const policy = { requests: 1, windowMs: 10_000 }
-    limiter.consume('alice', policy)
-    limiter.consume('bob', policy)
-
-    limiter.clear()
-
-    expect(limiter.consume('alice', policy).allowed).toBe(true)
-    expect(limiter.consume('bob', policy).allowed).toBe(true)
-  })
-
-  it('resetMs is non-zero when window has entries', () => {
-    const policy = { requests: 5, windowMs: 1000 }
-    const baseMs = 50_000
-    limiter.consume('alice', policy, baseMs)
-    const result = limiter.check('alice', policy, baseMs + 100)
-    expect(result.resetMs).toBeGreaterThan(0)
-    expect(result.resetMs).toBeLessThanOrEqual(1000)
-  })
-
-  it('different keys are independent', () => {
-    const policy = { requests: 1, windowMs: 10_000 }
-    limiter.consume('alice', policy)
-    // alice is blocked, but bob is not
-    expect(limiter.consume('alice', policy).allowed).toBe(false)
-    expect(limiter.consume('bob', policy).allowed).toBe(true)
-  })
-})

package/src/rateLimiter.ts

@@ -1,46 +0,0 @@
-export type RateLimitPolicy = { requests: number; windowMs: number }
-export type RateLimitResult = { allowed: boolean; remaining: number; resetMs: number }
-
-class SlidingWindowRateLimiter {
-  private windows: Map<string, number[]> = new Map()
-
-  // Check without recording — pure read
-  check(key: string, policy: RateLimitPolicy, nowMs = Date.now()): RateLimitResult {
-    const cutoff = nowMs - policy.windowMs
-    const timestamps = (this.windows.get(key) ?? []).filter(t => t > cutoff)
-    const used = timestamps.length
-    const allowed = used < policy.requests
-    const remaining = Math.max(0, policy.requests - used - (allowed ? 1 : 0))
-    // resetMs: time until the oldest timestamp falls out of window (0 if window empty)
-    const resetMs = timestamps.length > 0 ? Math.max(0, timestamps[0] + policy.windowMs - nowMs) : 0
-    return { allowed, remaining, resetMs }
-  }
-
-  // Consume — record a timestamp if allowed
-  consume(key: string, policy: RateLimitPolicy, nowMs = Date.now()): RateLimitResult {
-    const cutoff = nowMs - policy.windowMs
-    const timestamps = (this.windows.get(key) ?? []).filter(t => t > cutoff)
-    const used = timestamps.length
-    const allowed = used < policy.requests
-
-    if (allowed) {
-      timestamps.push(nowMs)
-      this.windows.set(key, timestamps)
-    }
-
-    const remaining = Math.max(0, policy.requests - timestamps.length)
-    const resetMs = timestamps.length > 0 ? Math.max(0, timestamps[0] + policy.windowMs - nowMs) : 0
-    return { allowed, remaining, resetMs }
-  }
-
-  reset(key: string): void {
-    this.windows.delete(key)
-  }
-
-  clear(): void {
-    this.windows.clear()
-  }
-}
-
-export const globalRateLimiter = new SlidingWindowRateLimiter()
-export { SlidingWindowRateLimiter }

package/src/redisIntegration.test.ts

@@ -1,134 +0,0 @@
-import net from 'node:net'
-import { afterAll, describe, expect, it } from 'vitest'
-import type { RedisLikeClient, RedisSetOptions } from './redisClient'
-import { createRedisReplayStore } from './replayStores'
-import { createRedisRevocationStore } from './revocation'
-
-/**
- * Minimal RESP client over a raw socket — just enough of the Redis wire
- * protocol to drive SET/GET/DEL. Dependency-free so the integration test can
- * run against a real redis-server without adding an npm Redis client.
- */
-class NetRedisClient implements RedisLikeClient {
-  private socket!: net.Socket
-  private buffer = Buffer.alloc(0)
-  private readonly waiters: Array<(reply: string | number | null | Error) => void> = []
-
-  connect(host = '127.0.0.1', port = 6379): Promise<void> {
-    return new Promise((resolve, reject) => {
-      this.socket = net.createConnection({ host, port }, resolve)
-      this.socket.on('error', reject)
-      this.socket.on('data', (chunk) => {
-        this.buffer = Buffer.concat([this.buffer, chunk])
-        this.drain()
-      })
-    })
-  }
-
-  close(): void {
-    this.socket?.end()
-  }
-
-  private drain(): void {
-    while (this.waiters.length > 0) {
-      const parsed = this.parseReply(this.buffer)
-      if (!parsed) return
-      this.buffer = this.buffer.subarray(parsed.consumed)
-      this.waiters.shift()!(parsed.value)
-    }
-  }
-
-  private parseReply(buf: Buffer): { value: string | number | null | Error; consumed: number } | null {
-    const end = buf.indexOf('\r\n')
-    if (end < 0) return null
-    const type = String.fromCharCode(buf[0]!)
-    const line = buf.toString('utf8', 1, end)
-    const headerConsumed = end + 2
-    if (type === '+') return { value: line, consumed: headerConsumed }
-    if (type === '-') return { value: new Error(line), consumed: headerConsumed }
-    if (type === ':') return { value: Number(line), consumed: headerConsumed }
-    if (type === '$') {
-      const len = Number(line)
-      if (len === -1) return { value: null, consumed: headerConsumed }
-      const dataEnd = headerConsumed + len
-      if (buf.length < dataEnd + 2) return null
-      return { value: buf.toString('utf8', headerConsumed, dataEnd), consumed: dataEnd + 2 }
-    }
-    return { value: new Error(`unsupported RESP type: ${type}`), consumed: headerConsumed }
-  }
-
-  private command(args: string[]): Promise<string | number | null> {
-    const payload = `*${args.length}\r\n${args.map((a) => `$${Buffer.byteLength(a)}\r\n${a}\r\n`).join('')}`
-    return new Promise((resolve, reject) => {
-      this.waiters.push((reply) => (reply instanceof Error ? reject(reply) : resolve(reply)))
-      this.socket.write(payload)
-    })
-  }
-
-  async set(key: string, value: string, options: RedisSetOptions = {}): Promise<'OK' | null> {
-    const args = ['SET', key, value]
-    if (options.pxMs !== undefined) args.push('PX', String(options.pxMs))
-    if (options.nx) args.push('NX')
-    const reply = await this.command(args)
-    return reply === 'OK' ? 'OK' : null
-  }
-
-  async get(key: string): Promise<string | null> {
-    const reply = await this.command(['GET', key])
-    return reply === null ? null : String(reply)
-  }
-
-  async del(key: string): Promise<number> {
-    const reply = await this.command(['DEL', key])
-    return Number(reply)
-  }
-}
-
-async function redisAvailable(): Promise<NetRedisClient | null> {
-  const client = new NetRedisClient()
-  try {
-    await client.connect()
-    return client
-  } catch {
-    return null
-  }
-}
-
-const client = await redisAvailable()
-const runOrSkip = client ? describe : describe.skip
-if (!client) {
-  console.warn('[redisIntegration] redis-server unreachable on 127.0.0.1:6379 — skipping live integration tests')
-}
-
-// Unique namespace per run so concurrent/previous runs never collide.
-const ns = `aip:test:${Date.now()}:${Math.floor(Math.random() * 1e6)}:`
-
-runOrSkip('Redis integration (live server)', () => {
-  const touched: string[] = []
-
-  afterAll(async () => {
-    if (!client) return
-    for (const key of touched) await client.del(key)
-    client.close()
-  })
-
-  it('replay store reserves a key once against real Redis', async () => {
-    const prefix = `${ns}replay:`
-    const store = createRedisReplayStore(client!, { keyPrefix: prefix })
-    const now = Date.now()
-    touched.push(`${prefix}s|m1|n1`)
-    expect(await store.reserve('s|m1|n1', now + 5000, now)).toBe(true)
-    expect(await store.reserve('s|m1|n1', now + 5000, now)).toBe(false)
-    expect(await store.reserve('s|m2|n2', now + 5000, now)).toBe(true)
-    touched.push(`${prefix}s|m2|n2`)
-  })
-
-  it('revocation store reflects a revoke against real Redis', async () => {
-    const prefix = `${ns}revoked:`
-    const store = createRedisRevocationStore(client!, { keyPrefix: prefix, cacheTtlMs: 0 })
-    touched.push(`${prefix}agent.a agent-k1`)
-    expect(await store.isRevoked('agent.a', 'agent-k1')).toBe(false)
-    await store.revoke('agent.a', 'agent-k1')
-    expect(await store.isRevoked('agent.a', 'agent-k1')).toBe(true)
-  })
-})

package/src/replayStores.test.ts

@@ -1,141 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import { InMemoryRedisLikeClient } from './redisClient'
-import { createRedisReplayStore } from './replayStores'
-import { DistributedReplayCache } from './protocolReplay'
-import { createEnvelope } from './protocol'
-
-describe('InMemoryRedisLikeClient (reference client)', () => {
-  it('SET NX returns OK on first write and null when the key already exists', async () => {
-    const client = new InMemoryRedisLikeClient()
-    const first = await client.set('k', '1', { nx: true, pxMs: 1000 })
-    const second = await client.set('k', '1', { nx: true, pxMs: 1000 })
-    expect(first).toBe('OK')
-    expect(second).toBeNull()
-  })
-
-  it('SET NX succeeds again after the PX TTL elapses', async () => {
-    let now = 1000
-    const client = new InMemoryRedisLikeClient({ now: () => now })
-    expect(await client.set('k', '1', { nx: true, pxMs: 500 })).toBe('OK')
-    now = 1400
-    expect(await client.set('k', '1', { nx: true, pxMs: 500 })).toBeNull()
-    now = 1600
-    expect(await client.set('k', '1', { nx: true, pxMs: 500 })).toBe('OK')
-  })
-})
-
-describe('createRedisReplayStore', () => {
-  it('reserve returns true for a new key and false for a duplicate', async () => {
-    const store = createRedisReplayStore(new InMemoryRedisLikeClient())
-    expect(await store.reserve('sender|m1|n1', 5000, 1000)).toBe(true)
-    expect(await store.reserve('sender|m1|n1', 5000, 1000)).toBe(false)
-  })
-
-  it('reserves distinct keys independently', async () => {
-    const store = createRedisReplayStore(new InMemoryRedisLikeClient())
-    expect(await store.reserve('sender|m1|n1', 5000, 1000)).toBe(true)
-    expect(await store.reserve('sender|m2|n2', 5000, 1000)).toBe(true)
-  })
-
-  it('sets the Redis key with the prefix and a positive PX derived from expiry minus now', async () => {
-    const client = new InMemoryRedisLikeClient()
-    const setSpy = vi.spyOn(client, 'set')
-    const store = createRedisReplayStore(client, { keyPrefix: 'aip:replay:' })
-    await store.reserve('sender|m1|n1', 5000, 1000)
-    expect(setSpy).toHaveBeenCalledWith('aip:replay:sender|m1|n1', '1', { nx: true, pxMs: 4000 })
-  })
-
-  it('clamps PX to at least 1ms when expiry is not in the future', async () => {
-    const client = new InMemoryRedisLikeClient()
-    const setSpy = vi.spyOn(client, 'set')
-    const store = createRedisReplayStore(client)
-    await store.reserve('sender|m1|n1', 1000, 1000)
-    expect(setSpy).toHaveBeenCalledWith('aip:replay:sender|m1|n1', '1', { nx: true, pxMs: 1 })
-  })
-})
-
-describe('createRedisReplayStore degraded behavior', () => {
-  function throwingClient() {
-    return {
-      set: async () => {
-        throw new Error('redis unreachable')
-      },
-    }
-  }
-
-  it('errorBehavior "reject" returns false and fires onDegraded when the client throws', async () => {
-    const onDegraded = vi.fn()
-    const store = createRedisReplayStore(throwingClient(), { errorBehavior: 'reject', onDegraded })
-    expect(await store.reserve('sender|m1|n1', 5000, 1000)).toBe(false)
-    expect(onDegraded).toHaveBeenCalledOnce()
-  })
-
-  it('errorBehavior "allow" returns true and fires onDegraded when the client throws', async () => {
-    const onDegraded = vi.fn()
-    const store = createRedisReplayStore(throwingClient(), { errorBehavior: 'allow', onDegraded })
-    expect(await store.reserve('sender|m1|n1', 5000, 1000)).toBe(true)
-    expect(onDegraded).toHaveBeenCalledOnce()
-  })
-
-  it('errorBehavior "fallback" (default) degrades to a local store and fires onDegraded', async () => {
-    const onDegraded = vi.fn()
-    const store = createRedisReplayStore(throwingClient(), { onDegraded })
-    // first call to the degraded local store reserves successfully
-    expect(await store.reserve('sender|m1|n1', 5000, 1000)).toBe(true)
-    // second identical call is caught locally as a replay
-    expect(await store.reserve('sender|m1|n1', 5000, 1000)).toBe(false)
-    expect(onDegraded).toHaveBeenCalledTimes(2)
-  })
-
-  it('errorBehavior "fallback" delegates to an explicitly provided local store', async () => {
-    const onDegraded = vi.fn()
-    const fallback = createRedisReplayStore(new InMemoryRedisLikeClient())
-    const store = createRedisReplayStore(throwingClient(), { fallback, onDegraded })
-    expect(await store.reserve('sender|m1|n1', 5000, 1000)).toBe(true)
-    expect(await store.reserve('sender|m1|n1', 5000, 1000)).toBe(false)
-    expect(onDegraded).toHaveBeenCalledTimes(2)
-  })
-})
-
-describe('createRedisReplayStore batch (reserveMany)', () => {
-  it('reserves a batch, deduplicating within the batch and against prior reservations', async () => {
-    const store = createRedisReplayStore(new InMemoryRedisLikeClient())
-    await store.reserve('sender|m0|n0', 5000, 1000)
-    const results = await store.reserveMany!(
-      [
-        { key: 'sender|m0|n0', expiresAtMs: 5000 }, // already reserved → false
-        { key: 'sender|m1|n1', expiresAtMs: 5000 }, // new → true
-        { key: 'sender|m1|n1', expiresAtMs: 5000 }, // duplicate within batch → false
-      ],
-      1000,
-    )
-    expect(results).toEqual([false, true, false])
-  })
-
-  it('uses the client pipeline when one is available (single round-trip)', async () => {
-    const client = new InMemoryRedisLikeClient()
-    const pipelineSpy = vi.spyOn(client, 'pipeline')
-    const store = createRedisReplayStore(client)
-    await store.reserveMany!(
-      [
-        { key: 'sender|m1|n1', expiresAtMs: 5000 },
-        { key: 'sender|m2|n2', expiresAtMs: 5000 },
-      ],
-      1000,
-    )
-    expect(pipelineSpy).toHaveBeenCalledOnce()
-  })
-})
-
-describe('DistributedReplayCache batch delegation', () => {
-  it('consumeMany routes through the store reserveMany when present', async () => {
-    const store = createRedisReplayStore(new InMemoryRedisLikeClient())
-    const reserveManySpy = vi.spyOn(store, 'reserveMany')
-    const cache = new DistributedReplayCache(store)
-    const e1 = { ...createEnvelope({ sender: 's', intent: 'PING', content: 'p', messageId: 'm1', nonce: 'n1', nowMs: 1000 }), signature: undefined } as never
-    const e2 = { ...createEnvelope({ sender: 's', intent: 'PING', content: 'p', messageId: 'm2', nonce: 'n2', nowMs: 1000 }), signature: undefined } as never
-    const results = await cache.consumeMany([e1, e2], 1000)
-    expect(reserveManySpy).toHaveBeenCalledOnce()
-    expect(results.map((r) => r.ok)).toEqual([true, true])
-  })
-})

package/src/replayStores.ts

@@ -1,82 +0,0 @@
-import type { DistributedReplayStore } from './protocolReplay'
-import { InMemoryRedisLikeClient, type RedisLikeClient } from './redisClient'
-
-/**
- * What to do when the Redis client throws (network blip, server down).
- *
- * - `fallback` (default): degrade to a local in-memory store so traffic keeps
- *   flowing with single-node replay protection still in force. Quality +
- *   reliability + scalability: Redis is never a fleet-wide kill switch.
- * - `reject`: fail closed — deny the message because uniqueness cannot be confirmed.
- * - `allow`: fail open — accept the message (skip the check) to maximise uptime.
- */
-export type ReplayErrorBehavior = 'fallback' | 'reject' | 'allow'
-
-export interface RedisReplayStoreOptions {
-  /** Key namespace in Redis. Default `aip:replay:`. */
-  keyPrefix?: string
-  /** Behavior when the Redis client throws. Default `fallback`. */
-  errorBehavior?: ReplayErrorBehavior
-  /** Local store used when `errorBehavior` is `fallback`. Defaults to an in-memory-backed store. */
-  fallback?: DistributedReplayStore
-  /** Observability hook fired whenever a Redis error forces degraded handling. */
-  onDegraded?: (error: unknown, context: { key: string; behavior: ReplayErrorBehavior }) => void
-}
-
-/**
- * Creates a {@link DistributedReplayStore} backed by Redis-style `SET NX PX`.
- *
- * Drop the returned store into `new DistributedReplayCache(store)` (or pass a
- * `DistributedReplayCache` as the transport `replayCache`).
- */
-export function createRedisReplayStore(
-  client: RedisLikeClient,
-  options: RedisReplayStoreOptions = {},
-): DistributedReplayStore {
-  const keyPrefix = options.keyPrefix ?? 'aip:replay:'
-  const errorBehavior = options.errorBehavior ?? 'fallback'
-  const onDegraded = options.onDegraded
-  const fallback =
-    options.fallback ??
-    (errorBehavior === 'fallback'
-      ? // The local fallback runs over a non-throwing in-memory client, so it
-        // needs no fallback of its own — `reject` terminates the chain.
-        createRedisReplayStore(new InMemoryRedisLikeClient(), { keyPrefix, errorBehavior: 'reject' })
-      : undefined)
-
-  function degrade(error: unknown, key: string, expiresAtMs: number, nowMs: number): Promise<boolean> | boolean {
-    onDegraded?.(error, { key, behavior: errorBehavior })
-    if (errorBehavior === 'allow') return true
-    if (errorBehavior === 'reject') return false
-    return fallback ? fallback.reserve(key, expiresAtMs, nowMs) : false
-  }
-
-  return {
-    async reserve(key: string, expiresAtMs: number, nowMs: number): Promise<boolean> {
-      const pxMs = Math.max(1, expiresAtMs - nowMs)
-      try {
-        const result = await client.set(`${keyPrefix}${key}`, '1', { nx: true, pxMs })
-        return result === 'OK'
-      } catch (error) {
-        return degrade(error, key, expiresAtMs, nowMs)
-      }
-    },
-
-    async reserveMany(entries: Array<{ key: string; expiresAtMs: number }>, nowMs: number): Promise<boolean[]> {
-      if (entries.length === 0) return []
-      if (client.pipeline) {
-        try {
-          const batch = client.pipeline()
-          for (const { key, expiresAtMs } of entries) {
-            batch.set(`${keyPrefix}${key}`, '1', { nx: true, pxMs: Math.max(1, expiresAtMs - nowMs) })
-          }
-          const results = await batch.exec()
-          return results.map((result) => result === 'OK')
-        } catch (error) {
-          return Promise.all(entries.map((entry) => degrade(error, entry.key, entry.expiresAtMs, nowMs)))
-        }
-      }
-      return Promise.all(entries.map((entry) => this.reserve(entry.key, entry.expiresAtMs, nowMs)))
-    },
-  }
-}