@trioforge/crucible 0.1.0 → 0.2.0

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

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

package/out/internal/data/receipts.luau

@@ -0,0 +1,190 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local bootClock = TS.import(script, script.Parent.Parent, "boot").bootClock
+local jsonBytes = TS.import(script, script.Parent, "envelope").jsonBytes
+local _limits = TS.import(script, script.Parent, "limits")
+local LOAD_DEADLINE_SECONDS = _limits.LOAD_DEADLINE_SECONDS
+local MAX_PURCHASE_IDS = _limits.MAX_PURCHASE_IDS
+local PURCHASE_ID_MAX_BYTES = _limits.PURCHASE_ID_MAX_BYTES
+local RECEIPT_SAVE_TIMEOUT_SECONDS = _limits.RECEIPT_SAVE_TIMEOUT_SECONDS
+local RECEIPTS_MAX_BYTES = _limits.RECEIPTS_MAX_BYTES
+--* @internal The part of Roblox's receipt info that data reads. 
+--* @internal A developer product purchase, as a grant callback sees it. 
+--* @internal Stages an effect that runs once, after the grant is durable (rule 61). 
+--* @internal 
+--* @internal The profile store and grant callback that handle one developer product. 
+--* @internal MarketplaceService, as far as the router uses it. 
+--[[
+	*
+	 * @internal Crucible's ProcessReceipt (rules 57 to 64). Idempotency rests on two facts: a purchase id and its grant's
+	 * data change are one revision, and "granted" is returned only once an owned write with the session's token is
+	 * confirmed to hold the id. Purchase ids are never evicted.
+	 
+]]
+local ReceiptRouter
+do
+	ReceiptRouter = setmetatable({}, {
+		__tostring = function()
+			return "ReceiptRouter"
+		end,
+	})
+	ReceiptRouter.__index = ReceiptRouter
+	function ReceiptRouter.new(...)
+		local self = setmetatable({}, ReceiptRouter)
+		return self:constructor(...) or self
+	end
+	function ReceiptRouter:constructor(engine)
+		self.engine = engine
+		self.routes = {}
+		self.closed = false
+	end
+	function ReceiptRouter:route(productId, route)
+		local _routes = self.routes
+		local _productId = productId
+		local _route = route
+		_routes[_productId] = _route
+	end
+	function ReceiptRouter:unroute(productId)
+		local _routes = self.routes
+		local _productId = productId
+		_routes[_productId] = nil
+	end
+	function ReceiptRouter:install(service)
+		self.service = service
+		service.ProcessReceipt = function(info)
+			return self:decision(self:process(info))
+		end
+	end
+	function ReceiptRouter:decision(result)
+		return if result == "granted" then Enum.ProductPurchaseDecision.PurchaseGranted else Enum.ProductPurchaseDecision.NotProcessedYet
+	end
+	function ReceiptRouter:close(retire)
+		if retire == nil then
+			retire = false
+		end
+		self.closed = true
+		if retire and self.service ~= nil then
+			self.service.ProcessReceipt = function()
+				return Enum.ProductPurchaseDecision.NotProcessedYet
+			end
+		end
+	end
+	function ReceiptRouter:process(info)
+		local engine = self.engine
+		local holdUntil = bootClock() + LOAD_DEADLINE_SECONDS
+		while true do
+			if self.closed then
+				return "notYet"
+			end
+			local _routes = self.routes
+			local _productId = info.ProductId
+			local route = _routes[_productId]
+			if route == nil then
+				engine:diagnose(`product:{info.ProductId}`, `a purchase of product {info.ProductId} was refused: no grant handles it`)
+				return "notYet"
+			end
+			local id = info.PurchaseId
+			if not (type(id) == "string") or #id < 1 or #id > PURCHASE_ID_MAX_BYTES then
+				engine:diagnose(`receipt-id:{info.ProductId}`, `a purchase of product {info.ProductId} was refused: its purchase id is not 1 to {PURCHASE_ID_MAX_BYTES} bytes`)
+				return "notYet"
+			end
+			local player = engine.port.players.byUserId(info.PlayerId)
+			if player == nil then
+				return "notYet"
+			end
+			local runtime = route.runtime
+			local session = runtime.sessions[player]
+			if session == nil or session.phase == 0 or session.sealedBy == "handoff" then
+				if bootClock() >= holdUntil then
+					return "notYet"
+				end
+				runtime.changed:park(holdUntil)
+				continue
+			end
+			if not runtime:writable(player) then
+				return "notYet"
+			end
+			if session.durable[id] ~= nil then
+				return self:granted(session, id)
+			end
+			return self:save(route, session, player, id, info)
+		end
+	end
+	function ReceiptRouter:save(route, session, player, id, info)
+		local runtime = route.runtime
+		local engine = self.engine
+		local _receipts = session.receipts
+		local _id = id
+		if not (table.find(_receipts, _id) ~= nil) then
+			if #session.receipts >= MAX_PURCHASE_IDS or jsonBytes(session.receipts) + jsonBytes(id) + 1 > RECEIPTS_MAX_BYTES then
+				engine:diagnose(`receipt-capacity:{session.token}`, `receipt capacity reached for {runtime.schema.name} {session.userId}`)
+				return "notYet"
+			end
+			local purchase = {
+				id = id,
+				productId = info.ProductId,
+				currencySpent = info.CurrencySpent,
+			}
+			local effects = {}
+			local afterGrant = function(effect)
+				local _effect = effect
+				if not (type(_effect) == "function") then
+					error("afterGrant takes a function", 2)
+				end
+				local _effect_1 = effect
+				table.insert(effects, _effect_1)
+			end
+			local ok = pcall(function()
+				return session:write(function(data)
+					return route.grant(player, data, purchase, afterGrant)
+				end, function()
+					session:stage(id)
+					local _effects = session.effects
+					local _id_1 = id
+					_effects[_id_1] = effects
+				end)
+			end)
+			if not ok then
+				engine:diagnose(`grant:{runtime.schema.name}:{info.ProductId}`, `{runtime.schema.name}: the grant for product {info.ProductId} threw, yielded or returned an invalid value; nothing was stored`)
+				return "notYet"
+			end
+		end
+		runtime:requestWrite(session, 2)
+		local timeout = bootClock() + RECEIPT_SAVE_TIMEOUT_SECONDS
+		while true do
+			local _durable = session.durable
+			local _id_1 = id
+			local _condition = not (_durable[_id_1] ~= nil)
+			if _condition then
+				_condition = session.phase ~= 3 and bootClock() < timeout and not engine.settled
+			end
+			if not _condition then
+				break
+			end
+			runtime.changed:park(timeout)
+		end
+		local _durable = session.durable
+		local _id_1 = id
+		return if _durable[_id_1] ~= nil then self:granted(session, id) else "notYet"
+	end
+	function ReceiptRouter:granted(session, id)
+		local _effects = session.effects
+		local _id = id
+		local effects = _effects[_id]
+		local _effects_1 = session.effects
+		local _id_1 = id
+		_effects_1[_id_1] = nil
+		for _, effect in effects or {} do
+			self.engine.port.spawn(function()
+				local ok = pcall(effect)
+				if not ok then
+					self.engine:diagnose(`effect:{session.token}:{id}`, `an afterGrant effect for {session.schema.name} {session.userId} threw`)
+				end
+			end)
+		end
+		return "granted"
+	end
+end
+return {
+	ReceiptRouter = ReceiptRouter,
+}

