@shadow-js/realtime 1.0.1 → 1.0.3

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 1.0.3
+
+### Fixed
+
+- Idempotency keys belong to their publisher: the hub stores `key/u:<user>` (a signed-in user), `key/a` (anonymous connections) or `key/s` (`hub.publish`), so another user or the server reusing a key is never a duplicate.
+- `maxPresenceMembers` holds under concurrent joins: joins to one channel are applied one at a time per hub.
+- A `revoke` issued while a subscribe is awaiting its async rule refuses that subscribe (and counts it).
+- After `subbed gap:true` the client resumes from the gap's head, so a gap with nothing left to replay is reported once, not on every reconnect.
+
+## 1.0.2
+
+### Fixed
+
+- Client: adding the same handler to a channel twice no longer leaves a subscription hold that nothing can release.
+- Client: a POST that never answers (server-sent events transport) is abandoned after the acknowledgment timeout, so the publishes queued behind it are sent.
+- Server: a stream declaration that names its own `t` or `n` is always read as a subscription, never as a publish or request.
+- Server: a WebSocket that closes while `authenticate` is still running no longer leaves a connection in the hub.
+- Server: presence changes posted over HTTP spend from the same rate limit as publishes, and a POST body is read only up to the size limit.
+- Server: a member whose presence entry expired is written back with its last state instead of `null`; a transport whose `send` throws is closed.
+- Memory adapter: idempotency keys are capped per channel (65,536), and expired ones are swept when the map doubles.
+- Redis adapter: a channel whose keys were lost and whose numbering restarted still delivers its messages (the hub tells subscribers `reset`).
+- Client: the event stream parser holds at most 1 MiB for an unfinished line and event; a longer one closes the stream and reconnects. A tab that becomes visible while the client waits out a reconnect backoff reconnects at once.
+- Server: `sub` and `unsub` frames spend from a per-connection bucket (the publish rate, a burst that covers all of `maxChannelsPerConnection`), so subscription churn is limited like publishing.
+- Server: a frame over `maxMessageBytes` is refused when it arrives instead of after the frames queued before it; it counts as an invalid frame.
+- Server: a presence state posted over HTTP also updates the connection's own copy (on this server directly, on another through the presence event), so a write-back after an expiry carries the newest version and state.
+- Cloudflare adapter: a listener whose queue overflows is reported (`onError`), and a presence listener is resynced to the real member set (leaves, joins, changes) instead of staying wrong.
+- Errors while dropping a connection and listener failures in the memory adapter go to `onError` (memory adapter: new `onError` option, default `console.error`) instead of being swallowed.
+- The realtime client takes `reconnect.maxReconnectAttempts` (default unlimited). After that many failed reconnects in a row (the count restarts when a connection stays open `stableMs`) the client is `closed`, pending calls reject, and `onError` receives a `closed` error.
+
 ## 1.0.1
 
 ### Changed

package/README.md

@@ -104,6 +104,41 @@ Root, `@shadow-js/realtime`: the wire protocol and shared types.
 `@shadow-js/realtime/cloudflare`: `cloudflareAdapter`, `RealtimeChannelObject`.
 `@shadow-js/realtime/testing`: `connectTest`, `adapterConformance`.
 
