@trioforge/crucible 0.1.0 → 0.2.0

package/out/internal/network/server-session.luau

@@ -0,0 +1,393 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local runtimeDiagnostic = TS.import(script, script.Parent.Parent, "diagnostics").runtimeDiagnostic
+local _catalog = TS.import(script, script.Parent, "catalog")
+local definitionAt = _catalog.definitionAt
+local definitionOf = _catalog.definitionOf
+local discardIndices = _catalog.discardIndices
+local seal = _catalog.seal
+local _claims = TS.import(script, script.Parent, "claims")
+local closeClaims = _claims.closeClaims
+local freezeClaims = _claims.freezeClaims
+local isLive = _claims.isLive
+local openClaims = _claims.openClaims
+local readyClaims = _claims.readyClaims
+local receiverOf = _claims.receiverOf
+local _envelope = TS.import(script, script.Parent, "envelope")
+local argumentCount = _envelope.argumentCount
+local controlPacket = _envelope.controlPacket
+local decodeBody = _envelope.decodeBody
+local encodeBody = _envelope.encodeBody
+local failureReason = _envelope.failureReason
+local frame = _envelope.frame
+local missingInstance = _envelope.missingInstance
+local openBody = _envelope.openBody
+local readHeader = _envelope.readHeader
+local L = TS.import(script, script.Parent, "limits")
+local _session = TS.import(script, script.Parent, "session")
+local newPeer = _session.newPeer
+local Session = _session.Session
+local FAIL_NAMES = { "overflow", "overloaded", "closing", "malformed" }
+--* @internal 
+local toClient
+local ServerSession
+do
+	local super = Session
+	ServerSession = setmetatable({}, {
+		__tostring = function()
+			return "ServerSession"
+		end,
+		__index = super,
+	})
+	ServerSession.__index = ServerSession
+	function ServerSession.new(...)
+		local self = setmetatable({}, ServerSession)
+		return self:constructor(...) or self
+	end
+	function ServerSession:constructor(...)
+		super.constructor(self, ...)
+		self.peers = {}
+		self.order = {}
+		self.connections = {}
+		self.catalog = ""
+		self.published = false
+		self.reportedNoPeer = false
+	end
+	function ServerSession:open()
+		self.stage = 1
+		openClaims({
+			side = "server",
+			retired = function(claim)
+				return self:retired(claim)
+			end,
+		})
+		self.port.create(function(player, ...)
+			local args = { ... }
+			return self:receive(player, argumentCount(args), args[1], args[2])
+		end)
+		local _connections = self.connections
+		local _arg0 = self.port.onPlayerAdded(function(player)
+			return self:add(player)
+		end)
+		table.insert(_connections, _arg0)
+		local _connections_1 = self.connections
+		local _arg0_1 = self.port.onPlayerRemoving(function(player)
+			local _peers = self.peers
+			local _player = player
+			local peer = _peers[_player]
+			if peer ~= nil then
+				self["end"](self, peer)
+			end
+		end)
+		table.insert(_connections_1, _arg0_1)
+		for _, player in self.port.players() do
+			self:add(player)
+		end
+	end
+	function ServerSession:loaded()
+		self.catalog = seal()
+		self.stage = 2
+	end
+	function ServerSession:commit()
+		freezeClaims()
+		self.port.publish(L.PROTOCOL_VERSION, self.catalog)
+		self.published = true
+		self.stage = 3
+	end
+	function ServerSession:close()
+		if self.stage == 4 then
+			return nil
+		end
+		local committed = self.stage == 3
+		self.stage = 4
+		local closing = controlPacket(5, {}, 2)
+		local _array = {}
+		local _length = #_array
+		local _array_1 = self.order
+		table.move(_array_1, 1, #_array_1, _length + 1, _array)
+		for _, peer in _array do
+			if self.published then
+				pcall(function()
+					return self:fire(peer, closing)
+				end)
+			end
+			pcall(function()
+				return self["end"](self, peer)
+			end)
+		end
+		for _, disconnect in self.connections do
+			pcall(disconnect)
+		end
+		table.clear(self.connections)
+		pcall(function()
+			return self.port.destroy()
+		end)
+		closeClaims(not committed)
+		if not committed then
+			discardIndices()
+		end
+	end
+	function ServerSession:send(player, token, value)
+		local sendable = self:sendable()
+		local definition = toClient(token, "Network.send")
+		local body = encodeBody(definition.name, definition.input, "payload", value)
+		if not sendable then
+			return false
+		end
+		local _peers = self.peers
+		local _player = player
+		local peer = _peers[_player]
+		return peer ~= nil and self:deliver(peer, frame(body, 0, { definition.index }))
+	end
+	function ServerSession:broadcast(token, value)
+		local sendable = self:sendable()
+		local definition = toClient(token, "Network.broadcast")
+		local body = encodeBody(definition.name, definition.input, "payload", value)
+		if not sendable then
+			return nil
+		end
+		local packet = frame(body, 0, { definition.index })
+		local _array = {}
+		local _length = #_array
+		local _array_1 = self.order
+		table.move(_array_1, 1, #_array_1, _length + 1, _array)
+		for _, peer in _array do
+			self:deliver(peer, packet)
+		end
+	end
+	function ServerSession:fire(peer, packet)
+		self.port.fireClient(peer.player, packet.bytes, packet.sidecar)
+	end
+	ServerSession["end"] = function(self, peer)
+		if peer.state == 2 then
+			return false
+		end
+		local player = peer.player
+		if self.peers[player] == peer then
+			self.peers[player] = nil
+		end
+		local _order = self.order
+		local _peer = peer
+		local index = (table.find(_order, _peer) or 0) - 1
+		if index ~= -1 then
+			table.remove(self.order, index + 1)
+		end
+		return super["end"](self, peer)
+	end
+	function ServerSession:fail(peer, reason)
+		if peer.state == 2 then
+			return nil
+		end
+		local player = peer.player
+		runtimeDiagnostic("error", `Crucible network peer {player.Name} failed ({FAIL_NAMES[reason + 1]}); kicking`)
+		local packet = controlPacket(5, {}, reason)
+		pcall(function()
+			return self:fire(peer, packet)
+		end)
+		self["end"](self, peer)
+		pcall(function()
+			return self.port.kick(player, L.KICK_MESSAGE)
+		end)
+	end
+	function ServerSession:add(player)
+		local _condition = self.stage == 4
+		if not _condition then
+			local _peers = self.peers
+			local _player = player
+			_condition = _peers[_player] ~= nil
+		end
+		if _condition then
+			return nil
+		end
+		local peer = newPeer(player)
+		local _peers = self.peers
+		local _player = player
+		_peers[_player] = peer
+		local _exp = self.order
+		table.insert(_exp, peer)
+	end
+	function ServerSession:retired(claim)
+		local cleanups = {}
+		for _, peer in self.order do
+			for _1, entry in peer.running do
+				local request = entry.request
+				if entry.claim ~= claim or request == nil or entry.settled then
+					continue
+				end
+				entry.settled = true
+				self:fire(peer, controlPacket(3, { request.definition.index, request.nonce }, 0))
+			end
+			for i = #peer.cleanups - 1, 0, -1 do
+				local entry = peer.cleanups[i + 1]
+				if entry.claim ~= claim then
+					continue
+				end
+				local _cleanups = peer.cleanups
+				local _i = i
+				table.remove(_cleanups, _i + 1)
+				local _arg0 = { peer, entry }
+				table.insert(cleanups, _arg0)
+			end
+		end
+		for _, _binding in cleanups do
+			local peer = _binding[1]
+			local entry = _binding[2]
+			self:deferCleanup(peer, entry)
+		end
+	end
+	function ServerSession:reject(peer, key, what, detail)
+		local _rejected = peer.rejected
+		local _key = key
+		if _rejected[_key] ~= nil then
+			return nil
+		end
+		local _rejected_1 = peer.rejected
+		local _key_1 = key
+		_rejected_1[_key_1] = true
+		local reason = if detail == nil then "" else `: {detail}`
+		runtimeDiagnostic("warning", `Crucible dropped {what} from {peer.player.Name}{reason}`)
+	end
+	function ServerSession:receive(player, count, packet, sidecar)
+		local ok, err = pcall(function()
+			return self:dispatch(player, count, packet, sidecar)
+		end)
+		if not ok then
+			runtimeDiagnostic("error", `Crucible network receive failed: {tostring(err)}`)
+		end
+	end
+	function ServerSession:dispatch(player, count, packet, sidecar)
+		local _peers = self.peers
+		local _player = player
+		local peer = _peers[_player]
+		if peer == nil then
+			if self.reportedNoPeer then
+				return nil
+			end
+			self.reportedNoPeer = true
+			runtimeDiagnostic("warning", "Crucible dropped a network packet from a player with no peer")
+			return nil
+		end
+		if self.stage ~= 3 then
+			return self:reject(peer, "envelope", "a packet before the network commit")
+		end
+		local header = readHeader(count, packet, sidecar)
+		if header == nil then
+			return self:reject(peer, "envelope", "a malformed network packet")
+		end
+		if header.opcode == 4 then
+			if peer.state ~= 0 then
+				return self:reject(peer, "envelope", "a second READY")
+			end
+			return self:ready(peer)
+		end
+		if header.opcode == 5 then
+			local _condition = FAIL_NAMES[header.reason + 1]
+			if _condition == nil then
+				_condition = `unknown reason {header.reason}`
+			end
+			local reason = _condition
+			runtimeDiagnostic("error", `Crucible network peer {player.Name} sent FAIL ({reason}); kicking`)
+			self["end"](self, peer)
+			pcall(function()
+				return self.port.kick(player, L.KICK_MESSAGE)
+			end)
+			return nil
+		end
+		if header.opcode ~= 0 and header.opcode ~= 1 then
+			return self:reject(peer, "envelope", "a server-to-client packet")
+		end
+		if peer.state ~= 1 then
+			return self:reject(peer, "envelope", "a game packet before READY")
+		end
+		local definition = definitionAt(header.index)
+		if definition == nil then
+			return self:reject(peer, "envelope", "an unknown message index")
+		end
+		local event = header.opcode == 0
+		if definition.kind ~= (if event then "to-server" else "ask-server") then
+			return self:reject(peer, definition, `{definition.name} sent as the wrong kind of packet`)
+		end
+		local opened, reader = pcall(openBody, packet, sidecar, header)
+		if not opened then
+			return self:reject(peer, definition, definition.name, failureReason(reader))
+		end
+		if header.opcode == 0 then
+			local decoded, value = pcall(decodeBody, definition.input, "payload", reader)
+			if not decoded then
+				if not missingInstance(value) then
+					self:reject(peer, definition, definition.name, failureReason(value))
+				end
+				return nil
+			end
+			local receiver = receiverOf(definition)
+			if receiver == nil then
+				return self:unreceived(definition)
+			end
+			if peer.counted >= L.MAX_ACTIVE_HANDLERS then
+				return self:fail(peer, 1)
+			end
+			return self:start(peer, receiver, { player, value })
+		end
+		local nonce = header.nonce
+		if nonce <= peer.lastRequestNonce then
+			return self:reject(peer, definition, `{definition.name} with a nonce already used`)
+		end
+		peer.lastRequestNonce = nonce
+		local refuse = function(reason)
+			return self:fire(peer, controlPacket(3, { header.index, nonce }, reason))
+		end
+		local decoded, value = pcall(decodeBody, definition.input, "request", reader)
+		if not decoded then
+			if not missingInstance(value) then
+				self:reject(peer, definition, definition.name, failureReason(value))
+			end
+			return refuse(3)
+		end
+		local receiver = receiverOf(definition)
+		if receiver == nil then
+			return refuse(0)
+		end
+		if peer.counted >= L.MAX_ACTIVE_HANDLERS then
+			return refuse(2)
+		end
+		self:start(peer, receiver, { player, value }, {
+			definition = definition,
+			nonce = nonce,
+		})
+	end
+	function ServerSession:ready(peer)
+		peer.state = 1
+		self:flush(peer)
+		local player = peer.player
+		for _, claim in readyClaims() do
+			if peer.state ~= 1 then
+				return nil
+			end
+			if not isLive(claim) then
+				continue
+			end
+			local ok, value = self:runReady(peer, claim, claim.callback, player)
+			if not ok then
+				continue
+			end
+			if type(value) == "function" then
+				self:keep(peer, {
+					claim = claim,
+					cleanup = value,
+				})
+			elseif value ~= nil then
+				self:reportCallback(peer, claim, nil, `returned a {typeof(value)}; ClientReady callbacks return nothing or a cleanup function`)
+			end
+		end
+	end
+end
+function toClient(token, call)
+	local definition = definitionOf(token)
+	if definition == nil or definition.kind ~= "to-client" then
+		error(`{call} needs a message declared with toClient`, 0)
+	end
+	return definition
+end
+return {
+	ServerSession = ServerSession,
+}

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

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

package/out/internal/network/session.luau

@@ -0,0 +1,266 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local runtimeDiagnostic = TS.import(script, script.Parent.Parent, "diagnostics").runtimeDiagnostic
+local _lifecycle = TS.import(script, script.Parent.Parent, "lifecycle")
+local defer = _lifecycle.defer
+local within = _lifecycle.within
+local _runner = TS.import(script, script.Parent.Parent, "runner")
+local disown = _runner.disown
+local own = _runner.own
+local isLive = TS.import(script, script.Parent, "claims").isLive
+local _envelope = TS.import(script, script.Parent, "envelope")
+local controlPacket = _envelope.controlPacket
+local encodeBody = _envelope.encodeBody
+local frame = _envelope.frame
+local L = TS.import(script, script.Parent, "limits")
+--* @internal 
+--* @internal 
+--* @internal 
+--* @internal 
+--* @internal 
+--* @internal 
+--* @internal 
+local function newPeer(player)
+	return {
+		player = player,
+		state = 0,
+		queue = {},
+		queuedBytes = 0,
+		running = {},
+		counted = 0,
+		lastRequestNonce = 0,
+		cleanups = {},
+		rejected = {},
+		failedClaims = {},
+	}
+end
+local function traceback(err)
+	return debug.traceback(tostring(err), 2)
+end
+local function invoke(callback, argument)
+	return callback(argument)
+end
+-- compiler-types 3.0.0-types.0 does not declare Promise.is; the RuntimeLib's TS.Promise has it.
+local function isPromise(value)
+	return (TS.Promise).is(value)
+end
+--* @internal 
+local Session
+do
+	Session = {}
+	function Session:constructor(port)
+		self.port = port
+		self.stage = 0
+		self.lateFailures = {}
+		self.noReceiver = {}
+	end
+	function Session:sendable()
+		if self.stage == 0 or self.stage == 1 then
+			error("Crucible networking is not ready; send from a constructor, a hook, or later", 0)
+		end
+		return self.stage ~= 4
+	end
+	function Session:deliver(peer, packet)
+		if peer.state == 1 then
+			self:fire(peer, packet)
+			return true
+		end
+		if peer.state == 2 then
+			return false
+		end
+		if #peer.queue >= L.MAX_QUEUED_PACKETS or packet.charge > L.MAX_QUEUED_BYTES - peer.queuedBytes then
+			self:fail(peer, 0)
+			return false
+		end
+		local _queue = peer.queue
+		local _packet = packet
+		table.insert(_queue, _packet)
+		peer.queuedBytes += packet.charge
+		return true
+	end
+	function Session:flush(peer)
+		local _array = {}
+		local _length = #_array
+		local _array_1 = peer.queue
+		table.move(_array_1, 1, #_array_1, _length + 1, _array)
+		local queue = _array
+		table.clear(peer.queue)
+		peer.queuedBytes = 0
+		for _, packet in queue do
+			self:fire(peer, packet)
+		end
+	end
+	function Session:start(peer, claim, args, request)
+		local entry = {
+			claim = claim,
+			request = request,
+			done = false,
+			counted = true,
+			settled = false,
+			reported = false,
+		}
+		local _exp = peer.running
+		table.insert(_exp, entry)
+		peer.counted += 1
+		local thread = coroutine.create(function()
+			local ok, value = xpcall(claim.callback, traceback, unpack(args))
+			disown(coroutine.running())
+			self:finish(peer, entry, ok, value)
+		end)
+		own(thread, claim.owner)
+		self.port.resume(thread)
+		if not entry.done and peer.state ~= 2 then
+			entry.lifetime = self.port.delay(L.HANDLER_LIFETIME_SECONDS, function()
+				return self:overrun(peer, entry)
+			end)
+		end
+	end
+	function Session:uncount(peer, entry)
+		if not entry.counted then
+			return nil
+		end
+		entry.counted = false
+		peer.counted -= 1
+	end
+	function Session:overrun(peer, entry)
+		entry.lifetime = nil
+		if entry.done then
+			return nil
+		end
+		self:reportCallback(peer, entry.claim, entry, `still running after {L.HANDLER_LIFETIME_SECONDS} seconds`)
+		self:uncount(peer, entry)
+	end
+	function Session:finish(peer, entry, ok, value)
+		entry.done = true
+		local _result = entry.lifetime
+		if _result ~= nil then
+			_result()
+		end
+		entry.lifetime = nil
+		local _running = peer.running
+		local _entry = entry
+		local index = (table.find(_running, _entry) or 0) - 1
+		if index ~= -1 then
+			table.remove(peer.running, index + 1)
+		end
+		self:uncount(peer, entry)
+		local failure
+		local request = entry.request
+		if not ok then
+			failure = tostring(value)
+		elseif request == nil then
+			if value ~= nil then
+				local _value = value
+				failure = `returned a {typeof(_value)}; event callbacks return nothing`
+			end
+		elseif isPromise(value) then
+			failure = "returned a Promise; request callbacks return the response"
+		end
+		local replies = request ~= nil and not entry.settled and peer.state ~= 2
+		local packet
+		if replies and failure == nil then
+			local _binding = request
+			local definition = _binding.definition
+			local nonce = _binding.nonce
+			local encoded, result = pcall(function()
+				return frame(encodeBody(definition.name, definition.output, "response", value), 2, { definition.index, nonce })
+			end)
+			if encoded then
+				packet = result
+			else
+				failure = tostring(result)
+			end
+		end
+		if failure ~= nil then
+			self:reportCallback(peer, entry.claim, entry, failure)
+		end
+		if not replies then
+			return nil
+		end
+		entry.settled = true
+		self:fire(peer, packet or controlPacket(3, { request.definition.index, request.nonce }, 1))
+	end
+	function Session:reportCallback(peer, claim, entry, message)
+		if entry ~= nil then
+			if entry.reported then
+				return nil
+			end
+			entry.reported = true
+		end
+		local player = peer.player
+		local live = player ~= nil and peer.state ~= 2
+		local seen = if live then peer.failedClaims else self.lateFailures
+		local _claim = claim
+		if seen[_claim] ~= nil then
+			return nil
+		end
+		local _claim_1 = claim
+		seen[_claim_1] = true
+		runtimeDiagnostic("error", `{claim.label}{if live then ` for {player.Name}` else ""} failed: {message}`)
+	end
+	function Session:runReady(peer, claim, work, argument)
+		local result, value = within(claim.owner, nil, 8, invoke, work, argument)
+		if result == 0 then
+			return true, value
+		end
+		self:reportCallback(peer, claim, nil, tostring(value))
+		return false, nil
+	end
+	function Session:deferCleanup(peer, entry)
+		defer(function()
+			return self:runReady(peer, entry.claim, entry.cleanup, nil)
+		end)
+	end
+	function Session:keep(peer, entry)
+		if isLive(entry.claim) and peer.state == 1 then
+			local _cleanups = peer.cleanups
+			local _entry = entry
+			table.insert(_cleanups, _entry)
+		else
+			self:deferCleanup(peer, entry)
+		end
+	end
+	Session["end"] = function(self, peer)
+		if peer.state == 2 then
+			return false
+		end
+		peer.state = 2
+		table.clear(peer.queue)
+		peer.queuedBytes = 0
+		for _, entry in peer.running do
+			local _result = entry.lifetime
+			if _result ~= nil then
+				_result()
+			end
+			entry.lifetime = nil
+		end
+		table.clear(peer.running)
+		table.clear(peer.rejected)
+		table.clear(peer.failedClaims)
+		local _array = {}
+		local _length = #_array
+		local _array_1 = peer.cleanups
+		table.move(_array_1, 1, #_array_1, _length + 1, _array)
+		local cleanups = _array
+		table.clear(peer.cleanups)
+		for i = #cleanups - 1, 0, -1 do
+			self:deferCleanup(peer, cleanups[i + 1])
+		end
+		return true
+	end
+	function Session:unreceived(definition)
+		local _noReceiver = self.noReceiver
+		local _definition = definition
+		if _noReceiver[_definition] ~= nil then
+			return nil
+		end
+		local _noReceiver_1 = self.noReceiver
+		local _definition_1 = definition
+		_noReceiver_1[_definition_1] = true
+		runtimeDiagnostic("warning", `Crucible dropped {definition.name}: it has no live receiver`)
+	end
+end
+return {
+	newPeer = newPeer,
+	Session = Session,
+}

package/out/internal/reactive/context.d.ts

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