@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/web.js

@@ -0,0 +1,518 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomAuthoringError as n } from "./errors.js";
+import { RoomInputCodec as r, RoomStateCodec as i } from "./stateCodec.js";
+import { WorldClientReceiptSchema as a, WorldClientRequestIdSchema as o, WorldClientTicketSchema as s } from "./worldClientSchemas.js";
+import { makeWorldHandoffView as c } from "./worldHandoffView.js";
+import { RoomTransportCleanupFailure as l } from "./transportCleanup.js";
+import { captureRoomTransportEndpoints as u } from "./transportEndpoints.js";
+import { RoomInputRedundancy as d, defaultRoomInputRedundancy as f } from "./inputRedundancy.js";
+import { RoomConnection as p, defaultRoomClockPingCadence as m, defaultRoomReconnectPolicy as h } from "./connection.js";
+import { defaultRoomWebSocketFactory as g, openRoomSocketTransport as _ } from "./socketTransport.js";
+import { RoomLatestDatagram as v, RoomStreamFrameDecoder as ee, encodeRoomStreamFrame as y } from "./streamFraming.js";
+import { makeRoomStreamTransport as b } from "./streamTransport.js";
+import { defaultRoomWebTransportFactory as x, openRoomWebTransport as S } from "./webTransportClient.js";
+import { roomTransportConnector as C } from "./transportConnector.js";
+import { listRooms as w, roomRpcReservations as T, worldRpcControls as E, worldRpcFollowerReservations as D, worldRpcPending as O, worldRpcReservations as k } from "./rpcClient.js";
+import { createRoom as A, createRoomClient as j, joinById as M, joinRoom as N, joinSeat as te, joinWorld as P } from "./client.js";
+import { RoomClockSync as F } from "./clockSync.js";
+import { decodeRoomFrame as I, encodeRoomFrame as L, roomFrameLayout as R } from "./wire.js";
+import { makeWorldEntityHandoffView as z } from "./worldEntityHandoffView.js";
+import { WorldClient as B, worldClientReceipt as V, worldClientTicket as H } from "./worldClient.js";
+import { shapeDigest as U } from "@voltro/protocol";
+import { Result as W } from "effect";
+//#region src/web.ts
+var G = Object.freeze({
+	maxPendingPings: 8,
+	pingTimeoutMs: 1e4
+}), K = (e) => {
+	let t = new i(e.state), a = new r(e.input), o = Object.entries(e.messages ?? {}).sort(([e], [t]) => e < t ? -1 : +(e > t)).map(([e, t]) => {
+		if (!/^[A-Za-z][A-Za-z0-9._-]*$/.test(e)) throw new n({
+			room: "wire",
+			detail: "Channel names must be stable ASCII identifiers"
+		});
+		return Object.freeze({
+			name: e,
+			direction: t.direction,
+			reliable: t.reliable,
+			codec: new r(t.schema)
+		});
+	}), s = Number.parseInt(U(JSON.stringify([
+		R,
+		t.schemaHash,
+		a.schemaHash,
+		o.map((e) => [
+			e.name,
+			e.codec.schemaHash,
+			e.direction,
+			e.reliable
+		])
+	])), 16), c = new TextEncoder().encode(JSON.stringify(t.transformRulesManifest()));
+	return Object.freeze({
+		state: t,
+		input: a,
+		channels: Object.freeze(o),
+		schemaHash: s,
+		get transformRules() {
+			return Uint8Array.from(c);
+		}
+	});
+}, q = /* @__PURE__ */ new WeakSet(), J = class {
+	transport;
+	clock;
+	maxBaselines;
+	codecs;
+	baselines = /* @__PURE__ */ new Map();
+	handoffListeners = /* @__PURE__ */ new Set();
+	listeners = /* @__PURE__ */ new Set();
+	messageListeners = /* @__PURE__ */ new Map();
+	detach = [];
+	currentState = null;
+	currentStatus = "connecting";
+	currentError = null;
+	tick = -1;
+	epoch = -1;
+	receivedAt = -1;
+	seq = 0;
+	inputAck = -1;
+	acknowledgedTick = -1;
+	pendingInputAck = null;
+	pairedInputState = null;
+	sessionId = null;
+	started = !1;
+	pendingPings = /* @__PURE__ */ new Map();
+	deltaDatagramsReceived = 0;
+	lossSample = null;
+	lossEstimate = null;
+	sampling;
+	clockSync;
+	inputHistory;
+	constructor(e, t, r, i = 8, a = {
+		nextSeq: 0,
+		lastAppliedSeq: -1
+	}, o = G, s = f) {
+		if (this.transport = e, this.clock = r, this.maxBaselines = i, this.inputHistory = new d(s), !Number.isSafeInteger(i) || i < 1) throw new n({
+			room: "client",
+			detail: "Client baseline history must be bounded"
+		});
+		if (!Number.isSafeInteger(a.nextSeq) || a.nextSeq < 0 || !Number.isSafeInteger(a.lastAppliedSeq) || a.lastAppliedSeq < -1 || a.lastAppliedSeq >= a.nextSeq) throw new n({
+			room: "client",
+			detail: "Invalid input recovery cursor"
+		});
+		if (this.seq = a.nextSeq, this.inputAck = a.lastAppliedSeq, !Number.isSafeInteger(o.maxPendingPings) || o.maxPendingPings < 1 || !Number.isSafeInteger(o.pingTimeoutMs) || o.pingTimeoutMs < 1) throw new n({
+			room: "client",
+			detail: "Clock sampling budgets must be positive safe integers"
+		});
+		this.sampling = Object.freeze({ ...o }), this.codecs = K(t), this.clockSync = new F(r), this.detach.push(e.reliable.onFrame((e, t) => this.receive(e, t))), e.unreliable && this.detach.push(e.unreliable.onFrame((e, t) => this.receive(e, t, !0)));
+		let c = () => {
+			(this.currentStatus === "joined" || this.currentStatus === "connecting") && (this.currentStatus = "reconnecting"), this.cleanup(), this.notify();
+		};
+		e.signal.addEventListener("abort", c, { once: !0 }), this.detach.push(() => e.signal.removeEventListener("abort", c)), e.signal.aborted && c(), q.add(this);
+	}
+	currentReliableChannelIdentity(e, t) {
+		let n = this.codecs.channels.find((t) => t.name === e);
+		return this.currentStatus !== "joined" || this.transport.signal.aborted || this.currentState === null || !this.sessionId || !n || !n.reliable || n.direction === "client" || n.codec.schemaHash !== t ? null : Object.freeze({
+			sessionId: this.sessionId,
+			epoch: this.epoch
+		});
+	}
+	currentReliableClientChannelIdentity(e, t) {
+		let n = this.codecs.channels.find((t) => t.name === e);
+		return this.currentStatus !== "joined" || this.transport.signal.aborted || this.currentState === null || !this.sessionId || !n || !n.reliable || n.direction !== "client" || n.codec.schemaHash !== t ? null : Object.freeze({
+			sessionId: this.sessionId,
+			epoch: this.epoch
+		});
+	}
+	get status() {
+		return this.currentStatus;
+	}
+	get error() {
+		return this.currentError;
+	}
+	get state() {
+		return this.currentState === null ? null : structuredClone(this.currentState);
+	}
+	get lastAppliedTick() {
+		return this.tick;
+	}
+	get lastAppliedInputSeq() {
+		return this.inputAck;
+	}
+	get reconciliationSnapshot() {
+		return this.pairedInputState === null ? null : structuredClone(this.pairedInputState);
+	}
+	get nextInputSeq() {
+		return this.seq;
+	}
+	get id() {
+		return this.sessionId;
+	}
+	get lossRate() {
+		return this.lossEstimate;
+	}
+	deliveredSnapshot() {
+		return this.currentStatus !== "joined" || this.currentState === null ? null : {
+			epoch: this.epoch,
+			tick: this.tick,
+			receivedAt: this.receivedAt,
+			state: structuredClone(this.currentState)
+		};
+	}
+	serverNow() {
+		return this.clockSync.serverNow();
+	}
+	async start(e, n) {
+		if (this.started || this.transport.signal.aborted) throw new t({ detail: "Session already started or transport closed" });
+		this.started = !0, await this.sendFrame({
+			kind: "Hello",
+			protocolVersion: 1,
+			token: e,
+			schemaHash: this.codecs.schemaHash,
+			...n === void 0 ? {} : { resumeFromTick: n },
+			transportCaps: this.transport.unreliable ? 3 : 1
+		});
+	}
+	async send(e) {
+		if (this.currentStatus !== "joined") throw new t({ detail: "Inputs require a joined session" });
+		if (!Number.isSafeInteger(this.seq)) throw new t({ detail: "Input sequence exhausted" });
+		let n = this.codecs.input.full(e);
+		if (W.isFailure(n)) throw n.failure;
+		let r = this.seq, i = this.acknowledgedTick < 0 ? {} : { ackTick: this.acknowledgedTick }, a = {
+			kind: "Input",
+			firstSeq: r,
+			inputs: [{
+				tickHint: this.tick,
+				payload: n.success
+			}],
+			...i
+		};
+		if (this.transport.unreliable) {
+			let e = this.inputHistory.offer(r, this.tick, n.success), t = L({
+				...e,
+				...i
+			});
+			this.seq++, W.isSuccess(t) && t.success.byteLength <= this.transport.unreliable.maxDatagramBytes ? this.transport.unreliable.send(t.success) : await this.sendFrame(a);
+		} else this.seq++, await this.sendFrame(a);
+		return r;
+	}
+	async message(e, n) {
+		if (this.currentStatus !== "joined") throw new t({ detail: "Messages require a joined session" });
+		let r = this.codecs.channels.findIndex((t) => t.name === e), i = this.codecs.channels[r];
+		if (!i || i.direction === "server") throw new t({ detail: "Channel is not client-sendable" });
+		let a = i.codec.full(n);
+		if (W.isFailure(a)) throw a.failure;
+		let o = {
+			kind: "ClientMessage",
+			channelId: r,
+			payload: a.success
+		}, s = L(o);
+		if (W.isFailure(s)) throw s.failure;
+		!i.reliable && this.transport.unreliable && s.success.byteLength <= this.transport.unreliable.maxDatagramBytes ? this.transport.unreliable.send(s.success) : await this.transport.reliable.send(s.success);
+	}
+	async replay(e, n) {
+		if (this.currentStatus !== "joined" || !Number.isSafeInteger(e) || e <= this.inputAck || e >= this.seq) throw new t({ detail: "Replay requires a joined session and an unacknowledged submitted sequence" });
+		let r = this.codecs.input.full(n);
+		if (W.isFailure(r)) throw r.failure;
+		await this.sendFrame({
+			kind: "Input",
+			firstSeq: e,
+			inputs: [{
+				tickHint: this.tick,
+				payload: r.success
+			}],
+			...this.acknowledgedTick < 0 ? {} : { ackTick: this.acknowledgedTick }
+		});
+	}
+	async ping() {
+		if (this.currentStatus !== "joined") throw new t({ detail: "Ping requires a joined session" });
+		let n = this.clock.now(), r = Math.floor(n);
+		if (!Number.isFinite(n) || n < 0 || !Number.isSafeInteger(r)) throw new t({ detail: "Invalid local ping clock" });
+		for (let [e, t] of this.pendingPings) n - t >= this.sampling.pingTimeoutMs && this.pendingPings.delete(e);
+		if (!this.pendingPings.has(r)) {
+			if (this.pendingPings.size >= this.sampling.maxPendingPings) throw new e({
+				budget: "pendingClockPings",
+				limit: this.sampling.maxPendingPings
+			});
+			this.pendingPings.set(r, n);
+			try {
+				await this.sendFrame({
+					kind: "Ping",
+					clientTimeMs: r
+				});
+			} catch (e) {
+				throw this.pendingPings.delete(r), e;
+			}
+		}
+	}
+	subscribe(e) {
+		return this.listeners.add(e), () => {
+			this.listeners.delete(e);
+		};
+	}
+	onWorldHandoff(e) {
+		return this.handoffListeners.add(e), () => {
+			this.handoffListeners.delete(e);
+		};
+	}
+	onMessage(e, t) {
+		let n = this.messageListeners.get(e) ?? /* @__PURE__ */ new Set();
+		return n.add(t), this.messageListeners.set(e, n), () => {
+			n.delete(t), n.size === 0 && this.messageListeners.delete(e);
+		};
+	}
+	async sendFrame(e) {
+		let t = L(e);
+		if (W.isFailure(t)) throw t.failure;
+		await this.transport.reliable.send(t.success);
+	}
+	sampleLoss(e) {
+		let t = this.deltaDatagramsReceived, n = this.lossSample;
+		if (n === null || e < n.sent) {
+			this.lossSample = {
+				sent: e,
+				received: t
+			};
+			return;
+		}
+		let r = e - n.sent;
+		if (r < 8) return;
+		let i = 1 - Math.min(r, t - n.received) / r;
+		this.lossEstimate = this.lossEstimate === null ? i : this.lossEstimate * .75 + i * .25, this.lossSample = {
+			sent: e,
+			received: t
+		};
+	}
+	ackFrame(e) {
+		return this.lossEstimate === null ? {
+			kind: "Ack",
+			tick: e
+		} : {
+			kind: "Ack",
+			tick: e,
+			lossPermille: Math.round(this.lossEstimate * 1e3)
+		};
+	}
+	acknowledge(e = this.tick) {
+		if (this.acknowledgedTick = e, this.transport.unreliable) {
+			let t = L(this.ackFrame(e));
+			if (W.isFailure(t)) {
+				this.fail(t.failure);
+				return;
+			}
+			if (t.success.byteLength <= this.transport.unreliable.maxDatagramBytes) {
+				try {
+					this.transport.unreliable.send(t.success);
+				} catch (e) {
+					this.fail(e);
+				}
+				return;
+			}
+		}
+		this.sendFrame(this.ackFrame(e)).catch((e) => this.fail(e));
+	}
+	fail(e) {
+		this.currentStatus !== "left" && this.currentStatus !== "kicked" && this.currentStatus !== "gone" && (this.currentError = e instanceof t ? e : new t({ detail: "Room transport failed" }), this.currentStatus = "left", this.cleanup(), this.transport.close(1002, "Room protocol error"), this.notify());
+	}
+	install(e, t, n) {
+		for (this.tick = e, this.receivedAt = n, this.currentState = structuredClone(t), this.baselines.set(e, structuredClone(t)); this.baselines.size > this.maxBaselines;) {
+			let e = this.baselines.keys().next();
+			if (e.done) break;
+			this.baselines.delete(e.value);
+		}
+		this.pairInputState(), this.acknowledge(), this.notify();
+	}
+	pairInputState() {
+		let e = this.pendingInputAck;
+		if (!e || !this.baselines.has(e.tick)) return;
+		let t = this.baselines.get(e.tick);
+		this.pairedInputState = Object.freeze({
+			epoch: this.epoch,
+			tick: e.tick,
+			lastAppliedSeq: e.seq,
+			state: structuredClone(t)
+		});
+	}
+	observeInputAck(e, n, r) {
+		if (n >= this.seq) return this.fail(new t({ detail: "Input acknowledgement exceeds submitted history" })), "refused";
+		if (r & -2) return this.fail(new t({ detail: "Unknown input acknowledgement flags" })), "refused";
+		let i = this.pendingInputAck;
+		return i && (n < i.seq || n === i.seq && e <= i.tick) ? "ignored" : i && e < i.tick ? (this.fail(new t({ detail: "Input receipt tick regressed while its sequence advanced" })), "refused") : (this.inputAck = Math.max(this.inputAck, n), this.pendingInputAck = Object.freeze({
+			tick: e,
+			seq: n
+		}), "accepted");
+	}
+	receive(e, n, r = !1) {
+		if (!Number.isFinite(n) || n < 0) {
+			this.fail(new t({ detail: "Invalid local room observation time" }));
+			return;
+		}
+		let i = I(e);
+		if (W.isFailure(i)) {
+			this.fail(i.failure);
+			return;
+		}
+		let a = i.success;
+		if (r && a.kind !== "Delta" && a.kind !== "InputAck" && a.kind !== "Pong" && (a.kind !== "ServerMessage" || this.codecs.channels[a.channelId]?.reliable !== !1)) this.fail(new t({ detail: "Room control and reliable message frames require the reliable lane" }));
+		else switch (r && a.kind === "Delta" && this.deltaDatagramsReceived++, a.kind) {
+			case "Welcome": {
+				if (!this.started || this.currentStatus !== "connecting") {
+					this.fail(new t({ detail: "Unexpected Welcome" }));
+					return;
+				}
+				let e = this.codecs.transformRules;
+				if (e.length !== a.transformRules.length || e.some((e, t) => e !== a.transformRules[t])) {
+					this.fail(new t({ detail: "Room transform rules do not match the admitted client manifest" }));
+					return;
+				}
+				let r = this.codecs.state.decodeFull(a.baseline);
+				if (W.isFailure(r)) {
+					this.fail(r.failure);
+					return;
+				}
+				try {
+					this.clockSync.anchor(a.serverTimeMs, n);
+				} catch (e) {
+					this.fail(e);
+					return;
+				}
+				this.sessionId = a.sessionId, this.epoch = a.epoch, this.currentStatus = "joined", this.install(a.tick, r.success, n);
+				return;
+			}
+			case "Full": {
+				if (this.currentStatus !== "joined") {
+					this.fail(new t({ detail: "Full requires a joined session" }));
+					return;
+				}
+				if (a.epoch < this.epoch || a.epoch === this.epoch && a.tick < this.tick) return;
+				let e = this.codecs.state.decodeFull(a.baseline);
+				if (W.isFailure(e)) {
+					this.fail(e.failure);
+					return;
+				}
+				if (a.epoch !== this.epoch && (this.clockSync.reset(), this.pendingPings.clear(), this.pendingInputAck = null, this.pairedInputState = null), a.inputAck && this.observeInputAck(a.tick, a.inputAck.lastAppliedSeq, a.inputAck.flags) === "refused") return;
+				this.epoch = a.epoch, this.baselines.clear(), this.install(a.tick, e.success, n);
+				return;
+			}
+			case "Delta": {
+				if (this.currentStatus !== "joined") {
+					this.fail(new t({ detail: "Delta requires a joined session" }));
+					return;
+				}
+				if (a.tick <= this.tick) return;
+				let e = this.baselines.get(a.baseTick);
+				if (e === void 0) {
+					this.acknowledge();
+					return;
+				}
+				let r = this.codecs.state.decodeDelta(a.patch, e);
+				if (W.isFailure(r)) {
+					this.fail(r.failure);
+					return;
+				}
+				if (a.inputAck && this.observeInputAck(a.tick, a.inputAck.lastAppliedSeq, a.inputAck.flags) === "refused") return;
+				this.install(a.tick, r.success, n);
+				return;
+			}
+			case "InputAck":
+				if (this.currentStatus !== "joined") {
+					this.fail(new t({ detail: "Input acknowledgement requires a joined session" }));
+					return;
+				}
+				if (r && a.tick <= this.tick || this.observeInputAck(a.tick, a.lastAppliedSeq, a.flags) !== "accepted") return;
+				this.pairInputState(), !this.baselines.has(a.tick) && a.tick < this.tick && this.acknowledge(Math.max(0, Math.min(this.tick, a.tick - 1))), this.notify();
+				return;
+			case "Pong": {
+				if (this.currentStatus !== "joined") {
+					this.fail(new t({ detail: "Pong requires a joined session" }));
+					return;
+				}
+				if (a.deltaDatagramsSent !== void 0 && this.pendingPings.has(a.clientTimeMs) && this.sampleLoss(a.deltaDatagramsSent), r && a.tick <= this.tick) return;
+				let e = this.pendingPings.get(a.clientTimeMs);
+				if (e === void 0 || (this.pendingPings.delete(a.clientTimeMs), n - e >= this.sampling.pingTimeoutMs)) return;
+				try {
+					this.clockSync.pong(e, a.serverTimeMs, n), this.notify();
+				} catch (e) {
+					this.fail(e);
+				}
+				return;
+			}
+			case "ServerMessage": {
+				if (this.currentStatus !== "joined") {
+					this.fail(new t({ detail: "Messages require a joined session" }));
+					return;
+				}
+				let e = this.codecs.channels[a.channelId];
+				if (!e || e.direction === "client") {
+					this.fail(new t({ detail: "Channel is not server-sendable" }));
+					return;
+				}
+				let n = e.codec.decodeFull(a.payload);
+				if (W.isFailure(n)) {
+					this.fail(n.failure);
+					return;
+				}
+				for (let t of this.messageListeners.get(e.name) ?? []) t(n.success);
+				return;
+			}
+			case "WorldHandoff": {
+				if (this.currentStatus !== "joined") {
+					this.fail(new t({ detail: "World handoff requires a joined session" }));
+					return;
+				}
+				if (a.sourceEpoch < this.epoch) return;
+				if (a.sourceEpoch !== this.epoch) {
+					this.fail(new t({ detail: "World handoff source epoch does not match the session" }));
+					return;
+				}
+				let e = Object.freeze({ ...a });
+				for (let t of this.handoffListeners) t(e);
+				return;
+			}
+			case "Kick":
+				this.currentStatus = "kicked", this.cleanup(), this.transport.close(1e3, "Room kicked"), this.notify();
+				return;
+			case "Migrate":
+				this.currentStatus = "reconnecting", this.cleanup(), this.transport.close(1e3, "Room migrating"), this.notify();
+				return;
+			case "Error":
+				this.fail(new t({ detail: a.detail }));
+				return;
+			default: this.fail(new t({ detail: "Server sent a client-only frame" }));
+		}
+	}
+	notify() {
+		for (let e of this.listeners) e();
+	}
+	cleanup() {
+		this.pendingPings.clear(), this.inputHistory.clear();
+		for (let e of this.detach.splice(0)) e();
+	}
+	async leave() {
+		try {
+			!this.transport.signal.aborted && this.currentStatus === "joined" && await this.sendFrame({
+				kind: "Leave",
+				reason: 0
+			});
+		} finally {
+			this.currentStatus = "left", this.cleanup(), this.transport.close(1e3, "Room left"), this.notify(), this.listeners.clear(), this.messageListeners.clear(), this.handoffListeners.clear();
+		}
+	}
+}, Y = J.prototype.currentReliableChannelIdentity, X = J.prototype.onMessage, Z = J.prototype.subscribe, Q = (e, n, r) => {
+	if (!e || typeof e != "object" || !q.has(e)) throw new t({ detail: "Actual constructed Room client Session is required" });
+	let i = e;
+	return Object.freeze({
+		identity: () => Y.call(i, n, r),
+		onMessage: (e) => X.call(i, n, e),
+		subscribe: (e) => Z.call(i, e)
+	});
+}, $ = J.prototype.currentReliableClientChannelIdentity, ne = J.prototype.message, re = (e, n, r) => {
+	if (!e || typeof e != "object" || !q.has(e)) throw new t({ detail: "Actual constructed client Session required for geometry requests" });
+	let i = e;
+	return Object.freeze({
+		identity: () => $.call(i, n, r),
+		write: (e) => {
+			if (!$.call(i, n, r)) throw new t({ detail: "Geometry request lost its exact native client channel admission" });
+			return ne.call(i, n, e);
+		}
+	});
+};
+//#endregion
+export { p as RoomConnection, d as RoomInputRedundancy, v as RoomLatestDatagram, J as RoomSession, ee as RoomStreamFrameDecoder, l as RoomTransportCleanupFailure, B as WorldClient, a as WorldClientReceiptSchema, o as WorldClientRequestIdSchema, s as WorldClientTicketSchema, Q as captureRoomClientReliableChannel, re as captureRoomClientReliableIntention, u as captureRoomTransportEndpoints, A as createRoom, j as createRoomClient, m as defaultRoomClockPingCadence, G as defaultRoomClockSampling, f as defaultRoomInputRedundancy, h as defaultRoomReconnectPolicy, g as defaultRoomWebSocketFactory, x as defaultRoomWebTransportFactory, y as encodeRoomStreamFrame, M as joinById, N as joinRoom, te as joinSeat, P as joinWorld, w as listRooms, b as makeRoomStreamTransport, z as makeWorldEntityHandoffView, c as makeWorldHandoffView, _ as openRoomSocketTransport, S as openRoomWebTransport, K as roomCodecs, T as roomRpcReservations, C as roomTransportConnector, V as worldClientReceipt, H as worldClientTicket, E as worldRpcControls, D as worldRpcFollowerReservations, O as worldRpcPending, k as worldRpcReservations };

