@voltro/plugin-broadcast 0.55.0 → 0.57.0

package/dist/index.d.ts

@@ -24,20 +24,22 @@ export declare interface AttachBroadcastBusOptions {
     /** Channel override (tests). Default `voltro:changes`. */
     readonly channel?: string;
     /**
-     * Called when this replica proves it missed changes from a peer.
+     * Called when this replica has a hole in what it received.
      *
-     * The count is EXACT — the difference between the serial in hand and the last
-     * one seen from that origin — not an estimate. There is nothing to replay
-     * (pub/sub keeps no log), so the caller's job is to make the loss irrelevant:
-     * a live query is idempotent, so re-running every one of them is always safe
-     * and always correct. `voltro dev` and `voltro serve` wire this to the
-     * dispatcher's refresh.
+     * Two causes, one shape (see `BroadcastGap`), because there is one recovery:
+     * re-run every live query. A live query is idempotent, so re-running all of
+     * them is always safe and always complete — which is the only recovery
+     * available, since pub/sub keeps no log and there is nothing to replay.
      *
-     * Absent ⇒ the gap is still DETECTED and logged; only the recovery is
+     *   - a peer's serial jumped: the count is EXACT, not an estimate.
+     *   - this replica was not subscribed for a while: no origin, no count, and
+     *     the same instruction.
+     *
+     * Absent ⇒ the hole is still DETECTED and logged; only the recovery is
      * missing. That is deliberate: a bus used without a dispatcher (a test, an
      * embedder) should still say what it lost.
      */
-    readonly onGap?: (origin: string, missed: number) => void;
+    readonly onGap?: (gap: BroadcastGap) => void;
 }
 
 /**
@@ -89,6 +91,28 @@ export declare interface BroadcastEnvelope {
      * than as a gap.
      */
     readonly n?: number;
+    /**
+     * Which PROCESS of that origin published this — a nonce minted once per bus
+     * attach, meaningless except for being different after a restart.
+     *
+     * `origin` is a replica's NAME, and a name can outlive the process wearing
+     * it: a StatefulSet pod keeps `POD_NAME` across a restart, and
+     * `VOLTRO_REPLICA_ID` is stable by definition. The serial, however, restarts
+     * at 1 — so a receiver holding a watermark of 500 sees the new process's
+     * 1, 2, 3… as "not newer than what I have", never advances, and reports no
+     * gap for the next 500 changes. Gap detection for that peer is simply off,
+     * silently, and precisely after the event that most deserves a refresh.
+     *
+     * The epoch turns that into a fact the receiver can read: a different epoch
+     * under a known origin means a NEW process, so reset the watermark. It is
+     * NOT reported as a gap — a restart is not evidence that this replica missed
+     * anything, and a gap is a claim about loss.
+     *
+     * Optional for the same reason `n` is: a message from an older replica
+     * mid-rolling-deploy carries none, and "cannot tell" must not read as
+     * "restarted".
+     */
+    readonly epoch?: string;
 }
 
 /**
@@ -115,6 +139,24 @@ declare const BroadcastError_base: Schema.TaggedErrorClass<BroadcastError, "Broa
     cause: Schema.optional<typeof Schema.Unknown>;
 }>;
 
+/**
+ * A proven — or presumed — hole in what this replica received.
+ *
+ * ONE shape for both causes, because the recovery is one thing: re-run every
+ * live query. Two callbacks would have been two things for `voltro dev` and
+ * `voltro serve` to each wire, and this repo has the history to say how that
+ * ends.
+ */
+export declare interface BroadcastGap {
+    /** What happened, for the refresh's log line. */
+    readonly reason: string;
+    /** The peer whose serial jumped — absent when the hole is this replica's own
+     *  (it was not subscribed). */
+    readonly origin?: string;
+    /** EXACT count of missed messages, when it is known. Never an estimate. */
+    readonly missed?: number;
+}
+
 /**
  * A broadcast plugin instance also exposes the resolved provider so the
  * CLI's serve pipeline can attach the bus to the live DataStore. The
@@ -189,6 +231,22 @@ export declare interface BroadcastProvider {
     readonly publish: (channel: string, payload: string) => Effect.Effect<void, BroadcastError>;
     readonly subscribe: (channel: string, handler: (payload: string) => void) => Effect.Effect<() => void, BroadcastError>;
     readonly close: () => Effect.Effect<void>;
+    /**
+     * Subscribe to the TRANSPORT's own connection lifecycle, when the backend
+     * has one to report.
+     *
+     * A broker outage is not visible in `publish`/`subscribe`: a driver that
+     * reconnects on its own hands back a working transport and says nothing, and
+     * every message published while it was down is gone. The bus's serial
+     * accounting catches that on the next message from a peer — but only if a
+     * peer publishes again. On a quiet table, "no peer published again" and "we
+     * are up to date" look identical, and one of them is stale forever.
+     *
+     * Optional: the memory provider has no connection to lose, and a provider a
+     * user brings themselves need not implement it. Absent means the bus falls
+     * back to serial-only detection, which is where it was before this existed.
+     */
+    readonly onTransportEvent?: (listener: (event: BroadcastTransportEvent) => void) => () => void;
 }
 
 /** Provider id understood by `resolveBroadcastProvider`. */
