@agent-score/commerce 2.0.1 → 2.1.0

package/dist/middleware/express.d.mts

@@ -0,0 +1,10 @@
+import { R as RateLimitCoreOptions } from '../_core-kI7FRAiZ.mjs';
+import { Request, RequestHandler } from 'express';
+
+interface RateLimitExpressOptions extends RateLimitCoreOptions {
+    /** Bucket key resolver. Default: first hop of `x-forwarded-for`, else req.ip, else `'unknown'`. */
+    keyResolver?: (req: Request) => string;
+}
+declare function rateLimitExpress(opts?: RateLimitExpressOptions): RequestHandler;
+
+export { type RateLimitExpressOptions, rateLimitExpress };

package/dist/middleware/express.d.ts

@@ -0,0 +1,10 @@
+import { R as RateLimitCoreOptions } from '../_core-kI7FRAiZ.js';
+import { Request, RequestHandler } from 'express';
+
+interface RateLimitExpressOptions extends RateLimitCoreOptions {
+    /** Bucket key resolver. Default: first hop of `x-forwarded-for`, else req.ip, else `'unknown'`. */
+    keyResolver?: (req: Request) => string;
+}
+declare function rateLimitExpress(opts?: RateLimitExpressOptions): RequestHandler;
+
+export { type RateLimitExpressOptions, rateLimitExpress };

package/dist/middleware/express.js

@@ -0,0 +1,128 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/middleware/express.ts
+var express_exports = {};
+__export(express_exports, {
+  rateLimitExpress: () => rateLimitExpress
+});
+module.exports = __toCommonJS(express_exports);
+
+// src/_redis.ts
+async function tryCreateRedis(opts) {
+  const url = opts.url ?? process.env.REDIS_URL;
+  if (!url) return null;
+  try {
+    const mod = await import("ioredis");
+    const client = new mod.default(url, {
+      connectTimeout: opts.connectTimeout ?? 3e3,
+      maxRetriesPerRequest: opts.maxRetriesPerRequest ?? 1,
+      tls: url.startsWith("rediss://") ? {} : void 0
+    });
+    client.on("error", (err) => console.error(`[${opts.label}] Redis error:`, err.message));
+    return client;
+  } catch {
+    return null;
+  }
+}
+function memoizedRedis(opts) {
+  let promise = null;
+  return () => {
+    if (!promise) promise = tryCreateRedis(opts);
+    return promise;
+  };
+}
+
+// src/middleware/_core.ts
+function createRateLimiter(opts = {}) {
+  const windowSeconds = opts.windowSeconds ?? 60;
+  const maxRequests = opts.maxRequests ?? 60;
+  const keyPrefix = opts.keyPrefix ?? "rl:";
+  const memMap = /* @__PURE__ */ new Map();
+  const getRedis = memoizedRedis({ url: opts.redisUrl, label: "rate-limit" });
+  const checkMem = (key) => {
+    const now = Date.now();
+    const entry = memMap.get(key);
+    if (!entry || entry.resetAt < now) {
+      memMap.set(key, { count: 1, resetAt: now + windowSeconds * 1e3 });
+      return { allowed: true, remaining: maxRequests - 1, limit: maxRequests };
+    }
+    entry.count++;
+    const remaining = Math.max(0, maxRequests - entry.count);
+    return { allowed: entry.count <= maxRequests, remaining, limit: maxRequests };
+  };
+  return {
+    async check(key) {
+      const r = await getRedis();
+      if (!r) return checkMem(key);
+      try {
+        const fullKey = `${keyPrefix}${key}`;
+        const count = await r.incr(fullKey);
+        if (count === 1) await r.expire(fullKey, windowSeconds);
+        const remaining = Math.max(0, maxRequests - count);
+        return { allowed: count <= maxRequests, remaining, limit: maxRequests };
+      } catch {
+        return checkMem(key);
+      }
+    }
+  };
+}
+var RATE_LIMIT_JSON_BODY = {
+  error: { code: "rate_limited", message: "Too many requests" }
+};
+function defaultKeyFromForwardedFor(forwardedFor) {
+  if (!forwardedFor) return "unknown";
+  return forwardedFor.split(",")[0]?.trim() || "unknown";
+}
+
+// src/middleware/express.ts
+function rateLimitExpress(opts = {}) {
+  const limiter = createRateLimiter(opts);
+  const keyResolver = opts.keyResolver ?? ((req) => {
+    const forwarded = req.header("x-forwarded-for");
+    if (forwarded) return defaultKeyFromForwardedFor(forwarded);
+    return req.ip ?? "unknown";
+  });
+  return async (req, res, next) => {
+    const { allowed, remaining, limit } = await limiter.check(keyResolver(req));
+    res.setHeader("X-RateLimit-Limit", String(limit));
+    res.setHeader("X-RateLimit-Remaining", String(remaining));
+    if (!allowed) {
+      res.setHeader("Cache-Control", "no-store");
+      res.status(429).json(RATE_LIMIT_JSON_BODY);
+      return;
+    }
+    next();
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rateLimitExpress
+});
+//# sourceMappingURL=express.js.map

