@php-skir/skir-client 1.0.19

package/dist/esm/skir-client.js

@@ -0,0 +1,2655 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { decode as decodeCbor, encode as encodeCbor } from "cbor-x";
+/**
+ * A single moment in time represented in a platform-independent format, with a
+ * precision of one millisecond.
+ *
+ * A `Timestamp` object can represent a maximum of ±8,640,000,000,000,000
+ * milliseconds, or ±100,000,000 (one hundred million) days, relative to the
+ * Unix epoch. This is the range from April 20, 271821 BC to September 13,
+ * 275760 AD.
+ *
+ * Unlike the Javascript built-in `Date` type, a `Timestamp` is immutable.
+ * Like a `Date`, a `Timestamp` object does not contain a timezone.
+ */
+export class Timestamp {
+    /**
+     * Returns a `Timestamp` representing the same moment in time as the given
+     * Javascript `Date` object.
+     *
+     * @throws if the given `Date` object has a timestamp value of NaN
+     */
+    static from(date) {
+        return this.fromUnixMillis(date.getTime());
+    }
+    /**
+     * Creates a `Timestamp` object from a number of milliseconds from the Unix
+     * epoch.
+     *
+     * If the given number if outside the valid range (±8,640,000,000,000,000),
+     * this function will return `Timestamp.MAX` or `Timestamp.MIN` depending on
+     * the sign of the number.
+     *
+     * @throws if the given number is NaN
+     */
+    static fromUnixMillis(unixMillis) {
+        if (unixMillis <= this.MIN.unixMillis) {
+            return Timestamp.MIN;
+        }
+        else if (unixMillis < Timestamp.MAX.unixMillis) {
+            return new Timestamp(Math.round(unixMillis));
+        }
+        else if (Number.isNaN(unixMillis)) {
+            throw new Error("Cannot construct Timestamp from NaN");
+        }
+        else {
+            return Timestamp.MAX;
+        }
+    }
+    /**
+     * Creates a `Timestamp` object from a number of seconds from the Unix epoch.
+     *
+     * If the given number if outside the valid range (±8,640,000,000,000), this
+     * function will return `Timestamp.MAX` or `Timestamp.MIN` depending on the
+     * sign of the number.
+     *
+     * @throws if the given number is NaN
+     */
+    static fromUnixSeconds(unixSeconds) {
+        return this.fromUnixMillis(unixSeconds * 1000);
+    }
+    /**
+     * Parses a date in the date time string format.
+     *
+     * @throws if the given string is not a date in the date time string format
+     * @see https://tc39.es/ecma262/multipage/numbers-and-dates.html#sec-date-time-string-format
+     */
+    static parse(date) {
+        return this.fromUnixMillis(Date.parse(date));
+    }
+    /** Returns a `Timestamp` representing the current moment in time. */
+    static now() {
+        return this.fromUnixMillis(Date.now());
+    }
+    constructor(
+    /** Number of milliseconds ellapsed since the Unix epoch. */
+    unixMillis) {
+        this.unixMillis = unixMillis;
+        Object.freeze(this);
+    }
+    /** Number of seconds ellapsed since the Unix epoch. */
+    get unixSeconds() {
+        return this.unixMillis / 1000.0;
+    }
+    /**
+     * Returns a `Date` object representing the same moment in time as this
+     * `Timestamp`.
+     */
+    toDate() {
+        return new Date(this.unixMillis);
+    }
+    toString() {
+        return this.toDate().toISOString();
+    }
+}
+/** Thursday, 1 January 1970. */
+Timestamp.UNIX_EPOCH = new Timestamp(0);
+/**
+ * Earliest moment in time representable as a `Timestamp`, namely April 20,
+ * 271821 BC.
+ *
+ * @see https://262.ecma-international.org/5.1/#sec-15.9.1.1
+ */
+Timestamp.MIN = new Timestamp(-8640000000000000);
+/**
+ * Latest moment in time representable as a `Timestamp`, namely September 13,
+ * 275760 AD.
+ *
+ * @see https://262.ecma-international.org/5.1/#sec-15.9.1.1
+ */
+Timestamp.MAX = new Timestamp(8640000000000000);
+/** An immutable array of bytes. */
+export class ByteString {
+    /**
+     * Returns an immutable byte string containing all the bytes of `input` from
+     * `start`, inclusive, up to `end`, exclusive.
+     *
+     * If `input` is an `ArrayBuffer`, this function copies the bytes. Otherwise
+     * this function returns a sliced view of the input `ByteString`.
+     *
+     * @example <caption>Copy an array buffer into a byte string</caption>
+     * const byteString = ByteString.sliceOf(arrayBuffer);
+     */
+    static sliceOf(input, start = 0, end) {
+        const { byteLength } = input;
+        if (start < 0) {
+            start = 0;
+        }
+        if (end === undefined || end > byteLength) {
+            end = byteLength;
+        }
+        if (end <= start) {
+            return ByteString.EMPTY;
+        }
+        if (input instanceof ByteString) {
+            if (start <= 0 && byteLength <= end) {
+                // Don't copy the ByteString itself.
+                return input;
+            }
+            else {
+                // Don't copy the ArrayBuffer.
+                const newByteOffset = input.byteOffset + start;
+                const newByteLength = end - start;
+                return new ByteString(input.arrayBuffer, newByteOffset, newByteLength);
+            }
+        }
+        else if (input instanceof ArrayBuffer) {
+            return new ByteString(input.slice(start, end));
+        }
+        else if (input instanceof SharedArrayBuffer) {
+            const slice = input.slice(start, end);
+            const newBuffer = new ArrayBuffer(slice.byteLength);
+            new Uint8Array(newBuffer).set(new Uint8Array(slice));
+            return new ByteString(newBuffer);
+        }
+        else {
+            const _ = input;
+            throw new TypeError(_);
+        }
+    }
+    /**
+     * Decodes a Base64 string, which can be obtained by calling `toBase64()`.
+     *
+     * @throws if the given string is not a valid Base64 string.
+     * @see https://en.wikipedia.org/wiki/Base64
+     */
+    static fromBase64(base64) {
+        // See https://developer.mozilla.org/en-US/docs/Glossary/Base64
+        const binaryString = atob(base64);
+        const array = Uint8Array.from(binaryString, (m) => m.codePointAt(0));
+        return new this(array.buffer);
+    }
+    /**
+     * Decodes a hexadecimal string, which can be obtained by calling
+     * `toBase16()`.
+     *
+     * @throws if the given string is not a valid Base64 string.
+     */
+    static fromBase16(base16) {
+        const bytes = new Uint8Array(base16.length / 2);
+        for (let i = 0; i < bytes.length; ++i) {
+            const byte = parseInt(base16.substring(i * 2, i * 2 + 2), 16);
+            if (Number.isNaN(byte)) {
+                throw new Error("Not a valid Base64 string");
+            }
+            bytes[i] = byte;
+        }
+        return new ByteString(bytes.buffer);
+    }
+    /** Copies the contents of this byte string into the given array buffer. */
+    copyTo(target, targetOffset = 0) {
+        new Uint8Array(target).set(this.uint8Array, targetOffset);
+    }
+    /** Copies the contents of this byte string into a new array buffer. */
+    toBuffer() {
+        return this.arrayBuffer.slice(this.byteOffset, this.byteOffset + this.byteLength);
+    }
+    /**
+     * Encodes this byte string into a Base64 string.
+     *
+     * @see https://en.wikipedia.org/wiki/Base64
+     */
+    toBase64() {
+        // See https://developer.mozilla.org/en-US/docs/Glossary/Base64
+        const binaryString = Array.from(this.uint8Array, (x) => String.fromCodePoint(x)).join("");
+        return btoa(binaryString);
+    }
+    /** Encodes this byte string into a hexadecimal string. */
+    toBase16() {
+        return [...this.uint8Array]
+            .map((x) => x.toString(16).padStart(2, "0"))
+            .join("");
+    }
+    at(index) {
+        return this.uint8Array[index < 0 ? index + this.byteLength : index];
+    }
+    toString() {
+        return `ByteString(${this.byteLength})`;
+    }
+    constructor(arrayBuffer, byteOffset = 0, 
+    /** The length of this byte string. */
+    byteLength = arrayBuffer.byteLength) {
+        this.arrayBuffer = arrayBuffer;
+        this.byteOffset = byteOffset;
+        this.byteLength = byteLength;
+        this.uint8Array = new Uint8Array(arrayBuffer, byteOffset, byteLength);
+        Object.freeze(this);
+    }
+}
+/** An empty byte string. */
+ByteString.EMPTY = new ByteString(new ArrayBuffer(0));
+/**
+ * Returns a serializer of instances of the given Skir primitive type.
+ *
+ * @example
+ * expect(
+ *   primitiveSerializer("string").toJsonCode("foo")
+ * ).toBe(
+ *   '"foo"'
+ * );
+ */
+export function primitiveSerializer(primitiveType) {
+    return primitiveSerializers[primitiveType];
+}
+/**
+ * Returns a serializer of arrays of `Item`s.
+ *
+ * @example
+ * expect(
+ *   arraySerializer(User.serializer).toJsonCode([JANE, JOE])
+ * ).toBe(
+ *   '[["jane"],["joe"]]'
+ * );
+ */
+export function arraySerializer(item, keyChain) {
+    if (keyChain !== undefined &&
+        !/^[a-z_][a-z0-9_]*(\.[a-z_][a-z0-9_]*)*$/.test(keyChain)) {
+        throw new Error(`Invalid keyChain "${keyChain}"`);
+    }
+    return new ArraySerializerImpl(item, keyChain);
+}
+/** Returns a serializer of nullable `T`s. */
+export function optionalSerializer(other) {
+    return other instanceof OptionalSerializerImpl
+        ? other
+        : new OptionalSerializerImpl(other);
+}
+/** Parameter of the {@link InternalSerializer.decode} method. */
+class InputStream {
+    constructor(buffer, keep) {
+        this.buffer = buffer;
+        this.offset = 0;
+        this.dataView = new DataView(buffer);
+        this.keepUnrecognizedValues = !!keep;
+    }
+    readUint8() {
+        return this.dataView.getUint8(this.offset++);
+    }
+}
+// For wires [232, 241]
+const DECODE_NUMBER_FNS = [
+    (s) => s.dataView.getUint16((s.offset += 2) - 2, true),
+    (s) => s.dataView.getUint32((s.offset += 4) - 4, true),
+    (s) => s.dataView.getBigUint64((s.offset += 8) - 8, true),
+    (stream) => stream.readUint8() - 256,
+    (s) => s.dataView.getUint16((s.offset += 2) - 2, true) - 65536,
+    (s) => s.dataView.getInt32((s.offset += 4) - 4, true),
+    (s) => s.dataView.getBigInt64((s.offset += 8) - 8, true),
+    (s) => s.dataView.getBigInt64((s.offset += 8) - 8, true),
+    (s) => s.dataView.getFloat32((s.offset += 4) - 4, true),
+    (s) => s.dataView.getFloat64((s.offset += 8) - 8, true),
+];
+function decodeNumber(stream) {
+    const wire = stream.readUint8();
+    return wire < 232 ? wire : DECODE_NUMBER_FNS[wire - 232](stream);
+}
+function decodeBigInt(stream) {
+    const number = decodeNumber(stream);
+    return typeof number === "bigint" ? number : BigInt(Math.round(number));
+}
+/** Parameter of the {@link InternalSerializer.encode} method. */
+class OutputStream {
+    constructor() {
+        this.buffer = new ArrayBuffer(128);
+        this.dataView = new DataView(this.buffer);
+        this.offset = 0;
+        // The final binary form is the result of concatenating these arrays.
+        // The length of each array is approximately twice the length of the previous
+        // array.
+        this.pieces = [];
+        // Updated each time `flush()` is called.
+        this.byteLength = 0;
+    }
+    writeUint8(value) {
+        const dataView = this.reserve(1);
+        dataView.setUint8(++this.offset - 1, value);
+    }
+    writeUint16(value) {
+        const dataView = this.reserve(2);
+        dataView.setUint16((this.offset += 2) - 2, value, true);
+    }
+    writeUint32(value) {
+        const dataView = this.reserve(4);
+        dataView.setUint32((this.offset += 4) - 4, value, true);
+    }
+    writeInt32(value) {
+        const dataView = this.reserve(4);
+        dataView.setInt32((this.offset += 4) - 4, value, true);
+    }
+    writeHash64(value) {
+        const dataView = this.reserve(8);
+        dataView.setBigUint64((this.offset += 8) - 8, value, true);
+    }
+    writeInt64(value) {
+        const dataView = this.reserve(8);
+        dataView.setBigInt64((this.offset += 8) - 8, value, true);
+    }
+    writeFloat32(value) {
+        const dataView = this.reserve(4);
+        dataView.setFloat32((this.offset += 4) - 4, value, true);
+    }
+    writeFloat64(value) {
+        const dataView = this.reserve(8);
+        dataView.setFloat64((this.offset += 8) - 8, value, true);
+    }
+    /**
+     * Encodes the given string to UTF-8 and writes the bytes to this stream.
+     * Returns the number of bytes written.
+     */
+    putUtf8String(string) {
+        // We do at most 3 writes:
+        //   - First, fill the current buffer as much as possible
+        //   - If there is not enough room, allocate a new buffer of N bytes, where
+        //       N is twice the number of remaining UTF-16 characters in the string,
+        //       and write to it. This new buffer is very likely to have enough
+        //       room.
+        //   - If there was not enough room, try again one last time.
+        //
+        // See https://developer.mozilla.org/en-US/docs/Web/API/TextEncoder
+        let dataView = this.dataView;
+        let result = 0;
+        while (string) {
+            const encodeResult = textEncoder.encodeInto(string, new Uint8Array(dataView.buffer, this.offset));
+            this.offset += encodeResult.written;
+            result += encodeResult.written;
+            string = string.substring(encodeResult.read);
+            if (string) {
+                dataView = this.reserve(string.length * 2);
+            }
+        }
+        return result;
+    }
+    putBytes(bytes) {
+        // We do at most 2 writes:
+        //   - First, fill the current buffer as much as possible
+        //   - If there is not enough room, allocate a new buffer of N bytes, where
+        //       N is at least the number of bytes left in the byte string.
+        const { buffer } = this;
+        const bytesLeftInCurrentBuffer = buffer.byteLength - this.offset;
+        const head = ByteString.sliceOf(bytes, 0, bytesLeftInCurrentBuffer);
+        head.copyTo(buffer, this.offset);
+        this.offset += head.byteLength;
+        const remainingBytes = bytes.byteLength - head.byteLength;
+        if (remainingBytes <= 0) {
+            // Everything was written.
+            return;
+        }
+        const tail = ByteString.sliceOf(bytes, remainingBytes);
+        this.reserve(remainingBytes);
+        tail.copyTo(buffer, this.offset);
+        this.offset += remainingBytes;
+    }
+    finalize() {
+        this.flush();
+        Object.freeze(this.pieces);
+        Object.freeze(this);
+        return this;
+    }
+    copyTo(target, offset = 0) {
+        const targetArea = new Uint8Array(target);
+        for (const piece of this.pieces) {
+            targetArea.set(piece, offset);
+            offset += piece.length;
+        }
+    }
+    toBuffer() {
+        const result = new ArrayBuffer(this.byteLength);
+        this.copyTo(result);
+        return result;
+    }
+    /** Returns a data view with enough capacity for `bytes` more bytes. */
+    reserve(bytes) {
+        if (this.offset < this.buffer.byteLength - bytes) {
+            // Enough room in the current data view.
+            return this.dataView;
+        }
+        this.flush();
+        const lengthInBytes = Math.max(this.byteLength, bytes);
+        this.offset = 0;
+        this.buffer = new ArrayBuffer(lengthInBytes);
+        return (this.dataView = new DataView(this.buffer));
+    }
+    /** Adds the current buffer to `pieces`. Updates `byteLength` accordingly. */
+    flush() {
+        const { offset } = this;
+        this.pieces.push(new Uint8Array(this.dataView.buffer, 0, offset));
+        this.byteLength += offset;
+    }
+}
+function encodeUint32(length, stream) {
+    if (length < 232) {
+        stream.writeUint8(length);
+    }
+    else if (length < 65536) {
+        stream.writeUint8(232);
+        stream.writeUint16(length);
+    }
+    else if (length < 4294967296) {
+        stream.writeUint8(233);
+        stream.writeUint32(length);
+    }
+    else {
+        throw new Error(`max length exceeded: ${length}`);
+    }
+}
+class AbstractSerializer {
+    fromJsonCode(code, keep) {
+        return this.fromJson(JSON.parse(code), keep);
+    }
+    fromBytes(bytes, keep) {
+        const inputStream = new InputStream(bytes, keep);
+        inputStream.offset = 4; // Skip the "skir" header.
+        return this.decode(inputStream);
+    }
+    toJsonCode(input, flavor) {
+        const indent = flavor === "readable" ? "  " : undefined;
+        return JSON.stringify(this.toJson(input, flavor), undefined, indent);
+    }
+    toBytes(input) {
+        const stream = new OutputStream();
+        stream.putUtf8String("skir");
+        this.encode(input, stream);
+        return stream.finalize();
+    }
+    // Default implementation; this behavior is not correct for all subclasses.
+    isDefault(input) {
+        return !input;
+    }
+    get typeDescriptor() {
+        return this;
+    }
+    asJson() {
+        const recordDefinitions = {};
+        this.addRecordDefinitionsTo(recordDefinitions);
+        const result = {
+            type: this.typeSignature,
+            records: Object.values(recordDefinitions),
+        };
+        return result;
+    }
+    asJsonCode() {
+        return JSON.stringify(this.asJson(), undefined, "  ");
+    }
+    transform(json_or_bytes, out) {
+        const decoded = json_or_bytes instanceof ArrayBuffer
+            ? this.fromBytes(json_or_bytes)
+            : this.fromJson(json_or_bytes);
+        return out === "bytes"
+            ? this.toBytes(decoded).toBuffer()
+            : this.toJson(decoded, out);
+    }
+}
+// The UNKNOWN variant is common to all enums.
+const UNKNOWN_VARIANT_DEFINITION = {
+    name: "UNKNOWN",
+    number: 0,
+};
+/**
+ * Returns a `TypeDescriptor` from its JSON representation as returned by
+ * `asJson()`.
+ */
+export function parseTypeDescriptorFromJson(json) {
+    var _a, _b, _c;
+    const typeDefinition = json;
+    const recordBundles = {};
+    // First loop: create the serializer for each record.
+    // It's not yet initialized.
+    for (const record of typeDefinition.records) {
+        let serializer;
+        switch (record.kind) {
+            case "struct":
+                serializer = new StructSerializerImpl({}, (initializer) => Object.freeze(Object.assign({}, initializer)), (() => ({})));
+                break;
+            case "enum":
+                serializer = new EnumSerializerImpl((o) => {
+                    if (o instanceof UnrecognizedEnum) {
+                        return Object.freeze({ kind: "UNKNOWN" });
+                    }
+                    if (typeof o === "string") {
+                        return Object.freeze({ kind: o });
+                    }
+                    else {
+                        const kind = o.kind;
+                        const value = o.value;
+                        const ret = { kind, value };
+                        return Object.freeze(ret);
+                    }
+                });
+                break;
+        }
+        const recordBundle = {
+            definition: record,
+            serializer: serializer,
+        };
+        recordBundles[record.id] = recordBundle;
+    }
+    function parse(ts) {
+        switch (ts.kind) {
+            case "array": {
+                const { item, key_extractor } = ts.value;
+                return new ArraySerializerImpl(parse(item), key_extractor);
+            }
+            case "optional":
+                return new OptionalSerializerImpl(parse(ts.value));
+            case "primitive":
+                return primitiveSerializer(ts.value);
+            case "record": {
+                const recordId = ts.value;
+                return recordBundles[recordId].serializer;
+            }
+        }
+    }
+    // Second loop: initialize each serializer.
+    const initOps = [];
+    for (const recordBundle of Object.values(recordBundles)) {
+        const { definition, serializer } = recordBundle;
+        const { defaultValue } = serializer;
+        const { id, removed_numbers } = definition;
+        const idParts = id.split(":");
+        const module = idParts[0];
+        const qualifiedName = idParts[1];
+        const nameParts = qualifiedName.split(".");
+        const name = nameParts[nameParts.length - 1];
+        const parentId = module + ":" + nameParts.slice(0, -1).join(".");
+        const parentType = (_a = recordBundles[parentId]) === null || _a === void 0 ? void 0 : _a.serializer;
+        const doc = (_b = definition.doc) !== null && _b !== void 0 ? _b : "";
+        switch (definition.kind) {
+            case "struct": {
+                const fields = [];
+                for (const f of definition.fields) {
+                    const fieldSerializer = parse(f.type);
+                    fields.push(new StructFieldImpl(f.name, f.name, f.number, fieldSerializer, (_c = f.doc) !== null && _c !== void 0 ? _c : ""));
+                    defaultValue[f.name] = fieldSerializer.defaultValue;
+                }
+                const s = serializer;
+                initOps.push(() => s.init(name, module, parentType, doc, fields, removed_numbers !== null && removed_numbers !== void 0 ? removed_numbers : []));
+                break;
+            }
+            case "enum": {
+                const s = serializer;
+                const variants = [UNKNOWN_VARIANT_DEFINITION]
+                    .concat(definition.variants)
+                    .map((f) => {
+                    var _a, _b;
+                    return f.type
+                        ? new EnumWrapperVariantImpl(f.name, f.number, parse(f.type), (_a = f.doc) !== null && _a !== void 0 ? _a : "", serializer.createFn)
+                        : {
+                            name: f.name,
+                            number: f.number,
+                            constant: Object.freeze({ kind: f.name }),
+                            doc: (_b = f.doc) !== null && _b !== void 0 ? _b : "",
+                        };
+                });
+                initOps.push(() => s.init(name, module, parentType, doc, variants, removed_numbers !== null && removed_numbers !== void 0 ? removed_numbers : []));
+                break;
+            }
+        }
+    }
+    // We need to actually initialize the serializers *after* the default values
+    // were constructed, because `init` calls `freezeDeeply` and this might result
+    // in freezing the default of another serializer.
+    initOps.forEach((op) => op());
+    return parse(typeDefinition.type).typeDescriptor;
+}
+/**
+ * Returns a `TypeDescriptor` from its JSON code representation as returned by
+ * `asJsonCode()`.
+ */
+export function parseTypeDescriptorFromJsonCode(code) {
+    return parseTypeDescriptorFromJson(JSON.parse(code));
+}
+class AbstractPrimitiveSerializer extends AbstractSerializer {
+    constructor() {
+        super(...arguments);
+        this.kind = "primitive";
+    }
+    get typeSignature() {
+        return {
+            kind: "primitive",
+            value: this.primitive,
+        };
+    }
+    addRecordDefinitionsTo(_out) { }
+}
+class BoolSerializer extends AbstractPrimitiveSerializer {
+    constructor() {
+        super(...arguments);
+        this.primitive = "bool";
+        this.defaultValue = false;
+    }
+    toJson(input, flavor) {
+        return flavor === "readable" ? !!input : input ? 1 : 0;
+    }
+    fromJson(json) {
+        return !!json && json !== "0";
+    }
+    encode(input, stream) {
+        stream.writeUint8(input ? 1 : 0);
+    }
+    decode(stream) {
+        return !!decodeNumber(stream);
+    }
+}
+class Int32Serializer extends AbstractPrimitiveSerializer {
+    constructor() {
+        super(...arguments);
+        this.primitive = "int32";
+        this.defaultValue = 0;
+    }
+    toJson(input) {
+        return input | 0;
+    }
+    fromJson(json) {
+        // `+value` will work if the input JSON value is a string, which is
+        // what the int64 serializer produces.
+        return +json | 0;
+    }
+    encode(input, stream) {
+        if (input < 0) {
+            if (input >= -256) {
+                stream.writeUint8(235);
+                stream.writeUint8(input + 256);
+            }
+            else if (input >= -65536) {
+                stream.writeUint8(236);
+                stream.writeUint16(input + 65536);
+            }
+            else {
+                stream.writeUint8(237);
+                stream.writeInt32(input >= -2147483648 ? input : -2147483648);
+            }
+        }
+        else if (input < 232) {
+            stream.writeUint8(input);
+        }
+        else if (input < 65536) {
+            stream.writeUint8(232);
+            stream.writeUint16(input);
+        }
+        else {
+            stream.writeUint8(233);
+            stream.writeUint32(input <= 2147483647 ? input : 2147483647);
+        }
+    }
+    decode(stream) {
+        return Number(decodeNumber(stream)) | 0;
+    }
+}
+const int32_Serializer = new Int32Serializer();
+class FloatSerializer extends AbstractPrimitiveSerializer {
+    constructor() {
+        super(...arguments);
+        this.defaultValue = 0;
+    }
+    toJson(input) {
+        if (Number.isFinite(input)) {
+            return input;
+        }
+        else if (typeof input === "number") {
+            // If the number is NaN or +/- Infinity, return a JSON string.
+            return input.toString();
+        }
+        throw new TypeError();
+    }
+    fromJson(json) {
+        return +json;
+    }
+    decode(stream) {
+        return Number(decodeNumber(stream));
+    }
+    isDefault(input) {
+        // Needs to work for NaN.
+        return input === 0;
+    }
+}
+class Float32Serializer extends FloatSerializer {
+    constructor() {
+        super(...arguments);
+        this.primitive = "float32";
+    }
+    encode(input, stream) {
+        if (input === 0) {
+            stream.writeUint8(0);
+        }
+        else {
+            stream.writeUint8(240);
+            stream.writeFloat32(input);
+        }
+    }
+}
+class Float64Serializer extends FloatSerializer {
+    constructor() {
+        super(...arguments);
+        this.primitive = "float64";
+    }
+    encode(input, stream) {
+        if (input === 0) {
+            stream.writeUint8(0);
+        }
+        else {
+            stream.writeUint8(241);
+            stream.writeFloat64(input);
+        }
+    }
+}
+class AbstractBigIntSerializer extends AbstractPrimitiveSerializer {
+    constructor() {
+        super(...arguments);
+        this.defaultValue = BigInt(0);
+    }
+    fromJson(json) {
+        try {
+            return BigInt(json);
+        }
+        catch (e) {
+            if (typeof json === "number") {
+                return BigInt(Math.round(json));
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+}
+const MIN_INT64 = BigInt("-9223372036854775808");
+const MAX_INT64 = BigInt("9223372036854775807");
+class Int64Serializer extends AbstractBigIntSerializer {
+    constructor() {
+        super(...arguments);
+        this.primitive = "int64";
+    }
+    toJson(input) {
+        // 9007199254740991 == Number.MAX_SAFE_INTEGER
+        if (-9007199254740991 <= input && input <= 9007199254740991) {
+            return Number(input);
+        }
+        const s = BigInt(input).toString();
+        // Clamp the number if it's out of bounds.
+        return s.length <= 18
+            ? // Small optimization for "small" numbers. The max int64 has 19 digits.
+                s
+            : input < MIN_INT64
+                ? MIN_INT64.toString()
+                : input < MAX_INT64
+                    ? s
+                    : MAX_INT64.toString();
+    }
+    encode(input, stream) {
+        if (input) {
+            if (-2147483648 <= input && input <= 2147483647) {
+                int32_Serializer.encode(Number(input), stream);
+            }
+            else {
+                stream.writeUint8(238);
+                // Clamp the number if it's out of bounds.
+                stream.writeInt64(input < MIN_INT64 ? MIN_INT64 : input < MAX_INT64 ? input : MAX_INT64);
+            }
+        }
+        else {
+            stream.writeUint8(0);
+        }
+    }
+    decode(stream) {
+        return decodeBigInt(stream);
+    }
+}
+const MAX_HASH64 = BigInt("18446744073709551615");
+class Hash64Serializer extends AbstractBigIntSerializer {
+    constructor() {
+        super(...arguments);
+        this.primitive = "hash64";
+    }
+    toJson(input) {
+        if (input <= 9007199254740991) {
+            return input <= 0 ? 0 : Number(input);
+        }
+        input = BigInt(input);
+        return MAX_HASH64 < input ? MAX_HASH64.toString() : input.toString();
+    }
+    encode(input, stream) {
+        if (input < 232) {
+            stream.writeUint8(input <= 0 ? 0 : Number(input));
+        }
+        else if (input < 4294967296) {
+            if (input < 65536) {
+                stream.writeUint8(232);
+                stream.writeUint16(Number(input));
+            }
+            else {
+                stream.writeUint8(233);
+                stream.writeUint32(Number(input));
+            }
+        }
+        else {
+            stream.writeUint8(234);
+            stream.writeHash64(input <= MAX_HASH64 ? input : MAX_HASH64);
+        }
+    }
+    decode(stream) {
+        return decodeBigInt(stream);
+    }
+}
+class TimestampSerializer extends AbstractPrimitiveSerializer {
+    constructor() {
+        super(...arguments);
+        this.primitive = "timestamp";
+        this.defaultValue = Timestamp.UNIX_EPOCH;
+    }
+    toJson(input, flavor) {
+        return flavor === "readable"
+            ? {
+                unix_millis: input.unixMillis,
+                formatted: input.toDate().toISOString(),
+            }
+            : input.unixMillis;
+    }
+    fromJson(json) {
+        return Timestamp.fromUnixMillis(typeof json === "number"
+            ? json
+            : typeof json === "string"
+                ? +json
+                : json["unix_millis"]);
+    }
+    encode(input, stream) {
+        const { unixMillis } = input;
+        if (unixMillis) {
+            stream.writeUint8(239);
+            stream.writeInt64(BigInt(unixMillis));
+        }
+        else {
+            stream.writeUint8(0);
+        }
+    }
+    decode(stream) {
+        const unixMillis = decodeNumber(stream);
+        return Timestamp.fromUnixMillis(Number(unixMillis));
+    }
+    isDefault(input) {
+        return !input.unixMillis;
+    }
+}
+class StringSerializer extends AbstractPrimitiveSerializer {
+    constructor() {
+        super(...arguments);
+        this.primitive = "string";
+        this.defaultValue = "";
+    }
+    toJson(input) {
+        if (typeof input === "string") {
+            return input;
+        }
+        throw this.newTypeError(input);
+    }
+    fromJson(json) {
+        if (typeof json === "string") {
+            return json;
+        }
+        if (json === 0) {
+            return "";
+        }
+        throw this.newTypeError(json);
+    }
+    encode(input, stream) {
+        if (!input) {
+            stream.writeUint8(242);
+            return;
+        }
+        stream.writeUint8(243);
+        // We don't know the length of the UTF-8 string until we actually encode the
+        // string. We just know that it's at most 3 times the length of the input
+        // string.
+        const maxEncodedLength = input.length * 3;
+        // Write zero in place of the UTF-8 sequence length. We will override this
+        // number later.
+        if (maxEncodedLength < 232) {
+            stream.writeUint8(0);
+        }
+        else if (maxEncodedLength < 65536) {
+            stream.writeUint8(232);
+            stream.writeUint16(0);
+        }
+        else {
+            stream.writeUint8(233);
+            stream.writeUint32(0);
+        }
+        const { dataView, offset } = stream;
+        // Write the UTF-8 string and record the number of bytes written.
+        const encodedLength = stream.putUtf8String(input);
+        // Write the length of the UTF-8 string where we wrote 0.
+        if (maxEncodedLength < 232) {
+            dataView.setUint8(offset - 1, encodedLength);
+        }
+        else if (maxEncodedLength < 65536) {
+            dataView.setUint16(offset - 2, encodedLength, true);
+        }
+        else {
+            dataView.setUint32(offset - 4, encodedLength, true);
+        }
+    }
+    decode(stream) {
+        const wire = stream.readUint8();
+        if (wire === 0 || wire === 242) {
+            return "";
+        }
+        const encodedLength = decodeNumber(stream);
+        return textDecoder.decode(new Uint8Array(stream.buffer, (stream.offset += encodedLength) - encodedLength, encodedLength));
+    }
+    newTypeError(actual) {
+        return new TypeError(`expected: string; actual: ${typeof actual}`);
+    }
+}
+class ByteStringSerializer extends AbstractPrimitiveSerializer {
+    constructor() {
+        super(...arguments);
+        this.primitive = "bytes";
+        this.defaultValue = ByteString.EMPTY;
+    }
+    toJson(input, flavor) {
+        return flavor === "readable" ? "hex:" + input.toBase16() : input.toBase64();
+    }
+    fromJson(json) {
+        if (json === 0) {
+            return ByteString.EMPTY;
+        }
+        const string = json;
+        return string.startsWith("hex:")
+            ? ByteString.fromBase16(string.substring(4))
+            : ByteString.fromBase64(string);
+    }
+    encode(input, stream) {
+        const { byteLength } = input;
+        if (byteLength) {
+            stream.writeUint8(245);
+            encodeUint32(byteLength, stream);
+            stream.putBytes(input);
+        }
+        else {
+            stream.writeUint8(244);
+        }
+    }
+    decode(stream) {
+        const wire = stream.readUint8();
+        if (wire === 0 || wire === 244) {
+            return ByteString.EMPTY;
+        }
+        const lengthInBytes = decodeNumber(stream);
+        return ByteString.sliceOf(stream.buffer, stream.offset, (stream.offset += lengthInBytes));
+    }
+    isDefault(input) {
+        return !input.byteLength;
+    }
+}
+class StructFieldImpl {
+    constructor(name, property, number, serializer, doc) {
+        this.name = name;
+        this.property = property;
+        this.number = number;
+        this.serializer = serializer;
+        this.doc = doc;
+    }
+    get type() {
+        return this.serializer.typeDescriptor;
+    }
+    get(struct) {
+        return Reflect.get(struct, this.property);
+    }
+    set(struct, value) {
+        Reflect.set(struct, this.property, value);
+    }
+}
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+class ArraySerializerImpl extends AbstractSerializer {
+    constructor(itemSerializer, keyExtractor) {
+        super();
+        this.itemSerializer = itemSerializer;
+        this.keyExtractor = keyExtractor;
+        this.kind = "array";
+        this.defaultValue = _EMPTY_ARRAY;
+    }
+    toJson(input, flavor) {
+        return input.map((e) => this.itemSerializer.toJson(e, flavor));
+    }
+    fromJson(json, keep) {
+        if (json === 0) {
+            return _EMPTY_ARRAY;
+        }
+        return freezeArray(json.map((e) => this.itemSerializer.fromJson(e, keep)));
+    }
+    encode(input, stream) {
+        const { length } = input;
+        if (length <= 3) {
+            stream.writeUint8(246 + length);
+        }
+        else {
+            stream.writeUint8(250);
+            encodeUint32(length, stream);
+        }
+        const { itemSerializer } = this;
+        for (let i = 0; i < input.length; ++i) {
+            itemSerializer.encode(input[i], stream);
+        }
+    }
+    decode(stream) {
+        const wire = stream.readUint8();
+        if (wire === 0 || wire === 246) {
+            return _EMPTY_ARRAY;
+        }
+        const length = wire === 250 ? decodeNumber(stream) : wire - 246;
+        const { itemSerializer } = this;
+        const result = new Array(length);
+        for (let i = 0; i < length; ++i) {
+            result[i] = itemSerializer.decode(stream);
+        }
+        return freezeArray(result);
+    }
+    isDefault(input) {
+        return !input.length;
+    }
+    get itemType() {
+        return this.itemSerializer.typeDescriptor;
+    }
+    get typeSignature() {
+        return {
+            kind: "array",
+            value: {
+                item: this.itemSerializer.typeSignature,
+                key_extractor: this.keyExtractor,
+            },
+        };
+    }
+    addRecordDefinitionsTo(out) {
+        this.itemSerializer.addRecordDefinitionsTo(out);
+    }
+}
+class OptionalSerializerImpl extends AbstractSerializer {
+    constructor(otherSerializer) {
+        super();
+        this.otherSerializer = otherSerializer;
+        this.kind = "optional";
+        this.defaultValue = null;
+    }
+    toJson(input, flavor) {
+        return input !== null ? this.otherSerializer.toJson(input, flavor) : null;
+    }
+    fromJson(json, keep) {
+        return json !== null ? this.otherSerializer.fromJson(json, keep) : null;
+    }
+    encode(input, stream) {
+        if (input === null) {
+            stream.writeUint8(255);
+        }
+        else {
+            this.otherSerializer.encode(input, stream);
+        }
+    }
+    decode(stream) {
+        const wire = stream.dataView.getUint8(stream.offset);
+        if (wire === 255) {
+            ++stream.offset;
+            return null;
+        }
+        return this.otherSerializer.decode(stream);
+    }
+    isDefault(input) {
+        return input === null;
+    }
+    get otherType() {
+        return this.otherSerializer.typeDescriptor;
+    }
+    get typeSignature() {
+        return {
+            kind: "optional",
+            value: this.otherSerializer.typeSignature,
+        };
+    }
+    addRecordDefinitionsTo(out) {
+        this.otherSerializer.addRecordDefinitionsTo(out);
+    }
+}
+const primitiveSerializers = {
+    bool: new BoolSerializer(),
+    int32: int32_Serializer,
+    int64: new Int64Serializer(),
+    hash64: new Hash64Serializer(),
+    float32: new Float32Serializer(),
+    float64: new Float64Serializer(),
+    timestamp: new TimestampSerializer(),
+    string: new StringSerializer(),
+    bytes: new ByteStringSerializer(),
+};
+function decodeUnused(stream) {
+    const wire = stream.readUint8();
+    if (wire < 232) {
+        return;
+    }
+    switch (wire - 232) {
+        case 0: // uint16
+        case 4: // uint16 - 65536
+            stream.offset += 2;
+            break;
+        case 1: // uint32
+        case 5: // int32
+        case 8: // float32
+            stream.offset += 4;
+            break;
+        case 2: // hash64
+        case 6: // int64
+        case 7: // hash64 timestamp
+        case 9: // float64
+            stream.offset += 8;
+            break;
+        case 3: // uint8 - 256
+            ++stream.offset;
+            break;
+        case 11: // string
+        case 13: {
+            // bytes
+            const length = decodeNumber(stream);
+            stream.offset += length;
+            break;
+        }
+        case 15: // array length==1
+        case 19: // enum value kind==1
+        case 20: // enum value kind==2
+        case 21: // enum value kind==3
+        case 22: // enum value kind==4
+            decodeUnused(stream);
+            break;
+        case 16: // array length==2
+            decodeUnused(stream);
+            decodeUnused(stream);
+            break;
+        case 17: // array length==3
+            decodeUnused(stream);
+            decodeUnused(stream);
+            decodeUnused(stream);
+            break;
+        case 18: {
+            // array length==N
+            const length = decodeNumber(stream);
+            for (let i = 0; i < length; ++i) {
+                decodeUnused(stream);
+            }
+            break;
+        }
+    }
+}
+class AbstractRecordSerializer extends AbstractSerializer {
+    constructor() {
+        super(...arguments);
+        /** Uniquely identifies this record serializer. */
+        this.token = Symbol();
+        this.name = "";
+        this.modulePath = "";
+        this.doc = "";
+        this.removedNumbers = new Set();
+    }
+    init(name, modulePath, parentType, doc, fieldsOrVariants, removedNumbers) {
+        this.name = name;
+        this.modulePath = modulePath;
+        this.parentType = parentType;
+        this.doc = doc;
+        this.removedNumbers = new Set(removedNumbers);
+        this.registerFieldsOrVariants(fieldsOrVariants);
+        this.initialized = true;
+        freezeDeeply(this);
+    }
+    get qualifiedName() {
+        const { name, parentType } = this;
+        return parentType ? `${parentType.name}.${name}` : name;
+    }
+    addRecordDefinitionsTo(out) {
+        const recordId = `${this.modulePath}:${this.qualifiedName}`;
+        if (out[recordId]) {
+            return;
+        }
+        const recordDefinition = this.makeRecordDefinition(recordId);
+        if (this.doc) {
+            recordDefinition.doc = this.doc;
+        }
+        if (this.removedNumbers.size) {
+            recordDefinition.removed_numbers = [...this.removedNumbers];
+        }
+        out[recordId] = recordDefinition;
+        for (const dependency of this.dependencies()) {
+            dependency.addRecordDefinitionsTo(out);
+        }
+    }
+}
+/** Unrecognized fields found when deserializing a struct. */
+class UnrecognizedFields {
+    constructor(
+    /** Uniquely identifies the struct. */
+    token, 
+    /** Total number of fields in the struct. */
+    totalSlots, json, bytes) {
+        this.token = token;
+        this.totalSlots = totalSlots;
+        this.json = json;
+        this.bytes = bytes;
+        Object.freeze(this);
+    }
+}
+class StructSerializerImpl extends AbstractRecordSerializer {
+    constructor(defaultValue, createFn, newMutableFn) {
+        super();
+        this.defaultValue = defaultValue;
+        this.createFn = createFn;
+        this.newMutableFn = newMutableFn;
+        this.kind = "struct";
+        // Fields in the order they appear in the '.skir' file.
+        this.fields = [];
+        this.fieldMapping = {};
+        // Fields sorted by number in descending order.
+        this.reversedFields = [];
+        // This is *not* a dense array, missing slots correspond to removed fields.
+        this.slots = [];
+        this.recognizedSlots = 0;
+        // Contains one zero for every field number.
+        this.zeros = [];
+        this.initializerTemplate = {};
+    }
+    toJson(input, flavor) {
+        if (input === this.defaultValue) {
+            return flavor === "readable" ? {} : [];
+        }
+        if (flavor === "readable") {
+            const { fields } = this;
+            const result = {};
+            for (const field of fields) {
+                const { serializer } = field;
+                const value = input[field.property];
+                if (field.serializer.isDefault(value)) {
+                    continue;
+                }
+                result[field.name] = serializer.toJson(value, flavor);
+            }
+            return result;
+        }
+        else {
+            // Dense flavor.
+            const { slots } = this;
+            let result;
+            const unrecognizedFields = //
+             input["^"];
+            if (unrecognizedFields &&
+                unrecognizedFields.json &&
+                unrecognizedFields.token === this.token) {
+                // We'll need to copy the unrecognized fields to the JSON.
+                result = this.zeros.concat(unrecognizedFields.json);
+                for (const field of this.fields) {
+                    result[field.number] = field.serializer.toJson(input[field.property], flavor);
+                }
+            }
+            else {
+                result = [];
+                const arrayLength = this.getArrayLength(input);
+                for (let i = 0; i < arrayLength; ++i) {
+                    const field = slots[i];
+                    result[i] = field
+                        ? field.serializer.toJson(input[field.property], flavor)
+                        : 0;
+                }
+            }
+            return result;
+        }
+    }
+    fromJson(json, keep) {
+        if (!json) {
+            return this.defaultValue;
+        }
+        const initializer = Object.assign({}, this.initializerTemplate);
+        if (json instanceof Array) {
+            const { slots, recognizedSlots } = this;
+            // Dense flavor.
+            if (json.length > recognizedSlots) {
+                // We have some unrecognized fields.
+                if (keep) {
+                    const unrecognizedFields = new UnrecognizedFields(this.token, json.length, copyJson(json.slice(recognizedSlots)));
+                    initializer["^"] = unrecognizedFields;
+                }
+                // Now that we have stored the unrecognized fields in `initializer`, we
+                // can remove them from `json`.
+                json = json.slice(0, recognizedSlots);
+            }
+            for (let i = 0; i < json.length && i < slots.length; ++i) {
+                const field = slots[i];
+                if (field) {
+                    initializer[field.property] = field.serializer.fromJson(json[i], keep);
+                }
+                // Else the field was removed.
+            }
+            return this.createFn(initializer);
+        }
+        else if (json instanceof Object) {
+            // Readable flavor.
+            const { fieldMapping } = this;
+            for (const name in json) {
+                const field = fieldMapping[name];
+                if (field) {
+                    initializer[field.property] = field.serializer.fromJson(json[name], keep);
+                }
+            }
+            return this.createFn(initializer);
+        }
+        throw TypeError();
+    }
+    encode(input, stream) {
+        // Total number of slots to write. Includes removed and unrecognized fields.
+        let totalSlots;
+        let recognizedSlots;
+        let unrecognizedBytes;
+        const unrecognizedFields = input["^"];
+        if (unrecognizedFields &&
+            unrecognizedFields.bytes &&
+            unrecognizedFields.token === this.token) {
+            totalSlots = unrecognizedFields.totalSlots;
+            recognizedSlots = this.recognizedSlots;
+            unrecognizedBytes = unrecognizedFields.bytes;
+        }
+        else {
+            // No unrecognized fields.
+            totalSlots = recognizedSlots = this.getArrayLength(input);
+        }
+        if (totalSlots <= 3) {
+            stream.writeUint8(246 + totalSlots);
+        }
+        else {
+            stream.writeUint8(250);
+            encodeUint32(totalSlots, stream);
+        }
+        const { slots } = this;
+        for (let i = 0; i < recognizedSlots; ++i) {
+            const field = slots[i];
+            if (field) {
+                field.serializer.encode(input[field.property], stream);
+            }
+            else {
+                // Append '0' if the field was removed.
+                stream.writeUint8(0);
+            }
+        }
+        if (unrecognizedBytes) {
+            // Copy the unrecognized fields.
+            stream.putBytes(unrecognizedBytes);
+        }
+    }
+    decode(stream) {
+        const wire = stream.readUint8();
+        if (wire === 0 || wire === 246) {
+            return this.defaultValue;
+        }
+        const initializer = Object.assign({}, this.initializerTemplate);
+        const encodedSlots = wire === 250 ? decodeNumber(stream) : wire - 246;
+        const { slots, recognizedSlots } = this;
+        // Do not read more slots than the number of recognized slots.
+        for (let i = 0; i < encodedSlots && i < recognizedSlots; ++i) {
+            const field = slots[i];
+            if (field) {
+                initializer[field.property] = field.serializer.decode(stream);
+            }
+            else {
+                // The field was removed.
+                decodeUnused(stream);
+            }
+        }
+        if (encodedSlots > recognizedSlots) {
+            // We have some unrecognized fields.
+            const start = stream.offset;
+            for (let i = recognizedSlots; i < encodedSlots; ++i) {
+                decodeUnused(stream);
+            }
+            if (stream.keepUnrecognizedValues) {
+                const end = stream.offset;
+                const unrecognizedBytes = ByteString.sliceOf(stream.buffer, start, end);
+                const unrecognizedFields = new UnrecognizedFields(this.token, encodedSlots, undefined, unrecognizedBytes);
+                initializer["^"] = unrecognizedFields;
+            }
+        }
+        return this.createFn(initializer);
+    }
+    /**
+     * Returns the length of the JSON array for the given input, which is also the
+     * number of slots and includes removed fields.
+     * Assumes that `input` does not contain unrecognized fields.
+     */
+    getArrayLength(input) {
+        const { reversedFields } = this;
+        for (let i = 0; i < reversedFields.length; ++i) {
+            const field = reversedFields[i];
+            const isDefault = //
+             field.serializer.isDefault(input[field.property]);
+            if (!isDefault) {
+                return field.number + 1;
+            }
+        }
+        return 0;
+    }
+    isDefault(input) {
+        if (input === this.defaultValue) {
+            return true;
+        }
+        // It's possible for a value of type T to be equal to T.DEFAULT but to not
+        // be the reference to T.DEFAULT.
+        if (input["^"]) {
+            return false;
+        }
+        return this.fields.every((f) => f.serializer.isDefault(input[f.property]));
+    }
+    get typeSignature() {
+        return {
+            kind: "record",
+            value: `${this.modulePath}:${this.qualifiedName}`,
+        };
+    }
+    getField(key) {
+        return this.fieldMapping[key];
+    }
+    newMutable(initializer) {
+        return this.newMutableFn(initializer);
+    }
+    registerFieldsOrVariants(fields) {
+        for (const field of fields) {
+            const { name, number, property } = field;
+            this.fields.push(field);
+            this.slots[number] = field;
+            this.fieldMapping[name] = field;
+            this.fieldMapping[property] = field;
+            this.fieldMapping[number] = field;
+            this.initializerTemplate[property] = this.defaultValue[field.property];
+        }
+        // Removed numbers count as recognized slots.
+        this.recognizedSlots =
+            Math.max(this.slots.length - 1, ...this.removedNumbers) + 1;
+        this.zeros.push(...Array(this.recognizedSlots).fill(0));
+        this.reversedFields = [...this.fields].sort((a, b) => b.number - a.number);
+    }
+    makeRecordDefinition(recordId) {
+        return {
+            kind: "struct",
+            id: recordId,
+            doc: undefined,
+            fields: this.fields.map((f) => ({
+                name: f.name,
+                number: f.number,
+                type: f.serializer.typeSignature,
+                doc: emptyToUndefined(f.doc),
+            })),
+        };
+    }
+    dependencies() {
+        return this.fields.map((f) => f.serializer);
+    }
+}
+class UnrecognizedEnum {
+    constructor(token, json, bytes) {
+        this.token = token;
+        this.json = json;
+        this.bytes = bytes;
+        Object.freeze(this);
+    }
+}
+class EnumWrapperVariantImpl {
+    constructor(name, number, serializer, doc, createFn) {
+        this.name = name;
+        this.number = number;
+        this.serializer = serializer;
+        this.doc = doc;
+        this.createFn = createFn;
+    }
+    get type() {
+        return this.serializer.typeDescriptor;
+    }
+    get(e) {
+        return e.kind === this.name
+            ? e.value
+            : undefined;
+    }
+    wrap(value) {
+        return this.createFn({ kind: this.name, value: value });
+    }
+}
+class EnumSerializerImpl extends AbstractRecordSerializer {
+    constructor(createFn) {
+        super();
+        this.createFn = createFn;
+        this.kind = "enum";
+        this.variants = [];
+        this.variantMapping = {};
+        this.defaultValue = createFn("UNKNOWN");
+    }
+    toJson(input, flavor) {
+        const unrecognized = input["^"];
+        const kind = input.kind;
+        if (kind === "UNKNOWN" &&
+            unrecognized &&
+            unrecognized.json &&
+            unrecognized.token === this.token) {
+            // Unrecognized variant.
+            return unrecognized.json;
+        }
+        if (kind === "UNKNOWN") {
+            return flavor === "readable" ? "unknown" : 0;
+        }
+        const variant = this.variantMapping[kind];
+        const { serializer } = variant;
+        if (serializer) {
+            const value = input.value;
+            if (flavor === "readable") {
+                return {
+                    kind: variant.name,
+                    value: serializer.toJson(value, flavor),
+                };
+            }
+            else {
+                // Dense flavor.
+                return [variant.number, serializer.toJson(value, flavor)];
+            }
+        }
+        else {
+            // A constant variant.
+            return flavor === "readable"
+                ? variant.name.toLowerCase()
+                : variant.number;
+        }
+    }
+    fromJson(json, keep) {
+        const isNumber = typeof json === "number";
+        if (isNumber || typeof json === "string") {
+            const variant = this.variantMapping[isNumber ? json : String(json)];
+            if (!variant) {
+                // Check if the variant was removed, in which case we want to return
+                // UNKNOWN, or is unrecognized.
+                return !keep || (isNumber && this.removedNumbers.has(json))
+                    ? this.defaultValue
+                    : this.createFn(new UnrecognizedEnum(this.token, copyJson(json)));
+            }
+            if (variant.serializer) {
+                // A constant variant became a wrapper variant.
+                return variant.wrap(variant.serializer.defaultValue);
+            }
+            return variant.constant;
+        }
+        let variantKey;
+        let valueAsJson;
+        if (json instanceof Array) {
+            variantKey = json[0];
+            valueAsJson = json[1];
+        }
+        else if (json instanceof Object) {
+            variantKey = json["kind"];
+            valueAsJson = json["value"];
+        }
+        else {
+            throw TypeError();
+        }
+        const variant = this.variantMapping[variantKey];
+        if (!variant) {
+            // Check if the variant was removed, in which case we want to return
+            // UNKNOWN, or is unrecognized.
+            return !keep ||
+                (typeof variantKey === "number" && this.removedNumbers.has(variantKey))
+                ? this.defaultValue
+                : this.createFn(new UnrecognizedEnum(this.token, copyJson(json), undefined));
+        }
+        const { serializer } = variant;
+        if (!serializer) {
+            // A wrapper variant became a constant variant.
+            return variant.constant;
+        }
+        return variant.wrap(serializer.fromJson(valueAsJson, keep));
+    }
+    encode(input, stream) {
+        const unrecognized = //
+         input["^"];
+        const kind = input.kind;
+        if (kind === "UNKNOWN" &&
+            unrecognized &&
+            unrecognized.bytes &&
+            unrecognized.token === this.token) {
+            // Unrecognized variant.
+            stream.putBytes(unrecognized.bytes);
+            return;
+        }
+        if (kind === "UNKNOWN") {
+            stream.writeUint8(0);
+            return;
+        }
+        const variant = this.variantMapping[kind];
+        const { number, serializer } = variant;
+        if (serializer) {
+            // A wrapper variant.
+            const value = input.value;
+            if (number < 5) {
+                // The number can't be 0 or else kind == "UNKNOWN".
+                stream.writeUint8(250 + number);
+            }
+            else {
+                stream.writeUint8(248);
+                encodeUint32(number, stream);
+            }
+            serializer.encode(value, stream);
+        }
+        else {
+            // A constant variant.
+            encodeUint32(number, stream);
+        }
+    }
+    decode(stream) {
+        const startOffset = stream.offset;
+        const wire = stream.dataView.getUint8(startOffset);
+        if (wire < 242) {
+            // A number
+            const number = decodeNumber(stream);
+            const variant = this.variantMapping[number];
+            if (!variant) {
+                // Check if the variant was removed, in which case we want to return
+                // UNKNOWN, or is unrecognized.
+                if (!stream.keepUnrecognizedValues || this.removedNumbers.has(number)) {
+                    return this.defaultValue;
+                }
+                else {
+                    const { offset } = stream;
+                    const bytes = ByteString.sliceOf(stream.buffer, startOffset, offset);
+                    return this.createFn(new UnrecognizedEnum(this.token, undefined, bytes));
+                }
+            }
+            if (variant.serializer) {
+                // A constant variant became a wrapper variant.
+                return variant.wrap(variant.serializer.defaultValue);
+            }
+            return variant.constant;
+        }
+        else {
+            ++stream.offset;
+            const number = wire === 248 ? decodeNumber(stream) : wire - 250;
+            const variant = this.variantMapping[number];
+            if (!variant) {
+                decodeUnused(stream);
+                // Check if the variant was removed, in which case we want to return
+                // UNKNOWN, or is unrecognized.
+                if (!stream.keepUnrecognizedValues || this.removedNumbers.has(number)) {
+                    return this.defaultValue;
+                }
+                else {
+                    const { offset } = stream;
+                    const bytes = ByteString.sliceOf(stream.buffer, startOffset, offset);
+                    return this.createFn(new UnrecognizedEnum(this.token, undefined, bytes));
+                }
+            }
+            const { serializer } = variant;
+            if (!serializer) {
+                decodeUnused(stream);
+                // A wrapper variant became a constant variant.
+                return variant.constant;
+            }
+            return variant.wrap(serializer.decode(stream));
+        }
+    }
+    get typeSignature() {
+        return {
+            kind: "record",
+            value: `${this.modulePath}:${this.qualifiedName}`,
+        };
+    }
+    isDefault(input) {
+        return input.kind === "UNKNOWN" && !input["^"];
+    }
+    getVariant(key) {
+        return this.variantMapping[key];
+    }
+    registerFieldsOrVariants(variants) {
+        for (const variant of variants) {
+            this.variants.push(variant);
+            this.variantMapping[variant.name] = variant;
+            // Register case aliases for constant variants so that both UPPER_CASE
+            // and lower_case names are accepted when parsing readable JSON.
+            if (variant.serializer === undefined) {
+                const nameUpper = variant.name.toUpperCase();
+                if (nameUpper !== variant.name) {
+                    this.variantMapping[nameUpper] = variant;
+                }
+                const nameLower = variant.name.toLowerCase();
+                if (nameLower !== variant.name) {
+                    this.variantMapping[nameLower] = variant;
+                }
+            }
+            this.variantMapping[variant.number] = variant;
+        }
+    }
+    makeRecordDefinition(recordId) {
+        return {
+            kind: "enum",
+            id: recordId,
+            doc: undefined,
+            variants: this.variants
+                // Skip the UNKNOWN variant.
+                .filter((f) => f.number)
+                .map((f) => {
+                var _a;
+                const result = {
+                    name: f.name.toLowerCase(),
+                    number: f.number,
+                    doc: emptyToUndefined(f.doc),
+                };
+                const type = (_a = f === null || f === void 0 ? void 0 : f.serializer) === null || _a === void 0 ? void 0 : _a.typeSignature;
+                return type ? Object.assign(Object.assign({}, result), { type: type }) : result;
+            }),
+        };
+    }
+    dependencies() {
+        const result = [];
+        for (const f of this.variants) {
+            if (f.serializer) {
+                result.push(f.serializer);
+            }
+        }
+        return result;
+    }
+}
+function copyJson(input) {
+    if (input instanceof Array) {
+        return Object.freeze(input.map(copyJson));
+    }
+    else if (input instanceof Object) {
+        return Object.freeze(Object.fromEntries(Object.entries(input).map((k, v) => [k, copyJson(v)])));
+    }
+    // A boolean, a number, a string or null.
+    return input;
+}
+function freezeDeeply(o) {
+    if (!(o instanceof Object)) {
+        return;
+    }
+    if (o instanceof _FrozenBase || o instanceof _EnumBase) {
+        return;
+    }
+    if (o instanceof AbstractRecordSerializer && !o.initialized) {
+        return;
+    }
+    if (Object.isFrozen(o)) {
+        return;
+    }
+    Object.freeze(o);
+    for (const v of Object.values(o)) {
+        freezeDeeply(v);
+    }
+}
+const frozenArrayRegistry = new WeakMap();
+function freezeArray(array) {
+    if (!frozenArrayRegistry.has(array)) {
+        frozenArrayRegistry.set(Object.freeze(array), {});
+    }
+    return array;
+}
+export const _EMPTY_ARRAY = freezeArray([]);
+export function _toFrozenArray(initializers, itemToFrozenFn) {
+    if (!initializers.length) {
+        return _EMPTY_ARRAY;
+    }
+    if (frozenArrayRegistry.has(initializers)) {
+        // No need to make a copy: the given array is already deeply-frozen.
+        return initializers;
+    }
+    const ret = Object.freeze(itemToFrozenFn
+        ? initializers.map(itemToFrozenFn)
+        : initializers.slice());
+    frozenArrayRegistry.set(ret, {});
+    return ret;
+}
+const PRIVATE_KEY = Symbol();
+function forPrivateUseError(t) {
+    const clazz = Object.getPrototypeOf(t).constructor;
+    const { qualifiedName } = clazz.serializer;
+    return Error([
+        "Do not call the constructor directly; ",
+        `instead, call ${qualifiedName}.create(...)`,
+    ].join(""));
+}
+export class _FrozenBase {
+    constructor(privateKey) {
+        if (privateKey !== PRIVATE_KEY) {
+            throw forPrivateUseError(this);
+        }
+    }
+    toMutable() {
+        return new (Object.getPrototypeOf(this).constructor.Mutable)(this);
+    }
+    toFrozen() {
+        return this;
+    }
+    toString() {
+        return toStringImpl(this);
+    }
+}
+export class _EnumBase {
+    constructor(privateKey, kind, value, unrecognized) {
+        if (privateKey !== PRIVATE_KEY) {
+            throw forPrivateUseError(this);
+        }
+        this.kind = kind;
+        this.value = value;
+        if (unrecognized) {
+            if (!(unrecognized instanceof UnrecognizedEnum)) {
+                throw new TypeError();
+            }
+            this["^"] = unrecognized;
+        }
+        Object.freeze(this);
+    }
+    toString() {
+        return toStringImpl(this);
+    }
+}
+// The TypeScript compiler complains if we define the property within the class.
+Object.defineProperty(_EnumBase.prototype, "union", {
+    get: function () {
+        return this;
+    },
+});
+function toStringImpl(value) {
+    const serializer = Object.getPrototypeOf(value).constructor
+        .serializer;
+    return serializer.toJsonCode(value, "readable");
+}
+function encodeCborJson(value) {
+    const encoded = encodeCbor(value);
+    return new Uint8Array(encoded.buffer, encoded.byteOffset, encoded.byteLength);
+}
+function decodeCborJson(value) {
+    const bytes = value instanceof Uint8Array ? value : new Uint8Array(value);
+    return decodeCbor(bytes);
+}
+function normalizeHeaders(headers) {
+    return new Headers(headers);
+}
+/** Sends RPCs to a SkirRPC service. */
+export class ServiceClient {
+    constructor(serviceUrl, getRequestMetadata = () => ({}), options = {}) {
+        this.serviceUrl = serviceUrl;
+        this.getRequestMetadata = getRequestMetadata;
+        this.options = options;
+        const url = new URL(serviceUrl);
+        if (url.search) {
+            throw new Error("Service URL must not contain a query string");
+        }
+    }
+    /** Invokes the given method on the remote server through an RPC. */
+    invokeRemote(method_1, request_1) {
+        return __awaiter(this, arguments, void 0, function* (method, request, httpMethod = "POST") {
+            const requestInit = Object.assign({}, (yield Promise.resolve(this.getRequestMetadata(method))));
+            const url = new URL(this.serviceUrl);
+            requestInit.method = httpMethod;
+            if (this.options.transportCodec === "cbor") {
+                if (httpMethod !== "POST") {
+                    throw new Error("CBOR transport only supports POST requests");
+                }
+                const headers = normalizeHeaders(requestInit.headers);
+                headers.set("Content-Type", "application/cbor");
+                headers.set("Accept", "application/cbor");
+                requestInit.headers = headers;
+                requestInit.body = encodeCborJson({
+                    method: method.name,
+                    request: method.requestSerializer.toJson(request, "dense"),
+                });
+            }
+            else {
+                const requestJson = method.requestSerializer.toJsonCode(request);
+                const requestBody = [method.name, method.number, "", requestJson].join(":");
+                if (httpMethod === "POST") {
+                    requestInit.body = requestBody;
+                }
+                else {
+                    url.search = requestBody.replace(/%/g, "%25");
+                }
+            }
+            const httpResponse = yield fetch(url, requestInit);
+            const responseData = yield httpResponse.blob();
+            if (httpResponse.ok) {
+                if (this.options.transportCodec === "cbor") {
+                    return method.responseSerializer.fromJson(decodeCborJson(yield responseData.arrayBuffer()), "keep-unrecognized-values");
+                }
+                else {
+                    const jsonCode = yield responseData.text();
+                    return method.responseSerializer.fromJsonCode(jsonCode, "keep-unrecognized-values");
+                }
+            }
+            else {
+                let message = "";
+                if (/text\/plain\b/.test(responseData.type)) {
+                    message = `: ${yield responseData.text()}`;
+                }
+                throw new Error(`HTTP status ${httpResponse.status}${message}`);
+            }
+        });
+    }
+}
+function makeOkJsonResponse(data) {
+    return {
+        data: data,
+        statusCode: 200,
+        contentType: "application/json",
+    };
+}
+function makeOkCborResponse(data) {
+    return {
+        data: encodeCborJson(data),
+        statusCode: 200,
+        contentType: "application/cbor",
+    };
+}
+function makeOkHtmlResponse(data) {
+    return {
+        data: data,
+        statusCode: 200,
+        contentType: "text/html; charset=utf-8",
+    };
+}
+function makeBadRequestResponse(data) {
+    return {
+        data: data,
+        statusCode: 400,
+        contentType: "text/plain; charset=utf-8",
+    };
+}
+function makeServerErrorResponse(data, statusCode = 500) {
+    return {
+        data: data,
+        statusCode: statusCode,
+        contentType: "text/plain; charset=utf-8",
+    };
+}
+function getStudioHtml(studioAppJsUrl) {
+    // Copied from
+    //   https://github.com/gepheum/skir-studio/blob/main/index.jsdeliver.html
+    // 'studioAppJsUrl' is produced by new URL(...).toString() so it can't contain
+    // any special characters that need escaping in HTML.
+    return `<!DOCTYPE html>
+
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>RPC Studio</title>
+    <link rel="icon" href="data:image/svg+xml,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 100 100%22><text y=%22.9em%22 font-size=%2290%22>🐙</text></svg>">
+    <script src="${studioAppJsUrl}"></script>
+  </head>
+  <body style="margin: 0; padding: 0;">
+    <skir-studio-app></skir-studio-app>
+  </body>
+</html>
+`;
+}
+/**
+ * If this error is thrown from a method implementation, the specified status
+ * code and message will be returned in the HTTP response.
+ *
+ * If any other type of exception is thrown, the response status code will be
+ * 500 (Internal Server Error).
+ */
+export class ServiceError extends Error {
+    constructor(spec) {
+        var _a;
+        super((_a = spec.message) !== null && _a !== void 0 ? _a : spec.desc);
+        this.spec = spec;
+    }
+    toRawResponse() {
+        var _a;
+        return makeServerErrorResponse((_a = this.spec.message) !== null && _a !== void 0 ? _a : this.spec.desc, this.spec.statusCode);
+    }
+}
+/**
+ * Implementation of a SkirRPC service.
+ *
+ * Usage: call `.addMethod()` to register methods, then install the service on
+ * an HTTP server either by:
+ *   - calling the `installServiceOnExpressApp()` top-level function if you are
+ *       using ExpressJS
+ *   - writing your own implementation of `installServiceOn*()` which calls
+ *       `.handleRequest()` if you are using another web application framework
+ *
+ * ## Handling Request Metadata
+ *
+ * The `RequestMeta` type parameter specifies what metadata (authentication,
+ * headers, etc.) your method implementations receive. There are two approaches:
+ *
+ * ### Approach 1: Use the framework's request type directly
+ *
+ * Set `RequestMeta` to your framework's request type (e.g., `ExpressRequest`).
+ * All method implementations will receive the full framework request object.
+ *
+ * ```typescript
+ * const service = new Service<ExpressRequest>();
+ * service.addMethod(myMethod, async (req, expressReq) => {
+ *   const isAdmin = expressReq.user?.role === 'admin';
+ *   // ...
+ * });
+ * installServiceOnExpressApp(app, '/api', service, text, json);
+ * ```
+ *
+ * ### Approach 2: Use a simplified custom type
+ *
+ * Set `RequestMeta` to a minimal type containing only what your service needs.
+ * Use `withMetaTransformer()` to extract this data from the framework request
+ * when installing the service.
+ *
+ * ```typescript
+ * const service = new Service<{ isAdmin: boolean }>();
+ * service.addMethod(myMethod, async (req, { isAdmin }) => {
+ *   // Implementation is framework-agnostic and easy to unit test
+ *   if (!isAdmin) throw new ServiceError({ statusCode: 403, desc: "Forbidden" });
+ *   // ...
+ * });
+ *
+ * // Adapt to Express when installing
+ * const handler = service.withMetaTransformer((req: ExpressRequest) => ({
+ *   isAdmin: req.user?.role === 'admin'
+ * }));
+ * installServiceOnExpressApp(app, '/api', handler, text, json);
+ * ```
+ *
+ * This approach decouples your service from the HTTP framework, making it easier
+ * to test and clearer about what request data it actually uses.
+ */
+export class Service {
+    constructor(options) {
+        var _a, _b, _c, _d, _f;
+        this.methodImpls = {};
+        this.options = {
+            transportCodec: (_a = options === null || options === void 0 ? void 0 : options.transportCodec) !== null && _a !== void 0 ? _a : DEFAULT_SERVICE_OPTIONS.transportCodec,
+            keepUnrecognizedValues: (_b = options === null || options === void 0 ? void 0 : options.keepUnrecognizedValues) !== null && _b !== void 0 ? _b : DEFAULT_SERVICE_OPTIONS.keepUnrecognizedValues,
+            canSendUnknownErrorMessage: (_c = options === null || options === void 0 ? void 0 : options.canSendUnknownErrorMessage) !== null && _c !== void 0 ? _c : DEFAULT_SERVICE_OPTIONS.canSendUnknownErrorMessage,
+            errorLogger: (_d = options === null || options === void 0 ? void 0 : options.errorLogger) !== null && _d !== void 0 ? _d : DEFAULT_SERVICE_OPTIONS.errorLogger,
+            studioAppJsUrl: new URL((_f = options === null || options === void 0 ? void 0 : options.studioAppJsUrl) !== null && _f !== void 0 ? _f : DEFAULT_SERVICE_OPTIONS.studioAppJsUrl).toString(),
+        };
+    }
+    addMethod(method, impl) {
+        const { number } = method;
+        if (this.methodImpls[number]) {
+            throw new Error(`Method with the same number already registered (${number})`);
+        }
+        this.methodImpls[number] = {
+            method: method,
+            impl: impl,
+        };
+        return this;
+    }
+    handleRequest(reqBody, reqMeta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.doHandleRequest(reqBody, reqMeta, (m) => m);
+        });
+    }
+    doHandleRequest(reqBody, originalReqMeta, transformReqMeta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof reqBody === "string" && reqBody === "list") {
+                const json = {
+                    methods: Object.values(this.methodImpls).map((methodImpl) => ({
+                        method: methodImpl.method.name,
+                        number: methodImpl.method.name,
+                        request: methodImpl.method.requestSerializer.typeDescriptor.asJson(),
+                        response: methodImpl.method.responseSerializer.typeDescriptor.asJson(),
+                        doc: emptyToUndefined(methodImpl.method.doc),
+                    })),
+                };
+                const jsonCode = JSON.stringify(json, undefined, "  ");
+                return makeOkJsonResponse(jsonCode);
+            }
+            else if (typeof reqBody === "string" &&
+                (reqBody === "" || reqBody === "studio")) {
+                const studioHtml = getStudioHtml(this.options.studioAppJsUrl);
+                return makeOkHtmlResponse(studioHtml);
+            }
+            // Parse request
+            let methodName;
+            let methodNumber;
+            let format;
+            let requestData;
+            if (this.options.transportCodec === "cbor") {
+                if (typeof reqBody === "string") {
+                    return makeBadRequestResponse("bad request: invalid CBOR");
+                }
+                let reqBodyJson;
+                try {
+                    reqBodyJson = decodeCborJson(reqBody);
+                }
+                catch (_e) {
+                    return makeBadRequestResponse("bad request: invalid CBOR");
+                }
+                if (typeof reqBodyJson !== "object" ||
+                    reqBodyJson === null ||
+                    Array.isArray(reqBodyJson)) {
+                    return makeBadRequestResponse("bad request: CBOR body must be a map");
+                }
+                const methodField = reqBodyJson["method"];
+                if (methodField === undefined) {
+                    return makeBadRequestResponse("bad request: missing 'method' field in CBOR");
+                }
+                if (typeof methodField === "string") {
+                    methodName = methodField;
+                    methodNumber = undefined;
+                }
+                else if (typeof methodField === "number") {
+                    methodName = "?";
+                    methodNumber = methodField;
+                }
+                else {
+                    return makeBadRequestResponse("bad request: 'method' field must be a string or a number");
+                }
+                format = "cbor";
+                const requestField = reqBodyJson["request"];
+                if (requestField === undefined) {
+                    return makeBadRequestResponse("bad request: missing 'request' field in CBOR");
+                }
+                requestData = ["json", requestField];
+            }
+            else if (typeof reqBody !== "string") {
+                return makeBadRequestResponse("bad request: invalid request format");
+            }
+            else {
+                const firstChar = reqBody.charAt(0);
+                if (/\s/.test(firstChar) || firstChar === "{") {
+                    // A JSON object
+                    let reqBodyJson;
+                    try {
+                        reqBodyJson = JSON.parse(reqBody);
+                    }
+                    catch (_e) {
+                        return makeBadRequestResponse("bad request: invalid JSON");
+                    }
+                    const methodField = reqBodyJson["method"];
+                    if (methodField === undefined) {
+                        return makeBadRequestResponse("bad request: missing 'method' field in JSON");
+                    }
+                    if (typeof methodField === "string") {
+                        methodName = methodField;
+                        methodNumber = undefined;
+                    }
+                    else if (typeof methodField === "number") {
+                        methodName = "?";
+                        methodNumber = methodField;
+                    }
+                    else {
+                        return makeBadRequestResponse("bad request: 'method' field must be a string or a number");
+                    }
+                    format = "readable";
+                    const requestField = reqBodyJson["request"];
+                    if (requestField === undefined) {
+                        return makeBadRequestResponse("bad request: missing 'request' field in JSON");
+                    }
+                    requestData = ["json", requestField];
+                }
+                else {
+                    // A colon-separated string
+                    const match = reqBody.match(/^([^:]*):([^:]*):([^:]*):([\S\s]*)$/);
+                    if (!match) {
+                        return makeBadRequestResponse("bad request: invalid request format");
+                    }
+                    methodName = match[1];
+                    const methodNumberStr = match[2];
+                    format = match[3];
+                    requestData = ["json-code", match[4]];
+                    if (methodNumberStr) {
+                        if (!/^-?[0-9]+$/.test(methodNumberStr)) {
+                            return makeBadRequestResponse("bad request: can't parse method number");
+                        }
+                        methodNumber = parseInt(methodNumberStr);
+                    }
+                    else {
+                        methodNumber = undefined;
+                    }
+                }
+            }
+            // Look up method by number or name
+            if (methodNumber === undefined) {
+                // Try to get the method number by name
+                const allMethods = Object.values(this.methodImpls);
+                const nameMatches = allMethods.filter((m) => m.method.name === methodName);
+                if (nameMatches.length === 0) {
+                    return makeBadRequestResponse(`bad request: method not found: ${methodName}`);
+                }
+                else if (nameMatches.length > 1) {
+                    return makeBadRequestResponse(`bad request: method name '${methodName}' is ambiguous; use method number instead`);
+                }
+                methodNumber = nameMatches[0].method.number;
+            }
+            const methodImpl = this.methodImpls[methodNumber];
+            if (!methodImpl) {
+                return makeBadRequestResponse(`bad request: method not found: ${methodName}; number: ${methodNumber}`);
+            }
+            let req;
+            try {
+                if (requestData[0] == "json") {
+                    req = methodImpl.method.requestSerializer.fromJson(requestData[1], this.options.keepUnrecognizedValues
+                        ? "keep-unrecognized-values"
+                        : undefined);
+                }
+                else {
+                    req = methodImpl.method.requestSerializer.fromJsonCode(requestData[1], this.options.keepUnrecognizedValues
+                        ? "keep-unrecognized-values"
+                        : undefined);
+                }
+            }
+            catch (e) {
+                return makeBadRequestResponse(`bad request: can't parse JSON: ${e}`);
+            }
+            let res;
+            let reqMeta;
+            try {
+                reqMeta = yield Promise.resolve(transformReqMeta(originalReqMeta));
+                res = yield methodImpl.impl(req, reqMeta);
+            }
+            catch (e) {
+                const errorInfo = {
+                    error: e,
+                    method: methodImpl.method,
+                    request: req,
+                    reqMeta: reqMeta,
+                };
+                this.options.errorLogger(errorInfo);
+                if (e instanceof ServiceError) {
+                    return e.toRawResponse();
+                }
+                else {
+                    let { canSendUnknownErrorMessage } = this.options;
+                    if (typeof canSendUnknownErrorMessage !== "boolean") {
+                        canSendUnknownErrorMessage = canSendUnknownErrorMessage(errorInfo);
+                    }
+                    const message = canSendUnknownErrorMessage
+                        ? `server error: ${e}`
+                        : "server error";
+                    return makeServerErrorResponse(message);
+                }
+            }
+            let resJson;
+            try {
+                const flavor = format === "readable" ? "readable" : "dense";
+                resJson =
+                    format === "cbor"
+                        ? methodImpl.method.responseSerializer.toJson(res, "dense")
+                        : methodImpl.method.responseSerializer.toJsonCode(res, flavor);
+            }
+            catch (e) {
+                return makeServerErrorResponse(`server error: can't serialize response to JSON: ${e}`);
+            }
+            return format === "cbor"
+                ? makeOkCborResponse(resJson)
+                : makeOkJsonResponse(resJson);
+        });
+    }
+    /**
+     * Creates a request handler that extracts simplified request metadata from
+     * framework-specific request objects before passing it to this service.
+     *
+     * This decouples your service implementation from the HTTP framework, making
+     * it easier to unit test (tests don't need to mock framework objects) and
+     * making the service implementation clearer by explicitly declaring exactly
+     * what request data it needs.
+     *
+     * @param transformFn Function that extracts the necessary data from the
+     *   framework-specific request object. Can be async or sync.
+     * @returns A request handler that accepts the framework-specific request type.
+     *
+     * @example
+     * ```typescript
+     * // Define a service that only needs to know if the user is an admin
+     *
+     * const service = new Service<{ isAdmin: boolean }>();
+     *
+     * service.addMethod(myMethod, async (req, { isAdmin }) => {
+     *   // Implementation is framework-agnostic and easy to test
+     *   if (!isAdmin) throw new ServiceError({ statusCode: 403, desc: "Forbidden" });
+     *   // ...
+     * });
+     *
+     * // Adapt it to work with Express
+     * const expressHandler = service.withMetaTransformer(
+     *   (req: ExpressRequest) => ({
+     *     isAdmin: req.user?.role === 'admin'
+     *   })
+     * );
+     * installServiceOnExpressApp(app, '/api', expressHandler, text, json);
+     * ```
+     */
+    withMetaTransformer(transformFn) {
+        return {
+            handleRequest: (reqBody, reqMeta) => __awaiter(this, void 0, void 0, function* () {
+                return this.doHandleRequest(reqBody, reqMeta, transformFn);
+            }),
+        };
+    }
+}
+const DEFAULT_SERVICE_OPTIONS = {
+    transportCodec: "legacy",
+    keepUnrecognizedValues: false,
+    canSendUnknownErrorMessage: false,
+    errorLogger: (errorInfo) => {
+        console.error(`Error in method ${errorInfo.method.name}:`, errorInfo.error);
+    },
+    studioAppJsUrl: "https://cdn.jsdelivr.net/npm/skir-studio/dist/skir-studio-standalone.js",
+};
+export function installServiceOnExpressApp(app, queryPath, service, text, json, raw) {
+    const callback = (req, res) => __awaiter(this, void 0, void 0, function* () {
+        let body;
+        const indexOfQuestionMark = req.originalUrl.indexOf("?");
+        if (indexOfQuestionMark >= 0) {
+            const queryString = req.originalUrl.substring(indexOfQuestionMark + 1);
+            body = decodeURIComponent(queryString);
+        }
+        else {
+            body =
+                req.body instanceof Uint8Array
+                    ? req.body
+                    : typeof req.body === "string"
+                        ? req.body
+                        : typeof req.body === "object"
+                            ? JSON.stringify(req.body)
+                            : "";
+        }
+        const rawResponse = yield service.handleRequest(body, req);
+        res
+            .status(rawResponse.statusCode)
+            .contentType(rawResponse.contentType)
+            .send(rawResponse.data);
+    });
+    app.get(queryPath, callback);
+    const middleware = raw
+        ? [text(), json(), raw({ type: "application/cbor" }), callback]
+        : [text(), json(), callback];
+    app.post(queryPath, ...middleware);
+}
+// The UNKNOWN variant is common to all enums.
+const UNKNOWN_VARIANT_SPEC = {
+    name: "UNKNOWN",
+    number: 0,
+};
+export function _initModuleClasses(modulePath, records) {
+    var _a, _b, _c, _d, _f;
+    const privateKey = PRIVATE_KEY;
+    // First loop: add a serializer property to every record class.
+    for (const record of records) {
+        const clazz = record.ctor;
+        switch (record.kind) {
+            case "struct": {
+                const { ctor, initFn } = record;
+                // Create the DEFAULT value. It will be initialized in a second loop.
+                // To see why we can't initialize it in the first loop, consider this
+                // example:
+                //   struct Foo { bar: Bar; }
+                //   struct Bar { foo: Foo; }
+                // The default value for Foo must contain a reference to the default
+                // value for Bar, and the default value for Bar also needs to contain
+                // a reference to the default value for Foo.
+                clazz.DEFAULT = new ctor(privateKey);
+                // Expose the mutable class as a static property of the frozen class.
+                const mutableCtor = makeMutableClassForRecord(record, clazz.DEFAULT);
+                clazz.Mutable = mutableCtor;
+                // Define the 'create' static factory function.
+                const createFn = (initializer) => {
+                    if (initializer instanceof ctor) {
+                        return initializer;
+                    }
+                    const ret = new ctor(privateKey);
+                    initFn(ret, initializer);
+                    if (initializer["^"]) {
+                        ret["^"] = initializer["^"];
+                    }
+                    return Object.freeze(ret);
+                };
+                clazz.create = createFn;
+                // Create the serializer. It will be initialized in a second loop.
+                clazz.serializer = new StructSerializerImpl(clazz.DEFAULT, createFn, () => new mutableCtor());
+                break;
+            }
+            case "enum": {
+                // Create the constants.
+                // Prepend the UNKNOWN variant to the array of variants specified from the
+                // generated code.
+                record.variants = [UNKNOWN_VARIANT_SPEC].concat(record.variants);
+                for (const variant of record.variants) {
+                    if (variant.type) {
+                        continue;
+                    }
+                    const property = variant.name;
+                    clazz[property] = new record.ctor(PRIVATE_KEY, variant.name);
+                }
+                // Define the 'create' static factory function.
+                const createFn = makeCreateEnumFunction(record);
+                clazz.create = createFn;
+                // Create the serializer. It will be initialized in a second loop.
+                clazz.serializer = new EnumSerializerImpl(createFn);
+                break;
+            }
+        }
+        // If the record is nested, expose the record class as a static property of
+        // the parent class.
+        if (record.parentCtor) {
+            record.parentCtor[record.name] = record.ctor;
+        }
+    }
+    // Second loop: initialize the serializer of every record, initialize the
+    // default value of every struct, and freeze every class so new properties
+    // can't be added to it.
+    for (const record of records) {
+        const clazz = record.ctor;
+        const parentTypeDescriptor = (_a = record.parentCtor) === null || _a === void 0 ? void 0 : _a.serializer;
+        switch (record.kind) {
+            case "struct": {
+                // Initializer serializer.
+                const fields = record.fields.map((f) => {
+                    var _a;
+                    return new StructFieldImpl(f.name, f.property, f.number, getSerializerForType(f.type), (_a = f.doc) !== null && _a !== void 0 ? _a : "");
+                });
+                const serializer = clazz.serializer;
+                serializer.init(record.name, modulePath, parentTypeDescriptor, (_b = record.doc) !== null && _b !== void 0 ? _b : "", fields, (_c = record.removedNumbers) !== null && _c !== void 0 ? _c : []);
+                // Initialize DEFAULT.
+                const { DEFAULT } = clazz;
+                record.initFn(DEFAULT, {});
+                Object.freeze(DEFAULT);
+                // Define the mutable getters in the Mutable class.
+                const mutableCtor = clazz.Mutable;
+                for (const field of record.fields) {
+                    if (field.mutableGetter) {
+                        Object.defineProperty(mutableCtor.prototype, field.mutableGetter, {
+                            get: makeMutableGetterFn(field),
+                        });
+                    }
+                }
+                // Define the search methods in the frozen class.
+                for (const field of record.fields) {
+                    if (field.indexable) {
+                        record.ctor.prototype[field.indexable.searchMethod] =
+                            makeSearchMethod(field);
+                    }
+                }
+                // Freeze the frozen class and the mutable class.
+                Object.freeze(record.ctor);
+                Object.freeze(record.ctor.prototype);
+                Object.freeze(clazz.Mutable);
+                Object.freeze(clazz.Mutable.prototype);
+                break;
+            }
+            case "enum": {
+                const serializer = clazz.serializer;
+                const variants = record.variants.map((f) => {
+                    var _a, _b;
+                    return f.type
+                        ? new EnumWrapperVariantImpl(f.name, f.number, getSerializerForType(f.type), (_a = f.doc) !== null && _a !== void 0 ? _a : "", serializer.createFn)
+                        : {
+                            name: f.name,
+                            number: f.number,
+                            constant: clazz[f.name],
+                            doc: (_b = f.doc) !== null && _b !== void 0 ? _b : "",
+                        };
+                });
+                serializer.init(record.name, modulePath, parentTypeDescriptor, (_d = record.doc) !== null && _d !== void 0 ? _d : "", variants, (_f = record.removedNumbers) !== null && _f !== void 0 ? _f : []);
+                // Freeze the enum class.
+                Object.freeze(record.ctor);
+                Object.freeze(record.ctor.prototype);
+                break;
+            }
+        }
+    }
+}
+function makeCreateEnumFunction(enumSpec) {
+    const { ctor, createValueFn } = enumSpec;
+    const createValue = createValueFn || (() => undefined);
+    const privateKey = PRIVATE_KEY;
+    return (initializer) => {
+        if (initializer instanceof ctor) {
+            return initializer;
+        }
+        if (typeof initializer === "string") {
+            const maybeResult = ctor[initializer];
+            if (maybeResult instanceof ctor) {
+                return maybeResult;
+            }
+            throw new Error(`Constant not found: ${initializer}`);
+        }
+        if (initializer instanceof UnrecognizedEnum) {
+            return new ctor(privateKey, "UNKNOWN", undefined, initializer);
+        }
+        const kind = initializer.kind;
+        if (kind === undefined) {
+            throw new Error("Missing entry: kind");
+        }
+        const unrecognized = initializer["^"];
+        const value = createValue(initializer);
+        if (value === undefined) {
+            const maybeConstant = ctor[kind];
+            if (!(maybeConstant instanceof ctor)) {
+                throw new Error(`Wrapper variant not found: ${kind}`);
+            }
+            return unrecognized
+                ? new ctor(privateKey, kind, undefined, unrecognized)
+                : maybeConstant;
+        }
+        return new ctor(privateKey, kind, value, unrecognized);
+    };
+}
+function makeMutableClassForRecord(structSpec, defaultFrozen) {
+    const { ctor: frozenCtor, initFn } = structSpec;
+    const frozenClass = frozenCtor;
+    class Mutable {
+        constructor(initializer = defaultFrozen) {
+            initFn(this, initializer);
+            if (initializer["^"]) {
+                this["^"] = initializer["^"];
+            }
+            Object.seal(this);
+        }
+        toFrozen() {
+            return frozenClass.create(this);
+        }
+        toString() {
+            const serializer = frozenClass.serializer;
+            return serializer.toJsonCode(this, "readable");
+        }
+    }
+    return Mutable;
+}
+function getSerializerForType(type) {
+    switch (type.kind) {
+        case "array":
+            return arraySerializer(getSerializerForType(type.item), type.keyChain);
+        case "optional":
+            return optionalSerializer(getSerializerForType(type.other));
+        case "primitive":
+            return primitiveSerializer(type.primitive);
+        case "record":
+            return type.ctor
+                .serializer;
+    }
+}
+// The `mutableArray()` getter of the Mutable class returns `this.array` if and
+// only if `mutableArray()` was never called before or if `this.array` is the
+// last value returned by `mutableArray()`.
+// Otherwise, it makes a mutable copy of `this.array`, assigns it to
+// `this.array` and returns it.
+const arraysReturnedByMutableGetters = new WeakMap();
+function makeMutableGetterFn(field) {
+    const { property, type } = field;
+    switch (type.kind) {
+        case "array": {
+            class Class {
+                static ret() {
+                    const value = this[property];
+                    if (arraysReturnedByMutableGetters.get(value) === this) {
+                        return value;
+                    }
+                    const copy = [...value];
+                    arraysReturnedByMutableGetters.set(copy, this);
+                    return (this[property] = copy);
+                }
+            }
+            return Class.ret;
+        }
+        case "record": {
+            const mutableCtor = type.ctor.Mutable;
+            class Class {
+                static ret() {
+                    const value = this[property];
+                    if (value instanceof mutableCtor) {
+                        return value;
+                    }
+                    return (this[property] = new mutableCtor(value));
+                }
+            }
+            return Class.ret;
+        }
+        default: {
+            throw new Error();
+        }
+    }
+}
+function makeSearchMethod(field) {
+    var _a;
+    const { property } = field;
+    const indexable = field.indexable;
+    const { keyFn } = indexable;
+    const keyToHashable = (_a = indexable.keyToHashable) !== null && _a !== void 0 ? _a : ((e) => e);
+    class Class {
+        ret(key) {
+            const array = this[property];
+            const frozenArrayInfo = frozenArrayRegistry.get(array);
+            let { keyFnToIndexing } = frozenArrayInfo;
+            if (!keyFnToIndexing) {
+                frozenArrayInfo.keyFnToIndexing = keyFnToIndexing = //
+                    new Map();
+            }
+            let hashableToValue = keyFnToIndexing.get(keyFn);
+            if (!hashableToValue) {
+                // The array has not been indexed yet. Index it.
+                hashableToValue = new Map();
+                for (const v of array) {
+                    const hashable = keyToHashable(keyFn(v));
+                    hashableToValue.set(hashable, v);
+                }
+                keyFnToIndexing.set(keyFn, hashableToValue);
+            }
+            return hashableToValue.get(keyToHashable(key));
+        }
+    }
+    return Class.prototype.ret;
+}
+function emptyToUndefined(str) {
+    return str ? str : undefined;
+}
+//# sourceMappingURL=skir-client.js.map