@vivero/stoma 0.1.0-rc.5

package/dist/adapters/bun.d.ts

@@ -0,0 +1,9 @@
+import { G as GatewayAdapter } from '../protocol-2fD3DJrL.js';
+import 'hono';
+import '../policies/sdk/trace.js';
+import '@vivero/stoma-core';
+
+/** Create a GatewayAdapter for Bun. Delegates to memoryAdapter() for in-memory stores. */
+declare function bunAdapter(): GatewayAdapter;
+
+export { bunAdapter };

package/dist/adapters/bun.js

@@ -0,0 +1,8 @@
+import { memoryAdapter } from "./memory";
+function bunAdapter() {
+  return memoryAdapter();
+}
+export {
+  bunAdapter
+};
+//# sourceMappingURL=bun.js.map

package/dist/adapters/bun.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/bun.ts"],"sourcesContent":["/**\n * Bun adapter for stoma.\n *\n * Bun doesn't provide `waitUntil` or service bindings natively.\n * Use `memoryAdapter()` for stores and this adapter as a marker/extension\n * point for Bun-specific capabilities.\n *\n * @example\n * ```ts\n * import { createGateway } from \"@vivero/stoma\";\n * import { bunAdapter } from \"@vivero/stoma/adapters/bun\";\n *\n * const gateway = createGateway({\n *   adapter: bunAdapter(),\n *   routes: [...]\n * });\n *\n * export default gateway.app;\n * ```\n *\n * @module bun-adapter\n */\nimport { memoryAdapter } from \"./memory\";\nimport type { GatewayAdapter } from \"./types\";\n\n/** Create a GatewayAdapter for Bun. Delegates to memoryAdapter() for in-memory stores. */\nexport function bunAdapter(): GatewayAdapter {\n  return memoryAdapter();\n}\n"],"mappings":"AAsBA,SAAS,qBAAqB;AAIvB,SAAS,aAA6B;AAC3C,SAAO,cAAc;AACvB;","names":[]}

package/dist/adapters/cloudflare.d.ts

@@ -0,0 +1,49 @@
+import { C as CacheStore, R as RateLimitStore, G as GatewayAdapter } from '../protocol-2fD3DJrL.js';
+import 'hono';
+import '../policies/sdk/trace.js';
+import '@vivero/stoma-core';
+
+/** Rate limit store backed by Cloudflare Workers KV. */
+declare class KVRateLimitStore implements RateLimitStore {
+    private kv;
+    constructor(kv: KVNamespace);
+    increment(key: string, windowSeconds: number): Promise<{
+        count: number;
+        resetAt: number;
+    }>;
+}
+/** Response cache backed by the Cloudflare Cache API. */
+declare class CacheApiCacheStore implements CacheStore {
+    private cache;
+    private origin;
+    /**
+     * @param cache - A `Cache` instance (e.g. `caches.default`). Falls back to `caches.default` when omitted.
+     * @param origin - Synthetic origin used to construct cache keys. Default: `"https://edge-gateway.internal"`.
+     */
+    constructor(cache?: Cache, origin?: string);
+    get(key: string): Promise<Response | null>;
+    put(key: string, response: Response, ttlSeconds: number): Promise<void>;
+    delete(key: string): Promise<boolean>;
+}
+interface CloudflareAdapterBindings {
+    rateLimitKv?: KVNamespace;
+    rateLimitDo?: DurableObjectNamespace;
+    cache?: Cache;
+    /** Synthetic origin used for Cache API cache keys. Default: `"https://edge-gateway.internal"`. */
+    cacheOrigin?: string;
+    /** Workers `ExecutionContext` - enables `waitUntil` for background work (e.g. traffic shadow). */
+    executionCtx?: ExecutionContext;
+    /** Workers `env` object - enables `dispatchBinding` for service binding dispatch via the adapter. */
+    env?: Record<string, unknown>;
+}
+/**
+ * Create a GatewayAdapter using Cloudflare-native stores.
+ *
+ * Rate limiting priority: Durable Objects (strongly consistent) > KV (eventually consistent) > none.
+ *
+ * Pass `executionCtx` to enable `waitUntil` (for traffic shadow and other background work).
+ * Pass `env` to enable `dispatchBinding` (for service binding dispatch via the adapter).
+ */
+declare function cloudflareAdapter(bindings: CloudflareAdapterBindings): GatewayAdapter;
+
+export { CacheApiCacheStore, type CloudflareAdapterBindings, KVRateLimitStore, cloudflareAdapter };

package/dist/adapters/cloudflare.js