package/dist/middleware/express.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/middleware/express.ts","../../src/_redis.ts","../../src/middleware/_core.ts"],"sourcesContent":["import {\n  RATE_LIMIT_JSON_BODY,\n  createRateLimiter,\n  defaultKeyFromForwardedFor,\n  type RateLimitCoreOptions,\n} from './_core';\nimport type { NextFunction, Request, RequestHandler, Response } from 'express';\n\nexport interface RateLimitExpressOptions extends RateLimitCoreOptions {\n  /** Bucket key resolver. Default: first hop of `x-forwarded-for`, else req.ip, else `'unknown'`. */\n  keyResolver?: (req: Request) => string;\n}\n\nexport function rateLimitExpress(opts: RateLimitExpressOptions = {}): RequestHandler {\n  const limiter = createRateLimiter(opts);\n  const keyResolver =\n    opts.keyResolver ??\n    ((req: Request): string => {\n      const forwarded = req.header('x-forwarded-for');\n      if (forwarded) return defaultKeyFromForwardedFor(forwarded);\n      return req.ip ?? 'unknown';\n    });\n\n  return async (req: Request, res: Response, next: NextFunction) => {\n    const { allowed, remaining, limit } = await limiter.check(keyResolver(req));\n    res.setHeader('X-RateLimit-Limit', String(limit));\n    res.setHeader('X-RateLimit-Remaining', String(remaining));\n    if (!allowed) {\n      res.setHeader('Cache-Control', 'no-store');\n      res.status(429).json(RATE_LIMIT_JSON_BODY);\n      return;\n    }\n    next();\n  };\n}\n","/** Shared lazy `ioredis` factory. Used by `quote_cache`, `middleware/_core`,\n *  and `stripe-multichain/pi-cache` so they don't drift on connect-timeout,\n *  TLS handling, or error-logging posture.\n *\n *  `ioredis` is an optional peer dep — callers pass `redisUrl` (or rely on\n *  `process.env.REDIS_URL`); when unset or the lazy import fails, this returns\n *  null and the caller falls back to its in-process `Map`.\n *\n *  Not part of the public API.\n */\n\n/** Minimal Redis surface — each caller intersects with its own usage\n *  (incr/expire for rate-limit, get/set/del for caches). Returning `unknown`\n *  on commands keeps the shape narrow; cast at the call site. */\nexport interface MinimalRedis {\n  on(event: 'error', handler: (err: Error) => void): unknown;\n}\n\nexport interface CreateRedisOptions {\n  /** Override `process.env.REDIS_URL` for tests. */\n  url?: string;\n  /** Logging label, e.g. `'quote-cache'` / `'rate-limit'` / `'pi-cache'`. */\n  label: string;\n  /** Connect timeout in ms. Default `3000`. */\n  connectTimeout?: number;\n  /** Per-request retry cap. Default `1`. */\n  maxRetriesPerRequest?: number;\n}\n\n/** Lazy-import ioredis and construct a client. Returns null when:\n *   - no URL is configured (caller falls back to in-memory)\n *   - `ioredis` isn't installed (optional peer; caller falls back to in-memory)\n *   - the import throws for any other reason\n *\n *  `rediss://` URLs auto-enable TLS. The error handler logs with the caller's\n *  label so multi-cache deployments can tell which subsystem complained. */\nasync function tryCreateRedis<T extends MinimalRedis>(opts: CreateRedisOptions): Promise<T | null> {\n  const url = opts.url ?? process.env.REDIS_URL;\n  if (!url) return null;\n  try {\n    const mod = (await import('ioredis')) as unknown as { default: new (url: string, opts?: unknown) => T };\n    const client = new mod.default(url, {\n      connectTimeout: opts.connectTimeout ?? 3000,\n      maxRetriesPerRequest: opts.maxRetriesPerRequest ?? 1,\n      tls: url.startsWith('rediss://') ? {} : undefined,\n    });\n    client.on('error', (err) => console.error(`[${opts.label}] Redis error:`, err.message));\n    return client;\n  } catch {\n    return null;\n  }\n}\n\n/** Memoized-promise variant: call once per caller; subsequent calls return the\n *  same promise. Pairs with the pattern `let p: Promise<T|null> | null = null;\n *  const getRedis = () => (p ??= tryCreateRedis(...))` in callers that want\n *  per-call promise caching without managing the closure themselves. */\nexport function memoizedRedis<T extends MinimalRedis>(opts: CreateRedisOptions): () => Promise<T | null> {\n  let promise: Promise<T | null> | null = null;\n  return () => {\n    if (!promise) promise = tryCreateRedis<T>(opts);\n    return promise;\n  };\n}\n","import { memoizedRedis, type MinimalRedis } from '../_redis';\n\nexport interface RateLimitCoreOptions {\n  windowSeconds?: number;\n  maxRequests?: number;\n  /** Redis connection URL. Default: `process.env.REDIS_URL`. Falls back to in-memory when unset or the lazy `ioredis` import fails. */\n  redisUrl?: string;\n  /** Per-instance key prefix so multiple limiters sharing a Redis don't collide. */\n  keyPrefix?: string;\n}\n\nexport interface RateLimitDecision {\n  allowed: boolean;\n  remaining: number;\n  limit: number;\n}\n\nexport interface RateLimiter {\n  check(key: string): Promise<RateLimitDecision>;\n}\n\ninterface RedisLike extends MinimalRedis {\n  incr(key: string): Promise<number>;\n  expire(key: string, seconds: number): Promise<unknown>;\n}\n\n/** Framework-agnostic rate limiter. Hono / Express / Fastify / Next.js / Web adapters\n *  share one core. Each `createRateLimiter` call owns its own memory map + redis\n *  connection, so multiple instances in the same process don't share state unless\n *  they share a Redis with the same `keyPrefix`. */\nexport function createRateLimiter(opts: RateLimitCoreOptions = {}): RateLimiter {\n  const windowSeconds = opts.windowSeconds ?? 60;\n  const maxRequests = opts.maxRequests ?? 60;\n  const keyPrefix = opts.keyPrefix ?? 'rl:';\n\n  const memMap = new Map<string, { count: number; resetAt: number }>();\n  const getRedis = memoizedRedis<RedisLike>({ url: opts.redisUrl, label: 'rate-limit' });\n\n  const checkMem = (key: string): RateLimitDecision => {\n    const now = Date.now();\n    const entry = memMap.get(key);\n    if (!entry || entry.resetAt < now) {\n      memMap.set(key, { count: 1, resetAt: now + windowSeconds * 1000 });\n      return { allowed: true, remaining: maxRequests - 1, limit: maxRequests };\n    }\n    entry.count++;\n    const remaining = Math.max(0, maxRequests - entry.count);\n    return { allowed: entry.count <= maxRequests, remaining, limit: maxRequests };\n  };\n\n  return {\n    async check(key: string): Promise<RateLimitDecision> {\n      const r = await getRedis();\n      if (!r) return checkMem(key);\n      try {\n        const fullKey = `${keyPrefix}${key}`;\n        const count = await r.incr(fullKey);\n        if (count === 1) await r.expire(fullKey, windowSeconds);\n        const remaining = Math.max(0, maxRequests - count);\n        return { allowed: count <= maxRequests, remaining, limit: maxRequests };\n      } catch {\n        return checkMem(key);\n      }\n    },\n  };\n}\n\nexport const RATE_LIMIT_JSON_BODY = {\n  error: { code: 'rate_limited', message: 'Too many requests' },\n} as const;\n\n/** Default key resolver: first hop of `x-forwarded-for`, else `'unknown'`. Works on any\n *  framework's request once you adapt the header read. */\nexport function defaultKeyFromForwardedFor(forwardedFor: string | null | undefined): string {\n  if (!forwardedFor) return 'unknown';\n  return forwardedFor.split(',')[0]?.trim() || 'unknown';\n}\n"],"mappings":"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","names":[]}

