@voltro/plugin-ratelimit 0.82.0 → 0.83.1

package/dist/index.js

@@ -1,23 +1,23 @@
 import { RateLimited as e } from "./errors.js";
-import { n as t, t as n } from "./window-lyQ6LXhj.js";
-import { redisStore as r } from "./redisStore.js";
-import { Effect as i } from "effect";
-import { createLogger as a } from "@voltro/logger";
-import { replicaEvidence as o } from "@voltro/protocol/identity";
-import { definePlugin as s, pluginInstanceName as c } from "@voltro/protocol";
+import { a as t, i as n, n as r, r as i, t as a } from "./postgresStore-CDP61pxx.js";
+import { redisStore as o } from "./redisStore.js";
+import { Effect as s } from "effect";
+import { createLogger as c } from "@voltro/logger";
+import { replicaEvidence as l } from "@voltro/protocol/identity";
+import { definePlugin as u, pluginInstanceName as d } from "@voltro/protocol";
 //#region src/inspect.ts
-var l = (e) => typeof e == "function" ? "dynamic" : e, u = (e) => typeof e == "function" ? "dynamic" : e, d = (e, n) => ({
+var f = (e) => typeof e == "function" ? "dynamic" : e, p = (e) => typeof e == "function" ? "dynamic" : e, m = (e, n) => ({
 	id: n === null ? "default" : `r${n}`,
 	match: "match" in e ? e.match instanceof RegExp ? String(e.match) : Array.isArray(e.match) ? e.match.join(", ") : e.match ?? "*" : "*",
 	kinds: e.kind === void 0 ? [] : typeof e.kind == "string" ? [e.kind] : e.kind,
-	limit: l(e.limit),
+	limit: f(e.limit),
 	windowMs: typeof e.window == "function" ? "dynamic" : t(e.window),
 	algorithm: e.algorithm ?? "sliding-window",
-	burst: e.burst === void 0 ? l(e.limit) : l(e.burst),
-	by: Array.isArray(e.by) ? e.by.map(u) : [u(e.by ?? "subject")],
+	burst: e.burst === void 0 ? f(e.limit) : f(e.burst),
+	by: Array.isArray(e.by) ? e.by.map(p) : [p(e.by ?? "subject")],
 	scope: e.scope ?? "tag",
 	tenantOverrides: Object.keys(e.tenants ?? {}).length
-}), f = () => ({
+}), h = () => ({
 	allowed: 0,
 	rejected: 0,
 	bypassed: 0,
@@ -25,11 +25,11 @@ var l = (e) => typeof e == "function" ? "dynamic" : e, u = (e) => typeof e == "f
 	storeErrors: 0,
 	lastRejectedAt: null,
 	lastStoreErrorAt: null
-}), p = (e, n) => {
+}), g = (e, n) => {
 	let r = Date.now(), i = {
-		rpc: f(),
-		http: f()
-	}, a = n.bindSql ? "waiting" : "not-required";
+		rpc: h(),
+		http: h()
+	}, a = n.bind ? "waiting" : "not-required";
 	return {
 		binding: (e) => {
 			a = e;
@@ -59,8 +59,8 @@ var l = (e) => typeof e == "function" ? "dynamic" : e, u = (e) => typeof e == "f
 					sqlBinding: a,
 					trackedBuckets: o
 				},
-				rules: (e.rules ?? []).map((e, t) => d(e, t)),
-				defaultRule: e.default ? d(e.default, null) : null,
+				rules: (e.rules ?? []).map((e, t) => m(e, t)),
+				defaultRule: e.default ? m(e.default, null) : null,
 				http: e.http ? {
 					limit: e.http.limit,
 					windowMs: t(e.http.window),
@@ -73,51 +73,34 @@ var l = (e) => typeof e == "function" ? "dynamic" : e, u = (e) => typeof e == "f
 			};
 		}
 	};