@@ -0,0 +1,85 @@
+import { InMemoryCircuitBreakerStore } from "../policies/resilience/circuit-breaker";
+import { DurableObjectRateLimitStore } from "./durable-object";
+class KVRateLimitStore {
+  constructor(kv) {
+    this.kv = kv;
+  }
+  async increment(key, windowSeconds) {
+    const now = Date.now();
+    const raw = await this.kv.get(key, "json");
+    if (raw && raw.resetAt > now) {
+      const updated = { count: raw.count + 1, resetAt: raw.resetAt };
+      const ttl = Math.max(1, Math.ceil((raw.resetAt - now) / 1e3));
+      await this.kv.put(key, JSON.stringify(updated), { expirationTtl: ttl });
+      return updated;
+    }
+    const resetAt = now + windowSeconds * 1e3;
+    const entry = { count: 1, resetAt };
+    await this.kv.put(key, JSON.stringify(entry), {
+      expirationTtl: windowSeconds
+    });
+    return entry;
+  }
+}
+const DEFAULT_CACHE_ORIGIN = "https://stoma.internal";
+class CacheApiCacheStore {
+  cache;
+  origin;
+  /**
+   * @param cache - A `Cache` instance (e.g. `caches.default`). Falls back to `caches.default` when omitted.
+   * @param origin - Synthetic origin used to construct cache keys. Default: `"https://edge-gateway.internal"`.
+   */
+  constructor(cache, origin) {
+    this.cache = cache ?? caches.default;
+    this.origin = origin ?? DEFAULT_CACHE_ORIGIN;
+  }
+  async get(key) {
+    const cacheKey = new Request(`${this.origin}/${encodeURIComponent(key)}`);
+    const match = await this.cache.match(cacheKey);
+    return match ?? null;
+  }
+  async put(key, response, ttlSeconds) {
+    const cacheKey = new Request(`${this.origin}/${encodeURIComponent(key)}`);
+    const headers = new Headers(response.headers);
+    headers.set("Cache-Control", `s-maxage=${ttlSeconds}`);
+    const body = await response.arrayBuffer();
+    const cached = new Response(body, {
+      status: response.status,
+      headers
+    });
+    await this.cache.put(cacheKey, cached);
+  }
+  async delete(key) {
+    const cacheKey = new Request(`${this.origin}/${encodeURIComponent(key)}`);
+    return this.cache.delete(cacheKey);
+  }
+}
+function cloudflareAdapter(bindings) {
+  let rateLimitStore;
+  if (bindings.rateLimitDo) {
+    rateLimitStore = new DurableObjectRateLimitStore(bindings.rateLimitDo);
+  } else if (bindings.rateLimitKv) {
+    rateLimitStore = new KVRateLimitStore(bindings.rateLimitKv);
+  }
+  return {
+    rateLimitStore,
+    circuitBreakerStore: new InMemoryCircuitBreakerStore(),
+    cacheStore: bindings.cache ? new CacheApiCacheStore(bindings.cache, bindings.cacheOrigin) : new CacheApiCacheStore(void 0, bindings.cacheOrigin),
+    waitUntil: bindings.executionCtx ? (p) => bindings.executionCtx.waitUntil(p) : void 0,
+    dispatchBinding: bindings.env ? async (service, request) => {
+      const binding = bindings.env[service];
+      if (!binding || typeof binding.fetch !== "function") {
+        throw new Error(
+          `Service binding "${service}" is not available in the Worker environment`
+        );
+      }
+      return binding.fetch(request);
+    } : void 0
+  };
+}
+export {
+  CacheApiCacheStore,
+  KVRateLimitStore,
+  cloudflareAdapter
+};
+//# sourceMappingURL=cloudflare.js.map

