limitly 1.0.2 → 3.0.0

package/dist/observability/opentelemetry.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TRACER_NAME = exports.DEFAULT_METER_NAME = void 0;
+exports.createOpenTelemetryMetricsHook = createOpenTelemetryMetricsHook;
+exports.createOpenTelemetryTracer = createOpenTelemetryTracer;
+exports.createOpenTelemetryInstrumentation = createOpenTelemetryInstrumentation;
+const api_1 = require("@opentelemetry/api");
+exports.DEFAULT_METER_NAME = "limitly";
+exports.DEFAULT_TRACER_NAME = "limitly";
+const instrumentCache = new WeakMap();
+function getMetricInstruments(meter, meterName) {
+    const cached = instrumentCache.get(meter);
+    if (cached) {
+        return cached;
+    }
+    const instruments = {
+        checksTotal: meter.createCounter(`${meterName}.check.total`, {
+            description: "Total number of rate limit checks",
+        }),
+        checkDuration: meter.createHistogram(`${meterName}.check.duration`, {
+            description: "Duration of rate limit checks",
+            unit: "ms",
+        }),
+    };
+    instrumentCache.set(meter, instruments);
+    return instruments;
+}
+function getBaseMetricAttributes(event, includeKey) {
+    const attributes = {
+        "limitly.algorithm": event.algorithm,
+        "limitly.outcome": event.type,
+    };
+    if (event.store) {
+        attributes["limitly.store"] = event.store;
+    }
+    if (includeKey) {
+        attributes["limitly.key"] = event.key;
+    }
+    return attributes;
+}
+function createOpenTelemetryMetricsHook(options = {}) {
+    const meterName = options.meterName ?? exports.DEFAULT_METER_NAME;
+    const meter = options.meter ?? api_1.metrics.getMeter(meterName);
+    const includeKey = options.includeKey ?? false;
+    const instruments = getMetricInstruments(meter, meterName);
+    return (event) => {
+        const attributes = getBaseMetricAttributes(event, includeKey);
+        instruments.checksTotal.add(1, attributes);
+        instruments.checkDuration.record(event.durationMs, attributes);
+    };
+}
+function createOpenTelemetryTracer(options = {}) {
+    const tracerName = options.tracerName ?? exports.DEFAULT_TRACER_NAME;
+    const otelTracer = options.tracer ?? api_1.trace.getTracer(tracerName);
+    return {
+        startSpan(name, attributes) {
+            const span = otelTracer.startSpan(name, { attributes }, api_1.context.active());
+            return {
+                setAttribute(key, value) {
+                    span.setAttribute(key, value);
+                },
+                setStatus(ok, message) {
+                    if (ok) {
+                        span.setStatus({ code: api_1.SpanStatusCode.OK });
+                        return;
+                    }
+                    span.setStatus({
+                        code: api_1.SpanStatusCode.ERROR,
+                        message,
+                    });
+                },
+                end() {
+                    span.end();
+                },
+            };
+        },
+    };
+}
+function createOpenTelemetryInstrumentation(options = {}) {
+    return {
+        tracer: createOpenTelemetryTracer(options),
+        onMetrics: createOpenTelemetryMetricsHook(options),
+    };
+}
+//# sourceMappingURL=opentelemetry.js.map

package/dist/observability/opentelemetry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"opentelemetry.js","sourceRoot":"","sources":["../../src/observability/opentelemetry.ts"],"names":[],"mappings":"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"}

package/dist/observability/prometheus.d.ts

@@ -0,0 +1,27 @@
+import { Registry, type RegistryContentType } from "prom-client";
+import type { RateLimitMetricsHook } from "../types";
+export declare const DEFAULT_PROMETHEUS_PREFIX = "limitly";
+export interface PrometheusExporterOptions {
+    /** Prometheus registry. Defaults to a new `Registry`. */
+    register?: Registry;
+    /** Metric name prefix. Defaults to `"limitly"`. */
+    prefix?: string;
+    /** Include the rate limit key as a label. Defaults to `false` (high cardinality). */
+    includeKey?: boolean;
+    /** Histogram buckets for check duration in seconds. */
+    durationBuckets?: number[];
+}
+export interface PrometheusExporter {
+    register: Registry;
+    onMetrics: RateLimitMetricsHook;
+    contentType: RegistryContentType;
+    getMetrics: () => Promise<string>;
+}
+export declare function createPrometheusMetricsHook(options?: PrometheusExporterOptions): RateLimitMetricsHook;
+export declare function createPrometheusExporter(options?: PrometheusExporterOptions): PrometheusExporter;
+export type PrometheusHandler = (req: unknown, res: {
+    setHeader(name: string, value: string): void;
+    end(body: string): void;
+}) => Promise<void>;
+export declare function createPrometheusHandler(exporter: PrometheusExporter): PrometheusHandler;
+//# sourceMappingURL=prometheus.d.ts.map