@@ -201,6 +259,12 @@ export declare interface BroadcastStore {
     injectExternalChange: (event: ChangeEvent) => void;
 }
 
+export declare interface BroadcastTransportEvent {
+    readonly kind: 'disconnected' | 'reconnected';
+    /** Driver detail for the log line — never parsed. */
+    readonly detail?: string;
+}
+
 /**
  * One framework channel inside a namespace.
  *
@@ -268,6 +332,12 @@ 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;
@@ -291,8 +361,17 @@ 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;
-    off: (event: 'message', listener: (channel: string, message: string) => void) => void;
+    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>;
 }
@@ -349,4 +428,10 @@ export declare const resolveBroadcastProvider: (options: ResolveBroadcastOptions
     crossReplica: boolean;
 };
 
+/** Retry cadence for a subscribe that could not land: 500ms doubling to a 10s
+ *  ceiling, forever. A bus that gives up subscribing is a replica that is
+ *  permanently deaf and says so once, which is the state this retry exists to
+ *  make impossible. */
+export declare const subscribeRetryDelayMs: (attempt: number) => number;
+
 export { }

package/dist/index.js

@@ -34,13 +34,25 @@ var r = "voltro", i = (e) => e.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-"
 	message: t,
 	transient: !1,
 	...n === void 0 ? {} : { cause: n }