package/dist/adapters/cloudflare.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/cloudflare.ts"],"sourcesContent":["import { InMemoryCircuitBreakerStore } from \"../policies/resilience/circuit-breaker\";\nimport type { CacheStore } from \"../policies/traffic/cache\";\nimport type { RateLimitStore } from \"../policies/traffic/rate-limit\";\nimport { DurableObjectRateLimitStore } from \"./durable-object\";\nimport type { GatewayAdapter } from \"./types\";\n\n// ---------------------------------------------------------------------------\n// KV-backed rate limit store\n// ---------------------------------------------------------------------------\n\n/** Rate limit store backed by Cloudflare Workers KV. */\nexport class KVRateLimitStore implements RateLimitStore {\n  constructor(private kv: KVNamespace) {}\n\n  async increment(\n    key: string,\n    windowSeconds: number\n  ): Promise<{ count: number; resetAt: number }> {\n    const now = Date.now();\n    const raw = (await this.kv.get(key, \"json\")) as {\n      count: number;\n      resetAt: number;\n    } | null;\n\n    if (raw && raw.resetAt > now) {\n      const updated = { count: raw.count + 1, resetAt: raw.resetAt };\n      const ttl = Math.max(1, Math.ceil((raw.resetAt - now) / 1000));\n      await this.kv.put(key, JSON.stringify(updated), { expirationTtl: ttl });\n      return updated;\n    }\n\n    const resetAt = now + windowSeconds * 1000;\n    const entry = { count: 1, resetAt };\n    await this.kv.put(key, JSON.stringify(entry), {\n      expirationTtl: windowSeconds,\n    });\n    return entry;\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Cache API-backed cache store\n// ---------------------------------------------------------------------------\n\nconst DEFAULT_CACHE_ORIGIN = \"https://stoma.internal\";\n\n/** Response cache backed by the Cloudflare Cache API. */\nexport class CacheApiCacheStore implements CacheStore {\n  private cache: Cache;\n  private origin: string;\n\n  /**\n   * @param cache - A `Cache` instance (e.g. `caches.default`). Falls back to `caches.default` when omitted.\n   * @param origin - Synthetic origin used to construct cache keys. Default: `\"https://edge-gateway.internal\"`.\n   */\n  constructor(cache?: Cache, origin?: string) {\n    // Default to caches.default when available, otherwise accept injected cache\n    this.cache = cache ?? (caches as unknown as { default: Cache }).default;\n    this.origin = origin ?? DEFAULT_CACHE_ORIGIN;\n  }\n\n  async get(key: string): Promise<Response | null> {\n    const cacheKey = new Request(`${this.origin}/${encodeURIComponent(key)}`);\n    const match = await this.cache.match(cacheKey);\n    return match ?? null;\n  }\n\n  async put(\n    key: string,\n    response: Response,\n    ttlSeconds: number\n  ): Promise<void> {\n    const cacheKey = new Request(`${this.origin}/${encodeURIComponent(key)}`);\n    const headers = new Headers(response.headers);\n    headers.set(\"Cache-Control\", `s-maxage=${ttlSeconds}`);\n    const body = await response.arrayBuffer();\n    const cached = new Response(body, {\n      status: response.status,\n      headers,\n    });\n    await this.cache.put(cacheKey, cached);\n  }\n\n  async delete(key: string): Promise<boolean> {\n    const cacheKey = new Request(`${this.origin}/${encodeURIComponent(key)}`);\n    return this.cache.delete(cacheKey);\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Factory\n// ---------------------------------------------------------------------------\n\nexport interface CloudflareAdapterBindings {\n  rateLimitKv?: KVNamespace;\n  rateLimitDo?: DurableObjectNamespace;\n  cache?: Cache;\n  /** Synthetic origin used for Cache API cache keys. Default: `\"https://edge-gateway.internal\"`. */\n  cacheOrigin?: string;\n  /** Workers `ExecutionContext` - enables `waitUntil` for background work (e.g. traffic shadow). */\n  executionCtx?: ExecutionContext;\n  /** Workers `env` object - enables `dispatchBinding` for service binding dispatch via the adapter. */\n  env?: Record<string, unknown>;\n}\n\n/**\n * Create a GatewayAdapter using Cloudflare-native stores.\n *\n * Rate limiting priority: Durable Objects (strongly consistent) > KV (eventually consistent) > none.\n *\n * Pass `executionCtx` to enable `waitUntil` (for traffic shadow and other background work).\n * Pass `env` to enable `dispatchBinding` (for service binding dispatch via the adapter).\n */\nexport function cloudflareAdapter(\n  bindings: CloudflareAdapterBindings\n): GatewayAdapter {\n  let rateLimitStore: RateLimitStore | undefined;\n  if (bindings.rateLimitDo) {\n    rateLimitStore = new DurableObjectRateLimitStore(bindings.rateLimitDo);\n  } else if (bindings.rateLimitKv) {\n    rateLimitStore = new KVRateLimitStore(bindings.rateLimitKv);\n  }\n\n  return {\n    rateLimitStore,\n    circuitBreakerStore: new InMemoryCircuitBreakerStore(),\n    cacheStore: bindings.cache\n      ? new CacheApiCacheStore(bindings.cache, bindings.cacheOrigin)\n      : new CacheApiCacheStore(undefined, bindings.cacheOrigin),\n    waitUntil: bindings.executionCtx\n      ? (p) => bindings.executionCtx!.waitUntil(p)\n      : undefined,\n    dispatchBinding: bindings.env\n      ? async (service, request) => {\n          const binding = bindings.env![service] as\n            | { fetch: typeof fetch }\n            | undefined;\n          if (!binding || typeof binding.fetch !== \"function\") {\n            throw new Error(\n              `Service binding \"${service}\" is not available in the Worker environment`\n            );\n          }\n          return binding.fetch(request);\n        }\n      : undefined,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/adapters/deno.d.ts

@@ -0,0 +1,9 @@
+import { G as GatewayAdapter } from '../protocol-2fD3DJrL.js';
+import 'hono';
+import '../policies/sdk/trace.js';
+import '@vivero/stoma-core';
+
+/** Create a GatewayAdapter for Deno. Delegates to memoryAdapter() for in-memory stores. */
+declare function denoAdapter(): GatewayAdapter;
+
+export { denoAdapter };

package/dist/adapters/deno.js

@@ -0,0 +1,8 @@
+import { memoryAdapter } from "./memory";
+function denoAdapter() {
+  return memoryAdapter();
+}
+export {
+  denoAdapter
+};
+//# sourceMappingURL=deno.js.map

package/dist/adapters/deno.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/deno.ts"],"sourcesContent":["/**\n * Deno adapter for stoma.\n *\n * Deno Deploy doesn't provide `waitUntil` or service bindings natively.\n * Use `memoryAdapter()` for stores and this adapter as a marker/extension\n * point for Deno-specific capabilities.\n *\n * @example\n * ```ts\n * import { createGateway } from \"@vivero/stoma\";\n * import { denoAdapter } from \"@vivero/stoma/adapters/deno\";\n *\n * const gateway = createGateway({\n *   adapter: denoAdapter(),\n *   routes: [...]\n * });\n *\n * Deno.serve(gateway.app.fetch);\n * ```\n *\n * @module deno-adapter\n */\nimport { memoryAdapter } from \"./memory\";\nimport type { GatewayAdapter } from \"./types\";\n\n/** Create a GatewayAdapter for Deno. Delegates to memoryAdapter() for in-memory stores. */\nexport function denoAdapter(): GatewayAdapter {\n  return memoryAdapter();\n}\n"],"mappings":"AAsBA,SAAS,qBAAqB;AAIvB,SAAS,cAA8B;AAC5C,SAAO,cAAc;AACvB;","names":[]}

package/dist/adapters/durable-object.d.ts

