@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/connection.js

@@ -0,0 +1,497 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomAuthoringError as n, RoomGone as r, RoomPoolWaking as i } from "./errors.js";
+import { captureOptionalRoomTransportDataMethod as a, captureRoomTransportDataMethod as o } from "./transportAuthoring.js";
+import { RoomTransportCleanupFailure as s } from "./transportCleanup.js";
+import { captureRoomTransportEndpoints as c } from "./transportEndpoints.js";
+import { RoomInputRedundancy as l, defaultRoomInputRedundancy as u } from "./inputRedundancy.js";
+import { RoomSession as d, defaultRoomClockSampling as f } from "./web.js";
+//#region src/connection.ts
+var p = (e) => e < 3e3 ? 200 : 1e3, m = (e) => {
+	if (!Number.isSafeInteger(e.attempt) || e.attempt < 0 || !Number.isFinite(e.initialBackoffMs) || e.initialBackoffMs <= 0 || !Number.isFinite(e.maxBackoffMs) || e.maxBackoffMs < e.initialBackoffMs || !Number.isFinite(e.remainingMs) || e.remainingMs <= 0 || !Number.isFinite(e.random) || e.random < 0 || e.random >= 1) throw new n({
+		room: "client",
+		detail: "Reconnect policy input is invalid"
+	});
+	let t = Math.min(e.maxBackoffMs, e.initialBackoffMs * 2 ** Math.min(e.attempt, 53));
+	return Math.min(e.remainingMs, t * (.5 + e.random * .5));
+}, h = () => new t({ detail: "Room connection was cancelled" }), g = (e, t) => new Promise((n, r) => {
+	let i = () => {
+		t.removeEventListener("abort", i), r(h());
+	};
+	t.aborted ? (e.catch(() => void 0), i()) : (t.addEventListener("abort", i, { once: !0 }), e.then((e) => {
+		t.removeEventListener("abort", i), t.aborted || n(e);
+	}, (e) => {
+		t.removeEventListener("abort", i), r(e);
+	}));
+}), _ = (e, t) => new Promise((n, r) => {
+	if (t.aborted) {
+		r(h());
+		return;
+	}
+	let i = () => {
+		clearTimeout(a), t.removeEventListener("abort", i), r(h());
+	}, a = setTimeout(() => {
+		t.removeEventListener("abort", i), n();
+	}, e);
+	t.addEventListener("abort", i, { once: !0 });
+}), v = /* @__PURE__ */ new WeakMap(), y = class {
+	manifest;
+	clock;
+	reservations;
+	connect;
+	controller = new AbortController();
+	listeners = /* @__PURE__ */ new Set();
+	buffered = [];
+	pendingInputs = /* @__PURE__ */ new Map();
+	options;
+	session = null;
+	handoffDetach = null;
+	handoffListeners = /* @__PURE__ */ new Set();
+	sessionDetach = null;
+	currentState = null;
+	currentStatus = "reserving";
+	currentError = null;
+	reconnectTask = null;
+	startTask = null;
+	started = !1;
+	leaving = !1;
+	lastSessionId = null;
+	lastTick = -1;
+	nextSeq = 0;
+	appliedSeq = -1;
+	clockTimer = null;
+	messageListeners = /* @__PURE__ */ new Map();
+	messageDetach = /* @__PURE__ */ new Map();
+	reservation = null;
+	cleanupTasks = /* @__PURE__ */ new Set();
+	cleanupFailures = [];
+	pendingReservationCalls = 0;
+	pendingTransportCalls = 0;
+	transportOwners = /* @__PURE__ */ new Map();
+	transportLifetimes = /* @__PURE__ */ new WeakMap();
+	withdrawalAttempted;
+	leaveTask = null;
+	left = !1;
+	constructor(e, t, r, i, a) {
+		this.manifest = e, this.clock = t, this.reservations = r, this.connect = i;
+		let o = a.inputRedundancy ?? u;
+		new l(o), this.options = {
+			graceMs: a.graceMs,
+			maxBufferedInputs: a.maxBufferedInputs ?? 128,
+			maxPendingInputs: a.maxPendingInputs ?? 256,
+			initialBackoffMs: a.initialBackoffMs ?? 250,
+			maxBackoffMs: a.maxBackoffMs ?? 8e3,
+			connectTimeoutMs: a.connectTimeoutMs ?? 5e3,
+			random: a.random ?? Math.random,
+			sleep: a.sleep ?? _,
+			reconnectPolicy: a.reconnectPolicy ?? m,
+			clockSampling: a.clockSampling ?? f,
+			inputRedundancy: Object.freeze({ ...o }),
+			clockPingCadence: a.clockPingCadence ?? p,
+			maxPendingReservationCalls: a.maxPendingReservationCalls ?? 4,
+			maxCleanupFailures: a.maxCleanupFailures ?? 32,
+			maxPendingTransportCalls: a.maxPendingTransportCalls ?? 4,
+			wakeTimeoutMs: a.wakeTimeoutMs ?? 18e4
+		};
+		for (let e of [
+			this.options.graceMs,
+			this.options.initialBackoffMs,
+			this.options.maxBackoffMs,
+			this.options.connectTimeoutMs,
+			this.options.wakeTimeoutMs
+		]) if (!Number.isFinite(e) || e <= 0) throw new n({
+			room: "client",
+			detail: "Reconnect durations must be positive"
+		});
+		if (!Number.isSafeInteger(this.options.maxBufferedInputs) || this.options.maxBufferedInputs < 1 || !Number.isSafeInteger(this.options.maxPendingInputs) || this.options.maxPendingInputs < 1 || !Number.isSafeInteger(this.options.maxPendingReservationCalls) || this.options.maxPendingReservationCalls < 1 || !Number.isSafeInteger(this.options.maxCleanupFailures) || this.options.maxCleanupFailures < 1 || !Number.isSafeInteger(this.options.maxPendingTransportCalls) || this.options.maxPendingTransportCalls < 1 || this.options.maxBackoffMs < this.options.initialBackoffMs) throw new n({
+			room: "client",
+			detail: "Reconnect buffer/backoff budget is invalid"
+		});
+		v.set(this, () => this.captureGeometrySession());
+	}
+	captureGeometrySession() {
+		return this.currentStatus === "joined" && !this.leaving ? this.session : null;
+	}
+	get status() {
+		return this.currentStatus;
+	}
+	get error() {
+		return this.currentError;
+	}
+	get state() {
+		return this.currentState === null ? null : structuredClone(this.currentState);
+	}
+	get id() {
+		return this.lastSessionId;
+	}
+	get roomId() {
+		return this.reservation?.roomId ?? null;
+	}
+	get lastAppliedTick() {
+		return this.lastTick;
+	}
+	get lastAppliedInputSeq() {
+		return this.appliedSeq;
+	}
+	get reconciliationSnapshot() {
+		return this.session?.reconciliationSnapshot ?? null;
+	}
+	deliveredSnapshot() {
+		return this.currentStatus === "joined" ? this.session?.deliveredSnapshot() ?? null : null;
+	}
+	clockStats() {
+		return this.session?.clockSync.stats() ?? {
+			rttMs: null,
+			offsetMs: null
+		};
+	}
+	serverNow() {
+		return this.session?.clockSync.serverNow() ?? null;
+	}
+	get lossRate() {
+		return this.session?.lossRate ?? null;
+	}
+	subscribe(e) {
+		return this.listeners.add(e), () => {
+			this.listeners.delete(e);
+		};
+	}
+	notify() {
+		for (let e of this.listeners) e();
+	}
+	active() {
+		if (this.controller.signal.aborted || this.leaving) throw h();
+	}
+	start(e) {
+		return this.started ? Promise.reject(new t({ detail: "Room connection already started" })) : (this.started = !0, this.startTask = (async () => {
+			try {
+				let t = this.clock.now() + this.options.wakeTimeoutMs;
+				for (;;) try {
+					await this.attempt(this.clock.now() + this.options.connectTimeoutMs, async (t) => {
+						let n = await this.requestReservation(() => this.reservations.reserve(e, t), t);
+						await this.install(n, !1, t);
+					});
+					break;
+				} catch (e) {
+					if (!(e instanceof i) || this.clock.now() + e.retryAfterMs > t) throw e;
+					this.currentStatus = "waking", this.currentError = null, this.notify(), await this.options.sleep(e.retryAfterMs, this.controller.signal), this.active(), this.currentStatus = "reserving", this.notify();
+				}
+			} catch (e) {
+				throw this.leaving || this.terminal(e, e instanceof r ? "gone" : "left"), e;
+			}
+		})(), this.startTask);
+	}
+	async attempt(e, t) {
+		this.active();
+		let n = e - this.clock.now();
+		if (n <= 0) throw new r({ roomId: "" });
+		let i = new AbortController(), a = () => {
+			i.abort();
+		};
+		this.controller.signal.addEventListener("abort", a, { once: !0 });
+		let o = setTimeout(a, n);
+		try {
+			await t(i.signal);
+		} finally {
+			clearTimeout(o), this.controller.signal.removeEventListener("abort", a);
+		}
+	}
+	async install(n, r, i) {
+		let a = n.endpoints === void 0 ? void 0 : c(n.endpoints);
+		if (this.reservation = {
+			...n,
+			token: Uint8Array.from(n.token),
+			...a === void 0 ? {} : { endpoints: a }
+		}, this.active(), this.pendingTransportCalls >= this.options.maxPendingTransportCalls) throw new e({
+			budget: "pendingTransportCalls",
+			limit: this.options.maxPendingTransportCalls
+		});
+		if (this.transportOwners.size) throw new t({ detail: "Room transport withdrawal must complete before another acquisition" });
+		this.pendingTransportCalls++;
+		let o = Promise.resolve().then(() => this.connect(n.address, i, a)), l = o.then(async (e) => {
+			this.pendingTransportCalls--, (i.aborted || this.leaving) && await this.releaseTransport(e, "Late cancelled room connection");
+		}, (e) => {
+			this.pendingTransportCalls--, e instanceof s && this.transportOwners.set(e, e);
+		}).catch((e) => {
+			this.currentError = e, this.notify();
+		});
+		this.cleanupTasks.add(l), l.then(() => {
+			this.cleanupTasks.delete(l);
+		});
+		let u = await g(o, i);
+		if (i.aborted || this.controller.signal.aborted || this.leaving) throw await this.releaseTransport(u, "Cancelled room connection"), h();
+		try {
+			this.sessionDetach?.(), this.sessionDetach = null, this.handoffDetach?.(), this.handoffDetach = null, this.stopClockSampling();
+			for (let e of this.messageDetach.values()) e();
+			this.messageDetach.clear();
+			let e = new d(u, this.manifest, this.clock, 8, {
+				nextSeq: this.nextSeq,
+				lastAppliedSeq: this.appliedSeq
+			}, this.options.clockSampling, this.options.inputRedundancy);
+			this.session = e, this.handoffDetach = e.onWorldHandoff((t) => {
+				if (!(e !== this.session || this.leaving)) for (let e of this.handoffListeners) e(t);
+			});
+			for (let t of this.messageListeners.keys()) this.attachMessages(e, t);
+			if (this.currentStatus = r ? "reconnecting" : "connecting", this.notify(), this.sessionDetach = e.subscribe(() => {
+				if (e !== this.session || this.leaving) return;
+				let n = e.state;
+				n !== null && (this.currentState = n), e.id && (this.lastSessionId = e.id), this.lastTick = Math.max(this.lastTick, e.lastAppliedTick), this.appliedSeq = Math.max(this.appliedSeq, e.lastAppliedInputSeq);
+				for (let e of this.pendingInputs.keys()) e <= this.appliedSeq && this.pendingInputs.delete(e);
+				if (e.status === "reconnecting") this.beginReconnect();
+				else if (e.status === "kicked" || e.status === "gone" || e.status === "left") {
+					if (r) {
+						this.notify();
+						return;
+					}
+					this.terminal(e.error ?? new t({ detail: "Room session ended" }), e.status);
+				} else this.notify();
+			}), await g(e.start(n.token, r && this.lastTick >= 0 ? this.lastTick : void 0), i), await this.waitForJoin(e, i), e.id !== n.sessionId) throw new t({ detail: "Welcome does not match the reserved session" });
+			if (this.lastSessionId = n.sessionId, r) for (let [t, n] of [...this.pendingInputs]) t <= this.appliedSeq || await g(e.replay(t, n), i);
+			for (; this.buffered.length;) {
+				this.active();
+				let t = this.buffered.shift();
+				if (!t) break;
+				try {
+					t.resolve(await g(this.submit(e, t.input), i));
+				} catch (e) {
+					throw t.reject(e), e;
+				}
+			}
+			if (this.active(), e.status !== "joined") throw new t({ detail: "Room disconnected before buffered inputs were delivered" });
+			this.currentState = e.state, this.lastTick = e.lastAppliedTick, this.currentStatus = "joined", this.currentError = null, this.notify(), this.startClockSampling(e);
+		} catch (e) {
+			this.sessionDetach?.(), this.sessionDetach = null, this.handoffDetach?.(), this.handoffDetach = null;
+			try {
+				await this.releaseTransport(u, "Room connection attempt ended");
+			} catch (t) {
+				throw AggregateError([e, t], "Room connection attempt and transport withdrawal failed");
+			}
+			throw e;
+		}
+	}
+	waitForJoin(e, t) {
+		return new Promise((n, r) => {
+			let i, a = (e) => {
+				i?.(), t.removeEventListener("abort", o), e === void 0 ? n() : r(e);
+			}, o = () => a(h()), s = () => {
+				t.aborted ? o() : e.status === "joined" ? a() : [
+					"left",
+					"kicked",
+					"gone",
+					"reconnecting"
+				].includes(e.status) && a(e.error ?? h());
+			};
+			i = e.subscribe(s), t.addEventListener("abort", o, { once: !0 }), s();
+		});
+	}
+	beginReconnect() {
+		if (this.stopClockSampling(), this.reconnectTask || this.leaving || this.controller.signal.aborted) return;
+		let e = this.lastSessionId;
+		if (!e) {
+			this.terminal(new r({ roomId: "" }), "gone");
+			return;
+		}
+		this.currentStatus = "reconnecting", this.notify();
+		let t = this.clock.now() + this.options.graceMs;
+		this.reconnectTask = (async () => {
+			let i = 0;
+			try {
+				for (;;) {
+					this.active();
+					let a = t - this.clock.now();
+					if (a <= 0) throw new r({ roomId: "" });
+					let o = this.options.random();
+					if (!Number.isFinite(o) || o < 0 || o >= 1) throw new n({
+						room: "client",
+						detail: "Reconnect jitter source must be in [0, 1)"
+					});
+					let s = this.options.reconnectPolicy({
+						attempt: i,
+						remainingMs: a,
+						random: o,
+						initialBackoffMs: this.options.initialBackoffMs,
+						maxBackoffMs: this.options.maxBackoffMs
+					});
+					if (!Number.isFinite(s) || s <= 0 || s > Math.min(this.options.maxBackoffMs, a)) throw new n({
+						room: "client",
+						detail: "Reconnect policy exceeded its duration budget"
+					});
+					if (await this.options.sleep(s, this.controller.signal), this.active(), this.clock.now() >= t) throw new r({ roomId: "" });
+					try {
+						this.session && await this.releaseTransport(this.session.transport, "Room reconnect replaces the withdrawn transport"), await this.attempt(Math.min(t, this.clock.now() + this.options.connectTimeoutMs), async (t) => {
+							let n = await this.requestReservation(() => this.reservations.resume(e, t), t);
+							await this.install(n, !0, t);
+						});
+						return;
+					} catch (e) {
+						if (e instanceof r || this.transportOwners.size) throw e;
+						this.active(), this.currentError = e, this.currentStatus = "reconnecting", this.notify();
+					}
+					if (!Number.isSafeInteger(++i)) throw new n({
+						room: "client",
+						detail: "Reconnect attempt counter exhausted"
+					});
+				}
+			} catch (e) {
+				this.leaving || this.terminal(e, e instanceof r ? "gone" : "left");
+			} finally {
+				this.reconnectTask = null;
+			}
+		})();
+	}
+	send(n) {
+		return this.currentStatus === "joined" && this.session ? this.submit(this.session, n) : this.currentStatus === "reconnecting" ? this.buffered.length >= this.options.maxBufferedInputs ? Promise.reject(new e({
+			budget: "reconnectInputs",
+			limit: this.options.maxBufferedInputs
+		})) : new Promise((e, t) => {
+			this.buffered.push({
+				input: structuredClone(n),
+				resolve: e,
+				reject: t
+			});
+		}) : Promise.reject(new t({ detail: "Inputs require a joined or reconnecting room" }));
+	}
+	submit(t, n) {
+		if (this.pendingInputs.size >= this.options.maxPendingInputs) return Promise.reject(new e({
+			budget: "unacknowledgedInputs",
+			limit: this.options.maxPendingInputs
+		}));
+		let r = structuredClone(n), i = t.nextInputSeq, a = t.send(r);
+		return t.nextInputSeq === i + 1 && (this.pendingInputs.set(i, r), this.nextSeq = t.nextInputSeq), a;
+	}
+	message(e, n) {
+		return this.currentStatus !== "joined" || !this.session ? Promise.reject(new t({ detail: "Messages require a joined room" })) : this.session.message(e, n);
+	}
+	onWorldHandoff(e) {
+		return this.handoffListeners.add(e), () => {
+			this.handoffListeners.delete(e);
+		};
+	}
+	onMessage(e, n) {
+		if (!this.manifest.messages?.[e] || this.manifest.messages[e].direction === "client") throw new t({ detail: "Channel is not server-sendable" });
+		let r = this.messageListeners.get(e), i = r ?? /* @__PURE__ */ new Set();
+		return i.add(n), this.messageListeners.set(e, i), !r && this.session && this.attachMessages(this.session, e), () => {
+			i.delete(n), i.size === 0 && (this.messageListeners.delete(e), this.messageDetach.get(e)?.(), this.messageDetach.delete(e));
+		};
+	}
+	attachMessages(e, t) {
+		this.messageDetach.set(t, e.onMessage(t, (e) => {
+			for (let n of this.messageListeners.get(t) ?? []) n(structuredClone(e));
+		}));
+	}
+	requestReservation(t, n) {
+		if (this.pendingReservationCalls >= this.options.maxPendingReservationCalls) return Promise.reject(new e({
+			budget: "pendingReservationCalls",
+			limit: this.options.maxPendingReservationCalls
+		}));
+		this.pendingReservationCalls++;
+		let r;
+		try {
+			r = t();
+		} catch (e) {
+			return this.pendingReservationCalls--, Promise.reject(e);
+		}
+		return r.then((e) => {
+			this.pendingReservationCalls--, n.aborted && this.releaseReservation(e);
+		}, () => {
+			this.pendingReservationCalls--;
+		}).catch((e) => {
+			this.currentError = e, this.notify();
+		}), g(r, n);
+	}
+	releaseReservation(e) {
+		let t = this.reservations.release;
+		if (!t) return;
+		let n = new AbortController(), r = setTimeout(() => n.abort(), this.options.connectTimeoutMs), i = (async () => {
+			try {
+				await g(t.call(this.reservations, e.sessionId, Uint8Array.from(e.token), n.signal), n.signal);
+			} catch (e) {
+				this.currentError = e, this.cleanupFailures.length === this.options.maxCleanupFailures && this.cleanupFailures.shift(), this.cleanupFailures.push(e), this.notify();
+			} finally {
+				clearTimeout(r);
+			}
+		})();
+		this.cleanupTasks.add(i), i.finally(() => {
+			this.cleanupTasks.delete(i);
+		});
+	}
+	stopClockSampling() {
+		this.clockTimer !== null && clearTimeout(this.clockTimer), this.clockTimer = null;
+	}
+	releaseTransport(e, t) {
+		let n = this.retainTransport(e, t);
+		return this.runTransportCleanup(e, n);
+	}
+	retainTransport(e, t) {
+		let n = this.transportLifetimes.get(e);
+		if (!n) {
+			let r = a(e, "closeAsync", "Room transport requires an actual asynchronous close method") ?? o(e, "close", "Room transport requires an actual close method");
+			n = new s(async () => {
+				await r(1e3, t);
+			}), this.transportLifetimes.set(e, n), this.transportOwners.set(e, n);
+		}
+		return n;
+	}
+	runTransportCleanup(e, t) {
+		this.withdrawalAttempted?.add(e);
+		let n = t.cleanupAsync();
+		return this.cleanupTasks.add(n), n.then(() => {
+			this.cleanupTasks.delete(n), this.transportOwners.get(e) === t && this.transportOwners.delete(e);
+		}, (e) => {
+			this.cleanupTasks.delete(n), this.currentError = e, this.notify();
+		}), n;
+	}
+	startClockSampling(e) {
+		let t = this.clock.now(), r = () => {
+			if (e !== this.session || this.currentStatus !== "joined" || this.leaving) return;
+			let i = this.options.clockPingCadence(Math.max(0, this.clock.now() - t));
+			!Number.isSafeInteger(i) || i <= 0 || i > 2147483647 ? this.terminal(new n({
+				room: "client",
+				detail: "Clock ping cadence must return a bounded positive timer duration"
+			}), "left") : this.clockTimer = setTimeout(() => {
+				this.clockTimer = null, !(e !== this.session || this.currentStatus !== "joined" || this.leaving) && e.ping().then(r, (t) => {
+					e !== this.session || this.currentStatus !== "joined" || this.leaving || (this.currentError = t, this.notify(), r());
+				});
+			}, i);
+		};
+		r();
+	}
+	terminal(e, t) {
+		this.stopClockSampling(), this.currentError = e, this.currentStatus = t, this.sessionDetach?.(), this.sessionDetach = null, this.handoffDetach?.(), this.handoffDetach = null;
+		for (let e of this.messageDetach.values()) e();
+		this.messageDetach.clear(), this.session && this.releaseTransport(this.session.transport, "Room connection ended").catch(() => {}), this.reservation &&= (this.releaseReservation(this.reservation), null);
+		for (let t of this.buffered.splice(0)) t.reject(e);
+		this.notify();
+	}
+	leave() {
+		if (this.left) return Promise.resolve();
+		if (this.leaveTask) return this.leaveTask;
+		let e = this.withdraw();
+		return this.leaveTask = e, e.catch(() => {
+			this.leaveTask === e && (this.leaveTask = null);
+		}), e;
+	}
+	async withdraw() {
+		this.withdrawalAttempted = /* @__PURE__ */ new Set(), this.leaving = !0, this.controller.abort(), this.stopClockSampling(), this.pendingInputs.clear(), this.sessionDetach?.(), this.sessionDetach = null, this.handoffDetach?.(), this.handoffDetach = null;
+		for (let e of this.buffered.splice(0)) e.reject(h());
+		let e = [];
+		this.session && e.push(this.session.leave()), this.startTask && e.push(this.startTask), this.reconnectTask && e.push(this.reconnectTask);
+		let t = await Promise.allSettled(e);
+		for (this.session && this.retainTransport(this.session.transport, "Room connection left"), this.reservation &&= (this.releaseReservation(this.reservation), null); this.cleanupTasks.size;) await Promise.allSettled([...this.cleanupTasks]);
+		let n = await Promise.allSettled([...this.transportOwners].filter(([e]) => !this.withdrawalAttempted.has(e)).map(([e, t]) => this.runTransportCleanup(e, t)));
+		for (let e of this.messageDetach.values()) e();
+		this.messageDetach.clear(), this.messageListeners.clear(), this.currentStatus = "left", this.notify();
+		let r = [...this.cleanupFailures, ...t.flatMap((e) => e.status === "rejected" ? [e.reason] : [])], i = n.flatMap((e) => e.status === "rejected" ? [e.reason] : []);
+		if (this.withdrawalAttempted = void 0, this.cleanupFailures.length || this.transportOwners.size || i.length) throw AggregateError([
+			...r,
+			...i,
+			...this.transportOwners.values()
+		], "Room connection withdrawal failed");
+		this.left = !0, this.listeners.clear();
+	}
+}, b = (e) => {
+	if (!e || typeof e != "object") throw h();
+	let n = v.get(e)?.();
+	if (!n) throw new t({ detail: "Geometry requires its genuine currently joined Room connection" });
+	return n;
+};
+//#endregion
+export { y as RoomConnection, b as captureRoomConnectionGeometrySession, p as defaultRoomClockPingCadence, m as defaultRoomReconnectPolicy };