@trioforge/crucible 0.1.0 → 0.3.0

package/out/internal/configs/runtime.luau

@@ -0,0 +1,981 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local Subsystem = TS.import(script, script.Parent.Parent.Parent, "subsystem").Subsystem
+local runtimeDiagnostic = TS.import(script, script.Parent.Parent, "diagnostics").runtimeDiagnostic
+local _lifecycle = TS.import(script, script.Parent.Parent, "lifecycle")
+local isLive = _lifecycle.isLive
+local stateOf = _lifecycle.stateOf
+local _schema = TS.import(script, script.Parent.Parent, "network", "schema")
+local admitsNil = _schema.admitsNil
+local assertDescriptor = _schema.assertDescriptor
+local runtimeKind = _schema.runtimeKind
+local _graph = TS.import(script, script.Parent.Parent, "reactive", "graph")
+local createStateNode = _graph.createStateNode
+local readState = _graph.readState
+local write = _graph.write
+local define = TS.import(script, script.Parent.Parent, "registry").define
+local L = TS.import(script, script.Parent, "limits")
+local configPort = TS.import(script, script.Parent, "port").configPort
+--* One value a reader sees. Commit is its only writer. 
+--* A config value as reactive state, so a read is tracked (rule 93) and a commit wakes its readers once. 
+local KEEP = table.freeze({})
+local declarations = {}
+local names = {}
+local sealer
+local function newScope(player)
+	return {
+		player = player,
+		phase = 0,
+		diagnosed = {},
+		ready = createStateNode(false),
+		values = {},
+	}
+end
+local global = newScope()
+local slots = {}
+--* Bumped at every join, so a read for a player with no scope yet reruns once their scope exists (rule 93). 
+local roster = createStateNode(0)
+local owner
+local retired = false
+local listeners = {}
+local flight
+local active = 0
+local queue = {}
+local function fail(path, reason)
+	error({
+		configFailure = true,
+		path = path,
+		reason = reason,
+	})
+end
+local F32_MAX = 3.4028234663852886e38
+local UINT_MAX = {
+	u8 = 255,
+	u16 = 65_535,
+	u32 = 4_294_967_295,
+}
+local function admit(node, value, root)
+	local visits = 0
+	local open = {}
+	local function enter(value, path, depth)
+		visits += 1
+		if visits > L.CONFIG_ADMISSION_VISITS then
+			fail(path, `more than {L.CONFIG_ADMISSION_VISITS} values`)
+		end
+		if depth > L.CONFIG_VALUE_DEPTH then
+			fail(path, `deeper than {L.CONFIG_VALUE_DEPTH}`)
+		end
+		if getmetatable(value) ~= nil then
+			fail(path, "a table with a metatable")
+		end
+		local _value = value
+		if open[_value] ~= nil then
+			fail(path, "a cycle")
+		end
+		local _value_1 = value
+		open[_value_1] = true
+	end
+	local function finish(source, copy)
+		local _source = source
+		open[_source] = nil
+		return table.freeze(copy)
+	end
+	local function scalar(value, path)
+		visits += 1
+		if visits > L.CONFIG_ADMISSION_VISITS then
+			fail(path, `more than {L.CONFIG_ADMISSION_VISITS} values`)
+		end
+		local _value = value
+		if type(_value) == "number" then
+			if value ~= value or math.abs(value) == math.huge then
+				fail(path, "expected a finite number")
+			end
+		else
+			local _value_1 = value
+			if type(_value_1) == "string" then
+				if #value > L.CONFIG_STRING_MAX_BYTES then
+					fail(path, `a string over {L.CONFIG_STRING_MAX_BYTES} bytes`)
+				end
+				if (utf8.len(value)) == nil then
+					fail(path, "invalid UTF-8")
+				end
+			else
+				local _value_2 = value
+				if not (type(_value_2) == "boolean") then
+					local _exp = path
+					local _value_3 = value
+					fail(_exp, `expected JSON, got {typeof(_value_3)}`)
+				end
+			end
+		end
+		return value
+	end
+	local function isArray(value)
+		local array = value
+		local count = 0
+		for key in pairs(array) do
+			if not (type(key) == "number") or key % 1 ~= 0 or key < 1 or key > #array then
+				return false
+			end
+			count += 1
+		end
+		return count == #array
+	end
+	local function json(value, path, depth)
+		local _value = value
+		if not (type(_value) == "table") then
+			return scalar(value, path)
+		end
+		enter(value, path, depth)
+		local copy = {}
+		if isArray(value) then
+			local array = value
+			for i = 0, #array - 1 do
+				local _arg0 = i + 1
+				local _arg1 = json(array[i + 1], `{path}[{i}]`, depth + 1)
+				copy[_arg0] = _arg1
+			end
+		else
+			for key, child in pairs(value) do
+				if not (type(key) == "string") then
+					fail(path, "a table mixing array and object keys")
+				end
+				local _arg1 = json(child, `{path}.{key}`, depth + 1)
+				copy[key] = _arg1
+			end
+		end
+		return finish(value, copy)
+	end
+	local function tableAt(value, path, depth)
+		local _value = value
+		if not (type(_value) == "table") then
+			local _exp = path
+			local _value_1 = value
+			fail(_exp, `expected a table, got {typeof(_value_1)}`)
+		end
+		enter(value, path, depth)
+		return value
+	end
+	local function dense(value, path, depth)
+		local t = tableAt(value, path, depth)
+		if not isArray(t) then
+			fail(path, "expected an array")
+		end
+		return t
+	end
+	local function walk(node, value, path, depth)
+		local _exp = node.kind
+		repeat
+			local _fallthrough = false
+			if _exp == "nil" then
+				if value ~= nil then
+					fail(path, "expected nothing")
+				end
+				return value
+			end
+			if _exp == "literal" then
+				if value ~= node.value then
+					fail(path, `expected the literal {tostring(node.value)}`)
+				end
+				return scalar(value, path)
+			end
+			if _exp == "bool" then
+				local _value = value
+				if not (type(_value) == "boolean") then
+					local _exp_1 = path
+					local _value_1 = value
+					fail(_exp_1, `expected a boolean, got {typeof(_value_1)}`)
+				end
+				return scalar(value, path)
+			end
+			if _exp == "string" then
+				local _value = value
+				if not (type(_value) == "string") then
+					local _exp_1 = path
+					local _value_1 = value
+					fail(_exp_1, `expected a string, got {typeof(_value_1)}`)
+				end
+				return scalar(value, path)
+			end
+			if _exp == "f64" then
+				_fallthrough = true
+			end
+			if _fallthrough or _exp == "f32" then
+				_fallthrough = true
+			end
+			if _fallthrough or _exp == "u8" then
+				_fallthrough = true
+			end
+			if _fallthrough or _exp == "u16" then
+				_fallthrough = true
+			end
+			if _fallthrough or _exp == "u32" then
+				local _value = value
+				if not (type(_value) == "number") then
+					local _exp_1 = path
+					local _value_1 = value
+					fail(_exp_1, `expected a number, got {typeof(_value_1)}`)
+				end
+				scalar(value, path)
+				if node.kind == "f32" and math.abs(value) > F32_MAX then
+					fail(path, "out of f32 range")
+				end
+				if node.kind ~= "f64" and node.kind ~= "f32" then
+					local maximum = UINT_MAX[node.kind]
+					if value % 1 ~= 0 or value < 0 or value > maximum then
+						fail(path, `expected an integer in [0, {maximum}]`)
+					end
+				end
+				return value
+			end
+			if _exp == "object" then
+				local source = tableAt(value, path, depth)
+				local copy = {}
+				local declared = {}
+				for _, _binding in node.fields do
+					local name = _binding[1]
+					local child = _binding[2]
+					declared[name] = true
+					local field = source[name]
+					if field ~= nil then
+						local _arg1 = walk(child, field, `{path}.{name}`, depth + 1)
+						copy[name] = _arg1
+					elseif not admitsNil(child) then
+						fail(`{path}.{name}`, "a required field is missing")
+					end
+				end
+				for key, child in pairs(source) do
+					if not (type(key) == "string") then
+						fail(path, "expected an object")
+					end
+					if not (declared[key] ~= nil) then
+						local _arg1 = json(child, `{path}.{key}`, depth + 1)
+						copy[key] = _arg1
+					end
+				end
+				return finish(source, copy)
+			end
+			if _exp == "array" then
+				local source = dense(value, path, depth)
+				-- ▼ ReadonlyArray.map ▼
+				local _newValue = table.create(#source)
+				local _callback = function(element, i)
+					return walk(node.element, element, `{path}[{i}]`, depth + 1)
+				end
+				for _k, _v in source do
+					_newValue[_k] = _callback(_v, _k - 1, source)
+				end
+				-- ▲ ReadonlyArray.map ▲
+				local copy = _newValue
+				return finish(source, copy)
+			end
+			if _exp == "tuple" then
+				local source = dense(value, path, depth)
+				if #source ~= #node.elements then
+					fail(path, `expected {#node.elements} elements`)
+				end
+				local _exp_1 = node.elements
+				-- ▼ ReadonlyArray.map ▼
+				local _newValue = table.create(#_exp_1)
+				local _callback = function(element, i)
+					return walk(element, source[i + 1], `{path}[{i}]`, depth + 1)
+				end
+				for _k, _v in _exp_1 do
+					_newValue[_k] = _callback(_v, _k - 1, _exp_1)
+				end
+				-- ▲ ReadonlyArray.map ▲
+				local copy = _newValue
+				return finish(source, copy)
+			end
+			if _exp == "map" then
+				local source = tableAt(value, path, depth)
+				local copy = {}
+				for key, child in pairs(source) do
+					local at = `{path}.{tostring(key)}`
+					walk(node.key, key, at, depth + 1)
+					local _arg1 = walk(node.value, child, at, depth + 1)
+					copy[key] = _arg1
+				end
+				return finish(source, copy)
+			end
+			if _exp == "union" then
+				for _, branch in node.branches do
+					if branch.kind == "variant" then
+						local _value = value
+						local _condition = type(_value) == "table"
+						if _condition then
+							_condition = value[branch.key] == branch.value
+						end
+						if _condition then
+							return walk(branch.body, value, path, depth)
+						end
+					else
+						local _result
+						if branch.kind == "literal" then
+							_result = value == branch.value
+						else
+							local _result_1
+							if branch.kind == "nil" then
+								_result_1 = value == nil
+							else
+								local _value = value
+								_result_1 = typeof(_value) == runtimeKind(branch)
+							end
+							_result = _result_1
+						end
+						if _result then
+							return walk(branch, value, path, depth)
+						end
+					end
+				end
+				local _exp_1 = path
+				local _value = value
+				return fail(_exp_1, `matches no member of the union, got {typeof(_value)}`)
+			end
+			fail(path, `a {node.kind} cannot be a config value`)
+		until true
+	end
+	return walk(node, value, root, 0)
+end
+local function acceptsString(node)
+	if node.kind == "union" then
+		local _exp = node.branches
+		-- ▼ ReadonlyArray.some ▼
+		local _result = false
+		for _k, _v in _exp do
+			if acceptsString(_v, _k - 1, _exp) then
+				_result = true
+				break
+			end
+		end
+		-- ▲ ReadonlyArray.some ▲
+		return _result
+	end
+	local _condition = node.kind == "string"
+	if not _condition then
+		local _condition_1 = node.kind == "literal"
+		if _condition_1 then
+			local _value = node.value
+			_condition_1 = type(_value) == "string"
+		end
+		_condition = _condition_1
+	end
+	return _condition
+end
+local function admitRaw(declaration, raw)
+	local port = configPort()
+	local value = raw
+	local _raw = raw
+	if type(_raw) == "string" then
+		if #raw > L.CONFIG_VALUE_MAX_BYTES then
+			fail(declaration.name, `over {L.CONFIG_VALUE_MAX_BYTES} bytes`)
+		end
+		if not acceptsString(declaration.node) then
+			local ok, decoded = pcall(function()
+				return port.decodeJson(raw)
+			end)
+			if not ok then
+				fail(declaration.name, "invalid JSON")
+			end
+			value = decoded
+		end
+	end
+	local _value = value
+	if type(_value) == "table" then
+		local ok, bytes = pcall(function()
+			return port.jsonBytes(value)
+		end)
+		if not ok then
+			fail(declaration.name, "not a JSON value")
+		end
+		if bytes > L.CONFIG_VALUE_MAX_BYTES then
+			fail(declaration.name, `over {L.CONFIG_VALUE_MAX_BYTES} bytes`)
+		end
+	end
+	return admit(declaration.node, value, declaration.name)
+end
+local function failure(err)
+	local _err = err
+	local _condition = type(_err) == "table"
+	if _condition then
+		_condition = err.configFailure == true
+	end
+	if _condition then
+		return err
+	end
+	return {
+		configFailure = true,
+		path = "",
+		reason = "admission failed",
+	}
+end
+local function deepEqual(a, b)
+	if a == b then
+		return true
+	end
+	local _a = a
+	local _condition = not (type(_a) == "table")
+	if not _condition then
+		local _b = b
+		_condition = not (type(_b) == "table")
+	end
+	if _condition then
+		return false
+	end
+	for key, value in pairs(a) do
+		if not deepEqual(value, b[key]) then
+			return false
+		end
+	end
+	for key in pairs(b) do
+		if a[key] == nil then
+			return false
+		end
+	end
+	return true
+end
+local function validName(name)
+	local _name = name
+	local _condition = not (type(_name) == "string")
+	if not _condition then
+		_condition = #name == 0
+	end
+	if _condition then
+		return false
+	end
+	local segments = string.split(name, ".")
+	local _condition_1 = segments[1] ~= "Crucible"
+	if _condition_1 then
+		-- ▼ ReadonlyArray.every ▼
+		local _result = true
+		local _callback = function(s)
+			return (string.match(s, "^[A-Za-z][A-Za-z0-9_]*$")) ~= nil
+		end
+		for _k, _v in segments do
+			if not _callback(_v, _k - 1, segments) then
+				_result = false
+				break
+			end
+		end
+		-- ▲ ReadonlyArray.every ▲
+		_condition_1 = _result
+	end
+	return _condition_1
+end
+local ended
+local function declare(name, kind, fallback, node)
+	if not validName(name) then
+		error(`Config name {tostring(name)} is invalid: use dot-separated [A-Za-z][A-Za-z0-9_]* segments, not Crucible.*`, 3)
+	end
+	if #name > L.CONFIG_NAME_MAX_BYTES then
+		error(`Config name {name} is {#name} bytes; the limit is {L.CONFIG_NAME_MAX_BYTES}`, 3)
+	end
+	local _name = name
+	if names[_name] ~= nil then
+		error(`Config {name} is declared twice`, 3)
+	end
+	if #declarations >= L.MAX_CONFIG_DECLARATIONS then
+		error(`Config {name} passes the limit of {L.MAX_CONFIG_DECLARATIONS} configs`, 3)
+	end
+	if sealer ~= nil and not ended(sealer) then
+		error(`{name} was declared after the config registry sealed; declare configs in modules that boot loads`, 3)
+	end
+	assertDescriptor(node)
+	local ok, admitted = pcall(function()
+		return admit(node, fallback, name)
+	end)
+	if not ok then
+		local f = failure(admitted)
+		error(`Config {name} has an invalid fallback at {f.path}: {f.reason}`, 3)
+	end
+	local declaration = {
+		name = name,
+		kind = kind,
+		node = node,
+		fallback = admitted,
+		global = createStateNode(admitted),
+	}
+	local _name_1 = name
+	names[_name_1] = true
+	table.insert(declarations, declaration)
+	return declaration
+end
+local function readGlobal(declaration)
+	return readState(declaration.global)
+end
+local function readPlayer(declaration, player)
+	local _player = player
+	local scope = slots[_player]
+	if scope == nil then
+		readState(roster)
+		return declaration.fallback
+	end
+	if readState(scope.ready) ~= true then
+		return readState(declaration.global)
+	end
+	local _values = scope.values
+	local _declaration = declaration
+	return readState(_values[_declaration])
+end
+local function ready(player)
+	if player == nil then
+		return readState(global.ready)
+	end
+	local _player = player
+	local scope = slots[_player]
+	if scope == nil then
+		readState(roster)
+		return false
+	end
+	return readState(scope.ready) == true
+end
+local function seal(runtime)
+	sealer = runtime
+end
+function ended(runtime)
+	local s = stateOf(runtime)
+	return s == nil or not isLive(s)
+end
+local function retire()
+	retired = true
+	for _, disconnect in listeners do
+		disconnect()
+	end
+	listeners = {}
+	local _result = global.snapshot
+	if _result ~= nil then
+		_result.disconnect()
+	end
+	for _, scope in slots do
+		local _result_1 = scope.snapshot
+		if _result_1 ~= nil then
+			_result_1.disconnect()
+		end
+	end
+end
+local function live()
+	return owner ~= nil and not retired
+end
+--* `subject` is a config name, or undefined for the snapshot request itself. 
+local function diagnose(scope, subject, reason)
+	local _condition = subject
+	if _condition == nil then
+		_condition = ""
+	end
+	local key = _condition
+	if scope.diagnosed[key] ~= nil then
+		return nil
+	end
+	scope.diagnosed[key] = true
+	local where = if scope.player == nil then "global snapshot" else `snapshot of player {scope.player.UserId}`
+	local _condition_1 = subject
+	if _condition_1 == nil then
+		_condition_1 = "request"
+	end
+	runtimeDiagnostic("warning", `Config {_condition_1} ({where}): {reason}`)
+end
+local function acquire()
+	if active < L.CONFIG_REQUEST_CONCURRENCY then
+		active += 1
+		return nil
+	end
+	local _arg0 = coroutine.running()
+	table.insert(queue, _arg0)
+	coroutine.yield()
+end
+local function release()
+	local waiting = table.remove(queue, 1)
+	if waiting ~= nil then
+		task.spawn(waiting)
+	else
+		active -= 1
+	end
+end
+local function abandoned(scope)
+	return scope.phase == 2 or not live()
+end
+--* One ConfigService request through the shared limit. Undefined when the scope is gone or configs retired. 
+local function request(scope, call)
+	acquire()
+	if abandoned(scope) then
+		release()
+		return nil
+	end
+	local ok, value = pcall(call)
+	release()
+	if abandoned(scope) then
+		return nil
+	end
+	return {
+		ok = ok,
+		value = value,
+	}
+end
+local function stage(scope, snapshot, first, updates)
+	scope.diagnosed = {}
+	local values = {}
+	for _, declaration in declarations do
+		if scope.player ~= nil and declaration.kind ~= "player" then
+			continue
+		end
+		local found, raw = pcall(function()
+			return snapshot.port.get(declaration.name)
+		end)
+		if not found then
+			diagnose(scope, declaration.name, "GetValue failed")
+			values[declaration] = KEEP
+		elseif raw == nil then
+			local _fallback = declaration.fallback
+			values[declaration] = _fallback
+		else
+			local ok, admitted = pcall(function()
+				return admitRaw(declaration, raw)
+			end)
+			if ok then
+				values[declaration] = admitted
+			else
+				local f = failure(admitted)
+				diagnose(scope, declaration.name, `{f.path}: {f.reason}; keeping the last good value`)
+				values[declaration] = KEEP
+			end
+		end
+	end
+	return {
+		scope = scope,
+		snapshot = snapshot,
+		first = first,
+		updates = updates,
+		values = values,
+	}
+end
+local function failed(snapshot)
+	local ok, value = pcall(function()
+		return snapshot.port.failed()
+	end)
+	return not ok or value == true
+end
+local function stale(snapshot)
+	if snapshot.updates ~= snapshot.applied or snapshot.dropped or failed(snapshot) then
+		return true
+	end
+	local ok, outdated = pcall(function()
+		return snapshot.port.outdated()
+	end)
+	return not ok or outdated == true
+end
+local function fetch(scope)
+	local player = scope.player
+	local port = configPort()
+	local result = request(scope, function()
+		return if player == nil then port.global() else port.forPlayer(player)
+	end)
+	if result == nil then
+		return nil
+	end
+	if not result.ok then
+		diagnose(scope, nil, `the fetch failed: {tostring(result.value)}`)
+		return nil
+	end
+	local snapshotPort = result.value
+	local snapshot
+	snapshot = {
+		port = snapshotPort,
+		updates = 0,
+		applied = 0,
+		dropped = false,
+		disconnect = snapshotPort.onUpdateAvailable(function()
+			if live() then
+				snapshot.updates += 1
+			end
+		end),
+	}
+	if failed(snapshot) then
+		snapshot.disconnect()
+		diagnose(scope, nil, "the snapshot failed to load")
+		return nil
+	end
+	return stage(scope, snapshot, true, 0)
+end
+local function refreshScope(scope)
+	if scope.phase == 0 then
+		return fetch(scope)
+	end
+	local snapshot = scope.snapshot
+	if scope.phase ~= 1 or snapshot == nil or not stale(snapshot) then
+		return nil
+	end
+	local updates = snapshot.updates
+	local result = request(scope, function()
+		return snapshot.port.refresh()
+	end)
+	if result == nil then
+		return nil
+	end
+	if not result.ok or failed(snapshot) then
+		diagnose(scope, nil, if result.ok then "the snapshot failed to load" else `the refresh failed: {tostring(result.value)}`)
+		return nil
+	end
+	return stage(scope, snapshot, false, updates)
+end
+--* Writes every changed value of every result in one pass that never yields. 
+local function commit(results)
+	local apply = live()
+	for _, result in results do
+		local scope = result.scope
+		if not apply or scope.phase == 2 or (result.first and scope.phase == 1) then
+			if result.first then
+				result.snapshot.disconnect()
+			end
+			continue
+		end
+		if result.first then
+			scope.snapshot = result.snapshot
+			scope.phase = 1
+		end
+		result.snapshot.applied = result.updates
+		result.snapshot.dropped = false
+		for declaration, value in result.values do
+			local cell
+			if scope.player == nil then
+				cell = declaration.global
+			else
+				cell = scope.values[declaration] or createStateNode(declaration.global.value)
+				local _values = scope.values
+				local _cell = cell
+				_values[declaration] = _cell
+			end
+			if value ~= KEEP and not deepEqual(cell.value, value) then
+				write(cell, value)
+			end
+		end
+		write(scope.ready, true)
+	end
+end
+local function fetchLoop(scope)
+	local port = configPort()
+	do
+		local attempt = 0
+		local _shouldIncrement = false
+		while true do
+			if _shouldIncrement then
+				attempt += 1
+			else
+				_shouldIncrement = true
+			end
+			if attempt > 0 then
+				port.wait(port.random() * math.min(L.CONFIG_FETCH_RETRY_CAP_SECONDS, L.CONFIG_FETCH_RETRY_BASE_SECONDS * 2 ^ (attempt - 1)))
+			end
+			if scope.phase ~= 0 or not live() then
+				return nil
+			end
+			local result = fetch(scope)
+			if result ~= nil then
+				commit({ result })
+				return nil
+			end
+		end
+	end
+end
+local function refresh()
+	if not live() then
+		return false
+	end
+	if flight ~= nil then
+		local _waiters = flight.waiters
+		local _arg0 = coroutine.running()
+		table.insert(_waiters, _arg0)
+		return (coroutine.yield())
+	end
+	local current = {
+		waiters = {},
+	}
+	flight = current
+	local scopes = { global }
+	for _, scope in slots do
+		table.insert(scopes, scope)
+	end
+	local results = {}
+	local caller = coroutine.running()
+	local pending = #scopes
+	local closed = false
+	local parked = false
+	local close = function()
+		if closed then
+			return nil
+		end
+		closed = true
+		if parked then
+			task.spawn(caller)
+		end
+	end
+	for _, scope in scopes do
+		task.spawn(function()
+			local result = refreshScope(scope)
+			if closed then
+				local _result = result
+				if _result ~= nil then
+					_result = _result.first
+				end
+				if _result then
+					result.snapshot.disconnect()
+				elseif result ~= nil then
+					result.snapshot.dropped = true
+				end
+				return nil
+			end
+			if result ~= nil then
+				table.insert(results, result)
+			end
+			pending -= 1
+			if pending == 0 then
+				close()
+			end
+		end)
+	end
+	if not closed then
+		task.spawn(function()
+			configPort().wait(L.CONFIG_REFRESH_TIMEOUT_SECONDS)
+			close()
+		end)
+		parked = true
+		coroutine.yield()
+	end
+	commit(results)
+	local _condition = live()
+	if _condition then
+		-- ▼ ReadonlyArray.every ▼
+		local _result = true
+		local _callback = function(scope)
+			return scope.phase == 2 or (scope.phase == 1 and not stale(scope.snapshot))
+		end
+		for _k, _v in scopes do
+			if not _callback(_v, _k - 1, scopes) then
+				_result = false
+				break
+			end
+		end
+		-- ▲ ReadonlyArray.every ▲
+		_condition = _result
+	end
+	local ok = _condition
+	flight = nil
+	for _, waiter in current.waiters do
+		task.spawn(waiter, ok)
+	end
+	return ok
+end
+local function join(player)
+	local _condition = not live()
+	if not _condition then
+		local _player = player
+		_condition = slots[_player] ~= nil
+	end
+	if _condition then
+		return nil
+	end
+	local scope = newScope(player)
+	local _player = player
+	slots[_player] = scope
+	write(roster, (roster.value) + 1)
+	task.spawn(fetchLoop, scope)
+end
+local function leave(player)
+	if not live() then
+		return nil
+	end
+	local _player = player
+	local scope = slots[_player]
+	if scope == nil then
+		return nil
+	end
+	local _player_1 = player
+	slots[_player_1] = nil
+	scope.phase = 2
+	write(scope.ready, false)
+	local _result = scope.snapshot
+	if _result ~= nil then
+		_result.disconnect()
+	end
+end
+local function activate(runtime)
+	owner = runtime
+	retired = false
+	local _exp = stateOf(runtime)
+	if _exp.subscriptions == nil then
+		_exp.subscriptions = {}
+	end
+	local _exp_1 = (_exp.subscriptions)
+	table.insert(_exp_1, retire)
+	task.spawn(fetchLoop, global)
+	-- ▼ ReadonlyArray.some ▼
+	local _result = false
+	local _callback = function(d)
+		return d.kind == "player"
+	end
+	for _k, _v in declarations do
+		if _callback(_v, _k - 1, declarations) then
+			_result = true
+			break
+		end
+	end
+	-- ▲ ReadonlyArray.some ▲
+	if not _result then
+		return nil
+	end
+	local port = configPort()
+	local _listeners = listeners
+	local _arg0 = port.onPlayerAdded(join)
+	local _arg1 = port.onPlayerRemoving(leave)
+	-- ▼ Array.push ▼
+	table.insert(_listeners, _arg0)
+	table.insert(_listeners, _arg1)
+	-- ▲ Array.push ▲
+	for _, player in port.players() do
+		join(player)
+	end
+end
+local ConfigRuntime
+do
+	local super = Subsystem
+	ConfigRuntime = setmetatable({}, {
+		__tostring = function()
+			return "ConfigRuntime"
+		end,
+		__index = super,
+	})
+	ConfigRuntime.__index = ConfigRuntime
+	function ConfigRuntime.new(...)
+		local self = setmetatable({}, ConfigRuntime)
+		return self:constructor(...) or self
+	end
+	function ConfigRuntime:constructor(...)
+		super.constructor(self, ...)
+	end
+	function ConfigRuntime:start()
+		seal(self)
+		if #declarations == 0 then
+			return nil
+		end
+		configPort().wait(0)
+		if ended(self) then
+			return nil
+		end
+		activate(self)
+	end
+end
+local function installConfigRuntime()
+	define(ConfigRuntime, {
+		kind = "subsystem",
+		id = "Crucible.ConfigRuntime",
+		deps = {},
+		provides = {},
+	})
+end
+return {
+	declare = declare,
+	readGlobal = readGlobal,
+	readPlayer = readPlayer,
+	ready = ready,
+	refresh = refresh,
+	installConfigRuntime = installConfigRuntime,
+}