@flamework-experimental/transformer 2.0.0-alpha.0

package/out/util/functions/buildSerializerFromType.js

@@ -0,0 +1,2309 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSerializerFromType = buildSerializerFromType;
+exports.buildDecoderFromType = buildDecoderFromType;
+exports.buildInlineEncoding = buildInlineEncoding;
+exports.buildResultDecoderFromType = buildResultDecoderFromType;
+exports.buildInlineResultEncoding = buildInlineResultEncoding;
+exports.unwrapPromise = unwrapPromise;
+exports.createSerializerGenerator = createSerializerGenerator;
+var typescript_1 = __importDefault(require("typescript"));
+var diagnostics_1 = require("../../classes/diagnostics");
+var factory_1 = require("../factory");
+var tsInternals_1 = require("../tsInternals");
+var buildGuardFromType_1 = require("./buildGuardFromType");
+var isTupleType_1 = require("./isTupleType");
+var WIDTH_SIZE = { u8: 1, i8: 1, u16: 2, i16: 2, u32: 4, i32: 4, f32: 4, f64: 8 };
+var LENGTH_MAX = { u8: 0xff, u16: 0xffff, u32: 0xffffffff };
+var lengthMin = function (width) { return (width === "v" ? 1 : WIDTH_SIZE[width]); };
+/** `number & { <anything>: "<brand>" }` selects a width; the property name does not matter. */
+var NUMBER_BRANDS = new Set(Object.keys(WIDTH_SIZE));
+var VARINT_BRAND = "varint";
+var STRING_BRANDS = { u8_string: "u8", u16_string: "u16", u32_string: "u32" };
+var BUFFER_BRANDS = { u16_buffer: "u16", u32_buffer: "u32" };
+/** A blob's 1-based index in the blob list, 0 for nil. */
+var BLOB_SIZE = 4;
+var VARINT_MAX_BYTES = 5;
+/**
+ * Counts of zero-size elements cannot be bounded by the bytes left, so a payload gets a plain cap on
+ * how many of them it may hold in all. Per payload rather than per collection: a cap per collection
+ * multiplies through nesting, and `Array<Array<Marker>>` let a 151-byte payload drive 50 × 65535
+ * element tables.
+ */
+var ZERO_SIZE_COUNT_MAX = 0xffff;
+/** Where roblox-ts declares the Roblox API: everything in there without a layout travels as a blob. */
+var ROBLOX_TYPES = /[\\/]@rbxts[\\/]types[\\/]/;
+/** Roblox datatypes with a buffer representation: the fields written, in constructor order. */
+var DATATYPES = {
+    Vector3: [
+        ["f32", ["X"]],
+        ["f32", ["Y"]],
+        ["f32", ["Z"]],
+    ],
+    Vector2: [
+        ["f32", ["X"]],
+        ["f32", ["Y"]],
+    ],
+    Vector3int16: [
+        ["i16", ["X"]],
+        ["i16", ["Y"]],
+        ["i16", ["Z"]],
+    ],
+    Vector2int16: [
+        ["i16", ["X"]],
+        ["i16", ["Y"]],
+    ],
+    Color3: [
+        ["f32", ["R"]],
+        ["f32", ["G"]],
+        ["f32", ["B"]],
+    ],
+    UDim: [
+        ["f32", ["Scale"]],
+        ["i32", ["Offset"]],
+    ],
+    UDim2: [
+        ["f32", ["X", "Scale"]],
+        ["i32", ["X", "Offset"]],
+        ["f32", ["Y", "Scale"]],
+        ["i32", ["Y", "Offset"]],
+    ],
+    NumberRange: [
+        ["f32", ["Min"]],
+        ["f32", ["Max"]],
+    ],
+    Rect: [
+        ["f32", ["Min", "X"]],
+        ["f32", ["Min", "Y"]],
+        ["f32", ["Max", "X"]],
+        ["f32", ["Max", "Y"]],
+    ],
+    BrickColor: [["u16", ["Number"]]],
+};
+var CFRAME_COMPONENTS = 12;
+var IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+var MALFORMED = "malformed payload";
+/** What a name has to mean globally for a generated local to have to avoid it; see `localName`. */
+var GLOBAL_MEANING = typescript_1.default.SymbolFlags.Value | typescript_1.default.SymbolFlags.Namespace;
+/** Kinds whose values are Luau tables, which can be indexed without a `typeof` check first. */
+var TABLE_KINDS = new Set(["object", "map", "array", "set", "list"]);
+function isKind(shape) {
+    return "kind" in shape;
+}
+// --- AST shorthands ---------------------------------------------------------------------------------
+var factory = typescript_1.default.factory;
+var num = function (value) { return factory_1.f.number(value); };
+var prop = function (object, name) {
+    return factory.createPropertyAccessExpression(typeof object === "string" ? factory_1.f.identifier(object) : object, name);
+};
+var bufferCall = function (method, args) { return factory_1.f.call(prop("buffer", method), args); };
+var uid = function (hint) { return factory_1.f.identifier(hint, true); };
+var assign = function (target, value) {
+    return factory_1.f.statement(factory_1.f.binary(target, typescript_1.default.SyntaxKind.EqualsToken, value));
+};
+var addAssign = function (target, value) {
+    return factory_1.f.statement(factory_1.f.binary(target, typescript_1.default.SyntaxKind.PlusEqualsToken, value));
+};
+var constDecl = function (name, value, type) {
+    return factory_1.f.variableStatement(name, value, type);
+};
+var letDecl = function (name, value, type) {
+    return factory_1.f.variableStatement(name, value, type, true);
+};
+var ifStatement = function (condition, then, otherwise) {
+    return factory.createIfStatement(condition, factory_1.f.block(then), Array.isArray(otherwise) ? factory_1.f.block(otherwise) : otherwise);
+};
+var forOf = function (name, iterable, body) {
+    return factory.createForOfStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(name)], typescript_1.default.NodeFlags.Const), iterable, factory_1.f.block(body));
+};
+var range = function (from, to) { return factory_1.f.call("$range", [from, to]); };
+var notNil = function (value) { return factory_1.f.binary(value, typescript_1.default.SyntaxKind.ExclamationEqualsEqualsToken, factory_1.f.nil()); };
+var isNil = function (value) { return factory_1.f.binary(value, typescript_1.default.SyntaxKind.EqualsEqualsEqualsToken, factory_1.f.nil()); };
+var equals = function (left, right) {
+    return factory_1.f.binary(left, typescript_1.default.SyntaxKind.EqualsEqualsEqualsToken, right);
+};
+var conditional = function (condition, whenTrue, whenFalse) {
+    return factory.createConditionalExpression(condition, factory_1.f.token(typescript_1.default.SyntaxKind.QuestionToken), whenTrue, factory_1.f.token(typescript_1.default.SyntaxKind.ColonToken), whenFalse);
+};
+var raise = function (message) { return factory_1.f.statement(factory_1.f.call("error", [factory_1.f.string(message)])); };
+/** `typeIs(v, name)`: roblox-ts emits `type(v) == name` for primitives and `typeof(v) == name` otherwise, with no temporaries. */
+var typeOfIs = function (value, name) { return factory_1.f.call("typeIs", [value, factory_1.f.string(name)]); };
+var construct = function (name, args, typeArguments) {
+    return factory.createNewExpression(factory_1.f.identifier(name), typeArguments, args);
+};
+/** A literal expression as text, for comparing and ordering literals. */
+function printLiteral(expression) {
+    if (factory_1.f.is.string(expression))
+        return JSON.stringify(expression.text);
+    if (factory_1.f.is.number(expression))
+        return expression.text;
+    if (typescript_1.default.isPrefixUnaryExpression(expression))
+        return "-".concat(printLiteral(expression.operand));
+    if (expression.kind === typescript_1.default.SyntaxKind.TrueKeyword)
+        return "true";
+    if (expression.kind === typescript_1.default.SyntaxKind.FalseKeyword)
+        return "false";
+    return "#".concat(expression.kind);
+}
+/** A byte total under construction: the constants fold into one literal, the terms keep their order. */
+var Sum = /** @class */ (function () {
+    function Sum() {
+        this.constant = 0;
+        this.terms = new Array();
+    }
+    Sum.prototype.add = function (part) {
+        if (typeof part === "number")
+            this.constant += part;
+        else if (factory_1.f.is.number(part))
+            this.constant += Number(part.text);
+        else
+            this.terms.push(part);
+    };
+    Sum.prototype.build = function () {
+        var e_1, _a;
+        var total;
+        try {
+            for (var _b = __values(this.terms), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var term = _c.value;
+                total = total ? factory_1.f.binary(total, typescript_1.default.SyntaxKind.PlusToken, term) : term;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return total ? add(total, this.constant) : num(this.constant);
+    };
+    return Sum;
+}());
+/** `left + right` with constants folded. */
+function add(left, right) {
+    if (typeof right === "number") {
+        if (right === 0)
+            return left;
+        if (factory_1.f.is.number(left))
+            return num(Number(left.text) + right);
+        return factory_1.f.binary(left, typescript_1.default.SyntaxKind.PlusToken, num(right));
+    }
+    if (factory_1.f.is.number(left) && Number(left.text) === 0)
+        return right;
+    if (factory_1.f.is.number(right))
+        return add(left, Number(right.text));
+    return factory_1.f.binary(left, typescript_1.default.SyntaxKind.PlusToken, right);
+}
+var T;
+(function (T) {
+    T.unknown = function () { return factory_1.f.keywordType(typescript_1.default.SyntaxKind.UnknownKeyword); };
+    T.number = function () { return factory_1.f.keywordType(typescript_1.default.SyntaxKind.NumberKeyword); };
+    T.string = function () { return factory_1.f.keywordType(typescript_1.default.SyntaxKind.StringKeyword); };
+    T.buffer = function () { return factory_1.f.referenceType("buffer"); };
+    T.defined = function () { return factory_1.f.referenceType("defined"); };
+    T.blobs = function () { return factory_1.f.referenceType("Array", [T.defined()]); };
+    T.array = function () { return factory_1.f.referenceType("Array", [T.unknown()]); };
+    T.record = function () { return factory_1.f.referenceType("Record", [T.string(), T.unknown()]); };
+    T.map = function () { return factory_1.f.referenceType("Map", [T.unknown(), T.unknown()]); };
+    T.set = function () { return factory_1.f.referenceType("Set", [T.defined()]); };
+    T.enumItem = function () { return factory_1.f.referenceType("EnumItem"); };
+    T.tuple = function (elements) { return factory_1.f.referenceType("LuaTuple", [factory_1.f.tupleType(elements)]); };
+    T.fn = function (parameters, result) {
+        return factory_1.f.functionType(parameters.map(function (_a) {
+            var _b = __read(_a, 2), name = _b[0], type = _b[1];
+            return factory_1.f.parameterDeclaration(name, type);
+        }), result);
+    };
+})(T || (T = {}));
+// --- entry points -----------------------------------------------------------------------------------
+/**
+ * One generator per file: every intrinsic and call site in it shares the hoisted helpers (a named
+ * type's functions, guards, literal and enum tables), which land at file scope ahead of the root
+ * statement that first needed them.
+ */
+var generators = new WeakMap();
+function generatorFor(state, node, file) {
+    var generator = generators.get(file);
+    if (!generator) {
+        generator = createSerializerGenerator(state, file, node);
+        generators.set(file, generator);
+    }
+    generator.use(node);
+    return generator;
+}
+function emitHoisted(state, generator) {
+    var _a;
+    (_a = state.nextRootStatements).push.apply(_a, __spreadArray([], __read(generator.takeHoisted()), false));
+}
+/** `Flamework.createSerializer<T>()`: a `{ serialize, deserialize }` pair for one value. */
+function buildSerializerFromType(state, node, type, file) {
+    var _a;
+    if (file === void 0) { file = state.getSourceFile(node); }
+    var generator = generatorFor(state, node, file);
+    // The type argument as written is where the unions in it get their member order from.
+    var written = typescript_1.default.isCallExpression(node) ? (_a = node.typeArguments) === null || _a === void 0 ? void 0 : _a[0] : undefined;
+    var serializer = generator.buildSerializer(generator.spell(written, unwrapPromise(state, type)));
+    emitHoisted(state, generator);
+    // roblox-ts type-checks the transformed file. The generated functions are typed loosely inside
+    // (`unknown` values with casts); the macro's own return type is what users see.
+    return factory_1.f.asNever(serializer);
+}
+/**
+ * Networking: the decoder for an argument list, given its tuple type: `(payload, blobs) => values`.
+ * Promise elements are unwrapped, since a function's resolved value is what crosses the network.
+ * There is no encoder counterpart as a value; see {@link buildInlineEncoding}. A list that carries
+ * nothing (no elements, or only `void` ones) gets `undefined`: the runtime then passes the (empty)
+ * argument list through, and the call sites send no payload at all.
+ */
+function buildDecoderFromType(state, node, type, file) {
+    if (file === void 0) { file = state.getSourceFile(node); }
+    var generator = generatorFor(state, node, file);
+    var decoder = generator.buildDecoder(type);
+    emitHoisted(state, generator);
+    if (!decoder)
+        return factory_1.f.nil();
+    // A block-bodied arrow cannot be followed by `as` without parentheses.
+    return factory_1.f.asNever(factory.createParenthesizedExpression(decoder));
+}
+/**
+ * Packs an argument list where it is sent. `values` are the call's arguments for the tuple's
+ * elements (a missing optional is `undefined`, extra ones feed the rest element), or the table that
+ * holds them when a spread argument makes their number unknown. Argument expressions must be
+ * identifiers or literals: they are read more than once.
+ */
+function buildInlineEncoding(state, node, type, values, file) {
+    if (file === void 0) { file = state.getSourceFile(node); }
+    var generator = generatorFor(state, node, file);
+    var encoding = generator.encodeList(type, values);
+    emitHoisted(state, generator);
+    return encoding;
+}
+/**
+ * Networking: the decoder for the result of a function type, carried as a one-element list. The
+ * function type, rather than its return type, so that a union written in the return type gets its
+ * member order from the declaration.
+ */
+function buildResultDecoderFromType(state, node, fn, file) {
+    if (file === void 0) { file = state.getSourceFile(node); }
+    var generator = generatorFor(state, node, file);
+    var decoder = generator.buildDecoder(resultOf(state, generator, fn, node));
+    emitHoisted(state, generator);
+    if (!decoder)
+        return factory_1.f.nil();
+    return factory_1.f.asNever(factory.createParenthesizedExpression(decoder));
+}
+/**
+ * Packs a function's result as a one-element list; see {@link buildResultDecoderFromType}. `value`
+ * is flagged as a parameter when it is one, so the generated code copies it before any macro sees it.
+ */
+function buildInlineResultEncoding(state, node, fn, value, isParameter, file) {
+    if (file === void 0) { file = state.getSourceFile(node); }
+    var generator = generatorFor(state, node, file);
+    if (isParameter)
+        generator.markParameter(value);
+    var encoding = generator.encodeList(resultOf(state, generator, fn, node), [value]);
+    emitHoisted(state, generator);
+    return encoding;
+}
+/** The one-element list a function's (resolved) result travels as, shaped by its declared return type node. */
+function resultOf(state, generator, fn, node) {
+    var _a;
+    var signature = fn.getCallSignatures()[0];
+    if (!signature) {
+        diagnostics_1.Diagnostics.error(node, "Flamework expected a function type here, got '".concat(state.typeChecker.typeToString(fn), "'."));
+    }
+    var returnType = unwrapPromise(state, signature.getReturnType());
+    return { kind: "list", elements: [generator.spell((_a = signature.getDeclaration()) === null || _a === void 0 ? void 0 : _a.type, returnType)] };
+}
+/** Unwraps `Promise<T>` to `T`. */
+function unwrapPromise(state, type) {
+    var _a;
+    var promiseSymbol = state.typeChecker.resolveName("Promise", undefined, typescript_1.default.SymbolFlags.Type, false);
+    if (promiseSymbol !== undefined && type.getSymbol() === promiseSymbol) {
+        return (_a = state.typeChecker.getTypeArguments(type)[0]) !== null && _a !== void 0 ? _a : type;
+    }
+    return type;
+}
+// --- generator --------------------------------------------------------------------------------------
+function createSerializerGenerator(state, file, initialNode) {
+    var typeChecker = state.typeChecker;
+    var diagnosticNode = initialNode;
+    var resolve = function (name) { return typeChecker.resolveName(name, undefined, typescript_1.default.SymbolFlags.Type, false); };
+    var kinds = new Map();
+    var layouts = new Map();
+    var visiting = new Set();
+    var provisional = 0;
+    var trail = new Array();
+    /** Forward declarations of hoisted functions, then everything they refer to, then their bodies. */
+    var declarations = new Array();
+    var tables = new Array();
+    var definitions = new Array();
+    var emitted = [0, 0, 0];
+    var hoisted = new Map();
+    var guards = new Map();
+    var enumTables = new Map();
+    var literalTables = new Map();
+    var discriminants = new Map();
+    /** A union's members as alternatives, shared by every spelling of it so a literal group is one table. */
+    var unionAlternatives = new Map();
+    var varint;
+    /** The per-file tally of zero-size elements the payload being decoded has announced; see `readCount`. */
+    var zeros;
+    /**
+     * Parameters of the generated functions. roblox-ts copies a parameter into a temporary wherever one
+     * of its macros (`typeIs`, `Map.get`, `Array.push`) takes it, and then everything after it in the
+     * call too; a `const` copy of our own passes straight through, so {@link bind} makes one.
+     */
+    var parameters = new Set();
+    return { buildSerializer: buildSerializer, buildDecoder: buildDecoder, encodeList: encodeList, use: use, spell: spell, markParameter: markParameter, takeHoisted: takeHoisted };
+    /** A fresh identifier declared as a parameter of a generated function. */
+    function parameter(hint) {
+        var id = uid(hint);
+        parameters.add(id);
+        return id;
+    }
+    /** Marks an identifier declared as a parameter by the caller; see {@link bind}. */
+    function markParameter(id) {
+        parameters.add(id);
+    }
+    /** Whether an identifier from user code names a parameter, which roblox-ts treats as mutable. */
+    function isParameterReference(id) {
+        var _a;
+        if (parameters.has(id))
+            return true;
+        var declaration = (_a = typeChecker.getSymbolAtLocation(id)) === null || _a === void 0 ? void 0 : _a.valueDeclaration;
+        return declaration !== undefined && typescript_1.default.isParameter(declaration);
+    }
+    /** Points diagnostics at the intrinsic or call site being built. */
+    function use(node) {
+        diagnosticNode = node;
+    }
+    /** Hoisted statements added since the last call, in an order that keeps every reference in scope. */
+    function takeHoisted() {
+        var statements = __spreadArray(__spreadArray(__spreadArray([], __read(declarations.slice(emitted[0])), false), __read(tables.slice(emitted[1])), false), __read(definitions.slice(emitted[2])), false);
+        emitted = [declarations.length, tables.length, definitions.length];
+        return statements;
+    }
+    function fail(message) {
+        var chain = trail.map(function (type) { return typeChecker.typeToString(type); }).join(" > ");
+        var lines = ["Flamework cannot serialize this type: ".concat(message, ".")];
+        if (chain !== "")
+            lines.push("Reached through: ".concat(chain));
+        return diagnostics_1.Diagnostics.error.apply(diagnostics_1.Diagnostics, __spreadArray([diagnosticNode], __read(lines), false));
+    }
+    // --- top level -----------------------------------------------------------------------------------
+    function buildSerializer(type) {
+        var layout = layoutOf(type);
+        var value = parameter("v");
+        var serialize = factory_1.f.arrowFunction(factory_1.f.block(encodeBody(type, layout, value)), [
+            factory_1.f.parameterDeclaration(value, T.unknown()),
+        ]);
+        var buf = uid("buf");
+        var blobs = layout.blobs ? uid("blobs") : undefined;
+        var body = new Array();
+        var result = decodeBody(type, layout, buf, blobs, body);
+        body.push(factory_1.f.returnStatement(result));
+        var deserialize = factory_1.f.arrowFunction(factory_1.f.block(body), blobs
+            ? [factory_1.f.parameterDeclaration(buf, T.buffer()), factory_1.f.parameterDeclaration(blobs, T.blobs())]
+            : [factory_1.f.parameterDeclaration(buf, T.buffer())]);
+        return factory_1.f.object([
+            factory_1.f.propertyAssignmentDeclaration("serialize", serialize),
+            factory_1.f.propertyAssignmentDeclaration("deserialize", deserialize),
+        ]);
+    }
+    function buildDecoder(type) {
+        var list = isKind(type) ? type : listOf(type);
+        if (carriesNothing(list))
+            return;
+        var layout = layoutOf(list);
+        var buf = uid("buf");
+        var blobs = layout.blobs ? uid("blobs") : undefined;
+        var body = new Array();
+        var result = decodeBody(list, layout, buf, blobs, body);
+        body.push(factory_1.f.returnStatement(result));
+        return factory_1.f.arrowFunction(factory_1.f.block(body), blobs
+            ? [factory_1.f.parameterDeclaration(buf, T.buffer()), factory_1.f.parameterDeclaration(blobs, T.blobs())]
+            : [factory_1.f.parameterDeclaration(buf, T.buffer())]);
+    }
+    function encodeList(type, values) {
+        return encodeElements(isKind(type) ? type : listOf(type), values);
+    }
+    /** A list with nothing to carry: no elements, or only `void` ones. Such a list sends no payload. */
+    function carriesNothing(list) {
+        return !list.rest && list.elements.every(function (element) { return describe(element).kind === "nothing"; });
+    }
+    /**
+     * Packs a list whose values are known one by one, so a static count of rest values and absent
+     * optionals fold into the layout: a call with only fixed-size arguments gets a constant buffer size.
+     */
+    function encodeElements(list, values) {
+        var e_2, _a, e_3, _b, e_4, _c;
+        if (carriesNothing(list))
+            return { statements: [], payload: undefined, blobs: undefined };
+        var layout = layoutOf(list);
+        var statements = new Array();
+        if (!Array.isArray(values)) {
+            var _d = encodeInto(list, layout, values.table, statements), buf_1 = _d.buf, blobs_1 = _d.blobs;
+            return { statements: statements, payload: buf_1, blobs: blobs_1 };
+        }
+        var elementValue = function (index) { var _a; return (_a = values[index]) !== null && _a !== void 0 ? _a : factory_1.f.nil(); };
+        var rest = values.slice(list.elements.length);
+        if (rest.length > 0 && !list.rest)
+            fail("more arguments than the list has elements");
+        // The rest count is known here, so its varint is a constant: literal bytes, no helper call.
+        var countBytes = staticVarint(rest.length);
+        var total = new Sum();
+        list.elements.forEach(function (element, index) { return total.add(emitSize(element, elementValue(index), statements)); });
+        if (list.rest) {
+            total.add(countBytes.length);
+            try {
+                for (var rest_1 = __values(rest), rest_1_1 = rest_1.next(); !rest_1_1.done; rest_1_1 = rest_1.next()) {
+                    var value = rest_1_1.value;
+                    total.add(emitSize(list.rest, value, statements));
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (rest_1_1 && !rest_1_1.done && (_a = rest_1.return)) _a.call(rest_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+        var size = total.build();
+        var buf = uid("buf");
+        statements.push(constDecl(buf, bufferCall("create", [size])));
+        var blobs = layout.blobs ? uid("blobs") : undefined;
+        if (blobs)
+            statements.push(constDecl(blobs, construct("Array", []), T.blobs()));
+        var variable = factory_1.f.is.number(size) ? undefined : uid("o");
+        if (variable)
+            statements.push(letDecl(variable, num(0)));
+        var ctx = { buf: buf, blobs: blobs, cursor: { variable: variable, base: variable, offset: 0 }, out: statements };
+        list.elements.forEach(function (element, index) { return emitWrite(element, elementValue(index), ctx); });
+        if (list.rest) {
+            try {
+                for (var countBytes_1 = __values(countBytes), countBytes_1_1 = countBytes_1.next(); !countBytes_1_1.done; countBytes_1_1 = countBytes_1.next()) {
+                    var byte = countBytes_1_1.value;
+                    ctx.out.push(factory_1.f.statement(bufferCall("writeu8", [buf, at(ctx), num(byte)])));
+                    ctx.cursor.offset += 1;
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (countBytes_1_1 && !countBytes_1_1.done && (_b = countBytes_1.return)) _b.call(countBytes_1);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            try {
+                for (var rest_2 = __values(rest), rest_2_1 = rest_2.next(); !rest_2_1.done; rest_2_1 = rest_2.next()) {
+                    var value = rest_2_1.value;
+                    emitWrite(list.rest, value, ctx);
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (rest_2_1 && !rest_2_1.done && (_c = rest_2.return)) _c.call(rest_2);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+        }
+        return { statements: statements, payload: buf, blobs: blobs };
+    }
+    /** The bytes of a varint known at compile time. */
+    function staticVarint(n) {
+        var bytes = new Array();
+        while (n >= 128) {
+            bytes.push((n % 128) + 128);
+            n = Math.floor(n / 128);
+        }
+        bytes.push(n);
+        return bytes;
+    }
+    /**
+     * The argument list a tuple type describes, with Promise elements unwrapped. Each element is shaped
+     * by where it was written: the tuple node when there is one, else the parameter or member it was
+     * declared with (`Parameters<F>` keeps those).
+     */
+    function listOf(type, node) {
+        var _a;
+        if (!(0, isTupleType_1.isTupleType)(state, type)) {
+            return { kind: "list", elements: [unwrapPromise(state, type)] };
+        }
+        var elements = new Array();
+        var rest;
+        var types = typeChecker.getTypeArguments(type);
+        for (var i = 0; i < types.length; i++) {
+            var element = unwrapPromise(state, types[i]);
+            var flags = type.target.elementFlags[i];
+            var isRest = (flags & typescript_1.default.ElementFlags.Rest) !== 0;
+            var written = node
+                ? tupleElementNode(node.elements[i])
+                : declaredTypeNode((_a = type.target.labeledElementDeclarations) === null || _a === void 0 ? void 0 : _a[i]);
+            var shape = spellElement(written, element, isRest);
+            if (isRest) {
+                rest = shape;
+            }
+            else if (flags & typescript_1.default.ElementFlags.Optional && !hasUndefined(element)) {
+                elements.push({ kind: "optional", inner: shape });
+            }
+            else {
+                elements.push(shape);
+            }
+        }
+        return { kind: "list", elements: elements, rest: rest };
+    }
+    /**
+     * `const buf = buffer.create(<size>)`, the blob list when the type has blob slots, the writes,
+     * and `return buf, blobs`.
+     */
+    function encodeBody(shape, layout, value) {
+        var body = new Array();
+        var _a = encodeInto(shape, layout, value, body), buf = _a.buf, blobs = _a.blobs;
+        body.push(factory_1.f.returnStatement(blobs ? factory_1.f.call("$tuple", [buf, blobs]) : buf));
+        return body;
+    }
+    /** The size pass, the buffer, the blob list when the type has blob slots, and the writes. */
+    function encodeInto(shape, layout, value, body) {
+        var size = emitSize(shape, value, body);
+        var buf = uid("buf");
+        body.push(constDecl(buf, bufferCall("create", [size])));
+        var blobs = layout.blobs ? uid("blobs") : undefined;
+        if (blobs)
+            body.push(constDecl(blobs, construct("Array", []), T.blobs()));
+        var top = isKind(shape) ? undefined : hoist(shape);
+        if (top) {
+            body.push(factory_1.f.statement(factory_1.f.call(top.write, blobs ? [buf, num(0), value, blobs] : [buf, num(0), value])));
+        }
+        else {
+            var variable = layout.size === undefined ? uid("o") : undefined;
+            if (variable)
+                body.push(letDecl(variable, num(0)));
+            emitWrite(shape, value, { buf: buf, blobs: blobs, cursor: { variable: variable, base: variable, offset: 0 }, out: body });
+        }
+        return { buf: buf, blobs: blobs };
+    }
+    /** The reads, ending with a check that the whole buffer was consumed; returns the value. */
+    function decodeBody(shape, layout, buf, blobs, body) {
+        var length = bufferCall("len", [buf]);
+        // The payload's own tally of zero-size elements starts here; decoding never yields, so one
+        // per file is never shared between two payloads.
+        if (layout.zeros)
+            body.push(assign(zeroTally(), num(0)));
+        var top = isKind(shape) ? undefined : hoist(shape);
+        if (top) {
+            var value = uid("value");
+            var end = uid("o");
+            body.push(constDecl(factory_1.f.arrayBindingDeclaration([value, end]), factory_1.f.call(top.read, blobs ? [buf, num(0), blobs] : [buf, num(0)])));
+            body.push(ifStatement(factory_1.f.binary(end, typescript_1.default.SyntaxKind.ExclamationEqualsEqualsToken, length), [raise(MALFORMED)]));
+            return value;
+        }
+        var variable = layout.size === undefined ? uid("o") : undefined;
+        if (variable)
+            body.push(letDecl(variable, num(0)));
+        var ctx = { buf: buf, blobs: blobs, cursor: { variable: variable, base: variable, offset: 0 }, out: body };
+        var result = emitRead(shape, ctx);
+        if (!factory_1.f.is.identifier(result) && !isLiteral(result)) {
+            result = bind(body, result, "value");
+        }
+        if (variable) {
+            sync(ctx);
+            body.push(ifStatement(factory_1.f.binary(variable, typescript_1.default.SyntaxKind.ExclamationEqualsEqualsToken, length), [raise(MALFORMED)]));
+        }
+        else {
+            body.push(ifStatement(factory_1.f.binary(length, typescript_1.default.SyntaxKind.ExclamationEqualsEqualsToken, num(layout.size)), [
+                raise(MALFORMED),
+            ]));
+        }
+        return result;
+    }
+    // --- classification ------------------------------------------------------------------------------
+    function describe(shape) {
+        if (isKind(shape))
+            return shape;
+        var kind = kinds.get(shape);
+        if (!kind) {
+            kind = classify(shape);
+            kinds.set(shape, kind);
+        }
+        return kind;
+    }
+    function classify(type) {
+        if (type.isUnion())
+            return classifyUnion(type);
+        if ((0, buildGuardFromType_1.isInstanceType)(type))
+            return { kind: "blob", typeofName: "Instance" };
+        if (type.isIntersection())
+            return classifyIntersection(type);
+        if ((0, buildGuardFromType_1.isConditionalType)(type)) {
+            var branches = [type.resolvedTrueType, type.resolvedFalseType];
+            return { kind: "union", alternatives: branches.map(function (branch) { return ({ shape: branch, type: branch }); }) };
+        }
+        if ((type.flags & typescript_1.default.TypeFlags.TypeVariable) !== 0) {
+            // An unconstrained type parameter can be anything, which is what a blob carries.
+            var constraint = typeChecker.getBaseConstraintOfType(type);
+            return constraint ? describe(constraint) : { kind: "blob" };
+        }
+        var literals = (0, buildGuardFromType_1.getLiteral)(type);
+        if (literals) {
+            return literals.length === 1
+                ? { kind: "constant", value: literals[0] }
+                : { kind: "literals", values: literals };
+        }
+        if (type.flags & (typescript_1.default.TypeFlags.Void | typescript_1.default.TypeFlags.Undefined | typescript_1.default.TypeFlags.Null))
+            return { kind: "nothing" };
+        if (type.flags & (typescript_1.default.TypeFlags.Any | typescript_1.default.TypeFlags.Unknown))
+            return { kind: "blob" };
+        if (type.flags & typescript_1.default.TypeFlags.Never)
+            fail("`never` has no values");
+        // A template literal (`${string}-id`) or `Uppercase<T>` is a string with a pattern; the bytes are the same.
+        if (type.flags & (typescript_1.default.TypeFlags.String | typescript_1.default.TypeFlags.TemplateLiteral | typescript_1.default.TypeFlags.StringMapping)) {
+            return { kind: "string", length: "v" };
+        }
+        if (type.flags & typescript_1.default.TypeFlags.Number)
+            return { kind: "number", width: "f64" };
+        if (type.flags & typescript_1.default.TypeFlags.BigInt)
+            fail("bigint does not exist in Luau");
+        if (type.flags & typescript_1.default.TypeFlags.ESSymbolLike)
+            fail("symbols cannot be sent");
+        if ((0, isTupleType_1.isTupleType)(state, type))
+            return listOf(type);
+        if ((0, isTupleType_1.isArrayType)(state, type) || typeChecker.isArrayType(type)) {
+            var element = typeChecker.getTypeArguments(type)[0];
+            if (!element)
+                fail("an array without an element type");
+            return { kind: "array", element: element };
+        }
+        if (type.getCallSignatures().length > 0)
+            fail("functions cannot be sent");
+        // `object`, and whatever else has no declaration behind it, has no structure to write.
+        var symbol = type.getSymbol();
+        if (!symbol)
+            return { kind: "blob" };
+        if (symbol === resolve("Map") || symbol === resolve("ReadonlyMap")) {
+            var _a = __read(typeChecker.getTypeArguments(type), 2), key = _a[0], value = _a[1];
+            if (!key || !value)
+                fail("a Map without key and value types");
+            return { kind: "map", key: key, value: value };
+        }
+        if (symbol === resolve("Set") || symbol === resolve("ReadonlySet")) {
+            var _b = __read(typeChecker.getTypeArguments(type), 1), element = _b[0];
+            if (!element)
+                fail("a Set without an element type");
+            return { kind: "set", element: element };
+        }
+        if (symbol === resolve("WeakMap") || symbol === resolve("WeakSet"))
+            fail("weak collections cannot be sent");
+        if (symbol === resolve("Promise"))
+            fail("a Promise cannot be sent; send its resolved value");
+        if (symbol === resolve("buffer"))
+            return { kind: "buffer", length: "v" };
+        var global = symbol === resolve(symbol.name);
+        if (global) {
+            if (symbol.name === "CFrame")
+                return { kind: "cframe" };
+            if (DATATYPES[symbol.name] !== undefined)
+                return { kind: "datatype", name: symbol.name };
+        }
+        // `Enum.Material` and friends are interfaces declared under the Enum namespace.
+        var enumNamespace = resolve("Enum");
+        if (symbol.parent && enumNamespace && typeChecker.getMergedSymbol(symbol.parent) === enumNamespace) {
+            return { kind: "enum", name: symbol.name };
+        }
+        // The rest of the Roblox API (EnumItem, Font, RBXScriptSignal, ...) and anything nominal has no
+        // structure a plain table could stand in for; a global's name is also what `typeof` reports.
+        if (isRobloxType(symbol))
+            return { kind: "blob", typeofName: global ? symbol.name : undefined };
+        if (hasNominalMarker(type))
+            return { kind: "blob" };
+        // A class instance is more than its fields; it travels as a reference.
+        if (type.isClass())
+            return { kind: "blob" };
+        return classifyObject(type);
+    }
+    /** Declared by roblox-ts's Roblox API types, as opposed to by the project or the TypeScript library. */
+    function isRobloxType(symbol) {
+        var declarations = symbol === null || symbol === void 0 ? void 0 : symbol.declarations;
+        if (!declarations)
+            return false;
+        return declarations.some(function (declaration) { return ROBLOX_TYPES.test(declaration.getSourceFile().fileName); });
+    }
+    /** roblox-ts marks its nominal types with a `_nominal_X` property; project code may do the same. */
+    function hasNominalMarker(type) {
+        return type.getProperties().some(function (property) { return property.name.startsWith("_nominal_"); });
+    }
+    /** A union as a kind; `node` is the spelling its members are numbered by, else the alias's own. */
+    function classifyUnion(type, node) {
+        if (type === typeChecker.getBooleanType())
+            return { kind: "boolean" };
+        var _a = alternativesOf(type), isOptional = _a.isOptional, alternatives = _a.alternatives;
+        var inner;
+        if (alternatives.length === 0)
+            inner = { kind: "nothing" };
+        else if (alternatives.length === 1)
+            inner = alternatives[0].shape;
+        // A one-byte tag numbers at most 256 members; past that the value travels whole.
+        else if (alternatives.length > 0xff)
+            inner = { kind: "blob" };
+        else
+            inner = { kind: "union", alternatives: orderAlternatives(alternatives, node !== null && node !== void 0 ? node : aliasNode(type)) };
+        if (isOptional)
+            return { kind: "optional", inner: inner };
+        return describe(inner);
+    }
+    function alternativesOf(type) {
+        var e_5, _a, e_6, _b;
+        var entry = unionAlternatives.get(type);
+        if (!entry) {
+            var _c = (0, buildGuardFromType_1.simplifyUnion)(type), enums = _c.enums, literals = _c.literals, types = _c.types;
+            var _d = __read((0, buildGuardFromType_1.extractTypes)(typeChecker, types), 2), isOptional = _d[0], members = _d[1];
+            var alternatives = new Array();
+            try {
+                for (var members_1 = __values(members), members_1_1 = members_1.next(); !members_1_1.done; members_1_1 = members_1.next()) {
+                    var member = members_1_1.value;
+                    alternatives.push({ shape: member, type: member });
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (members_1_1 && !members_1_1.done && (_a = members_1.return)) _a.call(members_1);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+            try {
+                for (var enums_1 = __values(enums), enums_1_1 = enums_1.next(); !enums_1_1.done; enums_1_1 = enums_1.next()) {
+                    var name_1 = enums_1_1.value;
+                    alternatives.push({ shape: { kind: "enum", name: name_1 } });
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (enums_1_1 && !enums_1_1.done && (_b = enums_1.return)) _b.call(enums_1);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+            if (literals.length === 1)
+                alternatives.push({ shape: { kind: "constant", value: literals[0] } });
+            if (literals.length > 1)
+                alternatives.push({ shape: { kind: "literals", values: literals } });
+            entry = { isOptional: isOptional, alternatives: alternatives };
+            unionAlternatives.set(type, entry);
+        }
+        return entry;
+    }
+    /**
+     * Union members in the order they were written: `{ Coins } | { Items }` numbers Coins 0 and Items
+     * 1. TypeScript lists them by internal id instead, so the order comes from the union's type node:
+     * an alias's own declaration, or the spelling the value is reached through (see {@link spell}).
+     * Members that node does not account for (a generic alias instantiation, say) keep TypeScript's
+     * order after the others; a union with no node at all keeps it throughout, which is the same in
+     * every file of a program.
+     */
+    function orderAlternatives(alternatives, node) {
+        var e_7, _a, e_8, _b;
+        if (!node)
+            return alternatives;
+        var positions = new Map();
+        try {
+            for (var _c = __values(node.types), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var member = _d.value;
+                var memberType = typeChecker.getTypeFromTypeNode(member);
+                try {
+                    for (var _e = (e_8 = void 0, __values(memberType.isUnion() ? memberType.types : [memberType])), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var constituent = _f.value;
+                        var alternative = alternativeFor(alternatives, constituent);
+                        if (alternative && !positions.has(alternative))
+                            positions.set(alternative, positions.size);
+                    }
+                }
+                catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_8) throw e_8.error; }
+                }
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        var rank = function (alternative) { var _a; return (_a = positions.get(alternative)) !== null && _a !== void 0 ? _a : positions.size + alternatives.indexOf(alternative); };
+        return __spreadArray([], __read(alternatives), false).sort(function (a, b) { return rank(a) - rank(b); });
+    }
+    function aliasNode(type) {
+        var _a, _b;
+        var declaration = (_b = (_a = type.aliasSymbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b[0];
+        if (declaration && typescript_1.default.isTypeAliasDeclaration(declaration) && typescript_1.default.isUnionTypeNode(declaration.type)) {
+            return declaration.type;
+        }
+    }
+    /** The alternative a flattened union constituent belongs to: its own, or the group it was folded into. */
+    function alternativeFor(alternatives, constituent) {
+        var own = alternatives.find(function (alternative) { return alternative.type === constituent; });
+        if (own)
+            return own;
+        if (constituent.flags & typescript_1.default.TypeFlags.BooleanLiteral) {
+            var boolean = alternatives.find(function (alternative) { return alternative.type === typeChecker.getBooleanType(); });
+            if (boolean)
+                return boolean;
+        }
+        var enumName = robloxEnumOf(constituent);
+        if (enumName !== undefined) {
+            var whole = alternatives.find(function (alternative) {
+                return isKind(alternative.shape) &&
+                    alternative.shape.kind === "enum" &&
+                    alternative.shape.name === enumName;
+            });
+            if (whole)
+                return whole;
+        }
+        if (enumName !== undefined || (0, buildGuardFromType_1.getLiteral)(constituent, true) !== undefined) {
+            return alternatives.find(function (alternative) {
+                return isKind(alternative.shape) &&
+                    (alternative.shape.kind === "constant" || alternative.shape.kind === "literals");
+            });
+        }
+    }
+    /** `Material` for `Enum.Material.Plastic`. */
+    function robloxEnumOf(type) {
+        var symbol = type.getSymbol();
+        var enumNamespace = resolve("Enum");
+        var group = symbol === null || symbol === void 0 ? void 0 : symbol.parent;
+        if ((group === null || group === void 0 ? void 0 : group.parent) && enumNamespace && typeChecker.getMergedSymbol(group.parent) === enumNamespace) {
+            return group.name;
+        }
+    }
+    /**
+     * The shape of `type` as written at `node`. TypeScript keeps one type for every spelling of an
+     * anonymous union -- `string | number` here and `number | string` elsewhere are the same object
+     * -- so its member order, which is the wire tag, has to come from the spelling the value is
+     * reached through: a union node gives a union kind numbered as written, and the walk goes on
+     * into array elements, `Set`, `Map` and `Promise` arguments, tuple elements, `readonly` and
+     * parentheses. Where the node adds nothing -- a reference to an alias, whose own declaration
+     * decides; a generic's type argument, which is not where the value is reached -- the type
+     * itself, whose unions keep TypeScript's order. Either way the sender and the receiver of a
+     * value go through the same declaration and number its members the same way.
+     */
+    function spell(node, type) {
+        if (!node)
+            return type;
+        if (typescript_1.default.isParenthesizedTypeNode(node))
+            return spell(node.type, type);
+        if (typescript_1.default.isTypeOperatorNode(node) && node.operator === typescript_1.default.SyntaxKind.ReadonlyKeyword) {
+            return spell(node.type, type);
+        }
+        if (typescript_1.default.isUnionTypeNode(node)) {
+            return type.isUnion() ? classifyUnion(type, node) : type;
+        }
+        if (typescript_1.default.isArrayTypeNode(node)) {
+            var kind = describe(type);
+            if (kind.kind !== "array" || isKind(kind.element))
+                return type;
+            return { kind: "array", element: spell(node.elementType, kind.element) };
+        }
+        if (typescript_1.default.isTypeReferenceNode(node) && node.typeArguments) {
+            var args = node.typeArguments;
+            var written = typeChecker.getTypeFromTypeNode(node);
+            // `Promise<T>` in a declaration: what crosses is `T`, so its spelling is the argument.
+            if (written !== type) {
+                return args.length === 1 && unwrapPromise(state, written) === type ? spell(args[0], type) : type;
+            }
+            var kind = describe(type);
+            if ((kind.kind === "array" || kind.kind === "set") && args.length === 1 && !isKind(kind.element)) {
+                return { kind: kind.kind, element: spell(args[0], kind.element) };
+            }
+            if (kind.kind === "map" && args.length === 2 && !isKind(kind.key) && !isKind(kind.value)) {
+                return { kind: "map", key: spell(args[0], kind.key), value: spell(args[1], kind.value) };
+            }
+            return type;
+        }
+        if (typescript_1.default.isTupleTypeNode(node) && (0, isTupleType_1.isTupleType)(state, type))
+            return listOf(type, node);
+        return type;
+    }
+    /** A tuple element or parameter: a rest element's node is the array, its type the element. */
+    function spellElement(node, type, rest) {
+        var _a;
+        if (!node || !rest)
+            return spell(node, type);
+        if (typescript_1.default.isArrayTypeNode(node))
+            return spell(node.elementType, type);
+        if (typescript_1.default.isTypeReferenceNode(node) && ((_a = node.typeArguments) === null || _a === void 0 ? void 0 : _a.length) === 1) {
+            return spell(node.typeArguments[0], type);
+        }
+        return type;
+    }
+    /** The node a tuple element's type was written in, past its name, `?` or `...`. */
+    function tupleElementNode(element) {
+        if (!element)
+            return;
+        if (typescript_1.default.isNamedTupleMember(element) || typescript_1.default.isRestTypeNode(element) || typescript_1.default.isOptionalTypeNode(element)) {
+            return element.type;
+        }
+        return element;
+    }
+    /** A property's, parameter's or tuple member's declared type node, where its unions were written. */
+    function declaredTypeNode(declaration) {
+        if (!declaration)
+            return;
+        if (typescript_1.default.isPropertySignature(declaration) ||
+            typescript_1.default.isPropertyDeclaration(declaration) ||
+            typescript_1.default.isParameter(declaration) ||
+            typescript_1.default.isNamedTupleMember(declaration)) {
+            return declaration.type;
+        }
+    }
+    function classifyIntersection(type) {
+        // `LuaTuple<T>` is `T & { LUA_TUPLE: never }`: several values at runtime, never a table.
+        if (type.types.some(function (member) { return member.getProperty("LUA_TUPLE") !== undefined; })) {
+            fail("a LuaTuple is several values at runtime, not a table; declare a tuple type such as `[A, B]` instead");
+        }
+        var brand = findBrand(type);
+        var disjoint = type.types.find(function (member) { return (member.flags & tsInternals_1.TYPE_FLAG_DISJOINT_DOMAINS) !== 0; });
+        if (disjoint) {
+            if (disjoint.flags & typescript_1.default.TypeFlags.Number) {
+                if (brand === VARINT_BRAND)
+                    return { kind: "varint" };
+                return { kind: "number", width: brand && NUMBER_BRANDS.has(brand) ? brand : "f64" };
+            }
+            if (disjoint.flags & typescript_1.default.TypeFlags.String) {
+                return { kind: "string", length: (brand && STRING_BRANDS[brand]) || "v" };
+            }
+            return describe(disjoint);
+        }
+        var bufferSymbol = resolve("buffer");
+        if (type.types.some(function (member) { return member.getSymbol() === bufferSymbol; })) {
+            return { kind: "buffer", length: (brand && BUFFER_BRANDS[brand]) || "v" };
+        }
+        var datatype = type.types.find(function (member) {
+            var _a;
+            var name = (_a = member.getSymbol()) === null || _a === void 0 ? void 0 : _a.name;
+            return (name !== undefined &&
+                (DATATYPES[name] !== undefined || name === "CFrame") &&
+                member.getSymbol() === resolve(name));
+        });
+        if (datatype)
+            return describe(datatype);
+        if (type.types.some(function (member) { return (0, buildGuardFromType_1.isInstanceType)(member); }))
+            return { kind: "blob", typeofName: "Instance" };
+        if (type.types.some(function (member) { return isRobloxType(member.getSymbol()); }) || hasNominalMarker(type)) {
+            return { kind: "blob" };
+        }
+        return classifyObject(type);
+    }
+    /** The literal in `number & { __brand: "u8" }`, whatever the property is called. */
+    function findBrand(type) {
+        var e_9, _a, e_10, _b;
+        try {
+            for (var _c = __values(type.types), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var member = _d.value;
+                if ((member.flags & typescript_1.default.TypeFlags.Object) === 0)
+                    continue;
+                try {
+                    for (var _e = (e_10 = void 0, __values(member.getProperties())), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var property = _f.value;
+                        var propertyType = typeChecker.getTypeOfPropertyOfType(member, property.name);
+                        if (propertyType === null || propertyType === void 0 ? void 0 : propertyType.isStringLiteral()) {
+                            var brand = propertyType.value;
+                            if (NUMBER_BRANDS.has(brand) || brand === VARINT_BRAND)
+                                return brand;
+                            if (brand in STRING_BRANDS || brand in BUFFER_BRANDS)
+                                return brand;
+                        }
+                    }
+                }
+                catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_10) throw e_10.error; }
+                }
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+    }
+    function classifyObject(type) {
+        var indexInfos = typeChecker.getIndexInfosOfType(type);
+        var properties = type.getProperties().filter(function (property) {
+            var propertyType = typeChecker.getTypeOfPropertyOfType(type, property.name);
+            return (propertyType !== undefined &&
+                (propertyType.flags & (typescript_1.default.TypeFlags.Never | typescript_1.default.TypeFlags.UniqueESSymbol)) === 0);
+        });
+        if (properties.length === 0 && indexInfos.length === 0)
+            return { kind: "blob" };
+        if (indexInfos.length > 0) {
+            // Named properties next to an index signature, or several signatures, have no single layout.
+            if (properties.length > 0 || indexInfos.length > 1)
+                return { kind: "blob" };
+            return { kind: "map", key: indexInfos[0].keyType, value: indexInfos[0].type };
+        }
+        // Declaration order, which every compilation of the same source shares.
+        var fields = properties.map(function (property) {
+            var propertyType = typeChecker.getTypeOfPropertyOfType(type, property.name);
+            if (propertyType.getCallSignatures().length > 0)
+                fail("property '".concat(property.name, "' is a function"));
+            var written = spell(declaredTypeNode(property.valueDeclaration), propertyType);
+            var optional = (property.flags & typescript_1.default.SymbolFlags.Optional) !== 0 && !hasUndefined(propertyType);
+            var shape = optional ? { kind: "optional", inner: written } : written;
+            return { name: property.name, shape: shape };
+        });
+        return { kind: "object", fields: fields };
+    }
+    function hasUndefined(type) {
+        return (type.isUnion() &&
+            type.types.some(function (member) { return (member.flags & (typescript_1.default.TypeFlags.Undefined | typescript_1.default.TypeFlags.Void)) !== 0; }));
+    }
+    // --- layout --------------------------------------------------------------------------------------
+    function layoutOf(shape) {
+        var memo = layouts.get(shape);
+        if (memo)
+            return memo;
+        // A type reached again while it is being measured: its size is not fixed, whatever it is.
+        if (visiting.has(shape)) {
+            provisional += 1;
+            return { size: undefined, min: 0, blobs: false, zeros: false };
+        }
+        visiting.add(shape);
+        var before = provisional;
+        var layout = computeLayout(shape);
+        visiting.delete(shape);
+        // A result that saw a cycle is only final for the type that closes it, at the top of the chain.
+        if (provisional === before || visiting.size === 0)
+            layouts.set(shape, layout);
+        if (visiting.size === 0)
+            provisional = 0;
+        return layout;
+    }
+    function computeLayout(shape) {
+        if (!isKind(shape)) {
+            trail.push(shape);
+            var layout = layoutOf(describe(shape));
+            trail.pop();
+            return layout;
+        }
+        var fixed = function (size, blobs) {
+            if (blobs === void 0) { blobs = false; }
+            return ({ size: size, min: size, blobs: blobs, zeros: false });
+        };
+        var kind = shape;
+        switch (kind.kind) {
+            case "number":
+                return fixed(WIDTH_SIZE[kind.width]);
+            case "varint":
+                return { size: undefined, min: 1, blobs: false, zeros: false };
+            case "boolean":
+                return fixed(1);
+            case "string":
+            case "buffer":
+                return { size: undefined, min: lengthMin(kind.length), blobs: false, zeros: false };
+            case "constant":
+            case "nothing":
+                return fixed(0);
+            case "literals":
+                return fixed(kind.values.length > 0xff ? 2 : 1);
+            case "blob":
+                return fixed(BLOB_SIZE, true);
+            case "datatype":
+                return fixed(DATATYPES[kind.name].reduce(function (total, _a) {
+                    var _b = __read(_a, 1), width = _b[0];
+                    return total + WIDTH_SIZE[width];
+                }, 0));
+            case "cframe":
+                return fixed(CFRAME_COMPONENTS * 4);
+            case "enum":
+                return fixed(2);
+            case "optional": {
+                var inner = layoutOf(kind.inner);
+                return { size: undefined, min: 1, blobs: inner.blobs, zeros: inner.zeros };
+            }
+            case "array":
+            case "set": {
+                var element = layoutOf(kind.element);
+                // A zero-size element is a fixed size of 0; a type still being measured reports `min` 0 too.
+                return { size: undefined, min: 1, blobs: element.blobs, zeros: element.size === 0 || element.zeros };
+            }
+            case "map": {
+                var key = layoutOf(kind.key);
+                var value = layoutOf(kind.value);
+                return {
+                    size: undefined,
+                    min: 1,
+                    blobs: key.blobs || value.blobs,
+                    zeros: (key.size === 0 && value.size === 0) || key.zeros || value.zeros,
+                };
+            }
+            case "list": {
+                var layout = sumLayouts(kind.elements.map(function (element) { return layoutOf(element); }));
+                if (kind.rest) {
+                    var rest = layoutOf(kind.rest);
+                    return {
+                        size: undefined,
+                        min: layout.min + 1,
+                        blobs: layout.blobs || rest.blobs,
+                        zeros: layout.zeros || rest.size === 0 || rest.zeros,
+                    };
+                }
+                return layout;
+            }
+            case "object":
+                return sumLayouts(kind.fields.map(function (field) { return layoutOf(field.shape); }));
+            case "union": {
+                var members = kind.alternatives.map(function (alternative) { return layoutOf(alternative.shape); });
+                var sizes = new Set(members.map(function (member) { return member.size; }));
+                var size = sizes.size === 1 && !sizes.has(undefined) ? 1 + members[0].size : undefined;
+                return {
+                    size: size,
+                    min: 1 + Math.min.apply(Math, __spreadArray([], __read(members.map(function (member) { return member.min; })), false)),
+                    blobs: members.some(function (member) { return member.blobs; }),
+                    zeros: members.some(function (member) { return member.zeros; }),
+                };
+            }
+        }
+    }
+    function sumLayouts(layouts) {
+        var e_11, _a;
+        var size = 0;
+        var min = 0;
+        var blobs = false;
+        var zeros = false;
+        try {
+            for (var layouts_1 = __values(layouts), layouts_1_1 = layouts_1.next(); !layouts_1_1.done; layouts_1_1 = layouts_1.next()) {
+                var layout = layouts_1_1.value;
+                size = size === undefined || layout.size === undefined ? undefined : size + layout.size;
+                min += layout.min;
+                blobs || (blobs = layout.blobs);
+                zeros || (zeros = layout.zeros);
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (layouts_1_1 && !layouts_1_1.done && (_a = layouts_1.return)) _a.call(layouts_1);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
+        return { size: size, min: min, blobs: blobs, zeros: zeros };
+    }
+    // --- hoisting ------------------------------------------------------------------------------------
+    /** Named object-like types with a variable size get their own functions; everything else inlines. */
+    function hoist(type) {
+        var existing = hoisted.get(type);
+        if (existing)
+            return existing;
+        var name = hoistName(type);
+        if (name === undefined)
+            return;
+        var layout = layoutOf(type);
+        if (layout.size !== undefined)
+            return;
+        // Only structured types are worth a function; a named alias of a string or an array inlines.
+        var structure = describe(type).kind;
+        if (structure !== "object" && structure !== "union" && structure !== "list")
+            return;
+        var info = { size: uid("s_".concat(name)), write: uid("w_".concat(name)), read: uid("r_".concat(name)), layout: layout };
+        hoisted.set(type, info);
+        var withBlobs = function (list, entry) { return (layout.blobs ? __spreadArray(__spreadArray([], __read(list), false), [entry], false) : list); };
+        var blobsParameter = ["blobs", T.blobs()];
+        var writeParameters = [
+            ["buf", T.buffer()],
+            ["o", T.number()],
+            ["v", T.unknown()],
+        ];
+        var readParameters = [
+            ["buf", T.buffer()],
+            ["o", T.number()],
+        ];
+        declarations.push(letDecl(info.size, undefined, T.fn([["v", T.unknown()]], T.number())));
+        declarations.push(letDecl(info.write, undefined, T.fn(withBlobs(writeParameters, blobsParameter), T.number())));
+        declarations.push(letDecl(info.read, undefined, T.fn(withBlobs(readParameters, blobsParameter), T.tuple([T.unknown(), T.number()]))));
+        // The bodies are built after the identifiers exist, which is what lets a type refer to itself.
+        var kind = describe(type);
+        trail.push(type);
+        var value = parameter("v");
+        var sizeBody = new Array();
+        var size = emitSize(kind, value, sizeBody);
+        sizeBody.push(factory_1.f.returnStatement(size));
+        definitions.push(assign(info.size, factory_1.f.arrowFunction(factory_1.f.block(sizeBody), [factory_1.f.parameterDeclaration(value)])));
+        var buf = uid("buf");
+        var o = uid("o");
+        var blobs = layout.blobs ? uid("blobs") : undefined;
+        var parameters = function () {
+            var names = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                names[_i] = arguments[_i];
+            }
+            return names.map(function (id) { return factory_1.f.parameterDeclaration(id); });
+        };
+        var writeBody = new Array();
+        var writeCtx = { buf: buf, blobs: blobs, cursor: { variable: o, base: o, offset: 0 }, out: writeBody };
+        emitWrite(kind, value, writeCtx);
+        sync(writeCtx);
+        writeBody.push(factory_1.f.returnStatement(o));
+        definitions.push(assign(info.write, factory_1.f.arrowFunction(factory_1.f.block(writeBody), parameters.apply(void 0, __spreadArray([], __read(withBlobs([buf, o, value], blobs)), false)))));
+        var readBody = new Array();
+        var readCtx = { buf: buf, blobs: blobs, cursor: { variable: o, base: o, offset: 0 }, out: readBody };
+        var result = emitRead(kind, readCtx);
+        var bound = factory_1.f.is.identifier(result) || isLiteral(result) ? result : bind(readBody, result, "value");
+        sync(readCtx);
+        readBody.push(factory_1.f.returnStatement(factory_1.f.call("$tuple", [bound, o])));
+        definitions.push(assign(info.read, factory_1.f.arrowFunction(factory_1.f.block(readBody), parameters.apply(void 0, __spreadArray([], __read(withBlobs([buf, o], blobs)), false)))));
+        trail.pop();
+        return info;
+    }
+    function hoistName(type) {
+        var _a, _b, _c;
+        if ((type.flags & (typescript_1.default.TypeFlags.Object | typescript_1.default.TypeFlags.UnionOrIntersection)) === 0)
+            return;
+        if ((0, buildGuardFromType_1.isInstanceType)(type) || (0, buildGuardFromType_1.getLiteral)(type) !== undefined)
+            return;
+        var symbolName = (_b = (_a = type.aliasSymbol) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : (_c = type.symbol) === null || _c === void 0 ? void 0 : _c.name;
+        if (symbolName === undefined || symbolName === "__type" || symbolName === "__object")
+            return;
+        if (symbolName === "Array" || symbolName === "ReadonlyArray")
+            return;
+        if (DATATYPES[symbolName] !== undefined || symbolName === "CFrame")
+            return;
+        return symbolName.replace(/\W/g, "_");
+    }
+    function guardFor(type) {
+        var guard = guards.get(type);
+        if (!guard) {
+            guard = uid("guard");
+            tables.push(constDecl(guard, (0, buildGuardFromType_1.buildGuardFromType)(state, diagnosticNode, type, file)));
+            guards.set(type, guard);
+        }
+        return guard;
+    }
+    /** `Enum.X` items by `Value`, built once: values are not always below 256, so they are sent as u16. */
+    function enumTableFor(name) {
+        var table = enumTables.get(name);
+        if (!table) {
+            table = uid("enum_".concat(name));
+            var item = uid("item");
+            tables.push(constDecl(table, construct("Map", []), factory_1.f.referenceType("Map", [T.number(), T.enumItem()])), forOf(item, factory_1.f.call(prop(prop("Enum", name), "GetEnumItems"), []), [
+                factory_1.f.statement(factory_1.f.call(prop(table, "set"), [prop(item, "Value"), item])),
+            ]));
+            enumTables.set(name, table);
+        }
+        return table;
+    }
+    /** A literal union's members as a list (decode) and as a lookup from member to index (encode). */
+    function literalTablesFor(kind) {
+        var entry = literalTables.get(kind);
+        if (!entry) {
+            entry = { list: uid("literals"), index: uid("literalIndex") };
+            // The key type is spelled out: inferred from the pairs, TypeScript would pick the first literal's
+            // type (`"lit"`, or one EnumItem interface) and reject the others.
+            var pairs = kind.values.map(function (value, index) { return factory_1.f.array([value, num(index)], false); });
+            tables.push(constDecl(entry.list, factory_1.f.array(kind.values, false), T.blobs()), constDecl(entry.index, construct("Map", [factory_1.f.array(pairs)], [T.defined(), T.number()]), factory_1.f.referenceType("Map", [T.defined(), T.number()])));
+            literalTables.set(kind, entry);
+        }
+        return entry;
+    }
+    // --- varints -------------------------------------------------------------------------------------
+    /**
+     * The LEB128 helpers, hoisted once per file: seven bits per byte, low bits first, the high bit set
+     * on every byte but the last. Reading gives up after five bytes, so a hostile buffer cannot loop.
+     */
+    function varintHelpers() {
+        if (varint)
+            return varint;
+        varint = { size: uid("vsize"), write: uid("vwrite"), read: uid("vread") };
+        var below = function (value, limit) { return factory_1.f.binary(value, typescript_1.default.SyntaxKind.LessThanToken, num(limit)); };
+        var parameter = function (id, type) { return factory_1.f.parameterDeclaration(id, type); };
+        // vsize: `n < 128 ? 1 : n < 16384 ? 2 : ... : 5`
+        var sizeOf = uid("n");
+        var size = num(VARINT_MAX_BYTES);
+        for (var bytes = VARINT_MAX_BYTES - 1; bytes >= 1; bytes--) {
+            size = conditional(below(sizeOf, Math.pow(128, bytes)), num(bytes), size);
+        }
+        tables.push(constDecl(varint.size, factory_1.f.arrowFunction(size, [parameter(sizeOf, T.number())])));
+        // vwrite: continuation bytes while 128 or more remain, then the last byte; returns the new position.
+        var wbuf = uid("buf");
+        var wo = uid("o");
+        var wn = uid("n");
+        tables.push(constDecl(varint.write, factory_1.f.arrowFunction(factory_1.f.block([
+            factory.createWhileStatement(factory_1.f.binary(wn, typescript_1.default.SyntaxKind.GreaterThanEqualsToken, num(128)), factory_1.f.block([
+                factory_1.f.statement(bufferCall("writeu8", [
+                    wbuf,
+                    wo,
+                    factory_1.f.binary(factory_1.f.binary(wn, typescript_1.default.SyntaxKind.PercentToken, num(128)), typescript_1.default.SyntaxKind.PlusToken, num(128)),
+                ])),
+                addAssign(wo, num(1)),
+                assign(wn, factory_1.f.call(prop("math", "floor"), [factory_1.f.binary(wn, typescript_1.default.SyntaxKind.SlashToken, num(128))])),
+            ])),
+            factory_1.f.statement(bufferCall("writeu8", [wbuf, wo, wn])),
+            factory_1.f.returnStatement(add(wo, 1)),
+        ]), [parameter(wbuf, T.buffer()), parameter(wo, T.number()), parameter(wn, T.number())])));
+        // vread: `n += (b % 128) * scale` per byte until one is below 128; returns the value and position.
+        var rbuf = uid("buf");
+        var ro = uid("o");
+        var rn = uid("n");
+        var byte = uid("b");
+        var scale = uid("scale");
+        tables.push(constDecl(varint.read, factory_1.f.arrowFunction(factory_1.f.block([
+            letDecl(rn, num(0)),
+            letDecl(scale, num(1)),
+            factory.createWhileStatement(factory_1.f.bool(true), factory_1.f.block([
+                constDecl(byte, bufferCall("readu8", [rbuf, ro])),
+                addAssign(ro, num(1)),
+                addAssign(rn, factory_1.f.binary(factory_1.f.binary(byte, typescript_1.default.SyntaxKind.PercentToken, num(128)), typescript_1.default.SyntaxKind.AsteriskToken, scale)),
+                ifStatement(below(byte, 128), [factory_1.f.returnStatement(factory_1.f.call("$tuple", [rn, ro]))]),
+                factory_1.f.statement(factory_1.f.binary(scale, typescript_1.default.SyntaxKind.AsteriskEqualsToken, num(128))),
+                ifStatement(factory_1.f.binary(scale, typescript_1.default.SyntaxKind.GreaterThanToken, num(Math.pow(128, (VARINT_MAX_BYTES - 1)))), [raise(MALFORMED)]),
+            ])),
+        ]), [parameter(rbuf, T.buffer()), parameter(ro, T.number())])));
+        return varint;
+    }
+    /** `o = vwrite(buf, o, n)`: the cursor re-bases on the position variable. */
+    function writeVarint(ctx, n) {
+        var variable = ctx.cursor.variable;
+        if (!variable)
+            throw new Error("Flamework: a varint inside a fixed layout");
+        ctx.out.push(assign(variable, factory_1.f.call(varintHelpers().write, [ctx.buf, at(ctx), n])));
+        ctx.cursor.base = variable;
+        ctx.cursor.offset = 0;
+    }
+    /** `const [n, o2] = vread(buf, o)`: the cursor re-bases on the position that came back. */
+    function readVarint(ctx, hint) {
+        if (hint === void 0) { hint = "n"; }
+        if (!ctx.cursor.variable)
+            throw new Error("Flamework: a varint inside a fixed layout");
+        var n = uid(hint);
+        var next = uid("o");
+        ctx.out.push(constDecl(factory_1.f.arrayBindingDeclaration([n, next]), factory_1.f.call(varintHelpers().read, [ctx.buf, at(ctx)])));
+        ctx.cursor.base = next;
+        ctx.cursor.offset = 0;
+        return n;
+    }
+    /** `<prefix> + length`: a constant prefix for a branded width, `vsize(length)` otherwise. */
+    function sizeWithLength(out, width, length) {
+        if (width !== "v")
+            return add(length, WIDTH_SIZE[width]);
+        var bound = bind(out, length, "length");
+        return add(factory_1.f.call(varintHelpers().size, [bound]), bound);
+    }
+    /** `vsize(n) + n * size` for a run of `n` fixed-size elements. */
+    function countedSize(prefix, count, size) {
+        if (size === 0)
+            return prefix;
+        return add(prefix, factory_1.f.binary(count, typescript_1.default.SyntaxKind.AsteriskToken, num(size)));
+    }
+    /**
+     * Sets and maps have no cheap length, so the elements are counted in the pass that measures them:
+     * `let size = 0, n = 0; for (...) { n += 1; size += <element>; } size += vsize(n)`.
+     */
+    function countedInPass(out, collection, binding, element) {
+        var total = uid("size");
+        var count = uid("n");
+        out.push(letDecl(total, num(0)), letDecl(count, num(0)));
+        var body = new Array();
+        body.push(addAssign(count, num(1)));
+        body.push(addAssign(total, element(body)));
+        out.push(forOf(binding, collection, body));
+        out.push(addAssign(total, factory_1.f.call(varintHelpers().size, [count])));
+        return total;
+    }
+    // --- unions --------------------------------------------------------------------------------------
+    /**
+     * The order the members are tested in when encoding: every member with a test of its own first,
+     * a blob that matches anything last. The tag written is still the member's own index.
+     */
+    function evaluationOrder(union) {
+        var catchAll = function (index) {
+            var kind = describe(union.alternatives[index].shape);
+            return kind.kind === "blob" && kind.typeofName === undefined ? 1 : 0;
+        };
+        return union.alternatives.map(function (_, index) { return index; }).sort(function (a, b) { return catchAll(a) - catchAll(b); });
+    }
+    /**
+     * A cheap test for an object member of a union: its discriminant compared (`v.kind == "a"`), or
+     * else the presence of a required key no other object member has (`v.Coins ~= nil`). Neither
+     * leaves a guard in the output; a member with no such test falls back to one.
+     */
+    function objectTest(union, kind, record) {
+        var discriminant = discriminantOf(union);
+        var field = discriminant !== undefined ? kind.fields.find(function (field) { return field.name === discriminant; }) : undefined;
+        if (field) {
+            var constant = describe(field.shape);
+            return equals(fieldAccess(record, field.name), constant.value);
+        }
+        // A collection among the members could hold any key, so presence is only trusted when the
+        // other members are objects or not tables at all.
+        var others = union.alternatives.map(function (other) { return describe(other.shape); }).filter(function (other) { return other !== kind; });
+        if (others.some(function (other) { return TABLE_KINDS.has(other.kind) && other.kind !== "object"; }))
+            return;
+        var unique = kind.fields.find(function (candidate) {
+            var shape = describe(candidate.shape);
+            if (shape.kind === "optional" || shape.kind === "nothing")
+                return false;
+            return others.every(function (other) { return other.kind !== "object" || !other.fields.some(function (field) { return field.name === candidate.name; }); });
+        });
+        if (unique)
+            return notNil(fieldAccess(record, unique.name));
+    }
+    /**
+     * A property every object member has with a distinct literal type (`kind: "circle"` against
+     * `kind: "rect"`). Comparing it is cheaper than a guard and leaves no guard in the output.
+     */
+    function discriminantOf(union) {
+        var e_12, _a;
+        var _b, _c;
+        if (discriminants.has(union))
+            return discriminants.get(union);
+        var objects = union.alternatives
+            .map(function (alternative) { return describe(alternative.shape); })
+            .filter(function (kind) { return kind.kind === "object"; });
+        var discriminant;
+        var _loop_1 = function (field) {
+            var seen = new Set();
+            var distinct = objects.every(function (object) {
+                var candidate = object.fields.find(function (other) { return other.name === field.name; });
+                var kind = candidate && describe(candidate.shape);
+                if (!kind || kind.kind !== "constant")
+                    return false;
+                var text = printLiteral(kind.value);
+                if (seen.has(text))
+                    return false;
+                seen.add(text);
+                return true;
+            });
+            if (distinct) {
+                discriminant = field.name;
+                return "break";
+            }
+        };
+        try {
+            for (var _d = __values((_c = (_b = objects[0]) === null || _b === void 0 ? void 0 : _b.fields) !== null && _c !== void 0 ? _c : []), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var field = _e.value;
+                var state_1 = _loop_1(field);
+                if (state_1 === "break")
+                    break;
+            }
+        }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_12) throw e_12.error; }
+        }
+        discriminants.set(union, discriminant);
+        return discriminant;
+    }
+    // --- cursor --------------------------------------------------------------------------------------
+    function at(ctx, extra) {
+        if (extra === void 0) { extra = 0; }
+        var offset = ctx.cursor.offset + extra;
+        return ctx.cursor.base ? add(ctx.cursor.base, offset) : num(offset);
+    }
+    /** Folds the pending constant (and any hoisted read's result) into the position variable. */
+    function sync(ctx) {
+        var cursor = ctx.cursor;
+        if (cursor.base === cursor.variable && cursor.offset === 0)
+            return;
+        if (!cursor.variable)
+            throw new Error("Flamework: a variable-size write inside a fixed layout");
+        if (cursor.base === cursor.variable) {
+            ctx.out.push(addAssign(cursor.variable, num(cursor.offset)));
+        }
+        else {
+            ctx.out.push(assign(cursor.variable, at(ctx)));
+        }
+        cursor.base = cursor.variable;
+        cursor.offset = 0;
+    }
+    /** Moves the position by a runtime amount, folding the pending constant into the same statement. */
+    function advanceBy(ctx, amount) {
+        var cursor = ctx.cursor;
+        if (!cursor.variable)
+            throw new Error("Flamework: a variable-size write inside a fixed layout");
+        if (cursor.base === cursor.variable) {
+            ctx.out.push(addAssign(cursor.variable, add(amount, cursor.offset)));
+        }
+        else {
+            ctx.out.push(assign(cursor.variable, add(at(ctx), amount)));
+        }
+        cursor.base = cursor.variable;
+        cursor.offset = 0;
+    }
+    /**
+     * Statements for a conditional or repeated body. In a variable layout the body starts from the
+     * synced position variable and leaves it exact; in a fixed layout it inherits the offset and the
+     * caller advances past it.
+     */
+    function branch(ctx, build) {
+        if (ctx.cursor.variable) {
+            sync(ctx);
+            var child_1 = __assign(__assign({}, ctx), { cursor: { variable: ctx.cursor.variable, base: ctx.cursor.variable, offset: 0 }, out: [] });
+            build(child_1);
+            sync(child_1);
+            return child_1.out;
+        }
+        var child = __assign(__assign({}, ctx), { cursor: __assign({}, ctx.cursor), out: [] });
+        build(child);
+        return child.out;
+    }
+    /**
+     * A value as a local: identifiers and casts of identifiers are returned as they are, except for a
+     * parameter, which is copied so that the macros it reaches see a `const` (see {@link parameters}).
+     */
+    function bind(out, value, hint, type) {
+        if (!type) {
+            if (factory_1.f.is.identifier(value) && !isParameterReference(value))
+                return value;
+            if (typescript_1.default.isAsExpression(value) && factory_1.f.is.identifier(value.expression))
+                return value;
+        }
+        var id = uid(hint);
+        out.push(constDecl(id, value, type));
+        return id;
+    }
+    function isNilLiteral(expression) {
+        return typescript_1.default.isIdentifier(expression) && expression.text === "undefined";
+    }
+    function isLiteral(expression) {
+        return factory_1.f.is.string(expression) || factory_1.f.is.number(expression) || factory_1.f.is.bool(expression) || factory_1.f.is.nil(expression);
+    }
+    function fieldAccess(object, name) {
+        return IDENTIFIER.test(name)
+            ? factory.createPropertyAccessExpression(object, name)
+            : factory.createElementAccessExpression(object, factory_1.f.string(name));
+    }
+    function path(object, names) {
+        return names.reduce(function (current, name) { return prop(current, name); }, object);
+    }
+    // --- size ----------------------------------------------------------------------------------------
+    /** The byte count of `value`: a constant for fixed layouts, otherwise an expression (plus statements). */
+    function emitSize(shape, value, out) {
+        var e_13, _a, e_14, _b;
+        var layout = layoutOf(shape);
+        if (layout.size !== undefined)
+            return num(layout.size);
+        if (!isKind(shape)) {
+            var info = hoist(shape);
+            if (info)
+                return factory_1.f.call(info.size, [value]);
+        }
+        var kind = describe(shape);
+        switch (kind.kind) {
+            case "string":
+                return sizeWithLength(out, kind.length, factory_1.f.call(prop(factory_1.f.as(value, T.string()), "size"), []));
+            case "buffer":
+                return sizeWithLength(out, kind.length, bufferCall("len", [factory_1.f.as(value, T.buffer())]));
+            case "varint":
+                return factory_1.f.call(varintHelpers().size, [factory_1.f.as(value, T.number())]);
+            case "optional": {
+                if (isNilLiteral(value))
+                    return num(1);
+                var inner = layoutOf(kind.inner);
+                var v = bind(out, value, "v");
+                if (inner.size !== undefined) {
+                    return conditional(notNil(v), num(1 + inner.size), num(1));
+                }
+                var total = uid("size");
+                out.push(letDecl(total, num(1)));
+                var body = new Array();
+                body.push(addAssign(total, emitSize(kind.inner, v, body)));
+                out.push(ifStatement(notNil(v), body));
+                return total;
+            }
+            case "array": {
+                var array = bind(out, factory_1.f.as(value, T.array()), "array");
+                var count = bind(out, factory_1.f.call(prop(array, "size"), []), "n");
+                var prefix = factory_1.f.call(varintHelpers().size, [count]);
+                var element = layoutOf(kind.element);
+                if (element.size !== undefined)
+                    return countedSize(prefix, count, element.size);
+                var total = uid("size");
+                var item = uid("item");
+                out.push(letDecl(total, prefix));
+                var body = new Array();
+                body.push(addAssign(total, emitSize(kind.element, item, body)));
+                out.push(forOf(item, array, body));
+                return total;
+            }
+            case "set": {
+                var set = bind(out, factory_1.f.as(value, T.set()), "set");
+                var element_1 = layoutOf(kind.element);
+                var item_1 = uid("item");
+                return countedInPass(out, set, item_1, function (body) {
+                    return element_1.size !== undefined ? num(element_1.size) : emitSize(kind.element, item_1, body);
+                });
+            }
+            case "map": {
+                var map = bind(out, factory_1.f.as(value, T.map()), "map");
+                var key_1 = uid("key");
+                var entry_1 = uid("entry");
+                return countedInPass(out, map, factory_1.f.arrayBindingDeclaration([key_1, entry_1]), function (body) {
+                    return add(emitSize(kind.key, key_1, body), emitSize(kind.value, entry_1, body));
+                });
+            }
+            case "list": {
+                var list_1 = bind(out, factory_1.f.as(value, T.array()), "list");
+                var total_1 = new Sum();
+                kind.elements.forEach(function (element, index) {
+                    total_1.add(emitSize(element, factory_1.f.elementAccessExpression(list_1, num(index)), out));
+                });
+                if (kind.rest) {
+                    var rest = layoutOf(kind.rest);
+                    var count = restCount(out, list_1, kind.elements.length);
+                    var prefix = factory_1.f.call(varintHelpers().size, [count]);
+                    if (rest.size !== undefined) {
+                        total_1.add(countedSize(prefix, count, rest.size));
+                        return total_1.build();
+                    }
+                    var sum = uid("size");
+                    var index = uid("i");
+                    total_1.add(prefix);
+                    out.push(letDecl(sum, total_1.build()));
+                    var body = new Array();
+                    var element = factory_1.f.elementAccessExpression(list_1, factory_1.f.binary(index, typescript_1.default.SyntaxKind.MinusToken, num(1)));
+                    body.push(addAssign(sum, emitSize(kind.rest, element, body)));
+                    out.push(forOf(index, range(num(kind.elements.length + 1), add(count, kind.elements.length)), body));
+                    return sum;
+                }
+                return total_1.build();
+            }
+            case "object": {
+                var object = bind(out, factory_1.f.as(value, T.record()), "object");
+                var total = new Sum();
+                try {
+                    for (var _c = __values(kind.fields), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var field = _d.value;
+                        total.add(emitSize(field.shape, fieldAccess(object, field.name), out));
+                    }
+                }
+                catch (e_13_1) { e_13 = { error: e_13_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                    }
+                    finally { if (e_13) throw e_13.error; }
+                }
+                return total.build();
+            }
+            case "union": {
+                var v = bind(out, value, "v");
+                var total = uid("size");
+                out.push(letDecl(total, num(1)));
+                var chain = void 0;
+                try {
+                    for (var _e = __values(evaluationOrder(kind).reverse()), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var i = _f.value;
+                        var alternative = kind.alternatives[i];
+                        var layout_1 = layoutOf(alternative.shape);
+                        var body = new Array();
+                        var size = layout_1.size !== undefined ? num(layout_1.size) : emitSize(alternative.shape, v, body);
+                        if (!(factory_1.f.is.number(size) && size.text === "0"))
+                            body.push(addAssign(total, size));
+                        if (body.length === 0 && chain === undefined)
+                            continue;
+                        chain = ifStatement(discriminate(kind, i, v), body, chain);
+                    }
+                }
+                catch (e_14_1) { e_14 = { error: e_14_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_14) throw e_14.error; }
+                }
+                if (chain)
+                    out.push(chain);
+                return total;
+            }
+            default:
+                throw new Error("Flamework: '".concat(kind.kind, "' has a fixed size"));
+        }
+    }
+    // --- write ---------------------------------------------------------------------------------------
+    function emitWrite(shape, value, ctx) {
+        var e_15, _a, e_16, _b, e_17, _c, e_18, _d;
+        if (!isKind(shape)) {
+            var info = hoist(shape);
+            if (info) {
+                var args = [ctx.buf, at(ctx), value];
+                if (info.layout.blobs)
+                    args.push(ctx.blobs);
+                ctx.out.push(assign(ctx.cursor.variable, factory_1.f.call(info.write, args)));
+                ctx.cursor.base = ctx.cursor.variable;
+                ctx.cursor.offset = 0;
+                return;
+            }
+        }
+        var kind = describe(shape);
+        switch (kind.kind) {
+            case "number":
+                ctx.out.push(factory_1.f.statement(bufferCall("write".concat(kind.width), [ctx.buf, at(ctx), factory_1.f.as(value, T.number())])));
+                ctx.cursor.offset += WIDTH_SIZE[kind.width];
+                return;
+            case "varint":
+                writeVarint(ctx, factory_1.f.as(value, T.number()));
+                return;
+            case "boolean":
+                // The value is the condition rather than `value === true`: an argument packed at its
+                // call site can be a literal, and `false === true` is a comparison TypeScript rejects
+                // when it checks the emitted code.
+                ctx.out.push(factory_1.f.statement(bufferCall("writeu8", [ctx.buf, at(ctx), conditional(value, num(1), num(0))])));
+                ctx.cursor.offset += 1;
+                return;
+            case "string": {
+                var text = bind(ctx.out, factory_1.f.as(value, T.string()), "text");
+                var length_1 = bind(ctx.out, factory_1.f.call(prop(text, "size"), []), "length");
+                writeLength(ctx, kind.length, length_1, "string");
+                ctx.out.push(factory_1.f.statement(bufferCall("writestring", [ctx.buf, at(ctx), text])));
+                advanceBy(ctx, length_1);
+                return;
+            }
+            case "buffer": {
+                var bytes = bind(ctx.out, factory_1.f.as(value, T.buffer()), "bytes");
+                var length_2 = bind(ctx.out, bufferCall("len", [bytes]), "length");
+                writeLength(ctx, kind.length, length_2, "buffer");
+                ctx.out.push(factory_1.f.statement(bufferCall("copy", [ctx.buf, at(ctx), bytes])));
+                advanceBy(ctx, length_2);
+                return;
+            }
+            case "constant":
+            case "nothing":
+                return;
+            case "literals": {
+                var index = literalTablesFor(kind).index;
+                var v = bind(ctx.out, value, "v");
+                var slot = bind(ctx.out, factory_1.f.call(prop(index, "get"), [factory_1.f.as(v, T.defined())]), "index");
+                ctx.out.push(ifStatement(isNil(slot), [raise("value is not one of the literals its type allows")]));
+                var width = kind.values.length > 0xff ? "u16" : "u8";
+                ctx.out.push(factory_1.f.statement(bufferCall("write".concat(width), [ctx.buf, at(ctx), slot])));
+                ctx.cursor.offset += WIDTH_SIZE[width];
+                return;
+            }
+            case "blob": {
+                var blob = bind(ctx.out, value, "blob");
+                var blobs = ctx.blobs;
+                ctx.out.push(ifStatement(notNil(blob), [
+                    factory_1.f.statement(factory_1.f.call(prop(blobs, "push"), [factory_1.f.as(blob, T.defined())])),
+                    factory_1.f.statement(bufferCall("writeu32", [ctx.buf, at(ctx), factory_1.f.call(prop(blobs, "size"), [])])),
+                ], [factory_1.f.statement(bufferCall("writeu32", [ctx.buf, at(ctx), num(0)]))]));
+                ctx.cursor.offset += BLOB_SIZE;
+                return;
+            }
+            case "datatype": {
+                var datatype = bind(ctx.out, factory_1.f.as(value, factory_1.f.referenceType(kind.name)), kind.name.toLowerCase());
+                try {
+                    for (var _e = __values(DATATYPES[kind.name]), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var _g = __read(_f.value, 2), width = _g[0], names = _g[1];
+                        ctx.out.push(factory_1.f.statement(bufferCall("write".concat(width), [ctx.buf, at(ctx), path(datatype, names)])));
+                        ctx.cursor.offset += WIDTH_SIZE[width];
+                    }
+                }
+                catch (e_15_1) { e_15 = { error: e_15_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+                    }
+                    finally { if (e_15) throw e_15.error; }
+                }
+                return;
+            }
+            case "cframe": {
+                var components = Array.from({ length: CFRAME_COMPONENTS }, function (_, i) { return uid("c".concat(i)); });
+                ctx.out.push(constDecl(factory_1.f.arrayBindingDeclaration(components), factory_1.f.call(prop(factory_1.f.as(value, factory_1.f.referenceType("CFrame")), "GetComponents"), [])));
+                try {
+                    for (var components_1 = __values(components), components_1_1 = components_1.next(); !components_1_1.done; components_1_1 = components_1.next()) {
+                        var component = components_1_1.value;
+                        ctx.out.push(factory_1.f.statement(bufferCall("writef32", [ctx.buf, at(ctx), component])));
+                        ctx.cursor.offset += 4;
+                    }
+                }
+                catch (e_16_1) { e_16 = { error: e_16_1 }; }
+                finally {
+                    try {
+                        if (components_1_1 && !components_1_1.done && (_b = components_1.return)) _b.call(components_1);
+                    }
+                    finally { if (e_16) throw e_16.error; }
+                }
+                return;
+            }
+            case "enum":
+                ctx.out.push(factory_1.f.statement(bufferCall("writeu16", [ctx.buf, at(ctx), prop(factory_1.f.as(value, T.enumItem()), "Value")])));
+                ctx.cursor.offset += 2;
+                return;
+            case "optional": {
+                if (isNilLiteral(value)) {
+                    ctx.out.push(factory_1.f.statement(bufferCall("writeu8", [ctx.buf, at(ctx), num(0)])));
+                    ctx.cursor.offset += 1;
+                    return;
+                }
+                var v_1 = bind(ctx.out, value, "v");
+                ctx.out.push(factory_1.f.statement(bufferCall("writeu8", [ctx.buf, at(ctx), conditional(notNil(v_1), num(1), num(0))])));
+                ctx.cursor.offset += 1;
+                ctx.out.push(ifStatement(notNil(v_1), branch(ctx, function (child) { return emitWrite(kind.inner, v_1, child); })));
+                return;
+            }
+            case "array": {
+                var array = bind(ctx.out, factory_1.f.as(value, T.array()), "array");
+                writeVarint(ctx, factory_1.f.call(prop(array, "size"), []));
+                var item_2 = uid("item");
+                ctx.out.push(forOf(item_2, array, branch(ctx, function (child) { return emitWrite(kind.element, item_2, child); })));
+                return;
+            }
+            case "set": {
+                var set = bind(ctx.out, factory_1.f.as(value, T.set()), "set");
+                writeCounted(ctx, set, function (item, child) { return emitWrite(kind.element, item, child); });
+                return;
+            }
+            case "map": {
+                var map = bind(ctx.out, factory_1.f.as(value, T.map()), "map");
+                var key_2 = uid("key");
+                var entry_2 = uid("entry");
+                writeCounted(ctx, map, function (_, child) {
+                    emitWrite(kind.key, key_2, child);
+                    emitWrite(kind.value, entry_2, child);
+                }, factory_1.f.arrayBindingDeclaration([key_2, entry_2]));
+                return;
+            }
+            case "list": {
+                var list_2 = bind(ctx.out, factory_1.f.as(value, T.array()), "list");
+                kind.elements.forEach(function (element, index) {
+                    emitWrite(element, factory_1.f.elementAccessExpression(list_2, num(index)), ctx);
+                });
+                if (kind.rest) {
+                    var count = restCount(ctx.out, list_2, kind.elements.length);
+                    writeVarint(ctx, count);
+                    var index = uid("i");
+                    var element_2 = factory_1.f.elementAccessExpression(list_2, factory_1.f.binary(index, typescript_1.default.SyntaxKind.MinusToken, num(1)));
+                    ctx.out.push(forOf(index, range(num(kind.elements.length + 1), add(count, kind.elements.length)), branch(ctx, function (child) { return emitWrite(kind.rest, element_2, child); })));
+                }
+                return;
+            }
+            case "object": {
+                var object = bind(ctx.out, factory_1.f.as(value, T.record()), "object");
+                try {
+                    for (var _h = __values(kind.fields), _j = _h.next(); !_j.done; _j = _h.next()) {
+                        var field = _j.value;
+                        emitWrite(field.shape, fieldAccess(object, field.name), ctx);
+                    }
+                }
+                catch (e_17_1) { e_17 = { error: e_17_1 }; }
+                finally {
+                    try {
+                        if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+                    }
+                    finally { if (e_17) throw e_17.error; }
+                }
+                return;
+            }
+            case "union": {
+                var v_2 = bind(ctx.out, value, "v");
+                var layout = layoutOf(kind);
+                // Who moves the position past the union. In a fixed layout the branches write at
+                // literal offsets and move nothing, so the size is added here; in a variable one
+                // `branch` syncs the position variable on the way out of every branch, and the
+                // union has already been stepped over. Adding it in both cases steps over it
+                // twice, which puts the next write a union's worth too far along and runs the
+                // element past what the size pass budgeted.
+                var isFixedLayout = ctx.cursor.variable === undefined;
+                var start = ctx.cursor.offset;
+                var chain = factory_1.f.block([raise("value matches none of the union's members")]);
+                var _loop_2 = function (i) {
+                    var alternative = kind.alternatives[i];
+                    var body = branch(ctx, function (child) {
+                        child.out.push(factory_1.f.statement(bufferCall("writeu8", [child.buf, at(child), num(i)])));
+                        child.cursor.offset += 1;
+                        emitWrite(alternative.shape, v_2, child);
+                    });
+                    chain = ifStatement(discriminate(kind, i, v_2), body, chain);
+                };
+                try {
+                    for (var _k = __values(evaluationOrder(kind).reverse()), _l = _k.next(); !_l.done; _l = _k.next()) {
+                        var i = _l.value;
+                        _loop_2(i);
+                    }
+                }
+                catch (e_18_1) { e_18 = { error: e_18_1 }; }
+                finally {
+                    try {
+                        if (_l && !_l.done && (_d = _k.return)) _d.call(_k);
+                    }
+                    finally { if (e_18) throw e_18.error; }
+                }
+                ctx.out.push(chain);
+                if (isFixedLayout && layout.size !== undefined)
+                    ctx.cursor.offset = start + layout.size;
+                return;
+            }
+        }
+    }
+    /** How many rest elements a list holds: never negative, since absent trailing optionals shorten it. */
+    function restCount(out, list, fixed) {
+        var count = uid("count");
+        var length = factory_1.f.binary(factory_1.f.call(prop(list, "size"), []), typescript_1.default.SyntaxKind.MinusToken, num(fixed));
+        out.push(constDecl(count, factory_1.f.call(prop("math", "max"), [length, num(0)])));
+        return count;
+    }
+    /** The length prefix of a string or buffer: a varint, or a fixed width refusing what it cannot hold. */
+    function writeLength(ctx, width, length, what) {
+        if (width === "v")
+            return writeVarint(ctx, length);
+        if (width !== "u32") {
+            ctx.out.push(ifStatement(factory_1.f.binary(length, typescript_1.default.SyntaxKind.GreaterThanToken, num(LENGTH_MAX[width])), [
+                raise("".concat(what, " is longer than its ").concat(width, " length prefix allows")),
+            ]));
+        }
+        ctx.out.push(factory_1.f.statement(bufferCall("write".concat(width), [ctx.buf, at(ctx), length])));
+        ctx.cursor.offset += WIDTH_SIZE[width];
+    }
+    /** Sets and maps have no cheap length: they are counted (a loop, in roblox-ts) before the elements. */
+    function writeCounted(ctx, collection, body, binding) {
+        var count = bind(ctx.out, factory_1.f.call(prop(collection, "size"), []), "n");
+        writeVarint(ctx, count);
+        var item = uid("item");
+        ctx.out.push(forOf(binding !== null && binding !== void 0 ? binding : item, collection, branch(ctx, function (child) { return body(item, child); })));
+    }
+    /** The test that tells member `index` of `union` apart from the others, given a value. */
+    function discriminate(union, index, value) {
+        var alternative = union.alternatives[index];
+        var kind = describe(alternative.shape);
+        if (kind.kind === "object") {
+            var test = objectTest(union, kind, factory_1.f.as(value, T.record()));
+            if (test) {
+                // Indexing is only safe once the value is known to be a table.
+                var tables_1 = union.alternatives.every(function (other) { return TABLE_KINDS.has(describe(other.shape).kind); });
+                return tables_1 ? test : factory_1.f.binary(typeOfIs(value, "table"), typescript_1.default.SyntaxKind.AmpersandAmpersandToken, test);
+            }
+        }
+        switch (kind.kind) {
+            case "number":
+            case "varint":
+                return typeOfIs(value, "number");
+            case "string":
+                return typeOfIs(value, "string");
+            case "boolean":
+                return typeOfIs(value, "boolean");
+            case "buffer":
+                return typeOfIs(value, "buffer");
+            case "datatype":
+                return typeOfIs(value, kind.name);
+            case "cframe":
+                return typeOfIs(value, "CFrame");
+            case "enum":
+                return factory_1.f.binary(typeOfIs(value, "EnumItem"), typescript_1.default.SyntaxKind.AmpersandAmpersandToken, equals(prop(factory_1.f.as(value, T.enumItem()), "EnumType"), prop("Enum", kind.name)));
+            case "literals":
+                return notNil(factory_1.f.call(prop(literalTablesFor(kind).index, "get"), [factory_1.f.as(value, T.defined())]));
+            case "constant":
+                return equals(value, kind.value);
+            case "nothing":
+                return isNil(value);
+            case "blob":
+                return kind.typeofName !== undefined ? typeOfIs(value, kind.typeofName) : factory_1.f.bool(true);
+            default:
+                if (!alternative.type)
+                    throw new Error("Flamework: cannot discriminate a synthetic ".concat(kind.kind));
+                return factory_1.f.call(guardFor(alternative.type), [value]);
+        }
+    }
+    // --- read ----------------------------------------------------------------------------------------
+    /**
+     * The value read at the cursor. Fixed-size reads are plain expressions; anything that moves the
+     * position by a runtime amount is bound to a local first, so the expressions of one container are
+     * always evaluated against a position that no later read has changed.
+     */
+    function emitRead(shape, ctx) {
+        if (!isKind(shape)) {
+            var info = hoist(shape);
+            if (info) {
+                var args = [ctx.buf, at(ctx)];
+                if (info.layout.blobs)
+                    args.push(ctx.blobs);
+                var value = uid("value");
+                var next = uid("o");
+                ctx.out.push(constDecl(factory_1.f.arrayBindingDeclaration([value, next]), factory_1.f.call(info.read, args)));
+                ctx.cursor.base = next;
+                ctx.cursor.offset = 0;
+                return value;
+            }
+        }
+        var kind = describe(shape);
+        switch (kind.kind) {
+            case "number": {
+                var read = bufferCall("read".concat(kind.width), [ctx.buf, at(ctx)]);
+                ctx.cursor.offset += WIDTH_SIZE[kind.width];
+                return read;
+            }
+            case "varint":
+                return readVarint(ctx);
+            case "boolean": {
+                var read = factory_1.f.binary(bufferCall("readu8", [ctx.buf, at(ctx)]), typescript_1.default.SyntaxKind.ExclamationEqualsEqualsToken, num(0));
+                ctx.cursor.offset += 1;
+                return read;
+            }
+            case "string": {
+                var length_3 = readLength(ctx, kind.length);
+                var text = bind(ctx.out, bufferCall("readstring", [ctx.buf, at(ctx), length_3]), "text");
+                advanceBy(ctx, length_3);
+                return text;
+            }
+            case "buffer": {
+                var length_4 = readLength(ctx, kind.length);
+                // `buffer.copy` bounds-checks, but only after `buffer.create` has allocated the announced
+                // length: a hostile length must be refused against what is left before it drives that.
+                var remaining = factory_1.f.binary(bufferCall("len", [ctx.buf]), typescript_1.default.SyntaxKind.MinusToken, at(ctx));
+                ctx.out.push(ifStatement(factory_1.f.binary(length_4, typescript_1.default.SyntaxKind.GreaterThanToken, remaining), [raise(MALFORMED)]));
+                var bytes = bind(ctx.out, bufferCall("create", [length_4]), "bytes");
+                ctx.out.push(factory_1.f.statement(bufferCall("copy", [bytes, num(0), ctx.buf, at(ctx), length_4])));
+                advanceBy(ctx, length_4);
+                return bytes;
+            }
+            case "constant":
+                return kind.value;
+            case "nothing":
+                return factory_1.f.nil();
+            case "literals": {
+                var list = literalTablesFor(kind).list;
+                var width = kind.values.length > 0xff ? "u16" : "u8";
+                var index = bufferCall("read".concat(width), [ctx.buf, at(ctx)]);
+                ctx.cursor.offset += WIDTH_SIZE[width];
+                var value = bind(ctx.out, factory_1.f.elementAccessExpression(list, index), "literal");
+                ctx.out.push(ifStatement(isNil(value), [raise(MALFORMED)]));
+                return value;
+            }
+            case "blob": {
+                var index = bufferCall("readu32", [ctx.buf, at(ctx)]);
+                ctx.cursor.offset += BLOB_SIZE;
+                // 1-based on the wire; roblox-ts adds the one back when indexing an array.
+                return factory_1.f.elementAccessExpression(ctx.blobs, factory_1.f.binary(index, typescript_1.default.SyntaxKind.MinusToken, num(1)));
+            }
+            case "datatype": {
+                var args = DATATYPES[kind.name].map(function (_a) {
+                    var _b = __read(_a, 1), width = _b[0];
+                    var read = bufferCall("read".concat(width), [ctx.buf, at(ctx)]);
+                    ctx.cursor.offset += WIDTH_SIZE[width];
+                    return read;
+                });
+                return construct(kind.name, args);
+            }
+            case "cframe": {
+                var args = Array.from({ length: CFRAME_COMPONENTS }, function () {
+                    var read = bufferCall("readf32", [ctx.buf, at(ctx)]);
+                    ctx.cursor.offset += 4;
+                    return read;
+                });
+                return construct("CFrame", args);
+            }
+            case "enum": {
+                var index = bufferCall("readu16", [ctx.buf, at(ctx)]);
+                ctx.cursor.offset += 2;
+                return factory_1.f.call(prop(enumTableFor(kind.name), "get"), [index]);
+            }
+            case "optional": {
+                var present = bind(ctx.out, factory_1.f.binary(bufferCall("readu8", [ctx.buf, at(ctx)]), typescript_1.default.SyntaxKind.ExclamationEqualsEqualsToken, num(0)), "present");
+                ctx.cursor.offset += 1;
+                var value_1 = uid("value");
+                ctx.out.push(letDecl(value_1, undefined, T.unknown()));
+                ctx.out.push(ifStatement(present, branch(ctx, function (child) { return child.out.push(assign(value_1, emitRead(kind.inner, child))); })));
+                return value_1;
+            }
+            case "array": {
+                var count = readCount(ctx, layoutOf(kind.element).min);
+                var array_1 = bind(ctx.out, construct("Array", [count]), "array", T.array());
+                var index_1 = uid("i");
+                ctx.out.push(forOf(index_1, range(num(1), count), branch(ctx, function (child) {
+                    var element = emitRead(kind.element, child);
+                    child.out.push(assign(factory_1.f.elementAccessExpression(array_1, factory_1.f.binary(index_1, typescript_1.default.SyntaxKind.MinusToken, num(1))), element));
+                })));
+                return array_1;
+            }
+            case "set": {
+                var count = readCount(ctx, layoutOf(kind.element).min);
+                var set_1 = bind(ctx.out, construct("Set", []), "set", T.set());
+                ctx.out.push(forOf(uid("_"), range(num(1), count), branch(ctx, function (child) {
+                    var element = emitRead(kind.element, child);
+                    child.out.push(factory_1.f.statement(factory_1.f.call(prop(set_1, "add"), [factory_1.f.as(element, T.defined())])));
+                })));
+                return set_1;
+            }
+            case "map": {
+                var count = readCount(ctx, layoutOf(kind.key).min + layoutOf(kind.value).min);
+                var map_1 = bind(ctx.out, construct("Map", []), "map", T.map());
+                ctx.out.push(forOf(uid("_"), range(num(1), count), branch(ctx, function (child) {
+                    var key = readInto(kind.key, child, "key");
+                    var value = readInto(kind.value, child, "entry");
+                    child.out.push(factory_1.f.statement(factory_1.f.call(prop(map_1, "set"), [key, value])));
+                })));
+                return map_1;
+            }
+            case "list": {
+                var elements = kind.elements.map(function (element) { return readInto(element, ctx, "arg"); });
+                // Typed explicitly: an empty list would otherwise be an implicit `any[]`.
+                if (!kind.rest)
+                    return factory_1.f.as(factory_1.f.array(elements, false), T.array());
+                var count = readCount(ctx, layoutOf(kind.rest).min);
+                var list_3 = bind(ctx.out, factory_1.f.array(elements, false), "list", T.array());
+                var index_2 = uid("i");
+                ctx.out.push(forOf(index_2, range(num(1), count), branch(ctx, function (child) {
+                    var element = emitRead(kind.rest, child);
+                    child.out.push(assign(factory_1.f.elementAccessExpression(list_3, factory_1.f.binary(index_2, typescript_1.default.SyntaxKind.PlusToken, num(kind.elements.length - 1))), element));
+                })));
+                return list_3;
+            }
+            case "object": {
+                var fields = kind.fields.map(function (field) {
+                    return factory_1.f.propertyAssignmentDeclaration(field.name, readInto(field.shape, ctx, field.name));
+                });
+                return factory_1.f.object(fields);
+            }
+            case "union": {
+                var layout = layoutOf(kind);
+                // As in {@link emitWrite}: only a fixed layout's branches leave the position where
+                // they found it, so only there does the union's size get added on top of them.
+                var isFixedLayout = ctx.cursor.variable === undefined;
+                var tag = bind(ctx.out, bufferCall("readu8", [ctx.buf, at(ctx)]), "tag");
+                ctx.cursor.offset += 1;
+                var start = ctx.cursor.offset;
+                var value_2 = uid("value");
+                ctx.out.push(letDecl(value_2, undefined, T.unknown()));
+                var chain = factory_1.f.block([raise(MALFORMED)]);
+                var _loop_3 = function (i) {
+                    var alternative = kind.alternatives[i];
+                    var body = branch(ctx, function (child) {
+                        return child.out.push(assign(value_2, emitRead(alternative.shape, child)));
+                    });
+                    chain = ifStatement(equals(tag, num(i)), body, chain);
+                };
+                for (var i = kind.alternatives.length - 1; i >= 0; i--) {
+                    _loop_3(i);
+                }
+                ctx.out.push(chain);
+                if (isFixedLayout && layout.size !== undefined)
+                    ctx.cursor.offset = start + layout.size - 1;
+                return value_2;
+            }
+        }
+    }
+    /** A read whose result is bound to a local in variable layouts; see {@link emitRead}. */
+    function readInto(shape, ctx, hint) {
+        var value = emitRead(shape, ctx);
+        if (!ctx.cursor.variable || factory_1.f.is.identifier(value) || isLiteral(value))
+            return value;
+        return bind(ctx.out, value, localName(hint));
+    }
+    /**
+     * A field's name as a local, kept clear of the globals the generated code reaches for.
+     *
+     * A synthesised local is renamed when it clashes with a name the file it lands in already uses,
+     * but a global is declared elsewhere, so nothing renames a local named after one. A field named
+     * after its own datatype -- `readonly CFrame: CFrame` -- then reads back as
+     * `const CFrame = new CFrame(...)`. The Luau that lowers to is correct, since its right-hand
+     * side is the outer binding; the intermediate TypeScript is checked before it is lowered, and a
+     * `const` in its own initializer is an error there. The same goes for a field named `buffer` or
+     * `Map`, which the reads that follow it would resolve to instead of the global.
+     */
+    function localName(hint) {
+        var name = hint.replace(/\W/g, "_");
+        var global = typeChecker.resolveName(name, undefined, GLOBAL_MEANING, false);
+        return global !== undefined ? "v_".concat(name) : name;
+    }
+    function readLength(ctx, width) {
+        if (width === "v")
+            return readVarint(ctx, "length");
+        var length = bind(ctx.out, bufferCall("read".concat(width), [ctx.buf, at(ctx)]), "length");
+        ctx.cursor.offset += WIDTH_SIZE[width];
+        return length;
+    }
+    /**
+     * An element count from the buffer, refused when the elements it announces could not fit in what
+     * is left: a hostile count must not drive a huge allocation or a long loop. Elements that take no
+     * bytes cannot be bounded that way; they are tallied across the whole payload instead, and the
+     * tally is capped, so that nesting cannot multiply what one count may announce.
+     */
+    function readCount(ctx, minimumElementSize) {
+        var count = readVarint(ctx, "count");
+        sync(ctx);
+        if (minimumElementSize === 0) {
+            var tally = zeroTally();
+            ctx.out.push(addAssign(tally, count));
+            ctx.out.push(ifStatement(factory_1.f.binary(tally, typescript_1.default.SyntaxKind.GreaterThanToken, num(ZERO_SIZE_COUNT_MAX)), [
+                raise(MALFORMED),
+            ]));
+            return count;
+        }
+        var remaining = factory_1.f.binary(bufferCall("len", [ctx.buf]), typescript_1.default.SyntaxKind.MinusToken, ctx.cursor.variable);
+        var needed = minimumElementSize > 1 ? factory_1.f.binary(count, typescript_1.default.SyntaxKind.AsteriskToken, num(minimumElementSize)) : count;
+        ctx.out.push(ifStatement(factory_1.f.binary(needed, typescript_1.default.SyntaxKind.GreaterThanToken, remaining), [raise(MALFORMED)]));
+        return count;
+    }
+    /** The file's zero-size element tally, declared once ahead of the hoisted functions that share it. */
+    function zeroTally() {
+        if (!zeros) {
+            zeros = uid("zeros");
+            tables.push(letDecl(zeros, num(0)));
+        }
+        return zeros;
+    }
+}