@trioforge/crucible 0.1.0 → 0.3.0

package/out/internal/network/schema.luau

@@ -0,0 +1,386 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local MAX_UNION_BRANCHES = TS.import(script, script.Parent, "limits").MAX_UNION_BRANCHES
+-- Descriptors arrive from Luau, where the types above do not hold, so provenance is checked at runtime.
+local descriptors = {}
+local function descriptor(node)
+	local _node = node
+	descriptors[_node] = true
+	return table.freeze(node)
+end
+local function assertDescriptor(node)
+	local _node = node
+	local _condition = type(_node) == "table"
+	if _condition then
+		local _node_1 = node
+		_condition = descriptors[_node_1] ~= nil
+	end
+	assert(_condition, "expected a descriptor constructor result")
+end
+local function numericName(name)
+	return tostring(tonumber(name)) == name
+end
+local function literal(value)
+	local _value = value
+	local _condition = type(_value) == "string"
+	if not _condition then
+		local _value_1 = value
+		_condition = type(_value_1) == "boolean"
+		if not _condition then
+			local _value_2 = value
+			local _condition_1 = type(_value_2) == "number"
+			if _condition_1 then
+				_condition_1 = value == value and math.abs(value) < math.huge
+			end
+			_condition = _condition_1
+		end
+	end
+	assert(_condition, "invalid literal")
+	return descriptor({
+		kind = "literal",
+		value = value,
+	})
+end
+local function admitsNil(node)
+	local _condition = node.kind == "nil" or node.kind == "dynamic"
+	if not _condition then
+		local _condition_1 = node.kind == "union"
+		if _condition_1 then
+			local _exp = node.branches
+			-- ▼ ReadonlyArray.some ▼
+			local _result = false
+			for _k, _v in _exp do
+				if admitsNil(_v, _k - 1, _exp) then
+					_result = true
+					break
+				end
+			end
+			-- ▲ ReadonlyArray.some ▲
+			_condition_1 = _result
+		end
+		_condition = _condition_1
+	end
+	return _condition
+end
+local function runtimeKind(node)
+	local _exp = node.kind
+	repeat
+		local _fallthrough = false
+		if _exp == "bool" then
+			return "boolean"
+		end
+		if _exp == "f64" then
+			_fallthrough = true
+		end
+		if _fallthrough or _exp == "f32" then
+			_fallthrough = true
+		end
+		if _fallthrough or _exp == "u8" then
+			_fallthrough = true
+		end
+		if _fallthrough or _exp == "u16" then
+			_fallthrough = true
+		end
+		if _fallthrough or _exp == "u32" then
+			return "number"
+		end
+		if _exp == "string" then
+			return "string"
+		end
+		if _exp == "vector3" then
+			return "Vector3"
+		end
+		if _exp == "color3" then
+			return "Color3"
+		end
+		if _exp == "cframe" then
+			return "CFrame"
+		end
+		if _exp == "instance" then
+			return "Instance"
+		end
+		return "table"
+	until true
+end
+local function literalLess(a, b)
+	local ranks = {
+		boolean = 0,
+		number = 1,
+		string = 2,
+	}
+	local _a = a
+	local ak = typeof(_a)
+	local _b = b
+	local bk = typeof(_b)
+	if ak ~= bk then
+		return ranks[ak] < ranks[bk]
+	end
+	local _a_1 = a
+	local _condition = type(_a_1) == "boolean"
+	if _condition then
+		local _b_1 = b
+		_condition = type(_b_1) == "boolean"
+	end
+	if _condition then
+		return not a and b
+	end
+	local _a_2 = a
+	local _condition_1 = type(_a_2) == "number"
+	if _condition_1 then
+		local _b_1 = b
+		_condition_1 = type(_b_1) == "number"
+	end
+	if _condition_1 then
+		return a < b
+	end
+	return a < b
+end
+--* Rule 63 order and rule 65 ambiguity, asserted by the builder and again by `compile`. 
+local function checkUnion(branches)
+	local _arg0 = #branches > 0 and #branches <= MAX_UNION_BRANCHES
+	assert(_arg0, "invalid union size")
+	local kinds = {}
+	local phase = 0
+	local previousLiteral
+	local previousKind
+	local discriminant
+	for i = 0, #branches - 1 do
+		local branch = branches[i + 1]
+		assertDescriptor(branch)
+		if branch.kind == "nil" then
+			local _arg0_1 = i == 0
+			assert(_arg0_1, "absent must be first")
+		elseif branch.kind == "literal" then
+			local _arg0_1 = phase <= 1 and (previousLiteral == nil or literalLess(previousLiteral, branch.value))
+			assert(_arg0_1, "literal order")
+			phase = 1
+			previousLiteral = branch.value
+		elseif branch.kind == "variant" then
+			local _arg0_1 = not (kinds.table ~= nil) and (discriminant == nil or discriminant == branch.key)
+			assert(_arg0_1, "ambiguous variants")
+			if phase < 3 then
+				previousLiteral = nil
+			end
+			local _arg0_2 = previousLiteral == nil or literalLess(previousLiteral, branch.value)
+			assert(_arg0_2, "variant order")
+			phase = 3
+			previousLiteral = branch.value
+			discriminant = branch.key
+		else
+			local kind = runtimeKind(branch)
+			local _arg0_1 = branch.kind ~= "union" and branch.kind ~= "dynamic" and phase <= 2 and not (kinds[kind] ~= nil) and (previousKind == nil or previousKind < kind)
+			assert(_arg0_1, "ambiguous union")
+			phase = 2
+			kinds[kind] = true
+			previousKind = kind
+		end
+	end
+end
+local function node(child)
+	assertDescriptor(child)
+	local _arg0 = child.kind ~= "variant"
+	assert(_arg0, "variant outside union")
+	return child
+end
+local n = table.freeze({
+	["nil"] = descriptor({
+		kind = "nil",
+	}),
+	bool = descriptor({
+		kind = "bool",
+	}),
+	f64 = descriptor({
+		kind = "f64",
+	}),
+	f32 = descriptor({
+		kind = "f32",
+	}),
+	u8 = descriptor({
+		kind = "u8",
+	}),
+	u16 = descriptor({
+		kind = "u16",
+	}),
+	u32 = descriptor({
+		kind = "u32",
+	}),
+	string = descriptor({
+		kind = "string",
+	}),
+	vector3 = descriptor({
+		kind = "vector3",
+	}),
+	color3 = descriptor({
+		kind = "color3",
+	}),
+	cframe = descriptor({
+		kind = "cframe",
+	}),
+	dynamic = descriptor({
+		kind = "dynamic",
+	}),
+	literal = literal,
+	instance = function(classes)
+		local _classes = classes
+		local _condition = type(_classes) == "table"
+		if _condition then
+			_condition = #classes > 0
+		end
+		assert(_condition, "empty Instance classes")
+		local _array = {}
+		local _length = #_array
+		table.move(classes, 1, #classes, _length + 1, _array)
+		local copy = _array
+		for i = 0, #copy - 1 do
+			local _arg0 = copy[i + 1]
+			local _condition_1 = type(_arg0) == "string"
+			if _condition_1 then
+				_condition_1 = (i == 0 or copy[i] < copy[i + 1])
+			end
+			assert(_condition_1, "Instance classes must be sorted and unique")
+		end
+		return descriptor({
+			kind = "instance",
+			classes = table.freeze(copy),
+		})
+	end,
+	object = function(fields)
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#fields)
+		local _callback = function(_param)
+			local name = _param[1]
+			local child = _param[2]
+			local _arg0 = type(name) == "string" and not numericName(name)
+			assert(_arg0, "numeric property name")
+			return table.freeze({ name, node(child) })
+		end
+		for _k, _v in fields do
+			_newValue[_k] = _callback(_v, _k - 1, fields)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		local copy = _newValue
+		for i = 1, #copy - 1 do
+			local _arg0 = copy[i][1] < copy[i + 1][1]
+			assert(_arg0, "fields must be sorted and unique")
+		end
+		return descriptor({
+			kind = "object",
+			fields = table.freeze(copy),
+		})
+	end,
+	array = function(element)
+		local _arg0 = not admitsNil(node(element))
+		assert(_arg0, "nil array element")
+		return descriptor({
+			kind = "array",
+			element = element,
+		})
+	end,
+	tuple = function(elements)
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#elements)
+		local _callback = function(element)
+			local _arg0 = not admitsNil(node(element))
+			assert(_arg0, "nil tuple element")
+			return element
+		end
+		for _k, _v in elements do
+			_newValue[_k] = _callback(_v, _k - 1, elements)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		local copy = _newValue
+		return descriptor({
+			kind = "tuple",
+			elements = table.freeze(copy),
+		})
+	end,
+	map = function(key, value)
+		node(key)
+		local _condition = key.kind == "string" or key.kind == "u8" or key.kind == "u16" or key.kind == "u32"
+		if not _condition then
+			local _condition_1 = key.kind == "union"
+			if _condition_1 then
+				local _exp = key.branches
+				-- ▼ ReadonlyArray.every ▼
+				local _result = true
+				local _callback = function(b)
+					local _condition_2 = b.kind == "literal"
+					if _condition_2 then
+						local _value = b.value
+						_condition_2 = not (type(_value) == "boolean")
+					end
+					return _condition_2
+				end
+				for _k, _v in _exp do
+					if not _callback(_v, _k - 1, _exp) then
+						_result = false
+						break
+					end
+				end
+				-- ▲ ReadonlyArray.every ▲
+				_condition_1 = _result
+			end
+			_condition = _condition_1
+		end
+		assert(_condition, "invalid map key")
+		local _arg0 = not admitsNil(node(value))
+		assert(_arg0, "nil map value")
+		return descriptor({
+			kind = "map",
+			key = key,
+			value = value,
+		})
+	end,
+	union = function(branches)
+		checkUnion(branches)
+		local _object = {
+			kind = "union",
+		}
+		local _left = "branches"
+		local _array = {}
+		local _length = #_array
+		table.move(branches, 1, #branches, _length + 1, _array)
+		_object[_left] = table.freeze(_array)
+		return descriptor(_object)
+	end,
+	variant = function(key, value, body)
+		literal(value)
+		local _key = key
+		local _condition = type(_key) == "string"
+		if _condition then
+			_condition = not numericName(key) and node(body).kind == "object"
+			if _condition then
+				local _exp = body.fields
+				-- ▼ ReadonlyArray.every ▼
+				local _result = true
+				local _callback = function(_param)
+					local name = _param[1]
+					return name ~= key
+				end
+				for _k, _v in _exp do
+					if not _callback(_v, _k - 1, _exp) then
+						_result = false
+						break
+					end
+				end
+				-- ▲ ReadonlyArray.every ▲
+				_condition = _result
+			end
+		end
+		assert(_condition, "invalid variant")
+		return descriptor({
+			kind = "variant",
+			key = key,
+			value = value,
+			body = body,
+		})
+	end,
+})
+return {
+	assertDescriptor = assertDescriptor,
+	admitsNil = admitsNil,
+	runtimeKind = runtimeKind,
+	literalLess = literalLess,
+	checkUnion = checkUnion,
+	n = n,
+}

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

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