@vivero/stoma 0.1.0-rc.10

package/dist/adapters/postgres.js

@@ -0,0 +1,242 @@
+const POSTGRES_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS stoma_rate_limits (
+  key TEXT PRIMARY KEY,
+  count INTEGER NOT NULL DEFAULT 0,
+  reset_at BIGINT NOT NULL DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_stoma_rate_limits_reset_at ON stoma_rate_limits (reset_at);
+
+CREATE TABLE IF NOT EXISTS stoma_circuit_breakers (
+  key TEXT PRIMARY KEY,
+  state TEXT NOT NULL DEFAULT 'closed',
+  failure_count INTEGER NOT NULL DEFAULT 0,
+  success_count INTEGER NOT NULL DEFAULT 0,
+  last_failure_time BIGINT NOT NULL DEFAULT 0,
+  last_state_change BIGINT NOT NULL DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS stoma_cache (
+  key TEXT PRIMARY KEY,
+  status INTEGER NOT NULL,
+  headers JSONB NOT NULL DEFAULT '[]',
+  body TEXT NOT NULL DEFAULT '',
+  expires_at BIGINT NOT NULL DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_stoma_cache_expires_at ON stoma_cache (expires_at);
+`;
+const NULL_BODY_STATUSES = /* @__PURE__ */ new Set([204, 304]);
+function safeBody(body, status) {
+  return NULL_BODY_STATUSES.has(status) ? null : body ?? null;
+}
+function uint8ToBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function base64ToUint8(b64) {
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+class PostgresRateLimitStore {
+  constructor(client, table) {
+    this.client = client;
+    this.table = table;
+  }
+  async increment(key, windowSeconds) {
+    const now = Date.now();
+    const resetAt = now + windowSeconds * 1e3;
+    const result = await this.client.query(
+      `INSERT INTO ${this.table} (key, count, reset_at)
+       VALUES ($1, 1, $2)
+       ON CONFLICT (key) DO UPDATE SET
+         count = CASE
+           WHEN ${this.table}.reset_at <= $3 THEN 1
+           ELSE ${this.table}.count + 1
+         END,
+         reset_at = CASE
+           WHEN ${this.table}.reset_at <= $3 THEN $2
+           ELSE ${this.table}.reset_at
+         END
+       RETURNING count, reset_at`,
+      [key, resetAt, now]
+    );
+    const row = result.rows[0];
+    return {
+      count: Number(row.count),
+      resetAt: Number(row.reset_at)
+    };
+  }
+  /** Remove expired entries. Call periodically (e.g. via cron or waitUntil). */
+  async cleanup() {
+    await this.client.query(`DELETE FROM ${this.table} WHERE reset_at <= $1`, [
+      Date.now()
+    ]);
+  }
+}
+function rowToSnapshot(row) {
+  return {
+    state: row.state ?? "closed",
+    failureCount: Number(row.failure_count ?? 0),
+    successCount: Number(row.success_count ?? 0),
+    lastFailureTime: Number(row.last_failure_time ?? 0),
+    lastStateChange: Number(row.last_state_change ?? Date.now())
+  };
+}
+function defaultSnapshot() {
+  return {
+    state: "closed",
+    failureCount: 0,
+    successCount: 0,
+    lastFailureTime: 0,
+    lastStateChange: Date.now()
+  };
+}
+class PostgresCircuitBreakerStore {
+  constructor(client, table) {
+    this.client = client;
+    this.table = table;
+  }
+  async getState(key) {
+    const result = await this.client.query(
+      `SELECT state, failure_count, success_count, last_failure_time, last_state_change
+       FROM ${this.table} WHERE key = $1`,
+      [key]
+    );
+    if (result.rows.length === 0) return defaultSnapshot();
+    return rowToSnapshot(result.rows[0]);
+  }
+  async recordSuccess(key) {
+    const now = Date.now();
+    const result = await this.client.query(
+      `INSERT INTO ${this.table} (key, state, failure_count, success_count, last_failure_time, last_state_change)
+       VALUES ($1, 'closed', 0, 1, 0, $2)
+       ON CONFLICT (key) DO UPDATE SET
+         success_count = ${this.table}.success_count + 1
+       RETURNING state, failure_count, success_count, last_failure_time, last_state_change`,
+      [key, now]
+    );
+    return rowToSnapshot(result.rows[0]);
+  }
+  async recordFailure(key) {
+    const now = Date.now();
+    const result = await this.client.query(
+      `INSERT INTO ${this.table} (key, state, failure_count, success_count, last_failure_time, last_state_change)
+       VALUES ($1, 'closed', 1, 0, $2, $2)
+       ON CONFLICT (key) DO UPDATE SET
+         failure_count = ${this.table}.failure_count + 1,
+         last_failure_time = $2
+       RETURNING state, failure_count, success_count, last_failure_time, last_state_change`,
+      [key, now]
+    );
+    return rowToSnapshot(result.rows[0]);
+  }
+  async transition(key, to) {
+    const now = Date.now();
+    let failureCount = "failure_count";
+    let successCount = "success_count";
+    if (to === "closed") {
+      failureCount = "0";
+      successCount = "0";
+    } else if (to === "half-open") {
+      successCount = "0";
+    }
+    const result = await this.client.query(
+      `INSERT INTO ${this.table} (key, state, failure_count, success_count, last_failure_time, last_state_change)
+       VALUES ($1, $2, 0, 0, 0, $3)
+       ON CONFLICT (key) DO UPDATE SET
+         state = $2,
+         failure_count = ${failureCount},
+         success_count = ${successCount},
+         last_state_change = $3
+       RETURNING state, failure_count, success_count, last_failure_time, last_state_change`,
+      [key, to, now]
+    );
+    return rowToSnapshot(result.rows[0]);
+  }
+  async reset(key) {
+    await this.client.query(`DELETE FROM ${this.table} WHERE key = $1`, [key]);
+  }
+}
+class PostgresCacheStore {
+  constructor(client, table) {
+    this.client = client;
+    this.table = table;
+  }
+  async get(key) {
+    const now = Date.now();
+    const result = await this.client.query(
+      `SELECT status, headers, body FROM ${this.table}
+       WHERE key = $1 AND expires_at > $2`,
+      [key, now]
+    );
+    if (result.rows.length === 0) return null;
+    const row = result.rows[0];
+    const status = Number(row.status);
+    const rawHeaders = row.headers;
+    const headers = typeof rawHeaders === "string" ? JSON.parse(rawHeaders) : rawHeaders;
+    const body = base64ToUint8(row.body);
+    return new Response(safeBody(body, status), { status, headers });
+  }
+  async put(key, response, ttlSeconds) {
+    const body = new Uint8Array(await response.arrayBuffer());
+    const headers = [];
+    response.headers.forEach((value, name) => {
+      headers.push([name, value]);
+    });
+    const expiresAt = Date.now() + ttlSeconds * 1e3;
+    await this.client.query(
+      `INSERT INTO ${this.table} (key, status, headers, body, expires_at)
+       VALUES ($1, $2, $3, $4, $5)
+       ON CONFLICT (key) DO UPDATE SET
+         status = $2, headers = $3, body = $4, expires_at = $5`,
+      [
+        key,
+        response.status,
+        JSON.stringify(headers),
+        uint8ToBase64(body),
+        expiresAt
+      ]
+    );
+  }
+  async delete(key) {
+    const result = await this.client.query(
+      `DELETE FROM ${this.table} WHERE key = $1 RETURNING key`,
+      [key]
+    );
+    return result.rows.length > 0;
+  }
+  /** Remove expired entries. Call periodically (e.g. via cron or waitUntil). */
+  async cleanup() {
+    await this.client.query(
+      `DELETE FROM ${this.table} WHERE expires_at <= $1`,
+      [Date.now()]
+    );
+  }
+}
+function postgresAdapter(config) {
+  const prefix = config.tablePrefix ?? "stoma_";
+  const stores = config.stores ?? {};
+  return {
+    rateLimitStore: stores.rateLimit !== false ? new PostgresRateLimitStore(config.client, `${prefix}rate_limits`) : void 0,
+    circuitBreakerStore: stores.circuitBreaker !== false ? new PostgresCircuitBreakerStore(
+      config.client,
+      `${prefix}circuit_breakers`
+    ) : void 0,
+    cacheStore: stores.cache !== false ? new PostgresCacheStore(config.client, `${prefix}cache`) : void 0,
+    waitUntil: config.waitUntil
+  };
+}
+export {
+  POSTGRES_SCHEMA_SQL,
+  PostgresCacheStore,
+  PostgresCircuitBreakerStore,
+  PostgresRateLimitStore,
+  postgresAdapter
+};
+//# sourceMappingURL=postgres.js.map

package/dist/adapters/postgres.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/postgres.ts"],"sourcesContent":["/**\n * PostgreSQL-backed adapter for stoma - production-ready stores for Node.js, Bun, and Deno.\n *\n * Zero dependencies: define a minimal {@link PostgresClient} interface that any Postgres\n * library (pg, postgres.js, etc.) satisfies, then pass it to {@link postgresAdapter}.\n *\n * @module adapters/postgres\n */\nimport type {\n  CircuitBreakerSnapshot,\n  CircuitBreakerStore,\n  CircuitState,\n} from \"../policies/resilience/circuit-breaker\";\nimport type { CacheStore } from \"../policies/traffic/cache\";\nimport type { RateLimitStore } from \"../policies/traffic/rate-limit\";\nimport type { GatewayAdapter } from \"./types\";\n\n// ---------------------------------------------------------------------------\n// Client interface\n// ---------------------------------------------------------------------------\n\n/**\n * Minimal PostgreSQL client interface - satisfied by `pg`, `postgres.js`, and most\n * Postgres libraries. Only a single `query` method is required.\n */\nexport interface PostgresClient {\n  query(\n    text: string,\n    params?: unknown[]\n  ): Promise<{ rows: Record<string, unknown>[] }>;\n}\n\n// ---------------------------------------------------------------------------\n// Config\n// ---------------------------------------------------------------------------\n\nexport interface PostgresAdapterConfig {\n  /** PostgreSQL client instance (pg Pool, postgres.js, etc.). */\n  client: PostgresClient;\n  /** Table name prefix. Default: `\"stoma_\"`. */\n  tablePrefix?: string;\n  /** Selectively enable/disable individual stores. All enabled by default. */\n  stores?: {\n    rateLimit?: boolean;\n    circuitBreaker?: boolean;\n    cache?: boolean;\n  };\n  /** Schedule background work that outlives the response. */\n  waitUntil?: (promise: Promise<unknown>) => void;\n}\n\n// ---------------------------------------------------------------------------\n// Schema SQL\n// ---------------------------------------------------------------------------\n\n/**\n * SQL to create the three stoma tables. Run this once against your database\n * before using the Postgres adapter. All statements use `IF NOT EXISTS` so\n * they're safe to re-run.\n *\n * @example\n * ```ts\n * import { POSTGRES_SCHEMA_SQL } from \"@vivero/stoma/adapters/postgres\";\n * await pool.query(POSTGRES_SCHEMA_SQL);\n * ```\n */\nexport const POSTGRES_SCHEMA_SQL = `\nCREATE TABLE IF NOT EXISTS stoma_rate_limits (\n  key TEXT PRIMARY KEY,\n  count INTEGER NOT NULL DEFAULT 0,\n  reset_at BIGINT NOT NULL DEFAULT 0\n);\nCREATE INDEX IF NOT EXISTS idx_stoma_rate_limits_reset_at ON stoma_rate_limits (reset_at);\n\nCREATE TABLE IF NOT EXISTS stoma_circuit_breakers (\n  key TEXT PRIMARY KEY,\n  state TEXT NOT NULL DEFAULT 'closed',\n  failure_count INTEGER NOT NULL DEFAULT 0,\n  success_count INTEGER NOT NULL DEFAULT 0,\n  last_failure_time BIGINT NOT NULL DEFAULT 0,\n  last_state_change BIGINT NOT NULL DEFAULT 0\n);\n\nCREATE TABLE IF NOT EXISTS stoma_cache (\n  key TEXT PRIMARY KEY,\n  status INTEGER NOT NULL,\n  headers JSONB NOT NULL DEFAULT '[]',\n  body TEXT NOT NULL DEFAULT '',\n  expires_at BIGINT NOT NULL DEFAULT 0\n);\nCREATE INDEX IF NOT EXISTS idx_stoma_cache_expires_at ON stoma_cache (expires_at);\n`;\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\n\n// Per HTTP spec, 204 and 304 responses must not carry a body.\nconst NULL_BODY_STATUSES = new Set([204, 304]);\nfunction safeBody(\n  body: BodyInit | null | undefined,\n  status: number\n): BodyInit | null {\n  return NULL_BODY_STATUSES.has(status) ? null : (body ?? null);\n}\n\n/** Encode a Uint8Array to base64 string (no Node Buffer dependency). */\nfunction uint8ToBase64(bytes: Uint8Array): string {\n  let binary = \"\";\n  for (let i = 0; i < bytes.length; i++) {\n    binary += String.fromCharCode(bytes[i]);\n  }\n  return btoa(binary);\n}\n\n/** Decode a base64 string to Uint8Array (no Node Buffer dependency). */\nfunction base64ToUint8(b64: string): Uint8Array {\n  const binary = atob(b64);\n  const bytes = new Uint8Array(binary.length);\n  for (let i = 0; i < binary.length; i++) {\n    bytes[i] = binary.charCodeAt(i);\n  }\n  return bytes;\n}\n\n// ---------------------------------------------------------------------------\n// Rate Limit Store\n// ---------------------------------------------------------------------------\n\n/**\n * Rate limit store backed by PostgreSQL using atomic upsert.\n *\n * Uses `INSERT ... ON CONFLICT DO UPDATE` with a `CASE` expression to\n * atomically reset or increment the counter in a single query.\n */\nexport class PostgresRateLimitStore implements RateLimitStore {\n  constructor(\n    private client: PostgresClient,\n    private table: string\n  ) {}\n\n  async increment(\n    key: string,\n    windowSeconds: number\n  ): Promise<{ count: number; resetAt: number }> {\n    const now = Date.now();\n    const resetAt = now + windowSeconds * 1000;\n\n    // Atomic upsert: insert new row or update existing.\n    // If the existing row has expired (reset_at <= now), reset counter to 1.\n    // Otherwise, increment the existing counter.\n    const result = await this.client.query(\n      `INSERT INTO ${this.table} (key, count, reset_at)\n       VALUES ($1, 1, $2)\n       ON CONFLICT (key) DO UPDATE SET\n         count = CASE\n           WHEN ${this.table}.reset_at <= $3 THEN 1\n           ELSE ${this.table}.count + 1\n         END,\n         reset_at = CASE\n           WHEN ${this.table}.reset_at <= $3 THEN $2\n           ELSE ${this.table}.reset_at\n         END\n       RETURNING count, reset_at`,\n      [key, resetAt, now]\n    );\n\n    const row = result.rows[0];\n    return {\n      count: Number(row.count),\n      resetAt: Number(row.reset_at),\n    };\n  }\n\n  /** Remove expired entries. Call periodically (e.g. via cron or waitUntil). */\n  async cleanup(): Promise<void> {\n    await this.client.query(`DELETE FROM ${this.table} WHERE reset_at <= $1`, [\n      Date.now(),\n    ]);\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Circuit Breaker Store\n// ---------------------------------------------------------------------------\n\nfunction rowToSnapshot(row: Record<string, unknown>): CircuitBreakerSnapshot {\n  return {\n    state: (row.state as CircuitState) ?? \"closed\",\n    failureCount: Number(row.failure_count ?? 0),\n    successCount: Number(row.success_count ?? 0),\n    lastFailureTime: Number(row.last_failure_time ?? 0),\n    lastStateChange: Number(row.last_state_change ?? Date.now()),\n  };\n}\n\nfunction defaultSnapshot(): CircuitBreakerSnapshot {\n  return {\n    state: \"closed\",\n    failureCount: 0,\n    successCount: 0,\n    lastFailureTime: 0,\n    lastStateChange: Date.now(),\n  };\n}\n\n/** Circuit breaker state store backed by PostgreSQL. */\nexport class PostgresCircuitBreakerStore implements CircuitBreakerStore {\n  constructor(\n    private client: PostgresClient,\n    private table: string\n  ) {}\n\n  async getState(key: string): Promise<CircuitBreakerSnapshot> {\n    const result = await this.client.query(\n      `SELECT state, failure_count, success_count, last_failure_time, last_state_change\n       FROM ${this.table} WHERE key = $1`,\n      [key]\n    );\n    if (result.rows.length === 0) return defaultSnapshot();\n    return rowToSnapshot(result.rows[0]);\n  }\n\n  async recordSuccess(key: string): Promise<CircuitBreakerSnapshot> {\n    const now = Date.now();\n    const result = await this.client.query(\n      `INSERT INTO ${this.table} (key, state, failure_count, success_count, last_failure_time, last_state_change)\n       VALUES ($1, 'closed', 0, 1, 0, $2)\n       ON CONFLICT (key) DO UPDATE SET\n         success_count = ${this.table}.success_count + 1\n       RETURNING state, failure_count, success_count, last_failure_time, last_state_change`,\n      [key, now]\n    );\n    return rowToSnapshot(result.rows[0]);\n  }\n\n  async recordFailure(key: string): Promise<CircuitBreakerSnapshot> {\n    const now = Date.now();\n    const result = await this.client.query(\n      `INSERT INTO ${this.table} (key, state, failure_count, success_count, last_failure_time, last_state_change)\n       VALUES ($1, 'closed', 1, 0, $2, $2)\n       ON CONFLICT (key) DO UPDATE SET\n         failure_count = ${this.table}.failure_count + 1,\n         last_failure_time = $2\n       RETURNING state, failure_count, success_count, last_failure_time, last_state_change`,\n      [key, now]\n    );\n    return rowToSnapshot(result.rows[0]);\n  }\n\n  async transition(\n    key: string,\n    to: CircuitState\n  ): Promise<CircuitBreakerSnapshot> {\n    const now = Date.now();\n\n    // Reset counters on state transitions matching in-memory behavior\n    let failureCount = \"failure_count\";\n    let successCount = \"success_count\";\n    if (to === \"closed\") {\n      failureCount = \"0\";\n      successCount = \"0\";\n    } else if (to === \"half-open\") {\n      successCount = \"0\";\n    }\n\n    const result = await this.client.query(\n      `INSERT INTO ${this.table} (key, state, failure_count, success_count, last_failure_time, last_state_change)\n       VALUES ($1, $2, 0, 0, 0, $3)\n       ON CONFLICT (key) DO UPDATE SET\n         state = $2,\n         failure_count = ${failureCount},\n         success_count = ${successCount},\n         last_state_change = $3\n       RETURNING state, failure_count, success_count, last_failure_time, last_state_change`,\n      [key, to, now]\n    );\n    return rowToSnapshot(result.rows[0]);\n  }\n\n  async reset(key: string): Promise<void> {\n    await this.client.query(`DELETE FROM ${this.table} WHERE key = $1`, [key]);\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Cache Store\n// ---------------------------------------------------------------------------\n\n/** Response cache backed by PostgreSQL with base64-encoded body and expiry timestamp. */\nexport class PostgresCacheStore implements CacheStore {\n  constructor(\n    private client: PostgresClient,\n    private table: string\n  ) {}\n\n  async get(key: string): Promise<Response | null> {\n    const now = Date.now();\n    const result = await this.client.query(\n      `SELECT status, headers, body FROM ${this.table}\n       WHERE key = $1 AND expires_at > $2`,\n      [key, now]\n    );\n\n    if (result.rows.length === 0) return null;\n\n    const row = result.rows[0];\n    const status = Number(row.status);\n    // JSONB columns are auto-parsed by most Postgres drivers (pg, postgres.js),\n    // but some may return a string. Handle both cases.\n    const rawHeaders = row.headers;\n    const headers: [string, string][] =\n      typeof rawHeaders === \"string\"\n        ? JSON.parse(rawHeaders)\n        : (rawHeaders as [string, string][]);\n    const body = base64ToUint8(row.body as string);\n\n    return new Response(safeBody(body, status), { status, headers });\n  }\n\n  async put(\n    key: string,\n    response: Response,\n    ttlSeconds: number\n  ): Promise<void> {\n    const body = new Uint8Array(await response.arrayBuffer());\n    const headers: [string, string][] = [];\n    response.headers.forEach((value, name) => {\n      headers.push([name, value]);\n    });\n    const expiresAt = Date.now() + ttlSeconds * 1000;\n\n    await this.client.query(\n      `INSERT INTO ${this.table} (key, status, headers, body, expires_at)\n       VALUES ($1, $2, $3, $4, $5)\n       ON CONFLICT (key) DO UPDATE SET\n         status = $2, headers = $3, body = $4, expires_at = $5`,\n      [\n        key,\n        response.status,\n        JSON.stringify(headers),\n        uint8ToBase64(body),\n        expiresAt,\n      ]\n    );\n  }\n\n  async delete(key: string): Promise<boolean> {\n    const result = await this.client.query(\n      `DELETE FROM ${this.table} WHERE key = $1 RETURNING key`,\n      [key]\n    );\n    return result.rows.length > 0;\n  }\n\n  /** Remove expired entries. Call periodically (e.g. via cron or waitUntil). */\n  async cleanup(): Promise<void> {\n    await this.client.query(\n      `DELETE FROM ${this.table} WHERE expires_at <= $1`,\n      [Date.now()]\n    );\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Factory\n// ---------------------------------------------------------------------------\n\n/**\n * Create a {@link GatewayAdapter} using PostgreSQL-backed stores.\n *\n * Before using, create the required tables by running {@link POSTGRES_SCHEMA_SQL}\n * against your database.\n *\n * @example\n * ```ts\n * import { Pool } from \"pg\";\n * import { postgresAdapter, POSTGRES_SCHEMA_SQL } from \"@vivero/stoma/adapters/postgres\";\n *\n * const pool = new Pool({ connectionString: process.env.DATABASE_URL });\n * await pool.query(POSTGRES_SCHEMA_SQL); // one-time setup\n *\n * const adapter = postgresAdapter({ client: pool });\n * createGateway({ adapter, ... });\n * ```\n */\nexport function postgresAdapter(config: PostgresAdapterConfig): GatewayAdapter {\n  const prefix = config.tablePrefix ?? \"stoma_\";\n  const stores = config.stores ?? {};\n\n  return {\n    rateLimitStore:\n      stores.rateLimit !== false\n        ? new PostgresRateLimitStore(config.client, `${prefix}rate_limits`)\n        : undefined,\n    circuitBreakerStore:\n      stores.circuitBreaker !== false\n        ? new PostgresCircuitBreakerStore(\n            config.client,\n            `${prefix}circuit_breakers`\n          )\n        : undefined,\n    cacheStore:\n      stores.cache !== false\n        ? new PostgresCacheStore(config.client, `${prefix}cache`)\n        : undefined,\n    waitUntil: config.waitUntil,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/adapters/redis.d.ts

@@ -0,0 +1,116 @@
+import { C as CacheStore, b as CircuitBreakerStore, a as CircuitBreakerSnapshot, c as CircuitState, R as RateLimitStore, G as GatewayAdapter } from '../protocol-2fD3DJrL.js';
+import 'hono';
+import '../policies/sdk/trace.js';
+import '@vivero/stoma-core';
+
+/**
+ * Redis-backed adapter for stoma - production-ready stores for Node.js, Bun, and Deno.
+ *
+ * Zero dependencies: define a minimal {@link RedisClient} interface that any Redis
+ * library (ioredis, node-redis, etc.) satisfies, then pass it to {@link redisAdapter}.
+ *
+ * @module adapters/redis
+ */
+
+/**
+ * Minimal Redis client interface - satisfied by ioredis, node-redis v4, and most
+ * Redis libraries. Only the methods stoma actually calls are required.
+ */
+interface RedisClient {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, ...args: unknown[]): Promise<unknown>;
+    del(...keys: string[]): Promise<number>;
+    eval(script: string, numkeys: number, ...args: (string | number)[]): Promise<unknown>;
+}
+interface RedisAdapterConfig {
+    /** Redis client instance (ioredis, node-redis, etc.). */
+    client: RedisClient;
+    /** Key prefix for all Redis keys. Default: `"stoma:"`. */
+    prefix?: string;
+    /**
+     * Override for SET-with-TTL. Default uses ioredis-style `client.set(key, value, "EX", ttl)`.
+     *
+     * For node-redis v4:
+     * ```ts
+     * (c, k, v, ttl) => c.set(k, v, { EX: ttl } as any)
+     * ```
+     */
+    setWithTTL?: (client: RedisClient, key: string, value: string, ttlSeconds: number) => Promise<unknown>;
+    /** Selectively enable/disable individual stores. All enabled by default. */
+    stores?: {
+        rateLimit?: boolean;
+        circuitBreaker?: boolean;
+        cache?: boolean;
+    };
+    /** Schedule background work that outlives the response. */
+    waitUntil?: (promise: Promise<unknown>) => void;
+}
+/** Rate limit store backed by Redis with atomic Lua script. */
+declare class RedisRateLimitStore implements RateLimitStore {
+    private client;
+    private prefix;
+    constructor(client: RedisClient, prefix: string);
+    increment(key: string, windowSeconds: number): Promise<{
+        count: number;
+        resetAt: number;
+    }>;
+}
+/** Circuit breaker state store backed by Redis JSON strings. */
+declare class RedisCircuitBreakerStore implements CircuitBreakerStore {
+    private client;
+    private prefix;
+    private setWithTTL;
+    constructor(client: RedisClient, prefix: string, setWithTTL: RedisAdapterConfig["setWithTTL"]);
+    private key;
+    /** Circuit breaker entries don't expire, but we set a generous TTL to avoid
+     *  zombie keys if a circuit is never referenced again. 24 hours. */
+    private static readonly TTL;
+    private load;
+    private save;
+    getState(key: string): Promise<CircuitBreakerSnapshot>;
+    recordSuccess(key: string): Promise<CircuitBreakerSnapshot>;
+    recordFailure(key: string): Promise<CircuitBreakerSnapshot>;
+    transition(key: string, to: CircuitState): Promise<CircuitBreakerSnapshot>;
+    reset(key: string): Promise<void>;
+}
+/** Response cache backed by Redis with base64-encoded body and TTL-based expiry. */
+declare class RedisCacheStore implements CacheStore {
+    private client;
+    private prefix;
+    private setWithTTL;
+    constructor(client: RedisClient, prefix: string, setWithTTL: RedisAdapterConfig["setWithTTL"]);
+    private key;
+    get(key: string): Promise<Response | null>;
+    put(key: string, response: Response, ttlSeconds: number): Promise<void>;
+    delete(key: string): Promise<boolean>;
+}
+/**
+ * Create a {@link GatewayAdapter} using Redis-backed stores.
+ *
+ * @example
+ * ```ts
+ * import Redis from "ioredis";
+ * import { redisAdapter } from "@vivero/stoma/adapters/redis";
+ *
+ * const redis = new Redis();
+ * const adapter = redisAdapter({ client: redis });
+ *
+ * createGateway({ adapter, ... });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // node-redis v4 (different SET signature)
+ * import { createClient } from "redis";
+ * import { redisAdapter } from "@vivero/stoma/adapters/redis";
+ *
+ * const client = await createClient().connect();
+ * const adapter = redisAdapter({
+ *   client: client as any,
+ *   setWithTTL: (c, k, v, ttl) => c.set(k, v, "EX", ttl),
+ * });
+ * ```
+ */
+declare function redisAdapter(config: RedisAdapterConfig): GatewayAdapter;
+
+export { type RedisAdapterConfig, RedisCacheStore, RedisCircuitBreakerStore, type RedisClient, RedisRateLimitStore, redisAdapter };

package/dist/adapters/redis.js

@@ -0,0 +1,194 @@
+function defaultSetWithTTL(client, key, value, ttlSeconds) {
+  return client.set(key, value, "EX", ttlSeconds);
+}
+const NULL_BODY_STATUSES = /* @__PURE__ */ new Set([204, 304]);
+function safeBody(body, status) {
+  return NULL_BODY_STATUSES.has(status) ? null : body ?? null;
+}
+function uint8ToBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function base64ToUint8(b64) {
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+const RATE_LIMIT_LUA = `
+local key = KEYS[1]
+local window = tonumber(ARGV[1])
+local now = tonumber(ARGV[2])
+
+local count = redis.call("INCR", key)
+if count == 1 then
+  redis.call("EXPIRE", key, window)
+end
+
+local ttl = redis.call("TTL", key)
+local resetAt = now + (ttl * 1000)
+
+return {count, resetAt}
+`;
+class RedisRateLimitStore {
+  constructor(client, prefix) {
+    this.client = client;
+    this.prefix = prefix;
+  }
+  async increment(key, windowSeconds) {
+    const redisKey = `${this.prefix}rl:${key}`;
+    const now = Date.now();
+    const result = await this.client.eval(
+      RATE_LIMIT_LUA,
+      1,
+      redisKey,
+      windowSeconds,
+      now
+    );
+    return { count: result[0], resetAt: result[1] };
+  }
+}
+function defaultEntry() {
+  return {
+    state: "closed",
+    failureCount: 0,
+    successCount: 0,
+    lastFailureTime: 0,
+    lastStateChange: Date.now()
+  };
+}
+class RedisCircuitBreakerStore {
+  constructor(client, prefix, setWithTTL) {
+    this.client = client;
+    this.prefix = prefix;
+    this.setWithTTL = setWithTTL;
+  }
+  key(k) {
+    return `${this.prefix}cb:${k}`;
+  }
+  /** Circuit breaker entries don't expire, but we set a generous TTL to avoid
+   *  zombie keys if a circuit is never referenced again. 24 hours. */
+  static TTL = 86400;
+  async load(key) {
+    const raw = await this.client.get(this.key(key));
+    if (!raw) return defaultEntry();
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return defaultEntry();
+    }
+  }
+  async save(key, entry) {
+    const setter = this.setWithTTL ?? defaultSetWithTTL;
+    await setter(
+      this.client,
+      this.key(key),
+      JSON.stringify(entry),
+      RedisCircuitBreakerStore.TTL
+    );
+  }
+  async getState(key) {
+    return { ...await this.load(key) };
+  }
+  async recordSuccess(key) {
+    const entry = await this.load(key);
+    entry.successCount++;
+    await this.save(key, entry);
+    return { ...entry };
+  }
+  async recordFailure(key) {
+    const entry = await this.load(key);
+    entry.failureCount++;
+    entry.lastFailureTime = Date.now();
+    await this.save(key, entry);
+    return { ...entry };
+  }
+  async transition(key, to) {
+    const entry = await this.load(key);
+    entry.state = to;
+    entry.lastStateChange = Date.now();
+    if (to === "closed") {
+      entry.failureCount = 0;
+      entry.successCount = 0;
+    }
+    if (to === "half-open") {
+      entry.successCount = 0;
+    }
+    await this.save(key, entry);
+    return { ...entry };
+  }
+  async reset(key) {
+    await this.client.del(this.key(key));
+  }
+}
+class RedisCacheStore {
+  constructor(client, prefix, setWithTTL) {
+    this.client = client;
+    this.prefix = prefix;
+    this.setWithTTL = setWithTTL;
+  }
+  key(k) {
+    return `${this.prefix}cache:${k}`;
+  }
+  async get(key) {
+    const raw = await this.client.get(this.key(key));
+    if (!raw) return null;
+    let envelope;
+    try {
+      envelope = JSON.parse(raw);
+    } catch {
+      return null;
+    }
+    const body = base64ToUint8(envelope.body);
+    return new Response(safeBody(body, envelope.status), {
+      status: envelope.status,
+      headers: envelope.headers
+    });
+  }
+  async put(key, response, ttlSeconds) {
+    const body = new Uint8Array(await response.arrayBuffer());
+    const headers = [];
+    response.headers.forEach((value, name) => {
+      headers.push([name, value]);
+    });
+    const envelope = {
+      status: response.status,
+      headers,
+      body: uint8ToBase64(body)
+    };
+    const setter = this.setWithTTL ?? defaultSetWithTTL;
+    await setter(
+      this.client,
+      this.key(key),
+      JSON.stringify(envelope),
+      ttlSeconds
+    );
+  }
+  async delete(key) {
+    const count = await this.client.del(this.key(key));
+    return count > 0;
+  }
+}
+function redisAdapter(config) {
+  const prefix = config.prefix ?? "stoma:";
+  const stores = config.stores ?? {};
+  const setWithTTL = config.setWithTTL;
+  return {
+    rateLimitStore: stores.rateLimit !== false ? new RedisRateLimitStore(config.client, prefix) : void 0,
+    circuitBreakerStore: stores.circuitBreaker !== false ? new RedisCircuitBreakerStore(config.client, prefix, setWithTTL) : void 0,
+    cacheStore: stores.cache !== false ? new RedisCacheStore(config.client, prefix, setWithTTL) : void 0,
+    waitUntil: config.waitUntil
+  };
+}
+export {
+  RedisCacheStore,
+  RedisCircuitBreakerStore,
+  RedisRateLimitStore,
+  redisAdapter
+};
+//# sourceMappingURL=redis.js.map

package/dist/adapters/redis.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/redis.ts"],"sourcesContent":["/**\n * Redis-backed adapter for stoma - production-ready stores for Node.js, Bun, and Deno.\n *\n * Zero dependencies: define a minimal {@link RedisClient} interface that any Redis\n * library (ioredis, node-redis, etc.) satisfies, then pass it to {@link redisAdapter}.\n *\n * @module adapters/redis\n */\nimport type {\n  CircuitBreakerSnapshot,\n  CircuitBreakerStore,\n  CircuitState,\n} from \"../policies/resilience/circuit-breaker\";\nimport type { CacheStore } from \"../policies/traffic/cache\";\nimport type { RateLimitStore } from \"../policies/traffic/rate-limit\";\nimport type { GatewayAdapter } from \"./types\";\n\n// ---------------------------------------------------------------------------\n// Client interface\n// ---------------------------------------------------------------------------\n\n/**\n * Minimal Redis client interface - satisfied by ioredis, node-redis v4, and most\n * Redis libraries. Only the methods stoma actually calls are required.\n */\nexport interface RedisClient {\n  get(key: string): Promise<string | null>;\n  set(key: string, value: string, ...args: unknown[]): Promise<unknown>;\n  del(...keys: string[]): Promise<number>;\n  eval(\n    script: string,\n    numkeys: number,\n    ...args: (string | number)[]\n  ): Promise<unknown>;\n}\n\n// ---------------------------------------------------------------------------\n// Config\n// ---------------------------------------------------------------------------\n\nexport interface RedisAdapterConfig {\n  /** Redis client instance (ioredis, node-redis, etc.). */\n  client: RedisClient;\n  /** Key prefix for all Redis keys. Default: `\"stoma:\"`. */\n  prefix?: string;\n  /**\n   * Override for SET-with-TTL. Default uses ioredis-style `client.set(key, value, \"EX\", ttl)`.\n   *\n   * For node-redis v4:\n   * ```ts\n   * (c, k, v, ttl) => c.set(k, v, { EX: ttl } as any)\n   * ```\n   */\n  setWithTTL?: (\n    client: RedisClient,\n    key: string,\n    value: string,\n    ttlSeconds: number\n  ) => Promise<unknown>;\n  /** Selectively enable/disable individual stores. All enabled by default. */\n  stores?: {\n    rateLimit?: boolean;\n    circuitBreaker?: boolean;\n    cache?: boolean;\n  };\n  /** Schedule background work that outlives the response. */\n  waitUntil?: (promise: Promise<unknown>) => void;\n}\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\n\n/** Default SET-with-TTL using ioredis-style positional args. */\nfunction defaultSetWithTTL(\n  client: RedisClient,\n  key: string,\n  value: string,\n  ttlSeconds: number\n): Promise<unknown> {\n  return client.set(key, value, \"EX\", ttlSeconds);\n}\n\n// Per HTTP spec, 204 and 304 responses must not carry a body.\nconst NULL_BODY_STATUSES = new Set([204, 304]);\nfunction safeBody(\n  body: BodyInit | null | undefined,\n  status: number\n): BodyInit | null {\n  return NULL_BODY_STATUSES.has(status) ? null : (body ?? null);\n}\n\n/** Encode a Uint8Array to base64 string (no Node Buffer dependency). */\nfunction uint8ToBase64(bytes: Uint8Array): string {\n  let binary = \"\";\n  for (let i = 0; i < bytes.length; i++) {\n    binary += String.fromCharCode(bytes[i]);\n  }\n  return btoa(binary);\n}\n\n/** Decode a base64 string to Uint8Array (no Node Buffer dependency). */\nfunction base64ToUint8(b64: string): Uint8Array {\n  const binary = atob(b64);\n  const bytes = new Uint8Array(binary.length);\n  for (let i = 0; i < binary.length; i++) {\n    bytes[i] = binary.charCodeAt(i);\n  }\n  return bytes;\n}\n\n// ---------------------------------------------------------------------------\n// Rate Limit Store\n// ---------------------------------------------------------------------------\n\n/**\n * Atomic rate limit counter using a Lua script.\n *\n * The script does `INCR` + conditional `EXPIRE` in a single round trip,\n * eliminating race conditions between reads and writes.\n */\nconst RATE_LIMIT_LUA = `\nlocal key = KEYS[1]\nlocal window = tonumber(ARGV[1])\nlocal now = tonumber(ARGV[2])\n\nlocal count = redis.call(\"INCR\", key)\nif count == 1 then\n  redis.call(\"EXPIRE\", key, window)\nend\n\nlocal ttl = redis.call(\"TTL\", key)\nlocal resetAt = now + (ttl * 1000)\n\nreturn {count, resetAt}\n`;\n\n/** Rate limit store backed by Redis with atomic Lua script. */\nexport class RedisRateLimitStore implements RateLimitStore {\n  constructor(\n    private client: RedisClient,\n    private prefix: string\n  ) {}\n\n  async increment(\n    key: string,\n    windowSeconds: number\n  ): Promise<{ count: number; resetAt: number }> {\n    const redisKey = `${this.prefix}rl:${key}`;\n    const now = Date.now();\n\n    const result = (await this.client.eval(\n      RATE_LIMIT_LUA,\n      1,\n      redisKey,\n      windowSeconds,\n      now\n    )) as [number, number];\n\n    return { count: result[0], resetAt: result[1] };\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Circuit Breaker Store\n// ---------------------------------------------------------------------------\n\ninterface CircuitBreakerEntry {\n  state: CircuitState;\n  failureCount: number;\n  successCount: number;\n  lastFailureTime: number;\n  lastStateChange: number;\n}\n\nfunction defaultEntry(): CircuitBreakerEntry {\n  return {\n    state: \"closed\",\n    failureCount: 0,\n    successCount: 0,\n    lastFailureTime: 0,\n    lastStateChange: Date.now(),\n  };\n}\n\n/** Circuit breaker state store backed by Redis JSON strings. */\nexport class RedisCircuitBreakerStore implements CircuitBreakerStore {\n  constructor(\n    private client: RedisClient,\n    private prefix: string,\n    private setWithTTL: RedisAdapterConfig[\"setWithTTL\"]\n  ) {}\n\n  private key(k: string): string {\n    return `${this.prefix}cb:${k}`;\n  }\n\n  /** Circuit breaker entries don't expire, but we set a generous TTL to avoid\n   *  zombie keys if a circuit is never referenced again. 24 hours. */\n  private static readonly TTL = 86400;\n\n  private async load(key: string): Promise<CircuitBreakerEntry> {\n    const raw = await this.client.get(this.key(key));\n    if (!raw) return defaultEntry();\n    try {\n      return JSON.parse(raw) as CircuitBreakerEntry;\n    } catch {\n      return defaultEntry();\n    }\n  }\n\n  private async save(key: string, entry: CircuitBreakerEntry): Promise<void> {\n    const setter = this.setWithTTL ?? defaultSetWithTTL;\n    await setter(\n      this.client,\n      this.key(key),\n      JSON.stringify(entry),\n      RedisCircuitBreakerStore.TTL\n    );\n  }\n\n  async getState(key: string): Promise<CircuitBreakerSnapshot> {\n    return { ...(await this.load(key)) };\n  }\n\n  async recordSuccess(key: string): Promise<CircuitBreakerSnapshot> {\n    const entry = await this.load(key);\n    entry.successCount++;\n    await this.save(key, entry);\n    return { ...entry };\n  }\n\n  async recordFailure(key: string): Promise<CircuitBreakerSnapshot> {\n    const entry = await this.load(key);\n    entry.failureCount++;\n    entry.lastFailureTime = Date.now();\n    await this.save(key, entry);\n    return { ...entry };\n  }\n\n  async transition(\n    key: string,\n    to: CircuitState\n  ): Promise<CircuitBreakerSnapshot> {\n    const entry = await this.load(key);\n    entry.state = to;\n    entry.lastStateChange = Date.now();\n    if (to === \"closed\") {\n      entry.failureCount = 0;\n      entry.successCount = 0;\n    }\n    if (to === \"half-open\") {\n      entry.successCount = 0;\n    }\n    await this.save(key, entry);\n    return { ...entry };\n  }\n\n  async reset(key: string): Promise<void> {\n    await this.client.del(this.key(key));\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Cache Store\n// ---------------------------------------------------------------------------\n\ninterface CacheEnvelope {\n  status: number;\n  headers: [string, string][];\n  body: string; // base64-encoded\n}\n\n/** Response cache backed by Redis with base64-encoded body and TTL-based expiry. */\nexport class RedisCacheStore implements CacheStore {\n  constructor(\n    private client: RedisClient,\n    private prefix: string,\n    private setWithTTL: RedisAdapterConfig[\"setWithTTL\"]\n  ) {}\n\n  private key(k: string): string {\n    return `${this.prefix}cache:${k}`;\n  }\n\n  async get(key: string): Promise<Response | null> {\n    const raw = await this.client.get(this.key(key));\n    if (!raw) return null;\n\n    let envelope: CacheEnvelope;\n    try {\n      envelope = JSON.parse(raw) as CacheEnvelope;\n    } catch {\n      return null;\n    }\n\n    const body = base64ToUint8(envelope.body);\n    return new Response(safeBody(body, envelope.status), {\n      status: envelope.status,\n      headers: envelope.headers,\n    });\n  }\n\n  async put(\n    key: string,\n    response: Response,\n    ttlSeconds: number\n  ): Promise<void> {\n    const body = new Uint8Array(await response.arrayBuffer());\n    const headers: [string, string][] = [];\n    response.headers.forEach((value, name) => {\n      headers.push([name, value]);\n    });\n\n    const envelope: CacheEnvelope = {\n      status: response.status,\n      headers,\n      body: uint8ToBase64(body),\n    };\n\n    const setter = this.setWithTTL ?? defaultSetWithTTL;\n    await setter(\n      this.client,\n      this.key(key),\n      JSON.stringify(envelope),\n      ttlSeconds\n    );\n  }\n\n  async delete(key: string): Promise<boolean> {\n    const count = await this.client.del(this.key(key));\n    return count > 0;\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Factory\n// ---------------------------------------------------------------------------\n\n/**\n * Create a {@link GatewayAdapter} using Redis-backed stores.\n *\n * @example\n * ```ts\n * import Redis from \"ioredis\";\n * import { redisAdapter } from \"@vivero/stoma/adapters/redis\";\n *\n * const redis = new Redis();\n * const adapter = redisAdapter({ client: redis });\n *\n * createGateway({ adapter, ... });\n * ```\n *\n * @example\n * ```ts\n * // node-redis v4 (different SET signature)\n * import { createClient } from \"redis\";\n * import { redisAdapter } from \"@vivero/stoma/adapters/redis\";\n *\n * const client = await createClient().connect();\n * const adapter = redisAdapter({\n *   client: client as any,\n *   setWithTTL: (c, k, v, ttl) => c.set(k, v, \"EX\", ttl),\n * });\n * ```\n */\nexport function redisAdapter(config: RedisAdapterConfig): GatewayAdapter {\n  const prefix = config.prefix ?? \"stoma:\";\n  const stores = config.stores ?? {};\n  const setWithTTL = config.setWithTTL;\n\n  return {\n    rateLimitStore:\n      stores.rateLimit !== false\n        ? new RedisRateLimitStore(config.client, prefix)\n        : undefined,\n    circuitBreakerStore:\n      stores.circuitBreaker !== false\n        ? new RedisCircuitBreakerStore(config.client, prefix, setWithTTL)\n        : undefined,\n    cacheStore:\n      stores.cache !== false\n        ? new RedisCacheStore(config.client, prefix, setWithTTL)\n        : undefined,\n    waitUntil: config.waitUntil,\n  };\n}\n"],"mappings":"AA0EA,SAAS,kBACP,QACA,KACA,OACA,YACkB;AAClB,SAAO,OAAO,IAAI,KAAK,OAAO,MAAM,UAAU;AAChD;AAGA,MAAM,qBAAqB,oBAAI,IAAI,CAAC,KAAK,GAAG,CAAC;AAC7C,SAAS,SACP,MACA,QACiB;AACjB,SAAO,mBAAmB,IAAI,MAAM,IAAI,OAAQ,QAAQ;AAC1D;AAGA,SAAS,cAAc,OAA2B;AAChD,MAAI,SAAS;AACb,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,cAAU,OAAO,aAAa,MAAM,CAAC,CAAC;AAAA,EACxC;AACA,SAAO,KAAK,MAAM;AACpB;AAGA,SAAS,cAAc,KAAyB;AAC9C,QAAM,SAAS,KAAK,GAAG;AACvB,QAAM,QAAQ,IAAI,WAAW,OAAO,MAAM;AAC1C,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,UAAM,CAAC,IAAI,OAAO,WAAW,CAAC;AAAA,EAChC;AACA,SAAO;AACT;AAYA,MAAM,iBAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBhB,MAAM,oBAA8C;AAAA,EACzD,YACU,QACA,QACR;AAFQ;AACA;AAAA,EACP;AAAA,EAEH,MAAM,UACJ,KACA,eAC6C;AAC7C,UAAM,WAAW,GAAG,KAAK,MAAM,MAAM,GAAG;AACxC,UAAM,MAAM,KAAK,IAAI;AAErB,UAAM,SAAU,MAAM,KAAK,OAAO;AAAA,MAChC;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAEA,WAAO,EAAE,OAAO,OAAO,CAAC,GAAG,SAAS,OAAO,CAAC,EAAE;AAAA,EAChD;AACF;AAcA,SAAS,eAAoC;AAC3C,SAAO;AAAA,IACL,OAAO;AAAA,IACP,cAAc;AAAA,IACd,cAAc;AAAA,IACd,iBAAiB;AAAA,IACjB,iBAAiB,KAAK,IAAI;AAAA,EAC5B;AACF;AAGO,MAAM,yBAAwD;AAAA,EACnE,YACU,QACA,QACA,YACR;AAHQ;AACA;AACA;AAAA,EACP;AAAA,EAEK,IAAI,GAAmB;AAC7B,WAAO,GAAG,KAAK,MAAM,MAAM,CAAC;AAAA,EAC9B;AAAA;AAAA;AAAA,EAIA,OAAwB,MAAM;AAAA,EAE9B,MAAc,KAAK,KAA2C;AAC5D,UAAM,MAAM,MAAM,KAAK,OAAO,IAAI,KAAK,IAAI,GAAG,CAAC;AAC/C,QAAI,CAAC,IAAK,QAAO,aAAa;AAC9B,QAAI;AACF,aAAO,KAAK,MAAM,GAAG;AAAA,IACvB,QAAQ;AACN,aAAO,aAAa;AAAA,IACtB;AAAA,EACF;AAAA,EAEA,MAAc,KAAK,KAAa,OAA2C;AACzE,UAAM,SAAS,KAAK,cAAc;AAClC,UAAM;AAAA,MACJ,KAAK;AAAA,MACL,KAAK,IAAI,GAAG;AAAA,MACZ,KAAK,UAAU,KAAK;AAAA,MACpB,yBAAyB;AAAA,IAC3B;AAAA,EACF;AAAA,EAEA,MAAM,SAAS,KAA8C;AAC3D,WAAO,EAAE,GAAI,MAAM,KAAK,KAAK,GAAG,EAAG;AAAA,EACrC;AAAA,EAEA,MAAM,cAAc,KAA8C;AAChE,UAAM,QAAQ,MAAM,KAAK,KAAK,GAAG;AACjC,UAAM;AACN,UAAM,KAAK,KAAK,KAAK,KAAK;AAC1B,WAAO,EAAE,GAAG,MAAM;AAAA,EACpB;AAAA,EAEA,MAAM,cAAc,KAA8C;AAChE,UAAM,QAAQ,MAAM,KAAK,KAAK,GAAG;AACjC,UAAM;AACN,UAAM,kBAAkB,KAAK,IAAI;AACjC,UAAM,KAAK,KAAK,KAAK,KAAK;AAC1B,WAAO,EAAE,GAAG,MAAM;AAAA,EACpB;AAAA,EAEA,MAAM,WACJ,KACA,IACiC;AACjC,UAAM,QAAQ,MAAM,KAAK,KAAK,GAAG;AACjC,UAAM,QAAQ;AACd,UAAM,kBAAkB,KAAK,IAAI;AACjC,QAAI,OAAO,UAAU;AACnB,YAAM,eAAe;AACrB,YAAM,eAAe;AAAA,IACvB;AACA,QAAI,OAAO,aAAa;AACtB,YAAM,eAAe;AAAA,IACvB;AACA,UAAM,KAAK,KAAK,KAAK,KAAK;AAC1B,WAAO,EAAE,GAAG,MAAM;AAAA,EACpB;AAAA,EAEA,MAAM,MAAM,KAA4B;AACtC,UAAM,KAAK,OAAO,IAAI,KAAK,IAAI,GAAG,CAAC;AAAA,EACrC;AACF;AAaO,MAAM,gBAAsC;AAAA,EACjD,YACU,QACA,QACA,YACR;AAHQ;AACA;AACA;AAAA,EACP;AAAA,EAEK,IAAI,GAAmB;AAC7B,WAAO,GAAG,KAAK,MAAM,SAAS,CAAC;AAAA,EACjC;AAAA,EAEA,MAAM,IAAI,KAAuC;AAC/C,UAAM,MAAM,MAAM,KAAK,OAAO,IAAI,KAAK,IAAI,GAAG,CAAC;AAC/C,QAAI,CAAC,IAAK,QAAO;AAEjB,QAAI;AACJ,QAAI;AACF,iBAAW,KAAK,MAAM,GAAG;AAAA,IAC3B,QAAQ;AACN,aAAO;AAAA,IACT;AAEA,UAAM,OAAO,cAAc,SAAS,IAAI;AACxC,WAAO,IAAI,SAAS,SAAS,MAAM,SAAS,MAAM,GAAG;AAAA,MACnD,QAAQ,SAAS;AAAA,MACjB,SAAS,SAAS;AAAA,IACpB,CAAC;AAAA,EACH;AAAA,EAEA,MAAM,IACJ,KACA,UACA,YACe;AACf,UAAM,OAAO,IAAI,WAAW,MAAM,SAAS,YAAY,CAAC;AACxD,UAAM,UAA8B,CAAC;AACrC,aAAS,QAAQ,QAAQ,CAAC,OAAO,SAAS;AACxC,cAAQ,KAAK,CAAC,MAAM,KAAK,CAAC;AAAA,IAC5B,CAAC;AAED,UAAM,WAA0B;AAAA,MAC9B,QAAQ,SAAS;AAAA,MACjB;AAAA,MACA,MAAM,cAAc,IAAI;AAAA,IAC1B;AAEA,UAAM,SAAS,KAAK,cAAc;AAClC,UAAM;AAAA,MACJ,KAAK;AAAA,MACL,KAAK,IAAI,GAAG;AAAA,MACZ,KAAK,UAAU,QAAQ;AAAA,MACvB;AAAA,IACF;AAAA,EACF;AAAA,EAEA,MAAM,OAAO,KAA+B;AAC1C,UAAM,QAAQ,MAAM,KAAK,OAAO,IAAI,KAAK,IAAI,GAAG,CAAC;AACjD,WAAO,QAAQ;AAAA,EACjB;AACF;AAiCO,SAAS,aAAa,QAA4C;AACvE,QAAM,SAAS,OAAO,UAAU;AAChC,QAAM,SAAS,OAAO,UAAU,CAAC;AACjC,QAAM,aAAa,OAAO;AAE1B,SAAO;AAAA,IACL,gBACE,OAAO,cAAc,QACjB,IAAI,oBAAoB,OAAO,QAAQ,MAAM,IAC7C;AAAA,IACN,qBACE,OAAO,mBAAmB,QACtB,IAAI,yBAAyB,OAAO,QAAQ,QAAQ,UAAU,IAC9D;AAAA,IACN,YACE,OAAO,UAAU,QACb,IAAI,gBAAgB,OAAO,QAAQ,QAAQ,UAAU,IACrD;AAAA,IACN,WAAW,OAAO;AAAA,EACpB;AACF;","names":[]}

package/dist/adapters/testing.d.ts

@@ -0,0 +1,32 @@
+import { G as GatewayAdapter } from '../protocol-2fD3DJrL.js';
+import 'hono';
+import '../policies/sdk/trace.js';
+import '@vivero/stoma-core';
+
+/**
+ * A GatewayAdapter implementation for unit testing.
+ *
+ * Provides a `waitUntil` implementation that collects background promises,
+ * allowing tests to `await adapter.waitAll()` before finishing.
+ */
+declare class TestAdapter implements GatewayAdapter {
+    private promises;
+    /**
+     * Add a promise to the background work queue.
+     */
+    waitUntil: (promise: Promise<unknown>) => void;
+    /**
+     * Await all pending background work collected via `waitUntil`.
+     */
+    waitAll(): Promise<void>;
+    /**
+     * Reset the collected promises.
+     */
+    reset(): void;
+}
+/**
+ * Create a new {@link TestAdapter}.
+ */
+declare function createTestAdapter(): TestAdapter;
+
+export { TestAdapter, createTestAdapter };