@voltro/kv 0.85.0 → 0.87.0

package/dist/hot.js

@@ -0,0 +1,7 @@
+import { consumeHotRateLimit as e } from "./hotRateLimit.js";
+import { readHotStoreWithFallback as t } from "./hotReadAvailability.js";
+import { HotError as n, HotStore as r } from "./hot-contract.js";
+import { HOT_MEMORY_DEFAULTS as i, layerHotMemory as a, makeMemoryHotStore as o } from "./hotMemory.js";
+import { HOT_REDIS_DEFAULTS as s, layerHotRedis as c, makeRedisHotStore as l } from "./hotRedis.js";
+import { layerRoutedHotRedis as u } from "./hotRouting.js";
+export { i as HOT_MEMORY_DEFAULTS, s as HOT_REDIS_DEFAULTS, n as HotError, r as HotStore, e as consumeHotRateLimit, a as layerHotMemory, c as layerHotRedis, u as layerRoutedHotRedis, o as makeMemoryHotStore, l as makeRedisHotStore, t as readHotStoreWithFallback };

package/dist/hotMemory.js

@@ -0,0 +1,46 @@
+import { hotStoreFromRunner as e, validateHotOp as t } from "./hotOperations.js";
+import { applyHotOperations as n, compareHotMembers as r } from "./hotState.js";
+import { HotError as i, HotStore as a } from "./hot-contract.js";
+import { Clock as o, Effect as s, Layer as c, Stream as l } from "effect";
+//#region src/hotMemory.ts
+var u = { sweepBatchSize: 32 }, d = (a = {}) => s.try({
+	try: () => {
+		let c = /* @__PURE__ */ new Map(), d = a.sweepBatchSize ?? u.sweepBatchSize;
+		if (!Number.isSafeInteger(d) || d < 1) throw Error("HotStore sweepBatchSize must be a positive integer");
+		let f = c.entries(), p = a.now === void 0 ? o.currentTimeMillis : s.sync(a.now);
+		return e((e) => p.pipe(s.flatMap((r) => s.try({
+			try: () => {
+				e.forEach(t);
+				for (let e = 0; e < d; e++) {
+					let e = f.next();
+					if (e.done) {
+						f = c.entries();
+						break;
+					}
+					e.value[1].expiresAt <= r && c.delete(e.value[0]);
+				}
+				return n(c, e, r);
+			},
+			catch: (e) => e instanceof i ? e : new i({
+				operation: "multi",
+				key: "",
+				reason: "invalid"
+			})
+		}))), (e) => l.unwrap(p.pipe(s.map((t) => {
+			let n = [];
+			for (let [r, i] of c) i.expiresAt <= t ? c.delete(r) : r.startsWith(e) && n.push(r);
+			return l.fromIterable(n.sort(r));
+		}))), {
+			atomicMulti: !0,
+			crossNode: !1,
+			persistent: !1
+		});
+	},
+	catch: () => new i({
+		operation: "connect",
+		key: "",
+		reason: "invalid"
+	})
+}), f = (e = {}) => c.effect(a, d(e));
+//#endregion
+export { u as HOT_MEMORY_DEFAULTS, f as layerHotMemory, d as makeMemoryHotStore };

package/dist/hotOperations.js