package/dist/middleware/express.mjs

@@ -0,0 +1,91 @@
+// src/_redis.ts
+async function tryCreateRedis(opts) {
+  const url = opts.url ?? process.env.REDIS_URL;
+  if (!url) return null;
+  try {
+    const mod = await import("ioredis");
+    const client = new mod.default(url, {
+      connectTimeout: opts.connectTimeout ?? 3e3,
+      maxRetriesPerRequest: opts.maxRetriesPerRequest ?? 1,
+      tls: url.startsWith("rediss://") ? {} : void 0
+    });
+    client.on("error", (err) => console.error(`[${opts.label}] Redis error:`, err.message));
+    return client;
+  } catch {
+    return null;
+  }
+}
+function memoizedRedis(opts) {
+  let promise = null;
+  return () => {
+    if (!promise) promise = tryCreateRedis(opts);
+    return promise;
+  };
+}
+
+// src/middleware/_core.ts
+function createRateLimiter(opts = {}) {
+  const windowSeconds = opts.windowSeconds ?? 60;
+  const maxRequests = opts.maxRequests ?? 60;
+  const keyPrefix = opts.keyPrefix ?? "rl:";
+  const memMap = /* @__PURE__ */ new Map();
+  const getRedis = memoizedRedis({ url: opts.redisUrl, label: "rate-limit" });
+  const checkMem = (key) => {
+    const now = Date.now();
+    const entry = memMap.get(key);
+    if (!entry || entry.resetAt < now) {
+      memMap.set(key, { count: 1, resetAt: now + windowSeconds * 1e3 });
+      return { allowed: true, remaining: maxRequests - 1, limit: maxRequests };
+    }
+    entry.count++;
+    const remaining = Math.max(0, maxRequests - entry.count);
+    return { allowed: entry.count <= maxRequests, remaining, limit: maxRequests };
+  };
+  return {
+    async check(key) {
+      const r = await getRedis();
+      if (!r) return checkMem(key);
+      try {
+        const fullKey = `${keyPrefix}${key}`;
+        const count = await r.incr(fullKey);
+        if (count === 1) await r.expire(fullKey, windowSeconds);
+        const remaining = Math.max(0, maxRequests - count);
+        return { allowed: count <= maxRequests, remaining, limit: maxRequests };
+      } catch {
+        return checkMem(key);
+      }
+    }
+  };
+}
+var RATE_LIMIT_JSON_BODY = {
+  error: { code: "rate_limited", message: "Too many requests" }
+};
+function defaultKeyFromForwardedFor(forwardedFor) {
+  if (!forwardedFor) return "unknown";
+  return forwardedFor.split(",")[0]?.trim() || "unknown";
+}
+
+// src/middleware/express.ts
+function rateLimitExpress(opts = {}) {
+  const limiter = createRateLimiter(opts);
+  const keyResolver = opts.keyResolver ?? ((req) => {
+    const forwarded = req.header("x-forwarded-for");
+    if (forwarded) return defaultKeyFromForwardedFor(forwarded);
+    return req.ip ?? "unknown";
+  });
+  return async (req, res, next) => {
+    const { allowed, remaining, limit } = await limiter.check(keyResolver(req));
+    res.setHeader("X-RateLimit-Limit", String(limit));
+    res.setHeader("X-RateLimit-Remaining", String(remaining));
+    if (!allowed) {
+      res.setHeader("Cache-Control", "no-store");
+      res.status(429).json(RATE_LIMIT_JSON_BODY);
+      return;
+    }
+    next();
+  };
+}
+export {
+  rateLimitExpress
+};
+//# sourceMappingURL=express.mjs.map

