halt-rate 0.3.0 → 0.4.0

package/README.md

@@ -39,9 +39,17 @@ observability are covered in the docs → **[halt.afroawi.com/docs](https://halt
 - Algorithms: token bucket, fixed/sliding window, leaky bucket
 - Keys: IP, user, API key, composite, or custom
 - Atomic **Redis** store (Lua, cluster-safe, fail-open) + in-memory dev store
+- **Dynamic limits**: change limits at runtime with `PolicyRegistry` / cached loaders — no restart
 - SaaS: per-plan limits, quotas, weighted endpoints, abuse penalties
 - Observability: `StatsCollector` + OpenTelemetry metrics
-- Adapters: Express, Next.js
+- Adapters: Express, Next.js, **Hono**, **Fastify**, GraphQL (Apollo)
+
+## Runtime support
+
+Ships dual **ESM + CJS** with types. The core (limiter, algorithms, in-memory store) is
+**edge-safe** — runs on Cloudflare Workers, Deno, Bun, and Vercel Edge. `RedisStore` is Node-only
+(TCP); for edge distributed limits, inject any `RedisClientLike` (e.g. a fetch/REST client).
+Full guidance: **[halt.afroawi.com/docs](https://halt.afroawi.com/docs)**.
 
 ## Links
 

package/dist/adapters/fastify.d.mts

@@ -0,0 +1,29 @@
+import { FastifyRequest, FastifyReply } from 'fastify';
+import { o as RateLimiter } from '../limiter-DqVVE0Kl.mjs';
+
+/**
+ * Fastify adapter for Halt rate limiting.
+ *
+ *   import Fastify from 'fastify';
+ *   import { RateLimiter, InMemoryStore, presets } from 'halt-rate';
+ *   import { haltHook } from 'halt-rate/fastify';
+ *
+ *   const limiter = new RateLimiter({ store: new InMemoryStore(), policy: presets.PUBLIC_API });
+ *   const app = Fastify();
+ *   app.addHook('preHandler', haltHook({ limiter }));
+ */
+
+interface FastifyHaltOptions {
+    limiter: RateLimiter;
+    /** Custom blocked response. */
+    onBlocked?: (request: FastifyRequest, reply: FastifyReply) => unknown;
+}
+/**
+ * Create a Fastify `preHandler` hook for rate limiting. Fastify's request already
+ * exposes `ip`, `headers`, and `url`, which Halt's extractors understand directly.
+ */
+declare function haltHook(options: FastifyHaltOptions): (request: FastifyRequest, reply: FastifyReply) => Promise<unknown>;
+/** Alias for symmetry with the other adapters. */
+declare const haltMiddleware: typeof haltHook;
+
+export { type FastifyHaltOptions, haltHook, haltMiddleware };

package/dist/adapters/fastify.d.ts

@@ -0,0 +1,29 @@
+import { FastifyRequest, FastifyReply } from 'fastify';
+import { o as RateLimiter } from '../limiter-DqVVE0Kl.js';
+
+/**
+ * Fastify adapter for Halt rate limiting.
+ *
+ *   import Fastify from 'fastify';
+ *   import { RateLimiter, InMemoryStore, presets } from 'halt-rate';
+ *   import { haltHook } from 'halt-rate/fastify';
+ *
+ *   const limiter = new RateLimiter({ store: new InMemoryStore(), policy: presets.PUBLIC_API });
+ *   const app = Fastify();
+ *   app.addHook('preHandler', haltHook({ limiter }));
+ */
+
+interface FastifyHaltOptions {
+    limiter: RateLimiter;
+    /** Custom blocked response. */
+    onBlocked?: (request: FastifyRequest, reply: FastifyReply) => unknown;
+}
+/**
+ * Create a Fastify `preHandler` hook for rate limiting. Fastify's request already
+ * exposes `ip`, `headers`, and `url`, which Halt's extractors understand directly.
+ */
+declare function haltHook(options: FastifyHaltOptions): (request: FastifyRequest, reply: FastifyReply) => Promise<unknown>;
+/** Alias for symmetry with the other adapters. */
+declare const haltMiddleware: typeof haltHook;
+
+export { type FastifyHaltOptions, haltHook, haltMiddleware };

package/dist/adapters/fastify.js

@@ -0,0 +1,38 @@
+'use strict';
+
+// src/core/decision.ts
+function toHeaders(decision) {
+  const headers = {
+    "RateLimit-Limit": String(decision.limit),
+    "RateLimit-Remaining": String(Math.max(0, decision.remaining)),
+    "RateLimit-Reset": String(decision.resetAt)
+  };
+  if (!decision.allowed && decision.retryAfter !== void 0) {
+    headers["Retry-After"] = String(decision.retryAfter);
+  }
+  return headers;
+}
+
+// src/adapters/fastify.ts
+function haltHook(options) {
+  const { limiter, onBlocked } = options;
+  return async (request, reply) => {
+    const decision = await limiter.check(request);
+    for (const [key, value] of Object.entries(toHeaders(decision))) {
+      reply.header(key, value);
+    }
+    if (decision.allowed) return;
+    if (onBlocked) return onBlocked(request, reply);
+    return reply.code(429).send({
+      error: "rate_limit_exceeded",
+      message: "Too many requests. Please try again later.",
+      retryAfter: decision.retryAfter
+    });
+  };
+}
+var haltMiddleware = haltHook;
+
+exports.haltHook = haltHook;
+exports.haltMiddleware = haltMiddleware;
+//# sourceMappingURL=fastify.js.map
+//# sourceMappingURL=fastify.js.map

package/dist/adapters/fastify.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/decision.ts","../../src/adapters/fastify.ts"],"names":[],"mappings":";;;AAoBO,SAAS,UAAU,QAAA,EAA4C;AAClE,EAAA,MAAM,OAAA,GAAkC;AAAA,IACpC,iBAAA,EAAmB,MAAA,CAAO,QAAA,CAAS,KAAK,CAAA;AAAA,IACxC,uBAAuB,MAAA,CAAO,IAAA,CAAK,IAAI,CAAA,EAAG,QAAA,CAAS,SAAS,CAAC,CAAA;AAAA,IAC7D,iBAAA,EAAmB,MAAA,CAAO,QAAA,CAAS,OAAO;AAAA,GAC9C;AAEA,EAAA,IAAI,CAAC,QAAA,CAAS,OAAA,IAAW,QAAA,CAAS,eAAe,MAAA,EAAW;AACxD,IAAA,OAAA,CAAQ,aAAa,CAAA,GAAI,MAAA,CAAO,QAAA,CAAS,UAAU,CAAA;AAAA,EACvD;AAEA,EAAA,OAAO,OAAA;AACX;;;ACNO,SAAS,SAAS,OAAA,EAA6B;AAClD,EAAA,MAAM,EAAE,OAAA,EAAS,SAAA,EAAU,GAAI,OAAA;AAE/B,EAAA,OAAO,OAAO,SAAyB,KAAA,KAAwB;AAC3D,IAAA,MAAM,QAAA,GAAW,MAAM,OAAA,CAAQ,KAAA,CAAM,OAAO,CAAA;AAE5C,IAAA,KAAA,MAAW,CAAC,KAAK,KAAK,CAAA,IAAK,OAAO,OAAA,CAAQ,SAAA,CAAU,QAAQ,CAAC,CAAA,EAAG;AAC5D,MAAA,KAAA,CAAM,MAAA,CAAO,KAAK,KAAK,CAAA;AAAA,IAC3B;AAEA,IAAA,IAAI,SAAS,OAAA,EAAS;AAEtB,IAAA,IAAI,SAAA,EAAW,OAAO,SAAA,CAAU,OAAA,EAAS,KAAK,CAAA;AAC9C,IAAA,OAAO,KAAA,CAAM,IAAA,CAAK,GAAG,CAAA,CAAE,IAAA,CAAK;AAAA,MACxB,KAAA,EAAO,qBAAA;AAAA,MACP,OAAA,EAAS,4CAAA;AAAA,MACT,YAAY,QAAA,CAAS;AAAA,KACxB,CAAA;AAAA,EACL,CAAA;AACJ;AAGO,IAAM,cAAA,GAAiB","file":"fastify.js","sourcesContent":["/**\n * Decision model for rate limiting results.\n */\n\nexport interface Decision {\n    /** Whether the request is allowed */\n    allowed: boolean;\n    /** Maximum number of requests allowed in the window */\n    limit: number;\n    /** Number of requests remaining in the current window */\n    remaining: number;\n    /** Unix timestamp when the limit resets */\n    resetAt: number;\n    /** Seconds to wait before retrying (only set when blocked) */\n    retryAfter?: number;\n}\n\n/**\n * Convert decision to standard rate limit headers.\n */\nexport function toHeaders(decision: Decision): Record<string, string> {\n    const headers: Record<string, string> = {\n        'RateLimit-Limit': String(decision.limit),\n        'RateLimit-Remaining': String(Math.max(0, decision.remaining)),\n        'RateLimit-Reset': String(decision.resetAt),\n    };\n\n    if (!decision.allowed && decision.retryAfter !== undefined) {\n        headers['Retry-After'] = String(decision.retryAfter);\n    }\n\n    return headers;\n}\n","/**\n * Fastify adapter for Halt rate limiting.\n *\n *   import Fastify from 'fastify';\n *   import { RateLimiter, InMemoryStore, presets } from 'halt-rate';\n *   import { haltHook } from 'halt-rate/fastify';\n *\n *   const limiter = new RateLimiter({ store: new InMemoryStore(), policy: presets.PUBLIC_API });\n *   const app = Fastify();\n *   app.addHook('preHandler', haltHook({ limiter }));\n */\n\nimport type { FastifyReply, FastifyRequest } from 'fastify';\nimport { RateLimiter } from '../core/limiter';\nimport { toHeaders } from '../core/decision';\n\nexport interface FastifyHaltOptions {\n    limiter: RateLimiter;\n    /** Custom blocked response. */\n    onBlocked?: (request: FastifyRequest, reply: FastifyReply) => unknown;\n}\n\n/**\n * Create a Fastify `preHandler` hook for rate limiting. Fastify's request already\n * exposes `ip`, `headers`, and `url`, which Halt's extractors understand directly.\n */\nexport function haltHook(options: FastifyHaltOptions) {\n    const { limiter, onBlocked } = options;\n\n    return async (request: FastifyRequest, reply: FastifyReply) => {\n        const decision = await limiter.check(request);\n\n        for (const [key, value] of Object.entries(toHeaders(decision))) {\n            reply.header(key, value);\n        }\n\n        if (decision.allowed) return;\n\n        if (onBlocked) return onBlocked(request, reply);\n        return reply.code(429).send({\n            error: 'rate_limit_exceeded',\n            message: 'Too many requests. Please try again later.',\n            retryAfter: decision.retryAfter,\n        });\n    };\n}\n\n/** Alias for symmetry with the other adapters. */\nexport const haltMiddleware = haltHook;\n"]}

package/dist/adapters/fastify.mjs

@@ -0,0 +1,35 @@
+// src/core/decision.ts
+function toHeaders(decision) {
+  const headers = {
+    "RateLimit-Limit": String(decision.limit),
+    "RateLimit-Remaining": String(Math.max(0, decision.remaining)),
+    "RateLimit-Reset": String(decision.resetAt)
+  };
+  if (!decision.allowed && decision.retryAfter !== void 0) {
+    headers["Retry-After"] = String(decision.retryAfter);
+  }
+  return headers;
+}
+
+// src/adapters/fastify.ts
+function haltHook(options) {
+  const { limiter, onBlocked } = options;
+  return async (request, reply) => {
+    const decision = await limiter.check(request);
+    for (const [key, value] of Object.entries(toHeaders(decision))) {
+      reply.header(key, value);
+    }
+    if (decision.allowed) return;
+    if (onBlocked) return onBlocked(request, reply);
+    return reply.code(429).send({
+      error: "rate_limit_exceeded",
+      message: "Too many requests. Please try again later.",
+      retryAfter: decision.retryAfter
+    });
+  };
+}
+var haltMiddleware = haltHook;
+
+export { haltHook, haltMiddleware };
+//# sourceMappingURL=fastify.mjs.map
+//# sourceMappingURL=fastify.mjs.map

package/dist/adapters/fastify.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/decision.ts","../../src/adapters/fastify.ts"],"names":[],"mappings":";AAoBO,SAAS,UAAU,QAAA,EAA4C;AAClE,EAAA,MAAM,OAAA,GAAkC;AAAA,IACpC,iBAAA,EAAmB,MAAA,CAAO,QAAA,CAAS,KAAK,CAAA;AAAA,IACxC,uBAAuB,MAAA,CAAO,IAAA,CAAK,IAAI,CAAA,EAAG,QAAA,CAAS,SAAS,CAAC,CAAA;AAAA,IAC7D,iBAAA,EAAmB,MAAA,CAAO,QAAA,CAAS,OAAO;AAAA,GAC9C;AAEA,EAAA,IAAI,CAAC,QAAA,CAAS,OAAA,IAAW,QAAA,CAAS,eAAe,MAAA,EAAW;AACxD,IAAA,OAAA,CAAQ,aAAa,CAAA,GAAI,MAAA,CAAO,QAAA,CAAS,UAAU,CAAA;AAAA,EACvD;AAEA,EAAA,OAAO,OAAA;AACX;;;ACNO,SAAS,SAAS,OAAA,EAA6B;AAClD,EAAA,MAAM,EAAE,OAAA,EAAS,SAAA,EAAU,GAAI,OAAA;AAE/B,EAAA,OAAO,OAAO,SAAyB,KAAA,KAAwB;AAC3D,IAAA,MAAM,QAAA,GAAW,MAAM,OAAA,CAAQ,KAAA,CAAM,OAAO,CAAA;AAE5C,IAAA,KAAA,MAAW,CAAC,KAAK,KAAK,CAAA,IAAK,OAAO,OAAA,CAAQ,SAAA,CAAU,QAAQ,CAAC,CAAA,EAAG;AAC5D,MAAA,KAAA,CAAM,MAAA,CAAO,KAAK,KAAK,CAAA;AAAA,IAC3B;AAEA,IAAA,IAAI,SAAS,OAAA,EAAS;AAEtB,IAAA,IAAI,SAAA,EAAW,OAAO,SAAA,CAAU,OAAA,EAAS,KAAK,CAAA;AAC9C,IAAA,OAAO,KAAA,CAAM,IAAA,CAAK,GAAG,CAAA,CAAE,IAAA,CAAK;AAAA,MACxB,KAAA,EAAO,qBAAA;AAAA,MACP,OAAA,EAAS,4CAAA;AAAA,MACT,YAAY,QAAA,CAAS;AAAA,KACxB,CAAA;AAAA,EACL,CAAA;AACJ;AAGO,IAAM,cAAA,GAAiB","file":"fastify.mjs","sourcesContent":["/**\n * Decision model for rate limiting results.\n */\n\nexport interface Decision {\n    /** Whether the request is allowed */\n    allowed: boolean;\n    /** Maximum number of requests allowed in the window */\n    limit: number;\n    /** Number of requests remaining in the current window */\n    remaining: number;\n    /** Unix timestamp when the limit resets */\n    resetAt: number;\n    /** Seconds to wait before retrying (only set when blocked) */\n    retryAfter?: number;\n}\n\n/**\n * Convert decision to standard rate limit headers.\n */\nexport function toHeaders(decision: Decision): Record<string, string> {\n    const headers: Record<string, string> = {\n        'RateLimit-Limit': String(decision.limit),\n        'RateLimit-Remaining': String(Math.max(0, decision.remaining)),\n        'RateLimit-Reset': String(decision.resetAt),\n    };\n\n    if (!decision.allowed && decision.retryAfter !== undefined) {\n        headers['Retry-After'] = String(decision.retryAfter);\n    }\n\n    return headers;\n}\n","/**\n * Fastify adapter for Halt rate limiting.\n *\n *   import Fastify from 'fastify';\n *   import { RateLimiter, InMemoryStore, presets } from 'halt-rate';\n *   import { haltHook } from 'halt-rate/fastify';\n *\n *   const limiter = new RateLimiter({ store: new InMemoryStore(), policy: presets.PUBLIC_API });\n *   const app = Fastify();\n *   app.addHook('preHandler', haltHook({ limiter }));\n */\n\nimport type { FastifyReply, FastifyRequest } from 'fastify';\nimport { RateLimiter } from '../core/limiter';\nimport { toHeaders } from '../core/decision';\n\nexport interface FastifyHaltOptions {\n    limiter: RateLimiter;\n    /** Custom blocked response. */\n    onBlocked?: (request: FastifyRequest, reply: FastifyReply) => unknown;\n}\n\n/**\n * Create a Fastify `preHandler` hook for rate limiting. Fastify's request already\n * exposes `ip`, `headers`, and `url`, which Halt's extractors understand directly.\n */\nexport function haltHook(options: FastifyHaltOptions) {\n    const { limiter, onBlocked } = options;\n\n    return async (request: FastifyRequest, reply: FastifyReply) => {\n        const decision = await limiter.check(request);\n\n        for (const [key, value] of Object.entries(toHeaders(decision))) {\n            reply.header(key, value);\n        }\n\n        if (decision.allowed) return;\n\n        if (onBlocked) return onBlocked(request, reply);\n        return reply.code(429).send({\n            error: 'rate_limit_exceeded',\n            message: 'Too many requests. Please try again later.',\n            retryAfter: decision.retryAfter,\n        });\n    };\n}\n\n/** Alias for symmetry with the other adapters. */\nexport const haltMiddleware = haltHook;\n"]}

package/dist/adapters/graphql.d.mts

@@ -0,0 +1,22 @@
+import { o as RateLimiter } from '../limiter-DqVVE0Kl.mjs';
+
+/**
+ * Apollo Server plugin adapter for Halt rate limiting.
+ *
+ * Usage:
+ * const plugin = haltApolloPlugin({ limiter });
+ * const server = new ApolloServer({ typeDefs, resolvers, plugins: [plugin] });
+ */
+
+interface ApolloHaltOptions {
+    limiter: RateLimiter;
+    /** Optional function to extract a resource name for per-field limits */
+    resourceExtractor?: (request: any) => string | null;
+}
+declare function haltApolloPlugin(options: ApolloHaltOptions): {
+    requestDidStart(): Promise<{
+        didResolveOperation(requestContext: any): Promise<void>;
+    }>;
+};
+
+export { type ApolloHaltOptions, haltApolloPlugin };

package/dist/adapters/graphql.d.ts

@@ -0,0 +1,22 @@
+import { o as RateLimiter } from '../limiter-DqVVE0Kl.js';
+
+/**
+ * Apollo Server plugin adapter for Halt rate limiting.
+ *
+ * Usage:
+ * const plugin = haltApolloPlugin({ limiter });
+ * const server = new ApolloServer({ typeDefs, resolvers, plugins: [plugin] });
+ */
+
+interface ApolloHaltOptions {
+    limiter: RateLimiter;
+    /** Optional function to extract a resource name for per-field limits */
+    resourceExtractor?: (request: any) => string | null;
+}
+declare function haltApolloPlugin(options: ApolloHaltOptions): {
+    requestDidStart(): Promise<{
+        didResolveOperation(requestContext: any): Promise<void>;
+    }>;
+};
+
+export { type ApolloHaltOptions, haltApolloPlugin };

package/dist/adapters/graphql.js

@@ -0,0 +1,51 @@
+'use strict';
+
+// src/adapters/graphql.ts
+function haltApolloPlugin(options) {
+  const { limiter, resourceExtractor } = options;
+  return {
+    async requestDidStart() {
+      return {
+        async didResolveOperation(requestContext) {
+          try {
+            const req = requestContext.request?.http || {};
+            if (resourceExtractor) {
+              req.resource = resourceExtractor(requestContext.request);
+            }
+            const decision = await limiter.check(req);
+            if (!decision.allowed) {
+              requestContext.response = {
+                http: {
+                  status: 429,
+                  headers: {
+                    ...requestContext.response?.http?.headers,
+                    "Retry-After": String(decision.retryAfter ?? 0)
+                  }
+                },
+                errors: [
+                  new Error("rate_limit_exceeded: Too many requests. Please try again later.")
+                ]
+              };
+            } else {
+              requestContext.response = requestContext.response || {};
+              requestContext.response.http = requestContext.response.http || {};
+              requestContext.response.http.headers = {
+                ...requestContext.response.http.headers,
+                "RateLimit-Limit": String(decision.limit),
+                "RateLimit-Remaining": String(Math.max(0, decision.remaining)),
+                "RateLimit-Reset": String(decision.resetAt)
+              };
+            }
+          } catch (err) {
+            requestContext.errors = requestContext.errors || [];
+            requestContext.errors.push(err);
+          }
+        }
+      };
+    }
+  };
+}
+
+exports.haltApolloPlugin = haltApolloPlugin;
+//# sourceMappingURL=graphql.js.map
+//# sourceMappingURL=graphql.js.map

package/dist/adapters/graphql.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/graphql.ts"],"names":[],"mappings":";;;AAgBO,SAAS,iBAAiB,OAAA,EAA4B;AACzD,EAAA,MAAM,EAAE,OAAA,EAAS,iBAAA,EAAkB,GAAI,OAAA;AAEvC,EAAA,OAAO;AAAA,IACH,MAAM,eAAA,GAAkB;AACpB,MAAA,OAAO;AAAA,QACH,MAAM,oBAAoB,cAAA,EAAqB;AAC3C,UAAA,IAAI;AAEA,YAAA,MAAM,GAAA,GAAM,cAAA,CAAe,OAAA,EAAS,IAAA,IAAQ,EAAC;AAC7C,YAAA,IAAI,iBAAA,EAAmB;AAEnB,cAAC,GAAA,CAAY,QAAA,GAAW,iBAAA,CAAkB,cAAA,CAAe,OAAO,CAAA;AAAA,YACpE;AAEA,YAAA,MAAM,QAAA,GAAW,MAAM,OAAA,CAAQ,KAAA,CAAM,GAAG,CAAA;AAExC,YAAA,IAAI,CAAC,SAAS,OAAA,EAAS;AAEnB,cAAA,cAAA,CAAe,QAAA,GAAW;AAAA,gBACtB,IAAA,EAAM;AAAA,kBACF,MAAA,EAAQ,GAAA;AAAA,kBACR,OAAA,EAAS;AAAA,oBACL,GAAG,cAAA,CAAe,QAAA,EAAU,IAAA,EAAM,OAAA;AAAA,oBAClC,aAAA,EAAe,MAAA,CAAO,QAAA,CAAS,UAAA,IAAc,CAAC;AAAA;AAClD,iBACJ;AAAA,gBACA,MAAA,EAAQ;AAAA,kBACJ,IAAI,MAAM,iEAAiE;AAAA;AAC/E,eACJ;AAAA,YACJ,CAAA,MAAO;AAEH,cAAA,cAAA,CAAe,QAAA,GAAW,cAAA,CAAe,QAAA,IAAY,EAAC;AACtD,cAAA,cAAA,CAAe,QAAA,CAAS,IAAA,GAAO,cAAA,CAAe,QAAA,CAAS,QAAQ,EAAC;AAChE,cAAA,cAAA,CAAe,QAAA,CAAS,KAAK,OAAA,GAAU;AAAA,gBACnC,GAAG,cAAA,CAAe,QAAA,CAAS,IAAA,CAAK,OAAA;AAAA,gBAChC,iBAAA,EAAmB,MAAA,CAAO,QAAA,CAAS,KAAK,CAAA;AAAA,gBACxC,uBAAuB,MAAA,CAAO,IAAA,CAAK,IAAI,CAAA,EAAG,QAAA,CAAS,SAAS,CAAC,CAAA;AAAA,gBAC7D,iBAAA,EAAmB,MAAA,CAAO,QAAA,CAAS,OAAO;AAAA,eAC9C;AAAA,YACJ;AAAA,UACJ,SAAS,GAAA,EAAK;AAEV,YAAA,cAAA,CAAe,MAAA,GAAS,cAAA,CAAe,MAAA,IAAU,EAAC;AAClD,YAAA,cAAA,CAAe,MAAA,CAAO,KAAK,GAAY,CAAA;AAAA,UAC3C;AAAA,QACJ;AAAA,OACJ;AAAA,IACJ;AAAA,GACJ;AACJ","file":"graphql.js","sourcesContent":["/**\n * Apollo Server plugin adapter for Halt rate limiting.\n *\n * Usage:\n * const plugin = haltApolloPlugin({ limiter });\n * const server = new ApolloServer({ typeDefs, resolvers, plugins: [plugin] });\n */\n\nimport { RateLimiter } from '../core/limiter';\n\nexport interface ApolloHaltOptions {\n    limiter: RateLimiter;\n    /** Optional function to extract a resource name for per-field limits */\n    resourceExtractor?: (request: any) => string | null;\n}\n\nexport function haltApolloPlugin(options: ApolloHaltOptions) {\n    const { limiter, resourceExtractor } = options;\n\n    return {\n        async requestDidStart() {\n            return {\n                async didResolveOperation(requestContext: any) {\n                    try {\n                        // Provide request object compatible with limiter.extractors\n                        const req = requestContext.request?.http || {};\n                        if (resourceExtractor) {\n                            // Allow users to attach custom resource info\n                            (req as any).resource = resourceExtractor(requestContext.request);\n                        }\n\n                        const decision = await limiter.check(req);\n\n                        if (!decision.allowed) {\n                            // Short-circuit the request by adding an error\n                            requestContext.response = {\n                                http: {\n                                    status: 429,\n                                    headers: {\n                                        ...requestContext.response?.http?.headers,\n                                        'Retry-After': String(decision.retryAfter ?? 0),\n                                    },\n                                },\n                                errors: [\n                                    new Error('rate_limit_exceeded: Too many requests. Please try again later.'),\n                                ],\n                            };\n                        } else {\n                            // Attach rate limit headers for downstream\n                            requestContext.response = requestContext.response || {};\n                            requestContext.response.http = requestContext.response.http || {};\n                            requestContext.response.http.headers = {\n                                ...requestContext.response.http.headers,\n                                'RateLimit-Limit': String(decision.limit),\n                                'RateLimit-Remaining': String(Math.max(0, decision.remaining)),\n                                'RateLimit-Reset': String(decision.resetAt),\n                            };\n                        }\n                    } catch (err) {\n                        // Don't block on errors from limiter; surface as server error\n                        requestContext.errors = requestContext.errors || [];\n                        requestContext.errors.push(err as Error);\n                    }\n                },\n            };\n        },\n    };\n}\n"]}

package/dist/adapters/graphql.mjs

@@ -0,0 +1,49 @@
+// src/adapters/graphql.ts
+function haltApolloPlugin(options) {
+  const { limiter, resourceExtractor } = options;
+  return {
+    async requestDidStart() {
+      return {
+        async didResolveOperation(requestContext) {
+          try {
+            const req = requestContext.request?.http || {};
+            if (resourceExtractor) {
+              req.resource = resourceExtractor(requestContext.request);
+            }
+            const decision = await limiter.check(req);
+            if (!decision.allowed) {
+              requestContext.response = {
+                http: {
+                  status: 429,
+                  headers: {
+                    ...requestContext.response?.http?.headers,
+                    "Retry-After": String(decision.retryAfter ?? 0)
+                  }
+                },
+                errors: [
+                  new Error("rate_limit_exceeded: Too many requests. Please try again later.")
+                ]
+              };
+            } else {
+              requestContext.response = requestContext.response || {};
+              requestContext.response.http = requestContext.response.http || {};
+              requestContext.response.http.headers = {
+                ...requestContext.response.http.headers,
+                "RateLimit-Limit": String(decision.limit),
+                "RateLimit-Remaining": String(Math.max(0, decision.remaining)),
+                "RateLimit-Reset": String(decision.resetAt)
+              };
+            }
+          } catch (err) {
+            requestContext.errors = requestContext.errors || [];
+            requestContext.errors.push(err);
+          }
+        }
+      };
+    }
+  };
+}
+
+export { haltApolloPlugin };
+//# sourceMappingURL=graphql.mjs.map
+//# sourceMappingURL=graphql.mjs.map

package/dist/adapters/graphql.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/graphql.ts"],"names":[],"mappings":";AAgBO,SAAS,iBAAiB,OAAA,EAA4B;AACzD,EAAA,MAAM,EAAE,OAAA,EAAS,iBAAA,EAAkB,GAAI,OAAA;AAEvC,EAAA,OAAO;AAAA,IACH,MAAM,eAAA,GAAkB;AACpB,MAAA,OAAO;AAAA,QACH,MAAM,oBAAoB,cAAA,EAAqB;AAC3C,UAAA,IAAI;AAEA,YAAA,MAAM,GAAA,GAAM,cAAA,CAAe,OAAA,EAAS,IAAA,IAAQ,EAAC;AAC7C,YAAA,IAAI,iBAAA,EAAmB;AAEnB,cAAC,GAAA,CAAY,QAAA,GAAW,iBAAA,CAAkB,cAAA,CAAe,OAAO,CAAA;AAAA,YACpE;AAEA,YAAA,MAAM,QAAA,GAAW,MAAM,OAAA,CAAQ,KAAA,CAAM,GAAG,CAAA;AAExC,YAAA,IAAI,CAAC,SAAS,OAAA,EAAS;AAEnB,cAAA,cAAA,CAAe,QAAA,GAAW;AAAA,gBACtB,IAAA,EAAM;AAAA,kBACF,MAAA,EAAQ,GAAA;AAAA,kBACR,OAAA,EAAS;AAAA,oBACL,GAAG,cAAA,CAAe,QAAA,EAAU,IAAA,EAAM,OAAA;AAAA,oBAClC,aAAA,EAAe,MAAA,CAAO,QAAA,CAAS,UAAA,IAAc,CAAC;AAAA;AAClD,iBACJ;AAAA,gBACA,MAAA,EAAQ;AAAA,kBACJ,IAAI,MAAM,iEAAiE;AAAA;AAC/E,eACJ;AAAA,YACJ,CAAA,MAAO;AAEH,cAAA,cAAA,CAAe,QAAA,GAAW,cAAA,CAAe,QAAA,IAAY,EAAC;AACtD,cAAA,cAAA,CAAe,QAAA,CAAS,IAAA,GAAO,cAAA,CAAe,QAAA,CAAS,QAAQ,EAAC;AAChE,cAAA,cAAA,CAAe,QAAA,CAAS,KAAK,OAAA,GAAU;AAAA,gBACnC,GAAG,cAAA,CAAe,QAAA,CAAS,IAAA,CAAK,OAAA;AAAA,gBAChC,iBAAA,EAAmB,MAAA,CAAO,QAAA,CAAS,KAAK,CAAA;AAAA,gBACxC,uBAAuB,MAAA,CAAO,IAAA,CAAK,IAAI,CAAA,EAAG,QAAA,CAAS,SAAS,CAAC,CAAA;AAAA,gBAC7D,iBAAA,EAAmB,MAAA,CAAO,QAAA,CAAS,OAAO;AAAA,eAC9C;AAAA,YACJ;AAAA,UACJ,SAAS,GAAA,EAAK;AAEV,YAAA,cAAA,CAAe,MAAA,GAAS,cAAA,CAAe,MAAA,IAAU,EAAC;AAClD,YAAA,cAAA,CAAe,MAAA,CAAO,KAAK,GAAY,CAAA;AAAA,UAC3C;AAAA,QACJ;AAAA,OACJ;AAAA,IACJ;AAAA,GACJ;AACJ","file":"graphql.mjs","sourcesContent":["/**\n * Apollo Server plugin adapter for Halt rate limiting.\n *\n * Usage:\n * const plugin = haltApolloPlugin({ limiter });\n * const server = new ApolloServer({ typeDefs, resolvers, plugins: [plugin] });\n */\n\nimport { RateLimiter } from '../core/limiter';\n\nexport interface ApolloHaltOptions {\n    limiter: RateLimiter;\n    /** Optional function to extract a resource name for per-field limits */\n    resourceExtractor?: (request: any) => string | null;\n}\n\nexport function haltApolloPlugin(options: ApolloHaltOptions) {\n    const { limiter, resourceExtractor } = options;\n\n    return {\n        async requestDidStart() {\n            return {\n                async didResolveOperation(requestContext: any) {\n                    try {\n                        // Provide request object compatible with limiter.extractors\n                        const req = requestContext.request?.http || {};\n                        if (resourceExtractor) {\n                            // Allow users to attach custom resource info\n                            (req as any).resource = resourceExtractor(requestContext.request);\n                        }\n\n                        const decision = await limiter.check(req);\n\n                        if (!decision.allowed) {\n                            // Short-circuit the request by adding an error\n                            requestContext.response = {\n                                http: {\n                                    status: 429,\n                                    headers: {\n                                        ...requestContext.response?.http?.headers,\n                                        'Retry-After': String(decision.retryAfter ?? 0),\n                                    },\n                                },\n                                errors: [\n                                    new Error('rate_limit_exceeded: Too many requests. Please try again later.'),\n                                ],\n                            };\n                        } else {\n                            // Attach rate limit headers for downstream\n                            requestContext.response = requestContext.response || {};\n                            requestContext.response.http = requestContext.response.http || {};\n                            requestContext.response.http.headers = {\n                                ...requestContext.response.http.headers,\n                                'RateLimit-Limit': String(decision.limit),\n                                'RateLimit-Remaining': String(Math.max(0, decision.remaining)),\n                                'RateLimit-Reset': String(decision.resetAt),\n                            };\n                        }\n                    } catch (err) {\n                        // Don't block on errors from limiter; surface as server error\n                        requestContext.errors = requestContext.errors || [];\n                        requestContext.errors.push(err as Error);\n                    }\n                },\n            };\n        },\n    };\n}\n"]}

package/dist/adapters/hono.d.mts

@@ -0,0 +1,30 @@
+import { Context, Next } from 'hono';
+import { o as RateLimiter } from '../limiter-DqVVE0Kl.mjs';
+
+/**
+ * Hono adapter for Halt rate limiting.
+ *
+ * Works on Node and on edge runtimes (Cloudflare Workers, Deno, Bun, Vercel Edge)
+ * when paired with an edge-compatible store (the in-memory store, or a Redis client
+ * satisfying `RedisClientLike`).
+ *
+ *   import { Hono } from 'hono';
+ *   import { RateLimiter, InMemoryStore, presets } from 'halt-rate';
+ *   import { haltMiddleware } from 'halt-rate/hono';
+ *
+ *   const limiter = new RateLimiter({ store: new InMemoryStore(), policy: presets.PUBLIC_API });
+ *   const app = new Hono();
+ *   app.use('*', haltMiddleware({ limiter }));
+ */
+
+interface HonoHaltOptions {
+    limiter: RateLimiter;
+    /** Custom blocked response; return a Response. */
+    onBlocked?: (c: Context) => Response | Promise<Response>;
+    /** Resolve the client IP (edge runtimes have no socket). Defaults to common headers. */
+    getClientIp?: (c: Context) => string | undefined;
+}
+/** Create a Hono middleware for rate limiting. */
+declare function haltMiddleware(options: HonoHaltOptions): (c: Context, next: Next) => Promise<Response | undefined>;
+
+export { type HonoHaltOptions, haltMiddleware };

package/dist/adapters/hono.d.ts

@@ -0,0 +1,30 @@
+import { Context, Next } from 'hono';
+import { o as RateLimiter } from '../limiter-DqVVE0Kl.js';
+
+/**
+ * Hono adapter for Halt rate limiting.
+ *
+ * Works on Node and on edge runtimes (Cloudflare Workers, Deno, Bun, Vercel Edge)
+ * when paired with an edge-compatible store (the in-memory store, or a Redis client
+ * satisfying `RedisClientLike`).
+ *
+ *   import { Hono } from 'hono';
+ *   import { RateLimiter, InMemoryStore, presets } from 'halt-rate';
+ *   import { haltMiddleware } from 'halt-rate/hono';
+ *
+ *   const limiter = new RateLimiter({ store: new InMemoryStore(), policy: presets.PUBLIC_API });
+ *   const app = new Hono();
+ *   app.use('*', haltMiddleware({ limiter }));
+ */
+
+interface HonoHaltOptions {
+    limiter: RateLimiter;
+    /** Custom blocked response; return a Response. */
+    onBlocked?: (c: Context) => Response | Promise<Response>;
+    /** Resolve the client IP (edge runtimes have no socket). Defaults to common headers. */
+    getClientIp?: (c: Context) => string | undefined;
+}
+/** Create a Hono middleware for rate limiting. */
+declare function haltMiddleware(options: HonoHaltOptions): (c: Context, next: Next) => Promise<Response | undefined>;
+
+export { type HonoHaltOptions, haltMiddleware };

package/dist/adapters/hono.js

@@ -0,0 +1,56 @@
+'use strict';
+
+// src/core/decision.ts
+function toHeaders(decision) {
+  const headers = {
+    "RateLimit-Limit": String(decision.limit),
+    "RateLimit-Remaining": String(Math.max(0, decision.remaining)),
+    "RateLimit-Reset": String(decision.resetAt)
+  };
+  if (!decision.allowed && decision.retryAfter !== void 0) {
+    headers["Retry-After"] = String(decision.retryAfter);
+  }
+  return headers;
+}
+
+// src/adapters/hono.ts
+function defaultClientIp(c) {
+  const h = (name) => c.req.header(name);
+  const xff = h("x-forwarded-for");
+  if (xff) return xff.split(",")[0].trim();
+  return h("cf-connecting-ip") || h("x-real-ip") || void 0;
+}
+function haltMiddleware(options) {
+  const { limiter, onBlocked, getClientIp = defaultClientIp } = options;
+  return async (c, next) => {
+    const request = {
+      headers: c.req.header(),
+      // Record<string, string>, lowercased keys
+      ip: getClientIp(c),
+      path: c.req.path,
+      url: c.req.url,
+      user: c.get("user")
+    };
+    const decision = await limiter.check(request);
+    for (const [key, value] of Object.entries(toHeaders(decision))) {
+      c.header(key, value);
+    }
+    if (decision.allowed) {
+      await next();
+      return;
+    }
+    if (onBlocked) return onBlocked(c);
+    return c.json(
+      {
+        error: "rate_limit_exceeded",
+        message: "Too many requests. Please try again later.",
+        retryAfter: decision.retryAfter
+      },
+      429
+    );
+  };
+}
+
+exports.haltMiddleware = haltMiddleware;
+//# sourceMappingURL=hono.js.map
+//# sourceMappingURL=hono.js.map

package/dist/adapters/hono.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/decision.ts","../../src/adapters/hono.ts"],"names":[],"mappings":";;;AAoBO,SAAS,UAAU,QAAA,EAA4C;AAClE,EAAA,MAAM,OAAA,GAAkC;AAAA,IACpC,iBAAA,EAAmB,MAAA,CAAO,QAAA,CAAS,KAAK,CAAA;AAAA,IACxC,uBAAuB,MAAA,CAAO,IAAA,CAAK,IAAI,CAAA,EAAG,QAAA,CAAS,SAAS,CAAC,CAAA;AAAA,IAC7D,iBAAA,EAAmB,MAAA,CAAO,QAAA,CAAS,OAAO;AAAA,GAC9C;AAEA,EAAA,IAAI,CAAC,QAAA,CAAS,OAAA,IAAW,QAAA,CAAS,eAAe,MAAA,EAAW;AACxD,IAAA,OAAA,CAAQ,aAAa,CAAA,GAAI,MAAA,CAAO,QAAA,CAAS,UAAU,CAAA;AAAA,EACvD;AAEA,EAAA,OAAO,OAAA;AACX;;;ACJA,SAAS,gBAAgB,CAAA,EAAgC;AACrD,EAAA,MAAM,IAAI,CAAC,IAAA,KAAiB,CAAA,CAAE,GAAA,CAAI,OAAO,IAAI,CAAA;AAC7C,EAAA,MAAM,GAAA,GAAM,EAAE,iBAAiB,CAAA;AAC/B,EAAA,IAAI,GAAA,SAAY,GAAA,CAAI,KAAA,CAAM,GAAG,CAAA,CAAE,CAAC,EAAE,IAAA,EAAK;AACvC,EAAA,OAAO,CAAA,CAAE,kBAAkB,CAAA,IAAK,CAAA,CAAE,WAAW,CAAA,IAAK,MAAA;AACtD;AAGO,SAAS,eAAe,OAAA,EAA0B;AACrD,EAAA,MAAM,EAAE,OAAA,EAAS,SAAA,EAAW,WAAA,GAAc,iBAAgB,GAAI,OAAA;AAE9D,EAAA,OAAO,OAAO,GAAY,IAAA,KAAe;AACrC,IAAA,MAAM,OAAA,GAAU;AAAA,MACZ,OAAA,EAAS,CAAA,CAAE,GAAA,CAAI,MAAA,EAAO;AAAA;AAAA,MACtB,EAAA,EAAI,YAAY,CAAC,CAAA;AAAA,MACjB,IAAA,EAAM,EAAE,GAAA,CAAI,IAAA;AAAA,MACZ,GAAA,EAAK,EAAE,GAAA,CAAI,GAAA;AAAA,MACX,IAAA,EAAM,CAAA,CAAE,GAAA,CAAI,MAAM;AAAA,KACtB;AAEA,IAAA,MAAM,QAAA,GAAW,MAAM,OAAA,CAAQ,KAAA,CAAM,OAAO,CAAA;AAE5C,IAAA,KAAA,MAAW,CAAC,KAAK,KAAK,CAAA,IAAK,OAAO,OAAA,CAAQ,SAAA,CAAU,QAAQ,CAAC,CAAA,EAAG;AAC5D,MAAA,CAAA,CAAE,MAAA,CAAO,KAAK,KAAK,CAAA;AAAA,IACvB;AAEA,IAAA,IAAI,SAAS,OAAA,EAAS;AAClB,MAAA,MAAM,IAAA,EAAK;AACX,MAAA;AAAA,IACJ;AAEA,IAAA,IAAI,SAAA,EAAW,OAAO,SAAA,CAAU,CAAC,CAAA;AACjC,IAAA,OAAO,CAAA,CAAE,IAAA;AAAA,MACL;AAAA,QACI,KAAA,EAAO,qBAAA;AAAA,QACP,OAAA,EAAS,4CAAA;AAAA,QACT,YAAY,QAAA,CAAS;AAAA,OACzB;AAAA,MACA;AAAA,KACJ;AAAA,EACJ,CAAA;AACJ","file":"hono.js","sourcesContent":["/**\n * Decision model for rate limiting results.\n */\n\nexport interface Decision {\n    /** Whether the request is allowed */\n    allowed: boolean;\n    /** Maximum number of requests allowed in the window */\n    limit: number;\n    /** Number of requests remaining in the current window */\n    remaining: number;\n    /** Unix timestamp when the limit resets */\n    resetAt: number;\n    /** Seconds to wait before retrying (only set when blocked) */\n    retryAfter?: number;\n}\n\n/**\n * Convert decision to standard rate limit headers.\n */\nexport function toHeaders(decision: Decision): Record<string, string> {\n    const headers: Record<string, string> = {\n        'RateLimit-Limit': String(decision.limit),\n        'RateLimit-Remaining': String(Math.max(0, decision.remaining)),\n        'RateLimit-Reset': String(decision.resetAt),\n    };\n\n    if (!decision.allowed && decision.retryAfter !== undefined) {\n        headers['Retry-After'] = String(decision.retryAfter);\n    }\n\n    return headers;\n}\n","/**\n * Hono adapter for Halt rate limiting.\n *\n * Works on Node and on edge runtimes (Cloudflare Workers, Deno, Bun, Vercel Edge)\n * when paired with an edge-compatible store (the in-memory store, or a Redis client\n * satisfying `RedisClientLike`).\n *\n *   import { Hono } from 'hono';\n *   import { RateLimiter, InMemoryStore, presets } from 'halt-rate';\n *   import { haltMiddleware } from 'halt-rate/hono';\n *\n *   const limiter = new RateLimiter({ store: new InMemoryStore(), policy: presets.PUBLIC_API });\n *   const app = new Hono();\n *   app.use('*', haltMiddleware({ limiter }));\n */\n\nimport type { Context, Next } from 'hono';\nimport { RateLimiter } from '../core/limiter';\nimport { toHeaders } from '../core/decision';\n\nexport interface HonoHaltOptions {\n    limiter: RateLimiter;\n    /** Custom blocked response; return a Response. */\n    onBlocked?: (c: Context) => Response | Promise<Response>;\n    /** Resolve the client IP (edge runtimes have no socket). Defaults to common headers. */\n    getClientIp?: (c: Context) => string | undefined;\n}\n\nfunction defaultClientIp(c: Context): string | undefined {\n    const h = (name: string) => c.req.header(name);\n    const xff = h('x-forwarded-for');\n    if (xff) return xff.split(',')[0].trim();\n    return h('cf-connecting-ip') || h('x-real-ip') || undefined;\n}\n\n/** Create a Hono middleware for rate limiting. */\nexport function haltMiddleware(options: HonoHaltOptions) {\n    const { limiter, onBlocked, getClientIp = defaultClientIp } = options;\n\n    return async (c: Context, next: Next) => {\n        const request = {\n            headers: c.req.header(), // Record<string, string>, lowercased keys\n            ip: getClientIp(c),\n            path: c.req.path,\n            url: c.req.url,\n            user: c.get('user'),\n        };\n\n        const decision = await limiter.check(request);\n\n        for (const [key, value] of Object.entries(toHeaders(decision))) {\n            c.header(key, value);\n        }\n\n        if (decision.allowed) {\n            await next();\n            return;\n        }\n\n        if (onBlocked) return onBlocked(c);\n        return c.json(\n            {\n                error: 'rate_limit_exceeded',\n                message: 'Too many requests. Please try again later.',\n                retryAfter: decision.retryAfter,\n            },\n            429\n        );\n    };\n}\n"]}

package/dist/adapters/hono.mjs

@@ -0,0 +1,54 @@
+// src/core/decision.ts
+function toHeaders(decision) {
+  const headers = {
+    "RateLimit-Limit": String(decision.limit),
+    "RateLimit-Remaining": String(Math.max(0, decision.remaining)),
+    "RateLimit-Reset": String(decision.resetAt)
+  };
+  if (!decision.allowed && decision.retryAfter !== void 0) {
+    headers["Retry-After"] = String(decision.retryAfter);
+  }
+  return headers;
+}
+
+// src/adapters/hono.ts
+function defaultClientIp(c) {
+  const h = (name) => c.req.header(name);
+  const xff = h("x-forwarded-for");
+  if (xff) return xff.split(",")[0].trim();
+  return h("cf-connecting-ip") || h("x-real-ip") || void 0;
+}
+function haltMiddleware(options) {
+  const { limiter, onBlocked, getClientIp = defaultClientIp } = options;
+  return async (c, next) => {
+    const request = {
+      headers: c.req.header(),
+      // Record<string, string>, lowercased keys
+      ip: getClientIp(c),
+      path: c.req.path,
+      url: c.req.url,
+      user: c.get("user")
+    };
+    const decision = await limiter.check(request);
+    for (const [key, value] of Object.entries(toHeaders(decision))) {
+      c.header(key, value);
+    }
+    if (decision.allowed) {
+      await next();
+      return;
+    }
+    if (onBlocked) return onBlocked(c);
+    return c.json(
+      {
+        error: "rate_limit_exceeded",
+        message: "Too many requests. Please try again later.",
+        retryAfter: decision.retryAfter
+      },
+      429
+    );
+  };
+}
+
+export { haltMiddleware };
+//# sourceMappingURL=hono.mjs.map
+//# sourceMappingURL=hono.mjs.map

package/dist/adapters/hono.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/decision.ts","../../src/adapters/hono.ts"],"names":[],"mappings":";AAoBO,SAAS,UAAU,QAAA,EAA4C;AAClE,EAAA,MAAM,OAAA,GAAkC;AAAA,IACpC,iBAAA,EAAmB,MAAA,CAAO,QAAA,CAAS,KAAK,CAAA;AAAA,IACxC,uBAAuB,MAAA,CAAO,IAAA,CAAK,IAAI,CAAA,EAAG,QAAA,CAAS,SAAS,CAAC,CAAA;AAAA,IAC7D,iBAAA,EAAmB,MAAA,CAAO,QAAA,CAAS,OAAO;AAAA,GAC9C;AAEA,EAAA,IAAI,CAAC,QAAA,CAAS,OAAA,IAAW,QAAA,CAAS,eAAe,MAAA,EAAW;AACxD,IAAA,OAAA,CAAQ,aAAa,CAAA,GAAI,MAAA,CAAO,QAAA,CAAS,UAAU,CAAA;AAAA,EACvD;AAEA,EAAA,OAAO,OAAA;AACX;;;ACJA,SAAS,gBAAgB,CAAA,EAAgC;AACrD,EAAA,MAAM,IAAI,CAAC,IAAA,KAAiB,CAAA,CAAE,GAAA,CAAI,OAAO,IAAI,CAAA;AAC7C,EAAA,MAAM,GAAA,GAAM,EAAE,iBAAiB,CAAA;AAC/B,EAAA,IAAI,GAAA,SAAY,GAAA,CAAI,KAAA,CAAM,GAAG,CAAA,CAAE,CAAC,EAAE,IAAA,EAAK;AACvC,EAAA,OAAO,CAAA,CAAE,kBAAkB,CAAA,IAAK,CAAA,CAAE,WAAW,CAAA,IAAK,MAAA;AACtD;AAGO,SAAS,eAAe,OAAA,EAA0B;AACrD,EAAA,MAAM,EAAE,OAAA,EAAS,SAAA,EAAW,WAAA,GAAc,iBAAgB,GAAI,OAAA;AAE9D,EAAA,OAAO,OAAO,GAAY,IAAA,KAAe;AACrC,IAAA,MAAM,OAAA,GAAU;AAAA,MACZ,OAAA,EAAS,CAAA,CAAE,GAAA,CAAI,MAAA,EAAO;AAAA;AAAA,MACtB,EAAA,EAAI,YAAY,CAAC,CAAA;AAAA,MACjB,IAAA,EAAM,EAAE,GAAA,CAAI,IAAA;AAAA,MACZ,GAAA,EAAK,EAAE,GAAA,CAAI,GAAA;AAAA,MACX,IAAA,EAAM,CAAA,CAAE,GAAA,CAAI,MAAM;AAAA,KACtB;AAEA,IAAA,MAAM,QAAA,GAAW,MAAM,OAAA,CAAQ,KAAA,CAAM,OAAO,CAAA;AAE5C,IAAA,KAAA,MAAW,CAAC,KAAK,KAAK,CAAA,IAAK,OAAO,OAAA,CAAQ,SAAA,CAAU,QAAQ,CAAC,CAAA,EAAG;AAC5D,MAAA,CAAA,CAAE,MAAA,CAAO,KAAK,KAAK,CAAA;AAAA,IACvB;AAEA,IAAA,IAAI,SAAS,OAAA,EAAS;AAClB,MAAA,MAAM,IAAA,EAAK;AACX,MAAA;AAAA,IACJ;AAEA,IAAA,IAAI,SAAA,EAAW,OAAO,SAAA,CAAU,CAAC,CAAA;AACjC,IAAA,OAAO,CAAA,CAAE,IAAA;AAAA,MACL;AAAA,QACI,KAAA,EAAO,qBAAA;AAAA,QACP,OAAA,EAAS,4CAAA;AAAA,QACT,YAAY,QAAA,CAAS;AAAA,OACzB;AAAA,MACA;AAAA,KACJ;AAAA,EACJ,CAAA;AACJ","file":"hono.mjs","sourcesContent":["/**\n * Decision model for rate limiting results.\n */\n\nexport interface Decision {\n    /** Whether the request is allowed */\n    allowed: boolean;\n    /** Maximum number of requests allowed in the window */\n    limit: number;\n    /** Number of requests remaining in the current window */\n    remaining: number;\n    /** Unix timestamp when the limit resets */\n    resetAt: number;\n    /** Seconds to wait before retrying (only set when blocked) */\n    retryAfter?: number;\n}\n\n/**\n * Convert decision to standard rate limit headers.\n */\nexport function toHeaders(decision: Decision): Record<string, string> {\n    const headers: Record<string, string> = {\n        'RateLimit-Limit': String(decision.limit),\n        'RateLimit-Remaining': String(Math.max(0, decision.remaining)),\n        'RateLimit-Reset': String(decision.resetAt),\n    };\n\n    if (!decision.allowed && decision.retryAfter !== undefined) {\n        headers['Retry-After'] = String(decision.retryAfter);\n    }\n\n    return headers;\n}\n","/**\n * Hono adapter for Halt rate limiting.\n *\n * Works on Node and on edge runtimes (Cloudflare Workers, Deno, Bun, Vercel Edge)\n * when paired with an edge-compatible store (the in-memory store, or a Redis client\n * satisfying `RedisClientLike`).\n *\n *   import { Hono } from 'hono';\n *   import { RateLimiter, InMemoryStore, presets } from 'halt-rate';\n *   import { haltMiddleware } from 'halt-rate/hono';\n *\n *   const limiter = new RateLimiter({ store: new InMemoryStore(), policy: presets.PUBLIC_API });\n *   const app = new Hono();\n *   app.use('*', haltMiddleware({ limiter }));\n */\n\nimport type { Context, Next } from 'hono';\nimport { RateLimiter } from '../core/limiter';\nimport { toHeaders } from '../core/decision';\n\nexport interface HonoHaltOptions {\n    limiter: RateLimiter;\n    /** Custom blocked response; return a Response. */\n    onBlocked?: (c: Context) => Response | Promise<Response>;\n    /** Resolve the client IP (edge runtimes have no socket). Defaults to common headers. */\n    getClientIp?: (c: Context) => string | undefined;\n}\n\nfunction defaultClientIp(c: Context): string | undefined {\n    const h = (name: string) => c.req.header(name);\n    const xff = h('x-forwarded-for');\n    if (xff) return xff.split(',')[0].trim();\n    return h('cf-connecting-ip') || h('x-real-ip') || undefined;\n}\n\n/** Create a Hono middleware for rate limiting. */\nexport function haltMiddleware(options: HonoHaltOptions) {\n    const { limiter, onBlocked, getClientIp = defaultClientIp } = options;\n\n    return async (c: Context, next: Next) => {\n        const request = {\n            headers: c.req.header(), // Record<string, string>, lowercased keys\n            ip: getClientIp(c),\n            path: c.req.path,\n            url: c.req.url,\n            user: c.get('user'),\n        };\n\n        const decision = await limiter.check(request);\n\n        for (const [key, value] of Object.entries(toHeaders(decision))) {\n            c.header(key, value);\n        }\n\n        if (decision.allowed) {\n            await next();\n            return;\n        }\n\n        if (onBlocked) return onBlocked(c);\n        return c.json(\n            {\n                error: 'rate_limit_exceeded',\n                message: 'Too many requests. Please try again later.',\n                retryAfter: decision.retryAfter,\n            },\n            429\n        );\n    };\n}\n"]}

package/dist/adapters/next.js

@@ -459,7 +459,8 @@ var RateLimiter = class {
       return decision2;
     }
     const store = this.store;
-    let algorithm = this.algorithmCache.get(policy.name);
+    const cacheKey = `${policy.name}|${policy.algorithm}|${policy.limit}|${policy.window}|${policy.burst}`;
+    let algorithm = this.algorithmCache.get(cacheKey);
     if (!algorithm) {
       if (policy.algorithm === "token_bucket" /* TOKEN_BUCKET */) {
         algorithm = new TokenBucket(policy.burst, policy.limit, policy.window);
@@ -473,7 +474,7 @@ var RateLimiter = class {
       } else {
         throw new Error(`Algorithm ${policy.algorithm} not implemented`);
       }
-      this.algorithmCache.set(policy.name, algorithm);
+      this.algorithmCache.set(cacheKey, algorithm);
     }
     const span = this.otelTracer?.startSpan?.("halt.check", { attributes: { policy: policy.name, key } });
     const state = store.get(storageKey);