@adcp/sdk 7.8.0 → 7.9.0

package/dist/lib/server/ctx-metadata/backends/redis.d.ts

@@ -0,0 +1,163 @@
+/**
+ * Redis backend for `CtxMetadataStore`.
+ *
+ * Stores one key per `(account_id, kind, id)` carrying the JSON payload
+ * `{ value, resource?, expiresAt? }`. Entries with no `expiresAt` have
+ * no Redis TTL — ctx-metadata lifetimes can be months (a media buy can
+ * run all year), and silent eviction would produce "package not found"
+ * errors that look like publisher bugs and run for weeks.
+ *
+ * **TTL semantics.** When `entry.expiresAt` is set, the backend stores
+ * the key with `EX = expiresAt - now + expiredGraceSeconds` (default
+ * 60s grace) so the store layer's own expiry check (`entry.expiresAt <
+ * now`) can still run on values within the grace window. When
+ * `entry.expiresAt` is absent, the key is stored with no TTL — durable
+ * by default, matches the pg backend's `expires_at NULL` semantic.
+ *
+ * **`bulkGet` uses `MGET`.** Single round trip for any batch size,
+ * unlike the looped-`GET` fallback. Adopters using an escape-hatch
+ * `RedisLikeClient` adapter MUST implement `mGet` for batch shapes
+ * (`get_products` with N products, `create_media_buy` carrying a
+ * package list referencing products by ID).
+ *
+ * **`clearAll` intentionally omitted.** Same rationale as the
+ * idempotency Redis backend — a shared Redis is a production resource,
+ * and a compliance-reset `FLUSHDB` would nuke unrelated keys. Tests
+ * against a dedicated db index (`REDIS_URL=…/15`) call `FLUSHDB`
+ * themselves.
+ *
+ * @example
+ * ```typescript
+ * import { createClient } from 'redis';
+ * import { createCtxMetadataStore, redisCtxMetadataStore } from '@adcp/sdk/server';
+ *
+ * const client = createClient({ url: process.env.REDIS_URL });
+ * client.on('error', (err) => console.error('redis error', err));
+ * await client.connect();
+ *
+ * const ctxMetadata = createCtxMetadataStore({
+ *   backend: redisCtxMetadataStore(client),
+ * });
+ * ```
+ */
+import type { CtxMetadataBackend } from '../store';
+import type { RedisClientType } from 'redis';
+/**
+ * Escape-hatch interface for adopters not using the official `redis`
+ * client (node-redis v4/v5). Mirrors the methods this backend calls.
+ *
+ * `mGet` matches node-redis's batch-get shape (single round trip).
+ * `ioredis` exposes `mget(keys)` which returns `(string | null)[]` in
+ * the same order — the shim is one line.
+ *
+ * @example ioredis adapter
+ * ```typescript
+ * import Redis from 'ioredis';
+ * const ioredis = new Redis(process.env.REDIS_URL!);
+ *
+ * const client: CtxMetadataRedisLikeClient = {
+ *   get: (k) => ioredis.get(k),
+ *   mGet: (keys) => ioredis.mget(keys),
+ *   set: (k, v, opts) =>
+ *     opts?.EX !== undefined
+ *       ? ioredis.set(k, v, 'EX', opts.EX)
+ *       : ioredis.set(k, v),
+ *   del: (k) => ioredis.del(k as string),
+ *   ping: () => ioredis.ping(),
+ * };
+ * ```
+ */
+export interface CtxMetadataRedisLikeClient {
+    get(key: string): Promise<string | null>;
+    mGet(keys: string[]): Promise<(string | null)[]>;
+    set(key: string, value: string, options?: {
+        EX?: number;
+    }): Promise<string | null>;
+    del(key: string | string[]): Promise<number>;
+    ping(): Promise<string>;
+}
+/**
+ * Accepted client shape: either a real `redis` (node-redis v4/v5)
+ * `RedisClientType` (the typical path — pass `createClient(...)`
+ * straight in) or an adapter conforming to `CtxMetadataRedisLikeClient`
+ * for non-node-redis clients (ioredis, Upstash, test doubles).
+ */
+export type CtxMetadataRedisBackendClient = RedisClientType<any, any, any> | CtxMetadataRedisLikeClient;
+export interface RedisCtxMetadataBackendOptions {
+    /**
+     * Key prefix prepended to every scoped key written to Redis. Defaults
+     * to `"adcp:ctx_meta:"`.
+     *
+     * **Sharing a Redis db across deployments? Override this.** The
+     * default is fine for a dedicated Redis (or a dedicated db index).
+     * Two AdCP servers sharing the same db with the same default prefix
+     * collide on any overlapping `accountId` — the per-tenant scope
+     * segment can't carry deployment isolation on its own. Set a
+     * deployment-unique prefix (`"adcp:ctx_meta:prod-eu:"`, etc.) or use
+     * separate Redis dbs.
+     */
+    keyPrefix?: string;
+    /**
+     * How many seconds past `entry.expiresAt` to keep the key alive in
+     * Redis so the store layer's expiry check (`entry.expiresAt < now`)
+     * can still observe the value within a clock-skew window. Defaults
+     * to 60s.
+     *
+     * Only applies to entries with an `expiresAt`; entries without one
+     * are stored with no TTL (durable by design).
+     */
+    expiredGraceSeconds?: number;
+    /**
+     * Suppress the one-time `console.warn` emitted at construction when
+     * the default `keyPrefix` is used against a node-redis client on db
+     * 0. Set to `true` if you know your Redis is dedicated to this
+     * deployment. The recommended fix is to set `keyPrefix` explicitly,
+     * not to suppress.
+     */
+    suppressDefaultPrefixWarning?: boolean;
+}
+/**
+ * Create a Redis-backed ctx-metadata cache.
+ *
+ * **Startup probe.** Call `store.probe()` before serving traffic to
+ * catch a bad `REDIS_URL` at boot rather than on the first
+ * ctx_metadata write.
+ *
+ * **Client error handling.** node-redis emits errors on the client
+ * itself for transient connection drops. Without a listener, Node's
+ * `EventEmitter` default-throws and crashes the process. Add one in
+ * your bootstrap:
+ *
+ * ```ts
+ * client.on('error', (err) => console.error('redis error', err));
+ * ```
+ *
+ * **Redis memory policy — set this on the deployment.** ctx_metadata
+ * entries default to durable (no TTL) when no `expiresAt` is provided,
+ * matching the pg sibling's `expires_at = NULL` semantic. Without a
+ * memory policy, an adopter who writes many durable entries can
+ * pressure Redis memory; once `maxmemory` is hit, default `noeviction`
+ * makes new writes fail. Choose deliberately:
+ *
+ * - **`maxmemory-policy allkeys-lru`** on a Redis db dedicated to AdCP
+ *   ctx_metadata — evicts the oldest entries to make room. Acceptable
+ *   for ctx_metadata because the next call referencing the same
+ *   resource will write a fresh entry; evicted entries are recoverable
+ *   as publisher traffic re-derives them, not lost permanently.
+ * - **`maxmemory-policy volatile-lru`** if you mostly use `expiresAt`
+ *   on entries — bounds growth to TTL'd keys only.
+ * - **`maxmemory-policy noeviction`** (Redis default) — fail-closed:
+ *   writes start erroring at the limit, mutating tools fail. Pages
+ *   you instead of silently evicting.
+ *
+ * For ctx_metadata specifically, evicting cached entries is safer than
+ * for the idempotency cache (which uses eviction as a feature) because
+ * publisher re-derivation refills the cache on the next reference.
+ * Note that this isn't synchronous "re-hydrate on miss" — the
+ * framework reads `null` for a missing entry and falls through to the
+ * publisher's adapter, which may or may not produce a fresh
+ * `ctx_metadata` value on that path. `allkeys-lru` is the recommended
+ * default on a dedicated db.
+ */
+export declare function redisCtxMetadataStore(client: CtxMetadataRedisBackendClient, options?: RedisCtxMetadataBackendOptions): CtxMetadataBackend;
+//# sourceMappingURL=redis.d.ts.map

