@trioforge/crucible 0.1.0 → 0.2.0

package/out/internal/data/inbox.luau

@@ -0,0 +1,437 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local bootClock = TS.import(script, script.Parent.Parent, "boot").bootClock
+local _inbox_transforms = TS.import(script, script.Parent, "inbox-transforms")
+local append = _inbox_transforms.append
+local clearQuarantine = _inbox_transforms.clearQuarantine
+local _envelope = TS.import(script, script.Parent, "envelope")
+local jsonBytes = _envelope.jsonBytes
+local parseEnvelope = _envelope.parseEnvelope
+local _limits = TS.import(script, script.Parent, "limits")
+local CALL_DEADLINE_SECONDS = _limits.CALL_DEADLINE_SECONDS
+local INBOX_MAX_ATTEMPTS = _limits.INBOX_MAX_ATTEMPTS
+local INBOX_RETRY_SECONDS = _limits.INBOX_RETRY_SECONDS
+local MESSAGE_ID_MAX_AGE_SECONDS = _limits.MESSAGE_ID_MAX_AGE_SECONDS
+local MESSAGE_PAYLOAD_MAX_BYTES = _limits.MESSAGE_PAYLOAD_MAX_BYTES
+local OPERATION_ID_MAX_BYTES = _limits.OPERATION_ID_MAX_BYTES
+local _operation_id = TS.import(script, script.Parent, "operation-id")
+local ageOf = _operation_id.ageOf
+local createdAt = _operation_id.createdAt
+local newOperationId = _operation_id.newOperationId
+--* @internal A message payload admitted against a descriptor (rule 76), or refused. 
+--* @internal A declared message: its name and the admission of its payload (rule 65). 
+--* @internal A quarantined item as `quarantined` lists it (rule 73). 
+local function retryAfter(attempts)
+	return INBOX_RETRY_SECONDS[math.min(attempts, #INBOX_RETRY_SECONDS)]
+end
+--* @internal One profile store's offline inbox: its receivers, its sends and the session-side delivery (rules 65 to 73). 
+local Inbox
+do
+	Inbox = setmetatable({}, {
+		__tostring = function()
+			return "Inbox"
+		end,
+	})
+	Inbox.__index = Inbox
+	function Inbox.new(...)
+		local self = setmetatable({}, Inbox)
+		return self:constructor(...) or self
+	end
+	function Inbox:constructor(runtime)
+		self.runtime = runtime
+		self.receivers = {}
+		self.engine = runtime.engine
+		self.store = runtime.schema.name
+	end
+	function Inbox:receive(message, receive)
+		local _receivers = self.receivers
+		local _name = message.name
+		local _arg1 = {
+			message = message,
+			receive = receive,
+		}
+		_receivers[_name] = _arg1
+	end
+	function Inbox:unreceive(name)
+		local _receivers = self.receivers
+		local _name = name
+		_receivers[_name] = nil
+	end
+	function Inbox:send(userId, message, payload, id)
+		local admitted = message.admit(payload)
+		if not admitted.ok then
+			error(`{self.store}: the payload of message {message.name} is invalid`, 2)
+		end
+		local bytes = jsonBytes(admitted.value)
+		if bytes > MESSAGE_PAYLOAD_MAX_BYTES then
+			error(`{self.store}: the payload of message {message.name} is {bytes} bytes, over {MESSAGE_PAYLOAD_MAX_BYTES}`, 2)
+		end
+		local port = self.engine.port
+		local _condition = id
+		if _condition == nil then
+			_condition = newOperationId(port)
+		end
+		local sent = _condition
+		if not (type(sent) == "string") or #sent > OPERATION_ID_MAX_BYTES or createdAt(sent) == nil then
+			error(`{self.store}: a message id comes from operationId() and is at most {OPERATION_ID_MAX_BYTES} bytes`, 2)
+		end
+		if ageOf(sent, port.wall(), MESSAGE_ID_MAX_AGE_SECONDS) ~= "fresh" then
+			return {
+				kind = "expired",
+			}
+		end
+		local item = {
+			id = sent,
+			name = message.name,
+			version = self.runtime.schema.version,
+			payload = admitted.value,
+			generation = 0,
+			attempts = 0,
+		}
+		local decision
+		local deadline = bootClock() + CALL_DEADLINE_SECONDS
+		local ticket = self.engine.scheduler:submit({
+			store = self.store,
+			key = tostring(userId),
+			priority = 5,
+			kind = "update",
+			dispatchDeadline = deadline,
+			bytes = bytes + 1024,
+			transform = function()
+				return function(current)
+					return append(current, userId, item, port.wall, function(d)
+						decision = d
+						return decision
+					end)
+				end
+			end,
+		})
+		local settled = ticket:wait(deadline) or {
+			kind = if ticket.dispatched then "uncertain" else "timeout",
+		}
+		if settled.kind ~= "done" then
+			return {
+				kind = settled.kind,
+			}
+		end
+		if settled.outcome.kind == "error" or decision == nil then
+			return {
+				kind = "unavailable",
+			}
+		end
+		if decision.kind == "unreadable" then
+			return {
+				kind = "unavailable",
+			}
+		end
+		if decision.kind ~= "appended" and decision.kind ~= "duplicate" then
+			return {
+				kind = decision.kind,
+			}
+		end
+		self:prompt(userId)
+		return {
+			kind = "ok",
+			value = nil,
+		}
+	end
+	function Inbox:prompt(userId)
+		for _, session in self.runtime.sessions do
+			if session.userId == userId and session.phase == 1 then
+				self.runtime:requestWrite(session, 3)
+			end
+		end
+	end
+	function Inbox:quarantined(userId)
+		local deadline = bootClock() + CALL_DEADLINE_SECONDS
+		local ticket = self.engine.scheduler:submit({
+			store = self.store,
+			key = tostring(userId),
+			priority = 5,
+			kind = "read",
+			dispatchDeadline = deadline,
+			bytes = 1024,
+		})
+		local settled = ticket:wait(deadline) or {
+			kind = if ticket.dispatched then "uncertain" else "timeout",
+		}
+		if settled.kind ~= "done" then
+			return {
+				kind = settled.kind,
+			}
+		end
+		if settled.outcome.kind == "error" then
+			return {
+				kind = "unavailable",
+			}
+		end
+		local _result = settled.outcome.value
+		if _result ~= nil then
+			_result = _result.value
+		end
+		local parsed = parseEnvelope(_result, "profiles")
+		if parsed.kind == "absent" then
+			return {
+				kind = "ok",
+				value = {},
+			}
+		end
+		if parsed.kind == "unreadable" then
+			return {
+				kind = "unavailable",
+			}
+		end
+		local _object = {
+			kind = "ok",
+		}
+		local _left = "value"
+		local _exp = parsed.envelope.quarantine
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#_exp)
+		local _callback = function(item)
+			local _object_1 = {
+				id = item.id,
+				name = item.name,
+				reason = item.reason,
+				attempts = item.attempts,
+			}
+			local _left_1 = "sentAt"
+			local _condition = createdAt(item.id)
+			if _condition == nil then
+				_condition = 0
+			end
+			_object_1[_left_1] = _condition
+			_object_1.payload = item.payload
+			return _object_1
+		end
+		for _k, _v in _exp do
+			_newValue[_k] = _callback(_v, _k - 1, _exp)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		_object[_left] = _newValue
+		return _object
+	end
+	function Inbox:clearQuarantined(userId, ids, action)
+		for _, id in ids do
+			if not (type(id) == "string") or #id > OPERATION_ID_MAX_BYTES then
+				error(`{self.store}: a message id is at most {OPERATION_ID_MAX_BYTES} bytes`, 2)
+			end
+		end
+		local decision
+		local _set = {}
+		for _, _v in ids do
+			_set[_v] = true
+		end
+		local listed = _set
+		local deadline = bootClock() + CALL_DEADLINE_SECONDS
+		local ticket = self.engine.scheduler:submit({
+			store = self.store,
+			key = tostring(userId),
+			priority = 5,
+			kind = "update",
+			dispatchDeadline = deadline,
+			bytes = 1024,
+			transform = function()
+				return function(current)
+					return clearQuarantine(current, userId, listed, action, function(d)
+						decision = d
+						return decision
+					end)
+				end
+			end,
+		})
+		local settled = ticket:wait(deadline) or {
+			kind = if ticket.dispatched then "uncertain" else "timeout",
+		}
+		if settled.kind ~= "done" then
+			return {
+				kind = settled.kind,
+			}
+		end
+		if settled.outcome.kind == "error" or decision == nil or decision.kind == "unreadable" then
+			return {
+				kind = "unavailable",
+			}
+		end
+		if decision.kind == "full" then
+			return {
+				kind = "full",
+			}
+		end
+		if decision.changed > 0 then
+			self:prompt(userId)
+		end
+		return {
+			kind = "ok",
+			value = decision.changed,
+		}
+	end
+	function Inbox:deliver(session, envelope)
+		for id, revision in session.acks do
+			if revision <= session.confirmed then
+				session.acks[id] = nil
+			end
+		end
+		for id, mark in session.marks do
+			local _exp = envelope.inbox
+			-- ▼ ReadonlyArray.find ▼
+			local _callback = function(other)
+				return other.id == id
+			end
+			local _result
+			for _i, _v in _exp do
+				if _callback(_v, _i - 1, _exp) == true then
+					_result = _v
+					break
+				end
+			end
+			-- ▲ ReadonlyArray.find ▲
+			local item = _result
+			local _result_1 = item
+			if _result_1 ~= nil then
+				_result_1 = _result_1.generation
+			end
+			if _result_1 == mark.generation then
+				continue
+			end
+			local _condition = mark.quarantine ~= nil
+			if _condition then
+				local _result_2 = item
+				if _result_2 ~= nil then
+					_result_2 = _result_2.generation
+				end
+				_condition = _result_2 == mark.generation + 1
+				if _condition then
+					_condition = item.attempts == mark.attempts
+				end
+			end
+			if _condition then
+				self.engine:diagnose(`quarantine-full:{self.store}:{session.userId}`, `quarantine full for {self.store} {session.userId}; clear it with clearQuarantined`)
+			end
+			session.marks[id] = nil
+		end
+		session.inbox = envelope.inbox
+		self:apply(session)
+	end
+	function Inbox:apply(session)
+		if not self.runtime:accept(session) then
+			return nil
+		end
+		local present = {}
+		for _, item in session.inbox do
+			local _id = item.id
+			present[_id] = true
+		end
+		for id in session.retryAt do
+			if not (present[id] ~= nil) then
+				session.retryAt[id] = nil
+			end
+		end
+		local soonest
+		local staged = false
+		for _, item in session.inbox do
+			local now = bootClock()
+			local _receivers = self.receivers
+			local _name = item.name
+			local receiver = _receivers[_name]
+			local _condition = receiver == nil
+			if not _condition then
+				local _acks = session.acks
+				local _id = item.id
+				_condition = _acks[_id] ~= nil
+				if not _condition then
+					local _marks = session.marks
+					local _id_1 = item.id
+					_condition = _marks[_id_1] ~= nil
+				end
+			end
+			if _condition then
+				continue
+			end
+			if item.version > self.runtime.schema.version then
+				self.engine:diagnose(`inbox-version:{session.token}:{item.id}`, `{self.store}: {session.userId}'s inbox item {item.id} was sent by a newer build (version {item.version}) and stays queued`)
+				continue
+			end
+			local _retryAt = session.retryAt
+			local _id = item.id
+			local at = _retryAt[_id]
+			if at == nil and item.attempts > 0 then
+				at = now + retryAfter(item.attempts)
+				local _retryAt_1 = session.retryAt
+				local _id_1 = item.id
+				local _at = at
+				_retryAt_1[_id_1] = _at
+			end
+			if at ~= nil and now < at then
+				local _condition_1 = soonest
+				if _condition_1 == nil then
+					_condition_1 = at
+				end
+				soonest = math.min(_condition_1, at)
+				continue
+			end
+			local admitted = receiver.message.admit(item.payload)
+			if not admitted.ok then
+				local _marks = session.marks
+				local _id_1 = item.id
+				local _arg1 = {
+					id = item.id,
+					generation = item.generation,
+					attempts = item.attempts,
+					quarantine = "payload",
+				}
+				_marks[_id_1] = _arg1
+				local _retryAt_1 = session.retryAt
+				local _id_2 = item.id
+				local _arg1_1 = now + retryAfter(#INBOX_RETRY_SECONDS)
+				_retryAt_1[_id_2] = _arg1_1
+				self.engine:diagnose(`inbox-payload:{session.token}:{item.id}`, `{self.store}: {session.userId}'s inbox item {item.id} ({item.name}) has a payload this build refuses; quarantined`)
+				staged = true
+				continue
+			end
+			local ok = pcall(function()
+				return session:write(function(data)
+					return receiver.receive(session.player, data, admitted.value)
+				end, function()
+					local _acks = session.acks
+					local _id_1 = item.id
+					local _arg1 = session.revision + 1
+					_acks[_id_1] = _arg1
+					return _acks
+				end)
+			end)
+			if not ok then
+				local attempts = item.attempts + 1
+				local _marks = session.marks
+				local _id_1 = item.id
+				local _arg1 = {
+					id = item.id,
+					generation = item.generation,
+					attempts = attempts,
+					quarantine = if attempts >= INBOX_MAX_ATTEMPTS then "attempts" else nil,
+				}
+				_marks[_id_1] = _arg1
+				local _retryAt_1 = session.retryAt
+				local _id_2 = item.id
+				local _arg1_1 = now + retryAfter(attempts)
+				_retryAt_1[_id_2] = _arg1_1
+				self.engine:diagnose(`inbox-attempt:{session.token}:{item.id}`, `{self.store}: {session.userId}'s inbox item {item.id} ({item.name}) failed attempt {attempts}`)
+				staged = true
+			else
+				staged = true
+			end
+		end
+		if staged then
+			self.runtime:requestWrite(session, 3)
+		end
+		if soonest ~= nil then
+			local at = soonest
+			self.engine.port.delay(math.max(at - bootClock(), 0), function()
+				return self:apply(session)
+			end)
+		end
+	end
+end
+return {
+	Inbox = Inbox,
+}

package/out/internal/data/lease.d.ts

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