@trioforge/crucible 0.0.0-stage → 0.2.0

package/out/internal/boot.luau

@@ -0,0 +1,562 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local runtimeDiagnostic = TS.import(script, script.Parent, "diagnostics").runtimeDiagnostic
+local Subsystem = TS.import(script, script.Parent.Parent, "subsystem").Subsystem
+local CrucibleBehaviour = TS.import(script, script.Parent.Parent, "crucible-behaviour").CrucibleBehaviour
+local _binding = TS.import(script, script.Parent, "binding")
+local construct = _binding.construct
+local forget = _binding.forget
+local reconcile = _binding.reconcile
+local useEngine = _binding.useEngine
+local watch = _binding.watch
+local _hooks = TS.import(script, script.Parent, "hooks")
+local hooks = _hooks.hooks
+local lifecycleHooks = _hooks.lifecycleHooks
+local shutdownHooks = _hooks.shutdownHooks
+local useImplementerPort = TS.import(script, script.Parent, "implementers").useImplementerPort
+local _lifecycle = TS.import(script, script.Parent, "lifecycle")
+local admit = _lifecycle.admit
+local drain = _lifecycle.drain
+local hasEnded = _lifecycle.hasEnded
+local request = _lifecycle.request
+local track = _lifecycle.track
+local useEffects = _lifecycle.useEffects
+local _registry = TS.import(script, script.Parent, "registry")
+local records = _registry.records
+local seal = _registry.seal
+local robloxPort = TS.import(script, script.Parent, "roblox-port").robloxPort
+local Scheduler = TS.import(script, script.Parent, "scheduler").Scheduler
+local _flush = TS.import(script, script.Parent, "reactive", "flush")
+local holdBarrier = _flush.holdBarrier
+local releaseBarrier = _flush.releaseBarrier
+local useReactivePort = _flush.useReactivePort
+local endInterval = TS.import(script, script.Parent, "reactive", "ownership").endInterval
+local _declarations = TS.import(script, script.Parent, "sync", "declarations")
+local rollbackDeclarations = _declarations.rollbackDeclarations
+local sealDeclarations = _declarations.sealDeclarations
+--* @internal 
+local BOOT_CLASSES = { Subsystem, CrucibleBehaviour }
+--* @internal 
+--* @internal 
+local PATTERN_PREFIX = "crucible-path:"
+--* @internal 
+local SHUTDOWN_DEADLINE_SECONDS = 25
+--* @internal 
+local SHUTDOWN_TIMEOUT_SECONDS = 28
+local clock
+local sweep
+--* @internal 
+--* @internal The one monotonic clock, core's and data's (data rules 25, 105). 
+local function bootClock()
+	return (clock or os.clock)()
+end
+--* @internal Undefined until the sweep has begun. 
+local function shutdownProgress(subsystem)
+	if sweep == nil then
+		return nil
+	end
+	local pending = 0
+	local notStarted = 0
+	for _, record in sweep.order do
+		local _condition = sweep.finished[record] ~= nil
+		if not _condition then
+			local _result = record.state
+			if _result ~= nil then
+				_result = _result.object
+			end
+			_condition = _result == subsystem
+		end
+		if _condition then
+			continue
+		end
+		pending += 1
+		if not (sweep.started[record] ~= nil) then
+			notStarted += 1
+		end
+	end
+	return {
+		startedAt = sweep.startTime,
+		forceStartAt = sweep.startTime + SHUTDOWN_DEADLINE_SECONDS,
+		deadline = sweep.startTime + SHUTDOWN_TIMEOUT_SECONDS,
+		pending = pending,
+		notStarted = notStarted,
+	}
+end
+--* @internal 
+local function parsePattern(pattern)
+	local _pattern = pattern
+	local _arg1 = #PATTERN_PREFIX
+	if string.sub(_pattern, 1, _arg1) ~= PATTERN_PREFIX then
+		error(`Crucible load needs the transformer: {pattern}`)
+	end
+	local _pattern_1 = pattern
+	local _arg0 = #PATTERN_PREFIX + 1
+	local segments = string.split(string.sub(_pattern_1, _arg0), "/")
+	-- ▼ ReadonlyArray.some ▼
+	local _result = false
+	local _callback = function(s)
+		return s == "" or s == "." or s == ".."
+	end
+	for _k, _v in segments do
+		if _callback(_v, _k - 1, segments) then
+			_result = true
+			break
+		end
+	end
+	-- ▲ ReadonlyArray.some ▲
+	if _result then
+		error(`Invalid Crucible load pattern: {pattern}`)
+	end
+	return segments
+end
+local function matches(name, pattern)
+	local open = string.find(pattern, "{", 1, true)
+	if open ~= nil then
+		local close = string.find(pattern, "}", open, true)
+		if close == nil then
+			error(`Invalid Crucible name pattern: {pattern}`)
+		end
+		local _pattern = pattern
+		local _arg0 = open + 1
+		local _arg1 = close - 1
+		local _exp = string.split(string.sub(_pattern, _arg0, _arg1), ",")
+		-- ▼ ReadonlyArray.some ▼
+		local _result = false
+		local _callback = function(part)
+			local _exp_1 = name
+			local _pattern_1 = pattern
+			local _arg1_1 = open - 1
+			local _exp_2 = string.sub(_pattern_1, 1, _arg1_1) .. part
+			local _pattern_2 = pattern
+			local _arg0_1 = close + 1
+			return matches(_exp_1, _exp_2 .. string.sub(_pattern_2, _arg0_1))
+		end
+		for _k, _v in _exp do
+			if _callback(_v, _k - 1, _exp) then
+				_result = true
+				break
+			end
+		end
+		-- ▲ ReadonlyArray.some ▲
+		return _result
+	end
+	local star = string.find(pattern, "*", 1, true)
+	if star == nil then
+		return name == pattern
+	end
+	local _pattern = pattern
+	local _arg1 = star - 1
+	local prefix = string.sub(_pattern, 1, _arg1)
+	local _name = name
+	local _arg1_1 = #prefix
+	if string.sub(_name, 1, _arg1_1) ~= prefix then
+		return false
+	end
+	for i = #prefix, #name do
+		local _name_1 = name
+		local _arg0 = i + 1
+		local _exp = string.sub(_name_1, _arg0)
+		local _pattern_1 = pattern
+		local _arg0_1 = star + 1
+		if matches(_exp, string.sub(_pattern_1, _arg0_1)) then
+			return true
+		end
+	end
+	return false
+end
+--* @internal 
+local function load(patterns)
+	local found = {}
+	local function walk(node, segments, index)
+		if index == #segments then
+			if node:IsA("ModuleScript") then
+				local _node = node
+				found[_node] = true
+			end
+			return nil
+		end
+		local segment = segments[index + 1]
+		if segment == "**" then
+			walk(node, segments, index + 1)
+		end
+		for _, child in node:GetChildren() do
+			if segment == "**" then
+				walk(child, segments, index)
+			elseif matches(child.Name, segment) then
+				walk(child, segments, index + 1)
+			end
+		end
+	end
+	for _, pattern in patterns do
+		local segments = parsePattern(pattern)
+		walk(game:GetService(segments[1]), segments, 1)
+	end
+	local _array = {}
+	local _length = #_array
+	for _v in found do
+		_length += 1
+		_array[_length] = _v
+	end
+	local modules = _array
+	table.sort(modules, function(a, b)
+		return a:GetFullName() < b:GetFullName()
+	end)
+	for _, module in modules do
+		require(module)
+	end
+end
+local HOOK_NAMES = { "constructor", "awake", "onEnable", "start", "onDisable", "onDestroy", "a frame hook", "accepts", "an All<T> callback", "settle", "cancel", "internal" }
+local function where(port, s)
+	local id = (s.record).id
+	return if s.instance == nil then id else `{id} on {port.describe(s.instance)}`
+end
+local function describeFault(port, s)
+	local fault = s.fault
+	local message = `{where(port, s)} faulted in {HOOK_NAMES[fault.hook + 1]}: {tostring(fault.error)}`
+	for _, later in fault.cleanup do
+		message ..= `\n  then {HOOK_NAMES[later.hook + 1]} failed: {tostring(later.error)}`
+	end
+	return message
+end
+local function hookCaller(s, hook)
+	if hook == 1 then
+		return function(s)
+			return hooks().awake(s.object, 0)
+		end
+	end
+	if s.record.kind ~= 1 then
+		return nil
+	end
+	if hook == 2 then
+		return function(s)
+			return lifecycleHooks().onEnable(s.object, 0)
+		end
+	end
+	if hook == 4 then
+		return function(s)
+			return lifecycleHooks().onDisable(s.object, 0)
+		end
+	end
+	if hook == 5 then
+		return function(s)
+			return lifecycleHooks().onDestroy(s.object, 0)
+		end
+	end
+	return nil
+end
+local function shutdown(port, order)
+	local started = {}
+	local finished = {}
+	local dependents = {}
+	for _, record in order do
+		dependents[record] = {}
+	end
+	for _, record in order do
+		for _1, dep in record.resolved do
+			if not dep.all then
+				local _record = dep.record
+				local _exp = dependents[_record]
+				table.insert(_exp, record)
+			end
+		end
+	end
+	local startTime = port.clock()
+	sweep = {
+		startTime = startTime,
+		order = order,
+		started = started,
+		finished = finished,
+	}
+	while true do
+		-- ▼ ReadonlySet.size ▼
+		local _size = 0
+		for _ in finished do
+			_size += 1
+		end
+		-- ▲ ReadonlySet.size ▲
+		if not (_size < #order) then
+			break
+		end
+		local expired = port.clock() - startTime >= SHUTDOWN_DEADLINE_SECONDS
+		for _, record in order do
+			local _condition = started[record] ~= nil
+			if not _condition then
+				local _condition_1 = not expired
+				if _condition_1 then
+					local _exp = dependents[record]
+					-- ▼ ReadonlyArray.every ▼
+					local _result = true
+					local _callback = function(r)
+						local _r = r
+						return finished[_r] ~= nil
+					end
+					for _k, _v in _exp do
+						if not _callback(_v, _k - 1, _exp) then
+							_result = false
+							break
+						end
+					end
+					-- ▲ ReadonlyArray.every ▲
+					_condition_1 = not _result
+				end
+				_condition = _condition_1
+			end
+			if _condition then
+				continue
+			end
+			started[record] = true
+			port.spawn(function()
+				local _object = record.state
+				if _object ~= nil then
+					_object = _object.object
+				end
+				local object = _object
+				if object ~= nil then
+					local ok, err = xpcall(function()
+						return shutdownHooks().onShutdown(object)
+					end, function(err)
+						return debug.traceback(tostring(err), 2)
+					end)
+					if not ok then
+						runtimeDiagnostic("error", `{record.id} onShutdown failed: {err}`)
+					end
+				end
+				finished[record] = true
+			end)
+		end
+		if port.clock() - startTime >= SHUTDOWN_TIMEOUT_SECONDS then
+			return nil
+		end
+		-- ▼ ReadonlySet.size ▼
+		local _size_1 = 0
+		for _ in finished do
+			_size_1 += 1
+		end
+		-- ▲ ReadonlySet.size ▲
+		if _size_1 < #order then
+			port.wait()
+		end
+	end
+end
+--* @internal 
+local function ignite(port, side, options)
+	clock = port.clock
+	sweep = nil
+	local singletons = seal({
+		renders = side.renders,
+	})
+	local frame = hooks().frame
+	local _exp = port
+	local _object = {}
+	local _left = "fixedRate"
+	local _condition = options.fixedRate
+	if _condition == nil then
+		_condition = 60
+	end
+	_object[_left] = _condition
+	_object.renders = side.renders
+	local scheduler = Scheduler.new(_exp, _object, {
+		[0] = function(o, dt)
+			return frame[0](o, dt)
+		end,
+		[1] = function(o, dt)
+			return frame[1](o, dt)
+		end,
+		[2] = function(o, dt)
+			return frame[2](o, dt)
+		end,
+		[3] = function(o, dt)
+			return frame[3](o, dt)
+		end,
+	})
+	local owned = {}
+	local stage = "booting"
+	local failure
+	local stop = function() end
+	local function reject(message)
+		if stage ~= "booting" then
+			return nil
+		end
+		failure = message
+		stage = "rollback"
+		stop()
+		for state in owned do
+			request(state, 2)
+		end
+	end
+	useEngine(port)
+	holdBarrier()
+	useReactivePort(port)
+	useImplementerPort(port)
+	useEffects({
+		construct = function(s)
+			if stage == "booting" then
+				local _s = s
+				owned[_s] = true
+			end
+			return construct(s)
+		end,
+		hook = hookCaller,
+		start = function(s)
+			return hooks().start(s.object, 0)
+		end,
+		join = function(s)
+			for _, set in (s.record).memberOf do
+				set:join(s.object)
+			end
+		end,
+		leave = function(s)
+			for _, set in (s.record).memberOf do
+				set:leave(s.object)
+			end
+		end,
+		tick = function(s)
+			return scheduler:add(s)
+		end,
+		untick = function(s)
+			return scheduler:remove(s)
+		end,
+		reconcile = function()
+			if stage == "rollback" then
+				return {}
+			end
+			local created = reconcile()
+			if stage == "booting" then
+				for _, s in created do
+					owned[s] = true
+				end
+			end
+			return created
+		end,
+		ended = function(s)
+			forget(s)
+			if s.fault == nil then
+				return nil
+			end
+			local message = describeFault(port, s)
+			runtimeDiagnostic("error", message)
+			if s.record.kind == 0 then
+				reject(message)
+			end
+		end,
+		defer = port.defer,
+		cancel = port.cancel,
+		failed = function(message)
+			runtimeDiagnostic("error", message)
+			reject(message)
+		end,
+		diagnose = function(s, hook, err)
+			return runtimeDiagnostic("error", `{where(port, s)} {HOOK_NAMES[hook + 1]} failed: {tostring(err)}`)
+		end,
+		disabled = endInterval,
+	})
+	local ok, err = pcall(function()
+		local _exp_1 = records()
+		-- ▼ ReadonlyArray.filter ▼
+		local _newValue = {}
+		local _callback = function(r)
+			return r.kind == 1
+		end
+		local _length = 0
+		for _k, _v in _exp_1 do
+			if _callback(_v, _k - 1, _exp_1) == true then
+				_length += 1
+				_newValue[_length] = _v
+			end
+		end
+		-- ▲ ReadonlyArray.filter ▲
+		stop = watch(_newValue)
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue_1 = table.create(#singletons)
+		local _callback_1 = function(r)
+			local s = track(r)
+			r.state = s
+			owned[s] = true
+			return s
+		end
+		for _k, _v in singletons do
+			_newValue_1[_k] = _callback_1(_v, _k - 1, singletons)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		local initial = _newValue_1
+		admit(initial)
+		drain()
+	end)
+	if not ok then
+		reject(tostring(err))
+	end
+	if failure == nil then
+		local unbooted = nil
+		local finalized, finalizeErr = pcall(function()
+			-- Roblox cannot unbind BindToClose, so the callback checks that this boot committed.
+			if side.name == "server" then
+				port.bindToClose(function()
+					if stage ~= "committed" then
+						return nil
+					end
+					shutdown(port, singletons)
+					side.network:close()
+				end)
+			end
+			unbooted = side.booted()
+			if side.name == "client" then
+				sealDeclarations()
+			end
+			side.network:commit()
+		end)
+		if not finalized then
+			local undo = unbooted
+			if undo ~= nil then
+				local undone, undoErr = pcall(undo)
+				if not undone then
+					runtimeDiagnostic("error", `Crucible: undoing booted failed: {tostring(undoErr)}`)
+				end
+			end
+			reject(`boot finalization failed: {tostring(finalizeErr)}`)
+		end
+	end
+	if failure ~= nil then
+		for s in owned do
+			if not hasEnded(s) then
+				request(s, 2)
+			end
+		end
+		drain()
+		table.clear(owned)
+		releaseBarrier()
+		error(`Crucible boot failed: {failure}`, 0)
+	end
+	stage = "committed"
+	table.clear(owned)
+	releaseBarrier()
+end
+--* @internal 
+local function boot(side, options)
+	local ok, err = pcall(function()
+		side.network:open()
+		load(options.load)
+		side.network:loaded()
+		if side.name == "server" then
+			sealDeclarations()
+		end
+		ignite(robloxPort(), side, options)
+	end)
+	if ok then
+		return nil
+	end
+	side.network:close()
+	rollbackDeclarations()
+	error(err, 0)
+end
+return {
+	bootClock = bootClock,
+	shutdownProgress = shutdownProgress,
+	parsePattern = parsePattern,
+	load = load,
+	ignite = ignite,
+	boot = boot,
+	BOOT_CLASSES = BOOT_CLASSES,
+	PATTERN_PREFIX = PATTERN_PREFIX,
+	SHUTDOWN_DEADLINE_SECONDS = SHUTDOWN_DEADLINE_SECONDS,
+	SHUTDOWN_TIMEOUT_SECONDS = SHUTDOWN_TIMEOUT_SECONDS,
+}

package/out/internal/configs/limits.d.ts

@@ -0,0 +1,10 @@
+export declare const MAX_CONFIG_DECLARATIONS = 1000;
+export declare const CONFIG_NAME_MAX_BYTES = 64;
+export declare const CONFIG_VALUE_MAX_BYTES = 100000;
+export declare const CONFIG_ADMISSION_VISITS = 100000;
+export declare const CONFIG_REQUEST_CONCURRENCY = 4;
+export declare const CONFIG_FETCH_RETRY_BASE_SECONDS = 1;
+export declare const CONFIG_FETCH_RETRY_CAP_SECONDS = 30;
+export declare const CONFIG_REFRESH_TIMEOUT_SECONDS = 10;
+export declare const CONFIG_VALUE_DEPTH = 28;
+export declare const CONFIG_STRING_MAX_BYTES = 65536;

package/out/internal/configs/limits.luau

@@ -0,0 +1,25 @@
+-- Compiled with roblox-ts v3.0.0
+local MAX_CONFIG_DECLARATIONS = 1_000
+local CONFIG_NAME_MAX_BYTES = 64
+local CONFIG_VALUE_MAX_BYTES = 100_000
+local CONFIG_ADMISSION_VISITS = 100_000
+local CONFIG_REQUEST_CONCURRENCY = 4
+local CONFIG_FETCH_RETRY_BASE_SECONDS = 1
+local CONFIG_FETCH_RETRY_CAP_SECONDS = 30
+local CONFIG_REFRESH_TIMEOUT_SECONDS = 10
+-- Rule 97 admits configs by rule 76's walk, whose depth and string bounds are data's PERSIST_DEPTH and
+-- PERSIST_STRING_BYTES. Data's limits module is not under configs yet, so the values are restated here.
+local CONFIG_VALUE_DEPTH = 28
+local CONFIG_STRING_MAX_BYTES = 65_536
+return {
+	MAX_CONFIG_DECLARATIONS = MAX_CONFIG_DECLARATIONS,
+	CONFIG_NAME_MAX_BYTES = CONFIG_NAME_MAX_BYTES,
+	CONFIG_VALUE_MAX_BYTES = CONFIG_VALUE_MAX_BYTES,
+	CONFIG_ADMISSION_VISITS = CONFIG_ADMISSION_VISITS,
+	CONFIG_REQUEST_CONCURRENCY = CONFIG_REQUEST_CONCURRENCY,
+	CONFIG_FETCH_RETRY_BASE_SECONDS = CONFIG_FETCH_RETRY_BASE_SECONDS,
+	CONFIG_FETCH_RETRY_CAP_SECONDS = CONFIG_FETCH_RETRY_CAP_SECONDS,
+	CONFIG_REFRESH_TIMEOUT_SECONDS = CONFIG_REFRESH_TIMEOUT_SECONDS,
+	CONFIG_VALUE_DEPTH = CONFIG_VALUE_DEPTH,
+	CONFIG_STRING_MAX_BYTES = CONFIG_STRING_MAX_BYTES,
+}

package/out/internal/configs/port.d.ts

@@ -0,0 +1,29 @@
+import type { Disconnect } from "../port";
+export interface ConfigSnapshotPort {
+    /** `GetValue`: nil for a missing key. A JSON config may arrive as a table or as its text. */
+    readonly get: (key: string) => unknown;
+    /** `Refresh`. Yields and may throw. */
+    readonly refresh: () => void;
+    /** Unmeasured in Studio: whether this turns true without `UpdateAvailable`. Runtime treats the two as independent. */
+    readonly outdated: () => boolean;
+    /** `Error` is `LoadFailed`. */
+    readonly failed: () => boolean;
+    readonly onUpdateAvailable: (listener: () => void) => Disconnect;
+}
+/** What configs ask of the engine. Requests yield and may throw. */
+export interface ConfigPort {
+    readonly global: () => ConfigSnapshotPort;
+    readonly forPlayer: (player: Player) => ConfigSnapshotPort;
+    readonly players: () => readonly Player[];
+    readonly onPlayerAdded: (listener: (player: Player) => void) => Disconnect;
+    readonly onPlayerRemoving: (listener: (player: Player) => void) => Disconnect;
+    readonly wait: (seconds: number) => void;
+    /** Uniform in [0, 1). */
+    readonly random: () => number;
+    readonly decodeJson: (text: string) => unknown;
+    /** The JSON text length of a decoded value. Throws for a value JSON cannot hold. */
+    readonly jsonBytes: (value: object) => number;
+}
+export declare function installConfigPort(value: ConfigPort): void;
+export declare function configPort(): ConfigPort;
+export declare function createRobloxConfigPort(): ConfigPort;