@@ -0,0 +1,223 @@
+import { HotError as e } from "./hot-contract.js";
+import { Effect as t, Option as n } from "effect";
+//#region src/hotOperations.ts
+var r = /* @__PURE__ */ new Set([
+	"zrank",
+	"zscore",
+	"zrange",
+	"zcard",
+	"hget",
+	"hgetAll",
+	"smembers",
+	"sismember"
+]), i = (e) => r.has(e.op), a = (t, n, r) => {
+	if (t !== void 0 && (typeof t != "object" || !t || Array.isArray(t) || t.consistency !== void 0 && t.consistency !== "primary" && t.consistency !== "eventual")) throw new e({
+		operation: n,
+		key: r,
+		reason: "invalid"
+	});
+}, o = (t) => {
+	let n = () => {
+		throw new e({
+			operation: t.op,
+			key: t.key,
+			reason: "invalid"
+		});
+	}, r = (e) => {
+		Number.isFinite(e) || n();
+	}, i = (e) => {
+		(typeof e != "string" || /[\uD800-\uDFFF]/u.test(e)) && n();
+	}, a = (e) => {
+		e !== void 0 && (!Number.isSafeInteger(e) || e <= 0) && n();
+	}, o = (e) => {
+		let t = "byRank" in e ? e.byRank : e.byScore;
+		t.forEach(r), "byRank" in e && !t.every(Number.isSafeInteger) && n();
+	};
+	if (i(t.key), t.key.length === 0 && n(), "member" in t && i(t.member), "field" in t && i(t.field), "value" in t && i(t.value), "members" in t && t.op !== "zadd" && t.members.forEach(i), t.op === "hset") for (let [e, n] of Object.entries(t.fields)) i(e), i(n);
+	switch (t.op === "hdel" && t.fields.forEach(i), "options" in t && t.options !== void 0 && "ttlMs" in t.options && a(t.options.ttlMs), t.op) {
+		case "zadd":
+			t.options?.mode !== void 0 && ![
+				"set",
+				"max",
+				"min",
+				"incr"
+			].includes(t.options.mode) && n();
+			for (let e of t.members) r(e.score), i(e.member);
+			break;
+		case "zrange":
+			t.options !== void 0 && "consistency" in t.options && t.options.consistency !== void 0 && n(), t.options?.limit !== void 0 && (!Number.isSafeInteger(t.options.limit) || t.options.limit < 0) && n(), o(t.range), ["asc", "desc"].includes(t.order) || n();
+			break;
+		case "zremRange":
+			o(t.range);
+			break;
+		case "zrank":
+			["asc", "desc"].includes(t.order) || n();
+			break;
+		case "incrBy":
+			Number.isSafeInteger(t.delta) || n(), t.options?.max !== void 0 && !Number.isSafeInteger(t.options.max) && n();
+			break;
+		case "tokenBucket":
+			r(t.config.capacity), r(t.config.refillPerSec), r(t.cost), (t.config.capacity <= 0 || t.config.refillPerSec <= 0 || t.cost <= 0 || t.cost > t.config.capacity) && n(), Number.isSafeInteger(Math.ceil(t.config.capacity / t.config.refillPerSec * 1e3)) || n();
+			break;
+		case "expire":
+		case "setNx":
+			a(t.ttlMs);
+			break;
+		case "compareDelete":
+			i(t.value);
+			break;
+		case "compareExpire":
+			i(t.value), t.ttlMs === void 0 && n(), a(t.ttlMs);
+			break;
+		case "rateLimit":
+			if ([
+				"fixed-window",
+				"sliding-window",
+				"token-bucket"
+			].includes(t.config.algorithm) || n(), r(t.config.limit), r(t.config.windowMs), r(t.config.burst), (t.config.limit < 0 || t.config.windowMs <= 0 || t.config.burst < 0 || t.config.algorithm === "token-bucket" && (t.config.limit === 0 || t.config.burst === 0) || !Number.isSafeInteger(Math.ceil(Math.max(t.config.windowMs * 2, 6e4) + 1e3))) && n(), t.config.algorithm === "token-bucket") {
+				let e = t.config.limit / t.config.windowMs;
+				(!Number.isFinite(e) || e <= 0 || !Number.isSafeInteger(Math.ceil(t.config.burst / e))) && n();
+			}
+			t.nowMs !== void 0 && (!Number.isFinite(t.nowMs) || Math.abs(t.nowMs) > 2 ** 53 - 1 - t.config.windowMs * 2) && n();
+	}
+}, s = (r, i, o) => {
+	let s = (n, i) => t.gen(function* () {
+		return yield* t.try({
+			try: () => a(i, n.op, n.key),
+			catch: () => new e({
+				operation: n.op,
+				key: n.key,
+				reason: "invalid"
+			})
+		}), (yield* r([n], i))[0];
+	});
+	return {
+		zadd: (e, n, r) => s({
+			op: "zadd",
+			key: e,
+			members: n,
+			...r === void 0 ? {} : { options: r }
+		}).pipe(t.asVoid),
+		zrem: (e, t) => s({
+			op: "zrem",
+			key: e,
+			members: t
+		}),
+		zrank: (e, r, i, a) => s({
+			op: "zrank",
+			key: e,
+			member: r,
+			order: i
+		}, a).pipe(t.map(n.fromNullishOr)),
+		zscore: (e, r, i) => s({
+			op: "zscore",
+			key: e,
+			member: r
+		}, i).pipe(t.map(n.fromNullishOr)),
+		zrange: (e, t, n, r) => s({
+			op: "zrange",
+			key: e,
+			range: t,
+			order: n,
+			...r?.limit === void 0 ? {} : { options: { limit: r.limit } }
+		}, r),
+		zcard: (e, t) => s({
+			op: "zcard",
+			key: e
+		}, t),
+		zremRange: (e, t) => s({
+			op: "zremRange",
+			key: e,
+			range: t
+		}),
+		incrBy: (e, t, n) => s({
+			op: "incrBy",
+			key: e,
+			delta: t,
+			...n === void 0 ? {} : { options: n }
+		}),
+		tokenBucket: (e, t, n = 1) => s({
+			op: "tokenBucket",
+			key: e,
+			config: t,
+			cost: n
+		}),
+		rateLimit: (e, t, n) => s({
+			op: "rateLimit",
+			key: e,
+			config: t,
+			...n === void 0 ? {} : { nowMs: n }
+		}),
+		hset: (e, n, r) => s({
+			op: "hset",
+			key: e,
+			fields: n,
+			...r === void 0 ? {} : { options: r }
+		}).pipe(t.asVoid),
+		hget: (e, r, i) => s({
+			op: "hget",
+			key: e,
+			field: r
+		}, i).pipe(t.map(n.fromNullishOr)),
+		hgetAll: (e, t) => s({
+			op: "hgetAll",
+			key: e
+		}, t),
+		hdel: (e, t) => s({
+			op: "hdel",
+			key: e,
+			fields: t
+		}),
+		sadd: (e, t, n) => s({
+			op: "sadd",
+			key: e,
+			members: t,
+			...n === void 0 ? {} : { options: n }
+		}),
+		srem: (e, t) => s({
+			op: "srem",
+			key: e,
+			members: t
+		}),
+		smembers: (e, t) => s({
+			op: "smembers",
+			key: e
+		}, t),
+		sismember: (e, t, n) => s({
+			op: "sismember",
+			key: e,
+			member: t
+		}, n),
+		setNx: (e, t, n) => s({
+			op: "setNx",
+			key: e,
+			value: t,
+			ttlMs: n
+		}),
+		compareDelete: (e, t) => s({
+			op: "compareDelete",
+			key: e,
+			value: t
+		}),
+		compareExpire: (e, t, n) => s({
+			op: "compareExpire",
+			key: e,
+			value: t,
+			ttlMs: n
+		}),
+		expire: (e, n) => s({
+			op: "expire",
+			key: e,
+			ttlMs: n
+		}).pipe(t.asVoid),
+		delete: (e) => s({
+			op: "delete",
+			key: e
+		}),
+		scanPrefix: i,
+		multi: (e) => r(e),
+		capabilities: o
+	};
+};
+//#endregion
+export { s as hotStoreFromRunner, i as isHotReadOperation, o as validateHotOp, a as validateHotReadOptions };