package/dist/observability/prometheus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prometheus.d.ts","sourceRoot":"","sources":["../../src/observability/prometheus.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,QAAQ,EACR,KAAK,mBAAmB,EACzB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAyB,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAE5E,eAAO,MAAM,yBAAyB,YAAY,CAAC;AAEnD,MAAM,WAAW,yBAAyB;IACxC,yDAAyD;IACzD,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,mDAAmD;IACnD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qFAAqF;IACrF,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,uDAAuD;IACvD,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,oBAAoB,CAAC;IAChC,WAAW,EAAE,mBAAmB,CAAC;IACjC,UAAU,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;CACnC;AA4ED,wBAAgB,2BAA2B,CACzC,OAAO,GAAE,yBAA8B,GACtC,oBAAoB,CAYtB;AAED,wBAAgB,wBAAwB,CACtC,OAAO,GAAE,yBAA8B,GACtC,kBAAkB,CAUpB;AAED,MAAM,MAAM,iBAAiB,GAAG,CAC9B,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7C,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB,KACE,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnB,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,kBAAkB,GAC3B,iBAAiB,CAMnB"}

package/dist/observability/prometheus.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PROMETHEUS_PREFIX = void 0;
+exports.createPrometheusMetricsHook = createPrometheusMetricsHook;
+exports.createPrometheusExporter = createPrometheusExporter;
+exports.createPrometheusHandler = createPrometheusHandler;
+const prom_client_1 = require("prom-client");
+exports.DEFAULT_PROMETHEUS_PREFIX = "limitly";
+const metricCache = new WeakMap();
+const DEFAULT_DURATION_BUCKETS = [
+    0.001, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1,
+];
+function getMetricSet(register, prefix, durationBuckets, includeKey) {
+    const cacheKey = `${prefix}:${includeKey ? "key" : "nokey"}`;
+    let byCacheKey = metricCache.get(register);
+    if (!byCacheKey) {
+        byCacheKey = new Map();
+        metricCache.set(register, byCacheKey);
+    }
+    const cached = byCacheKey.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const labelNames = includeKey
+        ? ["algorithm", "outcome", "store", "key"]
+        : ["algorithm", "outcome", "store"];
+    const metrics = {
+        checksTotal: new prom_client_1.Counter({
+            name: `${prefix}_check_total`,
+            help: "Total number of rate limit checks",
+            labelNames: [...labelNames],
+            registers: [register],
+        }),
+        checkDuration: new prom_client_1.Histogram({
+            name: `${prefix}_check_duration_seconds`,
+            help: "Duration of rate limit checks in seconds",
+            labelNames: [...labelNames],
+            buckets: durationBuckets,
+            registers: [register],
+        }),
+    };
+    byCacheKey.set(cacheKey, metrics);
+    return metrics;
+}
+function sanitizeLabel(value) {
+    return value.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 128);
+}
+function getLabels(event, includeKey) {
+    const labels = {
+        algorithm: event.algorithm,
+        outcome: event.type,
+        store: event.store ?? "unknown",
+    };
+    if (includeKey) {
+        labels.key = sanitizeLabel(event.key);
+    }
+    return labels;
+}
+function createPrometheusMetricsHook(options = {}) {
+    const register = options.register ?? new prom_client_1.Registry();
+    const prefix = options.prefix ?? exports.DEFAULT_PROMETHEUS_PREFIX;
+    const includeKey = options.includeKey ?? false;
+    const durationBuckets = options.durationBuckets ?? DEFAULT_DURATION_BUCKETS;
+    const metrics = getMetricSet(register, prefix, durationBuckets, includeKey);
+    return (event) => {
+        const labels = getLabels(event, includeKey);
+        metrics.checksTotal.inc(labels);
+        metrics.checkDuration.observe(labels, event.durationMs / 1000);
+    };
+}
+function createPrometheusExporter(options = {}) {
+    const register = options.register ?? new prom_client_1.Registry();
+    const onMetrics = createPrometheusMetricsHook({ ...options, register });
+    return {
+        register,
+        onMetrics,
+        contentType: register.contentType,
+        getMetrics: () => register.metrics(),
+    };
+}
+function createPrometheusHandler(exporter) {
+    return async (_req, res) => {
+        const body = await exporter.getMetrics();
+        res.setHeader("Content-Type", exporter.contentType);
+        res.end(body);
+    };
+}
+//# sourceMappingURL=prometheus.js.map

