@trioforge/crucible 0.0.0-stage → 0.2.0

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

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

package/out/internal/network/envelope.luau

@@ -0,0 +1,247 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _codec = TS.import(script, script.Parent, "codec")
+local Reader = _codec.Reader
+local Writer = _codec.Writer
+local L = TS.import(script, script.Parent, "limits")
+--* @internal 
+--* @internal 
+--* @internal 
+--* @internal 
+--* @internal 
+local EMPTY = table.freeze({})
+local function varuintSize(value)
+	local size = 1
+	while value >= 128 do
+		value = math.floor(value / 128)
+		size += 1
+	end
+	return size
+end
+local function parse(packet)
+	local reader = Reader.new(packet, 0, EMPTY, 0)
+	local opcode = reader:u8()
+	if opcode == 0 then
+		local index = reader:varuint()
+		local slots = reader:varuint()
+		return {
+			opcode = opcode,
+			index = index,
+			slots = slots,
+			payloadAt = 1 + varuintSize(index) + varuintSize(slots),
+		}
+	end
+	if opcode == 1 or opcode == 2 then
+		local index = reader:varuint()
+		local nonce = reader:varuint()
+		local slots = reader:varuint()
+		local _arg0 = nonce > 0
+		assert(_arg0, "nonce 0")
+		local payloadAt = 1 + varuintSize(index) + varuintSize(nonce) + varuintSize(slots)
+		return if opcode == 1 then {
+			opcode = opcode,
+			index = index,
+			nonce = nonce,
+			slots = slots,
+			payloadAt = payloadAt,
+		} else {
+			opcode = opcode,
+			index = index,
+			nonce = nonce,
+			slots = slots,
+			payloadAt = payloadAt,
+		}
+	end
+	local header
+	if opcode == 3 then
+		local index = reader:varuint()
+		local nonce = reader:varuint()
+		local _arg0 = nonce > 0
+		assert(_arg0, "nonce 0")
+		header = {
+			opcode = opcode,
+			index = index,
+			nonce = nonce,
+			reason = reader:u8(),
+		}
+	elseif opcode == 4 then
+		header = {
+			opcode = opcode,
+		}
+	elseif opcode == 5 then
+		header = {
+			opcode = opcode,
+			reason = reader:u8(),
+		}
+	else
+		error("unknown opcode")
+	end
+	local _arg0 = reader:finished()
+	assert(_arg0, "trailing bytes")
+	return header
+end
+--[[
+	*
+	 * @internal
+	 * The highest non-nil argument position. roblox-ts lowers `select("#", ...args)` through `unpack`, which stops at a
+	 * nil hole, so this walks the keys instead. A trailing nil argument carries nothing and stays invisible to it.
+	 
+]]
+local function argumentCount(args)
+	local count = 0
+	for key in pairs(args) do
+		if type(key) == "number" and key > count then
+			count = key
+		end
+	end
+	return count
+end
+--* @internal 
+local function readHeader(argumentCount, packet, sidecar)
+	local _condition = argumentCount ~= 2
+	if not _condition then
+		local _packet = packet
+		_condition = not (type(_packet) == "buffer")
+		if not _condition then
+			local _sidecar = sidecar
+			_condition = not (type(_sidecar) == "table")
+		end
+	end
+	if _condition then
+		return nil
+	end
+	if getmetatable(sidecar) ~= nil then
+		return nil
+	end
+	local ok, header = pcall(parse, packet)
+	if not ok then
+		return nil
+	end
+	if header.opcode ~= 0 and header.opcode ~= 1 and header.opcode ~= 2 then
+		if (next(sidecar)) ~= nil then
+			return nil
+		end
+	end
+	return header
+end
+local function headerBytes(opcode, fields, reason)
+	local writer = Writer.new()
+	writer:u8(opcode)
+	for _, field in fields do
+		writer:varuint(field)
+	end
+	if reason ~= nil then
+		writer:u8(reason)
+	end
+	return (writer:finish(buffer.create(0)))
+end
+--* @internal 
+local function controlPacket(opcode, fields, reason)
+	local bytes = headerBytes(opcode, fields, reason)
+	return table.freeze({
+		bytes = bytes,
+		sidecar = EMPTY,
+		charge = buffer.len(bytes),
+	})
+end
+--* An assert's message carries the asserting chunk and line, which say nothing about the payload. 
+local function plain(err)
+	return (string.gsub(tostring(err), "^[^\n]-:%d+: ", ""))
+end
+local function describe(name, path, err)
+	local _err = err
+	local _condition = type(_err) == "table"
+	if _condition then
+		_condition = err.codecFailure == true
+	end
+	if _condition then
+		local failure = err
+		return `{name} {failure.path}: {plain(failure.reason)}`
+	end
+	return `{name} {path}: {plain(err)}`
+end
+--* @internal 
+--* @internal 
+local function encodeBody(name, codec, path, value)
+	local writer = Writer.new()
+	local ok, err = pcall(function()
+		return codec.encode(writer, value, path)
+	end)
+	if not ok then
+		error(describe(name, path, err), 0)
+	end
+	return {
+		name = name,
+		path = path,
+		writer = writer,
+	}
+end
+--* @internal 
+local function frame(body, opcode, fields)
+	local slots = #body.writer.slots
+	local bytes = buffer.create(0)
+	local sidecar = EMPTY
+	local ok, err = pcall(function()
+		local _writer = body.writer
+		local _exp = opcode
+		local _array = {}
+		local _length = #_array
+		local _fieldsLength = #fields
+		table.move(fields, 1, _fieldsLength, _length + 1, _array)
+		_length += _fieldsLength
+		_array[_length + 1] = slots
+		bytes, sidecar = _writer:finish(headerBytes(_exp, _array))
+	end)
+	if not ok then
+		error(describe(body.name, body.path, err), 0)
+	end
+	return table.freeze({
+		bytes = bytes,
+		sidecar = sidecar,
+		charge = buffer.len(bytes) + L.QUEUED_SLOT_CHARGE_BYTES * slots,
+	})
+end
+--* @internal 
+local function openBody(packet, sidecar, header)
+	return Reader.new(packet, header.payloadAt, sidecar, header.slots)
+end
+--* @internal 
+local function decodeBody(codec, path, reader)
+	local value = codec.decode(reader, path)
+	local _arg0 = reader:finished()
+	assert(_arg0, "trailing bytes or unconsumed slots")
+	return value
+end
+--* @internal 
+local function missingInstance(err)
+	local _err = err
+	local _condition = type(_err) == "table"
+	if _condition then
+		_condition = err.missing == true
+	end
+	return _condition
+end
+--* @internal 
+local function failureReason(err)
+	local _err = err
+	local _condition = type(_err) == "table"
+	if _condition then
+		_condition = err.codecFailure == true
+	end
+	if _condition then
+		local failure = err
+		return `{failure.path}: {plain(failure.reason)}`
+	end
+	return plain(err)
+end
+return {
+	argumentCount = argumentCount,
+	readHeader = readHeader,
+	controlPacket = controlPacket,
+	encodeBody = encodeBody,
+	frame = frame,
+	openBody = openBody,
+	decodeBody = decodeBody,
+	missingInstance = missingInstance,
+	failureReason = failureReason,
+}

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