package/dist/hotRateLimit.js

@@ -0,0 +1,103 @@
+//#region src/hotRateLimit.ts
+var e = (e, i, a) => {
+	switch (i.algorithm) {
+		case "fixed-window": return t(e, i, a);
+		case "sliding-window": return n(e, i, a);
+		case "token-bucket": return r(e, i, a);
+	}
+}, t = (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
+		}
+	});
+}, n = (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
+		}
+	});
+}, r = (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
+		}
+	};
+};
+//#endregion
+export { e as consumeHotRateLimit };

package/dist/hotReadAvailability.js

@@ -0,0 +1,19 @@
+import { HotError as e } from "./hot-contract.js";
+import { Effect as t } from "effect";
+//#region src/hotReadAvailability.ts
+var n = (n) => t.suspend(() => n.onUnavailable !== "degrade" && n.onUnavailable !== "fail" ? t.fail(new e({
+	operation: "readFallback",
+	key: "",
+	reason: "invalid"
+})) : n.read({
+	zrank: (...e) => n.store.zrank(...e),
+	zscore: (...e) => n.store.zscore(...e),
+	zrange: (...e) => n.store.zrange(...e),
+	zcard: (...e) => n.store.zcard(...e),
+	hget: (...e) => n.store.hget(...e),
+	hgetAll: (...e) => n.store.hgetAll(...e),
+	smembers: (...e) => n.store.smembers(...e),
+	sismember: (...e) => n.store.sismember(...e)
+}).pipe(t.catch((e) => typeof e == "object" && e && e._tag === "HotError" && e.reason === "unavailable" && n.onUnavailable === "degrade" ? t.suspend(n.fallback) : t.fail(e))));
+//#endregion
+export { n as readHotStoreWithFallback };

package/dist/hotRedis.js

