@voltro/plugin-broadcast 0.86.0 → 0.88.0

package/dist/bus.js

@@ -1,7 +1,7 @@
 import { BROADCAST_CHANNEL as e } from "./types.js";
 import { createPublishQueue as t } from "./publishQueue.js";
 import { Effect as n, Metric as r } from "effect";
-//#region src/bus.ts
+// src/bus.ts
 var i = ({ origin: e, ...t }) => t, a = (e) => Math.min(500 * 2 ** Math.min(Math.max(e, 1) - 1, 5), 1e4), o = {
 	info: () => {},
 	warn: () => {},
@@ -177,5 +177,4 @@ var i = ({ origin: e, ...t }) => t, a = (e) => Math.min(500 * 2 ** Math.min(Math
 		})(), N)
 	};
 };
-//#endregion
 export { s as attachBroadcastBus, a as subscribeRetryDelayMs, i as withoutWireOrigin };

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 import { ChangeEvent } from '@voltro/database';
+import { ConnectionPubSub } from '@voltro/kv/connection';
+import { ConnectionRef } from '@voltro/kv/connection';
 import { Effect } from 'effect';
 import { Schema } from 'effect';
 import { VoltroPlugin } from '@voltro/protocol';
@@ -72,6 +74,12 @@ export declare interface BroadcastBusLogger {
  *  `voltro start` WEB process rather than an api replica. */
 export declare type BroadcastChannelKind = 'changes' | 'events' | 'members' | 'presence' | 'revalidate';
 
+export declare interface BroadcastConnectionSelection {
+    readonly role: string;
+    readonly kind: 'redis' | 'nats';
+    readonly reference?: BrokerReference;
+}
+
 /**
  * What rides the wire on the `voltro:changes` channel. `origin` is the
  * publishing replica's id; subscribers skip their OWN origin (the writer
@@ -193,7 +201,6 @@ export declare interface BroadcastHealth {
 export declare interface BroadcastPlugin extends VoltroPlugin {
     readonly broadcast: {
         readonly provider: BroadcastProvider;
-        readonly url: string | null;
         readonly crossReplica: boolean;
         /**
          * The namespace as DECLARED here, before the app name or env is consulted.
@@ -208,18 +215,14 @@ export declare const broadcastPlugin: (options?: BroadcastPluginOptions) => Broa
 
 export declare interface BroadcastPluginOptions {
     /** Provider name (`'redis' | 'nats' | 'memory'`) or a pre-built
-     *  `BroadcastProvider`. Default: inferred from `BROADCAST_URL` /
-     *  `BROADCAST_PROVIDER` / `REDIS_URL` env, else `'memory'`. */
+     *  `BroadcastProvider`. Default: reference kind, provider Env or registry endpoint Env, else memory. */
     readonly provider?: BroadcastProviderName | BroadcastProvider;
-    /** Broker URL — a broker-agnostic override (redis:// or nats://). Takes
-     *  precedence over the named-connection env. Default `BROADCAST_URL` env. */
-    readonly url?: string;
-    /** Named connection for the redis provider — resolves the broker URL via the
-     *  shared convention `<NAME>_REDIS_URL` → `REDIS_URL` (like cache / kv /
-     *  ratelimit). Default `'broadcast'` (→ `BROADCAST_REDIS_URL`, then
-     *  `REDIS_URL`). Point broadcast at its own server or the shared one purely
-     *  by which env var you set. */
-    readonly connection?: string;
+    /** Default broker reference. Endpoints and credentials belong in app connections. */
+    readonly connection?: ConnectionRef<'redis' | 'nats'>;
+    readonly events?: ConnectionRef<'redis' | 'nats'>;
+    readonly members?: ConnectionRef<'redis' | 'nats'>;
+    readonly presence?: ConnectionRef<'redis' | 'nats'>;
+    readonly revalidate?: ConnectionRef<'redis' | 'nats'>;
     /**
      * Namespace for EVERY framework channel on this broker — changes, events,
      * membership and presence alike.
@@ -299,6 +302,8 @@ export declare interface BroadcastTransportEvent {
     readonly detail?: string;
 }
 
+declare type BrokerReference = ConnectionRef<'redis' | 'nats'>;
+
 /**
  * One framework channel inside a namespace.
  *
@@ -362,63 +367,17 @@ export declare const getBroadcastPlugin: (plugins: ReadonlyArray<VoltroPlugin>)
  */
 export declare const memoryProvider: (bus?: string) => BroadcastProvider;
 
-declare interface NatsLike {
-    publish: (subject: string, data: Uint8Array) => void;
-    subscribe: (subject: string) => NatsSubscription;
-    drain: () => Promise<void>;
-    /** nats.js' connection events. Read for two reasons: to report a reconnect as
-     *  the hole it is, and to notice a connection that gave up. */
-    status: () => AsyncIterable<{
-        type: string;
-        data?: unknown;
-    }>;
-}
-
 export declare const natsProvider: (options: NatsProviderOptions) => BroadcastProvider;
 
-export declare interface NatsProviderOptions {
-    /** `nats://host:port` (comma-separated for a cluster). Required. */
-    readonly url: string;
-    /** Bring your own connected NATS connection (e.g. for shared creds). */
-    readonly connection?: NatsLike;
-}
-
-declare interface NatsSubscription extends AsyncIterable<{
-    data: Uint8Array;
-}> {
-    unsubscribe: () => void;
-}
-
-/** The slice of ioredis the provider touches — keeps the optional dep out
- *  of the type surface. */
-declare interface RedisLike {
-    publish: (channel: string, message: string) => Promise<number>;
-    subscribe: (channel: string) => Promise<unknown>;
-    unsubscribe: (channel: string) => Promise<unknown>;
-    on(event: 'message', listener: (channel: string, message: string) => void): void;
-    /** ioredis' connection lifecycle. The subscriber re-subscribes its channels
-     *  itself on `ready`; what it does NOT do is tell anyone that the messages
-     *  sent while it was away are gone. That is what these are read for. */
-    on(event: 'ready' | 'reconnecting' | 'end' | 'close', listener: () => void): void;
-    /** `error` is REQUIRED, not optional decoration: an `EventEmitter` with no
-     *  `error` listener turns the event into an uncaught exception. See the
-     *  registration below. */
-    on(event: 'error', listener: (err: unknown) => void): void;
-    off(event: 'message', listener: (channel: string, message: string) => void): void;
-    off(event: 'ready' | 'reconnecting' | 'end' | 'close', listener: () => void): void;
-    duplicate: () => RedisLike;
-    quit: () => Promise<unknown>;
+export declare interface NatsProviderOptions extends RedisProviderOptions {
 }
 
+/** Both adapters borrow the same consumer contract; neither owns a broker. */
 export declare const redisProvider: (options: RedisProviderOptions) => BroadcastProvider;
 
 export declare interface RedisProviderOptions {
-    /** `redis://[:pass@]host:port[/db]`. Required. */
-    readonly url: string;
-    /** Bring your own ioredis client (publisher). A `subscriber` is
-     *  `client.duplicate()`d internally — a RESP connection in subscribe
-     *  mode can't issue normal commands. */
-    readonly client?: RedisLike;
+    /** Acquire a consumer from the app's ConnectionRegistry, never a raw socket. */
+    readonly pubsub: Effect.Effect<ConnectionPubSub, unknown>;
 }
 
 /* Excluded from this release type: resetMemoryBus */
@@ -435,31 +394,18 @@ export declare interface ResolveBroadcastNamespaceInput {
 }
 
 export declare interface ResolveBroadcastOptions {
-    /** Explicit provider name or a pre-built `BroadcastProvider`. */
     readonly provider?: BroadcastProviderName | BroadcastProvider;
-    /** Broker URL — a broker-agnostic override (redis:// or nats://). Takes
-     *  precedence over the named-connection env. Default `BROADCAST_URL` env. */
-    readonly url?: string;
-    /** Named connection for the redis provider. The broker URL resolves via the
-     *  shared convention `<NAME>_REDIS_URL` → `REDIS_URL` (like cache / kv /
-     *  ratelimit), so a deployment points broadcast at the same server or its own
-     *  purely by env. Default `'broadcast'` (→ `BROADCAST_REDIS_URL`). */
-    readonly connection?: string;
+    readonly connection?: BrokerReference;
+    readonly events?: BrokerReference;
+    readonly members?: BrokerReference;
+    readonly presence?: BrokerReference;
+    readonly revalidate?: BrokerReference;
 }
 
-/**
- * Resolve the bus backend. Order: an object provider is used verbatim; a
- * named provider builds from `url`/env; absent → `BROADCAST_PROVIDER` env,
- * else inferred from a `redis://` / `nats://` URL, else `memory`.
- *
- * Returns the provider plus the URL it resolved (for the boot banner) and
- * whether the choice is a real cross-replica bus or the single-process
- * memory fallback.
- */
-export declare const resolveBroadcastProvider: (options: ResolveBroadcastOptions, env: NodeJS.ProcessEnv) => {
+export declare const resolveBroadcastProvider: (options: ResolveBroadcastOptions, environment: NodeJS.ProcessEnv, pubsub?: (role: string) => Effect.Effect<ConnectionPubSub, unknown>) => {
     provider: BroadcastProvider;
-    url: string | null;
     crossReplica: boolean;
+    selections: ReadonlyArray<BroadcastConnectionSelection>;
 };
 
 /** Retry cadence for a subscribe that could not land: 500ms doubling to a 10s

package/dist/namespace.js

@@ -1,4 +1,4 @@
-//#region src/namespace.ts
+// src/namespace.ts
 var e = "voltro", t = (e) => e.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, ""), n = (e) => {
 	let n = r(e), i = [e.option, e.env].find((e) => e !== void 0 && t(e).length > 0);
 	return {
@@ -18,5 +18,4 @@ var e = "voltro", t = (e) => e.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-"
 	}
 	return e;
 }, i = (e, t) => `${e}:${t}`, a = (e, n) => `${i(e, "events")}:${t(n)}`;
-//#endregion
 export { e as DEFAULT_BROADCAST_NAMESPACE, i as channelFor, n as describeNamespaceResolution, a as eventChannelFor, r as resolveBroadcastNamespace };

package/dist/plugin.js

@@ -1,67 +1,80 @@
 import { resolveBroadcastProvider as e } from "./resolve.js";
 import { Effect as t } from "effect";
 import { definePlugin as n } from "@voltro/protocol";
-//#region src/plugin.ts
+// src/plugin.ts
 var r = ["network:outbound:*"], i = [
 	{
-		name: "BROADCAST_URL",
+		name: "BROADCAST_NATS_URL",
 		required: !1,
 		secret: !0,
-		description: "Broker URL for the cross-replica bus, e.g. redis://host:6379 or nats://host:4222 (the scheme selects the provider). Absent → in-process memory fallback (single-process).",
-		example: "redis://localhost:6379"
+		description: "Named NATS registry endpoint for broadcast; falls back to NATS_URL.",
+		example: "nats://localhost:4222"
 	},
 	{
 		name: "BROADCAST_REDIS_URL",
 		required: !1,
 		secret: !0,
-		description: "Named-connection redis url for the bus (the shared <NAME>_REDIS_URL convention, like CACHE_REDIS_URL / KV_REDIS_URL). Used when the redis provider is selected and no broker-agnostic BROADCAST_URL is set; falls back to REDIS_URL. Set it to put broadcast on its own server.",
+		description: "Named-connection redis url for the bus (the shared <NAME>_REDIS_URL convention, like CACHE_REDIS_URL / KV_REDIS_URL). Used when the redis provider is selected and no explicit connection reference is set; falls back to REDIS_URL. Set it to put broadcast on its own server.",
 		example: "redis://localhost:6379"
 	},
 	{
 		name: "BROADCAST_PROVIDER",
 		required: !1,
 		secret: !1,
-		description: "Explicit provider: 'redis' | 'nats' | 'memory'. Overrides the scheme inferred from BROADCAST_URL. Default: inferred from the URL, else memory.",
+		description: "Explicit provider: 'redis' | 'nats' | 'memory'. The selected registry reference must match.",
 		example: "redis"
 	},
 	{
 		name: "REDIS_URL",
 		required: !1,
 		secret: !0,
-		description: "Fallback broker URL used when the resolved provider is redis and no BROADCAST_URL is set (also infers the redis provider when no provider/URL is given).",
+		description: "Fallback endpoint for registry-owned Redis broadcast (also infers the redis provider when no provider/URL is given).",
 		example: "redis://localhost:6379"
 	},
 	{
 		name: "NATS_URL",
 		required: !1,
 		secret: !0,
-		description: "Fallback broker URL used when the resolved provider is nats and no BROADCAST_URL is set (comma-separated for a cluster).",
+		description: "Fallback broker URL used when the resolved provider is nats and no BROADCAST_NATS_URL is set (comma-separated for a cluster).",
 		example: "nats://localhost:4222"
 	}
 ], a = (a = {}) => {
-	let o = e({
-		...a.provider === void 0 ? {} : { provider: a.provider },
-		...a.url === void 0 ? {} : { url: a.url },
-		...a.connection === void 0 ? {} : { connection: a.connection }
-	}, process.env);
+	let o, s = /* @__PURE__ */ new Map(), c = e(a, process.env, (e) => t.suspend(() => {
+		let n = s.get(e);
+		return o === void 0 || n === void 0 ? t.fail(/* @__PURE__ */ Error("Broadcast requires an activated app connection registry")) : o.pubsub(n);
+	})), l = Object.fromEntries(c.selections.flatMap((e) => e.reference === void 0 ? [] : [[e.role, e.reference]]));
 	return {
 		...n({
 			name: a.name ? `@voltro/plugin-broadcast#${a.name}` : "@voltro/plugin-broadcast",
 			description: "Cross-replica reactivity — fans out app-mutation ChangeEvents to every replica over a pub/sub bus (Redis / NATS). ADDITIVE to inline emit: local reactivity survives a broker outage. Closes the single-instance gap for every non-postgres dialect.",
 			permissions: r,
 			declaredEnv: i,
-			onActivate: (e) => t.sync(() => {
-				o.crossReplica ? e.logger.info("broadcast active", {
-					provider: o.provider.name,
-					url: o.url
-				}) : e.logger.warn("broadcast: resolved to the in-process memory provider — NO cross-replica fan-out. Set BROADCAST_URL (redis:// or nats://) for a real bus.");
+			...c.selections.length === 0 ? {} : {
+				needs: {
+					connections: c.selections.map(({ kind: e, role: t }) => ({
+						kind: e,
+						role: t
+					})),
+					pubsub: !0
+				},
+				connectionBindings: l
+			},
+			onActivate: (e) => t.gen(function* () {
+				o = e.connectionRegistry;
+				for (let t of c.selections) {
+					if (o === void 0) throw Error("Broadcast requires the app connection registry");
+					let n = e.connectionReference?.(t.role, t.kind) ?? t.reference ?? (t.kind === "nats" ? `nats:${t.role}` : process.env[`${t.role.toUpperCase()}_REDIS_URL`] ? `redis:${t.role}` : "");
+					s.set(t.role, n);
+					let r = yield* o.config(n);
+					if (t.kind === "redis" && (!("driver" in r) || r.driver !== "resp")) throw Error("Redis broadcast requires a RESP connection");
+				}
+				c.crossReplica ? e.logger.info("broadcast active", { provider: c.provider.name }) : e.logger.warn("broadcast: resolved to the in-process memory provider — NO cross-replica fan-out. Select a Redis or NATS connection for a cross-replica bus.");
 			}),
-			onDeactivate: () => t.void
+			onDeactivate: () => c.provider.close()
 		}),
 		broadcast: {
-			provider: o.provider,
-			url: o.url,
-			crossReplica: o.crossReplica,
+			provider: c.provider,
+			crossReplica: c.crossReplica,
 			namespace: a.namespace
 		}
 	};
@@ -69,5 +82,4 @@ var r = ["network:outbound:*"], i = [
 	for (let t of e) if (s(t)) return t;
 	return null;
 }, s = (e) => typeof e.broadcast == "object" && e.broadcast !== null && typeof e.broadcast.provider == "object";
-//#endregion
 export { a as broadcastPlugin, o as getBroadcastPlugin };

package/dist/providers.js

@@ -1,6 +1,6 @@
 import { BroadcastError as e } from "./types.js";
 import { Effect as t } from "effect";
-//#region src/providers.ts
+// src/providers.ts
 var n = (t, n, r) => new e({
 	provider: t,
 	message: n,
@@ -50,117 +50,45 @@ var n = (t, n, r) => new e({
 			for (let e of n) e();
 		})
 	};
-}, l = (e) => {
-	let a = null, o = i(), s = !0, c = () => a || (a = (async () => {
-		let t;
-		if (e.client) t = e.client;
-		else {
-			let n;
-			try {
-				n = (await import("ioredis")).default;
-			} catch (e) {
-				throw r("redis", "the 'redis' broadcast provider requires the 'ioredis' optional dependency. Install it to enable it.", e);
-			}
-			t = new n(e.url);
-		}
-		let n = t.duplicate();
-		return t.on("error", () => {}), n.on("error", () => {}), n.on("reconnecting", () => {
-			s && (s = !1, o.emit({
-				kind: "disconnected",
-				detail: "ioredis is re-dialling"
-			}));
-		}), n.on("ready", () => {
-			s || (s = !0, o.emit({ kind: "reconnected" }));
-		}), {
-			pub: t,
-			sub: n
-		};
-	})().catch((e) => {
-		throw a = null, e;
-	}), a);
-	return {
-		name: "redis",
-		onTransportEvent: o.subscribe,
-		publish: (e, r) => t.tryPromise({
-			try: async () => {
-				let { pub: t } = await c();
-				await t.publish(e, r);
-			},
-			catch: (e) => n("redis", `publish failed: ${String(e?.message ?? e)}`, e)
-		}),
-		subscribe: (e, r) => t.tryPromise({
-			try: async () => {
-				let { sub: t } = await c(), n = (t, n) => {
-					t === e && r(n);
-				};
-				return t.on("message", n), await t.subscribe(e), () => {
-					t.off("message", n), t.unsubscribe(e).catch(() => void 0);
-				};
-			},
-			catch: (e) => n("redis", `subscribe failed: ${String(e?.message ?? e)}`, e)
-		}),
-		close: () => t.promise(async () => {
-			if (a) try {
-				let { pub: t, sub: n } = await a;
-				await n.quit(), e.client || await t.quit();
-			} catch {}
-		})
+}, l = (e, a) => {
+	let o = i(), s = /* @__PURE__ */ new Set(), c, l, u = !1, d, f = (e) => (s.add(e), e.then(() => s.delete(e), () => s.delete(e)), e), p = (n) => {
+		if (u) return Promise.reject(r(e, "Broadcast consumer is closed"));
+		if (c !== void 0) return c;
+		let i = t.runPromiseWith(n)(a.pubsub).then((e) => (l = e.onTransportEvent(o.emit), e));
+		return c = i, i.catch(() => {
+			c === i && (c = void 0);
+		}), i;
 	};
-}, u = new TextEncoder(), d = new TextDecoder(), f = (e) => {
-	let a = null, o = i(), s = !0, c = (e) => {
-		(async () => {
-			try {
-				for await (let t of e.status()) t.type === "disconnect" && s ? (s = !1, o.emit({
-					kind: "disconnected",
-					detail: "nats disconnected"
-				})) : t.type === "reconnect" && !s && (s = !0, o.emit({ kind: "reconnected" }));
-			} catch {}
-		})();
-	}, l = () => import("@nats-io/transport-node").catch((e) => {
-		throw r("nats", "the 'nats' broadcast provider requires the '@nats-io/transport-node' optional dependency. Install it to enable it.", e);
-	}), f = () => a || (a = (async () => {
-		if (e.connection) return e.connection;
-		let t = await (await l()).connect({
-			servers: e.url,
-			maxReconnectAttempts: -1,
-			waitOnFirstConnect: !0,
-			reconnectTimeWait: 2e3
-		});
-		return c(t), t;
-	})().catch((e) => {
-		throw a = null, e;
-	}), a);
 	return {
-		name: "nats",
+		name: e,
 		onTransportEvent: o.subscribe,
-		publish: (e, r) => t.tryPromise({
-			try: async () => {
-				(await f()).publish(e, u.encode(r));
-			},
-			catch: (e) => n("nats", `publish failed: ${String(e?.message ?? e)}`, e)
-		}),
-		subscribe: (e, r) => t.tryPromise({
-			try: async () => {
-				let t = (await f()).subscribe(e), n = !1;
-				return (async () => {
-					for await (let e of t) r(d.decode(e.data));
-					!n && s && (s = !1, o.emit({
-						kind: "disconnected",
-						detail: `the nats subscription to '${e}' ended while the connection was up`
-					}));
-				})(), () => {
-					n = !0, t.unsubscribe();
+		publish: (i, a) => t.flatMap(t.context(), (o) => t.tryPromise({
+			try: () => f((async () => {
+				let n = await p(o);
+				if (u) throw r(e, "Broadcast consumer is closed");
+				await t.runPromiseWith(o)(n.publish(i, a));
+			})()),
+			catch: () => n(e, `${e} publication failed`)
+		})),
+		subscribe: (i, a) => t.flatMap(t.context(), (o) => t.tryPromise({
+			try: () => f((async () => {
+				let n = await p(o);
+				if (u) throw r(e, "Broadcast consumer is closed");
+				let s = !0, c = await t.runPromiseWith(o)(n.subscribe(i, (e) => {
+					s && !u && a(e);
+				}));
+				if (u) throw s = !1, await t.runPromiseWith(o)(c), r(e, "Broadcast consumer is closed");
+				return () => {
+					s && (s = !1, f(t.runPromiseWith(o)(c)).catch(() => void 0));
 				};
-			},
-			catch: (e) => n("nats", `subscribe failed: ${String(e?.message ?? e)}`, e)
-		}),
-		close: () => t.promise(async () => {
-			if (a) try {
-				let t = await a;
-				e.connection || await t.drain();
+			})()),
+			catch: () => n(e, `${e} subscription failed`)
+		})),
+		close: () => t.flatMap(t.context(), (e) => t.promise(() => d ??= (async () => {
+			if (u = !0, await Promise.allSettled([...s]), l?.(), c !== void 0) try {
+				await t.runPromiseWith(e)((await c).close);
 			} catch {}
-		})
+		})()))
 	};
-};
-//#endregion
-export { c as memoryProvider, f as natsProvider, l as redisProvider, s as resetMemoryBus };
+}, u = (e) => l("redis", e), d = (e) => l("nats", e);
+export { c as memoryProvider, d as natsProvider, u as redisProvider, s as resetMemoryBus };

package/dist/publishQueue.js

@@ -1,5 +1,5 @@
 import { Effect as e } from "effect";
-//#region src/publishQueue.ts
+// src/publishQueue.ts
 var t = (t, n, r, i, a = {}, o = () => {}) => {
 	let s = a.maxMessages ?? 1024, c = a.maxBytes ?? 8388608, l = a.timeoutMs ?? 5e3, u = a.shutdownTimeoutMs ?? 1e3;
 	for (let [e, t] of Object.entries({
@@ -60,5 +60,4 @@ var t = (t, n, r, i, a = {}, o = () => {}) => {
 		}
 	};
 };
-//#endregion
 export { t as createPublishQueue };

package/dist/resolve.js

@@ -1,53 +1,69 @@
 import { memoryProvider as e, natsProvider as t, redisProvider as n } from "./providers.js";
-//#region src/resolve.ts
-var r = (e, t) => t[`${e.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_REDIS_URL`], i = (i, a) => {
-	if (i.provider && typeof i.provider == "object") {
-		let e = i.provider;
-		return {
-			provider: e,
-			url: i.url ?? null,
-			crossReplica: e.name !== "memory"
-		};
+import { Effect as r } from "effect";
+// src/resolve.ts
+var i = (e) => {
+	if (!/^(redis|nats):[A-Za-z][A-Za-z0-9_-]*$/.test(e)) throw Error("Broadcast connections require redis:name or nats:name references");
+	return e.startsWith("nats:") ? "nats" : "redis";
+}, a = (a, o, s = () => r.fail(/* @__PURE__ */ Error("Broadcast requires the app connection registry"))) => {
+	let c = [], l = (e, i, a) => {
+		c.push({
+			kind: e,
+			role: i,
+			...a === void 0 ? {} : { reference: a }
+		});
+		let o = r.suspend(() => s(i));
+		return e === "nats" ? t({ pubsub: o }) : n({ pubsub: o });
+	}, u;
+	if (typeof a.provider == "object") {
+		if (a.connection !== void 0) throw Error("A custom Broadcast provider cannot also select a registry connection");
+		u = a.provider;
+	} else {
+		let t = a.provider ?? o.BROADCAST_PROVIDER;
+		if (t !== void 0 && ![
+			"redis",
+			"nats",
+			"memory"
+		].includes(t)) throw Error("Broadcast provider must be redis, nats or memory");
+		let n = a.connection === void 0 ? void 0 : i(a.connection), r = t ?? n ?? (o.BROADCAST_NATS_URL || o.NATS_URL ? "nats" : o.BROADCAST_REDIS_URL || o.REDIS_URL ? "redis" : "memory");
+		if (n !== void 0 && r !== n) throw Error("Broadcast provider must match its connection kind");
+		u = r === "memory" ? e() : l(r === "nats" ? "nats" : "redis", "broadcast", a.connection);
 	}
-	let o = i.url ?? a.BROADCAST_URL ?? null, s = r(i.connection ?? "broadcast", a), c = (i.provider ?? a.BROADCAST_PROVIDER)?.toLowerCase() ?? (o?.startsWith("nats://") ? "nats" : o?.startsWith("redis://") || o?.startsWith("rediss://") || s || a.REDIS_URL ? "redis" : void 0), l = (i.provider ?? a.BROADCAST_PROVIDER)?.toLowerCase();
-	if (l !== void 0 && l !== "redis" && l !== "nats" && l !== "memory") throw Error(`broadcastPlugin: unknown provider "${l}".\n  Valid: 'redis', 'nats', 'memory'.
-  A name we do not recognise used to fall through to the in-process bus, which boots fine on one replica and drops cross-replica traffic on the second.`);
-	if (o !== null && o !== "" && !/^(redis|rediss|nats):\/\//.test(o)) throw Error(`broadcastPlugin: url "${o}" names no provider we support.\n  Expected a redis://, rediss:// or nats:// url.`);
-	switch (c) {
-		case "redis": {
-			let t = o ?? s ?? a.REDIS_URL;
-			if (!t) {
-				if (l === "redis") throw Error("broadcastPlugin: provider \"redis\" was requested but no url resolves.\n  Set BROADCAST_URL, BROADCAST_REDIS_URL or REDIS_URL, or pass `url`.\n  Falling back to the in-process bus here would answer a stated requirement with a silent downgrade.");
-				return {
-					provider: e(),
-					url: null,
-					crossReplica: !1
-				};
-			}
-			return {
-				provider: n({ url: t }),
-				url: t,
-				crossReplica: !0
-			};
-		}
-		case "nats": {
-			let n = o ?? a.NATS_URL;
-			return n ? {
-				provider: t({ url: n }),
-				url: n,
-				crossReplica: !0
-			} : {
-				provider: e(),
-				url: null,
-				crossReplica: !1
-			};
-		}
-		default: return {
-			provider: e(),
-			url: null,
-			crossReplica: !1
-		};
+	let d = /* @__PURE__ */ new Map();
+	for (let e of [
+		"events",
+		"members",
+		"presence",
+		"revalidate"
+	]) {
+		let t = a[e];
+		t !== void 0 && d.set(e, l(i(t), e, t));
 	}
+	if (d.size === 0) return {
+		provider: u,
+		crossReplica: u.name !== "memory",
+		selections: c
+	};
+	let f = [.../* @__PURE__ */ new Set([u, ...d.values()])], p = (e) => {
+		let t = e.slice(e.indexOf(":") + 1).split(":")[0];
+		return d.get(t) ?? u;
+	};
+	return {
+		provider: {
+			name: [...new Set(f.map((e) => e.name))].join("+"),
+			publish: (e, t) => p(e).publish(e, t),
+			subscribe: (e, t) => p(e).subscribe(e, t),
+			onTransportEvent: (e) => {
+				let t = /* @__PURE__ */ new WeakSet(), n = f.flatMap((n) => n.onTransportEvent === void 0 ? [] : [n.onTransportEvent((n) => {
+					t.has(n) || (t.add(n), e(n));
+				})]);
+				return () => {
+					for (let e of n) e();
+				};
+			},
+			close: () => r.forEach(f, (e) => e.close(), { discard: !0 }).pipe(r.asVoid)
+		},
+		crossReplica: f.some((e) => e.name !== "memory"),
+		selections: c
+	};
 };
-//#endregion
-export { i as resolveBroadcastProvider };
+export { a as resolveBroadcastProvider };

package/dist/types.js

@@ -1,11 +1,10 @@
 import { DEFAULT_BROADCAST_NAMESPACE as e, channelFor as t } from "./namespace.js";
 import { Schema as n } from "effect";
-//#region src/types.ts
+// src/types.ts
 var r = class extends n.TaggedError()("BroadcastError", {
 	provider: n.String,
 	message: n.String,
 	transient: n.Boolean,
 	cause: n.optional(n.Unknown)
 }) {}, i = t(e, "changes");
-//#endregion
 export { i as BROADCAST_CHANNEL, r as BroadcastError };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/plugin-broadcast",
-  "version": "0.86.0",
+  "version": "0.88.0",
   "description": "Cross-replica reactivity — a pub/sub message bus (Redis / NATS / memory) that fans out app-mutation ChangeEvents to every replica behind a load balancer. ADDITIVE to inline emit: local reactivity survives a broker outage; cross-replica degrades gracefully. Closes the single-instance gap for every non-postgres dialect (postgres keeps native LISTEN/NOTIFY).",
   "keywords": [
     "voltro",
@@ -33,15 +33,12 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/database": "0.86.0",
-    "@voltro/protocol": "0.86.0"
-  },
-  "optionalDependencies": {
-    "@nats-io/transport-node": "^3.4.0",
-    "ioredis": "^5.11.1"
+    "@voltro/database": "0.88.0",
+    "@voltro/protocol": "0.88.0",
+    "@voltro/kv": "0.88.0"
   },
   "peerDependencies": {
-    "effect": "4.0.1"
+    "effect": "4.1.0"
   },
   "publishConfig": {
     "access": "public"