package/dist/lib/server/ctx-metadata/backends/redis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../../../../src/lib/server/ctx-metadata/backends/redis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAoB,MAAM,UAAU,CAAC;AAIrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,OAAO,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,0BAA0B;IACzC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACzC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC;IACjD,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACnF,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7C,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CACzB;AAED;;;;;GAKG;AACH,MAAM,MAAM,6BAA6B,GAAG,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,GAAG,0BAA0B,CAAC;AAExG,MAAM,WAAW,8BAA8B;IAC7C;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;;;OAQG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;;OAMG;IACH,4BAA4B,CAAC,EAAE,OAAO,CAAC;CACxC;AAWD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,6BAA6B,EACrC,OAAO,GAAE,8BAAmC,GAC3C,kBAAkB,CAwHpB"}

package/dist/lib/server/ctx-metadata/backends/redis.js

@@ -0,0 +1,204 @@
+"use strict";
+/**
+ * Redis backend for `CtxMetadataStore`.
+ *
+ * Stores one key per `(account_id, kind, id)` carrying the JSON payload
+ * `{ value, resource?, expiresAt? }`. Entries with no `expiresAt` have
+ * no Redis TTL — ctx-metadata lifetimes can be months (a media buy can
+ * run all year), and silent eviction would produce "package not found"
+ * errors that look like publisher bugs and run for weeks.
+ *
+ * **TTL semantics.** When `entry.expiresAt` is set, the backend stores
+ * the key with `EX = expiresAt - now + expiredGraceSeconds` (default
+ * 60s grace) so the store layer's own expiry check (`entry.expiresAt <
+ * now`) can still run on values within the grace window. When
+ * `entry.expiresAt` is absent, the key is stored with no TTL — durable
+ * by default, matches the pg backend's `expires_at NULL` semantic.
+ *
+ * **`bulkGet` uses `MGET`.** Single round trip for any batch size,
+ * unlike the looped-`GET` fallback. Adopters using an escape-hatch
+ * `RedisLikeClient` adapter MUST implement `mGet` for batch shapes
+ * (`get_products` with N products, `create_media_buy` carrying a
+ * package list referencing products by ID).
+ *
+ * **`clearAll` intentionally omitted.** Same rationale as the
+ * idempotency Redis backend — a shared Redis is a production resource,
+ * and a compliance-reset `FLUSHDB` would nuke unrelated keys. Tests
+ * against a dedicated db index (`REDIS_URL=…/15`) call `FLUSHDB`
+ * themselves.
+ *
+ * @example
+ * ```typescript
+ * import { createClient } from 'redis';
+ * import { createCtxMetadataStore, redisCtxMetadataStore } from '@adcp/sdk/server';
+ *
+ * const client = createClient({ url: process.env.REDIS_URL });
+ * client.on('error', (err) => console.error('redis error', err));
+ * await client.connect();
+ *
+ * const ctxMetadata = createCtxMetadataStore({
+ *   backend: redisCtxMetadataStore(client),
+ * });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redisCtxMetadataStore = redisCtxMetadataStore;
+const redis_default_prefix_warn_1 = require("../../../utils/redis-default-prefix-warn");
+const DEFAULT_KEY_PREFIX = 'adcp:ctx_meta:';
+const DEFAULT_EXPIRED_GRACE_SECONDS = 60;
+/**
+ * Create a Redis-backed ctx-metadata cache.
+ *
+ * **Startup probe.** Call `store.probe()` before serving traffic to
+ * catch a bad `REDIS_URL` at boot rather than on the first
+ * ctx_metadata write.
+ *
+ * **Client error handling.** node-redis emits errors on the client
+ * itself for transient connection drops. Without a listener, Node's
+ * `EventEmitter` default-throws and crashes the process. Add one in
+ * your bootstrap:
+ *
+ * ```ts
+ * client.on('error', (err) => console.error('redis error', err));
+ * ```
+ *
+ * **Redis memory policy — set this on the deployment.** ctx_metadata
+ * entries default to durable (no TTL) when no `expiresAt` is provided,
+ * matching the pg sibling's `expires_at = NULL` semantic. Without a
+ * memory policy, an adopter who writes many durable entries can
+ * pressure Redis memory; once `maxmemory` is hit, default `noeviction`
+ * makes new writes fail. Choose deliberately:
+ *
+ * - **`maxmemory-policy allkeys-lru`** on a Redis db dedicated to AdCP
+ *   ctx_metadata — evicts the oldest entries to make room. Acceptable
+ *   for ctx_metadata because the next call referencing the same
+ *   resource will write a fresh entry; evicted entries are recoverable
+ *   as publisher traffic re-derives them, not lost permanently.
+ * - **`maxmemory-policy volatile-lru`** if you mostly use `expiresAt`
+ *   on entries — bounds growth to TTL'd keys only.
+ * - **`maxmemory-policy noeviction`** (Redis default) — fail-closed:
+ *   writes start erroring at the limit, mutating tools fail. Pages
+ *   you instead of silently evicting.
+ *
+ * For ctx_metadata specifically, evicting cached entries is safer than
+ * for the idempotency cache (which uses eviction as a feature) because
+ * publisher re-derivation refills the cache on the next reference.
+ * Note that this isn't synchronous "re-hydrate on miss" — the
+ * framework reads `null` for a missing entry and falls through to the
+ * publisher's adapter, which may or may not produce a fresh
+ * `ctx_metadata` value on that path. `allkeys-lru` is the recommended
+ * default on a dedicated db.
+ */
+function redisCtxMetadataStore(client, options = {}) {
+    // The function calls only the methods on CtxMetadataRedisLikeClient.
+    // The wider RedisClientType union covers the node-redis happy path
+    // without forcing a cast at the call site; internally we narrow.
+    const c = client;
+    const keyPrefix = options.keyPrefix ?? DEFAULT_KEY_PREFIX;
+    const expiredGraceSeconds = options.expiredGraceSeconds ?? DEFAULT_EXPIRED_GRACE_SECONDS;
+    if (!Number.isFinite(expiredGraceSeconds) || expiredGraceSeconds < 0) {
+        throw new Error(`redisCtxMetadataStore: expiredGraceSeconds must be a non-negative finite number. Got ${expiredGraceSeconds}.`);
+    }
+    (0, redis_default_prefix_warn_1.maybeWarnOnSharedRedisPrefix)({
+        client,
+        callerKeyPrefix: options.keyPrefix,
+        defaultKeyPrefix: DEFAULT_KEY_PREFIX,
+        suppress: options.suppressDefaultPrefixWarning,
+        backendName: 'redisCtxMetadataStore',
+    });
+    function prefixed(scopedKey) {
+        return `${keyPrefix}${scopedKey}`;
+    }
+    /**
+     * Compute the Redis TTL when `expiresAt` is set. Returns `undefined`
+     * when no TTL should be applied (entry is durable). Throws if the
+     * resulting TTL would be non-positive — a logic bug at the caller.
+     */
+    function ttlFor(expiresAt) {
+        if (expiresAt === undefined)
+            return undefined;
+        const nowSeconds = Math.floor(Date.now() / 1000);
+        const ttl = Math.floor(expiresAt - nowSeconds + expiredGraceSeconds);
+        if (ttl <= 0) {
+            throw new Error(`redisCtxMetadataStore: refusing to write an entry whose expiresAt (${expiresAt}) is already past — ` +
+                `the substrate-level TTL would be ${ttl}s. Caller logic error.`);
+        }
+        return ttl;
+    }
+    function parseEntry(raw, scopedKey) {
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (err) {
+            // The scoped key contains the account id — omit from the public
+            // message; attach the parse error as Error.cause so server logs
+            // retain the detail without leaking via response bodies.
+            void scopedKey;
+            throw new Error('redisCtxMetadataStore: corrupt cache entry — not valid JSON. See server logs for key + parse error.', {
+                cause: err,
+            });
+        }
+        const entry = { value: parsed.value };
+        if (parsed.resource !== undefined)
+            entry.resource = parsed.resource;
+        if (parsed.expiresAt !== undefined)
+            entry.expiresAt = parsed.expiresAt;
+        return entry;
+    }
+    return {
+        async probe() {
+            try {
+                await c.ping();
+            }
+            catch (err) {
+                throw new Error(`ctx_metadata backend probe failed: Redis is unreachable or misconfigured. ` +
+                    `Check REDIS_URL and that the instance is up. See server logs for the underlying cause.`, { cause: err });
+            }
+        },
+        async get(scopedKey) {
+            const raw = await c.get(prefixed(scopedKey));
+            if (raw === null)
+                return null;
+            return parseEntry(raw, scopedKey);
+        },
+        async bulkGet(scopedKeys) {
+            if (scopedKeys.length === 0)
+                return new Map();
+            const prefixedKeys = scopedKeys.map(k => prefixed(k));
+            const raws = await c.mGet(prefixedKeys);
+            const out = new Map();
+            for (let i = 0; i < scopedKeys.length; i++) {
+                const raw = raws[i];
+                if (raw === null || raw === undefined)
+                    continue;
+                const scopedKey = scopedKeys[i];
+                if (scopedKey === undefined)
+                    continue;
+                out.set(scopedKey, parseEntry(raw, scopedKey));
+            }
+            return out;
+        },
+        async put(scopedKey, entry) {
+            const serialized = { value: entry.value };
+            if (entry.resource !== undefined)
+                serialized.resource = entry.resource;
+            if (entry.expiresAt !== undefined)
+                serialized.expiresAt = entry.expiresAt;
+            const ttl = ttlFor(entry.expiresAt);
+            const body = JSON.stringify(serialized);
+            if (ttl !== undefined) {
+                await c.set(prefixed(scopedKey), body, { EX: ttl });
+            }
+            else {
+                // No TTL: durable entry. Pass undefined / empty options so the
+                // call site is symmetric with the pg backend's `expires_at = NULL`.
+                await c.set(prefixed(scopedKey), body);
+            }
+        },
+        async delete(scopedKey) {
+            await c.del(prefixed(scopedKey));
+        },
+    };
+}
+//# sourceMappingURL=redis.js.map