package/dist/observability/prometheus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prometheus.js","sourceRoot":"","sources":["../../src/observability/prometheus.ts"],"names":[],"mappings":";;;AAsGA,kEAcC;AAED,4DAYC;AAUD,0DAQC;AApJD,6CAKqB;AAGR,QAAA,yBAAyB,GAAG,SAAS,CAAC;AAyBnD,MAAM,WAAW,GAAG,IAAI,OAAO,EAA8C,CAAC;AAE9E,MAAM,wBAAwB,GAAG;IAC/B,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;CACnD,CAAC;AAEF,SAAS,YAAY,CACnB,QAAkB,EAClB,MAAc,EACd,eAAyB,EACzB,UAAmB;IAEnB,MAAM,QAAQ,GAAG,GAAG,MAAM,IAAI,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;IAC7D,IAAI,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC3C,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,UAAU,GAAG,IAAI,GAAG,EAAE,CAAC;QACvB,WAAW,CAAC,GAAG,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;IACxC,CAAC;IAED,MAAM,MAAM,GAAG,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACxC,IAAI,MAAM,EAAE,CAAC;QACX,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,MAAM,UAAU,GAAG,UAAU;QAC3B,CAAC,CAAE,CAAC,WAAW,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,CAAW;QACrD,CAAC,CAAE,CAAC,WAAW,EAAE,SAAS,EAAE,OAAO,CAAW,CAAC;IAEjD,MAAM,OAAO,GAAwB;QACnC,WAAW,EAAE,IAAI,qBAAO,CAAC;YACvB,IAAI,EAAE,GAAG,MAAM,cAAc;YAC7B,IAAI,EAAE,mCAAmC;YACzC,UAAU,EAAE,CAAC,GAAG,UAAU,CAAC;YAC3B,SAAS,EAAE,CAAC,QAAQ,CAAC;SACtB,CAAC;QACF,aAAa,EAAE,IAAI,uBAAS,CAAC;YAC3B,IAAI,EAAE,GAAG,MAAM,yBAAyB;YACxC,IAAI,EAAE,0CAA0C;YAChD,UAAU,EAAE,CAAC,GAAG,UAAU,CAAC;YAC3B,OAAO,EAAE,eAAe;YACxB,SAAS,EAAE,CAAC,QAAQ,CAAC;SACtB,CAAC;KACH,CAAC;IAEF,UAAU,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAClC,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,SAAS,aAAa,CAAC,KAAa;IAClC,OAAO,KAAK,CAAC,OAAO,CAAC,iBAAiB,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AAC7D,CAAC;AAED,SAAS,SAAS,CAChB,KAA4B,EAC5B,UAAmB;IAEnB,MAAM,MAAM,GAA2B;QACrC,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,OAAO,EAAE,KAAK,CAAC,IAAI;QACnB,KAAK,EAAE,KAAK,CAAC,KAAK,IAAI,SAAS;KAChC,CAAC;IAEF,IAAI,UAAU,EAAE,CAAC;QACf,MAAM,CAAC,GAAG,GAAG,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACxC,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAgB,2BAA2B,CACzC,UAAqC,EAAE;IAEvC,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,IAAI,sBAAQ,EAAE,CAAC;IACpD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,iCAAyB,CAAC;IAC3D,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,KAAK,CAAC;IAC/C,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,IAAI,wBAAwB,CAAC;IAC5E,MAAM,OAAO,GAAG,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,eAAe,EAAE,UAAU,CAAC,CAAC;IAE5E,OAAO,CAAC,KAAK,EAAE,EAAE;QACf,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;QAC5C,OAAO,CAAC,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAChC,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IACjE,CAAC,CAAC;AACJ,CAAC;AAED,SAAgB,wBAAwB,CACtC,UAAqC,EAAE;IAEvC,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,IAAI,sBAAQ,EAAE,CAAC;IACpD,MAAM,SAAS,GAAG,2BAA2B,CAAC,EAAE,GAAG,OAAO,EAAE,QAAQ,EAAE,CAAC,CAAC;IAExE,OAAO;QACL,QAAQ;QACR,SAAS;QACT,WAAW,EAAE,QAAQ,CAAC,WAAW;QACjC,UAAU,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,OAAO,EAAE;KACrC,CAAC;AACJ,CAAC;AAUD,SAAgB,uBAAuB,CACrC,QAA4B;IAE5B,OAAO,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE;QACzB,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,UAAU,EAAE,CAAC;QACzC,GAAG,CAAC,SAAS,CAAC,cAAc,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;QACpD,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAChB,CAAC,CAAC;AACJ,CAAC"}