@@ -0,0 +1,139 @@
+import { RedisConnections as e } from "./connection.js";
+import { hotStoreFromRunner as t, isHotReadOperation as n, validateHotOp as r, validateHotReadOptions as i } from "./hotOperations.js";
+import { HotError as a, HotStore as o } from "./hot-contract.js";
+import { HOT_SCRIPT as s } from "./hotRedisScript.js";
+import { Effect as c, Layer as l, Option as u, Stream as d } from "effect";
+//#region src/hotRedis.ts
+var f = {
+	connectionName: "hot",
+	namespace: "voltro:hot",
+	scanCount: 200
+}, p = (e) => e.replace(/[\\*?\[\]]/g, "\\$&"), m = (e, o = f.namespace, l = f.scanCount) => {
+	if (o.length === 0 || /[{}]/.test(o)) throw Error("HotStore namespace must be nonempty and contain no braces");
+	if (!Number.isSafeInteger(l) || l < 1) throw Error("HotStore scanCount must be a positive integer");
+	let m = `{${o}}:`, h = (e) => m + e;
+	return t((t, o) => c.gen(function* () {
+		if (yield* c.try({
+			try: () => {
+				if (t.forEach(r), i(o, t[0]?.op ?? "multi", t[0]?.key ?? ""), o?.consistency === "eventual" && (t.length !== 1 || !n(t[0]))) throw new a({
+					operation: "multi",
+					key: "",
+					reason: "invalid"
+				});
+			},
+			catch: (e) => e instanceof a ? e : new a({
+				operation: "multi",
+				key: "",
+				reason: "invalid"
+			})
+		}), t.length === 0) return [];
+		let l = yield* c.tryPromise({
+			try: () => {
+				let n = o?.consistency === "eventual" ? e.readOnly : e;
+				return n === void 0 ? Promise.reject(/* @__PURE__ */ Error("Read-only Lua is unavailable")) : n.eval(s, t.length, ...t.map((e) => h(e.key)), JSON.stringify(t));
+			},
+			catch: () => new a({
+				operation: "multi",
+				key: "",
+				reason: "unavailable"
+			})
+		}), u = yield* c.try({
+			try: () => JSON.parse(String(l)),
+			catch: () => new a({
+				operation: "multi",
+				key: "",
+				reason: "unavailable"
+			})
+		});
+		return u.failure === void 0 ? u.results?.length === t.length ? yield* c.try({
+			try: () => u.results.map(({ value: e }, n) => {
+				let r = t[n];
+				if ([
+					"zrem",
+					"zrank",
+					"zscore",
+					"zcard",
+					"zremRange",
+					"incrBy",
+					"hdel",
+					"sadd",
+					"srem"
+				].includes(r.op)) return e === null ? null : Number(e);
+				if (r.op === "zrange") return Array.isArray(e) ? e.map((e) => ({
+					member: e.member,
+					score: Number(e.score)
+				})) : [];
+				if (r.op === "tokenBucket") {
+					let t = e;
+					return {
+						allowed: t.allowed,
+						remaining: Number(t.remaining),
+						retryAfterMs: Number(t.retryAfterMs)
+					};
+				}
+				if (r.op === "rateLimit") {
+					let t = e, n = {
+						allowed: t.allowed,
+						remaining: Number(t.remaining),
+						resetAtMs: Number(t.resetAtMs),
+						retryAfterMs: Number(t.retryAfterMs)
+					};
+					if (typeof n.allowed != "boolean" || ![
+						n.remaining,
+						n.resetAtMs,
+						n.retryAfterMs
+					].every(Number.isFinite)) throw new a({
+						operation: "rateLimit",
+						key: r.key,
+						reason: "unavailable"
+					});
+					return n;
+				}
+				return r.op === "smembers" && !Array.isArray(e) ? [] : e;
+			}),
+			catch: (e) => e instanceof a ? e : new a({
+				operation: "multi",
+				key: "",
+				reason: "unavailable"
+			})
+		}) : yield* c.fail(new a({
+			operation: "multi",
+			key: "",
+			reason: "unavailable"
+		})) : yield* c.fail(new a(u.failure));
+	}), (t) => d.unwrap(c.sync(() => {
+		let n = /* @__PURE__ */ new Set();
+		return d.paginate("0", (r) => c.tryPromise({
+			try: () => e.scan(r, `${p(m + t)}*`, l),
+			catch: () => new a({
+				operation: "scanPrefix",
+				key: t,
+				reason: "unavailable"
+			})
+		}).pipe(c.map(({ cursor: e, keys: r }) => {
+			let i = [];
+			for (let e of r) e.startsWith(m + t) && !n.has(e) && (n.add(e), i.push(e.slice(m.length)));
+			return [i, e === "0" ? u.none() : u.some(e)];
+		})));
+	})), {
+		atomicMulti: !0,
+		crossNode: e.crossNode ?? !0,
+		persistent: !1
+	});
+}, h = (t = {}) => l.effect(o, c.gen(function* () {
+	let n = yield* (yield* e).client(t.connectionName ?? f.connectionName).pipe(c.mapError(() => new a({
+		operation: "connect",
+		key: "",
+		reason: "unavailable"
+	})));
+	return yield* c.try({
+		try: () => m(n, t.namespace, t.scanCount),
+		catch: () => new a({
+			operation: "connect",
+			key: "",
+			reason: "invalid"
+		})
+	});
+}));
+//#endregion
+export { f as HOT_REDIS_DEFAULTS, h as layerHotRedis, m as makeRedisHotStore };

