@trioforge/crucible 0.0.0-stage → 0.1.0

package/out/internal/boot.luau

@@ -0,0 +1,463 @@
+-- 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
+--* @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
+--* @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()
+	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)
+	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)
+	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,
+	})
+	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
+		for s in owned do
+			if not hasEnded(s) then
+				request(s, 2)
+			end
+		end
+		drain()
+		table.clear(owned)
+		error(`Crucible boot failed: {failure}`, 0)
+	end
+	stage = "committed"
+	table.clear(owned)
+	if side.name == "server" then
+		port.bindToClose(function()
+			return shutdown(port, singletons)
+		end)
+	end
+	side.booted()
+end
+--* @internal 
+local function boot(side, options)
+	load(options.load)
+	ignite(robloxPort(), side, options)
+end
+return {
+	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/construction-claim.d.ts

@@ -0,0 +1 @@
+export {};

package/out/internal/construction-claim.luau

@@ -0,0 +1,26 @@
+-- Compiled with roblox-ts v3.0.0
+local claims = {}
+--* @internal 
+local function setClaim(state)
+	local _arg0 = coroutine.running()
+	local _state = state
+	claims[_arg0] = _state
+end
+--* @internal 
+local function readClaim()
+	local _arg0 = coroutine.running()
+	return claims[_arg0]
+end
+--* @internal 
+local function clearClaim(thread)
+	if thread == nil then
+		thread = coroutine.running()
+	end
+	local _thread = thread
+	claims[_thread] = nil
+end
+return {
+	setClaim = setClaim,
+	readClaim = readClaim,
+	clearClaim = clearClaim,
+}

package/out/internal/dense-list.d.ts

@@ -0,0 +1 @@
+export {};

package/out/internal/dense-list.luau

@@ -0,0 +1,155 @@
+-- Compiled with roblox-ts v3.0.0
+local function walk(items, stop, visit)
+	do
+		local i = 0
+		local _shouldIncrement = false
+		while true do
+			if _shouldIncrement then
+				i += 1
+			else
+				_shouldIncrement = true
+			end
+			if not (i < stop) then
+				break
+			end
+			local item = items[i + 1]
+			if item ~= nil then
+				visit(item)
+			end
+		end
+	end
+end
+--[[
+	*
+	 * @internal
+	 * Ordered list with O(1) append, O(1) removal by tombstone, and allocation-free iteration. Holes are
+	 * `end - count`. An append always writes at `end`, so no slot is reused until compaction, which runs outside a
+	 * walk once holes pass half the slots. Outside a walk `end <= 2 * count`, so a walk touches at most twice the
+	 * members and compaction costs at most twice the removals. Iteration order is insertion order and survives any
+	 * mutation from inside a visit. Items appended during `forEach` are visited by the next call, not this one.
+	 
+]]
+local DenseList
+do
+	DenseList = setmetatable({}, {
+		__tostring = function()
+			return "DenseList"
+		end,
+	})
+	DenseList.__index = DenseList
+	function DenseList.new(...)
+		local self = setmetatable({}, DenseList)
+		return self:constructor(...) or self
+	end
+	function DenseList:constructor()
+		self.items = {}
+		self.slots = {}
+		self["end"] = 0
+		self.count = 0
+		self.depth = 0
+	end
+	function DenseList:size()
+		return self.count
+	end
+	function DenseList:has(item)
+		local _slots = self.slots
+		local _item = item
+		return _slots[_item] ~= nil
+	end
+	function DenseList:add(item)
+		local _slots = self.slots
+		local _item = item
+		if _slots[_item] ~= nil then
+			return false
+		end
+		self.items[self["end"] + 1] = item
+		local _slots_1 = self.slots
+		local _item_1 = item
+		local _arg1 = self["end"]
+		_slots_1[_item_1] = _arg1
+		self["end"] += 1
+		self.count += 1
+		return true
+	end
+	function DenseList:remove(item)
+		local _slots = self.slots
+		local _item = item
+		local slot = _slots[_item]
+		if slot == nil then
+			return false
+		end
+		self.items[slot + 1] = nil
+		local _slots_1 = self.slots
+		local _item_1 = item
+		_slots_1[_item_1] = nil
+		self.count -= 1
+		self:compactIfSparse()
+		return true
+	end
+	function DenseList:forEach(visit)
+		self.depth += 1
+		local ok, err = pcall(walk, self.items, self["end"], visit)
+		self.depth -= 1
+		self:compactIfSparse()
+		if not ok then
+			error(err, 0)
+		end
+	end
+	function DenseList:first()
+		do
+			local i = 0
+			local _shouldIncrement = false
+			while true do
+				if _shouldIncrement then
+					i += 1
+				else
+					_shouldIncrement = true
+				end
+				if not (i < self["end"]) then
+					break
+				end
+				local item = self.items[i + 1]
+				if item ~= nil then
+					return item
+				end
+			end
+		end
+		return nil
+	end
+	function DenseList:compactIfSparse()
+		if self.depth > 0 or self["end"] - self.count <= self["end"] / 2 then
+			return nil
+		end
+		local write = 0
+		do
+			local read = 0
+			local _shouldIncrement = false
+			while true do
+				if _shouldIncrement then
+					read += 1
+				else
+					_shouldIncrement = true
+				end
+				if not (read < self["end"]) then
+					break
+				end
+				local item = self.items[read + 1]
+				if item == nil then
+					continue
+				end
+				if read ~= write then
+					self.items[write + 1] = item
+					self.items[read + 1] = nil
+					local _slots = self.slots
+					local _write = write
+					_slots[item] = _write
+				end
+				write += 1
+			end
+		end
+		self["end"] = write
+	end
+end
+return {
+	DenseList = DenseList,
+}

package/out/internal/diagnostics.d.ts

@@ -0,0 +1 @@
+export {};

package/out/internal/diagnostics.luau

@@ -0,0 +1,29 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local loggingPort = TS.import(script, script.Parent, "log-output").loggingPort
+local emitting = false
+local terminal = false
+--* @internal 
+local function runtimeDiagnostic(level, message)
+	if not emitting then
+		emitting = true
+		local ok = pcall(function()
+			return loggingPort().writeInternal(level, message)
+		end)
+		emitting = false
+		if ok then
+			return nil
+		end
+	end
+	if terminal then
+		return nil
+	end
+	terminal = true
+	pcall(function()
+		return warn(`[Crucible] {message}`)
+	end)
+	terminal = false
+end
+return {
+	runtimeDiagnostic = runtimeDiagnostic,
+}

package/out/internal/hooks.d.ts

@@ -0,0 +1 @@
+export {};