@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/serverSession.js

@@ -0,0 +1,810 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomAuthoringError as n, RoomForbidden as r } from "./errors.js";
+import { decodeRoomFrame as i, encodeRoomFrame as a } from "./wire.js";
+import { roomCodecs as o } from "./web.js";
+import { captureRoomConsumedSeat as s } from "./inputReceipts.js";
+import { WorldSourceSeatPending as c } from "./worldSourceSeatPending.js";
+import { WorldAdmissionPending as l } from "./worldAdmissionPending.js";
+import { RoomLockstepMemberOwner as u, isRoomLockstepMemberOwner as d } from "./lockstepMembers.js";
+import { RoomBaselineRing as f } from "./baselines.js";
+import { captureRoomServerSessionLimits as p } from "./serverSessionConfig.js";
+import { resolveRoomSeatTokenStrategies as m, roomSeatTokenDigest as h, verifyRoomSeat as g } from "./seats.js";
+import { projectRoomView as _ } from "./viewProjection.js";
+import { definedOnly as v } from "./resolvedOptions.js";
+import { SpectatorDelayBuffer as y } from "./replay.js";
+import { captureRoomSessionAdmissionEvidence as b } from "./sessionAdmission.js";
+import { Effect as x, Result as S } from "effect";
+// src/serverSession.ts
+var C = 250, w = /* @__PURE__ */ new WeakSet(), T = class extends AggregateError {
+	releaseListeners;
+	constructor(e, t) {
+		super(e, "Room Session listener acquisition failed"), this.releaseListeners = t;
+	}
+}, E = class E {
+	owner;
+	transport;
+	clock;
+	seats;
+	options;
+	codecs;
+	baselines;
+	detach = [];
+	writes = /* @__PURE__ */ new Set();
+	maxPendingWrites;
+	maxFramesPerSecond;
+	phase = "awaitingHello";
+	claims = null;
+	credentialDigest = null;
+	memberJoined = !1;
+	welcomeDelivered = !1;
+	datagramsAdmitted = !1;
+	resync = !1;
+	worldNotices = /* @__PURE__ */ new Map();
+	worldNoticeStateFence = null;
+	lastSentTick = -1;
+	lastSentAt = -1;
+	repairedTick = -1;
+	lastAckSeq = -1;
+	lastAckTick = -1;
+	sendLevel = 0;
+	sendSkip = 0;
+	sendThrottles = 0;
+	deltaDatagramsSent = 0;
+	reportedLossPermille = null;
+	staleInputsDropped = 0;
+	closeTask = null;
+	closeFailure = null;
+	localCleanupFailures = [];
+	ownershipLost = !1;
+	drainRequested = !1;
+	drainTask = null;
+	drainSettled = !1;
+	deferredClose = null;
+	authTask = null;
+	terminalError = null;
+	frameTokens;
+	byteTokens;
+	replenishedAt;
+	viewDurationMs = 0;
+	viewOverruns = 0;
+	lifecycleAbort = new AbortController();
+	helloTimeoutMs;
+	authTimeoutMs;
+	idleTimeoutMs;
+	connectedAt;
+	lastReceivedAt;
+	authenticatingAt = null;
+	authSettled = !0;
+	closeSettled = !1;
+	seatToken;
+	spectatorHistory;
+	delayedCursor;
+	delayedTask = null;
+	authorizeWorldPlayer;
+	authorizeWorldTarget;
+	revalidateSeat;
+	onClientMessage;
+	lockstepBinding = null;
+	lockstepActivated = !1;
+	constructor(e, r, i, a, s) {
+		this.owner = e, this.transport = r, this.clock = i, this.seats = a, this.options = s;
+		let c = e;
+		if (e instanceof u && !d(e)) throw new t({ detail: "Lockstep membership requires the genuine constructed owner" });
+		if (d(e) && s.epoch !== e.epoch) throw new t({ detail: "Lockstep Session epoch must match its member owner" });
+		if (d(e) && s.spectatorHistory) throw new t({ detail: "Lockstep membership cannot use state spectator history" });
+		let l = Object.getOwnPropertyDescriptor(s, "authorizeWorldPlayer");
+		if (l && (!("value" in l) || typeof l.value != "function") || !l && "authorizeWorldPlayer" in s) throw new t({ detail: "World player admission requires an own callback" });
+		this.authorizeWorldPlayer = l?.value.bind(s);
+		let h = Object.getOwnPropertyDescriptor(s, "authorizeWorldTarget");
+		if (h && (!("value" in h) || typeof h.value != "function") || !h && "authorizeWorldTarget" in s) throw new t({ detail: "World target admission requires an own callback" });
+		this.authorizeWorldTarget = h?.value.bind(s);
+		let g = Object.getOwnPropertyDescriptor(a, "revalidate");
+		if (g && (!("value" in g) || typeof g.value != "function") || !g && "revalidate" in a) throw new t({ detail: "Seat revalidation requires an own actual callback" });
+		if (this.revalidateSeat = g?.value.bind(a), this.seatToken = m(s.seatToken), s.onClientMessage !== void 0 && typeof s.onClientMessage != "function") throw new t({ detail: "Invalid client message hook" });
+		if (this.onClientMessage = s.onClientMessage?.bind(s), !Number.isSafeInteger(s.epoch) || s.epoch < 0) throw new n({
+			room: c.id,
+			detail: "Room epoch must be a nonnegative safe integer"
+		});
+		let _ = p(v({
+			maxPendingWrites: s.maxPendingWrites,
+			maxFramesPerSecond: s.maxFramesPerSecond,
+			baselineCapacity: s.baselineCapacity,
+			maxBaselineAgeMs: s.maxBaselineAgeMs,
+			helloTimeoutMs: s.helloTimeoutMs,
+			authTimeoutMs: s.authTimeoutMs,
+			idleTimeoutMs: s.idleTimeoutMs
+		}), c.id);
+		if (this.maxPendingWrites = _.maxPendingWrites, this.maxFramesPerSecond = _.maxFramesPerSecond, this.helloTimeoutMs = _.helloTimeoutMs, this.authTimeoutMs = _.authTimeoutMs, this.idleTimeoutMs = _.idleTimeoutMs, this.connectedAt = i.now(), this.lastReceivedAt = this.connectedAt, !Number.isFinite(this.connectedAt) || this.connectedAt < 0) throw new t({ detail: "Session clock must be monotonic" });
+		this.codecs = o(c.descriptor);
+		let b = s.spectatorHistory;
+		if (b !== void 0) {
+			if (b.roomId !== c.id || b.tenantId !== c.tenantId || !(b.history instanceof y) || typeof b.authorize != "function" || b.history.schemaDescription() !== this.codecs.state.schemaDescription()) throw new t({ detail: "Delayed spectator history requires the exact room, tenant, layout and group admission" });
+			this.spectatorHistory = Object.freeze({
+				delivery: b.history.delivery.bind(b.history),
+				authorize: b.authorize.bind(b),
+				delayMs: b.history.limits.delayMs
+			});
+		}
+		this.frameTokens = c.descriptor.budgets.burst, this.byteTokens = c.descriptor.budgets.bytesPerSecond, this.replenishedAt = i.now(), this.baselines = new f(_.baselineCapacity, _.maxBaselineAgeMs);
+		let x = !1, S = (e, n = !1) => {
+			if (!x) throw new t({ detail: "Native listeners cannot deliver before Session acquisition completes" });
+			this.receive(e, n);
+		};
+		try {
+			this.detach.push(r.reliable.onFrame((e) => S(e))), r.unreliable && this.detach.push(r.unreliable.onFrame((e) => S(e, !0)));
+			let e = () => {
+				this.backgroundClose("reconnecting");
+			};
+			r.signal.addEventListener("abort", e, { once: !0 }), this.detach.push(() => r.signal.removeEventListener("abort", e)), x = !0, r.signal.aborted && e();
+		} catch (e) {
+			this.phase = "closed", this.lifecycleAbort.abort();
+			let t = [e], n = /* @__PURE__ */ new Set();
+			for (let e of this.detach.splice(0)) try {
+				e();
+			} catch (r) {
+				t.push(r), n.add(e);
+			}
+			throw this.worldNotices.clear(), this.worldNoticeStateFence = null, this.baselines.release(), new T(t, () => {
+				let e = [];
+				for (let t of n) try {
+					t(), n.delete(t);
+				} catch (t) {
+					e.push(t);
+				}
+				if (e.length) throw AggregateError(e, "Room Session listener release remains incomplete");
+			});
+		}
+		w.add(this);
+	}
+	get actor() {
+		if (d(this.owner)) throw new t({ detail: "Lockstep membership owns no state actor" });
+		return this.owner;
+	}
+	get membershipMode() {
+		return d(this.owner) ? "lockstep" : "state-sync";
+	}
+	get status() {
+		return this.phase;
+	}
+	get failure() {
+		return this.terminalError;
+	}
+	teardownReady() {
+		return this.phase === "closed" && this.authSettled && this.closeSettled && this.writes.size === 0 && this.delayedTask === null;
+	}
+	admitFirstFrame(e) {
+		if (this.phase !== "awaitingHello") throw new t({ detail: "Room first frame has already been admitted" });
+		this.receive(Uint8Array.from(e));
+	}
+	maintenance() {
+		if (this.phase === "closed" || this.drainRequested) return;
+		let e = this.clock.now();
+		!Number.isFinite(e) || e < this.lastReceivedAt || e < this.connectedAt ? (this.terminalError = new t({ detail: "Session clock must be monotonic" }), this.backgroundClose("kicked")) : (this.phase === "awaitingHello" ? e - this.connectedAt >= this.helloTimeoutMs : this.phase === "authenticating" ? this.authenticatingAt !== null && e - this.authenticatingAt >= this.authTimeoutMs : e - this.lastReceivedAt >= this.idleTimeoutMs) && (this.terminalError = new t({ detail: "Room session deadline expired" }), this.backgroundClose("timeout"));
+	}
+	metrics() {
+		return {
+			viewDurationMs: this.viewDurationMs,
+			viewOverruns: this.viewOverruns,
+			pendingWrites: this.writes.size
+		};
+	}
+	snapshot() {
+		let e = this.actor.lastGoodSnapshot(), n = this.actor.descriptor.view;
+		if (!this.claims) return e;
+		let r = this.clock.now(), i = _(this.actor.descriptor.state, n, {
+			state: e.state,
+			tick: e.tick,
+			role: this.claims.role,
+			client: Object.freeze({
+				sessionId: this.claims.sessionId,
+				subjectId: this.claims.subjectId,
+				tenantId: this.claims.tenantId
+			})
+		}), a = this.clock.now() - r;
+		if (!Number.isFinite(a) || a < 0) throw new t({ detail: "Room view clock must be monotonic" });
+		return this.viewDurationMs += a, a > this.actor.descriptor.viewBudgetMs && this.viewOverruns++, {
+			tick: e.tick,
+			state: i
+		};
+	}
+	async write(e) {
+		let t = a(e);
+		if (S.isFailure(t)) throw t.failure;
+		return this.writeEncoded(t.success);
+	}
+	async writeEncoded(n) {
+		if (this.phase === "closed" || this.transport.signal.aborted) throw new t({ detail: "Room transport is closed" });
+		if (this.writes.size >= this.maxPendingWrites) throw new e({
+			budget: "pendingRoomWrites",
+			limit: this.maxPendingWrites
+		});
+		let r = this.transport.reliable.send(n);
+		this.writes.add(r);
+		try {
+			await r;
+		} finally {
+			this.writes.delete(r);
+		}
+	}
+	send(e) {
+		if (this.datagramsAdmitted && this.transport.unreliable && (e.kind === "Delta" || e.kind === "InputAck" || e.kind === "Pong" || e.kind === "ServerMessage" && this.codecs.channels[e.channelId]?.reliable === !1)) try {
+			let t = a(e);
+			if (S.isFailure(t)) throw t.failure;
+			if (t.success.byteLength <= this.transport.unreliable.maxDatagramBytes) {
+				this.transport.unreliable.send(t.success), e.kind === "Delta" && this.deltaDatagramsSent++;
+				return;
+			}
+		} catch (e) {
+			this.terminalError = e, this.backgroundClose("kicked");
+			return;
+		}
+		this.write(e).catch((e) => {
+			this.terminalError = e, this.backgroundClose("kicked");
+		});
+	}
+	backgroundClose(e) {
+		this.close(e).catch((e) => {
+			this.terminalError = e;
+		});
+	}
+	async authenticate(e) {
+		try {
+			if (e.protocolVersion !== 1 || e.schemaHash !== this.codecs.schemaHash || !(e.transportCaps & 1) || e.transportCaps & -4) throw new t({ detail: "Room protocol or schema manifest mismatch" });
+			this.datagramsAdmitted = !!(e.transportCaps & 2) && this.transport.unreliable !== void 0;
+			let n = g(e.token, this.options.secrets, this.options.epochNow(), {
+				roomId: this.owner.id,
+				tenantId: this.owner.tenantId,
+				epoch: this.options.epoch
+			}, this.seatToken.verify);
+			if (n.subjectId === null && this.owner.descriptor.auth !== "public") throw new r({ roomId: this.owner.id });
+			if (this.membershipMode === "lockstep" && (n.role !== "player" || n.subjectId === null || e.resumeFromTick !== void 0)) throw new t({ detail: "Lockstep membership requires a current Subject player and explicit initial admission" });
+			let a = h(e.token), o = await x.runPromise(this.seats.consume(n, a));
+			this.claims = n, this.credentialDigest = a;
+			let c = s(o);
+			if (c.worldTarget && (!this.authorizeWorldTarget || this.membershipMode !== "state-sync" || n.role !== "player")) throw new t({ detail: "World target Seat requires transition-aware player Host admission" });
+			if (this.status === "closed" || this.transport.signal.aborted) {
+				this.ownershipLost || await x.runPromise(this.seats.disconnect(n, "reconnecting", a));
+				return;
+			}
+			let l = n.role === "spectator" ? this.spectatorHistory : void 0, f;
+			if (l) {
+				let e = l.authorize(Object.freeze({ ...n }));
+				if (!x.isEffect(e)) throw new t({ detail: "Spectator group admission must return an Effect" });
+				if (await x.runPromise(e, { signal: this.lifecycleAbort.signal }), this.status === "closed" || this.transport.signal.aborted) return;
+				let r = l.delivery(Math.floor(this.clock.now()));
+				if (S.isFailure(r)) throw r.failure;
+				if (r.success.kind !== "full") throw new t({ detail: "Delayed spectator history is not yet available" });
+				let a = i(r.success.bytes);
+				if (S.isFailure(a)) throw a.failure;
+				if (a.success.kind !== "Full" || a.success.tick !== r.success.cursor.tick || a.success.epoch !== r.success.cursor.epoch || a.success.epoch > this.options.epoch) throw new t({ detail: "Delayed Welcome has invalid state authority" });
+				f = a.success, this.delayedCursor = r.success.cursor;
+			}
+			let p = {
+				sessionId: n.sessionId,
+				subjectId: n.subjectId,
+				tenantId: n.tenantId,
+				...n.attributes === void 0 ? {} : { attributes: n.attributes },
+				send: (e, n) => {
+					let r = this.codecs.channels.findIndex((t) => t.name === e), i = this.codecs.channels[r];
+					if (!i || i.direction === "client") throw new t({ detail: "Channel is not server-sendable" });
+					let a = i.codec.full(n);
+					if (S.isFailure(a)) throw a.failure;
+					this.send({
+						kind: "ServerMessage",
+						channelId: r,
+						payload: a.success
+					});
+				},
+				kick: (e) => {
+					this.write({
+						kind: "Kick",
+						code: 1,
+						reason: e
+					}).then(() => this.close("kicked")).catch((e) => {
+						this.terminalError = e, this.backgroundClose("kicked");
+					});
+				}
+			}, m = this.revalidateSeat ? async () => {
+				let e = this.revalidateSeat(n, a);
+				if (!x.isEffect(e)) throw new t({ detail: "Seat revalidation requires actual Effect" });
+				let r = await x.runPromise(x.result(e), { signal: this.lifecycleAbort.signal });
+				if (S.isFailure(r)) throw r.failure;
+			} : void 0;
+			if (c.worldTarget) {
+				let e = c.worldTarget;
+				await this.actor.joinWorldReservedAsync(p, c, async () => {
+					m && await m();
+					let r = this.authorizeWorldTarget(n, e, a);
+					if (!x.isEffect(r)) throw new t({ detail: "World target admission requires an actual Effect" });
+					let i = await x.runPromise(r, { signal: this.lifecycleAbort.signal });
+					if (i !== "pending" && i !== "committed" && i !== "settled") throw new t({ detail: "World admission returned an invalid activation phase" });
+					return i;
+				}, this.lifecycleAbort.signal);
+			} else this.membershipMode === "state-sync" ? await this.actor.joinReservedAsync(p, c, this.lifecycleAbort.signal, async () => {
+				if (m && await m(), this.authorizeWorldPlayer && n.role === "player") {
+					let e = this.authorizeWorldPlayer(n);
+					if (!x.isEffect(e)) throw new t({ detail: "World player admission requires an actual Effect" });
+					return await x.runPromise(e, { signal: this.lifecycleAbort.signal });
+				}
+			}) : await this.owner.joinReservedAsync(p, c, this.lifecycleAbort.signal);
+			if (this.memberJoined = !0, this.status === "closed" || this.transport.signal.aborted) {
+				try {
+					await this.owner.leaveAsync(n.sessionId, "reconnecting"), this.memberJoined = !1;
+				} catch (e) {
+					throw this.localCleanupFailures.push(e), e;
+				}
+				return;
+			}
+			if (d(this.owner) && !u.prototype.isCurrent.call(this.owner, n.sessionId, n.subjectId)) throw new t({ detail: "Lockstep member was withdrawn before Welcome publication" });
+			let _, v, y;
+			if (this.membershipMode === "lockstep") _ = 0, v = this.options.epoch, y = /* @__PURE__ */ new Uint8Array();
+			else if (f) _ = f.tick, v = f.epoch, y = f.baseline;
+			else {
+				let e = this.snapshot(), t = this.codecs.state.full(e.state);
+				if (S.isFailure(t)) throw t.failure;
+				this.baselines.record({
+					tick: e.tick,
+					epoch: this.options.epoch,
+					state: e.state
+				}), _ = e.tick, v = this.options.epoch, y = t.success;
+			}
+			this.lastSentTick = _, this.phase = "joined", await this.write({
+				kind: "Welcome",
+				sessionId: n.sessionId,
+				tick: _,
+				epoch: v,
+				serverTimeMs: this.observerNow(),
+				baseline: y,
+				transformRules: this.codecs.transformRules
+			}), this.welcomeDelivered = !0;
+			let b = this.membershipMode === "lockstep" ? -1 : this.actor.lastAppliedInputSeq(n.sessionId);
+			n.role === "player" && e.resumeFromTick !== void 0 && b >= 0 && (this.lastAckSeq = b, this.lastAckTick = _, await this.write({
+				kind: "InputAck",
+				lastAppliedSeq: b,
+				tick: _,
+				flags: 0
+			}));
+		} catch (e) {
+			this.terminalError = e, this.drainRequested || await this.close(e instanceof l || e instanceof c ? "reconnecting" : "kicked");
+		}
+	}
+	receive(a, o = !1) {
+		if (!(this.phase === "closed" || this.drainRequested)) try {
+			let s = this.clock.now(), c = this.owner.descriptor.budgets;
+			if (!Number.isFinite(s) || s < this.replenishedAt) throw new t({ detail: "Room transport clock must be monotonic" });
+			let l = (s - this.replenishedAt) / 1e3;
+			if (this.frameTokens = Math.min(c.burst, this.frameTokens + l * this.maxFramesPerSecond), this.byteTokens = Math.min(c.bytesPerSecond, this.byteTokens + l * c.bytesPerSecond), this.replenishedAt = s, this.frameTokens < 1 || this.byteTokens < a.byteLength) throw new e({
+				budget: "roomIncomingFrames",
+				limit: this.maxFramesPerSecond
+			});
+			this.frameTokens--, this.byteTokens -= a.byteLength;
+			let u = i(a);
+			if (S.isFailure(u)) throw u.failure;
+			let d = u.success;
+			if (this.lastReceivedAt = s, o && (!this.datagramsAdmitted || d.kind !== "Input" && d.kind !== "Ack" && !(this.lockstepActivated && d.kind === "LsInput") && (d.kind !== "ClientMessage" || this.codecs.channels[d.channelId]?.reliable !== !1))) throw new t({ detail: "Room control and reliable message frames require the admitted reliable lane" });
+			if (this.phase === "awaitingHello") {
+				if (d.kind !== "Hello") throw new t({ detail: "Hello must be the first room frame" });
+				this.phase = "authenticating", this.authenticatingAt = s, this.authSettled = !1, this.authTask = this.authenticate(d).finally(() => {
+					this.authSettled = !0;
+				}), this.authTask.catch((e) => {
+					this.terminalError = e;
+				});
+				return;
+			}
+			if (this.phase !== "joined" || !this.claims) throw new t({ detail: "Room admission is not complete" });
+			if (this.membershipMode === "lockstep" && !this.lockstepActivated && d.kind !== "Ping" && d.kind !== "Leave") throw new t({ detail: "Lockstep member cannot receive game frames before actual roster activation" });
+			if (this.lockstepActivated) {
+				if (!this.lockstepBinding || E.prototype.admittedIdentity.call(this) === null) throw new t({ detail: "Lockstep session ownership has been withdrawn" });
+				if (d.kind === "LsInput" || d.kind === "LsHash") {
+					if (this.lockstepBinding.receive(d) !== void 0) throw new t({ detail: "Lockstep intent delivery must be synchronous" });
+					return;
+				}
+				if (d.kind === "Input" || d.kind === "Ack") throw new t({ detail: "State-sync input and baseline acknowledgements cannot enter an activated lockstep session" });
+			}
+			switch (d.kind) {
+				case "Input":
+					if (this.claims.role !== "player") throw new r({ roomId: this.owner.id });
+					d.ackTick !== void 0 && this.acknowledgeBaseline(d.ackTick);
+					for (let e = 0; e < d.inputs.length; e++) {
+						let n = d.inputs[e];
+						if (!n) throw new t({ detail: "Missing batched input" });
+						let r = this.codecs.input.decodeFull(n.payload);
+						if (S.isFailure(r)) throw r.failure;
+						this.staleInput(n.tickHint) ? this.staleInputsDropped++ : this.actor.input(this.claims.sessionId, d.firstSeq + e, n.tickHint, r.success, n.payload.byteLength);
+					}
+					return;
+				case "Ack":
+					this.acknowledgeBaseline(d.tick), d.lossPermille !== void 0 && this.datagramsAdmitted && (this.reportedLossPermille = d.lossPermille);
+					return;
+				case "Ping":
+					this.send({
+						kind: "Pong",
+						clientTimeMs: d.clientTimeMs,
+						serverTimeMs: this.observerNow(),
+						tick: this.lockstepBinding ? this.lockstepBinding.tick() : this.claims.role === "spectator" && this.spectatorHistory ? this.lastSentTick : this.membershipMode === "lockstep" ? 0 : this.actor.lastGoodSnapshot().tick,
+						...this.datagramsAdmitted ? { deltaDatagramsSent: this.deltaDatagramsSent } : {}
+					});
+					return;
+				case "Leave":
+					this.backgroundClose("left");
+					return;
+				case "ClientMessage": {
+					let e = this.codecs.channels[d.channelId];
+					if (!e || e.direction === "server" || !this.onClientMessage) throw new t({ detail: "Channel is not client-receivable" });
+					if (this.claims.role === "spectator" && e.name !== "spectators") throw new r({ roomId: this.owner.id });
+					let i = e.codec.decodeFull(d.payload);
+					if (S.isFailure(i)) throw i.failure;
+					if (this.membershipMode === "state-sync" && (this.actor.isWorldPending(this.claims.sessionId) || this.actor.isWorldFinalizationHeld())) return;
+					if (this.onClientMessage(e.name, i.success, this.claims) !== void 0) throw new n({
+						room: this.owner.id,
+						detail: "Client message hooks must be synchronous"
+					});
+					return;
+				}
+				default: throw new t({ detail: "Client sent a server-only or duplicate admission frame" });
+			}
+		} catch (e) {
+			this.terminalError = e, this.backgroundClose("kicked");
+		}
+	}
+	acknowledgeBaseline(e) {
+		this.claims?.role === "spectator" && this.spectatorHistory ? e !== this.lastSentTick && (this.resync = !0) : this.baselines.acknowledge(e, this.clock.now()) ? (e < this.lastSentTick && (this.resync = !0), this.worldNoticeStateFence !== null && e > this.worldNoticeStateFence && (this.worldNoticeStateFence = null)) : this.resync = !0;
+	}
+	repairUnacknowledgedState(e, t) {
+		if (!this.datagramsAdmitted || !this.transport.unreliable || this.repairedTick === e.tick || this.lastSentAt < 0) return;
+		let n = this.clock.now();
+		if (n - this.lastSentAt < C) return;
+		let r = this.baselines.current(n);
+		if (r === null || r.tick >= e.tick) return;
+		let i = this.codecs.state.delta(e.state, r.state, t >= 0);
+		if (S.isFailure(i)) {
+			this.terminalError = i.failure, this.backgroundClose("kicked");
+			return;
+		}
+		if (this.repairedTick = e.tick, i.success === null) return;
+		let a = {
+			kind: "Delta",
+			tick: e.tick,
+			baseTick: r.tick,
+			patch: i.success,
+			...t >= 0 ? { inputAck: {
+				lastAppliedSeq: t,
+				flags: 1
+			} } : {}
+		};
+		this.write(a).catch((e) => {
+			this.terminalError = e, this.backgroundClose("kicked");
+		});
+	}
+	publishState() {
+		if (this.lockstepActivated || this.membershipMode === "lockstep" || this.drainRequested || this.actor.isWorldFinalizationHeld() || this.phase !== "joined" || !this.claims) return;
+		if (this.claims.role === "spectator" && this.spectatorHistory) {
+			this.publishDelayedState();
+			return;
+		}
+		if (this.backpressured()) return;
+		let e;
+		try {
+			e = this.snapshot();
+		} catch (e) {
+			this.terminalError = e, this.backgroundClose("kicked");
+			return;
+		}
+		let t = this.actor.lastAppliedInputSeq(this.claims.sessionId), n = t > this.lastAckSeq;
+		if (e.tick === this.lastSentTick && !this.resync) {
+			n && (this.lastAckSeq = t, this.lastAckTick = e.tick, this.send({
+				kind: "InputAck",
+				lastAppliedSeq: t,
+				tick: e.tick,
+				flags: 0
+			})), this.repairUnacknowledgedState(e, t);
+			return;
+		}
+		let r = this.resync || this.worldNoticeStateFence !== null ? null : this.baselines.current(this.clock.now()), i = this.lastAckTick >= 0 && (r === null || r.tick < this.lastAckTick), a = t >= 0 && (n || i || this.resync), o;
+		if (r && r.tick < e.tick) {
+			let t = this.codecs.state.delta(e.state, r.state, a);
+			if (S.isFailure(t)) {
+				this.terminalError = t.failure, this.backgroundClose("kicked");
+				return;
+			}
+			if (t.success !== null) o = {
+				kind: "Delta",
+				tick: e.tick,
+				baseTick: r.tick,
+				patch: t.success
+			};
+			else return;
+		} else {
+			let t = this.codecs.state.full(e.state);
+			if (S.isFailure(t)) {
+				this.terminalError = t.failure, this.backgroundClose("kicked");
+				return;
+			}
+			o = {
+				kind: "Full",
+				tick: e.tick,
+				epoch: this.options.epoch,
+				baseline: t.success
+			};
+		}
+		n && (this.lastAckSeq = t, this.lastAckTick = e.tick), a && (o = {
+			...o,
+			inputAck: {
+				lastAppliedSeq: t,
+				flags: +(o.kind === "Delta")
+			}
+		}), a && o.kind === "Delta" && this.send({
+			kind: "InputAck",
+			lastAppliedSeq: t,
+			tick: e.tick,
+			flags: 1
+		}), this.send(o), a && o.kind === "Full" && this.send({
+			kind: "InputAck",
+			lastAppliedSeq: t,
+			tick: e.tick,
+			flags: 0
+		}), e.tick > this.lastSentTick && this.baselines.record({
+			tick: e.tick,
+			epoch: this.options.epoch,
+			state: e.state
+		}), this.lastSentTick = e.tick, this.lastSentAt = this.clock.now(), this.resync = !1;
+	}
+	backpressured() {
+		if (this.sendSkip > 0) return this.sendSkip--, !0;
+		let { budgets: e, sendRate: t } = this.actor.descriptor, n = e.bytesPerSecond / t * 4, r = this.transport.stats().queuedBytes, i = this.reportedLossPermille ?? 0, a = i >= 100;
+		return r > n && this.sendLevel < 3 || a && this.sendLevel < 2 ? (this.sendLevel++, this.sendThrottles++) : r <= n / 2 && i < 50 && this.sendLevel > 0 && this.sendLevel--, this.sendSkip = (1 << this.sendLevel) - 1, !1;
+	}
+	staleInput(e) {
+		let { budgets: t, tickRate: n } = this.actor.descriptor, r = this.datagramsAdmitted && this.transport.unreliable ? this.baselines.acknowledgedTick() ?? -1 : this.lastSentTick;
+		return r >= 0 && e < r && (r - e) * 1e3 / n > t.inputLatencyBudgetMs;
+	}
+	staleInputs() {
+		return this.staleInputsDropped;
+	}
+	sendThrottle() {
+		return {
+			level: this.sendLevel,
+			throttles: this.sendThrottles
+		};
+	}
+	reportedLoss() {
+		return this.reportedLossPermille;
+	}
+	get id() {
+		return this.claims?.sessionId ?? null;
+	}
+	canSendLockstepMessages() {
+		return this.membershipMode === "lockstep" && this.lockstepActivated && this.lockstepBinding !== null && E.prototype.admittedIdentity.call(this) !== null;
+	}
+	async sendLockstepMessage(e) {
+		if (e.kind !== "ServerMessage" || !E.prototype.canSendLockstepMessages.call(this)) throw new t({ detail: "Lockstep messages need the same current activated native Session" });
+		let n = this.codecs.channels[e.channelId];
+		if (!n || n.direction === "client") throw new t({ detail: "Channel is not server-sendable" });
+		let r = n.codec.decodeFull(e.payload);
+		if (S.isFailure(r)) throw r.failure;
+		let i = a(e);
+		if (S.isFailure(i)) throw i.failure;
+		!n.reliable && this.datagramsAdmitted && this.transport.unreliable && i.success.byteLength <= this.transport.unreliable.maxDatagramBytes ? this.transport.unreliable.send(i.success) : n.reliable ? await E.prototype.writeReliableChannel.call(this, n.name, r.success, n.codec.schemaHash) : await this.writeEncoded(i.success);
+	}
+	async writeReliableChannel(e, n, r) {
+		let i = E.prototype.admittedIdentity.call(this), o = this.codecs.channels.find((t) => t.name === e);
+		if (!i || !o || !o.reliable || o.direction === "client" || o.codec.schemaHash !== r) throw new t({ detail: "Reliable channel delivery requires its exact current native player Session and layout" });
+		let s = o.codec.full(n);
+		if (S.isFailure(s)) throw s.failure;
+		let c = a({
+			kind: "ServerMessage",
+			channelId: this.codecs.channels.indexOf(o),
+			payload: s.success
+		});
+		if (S.isFailure(c)) throw c.failure;
+		if (await this.writeEncoded(c.success), JSON.stringify(E.prototype.admittedIdentity.call(this)) !== JSON.stringify(i)) throw new t({ detail: "Reliable native Session changed before delivery confirmation" });
+	}
+	async kick(e) {
+		if (this.phase === "closed") return this.close("kicked");
+		try {
+			await this.write({
+				kind: "Kick",
+				code: 1,
+				reason: e
+			});
+		} catch (e) {
+			this.terminalError = e;
+		}
+		await this.close("kicked");
+	}
+	admittedIdentity() {
+		return d(this.owner) && !u.prototype.isCurrent.call(this.owner, this.claims?.sessionId ?? "", this.claims?.subjectId ?? null) || this.phase !== "joined" || !this.authSettled || !this.memberJoined || !this.welcomeDelivered || this.closeTask !== null || this.ownershipLost || this.terminalError !== null || this.lifecycleAbort.signal.aborted || !this.claims || this.claims.role !== "player" || this.claims.subjectId === null || this.credentialDigest === null || this.claims.roomId !== this.owner.id || this.claims.tenantId !== this.owner.tenantId || this.claims.epoch !== this.owner.epoch ? null : b({
+			tenantId: this.claims.tenantId,
+			subjectId: this.claims.subjectId,
+			roomId: this.owner.id,
+			sessionId: this.claims.sessionId,
+			epoch: this.claims.epoch,
+			role: "player",
+			nonce: this.claims.nonce,
+			credentialDigest: this.credentialDigest
+		});
+	}
+	admittedInputSchemaHash() {
+		return E.prototype.admittedIdentity.call(this) === null ? null : this.codecs.input.schemaHash;
+	}
+	installLockstep(e) {
+		if (!this.canInstallLockstep() || this.spectatorHistory || typeof e.receive != "function" || typeof e.tick != "function") throw new t({ detail: "Lockstep binding needs the current welcomed player exactly once" });
+		return d(this.owner) && u.prototype.seal.call(this.owner), this.lockstepBinding = Object.freeze({
+			receive: e.receive,
+			tick: e.tick
+		}), this.lockstepActivated = !0, this.worldNotices.clear(), this.worldNoticeStateFence = null, this.baselines.release(), this.lockstepBinding;
+	}
+	canInstallLockstep() {
+		return !this.lockstepActivated && !this.spectatorHistory && E.prototype.admittedIdentity.call(this) !== null;
+	}
+	async writeLockstep(e, n) {
+		if (!this.lockstepBinding || this.lockstepBinding !== n || E.prototype.admittedIdentity.call(this) === null) throw new t({ detail: "Lockstep delivery requires the same live welcomed player" });
+		if (e.kind !== "LsStart" && e.kind !== "LsInputs" && e.kind !== "LsStall" && e.kind !== "LsDesync" && e.kind !== "LsJoin") throw new t({ detail: "Invalid server lockstep delivery" });
+		await this.write(e);
+	}
+	withdrawLockstep(e) {
+		this.lockstepBinding === e && (this.lockstepBinding = null);
+	}
+	observerNow() {
+		let e = Math.floor(this.clock.now());
+		if (!Number.isSafeInteger(e) || e < 0) throw new t({ detail: "Invalid observer clock" });
+		return this.claims?.role === "spectator" && this.spectatorHistory ? Math.max(0, e - this.spectatorHistory.delayMs) : e;
+	}
+	publishDelayedState() {
+		if (!this.spectatorHistory || this.delayedTask) return;
+		let e, n;
+		try {
+			let r = this.spectatorHistory.delivery(Math.floor(this.clock.now()), this.resync ? void 0 : this.delayedCursor);
+			if (S.isFailure(r)) throw r.failure;
+			if (r.success.kind === "unavailable" || r.success.kind === "unchanged") return;
+			if (n = r.success.cursor, n.epoch > this.options.epoch) throw new t({ detail: "Delayed state exceeds the admitted SQL epoch" });
+			e = r.success.kind === "full" ? [r.success.bytes] : r.success.frames.map((e) => e.bytes), this.resync = !1;
+		} catch (e) {
+			this.terminalError = e, this.backgroundClose("kicked");
+			return;
+		}
+		let r = (async () => {
+			for (let n of e) {
+				let e = i(n);
+				if (S.isFailure(e)) throw e.failure;
+				if (e.success.kind !== "Full" && e.success.kind !== "Delta") throw new t({ detail: "Delayed history returned a non-state frame" });
+				this.lastSentTick = e.success.tick, await this.writeEncoded(n);
+			}
+			this.delayedCursor = n, this.lastSentTick = n.tick;
+		})();
+		this.delayedTask = r, r.then(() => {
+			this.delayedTask = null;
+		}, (e) => {
+			this.delayedTask = null, this.terminalError = e, this.backgroundClose("kicked");
+		});
+	}
+	close(e = "left") {
+		if (this.closeTask) return this.closeTask;
+		if (this.drainRequested && !this.ownershipLost && e !== "disposed") return this.deferredClose ??= Promise.withResolvers(), this.deferredClose.promise;
+		this.phase = "closed", this.lockstepBinding = null, this.lifecycleAbort.abort();
+		for (let e of this.detach.splice(0)) try {
+			e();
+		} catch (e) {
+			this.localCleanupFailures.push(e);
+		}
+		let t = this.claims;
+		return this.closeTask = (async () => {
+			let n = [];
+			if (t && this.memberJoined && (this.memberJoined = !1, !this.owner.isDisposed() && !this.owner.isFaulted() && !this.owner.isRetiring())) try {
+				await this.owner.leaveAsync(t.sessionId, e);
+			} catch (e) {
+				this.localCleanupFailures.push(e);
+			}
+			if (!this.ownershipLost && t && this.credentialDigest) try {
+				await x.runPromise(this.seats.disconnect(t, e, this.credentialDigest));
+			} catch (e) {
+				n.push(e);
+			}
+			try {
+				this.transport.close(e === "kicked" ? 1008 : 1e3, "Room session closed");
+			} catch (e) {
+				this.localCleanupFailures.push(e);
+			}
+			if (n.push(...this.localCleanupFailures), n.length) throw this.closeFailure = AggregateError(n, "Room session teardown failed"), this.closeFailure;
+		})().finally(() => {
+			this.closeSettled = !0;
+		}), this.closeTask.then(() => this.deferredClose?.resolve(), (e) => this.deferredClose?.reject(e)), this.closeTask;
+	}
+	quiesceForDrain() {
+		if (this.drainRequested = !0, this.drainTask) return this.drainTask;
+		let e = (async () => {
+			if (await this.settled(), this.terminalError !== null) throw this.terminalError;
+			this.drainSettled = !0;
+		})();
+		return this.drainTask = e, e.catch(() => {
+			this.drainTask = null;
+		}), e;
+	}
+	notifyWorldHandoff(n) {
+		if (this.phase !== "joined" || !this.claims || this.drainRequested || this.membershipMode !== "state-sync" || this.claims.role === "spectator") return;
+		if (n.sourceEpoch !== this.claims.epoch) throw new t({ detail: "World notice differs from the admitted Session epoch" });
+		let r = this.clock.now();
+		for (let [e, t] of this.worldNotices) t.expiresAt <= r && this.worldNotices.delete(e);
+		let i = this.worldNotices.get(n.transitionId);
+		if (n.phase === "departed") {
+			if (i) return;
+			let t = this.baselines.current(r)?.state, a = t && Object.getOwnPropertyDescriptor(t, "entities"), o = a && "value" in a ? a.value : void 0;
+			if (!o || typeof o != "object" || !Object.hasOwn(o, n.entityId)) return;
+			if (this.worldNotices.size >= 128) {
+				this.terminalError = new e({
+					budget: "worldHandoffNotices",
+					limit: 128
+				}), this.backgroundClose("kicked");
+				return;
+			}
+			this.worldNotices.set(n.transitionId, {
+				entityId: n.entityId,
+				expiresAt: r + n.holdMs
+			});
+		} else {
+			if (!i || i.entityId !== n.entityId) return;
+			this.worldNotices.delete(n.transitionId);
+		}
+		this.worldNoticeStateFence = Math.max(this.worldNoticeStateFence ?? -1, n.tick), this.send(n);
+	}
+	async notifyMigration(e, n) {
+		if (!this.drainSettled || !Number.isSafeInteger(e) || e < 1 || e > 4294967295) throw new t({ detail: "Migration notification requires a quiesced Session and bounded grace" });
+		this.phase === "closed" || this.transport.signal.aborted || await this.write({
+			kind: "Migrate",
+			graceMs: e,
+			...n === void 0 ? {} : { address: n }
+		});
+	}
+	async settled() {
+		let e = (await Promise.allSettled([
+			...this.authTask ? [this.authTask] : [],
+			...this.closeTask ? [this.closeTask] : [],
+			...this.delayedTask ? [this.delayedTask] : [],
+			...this.writes
+		])).flatMap((e) => e.status === "rejected" ? [e.reason] : []);
+		if (e.length) throw AggregateError(e, "Room session work did not settle successfully");
+	}
+	async closeFenced() {
+		this.ownershipLost = !0;
+		let e = this.close("reconnecting"), t = await Promise.allSettled([
+			e,
+			...this.authTask ? [this.authTask] : [],
+			...this.delayedTask ? [this.delayedTask] : [],
+			...this.writes
+		]), n = [...this.localCleanupFailures];
+		for (let e of t) e.status === "rejected" && e.reason !== this.closeFailure && n.push(e.reason);
+		if (n.length) throw AggregateError(n, "Revoked Room session cleanup failed");
+	}
+}, D = E.prototype.admittedIdentity, O = E.prototype.admittedInputSchemaHash, k = E.prototype.canInstallLockstep, A = E.prototype.installLockstep, j = E.prototype.writeLockstep, M = E.prototype.withdrawLockstep, N = (e) => {
+	P(e);
+	let n = e, r = null;
+	return Object.freeze({
+		identity: () => D.call(n),
+		inputSchemaHash: () => O.call(n),
+		canActivate: () => k.call(n),
+		activate: (e, i) => {
+			if (r) throw new t({ detail: "Captured lockstep Session port is already activated" });
+			r = A.call(n, {
+				receive: e,
+				tick: i
+			});
+		},
+		send: (e) => r ? j.call(n, e, r) : Promise.reject(new t({ detail: "Captured lockstep Session port is not activated" })),
+		withdraw: () => {
+			r && M.call(n, r), r = null;
+		}
+	});
+}, P = (e) => {
+	if (!e || typeof e != "object" || !w.has(e)) throw new t({ detail: "Actual constructed Room server session is required" });
+	let n = e;
+	return Object.freeze({
+		identity: () => D.call(n),
+		inputSchemaHash: () => O.call(n)
+	});
+}, F = E.prototype.writeReliableChannel, I = (e) => {
+	let t = P(e), n = e;
+	return Object.freeze({
+		identity: t.identity,
+		write: (e, t, r) => F.call(n, e, t, r)
+	});
+};
+export { E as RoomServerSession, T as RoomServerSessionAcquisitionFailure, P as captureRoomAdmittedSessionReader, N as captureRoomLockstepSessionPort, I as captureRoomReliableChannelWriter };