@trioforge/crucible 0.1.0 → 0.2.0

package/out/internal/sync/values.luau

@@ -0,0 +1,930 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _codec = TS.import(script, script.Parent.Parent, "network", "codec")
+local checkFrame = _codec.frame
+local validString = _codec.validString
+local _limits = TS.import(script, script.Parent.Parent, "reactive", "limits")
+local SYNC_ADMISSION_VISITS = _limits.SYNC_ADMISSION_VISITS
+local SYNC_FRAME_BYTES = _limits.SYNC_FRAME_BYTES
+local SYNC_FRAME_COLLECTION_ENTRIES = _limits.SYNC_FRAME_COLLECTION_ENTRIES
+local SYNC_FRAME_VALUE_VISITS = _limits.SYNC_FRAME_VALUE_VISITS
+local SYNC_STRING_BYTES = _limits.SYNC_STRING_BYTES
+local SYNC_VALUE_DEPTH = _limits.SYNC_VALUE_DEPTH
+--* @internal What the dynamic codec charges for a value: wire.md's bytes, entries and visits, and table nesting. 
+--* @internal A peer examination's visit budget. A visit that would pass `limit` is not made. 
+--* @internal Thrown when a visit would pass a `Work` limit: the peer is over budget, not the value. 
+local OVER_BUDGET = table.freeze({
+	overBudget = true,
+})
+--* @internal 
+local function isOverBudget(err)
+	return rawequal(err, OVER_BUDGET)
+end
+--* @internal Charges one visit to `work`, checked before it is made. 
+local function spend(work)
+	if work.visits >= work.limit then
+		error(OVER_BUDGET)
+	end
+	work.visits += 1
+end
+local function weak()
+	return setmetatable({}, {
+		__mode = "k",
+	})
+end
+--* @internal A descriptor compiled for admission: lookups by name and by discriminant, and a conformance cache. 
+local RUNTIME_KINDS = {
+	bool = "boolean",
+	f64 = "number",
+	f32 = "number",
+	u8 = "number",
+	u16 = "number",
+	u32 = "number",
+	string = "string",
+	vector3 = "Vector3",
+	color3 = "Color3",
+	cframe = "CFrame",
+}
+local function admitsNil(plan)
+	return plan.kind == "nil" or (plan.kind == "union" and plan["nil"] ~= nil)
+end
+--* @internal Compiles a descriptor the codec already accepted. Shared subtrees compile once. 
+local function compilePlan(root)
+	local memo = {}
+	local build
+	local function object(fields, extra)
+		local byName = {}
+		local order = {}
+		local optional = {}
+		for _, _binding in fields do
+			local name = _binding[1]
+			local child = _binding[2]
+			local plan = build(child)
+			byName[name] = plan
+			table.insert(order, name)
+			if admitsNil(plan) then
+				optional[name] = true
+			end
+		end
+		if extra ~= nil then
+			local _arg0 = extra[1]
+			local _arg1 = {
+				kind = "literal",
+				value = extra[2],
+			}
+			byName[_arg0] = _arg1
+			local _arg0_1 = extra[1]
+			table.insert(order, _arg0_1)
+		end
+		return {
+			kind = "object",
+			fields = byName,
+			order = order,
+			optional = optional,
+			conforms = weak(),
+		}
+	end
+	function build(node)
+		local _node = node
+		local known = memo[_node]
+		if known ~= nil then
+			return known
+		end
+		local plan
+		local _exp = node.kind
+		repeat
+			local _fallthrough = false
+			if _exp == "nil" then
+				_fallthrough = true
+			end
+			if _fallthrough or _exp == "bool" then
+				_fallthrough = true
+			end
+			if _fallthrough or _exp == "string" then
+				_fallthrough = true
+			end
+			if _fallthrough or _exp == "vector3" then
+				_fallthrough = true
+			end
+			if _fallthrough or _exp == "color3" then
+				_fallthrough = true
+			end
+			if _fallthrough or _exp == "cframe" then
+				plan = {
+					kind = node.kind,
+				}
+				break
+			end
+			if _exp == "f64" then
+				_fallthrough = true
+			end
+			if _fallthrough or _exp == "f32" then
+				_fallthrough = true
+			end
+			if _fallthrough or _exp == "u8" then
+				_fallthrough = true
+			end
+			if _fallthrough or _exp == "u16" then
+				_fallthrough = true
+			end
+			if _fallthrough or _exp == "u32" then
+				plan = {
+					kind = "number",
+					width = node.kind,
+				}
+				break
+			end
+			if _exp == "literal" then
+				plan = {
+					kind = "literal",
+					value = node.value,
+				}
+				break
+			end
+			if _exp == "instance" then
+				plan = {
+					kind = "refuse",
+					reason = "replicated state cannot hold Instances; replicate a stable id",
+				}
+				break
+			end
+			if _exp == "dynamic" then
+				plan = {
+					kind = "refuse",
+					reason = "replicated state cannot hold an unknown value",
+				}
+				break
+			end
+			if _exp == "object" then
+				plan = object(node.fields)
+				break
+			end
+			if _exp == "variant" then
+				plan = object(node.body.fields, { node.key, node.value })
+				break
+			end
+			if _exp == "array" then
+				plan = {
+					kind = "array",
+					element = build(node.element),
+					conforms = weak(),
+				}
+				break
+			end
+			if _exp == "tuple" then
+				local _object = {
+					kind = "tuple",
+				}
+				local _left = "elements"
+				local _exp_1 = node.elements
+				-- ▼ ReadonlyArray.map ▼
+				local _newValue = table.create(#_exp_1)
+				for _k, _v in _exp_1 do
+					_newValue[_k] = build(_v, _k - 1, _exp_1)
+				end
+				-- ▲ ReadonlyArray.map ▲
+				_object[_left] = _newValue
+				_object.conforms = weak()
+				plan = _object
+				break
+			end
+			if _exp == "map" then
+				local keys
+				if node.key.kind == "union" then
+					keys = {}
+					for _, branch in node.key.branches do
+						local _keys = keys
+						local _arg0 = tostring(branch.value)
+						_keys[_arg0] = true
+					end
+				end
+				plan = {
+					kind = "map",
+					keys = keys,
+					value = build(node.value),
+					conforms = weak(),
+				}
+				break
+			end
+			if _exp == "union" then
+				local literals = {}
+				local variants = {}
+				local kinds = {}
+				local absent
+				local discriminant
+				for _, branch in node.branches do
+					local child = build(branch)
+					if branch.kind == "nil" then
+						absent = child
+					elseif branch.kind == "literal" then
+						local _value = branch.value
+						literals[_value] = child
+					elseif branch.kind == "variant" then
+						discriminant = branch.key
+						local _value = branch.value
+						variants[_value] = child
+					else
+						local _condition = RUNTIME_KINDS[branch.kind]
+						if _condition == nil then
+							_condition = "table"
+						end
+						kinds[_condition] = child
+					end
+				end
+				plan = {
+					kind = "union",
+					["nil"] = absent,
+					literals = literals,
+					discriminant = discriminant,
+					variants = variants,
+					kinds = kinds,
+				}
+				break
+			end
+		until true
+		local _node_1 = node
+		local _plan = plan
+		memo[_node_1] = _plan
+		return plan
+	end
+	return build(root)
+end
+local costs = setmetatable({}, {
+	__mode = "k",
+})
+local function varuintSize(value)
+	local size = 1
+	while value >= 128 do
+		value = math.floor(value / 128)
+		size += 1
+	end
+	return size
+end
+local function stringBytes(text)
+	return varuintSize(#text) + #text
+end
+--* @internal A leaf's dynamic cost, or an admitted table's cached cost. 
+local function costOf(value)
+	local _value = value
+	if type(_value) == "table" then
+		local _value_1 = value
+		local _condition = costs[_value_1]
+		if _condition == nil then
+			_condition = error("Crucible sync: costing a value admission never saw")
+		end
+		return _condition
+	end
+	local bytes = 1
+	local _value_1 = value
+	if type(_value_1) == "number" then
+		bytes = 9
+	else
+		local _value_2 = value
+		if type(_value_2) == "string" then
+			bytes = 1 + stringBytes(value)
+		else
+			local _value_3 = value
+			local _condition = typeof(_value_3) == "Vector3"
+			if not _condition then
+				local _value_4 = value
+				_condition = typeof(_value_4) == "Color3"
+			end
+			if _condition then
+				bytes = 25
+			else
+				local _value_4 = value
+				if typeof(_value_4) == "CFrame" then
+					bytes = 97
+				end
+			end
+		end
+	end
+	return {
+		bytes = bytes,
+		entries = 0,
+		visits = 1,
+		height = 0,
+	}
+end
+local function describe(value)
+	local _result
+	if value == nil then
+		_result = "nil"
+	else
+		local _value = value
+		_result = typeof(_value)
+	end
+	return _result
+end
+local Admission
+do
+	Admission = setmetatable({}, {
+		__tostring = function()
+			return "Admission"
+		end,
+	})
+	Admission.__index = Admission
+	function Admission.new(...)
+		local self = setmetatable({}, Admission)
+		return self:constructor(...) or self
+	end
+	function Admission:constructor(name, work)
+		self.name = name
+		self.work = work
+		self.steps = 0
+		self.bytes = 0
+		self.entries = 0
+		self.visits = 0
+		self.depth = 0
+		self.height = 0
+		self.active = {}
+		self.pending = {}
+	end
+	function Admission:reject(path, reason)
+		error(`{self.name}{path}: {reason}`, 0)
+	end
+	function Admission:step(path)
+		if self.work ~= nil then
+			spend(self.work)
+		end
+		if self.steps >= SYNC_ADMISSION_VISITS then
+			self:reject(path, "over SYNC_ADMISSION_VISITS")
+		end
+		self.steps += 1
+	end
+	function Admission:charge(bytes, entries, visits, path)
+		self.bytes += bytes
+		self.entries += entries
+		self.visits += visits
+		if self.bytes > SYNC_FRAME_BYTES then
+			self:reject(path, "over SYNC_FRAME_BYTES")
+		end
+		if self.entries > SYNC_FRAME_COLLECTION_ENTRIES then
+			self:reject(path, "over SYNC_FRAME_COLLECTION_ENTRIES")
+		end
+		if self.visits > SYNC_FRAME_VALUE_VISITS then
+			self:reject(path, "over SYNC_FRAME_VALUE_VISITS")
+		end
+	end
+	function Admission:chargeLeaf(value, path)
+		local cost = costOf(value)
+		self:charge(cost.bytes, 0, 1, path)
+	end
+	function Admission:open(plan, value, path)
+		local _value = value
+		if not (type(_value) == "table") then
+			self:reject(path, `expected table, got {describe(value)}`)
+		end
+		if getmetatable(value) ~= nil then
+			self:reject(path, "metatable")
+		end
+		local _active = self.active
+		local _value_1 = value
+		if _active[_value_1] ~= nil then
+			self:reject(path, "cycle")
+		end
+		local _condition = table.isfrozen(value)
+		if _condition then
+			local _conforms = plan.conforms
+			local _value_2 = value
+			_condition = _conforms[_value_2] ~= nil
+		end
+		if _condition then
+			local _value_2 = value
+			local cost = costs[_value_2]
+			if self.depth + cost.height > SYNC_VALUE_DEPTH then
+				self:reject(path, "deeper than SYNC_VALUE_DEPTH")
+			end
+			self:charge(cost.bytes, cost.entries, cost.visits, path)
+			self.height = math.max(self.height, cost.height)
+			return value
+		end
+		return nil
+	end
+	function Admission:nest(plan, value, path, walk)
+		self.depth += 1
+		if self.depth > SYNC_VALUE_DEPTH then
+			self:reject(path, "deeper than SYNC_VALUE_DEPTH")
+		end
+		local _active = self.active
+		local _value = value
+		_active[_value] = true
+		local outer = self.height
+		self.height = 0
+		local bytes, entries, visits = self.bytes, self.entries, self.visits
+		local result = walk()
+		local height = self.height + 1
+		local _pending = self.pending
+		local _arg0 = {
+			plan = plan,
+			value = result,
+			cost = {
+				bytes = self.bytes - bytes,
+				entries = self.entries - entries,
+				visits = self.visits - visits,
+				height = height,
+			},
+		}
+		table.insert(_pending, _arg0)
+		self.height = math.max(outer, height)
+		local _active_1 = self.active
+		local _value_1 = value
+		_active_1[_value_1] = nil
+		self.depth -= 1
+		return result
+	end
+end
+local function admitNumber(a, width, value, path)
+	local _value = value
+	if not (type(_value) == "number") then
+		a:reject(path, `expected number, got {describe(value)}`)
+	end
+	if value ~= value or math.abs(value) == math.huge then
+		a:reject(path, "expected finite number")
+	end
+	if width == "f32" then
+		local scratch = buffer.create(4)
+		buffer.writef32(scratch, 0, value)
+		if math.abs(buffer.readf32(scratch, 0)) == math.huge then
+			a:reject(path, "f32 out of range")
+		end
+	elseif width ~= "f64" then
+		local maximum = if width == "u8" then 255 elseif width == "u16" then 65535 else 4294967295
+		if value < 0 or value > maximum or value % 1 ~= 0 then
+			a:reject(path, `{width} out of range`)
+		end
+	end
+end
+local function admitString(a, value, path)
+	local _value = value
+	if not (type(_value) == "string") then
+		a:reject(path, `expected string, got {describe(value)}`)
+	end
+	if #value > SYNC_STRING_BYTES then
+		a:reject(path, "longer than SYNC_STRING_BYTES")
+	end
+	local ok = pcall(validString, value)
+	if not ok then
+		a:reject(path, "invalid UTF-8")
+	end
+end
+local admitObject, admitArray, admitMap, admitUnion
+local function admitNode(a, plan, value, path)
+	a:step(path)
+	local _exp = plan.kind
+	repeat
+		local _fallthrough = false
+		if _exp == "nil" then
+			if value ~= nil then
+				a:reject(path, `expected nil, got {describe(value)}`)
+			end
+			break
+		end
+		if _exp == "bool" then
+			local _value = value
+			if not (type(_value) == "boolean") then
+				a:reject(path, `expected boolean, got {describe(value)}`)
+			end
+			break
+		end
+		if _exp == "number" then
+			admitNumber(a, plan.width, value, path)
+			break
+		end
+		if _exp == "string" then
+			admitString(a, value, path)
+			break
+		end
+		if _exp == "literal" then
+			if value ~= plan.value then
+				a:reject(path, `expected a declared literal, got {describe(value)}`)
+			end
+			local _value = value
+			if type(_value) == "string" then
+				admitString(a, value, path)
+			end
+			break
+		end
+		if _exp == "vector3" then
+			local _value = value
+			if not (typeof(_value) == "Vector3") then
+				a:reject(path, `expected Vector3, got {describe(value)}`)
+			end
+			for _, component in { value.X, value.Y, value.Z } do
+				if component ~= component or math.abs(component) == math.huge then
+					a:reject(path, "expected finite number")
+				end
+			end
+			break
+		end
+		if _exp == "color3" then
+			local _value = value
+			if not (typeof(_value) == "Color3") then
+				a:reject(path, `expected Color3, got {describe(value)}`)
+			end
+			for _, component in { value.R, value.G, value.B } do
+				if component ~= component or math.abs(component) == math.huge then
+					a:reject(path, "expected finite number")
+				end
+			end
+			break
+		end
+		if _exp == "cframe" then
+			local _value = value
+			if not (typeof(_value) == "CFrame") then
+				a:reject(path, `expected CFrame, got {describe(value)}`)
+			end
+			local _array = {}
+			local _length = #_array
+			local _array_1 = { value:GetComponents() }
+			table.move(_array_1, 1, #_array_1, _length + 1, _array)
+			local ok = pcall(checkFrame, _array, path)
+			if not ok then
+				a:reject(path, "invalid CFrame")
+			end
+			break
+		end
+		if _exp == "refuse" then
+			return a:reject(path, plan.reason)
+		end
+		if _exp == "object" then
+			return admitObject(a, plan, value, path)
+		end
+		if _exp == "array" then
+			_fallthrough = true
+		end
+		if _fallthrough or _exp == "tuple" then
+			return admitArray(a, plan, value, path)
+		end
+		if _exp == "map" then
+			return admitMap(a, plan, value, path)
+		end
+		if _exp == "union" then
+			return admitUnion(a, plan, value, path)
+		end
+	until true
+	a:chargeLeaf(value, path)
+	return value
+end
+local function admitField(a, name, plan, value, path)
+	a:charge(stringBytes(name), 1, 1, path)
+	return admitNode(a, plan, value, `{path}.{name}`)
+end
+function admitObject(a, plan, value, path)
+	local cached = a:open(plan, value, path)
+	if cached ~= nil then
+		return cached
+	end
+	local source = value
+	return a:nest(plan, source, path, function()
+		a:charge(1, 0, 1, path)
+		local admitted = {}
+		local copy = false
+		local stopped = false
+		for key, child in pairs(source) do
+			a:step(path)
+			local field = if type(key) == "string" then plan.fields[key] else nil
+			if field == nil then
+				copy = true
+				stopped = true
+				break
+			end
+			local result = admitField(a, key, field, child, path)
+			if not rawequal(result, child) then
+				copy = true
+			end
+			admitted[key] = result
+		end
+		for _, name in plan.order do
+			if admitted[name] ~= nil then
+				continue
+			end
+			local child
+			if stopped then
+				a:step(path)
+				child = source[name]
+			end
+			if child == nil then
+				if not (plan.optional[name] ~= nil) then
+					a:reject(`{path}.{name}`, "missing")
+				end
+				continue
+			end
+			local result = admitField(a, name, plan.fields[name], child, path)
+			if not rawequal(result, child) then
+				copy = true
+			end
+			admitted[name] = result
+		end
+		local _a = a
+		-- ▼ ReadonlyMap.size ▼
+		local _size = 0
+		for _ in admitted do
+			_size += 1
+		end
+		-- ▲ ReadonlyMap.size ▲
+		_a:charge(varuintSize(_size), 0, 0, path)
+		if not copy then
+			return source
+		end
+		local out = {}
+		for name, child in admitted do
+			out[name] = child
+		end
+		return out
+	end)
+end
+function admitArray(a, plan, value, path)
+	local cached = a:open(plan, value, path)
+	if cached ~= nil then
+		return cached
+	end
+	local source = value
+	return a:nest(plan, source, path, function()
+		local count = #source
+		if plan.kind == "tuple" and count ~= #plan.elements then
+			a:reject(path, "tuple length")
+		end
+		a:charge(1 + varuintSize(count), count, 1, path)
+		local seen = 0
+		for key in pairs(source) do
+			a:step(path)
+			seen += 1
+			if seen > count or not (type(key) == "number") or key % 1 ~= 0 or key < 1 or key > count then
+				a:reject(path, "sparse array")
+			end
+		end
+		if seen ~= count then
+			a:reject(path, "sparse array")
+		end
+		local copy
+		do
+			local i = 0
+			local _shouldIncrement = false
+			while true do
+				if _shouldIncrement then
+					i += 1
+				else
+					_shouldIncrement = true
+				end
+				if not (i < count) then
+					break
+				end
+				local child = source[i + 1]
+				local result = admitNode(a, if plan.kind == "array" then plan.element else plan.elements[i + 1], child, `{path}[{i + 1}]`)
+				if not rawequal(result, child) and copy == nil then
+					copy = table.clone(source)
+				end
+				if copy ~= nil then
+					copy[i + 1] = result
+				end
+			end
+		end
+		return copy or source
+	end)
+end
+function admitMap(a, plan, value, path)
+	local cached = a:open(plan, value, path)
+	if cached ~= nil then
+		return cached
+	end
+	local source = value
+	return a:nest(plan, source, path, function()
+		a:charge(1, 0, 1, path)
+		local count = 0
+		local copy
+		for key, child in pairs(source) do
+			a:step(path)
+			if not (type(key) == "string") or (plan.keys ~= nil and not (plan.keys[key] ~= nil)) then
+				a:reject(path, "invalid map key")
+			end
+			count += 1
+			a:charge(stringBytes(key), 1, 1, path)
+			local result = admitNode(a, plan.value, child, `{path}[]`)
+			if not rawequal(result, child) and copy == nil then
+				copy = table.clone(source)
+			end
+			if copy ~= nil then
+				copy[key] = result
+			end
+		end
+		a:charge(varuintSize(count), 0, 0, path)
+		return copy or source
+	end)
+end
+function admitUnion(a, plan, value, path)
+	if value == nil then
+		if plan["nil"] == nil then
+			a:reject(path, "no branch for nil")
+		end
+		return admitNode(a, plan["nil"], value, path)
+	end
+	local _literals = plan.literals
+	local _value = value
+	local literal = _literals[_value]
+	if literal ~= nil then
+		return admitNode(a, literal, value, path)
+	end
+	local key = plan.discriminant
+	local _condition = key ~= nil
+	if _condition then
+		local _value_1 = value
+		_condition = type(_value_1) == "table"
+		if _condition then
+			_condition = getmetatable(value) == nil
+		end
+	end
+	if _condition then
+		a:step(path)
+		local _variants = plan.variants
+		local _arg0 = value[key]
+		local variant = _variants[_arg0]
+		if variant == nil then
+			a:reject(path, "no variant for its discriminant")
+		end
+		return admitNode(a, variant, value, path)
+	end
+	local _kinds = plan.kinds
+	local _value_1 = value
+	local _arg0 = typeof(_value_1)
+	local branch = _kinds[_arg0]
+	if branch == nil then
+		a:reject(path, `no branch for {describe(value)}`)
+	end
+	return admitNode(a, branch, value, path)
+end
+--[[
+	*
+	 * @internal
+	 * Rule 49. Projects `value` through `plan`: undeclared keys are dropped unread, declared positions are checked, and
+	 * the result is frozen. Throws "<name><path>: <reason>" for a rejected value, never the value itself, and
+	 * `OverBudget` when a visit would pass `work`'s limit.
+	 
+]]
+local function admit(plan, name, value, work)
+	local a = Admission.new(name, work)
+	local result = admitNode(a, plan, value, "")
+	for _, entry in a.pending do
+		if not table.isfrozen(entry.value) then
+			table.freeze(entry.value)
+		end
+		local _value = entry.value
+		local _cost = entry.cost
+		costs[_value] = _cost
+		local _conforms = entry.plan.conforms
+		local _value_1 = entry.value
+		_conforms[_value_1] = true
+	end
+	return result
+end
+local BOUND = table.freeze({
+	bounded = true,
+})
+--[[
+	*
+	 * @internal
+	 * Rule 61. Structural equality of two admitted values, free across `rawequal` subtrees. One visit per node pair and
+	 * per key iterated, charged to `work`; past SYNC_FRAME_VALUE_VISITS it answers not equal.
+	 
+]]
+local function equal(a, b, work)
+	local spent = 0
+	local function visit()
+		if work ~= nil then
+			spend(work)
+		end
+		spent += 1
+		if spent > SYNC_FRAME_VALUE_VISITS then
+			error(BOUND)
+		end
+	end
+	local function same(x, y)
+		visit()
+		if rawequal(x, y) then
+			return true
+		end
+		local _x = x
+		local _condition = not (type(_x) == "table")
+		if not _condition then
+			local _y = y
+			_condition = not (type(_y) == "table")
+		end
+		if _condition then
+			local _x_1 = x
+			local _exp = typeof(_x_1)
+			local _y = y
+			local _condition_1 = _exp == typeof(_y)
+			if _condition_1 then
+				_condition_1 = x == y
+			end
+			return _condition_1
+		end
+		local xs = x
+		local ys = y
+		if #xs > 0 or #ys > 0 then
+			if #xs ~= #ys then
+				return false
+			end
+			for i = 0, #ys - 1 do
+				visit()
+				if not same(xs[i + 1], ys[i + 1]) then
+					return false
+				end
+			end
+			return true
+		end
+		local xr = x
+		local count = 0
+		for key, child in pairs(y) do
+			visit()
+			count += 1
+			local other = xr[key]
+			if other == nil or not same(other, child) then
+				return false
+			end
+		end
+		local seen = 0
+		for _element, _element_1 in pairs(xr) do
+			local _ = { _element, _element_1 }
+			visit()
+			seen += 1
+			if seen > count then
+				return false
+			end
+		end
+		return seen == count
+	end
+	local ok, result = pcall(same, a, b)
+	if ok then
+		return result
+	end
+	if rawequal(result, BOUND) then
+		return false
+	end
+	error(result, 0)
+end
+--[[
+	*
+	 * @internal
+	 * Rule 63, client. The value to store for a `decoded` one: every subtree structurally equal to the matching subtree
+	 * of `current` is that subtree, so unchanged parts keep their identity. Returns `current` when the whole value is
+	 * equal. `decoded` is a fresh tree, so its new tables are frozen in place.
+	 
+]]
+local function reuse(current, decoded)
+	local _decoded = decoded
+	if not (type(_decoded) == "table") then
+		local _condition = rawequal(current, decoded)
+		if not _condition then
+			local _current = current
+			local _exp = typeof(_current)
+			local _decoded_1 = decoded
+			local _condition_1 = _exp == typeof(_decoded_1)
+			if _condition_1 then
+				_condition_1 = current == decoded
+			end
+			_condition = _condition_1
+		end
+		return if _condition then current else decoded
+	end
+	local _current = current
+	local old = if type(_current) == "table" then current else nil
+	local fresh = decoded
+	local same = old ~= nil
+	local count = 0
+	for key, child in pairs(fresh) do
+		count += 1
+		local _before = old
+		if _before ~= nil then
+			_before = _before[key]
+		end
+		local before = _before
+		local result = reuse(before, child)
+		if not rawequal(result, child) then
+			fresh[key] = result
+		end
+		if before == nil or not rawequal(result, before) then
+			same = false
+		end
+	end
+	if same then
+		local seen = 0
+		for _element, _element_1 in pairs(old) do
+			local _ = { _element, _element_1 }
+			seen += 1
+		end
+		if seen == count then
+			return old
+		end
+	end
+	return table.freeze(fresh)
+end
+return {
+	isOverBudget = isOverBudget,
+	spend = spend,
+	compilePlan = compilePlan,
+	costOf = costOf,
+	admit = admit,
+	equal = equal,
+	reuse = reuse,
+}