@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/transformPrediction3d.js

@@ -0,0 +1,126 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { interpolateTransform3D as t, normalizeTransform3D as n } from "./transform3d.js";
+// src/transformPrediction3d.ts
+function r(t) {
+	throw new e({
+		room: "transform-prediction3d",
+		detail: t
+	});
+}
+var i = (e) => Number.isFinite(e) ? e : r("Prediction values and clock must be finite"), a = {
+	x: 0,
+	y: 0,
+	z: 0,
+	qx: 0,
+	qy: 0,
+	qz: 0,
+	qw: 1
+}, o = (e, t) => n({
+	...a,
+	qx: e.qw * t.qx + e.qx * t.qw + e.qy * t.qz - e.qz * t.qy,
+	qy: e.qw * t.qy - e.qx * t.qz + e.qy * t.qw + e.qz * t.qx,
+	qz: e.qw * t.qz + e.qx * t.qy - e.qy * t.qx + e.qz * t.qw,
+	qw: e.qw * t.qw - e.qx * t.qx - e.qy * t.qy - e.qz * t.qz
+}), s = class {
+	pending = [];
+	predicted;
+	rules;
+	step;
+	now;
+	capacity;
+	threshold;
+	blendMs;
+	lastTime;
+	lastSeq = -1;
+	lastAck = -1;
+	correctionAt = 0;
+	offset = {
+		x: 0,
+		y: 0,
+		z: 0
+	};
+	rotationOffset = a;
+	operation = !1;
+	constructor(e, t, a, o) {
+		this.predicted = n(e), typeof a == "function" && o.clock && typeof o.clock.now == "function" || r("Pure step and render clock are required"), (!Number.isSafeInteger(o.capacity) || o.capacity < 1 || o.capacity > 16384) && r("Prediction capacity must be positive and bounded"), this.capacity = o.capacity, this.threshold = i(o.teleportThreshold), this.blendMs = i(o.correctionBlendMs ?? 80), (this.threshold <= 0 || this.blendMs < 0) && r("Prediction correction budgets must be positive/nonnegative");
+		try {
+			this.rules = structuredClone(t);
+		} catch {
+			r("Prediction rules must be detached data");
+		}
+		this.step = a, this.now = o.clock.now.bind(o.clock), this.lastTime = i(this.now()), this.lastTime < 0 && r("Prediction clock must be nonnegative");
+	}
+	enter() {
+		this.operation && r("Reentrant prediction mutation is refused"), this.operation = !0;
+	}
+	time() {
+		let e = i(this.now());
+		return e < this.lastTime && r("Prediction clock must not move backwards"), this.lastTime = e, e;
+	}
+	at(e) {
+		let r = this.blendMs === 0 ? 0 : Math.max(0, 1 - (e - this.correctionAt) / this.blendMs), i = o(t(a, this.rotationOffset, r, 1, "linear"), this.predicted);
+		return n({
+			...i,
+			x: this.predicted.x + this.offset.x * r,
+			y: this.predicted.y + this.offset.y * r,
+			z: this.predicted.z + this.offset.z * r
+		});
+	}
+	send(e, t, a) {
+		this.enter();
+		try {
+			this.time(), (!Number.isSafeInteger(e) || e <= this.lastSeq || i(a) <= 0) && r("Prediction sequence must increase and dt must be positive"), this.pending.length === this.capacity && r("Prediction input history is full");
+			let o = structuredClone(t), s = n(this.step({ ...this.predicted }, structuredClone(o), a, structuredClone(this.rules)));
+			return this.pending = [...this.pending, {
+				seq: e,
+				input: o,
+				dt: a
+			}], this.lastSeq = e, this.predicted = s, this.state();
+		} finally {
+			this.operation = !1;
+		}
+	}
+	reconcile(e, t, i = !1) {
+		this.enter();
+		try {
+			let s = this.time(), c = this.at(s), l = this.predicted;
+			if ((!Number.isSafeInteger(e) || e < 0 || e > this.lastSeq || typeof i != "boolean") && r("Invalid applied receipt or teleport"), e < this.lastAck) return this.state();
+			let u = this.pending.filter((t) => t.seq > e), d = n(t);
+			for (let e of u) d = n(this.step({ ...d }, structuredClone(e.input), e.dt, structuredClone(this.rules)));
+			let f = Math.abs(l.qx * d.qx + l.qy * d.qy + l.qz * d.qz + l.qw * d.qw), p = l.x === d.x && l.y === d.y && l.z === d.z && Math.abs(1 - f) <= 1e-12;
+			if (this.pending = u, this.lastAck = e, this.predicted = d, p && !i) return this.state();
+			let m = {
+				x: c.x - d.x,
+				y: c.y - d.y,
+				z: c.z - d.z
+			}, h = Math.hypot(l.x - d.x, l.y - d.y, l.z - d.z), g = i || h > this.threshold || this.blendMs === 0 || Object.values(m).some((e) => !Number.isFinite(e));
+			return this.offset = g ? {
+				x: 0,
+				y: 0,
+				z: 0
+			} : m, this.rotationOffset = g ? a : o(c, {
+				...d,
+				qx: -d.qx,
+				qy: -d.qy,
+				qz: -d.qz
+			}), this.correctionAt = s, this.state();
+		} finally {
+			this.operation = !1;
+		}
+	}
+	state() {
+		return { ...this.predicted };
+	}
+	render() {
+		this.enter();
+		try {
+			return this.at(this.time());
+		} finally {
+			this.operation = !1;
+		}
+	}
+	queued() {
+		return this.pending.length;
+	}
+};
+export { s as TransformRenderPrediction3D };

