@voltro/kv 0.85.0 → 0.87.0

package/dist/connectionPool.js

@@ -0,0 +1,738 @@
+import { KvError as e } from "./errors.js";
+import { withRespKeyPrefix as t } from "./connectionPrefix.js";
+import { sqlConfigProblem as n, sqlConnectionConfig as r, sqlConnectionName as i } from "./connectionSqlConfig.js";
+import { analyticsConfigProblem as a, analyticsConnectionConfig as o, analyticsConnectionName as s } from "./connectionAnalyticsConfig.js";
+import { connectionDefinitionsProblem as c, natsConnectionName as l, redisConnectionName as u } from "./connectionDefinitions.js";
+import { makeConnectionOwner as d } from "./connectionOwner.js";
+import { applyConnectionNamespace as f, connectionNamespace as p } from "./connectionNamespace.js";
+import { connectRedisSubscriber as m } from "./connectionSubscriber.js";
+import { assertNatsSubject as ee, withNatsSubjectPrefix as te } from "./connectionNatsSubjects.js";
+import { connectNats as ne } from "./connectionNats.js";
+import { natsConnectionConfig as re } from "./connectionNatsConfig.js";
+import { StorageError as h } from "./storage.js";
+import { storageConfigProblem as ie, storageConnectionConfig as ae, storageConnectionName as oe } from "./connectionStorageConfig.js";
+import { makeStorageFacade as se } from "./connectionStorageFacade.js";
+import { CONNECTION_PUBLISH_SCRIPT as ce } from "./connectionScripts.js";
+import { AnalyticsCapabilityNotSupported as g, AnalyticsError as _ } from "./analytics.js";
+import { makeConnectionMetrics as le } from "./connectionMetrics.js";
+import { withConnectionRegistryConfigProvider as v } from "./connectionConfigProvider.js";
+import { RedisConnections as ue, connect as de, connectionConfig as fe } from "./connection.js";
+import { Cause as y, Clock as b, Config as x, ConfigProvider as S, Context as C, Deferred as pe, Effect as w, Layer as T, Pull as me, Scope as he, Stream as E, SynchronizedRef as D } from "effect";
+import { CircuitBreaker as ge, CircuitOpen as _e } from "@voltro/shared";
+//#region src/connectionPool.ts
+var O = class extends C.Service()("@voltro/ConnectionRegistry") {}, k = (v = {}) => w.gen(function* () {
+	let ue = 0, C = v.connections === void 0 ? {} : v.connections;
+	if (v.requirements !== void 0 && !Array.isArray(v.requirements)) return yield* w.fail(new x.ConfigError(new S.SourceError({ message: "Connection requirements must be an array" })));
+	let T = (v.requirements ?? []).map((e) => Object.freeze({ ...e }));
+	for (let e of T) if (e.onUnavailable !== void 0 && e.onUnavailable !== "degrade" && e.onUnavailable !== "fail" || typeof e.consumer != "string" || !e.consumer.trim() || typeof e.role != "string" || !/^[A-Za-z][A-Za-z0-9_-]*$/.test(e.role) || e.reference !== "" && (typeof e.reference != "string" || !/^(redis|nats|storage|analytics|sql):[A-Za-z][A-Za-z0-9_-]*$/.test(e.reference)) || [
+		"crossNode",
+		"pubsub",
+		"atomicMulti"
+	].some((t) => {
+		let n = e[t];
+		return n !== void 0 && typeof n != "boolean";
+	})) return yield* w.fail(new x.ConfigError(new S.SourceError({ message: "Connection requirements need consumer, role, a typed reference, boolean capabilities and a degrade/fail unavailable policy" })));
+	v.namespaceIdentity !== void 0 && (yield* w.try({
+		try: () => p(v.namespaceIdentity),
+		catch: () => new x.ConfigError(new S.SourceError({ message: "Connection namespace requires a nonempty app name and environment" }))
+	}));
+	let O = le(v.namespaceIdentity === void 0 ? "unscoped" : p(v.namespaceIdentity)), k = c(C);
+	if (k) return yield* w.fail(new x.ConfigError(new S.SourceError({ message: k })));
+	let A = C.maxDynamicPools ?? 128, ve = C.rotationGraceMs ?? 3e4, ye = v.failureThreshold ?? 5, be = v.resetTimeoutMs ?? 3e4;
+	for (let [e, t, n] of [
+		[
+			"maxDynamicPools",
+			A,
+			!1
+		],
+		[
+			"rotationGraceMs",
+			ve,
+			!0
+		],
+		[
+			"failureThreshold",
+			ye,
+			!1
+		],
+		[
+			"resetTimeoutMs",
+			be,
+			!1
+		]
+	]) if (!Number.isSafeInteger(t) || t < +!n) return yield* w.fail(new x.ConfigError(new S.SourceError({ message: `${e} must be a ${n ? "nonnegative" : "positive"} safe integer` })));
+	let j = yield* w.context(), xe = w.runPromiseWith(j), M = yield* D.make(/* @__PURE__ */ new Map()), N = /* @__PURE__ */ new Map(), P = /* @__PURE__ */ new Map(), F = /* @__PURE__ */ new Map(), I = /* @__PURE__ */ new Map(), L = /* @__PURE__ */ new Map(), R = /* @__PURE__ */ new Map(), z = (e) => {
+		if (e.startsWith("sql:")) return `sql:${i(e, C)}`;
+		if (e.startsWith("analytics:")) return `analytics:${s(e, C)}`;
+		if (e.startsWith("storage:")) return `storage:${oe(e, C)}`;
+		if (e.startsWith("nats:")) return `nats:${l(e, C)}`;
+		let t = u(e, C);
+		return C.redis?.[t] === void 0 ? e.startsWith("redis:") ? t : e : `redis:${t}`;
+	}, B = (e, t) => JSON.stringify([z(e), V(e) ? t?.tenantId ?? null : null]), Se = (e) => e.startsWith("sql:") ? C.sql?.[i(e, C)] : e.startsWith("analytics:") ? C.analytics?.[s(e, C)] : e.startsWith("storage:") ? C.storage?.[oe(e, C)] : e.startsWith("nats:") ? C.nats?.[l(e, C)] : C.redis?.[u(e, C)], V = (e) => {
+		let t = Se(e);
+		return t !== void 0 && "_tag" in t && (t._tag === "DynamicRedisConnection" || t._tag === "DynamicNatsConnection" || t._tag === "DynamicStorageConnection" || t._tag === "DynamicAnalyticsConnection" || t._tag === "DynamicSqlConnection");
+	}, Ce = (e) => w.suspend(() => {
+		if (e !== "" && !/^(redis|nats|storage|analytics|sql):[A-Za-z][A-Za-z0-9_-]*$/.test(e)) return w.fail(new x.ConfigError(new S.SourceError({ message: "A connection reference must use redis:name, nats:name, storage:name, analytics:name or sql:name" })));
+		let t = V(e), n = {
+			reference: z(e),
+			tenantScoped: t
+		};
+		return t ? w.succeed(n) : Oe(e).pipe(w.as(n));
+	}), H = (e, t) => fe(e, C, t).pipe(w.flatMap((e) => v.namespaceIdentity === void 0 ? w.succeed(e) : w.try({
+		try: () => f(e, v.namespaceIdentity),
+		catch: (e) => new x.ConfigError(new S.SourceError({ message: e instanceof Error ? e.message : "Connection namespace admission failed" }))
+	})), w.flatMap((t) => {
+		let n = z(e);
+		for (let e of T) if (z(e.reference) === n) {
+			if (t.driver === "memory" && e.crossNode) return w.fail(new x.ConfigError(new S.SourceError({ message: `Plugin ${e.consumer} role ${e.role} requires a network Redis connection; memory is local` })));
+			if (t.driver === "http" && (e.pubsub || e.atomicMulti)) {
+				let t = e.pubsub ? "Pub/Sub" : "atomic MULTI";
+				return w.fail(new x.ConfigError(new S.SourceError({ message: `Plugin ${e.consumer} role ${e.role} requires ${t}; its selected Redis connection requires the RESP driver` })));
+			}
+		}
+		return w.succeed(t);
+	}), w.mapError((e) => e instanceof x.ConfigError ? e : new x.ConfigError(new S.SourceError({ message: "Dynamic connection credentials could not be resolved" })))), we = (e, t) => re(e, C, t).pipe(w.flatMap((e) => v.namespaceIdentity === void 0 ? w.succeed(e) : w.try({
+		try: () => f(e, v.namespaceIdentity),
+		catch: () => new x.ConfigError(new S.SourceError({ message: "Connection namespace admission failed" }))
+	})), w.mapError((e) => e instanceof x.ConfigError ? e : new x.ConfigError(new S.SourceError({ message: "Dynamic connection credentials could not be resolved" })))), Te = (e, t) => ae(e, C, t).pipe(w.flatMap((t) => {
+		if (v.namespaceIdentity?.environment === "production" && (t = {
+			...t,
+			tls: "required"
+		}), v.namespaceIdentity !== void 0 && t.keyPrefix === void 0 && (t = {
+			...t,
+			keyPrefix: `${p(v.namespaceIdentity)}/`
+		}), v.namespaceIdentity?.environment === "production" && t.keyPrefix !== `${p(v.namespaceIdentity)}/` && !t.allowSharedNamespace) return w.fail(new x.ConfigError(new S.SourceError({ message: "A custom production storage namespace requires allowSharedNamespace" })));
+		for (let n of T) if (z(n.reference) === z(e)) {
+			if (n.pubsub || n.atomicMulti) return w.fail(new x.ConfigError(new S.SourceError({ message: "Storage cannot provide Pub/Sub or atomic MULTI" })));
+			if (n.crossNode && [
+				"memory",
+				"filesystem",
+				"database"
+			].includes(t.provider)) return w.fail(new x.ConfigError(new S.SourceError({ message: "Cross-node storage requires a declared object-storage service" })));
+		}
+		let n = ie(t);
+		return n ? w.fail(new x.ConfigError(new S.SourceError({ message: n }))) : w.succeed(t);
+	}), w.mapError((e) => e instanceof x.ConfigError ? e : new x.ConfigError(new S.SourceError({ message: "Dynamic storage credentials could not be resolved" })))), Ee = (e, t) => o(e, C, t).pipe(w.flatMap((t) => {
+		v.namespaceIdentity?.environment === "production" && (t = {
+			...t,
+			tls: "required"
+		});
+		let n = a(t);
+		if (n) return w.fail(new x.ConfigError(new S.SourceError({ message: n })));
+		for (let n of T) if (z(n.reference) === z(e)) {
+			if (n.pubsub || n.atomicMulti) return w.fail(new x.ConfigError(new S.SourceError({ message: "Analytics cannot provide Redis Pub/Sub or atomic MULTI" })));
+			if (n.crossNode && t.provider === "duckdb") return w.fail(new x.ConfigError(new S.SourceError({ message: "Cross-node analytics requires a network provider; DuckDB is local" })));
+		}
+		return w.succeed(t);
+	}), w.mapError((e) => e instanceof x.ConfigError ? e : new x.ConfigError(new S.SourceError({ message: "Dynamic analytics credentials could not be resolved" })))), De = (e, t) => r(e, C, t).pipe(w.flatMap((t) => {
+		v.namespaceIdentity?.environment === "production" && !["sqlite", "turso"].includes(t.dialect) && (t = {
+			...t,
+			tls: "required"
+		});
+		let r = n(t);
+		if (r) return w.fail(new x.ConfigError(new S.SourceError({ message: r })));
+		for (let n of T) if (z(n.reference) === z(e)) {
+			if (n.pubsub || n.atomicMulti) return w.fail(new x.ConfigError(new S.SourceError({ message: "SQL cannot provide Redis Pub/Sub or atomic MULTI" })));
+			if (n.crossNode && ["sqlite", "turso"].includes(t.dialect)) return w.fail(new x.ConfigError(new S.SourceError({ message: "Cross-node SQL requires a network SQL dialect" })));
+		}
+		return w.succeed(t);
+	}), w.mapError((e) => e instanceof x.ConfigError ? e : new x.ConfigError(new S.SourceError({ message: "Dynamic SQL credentials could not be resolved" }))));
+	function Oe(e, t) {
+		return e.startsWith("sql:") ? De(e, t) : e.startsWith("analytics:") ? Ee(e, t) : e.startsWith("storage:") ? Te(e, t) : e.startsWith("nats:") ? we(e, t) : H(e, t);
+	}
+	for (let e of T) if ((e.reference.startsWith("nats:") || e.reference.startsWith("storage:") || e.reference.startsWith("analytics:") || e.reference.startsWith("sql:")) && e.atomicMulti) return yield* w.fail(new x.ConfigError(new S.SourceError({ message: `Plugin ${e.consumer} role ${e.role} requires atomic MULTI; NATS cannot provide Redis commands` })));
+	let U = yield* d({
+		rotationGraceMs: ve,
+		onStopping: () => {
+			N.clear();
+		},
+		onStopped: () => {
+			for (let e of P.values()) e.channels.clear(), e.listeners.clear();
+			P.clear();
+			for (let e of R.values()) e.dispose();
+			R.clear();
+			for (let e of F.values()) e.clear();
+			F.clear(), L.clear(), I.clear();
+		},
+		dispose: (e) => w.gen(function* () {
+			e.detachCommandReconnect?.(), e.binding?.current === e && delete e.binding.current, e.kind === "sql" || e.kind === "storage" || e.kind === "analytics" ? yield* e.transport.close : e.kind === "nats" ? yield* w.promise(() => e.transport.close().catch(() => void 0)) : (yield* w.promise(() => e.subscriber?.close().catch(() => void 0) ?? Promise.resolve()), yield* w.promise(() => e.client.close().catch(() => void 0)));
+		}).pipe(w.ensuring(w.sync(() => O.close(e))))
+	}), { close: W, trackOpen: ke } = U, G = (e) => {
+		U.register(e), O.register(e, e.reference);
+	}, Ae = (e) => w.sync(() => O.retire(e)).pipe(w.andThen(U.retire(e))), K = (e) => w.sync(() => O.release(e)).pipe(w.andThen(U.release(e))), q = (e) => {
+		e.errors++, O.error(e.reference);
+	}, J = (e) => (t) => y.hasInterruptsOnly(t) ? w.void : w.sync(() => {
+		q(e);
+	}), Y = (e, t) => b.currentTimeNanos.pipe(w.flatMap((n) => e.breaker.state.pipe(w.tap((r) => w.sync(() => {
+		e.latencyMs = Number(n - t) / 1e6, O.completed(e.reference, e.latencyMs), r === "open" && O.available(e, !1);
+	}))))), je = (e, t) => {
+		for (let n of e.listeners) try {
+			n(t);
+		} catch {}
+	}, Me = (t, n) => w.gen(function* () {
+		if (t.kind === "sql" || t.kind === "storage" || t.kind === "analytics") return yield* w.fail(new e({
+			operation: "subscribe",
+			key: "",
+			cause: "Selected connection has no Pub/Sub transport"
+		}));
+		if (t.subscriber !== void 0) return;
+		if (t.kind === "redis" && t.config.driver === "http") return yield* w.fail(new e({
+			operation: "subscribe",
+			key: "",
+			cause: "Redis Pub/Sub requires the RESP driver"
+		}));
+		let r = yield* (t.kind === "nats" ? w.succeed(te(t.transport, t.config.keyPrefix)) : t.memory === void 0 ? (v.connectSubscriber ?? m)(t.config) : w.sync(() => t.memory.subscriber())).pipe(w.mapError(() => new e({
+			operation: "subscribe",
+			key: "",
+			cause: "Redis subscriber could not be opened"
+		})));
+		t.subscriber = r, t.binding = n, r.onMessage((e, n) => {
+			let r = t.binding;
+			if (!(U.stopped || r?.current !== t || t.closed)) for (let t of r.channels.get(e) ?? []) try {
+				t(n);
+			} catch {}
+		}), r.onTransportEvent((e) => {
+			let n = t.binding;
+			!U.stopped && n?.current === t && !t.closed && je(n, e);
+		}), yield* w.forEach([...n.channels.keys()], (t) => w.tryPromise({
+			try: () => r.subscribe(t),
+			catch: () => new e({
+				operation: "subscribe",
+				key: "",
+				cause: "Redis subscription could not be registered"
+			})
+		}), { discard: !0 });
+	}), Ne = (e, t) => ke(Me(e, t)), X = (e) => {
+		O.activate(e), e.kind === "storage" && I.set(B(e.reference, e.context), e.config);
+		let t = e.binding;
+		if (t === void 0) return;
+		let n = t.current;
+		t.current = e, n !== void 0 && n !== e && t.channels.size > 0 && (je(t, { kind: "disconnected" }), je(t, { kind: "reconnected" }));
+	}, Pe = (n, r, i, a) => w.uninterruptibleMask((o) => w.gen(function* () {
+		let s = yield* o((n.startsWith("sql:") ? De(n, r).pipe(w.map((e) => ({
+			kind: "sql",
+			config: e
+		}))) : n.startsWith("analytics:") ? Ee(n, r).pipe(w.map((e) => ({
+			kind: "analytics",
+			config: e
+		}))) : n.startsWith("storage:") ? Te(n, r).pipe(w.map((e) => ({
+			kind: "storage",
+			config: e
+		}))) : n.startsWith("nats:") ? we(n, r).pipe(w.map((e) => ({
+			kind: "nats",
+			config: e
+		}))) : H(n, r).pipe(w.map((e) => ({
+			kind: "redis",
+			config: e
+		})))).pipe(w.interruptible)), c = yield* b.currentTimeMillis, l = Se(n), u = V(n), d = yield* ge.make({
+			name: n,
+			failureThreshold: ye,
+			resetTimeout: be,
+			...s.kind === "sql" ? { isFailure: (t) => t instanceof e || t instanceof _ || typeof t == "object" && !!t && "_tag" in t && t._tag === "HotError" && "reason" in t && t.reason === "unavailable" } : {}
+		}), f = yield* pe.make(), p = {
+			reference: z(n),
+			context: r,
+			breaker: d,
+			dynamic: u,
+			closedSignal: f,
+			expiresAt: l !== void 0 && "_tag" in l && "ttlMs" in l ? c + l.ttlMs : Infinity,
+			active: 0,
+			lastUsed: c,
+			commands: 0,
+			errors: 0,
+			latencyMs: null,
+			retired: !1,
+			closed: !1
+		}, m;
+		if (s.kind === "sql") {
+			if (v.connectSql === void 0) return yield* w.fail(new x.ConfigError(new S.SourceError({ message: "SQL requires an app-owned SQL connector" })));
+			if (a !== void 0 && (a.kind !== "sql" || a.config.dialect !== s.config.dialect)) return yield* w.fail(new x.ConfigError(new S.SourceError({ message: "SQL rotation must preserve the dialect contract" })));
+			let t = yield* v.connectSql(s.config).pipe(w.mapError(() => new e({
+				operation: "connect",
+				key: "",
+				cause: "SQL transport could not be constructed"
+			})));
+			m = {
+				...p,
+				kind: "sql",
+				drainUntilReleased: !0,
+				transport: t,
+				config: s.config
+			}, G(m), yield* o(t.probe.pipe(w.interruptible, w.timeout("5 seconds"), w.mapError(() => new e({
+				operation: "connect",
+				key: "",
+				cause: "SQL readiness failed"
+			})))).pipe(w.onError(() => W(m)));
+		} else if (s.kind === "analytics") {
+			if (v.connectAnalytics === void 0) return yield* w.fail(new x.ConfigError(new S.SourceError({ message: "Analytics requires an app-owned analytics connector" })));
+			let t = yield* v.connectAnalytics(s.config).pipe(w.mapError(() => new e({
+				operation: "connect",
+				key: "",
+				cause: "Analytics transport could not be constructed"
+			})));
+			if (m = {
+				...p,
+				kind: "analytics",
+				transport: t,
+				config: s.config
+			}, G(m), a !== void 0) {
+				if (a.kind !== "analytics" || a.config.provider !== s.config.provider) return yield* W(m), yield* w.fail(new x.ConfigError(new S.SourceError({ message: "Analytics rotation must preserve the provider contract" })));
+				let e = a.transport.sink, n = t.sink;
+				if (JSON.stringify(e.info.capabilities) !== JSON.stringify(n.info.capabilities) || JSON.stringify(e.mirror?.tables ?? []) !== JSON.stringify(n.mirror?.tables ?? []) || e.mirror?.primaryKey !== n.mirror?.primaryKey) return yield* W(m), yield* w.fail(new x.ConfigError(new S.SourceError({ message: "Analytics rotation must preserve capabilities and mirror schema" })));
+			}
+			yield* o(t.probe.pipe(w.interruptible, w.timeout("5 seconds"), w.mapError(() => new e({
+				operation: "connect",
+				key: "",
+				cause: a === void 0 ? "Analytics readiness failed" : "Replacement analytics readiness failed"
+			})))).pipe(w.onError(() => W(m)));
+		} else if (s.kind === "storage") {
+			if (v.connectStorage === void 0) return yield* w.fail(new x.ConfigError(new S.SourceError({ message: "Storage requires an app-owned storage connector" })));
+			let t;
+			if (s.config.provider === "memory") {
+				let e = B(n, r);
+				t = F.get(e), t === void 0 && (t = /* @__PURE__ */ new Map(), F.set(e, t));
+			}
+			let i = yield* v.connectStorage(s.config, t === void 0 ? {} : { memory: t }).pipe(w.mapError(() => new e({
+				operation: "connect",
+				key: "",
+				cause: "Storage transport could not be constructed"
+			})));
+			m = {
+				...p,
+				kind: "storage",
+				transport: i,
+				config: s.config
+			}, G(m);
+			let o = L.get(B(n, r));
+			o !== void 0 && i.provider.bindDataStore?.(o), a !== void 0 && (yield* i.probe.pipe(w.timeout("5 seconds"), w.mapError(() => new e({
+				operation: "connect",
+				key: "",
+				cause: "Replacement storage readiness failed"
+			})), w.onError(() => W(m))));
+		} else if (s.kind === "nats") {
+			let t = s.config, n = yield* (v.connectNats === void 0 ? ne(t).pipe(w.timeout("5 seconds"), w.interruptible) : v.connectNats(t)).pipe(w.mapError(() => new e({
+				operation: "connect",
+				key: "",
+				cause: "NATS driver could not be opened"
+			})));
+			m = {
+				...p,
+				kind: "nats",
+				transport: n,
+				config: t
+			}, G(m);
+			let r = m;
+			m.detachCommandReconnect = n.onTransportEvent((e) => {
+				e.kind === "reconnected" && !U.stopped && !r.closed && !r.retired && w.runSyncWith(j)(r.breaker.reset);
+			});
+		} else {
+			let i = s.config, { keyPrefix: a, ...o } = i, c;
+			if (i.driver === "memory") {
+				let e = B(n, r);
+				if (c = R.get(e), c === void 0) {
+					let { makeMemoryConnectionState: t } = yield* w.promise(() => import("./connectionMemory.js"));
+					c = t(i.memoryClock), R.set(e, c);
+				}
+			}
+			let l = yield* (c === void 0 ? v.connect === void 0 ? de(o).pipe(w.interruptible) : v.connect(o) : w.sync(() => c.command())).pipe(w.map((e) => t(e, a)), w.mapError(() => new e({
+				operation: "connect",
+				key: "",
+				cause: "Connection driver could not be opened"
+			})));
+			m = {
+				...p,
+				kind: "redis",
+				client: l,
+				config: i,
+				...c === void 0 ? {} : { memory: c }
+			}, G(m);
+			let u = m, d = l.onReconnect?.(() => {
+				!U.stopped && !u.closed && !u.retired && w.runSyncWith(j)(u.breaker.reset);
+			});
+			d !== void 0 && (m.detachCommandReconnect = d);
+		}
+		return O.available(m, m.kind !== "storage" || a !== void 0), i?.(m), a?.binding !== void 0 && (m.binding = a.binding, a.binding.channels.size > 0 && (yield* Ne(m, a.binding).pipe(w.onError(() => W(m))))), i === void 0 && X(m), m;
+	})), Fe = (e, t, n, r) => ke(Pe(e, t, n, r)).pipe(w.tapCause((t) => y.hasInterruptsOnly(t) ? w.void : w.sync(() => {
+		let t = z(e);
+		/^(redis|nats|storage|analytics|sql):[A-Za-z][A-Za-z0-9_-]*$/.test(t) && O.error(t);
+	}))), Z = (t, n) => D.modifyEffect(M, (r) => w.gen(function* () {
+		if (U.stopped) return yield* w.fail(new e({
+			operation: "connect",
+			key: "",
+			cause: "Connection registry is closed"
+		}));
+		let i = B(t, n), a = yield* b.currentTimeMillis, o = r.get(i);
+		if (o && o.expiresAt > a) return o.active++, O.acquire(o), o.lastUsed = a, [o, r];
+		let s = new Map(r);
+		if (!o && V(t)) {
+			let r = [...s.entries()].filter(([, e]) => e.dynamic);
+			if (r.length >= A) {
+				let a = r.filter(([, e]) => e.active === 0 && (e.binding?.channels.size ?? 0) === 0).sort((e, t) => e[1].lastUsed - t[1].lastUsed)[0];
+				if (!a) return yield* w.fail(new e({
+					operation: "connect",
+					key: "",
+					cause: "All dynamic connection pools are busy; maxDynamicPools reached"
+				}));
+				let c = yield* Fe(t, n, void 0, o);
+				return s.delete(a[0]), yield* Ae(a[1]), c.active++, O.acquire(c), s.set(i, c), [c, s];
+			}
+		}
+		let c = yield* Fe(t, n, void 0, o);
+		return o && (yield* Ae(o)), c.active++, O.acquire(c), s.set(i, c), [c, s];
+	})), Q = (t, n, r, i) => w.acquireUseRelease(Z(t, n), (t) => w.gen(function* () {
+		let n = yield* b.currentTimeNanos;
+		return t.commands++, O.command(t.reference), yield* t.breaker(i(t)).pipe(w.tap(() => w.sync(() => O.available(t, !0))), w.tapCause(J(t)), w.mapError((t) => t instanceof _e ? new e({
+			operation: r,
+			key: "",
+			cause: `Connection circuit is open; retry after ${t.retryAfterMs} ms`
+		}) : t), w.ensuring(Y(t, n)));
+	}), K), Ie = (t, n, r, i) => xe(Q(t, n, r, (t) => w.tryPromise({
+		try: () => i(t),
+		catch: () => new e({
+			operation: r,
+			key: "",
+			cause: "Connection command failed"
+		})
+	}))), Le = (t, n) => Q(t, n, "probe", (t) => t.kind === "sql" ? t.transport.probe : t.kind === "analytics" ? t.transport.probe.pipe(w.mapError(() => new e({
+		operation: "probe",
+		key: "",
+		cause: "Analytics readiness probe failed"
+	}))) : t.kind === "storage" ? t.transport.probe.pipe(w.mapError(() => new e({
+		operation: "probe",
+		key: "",
+		cause: "Storage readiness probe failed"
+	}))) : w.tryPromise({
+		try: async () => {
+			if (t.kind === "nats") return t.transport.flush();
+			if (t.client.ping === void 0 || await t.client.ping() !== "PONG") throw Error("Redis readiness requires PONG");
+		},
+		catch: () => new e({
+			operation: "probe",
+			key: "",
+			cause: "Connection readiness probe failed"
+		})
+	})), $ = (e, t, n, r) => Ie(e, t, n, (e) => {
+		if (e.kind !== "redis") throw Error("Redis commands require a Redis connection");
+		return r(e.client);
+	}), Re = (e, t) => w.gen(function* () {
+		if (e.includes(":") && !e.startsWith("redis:")) return yield* w.fail(new x.ConfigError(new S.SourceError({ message: "Redis commands require a redis:name reference" })));
+		let n = t === void 0 ? void 0 : Object.freeze({ tenantId: t.tenantId }), r = yield* w.acquireUseRelease(Z(e, n), (e) => e.kind === "redis" ? w.succeed({
+			ping: e.client.ping !== void 0,
+			crossNode: e.client.crossNode
+		}) : w.fail(new x.ConfigError(new S.SourceError({ message: "Redis commands require a redis:name reference" }))), K), i = B(e, n), a = N.get(i);
+		if (a) return a;
+		let o = (t, r) => $(e, n, t, (e) => {
+			if (e.readOnly === void 0) throw Error("Connection has no read-only transport");
+			return r(e.readOnly);
+		}), s = {
+			readOnly: {
+				get: (e) => o("read.get", (t) => t.get(e)),
+				exists: (e) => o("read.exists", (t) => t.exists(e)),
+				zrange: (e) => o("read.zrange", (t) => t.zrange(e)),
+				eval: (e, t, ...n) => o("read.eval", (r) => r.eval(e, t, ...n))
+			},
+			...r.crossNode === void 0 ? {} : { crossNode: r.crossNode },
+			...r.ping ? { ping: () => $(e, n, "ping", (e) => {
+				if (e.ping === void 0) throw Error("Connection driver has no PING probe");
+				return e.ping();
+			}) } : {},
+			diagnostics: () => $(e, n, "diagnostics", (e) => e.diagnostics?.() ?? Promise.resolve({ nodes: [] })),
+			get: (t) => $(e, n, "get", (e) => e.get(t)),
+			set: (t, r) => $(e, n, "set", (e) => e.set(t, r)),
+			psetex: (t, r, i) => $(e, n, "psetex", (e) => e.psetex(t, r, i)),
+			del: (t) => $(e, n, "del", (e) => e.del(t)),
+			exists: (t) => $(e, n, "exists", (e) => e.exists(t)),
+			eval: (t, r, ...i) => $(e, n, "eval", (e) => e.eval(t, r, ...i)),
+			zrange: (t) => $(e, n, "zrange", (e) => e.zrange(t)),
+			scan: (t, r, i) => $(e, n, "scan", (e) => e.scan(t, r, i)),
+			close: () => Promise.resolve()
+		};
+		return V(e) || N.set(i, s), s;
+	});
+	return {
+		client: Re,
+		config: Oe,
+		validate: Ce,
+		storage: (e, t) => w.gen(function* () {
+			if (!e.startsWith("storage:")) return yield* w.fail(new x.ConfigError(new S.SourceError({ message: "Storage requires a storage:name reference" })));
+			let n = t === void 0 ? void 0 : Object.freeze({ tenantId: t.tenantId }), r = yield* w.acquireUseRelease(Z(e, n), (e) => e.kind === "storage" ? w.succeed(e.config) : w.fail(new x.ConfigError(new S.SourceError({ message: "Storage requires a storage:name reference" }))), K), i = B(e, n), a = (e) => new h({
+				provider: r.provider,
+				message: "Storage connection operation failed",
+				transient: e instanceof h ? e.transient : !0,
+				...e instanceof h && e.outcome !== void 0 ? { outcome: e.outcome } : {},
+				...e instanceof h && e.status !== void 0 ? { status: e.status } : {}
+			});
+			return se({
+				config: () => I.get(i) ?? r,
+				command: (t, r) => w.acquireUseRelease(Z(e, n).pipe(w.mapError(a)), (e) => w.gen(function* () {
+					if (e.kind !== "storage") return yield* w.fail(a(void 0));
+					let t = yield* b.currentTimeNanos;
+					return e.commands++, O.command(e.reference), yield* e.breaker(r(e.transport.provider)).pipe(w.tap(() => w.sync(() => O.available(e, !0))), w.tapCause(J(e)), w.mapError(a), w.ensuring(Y(e, t)));
+				}), K),
+				stream: (t, r) => E.unwrap(w.acquireRelease(Z(e, n).pipe(w.mapError(a)), K).pipe(w.flatMap((e) => w.gen(function* () {
+					if (e.kind !== "storage") return yield* w.fail(a(void 0));
+					let n = yield* b.currentTimeNanos;
+					e.commands++, O.command(e.reference), yield* w.addFinalizer(() => Y(e, n));
+					let i = e.transport.provider, o = i.getStream === void 0 ? i.get(t).pipe(w.flatMap((t) => t.bytes.byteLength !== r.size || t.contentType !== (r.contentType ?? "application/octet-stream") ? w.fail(new h({
+						provider: e.config.provider,
+						message: "Storage metadata changed before stream consumption",
+						transient: !0
+					})) : w.succeed(E.succeed(t.bytes)))) : w.acquireRelease(i.getStream(t), (e) => e.close ?? w.void).pipe(w.flatMap((t) => t.size !== void 0 && t.size !== r.size || t.contentType !== (r.contentType ?? "application/octet-stream") ? w.fail(new h({
+						provider: e.config.provider,
+						message: "Storage metadata changed before stream consumption",
+						transient: !0
+					})) : w.succeed(t.stream)));
+					return yield* e.breaker(o).pipe(w.tap(() => w.sync(() => O.available(e, !0))), w.tapCause(J(e)), w.mapError(a), w.map((t) => t.pipe(E.mapError(a), E.tapCause((t) => J(e)(t)))));
+				})))),
+				bind: (e) => {
+					if (U.stopped) throw Error("Connection registry is closed");
+					L.set(i, e);
+					for (let t of w.runSyncWith(j)(D.get(M)).values()) t.kind === "storage" && B(t.reference, t.context) === i && t.transport.provider.bindDataStore?.(e);
+				}
+			});
+		}),
+		analytics: (e, t) => w.gen(function* () {
+			if (!e.startsWith("analytics:")) return yield* w.fail(new x.ConfigError(new S.SourceError({ message: "Analytics requires an analytics:name reference" })));
+			let n = t === void 0 ? void 0 : Object.freeze({ tenantId: t.tenantId }), r = yield* w.acquireUseRelease(Z(e, n), (e) => e.kind === "analytics" ? w.succeed(e.transport.sink) : w.fail(new x.ConfigError(new S.SourceError({ message: "Analytics requires an analytics:name reference" }))), K), i = Object.freeze({
+				provider: r.info.provider,
+				capabilities: Object.freeze({ ...r.info.capabilities })
+			}), a = (t, r) => Q(e, n, t, (e) => e.kind === "analytics" ? w.suspend(() => r(e.transport.sink)).pipe(w.mapError((e) => e instanceof g ? e : new _({
+				provider: i.provider,
+				operation: t,
+				cause: "Analytics connection operation failed"
+			}))) : w.fail(new _({
+				provider: i.provider,
+				operation: t,
+				cause: "Selected connection is not analytics"
+			}))).pipe(w.mapError((e) => e instanceof g ? e : new _({
+				provider: i.provider,
+				operation: t,
+				cause: "Analytics connection operation failed"
+			})));
+			return {
+				info: i,
+				track: (e) => a("track", (t) => t.track(e)),
+				aggregate: (e) => a("aggregate", (t) => t.aggregate(e)),
+				timeseries: (e) => a("timeseries", (t) => t.timeseries(e)),
+				topN: (e) => a("topN", (t) => t.topN(e)),
+				...r.mirror === void 0 ? {} : { mirror: {
+					tables: Object.freeze([...r.mirror.tables]),
+					...r.mirror.primaryKey === void 0 ? {} : { primaryKey: r.mirror.primaryKey },
+					upsert: (e) => a("mirror.upsert", (t) => t.mirror === void 0 ? w.fail(new g({
+						provider: i.provider,
+						capability: "mirror"
+					})) : t.mirror.upsert(e)),
+					remove: (e) => a("mirror.remove", (t) => t.mirror === void 0 ? w.fail(new g({
+						provider: i.provider,
+						capability: "mirror"
+					})) : t.mirror.remove(e)),
+					maxVersion: (e) => a("mirror.maxVersion", (t) => t.mirror === void 0 ? w.fail(new g({
+						provider: i.provider,
+						capability: "mirror"
+					})) : t.mirror.maxVersion(e))
+				} }
+			};
+		}),
+		sql: (t, n) => w.gen(function* () {
+			if (!/^sql:[A-Za-z][A-Za-z0-9_-]*$/.test(t)) return yield* w.fail(new x.ConfigError(new S.SourceError({ message: "SQL requires a sql:name reference" })));
+			let r = n === void 0 ? void 0 : Object.freeze({ tenantId: n.tenantId }), i = yield* w.acquireUseRelease(Z(t, r), (e) => e.kind === "sql" ? w.succeed(e.config.dialect) : w.fail(new x.ConfigError(new S.SourceError({ message: "SQL requires a sql:name reference" }))), K), a = () => new e({
+				operation: "sql",
+				key: "",
+				cause: "SQL connection operation failed"
+			}), o = (e) => typeof e == "object" && e && "_tag" in e && e._tag === "SqlError" ? a() : e;
+			return {
+				dialect: i,
+				use: (e) => Q(t, r, "sql", (t) => t.kind === "sql" ? w.suspend(() => e(t.transport.client)).pipe(w.mapError(o)) : w.fail(a())),
+				stream: (n) => E.unwrap(w.gen(function* () {
+					let i = yield* w.acquireRelease(Z(t, r), K);
+					if (i.kind !== "sql") return E.fail(a());
+					let s = yield* b.currentTimeNanos;
+					i.commands++, O.command(i.reference), yield* w.addFinalizer(() => Y(i, s));
+					let c = yield* w.scope, l = yield* w.cached(E.toPull(E.suspend(() => n(i.transport.client))).pipe(w.provideService(he.Scope, c))), u = w.flatMap(l, (e) => e);
+					return E.fromPull(w.succeed(i.breaker(u.pipe(w.mapError(o), me.catchDone(() => w.succeed(null)))).pipe(w.tap(() => w.sync(() => O.available(i, !0))), w.tapCause(J(i)), w.mapError((t) => t instanceof _e ? new e({
+						operation: "sql",
+						key: "",
+						cause: `Connection circuit is open; retry after ${t.retryAfterMs} ms`
+					}) : t), w.flatMap((e) => e === null ? y.done() : w.succeed(e)))));
+				}))
+			};
+		}),
+		pubsub: (t, n) => w.gen(function* () {
+			if (t.includes(":") && !/^(redis|nats):/.test(t)) return yield* w.fail(new x.ConfigError(new S.SourceError({ message: "Pub/Sub requires a Redis or NATS reference" })));
+			if (U.stopped) return yield* w.fail(new e({
+				operation: "subscribe",
+				key: "",
+				cause: "Connection registry is closed"
+			}));
+			let r = n === void 0 ? void 0 : Object.freeze({ tenantId: n.tenantId }), i = yield* t.startsWith("nats:") ? we(t, r) : H(t, r);
+			if (U.stopped) return yield* w.fail(new e({
+				operation: "subscribe",
+				key: "",
+				cause: "Connection registry is closed"
+			}));
+			if ("driver" in i && i.driver === "http") return yield* w.fail(new e({
+				operation: "subscribe",
+				key: "",
+				cause: "Redis Pub/Sub requires the RESP driver"
+			}));
+			let a = B(t, r), o = P.get(a);
+			o === void 0 && (o = {
+				channels: /* @__PURE__ */ new Map(),
+				listeners: /* @__PURE__ */ new Set(),
+				consumers: 0
+			}, P.set(a, o));
+			let s = o;
+			s.consumers++;
+			let c = !1, l = /* @__PURE__ */ new Set(), u = /* @__PURE__ */ new Set(), d = (e) => D.updateEffect(M, (t) => w.gen(function* () {
+				if (e.released) return t;
+				e.released = !0, l.delete(e);
+				let n = s.channels.get(e.channel);
+				if (n?.delete(e.handler), n?.size === 0) {
+					s.channels.delete(e.channel);
+					let t = s.current;
+					t?.subscriber !== void 0 && !t.closed && (yield* w.promise(() => t.subscriber.unsubscribe(e.channel).catch(() => {
+						q(t);
+					})));
+				}
+				return t;
+			})).pipe(w.uninterruptible), f = yield* w.cached(w.gen(function* () {
+				c = !0, yield* D.update(M, (e) => e);
+				for (let e of u) s.listeners.delete(e);
+				u.clear(), yield* w.forEach([...l], d, { discard: !0 }), s.consumers--, s.consumers === 0 && P.get(a) === s && P.delete(a);
+			}).pipe(w.uninterruptible)), p = (n) => t.startsWith("nats:") ? w.try({
+				try: () => ee(`${i.keyPrefix ?? ""}${n}`),
+				catch: () => new e({
+					operation: "subscribe",
+					key: "",
+					cause: "NATS channels must be exact nonempty subjects"
+				})
+			}) : w.void;
+			return {
+				publish: (n, i) => w.suspend(() => c || U.stopped ? w.fail(new e({
+					operation: "publish",
+					key: "",
+					cause: "Pub/Sub consumer is closed"
+				})) : p(n).pipe(w.andThen(w.tryPromise({
+					try: () => Ie(t, r, "publish", (e) => e.kind === "nats" ? e.transport.publish(`${e.config.keyPrefix ?? ""}${n}`, i) : e.kind === "redis" ? e.client.eval(ce, 0, n, i) : Promise.reject(/* @__PURE__ */ Error("Storage has no Pub/Sub"))),
+					catch: () => new e({
+						operation: "publish",
+						key: "",
+						cause: "Pub/Sub publication failed"
+					})
+				}))).pipe(w.asVoid)),
+				subscribe: (n, i) => p(n).pipe(w.andThen(w.uninterruptibleMask(() => w.acquireUseRelease(Z(t, r), () => D.modifyEffect(M, (t) => w.gen(function* () {
+					if (c || U.stopped) return yield* w.fail(new e({
+						operation: "subscribe",
+						key: "",
+						cause: "Pub/Sub consumer is closed"
+					}));
+					let r = t.get(a);
+					if (r === void 0) return yield* w.fail(new e({
+						operation: "subscribe",
+						key: "",
+						cause: "Connection generation is unavailable"
+					}));
+					let o = {
+						channel: n,
+						handler: (e) => {
+							c || i(e);
+						},
+						released: !1
+					}, u = s.channels.get(n) ?? /* @__PURE__ */ new Set(), f = u.size === 0;
+					u.add(o.handler), s.channels.set(n, u), r.binding = s, X(r);
+					let p = r.subscriber !== void 0;
+					return yield* w.gen(function* () {
+						if (yield* Ne(r, s), p && f && (yield* w.tryPromise({
+							try: () => r.subscriber.subscribe(n),
+							catch: () => new e({
+								operation: "subscribe",
+								key: "",
+								cause: "Redis subscription could not be registered"
+							})
+						})), c || U.stopped) return yield* w.fail(new e({
+							operation: "subscribe",
+							key: "",
+							cause: "Pub/Sub consumer is closed"
+						}));
+					}).pipe(w.onError(() => w.gen(function* () {
+						if (q(r), u.delete(o.handler), u.size === 0) {
+							s.channels.delete(n);
+							let e = r.subscriber;
+							e !== void 0 && !r.closed && (yield* w.promise(() => e.unsubscribe(n).catch(() => {
+								q(r);
+							})));
+						}
+					}))), l.add(o), [yield* w.cached(d(o)), t];
+				})), K)).pipe(ke, w.mapError(() => new e({
+					operation: "subscribe",
+					key: "",
+					cause: "Pub/Sub subscription could not be registered"
+				}))))),
+				onTransportEvent: (e) => {
+					if (c || U.stopped) throw Error("Pub/Sub consumer is closed");
+					let t = (t) => {
+						c || e(t);
+					};
+					return s.listeners.add(t), u.add(t), () => {
+						s.listeners.delete(t), u.delete(t);
+					};
+				},
+				close: f
+			};
+		}),
+		probe: Le,
+		reload: w.uninterruptibleMask((t) => w.gen(function* () {
+			if (U.stopped) return yield* w.fail(new e({
+				operation: "reload",
+				key: "",
+				cause: "Connection registry is closed"
+			}));
+			let n = yield* b.currentTimeMillis, r = yield* b.currentTimeNanos, i = yield* t(D.updateEffect(M, (e) => w.uninterruptibleMask((t) => w.gen(function* () {
+				let n = /* @__PURE__ */ new Map(), r = yield* t(w.forEach([...e], ([e, t]) => Fe(t.reference, t.context, (t) => {
+					n.set(e, t);
+				}, t))).pipe(w.exit);
+				if (r._tag === "Failure") return yield* w.forEach([...n.values()], W, { discard: !0 }), yield* w.failCause(r.cause);
+				for (let e of n.values()) X(e);
+				return yield* w.forEach([...e.values()], Ae, { discard: !0 }), n;
+			})))).pipe(w.exit), a = yield* b.currentTimeNanos, o = Object.freeze({
+				sequence: ++ue,
+				startedAt: n,
+				durationMs: Number(a - r) / 1e6,
+				outcome: i._tag === "Success" ? "succeeded" : "failed"
+			});
+			if (yield* w.sync(() => {
+				O.rotated(o.outcome, o.durationMs);
+				try {
+					v.onRotation?.(o);
+				} catch {}
+			}), i._tag === "Failure") return yield* w.failCause(i.cause);
+		})),
+		inspect: D.get(M).pipe(w.flatMap((e) => w.forEach([...e.values()], (e) => w.gen(function* () {
+			let t = e.config;
+			return {
+				reference: e.reference,
+				dynamic: e.dynamic,
+				activeCommands: e.active,
+				activeSubscriptions: [...e.binding?.channels.values() ?? []].reduce((e, t) => e + t.size, 0),
+				subscribedChannels: e.binding?.channels.size ?? 0,
+				commands: e.commands,
+				errors: e.errors,
+				latencyMs: e.latencyMs,
+				state: yield* e.breaker.state,
+				source: t.source ?? (C.redis && Object.keys(C.redis).length > 0 ? "config" : "environment"),
+				...t.label === void 0 ? {} : { label: t.label },
+				...t.region === void 0 ? {} : { region: t.region },
+				..."persistence" in t && t.persistence !== void 0 ? { persistence: t.persistence } : {}
+			};
+		})))),
+		redis: {
+			client: (e) => Re(e),
+			config: (e) => H(e)
+		}
+	};
+}), A = (e = {}) => T.effectContext(w.gen(function* () {
+	let t = yield* S.ConfigProvider, n = v(yield* k(e), t);
+	return C.make(O, n).pipe(C.add(ue, n.redis));
+}));
+//#endregion
+export { O as ConnectionRegistry, A as layerConfiguredConnections, k as makeConnectionRegistry };