package/dist/webTransportClient.js

@@ -0,0 +1,173 @@
+import { ProtocolError as e, RoomAuthoringError as t } from "./errors.js";
+import { captureRoomTransportClock as n } from "./transportAuthoring.js";
+import { RoomTransportCleanupFailure as r } from "./transportCleanup.js";
+import { RoomStreamFrameDecoder as i } from "./streamFraming.js";
+import { makeRoomStreamTransport as a } from "./streamTransport.js";
+//#region src/webTransportClient.ts
+var o = (t, n) => {
+	let r = Reflect.get(globalThis, "WebTransport");
+	if (typeof r != "function") throw new e({ detail: "This platform requires a Room WebTransport factory" });
+	let i = n === void 0 ? {} : { serverCertificateHashes: [{
+		algorithm: "sha-256",
+		value: Uint8Array.from(atob(n), (e) => e.charCodeAt(0))
+	}] };
+	return Reflect.construct(r, [t, {
+		requireUnreliable: !1,
+		datagramsReadableType: "bytes",
+		...i
+	}]);
+}, s = (e) => {
+	if (typeof e.createWritable == "function") return () => e.createWritable();
+	let t = e.writable;
+	return t instanceof WritableStream ? () => t : void 0;
+}, c = async (c, l, u, d) => {
+	let f = [
+		"factory",
+		"clock",
+		"connectTimeoutMs",
+		"maxFrameBytes",
+		"maxChunkBytes",
+		"maxFramesPerChunk",
+		"maxQueuedBytes",
+		"maxListeners",
+		"maxDatagramBytes"
+	];
+	if (!u || Object.getPrototypeOf(u) !== Object.prototype || Reflect.ownKeys(u).some((e) => {
+		let t = Object.getOwnPropertyDescriptor(u, e);
+		return typeof e != "string" || !f.includes(e) || !t?.enumerable || !("value" in t);
+	}) || u.factory !== void 0 && typeof u.factory != "function" || !Number.isSafeInteger(u.connectTimeoutMs) || u.connectTimeoutMs < 1 || u.connectTimeoutMs > 3e5 || !Number.isSafeInteger(u.maxQueuedBytes) || u.maxQueuedBytes < 1 || u.maxQueuedBytes > 33554432 || !Number.isSafeInteger(u.maxListeners) || u.maxListeners < 1 || u.maxListeners > 1024 || !Number.isSafeInteger(u.maxDatagramBytes) || u.maxDatagramBytes < 1 || u.maxDatagramBytes > 65535) throw new t({
+		room: "webtransport",
+		detail: "Room WebTransport requires actual providers and bounded budgets"
+	});
+	let p = Object.freeze({
+		maxFrameBytes: u.maxFrameBytes,
+		maxChunkBytes: u.maxChunkBytes,
+		maxFramesPerChunk: u.maxFramesPerChunk
+	});
+	new i(p);
+	let m = n(u.clock), h = u.factory ?? o, g = u.maxQueuedBytes, _ = u.maxListeners, v = u.maxDatagramBytes, y = u.connectTimeoutMs, b;
+	try {
+		b = new URL(c);
+	} catch {
+		throw new e({ detail: "Room WebTransport requires a valid HTTPS address" });
+	}
+	if (b.protocol !== "https:" || b.username || b.password || b.search || b.hash) throw new e({ detail: "Room WebTransport address must use HTTPS without credentials, query or fragment" });
+	if (l.aborted) throw new e({ detail: "Room WebTransport admission was cancelled" });
+	let x;
+	if (d !== void 0 && !/^[A-Za-z0-9+/]{43}=$/.test(d)) throw new e({ detail: "Room WebTransport certificate hash must be one base64 SHA-256 digest" });
+	try {
+		x = d === void 0 ? h(b.toString()) : h(b.toString(), d);
+	} catch {
+		throw new e({ detail: "Room WebTransport native acquisition failed" });
+	}
+	if (!x || typeof x.close != "function" || typeof x.createBidirectionalStream != "function" || typeof x.ready?.then != "function" || typeof x.closed?.then != "function") {
+		typeof x?.ready?.then == "function" && Promise.resolve(x.ready).catch(() => {});
+		let t = !1, n = new r(async () => {
+			if (x && typeof x.close == "function" && !t && (x.close({
+				closeCode: 1e3,
+				reason: "Room WebTransport provider admission failed"
+			}), t = !0), !t || typeof x.closed?.then != "function") throw new e({ detail: "Room WebTransport provider lifetime remains unknown" });
+			await Promise.resolve(x.closed).catch(() => {});
+		});
+		try {
+			await n.cleanupAsync();
+		} catch {
+			throw n;
+		}
+		throw new e({ detail: "Room WebTransport provider admission failed" });
+	}
+	let S = x.close.bind(x), C = x.createBidirectionalStream.bind(x), w = x.ready, T = x.closed, E = new AbortController(), D = !1, O, k, A, j, M, N, P = Promise.resolve(T).then(() => {
+		D = !0, E.abort();
+	}, () => {
+		D = !0, E.abort();
+	}), F = () => {
+		E.abort();
+	};
+	l.addEventListener("abort", F, { once: !0 }), l.aborted && E.abort();
+	let I = () => {
+		O !== void 0 && clearTimeout(O), O = void 0, l.removeEventListener("abort", F);
+	}, L = async (e, t) => {
+		I(), D || S({
+			closeCode: e,
+			reason: t
+		}), await P;
+	}, R = () => {}, z = new Promise((t, n) => {
+		let r = () => {
+			n(new e({ detail: "Room WebTransport admission was cancelled, closed or exceeded its deadline" }));
+		};
+		E.signal.addEventListener("abort", r, { once: !0 }), R = () => {
+			E.signal.removeEventListener("abort", r);
+		}, O = setTimeout(() => {
+			E.abort();
+		}, y), E.signal.aborted && r();
+	}), B = (async () => {
+		if (await w, E.signal.aborted) throw new e({ detail: "Room WebTransport closed before stream admission" });
+		let t = x.reliability, n = t === void 0 ? Number.isSafeInteger(x.datagrams?.maxDatagramSize) && x.datagrams.maxDatagramSize > 0 && s(x.datagrams) !== void 0 ? "supports-unreliable" : "reliable-only" : t;
+		if (n !== "reliable-only" && n !== "supports-unreliable") throw new e({ detail: "Room WebTransport did not establish a reliability capability" });
+		let r = await C();
+		if (k = {
+			readable: r.readable,
+			writable: r.writable
+		}, E.signal.aborted) throw new e({ detail: "Room WebTransport closed before stream transfer" });
+		if (n === "supports-unreliable") {
+			let t = x.datagrams, n = t.maxDatagramSize, r = s(t);
+			if (!Number.isSafeInteger(n) || n < 1 || n > 65535 || r === void 0) throw new e({ detail: "Room WebTransport did not provide an actual bounded datagram capability" });
+			j = t.readable, A = {
+				readable: j,
+				writable: r()
+			}, M = await a({
+				...p,
+				reliable: k,
+				datagrams: {
+					...A,
+					maxDatagramBytes: Math.min(v, n)
+				},
+				maxQueuedBytes: g,
+				maxListeners: _,
+				clock: m,
+				signal: E.signal,
+				release: L
+			});
+		} else M = await a({
+			...p,
+			reliable: k,
+			maxQueuedBytes: g,
+			maxListeners: _,
+			clock: m,
+			signal: E.signal,
+			release: L
+		});
+		return M;
+	})().catch((e) => {
+		throw e instanceof r && (N = e), e;
+	});
+	try {
+		let t = await Promise.race([B, z]);
+		if (E.signal.aborted) throw new e({ detail: "Room WebTransport closed during admission" });
+		return O !== void 0 && clearTimeout(O), O = void 0, R(), t;
+	} catch {
+		E.abort(), R();
+		let t = /* @__PURE__ */ new Set(), n = new r(async () => {
+			if (await L(1e3, "Room WebTransport admission failed"), await Promise.allSettled([B]), M) await M.closeAsync(1e3, "Room WebTransport admission failed");
+			else {
+				N && await N.cleanupAsync();
+				let n = [], r = (e, r) => {
+					t.has(e) || n.push(Promise.resolve().then(r).then(() => {
+						t.add(e);
+					}));
+				};
+				for (let e of [k, A]) e && (r(e.readable, () => e.readable.cancel()), r(e.writable, () => e.writable.abort()));
+				if (j && !A && r(j, () => j.cancel()), (await Promise.allSettled(n)).some((e) => e.status === "rejected")) throw new e({ detail: "Room WebTransport stream cleanup remains incomplete" });
+			}
+			I();
+		});
+		try {
+			await n.cleanupAsync();
+		} catch {
+			throw n;
+		}
+		throw new e({ detail: "Room WebTransport admission failed" });
+	}
+};
+//#endregion
+export { o as defaultRoomWebTransportFactory, c as openRoomWebTransport };