@voltro/kv 0.86.0 → 0.88.0

package/dist/hotState.js

@@ -0,0 +1,181 @@
+import { consumeHotRateLimit as e } from "./hotRateLimit.js";
+import { validateHotOp as t } from "./hotOperations.js";
+import { HotError as n } from "./hot-contract.js";
+// src/hotState.ts
+var r = (e, t) => {
+	let n = Array.from(e, (e) => e.codePointAt(0) ?? 0), r = Array.from(t, (e) => e.codePointAt(0) ?? 0);
+	for (let e = 0; e < Math.min(n.length, r.length); e++) {
+		let t = n[e] - r[e];
+		if (t !== 0) return t;
+	}
+	return n.length - r.length;
+}, i = (e, t) => Array.from(e, ([e, t]) => ({
+	member: e,
+	score: t
+})).sort((e, n) => (t === "asc" ? 1 : -1) * (e.score - n.score || r(e.member, n.member))), a = (e, t) => {
+	if ("byScore" in t) return e.filter((e) => e.score >= t.byScore[0] && e.score <= t.byScore[1]);
+	let [n, r] = t.byRank, i = Math.max(0, n < 0 ? e.length + n : n), a = r < 0 ? e.length + r : r;
+	return a < i ? [] : e.slice(i, a + 1);
+}, o = (e) => {
+	switch (e.kind) {
+		case "z": return {
+			...e,
+			values: new Map(e.values)
+		};
+		case "h": return {
+			...e,
+			values: new Map(e.values)
+		};
+		case "s": return {
+			...e,
+			values: new Set(e.values)
+		};
+		default: return { ...e };
+	}
+}, s = (s, c, l) => {
+	c.forEach(t);
+	let u = /* @__PURE__ */ new Map(), d = new Set(c.filter((e) => [
+		"zadd",
+		"zrem",
+		"zremRange",
+		"incrBy",
+		"tokenBucket",
+		"rateLimit",
+		"hset",
+		"hdel",
+		"sadd",
+		"srem",
+		"setNx",
+		"compareDelete",
+		"compareExpire",
+		"expire",
+		"delete"
+	].includes(e.op)).map((e) => e.key));
+	for (let e of c) {
+		let t = s.get(e.key);
+		t !== void 0 && t.expiresAt > l && !u.has(e.key) && u.set(e.key, d.has(e.key) ? o(t) : t);
+	}
+	let f = c.map((t) => {
+		let o = u.get(t.key), s = (e) => {
+			throw new n({
+				operation: t.op,
+				key: t.key,
+				reason: e
+			});
+		}, c = (e) => (o !== void 0 && o.kind !== e && s("wrongType"), o), d = (e) => (o = {
+			...e,
+			expiresAt: Infinity
+		}, u.set(t.key, o), o), f = (e) => {
+			e !== void 0 && o !== void 0 && (o.expiresAt = l + e);
+		}, p = (e) => {
+			e === 0 && u.delete(t.key);
+		};
+		switch (t.op) {
+			case "zadd": {
+				let e = c("z")?.values ?? /* @__PURE__ */ new Map();
+				o === void 0 && t.members.length > 0 && d({
+					kind: "z",
+					values: e
+				});
+				for (let n of t.members) {
+					let r = e.get(n.member), i = t.options?.mode ?? "set", a = r === void 0 || i === "set" ? n.score : i === "max" ? Math.max(r, n.score) : i === "min" ? Math.min(r, n.score) : r + n.score;
+					Number.isFinite(a) || s("invalid"), e.set(n.member, a);
+				}
+				return f(t.options?.ttlMs), null;
+			}
+			case "zrem": {
+				let e = c("z")?.values, n = 0;
+				for (let r of t.members) e?.delete(r) && n++;
+				return p(e?.size ?? 0), n;
+			}
+			case "zrank": {
+				let e = c("z")?.values, n = e === void 0 ? -1 : i(e, t.order).findIndex((e) => e.member === t.member);
+				return n < 0 ? null : n;
+			}
+			case "zscore": return c("z")?.values.get(t.member) ?? null;
+			case "zrange": {
+				let e = c("z")?.values, n = a(e === void 0 ? [] : i(e, t.order), t.range);
+				return t.options?.limit === void 0 ? n : n.slice(0, t.options.limit);
+			}
+			case "zcard": return c("z")?.values.size ?? 0;
+			case "zremRange": {
+				let e = c("z")?.values, n = a(e === void 0 ? [] : i(e, "asc"), t.range);
+				for (let t of n) e?.delete(t.member);
+				return p(e?.size ?? 0), n.length;
+			}
+			case "incrBy": {
+				let e = (c("counter")?.value ?? 0) + t.delta;
+				return Number.isSafeInteger(e) || s("invalid"), t.options?.max !== void 0 && e > t.options.max && s("limit"), o === void 0 ? d({
+					kind: "counter",
+					value: e
+				}) : o.kind === "counter" && (o.value = e), f(t.options?.ttlMs), e;
+			}
+			case "tokenBucket": {
+				let e = c("bucket"), n = e === void 0 ? 0 : Math.max(0, l - e.updatedAt), r = Math.min(t.config.capacity, (e?.tokens ?? t.config.capacity) + n * t.config.refillPerSec / 1e3), i = r >= t.cost, a = i ? r - t.cost : r;
+				return d({
+					kind: "bucket",
+					tokens: a,
+					updatedAt: Math.max(l, e?.updatedAt ?? l)
+				}), f(Math.max(1, Math.ceil(t.config.capacity / t.config.refillPerSec * 1e3))), {
+					allowed: i,
+					remaining: a,
+					retryAfterMs: i ? 0 : Math.ceil((t.cost - r) / t.config.refillPerSec * 1e3)
+				};
+			}
+			case "rateLimit": {
+				let n = c("rateLimit")?.state, r = e(n, t.config, t.nowMs ?? l);
+				return d({
+					kind: "rateLimit",
+					state: r.state
+				}), f(Math.ceil(Math.max(t.config.windowMs * 2, 6e4) + 1e3)), r.decision;
+			}
+			case "hset": {
+				let e = c("h")?.values ?? /* @__PURE__ */ new Map(), n = Object.entries(t.fields);
+				o === void 0 && n.length > 0 && d({
+					kind: "h",
+					values: e
+				});
+				for (let [t, r] of n) e.set(t, r);
+				return f(t.options?.ttlMs), null;
+			}
+			case "hget": return c("h")?.values.get(t.field) ?? null;
+			case "hgetAll": return Object.fromEntries(c("h")?.values ?? []);
+			case "hdel": {
+				let e = c("h")?.values, n = 0;
+				for (let r of t.fields) e?.delete(r) && n++;
+				return p(e?.size ?? 0), n;
+			}
+			case "sadd": {
+				let e = c("s")?.values ?? /* @__PURE__ */ new Set();
+				o === void 0 && t.members.length > 0 && d({
+					kind: "s",
+					values: e
+				});
+				let n = e.size;
+				for (let n of t.members) e.add(n);
+				return f(t.options?.ttlMs), e.size - n;
+			}
+			case "srem": {
+				let e = c("s")?.values, n = 0;
+				for (let r of t.members) e?.delete(r) && n++;
+				return p(e?.size ?? 0), n;
+			}
+			case "smembers": return [...c("s")?.values ?? []].sort(r);
+			case "sismember": return c("s")?.values.has(t.member) ?? !1;
+			case "setNx": return o === void 0 && (d({
+				kind: "lease",
+				value: t.value
+			}), f(t.ttlMs), !0);
+			case "expire": return f(t.ttlMs), null;
+			case "compareDelete": return c("lease")?.value === t.value && (u.delete(t.key), !0);
+			case "compareExpire": return c("lease")?.value === t.value && (f(t.ttlMs), !0);
+			case "delete": return u.delete(t.key);
+		}
+	});
+	for (let e of c) {
+		let t = u.get(e.key);
+		t === void 0 ? s.delete(e.key) : s.set(e.key, t);
+	}
+	return f;
+};
+export { s as applyHotOperations, r as compareHotMembers };