package/out/internal/data/record-bindings.d.ts

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

package/out/internal/data/record-bindings.luau

@@ -0,0 +1,92 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local bootClock = TS.import(script, script.Parent.Parent, "boot").bootClock
+local CALL_DEADLINE_SECONDS = TS.import(script, script.Parent, "limits").CALL_DEADLINE_SECONDS
+local dataPort = TS.import(script, script.Parent, "port").dataPort
+local _record_declarations = TS.import(script, script.Parent, "record-declarations")
+local declaredRecords = _record_declarations.declaredRecords
+local installRecordDriver = _record_declarations.installRecordDriver
+local RecordStore = TS.import(script, script.Parent, "records").RecordStore
+local Waiters = TS.import(script, script.Parent, "waiters").Waiters
+local bound = {}
+local activation
+--* @internal Rule 104: gives every declared record store its engine, and wakes calls waiting for activation. 
+local function bindRecords(engine)
+	for name, declaration in declaredRecords() do
+		local _recordStore = RecordStore.new(engine, declaration.schema)
+		bound[name] = _recordStore
+	end
+	local _result = activation
+	if _result ~= nil then
+		_result:wake()
+	end
+end
+--* @internal 
+local function unbindRecords()
+	table.clear(bound)
+end
+--* Rule 4: before activation a call waits for it, within its own deadline. 
+local function activated(name)
+	local deadline = bootClock() + CALL_DEADLINE_SECONDS
+	while true do
+		local _name = name
+		local _condition = bound[_name] == nil
+		if _condition then
+			_condition = bootClock() < deadline
+		end
+		if not _condition then
+			break
+		end
+		if activation == nil then
+			activation = Waiters.new(dataPort())
+		end
+		activation:park(deadline)
+	end
+	local _name = name
+	return bound[_name]
+end
+local function publicResult(result)
+	return if result.kind == "ok" then {
+		ok = true,
+		value = result.value,
+	} else {
+		ok = false,
+		reason = result.kind,
+	}
+end
+local function publicUpdate(result)
+	return if result.kind == "ok" then {
+		ok = true,
+		value = result.value,
+		replayed = result.replayed,
+	} else {
+		ok = false,
+		reason = result.kind,
+	}
+end
+installRecordDriver({
+	read = function(self, name, key)
+		local store = activated(name)
+		if store == nil then
+			return {
+				ok = false,
+				reason = "timeout",
+			}
+		end
+		return publicResult(store:read(key))
+	end,
+	update = function(self, name, key, change, id)
+		local store = activated(name)
+		if store == nil then
+			return {
+				ok = false,
+				reason = "timeout",
+			}
+		end
+		return publicUpdate(store:update(key, change, id))
+	end,
+})
+return {
+	bindRecords = bindRecords,
+	unbindRecords = unbindRecords,
+}

