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

package/dist/cjs/schema-codegen.js

@@ -0,0 +1,544 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSchemaTypes = generateSchemaTypes;
+exports.createDeterministicDescriptorBinarySchema = createDeterministicDescriptorBinarySchema;
+exports.generateSchemaBinarySource = generateSchemaBinarySource;
+exports.proveSchemaBinaryRoundTrip = proveSchemaBinaryRoundTrip;
+const schema_js_1 = require("./schema.js");
+const canonical_js_1 = require("./canonical.js");
+const schema_dsl_binary_js_1 = require("./schema-dsl-binary.js");
+const typeScriptIdentifierPattern = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function generateSchemaTypes(descriptor, options = {}) {
+    const validated = (0, schema_js_1.defineSyncplayGame)(descriptor);
+    const rootName = schemaRootName(options.rootName, validated.deterministicVersion);
+    const lines = [];
+    lines.push(`export const ${rootName}SchemaIdentity = ${JSON.stringify(validated.replayIdentity, null, 2)} as const;`);
+    lines.push('');
+    lines.push(`export interface ${rootName}Input {`);
+    for (const field of validated.input.fields) {
+        lines.push(`  readonly ${propertyName(field.name)}: ${fieldToType(field)};`);
+    }
+    lines.push('}');
+    lines.push('');
+    lines.push(`export function create${rootName}DefaultInput(): ${rootName}Input {`);
+    lines.push('  return {');
+    for (const field of validated.input.fields) {
+        lines.push(`    ${propertyName(field.name)}: ${literalForDefaultValue(field)},`);
+    }
+    lines.push('  };');
+    lines.push('}');
+    lines.push('');
+    lines.push(`export function serialize${rootName}Input(input: ${rootName}Input): string {`);
+    lines.push(`  return stableStringify${rootName}(input);`);
+    lines.push('}');
+    lines.push('');
+    lines.push(`export function deserialize${rootName}Input(source: string): ${rootName}Input {`);
+    lines.push(`  return validate${rootName}Input(JSON.parse(source) as unknown);`);
+    lines.push('}');
+    lines.push('');
+    lines.push(`export interface ${rootName}State {`);
+    for (const field of validated.state.fields) {
+        lines.push(`  readonly ${propertyName(field.name)}: ${fieldToType(field)};`);
+    }
+    lines.push('}');
+    lines.push('');
+    lines.push(`export function serialize${rootName}State(state: ${rootName}State): string {`);
+    lines.push(`  return stableStringify${rootName}(state);`);
+    lines.push('}');
+    lines.push('');
+    lines.push(`export function deserialize${rootName}State(source: string): ${rootName}State {`);
+    lines.push(`  return validate${rootName}State(JSON.parse(source) as unknown);`);
+    lines.push('}');
+    for (const channel of validated.commandChannels ?? []) {
+        const commandName = `${rootName}${toPascalCase(channel.id)}Command`;
+        lines.push('');
+        lines.push(`export interface ${commandName} {`);
+        for (const field of channel.fields) {
+            lines.push(`  readonly ${propertyName(field.name)}: ${fieldToType(field)};`);
+        }
+        lines.push('}');
+        lines.push('');
+        lines.push(`export function serialize${commandName}(command: ${commandName}): string {`);
+        lines.push(`  return stableStringify${rootName}(command);`);
+        lines.push('}');
+        lines.push('');
+        lines.push(`export function deserialize${commandName}(source: string): ${commandName} {`);
+        lines.push(`  return validate${commandName}(JSON.parse(source) as unknown);`);
+        lines.push('}');
+    }
+    lines.push('');
+    lines.push(`export interface ${rootName}ReplayMetadata {`);
+    lines.push('  readonly deterministicVersion: string;');
+    lines.push('  readonly engineIdentityHash: string;');
+    lines.push('  readonly artifactId: string;');
+    lines.push('  readonly inputSchemaId: string;');
+    lines.push('  readonly stateSchemaId: string;');
+    lines.push('  readonly commandSchemaId: string;');
+    lines.push('  readonly assetSchemaId: string;');
+    lines.push('  readonly configSchemaId: string;');
+    lines.push('  readonly randomSeed: number;');
+    lines.push('  readonly checksumCadence: number;');
+    lines.push('}');
+    lines.push('');
+    lines.push(`export function serialize${rootName}ReplayMetadata(metadata: ${rootName}ReplayMetadata): string {`);
+    lines.push(`  return stableStringify${rootName}(metadata);`);
+    lines.push('}');
+    lines.push('');
+    lines.push(`export function deserialize${rootName}ReplayMetadata(source: string): ${rootName}ReplayMetadata {`);
+    lines.push(`  return validate${rootName}ReplayMetadata(JSON.parse(source) as unknown);`);
+    lines.push('}');
+    lines.push('');
+    lines.push(`export interface ${rootName}AssetManifest {`);
+    lines.push('  readonly assetDbHash: string;');
+    lines.push('  readonly lookupHash: string;');
+    lines.push('  readonly schemaHash: string;');
+    lines.push('  readonly dependencyHash: string;');
+    lines.push('}');
+    lines.push('');
+    lines.push(`export function serialize${rootName}AssetManifest(manifest: ${rootName}AssetManifest): string {`);
+    lines.push(`  return stableStringify${rootName}(manifest);`);
+    lines.push('}');
+    lines.push('');
+    lines.push(`export function deserialize${rootName}AssetManifest(source: string): ${rootName}AssetManifest {`);
+    lines.push(`  return validate${rootName}AssetManifest(JSON.parse(source) as unknown);`);
+    lines.push('}');
+    const eventTypes = [];
+    for (const event of validated.events ?? []) {
+        const eventName = `${rootName}${toPascalCase(event.id.split('.').at(-1) ?? event.id)}Event`;
+        const payloadName = `${eventName}Payload`;
+        eventTypes.push(eventName);
+        lines.push('');
+        lines.push(`export interface ${payloadName} {`);
+        for (const field of event.payloadFields) {
+            lines.push(`  readonly ${propertyName(field.name)}: ${fieldToType(field)};`);
+        }
+        lines.push('}');
+        lines.push('');
+        lines.push(`export interface ${eventName} {`);
+        lines.push(`  readonly id: '${event.id}';`);
+        lines.push(`  readonly rollback: '${event.rollback}';`);
+        lines.push(`  readonly payload: ${payloadName};`);
+        lines.push('}');
+    }
+    if (eventTypes.length > 0) {
+        lines.push('');
+        lines.push(`export type ${rootName}Event = ${eventTypes.join(' | ')};`);
+    }
+    else {
+        lines.push('');
+        lines.push(`export type ${rootName}Event = never;`);
+    }
+    for (const asset of validated.assets ?? []) {
+        lines.push('');
+        lines.push(`export interface ${rootName}${toPascalCase(asset.id)}Asset {`);
+        for (const field of asset.fields) {
+            lines.push(`  readonly ${propertyName(field.name)}: ${fieldToType(field)};`);
+        }
+        lines.push('}');
+    }
+    if (validated.config !== undefined) {
+        lines.push('');
+        lines.push(`export interface ${rootName}Config {`);
+        for (const field of validated.config.fields) {
+            lines.push(`  readonly ${propertyName(field.name)}: ${fieldToType(field)};`);
+        }
+        lines.push('}');
+    }
+    lines.push('');
+    lines.push(`function stableStringify${rootName}(value: unknown): string {`);
+    lines.push(`  return JSON.stringify(stableCanonicalize${rootName}(value));`);
+    lines.push('}');
+    emitObjectValidator(lines, rootName, `${rootName}Input`, `${rootName}Input`, validated.input.fields, validated.maxPlayers);
+    emitObjectValidator(lines, rootName, `${rootName}State`, `${rootName}State`, validated.state.fields, validated.maxPlayers);
+    for (const channel of validated.commandChannels ?? []) {
+        const commandName = `${rootName}${toPascalCase(channel.id)}Command`;
+        emitObjectValidator(lines, rootName, commandName, commandName, channel.fields, validated.maxPlayers);
+    }
+    emitFixedObjectValidator(lines, rootName, `${rootName}ReplayMetadata`, `${rootName}ReplayMetadata`, [
+        { name: 'deterministicVersion', kind: 'string' },
+        { name: 'engineIdentityHash', kind: 'string' },
+        { name: 'artifactId', kind: 'string' },
+        { name: 'inputSchemaId', kind: 'string' },
+        { name: 'stateSchemaId', kind: 'string' },
+        { name: 'commandSchemaId', kind: 'string' },
+        { name: 'assetSchemaId', kind: 'string' },
+        { name: 'configSchemaId', kind: 'string' },
+        { name: 'randomSeed', kind: 'integer' },
+        { name: 'checksumCadence', kind: 'integer' },
+    ]);
+    emitFixedObjectValidator(lines, rootName, `${rootName}AssetManifest`, `${rootName}AssetManifest`, [
+        { name: 'assetDbHash', kind: 'string' },
+        { name: 'lookupHash', kind: 'string' },
+        { name: 'schemaHash', kind: 'string' },
+        { name: 'dependencyHash', kind: 'string' },
+    ]);
+    lines.push('');
+    lines.push(`function stableCanonicalize${rootName}(value: unknown): unknown {`);
+    lines.push('  if (value === null || typeof value !== "object") {');
+    lines.push('    return value;');
+    lines.push('  }');
+    lines.push('  if (Array.isArray(value)) {');
+    lines.push(`    return value.map((item) => stableCanonicalize${rootName}(item));`);
+    lines.push('  }');
+    lines.push('  const record = value as Record<string, unknown>;');
+    lines.push('  const output: Record<string, unknown> = {};');
+    lines.push(`  for (const key of Object.keys(record).sort(compare${rootName}Strings)) {`);
+    lines.push(`    output[key] = stableCanonicalize${rootName}(record[key]);`);
+    lines.push('  }');
+    lines.push('  return output;');
+    lines.push('}');
+    lines.push('');
+    lines.push(`function assert${rootName}Record(value: unknown, label: string): Record<string, unknown> {`);
+    lines.push('  if (value === null || typeof value !== "object" || Array.isArray(value)) {');
+    lines.push('    throw new Error(`${label} must be an object`);');
+    lines.push('  }');
+    lines.push('  return value as Record<string, unknown>;');
+    lines.push('}');
+    lines.push('');
+    lines.push(`function assert${rootName}ExactKeys(record: Record<string, unknown>, label: string, expectedKeys: readonly string[]): void {`);
+    lines.push(`  const actual = Object.keys(record).sort(compare${rootName}Strings);`);
+    lines.push(`  const expected = [...expectedKeys].sort(compare${rootName}Strings);`);
+    lines.push('  if (actual.length !== expected.length) {');
+    lines.push('    throw new Error(`${label} has ${actual.length} fields, expected ${expected.length}`);');
+    lines.push('  }');
+    lines.push('  for (let index = 0; index < expected.length; index += 1) {');
+    lines.push('    if (actual[index] !== expected[index]) {');
+    lines.push('      throw new Error(`${label} field mismatch at ${index}: expected ${expected[index]}, actual ${actual[index]}`);');
+    lines.push('    }');
+    lines.push('  }');
+    lines.push('}');
+    lines.push('');
+    lines.push(`function read${rootName}Boolean(value: unknown, label: string): boolean {`);
+    lines.push('  if (typeof value !== "boolean") {');
+    lines.push('    throw new Error(`${label} must be boolean`);');
+    lines.push('  }');
+    lines.push('  return value;');
+    lines.push('}');
+    lines.push('');
+    lines.push(`function read${rootName}String(value: unknown, label: string): string {`);
+    lines.push('  if (typeof value !== "string") {');
+    lines.push('    throw new Error(`${label} must be string`);');
+    lines.push('  }');
+    lines.push('  return value;');
+    lines.push('}');
+    lines.push('');
+    lines.push(`function read${rootName}Integer(value: unknown, label: string): number {`);
+    lines.push('  if (typeof value !== "number" || !Number.isInteger(value)) {');
+    lines.push('    throw new Error(`${label} must be integer`);');
+    lines.push('  }');
+    lines.push('  return value;');
+    lines.push('}');
+    lines.push('');
+    lines.push(`function assert${rootName}IntegerRange(value: number, label: string, min: number | undefined, max: number | undefined): number {`);
+    lines.push('  if (min !== undefined && value < min) {');
+    lines.push('    throw new Error(`${label} must be >= ${min}`);');
+    lines.push('  }');
+    lines.push('  if (max !== undefined && value > max) {');
+    lines.push('    throw new Error(`${label} must be <= ${max}`);');
+    lines.push('  }');
+    lines.push('  return value;');
+    lines.push('}');
+    lines.push('');
+    lines.push(`function read${rootName}Array<T>(value: unknown, label: string, readItem: (item: unknown, itemLabel: string) => T): readonly T[] {`);
+    lines.push('  if (!Array.isArray(value)) {');
+    lines.push('    throw new Error(`${label} must be array`);');
+    lines.push('  }');
+    lines.push('  return value.map((item, index) => readItem(item, `${label}[${index}]`));');
+    lines.push('}');
+    lines.push('');
+    lines.push(`function compare${rootName}Strings(left: string, right: string): number {`);
+    lines.push('  if (left < right) return -1;');
+    lines.push('  if (left > right) return 1;');
+    lines.push('  return 0;');
+    lines.push('}');
+    return `${lines.join('\n')}\n`;
+}
+function createDeterministicDescriptorBinarySchema(descriptor, options = {}) {
+    const validated = (0, schema_js_1.defineSyncplayGame)(descriptor);
+    const rootName = schemaRootName(options.rootName, validated.deterministicVersion);
+    const declarations = [
+        descriptorDeclaration('input', `${rootName}Input`, validated.input.fields),
+        descriptorDeclaration('component', `${rootName}State`, validated.state.fields),
+        ...(validated.commandChannels ?? []).map((channel) => commandDeclaration(rootName, channel)),
+        ...(validated.events ?? []).map((event) => eventDeclaration(rootName, event)),
+        ...(validated.assets ?? []).map((asset) => assetDeclaration(rootName, asset)),
+        ...(validated.config === undefined ? [] : [configDeclaration(rootName, validated.config)]),
+    ].sort(compareDslDeclarations);
+    const body = {
+        imports: [],
+        pragmas: {
+            artifact: validated.artifactId,
+            maxPlayers: String(validated.maxPlayers),
+            tickRate: String(validated.tickRate),
+        },
+        declarations,
+    };
+    return {
+        ...body,
+        schemaHash: (0, canonical_js_1.defaultChecksum)(body),
+    };
+}
+function generateSchemaBinarySource(descriptor, options = {}) {
+    const validated = (0, schema_js_1.defineSyncplayGame)(descriptor);
+    const rootName = schemaRootName(options.rootName, validated.deterministicVersion);
+    const importFrom = options.importFrom ?? '@series-inc/rundot-syncplay/browser';
+    const schema = createDeterministicDescriptorBinarySchema(validated, { rootName });
+    const declarationNames = schema.declarations.map((declaration) => declaration.name);
+    const lines = [];
+    lines.push('import {');
+    lines.push('  createDeterministicBinarySerializer,');
+    lines.push('  type DeterministicDslSchema,');
+    lines.push('  type DeterministicDslValue,');
+    lines.push(`} from ${JSON.stringify(importFrom)};`);
+    lines.push('');
+    lines.push(`export const ${rootName}BinarySchema = ${JSON.stringify(schema, null, 2)} as const satisfies DeterministicDslSchema;`);
+    lines.push('');
+    lines.push(`export const ${rootName}BinarySchemaHash = ${JSON.stringify(schema.schemaHash)} as const;`);
+    lines.push(`export const ${rootName}BinaryArtifactId = ${JSON.stringify(validated.artifactId)} as const;`);
+    lines.push(`export type ${rootName}BinaryDeclarationName = ${declarationNames.map((name) => JSON.stringify(name)).join(' | ')};`);
+    lines.push('');
+    lines.push(`const ${rootName}BinarySerializer = createDeterministicBinarySerializer(${rootName}BinarySchema);`);
+    lines.push('');
+    lines.push(`export function encode${rootName}Binary(declarationName: ${rootName}BinaryDeclarationName, value: Readonly<Record<string, DeterministicDslValue>>): Uint8Array {`);
+    lines.push(`  return ${rootName}BinarySerializer.encode(declarationName, value);`);
+    lines.push('}');
+    lines.push('');
+    lines.push(`export function decode${rootName}Binary(declarationName: ${rootName}BinaryDeclarationName, bytes: Uint8Array): Readonly<Record<string, DeterministicDslValue>> {`);
+    lines.push(`  return ${rootName}BinarySerializer.decode(declarationName, bytes);`);
+    lines.push('}');
+    return `${lines.join('\n')}\n`;
+}
+function proveSchemaBinaryRoundTrip(descriptor, options = {}) {
+    const schema = createDeterministicDescriptorBinarySchema(descriptor, options);
+    const serializer = (0, schema_dsl_binary_js_1.createDeterministicBinarySerializer)(schema);
+    const decoded = [];
+    let encodedBytes = 0;
+    for (const declaration of schema.declarations) {
+        const value = sampleBinaryValueForDeclaration(declaration);
+        const bytes = serializer.encode(declaration.name, value);
+        encodedBytes += bytes.byteLength;
+        decoded.push(serializer.decode(declaration.name, bytes));
+    }
+    return {
+        result: 'pass',
+        schemaHash: schema.schemaHash,
+        declarationCount: schema.declarations.length,
+        fieldCount: schema.declarations.reduce((sum, declaration) => sum + declaration.fields.length, 0),
+        encodedBytes,
+        roundTripChecksum: (0, canonical_js_1.defaultChecksum)(decoded),
+    };
+}
+function emitObjectValidator(lines, rootName, functionName, typeName, fields, maxPlayers) {
+    emitFixedObjectValidator(lines, rootName, functionName, typeName, fields.map((field) => ({
+        name: field.name,
+        kind: field.kind,
+        collection: field.collectionOrdering !== undefined,
+        min: field.kind === 'player-slot' ? field.min ?? 0 : field.min,
+        max: field.kind === 'player-slot' ? field.max ?? maxPlayers - 1 : field.max,
+    })));
+}
+function emitFixedObjectValidator(lines, rootName, functionName, typeName, fields) {
+    lines.push('');
+    lines.push(`function validate${functionName}(value: unknown): ${typeName} {`);
+    lines.push(`  const record = assert${rootName}Record(value, ${JSON.stringify(typeName)});`);
+    lines.push(`  assert${rootName}ExactKeys(record, ${JSON.stringify(typeName)}, [${fields.map((field) => JSON.stringify(field.name)).join(', ')}]);`);
+    lines.push('  return {');
+    for (const field of fields) {
+        lines.push(`    ${propertyName(field.name)}: ${field.collection === true ? collectionReadExpression(rootName, typeName, field) : scalarReadExpression(rootName, typeName, field)},`);
+    }
+    lines.push(`  } as ${typeName};`);
+    lines.push('}');
+}
+function scalarReadExpression(rootName, typeName, field) {
+    const reader = generatedValidatorReaderName(rootName, field.kind);
+    const label = JSON.stringify(`${typeName}.${field.name}`);
+    const readCall = `${reader}(record[${JSON.stringify(field.name)}], ${label})`;
+    return hasGeneratedRangeConstraint(field)
+        ? `${generatedIntegerRangeAssertName(rootName)}(${readCall}, ${label}, ${numberLiteral(field.min)}, ${numberLiteral(field.max)})`
+        : readCall;
+}
+function collectionReadExpression(rootName, typeName, field) {
+    const reader = generatedValidatorReaderName(rootName, field.kind);
+    if (!hasGeneratedRangeConstraint(field)) {
+        return `read${rootName}Array(record[${JSON.stringify(field.name)}], ${JSON.stringify(`${typeName}.${field.name}`)}, ${reader})`;
+    }
+    const rangeAssert = generatedIntegerRangeAssertName(rootName);
+    return `read${rootName}Array(record[${JSON.stringify(field.name)}], ${JSON.stringify(`${typeName}.${field.name}`)}, (item, itemLabel) => ${rangeAssert}(${reader}(item, itemLabel), itemLabel, ${numberLiteral(field.min)}, ${numberLiteral(field.max)}))`;
+}
+function hasGeneratedRangeConstraint(field) {
+    return (field.min !== undefined || field.max !== undefined)
+        && (field.kind === 'integer' || field.kind === 'fixed-q16' || field.kind === 'bitfield' || field.kind === 'player-slot');
+}
+function numberLiteral(value) {
+    return value === undefined ? 'undefined' : String(value);
+}
+function validatorSuffix(kind) {
+    switch (kind) {
+        case 'boolean':
+        case 'button':
+            return 'Boolean';
+        case 'string':
+        case 'asset-ref':
+            return 'String';
+        case 'integer':
+        case 'fixed-q16':
+        case 'bitfield':
+        case 'player-slot':
+            return 'Integer';
+        default:
+            return 'Never';
+    }
+}
+function generatedValidatorReaderName(rootName, kind) {
+    return generatedTypeScriptIdentifier(`read${rootName}${validatorSuffix(kind)}`, 'validator reader name');
+}
+function generatedIntegerRangeAssertName(rootName) {
+    return generatedTypeScriptIdentifier(`assert${rootName}IntegerRange`, 'integer range assertion name');
+}
+function literalForDefaultValue(field) {
+    if (typeof field.defaultValue === 'string') {
+        return JSON.stringify(field.defaultValue);
+    }
+    return String(field.defaultValue);
+}
+function fieldToType(field) {
+    const baseType = scalarFieldToType(field);
+    return field.collectionOrdering === undefined ? baseType : `readonly ${baseType}[]`;
+}
+function scalarFieldToType(field) {
+    switch (field.kind) {
+        case 'boolean':
+        case 'button':
+            return 'boolean';
+        case 'integer':
+        case 'fixed-q16':
+        case 'bitfield':
+        case 'player-slot':
+            return 'number';
+        case 'string':
+        case 'asset-ref':
+            return 'string';
+        default:
+            return 'never';
+    }
+}
+function descriptorDeclaration(kind, name, fields) {
+    return {
+        kind,
+        name,
+        fields: fields.map(descriptorBinaryField).sort(compareDslFields),
+        modifiers: [],
+    };
+}
+function commandDeclaration(rootName, channel) {
+    return descriptorDeclaration('command', `${rootName}${toPascalCase(channel.id)}Command`, channel.fields);
+}
+function eventDeclaration(rootName, event) {
+    return descriptorDeclaration('event', `${rootName}${toPascalCase(event.id.split('.').at(-1) ?? event.id)}Event`, event.payloadFields);
+}
+function assetDeclaration(rootName, asset) {
+    return descriptorDeclaration('struct', `${rootName}${toPascalCase(asset.id)}Asset`, asset.fields);
+}
+function configDeclaration(rootName, config) {
+    return descriptorDeclaration('global', `${rootName}${toPascalCase(config.id)}Config`, config.fields);
+}
+function descriptorBinaryField(field) {
+    const scalar = descriptorBinaryScalarKind(field);
+    return {
+        name: safeBinaryFieldName(field.name),
+        kind: field.collectionOrdering === undefined ? scalar : `${scalar}[]`,
+    };
+}
+function descriptorBinaryScalarKind(field) {
+    switch (field.kind) {
+        case 'boolean':
+            return 'bool';
+        case 'button':
+            return 'button';
+        case 'integer':
+        case 'bitfield':
+        case 'player-slot':
+            return 'int';
+        case 'fixed-q16':
+            return 'fixed';
+        case 'string':
+            return 'string';
+        case 'asset-ref':
+            return 'asset-ref';
+        default:
+            return 'int';
+    }
+}
+function safeBinaryFieldName(name) {
+    return toCamelCase(name);
+}
+function sampleBinaryValueForDeclaration(declaration) {
+    const value = {};
+    for (const field of declaration.fields) {
+        value[field.name] = sampleBinaryValueForField(field);
+    }
+    return value;
+}
+function sampleBinaryValueForField(field) {
+    if (field.kind.endsWith('[]')) {
+        return [sampleBinaryScalarValue(field.kind.slice(0, -2))];
+    }
+    return sampleBinaryScalarValue(field.kind);
+}
+function sampleBinaryScalarValue(kind) {
+    if (kind === 'bool' || kind === 'button') {
+        return true;
+    }
+    if (kind === 'string' || kind === 'asset-ref' || kind.startsWith('asset-ref:')) {
+        return 'sample.ref';
+    }
+    if (kind === 'fixed') {
+        return 1.5;
+    }
+    return 1;
+}
+function compareDslDeclarations(left, right) {
+    return compareStrings(left.kind, right.kind) || compareStrings(left.name, right.name);
+}
+function compareDslFields(left, right) {
+    return compareStrings(left.name, right.name);
+}
+function compareStrings(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}
+function toPascalCase(value) {
+    const words = value.split(/[^a-zA-Z0-9]+/).filter((word) => word.length > 0);
+    const name = words.map((word) => `${word[0].toUpperCase()}${word.slice(1)}`).join('');
+    return name.length === 0 ? 'DeterministicGame' : name;
+}
+function schemaRootName(rootName, deterministicVersion) {
+    const candidate = rootName ?? generatedRootName(deterministicVersion);
+    return generatedTypeScriptIdentifier(candidate, 'Schema rootName');
+}
+function generatedRootName(deterministicVersion) {
+    const candidate = toPascalCase(deterministicVersion.split('@')[0]);
+    return /^[A-Za-z_$]/.test(candidate) ? candidate : `Game${candidate}`;
+}
+function toCamelCase(value) {
+    const pascal = toPascalCase(value);
+    if (pascal.length === 0) {
+        return 'field';
+    }
+    return `${pascal[0].toLowerCase()}${pascal.slice(1)}`;
+}
+function propertyName(value) {
+    return typeScriptIdentifierPattern.test(value) ? value : JSON.stringify(value);
+}
+function isTypeScriptIdentifier(value) {
+    return typeScriptIdentifierPattern.test(value);
+}
+function generatedTypeScriptIdentifier(value, label) {
+    if (!isTypeScriptIdentifier(value)) {
+        throw new Error(`${label} must be a TypeScript identifier, received ${JSON.stringify(value)}`);
+    }
+    return value;
+}