package/dist/transformRules.js

@@ -0,0 +1,122 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { quantizationStep as t } from "./room.js";
+// src/transformRules.ts
+function n() {
+	throw new e({
+		room: "transform",
+		detail: "Invalid bounded 2D transform rules"
+	});
+}
+var r = (e) => typeof e == "object" && !!e && !Array.isArray(e), i = (e) => {
+	if (!r(e) || Object.keys(e).some((e) => ![
+		"bounds",
+		"maxSpeed",
+		"maxAccel",
+		"precision",
+		"rotation",
+		"velocity",
+		"interpolation",
+		"extrapolateMs",
+		"teleportThreshold"
+	].includes(e)) || !r(e.bounds) || Object.keys(e.bounds).some((e) => !["min", "max"].includes(e)) || !Array.isArray(e.bounds.min) || !Array.isArray(e.bounds.max) || e.bounds.min.length !== 2 || e.bounds.max.length !== 2 || ![
+		"linear",
+		"hermite",
+		"none"
+	].includes(e.interpolation)) return n();
+	for (let t of [
+		e.maxSpeed,
+		e.maxAccel,
+		e.precision,
+		e.teleportThreshold
+	]) if (typeof t != "number" || !Number.isFinite(t) || t <= 0) return n();
+	if (!Number.isFinite(e.extrapolateMs) || e.extrapolateMs < 0 || e.velocity !== void 0 && ![
+		"send",
+		"derive",
+		"none"
+	].includes(e.velocity)) return n();
+	e.velocity === "send" && t({
+		min: -e.maxSpeed,
+		max: e.maxSpeed,
+		step: e.maxSpeed * 2 / 255
+	});
+	for (let r of [0, 1]) {
+		let i = e.bounds.min[r], a = e.bounds.max[r];
+		if (!Number.isFinite(i) || !Number.isFinite(a) || !Number.isFinite(a - i) || a <= i) return n();
+		t({
+			min: i,
+			max: a,
+			step: e.precision
+		});
+	}
+	if (e.rotation !== void 0 && (!r(e.rotation) || Object.keys(e.rotation).some((e) => e !== "bits") || !Number.isSafeInteger(e.rotation.bits) || e.rotation.bits < 1 || e.rotation.bits > 32)) return n();
+}, a = (e) => (i(e), Object.freeze({
+	bounds: Object.freeze({
+		min: Object.freeze([e.bounds.min[0], e.bounds.min[1]]),
+		max: Object.freeze([e.bounds.max[0], e.bounds.max[1]])
+	}),
+	maxSpeed: e.maxSpeed,
+	maxAccel: e.maxAccel,
+	precision: e.precision,
+	rotation: Object.freeze({ bits: e.rotation?.bits ?? 9 }),
+	...e.velocity === void 0 ? {} : { velocity: e.velocity },
+	interpolation: e.interpolation,
+	extrapolateMs: e.extrapolateMs,
+	teleportThreshold: e.teleportThreshold
+})), o = (e) => {
+	if (!r(e) || Object.keys(e).some((e) => ![
+		"bounds",
+		"maxSpeed",
+		"maxAccel",
+		"precision",
+		"rotation",
+		"interpolation",
+		"extrapolateMs",
+		"teleportThreshold"
+	].includes(e)) || !r(e.bounds) || Object.keys(e.bounds).some((e) => !["min", "max"].includes(e)) || !Array.isArray(e.bounds.min) || !Array.isArray(e.bounds.max) || e.bounds.min.length !== 3 || e.bounds.max.length !== 3 || ![
+		"linear",
+		"hermite",
+		"none"
+	].includes(e.interpolation)) return n();
+	for (let t of [
+		e.maxSpeed,
+		e.maxAccel,
+		e.precision,
+		e.teleportThreshold
+	]) if (typeof t != "number" || !Number.isFinite(t) || t <= 0) return n();
+	if (!Number.isFinite(e.extrapolateMs) || e.extrapolateMs < 0) return n();
+	for (let r of [
+		0,
+		1,
+		2
+	]) {
+		let i = e.bounds.min[r], a = e.bounds.max[r];
+		if (!Number.isFinite(i) || !Number.isFinite(a) || !Number.isFinite(a - i) || a <= i) return n();
+		t({
+			min: i,
+			max: a,
+			step: e.precision
+		});
+	}
+	return e.rotation !== void 0 && (!r(e.rotation) || Object.keys(e.rotation).some((e) => e !== "bits") || !Number.isSafeInteger(e.rotation.bits) || e.rotation.bits < 4 || e.rotation.bits > 20) ? n() : Object.freeze({
+		bounds: Object.freeze({
+			min: Object.freeze([
+				e.bounds.min[0],
+				e.bounds.min[1],
+				e.bounds.min[2]
+			]),
+			max: Object.freeze([
+				e.bounds.max[0],
+				e.bounds.max[1],
+				e.bounds.max[2]
+			])
+		}),
+		maxSpeed: e.maxSpeed,
+		maxAccel: e.maxAccel,
+		precision: e.precision,
+		rotation: Object.freeze({ bits: e.rotation?.bits ?? 10 }),
+		interpolation: e.interpolation,
+		extrapolateMs: e.extrapolateMs,
+		teleportThreshold: e.teleportThreshold
+	});
+}, s = (e) => !r(e) || !r(e.bounds) || !Array.isArray(e.bounds.min) ? n() : e.bounds.min.length === 3 ? o(e) : a(e);
+export { s as captureTransformRules, a as captureTransformRules2D, o as captureTransformRules3D, i as validateTransformRules2D };

