@shadow-js/realtime 0.0.0-stage → 1.0.1

package/dist/dev/server/hub.js

@@ -0,0 +1,826 @@
+import { RealtimeError } from "../errors.js";
+import { byteLength, decodeClientFrame, isChannelName, isEventName, isIdempotencyKey } from "../protocol.js";
+import { TokenBucket, WindowCounter, resolveLimits } from "./limits.js";
+import { memoryAdapter } from "../memory.js";
+import { compileRule, matchRule } from "./rules.js";
+// src/server/hub.ts
+const REPLAY_PAGE = 500;
+const MAX_PUMP_BUFFER = 1e4;
+const ID_BYTES = 16;
+/** A random id: 128 bits, base64url. */
+function randomId() {
+	const bytes = new Uint8Array(ID_BYTES);
+	crypto.getRandomValues(bytes);
+	let text = "";
+	for (const byte of bytes) text += String.fromCharCode(byte);
+	return btoa(text).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function encodeFrame(frame) {
+	return JSON.stringify(frame);
+}
+function messageFrame(channel, message, replayed) {
+	return `{"t":"msg","c":${JSON.stringify(channel)},"s":${message.seq},"e":${JSON.stringify(message.event)},"d":${message.data}` + (message.publisher === void 0 ? "" : `,"p":${JSON.stringify(message.publisher)}`) + (message.user === void 0 ? "" : `,"u":${JSON.stringify(message.user)}`) + (replayed ? ",\"r\":1}" : "}");
+}
+/**
+* Creates the hub: the server side of `@shadow-js/realtime`. It owns connections and channel rules, enforces limits and talks to
+* one adapter. Wire it to a transport with `hub.websocket()`, `hub.sse()` and `hub.post()` (Dusk routes) or with `hub.connect`.
+*
+* @param options The adapter, the channel rules and the limits.
+* @returns The hub.
+* @throws RangeError for a limit that is not valid; TypeError for an invalid channel pattern.
+* @example
+* import { createHub } from "@shadow-js/realtime/server";
+*
+* const hub = createHub({
+*   channels: { "chat:{room}": { subscribe: true, publish: ({ identity }) => identity.user !== undefined } },
+* });
+* const sent: string[] = [];
+* const connection = hub.connect({ send: (frame) => (sent.push(frame), true), close: () => {} });
+* connection.receive('{"t":"sub","n":1,"c":"chat:lobby"}');
+* @since 1.0.0
+*/
+function createHubCore(options = {}) {
+	const limits = resolveLimits(options.limits);
+	const now = options.now ?? Date.now;
+	const ownsAdapter = options.adapter === void 0;
+	const adapter = options.adapter ?? memoryAdapter({ now });
+	const rules = [];
+	const conns = /* @__PURE__ */ new Map();
+	const chans = /* @__PURE__ */ new Map();
+	let heartbeat;
+	let closing = false;
+	let beating = false;
+	const counters = {
+		published: 0,
+		delivered: 0,
+		refused: 0,
+		slowConsumers: 0
+	};
+	const report = (error, context) => {
+		if (options.onError !== void 0) try {
+			options.onError(error, context);
+		} catch {}
+		else console.error(`[realtime] ${context.where}`, error);
+	};
+	function match(channel) {
+		for (const compiled of rules) {
+			const params = matchRule(compiled, channel);
+			if (params !== void 0) return {
+				rule: compiled.rule,
+				params
+			};
+		}
+	}
+	async function allowed(rule, op, channel, params, identity) {
+		const permission = rule[op];
+		if (permission === void 0 || permission === false) return false;
+		if (permission === true) return true;
+		try {
+			return await permission({
+				channel,
+				params,
+				identity,
+				op
+			}) === true;
+		} catch (error) {
+			report(error, {
+				where: `rule.${op}`,
+				channel
+			});
+			throw new RealtimeError("unavailable", "the channel rule could not be evaluated");
+		}
+	}
+	function send(conn, text) {
+		if (conn.closed) return;
+		try {
+			if ((conn.transport.buffered?.() ?? 0) > limits.maxBufferedBytes) {
+				counters.slowConsumers += 1;
+				drop(conn, 1013, "slow consumer");
+				return;
+			}
+			if (conn.transport.send(text)) return;
+		} catch (error) {
+			report(error, {
+				where: "transport.send",
+				connection: conn.id
+			});
+		}
+		closeConnection(conn);
+	}
+	function sendFrame(conn, frame) {
+		send(conn, encodeFrame(frame));
+	}
+	function fail(conn, n, code, channel, message) {
+		counters.refused += 1;
+		sendFrame(conn, {
+			t: "err",
+			...n === void 0 ? {} : { n },
+			...channel === void 0 ? {} : { c: channel },
+			code,
+			...message === void 0 ? {} : { msg: message }
+		});
+	}
+	/** Sends a final frame, closes the transport and releases the connection. */
+	function drop(conn, code, reason) {
+		if (conn.closed) return;
+		try {
+			conn.transport.send(encodeFrame({
+				t: "bye",
+				code,
+				why: reason
+			}));
+		} catch {}
+		try {
+			conn.transport.close(code, reason);
+		} catch {}
+		closeConnection(conn);
+	}
+	function channelState(name) {
+		let chan = chans.get(name);
+		if (chan === void 0 || chan.closing) {
+			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
+			};
+			chans.set(name, chan);
+		}
+		return chan;
+	}
+	async function ensureAdapterSub(chan) {
+		if (chan.adapterSub === void 0) {
+			chan.adapterSub = adapter.subscribe(chan.name, (message) => onMessage(chan, message));
+			chan.adapterSub.catch(() => {
+				chan.adapterSub = void 0;
+			});
+		}
+		await chan.adapterSub;
+	}
+	async function ensurePresenceSub(chan) {
+		if (chan.presenceSub === void 0) {
+			chan.presenceSub = adapter.presenceSubscribe(chan.name, (event) => onPresence(chan, event));
+			chan.presenceSub.catch(() => {
+				chan.presenceSub = void 0;
+			});
+		}
+		await chan.presenceSub;
+	}
+	function onMessage(chan, message) {
+		for (const sub of chan.subs) {
+			if (!sub.active) continue;
+			if (sub.pumping) {
+				if (sub.buffer.length >= MAX_PUMP_BUFFER) removeSub(sub, "gap");
+				else sub.buffer.push(message);
+				continue;
+			}
+			if (message.seq === sub.lastSeq + 1) deliver(sub, message, false);
+			else if (message.seq > sub.lastSeq + 1) {
+				sub.buffer.push(message);
+				pump(sub, void 0);
+			} else if (message.at > sub.lastAt) removeSub(sub, "reset");
+		}
+	}
+	function deliver(sub, message, replayed) {
+		sub.lastSeq = message.seq;
+		sub.lastAt = Math.max(sub.lastAt, 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 = {
+			seq: message.seq,
+			text
+		};
+		send(sub.conn, text);
+	}
+	/**
+	* Delivers, in order and without a gap, the messages after `sub.lastSeq` 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"`.
+	*/
+	async function pump(sub, upTo) {
+		if (sub.pumping && upTo === void 0) return;
+		sub.pumping = true;
+		try {
+			while (sub.active) {
+				sub.buffer = sub.buffer.filter((message) => message.seq > sub.lastSeq);
+				const next = sub.buffer[0];
+				if (next !== void 0 && next.seq === sub.lastSeq + 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.active) return;
+				const first = page.messages[0];
+				if (first === void 0 || first.seq !== sub.lastSeq + 1) {
+					if (!sub.gapOk) {
+						removeSub(sub, "gap");
+						return;
+					}
+					sub.lastSeq = (first?.seq ?? target + 1) - 1;
+					continue;
+				}
+				for (const message of page.messages) {
+					if (message.seq > target) break;
+					deliver(sub, message, true);
+				}
+			}
+		} catch (error) {
+			report(error, {
+				where: "pump",
+				channel: sub.channel.name,
+				connection: sub.conn.id
+			});
+			if (sub.active) removeSub(sub, "unavailable");
+		} finally {
+			sub.pumping = false;
+		}
+		if (sub.active && sub.buffer.length > 0) pump(sub, void 0);
+	}
+	function onPresence(chan, event) {
+		for (const sub of chan.subs) {
+			if (!sub.active || !sub.joined && !sub.watch) continue;
+			if (sub.presenceQueue !== void 0) sub.presenceQueue.push(event);
+			else sendPresence(sub, event);
+		}
+	}
+	function sendPresence(sub, event) {
+		sendFrame(sub.conn, {
+			t: "pres",
+			c: event.channel,
+			op: event.op,
+			m: event.member
+		});
+	}
+	/** Removes a subscription from its connection and channel; tells the peer when `why` is given. */
+	function removeSub(sub, why) {
+		if (!sub.active) return;
+		sub.active = false;
+		sub.conn.subs.delete(sub.channel.name);
+		sub.channel.subs.delete(sub);
+		if (why !== void 0 && !sub.conn.closed) sendFrame(sub.conn, {
+			t: "unsubbed",
+			c: sub.channel.name,
+			...why === "" ? {} : { why }
+		});
+		releaseSub(sub);
+	}
+	/** The releases still running, so that `close` finishes them before it closes the adapter. */
+	const releasing = /* @__PURE__ */ new Set();
+	function releaseSub(sub) {
+		const running = release(sub);
+		releasing.add(running);
+		running.finally(() => releasing.delete(running));
+		return running;
+	}
+	async function release(sub) {
+		const chan = sub.channel;
+		try {
+			await sub.joining?.catch(() => void 0);
+			if (sub.joined) {
+				sub.joined = false;
+				await adapter.presenceRemove(chan.name, sub.conn.id);
+			}
+		} catch (error) {
+			report(error, {
+				where: "presenceRemove",
+				channel: chan.name,
+				connection: sub.conn.id
+			});
+		}
+		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);
+		await Promise.all(stops.map(async (stop) => {
+			try {
+				await (await stop)();
+			} catch (error) {
+				report(error, {
+					where: "unsubscribe",
+					channel: chan.name
+				});
+			}
+		}));
+	}
+	function identityDenied(conn) {
+		return conn.identity.user === void 0 ? "unauthorized" : "forbidden";
+	}
+	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");
+		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);
+		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");
+		if (conn.closed) return;
+		const chan = channelState(name);
+		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,
+			echo: frame.echo !== false,
+			watch: frame.watch === true,
+			joined: false,
+			version: 0,
+			lastSeq: 0,
+			lastAt: now(),
+			pumping: true,
+			gapOk: false,
+			buffer: [],
+			presenceQueue: wantsPresence ? [] : void 0,
+			joining: void 0,
+			active: true
+		};
+		conn.subs.set(name, sub);
+		chan.subs.add(sub);
+		try {
+			await ensureAdapterSub(chan);
+			if (wantsPresence) {
+				await ensurePresenceSub(chan);
+				startHeartbeat();
+			}
+			const probe = await adapter.history(name, Number.MAX_SAFE_INTEGER, 0);
+			if (!sub.active) return;
+			const head = probe.head;
+			const after = frame.after;
+			let gap = false;
+			let reset = false;
+			if (after === void 0) sub.lastSeq = head;
+			else if (after > head) {
+				reset = true;
+				sub.lastSeq = head;
+			} else {
+				sub.lastSeq = after;
+				gap = probe.oldest === 0 ? head > after : probe.oldest > after + 1;
+				sub.gapOk = gap;
+			}
+			sendFrame(conn, {
+				t: "subbed",
+				n,
+				c: name,
+				head,
+				...gap ? { gap: true } : {},
+				...reset ? { reset: true } : {}
+			});
+			if (frame.hasPresence) {
+				sub.joining = joinPresence(sub, frame.presence ?? null);
+				await sub.joining;
+			}
+			if (wantsPresence) await syncPresence(sub);
+			if (!sub.active) return;
+			await pump(sub, head);
+			sub.gapOk = false;
+		} catch (error) {
+			if (sub.active) {
+				removeSub(sub);
+				report(error, {
+					where: "subscribe",
+					channel: name,
+					connection: conn.id
+				});
+				fail(conn, n, error instanceof RealtimeError ? error.code : "unavailable", name);
+			}
+		}
+	}
+	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.joined = true;
+		startHeartbeat();
+		const member = {
+			id: sub.conn.id,
+			...sub.conn.identity.user === void 0 ? {} : { u: sub.conn.identity.user },
+			s: state,
+			v: 1
+		};
+		await adapter.presenceSet(sub.channel.name, member, limits.presenceTtlMs);
+	}
+	async function syncPresence(sub) {
+		const members = await adapter.presenceList(sub.channel.name);
+		if (!sub.active) return;
+		sendFrame(sub.conn, {
+			t: "pres",
+			c: sub.channel.name,
+			op: "sync",
+			m: members
+		});
+		const queued = sub.presenceQueue ?? [];
+		sub.presenceQueue = 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);
+			if (event.op === "leave" ? version === void 0 : version !== void 0 && version >= event.member.v) continue;
+			sendPresence(sub, event);
+		}
+	}
+	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 (!conn.publishBucket.take(now())) return limit(conn, void 0, frame.c);
+		sub.version += 1;
+		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);
+		} catch (error) {
+			report(error, {
+				where: "presenceSet",
+				channel: frame.c,
+				connection: conn.id
+			});
+			fail(conn, void 0, "unavailable", frame.c);
+		}
+	}
+	function limit(conn, n, channel) {
+		fail(conn, n, "rate_limited", channel);
+		if (conn.limited.hit(now())) drop(conn, 1008, "rate limit exceeded");
+	}
+	async function publishFrame(conn, frame) {
+		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 (!conn.publishBucket.take(now()) || chans.get(name)?.bucket.take(now()) === false) return limit(conn, n, name);
+		try {
+			const result = await adapter.publish(name, {
+				event: frame.e,
+				data: frame.d,
+				publisher: conn.id,
+				...conn.identity.user === void 0 ? {} : { user: conn.identity.user }
+			}, {
+				history: found.rule.history ?? limits.history,
+				historyTtlMs: limits.historyTtlMs,
+				idempotencyTtlMs: limits.idempotencyTtlMs,
+				...frame.k === void 0 ? {} : { key: frame.k }
+			});
+			counters.published += result.duplicate ? 0 : 1;
+			if (n !== void 0) sendFrame(conn, {
+				t: "ack",
+				n,
+				s: result.seq,
+				...result.duplicate ? { dup: true } : {}
+			});
+		} catch (error) {
+			report(error, {
+				where: "publish",
+				channel: name,
+				connection: conn.id
+			});
+			fail(conn, n, "unavailable", name);
+		}
+	}
+	async function request(conn, frame) {
+		const { c: name, n } = frame;
+		let target = conn.subs.get(name);
+		if (target === void 0 && conn.stateless) {
+			const found = match(name);
+			if (found !== void 0 && await allowed(found.rule, "subscribe", name, found.params, conn.identity)) target = found;
+		}
+		if (target === void 0) return fail(conn, n, identityDenied(conn) === "unauthorized" && conn.stateless ? "unauthorized" : "not_subscribed", name);
+		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.publishBucket.take(now())) return limit(conn, n, name);
+		const controller = new AbortController();
+		conn.pending.add(controller);
+		const timeout = Math.min(frame.ms ?? limits.requestTimeoutMs, limits.requestTimeoutMs);
+		const timer = setTimeout(() => controller.abort(new RealtimeError("timeout")), timeout);
+		(async () => {
+			try {
+				const run = Promise.resolve(handler({
+					channel: name,
+					params: sub.params,
+					identity: conn.identity,
+					event: frame.e,
+					data: frame.d,
+					signal: controller.signal
+				}));
+				const aborted = new Promise((_resolve, reject) => {
+					controller.signal.addEventListener("abort", () => reject(controller.signal.reason), { once: true });
+				});
+				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");
+				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);
+				else {
+					report(error, {
+						where: "request",
+						channel: name,
+						connection: conn.id
+					});
+					fail(conn, n, "handler_error", name);
+				}
+			} finally {
+				clearTimeout(timer);
+				conn.pending.delete(controller);
+				settle(conn);
+			}
+		})();
+	}
+	async function handle(conn, text) {
+		const decoded = decodeClientFrame(text, limits.maxMessageBytes);
+		if (!decoded.ok) {
+			fail(conn, decoded.n, decoded.code, void 0, decoded.why);
+			if (conn.invalid.hit(now())) drop(conn, 1008, "too many invalid frames");
+			return;
+		}
+		const frame = decoded.frame;
+		try {
+			switch (frame.t) {
+				case "hello": return;
+				case "ping":
+					sendFrame(conn, {
+						t: "pong",
+						...frame.n === void 0 ? {} : { n: frame.n }
+					});
+					return;
+				case "sub": return await subscribe(conn, frame);
+				case "unsub": {
+					const sub = conn.subs.get(frame.c);
+					if (sub === void 0) return fail(conn, frame.n, "not_subscribed", frame.c);
+					removeSub(sub);
+					return;
+				}
+				case "pub": return await publishFrame(conn, frame);
+				case "req": return await request(conn, frame);
+				case "pres": return await setPresence(conn, frame);
+			}
+		} catch (error) {
+			const n = "n" in frame ? frame.n : void 0;
+			const channel = "c" in frame ? frame.c : void 0;
+			if (error instanceof RealtimeError) fail(conn, n, error.code, channel);
+			else {
+				report(error, {
+					where: "frame",
+					connection: conn.id,
+					...channel === void 0 ? {} : { channel }
+				});
+				fail(conn, n, "unavailable", channel);
+			}
+		}
+	}
+	async function run(conn) {
+		if (conn.running) return;
+		conn.running = true;
+		try {
+			for (let text = conn.queue.shift(); text !== void 0; text = conn.queue.shift()) {
+				if (conn.closed) break;
+				try {
+					await handle(conn, text);
+				} catch (error) {
+					if (error instanceof RealtimeError) fail(conn, void 0, error.code);
+					else {
+						report(error, {
+							where: "frame",
+							connection: conn.id
+						});
+						fail(conn, void 0, "unavailable");
+					}
+				}
+			}
+		} finally {
+			conn.running = false;
+			settle(conn);
+		}
+	}
+	/** Wakes the callers of `settled` when the connection has nothing left to do. */
+	function settle(conn) {
+		if (conn.running || conn.queue.length > 0 || conn.pending.size > 0) return;
+		for (const wake of conn.waiters.splice(0)) wake();
+	}
+	async function closeConnection(conn) {
+		if (conn.closed) return conn.done;
+		conn.closed = true;
+		if (conns.get(conn.id) === conn) conns.delete(conn.id);
+		for (const controller of conn.pending) controller.abort(new RealtimeError("closed"));
+		conn.pending.clear();
+		conn.queue.length = 0;
+		for (const wake of conn.waiters.splice(0)) wake();
+		const subs = [...conn.subs.values()];
+		for (const sub of subs) {
+			sub.active = false;
+			sub.channel.subs.delete(sub);
+		}
+		conn.subs.clear();
+		await Promise.allSettled(subs.map((sub) => releaseSub(sub)));
+		conn.release?.();
+	}
+	function startHeartbeat() {
+		if (heartbeat !== void 0 || closing) return;
+		const timer = setInterval(() => void beat(), limits.presenceHeartbeatMs);
+		timer.unref?.();
+		heartbeat = timer;
+	}
+	async function beat() {
+		if (beating) return;
+		beating = true;
+		try {
+			await beatOnce();
+		} 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: null,
+					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,
+		adapter,
+		report,
+		match,
+		allowed,
+		channel(pattern, rule) {
+			rules.push(compileRule(pattern, rule));
+			return core;
+		},
+		connect(transport, identity = {}, connectOptions = {}) {
+			if (closing) throw new RealtimeError("closed", "the hub is closed");
+			let release = () => void 0;
+			const done = new Promise((resolve) => {
+				release = resolve;
+			});
+			const owner = connectOptions.actingFor === void 0 ? void 0 : conns.get(connectOptions.actingFor);
+			const acting = owner !== void 0 && identity.user !== void 0 && owner.identity.user === identity.user;
+			const conn = {
+				id: acting ? connectOptions.actingFor : randomId(),
+				identity,
+				transport,
+				subs: /* @__PURE__ */ new Map(),
+				queue: [],
+				publishBucket: connectOptions.publishBucket ?? new TokenBucket(limits.publishesPerSecond, limits.publishBurst, 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
+			};
+			if (!acting) conns.set(conn.id, conn);
+			sendFrame(conn, {
+				t: "ready",
+				v: 1,
+				id: conn.id,
+				hb: limits.heartbeatMs,
+				max: limits.maxMessageBytes
+			});
+			return {
+				id: conn.id,
+				identity,
+				done,
+				receive(text) {
+					if (conn.closed) return;
+					if (conn.queue.length >= limits.maxQueuedFrames) {
+						drop(conn, 1013, "too many frames waiting");
+						return;
+					}
+					conn.queue.push(text);
+					run(conn);
+				},
+				closed() {
+					closeConnection(conn);
+				},
+				settled() {
+					return new Promise((resolve) => {
+						conn.waiters.push(resolve);
+						settle(conn);
+					});
+				}
+			};
+		},
+		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");
+			let text;
+			try {
+				text = JSON.stringify(data === void 0 ? null : data);
+			} catch (error) {
+				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");
+			const found = match(channel);
+			const result = await adapter.publish(channel, {
+				event,
+				data: text
+			}, {
+				history: found?.rule.history ?? limits.history,
+				historyTtlMs: limits.historyTtlMs,
+				idempotencyTtlMs: limits.idempotencyTtlMs,
+				...publishOptions.key === void 0 ? {} : { key: publishOptions.key }
+			});
+			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");
+			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");
+			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");
+			await adapter.presenceSet(channel, {
+				id: member.id,
+				u: member.u,
+				s: state,
+				v: member.v + 1
+			}, limits.presenceTtlMs);
+		},
+		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.");
+			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;
+				}
+			}
+			return count;
+		},
+		stats() {
+			let subscriptions = 0;
+			for (const conn of conns.values()) subscriptions += conn.subs.size;
+			return {
+				connections: conns.size,
+				channels: chans.size,
+				subscriptions,
+				...counters
+			};
+		},
+		async close() {
+			if (closing) return;
+			closing = true;
+			if (heartbeat !== void 0) clearInterval(heartbeat);
+			heartbeat = void 0;
+			const all = [...conns.values()];
+			for (const conn of all) drop(conn, 1001, "going away");
+			await Promise.all(all.map((conn) => conn.done));
+			await Promise.allSettled([...releasing]);
+			if (ownsAdapter) await adapter.close();
+		}
+	};
+	return core;
+}
+export { createHubCore };
+
+//# sourceMappingURL=hub.js.map