@trioforge/crucible 0.0.0-stage → 0.2.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/network/catalog.d.ts

@@ -0,0 +1,26 @@
+import { type Codec } from "./codec";
+import type { Node } from "./schema";
+export type MessageKind = "to-server" | "to-client" | "ask-server";
+export interface MessageSpec {
+    readonly kind: MessageKind;
+    readonly name: string;
+    readonly input: Node;
+    readonly output?: Node;
+    readonly timeout?: number;
+}
+export interface Definition {
+    readonly kind: MessageKind;
+    readonly name: string;
+    readonly input: Codec;
+    readonly output?: Codec;
+    readonly timeout: number;
+    readonly index?: number;
+}
+export declare function define(spec: MessageSpec): Definition;
+export declare function seal(): string;
+export declare function adopt(catalog: string): void;
+export declare function definitionAt(index: number): Definition | undefined;
+export declare function definitionOf(token: unknown): Definition | undefined;
+export declare function discardIndices(): void;
+export declare function unpublished(): readonly Definition[];
+export declare function catalogSize(): number;

package/out/internal/network/catalog.luau

@@ -0,0 +1,182 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local compile = TS.import(script, script.Parent, "codec").compile
+local L = TS.import(script, script.Parent, "limits")
+local definitions = {}
+local tokens = {}
+--* The framework's own messages: the only names under the reserved `Crucible.` segment (NET 3, rule 55). 
+local FRAMEWORK_MESSAGES = {
+	["Crucible.State.Fault"] = true,
+	["Crucible.State.Frame"] = true,
+}
+local names = {}
+local indices = {}
+local sealed = false
+local function validName(name)
+	local _name = name
+	local _condition = type(_name) == "string"
+	if _condition then
+		_condition = #name > 0 and #name <= L.MESSAGE_NAME_MAX_BYTES
+	end
+	assert(_condition, "invalid message name")
+	local segments = string.split(name, ".")
+	local _condition_1 = segments[1] ~= "Crucible"
+	if not _condition_1 then
+		local _name_1 = name
+		_condition_1 = FRAMEWORK_MESSAGES[_name_1] ~= nil
+	end
+	assert(_condition_1, "reserved message name")
+	for _, segment in segments do
+		local _arg0 = (string.match(segment, "^[A-Za-z][A-Za-z0-9_]*$")) ~= nil
+		assert(_arg0, "invalid message name")
+	end
+end
+local register
+local function define(spec)
+	validName(spec.name)
+	local _name = spec.name
+	local _arg0 = not (FRAMEWORK_MESSAGES[_name] ~= nil)
+	assert(_arg0, "reserved message name")
+	return register(spec)
+end
+--* @internal The trusted path: a framework message under the reserved `Crucible.` segment that game names refuse. 
+local function defineFramework(spec)
+	local _name = spec.name
+	local _arg0 = FRAMEWORK_MESSAGES[_name] ~= nil
+	assert(_arg0, "not a framework message")
+	return register(spec)
+end
+function register(spec)
+	local _arg0 = not sealed
+	local _arg1 = `{spec.name} was declared after the network catalog sealed; declare messages in modules that boot loads.`
+	assert(_arg0, _arg1)
+	local _name = spec.name
+	local _arg0_1 = not (definitions[_name] ~= nil)
+	local _arg1_1 = `duplicate message {spec.name}`
+	assert(_arg0_1, _arg1_1)
+	local _arg0_2 = spec.kind == "to-server" or spec.kind == "to-client" or spec.kind == "ask-server"
+	assert(_arg0_2, "invalid message kind")
+	local _arg0_3 = if spec.kind == "ask-server" then spec.output ~= nil else spec.output == nil and spec.timeout == nil
+	assert(_arg0_3, "invalid message options")
+	local _condition = spec.timeout
+	if _condition == nil then
+		_condition = L.DEFAULT_ASK_TIMEOUT_SECONDS
+	end
+	local timeout = _condition
+	local _arg0_4 = timeout > 0 and timeout <= L.MAX_ASK_TIMEOUT_SECONDS
+	assert(_arg0_4, "invalid ask timeout")
+	local tally = {
+		nodes = 0,
+	}
+	local definition = table.freeze(setmetatable({
+		kind = spec.kind,
+		name = spec.name,
+		input = compile(spec.input, tally),
+		output = if spec.output == nil then nil else compile(spec.output, tally),
+		timeout = timeout,
+	}, {
+		__index = function(_, key)
+			local _result
+			if key == "index" then
+				local _indices = indices
+				local _name_1 = spec.name
+				_result = _indices[_name_1]
+			else
+				_result = nil
+			end
+			return _result
+		end,
+	}))
+	local _name_1 = spec.name
+	definitions[_name_1] = definition
+	tokens[definition] = true
+	return definition
+end
+local function setNames(ordered)
+	names = ordered
+	indices = {}
+	for i = 0, #names - 1 do
+		local _indices = indices
+		local _arg0 = names[i + 1]
+		local _i = i
+		_indices[_arg0] = _i
+	end
+end
+local function seal()
+	local _arg0 = not sealed
+	assert(_arg0, "catalog already sealed")
+	-- ▼ ReadonlyMap.size ▼
+	local _size = 0
+	for _ in definitions do
+		_size += 1
+	end
+	-- ▲ ReadonlyMap.size ▲
+	local _arg0_1 = _size <= L.MAX_MESSAGES
+	assert(_arg0_1, "too many messages")
+	local ordered = {}
+	for name in definitions do
+		table.insert(ordered, name)
+	end
+	table.sort(ordered)
+	setNames(ordered)
+	sealed = true
+	return table.concat(names, "\n")
+end
+local function adopt(catalog)
+	local _condition = not sealed
+	if _condition then
+		local _catalog = catalog
+		_condition = type(_catalog) == "string"
+		if _condition then
+			_condition = #catalog < L.MAX_MESSAGES * (L.MESSAGE_NAME_MAX_BYTES + 1)
+		end
+	end
+	assert(_condition, "invalid catalog")
+	local ordered = if catalog == "" then {} else string.split(catalog, "\n")
+	local _arg0 = #ordered <= L.MAX_MESSAGES
+	assert(_arg0, "too many messages")
+	for i = 0, #ordered - 1 do
+		validName(ordered[i + 1])
+		local _arg0_1 = i == 0 or ordered[i] < ordered[i + 1]
+		assert(_arg0_1, "catalog not strictly ascending")
+	end
+	setNames(ordered)
+end
+local function definitionAt(index)
+	if index < 0 or index % 1 ~= 0 or index >= #names then
+		return nil
+	end
+	local _arg0 = names[index + 1]
+	return definitions[_arg0]
+end
+local function definitionOf(token)
+	local _token = token
+	return if tokens[_token] ~= nil then token else nil
+end
+local function discardIndices()
+	sealed = false
+	setNames({})
+end
+local function unpublished()
+	local result = {}
+	for _, definition in definitions do
+		if definition.index == nil then
+			table.insert(result, definition)
+		end
+	end
+	return result
+end
+local function catalogSize()
+	return #names
+end
+return {
+	define = define,
+	defineFramework = defineFramework,
+	seal = seal,
+	adopt = adopt,
+	definitionAt = definitionAt,
+	definitionOf = definitionOf,
+	discardIndices = discardIndices,
+	unpublished = unpublished,
+	catalogSize = catalogSize,
+}

