@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/worldClient.js

@@ -0,0 +1,664 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomAuthoringError as n, WorldTransitionCooldown as r } from "./errors.js";
+import { RoomInputCodec as i } from "./stateCodec.js";
+import { worldTransitionRequest as a } from "./worldCommands.js";
+import { WorldClientReceiptSchema as o, WorldClientRequestIdSchema as s, WorldClientTicketSchema as c } from "./worldClientSchemas.js";
+import { makeWorldHandoffView as l } from "./worldHandoffView.js";
+import { captureGeometryAssetBundle as u } from "./geometryAssetBundle.js";
+import { captureRoomConnectionGeometrySession as d } from "./connection.js";
+import { captureOwnedRoomGeometryChunkCache as f, captureRoomGeometryChunkCache as p, captureRoomGeometryChunkCacheRoot as m } from "./geometryClientChunks.js";
+import { captureGeometryRenderLodCacheOptions as h, makeGeometryRenderLodCache as g } from "./geometryRenderCache.js";
+import { captureWorldCatalog as _ } from "./world.js";
+import { Result as v, Schema as y } from "effect";
+//#region src/worldClient.ts
+var b = (e) => new t({ detail: e }), x = (e, t) => {
+	if (!e || typeof e != "object" || Object.getPrototypeOf(e) !== Object.prototype || Reflect.ownKeys(e).length !== t.length) throw b("Invalid World client record");
+	for (let n of t) {
+		let t = Object.getOwnPropertyDescriptor(e, n);
+		if (!t?.enumerable || !("value" in t)) throw b("World client records require own data");
+	}
+	return e;
+}, S = (e) => {
+	x(x(e, [
+		"requestId",
+		"transitionId",
+		"mode",
+		"target"
+	]).target, [
+		"worldId",
+		"cellId",
+		"layer",
+		"roomId",
+		"epoch"
+	]);
+	try {
+		let t = y.decodeUnknownSync(c)(e);
+		return Object.freeze({
+			requestId: t.requestId,
+			transitionId: t.transitionId,
+			mode: t.mode,
+			target: Object.freeze({
+				worldId: t.target.worldId,
+				cellId: t.target.cellId,
+				layer: t.target.layer,
+				roomId: t.target.roomId,
+				epoch: t.target.epoch
+			})
+		});
+	} catch {
+		throw b("Invalid World client ticket");
+	}
+}, C = (e) => {
+	let t = x(e, [
+		"ticket",
+		"phase",
+		"entityRevision"
+	]), n = S(t.ticket);
+	try {
+		let e = y.decodeUnknownSync(o)({
+			...t,
+			ticket: n
+		});
+		return Object.freeze({
+			ticket: n,
+			phase: e.phase,
+			entityRevision: e.entityRevision
+		});
+	} catch {
+		throw b("Invalid or contradictory World client receipt");
+	}
+}, w = (e, t) => JSON.stringify(e) === JSON.stringify(t), T = class {
+	options;
+	input;
+	handoffView;
+	handoffError = null;
+	controller = new AbortController();
+	commitWaitMs;
+	listeners = /* @__PURE__ */ new Set();
+	queue = [];
+	sends = /* @__PURE__ */ new Set();
+	receiptSubscriptions = /* @__PURE__ */ new Set();
+	draining = !1;
+	bytes = 0;
+	active;
+	source;
+	target = null;
+	sourceGeometry = null;
+	targetGeometry = null;
+	recoveryGeometry = null;
+	preparingAssets = null;
+	earlyAssets = null;
+	earlyAssetController = null;
+	earlyAssetFailed = !1;
+	pendingAssetBundles = /* @__PURE__ */ new Set();
+	geometryAssets = /* @__PURE__ */ new Map();
+	geometryRenders = /* @__PURE__ */ new Map();
+	detachSource = null;
+	detachTarget = null;
+	request = null;
+	prepared = null;
+	committed = !1;
+	assetsReady = !1;
+	operation = null;
+	closeTask = null;
+	closing = !1;
+	currentError = null;
+	snapshot;
+	constructor(e) {
+		let t = [
+			"source",
+			"input",
+			"maxBufferedInputs",
+			"maxBufferedBytes",
+			"maxInFlightInputs",
+			"prepare",
+			"observe",
+			"commit",
+			"cancel",
+			"createTarget",
+			"prefetchAssets"
+		], r = [
+			"commitWaitMs",
+			"subscribeReceipt",
+			"geometry",
+			"handoffView"
+		].filter((t) => Object.hasOwn(e, t));
+		x(e, [...t, ...r]);
+		let a = e.commitWaitMs ?? 2e4;
+		if (!Number.isSafeInteger(a) || a < 1 || a > 3e5) throw b("World commit wait requires a bounded live-query deadline");
+		if (this.commitWaitMs = a, !e || !Number.isSafeInteger(e.maxInFlightInputs) || e.maxInFlightInputs < 1 || e.maxInFlightInputs > 65536 || !Number.isSafeInteger(e.maxBufferedInputs) || e.maxBufferedInputs < 1 || e.maxBufferedInputs > 65536 || !Number.isSafeInteger(e.maxBufferedBytes) || e.maxBufferedBytes < 1 || e.maxBufferedBytes > 67108864) throw new n({
+			room: "world-client",
+			detail: "World input buffers require explicit bounded budgets"
+		});
+		this.handoffView = Object.hasOwn(e, "handoffView") ? l(e.handoffView) : null;
+		let o = { ...e };
+		for (let t of [
+			"prepare",
+			"observe",
+			"commit",
+			"cancel",
+			"createTarget",
+			"prefetchAssets"
+		]) {
+			let n = Object.getOwnPropertyDescriptor(e, t);
+			if (!n || !("value" in n) || typeof n.value != "function") throw b("World client requires actual own provider methods");
+			o[t] = n.value.bind(e);
+		}
+		if (Object.hasOwn(e, "subscribeReceipt")) {
+			let t = Object.getOwnPropertyDescriptor(e, "subscribeReceipt");
+			if (!t || !("value" in t) || typeof t.value != "function") throw b("World receipt wait requires an actual own subscription provider");
+			o.subscribeReceipt = t.value.bind(e);
+		}
+		if (Object.hasOwn(e, "geometry")) {
+			let t = x(e.geometry, [
+				"source",
+				"prepare",
+				...[
+					"recover",
+					"worlds",
+					"render",
+					"assets"
+				].filter((t) => Object.hasOwn(e.geometry, t))
+			]);
+			if (typeof t.prepare != "function") throw b("World geometry requires an actual own preparation provider");
+			let n = p(t.source, d(e.source));
+			if (Object.hasOwn(t, "recover") && typeof t.recover != "function") throw b("World geometry recovery requires an actual own provider");
+			let r = Object.hasOwn(t, "worlds") ? _(t.worlds) : void 0, i = Object.hasOwn(t, "render") ? h(t.render) : void 0;
+			if (i && !r?.length || r && !r.some((e) => e.geometry && e.name === m(n).worldId)) throw b("World render preparation requires its actual immutable geometry catalogue");
+			let a;
+			if (Object.hasOwn(t, "assets")) {
+				let e = x(t.assets, ["prepare", ...[
+					"source",
+					"recover",
+					"preload"
+				].filter((e) => Object.hasOwn(t.assets, e))]);
+				if (typeof e.prepare != "function" || Object.hasOwn(e, "recover") && typeof e.recover != "function" || Object.hasOwn(e, "preload") && typeof e.preload != "function") throw b("World assets require actual own preparation/recovery capabilities");
+				let r = Object.hasOwn(e, "source") ? this.admitGeometryAssets(e.source, n) : void 0;
+				a = Object.freeze({
+					...Object.hasOwn(e, "preload") ? { preload: e.preload.bind(t.assets) } : {},
+					prepare: e.prepare.bind(t.assets),
+					...Object.hasOwn(e, "recover") ? { recover: e.recover.bind(t.assets) } : {},
+					...r ? { source: r } : {}
+				}), r && this.geometryAssets.set(n, r);
+			}
+			o.geometry = Object.freeze({
+				source: n,
+				...a ? { assets: a } : {},
+				...r ? { worlds: r } : {},
+				...i ? { render: i } : {},
+				prepare: t.prepare.bind(e.geometry),
+				...Object.hasOwn(t, "recover") ? { recover: t.recover.bind(e.geometry) } : {}
+			}), this.sourceGeometry = n;
+		}
+		if (this.options = Object.freeze(o), this.input = new i(e.input), this.source = this.active = e.source, this.admitRoom(this.source), this.source.status !== "joined") throw b("World client requires its actual joined source");
+		this.snapshot = Object.freeze({
+			status: "idle",
+			step: null,
+			mode: null,
+			bufferedInputs: 0,
+			bufferedBytes: 0,
+			committed: !1,
+			error: null
+		}), this.detachSource = this.source.subscribe(() => this.notify());
+	}
+	get observation() {
+		return this.snapshot;
+	}
+	get roomId() {
+		return this.closing || this.committed && this.active !== this.target && this.request !== null ? null : this.active.roomId;
+	}
+	get geometry() {
+		return this.closing || this.committed && this.active !== this.target && this.request !== null ? null : this.active === this.target ? this.targetGeometry : this.sourceGeometry;
+	}
+	renderGeometry(e, t) {
+		try {
+			let n = this.geometry, r = this.options.geometry?.worlds;
+			if (!n || !r?.length || this.closing) throw b("World rendering requires its current verified geometry and actual catalogue");
+			let i = m(n), a = r.find((e) => e.name === i.worldId && e.geometry?.kind === i.kind);
+			if (!a) throw b("World render cache escaped its captured catalogue");
+			let o = this.geometryRenders.get(n);
+			return o || (o = g(n, a, this.options.geometry?.render), this.geometryRenders.set(n, o)), o.prepare(e, t);
+		} catch {
+			return Promise.reject(b("World native render preparation could not be admitted"));
+		}
+	}
+	get geometryRenderObservation() {
+		let e = this.geometry;
+		return e ? this.geometryRenders.get(e)?.observation() ?? null : null;
+	}
+	asset(e) {
+		let t = this.geometry, n = t ? this.geometryAssets.get(t) : void 0;
+		if (!n || this.closing) throw b("World asset access requires its selected fully verified owned bundle");
+		return n.at(e);
+	}
+	get assetObservation() {
+		let e = this.geometry;
+		return e ? this.geometryAssets.get(e)?.observation() ?? null : null;
+	}
+	admitGeometryAssets(e, t) {
+		let n = m(t), r = u(e, n.worldId), i = r.root;
+		if (i.tenantId !== n.tenantId || i.layerSetId !== n.layerSetId || i.version !== n.version || !r.observation().ready) throw b("World asset bundle escaped its actual geometry root or completed prefetch");
+		return r;
+	}
+	async closeGeometry(e) {
+		let t = this.geometryRenders.get(e), n = this.geometryAssets.get(e);
+		if ((await Promise.allSettled([
+			e.close(),
+			...t ? [t.close()] : [],
+			...n ? [n.close()] : []
+		])).some((e) => e.status === "rejected")) throw b("World native geometry/render cleanup remains incomplete");
+		this.geometryRenders.delete(e), this.geometryAssets.delete(e);
+	}
+	get error() {
+		return this.currentError;
+	}
+	get state() {
+		return this.committed && this.active !== this.target && this.request !== null ? null : this.active.state;
+	}
+	deliveredSnapshot() {
+		return this.committed && this.active !== this.target && this.request !== null ? null : this.active.deliveredSnapshot();
+	}
+	presentationSnapshot() {
+		if (this.closing) return null;
+		if (this.handoffError) throw this.handoffError;
+		if (this.handoffView) return this.handoffView.read(this.active.roomId, this.deliveredSnapshot());
+		let e = this.deliveredSnapshot();
+		return e ? Object.freeze({
+			snapshot: e,
+			handoff: !1
+		}) : null;
+	}
+	presentationWork(e) {
+		if (!(!this.handoffView || this.handoffError || this.closing)) try {
+			e(this.handoffView);
+		} catch {
+			this.handoffView.close(), this.handoffError = b("World handoff presentation is unavailable; authoritative delivery remains separate");
+		}
+	}
+	subscribe(e) {
+		return this.listeners.add(e), () => {
+			this.listeners.delete(e);
+		};
+	}
+	notify() {
+		this.request && !this.committed && this.presentationWork((e) => e.source(this.source.deliveredSnapshot()));
+		for (let e of this.listeners) try {
+			e();
+		} catch {}
+	}
+	update(e, t) {
+		this.snapshot = Object.freeze({
+			status: e,
+			step: t,
+			mode: this.prepared?.mode ?? null,
+			bufferedInputs: this.queue.length,
+			bufferedBytes: this.bytes,
+			committed: this.committed,
+			error: this.currentError ? "incomplete" : null
+		}), this.notify();
+	}
+	admitRoom(e) {
+		if (!e || [
+			"send",
+			"subscribe",
+			"leave",
+			"deliveredSnapshot"
+		].some((t) => typeof Reflect.get(e, t) != "function")) throw b("World client requires a complete Room connection");
+	}
+	run(e) {
+		if (this.closing || this.operation) return Promise.reject(b("World client is busy or closing"));
+		let t = {
+			status: this.snapshot.status,
+			step: this.snapshot.step
+		}, n = Promise.resolve().then(async () => {
+			try {
+				if (this.closing) throw b("World client is closing");
+				this.currentError = null, this.stopReceipts(), await e(), this.update(this.snapshot.status, this.snapshot.step);
+			} catch (e) {
+				throw e instanceof r ? (this.update(t.status, t.step), e) : (this.currentError = b("World client operation remains incomplete; confirm the saved request before retry"), this.update("failed", this.snapshot.step), this.currentError);
+			}
+		});
+		return this.operation = n, n.then(() => {
+			this.operation = null;
+		}, () => {
+			this.operation = null;
+		}), n;
+	}
+	stopReceipts() {
+		for (let e of this.receiptSubscriptions) e(), this.receiptSubscriptions.delete(e);
+	}
+	transition(e, t) {
+		let n, i;
+		try {
+			i = y.decodeUnknownSync(s)(e), n = a(t);
+		} catch (e) {
+			return Promise.reject(e);
+		}
+		return this.request !== null || this.recoveryGeometry ? Promise.reject(b("A World transition request or geometry recovery cleanup is still retained")) : this.run(async () => {
+			this.beginRequest(i, n.entityId);
+			let e;
+			try {
+				e = await this.options.prepare(i, structuredClone(n), this.controller.signal);
+			} catch (e) {
+				let t = typeof e == "object" && e && e._tag === "WorldTransitionCooldown" ? Number(e.retryAfterMs) : NaN;
+				throw Number.isFinite(t) && t >= 0 ? (this.request = null, this.handoffView?.rollback(), new r({ retryAfterMs: t })) : e;
+			}
+			this.acceptTicket(e), await this.connectAndCommit();
+		});
+	}
+	beginRequest(e, t) {
+		if (this.handoffError = null, this.handoffView) {
+			this.handoffView.read(this.active.roomId, this.deliveredSnapshot());
+			let n = this.source.deliveredSnapshot();
+			if (!n) throw b("World handoff presentation requires an actual source snapshot");
+			this.handoffView.begin(e, t, n);
+		}
+		this.request = Object.freeze({ id: e }), this.committed = !1, this.assetsReady = !1, this.prepared = null, this.update("preparing", "reserve");
+	}
+	adopt(e, t) {
+		let n;
+		try {
+			if (n = y.decodeUnknownSync(s)(e), typeof t != "string" || !/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,190}$/.test(t)) throw b("Invalid World adoption entity identity");
+		} catch (e) {
+			return Promise.reject(e);
+		}
+		return this.request !== null || this.recoveryGeometry ? Promise.reject(b("A World transition request or geometry recovery cleanup is still retained")) : this.run(async () => {
+			this.beginRequest(n, t), await this.reconcileRequest();
+		});
+	}
+	beginAssetPrefetch() {
+		let e = this.options.geometry?.assets, t = this.prepared;
+		if (!e?.preload || !t || this.preparingAssets || this.earlyAssets || this.assetsReady || this.targetGeometry && this.geometryAssets.has(this.targetGeometry)) return;
+		let n = new AbortController(), r = () => n.abort();
+		this.earlyAssetController = n, this.earlyAssetFailed = !1, this.controller.signal.addEventListener("abort", r, { once: !0 }), this.controller.signal.aborted && n.abort();
+		let i = Promise.resolve().then(async () => {
+			let r = e.preload(t, n.signal);
+			if (!(r instanceof Promise)) throw b("World early asset preparation requires its actual Promise");
+			let i = u(await r);
+			if (i === this.geometryAssets.get(this.sourceGeometry)) throw b("World early target assets cannot alias the active source");
+			this.pendingAssetBundles.add(i);
+			let a = this.sourceGeometry ? m(this.sourceGeometry) : null;
+			if (!a || i.root.tenantId !== a.tenantId || i.root.worldId !== t.target.worldId || !i.observation().ready || n.signal.aborted) throw b("World early assets escaped their authenticated target or completed lifetime");
+			return this.earlyAssets = i, i;
+		}).finally(() => {
+			this.controller.signal.removeEventListener("abort", r);
+		});
+		this.preparingAssets = i, i.catch(() => {
+			this.earlyAssetFailed = !0;
+		});
+	}
+	async closePendingAssetBundles() {
+		if (this.earlyAssetController?.abort(), this.preparingAssets && await this.preparingAssets.then(() => void 0, () => void 0), (await Promise.allSettled([...this.pendingAssetBundles].map((e) => e.close()))).some((e) => e.status === "rejected")) throw b("World early asset cleanup remains incomplete");
+		this.pendingAssetBundles.clear(), this.preparingAssets = null, this.earlyAssets = null, this.earlyAssetController = null, this.earlyAssetFailed = !1;
+	}
+	acceptTicket(e) {
+		let t = S(e);
+		if (!this.request || t.requestId !== this.request.id || this.prepared && !w(this.prepared, t)) throw b("World preparation changed request or target");
+		this.presentationWork((e) => e.prepare(t.mode, {
+			roomId: t.target.roomId,
+			epoch: t.target.epoch
+		})), this.prepared = t, this.beginAssetPrefetch();
+	}
+	acceptReceipt(e) {
+		let t = C(e);
+		return this.acceptTicket(t.ticket), t;
+	}
+	async connectTarget() {
+		if (this.earlyAssetFailed && (await this.closePendingAssetBundles(), this.beginAssetPrefetch()), !this.prepared) throw b("World target has no preparation");
+		if (this.target && this.target.status !== "joined" && (this.targetGeometry &&= (await this.closeGeometry(this.targetGeometry), null), await this.target.leave(), this.detachTarget?.(), this.detachTarget = null, this.target = null), !this.target) {
+			this.update("loading", "connect");
+			let e = this.options.createTarget(this.prepared);
+			if (this.admitRoom(e), e === this.source || typeof e.start != "function" || e.status !== "reserving" || e.roomId !== null || e.state !== null) throw b("World target must be a separate unopened Room connection");
+			this.target = e, this.detachTarget = e.subscribe(() => this.notify()), this.update("loading", "welcome"), await e.start(this.prepared);
+		}
+		if (this.target.status !== "joined") throw b("World target has not received its Welcome");
+		let e = this.target.deliveredSnapshot();
+		if (!e || e.epoch !== this.prepared.target.epoch || this.target.roomId !== this.prepared.target.roomId) throw b("World Welcome does not match the target epoch");
+		if (this.options.geometry && !this.targetGeometry) {
+			this.update("loading", "geometry");
+			let e = f(await this.options.geometry.prepare(this.target, this.prepared, this.controller.signal));
+			if (e === this.sourceGeometry) throw b("World target geometry must be separately owned");
+			this.targetGeometry = e;
+			try {
+				p(e, d(this.target), this.prepared.target.worldId);
+			} catch {
+				throw await this.closeGeometry(e), this.targetGeometry = null, b("World target geometry does not match actual native admission/World");
+			}
+			if (this.controller.signal.aborted) throw b("World geometry acquisition was cancelled");
+		}
+		if (!this.assetsReady) {
+			if (this.update("loading", "assets"), this.options.geometry?.assets && this.targetGeometry && !this.geometryAssets.has(this.targetGeometry)) {
+				let e = this.preparingAssets ? await this.preparingAssets : u(await this.options.geometry.assets.prepare(this.target, this.targetGeometry, this.prepared, this.controller.signal));
+				try {
+					let t = this.admitGeometryAssets(e, this.targetGeometry);
+					if (this.controller.signal.aborted || this.geometryAssets.get(this.sourceGeometry) === t) throw b("World target assets require separate owned live preparation");
+					this.geometryAssets.set(this.targetGeometry, t), this.pendingAssetBundles.delete(t), this.earlyAssets = null, this.preparingAssets = null;
+				} catch (t) {
+					throw e !== this.geometryAssets.get(this.sourceGeometry) && await e.close(), t;
+				}
+			}
+			await this.options.prefetchAssets(this.prepared, this.controller.signal), this.assetsReady = !0;
+		}
+	}
+	async connectAndCommit() {
+		if (await this.connectTarget(), this.update("switching", "commit"), (await Promise.allSettled([...this.sends])).some((e) => e.status === "rejected")) throw b("Source intentions remain unconfirmed before commit");
+		let e = null;
+		try {
+			e = { value: await this.options.commit(this.prepared, this.controller.signal) };
+		} catch (e) {
+			if (!this.options.subscribeReceipt) throw e;
+		}
+		let t = e === null ? await this.waitReceipt() : this.acceptReceipt(e.value);
+		if (t.phase === "prepared" && (t = await this.waitReceipt()), t.phase === "rolledBack") await this.finishRollback();
+		else {
+			if (t.phase !== "committed" && t.phase !== "settled") throw b("World server did not confirm its SQL commit");
+			this.committed = !0, this.presentationWork((e) => e.commit()), this.active = this.target, this.update("switching", "cleanup"), await this.finishCommit();
+		}
+	}
+	waitReceipt() {
+		let e = this.controller.signal, t = this.options.subscribeReceipt;
+		if (e.aborted || !this.request || !this.target || this.target.status !== "joined" || !t) return Promise.reject(b("World common commit wait requires its actual live receipt subscription/target"));
+		let n = this.request.id;
+		return new Promise((r, i) => {
+			let a, o = !1, s = !0, c, l, u = !1, d = (t, n) => {
+				if (!o) {
+					o = !0, clearTimeout(p), e.removeEventListener("abort", f);
+					try {
+						a && (a(), this.receiptSubscriptions.delete(a));
+					} catch {
+						i(b("World receipt subscription withdrawal remains incomplete"));
+						return;
+					}
+					t ? r(t) : i(n ?? b("World common commit receipt remains incomplete"));
+				}
+			}, f = () => {
+				d(void 0, b("World commit wait was closed"));
+			}, p = setTimeout(() => {
+				d(void 0, b("World common commit wait budget expired; retain the original request"));
+			}, this.commitWaitMs), m = (e) => {
+				if (!o) try {
+					let t = this.acceptReceipt(e);
+					if (s) {
+						c = t;
+						return;
+					}
+					t.phase !== "prepared" && d(t);
+				} catch (e) {
+					s ? (u = !0, l = e) : d(void 0, e);
+				}
+			}, h = (e) => {
+				s ? (u = !0, l = e) : d(void 0, e);
+			};
+			e.addEventListener("abort", f, { once: !0 });
+			try {
+				let r = t(n, {
+					onValue: m,
+					onError: h
+				}, e), i = r && Object.getOwnPropertyDescriptor(r, "unsubscribe");
+				if (!i || !("value" in i) || typeof i.value != "function") throw b("World receipt subscription requires actual withdrawal");
+				let p = i.value.bind(r);
+				a = p, this.receiptSubscriptions.add(p), s = !1, o ? (p(), this.receiptSubscriptions.delete(p)) : e.aborted ? f() : u ? d(void 0, l) : c?.phase !== "prepared" && c && d(c);
+			} catch (e) {
+				s = !1, d(void 0, e);
+			}
+		});
+	}
+	async flush(e, t) {
+		this.draining = !0;
+		try {
+			for (; this.queue.length;) {
+				if (this.closing) throw b("World client is closing");
+				let n = this.queue.shift();
+				this.bytes -= n.bytes, this.update(this.snapshot.status, this.snapshot.step);
+				try {
+					let r = await e.send(n.input);
+					n.resolve(t ? {
+						sourceSeq: null,
+						targetSeq: r
+					} : {
+						sourceSeq: r,
+						targetSeq: null
+					});
+				} catch {
+					let e = b("Buffered World intention delivery is unconfirmed");
+					throw n.reject(e), e;
+				}
+			}
+		} finally {
+			this.draining = !1;
+		}
+	}
+	async finishCommit() {
+		if (!this.committed || !this.target) throw b("No confirmed World target");
+		this.active = this.target, this.update("switching", "cleanup"), this.sourceGeometry &&= (await this.closeGeometry(this.sourceGeometry), null), await this.source.leave(), this.detachSource?.(), this.detachSource = null, await this.flush(this.target, !0), this.sourceGeometry = this.targetGeometry, this.targetGeometry = null, this.source = this.target, this.target = null, this.detachSource = this.detachTarget, this.detachTarget = null, this.request = null, this.update("settled", null);
+	}
+	resume() {
+		return this.run(() => this.reconcileRequest());
+	}
+	async reconcileRequest() {
+		if (!this.request) throw b("No retained World transition request");
+		let e = this.acceptReceipt(await this.options.observe(this.request.id, this.controller.signal));
+		if (e.phase === "rolledBack") await this.finishRollback();
+		else if (e.phase === "committed" || e.phase === "settled") this.committed = !0, this.presentationWork((e) => e.commit()), await this.connectTarget(), this.active = this.target, await this.finishCommit();
+		else {
+			if (this.committed) throw b("World server receipt regressed after commit");
+			await this.connectAndCommit();
+		}
+	}
+	recoverGeometry() {
+		return this.run(async () => {
+			let e = this.options.geometry;
+			if (!e?.recover || !this.sourceGeometry || this.request || this.target || this.source.status !== "joined") throw b("World geometry recovery requires its current joined source and no retained transition");
+			this.recoveryGeometry &&= (await this.closeGeometry(this.recoveryGeometry), null), this.update("loading", "geometry");
+			let t = m(this.sourceGeometry).worldId, n = f(await e.recover(this.source, this.controller.signal));
+			if (n === this.sourceGeometry) {
+				if (p(n, d(this.source), t), this.controller.signal.aborted) throw b("World geometry recovery was closed");
+				this.update(this.committed ? "settled" : "idle", null);
+			} else {
+				this.recoveryGeometry = n;
+				try {
+					if (p(n, d(this.source), t), this.controller.signal.aborted) throw b("World geometry recovery was closed");
+					if (e.assets) {
+						if (!e.assets.recover) throw b("World asset recovery requires its actual preparation source");
+						let t = u(await e.assets.recover(this.source, n, this.controller.signal));
+						try {
+							let e = this.admitGeometryAssets(t, n);
+							if (this.controller.signal.aborted || e === this.geometryAssets.get(this.sourceGeometry)) throw b("World recovered assets must have their own current lifetime");
+							this.geometryAssets.set(n, e);
+						} catch (e) {
+							throw t !== this.geometryAssets.get(this.sourceGeometry) && await t.close(), e;
+						}
+					}
+					if (await this.closeGeometry(this.sourceGeometry), p(n, d(this.source), t), this.controller.signal.aborted) throw b("World geometry recovery was closed");
+					this.sourceGeometry = n, this.recoveryGeometry = null, this.update(this.committed ? "settled" : "idle", null);
+				} catch (e) {
+					throw await this.closeGeometry(n), this.recoveryGeometry = null, e;
+				}
+			}
+		});
+	}
+	cancel() {
+		return this.run(async () => {
+			if (!this.request || this.committed) throw b("World cancellation requires retained pre-commit work");
+			let e = this.acceptReceipt(await this.options.cancel(this.request.id, this.controller.signal));
+			if (e.phase === "committed" || e.phase === "settled") throw this.committed = !0, this.presentationWork((e) => e.commit()), this.target && (this.active = this.target), this.update("switching", "cleanup"), b("World request committed; resume its target");
+			if (e.phase !== "rolledBack") throw b("World rollback is not confirmed");
+			await this.finishRollback();
+		});
+	}
+	async finishRollback() {
+		if (this.handoffView?.rollback(), this.handoffError = null, await this.closePendingAssetBundles(), this.committed) throw b("Committed World ownership cannot roll back");
+		this.targetGeometry &&= (await this.closeGeometry(this.targetGeometry), null), this.target && await this.target.leave(), this.detachTarget?.(), this.detachTarget = null, this.target = null, this.active = this.source, await this.flush(this.source, !1), this.request = null, this.prepared = null, this.assetsReady = !1, this.update("idle", null);
+	}
+	send(t) {
+		if (this.closing || this.draining) return Promise.reject(b("World client is closing or draining accepted intentions"));
+		if (this.sends.size >= this.options.maxInFlightInputs) return Promise.reject(new e({
+			budget: "worldInFlightInputs",
+			limit: this.options.maxInFlightInputs
+		}));
+		let n = this.input.full(t);
+		if (v.isFailure(n)) return Promise.reject(n.failure);
+		let r = this.input.decodeFull(n.success);
+		if (v.isFailure(r)) return Promise.reject(r.failure);
+		if (this.request && (this.prepared?.mode !== "seamless" || this.committed || this.snapshot.status === "failed" || this.snapshot.status === "switching")) return this.bytes + n.success.byteLength > this.options.maxBufferedBytes ? Promise.reject(new e({
+			budget: "worldBufferedInputBytes",
+			limit: this.options.maxBufferedBytes
+		})) : this.queue.length >= this.options.maxBufferedInputs ? Promise.reject(new e({
+			budget: "worldTransitionInputs",
+			limit: this.options.maxBufferedInputs
+		})) : new Promise((e, t) => {
+			this.queue.push({
+				input: r.success,
+				bytes: n.success.byteLength,
+				resolve: e,
+				reject: t
+			}), this.bytes += n.success.byteLength, this.update(this.snapshot.status, this.snapshot.step);
+		});
+		if (this.request && this.prepared?.mode === "seamless" && this.target?.status === "joined") return this.trackSend(Promise.allSettled([this.source.send(r.success), this.target.send(structuredClone(r.success))]).then((e) => {
+			if (e[0].status === "rejected" || e[1].status === "rejected") throw b("Seamless intention delivery is partially or wholly unconfirmed");
+			return {
+				sourceSeq: e[0].value,
+				targetSeq: e[1].value
+			};
+		}));
+		let i = this.committed, a = this.active;
+		return this.trackSend(a.send(r.success).then((e) => i ? {
+			sourceSeq: null,
+			targetSeq: e
+		} : {
+			sourceSeq: e,
+			targetSeq: null
+		}));
+	}
+	trackSend(e) {
+		return this.sends.add(e), e.then(() => {
+			this.sends.delete(e);
+		}, () => {
+			this.sends.delete(e);
+		}), e;
+	}
+	close() {
+		if (this.closeTask) return this.closeTask;
+		this.closing = !0, this.handoffView?.close(), this.controller.abort();
+		let e = (async () => {
+			try {
+				await this.operation;
+			} catch {}
+			await this.closePendingAssetBundles(), await Promise.allSettled([...this.sends]), this.stopReceipts();
+			for (let e of this.queue.splice(0)) e.reject(b("World client closed before intention delivery"));
+			if (this.bytes = 0, (await Promise.allSettled([...new Set([
+				this.sourceGeometry,
+				this.targetGeometry,
+				this.recoveryGeometry
+			].filter((e) => e !== null))].map((e) => this.closeGeometry(e)))).some((e) => e.status === "rejected")) throw b("World geometry cleanup remains incomplete");
+			if (this.sourceGeometry = this.targetGeometry = this.recoveryGeometry = null, (await Promise.allSettled([...new Set([this.source, this.target].filter((e) => e !== null))].map((e) => e.leave()))).some((e) => e.status === "rejected")) throw b("World connection cleanup remains incomplete");
+			this.detachSource?.(), this.detachTarget?.(), this.detachSource = this.detachTarget = null, this.update("closed", null), this.listeners.clear();
+		})();
+		return this.closeTask = e, e.then(() => {
+			this.closeTask = null;
+		}, () => {
+			this.closeTask = null;
+		}), e;
+	}
+};
+//#endregion
+export { T as WorldClient, C as worldClientReceipt, S as worldClientTicket };