@shadow-js/realtime 1.0.2 → 1.0.4

package/dist/dev/server/hub.js

@@ -50,6 +50,10 @@ function createHubCore(options = {}) {
 	const rules = [];
 	const conns = /* @__PURE__ */ new Map();
 	const chans = /* @__PURE__ */ new Map();
+	/** Subscribes whose rules are being awaited: a revoke issued meanwhile takes them out, so the grant cannot outlive it. */
+	const judging = /* @__PURE__ */ new Set();
+	/** The tail of each channel's presence joins that are queued or running; an entry leaves when its chain is idle. */
+	const joinChains = /* @__PURE__ */ new Map();
 	let heartbeat;
 	let closing = false;
 	let beating = false;
@@ -90,7 +94,7 @@ function createHubCore(options = {}) {
 				where: `rule.${op}`,
 				channel
 			});
-			throw new RealtimeError("unavailable", "the channel rule could not be evaluated");
+			throw new RealtimeError("unavailable", ...["the channel rule could not be evaluated"]);
 		}
 	}
 	function send(conn, text) {
@@ -152,11 +156,7 @@ function createHubCore(options = {}) {
 			chan = {
 				name,
 				subs: /* @__PURE__ */ new Set(),
-				bucket: new TokenBucket(limits.channelPublishesPerSecond, limits.channelPublishesPerSecond, now()),
-				adapterSub: void 0,
-				presenceSub: void 0,
-				closing: false,
-				frame: void 0
+				bucket: new TokenBucket(limits.channelPublishesPerSecond, limits.channelPublishesPerSecond, now())
 			};
 			chans.set(name, chan);
 		}
@@ -181,32 +181,31 @@ function createHubCore(options = {}) {
 				else sub.buffer.push(message);
 				continue;
 			}
-			if (message.seq === sub.lastSeq + 1) deliver(sub, message, false);
-			else if (message.seq > sub.lastSeq + 1) {
+			if (message.seq === sub.seq + 1) deliver(sub, message, false);
+			else if (message.seq > sub.seq + 1) {
 				sub.buffer.push(message);
 				pump(sub, void 0);
-			} else if (message.at > sub.lastAt) removeSub(sub, "reset");
+			} else if (message.at > sub.at) removeSub(sub, "reset");
 		}
 	}
 	function deliver(sub, message, replayed) {
-		sub.lastSeq = message.seq;
-		sub.lastAt = Math.max(sub.lastAt, message.at);
+		sub.seq = message.seq;
+		sub.at = Math.max(sub.at, message.at);
 		if (!sub.echo && message.publisher === sub.conn.id) return;
 		counters.delivered += 1;
 		if (replayed) {
 			send(sub.conn, messageFrame(sub.channel.name, message, true));
 			return;
 		}
-		const cached = sub.channel.frame;
-		const text = cached !== void 0 && cached.seq === message.seq ? cached.text : messageFrame(sub.channel.name, message, false);
-		if (cached === void 0 || cached.seq !== message.seq) sub.channel.frame = {
+		let cached = sub.channel.frame;
+		if (cached === void 0 || cached.seq !== message.seq) cached = sub.channel.frame = {
 			seq: message.seq,
-			text
+			text: messageFrame(sub.channel.name, message, false)
 		};
-		send(sub.conn, text);
+		send(sub.conn, cached.text);
 	}
 	/**
-	* Delivers, in order and without a gap, the messages after `sub.lastSeq` up to `upTo` and whatever is buffered. Fetches the
+	* Delivers, in order and without a gap, the messages after `sub.seq` up to `upTo` and whatever is buffered. Fetches the
 	* missing ones from history. When history no longer has them: a subscription that reported a gap skips ahead; any other one
 	* is removed with `unsubbed why:"gap"`.
 	*/
@@ -215,24 +214,24 @@ function createHubCore(options = {}) {
 		sub.pumping = true;
 		try {
 			while (sub.active) {
-				sub.buffer = sub.buffer.filter((message) => message.seq > sub.lastSeq);
+				sub.buffer = sub.buffer.filter((message) => message.seq > sub.seq);
 				const next = sub.buffer[0];
-				if (next !== void 0 && next.seq === sub.lastSeq + 1) {
+				if (next !== void 0 && next.seq === sub.seq + 1) {
 					deliver(sub, next, false);
 					sub.buffer.shift();
 					continue;
 				}
 				const target = next === void 0 ? upTo ?? 0 : next.seq - 1;
-				if (sub.lastSeq >= target) break;
-				const page = await adapter.history(sub.channel.name, sub.lastSeq, Math.min(REPLAY_PAGE, target - sub.lastSeq));
+				if (sub.seq >= target) break;
+				const page = await adapter.history(sub.channel.name, sub.seq, Math.min(REPLAY_PAGE, target - sub.seq));
 				if (!sub.active) return;
 				const first = page.messages[0];
-				if (first === void 0 || first.seq !== sub.lastSeq + 1) {
+				if (first === void 0 || first.seq !== sub.seq + 1) {
 					if (!sub.gapOk) {
 						removeSub(sub, "gap");
 						return;
 					}
-					sub.lastSeq = (first?.seq ?? target + 1) - 1;
+					sub.seq = (first?.seq ?? target + 1) - 1;
 					continue;
 				}
 				for (const message of page.messages) {
@@ -259,7 +258,7 @@ function createHubCore(options = {}) {
 				sub.state = event.member.s;
 			}
 			if (!sub.active || !sub.joined && !sub.watch) continue;
-			if (sub.presenceQueue !== void 0) sub.presenceQueue.push(event);
+			if (sub.queued !== void 0) sub.queued.push(event);
 			else sendPresence(sub, event);
 		}
 	}
@@ -310,7 +309,7 @@ function createHubCore(options = {}) {
 		if (chan.subs.size > 0 || chan.closing) return;
 		chan.closing = true;
 		if (chans.get(chan.name) === chan) chans.delete(chan.name);
-		const stops = [chan.adapterSub, chan.presenceSub].filter((item) => item !== void 0);
+		const stops = [chan.feed, chan.pfeed].filter((item) => item !== void 0);
 		await Promise.all(stops.map(async (stop) => {
 			try {
 				await (await stop)();
@@ -327,41 +326,46 @@ function createHubCore(options = {}) {
 	}
 	async function subscribe(conn, frame) {
 		const { c: name, n } = frame;
-		if (conn.subs.has(name)) return fail(conn, n, "conflict", name, "already subscribed");
-		if (conn.subs.size >= limits.maxChannelsPerConnection) return fail(conn, n, "limit", name, "too many channels on this connection");
+		if (conn.subs.has(name)) return fail(conn, n, "conflict", name, ...["already subscribed"]);
+		if (conn.subs.size >= limits.maxChannelsPerConnection) return fail(conn, n, "limit", name, ...["too many channels on this connection"]);
 		const found = match(name);
-		if (found === void 0 || !await allowed(found.rule, "subscribe", name, found.params, conn.identity)) return fail(conn, n, identityDenied(conn), name);
+		if (found === void 0) return fail(conn, n, identityDenied(conn), name);
 		const wantsPresence = frame.hasPresence || frame.watch === true;
-		if (wantsPresence && !await allowed(found.rule, "presence", name, found.params, conn.identity)) return fail(conn, n, identityDenied(conn), name);
-		if (frame.hasPresence && byteLength(JSON.stringify(frame.presence ?? null)) > limits.maxStateBytes) return fail(conn, n, "too_large", name, "the presence state is too large");
+		const pending = {
+			conn,
+			channel: name
+		};
+		judging.add(pending);
+		try {
+			if (!await allowed(found.rule, "subscribe", name, found.params, conn.identity) || wantsPresence && !await allowed(found.rule, "presence", name, found.params, conn.identity) || !judging.has(pending)) return fail(conn, n, identityDenied(conn), name);
+		} finally {
+			judging.delete(pending);
+		}
+		if (frame.hasPresence && byteLength(JSON.stringify(frame.presence ?? null)) > limits.maxStateBytes) return fail(conn, n, "too_large", name, ...["the presence state is too large"]);
 		if (conn.closed) return;
 		const chan = channelState(name);
-		if (chan.subs.size >= limits.maxSubscribersPerChannel) return fail(conn, n, "limit", name, "the channel is full");
+		if (chan.subs.size >= limits.maxSubscribersPerChannel) return fail(conn, n, "limit", name, ...["the channel is full"]);
 		const sub = {
 			conn,
 			channel: chan,
-			rule: found.rule,
-			params: found.params,
+			...found,
 			echo: frame.echo !== false,
 			watch: frame.watch === true,
-			joined: false,
 			version: 0,
 			state: null,
-			lastSeq: 0,
-			lastAt: now(),
+			seq: 0,
+			at: now(),
 			pumping: true,
-			gapOk: false,
 			buffer: [],
-			presenceQueue: wantsPresence ? [] : void 0,
-			joining: void 0,
+			queued: wantsPresence ? [] : void 0,
 			active: true
 		};
 		conn.subs.set(name, sub);
 		chan.subs.add(sub);
 		try {
-			await ensureFeed(chan, "adapterSub", () => adapter.subscribe(chan.name, (message) => onMessage(chan, message)));
+			await ensureFeed(chan, "feed", () => adapter.subscribe(chan.name, (message) => onMessage(chan, message)));
 			if (wantsPresence) {
-				await ensureFeed(chan, "presenceSub", () => adapter.presenceSubscribe(chan.name, (event) => onPresence(chan, event)));
+				await ensureFeed(chan, "pfeed", () => adapter.presenceSubscribe(chan.name, (event) => onPresence(chan, event)));
 				startHeartbeat();
 			}
 			const probe = await adapter.history(name, Number.MAX_SAFE_INTEGER, 0);
@@ -370,12 +374,12 @@ function createHubCore(options = {}) {
 			const after = frame.after;
 			let gap = false;
 			let reset = false;
-			if (after === void 0) sub.lastSeq = head;
+			if (after === void 0) sub.seq = head;
 			else if (after > head) {
 				reset = true;
-				sub.lastSeq = head;
+				sub.seq = head;
 			} else {
-				sub.lastSeq = after;
+				sub.seq = after;
 				gap = probe.oldest === 0 ? head > after : probe.oldest > after + 1;
 				sub.gapOk = gap;
 			}
@@ -407,19 +411,34 @@ function createHubCore(options = {}) {
 			}
 		}
 	}
-	async function joinPresence(sub, state) {
-		if ((await adapter.presenceList(sub.channel.name)).length >= limits.maxPresenceMembers) throw new RealtimeError("limit", "the presence set is full");
-		sub.version = 1;
-		sub.state = state;
-		sub.joined = true;
-		startHeartbeat();
-		const member = {
+	/** Joins one at a time per channel: the capacity check reads the set, so two joins in flight would both see room. */
+	function joinPresence(sub, state) {
+		const name = sub.channel.name;
+		const run = (joinChains.get(name) ?? Promise.resolve()).then(async () => {
+			if (!sub.active) return;
+			if ((await adapter.presenceList(name)).length >= limits.maxPresenceMembers) throw new RealtimeError("limit", ...["the presence set is full"]);
+			sub.version = 1;
+			sub.state = state;
+			sub.joined = true;
+			startHeartbeat();
+			await adapter.presenceSet(name, memberOf(sub), limits.presenceTtlMs);
+		});
+		const settle = () => {
+			if (joinChains.get(name) === tail) joinChains.delete(name);
+		};
+		const tail = run.then(settle, settle);
+		joinChains.set(name, tail);
+		return run;
+	}
+	/** The presence member a joined subscription stands for. */
+	function memberOf(sub) {
+		const { user } = sub.conn.identity;
+		return {
 			id: sub.conn.id,
-			...sub.conn.identity.user === void 0 ? {} : { u: sub.conn.identity.user },
-			s: state,
-			v: 1
+			...user === void 0 ? {} : { u: user },
+			s: sub.state,
+			v: sub.version
 		};
-		await adapter.presenceSet(sub.channel.name, member, limits.presenceTtlMs);
 	}
 	async function syncPresence(sub) {
 		const members = await adapter.presenceList(sub.channel.name);
@@ -430,8 +449,8 @@ function createHubCore(options = {}) {
 			op: "sync",
 			m: members
 		});
-		const queued = sub.presenceQueue ?? [];
-		sub.presenceQueue = void 0;
+		const queued = sub.queued ?? [];
+		sub.queued = void 0;
 		const known = new Map(members.map((member) => [member.id, member.v]));
 		for (const event of queued) {
 			const version = known.get(event.member.id);
@@ -442,18 +461,12 @@ function createHubCore(options = {}) {
 	async function setPresence(conn, frame) {
 		const sub = conn.subs.get(frame.c);
 		if (sub === void 0 || !sub.joined) return fail(conn, void 0, "not_subscribed", frame.c);
-		if (byteLength(JSON.stringify(frame.s)) > limits.maxStateBytes) return fail(conn, void 0, "too_large", frame.c, "the presence state is too large");
+		if (byteLength(JSON.stringify(frame.s)) > limits.maxStateBytes) return fail(conn, void 0, "too_large", frame.c, ...["the presence state is too large"]);
 		if (!conn.publishBucket.take(now())) return limit(conn, void 0, frame.c);
 		sub.version += 1;
 		sub.state = frame.s;
-		const member = {
-			id: conn.id,
-			...conn.identity.user === void 0 ? {} : { u: conn.identity.user },
-			s: frame.s,
-			v: sub.version
-		};
 		try {
-			await adapter.presenceSet(frame.c, member, limits.presenceTtlMs);
+			await adapter.presenceSet(frame.c, memberOf(sub), limits.presenceTtlMs);
 		} catch (error) {
 			report(error, {
 				where: "presenceSet",
@@ -471,7 +484,7 @@ function createHubCore(options = {}) {
 		const { c: name, n } = frame;
 		const found = match(name);
 		if (found === void 0 || !await allowed(found.rule, "publish", name, found.params, conn.identity)) return fail(conn, n, identityDenied(conn), name);
-		if (frame.d.length > limits.maxMessageBytes) return fail(conn, n, "too_large", name, "the message is too large");
+		if (frame.d.length > limits.maxMessageBytes) return fail(conn, n, "too_large", name, ...["the message is too large"]);
 		if (!conn.publishBucket.take(now()) || chans.get(name)?.bucket.take(now()) === false) return limit(conn, n, name);
 		try {
 			const result = await adapter.publish(name, {
@@ -483,7 +496,7 @@ function createHubCore(options = {}) {
 				history: found.rule.history ?? limits.history,
 				historyTtlMs: limits.historyTtlMs,
 				idempotencyTtlMs: limits.idempotencyTtlMs,
-				...frame.k === void 0 ? {} : { key: frame.k }
+				...frame.k === void 0 ? {} : { key: `${frame.k}/${conn.identity.user === void 0 ? "a" : `u:${conn.identity.user}`}` }
 			});
 			counters.published += result.duplicate ? 0 : 1;
 			if (n !== void 0) sendFrame(conn, {
@@ -512,7 +525,7 @@ function createHubCore(options = {}) {
 		const sub = target;
 		const handler = sub.rule.handlers?.[frame.e];
 		if (handler === void 0) return fail(conn, n, "no_handler", name);
-		if (conn.pending.size >= limits.maxPendingRequests) return fail(conn, n, "limit", name, "too many requests in flight");
+		if (conn.pending.size >= limits.maxPendingRequests) return fail(conn, n, "limit", name, ...["too many requests in flight"]);
 		if (!conn.publishBucket.take(now())) return limit(conn, n, name);
 		const controller = new AbortController();
 		conn.pending.add(controller);
@@ -533,7 +546,7 @@ function createHubCore(options = {}) {
 				});
 				const reply = await Promise.race([run, aborted]) ?? null;
 				const text = JSON.stringify(reply);
-				if (text === void 0 || byteLength(text) > limits.maxMessageBytes) return fail(conn, n, "too_large", name, "the reply is too large");
+				if (text === void 0 || byteLength(text) > limits.maxMessageBytes) return fail(conn, n, "too_large", name, ...["the reply is too large"]);
 				send(conn, `{"t":"rep","n":${n},"d":${text}}`);
 			} catch (error) {
 				if (error instanceof RealtimeError) fail(conn, n, error.code, name, error.code === "timeout" || error.code === "closed" ? void 0 : error.message);
@@ -565,7 +578,7 @@ function createHubCore(options = {}) {
 		}
 		const frame = decoded.frame;
 		const n = "n" in frame ? frame.n : void 0;
-		if ((frame.t === "sub" || frame.t === "unsub") && !conn.controlBucket.take(now()) && frame.t === "sub") return limit(conn, n, frame.c);
+		if ((frame.t === "sub" || frame.t === "unsub") && !conn.ctl.take(now()) && frame.t === "sub") return limit(conn, n, frame.c);
 		try {
 			switch (frame.t) {
 				case "hello": return;
@@ -655,43 +668,35 @@ function createHubCore(options = {}) {
 		if (beating) return;
 		beating = true;
 		try {
-			await beatOnce();
+			const refs = [];
+			const watched = /* @__PURE__ */ new Set();
+			for (const conn of conns.values()) for (const sub of conn.subs.values()) {
+				if (sub.joined) refs.push({
+					channel: sub.channel.name,
+					id: conn.id
+				});
+				if (sub.joined || sub.watch) watched.add(sub.channel.name);
+			}
+			if (refs.length === 0 && watched.size === 0) {
+				clearInterval(heartbeat);
+				heartbeat = void 0;
+				return;
+			}
+			try {
+				const missing = await adapter.presenceTouch(refs, limits.presenceTtlMs);
+				for (const ref of missing) {
+					const sub = conns.get(ref.id)?.subs.get(ref.channel);
+					if (sub === void 0 || !sub.joined) continue;
+					await adapter.presenceSet(ref.channel, memberOf(sub), limits.presenceTtlMs);
+				}
+				for (const channel of watched) await adapter.presenceReap(channel);
+			} catch (error) {
+				report(error, { where: "presenceHeartbeat" });
+			}
 		} finally {
 			beating = false;
 		}
 	}
-	async function beatOnce() {
-		const refs = [];
-		const watched = /* @__PURE__ */ new Set();
-		for (const conn of conns.values()) for (const sub of conn.subs.values()) {
-			if (sub.joined) refs.push({
-				channel: sub.channel.name,
-				id: conn.id
-			});
-			if (sub.joined || sub.watch) watched.add(sub.channel.name);
-		}
-		if (refs.length === 0 && watched.size === 0) {
-			clearInterval(heartbeat);
-			heartbeat = void 0;
-			return;
-		}
-		try {
-			const missing = await adapter.presenceTouch(refs, limits.presenceTtlMs);
-			for (const ref of missing) {
-				const sub = conns.get(ref.id)?.subs.get(ref.channel);
-				if (sub === void 0 || !sub.joined) continue;
-				await adapter.presenceSet(ref.channel, {
-					id: ref.id,
-					...sub.conn.identity.user === void 0 ? {} : { u: sub.conn.identity.user },
-					s: sub.state,
-					v: sub.version
-				}, limits.presenceTtlMs);
-			}
-			for (const channel of watched) await adapter.presenceReap(channel);
-		} catch (error) {
-			report(error, { where: "presenceHeartbeat" });
-		}
-	}
 	for (const [pattern, rule] of Object.entries(options.channels ?? {})) rules.push(compileRule(pattern, rule));
 	const core = {
 		limits,
@@ -704,8 +709,8 @@ function createHubCore(options = {}) {
 			return core;
 		},
 		connect(transport, identity = {}, connectOptions = {}) {
-			if (closing) throw new RealtimeError("closed", "the hub is closed");
-			let release = () => void 0;
+			if (closing) throw new RealtimeError("closed", ...["the hub is closed"]);
+			let release;
 			const done = new Promise((resolve) => {
 				release = resolve;
 			});
@@ -718,14 +723,12 @@ function createHubCore(options = {}) {
 				subs: /* @__PURE__ */ new Map(),
 				queue: [],
 				publishBucket: connectOptions.publishBucket ?? new TokenBucket(limits.publishesPerSecond, limits.publishBurst, now()),
-				controlBucket: new TokenBucket(limits.publishesPerSecond, Math.max(limits.publishBurst, limits.maxChannelsPerConnection), now()),
+				ctl: new TokenBucket(limits.publishesPerSecond, Math.max(limits.publishBurst, limits.maxChannelsPerConnection), now()),
 				stateless: connectOptions.stateless === true,
 				waiters: [],
 				invalid: new WindowCounter(10, 6e4),
 				limited: new WindowCounter(50, 1e4),
 				pending: /* @__PURE__ */ new Set(),
-				running: false,
-				closed: false,
 				release,
 				done
 			};
@@ -766,9 +769,9 @@ function createHubCore(options = {}) {
 			};
 		},
 		async publish(channel, event, data, publishOptions = {}) {
-			if (!isChannelName(channel)) throw new RealtimeError("bad_channel", `"${channel}" is not a valid channel name`);
-			if (!isEventName(event)) throw new RealtimeError("bad_frame", `"${event}" is not a valid event name`);
-			if (publishOptions.key !== void 0 && !isIdempotencyKey(publishOptions.key)) throw new RealtimeError("bad_frame", "the idempotency key is not valid");
+			if (!isChannelName(channel)) throw new RealtimeError("bad_channel", ...[`"${channel}" is not a valid channel name`]);
+			if (!isEventName(event)) throw new RealtimeError("bad_frame", ...[`"${event}" is not a valid event name`]);
+			if (publishOptions.key !== void 0 && !isIdempotencyKey(publishOptions.key)) throw new RealtimeError("bad_frame", ...["the idempotency key is not valid"]);
 			let text;
 			try {
 				text = JSON.stringify(data === void 0 ? null : data);
@@ -776,7 +779,7 @@ function createHubCore(options = {}) {
 				throw new TypeError("the data is not JSON", { cause: error });
 			}
 			if (text === void 0) throw new TypeError("the data is not JSON");
-			if (byteLength(text) > limits.maxMessageBytes) throw new RealtimeError("too_large", "the message is too large");
+			if (byteLength(text) > limits.maxMessageBytes) throw new RealtimeError("too_large", ...["the message is too large"]);
 			const found = match(channel);
 			const result = await adapter.publish(channel, {
 				event,
@@ -785,18 +788,18 @@ function createHubCore(options = {}) {
 				history: found?.rule.history ?? limits.history,
 				historyTtlMs: limits.historyTtlMs,
 				idempotencyTtlMs: limits.idempotencyTtlMs,
-				...publishOptions.key === void 0 ? {} : { key: publishOptions.key }
+				...publishOptions.key === void 0 ? {} : { key: `${publishOptions.key}/s` }
 			});
 			counters.published += result.duplicate ? 0 : 1;
 			return result;
 		},
 		async setMemberState(identity, channel, connectionId, state) {
-			if (identity.user === void 0) throw new RealtimeError("unauthorized", "presence changes over HTTP need a signed-in user");
+			if (identity.user === void 0) throw new RealtimeError("unauthorized", ...["presence changes over HTTP need a signed-in user"]);
 			const found = match(channel);
 			if (found === void 0 || !await allowed(found.rule, "presence", channel, found.params, identity)) throw new RealtimeError("forbidden");
-			if (byteLength(JSON.stringify(state)) > limits.maxStateBytes) throw new RealtimeError("too_large", "the presence state is too large");
+			if (byteLength(JSON.stringify(state)) > limits.maxStateBytes) throw new RealtimeError("too_large", ...["the presence state is too large"]);
 			const member = (await adapter.presenceList(channel)).find((item) => item.id === connectionId);
-			if (member === void 0 || member.u !== identity.user) throw new RealtimeError("forbidden", "that connection is not yours");
+			if (member === void 0 || member.u !== identity.user) throw new RealtimeError("forbidden", ...["that connection is not yours"]);
 			const local = conns.get(connectionId)?.subs.get(channel);
 			const version = Math.max(member.v, local?.version ?? 0) + 1;
 			if (local?.joined === true) {
@@ -812,15 +815,16 @@ function createHubCore(options = {}) {
 		},
 		revoke(target) {
 			if (target.user === void 0 && target.connection === void 0 && target.channel === void 0) throw new TypeError("revoke needs a user, a connection or a channel.");
+			const hit = (conn, channel) => (target.connection === void 0 || conn.id === target.connection) && (target.user === void 0 || conn.identity.user === target.user) && (target.channel === void 0 || channel === target.channel);
 			let count = 0;
-			for (const conn of [...conns.values()]) {
-				if (target.connection !== void 0 && conn.id !== target.connection) continue;
-				if (target.user !== void 0 && conn.identity.user !== target.user) continue;
-				for (const sub of [...conn.subs.values()]) {
-					if (target.channel !== void 0 && sub.channel.name !== target.channel) continue;
-					removeSub(sub, "revoked");
-					count += 1;
-				}
+			for (const item of judging) if (hit(item.conn, item.channel)) {
+				judging.delete(item);
+				count += 1;
+			}
+			for (const conn of [...conns.values()]) for (const sub of [...conn.subs.values()]) {
+				if (!hit(conn, sub.channel.name)) continue;
+				removeSub(sub, "revoked");
+				count += 1;
 			}
 			return count;
 		},