@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/lockstepServerRoles.js

@@ -0,0 +1,402 @@
+import { BudgetExceeded as e, ProtocolError as t, RoomAuthoringError as n } from "./errors.js";
+import { captureUint64Words as r, unsignedWord as i } from "./fixedWords.js";
+import { freezeSimulationValue as a, simulationOwnData as o } from "./simulationAuthoring.js";
+import { createSimulationOptionsCodec as s } from "./simulationOptionsWire.js";
+import { assertCapturedSimulation as c, createSimulationRunner as l } from "./simulation.js";
+import { captureRoomLockstepServerOptions as u } from "./lockstepServerConfig.js";
+import { RoomInputCodec as d } from "./stateCodec.js";
+import { RoomLockstepInputRoster as f } from "./lockstepServer.js";
+import { Result as p } from "effect";
+// src/lockstepServerRoles.ts
+function m(e) {
+	throw new t({ detail: e });
+}
+function h(e) {
+	throw new n({
+		room: "lockstep",
+		detail: e
+	});
+}
+function g(t, n) {
+	throw new e({
+		budget: t,
+		limit: n
+	});
+}
+var _ = class {
+	#e;
+	#t;
+	#n;
+	#r;
+	#i;
+	#a;
+	#o;
+	#s;
+	#c;
+	#l = -1;
+	#u;
+	#d;
+	#f = !1;
+	#p = !1;
+	#m = /* @__PURE__ */ new Map();
+	#h = [];
+	#g = 0;
+	#_ = /* @__PURE__ */ new Map();
+	#v = [];
+	#y = 0;
+	#b;
+	#x;
+	#S = 0;
+	#C = 0;
+	constructor(e, t, n, r, a = {}) {
+		c(e), this.#e = e, this.#i = i(t);
+		let p = o(r, [
+			"roomId",
+			"tenantId",
+			"epoch"
+		], [
+			"roomId",
+			"tenantId",
+			"epoch"
+		]);
+		this.#t = Object.freeze({
+			roomId: p.roomId,
+			tenantId: p.tenantId,
+			epoch: p.epoch
+		});
+		let m = u(a), g = m.limits, _ = m.roster;
+		this.#o = m.role, this.#c = m.policies, this.#s = g, this.#n = new f(e.definition.input, this.#t, _);
+		let v = _.maxPendingBytes ?? 65536;
+		this.#r = new d(e.definition.input, {
+			maxBytes: v,
+			maxFieldId: Math.min(4096, v * 7)
+		});
+		let y = s(e).capture(n);
+		if (this.#a = y, this.#o !== "relay") {
+			let n = g.hashHistoryTicks + 2 + (this.#o === "full" ? g.maxReplayTicks + 1 : 0);
+			e.stateCodec.limits.maxBytes > Math.floor(g.maxSnapshotBudgetBytes / n) && h("Referee/full snapshot upper-bound budget is too small for the selected schema/history"), this.#d = l(e, t, y, {
+				rollbackHorizonTicks: g.hashHistoryTicks,
+				maxReplaySteps: g.hashHistoryTicks,
+				maxPlayers: _.maxPlayers ?? 8,
+				maxRejectionAttempts: g.maxRejectionAttempts
+			}), this.#o === "full" && (this.#b = this.#d.snapshot());
+		}
+	}
+	get role() {
+		return this.#o;
+	}
+	get tick() {
+		return this.#n.tick;
+	}
+	get refereeTick() {
+		return this.#d?.tick ?? null;
+	}
+	get withdrawn() {
+		return this.#p;
+	}
+	work(e, t = !1) {
+		if (this.#f || this.#p && !t) return m("Lockstep role is withdrawn or cannot reenter active work");
+		this.#f = !0;
+		try {
+			return e();
+		} finally {
+			this.#f = !1;
+		}
+	}
+	admit(e, t) {
+		return this.work(() => {
+			let n = this.#n.admit(e, t);
+			return this.#m.set(n.playerId, t), n;
+		});
+	}
+	admitAt(e, t) {
+		return this.work(() => {
+			let n = this.#n.admitAt(e, t);
+			return this.#m.set(n.playerId, t), n;
+		});
+	}
+	rebind(e) {
+		return this.work(() => {
+			let t = this.#n.rebind(e);
+			return this.#m.set(t.playerId, e), t;
+		});
+	}
+	seal() {
+		return this.work(() => this.#n.seal());
+	}
+	join(e, t, n) {
+		return this.work(() => {
+			let r = this.#n.join(e, t, n);
+			return this.#m.set(r.playerId, t), r;
+		});
+	}
+	playerForSession(e) {
+		return this.work(() => this.#n.playerForSession(e));
+	}
+	submit(e, t, n) {
+		return this.work(() => this.#n.submit(e, t, n));
+	}
+	copyInputs(e) {
+		return Object.freeze(e.map((e) => Object.freeze({
+			playerId: e.playerId,
+			input: a(this.#e.inputCodec.capture(e.input))
+		})));
+	}
+	advance(e) {
+		return this.work(() => {
+			if (e !== void 0 && (!Number.isInteger(e) || e < 1 || e > 16777216)) return h("Invalid lockstep delivery-input work budget");
+			let t = this.#n.next();
+			if (t._tag !== "complete") return t;
+			let n = this.copyInputs(t.inputs), r = 8;
+			for (let e of n) {
+				let t = this.#r.full(e.input);
+				if (p.isFailure(t)) throw t.failure;
+				r += 8 + t.success.length;
+			}
+			if (e !== void 0 && r > e) return g("lockstepDeliveryInputBytes", e);
+			if (this.#o !== "relay") {
+				if (this.#h.length >= this.#s.maxQueuedTicks) return g("lockstepRefereeQueueTicks", this.#s.maxQueuedTicks);
+				if (this.#g + r > this.#s.maxQueuedInputBytes) return g("lockstepRefereeQueueBytes", this.#s.maxQueuedInputBytes);
+			}
+			let i = Object.freeze({
+				tick: t.tick,
+				inputs: n,
+				bytes: r
+			}), a = Object.freeze({
+				_tag: "relayed",
+				tick: t.tick,
+				inputRecordBytes: r,
+				players: t.players,
+				inputs: n
+			}), o = this.#n.consumeNext();
+			return o._tag !== "complete" || o.tick !== t.tick ? m("Lockstep player ownership changed while preparing its matrix") : (this.#o !== "relay" && (this.#h.push(i), this.#g += r), a);
+		});
+	}
+	pumpReferee(e = this.#s.maxRefereeSteps) {
+		return this.work(() => {
+			let t = this.#d;
+			if (!t) return m("Relay does not own a simulation or adjudicate results");
+			if (!Number.isInteger(e) || e < 1 || e > this.#s.maxRefereeSteps) return g("lockstepRefereeSteps", this.#s.maxRefereeSteps);
+			let n = 0;
+			for (; n < e && this.#h.length > this.#s.refereeLagTicks;) {
+				let e = this.#h[0];
+				if (e.tick !== t.tick + 1) return m("Referee input history is not contiguous");
+				let r;
+				if (this.#o === "full" && (r = this.#v.length === this.#s.maxReplayTicks ? this.#v[0] : void 0, this.#y - (r?.bytes ?? 0) + e.bytes > this.#s.maxReplayInputBytes)) return g("lockstepReplayInputBytes", this.#s.maxReplayInputBytes);
+				let i = t.advance(e.inputs);
+				this.#h.shift(), this.#g -= e.bytes, n++, this.#o === "full" && (r && (this.#v.shift(), this.#y -= r.bytes, this.#b = r.snapshot, this.#x = r.inputs), this.#v.push(Object.freeze({
+					...e,
+					snapshot: i
+				})), this.#y += e.bytes);
+				for (let [e, n] of this.#_) n.tick <= t.oldestTick && (this.#_.delete(e), this.#w.delete(e));
+			}
+			return Object.freeze({
+				steps: n,
+				tick: t.tick
+			});
+		});
+	}
+	observeStall(e) {
+		return this.work(() => {
+			if (i(e), e < this.#l) return m("Stall observation cannot move host logical ticks backwards");
+			let t = this.#n.next();
+			if (t._tag !== "waiting") return this.#l = e, this.#u = void 0, Object.freeze({
+				_tag: t._tag === "complete" ? "ready" : "empty",
+				tick: t.tick
+			});
+			let n = this.#u?.tick === t.tick ? this.#u : {
+				tick: t.tick,
+				observation: e
+			}, r = e - n.observation + 1;
+			if (r > 4294967295) return m("Stall observation age overflow requires an explicit new run");
+			let a = this.#c.stallDecision(t.tick, r, t.waitingFor);
+			return this.#l = e, this.#u = n, a;
+		});
+	}
+	snapshot() {
+		return this.work(() => this.#d ? this.#d.snapshot() : m("Relay has no authoritative snapshot"));
+	}
+	recovery() {
+		return this.work(() => this.recoveryOwned());
+	}
+	recoveryOwned() {
+		let e = this.#d;
+		if (!e || e.tick < 1) return m("Snapshot bootstrap needs an actual confirmed referee input base");
+		let t = e.snapshot(), n = e.inputsAt(t.tick), r = Object.freeze(this.#h.map((e, n) => e.tick === t.tick + n + 1 ? Object.freeze({
+			tick: e.tick,
+			inputs: this.copyInputs(e.inputs)
+		}) : m("Referee recovery authority queue is not contiguous")));
+		return (r.length ? r[r.length - 1].tick : t.tick) === this.tick ? Object.freeze({
+			snapshot: t,
+			inputs: n,
+			continuation: r
+		}) : m("Referee recovery does not reach actual input authority");
+	}
+	incident(e) {
+		let t = this.#d.snapshotAt(e.tick);
+		if (t.hash.hi === e.words.hi && t.hash.lo === e.words.lo) return Object.freeze({
+			_tag: "match",
+			tick: e.tick,
+			playerId: e.playerId
+		});
+		let n = Object.freeze({
+			tick: e.tick,
+			playerId: e.playerId,
+			expected: t.hash,
+			received: e.words
+		}), r = this.#c.desync(n);
+		if (r !== "resync" && r !== "end" && r !== "flag") return h("Desync policy returned an invalid action");
+		if (r !== "resync") return Object.freeze({
+			_tag: "desync",
+			action: r,
+			incident: n
+		});
+		let i = this.recoveryOwned();
+		return Object.freeze({
+			_tag: "desync",
+			action: r,
+			incident: n,
+			...i,
+			continuation: i.continuation ?? Object.freeze([])
+		});
+	}
+	currentPlayer(e) {
+		let t = this.#m.get(e);
+		if (!t || this.#n.playerForSession(t).playerId !== e) return m("Hash comparison requires the current actual admitted player");
+	}
+	submitHash(e, t, n) {
+		return this.work(() => {
+			let a = this.#d;
+			if (!a) return m("Relay cannot accept hashes as authoritative state or vote");
+			let o = this.#n.playerForSession(e), s = r(n);
+			if (i(t), t < 1 || t % this.#s.hashEvery !== 0) return m("Client hash tick is outside the configured hash cadence");
+			if (t <= a.oldestTick) return Object.freeze({
+				_tag: "expired",
+				tick: t,
+				playerId: o.playerId
+			});
+			if (t > this.tick) return m("Client hash cannot precede actual complete input authority");
+			let c = `${t}/${o.playerId}`, l = this.#_.get(c);
+			if (l) return l.words.hi !== s.hi || l.words.lo !== s.lo ? m("Conflicting immutable client hash claim") : Object.freeze({
+				_tag: "duplicate",
+				tick: t,
+				playerId: o.playerId
+			});
+			if (this.#_.size >= this.#s.maxPendingHashes) return g("lockstepPendingHashes", this.#s.maxPendingHashes);
+			let u = Object.freeze({
+				playerId: o.playerId,
+				tick: t,
+				words: s
+			});
+			if (t > a.tick) return this.#_.set(c, u), Object.freeze({
+				_tag: "pending",
+				tick: t,
+				playerId: o.playerId
+			});
+			let d = this.incident(u);
+			return this.currentPlayer(u.playerId), this.#_.set(c, u), this.#S++, d._tag === "desync" && this.#C++, this.#w.add(c), d;
+		});
+	}
+	#w = /* @__PURE__ */ new Set();
+	comparePendingHashes(e = this.#s.maxPendingHashes) {
+		return this.work(() => {
+			let t = this.#d;
+			if (!t) return m("Relay cannot adjudicate client hashes");
+			if (!Number.isInteger(e) || e < 1 || e > this.#s.maxPendingHashes) return g("lockstepHashComparisons", this.#s.maxPendingHashes);
+			let n = [], r = [];
+			for (let [i, a] of this.#_) {
+				if (n.length >= e) break;
+				if (this.#w.has(i) || a.tick > t.tick) continue;
+				this.currentPlayer(a.playerId);
+				let o = this.incident(a);
+				this.currentPlayer(a.playerId), r.push(i), n.push(o);
+			}
+			for (let e of r) this.currentPlayer(this.#_.get(e).playerId);
+			for (let e = 0; e < r.length; e++) this.#w.add(r[e]), this.#S++, n[e]._tag === "desync" && this.#C++;
+			return Object.freeze(n);
+		});
+	}
+	replay() {
+		return this.work(() => {
+			if (this.#o !== "full" || !this.#b) return m("Only full owns retained replay/spectator snapshot sources");
+			let e = this.copySnapshot(this.#b), t = a(this.#e.optionsCodec.capture(this.#a));
+			return Object.freeze({
+				seed: this.#i,
+				options: t,
+				base: e,
+				inputs: Object.freeze(this.#v.map((e) => Object.freeze({
+					tick: e.tick,
+					inputs: this.copyInputs(e.inputs),
+					hash: Object.freeze({ ...e.snapshot.hash })
+				}))),
+				...this.#x ? { baseInputs: this.copyInputs(this.#x) } : {}
+			});
+		});
+	}
+	copySnapshot(e) {
+		return Object.freeze({
+			tick: e.tick,
+			state: a(this.#e.stateCodec.capture(e.state)),
+			rng: Object.freeze({ ...e.rng }),
+			hash: Object.freeze({ ...e.hash })
+		});
+	}
+	exportSubject(e, t) {
+		return this.work(() => {
+			let n = new Set(this.#n.playersForSubject(e, t).map((e) => e.playerId)), r = /* @__PURE__ */ new Map(), i = (e, t) => {
+				for (let i of t) n.has(i.playerId) && r.set(`${e}/${i.playerId}`, Object.freeze({
+					tick: e,
+					playerId: i.playerId,
+					input: a(this.#e.inputCodec.capture(i.input))
+				}));
+			};
+			for (let n of this.#n.exportSubject(e, t)) i(n.tick, [n]);
+			for (let e of [...this.#v, ...this.#h]) i(e.tick, e.inputs);
+			if (this.#d) for (let e = this.#d.oldestTick + 1; e <= this.#d.tick; e++) i(e, this.#d.inputsAt(e));
+			let o = [...r.values()].sort((e, t) => e.tick - t.tick || e.playerId - t.playerId), s = [...this.#_.values()].filter((e) => n.has(e.playerId)).map((e) => Object.freeze({
+				tick: e.tick,
+				playerId: e.playerId,
+				hash: Object.freeze({ ...e.words })
+			})).sort((e, t) => e.tick - t.tick || e.playerId - t.playerId);
+			return Object.freeze({
+				inputs: Object.freeze(o),
+				hashClaims: Object.freeze(s)
+			});
+		}, !0);
+	}
+	eraseSubject(e, t) {
+		return this.work(() => {
+			let n = this.#n.playersForSubject(e, t);
+			return n.length ? (this.withdrawOwned(), n.length) : 0;
+		}, !0);
+	}
+	withdraw() {
+		this.work(() => this.withdrawOwned(), !0);
+	}
+	withdrawOwned() {
+		this.#n.withdraw(), this.#h = [], this.#g = 0, this.#v = [], this.#y = 0, this.#_.clear(), this.#w.clear(), this.#m.clear(), this.#d = void 0, this.#b = void 0, this.#x = void 0, this.#a = void 0, this.#u = void 0, this.#p = !0;
+	}
+	metrics() {
+		return Object.freeze({
+			role: this.#o,
+			tick: this.tick,
+			refereeTick: this.refereeTick,
+			withdrawn: this.#p,
+			refereeLagTicks: this.#s.refereeLagTicks,
+			stallAfterTicks: this.#c.stallPolicy.afterTicks,
+			stallAction: this.#c.stallPolicy.action,
+			players: this.#n.metrics().players,
+			pendingInputs: this.#n.metrics().pendingInputs,
+			pendingInputBytes: this.#n.metrics().pendingBytes,
+			queuedInputs: this.#h.reduce((e, t) => e + t.inputs.length, 0),
+			queuedTicks: this.#h.length,
+			queuedInputBytes: this.#g,
+			pendingHashes: this.#_.size,
+			retainedReplayTicks: this.#v.length,
+			retainedReplayInputBytes: this.#y,
+			comparedHashes: this.#S,
+			desyncs: this.#C
+		});
+	}
+}, v = (e, t, n, r, i = {}) => new _(e, t, n, r, i);
+export { _ as RoomLockstepServer, v as createRoomLockstepServer };

package/dist/lockstepServerStrategyFixtures.js

@@ -0,0 +1,32 @@
+import { defineSimulation as e } from "./simulation.js";
+import { defaultLockstepRefereeLag as t } from "./lockstepPolicies.js";
+import { fieldId as n } from "./room.js";
+import { createRoomLockstepServer as r } from "./lockstepServerRoles.js";
+import { Effect as i, Schema as a } from "effect";
+// src/lockstepServerStrategyFixtures.ts
+var o = () => e({
+	state: a.Struct({ value: a.Int.pipe(n(1)) }),
+	input: a.Struct({ move: a.Int }),
+	options: a.Struct({}),
+	init: () => ({ value: 0 }),
+	step: (e) => e
+}), s = {
+	roomId: "lag-fixture-room",
+	tenantId: "lag-fixture-tenant",
+	epoch: 1
+}, c = {
+	kind: "slot",
+	defaultImplementation: t,
+	defaultProbe: {
+		run: () => i.sync(() => r(o(), 42, {}, s, { serverRole: "referee" }).metrics().refereeLagTicks),
+		expected: 12
+	},
+	overrideProbe: {
+		run: () => i.sync(() => r(o(), 42, {}, s, {
+			serverRole: "referee",
+			strategies: { refereeLag: (e) => t(e) + 2 }
+		}).metrics().refereeLagTicks),
+		expected: 14
+	}
+};
+export { c as lockstepRefereeLagSlotFixture };

package/dist/lockstepStrategies.js

@@ -0,0 +1,5 @@
+import { schemaSimulationHash as e } from "./simulationState.js";
+import { defaultLockstepDesync as t, defaultLockstepRefereeLag as n, defaultLockstepStallPolicy as r } from "./lockstepPolicies.js";
+// src/lockstepStrategies.ts
+var i = (e, t) => e;
+export { t as defaultLockstepDesync, n as defaultLockstepRefereeLag, r as defaultLockstepStallPolicy, i as repeatLastLockstepInput, e as schemaSimulationHash };

package/dist/lockstepStrategyFixtures.js

@@ -0,0 +1,136 @@
+import { schemaSimulationHash as e } from "./simulationState.js";
+import { createSimulationRunner as t, defineSimulation as n } from "./simulation.js";
+import { createLockstepPolicies as r, defaultLockstepDesync as i, defaultLockstepStallPolicy as a } from "./lockstepPolicies.js";
+import { defaultRoomReconnectPolicy as o, defineRoom as s, fieldId as c } from "./room.js";
+import { repeatLastLockstepInput as l } from "./lockstepStrategies.js";
+import { createLockstepClientSimulation as u } from "./lockstep.js";
+import { Effect as d, Schema as f } from "effect";
+// src/lockstepStrategyFixtures.ts
+var p = f.Struct({ x: f.Int.pipe(c(1)) }), m = f.Struct({ amount: f.Int }), h = f.Struct({}), g = () => n({
+	state: p,
+	input: m,
+	options: h,
+	init: () => ({ x: 1 }),
+	step: (e, t) => {
+		for (let n of t) e.x += n.input.amount;
+		return e;
+	}
+}), _ = () => [{
+	playerId: 1,
+	input: { amount: 0 }
+}, {
+	playerId: 2,
+	input: { amount: 0 }
+}], v = {
+	kind: "slot",
+	defaultImplementation: l,
+	defaultProbe: {
+		run: () => d.sync(() => {
+			let e = u(g(), 42, {}, {
+				localPlayerId: 1,
+				initialInputs: _()
+			});
+			return e.advance(), e.snapshot().state.x;
+		}),
+		expected: 1
+	},
+	overrideProbe: {
+		run: () => d.sync(() => {
+			let e = u(g(), 42, {}, {
+				localPlayerId: 1,
+				initialInputs: _(),
+				inputPrediction: (e, t) => ({ amount: l(e, t).amount + 1 })
+			});
+			return e.advance(), e.snapshot().state.x;
+		}),
+		expected: 3
+	}
+}, y = {
+	kind: "slot",
+	defaultImplementation: e,
+	defaultProbe: {
+		run: () => d.sync(() => {
+			let n = g(), r = t(n, 42, {}).snapshot(), i = e(n.stateCodec, r.state);
+			return r.hash.hi === i.hi && r.hash.lo === i.lo;
+		}),
+		expected: !0
+	},
+	overrideProbe: {
+		run: () => d.sync(() => {
+			let e = g(), r = n({
+				...e.definition,
+				hash: () => ({
+					hi: 7,
+					lo: 9
+				})
+			});
+			return t(r, 42, {}).snapshot().hash.hi;
+		}),
+		expected: 7
+	}
+}, b = {
+	kind: "slot",
+	defaultImplementation: a,
+	defaultProbe: {
+		run: () => d.sync(() => r().stallDecision(1, 1, {
+			hi: 0,
+			lo: 3
+		})._tag),
+		expected: "waiting"
+	},
+	overrideProbe: {
+		run: () => d.sync(() => r({}, { stallPolicy: (e) => ({
+			...a(e),
+			afterTicks: 1
+		}) }).stallDecision(1, 1, {
+			hi: 0,
+			lo: 3
+		})._tag),
+		expected: "action"
+	}
+}, x = () => ({
+	tick: 1,
+	playerId: 7,
+	expected: {
+		hi: 0,
+		lo: 1
+	},
+	received: {
+		hi: 0,
+		lo: 2
+	}
+}), S = {
+	kind: "slot",
+	defaultImplementation: i,
+	defaultProbe: {
+		run: () => d.sync(() => r().desync(x())),
+		expected: "resync"
+	},
+	overrideProbe: {
+		run: () => d.sync(() => r({}, { onDesync: () => "flag" }).desync(x())),
+		expected: "flag"
+	}
+}, C = {
+	kind: "slot",
+	defaultImplementation: o,
+	defaultProbe: {
+		run: () => d.sync(() => s({
+			name: "lockstep-reconnect-fixture",
+			mode: "lockstep",
+			simulation: g(),
+			reconnect: { graceMs: 1234 }
+		}).reconnect.graceMs),
+		expected: 1234
+	},
+	overrideProbe: {
+		run: () => d.sync(() => s({
+			name: "lockstep-reconnect-fixture",
+			mode: "lockstep",
+			simulation: g(),
+			reconnect: { graceMs: 1234 },
+			strategies: { reconnectPolicy: (e) => ({ graceMs: o(e).graceMs * 2 }) }
+		}).reconnect.graceMs),
+		expected: 2468
+	}
+};
+export { S as lockstepDesyncSlotFixture, y as lockstepHashSlotFixture, v as lockstepInputPredictionSlotFixture, C as lockstepReconnectSlotFixture, b as lockstepStallPolicySlotFixture };

package/dist/lockstepTerminal.js

@@ -0,0 +1,89 @@
+import { ProtocolError as e } from "./errors.js";
+import { simulationOwnData as t } from "./simulationAuthoring.js";
+import { defineRoom as n } from "./room.js";
+import { ROOMS_TABLE as r, ROOM_SEATS_TABLE as i } from "./identities.js";
+import { RoomLockstepTerminalPort as a } from "./lockstepTerminalPorts.js";
+import { captureLockstepJournalScope as o, lockstepJournalIdentity as s } from "./lockstepJournalCodec.js";
+import { createRoomLockstepAdmissionCodec as c } from "./lockstepAdmissionCodec.js";
+import { and as l, eq as u } from "@voltro/database";
+import { Effect as d, Layer as f } from "effect";
+// src/lockstepTerminal.ts
+var p = (n) => {
+	let r = t(n, [
+		"roomId",
+		"tenantId",
+		"epoch",
+		"disposition"
+	], [
+		"roomId",
+		"tenantId",
+		"epoch",
+		"disposition"
+	]), i = o({
+		roomId: r.roomId,
+		tenantId: r.tenantId,
+		epoch: r.epoch
+	});
+	if (r.disposition !== "faulted" && r.disposition !== "disposed") throw new e({ detail: "Invalid actual lockstep terminal disposition" });
+	return Object.freeze({
+		...i,
+		disposition: r.disposition
+	});
+}, m = (a, o, f) => {
+	let m = n(o), h = t(f, [
+		"hostId",
+		"epochNow",
+		"authorize"
+	], [
+		"hostId",
+		"epochNow",
+		"authorize"
+	]), g = s(h.hostId), _ = h.epochNow, v = h.authorize, y = c(m.simulation, 67108864);
+	if (typeof _ != "function" || typeof v != "function") throw new e({ detail: "Lockstep terminal requires actual authorization and wall clock" });
+	return Object.freeze({ terminate: (t) => {
+		let n = p(t);
+		return d.uninterruptible(d.gen(function* () {
+			let t = v(n);
+			return d.isEffect(t) ? (yield* t, yield* d.tryPromise({
+				try: () => a.transactional(async (t) => {
+					let a = l(u("id", n.roomId), u("tenantId", n.tenantId)), o = await t.query({
+						table: r,
+						predicate: a,
+						order: [],
+						take: 2,
+						skip: void 0,
+						projection: void 0,
+						lock: "update"
+					}), s = o[0];
+					if (o.length !== 1 || !s || s.id !== n.roomId || s.tenantId !== n.tenantId || s.epoch !== n.epoch || s.hostId !== g || s.name !== m.name || s.maxClients !== m.maxClients || s.erasure != null || s.snapshotErasure != null || s.state !== "creating" && s.state !== "live" && s.state !== n.disposition) throw new e({ detail: "Terminal commit has no exact current unfenced SQL owner" });
+					let c = y.captureStored(s.lockstepAdmission, n, g);
+					if (s.lockstepCreatorSubjectId !== c.initial.creatorSubjectId || c.initial.name !== m.name) throw new e({ detail: "Terminal admission identity changed" });
+					let d = await t.query({
+						table: i,
+						predicate: l(u("roomId", n.roomId), u("tenantId", n.tenantId), u("state", "connected")),
+						order: [],
+						take: 1,
+						skip: void 0,
+						projection: ["sessionId"]
+					});
+					if (s.clients !== 0 || d.length) throw new e({ detail: "Terminal commit requires actual SQL player withdrawal" });
+					if (s.state !== n.disposition) {
+						let r = _();
+						if (typeof r != "number" || !Number.isSafeInteger(r) || r < 0 || r > 864e13) throw new e({ detail: "Invalid actual terminal wall clock" });
+						if (await t.updateMany("_voltro_rooms", {
+							state: n.disposition,
+							locked: !0,
+							updatedAt: new Date(r)
+						}, { where: l(a, u("hostId", g), u("epoch", n.epoch), u("state", s.state)) }) !== 1) throw new e({ detail: "Terminal SQL ownership CAS failed" });
+					}
+					return Object.freeze({
+						...n,
+						hostId: g
+					});
+				}),
+				catch: (t) => t instanceof e ? t : new e({ detail: "Lockstep terminal SQL outcome is unconfirmed" })
+			})) : yield* d.fail(new e({ detail: "Terminal authorization requires its actual Effect" }));
+		}).pipe(d.mapError((t) => t instanceof e ? t : new e({ detail: "Lockstep terminal authorization failed" }))));
+	} });
+}, h = (e, t, n) => f.succeed(a, m(e, t, n));
+export { a as RoomLockstepTerminalPort, p as captureRoomLockstepTerminal, m as dataStoreRoomLockstepTerminal, h as roomLockstepTerminalLayer };

package/dist/lockstepTerminalPorts.js

@@ -0,0 +1,4 @@
+import { Context as e } from "effect";
+// src/lockstepTerminalPorts.ts
+var t = class extends e.Service()("@voltro/RoomLockstepTerminalPort") {};
+export { t as RoomLockstepTerminalPort };