package/dist/transformSchemas.js

@@ -0,0 +1,19 @@
+import { fieldId as e, interpolate as t } from "./room.js";
+import { Schema as n } from "effect";
+// src/transformSchemas.ts
+var r = n.Struct({
+	x: n.Number.pipe(e(1)),
+	y: n.Number.pipe(e(2)),
+	rot: n.Number.pipe(e(3), t("angle")),
+	vx: n.optional(n.Number.pipe(e(4))),
+	vy: n.optional(n.Number.pipe(e(5)))
+}), i = n.Struct({
+	x: n.Number.pipe(e(1)),
+	y: n.Number.pipe(e(2)),
+	z: n.Number.pipe(e(3)),
+	qx: n.Number.pipe(e(4)),
+	qy: n.Number.pipe(e(5)),
+	qz: n.Number.pipe(e(6)),
+	qw: n.Number.pipe(e(7))
+});
+export { r as Transform2D, i as Transform3D };

package/dist/transport.js

@@ -0,0 +1,31 @@
+import "./streamFraming.js";
+import "./streamTransport.js";
+// src/transport.ts
+var e = (e) => {
+	let t = /* @__PURE__ */ new Set();
+	return e.onMessage((n, r) => {
+		if (!e.signal.aborted) for (let e of t) e(n, r);
+	}), e.signal.addEventListener("abort", () => {
+		t.clear();
+	}, { once: !0 }), Object.freeze({
+		name: "ws",
+		signal: e.signal,
+		reliable: Object.freeze({
+			send: async (t) => {
+				await e.sendAsync(t);
+			},
+			onFrame: (n) => (e.signal.aborted || t.add(n), () => {
+				t.delete(n);
+			})
+		}),
+		stats: () => ({
+			rttMs: null,
+			queuedBytes: e.queuedBytes,
+			droppedDatagrams: 0
+		}),
+		close: (t, n) => {
+			e.close(t, n);
+		}
+	});
+};
+export { e as gatewayRoomTransport };