package/dist/lib/server/ctx-metadata/backends/redis.js.map

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

package/dist/lib/server/ctx-metadata/index.d.ts

@@ -10,6 +10,8 @@ export { memoryCtxMetadataStore } from './backends/memory';
 export type { MemoryCtxMetadataStoreOptions } from './backends/memory';
 export { pgCtxMetadataStore, getCtxMetadataMigration, cleanupExpiredCtxMetadata, CTX_METADATA_MIGRATION, } from './backends/pg';
 export type { PgCtxMetadataBackendOptions } from './backends/pg';
+export { redisCtxMetadataStore } from './backends/redis';
+export type { RedisCtxMetadataBackendOptions, CtxMetadataRedisBackendClient, CtxMetadataRedisLikeClient, } from './backends/redis';
 export { stripCtxMetadata, hasCtxMetadata, stripImplementationConfig, hasImplementationConfig } from './wire-shape';
 export type { WireShape } from './wire-shape';
 //# sourceMappingURL=index.d.ts.map

package/dist/lib/server/ctx-metadata/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/server/ctx-metadata/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,0BAA0B,EAC1B,iBAAiB,EACjB,uBAAuB,EACvB,eAAe,GAChB,MAAM,SAAS,CAAC;AAEjB,YAAY,EACV,gBAAgB,EAChB,sBAAsB,EACtB,kBAAkB,EAClB,gBAAgB,EAChB,cAAc,EACd,YAAY,GACb,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,YAAY,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAEvE,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,yBAAyB,EACzB,sBAAsB,GACvB,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAEjE,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,yBAAyB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AACpH,YAAY,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/server/ctx-metadata/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,0BAA0B,EAC1B,iBAAiB,EACjB,uBAAuB,EACvB,eAAe,GAChB,MAAM,SAAS,CAAC;AAEjB,YAAY,EACV,gBAAgB,EAChB,sBAAsB,EACtB,kBAAkB,EAClB,gBAAgB,EAChB,cAAc,EACd,YAAY,GACb,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,YAAY,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAEvE,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,yBAAyB,EACzB,sBAAsB,GACvB,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAEjE,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACzD,YAAY,EACV,8BAA8B,EAC9B,6BAA6B,EAC7B,0BAA0B,GAC3B,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,yBAAyB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AACpH,YAAY,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC"}