package/dist/hotRedisScript.js

@@ -0,0 +1,4 @@
+//#region src/hotRedisScript.ts
+var e = "\nlocal ops = cjson.decode(ARGV[1])\nlocal tm = redis.call('TIME')\nlocal now = tonumber(tm[1]) * 1000 + math.floor(tonumber(tm[2]) / 1000)\nlocal out = {}\nlocal function fail(op, reason)\n  return cjson.encode({ failure = { operation = op.op, key = op.key, reason = reason } })\nend\nlocal function ttl(k, o)\n  if o and o.ttlMs then redis.call('PEXPIRE', k, string.format('%.0f', o.ttlMs)) end\nend\nlocal function numberString(k, prefix)\n  local raw = redis.call('GET', k)\n  if not raw then return nil end\n  if string.sub(raw, 1, 2) ~= prefix then error('WRONGTYPE') end\n  return string.sub(raw, 3)\nend\nlocal function run(o, k)\n  local op = o.op\n  local expected\n  if string.sub(op, 1, 1) == 'z' then expected = 'zset'\n  elseif string.sub(op, 1, 1) == 'h' then expected = 'hash'\n  elseif op == 'sadd' or op == 'srem' or op == 'smembers' or op == 'sismember' then expected = 'set' end\n  if expected then\n    local actual = redis.call('TYPE', k).ok\n    if actual ~= 'none' and actual ~= expected then error('WRONGTYPE') end\n  end\n  if op == 'zadd' then\n    local pending = {}\n    local mode = o.options and o.options.mode or 'set'\n    for _, m in ipairs(o.members) do\n      local old\n      if mode ~= 'set' then old = pending[m.member] or tonumber(redis.call('ZSCORE', k, m.member)) end\n      local score = m.score\n      if old then\n        if mode == 'max' then score = math.max(old, score)\n        elseif mode == 'min' then score = math.min(old, score)\n        elseif mode == 'incr' then score = old + score end\n      end\n      if score == math.huge or score == -math.huge or score ~= score then error('HOT_INVALID') end\n      pending[m.member] = score\n    end\n    -- RESP-family Lua bridges differ in number-to-argument precision.\n    for member, score in pairs(pending) do redis.call('ZADD', k, string.format('%.17g', score), member) end\n    ttl(k, o.options); return cjson.null\n  elseif op == 'zrem' then\n    local count = 0\n    for _, member in ipairs(o.members) do count = count + redis.call('ZREM', k, member) end\n    return count\n  elseif op == 'zrank' then\n    local cmd = o.order == 'desc' and 'ZREVRANK' or 'ZRANK'\n    return redis.call(cmd, k, o.member) or cjson.null\n  elseif op == 'zscore' then\n    return tonumber(redis.call('ZSCORE', k, o.member)) or cjson.null\n  elseif op == 'zcard' then return redis.call('ZCARD', k)\n  elseif op == 'zrange' then\n    local raw\n    local limit = o.options and o.options.limit\n    if limit == 0 then return {} end\n    if o.range.byRank then\n      local cmd = o.order == 'desc' and 'ZREVRANGE' or 'ZRANGE'\n      local lo, hi = o.range.byRank[1], o.range.byRank[2]\n      if limit then\n        local count = redis.call('ZCARD', k)\n        if lo < 0 then lo = count + lo end\n        if hi < 0 then hi = count + hi end\n        lo = math.max(0, lo)\n        hi = math.min(hi, lo + limit - 1)\n        if hi < lo then return {} end\n      end\n      raw = redis.call(cmd, k, string.format('%.0f', lo), string.format('%.0f', hi), 'WITHSCORES')\n    else\n      local cmd = o.order == 'desc' and 'ZREVRANGEBYSCORE' or 'ZRANGEBYSCORE'\n      local lo, hi = o.range.byScore[1], o.range.byScore[2]\n      if lo > hi then return {} end\n      if o.order == 'desc' then lo, hi = hi, lo end\n      if limit then raw = redis.call(cmd, k, string.format('%.17g', lo), string.format('%.17g', hi), 'WITHSCORES', 'LIMIT', 0, limit)\n      else raw = redis.call(cmd, k, string.format('%.17g', lo), string.format('%.17g', hi), 'WITHSCORES') end\n    end\n    local result = {}\n    for i = 1, #raw / 2 do\n      local score = raw[i * 2]\n      if type(score) == 'number' then score = string.format('%.17g', score) end\n      table.insert(result, { member = raw[i * 2 - 1], score = score })\n    end\n    return result\n  elseif op == 'zremRange' then\n    local pair = o.range.byRank or o.range.byScore\n    local cmd = o.range.byRank and 'ZREMRANGEBYRANK' or 'ZREMRANGEBYSCORE'\n    local format = o.range.byRank and '%.0f' or '%.17g'\n    return redis.call(cmd, k, string.format(format, pair[1]), string.format(format, pair[2]))\n  elseif op == 'incrBy' then\n    local value = tonumber(numberString(k, 'c:')) or 0\n    value = value + o.delta\n    if math.abs(value) > 9007199254740991 then error('HOT_INVALID') end\n    if o.options and o.options.max and value > o.options.max then error('HOT_LIMIT') end\n    redis.call('SET', k, 'c:' .. string.format('%.0f', value), 'KEEPTTL')\n    ttl(k, o.options); return value\n  elseif op == 'tokenBucket' then\n    local raw = numberString(k, 'b:')\n    local old = raw and cjson.decode(raw) or { tokens = o.config.capacity, updatedAt = now }\n    local available = math.min(o.config.capacity, tonumber(old.tokens) + math.max(0, now - tonumber(old.updatedAt)) * o.config.refillPerSec / 1000)\n    local allowed = available >= o.cost\n    local remaining = available\n    if allowed then remaining = remaining - o.cost end\n    local retry = allowed and 0 or math.ceil((o.cost - available) / o.config.refillPerSec * 1000)\n    local life = math.max(1, math.ceil(o.config.capacity / o.config.refillPerSec * 1000))\n    redis.call('SET', k, 'b:' .. cjson.encode({ tokens = string.format('%.17g', remaining), updatedAt = string.format('%.0f', math.max(now, tonumber(old.updatedAt))) }), 'PX', string.format('%.0f', life))\n    return { allowed = allowed, remaining = string.format('%.17g', remaining), retryAfterMs = string.format('%.0f', retry) }\n  elseif op == 'rateLimit' then\n    local raw = numberString(k, 'r:')\n    local s = raw and cjson.decode(raw) or nil\n    local cfg = o.config\n    local at = o.nowMs or now\n    local limit, windowMs, capacity = cfg.limit, cfg.windowMs, cfg.burst\n    local allowed, remaining, resetAt, retryAfter\n    local state\n    if cfg.algorithm == 'fixed-window' then\n      local start = s and s.kind == 'fixed' and tonumber(s.windowStart) or at\n      local count = s and s.kind == 'fixed' and tonumber(s.count) or 0\n      if at - start >= windowMs then start = at; count = 0 end\n      resetAt = start + windowMs\n      allowed = count < limit\n      if allowed then count = count + 1 end\n      remaining = allowed and limit - count or 0\n      retryAfter = allowed and 0 or resetAt - at\n      state = { kind = 'fixed', windowStart = start, count = count }\n    elseif cfg.algorithm == 'sliding-window' then\n      local start = s and s.kind == 'sliding' and tonumber(s.currStart) or at\n      local current = s and s.kind == 'sliding' and tonumber(s.currCount) or 0\n      local previous = s and s.kind == 'sliding' and tonumber(s.prevCount) or 0\n      local elapsed = math.floor((at - start) / windowMs)\n      if elapsed >= 2 then previous = 0; current = 0; start = at\n      elseif elapsed == 1 then previous = current; current = 0; start = start + windowMs end\n      local weight = (windowMs - (at - start)) / windowMs\n      local estimate = previous * weight + current\n      resetAt = start + windowMs\n      allowed = estimate < limit\n      if allowed then current = current + 1 end\n      remaining = allowed and math.max(0, math.floor(limit - estimate - 1)) or 0\n      retryAfter = allowed and 0 or resetAt - at\n      state = { kind = 'sliding', currStart = start, currCount = current, prevCount = previous }\n    else\n      local tokens = s and s.kind == 'token' and tonumber(s.tokens) or capacity\n      local last = s and s.kind == 'token' and tonumber(s.lastRefill) or at\n      local refill = limit / windowMs\n      tokens = math.min(capacity, tokens + (at - last) * refill)\n      allowed = tokens >= 1\n      if allowed then tokens = tokens - 1 end\n      retryAfter = allowed and 0 or math.ceil((1 - tokens) / refill)\n      remaining = allowed and math.floor(tokens) or 0\n      resetAt = at + (allowed and math.ceil((capacity - tokens) / refill) or retryAfter)\n      state = { kind = 'token', tokens = tokens, lastRefill = at }\n    end\n    for field, value in pairs(state) do\n      if type(value) == 'number' then state[field] = string.format('%.17g', value) end\n    end\n    redis.call('SET', k, 'r:' .. cjson.encode(state), 'PX', string.format('%.0f', math.ceil(math.max(windowMs * 2, 60000) + 1000)))\n    return { allowed = allowed, remaining = string.format('%.17g', remaining), resetAtMs = string.format('%.17g', resetAt), retryAfterMs = string.format('%.17g', retryAfter) }\n  elseif op == 'hset' then\n    for f, v in pairs(o.fields) do redis.call('HSET', k, f, v) end\n    ttl(k, o.options); return cjson.null\n  elseif op == 'hget' then return redis.call('HGET', k, o.field) or cjson.null\n  elseif op == 'hgetAll' then\n    local raw = redis.call('HGETALL', k)\n    local fields = {}\n    for i = 1, #raw, 2 do fields[raw[i]] = raw[i + 1] end\n    return fields\n  elseif op == 'hdel' then\n    local count = 0\n    for _, field in ipairs(o.fields) do count = count + redis.call('HDEL', k, field) end\n    return count\n  elseif op == 'sadd' or op == 'srem' then\n    local count = 0\n    for _, member in ipairs(o.members) do count = count + redis.call(op == 'sadd' and 'SADD' or 'SREM', k, member) end\n    if op == 'sadd' then ttl(k, o.options) end\n    return count\n  elseif op == 'smembers' then\n    local members = redis.call('SMEMBERS', k); table.sort(members); return members\n  elseif op == 'sismember' then return redis.call('SISMEMBER', k, o.member) == 1\n  elseif op == 'setNx' then return redis.call('SET', k, 'l:' .. o.value, 'NX', 'PX', string.format('%.0f', o.ttlMs)) ~= false\n  elseif op == 'compareDelete' or op == 'compareExpire' then\n    local value = numberString(k, 'l:')\n    if value == nil or value ~= o.value then return false end\n    if op == 'compareDelete' then return redis.call('DEL', k) == 1 end\n    return redis.call('PEXPIRE', k, string.format('%.0f', o.ttlMs)) == 1\n  elseif op == 'expire' then redis.call('PEXPIRE', k, string.format('%.0f', o.ttlMs)); return cjson.null\n  elseif op == 'delete' then return redis.call('DEL', k) == 1 end\n  error('HOT_INVALID')\nend\nfor i, op in ipairs(ops) do\n  local ok, result = pcall(run, op, KEYS[i])\n  if not ok then\n    local reason = 'unavailable'\n    if string.find(result, 'WRONGTYPE', 1, true) then reason = 'wrongType'\n    elseif string.find(result, 'HOT_LIMIT', 1, true) then reason = 'limit'\n    elseif string.find(result, 'HOT_INVALID', 1, true) then reason = 'invalid' end\n    return fail(op, reason)\n  end\n  -- Redis cjson numbers have only 14 significant digits. Use strings on\n  -- known numeric result slots so safe integers and fractional scores survive.\n  if type(result) == 'number' then result = string.format('%.17g', result) end\n  table.insert(out, { value = result })\nend\nreturn cjson.encode({ results = out })\n";
+//#endregion
+export { e as HOT_SCRIPT };