package/dist/transportAuthoring.js

@@ -0,0 +1,28 @@
+import { RoomAuthoringError as e } from "./errors.js";
+// src/transportAuthoring.ts
+var t = (t, r, i) => {
+	let a = n(t, r, i);
+	if (a) return a;
+	throw new e({
+		room: "transport",
+		detail: i
+	});
+}, n = (t, n, r) => {
+	let i = t, a = 0;
+	for (; i !== null && (typeof i == "object" || typeof i == "function") && a++ < 16;) {
+		let a = Object.getOwnPropertyDescriptor(i, n);
+		if (a) {
+			if ("value" in a && typeof a.value == "function") return a.value.bind(t);
+			throw new e({
+				room: "transport",
+				detail: r
+			});
+		}
+		i = Object.getPrototypeOf(i);
+	}
+	if (i !== null) throw new e({
+		room: "transport",
+		detail: r
+	});
+}, r = (e) => Object.freeze({ now: t(e, "now", "Room transport clock requires an actual captured data method") });
+export { n as captureOptionalRoomTransportDataMethod, r as captureRoomTransportClock, t as captureRoomTransportDataMethod };

package/dist/transportCleanup.js

@@ -0,0 +1,21 @@
+// src/transportCleanup.ts
+var e = class extends Error {
+	cleanup;
+	_tag = "RoomTransportCleanupFailure";
+	pending;
+	complete = !1;
+	constructor(e) {
+		super("Room transport cleanup remains incomplete"), this.cleanup = e, this.name = "RoomTransportCleanupFailure";
+	}
+	cleanupAsync() {
+		if (this.complete) return Promise.resolve();
+		if (this.pending) return this.pending;
+		let e = Promise.resolve().then(this.cleanup).then(() => {
+			this.complete = !0;
+		});
+		return this.pending = e, e.catch(() => {
+			this.pending === e && (this.pending = void 0);
+		}), e;
+	}
+};
+export { e as RoomTransportCleanupFailure };

package/dist/transportConformance.js