package/dist/lib/server/ctx-metadata/index.js

@@ -6,7 +6,7 @@
  * @public
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasImplementationConfig = exports.stripImplementationConfig = exports.hasCtxMetadata = exports.stripCtxMetadata = exports.CTX_METADATA_MIGRATION = exports.cleanupExpiredCtxMetadata = exports.getCtxMetadataMigration = exports.pgCtxMetadataStore = exports.memoryCtxMetadataStore = exports.MAX_TTL_SECONDS = exports.DEFAULT_MAX_VALUE_BYTES = exports.ADCP_INTERNAL_TAG = exports.CtxMetadataValidationError = exports.scopeCtxMetadataKey = exports.ctxMetadataResultKey = exports.createCtxMetadataStore = void 0;
+exports.hasImplementationConfig = exports.stripImplementationConfig = exports.hasCtxMetadata = exports.stripCtxMetadata = exports.redisCtxMetadataStore = exports.CTX_METADATA_MIGRATION = exports.cleanupExpiredCtxMetadata = exports.getCtxMetadataMigration = exports.pgCtxMetadataStore = exports.memoryCtxMetadataStore = exports.MAX_TTL_SECONDS = exports.DEFAULT_MAX_VALUE_BYTES = exports.ADCP_INTERNAL_TAG = exports.CtxMetadataValidationError = exports.scopeCtxMetadataKey = exports.ctxMetadataResultKey = exports.createCtxMetadataStore = void 0;
 var store_1 = require("./store");
 Object.defineProperty(exports, "createCtxMetadataStore", { enumerable: true, get: function () { return store_1.createCtxMetadataStore; } });
 Object.defineProperty(exports, "ctxMetadataResultKey", { enumerable: true, get: function () { return store_1.ctxMetadataResultKey; } });