package/dist/hotStoreConformance.js

@@ -0,0 +1,365 @@
+import { HotStore as e } from "./hot-contract.js";
+import { Effect as t, Option as n, Result as r, Stream as i } from "effect";
+// src/hotStoreConformance.ts
+var a = (a, o, s) => {
+	let { describe: c, expect: l, it: u } = s, d = (n, r) => u(n, async () => {
+		let n = o();
+		await t.runPromise(t.gen(function* () {
+			let t = yield* e;
+			l(t.capabilities).toEqual(n.capabilities), yield* r(t, n.advance);
+		}).pipe(t.provide(n.layer)));
+	});
+	c(`hotStoreConformance — ${a}`, () => {
+		d("sorted-set order, reverse ties, negative ranks, inclusive score bounds and limits", (e) => t.gen(function* () {
+			yield* e.zadd("board", [
+				{
+					member: "b",
+					score: 10
+				},
+				{
+					member: "a",
+					score: 10
+				},
+				{
+					member: "c",
+					score: 20
+				},
+				{
+					member: "𐀀",
+					score: 30
+				},
+				{
+					member: "",
+					score: 30
+				}
+			]), l((yield* e.zrange("board", { byRank: [0, -1] }, "asc")).map((e) => e.member)).toEqual([
+				"a",
+				"b",
+				"c",
+				"",
+				"𐀀"
+			]), l((yield* e.zrange("board", { byScore: [10, 20] }, "desc")).map((e) => e.member)).toEqual([
+				"c",
+				"b",
+				"a"
+			]), l(yield* e.zrange("board", { byRank: [0, -1] }, "asc", { limit: 0 })).toEqual([]), l((yield* e.zrange("board", { byRank: [-2, -1] }, "asc")).length).toBe(2), l((yield* e.zrange("board", { byScore: [10, 20] }, "asc", { limit: 1 }))[0]?.member).toBe("a"), l(n.getOrNull(yield* e.zrank("board", "b", "asc"))).toBe(1), l(n.getOrNull(yield* e.zrank("board", "b", "desc"))).toBe(3), l(n.isNone(yield* e.zrank("board", "absent", "asc"))).toBe(!0), l(yield* e.zcard("board")).toBe(5);
+		})), d("score modes, duplicate members and removal by rank/score", (e) => t.gen(function* () {
+			yield* e.zadd("z", [{
+				member: "a",
+				score: 10
+			}]), yield* e.zadd("z", [{
+				member: "a",
+				score: 5
+			}], { mode: "max" }), l(n.getOrNull(yield* e.zscore("z", "a"))).toBe(10), yield* e.zadd("z", [{
+				member: "a",
+				score: 7
+			}], { mode: "min" }), yield* e.zadd("z", [{
+				member: "a",
+				score: 2
+			}, {
+				member: "a",
+				score: 3
+			}], { mode: "incr" }), l(n.getOrNull(yield* e.zscore("z", "a"))).toBe(12), yield* e.zadd("z", [{
+				member: "b",
+				score: 20
+			}, {
+				member: "c",
+				score: 30
+			}]), l(yield* e.zremRange("z", { byScore: [20, 20] })).toBe(1), l(yield* e.zremRange("z", { byRank: [-1, -1] })).toBe(1), l(yield* e.zrem("z", ["a", "a"])).toBe(1), l(yield* e.zrange("z", { byRank: [0, -1] }, "asc")).toEqual([]), l(n.isNone(yield* e.zscore("z", "a"))).toBe(!0), yield* e.zadd("precise", [{
+				member: "p",
+				score: 1.2345678901234567
+			}]), l(n.getOrNull(yield* e.zscore("precise", "p"))).toBe(1.2345678901234567), l((yield* e.zrange("precise", { byRank: [0, -1] }, "asc"))[0]?.score).toBe(1.2345678901234567), l((yield* e.zrange("precise", { byScore: [1.2345678901234567, 1.2345678901234567] }, "asc"))[0]?.score).toBe(1.2345678901234567), l(yield* e.zremRange("precise", { byScore: [1.2345678901234567, 1.2345678901234567] })).toBe(1);
+		})), d("hashes preserve arbitrary field names and sets count unique changes", (e) => t.gen(function* () {
+			yield* e.hset("hash", Object.fromEntries([
+				["__proto__", "p"],
+				["constructor", "c"],
+				["a", "1"]
+			])), l(n.getOrNull(yield* e.hget("hash", "__proto__"))).toBe("p"), l(yield* e.hgetAll("hash")).toEqual(Object.fromEntries([
+				["__proto__", "p"],
+				["constructor", "c"],
+				["a", "1"]
+			])), l(yield* e.hdel("hash", ["a", "a"])).toBe(1), l(n.isNone(yield* e.hget("hash", "a"))).toBe(!0), l(yield* e.sadd("set", [
+				"b",
+				"a",
+				"a"
+			])).toBe(2), l(yield* e.sadd("set", ["b"])).toBe(0), l(yield* e.smembers("set")).toEqual(["a", "b"]), l(yield* e.sismember("set", "a")).toBe(!0), l(yield* e.srem("set", ["a", "a"])).toBe(1), l(yield* e.sismember("set", "a")).toBe(!1), l(yield* e.hgetAll("absent")).toEqual({});
+		})), d("counter bounds fail without changing the value; increments are atomic", (e) => t.gen(function* () {
+			let n = yield* t.all(Array.from({ length: 100 }, () => e.incrBy("counter", 1)), { concurrency: "unbounded" });
+			l(new Set(n).size).toBe(100), l(yield* e.incrBy("counter", 0)).toBe(100);
+			let i = yield* e.incrBy("counter", 1, { max: 100 }).pipe(t.result);
+			l(r.isFailure(i)).toBe(!0), r.isFailure(i) && l(i.failure.reason).toBe("limit"), l(yield* e.incrBy("counter", -20)).toBe(80);
+		})), d("concurrent batches do not interleave and concurrent leases have one winner", (e) => t.gen(function* () {
+			let n = yield* t.all(Array.from({ length: 20 }, () => e.multi([{
+				op: "incrBy",
+				key: "atomic",
+				delta: 1
+			}, {
+				op: "incrBy",
+				key: "atomic",
+				delta: 1
+			}])), { concurrency: "unbounded" });
+			for (let e of n) l(e[1]).toBe(Number(e[0]) + 1);
+			l(yield* e.incrBy("atomic", 0)).toBe(40);
+			let r = yield* t.all(Array.from({ length: 100 }, (t, n) => e.setNx("seat", String(n), 2e3)), { concurrency: "unbounded" });
+			l(r.filter(Boolean)).toHaveLength(1);
+		})), d("conditional lease release and renewal refuse expired owners without changing a successor", (e, n) => t.gen(function* () {
+			l(yield* e.compareDelete("conditional", "old")).toBe(!1), l(yield* e.compareExpire("conditional", "old", 1e3)).toBe(!1), l(yield* e.setNx("conditional", "old", 1e3)).toBe(!0), l(yield* e.compareDelete("conditional", "other")).toBe(!1), l(yield* e.compareExpire("conditional", "other", 1e4)).toBe(!1), yield* n(1100), l(yield* e.setNx("conditional", "successor", 1e3)).toBe(!0), l(yield* e.compareDelete("conditional", "old")).toBe(!1), l(yield* e.compareExpire("conditional", "old", 1e4)).toBe(!1), l(yield* e.setNx("conditional", "contender", 1e3)).toBe(!1), yield* n(1100), l(yield* e.setNx("conditional", "next", 1e3)).toBe(!0), l(yield* e.compareDelete("conditional", "next")).toBe(!0), l(yield* e.compareDelete("conditional", "next")).toBe(!1);
+		})), d("matching renewals reset TTL and batches retain ordered lease comparisons", (e, n) => t.gen(function* () {
+			yield* e.setNx("renewal", "Grüße 🎮", 1e3), l(yield* e.compareExpire("renewal", "Grüße 🎮", 3e3)).toBe(!0), yield* n(1100), l(yield* e.setNx("renewal", "other", 1e3)).toBe(!1), yield* n(2100), l(yield* e.setNx("renewal", "", 1e3)).toBe(!0), l(yield* e.multi([
+				{
+					op: "compareExpire",
+					key: "renewal",
+					value: "",
+					ttlMs: 1e3
+				},
+				{
+					op: "compareDelete",
+					key: "renewal",
+					value: ""
+				},
+				{
+					op: "setNx",
+					key: "renewal",
+					value: "successor",
+					ttlMs: 1e3
+				},
+				{
+					op: "compareDelete",
+					key: "renewal",
+					value: ""
+				}
+			])).toEqual([
+				!0,
+				!0,
+				!0,
+				!1
+			]), l(yield* e.compareDelete("renewal", "successor")).toBe(!0);
+		})), d("conditional lease operations refuse other structures and validate before batch mutation", (e) => t.gen(function* () {
+			yield* e.hset("conditional:hash", { value: "retained" }), yield* e.incrBy("conditional:counter", 7), yield* e.tokenBucket("conditional:bucket", {
+				capacity: 1,
+				refillPerSec: .001
+			}), yield* e.rateLimit("conditional:quota", {
+				algorithm: "fixed-window",
+				limit: 1,
+				windowMs: 6e4,
+				burst: 1
+			});
+			for (let n of [
+				"conditional:hash",
+				"conditional:counter",
+				"conditional:bucket",
+				"conditional:quota"
+			]) for (let i of [e.compareDelete(n, "7"), e.compareExpire(n, "7", 1e3)]) {
+				let e = yield* i.pipe(t.result);
+				l(r.isFailure(e)).toBe(!0), r.isFailure(e) && l(e.failure.reason).toBe("wrongType");
+			}
+			l(yield* e.hgetAll("conditional:hash")).toEqual({ value: "retained" }), l(yield* e.incrBy("conditional:counter", 0)).toBe(7);
+			let n = yield* e.multi([{
+				op: "setNx",
+				key: "conditional:untouched",
+				value: "owner",
+				ttlMs: 1e3
+			}, {
+				op: "compareExpire",
+				key: "conditional:untouched",
+				value: "owner",
+				ttlMs: 0
+			}]).pipe(t.result);
+			l(r.isFailure(n)).toBe(!0), l(yield* e.setNx("conditional:untouched", "new", 1e3)).toBe(!0);
+			let i = yield* t.all(Array.from({ length: 40 }, () => e.compareDelete("conditional:untouched", "new")), { concurrency: "unbounded" });
+			l(i.filter(Boolean)).toHaveLength(1);
+		})), d("token bucket admits once per token and refills with elapsed time", (e, n) => t.gen(function* () {
+			let t = {
+				capacity: 2,
+				refillPerSec: 1
+			};
+			l((yield* e.tokenBucket("bucket", t)).allowed).toBe(!0), l((yield* e.tokenBucket("bucket", t)).allowed).toBe(!0);
+			let r = yield* e.tokenBucket("bucket", t);
+			l(r.allowed).toBe(!1), l(r.retryAfterMs).toBeGreaterThan(0), l(r.retryAfterMs).toBeLessThanOrEqual(1e3), yield* n(1100), l((yield* e.tokenBucket("bucket", t)).allowed).toBe(!0);
+		})), d("concurrent token consumption cannot oversubscribe capacity", (e) => t.gen(function* () {
+			let n = yield* t.all(Array.from({ length: 50 }, () => e.tokenBucket("parallel:bucket", {
+				capacity: 10,
+				refillPerSec: .001
+			})), { concurrency: "unbounded" });
+			l(n.filter((e) => e.allowed)).toHaveLength(10);
+		}));
+		for (let e of [
+			"fixed-window",
+			"sliding-window",
+			"token-bucket"
+		]) d(`${e} quotas cannot oversubscribe under concurrent requests`, (n) => t.gen(function* () {
+			let r = {
+				algorithm: e,
+				limit: 10,
+				windowMs: 6e4,
+				burst: 10
+			}, i = yield* t.all(Array.from({ length: 120 }, () => n.rateLimit("quota:" + e, r, 1e3)), { concurrency: "unbounded" });
+			l(i.filter((e) => e.allowed)).toHaveLength(10), l(i.filter((e) => !e.allowed).every((e) => e.remaining === 0 && e.retryAfterMs > 0)).toBe(!0);
+		}));
+		d("rate-limit window edges, weighted previous window and token refill preserve exact decisions", (e) => t.gen(function* () {
+			let t = {
+				algorithm: "fixed-window",
+				limit: 2,
+				windowMs: 1e3,
+				burst: 2
+			};
+			l(yield* e.rateLimit("fixed", t, 0)).toEqual({
+				allowed: !0,
+				remaining: 1,
+				resetAtMs: 1e3,
+				retryAfterMs: 0
+			}), yield* e.rateLimit("fixed", t, 0), l(yield* e.rateLimit("fixed", t, 999)).toEqual({
+				allowed: !1,
+				remaining: 0,
+				resetAtMs: 1e3,
+				retryAfterMs: 1
+			}), l((yield* e.rateLimit("fixed", t, 1e3)).remaining).toBe(1);
+			let n = {
+				...t,
+				algorithm: "sliding-window"
+			};
+			yield* e.rateLimit("sliding", n, 0), yield* e.rateLimit("sliding", n, 0), l((yield* e.rateLimit("sliding", n, 1e3)).allowed).toBe(!1), l(yield* e.rateLimit("sliding", n, 1500)).toEqual({
+				allowed: !0,
+				remaining: 0,
+				resetAtMs: 2e3,
+				retryAfterMs: 0
+			}), l((yield* e.rateLimit("sliding", n, 1500)).allowed).toBe(!1), l((yield* e.rateLimit("sliding", n, 4e3)).remaining).toBe(1);
+			let r = {
+				...t,
+				algorithm: "token-bucket",
+				burst: 1
+			};
+			l((yield* e.rateLimit("token", r, 0)).allowed).toBe(!0), l(yield* e.rateLimit("token", r, 499)).toEqual({
+				allowed: !1,
+				remaining: 0,
+				resetAtMs: 501,
+				retryAfterMs: 2
+			}), l((yield* e.rateLimit("token", r, 500)).allowed).toBe(!0), l((yield* e.rateLimit("fixed", r, 1100)).allowed).toBe(!0), l((yield* e.rateLimit("zero", {
+				...t,
+				limit: 0,
+				burst: 0
+			}, 0)).allowed).toBe(!1);
+		})), d("rate-limit validation precedes batch mutation; wrong types do not destroy data", (e) => t.gen(function* () {
+			let n = {
+				algorithm: "fixed-window",
+				limit: 1,
+				windowMs: 1e3,
+				burst: 1
+			}, i = yield* e.multi([{
+				op: "incrBy",
+				key: "validation",
+				delta: 1
+			}, {
+				op: "rateLimit",
+				key: "quota",
+				config: {
+					...n,
+					limit: -1
+				}
+			}]).pipe(t.result);
+			l(r.isFailure(i)).toBe(!0), l(yield* e.incrBy("validation", 0)).toBe(0), yield* e.hset("typed", { value: "retained" });
+			let a = yield* e.rateLimit("typed", n).pipe(t.result);
+			l(r.isFailure(a)).toBe(!0), r.isFailure(a) && l(a.failure.reason).toBe("wrongType"), l(yield* e.hgetAll("typed")).toEqual({ value: "retained" });
+			let o = yield* e.multi([{
+				op: "rateLimit",
+				key: "batched",
+				config: n,
+				nowMs: 0
+			}, {
+				op: "rateLimit",
+				key: "batched",
+				config: n,
+				nowMs: 0
+			}]);
+			l(o).toEqual([{
+				allowed: !0,
+				remaining: 0,
+				resetAtMs: 1e3,
+				retryAfterMs: 0
+			}, {
+				allowed: !1,
+				remaining: 0,
+				resetAtMs: 1e3,
+				retryAfterMs: 1e3
+			}]);
+		})), d("rate-limit state expires with its structure TTL and remains scan/delete addressable", (e, n) => t.gen(function* () {
+			let t = {
+				algorithm: "fixed-window",
+				limit: 1,
+				windowMs: 1e3,
+				burst: 1
+			};
+			yield* e.rateLimit("ttl:quota", t, 0), yield* e.expire("ttl:quota", 20), yield* n(40), l((yield* e.rateLimit("ttl:quota", t, 0)).allowed).toBe(!0), l(yield* i.runCollect(e.scanPrefix("ttl:quota"))).toEqual(["ttl:quota"]), l(yield* e.delete("ttl:quota")).toBe(!0);
+		})), d("TTL expires every structure; reads and rejected lease attempts do not extend it", (e, n) => t.gen(function* () {
+			yield* e.zadd("ttl:z", [{
+				member: "a",
+				score: 1
+			}], { ttlMs: 1e3 }), yield* e.hset("ttl:h", { a: "b" }, { ttlMs: 1e3 }), yield* e.sadd("ttl:s", ["a"], { ttlMs: 1e3 }), yield* e.incrBy("ttl:c", 1, { ttlMs: 1e3 }), l(yield* e.setNx("ttl:l", "owner", 1e3)).toBe(!0), l(yield* e.setNx("ttl:l", "other", 1e4)).toBe(!1), l(yield* e.zcard("ttl:z")).toBe(1), yield* n(1100), l(yield* e.zcard("ttl:z")).toBe(0), l(yield* e.hgetAll("ttl:h")).toEqual({}), l(yield* e.smembers("ttl:s")).toEqual([]), l(yield* e.incrBy("ttl:c", 1)).toBe(1), l(yield* e.setNx("ttl:l", "newOwner", 1e3)).toBe(!0);
+		})), d("explicit expiry and deletion are scoped; scans treat glob symbols literally", (e, n) => t.gen(function* () {
+			yield* e.sadd("literal:*?[]a", ["a"]), yield* e.sadd("literal:other", ["a"]);
+			let t = yield* i.runCollect(e.scanPrefix("literal:*?[]"));
+			l(t).toEqual(["literal:*?[]a"]), yield* e.expire("literal:*?[]a", 1e3), yield* n(1100), l(yield* i.runCollect(e.scanPrefix("literal:*?[]"))).toEqual([]), l(yield* e.delete("literal:other")).toBe(!0), l(yield* e.delete("literal:other")).toBe(!1);
+		})), d("scans traverse multiple pages without duplicates or other prefixes", (e) => t.gen(function* () {
+			let t = Array.from({ length: 250 }, (e, t) => `pages:${t}`);
+			yield* e.multi(t.map((e) => ({
+				op: "sadd",
+				key: e,
+				members: ["a"]
+			}))), yield* e.sadd("unrelated", ["a"]);
+			let n = yield* i.runCollect(e.scanPrefix("pages:"));
+			l(n.length).toBe(t.length), l([...n].sort()).toEqual([...t].sort());
+		})), d("batch results reflect ordered writes and reads; arguments validate before writes", (e) => t.gen(function* () {
+			l(yield* e.multi([])).toEqual([]), l(yield* e.multi([
+				{
+					op: "incrBy",
+					key: "batch:c",
+					delta: 2
+				},
+				{
+					op: "incrBy",
+					key: "batch:c",
+					delta: 3
+				},
+				{
+					op: "sadd",
+					key: "batch:s",
+					members: ["a"]
+				},
+				{
+					op: "sismember",
+					key: "batch:s",
+					member: "a"
+				}
+			])).toEqual([
+				2,
+				5,
+				1,
+				!0
+			]), l(r.isFailure(yield* e.multi([{
+				op: "incrBy",
+				key: "untouched",
+				delta: 10
+			}, {
+				op: "expire",
+				key: "bad",
+				ttlMs: -1
+			}]).pipe(t.result))).toBe(!0), l(yield* e.incrBy("untouched", 0)).toBe(0);
+		})), d("wrong types and non-finite/unsafe arguments are typed failures", (e) => t.gen(function* () {
+			yield* e.sadd("typed", ["a"]);
+			let n = yield* e.zcard("typed").pipe(t.result);
+			l(r.isFailure(n)).toBe(!0), r.isFailure(n) && l(n.failure.reason).toBe("wrongType"), l(r.isFailure(yield* e.incrBy("bad", .5).pipe(t.result))).toBe(!0), l(r.isFailure(yield* e.zadd("bad", [{
+				member: "a",
+				score: NaN
+			}]).pipe(t.result))).toBe(!0), l(r.isFailure(yield* e.setNx("bad", "a", 0).pipe(t.result))).toBe(!0), l(r.isFailure(yield* e.tokenBucket("bad", {
+				capacity: 1,
+				refillPerSec: 1
+			}, 2).pipe(t.result))).toBe(!0), l(r.isFailure(yield* e.sadd("\ud800", ["a"]).pipe(t.result))).toBe(!0), l(r.isFailure(yield* e.tokenBucket("bad", {
+				capacity: 1e300,
+				refillPerSec: 1
+			}).pipe(t.result))).toBe(!0), yield* e.incrBy("safe", 2 ** 53 - 1), l(r.isFailure(yield* e.incrBy("safe", 1).pipe(t.result))).toBe(!0), l(yield* e.incrBy("safe", 0)).toBe(2 ** 53 - 1);
+		})), d("empty writes do not create keys and deleting last members removes structures", (e) => t.gen(function* () {
+			yield* e.zadd("empty:z", []), yield* e.hset("empty:h", {}), yield* e.sadd("empty:s", []), l(yield* i.runCollect(e.scanPrefix("empty:"))).toEqual([]), yield* e.hset("empty:h", { a: "1" }), yield* e.hdel("empty:h", ["a"]), yield* e.sadd("empty:s", ["a"]), yield* e.srem("empty:s", ["a"]), l(yield* i.runCollect(e.scanPrefix("empty:"))).toEqual([]);
+		}));
+	});
+};
+export { a as hotStoreConformance };