@@ -0,0 +1,123 @@
+import { ProtocolError as e } from "./errors.js";
+import { decodeRoomFrame as t, encodeRoomFrame as n } from "./wire.js";
+import { Result as r } from "effect";
+// src/transportConformance.ts
+var i = (t, n) => {
+	if (!t) throw new e({ detail: n });
+}, a = (e, t) => e.byteLength === t.byteLength && e.every((e, n) => e === t[n]), o = async (o) => {
+	let s = await o(), c = [], l = [], u, d = [];
+	try {
+		i(Number.isSafeInteger(s.maxQueuedBytes) && s.maxQueuedBytes >= 64 && s.maxQueuedBytes <= 4096 && Number.isSafeInteger(s.maxFrameBytes) && s.maxFrameBytes >= 64, "Transport conformance requires bounded real fixture budgets"), i(s.client.unreliable === void 0 == (s.server.unreliable === void 0), "Transport conformance requires matching actual lane capabilities");
+		let e = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(32)), o = n({
+			kind: "Hello",
+			protocolVersion: 1,
+			token: e,
+			schemaHash: 1,
+			transportCaps: s.client.unreliable ? 3 : 1
+		});
+		if (r.isFailure(o)) throw o.failure;
+		let f = !1, p = !1;
+		c.push(s.server.reliable.onFrame((o) => {
+			let c = t(o);
+			if (r.isFailure(c) || c.success.kind !== "Hello") return;
+			i(a(c.success.token, e), "Transport changed the binary control payload"), f = !0;
+			let u = n({
+				kind: "Welcome",
+				sessionId: "conformance",
+				tick: 0,
+				epoch: 0,
+				serverTimeMs: 0,
+				baseline: new Uint8Array([1]),
+				transformRules: /* @__PURE__ */ new Uint8Array()
+			});
+			if (r.isFailure(u)) throw u.failure;
+			l.push(s.server.reliable.send(u.success));
+		})), c.push(s.client.reliable.onFrame((e) => {
+			let n = t(e);
+			r.isSuccess(n) && n.success.kind === "Welcome" && (p = !0);
+		})), l.push(s.client.reliable.send(o.success)), await s.drive(), await Promise.all(l.splice(0)), await s.drive(), i(f && p, "Transport did not exchange actual binary Hello/Welcome controls"), d.push("binary-control");
+		for (let e of c.splice(0)) e();
+		let m = [], h = [
+			new Uint8Array([1, 2]),
+			new Uint8Array([3, 4]),
+			new Uint8Array([5, 6])
+		];
+		c.push(s.server.reliable.onFrame((e) => {
+			m.push(e.slice());
+		}));
+		for (let e of h) l.push(s.client.reliable.send(e));
+		await s.drive(), await Promise.all(l.splice(0)), await s.drive(), i(m.length === h.length && m.every((e, t) => a(e, h[t])), "Transport reliable lane lost/reordered/changed actual frames"), d.push("reliable-order");
+		for (let e of c.splice(0)) e();
+		if (s.client.unreliable && s.server.unreliable) {
+			let e = s.client.unreliable, t = [], n = new Uint8Array([7]);
+			i(Number.isSafeInteger(e.maxDatagramBytes) && e.maxDatagramBytes >= 1 && e.maxDatagramBytes <= 65535, "Transport returned an invalid datagram budget"), c.push(s.server.unreliable.onFrame((e) => {
+				t.push(e.slice());
+			})), e.send(n), n[0] = 99, await s.drive(), i(t.some((e) => a(e, new Uint8Array([7]))), "Transport changed the admitted actual datagram");
+			let r = !1;
+			try {
+				e.send(new Uint8Array(e.maxDatagramBytes + 1));
+			} catch {
+				r = !0;
+			}
+			i(r, "Transport accepted an oversized datagram"), d.push("datagram-bound");
+			for (let e of c.splice(0)) e();
+			i(typeof s.pauseDatagrams == "function", "Datagram conformance requires actual held-write pressure"), u = s.pauseDatagrams();
+			let o = [], l = s.client.stats().droppedDatagrams;
+			c.push(s.server.unreliable.onFrame((e) => {
+				o.push(e.slice());
+			})), e.send(new Uint8Array([1])), await u.blocked;
+			for (let t of [
+				2,
+				3,
+				4
+			]) e.send(new Uint8Array([t]));
+			await s.drive(), i(s.client.stats().droppedDatagrams - l >= 2, "Datagram pressure did not replace older unsent payloads"), u.resume(), u = void 0, await s.drive(), i(o.some((e) => a(e, new Uint8Array([4]))) && !o.some((e) => a(e, new Uint8Array([2])) || a(e, new Uint8Array([3]))), "Datagram pressure did not preserve latest pending payload"), d.push("datagram-latest");
+			for (let e of c.splice(0)) e();
+		}
+		u = s.pauseReliable();
+		let g = new Uint8Array(Math.min(64, s.maxFrameBytes)), _ = [], v = !1, y = s.client.reliable.send(g).then(() => {
+			v = !0, _.push("accepted");
+		}, () => {
+			v = !0, _.push("withdrawn");
+		});
+		l.push(y), await u.blocked, await s.drive(), i(!v && s.client.stats().queuedBytes >= g.byteLength, "Transport did not expose actual held native pressure"), d.push("native-pressure");
+		for (let e = 0; e < 128 && !s.client.signal.aborted; e++) l.push(s.client.reliable.send(g).then(() => {
+			_.push("accepted");
+		}, () => {
+			_.push("withdrawn");
+		}));
+		await s.drive(), i(s.client.signal.aborted, "Transport did not fence actual reliable queue overflow"), u.resume(), u = void 0, await s.drive(), await Promise.all(l.splice(0)), i(_.includes("withdrawn"), "Transport reported every overflowing/withdrawn write as accepted"), d.push("queue-overflow");
+		let b = !1;
+		try {
+			await s.client.reliable.send(g);
+		} catch {
+			b = !0;
+		}
+		return i(b, "Transport accepted a reliable frame after withdrawal"), s.client.close(1e3, "Transport conformance complete"), await s.drive(), i(s.client.signal.aborted, "Transport lost its terminal withdrawal signal"), d.push("withdrawal"), Object.freeze({
+			scope: "transport-only",
+			datagrams: s.client.unreliable !== void 0,
+			checks: Object.freeze(d)
+		});
+	} finally {
+		let t = [];
+		try {
+			u?.resume();
+		} catch (e) {
+			t.push(e);
+		}
+		for (let e of c) try {
+			e();
+		} catch (e) {
+			t.push(e);
+		}
+		try {
+			await s.close();
+		} catch (e) {
+			t.push(e);
+		}
+		let n = await Promise.allSettled(l);
+		for (let e of n) e.status === "rejected" && t.push(e.reason);
+		if (t.length) throw new e({ detail: "Transport conformance owned cleanup remains incomplete" });
+	}
+};
+export { o as roomTransportConformance };

