@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/wire.js

@@ -0,0 +1,491 @@
+import { ProtocolError as e } from "./errors.js";
+import { captureUint64Words as t } from "./fixedWords.js";
+import { RoomInputCodec as n, RoomStateCodec as r } from "./stateCodec.js";
+import { captureRoomLockstepWireRoster as i } from "./lockstepWireRoster.js";
+import { geometryNativeCodecMetadata as a } from "./geometryNativeMetadata.js";
+import { geometryWorldMetadata as o } from "./geometryWorldMetadata.js";
+import { Result as s } from "effect";
+// src/wire.ts
+var c = "v1/input-ackTick/state-inputReceipt/pong-tick/lockstep-v4-snapshot/recovery-v2/world-handoff-v1", l = Object.freeze({
+	maxBytes: 65536,
+	maxInputs: 256
+});
+function u(t) {
+	throw new e({ detail: t });
+}
+var d = (e) => Number.isInteger(e) && e >= 0 && e <= 4294967295 ? e : u("Expected an unsigned32 lockstep word"), f = (e) => Number.isSafeInteger(e) && e >= 0 ? e : u("Expected a nonnegative safe integer"), p = (e) => ((!["departed", "cancelled"].includes(e.phase) || ![
+	e.transitionId,
+	e.entityId,
+	e.targetRoomId
+].every((e) => typeof e == "string" && /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,190}$/.test(e)) || ![e.sourceEpoch, e.targetEpoch].every((e) => Number.isSafeInteger(e) && e > 0) || !Number.isSafeInteger(e.holdMs) || e.holdMs < 1 || e.holdMs > 3e5) && u("Invalid World handoff metadata"), f(e.tick), e), m = class {
+	maxBytes;
+	bytes = [];
+	constructor(e) {
+		this.maxBytes = e;
+	}
+	byte(e) {
+		(!Number.isInteger(e) || e < 0 || e > 255) && u("Expected an unsigned byte"), this.bytes.length >= this.maxBytes && u("Frame exceeds its byte budget"), this.bytes.push(e);
+	}
+	word(e) {
+		d(e);
+		for (let t = 0; t < 4; t++) this.byte(e >>> t * 8 & 255);
+	}
+	uint(e) {
+		let t = f(e);
+		do {
+			let e = t % 128;
+			t = Math.floor(t / 128), this.byte(e + (t > 0 ? 128 : 0));
+		} while (t > 0);
+	}
+	blob(e) {
+		e.byteLength > this.maxBytes - this.bytes.length && u("Blob exceeds its byte budget"), this.uint(e.byteLength);
+		for (let t of e) this.byte(t);
+	}
+	string(e) {
+		e.isWellFormed() || u("Strings must contain well-formed Unicode"), this.blob(new TextEncoder().encode(e));
+	}
+	finish() {
+		return Uint8Array.from(this.bytes);
+	}
+}, h = class {
+	bytes;
+	at = 0;
+	constructor(e) {
+		this.bytes = e;
+	}
+	remaining() {
+		return this.bytes.byteLength - this.at;
+	}
+	byte() {
+		let e = this.bytes[this.at++];
+		return e === void 0 ? u("Truncated frame") : e;
+	}
+	word() {
+		let e = 0;
+		for (let t = 0; t < 4; t++) e += this.byte() * 2 ** (t * 8);
+		return e;
+	}
+	uint() {
+		let e = 0, t = 1;
+		for (let n = 0; n < 8; n++) {
+			let r = this.byte(), i = r & 127;
+			if (e += i * t, Number.isSafeInteger(e) || u("Varint exceeds the safe integer range"), r < 128) return n > 0 && i === 0 && u("Noncanonical varint"), e;
+			t *= 128;
+		}
+		u("Varint is too long");
+	}
+	blob() {
+		let e = this.uint();
+		e > this.remaining() && u("Truncated blob");
+		let t = this.bytes.slice(this.at, this.at + e);
+		return this.at += e, t;
+	}
+	string() {
+		return new TextDecoder("utf-8", { fatal: !0 }).decode(this.blob());
+	}
+	end() {
+		this.remaining() !== 0 && u("Trailing frame bytes");
+	}
+}, g = (e) => {
+	let t = {
+		...l,
+		...e
+	};
+	return (!Number.isSafeInteger(t.maxBytes) || t.maxBytes < 1 || !Number.isSafeInteger(t.maxInputs) || t.maxInputs < 1) && u("Invalid frame limits"), t;
+}, _ = (t) => t instanceof e ? t : new e({ detail: "Malformed frame" }), v = (e) => e.remaining() === 0 ? {} : { inputAck: {
+	lastAppliedSeq: e.uint(),
+	flags: e.byte()
+} }, y = (e, t) => {
+	t !== void 0 && (e.uint(t.lastAppliedSeq), e.byte(t.flags));
+}, b = (e, t) => {
+	if (!Array.isArray(e) || e.length < 1 || e.length > t || Reflect.ownKeys(e).length !== e.length + 1) return u("Lockstep arrays exceed count or dense-shape budget");
+	let n = [];
+	for (let t = 0; t < e.length; t++) {
+		let r = Object.getOwnPropertyDescriptor(e, String(t));
+		if (!r?.enumerable || !("value" in r)) return u("Lockstep arrays cannot contain holes or accessors");
+		n.push(r.value);
+	}
+	return n;
+}, x = (e) => {
+	let t = 0, n = e;
+	for (; n !== 0;) n &= n - 1, t++;
+	return t;
+}, S = (e) => x(e.hi) + x(e.lo), C = (e, n) => {
+	let r = t(n), i = S(r);
+	return i === 0 ? u("Lockstep player mask must contain at least one slot") : (e.word(r.hi), e.word(r.lo), i);
+}, w = (e) => {
+	let t = {
+		hi: e.word(),
+		lo: e.word()
+	};
+	return S(t) === 0 ? u("Lockstep player mask must contain at least one slot") : t;
+}, T = (e, t, n) => {
+	d(e), (!Number.isSafeInteger(t) || t < 1 || t > n || e > 4294967295 - t + 1) && u("Lockstep tick batch exceeds count or unsigned32 tick budget");
+}, E = (e) => e instanceof Uint8Array ? e : u("Lockstep payloads require byte arrays"), D = (t, n = {}) => {
+	try {
+		let r = g(n);
+		t.byteLength > r.maxBytes && u("Frame exceeds its byte budget");
+		let a = new h(t), o;
+		switch (a.byte()) {
+			case 1: {
+				let e = a.uint(), t = a.blob(), n = a.uint(), r = a.remaining() > 1 ? a.uint() : void 0;
+				o = {
+					kind: "Hello",
+					protocolVersion: e,
+					token: t,
+					schemaHash: n,
+					...r === void 0 ? {} : { resumeFromTick: r },
+					transportCaps: a.byte()
+				};
+				break;
+			}
+			case 2: {
+				let e = a.uint(), t = a.uint();
+				(t < 1 || t > r.maxInputs || e > 2 ** 53 - 1 - t + 1) && u("Input batch exceeds its sequence or count budget");
+				let n = [];
+				for (let e = 0; e < t; e++) n.push({
+					tickHint: a.uint(),
+					payload: a.blob()
+				});
+				o = {
+					kind: "Input",
+					firstSeq: e,
+					inputs: n,
+					...a.remaining() === 0 ? {} : { ackTick: a.uint() }
+				};
+				break;
+			}
+			case 7: {
+				let e = a.uint(), t = a.uint();
+				T(e, t, r.maxInputs);
+				let n = [];
+				for (let e = 0; e < t; e++) n.push(a.blob());
+				o = {
+					kind: "LsInput",
+					firstTick: e,
+					inputs: n
+				};
+				break;
+			}
+			case 8:
+				o = {
+					kind: "LsHash",
+					tick: d(a.uint()),
+					hi: a.word(),
+					lo: a.word()
+				};
+				break;
+			case 138: {
+				let e = a.uint(), t = a.uint();
+				T(e, t, r.maxInputs);
+				let n = [], i = 0;
+				for (let e = 0; e < t; e++) {
+					let e = w(a), t = S(e);
+					i += t, i > r.maxInputs && u("Lockstep matrix cells exceed input count budget");
+					let o = [];
+					for (let e = 0; e < t; e++) o.push(a.blob());
+					n.push({
+						players: e,
+						inputs: o
+					});
+				}
+				o = {
+					kind: "LsInputs",
+					firstTick: e,
+					matrices: n
+				};
+				break;
+			}
+			case 139: {
+				let t = d(a.uint()), n = a.byte();
+				if (n === 0) {
+					let e = a.blob();
+					e.byteLength === 0 && u("Lockstep resync requires snapshot bytes"), o = {
+						kind: "LsDesync",
+						tick: t,
+						action: "resync",
+						snapshot: e
+					};
+				} else if (n === 1 || n === 2) o = {
+					kind: "LsDesync",
+					tick: t,
+					action: n === 1 ? "end" : "flag"
+				};
+				else return s.fail(new e({ detail: "Unknown lockstep desync action" }));
+				break;
+			}
+			case 140: {
+				let e = d(a.uint()), t = d(a.uint()), n = a.blob(), s = a.uint(), c = d(a.uint()), l = a.uint();
+				(l < 1 || l > Math.min(64, r.maxInputs)) && u("Start roster exceeds player count budget");
+				let f = [];
+				for (let e = 0; e < l; e++) f.push({
+					slot: a.byte(),
+					playerId: d(a.uint())
+				});
+				let p = i(f, Math.min(64, r.maxInputs));
+				!p.some((e) => e.playerId === c) && p.length >= 64 && u("Start recipient must belong to its actual roster");
+				let m = a.blob(), h = a.blob();
+				(m.byteLength > 0 && h.byteLength > 0 || e > 0 && m.byteLength === 0 && h.byteLength === 0 || e === 0 && h.byteLength > 0) && u("Recovered Start requires one actual history or positive-frontier snapshot"), o = {
+					kind: "LsStart",
+					startTick: e,
+					seed: t,
+					options: n,
+					serverTimeMs: s,
+					localPlayerId: c,
+					roster: p,
+					...m.byteLength ? { history: m } : {},
+					...h.byteLength ? { snapshot: h } : {}
+				};
+				break;
+			}
+			case 141:
+				o = {
+					kind: "LsStall",
+					waitingFor: w(a)
+				};
+				break;
+			case 143: {
+				let e = d(a.uint()), t = a.byte(), n = d(a.uint());
+				(e < 1 || t > 63) && u("Late join names an invalid tick or slot"), o = {
+					kind: "LsJoin",
+					tick: e,
+					slot: t,
+					playerId: n
+				};
+				break;
+			}
+			case 3: {
+				let e = a.uint(), t = a.remaining() === 0 ? void 0 : a.uint();
+				t !== void 0 && t > 1e3 && u("Loss estimate exceeds 1000 permille"), o = {
+					kind: "Ack",
+					tick: e,
+					...t === void 0 ? {} : { lossPermille: t }
+				};
+				break;
+			}
+			case 4:
+				o = {
+					kind: "Ping",
+					clientTimeMs: a.uint()
+				};
+				break;
+			case 5:
+				o = {
+					kind: "ClientMessage",
+					channelId: a.uint(),
+					payload: a.blob()
+				};
+				break;
+			case 6:
+				o = {
+					kind: "Leave",
+					reason: a.byte()
+				};
+				break;
+			case 129:
+				o = {
+					kind: "Welcome",
+					sessionId: a.string(),
+					tick: a.uint(),
+					serverTimeMs: a.uint(),
+					epoch: a.uint(),
+					baseline: a.blob(),
+					transformRules: a.blob()
+				};
+				break;
+			case 130:
+				o = {
+					kind: "Delta",
+					tick: a.uint(),
+					baseTick: a.uint(),
+					patch: a.blob(),
+					...v(a)
+				};
+				break;
+			case 131:
+				o = {
+					kind: "Full",
+					tick: a.uint(),
+					epoch: a.uint(),
+					baseline: a.blob(),
+					...v(a)
+				};
+				break;
+			case 132:
+				o = {
+					kind: "InputAck",
+					lastAppliedSeq: a.uint(),
+					tick: a.uint(),
+					flags: a.byte()
+				};
+				break;
+			case 133: {
+				let e = a.uint(), t = a.uint(), n = a.uint(), r = a.remaining() === 0 ? void 0 : a.uint();
+				o = {
+					kind: "Pong",
+					clientTimeMs: e,
+					serverTimeMs: t,
+					tick: n,
+					...r === void 0 ? {} : { deltaDatagramsSent: r }
+				};
+				break;
+			}
+			case 134:
+				o = {
+					kind: "ServerMessage",
+					channelId: a.uint(),
+					payload: a.blob()
+				};
+				break;
+			case 135:
+				o = {
+					kind: "Kick",
+					code: a.byte(),
+					reason: a.string()
+				};
+				break;
+			case 136: {
+				let e = a.string(), t = a.uint();
+				o = {
+					kind: "Migrate",
+					...e === "" ? {} : { address: e },
+					graceMs: t
+				};
+				break;
+			}
+			case 142: {
+				let e = a.byte();
+				e > 1 && u("Invalid World handoff phase"), o = p({
+					kind: "WorldHandoff",
+					phase: e === 0 ? "departed" : "cancelled",
+					transitionId: a.string(),
+					entityId: a.string(),
+					tick: a.uint(),
+					sourceEpoch: a.uint(),
+					targetRoomId: a.string(),
+					targetEpoch: a.uint(),
+					holdMs: a.uint()
+				});
+				break;
+			}
+			case 137:
+				o = {
+					kind: "Error",
+					code: a.byte(),
+					detail: a.string()
+				};
+				break;
+			default: return s.fail(new e({ detail: "Unknown frame kind" }));
+		}
+		return a.end(), s.succeed(o);
+	} catch (e) {
+		return s.fail(_(e));
+	}
+}, O = (e, t = {}) => {
+	try {
+		let n = g(t), r = new m(n.maxBytes);
+		switch (e.kind) {
+			case "Hello":
+				r.byte(1), r.uint(e.protocolVersion), r.blob(e.token), r.uint(e.schemaHash), e.resumeFromTick !== void 0 && r.uint(e.resumeFromTick), r.byte(e.transportCaps);
+				break;
+			case "Input":
+				(e.inputs.length < 1 || e.inputs.length > n.maxInputs || e.firstSeq > 2 ** 53 - 1 - e.inputs.length + 1) && u("Input batch exceeds its sequence or count budget"), r.byte(2), r.uint(e.firstSeq), r.uint(e.inputs.length);
+				for (let t of e.inputs) r.uint(t.tickHint), r.blob(t.payload);
+				e.ackTick !== void 0 && r.uint(e.ackTick);
+				break;
+			case "LsInput": {
+				let t = b(e.inputs, n.maxInputs);
+				T(e.firstTick, t.length, n.maxInputs), r.byte(7), r.uint(e.firstTick), r.uint(t.length);
+				for (let e of t) r.blob(E(e));
+				break;
+			}
+			case "LsHash":
+				r.byte(8), r.uint(d(e.tick)), r.word(e.hi), r.word(e.lo);
+				break;
+			case "LsInputs": {
+				let t = b(e.matrices, n.maxInputs);
+				T(e.firstTick, t.length, n.maxInputs), r.byte(138), r.uint(e.firstTick), r.uint(t.length);
+				let i = 0;
+				for (let e of t) {
+					e && Object.getPrototypeOf(e) === Object.prototype && Reflect.ownKeys(e).length === 2 || u("Lockstep matrices require exact own players/inputs data");
+					let t = Object.getOwnPropertyDescriptor(e, "players"), a = Object.getOwnPropertyDescriptor(e, "inputs");
+					t?.enumerable && a?.enumerable && "value" in t && "value" in a || u("Lockstep matrix accessors refuse");
+					let o = C(r, t.value), s = b(a.value, 64);
+					(s.length !== o || (i += o) > n.maxInputs) && u("Lockstep matrix mask/cell count exceeds input budget");
+					for (let e of s) r.blob(E(e));
+				}
+				break;
+			}
+			case "LsDesync":
+				r.byte(139), r.uint(d(e.tick)), e.action === "resync" ? (E(e.snapshot).byteLength === 0 && u("Lockstep resync requires snapshot bytes"), r.byte(0), r.blob(e.snapshot)) : e.action === "end" || e.action === "flag" ? (Object.hasOwn(e, "snapshot") && u("Only resync may carry snapshot bytes"), r.byte(e.action === "end" ? 1 : 2)) : u("Unknown lockstep desync action");
+				break;
+			case "LsStart": {
+				let t = Object.getOwnPropertyDescriptor(e, "roster"), a = Object.getOwnPropertyDescriptor(e, "localPlayerId");
+				t?.enumerable && a?.enumerable && "value" in t && "value" in a || u("Start identity requires own data without accessors");
+				let o = i(t.value, Math.min(64, n.maxInputs)), s = d(a.value);
+				!o.some((e) => e.playerId === s) && o.length >= 64 && u("Start recipient must belong to its actual roster"), r.byte(140), r.uint(d(e.startTick)), r.uint(d(e.seed)), r.blob(E(e.options)), r.uint(e.serverTimeMs), r.uint(s), r.uint(o.length);
+				for (let e of o) r.byte(e.slot), r.uint(e.playerId);
+				let c = Object.getOwnPropertyDescriptor(e, "history");
+				(c && (!c.enumerable || !("value" in c)) || !c && "history" in e) && u("Start history requires own data without accessors");
+				let l = Object.getOwnPropertyDescriptor(e, "snapshot");
+				(l && (!l.enumerable || !("value" in l)) || !l && "snapshot" in e) && u("Start snapshot requires own data without accessors");
+				let f = c ? E(c.value) : /* @__PURE__ */ new Uint8Array(), p = l ? E(l.value) : /* @__PURE__ */ new Uint8Array();
+				(f.byteLength > 0 && p.byteLength > 0 || e.startTick > 0 && !f.byteLength && !p.byteLength || e.startTick === 0 && p.byteLength > 0) && u("Recovered Start requires one actual history or positive-frontier snapshot"), r.blob(f), r.blob(p);
+				break;
+			}
+			case "LsStall":
+				r.byte(141), C(r, e.waitingFor);
+				break;
+			case "LsJoin":
+				(d(e.tick) < 1 || !Number.isInteger(e.slot) || e.slot < 0 || e.slot > 63) && u("Late join names an invalid tick or slot"), r.byte(143), r.uint(e.tick), r.byte(e.slot), r.uint(d(e.playerId));
+				break;
+			case "Ack":
+				e.lossPermille !== void 0 && (!Number.isSafeInteger(e.lossPermille) || e.lossPermille < 0 || e.lossPermille > 1e3) && u("Loss estimate must be 0–1000 permille"), r.byte(3), r.uint(e.tick), e.lossPermille !== void 0 && r.uint(e.lossPermille);
+				break;
+			case "Ping":
+				r.byte(4), r.uint(e.clientTimeMs);
+				break;
+			case "ClientMessage":
+				r.byte(5), r.uint(e.channelId), r.blob(e.payload);
+				break;
+			case "Leave":
+				r.byte(6), r.byte(e.reason);
+				break;
+			case "Welcome":
+				r.byte(129), r.string(e.sessionId), r.uint(e.tick), r.uint(e.serverTimeMs), r.uint(e.epoch), r.blob(e.baseline), r.blob(e.transformRules);
+				break;
+			case "Delta":
+				r.byte(130), r.uint(e.tick), r.uint(e.baseTick), r.blob(e.patch), y(r, e.inputAck);
+				break;
+			case "Full":
+				r.byte(131), r.uint(e.tick), r.uint(e.epoch), r.blob(e.baseline), y(r, e.inputAck);
+				break;
+			case "InputAck":
+				r.byte(132), r.uint(e.lastAppliedSeq), r.uint(e.tick), r.byte(e.flags);
+				break;
+			case "Pong":
+				r.byte(133), r.uint(e.clientTimeMs), r.uint(e.serverTimeMs), r.uint(e.tick), e.deltaDatagramsSent !== void 0 && r.uint(e.deltaDatagramsSent);
+				break;
+			case "ServerMessage":
+				r.byte(134), r.uint(e.channelId), r.blob(e.payload);
+				break;
+			case "Kick":
+				r.byte(135), r.byte(e.code), r.string(e.reason);
+				break;
+			case "Migrate":
+				r.byte(136), r.string(e.address ?? ""), r.uint(e.graceMs);
+				break;
+			case "WorldHandoff":
+				p(e), r.byte(142), r.byte(e.phase === "departed" ? 0 : 1), r.string(e.transitionId), r.string(e.entityId), r.uint(e.tick), r.uint(e.sourceEpoch), r.string(e.targetRoomId), r.uint(e.targetEpoch), r.uint(e.holdMs);
+				break;
+			case "Error":
+				r.byte(137), r.byte(e.code), r.string(e.detail);
+				break;
+			default: u("Unknown frame kind");
+		}
+		return s.succeed(r.finish());
+	} catch (e) {
+		return s.fail(_(e));
+	}
+};
+export { n as RoomInputCodec, r as RoomStateCodec, D as decodeRoomFrame, O as encodeRoomFrame, a as geometryNativeCodecMetadata, o as geometryWorldMetadata, c as roomFrameLayout };

