@shadow-js/realtime 0.0.0-stage → 1.0.0

package/dist/dev/client/core.js

@@ -0,0 +1,845 @@
+import { RealtimeError } from "../errors.js";
+import { byteLength, decodeServerFrame, isChannelName, isEventName, isIdempotencyKey } from "../protocol.js";
+import { applyPresence } from "./presence.js";
+import { openStream } from "./sse.js";
+import { backoff, clientId, resolveUrl, sendUrl } from "./util.js";
+import { openSocket } from "./ws.js";
+//#region src/client/core.ts
+/** Close codes that mean the client did something the server will not accept again. */
+const FATAL = /* @__PURE__ */ new Set([
+	1002,
+	1008,
+	1009
+]);
+/** Refusals that may heal by asking again. */
+const TRANSIENT = /* @__PURE__ */ new Set([
+	"unavailable",
+	"rate_limited",
+	"timeout"
+]);
+/** HTTP sl of a stream request that are worth retrying among the 4xx. */
+const RETRYABLE_STATUS = /* @__PURE__ */ new Set([
+	408,
+	425,
+	429
+]);
+const MAX_FRAMES_PER_POST = 64;
+const MAX_POST_BYTES = 256e3;
+const MAX_STREAM_CHANNELS = 64;
+const DEFAULT_REQUEST_MS = 1e4;
+/**
+* Creates the realtime client: one transport (WebSocket, falling back to server-sent ev), reconnects with backoff, a
+* bounded offline queue, resume from the last sequence number and typed channels. It connects when the first channel
+* listens or the first message is sent, never earlier.
+*
+* @param options The stream URL and the policy.
+* @returns The client.
+* @example
+* import { createRealtime } from "@shadow-js/realtime/client";
+*
+* type Schema = { [name: `chat:${string}`]: { ev: { message: { text: string } } } };
+* const rt = createRealtime<Schema>({ url: "/rt" });
+* const lobby = rt.channel("chat:lobby");
+* const stop = lobby.on("message", (data) => console.log(data.text));
+* await lobby.publish("message", { text: "hello" });
+* stop();
+* rt.close();
+* @since 1.0.0
+*/
+function createRealtime(options) {
+	const reconnect = options.reconnect ?? {};
+	const minDelay = reconnect.minDelayMs ?? 250;
+	const maxDelay = reconnect.maxDelayMs ?? 3e4;
+	const stableMs = reconnect.stableMs ?? 5e3;
+	const random = reconnect.random ?? Math.random;
+	const maxQueued = options.maxQueued ?? 100;
+	const queueTtl = options.queueTtlMs ?? 3e4;
+	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 = [];
+	const inflight = /* @__PURE__ */ new Map();
+	const statusListeners = /* @__PURE__ */ new Set();
+	let status = "connecting";
+	let mode = options.transport === "sse" ? "sse" : "ws";
+	let finished = false;
+	let scheduled = false;
+	let link;
+	let gen = 0;
+	let ready = false;
+	let connId;
+	let maxBytes = 65536;
+	let streamSig = "";
+	let byeCode;
+	let wsFails = 0;
+	let attempt = 0;
+	let counter = 0;
+	let keys = 0;
+	let orders = 0;
+	let received = false;
+	let silent = 0;
+	let connectTimer;
+	let reconnectTimer;
+	let stableTimer;
+	let beatTimer;
+	let posting = false;
+	let postTimer;
+	let postFails = 0;
+	let listening = false;
+	const report = (error) => {
+		try {
+			if (options.onError !== void 0) options.onError(error);
+			else console.error("[realtime]", error);
+		} catch {}
+	};
+	const guard = (run) => {
+		try {
+			run();
+		} catch (error) {
+			report(error);
+		}
+	};
+	const doFetch = (input, init) => (options.fetch ?? globalThis.fetch)(input, init);
+	const getHeaders = () => typeof options.headers === "function" ? options.headers() : options.headers;
+	const emit = (listeners, value) => {
+		for (const listener of [...listeners]) guard(() => listener(value));
+	};
+	const setStatus = (next) => {
+		if (next === status) return;
+		status = next;
+		if (options.onStatus !== void 0) guard(() => options.onStatus?.(next));
+		emit(statusListeners, next);
+	};
+	const setChanStatus = (chan, next) => {
+		if (chan.status === next) return;
+		chan.status = next;
+		emit(chan.sl, next);
+	};
+	/** Settles an operation once; an unacknowledged publish that fails is reported instead. */
+	const finish = (op, error, value) => {
+		clearTimeout(op.timer);
+		const settle = op.settle;
+		op.settle = void 0;
+		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"));
+		}, ms);
+	};
+	const take = (n) => {
+		const op = inflight.get(n);
+		if (op !== void 0) inflight.delete(n);
+		return op;
+	};
+	const enqueue = (op) => {
+		if (finished) return new RealtimeError("closed");
+		const flowing = ready && mode === "ws";
+		if (op.kind !== "pres" && !flowing && queue.length >= maxQueued) return new RealtimeError("queue_full");
+		if (op.kind === "pres") {
+			const old = queue.findIndex((item) => item.kind === "pres" && item.chan === op.chan);
+			if (old >= 0) queue.splice(old, 1);
+		} else arm(op, queueTtl);
+		queue.push(op);
+		if (ready) flush();
+		else schedule();
+	};
+	const newOp = (kind, chan, event, data, extra) => ({
+		kind,
+		chan,
+		event,
+		data,
+		key: extra.key,
+		ack: extra.ack ?? true,
+		ms: extra.ms ?? 0,
+		order: ++orders,
+		n: 0,
+		timer: void 0,
+		settle: extra.settle
+	});
+	/** 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;
+		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"));
+			return;
+		}
+		return text;
+	};
+	/** 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) {
+			inflight.set(op.n, op);
+			arm(op, op.kind === "req" ? op.ms + 1e3 : ackTtl);
+		} 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"));
+		else {
+			if (op.kind === "pub") arm(op, queueTtl);
+			again.push(op);
+		}
+		queue.unshift(...again);
+	};
+	const wants = (chan) => !chan.closed && (chan.refs > 0 || chan.state !== void 0 || chan.options.watch === true || chan.hd > 0 && mode === "ws");
+	const joins = (chan) => chan.state !== void 0;
+	const watches = (chan) => !joins(chan) && (chan.presence.size > 0 || chan.options.watch === true);
+	const touch = (chan) => {
+		if (chan.status === "idle" && wants(chan)) setChanStatus(chan, "subscribing");
+		dirty.add(chan);
+		schedule();
+	};
+	/** The fields a subscription goes out with, over a WebSocket as a frame and over SSE as a query entry. */
+	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;
+		chan.w = {
+			n,
+			join,
+			watch,
+			after,
+			ver: chan.sv,
+			ready: !join
+		};
+		setChanStatus(chan, chan.sy ? "resuming" : "subscribing");
+		return { fields: {
+			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;
+		if (w === void 0 || chan.state === void 0) return;
+		w.ver = chan.sv;
+		const op = newOp("pres", chan, "", JSON.stringify(chan.state), {});
+		if (mode === "ws") {
+			const text = encode(op);
+			if (text !== void 0) link?.send(text);
+		} else enqueue(op);
+	};
+	const goIdle = (chan) => {
+		chan.sy = false;
+		chan.last = 0;
+		chan.w = void 0;
+		clearTimeout(chan.retry);
+		chan.retry = void 0;
+		chan.fails = 0;
+		if (chan.members.size > 0) {
+			chan.members.clear();
+			chan.list = void 0;
+		}
+		setChanStatus(chan, chan.closed ? "closed" : "idle");
+	};
+	/** Brings the w in line with what a channel wants (WebSocket: subscribe, unsubscribe, presence). */
+	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)}}`);
+				chan.w = void 0;
+			}
+			if (want && chan.w === void 0 && chan.retry === void 0) {
+				const n = ++counter;
+				link?.send(JSON.stringify({
+					t: "sub",
+					n,
+					...subscription(chan, n).fields
+				}));
+			}
+		}
+		if (!want) {
+			if (chan.status !== "idle" && chan.status !== "closed") goIdle(chan);
+			return;
+		}
+		const current = chan.w;
+		if (current?.join && current.ready && current.ver !== chan.sv) sendPresence(chan);
+	};
+	const syncAll = () => {
+		const batch = [...dirty];
+		dirty.clear();
+		for (const chan of batch) syncChan(chan);
+	};
+	const closeChan = (chan, error) => {
+		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)}}`);
+		goIdle(chan);
+		chan.ev.clear();
+		chan.any.clear();
+		chan.gl.clear();
+		chan.presence.clear();
+		chan.sl.clear();
+		chan.refs = 0;
+		dirty.delete(chan);
+		if (error !== void 0) report(error);
+		schedule();
+	};
+	/** Subscribes again after a refusal or a removal the server announced; `now` skips the delay. */
+	const resubscribe = (chan, now) => {
+		chan.w = void 0;
+		setChanStatus(chan, chan.sy ? "resuming" : "subscribing");
+		if (now) {
+			touch(chan);
+			return;
+		}
+		chan.retry = setTimeout(() => {
+			chan.retry = void 0;
+			touch(chan);
+		}, 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 = "";
+		for (const chan of chans.values()) if (wants(chan)) sig += `${chan.name}|${chan.options.echo === false ? 0 : 1}${joins(chan) ? 1 : 0}${watches(chan) ? 1 : 0};`;
+		return sig;
+	};
+	const connect = () => {
+		clearTimeout(reconnectTimer);
+		reconnectTimer = void 0;
+		if (finished || link !== void 0) return;
+		gen += 1;
+		const g = gen;
+		ready = false;
+		received = false;
+		silent = 0;
+		const ev = {
+			rx: () => {
+				if (g === gen) received = true;
+			},
+			frame: (frame) => {
+				if (g === gen) guard(() => onFrame(frame, false));
+			},
+			closed: (info) => {
+				if (g === gen) linkClosed(info);
+			}
+		};
+		try {
+			if (!listening && typeof addEventListener === "function") {
+				listening = true;
+				addEventListener("online", onOnline);
+			}
+			if (mode === "sse") {
+				const url = resolveUrl(options.url, false);
+				url.searchParams.set("s", JSON.stringify(declare()));
+				link = openStream(url.toString(), doFetch, getHeaders, ev);
+			} else link = openSocket(resolveUrl(options.url, true).toString(), options.WebSocket ?? globalThis.WebSocket, ev);
+		} catch (error) {
+			gen += 1;
+			shutdown(new RealtimeError("closed", "cannot open", { cause: error }));
+			return;
+		}
+		connectTimer = setTimeout(() => {
+			if (g === gen) linkClosed({});
+		}, ackTtl);
+	};
+	const onOnline = () => {
+		if (reconnectTimer !== void 0) connect();
+	};
+	/** Releases the current transport and everything tied to it. */
+	const drop = () => {
+		gen += 1;
+		const old = link;
+		link = void 0;
+		ready = false;
+		connId = void 0;
+		clearTimeout(connectTimer);
+		clearTimeout(stableTimer);
+		clearInterval(beatTimer);
+		beatTimer = void 0;
+		old?.close();
+	};
+	const linkClosed = (info) => {
+		const wasReady = ready;
+		const code = byeCode ?? info.code;
+		byeCode = void 0;
+		drop();
+		if (finished) return;
+		if (mode === "ws" && inflight.size > 0) {
+			const lost = [...inflight.values()];
+			inflight.clear();
+			requeue(lost);
+		}
+		for (const chan of chans.values()) {
+			chan.w = void 0;
+			clearTimeout(chan.retry);
+			chan.retry = void 0;
+			if (wants(chan)) setChanStatus(chan, chan.sy ? "resuming" : "subscribing");
+		}
+		const refused = info.status !== void 0 && info.status >= 400 && info.status < 500 && !RETRYABLE_STATUS.has(info.status);
+		if ((code !== void 0 && FATAL.has(code) || refused) && reconnect.retryFatal !== true) {
+			const why = code !== void 0 ? `the server closed the connection with ${code}` : `the server answered ${info.status}`;
+			shutdown(new RealtimeError("closed", why));
+			return;
+		}
+		let delay = backoff(attempt, minDelay, maxDelay, random);
+		attempt += 1;
+		if (wasReady) wsFails = 0;
+		else if (auto && mode === "ws") {
+			wsFails += 1;
+			if (wsFails >= 2) {
+				mode = "sse";
+				delay = 0;
+			}
+		}
+		setStatus("reconnecting");
+		reconnectTimer = setTimeout(connect, delay);
+	};
+	/** 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;
+			}
+		}
+		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);
+				return;
+			case "bye":
+				byeCode = frame.code;
+				return;
+			case "subbed": {
+				const chan = chans.get(frame.c);
+				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);
+				chan.sy = true;
+				chan.fails = 0;
+				setChanStatus(chan, "live");
+				if (gap) emit(chan.gl, {
+					...info,
+					reset: frame.reset === true
+				});
+				return;
+			}
+			case "unsubbed": {
+				const chan = chans.get(frame.c);
+				if (chan === void 0) return;
+				if (frame.why === "revoked") {
+					chan.w = void 0;
+					closeChan(chan, new RealtimeError("forbidden", "revoked"));
+				} else resubscribe(chan, frame.why === "gap" || frame.why === "reset");
+				return;
+			}
+			case "msg": {
+				const chan = chans.get(frame.c);
+				if (chan === void 0 || frame.s <= chan.last) return;
+				chan.last = frame.s;
+				const meta = {
+					seq: frame.s,
+					replayed: frame.r === 1,
+					...frame.p === void 0 ? {} : { publisher: frame.p },
+					...frame.u === void 0 ? {} : { user: frame.u }
+				};
+				for (const handler of [...chan.ev.get(frame.e) ?? []]) guard(() => handler(frame.d, meta));
+				for (const handler of [...chan.any]) guard(() => handler({
+					event: frame.e,
+					data: frame.d,
+					meta
+				}));
+				return;
+			}
+			case "ack": {
+				const op = take(frame.n);
+				if (op !== void 0) succeed(op, {
+					seq: frame.s,
+					duplicate: frame.dup === true
+				});
+				return;
+			}
+			case "rep": {
+				const op = take(frame.n);
+				if (op !== void 0) succeed(op, frame.d);
+				return;
+			}
+			case "err": {
+				const error = new RealtimeError(frame.code, frame.msg);
+				const chan = frame.c === void 0 ? void 0 : chans.get(frame.c);
+				if (frame.n !== void 0) {
+					if (!viaPost && chan?.w?.n === frame.n) {
+						if (TRANSIENT.has(frame.code)) {
+							resubscribe(chan, false);
+							report(error);
+						} else {
+							chan.w = void 0;
+							closeChan(chan, error);
+						}
+						return;
+					}
+					const op = viaPost || mode === "ws" ? take(frame.n) : void 0;
+					if (op !== void 0) {
+						fail(op, error);
+						return;
+					}
+				}
+				report(error);
+				return;
+			}
+			case "pres": {
+				const chan = chans.get(frame.c);
+				if (chan === void 0) return;
+				if (applyPresence(chan.members, frame.op, frame.m)) notifyPresence(chan);
+				if (frame.op === "sync" && chan.w !== void 0) {
+					chan.w.ready = true;
+					if (chan.w.join && chan.w.ver !== chan.sv) sendPresence(chan);
+				}
+				return;
+			}
+			case "pong": return;
+		}
+	};
+	const flush = () => {
+		if (!ready || finished) return;
+		syncAll();
+		if (mode === "sse") {
+			postNext();
+			return;
+		}
+		for (let op = queue[0]; op !== void 0 && ready; op = queue[0]) {
+			const text = encode(op);
+			if (text !== void 0) {
+				if (link?.send(text) !== true) return;
+				sent(op);
+			}
+			queue.shift();
+		}
+	};
+	const postNext = () => {
+		if (posting || postTimer !== void 0 || connId === void 0) return;
+		const ops = [];
+		const texts = [];
+		let bytes = 0;
+		while (queue.length > 0 && ops.length < MAX_FRAMES_PER_POST && bytes < MAX_POST_BYTES) {
+			const op = queue.shift();
+			if (op === void 0) break;
+			const text = encode(op);
+			if (text === void 0) continue;
+			ops.push(op);
+			texts.push(text);
+			bytes += text.length;
+		}
+		if (ops.length === 0) return;
+		posting = true;
+		postBatch(ops, `{"cid":${JSON.stringify(connId)},"frames":[${texts.join(",")}]}`).then(void 0, report);
+	};
+	const postBatch = async (ops, body) => {
+		for (const op of ops) sent(op);
+		let again = false;
+		try {
+			const headers = new Headers(await getHeaders());
+			headers.set("content-type", "application/json");
+			const url = options.postUrl === void 0 ? sendUrl(resolveUrl(options.url, false)) : resolveUrl(options.postUrl, false);
+			const response = await doFetch(url, {
+				method: "POST",
+				headers,
+				body,
+				signal: life.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));
+					if (frame !== void 0) guard(() => onFrame(frame, true));
+				}
+				postFails = 0;
+			} else if (response.status >= 500 || RETRYABLE_STATUS.has(response.status)) again = true;
+			else {
+				const refusal = await response.json().catch(() => void 0);
+				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));
+				}
+			}
+		} catch {
+			if (life.signal.aborted) return;
+			again = true;
+		}
+		posting = false;
+		const unanswered = ops.filter((op) => (op.kind === "req" || op.kind === "pub" && op.ack) && 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"));
+			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"));
+		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();
+			return;
+		}
+		if (mode === "sse" && (signature() !== streamSig || [...chans.values()].some((c) => wants(c) && c.w === void 0 && c.retry === void 0))) reopen();
+		else flush();
+	};
+	function schedule() {
+		if (scheduled || finished) return;
+		scheduled = true;
+		queueMicrotask(run);
+	}
+	function shutdown(error) {
+		if (finished) return;
+		finished = true;
+		clearTimeout(reconnectTimer);
+		clearTimeout(postTimer);
+		reconnectTimer = void 0;
+		postTimer = void 0;
+		drop();
+		life.abort();
+		if (listening && typeof removeEventListener === "function") removeEventListener("online", onOnline);
+		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);
+		for (const chan of [...chans.values()]) closeChan(chan);
+		chans.clear();
+		dirty.clear();
+		setStatus("closed");
+		statusListeners.clear();
+		if (error !== void 0) report(error);
+	}
+	const makeChannel = (name, channelOptions) => {
+		const chan = {
+			name,
+			options: channelOptions,
+			ev: /* @__PURE__ */ new Map(),
+			any: /* @__PURE__ */ new Set(),
+			gl: /* @__PURE__ */ new Set(),
+			sl: /* @__PURE__ */ new Set(),
+			presence: /* @__PURE__ */ new Set(),
+			members: /* @__PURE__ */ new Map(),
+			list: void 0,
+			status: "idle",
+			refs: 0,
+			hd: 0,
+			last: 0,
+			sy: false,
+			state: channelOptions.presence,
+			sv: 0,
+			w: void 0,
+			retry: void 0,
+			fails: 0,
+			closed: false,
+			hn: void 0
+		};
+		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;
+			set.add(item);
+			if (!passive) {
+				chan.refs += 1;
+				touch(chan);
+			}
+			return () => {
+				if (!set.delete(item) || passive) return;
+				chan.refs -= 1;
+				after?.();
+				touch(chan);
+			};
+		};
+		/** Validates and queues a publish or a request; the promise settles with its answer. */
+		const submit = (kind, event, data, key, ack, ms) => {
+			let text = "null";
+			let refusal;
+			if (chan.closed) refusal = new RealtimeError("closed");
+			else if (!isEventName(event) || key !== void 0 && !isIdempotencyKey(key)) refusal = new RealtimeError("bad_frame");
+			else try {
+				text = JSON.stringify(data ?? null) ?? "null";
+			} catch (cause) {
+				refusal = new RealtimeError("bad_frame", "not JSON", { cause });
+			}
+			if (refusal !== void 0) return Promise.reject(refusal);
+			return new Promise((resolve, reject) => {
+				const request = kind === "req";
+				const op = newOp(kind, chan, event, text, {
+					key: request ? void 0 : key ?? `${id}:${++keys}`,
+					ack,
+					ms,
+					settle: ack ? (error, value) => {
+						if (request) {
+							chan.hd -= 1;
+							touch(chan);
+						}
+						if (error) reject(error);
+						else resolve(value);
+					} : void 0
+				});
+				if (request) {
+					chan.hd += 1;
+					touch(chan);
+				}
+				const refused = enqueue(op);
+				if (refused !== void 0) {
+					op.settle = void 0;
+					if (request) chan.hd -= 1;
+					reject(refused);
+				} else if (!ack) resolve({
+					seq: 0,
+					duplicate: false
+				});
+			});
+		};
+		const hn = {
+			name,
+			get status() {
+				return chan.status;
+			},
+			get lastSeq() {
+				return chan.last;
+			},
+			on(event, handler) {
+				let set = chan.ev.get(event);
+				if (set === void 0) {
+					set = /* @__PURE__ */ new Set();
+					chan.ev.set(event, set);
+				}
+				const handlers = set;
+				return listen(handlers, handler, false, () => {
+					if (handlers.size === 0 && chan.ev.get(event) === handlers) chan.ev.delete(event);
+				});
+			},
+			onAny: (handler) => listen(chan.any, handler),
+			onGap: (handler) => listen(chan.gl, handler),
+			onStatus: (handler) => listen(chan.sl, handler, true),
+			publish: (event, data, publishOptions = {}) => submit("pub", event, data, publishOptions.key, publishOptions.ack !== false, 0),
+			request: (event, data, requestOptions = {}) => submit("req", event, data, void 0, true, requestOptions.timeoutMs ?? DEFAULT_REQUEST_MS),
+			presence: {
+				members: () => {
+					chan.list ??= [...chan.members.values()];
+					return chan.list;
+				},
+				set(state) {
+					if (chan.closed) return;
+					chan.state = state;
+					chan.sv += 1;
+					touch(chan);
+				},
+				leave() {
+					if (chan.closed || chan.state === void 0) return;
+					chan.state = void 0;
+					chan.sv += 1;
+					touch(chan);
+				},
+				on: (callback) => listen(chan.presence, callback)
+			},
+			close: () => closeChan(chan)
+		};
+		chan.hn = hn;
+		return hn;
+	};
+	return {
+		channel(name, channelOptions = {}) {
+			if (finished) throw new RealtimeError("closed");
+			if (!isChannelName(name)) throw new RealtimeError("bad_channel", name);
+			return chans.get(name)?.hn ?? makeChannel(name, channelOptions);
+		},
+		get status() {
+			return status;
+		},
+		get connectionId() {
+			return connId;
+		},
+		onStatus(handler) {
+			if (!finished) statusListeners.add(handler);
+			return () => {
+				statusListeners.delete(handler);
+			};
+		},
+		close: () => shutdown()
+	};
+}
+//#endregion
+export { createRealtime };
+
+//# sourceMappingURL=core.js.map