@trioforge/crucible 0.0.0-stage → 0.2.0

package/out/internal/data/handles.luau

@@ -0,0 +1,255 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _graph = TS.import(script, script.Parent.Parent, "reactive", "graph")
+local createComputedNode = _graph.createComputedNode
+local readComputed = _graph.readComputed
+local _paths = TS.import(script, script.Parent, "paths")
+local childNode = _paths.childNode
+local describePath = _paths.describePath
+local getPath = _paths.getPath
+local luaKey = _paths.luaKey
+local setPath = _paths.setPath
+local tableBranch = _paths.tableBranch
+--[[
+	*
+	 * @internal What a tree of handles reads from and writes to: a player's slot on the server, an inert source for a
+	 * player who is not present, or the owner's views on the client (rules 115, 117, 124, 126).
+	 
+]]
+--* The node lives in each handle's own metatable: Luau's weak keys are not ephemerons, so no shared table maps them. 
+local NODE = {}
+local RESERVED = {
+	["set"] = true,
+	["update"] = true,
+	["insert"] = true,
+	["remove"] = true,
+}
+local function nodeOf(target)
+	local _target = target
+	if not (type(_target) == "table") then
+		return nil
+	end
+	local meta = getmetatable(target)
+	return if type(meta) == "table" then (meta[NODE]) else nil
+end
+local function mapKey(name)
+	error(`a map key named "{name}" has no handle; read the map and write it with the map's update`, 3)
+end
+local function writer(handle, method)
+	local node = nodeOf(handle)
+	if node == nil then
+		mapKey(method)
+	end
+	return node
+end
+--* Rule 118: the parent of the written position exists and is a table, and an index is an integer in range. 
+local function check(node, root, path, extra)
+	local name = node.source.name
+	local parent = root
+	for i = 0, #path - 2 do
+		parent = parent[luaKey(path[i + 1])]
+		local _parent = parent
+		if not (type(_parent) == "table") then
+			error(`{describePath(name, path)}: its parent does not exist; set the parent whole`, 0)
+		end
+	end
+	local last = path[#path]
+	if type(last) == "number" then
+		local highest = #parent - 1 + extra
+		if last % 1 ~= 0 or last < 0 or last > highest then
+			error(`{describePath(name, path)}: {if highest < 0 then "the array is empty" else `the index is not an integer from 0 to {highest}`}`, 0)
+		end
+	end
+	return parent
+end
+local function method(name, run)
+	return setmetatable({}, {
+		__call = function(_, handle, ...)
+			local args = { ... }
+			return run(writer(handle, name), unpack(args))
+		end,
+		__index = function()
+			return mapKey(name)
+		end,
+		__newindex = function()
+			return mapKey(name)
+		end,
+	})
+end
+--* The four write members, shared by every server handle (rules 118 to 120, 122). 
+local arrayAt
+local METHODS = {
+	set = method("set", function(node, value)
+		return node.source:write(function(root)
+			if #node.path > 0 then
+				check(node, root, node.path, 0)
+			end
+			return setPath(root, node.path, value)
+		end)
+	end),
+	update = method("update", function(node, change)
+		return node.source:write(function(root)
+			if #node.path > 0 then
+				check(node, root, node.path, 0)
+			end
+			return setPath(root, node.path, change(getPath(root, node.path)))
+		end)
+	end),
+	insert = method("insert", function(node, value, index)
+		return node.source:write(function(root)
+			local array = arrayAt(node, root)
+			local position = if index == nil then #array else index
+			local _exp = node
+			local _exp_1 = root
+			local _array = {}
+			local _length = #_array
+			local _array_1 = node.path
+			local _Length = #_array_1
+			table.move(_array_1, 1, _Length, _length + 1, _array)
+			_length += _Length
+			_array[_length + 1] = position
+			check(_exp, _exp_1, _array, 1)
+			local copy = table.clone(array)
+			local _value = value
+			table.insert(copy, position + 1, _value)
+			return setPath(root, node.path, copy)
+		end)
+	end),
+	remove = method("remove", function(node, index)
+		return node.source:write(function(root)
+			local array = arrayAt(node, root)
+			local _exp = node
+			local _exp_1 = root
+			local _array = {}
+			local _length = #_array
+			local _array_1 = node.path
+			local _Length = #_array_1
+			table.move(_array_1, 1, _Length, _length + 1, _array)
+			_length += _Length
+			_array[_length + 1] = index
+			check(_exp, _exp_1, _array, 0)
+			local copy = table.clone(array)
+			local _index = index
+			table.remove(copy, _index + 1)
+			return setPath(root, node.path, copy)
+		end)
+	end),
+}
+function arrayAt(node, root)
+	local value = getPath(root, node.path)
+	if not (type(value) == "table") then
+		error(`{describePath(node.source.name, node.path)}: it does not exist; set it whole`, 0)
+	end
+	return value
+end
+local makeHandle
+local function child(parent, node, key)
+	local schema = childNode(node.schema, key)
+	local _condition = schema ~= nil
+	if _condition then
+		local _result = tableBranch(node.schema)
+		if _result ~= nil then
+			_result = _result.kind
+		end
+		_condition = _result == "object"
+	end
+	local strong = _condition
+	local cache = if strong then node.fields else node.entries
+	local _key = key
+	local found = cache[_key]
+	if found ~= nil then
+		return found
+	end
+	local _object = {
+		source = node.source,
+	}
+	local _left = "path"
+	local _array = {}
+	local _length = #_array
+	local _array_1 = node.path
+	local _Length = #_array_1
+	table.move(_array_1, 1, _Length, _length + 1, _array)
+	_length += _Length
+	_array[_length + 1] = key
+	_object[_left] = _array
+	_object.schema = schema
+	_object.parent = parent
+	_object.fields = {}
+	_object.entries = setmetatable({}, {
+		__mode = "v",
+	})
+	local made = makeHandle(_object)
+	local _key_1 = key
+	cache[_key_1] = made
+	return made
+end
+local handleCall = function(handle, ...)
+	local args = { ... }
+	local node = nodeOf(handle)
+	local source = node.source
+	if #args > 0 then
+		error(if source.client then `{source.name}() is read-only on the client` else `{source.name}: read a handle with h(); write it with set or update`, 2)
+	end
+	source:beforeRead()
+	if node.read == nil then
+		local path = node.path
+		node.read = createComputedNode(function()
+			return source:read(path)
+		end)
+	end
+	return readComputed(node.read)
+end
+local handleIndex = function(handle, key)
+	local node = nodeOf(handle)
+	local _key = key
+	local _condition = type(_key) == "string"
+	if _condition then
+		local _key_1 = key
+		_condition = RESERVED[_key_1] ~= nil
+		if _condition then
+			_condition = not node.source.client
+		end
+	end
+	if _condition then
+		local _key_1 = key
+		return METHODS[_key_1]
+	end
+	local _key_1 = key
+	local _condition_1 = not (type(_key_1) == "string")
+	if _condition_1 then
+		local _key_2 = key
+		_condition_1 = not (type(_key_2) == "number")
+	end
+	if _condition_1 then
+		error("a handle's children are reached by key or index", 2)
+	end
+	return child(handle, node, key)
+end
+local handleNewindex = function()
+	return error("a handle has no fields to assign; write with set or update", 2)
+end
+--* @internal Rule 122: an empty table with a metatable of its own, holding its node under a private key. 
+function makeHandle(node)
+	local meta = {
+		__call = handleCall,
+		__index = handleIndex,
+		__newindex = handleNewindex,
+		[NODE] = node,
+	}
+	return setmetatable({}, meta)
+end
+--* @internal A root handle over `source`, typed by the descriptor `schema` (rules 115, 124). 
+local function rootHandle(source, schema)
+	return makeHandle({
+		source = source,
+		path = {},
+		schema = schema,
+		fields = {},
+		entries = setmetatable({}, {
+			__mode = "v",
+		}),
+	})
+end
+return {
+	rootHandle = rootHandle,
+}

package/out/internal/data/inbox-transforms.d.ts

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

package/out/internal/data/inbox-transforms.luau

@@ -0,0 +1,458 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _envelope = TS.import(script, script.Parent, "envelope")
+local emptyEnvelope = _envelope.emptyEnvelope
+local envelopeBytes = _envelope.envelopeBytes
+local jsonBytes = _envelope.jsonBytes
+local parseEnvelope = _envelope.parseEnvelope
+local _limits = TS.import(script, script.Parent, "limits")
+local INBOX_MAX_BYTES = _limits.INBOX_MAX_BYTES
+local INBOX_MAX_MESSAGES = _limits.INBOX_MAX_MESSAGES
+local MAX_ENVELOPE_BYTES = _limits.MAX_ENVELOPE_BYTES
+local MESSAGE_ID_MAX_AGE_SECONDS = _limits.MESSAGE_ID_MAX_AGE_SECONDS
+local QUARANTINE_MAX_BYTES = _limits.QUARANTINE_MAX_BYTES
+local QUARANTINE_MAX_MESSAGES = _limits.QUARANTINE_MAX_MESSAGES
+local SEEN_MAX_MESSAGES = _limits.SEEN_MAX_MESSAGES
+local _operation_id = TS.import(script, script.Parent, "operation-id")
+local ageOf = _operation_id.ageOf
+local createdAt = _operation_id.createdAt
+local evictable = _operation_id.evictable
+--[[
+	*
+	 * @internal An attempt count or a quarantine move for one item, compare-and-set on the item's generation: it applies
+	 * only while the stored item is live with exactly `generation` (rule 72).
+	 
+]]
+local function addSeen(envelope, ids)
+	local _array = {}
+	local _length = #_array
+	local _array_1 = envelope.seen
+	table.move(_array_1, 1, #_array_1, _length + 1, _array)
+	local seen = _array
+	local floor = envelope.seenFloor
+	for _, id in ids do
+		if not (table.find(seen, id) ~= nil) then
+			table.insert(seen, id)
+		end
+	end
+	while #seen > SEEN_MAX_MESSAGES do
+		local evicted = table.remove(seen, 1)
+		local _exp = floor
+		local _condition = createdAt(evicted)
+		if _condition == nil then
+			_condition = 0
+		end
+		floor = math.max(_exp, _condition)
+	end
+	return {
+		seen = seen,
+		seenFloor = floor,
+	}
+end
+--* @internal Each id leaves the inbox or the quarantine, wherever it is, and enters seen as its exact string (rule 72). 
+local function applyAcks(envelope, acks)
+	local _set = {}
+	for _, _v in acks do
+		_set[_v] = true
+	end
+	local gone = _set
+	local _object = table.clone(envelope)
+	setmetatable(_object, nil)
+	local _left = "inbox"
+	local _exp = envelope.inbox
+	-- ▼ ReadonlyArray.filter ▼
+	local _newValue = {}
+	local _callback = function(item)
+		local _id = item.id
+		return not (gone[_id] ~= nil)
+	end
+	local _length = 0
+	for _k, _v in _exp do
+		if _callback(_v, _k - 1, _exp) == true then
+			_length += 1
+			_newValue[_length] = _v
+		end
+	end
+	-- ▲ ReadonlyArray.filter ▲
+	_object[_left] = _newValue
+	local _left_1 = "quarantine"
+	local _exp_1 = envelope.quarantine
+	-- ▼ ReadonlyArray.filter ▼
+	local _newValue_1 = {}
+	local _callback_1 = function(item)
+		local _id = item.id
+		return not (gone[_id] ~= nil)
+	end
+	local _length_1 = 0
+	for _k, _v in _exp_1 do
+		if _callback_1(_v, _k - 1, _exp_1) == true then
+			_length_1 += 1
+			_newValue_1[_length_1] = _v
+		end
+	end
+	-- ▲ ReadonlyArray.filter ▲
+	_object[_left_1] = _newValue_1
+	for _k, _v in addSeen(envelope, acks) do
+		_object[_k] = _v
+	end
+	return _object
+end
+--[[
+	*
+	 * @internal Rule 72's compare-and-set. A move into a full quarantine leaves the item live with its attempts updated.
+	 * A mark whose generation no longer matches skips, and the item is untouched.
+	 
+]]
+local function applyMarks(envelope, marks)
+	local inbox = envelope.inbox
+	local quarantine = envelope.quarantine
+	for _, mark in marks do
+		-- ▼ ReadonlyArray.findIndex ▼
+		local _callback = function(item)
+			return item.id == mark.id and item.generation == mark.generation
+		end
+		local _result = -1
+		for _i, _v in inbox do
+			if _callback(_v, _i - 1, inbox) == true then
+				_result = _i - 1
+				break
+			end
+		end
+		-- ▲ ReadonlyArray.findIndex ▲
+		local index = _result
+		if index < 0 then
+			continue
+		end
+		local item = inbox[index + 1]
+		local _object = table.clone(item)
+		setmetatable(_object, nil)
+		_object.attempts = mark.attempts
+		_object.generation = item.generation + 1
+		local marked = _object
+		local _array = {}
+		local _length = #_array
+		local _quarantineLength = #quarantine
+		table.move(quarantine, 1, _quarantineLength, _length + 1, _array)
+		_length += _quarantineLength
+		local _object_1 = table.clone(marked)
+		setmetatable(_object_1, nil)
+		_object_1.reason = mark.quarantine
+		_array[_length + 1] = _object_1
+		local moved = _array
+		local room = mark.quarantine ~= nil and #moved <= QUARANTINE_MAX_MESSAGES and jsonBytes(moved) <= QUARANTINE_MAX_BYTES
+		local _array_1 = {}
+		local _length_1 = #_array_1
+		table.move(inbox, 1, #inbox, _length_1 + 1, _array_1)
+		local rest = _array_1
+		if room then
+			table.remove(rest, index + 1)
+			quarantine = moved
+		else
+			rest[index + 1] = marked
+		end
+		inbox = rest
+	end
+	local _result
+	if inbox == envelope.inbox then
+		_result = envelope
+	else
+		local _object = table.clone(envelope)
+		setmetatable(_object, nil)
+		_object.inbox = inbox
+		_object.quarantine = quarantine
+		_result = _object
+	end
+	return _result
+end
+--* @internal Exact structural equality of two stored JSON values (rule 68). 
+local function sameValue(a, b)
+	local _a = a
+	local _condition = not (type(_a) == "table")
+	if not _condition then
+		local _b = b
+		_condition = not (type(_b) == "table")
+	end
+	if _condition then
+		return a == b
+	end
+	local count = 0
+	for key, value in pairs(a) do
+		count += 1
+		if not sameValue(value, b[key]) then
+			return false
+		end
+	end
+	for _element, _element_1 in pairs(b) do
+		local _ = { _element, _element_1 }
+		count -= 1
+	end
+	return count == 0
+end
+local function stored(current, userId, envelope)
+	local _array = {}
+	local _length = #_array
+	local _result = current
+	if _result ~= nil then
+		_result = _result.userIds
+	end
+	local _condition = _result
+	if _condition == nil then
+		_condition = {}
+	end
+	table.move(_condition, 1, #_condition, _length + 1, _array)
+	local userIds = _array
+	local _userId = userId
+	if not (table.find(userIds, _userId) ~= nil) then
+		local _userId_1 = userId
+		table.insert(userIds, _userId_1)
+	end
+	local _object = {
+		value = envelope,
+		userIds = userIds,
+	}
+	local _left = "metadata"
+	local _result_1 = current
+	if _result_1 ~= nil then
+		_result_1 = _result_1.metadata
+	end
+	local _condition_1 = _result_1
+	if _condition_1 == nil then
+		_condition_1 = {}
+	end
+	_object[_left] = _condition_1
+	return _object
+end
+--* @internal 
+--[[
+	*
+	 * @internal An inbox append (rules 66 to 70). Touches only `inbox`, needs no lease and works on any stored version. An
+	 * absent key becomes an unopened envelope.
+	 
+]]
+local function append(current, userId, item, wall, record)
+	local _result = current
+	if _result ~= nil then
+		_result = _result.value
+	end
+	local parsed = parseEnvelope(_result, "profiles")
+	if parsed.kind == "unreadable" then
+		record(parsed)
+		return nil
+	end
+	local envelope = if parsed.kind == "ok" then parsed.envelope else emptyEnvelope("profiles")
+	local _exp = envelope.inbox
+	-- ▼ ReadonlyArray.find ▼
+	local _callback = function(other)
+		return other.id == item.id
+	end
+	local _result_1
+	for _i, _v in _exp do
+		if _callback(_v, _i - 1, _exp) == true then
+			_result_1 = _v
+			break
+		end
+	end
+	-- ▲ ReadonlyArray.find ▲
+	local _condition = _result_1
+	if _condition == nil then
+		local _exp_1 = envelope.quarantine
+		-- ▼ ReadonlyArray.find ▼
+		local _callback_1 = function(other)
+			return other.id == item.id
+		end
+		local _result_2
+		for _i, _v in _exp_1 do
+			if _callback_1(_v, _i - 1, _exp_1) == true then
+				_result_2 = _v
+				break
+			end
+		end
+		-- ▲ ReadonlyArray.find ▲
+		_condition = _result_2
+	end
+	local held = _condition
+	if held ~= nil then
+		record({
+			kind = if held.name == item.name and sameValue(held.payload, item.payload) then "duplicate" else "reused",
+		})
+		return nil
+	end
+	local _seen = envelope.seen
+	local _id = item.id
+	if table.find(_seen, _id) ~= nil then
+		record({
+			kind = "duplicate",
+		})
+		return nil
+	end
+	local now = wall()
+	if ageOf(item.id, now, MESSAGE_ID_MAX_AGE_SECONDS) ~= "fresh" or createdAt(item.id) <= envelope.seenFloor then
+		record({
+			kind = "expired",
+		})
+		return nil
+	end
+	local _array = {}
+	local _length = #_array
+	local _array_1 = envelope.inbox
+	local _Length = #_array_1
+	table.move(_array_1, 1, _Length, _length + 1, _array)
+	_length += _Length
+	_array[_length + 1] = item
+	local inbox = _array
+	if #inbox > INBOX_MAX_MESSAGES or jsonBytes(inbox) > INBOX_MAX_BYTES then
+		record({
+			kind = "full",
+		})
+		return nil
+	end
+	if #envelope.seen >= SEEN_MAX_MESSAGES and not evictable(envelope.seen[1], now) then
+		record({
+			kind = "overloaded",
+		})
+		return nil
+	end
+	local _object = table.clone(envelope)
+	setmetatable(_object, nil)
+	_object.inbox = inbox
+	local written = _object
+	if envelopeBytes(written) > MAX_ENVELOPE_BYTES then
+		record({
+			kind = "full",
+		})
+		return nil
+	end
+	record({
+		kind = "appended",
+	})
+	return stored(current, userId, written)
+end
+--* @internal 
+--* @internal clearQuarantined (rule 73): touches only `inbox`, `quarantine` and `seen`, with no lease. 
+local function clearQuarantine(current, userId, ids, action, record)
+	local _result = current
+	if _result ~= nil then
+		_result = _result.value
+	end
+	local parsed = parseEnvelope(_result, "profiles")
+	if parsed.kind == "unreadable" then
+		record(parsed)
+		return nil
+	end
+	if parsed.kind == "absent" then
+		record({
+			kind = "cleared",
+			changed = 0,
+		})
+		return nil
+	end
+	local envelope = parsed.envelope
+	local _exp = envelope.quarantine
+	-- ▼ ReadonlyArray.filter ▼
+	local _newValue = {}
+	local _callback = function(item)
+		local _ids = ids
+		local _id = item.id
+		return _ids[_id] ~= nil
+	end
+	local _length = 0
+	for _k, _v in _exp do
+		if _callback(_v, _k - 1, _exp) == true then
+			_length += 1
+			_newValue[_length] = _v
+		end
+	end
+	-- ▲ ReadonlyArray.filter ▲
+	local listed = _newValue
+	if #listed == 0 then
+		record({
+			kind = "cleared",
+			changed = 0,
+		})
+		return nil
+	end
+	local _exp_1 = envelope.quarantine
+	-- ▼ ReadonlyArray.filter ▼
+	local _newValue_1 = {}
+	local _callback_1 = function(item)
+		local _ids = ids
+		local _id = item.id
+		return not (_ids[_id] ~= nil)
+	end
+	local _length_1 = 0
+	for _k, _v in _exp_1 do
+		if _callback_1(_v, _k - 1, _exp_1) == true then
+			_length_1 += 1
+			_newValue_1[_length_1] = _v
+		end
+	end
+	-- ▲ ReadonlyArray.filter ▲
+	local quarantine = _newValue_1
+	local written
+	if action == "retry" then
+		local _array = {}
+		local _length_2 = #_array
+		local _array_1 = envelope.inbox
+		local _Length = #_array_1
+		table.move(_array_1, 1, _Length, _length_2 + 1, _array)
+		_length_2 += _Length
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue_2 = table.create(#listed)
+		local _callback_2 = function(item)
+			return {
+				id = item.id,
+				name = item.name,
+				version = item.version,
+				payload = item.payload,
+				generation = item.generation + 1,
+				attempts = 0,
+			}
+		end
+		for _k, _v in listed do
+			_newValue_2[_k] = _callback_2(_v, _k - 1, listed)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		table.move(_newValue_2, 1, #_newValue_2, _length_2 + 1, _array)
+		local inbox = _array
+		if #inbox > INBOX_MAX_MESSAGES or jsonBytes(inbox) > INBOX_MAX_BYTES then
+			record({
+				kind = "full",
+			})
+			return nil
+		end
+		local _object = table.clone(envelope)
+		setmetatable(_object, nil)
+		_object.inbox = inbox
+		_object.quarantine = quarantine
+		written = _object
+	else
+		local _object = table.clone(envelope)
+		setmetatable(_object, nil)
+		_object.quarantine = quarantine
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue_2 = table.create(#listed)
+		local _callback_2 = function(item)
+			return item.id
+		end
+		for _k, _v in listed do
+			_newValue_2[_k] = _callback_2(_v, _k - 1, listed)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		for _k, _v in addSeen(envelope, _newValue_2) do
+			_object[_k] = _v
+		end
+		written = _object
+	end
+	record({
+		kind = "cleared",
+		changed = #listed,
+	})
+	return stored(current, userId, written)
+end
+return {
+	applyAcks = applyAcks,
+	applyMarks = applyMarks,
+	sameValue = sameValue,
+	append = append,
+	clearQuarantine = clearQuarantine,
+}

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

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