-}), p = /* @__PURE__ */ new Map(), m = (e) => {
-	let t = p.get(e);
-	return t || (t = { handlers: /* @__PURE__ */ new Map() }, p.set(e, t)), t;
-}, h = (e) => {
-	p.get(e)?.handlers.clear();
-}, g = (t = `default-${Math.random().toString(36).slice(2)}`) => {
-	let n = m(t);
+}), p = () => {
+	let e = /* @__PURE__ */ new Set();
+	return {
+		subscribe: (t) => (e.add(t), () => {
+			e.delete(t);
+		}),
+		emit: (t) => {
+			for (let n of e) try {
+				n(t);
+			} catch {}
+		}
+	};
+}, m = /* @__PURE__ */ new Map(), h = (e) => {
+	let t = m.get(e);
+	return t || (t = { handlers: /* @__PURE__ */ new Map() }, m.set(e, t)), t;
+}, g = (e) => {
+	m.get(e)?.handlers.clear();
+}, _ = (t = `default-${Math.random().toString(36).slice(2)}`) => {
+	let n = h(t);
 	return {
 		name: "memory",
 		publish: (t, r) => e.sync(() => {
@@ -57,8 +69,8 @@ var r = "voltro", i = (e) => e.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-"
 		}),
 		close: () => e.void
 	};
-}, _ = (t) => {
-	let n = null, r = () => n || (n = (async () => {
+}, v = (t) => {
+	let n = null, r = p(), i = !0, a = () => n || (n = (async () => {
 		let e;
 		if (t.client) e = t.client;
 		else {
@@ -71,27 +83,37 @@ var r = "voltro", i = (e) => e.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-"
 			e = new n(t.url);
 		}
 		let n = e.duplicate();
-		return {
+		return e.on("error", () => {}), n.on("error", () => {}), n.on("reconnecting", () => {
+			i && (i = !1, r.emit({
+				kind: "disconnected",
+				detail: "ioredis is re-dialling"
+			}));
+		}), n.on("ready", () => {
+			i || (i = !0, r.emit({ kind: "reconnected" }));
+		}), {
 			pub: e,
 			sub: n
 		};
-	})(), n);
+	})().catch((e) => {
+		throw n = null, e;
+	}), n);
 	return {
 		name: "redis",
+		onTransportEvent: r.subscribe,
 		publish: (t, n) => e.tryPromise({
 			try: async () => {
-				let { pub: e } = await r();
+				let { pub: e } = await a();
 				await e.publish(t, n);
 			},
 			catch: (e) => d("redis", `publish failed: ${String(e?.message ?? e)}`, e)
 		}),
 		subscribe: (t, n) => e.tryPromise({
 			try: async () => {
-				let { sub: e } = await r(), i = (e, r) => {
+				let { sub: e } = await a(), r = (e, r) => {
 					e === t && n(r);
 				};
-				return e.on("message", i), await e.subscribe(t), () => {
-					e.off("message", i), e.unsubscribe(t);
+				return e.on("message", r), await e.subscribe(t), () => {
+					e.off("message", r), e.unsubscribe(t);
 				};
 			},
 			catch: (e) => d("redis", `subscribe failed: ${String(e?.message ?? e)}`, e)
@@ -103,25 +125,50 @@ var r = "voltro", i = (e) => e.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-"
 			} catch {}
 		})
 	};
-}, v = new TextEncoder(), y = new TextDecoder(), b = (t) => {
-	let n = null, r = () => import("@nats-io/transport-node").catch((e) => {
+}, y = new TextEncoder(), b = new TextDecoder(), x = (t) => {
+	let n = null, r = p(), i = !0, a = (e) => {
+		(async () => {
+			try {
+				for await (let t of e.status()) t.type === "disconnect" && i ? (i = !1, r.emit({
+					kind: "disconnected",
+					detail: "nats disconnected"
+				})) : t.type === "reconnect" && !i && (i = !0, r.emit({ kind: "reconnected" }));
+			} catch {}
+		})();
+	}, o = () => import("@nats-io/transport-node").catch((e) => {
 		throw f("nats", "the 'nats' broadcast provider requires the '@nats-io/transport-node' optional dependency. Install it to enable it.", e);
-	}), i = () => n || (n = (async () => t.connection ? t.connection : (await r()).connect({ servers: t.url }))(), n);
+	}), s = () => n || (n = (async () => {
+		if (t.connection) return t.connection;
+		let e = await (await o()).connect({
+			servers: t.url,
+			maxReconnectAttempts: -1,
+			waitOnFirstConnect: !0,
+			reconnectTimeWait: 2e3
+		});
+		return a(e), e;
+	})().catch((e) => {
+		throw n = null, e;
+	}), n);
 	return {
 		name: "nats",
+		onTransportEvent: r.subscribe,
 		publish: (t, n) => e.tryPromise({
 			try: async () => {
-				(await i()).publish(t, v.encode(n));
+				(await s()).publish(t, y.encode(n));
 			},
 			catch: (e) => d("nats", `publish failed: ${String(e?.message ?? e)}`, e)
 		}),
 		subscribe: (t, n) => e.tryPromise({
 			try: async () => {
-				let e = (await i()).subscribe(t);
+				let e = (await s()).subscribe(t), a = !1;
 				return (async () => {
-					for await (let t of e) n(y.decode(t.data));
+					for await (let t of e) n(b.decode(t.data));
+					!a && i && (i = !1, r.emit({
+						kind: "disconnected",
+						detail: `the nats subscription to '${t}' ended while the connection was up`
+					}));
 				})(), () => {
-					e.unsubscribe();
+					a = !0, e.unsubscribe();
 				};
 			},
 			catch: (e) => d("nats", `subscribe failed: ${String(e?.message ?? e)}`, e)
@@ -133,7 +180,7 @@ var r = "voltro", i = (e) => e.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-"
 			} catch {}
 		})
 	};
-}, x = (e, t) => t[`${e.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_REDIS_URL`], S = (e, t) => {
+}, S = (e, t) => t[`${e.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_REDIS_URL`], C = (e, t) => {
 	if (e.provider && typeof e.provider == "object") {
 		let t = e.provider;
 		return {
@@ -142,7 +189,7 @@ var r = "voltro", i = (e) => e.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-"
 			crossReplica: t.name !== "memory"
 		};
 	}
-	let n = e.url ?? t.BROADCAST_URL ?? null, r = x(e.connection ?? "broadcast", t), i = (e.provider ?? t.BROADCAST_PROVIDER)?.toLowerCase() ?? (n?.startsWith("nats://") ? "nats" : n?.startsWith("redis://") || n?.startsWith("rediss://") || r || t.REDIS_URL ? "redis" : void 0), a = (e.provider ?? t.BROADCAST_PROVIDER)?.toLowerCase();
+	let n = e.url ?? t.BROADCAST_URL ?? null, r = S(e.connection ?? "broadcast", t), i = (e.provider ?? t.BROADCAST_PROVIDER)?.toLowerCase() ?? (n?.startsWith("nats://") ? "nats" : n?.startsWith("redis://") || n?.startsWith("rediss://") || r || t.REDIS_URL ? "redis" : void 0), a = (e.provider ?? t.BROADCAST_PROVIDER)?.toLowerCase();
 	if (a !== void 0 && a !== "redis" && a !== "nats" && a !== "memory") throw Error(`broadcastPlugin: unknown provider "${a}".\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 (n !== null && n !== "" && !/^(redis|rediss|nats):\/\//.test(n)) throw Error(`broadcastPlugin: url "${n}" names no provider we support.\n  Expected a redis://, rediss:// or nats:// url.`);
@@ -152,13 +199,13 @@ var r = "voltro", i = (e) => e.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-"
 			if (!e) {
 				if (a === "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: g(),
+					provider: _(),
 					url: null,
 					crossReplica: !1
 				};
 			}
 			return {
-				provider: _({ url: e }),
+				provider: v({ url: e }),
 				url: e,
 				crossReplica: !0
 			};
@@ -166,22 +213,22 @@ var r = "voltro", i = (e) => e.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-"
 		case "nats": {
 			let e = n ?? t.NATS_URL;
 			return e ? {
-				provider: b({ url: e }),
+				provider: x({ url: e }),
 				url: e,
 				crossReplica: !0
 			} : {
-				provider: g(),
+				provider: _(),
 				url: null,
 				crossReplica: !1
 			};
 		}
 		default: return {
-			provider: g(),
+			provider: _(),
 			url: null,
 			crossReplica: !1
 		};
 	}
-}, C = ["network:outbound:*"], w = [
+}, w = ["network:outbound:*"], T = [
 	{
 		name: "BROADCAST_URL",
 		required: !1,
@@ -217,8 +264,8 @@ var r = "voltro", i = (e) => e.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-"
 		description: "Fallback broker URL used when the resolved provider is nats and no BROADCAST_URL is set (comma-separated for a cluster).",
 		example: "nats://localhost:4222"
 	}
-], T = (t = {}) => {
-	let r = S({
+], E = (t = {}) => {
+	let r = C({
 		...t.provider === void 0 ? {} : { provider: t.provider },
 		...t.url === void 0 ? {} : { url: t.url },
 		...t.connection === void 0 ? {} : { connection: t.connection }
@@ -227,8 +274,8 @@ var r = "voltro", i = (e) => e.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-"
 		...n({
 			name: t.name ? `@voltro/plugin-broadcast#${t.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: C,
-			declaredEnv: w,
+			permissions: w,
+			declaredEnv: T,
 			onActivate: (t) => e.sync(() => {
 				r.crossReplica ? t.logger.info("broadcast active", {
 					provider: r.provider.name,
@@ -244,57 +291,101 @@ var r = "voltro", i = (e) => e.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-"
 			namespace: t.namespace
 		}
 	};
-}, E = (e) => {
-	for (let t of e) if (D(t)) return t;
+}, D = (e) => {
+	for (let t of e) if (O(t)) return t;
 	return null;
-}, D = (e) => typeof e.broadcast == "object" && e.broadcast !== null && typeof e.broadcast.provider == "object", O = ({ origin: e, ...t }) => t, k = {
+}, O = (e) => typeof e.broadcast == "object" && e.broadcast !== null && typeof e.broadcast.provider == "object", k = ({ origin: e, ...t }) => t, A = (e) => Math.min(500 * 2 ** Math.min(Math.max(e, 1) - 1, 5), 1e4), j = {
 	info: () => {},
 	warn: () => {},
 	debug: () => {}
-}, A = async (t) => {
-	let { store: n, provider: r, replicaId: i } = t, a = t.logger ?? k, o = t.channel ?? u, s = !1, c, l = !1, d = 0, f = /* @__PURE__ */ new Map(), p = await e.runPromise(r.subscribe(o, (e) => {
-		let r;
+}, M = async (t) => {
+	let { store: n, provider: r, replicaId: i } = t, a = t.logger ?? j, o = t.channel ?? u, s = !1, c, l = !1, d = 0, f = /* @__PURE__ */ new Map(), p = `${Date.now().toString(36)}.${Math.random().toString(36).slice(2, 10)}`, m = (e) => {
+		a.warn(`broadcast: ${e.reason} — refreshing live queries, which is safe because a query is idempotent`, {
+			...e.origin === void 0 ? {} : { origin: e.origin },
+			...e.missed === void 0 ? {} : { missed: e.missed }
+		});
+		try {
+			t.onGap?.(e);
+		} catch (e) {
+			a.warn("broadcast: gap recovery threw", { err: e });
+		}
+	}, h = (e) => {
+		let t;
 		try {
-			r = JSON.parse(e);
+			t = JSON.parse(e);
 		} catch {
 			a.warn("broadcast: bad payload (not JSON)", { channel: o });
 			return;
 		}
-		if (r.origin === i || !r.event || typeof r.event != "object") return;
-		if (typeof r.n == "number" && Number.isFinite(r.n)) {
-			let e = f.get(r.origin);
-			if (e !== void 0 && r.n > e + 1) {
-				let n = r.n - e - 1;
-				a.warn("broadcast: missed changes from a peer — refreshing live queries, which is safe because a query is idempotent", {
-					origin: r.origin,
-					missed: n,
-					from: e,
-					to: r.n
-				});
-				try {
-					t.onGap?.(r.origin, n);
-				} catch (e) {
-					a.warn("broadcast: gap recovery threw", { err: e });
-				}
-			}
-			(e === void 0 || r.n > e) && f.set(r.origin, r.n);
+		if (t.origin === i || !t.event || typeof t.event != "object") return;
+		if (typeof t.n == "number" && Number.isFinite(t.n)) {
+			let e = t.epoch ?? "", n = f.get(t.origin);
+			n === void 0 ? f.set(t.origin, {
+				epoch: e,
+				n: t.n
+			}) : n.epoch === e ? (t.n > n.n + 1 && m({
+				reason: `missed ${t.n - n.n - 1} change(s) from ${t.origin}`,
+				origin: t.origin,
+				missed: t.n - n.n - 1
+			}), t.n > n.n && f.set(t.origin, {
+				epoch: e,
+				n: t.n
+			})) : f.set(t.origin, {
+				epoch: e,
+				n: t.n
+			});
 		}
-		let l = O(r.event);
-		s = !0, c = l;
+		let r = k(t.event);
+		s = !0, c = r;
 		try {
-			n.injectExternalChange(l);
+			n.injectExternalChange(r);
 		} catch (e) {
 			a.warn("broadcast: inject failed", { err: e });
 		} finally {
 			s = !1, c = void 0;
 		}
-	})), m = n.onChange((t) => {
-		if (s && (t.origin === "injected" || t === c)) return;
+	}, g, _ = !1, v = 0, y = async () => {
+		try {
+			return g = await e.runPromise(r.subscribe(o, h)), !0;
+		} catch (e) {
+			return v += 1, v === 1 && a.warn("broadcast: could not subscribe — this replica will not receive other replicas' changes yet. Retrying in the background; local reactivity is unaffected.", {
+				provider: r.name,
+				channel: o,
+				err: e
+			}), !1;
+		}
+	};
+	await y() || (async () => {
+		let e = Date.now();
+		for (; !_ && g === void 0;) {
+			if (await new Promise((e) => setTimeout(e, A(v))), _) return;
+			if (await y()) {
+				a.info("broadcast: subscribed", {
+					provider: r.name,
+					channel: o,
+					attempts: v
+				}), m({ reason: `this replica was not subscribed to '${o}' for ${Math.round((Date.now() - e) / 1e3)}s` });
+				return;
+			}
+		}
+	})();
+	let b = r.onTransportEvent?.((e) => {
+		if (e.kind === "disconnected") {
+			a.warn("broadcast: transport disconnected — cross-replica fan-out is down until it re-dials", {
+				provider: r.name,
+				...e.detail === void 0 ? {} : { detail: e.detail }
+			});
+			return;
+		}
+		m({ reason: `the ${r.name} transport reconnected after an outage` });
+	}), x = n.onChange((t) => {
+		if (t.origin === "injected" || s && t === c) return;
 		d += 1;
 		let n = {
 			origin: i,
 			event: t,
-			n: d
+			n: d,
+			epoch: p
 		};
 		e.runPromise(r.publish(o, JSON.stringify(n)).pipe(e.tap(() => e.sync(() => {
 			l = !1;
@@ -306,21 +397,19 @@ var r = "voltro", i = (e) => e.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-"
 			}));
 		}))));
 	});
-	a.info("broadcast bus attached", {
+	return a.info("broadcast bus attached", {
 		provider: r.name,
 		channel: o,
 		replicaId: i
-	});
-	let h = !1;
-	return { close: async () => {
-		if (!h) {
-			h = !0, m();
+	}), { close: async () => {
+		if (!_) {
+			_ = !0, x(), b?.();
 			try {
-				p();
+				g?.();
 			} catch {}
 			await e.runPromise(r.close());
 		}
 	} };
 };
 //#endregion
-export { u as BROADCAST_CHANNEL, l as BroadcastError, r as DEFAULT_BROADCAST_NAMESPACE, A as attachBroadcastBus, T as broadcastPlugin, s as channelFor, a as describeNamespaceResolution, c as eventChannelFor, E as getBroadcastPlugin, g as memoryProvider, b as natsProvider, _ as redisProvider, h as resetMemoryBus, o as resolveBroadcastNamespace, S as resolveBroadcastProvider };
+export { u as BROADCAST_CHANNEL, l as BroadcastError, r as DEFAULT_BROADCAST_NAMESPACE, M as attachBroadcastBus, E as broadcastPlugin, s as channelFor, a as describeNamespaceResolution, c as eventChannelFor, D as getBroadcastPlugin, _ as memoryProvider, x as natsProvider, v as redisProvider, g as resetMemoryBus, o as resolveBroadcastNamespace, C as resolveBroadcastProvider, A as subscribeRetryDelayMs };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/plugin-broadcast",
-  "version": "0.55.0",
+  "version": "0.57.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,8 +33,8 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/database": "0.55.0",
-    "@voltro/protocol": "0.55.0"
+    "@voltro/database": "0.57.0",
+    "@voltro/protocol": "0.57.0"
   },
   "optionalDependencies": {
     "@nats-io/transport-node": "^3.4.0",