@@ -0,0 +1,63 @@
+import { R as RateLimitStore } from '../protocol-2fD3DJrL.js';
+import 'hono';
+import '../policies/sdk/trace.js';
+import '@vivero/stoma-core';
+
+/**
+ * Durable Object that maintains an atomic rate limit counter.
+ *
+ * Each unique rate limit key maps to one DO instance via `idFromName(key)`.
+ * The counter auto-expires using the DO alarm API.
+ *
+ * **Consumer setup**: Export this class from your Worker entry point and
+ * reference it in `wrangler.jsonc`:
+ *
+ * ```jsonc
+ * {
+ *   "durable_objects": {
+ *     "bindings": [
+ *       {
+ *         "name": "RATE_LIMITER",
+ *         "class_name": "RateLimiterDO"
+ *       }
+ *     ]
+ *   }
+ * }
+ * ```
+ *
+ * ```ts
+ * // worker entry
+ * export { RateLimiterDO } from "@vivero/stoma/adapters";
+ * ```
+ */
+declare class RateLimiterDO implements DurableObject {
+    private state;
+    constructor(state: DurableObjectState);
+    fetch(request: Request): Promise<Response>;
+    alarm(): Promise<void>;
+}
+/**
+ * Rate limit store backed by a Durable Object.
+ *
+ * Each rate limit key maps to a unique DO instance, providing strongly
+ * consistent atomic counters that survive Worker eviction and work
+ * across isolates.
+ *
+ * @example
+ * ```ts
+ * import { DurableObjectRateLimitStore } from "@vivero/stoma/adapters";
+ *
+ * const store = new DurableObjectRateLimitStore(env.RATE_LIMITER);
+ * rateLimit({ max: 100, store });
+ * ```
+ */
+declare class DurableObjectRateLimitStore implements RateLimitStore {
+    private namespace;
+    constructor(namespace: DurableObjectNamespace);
+    increment(key: string, windowSeconds: number): Promise<{
+        count: number;
+        resetAt: number;
+    }>;
+}
+
+export { DurableObjectRateLimitStore, RateLimiterDO };

package/dist/adapters/durable-object.js

@@ -0,0 +1,46 @@
+class RateLimiterDO {
+  state;
+  constructor(state) {
+    this.state = state;
+  }
+  async fetch(request) {
+    const url = new URL(request.url);
+    const windowSeconds = Number(url.searchParams.get("window") ?? "60");
+    return this.state.blockConcurrencyWhile(async () => {
+      const now = Date.now();
+      const stored = await this.state.storage.get("counter");
+      if (stored && stored.resetAt > now) {
+        const updated = { count: stored.count + 1, resetAt: stored.resetAt };
+        await this.state.storage.put("counter", updated);
+        return Response.json(updated);
+      }
+      const resetAt = now + windowSeconds * 1e3;
+      const entry = { count: 1, resetAt };
+      await this.state.storage.put("counter", entry);
+      await this.state.storage.setAlarm(resetAt);
+      return Response.json(entry);
+    });
+  }
+  async alarm() {
+    await this.state.storage.delete("counter");
+  }
+}
+const DO_ORIGIN = "https://rate-limiter.internal";
+class DurableObjectRateLimitStore {
+  constructor(namespace) {
+    this.namespace = namespace;
+  }
+  async increment(key, windowSeconds) {
+    const id = this.namespace.idFromName(key);
+    const stub = this.namespace.get(id);
+    const response = await stub.fetch(
+      new Request(`${DO_ORIGIN}/increment?window=${windowSeconds}`)
+    );
+    return response.json();
+  }
+}
+export {
+  DurableObjectRateLimitStore,
+  RateLimiterDO
+};
+//# sourceMappingURL=durable-object.js.map

