@series-inc/rundot-syncplay 5.23.0-beta.7

package/dist/cjs/schema-dsl-binary.js

@@ -0,0 +1,655 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deterministicDslMaxPlayers = deterministicDslMaxPlayers;
+exports.parseDeterministicSchemaDsl = parseDeterministicSchemaDsl;
+exports.createDeterministicBinarySerializer = createDeterministicBinarySerializer;
+exports.runDeterministicDslBinaryFixture = runDeterministicDslBinaryFixture;
+exports.stableDeterministicDslSchemaJson = stableDeterministicDslSchemaJson;
+const canonical_js_1 = require("./canonical.js");
+function deterministicDslMaxPlayers(schema) {
+    return Number(schema.pragmas['max-players'] ?? 0);
+}
+function parseDeterministicSchemaDsl(source) {
+    const imports = [...source.matchAll(/\bimport\s+(?:"([^"]+)"|'([^']+)'|([A-Za-z_][A-Za-z0-9_./-]*))\s*;/g)]
+        .map((match) => match[1] ?? match[2] ?? match[3])
+        .sort(compareStrings);
+    const pragmaEntries = [...source.matchAll(/#pragma\s+([A-Za-z_][A-Za-z0-9_-]*)\s+([A-Za-z0-9_.:/-]+)/g)]
+        .map((match) => [match[1], match[2]])
+        .sort((left, right) => compareStrings(left[0], right[0]));
+    const pragmas = Object.fromEntries(pragmaEntries);
+    assertUniqueStrings(imports, 'DSL import');
+    assertUniqueStrings(pragmaEntries.map((entry) => entry[0]), 'DSL pragma');
+    const declarations = [...source.matchAll(/\b((?:(?:synced|abstract|local|remote|server|client)\s+)*)(component|singleton|global|input|command|event|signal|struct|enum|flags|union)\s+([A-Za-z_][A-Za-z0-9_]*)\s*\{([^}]*)\}/g)]
+        .map((match) => ({
+        kind: match[2],
+        name: match[3],
+        fields: match[2] === 'enum' || match[2] === 'flags' ? parseDslSymbolFields(match[4]) : parseDslFields(match[4]),
+        modifiers: parseDslDeclarationModifiers(match[1]),
+    }))
+        .sort(compareDeclarations);
+    if (declarations.length === 0) {
+        throw new Error('Schema DSL did not contain any declarations');
+    }
+    const names = new Set();
+    for (const declaration of declarations) {
+        if (names.has(declaration.name)) {
+            throw new Error(`Duplicate DSL declaration ${declaration.name}`);
+        }
+        names.add(declaration.name);
+    }
+    const body = { imports, pragmas, declarations };
+    return { ...body, schemaHash: (0, canonical_js_1.defaultChecksum)(body) };
+}
+function createDeterministicBinarySerializer(schema) {
+    const declarations = new Map(schema.declarations.map((declaration) => [declaration.name, declaration]));
+    return {
+        encode(declarationName, value) {
+            const declaration = declarations.get(declarationName);
+            if (declaration === undefined) {
+                throw new Error(`Unknown DSL declaration ${declarationName}`);
+            }
+            return new Uint8Array(encodeFields(declaration, value));
+        },
+        decode(declarationName, bytes) {
+            const declaration = declarations.get(declarationName);
+            if (declaration === undefined) {
+                throw new Error(`Unknown DSL declaration ${declarationName}`);
+            }
+            return decodeFields(declaration, bytes);
+        },
+    };
+}
+function runDeterministicDslBinaryFixture() {
+    const source = `
+#pragma max-players 128
+import "shared/loadouts";
+enum Team { Red; Blue; }
+flags AbilityFlags { Flying; Shielded; }
+component Position { x: fixed; y: fixed; z: fixed; }
+singleton MatchState { tick: int; overtime: bool; }
+global RuntimeConfig { maxPlayers: int; modes: set<string>; weights: dictionary<string,int>; }
+input Move { dx: int; dz: int; jump: button; }
+command Spawn { prototype: asset_ref<Prototype>; owner: player_ref; targets: entity-ref[2]; count: int; }
+synced event DamageEvent { source: entity-ref; target: entity-ref; amount: int; team: enum<Team>; flags: bitset<AbilityFlags>; }
+signal ScoreSignal { slot: int; points: int; }
+union TargetUnion { entity: entity_ref; owner: player_ref; }
+struct Loadout { weapons: asset-ref[]; flags: bool[3]; inventory: list<asset_ref<Prototype>>; tags: hash_set<string>; ammo: dictionary<string,int>; }
+`;
+    const permutedSource = `
+#pragma max-players 128
+import shared/loadouts;
+struct Loadout { tags: hash_set<string>; inventory: list<asset_ref<Prototype>>; flags: bool[3]; ammo: dictionary<string,int>; weapons: asset-ref[]; }
+union TargetUnion { owner: player_ref; entity: entity_ref; }
+signal ScoreSignal { points: int; slot: int; }
+synced event DamageEvent { amount: int; flags: bitset<AbilityFlags>; source: entity-ref; target: entity-ref; team: enum<Team>; }
+command Spawn { count: int; owner: player_ref; prototype: asset_ref<Prototype>; targets: entity-ref[2]; }
+input Move { dx: int; dz: int; jump: button; }
+global RuntimeConfig { weights: dictionary<string, int>; modes: set<string>; maxPlayers: int; }
+singleton MatchState { tick: int; overtime: bool; }
+component Position { x: fixed; y: fixed; z: fixed; }
+flags AbilityFlags { Shielded; Flying; }
+enum Team { Blue; Red; }
+`;
+    const schema = parseDeterministicSchemaDsl(source);
+    const permuted = parseDeterministicSchemaDsl(permutedSource);
+    const serializer = createDeterministicBinarySerializer(schema);
+    const samples = [
+        serializer.encode('Position', { x: 1.25, y: -2.5, z: 3 }),
+        serializer.encode('MatchState', { tick: 120, overtime: true }),
+        serializer.encode('RuntimeConfig', {
+            maxPlayers: 128,
+            modes: ['duel', 'arena'],
+            weights: [{ key: 'duel', value: 2 }, { key: 'arena', value: 1 }],
+        }),
+        serializer.encode('Move', { dx: -1, dz: 1, jump: true }),
+        serializer.encode('Spawn', { prototype: 'enemy.basic', owner: 4, targets: [11, 12], count: 3 }),
+        serializer.encode('DamageEvent', { source: 1, target: 2, amount: 7, team: 1, flags: 3 }),
+        serializer.encode('ScoreSignal', { slot: 3, points: 25 }),
+        serializer.encode('TargetUnion', { entity: 12, owner: 4 }),
+        serializer.encode('Loadout', {
+            weapons: ['weapon.a', 'weapon.b'],
+            flags: [true, false, true],
+            inventory: ['item.z', 'item.a'],
+            tags: ['rare', 'starter'],
+            ammo: [{ key: 'rocket', value: 2 }, { key: 'bullet', value: 30 }],
+        }),
+    ];
+    const decoded = [
+        serializer.decode('Position', samples[0]),
+        serializer.decode('MatchState', samples[1]),
+        serializer.decode('RuntimeConfig', samples[2]),
+        serializer.decode('Move', samples[3]),
+        serializer.decode('Spawn', samples[4]),
+        serializer.decode('DamageEvent', samples[5]),
+        serializer.decode('ScoreSignal', samples[6]),
+        serializer.decode('TargetUnion', samples[7]),
+        serializer.decode('Loadout', samples[8]),
+    ];
+    let rejectedBadField = false;
+    try {
+        serializer.encode('Move', { dx: 1, jump: false });
+    }
+    catch {
+        rejectedBadField = true;
+    }
+    let rejectedExtraField = false;
+    try {
+        serializer.encode('Move', { dx: 1, dz: 0, jump: false, extra: 1 });
+    }
+    catch {
+        rejectedExtraField = true;
+    }
+    let rejectedBadDeclaration = false;
+    try {
+        serializer.encode('Missing', {});
+    }
+    catch {
+        rejectedBadDeclaration = true;
+    }
+    let rejectedDuplicateSetValue = false;
+    try {
+        serializer.encode('RuntimeConfig', {
+            maxPlayers: 128,
+            modes: ['arena', 'arena'],
+            weights: [{ key: 'arena', value: 1 }],
+        });
+    }
+    catch {
+        rejectedDuplicateSetValue = true;
+    }
+    let rejectedDuplicateDictionaryKey = false;
+    try {
+        serializer.encode('RuntimeConfig', {
+            maxPlayers: 128,
+            modes: ['arena'],
+            weights: [{ key: 'arena', value: 1 }, { key: 'arena', value: 2 }],
+        });
+    }
+    catch {
+        rejectedDuplicateDictionaryKey = true;
+    }
+    let rejectedWrongFixedArrayLength = false;
+    try {
+        serializer.encode('Spawn', { prototype: 'enemy.basic', owner: 4, targets: [11], count: 3 });
+    }
+    catch {
+        rejectedWrongFixedArrayLength = true;
+    }
+    const fields = schema.declarations.flatMap((declaration) => declaration.fields);
+    return {
+        schemaHash: schema.schemaHash,
+        declarations: schema.declarations.length,
+        fieldKinds: [...new Set(fields.map((field) => field.kind))].sort(compareStrings),
+        eventDeclarations: schema.declarations.filter((declaration) => declaration.kind === 'event').length,
+        signalDeclarations: schema.declarations.filter((declaration) => declaration.kind === 'signal').length,
+        structDeclarations: schema.declarations.filter((declaration) => declaration.kind === 'struct').length,
+        globalDeclarations: schema.declarations.filter((declaration) => declaration.kind === 'global').length,
+        importCount: schema.imports.length,
+        pragmaCount: stableRecordKeys(schema.pragmas).length,
+        maxPlayers: deterministicDslMaxPlayers(schema),
+        assetRefFields: fields.filter((field) => scalarKindForCollection(field.kind) === 'asset-ref').length,
+        entityRefFields: fields.filter((field) => scalarKindForCollection(field.kind) === 'entity-ref').length,
+        arrayFields: fields.filter((field) => isArrayKind(field.kind) || isFixedArrayKind(field.kind)).length,
+        fixedArrayFields: fields.filter((field) => isFixedArrayKind(field.kind)).length,
+        listFields: fields.filter((field) => isListKind(field.kind)).length,
+        setFields: fields.filter((field) => isSetKind(field.kind)).length,
+        dictionaryFields: fields.filter((field) => isDictionaryKind(field.kind)).length,
+        buttonFields: fields.filter((field) => field.kind === 'button').length,
+        enumDeclarations: schema.declarations.filter((declaration) => declaration.kind === 'enum').length,
+        flagsDeclarations: schema.declarations.filter((declaration) => declaration.kind === 'flags').length,
+        unionDeclarations: schema.declarations.filter((declaration) => declaration.kind === 'union').length,
+        playerRefFields: fields.filter((field) => scalarKindForCollection(field.kind) === 'player-ref').length,
+        typedAssetRefFields: fields.filter((field) => isTypedAssetRefKind(scalarKindForCollection(field.kind))).length,
+        bitsetFields: fields.filter((field) => isBitsetKind(scalarKindForCollection(field.kind))).length,
+        declarationModifiers: schema.declarations.reduce((sum, declaration) => sum + declaration.modifiers.length, 0),
+        hashSetAliasFields: fields.filter((field) => isSetKind(field.kind)).length,
+        encodedBytes: samples.reduce((sum, bytes) => sum + bytes.byteLength, 0),
+        roundTripChecksum: (0, canonical_js_1.defaultChecksum)(decoded),
+        permutationStable: schema.schemaHash === permuted.schemaHash,
+        rejectedBadField,
+        rejectedExtraField,
+        rejectedBadDeclaration,
+        rejectedDuplicateSetValue,
+        rejectedDuplicateDictionaryKey,
+        rejectedWrongFixedArrayLength,
+    };
+}
+function parseDslFields(body) {
+    const fields = body.split(';')
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0)
+        .map(parseDslField)
+        .sort(compareFields);
+    const names = new Set();
+    for (const field of fields) {
+        if (names.has(field.name)) {
+            throw new Error(`Duplicate DSL field ${field.name}`);
+        }
+        names.add(field.name);
+    }
+    return fields;
+}
+function parseDslField(part) {
+    const colonIndex = part.indexOf(':');
+    if (colonIndex >= 0) {
+        const name = part.slice(0, colonIndex).trim();
+        const kind = part.slice(colonIndex + 1).trim();
+        if (isDslIdentifier(name) && kind.length > 0) {
+            return { name, kind: parseDslFieldKind(kind) };
+        }
+        throw new Error(`Invalid DSL field ${part}`);
+    }
+    const separatorIndex = lastWhitespaceRunStart(part);
+    if (separatorIndex < 0) {
+        throw new Error(`Invalid DSL field ${part}`);
+    }
+    const kind = part.slice(0, separatorIndex).trim();
+    const name = part.slice(separatorIndex).trim();
+    if (kind.length === 0 || !isDslIdentifier(name)) {
+        throw new Error(`Invalid DSL field ${part}`);
+    }
+    return { name, kind: parseDslFieldKind(kind) };
+}
+function lastWhitespaceRunStart(value) {
+    let index = value.length - 1;
+    while (index >= 0 && !isWhitespace(value[index])) {
+        index -= 1;
+    }
+    if (index < 0) {
+        return -1;
+    }
+    while (index > 0 && isWhitespace(value[index - 1])) {
+        index -= 1;
+    }
+    return index;
+}
+function isDslIdentifier(value) {
+    if (value.length === 0 || !isIdentifierStart(value.charCodeAt(0))) {
+        return false;
+    }
+    for (let index = 1; index < value.length; index += 1) {
+        if (!isIdentifierPart(value.charCodeAt(index))) {
+            return false;
+        }
+    }
+    return true;
+}
+function isIdentifierStart(code) {
+    return (code >= 65 && code <= 90) || (code >= 97 && code <= 122) || code === 95;
+}
+function isIdentifierPart(code) {
+    return isIdentifierStart(code) || (code >= 48 && code <= 57);
+}
+function isWhitespace(value) {
+    return value === ' ' || value === '\n' || value === '\r' || value === '\t' || value === '\f';
+}
+function parseDslSymbolFields(body) {
+    const fields = body.split(';')
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0)
+        .map((part) => {
+        const match = /^([A-Za-z_][A-Za-z0-9_]*)(?:\s*=\s*-?[0-9]+)?$/.exec(part);
+        if (match === null) {
+            throw new Error(`Invalid DSL symbol ${part}`);
+        }
+        return { name: match[1], kind: 'int' };
+    })
+        .sort(compareFields);
+    const names = new Set();
+    for (const field of fields) {
+        if (names.has(field.name)) {
+            throw new Error(`Duplicate DSL symbol ${field.name}`);
+        }
+        names.add(field.name);
+    }
+    return fields;
+}
+function parseDslDeclarationModifiers(raw) {
+    const modifiers = raw.trim().length === 0
+        ? []
+        : raw.trim().split(/\s+/).filter((modifier) => modifier.length > 0).sort(compareStrings);
+    assertUniqueStrings(modifiers, 'DSL declaration modifier');
+    return modifiers;
+}
+function encodeFields(declaration, value) {
+    const bytes = [];
+    const fieldNames = new Set(declaration.fields.map((field) => field.name));
+    for (const key of Object.keys(value).sort(compareStrings)) {
+        if (!fieldNames.has(key)) {
+            throw new Error(`Unknown field ${key} for ${declaration.name}`);
+        }
+    }
+    for (const field of declaration.fields) {
+        if (!(field.name in value)) {
+            throw new Error(`Missing field ${field.name} for ${declaration.name}`);
+        }
+        appendField(bytes, field.kind, value[field.name]);
+    }
+    return bytes;
+}
+function appendField(bytes, kind, value) {
+    if (isDictionaryKind(kind)) {
+        appendDictionaryField(bytes, kind, value);
+        return;
+    }
+    if (isArrayLikeKind(kind)) {
+        if (!Array.isArray(value)) {
+            throw new Error(`Expected array for ${kind} field`);
+        }
+        const fixedLength = fixedArrayLength(kind);
+        if (fixedLength !== undefined && value.length !== fixedLength) {
+            throw new Error(`Fixed array ${kind} field requires exactly ${fixedLength} values`);
+        }
+        if (fixedLength === undefined && value.length > 65535) {
+            throw new Error('Array field too large');
+        }
+        const scalarKind = scalarKindForCollection(kind);
+        const values = isSetKind(kind) ? canonicalSetValues(value, scalarKind) : value;
+        if (fixedLength === undefined) {
+            appendUint16(bytes, values.length);
+        }
+        for (const item of values) {
+            if (isDictionaryEntry(item)) {
+                throw new Error(`Invalid ${kind} field value`);
+            }
+            appendScalarField(bytes, scalarKind, item);
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        throw new Error(`Unexpected array for ${kind} field`);
+    }
+    if (typeof value !== 'boolean' && typeof value !== 'number' && typeof value !== 'string') {
+        throw new Error(`Invalid ${kind} field value`);
+    }
+    appendScalarField(bytes, kind, value);
+}
+function appendScalarField(bytes, kind, value) {
+    if (kind === 'bool' || kind === 'button') {
+        if (typeof value !== 'boolean') {
+            throw new Error(`${kind} field requires boolean value`);
+        }
+        bytes.push(value ? 1 : 0);
+        return;
+    }
+    if (kind === 'string' || kind === 'asset-ref' || isTypedAssetRefKind(kind)) {
+        if (typeof value !== 'string') {
+            throw new Error(`${kind} field requires string value`);
+        }
+        const encoded = (0, canonical_js_1.encodeUtf8)(value);
+        if (encoded.byteLength > 65535) {
+            throw new Error('String field too large');
+        }
+        appendUint16(bytes, encoded.byteLength);
+        for (const byte of encoded) {
+            bytes.push(byte);
+        }
+        return;
+    }
+    const numeric = kind === 'fixed' ? Math.round(Number(value) * 65536) : Number(value);
+    if (!Number.isInteger(numeric)) {
+        throw new Error(`Non-integer ${kind} value`);
+    }
+    if (numeric < -2147483648 || numeric > 2147483647) {
+        throw new Error(`${kind} value outside int32 range`);
+    }
+    appendInt32(bytes, numeric);
+}
+function decodeFields(declaration, bytes) {
+    let offset = 0;
+    const value = {};
+    for (const field of declaration.fields) {
+        const decoded = readField(bytes, offset, field.kind);
+        value[field.name] = decoded.value;
+        offset = decoded.offset;
+    }
+    if (offset !== bytes.byteLength) {
+        throw new Error(`Trailing bytes for ${declaration.name}`);
+    }
+    return value;
+}
+function readField(bytes, offset, kind) {
+    if (isDictionaryKind(kind)) {
+        return readDictionaryField(bytes, offset, kind);
+    }
+    if (isArrayLikeKind(kind)) {
+        const fixedLength = fixedArrayLength(kind);
+        const length = fixedLength ?? readUint16(bytes, offset);
+        let nextOffset = fixedLength === undefined ? offset + 2 : offset;
+        const scalarKind = scalarKindForCollection(kind);
+        const value = [];
+        for (let index = 0; index < length; index += 1) {
+            const decoded = readScalarField(bytes, nextOffset, scalarKind);
+            value.push(decoded.value);
+            nextOffset = decoded.offset;
+        }
+        return { value, offset: nextOffset };
+    }
+    return readScalarField(bytes, offset, kind);
+}
+function readScalarField(bytes, offset, kind) {
+    if (kind === 'bool' || kind === 'button') {
+        assertAvailable(bytes, offset, 1);
+        if (bytes[offset] !== 0 && bytes[offset] !== 1) {
+            throw new Error(`Invalid ${kind} byte`);
+        }
+        return { value: bytes[offset] === 1, offset: offset + 1 };
+    }
+    if (kind === 'string' || kind === 'asset-ref' || isTypedAssetRefKind(kind)) {
+        const length = readUint16(bytes, offset);
+        const start = offset + 2;
+        const end = start + length;
+        assertAvailable(bytes, start, length);
+        return {
+            value: (0, canonical_js_1.decodeUtf8)(bytes.slice(start, end)),
+            offset: end,
+        };
+    }
+    const int = readInt32(bytes, offset);
+    return { value: kind === 'fixed' ? int / 65536 : int, offset: offset + 4 };
+}
+function appendInt32(bytes, value) {
+    bytes.push(value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff, (value >> 24) & 0xff);
+}
+function appendUint16(bytes, value) {
+    bytes.push(value & 0xff, (value >> 8) & 0xff);
+}
+function readInt32(bytes, offset) {
+    assertAvailable(bytes, offset, 4);
+    return (bytes[offset] | (bytes[offset + 1] << 8) | (bytes[offset + 2] << 16) | (bytes[offset + 3] << 24)) | 0;
+}
+function readUint16(bytes, offset) {
+    assertAvailable(bytes, offset, 2);
+    return bytes[offset] | (bytes[offset + 1] << 8);
+}
+function assertAvailable(bytes, offset, length) {
+    if (offset < 0 || offset + length > bytes.byteLength) {
+        throw new Error('Truncated DSL binary payload');
+    }
+}
+function isArrayKind(kind) {
+    return kind.endsWith('[]');
+}
+function isFixedArrayKind(kind) {
+    return new RegExp(`^${scalarKindPattern()}\\[[1-9][0-9]*\\]$`).test(kind);
+}
+function isListKind(kind) {
+    return kind.startsWith('list<') && kind.endsWith('>');
+}
+function isSetKind(kind) {
+    return kind.startsWith('set<') && kind.endsWith('>');
+}
+function isDictionaryKind(kind) {
+    return kind.startsWith('dictionary<') && kind.endsWith('>');
+}
+function isArrayLikeKind(kind) {
+    return isArrayKind(kind) || isFixedArrayKind(kind) || isListKind(kind) || isSetKind(kind);
+}
+function scalarKindForCollection(kind) {
+    if (isArrayKind(kind)) {
+        return kind.slice(0, -2);
+    }
+    if (isFixedArrayKind(kind)) {
+        return kind.slice(0, kind.indexOf('['));
+    }
+    if (isListKind(kind) || isSetKind(kind)) {
+        return kind.slice(kind.indexOf('<') + 1, -1);
+    }
+    if (isDictionaryKind(kind)) {
+        return kind.slice(kind.indexOf('<') + 1, kind.indexOf(','));
+    }
+    return kind;
+}
+function parseDslFieldKind(rawKind) {
+    const normalized = normalizeDslFieldKind(rawKind);
+    const scalar = scalarKindPattern();
+    if (new RegExp(`^${scalar}(\\[\\])?$`).test(normalized)) {
+        return normalized;
+    }
+    if (new RegExp(`^${scalar}\\[[1-9][0-9]*\\]$`).test(normalized)) {
+        return normalized;
+    }
+    if (new RegExp(`^(list|set)<${scalar}>$`).test(normalized)) {
+        return normalized;
+    }
+    if (new RegExp(`^dictionary<${scalar},${scalar}>$`).test(normalized)) {
+        return normalized;
+    }
+    throw new Error(`Invalid DSL field kind ${rawKind}`);
+}
+function normalizeDslFieldKind(rawKind) {
+    return rawKind
+        .replace(/\bFP\b/g, 'fixed')
+        .replace(/\bInt32\b/g, 'int')
+        .replace(/\bBoolean\b/g, 'bool')
+        .replace(/\bEntityRef\b/g, 'entity-ref')
+        .replace(/\bPlayerRef\b/g, 'player-ref')
+        .replace(/\bAssetRef<([A-Za-z_][A-Za-z0-9_]*)>/g, 'asset-ref:$1')
+        .replace(/\s+/g, '')
+        .replace(/\bentity_ref\b/g, 'entity-ref')
+        .replace(/\bplayer_ref\b/g, 'player-ref')
+        .replace(/\bhash_set</g, 'set<')
+        .replace(/\basset_ref<([A-Za-z_][A-Za-z0-9_]*)>/g, 'asset-ref:$1')
+        .replace(/\basset-ref<([A-Za-z_][A-Za-z0-9_]*)>/g, 'asset-ref:$1')
+        .replace(/\benum<([A-Za-z_][A-Za-z0-9_]*)>/g, 'enum:$1')
+        .replace(/\bflags<([A-Za-z_][A-Za-z0-9_]*)>/g, 'flags:$1')
+        .replace(/\bbitset<([A-Za-z_][A-Za-z0-9_]*)>/g, 'bitset:$1');
+}
+function scalarKindPattern() {
+    return '(?:int|fixed|bool|button|string|asset-ref|entity-ref|player-ref|asset-ref:[A-Za-z_][A-Za-z0-9_]*|enum:[A-Za-z_][A-Za-z0-9_]*|flags:[A-Za-z_][A-Za-z0-9_]*|bitset:[A-Za-z_][A-Za-z0-9_]*)';
+}
+function isTypedAssetRefKind(kind) {
+    return kind.startsWith('asset-ref:');
+}
+function isBitsetKind(kind) {
+    return kind.startsWith('bitset:');
+}
+function fixedArrayLength(kind) {
+    if (!isFixedArrayKind(kind)) {
+        return undefined;
+    }
+    return Number(kind.slice(kind.indexOf('[') + 1, -1));
+}
+function appendDictionaryField(bytes, kind, value) {
+    if (!Array.isArray(value)) {
+        throw new Error(`Expected dictionary entries for ${kind} field`);
+    }
+    const entries = canonicalDictionaryEntries(value, kind);
+    if (entries.length > 65535) {
+        throw new Error('Dictionary field too large');
+    }
+    appendUint16(bytes, entries.length);
+    const [keyKind, valueKind] = dictionaryKinds(kind);
+    for (const entry of entries) {
+        appendScalarField(bytes, keyKind, entry.key);
+        appendScalarField(bytes, valueKind, entry.value);
+    }
+}
+function readDictionaryField(bytes, offset, kind) {
+    const length = readUint16(bytes, offset);
+    let nextOffset = offset + 2;
+    const [keyKind, valueKind] = dictionaryKinds(kind);
+    const value = [];
+    for (let index = 0; index < length; index += 1) {
+        const key = readScalarField(bytes, nextOffset, keyKind);
+        const decodedValue = readScalarField(bytes, key.offset, valueKind);
+        value.push({ key: key.value, value: decodedValue.value });
+        nextOffset = decodedValue.offset;
+    }
+    return { value, offset: nextOffset };
+}
+function canonicalSetValues(value, scalarKind) {
+    const values = value.map((item) => {
+        if (isDictionaryEntry(item)) {
+            throw new Error('Set field cannot contain dictionary entries');
+        }
+        return item;
+    }).sort(compareScalarValues);
+    let previous;
+    for (const item of values) {
+        const key = scalarValueKey(item);
+        if (previous === key) {
+            throw new Error(`Duplicate ${scalarKind} set value ${key}`);
+        }
+        previous = key;
+    }
+    return values;
+}
+function canonicalDictionaryEntries(value, kind) {
+    const entries = value.map((entry) => {
+        if (!isDictionaryEntry(entry)) {
+            throw new Error(`Invalid ${kind} dictionary entry`);
+        }
+        return entry;
+    }).sort(compareDictionaryEntries);
+    let previous;
+    for (const entry of entries) {
+        const key = scalarValueKey(entry.key);
+        if (previous === key) {
+            throw new Error(`Duplicate dictionary key ${key}`);
+        }
+        previous = key;
+    }
+    return entries;
+}
+function dictionaryKinds(kind) {
+    const body = kind.slice('dictionary<'.length, -1);
+    const [keyKind, valueKind] = body.split(',');
+    return [keyKind, valueKind];
+}
+function isDictionaryEntry(value) {
+    return typeof value === 'object' && value !== null && 'key' in value && 'value' in value;
+}
+function assertUniqueStrings(values, label) {
+    const seen = new Set();
+    for (const value of values) {
+        if (seen.has(value)) {
+            throw new Error(`Duplicate ${label} ${value}`);
+        }
+        seen.add(value);
+    }
+}
+function stableRecordKeys(record) {
+    return Object.keys(record).sort(compareStrings);
+}
+function compareScalarValues(left, right) {
+    return scalarValueKey(left) < scalarValueKey(right) ? -1 : scalarValueKey(left) > scalarValueKey(right) ? 1 : 0;
+}
+function compareDictionaryEntries(left, right) {
+    return compareScalarValues(left.key, right.key) || compareScalarValues(left.value, right.value);
+}
+function scalarValueKey(value) {
+    return `${typeof value}:${String(value)}`;
+}
+function compareDeclarations(left, right) {
+    return compareStrings(left.kind, right.kind) || compareStrings(left.name, right.name);
+}
+function compareFields(left, right) {
+    return compareStrings(left.name, right.name);
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function stableDeterministicDslSchemaJson(schema) {
+    return `${(0, canonical_js_1.canonicalStringify)(schema)}\n`;
+}