@trioforge/crucible 0.0.0-stage → 0.1.0

package/out/internal/log-output.d.ts

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

package/out/internal/log-output.luau

@@ -0,0 +1,106 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local LogLevel = TS.import(script, script.Parent.Parent, "log-level").LogLevel
+--* @internal 
+local port
+--* @internal 
+local function installLoggingPort(value)
+	local _arg0 = port == nil
+	assert(_arg0, "Logging port already selected")
+	port = value
+end
+--* @internal 
+local createRobloxLoggingPort
+local function loggingPort()
+	if port == nil then
+		port = createRobloxLoggingPort()
+	end
+	return port
+end
+local function escape(text)
+	return (string.gsub((string.gsub(text, "{", "{{")), "}", "}}"))
+end
+--* @internal 
+function createRobloxLoggingPort()
+	local gameLogger
+	local crucibleLogger
+	local fallback = false
+	local studio = game:GetService("RunService"):IsStudio()
+	local function native(write, plain)
+		if not fallback then
+			local ok = pcall(function()
+				local service = game:GetService("LogService")
+				if gameLogger == nil then
+					gameLogger = service:GetLogger("Game")
+				end
+				if crucibleLogger == nil then
+					crucibleLogger = service:GetLogger("Crucible")
+				end
+				write()
+			end)
+			if ok then
+				return nil
+			end
+			fallback = true
+		end
+		plain()
+	end
+	return {
+		isStudio = function()
+			return studio
+		end,
+		now = function()
+			return os.clock()
+		end,
+		describeInstance = function(instance)
+			return instance:GetFullName()
+		end,
+		writeGame = function(record)
+			local text = `[{record.source}] {record.message}`
+			if record.level == LogLevel.Error then
+				task.spawn(function()
+					local _condition = record.traceback
+					if _condition == nil then
+						_condition = ""
+					end
+					return error(`{text}\n{_condition}`, 0)
+				end)
+				return nil
+			end
+			native(function()
+				local logger = gameLogger
+				if record.level == LogLevel.Debug then
+					logger:Output(escape(text), record.context)
+				elseif record.level == LogLevel.Info then
+					logger:Info(escape(text), record.context)
+				else
+					logger:Warn(escape(text), record.context)
+				end
+			end, function()
+				if record.level == LogLevel.Warning then
+					warn(text)
+				else
+					print(text)
+				end
+			end)
+		end,
+		writeInternal = function(level, message)
+			if level == "error" then
+				task.spawn(function()
+					return error(`[Crucible] {message}`, 0)
+				end)
+			else
+				native(function()
+					return crucibleLogger:Warn(escape(`[Crucible] {message}`), {})
+				end, function()
+					return warn(`[Crucible] {message}`)
+				end)
+			end
+		end,
+	}
+end
+return {
+	installLoggingPort = installLoggingPort,
+	loggingPort = loggingPort,
+	createRobloxLoggingPort = createRobloxLoggingPort,
+}

package/out/internal/port.d.ts

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

package/out/internal/port.luau

@@ -0,0 +1,12 @@
+-- Compiled with roblox-ts v3.0.0
+--* @internal Ends one engine subscription. Idempotent. 
+--* @internal The RunService events the scheduler connects. `BindToRenderStep` lanes have their own entry. 
+--[[
+	*
+	 * @internal
+	 * Everything the runtime asks of the engine. Coroutine functions are not here: they are the Luau language,
+	 * identical in Roblox and Lune. The runner cancels a yielded worker with `task.cancel` itself, because the pool
+	 * works before any port is installed.
+	 
+]]
+return nil

package/out/internal/registry.d.ts

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

package/out/internal/registry.luau

@@ -0,0 +1,446 @@
+-- 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)
+	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
+		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 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 {};