package/dist/adapters/durable-object.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/durable-object.ts"],"sourcesContent":["import type { RateLimitStore } from \"../policies/traffic/rate-limit\";\n\n// ---------------------------------------------------------------------------\n// Durable Object class - exported for the consumer's wrangler.jsonc\n// ---------------------------------------------------------------------------\n\n/**\n * Durable Object that maintains an atomic rate limit counter.\n *\n * Each unique rate limit key maps to one DO instance via `idFromName(key)`.\n * The counter auto-expires using the DO alarm API.\n *\n * **Consumer setup**: Export this class from your Worker entry point and\n * reference it in `wrangler.jsonc`:\n *\n * ```jsonc\n * {\n *   \"durable_objects\": {\n *     \"bindings\": [\n *       {\n *         \"name\": \"RATE_LIMITER\",\n *         \"class_name\": \"RateLimiterDO\"\n *       }\n *     ]\n *   }\n * }\n * ```\n *\n * ```ts\n * // worker entry\n * export { RateLimiterDO } from \"@vivero/stoma/adapters\";\n * ```\n */\nexport class RateLimiterDO implements DurableObject {\n  private state: DurableObjectState;\n\n  constructor(state: DurableObjectState) {\n    this.state = state;\n  }\n\n  async fetch(request: Request): Promise<Response> {\n    const url = new URL(request.url);\n    const windowSeconds = Number(url.searchParams.get(\"window\") ?? \"60\");\n\n    // Use blockConcurrencyWhile to ensure atomic increments.\n    // This serializes all concurrent requests to this DO instance,\n    // preventing the race condition where two requests read the same count\n    // and both write count+1, losing one increment.\n    return this.state.blockConcurrencyWhile(async () => {\n      const now = Date.now();\n      const stored = (await this.state.storage.get(\"counter\")) as {\n        count: number;\n        resetAt: number;\n      } | null;\n\n      if (stored && stored.resetAt > now) {\n        // Window still active - increment atomically\n        const updated = { count: stored.count + 1, resetAt: stored.resetAt };\n        await this.state.storage.put(\"counter\", updated);\n        return Response.json(updated);\n      }\n\n      // Start a new window\n      const resetAt = now + windowSeconds * 1000;\n      const entry = { count: 1, resetAt };\n      await this.state.storage.put(\"counter\", entry);\n      // Schedule alarm to clean up expired counter\n      await this.state.storage.setAlarm(resetAt);\n      return Response.json(entry);\n    });\n  }\n\n  async alarm(): Promise<void> {\n    // Clean up expired counter to free storage\n    await this.state.storage.delete(\"counter\");\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Client store - wraps the DO namespace for use with the rateLimit policy\n// ---------------------------------------------------------------------------\n\nconst DO_ORIGIN = \"https://rate-limiter.internal\";\n\n/**\n * Rate limit store backed by a Durable Object.\n *\n * Each rate limit key maps to a unique DO instance, providing strongly\n * consistent atomic counters that survive Worker eviction and work\n * across isolates.\n *\n * @example\n * ```ts\n * import { DurableObjectRateLimitStore } from \"@vivero/stoma/adapters\";\n *\n * const store = new DurableObjectRateLimitStore(env.RATE_LIMITER);\n * rateLimit({ max: 100, store });\n * ```\n */\nexport class DurableObjectRateLimitStore implements RateLimitStore {\n  constructor(private namespace: DurableObjectNamespace) {}\n\n  async increment(\n    key: string,\n    windowSeconds: number\n  ): Promise<{ count: number; resetAt: number }> {\n    const id = this.namespace.idFromName(key);\n    const stub = this.namespace.get(id);\n    const response = await stub.fetch(\n      new Request(`${DO_ORIGIN}/increment?window=${windowSeconds}`)\n    );\n    return response.json() as Promise<{ count: number; resetAt: number }>;\n  }\n}\n"],"mappings":"AAiCO,MAAM,cAAuC;AAAA,EAC1C;AAAA,EAER,YAAY,OAA2B;AACrC,SAAK,QAAQ;AAAA,EACf;AAAA,EAEA,MAAM,MAAM,SAAqC;AAC/C,UAAM,MAAM,IAAI,IAAI,QAAQ,GAAG;AAC/B,UAAM,gBAAgB,OAAO,IAAI,aAAa,IAAI,QAAQ,KAAK,IAAI;AAMnE,WAAO,KAAK,MAAM,sBAAsB,YAAY;AAClD,YAAM,MAAM,KAAK,IAAI;AACrB,YAAM,SAAU,MAAM,KAAK,MAAM,QAAQ,IAAI,SAAS;AAKtD,UAAI,UAAU,OAAO,UAAU,KAAK;AAElC,cAAM,UAAU,EAAE,OAAO,OAAO,QAAQ,GAAG,SAAS,OAAO,QAAQ;AACnE,cAAM,KAAK,MAAM,QAAQ,IAAI,WAAW,OAAO;AAC/C,eAAO,SAAS,KAAK,OAAO;AAAA,MAC9B;AAGA,YAAM,UAAU,MAAM,gBAAgB;AACtC,YAAM,QAAQ,EAAE,OAAO,GAAG,QAAQ;AAClC,YAAM,KAAK,MAAM,QAAQ,IAAI,WAAW,KAAK;AAE7C,YAAM,KAAK,MAAM,QAAQ,SAAS,OAAO;AACzC,aAAO,SAAS,KAAK,KAAK;AAAA,IAC5B,CAAC;AAAA,EACH;AAAA,EAEA,MAAM,QAAuB;AAE3B,UAAM,KAAK,MAAM,QAAQ,OAAO,SAAS;AAAA,EAC3C;AACF;AAMA,MAAM,YAAY;AAiBX,MAAM,4BAAsD;AAAA,EACjE,YAAoB,WAAmC;AAAnC;AAAA,EAAoC;AAAA,EAExD,MAAM,UACJ,KACA,eAC6C;AAC7C,UAAM,KAAK,KAAK,UAAU,WAAW,GAAG;AACxC,UAAM,OAAO,KAAK,UAAU,IAAI,EAAE;AAClC,UAAM,WAAW,MAAM,KAAK;AAAA,MAC1B,IAAI,QAAQ,GAAG,SAAS,qBAAqB,aAAa,EAAE;AAAA,IAC9D;AACA,WAAO,SAAS,KAAK;AAAA,EACvB;AACF;","names":[]}

package/dist/adapters/index.d.ts

@@ -0,0 +1,13 @@
+export { bunAdapter } from './bun.js';
+export { CacheApiCacheStore, CloudflareAdapterBindings, KVRateLimitStore, cloudflareAdapter } from './cloudflare.js';
+export { denoAdapter } from './deno.js';
+export { DurableObjectRateLimitStore, RateLimiterDO } from './durable-object.js';
+export { memoryAdapter } from './memory.js';
+export { nodeAdapter } from './node.js';
+export { POSTGRES_SCHEMA_SQL, PostgresAdapterConfig, PostgresCacheStore, PostgresCircuitBreakerStore, PostgresClient, PostgresRateLimitStore, postgresAdapter } from './postgres.js';
+export { RedisAdapterConfig, RedisCacheStore, RedisCircuitBreakerStore, RedisClient, RedisRateLimitStore, redisAdapter } from './redis.js';
+export { TestAdapter, createTestAdapter } from './testing.js';
+export { G as GatewayAdapter } from '../protocol-2fD3DJrL.js';
+import 'hono';
+import '../policies/sdk/trace.js';
+import '@vivero/stoma-core';

package/dist/adapters/index.js