+## Production error codes
+
+A production build keeps a short code instead of the development explanation, so message text never reaches user bundles. Search this table for the code. In the explanation, `…` stands for a value the development message names. A code followed by a word names the option, feature or member at fault.
+
+| Code | Development explanation |
+| --- | --- |
+| `REALTIME_CLOSED` | the adapter is closed. |
+| `REALTIME_DATA` | the data is not JSON |
+| `REALTIME_FRAME_1` | after must be a non-negative integer |
+| `REALTIME_FRAME_10` | the frame is not an object |
+| `REALTIME_FRAME_11` | the frame is larger than the limit |
+| `REALTIME_FRAME_12` | unknown frame type |
+| `REALTIME_FRAME_13` | v must be a version |
+| `REALTIME_FRAME_14` | watch must be a boolean |
+| `REALTIME_FRAME_2` | c is not a valid channel name |
+| `REALTIME_FRAME_3` | echo must be a boolean |
+| `REALTIME_FRAME_4` | e is not a valid event name |
+| `REALTIME_FRAME_5` | the frame is not JSON |
+| `REALTIME_FRAME_6` | k is not a valid key |
+| `REALTIME_FRAME_7` | ms must be a positive number |
+| `REALTIME_FRAME_8` | n must be a non-negative integer |
+| `REALTIME_FRAME_9` | sub needs n / req needs n |
+| `REALTIME_LIMIT_1` | limits.history must be at most …. |
+| `REALTIME_LIMIT_2` | unknown limit "…". |
+| `REALTIME_LIMIT_3` | limits.presenceTtlMs must be larger than limits.presenceHeartbeatMs. |
+| `REALTIME_LIMIT_4` | limits.… must be … integer. |
+| `REALTIME_PATTERN_1` | the channel pattern "…" must be 1..128 characters. |
+| `REALTIME_PATTERN_2` | the channel pattern "…" repeats "…". |
+| `REALTIME_PATTERN_3` | the channel pattern "…": {...name} must be the last segment. |
+| `REALTIME_PATTERN_4` | the channel pattern "…" has an invalid segment "…". |
+| `REALTIME_REVOKE` | revoke needs a user, a connection or a channel. |
+| `REALTIME_RULE` | the rule for "…": history must be a non-negative integer. |
+
+A `RealtimeError` raised without a message uses its protocol code (`forbidden`, `too_large`, ...) as the message; those codes are listed in the protocol guide at https://realtime.shadowjs.net/guides/realtime-protocol/. The `REALTIME_FRAME_*` codes are the `why` of a refused client frame, sent with the `bad_frame` error.
+
 ## Learn more
 
 See the ShadowJS documentation at https://shadowjs.net, and the realtime guide at https://realtime.shadowjs.net.

package/dist/dev/client/core.js

@@ -1,5 +1,5 @@
 import { RealtimeError } from "../errors.js";
-import { byteLength, decodeServerFrame, isChannelName, isEventName, isIdempotencyKey } from "../protocol.js";
+import { byteLength, isChannelName, isEventName, isIdempotencyKey, serverFrameOf } from "../protocol.js";
 import { applyPresence } from "./presence.js";
 import { openStream } from "./sse.js";
 import { backoff, clientId, resolveUrl, sendUrl } from "./util.js";
