@trioforge/crucible 0.1.0 → 0.3.0

package/out/internal/data/profiles.luau

@@ -0,0 +1,862 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local bootClock = TS.import(script, script.Parent.Parent, "boot").bootClock
+local runtimeDiagnostic = TS.import(script, script.Parent.Parent, "diagnostics").runtimeDiagnostic
+local _admission = TS.import(script, script.Parent, "admission")
+local loadRecord = _admission.loadRecord
+local sealSchema = _admission.sealSchema
+local _envelope = TS.import(script, script.Parent, "envelope")
+local jsonBytes = _envelope.jsonBytes
+local parseEnvelope = _envelope.parseEnvelope
+local _lease = TS.import(script, script.Parent, "lease")
+local abandonAcquisition = _lease.abandonAcquisition
+local acquire = _lease.acquire
+local ownedWrite = _lease.ownedWrite
+local Inbox = TS.import(script, script.Parent, "inbox").Inbox
+local _limits = TS.import(script, script.Parent, "limits")
+local CALL_DEADLINE_SECONDS = _limits.CALL_DEADLINE_SECONDS
+local HANDOFF_TIMEOUT_SECONDS = _limits.HANDOFF_TIMEOUT_SECONDS
+local LEASE_SECONDS = _limits.LEASE_SECONDS
+local LOAD_BUSY_MESSAGE = _limits.LOAD_BUSY_MESSAGE
+local LOAD_DEADLINE_SECONDS = _limits.LOAD_DEADLINE_SECONDS
+local LOAD_FAILED_MESSAGE = _limits.LOAD_FAILED_MESSAGE
+local LOAD_POLL_JITTER = _limits.LOAD_POLL_JITTER
+local LOAD_POLL_MIN_SECONDS = _limits.LOAD_POLL_MIN_SECONDS
+local LOAD_POLL_SCHEDULE_SECONDS = _limits.LOAD_POLL_SCHEDULE_SECONDS
+local LOCAL_AUTHORITY_SECONDS = _limits.LOCAL_AUTHORITY_SECONDS
+local RENEW_INTERVAL_SECONDS = _limits.RENEW_INTERVAL_SECONDS
+local RENEW_JITTER_SECONDS = _limits.RENEW_JITTER_SECONDS
+local SAVE_TIMEOUT_DEFAULT_SECONDS = _limits.SAVE_TIMEOUT_DEFAULT_SECONDS
+local SAVE_TIMEOUT_MAX_SECONDS = _limits.SAVE_TIMEOUT_MAX_SECONDS
+local SERVER_UPDATING_MESSAGE = _limits.SERVER_UPDATING_MESSAGE
+local SESSION_ENDED_MESSAGE = _limits.SESSION_ENDED_MESSAGE
+local TAKEOVER_GRACE_SECONDS = _limits.TAKEOVER_GRACE_SECONDS
+local ReceiptRouter = TS.import(script, script.Parent, "receipts").ReceiptRouter
+local KeyedScheduler = TS.import(script, script.Parent, "scheduler").KeyedScheduler
+local _session = TS.import(script, script.Parent, "session")
+local assertOutsideCallback = _session.assertOutsideCallback
+local Session = _session.Session
+local Waiters = TS.import(script, script.Parent, "waiters").Waiters
+--* @internal 
+--* @internal 
+--* @internal 
+--* @internal 
+--[[
+	*
+	 * @internal The seams later units fill. D4 runs the claims and owns the slot's node; D2 delivers the inbox and receipts
+	 * from every envelope the session reads. Each defaults to doing nothing.
+	 
+]]
+local NO_HOOKS = {
+	onLoad = function(_, value)
+		return value
+	end,
+	onRelease = function(_, value)
+		return value
+	end,
+	publish = function() end,
+	delivered = function() end,
+}
+--* @internal One server's data engine: its port, its scheduler and its shutdown state (rules 32, 50 to 56, 107). 
+local ProfileRuntime
+local DataEngine
+do
+	DataEngine = setmetatable({}, {
+		__tostring = function()
+			return "DataEngine"
+		end,
+	})
+	DataEngine.__index = DataEngine
+	function DataEngine.new(...)
+		local self = setmetatable({}, DataEngine)
+		return self:constructor(...) or self
+	end
+	function DataEngine:constructor(port)
+		self.port = port
+		self.profiles = {}
+		self.closing = false
+		self.finalPhase = false
+		self.settled = false
+		self.diagnosed = {}
+		self.scheduler = KeyedScheduler.new(port, function(key, message)
+			return self:diagnose(key, message)
+		end)
+		self.receipts = ReceiptRouter.new(self)
+	end
+	function DataEngine:diagnose(key, message)
+		local _diagnosed = self.diagnosed
+		local _key = key
+		if _diagnosed[_key] ~= nil then
+			return nil
+		end
+		local _diagnosed_1 = self.diagnosed
+		local _key_1 = key
+		_diagnosed_1[_key_1] = true
+		runtimeDiagnostic("warning", message)
+	end
+	function DataEngine:profile(schema, hooks)
+		if hooks == nil then
+			hooks = NO_HOOKS
+		end
+		local runtime = ProfileRuntime.new(self, sealSchema(schema), hooks)
+		local _exp = self.profiles
+		table.insert(_exp, runtime)
+		return runtime
+	end
+	function DataEngine:wake()
+		for _, runtime in self.profiles do
+			runtime.changed:wake()
+		end
+	end
+	function DataEngine:retire()
+		self.settled = true
+		for _, runtime in self.profiles do
+			for _1, session in runtime.sessions do
+				if session.phase == 0 then
+					session.abandoned = true
+				elseif session.phase == 1 then
+					runtime:seal(session, "retired")
+					runtime:startRelease(session)
+				end
+			end
+		end
+		self.receipts:close(true)
+		self:wake()
+	end
+end
+--* @internal The durability engine behind one profile store (rules 9 to 49). 
+do
+	ProfileRuntime = setmetatable({}, {
+		__tostring = function()
+			return "ProfileRuntime"
+		end,
+	})
+	ProfileRuntime.__index = ProfileRuntime
+	function ProfileRuntime.new(...)
+		local self = setmetatable({}, ProfileRuntime)
+		return self:constructor(...) or self
+	end
+	function ProfileRuntime:constructor(engine, schema, hooks)
+		self.engine = engine
+		self.schema = schema
+		self.hooks = hooks
+		self.sessions = {}
+		self.sealed = {}
+		self.changed = Waiters.new(engine.port)
+		self.inbox = Inbox.new(self)
+	end
+	function ProfileRuntime:key(userId)
+		return tostring(userId)
+	end
+	function ProfileRuntime:present(player)
+		return self.engine.port.players.present(player)
+	end
+	function ProfileRuntime:accept(session)
+		if session.phase ~= 1 then
+			return false
+		end
+		if bootClock() < session.safeUntil then
+			return true
+		end
+		self:lose(session, "authority")
+		return false
+	end
+	function ProfileRuntime:writable(player)
+		local _sessions = self.sessions
+		local _player = player
+		local session = _sessions[_player]
+		return session ~= nil and self:accept(session)
+	end
+	function ProfileRuntime:players()
+		local result = {}
+		for player, session in self.sessions do
+			if session:writable() then
+				table.insert(result, player)
+			end
+		end
+		return result
+	end
+	function ProfileRuntime:write(player, change, stage)
+		local _sessions = self.sessions
+		local _player = player
+		local session = _sessions[_player]
+		local _result = session
+		if _result ~= nil then
+			_result:assertIdle()
+		end
+		assertOutsideCallback()
+		if self.engine.finalPhase then
+			self.engine:diagnose(`late:{self.schema.name}`, `{self.schema.name} refused a write after the shutdown final phase; a shutdown hook that writes profiles must finish before the sweep's deadline - 10 s`)
+			return false
+		end
+		if session == nil or not self:accept(session) then
+			return false
+		end
+		session:write(change, stage)
+		return true
+	end
+	function ProfileRuntime:newSession(player)
+		local session = Session.new(self.schema, player, player.UserId, self.engine.port.guid(), {
+			changed = function()
+				return self.changed:wake()
+			end,
+			publish = function(value)
+				return self.hooks.publish(player, value)
+			end,
+		})
+		local _sessions = self.sessions
+		local _player = player
+		_sessions[_player] = session
+		self.changed:wake()
+		return session
+	end
+	function ProfileRuntime:supersedes(userId)
+		local result = {}
+		local _sealed = self.sealed
+		local _userId = userId
+		local _condition = _sealed[_userId]
+		if _condition == nil then
+			_condition = {}
+		end
+		for token, session in _condition do
+			if session.released ~= nil then
+				local _arg1 = {
+					epoch = session.epoch,
+					snapshot = session:snapshot(),
+				}
+				result[token] = _arg1
+			end
+		end
+		return result
+	end
+	function ProfileRuntime:stopped(session)
+		return session.abandoned or self.engine.closing or not self:present(session.player)
+	end
+	ProfileRuntime["end"] = function(self, session, mayHaveCommitted, message)
+		session.phase = 3
+		if mayHaveCommitted then
+			self.engine.scheduler:submit({
+				store = self.schema.name,
+				key = self:key(session.userId),
+				priority = 1,
+				kind = "update",
+				dispatchDeadline = bootClock() + CALL_DEADLINE_SECONDS,
+				bytes = 512,
+				transform = function()
+					return function(current)
+						return abandonAcquisition(current, session.userId, session.token, function() end)
+					end
+				end,
+			})
+		end
+		if message ~= nil then
+			self.engine.port.players.kick(session.player, message)
+		end
+		self:drop(session)
+		self.changed:wake()
+		return false
+	end
+	function ProfileRuntime:drop(session)
+		local _sessions = self.sessions
+		local _player = session.player
+		local _condition = _sessions[_player] == session
+		if _condition then
+			_condition = not self:present(session.player)
+		end
+		if _condition then
+			local _sessions_1 = self.sessions
+			local _player_1 = session.player
+			_sessions_1[_player_1] = nil
+		end
+	end
+	function ProfileRuntime:load(player, reason)
+		local _sessions = self.sessions
+		local _player = player
+		local existing = _sessions[_player]
+		if existing ~= nil and (existing.phase == 0 or existing.phase == 1) then
+			return self:await(player)
+		end
+		local port = self.engine.port
+		local deadline = bootClock() + LOAD_DEADLINE_SECONDS
+		local session = self:newSession(player)
+		local userId = session.userId
+		local polls = 0
+		local held = false
+		local mayHaveCommitted = false
+		local earliest
+		local envelope
+		while envelope == nil do
+			if self:stopped(session) then
+				return self["end"](self, session, mayHaveCommitted)
+			end
+			if bootClock() >= deadline then
+				return self["end"](self, session, mayHaveCommitted, if held then LOAD_BUSY_MESSAGE else LOAD_FAILED_MESSAGE)
+			end
+			local decision
+			local sentAt = 0
+			local ticket = self.engine.scheduler:submit({
+				store = self.schema.name,
+				key = self:key(userId),
+				priority = 4,
+				kind = "update",
+				dispatchDeadline = deadline,
+				bytes = 1024,
+				transform = function()
+					local input = {
+						userId = userId,
+						token = session.token,
+						serverId = port.serverId,
+						jobId = port.jobId,
+						schemaVersion = self.schema.version,
+						supersedes = self:supersedes(userId),
+						wall = port.wall,
+					}
+					return function(current)
+						return acquire(current, input, function(d)
+							decision = d
+							return decision
+						end)
+					end
+				end,
+				onDispatch = function(at)
+					sentAt = at
+					return sentAt
+				end,
+				onResult = function(outcome)
+					if outcome.kind == "error" and not outcome.ambiguous then
+						return nil
+					end
+					if earliest == nil then
+						earliest = sentAt
+					end
+					mayHaveCommitted = true
+				end,
+			})
+			ticket:onSettled(function()
+				return self.changed:wake()
+			end)
+			while ticket.settled == nil and not self:stopped(session) do
+				self.changed:park()
+			end
+			local settled = ticket.settled
+			if settled == nil then
+				return self["end"](self, session, true)
+			end
+			if settled.kind == "done" and settled.outcome.kind == "error" then
+				return self["end"](self, session, mayHaveCommitted, LOAD_FAILED_MESSAGE)
+			end
+			if settled.kind ~= "done" then
+				held = false
+				if settled.kind == "overloaded" then
+					local wake = math.min(deadline, bootClock() + LOAD_POLL_MIN_SECONDS)
+					while bootClock() < wake and not self:stopped(session) do
+						self.changed:park(wake)
+					end
+				end
+				continue
+			end
+			local answer = decision
+			if answer.kind == "taken" or answer.kind == "already" then
+				envelope = answer.envelope
+			elseif answer.kind == "newer" then
+				return self["end"](self, session, false, SERVER_UPDATING_MESSAGE)
+			elseif answer.kind == "unreadable" then
+				self.engine:diagnose(`unreadable:{self.schema.name}:{userId}`, `{self.schema.name}: {userId}'s record is unreadable: {answer.reason}`)
+				return self["end"](self, session, false, LOAD_FAILED_MESSAGE)
+			else
+				held = true
+				mayHaveCommitted = false
+				earliest = nil
+				local base = LOAD_POLL_SCHEDULE_SECONDS[math.min(polls, #LOAD_POLL_SCHEDULE_SECONDS - 1) + 1]
+				polls += 1
+				local jittered = base * (1 - LOAD_POLL_JITTER + 2 * LOAD_POLL_JITTER * port.random())
+				local room = answer.lease.expiresAt + TAKEOVER_GRACE_SECONDS - port.wall()
+				local wake = math.min(deadline, bootClock() + math.max(LOAD_POLL_MIN_SECONDS, math.min(jittered, room)))
+				while bootClock() < wake and not self:stopped(session) do
+					self.changed:park(wake)
+				end
+			end
+		end
+		session.epoch = envelope.epoch
+		session.safeUntil = earliest + LOCAL_AUTHORITY_SECONDS
+		local superseded = self.sealed[userId]
+		if superseded ~= nil then
+			for token, sealed in superseded do
+				if sealed.released ~= nil then
+					superseded[token] = nil
+				end
+			end
+		end
+		local loaded = loadRecord(self.schema, envelope.payload, envelope.schemaVersion)
+		if loaded.kind ~= "ok" then
+			self.engine:diagnose(`load:{self.schema.name}:{if loaded.kind == "newer" then "newer" else loaded.code}`, if loaded.kind == "newer" then `{self.schema.name}: {userId}'s record was written by a newer build (version {loaded.version})` else `{self.schema.name}: {userId}'s record did not load: {loaded.reason}`)
+			return self["end"](self, session, true, if loaded.kind == "newer" then SERVER_UPDATING_MESSAGE else LOAD_FAILED_MESSAGE)
+		end
+		session.value = loaded.value
+		session.revision = if loaded.migrated then 1 else 0
+		for _, id in envelope.receipts do
+			session:stage(id)
+		end
+		local _set = {}
+		for _, _v in envelope.receipts do
+			_set[_v] = true
+		end
+		session.durable = _set
+		local ok, claimed = pcall(function()
+			local result = self.hooks.onLoad(session, session.value, reason)
+			return if rawequal(result, session.value) then result else session:prepare(result)
+		end)
+		if not ok then
+			self.engine:diagnose(`onLoad:{self.schema.name}:{session.token}`, `{self.schema.name}: {userId}'s onLoad failed ({reason})`)
+			return self["end"](self, session, true, LOAD_FAILED_MESSAGE)
+		end
+		if not rawequal(claimed, session.value) then
+			session:commit(claimed)
+		end
+		if self:stopped(session) then
+			return self["end"](self, session, true)
+		end
+		if bootClock() >= session.safeUntil then
+			return self["end"](self, session, true, SESSION_ENDED_MESSAGE)
+		end
+		session.phase = 1
+		self.hooks.publish(player, session.value)
+		self.hooks.delivered(session, envelope)
+		self.inbox:deliver(session, envelope)
+		session.renewAt = bootClock() + port.random() * RENEW_INTERVAL_SECONDS
+		self:armSeal(session)
+		self:armRenewal(session)
+		if session.revision > 0 then
+			self:requestWrite(session, 3)
+		end
+		self.changed:wake()
+		return true
+	end
+	function ProfileRuntime:armSeal(session)
+		local port = self.engine.port
+		local check
+		check = function()
+			if session.phase ~= 1 then
+				return nil
+			end
+			local now = bootClock()
+			if now < session.safeUntil then
+				port.delay(session.safeUntil - now, check)
+				return nil
+			end
+			while session.busy do
+				self.changed:park()
+			end
+			self:lose(session, "authority")
+		end
+		port.delay(session.safeUntil - bootClock(), check)
+	end
+	function ProfileRuntime:armRenewal(session)
+		local port = self.engine.port
+		local tick
+		tick = function()
+			if session.phase ~= 1 or self.engine.settled then
+				return nil
+			end
+			local now = bootClock()
+			if now >= session.renewAt then
+				if not self:present(session.player) then
+					self:leave(session.player)
+					return nil
+				end
+				self:requestWrite(session, 3)
+			end
+			port.delay(math.max(session.renewAt - bootClock(), 1), tick)
+		end
+		port.delay(math.max(session.renewAt - bootClock(), 0), tick)
+	end
+	function ProfileRuntime:seal(session, reason)
+		if session.phase == 0 then
+			session.abandoned = true
+		end
+		if session.phase ~= 1 then
+			return nil
+		end
+		session.phase = 2
+		session.sealedBy = reason
+		self.hooks.publish(session.player, nil)
+		local _sealed = self.sealed
+		local _userId = session.userId
+		local tokens = _sealed[_userId]
+		if tokens == nil then
+			tokens = {}
+			local _sealed_1 = self.sealed
+			local _userId_1 = session.userId
+			local _tokens = tokens
+			_sealed_1[_userId_1] = _tokens
+		end
+		local _tokens = tokens
+		local _token = session.token
+		local _session_1 = session
+		_tokens[_token] = _session_1
+		if reason == "authority" or reason == "fenced" then
+			self.engine:diagnose(`authority:{self.schema.name}:{session.token}`, `{self.schema.name}: {session.userId}'s session lost authority ({reason}) at revision {session.revision}, confirmed {session.confirmed}`)
+			if self:present(session.player) then
+				self.engine.port.players.kick(session.player, SESSION_ENDED_MESSAGE)
+			end
+		end
+		self.changed:wake()
+	end
+	function ProfileRuntime:lose(session, reason)
+		self:seal(session, reason)
+		self:startRelease(session)
+	end
+	function ProfileRuntime:startRelease(session)
+		session.releaseWanted = true
+		self:pumpWriter(session)
+	end
+	function ProfileRuntime:flush(session)
+		self:requestWrite(session, 1)
+	end
+	function ProfileRuntime:requestWrite(session, priority)
+		session.want = if session.want == nil then priority else math.min(session.want, priority)
+		self:pumpWriter(session)
+	end
+	function ProfileRuntime:pumpWriter(session)
+		if session.writing ~= nil then
+			return nil
+		end
+		local release = session.releaseWanted and session.released == nil and session.phase == 2
+		if not release and (session.want == nil or session.phase ~= 1) then
+			return nil
+		end
+		local priority = if release then 1 else session.want
+		session.want = nil
+		local port = self.engine.port
+		session.op += 1
+		local op = session.op
+		local decision
+		local sentAt = 0
+		local earliest
+		if not release then
+			session.renewAt = bootClock() + RENEW_INTERVAL_SECONDS + (port.random() * 2 - 1) * RENEW_JITTER_SECONDS
+		end
+		local ticket = self.engine.scheduler:submit({
+			store = self.schema.name,
+			key = self:key(session.userId),
+			priority = priority,
+			kind = "update",
+			renewal = not release,
+			safeUntil = session.safeUntil,
+			dispatchDeadline = if release then session.safeUntil - LOCAL_AUTHORITY_SECONDS + LEASE_SECONDS else session.safeUntil,
+			bytes = jsonBytes(session.value) + 1024,
+			transform = function()
+				local snapshot = session:snapshot()
+				session.carrying = snapshot.revision
+				local input = {
+					userId = session.userId,
+					token = session.token,
+					epoch = session.epoch,
+					op = op,
+					snapshot = snapshot,
+					release = release,
+					wall = port.wall,
+				}
+				return function(current)
+					return ownedWrite(current, input, function(d)
+						decision = d
+						return decision
+					end)
+				end
+			end,
+			onDispatch = function(at)
+				sentAt = at
+				return sentAt
+			end,
+			onResult = function(outcome)
+				if outcome.kind == "ok" or outcome.ambiguous then
+					if earliest == nil then
+						earliest = sentAt
+					end
+				end
+			end,
+		})
+		session.writing = ticket
+		ticket:onSettled(function(settled)
+			return self:settleOwned(session, release, settled, decision, earliest)
+		end)
+	end
+	function ProfileRuntime:settleOwned(session, release, settled, decision, earliest)
+		local _result = session.writing
+		if _result ~= nil then
+			_result = _result.ambiguous
+		end
+		local ambiguous = _result == true
+		session.writing = nil
+		local outcome = "given up"
+		local lost
+		if settled.kind == "done" and settled.outcome.kind == "ok" and decision ~= nil then
+			if decision.kind == "written" or decision.kind == "already" then
+				outcome = "committed"
+				self:confirm(session, decision.envelope, earliest)
+			elseif decision.kind == "fenced" or decision.kind == "expired" then
+				outcome = "fenced"
+				lost = if decision.kind == "fenced" then "fenced" else "authority"
+			else
+				self.engine:diagnose(`write:{self.schema.name}:{decision.kind}`, `{self.schema.name}: {session.userId}'s owned write was refused: {decision.kind}`)
+				lost = "authority"
+			end
+		elseif settled.kind == "uncertain" then
+			session.lost = math.max(session.lost, session.carrying)
+		end
+		if release then
+			session.released = outcome
+			session.releaseAmbiguous = outcome ~= "committed" and ambiguous
+			session.phase = 3
+			self:released(session)
+		elseif lost ~= nil then
+			self:lose(session, lost)
+		end
+		self.changed:wake()
+		self:pumpWriter(session)
+	end
+	function ProfileRuntime:released(session)
+		if session.released ~= "committed" then
+			self.engine:diagnose(`release:{self.schema.name}:{session.token}`, `{self.schema.name}: {session.userId}'s release did not confirm ({session.released}); revisions {session.confirmed + 1} to {session.revision} unconfirmed`)
+		end
+		if session.sealedBy == "retired" and self:present(session.player) then
+			self.engine.port.players.kick(session.player, SESSION_ENDED_MESSAGE)
+		end
+		local _sealed = self.sealed
+		local _userId = session.userId
+		local tokens = _sealed[_userId]
+		self.engine.port.delay(LEASE_SECONDS + TAKEOVER_GRACE_SECONDS, function()
+			local _result = tokens
+			if _result ~= nil then
+				local _token = session.token
+				_result = _result[_token]
+			end
+			if _result ~= session then
+				return nil
+			end
+			local _token = session.token
+			tokens[_token] = nil
+			-- ▼ ReadonlyMap.size ▼
+			local _size = 0
+			for _ in tokens do
+				_size += 1
+			end
+			-- ▲ ReadonlyMap.size ▲
+			local _condition = _size == 0
+			if _condition then
+				local _sealed_1 = self.sealed
+				local _userId_1 = session.userId
+				_condition = _sealed_1[_userId_1] == tokens
+			end
+			if _condition then
+				local _sealed_1 = self.sealed
+				local _userId_1 = session.userId
+				_sealed_1[_userId_1] = nil
+			end
+		end)
+		self:drop(session)
+	end
+	function ProfileRuntime:confirm(session, envelope, earliest)
+		session.confirmed = math.max(session.confirmed, envelope.commit.revision)
+		local _set = {}
+		for _, _v in envelope.receipts do
+			_set[_v] = true
+		end
+		session.durable = _set
+		if earliest ~= nil and self:accept(session) then
+			session.safeUntil = math.max(session.safeUntil, earliest + LOCAL_AUTHORITY_SECONDS)
+		end
+		self.hooks.delivered(session, envelope)
+		self.inbox:deliver(session, envelope)
+	end
+	function ProfileRuntime:releaseClaims(session, reason)
+		local ok, claimed = pcall(function()
+			local result = self.hooks.onRelease(session, session.value, reason)
+			return if rawequal(result, session.value) then result else session:prepare(result)
+		end)
+		if not ok then
+			self.engine:diagnose(`onRelease:{self.schema.name}:{session.token}`, `{self.schema.name}: {session.userId}'s onRelease ({reason}) was skipped`)
+		elseif not rawequal(claimed, session.value) then
+			session:commit(claimed)
+		end
+	end
+	function ProfileRuntime:release(session, reason)
+		while session.busy do
+			self.changed:park()
+		end
+		if session.phase == 0 then
+			session.abandoned = true
+			self.changed:wake()
+			return nil
+		end
+		if session.phase == 1 then
+			self:releaseClaims(session, reason)
+			self:seal(session, reason)
+			self:startRelease(session)
+		elseif session.phase == 3 then
+			self:drop(session)
+		end
+	end
+	function ProfileRuntime:leave(player)
+		local _sessions = self.sessions
+		local _player = player
+		local session = _sessions[_player]
+		if session ~= nil then
+			self:release(session, "leave")
+		end
+		self.changed:wake()
+	end
+	function ProfileRuntime:handoff(player)
+		local _sessions = self.sessions
+		local _player = player
+		local session = _sessions[_player]
+		local _result = session
+		if _result ~= nil then
+			_result:assertIdle()
+		end
+		assertOutsideCallback()
+		if session == nil or not self:accept(session) then
+			return "unavailable"
+		end
+		self:seal(session, "handoff")
+		self:releaseClaims(session, "handoff")
+		self:startRelease(session)
+		local deadline = bootClock() + HANDOFF_TIMEOUT_SECONDS
+		while session.released == nil and bootClock() < deadline and not self.engine.settled do
+			self.changed:park(deadline)
+		end
+		if session.released == "committed" then
+			return "ok"
+		end
+		local pending = session.writing
+		local _condition = session.releaseAmbiguous
+		if not _condition then
+			local _result_1 = pending
+			if _result_1 ~= nil then
+				_result_1 = _result_1.dispatched
+			end
+			local _condition_1 = _result_1 == true
+			if _condition_1 then
+				_condition_1 = (pending.inFlight or pending.ambiguous)
+			end
+			_condition = _condition_1
+		end
+		return if _condition then "uncertain" else "timeout"
+	end
+	function ProfileRuntime:resume(player)
+		local _sessions = self.sessions
+		local _player = player
+		local session = _sessions[_player]
+		local _result = session
+		if _result ~= nil then
+			_result:assertIdle()
+		end
+		assertOutsideCallback()
+		if session ~= nil and self:accept(session) then
+			return true
+		end
+		if not self:present(player) then
+			return false
+		end
+		return self:load(player, "resume")
+	end
+	function ProfileRuntime:await(player)
+		local deadline = bootClock() + LOAD_DEADLINE_SECONDS
+		while true do
+			local _sessions = self.sessions
+			local _player = player
+			local session = _sessions[_player]
+			if session ~= nil and self:accept(session) then
+				return true
+			end
+			if not self:present(player) or self.engine.closing or bootClock() >= deadline then
+				return false
+			end
+			if session ~= nil and session.phase ~= 0 then
+				return false
+			end
+			self.changed:park(deadline)
+		end
+	end
+	function ProfileRuntime:save(player, timeoutSeconds)
+		if timeoutSeconds == nil then
+			timeoutSeconds = SAVE_TIMEOUT_DEFAULT_SECONDS
+		end
+		assertOutsideCallback()
+		local _sessions = self.sessions
+		local _player = player
+		local session = _sessions[_player]
+		if session == nil or not self:accept(session) then
+			return "unavailable"
+		end
+		local deadline = bootClock() + math.clamp(timeoutSeconds, 0, SAVE_TIMEOUT_MAX_SECONDS)
+		local target = session.revision
+		self:requestWrite(session, 3)
+		while session.confirmed < target and session.phase ~= 3 and bootClock() < deadline and not self.engine.settled do
+			self.changed:park(deadline)
+		end
+		if session.confirmed >= target then
+			return "ok"
+		end
+		return if session:uncertain() >= target then "uncertain" else "timeout"
+	end
+	function ProfileRuntime:inspect(userId)
+		for _, session in self.sessions do
+			if session.userId == userId and self:accept(session) then
+				return {
+					kind = "ok",
+					value = session.value,
+				}
+			end
+		end
+		local deadline = bootClock() + CALL_DEADLINE_SECONDS
+		local ticket = self.engine.scheduler:submit({
+			store = self.schema.name,
+			key = self:key(userId),
+			priority = 5,
+			kind = "read",
+			dispatchDeadline = deadline,
+			bytes = 1024,
+		})
+		local settled = ticket:wait(deadline) or {
+			kind = if ticket.dispatched then "uncertain" else "timeout",
+		}
+		if settled.kind ~= "done" then
+			return {
+				kind = settled.kind,
+			}
+		end
+		if settled.outcome.kind == "error" then
+			return {
+				kind = "unavailable",
+			}
+		end
+		local _result = settled.outcome.value
+		if _result ~= nil then
+			_result = _result.value
+		end
+		local parsed = parseEnvelope(_result, "profiles")
+		if parsed.kind == "absent" or (parsed.kind == "ok" and parsed.envelope.payload == nil) then
+			return {
+				kind = "ok",
+				value = nil,
+			}
+		end
+		if parsed.kind == "unreadable" then
+			return {
+				kind = "unavailable",
+			}
+		end
+		local loaded = loadRecord(self.schema, parsed.envelope.payload, parsed.envelope.schemaVersion)
+		return if loaded.kind == "ok" then {
+			kind = "ok",
+			value = loaded.value,
+		} else {
+			kind = "unavailable",
+		}
+	end
+end
+return {
+	DataEngine = DataEngine,
+	ProfileRuntime = ProfileRuntime,
+}