@voltro/kv 0.86.0 → 0.88.0

package/dist/index.d.ts

@@ -21,7 +21,42 @@ export declare const commandRetry: Schedule.Schedule< Duration, unknown, never,
  */
 export declare const connect: (config: RedisConnectionConfig) => Effect.Effect<RespClient, KvError>;
 
-export declare const connectionConfig: (name: string) => Effect.Effect<RedisConnectionConfig, Config.ConfigError>;
+/** Resolve an explicit kind:name, a configured default, or the established env convention. */
+export declare function connectionConfig(reference: string): Effect.Effect<RedisConnectionConfig, Config.ConfigError>;
+
+export declare function connectionConfig(reference: string, definitions: RedisConnectionsConfig, context?: ConnectionContext): Effect.Effect<RedisConnectionConfig, Config.ConfigError | KvError>;
+
+declare interface ConnectionContext {
+    readonly tenantId: string;
+}
+
+/** An environment declaration, never the environment value itself. */
+declare interface ConnectionEnv {
+    readonly _tag: 'ConnectionEnv';
+    readonly name: string;
+}
+
+/** A connection's kind is part of its reference, so consumers cannot mix ports. */
+declare type ConnectionKind = 'redis' | 'nats' | 'storage' | 'analytics' | 'sql';
+
+declare interface ConnectionMetadata {
+    readonly tls?: 'auto' | 'required';
+    readonly persistence?: 'required' | 'optional' | 'none';
+    readonly keyPrefix?: string;
+    /** Explicit opt-in when a production connection intentionally uses a shared namespace. */
+    readonly allowSharedNamespace?: boolean;
+    readonly region?: string;
+    readonly label?: string;
+    readonly acl?: string;
+}
+
+declare type ConnectionRef<K extends ConnectionKind = ConnectionKind> = `${K}:${string}`;
+
+declare interface DynamicRedisConnection {
+    readonly _tag: 'DynamicRedisConnection';
+    readonly resolve: (context: ConnectionContext) => Effect.Effect<RedisConnectionConfig, KvError>;
+    readonly ttlMs: number;
+}
 
 export declare class Kv extends Kv_base {
     /** `Kv` over whatever `KvStore` is provided. */
@@ -53,6 +88,7 @@ declare const Kv_base: Context.ServiceClass<Kv, "@voltro/Kv", {
 };
 
 export declare class KvError extends KvError_base {
+    get message(): string;
 }
 
 declare const KvError_base: Schema.Class<KvError, Schema.TaggedStruct<"KvError", {
@@ -125,14 +161,40 @@ export declare interface MemoryKvOptions {
     readonly now?: () => number;
 }
 
-export declare interface RedisConnectionConfig {
-    /** `redis://…` / `rediss://…` for the `resp` driver, the REST url for `http`. */
+/** A local registry entry. Its clock is injectable; it opens no transport. */
+declare interface MemoryRedisConnection {
+    readonly _tag: 'MemoryRedisConnection';
+    readonly now?: () => number;
+}
+
+export declare interface RedisConnectionConfig extends ConnectionMetadata, RedisTimeouts {
+    /** Native Redis, Cluster/Sentinel seed URLs, or the REST URL for HTTP. */
     readonly url: string;
-    readonly driver: 'resp' | 'http';
+    readonly driver: 'resp' | 'http' | 'memory';
+    readonly memoryClock?: () => number;
     /** Auth token — `http` (Upstash REST) driver only. */
     readonly token?: string;
     /** Optional key namespace a deployment may layer its own prefix under. */
-    readonly keyPrefix?: string;
+    readonly cluster?: boolean;
+    readonly replicas?: ReadonlyArray<string>;
+    readonly readFrom?: 'primary' | 'replica' | 'nearest';
+    readonly maxmemoryPolicyHint?: string;
+    readonly source?: 'config' | 'environment' | 'override';
+}
+
+declare interface RedisConnectionDefinition extends ConnectionMetadata, RedisTimeouts {
+    readonly url: ConnectionEnv;
+    readonly driver?: 'resp' | 'http';
+    readonly token?: ConnectionEnv;
+    readonly cluster?: boolean;
+    readonly replicas?: ReadonlyArray<ConnectionEnv>;
+    readonly readFrom?: 'primary' | 'replica' | 'nearest';
+    readonly maxmemoryPolicyHint?: string;
+}
+
+declare interface RedisConnectionDiagnostics {
+    /** Every current Cluster primary, or the single standalone/Sentinel primary. */
+    readonly nodes: ReadonlyArray<RedisNodeDiagnostics>;
 }
 
 export declare class RedisConnections extends RedisConnections_base {
@@ -140,6 +202,17 @@ export declare class RedisConnections extends RedisConnections_base {
 
 declare const RedisConnections_base: Context.ServiceClass<RedisConnections, "@voltro/RedisConnections", RespConnections>;
 
+declare interface RedisConnectionsConfig {
+    readonly redis?: Readonly<Record<string, RedisConnectionDefinition | DynamicRedisConnection | MemoryRedisConnection>>;
+    readonly defaults?: {
+        readonly redis?: string;
+    };
+    /** App-owned selection by plugin name and declared role; plugins never choose endpoints. */
+    readonly bindings?: Readonly<Record<string, Readonly<Record<string, ConnectionRef>>>>;
+    readonly maxDynamicPools?: number;
+    readonly rotationGraceMs?: number;
+}
+
 export declare interface RedisKvOptions {
     /** Named connection to draw from the registry. Default `'kv'` — reads
      *  `KV_REDIS_URL` → `REDIS_URL`. */
@@ -148,11 +221,28 @@ export declare interface RedisKvOptions {
     readonly keyPrefix?: string;
 }
 
-/** The minimal command surface both ioredis and @upstash/redis satisfy —
- *  the superset the framework's command-only RESP consumers (cache, rate
- *  limiter, KV) need. `eval` runs a Lua script server-side (numKeys splits
- *  KEYS from ARGV, the ioredis convention); `zrange` reads a full sorted set. */
+/** Only enumerated server settings leave the transport; never raw INFO/errors. */
+declare interface RedisNodeDiagnostics {
+    readonly persistence: 'aof' | 'snapshot' | 'none' | 'unknown';
+    readonly maxmemoryPolicy: 'noeviction' | 'allkeys-lru' | 'allkeys-lfu' | 'allkeys-random' | 'volatile-lru' | 'volatile-lfu' | 'volatile-random' | 'volatile-ttl' | 'unknown';
+}
+
+/** Optional native RESP transport deadlines in integer milliseconds. */
+declare interface RedisTimeouts {
+    /** TCP/TLS connection establishment limit; does not prove command completion. */
+    readonly connectTimeoutMs?: number;
+    /** Limit for a command reply. A write may still complete after this expires. */
+    readonly commandTimeoutMs?: number;
+}
+
 export declare interface RespClient {
+    readonly readOnly?: RespReadClient;
+    /** False for a local test connection. PING never turns it into a network backend. */
+    readonly crossNode?: boolean;
+    /** Read-only round-trip probe. Custom drivers may omit it; no readiness is inferred. */
+    readonly ping?: () => Promise<string>;
+    /** Explicit read-only server-settings observation. Missing/denied fields stay unknown. */
+    readonly diagnostics?: () => Promise<RedisConnectionDiagnostics>;
     readonly get: (key: string) => Promise<string | null>;
     readonly set: (key: string, value: string) => Promise<unknown>;
     readonly psetex: (key: string, ms: number, value: string) => Promise<unknown>;
@@ -164,6 +254,8 @@ export declare interface RespClient {
         readonly cursor: string;
         readonly keys: ReadonlyArray<string>;
     }>;
+    /** Native command transport is ready again after reconnect. Registry-owned. */
+    readonly onReconnect?: (listener: () => void) => () => void;
     readonly close: () => Promise<void>;
 }
 
@@ -177,4 +269,16 @@ export declare interface RespConnections {
     readonly config: (name: string) => Effect.Effect<RedisConnectionConfig, Config.ConfigError>;
 }
 
+/** The minimal command surface both ioredis and @upstash/redis satisfy —
+ *  the superset the framework's command-only RESP consumers (cache, rate
+ *  limiter, KV) need. `eval` runs a Lua script server-side (numKeys splits
+ *  KEYS from ARGV, the ioredis convention); `zrange` reads a full sorted set. */
+/** Read-only commands. Native and HTTP Lua use EVAL_RO, never writable EVAL. */
+declare interface RespReadClient {
+    readonly get: (key: string) => Promise<string | null>;
+    readonly exists: (key: string) => Promise<number>;
+    readonly zrange: (key: string) => Promise<ReadonlyArray<string>>;
+    readonly eval: (script: string, numKeys: number, ...args: ReadonlyArray<string | number>) => Promise<unknown>;
+}
+
 export { }

package/dist/nativeRedisReads.js

@@ -0,0 +1,77 @@
+import { createNativeRedisConnection as e, disconnectNativeRedis as t, nativeRedisTopology as n } from "./nativeRedisTopology.js";
+import { measuredRedisReader as r } from "./redisReadPolicy.js";
+// src/nativeRedisReads.ts
+var i = () => {
+	throw Error("No confirmed native Redis reader is available");
+}, a = (e, t, n) => {
+	let r = (t ? e.slice(1) : e).filter((e) => e.status === "ready" && n.has(e));
+	return r.sort((e, t) => n.get(e) - n.get(t)), r[0] ?? i();
+}, o = (e) => {
+	let t = n(e);
+	if (t.kind === "standalone" && e.readFrom === "replica" && !e.replicas?.length) throw Error("Standalone replica reads require replica endpoints");
+	let r = t.kind === "standalone" ? t.db : t.kind === "sentinel" ? t.options.db ?? 0 : 0;
+	return (e.replicas ?? []).map((i) => {
+		let a = {
+			...e,
+			url: i,
+			cluster: t.kind === "cluster",
+			replicas: [],
+			readFrom: "primary"
+		}, o = n(a);
+		if ((o.kind === "standalone" ? o.db : o.kind === "sentinel" ? o.options.db ?? 0 : 0) !== r || t.kind === "cluster" != (o.kind === "cluster") || o.kind === "sentinel" || /^rediss(?:\+cluster|\+sentinel)?:/i.test(e.url) && !/^rediss(?:\+cluster)?:/i.test(i)) throw Error("Replica endpoints must retain topology, database and TLS admission");
+		return a;
+	});
+}, s = async (n, s, c) => {
+	let l = n.readFrom ?? "primary", u = o(n), d = [], f = /* @__PURE__ */ new Map(), p = async () => {
+		await Promise.all(d.map(t));
+	}, m = async (t) => {
+		c.throwIfAborted();
+		let n = /* @__PURE__ */ new Map(), r = await e(t, "command", l, (e) => a(e, l === "replica", n));
+		d.push(r), f.set(r, n), r.client.on("error", () => {});
+		let i = () => {
+			r.client.disconnect();
+		};
+		c.addEventListener("abort", i, { once: !0 });
+		try {
+			c.throwIfAborted(), await r.client.connect(), await r.ready(), c.throwIfAborted();
+		} finally {
+			c.removeEventListener("abort", i);
+		}
+		return r;
+	};
+	try {
+		if (l !== "primary") {
+			if (u.length > 0) for (let e of u) await m(e);
+			else s.kind === "standalone" ? l === "replica" && i() : await m(n);
+		}
+		let e = l === "replica" || s.kind === "cluster" && l !== "primary" ? d : [s, ...d], t = async (e) => {
+			if (e.kind === "cluster" && await new Promise((t, n) => e.client.refreshSlotsCache((e) => e ? n(e) : t())), await e.ready(), e.kind === "cluster") {
+				let t = f.get(e) ?? i(), n = await Promise.all(e.client.nodes("all").map(async (e) => {
+					if (e.status !== "ready") return;
+					let t = performance.now();
+					try {
+						if (await e.ping() !== "PONG") return;
+						let n = performance.now() - t;
+						if (Number(await e.call("eval_ro", "return 1", 0)) === 1) return [e, n];
+					} catch {}
+				}));
+				t.clear();
+				for (let e of n) e !== void 0 && t.set(...e);
+				(l === "replica" ? e.client.nodes("slave") : e.client.nodes("all")).some((e) => t.has(e)) || i();
+			} else {
+				if (await e.client.ping() !== "PONG" && i(), e !== s) {
+					let [t, n] = await Promise.all([s.client.info("replication"), e.client.info("replication")]), r = (e, t) => e.split(/\r?\n/).find((e) => e.startsWith(t + ":"))?.slice(t.length + 1);
+					r(n, "role") === "slave" && r(n, "master_link_status") === "up" && r(t, "master_replid") && r(t, "master_replid") === r(n, "master_replid") || i();
+				}
+				Number(await e.client.call("eval_ro", "return 1", 0)) !== 1 && i();
+			}
+		};
+		return l !== "primary" && await r(e, t), {
+			close: p,
+			select: async () => l === "primary" ? s : r(e, t)
+		};
+	} catch (e) {
+		throw await p(), e;
+	}
+};
+export { o as nativeRedisReadConfigs, s as openNativeRedisReaders, a as selectNativeReadNode };

package/dist/nativeRedisTopology.js

@@ -0,0 +1,222 @@
+import { connectionMetadataProblem as e, redisTimeoutsProblem as t } from "./connectionDefinitions.js";
+import { missingDriver as n } from "./driverModule.js";
+// src/nativeRedisTopology.ts
+var r = (e) => {
+	throw Error(`Invalid native Redis topology: ${e}`);
+}, i = (e) => !/^\d+$/.test(e) || !Number.isSafeInteger(Number(e)) ? r("database must be a nonnegative integer") : Number(e), a = (n) => {
+	let a = t(n, n.driver);
+	if (a) return r(a);
+	try {
+		let t = e(n);
+		if (t) return r(t);
+		if (typeof n.url != "string" || !n.url.trim()) return r("URL is required");
+		if (n.url !== n.url.trim()) return r("URL must not contain surrounding whitespace");
+		if (n.cluster !== void 0 && typeof n.cluster != "boolean") return r("cluster must be boolean");
+		let a = /^([a-z][a-z\d+.-]*):\/\/([^/?#]+)(.*)$/i.exec(n.url);
+		if (!a) return r("URL must declare a native Redis scheme and endpoint");
+		let o = a[1].toLowerCase(), s = o === "redis+cluster" || o === "rediss+cluster", c = o === "redis+sentinel" || o === "rediss+sentinel";
+		if (!s && !c && o !== "redis" && o !== "rediss") return r("scheme is not native Redis");
+		if (s && n.cluster === !1) return r("cluster URL conflicts with cluster: false");
+		if (c && n.cluster === !0) return r("Sentinel URL conflicts with cluster: true");
+		let l = o.startsWith("rediss");
+		if (n.tls === "required" && !l) return r("TLS requires a secure Redis scheme");
+		let u = s || n.cluster === !0, d = a[2], f = d.lastIndexOf("@"), p = f < 0 ? "" : d.slice(0, f + 1), m = (f < 0 ? d : d.slice(f + 1)).split(",");
+		if (!u && !c && m.length !== 1) return r("standalone URL must contain one endpoint");
+		let h = m.map((e) => {
+			if (!e) return r("endpoint list contains an empty entry");
+			let t = new URL(`redis://${e}`);
+			if (t.username || t.password || t.pathname !== "" || t.search || t.hash || !t.hostname || /\s|%/.test(t.hostname)) return r("endpoint shape is invalid");
+			let n = t.port ? Number(t.port) : c ? 26379 : 6379;
+			return !Number.isInteger(n) || n < 1 || n > 65535 ? r("endpoint port is invalid") : {
+				host: t.hostname.replace(/^\[|\]$/g, ""),
+				port: n
+			};
+		}), g = new URL(`redis://${p}${m[0]}${a[3]}`);
+		if (g.hash) return r("URL fragments are not permitted");
+		let _ = decodeURIComponent(g.username), v = decodeURIComponent(g.password), y = c ? [
+			"db",
+			"sentinelUsername",
+			"sentinelPassword"
+		] : ["db"];
+		for (let e of g.searchParams.keys()) if (!y.includes(e) || g.searchParams.getAll(e).length !== 1) return r("query parameter is unknown or repeated");
+		if (!u && !c) {
+			let e = g.pathname === "" || g.pathname === "/" ? void 0 : i(g.pathname.slice(1)), t = g.searchParams.get("db");
+			return t !== null && e !== void 0 && i(t) !== e ? r("database declarations conflict") : {
+				kind: "standalone",
+				url: n.url,
+				db: t === null ? e ?? 0 : i(t)
+			};
+		}
+		let b = {
+			..._ ? { username: _ } : {},
+			...v ? { password: v } : {},
+			...l ? { tls: {} } : {}
+		}, x = [...new Map(h.map((e) => [JSON.stringify([e.host, e.port]), e])).values()];
+		if (u) {
+			let e = g.pathname === "" || g.pathname === "/" ? 0 : i(g.pathname.slice(1)), t = g.searchParams.get("db");
+			return e !== 0 || t !== null && i(t) !== 0 ? r("Cluster requires database zero") : {
+				kind: "cluster",
+				nodes: x,
+				options: b
+			};
+		}
+		let S = decodeURIComponent(g.pathname.slice(1));
+		if (!S || /[\s/\\?#]/.test(S)) return r("Sentinel requires one master group name");
+		let C = g.searchParams.get("sentinelUsername"), w = g.searchParams.get("sentinelPassword"), T = g.searchParams.get("db");
+		return {
+			kind: "sentinel",
+			nodes: x,
+			name: S,
+			options: {
+				...b,
+				db: T === null ? 0 : i(T),
+				...C === null ? {} : { sentinelUsername: C },
+				...w === null ? {} : { sentinelPassword: w },
+				...l ? {
+					enableTLSForSentinelMode: !0,
+					sentinelTLS: {}
+				} : {}
+			}
+		};
+	} catch (e) {
+		if (e instanceof Error && e.message.startsWith("Invalid native Redis topology:")) throw e;
+		return r("URL or encoded component is invalid");
+	}
+}, o = (e, t = "master") => {
+	let n = /* @__PURE__ */ new WeakMap(), r = () => /* @__PURE__ */ Error("Native Redis Cluster sockets are not confirmed"), i = (e) => {
+		if (e.status === "ready") return Promise.resolve();
+		let t = n.get(e);
+		if (t !== void 0) return t;
+		if (![
+			"wait",
+			"connecting",
+			"connect"
+		].includes(e.status)) return Promise.reject(r());
+		let i = new Promise((t, n) => {
+			let i = !1, a = () => {
+				e.off("ready", s), e.off("close", o), e.off("end", o), e.off("error", o);
+			}, o = () => {
+				i || (i = !0, a(), n(r()));
+			}, s = () => {
+				e.status === "ready" ? i || (i = !0, a(), t()) : o();
+			};
+			if (e.once("ready", s), e.once("close", o), e.once("end", o), e.once("error", o), e.status === "wait") try {
+				e.connect().then(s, o);
+			} catch {
+				o();
+			}
+			else e.status === "ready" && s();
+		});
+		return n.set(e, i), i.then(() => n.delete(e), () => n.delete(e)), i;
+	};
+	return async () => {
+		if (e.status !== "ready") throw r();
+		let n = e.nodes(t);
+		if (n.length === 0) throw r();
+		await Promise.all(n.map(i));
+		let a = e.nodes(t);
+		if (e.status !== "ready" || a.length !== n.length || a.some((e) => e.status !== "ready" || !n.includes(e))) throw r();
+	};
+}, s = (e, t) => {
+	let n = 0, r, i = () => /* @__PURE__ */ Error("Native Redis database is not confirmed");
+	return t !== 0 && (e.on("close", () => {
+		n++, r = void 0;
+	}), e.on("ready", () => {
+		let a = ++n, o = Promise.resolve().then(() => {
+			if (n !== a || e.status !== "ready") throw i();
+			return e.select(t);
+		}).then((t) => {
+			if (t !== "OK" || n !== a || e.status !== "ready") throw i();
+		}, () => {
+			throw i();
+		});
+		r = o, o.catch(() => {
+			n === a && e.disconnect();
+		});
+	})), async () => {
+		let n = r;
+		if (e.status !== "ready" || t !== 0 && n === void 0 || (await n, e.status !== "ready" || r !== n)) throw i();
+	};
+}, c = (e) => {
+	let t = (e.kind === "cluster" ? [e.client, ...e.client.nodes("all")] : [e.client]).map((e) => [
+		"end",
+		"wait",
+		"close",
+		"reconnecting"
+	].includes(e.status) ? Promise.resolve() : new Promise((t) => {
+		let n = () => {
+			e.off("close", n), e.off("end", n), t();
+		};
+		e.once("close", n), e.once("end", n);
+	}));
+	return e.client.status !== "end" && e.client.disconnect(), Promise.all(t).then(() => void 0);
+}, l = (e, t = {}) => ({
+	protocol: 2,
+	lazyConnect: !0,
+	autoResendUnfulfilledCommands: !1,
+	maxRetriesPerRequest: 0,
+	enableOfflineQueue: !1,
+	autoResubscribe: !1,
+	disconnectTimeout: 0,
+	...t.connectTimeoutMs === void 0 ? {} : { connectTimeout: t.connectTimeoutMs },
+	...t.commandTimeoutMs === void 0 ? {} : {
+		commandTimeout: t.commandTimeoutMs,
+		sentinelCommandTimeout: t.commandTimeoutMs
+	},
+	...e === "subscriber" ? {
+		retryStrategy: () => null,
+		sentinelRetryStrategy: () => null
+	} : {}
+}), u = async (e, t = "command", r = "primary", i) => {
+	let c = a(e), u = await import("ioredis").catch(n("ioredis", "A Redis connection")), d = u.default, f = l(t, e);
+	if (c.kind === "cluster") {
+		let e = new u.Cluster([...c.nodes], {
+			lazyConnect: !0,
+			enableOfflineQueue: !1,
+			scaleReads: i ?? "master",
+			retryDelayOnFailover: 0,
+			redisOptions: {
+				...c.options,
+				...f
+			},
+			...t === "subscriber" ? { clusterRetryStrategy: () => null } : {}
+		});
+		return {
+			kind: "cluster",
+			client: e,
+			ready: o(e, r === "primary" ? "master" : "all")
+		};
+	}
+	let p = c.kind === "standalone" ? new d(c.url, {
+		...f,
+		db: c.db,
+		.../^rediss:\/\//i.test(c.url) ? { tls: {} } : {}
+	}) : new d({
+		...c.options,
+		...f,
+		name: c.name,
+		sentinels: [...c.nodes],
+		role: r === "primary" ? "master" : "slave"
+	}), m = c.kind === "standalone" ? c.db : c.options.db ?? 0;
+	return {
+		kind: c.kind,
+		client: p,
+		ready: s(p, m)
+	};
+}, d = async (e, t, n, r) => {
+	if (e.kind !== "cluster") {
+		let [i, a] = await e.client.scan(t, "MATCH", n, "COUNT", r);
+		return {
+			cursor: i,
+			keys: a
+		};
+	}
+	let i = e.client.nodes("master").sort((e, t) => `${e.options.host}:${e.options.port}`.localeCompare(`${t.options.host}:${t.options.port}`)), a = t === "0" ? ["0", "0"] : t.split(":"), o = Number(a[0]);
+	if (a.length !== 2 || !/^\d+$/.test(a[0]) || !/^\d+$/.test(a[1]) || !Number.isSafeInteger(o) || o >= i.length) throw Error("Invalid Cluster scan cursor or unavailable primary");
+	let [s, c] = await i[o].scan(a[1], "MATCH", n, "COUNT", r);
+	return {
+		cursor: s === "0" ? o + 1 < i.length ? `${o + 1}:0` : "0" : `${o}:${s}`,
+		keys: c
+	};
+};
+export { u as createNativeRedisConnection, c as disconnectNativeRedis, o as nativeClusterReadiness, s as nativeDatabaseReadiness, l as nativeRedisOptions, a as nativeRedisTopology, d as scanNativeRedis };

package/dist/redisDiagnostics.js

@@ -0,0 +1,26 @@
+// src/redisDiagnostics.ts
+var e = [
+	"noeviction",
+	"allkeys-lru",
+	"allkeys-lfu",
+	"allkeys-random",
+	"volatile-lru",
+	"volatile-lfu",
+	"volatile-random",
+	"volatile-ttl"
+], t = (e, t) => {
+	if (typeof e != "string" || e.length > 1048576) return;
+	let n = e.split(/\r?\n/).filter((e) => e.startsWith(t + ":")).map((e) => e.slice(t.length + 1));
+	return n.length === 1 ? n[0] : void 0;
+}, n = (n, r, i) => {
+	let a = t(n, "aof_enabled"), o = t(r, "maxmemory_policy"), s = Array.isArray(i) && i.length === 2 && i[0] === "save" && typeof i[1] == "string" ? i[1].trim() : void 0, c = s?.split(/\s+/), l = s === "" ? !1 : c !== void 0 && c.length % 2 == 0 && c.every((e) => /^\d+$/.test(e) && Number.isSafeInteger(Number(e))) && c.every((e, t) => t % 2 == 1 || Number(e) > 0) ? !0 : void 0;
+	return {
+		persistence: a === "1" ? "aof" : a === "0" && l !== void 0 ? l ? "snapshot" : "none" : "unknown",
+		maxmemoryPolicy: e.find((e) => e === o) ?? "unknown"
+	};
+}, r = async (e) => n(...(await Promise.allSettled([
+	e.info("persistence"),
+	e.info("memory"),
+	e.config("GET", "save")
+])).map((e) => e.status === "fulfilled" ? e.value : void 0));
+export { r as readRedisNodeDiagnostics, n as redisNodeDiagnostics };

package/dist/redisReadPolicy.js

@@ -0,0 +1,38 @@
+// src/redisReadPolicy.ts
+var e = async (e, t) => {
+	let n = (await Promise.all(e.map(async (e) => {
+		let n = performance.now();
+		try {
+			return await t(e), {
+				candidate: e,
+				elapsed: performance.now() - n
+			};
+		} catch {
+			return;
+		}
+	}))).filter((e) => e !== void 0).sort((e, t) => e.elapsed - t.elapsed);
+	if (n.length === 0) throw Error("No confirmed Redis reader is available");
+	return n[0].candidate;
+}, t = (t, n, r) => {
+	let i = r === "replica" ? n : [t, ...n], a = async () => {
+		let n = r === void 0 || r === "primary" ? t : await e(i, async (e) => {
+			if (e.ping === void 0 || await e.ping() !== "PONG" || e.readOnly === void 0) throw Error("Redis reader is not ready");
+			if (Number(await e.readOnly.eval("return 1", 0)) !== 1) throw Error("Redis read-only Lua is unavailable");
+		});
+		if (n.readOnly === void 0) throw Error("Redis read-only Lua is unavailable");
+		return n.readOnly;
+	};
+	return {
+		...t,
+		readOnly: {
+			get: async (e) => (await a()).get(e),
+			exists: async (e) => (await a()).exists(e),
+			zrange: async (e) => (await a()).zrange(e),
+			eval: async (e, t, ...n) => (await a()).eval(e, t, ...n)
+		},
+		close: async () => {
+			await Promise.all([t, ...n].map((e) => e.close()));
+		}
+	};
+};
+export { t as httpRedisReaders, e as measuredRedisReader };

package/dist/sql.d.ts

@@ -0,0 +1,77 @@
+import { Config } from 'effect';
+import { Effect } from 'effect';
+import { Schema } from 'effect';
+import { SqlClient } from 'effect/sql';
+import { Stream } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+declare interface ConnectionContext {
+    readonly tenantId: string;
+}
+
+/** An environment declaration, never the environment value itself. */
+declare interface ConnectionEnv {
+    readonly _tag: 'ConnectionEnv';
+    readonly name: string;
+}
+
+export declare interface DynamicSqlConnection {
+    readonly _tag: 'DynamicSqlConnection';
+    readonly resolve: (context: ConnectionContext) => Effect.Effect<SqlConnectionConfig, KvError>;
+    readonly ttlMs: number;
+}
+
+declare class KvError extends KvError_base {
+    get message(): string;
+}
+
+declare const KvError_base: Schema.Class<KvError, Schema.TaggedStruct<"KvError", {
+    /** Which op failed: 'get' | 'set' | 'delete' | 'has' | 'clear' |
+     *  'list' | 'connect' | 'serialize' | 'deserialize'. */
+    readonly operation: Schema.String;
+    /** The key (or connection name) involved; '' where not applicable. */
+    readonly key: Schema.String;
+    /** `String(originalError)` — round-trip-safe diagnostic form. */
+    readonly cause: Schema.String;
+}>, YieldableError>;
+
+/** A whole operation (including its transaction) borrows one physical generation.
+ * Do not return the client, a deferred statement or a stream from use: execute it
+ * inside the callback. Use stream for a lazy result that must retain its lease. */
+export declare interface SqlConnection {
+    readonly dialect: SqlConnectionConfig['dialect'];
+    readonly use: <A, E, R>(run: (client: SqlClient.SqlClient) => Effect.Effect<A, E, R>) => Effect.Effect<A, E | KvError | Config.ConfigError, R>;
+    readonly stream: <A, E, R>(run: (client: SqlClient.SqlClient) => Stream.Stream<A, E, R>) => Stream.Stream<A, E | KvError | Config.ConfigError, R>;
+}
+
+/** Additional SQL target. The primary DataStore retains its own configuration. */
+export declare interface SqlConnectionConfig {
+    readonly dialect: SqlConnectionDialect;
+    readonly url: string;
+    readonly tls?: 'auto' | 'required';
+    readonly maxConnections?: number;
+    readonly acquireTimeoutMs?: number;
+    readonly acquireQueueLimit?: number;
+    readonly statementTimeoutMs?: number;
+    readonly schema?: string;
+    readonly label?: string;
+    readonly region?: string;
+    readonly source?: 'config' | 'override';
+}
+
+export declare type SqlConnectionConnector = (config: SqlConnectionConfig) => Effect.Effect<SqlConnectionTransport, KvError>;
+
+export declare interface SqlConnectionDefinition extends Omit<SqlConnectionConfig, 'url' | 'source'> {
+    readonly url: ConnectionEnv;
+}
+
+export declare type SqlConnectionDialect = 'postgres' | 'mysql' | 'mariadb' | 'mssql' | 'sqlite' | 'turso';
+
+/** Connector-owned resources; a consumer never receives physical disposal. */
+export declare interface SqlConnectionTransport {
+    readonly client: SqlClient.SqlClient;
+    readonly probe: Effect.Effect<void, KvError>;
+    readonly close: Effect.Effect<void>;
+}
+
+export { }