@@ -57,7 +57,6 @@ function createRealtime(options) {
 	const ackTtl = options.ackTimeoutMs ?? 1e4;
 	const auto = (options.transport ?? "auto") === "auto";
 	const id = clientId();
-	const life = new AbortController();
 	const chans = /* @__PURE__ */ new Map();
 	const dirty = /* @__PURE__ */ new Set();
 	const queue = [];
@@ -79,13 +78,15 @@ function createRealtime(options) {
 	let counter = 0;
 	let keys = 0;
 	let orders = 0;
-	let received = false;
+	/** Heartbeat intervals since the last thing was received. */
 	let silent = 0;
 	let connectTimer;
 	let reconnectTimer;
 	let stableTimer;
 	let beatTimer;
 	let posting = false;
+	/** The POST in flight, which closing the client abandons. */
+	let batch;
 	let postTimer;
 	let postFails = 0;
 	let listening = false;
@@ -126,15 +127,13 @@ function createRealtime(options) {
 		if (settle !== void 0) settle(error, value);
 		else if (error !== void 0 && op.kind === "pub") report(error);
 	};
-	const fail = (op, error) => finish(op, error);
-	const succeed = (op, value) => finish(op, void 0, value);
 	const arm = (op, ms) => {
 		clearTimeout(op.timer);
 		op.timer = setTimeout(() => {
 			const at = queue.indexOf(op);
 			if (at >= 0) queue.splice(at, 1);
 			if (inflight.get(op.n) === op) inflight.delete(op.n);
-			fail(op, new RealtimeError("timeout"));
+			finish(op, new RealtimeError("timeout"));
 		}, ms);
 	};
 	const take = (n) => {
@@ -159,22 +158,24 @@ function createRealtime(options) {
 		chan,
 		event,
 		data,
-		key: extra.key,
-		ack: extra.ack ?? true,
-		ms: extra.ms ?? 0,
+		ack: true,
+		ms: 0,
 		order: ++orders,
 		n: 0,
-		timer: void 0,
-		settle: extra.settle
+		...extra
 	});
+	/** Whether the server answers an operation (a request, or a publish that asks for an acknowledgment). */
+	const answered = (op) => op.kind === "req" || op.kind === "pub" && op.ack;
+	/** How long an operation that went out waits for its answer: a request's own time and a second, or the acknowledgment time. */
+	const waitOf = (op) => op.kind === "req" ? op.ms + 1e3 : ackTtl;
 	/** The frame text of an operation, numbered for an answer. Undefined (and the operation failed) when it is too large. */
 	const encode = (op) => {
 		const c = JSON.stringify(op.chan.name);
-		const wantsAnswer = op.kind === "req" || op.kind === "pub" && op.ack;
+		const wantsAnswer = answered(op);
 		op.n = wantsAnswer ? ++counter : 0;
 		const text = op.kind === "pres" ? `{"t":"pres","c":${c},"s":${op.data}}` : op.kind === "req" ? `{"t":"req","n":${op.n},"c":${c},"e":"${op.event}","d":${op.data},"ms":${op.ms}}` : `{"t":"pub","c":${c},"e":"${op.event}","d":${op.data}${wantsAnswer ? `,"n":${op.n}` : ""},"k":${JSON.stringify(op.key)}}`;
 		if (byteLength(text) > maxBytes) {
-			fail(op, new RealtimeError("too_large"));
+			finish(op, new RealtimeError("too_large"));
 			return;
 		}
 		return text;
@@ -182,16 +183,16 @@ function createRealtime(options) {
 	/** Records that an operation went out: it now waits for an answer, or is done. */
 	const sent = (op) => {
 		if (op.kind === "pres") return;
-		if (op.kind === "req" || op.ack) {
+		if (answered(op)) {
 			inflight.set(op.n, op);
-			arm(op, op.kind === "req" ? op.ms + 1e3 : ackTtl);
+			arm(op, waitOf(op));
 		} else clearTimeout(op.timer);
 	};
 	/** Puts operations that went out on a connection that died back at the head of the queue, in their original order. */
 	const requeue = (ops) => {
 		ops.sort((a, b) => a.order - b.order);
 		const again = [];
-		for (const op of ops) if (op.kind === "req") fail(op, new RealtimeError("closed"));
+		for (const op of ops) if (op.kind === "req") finish(op, new RealtimeError("closed"));
 		else {
 			if (op.kind === "pub") arm(op, queueTtl);
 			again.push(op);
@@ -210,7 +211,7 @@ function createRealtime(options) {
 	const subscription = (chan, n) => {
 		const join = joins(chan);
 		const watch = watches(chan);
-		const after = chan.sy ? chan.last : chan.options.replay === true ? 0 : void 0;
+		const after = chan.sy ? Math.max(chan.last, chan.gh) : chan.options.replay === true ? 0 : void 0;
 		chan.w = {
 			n,
 			join,
@@ -220,13 +221,13 @@ function createRealtime(options) {
 			ready: !join
 		};
 		setChanStatus(chan, chan.sy ? "resuming" : "subscribing");
-		return { fields: {
+		return {
 			c: chan.name,
 			...after === void 0 ? {} : { after },
 			...chan.options.echo === false ? { echo: false } : {},
 			...join ? { presence: chan.state } : {},
 			...watch ? { watch: true } : {}
-		} };
+		};
 	};
 	const sendPresence = (chan) => {
 		const w = chan.w;
@@ -252,12 +253,15 @@ function createRealtime(options) {
 		setChanStatus(chan, chan.closed ? "closed" : "idle");
 	};
 	/** Brings the w in line with what a channel wants (WebSocket: subscribe, unsubscribe, presence). */
+	const unsub = (chan) => {
+		link?.send(`{"t":"unsub","c":${JSON.stringify(chan.name)}}`);
+	};
 	const syncChan = (chan) => {
 		const want = wants(chan);
 		const w = chan.w;
 		if (mode === "ws" && ready) {
 			if (w !== void 0 && (!want || w.join !== joins(chan) || w.watch !== watches(chan))) {
-				link?.send(`{"t":"unsub","c":${JSON.stringify(chan.name)}}`);
+				unsub(chan);
 				chan.w = void 0;
 			}
 			if (want && chan.w === void 0 && chan.retry === void 0) {
@@ -265,7 +269,7 @@ function createRealtime(options) {
 				link?.send(JSON.stringify({
 					t: "sub",
 					n,
-					...subscription(chan, n).fields
+					...subscription(chan, n)
 				}));
 			}
 		}
@@ -285,7 +289,7 @@ function createRealtime(options) {
 		if (chan.closed) return;
 		chan.closed = true;
 		if (chans.get(chan.name) === chan) chans.delete(chan.name);
-		if (chan.w !== void 0 && mode === "ws" && ready) link?.send(`{"t":"unsub","c":${JSON.stringify(chan.name)}}`);
+		if (chan.w !== void 0 && mode === "ws" && ready) unsub(chan);
 		goIdle(chan);
 		chan.ev.clear();
 		chan.any.clear();
@@ -311,20 +315,6 @@ function createRealtime(options) {
 		}, backoff(chan.fails, minDelay, maxDelay, random));
 		chan.fails += 1;
 	};
-	/** Declares the subscriptions of an SSE stream; returns the query entries. */
-	const declare = () => {
-		const entries = [];
-		for (const chan of [...chans.values()]) {
-			if (!wants(chan)) continue;
-			if (entries.length >= MAX_STREAM_CHANNELS) {
-				closeChan(chan, new RealtimeError("limit"));
-				continue;
-			}
-			entries.push(subscription(chan, entries.length + 1).fields);
-		}
-		streamSig = signature();
-		return entries;
-	};
 	/** What the open stream must be reopened for: the channels it carries and how they join. */
 	const signature = () => {
 		let sig = "";
@@ -338,11 +328,10 @@ function createRealtime(options) {
 		gen += 1;
 		const g = gen;
 		ready = false;
-		received = false;
 		silent = 0;
 		const ev = {
 			rx: () => {
-				if (g === gen) received = true;
+				if (g === gen) silent = 0;
 			},
 			frame: (frame) => {
 				if (g === gen) guard(() => onFrame(frame, false));
@@ -355,10 +344,21 @@ function createRealtime(options) {
 			if (!listening && typeof addEventListener === "function") {
 				listening = true;
 				addEventListener("online", onOnline);
+				if (typeof document !== "undefined") document.addEventListener("visibilitychange", onVisible);
 			}
 			if (mode === "sse") {
 				const url = resolveUrl(options.url, false);
-				url.searchParams.set("s", JSON.stringify(declare()));
+				const entries = [];
+				for (const chan of [...chans.values()]) {
+					if (!wants(chan)) continue;
+					if (entries.length >= MAX_STREAM_CHANNELS) {
+						closeChan(chan, new RealtimeError("limit"));
+						continue;
+					}
+					entries.push(subscription(chan, entries.length + 1));
+				}
+				streamSig = signature();
+				url.searchParams.set("s", JSON.stringify(entries));
 				link = openStream(url.toString(), doFetch, getHeaders, ev);
 			} else link = openSocket(resolveUrl(options.url, true).toString(), options.WebSocket ?? globalThis.WebSocket, ev);
 		} catch (error) {
@@ -373,6 +373,10 @@ function createRealtime(options) {
 	const onOnline = () => {
 		if (reconnectTimer !== void 0) connect();
 	};
+	/** A tab that was hidden keeps its timers throttled or frozen: when it shows again, a connection waiting out a backoff reconnects now. */
+	const onVisible = () => {
+		if (document.visibilityState === "visible" && reconnectTimer !== void 0) connect();
+	};
 	/** Releases the current transport and everything tied to it. */
 	const drop = () => {
 		gen += 1;
@@ -409,6 +413,10 @@ function createRealtime(options) {
 			shutdown(new RealtimeError("closed", why));
 			return;
 		}
+		if (attempt >= (reconnect.maxReconnectAttempts ?? Infinity)) {
+			shutdown(new RealtimeError("closed", `gave up after ${reconnect.maxReconnectAttempts} reconnect attempts`));
+			return;
+		}
 		let delay = backoff(attempt, minDelay, maxDelay, random);
 		attempt += 1;
 		if (wasReady) wsFails = 0;
@@ -424,49 +432,30 @@ function createRealtime(options) {
 	};
 	/** Heartbeat: every interval sends a ping; two intervals with nothing received declare the connection dead. */
 	const beat = () => {
-		if (received) {
-			received = false;
-			silent = 0;
-		} else {
-			silent += 1;
-			if (silent >= 2) {
-				linkClosed({});
-				return;
-			}
+		silent += 1;
+		if (silent > 2) {
+			linkClosed({});
+			return;
 		}
 		if (mode === "ws") link?.send("{\"t\":\"ping\"}");
 	};
-	const reopen = () => {
-		drop();
-		for (const chan of chans.values()) chan.w = void 0;
-		connect();
-	};
-	const onReady = (frame) => {
-		if (ready) return;
-		ready = true;
-		connId = frame.id;
-		maxBytes = frame.max;
-		wsFails = 0;
-		received = true;
-		silent = 0;
-		clearTimeout(connectTimer);
-		if (frame.hb > 0) beatTimer = setInterval(beat, frame.hb);
-		stableTimer = setTimeout(() => {
-			attempt = 0;
-		}, stableMs);
-		setStatus("open");
-		if (mode === "ws") for (const chan of chans.values()) dirty.add(chan);
-		flush();
-	};
-	const notifyPresence = (chan) => {
-		const members = [...chan.members.values()];
-		chan.list = members;
-		emit(chan.presence, members);
-	};
 	const onFrame = (frame, viaPost) => {
 		switch (frame.t) {
 			case "ready":
-				onReady(frame);
+				if (ready) return;
+				ready = true;
+				connId = frame.id;
+				maxBytes = frame.max;
+				wsFails = 0;
+				silent = 0;
+				clearTimeout(connectTimer);
+				if (frame.hb > 0) beatTimer = setInterval(beat, frame.hb);
+				stableTimer = setTimeout(() => {
+					attempt = 0;
+				}, stableMs);
+				setStatus("open");
+				if (mode === "ws") for (const chan of chans.values()) dirty.add(chan);
+				flush();
 				return;
 			case "bye":
 				byeCode = frame.code;
@@ -476,16 +465,14 @@ function createRealtime(options) {
 				const w = chan?.w;
 				if (chan === void 0 || w === void 0 || w.n !== frame.n) return;
 				if (frame.reset || w.after === void 0) chan.last = frame.head;
-				const info = {
-					after: w.after ?? 0,
-					head: frame.head
-				};
-				const gap = frame.reset ? true : frame.gap === true && w.after !== void 0 && !(w.after === 0 && !chan.sy);
+				const gap = frame.reset === true || frame.gap === true && w.after !== void 0 && !(w.after === 0 && !chan.sy);
 				chan.sy = true;
 				chan.fails = 0;
 				setChanStatus(chan, "live");
+				chan.gh = gap ? frame.head : 0;
 				if (gap) emit(chan.gl, {
-					...info,
+					after: w.after ?? 0,
+					head: frame.head,
 					reset: frame.reset === true
 				});
 				return;
@@ -519,7 +506,7 @@ function createRealtime(options) {
 			}
 			case "ack": {
 				const op = take(frame.n);
-				if (op !== void 0) succeed(op, {
+				if (op !== void 0) finish(op, void 0, {
 					seq: frame.s,
 					duplicate: frame.dup === true
 				});
@@ -527,7 +514,7 @@ function createRealtime(options) {
 			}
 			case "rep": {
 				const op = take(frame.n);
-				if (op !== void 0) succeed(op, frame.d);
+				if (op !== void 0) finish(op, void 0, frame.d);
 				return;
 			}
 			case "err": {
@@ -546,7 +533,7 @@ function createRealtime(options) {
 					}
 					const op = viaPost || mode === "ws" ? take(frame.n) : void 0;
 					if (op !== void 0) {
-						fail(op, error);
+						finish(op, error);
 						return;
 					}
 				}
@@ -556,7 +543,10 @@ function createRealtime(options) {
 			case "pres": {
 				const chan = chans.get(frame.c);
 				if (chan === void 0) return;
-				if (applyPresence(chan.members, frame.op, frame.m)) notifyPresence(chan);
+				if (applyPresence(chan.members, frame.op, frame.m)) {
+					chan.list = [...chan.members.values()];
+					emit(chan.presence, chan.list);
+				}
 				if (frame.op === "sync" && chan.w !== void 0) {
 					chan.w.ready = true;
 					if (chan.w.join && chan.w.ver !== chan.sv) sendPresence(chan);
@@ -603,6 +593,9 @@ function createRealtime(options) {
 	const postBatch = async (ops, body) => {
 		for (const op of ops) sent(op);
 		let again = false;
+		const mine = new AbortController();
+		batch = mine;
+		const patience = setTimeout(() => mine.abort(), Math.max(...ops.map(waitOf)));
 		try {
 			const headers = new Headers(await getHeaders());
 			headers.set("content-type", "application/json");
@@ -611,12 +604,12 @@ function createRealtime(options) {
 				method: "POST",
 				headers,
 				body,
-				signal: life.signal
+				signal: mine.signal
 			});
 			if (response.ok) {
 				const parsed = await response.json();
 				if (Array.isArray(parsed.frames)) for (const item of parsed.frames) {
-					const frame = decodeServerFrame(JSON.stringify(item));
+					const frame = serverFrameOf(item);
 					if (frame !== void 0) guard(() => onFrame(frame, true));
 				}
 				postFails = 0;
@@ -626,38 +619,42 @@ function createRealtime(options) {
 				const code = refusal?.error?.code ?? "unavailable";
 				for (const op of ops) {
 					if (inflight.get(op.n) === op) inflight.delete(op.n);
-					fail(op, new RealtimeError(code, refusal?.error?.message));
+					finish(op, new RealtimeError(code, refusal?.error?.message));
 				}
 			}
 		} catch {
-			if (life.signal.aborted) return;
+			if (finished) return;
 			again = true;
+		} finally {
+			clearTimeout(patience);
 		}
 		posting = false;
-		const unanswered = ops.filter((op) => (op.kind === "req" || op.kind === "pub" && op.ack) && inflight.get(op.n) === op);
+		const unanswered = ops.filter((op) => answered(op) && inflight.get(op.n) === op);
 		for (const op of unanswered) inflight.delete(op.n);
 		if (again) {
-			for (const op of unanswered) if (op.kind === "req") fail(op, new RealtimeError("unavailable"));
+			for (const op of unanswered) if (op.kind === "req") finish(op, new RealtimeError("unavailable"));
 			requeue(ops.filter((op) => op.kind === "pres" || op.kind === "pub" && (!op.ack || unanswered.includes(op))));
 			postFails += 1;
 			postTimer = setTimeout(() => {
 				postTimer = void 0;
 				flush();
 			}, backoff(postFails - 1, minDelay, maxDelay, random));
-		} else for (const op of unanswered) fail(op, new RealtimeError("unavailable"));
+		} else for (const op of unanswered) finish(op, new RealtimeError("unavailable"));
 		flush();
 	};
-	const needed = () => queue.length > 0 || [...chans.values()].some(wants);
 	const run = () => {
 		scheduled = false;
 		if (finished) return;
 		syncAll();
 		if (link === void 0) {
-			if (reconnectTimer === void 0 && needed()) connect();
+			if (reconnectTimer === void 0 && (queue.length > 0 || [...chans.values()].some(wants))) connect();
 			return;
 		}
-		if (mode === "sse" && (signature() !== streamSig || [...chans.values()].some((c) => wants(c) && c.w === void 0 && c.retry === void 0))) reopen();
-		else flush();
+		if (mode === "sse" && (signature() !== streamSig || [...chans.values()].some((c) => wants(c) && c.w === void 0 && c.retry === void 0))) {
+			drop();
+			for (const chan of chans.values()) chan.w = void 0;
+			connect();
+		} else flush();
 	};
 	function schedule() {
 		if (scheduled || finished) return;
@@ -672,14 +669,17 @@ function createRealtime(options) {
 		reconnectTimer = void 0;
 		postTimer = void 0;
 		drop();
-		life.abort();
-		if (listening && typeof removeEventListener === "function") removeEventListener("online", onOnline);
-		listening = false;
+		batch?.abort();
+		if (listening) {
+			if (typeof removeEventListener === "function") removeEventListener("online", onOnline);
+			if (typeof document !== "undefined") document.removeEventListener("visibilitychange", onVisible);
+			listening = false;
+		}
 		const closed = error ?? new RealtimeError("closed");
 		const pending = [...queue.splice(0), ...inflight.values()];
 		inflight.clear();
 		for (const op of pending) if (op.settle === void 0) clearTimeout(op.timer);
-		else fail(op, closed);
+		else finish(op, closed);
 		for (const chan of [...chans.values()]) closeChan(chan);
 		chans.clear();
 		dirty.clear();
@@ -697,31 +697,31 @@ function createRealtime(options) {
 			sl: /* @__PURE__ */ new Set(),
 			presence: /* @__PURE__ */ new Set(),
 			members: /* @__PURE__ */ new Map(),
-			list: void 0,
 			status: "idle",
 			refs: 0,
 			hd: 0,
 			last: 0,
+			gh: 0,
 			sy: false,
 			state: channelOptions.presence,
 			sv: 0,
-			w: void 0,
-			retry: void 0,
 			fails: 0,
-			closed: false,
-			hn: void 0
+			closed: false
 		};
 		chans.set(name, chan);
 		if (wants(chan)) touch(chan);
 		/** Registers a listener; unless `passive`, it keeps the channel subscribed until removed. */
 		const listen = (set, item, passive, after) => {
 			if (chan.closed) return () => void 0;
+			let owns = !set.has(item);
 			set.add(item);
-			if (!passive) {
+			if (!passive && owns) {
 				chan.refs += 1;
 				touch(chan);
 			}
 			return () => {
+				if (!owns) return;
+				owns = false;
 				if (!set.delete(item) || passive) return;
 				chan.refs -= 1;
 				after?.();