-}, m = (e = {}) => {
-	let t = e.maxKeys ?? 1e5, r = e.staleAfterMs ?? 36e5, a = /* @__PURE__ */ new Map(), o = (e) => {
-		if (a.size <= t) return;
-		let n = a.size - t, r = 0;
-		for (let t of a.keys()) {
+}, _ = (e = {}) => {
+	let t = e.maxKeys ?? 1e5, r = e.staleAfterMs ?? 36e5, i = /* @__PURE__ */ new Map(), a = (e) => {
+		if (i.size <= t) return;
+		let n = i.size - t, r = 0;
+		for (let t of i.keys()) {
 			if (r >= n) break;
-			t !== e && (a.delete(t), r += 1);
+			t !== e && (i.delete(t), r += 1);
 		}
 	};
 	return {
-		consume: (e, t, r) => i.sync(() => {
-			let i = a.get(e), { state: s, decision: c } = n(i?.state, t, r);
-			return a.set(e, {
+		consume: (e, t, r) => s.sync(() => {
+			let o = i.get(e), { state: s, decision: c } = n(o?.state, t, r);
+			return i.set(e, {
 				state: s,
 				touched: r
-			}), o(e), c;
+			}), a(e), c;
 		}),
 		sweep: (e) => {
 			let t = e - r;
-			for (let [e, n] of a) n.touched < t && a.delete(e);
+			for (let [e, n] of i) n.touched < t && i.delete(e);
 		},
-		size: () => a.size
+		size: () => i.size
 	};
-}, h = (e, t) => ({
-	allowed: !0,
-	failOpenReason: "unbound",
-	remaining: e.limit,
-	resetAtMs: t + e.windowMs,
-	retryAfterMs: 0
-}), g = (e = {}) => {
-	let t = null;
-	return {
-		consume: (e, n, r) => t ? t.consume(e, n, r) : i.succeed(h(n, r)),
-		sweep: (e) => t?.sweep(e),
-		size: () => t ? t.size() : -1,
-		bindSql: async (n) => {
-			let { postgresStore: r } = await import("./postgresStore.js"), i = r(e);
-			await i.bindSql(n), t = i;
-		}
-	};
-}, _ = (e, t) => typeof e == "function" ? e(t) : e, v = /* @__PURE__ */ new WeakMap(), y = (e) => {
+}, v = (e, t) => typeof e == "function" ? e(t) : e, y = /* @__PURE__ */ new WeakMap(), b = (e) => {
 	if (!e.global && !e.sticky) return e;
-	let t = v.get(e);
-	return t === void 0 && (t = new RegExp(e.source, e.flags.replace(/[gy]/g, "")), v.set(e, t)), t;
-}, b = (e, t) => e === void 0 ? !0 : typeof e == "string" ? e === t : Array.isArray(e) ? e.includes(t) : y(e).test(t), x = (e, t) => e === void 0 ? !0 : Array.isArray(e) ? e.includes(t) : e === t, S = (e, t) => {
+	let t = y.get(e);
+	return t === void 0 && (t = new RegExp(e.source, e.flags.replace(/[gy]/g, "")), y.set(e, t)), t;
+}, x = (e, t) => e === void 0 ? !0 : typeof e == "string" ? e === t : Array.isArray(e) ? e.includes(t) : b(e).test(t), S = (e, t) => e === void 0 ? !0 : Array.isArray(e) ? e.includes(t) : e === t, C = (e, t) => {
 	let n = t === null ? void 0 : e.tenants?.[t];
 	return {
 		limit: n?.limit ?? e.limit,
@@ -128,27 +111,27 @@ var l = (e) => typeof e == "function" ? "dynamic" : e, u = (e) => typeof e == "f
 		scope: e.scope ?? "tag",
 		disabled: n?.disabled ?? !1
 	};
-}, C = (e, t, n) => {
+}, w = (e, t, n) => {
 	for (let t = 0; t < e.length; t++) {
 		let r = e[t];
-		if (b(r.match, n.tag) && x(r.kind, n.kind)) return {
-			effective: S(r, n.tenantId),
+		if (x(r.match, n.tag) && S(r.kind, n.kind)) return {
+			effective: C(r, n.tenantId),
 			ruleId: `r${t}`
 		};
 	}
-	if (t && x(t.kind, n.kind)) return {
-		effective: S(t, n.tenantId),
+	if (t && S(t.kind, n.kind)) return {
+		effective: C(t, n.tenantId),
 		ruleId: "default"
 	};
-}, w = (e, n) => {
-	let r = _(e.limit, n);
+}, T = (e, n) => {
+	let r = v(e.limit, n);
 	return {
 		limit: r,
-		windowMs: t(_(e.window, n)),
+		windowMs: t(v(e.window, n)),
 		algorithm: e.algorithm ?? "sliding-window",
-		burst: e.burst === void 0 ? r : _(e.burst, n)
+		burst: e.burst === void 0 ? r : v(e.burst, n)
 	};
-}, T = (e) => {
+}, E = (e) => {
 	let n = e.limit;
 	return {
 		limit: n,
@@ -156,12 +139,12 @@ var l = (e) => typeof e == "function" ? "dynamic" : e, u = (e) => typeof e == "f
 		algorithm: e.algorithm ?? "sliding-window",
 		burst: e.burst ?? n
 	};
-}, E = (e) => ({
+}, D = (e) => ({
 	limit: e.limit,
 	window: e.windowMs,
 	algorithm: e.algorithm,
 	burst: e.burst
-}), D = (e, t) => {
+}), O = (e, t) => {
 	if (typeof e == "function") return e(t);
 	switch (e) {
 		case "subject": return `s:${t.tenantId ?? "∅"}:${t.subject.id ?? "anon"}`;
@@ -170,10 +153,10 @@ var l = (e) => typeof e == "function" ? "dynamic" : e, u = (e) => typeof e == "f
 		case "global": return "g";
 		case "ip": return `i:${t.remoteAddr ?? "unknown"}`;
 	}
-}, O = (e, t) => {
+}, k = (e, t) => {
 	let { effective: n, ruleId: r } = e, i = n.scope === "rule" ? `rule#${r}` : `tag:${t.tag}`, a = n.by;
-	return `${i}|${Array.isArray(a) ? a.map((e) => D(e, t)).join("|") : D(a, t)}`;
-}, k = (e) => ({
+	return `${i}|${Array.isArray(a) ? a.map((e) => O(e, t)).join("|") : O(a, t)}`;
+}, A = (e) => ({
 	tag: e.tag,
 	kind: e.kind,
 	subject: e.subject,
@@ -182,7 +165,7 @@ var l = (e) => typeof e == "function" ? "dynamic" : e, u = (e) => typeof e == "f
 	...e.surface === void 0 ? {} : { surface: e.surface },
 	...e.remoteAddr === void 0 ? {} : { remoteAddr: e.remoteAddr },
 	...e.surface === "rest" && e.publicApi?.rateLimit !== void 0 ? { publicApiRateLimit: e.publicApi.rateLimit } : {}
-}), A = (e) => e.publicApiRateLimit === void 0 ? void 0 : {
+}), j = (e) => e.publicApiRateLimit === void 0 ? void 0 : {
 	ruleId: "publicApi",
 	effective: {
 		limit: e.publicApiRateLimit.limit,
@@ -193,7 +176,7 @@ var l = (e) => typeof e == "function" ? "dynamic" : e, u = (e) => typeof e == "f
 		scope: "tag",
 		disabled: !1
 	}
-}, j = (e) => {
+}, M = (e) => {
 	let t = e, n = Date.now();
 	return {
 		"retry-after": String(Math.max(1, Math.ceil(t.retryAfterMs / 1e3))),
@@ -201,11 +184,11 @@ var l = (e) => typeof e == "function" ? "dynamic" : e, u = (e) => typeof e == "f
 		"ratelimit-remaining": "0",
 		"ratelimit-reset": String(Math.max(0, Math.ceil((t.resetAtMs - n) / 1e3)))
 	};
-}, M = a({ scope: "voltro:ratelimit" }), N = (n = {}) => {
-	let a = n.rules ?? [], l = n.store === void 0 || n.store === "memory" ? m() : n.store === "postgres" ? g() : n.store === "redis" ? r() : n.store, u = p(n, l), d = (e) => {
+}, N = c({ scope: "voltro:ratelimit" }), P = (n = {}) => {
+	let a = n.rules ?? [], c = n.store === void 0 || n.store === "memory" ? _() : n.store === "postgres" ? r() : n.store === "redis" ? o() : n.store, f = g(n, c), p = (e) => {
 		let t = n.enabled;
 		return t === void 0 ? !0 : typeof t == "function" ? t(e) : t;
-	}, f = (e, t, r, i) => {
+	}, m = (e, t, r, i) => {
 		if (!n.onLimited) return;
 		let a = {
 			tag: e.tag,
@@ -221,87 +204,88 @@ var l = (e) => typeof e == "function" ? "dynamic" : e, u = (e) => typeof e == "f
 		} catch {}
 	}, h = (e, t) => {
 		let r = n.resolve;
-		return r ? i.suspend(() => {
+		return r ? s.suspend(() => {
 			let n = r(e, t);
-			return (i.isEffect(n) ? n : n instanceof Promise ? i.promise(() => n) : i.succeed(n)).pipe(i.map((e) => e === "exempt" ? "exempt" : T(e === void 0 ? t : e)));
-		}) : i.succeed(T(t));
-	}, _ = (t, r) => i.suspend(() => {
-		let o = k(r);
-		if (!d(o)) return u.bypass(), t;
-		let s = A(o) ?? C(a, n.default, o);
-		if (!s || s.effective.disabled) return u.bypass(), t;
-		let c = E(w(s.effective, o));
-		return h(o, c).pipe(i.flatMap((n) => {
-			if (n === "exempt") return u.bypass(), t;
-			let r = O(s, o);
-			return l.consume(r, n, Date.now()).pipe(i.catchAllDefect((e) => i.as(i.logWarning(`[ratelimit] store error — failing open for ${o.tag}: ${String(e)}`), {
+			return (s.isEffect(n) ? n : n instanceof Promise ? s.promise(() => n) : s.succeed(n)).pipe(s.map((e) => e === "exempt" ? "exempt" : E(e === void 0 ? t : e)));
+		}) : s.succeed(E(t));
+	}, v = (t, r) => s.suspend(() => {
+		let i = A(r);
+		if (!p(i)) return f.bypass(), t;
+		let o = j(i) ?? w(a, n.default, i);
+		if (!o || o.effective.disabled) return f.bypass(), t;
+		let l = D(T(o.effective, i));
+		return h(i, l).pipe(s.flatMap((n) => {
+			if (n === "exempt") return f.bypass(), t;
+			let r = k(o, i);
+			return c.consume(r, n, Date.now()).pipe(s.catchAllDefect((e) => s.as(s.logWarning(`[ratelimit] store error — failing open for ${i.tag}: ${String(e)}`), {
 				allowed: !0,
 				failOpenReason: "store-error",
 				remaining: n.limit,
 				resetAtMs: Date.now(),
 				retryAfterMs: 0
-			})), i.tap((e) => i.sync(() => u.record("rpc", e))), i.flatMap((a) => a.allowed ? t : i.zipRight(i.sync(() => f(o, r, n, a)), i.fail(new e({
-				tag: o.tag,
+			})), s.tap((e) => s.sync(() => f.record("rpc", e))), s.flatMap((a) => a.allowed ? t : s.zipRight(s.sync(() => m(i, r, n, a)), s.fail(new e({
+				tag: i.tag,
 				limit: n.limit,
 				windowMs: n.windowMs,
 				retryAfterMs: a.retryAfterMs,
 				resetAtMs: a.resetAtMs
 			})))));
 		}));
-	}), v = n.http ? async (e, r) => {
-		let a = n.http, o = {
-			limit: a.limit,
-			windowMs: t(a.window),
-			algorithm: a.algorithm ?? "fixed-window",
-			burst: a.limit
-		}, s = r.remoteAddr ?? "unknown", c = Date.now(), d;
+	}), y = n.http ? async (e, r) => {
+		let i = n.http, a = {
+			limit: i.limit,
+			windowMs: t(i.window),
+			algorithm: i.algorithm ?? "fixed-window",
+			burst: i.limit
+		}, o = r.remoteAddr ?? "unknown", l = Date.now(), u;
 		try {
-			d = await i.runPromise(l.consume(`http:ip:${s}`, o, c));
+			u = await s.runPromise(c.consume(`http:ip:${o}`, a, l));
 		} catch (t) {
-			return u.record("http", {
+			return f.record("http", {
 				allowed: !0,
 				failOpenReason: "store-error",
 				remaining: 0,
-				resetAtMs: c,
+				resetAtMs: l,
 				retryAfterMs: 0
-			}), M.warn("http shield store failure — request ALLOWED without a limit check", { cause: String(t) }), e();
+			}), N.warn("http shield store failure — request ALLOWED without a limit check", { cause: String(t) }), e();
 		}
-		u.record("http", d);
-		let f = String(Math.max(0, Math.ceil((d.resetAtMs - c) / 1e3)));
-		return d.allowed ? e() : {
+		f.record("http", u);
+		let d = String(Math.max(0, Math.ceil((u.resetAtMs - l) / 1e3)));
+		return u.allowed ? e() : {
 			status: 429,
 			body: "Too Many Requests",
 			headers: {
 				"content-type": "text/plain; charset=utf-8",
-				"retry-after": String(Math.max(1, Math.ceil(d.retryAfterMs / 1e3))),
-				"ratelimit-limit": String(o.limit),
-				"ratelimit-remaining": String(Math.max(0, d.remaining)),
-				"ratelimit-reset": f
+				"retry-after": String(Math.max(1, Math.ceil(u.retryAfterMs / 1e3))),
+				"ratelimit-limit": String(a.limit),
+				"ratelimit-remaining": String(Math.max(0, u.remaining)),
+				"ratelimit-reset": d
 			}
 		};
-	} : void 0, y = [
+	} : void 0, b = [
 		"inspect:read",
 		"rpc:intercept:mutation",
 		"rpc:intercept:query",
 		"rpc:intercept:action",
 		"rpc:intercept:workflow",
-		...n.http ? ["http:intercept"] : []
-	], b, x;
-	return s({
-		name: c({
+		...n.http ? ["http:intercept"] : [],
+		...n.store === "postgres" ? ["store:write"] : []
+	], x, S;
+	return u({
+		name: d({
 			base: "@voltro/plugin-ratelimit",
 			instance: n.name
 		}),
 		description: "Per-endpoint / per-subject / per-tenant rate limiting via the rpc interceptors. Configurable rules, three algorithms, static + dynamic per-tenant overrides.",
-		permissions: y,
+		permissions: b,
 		inspectEndpoints: [{
 			method: "GET",
 			path: "/state",
 			scope: "process",
 			description: "Declared rules and process-local limiting evidence, without bucket identities.",
-			handler: () => i.sync(() => ({
+			handler: () => s.sync(() => ({
 				kind: "json",
-				data: u.snapshot()
+				data: f.snapshot()
 			}))
 		}],
 		declaredEnv: [
@@ -336,7 +320,7 @@ var l = (e) => typeof e == "function" ? "dynamic" : e, u = (e) => typeof e == "f
 				description: "Fallback Upstash REST token for the http redis driver."
 			}
 		],
-		...v ? { onHttpRequest: v } : {},
+		...y ? { onHttpRequest: y } : {},
 		errorSchemas: [{
 			schema: e,
 			import: {
@@ -345,34 +329,34 @@ var l = (e) => typeof e == "function" ? "dynamic" : e, u = (e) => typeof e == "f
 			},
 			rest: {
 				status: 429,
-				headers: j
+				headers: M
 			}
 		}],
-		interceptMutation: _,
-		interceptQuery: _,
-		interceptAction: _,
-		interceptWorkflow: _,
-		bindDataStore: (e, t) => {
-			let n = t?.sql;
-			n && l.bindSql && (u.binding("binding"), l.bindSql(n).then(() => {
-				x = void 0, u.binding("bound");
+		interceptMutation: v,
+		interceptQuery: v,
+		interceptAction: v,
+		interceptWorkflow: v,
+		...n.store === "postgres" ? { extendSchema: { tables: [i] } } : {},
+		bindDataStore: (e) => {
+			c.bind && (f.binding("binding"), c.bind(e).then(() => {
+				S = void 0, f.binding("bound");
 			}).catch((e) => {
-				u.binding("failed"), x = e;
+				f.binding("failed"), S = e;
 			}));
 		},
-		onActivate: (e) => i.gen(function* () {
-			l.activate && (yield* i.promise(() => l.activate(e.env))), b = setInterval(() => l.sweep(Date.now()), 6e4), b.unref?.(), x !== void 0 && e.logger.warn("rate-limit: SQL store bind failed — limiter runs fail-open", { error: x instanceof Error ? x.message : String(x) });
-			let t = n.store === void 0 || n.store === "memory" ? o(e.env) : null;
+		onActivate: (e) => s.gen(function* () {
+			c.activate && (yield* s.promise(() => c.activate(e.env))), x = setInterval(() => c.sweep(Date.now()), 6e4), x.unref?.(), S !== void 0 && e.logger.warn("rate-limit: SQL store bind failed — limiter runs fail-open", { error: S instanceof Error ? S.message : String(S) });
+			let t = n.store === void 0 || n.store === "memory" ? l(e.env) : null;
 			t !== null && e.logger.warn(`rate-limit: the counter store is PROCESS-LOCAL (the default), but ${t}, which means several replicas. Each pod counts on its own, so every limit is effectively multiplied by the number of replicas. Set \`store: 'redis'\` or \`store: 'postgres'\` to share the counters.`), e.logger.info("rate-limit active", {
 				rules: a.length,
 				hasDefault: n.default !== void 0,
 				store: typeof n.store == "string" ? n.store : n.store === void 0 ? "memory" : "custom"
 			});
 		}),
-		onDeactivate: () => i.gen(function* () {
-			b && clearInterval(b), l.deactivate && (yield* i.promise(() => l.deactivate()));
+		onDeactivate: () => s.gen(function* () {
+			x && clearInterval(x), c.deactivate && (yield* s.promise(() => c.deactivate()));
 		})
 	});
 };
 //#endregion
-export { e as RateLimited, n as consumeBucket, m as memoryStore, t as parseWindow, N as rateLimitPlugin, r as redisStore };
+export { a as RATELIMIT_TABLE, e as RateLimited, n as consumeBucket, _ as memoryStore, t as parseWindow, r as postgresStore, P as rateLimitPlugin, i as rateLimitTable, o as redisStore };

package/dist/postgresStore-CDP61pxx.js

@@ -0,0 +1,160 @@
+import { Effect as e } from "effect";
+import { dropped as t, eq as n, id as r, json as i, lt as a, queryFor as o, table as s, text as c, timestamp as l } from "@voltro/database";
+//#region src/window.ts
+var u = {
+	ms: 1,
+	s: 1e3,
+	m: 6e4,
+	h: 36e5,
+	d: 864e5
+}, d = (e) => {
+	if (typeof e == "number") {
+		if (!Number.isFinite(e) || e <= 0) throw Error(`@voltro/plugin-ratelimit: window must be a positive number, got ${e}`);
+		return e;
+	}
+	let t = /^(\d+(?:\.\d+)?)(ms|s|m|h|d)$/.exec(e.trim());
+	if (!t) throw Error(`@voltro/plugin-ratelimit: invalid window "${e}" — use e.g. "1m", "10s", "500ms", "2h", "1d"`);
+	return Number(t[1]) * u[t[2]];
+}, f = (e, t, n) => {
+	switch (t.algorithm) {
+		case "fixed-window": return p(e, t, n);
+		case "sliding-window": return m(e, t, n);
+		case "token-bucket": return h(e, t, n);
+	}
+}, p = (e, t, n) => {
+	let r = e?.kind === "fixed" ? e.windowStart : n, i = e?.kind === "fixed" ? e.count : 0;
+	n - r >= t.windowMs && (r = n, i = 0);
+	let a = r + t.windowMs;
+	return i >= t.limit ? {
+		state: {
+			kind: "fixed",
+			windowStart: r,
+			count: i
+		},
+		decision: {
+			allowed: !1,
+			remaining: 0,
+			resetAtMs: a,
+			retryAfterMs: a - n
+		}
+	} : (i += 1, {
+		state: {
+			kind: "fixed",
+			windowStart: r,
+			count: i
+		},
+		decision: {
+			allowed: !0,
+			remaining: t.limit - i,
+			resetAtMs: a,
+			retryAfterMs: 0
+		}
+	});
+}, m = (e, t, n) => {
+	let r = t.windowMs, i = e?.kind === "sliding" ? e.currStart : n, a = e?.kind === "sliding" ? e.currCount : 0, o = e?.kind === "sliding" ? e.prevCount : 0, s = Math.floor((n - i) / r);
+	s >= 2 ? (o = 0, a = 0, i = n) : s === 1 && (o = a, a = 0, i += r);
+	let c = (r - (n - i)) / r, l = o * c + a, u = i + r;
+	return l >= t.limit ? {
+		state: {
+			kind: "sliding",
+			currStart: i,
+			currCount: a,
+			prevCount: o
+		},
+		decision: {
+			allowed: !1,
+			remaining: 0,
+			resetAtMs: u,
+			retryAfterMs: u - n
+		}
+	} : (a += 1, {
+		state: {
+			kind: "sliding",
+			currStart: i,
+			currCount: a,
+			prevCount: o
+		},
+		decision: {
+			allowed: !0,
+			remaining: Math.max(0, Math.floor(t.limit - l - 1)),
+			resetAtMs: u,
+			retryAfterMs: 0
+		}
+	});
+}, h = (e, t, n) => {
+	let r = t.burst, i = t.limit / t.windowMs, a = e?.kind === "token" ? e.tokens : r, o = e?.kind === "token" ? e.lastRefill : n;
+	if (a = Math.min(r, a + (n - o) * i), a >= 1) {
+		--a;
+		let e = n + Math.ceil((r - a) / i);
+		return {
+			state: {
+				kind: "token",
+				tokens: a,
+				lastRefill: n
+			},
+			decision: {
+				allowed: !0,
+				remaining: Math.floor(a),
+				resetAtMs: e,
+				retryAfterMs: 0
+			}
+		};
+	}
+	let s = Math.ceil((1 - a) / i);
+	return {
+		state: {
+			kind: "token",
+			tokens: a,
+			lastRefill: n
+		},
+		decision: {
+			allowed: !1,
+			remaining: 0,
+			resetAtMs: n + s,
+			retryAfterMs: s
+		}
+	};
+}, g = "_voltro_ratelimit", _ = s(g, {
+	id: r({ scheme: "numeric" }),
+	key: c().maxLength(512),
+	state: i().nullable(),
+	touchedAt: l().default("now"),
+	touched: t()
+}).unique("rateLimitKey", ["key"]).nonReactive(), v = (t = {}) => {
+	let r = t.staleAfterMs ?? 36e5, i = null, s = (e, t, n) => ({
+		failOpenReason: n,
+		allowed: !0,
+		remaining: e.limit,
+		resetAtMs: t + e.windowMs,
+		retryAfterMs: 0
+	}), c = async (e, t, r, i) => {
+		let a = new Date(i);
+		return await e.insertIgnore(g, {
+			key: t,
+			state: null,
+			touchedAt: a
+		}, { conflictColumns: ["key"] }), e.transactional(async (e) => {
+			let { state: s, decision: c } = f((await e.query(o(_).where(n("key", t)).forUpdate().descriptor))[0]?.state ?? void 0 ?? void 0, r, i);
+			return await e.updateMany(g, {
+				state: s,
+				touchedAt: a
+			}, { where: n("key", t) }), c;
+		});
+	};
+	return {
+		consume: (t, n, r) => {
+			let a = i;
+			return a ? e.tryPromise(() => c(a, t, n, r)).pipe(e.catchAll(() => e.succeed(s(n, r, "store-error")))) : e.succeed(s(n, r, "unbound"));
+		},
+		sweep: (e) => {
+			let t = i;
+			t && t.deleteMany(g, { where: a("touchedAt", new Date(e - r)) }).catch(() => {});
+		},
+		size: () => -1,
+		bind: async (e) => {
+			i = e;
+		}
+	};
+};
+//#endregion
+export { d as a, f as i, v as n, _ as r, g as t };

package/dist/postgresStore.d.ts

@@ -1,17 +1,37 @@
+import { ColumnBuilder } from '@voltro/database';
+import { DataStore } from '@voltro/database';
 import { Effect } from 'effect';
-import { SqlClient } from '@effect/sql';
+import { FieldDefinitions } from '@voltro/database';
+import { Table } from '@voltro/database';
 
 declare type Algorithm = 'fixed-window' | 'sliding-window' | 'token-bucket';
 
+/** Opaque per-key state. The store persists it verbatim; only this
+ *  module reads its shape. */
+declare type BucketState = {
+    readonly kind: 'fixed';
+    readonly windowStart: number;
+    readonly count: number;
+} | {
+    readonly kind: 'sliding';
+    readonly currStart: number;
+    readonly currCount: number;
+    readonly prevCount: number;
+} | {
+    readonly kind: 'token';
+    readonly tokens: number;
+    readonly lastRefill: number;
+};
+
 export declare const postgresStore: (options?: PostgresStoreOptions) => RateLimitStore;
 
 export declare interface PostgresStoreOptions {
-    /** Table name. Default `_voltro_ratelimit`. */
-    readonly table?: string;
     /** Drop rows untouched for longer than this (ms) on sweep. Default 1h. */
     readonly staleAfterMs?: number;
 }
 
+export declare const RATELIMIT_TABLE = "_voltro_ratelimit";
+
 declare interface RateLimitDecision {
     readonly allowed: boolean;
     /** The request passed without a quota check because the store was unavailable.
@@ -38,13 +58,23 @@ declare interface RateLimitStore {
     readonly activate?: (env: NodeJS.ProcessEnv) => Promise<void>;
     /** Optional teardown at plugin deactivate (close pools). */
     readonly deactivate?: () => Promise<void>;
-    /** Optional bind of the framework's already-open `SqlClient` (from the
-     *  plugin's `bindDataStore(store, ctx)` → `ctx.sql`). A SQL-backed store
-     *  runs through THIS client instead of standing up its own pool; creates
-     *  its bookkeeping table here. Not present on memory / redis stores. */
-    readonly bindSql?: (sql: SqlClient.SqlClient) => Promise<void>;
+    /** Optional bind of the app's `DataStore` (the plugin's `bindDataStore`).
+     *  A store kept in the app's database reads and writes through it — its
+     *  table is declared through `extendSchema`, never created here. Not
+     *  present on memory / redis stores. */
+    readonly bind?: (store: DataStore) => Promise<void>;
 }
 
+/** One row per rate-limit key. `id` + a unique `key` rather than `key` as the
+ *  primary key: every dialect store addresses a row by `id`. */
+export declare const rateLimitTable: Table<"_voltro_ratelimit", FieldDefinitions<{
+    readonly id: ColumnBuilder<number, "id", boolean>;
+    readonly key: ColumnBuilder<string, "text", boolean>;
+    readonly state: ColumnBuilder<BucketState | null, "json", boolean>;
+    readonly touchedAt: ColumnBuilder<Date, "timestamp", true>;
+    readonly touched: ColumnBuilder<unknown, "text", boolean>;
+}>, false, never>;
+
 /** The fully-resolved limit the store consumes against. All dynamic /
  *  per-tenant resolution has already collapsed into these scalars. */
 declare interface ResolvedLimit {