@@ -22,6 +22,8 @@ Object.defineProperty(exports, "pgCtxMetadataStore", { enumerable: true, get: fu
 Object.defineProperty(exports, "getCtxMetadataMigration", { enumerable: true, get: function () { return pg_1.getCtxMetadataMigration; } });
 Object.defineProperty(exports, "cleanupExpiredCtxMetadata", { enumerable: true, get: function () { return pg_1.cleanupExpiredCtxMetadata; } });
 Object.defineProperty(exports, "CTX_METADATA_MIGRATION", { enumerable: true, get: function () { return pg_1.CTX_METADATA_MIGRATION; } });
+var redis_1 = require("./backends/redis");
+Object.defineProperty(exports, "redisCtxMetadataStore", { enumerable: true, get: function () { return redis_1.redisCtxMetadataStore; } });
 var wire_shape_1 = require("./wire-shape");
 Object.defineProperty(exports, "stripCtxMetadata", { enumerable: true, get: function () { return wire_shape_1.stripCtxMetadata; } });
 Object.defineProperty(exports, "hasCtxMetadata", { enumerable: true, get: function () { return wire_shape_1.hasCtxMetadata; } });

package/dist/lib/server/ctx-metadata/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/lib/server/ctx-metadata/index.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAEH,iCAQiB;AAPf,+GAAA,sBAAsB,OAAA;AACtB,6GAAA,oBAAoB,OAAA;AACpB,4GAAA,mBAAmB,OAAA;AACnB,mHAAA,0BAA0B,OAAA;AAC1B,0GAAA,iBAAiB,OAAA;AACjB,gHAAA,uBAAuB,OAAA;AACvB,wGAAA,eAAe,OAAA;AAYjB,4CAA2D;AAAlD,gHAAA,sBAAsB,OAAA;AAG/B,oCAKuB;AAJrB,wGAAA,kBAAkB,OAAA;AAClB,6GAAA,uBAAuB,OAAA;AACvB,+GAAA,yBAAyB,OAAA;AACzB,4GAAA,sBAAsB,OAAA;AAIxB,2CAAoH;AAA3G,8GAAA,gBAAgB,OAAA;AAAE,4GAAA,cAAc,OAAA;AAAE,uHAAA,yBAAyB,OAAA;AAAE,qHAAA,uBAAuB,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/lib/server/ctx-metadata/index.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAEH,iCAQiB;AAPf,+GAAA,sBAAsB,OAAA;AACtB,6GAAA,oBAAoB,OAAA;AACpB,4GAAA,mBAAmB,OAAA;AACnB,mHAAA,0BAA0B,OAAA;AAC1B,0GAAA,iBAAiB,OAAA;AACjB,gHAAA,uBAAuB,OAAA;AACvB,wGAAA,eAAe,OAAA;AAYjB,4CAA2D;AAAlD,gHAAA,sBAAsB,OAAA;AAG/B,oCAKuB;AAJrB,wGAAA,kBAAkB,OAAA;AAClB,6GAAA,uBAAuB,OAAA;AACvB,+GAAA,yBAAyB,OAAA;AACzB,4GAAA,sBAAsB,OAAA;AAIxB,0CAAyD;AAAhD,8GAAA,qBAAqB,OAAA;AAO9B,2CAAoH;AAA3G,8GAAA,gBAAgB,OAAA;AAAE,4GAAA,cAAc,OAAA;AAAE,uHAAA,yBAAyB,OAAA;AAAE,qHAAA,uBAAuB,OAAA"}

package/dist/lib/server/idempotency/backends/redis.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Redis backend for the idempotency store.
+ *
+ * Stores one key per `(principal, key, [extraScope])` carrying the JSON
+ * payload `{ payloadHash, response, expiresAt }`. Expiry is enforced by
+ * Redis itself via the key TTL — no sweeper job required.
+ *
+ * **Reclaim semantics.** The `putIfAbsent` claim maps to `SET … NX EX`:
+ * because Redis auto-deletes expired keys, a crashed in-flight claim is
+ * naturally reclaimable on retry without the explicit `WHERE expires_at <
+ * NOW()` dance the Postgres backend needs.
+ *
+ * **`expired` vs `miss` parity.** The store layer distinguishes `expired`
+ * (cached key past TTL within clock-skew window) from `miss` (no cached
+ * key) — that affects whether the buyer sees `IDEMPOTENCY_EXPIRED` or a
+ * fresh execution. Postgres rows linger past `expires_at` until cleanup;
+ * Redis would evict them at the second they expire, collapsing `expired`
+ * into `miss`. We hold the key alive for an extra `expiredGraceSeconds`
+ * (defaults to 120s — covers the store's default 60s clock skew plus a
+ * margin) so the store layer can read `expiresAt` from the value and
+ * return `expired` correctly within the skew window.
+ *
+ * **`clearAll` intentionally omitted.** A shared Redis instance is a
+ * production resource — accidentally calling `FLUSHDB` from a compliance
+ * reset hook would nuke unrelated keys. Test setups that want a clean
+ * slate should run against a dedicated Redis db (`REDIS_URL=…/15`) and
+ * call `FLUSHDB` themselves.
+ *
+ * @example
+ * ```typescript
+ * import { createClient } from 'redis';
+ * import { createIdempotencyStore, redisBackend } from '@adcp/sdk/server';
+ *
+ * const client = createClient({ url: process.env.REDIS_URL });
+ * client.on('error', (err) => console.error('redis error', err));
+ * await client.connect();
+ *
+ * const store = createIdempotencyStore({
+ *   backend: redisBackend(client),
+ *   ttlSeconds: 86400,
+ * });
+ * ```
+ */
+import type { IdempotencyBackend } from '../store';
+import type { RedisClientType } from 'redis';
+/**
+ * Escape-hatch interface for adopters not using the official `redis`
+ * client (node-redis v4/v5) — e.g., `ioredis`, Upstash, a test double.
+ *
+ * Mirrors the four methods this backend actually calls. The `set`
+ * signature follows node-redis's options-object form; `ioredis` users
+ * pass a thin shim that maps to its positional API.
+ *
+ * @example ioredis adapter
+ * ```typescript
+ * import Redis from 'ioredis';
+ * const ioredis = new Redis(process.env.REDIS_URL!);
+ *
+ * const client: RedisLikeClient = {
+ *   get: (k) => ioredis.get(k),
+ *   set: (k, v, { EX, NX }) =>
+ *     NX
+ *       ? ioredis.set(k, v, 'EX', EX, 'NX').then(r => (r === 'OK' ? 'OK' : null))
+ *       : ioredis.set(k, v, 'EX', EX),
+ *   del: (k) => ioredis.del(k as string),
+ *   ping: () => ioredis.ping(),
+ * };
+ * ```
+ */
+export interface RedisLikeClient {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, options: {
+        EX: number;
+        NX?: boolean;
+    }): Promise<string | null>;
+    del(key: string | string[]): Promise<number>;
+    ping(): Promise<string>;
+}
+/**
+ * Accepted client shape: either a real `redis` (node-redis v4/v5)
+ * `RedisClientType` (the typical path — pass `createClient(...)` straight
+ * in) or an adapter that conforms to `RedisLikeClient` (for `ioredis`,
+ * Upstash, or test doubles). The union avoids forcing node-redis users
+ * to write `as unknown as RedisLikeClient` casts on the documented path.
+ */
+export type RedisBackendClient = RedisClientType<any, any, any> | RedisLikeClient;
+export interface RedisBackendOptions {
+    /**
+     * Key prefix prepended to every scoped key written to Redis. Defaults
+     * to `"adcp:idem:"`.
+     *
+     * **Sharing a Redis db across deployments? Override this.** The default
+     * is fine for a dedicated Redis (or a dedicated db index) and for
+     * coexisting with non-AdCP applications. But two AdCP servers sharing
+     * the *same* db with the *same* default prefix will collide on any
+     * overlapping principal namespace (e.g., both deployments having a
+     * tenant called `acme`) — the principal segment is per-tenant, not
+     * per-deployment, so it's the wrong layer to do deployment isolation.
+     * Set a deployment-unique prefix (`"adcp:idem:prod-eu:"`, etc.) or use
+     * separate Redis dbs.
+     */
+    keyPrefix?: string;
+    /**
+     * Suppress the one-time `console.warn` emitted at construction when the
+     * default `keyPrefix` is used against a node-redis client that appears
+     * to be on db 0 (the most likely signal of a shared, non-dedicated
+     * Redis). Set to `true` if you know your Redis is dedicated to this
+     * AdCP deployment and don't want the warning noise. The recommended
+     * fix is to set `keyPrefix` explicitly, not to suppress.
+     */
+    suppressDefaultPrefixWarning?: boolean;
+    /**
+     * How many seconds past `expiresAt` to keep the key alive in Redis, so
+     * the store layer can still read it during the clock-skew window and
+     * return `IDEMPOTENCY_EXPIRED` (rather than treating it as a fresh
+     * miss). Defaults to 120s — covers the store's default 60s skew with
+     * margin. Set to 0 to collapse `expired` into `miss` (not recommended
+     * — buyers lose the explicit expired signal).
+     */
+    expiredGraceSeconds?: number;
+}
+/**
+ * Test-only escape hatch to reset the once-warn flag between test runs.
+ * Not exported through any index — adopters can't reach it from outside
+ * this file.
+ */
+export declare function __resetDefaultPrefixWarningForTests(): void;
+/**
+ * Create a Redis-backed idempotency cache.
+ *
+ * **Startup probe.** Call `store.probe()` (or `probeIdempotencyStore(store)`)
+ * before serving traffic to catch a bad `REDIS_URL` or unreachable
+ * instance at boot rather than on the first mutating request. Wire it via:
+ *
+ * ```ts
+ * serve(createAgent, { readinessCheck: () => store.probe() });
+ * ```
+ *
+ * **Client error handling.** node-redis emits errors on the client itself
+ * for transient connection drops. Without a listener, Node's
+ * `EventEmitter` default-throws and crashes the process. Add one in your
+ * bootstrap:
+ *
+ * ```ts
+ * client.on('error', (err) => console.error('redis error', err));
+ * ```
+ *
+ * **Redis memory policy — set this on the deployment.** A buyer with a
+ * valid principal can mint unbounded distinct `idempotency_key` values
+ * and hit any mutating tool; each write adds a key to Redis with the
+ * configured `ttlSeconds` (default 24h). A sufficient rate can pressure
+ * Redis memory before TTLs evict naturally. Configure your Redis with:
+ *
+ * - **`maxmemory-policy volatile-lru`** (recommended) — evicts only
+ *   TTL'd keys, containing blast radius to AdCP's keyspace if the
+ *   instance is shared with other apps. All keys this backend writes
+ *   carry TTL, so this is safe.
+ * - **`maxmemory-policy allkeys-lru`** — only on a Redis db dedicated
+ *   to AdCP. Will evict your other keys if shared.
+ * - **`maxmemory-policy noeviction`** (Redis default) — fail-closed:
+ *   the backend's writes will start erroring once memory fills, and
+ *   mutating requests will fail. Operationally noisy but never serves
+ *   stale data; choose this only if you'd rather page than evict.
+ *
+ * Pair with alerting on a per-principal `VALIDATION_ERROR` rate — a
+ * drifted handler hit by a retrying buyer writes 10s-TTL entries on
+ * every fresh key, amplifying the rate of cache fill. Steady-state
+ * `VALIDATION_ERROR` should be zero.
+ */
+export declare function redisBackend(client: RedisBackendClient, options?: RedisBackendOptions): IdempotencyBackend;
+//# sourceMappingURL=redis.d.ts.map

package/dist/lib/server/idempotency/backends/redis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../../../../src/lib/server/idempotency/backends/redis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAyB,MAAM,UAAU,CAAC;AAK1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,OAAO,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,WAAW,eAAe;IAC9B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACzC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,EAAE,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC/F,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7C,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CACzB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAAG,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,GAAG,eAAe,CAAC;AAElF,MAAM,WAAW,mBAAmB;IAClC;;;;;;;;;;;;;OAaG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;;OAOG;IACH,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC;;;;;;;OAOG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAkDD;;;;GAIG;AACH,wBAAgB,mCAAmC,IAAI,IAAI,CAE1D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,kBAAkB,EAAE,OAAO,GAAE,mBAAwB,GAAG,kBAAkB,CA+H9G"}