package/dist/transportConnector.js

@@ -0,0 +1,81 @@
+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 { captureRoomTransportEndpoints as i } from "./transportEndpoints.js";
+import { openRoomSocketTransport as a } from "./socketTransport.js";
+import { openRoomWebTransport as o } from "./webTransportClient.js";
+// src/transportConnector.ts
+var s = Object.freeze({
+	connectTimeoutMs: 5e3,
+	maxFrameBytes: 65536,
+	maxChunkBytes: 262144,
+	maxFramesPerChunk: 64,
+	maxQueuedBytes: 1048576,
+	maxListeners: 128,
+	maxDatagramBytes: 65535
+}), c = (e, n) => {
+	if (!e || Object.getPrototypeOf(e) !== Object.prototype || Reflect.ownKeys(e).some((t) => {
+		let r = Object.getOwnPropertyDescriptor(e, t);
+		return typeof t != "string" || !n.includes(t) || !r?.enumerable || !("value" in r);
+	})) throw new t({
+		room: "client",
+		detail: "Room transport selection requires exact own data options"
+	});
+	return Object.freeze({ ...e });
+}, l = (l) => {
+	let u = c(l, [
+		"clock",
+		"preference",
+		"socket",
+		"webTransport"
+	]), d = n(u.clock), f = u.preference ?? "auto";
+	if (![
+		"auto",
+		"ws",
+		"wt"
+	].includes(f)) throw new t({
+		room: "client",
+		detail: "Room transport preference is invalid"
+	});
+	let p = u.socket === void 0 ? {} : c(u.socket, [
+		"factory",
+		"clock",
+		"connectTimeoutMs",
+		"drainPollMs",
+		"maxFrameBytes",
+		"maxPendingBytes",
+		"maxPendingFrames",
+		"highWaterBytes",
+		"maxListeners"
+	]), m = u.webTransport === void 0 ? {} : c(u.webTransport, [
+		"factory",
+		"connectTimeoutMs",
+		"maxFrameBytes",
+		"maxChunkBytes",
+		"maxFramesPerChunk",
+		"maxQueuedBytes",
+		"maxListeners",
+		"maxDatagramBytes"
+	]), h = Object.freeze({
+		...p,
+		clock: d
+	}), g = Object.freeze({
+		...s,
+		...m,
+		clock: d
+	});
+	return async (t, n, s) => {
+		let c = i(s ?? { ws: t });
+		if (c.ws !== i({ ws: t }).ws) throw new e({ detail: "Room reservation and endpoint socket address differ" });
+		if (n.aborted) throw new e({ detail: "Room transport selection was cancelled" });
+		if (f !== "ws" && c.wt !== void 0) try {
+			return await o(c.wt, n, g, c.wtCertificateHash);
+		} catch (t) {
+			if (f === "wt" || n.aborted || t instanceof r || !(t instanceof e)) throw t;
+		}
+		else if (f === "wt") throw new e({ detail: "Room reservation did not advertise WebTransport" });
+		if (n.aborted) throw new e({ detail: "Room transport selection was cancelled" });
+		return a(c.ws, n, h);
+	};
+};
+export { l as roomTransportConnector };

