@neta-art/cohub 11.1.0 → 11.3.0

package/dist/chunks/app-realtime.js

@@ -0,0 +1,1697 @@
+import { O as readRtcTransportStats, k as waitForIceGathering } from "./http.js";
+import { o as REALTIME_ROOM_EVENT_NAME_PATTERN, t as HttpError } from "./transport.js";
+import { z } from "zod";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+z.object({
+	urls: z.union([z.string().min(1).max(512), z.array(z.string().min(1).max(512)).min(1).max(16)]),
+	username: z.string().max(512).optional(),
+	credential: z.string().max(512).optional()
+});
+const sessionDescriptionSchema = z.object({
+	type: z.enum(["offer", "answer"]),
+	sdp: z.string().min(1).max(65536)
+});
+const APP_RTC_DELIVERIES = ["reliable", "latest"];
+const APP_RTC_PUBLICATION_KINDS = [
+	"data",
+	"audio",
+	"video"
+];
+const APP_RTC_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,63}$/;
+const isAppRtcName = (value) => typeof value === "string" && APP_RTC_NAME_PATTERN.test(value) && !value.toLowerCase().startsWith("cohub.");
+const APP_RTC_LIMITS = {
+	channelsPerMember: 16,
+	tracksPerMember: 4,
+	dataSubscriptions: 512,
+	mediaSubscriptions: 16,
+	messageBytes: 65536,
+	operationsPerSecond: 10,
+	opensPerSecond: 2,
+	batch: 64
+};
+const APP_RTC_QUALITIES = [
+	"high",
+	"medium",
+	"low"
+];
+const APP_RTC_SIMULCAST_LAYERS = [
+	{
+		rid: "f",
+		quality: "high",
+		scaleResolutionDownBy: 1
+	},
+	{
+		rid: "h",
+		quality: "medium",
+		scaleResolutionDownBy: 2
+	},
+	{
+		rid: "q",
+		quality: "low",
+		scaleResolutionDownBy: 4
+	}
+];
+z.object({
+	id: z.string().min(1).max(32),
+	name: z.string().regex(APP_RTC_NAME_PATTERN),
+	kind: z.enum(APP_RTC_PUBLICATION_KINDS),
+	delivery: z.enum(APP_RTC_DELIVERIES).optional(),
+	simulcast: z.boolean().optional()
+});
+const nameSchema = z.string().refine(isAppRtcName, "invalid name");
+const participantIdSchema = z.string().uuid();
+z.object({
+	ticket: z.string().min(1).max(4096),
+	participantId: participantIdSchema
+});
+z.object({ answer: sessionDescriptionSchema.refine((value) => value.type === "answer", "expected an answer") });
+z.union([z.object({ channels: z.array(z.object({
+	name: nameSchema,
+	delivery: z.enum(APP_RTC_DELIVERIES)
+})).min(1).max(APP_RTC_LIMITS.channelsPerMember) }), z.object({
+	offer: sessionDescriptionSchema.refine((value) => value.type === "offer", "expected an offer"),
+	tracks: z.array(z.object({
+		name: nameSchema,
+		kind: z.enum(["audio", "video"]),
+		mid: z.string().min(1).max(32),
+		simulcast: z.boolean().optional()
+	})).min(1).max(APP_RTC_LIMITS.tracksPerMember)
+})]);
+z.object({
+	ids: z.array(z.string().min(1).max(32)).min(1).max(APP_RTC_LIMITS.channelsPerMember + APP_RTC_LIMITS.tracksPerMember),
+	offer: sessionDescriptionSchema.refine((value) => value.type === "offer", "expected an offer").optional()
+});
+const subscriptionRefSchema = z.object({
+	participantId: participantIdSchema,
+	publicationId: z.string().min(1).max(32)
+});
+const qualitySchema = z.enum(APP_RTC_QUALITIES);
+z.object({
+	kind: z.enum(["data", "media"]),
+	items: z.array(subscriptionRefSchema.extend({ quality: qualitySchema.optional() })).min(1).max(APP_RTC_LIMITS.batch)
+});
+z.object({ items: z.array(subscriptionRefSchema.extend({
+	mid: z.string().min(1).max(32),
+	quality: qualitySchema.optional()
+})).min(1).max(APP_RTC_LIMITS.mediaSubscriptions) });
+z.object({
+	items: z.array(subscriptionRefSchema).min(1).max(APP_RTC_LIMITS.batch),
+	offer: sessionDescriptionSchema.refine((value) => value.type === "offer", "expected an offer").optional()
+});
+//#endregion
+//#region src/apis/app-room-rtc.ts
+var AppRtcError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "AppRtcError";
+	}
+};
+const SERVER_CODES = /* @__PURE__ */ new Set([
+	"RTC_UNAVAILABLE",
+	"RTC_FORBIDDEN",
+	"RTC_LIMIT_EXCEEDED",
+	"RTC_RATE_LIMITED",
+	"ROOM_NOT_FOUND",
+	"ROOM_EXPIRED"
+]);
+const toAppRtcError = (error) => {
+	if (error instanceof AppRtcError) return error;
+	if (error instanceof HttpError && SERVER_CODES.has(error.code)) return new AppRtcError(error.code, error.message);
+	return new AppRtcError("RTC_FAILED", error instanceof Error ? error.message : String(error));
+};
+const HEADER_BYTES = 5;
+const FLAG_BINARY = 1;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+function encodeAppRtcFrame(data, sequence) {
+	let payload;
+	let flags = 0;
+	if (data instanceof ArrayBuffer) {
+		payload = new Uint8Array(data);
+		flags = FLAG_BINARY;
+	} else if (ArrayBuffer.isView(data)) {
+		payload = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+		flags = FLAG_BINARY;
+	} else {
+		const json = JSON.stringify(data);
+		if (json === void 0) throw new TypeError("RTC message is not serializable");
+		payload = encoder.encode(json);
+	}
+	if (payload.byteLength > APP_RTC_LIMITS.messageBytes) throw new RangeError(`RTC message exceeds ${APP_RTC_LIMITS.messageBytes} bytes`);
+	const frame = new Uint8Array(HEADER_BYTES + payload.byteLength);
+	frame[0] = flags;
+	new DataView(frame.buffer).setUint32(1, sequence >>> 0);
+	frame.set(payload, HEADER_BYTES);
+	return frame;
+}
+function decodeAppRtcFrame(frame) {
+	if (frame.byteLength < HEADER_BYTES) return null;
+	const view = new DataView(frame);
+	const flags = view.getUint8(0);
+	const sequence = view.getUint32(1);
+	const payload = new Uint8Array(frame, HEADER_BYTES);
+	if (flags & FLAG_BINARY) return {
+		data: payload.slice().buffer,
+		sequence
+	};
+	try {
+		return {
+			data: JSON.parse(decoder.decode(payload)),
+			sequence
+		};
+	} catch {
+		return null;
+	}
+}
+const isNewerSequence = (next, last) => last === null || next !== last && next - last >>> 0 < 2147483648;
+const publicationsKey = (members) => members.map((member) => `${member.participantId}:${member.publications?.map((item) => item.id).join(",") ?? ""}`).join(";");
+const GATHER_TIMEOUT_MS = 2e3;
+const CONNECT_TIMEOUT_MS = 15e3;
+const PENDING_RELIABLE_FRAMES = 256;
+const LATEST_BACKLOG_BYTES = 65536;
+const RECONNECT_DELAYS_MS = [
+	500,
+	1e3,
+	2e3,
+	5e3,
+	1e4,
+	3e4
+];
+const RATE_LIMIT_RETRY_MS = 1e3;
+var ConnectionReplacedError = class extends Error {
+	constructor() {
+		super("RTC connection was replaced");
+		this.name = "ConnectionReplacedError";
+	}
+};
+const policyOf = (delivery) => delivery === "latest" ? {
+	ordered: false,
+	maxRetransmits: 0
+} : { ordered: true };
+const isSessionLost = (error) => error instanceof HttpError && (error.code === "RTC_STALE" || error.code === "RTC_SESSION_NOT_FOUND");
+const isRoomGone = (error) => error instanceof HttpError && (error.code === "ROOM_NOT_FOUND" || error.code === "ROOM_EXPIRED");
+const chunk = (items, size) => {
+	const chunks = [];
+	for (let index = 0; index < items.length; index += size) chunks.push(items.slice(index, index + size));
+	return chunks;
+};
+const mediaKey = (participantId, publicationId) => `${participantId}:${publicationId}`;
+var AppRtcChannel = class {
+	rtc;
+	name;
+	delivery;
+	handlers = /* @__PURE__ */ new Set();
+	peerHandlers = /* @__PURE__ */ new Set();
+	openPeers = /* @__PURE__ */ new Set();
+	publication = null;
+	pending = [];
+	offFlush = null;
+	sequence = 0;
+	closed = false;
+	constructor(rtc, name, delivery) {
+		this.rtc = rtc;
+		this.name = name;
+		this.delivery = delivery;
+	}
+	get peers() {
+		return [...this.openPeers];
+	}
+	send(data) {
+		if (this.closed || this.rtc.state === "closed") return false;
+		this.sequence = this.sequence + 1 >>> 0;
+		const frame = encodeAppRtcFrame(data, this.sequence);
+		const channel = this.publication?.channel;
+		if (channel?.readyState === "open" && this.pending.length === 0) return this.write(channel, frame);
+		if (this.delivery === "latest") this.pending = [frame];
+		else if (this.pending.length >= PENDING_RELIABLE_FRAMES) return false;
+		else this.pending.push(frame);
+		return true;
+	}
+	onMessage(handler) {
+		this.handlers.add(handler);
+		return () => this.handlers.delete(handler);
+	}
+	/** Reports when this client starts or stops receiving a peer's channel. */
+	onPeer(handler) {
+		this.peerHandlers.add(handler);
+		return () => this.peerHandlers.delete(handler);
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.handlers.clear();
+		this.peerHandlers.clear();
+		this.openPeers.clear();
+		this.pending = [];
+		this.offFlush?.();
+		this.offFlush = null;
+		this.rtc.closeChannel(this);
+	}
+	/** @internal */
+	get isOpen() {
+		return !this.closed;
+	}
+	/** @internal */
+	get publicationId() {
+		return this.publication?.id ?? null;
+	}
+	/** @internal */
+	attach(id, channel) {
+		this.offFlush?.();
+		this.publication = {
+			id,
+			channel
+		};
+		channel.binaryType = "arraybuffer";
+		channel.bufferedAmountLowThreshold = LATEST_BACKLOG_BYTES;
+		const flush = () => {
+			let sent = 0;
+			while (sent < this.pending.length) {
+				const frame = this.pending[sent];
+				if (!frame || !this.write(channel, frame)) break;
+				sent++;
+			}
+			this.pending = this.pending.slice(sent);
+		};
+		channel.addEventListener("open", flush);
+		channel.addEventListener("bufferedamountlow", flush);
+		this.offFlush = () => {
+			channel.removeEventListener("open", flush);
+			channel.removeEventListener("bufferedamountlow", flush);
+		};
+		if (channel.readyState === "open") flush();
+	}
+	/** @internal */
+	detach() {
+		this.offFlush?.();
+		this.offFlush = null;
+		this.publication = null;
+	}
+	/** @internal */
+	fail() {
+		this.close();
+	}
+	/** @internal */
+	deliver(from, data) {
+		for (const handler of this.handlers) handler({
+			from,
+			data
+		});
+	}
+	/** @internal */
+	setPeer(participantId, open) {
+		if (open ? this.openPeers.has(participantId) : !this.openPeers.delete(participantId)) return;
+		if (open) this.openPeers.add(participantId);
+		for (const handler of this.peerHandlers) handler({
+			participantId,
+			open
+		});
+	}
+	write(channel, frame) {
+		if (channel.bufferedAmount > (this.delivery === "latest" ? LATEST_BACKLOG_BYTES : 4194304)) return false;
+		try {
+			channel.send(frame);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+};
+var AppRoomRtc = class {
+	host;
+	_state = "connecting";
+	pc = null;
+	sessionId = null;
+	queue = Promise.resolve();
+	releasePending = Promise.resolve();
+	reconcileQueued = false;
+	reconcileFailures = 0;
+	reconnectAttempt = 0;
+	reconnectTimer = null;
+	generation = 0;
+	filter = null;
+	channels = /* @__PURE__ */ new Map();
+	channelsToPublish = /* @__PURE__ */ new Set();
+	remoteData = /* @__PURE__ */ new Map();
+	localTracks = /* @__PURE__ */ new Map();
+	remoteMedia = /* @__PURE__ */ new Map();
+	mediaByMid = /* @__PURE__ */ new Map();
+	stateHandlers = /* @__PURE__ */ new Set();
+	trackHandlers = /* @__PURE__ */ new Set();
+	offMembers;
+	constructor(host) {
+		this.host = host;
+		let published = "";
+		this.offMembers = host.onMembersChanged((members) => {
+			const next = publicationsKey(members);
+			if (next === published) return;
+			published = next;
+			this.scheduleReconcile();
+		});
+	}
+	get state() {
+		return this._state;
+	}
+	get tracks() {
+		const tracks = [];
+		for (const [key, item] of this.remoteMedia) {
+			if (!item.track) continue;
+			tracks.push({
+				participantId: item.participantId,
+				name: item.name,
+				kind: item.kind,
+				track: item.track,
+				quality: item.quality ?? null,
+				setQuality: (quality) => this.setQuality(key, quality)
+			});
+		}
+		return tracks;
+	}
+	get candidates() {
+		return this.mediaCandidates().map(({ candidate }) => candidate);
+	}
+	onStateChange(handler) {
+		this.stateHandlers.add(handler);
+		return () => this.stateHandlers.delete(handler);
+	}
+	onTracksChanged(handler) {
+		this.trackHandlers.add(handler);
+		return () => this.trackHandlers.delete(handler);
+	}
+	select(filter) {
+		this.filter = filter;
+		this.scheduleReconcile();
+	}
+	channel(name, options = {}) {
+		if (!isAppRtcName(name)) throw new AppRtcError("RTC_FAILED", `invalid RTC channel name: ${name}`);
+		const delivery = options.delivery ?? "reliable";
+		const existing = this.channels.get(name);
+		if (existing?.isOpen) {
+			if (existing.delivery !== delivery) throw new AppRtcError("RTC_FAILED", `RTC channel ${name} is already open with ${existing.delivery} delivery`);
+			return existing;
+		}
+		if (this._state === "closed") throw new AppRtcError("RTC_CLOSED", "RTC connection is closed");
+		const channel = new AppRtcChannel(this, name, delivery);
+		this.channels.set(name, channel);
+		this.publishChannel(channel);
+		this.scheduleReconcile();
+		return channel;
+	}
+	async publish(tracks) {
+		if (this._state === "closed") throw new AppRtcError("RTC_CLOSED", "RTC connection is closed");
+		const inputs = Object.entries(tracks);
+		for (const [name] of inputs) {
+			if (!isAppRtcName(name)) throw new AppRtcError("RTC_FAILED", `invalid RTC track name: ${name}`);
+			if (this.localTracks.has(name)) throw new AppRtcError("RTC_FAILED", `RTC track ${name} is already published`);
+		}
+		if (this.localTracks.size + inputs.length > APP_RTC_LIMITS.tracksPerMember) throw new AppRtcError("RTC_LIMIT_EXCEEDED", `at most ${APP_RTC_LIMITS.tracksPerMember} tracks per member`);
+		const entries = inputs.map(([name, input]) => {
+			const { track, simulcast } = "track" in input ? input : {
+				track: input,
+				simulcast: false
+			};
+			const kind = track.kind === "audio" ? "audio" : "video";
+			return this.localEntry(name, kind, track, simulcast === true && kind === "video");
+		});
+		for (const entry of entries) this.localTracks.set(entry.name, entry);
+		try {
+			await this.enqueue(() => this.publishTracks(entries.map((entry) => entry.name)));
+		} catch (error) {
+			if (!(error instanceof ConnectionReplacedError)) {
+				for (const entry of entries) this.dropLocal(entry);
+				throw toAppRtcError(error);
+			}
+		}
+		return Object.fromEntries(entries.map((entry) => [entry.name, this.localHandle(entry)]));
+	}
+	async stats() {
+		return this.pc ? readRtcTransportStats(await this.pc.getStats()) : {
+			path: null,
+			relayProtocol: null,
+			rttMs: null
+		};
+	}
+	close() {
+		if (this._state === "closed") return;
+		this.setState("closed");
+		this.offMembers();
+		if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+		for (const channel of this.channels.values()) channel.close();
+		for (const entry of this.localTracks.values()) entry.track.removeEventListener("ended", entry.onEnded);
+		this.teardown(true);
+	}
+	async shutdown() {
+		this.close();
+		await this.releasePending;
+	}
+	/** @internal */
+	async start() {
+		try {
+			await this.connect();
+		} catch (error) {
+			throw toAppRtcError(error);
+		}
+	}
+	/** @internal */
+	async verify() {
+		if (this._state === "closed" || !this.sessionId) return;
+		try {
+			await this.request("GET", `/${this.sessionId}`);
+		} catch (error) {
+			if (isSessionLost(error)) this.reconnect();
+		}
+	}
+	/** @internal */
+	closeChannel(channel) {
+		if (this.channels.get(channel.name) === channel) this.channels.delete(channel.name);
+		const id = channel.publicationId;
+		channel.detach();
+		if (id) this.enqueue(() => this.unpublishData([id])).catch(() => void 0);
+		this.scheduleReconcile();
+	}
+	localEntry(name, kind, track, simulcast) {
+		const entry = {
+			name,
+			kind,
+			track,
+			simulcast,
+			transceiver: null,
+			id: null,
+			ended: /* @__PURE__ */ new Set(),
+			onEnded: () => void 0
+		};
+		entry.onEnded = () => {
+			if (this.localTracks.get(name) !== entry) return;
+			for (const handler of entry.ended) handler();
+			this.stopLocal(entry).catch(() => void 0);
+		};
+		track.addEventListener("ended", entry.onEnded);
+		return entry;
+	}
+	localHandle(entry) {
+		return {
+			name: entry.name,
+			kind: entry.kind,
+			simulcast: entry.simulcast,
+			get track() {
+				return entry.track;
+			},
+			replace: async (track) => {
+				if (track.kind !== entry.kind) throw new AppRtcError("RTC_FAILED", `replace ${entry.name} with another ${entry.kind} track`);
+				if (this.localTracks.get(entry.name) !== entry) throw new AppRtcError("RTC_CLOSED", `RTC track ${entry.name} has stopped`);
+				entry.track.removeEventListener("ended", entry.onEnded);
+				entry.track = track;
+				track.addEventListener("ended", entry.onEnded);
+				await entry.transceiver?.sender.replaceTrack(track);
+			},
+			onEnded: (handler) => {
+				entry.ended.add(handler);
+				return () => entry.ended.delete(handler);
+			},
+			stop: () => this.stopLocal(entry)
+		};
+	}
+	dropLocal(entry) {
+		entry.track.removeEventListener("ended", entry.onEnded);
+		if (this.localTracks.get(entry.name) === entry) this.localTracks.delete(entry.name);
+	}
+	stopLocal(entry) {
+		if (this.localTracks.get(entry.name) !== entry) return Promise.resolve();
+		this.dropLocal(entry);
+		return this.enqueue(() => this.unpublishTrack(entry)).catch((error) => {
+			if (error instanceof ConnectionReplacedError) return;
+			throw toAppRtcError(error);
+		});
+	}
+	async publishTracks(names) {
+		const pc = this.requirePc();
+		const entries = names.flatMap((name) => {
+			const entry = this.localTracks.get(name);
+			return entry && !entry.id ? [entry] : [];
+		});
+		if (entries.length === 0) return;
+		for (const entry of entries) entry.transceiver = pc.addTransceiver(entry.track, {
+			direction: "sendonly",
+			...entry.simulcast ? { sendEncodings: APP_RTC_SIMULCAST_LAYERS.map(({ rid, scaleResolutionDownBy }) => ({
+				rid,
+				scaleResolutionDownBy
+			})) } : {}
+		});
+		const offer = await this.localOffer(pc);
+		let result;
+		try {
+			result = await this.request("POST", `/${this.sessionId}/publish`, {
+				offer,
+				tracks: entries.map((entry) => ({
+					name: entry.name,
+					kind: entry.kind,
+					mid: entry.transceiver?.mid ?? "",
+					...entry.simulcast ? { simulcast: true } : {}
+				}))
+			});
+		} catch (error) {
+			if (error instanceof ConnectionReplacedError) throw error;
+			await this.settleOffer(pc, void 0).catch(() => void 0);
+			for (const entry of entries) {
+				entry.transceiver?.stop();
+				entry.transceiver = null;
+			}
+			throw error;
+		}
+		await this.settleOffer(pc, result.answer);
+		for (const publication of result.publications) {
+			const entry = entries.find((candidate) => candidate.name === publication.name);
+			if (entry) entry.id = publication.id;
+		}
+	}
+	async unpublishTrack(entry) {
+		if (!entry.id || !entry.transceiver || !this.pc) return;
+		const id = entry.id;
+		entry.transceiver.stop();
+		await this.offerExchange(this.pc, (offer) => this.request("POST", `/${this.sessionId}/unpublish`, {
+			ids: [id],
+			offer
+		}));
+		entry.id = null;
+	}
+	publishChannel(channel) {
+		this.channelsToPublish.add(channel);
+		if (this.channelsToPublish.size > 1 || !this.pc) return;
+		this.enqueue(async () => {
+			const batch = [...this.channelsToPublish];
+			this.channelsToPublish.clear();
+			try {
+				await this.publishChannels(batch);
+			} catch (error) {
+				if (isSessionLost(error) || error instanceof ConnectionReplacedError) throw error;
+				if (error instanceof HttpError && error.code === "RTC_RATE_LIMITED") {
+					setTimeout(() => {
+						for (const item of batch) if (item.isOpen) this.publishChannel(item);
+					}, RATE_LIMIT_RETRY_MS);
+					return;
+				}
+				for (const item of batch) item.fail();
+				console.warn("[Cohub AppRtc] failed to publish channels", error);
+			}
+		}).catch(() => void 0);
+	}
+	async connect() {
+		const generation = ++this.generation;
+		const opened = await this.send("POST", "", {
+			ticket: this.host.ticket,
+			participantId: this.host.participantId()
+		});
+		if (generation !== this.generation || this._state === "closed") {
+			this.send("DELETE", `/${opened.sessionId}`).catch(() => void 0);
+			return;
+		}
+		this.sessionId = opened.sessionId;
+		const configuration = {
+			iceServers: opened.iceServers,
+			bundlePolicy: "max-bundle"
+		};
+		let pc;
+		try {
+			pc = this.host.createPeerConnection?.(configuration) ?? new RTCPeerConnection(configuration);
+		} catch (error) {
+			await this.shutdown();
+			throw error;
+		}
+		this.pc = pc;
+		pc.addEventListener("connectionstatechange", () => {
+			if (this.pc !== pc) return;
+			if (pc.connectionState === "connected") {
+				this.reconnectAttempt = 0;
+				this.setState("connected");
+			} else if (pc.connectionState === "failed") this.reconnect();
+		});
+		pc.addEventListener("track", (event) => this.onTrack(event));
+		const ready = (async () => {
+			await this.answerOffer(opened.offer);
+			await this.connected(pc);
+		})();
+		this.queue = ready.catch(() => void 0);
+		try {
+			await ready;
+		} catch (error) {
+			if (generation === this.generation) this.reconnect();
+			throw error;
+		}
+		this.channelsToPublish.clear();
+		const republish = [...this.channels.values()].filter((channel) => channel.isOpen);
+		const tracks = [...this.localTracks.keys()];
+		await Promise.all([republish.length ? this.enqueue(() => this.publishChannels(republish)).catch((error) => {
+			if (error instanceof ConnectionReplacedError || isSessionLost(error)) return;
+			for (const channel of republish) channel.fail();
+			console.warn("[Cohub AppRtc] failed to publish channels on the new connection", error);
+		}) : null, tracks.length ? this.enqueue(() => this.publishTracks(tracks)).catch((error) => {
+			if (error instanceof ConnectionReplacedError || isSessionLost(error)) return;
+			console.warn("[Cohub AppRtc] failed to publish tracks on the new connection", error);
+		}) : null]);
+		this.scheduleReconcile();
+	}
+	connected(pc) {
+		if (pc.connectionState === "connected") return Promise.resolve();
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => done(/* @__PURE__ */ new Error("RTC connection timed out")), CONNECT_TIMEOUT_MS);
+			const done = (error) => {
+				clearTimeout(timer);
+				pc.removeEventListener("connectionstatechange", check);
+				if (error) reject(error);
+				else resolve();
+			};
+			const check = () => {
+				if (pc.connectionState === "connected") done();
+				else if (pc.connectionState === "failed" || pc.connectionState === "closed") done(/* @__PURE__ */ new Error("RTC connection failed"));
+			};
+			pc.addEventListener("connectionstatechange", check);
+		});
+	}
+	reconnect() {
+		if (this._state === "closed" || this.reconnectTimer) return;
+		this.setState(this._state === "connecting" ? "connecting" : "reconnecting");
+		this.teardown(true);
+		const delay = RECONNECT_DELAYS_MS[Math.min(this.reconnectAttempt, RECONNECT_DELAYS_MS.length - 1)] ?? 3e4;
+		this.reconnectAttempt += 1;
+		this.reconnectTimer = setTimeout(() => {
+			this.reconnectTimer = null;
+			this.connect().catch((error) => {
+				if (isRoomGone(error) || error instanceof HttpError && (error.status === 403 || error.status === 503)) this.close();
+				else this.reconnect();
+			});
+		}, delay);
+	}
+	teardown(release) {
+		this.generation += 1;
+		const sessionId = this.sessionId;
+		this.sessionId = null;
+		this.queue = Promise.resolve();
+		for (const channel of this.channels.values()) channel.detach();
+		for (const item of this.remoteData.values()) this.dropRemoteData(item);
+		this.remoteData.clear();
+		for (const item of this.localTracks.values()) {
+			item.transceiver = null;
+			item.id = null;
+		}
+		const hadTracks = this.remoteMedia.size > 0;
+		this.remoteMedia.clear();
+		this.mediaByMid.clear();
+		this.pc?.close();
+		this.pc = null;
+		if (hadTracks) this.notifyTracks();
+		if (release && sessionId) {
+			this.releasePending = Promise.allSettled([this.releasePending, this.send("DELETE", `/${sessionId}`)]).then((results) => {
+				const failed = results.find((result) => result.status === "rejected");
+				if (failed?.status === "rejected") throw failed.reason;
+			});
+			this.releasePending.catch(() => void 0);
+		}
+	}
+	enqueue(operation) {
+		const generation = this.generation;
+		const run = async () => {
+			if (generation !== this.generation || !this.pc || !this.sessionId) throw new ConnectionReplacedError();
+			try {
+				return await operation();
+			} catch (error) {
+				if (isSessionLost(error)) this.reconnect();
+				throw error;
+			}
+		};
+		const next = this.queue.then(run, run);
+		this.queue = next.catch(() => void 0);
+		return next;
+	}
+	async publishChannels(channels) {
+		const pc = this.requirePc();
+		const open = channels.filter((channel) => channel.isOpen && !channel.publicationId);
+		if (open.length === 0) return;
+		const result = await this.request("POST", `/${this.sessionId}/publish`, { channels: open.map((channel) => ({
+			name: channel.name,
+			delivery: channel.delivery
+		})) });
+		for (const publication of result.publications) {
+			const channel = open.find((item) => item.name === publication.name);
+			const id = result.channelIds?.[publication.id];
+			if (!channel || id === void 0) continue;
+			const dataChannel = pc.createDataChannel(publication.name, {
+				negotiated: true,
+				id,
+				...policyOf(channel.delivery)
+			});
+			channel.attach(publication.id, dataChannel);
+			if (!channel.isOpen) await this.unpublishData([publication.id]);
+		}
+	}
+	async unpublishData(ids) {
+		await this.request("POST", `/${this.sessionId}/unpublish`, { ids });
+	}
+	async settleOffer(pc, answer) {
+		if (answer) await pc.setRemoteDescription(answer);
+		else if (pc.signalingState === "have-local-offer") await pc.setLocalDescription({ type: "rollback" });
+	}
+	async offerExchange(pc, send) {
+		const offer = await this.localOffer(pc);
+		let answer;
+		try {
+			({answer} = await send(offer));
+		} catch (error) {
+			if (!(error instanceof ConnectionReplacedError)) await this.settleOffer(pc, void 0).catch(() => void 0);
+			throw error;
+		}
+		await this.settleOffer(pc, answer);
+	}
+	scheduleReconcile() {
+		if (this.reconcileQueued || !this.pc || this._state === "closed") return;
+		this.reconcileQueued = true;
+		this.enqueue(async () => {
+			this.reconcileQueued = false;
+			await this.reconcile();
+			this.reconcileFailures = 0;
+		}).catch((error) => {
+			this.reconcileQueued = false;
+			if (isSessionLost(error) || error instanceof ConnectionReplacedError) return;
+			console.warn("[Cohub AppRtc] failed to update subscriptions", error);
+			if (error instanceof HttpError && error.code === "RTC_LIMIT_EXCEEDED") return;
+			const delay = RECONNECT_DELAYS_MS[Math.min(this.reconcileFailures, RECONNECT_DELAYS_MS.length - 1)] ?? 3e4;
+			this.reconcileFailures += 1;
+			const generation = this.generation;
+			setTimeout(() => {
+				if (generation === this.generation) this.scheduleReconcile();
+			}, delay);
+		});
+	}
+	mediaCandidates() {
+		const self = this.host.participantId();
+		const candidates = [];
+		for (const member of this.host.members()) {
+			if (member.participantId === self) continue;
+			for (const publication of member.publications ?? []) {
+				if (publication.kind === "data") continue;
+				candidates.push({
+					publication,
+					candidate: {
+						participantId: member.participantId,
+						name: publication.name,
+						kind: publication.kind,
+						simulcast: publication.simulcast === true,
+						subscribed: this.remoteMedia.has(mediaKey(member.participantId, publication.id))
+					}
+				});
+			}
+		}
+		return candidates;
+	}
+	async reconcile() {
+		const self = this.host.participantId();
+		const wantedData = /* @__PURE__ */ new Map();
+		for (const member of this.host.members()) {
+			if (member.participantId === self) continue;
+			for (const publication of member.publications ?? []) {
+				if (publication.kind !== "data") continue;
+				const channel = this.channels.get(publication.name);
+				if (channel?.isOpen && channel.delivery === (publication.delivery ?? "reliable")) wantedData.set(mediaKey(member.participantId, publication.id), {
+					participantId: member.participantId,
+					publicationId: publication.id,
+					name: publication.name,
+					delivery: channel.delivery
+				});
+			}
+		}
+		const wantedMedia = /* @__PURE__ */ new Map();
+		for (const { candidate, publication } of this.mediaCandidates()) {
+			if (wantedMedia.size >= APP_RTC_LIMITS.mediaSubscriptions) break;
+			if (this.filter && !this.filter(candidate)) continue;
+			const key = mediaKey(candidate.participantId, publication.id);
+			const quality = this.remoteMedia.get(key)?.quality ?? (candidate.simulcast ? "high" : void 0);
+			wantedMedia.set(key, {
+				participantId: candidate.participantId,
+				publicationId: publication.id,
+				name: candidate.name,
+				kind: candidate.kind,
+				...quality ? { quality } : {}
+			});
+		}
+		await this.reconcileData(wantedData);
+		await this.reconcileMedia(wantedMedia);
+		if ([...wantedData.keys()].some((key) => !this.remoteData.has(key)) || [...wantedMedia.keys()].some((key) => !this.remoteMedia.has(key))) throw new AppRtcError("RTC_FAILED", "Some RTC subscriptions could not be established");
+	}
+	dropRemoteData(item) {
+		item.channel.close();
+		this.channels.get(item.name)?.setPeer(item.participantId, false);
+	}
+	async reconcileData(wanted) {
+		const pc = this.requirePc();
+		const stale = [...this.remoteData].filter(([key]) => !wanted.has(key));
+		for (const batch of chunk(stale, APP_RTC_LIMITS.batch)) {
+			await this.request("POST", `/${this.sessionId}/unsubscribe`, { items: batch.map(([, item]) => ({
+				participantId: item.participantId,
+				publicationId: item.publicationId
+			})) });
+			for (const [key, item] of batch) {
+				this.dropRemoteData(item);
+				this.remoteData.delete(key);
+			}
+		}
+		const missing = [...wanted].filter(([key]) => !this.remoteData.has(key)).map(([, item]) => item);
+		for (const batch of chunk(missing, APP_RTC_LIMITS.batch)) {
+			const result = await this.request("POST", `/${this.sessionId}/subscribe`, {
+				kind: "data",
+				items: batch.map(({ participantId, publicationId }) => ({
+					participantId,
+					publicationId
+				}))
+			});
+			for (const subscription of result.subscriptions) {
+				const item = batch.find((entry) => entry.participantId === subscription.participantId && entry.publicationId === subscription.publicationId);
+				if (!item || subscription.channelId === void 0) continue;
+				const channel = pc.createDataChannel(item.name, {
+					negotiated: true,
+					id: subscription.channelId,
+					...policyOf(item.delivery)
+				});
+				channel.binaryType = "arraybuffer";
+				const remote = {
+					name: item.name,
+					participantId: item.participantId,
+					publicationId: item.publicationId,
+					channel,
+					last: null
+				};
+				channel.addEventListener("message", (event) => this.onData(remote, event.data));
+				channel.addEventListener("open", () => {
+					if (this.remoteData.get(mediaKey(remote.participantId, remote.publicationId)) === remote) this.channels.get(remote.name)?.setPeer(remote.participantId, true);
+				});
+				this.remoteData.set(mediaKey(item.participantId, item.publicationId), remote);
+			}
+		}
+	}
+	async reconcileMedia(wanted) {
+		const stale = [...this.remoteMedia].filter(([key]) => !wanted.has(key));
+		const missing = [...wanted].filter(([key]) => !this.remoteMedia.has(key)).map(([, item]) => item);
+		const moves = [];
+		for (const to of [...missing]) {
+			const index = stale.findIndex(([, receiver]) => receiver.kind === to.kind);
+			const found = index >= 0 ? stale.splice(index, 1)[0] : void 0;
+			if (!found) continue;
+			moves.push({
+				from: found[0],
+				receiver: found[1],
+				to
+			});
+			missing.splice(missing.indexOf(to), 1);
+		}
+		if (moves.length) {
+			const moved = await this.retarget(moves.map(({ receiver, to }) => ({
+				...to,
+				mid: receiver.mid
+			})));
+			for (const { from, receiver, to } of moves) if (moved.has(receiver.mid)) {
+				this.remoteMedia.delete(from);
+				this.remoteMedia.set(mediaKey(to.participantId, to.publicationId), {
+					...to,
+					mid: receiver.mid,
+					track: receiver.track
+				});
+				this.mediaByMid.set(receiver.mid, mediaKey(to.participantId, to.publicationId));
+			} else {
+				stale.push([from, receiver]);
+				missing.push(to);
+			}
+			if (moved.size) this.notifyTracks();
+		}
+		await this.unsubscribeMedia(stale);
+		await this.subscribeMedia(missing);
+	}
+	async retarget(items) {
+		try {
+			const result = await this.request("PATCH", `/${this.sessionId}/media`, { items: items.map(({ participantId, publicationId, mid, quality }) => ({
+				participantId,
+				publicationId,
+				mid,
+				...quality ? { quality } : {}
+			})) });
+			if (result.offer) await this.answerOffer(result.offer);
+			return new Set(result.updated.map((item) => item.mid));
+		} catch (error) {
+			if (error instanceof ConnectionReplacedError || isSessionLost(error)) throw error;
+			return /* @__PURE__ */ new Set();
+		}
+	}
+	async setQuality(key, quality) {
+		await this.enqueue(async () => {
+			const item = this.remoteMedia.get(key);
+			if (!item || item.quality === void 0 || item.quality === quality) return;
+			if ((await this.retarget([{
+				...item,
+				quality
+			}])).has(item.mid)) {
+				item.quality = quality;
+				this.notifyTracks();
+			}
+		}).catch((error) => {
+			if (error instanceof ConnectionReplacedError) return;
+			throw toAppRtcError(error);
+		});
+	}
+	async unsubscribeMedia(stale) {
+		if (stale.length === 0) return;
+		const pc = this.requirePc();
+		for (const [, item] of stale) {
+			pc.getTransceivers().find((transceiver) => transceiver.mid === item.mid)?.stop();
+			item.track = null;
+		}
+		this.notifyTracks();
+		await this.offerExchange(pc, (offer) => this.request("POST", `/${this.sessionId}/unsubscribe`, {
+			items: stale.map(([, item]) => ({
+				participantId: item.participantId,
+				publicationId: item.publicationId
+			})),
+			offer
+		}));
+		for (const [key, item] of stale) {
+			this.remoteMedia.delete(key);
+			this.mediaByMid.delete(item.mid);
+		}
+	}
+	async subscribeMedia(missing) {
+		if (missing.length === 0) return;
+		const result = await this.request("POST", `/${this.sessionId}/subscribe`, {
+			kind: "media",
+			items: missing.map(({ participantId, publicationId, quality }) => ({
+				participantId,
+				publicationId,
+				...quality ? { quality } : {}
+			}))
+		});
+		for (const subscription of result.subscriptions) {
+			const item = missing.find((entry) => entry.participantId === subscription.participantId && entry.publicationId === subscription.publicationId);
+			if (!item || !subscription.mid) continue;
+			const key = mediaKey(item.participantId, item.publicationId);
+			this.remoteMedia.set(key, {
+				...item,
+				mid: subscription.mid,
+				track: null
+			});
+			this.mediaByMid.set(subscription.mid, key);
+		}
+		if (!result.offer) return;
+		try {
+			await this.answerOffer(result.offer);
+		} catch (error) {
+			if (!(error instanceof ConnectionReplacedError)) this.reconnect();
+			throw error;
+		}
+	}
+	async answerOffer(offer) {
+		const pc = this.requirePc();
+		await pc.setRemoteDescription(offer);
+		await pc.setLocalDescription(await pc.createAnswer());
+		await waitForIceGathering(pc, GATHER_TIMEOUT_MS);
+		const answer = pc.localDescription;
+		if (!answer) throw new Error("the browser produced no answer");
+		await this.request("PUT", `/${this.sessionId}`, { answer: {
+			type: "answer",
+			sdp: answer.sdp
+		} });
+	}
+	async localOffer(pc) {
+		await pc.setLocalDescription(await pc.createOffer());
+		await waitForIceGathering(pc, GATHER_TIMEOUT_MS);
+		const offer = pc.localDescription;
+		if (!offer) throw new Error("the browser produced no offer");
+		return {
+			type: "offer",
+			sdp: offer.sdp
+		};
+	}
+	async request(method, path, body) {
+		const generation = this.generation;
+		const settled = await this.send(method, path, body).then((value) => ({ value }), (error) => ({ error }));
+		if (generation !== this.generation) throw new ConnectionReplacedError();
+		if ("error" in settled) throw settled.error;
+		return settled.value;
+	}
+	send(method, path, body) {
+		const url = `${this.host.hosted ? `/api/rooms/${encodeURIComponent(this.host.roomId)}/rtc` : `/api/apps/${encodeURIComponent(this.host.appId)}/realtime/rooms/${encodeURIComponent(this.host.roomId)}/rtc`}${path}`;
+		return this.host.transport.request(url, {
+			method,
+			...body === void 0 ? {} : {
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(body)
+			}
+		});
+	}
+	requirePc() {
+		if (!this.pc || !this.sessionId) throw new ConnectionReplacedError();
+		return this.pc;
+	}
+	onData(remote, raw) {
+		if (!(raw instanceof ArrayBuffer)) return;
+		const frame = decodeAppRtcFrame(raw);
+		if (!frame) return;
+		const channel = this.channels.get(remote.name);
+		if (!channel?.isOpen) return;
+		if (channel.delivery === "latest") {
+			if (!isNewerSequence(frame.sequence, remote.last)) return;
+			remote.last = frame.sequence;
+		}
+		channel.deliver(remote.participantId, frame.data);
+	}
+	onTrack(event) {
+		const mid = event.transceiver.mid;
+		const key = mid ? this.mediaByMid.get(mid) : void 0;
+		const item = key ? this.remoteMedia.get(key) : void 0;
+		if (!item || !mid) return;
+		item.track = event.track;
+		event.track.addEventListener("ended", () => {
+			const current = this.mediaByMid.get(mid);
+			const owner = current ? this.remoteMedia.get(current) : void 0;
+			if (owner?.track === event.track) {
+				owner.track = null;
+				this.notifyTracks();
+			}
+		});
+		this.notifyTracks();
+	}
+	notifyTracks() {
+		const tracks = this.tracks;
+		for (const handler of this.trackHandlers) handler(tracks);
+	}
+	setState(state) {
+		if (this._state === state) return;
+		this._state = state;
+		for (const handler of this.stateHandlers) handler(state);
+	}
+};
+//#endregion
+//#region src/apis/app-realtime.ts
+var app_realtime_exports = /* @__PURE__ */ __exportAll({
+	AppRealtimeApi: () => AppRealtimeApi,
+	AppRoom: () => AppRoom,
+	WorkRealtimeApi: () => WorkRealtimeApi,
+	WorkRoom: () => WorkRoom
+});
+const randomId = () => globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+const textEncoder = new TextEncoder();
+const byteLength = (text) => textEncoder.encode(text).byteLength;
+/**
+* Ceiling on deltas held during a join, so a stalled handshake cannot buffer without
+* limit. Dropping the tail needs no extra signal: the gap detection below reports it.
+*/
+const APP_ROOM_MAX_JOIN_BUFFER = 512;
+/** Room events that mutate state, so they must not be applied before the join snapshot. */
+const APP_ROOM_DELTA_EVENTS = /* @__PURE__ */ new Set([
+	"realtime.room.event",
+	"realtime.room.member.joined",
+	"realtime.room.member.left",
+	"realtime.room.presence.updated",
+	"realtime.room.publications.updated"
+]);
+const APP_ROOM_MEMBER_EVENTS = /* @__PURE__ */ new Set([
+	"realtime.room.member.joined",
+	"realtime.room.member.left",
+	"realtime.room.presence.updated",
+	"realtime.room.publications.updated"
+]);
+const requestError = (event) => {
+	const payload = event.payload;
+	return new Error(typeof payload.message === "string" ? payload.message : typeof payload.code === "string" ? payload.code : "room request failed");
+};
+const isRoomEvent = (event, roomId) => {
+	if (event.domain !== "room") return false;
+	return event.payload.roomId === roomId || event.rooms?.includes(`room:${roomId}`);
+};
+var AppRoom = class {
+	websocket;
+	admission;
+	appContext;
+	id;
+	code;
+	createdAt;
+	expiresAt;
+	maxParticipants;
+	seatPerUser;
+	/** Opaque, stable identity of this viewer inside the room. */
+	userKey;
+	_participantId;
+	_state = "connecting";
+	_members = [];
+	joinBuffer = null;
+	lastSequence = 0;
+	hasJoined = false;
+	explicitLeave = false;
+	expiryTimer = null;
+	pending = /* @__PURE__ */ new Map();
+	handlers = /* @__PURE__ */ new Map();
+	allHandlers = /* @__PURE__ */ new Set();
+	stateHandlers = /* @__PURE__ */ new Set();
+	membersHandlers = /* @__PURE__ */ new Set();
+	outOfSyncHandlers = /* @__PURE__ */ new Set();
+	sendErrorHandlers = /* @__PURE__ */ new Set();
+	offEvent;
+	offOpen;
+	offClose;
+	offReconnecting;
+	instanceId = randomId().replace(/[^A-Za-z0-9_-]/g, "");
+	rtcConnection = null;
+	constructor(websocket, admission, appContext) {
+		this.websocket = websocket;
+		this.admission = admission;
+		this.appContext = appContext;
+		this.id = admission.room.id;
+		this.code = admission.room.code;
+		this.createdAt = admission.room.createdAt;
+		this.expiresAt = admission.room.expiresAt;
+		this.maxParticipants = admission.room.maxParticipants;
+		this.seatPerUser = admission.room.seatPerUser === true;
+		this.userKey = admission.userKey;
+		this._participantId = admission.participantId;
+		this.offEvent = websocket.on("event", (event) => this.handleEvent(event));
+		this.offOpen = websocket.on("open", () => {
+			if (!this.hasJoined || this.explicitLeave || this._state === "expired" || this._state === "closed") return;
+			this.rejoin();
+		});
+		this.offReconnecting = websocket.on("reconnecting", () => {
+			if (this.hasJoined && !this.explicitLeave) this.setState("reconnecting");
+		});
+		this.offClose = websocket.on("close", ({ willReconnect }) => {
+			this.rejectPending(/* @__PURE__ */ new Error("room connection closed"));
+			if (this.explicitLeave || !willReconnect) {
+				if (this._state !== "expired") this.setState("closed");
+				this.hasJoined = false;
+				this.dispose();
+			} else if (this.hasJoined) this.setState("reconnecting");
+		});
+		const delay = Math.max(0, Date.parse(this.expiresAt) - Date.now());
+		this.expiryTimer = setTimeout(() => this.expire(), Math.min(delay, 2147e6));
+	}
+	get state() {
+		return this._state;
+	}
+	/**
+	* Identity of this connection inside the room. A `seatPerUser` join can take over a
+	* seat the viewer already holds, so this may differ from the id issued at admission.
+	*/
+	get participantId() {
+		return this._participantId;
+	}
+	get members() {
+		return this._members.slice();
+	}
+	get sequence() {
+		return this.lastSequence;
+	}
+	async connect(options = {}) {
+		if (this.explicitLeave || this.state === "closed" || this.state === "expired") throw new Error("room is closed");
+		if (this.hasJoined) return this;
+		if (options.after !== void 0 && (!Number.isSafeInteger(options.after) || options.after < 0)) throw new Error("after must be a non-negative safe integer");
+		this.lastSequence = options.after ?? 0;
+		await this.joinOverWebsocket(false, options.after);
+		return this;
+	}
+	subscribe(type, handler) {
+		const handlers = this.handlers.get(type) ?? /* @__PURE__ */ new Set();
+		handlers.add(handler);
+		this.handlers.set(type, handlers);
+		return () => handlers.delete(handler);
+	}
+	subscribeAll(handler) {
+		this.allHandlers.add(handler);
+		return () => this.allHandlers.delete(handler);
+	}
+	onStateChange(handler) {
+		this.stateHandlers.add(handler);
+		return () => this.stateHandlers.delete(handler);
+	}
+	onMembersChanged(handler) {
+		this.membersHandlers.add(handler);
+		return () => this.membersHandlers.delete(handler);
+	}
+	onOutOfSync(handler) {
+		this.outOfSyncHandlers.add(handler);
+		return () => this.outOfSyncHandlers.delete(handler);
+	}
+	/** Reports failures of {@link send}, which has no ack to reject. */
+	onSendError(handler) {
+		this.sendErrorHandlers.add(handler);
+		return () => this.sendErrorHandlers.delete(handler);
+	}
+	/**
+	* Publishes without waiting for the server ack, for high-frequency traffic such as
+	* input frames. Awaiting {@link publish} instead caps a loop at `1000 / rtt` events
+	* per second. Ordering still holds, but failures surface through
+	* {@link onSendError} rather than a rejected promise, and calls are ignored while
+	* the room is not joined; watch {@link onStateChange} to know when it resumes.
+	*/
+	send(type, data) {
+		if (this._state !== "joined" || !this.hasJoined) return;
+		const failure = this.validateSend(type, data);
+		if (failure) {
+			for (const handler of this.sendErrorHandlers) handler(failure);
+			return;
+		}
+		this.websocket.publishRealtimeRoom({
+			roomId: this.id,
+			event: type,
+			data
+		}).catch((error) => {
+			const reason = error instanceof Error ? error : new Error(String(error));
+			for (const handler of this.sendErrorHandlers) handler(reason);
+		});
+	}
+	validateSend(type, data) {
+		if (!REALTIME_ROOM_EVENT_NAME_PATTERN.test(type)) return /* @__PURE__ */ new Error(`invalid room event name: ${type}`);
+		let encoded;
+		try {
+			encoded = JSON.stringify(data);
+		} catch {
+			return /* @__PURE__ */ new Error("room event data is not serializable");
+		}
+		if (encoded === void 0) return /* @__PURE__ */ new Error("room event data is not serializable");
+		if (byteLength(encoded) > 16384) return /* @__PURE__ */ new Error("room event payload is too large");
+		return null;
+	}
+	async publish(type, data, options) {
+		this.assertJoined();
+		const failure = this.validateSend(type, data);
+		if (failure) throw failure;
+		const requestId = randomId();
+		const response = await this.request(requestId, /* @__PURE__ */ new Set(["realtime.room.request.ok"]), () => this.websocket.publishRealtimeRoom({
+			roomId: this.id,
+			event: type,
+			data,
+			clientEventId: options?.clientEventId,
+			requestId
+		}));
+		const payload = response.payload;
+		return {
+			eventId: typeof payload.eventId === "string" ? payload.eventId : response.id,
+			sequence: typeof payload.sequence === "number" ? payload.sequence : 0,
+			clientEventId: typeof payload.clientEventId === "string" ? payload.clientEventId : null
+		};
+	}
+	/** Published events after `after`, oldest first; without it, the newest ones. */
+	async history(input = {}) {
+		this.assertJoined();
+		if (!this.websocket.supportsCapability("realtime.room.history.v1")) throw new Error("Room history is not supported by the Gateway");
+		const requestId = randomId();
+		const response = await this.request(requestId, /* @__PURE__ */ new Set(["realtime.room.history"]), () => this.websocket.readRealtimeRoomHistory({
+			roomId: this.id,
+			...input,
+			requestId
+		}));
+		return this.toHistory(response.payload);
+	}
+	/** An invite for someone outside the App, e.g. an Agent: `cohub rooms join <invite>`. */
+	async invite(input = {}) {
+		this.assertJoined();
+		const context = this.appContext;
+		if (!context) throw new Error("Invites are only available inside a published App or hosted Room");
+		if (context.hosted) return context.transport.request(`/api/rooms/${encodeURIComponent(this.id)}/invites`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(input)
+		});
+		return context.transport.request(`/api/apps/${encodeURIComponent(context.appId)}/realtime/rooms/${encodeURIComponent(this.id)}/invites`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				ticket: this.admission.ticket,
+				...input
+			})
+		});
+	}
+	rtcFactory;
+	rtc(options) {
+		if (options?.createPeerConnection) this.rtcFactory = options.createPeerConnection;
+		this.assertJoined();
+		if (this.rtcConnection) {
+			const current = this.rtcConnection;
+			return current.then((rtc) => {
+				if (rtc.state !== "closed") return rtc;
+				return (this.rtcConnection === current ? this.openRtc() : this.rtcConnection) ?? this.openRtc();
+			});
+		}
+		return this.openRtc();
+	}
+	openRtc() {
+		this.assertJoined();
+		const context = this.appContext;
+		if (!context) return Promise.reject(new AppRtcError("RTC_UNSUPPORTED", "RTC requires room context"));
+		if (!this.rtcFactory && typeof RTCPeerConnection === "undefined") return Promise.reject(new AppRtcError("RTC_UNSUPPORTED", "RTC needs a WebRTC adapter"));
+		if (!this.websocket.supportsCapability("realtime.room.rtc.v1")) return Promise.reject(new AppRtcError("RTC_UNSUPPORTED", "RTC is not supported by the Gateway"));
+		const rtc = new AppRoomRtc({
+			roomId: this.id,
+			appId: context.appId,
+			ticket: this.admission.ticket,
+			transport: context.transport,
+			hosted: context.hosted,
+			createPeerConnection: this.rtcFactory,
+			participantId: () => this._participantId,
+			members: () => this._members,
+			onMembersChanged: (handler) => this.onMembersChanged(handler)
+		});
+		const opening = rtc.start().then(() => rtc, (error) => {
+			rtc.close();
+			if (this.rtcConnection === opening) this.rtcConnection = null;
+			throw error;
+		});
+		this.rtcConnection = opening;
+		return opening;
+	}
+	async setPresence(presence) {
+		this.assertJoined();
+		const requestId = randomId();
+		await this.request(requestId, /* @__PURE__ */ new Set(["realtime.room.request.ok"]), () => this.websocket.updateRealtimeRoomPresence({
+			roomId: this.id,
+			presence,
+			requestId
+		}));
+	}
+	async disconnect() {
+		if (this.explicitLeave || this._state === "closed" || this._state === "expired") return;
+		this.explicitLeave = true;
+		try {
+			if (this.hasJoined && this.websocket.state === "open") {
+				const requestId = randomId();
+				await this.request(requestId, /* @__PURE__ */ new Set(["realtime.room.request.ok"]), () => this.appContext?.hosted ? this.websocket.detachRealtimeRoom({
+					roomId: this.id,
+					requestId
+				}) : this.websocket.leaveRealtimeRoom({
+					roomId: this.id,
+					requestId
+				}));
+			}
+		} finally {
+			this.hasJoined = false;
+			this.setState("closed");
+			this.dispose();
+		}
+	}
+	async leave() {
+		if (!this.appContext?.hosted) return this.disconnect();
+		if (this.explicitLeave || this.state === "closed" || this.state === "expired") return;
+		await this.appContext.transport.request(`/api/rooms/${encodeURIComponent(this.id)}/seat`, { method: "DELETE" });
+		this.explicitLeave = true;
+		this.hasJoined = false;
+		this.rejectPending(/* @__PURE__ */ new Error("room left"));
+		this.setState("closed");
+		this.dispose();
+	}
+	async rejoin() {
+		if (this.explicitLeave || this._state === "expired" || this._state === "closed") return;
+		try {
+			await this.joinOverWebsocket(true);
+		} catch (error) {
+			if (this.state === "expired") return;
+			this.setState("closed");
+			this.dispose();
+			console.warn("[Cohub AppRoom] failed to rejoin room", error);
+		}
+	}
+	async joinOverWebsocket(isReconnect, initialAfter) {
+		if (!this.websocket.supportsCapability("realtime.room.v1") && this.websocket.state === "open") throw new Error("Realtime rooms are not supported by the Gateway");
+		this.setState(isReconnect ? "reconnecting" : "connecting");
+		const requestId = randomId();
+		const after = isReconnect && this.websocket.supportsCapability("realtime.room.history.v1") ? this.lastSequence : initialAfter;
+		let missed = null;
+		this.joinBuffer = [];
+		try {
+			if (this.appContext?.hosted && isReconnect) {
+				const admission = await this.appContext.transport.request(`/api/rooms/${encodeURIComponent(this.id)}/connect`, { method: "POST" });
+				if (admission.participantId !== this.participantId) throw new Error("room seat changed during reconnect");
+				this.admission.ticket = admission.ticket;
+			}
+			const payload = (await this.request(requestId, /* @__PURE__ */ new Set(["realtime.room.joined"]), () => this.websocket.joinRealtimeRoom({
+				roomId: this.id,
+				ticket: this.admission.ticket,
+				instanceId: this.instanceId,
+				after,
+				requestId
+			}))).payload;
+			if (typeof payload.participantId !== "string" || !Array.isArray(payload.members)) throw new Error("invalid room join response");
+			this._participantId = payload.participantId;
+			this._members = payload.members;
+			const sequence = typeof payload.sequence === "number" ? payload.sequence : 0;
+			if (after !== void 0 && sequence > after) missed = await this.catchUp(payload.missed, after, sequence);
+			this.lastSequence = sequence;
+		} catch (error) {
+			this.joinBuffer = null;
+			throw error;
+		}
+		if (this.explicitLeave || this._state === "closed" || this._state === "expired") throw new Error("room is closed");
+		this.hasJoined = true;
+		this.setState("joined");
+		this.notifyMembers();
+		if (missed) {
+			const { lost } = missed;
+			if (lost) for (const handler of this.outOfSyncHandlers) handler(lost[0], lost[1]);
+			for (const event of missed.events) this.emit(event);
+		}
+		const buffered = this.joinBuffer ?? [];
+		this.joinBuffer = null;
+		for (const item of buffered) {
+			const sequence = item.payload.sequence;
+			if (typeof sequence === "number" && sequence <= this.lastSequence) continue;
+			this.handleEvent(item);
+		}
+		if (isReconnect) this.rtcConnection?.then((rtc) => rtc.verify()).catch(() => void 0);
+	}
+	request(requestId, expected, send) {
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.pending.delete(requestId);
+				reject(/* @__PURE__ */ new Error("room request timed out"));
+			}, 2e4);
+			this.pending.set(requestId, {
+				expected,
+				resolve,
+				reject,
+				timer
+			});
+			send().catch((error) => {
+				this.pending.delete(requestId);
+				clearTimeout(timer);
+				reject(error instanceof Error ? error : new Error(String(error)));
+			});
+		});
+	}
+	/** Detaches the entry awaiting this requestId, so the caller can settle it. */
+	takePending(requestId) {
+		const pending = requestId ? this.pending.get(requestId) : void 0;
+		if (!pending || !requestId) return null;
+		this.pending.delete(requestId);
+		clearTimeout(pending.timer);
+		return pending;
+	}
+	handleEvent(event) {
+		if (!isRoomEvent(event, this.id)) {
+			if (event.type === "system.request.error") this.takePending(event.requestId)?.reject(requestError(event));
+			return;
+		}
+		if (event.type === "realtime.room.request.error") {
+			const failure = requestError(event);
+			if (event.requestId) {
+				this.takePending(event.requestId)?.reject(failure);
+				return;
+			}
+			for (const handler of this.sendErrorHandlers) handler(failure);
+			return;
+		}
+		const awaiting = event.requestId ? this.pending.get(event.requestId) : void 0;
+		if (awaiting?.expected.has(event.type)) {
+			this.takePending(event.requestId);
+			awaiting.resolve(event);
+		}
+		if (this.joinBuffer && APP_ROOM_DELTA_EVENTS.has(event.type)) {
+			if (this.joinBuffer.length < APP_ROOM_MAX_JOIN_BUFFER) this.joinBuffer.push(event);
+			return;
+		}
+		const payload = event.payload;
+		if (APP_ROOM_DELTA_EVENTS.has(event.type) && typeof payload.sequence === "number") this.observeSequence(payload.sequence);
+		if (APP_ROOM_MEMBER_EVENTS.has(event.type)) {
+			const member = payload.member;
+			if (member?.participantId) {
+				const members = new Map(this._members.map((item) => [item.participantId, item]));
+				if (event.type === "realtime.room.member.left") members.delete(member.participantId);
+				else members.set(member.participantId, member);
+				this._members = [...members.values()];
+				this.notifyMembers();
+			}
+			return;
+		}
+		if (event.type === "realtime.room.closed") {
+			this.hasJoined = false;
+			if (payload.reason === "expired") this.setState("expired");
+			else this.setState("closed");
+			this.rejectPending(/* @__PURE__ */ new Error(`room closed: ${typeof payload.reason === "string" ? payload.reason : "unknown"}`));
+			this.dispose();
+			return;
+		}
+		if (event.type !== "realtime.room.event") return;
+		const { id, timestamp, payload: roomPayload } = event;
+		this.emit({
+			id,
+			timestamp,
+			roomId: roomPayload.roomId,
+			sequence: roomPayload.sequence,
+			type: roomPayload.event,
+			data: roomPayload.data,
+			clientEventId: roomPayload.clientEventId,
+			sender: roomPayload.sender,
+			self: roomPayload.sender.participantId === this.participantId
+		});
+	}
+	async catchUp(first, after, sequence) {
+		if (!first) return {
+			events: [],
+			lost: [after + 1, sequence]
+		};
+		const events = this.toHistory(first).events;
+		const { truncated } = first;
+		let { cursor } = first;
+		while (cursor < sequence) {
+			const requestId = randomId();
+			const page = (await this.request(requestId, /* @__PURE__ */ new Set(["realtime.room.history"]), () => this.websocket.readRealtimeRoomHistory({
+				roomId: this.id,
+				after: cursor,
+				requestId
+			})).catch(() => null))?.payload;
+			if (!page || page.cursor <= cursor) break;
+			events.push(...this.toHistory(page).events);
+			cursor = page.cursor;
+		}
+		const kept = events.filter((event) => event.sequence <= sequence);
+		const lost = truncated ? [after + 1, kept[0]?.sequence ?? sequence] : cursor < sequence ? [cursor + 1, sequence] : null;
+		return {
+			events: kept,
+			lost: lost && lost[1] > lost[0] ? lost : null
+		};
+	}
+	emit(item) {
+		this.handlers.get(item.type)?.forEach((handler) => {
+			handler(item);
+		});
+		this.allHandlers.forEach((handler) => {
+			handler(item);
+		});
+	}
+	toHistory(history) {
+		return {
+			events: history.events.map((event) => ({
+				...event,
+				data: event.data,
+				roomId: this.id,
+				self: event.sender.participantId === this.participantId
+			})),
+			cursor: history.cursor,
+			truncated: history.truncated
+		};
+	}
+	observeSequence(sequence) {
+		if (this.lastSequence > 0 && sequence > this.lastSequence + 1) for (const handler of this.outOfSyncHandlers) handler(this.lastSequence + 1, sequence);
+		if (sequence > this.lastSequence) this.lastSequence = sequence;
+	}
+	assertJoined() {
+		if (this._state !== "joined" || !this.hasJoined) throw new Error("room is not joined");
+	}
+	setState(state) {
+		if (this._state === state) return;
+		this._state = state;
+		for (const handler of this.stateHandlers) handler(state);
+	}
+	notifyMembers() {
+		const members = this.members;
+		for (const handler of this.membersHandlers) handler(members);
+	}
+	rejectPending(error) {
+		for (const [requestId, pending] of this.pending) {
+			this.pending.delete(requestId);
+			clearTimeout(pending.timer);
+			pending.reject(error);
+		}
+	}
+	expire() {
+		if (this.explicitLeave || this._state === "closed" || this._state === "expired") return;
+		this.hasJoined = false;
+		this.setState("expired");
+		this.rejectPending(/* @__PURE__ */ new Error("room expired"));
+		this.dispose();
+	}
+	dispose() {
+		const rtc = this.rtcConnection;
+		this.rtcConnection = null;
+		rtc?.then((connection) => connection.close()).catch(() => void 0);
+		this.offEvent();
+		this.offOpen();
+		this.offClose();
+		this.offReconnecting();
+		if (this.expiryTimer) clearTimeout(this.expiryTimer);
+		this.expiryTimer = null;
+	}
+};
+var AppRealtimeApi = class {
+	transport;
+	websocket;
+	getContext;
+	constructor(transport, websocket, getContext) {
+		this.transport = transport;
+		this.websocket = websocket;
+		this.getContext = getContext;
+	}
+	async createRoom(input = {}) {
+		const appId = await this.requireAppId();
+		const admission = await this.transport.request(`/api/apps/${encodeURIComponent(appId)}/realtime/rooms`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(input)
+		});
+		return this.openRoom(appId, admission);
+	}
+	async joinRoom(input) {
+		const appId = await this.requireAppId();
+		const admission = await this.transport.request(`/api/apps/${encodeURIComponent(appId)}/realtime/rooms/join`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(input)
+		});
+		return this.openRoom(appId, admission);
+	}
+	async requireAppId() {
+		const context = await this.getContext();
+		if (!context?.app?.id) throw new Error("App context is unavailable — not running inside a published app runtime.");
+		return context.app.id;
+	}
+	async openRoom(appId, admission) {
+		const room = new AppRoom(this.websocket, admission, {
+			transport: this.transport,
+			appId
+		});
+		try {
+			await room.connect();
+			return room;
+		} catch (error) {
+			await room.leave().catch(() => void 0);
+			throw error;
+		}
+	}
+};
+/** @deprecated Use `AppRealtimeApi`. */
+var WorkRealtimeApi = class extends AppRealtimeApi {};
+/** @deprecated Use `AppRoom`. */
+var WorkRoom = class extends AppRoom {};
+//#endregion
+export { app_realtime_exports as a, AppRtcError as c, WorkRoom as i, AppRoom as n, AppRoomRtc as o, WorkRealtimeApi as r, AppRtcChannel as s, AppRealtimeApi as t };