@@ -0,0 +1,26 @@
+export declare const PROTOCOL_VERSION = 1;
+export declare const REMOTE_NAME = "CrucibleNetwork";
+export declare const PROTOCOL_ATTRIBUTE = "Protocol";
+export declare const CATALOG_ATTRIBUTE = "Catalog";
+export declare const KICK_MESSAGE = "Connection problem, please rejoin.";
+export declare const MESSAGE_NAME_MAX_BYTES = 64;
+export declare const MAX_MESSAGES = 1024;
+export declare const CLIENT_DISCOVERY_TIMEOUT_SECONDS = 30;
+export declare const MAX_QUEUED_PACKETS = 256;
+export declare const MAX_QUEUED_BYTES = 1048576;
+export declare const QUEUED_SLOT_CHARGE_BYTES = 64;
+export declare const MAX_PACKET_BYTES = 262144;
+export declare const MAX_INSTANCE_SLOTS = 256;
+export declare const MAX_DEPTH = 32;
+export declare const MAX_VALUE_VISITS = 65536;
+export declare const MAX_COLLECTION_ENTRIES = 16384;
+export declare const MAX_STRING_BYTES = 65536;
+export declare const VARUINT_MAX_BYTES = 5;
+export declare const MAX_UNION_BRANCHES = 256;
+export declare const MAX_SCHEMA_NODES = 4096;
+export declare const CFRAME_TOLERANCE = 0.001;
+export declare const MAX_ACTIVE_HANDLERS = 64;
+export declare const MAX_PENDING_ASKS = 64;
+export declare const HANDLER_LIFETIME_SECONDS = 30;
+export declare const DEFAULT_ASK_TIMEOUT_SECONDS = 10;
+export declare const MAX_ASK_TIMEOUT_SECONDS = 120;

