@trioforge/crucible 0.1.0 → 0.3.0

package/out/internal/data/runtime.luau

@@ -0,0 +1,918 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local Subsystem = TS.import(script, script.Parent.Parent.Parent, "subsystem").Subsystem
+local readClaim = TS.import(script, script.Parent.Parent, "construction-claim").readClaim
+local _lifecycle = TS.import(script, script.Parent.Parent, "lifecycle")
+local isLive = _lifecycle.isLive
+local stateOf = _lifecycle.stateOf
+local _graph = TS.import(script, script.Parent.Parent, "reactive", "graph")
+local createComputedNode = _graph.createComputedNode
+local createStateNode = _graph.createStateNode
+local guardPure = _graph.guardPure
+local readComputed = _graph.readComputed
+local readState = _graph.readState
+local write = _graph.write
+local define = TS.import(script, script.Parent.Parent, "registry").define
+local claimPublication = TS.import(script, script.Parent.Parent, "sync", "declarations").claimPublication
+local _values = TS.import(script, script.Parent.Parent, "sync", "values")
+local admitReplicated = _values.admit
+local costOf = _values.costOf
+local bootClock = TS.import(script, script.Parent.Parent, "boot").bootClock
+local _declarations = TS.import(script, script.Parent, "declarations")
+local installServerSide = _declarations.installServerSide
+local profileDeclarations = _declarations.profileDeclarations
+local rootHandle = TS.import(script, script.Parent, "handles").rootHandle
+local _limits = TS.import(script, script.Parent, "limits")
+local CALL_DEADLINE_SECONDS = _limits.CALL_DEADLINE_SECONDS
+local LOAD_DEADLINE_SECONDS = _limits.LOAD_DEADLINE_SECONDS
+local OWNER_VIEWS_MAX_BYTES = _limits.OWNER_VIEWS_MAX_BYTES
+local OWNER_VIEWS_MAX_ENTRIES = _limits.OWNER_VIEWS_MAX_ENTRIES
+local OWNER_VIEWS_MAX_VISITS = _limits.OWNER_VIEWS_MAX_VISITS
+local SAVE_TIMEOUT_DEFAULT_SECONDS = _limits.SAVE_TIMEOUT_DEFAULT_SECONDS
+local SAVE_TIMEOUT_MAX_SECONDS = _limits.SAVE_TIMEOUT_MAX_SECONDS
+local messageOf = TS.import(script, script.Parent, "messages").messageOf
+local getPath = TS.import(script, script.Parent, "paths").getPath
+local dataPort = TS.import(script, script.Parent, "port").dataPort
+local DataEngine = TS.import(script, script.Parent, "profiles").DataEngine
+local _record_bindings = TS.import(script, script.Parent, "record-bindings")
+local bindRecords = _record_bindings.bindRecords
+local unbindRecords = _record_bindings.unbindRecords
+local _record_declarations = TS.import(script, script.Parent, "record-declarations")
+local declaredRecords = _record_declarations.declaredRecords
+local sealDeclarations = _record_declarations.sealDeclarations
+local _session = TS.import(script, script.Parent, "session")
+local assertOutsideCallback = _session.assertOutsideCallback
+local insideDataCallback = _session.insideDataCallback
+local shutdownData = TS.import(script, script.Parent, "shutdown").shutdownData
+local Waiters = TS.import(script, script.Parent, "waiters").Waiters
+--* Rule 127's three measures. 
+--* Server state for every profile store in this realm: one engine, one activation, one claim index (rules 6, 104). 
+local server = {
+	engine = nil,
+	owner = nil,
+	activated = false,
+	activation = nil,
+	disconnect = {},
+	receivers = {},
+	grants = {},
+	stores = 0,
+}
+local bindings = {}
+local function port()
+	local _result = server.engine
+	if _result ~= nil then
+		_result = _result.port
+	end
+	local _condition = _result
+	if _condition == nil then
+		_condition = dataPort()
+	end
+	return _condition
+end
+local function varuintSize(value)
+	local size = 1
+	while value >= 128 do
+		value = math.floor(value / 128)
+		size += 1
+	end
+	return size
+end
+--* A player's slot: one state holding the admitted value while writable, else undefined (rule 9). 
+local Slot
+do
+	Slot = setmetatable({}, {
+		__tostring = function()
+			return "Slot"
+		end,
+	})
+	Slot.__index = Slot
+	function Slot.new(...)
+		local self = setmetatable({}, Slot)
+		return self:constructor(...) or self
+	end
+	function Slot:constructor(binding, player)
+		self.binding = binding
+		self.player = player
+		self.node = createStateNode(nil)
+		self.live = createComputedNode(function()
+			return readState(self.node) ~= nil
+		end)
+		self.client = false
+		self.name = binding.declaration.name
+		self.root = rootHandle(self, binding.declaration.persist)
+	end
+	function Slot:read(path)
+		local _condition = readState(self.node)
+		if _condition == nil then
+			_condition = self.binding.declaration.schema.defaults
+		end
+		return getPath(_condition, path)
+	end
+	function Slot:beforeRead()
+		self.binding:beforeRead(self.player)
+	end
+	function Slot:write(change)
+		return self.binding:write(self.player, change)
+	end
+end
+--* Rule 115: a player who is not present reads the template and writes nothing, and gets no slot. 
+local function inertSource(binding)
+	return {
+		name = binding.declaration.name,
+		client = false,
+		read = function(self, path)
+			return getPath(binding.declaration.schema.defaults, path)
+		end,
+		beforeRead = function(self) end,
+		write = function(self)
+			binding:guard(nil)
+			return false
+		end,
+	}
+end
+--* One profile store's server side: slots, the gate, claims and the owner's views (rules 6, 9 to 12, 115 to 127). 
+local ProfileBinding
+do
+	ProfileBinding = setmetatable({}, {
+		__tostring = function()
+			return "ProfileBinding"
+		end,
+	})
+	ProfileBinding.__index = ProfileBinding
+	function ProfileBinding.new(...)
+		local self = setmetatable({}, ProfileBinding)
+		return self:constructor(...) or self
+	end
+	function ProfileBinding:constructor(declaration)
+		self.declaration = declaration
+		self.slots = {}
+		self.playersNode = createStateNode(table.freeze({}))
+		self.claims = {}
+		self.claiming = {}
+		self.costs = {}
+		for i = 0, #declaration.fields - 1 do
+			local _costs = self.costs
+			local _arg0 = setmetatable({}, {
+				__mode = "k",
+			})
+			table.insert(_costs, _arg0)
+		end
+	end
+	function ProfileBinding:slot(player)
+		local _slots = self.slots
+		local _player = player
+		local slot = _slots[_player]
+		if slot == nil and port().players.present(player) then
+			slot = Slot.new(self, player)
+			local _slots_1 = self.slots
+			local _player_1 = player
+			local _slot = slot
+			_slots_1[_player_1] = _slot
+		end
+		return slot
+	end
+	function ProfileBinding:root(player)
+		local _result = self:slot(player)
+		if _result ~= nil then
+			_result = _result.root
+		end
+		local _condition = _result
+		if _condition == nil then
+			_condition = rootHandle(inertSource(self), self.declaration.persist)
+		end
+		return _condition
+	end
+	function ProfileBinding:guard(session)
+		local _result = session
+		if _result ~= nil then
+			_result:assertIdle()
+		end
+		assertOutsideCallback()
+		if insideDataCallback() then
+			error("a write inside a data callback; return the data instead", 0)
+		end
+		guardPure("write state")
+	end
+	function ProfileBinding:write(player, change)
+		local runtime = self.runtime
+		local _self = self
+		local _result = runtime
+		if _result ~= nil then
+			local _sessions = _result.sessions
+			local _player = player
+			_result = _sessions[_player]
+		end
+		_self:guard(_result)
+		if runtime == nil then
+			return false
+		end
+		return runtime:write(player, change)
+	end
+	function ProfileBinding:beforeRead(player)
+		local _claiming = self.claiming
+		local _player = player
+		local claim = _claiming[_player]
+		if claim ~= nil then
+			error(`{self.declaration.name}: {player.UserId}'s handles are read inside its {claim} claim; read the claim's data argument`, 3)
+		end
+	end
+	function ProfileBinding:publish(player, value)
+		local _result
+		if value == nil then
+			local _slots = self.slots
+			local _player = player
+			_result = _slots[_player]
+		else
+			_result = self:slot(player)
+		end
+		local slot = _result
+		if slot == nil then
+			return nil
+		end
+		local before = slot.node.value ~= nil
+		write(slot.node, value)
+		if before ~= (value ~= nil) then
+			self:refreshPlayers()
+		end
+	end
+	function ProfileBinding:refreshPlayers()
+		local _exp = self.playersNode
+		local _array = {}
+		local _length = #_array
+		local _result = self.runtime
+		if _result ~= nil then
+			_result = _result:players()
+		end
+		local _condition = _result
+		if _condition == nil then
+			_condition = {}
+		end
+		table.move(_condition, 1, #_condition, _length + 1, _array)
+		write(_exp, table.freeze(_array))
+	end
+	function ProfileBinding:drop(player)
+		local _slots = self.slots
+		local _player = player
+		local slot = _slots[_player]
+		if slot == nil then
+			return nil
+		end
+		write(slot.node, nil)
+		local _slots_1 = self.slots
+		local _player_1 = player
+		_slots_1[_player_1] = nil
+		self:refreshPlayers()
+	end
+	function ProfileBinding:loaded(player)
+		local slot = self:slot(player)
+		if slot == nil or readComputed(slot.live) ~= true then
+			return false
+		end
+		local _result = self.runtime
+		if _result ~= nil then
+			_result = _result:writable(player)
+		end
+		return _result == true
+	end
+	function ProfileBinding:checkViews(value, committed)
+		local declaration = self.declaration
+		local record = value
+		local before = committed
+		local live = declaration.liveDeclaration.name
+		local bytes = varuintSize(#live) + #live + costOf(true).bytes
+		local entries = 1 + costOf(true).entries
+		local visits = 2 + costOf(true).visits
+		local _exp = declaration.fields
+		-- ▼ ReadonlyArray.forEach ▼
+		local _callback = function(field, index)
+			local current = record[field.name]
+			local cache = self.costs[index + 1]
+			local cost = if type(current) == "table" and before ~= nil then cache[current] else nil
+			local _condition = cost == nil
+			if not _condition then
+				local _result = before
+				if _result ~= nil then
+					_result = _result[field.name]
+				end
+				_condition = not rawequal(current, _result)
+			end
+			if _condition then
+				local admitted = admitReplicated(field.declaration.plan, `{declaration.name}.{field.name}`, current)
+				cost = costOf(admitted)
+				if type(current) == "table" then
+					local _cost = cost
+					cache[current] = _cost
+				end
+			end
+			local key = field.declaration.name
+			bytes += varuintSize(#key) + #key + cost.bytes
+			entries += 1 + cost.entries
+			visits += 2 + cost.visits
+		end
+		for _k, _v in _exp do
+			_callback(_v, _k - 1, _exp)
+		end
+		-- ▲ ReadonlyArray.forEach ▲
+		local share = self.share
+		if share == nil then
+			return nil
+		end
+		local over = function(measure, cost, limit)
+			return error(`{declaration.name}: the owner's views would cost {cost} {measure}, over this store's share of {limit} ({server.stores} profile stores)`, 0)
+		end
+		if bytes > share.bytes then
+			over("bytes", bytes, share.bytes)
+		end
+		if entries > share.entries then
+			over("entries", entries, share.entries)
+		end
+		if visits > share.visits then
+			over("visits", visits, share.visits)
+		end
+	end
+	function ProfileBinding:onLoad(session, value, reason)
+		local name = self.declaration.name
+		local fits, why = pcall(function()
+			return self:checkViews(value, nil)
+		end)
+		if not fits then
+			server.engine:diagnose(`views:{name}:{session.token}`, `{name}: {session.userId}'s profile does not fit the owner's views: {tostring(why)}`)
+			error(why, 0)
+		end
+		self:runClaims(session, "onLoad", function(claim, data)
+			return claim.callback(session.player, data, reason)
+		end, true, reason)
+		return session.value
+	end
+	function ProfileBinding:onRelease(session, _value, reason)
+		self:runClaims(session, "onRelease", function(claim, data)
+			return claim.callback(session.player, data, reason)
+		end, false, reason)
+		return session.value
+	end
+	function ProfileBinding:runClaims(session, kind, call, fatal, reason)
+		local name = self.declaration.name
+		local _claiming = self.claiming
+		local _player = session.player
+		local _kind = kind
+		_claiming[_player] = _kind
+		for _, claim in self.claims do
+			if claim.kind ~= kind or not claim.live then
+				continue
+			end
+			local current = session.value
+			local ok, err = pcall(function()
+				local result = session:transact(function()
+					return session:callback(function(data)
+						return call(claim, data)
+					end, current, 0)
+				end)
+				if not rawequal(result, current) then
+					session:commit(session:prepare(result))
+				end
+			end)
+			if ok then
+				continue
+			end
+			server.engine:diagnose(`{kind}:{name}:{session.token}:{claim.owner}`, if fatal then `{name}: {session.userId}'s onLoad claim of {claim.owner} failed ({reason}); the load failed` else `{name}: {session.userId}'s onRelease claim of {claim.owner} was skipped ({reason})`)
+			if fatal then
+				local _claiming_1 = self.claiming
+				local _player_1 = session.player
+				_claiming_1[_player_1] = nil
+				error(err, 0)
+			end
+		end
+		local _claiming_1 = self.claiming
+		local _player_1 = session.player
+		_claiming_1[_player_1] = nil
+	end
+	function ProfileBinding:claim(kind, callback, extra)
+		local name = self.declaration.name
+		local owner = readClaim()
+		if owner == nil or owner.record.kind ~= 0 then
+			error(`{name}.{kind} runs while a server Subsystem is constructed; make it a field initializer`, 3)
+		end
+		if server.activated then
+			error(`{name}.{kind}: claims are frozen once the data runtime has started`, 3)
+		end
+		local _callback = callback
+		if not (type(_callback) == "function") then
+			error(`{name}.{kind} takes a function`, 3)
+		end
+		local label = (owner.record).id
+		local _object = {
+			kind = kind,
+			owner = label,
+			callback = callback,
+		}
+		local _left = "message"
+		local _result = extra
+		if _result ~= nil then
+			_result = _result.message
+		end
+		_object[_left] = _result
+		local _left_1 = "productId"
+		local _result_1 = extra
+		if _result_1 ~= nil then
+			_result_1 = _result_1.productId
+		end
+		_object[_left_1] = _result_1
+		_object.live = true
+		local claim = _object
+		if claim.message ~= nil then
+			local _receivers = server.receivers
+			local _name = claim.message.name
+			local other = _receivers[_name]
+			if other ~= nil then
+				error(`{claim.message.name} is received by {other} and {label}; one Subsystem receives each message`, 3)
+			end
+			local _receivers_1 = server.receivers
+			local _name_1 = claim.message.name
+			_receivers_1[_name_1] = label
+		end
+		if claim.productId ~= nil then
+			local _grants = server.grants
+			local _productId = claim.productId
+			local other = _grants[_productId]
+			if other ~= nil then
+				error(`product {claim.productId} is granted by {other} and {label}; one grant handles each product`, 3)
+			end
+			local _grants_1 = server.grants
+			local _productId_1 = claim.productId
+			_grants_1[_productId_1] = label
+		end
+		local _exp = self.claims
+		table.insert(_exp, claim)
+		if owner.subscriptions == nil then
+			owner.subscriptions = {}
+		end
+		local _exp_1 = (owner.subscriptions)
+		table.insert(_exp_1, function()
+			return self:retireClaim(claim)
+		end)
+		return table.freeze({})
+	end
+	function ProfileBinding:retireClaim(claim)
+		if not claim.live then
+			return nil
+		end
+		claim.live = false
+		local engine = server.engine
+		if claim.message ~= nil then
+			local _receivers = server.receivers
+			local _name = claim.message.name
+			_receivers[_name] = nil
+			local _result = self.runtime
+			if _result ~= nil then
+				_result = _result.inbox:unreceive(claim.message.name)
+			end
+		end
+		if claim.productId ~= nil then
+			local _grants = server.grants
+			local _productId = claim.productId
+			_grants[_productId] = nil
+			local _result = engine
+			if _result ~= nil then
+				_result = _result.receipts:unroute(claim.productId)
+			end
+		end
+	end
+	function ProfileBinding:route(engine)
+		local runtime = self.runtime
+		local granted = false
+		for _, claim in self.claims do
+			if not claim.live then
+				continue
+			end
+			if claim.kind == "receive" then
+				runtime.inbox:receive(claim.message, function(player, data, payload)
+					return claim.callback(player, data, payload)
+				end)
+			elseif claim.kind == "grant" then
+				granted = true
+				engine.receipts:route(claim.productId, {
+					runtime = runtime,
+					grant = function(player, data, purchase, afterGrant)
+						return claim.callback(player, data, purchase, afterGrant)
+					end,
+				})
+			end
+		end
+		return granted
+	end
+end
+local function bindingOf(declaration)
+	local _declaration = declaration
+	local binding = bindings[_declaration]
+	if binding == nil then
+		binding = ProfileBinding.new(declaration)
+		local _declaration_1 = declaration
+		local _binding = binding
+		bindings[_declaration_1] = _binding
+	end
+	return binding
+end
+--* Rule 4: a yielding call before activation waits for it within its own deadline. 
+local function activated(deadline)
+	while not server.activated and bootClock() < deadline do
+		if server.activation == nil then
+			server.activation = Waiters.new(port())
+		end
+		server.activation:park(deadline)
+	end
+	return server.activated
+end
+local function saveResult(result)
+	return if result == "ok" then {
+		ok = true,
+	} else {
+		ok = false,
+		reason = result,
+	}
+end
+local function storeResult(result)
+	return if result.kind == "ok" then {
+		ok = true,
+		value = result.value,
+	} else {
+		ok = false,
+		reason = result.kind,
+	}
+end
+local function player(name, member, value)
+	if value == nil then
+		error(`{name}.{member} needs its player on the server`, 3)
+	end
+	return value
+end
+--* Rule 13: send and clearQuarantined are data writes too. 
+local function outsideCallbacks()
+	assertOutsideCallback()
+	if insideDataCallback() then
+		error("a write inside a data callback; return the data instead", 0)
+	end
+end
+local function member(declaration, key)
+	local binding = bindingOf(declaration)
+	local name = declaration.name
+	repeat
+		local _fallthrough = false
+		if key == "loaded" then
+			return function(_, who)
+				return binding:loaded(player(name, "loaded", who))
+			end
+		end
+		if key == "players" then
+			return function()
+				return readState(binding.playersNode)
+			end
+		end
+		if key == "await" then
+			return function(_, who)
+				local target = player(name, "await", who)
+				if not activated(bootClock() + LOAD_DEADLINE_SECONDS) then
+					return false
+				end
+				return binding.runtime:await(target)
+			end
+		end
+		if key == "save" then
+			return function(_, who, timeoutSeconds)
+				local target = player(name, "save", who)
+				local _condition = timeoutSeconds
+				if _condition == nil then
+					_condition = SAVE_TIMEOUT_DEFAULT_SECONDS
+				end
+				local timeout = math.clamp(_condition, 0, SAVE_TIMEOUT_MAX_SECONDS)
+				outsideCallbacks()
+				if not activated(bootClock() + timeout) then
+					return saveResult("unavailable")
+				end
+				return saveResult(binding.runtime:save(target, timeout))
+			end
+		end
+		if key == "handoff" then
+			return function(_, who)
+				local target = player(name, "handoff", who)
+				local _result = binding.runtime
+				if _result ~= nil then
+					_result = _result.sessions[target]
+				end
+				binding:guard(_result)
+				if binding.runtime == nil then
+					return saveResult("unavailable")
+				end
+				return saveResult(binding.runtime:handoff(target))
+			end
+		end
+		if key == "resume" then
+			return function(_, who)
+				local target = player(name, "resume", who)
+				local _result = binding.runtime
+				if _result ~= nil then
+					_result = _result.sessions[target]
+				end
+				binding:guard(_result)
+				if not activated(bootClock() + LOAD_DEADLINE_SECONDS) then
+					return false
+				end
+				return binding.runtime:resume(target)
+			end
+		end
+		if key == "inspect" then
+			return function(_, userId)
+				if not activated(bootClock() + CALL_DEADLINE_SECONDS) then
+					return storeResult({
+						kind = "timeout",
+					})
+				end
+				return storeResult(binding.runtime:inspect(userId))
+			end
+		end
+		if key == "send" then
+			return function(_, userId, message, payload, id)
+				local decl = messageOf(message) or error(`{name}.send takes a profile message`, 2)
+				outsideCallbacks()
+				if not activated(bootClock() + CALL_DEADLINE_SECONDS) then
+					return storeResult({
+						kind = "timeout",
+					})
+				end
+				return storeResult(binding.runtime.inbox:send(userId, decl, payload, id))
+			end
+		end
+		if key == "quarantined" then
+			return function(_, userId)
+				if not activated(bootClock() + CALL_DEADLINE_SECONDS) then
+					return storeResult({
+						kind = "timeout",
+					})
+				end
+				return storeResult(binding.runtime.inbox:quarantined(userId))
+			end
+		end
+		if key == "clearQuarantined" then
+			return function(_, userId, ids, action)
+				outsideCallbacks()
+				if not activated(bootClock() + CALL_DEADLINE_SECONDS) then
+					return storeResult({
+						kind = "timeout",
+					})
+				end
+				return storeResult(binding.runtime.inbox:clearQuarantined(userId, ids, action))
+			end
+		end
+		if key == "onLoad" then
+			_fallthrough = true
+		end
+		if _fallthrough or key == "onRelease" then
+			return function(_, callback)
+				return binding:claim(key, callback)
+			end
+		end
+		if key == "receive" then
+			return function(_, message, callback)
+				return binding:claim("receive", callback, {
+					message = messageOf(message) or error(`{name}.receive takes a profile message`, 2),
+				})
+			end
+		end
+		if key == "grant" then
+			return function(_, productId, callback)
+				local _productId = productId
+				if not (type(_productId) == "number") then
+					error(`{name}.grant takes a product id`, 2)
+				end
+				return binding:claim("grant", callback, {
+					productId = productId,
+				})
+			end
+		end
+	until true
+	error(`{name} has no member {key}`, 2)
+end
+installServerSide({
+	root = function(declaration, who)
+		return bindingOf(declaration):root(who)
+	end,
+	member = member,
+})
+local function ended(object)
+	local s = stateOf(object)
+	return s == nil or not isLive(s)
+end
+--* Rule 107, and a failed boot's rollback, which unseals the registry (rule 3). 
+local function retire()
+	local engine = server.engine
+	for _, disconnect in server.disconnect do
+		disconnect()
+	end
+	table.clear(server.disconnect)
+	if not server.activated then
+		sealDeclarations(false)
+		server.engine = nil
+		server.owner = nil
+		for _, binding in bindings do
+			binding.runtime = nil
+		end
+		return nil
+	end
+	unbindRecords()
+	local _result = engine
+	if _result ~= nil then
+		_result:retire()
+	end
+end
+--[[
+	*
+	 * Rules 3, 104, 125 and 127 at construction: the registry seals, each store gets its engine, the shares are divided
+	 * and every template must fit its share, and the views are published under this construction claim.
+	 
+]]
+local function construct()
+	local state = readClaim()
+	local declarations = profileDeclarations()
+	sealDeclarations(true)
+	if state.subscriptions == nil then
+		state.subscriptions = {}
+	end
+	local _exp = (state.subscriptions)
+	table.insert(_exp, retire)
+	local _condition = #declarations == 0
+	if _condition then
+		-- ▼ ReadonlyMap.size ▼
+		local _size = 0
+		for _ in declaredRecords() do
+			_size += 1
+		end
+		-- ▲ ReadonlyMap.size ▲
+		_condition = _size == 0
+	end
+	if _condition then
+		return nil
+	end
+	local engine = DataEngine.new(dataPort())
+	server.engine = engine
+	server.owner = state
+	server.stores = #declarations
+	local count = math.max(#declarations, 1)
+	local share = {
+		bytes = math.floor(OWNER_VIEWS_MAX_BYTES / count),
+		entries = math.floor(OWNER_VIEWS_MAX_ENTRIES / count),
+		visits = math.floor(OWNER_VIEWS_MAX_VISITS / count),
+	}
+	for _, declaration in declarations do
+		local binding = bindingOf(declaration)
+		binding.share = share
+		binding:checkViews(declaration.schema.defaults, nil)
+		local _object = table.clone(declaration.schema)
+		setmetatable(_object, nil)
+		_object.check = function(value, committed)
+			return binding:checkViews(value, committed)
+		end
+		binding.runtime = engine:profile(_object, {
+			onLoad = function(session, value, reason)
+				return binding:onLoad(session, value, reason)
+			end,
+			onRelease = function(session, value, reason)
+				return binding:onRelease(session, value, reason)
+			end,
+			publish = function(who, value)
+				return binding:publish(who, value)
+			end,
+			delivered = function() end,
+		})
+		claimPublication(declaration.live, function(who)
+			local slot = binding:slot(who)
+			return slot ~= nil and readComputed(slot.live) == true
+		end)
+		for _1, field in declaration.fields do
+			claimPublication(field.handle, function(who)
+				local slot = binding:slot(who)
+				local value = if slot == nil then nil else readState(slot.node)
+				return if value == nil then nil else value[field.name]
+			end)
+		end
+	end
+end
+--* Rule 104: after one wait, a live generation means boot committed. 
+local function activate(owner)
+	local engine = server.engine
+	if engine == nil then
+		return nil
+	end
+	engine.port.wait(0)
+	if ended(owner) then
+		return nil
+	end
+	server.activated = true
+	bindRecords(engine)
+	local granted = false
+	for _, binding in bindings do
+		if binding.runtime ~= nil and binding:route(engine) then
+			granted = true
+		end
+	end
+	if granted then
+		engine.receipts:install(engine.port.marketplace())
+	end
+	local players = engine.port.players
+	local live = {}
+	for _, binding in bindings do
+		if binding.runtime ~= nil then
+			table.insert(live, binding)
+		end
+	end
+	if #live > 0 then
+		local join = function(who)
+			for _, binding in live do
+				engine.port.spawn(function()
+					return binding.runtime:load(who, "join")
+				end)
+			end
+		end
+		local leave = function(who)
+			for _, binding in live do
+				local runtime = binding.runtime
+				engine.port.spawn(function()
+					runtime:leave(who)
+					while true do
+						local _sessions = runtime.sessions
+						local _who = who
+						if not (_sessions[_who] ~= nil) then
+							break
+						end
+						runtime.changed:park()
+					end
+					binding:drop(who)
+				end)
+			end
+		end
+		local _disconnect = server.disconnect
+		local _arg0 = players.onAdded(join)
+		local _arg1 = players.onRemoving(leave)
+		-- ▼ Array.push ▼
+		table.insert(_disconnect, _arg0)
+		table.insert(_disconnect, _arg1)
+		-- ▲ Array.push ▲
+		for _, binding in live do
+			for who in binding.slots do
+				if not players.present(who) then
+					binding:drop(who)
+				end
+			end
+		end
+		for _, who in players.all() do
+			join(who)
+		end
+	end
+	local _result = server.activation
+	if _result ~= nil then
+		_result:wake()
+	end
+end
+--* @internal The framework's data Subsystem (rules 50 to 56, 104, 107). No injection identity; nothing depends on it. 
+local DataRuntime
+do
+	local super = Subsystem
+	DataRuntime = setmetatable({}, {
+		__tostring = function()
+			return "DataRuntime"
+		end,
+		__index = super,
+	})
+	DataRuntime.__index = DataRuntime
+	function DataRuntime.new(...)
+		local self = setmetatable({}, DataRuntime)
+		return self:constructor(...) or self
+	end
+	function DataRuntime:constructor()
+		super.constructor(self)
+		construct()
+	end
+	function DataRuntime:start()
+		activate(self)
+	end
+	function DataRuntime:onShutdown()
+		if server.engine ~= nil then
+			shutdownData(server.engine, self)
+		end
+	end
+end
+local installed = false
+--* @internal The server entry defines DataRuntime once per realm, after ServerSync (rule 104). 
+local function installDataRuntime()
+	if installed then
+		return nil
+	end
+	installed = true
+	define(DataRuntime, {
+		kind = "subsystem",
+		id = "Crucible.DataRuntime",
+		deps = {},
+		provides = {},
+	})
+end
+return {
+	installDataRuntime = installDataRuntime,
+}