package/dist/hotRouting.js

@@ -0,0 +1,78 @@
+import { ConnectionRegistry as e } from "./connectionPool.js";
+import { hotStoreFromRunner as t, validateHotOp as n, validateHotReadOptions as r } from "./hotOperations.js";
+import { HotError as i, HotStore as a } from "./hot-contract.js";
+import { makeRedisHotStore as o } from "./hotRedis.js";
+import { Effect as s, Layer as c, Stream as l } from "effect";
+//#region src/hotRouting.ts
+var u = (u) => c.effect(a, s.gen(function* () {
+	let a = yield* e, c = u.routes?.[u.consumer], d = c?.select, f = u.context === void 0 ? void 0 : Object.freeze({ tenantId: u.context.tenantId }), p = u.consumers?.[u.consumer] ?? u.connection, m = [...new Set(c?.connections ?? [p ?? ""])], h = u.namespace, g = u.scanCount, _ = (e, t = "") => new i({
+		operation: e,
+		key: t,
+		reason: "invalid"
+	});
+	if (!u.consumer || m.length === 0 || c !== void 0 && (c.keyAffinity !== !0 || typeof c.select != "function")) return yield* s.fail(_("route"));
+	let v = !0;
+	for (let e of m) {
+		if (e !== "" && !/^redis:[A-Za-z][A-Za-z0-9_-]*$/.test(e)) return yield* s.fail(_("route"));
+		(!(yield* a.validate(e).pipe(s.mapError(() => _("route")))).tenantScoped || f !== void 0) && (yield* a.config(e, f).pipe(s.mapError(() => _("route")))).driver === "memory" && (v = !1);
+	}
+	if (h !== void 0 && (!h || /[{}]/.test(h)) || g !== void 0 && (!Number.isSafeInteger(g) || g < 1)) return yield* s.fail(_("route"));
+	let y = (e) => s.try({
+		try: () => {
+			let t = d === void 0 ? m[0] : d({
+				key: e,
+				...f === void 0 ? {} : { tenantId: f.tenantId }
+			});
+			if (!m.includes(t)) throw _("route", e);
+			return t;
+		},
+		catch: () => _("route", e)
+	}), b = (e) => a.client(e, f).pipe(s.mapError(() => new i({
+		operation: "connect",
+		key: "",
+		reason: "unavailable"
+	})), s.map((e) => o(e, h, g)));
+	return t((e, t) => s.gen(function* () {
+		if (yield* s.try({
+			try: () => {
+				e.forEach(n), r(t, e[0]?.op ?? "multi", e[0]?.key ?? "");
+			},
+			catch: (e) => e instanceof i ? e : _("multi")
+		}), e.length === 0) return [];
+		let a = /* @__PURE__ */ new Map();
+		for (let t of e) a.has(t.key) || a.set(t.key, yield* y(t.key));
+		let o = new Set(a.values());
+		if (o.size !== 1) return yield* s.fail(_("multi"));
+		let c = yield* b(o.values().next().value);
+		if (t?.consistency === "eventual") {
+			if (e.length !== 1) return yield* s.fail(_("multi"));
+			let n = e[0];
+			return [yield* s.gen(function* () {
+				switch (n.op) {
+					case "zrank": return yield* c.zrank(n.key, n.member, n.order, t).pipe(s.map((e) => e._tag === "Some" ? e.value : null));
+					case "zscore": return yield* c.zscore(n.key, n.member, t).pipe(s.map((e) => e._tag === "Some" ? e.value : null));
+					case "zrange": return yield* c.zrange(n.key, n.range, n.order, {
+						...n.options,
+						...t
+					});
+					case "zcard": return yield* c.zcard(n.key, t);
+					case "hget": return yield* c.hget(n.key, n.field, t).pipe(s.map((e) => e._tag === "Some" ? e.value : null));
+					case "hgetAll": return yield* c.hgetAll(n.key, t);
+					case "smembers": return yield* c.smembers(n.key, t);
+					case "sismember": return yield* c.sismember(n.key, n.member, t);
+					default: return yield* s.fail(_(n.op, n.key));
+				}
+			})];
+		}
+		return yield* c.multi(e);
+	}), (e) => l.unwrap(s.sync(() => {
+		let t = /* @__PURE__ */ new Set();
+		return l.fromIterable(m).pipe(l.flatMap((t) => l.unwrap(b(t).pipe(s.map((t) => t.scanPrefix(e))))), l.filter((e) => !t.has(e) && (t.add(e), !0)));
+	})), {
+		atomicMulti: m.length === 1,
+		crossNode: v,
+		persistent: !1
+	});
+}));
+//#endregion
+export { u as layerRoutedHotRedis };