@trioforge/crucible 0.0.0-stage → 0.2.0

package/out/internal/registry.luau

@@ -0,0 +1,455 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local hooks = TS.import(script, script.Parent, "hooks").hooks
+local ImplementerSet = TS.import(script, script.Parent, "implementers").ImplementerSet
+local drain = TS.import(script, script.Parent, "lifecycle").drain
+--* @internal 
+--* @internal 
+--* @internal 
+--* @internal 
+--* @internal 
+--* @internal 
+--* @internal 
+--* @internal 
+--* @internal 
+--* @internal 
+--* @internal 
+--* @internal 
+local registered = {}
+local byClass = {}
+local duplicates = {}
+local sets = {}
+local sealed
+--* @internal 
+local function define(klass, emitted, first)
+	if first == nil then
+		first = false
+	end
+	if sealed ~= nil then
+		error(`Crucible: {emitted.id} registered after boot; it would never be constructed or bound`)
+	end
+	local id = emitted.id
+	-- ▼ ReadonlyArray.some ▼
+	local _result = false
+	local _callback = function(record)
+		return record.id == id
+	end
+	for _k, _v in registered do
+		if _callback(_v, _k - 1, registered) then
+			_result = true
+			break
+		end
+	end
+	-- ▲ ReadonlyArray.some ▲
+	if _result then
+		table.insert(duplicates, id)
+	end
+	local statics = klass
+	local _object = {
+		id = id,
+		klass = klass,
+		hooks = hooks().overrides(klass),
+	}
+	local _left = "deps"
+	local _exp = emitted.deps
+	-- ▼ ReadonlyArray.map ▼
+	local _newValue = table.create(#_exp)
+	local _callback_1 = function(dep)
+		local _dep = dep
+		return if type(_dep) == "string" then {
+			id = dep,
+			all = false,
+		} else {
+			id = dep.all,
+			all = true,
+		}
+	end
+	for _k, _v in _exp do
+		_newValue[_k] = _callback_1(_v, _k - 1, _exp)
+	end
+	-- ▲ ReadonlyArray.map ▲
+	_object[_left] = _newValue
+	local _left_1 = "provides"
+	local _array = { id }
+	local _length = #_array
+	local _exp_1 = emitted.provides
+	-- ▼ ReadonlyArray.map ▼
+	local _newValue_1 = table.create(#_exp_1)
+	local _callback_2 = function(provided)
+		return provided
+	end
+	for _k, _v in _exp_1 do
+		_newValue_1[_k] = _callback_2(_v, _k - 1, _exp_1)
+	end
+	-- ▲ ReadonlyArray.map ▲
+	table.move(_newValue_1, 1, #_newValue_1, _length + 1, _array)
+	_object[_left_1] = _array
+	_object.renderPriority = statics.renderPriority
+	_object.resolved = {}
+	_object.memberOf = {}
+	local base = _object
+	local record
+	if emitted.kind == "subsystem" then
+		local _object_1 = table.clone(base)
+		setmetatable(_object_1, nil)
+		_object_1.kind = 0
+		_object_1.first = first
+		record = _object_1
+	else
+		local tag = emitted.tag
+		klass.tag = tag
+		local attributes
+		if emitted.attributes ~= nil then
+			attributes = {}
+			for name, check in pairs(emitted.attributes) do
+				attributes[name] = check
+			end
+		end
+		local _object_1 = table.clone(base)
+		setmetatable(_object_1, nil)
+		_object_1.kind = 1
+		_object_1.tag = tag
+		_object_1.instanceClasses = emitted.instance
+		_object_1.attributes = attributes
+		_object_1.bound = {}
+		_object_1.suppressed = {}
+		record = _object_1
+	end
+	local _record = record
+	table.insert(registered, _record)
+	local _klass = klass
+	local _record_1 = record
+	byClass[_klass] = _record_1
+end
+--* @internal 
+local function plan(records, side)
+	local problems = {}
+	local providers = {}
+	for _, record in records do
+		for _1, id in record.provides do
+			local list = providers[id]
+			if list == nil then
+				local _arg1 = { record }
+				providers[id] = _arg1
+			else
+				table.insert(list, record)
+			end
+		end
+	end
+	local single = {}
+	for _, record in records do
+		local edges = {}
+		for _1, dep in record.deps do
+			if dep.all then
+				continue
+			end
+			local _id = dep.id
+			local _condition = providers[_id]
+			if _condition == nil then
+				_condition = {}
+			end
+			local candidates = _condition
+			-- ▼ ReadonlyArray.filter ▼
+			local _newValue = {}
+			local _callback = function(candidate)
+				return candidate.kind == 0
+			end
+			local _length = 0
+			for _k, _v in candidates do
+				if _callback(_v, _k - 1, candidates) == true then
+					_length += 1
+					_newValue[_length] = _v
+				end
+			end
+			-- ▲ ReadonlyArray.filter ▲
+			local subsystems = _newValue
+			if #candidates == 0 then
+				local _arg0 = {
+					kind = "missing",
+					needer = record.id,
+					dep = dep.id,
+				}
+				table.insert(problems, _arg0)
+			elseif #subsystems == 0 then
+				local _arg0 = {
+					kind = "behaviour-dependency",
+					needer = record.id,
+					dep = dep.id,
+				}
+				table.insert(problems, _arg0)
+			elseif #candidates > 1 then
+				local _object = {
+					kind = "ambiguous",
+					needer = record.id,
+					dep = dep.id,
+				}
+				local _left = "providers"
+				-- ▼ ReadonlyArray.map ▼
+				local _newValue_1 = table.create(#candidates)
+				local _callback_1 = function(c)
+					return c.id
+				end
+				for _k, _v in candidates do
+					_newValue_1[_k] = _callback_1(_v, _k - 1, candidates)
+				end
+				-- ▲ ReadonlyArray.map ▲
+				_object[_left] = _newValue_1
+				table.insert(problems, _object)
+			else
+				local _arg0 = subsystems[1]
+				table.insert(edges, _arg0)
+			end
+		end
+		single[record] = edges
+		local renders = (bit32.band(record.hooks, (bit32.lshift(1, 0)))) ~= 0 or record.renderPriority ~= nil
+		if not side.renders and renders then
+			local _arg0 = {
+				kind = "render-on-server",
+				id = record.id,
+				priority = record.renderPriority,
+			}
+			table.insert(problems, _arg0)
+		end
+	end
+	local order = {}
+	local colour = {}
+	local path = {}
+	local visit
+	visit = function(record)
+		local _record = record
+		local seen = colour[_record]
+		if seen == "black" then
+			return nil
+		end
+		if seen == "grey" then
+			local _record_1 = record
+			local from = (table.find(path, _record_1) or 0) - 1
+			local cycle = {}
+			do
+				local i = from
+				local _shouldIncrement = false
+				while true do
+					if _shouldIncrement then
+						i += 1
+					else
+						_shouldIncrement = true
+					end
+					if not (i < #path) then
+						break
+					end
+					local _id = path[i + 1].id
+					table.insert(cycle, _id)
+				end
+			end
+			local _id = record.id
+			table.insert(cycle, _id)
+			local _arg0 = {
+				kind = "cycle",
+				path = cycle,
+			}
+			table.insert(problems, _arg0)
+			return nil
+		end
+		local _record_1 = record
+		colour[_record_1] = "grey"
+		local _record_2 = record
+		table.insert(path, _record_2)
+		local _record_3 = record
+		local _condition = single[_record_3]
+		if _condition == nil then
+			_condition = {}
+		end
+		for _, dep in _condition do
+			visit(dep)
+		end
+		path[#path] = nil
+		local _record_4 = record
+		colour[_record_4] = "black"
+		local _record_5 = record
+		table.insert(order, _record_5)
+	end
+	for _, record in records do
+		if record.kind == 0 and record.first then
+			visit(record)
+		end
+	end
+	for _, record in records do
+		if record.kind == 0 then
+			visit(record)
+		end
+	end
+	if #problems > 0 then
+		return {
+			ok = false,
+			problems = problems,
+		}
+	end
+	return {
+		ok = true,
+		plan = {
+			providers = providers,
+			subsystemOrder = order,
+		},
+	}
+end
+local function describe(problem)
+	local _exp = problem.kind
+	repeat
+		if _exp == "duplicate" then
+			return `{problem.id} is registered twice`
+		end
+		if _exp == "missing" then
+			return `{problem.needer} needs {problem.dep}, which nothing provides`
+		end
+		if _exp == "ambiguous" then
+			return `{problem.needer} needs one {problem.dep}, but {table.concat(problem.providers, ", ")} all provide it`
+		end
+		if _exp == "behaviour-dependency" then
+			return `{problem.needer} needs {problem.dep}, which only behaviours provide; take All<T> or call X.get(instance)`
+		end
+		if _exp == "cycle" then
+			return `dependency cycle {table.concat(problem.path, " -> ")}; break it with All<T>`
+		end
+		if _exp == "render-on-server" then
+			return `{problem.id} renders but is loaded on the server`
+		end
+	until true
+end
+--* @internal 
+local setFor
+local function seal(side)
+	if sealed ~= nil then
+		error("Crucible: boot already ran on this side")
+	end
+	local result = plan(registered, side)
+	local problems = {}
+	for _, id in duplicates do
+		local _arg0 = {
+			kind = "duplicate",
+			id = id,
+		}
+		table.insert(problems, _arg0)
+	end
+	if not result.ok then
+		for _, problem in result.problems do
+			table.insert(problems, problem)
+		end
+	end
+	if #problems > 0 then
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#problems)
+		for _k, _v in problems do
+			_newValue[_k] = describe(_v, _k - 1, problems)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		error(`Crucible could not boot:\n  {table.concat(_newValue, "\n  ")}`)
+	end
+	if not result.ok then
+		return {}
+	end
+	local _binding = result.plan
+	local providers = _binding.providers
+	local subsystemOrder = _binding.subsystemOrder
+	for _, record in registered do
+		local _exp = record.deps
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#_exp)
+		local _callback = function(dep)
+			if dep.all then
+				return {
+					all = true,
+					set = setFor(dep.id),
+				}
+			end
+			local _object = {
+				all = false,
+			}
+			local _left = "record"
+			local _id = dep.id
+			local _condition = providers[_id]
+			if _condition == nil then
+				_condition = {}
+			end
+			_object[_left] = _condition[1]
+			return _object
+		end
+		for _k, _v in _exp do
+			_newValue[_k] = _callback(_v, _k - 1, _exp)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		record.resolved = _newValue
+		local _exp_1 = record.provides
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue_1 = table.create(#_exp_1)
+		for _k, _v in _exp_1 do
+			_newValue_1[_k] = setFor(_v, _k - 1, _exp_1)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		record.memberOf = _newValue_1
+	end
+	sealed = result.plan
+	return subsystemOrder
+end
+--* @internal 
+local function records()
+	return registered
+end
+--* @internal 
+local function recordOf(klass)
+	local _klass = klass
+	return byClass[_klass]
+end
+--* @internal 
+local function resolveOne(id)
+	drain()
+	local plan = sealed or error(`inject<{id}>() called before boot`)
+	local _providers = plan.providers
+	local _id = id
+	local _condition = _providers[_id]
+	if _condition == nil then
+		_condition = {}
+	end
+	local candidates = _condition
+	local provider = candidates[1]
+	if #candidates ~= 1 or provider.kind ~= 0 then
+		error(`inject<{id}>(): {#candidates} providers; inject needs exactly one subsystem`)
+	end
+	local state = provider.state
+	local _result = state
+	if _result ~= nil then
+		_result = _result.phase
+	end
+	if _result == 5 then
+		error(`inject<{id}>(): provider {provider.id} is Faulted`)
+	end
+	local _object = state
+	if _object ~= nil then
+		_object = _object.object
+	end
+	local object = _object
+	if state == nil or object == nil or state.phase == 0 or state.phase == 1 then
+		error(`inject<{id}>(): {provider.id} is not awake yet; call inject from start or later, or take a constructor parameter`)
+	end
+	return object
+end
+--* @internal 
+function setFor(id)
+	local _id = id
+	local set = sets[_id]
+	if set == nil then
+		set = ImplementerSet.new(id)
+		local _id_1 = id
+		local _set = set
+		sets[_id_1] = _set
+	end
+	return set
+end
+return {
+	define = define,
+	plan = plan,
+	seal = seal,
+	records = records,
+	recordOf = recordOf,
+	resolveOne = resolveOne,
+	setFor = setFor,
+}

package/out/internal/roblox-port.d.ts

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

package/out/internal/roblox-port.luau

@@ -0,0 +1,117 @@
+-- Compiled with roblox-ts v3.0.0
+--* @internal 
+--* @internal 
+local robloxBindingPort
+local function robloxPort()
+	local runService = game:GetService("RunService")
+	local events = {
+		[0] = runService.PreRender,
+		[1] = runService.PreSimulation,
+		[2] = runService.PostSimulation,
+		[3] = runService.RenderStepped,
+		[4] = runService.PreAnimation,
+		[5] = runService.Heartbeat,
+	}
+	local _object = table.clone(robloxBindingPort())
+	setmetatable(_object, nil)
+	_object.onFrame = function(event, listener)
+		local connection = events[event]:Connect(listener)
+		return function()
+			return connection:Disconnect()
+		end
+	end
+	_object.bindRenderStep = function(name, priority, listener)
+		runService:BindToRenderStep(name, priority, listener)
+		return function()
+			return runService:UnbindFromRenderStep(name)
+		end
+	end
+	_object.defer = function(callback)
+		task.defer(callback)
+	end
+	_object.cancel = function(thread)
+		return task.cancel(thread)
+	end
+	_object.spawn = function(callback)
+		task.spawn(callback)
+	end
+	_object.clock = function()
+		return os.clock()
+	end
+	_object.wait = function()
+		task.wait()
+	end
+	_object.bindToClose = function(callback)
+		return game:BindToClose(callback)
+	end
+	return _object
+end
+--* @internal 
+--* @internal 
+function robloxBindingPort()
+	local collection = game:GetService("CollectionService")
+	local excluded = { game:GetService("ServerStorage"), game:GetService("ReplicatedStorage"), game:GetService("ServerScriptService"), game:GetService("StarterGui"), game:GetService("StarterPack"), game:GetService("StarterPlayer") }
+	return {
+		hasTag = function(instance, tag)
+			return collection:HasTag(instance, tag)
+		end,
+		tagged = function(tag)
+			return collection:GetTagged(tag)
+		end,
+		onTagAdded = function(tag, listener)
+			local c = collection:GetInstanceAddedSignal(tag):Connect(listener)
+			return function()
+				return c:Disconnect()
+			end
+		end,
+		onTagRemoved = function(tag, listener)
+			local c = collection:GetInstanceRemovedSignal(tag):Connect(listener)
+			return function()
+				return c:Disconnect()
+			end
+		end,
+		inWorld = function(instance)
+			return instance:IsDescendantOf(game)
+		end,
+		isA = function(instance, name)
+			return instance:IsA(name)
+		end,
+		bindingScope = function(instance)
+			-- ▼ ReadonlyArray.some ▼
+			local _result = false
+			local _callback = function(container)
+				return instance == container or instance:IsDescendantOf(container)
+			end
+			for _k, _v in excluded do
+				if _callback(_v, _k - 1, excluded) then
+					_result = true
+					break
+				end
+			end
+			-- ▲ ReadonlyArray.some ▲
+			return not _result
+		end,
+		onAncestryChanged = function(instance, listener)
+			local c = instance.AncestryChanged:Connect(listener)
+			return function()
+				return c:Disconnect()
+			end
+		end,
+		getAttribute = function(instance, name)
+			return instance:GetAttribute(name)
+		end,
+		onAttributeChanged = function(instance, name, listener)
+			local c = instance:GetAttributeChangedSignal(name):Connect(listener)
+			return function()
+				return c:Disconnect()
+			end
+		end,
+		describe = function(instance)
+			return instance:GetFullName()
+		end,
+	}
+end
+return {
+	robloxPort = robloxPort,
+	robloxBindingPort = robloxBindingPort,
+}

package/out/internal/runner.d.ts

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

package/out/internal/runner.luau

@@ -0,0 +1,86 @@
+-- Compiled with roblox-ts v3.0.0
+--* @internal 
+--* @internal The error value of a call that yielded. 
+local YIELDED = "yielded; only start may yield"
+local DONE = {}
+local free = {}
+local owners = {}
+local function loop(work, a, b)
+	while true do
+		-- The only resumer is `call`, which always passes a function and its two arguments.
+		local result = work(a, b)
+		-- A parked worker must not keep its last arguments alive.
+		work = nil
+		a = nil
+		b = nil
+		local nextWork, nextA, nextB = coroutine.yield(DONE, result)
+		work = nextWork
+		a = nextA
+		b = nextB
+	end
+end
+--[[
+	*
+	 * @internal
+	 * Runs every callback that must not yield: hooks other than `start`, constructors, `accepts`, and `All<T>`
+	 * callbacks. A pool of parked worker coroutines (GoodSignal's free-runner trick) detects a yield, which
+	 * `pcall` cannot. A worker returns to the pool after a call that returned, so steady-state calls allocate
+	 * nothing. A throw kills its worker, and a yield gets its worker cancelled, so only failures allocate a new
+	 * one. A callback that calls `call` again takes another worker, and the pool grows to the deepest nesting.
+	 *
+	 * `owner` becomes the worker's owner for the call, which is what `current()` reads. Without one the call is
+	 * ownerless. Returns the callback's result on Ok, or the error (with a traceback) on Threw and Yielded.
+	 
+]]
+local function call(work, a, b, owner)
+	-- ▼ Array.pop ▼
+	local _length = #free
+	local _result = free[_length]
+	free[_length] = nil
+	-- ▲ Array.pop ▲
+	local _condition = _result
+	if _condition == nil then
+		_condition = coroutine.create(loop)
+	end
+	local worker = _condition
+	if owner ~= nil then
+		local _owner = owner
+		owners[worker] = _owner
+	end
+	local ok, marker, value = coroutine.resume(worker, work, a, b)
+	owners[worker] = nil
+	if not ok then
+		return 1, debug.traceback(worker, tostring(marker))
+	end
+	if marker ~= DONE then
+		local trace = debug.traceback(worker, YIELDED)
+		-- A failed cancel leaves the worker suspended, so it never returns to the pool.
+		local cancelled, err = pcall(task.cancel, worker)
+		return 2, if cancelled then trace else `{trace}\ncancellation failed: {err}`
+	end
+	table.insert(free, worker)
+	return 0, value
+end
+--* @internal The object that owns `thread`: a runner worker during an owned call, or a start thread for its life. 
+local function ownerOf(thread)
+	local _thread = thread
+	return owners[_thread]
+end
+--* @internal 
+local function own(thread, owner)
+	local _thread = thread
+	local _owner = owner
+	owners[_thread] = _owner
+end
+--* @internal 
+local function disown(thread)
+	local _thread = thread
+	owners[_thread] = nil
+end
+return {
+	call = call,
+	ownerOf = ownerOf,
+	own = own,
+	disown = disown,
+	YIELDED = YIELDED,
+}

package/out/internal/scheduler.d.ts

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