package/dist/observability/types.d.ts

@@ -0,0 +1,9 @@
+export interface RateLimitSpan {
+    setAttribute(key: string, value: string | number | boolean): void;
+    setStatus(ok: boolean, message?: string): void;
+    end(): void;
+}
+export interface RateLimitTracer {
+    startSpan(name: string, attributes?: Record<string, string | number | boolean>): RateLimitSpan;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/observability/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/observability/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC5B,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;IAClE,SAAS,CAAC,EAAE,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/C,GAAG,IAAI,IAAI,CAAC;CACb;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,CACP,IAAI,EAAE,MAAM,EACZ,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,GACrD,aAAa,CAAC;CAClB"}

package/dist/observability/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/observability/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/observability/types.ts"],"names":[],"mappings":""}

package/dist/prometheus.d.ts

@@ -0,0 +1,3 @@
+export { createPrometheusExporter, createPrometheusHandler, createPrometheusMetricsHook, DEFAULT_PROMETHEUS_PREFIX, } from "./observability/prometheus";
+export type { PrometheusExporter, PrometheusExporterOptions, PrometheusHandler, } from "./observability/prometheus";
+//# sourceMappingURL=prometheus.d.ts.map

package/dist/prometheus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prometheus.d.ts","sourceRoot":"","sources":["../src/prometheus.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,uBAAuB,EACvB,2BAA2B,EAC3B,yBAAyB,GAC1B,MAAM,4BAA4B,CAAC;AACpC,YAAY,EACV,kBAAkB,EAClB,yBAAyB,EACzB,iBAAiB,GAClB,MAAM,4BAA4B,CAAC"}

package/dist/prometheus.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PROMETHEUS_PREFIX = exports.createPrometheusMetricsHook = exports.createPrometheusHandler = exports.createPrometheusExporter = void 0;
+var prometheus_1 = require("./observability/prometheus");
+Object.defineProperty(exports, "createPrometheusExporter", { enumerable: true, get: function () { return prometheus_1.createPrometheusExporter; } });
+Object.defineProperty(exports, "createPrometheusHandler", { enumerable: true, get: function () { return prometheus_1.createPrometheusHandler; } });
+Object.defineProperty(exports, "createPrometheusMetricsHook", { enumerable: true, get: function () { return prometheus_1.createPrometheusMetricsHook; } });
+Object.defineProperty(exports, "DEFAULT_PROMETHEUS_PREFIX", { enumerable: true, get: function () { return prometheus_1.DEFAULT_PROMETHEUS_PREFIX; } });
+//# sourceMappingURL=prometheus.js.map

package/dist/prometheus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prometheus.js","sourceRoot":"","sources":["../src/prometheus.ts"],"names":[],"mappings":";;;AAAA,yDAKoC;AAJlC,sHAAA,wBAAwB,OAAA;AACxB,qHAAA,uBAAuB,OAAA;AACvB,yHAAA,2BAA2B,OAAA;AAC3B,uHAAA,yBAAyB,OAAA"}

package/dist/scripts/concurrencyAcquire.lua

@@ -0,0 +1,34 @@
+-- Concurrency limiter using a lease-based sorted set
+-- KEYS[1] = concurrency key
+-- ARGV[1] = limit
+-- ARGV[2] = ttl (seconds)
+-- ARGV[3] = slot id
+-- ARGV[4] = current timestamp (milliseconds)
+
+local key = KEYS[1]
+local limit = tonumber(ARGV[1])
+local ttl = tonumber(ARGV[2])
+local slot_id = ARGV[3]
+local now = tonumber(ARGV[4])
+local expires_at = now + (ttl * 1000)
+
+redis.call('ZREMRANGEBYSCORE', key, '-inf', now)
+local current = redis.call('ZCARD', key)
+
+if current < limit then
+    redis.call('ZADD', key, expires_at, slot_id)
+    redis.call('PEXPIRE', key, ttl * 1000)
+    local remaining = limit - current - 1
+    local reset = math.ceil(expires_at / 1000)
+    return {1, limit, remaining, reset, 0, slot_id}
+else
+    local oldest = redis.call('ZRANGE', key, 0, 0, 'WITHSCORES')
+    local reset
+    if #oldest > 0 then
+        reset = math.ceil(tonumber(oldest[2]) / 1000)
+    else
+        reset = math.ceil(expires_at / 1000)
+    end
+    local retry_after = math.max(1, reset - math.ceil(now / 1000))
+    return {0, limit, 0, reset, retry_after, ''}
+end

package/dist/scripts/concurrencyRelease.lua

@@ -0,0 +1,9 @@
+-- Release a concurrency slot
+-- KEYS[1] = concurrency key
+-- ARGV[1] = slot id
+
+local key = KEYS[1]
+local slot_id = ARGV[1]
+
+redis.call('ZREM', key, slot_id)
+return {1}

package/dist/scripts/gcra.lua

@@ -0,0 +1,38 @@
+-- GCRA (Generic Cell Rate Algorithm) rate limiter
+-- KEYS[1] = rate limit key
+-- ARGV[1] = limit
+-- ARGV[2] = window (seconds)
+-- ARGV[3] = current timestamp (milliseconds)
+
+local key = KEYS[1]
+local limit = tonumber(ARGV[1])
+local window = tonumber(ARGV[2])
+local now = tonumber(ARGV[3])
+
+local emission_interval = (window * 1000) / limit
+local burst_tolerance = window * 1000
+
+local tat_raw = redis.call('GET', key)
+local tat = tat_raw and tonumber(tat_raw) or now
+local earliest = tat - burst_tolerance
+
+if now < earliest then
+    local retry_after = math.max(1, math.ceil((earliest - now) / 1000))
+    local reset = math.ceil(tat / 1000)
+    return {0, limit, 0, reset, retry_after}
+end
+
+local new_tat = math.max(tat, now) + emission_interval
+local ttl_ms = math.ceil(burst_tolerance + emission_interval)
+redis.call('SET', key, new_tat, 'PX', ttl_ms)
+
+local remaining = math.floor((new_tat - now + burst_tolerance - emission_interval) / emission_interval)
+if remaining < 0 then
+    remaining = 0
+end
+if remaining > limit - 1 then
+    remaining = limit - 1
+end
+
+local reset = math.ceil(new_tat / 1000)
+return {1, limit, remaining, reset, 0}

package/dist/stores/factory.d.ts

@@ -0,0 +1,5 @@
+import type { RedisLimitOptions } from "../types";
+import type { RateLimitStore, StoreType } from "./types";
+export declare function resolveStoreType(options: RedisLimitOptions): StoreType;
+export declare function createStore(options: RedisLimitOptions): RateLimitStore;
+//# sourceMappingURL=factory.d.ts.map

package/dist/stores/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/stores/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAKlD,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAIzD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,iBAAiB,GAAG,SAAS,CAQtE;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,iBAAiB,GAAG,cAAc,CAgCtE"}

package/dist/stores/factory.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveStoreType = resolveStoreType;
+exports.createStore = createStore;
+const memcached_1 = require("../utils/memcached");
+const redis_1 = require("../utils/redis");
+const memcached_store_1 = require("./memcached-store");
+const redis_store_1 = require("./redis-store");
+const REDIS_COMPATIBLE_STORES = ["redis", "valkey", "dragonfly"];
+function resolveStoreType(options) {
+    if (options.store) {
+        return options.store;
+    }
+    if (options.memcached) {
+        return "memcached";
+    }
+    return "redis";
+}
+function createStore(options) {
+    const storeType = resolveStoreType(options);
+    const keyPrefix = options.keyPrefix ?? redis_1.DEFAULT_KEY_PREFIX;
+    if (storeType === "memcached") {
+        if (!options.memcached) {
+            throw new Error('Memcached configuration is required when store is "memcached"');
+        }
+        return new memcached_store_1.MemcachedStore((0, memcached_1.createMemcachedClient)(options.memcached), keyPrefix);
+    }
+    if (!options.redis) {
+        throw new Error(`Redis configuration is required when store is "${storeType}"`);
+    }
+    if (!REDIS_COMPATIBLE_STORES.includes(storeType)) {
+        throw new Error(`Unsupported store type: ${storeType}`);
+    }
+    const client = (0, redis_1.createRedisClient)(options.redis);
+    return new redis_store_1.RedisStore(client, keyPrefix, storeType, {
+        hashTag: options.hashTag,
+        warmupScripts: options.warmupScripts,
+    });
+}
+//# sourceMappingURL=factory.js.map

package/dist/stores/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.js","sourceRoot":"","sources":["../../src/stores/factory.ts"],"names":[],"mappings":";;AASA,4CAQC;AAED,kCAgCC;AAlDD,kDAA2D;AAC3D,0CAAuE;AACvE,uDAAmD;AACnD,+CAA2C;AAG3C,MAAM,uBAAuB,GAAgB,CAAC,OAAO,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC;AAE9E,SAAgB,gBAAgB,CAAC,OAA0B;IACzD,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;QAClB,OAAO,OAAO,CAAC,KAAK,CAAC;IACvB,CAAC;IACD,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;QACtB,OAAO,WAAW,CAAC;IACrB,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,SAAgB,WAAW,CAAC,OAA0B;IACpD,MAAM,SAAS,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAC5C,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,0BAAkB,CAAC;IAE1D,IAAI,SAAS,KAAK,WAAW,EAAE,CAAC;QAC9B,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC;YACvB,MAAM,IAAI,KAAK,CACb,+DAA+D,CAChE,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,gCAAc,CACvB,IAAA,iCAAqB,EAAC,OAAO,CAAC,SAAS,CAAC,EACxC,SAAS,CACV,CAAC;IACJ,CAAC;IAED,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QACnB,MAAM,IAAI,KAAK,CACb,kDAAkD,SAAS,GAAG,CAC/D,CAAC;IACJ,CAAC;IAED,IAAI,CAAC,uBAAuB,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;QACjD,MAAM,IAAI,KAAK,CAAC,2BAA2B,SAAS,EAAE,CAAC,CAAC;IAC1D,CAAC;IAED,MAAM,MAAM,GAAG,IAAA,yBAAiB,EAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAEhD,OAAO,IAAI,wBAAU,CAAC,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE;QAClD,OAAO,EAAE,OAAO,CAAC,OAAO;QACxB,aAAa,EAAE,OAAO,CAAC,aAAa;KACrC,CAAC,CAAC;AACL,CAAC"}

package/dist/stores/memcached-store.d.ts

@@ -0,0 +1,16 @@
+import type { RateLimitResult } from "../types";
+import type { MemcachedClient } from "../types";
+import type { RateLimitStore } from "./types";
+export declare class MemcachedStore implements RateLimitStore {
+    readonly type: "memcached";
+    private readonly client;
+    private readonly keyPrefix;
+    constructor(client: MemcachedClient, keyPrefix: string);
+    getClient(): MemcachedClient;
+    slidingWindow(key: string, limit: number, window: number): Promise<RateLimitResult>;
+    tokenBucket(key: string, capacity: number, refillRate: number): Promise<RateLimitResult>;
+    gcra(key: string, limit: number, window: number): Promise<RateLimitResult>;
+    concurrencyAcquire(key: string, limit: number, ttl: number): Promise<RateLimitResult>;
+    concurrencyRelease(key: string, _slotId: string): Promise<void>;
+}
+//# sourceMappingURL=memcached-store.d.ts.map

package/dist/stores/memcached-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memcached-store.d.ts","sourceRoot":"","sources":["../../src/stores/memcached-store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAUhD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAI9C,qBAAa,cAAe,YAAW,cAAc;IACnD,QAAQ,CAAC,IAAI,EAAG,WAAW,CAAU;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkB;IACzC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAEvB,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM;IAKtD,SAAS,IAAI,eAAe;IAItB,aAAa,CACjB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,eAAe,CAAC;IA4CrB,WAAW,CACf,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,eAAe,CAAC;IAmGrB,IAAI,CACR,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,eAAe,CAAC;IAoErB,kBAAkB,CACtB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,eAAe,CAAC;IA4BrB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CA2BtE"}

package/dist/stores/memcached-store.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemcachedStore = void 0;
+const crypto_1 = require("crypto");
+const redis_1 = require("../utils/redis");
+const memcached_1 = require("../utils/memcached");
+const CAS_RETRIES = 5;
+class MemcachedStore {
+    constructor(client, keyPrefix) {
+        this.type = "memcached";
+        this.client = client;
+        this.keyPrefix = keyPrefix;
+    }
+    getClient() {
+        return this.client;
+    }
+    async slidingWindow(key, limit, window) {
+        const baseKey = (0, redis_1.buildKey)(this.keyPrefix, `sw:${key}`);
+        const now = Date.now();
+        const windowMs = window * 1000;
+        const currentWindow = Math.floor(now / windowMs);
+        const previousWindow = currentWindow - 1;
+        const elapsedRatio = (now % windowMs) / windowMs;
+        const currentKey = `${baseKey}:${currentWindow}`;
+        const previousKey = `${baseKey}:${previousWindow}`;
+        await (0, memcached_1.memcachedAdd)(this.client, currentKey, "0", window * 2);
+        const currentCount = await (0, memcached_1.memcachedIncr)(this.client, currentKey, 1);
+        const previousRaw = await (0, memcached_1.memcachedGet)(this.client, previousKey);
+        const previousCount = previousRaw ? Number(previousRaw) : 0;
+        const weightedCount = previousCount * (1 - elapsedRatio) + currentCount;
+        const reset = Math.ceil((now + windowMs) / 1000);
+        if (weightedCount <= limit) {
+            return {
+                allowed: true,
+                limit,
+                remaining: Math.max(0, Math.floor(limit - weightedCount)),
+                reset,
+            };
+        }
+        const retryAfter = Math.max(1, Math.ceil((1 - elapsedRatio) * window));
+        return {
+            allowed: false,
+            limit,
+            remaining: 0,
+            reset,
+            retryAfter,
+        };
+    }
+    async tokenBucket(key, capacity, refillRate) {
+        const cacheKey = (0, redis_1.buildKey)(this.keyPrefix, `tb:${key}`);
+        const now = Date.now();
+        const ttl = Math.ceil(capacity / refillRate) + 1;
+        for (let attempt = 0; attempt < CAS_RETRIES; attempt++) {
+            const existing = await (0, memcached_1.memcachedGets)(this.client, cacheKey);
+            let tokens;
+            let lastRefill;
+            if (!existing) {
+                tokens = capacity;
+                lastRefill = now;
+            }
+            else {
+                const parsed = JSON.parse(existing.value);
+                tokens = parsed.tokens;
+                lastRefill = parsed.lastRefill;
+            }
+            const elapsed = (now - lastRefill) / 1000;
+            tokens = Math.min(capacity, tokens + elapsed * refillRate);
+            lastRefill = now;
+            if (tokens < 1) {
+                const retryAfter = Math.max(1, Math.ceil((1 - tokens) / refillRate));
+                const reset = Math.ceil(now / 1000) + retryAfter;
+                if (!existing) {
+                    await (0, memcached_1.memcachedAdd)(this.client, cacheKey, JSON.stringify({ tokens, lastRefill }), ttl);
+                }
+                else {
+                    await (0, memcached_1.memcachedCas)(this.client, cacheKey, JSON.stringify({ tokens, lastRefill }), existing.cas, ttl);
+                }
+                return {
+                    allowed: false,
+                    limit: capacity,
+                    remaining: 0,
+                    reset,
+                    retryAfter,
+                };
+            }
+            tokens -= 1;
+            const payload = JSON.stringify({ tokens, lastRefill });
+            if (!existing) {
+                try {
+                    await (0, memcached_1.memcachedAdd)(this.client, cacheKey, payload, ttl);
+                    return {
+                        allowed: true,
+                        limit: capacity,
+                        remaining: Math.floor(tokens),
+                        reset: Math.ceil(now / 1000) +
+                            Math.ceil((capacity - tokens) / refillRate),
+                    };
+                }
+                catch {
+                    continue;
+                }
+            }
+            const updated = await (0, memcached_1.memcachedCas)(this.client, cacheKey, payload, existing.cas, ttl);
+            if (updated) {
+                return {
+                    allowed: true,
+                    limit: capacity,
+                    remaining: Math.floor(tokens),
+                    reset: Math.ceil(now / 1000) +
+                        Math.ceil((capacity - tokens) / refillRate),
+                };
+            }
+        }
+        throw new Error("Token bucket CAS retries exhausted");
+    }
+    async gcra(key, limit, window) {
+        const cacheKey = (0, redis_1.buildKey)(this.keyPrefix, `gcra:${key}`);
+        const now = Date.now();
+        const emissionInterval = (window * 1000) / limit;
+        const burstTolerance = window * 1000;
+        const ttl = Math.ceil(window) + 1;
+        for (let attempt = 0; attempt < CAS_RETRIES; attempt++) {
+            const existing = await (0, memcached_1.memcachedGets)(this.client, cacheKey);
+            const tat = existing ? Number(existing.value) : now;
+            const earliest = tat - burstTolerance;
+            if (now < earliest) {
+                const retryAfter = Math.max(1, Math.ceil((earliest - now) / 1000));
+                const reset = Math.ceil(tat / 1000);
+                return {
+                    allowed: false,
+                    limit,
+                    remaining: 0,
+                    reset,
+                    retryAfter,
+                };
+            }
+            const newTat = Math.max(tat, now) + emissionInterval;
+            let remaining = Math.floor((newTat - now + burstTolerance - emissionInterval) / emissionInterval);
+            remaining = Math.max(0, Math.min(limit - 1, remaining));
+            const reset = Math.ceil(newTat / 1000);
+            const payload = String(newTat);
+            if (!existing) {
+                try {
+                    await (0, memcached_1.memcachedAdd)(this.client, cacheKey, payload, ttl);
+                    return {
+                        allowed: true,
+                        limit,
+                        remaining,
+                        reset,
+                    };
+                }
+                catch {
+                    continue;
+                }
+            }
+            const updated = await (0, memcached_1.memcachedCas)(this.client, cacheKey, payload, existing.cas, ttl);
+            if (updated) {
+                return {
+                    allowed: true,
+                    limit,
+                    remaining,
+                    reset,
+                };
+            }
+        }
+        throw new Error("GCRA CAS retries exhausted");
+    }
+    async concurrencyAcquire(key, limit, ttl) {
+        const counterKey = (0, redis_1.buildKey)(this.keyPrefix, `cc:${key}`);
+        const slotId = (0, crypto_1.randomUUID)();
+        await (0, memcached_1.memcachedAdd)(this.client, counterKey, "0", ttl);
+        const count = await (0, memcached_1.memcachedIncr)(this.client, counterKey, 1);
+        const reset = Math.ceil(Date.now() / 1000) + ttl;
+        if (count > limit) {
+            await (0, memcached_1.memcachedDecr)(this.client, counterKey, 1);
+            return {
+                allowed: false,
+                limit,
+                remaining: 0,
+                reset,
+                retryAfter: ttl,
+            };
+        }
+        return {
+            allowed: true,
+            limit,
+            remaining: Math.max(0, limit - count),
+            reset,
+            slotId,
+        };
+    }
+    async concurrencyRelease(key, _slotId) {
+        const counterKey = (0, redis_1.buildKey)(this.keyPrefix, `cc:${key}`);
+        for (let attempt = 0; attempt < CAS_RETRIES; attempt++) {
+            const current = await (0, memcached_1.memcachedGets)(this.client, counterKey);
+            if (!current) {
+                return;
+            }
+            const value = Number(current.value);
+            if (value <= 0) {
+                return;
+            }
+            const updated = await (0, memcached_1.memcachedCas)(this.client, counterKey, String(value - 1), current.cas, 300);
+            if (updated) {
+                return;
+            }
+        }
+    }
+}
+exports.MemcachedStore = MemcachedStore;
+//# sourceMappingURL=memcached-store.js.map