package/out/internal/network/claims.d.ts

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

package/out/internal/network/claims.luau

@@ -0,0 +1,154 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local ClientReady = TS.import(script, script.Parent.Parent.Parent, "network").ClientReady
+local readClaim = TS.import(script, script.Parent.Parent, "construction-claim").readClaim
+local definitionOf = TS.import(script, script.Parent, "catalog").definitionOf
+--* @internal 
+--* @internal 
+local session
+local frozen = false
+local receivers = {}
+local ready = {}
+local live = {}
+local function retire(claim)
+	local _claim = claim
+	-- ▼ Set.delete ▼
+	local _valueExisted = live[_claim] ~= nil
+	live[_claim] = nil
+	-- ▲ Set.delete ▲
+	if not _valueExisted then
+		return nil
+	end
+	if claim.target == ClientReady then
+		local _claim_1 = claim
+		local _arg0 = (table.find(ready, _claim_1) or 0) - 1
+		table.remove(ready, _arg0 + 1)
+	else
+		local _target = claim.target
+		receivers[_target] = nil
+	end
+	local _result = session
+	if _result ~= nil then
+		_result.retired(claim)
+	end
+end
+--[[
+	*
+	 * @internal
+	 * Re-checks what the transformer checked, because untransformed or cast code skips it. A violation throws from the
+	 * constructor and fails boot.
+	 
+]]
+local function claim(owner, field, target, callback)
+	local state = readClaim()
+	if state == nil or state.object ~= owner then
+		error("receive() must initialize a readonly field of the Subsystem being constructed")
+	end
+	local record = state.record
+	local label = `{record.id}.{field}`
+	if record.kind ~= 0 then
+		error(`{label}: receive() must initialize a readonly field of a Subsystem; behaviours do not receive`)
+	end
+	if frozen then
+		error(`{label}: receive() after the network commit`)
+	end
+	local _result = session
+	if _result ~= nil then
+		_result = _result.side
+	end
+	local _condition = _result
+	if _condition == nil then
+		_condition = error(`{label}: receive() before the network session opened`)
+	end
+	local side = _condition
+	local _callback = callback
+	if not (type(_callback) == "function") then
+		error(`{label}: receive() needs a callback`)
+	end
+	if target == ClientReady then
+		if side ~= "server" then
+			error(`{label}: ClientReady is received in a server Subsystem.`)
+		end
+		for _, other in ready do
+			if other.owner == state then
+				error(`{label}: {other.label} already receives ClientReady; a Subsystem holds one`)
+			end
+		end
+	else
+		local definition = definitionOf(target) or error(`{label}: receive() needs a message declared with toServer, toClient or askServer`)
+		local serverSide = definition.kind ~= "to-client"
+		if serverSide ~= (side == "server") then
+			error(if serverSide then `{label}: {definition.name} is client-to-server; receive it in a server Subsystem.` else `{label}: {definition.name} is server-to-client; receive it in a client Subsystem.`)
+		end
+		local other = receivers[definition]
+		if other ~= nil then
+			error(`{definition.name} has two receivers: {other.label} and {label}`)
+		end
+	end
+	local entry = {
+		owner = state,
+		label = label,
+		target = target,
+		callback = callback,
+	}
+	if target == ClientReady then
+		table.insert(ready, entry)
+	else
+		local _target = target
+		receivers[_target] = entry
+	end
+	live[entry] = true
+	if state.subscriptions == nil then
+		state.subscriptions = {}
+	end
+	local _exp = state.subscriptions
+	table.insert(_exp, function()
+		return retire(entry)
+	end)
+	return table.freeze({})
+end
+--* @internal 
+local function isLive(claim)
+	local _claim = claim
+	return live[_claim] ~= nil
+end
+--* @internal 
+local function receiverOf(definition)
+	local _definition = definition
+	return receivers[_definition]
+end
+--* @internal 
+local function readyClaims()
+	local _array = {}
+	local _length = #_array
+	table.move(ready, 1, #ready, _length + 1, _array)
+	return _array
+end
+--* @internal 
+local function openClaims(value)
+	session = value
+end
+--* @internal 
+local function freezeClaims()
+	frozen = true
+end
+--* @internal 
+local function closeClaims(discard)
+	session = nil
+	if not discard then
+		return nil
+	end
+	frozen = false
+	table.clear(receivers)
+	table.clear(ready)
+	table.clear(live)
+end
+return {
+	claim = claim,
+	isLive = isLive,
+	receiverOf = receiverOf,
+	readyClaims = readyClaims,
+	openClaims = openClaims,
+	freezeClaims = freezeClaims,
+	closeClaims = closeClaims,
+}

package/out/internal/network/client-session.d.ts

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