package/dist/middleware/express.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/_redis.ts","../../src/middleware/_core.ts","../../src/middleware/express.ts"],"sourcesContent":["/** Shared lazy `ioredis` factory. Used by `quote_cache`, `middleware/_core`,\n *  and `stripe-multichain/pi-cache` so they don't drift on connect-timeout,\n *  TLS handling, or error-logging posture.\n *\n *  `ioredis` is an optional peer dep — callers pass `redisUrl` (or rely on\n *  `process.env.REDIS_URL`); when unset or the lazy import fails, this returns\n *  null and the caller falls back to its in-process `Map`.\n *\n *  Not part of the public API.\n */\n\n/** Minimal Redis surface — each caller intersects with its own usage\n *  (incr/expire for rate-limit, get/set/del for caches). Returning `unknown`\n *  on commands keeps the shape narrow; cast at the call site. */\nexport interface MinimalRedis {\n  on(event: 'error', handler: (err: Error) => void): unknown;\n}\n\nexport interface CreateRedisOptions {\n  /** Override `process.env.REDIS_URL` for tests. */\n  url?: string;\n  /** Logging label, e.g. `'quote-cache'` / `'rate-limit'` / `'pi-cache'`. */\n  label: string;\n  /** Connect timeout in ms. Default `3000`. */\n  connectTimeout?: number;\n  /** Per-request retry cap. Default `1`. */\n  maxRetriesPerRequest?: number;\n}\n\n/** Lazy-import ioredis and construct a client. Returns null when:\n *   - no URL is configured (caller falls back to in-memory)\n *   - `ioredis` isn't installed (optional peer; caller falls back to in-memory)\n *   - the import throws for any other reason\n *\n *  `rediss://` URLs auto-enable TLS. The error handler logs with the caller's\n *  label so multi-cache deployments can tell which subsystem complained. */\nasync function tryCreateRedis<T extends MinimalRedis>(opts: CreateRedisOptions): Promise<T | null> {\n  const url = opts.url ?? process.env.REDIS_URL;\n  if (!url) return null;\n  try {\n    const mod = (await import('ioredis')) as unknown as { default: new (url: string, opts?: unknown) => T };\n    const client = new mod.default(url, {\n      connectTimeout: opts.connectTimeout ?? 3000,\n      maxRetriesPerRequest: opts.maxRetriesPerRequest ?? 1,\n      tls: url.startsWith('rediss://') ? {} : undefined,\n    });\n    client.on('error', (err) => console.error(`[${opts.label}] Redis error:`, err.message));\n    return client;\n  } catch {\n    return null;\n  }\n}\n\n/** Memoized-promise variant: call once per caller; subsequent calls return the\n *  same promise. Pairs with the pattern `let p: Promise<T|null> | null = null;\n *  const getRedis = () => (p ??= tryCreateRedis(...))` in callers that want\n *  per-call promise caching without managing the closure themselves. */\nexport function memoizedRedis<T extends MinimalRedis>(opts: CreateRedisOptions): () => Promise<T | null> {\n  let promise: Promise<T | null> | null = null;\n  return () => {\n    if (!promise) promise = tryCreateRedis<T>(opts);\n    return promise;\n  };\n}\n","import { memoizedRedis, type MinimalRedis } from '../_redis';\n\nexport interface RateLimitCoreOptions {\n  windowSeconds?: number;\n  maxRequests?: number;\n  /** Redis connection URL. Default: `process.env.REDIS_URL`. Falls back to in-memory when unset or the lazy `ioredis` import fails. */\n  redisUrl?: string;\n  /** Per-instance key prefix so multiple limiters sharing a Redis don't collide. */\n  keyPrefix?: string;\n}\n\nexport interface RateLimitDecision {\n  allowed: boolean;\n  remaining: number;\n  limit: number;\n}\n\nexport interface RateLimiter {\n  check(key: string): Promise<RateLimitDecision>;\n}\n\ninterface RedisLike extends MinimalRedis {\n  incr(key: string): Promise<number>;\n  expire(key: string, seconds: number): Promise<unknown>;\n}\n\n/** Framework-agnostic rate limiter. Hono / Express / Fastify / Next.js / Web adapters\n *  share one core. Each `createRateLimiter` call owns its own memory map + redis\n *  connection, so multiple instances in the same process don't share state unless\n *  they share a Redis with the same `keyPrefix`. */\nexport function createRateLimiter(opts: RateLimitCoreOptions = {}): RateLimiter {\n  const windowSeconds = opts.windowSeconds ?? 60;\n  const maxRequests = opts.maxRequests ?? 60;\n  const keyPrefix = opts.keyPrefix ?? 'rl:';\n\n  const memMap = new Map<string, { count: number; resetAt: number }>();\n  const getRedis = memoizedRedis<RedisLike>({ url: opts.redisUrl, label: 'rate-limit' });\n\n  const checkMem = (key: string): RateLimitDecision => {\n    const now = Date.now();\n    const entry = memMap.get(key);\n    if (!entry || entry.resetAt < now) {\n      memMap.set(key, { count: 1, resetAt: now + windowSeconds * 1000 });\n      return { allowed: true, remaining: maxRequests - 1, limit: maxRequests };\n    }\n    entry.count++;\n    const remaining = Math.max(0, maxRequests - entry.count);\n    return { allowed: entry.count <= maxRequests, remaining, limit: maxRequests };\n  };\n\n  return {\n    async check(key: string): Promise<RateLimitDecision> {\n      const r = await getRedis();\n      if (!r) return checkMem(key);\n      try {\n        const fullKey = `${keyPrefix}${key}`;\n        const count = await r.incr(fullKey);\n        if (count === 1) await r.expire(fullKey, windowSeconds);\n        const remaining = Math.max(0, maxRequests - count);\n        return { allowed: count <= maxRequests, remaining, limit: maxRequests };\n      } catch {\n        return checkMem(key);\n      }\n    },\n  };\n}\n\nexport const RATE_LIMIT_JSON_BODY = {\n  error: { code: 'rate_limited', message: 'Too many requests' },\n} as const;\n\n/** Default key resolver: first hop of `x-forwarded-for`, else `'unknown'`. Works on any\n *  framework's request once you adapt the header read. */\nexport function defaultKeyFromForwardedFor(forwardedFor: string | null | undefined): string {\n  if (!forwardedFor) return 'unknown';\n  return forwardedFor.split(',')[0]?.trim() || 'unknown';\n}\n","import {\n  RATE_LIMIT_JSON_BODY,\n  createRateLimiter,\n  defaultKeyFromForwardedFor,\n  type RateLimitCoreOptions,\n} from './_core';\nimport type { NextFunction, Request, RequestHandler, Response } from 'express';\n\nexport interface RateLimitExpressOptions extends RateLimitCoreOptions {\n  /** Bucket key resolver. Default: first hop of `x-forwarded-for`, else req.ip, else `'unknown'`. */\n  keyResolver?: (req: Request) => string;\n}\n\nexport function rateLimitExpress(opts: RateLimitExpressOptions = {}): RequestHandler {\n  const limiter = createRateLimiter(opts);\n  const keyResolver =\n    opts.keyResolver ??\n    ((req: Request): string => {\n      const forwarded = req.header('x-forwarded-for');\n      if (forwarded) return defaultKeyFromForwardedFor(forwarded);\n      return req.ip ?? 'unknown';\n    });\n\n  return async (req: Request, res: Response, next: NextFunction) => {\n    const { allowed, remaining, limit } = await limiter.check(keyResolver(req));\n    res.setHeader('X-RateLimit-Limit', String(limit));\n    res.setHeader('X-RateLimit-Remaining', String(remaining));\n    if (!allowed) {\n      res.setHeader('Cache-Control', 'no-store');\n      res.status(429).json(RATE_LIMIT_JSON_BODY);\n      return;\n    }\n    next();\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/middleware/fastify.d.mts

@@ -0,0 +1,10 @@
+import { R as RateLimitCoreOptions } from '../_core-kI7FRAiZ.mjs';
+import { FastifyRequest, preHandlerHookHandler } from 'fastify';
+
+interface RateLimitFastifyOptions extends RateLimitCoreOptions {
+    /** Bucket key resolver. Default: first hop of `x-forwarded-for`, else `req.ip`, else `'unknown'`. */
+    keyResolver?: (req: FastifyRequest) => string;
+}
+declare function rateLimitFastify(opts?: RateLimitFastifyOptions): preHandlerHookHandler;
+
+export { type RateLimitFastifyOptions, rateLimitFastify };

package/dist/middleware/fastify.d.ts

@@ -0,0 +1,10 @@
+import { R as RateLimitCoreOptions } from '../_core-kI7FRAiZ.js';
+import { FastifyRequest, preHandlerHookHandler } from 'fastify';
+
+interface RateLimitFastifyOptions extends RateLimitCoreOptions {
+    /** Bucket key resolver. Default: first hop of `x-forwarded-for`, else `req.ip`, else `'unknown'`. */
+    keyResolver?: (req: FastifyRequest) => string;
+}
+declare function rateLimitFastify(opts?: RateLimitFastifyOptions): preHandlerHookHandler;
+
+export { type RateLimitFastifyOptions, rateLimitFastify };

package/dist/middleware/fastify.js

@@ -0,0 +1,127 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/middleware/fastify.ts
+var fastify_exports = {};
+__export(fastify_exports, {
+  rateLimitFastify: () => rateLimitFastify
+});
+module.exports = __toCommonJS(fastify_exports);
+
+// src/_redis.ts
+async function tryCreateRedis(opts) {
+  const url = opts.url ?? process.env.REDIS_URL;
+  if (!url) return null;
+  try {
+    const mod = await import("ioredis");
+    const client = new mod.default(url, {
+      connectTimeout: opts.connectTimeout ?? 3e3,
+      maxRetriesPerRequest: opts.maxRetriesPerRequest ?? 1,
+      tls: url.startsWith("rediss://") ? {} : void 0
+    });
+    client.on("error", (err) => console.error(`[${opts.label}] Redis error:`, err.message));
+    return client;
+  } catch {
+    return null;
+  }
+}
+function memoizedRedis(opts) {
+  let promise = null;
+  return () => {
+    if (!promise) promise = tryCreateRedis(opts);
+    return promise;
+  };
+}
+
+// src/middleware/_core.ts
+function createRateLimiter(opts = {}) {
+  const windowSeconds = opts.windowSeconds ?? 60;
+  const maxRequests = opts.maxRequests ?? 60;
+  const keyPrefix = opts.keyPrefix ?? "rl:";
+  const memMap = /* @__PURE__ */ new Map();
+  const getRedis = memoizedRedis({ url: opts.redisUrl, label: "rate-limit" });
+  const checkMem = (key) => {
+    const now = Date.now();
+    const entry = memMap.get(key);
+    if (!entry || entry.resetAt < now) {
+      memMap.set(key, { count: 1, resetAt: now + windowSeconds * 1e3 });
+      return { allowed: true, remaining: maxRequests - 1, limit: maxRequests };
+    }
+    entry.count++;
+    const remaining = Math.max(0, maxRequests - entry.count);
+    return { allowed: entry.count <= maxRequests, remaining, limit: maxRequests };
+  };
+  return {
+    async check(key) {
+      const r = await getRedis();
+      if (!r) return checkMem(key);
+      try {
+        const fullKey = `${keyPrefix}${key}`;
+        const count = await r.incr(fullKey);
+        if (count === 1) await r.expire(fullKey, windowSeconds);
+        const remaining = Math.max(0, maxRequests - count);
+        return { allowed: count <= maxRequests, remaining, limit: maxRequests };
+      } catch {
+        return checkMem(key);
+      }
+    }
+  };
+}
+var RATE_LIMIT_JSON_BODY = {
+  error: { code: "rate_limited", message: "Too many requests" }
+};
+function defaultKeyFromForwardedFor(forwardedFor) {
+  if (!forwardedFor) return "unknown";
+  return forwardedFor.split(",")[0]?.trim() || "unknown";
+}
+
+// src/middleware/fastify.ts
+function rateLimitFastify(opts = {}) {
+  const limiter = createRateLimiter(opts);
+  const keyResolver = opts.keyResolver ?? ((req) => {
+    const forwarded = req.headers["x-forwarded-for"];
+    const forwardedStr = Array.isArray(forwarded) ? forwarded[0] : forwarded;
+    if (forwardedStr) return defaultKeyFromForwardedFor(forwardedStr);
+    return req.ip ?? "unknown";
+  });
+  return async (req, reply) => {
+    const { allowed, remaining, limit } = await limiter.check(keyResolver(req));
+    reply.header("X-RateLimit-Limit", String(limit));
+    reply.header("X-RateLimit-Remaining", String(remaining));
+    if (!allowed) {
+      reply.header("Cache-Control", "no-store");
+      reply.code(429).send(RATE_LIMIT_JSON_BODY);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rateLimitFastify
+});
+//# sourceMappingURL=fastify.js.map

package/dist/middleware/fastify.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/middleware/fastify.ts","../../src/_redis.ts","../../src/middleware/_core.ts"],"sourcesContent":["import {\n  RATE_LIMIT_JSON_BODY,\n  createRateLimiter,\n  defaultKeyFromForwardedFor,\n  type RateLimitCoreOptions,\n} from './_core';\nimport type { FastifyReply, FastifyRequest, preHandlerHookHandler } from 'fastify';\n\nexport interface RateLimitFastifyOptions extends RateLimitCoreOptions {\n  /** Bucket key resolver. Default: first hop of `x-forwarded-for`, else `req.ip`, else `'unknown'`. */\n  keyResolver?: (req: FastifyRequest) => string;\n}\n\nexport function rateLimitFastify(opts: RateLimitFastifyOptions = {}): preHandlerHookHandler {\n  const limiter = createRateLimiter(opts);\n  const keyResolver =\n    opts.keyResolver ??\n    ((req: FastifyRequest): string => {\n      const forwarded = req.headers['x-forwarded-for'];\n      const forwardedStr = Array.isArray(forwarded) ? forwarded[0] : forwarded;\n      if (forwardedStr) return defaultKeyFromForwardedFor(forwardedStr);\n      return req.ip ?? 'unknown';\n    });\n\n  return async (req: FastifyRequest, reply: FastifyReply) => {\n    const { allowed, remaining, limit } = await limiter.check(keyResolver(req));\n    reply.header('X-RateLimit-Limit', String(limit));\n    reply.header('X-RateLimit-Remaining', String(remaining));\n    if (!allowed) {\n      reply.header('Cache-Control', 'no-store');\n      reply.code(429).send(RATE_LIMIT_JSON_BODY);\n    }\n  };\n}\n","/** Shared lazy `ioredis` factory. Used by `quote_cache`, `middleware/_core`,\n *  and `stripe-multichain/pi-cache` so they don't drift on connect-timeout,\n *  TLS handling, or error-logging posture.\n *\n *  `ioredis` is an optional peer dep — callers pass `redisUrl` (or rely on\n *  `process.env.REDIS_URL`); when unset or the lazy import fails, this returns\n *  null and the caller falls back to its in-process `Map`.\n *\n *  Not part of the public API.\n */\n\n/** Minimal Redis surface — each caller intersects with its own usage\n *  (incr/expire for rate-limit, get/set/del for caches). Returning `unknown`\n *  on commands keeps the shape narrow; cast at the call site. */\nexport interface MinimalRedis {\n  on(event: 'error', handler: (err: Error) => void): unknown;\n}\n\nexport interface CreateRedisOptions {\n  /** Override `process.env.REDIS_URL` for tests. */\n  url?: string;\n  /** Logging label, e.g. `'quote-cache'` / `'rate-limit'` / `'pi-cache'`. */\n  label: string;\n  /** Connect timeout in ms. Default `3000`. */\n  connectTimeout?: number;\n  /** Per-request retry cap. Default `1`. */\n  maxRetriesPerRequest?: number;\n}\n\n/** Lazy-import ioredis and construct a client. Returns null when:\n *   - no URL is configured (caller falls back to in-memory)\n *   - `ioredis` isn't installed (optional peer; caller falls back to in-memory)\n *   - the import throws for any other reason\n *\n *  `rediss://` URLs auto-enable TLS. The error handler logs with the caller's\n *  label so multi-cache deployments can tell which subsystem complained. */\nasync function tryCreateRedis<T extends MinimalRedis>(opts: CreateRedisOptions): Promise<T | null> {\n  const url = opts.url ?? process.env.REDIS_URL;\n  if (!url) return null;\n  try {\n    const mod = (await import('ioredis')) as unknown as { default: new (url: string, opts?: unknown) => T };\n    const client = new mod.default(url, {\n      connectTimeout: opts.connectTimeout ?? 3000,\n      maxRetriesPerRequest: opts.maxRetriesPerRequest ?? 1,\n      tls: url.startsWith('rediss://') ? {} : undefined,\n    });\n    client.on('error', (err) => console.error(`[${opts.label}] Redis error:`, err.message));\n    return client;\n  } catch {\n    return null;\n  }\n}\n\n/** Memoized-promise variant: call once per caller; subsequent calls return the\n *  same promise. Pairs with the pattern `let p: Promise<T|null> | null = null;\n *  const getRedis = () => (p ??= tryCreateRedis(...))` in callers that want\n *  per-call promise caching without managing the closure themselves. */\nexport function memoizedRedis<T extends MinimalRedis>(opts: CreateRedisOptions): () => Promise<T | null> {\n  let promise: Promise<T | null> | null = null;\n  return () => {\n    if (!promise) promise = tryCreateRedis<T>(opts);\n    return promise;\n  };\n}\n","import { memoizedRedis, type MinimalRedis } from '../_redis';\n\nexport interface RateLimitCoreOptions {\n  windowSeconds?: number;\n  maxRequests?: number;\n  /** Redis connection URL. Default: `process.env.REDIS_URL`. Falls back to in-memory when unset or the lazy `ioredis` import fails. */\n  redisUrl?: string;\n  /** Per-instance key prefix so multiple limiters sharing a Redis don't collide. */\n  keyPrefix?: string;\n}\n\nexport interface RateLimitDecision {\n  allowed: boolean;\n  remaining: number;\n  limit: number;\n}\n\nexport interface RateLimiter {\n  check(key: string): Promise<RateLimitDecision>;\n}\n\ninterface RedisLike extends MinimalRedis {\n  incr(key: string): Promise<number>;\n  expire(key: string, seconds: number): Promise<unknown>;\n}\n\n/** Framework-agnostic rate limiter. Hono / Express / Fastify / Next.js / Web adapters\n *  share one core. Each `createRateLimiter` call owns its own memory map + redis\n *  connection, so multiple instances in the same process don't share state unless\n *  they share a Redis with the same `keyPrefix`. */\nexport function createRateLimiter(opts: RateLimitCoreOptions = {}): RateLimiter {\n  const windowSeconds = opts.windowSeconds ?? 60;\n  const maxRequests = opts.maxRequests ?? 60;\n  const keyPrefix = opts.keyPrefix ?? 'rl:';\n\n  const memMap = new Map<string, { count: number; resetAt: number }>();\n  const getRedis = memoizedRedis<RedisLike>({ url: opts.redisUrl, label: 'rate-limit' });\n\n  const checkMem = (key: string): RateLimitDecision => {\n    const now = Date.now();\n    const entry = memMap.get(key);\n    if (!entry || entry.resetAt < now) {\n      memMap.set(key, { count: 1, resetAt: now + windowSeconds * 1000 });\n      return { allowed: true, remaining: maxRequests - 1, limit: maxRequests };\n    }\n    entry.count++;\n    const remaining = Math.max(0, maxRequests - entry.count);\n    return { allowed: entry.count <= maxRequests, remaining, limit: maxRequests };\n  };\n\n  return {\n    async check(key: string): Promise<RateLimitDecision> {\n      const r = await getRedis();\n      if (!r) return checkMem(key);\n      try {\n        const fullKey = `${keyPrefix}${key}`;\n        const count = await r.incr(fullKey);\n        if (count === 1) await r.expire(fullKey, windowSeconds);\n        const remaining = Math.max(0, maxRequests - count);\n        return { allowed: count <= maxRequests, remaining, limit: maxRequests };\n      } catch {\n        return checkMem(key);\n      }\n    },\n  };\n}\n\nexport const RATE_LIMIT_JSON_BODY = {\n  error: { code: 'rate_limited', message: 'Too many requests' },\n} as const;\n\n/** Default key resolver: first hop of `x-forwarded-for`, else `'unknown'`. Works on any\n *  framework's request once you adapt the header read. */\nexport function defaultKeyFromForwardedFor(forwardedFor: string | null | undefined): string {\n  if (!forwardedFor) return 'unknown';\n  return forwardedFor.split(',')[0]?.trim() || 'unknown';\n}\n"],"mappings":"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","names":[]}

package/dist/middleware/fastify.mjs

@@ -0,0 +1,90 @@
+// src/_redis.ts
+async function tryCreateRedis(opts) {
+  const url = opts.url ?? process.env.REDIS_URL;
+  if (!url) return null;
+  try {
+    const mod = await import("ioredis");
+    const client = new mod.default(url, {
+      connectTimeout: opts.connectTimeout ?? 3e3,
+      maxRetriesPerRequest: opts.maxRetriesPerRequest ?? 1,
+      tls: url.startsWith("rediss://") ? {} : void 0
+    });
+    client.on("error", (err) => console.error(`[${opts.label}] Redis error:`, err.message));
+    return client;
+  } catch {
+    return null;
+  }
+}
+function memoizedRedis(opts) {
+  let promise = null;
+  return () => {
+    if (!promise) promise = tryCreateRedis(opts);
+    return promise;
+  };
+}
+
+// src/middleware/_core.ts
+function createRateLimiter(opts = {}) {
+  const windowSeconds = opts.windowSeconds ?? 60;
+  const maxRequests = opts.maxRequests ?? 60;
+  const keyPrefix = opts.keyPrefix ?? "rl:";
+  const memMap = /* @__PURE__ */ new Map();
+  const getRedis = memoizedRedis({ url: opts.redisUrl, label: "rate-limit" });
+  const checkMem = (key) => {
+    const now = Date.now();
+    const entry = memMap.get(key);
+    if (!entry || entry.resetAt < now) {
+      memMap.set(key, { count: 1, resetAt: now + windowSeconds * 1e3 });
+      return { allowed: true, remaining: maxRequests - 1, limit: maxRequests };
+    }
+    entry.count++;
+    const remaining = Math.max(0, maxRequests - entry.count);
+    return { allowed: entry.count <= maxRequests, remaining, limit: maxRequests };
+  };
+  return {
+    async check(key) {
+      const r = await getRedis();
+      if (!r) return checkMem(key);
+      try {
+        const fullKey = `${keyPrefix}${key}`;
+        const count = await r.incr(fullKey);
+        if (count === 1) await r.expire(fullKey, windowSeconds);
+        const remaining = Math.max(0, maxRequests - count);
+        return { allowed: count <= maxRequests, remaining, limit: maxRequests };
+      } catch {
+        return checkMem(key);
+      }
+    }
+  };
+}
+var RATE_LIMIT_JSON_BODY = {
+  error: { code: "rate_limited", message: "Too many requests" }
+};
+function defaultKeyFromForwardedFor(forwardedFor) {
+  if (!forwardedFor) return "unknown";
+  return forwardedFor.split(",")[0]?.trim() || "unknown";
+}
+
+// src/middleware/fastify.ts
+function rateLimitFastify(opts = {}) {
+  const limiter = createRateLimiter(opts);
+  const keyResolver = opts.keyResolver ?? ((req) => {
+    const forwarded = req.headers["x-forwarded-for"];
+    const forwardedStr = Array.isArray(forwarded) ? forwarded[0] : forwarded;
+    if (forwardedStr) return defaultKeyFromForwardedFor(forwardedStr);
+    return req.ip ?? "unknown";
+  });
+  return async (req, reply) => {
+    const { allowed, remaining, limit } = await limiter.check(keyResolver(req));
+    reply.header("X-RateLimit-Limit", String(limit));
+    reply.header("X-RateLimit-Remaining", String(remaining));
+    if (!allowed) {
+      reply.header("Cache-Control", "no-store");
+      reply.code(429).send(RATE_LIMIT_JSON_BODY);
+    }
+  };
+}
+export {
+  rateLimitFastify
+};
+//# sourceMappingURL=fastify.mjs.map

package/dist/middleware/fastify.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/_redis.ts","../../src/middleware/_core.ts","../../src/middleware/fastify.ts"],"sourcesContent":["/** Shared lazy `ioredis` factory. Used by `quote_cache`, `middleware/_core`,\n *  and `stripe-multichain/pi-cache` so they don't drift on connect-timeout,\n *  TLS handling, or error-logging posture.\n *\n *  `ioredis` is an optional peer dep — callers pass `redisUrl` (or rely on\n *  `process.env.REDIS_URL`); when unset or the lazy import fails, this returns\n *  null and the caller falls back to its in-process `Map`.\n *\n *  Not part of the public API.\n */\n\n/** Minimal Redis surface — each caller intersects with its own usage\n *  (incr/expire for rate-limit, get/set/del for caches). Returning `unknown`\n *  on commands keeps the shape narrow; cast at the call site. */\nexport interface MinimalRedis {\n  on(event: 'error', handler: (err: Error) => void): unknown;\n}\n\nexport interface CreateRedisOptions {\n  /** Override `process.env.REDIS_URL` for tests. */\n  url?: string;\n  /** Logging label, e.g. `'quote-cache'` / `'rate-limit'` / `'pi-cache'`. */\n  label: string;\n  /** Connect timeout in ms. Default `3000`. */\n  connectTimeout?: number;\n  /** Per-request retry cap. Default `1`. */\n  maxRetriesPerRequest?: number;\n}\n\n/** Lazy-import ioredis and construct a client. Returns null when:\n *   - no URL is configured (caller falls back to in-memory)\n *   - `ioredis` isn't installed (optional peer; caller falls back to in-memory)\n *   - the import throws for any other reason\n *\n *  `rediss://` URLs auto-enable TLS. The error handler logs with the caller's\n *  label so multi-cache deployments can tell which subsystem complained. */\nasync function tryCreateRedis<T extends MinimalRedis>(opts: CreateRedisOptions): Promise<T | null> {\n  const url = opts.url ?? process.env.REDIS_URL;\n  if (!url) return null;\n  try {\n    const mod = (await import('ioredis')) as unknown as { default: new (url: string, opts?: unknown) => T };\n    const client = new mod.default(url, {\n      connectTimeout: opts.connectTimeout ?? 3000,\n      maxRetriesPerRequest: opts.maxRetriesPerRequest ?? 1,\n      tls: url.startsWith('rediss://') ? {} : undefined,\n    });\n    client.on('error', (err) => console.error(`[${opts.label}] Redis error:`, err.message));\n    return client;\n  } catch {\n    return null;\n  }\n}\n\n/** Memoized-promise variant: call once per caller; subsequent calls return the\n *  same promise. Pairs with the pattern `let p: Promise<T|null> | null = null;\n *  const getRedis = () => (p ??= tryCreateRedis(...))` in callers that want\n *  per-call promise caching without managing the closure themselves. */\nexport function memoizedRedis<T extends MinimalRedis>(opts: CreateRedisOptions): () => Promise<T | null> {\n  let promise: Promise<T | null> | null = null;\n  return () => {\n    if (!promise) promise = tryCreateRedis<T>(opts);\n    return promise;\n  };\n}\n","import { memoizedRedis, type MinimalRedis } from '../_redis';\n\nexport interface RateLimitCoreOptions {\n  windowSeconds?: number;\n  maxRequests?: number;\n  /** Redis connection URL. Default: `process.env.REDIS_URL`. Falls back to in-memory when unset or the lazy `ioredis` import fails. */\n  redisUrl?: string;\n  /** Per-instance key prefix so multiple limiters sharing a Redis don't collide. */\n  keyPrefix?: string;\n}\n\nexport interface RateLimitDecision {\n  allowed: boolean;\n  remaining: number;\n  limit: number;\n}\n\nexport interface RateLimiter {\n  check(key: string): Promise<RateLimitDecision>;\n}\n\ninterface RedisLike extends MinimalRedis {\n  incr(key: string): Promise<number>;\n  expire(key: string, seconds: number): Promise<unknown>;\n}\n\n/** Framework-agnostic rate limiter. Hono / Express / Fastify / Next.js / Web adapters\n *  share one core. Each `createRateLimiter` call owns its own memory map + redis\n *  connection, so multiple instances in the same process don't share state unless\n *  they share a Redis with the same `keyPrefix`. */\nexport function createRateLimiter(opts: RateLimitCoreOptions = {}): RateLimiter {\n  const windowSeconds = opts.windowSeconds ?? 60;\n  const maxRequests = opts.maxRequests ?? 60;\n  const keyPrefix = opts.keyPrefix ?? 'rl:';\n\n  const memMap = new Map<string, { count: number; resetAt: number }>();\n  const getRedis = memoizedRedis<RedisLike>({ url: opts.redisUrl, label: 'rate-limit' });\n\n  const checkMem = (key: string): RateLimitDecision => {\n    const now = Date.now();\n    const entry = memMap.get(key);\n    if (!entry || entry.resetAt < now) {\n      memMap.set(key, { count: 1, resetAt: now + windowSeconds * 1000 });\n      return { allowed: true, remaining: maxRequests - 1, limit: maxRequests };\n    }\n    entry.count++;\n    const remaining = Math.max(0, maxRequests - entry.count);\n    return { allowed: entry.count <= maxRequests, remaining, limit: maxRequests };\n  };\n\n  return {\n    async check(key: string): Promise<RateLimitDecision> {\n      const r = await getRedis();\n      if (!r) return checkMem(key);\n      try {\n        const fullKey = `${keyPrefix}${key}`;\n        const count = await r.incr(fullKey);\n        if (count === 1) await r.expire(fullKey, windowSeconds);\n        const remaining = Math.max(0, maxRequests - count);\n        return { allowed: count <= maxRequests, remaining, limit: maxRequests };\n      } catch {\n        return checkMem(key);\n      }\n    },\n  };\n}\n\nexport const RATE_LIMIT_JSON_BODY = {\n  error: { code: 'rate_limited', message: 'Too many requests' },\n} as const;\n\n/** Default key resolver: first hop of `x-forwarded-for`, else `'unknown'`. Works on any\n *  framework's request once you adapt the header read. */\nexport function defaultKeyFromForwardedFor(forwardedFor: string | null | undefined): string {\n  if (!forwardedFor) return 'unknown';\n  return forwardedFor.split(',')[0]?.trim() || 'unknown';\n}\n","import {\n  RATE_LIMIT_JSON_BODY,\n  createRateLimiter,\n  defaultKeyFromForwardedFor,\n  type RateLimitCoreOptions,\n} from './_core';\nimport type { FastifyReply, FastifyRequest, preHandlerHookHandler } from 'fastify';\n\nexport interface RateLimitFastifyOptions extends RateLimitCoreOptions {\n  /** Bucket key resolver. Default: first hop of `x-forwarded-for`, else `req.ip`, else `'unknown'`. */\n  keyResolver?: (req: FastifyRequest) => string;\n}\n\nexport function rateLimitFastify(opts: RateLimitFastifyOptions = {}): preHandlerHookHandler {\n  const limiter = createRateLimiter(opts);\n  const keyResolver =\n    opts.keyResolver ??\n    ((req: FastifyRequest): string => {\n      const forwarded = req.headers['x-forwarded-for'];\n      const forwardedStr = Array.isArray(forwarded) ? forwarded[0] : forwarded;\n      if (forwardedStr) return defaultKeyFromForwardedFor(forwardedStr);\n      return req.ip ?? 'unknown';\n    });\n\n  return async (req: FastifyRequest, reply: FastifyReply) => {\n    const { allowed, remaining, limit } = await limiter.check(keyResolver(req));\n    reply.header('X-RateLimit-Limit', String(limit));\n    reply.header('X-RateLimit-Remaining', String(remaining));\n    if (!allowed) {\n      reply.header('Cache-Control', 'no-store');\n      reply.code(429).send(RATE_LIMIT_JSON_BODY);\n    }\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/middleware/hono.d.mts

@@ -0,0 +1,10 @@
+import { R as RateLimitCoreOptions } from '../_core-kI7FRAiZ.mjs';
+import { Context, MiddlewareHandler } from 'hono';
+
+interface RateLimitHonoOptions extends RateLimitCoreOptions {
+    /** Bucket key resolver. Default: first hop of `x-forwarded-for`, else `'unknown'`. */
+    keyResolver?: (c: Context) => string;
+}
+declare function rateLimitHono(opts?: RateLimitHonoOptions): MiddlewareHandler;
+
+export { type RateLimitHonoOptions, rateLimitHono };

package/dist/middleware/hono.d.ts

@@ -0,0 +1,10 @@
+import { R as RateLimitCoreOptions } from '../_core-kI7FRAiZ.js';
+import { Context, MiddlewareHandler } from 'hono';
+
+interface RateLimitHonoOptions extends RateLimitCoreOptions {
+    /** Bucket key resolver. Default: first hop of `x-forwarded-for`, else `'unknown'`. */
+    keyResolver?: (c: Context) => string;
+}
+declare function rateLimitHono(opts?: RateLimitHonoOptions): MiddlewareHandler;
+
+export { type RateLimitHonoOptions, rateLimitHono };