@7h3/protocol 0.5.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,273 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import { InMemoryRedisLikeClient } from './redisClient'
-import {
-  createRedisReplayStore,
-  RedisReplayStore,
-  ClusterRedisReplayStore,
-  createClusterReplayStore,
-  type ReplayStore,
-  type RedisClientLike,
-} 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])
-  })
-})
-
-// ---------------------------------------------------------------------------
-// New ReplayStore interface and class tests (check()-based API)
-// ---------------------------------------------------------------------------
-
-/**
- * Build a mock RedisClientLike whose SET NX behaviour can be scripted:
- * first call returns 'OK' (fresh), subsequent calls return null (replay).
- */
-function mockRedisClient(): RedisClientLike {
-  let callCount = 0
-  return {
-    set: vi.fn(async (_key: string, _value: string, _opts?: { nx?: boolean; px?: number }) => {
-      callCount++
-      return callCount === 1 ? 'OK' : null
-    }),
-    get: vi.fn(async (_key: string) => null),
-    del: vi.fn(async (_key: string) => 0),
-    quit: vi.fn(async () => undefined),
-  }
-}
-
-describe('RedisReplayStore (check() interface)', () => {
-  it('first call returns false (fresh) and second call returns true (replay)', async () => {
-    const client = mockRedisClient()
-    const store = new RedisReplayStore({ client })
-    const fresh = await store.check('nonce-abc', 30_000)
-    const replay = await store.check('nonce-abc', 30_000)
-    expect(fresh).toBe(false)
-    expect(replay).toBe(true)
-  })
-
-  it('satisfies the ReplayStore interface', () => {
-    const store: ReplayStore = new RedisReplayStore({ client: mockRedisClient() })
-    expect(typeof store.check).toBe('function')
-  })
-
-  it('uses default keyPrefix "7h3:nonce:"', async () => {
-    const client = mockRedisClient()
-    const store = new RedisReplayStore({ client })
-    await store.check('my-nonce', 5000)
-    expect(client.set).toHaveBeenCalledWith('7h3:nonce:my-nonce', '1', { nx: true, px: 5000 })
-  })
-
-  it('respects a custom keyPrefix', async () => {
-    const client = mockRedisClient()
-    const store = new RedisReplayStore({ client, keyPrefix: 'custom:' })
-    await store.check('n1', 1000)
-    expect(client.set).toHaveBeenCalledWith('custom:n1', '1', { nx: true, px: 1000 })
-  })
-
-  it('clamps TTL to at least 1ms', async () => {
-    const client = mockRedisClient()
-    const store = new RedisReplayStore({ client })
-    await store.check('n1', 0)
-    expect(client.set).toHaveBeenCalledWith('7h3:nonce:n1', '1', { nx: true, px: 1 })
-  })
-})
-
-describe('createRedisReplayStore opts-object overload', () => {
-  it('returns a RedisReplayStore with the correct keyPrefix', () => {
-    const store = createRedisReplayStore({ keyPrefix: '7h3:nonce:' })
-    expect(store).toBeInstanceOf(RedisReplayStore)
-  })
-
-  it('returns a RedisReplayStore with default keyPrefix when none specified', () => {
-    const store = createRedisReplayStore({ client: mockRedisClient() })
-    expect(store).toBeInstanceOf(RedisReplayStore)
-  })
-})
-
-describe('ClusterRedisReplayStore', () => {
-  it('check() returns false (fresh) when ALL nodes say fresh', async () => {
-    // Build two nodes each with a fresh client
-    const makeClient = () => {
-      const c = mockRedisClient()
-      return c
-    }
-    const node1 = new RedisReplayStore({ client: makeClient() })
-    const node2 = new RedisReplayStore({ client: makeClient() })
-    const cluster = new ClusterRedisReplayStore([node1, node2])
-    // First call: both nodes return OK → fresh
-    const result = await cluster.check('nonce-xyz', 10_000)
-    expect(result).toBe(false)
-  })
-
-  it('check() returns true (replay) when ANY node reports replay', async () => {
-    // node1: already seen (returns null immediately)
-    const replayClient: RedisClientLike = {
-      set: vi.fn(async () => null), // always null = always replay
-      get: vi.fn(async () => null),
-      del: vi.fn(async () => 0),
-      quit: vi.fn(async () => undefined),
-    }
-    // node2: fresh (returns OK)
-    const freshClient: RedisClientLike = {
-      set: vi.fn(async () => 'OK'),
-      get: vi.fn(async () => null),
-      del: vi.fn(async () => 0),
-      quit: vi.fn(async () => undefined),
-    }
-    const node1 = new RedisReplayStore({ client: replayClient })
-    const node2 = new RedisReplayStore({ client: freshClient })
-    const cluster = new ClusterRedisReplayStore([node1, node2])
-    const result = await cluster.check('nonce-xyz', 10_000)
-    expect(result).toBe(true)
-  })
-
-  it('queries all nodes in parallel via Promise.all', async () => {
-    const clients = [mockRedisClient(), mockRedisClient(), mockRedisClient()]
-    const nodes = clients.map((c) => new RedisReplayStore({ client: c }))
-    const cluster = new ClusterRedisReplayStore(nodes)
-    await cluster.check('nonce-parallel', 5000)
-    for (const c of clients) {
-      expect(c.set).toHaveBeenCalledOnce()
-    }
-  })
-})
-
-describe('createClusterReplayStore', () => {
-  it('returns a ClusterRedisReplayStore from an array of URLs', () => {
-    const cluster = createClusterReplayStore(['redis://node1:6379', 'redis://node2:6379'])
-    expect(cluster).toBeInstanceOf(ClusterRedisReplayStore)
-  })
-})