@@ -0,0 +1,53 @@
+import { bunAdapter } from "./bun";
+import {
+  CacheApiCacheStore,
+  cloudflareAdapter,
+  KVRateLimitStore
+} from "./cloudflare";
+import { denoAdapter } from "./deno";
+import {
+  DurableObjectRateLimitStore,
+  RateLimiterDO
+} from "./durable-object";
+import { memoryAdapter } from "./memory";
+import { nodeAdapter } from "./node";
+import {
+  POSTGRES_SCHEMA_SQL,
+  PostgresCacheStore,
+  PostgresCircuitBreakerStore,
+  PostgresRateLimitStore,
+  postgresAdapter
+} from "./postgres";
+import {
+  RedisCacheStore,
+  RedisCircuitBreakerStore,
+  RedisRateLimitStore,
+  redisAdapter
+} from "./redis";
+import {
+  createTestAdapter,
+  TestAdapter
+} from "./testing";
+export {
+  CacheApiCacheStore,
+  DurableObjectRateLimitStore,
+  KVRateLimitStore,
+  POSTGRES_SCHEMA_SQL,
+  PostgresCacheStore,
+  PostgresCircuitBreakerStore,
+  PostgresRateLimitStore,
+  RateLimiterDO,
+  RedisCacheStore,
+  RedisCircuitBreakerStore,
+  RedisRateLimitStore,
+  TestAdapter,
+  bunAdapter,
+  cloudflareAdapter,
+  createTestAdapter,
+  denoAdapter,
+  memoryAdapter,
+  nodeAdapter,
+  postgresAdapter,
+  redisAdapter
+};
+//# sourceMappingURL=index.js.map

package/dist/adapters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/index.ts"],"sourcesContent":["/**\n * Runtime adapters for stoma - plug in platform-specific stores and capabilities.\n *\n * Stoma runs on any runtime that supports Hono (Cloudflare Workers, Deno, Bun,\n * Node.js, and more). Adapters provide the bridge between the gateway's\n * pluggable store interfaces (rate limiting, circuit breaker, cache) and each\n * runtime's native APIs.\n *\n * | Adapter              | Rate Limit Store         | Circuit Breaker Store | Cache Store       | `waitUntil` | `dispatchBinding` |\n * |----------------------|--------------------------|-----------------------|-------------------|-------------|-------------------|\n * | `cloudflareAdapter`  | KV or Durable Objects    | In-memory             | Cache API         | Yes         | Yes               |\n * | `redisAdapter`       | Redis (Lua)              | Redis (JSON)          | Redis (JSON)      | Optional    | No                |\n * | `postgresAdapter`    | PostgreSQL (upsert)      | PostgreSQL (upsert)   | PostgreSQL        | Optional    | No                |\n * | `memoryAdapter`      | In-memory                | In-memory             | In-memory         | No          | No                |\n * | `denoAdapter`        | (use memoryAdapter)      | (use memoryAdapter)   | (use memoryAdapter)| No         | No                |\n * | `bunAdapter`         | (use memoryAdapter)      | (use memoryAdapter)   | (use memoryAdapter)| No         | No                |\n * | `nodeAdapter`        | (use memoryAdapter)      | (use memoryAdapter)   | (use memoryAdapter)| No         | No                |\n *\n * For testing, use `createTestAdapter()` which collects `waitUntil` promises\n * so tests can `await adapter.waitAll()` before asserting.\n *\n * @example\n * ```ts\n * // Cloudflare Workers\n * import { cloudflareAdapter } from \"@vivero/stoma/adapters\";\n * createGateway({ adapter: cloudflareAdapter({ rateLimitKv: env.RATE_LIMIT, executionCtx: ctx }), ... });\n *\n * // Redis (Node.js / Bun / Deno)\n * import { redisAdapter } from \"@vivero/stoma/adapters\";\n * createGateway({ adapter: redisAdapter({ client: redis }), ... });\n *\n * // PostgreSQL (Node.js / Bun / Deno)\n * import { postgresAdapter } from \"@vivero/stoma/adapters\";\n * createGateway({ adapter: postgresAdapter({ client: pool }), ... });\n *\n * // Development / testing\n * import { memoryAdapter } from \"@vivero/stoma/adapters\";\n * createGateway({ adapter: memoryAdapter(), ... });\n * ```\n *\n * @module adapters\n */\n\n/** Create an adapter for Bun - marker/extension point for Bun-specific capabilities. */\nexport { bunAdapter } from \"./bun\";\n/** Bindings accepted by `cloudflareAdapter()` - KV, DO, Cache, ExecutionContext, and env. */\nexport type { CloudflareAdapterBindings } from \"./cloudflare\";\n/** Create a Cloudflare-native adapter with KV/DO rate limiting, Cache API caching, waitUntil, and service bindings. */\nexport {\n  /** Response cache backed by the Cloudflare Cache API. */\n  CacheApiCacheStore,\n  cloudflareAdapter,\n  /** Rate limit store backed by Cloudflare Workers KV (eventually consistent). */\n  KVRateLimitStore,\n} from \"./cloudflare\";\n/** Create an adapter for Deno Deploy - marker/extension point for Deno-specific capabilities. */\nexport { denoAdapter } from \"./deno\";\n/** Durable Object class for atomic rate limit counters - export from your Worker entry and reference in wrangler.jsonc. */\nexport {\n  /** Rate limit store backed by Cloudflare Durable Objects (strongly consistent). */\n  DurableObjectRateLimitStore,\n  RateLimiterDO,\n} from \"./durable-object\";\n/** Create an adapter using in-memory stores - suitable for development, demos, and testing. */\nexport { memoryAdapter } from \"./memory\";\n\n/** Create an adapter for Node.js (via `@hono/node-server`) - marker/extension point for Node-specific capabilities. */\nexport { nodeAdapter } from \"./node\";\n/** Config accepted by `postgresAdapter()` - client, table prefix, store toggles. */\nexport type { PostgresAdapterConfig, PostgresClient } from \"./postgres\";\n/** Create a PostgreSQL-backed adapter with upsert-based rate limiting, circuit breaker, and cache stores. */\nexport {\n  /** Exported SQL to create the required stoma tables. Run once against your database. */\n  POSTGRES_SCHEMA_SQL,\n  /** Response cache backed by PostgreSQL with base64-encoded body. */\n  PostgresCacheStore,\n  /** Circuit breaker state store backed by PostgreSQL. */\n  PostgresCircuitBreakerStore,\n  /** Rate limit store backed by PostgreSQL using atomic upsert. */\n  PostgresRateLimitStore,\n  postgresAdapter,\n} from \"./postgres\";\n/** Config accepted by `redisAdapter()` - client, prefix, setWithTTL override, store toggles. */\nexport type { RedisAdapterConfig, RedisClient } from \"./redis\";\n/** Create a Redis-backed adapter with Lua-based rate limiting, JSON circuit breaker, and JSON cache stores. */\nexport {\n  /** Response cache backed by Redis with base64-encoded body. */\n  RedisCacheStore,\n  /** Circuit breaker state store backed by Redis JSON strings. */\n  RedisCircuitBreakerStore,\n  /** Rate limit store backed by Redis with atomic Lua script. */\n  RedisRateLimitStore,\n  redisAdapter,\n} from \"./redis\";\n/** Test adapter that collects `waitUntil` promises for assertion in unit tests. */\nexport {\n  /** Factory function to create a new TestAdapter instance. */\n  createTestAdapter,\n  TestAdapter,\n} from \"./testing\";\n/** Runtime adapter interface - bag of optional store implementations and platform capabilities. */\nexport type { GatewayAdapter } from \"./types\";\n"],"mappings":"AA4CA,SAAS,kBAAkB;AAI3B;AAAA,EAEE;AAAA,EACA;AAAA,EAEA;AAAA,OACK;AAEP,SAAS,mBAAmB;AAE5B;AAAA,EAEE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,qBAAqB;AAG9B,SAAS,mBAAmB;AAI5B;AAAA,EAEE;AAAA,EAEA;AAAA,EAEA;AAAA,EAEA;AAAA,EACA;AAAA,OACK;AAIP;AAAA,EAEE;AAAA,EAEA;AAAA,EAEA;AAAA,EACA;AAAA,OACK;AAEP;AAAA,EAEE;AAAA,EACA;AAAA,OACK;","names":[]}