package/dist/withdrawalPort.js

@@ -0,0 +1,27 @@
+import { ProtocolError as e } from "./errors.js";
+import { RoomHostWithdrawalPort as t } from "./ports.js";
+import { captureRoomHostWithdrawalInput as n } from "./ownershipWithdrawal.js";
+import { Effect as r, Layer as i } from "effect";
+// src/withdrawalPort.ts
+var a = (t) => {
+	let i = t.host.id, a = t.withdraw.bind(t);
+	return Object.freeze({ withdraw: (t, o) => {
+		try {
+			if (t !== i) throw new e({ detail: "Room withdrawal belongs to another host" });
+			let s = n(o);
+			return r.uninterruptible(r.tryPromise({
+				try: () => a(s),
+				catch: (t) => t instanceof e ? t : new e({ detail: "Room owner withdrawal remains unconfirmed" })
+			}));
+		} catch (t) {
+			return r.fail(t instanceof e ? t : new e({ detail: "Invalid room ownership withdrawal" }));
+		}
+	} });
+}, o = (e) => i.succeed(t, a(e)), s = (t) => Object.freeze({ withdraw: (n, i) => {
+	let o = r.fail(new e({ detail: "Room owner withdrawal remains unconfirmed" })), s = t.local();
+	if (s === void 0) return o;
+	if (n === s.host.id) return a(s).withdraw(n, i);
+	let c = t.peers();
+	return c === void 0 ? o : c.withdraw(n, i);
+} });
+export { o as controllerRoomHostWithdrawalLayer, a as controllerRoomHostWithdrawalService, s as routedRoomHostWithdrawalService };