@trioforge/crucible 0.0.0-stage → 0.2.0

package/out/internal/data/paths.luau

@@ -0,0 +1,323 @@
+-- Compiled with roblox-ts v3.0.0
+--* @internal A path segment as TypeScript wrote it: a field or map key, or an array index from 0. 
+--* @internal Rule 116: TypeScript indices reach a handle as written; Luau arrays start at 1. 
+local function luaKey(segment)
+	local _segment = segment
+	return if type(_segment) == "number" then segment + 1 else segment
+end
+--* @internal The value at `path`, or undefined where a table on the way is absent. Never throws. 
+local function getPath(root, path, from)
+	if from == nil then
+		from = 0
+	end
+	local current = root
+	do
+		local i = from
+		local _shouldIncrement = false
+		while true do
+			if _shouldIncrement then
+				i += 1
+			else
+				_shouldIncrement = true
+			end
+			if not (i < #path) then
+				break
+			end
+			local _current = current
+			if not (type(_current) == "table") then
+				return nil
+			end
+			current = current[luaKey(path[i + 1])]
+		end
+	end
+	return current
+end
+--[[
+	*
+	 * @internal Rule 118's path copy: each table on the path is `table.clone` of the stored one with one field replaced,
+	 * which is what a spread compiles to, so undeclared keys stay in place at every level (rule 78). A leaf rawequal to the
+	 * stored one returns `root` itself, which is no revision (rule 12). Admission freezes what this builds (rule 15).
+	 
+]]
+local function setPath(root, path, leaf, from)
+	if from == nil then
+		from = 0
+	end
+	if from >= #path then
+		return leaf
+	end
+	local current = root
+	local key = luaKey(path[from + 1])
+	local child = current[key]
+	local replaced = setPath(child, path, leaf, from + 1)
+	if rawequal(replaced, child) then
+		return root
+	end
+	local copy = table.clone(current)
+	copy[key] = replaced
+	return copy
+end
+--* @internal `FD.Players.career.jobs[0].coins`: keys after dots, indices from 0 in brackets. 
+local function describePath(name, path, upTo)
+	if upTo == nil then
+		upTo = #path
+	end
+	local text = name
+	do
+		local i = 0
+		local _shouldIncrement = false
+		while true do
+			if _shouldIncrement then
+				i += 1
+			else
+				_shouldIncrement = true
+			end
+			if not (i < upTo) then
+				break
+			end
+			local segment = path[i + 1]
+			text ..= if type(segment) == "number" then `[{segment}]` else `.{segment}`
+		end
+	end
+	return text
+end
+--* @internal The one table branch of an optional table (`V | undefined`), which keeps its children (rule 116). 
+local function tableBranch(node)
+	if node == nil or node.kind ~= "union" then
+		return node
+	end
+	local found
+	for _, branch in node.branches do
+		if branch.kind == "nil" then
+			continue
+		end
+		if found ~= nil then
+			return nil
+		end
+		found = branch
+	end
+	return if found == nil or found.kind == "variant" then nil else found
+end
+--* @internal The descriptor below `node` at `segment`, or undefined below a leaf or a union of several types. 
+local function childNode(node, segment)
+	local at = tableBranch(node)
+	if at == nil then
+		return nil
+	end
+	local _exp = at.kind
+	repeat
+		if _exp == "object" then
+			local _segment = segment
+			if not (type(_segment) == "string") then
+				return nil
+			end
+			for _, _binding in at.fields do
+				local name = _binding[1]
+				local child = _binding[2]
+				if name == segment then
+					return child
+				end
+			end
+			return nil
+		end
+		if _exp == "map" then
+			local _segment = segment
+			return if type(_segment) == "string" then at.value else nil
+		end
+		if _exp == "array" then
+			local _segment = segment
+			return if type(_segment) == "number" then at.element else nil
+		end
+		if _exp == "tuple" then
+			local _segment = segment
+			return if type(_segment) == "number" then at.elements[segment + 1] else nil
+		end
+		return nil
+	until true
+end
+--* True when `a` sorts before `b` by bytes. 
+local function bytesLess(a, b)
+	local length = math.min(#a, #b)
+	do
+		local i = 1
+		local _shouldIncrement = false
+		while true do
+			if _shouldIncrement then
+				i += 1
+			else
+				_shouldIncrement = true
+			end
+			if not (i <= length) then
+				break
+			end
+			local x = string.byte(a, i)
+			local y = string.byte(b, i)
+			if x ~= y then
+				return x < y
+			end
+		end
+	end
+	return #a < #b
+end
+--* @internal Rule 131's order: segment by segment, each by bytes, a prefix first. 
+local function pathLess(a, b)
+	local length = math.min(#a, #b)
+	do
+		local i = 0
+		local _shouldIncrement = false
+		while true do
+			if _shouldIncrement then
+				i += 1
+			else
+				_shouldIncrement = true
+			end
+			if not (i < length) then
+				break
+			end
+			if a[i + 1] ~= b[i + 1] then
+				return bytesLess(a[i + 1], b[i + 1])
+			end
+		end
+	end
+	return #a < #b
+end
+--* @internal Two segment arrays are equal segment by segment, never as joined text (rules 4, 131). 
+local function samePath(a, b)
+	if #a ~= #b then
+		return false
+	end
+	for i = 0, #a - 1 do
+		if a[i + 1] ~= b[i + 1] then
+			return false
+		end
+	end
+	return true
+end
+--* `{ "career", "a.b" }`, as rule 131's messages print a path. 
+local function showPath(path)
+	-- ▼ ReadonlyArray.map ▼
+	local _newValue = table.create(#path)
+	local _callback = function(segment)
+		return `"{segment}"`
+	end
+	for _k, _v in path do
+		_newValue[_k] = _callback(_v, _k - 1, path)
+	end
+	-- ▲ ReadonlyArray.map ▲
+	return `\{ {table.concat(_newValue, ", ")} \}`
+end
+--* A key that is "[]" or "*", or starts with a backslash, takes one more backslash, so no key stands for a marker. 
+local function escape(key)
+	return if key == "[]" or key == "*" or string.sub(key, 1, 1) == "\\" then `\\{key}` else key
+end
+--[[
+	*
+	 * @internal Rule 131: every object field path of `node`, one key per level, "[]" for an array element and "*" for a
+	 * map value, deduplicated across union members and sorted.
+	 
+]]
+local function fieldPaths(node)
+	local found = {}
+	local add = function(path)
+		local identity = ""
+		for _, segment in path do
+			identity ..= `{#segment}:{segment}`
+		end
+		local _identity = identity
+		if not (found[_identity] ~= nil) then
+			local _identity_1 = identity
+			local _path = path
+			found[_identity_1] = _path
+		end
+	end
+	local walk
+	walk = function(at, prefix)
+		local _exp = at.kind
+		repeat
+			if _exp == "object" then
+				for _, _binding in at.fields do
+					local key = _binding[1]
+					local child = _binding[2]
+					local _array = {}
+					local _length = #_array
+					local _prefixLength = #prefix
+					table.move(prefix, 1, _prefixLength, _length + 1, _array)
+					_length += _prefixLength
+					_array[_length + 1] = escape(key)
+					local path = _array
+					add(path)
+					walk(child, path)
+				end
+				return nil
+			end
+			if _exp == "array" then
+				local _exp_1 = at.element
+				local _array = {}
+				local _length = #_array
+				local _prefixLength = #prefix
+				table.move(prefix, 1, _prefixLength, _length + 1, _array)
+				_length += _prefixLength
+				_array[_length + 1] = "[]"
+				return walk(_exp_1, _array)
+			end
+			if _exp == "tuple" then
+				for _, element in at.elements do
+					local _array = {}
+					local _length = #_array
+					local _prefixLength = #prefix
+					table.move(prefix, 1, _prefixLength, _length + 1, _array)
+					_length += _prefixLength
+					_array[_length + 1] = "[]"
+					walk(element, _array)
+				end
+				return nil
+			end
+			if _exp == "map" then
+				local _exp_1 = at.value
+				local _array = {}
+				local _length = #_array
+				local _prefixLength = #prefix
+				table.move(prefix, 1, _prefixLength, _length + 1, _array)
+				_length += _prefixLength
+				_array[_length + 1] = "*"
+				return walk(_exp_1, _array)
+			end
+			if _exp == "union" then
+				for _, branch in at.branches do
+					walk(branch, prefix)
+				end
+				return nil
+			end
+			if _exp == "variant" then
+				local _array = {}
+				local _length = #_array
+				local _prefixLength = #prefix
+				table.move(prefix, 1, _prefixLength, _length + 1, _array)
+				_length += _prefixLength
+				_array[_length + 1] = escape(at.key)
+				add(_array)
+				return walk(at.body, prefix)
+			end
+		until true
+	end
+	walk(node, {})
+	local paths = {}
+	for _, path in found do
+		local _arg0 = table.freeze(path)
+		table.insert(paths, _arg0)
+	end
+	table.sort(paths, pathLess)
+	return table.freeze(paths)
+end
+return {
+	luaKey = luaKey,
+	getPath = getPath,
+	setPath = setPath,
+	describePath = describePath,
+	tableBranch = tableBranch,
+	childNode = childNode,
+	pathLess = pathLess,
+	samePath = samePath,
+	showPath = showPath,
+	fieldPaths = fieldPaths,
+}

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

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

package/out/internal/data/port.luau

@@ -0,0 +1,290 @@
+-- Compiled with roblox-ts v3.0.0
+--* @internal A stored value with the platform data UpdateAsync clears unless the transform returns it (rule 41). 
+--* @internal `retryable`: throttle or transient. `ambiguous`: the write may have committed. 
+--* @internal Transforms may run several times and never yield; returning undefined cancels. 
+--[[
+	*
+	 * @internal
+	 * Everything data asks of the engine (rule 105). It has no monotonic clock: data reads `bootClock()`, the clock core's
+	 * shutdown sweep uses (rule 25). `wall` is for leases and id times only.
+	 
+]]
+local port
+--* @internal 
+local function installDataPort(value)
+	local _arg0 = port == nil
+	assert(_arg0, "Data port already selected")
+	port = value
+end
+--* @internal 
+local createRobloxDataPort
+local function dataPort()
+	if port == nil then
+		port = createRobloxDataPort()
+	end
+	return port
+end
+--* @internal 301 to 306 are throttles that sent nothing; 5xx and codeless errors may have committed. 
+local function classify(message)
+	local digits = string.match(tostring(message), "^(%d+):")
+	local code = if digits == nil then 0 else tonumber(digits)
+	if code >= 301 and code <= 306 then
+		return {
+			kind = "error",
+			code = code,
+			retryable = true,
+			ambiguous = false,
+		}
+	end
+	if code == 0 or (code >= 500 and code <= 599) then
+		return {
+			kind = "error",
+			code = code,
+			retryable = true,
+			ambiguous = true,
+		}
+	end
+	return {
+		kind = "error",
+		code = code,
+		retryable = false,
+		ambiguous = false,
+	}
+end
+local function liveBacking()
+	local service = game:GetService("DataStoreService")
+	return {
+		update = function(store, key, transform)
+			local ok, result = pcall(function()
+				local value = service:GetDataStore(store):UpdateAsync(key, function(value, info)
+					local _fn = transform
+					local _result
+					if value == nil and info == nil then
+						_result = nil
+					else
+						local _object = {
+							value = value,
+						}
+						local _left = "userIds"
+						local _result_1 = info
+						if _result_1 ~= nil then
+							_result_1 = _result_1:GetUserIds()
+						end
+						local _condition = _result_1
+						if _condition == nil then
+							_condition = {}
+						end
+						_object[_left] = _condition
+						local _left_1 = "metadata"
+						local _result_2 = info
+						if _result_2 ~= nil then
+							_result_2 = _result_2:GetMetadata()
+						end
+						local _condition_1 = _result_2
+						if _condition_1 == nil then
+							_condition_1 = {}
+						end
+						_object[_left_1] = _condition_1
+						_result = _object
+					end
+					local written = _fn(_result)
+					if written == nil then
+						return nil
+					end
+					return written.value, written.userIds, written.metadata
+				end)
+				return value
+			end)
+			if not ok then
+				return classify(result)
+			end
+			return {
+				kind = "ok",
+				value = if result == nil then nil else {
+					value = result,
+					userIds = {},
+					metadata = {},
+				},
+			}
+		end,
+		read = function(store, key)
+			local ok, value, info = pcall(function()
+				return service:GetDataStore(store):GetAsync(key)
+			end)
+			if not ok then
+				return classify(value)
+			end
+			if value == nil then
+				return {
+					kind = "ok",
+					value = nil,
+				}
+			end
+			local keyInfo = info
+			local _object = {
+				kind = "ok",
+			}
+			local _left = "value"
+			local _object_1 = {
+				value = value,
+			}
+			local _left_1 = "userIds"
+			local _result = keyInfo
+			if _result ~= nil then
+				_result = _result:GetUserIds()
+			end
+			local _condition = _result
+			if _condition == nil then
+				_condition = {}
+			end
+			_object_1[_left_1] = _condition
+			local _left_2 = "metadata"
+			local _result_1 = keyInfo
+			if _result_1 ~= nil then
+				_result_1 = _result_1:GetMetadata()
+			end
+			local _condition_1 = _result_1
+			if _condition_1 == nil then
+				_condition_1 = {}
+			end
+			_object_1[_left_2] = _condition_1
+			_object[_left] = _object_1
+			return _object
+		end,
+		budget = function(kind)
+			return service:GetRequestBudgetForRequestType(if kind == "update" then Enum.DataStoreRequestType.UpdateAsync else Enum.DataStoreRequestType.GetAsync)
+		end,
+	}
+end
+--* Studio's store: the same transforms over an in-process table, so Studio runs lease.ts (rule 106). 
+local function memoryBacking()
+	local stores = {}
+	local keys = function(store)
+		local _store = store
+		local found = stores[_store]
+		if found == nil then
+			found = {}
+			local _store_1 = store
+			local _found = found
+			stores[_store_1] = _found
+		end
+		return found
+	end
+	return {
+		update = function(store, key, transform)
+			local ok, result = pcall(function()
+				local _fn = transform
+				local _exp = keys(store)
+				local _key = key
+				local written = _fn(_exp[_key])
+				if written ~= nil then
+					local _exp_1 = keys(store)
+					local _key_1 = key
+					_exp_1[_key_1] = written
+				end
+				return written
+			end)
+			if not ok then
+				return {
+					kind = "error",
+					code = 0,
+					retryable = false,
+					ambiguous = false,
+				}
+			end
+			return {
+				kind = "ok",
+				value = result,
+			}
+		end,
+		read = function(store, key)
+			local _object = {
+				kind = "ok",
+			}
+			local _left = "value"
+			local _exp = keys(store)
+			local _key = key
+			_object[_left] = _exp[_key]
+			return _object
+		end,
+		budget = function()
+			return math.huge
+		end,
+	}
+end
+--* @internal 
+function createRobloxDataPort()
+	local runService = game:GetService("RunService")
+	local players = game:GetService("Players")
+	local http = game:GetService("HttpService")
+	local live = not runService:IsStudio() or game:GetService("ServerStorage"):GetAttribute("CrucibleLiveData") == true
+	local backing = if live then liveBacking() else memoryBacking()
+	local random = Random.new()
+	local _object = table.clone(backing)
+	setmetatable(_object, nil)
+	_object.wall = function()
+		return DateTime.now().UnixTimestampMillis / 1000
+	end
+	_object.serverId = http:GenerateGUID(false)
+	_object.jobId = game.JobId
+	_object.guid = function()
+		return http:GenerateGUID(false)
+	end
+	_object.random = function()
+		return random:NextNumber()
+	end
+	_object.spawn = function(work)
+		task.spawn(work)
+	end
+	_object.delay = function(seconds, work)
+		return task.delay(seconds, work)
+	end
+	_object.cancel = function(thread)
+		return task.cancel(thread)
+	end
+	_object.resume = function(thread)
+		task.spawn(thread)
+	end
+	_object.wait = function(seconds)
+		task.wait(seconds)
+	end
+	_object.players = {
+		count = function()
+			return #players:GetPlayers()
+		end,
+		present = function(player)
+			return player.Parent == players
+		end,
+		byUserId = function(userId)
+			return players:GetPlayerByUserId(userId)
+		end,
+		kick = function(player, message)
+			return player:Kick(message)
+		end,
+		all = function()
+			return players:GetPlayers()
+		end,
+		onAdded = function(listener)
+			local connection = players.PlayerAdded:Connect(listener)
+			return function()
+				return connection:Disconnect()
+			end
+		end,
+		onRemoving = function(listener)
+			local connection = players.PlayerRemoving:Connect(listener)
+			return function()
+				return connection:Disconnect()
+			end
+		end,
+	}
+	_object.marketplace = function()
+		return game:GetService("MarketplaceService")
+	end
+	return _object
+end
+return {
+	installDataPort = installDataPort,
+	dataPort = dataPort,
+	classify = classify,
+	createRobloxDataPort = createRobloxDataPort,
+}

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

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