package/out/internal/network/limits.luau

@@ -0,0 +1,55 @@
+-- Compiled with roblox-ts v3.0.0
+local PROTOCOL_VERSION = 1
+local REMOTE_NAME = "CrucibleNetwork"
+local PROTOCOL_ATTRIBUTE = "Protocol"
+local CATALOG_ATTRIBUTE = "Catalog"
+local KICK_MESSAGE = "Connection problem, please rejoin."
+local MESSAGE_NAME_MAX_BYTES = 64
+local MAX_MESSAGES = 1024
+local CLIENT_DISCOVERY_TIMEOUT_SECONDS = 30
+local MAX_QUEUED_PACKETS = 256
+local MAX_QUEUED_BYTES = 1_048_576
+local QUEUED_SLOT_CHARGE_BYTES = 64
+local MAX_PACKET_BYTES = 262_144
+local MAX_INSTANCE_SLOTS = 256
+local MAX_DEPTH = 32
+local MAX_VALUE_VISITS = 65_536
+local MAX_COLLECTION_ENTRIES = 16_384
+local MAX_STRING_BYTES = 65_536
+local VARUINT_MAX_BYTES = 5
+local MAX_UNION_BRANCHES = 256
+local MAX_SCHEMA_NODES = 4096
+local CFRAME_TOLERANCE = 0.001
+local MAX_ACTIVE_HANDLERS = 64
+local MAX_PENDING_ASKS = 64
+local HANDLER_LIFETIME_SECONDS = 30
+local DEFAULT_ASK_TIMEOUT_SECONDS = 10
+local MAX_ASK_TIMEOUT_SECONDS = 120
+return {
+	PROTOCOL_VERSION = PROTOCOL_VERSION,
+	REMOTE_NAME = REMOTE_NAME,
+	PROTOCOL_ATTRIBUTE = PROTOCOL_ATTRIBUTE,
+	CATALOG_ATTRIBUTE = CATALOG_ATTRIBUTE,
+	KICK_MESSAGE = KICK_MESSAGE,
+	MESSAGE_NAME_MAX_BYTES = MESSAGE_NAME_MAX_BYTES,
+	MAX_MESSAGES = MAX_MESSAGES,
+	CLIENT_DISCOVERY_TIMEOUT_SECONDS = CLIENT_DISCOVERY_TIMEOUT_SECONDS,
+	MAX_QUEUED_PACKETS = MAX_QUEUED_PACKETS,
+	MAX_QUEUED_BYTES = MAX_QUEUED_BYTES,
+	QUEUED_SLOT_CHARGE_BYTES = QUEUED_SLOT_CHARGE_BYTES,
+	MAX_PACKET_BYTES = MAX_PACKET_BYTES,
+	MAX_INSTANCE_SLOTS = MAX_INSTANCE_SLOTS,
+	MAX_DEPTH = MAX_DEPTH,
+	MAX_VALUE_VISITS = MAX_VALUE_VISITS,
+	MAX_COLLECTION_ENTRIES = MAX_COLLECTION_ENTRIES,
+	MAX_STRING_BYTES = MAX_STRING_BYTES,
+	VARUINT_MAX_BYTES = VARUINT_MAX_BYTES,
+	MAX_UNION_BRANCHES = MAX_UNION_BRANCHES,
+	MAX_SCHEMA_NODES = MAX_SCHEMA_NODES,
+	CFRAME_TOLERANCE = CFRAME_TOLERANCE,
+	MAX_ACTIVE_HANDLERS = MAX_ACTIVE_HANDLERS,
+	MAX_PENDING_ASKS = MAX_PENDING_ASKS,
+	HANDLER_LIFETIME_SECONDS = HANDLER_LIFETIME_SECONDS,
+	DEFAULT_ASK_TIMEOUT_SECONDS = DEFAULT_ASK_TIMEOUT_SECONDS,
+	MAX_ASK_TIMEOUT_SECONDS = MAX_ASK_TIMEOUT_SECONDS,
+}

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

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

