@adcp/sdk 7.8.0 → 7.9.0

package/dist/lib/signing/redis-replay-store.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Redis-backed `ReplayStore` for distributed AdCP verifier deployments.
+ *
+ * Sister of `PostgresReplayStore`. The spec comment on `ReplayStore.insert`
+ * (`src/lib/signing/replay.ts`) literally names this as a canonical
+ * implementation: "Multi-replica adopters writing Redis / Postgres
+ * stores MUST implement this as a single atomic operation (e.g. Redis
+ * `SET NX EX`, Postgres `INSERT ... ON CONFLICT DO NOTHING RETURNING`,
+ * a `WATCH/MULTI/EXEC` transaction)."
+ *
+ * **Data model.** One Redis sorted set per `(keyid, scope)` pair. The
+ * sorted-set members are nonces; the score is `expiresAt` (unix epoch
+ * seconds). Sorted sets give us all three primitives the `ReplayStore`
+ * interface needs in single Redis commands:
+ *
+ * - `has(nonce)` → `ZSCORE` + JS-side `score > now` check.
+ * - `isCapHit()` → `ZCOUNT key (now +inf` (active nonces).
+ * - `insert()` → a Lua script that runs `ZREMRANGEBYSCORE -inf now`
+ *   (drop expired) → `ZSCORE` (replay check) → `ZCARD` (cap check) →
+ *   `ZADD` (insert) + `PEXPIREAT` (extend set's own TTL) atomically.
+ *
+ * **No sweeper needed.** Expired nonces are dropped at the start of
+ * every `insert` (the `ZREMRANGEBYSCORE` step), and Redis evicts the
+ * entire sorted set when its `PEXPIREAT` lapses if no further inserts
+ * arrive. The Postgres backend's `sweepExpiredReplays` cron has no
+ * Redis equivalent — eviction is automatic.
+ *
+ * **Atomicity.** The Lua script runs as a single uninterruptable
+ * operation against the Redis server (Redis is single-threaded; Lua
+ * blocks everything else for the script duration). Two concurrent
+ * `insert` calls with the same `(keyid, scope, nonce)` are guaranteed
+ * to see exactly one `'ok'` and one `'replayed'` — matches the
+ * `InMemoryReplayStore` semantics the spec mandates.
+ *
+ * **Redis memory policy — set this on the deployment.** Each
+ * `(keyid, scope)` sorted set is capped (default 100k nonces). A
+ * hostile signer with a valid keyid + scope can fill the set to its
+ * cap; legitimate fan-out (many sibling verifiers, many scopes) grows
+ * the number of sets. Configure your Redis with:
+ *
+ * - **`maxmemory-policy volatile-lru`** (recommended) — evicts only
+ *   TTL'd keys. All sets this store writes carry `PEXPIREAT`, so
+ *   they're all evictable. Safe on a shared Redis instance.
+ * - **`maxmemory-policy allkeys-lru`** — only on a dedicated db.
+ *   Otherwise evicts unrelated app keys.
+ * - **`maxmemory-policy noeviction`** (Redis default) — fail-closed:
+ *   writes start erroring at the memory limit; the verifier will
+ *   throw and the middleware will return 500 (replay protection
+ *   stays intact — never fail-open). Operationally noisy but
+ *   never serves stale replay decisions.
+ *
+ * Eviction-on-replay implication: if `volatile-lru` evicts a sorted
+ * set before its members would have expired naturally, an attacker's
+ * later replay of one of those nonces sees a fresh set with no prior
+ * entry, returns `'ok'`. The cap is the primary defense; memory-policy
+ * eviction is a secondary recovery mode. Size Redis to keep the
+ * working set in memory under normal traffic and treat eviction as
+ * pressure to scale up, not as a feature.
+ *
+ * @example
+ * ```typescript
+ * import { createClient } from 'redis';
+ * import { RedisReplayStore } from '@adcp/sdk/signing/server';
+ *
+ * const client = createClient({ url: process.env.REDIS_URL });
+ * client.on('error', (err) => console.error('redis error', err));
+ * await client.connect();
+ *
+ * const replayStore = new RedisReplayStore(client);
+ *
+ * app.use(createExpressVerifier({
+ *   capability: { ... },
+ *   jwks,
+ *   replayStore,           // <-- shared across instances
+ *   resolveOperation: mcpToolNameResolver,
+ * }));
+ * ```
+ */
+import type { RedisClientType } from 'redis';
+import type { ReplayInsertResult, ReplayStore } from './replay';
+/**
+ * Escape-hatch interface for adopters not using the official `redis`
+ * client (node-redis v4/v5) — `ioredis`, Upstash, test doubles.
+ * Mirrors the methods this store calls.
+ *
+ * **Footgun: `ioredis.zscore` returns `Promise<string | null>`**, not
+ * `Promise<number | null>` like node-redis. The `Number(v)` coercion
+ * in the adapter is **mandatory** — without it, the `score > now`
+ * comparison inside `has()` becomes a string-vs-number compare that's
+ * silently wrong near unix-second boundaries (JS coerces the number
+ * to a string for `>`, producing lexicographic ordering — replay
+ * decisions break). Test doubles writing their own `zScore` MUST
+ * also return `number | null`.
+ *
+ * @example ioredis adapter
+ * ```typescript
+ * import Redis from 'ioredis';
+ * const ioredis = new Redis(process.env.REDIS_URL!);
+ *
+ * const client: ReplayRedisLikeClient = {
+ *   eval: (script, opts) =>
+ *     ioredis.eval(script, opts.keys.length, ...opts.keys, ...opts.arguments),
+ *   // Number() coercion is REQUIRED — ioredis.zscore returns string|null.
+ *   zScore: (k, m) => ioredis.zscore(k, m).then(v => (v === null ? null : Number(v))),
+ *   zCount: (k, min, max) => ioredis.zcount(k, min, max),
+ *   ping: () => ioredis.ping(),
+ * };
+ * ```
+ */
+export interface ReplayRedisLikeClient {
+    eval(script: string, options: {
+        keys: string[];
+        arguments: string[];
+    }): Promise<unknown>;
+    zScore(key: string, member: string): Promise<number | null>;
+    zCount(key: string, min: number | string, max: number | string): Promise<number>;
+    ping(): Promise<string>;
+}
+/**
+ * Accepted client shape: either a real node-redis client (the typical
+ * path — pass `createClient(...)` straight in) or an adapter
+ * conforming to `ReplayRedisLikeClient`.
+ */
+export type ReplayRedisBackendClient = RedisClientType<any, any, any> | ReplayRedisLikeClient;
+export interface RedisReplayStoreOptions {
+    /**
+     * Key prefix prepended to every `(keyid, scope)` Redis key. Defaults
+     * to `"adcp:replay:"`.
+     *
+     * **Sharing a Redis db across deployments? Override this.** The
+     * default is fine for a dedicated Redis (or db index). Two verifier
+     * deployments sharing the same db with the same default prefix can
+     * collide on overlapping `keyid`s — set a deployment-unique prefix
+     * or use separate dbs.
+     */
+    keyPrefix?: string;
+    /**
+     * Max retained (unexpired) nonces per `(keyid, scope)` pair before
+     * `insert` returns `'rate_abuse'`. Mirrors `PostgresReplayStore`'s
+     * cap. Defaults to 100,000.
+     *
+     * Unlike the Postgres backend, the cap check is **strictly atomic**
+     * — it runs inside the same Lua script as the insert. Concurrent
+     * inserts at `cap - 1` can never both succeed.
+     */
+    cap?: number;
+    /**
+     * How many seconds past the latest entry's `expiresAt` to keep the
+     * sorted set alive in Redis. Defaults to 3600 (1h). See the
+     * `DEFAULT_SET_TTL_GRACE_SECONDS` comment for rationale.
+     */
+    setTtlGraceSeconds?: number;
+    /**
+     * Suppress the one-time `console.warn` at construction when the
+     * default `keyPrefix` is used against a node-redis client on db 0.
+     */
+    suppressDefaultPrefixWarning?: boolean;
+}
+export declare class RedisReplayStore implements ReplayStore {
+    private readonly c;
+    private readonly keyPrefix;
+    private readonly cap;
+    private readonly setTtlGraceSeconds;
+    constructor(client: ReplayRedisBackendClient, options?: RedisReplayStoreOptions);
+    /**
+     * Compose the sorted-set Redis key for a `(keyid, scope)` pair.
+     * Uses `\x1f` (unit separator) between segments — illegal in RFC
+     * 7517 JWK kids and in URLs, so no legitimate input collides.
+     */
+    private redisKey;
+    /**
+     * Probe — ping Redis. Not part of the `ReplayStore` interface; call
+     * before serving traffic if you want a boot-time readiness check.
+     */
+    probe(): Promise<void>;
+    has(keyid: string, scope: string, nonce: string, now: number): Promise<boolean>;
+    isCapHit(keyid: string, scope: string, now: number): Promise<boolean>;
+    insert(keyid: string, scope: string, nonce: string, ttlSeconds: number, now: number): Promise<ReplayInsertResult>;
+}
+//# sourceMappingURL=redis-replay-store.d.ts.map

package/dist/lib/signing/redis-replay-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-replay-store.d.ts","sourceRoot":"","sources":["../../../src/lib/signing/redis-replay-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6EG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,OAAO,CAAC;AAC7C,OAAO,KAAK,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAGhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,WAAW,qBAAqB;IACpC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,SAAS,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACzF,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC5D,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACjF,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,MAAM,wBAAwB,GAAG,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,GAAG,qBAAqB,CAAC;AAe9F,MAAM,WAAW,uBAAuB;IACtC;;;;;;;;;OASG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;;;OAQG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;OAGG;IACH,4BAA4B,CAAC,EAAE,OAAO,CAAC;CACxC;AAuFD,qBAAa,gBAAiB,YAAW,WAAW;IAClD,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAwB;IAC1C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;gBAEhC,MAAM,EAAE,wBAAwB,EAAE,OAAO,GAAE,uBAA4B;IAwBnF;;;;OAIG;IACH,OAAO,CAAC,QAAQ;IAIhB;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAatB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAU/E,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAUrE,MAAM,CACV,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,kBAAkB,CAAC;CA0B/B"}

package/dist/lib/signing/redis-replay-store.js

@@ -0,0 +1,270 @@
+"use strict";
+/**
+ * Redis-backed `ReplayStore` for distributed AdCP verifier deployments.
+ *
+ * Sister of `PostgresReplayStore`. The spec comment on `ReplayStore.insert`
+ * (`src/lib/signing/replay.ts`) literally names this as a canonical
+ * implementation: "Multi-replica adopters writing Redis / Postgres
+ * stores MUST implement this as a single atomic operation (e.g. Redis
+ * `SET NX EX`, Postgres `INSERT ... ON CONFLICT DO NOTHING RETURNING`,
+ * a `WATCH/MULTI/EXEC` transaction)."
+ *
+ * **Data model.** One Redis sorted set per `(keyid, scope)` pair. The
+ * sorted-set members are nonces; the score is `expiresAt` (unix epoch
+ * seconds). Sorted sets give us all three primitives the `ReplayStore`
+ * interface needs in single Redis commands:
+ *
+ * - `has(nonce)` → `ZSCORE` + JS-side `score > now` check.
+ * - `isCapHit()` → `ZCOUNT key (now +inf` (active nonces).
+ * - `insert()` → a Lua script that runs `ZREMRANGEBYSCORE -inf now`
+ *   (drop expired) → `ZSCORE` (replay check) → `ZCARD` (cap check) →
+ *   `ZADD` (insert) + `PEXPIREAT` (extend set's own TTL) atomically.
+ *
+ * **No sweeper needed.** Expired nonces are dropped at the start of
+ * every `insert` (the `ZREMRANGEBYSCORE` step), and Redis evicts the
+ * entire sorted set when its `PEXPIREAT` lapses if no further inserts
+ * arrive. The Postgres backend's `sweepExpiredReplays` cron has no
+ * Redis equivalent — eviction is automatic.
+ *
+ * **Atomicity.** The Lua script runs as a single uninterruptable
+ * operation against the Redis server (Redis is single-threaded; Lua
+ * blocks everything else for the script duration). Two concurrent
+ * `insert` calls with the same `(keyid, scope, nonce)` are guaranteed
+ * to see exactly one `'ok'` and one `'replayed'` — matches the
+ * `InMemoryReplayStore` semantics the spec mandates.
+ *
+ * **Redis memory policy — set this on the deployment.** Each
+ * `(keyid, scope)` sorted set is capped (default 100k nonces). A
+ * hostile signer with a valid keyid + scope can fill the set to its
+ * cap; legitimate fan-out (many sibling verifiers, many scopes) grows
+ * the number of sets. Configure your Redis with:
+ *
+ * - **`maxmemory-policy volatile-lru`** (recommended) — evicts only
+ *   TTL'd keys. All sets this store writes carry `PEXPIREAT`, so
+ *   they're all evictable. Safe on a shared Redis instance.
+ * - **`maxmemory-policy allkeys-lru`** — only on a dedicated db.
+ *   Otherwise evicts unrelated app keys.
+ * - **`maxmemory-policy noeviction`** (Redis default) — fail-closed:
+ *   writes start erroring at the memory limit; the verifier will
+ *   throw and the middleware will return 500 (replay protection
+ *   stays intact — never fail-open). Operationally noisy but
+ *   never serves stale replay decisions.
+ *
+ * Eviction-on-replay implication: if `volatile-lru` evicts a sorted
+ * set before its members would have expired naturally, an attacker's
+ * later replay of one of those nonces sees a fresh set with no prior
+ * entry, returns `'ok'`. The cap is the primary defense; memory-policy
+ * eviction is a secondary recovery mode. Size Redis to keep the
+ * working set in memory under normal traffic and treat eviction as
+ * pressure to scale up, not as a feature.
+ *
+ * @example
+ * ```typescript
+ * import { createClient } from 'redis';
+ * import { RedisReplayStore } from '@adcp/sdk/signing/server';
+ *
+ * const client = createClient({ url: process.env.REDIS_URL });
+ * client.on('error', (err) => console.error('redis error', err));
+ * await client.connect();
+ *
+ * const replayStore = new RedisReplayStore(client);
+ *
+ * app.use(createExpressVerifier({
+ *   capability: { ... },
+ *   jwks,
+ *   replayStore,           // <-- shared across instances
+ *   resolveOperation: mcpToolNameResolver,
+ * }));
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisReplayStore = void 0;
+const redis_default_prefix_warn_1 = require("../utils/redis-default-prefix-warn");
+const DEFAULT_KEY_PREFIX = 'adcp:replay:';
+const DEFAULT_CAP = 100_000;
+/**
+ * Extra seconds added to the sorted-set's own `PEXPIREAT` past the
+ * latest entry's `expiresAt`. Without this, a sorted set whose last
+ * entry just expired would be evicted by Redis between `insert` calls,
+ * losing the cap-counter accounting briefly. 1 hour is conservative —
+ * memory-cheap because the set is also empty (`ZREMRANGEBYSCORE` ran
+ * before the eventual eviction) and short enough that abandoned
+ * `(keyid, scope)` tuples don't leak indefinitely.
+ */
+const DEFAULT_SET_TTL_GRACE_SECONDS = 3600;
+/**
+ * Lua script — atomic replay check, cap check, and insert.
+ *
+ * KEYS[1] — the sorted-set key for this `(keyid, scope)` pair.
+ * ARGV[1] — nonce.
+ * ARGV[2] — expiresAt (unix epoch seconds).
+ * ARGV[3] — now (unix epoch seconds).
+ * ARGV[4] — cap (max retained nonces).
+ * ARGV[5] — setTtlGraceSeconds (extra TTL on the sorted set itself).
+ *
+ * Returns the literal string `'ok'`, `'replayed'`, or `'rate_abuse'`
+ * to match the `ReplayInsertResult` enum.
+ *
+ * Precedence (matches `InMemoryReplayStore` and `PostgresReplayStore`):
+ *   1. replay wins,
+ *   2. then rate_abuse,
+ *   3. then ok.
+ *
+ * The `ZREMRANGEBYSCORE` step drops entries whose score is `<= now` —
+ * matching the pg backend's `expires_at > to_timestamp($4)` "still
+ * valid" semantic.
+ */
+const INSERT_LUA = `
+local key = KEYS[1]
+local nonce = ARGV[1]
+local expiresAt = tonumber(ARGV[2])
+local now = tonumber(ARGV[3])
+local cap = tonumber(ARGV[4])
+local grace = tonumber(ARGV[5])
+
+-- Drop expired entries first (inclusive: score <= now is expired)
+redis.call('ZREMRANGEBYSCORE', key, '-inf', now)
+
+-- Replay check — only unexpired entries can be found by ZSCORE because
+-- the cleanup above ran.
+if redis.call('ZSCORE', key, nonce) then
+  return 'replayed'
+end
+
+-- Cap check (count of unexpired entries — already pruned above)
+if redis.call('ZCARD', key) >= cap then
+  return 'rate_abuse'
+end
+
+-- Insert the new nonce.
+redis.call('ZADD', key, expiresAt, nonce)
+
+-- Extend set TTL — but only forward, never backward. A short-lived
+-- insert after a long-lived one must NOT shrink the set's eviction
+-- time below the longest-still-valid nonce's expiry; otherwise the
+-- set would evict early and take still-valid nonces with it (replay
+-- bypass: has() returns false because the key disappeared, and the
+-- attacker's retry of the long-lived nonce is wrongly accepted).
+--
+-- Desired set expiry = max(existing PEXPIREAT, expiresAt + grace).
+-- PTTL returns -1 (no TTL set) or ms-remaining. Since ZADD ran above,
+-- the key exists, so PTTL won't return -2. nowMs is passed from the
+-- SDK side as ARGV[6] — using Redis's TIME command would make the
+-- script non-deterministic for replication.
+local desiredExpireAtMs = (expiresAt + grace) * 1000
+local currentTtlMs = redis.call('PTTL', key)
+local nowMs = tonumber(ARGV[6])
+if currentTtlMs < 0 then
+  -- -1: no TTL set. (ZADD just wrote the key so -2 is impossible.)
+  redis.call('PEXPIREAT', key, desiredExpireAtMs)
+else
+  local currentExpireAtMs = nowMs + currentTtlMs
+  if desiredExpireAtMs > currentExpireAtMs then
+    redis.call('PEXPIREAT', key, desiredExpireAtMs)
+  end
+end
+return 'ok'
+`;
+/**
+ * Reject non-finite / out-of-range timestamps before they reach Redis.
+ * Matches the Postgres backend's defensive guard so a buggy `options.now()`
+ * injection can't DoS the verifier with Redis parse errors.
+ */
+function assertFiniteSeconds(label, value) {
+    if (!Number.isFinite(value) || value < 0 || value > Number.MAX_SAFE_INTEGER) {
+        throw new TypeError(`RedisReplayStore: ${label} must be a finite non-negative number; received ${value}`);
+    }
+}
+class RedisReplayStore {
+    c;
+    keyPrefix;
+    cap;
+    setTtlGraceSeconds;
+    constructor(client, options = {}) {
+        this.c = client;
+        this.keyPrefix = options.keyPrefix ?? DEFAULT_KEY_PREFIX;
+        this.cap = options.cap ?? DEFAULT_CAP;
+        this.setTtlGraceSeconds = options.setTtlGraceSeconds ?? DEFAULT_SET_TTL_GRACE_SECONDS;
+        if (!Number.isFinite(this.cap) || this.cap <= 0) {
+            throw new Error(`RedisReplayStore: cap must be a positive finite number. Got ${this.cap}.`);
+        }
+        if (!Number.isFinite(this.setTtlGraceSeconds) || this.setTtlGraceSeconds < 0) {
+            throw new Error(`RedisReplayStore: setTtlGraceSeconds must be a non-negative finite number. Got ${this.setTtlGraceSeconds}.`);
+        }
+        (0, redis_default_prefix_warn_1.maybeWarnOnSharedRedisPrefix)({
+            client,
+            callerKeyPrefix: options.keyPrefix,
+            defaultKeyPrefix: DEFAULT_KEY_PREFIX,
+            suppress: options.suppressDefaultPrefixWarning,
+            backendName: 'RedisReplayStore',
+        });
+    }
+    /**
+     * Compose the sorted-set Redis key for a `(keyid, scope)` pair.
+     * Uses `\x1f` (unit separator) between segments — illegal in RFC
+     * 7517 JWK kids and in URLs, so no legitimate input collides.
+     */
+    redisKey(keyid, scope) {
+        return `${this.keyPrefix}${keyid}\x1f${scope}`;
+    }
+    /**
+     * Probe — ping Redis. Not part of the `ReplayStore` interface; call
+     * before serving traffic if you want a boot-time readiness check.
+     */
+    async probe() {
+        try {
+            await this.c.ping();
+        }
+        catch (err) {
+            throw new Error(`RedisReplayStore probe failed: Redis is unreachable or misconfigured. ` +
+                `The verifier would accept signed requests but every replay-cache write would fail. ` +
+                `Check REDIS_URL and that the instance is up. See server logs for the underlying cause.`, { cause: err });
+        }
+    }
+    async has(keyid, scope, nonce, now) {
+        assertFiniteSeconds('now', now);
+        const score = await this.c.zScore(this.redisKey(keyid, scope), nonce);
+        // Score === expiresAt. An entry is "present" only if it's still
+        // unexpired (score > now). The Lua script also prunes expired
+        // entries on insert, but `has` is called independently and can
+        // race a never-since-touched key.
+        return score !== null && score > now;
+    }
+    async isCapHit(keyid, scope, now) {
+        assertFiniteSeconds('now', now);
+        // ZCOUNT with `(now` lower bound is exclusive — only entries
+        // strictly in the future count toward the cap. Stale entries
+        // beyond their expiresAt don't inflate the count even before the
+        // next insert prunes them.
+        const active = await this.c.zCount(this.redisKey(keyid, scope), `(${now}`, '+inf');
+        return active >= this.cap;
+    }
+    async insert(keyid, scope, nonce, ttlSeconds, now) {
+        assertFiniteSeconds('now', now);
+        assertFiniteSeconds('ttlSeconds', ttlSeconds);
+        const expiresAt = now + ttlSeconds;
+        // `nowMs` (ARGV[6]) is `now * 1000` rather than `Date.now()` so the
+        // script's "extend forward only" branch uses the SAME clock as the
+        // rest of the verifier path (`now` is the verifier-supplied second-
+        // precision time, used for prune + replay + cap). Using `Date.now()`
+        // here would let scripts disagree with the surrounding logic when
+        // tests inject `options.now()`.
+        const result = await this.c.eval(INSERT_LUA, {
+            keys: [this.redisKey(keyid, scope)],
+            arguments: [
+                nonce,
+                String(expiresAt),
+                String(now),
+                String(this.cap),
+                String(this.setTtlGraceSeconds),
+                String(now * 1000),
+            ],
+        });
+        if (result !== 'ok' && result !== 'replayed' && result !== 'rate_abuse') {
+            throw new Error(`RedisReplayStore.insert: Lua script returned unexpected value: ${String(result)}`);
+        }
+        return result;
+    }
+}
+exports.RedisReplayStore = RedisReplayStore;
+//# sourceMappingURL=redis-replay-store.js.map

package/dist/lib/signing/redis-replay-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-replay-store.js","sourceRoot":"","sources":["../../../src/lib/signing/redis-replay-store.ts"],"names":[],"mappings":"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"}

package/dist/lib/signing/server.d.ts

@@ -19,6 +19,7 @@ export { BrandJsonJwksResolver, BrandJsonResolverError, type BrandAgentType, typ
 export { parseSignature, parseSignatureInput, type ParsedSignature, type ParsedSignatureInput } from './parser';
 export { InMemoryReplayStore, type InMemoryReplayStoreOptions, type ReplayInsertResult, type ReplayStore, } from './replay';
 export { PostgresReplayStore, REPLAY_CACHE_MIGRATION, getReplayStoreMigration, sweepExpiredReplays, type PostgresReplayStoreOptions, type SweepExpiredReplaysOptions, } from './postgres-replay-store';
+export { RedisReplayStore, type RedisReplayStoreOptions, type ReplayRedisBackendClient, type ReplayRedisLikeClient, } from './redis-replay-store';
 export { InMemoryRevocationStore, type RevocationStore } from './revocation';
 export { HttpsRevocationStore, type HttpsRevocationStoreOptions } from './revocation-https';
 export { ALLOWED_ALGS, CLOCK_SKEW_TOLERANCE_SECONDS, MANDATORY_COMPONENTS, MAX_SIGNATURE_WINDOW_SECONDS, REQUEST_SIGNING_TAG, RESPONSE_MANDATORY_COMPONENTS, RESPONSE_SIGNING_TAG, type AdcpJsonWebKey, type ContentDigestPolicy, type RevocationSnapshot, type VerifiedSigner, type VerifierCapability, type VerifyResult, } from './types';

package/dist/lib/signing/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/lib/signing/server.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/lib/signing/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EACL,0BAA0B,EAC1B,kBAAkB,EAClB,kBAAkB,EAClB,eAAe,EACf,kBAAkB,EAClB,qBAAqB,EACrB,cAAc,EACd,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,eAAe,GACrB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAClG,OAAO,EACL,yBAAyB,EACzB,uBAAuB,EACvB,wBAAwB,EACxB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,gCAAgC,EACrC,KAAK,+BAA+B,GACrC,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAC3D,OAAO,EACL,qBAAqB,EACrB,KAAK,yBAAyB,EAC9B,sBAAsB,EACtB,KAAK,0BAA0B,EAC/B,qBAAqB,EACrB,KAAK,yBAAyB,GAC/B,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,kBAAkB,EAAE,KAAK,YAAY,EAAE,MAAM,QAAQ,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,KAAK,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAChF,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,KAAK,cAAc,EACnB,KAAK,4BAA4B,EACjC,KAAK,0BAA0B,GAChC,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,KAAK,eAAe,EAAE,KAAK,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAChH,OAAO,EACL,mBAAmB,EACnB,KAAK,0BAA0B,EAC/B,KAAK,kBAAkB,EACvB,KAAK,WAAW,GACjB,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,uBAAuB,EACvB,mBAAmB,EACnB,KAAK,0BAA0B,EAC/B,KAAK,0BAA0B,GAChC,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,gBAAgB,EAChB,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC7B,KAAK,qBAAqB,GAC3B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,uBAAuB,EAAE,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAC7E,OAAO,EAAE,oBAAoB,EAAE,KAAK,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAC5F,OAAO,EACL,YAAY,EACZ,4BAA4B,EAC5B,oBAAoB,EACpB,4BAA4B,EAC5B,mBAAmB,EACnB,6BAA6B,EAC7B,oBAAoB,EACpB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,YAAY,GAClB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,sBAAsB,EAAE,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAC/E,OAAO,EACL,sBAAsB,EACtB,uBAAuB,EACvB,KAAK,6BAA6B,EAClC,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,GAC1B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,4BAA4B,EAC5B,mBAAmB,EACnB,KAAK,4BAA4B,EACjC,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,GACzB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,qBAAqB,EAAE,KAAK,WAAW,EAAE,KAAK,wBAAwB,EAAE,MAAM,cAAc,CAAC;AACtG,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,wBAAwB,EACxB,mBAAmB,EACnB,gBAAgB,EAChB,mBAAmB,EACnB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,4BAA4B,EACjC,KAAK,yBAAyB,EAC9B,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,SAAS,GACf,MAAM,kBAAkB,CAAC"}

package/dist/lib/signing/server.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentResolverError = exports.createAgentJwksSet = exports.getAgentJwks = exports.resolveAgent = exports.createExpressVerifier = exports.WEBHOOK_SIGNING_TAG = exports.WEBHOOK_MANDATORY_COMPONENTS = exports.verifyWebhookSignature = exports.createWebhookVerifier = exports.verifyResponseSignature = exports.createResponseVerifier = exports.verifyRequestSignature = exports.RESPONSE_SIGNING_TAG = exports.RESPONSE_MANDATORY_COMPONENTS = exports.REQUEST_SIGNING_TAG = exports.MAX_SIGNATURE_WINDOW_SECONDS = exports.MANDATORY_COMPONENTS = exports.CLOCK_SKEW_TOLERANCE_SECONDS = exports.ALLOWED_ALGS = exports.HttpsRevocationStore = exports.InMemoryRevocationStore = exports.sweepExpiredReplays = exports.getReplayStoreMigration = exports.REPLAY_CACHE_MIGRATION = exports.PostgresReplayStore = exports.InMemoryReplayStore = exports.parseSignatureInput = exports.parseSignature = exports.BrandJsonResolverError = exports.BrandJsonJwksResolver = exports.HttpsJwksResolver = exports.StaticJwksResolver = exports.WebhookSignatureError = exports.ResponseSignatureError = exports.RequestSignatureError = exports.verifySignature = exports.jwkToPublicKey = exports.requestContextFromLambda = exports.requestContextFromFetch = exports.requestContextFromExpress = exports.parseContentDigest = exports.contentDigestMatches = exports.computeContentDigest = exports.getHeaderValue = exports.formatSignatureParams = exports.canonicalTargetUri = exports.canonicalMethod = exports.canonicalAuthority = exports.buildSignatureBase = exports.buildResponseSignatureBase = void 0;
-exports.readIdentityPosture = exports.readBrandJsonUrl = exports.ATTACKER_INFLUENCED = exports.attackerInfluencedFields = void 0;
+exports.createAgentJwksSet = exports.getAgentJwks = exports.resolveAgent = exports.createExpressVerifier = exports.WEBHOOK_SIGNING_TAG = exports.WEBHOOK_MANDATORY_COMPONENTS = exports.verifyWebhookSignature = exports.createWebhookVerifier = exports.verifyResponseSignature = exports.createResponseVerifier = exports.verifyRequestSignature = exports.RESPONSE_SIGNING_TAG = exports.RESPONSE_MANDATORY_COMPONENTS = exports.REQUEST_SIGNING_TAG = exports.MAX_SIGNATURE_WINDOW_SECONDS = exports.MANDATORY_COMPONENTS = exports.CLOCK_SKEW_TOLERANCE_SECONDS = exports.ALLOWED_ALGS = exports.HttpsRevocationStore = exports.InMemoryRevocationStore = exports.RedisReplayStore = exports.sweepExpiredReplays = exports.getReplayStoreMigration = exports.REPLAY_CACHE_MIGRATION = exports.PostgresReplayStore = exports.InMemoryReplayStore = exports.parseSignatureInput = exports.parseSignature = exports.BrandJsonResolverError = exports.BrandJsonJwksResolver = exports.HttpsJwksResolver = exports.StaticJwksResolver = exports.WebhookSignatureError = exports.ResponseSignatureError = exports.RequestSignatureError = exports.verifySignature = exports.jwkToPublicKey = exports.requestContextFromLambda = exports.requestContextFromFetch = exports.requestContextFromExpress = exports.parseContentDigest = exports.contentDigestMatches = exports.computeContentDigest = exports.getHeaderValue = exports.formatSignatureParams = exports.canonicalTargetUri = exports.canonicalMethod = exports.canonicalAuthority = exports.buildSignatureBase = exports.buildResponseSignatureBase = void 0;
+exports.readIdentityPosture = exports.readBrandJsonUrl = exports.ATTACKER_INFLUENCED = exports.attackerInfluencedFields = exports.AgentResolverError = void 0;
 /**
  * Server-side signing surface: what a seller running an AdCP agent needs to
  * verify inbound RFC 9421 signatures — verifier pipeline, Express-shaped
@@ -52,6 +52,8 @@ Object.defineProperty(exports, "PostgresReplayStore", { enumerable: true, get: f
 Object.defineProperty(exports, "REPLAY_CACHE_MIGRATION", { enumerable: true, get: function () { return postgres_replay_store_1.REPLAY_CACHE_MIGRATION; } });
 Object.defineProperty(exports, "getReplayStoreMigration", { enumerable: true, get: function () { return postgres_replay_store_1.getReplayStoreMigration; } });
 Object.defineProperty(exports, "sweepExpiredReplays", { enumerable: true, get: function () { return postgres_replay_store_1.sweepExpiredReplays; } });
+var redis_replay_store_1 = require("./redis-replay-store");
+Object.defineProperty(exports, "RedisReplayStore", { enumerable: true, get: function () { return redis_replay_store_1.RedisReplayStore; } });
 var revocation_1 = require("./revocation");
 Object.defineProperty(exports, "InMemoryRevocationStore", { enumerable: true, get: function () { return revocation_1.InMemoryRevocationStore; } });
 var revocation_https_1 = require("./revocation-https");

package/dist/lib/signing/server.js.map

@@ -1 +1 @@
-{"version":3,"file":"server.js","sourceRoot":"","sources":["../../../src/lib/signing/server.ts"],"names":[],"mappings":";;;;AAAA;;;;;;;;;GASG;AACH,+CAWwB;AAVtB,0HAAA,0BAA0B,OAAA;AAC1B,kHAAA,kBAAkB,OAAA;AAClB,kHAAA,kBAAkB,OAAA;AAClB,+GAAA,eAAe,OAAA;AACf,kHAAA,kBAAkB,OAAA;AAClB,qHAAA,qBAAqB,OAAA;AACrB,8GAAA,cAAc,OAAA;AAKhB,mDAAkG;AAAzF,sHAAA,oBAAoB,OAAA;AAAE,sHAAA,oBAAoB,OAAA;AAAE,oHAAA,kBAAkB,OAAA;AACvE,qDAS2B;AARzB,4HAAA,yBAAyB,OAAA;AACzB,0HAAA,uBAAuB,OAAA;AACvB,2HAAA,wBAAwB,OAAA;AAO1B,mCAA2D;AAAlD,wGAAA,cAAc,OAAA;AAAE,yGAAA,eAAe,OAAA;AACxC,mCAOkB;AANhB,+GAAA,qBAAqB,OAAA;AAErB,gHAAA,sBAAsB,OAAA;AAEtB,+GAAA,qBAAqB,OAAA;AAGvB,+BAA+D;AAAtD,0GAAA,kBAAkB,OAAA;AAC3B,2CAAgF;AAAvE,+GAAA,iBAAiB,OAAA;AAC1B,2CAMsB;AALpB,mHAAA,qBAAqB,OAAA;AACrB,oHAAA,sBAAsB,OAAA;AAKxB,mCAAgH;AAAvG,wGAAA,cAAc,OAAA;AAAE,6GAAA,mBAAmB,OAAA;AAC5C,mCAKkB;AAJhB,6GAAA,mBAAmB,OAAA;AAKrB,iEAOiC;AAN/B,4HAAA,mBAAmB,OAAA;AACnB,+HAAA,sBAAsB,OAAA;AACtB,gIAAA,uBAAuB,OAAA;AACvB,4HAAA,mBAAmB,OAAA;AAIrB,2CAA6E;AAApE,qHAAA,uBAAuB,OAAA;AAChC,uDAA4F;AAAnF,wHAAA,oBAAoB,OAAA;AAC7B,iCAciB;AAbf,qGAAA,YAAY,OAAA;AACZ,qHAAA,4BAA4B,OAAA;AAC5B,6GAAA,oBAAoB,OAAA;AACpB,qHAAA,4BAA4B,OAAA;AAC5B,4GAAA,mBAAmB,OAAA;AACnB,sHAAA,6BAA6B,OAAA;AAC7B,6GAAA,oBAAoB,OAAA;AAQtB,uCAA+E;AAAtE,kHAAA,sBAAsB,OAAA;AAC/B,yDAM6B;AAL3B,2HAAA,sBAAsB,OAAA;AACtB,4HAAA,uBAAuB,OAAA;AAKzB,uDAQ4B;AAP1B,yHAAA,qBAAqB,OAAA;AACrB,0HAAA,sBAAsB,OAAA;AACtB,gIAAA,4BAA4B,OAAA;AAC5B,uHAAA,mBAAmB,OAAA;AAKrB,2CAAsG;AAA7F,mHAAA,qBAAqB,OAAA;AAC9B,mDAwB0B;AAvBxB,8GAAA,YAAY,OAAA;AACZ,8GAAA,YAAY,OAAA;AACZ,oHAAA,kBAAkB,OAAA;AAClB,oHAAA,kBAAkB,OAAA;AAClB,0HAAA,wBAAwB,OAAA;AACxB,qHAAA,mBAAmB,OAAA;AACnB,kHAAA,gBAAgB,OAAA;AAChB,qHAAA,mBAAmB,OAAA"}
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../../../src/lib/signing/server.ts"],"names":[],"mappings":";;;;AAAA;;;;;;;;;GASG;AACH,+CAWwB;AAVtB,0HAAA,0BAA0B,OAAA;AAC1B,kHAAA,kBAAkB,OAAA;AAClB,kHAAA,kBAAkB,OAAA;AAClB,+GAAA,eAAe,OAAA;AACf,kHAAA,kBAAkB,OAAA;AAClB,qHAAA,qBAAqB,OAAA;AACrB,8GAAA,cAAc,OAAA;AAKhB,mDAAkG;AAAzF,sHAAA,oBAAoB,OAAA;AAAE,sHAAA,oBAAoB,OAAA;AAAE,oHAAA,kBAAkB,OAAA;AACvE,qDAS2B;AARzB,4HAAA,yBAAyB,OAAA;AACzB,0HAAA,uBAAuB,OAAA;AACvB,2HAAA,wBAAwB,OAAA;AAO1B,mCAA2D;AAAlD,wGAAA,cAAc,OAAA;AAAE,yGAAA,eAAe,OAAA;AACxC,mCAOkB;AANhB,+GAAA,qBAAqB,OAAA;AAErB,gHAAA,sBAAsB,OAAA;AAEtB,+GAAA,qBAAqB,OAAA;AAGvB,+BAA+D;AAAtD,0GAAA,kBAAkB,OAAA;AAC3B,2CAAgF;AAAvE,+GAAA,iBAAiB,OAAA;AAC1B,2CAMsB;AALpB,mHAAA,qBAAqB,OAAA;AACrB,oHAAA,sBAAsB,OAAA;AAKxB,mCAAgH;AAAvG,wGAAA,cAAc,OAAA;AAAE,6GAAA,mBAAmB,OAAA;AAC5C,mCAKkB;AAJhB,6GAAA,mBAAmB,OAAA;AAKrB,iEAOiC;AAN/B,4HAAA,mBAAmB,OAAA;AACnB,+HAAA,sBAAsB,OAAA;AACtB,gIAAA,uBAAuB,OAAA;AACvB,4HAAA,mBAAmB,OAAA;AAIrB,2DAK8B;AAJ5B,sHAAA,gBAAgB,OAAA;AAKlB,2CAA6E;AAApE,qHAAA,uBAAuB,OAAA;AAChC,uDAA4F;AAAnF,wHAAA,oBAAoB,OAAA;AAC7B,iCAciB;AAbf,qGAAA,YAAY,OAAA;AACZ,qHAAA,4BAA4B,OAAA;AAC5B,6GAAA,oBAAoB,OAAA;AACpB,qHAAA,4BAA4B,OAAA;AAC5B,4GAAA,mBAAmB,OAAA;AACnB,sHAAA,6BAA6B,OAAA;AAC7B,6GAAA,oBAAoB,OAAA;AAQtB,uCAA+E;AAAtE,kHAAA,sBAAsB,OAAA;AAC/B,yDAM6B;AAL3B,2HAAA,sBAAsB,OAAA;AACtB,4HAAA,uBAAuB,OAAA;AAKzB,uDAQ4B;AAP1B,yHAAA,qBAAqB,OAAA;AACrB,0HAAA,sBAAsB,OAAA;AACtB,gIAAA,4BAA4B,OAAA;AAC5B,uHAAA,mBAAmB,OAAA;AAKrB,2CAAsG;AAA7F,mHAAA,qBAAqB,OAAA;AAC9B,mDAwB0B;AAvBxB,8GAAA,YAAY,OAAA;AACZ,8GAAA,YAAY,OAAA;AACZ,oHAAA,kBAAkB,OAAA;AAClB,oHAAA,kBAAkB,OAAA;AAClB,0HAAA,wBAAwB,OAAA;AACxB,qHAAA,mBAAmB,OAAA;AACnB,kHAAA,gBAAgB,OAAA;AAChB,qHAAA,mBAAmB,OAAA"}

package/dist/lib/utils/redis-default-prefix-warn.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Shared default-prefix-on-db-0 warning helper for Redis backends.
+ *
+ * Every Redis-backed SDK store (idempotency, ctx-metadata, replay)
+ * prefixes its keys (`"adcp:idem:"`, `"adcp:ctx_meta:"`, `"adcp:replay:"`)
+ * so a shared Redis instance can host multiple AdCP servers — or AdCP
+ * alongside other apps — without collision. But two AdCP deployments
+ * sharing the *same* db with the *same* default prefix collide on any
+ * overlapping principal/account/keyid namespace.
+ *
+ * This helper emits a one-time `console.warn` at backend construction
+ * when the default prefix meets a node-redis client we can confidently
+ * identify as being on db 0 (the most likely signal of a shared,
+ * non-dedicated Redis). Once per process across every backend that uses
+ * it — operators standing up multiple Redis backends shouldn't see N
+ * identical warnings.
+ *
+ * Best-effort: stays silent for escape-hatch clients (ioredis, Upstash,
+ * test doubles) where we can't introspect the db index. Prefer
+ * false-negative over a noisy false-positive warning.
+ */
+/**
+ * Detect the Redis db index when the client is a node-redis v4/v5
+ * `RedisClientType`. Returns `null` for clients we can't introspect.
+ *
+ * Reads `client.options.database` (numeric, present when the client was
+ * constructed with `createClient({ database: N })`) or parses the path
+ * component of `client.options.url`. Escape-hatch clients (no `options`
+ * object of the canonical shape) return `null` and skip the warn.
+ */
+export declare function detectNodeRedisDbIndex(client: unknown): number | null;
+export interface WarnOnSharedRedisPrefixOptions {
+    /** The Redis client passed to the backend constructor. */
+    client: unknown;
+    /** `options.keyPrefix` as the caller passed it — `undefined` means default. */
+    callerKeyPrefix: string | undefined;
+    /** The backend's own default prefix (e.g., `"adcp:idem:"`). */
+    defaultKeyPrefix: string;
+    /** Caller-supplied suppression switch. */
+    suppress: boolean | undefined;
+    /** Backend label for the warning text (e.g., `"redisBackend"`, `"redisCtxMetadataStore"`). */
+    backendName: string;
+}
+/**
+ * Emit the one-time warn if (a) the caller used the default `keyPrefix`,
+ * (b) didn't pass `suppress`, (c) we can confidently see db 0 from the
+ * client. Otherwise silent.
+ *
+ * **Once per process.** All Redis backends share the warn flag — an
+ * adopter who configures three Redis-backed stores against the same
+ * misconfigured Redis sees one warning total, not three.
+ */
+export declare function maybeWarnOnSharedRedisPrefix(options: WarnOnSharedRedisPrefixOptions): void;
+/**
+ * Test-only escape hatch to reset the once-warn flag between test runs.
+ * Not exported through any public index — adopters can't reach it from
+ * outside the SDK.
+ */
+export declare function __resetDefaultPrefixWarningForTests(): void;
+//# sourceMappingURL=redis-default-prefix-warn.d.ts.map

package/dist/lib/utils/redis-default-prefix-warn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-default-prefix-warn.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/redis-default-prefix-warn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAkBrE;AAED,MAAM,WAAW,8BAA8B;IAC7C,0DAA0D;IAC1D,MAAM,EAAE,OAAO,CAAC;IAChB,+EAA+E;IAC/E,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,+DAA+D;IAC/D,gBAAgB,EAAE,MAAM,CAAC;IACzB,0CAA0C;IAC1C,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,8FAA8F;IAC9F,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,8BAA8B,GAAG,IAAI,CAc1F;AAED;;;;GAIG;AACH,wBAAgB,mCAAmC,IAAI,IAAI,CAE1D"}