@trioforge/crucible 0.0.0-stage → 0.2.0

package/out/internal/data/session.luau

@@ -0,0 +1,234 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local bootClock = TS.import(script, script.Parent.Parent, "boot").bootClock
+local _graph = TS.import(script, script.Parent.Parent, "reactive", "graph")
+local createStateNode = _graph.createStateNode
+local update = _graph.update
+local call = TS.import(script, script.Parent.Parent, "runner").call
+local admitWrite = TS.import(script, script.Parent, "admission").admitWrite
+local jsonBytes = TS.import(script, script.Parent, "envelope").jsonBytes
+local PAYLOAD_MAX_BYTES = TS.import(script, script.Parent, "limits").PAYLOAD_MAX_BYTES
+--* @internal `confirmed` before any owned write with the session's token is confirmed (rule 37). 
+local NONE = -1
+--[[
+	*
+	 * @internal
+	 *   Loading --acquired, onLoad--> Active --leave / handoff / final phase / authority lost--> Sealed --release--> Ended
+	 *   Loading --failed, left or closed: abandon only--> Ended
+	 
+]]
+--* @internal 
+--* @internal How a release settled: its write committed, or it was fenced or gave up (rule 29). 
+local callbackThreads = {}
+--* Data never writes this state: its `update` frame is what makes reactive reject a nested write (rule 13, K7). 
+local transaction = createStateNode(0)
+local depth = 0
+--[[
+	*
+	 * @internal Runs a data callback on a no-yield worker whose thread may not write data, inside the `update` of a private
+	 * reactive state so a state, publish or apply write throws (rule 13); a yield or throw is thrown here.
+	 
+]]
+local function dataCallback(work, a, b)
+	local worker
+	depth += 1
+	local status, value = call(function(x, y)
+		worker = coroutine.running()
+		local _worker = worker
+		callbackThreads[_worker] = true
+		local result
+		update(transaction, function(current)
+			result = work(x, y)
+			return current
+		end)
+		return result
+	end, a, b)
+	depth -= 1
+	if worker ~= nil then
+		local _worker = worker
+		callbackThreads[_worker] = nil
+	end
+	if status ~= 0 then
+		error(value, 0)
+	end
+	return value
+end
+--[[
+	*
+	 * @internal True while any data callback runs. Callbacks never yield, so code running then was started inside one,
+	 * on its thread or a thread it spawned (rule 123).
+	 
+]]
+local function insideDataCallback()
+	return depth > 0
+end
+--* @internal Rule 13: no data write on a data callback's own thread. 
+local function assertOutsideCallback()
+	local _arg0 = coroutine.running()
+	if callbackThreads[_arg0] ~= nil then
+		error("a write inside a data callback; return the data instead", 3)
+	end
+end
+--* @internal One player's profile on this server, and the only writer of its data (rules 12 to 16). 
+local Session
+do
+	Session = setmetatable({}, {
+		__tostring = function()
+			return "Session"
+		end,
+	})
+	Session.__index = Session
+	function Session.new(...)
+		local self = setmetatable({}, Session)
+		return self:constructor(...) or self
+	end
+	function Session:constructor(schema, player, userId, token, hooks)
+		self.schema = schema
+		self.player = player
+		self.userId = userId
+		self.token = token
+		self.hooks = hooks
+		self.phase = 0
+		self.abandoned = false
+		self.epoch = 0
+		self.safeUntil = 0
+		self.revision = 0
+		self.confirmed = NONE
+		self.op = 0
+		self.busy = false
+		self.receipts = {}
+		self.durable = {}
+		self.effects = {}
+		self.acks = {}
+		self.marks = {}
+		self.inbox = {}
+		self.retryAt = {}
+		self.carrying = NONE
+		self.lost = NONE
+		self.releaseWanted = false
+		self.releaseAmbiguous = false
+		self.renewAt = 0
+	end
+	function Session:writable()
+		return self.phase == 1 and bootClock() < self.safeUntil
+	end
+	function Session:snapshot()
+		local applied = {}
+		for id, revision in self.acks do
+			local _arg0 = { id, revision }
+			table.insert(applied, _arg0)
+		end
+		table.sort(applied, function(a, b)
+			return a[2] < b[2]
+		end)
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#applied)
+		local _callback = function(_param)
+			local id = _param[1]
+			return id
+		end
+		for _k, _v in applied do
+			_newValue[_k] = _callback(_v, _k - 1, applied)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		local acks = _newValue
+		local marks = {}
+		for _, mark in self.marks do
+			table.insert(marks, mark)
+		end
+		local _object = {
+			revision = self.revision,
+			schemaVersion = self.schema.version,
+			payload = self.value,
+		}
+		local _left = "receipts"
+		local _array = {}
+		local _length = #_array
+		local _array_1 = self.receipts
+		table.move(_array_1, 1, #_array_1, _length + 1, _array)
+		_object[_left] = _array
+		_object.acks = acks
+		_object.marks = marks
+		return _object
+	end
+	function Session:uncertain()
+		local ticket = self.writing
+		local _result = ticket
+		if _result ~= nil then
+			_result = _result.dispatched
+		end
+		local _condition = _result == true
+		if _condition then
+			_condition = (ticket.inFlight or ticket.ambiguous)
+		end
+		local pending = if _condition then self.carrying else NONE
+		return math.max(pending, self.lost)
+	end
+	function Session:assertIdle()
+		if self.busy then
+			error(`{self.schema.name}: {self.userId}'s profile is inside a data callback; return the data instead`, 3)
+		end
+	end
+	function Session:transact(work)
+		self:assertIdle()
+		self.busy = true
+		local ok, result = pcall(work)
+		self.busy = false
+		self.hooks.changed()
+		if not ok then
+			error(result, 0)
+		end
+		return result
+	end
+	function Session:callback(work, a, b)
+		return dataCallback(work, a, b)
+	end
+	function Session:prepare(value)
+		local admitted = admitWrite(self.schema, value)
+		local bytes = jsonBytes(admitted)
+		if bytes > PAYLOAD_MAX_BYTES then
+			error(`{self.schema.name}: {self.userId}'s profile is {bytes} bytes, over {PAYLOAD_MAX_BYTES}`, 0)
+		end
+		local _result = self.schema.check
+		if _result ~= nil then
+			_result(admitted, self.value)
+		end
+		return admitted
+	end
+	function Session:commit(value, stage)
+		self.value = value
+		local _result = stage
+		if _result ~= nil then
+			_result()
+		end
+		self.revision += 1
+	end
+	function Session:write(change, stage)
+		return self:transact(function()
+			local current = self.value
+			local result = self:callback(change, current, nil)
+			if rawequal(result, current) and stage == nil then
+				return false
+			end
+			self:commit(self:prepare(result), stage)
+			self.hooks.publish(self.value)
+			return true
+		end)
+	end
+	function Session:stage(id)
+		local _receipts = self.receipts
+		local _id = id
+		if not (table.find(_receipts, _id) ~= nil) then
+			local _receipts_1 = self.receipts
+			local _id_1 = id
+			table.insert(_receipts_1, _id_1)
+		end
+	end
+end
+return {
+	dataCallback = dataCallback,
+	insideDataCallback = insideDataCallback,
+	assertOutsideCallback = assertOutsideCallback,
+	NONE = NONE,
+	Session = Session,
+}

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

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

package/out/internal/data/shutdown.luau

@@ -0,0 +1,91 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _boot = TS.import(script, script.Parent.Parent, "boot")
+local bootClock = _boot.bootClock
+local shutdownProgress = _boot.shutdownProgress
+local _limits = TS.import(script, script.Parent, "limits")
+local DISPATCH_CUTOFF_SECONDS = _limits.DISPATCH_CUTOFF_SECONDS
+local FINAL_PHASE_SECONDS = _limits.FINAL_PHASE_SECONDS
+local SETTLE_MARGIN_SECONDS = _limits.SETTLE_MARGIN_SECONDS
+local SHUTDOWN_FALLBACK_SECONDS = _limits.SHUTDOWN_FALLBACK_SECONDS
+local function pending(engine)
+	for _, runtime in engine.profiles do
+		for _1, session in runtime.sessions do
+			if session.phase ~= 3 then
+				return true
+			end
+		end
+	end
+	return false
+end
+--[[
+	*
+	 * @internal DataRuntime's onShutdown (rules 50 to 56), against core's deadline through E-D1. `subsystem` is the hook's
+	 * own Subsystem, excluded from `pending`; with no visible sweep the window is SHUTDOWN_FALLBACK_SECONDS.
+	 
+]]
+local function shutdownData(engine, subsystem)
+	local port = engine.port
+	local progress = if subsystem == nil then nil else shutdownProgress(subsystem)
+	local _result = progress
+	if _result ~= nil then
+		_result = _result.deadline
+	end
+	local _condition = _result
+	if _condition == nil then
+		_condition = bootClock() + SHUTDOWN_FALLBACK_SECONDS
+	end
+	local deadline = _condition
+	local finalAt = deadline - FINAL_PHASE_SECONDS
+	local cutoff = deadline - DISPATCH_CUTOFF_SECONDS
+	local settleAt = deadline - SETTLE_MARGIN_SECONDS
+	engine.scheduler:setDispatchCutoff(cutoff)
+	engine.closing = true
+	engine.receipts:close()
+	for _, runtime in engine.profiles do
+		for _1, session in runtime.sessions do
+			if session.phase == 0 then
+				session.abandoned = true
+			elseif session.phase == 1 and session.revision > session.confirmed then
+				runtime:flush(session)
+			end
+		end
+	end
+	engine:wake()
+	local others = function()
+		local _result_1
+		if subsystem == nil then
+			_result_1 = 0
+		else
+			local _result_2 = shutdownProgress(subsystem)
+			if _result_2 ~= nil then
+				_result_2 = _result_2.pending
+			end
+			local _condition_1 = _result_2
+			if _condition_1 == nil then
+				_condition_1 = 0
+			end
+			_result_1 = _condition_1
+		end
+		return _result_1
+	end
+	while bootClock() < finalAt and others() > 0 do
+		port.wait(0)
+	end
+	engine.finalPhase = true
+	for _, runtime in engine.profiles do
+		for _1, session in runtime.sessions do
+			if session.phase == 1 then
+				runtime:release(session, "shutdown")
+			end
+		end
+	end
+	while bootClock() < settleAt and pending(engine) do
+		port.wait(0)
+	end
+	engine.settled = true
+	engine:wake()
+end
+return {
+	shutdownData = shutdownData,
+}

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

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

package/out/internal/data/waiters.luau

@@ -0,0 +1,65 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local bootClock = TS.import(script, script.Parent.Parent, "boot").bootClock
+--[[
+	*
+	 * @internal Threads parked until a wake or their deadline. Callers re-check their condition in a loop, so a spurious
+	 * wake costs one check. A park id guards each resume, so a stale deadline timer never resumes a later park.
+	 
+]]
+local Waiters
+do
+	Waiters = setmetatable({}, {
+		__tostring = function()
+			return "Waiters"
+		end,
+	})
+	Waiters.__index = Waiters
+	function Waiters.new(...)
+		local self = setmetatable({}, Waiters)
+		return self:constructor(...) or self
+	end
+	function Waiters:constructor(port)
+		self.port = port
+		self.parked = {}
+		self.sequence = 0
+	end
+	function Waiters:park(deadline)
+		local thread = coroutine.running()
+		self.sequence += 1
+		local id = self.sequence
+		self.parked[thread] = id
+		local fired = false
+		local timer = if deadline == nil then nil else self.port.delay(math.max(deadline - bootClock(), 0), function()
+			fired = true
+			if self.parked[thread] ~= id then
+				return nil
+			end
+			self.parked[thread] = nil
+			self.port.resume(thread)
+		end)
+		coroutine.yield()
+		self.parked[thread] = nil
+		if timer ~= nil and not fired then
+			self.port.cancel(timer)
+		end
+	end
+	function Waiters:wake()
+		local threads = {}
+		for thread, id in self.parked do
+			local _arg0 = { thread, id }
+			table.insert(threads, _arg0)
+		end
+		table.clear(self.parked)
+		table.sort(threads, function(a, b)
+			return a[2] < b[2]
+		end)
+		for _, _binding in threads do
+			local thread = _binding[1]
+			self.port.resume(thread)
+		end
+	end
+end
+return {
+	Waiters = Waiters,
+}

package/out/internal/dense-list.d.ts

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

package/out/internal/dense-list.luau

@@ -0,0 +1,155 @@
+-- Compiled with roblox-ts v3.0.0
+local function walk(items, stop, visit)
+	do
+		local i = 0
+		local _shouldIncrement = false
+		while true do
+			if _shouldIncrement then
+				i += 1
+			else
+				_shouldIncrement = true
+			end
+			if not (i < stop) then
+				break
+			end
+			local item = items[i + 1]
+			if item ~= nil then
+				visit(item)
+			end
+		end
+	end
+end
+--[[
+	*
+	 * @internal
+	 * Ordered list with O(1) append, O(1) removal by tombstone, and allocation-free iteration. Holes are
+	 * `end - count`. An append always writes at `end`, so no slot is reused until compaction, which runs outside a
+	 * walk once holes pass half the slots. Outside a walk `end <= 2 * count`, so a walk touches at most twice the
+	 * members and compaction costs at most twice the removals. Iteration order is insertion order and survives any
+	 * mutation from inside a visit. Items appended during `forEach` are visited by the next call, not this one.
+	 
+]]
+local DenseList
+do
+	DenseList = setmetatable({}, {
+		__tostring = function()
+			return "DenseList"
+		end,
+	})
+	DenseList.__index = DenseList
+	function DenseList.new(...)
+		local self = setmetatable({}, DenseList)
+		return self:constructor(...) or self
+	end
+	function DenseList:constructor()
+		self.items = {}
+		self.slots = {}
+		self["end"] = 0
+		self.count = 0
+		self.depth = 0
+	end
+	function DenseList:size()
+		return self.count
+	end
+	function DenseList:has(item)
+		local _slots = self.slots
+		local _item = item
+		return _slots[_item] ~= nil
+	end
+	function DenseList:add(item)
+		local _slots = self.slots
+		local _item = item
+		if _slots[_item] ~= nil then
+			return false
+		end
+		self.items[self["end"] + 1] = item
+		local _slots_1 = self.slots
+		local _item_1 = item
+		local _arg1 = self["end"]
+		_slots_1[_item_1] = _arg1
+		self["end"] += 1
+		self.count += 1
+		return true
+	end
+	function DenseList:remove(item)
+		local _slots = self.slots
+		local _item = item
+		local slot = _slots[_item]
+		if slot == nil then
+			return false
+		end
+		self.items[slot + 1] = nil
+		local _slots_1 = self.slots
+		local _item_1 = item
+		_slots_1[_item_1] = nil
+		self.count -= 1
+		self:compactIfSparse()
+		return true
+	end
+	function DenseList:forEach(visit)
+		self.depth += 1
+		local ok, err = pcall(walk, self.items, self["end"], visit)
+		self.depth -= 1
+		self:compactIfSparse()
+		if not ok then
+			error(err, 0)
+		end
+	end
+	function DenseList:first()
+		do
+			local i = 0
+			local _shouldIncrement = false
+			while true do
+				if _shouldIncrement then
+					i += 1
+				else
+					_shouldIncrement = true
+				end
+				if not (i < self["end"]) then
+					break
+				end
+				local item = self.items[i + 1]
+				if item ~= nil then
+					return item
+				end
+			end
+		end
+		return nil
+	end
+	function DenseList:compactIfSparse()
+		if self.depth > 0 or self["end"] - self.count <= self["end"] / 2 then
+			return nil
+		end
+		local write = 0
+		do
+			local read = 0
+			local _shouldIncrement = false
+			while true do
+				if _shouldIncrement then
+					read += 1
+				else
+					_shouldIncrement = true
+				end
+				if not (read < self["end"]) then
+					break
+				end
+				local item = self.items[read + 1]
+				if item == nil then
+					continue
+				end
+				if read ~= write then
+					self.items[write + 1] = item
+					self.items[read + 1] = nil
+					local _slots = self.slots
+					local _write = write
+					_slots[item] = _write
+				end
+				write += 1
+			end
+		end
+		self["end"] = write
+	end
+end
+return {
+	DenseList = DenseList,
+}

package/out/internal/diagnostics.d.ts

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

package/out/internal/diagnostics.luau

@@ -0,0 +1,29 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local loggingPort = TS.import(script, script.Parent, "log-output").loggingPort
+local emitting = false
+local terminal = false
+--* @internal 
+local function runtimeDiagnostic(level, message)
+	if not emitting then
+		emitting = true
+		local ok = pcall(function()
+			return loggingPort().writeInternal(level, message)
+		end)
+		emitting = false
+		if ok then
+			return nil
+		end
+	end
+	if terminal then
+		return nil
+	end
+	terminal = true
+	pcall(function()
+		return warn(`[Crucible] {message}`)
+	end)
+	terminal = false
+end
+return {
+	runtimeDiagnostic = runtimeDiagnostic,
+}

package/out/internal/hooks.d.ts

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

package/out/internal/hooks.luau

@@ -0,0 +1,53 @@
+-- Compiled with roblox-ts v3.0.0
+--* @internal 
+--* @internal 
+--* @internal 
+local FRAME_HOOK_NAMES = { "preRender", "fixedUpdate", "update", "lateUpdate" }
+--* @internal 
+local OBJECT_HOOK_NAMES = { "awake", "start", "fixedUpdate", "update", "lateUpdate", "preRender" }
+--* @internal 
+local BEHAVIOUR_HOOK_NAMES = { "onEnable", "onDisable", "onDestroy" }
+--* @internal 
+--* @internal 
+--* @internal 
+local SUBSYSTEM_HOOK_NAMES = { "onShutdown" }
+--* @internal 
+local subsystemHooks
+--* @internal 
+local function installSubsystemHooks(value)
+	subsystemHooks = value
+end
+--* @internal 
+local function shutdownHooks()
+	return subsystemHooks or error("Subsystem hooks not installed")
+end
+local objectHooks
+local behaviourHooks
+--* @internal 
+local function installObjectHooks(hooks)
+	objectHooks = hooks
+end
+--* @internal 
+local function installBehaviourHooks(hooks)
+	behaviourHooks = hooks
+end
+--* @internal 
+local function hooks()
+	return objectHooks or error("Crucible hooks used before CrucibleObject loaded")
+end
+--* @internal 
+local function lifecycleHooks()
+	return behaviourHooks or error("Crucible hooks used before CrucibleObject loaded")
+end
+return {
+	installSubsystemHooks = installSubsystemHooks,
+	shutdownHooks = shutdownHooks,
+	installObjectHooks = installObjectHooks,
+	installBehaviourHooks = installBehaviourHooks,
+	hooks = hooks,
+	lifecycleHooks = lifecycleHooks,
+	FRAME_HOOK_NAMES = FRAME_HOOK_NAMES,
+	OBJECT_HOOK_NAMES = OBJECT_HOOK_NAMES,
+	BEHAVIOUR_HOOK_NAMES = BEHAVIOUR_HOOK_NAMES,
+	SUBSYSTEM_HOOK_NAMES = SUBSYSTEM_HOOK_NAMES,
+}

package/out/internal/implementers.d.ts

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