package/out/internal/data/record-declarations.d.ts

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

package/out/internal/data/record-declarations.luau

@@ -0,0 +1,140 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local sealSchema = TS.import(script, script.Parent, "admission").sealSchema
+local _limits = TS.import(script, script.Parent, "limits")
+local MAX_DATA_DECLARATIONS = _limits.MAX_DATA_DECLARATIONS
+local STORE_NAME_MAX_BYTES = _limits.STORE_NAME_MAX_BYTES
+--* @internal 
+--[[
+	*
+	 * @internal What a declared store's calls run on once DataRuntime activates. This module is reached from the emit
+	 * entry, so it imports nothing that loads boot; `record-bindings.ts` installs the driver.
+	 
+]]
+local declarations = {}
+local sealed = false
+local driver
+local profiles = {}
+--* @internal Rule 2: profile and generic stores share one index of store names. 
+local function storeNameTaken(name)
+	local _name = name
+	local _condition = declarations[_name] ~= nil
+	if not _condition then
+		local _name_1 = name
+		_condition = profiles[_name_1] ~= nil
+	end
+	return _condition
+end
+--* @internal Rule 3: every data declaration in this realm counts toward MAX_DATA_DECLARATIONS. 
+local function dataDeclarationCount()
+	-- ▼ ReadonlyMap.size ▼
+	local _size = 0
+	for _ in declarations do
+		_size += 1
+	end
+	-- ▲ ReadonlyMap.size ▲
+	-- ▼ ReadonlySet.size ▼
+	local _size_1 = 0
+	for _ in profiles do
+		_size_1 += 1
+	end
+	-- ▲ ReadonlySet.size ▲
+	return _size + _size_1
+end
+--* @internal 
+local function registerProfileName(name)
+	local _name = name
+	profiles[_name] = true
+end
+--* @internal True after DataRuntime constructed (rule 3). 
+local function dataRegistrySealed()
+	return sealed
+end
+--* @internal Rule 2's grammar: dot-separated `[A-Za-z][A-Za-z0-9_]*` segments, with `Crucible` reserved as the first. 
+local function checkStoreName(name)
+	if #name == 0 or #name > STORE_NAME_MAX_BYTES then
+		error(`{name}: a store name is 1 to {STORE_NAME_MAX_BYTES} bytes`, 4)
+	end
+	local segments = string.split(name, ".")
+	for _, segment in segments do
+		if (string.match(segment, "^[A-Za-z][A-Za-z0-9_]*$")) == nil then
+			error(`{name}: a store name is dot-separated segments of letters, digits and underscores`, 4)
+		end
+	end
+	if segments[1] == "Crucible" then
+		error(`{name}: the name Crucible is reserved`, 4)
+	end
+end
+--* @internal Rule 3: DataRuntime seals the registry when it constructs; a failed boot unseals it. 
+local function sealDeclarations(value)
+	sealed = value
+end
+--* @internal The declarations a DataRuntime binds at activation (rule 104). 
+local function declaredRecords()
+	return declarations
+end
+--* @internal 
+local function installRecordDriver(value)
+	driver = value
+end
+local function installed(name)
+	if driver == nil then
+		error(`{name}: the data runtime is not loaded; import @trioforge/crucible/server`, 3)
+	end
+	return driver
+end
+--[[
+	*
+	 * @internal Rules 4 and 85: the emit form's body. Admits and freezes `defaults` with `value`, registers the name, and
+	 * returns a frozen handle whose two calls bind to the engine at activation.
+	 
+]]
+local function declareRecords(name, defaults, migrations, value)
+	checkStoreName(name)
+	if sealed then
+		error(`{name} was declared after the data registry sealed; declare stores in modules that boot loads`, 3)
+	end
+	if storeNameTaken(name) then
+		error(`{name} is already declared`, 3)
+	end
+	if dataDeclarationCount() >= MAX_DATA_DECLARATIONS then
+		error(`{name}: more than {MAX_DATA_DECLARATIONS} data declarations`, 3)
+	end
+	local _array = {}
+	local _length = #_array
+	local _array_1 = (migrations or {})
+	table.move(_array_1, 1, #_array_1, _length + 1, _array)
+	local steps = _array
+	local schema = sealSchema({
+		name = name,
+		version = #steps,
+		defaults = defaults,
+		node = value,
+		migrations = steps,
+	})
+	local _name = name
+	local _arg1 = {
+		name = name,
+		schema = schema,
+	}
+	declarations[_name] = _arg1
+	return table.freeze({
+		read = function(self, key)
+			return installed(name):read(name, key)
+		end,
+		update = function(self, key, change, id)
+			return installed(name):update(name, key, change, id)
+		end,
+	})
+end
+return {
+	storeNameTaken = storeNameTaken,
+	dataDeclarationCount = dataDeclarationCount,
+	registerProfileName = registerProfileName,
+	dataRegistrySealed = dataRegistrySealed,
+	checkStoreName = checkStoreName,
+	sealDeclarations = sealDeclarations,
+	declaredRecords = declaredRecords,
+	installRecordDriver = installRecordDriver,
+	declareRecords = declareRecords,
+}

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

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