package/out/internal/network/port.luau

@@ -0,0 +1,19 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local robloxNetworkPort = TS.import(script, script.Parent, "roblox-network-port").robloxNetworkPort
+--* @internal 
+--* @internal 
+--* @internal 
+local installed
+--* @internal 
+local function installNetworkPort(port)
+	installed = port
+end
+--* @internal 
+local function networkPort()
+	return installed or robloxNetworkPort()
+end
+return {
+	installNetworkPort = installNetworkPort,
+	networkPort = networkPort,
+}

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

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

package/out/internal/network/roblox-network-port.luau

@@ -0,0 +1,105 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _limits = TS.import(script, script.Parent, "limits")
+local CATALOG_ATTRIBUTE = _limits.CATALOG_ATTRIBUTE
+local PROTOCOL_ATTRIBUTE = _limits.PROTOCOL_ATTRIBUTE
+local REMOTE_NAME = _limits.REMOTE_NAME
+--* @internal 
+local function robloxNetworkPort()
+	local players = game:GetService("Players")
+	local storage = game:GetService("ReplicatedStorage")
+	local remote
+	local connection
+	local function disconnect()
+		local _result = connection
+		if _result ~= nil then
+			_result:Disconnect()
+		end
+		connection = nil
+	end
+	return {
+		create = function(receive)
+			local created = Instance.new("RemoteEvent")
+			created.Name = REMOTE_NAME
+			connection = created.OnServerEvent:Connect(receive)
+			remote = created
+		end,
+		publish = function(protocol, catalog)
+			local target = remote or error("Crucible network remote was not created")
+			target:SetAttribute(PROTOCOL_ATTRIBUTE, protocol)
+			target:SetAttribute(CATALOG_ATTRIBUTE, catalog)
+			target.Parent = storage
+		end,
+		fireClient = function(player, packet, sidecar)
+			local _result = remote
+			if _result ~= nil then
+				_result = _result:FireClient(player, packet, sidecar)
+			end
+			return _result
+		end,
+		players = function()
+			return players:GetPlayers()
+		end,
+		onPlayerAdded = function(listener)
+			local c = players.PlayerAdded:Connect(listener)
+			return function()
+				return c:Disconnect()
+			end
+		end,
+		onPlayerRemoving = function(listener)
+			local c = players.PlayerRemoving:Connect(listener)
+			return function()
+				return c:Disconnect()
+			end
+		end,
+		kick = function(player, message)
+			return player:Kick(message)
+		end,
+		destroy = function()
+			disconnect()
+			local _result = remote
+			if _result ~= nil then
+				_result:Destroy()
+			end
+			remote = nil
+		end,
+		discover = function(timeout, receive)
+			local found = storage:WaitForChild(REMOTE_NAME, timeout)
+			if found == nil then
+				return nil
+			end
+			if found:IsA("RemoteEvent") then
+				remote = found
+				connection = found.OnClientEvent:Connect(receive)
+			end
+			return {
+				className = found.ClassName,
+				protocol = found:GetAttribute(PROTOCOL_ATTRIBUTE),
+				catalog = found:GetAttribute(CATALOG_ATTRIBUTE),
+			}
+		end,
+		disconnect = disconnect,
+		fireServer = function(packet, sidecar)
+			local _result = remote
+			if _result ~= nil then
+				_result = _result:FireServer(packet, sidecar)
+			end
+			return _result
+		end,
+		delay = function(seconds, callback)
+			local thread = task.delay(seconds, callback)
+			return function()
+				if coroutine.status(thread) == "suspended" then
+					task.cancel(thread)
+				end
+			end
+		end,
+		resume = function(thread, ...)
+			local args = { ... }
+			task.spawn(thread, unpack(args))
+		end,
+	}
+end
+return {
+	robloxNetworkPort = robloxNetworkPort,
+}

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

