@trioforge/crucible 0.0.0-stage → 0.2.0

package/out/internal/network/codec.luau

@@ -0,0 +1,1183 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local L = TS.import(script, script.Parent, "limits")
+local _schema = TS.import(script, script.Parent, "schema")
+local assertDescriptor = _schema.assertDescriptor
+local checkUnion = _schema.checkUnion
+local n = _schema.n
+local runtimeKind = _schema.runtimeKind
+local function fail(path, reason, missing)
+	error({
+		codecFailure = true,
+		path = path,
+		reason = reason,
+		missing = missing,
+	})
+end
+local function finite(value, path)
+	local _value = value
+	local _condition = not (type(_value) == "number")
+	if not _condition then
+		_condition = value ~= value or math.abs(value) == math.huge
+	end
+	if _condition then
+		fail(path, "expected finite number")
+	end
+	return value
+end
+local function uint(value, maximum)
+	local _arg0 = value >= 0 and value <= maximum and value % 1 == 0
+	assert(_arg0, "integer out of range")
+end
+--* @internal 
+local function validString(value)
+	local _arg0 = #value <= L.MAX_STRING_BYTES
+	assert(_arg0, "string too long")
+	local bytes = buffer.fromstring(value)
+	local offset = 0
+	while offset < buffer.len(bytes) do
+		local _original = offset
+		offset += 1
+		local lead = buffer.readu8(bytes, _original)
+		if lead < 0x80 then
+			continue
+		end
+		local count = if lead >= 0xc2 and lead <= 0xdf then 1 elseif lead >= 0xe0 and lead <= 0xef then 2 elseif lead >= 0xf0 and lead <= 0xf4 then 3 else 0
+		local _arg0_1 = count > 0 and count <= buffer.len(bytes) - offset
+		assert(_arg0_1, "invalid UTF-8")
+		local second = buffer.readu8(bytes, offset)
+		local _arg0_2 = lead ~= 0xe0 or second >= 0xa0
+		assert(_arg0_2, "invalid UTF-8")
+		local _arg0_3 = lead ~= 0xed or second < 0xa0
+		assert(_arg0_3, "invalid UTF-8")
+		local _arg0_4 = lead ~= 0xf0 or second >= 0x90
+		assert(_arg0_4, "invalid UTF-8")
+		local _arg0_5 = lead ~= 0xf4 or second < 0x90
+		assert(_arg0_5, "invalid UTF-8")
+		for i = 0, count - 1 do
+			local _original_1 = offset
+			offset += 1
+			local byte = buffer.readu8(bytes, _original_1)
+			local _arg0_6 = byte >= 0x80 and byte <= 0xbf
+			assert(_arg0_6, "invalid UTF-8")
+		end
+	end
+end
+local Budget
+do
+	Budget = setmetatable({}, {
+		__tostring = function()
+			return "Budget"
+		end,
+	})
+	Budget.__index = Budget
+	function Budget.new(...)
+		local self = setmetatable({}, Budget)
+		return self:constructor(...) or self
+	end
+	function Budget:constructor()
+		self.visits = 0
+		self.entries = 0
+		self.depth = 0
+	end
+	function Budget:chargeEntries(count, path)
+		if count < 0 or count % 1 ~= 0 or count > L.MAX_COLLECTION_ENTRIES - self.entries then
+			fail(path, "entry budget exhausted")
+		end
+		self.entries += count
+	end
+	function Budget:visit(path)
+		self.visits += 1
+		if self.visits > L.MAX_VALUE_VISITS then
+			fail(path, "visit budget exhausted")
+		end
+	end
+	function Budget:enter(path)
+		self.depth += 1
+		if self.depth > L.MAX_DEPTH then
+			fail(path, "depth budget exhausted")
+		end
+	end
+	function Budget:leave()
+		self.depth -= 1
+	end
+end
+local Writer
+do
+	Writer = setmetatable({}, {
+		__tostring = function()
+			return "Writer"
+		end,
+	})
+	Writer.__index = Writer
+	function Writer.new(...)
+		local self = setmetatable({}, Writer)
+		return self:constructor(...) or self
+	end
+	function Writer:constructor()
+		self.budget = Budget.new()
+		self.slots = {}
+		self.data = buffer.create(64)
+		self.cursor = 0
+	end
+	function Writer:reserve(size)
+		local _arg0 = size <= L.MAX_PACKET_BYTES - self.cursor
+		assert(_arg0, "packet too large")
+		if size > buffer.len(self.data) - self.cursor then
+			local capacity = math.min(L.MAX_PACKET_BYTES, math.max(buffer.len(self.data) * 2, self.cursor + size))
+			local grown = buffer.create(capacity)
+			buffer.copy(grown, 0, self.data, 0, self.cursor)
+			self.data = grown
+		end
+		local offset = self.cursor
+		self.cursor += size
+		return offset
+	end
+	function Writer:u8(value)
+		uint(value, 255)
+		local offset = self:reserve(1)
+		buffer.writeu8(self.data, offset, value)
+	end
+	function Writer:u16(value)
+		uint(value, 65535)
+		local offset = self:reserve(2)
+		buffer.writeu16(self.data, offset, value)
+	end
+	function Writer:u32(value)
+		uint(value, 4294967295)
+		local offset = self:reserve(4)
+		buffer.writeu32(self.data, offset, value)
+	end
+	function Writer:varuint(value)
+		uint(value, 4294967295)
+		repeat
+			do
+				local low = value % 128
+				value = math.floor(value / 128)
+				self:u8(low + (if value > 0 then 128 else 0))
+			end
+		until not (value > 0)
+	end
+	function Writer:f32(value)
+		finite(value, "payload")
+		local offset = self:reserve(4)
+		buffer.writef32(self.data, offset, value)
+		finite(buffer.readf32(self.data, offset), "payload")
+	end
+	function Writer:f64(value)
+		finite(value, "payload")
+		local offset = self:reserve(8)
+		buffer.writef64(self.data, offset, value)
+	end
+	function Writer:bytes(text)
+		validString(text)
+		self:varuint(#text)
+		local offset = self:reserve(#text)
+		buffer.writestring(self.data, offset, text)
+	end
+	function Writer:slot(instance)
+		local _arg0 = #self.slots < L.MAX_INSTANCE_SLOTS
+		assert(_arg0, "slot budget exhausted")
+		local _slots = self.slots
+		local _instance = instance
+		table.insert(_slots, _instance)
+	end
+	function Writer:finish(header)
+		local size = buffer.len(header) + self.cursor
+		local _arg0 = size <= L.MAX_PACKET_BYTES
+		assert(_arg0, "packet too large")
+		local packet = buffer.create(size)
+		buffer.copy(packet, 0, header)
+		buffer.copy(packet, buffer.len(header), self.data, 0, self.cursor)
+		local sidecar = {}
+		for i = 0, #self.slots - 1 do
+			sidecar[tostring(i + 1)] = self.slots[i + 1]
+		end
+		return packet, table.freeze(sidecar), #self.slots
+	end
+end
+local Reader
+do
+	Reader = setmetatable({}, {
+		__tostring = function()
+			return "Reader"
+		end,
+	})
+	Reader.__index = Reader
+	function Reader.new(...)
+		local self = setmetatable({}, Reader)
+		return self:constructor(...) or self
+	end
+	function Reader:constructor(packet, cursor, sidecar, slotCount)
+		self.packet = packet
+		self.cursor = cursor
+		self.sidecar = sidecar
+		self.slotCount = slotCount
+		self.budget = Budget.new()
+		self.nextSlot = 1
+		local _packet = packet
+		local _condition = type(_packet) == "buffer"
+		if _condition then
+			_condition = buffer.len(packet) <= L.MAX_PACKET_BYTES
+		end
+		assert(_condition, "invalid packet")
+		uint(cursor, buffer.len(packet))
+		uint(slotCount, L.MAX_INSTANCE_SLOTS)
+		local _sidecar = sidecar
+		local _condition_1 = type(_sidecar) == "table"
+		if _condition_1 then
+			_condition_1 = getmetatable(sidecar) == nil
+		end
+		assert(_condition_1, "invalid sidecar")
+		-- At most R keys are valid, so the key check ends iteration by entry R + 1 (rule 71).
+		for key, value in pairs(sidecar) do
+			local slot = if type(key) == "string" then tonumber(key) else nil
+			local _arg0 = slot ~= nil and slot >= 1 and slot <= slotCount and slot % 1 == 0 and tostring(slot) == key and typeof(value) == "Instance"
+			assert(_arg0, "invalid sidecar slot")
+		end
+	end
+	function Reader:take(size)
+		local _arg0 = size <= buffer.len(self.packet) - self.cursor
+		assert(_arg0, "truncated packet")
+		local offset = self.cursor
+		self.cursor += size
+		return offset
+	end
+	function Reader:u8()
+		return buffer.readu8(self.packet, self:take(1))
+	end
+	function Reader:u16()
+		return buffer.readu16(self.packet, self:take(2))
+	end
+	function Reader:u32()
+		return buffer.readu32(self.packet, self:take(4))
+	end
+	function Reader:varuint()
+		local value = 0
+		for i = 0, L.VARUINT_MAX_BYTES - 1 do
+			local byte = self:u8()
+			local _arg0 = i < 4 or byte <= 15
+			assert(_arg0, "varuint overflow")
+			value += (byte % 128) * 2 ^ (7 * i)
+			if byte < 128 then
+				local _arg0_1 = i == 0 or byte ~= 0
+				assert(_arg0_1, "non-minimal varuint")
+				return value
+			end
+		end
+		error("varuint overflow")
+	end
+	function Reader:f32()
+		return finite(buffer.readf32(self.packet, self:take(4)), "payload")
+	end
+	function Reader:f64()
+		return finite(buffer.readf64(self.packet, self:take(8)), "payload")
+	end
+	function Reader:string()
+		local size = self:varuint()
+		local _arg0 = size <= L.MAX_STRING_BYTES
+		assert(_arg0, "string too long")
+		local text = buffer.readstring(self.packet, self:take(size), size)
+		validString(text)
+		return text
+	end
+	function Reader:count(minElementBytes, path)
+		local count = self:varuint()
+		self.budget:chargeEntries(count, path)
+		local _arg0 = minElementBytes == 0 or count <= math.floor((buffer.len(self.packet) - self.cursor) / minElementBytes)
+		assert(_arg0, "count exceeds remaining bytes")
+		return count
+	end
+	function Reader:slot(path)
+		if self.nextSlot > self.slotCount then
+			fail(path, "slot count exceeded")
+		end
+		local _exp = self.sidecar
+		local _original = self.nextSlot
+		self.nextSlot += 1
+		return _exp[tostring(_original)]
+	end
+	function Reader:finished()
+		return self.cursor == buffer.len(self.packet) and self.nextSlot == self.slotCount + 1
+	end
+end
+local function tableValue(value, path)
+	local _value = value
+	if not (type(_value) == "table") then
+		fail(path, "expected table")
+	end
+	return value
+end
+local function dense(value, path)
+	tableValue(value, path)
+	local array = value
+	local count = 0
+	for key in pairs(array) do
+		count += 1
+		if not (type(key) == "number") or key % 1 ~= 0 or key < 1 or key > #array then
+			fail(path, "expected dense array")
+		end
+	end
+	if count ~= #array then
+		fail(path, "expected dense array")
+	end
+	return array
+end
+--* @internal NET 60: finite, orthonormal, right-handed rows. 
+local function frame(values, path)
+	for _, v in values do
+		finite(v, path)
+	end
+	-- ▼ ReadonlyArray.filter ▼
+	local _newValue = {}
+	local _callback = function(_, i)
+		return i >= 3
+	end
+	local _length = 0
+	for _k, _v in values do
+		if _callback(_v, _k - 1, values) == true then
+			_length += 1
+			_newValue[_length] = _v
+		end
+	end
+	-- ▲ ReadonlyArray.filter ▲
+	local r = _newValue
+	local dot = function(a, b)
+		return r[a + 1] * r[b + 1] + r[a + 2] * r[b + 2] + r[a + 3] * r[b + 3]
+	end
+	for _, i in { 0, 3, 6 } do
+		if math.abs(math.sqrt(dot(i, i)) - 1) > L.CFRAME_TOLERANCE then
+			fail(path, "invalid CFrame rows")
+		end
+	end
+	if math.abs(dot(0, 3)) > L.CFRAME_TOLERANCE or math.abs(dot(0, 6)) > L.CFRAME_TOLERANCE or math.abs(dot(3, 6)) > L.CFRAME_TOLERANCE then
+		fail(path, "invalid CFrame orthogonality")
+	end
+	local det = r[1] * (r[5] * r[9] - r[6] * r[8]) - r[2] * (r[4] * r[9] - r[6] * r[7]) + r[3] * (r[4] * r[8] - r[5] * r[7])
+	if math.abs(det - 1) > L.CFRAME_TOLERANCE then
+		fail(path, "invalid CFrame determinant")
+	end
+end
+local encodeDynamic, decodeDynamic
+local function compile(node, tally)
+	if tally == nil then
+		tally = {
+			nodes = 0,
+		}
+	end
+	assertDescriptor(node)
+	local active = {}
+	local function build(node, depth, empty, nilable)
+		if empty == nil then
+			empty = false
+		end
+		if nilable == nil then
+			nilable = false
+		end
+		tally.nodes += 1
+		local _condition = tally.nodes <= L.MAX_SCHEMA_NODES
+		if _condition then
+			_condition = depth <= L.MAX_DEPTH
+			if _condition then
+				local _node = node
+				_condition = not (active[_node] ~= nil)
+			end
+		end
+		assert(_condition, "schema budget exhausted")
+		local _node = node
+		active[_node] = true
+		local minBytes = 0
+		local encode
+		local decode
+		local _exp = node.kind
+		repeat
+			local _fallthrough = false
+			if _exp == "nil" then
+				encode = function(_, v, p)
+					if v ~= nil then
+						fail(p, "expected undefined")
+					end
+				end
+				decode = function()
+					return nil
+				end
+				break
+			end
+			if _exp == "literal" then
+				encode = function(_, v, p)
+					if v ~= node.value then
+						fail(p, "expected literal")
+					end
+				end
+				decode = function()
+					return node.value
+				end
+				break
+			end
+			if _exp == "bool" then
+				minBytes = 1
+				encode = function(w, v, p)
+					local _v = v
+					if not (type(_v) == "boolean") then
+						fail(p, "expected boolean")
+					end
+					w:u8(if v then 1 else 0)
+				end
+				decode = function(r, p)
+					local b = r:u8()
+					if b > 1 then
+						fail(p, "invalid boolean")
+					end
+					return b == 1
+				end
+				break
+			end
+			if _exp == "u8" then
+				_fallthrough = true
+			end
+			if _fallthrough or _exp == "u16" then
+				_fallthrough = true
+			end
+			if _fallthrough or _exp == "u32" then
+				_fallthrough = true
+			end
+			if _fallthrough or _exp == "f32" then
+				_fallthrough = true
+			end
+			if _fallthrough or _exp == "f64" then
+				local kind = node.kind
+				minBytes = if kind == "u8" then 1 elseif kind == "u16" then 2 elseif kind == "f64" then 8 else 4
+				encode = function(w, v, p)
+					local number = finite(v, p)
+					if kind == "u8" then
+						w:u8(number)
+					elseif kind == "u16" then
+						w:u16(number)
+					elseif kind == "u32" then
+						w:u32(number)
+					elseif kind == "f32" then
+						w:f32(number)
+					else
+						w:f64(number)
+					end
+				end
+				decode = function(r)
+					return if kind == "u8" then r:u8() elseif kind == "u16" then r:u16() elseif kind == "u32" then r:u32() elseif kind == "f32" then r:f32() else r:f64()
+				end
+				break
+			end
+			if _exp == "string" then
+				minBytes = 1
+				encode = function(w, v, p)
+					local _v = v
+					if not (type(_v) == "string") then
+						fail(p, "expected string")
+					end
+					w:bytes(v)
+				end
+				decode = function(r)
+					return r:string()
+				end
+				break
+			end
+			if _exp == "vector3" then
+				_fallthrough = true
+			end
+			if _fallthrough or _exp == "color3" then
+				_fallthrough = true
+			end
+			if _fallthrough or _exp == "cframe" then
+				local kind = node.kind
+				minBytes = if kind == "cframe" then 96 else 24
+				encode = function(w, v, p)
+					local values
+					local _condition_1 = kind == "vector3"
+					if _condition_1 then
+						local _v = v
+						_condition_1 = typeof(_v) == "Vector3"
+					end
+					if _condition_1 then
+						values = { v.X, v.Y, v.Z }
+					else
+						local _condition_2 = kind == "color3"
+						if _condition_2 then
+							local _v = v
+							_condition_2 = typeof(_v) == "Color3"
+						end
+						if _condition_2 then
+							values = { v.R, v.G, v.B }
+						else
+							local _condition_3 = kind == "cframe"
+							if _condition_3 then
+								local _v = v
+								_condition_3 = typeof(_v) == "CFrame"
+							end
+							if _condition_3 then
+								local _array = {}
+								local _length = #_array
+								local _array_1 = { v:GetComponents() }
+								table.move(_array_1, 1, #_array_1, _length + 1, _array)
+								values = _array
+								frame(values, p)
+							else
+								return fail(p, "expected datatype")
+							end
+						end
+					end
+					for _, component in values do
+						w:f64(component)
+					end
+				end
+				decode = function(r, p)
+					local values = {}
+					do
+						local i = 0
+						local _shouldIncrement = false
+						while true do
+							if _shouldIncrement then
+								i += 1
+							else
+								_shouldIncrement = true
+							end
+							if not (i < minBytes / 8) then
+								break
+							end
+							local _arg0 = r:f64()
+							table.insert(values, _arg0)
+						end
+					end
+					if kind == "vector3" then
+						local result = Vector3.new(values[1], values[2], values[3])
+						for _, value in { result.X, result.Y, result.Z } do
+							finite(value, p)
+						end
+						return result
+					end
+					if kind == "color3" then
+						local result = Color3.new(values[1], values[2], values[3])
+						for _, value in { result.R, result.G, result.B } do
+							finite(value, p)
+						end
+						return result
+					end
+					frame(values, p)
+					local result = CFrame.new(values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12])
+					for _, value in { result:GetComponents() } do
+						finite(value, p)
+					end
+					return result
+				end
+				break
+			end
+			if _exp == "instance" then
+				local check = function(v, p)
+					local _v = v
+					local _condition_1 = not (typeof(_v) == "Instance")
+					if not _condition_1 then
+						local _exp_1 = node.classes
+						-- ▼ ReadonlyArray.some ▼
+						local _result = false
+						local _callback = function(name)
+							return v:IsA(name)
+						end
+						for _k, _v_1 in _exp_1 do
+							if _callback(_v_1, _k - 1, _exp_1) then
+								_result = true
+								break
+							end
+						end
+						-- ▲ ReadonlyArray.some ▲
+						_condition_1 = not _result
+					end
+					if _condition_1 then
+						fail(p, "expected declared Instance class")
+					end
+					return v
+				end
+				encode = function(w, v, p)
+					return w:slot(check(v, p))
+				end
+				decode = function(r, p)
+					local value = r:slot(p)
+					if value == nil then
+						if nilable then
+							return nil
+						end
+						return fail(p, "missing Instance", true)
+					end
+					return check(value, p)
+				end
+				break
+			end
+			if _exp == "object" then
+				local _arg0 = empty or #node.fields > 0
+				assert(_arg0, "empty object type")
+				local _exp_1 = node.fields
+				-- ▼ ReadonlyArray.map ▼
+				local _newValue = table.create(#_exp_1)
+				local _callback = function(_param)
+					local name = _param[1]
+					local child = _param[2]
+					return { name, build(child, depth + 1) }
+				end
+				for _k, _v in _exp_1 do
+					_newValue[_k] = _callback(_v, _k - 1, _exp_1)
+				end
+				-- ▲ ReadonlyArray.map ▲
+				local fields = _newValue
+				for _, _binding in fields do
+					local codec = _binding[2]
+					minBytes += codec.minBytes
+				end
+				encode = function(w, v, p)
+					local object = tableValue(v, p)
+					for _, _binding in fields do
+						local name = _binding[1]
+						local c = _binding[2]
+						c.encode(w, object[name], `{p}.{name}`)
+					end
+				end
+				decode = function(r, p)
+					local object = {}
+					for _, _binding in fields do
+						local name = _binding[1]
+						local c = _binding[2]
+						object[name] = c.decode(r, `{p}.{name}`)
+					end
+					return object
+				end
+				break
+			end
+			if _exp == "variant" then
+				local _empty = empty
+				assert(_empty, "variant outside union")
+				local body = build(node.body, depth + 1, true)
+				minBytes = body.minBytes
+				encode = function(w, v, p)
+					if tableValue(v, p)[node.key] ~= node.value then
+						fail(p, "invalid discriminant")
+					end
+					body.encode(w, v, p)
+				end
+				decode = function(r, p)
+					local v = body.decode(r, p)
+					v[node.key] = node.value
+					return v
+				end
+				break
+			end
+			if _exp == "union" then
+				checkUnion(node.branches)
+				local _exp_1 = node.branches
+				-- ▼ ReadonlyArray.map ▼
+				local _newValue = table.create(#_exp_1)
+				local _callback = function(b)
+					local _exp_2 = b
+					local _exp_3 = depth + 1
+					local _exp_4 = b.kind == "variant"
+					local _exp_5 = node.branches
+					-- ▼ ReadonlyArray.some ▼
+					local _result = false
+					local _callback_1 = function(b)
+						return b.kind == "nil"
+					end
+					for _k, _v in _exp_5 do
+						if _callback_1(_v, _k - 1, _exp_5) then
+							_result = true
+							break
+						end
+					end
+					-- ▲ ReadonlyArray.some ▲
+					return build(_exp_2, _exp_3, _exp_4, _result)
+				end
+				for _k, _v in _exp_1 do
+					_newValue[_k] = _callback(_v, _k - 1, _exp_1)
+				end
+				-- ▲ ReadonlyArray.map ▲
+				local branches = _newValue
+				-- ▼ ReadonlyArray.map ▼
+				local _newValue_1 = table.create(#branches)
+				local _callback_1 = function(c)
+					return c.minBytes
+				end
+				for _k, _v in branches do
+					_newValue_1[_k] = _callback_1(_v, _k - 1, branches)
+				end
+				-- ▲ ReadonlyArray.map ▲
+				minBytes = 1 + math.min(unpack(_newValue_1))
+				local choose = function(v, p)
+					for i = 0, #node.branches - 1 do
+						local b = node.branches[i + 1]
+						if (b.kind == "nil" and v == nil) or (b.kind == "literal" and v == b.value) then
+							return i
+						end
+					end
+					if v ~= nil then
+						for i = 0, #node.branches - 1 do
+							local b = node.branches[i + 1]
+							if b.kind == "variant" then
+								local _v = v
+								local _condition_1 = type(_v) == "table"
+								if _condition_1 then
+									_condition_1 = v[b.key] == b.value
+								end
+								if _condition_1 then
+									return i
+								end
+							else
+								local _condition_1 = b.kind ~= "nil" and b.kind ~= "literal"
+								if _condition_1 then
+									local _exp_2 = runtimeKind(b)
+									local _v = v
+									_condition_1 = _exp_2 == typeof(_v)
+								end
+								if _condition_1 then
+									return i
+								end
+							end
+						end
+					end
+					return fail(p, "no union branch")
+				end
+				encode = function(w, v, p)
+					w.budget:visit(p)
+					local tag = choose(v, p)
+					w:varuint(tag)
+					branches[tag + 1].encode(w, v, p)
+				end
+				decode = function(r, p)
+					r.budget:visit(p)
+					local tag = r:varuint()
+					if tag >= #branches then
+						fail(p, "bad union tag")
+					end
+					return branches[tag + 1].decode(r, p)
+				end
+				break
+			end
+			if _exp == "array" then
+				_fallthrough = true
+			end
+			if _fallthrough or _exp == "tuple" then
+				local array = node.kind == "array"
+				local _result
+				if array then
+					_result = { build(node.element, depth + 1) }
+				else
+					local _exp_1 = node.elements
+					-- ▼ ReadonlyArray.map ▼
+					local _newValue = table.create(#_exp_1)
+					local _callback = function(b)
+						return build(b, depth + 1)
+					end
+					for _k, _v in _exp_1 do
+						_newValue[_k] = _callback(_v, _k - 1, _exp_1)
+					end
+					-- ▲ ReadonlyArray.map ▲
+					_result = _newValue
+				end
+				local children = _result
+				local _result_1
+				if array then
+					_result_1 = 1
+				else
+					-- ▼ ReadonlyArray.reduce ▼
+					local _result_2 = 0
+					local _callback = function(sum, c)
+						return sum + c.minBytes
+					end
+					for _i = 1, #children do
+						_result_2 = _callback(_result_2, children[_i], _i - 1, children)
+					end
+					-- ▲ ReadonlyArray.reduce ▲
+					_result_1 = _result_2
+				end
+				minBytes = _result_1
+				encode = function(w, v, p)
+					local values = dense(v, p)
+					if not array and #values ~= #children then
+						fail(p, "tuple length")
+					end
+					if array then
+						w.budget:chargeEntries(#values, p)
+						w:varuint(#values)
+					end
+					for i = 0, #values - 1 do
+						if values[i + 1] == nil then
+							fail(p, "nil element")
+						end
+						children[(if array then 0 else i) + 1].encode(w, values[i + 1], `{p}[]`)
+					end
+				end
+				decode = function(r, p)
+					local count = if array then r:count(children[1].minBytes, p) else #children
+					local values = {}
+					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 value = children[(if array then 0 else i) + 1].decode(r, `{p}[]`)
+							if value == nil then
+								fail(p, "nil element")
+							end
+							table.insert(values, value)
+						end
+					end
+					return values
+				end
+				break
+			end
+			if _exp == "map" then
+				local key = build(node.key, depth + 1)
+				local value = build(node.value, depth + 1)
+				minBytes = 1
+				local order = function(v)
+					if node.key.kind == "union" then
+						local _exp_1 = node.key.branches
+						-- ▼ ReadonlyArray.findIndex ▼
+						local _callback = function(b)
+							return b.kind == "literal" and b.value == v
+						end
+						local _result = -1
+						for _i, _v in _exp_1 do
+							if _callback(_v, _i - 1, _exp_1) == true then
+								_result = _i - 1
+								break
+							end
+						end
+						-- ▲ ReadonlyArray.findIndex ▲
+						local index = _result
+						local _arg0 = index >= 0
+						assert(_arg0, "invalid map key")
+						return index
+					end
+					return v
+				end
+				local less = function(a, b)
+					local x = order(a)
+					local y = order(b)
+					return if type(x) == "number" and type(y) == "number" then x < y else x < y
+				end
+				encode = function(w, v, p)
+					local entries = {}
+					for k, val in pairs(tableValue(v, p)) do
+						local _arg0 = { k, val }
+						table.insert(entries, _arg0)
+					end
+					w.budget:chargeEntries(#entries, p)
+					table.sort(entries, function(a, b)
+						return less(a[1], b[1])
+					end)
+					w:varuint(#entries)
+					for _, _binding in entries do
+						local k = _binding[1]
+						local val = _binding[2]
+						key.encode(w, k, `{p}.key`)
+						if val == nil then
+							fail(p, "nil map value")
+						end
+						value.encode(w, val, `{p}[]`)
+					end
+				end
+				decode = function(r, p)
+					local count = r:count(key.minBytes + value.minBytes, p)
+					local values = {}
+					local last
+					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 k = key.decode(r, `{p}.key`)
+							if i > 0 and not less(last, k) then
+								fail(p, "map keys not strictly ascending")
+							end
+							last = k
+							local v = value.decode(r, `{p}[]`)
+							if v == nil then
+								fail(p, "nil map value")
+							end
+							values[k] = v
+						end
+					end
+					return values
+				end
+				break
+			end
+			if _exp == "dynamic" then
+				minBytes = 1
+				encode = function(w, v, p)
+					return encodeDynamic(w, v, p, {})
+				end
+				decode = function(r, p)
+					return decodeDynamic(r, p, true)
+				end
+				break
+			end
+			error("unknown descriptor kind")
+		until true
+		local _node_1 = node
+		active[_node_1] = nil
+		local container = node.kind == "object" or node.kind == "array" or node.kind == "tuple" or node.kind == "map"
+		-- A union charges its selection, a variant is its body's value, and a dynamic value charges itself.
+		local visits = node.kind ~= "union" and node.kind ~= "variant" and node.kind ~= "dynamic"
+		return {
+			node = node,
+			minBytes = minBytes,
+			encode = function(w, v, p)
+				if visits then
+					w.budget:visit(p)
+				end
+				if container then
+					w.budget:enter(p)
+				end
+				local ok, reason = pcall(function()
+					return encode(w, v, p)
+				end)
+				if not ok then
+					if type(reason) == "table" and reason.codecFailure == true then
+						error(reason)
+					end
+					fail(p, tostring(reason))
+				end
+				if container then
+					w.budget:leave()
+				end
+			end,
+			decode = function(r, p)
+				if visits then
+					r.budget:visit(p)
+				end
+				if container then
+					r.budget:enter(p)
+				end
+				local value = decode(r, p)
+				if container then
+					r.budget:leave()
+				end
+				return value
+			end,
+		}
+	end
+	return build(node, 1)
+end
+local datatypes = {
+	vector3 = compile(n.vector3),
+	color3 = compile(n.color3),
+	cframe = compile(n.cframe),
+}
+function encodeDynamic(w, value, path, active, topLevel, arrayElement)
+	if topLevel == nil then
+		topLevel = true
+	end
+	if arrayElement == nil then
+		arrayElement = false
+	end
+	local _value = value
+	local _condition = typeof(_value) == "Vector3"
+	if not _condition then
+		local _value_1 = value
+		_condition = typeof(_value_1) == "Color3"
+		if not _condition then
+			local _value_2 = value
+			_condition = typeof(_value_2) == "CFrame"
+		end
+	end
+	local datatype = _condition
+	if not datatype then
+		w.budget:visit(path)
+	end
+	if value == nil then
+		if not topLevel then
+			fail(path, "nil nested dynamic value")
+		end
+		w:u8(0)
+	else
+		local _value_1 = value
+		if type(_value_1) == "boolean" then
+			w:u8(if value then 2 else 1)
+		else
+			local _value_2 = value
+			if type(_value_2) == "number" then
+				w:u8(3)
+				w:f64(value)
+			else
+				local _value_3 = value
+				if type(_value_3) == "string" then
+					w:u8(4)
+					w:bytes(value)
+				else
+					local _value_4 = value
+					if typeof(_value_4) == "Instance" then
+						if arrayElement then
+							fail(path, "Instance array element")
+						end
+						w:u8(10)
+						w:slot(value)
+					else
+						local _value_5 = value
+						local _condition_1 = typeof(_value_5) == "Vector3"
+						if not _condition_1 then
+							local _value_6 = value
+							_condition_1 = typeof(_value_6) == "Color3"
+							if not _condition_1 then
+								local _value_7 = value
+								_condition_1 = typeof(_value_7) == "CFrame"
+							end
+						end
+						if _condition_1 then
+							local _value_6 = value
+							local _result
+							if typeof(_value_6) == "Vector3" then
+								_result = "vector3"
+							else
+								local _value_7 = value
+								_result = if typeof(_value_7) == "Color3" then "color3" else "cframe"
+							end
+							local kind = _result
+							w:u8(if kind == "vector3" then 7 elseif kind == "color3" then 8 else 9)
+							datatypes[kind].encode(w, value, path)
+						else
+							local object = tableValue(value, path)
+							if getmetatable(object) ~= nil then
+								fail(path, "dynamic metatable")
+							end
+							if active[object] ~= nil then
+								fail(path, "cycle")
+							end
+							active[object] = true
+							w.budget:enter(path)
+							local keys = {}
+							local numeric = 0
+							for k in pairs(object) do
+								if type(k) == "number" then
+									numeric += 1
+								elseif type(k) == "string" then
+									table.insert(keys, k)
+								else
+									fail(path, "invalid dynamic key")
+								end
+							end
+							if numeric > 0 then
+								if not (#keys == 0) then
+									fail(path, "mixed dynamic table")
+								end
+								local values = dense(value, path)
+								w.budget:chargeEntries(#values, path)
+								w:u8(5)
+								w:varuint(#values)
+								for _, v in values do
+									encodeDynamic(w, v, `{path}[]`, active, false, true)
+								end
+							else
+								table.sort(keys)
+								w.budget:chargeEntries(#keys, path)
+								w:u8(6)
+								w:varuint(#keys)
+								for _, key in keys do
+									w.budget:visit(path)
+									w:bytes(key)
+									encodeDynamic(w, object[key], `{path}[]`, active, false)
+								end
+							end
+							w.budget:leave()
+							active[object] = nil
+						end
+					end
+				end
+			end
+		end
+	end
+end
+function decodeDynamic(r, path, topLevel, arrayElement)
+	if arrayElement == nil then
+		arrayElement = false
+	end
+	local tag = r:u8()
+	if tag >= 7 and tag <= 9 then
+		return datatypes[if tag == 7 then "vector3" elseif tag == 8 then "color3" else "cframe"].decode(r, path)
+	end
+	r.budget:visit(path)
+	if tag == 0 then
+		if not topLevel then
+			fail(path, "nil nested dynamic value")
+		end
+		return nil
+	end
+	if tag == 1 or tag == 2 then
+		return tag == 2
+	end
+	if tag == 3 then
+		return r:f64()
+	end
+	if tag == 4 then
+		return r:string()
+	end
+	if tag == 10 then
+		if arrayElement then
+			fail(path, "Instance array element")
+		end
+		return r:slot(path)
+	end
+	if tag ~= 5 and tag ~= 6 then
+		return fail(path, "bad dynamic tag")
+	end
+	r.budget:enter(path)
+	local count = r:count(if tag == 5 then 1 else 2, path)
+	local values = {}
+	local array = {}
+	local last
+	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
+			if tag == 5 then
+				local _arg0 = decodeDynamic(r, `{path}[]`, false, true)
+				table.insert(array, _arg0)
+			else
+				r.budget:visit(path)
+				local key = r:string()
+				if last ~= nil and key <= last then
+					fail(path, "record keys not strictly ascending")
+				end
+				last = key
+				values[key] = decodeDynamic(r, `{path}[]`, false)
+			end
+		end
+	end
+	r.budget:leave()
+	return if tag == 5 then array else values
+end
+return {
+	validString = validString,
+	frame = frame,
+	compile = compile,
+	encodeDynamic = encodeDynamic,
+	decodeDynamic = decodeDynamic,
+	Budget = Budget,
+	Writer = Writer,
+	Reader = Reader,
+}