package/dist/adapters/memory.d.ts

@@ -0,0 +1,9 @@
+import { G as GatewayAdapter } from '../protocol-2fD3DJrL.js';
+import 'hono';
+import '../policies/sdk/trace.js';
+import '@vivero/stoma-core';
+
+/** Create a GatewayAdapter using in-memory stores. Suitable for dev/demo/testing. */
+declare function memoryAdapter(): GatewayAdapter;
+
+export { memoryAdapter };

package/dist/adapters/memory.js

@@ -0,0 +1,14 @@
+import { InMemoryCircuitBreakerStore } from "../policies/resilience/circuit-breaker";
+import { InMemoryCacheStore } from "../policies/traffic/cache";
+import { InMemoryRateLimitStore } from "../policies/traffic/rate-limit";
+function memoryAdapter() {
+  return {
+    rateLimitStore: new InMemoryRateLimitStore(),
+    circuitBreakerStore: new InMemoryCircuitBreakerStore(),
+    cacheStore: new InMemoryCacheStore()
+  };
+}
+export {
+  memoryAdapter
+};
+//# sourceMappingURL=memory.js.map

package/dist/adapters/memory.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/memory.ts"],"sourcesContent":["import { InMemoryCircuitBreakerStore } from \"../policies/resilience/circuit-breaker\";\nimport { InMemoryCacheStore } from \"../policies/traffic/cache\";\nimport { InMemoryRateLimitStore } from \"../policies/traffic/rate-limit\";\nimport type { GatewayAdapter } from \"./types\";\n\n/** Create a GatewayAdapter using in-memory stores. Suitable for dev/demo/testing. */\nexport function memoryAdapter(): GatewayAdapter {\n  return {\n    rateLimitStore: new InMemoryRateLimitStore(),\n    circuitBreakerStore: new InMemoryCircuitBreakerStore(),\n    cacheStore: new InMemoryCacheStore(),\n  };\n}\n"],"mappings":"AAAA,SAAS,mCAAmC;AAC5C,SAAS,0BAA0B;AACnC,SAAS,8BAA8B;AAIhC,SAAS,gBAAgC;AAC9C,SAAO;AAAA,IACL,gBAAgB,IAAI,uBAAuB;AAAA,IAC3C,qBAAqB,IAAI,4BAA4B;AAAA,IACrD,YAAY,IAAI,mBAAmB;AAAA,EACrC;AACF;","names":[]}

package/dist/adapters/node.d.ts

@@ -0,0 +1,9 @@
+import { G as GatewayAdapter } from '../protocol-2fD3DJrL.js';
+import 'hono';
+import '../policies/sdk/trace.js';
+import '@vivero/stoma-core';
+
+/** Create a GatewayAdapter for Node.js. Delegates to memoryAdapter() for in-memory stores. */
+declare function nodeAdapter(): GatewayAdapter;
+
+export { nodeAdapter };