@@ -0,0 +1,72 @@
+export type Literal = string | number | boolean;
+export type LeafKind = "nil" | "bool" | "f64" | "f32" | "u8" | "u16" | "u32" | "string" | "vector3" | "color3" | "cframe" | "dynamic";
+export interface LeafNode<K extends LeafKind = LeafKind> {
+    readonly kind: K;
+}
+export interface LiteralNode<V extends Literal = Literal> {
+    readonly kind: "literal";
+    readonly value: V;
+}
+export interface InstanceNode {
+    readonly kind: "instance";
+    readonly classes: readonly (keyof Instances)[];
+}
+export interface ObjectNode {
+    readonly kind: "object";
+    readonly fields: readonly (readonly [name: string, value: Node])[];
+}
+export interface ArrayNode {
+    readonly kind: "array";
+    readonly element: Node;
+}
+export interface TupleNode {
+    readonly kind: "tuple";
+    readonly elements: readonly Node[];
+}
+export interface MapNode {
+    readonly kind: "map";
+    readonly key: MapKey;
+    readonly value: Node;
+}
+export interface VariantNode {
+    readonly kind: "variant";
+    readonly key: string;
+    readonly value: Literal;
+    readonly body: ObjectNode;
+}
+export type Branch = Node | VariantNode;
+export interface UnionNode<B extends Branch = Branch> {
+    readonly kind: "union";
+    readonly branches: readonly B[];
+}
+export type Node = LeafNode | LiteralNode | InstanceNode | ObjectNode | ArrayNode | TupleNode | MapNode | UnionNode;
+export type MapKey = LeafNode<"string" | "u8" | "u16" | "u32"> | UnionNode<LiteralNode<string | number>>;
+export interface NodeBuilders {
+    readonly nil: LeafNode<"nil">;
+    readonly bool: LeafNode<"bool">;
+    readonly f64: LeafNode<"f64">;
+    readonly f32: LeafNode<"f32">;
+    readonly u8: LeafNode<"u8">;
+    readonly u16: LeafNode<"u16">;
+    readonly u32: LeafNode<"u32">;
+    readonly string: LeafNode<"string">;
+    readonly vector3: LeafNode<"vector3">;
+    readonly color3: LeafNode<"color3">;
+    readonly cframe: LeafNode<"cframe">;
+    readonly dynamic: LeafNode<"dynamic">;
+    readonly literal: <V extends Literal>(value: V) => LiteralNode<V>;
+    readonly instance: (classes: readonly (keyof Instances)[]) => InstanceNode;
+    readonly object: (fields: readonly (readonly [name: string, value: Node])[]) => ObjectNode;
+    readonly array: (element: Node) => ArrayNode;
+    readonly tuple: (elements: readonly Node[]) => TupleNode;
+    readonly map: (key: MapKey, value: Node) => MapNode;
+    readonly union: <B extends Branch>(branches: readonly B[]) => UnionNode<B>;
+    readonly variant: (key: string, value: Literal, body: ObjectNode) => VariantNode;
+}
+export declare function assertDescriptor(node: unknown): asserts node is Branch;
+export declare function admitsNil(node: Branch): boolean;
+export declare function runtimeKind(node: Branch): string;
+export declare function literalLess(a: Literal, b: Literal): boolean;
+/** Rule 63 order and rule 65 ambiguity, asserted by the builder and again by `compile`. */
+export declare function checkUnion(branches: readonly Branch[]): void;
+export declare const n: NodeBuilders;