package/dist/transportEndpoints.js

@@ -0,0 +1,37 @@
+import { ProtocolError as e } from "./errors.js";
+// src/transportEndpoints.ts
+var t = (t, n, i) => {
+	if (typeof t != "string" || n != null && typeof n != "string" || i != null && typeof i != "string") throw new e({ detail: "Room host routing data is malformed" });
+	return r({
+		ws: t,
+		...n == null ? {} : { wt: n },
+		...i == null ? {} : { wtCertificateHash: i }
+	});
+}, n = /^[A-Za-z0-9+/]{43}=$/, r = (t) => {
+	if (!t || Object.getPrototypeOf(t) !== Object.prototype || Reflect.ownKeys(t).some((e) => {
+		let n = Object.getOwnPropertyDescriptor(t, e);
+		return typeof e != "string" || ![
+			"ws",
+			"wt",
+			"wtCertificateHash"
+		].includes(e) || !n?.enumerable || !("value" in n);
+	})) throw new e({ detail: "Room endpoints require exact own routing data" });
+	let r = (t, n) => {
+		if (typeof t != "string") throw new e({ detail: "Room endpoint address is missing" });
+		let r;
+		try {
+			r = new URL(t);
+		} catch {
+			throw new e({ detail: "Room endpoint address is malformed" });
+		}
+		if (!n.includes(r.protocol) || r.username || r.password || r.search || r.hash) throw new e({ detail: "Room endpoint address requires its declared protocol without credentials, query or fragment" });
+		return r.toString();
+	}, i = t.wtCertificateHash;
+	if (i !== void 0 && (t.wt === void 0 || typeof i != "string" || !n.test(i))) throw new e({ detail: "Room endpoint certificate hash requires a WebTransport address and one base64 SHA-256 digest" });
+	return Object.freeze({
+		ws: r(t.ws, ["ws:", "wss:"]),
+		...t.wt === void 0 ? {} : { wt: r(t.wt, ["https:"]) },
+		...i === void 0 ? {} : { wtCertificateHash: i }
+	});
+};
+export { r as captureRoomTransportEndpoints, t as roomHostTransportEndpoints };