package/dist/adapters/node.js

@@ -0,0 +1,8 @@
+import { memoryAdapter } from "./memory";
+function nodeAdapter() {
+  return memoryAdapter();
+}
+export {
+  nodeAdapter
+};
+//# sourceMappingURL=node.js.map

package/dist/adapters/node.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/node.ts"],"sourcesContent":["/**\n * Node.js adapter for stoma.\n *\n * Node.js (via `@hono/node-server`) doesn't provide `waitUntil` or\n * service bindings natively. Use `memoryAdapter()` for stores and this\n * adapter as a marker/extension point for Node-specific capabilities.\n *\n * @example\n * ```ts\n * import { createGateway } from \"@vivero/stoma\";\n * import { nodeAdapter } from \"@vivero/stoma/adapters/node\";\n * import { serve } from \"@hono/node-server\";\n *\n * const gateway = createGateway({\n *   adapter: nodeAdapter(),\n *   routes: [...]\n * });\n *\n * serve(gateway.app);\n * ```\n *\n * @module node-adapter\n */\nimport { memoryAdapter } from \"./memory\";\nimport type { GatewayAdapter } from \"./types\";\n\n/** Create a GatewayAdapter for Node.js. Delegates to memoryAdapter() for in-memory stores. */\nexport function nodeAdapter(): GatewayAdapter {\n  return memoryAdapter();\n}\n"],"mappings":"AAuBA,SAAS,qBAAqB;AAIvB,SAAS,cAA8B;AAC5C,SAAO,cAAc;AACvB;","names":[]}

package/dist/adapters/postgres.d.ts

@@ -0,0 +1,109 @@
+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';
+
+/**
+ * PostgreSQL-backed adapter for stoma - production-ready stores for Node.js, Bun, and Deno.
+ *
+ * Zero dependencies: define a minimal {@link PostgresClient} interface that any Postgres
+ * library (pg, postgres.js, etc.) satisfies, then pass it to {@link postgresAdapter}.
+ *
+ * @module adapters/postgres
+ */
+
+/**
+ * Minimal PostgreSQL client interface - satisfied by `pg`, `postgres.js`, and most
+ * Postgres libraries. Only a single `query` method is required.
+ */
+interface PostgresClient {
+    query(text: string, params?: unknown[]): Promise<{
+        rows: Record<string, unknown>[];
+    }>;
+}
+interface PostgresAdapterConfig {
+    /** PostgreSQL client instance (pg Pool, postgres.js, etc.). */
+    client: PostgresClient;
+    /** Table name prefix. Default: `"stoma_"`. */
+    tablePrefix?: string;
+    /** 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;
+}
+/**
+ * SQL to create the three stoma tables. Run this once against your database
+ * before using the Postgres adapter. All statements use `IF NOT EXISTS` so
+ * they're safe to re-run.
+ *
+ * @example
+ * ```ts
+ * import { POSTGRES_SCHEMA_SQL } from "@vivero/stoma/adapters/postgres";
+ * await pool.query(POSTGRES_SCHEMA_SQL);
+ * ```
+ */
+declare 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";
+/**
+ * Rate limit store backed by PostgreSQL using atomic upsert.
+ *
+ * Uses `INSERT ... ON CONFLICT DO UPDATE` with a `CASE` expression to
+ * atomically reset or increment the counter in a single query.
+ */
+declare class PostgresRateLimitStore implements RateLimitStore {
+    private client;
+    private table;
+    constructor(client: PostgresClient, table: string);
+    increment(key: string, windowSeconds: number): Promise<{
+        count: number;
+        resetAt: number;
+    }>;
+    /** Remove expired entries. Call periodically (e.g. via cron or waitUntil). */
+    cleanup(): Promise<void>;
+}
+/** Circuit breaker state store backed by PostgreSQL. */
+declare class PostgresCircuitBreakerStore implements CircuitBreakerStore {
+    private client;
+    private table;
+    constructor(client: PostgresClient, table: string);
+    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 PostgreSQL with base64-encoded body and expiry timestamp. */
+declare class PostgresCacheStore implements CacheStore {
+    private client;
+    private table;
+    constructor(client: PostgresClient, table: string);
+    get(key: string): Promise<Response | null>;
+    put(key: string, response: Response, ttlSeconds: number): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    /** Remove expired entries. Call periodically (e.g. via cron or waitUntil). */
+    cleanup(): Promise<void>;
+}
+/**
+ * Create a {@link GatewayAdapter} using PostgreSQL-backed stores.
+ *
+ * Before using, create the required tables by running {@link POSTGRES_SCHEMA_SQL}
+ * against your database.
+ *
+ * @example
+ * ```ts
+ * import { Pool } from "pg";
+ * import { postgresAdapter, POSTGRES_SCHEMA_SQL } from "@vivero/stoma/adapters/postgres";
+ *
+ * const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+ * await pool.query(POSTGRES_SCHEMA_SQL); // one-time setup
+ *
+ * const adapter = postgresAdapter({ client: pool });
+ * createGateway({ adapter, ... });
+ * ```
+ */
+declare function postgresAdapter(config: PostgresAdapterConfig): GatewayAdapter;
+
+export { POSTGRES_SCHEMA_SQL, type PostgresAdapterConfig, PostgresCacheStore, PostgresCircuitBreakerStore, type PostgresClient, PostgresRateLimitStore, postgresAdapter };